ts-ioc-container 67.0.0 → 68.1.0

package/cjm/index.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.onConstruct = exports.injectProp = exports.createHookExecutionContext = exports.createHookContextFactory = exports.HookContext = exports.toHookFn = 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.runAtOnce = exports.runInOrder = 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.HookExecutionStrategy = exports.oncePerInstance = exports.parallel = exports.sequential = exports.resolved = exports.OnResolvedModule = exports.onResolved = exports.OnDisposeModule = exports.onScopeDisposed = exports.OnConstructModule = void 0;
-exports.Is = exports.unwrapProxy = exports.ProxyRegistry = exports.pipe = exports.select = exports.TypedEvent = exports.once = exports.shallowCache = exports.debounce = void 0;
+exports.injectProp = exports.createHookExecutionContext = exports.createHookContextFactory = exports.HookContext = exports.toHookFn = exports.hasHooks = exports.hook = exports.getHooks = exports.ArgumentNotFoundError = 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.pipe = exports.select = exports.TypedEvent = exports.getConstructorChain = exports.memoize = exports.once = exports.shallowCache = exports.debounce = exports.throttle = exports.runAtOnce = exports.runInOrder = 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.toTask = exports.HookCollector = exports.oncePerInstance = exports.parallel = exports.sequential = void 0;
+exports.Is = exports.unwrapProxy = exports.ProxyRegistry = exports.findOrFail = 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");
@@ -65,6 +65,8 @@ 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 ArgumentNotFoundError_1 = require("./errors/ArgumentNotFoundError");
+Object.defineProperty(exports, "ArgumentNotFoundError", { enumerable: true, get: function () { return ArgumentNotFoundError_1.ArgumentNotFoundError; } });
 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; } });
