ts-ioc-container 60.2.0 → 61.0.0

package/README.md

@@ -54,6 +54,7 @@ provider pipelines, aliases, and custom injector strategies.
   - [Scope](#scope) `scope`
 - [Module](#module)
 - [Hook](#hook) `@hook`
+  - [Hook domains](#hook-domains) `ScopeHook` `InjectorHook` `ProviderHook`
   - [OnConstruct](#onconstruct) `@onConstruct`
   - [OnConstructAsync](#onconstructasync) `@onConstructAsync`
   - [OnContainerDisposed](#oncontainerdisposed) `@onContainerDisposed`
@@ -2379,7 +2380,7 @@ 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.
+Sometimes you don't want to change the dependency, only to react to it. Use the `onResolve(...)` pipe — it appends a `ProviderHook` that receives the resolved dependency and the resolving scope.
 
 - `provider(onResolve((instance, scope) => tracker.track(instance)))`
 
@@ -2833,11 +2834,57 @@ 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`.
 
+### Hook domains
+
+The decorators above declare hook *metadata* on a class. The imperative side —
+the callbacks the container machinery runs — is registered on whichever
+abstraction raises the event, one hook type per domain:
+
+| Domain       | Registered on | Type            | Methods                                                  |
+| ------------ | ------------- | --------------- | -------------------------------------------------------- |
+| **Scope**    | `IContainer`  | `ScopeHook`     | `onScopeCreated(...)`, `onScopeDisposed(...)`            |
+| **Scope**    | `IContainer`  | `RegisteredHook`| `onRegistered(...)`                                      |
+| **Injector** | `IInjector`   | `InjectorHook`  | `onConstructed(...)`                                     |
+| **Provider** | `IProvider`   | `ProviderHook`  | `onResolved(...)`, or the [`onResolve`](#on-resolve) pipe |
+
+A container never hands its injector out — the injector is configured first and
+passed in at construction:
+
+```typescript
+// Construction is the injector's event, not a scope's
+const injector = new MetadataInjector().onConstructed((instance, scope) => metrics.built(instance, scope));
+
+const container = new Container({ injector, tags: ['application'] })
+  .onScopeCreated((scope) => audit.scopeOpened(scope))
+  .onScopeDisposed((scope) => audit.scopeClosed(scope))
+  .onRegistered((provider, key) => audit.registered(key));
+```
+
+A container passes its injector to every scope it creates, so **one injector**
+backs the whole scope tree and an `onConstructed` hook covers all of it, whenever
+it was added. Scope hooks, by contrast, are copied into a child at `createScope`
+time, so a child inherits what its parent held then and later additions to either
+stay local.
+
+The built-in modules follow the same split. `OnConstructModule` and
+`OnConstructAsyncModule` are **injector** modules (`IInjectorModule`), applied
+with `injector.useModule(...)`:
+
+```typescript
+const injector = new MetadataInjector().useModule(new OnConstructModule());
+const container = new Container({ injector });
+```
+
+`OnDisposeModule` is a container module hooking `onScopeDisposed`, and
+`OnResolvedModule` / `OnResolvedAsyncModule` are container modules reaching every
+provider through `onRegistered`.
+
 ### OnConstruct
 
 ```typescript
 import 'reflect-metadata';
 import {
+  MetadataInjector,
   OnConstructModule,
   Container,
   type ExecutionContext,
@@ -2865,9 +2912,9 @@ describe('onConstruct', function () {
       }
     }
 
-    const container = new Container()
-      .useModule(new OnConstructModule())
-      .addRegistration(R.fromValue('postgres://localhost:5432').bindTo('ConnectionString'));
+    const container = new Container({
+      injector: new MetadataInjector().useModule(new OnConstructModule()),
+    }).addRegistration(R.fromValue('postgres://localhost:5432').bindTo('ConnectionString'));
 
     const db = container.resolve(DatabaseConnection);
 
@@ -2886,11 +2933,13 @@ describe('onConstruct', function () {
     }
 
     let captured: { ex: unknown; context: ExecutionContext } | undefined;
-    const container = new Container().useModule(
-      new OnConstructModule((ex, context) => {
-        captured = { ex, context };
-      }),
-    );
+    const container = new Container({
+      injector: new MetadataInjector().useModule(
+        new OnConstructModule((ex, context) => {
+          captured = { ex, context };
+        }),
+      ),
+    });
 
     expect(() => container.resolve(BrokenService)).not.toThrow();
     expect(captured?.ex).toBe(failure);
@@ -2907,7 +2956,7 @@ describe('onConstruct', function () {
       init() {}
     }
 
-    const container = new Container().useModule(new OnConstructModule());
+    const container = new Container({ injector: new MetadataInjector().useModule(new OnConstructModule()) });
 
     expect(() => container.resolve(BrokenService)).toThrow(failure);
   });
@@ -2921,11 +2970,13 @@ describe('onConstruct', function () {
     }
 
     let scope: IContainer | undefined;
-    const container = new Container().useModule(
-      new OnConstructModule((_ex, context) => {
-        scope = context.scope;
-      }),
-    );
+    const container = new Container({
+      injector: new MetadataInjector().useModule(
+        new OnConstructModule((_ex, context) => {
+          scope = context.scope;
+        }),
+      ),
+    });
     const child = container.createScope();
 
     child.resolve(BrokenService);
@@ -2945,6 +2996,7 @@ is created and they settle afterwards, so `resolve` returns before they finish.
 ```typescript
 import 'reflect-metadata';
 import {
+  MetadataInjector,
   OnConstructAsyncModule,
   Container,
   type ExecutionContext,
@@ -2982,9 +3034,9 @@ describe('onConstructAsync', function () {
       }
     }
 
-    const container = new Container()
-      .useModule(new OnConstructAsyncModule())
-      .addRegistration(R.fromValue('postgres://localhost:5432').bindTo('ConnectionString'));
+    const container = new Container({
+      injector: new MetadataInjector().useModule(new OnConstructAsyncModule()),
+    }).addRegistration(R.fromValue('postgres://localhost:5432').bindTo('ConnectionString'));
 
     const db = container.resolve(DatabaseConnection);
 
@@ -3006,11 +3058,13 @@ describe('onConstructAsync', function () {
     }
 
     let captured: { ex: unknown; context: ExecutionContext } | undefined;
-    const container = new Container().useModule(
-      new OnConstructAsyncModule((ex, context) => {
-        captured = { ex, context };
-      }),
-    );
+    const container = new Container({
+      injector: new MetadataInjector().useModule(
+        new OnConstructAsyncModule((ex, context) => {
+          captured = { ex, context };
+        }),
+      ),
+    });
 
     const child = container.createScope();
     child.resolve(BrokenService);

package/cjm/container/Container.js

@@ -19,10 +19,9 @@ class Container {
     providers = new Map();
     aliases = new AliasMap_1.AliasMap();
     injector;
-    onConstructHookList = [];
-    onDisposeHookList = [];
     onScopeCreatedHookList = [];
-    onProviderRegisteredHookList = [];
+    onScopeDisposedHookList = [];
+    onRegisteredHookList = [];
     constructor(options = {}) {
         this.injector = options.injector ?? new MetadataInjector_1.MetadataInjector();
         this.parent = options.parent ?? new EmptyContainer_1.EmptyContainer();
@@ -32,8 +31,8 @@ class Container {
         this.validateContainer();
         this.providers.set(key, provider);
         this.aliases.setAliasesByKey(key, aliases);
-        for (const onProviderRegistered of this.onProviderRegisteredHookList) {
-            onProviderRegistered(provider, key, this);
+        for (const onRegistered of this.onRegisteredHookList) {
+            onRegistered(provider, key, this);
         }
         return this;
     }
@@ -78,10 +77,9 @@ class Container {
     createScope({ tags } = {}) {
         this.validateContainer();
         const scope = new Container({ injector: this.injector, parent: this, tags })
-            .onConstruct(...this.onConstructHookList)
-            .onInstanceDisposed(...this.onDisposeHookList)
             .onScopeCreated(...this.onScopeCreatedHookList)
-            .onProviderRegistered(...this.onProviderRegisteredHookList);
+            .onScopeDisposed(...this.onScopeDisposedHookList)
+            .onRegistered(...this.onRegisteredHookList);
         for (const registration of this.getRegistrations()) {
             registration.applyTo(scope);
         }
@@ -103,8 +101,8 @@ class Container {
     dispose() {
         this.validateContainer();
         this.isDisposed = true;
-        for (const hook of this.onDisposeHookList) {
-            hook(this);
+        for (const onScopeDisposed of this.onScopeDisposedHookList) {
+            onScopeDisposed(this);
         }
         this.parent.removeScope(this);
         this.parent = new EmptyContainer_1.EmptyContainer();
@@ -115,10 +113,9 @@ class Container {
         this.aliases.destroy();
         this.instances.clear();
         this.registrations = [];
-        this.onConstructHookList.length = 0;
-        this.onDisposeHookList.length = 0;
         this.onScopeCreatedHookList.length = 0;
-        this.onProviderRegisteredHookList.length = 0;
+        this.onScopeDisposedHookList.length = 0;
+        this.onRegisteredHookList.length = 0;
     }
     addRegistration(registration) {
         this.registrations.push(registration);
@@ -131,27 +128,20 @@ class Container {
     hasRegistration(key) {
         return this.registrations.some((r) => r.getKeyOrFail() === key) || this.parent.hasRegistration(key);
     }
-    onConstruct(...hooks) {
-        this.onConstructHookList.push(...hooks);
-        return this;
-    }
-    onInstanceDisposed(...hooks) {
-        this.onDisposeHookList.push(...hooks);
-        return this;
-    }
     onScopeCreated(...hooks) {
         this.onScopeCreatedHookList.push(...hooks);
         return this;
     }
-    onProviderRegistered(...hooks) {
-        this.onProviderRegisteredHookList.push(...hooks);
+    onScopeDisposed(...hooks) {
+        this.onScopeDisposedHookList.push(...hooks);
+        return this;
+    }
+    onRegistered(...hooks) {
+        this.onRegisteredHookList.push(...hooks);
         return this;
     }
     addInstance(instance) {
         this.instances.add(instance);
-        for (const onConstruct of this.onConstructHookList) {
-            onConstruct(instance, this);
-        }
     }
     getScopes() {
         return [...this.scopes];

package/cjm/container/EmptyContainer.js

@@ -60,16 +60,13 @@ class EmptyContainer {
     resolveOneByAlias(alias, options) {
         throw new DependencyNotFoundError_1.DependencyNotFoundError(`Cannot find alias ${alias.toString()}`);
     }
-    onInstanceDisposed(...hooks) {
-        throw new MethodNotImplementedError_1.MethodNotImplementedError();
-    }
-    onConstruct(...hooks) {
+    onScopeCreated(...hooks) {
         throw new MethodNotImplementedError_1.MethodNotImplementedError();
     }
-    onScopeCreated(...hooks) {
+    onScopeDisposed(...hooks) {
         throw new MethodNotImplementedError_1.MethodNotImplementedError();
     }
-    onProviderRegistered(...hooks) {
+    onRegistered(...hooks) {
         throw new MethodNotImplementedError_1.MethodNotImplementedError();
     }
 }

package/cjm/hooks/onConstruct.js

@@ -11,8 +11,8 @@ class OnConstructModule {
     constructor(onException) {
         this.onException = onException;
     }
-    applyTo(container) {
-        container.onConstruct((instance, scope) => {
+    applyTo(injector) {
+        injector.onConstructed((instance, scope) => {
             try {
                 exports.onConstructHooksRunner.execute(instance, { scope });
             }

package/cjm/hooks/onConstructAsync.js

@@ -11,8 +11,8 @@ class OnConstructAsyncModule {
     constructor(onException) {
         this.onException = onException;
     }
-    applyTo(container) {
-        container.onConstruct((instance, scope) => {
+    applyTo(injector) {
+        injector.onConstructed((instance, scope) => {
             if (!exports.onConstructAsyncHooksRunner.hasHooks(instance)) {
                 return;
             }

package/cjm/hooks/onContainerDisposed.js

@@ -8,7 +8,7 @@ const onContainerDisposed = (...fns) => (0, hook_1.hook)('onContainerDisposed',
 exports.onContainerDisposed = onContainerDisposed;
 class OnDisposeModule {
     applyTo(container) {
-        container.onInstanceDisposed((scope) => {
+        container.onScopeDisposed((scope) => {
             for (const instance of scope.getInstances()) {
                 exports.onContainerDisposedHooksRunner.execute(instance, { scope });
             }

package/cjm/hooks/onResolved.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolved = exports.OnResolvedModule = exports.onceResolved = exports.onResolved = exports.onResolvedHooksRunner = void 0;
+const HooksRunner_1 = require("./HooksRunner");
+const IRegistration_1 = require("../registration/IRegistration");
+const resolveHooks_1 = require("./resolveHooks");
+exports.onResolvedHooksRunner = new HooksRunner_1.HooksRunner('onResolved');
+exports.onResolved = (0, resolveHooks_1.resolvedHook)('onResolved');
+exports.onceResolved = (0, resolveHooks_1.onceResolvedHook)('onResolved');
+const runHooks = (0, resolveHooks_1.forEachResolvedObject)((0, resolveHooks_1.executeHooks)(exports.onResolvedHooksRunner));
+class OnResolvedModule {
+    applyTo(container) {
+        container.onRegistered((provider) => {
+            provider.onResolved(runHooks);
+        });
+    }
+}
+exports.OnResolvedModule = OnResolvedModule;
+const resolved = () => (0, IRegistration_1.registerPipe)((p) => p.onResolved(runHooks));
+exports.resolved = resolved;

package/cjm/hooks/onResolvedAsync.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolvedAsync = exports.OnResolvedAsyncModule = exports.onceResolvedAsync = exports.onResolvedAsync = exports.onResolvedAsyncHooksRunner = void 0;
+const HooksRunner_1 = require("./HooksRunner");
+const IRegistration_1 = require("../registration/IRegistration");
+const resolveHooks_1 = require("./resolveHooks");
+exports.onResolvedAsyncHooksRunner = new HooksRunner_1.HooksRunner('onResolvedAsync');
+exports.onResolvedAsync = (0, resolveHooks_1.resolvedHook)('onResolvedAsync');
+exports.onceResolvedAsync = (0, resolveHooks_1.onceResolvedHook)('onResolvedAsync');
+const runHooks = (onException) => (0, resolveHooks_1.forEachResolvedObject)((0, resolveHooks_1.executeHooksAsync)(exports.onResolvedAsyncHooksRunner, onException));
+class OnResolvedAsyncModule {
+    runHooks;
+    constructor(onException) {
+        this.runHooks = runHooks(onException);
+    }
+    applyTo(container) {
+        container.onRegistered((provider) => {
+            provider.onResolved(this.runHooks);
+        });
+    }
+}
+exports.OnResolvedAsyncModule = OnResolvedAsyncModule;
+const resolvedAsync = (onException) => (0, IRegistration_1.registerPipe)((p) => p.onResolved(runHooks(onException)));
+exports.resolvedAsync = resolvedAsync;

package/cjm/hooks/resolveHooks.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeHooksAsync = exports.executeHooks = exports.forEachResolvedObject = exports.onceResolvedHook = exports.resolvedHook = exports.invokeMethod = void 0;
+const hook_1 = require("./hook");
+const basic_1 = require("../utils/basic");
+const invokeMethod = (context) => {
+    context.invokeMethod();
+};
+exports.invokeMethod = invokeMethod;
+const toHooks = (hooks) => (hooks.length > 0 ? hooks : [exports.invokeMethod]);
+const onceForEachInstance = (execute) => {
+    const invokedInstances = new WeakSet();
+    return (context) => {
+        if (invokedInstances.has(context.instance)) {
+            return;
+        }
+        invokedInstances.add(context.instance);
+        return (0, hook_1.toHookFn)(execute)(context);
+    };
+};
+const resolvedHook = (key) => (...hooks) => (0, hook_1.hook)(key, (0, hook_1.prependHooks)(...toHooks(hooks)));
+exports.resolvedHook = resolvedHook;
+const onceResolvedHook = (key) => (...hooks) => (0, hook_1.hook)(key, (0, hook_1.prependHooks)(...toHooks(hooks).map(onceForEachInstance)));
+exports.onceResolvedHook = onceResolvedHook;
+const forEachResolvedObject = (run) => (dependency, scope) => {
+    if (basic_1.Is.object(dependency)) {
+        run(dependency, scope);
+    }
+};
+exports.forEachResolvedObject = forEachResolvedObject;
+const executeHooks = (runner) => (dependency, scope) => runner.execute(dependency, { scope });
+exports.executeHooks = executeHooks;
+const executeHooksAsync = (runner, onException) => (dependency, scope) => {
+    if (!runner.hasHooks(dependency)) {
+        return;
+    }
+    runner.executeAsync(dependency, { scope }).catch((ex) => {
+        if (!onException) {
+            throw ex;
+        }
+        onException(ex, { scope });
+    });
+};
+exports.executeHooksAsync = executeHooksAsync;

package/cjm/index.js

@@ -1,8 +1,8 @@
 "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.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.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.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.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.Is = exports.unwrapProxy = exports.ProxyRegistry = exports.pipe = exports.select = void 0;
+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.HooksRunner = exports.invokeMethod = exports.resolvedAsync = exports.OnResolvedAsyncModule = exports.onceResolvedAsync = exports.onResolvedAsync = exports.onResolvedAsyncHooksRunner = exports.resolved = exports.OnResolvedModule = exports.onceResolved = exports.onResolved = exports.onResolvedHooksRunner = 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.Is = exports.unwrapProxy = exports.ProxyRegistry = 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 = 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");
@@ -91,6 +91,20 @@ 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, "OnDisposeModule", { enumerable: true, get: function () { return onContainerDisposed_1.OnDisposeModule; } });
+var onResolved_1 = require("./hooks/onResolved");
+Object.defineProperty(exports, "onResolvedHooksRunner", { enumerable: true, get: function () { return onResolved_1.onResolvedHooksRunner; } });
+Object.defineProperty(exports, "onResolved", { enumerable: true, get: function () { return onResolved_1.onResolved; } });
+Object.defineProperty(exports, "onceResolved", { enumerable: true, get: function () { return onResolved_1.onceResolved; } });
+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 onResolvedAsync_1 = require("./hooks/onResolvedAsync");
+Object.defineProperty(exports, "onResolvedAsyncHooksRunner", { enumerable: true, get: function () { return onResolvedAsync_1.onResolvedAsyncHooksRunner; } });
+Object.defineProperty(exports, "onResolvedAsync", { enumerable: true, get: function () { return onResolvedAsync_1.onResolvedAsync; } });
+Object.defineProperty(exports, "onceResolvedAsync", { enumerable: true, get: function () { return onResolvedAsync_1.onceResolvedAsync; } });
+Object.defineProperty(exports, "OnResolvedAsyncModule", { enumerable: true, get: function () { return onResolvedAsync_1.OnResolvedAsyncModule; } });
+Object.defineProperty(exports, "resolvedAsync", { enumerable: true, get: function () { return onResolvedAsync_1.resolvedAsync; } });
+var resolveHooks_1 = require("./hooks/resolveHooks");
+Object.defineProperty(exports, "invokeMethod", { enumerable: true, get: function () { return resolveHooks_1.invokeMethod; } });
 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/injector/IInjector.js

@@ -4,6 +4,7 @@ exports.Injector = void 0;
 const ProxyRegistry_1 = require("../utils/ProxyRegistry");
 class Injector {
     proxyRegistry;
+    onConstructedHookList = [];
     constructor(proxyRegistry = ProxyRegistry_1.ProxyRegistry.getInstance()) {
         this.proxyRegistry = proxyRegistry;
     }
@@ -11,8 +12,19 @@ class Injector {
         return this.proxyRegistry.toLazyIf(() => {
             const instance = this.createInstance(scope, Target, { args });
             scope.addInstance(instance);
+            for (const onConstructed of this.onConstructedHookList) {
+                onConstructed(instance, scope);
+            }
             return instance;
         }, lazy);
     }
+    onConstructed(...hooks) {
+        this.onConstructedHookList.push(...hooks);
+        return this;
+    }
+    useModule(module) {
+        module.applyTo(this);
+        return this;
+    }
 }
 exports.Injector = Injector;

package/cjm/provider/Provider.js

@@ -22,7 +22,7 @@ class Provider {
     cache = new Map();
     getKey;
     isDisposed = false;
-    onResolveHookList = [];
+    onResolvedHookList = [];
     constructor(resolveDependency) {
         this.resolveDependency = resolveDependency;
     }
@@ -43,8 +43,8 @@ class Provider {
             lazy: lazy ?? this.isLazy,
         });
         dependency = this.mappers.reduce((acc, current) => current(acc, scope), dependency);
-        for (const onResolve of this.onResolveHookList) {
-            onResolve(dependency, scope);
+        for (const onResolved of this.onResolvedHookList) {
+            onResolved(dependency, scope);
         }
         return dependency;
     }
@@ -81,8 +81,8 @@ class Provider {
         this.getKey = getCacheKey;
         return this;
     }
-    onResolve(...hooks) {
-        this.onResolveHookList.push(...hooks);
+    onResolved(...hooks) {
+        this.onResolvedHookList.push(...hooks);
         return this;
     }
     dispose() {
@@ -94,7 +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);
+        this.onResolvedHookList.splice(0, this.onResolvedHookList.length);
     }
 }
 exports.Provider = Provider;

package/cjm/registration/IRegistration.js

@@ -54,5 +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));
+const onResolve = (...hooks) => (0, exports.registerPipe)((p) => p.onResolved(...hooks));
 exports.onResolve = onResolve;

package/esm/container/Container.js

@@ -16,10 +16,9 @@ export class Container {
     providers = new Map();
     aliases = new AliasMap();
     injector;
-    onConstructHookList = [];
-    onDisposeHookList = [];
     onScopeCreatedHookList = [];
-    onProviderRegisteredHookList = [];
+    onScopeDisposedHookList = [];
+    onRegisteredHookList = [];
     constructor(options = {}) {
         this.injector = options.injector ?? new MetadataInjector();
         this.parent = options.parent ?? new EmptyContainer();
@@ -29,8 +28,8 @@ export class Container {
         this.validateContainer();
         this.providers.set(key, provider);
         this.aliases.setAliasesByKey(key, aliases);
-        for (const onProviderRegistered of this.onProviderRegisteredHookList) {
-            onProviderRegistered(provider, key, this);
+        for (const onRegistered of this.onRegisteredHookList) {
+            onRegistered(provider, key, this);
         }
         return this;
     }
@@ -75,10 +74,9 @@ export class Container {
     createScope({ tags } = {}) {
         this.validateContainer();
         const scope = new Container({ injector: this.injector, parent: this, tags })
-            .onConstruct(...this.onConstructHookList)
-            .onInstanceDisposed(...this.onDisposeHookList)
             .onScopeCreated(...this.onScopeCreatedHookList)
-            .onProviderRegistered(...this.onProviderRegisteredHookList);
+            .onScopeDisposed(...this.onScopeDisposedHookList)
+            .onRegistered(...this.onRegisteredHookList);
         for (const registration of this.getRegistrations()) {
             registration.applyTo(scope);
         }
@@ -100,8 +98,8 @@ export class Container {
     dispose() {
         this.validateContainer();
         this.isDisposed = true;
-        for (const hook of this.onDisposeHookList) {
-            hook(this);
+        for (const onScopeDisposed of this.onScopeDisposedHookList) {
+            onScopeDisposed(this);
         }
         this.parent.removeScope(this);
         this.parent = new EmptyContainer();
@@ -112,10 +110,9 @@ export class Container {
         this.aliases.destroy();
         this.instances.clear();
         this.registrations = [];
-        this.onConstructHookList.length = 0;
-        this.onDisposeHookList.length = 0;
         this.onScopeCreatedHookList.length = 0;
-        this.onProviderRegisteredHookList.length = 0;
+        this.onScopeDisposedHookList.length = 0;
+        this.onRegisteredHookList.length = 0;
     }
     addRegistration(registration) {
         this.registrations.push(registration);
@@ -128,27 +125,20 @@ export class Container {
     hasRegistration(key) {
         return this.registrations.some((r) => r.getKeyOrFail() === key) || this.parent.hasRegistration(key);
     }
-    onConstruct(...hooks) {
-        this.onConstructHookList.push(...hooks);
-        return this;
-    }
-    onInstanceDisposed(...hooks) {
-        this.onDisposeHookList.push(...hooks);
-        return this;
-    }
     onScopeCreated(...hooks) {
         this.onScopeCreatedHookList.push(...hooks);
         return this;
     }
-    onProviderRegistered(...hooks) {
-        this.onProviderRegisteredHookList.push(...hooks);
+    onScopeDisposed(...hooks) {
+        this.onScopeDisposedHookList.push(...hooks);
+        return this;
+    }
+    onRegistered(...hooks) {
+        this.onRegisteredHookList.push(...hooks);
         return this;
     }
     addInstance(instance) {
         this.instances.add(instance);
-        for (const onConstruct of this.onConstructHookList) {
-            onConstruct(instance, this);
-        }
     }
     getScopes() {
         return [...this.scopes];

package/esm/container/EmptyContainer.js

@@ -57,16 +57,13 @@ export class EmptyContainer {
     resolveOneByAlias(alias, options) {
         throw new DependencyNotFoundError(`Cannot find alias ${alias.toString()}`);
     }
-    onInstanceDisposed(...hooks) {
-        throw new MethodNotImplementedError();
-    }
-    onConstruct(...hooks) {
+    onScopeCreated(...hooks) {
         throw new MethodNotImplementedError();
     }
-    onScopeCreated(...hooks) {
+    onScopeDisposed(...hooks) {
         throw new MethodNotImplementedError();
     }
-    onProviderRegistered(...hooks) {
+    onRegistered(...hooks) {
         throw new MethodNotImplementedError();
     }
 }

package/esm/hooks/onConstruct.js

@@ -7,8 +7,8 @@ export class OnConstructModule {
     constructor(onException) {
         this.onException = onException;
     }
-    applyTo(container) {
-        container.onConstruct((instance, scope) => {
+    applyTo(injector) {
+        injector.onConstructed((instance, scope) => {
             try {
                 onConstructHooksRunner.execute(instance, { scope });
             }

package/esm/hooks/onConstructAsync.js

@@ -7,8 +7,8 @@ export class OnConstructAsyncModule {
     constructor(onException) {
         this.onException = onException;
     }
-    applyTo(container) {
-        container.onConstruct((instance, scope) => {
+    applyTo(injector) {
+        injector.onConstructed((instance, scope) => {
             if (!onConstructAsyncHooksRunner.hasHooks(instance)) {
                 return;
             }

package/esm/hooks/onContainerDisposed.js

@@ -4,7 +4,7 @@ export const onContainerDisposedHooksRunner = new HooksRunner('onContainerDispos
 export const onContainerDisposed = (...fns) => hook('onContainerDisposed', prependHooks(...fns));
 export class OnDisposeModule {
     applyTo(container) {
-        container.onInstanceDisposed((scope) => {
+        container.onScopeDisposed((scope) => {
             for (const instance of scope.getInstances()) {
                 onContainerDisposedHooksRunner.execute(instance, { scope });
             }

package/esm/hooks/onResolved.js

@@ -0,0 +1,15 @@
+import { HooksRunner } from './HooksRunner.js';
+import { registerPipe } from '../registration/IRegistration.js';
+import { executeHooks, forEachResolvedObject, onceResolvedHook, resolvedHook } from './resolveHooks.js';
+export const onResolvedHooksRunner = new HooksRunner('onResolved');
+export const onResolved = resolvedHook('onResolved');
+export const onceResolved = onceResolvedHook('onResolved');
+const runHooks = forEachResolvedObject(executeHooks(onResolvedHooksRunner));
+export class OnResolvedModule {
+    applyTo(container) {
+        container.onRegistered((provider) => {
+            provider.onResolved(runHooks);
+        });
+    }
+}
+export const resolved = () => registerPipe((p) => p.onResolved(runHooks));

package/esm/hooks/onResolvedAsync.js

@@ -0,0 +1,19 @@
+import { HooksRunner } from './HooksRunner.js';
+import { registerPipe } from '../registration/IRegistration.js';
+import { executeHooksAsync, forEachResolvedObject, onceResolvedHook, resolvedHook } from './resolveHooks.js';
+export const onResolvedAsyncHooksRunner = new HooksRunner('onResolvedAsync');
+export const onResolvedAsync = resolvedHook('onResolvedAsync');
+export const onceResolvedAsync = onceResolvedHook('onResolvedAsync');
+const runHooks = (onException) => forEachResolvedObject(executeHooksAsync(onResolvedAsyncHooksRunner, onException));
+export class OnResolvedAsyncModule {
+    runHooks;
+    constructor(onException) {
+        this.runHooks = runHooks(onException);
+    }
+    applyTo(container) {
+        container.onRegistered((provider) => {
+            provider.onResolved(this.runHooks);
+        });
+    }
+}
+export const resolvedAsync = (onException) => registerPipe((p) => p.onResolved(runHooks(onException)));

package/esm/hooks/resolveHooks.js

@@ -0,0 +1,35 @@
+import { hook, prependHooks, toHookFn } from './hook.js';
+import { Is } from '../utils/basic.js';
+export const invokeMethod = (context) => {
+    context.invokeMethod();
+};
+const toHooks = (hooks) => (hooks.length > 0 ? hooks : [invokeMethod]);
+const onceForEachInstance = (execute) => {
+    const invokedInstances = new WeakSet();
+    return (context) => {
+        if (invokedInstances.has(context.instance)) {
+            return;
+        }
+        invokedInstances.add(context.instance);
+        return toHookFn(execute)(context);
+    };
+};
+export const resolvedHook = (key) => (...hooks) => hook(key, prependHooks(...toHooks(hooks)));
+export const onceResolvedHook = (key) => (...hooks) => hook(key, prependHooks(...toHooks(hooks).map(onceForEachInstance)));
+export const forEachResolvedObject = (run) => (dependency, scope) => {
+    if (Is.object(dependency)) {
+        run(dependency, scope);
+    }
+};
+export const executeHooks = (runner) => (dependency, scope) => runner.execute(dependency, { scope });
+export const executeHooksAsync = (runner, onException) => (dependency, scope) => {
+    if (!runner.hasHooks(dependency)) {
+        return;
+    }
+    runner.executeAsync(dependency, { scope }).catch((ex) => {
+        if (!onException) {
+            throw ex;
+        }
+        onException(ex, { scope });
+    });
+};

package/esm/index.js

@@ -2,7 +2,7 @@ export { isDependencyKey, } from './container/IContainer.js';
 export { Container } from './container/Container.js';
 export { AutoResolveModule } from './container/AutoResolveModule.js';
 export { EmptyContainer } from './container/EmptyContainer.js';
-export { Injector } from './injector/IInjector.js';
+export { Injector, } from './injector/IInjector.js';
 export { MetadataInjector, inject, arg, args, argsFn, resolveArgs } from './injector/MetadataInjector.js';
 export { SimpleInjector } from './injector/SimpleInjector.js';
 export { ProxyInjector } from './injector/ProxyInjector.js';
@@ -25,6 +25,9 @@ export { injectProp } from './hooks/injectProp.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 { onResolvedHooksRunner, onResolved, onceResolved, OnResolvedModule, resolved } from './hooks/onResolved.js';
+export { onResolvedAsyncHooksRunner, onResolvedAsync, onceResolvedAsync, OnResolvedAsyncModule, resolvedAsync, } from './hooks/onResolvedAsync.js';
+export { invokeMethod } from './hooks/resolveHooks.js';
 export { HooksRunner } from './hooks/HooksRunner.js';
 export { InjectionToken } from './token/InjectionToken.js';
 export { toToken, toMappedToken, argToToken } from './token/toToken.js';

package/esm/injector/IInjector.js

@@ -1,6 +1,7 @@
 import { ProxyRegistry } from '../utils/ProxyRegistry.js';
 export class Injector {
     proxyRegistry;
+    onConstructedHookList = [];
     constructor(proxyRegistry = ProxyRegistry.getInstance()) {
         this.proxyRegistry = proxyRegistry;
     }
@@ -8,7 +9,18 @@ export class Injector {
         return this.proxyRegistry.toLazyIf(() => {
             const instance = this.createInstance(scope, Target, { args });
             scope.addInstance(instance);
+            for (const onConstructed of this.onConstructedHookList) {
+                onConstructed(instance, scope);
+            }
             return instance;
         }, lazy);
     }
+    onConstructed(...hooks) {
+        this.onConstructedHookList.push(...hooks);
+        return this;
+    }
+    useModule(module) {
+        module.applyTo(this);
+        return this;
+    }
 }

package/esm/provider/Provider.js

@@ -19,7 +19,7 @@ export class Provider {
     cache = new Map();
     getKey;
     isDisposed = false;
-    onResolveHookList = [];
+    onResolvedHookList = [];
     constructor(resolveDependency) {
         this.resolveDependency = resolveDependency;
     }
@@ -40,8 +40,8 @@ export class Provider {
             lazy: lazy ?? this.isLazy,
         });
         dependency = this.mappers.reduce((acc, current) => current(acc, scope), dependency);
-        for (const onResolve of this.onResolveHookList) {
-            onResolve(dependency, scope);
+        for (const onResolved of this.onResolvedHookList) {
+            onResolved(dependency, scope);
         }
         return dependency;
     }
@@ -78,8 +78,8 @@ export class Provider {
         this.getKey = getCacheKey;
         return this;
     }
-    onResolve(...hooks) {
-        this.onResolveHookList.push(...hooks);
+    onResolved(...hooks) {
+        this.onResolvedHookList.push(...hooks);
         return this;
     }
     dispose() {
@@ -91,6 +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);
+        this.onResolvedHookList.splice(0, this.onResolvedHookList.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,4 +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));
+export const onResolve = (...hooks) => registerPipe((p) => p.onResolved(...hooks));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-ioc-container",
-  "version": "60.2.0",
+  "version": "61.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 InstanceHook, type ProviderHook, type RegisterOptions, ResolveManyOptions, type ResolveOneOptions, type ScopeHook, type Tag } from './IContainer.js';
+import { type AutoResolveOptions, type CreateScopeOptions, type DependencyKey, type IContainer, type IContainerModule, type RegisteredHook, 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 { OnDisposeHook } from '../hooks/onContainerDisposed.js';
 import { constructor, Instance } from '../utils/basic.js';
 export declare class Container implements IContainer {
     isDisposed: boolean;
@@ -14,10 +13,9 @@ export declare class Container implements IContainer {
     private readonly providers;
     private readonly aliases;
     private readonly injector;
-    private readonly onConstructHookList;
-    private readonly onDisposeHookList;
     private readonly onScopeCreatedHookList;
-    private readonly onProviderRegisteredHookList;
+    private readonly onScopeDisposedHookList;
+    private readonly onRegisteredHookList;
     constructor(options?: {
         injector?: IInjector;
         parent?: IContainer;
@@ -33,10 +31,9 @@ export declare class Container implements IContainer {
     addRegistration(registration: IRegistration): this;
     getRegistrations(): IRegistration[];
     hasRegistration(key: DependencyKey): boolean;
-    onConstruct(...hooks: InstanceHook[]): this;
-    onInstanceDisposed(...hooks: OnDisposeHook[]): this;
     onScopeCreated(...hooks: ScopeHook[]): this;
-    onProviderRegistered(...hooks: ProviderHook[]): this;
+    onScopeDisposed(...hooks: ScopeHook[]): this;
+    onRegistered(...hooks: RegisteredHook[]): this;
     addInstance(instance: Instance): void;
     getScopes(): IContainer[];
     hasInstance(instance: Instance): boolean;

package/typings/container/EmptyContainer.d.ts

@@ -1,7 +1,6 @@
-import { type AutoResolveOptions, type DependencyKey, type IContainer, type IContainerModule, type ScopeHook, type ProviderHook, type ResolveManyOptions, type ResolveOneOptions, type Tag, type InstanceHook } from './IContainer.js';
+import { type AutoResolveOptions, type DependencyKey, type IContainer, type IContainerModule, type ScopeHook, type RegisteredHook, type ResolveManyOptions, type ResolveOneOptions, type Tag } from './IContainer.js';
 import { type IProvider } from '../provider/IProvider.js';
 import { type IRegistration } from '../registration/IRegistration.js';
-import { OnDisposeHook } from '../hooks/onContainerDisposed.js';
 import { type constructor, type Instance } from '../utils/basic.js';
 export declare class EmptyContainer implements IContainer {
     get isDisposed(): boolean;
@@ -24,8 +23,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;
-    onInstanceDisposed(...hooks: OnDisposeHook[]): this;
-    onConstruct(...hooks: InstanceHook[]): this;
     onScopeCreated(...hooks: ScopeHook[]): this;
-    onProviderRegistered(...hooks: ProviderHook[]): this;
+    onScopeDisposed(...hooks: ScopeHook[]): this;
+    onRegistered(...hooks: RegisteredHook[]): 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 { OnDisposeHook } from '../hooks/onContainerDisposed.js';
 import { type WithArgs } from '../injector/IInjector.js';
 import { type constructor, Instance } from '../utils/basic.js';
 export type DependencyKey = string | symbol;
@@ -33,15 +32,12 @@ 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 type ProviderHook = (provider: IProvider, key: DependencyKey, scope: IContainer) => void;
+export type RegisteredHook = (provider: IProvider, key: DependencyKey, scope: IContainer) => void;
 export interface IContainer extends Tagged {
     readonly isDisposed: boolean;
-    onConstruct(...hooks: InstanceHook[]): this;
-    onInstanceDisposed(...hooks: OnDisposeHook[]): this;
     onScopeCreated(...hooks: ScopeHook[]): this;
-    onProviderRegistered(...hooks: ProviderHook[]): this;
+    onScopeDisposed(...hooks: ScopeHook[]): this;
+    onRegistered(...hooks: RegisteredHook[]): this;
     register(key: DependencyKey, value: IProvider, options?: RegisterOptions): this;
     addRegistration(registration: IRegistration): this;
     getRegistrations(): IRegistration[];

package/typings/hooks/onConstruct.d.ts

@@ -1,12 +1,12 @@
 import { HookType } from './hook.js';
-import type { IContainer, IContainerModule } from '../container/IContainer.js';
+import type { IInjector, IInjectorModule } from '../injector/IInjector.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 OnExceptionHandler = (ex: unknown, context: ExecutionContext) => void;
-export declare class OnConstructModule implements IContainerModule {
+export declare class OnConstructModule implements IInjectorModule {
     private readonly onException?;
     constructor(onException?: OnExceptionHandler | undefined);
-    applyTo(container: IContainer): void;
+    applyTo(injector: IInjector): void;
 }

package/typings/hooks/onConstructAsync.d.ts

@@ -1,11 +1,11 @@
 import { HookType } from './hook.js';
-import type { IContainer, IContainerModule } from '../container/IContainer.js';
+import type { IInjector, IInjectorModule } from '../injector/IInjector.js';
 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 OnConstructAsyncModule implements IContainerModule {
+export declare class OnConstructAsyncModule implements IInjectorModule {
     private readonly onException?;
     constructor(onException?: OnExceptionHandler | undefined);
-    applyTo(container: IContainer): void;
+    applyTo(injector: IInjector): void;
 }

package/typings/hooks/onContainerDisposed.d.ts

@@ -3,7 +3,6 @@ import type { IContainer, IContainerModule } from '../container/IContainer.js';
 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 OnDisposeModule implements IContainerModule {
     applyTo(container: IContainer): void;
 }

package/typings/hooks/onResolved.d.ts

@@ -0,0 +1,9 @@
+import type { IContainer, IContainerModule } from '../container/IContainer.js';
+import { HooksRunner } from './HooksRunner.js';
+export declare const onResolvedHooksRunner: HooksRunner;
+export declare const onResolved: (...hooks: import("./hook.js").HookType[]) => (target: object, propertyKey: string | symbol) => void;
+export declare const onceResolved: (...hooks: import("./hook.js").HookType[]) => (target: object, propertyKey: string | symbol) => void;
+export declare class OnResolvedModule implements IContainerModule {
+    applyTo(container: IContainer): void;
+}
+export declare const resolved: <T = unknown>() => import("../registration/IRegistration.js").ProviderPipe<T>;

package/typings/hooks/onResolvedAsync.d.ts

@@ -0,0 +1,12 @@
+import type { IContainer, IContainerModule } from '../container/IContainer.js';
+import { HooksRunner } from './HooksRunner.js';
+import type { OnExceptionHandler } from './onConstruct.js';
+export declare const onResolvedAsyncHooksRunner: HooksRunner;
+export declare const onResolvedAsync: (...hooks: import("./hook.js").HookType[]) => (target: object, propertyKey: string | symbol) => void;
+export declare const onceResolvedAsync: (...hooks: import("./hook.js").HookType[]) => (target: object, propertyKey: string | symbol) => void;
+export declare class OnResolvedAsyncModule implements IContainerModule {
+    private readonly runHooks;
+    constructor(onException?: OnExceptionHandler);
+    applyTo(container: IContainer): void;
+}
+export declare const resolvedAsync: <T = unknown>(onException?: OnExceptionHandler) => import("../registration/IRegistration.js").ProviderPipe<T>;

package/typings/hooks/resolveHooks.d.ts

@@ -0,0 +1,12 @@
+import type { IContainer } from '../container/IContainer.js';
+import type { ProviderHook } from '../provider/IProvider.js';
+import type { HooksRunner } from './HooksRunner.js';
+import { type HookFn, type HookType } from './hook.js';
+import type { OnExceptionHandler } from './onConstruct.js';
+export type ResolvedObjectHook = (dependency: object, scope: IContainer) => void;
+export declare const invokeMethod: HookFn;
+export declare const resolvedHook: (key: string) => (...hooks: HookType[]) => (target: object, propertyKey: string | symbol) => void;
+export declare const onceResolvedHook: (key: string) => (...hooks: HookType[]) => (target: object, propertyKey: string | symbol) => void;
+export declare const forEachResolvedObject: (run: ResolvedObjectHook) => ProviderHook;
+export declare const executeHooks: (runner: HooksRunner) => ResolvedObjectHook;
+export declare const executeHooksAsync: (runner: HooksRunner, onException?: OnExceptionHandler) => ResolvedObjectHook;

package/typings/index.d.ts

@@ -1,12 +1,12 @@
-export { type IContainer, type Resolvable, type IContainerModule, type DependencyKey, type Tag, type Tagged, type ResolveOneOptions, type ResolveManyOptions, type ScopeHook, type InstanceHook, type DependencyHook, type ProviderHook, 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 RegisteredHook, 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';
-export { type IInjector, type InjectOptions, type IInjectFnResolver, Injector } from './injector/IInjector.js';
+export { type IInjector, type InjectOptions, type IInjectFnResolver, type IInjectorModule, type InjectorHook, Injector, } from './injector/IInjector.js';
 export { MetadataInjector, inject, arg, args, argsFn, resolveArgs } from './injector/MetadataInjector.js';
 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 { type ResolveDependency, type IProvider, type DecorateFn, type ArgsFn, type ProviderOptions, type GetCacheKey, type ScopeAccessOptions, type ScopeAccessRule, type ProviderHook, } 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, onResolve, } from './registration/IRegistration.js';
 export { Registration } from './registration/Registration.js';
@@ -26,6 +26,9 @@ export { injectProp } from './hooks/injectProp.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 { onResolvedHooksRunner, onResolved, onceResolved, OnResolvedModule, resolved } from './hooks/onResolved.js';
+export { onResolvedAsyncHooksRunner, onResolvedAsync, onceResolvedAsync, OnResolvedAsyncModule, resolvedAsync, } from './hooks/onResolvedAsync.js';
+export { invokeMethod, type ResolvedObjectHook } from './hooks/resolveHooks.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/injector/IInjector.d.ts

@@ -1,20 +1,28 @@
 import { type IContainer, ResolveOneOptions } from '../container/IContainer.js';
 import { ProviderOptions } from '../provider/IProvider.js';
 import { type IProxyRegistry } from '../utils/ProxyRegistry.js';
-import { type constructor } from '../utils/basic.js';
+import { type constructor, Instance } from '../utils/basic.js';
 export type WithArgs = {
     args: unknown[];
 };
 export type InjectOptions = Partial<WithArgs>;
+export type InjectorHook = (instance: Instance, scope: IContainer) => void;
 export interface IInjector {
     resolve<T>(container: IContainer, value: constructor<T>, options?: ProviderOptions): T;
+    onConstructed(...hooks: InjectorHook[]): this;
+}
+export interface IInjectorModule {
+    applyTo(injector: IInjector): void;
 }
 export interface IInjectFnResolver<T> {
     resolve(s: IContainer, options?: ResolveOneOptions): T;
 }
 export declare abstract class Injector {
     private readonly proxyRegistry;
+    private readonly onConstructedHookList;
     constructor(proxyRegistry?: IProxyRegistry);
     resolve<T>(scope: IContainer, Target: constructor<T>, { args, lazy }?: ProviderOptions): T;
+    onConstructed(...hooks: InjectorHook[]): this;
+    useModule(module: IInjectorModule): this;
     protected abstract createInstance<T>(scope: IContainer, Target: constructor<T>, options?: InjectOptions): T;
 }

package/typings/provider/IProvider.d.ts

@@ -1,4 +1,4 @@
-import { type DependencyHook, IContainer, Tagged } from '../container/IContainer.js';
+import { IContainer, Tagged } from '../container/IContainer.js';
 import { InjectOptions } from '../injector/IInjector.js';
 export type WithLazy = {
     lazy: boolean;
@@ -14,6 +14,7 @@ export type ScopeAccessRule = (options: ScopeAccessOptions, prev: boolean) => bo
 export type ArgsFn = (l: IContainer, options?: InjectOptions) => unknown[];
 export type GetCacheKey = (...args: unknown[]) => string | symbol;
 export type DecorateFn<Instance = any> = (dep: Instance, scope: IContainer) => Instance;
+export type ProviderHook = (dependency: unknown, scope: IContainer) => void;
 export interface IProvider<T = any> {
     resolve(container: IContainer, options: ProviderOptions): T;
     hasAccess(options: ScopeAccessOptions): boolean;
@@ -25,5 +26,5 @@ export interface IProvider<T = any> {
     isAutoResolvable(): boolean;
     singleton(getCacheKey?: GetCacheKey): this;
     dispose(): void;
-    onResolve(...hooks: DependencyHook[]): this;
+    onResolved(...hooks: ProviderHook[]): 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 { DependencyHook, DependencyKey, IContainer } from '../container/IContainer.js';
+import { type ArgsFn, type DecorateFn, type GetCacheKey, type IProvider, type ProviderOptions, type ResolveDependency, type ScopeAccessOptions, type ScopeAccessRule, type ProviderHook } from './IProvider.js';
+import type { 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,7 +14,7 @@ export declare class Provider<T = any> implements IProvider<T> {
     private cache;
     private getKey;
     private isDisposed;
-    private readonly onResolveHookList;
+    private readonly onResolvedHookList;
     constructor(resolveDependency: ResolveDependency<T>);
     resolve(scope: IContainer, options: ProviderOptions): T;
     private resolveDep;
@@ -26,6 +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;
+    onResolved(...hooks: ProviderHook[]): this;
     dispose(): void;
 }

package/typings/registration/IRegistration.d.ts

@@ -1,5 +1,5 @@
-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 { type DependencyKey, type IContainer, type IContainerModule } from '../container/IContainer.js';
+import type { ArgsFn, DecorateFn, GetCacheKey, IProvider, ProviderHook, ScopeAccessRule } from '../provider/IProvider.js';
 import { BindToken } from '../token/BindToken.js';
 import { MapFn } from '../utils/fp.js';
 import { type constructor } from '../utils/basic.js';
@@ -36,4 +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>;
+export declare const onResolve: <T = unknown>(...hooks: ProviderHook[]) => ProviderPipe<T>;