ts-ioc-container 61.0.0 → 62.0.0

package/README.md

@@ -18,7 +18,7 @@ provider pipelines, aliases, and custom injector strategies.
 - clean API for classes, keys, tokens, aliases, and scopes
 - no global container object; pass containers and scopes explicitly
 - supports tagged application, request, transaction, page, and widget scopes
-- decorator support with `@register`, `@inject`, `@onConstruct`, and `@onContainerDisposed`
+- decorator support with `@register`, `@inject`, `@onConstruct`, and `@onScopeDisposed`
 - can [inject properties](#inject-property)
 - can inject [lazy dependencies](#lazy)
 - composable provider and registration pipelines
@@ -56,8 +56,7 @@ provider pipelines, aliases, and custom injector strategies.
 - [Hook](#hook) `@hook`
   - [Hook domains](#hook-domains) `ScopeHook` `InjectorHook` `ProviderHook`
   - [OnConstruct](#onconstruct) `@onConstruct`
-  - [OnConstructAsync](#onconstructasync) `@onConstructAsync`
-  - [OnContainerDisposed](#oncontainerdisposed) `@onContainerDisposed`
+  - [OnScopeDisposed](#onscopedisposed) `@onScopeDisposed`
   - [Inject Property](#inject-property)
   - [Inject Method](#inject-method)
 - [Mock](#mock)
@@ -108,7 +107,7 @@ bundlers tree-shake unused exports.
 
 > [!NOTE]
 > The default `MetadataInjector` (and the `@inject` / `@onConstruct` /
-> `@onContainerDisposed` decorators) rely on `reflect-metadata`. It is declared as an
+> `@onScopeDisposed` decorators) rely on `reflect-metadata`. It is declared as an
 > optional peer dependency — install it and import it once at your entrypoint.
 > `SimpleInjector` and `ProxyInjector` do not need it.
 
@@ -455,7 +454,7 @@ describe('Instances', function () {
 Sometimes you want to dispose a container or scope. For example, when a request, page, widget, or other local lifecycle ends.
 
 - container can be disposed
-- when container is disposed then it runs its `onContainerDisposed` hooks, unregisters its providers, removes its local instances, and detaches from its parent
+- when container is disposed then it runs its `onScopeDisposed` hooks, unregisters its providers, removes its local instances, and detaches from its parent
 
 > [!IMPORTANT]
 > Dispose is local to the container being disposed. Child scopes are not disposed automatically; dispose them explicitly when their own lifecycle ends.
@@ -474,7 +473,7 @@ import { bindTo, Container, ContainerDisposedError, register, Registration as R,
  * - Cache entries cleared
  *
  * The container.dispose() method:
- * 1. Executes all onContainerDisposed hooks
+ * 1. Executes all onScopeDisposed hooks
  * 2. Clears all instances and registrations
  * 3. Detaches from parent scope
  * 4. Prevents further resolution
@@ -2829,10 +2828,27 @@ Decorators are applied bottom-up, so `authorize` runs first, then `validate` and
 `(...prev) => [...prev].reverse()` to reorder, or `() => [onlyThisOne]` to
 replace the accumulated hooks.
 
-`@onConstruct`, `@onConstructAsync` and `@onContainerDisposed` keep their
-variadic signature and compensate for the bottom-up application order, so
-stacked decorators run in declaration order: `@onConstruct(h1) @onConstruct(h2)`
-runs `h1` before `h2`.
+`@onConstruct` and `@onScopeDisposed` keep their variadic signature and
+compensate for the bottom-up application order, so stacked decorators run in
+declaration order: `@onConstruct(h1) @onConstruct(h2)` runs `h1` before `h2`.
+
+Every hook may be sync or async — one decorator and one module take both, so
+there is no separate async form to reach for. A `HooksRunner` runs a hook chain
+eagerly and stays synchronous until a hook returns a promise, then awaits the
+rest of that chain. Sync hooks therefore finish before `resolve` (or `dispose`)
+returns, exactly as before; async ones are started there and settle afterwards,
+so `resolve` returns before they finish. Instances that must expose readiness
+should publish it themselves, for example by storing the pending promise on the
+instance.
+
+`HooksRunner.execute` mirrors that: it returns `undefined` when nothing went
+async and a promise otherwise, so a caller running its own hooks can `await` the
+result either way.
+
+Every module takes an optional `onException` handler, and it catches both kinds
+of failure — what a sync hook threw and what an async hook rejected with.
+Without one, a sync hook throws out of the call and an async hook surfaces as an
+unhandled promise rejection.
 
 ### Hook domains
 
@@ -2866,9 +2882,8 @@ it was added. Scope hooks, by contrast, are copied into a child at `createScope`
 time, so a child inherits what its parent held then and later additions to either
 stay local.
 
-The built-in modules follow the same split. `OnConstructModule` and
-`OnConstructAsyncModule` are **injector** modules (`IInjectorModule`), applied
-with `injector.useModule(...)`:
+The built-in modules follow the same split. `OnConstructModule` is an
+**injector** module (`IInjectorModule`), applied with `injector.useModule(...)`:
 
 ```typescript
 const injector = new MetadataInjector().useModule(new OnConstructModule());
@@ -2876,8 +2891,8 @@ const container = new Container({ injector });
 ```
 
 `OnDisposeModule` is a container module hooking `onScopeDisposed`, and
-`OnResolvedModule` / `OnResolvedAsyncModule` are container modules reaching every
-provider through `onRegistered`.
+`OnResolvedModule` is a container module reaching every provider through
+`onRegistered`.
 
 ### OnConstruct
 
@@ -2899,6 +2914,10 @@ const execute: HookFn = (ctx) => {
   ctx.invokeMethod({ args: ctx.resolveArgs() });
 };
 
+const executeAsync: HookFn = async (ctx) => {
+  await ctx.invokeMethod({ args: ctx.resolveArgs() });
+};
+
 describe('onConstruct', function () {
   it('should run initialization method after dependencies are resolved', function () {
     class DatabaseConnection {
@@ -2983,34 +3002,7 @@ describe('onConstruct', function () {
 
     expect(scope).toBe(child);
   });
-});
 
-```
-
-### OnConstructAsync
-
-`@onConstructAsync` runs promise-returning initialization. Resolution stays
-synchronous: `OnConstructAsyncModule` starts the hooks when the instance
-is created and they settle afterwards, so `resolve` returns before they finish.
-
-```typescript
-import 'reflect-metadata';
-import {
-  MetadataInjector,
-  OnConstructAsyncModule,
-  Container,
-  type ExecutionContext,
-  type HookFn,
-  inject,
-  onConstructAsync,
-  Registration as R,
-} from 'ts-ioc-container';
-
-const execute: HookFn = async (ctx) => {
-  await ctx.invokeMethod({ args: ctx.resolveArgs() });
-};
-
-describe('onConstructAsync', function () {
   it('should run an async initialization method after the instance is created', async function () {
     class DatabaseConnection {
       isConnected = false;
@@ -3025,7 +3017,7 @@ describe('onConstructAsync', function () {
         });
       }
 
-      @onConstructAsync(execute)
+      @onConstruct(executeAsync)
       async connect(@inject('ConnectionString') connectionString: string) {
         await Promise.resolve();
         this.connectionString = connectionString;
@@ -3035,7 +3027,7 @@ describe('onConstructAsync', function () {
     }
 
     const container = new Container({
-      injector: new MetadataInjector().useModule(new OnConstructAsyncModule()),
+      injector: new MetadataInjector().useModule(new OnConstructModule()),
     }).addRegistration(R.fromValue('postgres://localhost:5432').bindTo('ConnectionString'));
 
     const db = container.resolve(DatabaseConnection);
@@ -3053,14 +3045,14 @@ describe('onConstructAsync', function () {
     const failure = new Error('boom');
 
     class BrokenService {
-      @onConstructAsync(() => Promise.reject(failure))
+      @onConstruct(() => Promise.reject(failure))
       init() {}
     }
 
     let captured: { ex: unknown; context: ExecutionContext } | undefined;
     const container = new Container({
       injector: new MetadataInjector().useModule(
-        new OnConstructAsyncModule((ex, context) => {
+        new OnConstructModule((ex, context) => {
           captured = { ex, context };
         }),
       ),
@@ -3078,7 +3070,7 @@ describe('onConstructAsync', function () {
 
 ```
 
-### OnContainerDisposed
+### OnScopeDisposed
 
 ```typescript
 import 'reflect-metadata';
@@ -3088,7 +3080,7 @@ import {
   Container,
   type HookFn,
   inject,
-  onContainerDisposed,
+  onScopeDisposed,
   register,
   Registration as R,
   singleton,
@@ -3117,13 +3109,13 @@ class Logger {
     this.messages.push(message);
   }
 
-  @onContainerDisposed(execute)
+  @onScopeDisposed(execute)
   save() {
     this.logsRepo.saveLogs(this.messages);
   }
 }
 
-describe('onContainerDisposed', function () {
+describe('onScopeDisposed', function () {
   it('should invoke hooks on all instances when container is disposed', function () {
     const container = new Container()
       .useModule(new OnDisposeModule())

package/cjm/hooks/HooksRunner.js

@@ -1,10 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HooksRunner = void 0;
+exports.runHooks = exports.HooksRunner = void 0;
 const HookContext_1 = require("./HookContext");
 const hook_1 = require("./hook");
-const UnexpectedHookResultError_1 = require("../errors/UnexpectedHookResultError");
-const promise_1 = require("../utils/promise");
+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) {
@@ -15,28 +21,30 @@ class HooksRunner {
     }
     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 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_1.UnexpectedHookResultError(`Hook ${methodName} returned a promise, use runHooksAsync instead`);
-                }
-            }
-        };
+        const pending = [];
         for (const [methodName, executions] of hooks) {
-            runMethodHooks(methodName, executions.map(hook_1.toHookFn));
-        }
-    }
-    async executeAsync(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 runMethodHooks = async (methodName, executions) => {
             const context = mapContext(createContext(target, scope, methodName));
-            for (const execute of executions) {
-                await (0, promise_1.promisify)(execute(context));
+            const result = runFrom(executions.map(hook_1.toHookFn), 0, context);
+            if (result) {
+                pending.push(result);
             }
-        };
-        return Promise.all(hooks.map(([methodName, executions]) => runMethodHooks(methodName, executions.map(hook_1.toHookFn))));
+        }
+        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/cjm/hooks/onConstruct.js

@@ -13,15 +13,7 @@ class OnConstructModule {
     }
     applyTo(injector) {
         injector.onConstructed((instance, scope) => {
-            try {
-                exports.onConstructHooksRunner.execute(instance, { scope });
-            }
-            catch (ex) {
-                if (!this.onException) {
-                    throw ex;
-                }
-                this.onException(ex, { scope });
-            }
+            (0, HooksRunner_1.runHooks)(exports.onConstructHooksRunner, instance, scope, this.onException);
         });
     }
 }

package/cjm/hooks/onResolved.js

@@ -7,14 +7,18 @@ const resolveHooks_1 = require("./resolveHooks");
 exports.onResolvedHooksRunner = new HooksRunner_1.HooksRunner('onResolved');
 exports.onResolved = (0, resolveHooks_1.resolvedHook)('onResolved');
 exports.onceResolved = (0, resolveHooks_1.onceResolvedHook)('onResolved');
-const runHooks = (0, resolveHooks_1.forEachResolvedObject)((0, resolveHooks_1.executeHooks)(exports.onResolvedHooksRunner));
+const runHooks = (onException) => (0, resolveHooks_1.forEachResolvedObject)((0, resolveHooks_1.executeHooks)(exports.onResolvedHooksRunner, onException));
 class OnResolvedModule {
+    runHooks;
+    constructor(onException) {
+        this.runHooks = runHooks(onException);
+    }
     applyTo(container) {
         container.onRegistered((provider) => {
-            provider.onResolved(runHooks);
+            provider.onResolved(this.runHooks);
         });
     }
 }
 exports.OnResolvedModule = OnResolvedModule;
-const resolved = () => (0, IRegistration_1.registerPipe)((p) => p.onResolved(runHooks));
+const resolved = (onException) => (0, IRegistration_1.registerPipe)((p) => p.onResolved(runHooks(onException)));
 exports.resolved = resolved;

package/cjm/hooks/onScopeDisposed.js

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

package/cjm/hooks/resolveHooks.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.executeHooksAsync = exports.executeHooks = exports.forEachResolvedObject = exports.onceResolvedHook = exports.resolvedHook = exports.invokeMethod = void 0;
+exports.executeHooks = exports.forEachResolvedObject = exports.onceResolvedHook = exports.resolvedHook = exports.invokeMethod = void 0;
+const HooksRunner_1 = require("./HooksRunner");
 const hook_1 = require("./hook");
 const basic_1 = require("../utils/basic");
 const invokeMethod = (context) => {
@@ -28,17 +29,5 @@ const forEachResolvedObject = (run) => (dependency, scope) => {
     }
 };
 exports.forEachResolvedObject = forEachResolvedObject;
-const executeHooks = (runner) => (dependency, scope) => runner.execute(dependency, { scope });
+const executeHooks = (runner, onException) => (dependency, scope) => (0, HooksRunner_1.runHooks)(runner, dependency, scope, onException);
 exports.executeHooks = executeHooks;
-const executeHooksAsync = (runner, onException) => (dependency, scope) => {
-    if (!runner.hasHooks(dependency)) {
-        return;
-    }
-    runner.executeAsync(dependency, { scope }).catch((ex) => {
-        if (!onException) {
-            throw ex;
-        }
-        onException(ex, { scope });
-    });
-};
-exports.executeHooksAsync = executeHooksAsync;

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/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 {
@@ -9,15 +9,7 @@ export class OnConstructModule {
     }
     applyTo(injector) {
         injector.onConstructed((instance, scope) => {
-            try {
-                onConstructHooksRunner.execute(instance, { scope });
-            }
-            catch (ex) {
-                if (!this.onException) {
-                    throw ex;
-                }
-                this.onException(ex, { 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.onRegistered((provider) => {
-            provider.onResolved(runHooks);
+            provider.onResolved(this.runHooks);
         });
     }
 }
-export const resolved = () => registerPipe((p) => p.onResolved(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

@@ -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/package.json

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

package/typings/hooks/onConstruct.d.ts

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

package/typings/hooks/onResolved.d.ts

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

package/typings/hooks/onScopeDisposed.d.ts

@@ -0,0 +1,10 @@
+import { HookType } from './hook.js';
+import type { IContainer, IContainerModule } from '../container/IContainer.js';
+import { HooksRunner, type OnExceptionHandler } from './HooksRunner.js';
+export declare const onScopeDisposedHooksRunner: HooksRunner;
+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);
+    applyTo(container: IContainer): void;
+}

package/typings/hooks/resolveHooks.d.ts

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

package/typings/index.d.ts

@@ -17,19 +17,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, 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 { injectProp } from './hooks/injectProp.js';
-export { onConstructHooksRunner, onConstruct, OnConstructModule, type OnExceptionHandler } from './hooks/onConstruct.js';
-export { onConstructAsyncHooksRunner, onConstructAsync, OnConstructAsyncModule } from './hooks/onConstructAsync.js';
-export { onContainerDisposedHooksRunner, onContainerDisposed, OnDisposeModule } from './hooks/onContainerDisposed.js';
+export { onConstructHooksRunner, onConstruct, OnConstructModule } from './hooks/onConstruct.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, type ResolvedObjectHook } from './hooks/resolveHooks.js';
-export { HooksRunner, type HooksRunnerContext, type MapHookContext } from './hooks/HooksRunner.js';
+export { HooksRunner, runHooks, type HooksRunnerContext, type MapHookContext, type OnExceptionHandler, } from './hooks/HooksRunner.js';
 export { InjectionToken } from './token/InjectionToken.js';
 export { type Injectable, toToken, toMappedToken, argToToken } from './token/toToken.js';
 export { GroupAliasToken, toGroupAlias } from './token/GroupAliasToken.js';

package/cjm/errors/UnexpectedHookResultError.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UnexpectedHookResultError = void 0;
-const ContainerError_1 = require("./ContainerError");
-class UnexpectedHookResultError extends ContainerError_1.ContainerError {
-    name = 'UnexpectedHookResultError';
-    constructor(message) {
-        super(message);
-        Object.setPrototypeOf(this, UnexpectedHookResultError.prototype);
-    }
-}
-exports.UnexpectedHookResultError = UnexpectedHookResultError;

package/cjm/hooks/onConstructAsync.js

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OnConstructAsyncModule = exports.onConstructAsync = exports.onConstructAsyncHooksRunner = void 0;
-const hook_1 = require("./hook");
-const HooksRunner_1 = require("./HooksRunner");
-exports.onConstructAsyncHooksRunner = new HooksRunner_1.HooksRunner('onConstructAsync');
-const onConstructAsync = (...fns) => (0, hook_1.hook)('onConstructAsync', (0, hook_1.prependHooks)(...fns));
-exports.onConstructAsync = onConstructAsync;
-class OnConstructAsyncModule {
-    onException;
-    constructor(onException) {
-        this.onException = onException;
-    }
-    applyTo(injector) {
-        injector.onConstructed((instance, scope) => {
-            if (!exports.onConstructAsyncHooksRunner.hasHooks(instance)) {
-                return;
-            }
-            exports.onConstructAsyncHooksRunner.executeAsync(instance, { scope }).catch((ex) => {
-                if (!this.onException) {
-                    throw ex;
-                }
-                this.onException(ex, { scope });
-            });
-        });
-    }
-}
-exports.OnConstructAsyncModule = OnConstructAsyncModule;

package/cjm/hooks/onContainerDisposed.js

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

package/cjm/hooks/onResolvedAsync.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolvedAsync = exports.OnResolvedAsyncModule = exports.onceResolvedAsync = exports.onResolvedAsync = exports.onResolvedAsyncHooksRunner = void 0;
-const HooksRunner_1 = require("./HooksRunner");
-const IRegistration_1 = require("../registration/IRegistration");
-const resolveHooks_1 = require("./resolveHooks");
-exports.onResolvedAsyncHooksRunner = new HooksRunner_1.HooksRunner('onResolvedAsync');
-exports.onResolvedAsync = (0, resolveHooks_1.resolvedHook)('onResolvedAsync');
-exports.onceResolvedAsync = (0, resolveHooks_1.onceResolvedHook)('onResolvedAsync');
-const runHooks = (onException) => (0, resolveHooks_1.forEachResolvedObject)((0, resolveHooks_1.executeHooksAsync)(exports.onResolvedAsyncHooksRunner, onException));
-class OnResolvedAsyncModule {
-    runHooks;
-    constructor(onException) {
-        this.runHooks = runHooks(onException);
-    }
-    applyTo(container) {
-        container.onRegistered((provider) => {
-            provider.onResolved(this.runHooks);
-        });
-    }
-}
-exports.OnResolvedAsyncModule = OnResolvedAsyncModule;
-const resolvedAsync = (onException) => (0, IRegistration_1.registerPipe)((p) => p.onResolved(runHooks(onException)));
-exports.resolvedAsync = resolvedAsync;

package/cjm/utils/promise.js

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.promisify = void 0;
-const promisify = (arg) => (arg instanceof Promise ? arg : Promise.resolve(arg));
-exports.promisify = promisify;

package/esm/errors/UnexpectedHookResultError.js

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

package/esm/hooks/onConstructAsync.js

@@ -1,23 +0,0 @@
-import { hook, prependHooks } from './hook.js';
-import { HooksRunner } from './HooksRunner.js';
-export const onConstructAsyncHooksRunner = new HooksRunner('onConstructAsync');
-export const onConstructAsync = (...fns) => hook('onConstructAsync', prependHooks(...fns));
-export class OnConstructAsyncModule {
-    onException;
-    constructor(onException) {
-        this.onException = onException;
-    }
-    applyTo(injector) {
-        injector.onConstructed((instance, scope) => {
-            if (!onConstructAsyncHooksRunner.hasHooks(instance)) {
-                return;
-            }
-            onConstructAsyncHooksRunner.executeAsync(instance, { scope }).catch((ex) => {
-                if (!this.onException) {
-                    throw ex;
-                }
-                this.onException(ex, { scope });
-            });
-        });
-    }
-}

package/esm/hooks/onContainerDisposed.js

@@ -1,13 +0,0 @@
-import { hook, prependHooks } from './hook.js';
-import { HooksRunner } from './HooksRunner.js';
-export const onContainerDisposedHooksRunner = new HooksRunner('onContainerDisposed');
-export const onContainerDisposed = (...fns) => hook('onContainerDisposed', prependHooks(...fns));
-export class OnDisposeModule {
-    applyTo(container) {
-        container.onScopeDisposed((scope) => {
-            for (const instance of scope.getInstances()) {
-                onContainerDisposedHooksRunner.execute(instance, { scope });
-            }
-        });
-    }
-}

package/esm/hooks/onResolvedAsync.js

@@ -1,19 +0,0 @@
-import { HooksRunner } from './HooksRunner.js';
-import { registerPipe } from '../registration/IRegistration.js';
-import { executeHooksAsync, forEachResolvedObject, onceResolvedHook, resolvedHook } from './resolveHooks.js';
-export const onResolvedAsyncHooksRunner = new HooksRunner('onResolvedAsync');
-export const onResolvedAsync = resolvedHook('onResolvedAsync');
-export const onceResolvedAsync = onceResolvedHook('onResolvedAsync');
-const runHooks = (onException) => forEachResolvedObject(executeHooksAsync(onResolvedAsyncHooksRunner, onException));
-export class OnResolvedAsyncModule {
-    runHooks;
-    constructor(onException) {
-        this.runHooks = runHooks(onException);
-    }
-    applyTo(container) {
-        container.onRegistered((provider) => {
-            provider.onResolved(this.runHooks);
-        });
-    }
-}
-export const resolvedAsync = (onException) => registerPipe((p) => p.onResolved(runHooks(onException)));

package/esm/utils/promise.js

@@ -1 +0,0 @@
-export const promisify = (arg) => (arg instanceof Promise ? arg : Promise.resolve(arg));

package/typings/errors/UnexpectedHookResultError.d.ts

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

package/typings/hooks/onConstructAsync.d.ts

@@ -1,11 +0,0 @@
-import { HookType } from './hook.js';
-import type { IInjector, IInjectorModule } from '../injector/IInjector.js';
-import { HooksRunner } from './HooksRunner.js';
-import type { OnExceptionHandler } from './onConstruct.js';
-export declare const onConstructAsyncHooksRunner: HooksRunner;
-export declare const onConstructAsync: (...fns: HookType[]) => (target: object, propertyKey: string | symbol) => void;
-export declare class OnConstructAsyncModule implements IInjectorModule {
-    private readonly onException?;
-    constructor(onException?: OnExceptionHandler | undefined);
-    applyTo(injector: IInjector): void;
-}

package/typings/hooks/onContainerDisposed.d.ts

@@ -1,8 +0,0 @@
-import { HookType } from './hook.js';
-import type { IContainer, IContainerModule } from '../container/IContainer.js';
-import { HooksRunner } from './HooksRunner.js';
-export declare const onContainerDisposedHooksRunner: HooksRunner;
-export declare const onContainerDisposed: (...fns: HookType[]) => (target: object, propertyKey: string | symbol) => void;
-export declare class OnDisposeModule implements IContainerModule {
-    applyTo(container: IContainer): void;
-}

package/typings/hooks/onResolvedAsync.d.ts

@@ -1,12 +0,0 @@
-import type { IContainer, IContainerModule } from '../container/IContainer.js';
-import { HooksRunner } from './HooksRunner.js';
-import type { OnExceptionHandler } from './onConstruct.js';
-export declare const onResolvedAsyncHooksRunner: HooksRunner;
-export declare const onResolvedAsync: (...hooks: import("./hook.js").HookType[]) => (target: object, propertyKey: string | symbol) => void;
-export declare const onceResolvedAsync: (...hooks: import("./hook.js").HookType[]) => (target: object, propertyKey: string | symbol) => void;
-export declare class OnResolvedAsyncModule implements IContainerModule {
-    private readonly runHooks;
-    constructor(onException?: OnExceptionHandler);
-    applyTo(container: IContainer): void;
-}
-export declare const resolvedAsync: <T = unknown>(onException?: OnExceptionHandler) => import("../registration/IRegistration.js").ProviderPipe<T>;

package/typings/utils/promise.d.ts

@@ -1 +0,0 @@
-export declare const promisify: <T>(arg: T | Promise<T>) => Promise<T>;