ts-ioc-container 43.5.2 → 44.0.0

package/README.md

@@ -1394,28 +1394,18 @@ Sometimes you need to invoke methods after construct or dispose of class. This i
 ```typescript
 import {
   bindTo,
-  type constructor,
   Container,
   hook,
-  type IContainer,
-  type IInjector,
-  type InjectOptions,
-  MetadataInjector,
+  HookContext,
+  HookFn,
+  HooksRunner,
+  inject,
+  onConstruct,
   register,
   Registration as R,
-  SyncHooksRunner,
 } from 'ts-ioc-container';
 
-const onConstructHooksRunner = new SyncHooksRunner('onConstruct');
-class MyInjector implements IInjector {
-  private injector = new MetadataInjector();
-
-  resolve<T>(container: IContainer, value: constructor<T>, options: InjectOptions): T {
-    const instance = this.injector.resolve(container, value, options);
-    onConstructHooksRunner.execute(instance as object, { scope: container });
-    return instance;
-  }
-}
+const onConstructHooksRunner = new HooksRunner('onConstruct');
 
 @register(bindTo('logger'))
 class Logger {
@@ -1435,31 +1425,54 @@ class Logger {
 
 describe('onConstruct', function () {
   it('should make logger be ready on resolve', function () {
-    const container = new Container({ injector: new MyInjector() }).addRegistration(R.fromClass(Logger));
+    const container = new Container()
+      .addOnConstructHook((instance, scope) => {
+        onConstructHooksRunner.execute(instance as object, { scope });
+      })
+      .addRegistration(R.fromClass(Logger));
 
     const logger = container.resolve<Logger>('logger');
 
     expect(logger.isReady).toBe(true);
   });
+
+  it('should run methods and resolve arguments from container', function () {
+    const execute: HookFn = (ctx: HookContext) => {
+      ctx.invokeMethod({ args: ctx.resolveArgs() });
+    };
+
+    class Car {
+      private engine!: string;
+
+      @onConstruct(execute)
+      setEngine(@inject('engine') engine: string) {
+        this.engine = engine;
+      }
+
+      getEngine() {
+        return this.engine;
+      }
+    }
+
+    const root = new Container()
+      .addOnConstructHook((instance, scope) => {
+        onConstructHooksRunner.execute(instance as object, { scope });
+      })
+      .addRegistration(R.fromValue('bmw').bindTo('engine'));
+
+    const car = root.resolve(Car);
+
+    expect(car.getEngine()).toBe('bmw');
+  });
 });
 
 ```
 
 ### OnDispose
 ```typescript
-import {
-  bindTo,
-  Container,
-  hook,
-  inject,
-  register,
-  Registration as R,
-  select,
-  singleton,
-  SyncHooksRunner,
-} from 'ts-ioc-container';
+import { bindTo, Container, hook, HooksRunner, inject, register, Registration as R, select, singleton } from 'ts-ioc-container';
 
-const onDisposeHookRunner = new SyncHooksRunner('onDispose');
+const onDisposeHookRunner = new HooksRunner('onDispose');
 @register(bindTo('logsRepo'), singleton())
 class LogsRepo {
   savedLogs: string[] = [];
@@ -1515,9 +1528,9 @@ describe('onDispose', function () {
 ### Inject property
 
 ```typescript
-import { Container, hook, injectProp, Registration, SyncHooksRunner } from 'ts-ioc-container';
+import { Container, hook, HooksRunner, injectProp, Registration } from 'ts-ioc-container';
 
