ts-ioc-container 60.3.0 → 62.0.0

package/cjm/index.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createHookContextFactory = exports.HookContext = exports.prepend = exports.append = exports.prependHooks = exports.appendHooks = exports.hasHooks = exports.hook = exports.getHooks = exports.UnsupportedTokenTypeError = exports.CannonSingletonApplyTwiceError = exports.UnexpectedHookResultError = 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.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.HooksRunner = exports.invokeMethod = exports.resolvedAsync = exports.OnResolvedAsyncModule = exports.onceResolvedAsync = exports.onResolvedAsync = exports.onResolvedAsyncHooksRunner = exports.resolved = exports.OnResolvedModule = exports.onceResolved = exports.onResolved = exports.onResolvedHooksRunner = exports.OnDisposeModule = exports.onContainerDisposed = exports.onContainerDisposedHooksRunner = exports.OnConstructAsyncModule = exports.onConstructAsync = exports.onConstructAsyncHooksRunner = exports.OnConstructModule = exports.onConstruct = exports.onConstructHooksRunner = exports.injectProp = exports.createHookContext = void 0;
-exports.Is = exports.unwrapProxy = exports.ProxyRegistry = exports.pipe = exports.select = exports.once = exports.shallowCache = exports.debounce = exports.throttle = exports.handleAsyncError = exports.handleError = exports.getMethodTags = exports.addMethodTag = exports.getMethodLabels = exports.addMethodLabel = exports.getMethodMeta = void 0;
+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.invokeMethod = exports.resolved = exports.OnResolvedModule = exports.onceResolved = 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;
 var IContainer_1 = require("./container/IContainer");
 Object.defineProperty(exports, "isDependencyKey", { enumerable: true, get: function () { return IContainer_1.isDependencyKey; } });
 var Container_1 = require("./container/Container");
@@ -59,8 +59,6 @@ var ContainerDisposedError_1 = require("./errors/ContainerDisposedError");
 Object.defineProperty(exports, "ContainerDisposedError", { enumerable: true, get: function () { return ContainerDisposedError_1.ContainerDisposedError; } });
 var ProviderDisposedError_1 = require("./errors/ProviderDisposedError");
 Object.defineProperty(exports, "ProviderDisposedError", { enumerable: true, get: function () { return ProviderDisposedError_1.ProviderDisposedError; } });
-var UnexpectedHookResultError_1 = require("./errors/UnexpectedHookResultError");
-Object.defineProperty(exports, "UnexpectedHookResultError", { enumerable: true, get: function () { return UnexpectedHookResultError_1.UnexpectedHookResultError; } });
 var CannonSingletonApplyTwiceError_1 = require("./errors/CannonSingletonApplyTwiceError");
 Object.defineProperty(exports, "CannonSingletonApplyTwiceError", { enumerable: true, get: function () { return CannonSingletonApplyTwiceError_1.CannonSingletonApplyTwiceError; } });
 var UnsupportedTokenTypeError_1 = require("./errors/UnsupportedTokenTypeError");
@@ -83,30 +81,21 @@ 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 onConstructAsync_1 = require("./hooks/onConstructAsync");
-Object.defineProperty(exports, "onConstructAsyncHooksRunner", { enumerable: true, get: function () { return onConstructAsync_1.onConstructAsyncHooksRunner; } });
-Object.defineProperty(exports, "onConstructAsync", { enumerable: true, get: function () { return onConstructAsync_1.onConstructAsync; } });
-Object.defineProperty(exports, "OnConstructAsyncModule", { enumerable: true, get: function () { return onConstructAsync_1.OnConstructAsyncModule; } });
-var onContainerDisposed_1 = require("./hooks/onContainerDisposed");
-Object.defineProperty(exports, "onContainerDisposedHooksRunner", { enumerable: true, get: function () { return onContainerDisposed_1.onContainerDisposedHooksRunner; } });
-Object.defineProperty(exports, "onContainerDisposed", { enumerable: true, get: function () { return onContainerDisposed_1.onContainerDisposed; } });
-Object.defineProperty(exports, "OnDisposeModule", { enumerable: true, get: function () { return onContainerDisposed_1.OnDisposeModule; } });
+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, "onceResolved", { enumerable: true, get: function () { return onResolved_1.onceResolved; } });
 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 onResolvedAsync_1 = require("./hooks/onResolvedAsync");
