fix: handle correctly non-shared instances in injector

Currently `$injector` can have non-shared instances by setting the third argument of the `register` method to false, i.e.:
```
$injector.register("myClass", MyClass, false);
```

However, in this case, the injector caches only the last created instance and this way it will not call the dispose method of all created instances. Fix this by caching all instances in an array and iterrate over them when disposing them.
This way we can have correct resolving of instances by name when constructor has non-injectable dependencies:
```
class A {
    constructor(private stringArg: string) { }
}
$injector.register("a", A, false);

// in another file:
$injector.resolve("a", { stringArg: "stringValue" }); //returns new instance;
$injector.resolve("a", { stringArg: "different stringValue" }); //returns new instance;
```

Author: rosen-vladimirov

lib/common/test/unit-tests/yok.ts

@@ -227,6 +227,30 @@ describe("yok", () => {
 			assert.isTrue(thing.disposed);
 		});
 
+		it("disposes all instances", () => {
+			const injector = new Yok();
+
+			function Thing(arg: string) { this.arg = arg; /* intentionally left blank */ }
+
+			Thing.prototype.dispose = function () {
+				this.disposed = true;
+			};
+
+			injector.register("thing", Thing, false);
+			const thing1 = injector.resolve("thing", { arg: "thing1"});
+			const thing2 = injector.resolve("thing", { arg: "thing2"});
+			const thing3 = injector.resolve("thing", { arg: "thing3"});
+
+			assert.equal(thing1.arg, "thing1");
+			assert.equal(thing2.arg, "thing2");
+			assert.equal(thing3.arg, "thing3");
+			injector.dispose();
+
+			assert.isTrue(thing1.disposed);
+			assert.isTrue(thing2.disposed);
+			assert.isTrue(thing3.disposed);
+		});
+
 	});
 
 	describe("classes", () => {

lib/common/yok.ts

@@ -40,7 +40,7 @@ export function register(...rest: any[]) {
 export interface IDependency {
 	require?: string;
 	resolver?: () => any;
-	instance?: any;
+	instances?: any[];
 	shared?: boolean;
 }
 
@@ -128,7 +128,7 @@ export class Yok implements IInjector {
 	}
 
 	private resolveInstance(name: string): any {
-		let classInstance = this.modules[name].instance;
+		let classInstance = _.first(this.modules[name].instances);
 		if (!classInstance) {
 			classInstance = this.resolve(name);
 		}
@@ -282,7 +282,12 @@ export class Yok implements IInjector {
 		if (_.isFunction(resolver)) {
 			dependency.resolver = resolver;
 		} else {
-			dependency.instance = resolver;
+			dependency.instances = dependency.instances || [];
+			if (shared) {
+				dependency.instances[0] = resolver;
+			} else {
+				dependency.instances.push(resolver);
+			}
 		}
 
 		this.modules[name] = dependency;
@@ -370,26 +375,32 @@ export class Yok implements IInjector {
 		pushIndent();
 
 		let dependency: IDependency;
+		let instance: any;
 		try {
 			dependency = this.resolveDependency(name);
 
 			if (!dependency) {
 				throw new Error("unable to resolve " + name);
 			}
 
-			if (!dependency.instance || !dependency.shared) {
+			if (!dependency.instances || !dependency.instances.length || !dependency.shared) {
 				if (!dependency.resolver) {
 					throw new Error("no resolver registered for " + name);
 				}
 
-				dependency.instance = this.resolveConstructor(dependency.resolver, ctorArguments);
+				dependency.instances = dependency.instances || [];
+
+				instance = this.resolveConstructor(dependency.resolver, ctorArguments);
+				dependency.instances.push(instance);
+			} else {
+				instance = _.first(dependency.instances);
 			}
 		} finally {
 			popIndent();
 			delete this.resolutionProgress[name];
 		}
 
-		return dependency.instance;
+		return instance;
 	}
 
 	private resolveDependency(name: string): IDependency {
@@ -424,10 +435,12 @@ export class Yok implements IInjector {
 
 	public dispose(): void {
 		Object.keys(this.modules).forEach((moduleName) => {
-			const instance = this.modules[moduleName].instance;
-			if (instance && instance.dispose && instance !== this) {
-				instance.dispose();
-			}
+			const instances = this.modules[moduleName].instances;
+			_.forEach(instances, instance => {
+				if (instance && instance.dispose && instance !== this) {
+					instance.dispose();
+				}
+			});
 		});
 	}
 }