ts-ioc-container 63.0.0 → 65.0.0

package/cjm/hooks/SequentialSync.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SequentialSync = void 0;
+const HookExecutionStrategy_1 = require("./HookExecutionStrategy");
+class SequentialSync extends HookExecutionStrategy_1.HookExecutionStrategy {
+    processHooks(members) {
+        for (const { hooks, context } of members) {
+            for (const hook of hooks) {
+                hook(context);
+            }
+        }
+    }
+}
+exports.SequentialSync = SequentialSync;

package/cjm/hooks/onConstruct.js

@@ -1,19 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OnConstructModule = exports.onConstruct = exports.onConstructHooksRunner = void 0;
+exports.OnConstructModule = exports.onConstruct = void 0;
 const hook_1 = require("./hook");
-const HooksRunner_1 = require("./HooksRunner");
-exports.onConstructHooksRunner = new HooksRunner_1.HooksRunner('onConstruct');
 const onConstruct = (...fns) => (0, hook_1.hook)('onConstruct', (0, hook_1.prependHooks)(...fns));
 exports.onConstruct = onConstruct;
 class OnConstructModule {
-    onException;
-    constructor(onException) {
-        this.onException = onException;
+    strategy;
+    constructor(strategy) {
+        this.strategy = strategy;
     }
-    applyTo(injector) {
-        injector.onConstructed((instance, scope) => {
-            (0, HooksRunner_1.runHooks)(exports.onConstructHooksRunner, instance, scope, this.onException);
+    applyTo(container) {
+        container.getInjector().onConstructed((instance, scope) => {
+            this.strategy.execute(instance, { scope });
         });
     }
 }

package/cjm/hooks/onResolved.js

@@ -1,23 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolved = exports.OnResolvedModule = exports.onResolved = exports.onResolvedHooksRunner = void 0;
-const HooksRunner_1 = require("./HooksRunner");
+exports.resolved = exports.OnResolvedModule = exports.onResolved = void 0;
 const IRegistration_1 = require("../registration/IRegistration");
-const resolveHooks_1 = require("./resolveHooks");
-exports.onResolvedHooksRunner = new HooksRunner_1.HooksRunner('onResolved');
-exports.onResolved = (0, resolveHooks_1.resolvedHook)('onResolved');
-const runHooks = (onException) => (0, resolveHooks_1.forEachResolvedObject)((0, resolveHooks_1.executeHooks)(exports.onResolvedHooksRunner, onException));
+const basic_1 = require("../utils/basic");
+const hook_1 = require("./hook");
+const onResolved = (...hooks) => (0, hook_1.hook)('onResolved', (0, hook_1.prependHooks)(...hooks));
+exports.onResolved = onResolved;
+const runHooks = (strategy) => (dependency, scope) => {
+    if (basic_1.Is.object(dependency)) {
+        strategy.execute(dependency, { scope });
+    }
+};
 class OnResolvedModule {
     runHooks;
-    constructor(onException) {
-        this.runHooks = runHooks(onException);
+    constructor(strategy) {
+        this.runHooks = runHooks(strategy);
     }
     applyTo(container) {
-        container.onRegistered((provider) => {
+        container.registered.subscribe((provider) => {
             provider.onResolved(this.runHooks);
         });
     }
 }
 exports.OnResolvedModule = OnResolvedModule;
-const resolved = (onException) => (0, IRegistration_1.registerPipe)((p) => p.onResolved(runHooks(onException)));
+const resolved = (strategy) => (0, IRegistration_1.registerPipe)((p) => p.onResolved(runHooks(strategy)));
 exports.resolved = resolved;

package/cjm/hooks/onScopeDisposed.js

@@ -1,20 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OnDisposeModule = exports.onScopeDisposed = exports.onScopeDisposedHooksRunner = void 0;
+exports.OnDisposeModule = exports.onScopeDisposed = void 0;
 const hook_1 = require("./hook");
-const HooksRunner_1 = require("./HooksRunner");
-exports.onScopeDisposedHooksRunner = new HooksRunner_1.HooksRunner('onScopeDisposed');
 const onScopeDisposed = (...fns) => (0, hook_1.hook)('onScopeDisposed', (0, hook_1.prependHooks)(...fns));
 exports.onScopeDisposed = onScopeDisposed;
 class OnDisposeModule {
-    onException;
-    constructor(onException) {
-        this.onException = onException;
+    strategy;
+    constructor(strategy) {
+        this.strategy = strategy;
     }
     applyTo(container) {
-        container.onScopeDisposed((scope) => {
+        container.scopeDisposed.subscribe((scope) => {
             for (const instance of scope.getInstances()) {
-                (0, HooksRunner_1.runHooks)(exports.onScopeDisposedHooksRunner, instance, scope, this.onException);
+                this.strategy.execute(instance, { scope });
             }
         });
     }

package/cjm/hooks/resolveHooks.js

@@ -1,14 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.executeHooks = exports.forEachResolvedObject = exports.resolvedHook = exports.oncePerInstance = exports.invokeMethod = void 0;
-const HooksRunner_1 = require("./HooksRunner");
+exports.oncePerInstance = void 0;
 const hook_1 = require("./hook");
-const basic_1 = require("../utils/basic");
-const invokeMethod = (context) => {
-    context.invokeMethod();
-};
-exports.invokeMethod = invokeMethod;
-const toHooks = (hooks) => (hooks.length > 0 ? hooks : [exports.invokeMethod]);
 const oncePerInstance = (execute) => {
     const invokedInstances = new WeakSet();
     return (context) => {
@@ -20,13 +13,3 @@ const oncePerInstance = (execute) => {
     };
 };
 exports.oncePerInstance = oncePerInstance;
-const resolvedHook = (key) => (...hooks) => (0, hook_1.hook)(key, (0, hook_1.prependHooks)(...toHooks(hooks)));
-exports.resolvedHook = resolvedHook;
-const forEachResolvedObject = (run) => (dependency, scope) => {
-    if (basic_1.Is.object(dependency)) {
-        run(dependency, scope);
-    }
-};
-exports.forEachResolvedObject = forEachResolvedObject;
-const executeHooks = (runner, onException) => (dependency, scope) => (0, HooksRunner_1.runHooks)(runner, dependency, scope, onException);
-exports.executeHooks = executeHooks;

package/cjm/index.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createHookContext = exports.createHookContextFactory = exports.HookContext = exports.prepend = exports.append = exports.prependHooks = exports.appendHooks = exports.hasHooks = exports.hook = exports.getHooks = exports.UnsupportedTokenTypeError = exports.CannonSingletonApplyTwiceError = exports.ProviderDisposedError = exports.ContainerDisposedError = exports.MethodNotImplementedError = exports.DependencyMissingKeyError = exports.ContainerNotFoundError = exports.DependencyNotFoundError = exports.ContainerError = exports.Registration = exports.onResolve = exports.appendArgsFn = exports.appendArgs = exports.decorate = exports.singleton = exports.autoResolve = exports.lazy = exports.scopeAccess = exports.scope = exports.bindTo = exports.register = exports.toRegistrationFn = exports.toProviderFn = exports.toBindToken = exports.registerPipe = exports.isProviderPipe = exports.Provider = exports.ProxyInjector = exports.SimpleInjector = exports.resolveArgs = exports.argsFn = exports.args = exports.arg = exports.inject = exports.MetadataInjector = exports.Injector = exports.EmptyContainer = exports.AutoResolveModule = exports.Container = exports.isDependencyKey = void 0;
-exports.throttle = exports.handleAsyncError = exports.handleError = exports.getMethodTags = exports.addMethodTag = exports.getMethodLabels = exports.addMethodLabel = exports.getMethodMeta = exports.addMethodMeta = exports.getParamTags = exports.addParamTag = exports.getParamLabels = exports.addParamLabel = exports.getParamMeta = exports.addParamMeta = exports.getClassTags = exports.addClassTag = exports.getClassLabels = exports.addClassLabel = exports.getClassMeta = exports.addClassMeta = exports.resolveConstructor = exports.GroupInstanceToken = exports.ConstantToken = exports.FunctionToken = exports.SingleToken = exports.ClassToken = exports.toSingleAlias = exports.SingleAliasToken = exports.toGroupAlias = exports.GroupAliasToken = exports.argToToken = exports.toMappedToken = exports.toToken = exports.InjectionToken = exports.runHooks = exports.HooksRunner = exports.oncePerInstance = exports.invokeMethod = exports.resolved = exports.OnResolvedModule = exports.onResolved = exports.onResolvedHooksRunner = exports.OnDisposeModule = exports.onScopeDisposed = exports.onScopeDisposedHooksRunner = exports.OnConstructModule = exports.onConstruct = exports.onConstructHooksRunner = exports.injectProp = void 0;
-exports.Is = exports.unwrapProxy = exports.ProxyRegistry = exports.pipe = exports.select = exports.once = exports.shallowCache = exports.debounce = void 0;
+exports.createHookContextFactory = exports.HookContext = exports.prepend = exports.append = exports.prependHooks = exports.appendHooks = exports.hasHooks = exports.hook = exports.getHooks = exports.TypedEventDisposedError = exports.UnsupportedTokenTypeError = exports.CannonSingletonApplyTwiceError = exports.ProviderDisposedError = exports.ContainerDisposedError = exports.MethodNotImplementedError = exports.DependencyMissingKeyError = exports.ContainerNotFoundError = exports.DependencyNotFoundError = exports.ContainerError = exports.Registration = exports.onResolve = exports.appendArgsFn = exports.appendArgs = exports.decorate = exports.singleton = exports.autoResolve = exports.lazy = exports.scopeAccess = exports.scope = exports.bindTo = exports.register = exports.toRegistrationFn = exports.toProviderFn = exports.toBindToken = exports.registerPipe = exports.isProviderPipe = exports.Provider = exports.ProxyInjector = exports.SimpleInjector = exports.resolveArgs = exports.argsFn = exports.args = exports.arg = exports.inject = exports.MetadataInjector = exports.Injector = exports.EmptyContainer = exports.AutoResolveModule = exports.Container = exports.isDependencyKey = void 0;
+exports.throttle = exports.handleAsyncError = exports.handleError = exports.getMethodTags = exports.addMethodTag = exports.getMethodLabels = exports.addMethodLabel = exports.getMethodMeta = exports.addMethodMeta = exports.getParamTags = exports.addParamTag = exports.getParamLabels = exports.addParamLabel = exports.getParamMeta = exports.addParamMeta = exports.getClassTags = exports.addClassTag = exports.getClassLabels = exports.addClassLabel = exports.getClassMeta = exports.addClassMeta = exports.resolveConstructor = exports.GroupInstanceToken = exports.ConstantToken = exports.FunctionToken = exports.SingleToken = exports.ClassToken = exports.toSingleAlias = exports.SingleAliasToken = exports.toGroupAlias = exports.GroupAliasToken = exports.argToToken = exports.toMappedToken = exports.toToken = exports.InjectionToken = exports.ParallelAsync = exports.SequentialAsync = exports.SequentialSync = exports.AsyncHookExecutionStrategy = exports.HookExecutionStrategy = exports.oncePerInstance = exports.resolved = exports.OnResolvedModule = exports.onResolved = exports.OnDisposeModule = exports.onScopeDisposed = exports.OnConstructModule = exports.onConstruct = exports.injectProp = exports.createHookExecutionContext = void 0;
+exports.Is = exports.unwrapProxy = exports.ProxyRegistry = exports.pipe = exports.select = exports.TypedEvent = exports.once = exports.shallowCache = exports.debounce = void 0;
 var IContainer_1 = require("./container/IContainer");
 Object.defineProperty(exports, "isDependencyKey", { enumerable: true, get: function () { return IContainer_1.isDependencyKey; } });
 var Container_1 = require("./container/Container");
@@ -63,6 +63,8 @@ var CannonSingletonApplyTwiceError_1 = require("./errors/CannonSingletonApplyTwi
 Object.defineProperty(exports, "CannonSingletonApplyTwiceError", { enumerable: true, get: function () { return CannonSingletonApplyTwiceError_1.CannonSingletonApplyTwiceError; } });
 var UnsupportedTokenTypeError_1 = require("./errors/UnsupportedTokenTypeError");
 Object.defineProperty(exports, "UnsupportedTokenTypeError", { enumerable: true, get: function () { return UnsupportedTokenTypeError_1.UnsupportedTokenTypeError; } });
+var TypedEventDisposedError_1 = require("./errors/TypedEventDisposedError");
+Object.defineProperty(exports, "TypedEventDisposedError", { enumerable: true, get: function () { return TypedEventDisposedError_1.TypedEventDisposedError; } });
 var hook_1 = require("./hooks/hook");
 Object.defineProperty(exports, "getHooks", { enumerable: true, get: function () { return hook_1.getHooks; } });
 Object.defineProperty(exports, "hook", { enumerable: true, get: function () { return hook_1.hook; } });
@@ -74,28 +76,31 @@ Object.defineProperty(exports, "prepend", { enumerable: true, get: function () {
 var HookContext_1 = require("./hooks/HookContext");
 Object.defineProperty(exports, "HookContext", { enumerable: true, get: function () { return HookContext_1.HookContext; } });
 Object.defineProperty(exports, "createHookContextFactory", { enumerable: true, get: function () { return HookContext_1.createHookContextFactory; } });
-Object.defineProperty(exports, "createHookContext", { enumerable: true, get: function () { return HookContext_1.createHookContext; } });
+Object.defineProperty(exports, "createHookExecutionContext", { enumerable: true, get: function () { return HookContext_1.createHookExecutionContext; } });
 var injectProp_1 = require("./hooks/injectProp");
 Object.defineProperty(exports, "injectProp", { enumerable: true, get: function () { return injectProp_1.injectProp; } });
 var onConstruct_1 = require("./hooks/onConstruct");
-Object.defineProperty(exports, "onConstructHooksRunner", { enumerable: true, get: function () { return onConstruct_1.onConstructHooksRunner; } });
 Object.defineProperty(exports, "onConstruct", { enumerable: true, get: function () { return onConstruct_1.onConstruct; } });
 Object.defineProperty(exports, "OnConstructModule", { enumerable: true, get: function () { return onConstruct_1.OnConstructModule; } });
 var onScopeDisposed_1 = require("./hooks/onScopeDisposed");
-Object.defineProperty(exports, "onScopeDisposedHooksRunner", { enumerable: true, get: function () { return onScopeDisposed_1.onScopeDisposedHooksRunner; } });
 Object.defineProperty(exports, "onScopeDisposed", { enumerable: true, get: function () { return onScopeDisposed_1.onScopeDisposed; } });
 Object.defineProperty(exports, "OnDisposeModule", { enumerable: true, get: function () { return onScopeDisposed_1.OnDisposeModule; } });
 var onResolved_1 = require("./hooks/onResolved");
-Object.defineProperty(exports, "onResolvedHooksRunner", { enumerable: true, get: function () { return onResolved_1.onResolvedHooksRunner; } });
 Object.defineProperty(exports, "onResolved", { enumerable: true, get: function () { return onResolved_1.onResolved; } });
 Object.defineProperty(exports, "OnResolvedModule", { enumerable: true, get: function () { return onResolved_1.OnResolvedModule; } });
 Object.defineProperty(exports, "resolved", { enumerable: true, get: function () { return onResolved_1.resolved; } });
 var resolveHooks_1 = require("./hooks/resolveHooks");
-Object.defineProperty(exports, "invokeMethod", { enumerable: true, get: function () { return resolveHooks_1.invokeMethod; } });
 Object.defineProperty(exports, "oncePerInstance", { enumerable: true, get: function () { return resolveHooks_1.oncePerInstance; } });
-var HooksRunner_1 = require("./hooks/HooksRunner");
-Object.defineProperty(exports, "HooksRunner", { enumerable: true, get: function () { return HooksRunner_1.HooksRunner; } });
-Object.defineProperty(exports, "runHooks", { enumerable: true, get: function () { return HooksRunner_1.runHooks; } });
+var HookExecutionStrategy_1 = require("./hooks/HookExecutionStrategy");
+Object.defineProperty(exports, "HookExecutionStrategy", { enumerable: true, get: function () { return HookExecutionStrategy_1.HookExecutionStrategy; } });
+var AsyncHookExecutionStrategy_1 = require("./hooks/AsyncHookExecutionStrategy");
+Object.defineProperty(exports, "AsyncHookExecutionStrategy", { enumerable: true, get: function () { return AsyncHookExecutionStrategy_1.AsyncHookExecutionStrategy; } });
+var SequentialSync_1 = require("./hooks/SequentialSync");
+Object.defineProperty(exports, "SequentialSync", { enumerable: true, get: function () { return SequentialSync_1.SequentialSync; } });
+var SequentialAsync_1 = require("./hooks/SequentialAsync");
+Object.defineProperty(exports, "SequentialAsync", { enumerable: true, get: function () { return SequentialAsync_1.SequentialAsync; } });
+var ParallelAsync_1 = require("./hooks/ParallelAsync");
+Object.defineProperty(exports, "ParallelAsync", { enumerable: true, get: function () { return ParallelAsync_1.ParallelAsync; } });
 var InjectionToken_1 = require("./token/InjectionToken");
 Object.defineProperty(exports, "InjectionToken", { enumerable: true, get: function () { return InjectionToken_1.InjectionToken; } });
 var toToken_1 = require("./token/toToken");
@@ -152,6 +157,8 @@ var shallowCache_1 = require("./utils/shallowCache");
 Object.defineProperty(exports, "shallowCache", { enumerable: true, get: function () { return shallowCache_1.shallowCache; } });
 var once_1 = require("./utils/once");
 Object.defineProperty(exports, "once", { enumerable: true, get: function () { return once_1.once; } });
+var TypedEvent_1 = require("./utils/TypedEvent");
+Object.defineProperty(exports, "TypedEvent", { enumerable: true, get: function () { return TypedEvent_1.TypedEvent; } });
 var select_1 = require("./select");
 Object.defineProperty(exports, "select", { enumerable: true, get: function () { return select_1.select; } });
 var fp_1 = require("./utils/fp");

package/cjm/utils/TypedEvent.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypedEvent = void 0;
+const TypedEventDisposedError_1 = require("../errors/TypedEventDisposedError");
+class TypedEvent {
+    listeners = new Set();
+    isDisposed = false;
+    subscribe(listener) {
+        this.validate();
+        this.listeners.add(listener);
+        return () => this.unsubscribe(listener);
+    }
+    unsubscribe(listener) {
+        this.listeners.delete(listener);
+    }
+    emit(...args) {
+        this.validate();
+        for (const listener of [...this.listeners]) {
+            if (this.listeners.has(listener)) {
+                listener(...args);
+            }
+        }
+    }
+    getListeners() {
+        return [...this.listeners];
+    }
+    dispose() {
+        this.listeners.clear();
+        this.isDisposed = true;
+    }
+    validate() {
+        TypedEventDisposedError_1.TypedEventDisposedError.assert(!this.isDisposed, 'TypedEvent is already disposed');
+    }
+}
+exports.TypedEvent = TypedEvent;

package/esm/container/AutoResolveModule.js

@@ -4,6 +4,6 @@ export class AutoResolveModule {
         this.options = options;
     }
     applyTo(container) {
-        container.onScopeCreated((scope) => scope.autoResolve(this.options));
+        container.scopeCreated.subscribe((scope) => scope.autoResolve(this.options));
     }
 }

package/esm/container/Container.js

@@ -6,6 +6,7 @@ import { unwrapProxy } from '../utils/ProxyRegistry.js';
 import { DependencyNotFoundError } from '../errors/DependencyNotFoundError.js';
 import { Is } from '../utils/basic.js';
 import { Filter as F } from '../utils/array.js';
+import { TypedEvent } from '../utils/TypedEvent.js';
 export class Container {
     isDisposed = false;
     parent;
@@ -16,9 +17,12 @@ export class Container {
     providers = new Map();
     aliases = new AliasMap();
     injector;
-    onScopeCreatedHookList = [];
-    onScopeDisposedHookList = [];
-    onRegisteredHookList = [];
+    scopeCreatedEvent = new TypedEvent();
+    scopeDisposedEvent = new TypedEvent();
+    registeredEvent = new TypedEvent();
+    scopeCreated = this.scopeCreatedEvent;
+    scopeDisposed = this.scopeDisposedEvent;
+    registered = this.registeredEvent;
     constructor(options = {}) {
         this.injector = options.injector ?? new MetadataInjector();
         this.parent = options.parent ?? new EmptyContainer();
@@ -28,9 +32,7 @@ export class Container {
         this.validateContainer();
         this.providers.set(key, provider);
         this.aliases.setAliasesByKey(key, aliases);
-        for (const onRegistered of this.onRegisteredHookList) {
-            onRegistered(provider, key, this);
-        }
+        this.registeredEvent.emit(provider, key, this);
         return this;
     }
     resolve(target, { args = [], child = this, lazy } = {}) {
@@ -73,17 +75,15 @@ export class Container {
     }
     createScope({ tags } = {}) {
         this.validateContainer();
-        const scope = new Container({ injector: this.injector, parent: this, tags })
-            .onScopeCreated(...this.onScopeCreatedHookList)
-            .onScopeDisposed(...this.onScopeDisposedHookList)
-            .onRegistered(...this.onRegisteredHookList);
+        const scope = new Container({ injector: this.injector, parent: this, tags });
+        this.scopeCreatedEvent.getListeners().forEach((hook) => scope.scopeCreatedEvent.subscribe(hook));
+        this.scopeDisposedEvent.getListeners().forEach((hook) => scope.scopeDisposedEvent.subscribe(hook));
+        this.registeredEvent.getListeners().forEach((hook) => scope.registeredEvent.subscribe(hook));
         for (const registration of this.getRegistrations()) {
             registration.applyTo(scope);
         }
         this.scopes.push(scope);
-        for (const onScopeCreated of this.onScopeCreatedHookList) {
-            onScopeCreated(scope);
-        }
+        this.scopeCreatedEvent.emit(scope);
         return scope;
     }
     autoResolve({ args = [] } = {}) {
@@ -98,9 +98,7 @@ export class Container {
     dispose() {
         this.validateContainer();
         this.isDisposed = true;
-        for (const onScopeDisposed of this.onScopeDisposedHookList) {
-            onScopeDisposed(this);
-        }
+        this.scopeDisposedEvent.emit(this);
         this.parent.removeScope(this);
         this.parent = new EmptyContainer();
         for (const provider of this.providers.values()) {
@@ -110,9 +108,9 @@ export class Container {
         this.aliases.destroy();
         this.instances.clear();
         this.registrations = [];
-        this.onScopeCreatedHookList.length = 0;
-        this.onScopeDisposedHookList.length = 0;
-        this.onRegisteredHookList.length = 0;
+        this.scopeCreatedEvent.dispose();
+        this.scopeDisposedEvent.dispose();
+        this.registeredEvent.dispose();
     }
     addRegistration(registration) {
         this.registrations.push(registration);
@@ -122,21 +120,12 @@ export class Container {
     getRegistrations() {
         return [...this.parent.getRegistrations(), ...this.registrations];
     }
+    getInjector() {
+        return this.injector;
+    }
     hasRegistration(key) {
         return this.registrations.some((r) => r.getKeyOrFail() === key) || this.parent.hasRegistration(key);
     }
-    onScopeCreated(...hooks) {
-        this.onScopeCreatedHookList.push(...hooks);
-        return this;
-    }
-    onScopeDisposed(...hooks) {
-        this.onScopeDisposedHookList.push(...hooks);
-        return this;
-    }
-    onRegistered(...hooks) {
-        this.onRegisteredHookList.push(...hooks);
-        return this;
-    }
     addInstance(instance) {
         this.instances.add(instance);
     }

package/esm/container/EmptyContainer.js

@@ -20,6 +20,9 @@ export class EmptyContainer {
     createScope() {
         throw new MethodNotImplementedError();
     }
+    getInjector() {
+        throw new MethodNotImplementedError();
+    }
     autoResolve(options) {
         throw new MethodNotImplementedError();
     }
@@ -57,13 +60,13 @@ export class EmptyContainer {
     resolveOneByAlias(alias, options) {
         throw new DependencyNotFoundError(`Cannot find alias ${alias.toString()}`);
     }
-    onScopeCreated(...hooks) {
+    get scopeCreated() {
         throw new MethodNotImplementedError();
     }
-    onScopeDisposed(...hooks) {
+    get scopeDisposed() {
         throw new MethodNotImplementedError();
     }
-    onRegistered(...hooks) {
+    get registered() {
         throw new MethodNotImplementedError();
     }
 }

package/esm/errors/TypedEventDisposedError.js

@@ -0,0 +1,13 @@
+import { ContainerError } from './ContainerError.js';
+export class TypedEventDisposedError extends ContainerError {
+    name = 'TypedEventDisposedError';
+    static assert(isTrue, failMessage) {
+        if (!isTrue) {
+            throw new TypedEventDisposedError(failMessage);
+        }
+    }
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, TypedEventDisposedError.prototype);
+    }
+}

package/esm/hooks/AsyncHookExecutionStrategy.js

@@ -0,0 +1,11 @@
+import { HookExecutionStrategy, runAtOnce, runInOrder, } from './HookExecutionStrategy.js';
+export class AsyncHookExecutionStrategy extends HookExecutionStrategy {
+    methodStrategy;
+    constructor({ methodStrategy = 'sequential', ...props }) {
+        super(props);
+        this.methodStrategy = methodStrategy;
+    }
+    runMember({ hooks, context }) {
+        return this.methodStrategy === 'parallel' ? runAtOnce(hooks, context) : runInOrder(hooks, context);
+    }
+}

package/esm/hooks/HookContext.js

@@ -31,5 +31,5 @@ export class HookContext {
         return this.initialArgs;
     }
 }
-export const createHookContext = (Target, scope, methodName = 'constructor') => new HookContext(Target, scope, methodName);
-export const createHookContextFactory = ({ args = [] } = {}) => (Target, scope, methodName) => createHookContext(Target, scope, methodName).setInitialArgs(...args);
+export const createHookExecutionContext = (Target, scope, methodName = 'constructor') => new HookContext(Target, scope, methodName);
+export const createHookContextFactory = ({ args = [] } = {}) => (Target, scope, methodName) => createHookExecutionContext(Target, scope, methodName).setInitialArgs(...args);

package/esm/hooks/HookExecutionStrategy.js

@@ -0,0 +1,62 @@
+import { resolveConstructor } from '../metadata/target.js';
+import { getHooks, hasHooks, toHookFn } from './hook.js';
+import { createHookExecutionContext } from './HookContext.js';
+export const runInOrder = (hooks, context, from = 0) => {
+    for (let i = from; i < hooks.length; i++) {
+        const result = hooks[i](context);
+        if (result instanceof Promise) {
+            return result.then(() => runInOrder(hooks, context, i + 1));
+        }
+    }
+};
+export const runAtOnce = (hooks, context) => {
+    const pending = [];
+    for (const hook of hooks) {
+        const result = hook(context);
+        if (result instanceof Promise) {
+            pending.push(result);
+        }
+    }
+    return pending.length > 0 ? Promise.all(pending).then(() => undefined) : undefined;
+};
+export class HookExecutionStrategy {
+    key;
+    onError;
+    options;
+    hooksByClass = new WeakMap();
+    constructor({ key, onError, createExecutionContext = createHookExecutionContext, mapExecutionContext = (context) => context, predicate = () => true, }) {
+        this.key = key;
+        this.onError = onError;
+        this.options = { createExecutionContext, mapExecutionContext, predicate };
+    }
+    hasHooks(target) {
+        return hasHooks(target, this.key);
+    }
+    execute(target, { scope, ...overrides }) {
+        const report = (ex) => this.onError?.(scope)(ex);
+        try {
+            this.processHooks(this.collect(target, scope, overrides))?.catch(report);
+        }
+        catch (ex) {
+            report(ex);
+        }
+    }
+    collect(target, scope, { createExecutionContext = this.options.createExecutionContext, mapExecutionContext = this.options.mapExecutionContext, predicate = this.options.predicate, }) {
+        const members = [];
+        for (const { methodName, hooks } of this.hooksOf(target)) {
+            if (predicate(methodName)) {
+                members.push({ hooks, context: mapExecutionContext(createExecutionContext(target, scope, methodName)) });
+            }
+        }
+        return members;
+    }
+    hooksOf(target) {
+        const Target = resolveConstructor(target);
+        let hooks = this.hooksByClass.get(Target);
+        if (!hooks) {
+            hooks = Array.from(getHooks(Target, this.key), ([methodName, fns]) => ({ methodName, hooks: fns.map(toHookFn) }));
+            this.hooksByClass.set(Target, hooks);
+        }
+        return hooks;
+    }
+}

package/esm/hooks/ParallelAsync.js

@@ -0,0 +1,13 @@
+import { AsyncHookExecutionStrategy } from './AsyncHookExecutionStrategy.js';
+export class ParallelAsync extends AsyncHookExecutionStrategy {
+    processHooks(members) {
+        const pending = [];
+        for (const member of members) {
+            const result = this.runMember(member);
+            if (result) {
+                pending.push(result);
+            }
+        }
+        return pending.length > 0 ? Promise.all(pending).then(() => undefined) : undefined;
+    }
+}

package/esm/hooks/SequentialAsync.js

@@ -0,0 +1,11 @@
+import { AsyncHookExecutionStrategy } from './AsyncHookExecutionStrategy.js';
+export class SequentialAsync extends AsyncHookExecutionStrategy {
+    processHooks(members, from = 0) {
+        for (let i = from; i < members.length; i++) {
+            const result = this.runMember(members[i]);
+            if (result) {
+                return result.then(() => this.processHooks(members, i + 1));
+            }
+        }
+    }
+}

package/esm/hooks/SequentialSync.js

@@ -0,0 +1,10 @@
+import { HookExecutionStrategy } from './HookExecutionStrategy.js';
+export class SequentialSync extends HookExecutionStrategy {
+    processHooks(members) {
+        for (const { hooks, context } of members) {
+            for (const hook of hooks) {
+                hook(context);
+            }
+        }
+    }
+}

package/esm/hooks/onConstruct.js

@@ -1,15 +1,13 @@
 import { hook, prependHooks } from './hook.js';
-import { HooksRunner, runHooks } from './HooksRunner.js';
-export const onConstructHooksRunner = new HooksRunner('onConstruct');
 export const onConstruct = (...fns) => hook('onConstruct', prependHooks(...fns));
 export class OnConstructModule {
-    onException;
-    constructor(onException) {
-        this.onException = onException;
+    strategy;
+    constructor(strategy) {
+        this.strategy = strategy;
     }
-    applyTo(injector) {
-        injector.onConstructed((instance, scope) => {
-            runHooks(onConstructHooksRunner, instance, scope, this.onException);
+    applyTo(container) {
+        container.getInjector().onConstructed((instance, scope) => {
+            this.strategy.execute(instance, { scope });
         });
     }
 }

package/esm/hooks/onResolved.js

@@ -1,18 +1,21 @@
-import { HooksRunner } from './HooksRunner.js';
 import { registerPipe } from '../registration/IRegistration.js';
-import { executeHooks, forEachResolvedObject, resolvedHook } from './resolveHooks.js';
-export const onResolvedHooksRunner = new HooksRunner('onResolved');
-export const onResolved = resolvedHook('onResolved');
-const runHooks = (onException) => forEachResolvedObject(executeHooks(onResolvedHooksRunner, onException));
+import { Is } from '../utils/basic.js';
+import { hook, prependHooks } from './hook.js';
+export const onResolved = (...hooks) => hook('onResolved', prependHooks(...hooks));
+const runHooks = (strategy) => (dependency, scope) => {
+    if (Is.object(dependency)) {
+        strategy.execute(dependency, { scope });
+    }
+};
 export class OnResolvedModule {
     runHooks;
-    constructor(onException) {
-        this.runHooks = runHooks(onException);
+    constructor(strategy) {
+        this.runHooks = runHooks(strategy);
     }
     applyTo(container) {
-        container.onRegistered((provider) => {
+        container.registered.subscribe((provider) => {
             provider.onResolved(this.runHooks);
         });
     }
 }
-export const resolved = (onException) => registerPipe((p) => p.onResolved(runHooks(onException)));
+export const resolved = (strategy) => registerPipe((p) => p.onResolved(runHooks(strategy)));

package/esm/hooks/onScopeDisposed.js

@@ -1,16 +1,14 @@
 import { hook, prependHooks } from './hook.js';
-import { HooksRunner, runHooks } from './HooksRunner.js';
-export const onScopeDisposedHooksRunner = new HooksRunner('onScopeDisposed');
 export const onScopeDisposed = (...fns) => hook('onScopeDisposed', prependHooks(...fns));
 export class OnDisposeModule {
-    onException;
-    constructor(onException) {
-        this.onException = onException;
+    strategy;
+    constructor(strategy) {
+        this.strategy = strategy;
     }
     applyTo(container) {
-        container.onScopeDisposed((scope) => {
+        container.scopeDisposed.subscribe((scope) => {
             for (const instance of scope.getInstances()) {
-                runHooks(onScopeDisposedHooksRunner, instance, scope, this.onException);
+                this.strategy.execute(instance, { scope });
             }
         });
     }

package/esm/hooks/resolveHooks.js

@@ -1,10 +1,4 @@
-import { runHooks } from './HooksRunner.js';
-import { hook, prependHooks, toHookFn } from './hook.js';
-import { Is } from '../utils/basic.js';
-export const invokeMethod = (context) => {
-    context.invokeMethod();
-};
-const toHooks = (hooks) => (hooks.length > 0 ? hooks : [invokeMethod]);
+import { toHookFn } from './hook.js';
 export const oncePerInstance = (execute) => {
     const invokedInstances = new WeakSet();
     return (context) => {
@@ -15,10 +9,3 @@ export const oncePerInstance = (execute) => {
         return toHookFn(execute)(context);
     };
 };
-export const resolvedHook = (key) => (...hooks) => hook(key, prependHooks(...toHooks(hooks)));
-export const forEachResolvedObject = (run) => (dependency, scope) => {
-    if (Is.object(dependency)) {
-        run(dependency, scope);
-    }
-};
-export const executeHooks = (runner, onException) => (dependency, scope) => runHooks(runner, dependency, scope, onException);