ts-ioc-container 65.0.0 → 67.0.0

package/README.md

@@ -162,7 +162,7 @@ describe('Quickstart', function () {
 - Lazy token: `select.token('Service').lazy()`
 - Inject decorator: `@inject('Key')`
 - Map an injected value: `@inject('Key', sanitize(), validate())`
-- Property inject: `@hook('onInit', append(injectProp('Key')))`
+- Property inject: `@hook('onInit', injectProp('Key'))`
 
 > [!TIP]
 > For classes, prefer the `@register(bindTo('Key'))` decorator over the fluent
@@ -2385,6 +2385,8 @@ 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.
+
 ```typescript
 import 'reflect-metadata';
 import { Container, type IContainer, onResolve, register, Registration as R, singleton } from 'ts-ioc-container';
@@ -2809,41 +2811,51 @@ describe('Container Modules', function () {
 
 Sometimes you need to invoke methods after construct or dispose of class. This is what hooks are for.
 
-The generic `@hook` decorator takes a hook key and a map function
-`(...prev: HookType[]) => HookType[]`, where `prev` is the list of hooks already
-registered on the class for the decorated member. Use `appendHooks` /
-`prependHooks` (exported as `append` / `prepend` too) to place new hooks around
-the existing ones:
+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:
 
 ```typescript
 class OrderService {
-  @hook('actions', append(validate, persist))
-  @hook('actions', prepend(authorize))
+  @hook('actions', sequential(authorize, validate, persist))
   submit() {}
+
+  @onScopeDisposed(parallel(flushMetrics, closeSocket))
+  destroy() {}
 }
 ```
 
-Decorators are applied bottom-up, so `authorize` runs first, then `validate` and
-`persist`. Any other map function works as well — for example
-`(...prev) => [...prev].reverse()` to reorder, or `() => [onlyThisOne]` to
-replace the accumulated hooks.
+- `sequential(...hooks)` runs them in declaration order, awaiting each one that
+  goes async before the next.
+- `parallel(...hooks)` starts them all at once and settles when every one has.
+- `oncePerInstance(hook)` runs its hook a single time per instance, however
+  often the event fires.
 
-`@onConstruct` and `@onScopeDisposed` keep their variadic signature and
-compensate for the bottom-up application order, so stacked decorators run in
-declaration order: `@onConstruct(h1) @onConstruct(h2)` runs `h1` before `h2`.
+They compose, because each returns an ordinary `HookFn`:
+`oncePerInstance(sequential(connect, warmUp))`, or a `parallel(...)` nested
+inside a `sequential(...)`. A hook class (`HookType`) may be passed anywhere a
+hook function can. Writing your own combinator needs nothing from the library
+beyond `toHookFn`.
+
+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), 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    |
+(`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    |
 
 ```typescript
 const container = new Container()
@@ -2915,15 +2927,26 @@ and `OnResolvedModule` reaches every provider through `registered`.
 
 ### OnConstruct
 
+> **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
+> the provider's `decorate(...)` chain wraps it, so a hook sees the bare
+> instance rather than what the caller receives. `@onResolved` 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.
+
 ```typescript
 import 'reflect-metadata';
 import {
-  OnConstructModule,
   Container,
   type HookFn,
   type IContainer,
   inject,
   onConstruct,
+  OnConstructModule,
   Registration as R,
   SequentialAsync,
   SequentialSync,
@@ -3154,7 +3177,7 @@ describe('onScopeDisposed', function () {
 
 ```typescript
 import 'reflect-metadata';
-import { append, Container, hook, SequentialSync, injectProp, Registration } from 'ts-ioc-container';
+import { Container, hook, injectProp, Registration, sequential, SequentialSync } from 'ts-ioc-container';
 
 /**
  * UI Components - Property Injection
@@ -3174,7 +3197,7 @@ describe('inject property', () => {
 
     class UserViewModel {
       // Inject 'GreetingService' into 'greeting' property during 'onInit'
-      @hook('onInit', append(injectProp('GreetingService')))
+      @hook('onInit', injectProp('GreetingService'))
       greetingService!: string;
 
       display(): string {
@@ -3202,7 +3225,7 @@ describe('inject property', () => {
     class UserViewModel {
       @hook(
         'onInit',
-        append(injectProp('GreetingService'), (context) => {
+        sequential(injectProp('GreetingService'), (context) => {
           injectedValue = context.getProperty();
         }),
       )

package/cjm/hooks/HookExecutionStrategy.js

@@ -1,29 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HookExecutionStrategy = exports.runAtOnce = exports.runInOrder = void 0;
+exports.HookExecutionStrategy = 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;
@@ -48,9 +28,9 @@ class HookExecutionStrategy {
     }
     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)) {
+        for (const { methodName, hook } of this.hooksOf(target)) {
             if (predicate(methodName)) {
-                members.push({ hooks, context: mapExecutionContext(createExecutionContext(target, scope, methodName)) });
+                members.push({ hook, context: mapExecutionContext(createExecutionContext(target, scope, methodName)) });
             }
         }
         return members;
@@ -59,7 +39,7 @@ class HookExecutionStrategy {
         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) }));
+            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;

package/cjm/hooks/ParallelAsync.js

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

package/cjm/hooks/SequentialAsync.js

@@ -1,15 +1,11 @@
 "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));
-            }
-        }
+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

@@ -4,10 +4,8 @@ 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);
-            }
+        for (const { hook, context } of members) {
+            hook(context);
         }
     }
 }

package/cjm/hooks/combinators.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.oncePerInstance = exports.parallel = exports.sequential = void 0;
+const task_1 = require("../utils/task");
+const hook_1 = require("./hook");
+const sequential = (...hooks) => {
+    const fns = hooks.map(hook_1.toHookFn);
+    return (context) => (0, task_1.runInOrder)(fns.map((fn) => () => fn(context)));
+};
+exports.sequential = sequential;
+const parallel = (...hooks) => {
+    const fns = hooks.map(hook_1.toHookFn);
+    return (context) => (0, task_1.runAtOnce)(fns.map((fn) => () => fn(context)));
+};
+exports.parallel = parallel;
+const oncePerInstance = (execute) => {
+    const invokedInstances = new WeakSet();
+    const fn = (0, hook_1.toHookFn)(execute);
+    return (context) => {
+        if (invokedInstances.has(context.instance)) {
+            return;
+        }
+        invokedInstances.add(context.instance);
+        return fn(context);
+    };
+};
+exports.oncePerInstance = oncePerInstance;

package/cjm/hooks/hook.js

@@ -1,16 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.hook = exports.toHookFn = exports.prepend = exports.append = exports.prependHooks = exports.appendHooks = void 0;
+exports.hook = exports.toHookFn = void 0;
 exports.getHooks = getHooks;
 exports.hasHooks = hasHooks;
 const basic_1 = require("../utils/basic");
 const target_1 = require("../metadata/target");
-const appendHooks = (...fns) => (...prev) => [...prev, ...fns];
-exports.appendHooks = appendHooks;
-const prependHooks = (...fns) => (...prev) => [...fns, ...prev];
-exports.prependHooks = prependHooks;
-exports.append = exports.appendHooks;
-exports.prepend = exports.prependHooks;
 const isHookClassConstructor = (execute) => {
     return basic_1.Is.constructor(execute) && execute.prototype.execute;
 };
@@ -30,8 +24,8 @@ function getHooks(target, key) {
     for (const ctor of getConstructorChain((0, target_1.resolveConstructor)(target)).reverse()) {
         const ownHooks = Reflect.getOwnMetadata(key, ctor);
         if (ownHooks) {
-            for (const [methodName, fns] of ownHooks) {
-                merged.set(methodName, fns);
+            for (const [methodName, fn] of ownHooks) {
+                merged.set(methodName, fn);
             }
         }
     }
@@ -40,11 +34,11 @@ function getHooks(target, key) {
 function hasHooks(target, key) {
     return getConstructorChain((0, target_1.resolveConstructor)(target)).some((ctor) => Reflect.hasOwnMetadata(key, ctor));
 }
-const hook = (key, mapFn) => (target, propertyKey) => {
+const hook = (key, fn) => (target, propertyKey) => {
     const hooks = Reflect.hasOwnMetadata(key, target.constructor)
         ? Reflect.getOwnMetadata(key, target.constructor)
         : new Map();
-    hooks.set(propertyKey, mapFn(...(hooks.get(propertyKey) ?? [])));
+    hooks.set(propertyKey, fn);
     Reflect.defineMetadata(key, hooks, target.constructor);
 };
 exports.hook = hook;

package/cjm/hooks/onConstruct.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OnConstructModule = exports.onConstruct = void 0;
 const hook_1 = require("./hook");
-const onConstruct = (...fns) => (0, hook_1.hook)('onConstruct', (0, hook_1.prependHooks)(...fns));
+const onConstruct = (fn) => (0, hook_1.hook)('onConstruct', fn);
 exports.onConstruct = onConstruct;
 class OnConstructModule {
     strategy;

package/cjm/hooks/onResolved.js

@@ -4,7 +4,7 @@ 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 = (...hooks) => (0, hook_1.hook)('onResolved', (0, hook_1.prependHooks)(...hooks));
+const onResolved = (fn) => (0, hook_1.hook)('onResolved', fn);
 exports.onResolved = onResolved;
 const runHooks = (strategy) => (dependency, scope) => {
     if (basic_1.Is.object(dependency)) {

package/cjm/hooks/onScopeDisposed.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OnDisposeModule = exports.onScopeDisposed = void 0;
 const hook_1 = require("./hook");
-const onScopeDisposed = (...fns) => (0, hook_1.hook)('onScopeDisposed', (0, hook_1.prependHooks)(...fns));
+const onScopeDisposed = (fn) => (0, hook_1.hook)('onScopeDisposed', fn);
 exports.onScopeDisposed = onScopeDisposed;
 class OnDisposeModule {
     strategy;

package/cjm/index.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createHookContextFactory = exports.HookContext = exports.prepend = exports.append = exports.prependHooks = exports.appendHooks = exports.hasHooks = exports.hook = exports.getHooks = exports.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.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.AsyncHookExecutionStrategy = exports.HookExecutionStrategy = exports.oncePerInstance = exports.resolved = exports.OnResolvedModule = exports.onResolved = exports.OnDisposeModule = exports.onScopeDisposed = exports.OnConstructModule = exports.onConstruct = exports.injectProp = exports.createHookExecutionContext = void 0;
+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;
 var IContainer_1 = require("./container/IContainer");
 Object.defineProperty(exports, "isDependencyKey", { enumerable: true, get: function () { return IContainer_1.isDependencyKey; } });
@@ -69,10 +69,7 @@ var hook_1 = require("./hooks/hook");
 Object.defineProperty(exports, "getHooks", { enumerable: true, get: function () { return hook_1.getHooks; } });
 Object.defineProperty(exports, "hook", { enumerable: true, get: function () { return hook_1.hook; } });
 Object.defineProperty(exports, "hasHooks", { enumerable: true, get: function () { return hook_1.hasHooks; } });
-Object.defineProperty(exports, "appendHooks", { enumerable: true, get: function () { return hook_1.appendHooks; } });
-Object.defineProperty(exports, "prependHooks", { enumerable: true, get: function () { return hook_1.prependHooks; } });
-Object.defineProperty(exports, "append", { enumerable: true, get: function () { return hook_1.append; } });
-Object.defineProperty(exports, "prepend", { enumerable: true, get: function () { return hook_1.prepend; } });
+Object.defineProperty(exports, "toHookFn", { enumerable: true, get: function () { return hook_1.toHookFn; } });
 var HookContext_1 = require("./hooks/HookContext");
 Object.defineProperty(exports, "HookContext", { enumerable: true, get: function () { return HookContext_1.HookContext; } });
 Object.defineProperty(exports, "createHookContextFactory", { enumerable: true, get: function () { return HookContext_1.createHookContextFactory; } });
@@ -89,12 +86,12 @@ 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 resolveHooks_1 = require("./hooks/resolveHooks");
-Object.defineProperty(exports, "oncePerInstance", { enumerable: true, get: function () { return resolveHooks_1.oncePerInstance; } });
+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 AsyncHookExecutionStrategy_1 = require("./hooks/AsyncHookExecutionStrategy");
-Object.defineProperty(exports, "AsyncHookExecutionStrategy", { enumerable: true, get: function () { return AsyncHookExecutionStrategy_1.AsyncHookExecutionStrategy; } });
 var SequentialSync_1 = require("./hooks/SequentialSync");
 Object.defineProperty(exports, "SequentialSync", { enumerable: true, get: function () { return SequentialSync_1.SequentialSync; } });
 var SequentialAsync_1 = require("./hooks/SequentialAsync");
@@ -149,6 +146,9 @@ Object.defineProperty(exports, "getMethodTags", { enumerable: true, get: functio
 var errorHandler_1 = require("./utils/errorHandler");
 Object.defineProperty(exports, "handleError", { enumerable: true, get: function () { return errorHandler_1.handleError; } });
 Object.defineProperty(exports, "handleAsyncError", { enumerable: true, get: function () { return errorHandler_1.handleAsyncError; } });
+var task_1 = require("./utils/task");
+Object.defineProperty(exports, "runInOrder", { enumerable: true, get: function () { return task_1.runInOrder; } });
+Object.defineProperty(exports, "runAtOnce", { enumerable: true, get: function () { return task_1.runAtOnce; } });
 var throttle_1 = require("./utils/throttle");
 Object.defineProperty(exports, "throttle", { enumerable: true, get: function () { return throttle_1.throttle; } });
 var debounce_1 = require("./utils/debounce");

package/cjm/utils/task.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runAtOnce = exports.runInOrder = void 0;
+const runInOrder = (tasks, from = 0) => {
+    for (let i = from; i < tasks.length; i++) {
+        const result = tasks[i]();
+        if (result instanceof Promise) {
+            return result.then(() => (0, exports.runInOrder)(tasks, i + 1));
+        }
+    }
+};
+exports.runInOrder = runInOrder;
+const runAtOnce = (tasks) => {
+    const pending = [];
+    for (const task of tasks) {
+        const result = task();
+        if (result instanceof Promise) {
+            pending.push(result);
+        }
+    }
+    return pending.length > 0 ? Promise.all(pending).then(() => undefined) : undefined;
+};
+exports.runAtOnce = runAtOnce;

package/esm/hooks/HookExecutionStrategy.js

@@ -1,24 +1,6 @@
 import { resolveConstructor } from '../metadata/target.js';
 import { getHooks, hasHooks, toHookFn } from './hook.js';
 import { createHookExecutionContext } from './HookContext.js';
-export 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(() => runInOrder(hooks, context, i + 1));
-        }
-    }
-};
-export 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;
-};
 export class HookExecutionStrategy {
     key;
     onError;
@@ -43,9 +25,9 @@ export class HookExecutionStrategy {
     }
     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)) {
+        for (const { methodName, hook } of this.hooksOf(target)) {
             if (predicate(methodName)) {
-                members.push({ hooks, context: mapExecutionContext(createExecutionContext(target, scope, methodName)) });
+                members.push({ hook, context: mapExecutionContext(createExecutionContext(target, scope, methodName)) });
             }
         }
         return members;
@@ -54,7 +36,7 @@ export class HookExecutionStrategy {
         const Target = resolveConstructor(target);
         let hooks = this.hooksByClass.get(Target);
         if (!hooks) {
-            hooks = Array.from(getHooks(Target, this.key), ([methodName, fns]) => ({ methodName, hooks: fns.map(toHookFn) }));
+            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,13 +1,7 @@
-import { AsyncHookExecutionStrategy } from './AsyncHookExecutionStrategy.js';
-export class ParallelAsync extends AsyncHookExecutionStrategy {
+import { HookExecutionStrategy } from './HookExecutionStrategy.js';
+import { runAtOnce } from '../utils/task.js';
+export class ParallelAsync extends HookExecutionStrategy {
     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;
+        return runAtOnce(members.map(({ hook, context }) => () => hook(context)));
     }
 }

package/esm/hooks/SequentialAsync.js

@@ -1,11 +1,7 @@
-import { AsyncHookExecutionStrategy } from './AsyncHookExecutionStrategy.js';
-export class SequentialAsync extends 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));
-            }
-        }
+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,10 +1,8 @@
 import { HookExecutionStrategy } from './HookExecutionStrategy.js';
 export class SequentialSync extends HookExecutionStrategy {
     processHooks(members) {
-        for (const { hooks, context } of members) {
-            for (const hook of hooks) {
-                hook(context);
-            }
+        for (const { hook, context } of members) {
+            hook(context);
         }
     }
 }

package/esm/hooks/combinators.js

@@ -0,0 +1,21 @@
+import { runAtOnce, runInOrder } from '../utils/task.js';
+import { toHookFn } from './hook.js';
+export const sequential = (...hooks) => {
+    const fns = hooks.map(toHookFn);
+    return (context) => runInOrder(fns.map((fn) => () => fn(context)));
+};
+export const parallel = (...hooks) => {
+    const fns = hooks.map(toHookFn);
+    return (context) => runAtOnce(fns.map((fn) => () => fn(context)));
+};
+export const oncePerInstance = (execute) => {
+    const invokedInstances = new WeakSet();
+    const fn = toHookFn(execute);
+    return (context) => {
+        if (invokedInstances.has(context.instance)) {
+            return;
+        }
+        invokedInstances.add(context.instance);
+        return fn(context);
+    };
+};

package/esm/hooks/hook.js

@@ -1,9 +1,5 @@
 import { Is } from '../utils/basic.js';
 import { resolveConstructor } from '../metadata/target.js';
-export const appendHooks = (...fns) => (...prev) => [...prev, ...fns];
-export const prependHooks = (...fns) => (...prev) => [...fns, ...prev];
-export const append = appendHooks;
-export const prepend = prependHooks;
 const isHookClassConstructor = (execute) => {
     return Is.constructor(execute) && execute.prototype.execute;
 };
@@ -22,8 +18,8 @@ export function getHooks(target, key) {
     for (const ctor of getConstructorChain(resolveConstructor(target)).reverse()) {
         const ownHooks = Reflect.getOwnMetadata(key, ctor);
         if (ownHooks) {
-            for (const [methodName, fns] of ownHooks) {
-                merged.set(methodName, fns);
+            for (const [methodName, fn] of ownHooks) {
+                merged.set(methodName, fn);
             }
         }
     }
@@ -32,10 +28,10 @@ export function getHooks(target, key) {
 export function hasHooks(target, key) {
     return getConstructorChain(resolveConstructor(target)).some((ctor) => Reflect.hasOwnMetadata(key, ctor));
 }
-export const hook = (key, mapFn) => (target, propertyKey) => {
+export const hook = (key, fn) => (target, propertyKey) => {
     const hooks = Reflect.hasOwnMetadata(key, target.constructor)
         ? Reflect.getOwnMetadata(key, target.constructor)
         : new Map();
-    hooks.set(propertyKey, mapFn(...(hooks.get(propertyKey) ?? [])));
+    hooks.set(propertyKey, fn);
     Reflect.defineMetadata(key, hooks, target.constructor);
 };

package/esm/hooks/onConstruct.js

@@ -1,5 +1,5 @@
-import { hook, prependHooks } from './hook.js';
-export const onConstruct = (...fns) => hook('onConstruct', prependHooks(...fns));
+import { hook } from './hook.js';
+export const onConstruct = (fn) => hook('onConstruct', fn);
 export class OnConstructModule {
     strategy;
     constructor(strategy) {

package/esm/hooks/onResolved.js

@@ -1,7 +1,7 @@
 import { registerPipe } from '../registration/IRegistration.js';
 import { Is } from '../utils/basic.js';
-import { hook, prependHooks } from './hook.js';
-export const onResolved = (...hooks) => hook('onResolved', prependHooks(...hooks));
+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 });

package/esm/hooks/onScopeDisposed.js

@@ -1,5 +1,5 @@
-import { hook, prependHooks } from './hook.js';
-export const onScopeDisposed = (...fns) => hook('onScopeDisposed', prependHooks(...fns));
+import { hook } from './hook.js';
+export const onScopeDisposed = (fn) => hook('onScopeDisposed', fn);
 export class OnDisposeModule {
     strategy;
     constructor(strategy) {

package/esm/index.js

@@ -19,15 +19,14 @@ export { ProviderDisposedError } from './errors/ProviderDisposedError.js';
 export { CannonSingletonApplyTwiceError } from './errors/CannonSingletonApplyTwiceError.js';
 export { UnsupportedTokenTypeError } from './errors/UnsupportedTokenTypeError.js';
 export { TypedEventDisposedError } from './errors/TypedEventDisposedError.js';
-export { getHooks, hook, hasHooks, appendHooks, prependHooks, append, prepend, } from './hooks/hook.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 { oncePerInstance } from './hooks/resolveHooks.js';
+export { sequential, parallel, oncePerInstance } from './hooks/combinators.js';
 export { HookExecutionStrategy, } from './hooks/HookExecutionStrategy.js';
-export { AsyncHookExecutionStrategy, } from './hooks/AsyncHookExecutionStrategy.js';
 export { SequentialSync } from './hooks/SequentialSync.js';
 export { SequentialAsync } from './hooks/SequentialAsync.js';
 export { ParallelAsync } from './hooks/ParallelAsync.js';
@@ -45,6 +44,7 @@ export { addClassMeta, getClassMeta, addClassLabel, getClassLabels, addClassTag,
 export { addParamMeta, getParamMeta, addParamLabel, getParamLabels, addParamTag, getParamTags, } from './metadata/parameter.js';
 export { addMethodMeta, getMethodMeta, addMethodLabel, getMethodLabels, addMethodTag, getMethodTags, } from './metadata/method.js';
 export { handleError, handleAsyncError } from './utils/errorHandler.js';
+export { runInOrder, runAtOnce } from './utils/task.js';
 export { throttle } from './utils/throttle.js';
 export { debounce } from './utils/debounce.js';
 export { shallowCache } from './utils/shallowCache.js';

package/esm/utils/task.js

@@ -0,0 +1,18 @@
+export const runInOrder = (tasks, from = 0) => {
+    for (let i = from; i < tasks.length; i++) {
+        const result = tasks[i]();
+        if (result instanceof Promise) {
+            return result.then(() => runInOrder(tasks, i + 1));
+        }
+    }
+};
+export const runAtOnce = (tasks) => {
+    const pending = [];
+    for (const task of tasks) {
+        const result = task();
+        if (result instanceof Promise) {
+            pending.push(result);
+        }
+    }
+    return pending.length > 0 ? Promise.all(pending).then(() => undefined) : undefined;
+};

package/package.json

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

@@ -15,12 +15,10 @@ export type HookExecutionStrategyProps = HookExecutionOptions & {
     key: string | symbol;
     onError?: OnErrorHandler;
 };
-export type MemberHooks = {
-    hooks: HookFn[];
+export type MemberHook = {
+    hook: HookFn;
     context: IHookContext;
 };
-export declare const runInOrder: (hooks: HookFn[], context: IHookContext, from?: number) => void | Promise<void>;
-export declare const runAtOnce: (hooks: HookFn[], context: IHookContext) => void | Promise<void>;
 export declare abstract class HookExecutionStrategy {
     private readonly key;
     private readonly onError?;
@@ -29,7 +27,7 @@ export declare abstract class HookExecutionStrategy {
     constructor({ key, onError, createExecutionContext, mapExecutionContext, predicate, }: HookExecutionStrategyProps);
     hasHooks(target: Instance): boolean;
     execute(target: Instance, { scope, ...overrides }: HookExecutionContext): void;
-    protected abstract processHooks(members: MemberHooks[]): void | Promise<void>;
+    protected abstract processHooks(members: MemberHook[]): void | Promise<void>;
     private collect;
     private hooksOf;
 }

package/typings/hooks/ParallelAsync.d.ts

@@ -1,5 +1,4 @@
-import { AsyncHookExecutionStrategy } from './AsyncHookExecutionStrategy.js';
-import { type MemberHooks } from './HookExecutionStrategy.js';
-export declare class ParallelAsync extends AsyncHookExecutionStrategy {
-    protected processHooks(members: MemberHooks[]): void | Promise<void>;
+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,5 +1,4 @@
-import { AsyncHookExecutionStrategy } from './AsyncHookExecutionStrategy.js';
-import { type MemberHooks } from './HookExecutionStrategy.js';
-export declare class SequentialAsync extends AsyncHookExecutionStrategy {
-    protected processHooks(members: MemberHooks[], from?: number): void | Promise<void>;
+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 +1,4 @@
-import { HookExecutionStrategy, type MemberHooks } from './HookExecutionStrategy.js';
+import { HookExecutionStrategy, type MemberHook } from './HookExecutionStrategy.js';
 export declare class SequentialSync extends HookExecutionStrategy {
-    protected processHooks(members: MemberHooks[]): void;
+    protected processHooks(members: MemberHook[]): void;
 }

package/typings/hooks/{resolveHooks.d.ts → combinators.d.ts}

@@ -1,4 +1,6 @@
 import type { IContainer } from '../container/IContainer.js';
 import { type HookFn, type HookType } from './hook.js';
 export type ResolvedObjectHook = (dependency: object, scope: IContainer) => void;
+export declare const sequential: (...hooks: HookType[]) => HookFn;
+export declare const parallel: (...hooks: HookType[]) => HookFn;
 export declare const oncePerInstance: (execute: HookType) => HookFn;

package/typings/hooks/hook.d.ts

@@ -8,13 +8,8 @@ export interface HookClass<T extends IHookContext = IHookContext> {
     execute(context: Omit<T, 'scope'>): void | Promise<void>;
 }
 export type HookType<T extends IHookContext = IHookContext> = HookFn<T> | constructor<HookClass<T>>;
-export type MapHooksFn = (...prev: HookType[]) => HookType[];
-export type HooksOfClass = Map<string, HookType[]>;
-export declare const appendHooks: (...fns: HookType[]) => MapHooksFn;
-export declare const prependHooks: (...fns: HookType[]) => MapHooksFn;
-export declare const append: (...fns: HookType[]) => MapHooksFn;
-export declare const prepend: (...fns: HookType[]) => MapHooksFn;
+export type HooksOfClass = Map<string, HookType>;
 export declare const toHookFn: <C extends IHookContext>(execute: HookFn<C> | constructor<HookClass<C>>) => HookFn<C>;
 export declare function getHooks(target: Instance | constructor<unknown>, key: string | symbol): HooksOfClass;
 export declare function hasHooks(target: Instance | constructor<unknown>, key: string | symbol): boolean;
-export declare const hook: (key: string | symbol, mapFn: MapHooksFn) => (target: object, propertyKey: string | symbol) => void;
+export declare const hook: (key: string | symbol, fn: HookType) => (target: object, propertyKey: string | symbol) => void;

package/typings/hooks/onConstruct.d.ts

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

package/typings/hooks/onResolved.d.ts

@@ -1,7 +1,7 @@
 import type { IContainer, IContainerModule } from '../container/IContainer.js';
 import { type HookExecutionStrategy } from './HookExecutionStrategy.js';
 import { type HookType } from './hook.js';
-export declare const onResolved: (...hooks: HookType[]) => (target: object, propertyKey: string | symbol) => void;
+export declare const onResolved: (fn: HookType) => (target: object, propertyKey: string | symbol) => void;
 export declare class OnResolvedModule implements IContainerModule {
     private readonly runHooks;
     constructor(strategy: HookExecutionStrategy);

package/typings/hooks/onScopeDisposed.d.ts

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

package/typings/index.d.ts

@@ -20,15 +20,14 @@ export { ProviderDisposedError } from './errors/ProviderDisposedError.js';
 export { CannonSingletonApplyTwiceError } from './errors/CannonSingletonApplyTwiceError.js';
 export { UnsupportedTokenTypeError } from './errors/UnsupportedTokenTypeError.js';
 export { TypedEventDisposedError } from './errors/TypedEventDisposedError.js';
-export { getHooks, hook, hasHooks, appendHooks, prependHooks, append, prepend, type HookFn, type HookClass, type HookType, type MapHooksFn, type InjectFn, type HooksOfClass, } from './hooks/hook.js';
+export { 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 { oncePerInstance, type ResolvedObjectHook } from './hooks/resolveHooks.js';
-export { HookExecutionStrategy, type HookExecutionContext, type HookExecutionOptions, type HookExecutionStrategyProps, type MapHookExecutionContext, type MemberHooks, type OnErrorHandler, } from './hooks/HookExecutionStrategy.js';
-export { AsyncHookExecutionStrategy, type AsyncHookExecutionStrategyProps, type MethodStrategy, } from './hooks/AsyncHookExecutionStrategy.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';
@@ -46,6 +45,7 @@ export { addClassMeta, getClassMeta, addClassLabel, getClassLabels, addClassTag,
 export { addParamMeta, getParamMeta, addParamLabel, getParamLabels, addParamTag, getParamTags, } from './metadata/parameter.js';
 export { addMethodMeta, getMethodMeta, addMethodLabel, getMethodLabels, addMethodTag, getMethodTags, } from './metadata/method.js';
 export { handleError, handleAsyncError, type HandleErrorParams } from './utils/errorHandler.js';
+export { runInOrder, runAtOnce, type Task } from './utils/task.js';
 export { throttle } from './utils/throttle.js';
 export { debounce } from './utils/debounce.js';
 export { shallowCache } from './utils/shallowCache.js';

package/typings/utils/task.d.ts

@@ -0,0 +1,3 @@
+export type Task = () => void | Promise<void>;
+export declare const runInOrder: (tasks: Task[], from?: number) => void | Promise<void>;
+export declare const runAtOnce: (tasks: Task[]) => void | Promise<void>;

package/cjm/hooks/AsyncHookExecutionStrategy.js

@@ -1,15 +0,0 @@
-"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/resolveHooks.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.oncePerInstance = void 0;
-const hook_1 = require("./hook");
-const oncePerInstance = (execute) => {
-    const invokedInstances = new WeakSet();
-    return (context) => {
-        if (invokedInstances.has(context.instance)) {
-            return;
-        }
-        invokedInstances.add(context.instance);
-        return (0, hook_1.toHookFn)(execute)(context);
-    };
-};
-exports.oncePerInstance = oncePerInstance;

package/esm/hooks/AsyncHookExecutionStrategy.js

@@ -1,11 +0,0 @@
-import { HookExecutionStrategy, runAtOnce, runInOrder, } from './HookExecutionStrategy.js';
-export class AsyncHookExecutionStrategy extends HookExecutionStrategy {
-    methodStrategy;
-    constructor({ methodStrategy = 'sequential', ...props }) {
-        super(props);
-        this.methodStrategy = methodStrategy;
-    }
-    runMember({ hooks, context }) {
-        return this.methodStrategy === 'parallel' ? runAtOnce(hooks, context) : runInOrder(hooks, context);
-    }
-}

package/esm/hooks/resolveHooks.js

@@ -1,11 +0,0 @@
-import { toHookFn } from './hook.js';
-export const oncePerInstance = (execute) => {
-    const invokedInstances = new WeakSet();
-    return (context) => {
-        if (invokedInstances.has(context.instance)) {
-            return;
-        }
-        invokedInstances.add(context.instance);
-        return toHookFn(execute)(context);
-    };
-};

package/typings/hooks/AsyncHookExecutionStrategy.d.ts

@@ -1,10 +0,0 @@
-import { HookExecutionStrategy, type HookExecutionStrategyProps, type MemberHooks } from './HookExecutionStrategy.js';
-export type MethodStrategy = 'sequential' | 'parallel';
-export type AsyncHookExecutionStrategyProps = HookExecutionStrategyProps & {
-    methodStrategy?: MethodStrategy;
-};
-export declare abstract class AsyncHookExecutionStrategy extends HookExecutionStrategy {
-    private readonly methodStrategy;
-    constructor({ methodStrategy, ...props }: AsyncHookExecutionStrategyProps);
-    protected runMember({ hooks, context }: MemberHooks): void | Promise<void>;
-}