ts-ioc-container 58.0.0 → 60.0.0

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/HookContext.js

@@ -1,14 +1,13 @@
-import { getProxyTarget, isProxy } from '../utils/proxy.js';
 import { resolveArgs } from '../injector/MetadataInjector.js';
 export class HookContext {
+    instance;
     scope;
     methodName;
-    instance;
     initialArgs = [];
     constructor(instance, scope, methodName) {
+        this.instance = instance;
         this.scope = scope;
         this.methodName = methodName;
-        this.instance = isProxy(instance) ? getProxyTarget(instance) : instance;
     }
     resolveArgs(...args) {
         return resolveArgs(this.instance.constructor, this.methodName)(this.scope, {

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';
@@ -45,5 +45,5 @@ export { shallowCache } from './utils/shallowCache.js';
 export { once } from './utils/once.js';
 export { select } from './select.js';
 export { pipe } from './utils/fp.js';
-export { createProxy, unwrapProxyTarget } from './utils/proxy.js';
+export { ProxyRegistry } from './utils/ProxyRegistry.js';
 export { Is, resolveConstructor } from './utils/basic.js';

package/esm/injector/IInjector.js

@@ -1,7 +1,11 @@
-import { toLazyIf } from '../utils/proxy.js';
+import { ProxyRegistry } from '../utils/ProxyRegistry.js';
 export class Injector {
+    proxyRegistry;
+    constructor(proxyRegistry = ProxyRegistry.getInstance()) {
+        this.proxyRegistry = proxyRegistry;
+    }
     resolve(scope, Target, { args, lazy } = {}) {
-        return toLazyIf(() => {
+        return this.proxyRegistry.toLazyIf(() => {
             const instance = this.createInstance(scope, Target, { args });
             scope.addInstance(instance);
             return instance;

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/esm/utils/ProxyRegistry.js

@@ -0,0 +1,51 @@
+export class ProxyRegistry {
+    static instance;
+    states = new WeakMap();
+    constructor() { }
+    static getInstance() {
+        ProxyRegistry.instance ??= new ProxyRegistry();
+        return ProxyRegistry.instance;
+    }
+    unwrap(value) {
+        return this.isProxy(value) ? this.getTarget(value) : value;
+    }
+    createProxy(target, handler = {}) {
+        const proxy = new Proxy(target, handler);
+        return this.register(proxy, { getTarget: () => target });
+    }
+    createLazyProxy(resolveInstance) {
+        let instance;
+        const state = {
+            getTarget: () => {
+                instance = instance ?? this.unwrap(resolveInstance());
+                return instance;
+            },
+        };
+        const proxy = new Proxy({}, {
+            get: (_, prop) => {
+                const target = state.getTarget();
+                return target[prop];
+            },
+            set: (_, prop, value) => {
+                const target = state.getTarget();
+                target[prop] = value;
+                return true;
+            },
+        });
+        return this.register(proxy, state);
+    }
+    toLazyIf(resolveInstance, isLazy = false) {
+        return isLazy ? this.createLazyProxy(resolveInstance) : resolveInstance();
+    }
+    isProxy(value) {
+        return this.states.has(value);
+    }
+    getTarget(value) {
+        const target = this.states.get(value).getTarget();
+        return this.unwrap(target);
+    }
+    register(proxy, state) {
+        this.states.set(proxy, state);
+        return proxy;
+    }
+}

package/package.json

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

@@ -15,9 +15,9 @@ export interface IHookContext {
     getInitialArgs(): unknown[];
 }
 export declare class HookContext implements IHookContext {
-    scope: IContainer;
-    methodName?: string | undefined;
     readonly instance: Instance;
+    readonly scope: IContainer;
+    readonly methodName?: string | undefined;
     private initialArgs;
     constructor(instance: Instance, scope: IContainer, methodName?: string | undefined);
     resolveArgs(...args: unknown[]): unknown[];

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';
@@ -47,5 +47,5 @@ export { once } from './utils/once.js';
 export { type ExecutionContext } from './ExecutionContext.js';
 export { select } from './select.js';
 export { pipe, type MapFn } from './utils/fp.js';
-export { createProxy, unwrapProxyTarget } from './utils/proxy.js';
+export { ProxyRegistry, type IProxyRegistry } from './utils/ProxyRegistry.js';
 export { type Branded, type constructor, type Instance, Is, resolveConstructor } from './utils/basic.js';

package/typings/injector/IInjector.d.ts

@@ -1,5 +1,6 @@
 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';
 export type WithArgs = {
     args: unknown[];
@@ -12,6 +13,8 @@ export interface IInjectFnResolver<T> {
     resolve(s: IContainer, options?: ResolveOneOptions): T;
 }
 export declare abstract class Injector {
+    private readonly proxyRegistry;
+    constructor(proxyRegistry?: IProxyRegistry);
     resolve<T>(scope: IContainer, Target: constructor<T>, { args, lazy }?: ProviderOptions): T;
     protected abstract createInstance<T>(scope: IContainer, Target: constructor<T>, options?: InjectOptions): T;
 }

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>;

package/typings/utils/ProxyRegistry.d.ts

@@ -0,0 +1,19 @@
+export interface IProxyRegistry {
+    unwrap<T extends object>(value: T): T;
+    createProxy<T extends object>(target: T, handler?: ProxyHandler<T>): T;
+    createLazyProxy<T extends object>(resolveInstance: () => T): T;
+    toLazyIf<T extends object>(resolveInstance: () => T, isLazy?: boolean): T;
+}
+export declare class ProxyRegistry implements IProxyRegistry {
+    private static instance?;
+    private readonly states;
+    private constructor();
+    static getInstance(): ProxyRegistry;
+    unwrap<T extends object>(value: T): T;
+    createProxy<T extends object>(target: T, handler?: ProxyHandler<T>): T;
+    createLazyProxy<T extends object>(resolveInstance: () => T): T;
+    toLazyIf<T extends object>(resolveInstance: () => T, isLazy?: boolean): T;
+    private isProxy;
+    private getTarget;
+    private register;
+}

package/cjm/utils/proxy.js

@@ -1,48 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.unwrapProxyTarget = void 0;
-exports.isProxy = isProxy;
-exports.getProxyTarget = getProxyTarget;
-exports.createProxy = createProxy;
-exports.lazyProxy = lazyProxy;
-exports.toLazyIf = toLazyIf;
-const proxyStateMap = new WeakMap();
-const unwrapProxyTarget = (value) => {
-    return isProxy(value) ? getProxyTarget(value) : value;
-};
-exports.unwrapProxyTarget = unwrapProxyTarget;
-function isProxy(value) {
-    return proxyStateMap.has(value);
-}
-function getProxyTarget(value) {
-    const target = proxyStateMap.get(value).getTarget();
-    return (0, exports.unwrapProxyTarget)(target);
-}
-function createProxy(target, handler = {}) {
-    const proxy = new Proxy(target, handler);
-    proxyStateMap.set(proxy, { getTarget: () => target });
-    return proxy;
-}
-function lazyProxy(resolveInstance) {
-    let instance;
-    const state = {
-        getTarget: () => {
-            instance = instance ?? (0, exports.unwrapProxyTarget)(resolveInstance());
-            return instance;
-        },
-    };
-    const proxy = new Proxy({}, {
-        get: (_, prop) => {
-            const target = state.getTarget();
-            return target[prop];
-        },
-    });
-    proxyStateMap.set(proxy, state);
-    return proxy;
-}
-function toLazyIf(resolveInstance, isLazy = false) {
-    if (isLazy) {
-        return lazyProxy(resolveInstance);
-    }
-    return resolveInstance();
-}