ts-ioc-container 63.0.0 → 65.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
 
@@ -2856,58 +2873,60 @@ The decorators above declare hook *metadata* on a class. The imperative side —
 the callbacks the container machinery runs — is registered on whichever
 abstraction raises the event, one hook type per domain:
 
-| Domain       | Registered on | Type            | Methods                                                  |
+| Domain       | Registered on | Type            | Where                                                    |
 | ------------ | ------------- | --------------- | -------------------------------------------------------- |
-| **Scope**    | `IContainer`  | `ScopeHook`     | `onScopeCreated(...)`, `onScopeDisposed(...)`            |
-| **Scope**    | `IContainer`  | `RegisteredHook`| `onRegistered(...)`                                      |
+| **Scope**    | `IContainer`  | `ScopeHook`     | `scopeCreated.subscribe(...)`, `scopeDisposed.subscribe(...)` |
+| **Scope**    | `IContainer`  | `RegisteredHook`| `registered.subscribe(...)`                              |
 | **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({ tags: ['application'] });
 
-const container = new Container({ injector, tags: ['application'] })
-  .onScopeCreated((scope) => audit.scopeOpened(scope))
-  .onScopeDisposed((scope) => audit.scopeClosed(scope))
-  .onRegistered((provider, key) => audit.registered(key));
-```
+// Scope events are typed events on the container itself
+const stop = container.scopeCreated.subscribe((scope) => audit.scopeOpened(scope));
+container.scopeDisposed.subscribe((scope) => audit.scopeClosed(scope));
+container.registered.subscribe((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(...)`:
+stop(); // detached; `container.scopeCreated.unsubscribe(fn)` does the same by reference
 