-const onInitHookRunner = new SyncHooksRunner('onInit');
+const onInitHookRunner = new HooksRunner('onInit');
 describe('inject property', () => {
   it('should inject property', () => {
     class App {
@@ -1526,9 +1539,9 @@ describe('inject property', () => {
     }
     const expected = 'Hello world!';
 
-    const container = new Container().addRegistration(Registration.fromValue(expected).bindToKey('greeting'));
-    const app = container.resolve(App);
-    onInitHookRunner.execute(app as object, { scope: container });
+    const scope = new Container().addRegistration(Registration.fromValue(expected).bindToKey('greeting'));
+    const app = scope.resolve(App);
+    onInitHookRunner.execute(app, { scope });
 
     expect(app.greeting).toBe(expected);
   });

package/cjm/container/AliasMap.js

@@ -3,18 +3,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AliasMap = void 0;
 class AliasMap {
     aliasToKeySet = new Map();
-    deleteAliasesByKey(key) {
+    getKeysByAlias(alias) {
+        return [...(this.aliasToKeySet.get(alias) ?? [])];
+    }
+    setAliasesByKey(key, aliases) {
+        // reset existing key's aliases
         for (const [alias, keySet] of this.aliasToKeySet) {
             keySet.delete(key);
             if (keySet.size === 0) {
                 this.aliasToKeySet.delete(alias);
             }
         }
-    }
-    getKeysByAlias(alias) {
-        return [...(this.aliasToKeySet.get(alias) ?? [])];
-    }
-    setAliasesByKey(key, aliases) {
         for (const alias of aliases) {
             const dependencyKeySet = this.aliasToKeySet.get(alias) ?? new Set();
             this.aliasToKeySet.set(alias, dependencyKeySet.add(key));

package/cjm/container/Container.js

@@ -10,12 +10,12 @@ const DependencyNotFoundError_1 = require("../errors/DependencyNotFoundError");
 class Container {
     isDisposed = false;
     parent;
-    scopes = new Set();
-    instances = new Set();
+    scopes = [];
+    instances = [];
+    registrations = [];
     tags;
     providers = new Map();
     aliases = new AliasMap_1.AliasMap();
-    registrations = new Set();
     injector;
     onConstructHookList = [];
     onDisposeHookList = [];
@@ -24,45 +24,21 @@ class Container {
         this.parent = options.parent ?? new EmptyContainer_1.EmptyContainer();
         this.tags = new Set(options.tags ?? []);
     }
-    addOnConstructHook(...hooks) {
-        this.onConstructHookList.push(...hooks);
-        return this;
-    }
-    addOnDisposeHook(...hooks) {
-        this.onDisposeHookList.push(...hooks);
-        return this;
-    }
-    addInstance(instance) {
-        this.instances.add(instance);
-        // Execute onConstruct hooks
-        for (const onConstruct of this.onConstructHookList) {
-            onConstruct(instance, this);
-        }
-    }
     register(key, provider, { aliases = [] } = {}) {
         this.validateContainer();
         this.providers.set(key, provider);
-        this.aliases.deleteAliasesByKey(key);
         this.aliases.setAliasesByKey(key, aliases);
         return this;
     }
-    addRegistration(registration) {
-        this.registrations.add(registration);
-        registration.applyTo(this);
-        return this;
-    }
-    getRegistrations() {
-        return [...this.parent.getRegistrations(), ...this.registrations];
-    }
-    resolve(keyOrAlias, { args = [], child = this, lazy } = {}) {
+    resolve(key, { args = [], child = this, lazy } = {}) {
         this.validateContainer();
-        if (utils_1.Is.constructor(keyOrAlias)) {
-            return (0, utils_1.toLazyIf)(() => this.injector.resolve(this, keyOrAlias, { args }), lazy);
+        if (utils_1.Is.constructor(key)) {
+            return this.injector.resolve(this, key, { args, lazy });
         }
-        const provider = this.providers.get(keyOrAlias);
+        const provider = this.providers.get(key);
         return provider?.hasAccess({ invocationScope: child, providerScope: this })
             ? provider.resolve(this, { args, lazy })
-            : this.parent.resolve(keyOrAlias, { args, child, lazy });
+            : this.parent.resolve(key, { args, child, lazy });
     }
     resolveByAlias(alias, { args = [], child = this, lazy, excludedKeys = [] } = {}) {
         this.validateContainer();
@@ -87,7 +63,7 @@ class Container {
     resolveOneByAlias(alias, { args = [], child = this, lazy } = {}) {
         this.validateContainer();
         const [key, ..._] = this.aliases.getKeysByAlias(alias);
-        const provider = key !== undefined ? this.findProviderByKeyOrFail(key) : undefined;
+        const provider = key ? this.findProviderByKeyOrFail(key) : undefined;
         return provider?.hasAccess({ invocationScope: child, providerScope: this })
             ? provider.resolve(this, { args, lazy })
             : this.parent.resolveOneByAlias(key, { args, child, lazy });
@@ -100,14 +76,56 @@ class Container {
         for (const registration of this.getRegistrations()) {
             registration.applyTo(scope);
         }
-        this.scopes.add(scope);
+        this.scopes.push(scope);
         return scope;
     }
+    dispose() {
+        this.validateContainer();
+        this.isDisposed = true;
+        // Execute onDispose hooks
+        while (this.onDisposeHookList.length) {
+            const onDispose = this.onDisposeHookList.shift();
+            onDispose(this);
+        }
+        // Detach from parent
+        this.parent.removeScope(this);
+        this.parent = new EmptyContainer_1.EmptyContainer();
+        // Reset the state
+        this.providers.clear();
+        this.aliases.destroy();
+        this.instances = [];
+        this.registrations = [];
+        // Clear hooks
+        this.onConstructHookList.splice(0, this.onConstructHookList.length);
+    }
+    addRegistration(registration) {
+        this.registrations.push(registration);
+        registration.applyTo(this);
+        return this;
+    }
+    getRegistrations() {
+        return [...this.parent.getRegistrations(), ...this.registrations];
+    }
+    addOnConstructHook(...hooks) {
+        this.onConstructHookList.push(...hooks);
+        return this;
+    }
+    addOnDisposeHook(...hooks) {
+        this.onDisposeHookList.push(...hooks);
+        return this;
+    }
+    addInstance(instance) {
+        this.instances.push(instance);
+        // Execute onConstruct hooks
+        for (const onConstruct of this.onConstructHookList) {
+            onConstruct(instance, this);
+        }
+    }
     getScopes() {
         return [...this.scopes];
     }
     removeScope(child) {
-        this.scopes.delete(child);
+        this.scopes = this.scopes.filter((s) => s !== child);
     }
     useModule(module) {
         module.applyTo(this);
@@ -116,31 +134,15 @@ class Container {
     getParent() {
         return this.parent;
     }
-    getInstances() {
-        return [...this.instances];
+    getInstances(cascade = false) {
+        if (!cascade) {
+            return [...this.instances];
+        }
+        return [...this.instances, ...this.scopes.flatMap((s) => s.getInstances(true))];
     }
     hasTag(tag) {
         return this.tags.has(tag);
     }
-    dispose() {
-        this.validateContainer();
-        this.isDisposed = true;
-        // Detach from parent
-        this.parent.removeScope(this);
-        this.parent = new EmptyContainer_1.EmptyContainer();
-        // Reset the state
-        this.providers.clear();
-        this.aliases.destroy();
-        this.instances.clear();
-        this.registrations.clear();
-        // Clear hooks
-        this.onConstructHookList.splice(0, this.onConstructHookList.length);
-        // Execute onDispose hooks
-        while (this.onDisposeHookList.length) {
-            const onDispose = this.onDisposeHookList.shift();
-            onDispose(this);
-        }
-    }
     validateContainer() {
         if (this.isDisposed) {
             throw new ContainerDisposedError_1.ContainerDisposedError('Container is already disposed');

package/cjm/hooks/{runner/SyncHooksRunner.js → HooksRunner.js}

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SyncHooksRunner = void 0;
-const HookContext_1 = require("../HookContext");
-const hook_1 = require("../hook");
-const UnexpectedHookResultError_1 = require("../../errors/UnexpectedHookResultError");
-class SyncHooksRunner {
+exports.HooksRunner = void 0;
+const HookContext_1 = require("./HookContext");
+const hook_1 = require("./hook");
+const UnexpectedHookResultError_1 = require("../errors/UnexpectedHookResultError");
+const utils_1 = require("../utils");
+class HooksRunner {
     key;
     constructor(key) {
         this.key = key;
@@ -24,5 +25,15 @@ class SyncHooksRunner {
             runMethodHooks(methodName, executions.map(hook_1.toHookFn));
         }
     }
+    async executeAsync(target, { scope, createContext = HookContext_1.createHookContext, predicate = () => true, }) {
+        const hooks = Array.from((0, hook_1.getHooks)(target, this.key).entries()).filter(([methodName]) => predicate(methodName));
+        const runMethodHooks = async (methodName, executions) => {
+            const context = createContext(target, scope, methodName);
+            for (const execute of executions) {
+                await (0, utils_1.promisify)(execute(context));
+            }
+        };
+        return Promise.all(hooks.map(([methodName, executions]) => runMethodHooks(methodName, executions.map(hook_1.toHookFn))));
+    }
 }
-exports.SyncHooksRunner = SyncHooksRunner;
+exports.HooksRunner = HooksRunner;

package/cjm/hooks/onConstruct.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.onConstruct = exports.onConstructHooksRunner = void 0;
 const hook_1 = require("./hook");
-const SyncHooksRunner_1 = require("./runner/SyncHooksRunner");
-exports.onConstructHooksRunner = new SyncHooksRunner_1.SyncHooksRunner('onConstruct');
+const HooksRunner_1 = require("./HooksRunner");
+exports.onConstructHooksRunner = new HooksRunner_1.HooksRunner('onConstruct');
 const onConstruct = (fn) => (0, hook_1.hook)('onConstruct', fn);
 exports.onConstruct = onConstruct;

package/cjm/hooks/onDispose.js

@@ -2,8 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.onDispose = exports.onDisposeHooksRunner = void 0;
 const hook_1 = require("./hook");
-const SyncHooksRunner_1 = require("./runner/SyncHooksRunner");
-exports.onDisposeHooksRunner = new SyncHooksRunner_1.SyncHooksRunner('onDispose');
-exports.onDispose = (0, hook_1.hook)('onDispose', (context) => {
-    context.invokeMethod({});
-});
+const HooksRunner_1 = require("./HooksRunner");
+exports.onDisposeHooksRunner = new HooksRunner_1.HooksRunner('onDispose');
+const onDispose = (fn) => (0, hook_1.hook)('onDispose', fn);
+exports.onDispose = onDispose;

package/cjm/index.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AliasUniqToken = exports.toAlias = exports.AliasToken = exports.InjectionToken = exports.getParameterMetadata = exports.getMethodMetadata = exports.setMethodMetadata = exports.setParameterMetadata = exports.getMetadata = exports.setMetadata = exports.SyncHooksRunner = exports.AsyncHooksRunner = exports.onDispose = exports.onDisposeHooksRunner = exports.onConstruct = exports.onConstructHooksRunner = exports.injectProp = exports.HookContext = exports.hasHooks = exports.hook = exports.getHooks = exports.UnexpectedHookResultError = exports.ContainerDisposedError = exports.MethodNotImplementedError = exports.DependencyMissingKeyError = exports.DependencyNotFoundError = exports.Registration = exports.bindTo = exports.register = exports.scope = exports.decorate = exports.MultiCache = exports.multiCache = exports.SingletonProvider = exports.singleton = exports.Provider = exports.resolveByArgs = exports.ProviderDecorator = exports.args = exports.argsFn = exports.lazy = exports.scopeAccess = exports.ProxyInjector = exports.SimpleInjector = exports.MetadataInjector = exports.resolveArgs = exports.inject = exports.EmptyContainer = exports.Container = exports.isDependencyKey = void 0;
-exports.Is = exports.select = exports.toToken = exports.InstanceListToken = exports.ConstantToken = exports.FunctionToken = exports.IDToken = exports.ClassToken = exports.toAliasUniq = void 0;
+exports.toAliasUniq = exports.AliasUniqToken = exports.toAlias = exports.AliasToken = exports.InjectionToken = exports.getParameterMetadata = exports.getMethodMetadata = exports.setMethodMetadata = exports.setParameterMetadata = exports.getMetadata = exports.setMetadata = exports.HooksRunner = exports.onDispose = exports.onDisposeHooksRunner = exports.onConstruct = exports.onConstructHooksRunner = exports.injectProp = exports.HookContext = exports.hasHooks = exports.hook = exports.getHooks = exports.UnexpectedHookResultError = exports.ContainerDisposedError = exports.MethodNotImplementedError = exports.DependencyMissingKeyError = exports.DependencyNotFoundError = exports.Registration = exports.bindTo = exports.register = exports.scope = exports.decorate = exports.MultiCache = exports.multiCache = exports.SingletonProvider = exports.singleton = exports.Provider = exports.resolveByArgs = exports.ProviderDecorator = exports.args = exports.argsFn = exports.lazy = exports.scopeAccess = exports.ProxyInjector = exports.SimpleInjector = exports.MetadataInjector = exports.resolveArgs = exports.inject = exports.EmptyContainer = exports.Container = exports.isDependencyKey = void 0;
+exports.Is = exports.select = exports.toToken = exports.InstanceListToken = exports.ConstantToken = exports.FunctionToken = exports.IDToken = exports.ClassToken = void 0;
 // Containers
 var IContainer_1 = require("./container/IContainer");
 Object.defineProperty(exports, "isDependencyKey", { enumerable: true, get: function () { return IContainer_1.isDependencyKey; } });
@@ -70,10 +70,9 @@ Object.defineProperty(exports, "onConstruct", { enumerable: true, get: function
 var onDispose_1 = require("./hooks/onDispose");
 Object.defineProperty(exports, "onDisposeHooksRunner", { enumerable: true, get: function () { return onDispose_1.onDisposeHooksRunner; } });
 Object.defineProperty(exports, "onDispose", { enumerable: true, get: function () { return onDispose_1.onDispose; } });
-var AsyncHooksRunner_1 = require("./hooks/runner/AsyncHooksRunner");
-Object.defineProperty(exports, "AsyncHooksRunner", { enumerable: true, get: function () { return AsyncHooksRunner_1.AsyncHooksRunner; } });
-var SyncHooksRunner_1 = require("./hooks/runner/SyncHooksRunner");
-Object.defineProperty(exports, "SyncHooksRunner", { enumerable: true, get: function () { return SyncHooksRunner_1.SyncHooksRunner; } });
+// Hooks runner
+var HooksRunner_1 = require("./hooks/HooksRunner");
+Object.defineProperty(exports, "HooksRunner", { enumerable: true, get: function () { return HooksRunner_1.HooksRunner; } });
 // Metadata
 var metadata_1 = require("./metadata");
 Object.defineProperty(exports, "setMetadata", { enumerable: true, get: function () { return metadata_1.setMetadata; } });

package/cjm/injector/IInjector.js

@@ -1,11 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Injector = void 0;
+const utils_1 = require("../utils");
 class Injector {
-    resolve(scope, Target, options) {
-        const instance = this.createInstance(scope, Target, options);
-        scope.addInstance(instance);
-        return instance;
+    resolve(scope, Target, { args, lazy } = {}) {
+        return (0, utils_1.toLazyIf)(() => {
+            const instance = this.createInstance(scope, Target, { args });
+            scope.addInstance(instance);
+            return instance;
+        }, lazy);
     }
 }
 exports.Injector = Injector;

package/cjm/provider/Provider.js

@@ -25,9 +25,10 @@ class Provider {
         return (0, utils_1.pipe)(...fns)(this);
     }
     resolve(container, { args = [], lazy } = {}) {
-        return (0, utils_1.toLazyIf)(() => this.resolveDependency(container, {
+        return this.resolveDependency(container, {
             args: [...this.argsFn(container, ...args), ...args],
-        }), lazy ?? this.isLazy);
+            lazy: lazy ?? this.isLazy,
+        });
     }
     setAccessPredicate(predicate) {
         this.checkAccess = predicate;

package/cjm/token/InstanceListToken.js

@@ -24,15 +24,7 @@ class InstanceListToken extends InjectionToken_1.InjectionToken {
         return this;
     }
     resolve(c) {
-        const result = new Set(c.getInstances().filter(this.predicate));
-        if (this.isCascade) {
-            for (const s of c.getScopes()) {
-                for (const instance of s.getInstances().filter(this.predicate)) {
-                    result.add(instance);
-                }
-            }
-        }
-        return [...result];
+        return c.getInstances(this.isCascade).filter(this.predicate);
     }
 }
 exports.InstanceListToken = InstanceListToken;

package/esm/container/AliasMap.js

@@ -1,17 +1,16 @@
 export class AliasMap {
     aliasToKeySet = new Map();
-    deleteAliasesByKey(key) {
+    getKeysByAlias(alias) {
+        return [...(this.aliasToKeySet.get(alias) ?? [])];
+    }
+    setAliasesByKey(key, aliases) {
+        // reset existing key's aliases
         for (const [alias, keySet] of this.aliasToKeySet) {
             keySet.delete(key);
             if (keySet.size === 0) {
                 this.aliasToKeySet.delete(alias);
             }
         }
-    }
-    getKeysByAlias(alias) {
-        return [...(this.aliasToKeySet.get(alias) ?? [])];
-    }
-    setAliasesByKey(key, aliases) {
         for (const alias of aliases) {
             const dependencyKeySet = this.aliasToKeySet.get(alias) ?? new Set();
             this.aliasToKeySet.set(alias, dependencyKeySet.add(key));

package/esm/container/Container.js

@@ -1,18 +1,18 @@
 import { EmptyContainer } from './EmptyContainer';
 import { ContainerDisposedError } from '../errors/ContainerDisposedError';
 import { MetadataInjector } from '../injector/MetadataInjector';
-import { Filter as F, Is, toLazyIf } from '../utils';
+import { Filter as F, Is } from '../utils';
 import { AliasMap } from './AliasMap';
 import { DependencyNotFoundError } from '../errors/DependencyNotFoundError';
 export class Container {
     isDisposed = false;
     parent;
-    scopes = new Set();
-    instances = new Set();
+    scopes = [];
+    instances = [];
+    registrations = [];
     tags;
     providers = new Map();
     aliases = new AliasMap();
-    registrations = new Set();
     injector;
     onConstructHookList = [];
     onDisposeHookList = [];
@@ -21,45 +21,21 @@ export class Container {
         this.parent = options.parent ?? new EmptyContainer();
         this.tags = new Set(options.tags ?? []);
     }
-    addOnConstructHook(...hooks) {
-        this.onConstructHookList.push(...hooks);
-        return this;
-    }
-    addOnDisposeHook(...hooks) {
-        this.onDisposeHookList.push(...hooks);
-        return this;
-    }
-    addInstance(instance) {
-        this.instances.add(instance);
-        // Execute onConstruct hooks
-        for (const onConstruct of this.onConstructHookList) {
-            onConstruct(instance, this);
-        }
-    }
     register(key, provider, { aliases = [] } = {}) {
         this.validateContainer();
         this.providers.set(key, provider);
-        this.aliases.deleteAliasesByKey(key);
         this.aliases.setAliasesByKey(key, aliases);
         return this;
     }
-    addRegistration(registration) {
-        this.registrations.add(registration);
-        registration.applyTo(this);
-        return this;
-    }
-    getRegistrations() {
-        return [...this.parent.getRegistrations(), ...this.registrations];
-    }
-    resolve(keyOrAlias, { args = [], child = this, lazy } = {}) {
+    resolve(key, { args = [], child = this, lazy } = {}) {
         this.validateContainer();
-        if (Is.constructor(keyOrAlias)) {
-            return toLazyIf(() => this.injector.resolve(this, keyOrAlias, { args }), lazy);
+        if (Is.constructor(key)) {
+            return this.injector.resolve(this, key, { args, lazy });
         }
-        const provider = this.providers.get(keyOrAlias);
+        const provider = this.providers.get(key);
         return provider?.hasAccess({ invocationScope: child, providerScope: this })
             ? provider.resolve(this, { args, lazy })
-            : this.parent.resolve(keyOrAlias, { args, child, lazy });
+            : this.parent.resolve(key, { args, child, lazy });
     }
     resolveByAlias(alias, { args = [], child = this, lazy, excludedKeys = [] } = {}) {
         this.validateContainer();
@@ -84,7 +60,7 @@ export class Container {
     resolveOneByAlias(alias, { args = [], child = this, lazy } = {}) {
         this.validateContainer();
         const [key, ..._] = this.aliases.getKeysByAlias(alias);
-        const provider = key !== undefined ? this.findProviderByKeyOrFail(key) : undefined;
+        const provider = key ? this.findProviderByKeyOrFail(key) : undefined;
         return provider?.hasAccess({ invocationScope: child, providerScope: this })
             ? provider.resolve(this, { args, lazy })
             : this.parent.resolveOneByAlias(key, { args, child, lazy });
@@ -97,14 +73,56 @@ export class Container {
         for (const registration of this.getRegistrations()) {
             registration.applyTo(scope);
         }
-        this.scopes.add(scope);
+        this.scopes.push(scope);
         return scope;
     }
+    dispose() {
+        this.validateContainer();
+        this.isDisposed = true;
+        // Execute onDispose hooks
+        while (this.onDisposeHookList.length) {
+            const onDispose = this.onDisposeHookList.shift();
+            onDispose(this);
+        }
+        // Detach from parent
+        this.parent.removeScope(this);
+        this.parent = new EmptyContainer();
+        // Reset the state
+        this.providers.clear();
+        this.aliases.destroy();
+        this.instances = [];
+        this.registrations = [];
+        // Clear hooks
+        this.onConstructHookList.splice(0, this.onConstructHookList.length);
+    }
+    addRegistration(registration) {
+        this.registrations.push(registration);
+        registration.applyTo(this);
+        return this;
+    }
+    getRegistrations() {
+        return [...this.parent.getRegistrations(), ...this.registrations];
+    }
+    addOnConstructHook(...hooks) {
+        this.onConstructHookList.push(...hooks);
+        return this;
+    }
+    addOnDisposeHook(...hooks) {
+        this.onDisposeHookList.push(...hooks);
+        return this;
+    }
+    addInstance(instance) {
+        this.instances.push(instance);
+        // Execute onConstruct hooks
+        for (const onConstruct of this.onConstructHookList) {
+            onConstruct(instance, this);
+        }
+    }
     getScopes() {
         return [...this.scopes];
     }
     removeScope(child) {
-        this.scopes.delete(child);
+        this.scopes = this.scopes.filter((s) => s !== child);
     }
     useModule(module) {
         module.applyTo(this);
@@ -113,31 +131,15 @@ export class Container {
     getParent() {
         return this.parent;
     }
-    getInstances() {
-        return [...this.instances];
+    getInstances(cascade = false) {
+        if (!cascade) {
+            return [...this.instances];
+        }
+        return [...this.instances, ...this.scopes.flatMap((s) => s.getInstances(true))];
     }
     hasTag(tag) {
         return this.tags.has(tag);
     }
-    dispose() {
-        this.validateContainer();
-        this.isDisposed = true;
-        // Detach from parent
-        this.parent.removeScope(this);
-        this.parent = new EmptyContainer();
-        // Reset the state
-        this.providers.clear();
-        this.aliases.destroy();
-        this.instances.clear();
-        this.registrations.clear();
-        // Clear hooks
-        this.onConstructHookList.splice(0, this.onConstructHookList.length);
-        // Execute onDispose hooks
-        while (this.onDisposeHookList.length) {
-            const onDispose = this.onDisposeHookList.shift();
-            onDispose(this);
-        }
-    }
     validateContainer() {
         if (this.isDisposed) {
             throw new ContainerDisposedError('Container is already disposed');

package/esm/hooks/{runner/SyncHooksRunner.js → HooksRunner.js}

@@ -1,7 +1,8 @@
-import { createHookContext } from '../HookContext';
-import { getHooks, toHookFn } from '../hook';
-import { UnexpectedHookResultError } from '../../errors/UnexpectedHookResultError';
-export class SyncHooksRunner {
+import { createHookContext } from './HookContext';
+import { getHooks, toHookFn } from './hook';
+import { UnexpectedHookResultError } from '../errors/UnexpectedHookResultError';
+import { promisify } from '../utils';
+export class HooksRunner {
     key;
     constructor(key) {
         this.key = key;
@@ -21,4 +22,14 @@ export class SyncHooksRunner {
             runMethodHooks(methodName, executions.map(toHookFn));
         }
     }
+    async executeAsync(target, { scope, createContext = createHookContext, predicate = () => true, }) {
+        const hooks = Array.from(getHooks(target, this.key).entries()).filter(([methodName]) => predicate(methodName));
+        const runMethodHooks = async (methodName, executions) => {
+            const context = createContext(target, scope, methodName);
+            for (const execute of executions) {
+                await promisify(execute(context));
+            }
+        };
+        return Promise.all(hooks.map(([methodName, executions]) => runMethodHooks(methodName, executions.map(toHookFn))));
+    }
 }

package/esm/hooks/onConstruct.js

@@ -1,4 +1,4 @@
 import { hook } from './hook';
-import { SyncHooksRunner } from './runner/SyncHooksRunner';
-export const onConstructHooksRunner = new SyncHooksRunner('onConstruct');
+import { HooksRunner } from './HooksRunner';
+export const onConstructHooksRunner = new HooksRunner('onConstruct');
 export const onConstruct = (fn) => hook('onConstruct', fn);

package/esm/hooks/onDispose.js

@@ -1,6 +1,4 @@
 import { hook } from './hook';
-import { SyncHooksRunner } from './runner/SyncHooksRunner';
-export const onDisposeHooksRunner = new SyncHooksRunner('onDispose');
-export const onDispose = hook('onDispose', (context) => {
-    context.invokeMethod({});
-});
+import { HooksRunner } from './HooksRunner';
+export const onDisposeHooksRunner = new HooksRunner('onDispose');
+export const onDispose = (fn) => hook('onDispose', fn);

package/esm/index.js

@@ -28,8 +28,8 @@ export { HookContext } from './hooks/HookContext';
 export { injectProp } from './hooks/injectProp';
 export { onConstructHooksRunner, onConstruct } from './hooks/onConstruct';
 export { onDisposeHooksRunner, onDispose } from './hooks/onDispose';
-export { AsyncHooksRunner } from './hooks/runner/AsyncHooksRunner';
-export { SyncHooksRunner } from './hooks/runner/SyncHooksRunner';
+// Hooks runner
+export { HooksRunner } from './hooks/HooksRunner';
 // Metadata
 export { setMetadata, getMetadata, setParameterMetadata, setMethodMetadata, getMethodMetadata, getParameterMetadata, } from './metadata';
 // InjectionToken

package/esm/injector/IInjector.js

@@ -1,7 +1,10 @@
+import { toLazyIf } from '../utils';
 export class Injector {
-    resolve(scope, Target, options) {
-        const instance = this.createInstance(scope, Target, options);
-        scope.addInstance(instance);
-        return instance;
+    resolve(scope, Target, { args, lazy } = {}) {
+        return toLazyIf(() => {
+            const instance = this.createInstance(scope, Target, { args });
+            scope.addInstance(instance);
+            return instance;
+        }, lazy);
     }
 }

package/esm/provider/Provider.js

@@ -1,4 +1,4 @@
-import { pipe, toLazyIf } from '../utils';
+import { pipe } from '../utils';
 import { isProviderPipe } from './ProviderPipe';
 export class Provider {
     resolveDependency;
@@ -22,9 +22,10 @@ export class Provider {
         return pipe(...fns)(this);
     }
     resolve(container, { args = [], lazy } = {}) {
-        return toLazyIf(() => this.resolveDependency(container, {
+        return this.resolveDependency(container, {
             args: [...this.argsFn(container, ...args), ...args],
-        }), lazy ?? this.isLazy);
+            lazy: lazy ?? this.isLazy,
+        });
     }
     setAccessPredicate(predicate) {
         this.checkAccess = predicate;

package/esm/token/InstanceListToken.js

@@ -21,14 +21,6 @@ export class InstanceListToken extends InjectionToken {
         return this;
     }
     resolve(c) {
-        const result = new Set(c.getInstances().filter(this.predicate));
-        if (this.isCascade) {
-            for (const s of c.getScopes()) {
-                for (const instance of s.getInstances().filter(this.predicate)) {
-                    result.add(instance);
-                }
-            }
-        }
-        return [...result];
+        return c.getInstances(this.isCascade).filter(this.predicate);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-ioc-container",
-  "version": "43.5.2",
+  "version": "44.0.0",
   "description": "Typescript IoC container",
   "publishConfig": {
     "access": "public",

package/typings/container/AliasMap.d.ts

@@ -2,7 +2,6 @@ import { type DependencyKey } from './IContainer';
 export type Alias = DependencyKey;
 export declare class AliasMap {
     private readonly aliasToKeySet;
-    deleteAliasesByKey(key: DependencyKey): void;
     getKeysByAlias(alias: DependencyKey): DependencyKey[];
     setAliasesByKey(key: DependencyKey, aliases: DependencyKey[]): void;
     destroy(): void;

package/typings/container/Container.d.ts

@@ -8,12 +8,12 @@ import { constructor, Instance } from '../types';
 export declare class Container implements IContainer {
     isDisposed: boolean;
     private parent;
-    private readonly scopes;
-    private readonly instances;
+    private scopes;
+    private instances;
+    private registrations;
     private readonly tags;
     private readonly providers;
     private readonly aliases;
-    private readonly registrations;
     private readonly injector;
     private readonly onConstructHookList;
     private readonly onDisposeHookList;
@@ -22,23 +22,23 @@ export declare class Container implements IContainer {
         parent?: IContainer;
         tags?: Tag[];
     });
-    addOnConstructHook(...hooks: OnConstructHook[]): this;
-    addOnDisposeHook(...hooks: OnDisposeHook[]): this;
-    addInstance(instance: Instance): void;
     register(key: DependencyKey, provider: IProvider, { aliases }?: RegisterOptions): this;
-    addRegistration(registration: IRegistration): this;
-    getRegistrations(): IRegistration[];
-    resolve<T>(keyOrAlias: constructor<T> | DependencyKey, { args, child, lazy }?: ResolveOneOptions): T;
+    resolve<T>(key: constructor<T> | DependencyKey, { args, child, lazy }?: ResolveOneOptions): T;
     resolveByAlias<T>(alias: DependencyKey, { args, child, lazy, excludedKeys }?: ResolveManyOptions): T[];
     resolveOneByAlias<T>(alias: DependencyKey, { args, child, lazy }?: ResolveOneOptions): T;
     createScope({ tags }?: CreateScopeOptions): IContainer;
+    dispose(): void;
+    addRegistration(registration: IRegistration): this;
+    getRegistrations(): IRegistration[];
+    addOnConstructHook(...hooks: OnConstructHook[]): this;
+    addOnDisposeHook(...hooks: OnDisposeHook[]): this;
+    addInstance(instance: Instance): void;
     getScopes(): IContainer[];
     removeScope(child: IContainer): void;
     useModule(module: IContainerModule): this;
     getParent(): IContainer;
-    getInstances(): Instance<unknown>[];
+    getInstances(cascade?: boolean): Instance<unknown>[];
     hasTag(tag: Tag): boolean;
-    dispose(): void;
     private validateContainer;
     private findProviderByKeyOrFail;
 }

package/typings/container/IContainer.d.ts

@@ -41,7 +41,7 @@ export interface IContainer extends Tagged {
     removeScope(child: IContainer): void;
     useModule(module: IContainerModule): this;
     getParent(): IContainer | undefined;
-    getInstances(): Instance[];
+    getInstances(cascade?: boolean): Instance[];
     dispose(): void;
     addInstance(instance: Instance): void;
 }

package/typings/hooks/HooksRunner.d.ts

@@ -0,0 +1,17 @@
+import { createHookContext, type CreateHookContext } from './HookContext';
+import type { IContainer } from '../container/IContainer';
+export type HooksRunnerContext = {
+    scope: IContainer;
+    createContext?: CreateHookContext;
+    predicate?: (methodName: string) => boolean;
+};
+export declare class HooksRunner {
+    private readonly key;
+    constructor(key: string | symbol);
+    execute(target: object, { scope, createContext, predicate }: HooksRunnerContext): void;
+    executeAsync(target: object, { scope, createContext, predicate, }: {
+        scope: IContainer;
+        createContext?: typeof createHookContext;
+        predicate?: (methodName: string) => boolean;
+    }): Promise<void[]>;
+}

package/typings/hooks/hook.d.ts

@@ -6,8 +6,8 @@ export type HookFn<T extends IHookContext = IHookContext> = (context: T) => void
 export interface HookClass<T extends IHookContext = IHookContext> {
     execute(context: Omit<T, 'scope'>): void | Promise<void>;
 }
-export declare const toHookFn: <C extends IHookContext>(execute: HookFn<C> | constructor<HookClass<C>>) => HookFn<C>;
 type HooksOfClass = Map<string, (HookFn | constructor<HookClass>)[]>;
+export declare const toHookFn: <C extends IHookContext>(execute: HookFn<C> | constructor<HookClass<C>>) => HookFn<C>;
 export declare function getHooks(target: object, key: string | symbol): HooksOfClass;
 export declare function hasHooks(target: object, key: string | symbol): boolean;
 export declare const hook: (key: string | symbol, ...fns: (HookFn | constructor<HookClass>)[]) => (target: object, propertyKey: string | symbol) => void;

package/typings/hooks/onConstruct.d.ts

@@ -1,7 +1,7 @@
-import { HookFn } from './hook';
-import { SyncHooksRunner } from './runner/SyncHooksRunner';
+import { HookClass, HookFn } from './hook';
 import type { IContainer } from '../container/IContainer';
-import { Instance } from '../types';
-export declare const onConstructHooksRunner: SyncHooksRunner;
-export declare const onConstruct: (fn: HookFn) => (target: object, propertyKey: string | symbol) => void;
+import { constructor, Instance } from '../types';
+import { HooksRunner } from './HooksRunner';
+export declare const onConstructHooksRunner: HooksRunner;
+export declare const onConstruct: (fn: HookFn | constructor<HookClass>) => (target: object, propertyKey: string | symbol) => void;
 export type OnConstructHook = (instance: Instance, scope: IContainer) => void;

package/typings/hooks/onDispose.d.ts

@@ -1,5 +1,7 @@
-import { SyncHooksRunner } from './runner/SyncHooksRunner';
+import { HookClass, HookFn } from './hook';
 import type { IContainer } from '../container/IContainer';
-export declare const onDisposeHooksRunner: SyncHooksRunner;
-export declare const onDispose: (target: object, propertyKey: string | symbol) => void;
+import { constructor } from '../types';
+import { HooksRunner } from './HooksRunner';
+export declare const onDisposeHooksRunner: HooksRunner;
+export declare const onDispose: (fn: HookFn | constructor<HookClass>) => (target: object, propertyKey: string | symbol) => void;
 export type OnDisposeHook = (scope: IContainer) => void;

package/typings/index.d.ts

@@ -24,9 +24,7 @@ export { HookContext, type IHookContext } from './hooks/HookContext';
 export { injectProp } from './hooks/injectProp';
 export { onConstructHooksRunner, onConstruct } from './hooks/onConstruct';
 export { onDisposeHooksRunner, onDispose } from './hooks/onDispose';
-export { HooksRunnerContext } from './hooks/runner/HooksRunner';
-export { AsyncHooksRunner } from './hooks/runner/AsyncHooksRunner';
-export { SyncHooksRunner } from './hooks/runner/SyncHooksRunner';
+export { HooksRunnerContext, HooksRunner } from './hooks/HooksRunner';
 export { setMetadata, getMetadata, setParameterMetadata, setMethodMetadata, getMethodMetadata, getParameterMetadata, } from './metadata';
 export { InjectionToken } from './token/InjectionToken';
 export { AliasToken, toAlias } from './token/AliasToken';
@@ -40,5 +38,4 @@ export { toToken } from './token/toToken';
 export { select } from './select';
 export { Is } from './utils';
 export { InjectFn } from './hooks/hook';
-export { Instance } from './types';
-export { constructor } from './types';
+export { Instance, constructor } from './types';

package/typings/injector/IInjector.d.ts

@@ -1,17 +1,18 @@
 import { type IContainer, ResolveOneOptions } from '../container/IContainer';
 import { constructor } from '../types';
+import { ProviderOptions } from '../provider/IProvider';
 type WithArgs = {
     args: unknown[];
 };
 export type InjectOptions = Partial<WithArgs>;
 export interface IInjector {
-    resolve<T>(container: IContainer, value: constructor<T>, options?: InjectOptions): T;
+    resolve<T>(container: IContainer, value: constructor<T>, options?: ProviderOptions): T;
 }
 export interface IInjectFnResolver<T> {
     resolve(s: IContainer, options?: ResolveOneOptions): T;
 }
 export declare abstract class Injector {
-    resolve<T>(scope: IContainer, Target: constructor<T>, options?: InjectOptions): T;
+    resolve<T>(scope: IContainer, Target: constructor<T>, { args, lazy }?: ProviderOptions): T;
     protected abstract createInstance<T>(scope: IContainer, Target: constructor<T>, options?: InjectOptions): T;
 }
 export {};

package/typings/provider/IProvider.d.ts

@@ -6,7 +6,7 @@ export type WithLazy = {
     lazy: boolean;
 };
 export type ProviderOptions = InjectOptions & Partial<WithLazy>;
-export type ResolveDependency<T = unknown> = (container: IContainer, options: InjectOptions) => T;
+export type ResolveDependency<T = unknown> = (container: IContainer, options: ProviderOptions) => T;
 export type ScopeAccessOptions = {
     invocationScope: Tagged;
     providerScope: Tagged;

package/cjm/hooks/runner/AsyncHooksRunner.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AsyncHooksRunner = void 0;
-const HookContext_1 = require("../HookContext");
-const hook_1 = require("../hook");
-const utils_1 = require("../../utils");
-class AsyncHooksRunner {
-    key;
-    constructor(key) {
-        this.key = key;
-    }
-    async execute(target, { scope, createContext = HookContext_1.createHookContext, predicate = () => true, }) {
-        const hooks = Array.from((0, hook_1.getHooks)(target, this.key).entries()).filter(([methodName]) => predicate(methodName));
-        const runMethodHooks = async (methodName, executions) => {
-            const context = createContext(target, scope, methodName);
-            for (const execute of executions) {
-                await (0, utils_1.promisify)(execute(context));
-            }
-        };
-        return Promise.all(hooks.map(([methodName, executions]) => runMethodHooks(methodName, executions.map(hook_1.toHookFn))));
-    }
-}
-exports.AsyncHooksRunner = AsyncHooksRunner;

package/cjm/hooks/runner/HooksRunner.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/esm/hooks/runner/AsyncHooksRunner.js

@@ -1,19 +0,0 @@
-import { createHookContext } from '../HookContext';
-import { getHooks, toHookFn } from '../hook';
-import { promisify } from '../../utils';
-export class AsyncHooksRunner {
-    key;
-    constructor(key) {
-        this.key = key;
-    }
-    async execute(target, { scope, createContext = createHookContext, predicate = () => true, }) {
-        const hooks = Array.from(getHooks(target, this.key).entries()).filter(([methodName]) => predicate(methodName));
-        const runMethodHooks = async (methodName, executions) => {
-            const context = createContext(target, scope, methodName);
-            for (const execute of executions) {
-                await promisify(execute(context));
-            }
-        };
-        return Promise.all(hooks.map(([methodName, executions]) => runMethodHooks(methodName, executions.map(toHookFn))));
-    }
-}

package/esm/hooks/runner/HooksRunner.js

@@ -1 +0,0 @@
-export {};

package/typings/hooks/runner/AsyncHooksRunner.d.ts

@@ -1,11 +0,0 @@
-import { createHookContext } from '../HookContext';
-import type { IContainer } from '../../container/IContainer';
-export declare class AsyncHooksRunner {
-    private readonly key;
-    constructor(key: string | symbol);
-    execute(target: object, { scope, createContext, predicate, }: {
-        scope: IContainer;
-        createContext?: typeof createHookContext;
-        predicate?: (methodName: string) => boolean;
-    }): Promise<void[]>;
-}

package/typings/hooks/runner/HooksRunner.d.ts

@@ -1,7 +0,0 @@
-import { type CreateHookContext } from '../HookContext';
-import type { IContainer } from '../../container/IContainer';
-export type HooksRunnerContext = {
-    scope: IContainer;
-    createContext?: CreateHookContext;
-    predicate?: (methodName: string) => boolean;
-};

package/typings/hooks/runner/SyncHooksRunner.d.ts

@@ -1,6 +0,0 @@
-import { HooksRunnerContext } from './HooksRunner';
-export declare class SyncHooksRunner {
-    private readonly key;
-    constructor(key: string | symbol);
-    execute(target: object, { scope, createContext, predicate }: HooksRunnerContext): void;
-}