@@ -76,28 +78,13 @@ Object.defineProperty(exports, "createHookContextFactory", { enumerable: true, g
 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, "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, "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, "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 combinators_1 = require("./hooks/combinators");
 Object.defineProperty(exports, "sequential", { enumerable: true, get: function () { return combinators_1.sequential; } });
 Object.defineProperty(exports, "parallel", { enumerable: true, get: function () { return combinators_1.parallel; } });
 Object.defineProperty(exports, "oncePerInstance", { enumerable: true, get: function () { return combinators_1.oncePerInstance; } });
-var HookExecutionStrategy_1 = require("./hooks/HookExecutionStrategy");
-Object.defineProperty(exports, "HookExecutionStrategy", { enumerable: true, get: function () { return HookExecutionStrategy_1.HookExecutionStrategy; } });
-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 HookCollector_1 = require("./hooks/HookCollector");
+Object.defineProperty(exports, "HookCollector", { enumerable: true, get: function () { return HookCollector_1.HookCollector; } });
+Object.defineProperty(exports, "toTask", { enumerable: true, get: function () { return HookCollector_1.toTask; } });
 var InjectionToken_1 = require("./token/InjectionToken");
 Object.defineProperty(exports, "InjectionToken", { enumerable: true, get: function () { return InjectionToken_1.InjectionToken; } });
 var toToken_1 = require("./token/toToken");
@@ -157,12 +144,18 @@ 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 memoize_1 = require("./utils/memoize");
+Object.defineProperty(exports, "memoize", { enumerable: true, get: function () { return memoize_1.memoize; } });
+var getConstructorChain_1 = require("./utils/getConstructorChain");
+Object.defineProperty(exports, "getConstructorChain", { enumerable: true, get: function () { return getConstructorChain_1.getConstructorChain; } });
 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");
 Object.defineProperty(exports, "pipe", { enumerable: true, get: function () { return fp_1.pipe; } });
+var array_1 = require("./utils/array");
+Object.defineProperty(exports, "findOrFail", { enumerable: true, get: function () { return array_1.findOrFail; } });
 var ProxyRegistry_1 = require("./utils/ProxyRegistry");
 Object.defineProperty(exports, "ProxyRegistry", { enumerable: true, get: function () { return ProxyRegistry_1.ProxyRegistry; } });
 Object.defineProperty(exports, "unwrapProxy", { enumerable: true, get: function () { return ProxyRegistry_1.unwrapProxy; } });

package/cjm/utils/array.js

@@ -1,9 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Filter = void 0;
+exports.findOrFail = exports.Filter = void 0;
+const ArgumentNotFoundError_1 = require("../errors/ArgumentNotFoundError");
 exports.Filter = {
     exclude: (arr) => {
         const excludeSet = arr instanceof Array ? new Set(arr) : arr;
         return (v) => !excludeSet.has(v);
     },
 };
+const findOrFail = (predicate) => (...args) => {
+    const index = args.findIndex((arg) => predicate(arg));
+    if (index === -1) {
+        throw new ArgumentNotFoundError_1.ArgumentNotFoundError();
+    }
+    return args[index];
+};
+exports.findOrFail = findOrFail;

package/cjm/utils/getConstructorChain.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConstructorChain = void 0;
+const getConstructorChain = (ctor) => {
+    const chain = [];
+    let current = ctor;
+    while (typeof current === 'function' && current !== Function.prototype) {
+        chain.push(current);
+        current = Object.getPrototypeOf(current);
+    }
+    return chain;
+};
+exports.getConstructorChain = getConstructorChain;

package/cjm/utils/memoize.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.memoize = void 0;
+const memoize = (fn) => {
+    const cache = new WeakMap();
+    return (target, key) => {
+        let byKey = cache.get(target);
+        if (!byKey) {
+            byKey = new Map();
+            cache.set(target, byKey);
+        }
+        if (!byKey.has(key)) {
+            byKey.set(key, fn(target, key));
+        }
+        return byKey.get(key);
+    };
+};
+exports.memoize = memoize;

package/esm/errors/ArgumentNotFoundError.js

@@ -0,0 +1,8 @@
+import { ContainerError } from './ContainerError.js';
+export class ArgumentNotFoundError extends ContainerError {
+    name = 'ArgumentNotFoundError';
+    constructor(message = 'Argument not found') {
+        super(message);
+        Object.setPrototypeOf(this, ArgumentNotFoundError.prototype);
+    }
+}

package/esm/hooks/HookCollector.js

@@ -0,0 +1,29 @@
+import { resolveConstructor } from '../metadata/target.js';
+import { memoize } from '../utils/memoize.js';
+import { getHooks, hasHooks, toHookFn } from './hook.js';
+import { createHookExecutionContext } from './HookContext.js';
+export class HookCollector {
+    key;
+    options;
+    hooksOf = memoize(getHooks);
+    constructor({ key, createExecutionContext = createHookExecutionContext, mapExecutionContext = (context) => context, predicate = () => true, }) {
+        this.key = key;
+        this.options = { createExecutionContext, mapExecutionContext, predicate };
+    }
+    hasHooks(target) {
+        return hasHooks(target, this.key);
+    }
+    getActions(target, { scope, createExecutionContext = this.options.createExecutionContext, mapExecutionContext = this.options.mapExecutionContext, predicate = this.options.predicate, }) {
+        const actions = [];
+        for (const [methodName, fn] of this.hooksOf(resolveConstructor(target), this.key)) {
+            if (predicate(methodName)) {
+                actions.push({
+                    hook: toHookFn(fn),
+                    context: mapExecutionContext(createExecutionContext(target, scope, methodName)),
+                });
+            }
+        }
+        return actions;
+    }
+}
+export const toTask = ({ hook, context }) => () => hook(context);

package/esm/hooks/hook.js

@@ -1,18 +1,10 @@
 import { Is } from '../utils/basic.js';
 import { resolveConstructor } from '../metadata/target.js';
+import { getConstructorChain } from '../utils/getConstructorChain.js';
 const isHookClassConstructor = (execute) => {
     return Is.constructor(execute) && execute.prototype.execute;
 };
 export const toHookFn = (execute) => isHookClassConstructor(execute) ? (context) => context.scope.resolve(execute).execute(context) : execute;
-const getConstructorChain = (ctor) => {
-    const chain = [];
-    let current = ctor;
-    while (typeof current === 'function' && current !== Function.prototype) {
-        chain.push(current);
-        current = Object.getPrototypeOf(current);
-    }
-    return chain;
-};
 export function getHooks(target, key) {
     const merged = new Map();
     for (const ctor of getConstructorChain(resolveConstructor(target)).reverse()) {

package/esm/index.js

@@ -19,17 +19,12 @@ 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 { ArgumentNotFoundError } from './errors/ArgumentNotFoundError.js';
 export { getHooks, hook, hasHooks, toHookFn, } from './hooks/hook.js';
 export { HookContext, createHookContextFactory, createHookExecutionContext, } from './hooks/HookContext.js';
 export { injectProp } from './hooks/injectProp.js';
-export { onConstruct, OnConstructModule } from './hooks/onConstruct.js';
-export { onScopeDisposed, OnDisposeModule } from './hooks/onScopeDisposed.js';
-export { onResolved, OnResolvedModule, resolved } from './hooks/onResolved.js';
 export { sequential, parallel, oncePerInstance } from './hooks/combinators.js';
-export { HookExecutionStrategy, } from './hooks/HookExecutionStrategy.js';
-export { SequentialSync } from './hooks/SequentialSync.js';
-export { SequentialAsync } from './hooks/SequentialAsync.js';
-export { ParallelAsync } from './hooks/ParallelAsync.js';
+export { HookCollector, toTask, } from './hooks/HookCollector.js';
 export { InjectionToken } from './token/InjectionToken.js';
 export { toToken, toMappedToken, argToToken } from './token/toToken.js';
 export { GroupAliasToken, toGroupAlias } from './token/GroupAliasToken.js';
@@ -49,8 +44,11 @@ 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 { memoize } from './utils/memoize.js';
+export { getConstructorChain } from './utils/getConstructorChain.js';
 export { TypedEvent } from './utils/TypedEvent.js';
 export { select } from './select.js';
 export { pipe } from './utils/fp.js';
+export { findOrFail } from './utils/array.js';
 export { ProxyRegistry, unwrapProxy } from './utils/ProxyRegistry.js';
 export { Is } from './utils/basic.js';

package/esm/utils/array.js

@@ -1,6 +1,14 @@
+import { ArgumentNotFoundError } from '../errors/ArgumentNotFoundError.js';
 export const Filter = {
     exclude: (arr) => {
         const excludeSet = arr instanceof Array ? new Set(arr) : arr;
         return (v) => !excludeSet.has(v);
     },
 };
+export const findOrFail = (predicate) => (...args) => {
+    const index = args.findIndex((arg) => predicate(arg));
+    if (index === -1) {
+        throw new ArgumentNotFoundError();
+    }
+    return args[index];
+};

package/esm/utils/getConstructorChain.js

@@ -0,0 +1,9 @@
+export const getConstructorChain = (ctor) => {
+    const chain = [];
+    let current = ctor;
+    while (typeof current === 'function' && current !== Function.prototype) {
+        chain.push(current);
+        current = Object.getPrototypeOf(current);
+    }
+    return chain;
+};

package/esm/utils/memoize.js

@@ -0,0 +1,14 @@
+export const memoize = (fn) => {
+    const cache = new WeakMap();
+    return (target, key) => {
+        let byKey = cache.get(target);
+        if (!byKey) {
+            byKey = new Map();
+            cache.set(target, byKey);
+        }
+        if (!byKey.has(key)) {
+            byKey.set(key, fn(target, key));
+        }
+        return byKey.get(key);
+    };
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-ioc-container",
-  "version": "67.0.0",
+  "version": "68.1.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/errors/ArgumentNotFoundError.d.ts

@@ -0,0 +1,5 @@
+import { ContainerError } from './ContainerError.js';
+export declare class ArgumentNotFoundError extends ContainerError {
+    name: string;
+    constructor(message?: string);
+}

package/typings/hooks/HookCollector.d.ts

@@ -0,0 +1,28 @@
+import type { ExecutionContext } from '../ExecutionContext.js';
+import { type Task } from '../utils/task.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 HookAction = {
+    hook: HookFn;
+    context: IHookContext;
+};
+export type HookCollectorOptions = {
+    createExecutionContext?: CreateHookExecutionContext;
+    mapExecutionContext?: MapHookExecutionContext;
+    predicate?: (methodName: string) => boolean;
+};
+export type HookCollectionContext = ExecutionContext & HookCollectorOptions;
+export type HookCollectorProps = HookCollectorOptions & {
+    key: string | symbol;
+};
+export declare class HookCollector {
+    private readonly key;
+    private readonly options;
+    private readonly hooksOf;
+    constructor({ key, createExecutionContext, mapExecutionContext, predicate, }: HookCollectorProps);
+    hasHooks(target: Instance): boolean;
+    getActions(target: Instance, { scope, createExecutionContext, mapExecutionContext, predicate, }: HookCollectionContext): HookAction[];
+}
+export declare const toTask: ({ hook, context }: HookAction) => Task;

package/typings/index.d.ts

@@ -20,17 +20,12 @@ 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 { ArgumentNotFoundError } from './errors/ArgumentNotFoundError.js';
 export { getHooks, hook, hasHooks, toHookFn, type HookFn, type HookClass, type HookType, type InjectFn, type HooksOfClass, } from './hooks/hook.js';
 export { HookContext, createHookContextFactory, createHookExecutionContext, type CreateHookExecutionContext, type IHookContext, } from './hooks/HookContext.js';
 export { injectProp } from './hooks/injectProp.js';
-export { onConstruct, OnConstructModule } from './hooks/onConstruct.js';
-export { onScopeDisposed, OnDisposeModule } from './hooks/onScopeDisposed.js';
-export { onResolved, OnResolvedModule, resolved } from './hooks/onResolved.js';
 export { sequential, parallel, oncePerInstance, type ResolvedObjectHook } from './hooks/combinators.js';
-export { HookExecutionStrategy, type HookExecutionContext, type HookExecutionOptions, type HookExecutionStrategyProps, type MapHookExecutionContext, type MemberHook, type OnErrorHandler, } from './hooks/HookExecutionStrategy.js';
-export { SequentialSync } from './hooks/SequentialSync.js';
-export { SequentialAsync } from './hooks/SequentialAsync.js';
-export { ParallelAsync } from './hooks/ParallelAsync.js';
+export { HookCollector, toTask, type HookAction, type HookCollectionContext, type HookCollectorOptions, type HookCollectorProps, type MapHookExecutionContext, } from './hooks/HookCollector.js';
 export { InjectionToken } from './token/InjectionToken.js';
 export { type Injectable, toToken, toMappedToken, argToToken } from './token/toToken.js';
 export { GroupAliasToken, toGroupAlias } from './token/GroupAliasToken.js';
@@ -50,9 +45,12 @@ 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 { memoize } from './utils/memoize.js';
+export { getConstructorChain } from './utils/getConstructorChain.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';
+export { findOrFail, type Predicate } from './utils/array.js';
 export { ProxyRegistry, unwrapProxy, type IProxyRegistry } from './utils/ProxyRegistry.js';
 export { type Branded, type constructor, type Instance, Is } from './utils/basic.js';

package/typings/utils/array.d.ts

@@ -1,3 +1,5 @@
+export type Predicate<T> = (value: T) => boolean;
 export declare const Filter: {
     exclude: <T>(arr: Set<T> | T[]) => (v: T) => boolean;
 };
+export declare const findOrFail: <T>(predicate: Predicate<T>) => (...args: unknown[]) => T;

package/typings/utils/getConstructorChain.d.ts

@@ -0,0 +1 @@
+export declare const getConstructorChain: (ctor: unknown) => object[];

package/typings/utils/memoize.d.ts

@@ -0,0 +1 @@
+export declare const memoize: <T extends object, K, R>(fn: (target: T, key: K) => R) => ((target: T, key: K) => R);

package/cjm/hooks/HookExecutionStrategy.js

@@ -1,48 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HookExecutionStrategy = void 0;
-const target_1 = require("../metadata/target");
-const hook_1 = require("./hook");
-const HookContext_1 = require("./HookContext");
-class HookExecutionStrategy {
-    key;
-    onError;
-    options;
-    hooksByClass = new WeakMap();
-    constructor({ key, onError, createExecutionContext = HookContext_1.createHookExecutionContext, mapExecutionContext = (context) => context, predicate = () => true, }) {
-        this.key = key;
-        this.onError = onError;
-        this.options = { createExecutionContext, mapExecutionContext, predicate };
-    }
-    hasHooks(target) {
-        return (0, hook_1.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, hook } of this.hooksOf(target)) {
-            if (predicate(methodName)) {
-                members.push({ hook, context: mapExecutionContext(createExecutionContext(target, scope, methodName)) });
-            }
-        }
-        return members;
-    }
-    hooksOf(target) {
-        const Target = (0, target_1.resolveConstructor)(target);
-        let hooks = this.hooksByClass.get(Target);
-        if (!hooks) {
-            hooks = Array.from((0, hook_1.getHooks)(Target, this.key), ([methodName, fn]) => ({ methodName, hook: (0, hook_1.toHookFn)(fn) }));
-            this.hooksByClass.set(Target, hooks);
-        }
-        return hooks;
-    }
-}
-exports.HookExecutionStrategy = HookExecutionStrategy;

package/cjm/hooks/ParallelAsync.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ParallelAsync = void 0;
-const HookExecutionStrategy_1 = require("./HookExecutionStrategy");
-const task_1 = require("../utils/task");
-class ParallelAsync extends HookExecutionStrategy_1.HookExecutionStrategy {
-    processHooks(members) {
-        return (0, task_1.runAtOnce)(members.map(({ hook, context }) => () => hook(context)));
-    }
-}
-exports.ParallelAsync = ParallelAsync;

package/cjm/hooks/SequentialAsync.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SequentialAsync = void 0;
-const HookExecutionStrategy_1 = require("./HookExecutionStrategy");
-const task_1 = require("../utils/task");
-class SequentialAsync extends HookExecutionStrategy_1.HookExecutionStrategy {
-    processHooks(members) {
-        return (0, task_1.runInOrder)(members.map(({ hook, context }) => () => hook(context)));
-    }
-}
-exports.SequentialAsync = SequentialAsync;

package/cjm/hooks/SequentialSync.js

@@ -1,12 +0,0 @@
-"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 { hook, context } of members) {
-            hook(context);
-        }
-    }
-}
-exports.SequentialSync = SequentialSync;

