ts-ioc-container 46.9.0 → 46.9.1

package/cjm/hooks/HookContext.js

@@ -2,15 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createHookContext = exports.HookContext = void 0;
 const inject_1 = require("../injector/inject");
+const proxy_1 = require("../utils/proxy");
 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, inject_1.resolveArgs)(this.instance.constructor, this.methodName)(this.scope, ...[...this.initialArgs, ...args]);

package/cjm/hooks/hook.js

@@ -4,17 +4,25 @@ exports.hook = exports.toHookFn = void 0;
 exports.getHooks = getHooks;
 exports.hasHooks = hasHooks;
 const basic_1 = require("../utils/basic");
+const proxy_1 = require("../utils/proxy");
 const isHookClassConstructor = (execute) => {
     return basic_1.Is.constructor(execute) && execute.prototype.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;
+};
 // Get hooks metadata
 function getHooks(target, key) {
-    return Reflect.hasMetadata(key, target.constructor) ? Reflect.getMetadata(key, target.constructor) : new Map();
+    const reflectionTarget = getReflectionTarget(target);
+    return Reflect.hasMetadata(key, reflectionTarget.constructor)
+        ? Reflect.getMetadata(key, reflectionTarget.constructor)
+        : new Map();
 }
 function hasHooks(target, key) {
-    return Reflect.hasMetadata(key, target.constructor);
+    const reflectionTarget = getReflectionTarget(target);
+    return Reflect.hasMetadata(key, reflectionTarget.constructor);
 }
 // Hook decorator
 const hook = (key, ...fns) => (target, propertyKey) => {

package/cjm/injector/IInjector.js

@@ -4,6 +4,7 @@ exports.Injector = void 0;
 const proxy_1 = require("../utils/proxy");
 class Injector {
     resolve(scope, Target, { args, lazy } = {}) {
+        // @ts-ignore
         return (0, proxy_1.toLazyIf)(() => {
             const instance = this.createInstance(scope, Target, { args });
             scope.addInstance(instance);

package/cjm/utils/proxy.js

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

package/esm/hooks/HookContext.js

@@ -1,13 +1,14 @@
 import { resolveArgs } from '../injector/inject';
+import { getProxyTarget, isProxy } from '../utils/proxy';
 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, ...[...this.initialArgs, ...args]);

package/esm/hooks/hook.js

@@ -1,14 +1,22 @@
 import { Is } from '../utils/basic';
+import { getProxyTarget, isProxy } from '../utils/proxy';
 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;
+};
 // Get hooks metadata
 export function getHooks(target, key) {
-    return Reflect.hasMetadata(key, target.constructor) ? Reflect.getMetadata(key, target.constructor) : new Map();
+    const reflectionTarget = getReflectionTarget(target);
+    return Reflect.hasMetadata(key, reflectionTarget.constructor)
+        ? Reflect.getMetadata(key, reflectionTarget.constructor)
+        : new Map();
 }
 export function hasHooks(target, key) {
-    return Reflect.hasMetadata(key, target.constructor);
+    const reflectionTarget = getReflectionTarget(target);
+    return Reflect.hasMetadata(key, reflectionTarget.constructor);
 }
 // Hook decorator
 export const hook = (key, ...fns) => (target, propertyKey) => {

package/esm/injector/IInjector.js

@@ -1,6 +1,7 @@
 import { toLazyIf } from '../utils/proxy';
 export class Injector {
     resolve(scope, Target, { args, lazy } = {}) {
+        // @ts-ignore
         return toLazyIf(() => {
             const instance = this.createInstance(scope, Target, { args });
             scope.addInstance(instance);

package/esm/utils/proxy.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-ioc-container",
-  "version": "46.9.0",
+  "version": "46.9.1",
   "description": "Typescript IoC container",
   "workspaces": [
     "docs"

package/typings/hooks/HookContext.d.ts

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

package/typings/utils/proxy.d.ts

@@ -1,2 +1,4 @@
-export declare function lazyProxy<T>(resolveInstance: () => T): T;
-export declare function toLazyIf<T>(resolveInstance: () => T, isLazy?: boolean): T;
+export declare function isProxy(value: object): boolean;
+export declare function getProxyTarget<T extends object>(value: T): T;
+export declare function lazyProxy<T extends object>(resolveInstance: () => T): T;
+export declare function toLazyIf<T extends object>(resolveInstance: () => T, isLazy?: boolean): T;