ts-ioc-container 63.0.0 → 64.0.0

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.createHookExecutionContext = 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.debounce = 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 = void 0;
+exports.Is = exports.unwrapProxy = exports.ProxyRegistry = exports.pipe = exports.select = exports.once = exports.shallowCache = 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");
@@ -74,28 +74,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");

package/esm/container/Container.js

@@ -122,6 +122,9 @@ 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);
     }

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();
     }

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,13 +1,16 @@
-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) => {
@@ -15,4 +18,4 @@ export class OnResolvedModule {
         });
     }
 }
-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) => {
             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);

package/esm/index.js

@@ -19,13 +19,17 @@ export { ProviderDisposedError } from './errors/ProviderDisposedError.js';
 export { CannonSingletonApplyTwiceError } from './errors/CannonSingletonApplyTwiceError.js';
 export { UnsupportedTokenTypeError } from './errors/UnsupportedTokenTypeError.js';
 export { getHooks, hook, hasHooks, appendHooks, prependHooks, append, prepend, } from './hooks/hook.js';
-export { HookContext, createHookContextFactory, createHookContext } from './hooks/HookContext.js';
+export { HookContext, createHookContextFactory, createHookExecutionContext, } from './hooks/HookContext.js';
 export { injectProp } from './hooks/injectProp.js';
-export { onConstructHooksRunner, onConstruct, OnConstructModule } from './hooks/onConstruct.js';
-export { onScopeDisposedHooksRunner, onScopeDisposed, OnDisposeModule } from './hooks/onScopeDisposed.js';
-export { onResolvedHooksRunner, onResolved, OnResolvedModule, resolved } from './hooks/onResolved.js';
-export { invokeMethod, oncePerInstance } from './hooks/resolveHooks.js';
-export { HooksRunner, runHooks, } from './hooks/HooksRunner.js';
+export { onConstruct, OnConstructModule } from './hooks/onConstruct.js';
+export { onScopeDisposed, OnDisposeModule } from './hooks/onScopeDisposed.js';
+export { onResolved, OnResolvedModule, resolved } from './hooks/onResolved.js';
+export { oncePerInstance } from './hooks/resolveHooks.js';
+export { HookExecutionStrategy, } from './hooks/HookExecutionStrategy.js';
+export { AsyncHookExecutionStrategy, } from './hooks/AsyncHookExecutionStrategy.js';
+export { SequentialSync } from './hooks/SequentialSync.js';
+export { SequentialAsync } from './hooks/SequentialAsync.js';
+export { ParallelAsync } from './hooks/ParallelAsync.js';
 export { InjectionToken } from './token/InjectionToken.js';
 export { toToken, toMappedToken, argToToken } from './token/toToken.js';
 export { GroupAliasToken, toGroupAlias } from './token/GroupAliasToken.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-ioc-container",
