ts-ioc-container 63.0.0 → 64.0.0

package/README.md

@@ -2833,22 +2833,39 @@ 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.
+there is no separate async form to reach for. *How* the hooks run is a separate
+choice: each module takes a `HookExecutionStrategy`, keyed to the hooks it runs
+(`onConstruct`, `onScopeDisposed`, `onResolved`, or a custom key), and the
+strategy decides the order, what is awaited, and where a failure goes
+([ADR 0014](../../adr/0014-hook-execution-strategy.md)):
+
+| Strategy          | Members (decorated methods) | Hooks of one member                         | Awaits |
+| ----------------- | --------------------------- | ------------------------------------------- | ------ |
+| `SequentialSync`  | one after another           | in declaration order                        | no     |
+| `SequentialAsync` | one after another           | in order, or all at once (`methodStrategy`) | yes    |
+| `ParallelAsync`   | all at once                 | in order, or all at once (`methodStrategy`) | yes    |
+
+```typescript
+const container = new Container()
+  .useModule(new OnConstructModule(new SequentialSync({ key: 'onConstruct' })))
+  .useModule(new OnDisposeModule(new ParallelAsync({ key: 'onScopeDisposed' })));
+```
+
+Resolution and disposal stay synchronous under every strategy: a run stays
+synchronous until a hook returns a promise, so sync hooks finish before
+`resolve` (or `dispose`) returns, and async ones are started there and settle
+afterwards. Instances that must expose readiness should publish it themselves,
+for example by storing the pending promise on the instance. The sync strategy
+never awaits — a hook that returns a promise under it is started but not
+observed.
+
+`strategy.execute(instance, { scope })` runs the hooks of a custom key by hand;
+`predicate`, `createExecutionContext` and `mapExecutionContext` can be set on
+the strategy or per call.
+
+A strategy takes an optional `onError: (scope) => (error) => void`, which
+receives both kinds of failure — what a sync hook threw and what an async hook
+rejected with. Without one, failures are dropped.
 
 ### Hook domains
 
