ts-ioc-container 59.0.0 → 60.0.0

package/README.md

@@ -48,6 +48,7 @@ provider pipelines, aliases, and custom injector strategies.
   - [Visibility](#visibility) `visible`
   - [Alias](#alias) `asAlias`
   - [Decorator](#decorator) `decorate`
+  - [On resolve](#on-resolve) `onResolve`
 - [Registration](#registration) `@register`
   - [Token](#token) `bindTo`
   - [Scope](#scope) `scope`
@@ -2376,6 +2377,84 @@ describe('Decorator Pattern', () => {
 
 ```
 
+### On resolve
+
+Sometimes you don't want to change the dependency, only to react to it. Use the `onResolve(...)` pipe — it appends a `DependencyHook` that receives the resolved dependency and the resolving scope.
+
+- `provider(onResolve((instance, scope) => tracker.track(instance)))`
+
+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.
+
+```typescript
+import 'reflect-metadata';
+import { Container, type IContainer, onResolve, register, Registration as R, singleton } from 'ts-ioc-container';
+
+/**
+ * Observability Domain - onResolve hooks
+ *
+ * `onResolve(...)` attaches side effects to a provider. Every time the provider
+ * hands a dependency back, each hook is called with that dependency and the
+ * resolving scope.
+ *
+ * Unlike `decorate(...)`, a hook cannot replace the dependency - its return
+ * value is ignored. Use `decorate` to change what the caller gets, and
+ * `onResolve` to react to what the caller got: tracking, metrics, registering
+ * the instance with an external bus.
+ *
+ * Hooks always run after the whole `decorate` chain, so they observe the fully
+ * decorated dependency no matter where `onResolve` sits in the pipe list.
+ */
+describe('onResolve', () => {
+  it('should observe every resolved dependency without changing it', () => {
+    const resolved: Array<{ name: string; fromRequest: boolean }> = [];
+
+    const track = (dependency: unknown, scope: IContainer) => {
+      resolved.push({ name: (dependency as Connection).name, fromRequest: scope.hasTag('request') });
+    };
+
+    @register(onResolve(track))
+    class Connection {
+      readonly name = 'Connection';
+    }
+
+    const app = new Container({ tags: ['application'] }).addRegistration(R.fromClass(Connection));
+    const request = app.createScope({ tags: ['request'] });
+
+    const connection = request.resolve<Connection>('Connection');
+
+    // The caller still receives the untouched instance
+    expect(connection).toBeInstanceOf(Connection);
+    // ...and the hook saw it, together with the scope it was resolved from
+    expect(resolved).toEqual([{ name: 'Connection', fromRequest: true }]);
+  });
+
+  it('should run once for a singleton and on every resolve otherwise', () => {
+    let poolCount = 0;
+    let sessionCount = 0;
+
+    @register(singleton(), onResolve(() => poolCount++))
+    class ConnectionPool {}
+
+    @register(onResolve(() => sessionCount++))
+    class Session {}
+
+    const app = new Container({ tags: ['application'] })
+      .addRegistration(R.fromClass(ConnectionPool))
+      .addRegistration(R.fromClass(Session));
+
+    app.resolve('ConnectionPool');
+    app.resolve('ConnectionPool');
+    app.resolve('Session');
+    app.resolve('Session');
+
+    // A singleton caches the dependency, so hooks fire on the resolve that filled the cache
+    expect(poolCount).toBe(1);
+    expect(sessionCount).toBe(2);
+  });
+});
+
+```
+
 ## Registration
 
 Registration is provider factory which registers provider in container.
@@ -2759,7 +2838,7 @@ runs `h1` before `h2`.
 ```typescript
 import 'reflect-metadata';
 import {
-  AddOnConstructHookModule,
+  OnConstructModule,
   Container,
   type ExecutionContext,
   type HookFn,
@@ -2787,7 +2866,7 @@ describe('onConstruct', function () {
     }
 
     const container = new Container()
-      .useModule(new AddOnConstructHookModule())
+      .useModule(new OnConstructModule())
       .addRegistration(R.fromValue('postgres://localhost:5432').bindTo('ConnectionString'));
 
     const db = container.resolve(DatabaseConnection);
@@ -2808,7 +2887,7 @@ describe('onConstruct', function () {
 
     let captured: { ex: unknown; context: ExecutionContext } | undefined;
     const container = new Container().useModule(
-      new AddOnConstructHookModule((ex, context) => {
+      new OnConstructModule((ex, context) => {
         captured = { ex, context };
       }),
     );
@@ -2828,7 +2907,7 @@ describe('onConstruct', function () {
       init() {}
     }
 
-    const container = new Container().useModule(new AddOnConstructHookModule());
+    const container = new Container().useModule(new OnConstructModule());
 
     expect(() => container.resolve(BrokenService)).toThrow(failure);
   });
@@ -2843,7 +2922,7 @@ describe('onConstruct', function () {
 
     let scope: IContainer | undefined;
     const container = new Container().useModule(
-      new AddOnConstructHookModule((_ex, context) => {
+      new OnConstructModule((_ex, context) => {
         scope = context.scope;
       }),
     );
@@ -2860,13 +2939,13 @@ describe('onConstruct', function () {
 ### OnConstructAsync
 
 `@onConstructAsync` runs promise-returning initialization. Resolution stays
-synchronous: `AddOnConstructAsyncHookModule` starts the hooks when the instance
+synchronous: `OnConstructAsyncModule` starts the hooks when the instance
 is created and they settle afterwards, so `resolve` returns before they finish.
 
 ```typescript
 import 'reflect-metadata';
 import {
-  AddOnConstructAsyncHookModule,
+  OnConstructAsyncModule,
   Container,
   type ExecutionContext,
   type HookFn,
@@ -2904,7 +2983,7 @@ describe('onConstructAsync', function () {
     }
 
     const container = new Container()
-      .useModule(new AddOnConstructAsyncHookModule())
+      .useModule(new OnConstructAsyncModule())
       .addRegistration(R.fromValue('postgres://localhost:5432').bindTo('ConnectionString'));
 
     const db = container.resolve(DatabaseConnection);
@@ -2928,7 +3007,7 @@ describe('onConstructAsync', function () {
 
     let captured: { ex: unknown; context: ExecutionContext } | undefined;
     const container = new Container().useModule(
-      new AddOnConstructAsyncHookModule((ex, context) => {
+      new OnConstructAsyncModule((ex, context) => {
         captured = { ex, context };
       }),
     );
@@ -2950,7 +3029,7 @@ describe('onConstructAsync', function () {
 ```typescript
 import 'reflect-metadata';
 import {
-  AddOnDisposeHookModule,
+  OnDisposeModule,
   bindTo,
   Container,
   type HookFn,
@@ -2993,7 +3072,7 @@ class Logger {
 describe('onContainerDisposed', function () {
   it('should invoke hooks on all instances when container is disposed', function () {
     const container = new Container()
-      .useModule(new AddOnDisposeHookModule())
+      .useModule(new OnDisposeModule())
       .addRegistration(R.fromClass(Logger))
       .addRegistration(R.fromClass(LogsRepo));
 

package/cjm/container/AutoResolveModule.js

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

package/cjm/container/Container.js

@@ -73,9 +73,9 @@ class Container {
     createScope({ tags } = {}) {
         this.validateContainer();
         const scope = new Container({ injector: this.injector, parent: this, tags })
-            .addOnConstructHook(...this.onConstructHookList)
-            .addOnDisposeHook(...this.onDisposeHookList)
-            .addOnScopeCreatedHook(...this.onScopeCreatedHookList);
+            .onConstruct(...this.onConstructHookList)
+            .onInstanceDisposed(...this.onDisposeHookList)
+            .onScopeCreated(...this.onScopeCreatedHookList);
         for (const registration of this.getRegistrations()) {
             registration.applyTo(scope);
         }
@@ -97,9 +97,8 @@ class Container {
     dispose() {
         this.validateContainer();
         this.isDisposed = true;
-        while (this.onDisposeHookList.length) {
-            const onDispose = this.onDisposeHookList.shift();
-            onDispose(this);
+        for (const hook of this.onDisposeHookList) {
+            hook(this);
         }
         this.parent.removeScope(this);
         this.parent = new EmptyContainer_1.EmptyContainer();
@@ -111,6 +110,7 @@ class Container {
         this.instances.clear();
         this.registrations = [];
         this.onConstructHookList.length = 0;
+        this.onDisposeHookList.length = 0;
         this.onScopeCreatedHookList.length = 0;
     }
     addRegistration(registration) {
@@ -124,15 +124,15 @@ class Container {
     hasRegistration(key) {
         return this.registrations.some((r) => r.getKeyOrFail() === key) || this.parent.hasRegistration(key);
     }
-    addOnConstructHook(...hooks) {
+    onConstruct(...hooks) {
         this.onConstructHookList.push(...hooks);
         return this;
     }
-    addOnDisposeHook(...hooks) {
+    onInstanceDisposed(...hooks) {
         this.onDisposeHookList.push(...hooks);
         return this;
     }
-    addOnScopeCreatedHook(...hooks) {
+    onScopeCreated(...hooks) {
         this.onScopeCreatedHookList.push(...hooks);
         return this;
     }
@@ -148,13 +148,6 @@ class Container {
     hasInstance(instance) {
         return this.instances.has(instance);
     }
-    getScopeByInstanceOrFail(instance) {
-        this.validateContainer();
-        if (this.hasInstance(instance)) {
-            return this;
-        }
-        return this.parent.getScopeByInstanceOrFail(instance);
-    }
     removeScope(child) {
         this.scopes = this.scopes.filter((s) => s !== child);
     }

package/cjm/container/EmptyContainer.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.EmptyContainer = void 0;
 const MethodNotImplementedError_1 = require("../errors/MethodNotImplementedError");
 const DependencyNotFoundError_1 = require("../errors/DependencyNotFoundError");
-const ContainerNotFoundError_1 = require("../errors/ContainerNotFoundError");
 class EmptyContainer {
     get isDisposed() {
         throw new MethodNotImplementedError_1.MethodNotImplementedError();
@@ -15,9 +14,6 @@ class EmptyContainer {
     getScopes() {
         return [];
     }
-    getScopeByInstanceOrFail(instance) {
-        throw new ContainerNotFoundError_1.ContainerNotFoundError('Cannot find scope for the given instance');
-    }
     getInstances() {
         return [];
     }
@@ -64,13 +60,13 @@ class EmptyContainer {
     resolveOneByAlias(alias, options) {
         throw new DependencyNotFoundError_1.DependencyNotFoundError(`Cannot find alias ${alias.toString()}`);
     }
-    addOnDisposeHook(...hooks) {
+    onInstanceDisposed(...hooks) {
         throw new MethodNotImplementedError_1.MethodNotImplementedError();
     }
-    addOnConstructHook(...hooks) {
+    onConstruct(...hooks) {
         throw new MethodNotImplementedError_1.MethodNotImplementedError();
     }
-    addOnScopeCreatedHook(...hooks) {
+    onScopeCreated(...hooks) {
         throw new MethodNotImplementedError_1.MethodNotImplementedError();
     }
 }

package/cjm/hooks/onConstruct.js

@@ -1,18 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AddOnConstructHookModule = exports.onConstruct = exports.onConstructHooksRunner = void 0;
+exports.OnConstructModule = exports.onConstruct = exports.onConstructHooksRunner = void 0;
 const hook_1 = require("./hook");
 const HooksRunner_1 = require("./HooksRunner");
 exports.onConstructHooksRunner = new HooksRunner_1.HooksRunner('onConstruct');
 const onConstruct = (...fns) => (0, hook_1.hook)('onConstruct', (0, hook_1.prependHooks)(...fns));
 exports.onConstruct = onConstruct;
-class AddOnConstructHookModule {
+class OnConstructModule {
     onException;
     constructor(onException) {
         this.onException = onException;
     }
     applyTo(container) {
-        container.addOnConstructHook((instance, scope) => {
+        container.onConstruct((instance, scope) => {
             try {
                 exports.onConstructHooksRunner.execute(instance, { scope });
             }
@@ -25,4 +25,4 @@ class AddOnConstructHookModule {
         });
     }
 }
-exports.AddOnConstructHookModule = AddOnConstructHookModule;
+exports.OnConstructModule = OnConstructModule;

package/cjm/hooks/onConstructAsync.js

@@ -1,18 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AddOnConstructAsyncHookModule = exports.onConstructAsync = exports.onConstructAsyncHooksRunner = void 0;
+exports.OnConstructAsyncModule = exports.onConstructAsync = exports.onConstructAsyncHooksRunner = void 0;
 const hook_1 = require("./hook");
 const HooksRunner_1 = require("./HooksRunner");
 exports.onConstructAsyncHooksRunner = new HooksRunner_1.HooksRunner('onConstructAsync');
 const onConstructAsync = (...fns) => (0, hook_1.hook)('onConstructAsync', (0, hook_1.prependHooks)(...fns));
 exports.onConstructAsync = onConstructAsync;
-class AddOnConstructAsyncHookModule {
+class OnConstructAsyncModule {
     onException;
     constructor(onException) {
         this.onException = onException;
     }
     applyTo(container) {
-        container.addOnConstructHook((instance, scope) => {
+        container.onConstruct((instance, scope) => {
             if (!exports.onConstructAsyncHooksRunner.hasHooks(instance)) {
                 return;
             }
@@ -25,4 +25,4 @@ class AddOnConstructAsyncHookModule {
         });
     }
 }
-exports.AddOnConstructAsyncHookModule = AddOnConstructAsyncHookModule;
+exports.OnConstructAsyncModule = OnConstructAsyncModule;

package/cjm/hooks/onContainerDisposed.js

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

package/cjm/index.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createHookContext = exports.createHookContextFactory = exports.HookContext = exports.prepend = exports.append = exports.prependHooks = exports.appendHooks = exports.hasHooks = exports.hook = exports.getHooks = exports.UnsupportedTokenTypeError = exports.CannonSingletonApplyTwiceError = exports.UnexpectedHookResultError = exports.ProviderDisposedError = exports.ContainerDisposedError = exports.MethodNotImplementedError = exports.DependencyMissingKeyError = exports.ContainerNotFoundError = exports.DependencyNotFoundError = exports.ContainerError = exports.Registration = 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.pipe = exports.select = exports.once = exports.shallowCache = exports.debounce = exports.throttle = exports.handleAsyncError = exports.handleError = exports.getMethodTags = exports.addMethodTag = exports.getMethodLabels = exports.addMethodLabel = exports.getMethodMeta = 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.GroupInstanceToken = exports.ConstantToken = exports.FunctionToken = exports.SingleToken = exports.ClassToken = exports.toSingleAlias = exports.SingleAliasToken = exports.toGroupAlias = exports.GroupAliasToken = exports.argToToken = exports.toMappedToken = exports.toToken = exports.InjectionToken = exports.HooksRunner = exports.AddOnDisposeHookModule = exports.onContainerDisposed = exports.onContainerDisposedHooksRunner = exports.AddOnConstructAsyncHookModule = exports.onConstructAsync = exports.onConstructAsyncHooksRunner = exports.AddOnConstructHookModule = exports.onConstruct = exports.onConstructHooksRunner = exports.injectProp = void 0;
-exports.resolveConstructor = exports.Is = exports.ProxyRegistry = void 0;
+exports.createHookContextFactory = exports.HookContext = exports.prepend = exports.append = exports.prependHooks = exports.appendHooks = exports.hasHooks = exports.hook = exports.getHooks = exports.UnsupportedTokenTypeError = exports.CannonSingletonApplyTwiceError = exports.UnexpectedHookResultError = exports.ProviderDisposedError = exports.ContainerDisposedError = exports.MethodNotImplementedError = exports.DependencyMissingKeyError = exports.ContainerNotFoundError = exports.DependencyNotFoundError = exports.ContainerError = exports.Registration = exports.onResolve = exports.appendArgsFn = exports.appendArgs = exports.decorate = exports.singleton = exports.autoResolve = exports.lazy = exports.scopeAccess = exports.scope = exports.bindTo = exports.register = exports.toRegistrationFn = exports.toProviderFn = exports.toBindToken = exports.registerPipe = exports.isProviderPipe = exports.Provider = exports.ProxyInjector = exports.SimpleInjector = exports.resolveArgs = exports.argsFn = exports.args = exports.arg = exports.inject = exports.MetadataInjector = exports.Injector = exports.EmptyContainer = exports.AutoResolveModule = exports.Container = exports.isDependencyKey = void 0;
+exports.select = exports.once = exports.shallowCache = exports.debounce = 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.GroupInstanceToken = exports.ConstantToken = exports.FunctionToken = exports.SingleToken = exports.ClassToken = exports.toSingleAlias = exports.SingleAliasToken = exports.toGroupAlias = exports.GroupAliasToken = exports.argToToken = exports.toMappedToken = exports.toToken = exports.InjectionToken = exports.HooksRunner = exports.OnDisposeModule = exports.onContainerDisposed = exports.onContainerDisposedHooksRunner = exports.OnConstructAsyncModule = exports.onConstructAsync = exports.onConstructAsyncHooksRunner = exports.OnConstructModule = exports.onConstruct = exports.onConstructHooksRunner = exports.injectProp = exports.createHookContext = void 0;
+exports.resolveConstructor = exports.Is = exports.ProxyRegistry = exports.pipe = 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");
@@ -42,6 +42,7 @@ Object.defineProperty(exports, "singleton", { enumerable: true, get: function ()
 Object.defineProperty(exports, "decorate", { enumerable: true, get: function () { return IRegistration_1.decorate; } });
 Object.defineProperty(exports, "appendArgs", { enumerable: true, get: function () { return IRegistration_1.appendArgs; } });
 Object.defineProperty(exports, "appendArgsFn", { enumerable: true, get: function () { return IRegistration_1.appendArgsFn; } });
+Object.defineProperty(exports, "onResolve", { enumerable: true, get: function () { return IRegistration_1.onResolve; } });
 var Registration_1 = require("./registration/Registration");
 Object.defineProperty(exports, "Registration", { enumerable: true, get: function () { return Registration_1.Registration; } });
 var ContainerError_1 = require("./errors/ContainerError");
@@ -81,15 +82,15 @@ Object.defineProperty(exports, "injectProp", { enumerable: true, get: function (
 var onConstruct_1 = require("./hooks/onConstruct");
 Object.defineProperty(exports, "onConstructHooksRunner", { enumerable: true, get: function () { return onConstruct_1.onConstructHooksRunner; } });
 Object.defineProperty(exports, "onConstruct", { enumerable: true, get: function () { return onConstruct_1.onConstruct; } });
-Object.defineProperty(exports, "AddOnConstructHookModule", { enumerable: true, get: function () { return onConstruct_1.AddOnConstructHookModule; } });
+Object.defineProperty(exports, "OnConstructModule", { enumerable: true, get: function () { return onConstruct_1.OnConstructModule; } });
 var onConstructAsync_1 = require("./hooks/onConstructAsync");
 Object.defineProperty(exports, "onConstructAsyncHooksRunner", { enumerable: true, get: function () { return onConstructAsync_1.onConstructAsyncHooksRunner; } });
 Object.defineProperty(exports, "onConstructAsync", { enumerable: true, get: function () { return onConstructAsync_1.onConstructAsync; } });
-Object.defineProperty(exports, "AddOnConstructAsyncHookModule", { enumerable: true, get: function () { return onConstructAsync_1.AddOnConstructAsyncHookModule; } });
+Object.defineProperty(exports, "OnConstructAsyncModule", { enumerable: true, get: function () { return onConstructAsync_1.OnConstructAsyncModule; } });
 var onContainerDisposed_1 = require("./hooks/onContainerDisposed");
 Object.defineProperty(exports, "onContainerDisposedHooksRunner", { enumerable: true, get: function () { return onContainerDisposed_1.onContainerDisposedHooksRunner; } });
 Object.defineProperty(exports, "onContainerDisposed", { enumerable: true, get: function () { return onContainerDisposed_1.onContainerDisposed; } });
-Object.defineProperty(exports, "AddOnDisposeHookModule", { enumerable: true, get: function () { return onContainerDisposed_1.AddOnDisposeHookModule; } });
+Object.defineProperty(exports, "OnDisposeModule", { enumerable: true, get: function () { return onContainerDisposed_1.OnDisposeModule; } });
 var HooksRunner_1 = require("./hooks/HooksRunner");
 Object.defineProperty(exports, "HooksRunner", { enumerable: true, get: function () { return HooksRunner_1.HooksRunner; } });
 var InjectionToken_1 = require("./token/InjectionToken");

package/cjm/provider/Provider.js

@@ -22,6 +22,7 @@ class Provider {
     cache = new Map();
     getKey;
     isDisposed = false;
+    onResolveHookList = [];
     constructor(resolveDependency) {
         this.resolveDependency = resolveDependency;
     }
@@ -37,11 +38,15 @@ class Provider {
         return this.cache.get(key);
     }
     resolveDep(scope, { args = [], lazy } = {}) {
-        const dependency = this.resolveDependency(scope, {
+        let dependency = this.resolveDependency(scope, {
             args: this.argsFnList.reduce((acc, current) => current(scope, { args: acc }), args),
             lazy: lazy ?? this.isLazy,
         });
-        return this.mappers.reduce((acc, current) => current(acc, scope), dependency);
+        dependency = this.mappers.reduce((acc, current) => current(acc, scope), dependency);
+        for (const onResolve of this.onResolveHookList) {
+            onResolve(dependency, scope);
+        }
+        return dependency;
     }
     map(...mappers) {
         this.mappers.push(...mappers);
@@ -76,6 +81,10 @@ class Provider {
         this.getKey = getCacheKey;
         return this;
     }
+    onResolve(...hooks) {
+        this.onResolveHookList.push(...hooks);
+        return this;
+    }
     dispose() {
         ProviderDisposedError_1.ProviderDisposedError.assert(!this.isDisposed, 'Provider is already disposed');
         this.isDisposed = true;
@@ -85,6 +94,7 @@ class Provider {
         this.accessRules.splice(0, this.accessRules.length);
         this.mappers.splice(0, this.mappers.length);
         this.argsFnList.splice(0, this.argsFnList.length);
+        this.onResolveHookList.splice(0, this.onResolveHookList.length);
     }
 }
 exports.Provider = Provider;

package/cjm/registration/IRegistration.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.singleton = exports.decorate = exports.autoResolve = exports.lazy = exports.scopeAccess = exports.appendArgsFn = exports.appendArgs = exports.scope = exports.bindTo = exports.register = exports.getTransformers = exports.toRegistrationFn = exports.toProviderFn = exports.toBindToken = exports.registerPipe = exports.isProviderPipe = void 0;
+exports.onResolve = exports.singleton = exports.decorate = exports.autoResolve = exports.lazy = exports.scopeAccess = exports.appendArgsFn = exports.appendArgs = exports.scope = exports.bindTo = exports.register = exports.getTransformers = exports.toRegistrationFn = exports.toProviderFn = exports.toBindToken = exports.registerPipe = exports.isProviderPipe = void 0;
 const IContainer_1 = require("../container/IContainer");
 const SingleToken_1 = require("../token/SingleToken");
 const class_1 = require("../metadata/class");
@@ -54,3 +54,5 @@ const decorate = (...fns) => (0, exports.registerPipe)((p) => p.map(...fns));
 exports.decorate = decorate;
 const singleton = (getCacheKey) => (0, exports.registerPipe)((p) => p.singleton(getCacheKey));
 exports.singleton = singleton;
+const onResolve = (...hooks) => (0, exports.registerPipe)((p) => p.onResolve(...hooks));
+exports.onResolve = onResolve;

package/esm/container/AutoResolveModule.js

@@ -4,6 +4,6 @@ export class AutoResolveModule {
         this.options = options;
     }
     applyTo(container) {
-        container.addOnScopeCreatedHook((scope) => scope.autoResolve(this.options));
+        container.onScopeCreated((scope) => scope.autoResolve(this.options));
     }
 }

package/esm/container/Container.js

@@ -70,9 +70,9 @@ export class Container {
     createScope({ tags } = {}) {
         this.validateContainer();
         const scope = new Container({ injector: this.injector, parent: this, tags })
-            .addOnConstructHook(...this.onConstructHookList)
-            .addOnDisposeHook(...this.onDisposeHookList)
-            .addOnScopeCreatedHook(...this.onScopeCreatedHookList);
+            .onConstruct(...this.onConstructHookList)
+            .onInstanceDisposed(...this.onDisposeHookList)
+            .onScopeCreated(...this.onScopeCreatedHookList);
         for (const registration of this.getRegistrations()) {
             registration.applyTo(scope);
         }
@@ -94,9 +94,8 @@ export class Container {
     dispose() {
         this.validateContainer();
         this.isDisposed = true;
-        while (this.onDisposeHookList.length) {
-            const onDispose = this.onDisposeHookList.shift();
-            onDispose(this);
+        for (const hook of this.onDisposeHookList) {
+            hook(this);
         }
         this.parent.removeScope(this);
         this.parent = new EmptyContainer();
@@ -108,6 +107,7 @@ export class Container {
         this.instances.clear();
         this.registrations = [];
         this.onConstructHookList.length = 0;
+        this.onDisposeHookList.length = 0;
         this.onScopeCreatedHookList.length = 0;
     }
     addRegistration(registration) {
@@ -121,15 +121,15 @@ export class Container {
     hasRegistration(key) {
         return this.registrations.some((r) => r.getKeyOrFail() === key) || this.parent.hasRegistration(key);
     }
-    addOnConstructHook(...hooks) {
+    onConstruct(...hooks) {
         this.onConstructHookList.push(...hooks);
         return this;
     }
-    addOnDisposeHook(...hooks) {
+    onInstanceDisposed(...hooks) {
         this.onDisposeHookList.push(...hooks);
         return this;
     }
-    addOnScopeCreatedHook(...hooks) {
+    onScopeCreated(...hooks) {
         this.onScopeCreatedHookList.push(...hooks);
         return this;
     }
@@ -145,13 +145,6 @@ export class Container {
     hasInstance(instance) {
         return this.instances.has(instance);
     }
-    getScopeByInstanceOrFail(instance) {
-        this.validateContainer();
-        if (this.hasInstance(instance)) {
-            return this;
-        }
-        return this.parent.getScopeByInstanceOrFail(instance);
-    }
     removeScope(child) {
         this.scopes = this.scopes.filter((s) => s !== child);
     }

package/esm/container/EmptyContainer.js

@@ -1,6 +1,5 @@
 import { MethodNotImplementedError } from '../errors/MethodNotImplementedError.js';
 import { DependencyNotFoundError } from '../errors/DependencyNotFoundError.js';
-import { ContainerNotFoundError } from '../errors/ContainerNotFoundError.js';
 export class EmptyContainer {
     get isDisposed() {
         throw new MethodNotImplementedError();
@@ -12,9 +11,6 @@ export class EmptyContainer {
     getScopes() {
         return [];
     }
-    getScopeByInstanceOrFail(instance) {
-        throw new ContainerNotFoundError('Cannot find scope for the given instance');
-    }
     getInstances() {
         return [];
     }
@@ -61,13 +57,13 @@ export class EmptyContainer {
     resolveOneByAlias(alias, options) {
         throw new DependencyNotFoundError(`Cannot find alias ${alias.toString()}`);
     }
-    addOnDisposeHook(...hooks) {
+    onInstanceDisposed(...hooks) {
         throw new MethodNotImplementedError();
     }
-    addOnConstructHook(...hooks) {
+    onConstruct(...hooks) {
         throw new MethodNotImplementedError();
     }
-    addOnScopeCreatedHook(...hooks) {
+    onScopeCreated(...hooks) {
         throw new MethodNotImplementedError();
     }
 }

package/esm/hooks/onConstruct.js

@@ -2,13 +2,13 @@ import { hook, prependHooks } from './hook.js';
 import { HooksRunner } from './HooksRunner.js';
 export const onConstructHooksRunner = new HooksRunner('onConstruct');
 export const onConstruct = (...fns) => hook('onConstruct', prependHooks(...fns));
-export class AddOnConstructHookModule {
+export class OnConstructModule {
     onException;
     constructor(onException) {
         this.onException = onException;
     }
     applyTo(container) {
-        container.addOnConstructHook((instance, scope) => {
+        container.onConstruct((instance, scope) => {
             try {
                 onConstructHooksRunner.execute(instance, { scope });
             }

package/esm/hooks/onConstructAsync.js

@@ -2,13 +2,13 @@ import { hook, prependHooks } from './hook.js';
 import { HooksRunner } from './HooksRunner.js';
 export const onConstructAsyncHooksRunner = new HooksRunner('onConstructAsync');
 export const onConstructAsync = (...fns) => hook('onConstructAsync', prependHooks(...fns));
-export class AddOnConstructAsyncHookModule {
+export class OnConstructAsyncModule {
     onException;
     constructor(onException) {
         this.onException = onException;
     }
     applyTo(container) {
-        container.addOnConstructHook((instance, scope) => {
+        container.onConstruct((instance, scope) => {
             if (!onConstructAsyncHooksRunner.hasHooks(instance)) {
                 return;
             }

package/esm/hooks/onContainerDisposed.js

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

package/esm/index.js

@@ -7,7 +7,7 @@ export { MetadataInjector, inject, arg, args, argsFn, resolveArgs } from './inje
 export { SimpleInjector } from './injector/SimpleInjector.js';
 export { ProxyInjector } from './injector/ProxyInjector.js';
 export { Provider } from './provider/Provider.js';
-export { isProviderPipe, registerPipe, toBindToken, toProviderFn, toRegistrationFn, register, bindTo, scope, scopeAccess, lazy, autoResolve, singleton, decorate, appendArgs, appendArgsFn, } from './registration/IRegistration.js';
+export { isProviderPipe, registerPipe, toBindToken, toProviderFn, toRegistrationFn, register, bindTo, scope, scopeAccess, lazy, autoResolve, singleton, decorate, appendArgs, appendArgsFn, onResolve, } from './registration/IRegistration.js';
 export { Registration } from './registration/Registration.js';
 export { ContainerError } from './errors/ContainerError.js';
 export { DependencyNotFoundError } from './errors/DependencyNotFoundError.js';
@@ -22,9 +22,9 @@ export { UnsupportedTokenTypeError } from './errors/UnsupportedTokenTypeError.js
 export { getHooks, hook, hasHooks, appendHooks, prependHooks, append, prepend, } from './hooks/hook.js';
 export { HookContext, createHookContextFactory, createHookContext } from './hooks/HookContext.js';
 export { injectProp } from './hooks/injectProp.js';
-export { onConstructHooksRunner, onConstruct, AddOnConstructHookModule, } from './hooks/onConstruct.js';
-export { onConstructAsyncHooksRunner, onConstructAsync, AddOnConstructAsyncHookModule } from './hooks/onConstructAsync.js';
-export { onContainerDisposedHooksRunner, onContainerDisposed, AddOnDisposeHookModule, } from './hooks/onContainerDisposed.js';
+export { onConstructHooksRunner, onConstruct, OnConstructModule } from './hooks/onConstruct.js';
+export { onConstructAsyncHooksRunner, onConstructAsync, OnConstructAsyncModule } from './hooks/onConstructAsync.js';
+export { onContainerDisposedHooksRunner, onContainerDisposed, OnDisposeModule } from './hooks/onContainerDisposed.js';
 export { HooksRunner } from './hooks/HooksRunner.js';
 export { InjectionToken } from './token/InjectionToken.js';
 export { toToken, toMappedToken, argToToken } from './token/toToken.js';

package/esm/provider/Provider.js

@@ -19,6 +19,7 @@ export class Provider {
     cache = new Map();
     getKey;
     isDisposed = false;
+    onResolveHookList = [];
     constructor(resolveDependency) {
         this.resolveDependency = resolveDependency;
     }
@@ -34,11 +35,15 @@ export class Provider {
         return this.cache.get(key);
     }
     resolveDep(scope, { args = [], lazy } = {}) {
-        const dependency = this.resolveDependency(scope, {
+        let dependency = this.resolveDependency(scope, {
             args: this.argsFnList.reduce((acc, current) => current(scope, { args: acc }), args),
             lazy: lazy ?? this.isLazy,
         });
-        return this.mappers.reduce((acc, current) => current(acc, scope), dependency);
+        dependency = this.mappers.reduce((acc, current) => current(acc, scope), dependency);
+        for (const onResolve of this.onResolveHookList) {
+            onResolve(dependency, scope);
+        }
+        return dependency;
     }
     map(...mappers) {
         this.mappers.push(...mappers);
@@ -73,6 +78,10 @@ export class Provider {
         this.getKey = getCacheKey;
         return this;
     }
+    onResolve(...hooks) {
+        this.onResolveHookList.push(...hooks);
+        return this;
+    }
     dispose() {
         ProviderDisposedError.assert(!this.isDisposed, 'Provider is already disposed');
         this.isDisposed = true;
@@ -82,5 +91,6 @@ export class Provider {
         this.accessRules.splice(0, this.accessRules.length);
         this.mappers.splice(0, this.mappers.length);
         this.argsFnList.splice(0, this.argsFnList.length);
+        this.onResolveHookList.splice(0, this.onResolveHookList.length);
     }
 }

package/esm/registration/IRegistration.js

@@ -1,4 +1,4 @@
-import { isDependencyKey } from '../container/IContainer.js';
+import { isDependencyKey, } from '../container/IContainer.js';
 import { SingleToken } from '../token/SingleToken.js';
 import { addClassMeta, getClassMeta } from '../metadata/class.js';
 export const isProviderPipe = (obj) => obj !== null && typeof obj === 'object' && 'mapProvider' in obj;
@@ -35,3 +35,4 @@ export const lazy = () => registerPipe((p) => p.lazy());
 export const autoResolve = () => registerPipe((p) => p.autoResolve());
 export const decorate = (...fns) => registerPipe((p) => p.map(...fns));
 export const singleton = (getCacheKey) => registerPipe((p) => p.singleton(getCacheKey));
+export const onResolve = (...hooks) => registerPipe((p) => p.onResolve(...hooks));

package/package.json

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

@@ -1,8 +1,7 @@
-import { type AutoResolveOptions, type CreateScopeOptions, type DependencyKey, type IContainer, type IContainerModule, type OnScopeCreatedHook, type RegisterOptions, ResolveManyOptions, type ResolveOneOptions, type Tag } from './IContainer.js';
+import { type AutoResolveOptions, type CreateScopeOptions, type DependencyKey, type IContainer, type IContainerModule, type InstanceHook, type RegisterOptions, ResolveManyOptions, type ResolveOneOptions, type ScopeHook, type Tag } from './IContainer.js';
 import { type IInjector } from '../injector/IInjector.js';
 import { type IProvider } from '../provider/IProvider.js';
 import { type IRegistration } from '../registration/IRegistration.js';
-import { OnConstructHook } from '../hooks/onConstruct.js';
 import { OnDisposeHook } from '../hooks/onContainerDisposed.js';
 import { constructor, Instance } from '../utils/basic.js';
 export declare class Container implements IContainer {
@@ -33,13 +32,12 @@ export declare class Container implements IContainer {
     addRegistration(registration: IRegistration): this;
     getRegistrations(): IRegistration[];
     hasRegistration(key: DependencyKey): boolean;
-    addOnConstructHook(...hooks: OnConstructHook[]): this;
-    addOnDisposeHook(...hooks: OnDisposeHook[]): this;
-    addOnScopeCreatedHook(...hooks: OnScopeCreatedHook[]): this;
+    onConstruct(...hooks: InstanceHook[]): this;
+    onInstanceDisposed(...hooks: OnDisposeHook[]): this;
+    onScopeCreated(...hooks: ScopeHook[]): this;
     addInstance(instance: Instance): void;
     getScopes(): IContainer[];
     hasInstance(instance: Instance): boolean;
-    getScopeByInstanceOrFail(instance: Instance): IContainer;
     removeScope(child: IContainer): void;
     useModule(module: IContainerModule): this;
     getParent(): IContainer;

package/typings/container/EmptyContainer.d.ts

@@ -1,15 +1,13 @@
-import { type AutoResolveOptions, type DependencyKey, type IContainer, type IContainerModule, type OnScopeCreatedHook, type ResolveManyOptions, type ResolveOneOptions, type Tag } from './IContainer.js';
+import { type AutoResolveOptions, type DependencyKey, type IContainer, type IContainerModule, type ScopeHook, type ResolveManyOptions, type ResolveOneOptions, type Tag, type InstanceHook } from './IContainer.js';
 import { type IProvider } from '../provider/IProvider.js';
 import { type IRegistration } from '../registration/IRegistration.js';
 import { OnDisposeHook } from '../hooks/onContainerDisposed.js';
-import { OnConstructHook } from '../hooks/onConstruct.js';
 import { type constructor, type Instance } from '../utils/basic.js';
 export declare class EmptyContainer implements IContainer {
     get isDisposed(): boolean;
     addInstance(instance: Instance): void;
     getParent(): undefined;
     getScopes(): never[];
-    getScopeByInstanceOrFail(instance: Instance): IContainer;
     getInstances(): never[];
     hasInstance(instance: Instance): boolean;
     createScope(): IContainer;
@@ -26,7 +24,7 @@ export declare class EmptyContainer implements IContainer {
     resolve<T>(key: constructor<T> | DependencyKey, options?: ResolveOneOptions): T;
     resolveByAlias<T>(alias: DependencyKey, options?: ResolveManyOptions): T[];
     resolveOneByAlias<T>(alias: DependencyKey, options?: ResolveOneOptions): T;
-    addOnDisposeHook(...hooks: OnDisposeHook[]): this;
-    addOnConstructHook(...hooks: OnConstructHook[]): this;
-    addOnScopeCreatedHook(...hooks: OnScopeCreatedHook[]): this;
+    onInstanceDisposed(...hooks: OnDisposeHook[]): this;
+    onConstruct(...hooks: InstanceHook[]): this;
+    onScopeCreated(...hooks: ScopeHook[]): this;
 }

package/typings/container/IContainer.d.ts

@@ -1,6 +1,5 @@
 import { type IProvider, ProviderOptions } from '../provider/IProvider.js';
 import { type IRegistration } from '../registration/IRegistration.js';
-import { OnConstructHook } from '../hooks/onConstruct.js';
 import { OnDisposeHook } from '../hooks/onContainerDisposed.js';
 import { type WithArgs } from '../injector/IInjector.js';
 import { type constructor, Instance } from '../utils/basic.js';
@@ -30,15 +29,17 @@ export interface IContainerModule {
 }
 export type CreateScopeOptions = Partial<WithTags>;
 export type AutoResolveOptions = Partial<WithArgs>;
-export type OnScopeCreatedHook = (scope: IContainer) => void;
 export type RegisterOptions = {
     aliases?: DependencyKey[];
 };
+export type ScopeHook = (scope: IContainer) => void;
+export type InstanceHook = (instance: Instance, scope: IContainer) => void;
+export type DependencyHook = (dependency: unknown, scope: IContainer) => void;
 export interface IContainer extends Tagged {
     readonly isDisposed: boolean;
-    addOnConstructHook(...hooks: OnConstructHook[]): this;
-    addOnDisposeHook(...hooks: OnDisposeHook[]): this;
-    addOnScopeCreatedHook(...hooks: OnScopeCreatedHook[]): this;
+    onConstruct(...hooks: InstanceHook[]): this;
+    onInstanceDisposed(...hooks: OnDisposeHook[]): this;
+    onScopeCreated(...hooks: ScopeHook[]): this;
     register(key: DependencyKey, value: IProvider, options?: RegisterOptions): this;
     addRegistration(registration: IRegistration): this;
     getRegistrations(): IRegistration[];
@@ -49,7 +50,6 @@ export interface IContainer extends Tagged {
     createScope(options?: CreateScopeOptions): IContainer;
     autoResolve(options?: AutoResolveOptions): this;
     getScopes(): IContainer[];
-    getScopeByInstanceOrFail(instance: Instance): IContainer;
     removeScope(child: IContainer): void;
     useModule(module: IContainerModule): this;
     getParent(): IContainer | undefined;

package/typings/hooks/onConstruct.d.ts

@@ -1,13 +1,11 @@
 import { HookType } from './hook.js';
 import type { IContainer, IContainerModule } from '../container/IContainer.js';
-import { Instance } from '../utils/basic.js';
 import { HooksRunner } from './HooksRunner.js';
 import type { ExecutionContext } from '../ExecutionContext.js';
 export declare const onConstructHooksRunner: HooksRunner;
 export declare const onConstruct: (...fns: HookType[]) => (target: object, propertyKey: string | symbol) => void;
-export type OnConstructHook = (instance: Instance, scope: IContainer) => void;
 export type OnExceptionHandler = (ex: unknown, context: ExecutionContext) => void;
-export declare class AddOnConstructHookModule implements IContainerModule {
+export declare class OnConstructModule implements IContainerModule {
     private readonly onException?;
     constructor(onException?: OnExceptionHandler | undefined);
     applyTo(container: IContainer): void;

package/typings/hooks/onConstructAsync.d.ts

@@ -4,7 +4,7 @@ import { HooksRunner } from './HooksRunner.js';
 import type { OnExceptionHandler } from './onConstruct.js';
 export declare const onConstructAsyncHooksRunner: HooksRunner;
 export declare const onConstructAsync: (...fns: HookType[]) => (target: object, propertyKey: string | symbol) => void;
-export declare class AddOnConstructAsyncHookModule implements IContainerModule {
+export declare class OnConstructAsyncModule implements IContainerModule {
     private readonly onException?;
     constructor(onException?: OnExceptionHandler | undefined);
     applyTo(container: IContainer): void;

package/typings/hooks/onContainerDisposed.d.ts

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

package/typings/index.d.ts

@@ -1,4 +1,4 @@
-export { type IContainer, type Resolvable, type IContainerModule, type DependencyKey, type Tag, type Tagged, type ResolveOneOptions, type ResolveManyOptions, type OnScopeCreatedHook, type AutoResolveOptions, isDependencyKey, } from './container/IContainer.js';
+export { type IContainer, type Resolvable, type IContainerModule, type DependencyKey, type Tag, type Tagged, type ResolveOneOptions, type ResolveManyOptions, type ScopeHook, type InstanceHook, type DependencyHook, type AutoResolveOptions, isDependencyKey, } from './container/IContainer.js';
 export { Container } from './container/Container.js';
 export { AutoResolveModule } from './container/AutoResolveModule.js';
 export { EmptyContainer } from './container/EmptyContainer.js';
@@ -8,7 +8,7 @@ export { SimpleInjector } from './injector/SimpleInjector.js';
 export { ProxyInjector } from './injector/ProxyInjector.js';
 export { type ResolveDependency, type IProvider, type DecorateFn, type ArgsFn, type ProviderOptions, type GetCacheKey, type ScopeAccessOptions, type ScopeAccessRule, } from './provider/IProvider.js';
 export { Provider } from './provider/Provider.js';
-export { type IRegistration, type ReturnTypeOfRegistration, type ScopeMatchRule, type ProviderPipe, type Bindable, type ProviderMapper, type RegistrationMapper, isProviderPipe, registerPipe, toBindToken, toProviderFn, toRegistrationFn, register, bindTo, scope, scopeAccess, lazy, autoResolve, singleton, decorate, appendArgs, appendArgsFn, } from './registration/IRegistration.js';
+export { type IRegistration, type ReturnTypeOfRegistration, type ScopeMatchRule, type ProviderPipe, type Bindable, type ProviderMapper, type RegistrationMapper, isProviderPipe, registerPipe, toBindToken, toProviderFn, toRegistrationFn, register, bindTo, scope, scopeAccess, lazy, autoResolve, singleton, decorate, appendArgs, appendArgsFn, onResolve, } from './registration/IRegistration.js';
 export { Registration } from './registration/Registration.js';
 export { ContainerError } from './errors/ContainerError.js';
 export { DependencyNotFoundError } from './errors/DependencyNotFoundError.js';
@@ -23,9 +23,9 @@ export { UnsupportedTokenTypeError } from './errors/UnsupportedTokenTypeError.js
 export { getHooks, hook, hasHooks, appendHooks, prependHooks, append, prepend, type HookFn, type HookClass, type HookType, type MapHooksFn, type InjectFn, type HooksOfClass, } from './hooks/hook.js';
 export { HookContext, createHookContextFactory, createHookContext, type IHookContext } from './hooks/HookContext.js';
 export { injectProp } from './hooks/injectProp.js';
-export { onConstructHooksRunner, onConstruct, AddOnConstructHookModule, type OnExceptionHandler, } from './hooks/onConstruct.js';
-export { onConstructAsyncHooksRunner, onConstructAsync, AddOnConstructAsyncHookModule } from './hooks/onConstructAsync.js';
-export { onContainerDisposedHooksRunner, onContainerDisposed, AddOnDisposeHookModule, } from './hooks/onContainerDisposed.js';
+export { onConstructHooksRunner, onConstruct, OnConstructModule, type OnExceptionHandler } from './hooks/onConstruct.js';
+export { onConstructAsyncHooksRunner, onConstructAsync, OnConstructAsyncModule } from './hooks/onConstructAsync.js';
+export { onContainerDisposedHooksRunner, onContainerDisposed, OnDisposeModule } from './hooks/onContainerDisposed.js';
 export { HooksRunner, type HooksRunnerContext, type MapHookContext } from './hooks/HooksRunner.js';
 export { InjectionToken } from './token/InjectionToken.js';
 export { type Injectable, toToken, toMappedToken, argToToken } from './token/toToken.js';

package/typings/provider/IProvider.d.ts

@@ -1,4 +1,4 @@
-import { IContainer, Tagged } from '../container/IContainer.js';
+import { type DependencyHook, IContainer, Tagged } from '../container/IContainer.js';
 import { InjectOptions } from '../injector/IInjector.js';
 export type WithLazy = {
     lazy: boolean;
@@ -25,4 +25,5 @@ export interface IProvider<T = any> {
     isAutoResolvable(): boolean;
     singleton(getCacheKey?: GetCacheKey): this;
     dispose(): void;
+    onResolve(...hooks: DependencyHook[]): this;
 }

package/typings/provider/Provider.d.ts

@@ -1,5 +1,5 @@
 import { type ArgsFn, type DecorateFn, type GetCacheKey, type IProvider, type ProviderOptions, type ResolveDependency, type ScopeAccessOptions, type ScopeAccessRule } from './IProvider.js';
-import type { DependencyKey, IContainer } from '../container/IContainer.js';
+import type { DependencyHook, DependencyKey, IContainer } from '../container/IContainer.js';
 import { type constructor } from '../utils/basic.js';
 export declare class Provider<T = any> implements IProvider<T> {
     private readonly resolveDependency;
@@ -14,6 +14,7 @@ export declare class Provider<T = any> implements IProvider<T> {
     private cache;
     private getKey;
     private isDisposed;
+    private readonly onResolveHookList;
     constructor(resolveDependency: ResolveDependency<T>);
     resolve(scope: IContainer, options: ProviderOptions): T;
     private resolveDep;
@@ -25,5 +26,6 @@ export declare class Provider<T = any> implements IProvider<T> {
     addArgsFn(...fns: ArgsFn[]): this;
     hasAccess(options: ScopeAccessOptions): boolean;
     singleton(getCacheKey?: GetCacheKey): this;
+    onResolve(...hooks: DependencyHook[]): this;
     dispose(): void;
 }

package/typings/registration/IRegistration.d.ts

@@ -1,4 +1,4 @@
-import { type DependencyKey, type IContainer, type IContainerModule } from '../container/IContainer.js';
+import { type DependencyHook, type DependencyKey, type IContainer, type IContainerModule } from '../container/IContainer.js';
 import type { ArgsFn, DecorateFn, GetCacheKey, IProvider, ScopeAccessRule } from '../provider/IProvider.js';
 import { BindToken } from '../token/BindToken.js';
 import { MapFn } from '../utils/fp.js';
@@ -36,3 +36,4 @@ export declare const lazy: <T>() => ProviderPipe<T>;
 export declare const autoResolve: <T>() => ProviderPipe<T>;
 export declare const decorate: (...fns: DecorateFn[]) => ProviderPipe<unknown>;
 export declare const singleton: <T = unknown>(getCacheKey?: GetCacheKey) => ProviderPipe<T>;
+export declare const onResolve: <T = unknown>(...hooks: DependencyHook[]) => ProviderPipe<T>;