ts-ioc-container 58.0.0 → 59.0.0

package/cjm/hooks/HookContext.js

@@ -1,17 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createHookContextFactory = exports.createHookContext = exports.HookContext = void 0;
-const proxy_1 = require("../utils/proxy");
 const MetadataInjector_1 = require("../injector/MetadataInjector");
 class HookContext {
+    instance;
     scope;
     methodName;
-    instance;
     initialArgs = [];
     constructor(instance, scope, methodName) {
+        this.instance = instance;
         this.scope = scope;
         this.methodName = methodName;
-        this.instance = (0, proxy_1.isProxy)(instance) ? (0, proxy_1.getProxyTarget)(instance) : instance;
     }
     resolveArgs(...args) {
         return (0, MetadataInjector_1.resolveArgs)(this.instance.constructor, this.methodName)(this.scope, {

package/cjm/index.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createHookContext = exports.createHookContextFactory = exports.HookContext = exports.prepend = exports.append = exports.prependHooks = exports.appendHooks = exports.hasHooks = exports.hook = exports.getHooks = exports.UnsupportedTokenTypeError = exports.CannonSingletonApplyTwiceError = exports.UnexpectedHookResultError = exports.ProviderDisposedError = exports.ContainerDisposedError = exports.MethodNotImplementedError = exports.DependencyMissingKeyError = exports.ContainerNotFoundError = exports.DependencyNotFoundError = exports.ContainerError = exports.Registration = exports.appendArgsFn = exports.appendArgs = exports.decorate = exports.singleton = exports.autoResolve = exports.lazy = exports.scopeAccess = exports.scope = exports.bindTo = exports.register = exports.toRegistrationFn = exports.toProviderFn = exports.toBindToken = exports.registerPipe = exports.isProviderPipe = exports.Provider = exports.ProxyInjector = exports.SimpleInjector = exports.resolveArgs = exports.argsFn = exports.args = exports.arg = exports.inject = exports.MetadataInjector = exports.Injector = exports.EmptyContainer = exports.AutoResolveModule = exports.Container = exports.isDependencyKey = void 0;
 exports.pipe = exports.select = exports.once = exports.shallowCache = exports.debounce = exports.throttle = exports.handleAsyncError = exports.handleError = exports.getMethodTags = exports.addMethodTag = exports.getMethodLabels = exports.addMethodLabel = exports.getMethodMeta = exports.addMethodMeta = exports.getParamTags = exports.addParamTag = exports.getParamLabels = exports.addParamLabel = exports.getParamMeta = exports.addParamMeta = exports.getClassTags = exports.addClassTag = exports.getClassLabels = exports.addClassLabel = exports.getClassMeta = exports.addClassMeta = exports.GroupInstanceToken = exports.ConstantToken = exports.FunctionToken = exports.SingleToken = exports.ClassToken = exports.toSingleAlias = exports.SingleAliasToken = exports.toGroupAlias = exports.GroupAliasToken = exports.argToToken = exports.toMappedToken = exports.toToken = exports.InjectionToken = exports.HooksRunner = exports.AddOnDisposeHookModule = exports.onContainerDisposed = exports.onContainerDisposedHooksRunner = exports.AddOnConstructAsyncHookModule = exports.onConstructAsync = exports.onConstructAsyncHooksRunner = exports.AddOnConstructHookModule = exports.onConstruct = exports.onConstructHooksRunner = exports.injectProp = void 0;
-exports.resolveConstructor = exports.Is = exports.unwrapProxyTarget = exports.createProxy = void 0;
+exports.resolveConstructor = exports.Is = exports.ProxyRegistry = 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");
@@ -150,9 +150,8 @@ var select_1 = require("./select");
 Object.defineProperty(exports, "select", { enumerable: true, get: function () { return select_1.select; } });
 var fp_1 = require("./utils/fp");
 Object.defineProperty(exports, "pipe", { enumerable: true, get: function () { return fp_1.pipe; } });
-var proxy_1 = require("./utils/proxy");
-Object.defineProperty(exports, "createProxy", { enumerable: true, get: function () { return proxy_1.createProxy; } });
-Object.defineProperty(exports, "unwrapProxyTarget", { enumerable: true, get: function () { return proxy_1.unwrapProxyTarget; } });
+var ProxyRegistry_1 = require("./utils/ProxyRegistry");
+Object.defineProperty(exports, "ProxyRegistry", { enumerable: true, get: function () { return ProxyRegistry_1.ProxyRegistry; } });
 var basic_1 = require("./utils/basic");
 Object.defineProperty(exports, "Is", { enumerable: true, get: function () { return basic_1.Is; } });
 Object.defineProperty(exports, "resolveConstructor", { enumerable: true, get: function () { return basic_1.resolveConstructor; } });

package/cjm/injector/IInjector.js

@@ -1,10 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Injector = void 0;
-const proxy_1 = require("../utils/proxy");
+const ProxyRegistry_1 = require("../utils/ProxyRegistry");
 class Injector {
+    proxyRegistry;
+    constructor(proxyRegistry = ProxyRegistry_1.ProxyRegistry.getInstance()) {
+        this.proxyRegistry = proxyRegistry;
+    }
     resolve(scope, Target, { args, lazy } = {}) {
-        return (0, proxy_1.toLazyIf)(() => {
+        return this.proxyRegistry.toLazyIf(() => {
             const instance = this.createInstance(scope, Target, { args });
             scope.addInstance(instance);
             return instance;

package/cjm/utils/ProxyRegistry.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProxyRegistry = void 0;
+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;
+    }
+}
+exports.ProxyRegistry = ProxyRegistry;

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/index.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/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": "59.0.0",
   "description": "Fast, lightweight TypeScript dependency injection container with a clean API, scoped lifecycles, decorators, tokens, hooks, lazy injection, customizable providers, and no global container objects.",
   "publishConfig": {
     "access": "public",

package/typings/hooks/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/index.d.ts

@@ -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/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();
-}

package/esm/utils/proxy.js

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

package/typings/utils/proxy.d.ts

@@ -1,6 +0,0 @@
-export declare const unwrapProxyTarget: <T extends object>(value: T) => T;
-export declare function isProxy(value: object): boolean;
-export declare function getProxyTarget<T extends object>(value: T): T;
-export declare function createProxy<T extends object>(target: T, handler?: ProxyHandler<T>): T;
-export declare function lazyProxy<T extends object>(resolveInstance: () => T): T;
-export declare function toLazyIf<T extends object>(resolveInstance: () => T, isLazy?: boolean): T;