-```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 scope events are `scopeCreated`, `scopeDisposed` (`ITypedEvent<[IContainer]>`)
+and `registered` (`ITypedEvent<[IProvider, DependencyKey, IContainer]>`);
+`subscribe` returns the unsubscribe function. The exposed events carry no
+`emit` — only the container raises its own events.
+
+`TypedEvent` itself is exported for your own events: `subscribe` / `unsubscribe`
+/ `emit` / `dispose`, with `ITypedEvent` as the subscriber-only view to hand out.
+
+The built-in modules are all container modules: `OnConstructModule` reaches the
+injector through `getInjector()`, `OnDisposeModule` subscribes to `scopeDisposed`,
+and `OnResolvedModule` reaches every provider through `registered`.
 
 ### 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 +2950,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 +2961,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 +2971,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 +2997,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 +3037,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 +3053,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 +3061,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 +3079,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 +3098,7 @@ import {
   onScopeDisposed,
   register,
   Registration as R,
+  SequentialSync,
   singleton,
 } from 'ts-ioc-container';
 
@@ -3118,7 +3134,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 +3154,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 +3169,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 +3188,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 +3212,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/AutoResolveModule.js

@@ -7,7 +7,7 @@ class AutoResolveModule {
         this.options = options;
     }
     applyTo(container) {
-        container.onScopeCreated((scope) => scope.autoResolve(this.options));
+        container.scopeCreated.subscribe((scope) => scope.autoResolve(this.options));
     }
 }
 exports.AutoResolveModule = AutoResolveModule;

package/cjm/container/Container.js

@@ -9,6 +9,7 @@ const ProxyRegistry_1 = require("../utils/ProxyRegistry");
 const DependencyNotFoundError_1 = require("../errors/DependencyNotFoundError");
 const basic_1 = require("../utils/basic");
 const array_1 = require("../utils/array");
+const TypedEvent_1 = require("../utils/TypedEvent");
 class Container {
     isDisposed = false;
     parent;
@@ -19,9 +20,12 @@ class Container {
     providers = new Map();
     aliases = new AliasMap_1.AliasMap();
     injector;
-    onScopeCreatedHookList = [];
-    onScopeDisposedHookList = [];
-    onRegisteredHookList = [];
+    scopeCreatedEvent = new TypedEvent_1.TypedEvent();
+    scopeDisposedEvent = new TypedEvent_1.TypedEvent();
+    registeredEvent = new TypedEvent_1.TypedEvent();
+    scopeCreated = this.scopeCreatedEvent;
+    scopeDisposed = this.scopeDisposedEvent;
+    registered = this.registeredEvent;
     constructor(options = {}) {
         this.injector = options.injector ?? new MetadataInjector_1.MetadataInjector();
         this.parent = options.parent ?? new EmptyContainer_1.EmptyContainer();
@@ -31,9 +35,7 @@ class Container {
         this.validateContainer();
         this.providers.set(key, provider);
         this.aliases.setAliasesByKey(key, aliases);
-        for (const onRegistered of this.onRegisteredHookList) {
-            onRegistered(provider, key, this);
-        }
+        this.registeredEvent.emit(provider, key, this);
         return this;
     }
     resolve(target, { args = [], child = this, lazy } = {}) {
@@ -76,17 +78,15 @@ class Container {
     }
     createScope({ tags } = {}) {
         this.validateContainer();
-        const scope = new Container({ injector: this.injector, parent: this, tags })
-            .onScopeCreated(...this.onScopeCreatedHookList)
-            .onScopeDisposed(...this.onScopeDisposedHookList)
-            .onRegistered(...this.onRegisteredHookList);
+        const scope = new Container({ injector: this.injector, parent: this, tags });
+        this.scopeCreatedEvent.getListeners().forEach((hook) => scope.scopeCreatedEvent.subscribe(hook));
+        this.scopeDisposedEvent.getListeners().forEach((hook) => scope.scopeDisposedEvent.subscribe(hook));
+        this.registeredEvent.getListeners().forEach((hook) => scope.registeredEvent.subscribe(hook));
         for (const registration of this.getRegistrations()) {
             registration.applyTo(scope);
         }
         this.scopes.push(scope);
-        for (const onScopeCreated of this.onScopeCreatedHookList) {
-            onScopeCreated(scope);
-        }
+        this.scopeCreatedEvent.emit(scope);
         return scope;
     }
     autoResolve({ args = [] } = {}) {
@@ -101,9 +101,7 @@ class Container {
     dispose() {
         this.validateContainer();
         this.isDisposed = true;
-        for (const onScopeDisposed of this.onScopeDisposedHookList) {
-            onScopeDisposed(this);
-        }
+        this.scopeDisposedEvent.emit(this);
         this.parent.removeScope(this);
         this.parent = new EmptyContainer_1.EmptyContainer();
         for (const provider of this.providers.values()) {
@@ -113,9 +111,9 @@ class Container {
         this.aliases.destroy();
         this.instances.clear();
         this.registrations = [];
-        this.onScopeCreatedHookList.length = 0;
-        this.onScopeDisposedHookList.length = 0;
-        this.onRegisteredHookList.length = 0;
+        this.scopeCreatedEvent.dispose();
+        this.scopeDisposedEvent.dispose();
+        this.registeredEvent.dispose();
     }
     addRegistration(registration) {
         this.registrations.push(registration);
@@ -125,21 +123,12 @@ 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);
     }
-    onScopeCreated(...hooks) {
-        this.onScopeCreatedHookList.push(...hooks);
-        return this;
-    }
-    onScopeDisposed(...hooks) {
-        this.onScopeDisposedHookList.push(...hooks);
-        return this;
-    }
-    onRegistered(...hooks) {
-        this.onRegisteredHookList.push(...hooks);
-        return this;
-    }
     addInstance(instance) {
         this.instances.add(instance);
     }

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();
     }
@@ -60,13 +63,13 @@ class EmptyContainer {
     resolveOneByAlias(alias, options) {
         throw new DependencyNotFoundError_1.DependencyNotFoundError(`Cannot find alias ${alias.toString()}`);
     }
-    onScopeCreated(...hooks) {
+    get scopeCreated() {
         throw new MethodNotImplementedError_1.MethodNotImplementedError();
     }
-    onScopeDisposed(...hooks) {
+    get scopeDisposed() {
         throw new MethodNotImplementedError_1.MethodNotImplementedError();
     }
-    onRegistered(...hooks) {
+    get registered() {
         throw new MethodNotImplementedError_1.MethodNotImplementedError();
     }
 }

package/cjm/errors/TypedEventDisposedError.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypedEventDisposedError = void 0;
+const ContainerError_1 = require("./ContainerError");
+class TypedEventDisposedError extends ContainerError_1.ContainerError {
+    name = 'TypedEventDisposedError';
+    static assert(isTrue, failMessage) {
+        if (!isTrue) {
+            throw new TypedEventDisposedError(failMessage);
+        }
+    }
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, TypedEventDisposedError.prototype);
+    }
+}
+exports.TypedEventDisposedError = TypedEventDisposedError;

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;