ts-ioc-container 63.0.0 → 65.0.0

package/esm/index.js

@@ -18,14 +18,19 @@ export { ContainerDisposedError } from './errors/ContainerDisposedError.js';
 export { ProviderDisposedError } from './errors/ProviderDisposedError.js';
 export { CannonSingletonApplyTwiceError } from './errors/CannonSingletonApplyTwiceError.js';
 export { UnsupportedTokenTypeError } from './errors/UnsupportedTokenTypeError.js';
+export { TypedEventDisposedError } from './errors/TypedEventDisposedError.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';
@@ -44,6 +49,7 @@ export { throttle } from './utils/throttle.js';
 export { debounce } from './utils/debounce.js';
 export { shallowCache } from './utils/shallowCache.js';
 export { once } from './utils/once.js';
+export { TypedEvent } from './utils/TypedEvent.js';
 export { select } from './select.js';
 export { pipe } from './utils/fp.js';
 export { ProxyRegistry, unwrapProxy } from './utils/ProxyRegistry.js';

package/esm/utils/TypedEvent.js

@@ -0,0 +1,31 @@
+import { TypedEventDisposedError } from '../errors/TypedEventDisposedError.js';
+export 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.assert(!this.isDisposed, 'TypedEvent is already disposed');
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-ioc-container",
-  "version": "63.0.0",
+  "version": "65.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

@@ -1,8 +1,9 @@
-import { type AutoResolveOptions, type CreateScopeOptions, type DependencyKey, type IContainer, type IContainerModule, type RegisteredHook, type RegisterOptions, ResolveManyOptions, type ResolveOneOptions, type ScopeHook, type Tag } from './IContainer.js';
+import { type AutoResolveOptions, type CreateScopeOptions, type DependencyKey, type IContainer, type IContainerModule, type RegisterOptions, ResolveManyOptions, type ResolveOneOptions, type Tag } from './IContainer.js';
 import { type IInjector } from '../injector/IInjector.js';
 import { type IProvider } from '../provider/IProvider.js';
 import { type IRegistration } from '../registration/IRegistration.js';
 import { constructor, Instance } from '../utils/basic.js';