package/cjm/hooks/onConstruct.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OnConstructModule = exports.onConstruct = void 0;
-const hook_1 = require("./hook");
-const onConstruct = (fn) => (0, hook_1.hook)('onConstruct', fn);
-exports.onConstruct = onConstruct;
-class OnConstructModule {
-    strategy;
-    constructor(strategy) {
-        this.strategy = strategy;
-    }
-    applyTo(container) {
-        container.getInjector().onConstructed((instance, scope) => {
-            this.strategy.execute(instance, { scope });
-        });
-    }
-}
-exports.OnConstructModule = OnConstructModule;

package/cjm/hooks/onResolved.js

@@ -1,27 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolved = exports.OnResolvedModule = exports.onResolved = void 0;
-const IRegistration_1 = require("../registration/IRegistration");
-const basic_1 = require("../utils/basic");
-const hook_1 = require("./hook");
-const onResolved = (fn) => (0, hook_1.hook)('onResolved', fn);
-exports.onResolved = onResolved;
-const runHooks = (strategy) => (dependency, scope) => {
-    if (basic_1.Is.object(dependency)) {
-        strategy.execute(dependency, { scope });
-    }
-};
-class OnResolvedModule {
-    runHooks;
-    constructor(strategy) {
-        this.runHooks = runHooks(strategy);
-    }
-    applyTo(container) {
-        container.registered.subscribe((provider) => {
-            provider.onResolved(this.runHooks);
-        });
-    }
-}
-exports.OnResolvedModule = OnResolvedModule;
-const resolved = (strategy) => (0, IRegistration_1.registerPipe)((p) => p.onResolved(runHooks(strategy)));
-exports.resolved = resolved;

