ts-ioc-container 67.0.0 → 68.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 `@onScopeDisposed`
+- decorator support with `@register`, `@inject`, and `@hook` — lifecycle hook keys are yours to name
 - can [inject properties](#inject-property)
 - can inject [lazy dependencies](#lazy)
 - composable provider and registration pipelines
@@ -55,8 +55,8 @@ provider pipelines, aliases, and custom injector strategies.
 - [Module](#module)
 - [Hook](#hook) `@hook`
   - [Hook domains](#hook-domains) `ScopeHook` `InjectorHook` `ProviderHook`
-  - [OnConstruct](#onconstruct) `@onConstruct`
-  - [OnScopeDisposed](#onscopedisposed) `@onScopeDisposed`
+  - [Construct hooks](#construct-hooks) `onConstructed`
+  - [Scope disposal hooks](#scope-disposal-hooks) `scopeDisposed`
   - [Inject Property](#inject-property)
   - [Inject Method](#inject-method)
 - [Mock](#mock)
@@ -106,8 +106,8 @@ bundlers tree-shake unused exports.
 | Bun | ✅ | CJS + ESM | Runs the native ESM/CJS builds directly. |
 
 > [!NOTE]
-> The default `MetadataInjector` (and the `@inject` / `@onConstruct` /
-> `@onScopeDisposed` decorators) rely on `reflect-metadata`. It is declared as an
+> The default `MetadataInjector` (and the `@inject` / `@hook` 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.
 
@@ -2385,7 +2385,7 @@ Sometimes you don't want to change the dependency, only to react to it. Use the
 
 Hooks run after the whole `decorate(...)` chain, so they always observe the fully decorated dependency, and their return value is ignored — `onResolve` can never swap the dependency out. They fire per resolution, which means a `singleton()` provider runs them only on the resolve that fills the cache.
 
-This — or the `@onResolved` decorator over the same provider event — is the recommended way to react to a dependency; see [OnConstruct](#onconstruct) for why `@onConstruct` is the narrower tool.
+This — or a hook key collected over the same provider event — is the recommended way to react to a dependency; see [Construct hooks](#construct-hooks) for why construction is the narrower event.
 
 ```typescript
 import 'reflect-metadata';
@@ -2811,10 +2811,18 @@ describe('Container Modules', function () {
 
 Sometimes you need to invoke methods after construct or dispose of class. This is what hooks are for.
 
-Every hook decorator — the generic `@hook(key, hook)` and `@onConstruct`,
-`@onScopeDisposed`, `@onResolved` — takes **one** hook for the decorated member.
-Several hooks are combined at the declaration site, by the combinator that says
-how they relate:
+`@hook(key, hook)` is the only hook decorator the library ships, and the key is
+yours: there is no `@onConstruct` or `@onScopeDisposed` in the package, because
+each is one line of your own code
+([ADR 0017](../../adr/0017-no-predefined-hook-keys.md)).
+
+```typescript
+// yours, named in your vocabulary
+const onScopeDisposed = (fn: HookType) => hook('onScopeDisposed', fn);
+```
+
+A decorated member takes **one** hook. Several hooks are combined at the
+declaration site, by the combinator that says how they relate:
 
 ```typescript
 class OrderService {
@@ -2842,42 +2850,115 @@ A member carries exactly one hook per key, so decorating the same member twice
 under one key replaces the earlier hook rather than adding to it — decorators
 are applied bottom-up, so the topmost one is the one that stays.
 
-Every hook may be sync or async — one decorator and one module take both, so
-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). A strategy
-decides how the **members** — the decorated methods — relate to each other,
-what is awaited, and where a failure goes
-([ADR 0015](../../adr/0015-one-hook-per-member.md)); how the hooks *within* one
-member relate is the combinator's job, not the strategy's:
-
-| Strategy          | Members (decorated methods) | Awaits |
-| ----------------- | --------------------------- | ------ |
-| `SequentialSync`  | one after another           | no     |
-| `SequentialAsync` | one after another           | yes    |
-| `ParallelAsync`   | all at once                 | yes    |
+Every hook may be sync or async — the one decorator takes both, so there is no
+separate async form to reach for. *Running* them is not the library's job at
+all, and neither is deciding when to collect them
+([ADR 0016](../../adr/0016-collect-hooks-let-the-caller-run-them.md),
+[ADR 0018](../../adr/0018-no-hook-modules.md)). The library answers one
+question — which hooks does this object declare, and against what context do
+they run — and the container's events are where you ask it.
+
+A **`HookCollector`** is keyed to one of your hook keys and answers a single
+question: `getActions(target, { scope })` returns one **`HookAction`** per
+decorated member — the hook resolved to a function, bound to the
+`IHookContext` it runs against (which carries the member's own `methodName`). It performs nothing, and how the
+hooks *within* one member relate was already settled by the combinator at the
+declaration site ([ADR 0015](../../adr/0015-one-hook-per-member.md)). It reads a
+class's metadata once and reuses it, so collecting on a hot event is cheap.
+
+A **runner** performs them. Order, awaiting and failure handling are decided
+there and nowhere else; `toTask` turns an action into the `Task` that
+`runInOrder` and `runAtOnce` take. The library exports no type for it — it
+never calls a runner, nor is it handed one — so name the shape yourself:
 
 ```typescript
-const container = new Container()
-  .useModule(new OnConstructModule(new SequentialSync({ key: 'onConstruct' })))
-  .useModule(new OnDisposeModule(new ParallelAsync({ key: 'onScopeDisposed' })));
+// yours, like the hook keys
+type HookRunner = (actions: HookAction[], context: ExecutionContext) => void;
+
+// members one after another, never awaited: sync hooks finish before this returns
+const immediate: HookRunner = (actions) => {
+  for (const { hook, context } of actions) {
+    hook(context);
+  }
+};
+
+// members one after another, awaiting any that goes async; both kinds of failure reported
+const inOrder =
+  (onError: (scope: IContainer) => (error: unknown) => void): HookRunner =>
+  (actions, { scope }) => {
+    try {
+      runInOrder(actions.map(toTask))?.catch(onError(scope));
+    } catch (ex) {
+      onError(scope)(ex);
+    }
+  };
+
+// every member started at once
+const atOnce: HookRunner = (actions) => {
+  runAtOnce(actions.map(toTask));
+};
+
 ```
 
-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.
+Then wire collecting to the event you want it on. There is no
+`OnConstructModule` in the package: an `IContainerModule` is one method, and
+these are the whole of what the modules this library used to ship contained.
 
-`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.
+```typescript
+const onConstructHooks = new HookCollector({ key: 'onConstruct' });
+const onScopeDisposedHooks = new HookCollector({ key: 'onScopeDisposed' });
+
+// construction is the injector's event, and one injector backs the whole scope tree
+const constructModule = (run: HookRunner): IContainerModule => ({
+  applyTo: (container) =>
+    container.getInjector().onConstructed((instance, scope) => {
+      run(onConstructHooks.getActions(instance, { scope }), { scope });
+    }),
+});
+
+// disposal is a scope event; collecting every instance into one list lets the
+// runner order the instances as well as the members
+const disposeModule = (run: HookRunner): IContainerModule => ({
+  applyTo: (container) =>
+    container.scopeDisposed.subscribe((scope) => {
+      run(
+        scope.getInstances().flatMap((instance) => onScopeDisposedHooks.getActions(instance, { scope })),
+        { scope },
+      );
+    }),
+});
+
+const container = new Container().useModule(constructModule(inOrder(report))).useModule(disposeModule(atOnce));
+```
 
-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.
+For resolve hooks, reach the providers through `registered.subscribe(...)` and
+`provider.onResolved(...)`, or pipe a single registration with
+[`onResolve`](#on-resolve). Narrowing is the collector's:
+`new HookCollector({ key: 'onConstruct', predicate })`.
+
+Resolution and disposal stay synchronous unless the runner makes them
+otherwise: `runInOrder` and `runAtOnce` stay 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.
+
+Failures belong to the runner too — nothing in the library catches what a hook
+throws or rejects with. A runner which neither guards nor awaits lets a sync
+throw propagate out of `resolve` / `dispose` and drops an async rejection.
+
+A custom key is collected and run the same way, with no module in between:
+
+```typescript
+const workflow = new HookCollector({ key: 'workflow' });
+
+container.getInjector().onConstructed((instance, scope) => {
+  runInOrder(workflow.getActions(instance, { scope }).map(toTask));
+});
+```
+
+`predicate`, `createExecutionContext` and `mapExecutionContext` can be set on
+the collector or overridden per `getActions` call.
 
 ### Hook domains
 
@@ -2921,22 +3002,22 @@ and `registered` (`ITypedEvent<[IProvider, DependencyKey, IContainer]>`);
 `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`.
+These four events are the whole surface hooks are wired to; the library ships no
+module over them ([ADR 0018](../../adr/0018-no-hook-modules.md)).
 
-### OnConstruct
+### Construct hooks
 
-> **Prefer `@onResolved` — or the [`onResolve`](#on-resolve) pipe — over
-> `@onConstruct`.** Construction is the *injector's* event, so `@onConstruct`
-> fires only for dependencies the injector builds: a `fromValue` constant or a
-> factory registration never triggers it. It also observes the instance before
+> **Prefer collecting on resolve — through `registered` / `onResolved`, or the
+> [`onResolve`](#on-resolve) pipe — over collecting on construction.**
+> Construction is the *injector's* event, so it fires only for dependencies the
+> injector builds: a `fromValue` constant or a factory registration never
+> triggers it. It also observes the instance before
 > the provider's `decorate(...)` chain wraps it, so a hook sees the bare
-> instance rather than what the caller receives. `@onResolved` runs on every
+> instance rather than what the caller receives. A resolve hook runs on every
 > dependency leaving a provider, after the whole decorate chain — the same
 > ordering, awaiting and error handling, on what the caller actually gets.
-> Reach for `@onConstruct` only when you mean "this class was just constructed"
-> specifically.
+> Reach for construct hooks only when you mean "this class was just
+> constructed" specifically.
 
 ```typescript
 import 'reflect-metadata';
@@ -2944,12 +3025,16 @@ import {
   Container,
   type HookFn,
   type IContainer,
+  hook,
+  HookCollector,
+  type HookType,
+  type IContainerModule,
   inject,
-  onConstruct,
-  OnConstructModule,
   Registration as R,
-  SequentialAsync,
-  SequentialSync,
+  runInOrder,
+  toTask,
+  type ExecutionContext,
+  type HookAction,
 } from 'ts-ioc-container';
 
 const execute: HookFn = (ctx) => {
@@ -2960,6 +3045,37 @@ const executeAsync: HookFn = async (ctx) => {
   await ctx.invokeMethod({ args: ctx.resolveArgs() });
 };
 
+// The library ships no construct decorator: the key, the decorator which writes
+// it and the collector which reads it are all ours.
+const onConstruct = (fn: HookType) => hook('onConstruct', fn);
+const onConstructHooks = new HookCollector({ key: 'onConstruct' });
+
+// Running the collected hooks is ours too, and so is naming the shape that does
+// it: the library neither calls a runner nor is handed one.
+type HookRunner = (actions: HookAction[], context: ExecutionContext) => void;
+
+// This runner keeps the
+// actions in declaration order, stays synchronous until one returns a promise,
+// and reports a throw and a rejection alike.
+const run =
+  (onError: (scope: IContainer) => (ex: unknown) => void = () => () => {}): HookRunner =>
+  (actions, { scope }) => {
+    try {
+      runInOrder(actions.map(toTask))?.catch(onError(scope));
+    } catch (ex) {
+      onError(scope)(ex);
+    }
+  };
+
+// Construction is the injector's event, and hanging the collection off it is
+// ours: the library ships no module for that, and a module is just an `applyTo`.
+const onConstructModule = (run: HookRunner): IContainerModule => ({
+  applyTo: (container) =>
+    container.getInjector().onConstructed((instance, scope) => {
+      run(onConstructHooks.getActions(instance, { scope }), { scope });
+    }),
+});
+
 describe('onConstruct', function () {
   it('should run initialization method after dependencies are resolved', function () {
     class DatabaseConnection {
@@ -2973,9 +3089,8 @@ describe('onConstruct', function () {
       }
     }
 
-    // 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' })))
+      .useModule(onConstructModule(run()))
       .addRegistration(R.fromValue('postgres://localhost:5432').bindTo('ConnectionString'));
 
     const db = container.resolve(DatabaseConnection);
@@ -2984,7 +3099,7 @@ describe('onConstruct', function () {
     expect(db.connectionString).toBe('postgres://localhost:5432');
   });
 
-  it('should forward hook exceptions to the onError handler with the scope', function () {
+  it('should forward hook exceptions to the runner’s error handler with the scope', function () {
     const failure = new Error('boom');
 
     class BrokenService {
@@ -2996,12 +3111,9 @@ describe('onConstruct', function () {
 
     let captured: { ex: unknown; scope: IContainer } | undefined;
     const container = new Container().useModule(
-      new OnConstructModule(
-        new SequentialSync({
-          key: 'onConstruct',
-          onError: (scope) => (ex) => {
-            captured = { ex, scope };
-          },
+      onConstructModule(
+        run((scope) => (ex) => {
+          captured = { ex, scope };
         }),
       ),
     );
@@ -3011,7 +3123,7 @@ describe('onConstruct', function () {
     expect(captured?.scope).toBe(container);
   });
 
-  it('should expose the resolving scope to the onError handler', function () {
+  it('should expose the resolving scope to the runner’s error handler', function () {
     class BrokenService {
       @onConstruct(() => {
         throw new Error('boom');
@@ -3021,12 +3133,9 @@ describe('onConstruct', function () {
 
     let scope: IContainer | undefined;
     const container = new Container().useModule(
-      new OnConstructModule(
-        new SequentialSync({
-          key: 'onConstruct',
-          onError: (s) => () => {
-            scope = s;
-          },
+      onConstructModule(
+        run((s) => () => {
+          scope = s;
         }),
       ),
     );
@@ -3060,9 +3169,9 @@ describe('onConstruct', function () {
       }
     }
 
-    // An async strategy awaits the hooks; resolution itself still does not wait for them.
+    // The runner awaits the hooks; resolution itself still does not wait for them.
     const container = new Container()
-      .useModule(new OnConstructModule(new SequentialAsync({ key: 'onConstruct' })))
+      .useModule(onConstructModule(run()))
       .addRegistration(R.fromValue('postgres://localhost:5432').bindTo('ConnectionString'));
 
     const db = container.resolve(DatabaseConnection);
@@ -3076,7 +3185,7 @@ describe('onConstruct', function () {
     expect(db.connectionString).toBe('postgres://localhost:5432');
   });
 
-  it('should forward rejected hooks to the onError handler with the scope', async function () {
+  it('should forward rejected hooks to the runner’s error handler with the scope', async function () {
     const failure = new Error('boom');
 
     class BrokenService {
@@ -3086,12 +3195,9 @@ describe('onConstruct', function () {
 
     let captured: { ex: unknown; scope: IContainer } | undefined;
     const container = new Container().useModule(
-      new OnConstructModule(
-        new SequentialAsync({
-          key: 'onConstruct',
-          onError: (scope) => (ex) => {
-            captured = { ex, scope };
-          },
+      onConstructModule(
+        run((scope) => (ex) => {
+          captured = { ex, scope };
         }),
       ),
     );
@@ -3108,27 +3214,60 @@ describe('onConstruct', function () {
 
 ```
 
-### OnScopeDisposed
+### Scope disposal hooks
 
 ```typescript
 import 'reflect-metadata';
 import {
-  OnDisposeModule,
   bindTo,
   Container,
   type HookFn,
+  hook,
+  HookCollector,
+  type HookType,
   inject,
-  onScopeDisposed,
   register,
   Registration as R,
-  SequentialSync,
   singleton,
+  type ExecutionContext,
+  type HookAction,
+  type IContainerModule,
 } from 'ts-ioc-container';
 
 const execute: HookFn = (ctx) => {
   ctx.invokeMethod({ args: ctx.resolveArgs() });
 };
 
+// The library ships no dispose decorator: the key, the decorator which writes it
+// and the collector which reads it are all ours.
+const onScopeDisposed = (fn: HookType) => hook('onScopeDisposed', fn);
+const onScopeDisposedHooks = new HookCollector({ key: 'onScopeDisposed' });
+
+// Naming the shape which performs collected actions is ours: the library
+// neither calls a runner nor is handed one.
+type HookRunner = (actions: HookAction[], context: ExecutionContext) => void;
+
+// This runner performs the collected hooks in order and never awaits.
+const run: HookRunner = (actions) => {
+  for (const { hook, context } of actions) {
+    hook(context);
+  }
+};
+
+// Disposal is a scope event, and hanging the collection off it is ours: the
+// library ships no module for that, and a module is just an `applyTo`. Every
+// instance of the scope is collected into one list, so the runner orders the
+// instances as well as the members.
+const onScopeDisposedModule = (run: HookRunner): IContainerModule => ({
+  applyTo: (container) =>
+    container.scopeDisposed.subscribe((scope) => {
+      run(
+        scope.getInstances().flatMap((instance) => onScopeDisposedHooks.getActions(instance, { scope })),
+        { scope },
+      );
+    }),
+});
+
 @register(bindTo('logsRepo'), singleton())
 class LogsRepo {
   savedLogs: string[] = [];
@@ -3157,7 +3296,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(new SequentialSync({ key: 'onScopeDisposed' })))
+      .useModule(onScopeDisposedModule(run))
       .addRegistration(R.fromClass(Logger))
       .addRegistration(R.fromClass(LogsRepo));
 
@@ -3177,7 +3316,7 @@ describe('onScopeDisposed', function () {
 
 ```typescript
 import 'reflect-metadata';
-import { Container, hook, injectProp, Registration, sequential, SequentialSync } from 'ts-ioc-container';
+import { Container, hook, HookCollector, injectProp, Registration, sequential, toTask } from 'ts-ioc-container';
 
 /**
  * UI Components - Property Injection
@@ -3192,8 +3331,8 @@ import { Container, hook, injectProp, Registration, sequential, SequentialSync }
 
 describe('inject property', () => {
   it('should inject property', () => {
-    // Strategy for the 'onInit' lifecycle hook
-    const onInitStrategy = new SequentialSync({ key: 'onInit' });
+    // Collector for the 'onInit' lifecycle hook
+    const onInit = new HookCollector({ key: 'onInit' });
 
     class UserViewModel {
       // Inject 'GreetingService' into 'greeting' property during 'onInit'
@@ -3210,15 +3349,18 @@ describe('inject property', () => {
     // 1. Create instance (dependencies not yet injected)
     const viewModel = container.resolve(UserViewModel);
 
-    // 2. Run lifecycle hooks to inject properties
-    onInitStrategy.execute(viewModel, { scope: container });
+    // 2. Collect the lifecycle hooks and run them to inject properties
+    onInit
+      .getActions(viewModel, { scope: container })
+      .map(toTask)
+      .forEach((task) => task());
 
     expect(viewModel.greetingService).toBe('Hello');
     expect(viewModel.display()).toBe('Hello User');
   });
 
   it('should read the applied instance property via getProperty', () => {
-    const onInitStrategy = new SequentialSync({ key: 'onInit' });
+    const onInit = new HookCollector({ key: 'onInit' });
 
     let injectedValue: unknown;
 
@@ -3235,7 +3377,10 @@ describe('inject property', () => {
     const container = new Container().addRegistration(Registration.fromValue('Hello').bindToKey('GreetingService'));
 
     const viewModel = container.resolve(UserViewModel);
-    onInitStrategy.execute(viewModel, { scope: container });
+    onInit
+      .getActions(viewModel, { scope: container })
+      .map(toTask)
+      .forEach((task) => task());
 
     expect(injectedValue).toBe('Hello');
   });

package/cjm/hooks/HookCollector.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toTask = exports.HookCollector = void 0;
+const target_1 = require("../metadata/target");
+const memoize_1 = require("../utils/memoize");
+const hook_1 = require("./hook");
+const HookContext_1 = require("./HookContext");
+class HookCollector {
+    key;
+    options;
+    hooksOf = (0, memoize_1.memoize)(hook_1.getHooks);
+    constructor({ key, createExecutionContext = HookContext_1.createHookExecutionContext, mapExecutionContext = (context) => context, predicate = () => true, }) {
+        this.key = key;
+        this.options = { createExecutionContext, mapExecutionContext, predicate };
+    }
+    hasHooks(target) {
+        return (0, hook_1.hasHooks)(target, this.key);
+    }
+    getActions(target, { scope, createExecutionContext = this.options.createExecutionContext, mapExecutionContext = this.options.mapExecutionContext, predicate = this.options.predicate, }) {
+        const actions = [];
+        for (const [methodName, fn] of this.hooksOf((0, target_1.resolveConstructor)(target), this.key)) {
+            if (predicate(methodName)) {
+                actions.push({
+                    hook: (0, hook_1.toHookFn)(fn),
+                    context: mapExecutionContext(createExecutionContext(target, scope, methodName)),
+                });
+            }
+        }
+        return actions;
+    }
+}
+exports.HookCollector = HookCollector;
+const toTask = ({ hook, context }) => () => hook(context);
+exports.toTask = toTask;

package/cjm/hooks/hook.js

@@ -5,23 +5,15 @@ exports.getHooks = getHooks;
 exports.hasHooks = hasHooks;
 const basic_1 = require("../utils/basic");
 const target_1 = require("../metadata/target");
+const getConstructorChain_1 = require("../utils/getConstructorChain");
 const isHookClassConstructor = (execute) => {
     return basic_1.Is.constructor(execute) && execute.prototype.execute;
 };
 const toHookFn = (execute) => isHookClassConstructor(execute) ? (context) => context.scope.resolve(execute).execute(context) : execute;
 exports.toHookFn = toHookFn;
-const getConstructorChain = (ctor) => {
-    const chain = [];
-    let current = ctor;
-    while (typeof current === 'function' && current !== Function.prototype) {
-        chain.push(current);
-        current = Object.getPrototypeOf(current);
-    }
-    return chain;
-};
 function getHooks(target, key) {
     const merged = new Map();
-    for (const ctor of getConstructorChain((0, target_1.resolveConstructor)(target)).reverse()) {
+    for (const ctor of (0, getConstructorChain_1.getConstructorChain)((0, target_1.resolveConstructor)(target)).reverse()) {
         const ownHooks = Reflect.getOwnMetadata(key, ctor);
         if (ownHooks) {
             for (const [methodName, fn] of ownHooks) {
@@ -32,7 +24,7 @@ function getHooks(target, key) {
     return merged;
 }
 function hasHooks(target, key) {
-    return getConstructorChain((0, target_1.resolveConstructor)(target)).some((ctor) => Reflect.hasOwnMetadata(key, ctor));
+    return (0, getConstructorChain_1.getConstructorChain)((0, target_1.resolveConstructor)(target)).some((ctor) => Reflect.hasOwnMetadata(key, ctor));
 }
 const hook = (key, fn) => (target, propertyKey) => {
     const hooks = Reflect.hasOwnMetadata(key, target.constructor)

package/cjm/index.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.onConstruct = exports.injectProp = exports.createHookExecutionContext = exports.createHookContextFactory = exports.HookContext = exports.toHookFn = exports.hasHooks = exports.hook = exports.getHooks = exports.TypedEventDisposedError = exports.UnsupportedTokenTypeError = exports.CannonSingletonApplyTwiceError = exports.ProviderDisposedError = exports.ContainerDisposedError = exports.MethodNotImplementedError = exports.DependencyMissingKeyError = exports.ContainerNotFoundError = exports.DependencyNotFoundError = exports.ContainerError = exports.Registration = exports.onResolve = exports.appendArgsFn = exports.appendArgs = exports.decorate = exports.singleton = exports.autoResolve = exports.lazy = exports.scopeAccess = exports.scope = exports.bindTo = exports.register = exports.toRegistrationFn = exports.toProviderFn = exports.toBindToken = exports.registerPipe = exports.isProviderPipe = exports.Provider = exports.ProxyInjector = exports.SimpleInjector = exports.resolveArgs = exports.argsFn = exports.args = exports.arg = exports.inject = exports.MetadataInjector = exports.Injector = exports.EmptyContainer = exports.AutoResolveModule = exports.Container = exports.isDependencyKey = void 0;
-exports.throttle = exports.runAtOnce = exports.runInOrder = exports.handleAsyncError = exports.handleError = exports.getMethodTags = exports.addMethodTag = exports.getMethodLabels = exports.addMethodLabel = exports.getMethodMeta = exports.addMethodMeta = exports.getParamTags = exports.addParamTag = exports.getParamLabels = exports.addParamLabel = exports.getParamMeta = exports.addParamMeta = exports.getClassTags = exports.addClassTag = exports.getClassLabels = exports.addClassLabel = exports.getClassMeta = exports.addClassMeta = exports.resolveConstructor = exports.GroupInstanceToken = exports.ConstantToken = exports.FunctionToken = exports.SingleToken = exports.ClassToken = exports.toSingleAlias = exports.SingleAliasToken = exports.toGroupAlias = exports.GroupAliasToken = exports.argToToken = exports.toMappedToken = exports.toToken = exports.InjectionToken = exports.ParallelAsync = exports.SequentialAsync = exports.SequentialSync = exports.HookExecutionStrategy = exports.oncePerInstance = exports.parallel = exports.sequential = exports.resolved = exports.OnResolvedModule = exports.onResolved = exports.OnDisposeModule = exports.onScopeDisposed = exports.OnConstructModule = void 0;
-exports.Is = exports.unwrapProxy = exports.ProxyRegistry = exports.pipe = exports.select = exports.TypedEvent = exports.once = exports.shallowCache = exports.debounce = void 0;
+exports.sequential = exports.injectProp = exports.createHookExecutionContext = exports.createHookContextFactory = exports.HookContext = exports.toHookFn = exports.hasHooks = exports.hook = exports.getHooks = exports.TypedEventDisposedError = exports.UnsupportedTokenTypeError = exports.CannonSingletonApplyTwiceError = exports.ProviderDisposedError = exports.ContainerDisposedError = exports.MethodNotImplementedError = exports.DependencyMissingKeyError = exports.ContainerNotFoundError = exports.DependencyNotFoundError = exports.ContainerError = exports.Registration = exports.onResolve = exports.appendArgsFn = exports.appendArgs = exports.decorate = exports.singleton = exports.autoResolve = exports.lazy = exports.scopeAccess = exports.scope = exports.bindTo = exports.register = exports.toRegistrationFn = exports.toProviderFn = exports.toBindToken = exports.registerPipe = exports.isProviderPipe = exports.Provider = exports.ProxyInjector = exports.SimpleInjector = exports.resolveArgs = exports.argsFn = exports.args = exports.arg = exports.inject = exports.MetadataInjector = exports.Injector = exports.EmptyContainer = exports.AutoResolveModule = exports.Container = exports.isDependencyKey = void 0;
+exports.ProxyRegistry = exports.pipe = exports.select = exports.TypedEvent = exports.getConstructorChain = exports.memoize = exports.once = exports.shallowCache = exports.debounce = exports.throttle = exports.runAtOnce = exports.runInOrder = exports.handleAsyncError = exports.handleError = exports.getMethodTags = exports.addMethodTag = exports.getMethodLabels = exports.addMethodLabel = exports.getMethodMeta = exports.addMethodMeta = exports.getParamTags = exports.addParamTag = exports.getParamLabels = exports.addParamLabel = exports.getParamMeta = exports.addParamMeta = exports.getClassTags = exports.addClassTag = exports.getClassLabels = exports.addClassLabel = exports.getClassMeta = exports.addClassMeta = exports.resolveConstructor = exports.GroupInstanceToken = exports.ConstantToken = exports.FunctionToken = exports.SingleToken = exports.ClassToken = exports.toSingleAlias = exports.SingleAliasToken = exports.toGroupAlias = exports.GroupAliasToken = exports.argToToken = exports.toMappedToken = exports.toToken = exports.InjectionToken = exports.toTask = exports.HookCollector = exports.oncePerInstance = exports.parallel = void 0;
+exports.Is = exports.unwrapProxy = 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");
@@ -76,28 +76,13 @@ Object.defineProperty(exports, "createHookContextFactory", { enumerable: true, g
 Object.defineProperty(exports, "createHookExecutionContext", { enumerable: true, get: function () { return HookContext_1.createHookExecutionContext; } });
 var injectProp_1 = require("./hooks/injectProp");
 Object.defineProperty(exports, "injectProp", { enumerable: true, get: function () { return injectProp_1.injectProp; } });
-var onConstruct_1 = require("./hooks/onConstruct");
-Object.defineProperty(exports, "onConstruct", { enumerable: true, get: function () { return onConstruct_1.onConstruct; } });
-Object.defineProperty(exports, "OnConstructModule", { enumerable: true, get: function () { return onConstruct_1.OnConstructModule; } });
-var onScopeDisposed_1 = require("./hooks/onScopeDisposed");
-Object.defineProperty(exports, "onScopeDisposed", { enumerable: true, get: function () { return onScopeDisposed_1.onScopeDisposed; } });
-Object.defineProperty(exports, "OnDisposeModule", { enumerable: true, get: function () { return onScopeDisposed_1.OnDisposeModule; } });
-var onResolved_1 = require("./hooks/onResolved");
-Object.defineProperty(exports, "onResolved", { enumerable: true, get: function () { return onResolved_1.onResolved; } });
-Object.defineProperty(exports, "OnResolvedModule", { enumerable: true, get: function () { return onResolved_1.OnResolvedModule; } });
-Object.defineProperty(exports, "resolved", { enumerable: true, get: function () { return onResolved_1.resolved; } });
 var combinators_1 = require("./hooks/combinators");
 Object.defineProperty(exports, "sequential", { enumerable: true, get: function () { return combinators_1.sequential; } });
 Object.defineProperty(exports, "parallel", { enumerable: true, get: function () { return combinators_1.parallel; } });
 Object.defineProperty(exports, "oncePerInstance", { enumerable: true, get: function () { return combinators_1.oncePerInstance; } });
-var HookExecutionStrategy_1 = require("./hooks/HookExecutionStrategy");
-Object.defineProperty(exports, "HookExecutionStrategy", { enumerable: true, get: function () { return HookExecutionStrategy_1.HookExecutionStrategy; } });
-var SequentialSync_1 = require("./hooks/SequentialSync");
-Object.defineProperty(exports, "SequentialSync", { enumerable: true, get: function () { return SequentialSync_1.SequentialSync; } });
-var SequentialAsync_1 = require("./hooks/SequentialAsync");
-Object.defineProperty(exports, "SequentialAsync", { enumerable: true, get: function () { return SequentialAsync_1.SequentialAsync; } });
-var ParallelAsync_1 = require("./hooks/ParallelAsync");
-Object.defineProperty(exports, "ParallelAsync", { enumerable: true, get: function () { return ParallelAsync_1.ParallelAsync; } });
+var HookCollector_1 = require("./hooks/HookCollector");
+Object.defineProperty(exports, "HookCollector", { enumerable: true, get: function () { return HookCollector_1.HookCollector; } });
+Object.defineProperty(exports, "toTask", { enumerable: true, get: function () { return HookCollector_1.toTask; } });
 var InjectionToken_1 = require("./token/InjectionToken");
 Object.defineProperty(exports, "InjectionToken", { enumerable: true, get: function () { return InjectionToken_1.InjectionToken; } });
 var toToken_1 = require("./token/toToken");
@@ -157,6 +142,10 @@ var shallowCache_1 = require("./utils/shallowCache");
 Object.defineProperty(exports, "shallowCache", { enumerable: true, get: function () { return shallowCache_1.shallowCache; } });
 var once_1 = require("./utils/once");
 Object.defineProperty(exports, "once", { enumerable: true, get: function () { return once_1.once; } });
+var memoize_1 = require("./utils/memoize");
+Object.defineProperty(exports, "memoize", { enumerable: true, get: function () { return memoize_1.memoize; } });
+var getConstructorChain_1 = require("./utils/getConstructorChain");
+Object.defineProperty(exports, "getConstructorChain", { enumerable: true, get: function () { return getConstructorChain_1.getConstructorChain; } });
 var TypedEvent_1 = require("./utils/TypedEvent");
 Object.defineProperty(exports, "TypedEvent", { enumerable: true, get: function () { return TypedEvent_1.TypedEvent; } });
 var select_1 = require("./select");

package/cjm/utils/getConstructorChain.js

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

package/cjm/utils/memoize.js

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

package/esm/hooks/HookCollector.js

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

package/esm/hooks/hook.js

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

package/esm/index.js

@@ -22,14 +22,8 @@ export { TypedEventDisposedError } from './errors/TypedEventDisposedError.js';
 export { getHooks, hook, hasHooks, toHookFn, } from './hooks/hook.js';
 export { HookContext, createHookContextFactory, createHookExecutionContext, } from './hooks/HookContext.js';
 export { injectProp } from './hooks/injectProp.js';
-export { onConstruct, OnConstructModule } from './hooks/onConstruct.js';
-export { onScopeDisposed, OnDisposeModule } from './hooks/onScopeDisposed.js';
-export { onResolved, OnResolvedModule, resolved } from './hooks/onResolved.js';
 export { sequential, parallel, oncePerInstance } from './hooks/combinators.js';
-export { HookExecutionStrategy, } from './hooks/HookExecutionStrategy.js';
-export { SequentialSync } from './hooks/SequentialSync.js';
-export { SequentialAsync } from './hooks/SequentialAsync.js';
-export { ParallelAsync } from './hooks/ParallelAsync.js';
+export { HookCollector, toTask, } from './hooks/HookCollector.js';
 export { InjectionToken } from './token/InjectionToken.js';
 export { toToken, toMappedToken, argToToken } from './token/toToken.js';
 export { GroupAliasToken, toGroupAlias } from './token/GroupAliasToken.js';
@@ -49,6 +43,8 @@ export { throttle } from './utils/throttle.js';
 export { debounce } from './utils/debounce.js';
 export { shallowCache } from './utils/shallowCache.js';
 export { once } from './utils/once.js';
+export { memoize } from './utils/memoize.js';
+export { getConstructorChain } from './utils/getConstructorChain.js';
 export { TypedEvent } from './utils/TypedEvent.js';
 export { select } from './select.js';
 export { pipe } from './utils/fp.js';

package/esm/utils/getConstructorChain.js

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

package/esm/utils/memoize.js

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

package/package.json

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

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

package/typings/index.d.ts

@@ -23,14 +23,8 @@ export { TypedEventDisposedError } from './errors/TypedEventDisposedError.js';
 export { getHooks, hook, hasHooks, toHookFn, type HookFn, type HookClass, type HookType, type InjectFn, type HooksOfClass, } from './hooks/hook.js';
 export { HookContext, createHookContextFactory, createHookExecutionContext, type CreateHookExecutionContext, type IHookContext, } from './hooks/HookContext.js';
 export { injectProp } from './hooks/injectProp.js';
-export { onConstruct, OnConstructModule } from './hooks/onConstruct.js';
-export { onScopeDisposed, OnDisposeModule } from './hooks/onScopeDisposed.js';
-export { onResolved, OnResolvedModule, resolved } from './hooks/onResolved.js';
 export { sequential, parallel, oncePerInstance, type ResolvedObjectHook } from './hooks/combinators.js';
-export { HookExecutionStrategy, type HookExecutionContext, type HookExecutionOptions, type HookExecutionStrategyProps, type MapHookExecutionContext, type MemberHook, type OnErrorHandler, } from './hooks/HookExecutionStrategy.js';
-export { SequentialSync } from './hooks/SequentialSync.js';
-export { SequentialAsync } from './hooks/SequentialAsync.js';
-export { ParallelAsync } from './hooks/ParallelAsync.js';
+export { HookCollector, toTask, type HookAction, type HookCollectionContext, type HookCollectorOptions, type HookCollectorProps, type MapHookExecutionContext, } from './hooks/HookCollector.js';
 export { InjectionToken } from './token/InjectionToken.js';
 export { type Injectable, toToken, toMappedToken, argToToken } from './token/toToken.js';
 export { GroupAliasToken, toGroupAlias } from './token/GroupAliasToken.js';
@@ -50,6 +44,8 @@ export { throttle } from './utils/throttle.js';
 export { debounce } from './utils/debounce.js';
 export { shallowCache } from './utils/shallowCache.js';
 export { once } from './utils/once.js';
+export { memoize } from './utils/memoize.js';
+export { getConstructorChain } from './utils/getConstructorChain.js';
 export { TypedEvent, type ITypedEvent, type TypedEventListener, type Unsubscribe } from './utils/TypedEvent.js';
 export { type ExecutionContext } from './ExecutionContext.js';
 export { select } from './select.js';

package/typings/utils/getConstructorChain.d.ts

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

package/typings/utils/memoize.d.ts

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

package/cjm/hooks/HookExecutionStrategy.js

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

package/cjm/hooks/ParallelAsync.js

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

package/cjm/hooks/SequentialAsync.js

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

package/cjm/hooks/SequentialSync.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SequentialSync = void 0;
-const HookExecutionStrategy_1 = require("./HookExecutionStrategy");
-class SequentialSync extends HookExecutionStrategy_1.HookExecutionStrategy {
-    processHooks(members) {
-        for (const { hook, context } of members) {
-            hook(context);
-        }
-    }
-}
-exports.SequentialSync = SequentialSync;

package/cjm/hooks/onConstruct.js

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

package/cjm/hooks/onResolved.js

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

package/cjm/hooks/onScopeDisposed.js

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

package/esm/hooks/HookExecutionStrategy.js

@@ -1,44 +0,0 @@
-import { resolveConstructor } from '../metadata/target.js';
-import { getHooks, hasHooks, toHookFn } from './hook.js';
-import { createHookExecutionContext } from './HookContext.js';
-export class HookExecutionStrategy {
-    key;
-    onError;
-    options;
-    hooksByClass = new WeakMap();
-    constructor({ key, onError, createExecutionContext = createHookExecutionContext, mapExecutionContext = (context) => context, predicate = () => true, }) {
-        this.key = key;
-        this.onError = onError;
-        this.options = { createExecutionContext, mapExecutionContext, predicate };
-    }
-    hasHooks(target) {
-        return hasHooks(target, this.key);
-    }
-    execute(target, { scope, ...overrides }) {
-        const report = (ex) => this.onError?.(scope)(ex);
-        try {
-            this.processHooks(this.collect(target, scope, overrides))?.catch(report);
-        }
-        catch (ex) {
-            report(ex);
-        }
-    }
-    collect(target, scope, { createExecutionContext = this.options.createExecutionContext, mapExecutionContext = this.options.mapExecutionContext, predicate = this.options.predicate, }) {
-        const members = [];
-        for (const { methodName, hook } of this.hooksOf(target)) {
-            if (predicate(methodName)) {
-                members.push({ hook, context: mapExecutionContext(createExecutionContext(target, scope, methodName)) });
-            }
-        }
-        return members;
-    }
-    hooksOf(target) {
-        const Target = resolveConstructor(target);
-        let hooks = this.hooksByClass.get(Target);
-        if (!hooks) {
-            hooks = Array.from(getHooks(Target, this.key), ([methodName, fn]) => ({ methodName, hook: toHookFn(fn) }));
-            this.hooksByClass.set(Target, hooks);
-        }
-        return hooks;
-    }
-}

package/esm/hooks/ParallelAsync.js

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

package/esm/hooks/SequentialAsync.js

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

package/esm/hooks/SequentialSync.js

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

package/esm/hooks/onConstruct.js

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

package/esm/hooks/onResolved.js

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

package/esm/hooks/onScopeDisposed.js

@@ -1,15 +0,0 @@
-import { hook } from './hook.js';
-export const onScopeDisposed = (fn) => hook('onScopeDisposed', fn);
-export class OnDisposeModule {
-    strategy;
-    constructor(strategy) {
-        this.strategy = strategy;
-    }
-    applyTo(container) {
-        container.scopeDisposed.subscribe((scope) => {
-            for (const instance of scope.getInstances()) {
-                this.strategy.execute(instance, { scope });
-            }
-        });
-    }
-}

package/typings/hooks/HookExecutionStrategy.d.ts

@@ -1,33 +0,0 @@
-import type { IContainer } from '../container/IContainer.js';
-import type { ExecutionContext } from '../ExecutionContext.js';
-import { type Instance } from '../utils/basic.js';
-import { type HookFn } from './hook.js';
-import { type CreateHookExecutionContext, type IHookContext } from './HookContext.js';
-export type MapHookExecutionContext = (context: IHookContext) => IHookContext;
-export type OnErrorHandler = (scope: IContainer) => (error: unknown) => void;
-export type HookExecutionOptions = {
-    createExecutionContext?: CreateHookExecutionContext;
-    mapExecutionContext?: MapHookExecutionContext;
-    predicate?: (methodName: string) => boolean;
-};
-export type HookExecutionContext = ExecutionContext & HookExecutionOptions;
-export type HookExecutionStrategyProps = HookExecutionOptions & {
-    key: string | symbol;
-    onError?: OnErrorHandler;
-};
-export type MemberHook = {
-    hook: HookFn;
-    context: IHookContext;
-};
-export declare abstract class HookExecutionStrategy {
-    private readonly key;
-    private readonly onError?;
-    private readonly options;
-    private readonly hooksByClass;
-    constructor({ key, onError, createExecutionContext, mapExecutionContext, predicate, }: HookExecutionStrategyProps);
-    hasHooks(target: Instance): boolean;
-    execute(target: Instance, { scope, ...overrides }: HookExecutionContext): void;
-    protected abstract processHooks(members: MemberHook[]): void | Promise<void>;
-    private collect;
-    private hooksOf;
-}

package/typings/hooks/ParallelAsync.d.ts

@@ -1,4 +0,0 @@
-import { HookExecutionStrategy, type MemberHook } from './HookExecutionStrategy.js';
-export declare class ParallelAsync extends HookExecutionStrategy {
-    protected processHooks(members: MemberHook[]): void | Promise<void>;
-}

package/typings/hooks/SequentialAsync.d.ts

@@ -1,4 +0,0 @@
-import { HookExecutionStrategy, type MemberHook } from './HookExecutionStrategy.js';
-export declare class SequentialAsync extends HookExecutionStrategy {
-    protected processHooks(members: MemberHook[]): void | Promise<void>;
-}

package/typings/hooks/SequentialSync.d.ts

@@ -1,4 +0,0 @@
-import { HookExecutionStrategy, type MemberHook } from './HookExecutionStrategy.js';
-export declare class SequentialSync extends HookExecutionStrategy {
-    protected processHooks(members: MemberHook[]): void;
-}

package/typings/hooks/onConstruct.d.ts

@@ -1,9 +0,0 @@
-import { type HookType } from './hook.js';
-import type { IContainer, IContainerModule } from '../container/IContainer.js';
-import { type HookExecutionStrategy } from './HookExecutionStrategy.js';
-export declare const onConstruct: (fn: HookType) => (target: object, propertyKey: string | symbol) => void;
-export declare class OnConstructModule implements IContainerModule {
-    private readonly strategy;
-    constructor(strategy: HookExecutionStrategy);
-    applyTo(container: IContainer): void;
-}

package/typings/hooks/onResolved.d.ts

@@ -1,10 +0,0 @@
-import type { IContainer, IContainerModule } from '../container/IContainer.js';
-import { type HookExecutionStrategy } from './HookExecutionStrategy.js';
-import { type HookType } from './hook.js';
-export declare const onResolved: (fn: HookType) => (target: object, propertyKey: string | symbol) => void;
-export declare class OnResolvedModule implements IContainerModule {
-    private readonly runHooks;
-    constructor(strategy: HookExecutionStrategy);
-    applyTo(container: IContainer): void;
-}
-export declare const resolved: <T = unknown>(strategy: HookExecutionStrategy) => import("../registration/IRegistration.js").ProviderPipe<T>;

package/typings/hooks/onScopeDisposed.d.ts

@@ -1,9 +0,0 @@
-import { type HookType } from './hook.js';
-import type { IContainer, IContainerModule } from '../container/IContainer.js';
-import { type HookExecutionStrategy } from './HookExecutionStrategy.js';
-export declare const onScopeDisposed: (fn: HookType) => (target: object, propertyKey: string | symbol) => void;
-export declare class OnDisposeModule implements IContainerModule {
-    private readonly strategy;
-    constructor(strategy: HookExecutionStrategy);
-    applyTo(container: IContainer): void;
-}