+import { type ITypedEvent } from '../utils/TypedEvent.js';
 export declare class Container implements IContainer {
     isDisposed: boolean;
     private parent;
@@ -13,9 +14,12 @@ export declare class Container implements IContainer {
     private readonly providers;
     private readonly aliases;
     private readonly injector;
-    private readonly onScopeCreatedHookList;
-    private readonly onScopeDisposedHookList;
-    private readonly onRegisteredHookList;
+    private readonly scopeCreatedEvent;
+    private readonly scopeDisposedEvent;
+    private readonly registeredEvent;
+    readonly scopeCreated: ITypedEvent<[IContainer]>;
+    readonly scopeDisposed: ITypedEvent<[IContainer]>;
+    readonly registered: ITypedEvent<[IProvider, DependencyKey, IContainer]>;
     constructor(options?: {
         injector?: IInjector;
         parent?: IContainer;
@@ -30,10 +34,8 @@ 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;
-    onRegistered(...hooks: RegisteredHook[]): this;
     addInstance(instance: Instance): void;
     getScopes(): IContainer[];
     hasInstance(instance: Instance): boolean;

package/typings/container/EmptyContainer.d.ts

@@ -1,7 +1,9 @@
-import { type AutoResolveOptions, type DependencyKey, type IContainer, type IContainerModule, type ScopeHook, type RegisteredHook, type ResolveManyOptions, type ResolveOneOptions, type Tag } from './IContainer.js';
+import { type AutoResolveOptions, type DependencyKey, type IContainer, type IContainerModule, type ResolveManyOptions, type ResolveOneOptions, type Tag } from './IContainer.js';
 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';
+import { type ITypedEvent } from '../utils/TypedEvent.js';
 export declare class EmptyContainer implements IContainer {
     get isDisposed(): boolean;
     addInstance(instance: Instance): void;
@@ -10,6 +12,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;
@@ -23,7 +26,7 @@ export declare class EmptyContainer implements IContainer {
     resolve<T>(key: constructor<T> | DependencyKey, options?: ResolveOneOptions): T;
     resolveByAlias<T>(alias: DependencyKey, options?: ResolveManyOptions): T[];
     resolveOneByAlias<T>(alias: DependencyKey, options?: ResolveOneOptions): T;
-    onScopeCreated(...hooks: ScopeHook[]): this;
-    onScopeDisposed(...hooks: ScopeHook[]): this;
-    onRegistered(...hooks: RegisteredHook[]): this;
+    get scopeCreated(): ITypedEvent<[IContainer]>;
+    get scopeDisposed(): ITypedEvent<[IContainer]>;
+    get registered(): ITypedEvent<[IProvider, DependencyKey, IContainer]>;
 }

package/typings/container/IContainer.d.ts

@@ -1,7 +1,8 @@
 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';
+import { type ITypedEvent } from '../utils/TypedEvent.js';
 export type DependencyKey = string | symbol;
 export declare function isDependencyKey(target: unknown): target is DependencyKey;
 export type Tag = string;
@@ -35,9 +36,9 @@ export type ScopeHook = (scope: IContainer) => void;
 export type RegisteredHook = (provider: IProvider, key: DependencyKey, scope: IContainer) => void;
 export interface IContainer extends Tagged {
     readonly isDisposed: boolean;
-    onScopeCreated(...hooks: ScopeHook[]): this;
-    onScopeDisposed(...hooks: ScopeHook[]): this;
-    onRegistered(...hooks: RegisteredHook[]): this;
+    readonly scopeCreated: ITypedEvent<[IContainer]>;
+    readonly scopeDisposed: ITypedEvent<[IContainer]>;
+    readonly registered: ITypedEvent<[IProvider, DependencyKey, IContainer]>;
     register(key: DependencyKey, value: IProvider, options?: RegisterOptions): this;
     addRegistration(registration: IRegistration): this;
     getRegistrations(): IRegistration[];
@@ -55,5 +56,6 @@ export interface IContainer extends Tagged {
     hasInstance(instance: Instance): boolean;
     dispose(): void;
     addInstance(instance: Instance): void;
+    getInjector(): IInjector;
 }
 export {};

package/typings/errors/TypedEventDisposedError.d.ts

@@ -0,0 +1,6 @@
+import { ContainerError } from './ContainerError.js';
+export declare class TypedEventDisposedError extends ContainerError {
+    name: string;
+    static assert(isTrue: boolean, failMessage: string): void;
+    constructor(message: string);
+}

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

@@ -19,14 +19,19 @@ export { ContainerDisposedError } from './errors/ContainerDisposedError.js';
 export { ProviderDisposedError } from './errors/ProviderDisposedError.js';
 export { CannonSingletonApplyTwiceError } from './errors/CannonSingletonApplyTwiceError.js';
 export { UnsupportedTokenTypeError } from './errors/UnsupportedTokenTypeError.js';
+export { TypedEventDisposedError } from './errors/TypedEventDisposedError.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';
@@ -45,6 +50,7 @@ export { throttle } from './utils/throttle.js';
 export { debounce } from './utils/debounce.js';
 export { shallowCache } from './utils/shallowCache.js';
 export { once } from './utils/once.js';
+export { TypedEvent, type ITypedEvent, type TypedEventListener, type Unsubscribe } from './utils/TypedEvent.js';
 export { type ExecutionContext } from './ExecutionContext.js';
 export { select } from './select.js';
 export { pipe, type MapFn } from './utils/fp.js';

package/typings/utils/TypedEvent.d.ts

@@ -0,0 +1,17 @@
+export type TypedEventListener<TArgs extends unknown[]> = (...args: TArgs) => void;
+export type Unsubscribe = () => void;
+export interface ITypedEvent<TArgs extends unknown[]> {
+    subscribe(listener: TypedEventListener<TArgs>): Unsubscribe;
+    unsubscribe(listener: TypedEventListener<TArgs>): void;
+    dispose(): void;
+}
+export declare class TypedEvent<TArgs extends unknown[] = []> implements ITypedEvent<TArgs> {
+    private readonly listeners;
+    private isDisposed;
+    subscribe(listener: TypedEventListener<TArgs>): Unsubscribe;
+    unsubscribe(listener: TypedEventListener<TArgs>): void;
+    emit(...args: TArgs): void;
+    getListeners(): TypedEventListener<TArgs>[];
+    dispose(): void;
+    private validate;
+}

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;

package/esm/hooks/HooksRunner.js

@@ -1,45 +0,0 @@
-import { createHookContext } from './HookContext.js';
-import { getHooks, hasHooks, toHookFn } from './hook.js';
-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));
-        }
-    }
-};
-export class HooksRunner {
-    key;
-    constructor(key) {
-        this.key = key;
-    }
-    hasHooks(target) {
-        return hasHooks(target, this.key);
-    }
-    execute(target, { scope, createContext = createHookContext, mapContext = (context) => context, predicate = () => true, }) {
-        const hooks = Array.from(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(toHookFn), 0, context);
-            if (result) {
-                pending.push(result);
-            }
-        }
-        return pending.length > 0 ? Promise.all(pending).then(() => undefined) : undefined;
-    }
-}
-export 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);
-    }
-};

package/typings/hooks/HooksRunner.d.ts

@@ -1,19 +0,0 @@
-import { type CreateHookContext, type IHookContext } from './HookContext.js';
-import type { IContainer } from '../container/IContainer.js';
-import { type Instance } from '../utils/basic.js';
-import type { ExecutionContext } from '../ExecutionContext.js';
-export type MapHookContext = (context: IHookContext) => IHookContext;
-export type OnExceptionHandler = (ex: unknown, context: ExecutionContext) => void;
-export type HooksRunnerContext = {
-    scope: IContainer;
-    createContext?: CreateHookContext;
-    mapContext?: MapHookContext;
-    predicate?: (methodName: string) => boolean;
-};
-export declare class HooksRunner {
-    private readonly key;
-    constructor(key: string | symbol);
-    hasHooks(target: Instance): boolean;
-    execute(target: Instance, { scope, createContext, mapContext, predicate, }: HooksRunnerContext): void | Promise<void>;
-}
-export declare const runHooks: (runner: HooksRunner, target: Instance, scope: IContainer, onException?: OnExceptionHandler) => void;