@@ -2863,51 +2880,41 @@ abstraction raises the event, one hook type per domain:
 | **Injector** | `IInjector`   | `InjectorHook`  | `onConstructed(...)`                                     |
 | **Provider** | `IProvider`   | `ProviderHook`  | `onResolved(...)`, or the [`onResolve`](#on-resolve) pipe |
 
-A container never hands its injector out — the injector is configured first and
-passed in at construction:
+A container passes its injector to every scope it creates, so **one injector**
+backs the whole scope tree, and `container.getInjector()` hands it out: an
+`onConstructed` hook registered through it covers every scope, whenever 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.
 
 ```typescript
-// Construction is the injector's event, not a scope's
-const injector = new MetadataInjector().onConstructed((instance, scope) => metrics.built(instance, scope));
-
-const container = new Container({ injector, tags: ['application'] })
+const container = new Container({ tags: ['application'] })
   .onScopeCreated((scope) => audit.scopeOpened(scope))
   .onScopeDisposed((scope) => audit.scopeClosed(scope))
   .onRegistered((provider, key) => audit.registered(key));
-```
-
-A container passes its injector to every scope it creates, so **one injector**
-backs the whole scope tree and an `onConstructed` hook covers all of it, whenever
-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` is an
-**injector** module (`IInjectorModule`), applied with `injector.useModule(...)`:
 
-```typescript
-const injector = new MetadataInjector().useModule(new OnConstructModule());
-const container = new Container({ injector });
+// Construction is the injector's event, not a scope's
+container.getInjector().onConstructed((instance, scope) => metrics.built(instance, scope));
 ```
 
-`OnDisposeModule` is a container module hooking `onScopeDisposed`, and
-`OnResolvedModule` is a container module reaching every provider through
-`onRegistered`.
+The built-in modules are all container modules: `OnConstructModule` reaches the
+injector through `getInjector()`, `OnDisposeModule` hooks `onScopeDisposed`, and
+`OnResolvedModule` reaches every provider through `onRegistered`.
 
 ### OnConstruct
 
 ```typescript
 import 'reflect-metadata';
 import {
-  MetadataInjector,
   OnConstructModule,
   Container,
-  type ExecutionContext,
   type HookFn,
   type IContainer,
   inject,
   onConstruct,
   Registration as R,
+  SequentialAsync,
+  SequentialSync,
 } from 'ts-ioc-container';
 
 const execute: HookFn = (ctx) => {
@@ -2931,9 +2938,10 @@ describe('onConstruct', function () {
       }
     }
 
-    const container = new Container({
-      injector: new MetadataInjector().useModule(new OnConstructModule()),
-    }).addRegistration(R.fromValue('postgres://localhost:5432').bindTo('ConnectionString'));
+    // The module takes a strategy for how the hooks run; the strategy is keyed to the hooks it runs.
+    const container = new Container()
+      .useModule(new OnConstructModule(new SequentialSync({ key: 'onConstruct' })))
+      .addRegistration(R.fromValue('postgres://localhost:5432').bindTo('ConnectionString'));
 
     const db = container.resolve(DatabaseConnection);
 
@@ -2941,7 +2949,7 @@ describe('onConstruct', function () {
     expect(db.connectionString).toBe('postgres://localhost:5432');
   });
 
-  it('should forward hook exceptions to the onException handler with the execution context', function () {
+  it('should forward hook exceptions to the onError handler with the scope', function () {
     const failure = new Error('boom');
 
     class BrokenService {
@@ -2951,36 +2959,24 @@ describe('onConstruct', function () {
       init() {}
     }
 
-    let captured: { ex: unknown; context: ExecutionContext } | undefined;
-    const container = new Container({
-      injector: new MetadataInjector().useModule(
-        new OnConstructModule((ex, context) => {
-          captured = { ex, context };
+    let captured: { ex: unknown; scope: IContainer } | undefined;
+    const container = new Container().useModule(
+      new OnConstructModule(
+        new SequentialSync({
+          key: 'onConstruct',
+          onError: (scope) => (ex) => {
+            captured = { ex, scope };
+          },
         }),
       ),
-    });
+    );
 
     expect(() => container.resolve(BrokenService)).not.toThrow();
     expect(captured?.ex).toBe(failure);
-    expect(captured?.context.scope).toBe(container);
-  });
-
-  it('should rethrow hook exceptions when no onException handler is provided', function () {
-    const failure = new Error('boom');
-
-    class BrokenService {
-      @onConstruct(() => {
-        throw failure;
-      })
-      init() {}
-    }
-
-    const container = new Container({ injector: new MetadataInjector().useModule(new OnConstructModule()) });
-
-    expect(() => container.resolve(BrokenService)).toThrow(failure);
+    expect(captured?.scope).toBe(container);
   });
 
-  it('should expose the resolving scope through the execution context', function () {
+  it('should expose the resolving scope to the onError handler', function () {
     class BrokenService {
       @onConstruct(() => {
         throw new Error('boom');
@@ -2989,13 +2985,16 @@ describe('onConstruct', function () {
     }
 
     let scope: IContainer | undefined;
-    const container = new Container({
-      injector: new MetadataInjector().useModule(
-        new OnConstructModule((_ex, context) => {
-          scope = context.scope;
+    const container = new Container().useModule(
+      new OnConstructModule(
+        new SequentialSync({
+          key: 'onConstruct',
+          onError: (s) => () => {
+            scope = s;
+          },
         }),
       ),
-    });
+    );
     const child = container.createScope();
 
     child.resolve(BrokenService);
@@ -3026,9 +3025,10 @@ describe('onConstruct', function () {
       }
     }
 
-    const container = new Container({
-      injector: new MetadataInjector().useModule(new OnConstructModule()),
-    }).addRegistration(R.fromValue('postgres://localhost:5432').bindTo('ConnectionString'));
+    // An async strategy awaits the hooks; resolution itself still does not wait for them.
+    const container = new Container()
+      .useModule(new OnConstructModule(new SequentialAsync({ key: 'onConstruct' })))
+      .addRegistration(R.fromValue('postgres://localhost:5432').bindTo('ConnectionString'));
 
     const db = container.resolve(DatabaseConnection);
 
@@ -3041,7 +3041,7 @@ describe('onConstruct', function () {
     expect(db.connectionString).toBe('postgres://localhost:5432');
   });
 
-  it('should forward rejected hooks to the onException handler with the execution context', async function () {
+  it('should forward rejected hooks to the onError handler with the scope', async function () {
     const failure = new Error('boom');
 
     class BrokenService {
@@ -3049,14 +3049,17 @@ describe('onConstruct', function () {
       init() {}
     }
 
-    let captured: { ex: unknown; context: ExecutionContext } | undefined;
-    const container = new Container({
-      injector: new MetadataInjector().useModule(
-        new OnConstructModule((ex, context) => {
-          captured = { ex, context };
+    let captured: { ex: unknown; scope: IContainer } | undefined;
+    const container = new Container().useModule(
+      new OnConstructModule(
+        new SequentialAsync({
+          key: 'onConstruct',
+          onError: (scope) => (ex) => {
+            captured = { ex, scope };
+          },
         }),
       ),
-    });
+    );
 
     const child = container.createScope();
     child.resolve(BrokenService);
@@ -3064,7 +3067,7 @@ describe('onConstruct', function () {
     await vi.waitFor(() => expect(captured).toBeDefined());
 
     expect(captured?.ex).toBe(failure);
-    expect(captured?.context.scope).toBe(child);
+    expect(captured?.scope).toBe(child);
   });
 });
 
@@ -3083,6 +3086,7 @@ import {
   onScopeDisposed,
   register,
   Registration as R,
+  SequentialSync,
   singleton,
 } from 'ts-ioc-container';
 
@@ -3118,7 +3122,7 @@ class Logger {
 describe('onScopeDisposed', function () {
   it('should invoke hooks on all instances when container is disposed', function () {
     const container = new Container()
-      .useModule(new OnDisposeModule())
+      .useModule(new OnDisposeModule(new SequentialSync({ key: 'onScopeDisposed' })))
       .addRegistration(R.fromClass(Logger))
       .addRegistration(R.fromClass(LogsRepo));
 
@@ -3138,7 +3142,7 @@ describe('onScopeDisposed', function () {
 
 ```typescript
 import 'reflect-metadata';
-import { append, Container, hook, HooksRunner, injectProp, Registration } from 'ts-ioc-container';
+import { append, Container, hook, SequentialSync, injectProp, Registration } from 'ts-ioc-container';
 
 /**
  * UI Components - Property Injection
@@ -3153,8 +3157,8 @@ import { append, Container, hook, HooksRunner, injectProp, Registration } from '
 
 describe('inject property', () => {
   it('should inject property', () => {
-    // Runner for the 'onInit' lifecycle hook
-    const onInitHookRunner = new HooksRunner('onInit');
+    // Strategy for the 'onInit' lifecycle hook
+    const onInitStrategy = new SequentialSync({ key: 'onInit' });
 
     class UserViewModel {
       // Inject 'GreetingService' into 'greeting' property during 'onInit'
@@ -3172,14 +3176,14 @@ describe('inject property', () => {
     const viewModel = container.resolve(UserViewModel);
 
     // 2. Run lifecycle hooks to inject properties
-    onInitHookRunner.execute(viewModel, { scope: container });
+    onInitStrategy.execute(viewModel, { scope: container });
 
     expect(viewModel.greetingService).toBe('Hello');
     expect(viewModel.display()).toBe('Hello User');
   });
 
   it('should read the applied instance property via getProperty', () => {
-    const onInitHookRunner = new HooksRunner('onInit');
+    const onInitStrategy = new SequentialSync({ key: 'onInit' });
 
     let injectedValue: unknown;
 
@@ -3196,7 +3200,7 @@ describe('inject property', () => {
     const container = new Container().addRegistration(Registration.fromValue('Hello').bindToKey('GreetingService'));
 
     const viewModel = container.resolve(UserViewModel);
-    onInitHookRunner.execute(viewModel, { scope: container });
+    onInitStrategy.execute(viewModel, { scope: container });
 
     expect(injectedValue).toBe('Hello');
   });

package/cjm/container/Container.js

@@ -125,6 +125,9 @@ class Container {
     getRegistrations() {
         return [...this.parent.getRegistrations(), ...this.registrations];
     }
+    getInjector() {
+        return this.injector;
+    }
     hasRegistration(key) {
         return this.registrations.some((r) => r.getKeyOrFail() === key) || this.parent.hasRegistration(key);
     }

package/cjm/container/EmptyContainer.js

@@ -23,6 +23,9 @@ class EmptyContainer {
     createScope() {
         throw new MethodNotImplementedError_1.MethodNotImplementedError();
     }
+    getInjector() {
+        throw new MethodNotImplementedError_1.MethodNotImplementedError();
+    }
     autoResolve(options) {
         throw new MethodNotImplementedError_1.MethodNotImplementedError();
     }

package/cjm/hooks/AsyncHookExecutionStrategy.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncHookExecutionStrategy = void 0;
+const HookExecutionStrategy_1 = require("./HookExecutionStrategy");
+class AsyncHookExecutionStrategy extends HookExecutionStrategy_1.HookExecutionStrategy {
+    methodStrategy;
+    constructor({ methodStrategy = 'sequential', ...props }) {
+        super(props);
+        this.methodStrategy = methodStrategy;
+    }
+    runMember({ hooks, context }) {
+        return this.methodStrategy === 'parallel' ? (0, HookExecutionStrategy_1.runAtOnce)(hooks, context) : (0, HookExecutionStrategy_1.runInOrder)(hooks, context);
+    }
+}
+exports.AsyncHookExecutionStrategy = AsyncHookExecutionStrategy;

package/cjm/hooks/HookContext.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createHookContextFactory = exports.createHookContext = exports.HookContext = void 0;
+exports.createHookContextFactory = exports.createHookExecutionContext = exports.HookContext = void 0;
 const MetadataInjector_1 = require("../injector/MetadataInjector");
 class HookContext {
     instance;
@@ -35,7 +35,7 @@ class HookContext {
     }
 }
 exports.HookContext = HookContext;
-const createHookContext = (Target, scope, methodName = 'constructor') => new HookContext(Target, scope, methodName);
-exports.createHookContext = createHookContext;
-const createHookContextFactory = ({ args = [] } = {}) => (Target, scope, methodName) => (0, exports.createHookContext)(Target, scope, methodName).setInitialArgs(...args);
+const createHookExecutionContext = (Target, scope, methodName = 'constructor') => new HookContext(Target, scope, methodName);
+exports.createHookExecutionContext = createHookExecutionContext;
+const createHookContextFactory = ({ args = [] } = {}) => (Target, scope, methodName) => (0, exports.createHookExecutionContext)(Target, scope, methodName).setInitialArgs(...args);
 exports.createHookContextFactory = createHookContextFactory;

package/cjm/hooks/HookExecutionStrategy.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HookExecutionStrategy = exports.runAtOnce = exports.runInOrder = void 0;
+const target_1 = require("../metadata/target");
+const hook_1 = require("./hook");
+const HookContext_1 = require("./HookContext");
+const runInOrder = (hooks, context, from = 0) => {
+    for (let i = from; i < hooks.length; i++) {
+        const result = hooks[i](context);
+        if (result instanceof Promise) {
+            return result.then(() => (0, exports.runInOrder)(hooks, context, i + 1));
+        }
+    }
+};
+exports.runInOrder = runInOrder;
+const runAtOnce = (hooks, context) => {
+    const pending = [];
+    for (const hook of hooks) {
+        const result = hook(context);
+        if (result instanceof Promise) {
+            pending.push(result);
+        }
+    }
+    return pending.length > 0 ? Promise.all(pending).then(() => undefined) : undefined;
+};
+exports.runAtOnce = runAtOnce;
+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, hooks } of this.hooksOf(target)) {
+            if (predicate(methodName)) {
+                members.push({ hooks, 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, fns]) => ({ methodName, hooks: fns.map(hook_1.toHookFn) }));
+            this.hooksByClass.set(Target, hooks);
+        }
+        return hooks;
+    }
+}
+exports.HookExecutionStrategy = HookExecutionStrategy;

package/cjm/hooks/ParallelAsync.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParallelAsync = void 0;
+const AsyncHookExecutionStrategy_1 = require("./AsyncHookExecutionStrategy");
+class ParallelAsync extends AsyncHookExecutionStrategy_1.AsyncHookExecutionStrategy {
+    processHooks(members) {
+        const pending = [];
+        for (const member of members) {
+            const result = this.runMember(member);
+            if (result) {
+                pending.push(result);
+            }
+        }
+        return pending.length > 0 ? Promise.all(pending).then(() => undefined) : undefined;
+    }
+}
+exports.ParallelAsync = ParallelAsync;

package/cjm/hooks/SequentialAsync.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SequentialAsync = void 0;
+const AsyncHookExecutionStrategy_1 = require("./AsyncHookExecutionStrategy");
+class SequentialAsync extends AsyncHookExecutionStrategy_1.AsyncHookExecutionStrategy {
+    processHooks(members, from = 0) {
+        for (let i = from; i < members.length; i++) {
+            const result = this.runMember(members[i]);
+            if (result) {
+                return result.then(() => this.processHooks(members, i + 1));
+            }
+        }
+    }
+}
+exports.SequentialAsync = SequentialAsync;

package/cjm/hooks/SequentialSync.js

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

package/cjm/hooks/onConstruct.js

@@ -1,19 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OnConstructModule = exports.onConstruct = exports.onConstructHooksRunner = void 0;
+exports.OnConstructModule = exports.onConstruct = void 0;
 const hook_1 = require("./hook");
-const HooksRunner_1 = require("./HooksRunner");
-exports.onConstructHooksRunner = new HooksRunner_1.HooksRunner('onConstruct');
 const onConstruct = (...fns) => (0, hook_1.hook)('onConstruct', (0, hook_1.prependHooks)(...fns));
 exports.onConstruct = onConstruct;
 class OnConstructModule {
-    onException;
-    constructor(onException) {
-        this.onException = onException;
+    strategy;
+    constructor(strategy) {
+        this.strategy = strategy;
     }
-    applyTo(injector) {
-        injector.onConstructed((instance, scope) => {
-            (0, HooksRunner_1.runHooks)(exports.onConstructHooksRunner, instance, scope, this.onException);
+    applyTo(container) {
+        container.getInjector().onConstructed((instance, scope) => {
+            this.strategy.execute(instance, { scope });
         });
     }
 }

package/cjm/hooks/onResolved.js

@@ -1,16 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolved = exports.OnResolvedModule = exports.onResolved = exports.onResolvedHooksRunner = void 0;
-const HooksRunner_1 = require("./HooksRunner");
+exports.resolved = exports.OnResolvedModule = exports.onResolved = void 0;
 const IRegistration_1 = require("../registration/IRegistration");
-const resolveHooks_1 = require("./resolveHooks");
-exports.onResolvedHooksRunner = new HooksRunner_1.HooksRunner('onResolved');
-exports.onResolved = (0, resolveHooks_1.resolvedHook)('onResolved');
-const runHooks = (onException) => (0, resolveHooks_1.forEachResolvedObject)((0, resolveHooks_1.executeHooks)(exports.onResolvedHooksRunner, onException));
+const basic_1 = require("../utils/basic");
+const hook_1 = require("./hook");
+const onResolved = (...hooks) => (0, hook_1.hook)('onResolved', (0, hook_1.prependHooks)(...hooks));
+exports.onResolved = onResolved;
+const runHooks = (strategy) => (dependency, scope) => {
+    if (basic_1.Is.object(dependency)) {
+        strategy.execute(dependency, { scope });
+    }
+};
 class OnResolvedModule {
     runHooks;
-    constructor(onException) {
-        this.runHooks = runHooks(onException);
+    constructor(strategy) {
+        this.runHooks = runHooks(strategy);
     }
     applyTo(container) {
         container.onRegistered((provider) => {
@@ -19,5 +23,5 @@ class OnResolvedModule {
     }
 }
 exports.OnResolvedModule = OnResolvedModule;
-const resolved = (onException) => (0, IRegistration_1.registerPipe)((p) => p.onResolved(runHooks(onException)));
+const resolved = (strategy) => (0, IRegistration_1.registerPipe)((p) => p.onResolved(runHooks(strategy)));
 exports.resolved = resolved;

package/cjm/hooks/onScopeDisposed.js

@@ -1,20 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OnDisposeModule = exports.onScopeDisposed = exports.onScopeDisposedHooksRunner = void 0;
+exports.OnDisposeModule = exports.onScopeDisposed = 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;
+    strategy;
+    constructor(strategy) {
+        this.strategy = strategy;
     }
     applyTo(container) {
         container.onScopeDisposed((scope) => {
             for (const instance of scope.getInstances()) {
-                (0, HooksRunner_1.runHooks)(exports.onScopeDisposedHooksRunner, instance, scope, this.onException);
+                this.strategy.execute(instance, { scope });
             }
         });
     }

package/cjm/hooks/resolveHooks.js

@@ -1,14 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.executeHooks = exports.forEachResolvedObject = exports.resolvedHook = exports.oncePerInstance = exports.invokeMethod = void 0;
-const HooksRunner_1 = require("./HooksRunner");
+exports.oncePerInstance = void 0;
 const hook_1 = require("./hook");
-const basic_1 = require("../utils/basic");
-const invokeMethod = (context) => {
-    context.invokeMethod();
-};
-exports.invokeMethod = invokeMethod;
-const toHooks = (hooks) => (hooks.length > 0 ? hooks : [exports.invokeMethod]);
 const oncePerInstance = (execute) => {
     const invokedInstances = new WeakSet();
     return (context) => {
@@ -20,13 +13,3 @@ const oncePerInstance = (execute) => {
     };
 };
 exports.oncePerInstance = oncePerInstance;
-const resolvedHook = (key) => (...hooks) => (0, hook_1.hook)(key, (0, hook_1.prependHooks)(...toHooks(hooks)));
-exports.resolvedHook = resolvedHook;
-const forEachResolvedObject = (run) => (dependency, scope) => {
-    if (basic_1.Is.object(dependency)) {
-        run(dependency, scope);
-    }
-};
-exports.forEachResolvedObject = forEachResolvedObject;
-const executeHooks = (runner, onException) => (dependency, scope) => (0, HooksRunner_1.runHooks)(runner, dependency, scope, onException);
-exports.executeHooks = executeHooks;