-Object.defineProperty(exports, "onResolvedAsyncHooksRunner", { enumerable: true, get: function () { return onResolvedAsync_1.onResolvedAsyncHooksRunner; } });
-Object.defineProperty(exports, "onResolvedAsync", { enumerable: true, get: function () { return onResolvedAsync_1.onResolvedAsync; } });
-Object.defineProperty(exports, "onceResolvedAsync", { enumerable: true, get: function () { return onResolvedAsync_1.onceResolvedAsync; } });
-Object.defineProperty(exports, "OnResolvedAsyncModule", { enumerable: true, get: function () { return onResolvedAsync_1.OnResolvedAsyncModule; } });
-Object.defineProperty(exports, "resolvedAsync", { enumerable: true, get: function () { return onResolvedAsync_1.resolvedAsync; } });
 var resolveHooks_1 = require("./hooks/resolveHooks");
 Object.defineProperty(exports, "invokeMethod", { enumerable: true, get: function () { return resolveHooks_1.invokeMethod; } });
 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 InjectionToken_1 = require("./token/InjectionToken");
 Object.defineProperty(exports, "InjectionToken", { enumerable: true, get: function () { return InjectionToken_1.InjectionToken; } });
 var toToken_1 = require("./token/toToken");

package/cjm/injector/IInjector.js

@@ -4,6 +4,7 @@ exports.Injector = void 0;
 const ProxyRegistry_1 = require("../utils/ProxyRegistry");
 class Injector {
     proxyRegistry;
+    onConstructedHookList = [];
     constructor(proxyRegistry = ProxyRegistry_1.ProxyRegistry.getInstance()) {
         this.proxyRegistry = proxyRegistry;
     }
@@ -11,8 +12,19 @@ class Injector {
         return this.proxyRegistry.toLazyIf(() => {
             const instance = this.createInstance(scope, Target, { args });
             scope.addInstance(instance);
+            for (const onConstructed of this.onConstructedHookList) {
+                onConstructed(instance, scope);
+            }
             return instance;
         }, lazy);
     }
+    onConstructed(...hooks) {
+        this.onConstructedHookList.push(...hooks);
+        return this;
+    }
+    useModule(module) {
+        module.applyTo(this);
+        return this;
+    }
 }
 exports.Injector = Injector;

package/cjm/provider/Provider.js

@@ -22,7 +22,7 @@ class Provider {
     cache = new Map();
     getKey;
     isDisposed = false;
-    onResolveHookList = [];
+    onResolvedHookList = [];
     constructor(resolveDependency) {
         this.resolveDependency = resolveDependency;
     }
@@ -43,8 +43,8 @@ class Provider {
             lazy: lazy ?? this.isLazy,
         });
         dependency = this.mappers.reduce((acc, current) => current(acc, scope), dependency);
-        for (const onResolve of this.onResolveHookList) {
-            onResolve(dependency, scope);
+        for (const onResolved of this.onResolvedHookList) {
+            onResolved(dependency, scope);
         }
         return dependency;
     }
@@ -81,8 +81,8 @@ class Provider {
         this.getKey = getCacheKey;
         return this;
     }