package/cjm/hooks/onScopeDisposed.js

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

package/esm/hooks/HookExecutionStrategy.js

@@ -1,44 +0,0 @@
-import { resolveConstructor } from '../metadata/target.js';
-import { getHooks, hasHooks, toHookFn } from './hook.js';
-import { createHookExecutionContext } from './HookContext.js';
-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, hook } of this.hooksOf(target)) {
-            if (predicate(methodName)) {
-                members.push({ hook, 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, fn]) => ({ methodName, hook: toHookFn(fn) }));
-            this.hooksByClass.set(Target, hooks);
-        }
-        return hooks;
-    }
-}

package/esm/hooks/ParallelAsync.js

@@ -1,7 +0,0 @@
-import { HookExecutionStrategy } from './HookExecutionStrategy.js';
-import { runAtOnce } from '../utils/task.js';
-export class ParallelAsync extends HookExecutionStrategy {
-    processHooks(members) {
-        return runAtOnce(members.map(({ hook, context }) => () => hook(context)));
-    }
-}

package/esm/hooks/SequentialAsync.js

@@ -1,7 +0,0 @@
-import { HookExecutionStrategy } from './HookExecutionStrategy.js';
-import { runInOrder } from '../utils/task.js';
-export class SequentialAsync extends HookExecutionStrategy {
-    processHooks(members) {
-        return runInOrder(members.map(({ hook, context }) => () => hook(context)));
-    }
-}

