ts-ioc-container 57.4.0 → 59.0.0

package/cjm/container/Container.js

@@ -8,7 +8,6 @@ const AliasMap_1 = require("./AliasMap");
 const DependencyNotFoundError_1 = require("../errors/DependencyNotFoundError");
 const basic_1 = require("../utils/basic");
 const array_1 = require("../utils/array");
-const proxy_1 = require("../utils/proxy");
 class Container {
     isDisposed = false;
     parent;
@@ -147,7 +146,7 @@ class Container {
         return [...this.scopes];
     }
     hasInstance(instance) {
-        return this.instances.has((0, proxy_1.unwrapProxyTarget)(instance));
+        return this.instances.has(instance);
     }
     getScopeByInstanceOrFail(instance) {
         this.validateContainer();

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/hooks/hook.js

@@ -4,7 +4,6 @@ exports.hook = exports.toHookFn = exports.prepend = exports.append = exports.pre
 exports.getHooks = getHooks;
 exports.hasHooks = hasHooks;
 const basic_1 = require("../utils/basic");
-const proxy_1 = require("../utils/proxy");
 const appendHooks = (...fns) => (...prev) => [...prev, ...fns];
 exports.appendHooks = appendHooks;
 const prependHooks = (...fns) => (...prev) => [...fns, ...prev];
@@ -16,9 +15,6 @@ const isHookClassConstructor = (execute) => {
 };
 const toHookFn = (execute) => isHookClassConstructor(execute) ? (context) => context.scope.resolve(execute).execute(context) : execute;
 exports.toHookFn = toHookFn;
-const getReflectionTarget = (target) => {
-    return (0, proxy_1.isProxy)(target) ? (0, proxy_1.getProxyTarget)(target) : target;
-};
 const getConstructorChain = (ctor) => {
     const chain = [];
     let current = ctor;
@@ -29,9 +25,8 @@ const getConstructorChain = (ctor) => {
     return chain;
 };
 function getHooks(target, key) {
-    const reflectionTarget = getReflectionTarget(target);
     const merged = new Map();
-    for (const ctor of getConstructorChain(reflectionTarget.constructor).reverse()) {
+    for (const ctor of getConstructorChain(target.constructor).reverse()) {
         const ownHooks = Reflect.getOwnMetadata(key, ctor);
         if (ownHooks) {
             for (const [methodName, fns] of ownHooks) {
@@ -42,8 +37,7 @@ function getHooks(target, key) {
     return merged;
 }
 function hasHooks(target, key) {
-    const reflectionTarget = getReflectionTarget(target);
-    return getConstructorChain(reflectionTarget.constructor).some((ctor) => Reflect.hasOwnMetadata(key, ctor));
+    return getConstructorChain(target.constructor).some((ctor) => Reflect.hasOwnMetadata(key, ctor));
 }
 const hook = (key, mapFn) => (target, propertyKey) => {
     const hooks = Reflect.hasOwnMetadata(key, target.constructor)

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.isProxy = exports.getProxyTarget = 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,10 +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, "getProxyTarget", { enumerable: true, get: function () { return proxy_1.getProxyTarget; } });
-Object.defineProperty(exports, "isProxy", { enumerable: true, get: function () { return proxy_1.isProxy; } });
+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/container/Container.js

@@ -5,7 +5,6 @@ import { AliasMap } from './AliasMap.js';
 import { DependencyNotFoundError } from '../errors/DependencyNotFoundError.js';
 import { Is } from '../utils/basic.js';
 import { Filter as F } from '../utils/array.js';
-import { unwrapProxyTarget } from '../utils/proxy.js';
 export class Container {
     isDisposed = false;
     parent;
@@ -144,7 +143,7 @@ export class Container {
         return [...this.scopes];
     }
     hasInstance(instance) {
-        return this.instances.has(unwrapProxyTarget(instance));
+        return this.instances.has(instance);
     }
     getScopeByInstanceOrFail(instance) {
         this.validateContainer();

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

@@ -1,5 +1,4 @@
 import { Is } from '../utils/basic.js';
-import { getProxyTarget, isProxy } from '../utils/proxy.js';
 export const appendHooks = (...fns) => (...prev) => [...prev, ...fns];
 export const prependHooks = (...fns) => (...prev) => [...fns, ...prev];
 export const append = appendHooks;
@@ -8,9 +7,6 @@ const isHookClassConstructor = (execute) => {
     return Is.constructor(execute) && execute.prototype.execute;
 };
 export const toHookFn = (execute) => isHookClassConstructor(execute) ? (context) => context.scope.resolve(execute).execute(context) : execute;
-const getReflectionTarget = (target) => {
-    return isProxy(target) ? getProxyTarget(target) : target;
-};
 const getConstructorChain = (ctor) => {
     const chain = [];
     let current = ctor;
@@ -21,9 +17,8 @@ const getConstructorChain = (ctor) => {
     return chain;
 };
 export function getHooks(target, key) {
-    const reflectionTarget = getReflectionTarget(target);
     const merged = new Map();
-    for (const ctor of getConstructorChain(reflectionTarget.constructor).reverse()) {
+    for (const ctor of getConstructorChain(target.constructor).reverse()) {
         const ownHooks = Reflect.getOwnMetadata(key, ctor);
         if (ownHooks) {
             for (const [methodName, fns] of ownHooks) {
@@ -34,8 +29,7 @@ export function getHooks(target, key) {
     return merged;
 }
 export function hasHooks(target, key) {
-    const reflectionTarget = getReflectionTarget(target);
-    return getConstructorChain(reflectionTarget.constructor).some((ctor) => Reflect.hasOwnMetadata(key, ctor));
+    return getConstructorChain(target.constructor).some((ctor) => Reflect.hasOwnMetadata(key, ctor));
 }
 export const hook = (key, mapFn) => (target, propertyKey) => {
     const hooks = Reflect.hasOwnMetadata(key, target.constructor)

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, getProxyTarget, isProxy } 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": "57.4.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/container/Container.d.ts

@@ -38,12 +38,12 @@ export declare class Container implements IContainer {
     addOnScopeCreatedHook(...hooks: OnScopeCreatedHook[]): this;
     addInstance(instance: Instance): void;
     getScopes(): IContainer[];
-    hasInstance(instance: object): boolean;
-    getScopeByInstanceOrFail(instance: object): IContainer;
+    hasInstance(instance: Instance): boolean;
+    getScopeByInstanceOrFail(instance: Instance): IContainer;
     removeScope(child: IContainer): void;
     useModule(module: IContainerModule): this;
     getParent(): IContainer;
-    getInstances(cascade?: boolean): Instance<unknown>[];
+    getInstances(cascade?: boolean): Instance[];
     hasTag(tag: Tag): boolean;
     addTags(...tags: Tag[]): void;
     private validateContainer;

package/typings/container/EmptyContainer.d.ts

@@ -9,9 +9,9 @@ export declare class EmptyContainer implements IContainer {
     addInstance(instance: Instance): void;
     getParent(): undefined;
     getScopes(): never[];
-    getScopeByInstanceOrFail(instance: object): IContainer;
+    getScopeByInstanceOrFail(instance: Instance): IContainer;
     getInstances(): never[];
-    hasInstance(instance: object): boolean;
+    hasInstance(instance: Instance): boolean;
     createScope(): IContainer;
     autoResolve(options?: AutoResolveOptions): this;
     dispose(): void;

package/typings/container/IContainer.d.ts

@@ -49,12 +49,12 @@ export interface IContainer extends Tagged {
     createScope(options?: CreateScopeOptions): IContainer;
     autoResolve(options?: AutoResolveOptions): this;
     getScopes(): IContainer[];
-    getScopeByInstanceOrFail(instance: object): IContainer;
+    getScopeByInstanceOrFail(instance: Instance): IContainer;
     removeScope(child: IContainer): void;
     useModule(module: IContainerModule): this;
     getParent(): IContainer | undefined;
     getInstances(cascade?: boolean): Instance[];
-    hasInstance(instance: object): boolean;
+    hasInstance(instance: Instance): boolean;
     dispose(): void;
     addInstance(instance: Instance): void;
 }

package/typings/hooks/HookContext.d.ts

@@ -1,7 +1,8 @@
 import type { IContainer } from '../container/IContainer.js';
 import { InjectionToken } from '../token/InjectionToken.js';
+import { type Instance } from '../utils/basic.js';
 export interface IHookContext {
-    instance: object;
+    instance: Instance;
     scope: IContainer;
     methodName?: string;
     resolveArgs(...args: unknown[]): unknown[];
@@ -14,11 +15,11 @@ export interface IHookContext {
     getInitialArgs(): unknown[];
 }
 export declare class HookContext implements IHookContext {
-    scope: IContainer;
-    methodName?: string | undefined;
-    readonly instance: object;
+    readonly instance: Instance;
+    readonly scope: IContainer;
+    readonly methodName?: string | undefined;
     private initialArgs;
-    constructor(instance: object, scope: IContainer, methodName?: string | undefined);
+    constructor(instance: Instance, scope: IContainer, methodName?: string | undefined);
     resolveArgs(...args: unknown[]): unknown[];
     invokeMethod({ args }?: {
         args?: unknown[];
@@ -28,7 +29,7 @@ export declare class HookContext implements IHookContext {
     setInitialArgs(...args: unknown[]): this;
     getInitialArgs(): unknown[];
 }
-export type CreateHookContext = (Target: object, scope: IContainer, methodName?: string) => IHookContext;
+export type CreateHookContext = (Target: Instance, scope: IContainer, methodName?: string) => IHookContext;
 export declare const createHookContext: CreateHookContext;
 export declare const createHookContextFactory: ({ args }?: {
     args?: unknown[];

package/typings/hooks/HooksRunner.d.ts

@@ -1,5 +1,6 @@
 import { type CreateHookContext, type IHookContext } from './HookContext.js';
 import type { IContainer } from '../container/IContainer.js';
+import { type Instance } from '../utils/basic.js';
 export type MapHookContext = (context: IHookContext) => IHookContext;
 export type HooksRunnerContext = {
     scope: IContainer;
@@ -10,7 +11,7 @@ export type HooksRunnerContext = {
 export declare class HooksRunner {
     private readonly key;
     constructor(key: string | symbol);
-    hasHooks(target: object): boolean;
-    execute(target: object, { scope, createContext, mapContext, predicate, }: HooksRunnerContext): void;
-    executeAsync(target: object, { scope, createContext, mapContext, predicate, }: HooksRunnerContext): Promise<void[]>;
+    hasHooks(target: Instance): boolean;
+    execute(target: Instance, { scope, createContext, mapContext, predicate, }: HooksRunnerContext): void;
+    executeAsync(target: Instance, { scope, createContext, mapContext, predicate, }: HooksRunnerContext): Promise<void[]>;
 }

package/typings/hooks/hook.d.ts

@@ -1,6 +1,6 @@
 import { type IHookContext } from './HookContext.js';
 import type { IContainer } from '../container/IContainer.js';
-import { type constructor } from '../utils/basic.js';
+import { type constructor, type Instance } from '../utils/basic.js';
 import { ProviderOptions } from '../provider/IProvider.js';
 export type InjectFn<T = unknown> = (s: IContainer, options: ProviderOptions) => T;
 export type HookFn<T extends IHookContext = IHookContext> = (context: T) => void | Promise<void>;
@@ -15,6 +15,6 @@ export declare const prependHooks: (...fns: HookType[]) => MapHooksFn;
 export declare const append: (...fns: HookType[]) => MapHooksFn;
 export declare const prepend: (...fns: HookType[]) => MapHooksFn;
 export declare const toHookFn: <C extends IHookContext>(execute: HookFn<C> | constructor<HookClass<C>>) => HookFn<C>;
-export declare function getHooks(target: object, key: string | symbol): HooksOfClass;
-export declare function hasHooks(target: object, key: string | symbol): boolean;
+export declare function getHooks(target: Instance, key: string | symbol): HooksOfClass;
+export declare function hasHooks(target: Instance, key: string | symbol): boolean;
 export declare const hook: (key: string | symbol, mapFn: MapHooksFn) => (target: object, propertyKey: string | symbol) => void;

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, getProxyTarget, isProxy } from './utils/proxy.js';
-export { type constructor, type Instance, Is, resolveConstructor } from './utils/basic.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/typings/utils/basic.d.ts

@@ -1,7 +1,8 @@
 export type constructor<T> = new (...args: any[]) => T;
-export interface Instance<T = unknown> {
-    new (...args: unknown[]): T;
-}
+export type Branded<TBrand extends string, T> = T & {
+    readonly __brand?: TBrand;
+};
+export type Instance = Branded<'Instance', object>;
 export declare const Is: {
     nullish: <T>(value: T | undefined | null) => value is null | undefined;
     object: (target: unknown) => target is object;

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;