-  "version": "63.0.0",
+  "version": "64.0.0",
   "description": "Fast, lightweight TypeScript dependency injection container with a clean API, scoped lifecycles, decorators, tokens, hooks, lazy injection, customizable providers, and no global container objects.",
   "publishConfig": {
     "access": "public",

package/typings/container/Container.d.ts

@@ -30,6 +30,7 @@ export declare class Container implements IContainer {
     dispose(): void;
     addRegistration(registration: IRegistration): this;
     getRegistrations(): IRegistration[];
+    getInjector(): IInjector;
     hasRegistration(key: DependencyKey): boolean;
     onScopeCreated(...hooks: ScopeHook[]): this;
     onScopeDisposed(...hooks: ScopeHook[]): this;

package/typings/container/EmptyContainer.d.ts

@@ -2,6 +2,7 @@ import { type AutoResolveOptions, type DependencyKey, type IContainer, type ICon
 import { type IProvider } from '../provider/IProvider.js';
 import { type IRegistration } from '../registration/IRegistration.js';
 import { type constructor, type Instance } from '../utils/basic.js';
+import { type IInjector } from '../injector/IInjector.js';
 export declare class EmptyContainer implements IContainer {
     get isDisposed(): boolean;
     addInstance(instance: Instance): void;
@@ -10,6 +11,7 @@ export declare class EmptyContainer implements IContainer {
     getInstances(): never[];
     hasInstance(instance: Instance): boolean;
     createScope(): IContainer;
+    getInjector(): IInjector;
     autoResolve(options?: AutoResolveOptions): this;
     dispose(): void;
     register(key: DependencyKey, value: IProvider): this;

package/typings/container/IContainer.d.ts

@@ -1,6 +1,6 @@
 import { type IProvider, ProviderOptions } from '../provider/IProvider.js';
 import { type IRegistration } from '../registration/IRegistration.js';
-import { type WithArgs } from '../injector/IInjector.js';
+import { IInjector, type WithArgs } from '../injector/IInjector.js';
 import { type constructor, Instance } from '../utils/basic.js';
 export type DependencyKey = string | symbol;
 export declare function isDependencyKey(target: unknown): target is DependencyKey;
@@ -55,5 +55,6 @@ export interface IContainer extends Tagged {
     hasInstance(instance: Instance): boolean;
     dispose(): void;
     addInstance(instance: Instance): void;
+    getInjector(): IInjector;
 }
 export {};

package/typings/hooks/AsyncHookExecutionStrategy.d.ts

@@ -0,0 +1,10 @@
+import { HookExecutionStrategy, type HookExecutionStrategyProps, type MemberHooks } from './HookExecutionStrategy.js';
+export type MethodStrategy = 'sequential' | 'parallel';
+export type AsyncHookExecutionStrategyProps = HookExecutionStrategyProps & {
+    methodStrategy?: MethodStrategy;
+};
+export declare abstract class AsyncHookExecutionStrategy extends HookExecutionStrategy {
+    private readonly methodStrategy;
+    constructor({ methodStrategy, ...props }: AsyncHookExecutionStrategyProps);
+    protected runMember({ hooks, context }: MemberHooks): void | Promise<void>;
+}

package/typings/hooks/HookContext.d.ts

@@ -29,8 +29,8 @@ export declare class HookContext implements IHookContext {
     setInitialArgs(...args: unknown[]): this;
     getInitialArgs(): unknown[];
 }
-export type CreateHookContext = (Target: Instance, scope: IContainer, methodName?: string) => IHookContext;
-export declare const createHookContext: CreateHookContext;
+export type CreateHookExecutionContext = (Target: Instance, scope: IContainer, methodName?: string) => IHookContext;
+export declare const createHookExecutionContext: CreateHookExecutionContext;
 export declare const createHookContextFactory: ({ args }?: {
     args?: unknown[];
-}) => CreateHookContext;
+}) => CreateHookExecutionContext;

package/typings/hooks/HookExecutionStrategy.d.ts

@@ -0,0 +1,35 @@
+import type { IContainer } from '../container/IContainer.js';
+import type { ExecutionContext } from '../ExecutionContext.js';
+import { type Instance } from '../utils/basic.js';
+import { type HookFn } from './hook.js';
+import { type CreateHookExecutionContext, type IHookContext } from './HookContext.js';
+export type MapHookExecutionContext = (context: IHookContext) => IHookContext;
+export type OnErrorHandler = (scope: IContainer) => (error: unknown) => void;
+export type HookExecutionOptions = {
+    createExecutionContext?: CreateHookExecutionContext;
+    mapExecutionContext?: MapHookExecutionContext;
+    predicate?: (methodName: string) => boolean;
+};
+export type HookExecutionContext = ExecutionContext & HookExecutionOptions;
+export type HookExecutionStrategyProps = HookExecutionOptions & {
+    key: string | symbol;
+    onError?: OnErrorHandler;
+};
+export type MemberHooks = {
+    hooks: HookFn[];
+    context: IHookContext;
+};
+export declare const runInOrder: (hooks: HookFn[], context: IHookContext, from?: number) => void | Promise<void>;
+export declare const runAtOnce: (hooks: HookFn[], context: IHookContext) => void | Promise<void>;
+export declare abstract class HookExecutionStrategy {
+    private readonly key;
+    private readonly onError?;
+    private readonly options;
+    private readonly hooksByClass;
+    constructor({ key, onError, createExecutionContext, mapExecutionContext, predicate, }: HookExecutionStrategyProps);
+    hasHooks(target: Instance): boolean;
+    execute(target: Instance, { scope, ...overrides }: HookExecutionContext): void;
+    protected abstract processHooks(members: MemberHooks[]): void | Promise<void>;
+    private collect;
+    private hooksOf;
+}

package/typings/hooks/ParallelAsync.d.ts

@@ -0,0 +1,5 @@
+import { AsyncHookExecutionStrategy } from './AsyncHookExecutionStrategy.js';
+import { type MemberHooks } from './HookExecutionStrategy.js';
+export declare class ParallelAsync extends AsyncHookExecutionStrategy {
+    protected processHooks(members: MemberHooks[]): void | Promise<void>;
+}

package/typings/hooks/SequentialAsync.d.ts

@@ -0,0 +1,5 @@
+import { AsyncHookExecutionStrategy } from './AsyncHookExecutionStrategy.js';
+import { type MemberHooks } from './HookExecutionStrategy.js';
+export declare class SequentialAsync extends AsyncHookExecutionStrategy {
+    protected processHooks(members: MemberHooks[], from?: number): void | Promise<void>;
+}

package/typings/hooks/SequentialSync.d.ts

@@ -0,0 +1,4 @@
+import { HookExecutionStrategy, type MemberHooks } from './HookExecutionStrategy.js';
+export declare class SequentialSync extends HookExecutionStrategy {
+    protected processHooks(members: MemberHooks[]): void;
+}

package/typings/hooks/onConstruct.d.ts

@@ -1,10 +1,9 @@
-import { HookType } from './hook.js';
-import type { IInjector, IInjectorModule } from '../injector/IInjector.js';
-import { HooksRunner, type OnExceptionHandler } from './HooksRunner.js';
-export declare const onConstructHooksRunner: HooksRunner;
+import { type HookType } from './hook.js';
+import type { IContainer, IContainerModule } from '../container/IContainer.js';
+import { type HookExecutionStrategy } from './HookExecutionStrategy.js';
 export declare const onConstruct: (...fns: HookType[]) => (target: object, propertyKey: string | symbol) => void;
-export declare class OnConstructModule implements IInjectorModule {
-    private readonly onException?;
-    constructor(onException?: OnExceptionHandler | undefined);
-    applyTo(injector: IInjector): void;
+export declare class OnConstructModule implements IContainerModule {
+    private readonly strategy;
+    constructor(strategy: HookExecutionStrategy);
+    applyTo(container: IContainer): void;
 }

package/typings/hooks/onResolved.d.ts

@@ -1,10 +1,10 @@
 import type { IContainer, IContainerModule } from '../container/IContainer.js';
-import { HooksRunner, type OnExceptionHandler } from './HooksRunner.js';
-export declare const onResolvedHooksRunner: HooksRunner;
-export declare const onResolved: (...hooks: import("./hook.js").HookType[]) => (target: object, propertyKey: string | symbol) => void;
+import { type HookExecutionStrategy } from './HookExecutionStrategy.js';
+import { type HookType } from './hook.js';
+export declare const onResolved: (...hooks: HookType[]) => (target: object, propertyKey: string | symbol) => void;
 export declare class OnResolvedModule implements IContainerModule {
     private readonly runHooks;
-    constructor(onException?: OnExceptionHandler);
+    constructor(strategy: HookExecutionStrategy);
     applyTo(container: IContainer): void;
 }
-export declare const resolved: <T = unknown>(onException?: OnExceptionHandler) => import("../registration/IRegistration.js").ProviderPipe<T>;
+export declare const resolved: <T = unknown>(strategy: HookExecutionStrategy) => import("../registration/IRegistration.js").ProviderPipe<T>;

package/typings/hooks/onScopeDisposed.d.ts

@@ -1,10 +1,9 @@
-import { HookType } from './hook.js';
+import { type HookType } from './hook.js';
 import type { IContainer, IContainerModule } from '../container/IContainer.js';
-import { HooksRunner, type OnExceptionHandler } from './HooksRunner.js';
-export declare const onScopeDisposedHooksRunner: HooksRunner;
+import { type HookExecutionStrategy } from './HookExecutionStrategy.js';
 export declare const onScopeDisposed: (...fns: HookType[]) => (target: object, propertyKey: string | symbol) => void;
 export declare class OnDisposeModule implements IContainerModule {
-    private readonly onException?;
-    constructor(onException?: OnExceptionHandler | undefined);
+    private readonly strategy;
+    constructor(strategy: HookExecutionStrategy);
     applyTo(container: IContainer): void;
 }

package/typings/hooks/resolveHooks.d.ts

@@ -1,10 +1,4 @@
 import type { IContainer } from '../container/IContainer.js';
-import type { ProviderHook } from '../provider/IProvider.js';
-import { type HooksRunner, type OnExceptionHandler } from './HooksRunner.js';
 import { type HookFn, type HookType } from './hook.js';
 export type ResolvedObjectHook = (dependency: object, scope: IContainer) => void;
-export declare const invokeMethod: HookFn;
 export declare const oncePerInstance: (execute: HookType) => HookFn;
-export declare const resolvedHook: (key: string) => (...hooks: HookType[]) => (target: object, propertyKey: string | symbol) => void;
-export declare const forEachResolvedObject: (run: ResolvedObjectHook) => ProviderHook;
-export declare const executeHooks: (runner: HooksRunner, onException?: OnExceptionHandler) => ResolvedObjectHook;

package/typings/index.d.ts

@@ -20,13 +20,17 @@ export { ProviderDisposedError } from './errors/ProviderDisposedError.js';
 export { CannonSingletonApplyTwiceError } from './errors/CannonSingletonApplyTwiceError.js';
 export { UnsupportedTokenTypeError } from './errors/UnsupportedTokenTypeError.js';
 export { getHooks, hook, hasHooks, appendHooks, prependHooks, append, prepend, type HookFn, type HookClass, type HookType, type MapHooksFn, type InjectFn, type HooksOfClass, } from './hooks/hook.js';
-export { HookContext, createHookContextFactory, createHookContext, type IHookContext } from './hooks/HookContext.js';
+export { HookContext, createHookContextFactory, createHookExecutionContext, type CreateHookExecutionContext, type IHookContext, } from './hooks/HookContext.js';
 export { injectProp } from './hooks/injectProp.js';
-export { onConstructHooksRunner, onConstruct, OnConstructModule } from './hooks/onConstruct.js';
-export { onScopeDisposedHooksRunner, onScopeDisposed, OnDisposeModule } from './hooks/onScopeDisposed.js';
-export { onResolvedHooksRunner, onResolved, OnResolvedModule, resolved } from './hooks/onResolved.js';
-export { invokeMethod, oncePerInstance, type ResolvedObjectHook } from './hooks/resolveHooks.js';
-export { HooksRunner, runHooks, type HooksRunnerContext, type MapHookContext, type OnExceptionHandler, } from './hooks/HooksRunner.js';
+export { onConstruct, OnConstructModule } from './hooks/onConstruct.js';
+export { onScopeDisposed, OnDisposeModule } from './hooks/onScopeDisposed.js';
+export { onResolved, OnResolvedModule, resolved } from './hooks/onResolved.js';
+export { oncePerInstance, type ResolvedObjectHook } from './hooks/resolveHooks.js';
+export { HookExecutionStrategy, type HookExecutionContext, type HookExecutionOptions, type HookExecutionStrategyProps, type MapHookExecutionContext, type MemberHooks, type OnErrorHandler, } from './hooks/HookExecutionStrategy.js';
+export { AsyncHookExecutionStrategy, type AsyncHookExecutionStrategyProps, type MethodStrategy, } from './hooks/AsyncHookExecutionStrategy.js';
+export { SequentialSync } from './hooks/SequentialSync.js';
+export { SequentialAsync } from './hooks/SequentialAsync.js';
+export { ParallelAsync } from './hooks/ParallelAsync.js';
 export { InjectionToken } from './token/InjectionToken.js';
 export { type Injectable, toToken, toMappedToken, argToToken } from './token/toToken.js';
 export { GroupAliasToken, toGroupAlias } from './token/GroupAliasToken.js';

package/cjm/hooks/HooksRunner.js

@@ -1,50 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runHooks = exports.HooksRunner = void 0;
-const HookContext_1 = require("./HookContext");
-const hook_1 = require("./hook");
-const runFrom = (fns, index, context) => {
-    for (let i = index; i < fns.length; i++) {
-        const result = fns[i](context);
-        if (result instanceof Promise) {
-            return result.then(() => runFrom(fns, i + 1, context));
-        }
-    }
-};
-class HooksRunner {
-    key;
-    constructor(key) {
-        this.key = key;
-    }
-    hasHooks(target) {
-        return (0, hook_1.hasHooks)(target, this.key);
-    }
-    execute(target, { scope, createContext = HookContext_1.createHookContext, mapContext = (context) => context, predicate = () => true, }) {
-        const hooks = Array.from((0, hook_1.getHooks)(target, this.key).entries()).filter(([methodName]) => predicate(methodName));
-        const pending = [];
-        for (const [methodName, executions] of hooks) {
-            const context = mapContext(createContext(target, scope, methodName));
-            const result = runFrom(executions.map(hook_1.toHookFn), 0, context);
-            if (result) {
-                pending.push(result);
-            }
-        }
-        return pending.length > 0 ? Promise.all(pending).then(() => undefined) : undefined;
-    }
-}
-exports.HooksRunner = HooksRunner;
-const runHooks = (runner, target, scope, onException) => {
-    const report = (ex) => {
-        if (!onException) {
-            throw ex;
-        }
-        onException(ex, { scope });
-    };
-    try {
-        runner.execute(target, { scope })?.catch(report);
-    }
-    catch (ex) {
-        report(ex);
-    }
-};
-exports.runHooks = runHooks;