package/esm/hooks/SequentialSync.js

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

package/esm/hooks/onConstruct.js

@@ -1,13 +0,0 @@
-import { hook } from './hook.js';
-export const onConstruct = (fn) => hook('onConstruct', fn);
-export class OnConstructModule {
-    strategy;
-    constructor(strategy) {
-        this.strategy = strategy;
-    }
-    applyTo(container) {
-        container.getInjector().onConstructed((instance, scope) => {
-            this.strategy.execute(instance, { scope });
-        });
-    }
-}

package/esm/hooks/onResolved.js

@@ -1,21 +0,0 @@
-import { registerPipe } from '../registration/IRegistration.js';
-import { Is } from '../utils/basic.js';
-import { hook } from './hook.js';
-export const onResolved = (fn) => hook('onResolved', fn);
-const runHooks = (strategy) => (dependency, scope) => {
-    if (Is.object(dependency)) {
-        strategy.execute(dependency, { scope });
-    }
-};
-export class OnResolvedModule {
-    runHooks;
-    constructor(strategy) {
-        this.runHooks = runHooks(strategy);
-    }
-    applyTo(container) {
-        container.registered.subscribe((provider) => {
-            provider.onResolved(this.runHooks);
-        });
-    }
-}
-export const resolved = (strategy) => registerPipe((p) => p.onResolved(runHooks(strategy)));