-    onResolve(...hooks) {
-        this.onResolveHookList.push(...hooks);
+    onResolved(...hooks) {
+        this.onResolvedHookList.push(...hooks);
         return this;
     }
     dispose() {
@@ -94,7 +94,7 @@ class Provider {
         this.accessRules.splice(0, this.accessRules.length);
         this.mappers.splice(0, this.mappers.length);
         this.argsFnList.splice(0, this.argsFnList.length);
-        this.onResolveHookList.splice(0, this.onResolveHookList.length);
+        this.onResolvedHookList.splice(0, this.onResolvedHookList.length);
     }
 }
 exports.Provider = Provider;

package/cjm/registration/IRegistration.js

@@ -54,5 +54,5 @@ const decorate = (...fns) => (0, exports.registerPipe)((p) => p.map(...fns));
 exports.decorate = decorate;
 const singleton = (getCacheKey) => (0, exports.registerPipe)((p) => p.singleton(getCacheKey));
 exports.singleton = singleton;
-const onResolve = (...hooks) => (0, exports.registerPipe)((p) => p.onResolve(...hooks));
+const onResolve = (...hooks) => (0, exports.registerPipe)((p) => p.onResolved(...hooks));
 exports.onResolve = onResolve;

package/esm/container/Container.js

@@ -16,10 +16,9 @@ export class Container {
     providers = new Map();
     aliases = new AliasMap();
     injector;
-    onConstructHookList = [];
-    onDisposeHookList = [];
     onScopeCreatedHookList = [];
-    onProviderRegisteredHookList = [];
+    onScopeDisposedHookList = [];
+    onRegisteredHookList = [];
     constructor(options = {}) {
         this.injector = options.injector ?? new MetadataInjector();
         this.parent = options.parent ?? new EmptyContainer();
@@ -29,8 +28,8 @@ export class Container {
         this.validateContainer();
         this.providers.set(key, provider);
         this.aliases.setAliasesByKey(key, aliases);
-        for (const onProviderRegistered of this.onProviderRegisteredHookList) {
-            onProviderRegistered(provider, key, this);
+        for (const onRegistered of this.onRegisteredHookList) {
+            onRegistered(provider, key, this);
         }
         return this;
     }
@@ -75,10 +74,9 @@ export class Container {
     createScope({ tags } = {}) {
         this.validateContainer();
         const scope = new Container({ injector: this.injector, parent: this, tags })
-            .onConstruct(...this.onConstructHookList)
-            .onInstanceDisposed(...this.onDisposeHookList)
             .onScopeCreated(...this.onScopeCreatedHookList)
-            .onProviderRegistered(...this.onProviderRegisteredHookList);
+            .onScopeDisposed(...this.onScopeDisposedHookList)
+            .onRegistered(...this.onRegisteredHookList);
         for (const registration of this.getRegistrations()) {
             registration.applyTo(scope);
         }
@@ -100,8 +98,8 @@ export class Container {
     dispose() {
         this.validateContainer();
         this.isDisposed = true;
-        for (const hook of this.onDisposeHookList) {
-            hook(this);
+        for (const onScopeDisposed of this.onScopeDisposedHookList) {
+            onScopeDisposed(this);
         }
         this.parent.removeScope(this);
         this.parent = new EmptyContainer();
@@ -112,10 +110,9 @@ export class Container {
         this.aliases.destroy();
         this.instances.clear();
         this.registrations = [];
-        this.onConstructHookList.length = 0;
-        this.onDisposeHookList.length = 0;
         this.onScopeCreatedHookList.length = 0;
-        this.onProviderRegisteredHookList.length = 0;
+        this.onScopeDisposedHookList.length = 0;
+        this.onRegisteredHookList.length = 0;
     }
     addRegistration(registration) {
         this.registrations.push(registration);
@@ -128,27 +125,20 @@ export class Container {
     hasRegistration(key) {
         return this.registrations.some((r) => r.getKeyOrFail() === key) || this.parent.hasRegistration(key);
     }
-    onConstruct(...hooks) {
-        this.onConstructHookList.push(...hooks);
-        return this;
-    }
-    onInstanceDisposed(...hooks) {
-        this.onDisposeHookList.push(...hooks);
-        return this;
-    }
     onScopeCreated(...hooks) {
         this.onScopeCreatedHookList.push(...hooks);
         return this;
     }
-    onProviderRegistered(...hooks) {
-        this.onProviderRegisteredHookList.push(...hooks);
+    onScopeDisposed(...hooks) {
+        this.onScopeDisposedHookList.push(...hooks);
+        return this;
+    }
+    onRegistered(...hooks) {
+        this.onRegisteredHookList.push(...hooks);
         return this;
     }
     addInstance(instance) {
         this.instances.add(instance);
-        for (const onConstruct of this.onConstructHookList) {
-            onConstruct(instance, this);
-        }
     }
     getScopes() {
         return [...this.scopes];

package/esm/container/EmptyContainer.js

@@ -57,16 +57,13 @@ export class EmptyContainer {
     resolveOneByAlias(alias, options) {
         throw new DependencyNotFoundError(`Cannot find alias ${alias.toString()}`);
     }
-    onInstanceDisposed(...hooks) {
-        throw new MethodNotImplementedError();
-    }
-    onConstruct(...hooks) {
+    onScopeCreated(...hooks) {
         throw new MethodNotImplementedError();
     }
-    onScopeCreated(...hooks) {
+    onScopeDisposed(...hooks) {
         throw new MethodNotImplementedError();
     }
-    onProviderRegistered(...hooks) {
+    onRegistered(...hooks) {
         throw new MethodNotImplementedError();
     }
 }

package/esm/hooks/HooksRunner.js

@@ -1,7 +1,13 @@
 import { createHookContext } from './HookContext.js';
 import { getHooks, hasHooks, toHookFn } from './hook.js';
-import { UnexpectedHookResultError } from '../errors/UnexpectedHookResultError.js';
-import { promisify } from '../utils/promise.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) {
@@ -12,27 +18,28 @@ export class HooksRunner {
     }
     execute(target, { scope, createContext = createHookContext, mapContext = (context) => context, predicate = () => true, }) {
         const hooks = Array.from(getHooks(target, this.key).entries()).filter(([methodName]) => predicate(methodName));
-        const runMethodHooks = (methodName, executions) => {
-            const context = mapContext(createContext(target, scope, methodName));
-            for (const execute of executions) {
-                const result = execute(context);
-                if (result instanceof Promise) {
-                    throw new UnexpectedHookResultError(`Hook ${methodName} returned a promise, use runHooksAsync instead`);
-                }
-            }
-        };
+        const pending = [];
         for (const [methodName, executions] of hooks) {
-            runMethodHooks(methodName, executions.map(toHookFn));
-        }
-    }
-    async executeAsync(target, { scope, createContext = createHookContext, mapContext = (context) => context, predicate = () => true, }) {
-        const hooks = Array.from(getHooks(target, this.key).entries()).filter(([methodName]) => predicate(methodName));
-        const runMethodHooks = async (methodName, executions) => {
             const context = mapContext(createContext(target, scope, methodName));
-            for (const execute of executions) {
-                await promisify(execute(context));
+            const result = runFrom(executions.map(toHookFn), 0, context);
+            if (result) {
+                pending.push(result);
             }
-        };
-        return Promise.all(hooks.map(([methodName, executions]) => runMethodHooks(methodName, executions.map(toHookFn))));
+        }
+        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/esm/hooks/onConstruct.js

@@ -1,5 +1,5 @@
 import { hook, prependHooks } from './hook.js';
-import { HooksRunner } from './HooksRunner.js';
+import { HooksRunner, runHooks } from './HooksRunner.js';
 export const onConstructHooksRunner = new HooksRunner('onConstruct');
 export const onConstruct = (...fns) => hook('onConstruct', prependHooks(...fns));
 export class OnConstructModule {
@@ -7,17 +7,9 @@ export class OnConstructModule {
     constructor(onException) {
         this.onException = onException;
     }
-    applyTo(container) {
-        container.onConstruct((instance, scope) => {
-            try {
-                onConstructHooksRunner.execute(instance, { scope });
-            }
-            catch (ex) {
-                if (!this.onException) {
-                    throw ex;
-                }
-                this.onException(ex, { scope });
-            }
+    applyTo(injector) {
+        injector.onConstructed((instance, scope) => {
+            runHooks(onConstructHooksRunner, instance, scope, this.onException);
         });
     }
 }

package/esm/hooks/onResolved.js

@@ -4,12 +4,16 @@ import { executeHooks, forEachResolvedObject, onceResolvedHook, resolvedHook } f
 export const onResolvedHooksRunner = new HooksRunner('onResolved');
 export const onResolved = resolvedHook('onResolved');
 export const onceResolved = onceResolvedHook('onResolved');
-const runHooks = forEachResolvedObject(executeHooks(onResolvedHooksRunner));
+const runHooks = (onException) => forEachResolvedObject(executeHooks(onResolvedHooksRunner, onException));
 export class OnResolvedModule {
+    runHooks;
+    constructor(onException) {
+        this.runHooks = runHooks(onException);
+    }
     applyTo(container) {
-        container.onProviderRegistered((provider) => {
-            provider.onResolve(runHooks);
+        container.onRegistered((provider) => {
+            provider.onResolved(this.runHooks);
         });
     }
 }
-export const resolved = () => registerPipe((p) => p.onResolve(runHooks));
+export const resolved = (onException) => registerPipe((p) => p.onResolved(runHooks(onException)));

package/esm/hooks/onScopeDisposed.js

@@ -0,0 +1,17 @@
+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;
+    }
+    applyTo(container) {
+        container.onScopeDisposed((scope) => {
+            for (const instance of scope.getInstances()) {
+                runHooks(onScopeDisposedHooksRunner, instance, scope, this.onException);
+            }
+        });
+    }
+}

package/esm/hooks/resolveHooks.js

@@ -1,3 +1,4 @@
+import { runHooks } from './HooksRunner.js';
 import { hook, prependHooks, toHookFn } from './hook.js';
 import { Is } from '../utils/basic.js';
 export const invokeMethod = (context) => {
@@ -21,15 +22,4 @@ export const forEachResolvedObject = (run) => (dependency, scope) => {
         run(dependency, scope);
     }
 };
-export const executeHooks = (runner) => (dependency, scope) => runner.execute(dependency, { scope });
-export const executeHooksAsync = (runner, onException) => (dependency, scope) => {
-    if (!runner.hasHooks(dependency)) {
-        return;
-    }
-    runner.executeAsync(dependency, { scope }).catch((ex) => {
-        if (!onException) {
-            throw ex;
-        }
-        onException(ex, { scope });
-    });
-};
+export const executeHooks = (runner, onException) => (dependency, scope) => runHooks(runner, dependency, scope, onException);

package/esm/index.js

@@ -2,7 +2,7 @@ export { isDependencyKey, } from './container/IContainer.js';
 export { Container } from './container/Container.js';
 export { AutoResolveModule } from './container/AutoResolveModule.js';
 export { EmptyContainer } from './container/EmptyContainer.js';
-export { Injector } from './injector/IInjector.js';
+export { Injector, } from './injector/IInjector.js';
 export { MetadataInjector, inject, arg, args, argsFn, resolveArgs } from './injector/MetadataInjector.js';
 export { SimpleInjector } from './injector/SimpleInjector.js';
 export { ProxyInjector } from './injector/ProxyInjector.js';
@@ -16,19 +16,16 @@ export { DependencyMissingKeyError } from './errors/DependencyMissingKeyError.js
 export { MethodNotImplementedError } from './errors/MethodNotImplementedError.js';
 export { ContainerDisposedError } from './errors/ContainerDisposedError.js';
 export { ProviderDisposedError } from './errors/ProviderDisposedError.js';
-export { UnexpectedHookResultError } from './errors/UnexpectedHookResultError.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 { injectProp } from './hooks/injectProp.js';
 export { onConstructHooksRunner, onConstruct, OnConstructModule } from './hooks/onConstruct.js';
-export { onConstructAsyncHooksRunner, onConstructAsync, OnConstructAsyncModule } from './hooks/onConstructAsync.js';
-export { onContainerDisposedHooksRunner, onContainerDisposed, OnDisposeModule } from './hooks/onContainerDisposed.js';
+export { onScopeDisposedHooksRunner, onScopeDisposed, OnDisposeModule } from './hooks/onScopeDisposed.js';
 export { onResolvedHooksRunner, onResolved, onceResolved, OnResolvedModule, resolved } from './hooks/onResolved.js';
-export { onResolvedAsyncHooksRunner, onResolvedAsync, onceResolvedAsync, OnResolvedAsyncModule, resolvedAsync, } from './hooks/onResolvedAsync.js';
 export { invokeMethod } from './hooks/resolveHooks.js';
-export { HooksRunner } from './hooks/HooksRunner.js';
+export { HooksRunner, runHooks, } from './hooks/HooksRunner.js';
 export { InjectionToken } from './token/InjectionToken.js';
 export { toToken, toMappedToken, argToToken } from './token/toToken.js';
 export { GroupAliasToken, toGroupAlias } from './token/GroupAliasToken.js';

package/esm/injector/IInjector.js

@@ -1,6 +1,7 @@
 import { ProxyRegistry } from '../utils/ProxyRegistry.js';
 export class Injector {
     proxyRegistry;
+    onConstructedHookList = [];
     constructor(proxyRegistry = ProxyRegistry.getInstance()) {
         this.proxyRegistry = proxyRegistry;
     }
@@ -8,7 +9,18 @@ export class Injector {
         return this.proxyRegistry.toLazyIf(() => {
             const instance = this.createInstance(scope, Target, { args });
             scope.addInstance(instance);
+            for (const onConstructed of this.onConstructedHookList) {
+                onConstructed(instance, scope);
+            }
             return instance;
         }, lazy);
     }
+    onConstructed(...hooks) {
+        this.onConstructedHookList.push(...hooks);
+        return this;
+    }
+    useModule(module) {
+        module.applyTo(this);
+        return this;
+    }
 }

package/esm/provider/Provider.js

@@ -19,7 +19,7 @@ export class Provider {
     cache = new Map();
     getKey;
     isDisposed = false;
-    onResolveHookList = [];
+    onResolvedHookList = [];
     constructor(resolveDependency) {
         this.resolveDependency = resolveDependency;
     }
@@ -40,8 +40,8 @@ export class Provider {
             lazy: lazy ?? this.isLazy,
         });
         dependency = this.mappers.reduce((acc, current) => current(acc, scope), dependency);
-        for (const onResolve of this.onResolveHookList) {
-            onResolve(dependency, scope);
+        for (const onResolved of this.onResolvedHookList) {
+            onResolved(dependency, scope);
         }
         return dependency;
     }
@@ -78,8 +78,8 @@ export class Provider {
         this.getKey = getCacheKey;
         return this;
     }
-    onResolve(...hooks) {
-        this.onResolveHookList.push(...hooks);
+    onResolved(...hooks) {
+        this.onResolvedHookList.push(...hooks);
         return this;
     }
     dispose() {
@@ -91,6 +91,6 @@ export class Provider {
         this.accessRules.splice(0, this.accessRules.length);
         this.mappers.splice(0, this.mappers.length);
         this.argsFnList.splice(0, this.argsFnList.length);
-        this.onResolveHookList.splice(0, this.onResolveHookList.length);
+        this.onResolvedHookList.splice(0, this.onResolvedHookList.length);
     }
 }

package/esm/registration/IRegistration.js

@@ -1,4 +1,4 @@
-import { isDependencyKey, } from '../container/IContainer.js';
+import { isDependencyKey } from '../container/IContainer.js';
 import { SingleToken } from '../token/SingleToken.js';
 import { addClassMeta, getClassMeta } from '../metadata/class.js';
 export const isProviderPipe = (obj) => obj !== null && typeof obj === 'object' && 'mapProvider' in obj;
@@ -35,4 +35,4 @@ export const lazy = () => registerPipe((p) => p.lazy());
 export const autoResolve = () => registerPipe((p) => p.autoResolve());
 export const decorate = (...fns) => registerPipe((p) => p.map(...fns));
 export const singleton = (getCacheKey) => registerPipe((p) => p.singleton(getCacheKey));
-export const onResolve = (...hooks) => registerPipe((p) => p.onResolve(...hooks));
+export const onResolve = (...hooks) => registerPipe((p) => p.onResolved(...hooks));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-ioc-container",
-  "version": "60.3.0",
+  "version": "62.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,7 @@
-import { type AutoResolveOptions, type CreateScopeOptions, type DependencyKey, type IContainer, type IContainerModule, type InstanceHook, type ProviderHook, type RegisterOptions, ResolveManyOptions, type ResolveOneOptions, type ScopeHook, type Tag } from './IContainer.js';
+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 IInjector } from '../injector/IInjector.js';
 import { type IProvider } from '../provider/IProvider.js';
 import { type IRegistration } from '../registration/IRegistration.js';
-import { OnDisposeHook } from '../hooks/onContainerDisposed.js';
 import { constructor, Instance } from '../utils/basic.js';
 export declare class Container implements IContainer {
     isDisposed: boolean;
@@ -14,10 +13,9 @@ export declare class Container implements IContainer {
     private readonly providers;
     private readonly aliases;
     private readonly injector;
-    private readonly onConstructHookList;
-    private readonly onDisposeHookList;
     private readonly onScopeCreatedHookList;
-    private readonly onProviderRegisteredHookList;
+    private readonly onScopeDisposedHookList;
+    private readonly onRegisteredHookList;
     constructor(options?: {
         injector?: IInjector;
         parent?: IContainer;
@@ -33,10 +31,9 @@ export declare class Container implements IContainer {
     addRegistration(registration: IRegistration): this;
     getRegistrations(): IRegistration[];
     hasRegistration(key: DependencyKey): boolean;
-    onConstruct(...hooks: InstanceHook[]): this;
-    onInstanceDisposed(...hooks: OnDisposeHook[]): this;
     onScopeCreated(...hooks: ScopeHook[]): this;
-    onProviderRegistered(...hooks: ProviderHook[]): 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,6 @@
-import { type AutoResolveOptions, type DependencyKey, type IContainer, type IContainerModule, type ScopeHook, type ProviderHook, type ResolveManyOptions, type ResolveOneOptions, type Tag, type InstanceHook } from './IContainer.js';
+import { type AutoResolveOptions, type DependencyKey, type IContainer, type IContainerModule, type ScopeHook, type RegisteredHook, type ResolveManyOptions, type ResolveOneOptions, type Tag } from './IContainer.js';
 import { type IProvider } from '../provider/IProvider.js';
 import { type IRegistration } from '../registration/IRegistration.js';
-import { OnDisposeHook } from '../hooks/onContainerDisposed.js';
 import { type constructor, type Instance } from '../utils/basic.js';
 export declare class EmptyContainer implements IContainer {
     get isDisposed(): boolean;
@@ -24,8 +23,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;
-    onInstanceDisposed(...hooks: OnDisposeHook[]): this;
-    onConstruct(...hooks: InstanceHook[]): this;
     onScopeCreated(...hooks: ScopeHook[]): this;
-    onProviderRegistered(...hooks: ProviderHook[]): this;
+    onScopeDisposed(...hooks: ScopeHook[]): this;
+    onRegistered(...hooks: RegisteredHook[]): this;
 }

package/typings/container/IContainer.d.ts

@@ -1,6 +1,5 @@
 import { type IProvider, ProviderOptions } from '../provider/IProvider.js';
 import { type IRegistration } from '../registration/IRegistration.js';
-import { OnDisposeHook } from '../hooks/onContainerDisposed.js';
 import { type WithArgs } from '../injector/IInjector.js';
 import { type constructor, Instance } from '../utils/basic.js';
 export type DependencyKey = string | symbol;
@@ -33,15 +32,12 @@ export type RegisterOptions = {
     aliases?: DependencyKey[];
 };
 export type ScopeHook = (scope: IContainer) => void;
-export type InstanceHook = (instance: Instance, scope: IContainer) => void;
-export type DependencyHook = (dependency: unknown, scope: IContainer) => void;
-export type ProviderHook = (provider: IProvider, key: DependencyKey, scope: IContainer) => void;
+export type RegisteredHook = (provider: IProvider, key: DependencyKey, scope: IContainer) => void;
 export interface IContainer extends Tagged {
     readonly isDisposed: boolean;
-    onConstruct(...hooks: InstanceHook[]): this;
-    onInstanceDisposed(...hooks: OnDisposeHook[]): this;
     onScopeCreated(...hooks: ScopeHook[]): this;
-    onProviderRegistered(...hooks: ProviderHook[]): this;
+    onScopeDisposed(...hooks: ScopeHook[]): this;
+    onRegistered(...hooks: RegisteredHook[]): this;
     register(key: DependencyKey, value: IProvider, options?: RegisterOptions): this;
     addRegistration(registration: IRegistration): this;
     getRegistrations(): IRegistration[];

package/typings/hooks/HooksRunner.d.ts

@@ -1,7 +1,9 @@
 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;
@@ -12,6 +14,6 @@ export declare class HooksRunner {
     private readonly key;
     constructor(key: string | symbol);
     hasHooks(target: Instance): boolean;
-    execute(target: Instance, { scope, createContext, mapContext, predicate, }: HooksRunnerContext): void;
-    executeAsync(target: Instance, { scope, createContext, mapContext, predicate, }: HooksRunnerContext): Promise<void[]>;
+    execute(target: Instance, { scope, createContext, mapContext, predicate, }: HooksRunnerContext): void | Promise<void>;
 }
+export declare const runHooks: (runner: HooksRunner, target: Instance, scope: IContainer, onException?: OnExceptionHandler) => void;