ts-ioc-container 46.8.1 → 46.9.1

package/cjm/container/Container.js

@@ -63,7 +63,7 @@ class Container {
     }
     resolveOneByAlias(alias, { args, child = this, lazy } = {}) {
         this.validateContainer();
-        const key = this.aliases.getKeysByAlias(alias)[0];
+        const [key, ..._] = this.aliases.getKeysByAlias(alias);
         const provider = key ? this.findProviderByKeyOrFail(key) : undefined;
         return provider?.hasAccess({ invocationScope: child, providerScope: this })
             ? provider.resolve(this, { args, lazy })

package/cjm/hooks/HookContext.js

@@ -2,19 +2,21 @@
 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, ...args);
+        return (0, inject_1.resolveArgs)(this.instance.constructor, this.methodName)(this.scope, ...[...this.initialArgs, ...args]);
     }
-    invokeMethod({ args = this.resolveArgs() }) {
+    invokeMethod({ args = this.resolveArgs() } = {}) {
         // @ts-ignore
         return this.instance[this.methodName](...args);
     }
@@ -22,6 +24,10 @@ class HookContext {
         // @ts-ignore
         this.instance[this.methodName] = fn.resolve(this.scope);
     }
+    setInitialArgs(...args) {
+        this.initialArgs = args;
+        return this;
+    }
 }
 exports.HookContext = HookContext;
 const createHookContext = (Target, scope, methodName = 'constructor') => new HookContext(Target, scope, methodName);

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/container/Container.js

@@ -60,7 +60,7 @@ export class Container {
     }
     resolveOneByAlias(alias, { args, child = this, lazy } = {}) {
         this.validateContainer();
-        const key = this.aliases.getKeysByAlias(alias)[0];
+        const [key, ..._] = this.aliases.getKeysByAlias(alias);
         const provider = key ? this.findProviderByKeyOrFail(key) : undefined;
         return provider?.hasAccess({ invocationScope: child, providerScope: this })
             ? provider.resolve(this, { args, lazy })

package/esm/hooks/HookContext.js

@@ -1,17 +1,19 @@
 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, ...args);
+        return resolveArgs(this.instance.constructor, this.methodName)(this.scope, ...[...this.initialArgs, ...args]);
     }
-    invokeMethod({ args = this.resolveArgs() }) {
+    invokeMethod({ args = this.resolveArgs() } = {}) {
         // @ts-ignore
         return this.instance[this.methodName](...args);
     }
@@ -19,5 +21,9 @@ export class HookContext {
         // @ts-ignore
         this.instance[this.methodName] = fn.resolve(this.scope);
     }
+    setInitialArgs(...args) {
+        this.initialArgs = args;
+        return this;
+    }
 }
 export const createHookContext = (Target, scope, methodName = 'constructor') => new HookContext(Target, scope, methodName);

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,7 +1,10 @@
 {
   "name": "ts-ioc-container",
-  "version": "46.8.1",
+  "version": "46.9.1",
   "description": "Typescript IoC container",
+  "workspaces": [
+    "docs"
+  ],
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org/"
@@ -35,39 +38,74 @@
   ],
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/IgorBabkin/ts-ioc-container",
-    "directory": "packages/ts-ioc-container"
+    "url": "git+https://github.com/IgorBabkin/ts-ioc-container"
   },
   "scripts": {
     "build:cjm": "rimraf cjm && tsc -p tsconfig.production.json --outDir cjm --module CommonJS",
     "build:esm": "rimraf esm && tsc -p tsconfig.production.json --outDir esm",
     "build:types": "rimraf typings && tsc -p tsconfig.production.json --outDir typings --emitDeclarationOnly --declaration",
-    "build": "pnpm run build:cjm && pnpm run build:esm && pnpm run build:types",
-    "test": "jest --maxWorkers=2",
-    "test:coverage": "jest --maxWorkers=2 --coverage --coverageReporters=lcov --coverageReporters=text-summary",
+    "generate:docs": "scripts/generate-readme/generate-readme.ts && git add README.md",
+    "build": "npm run build:cjm && npm run build:esm && npm run build:types",
+    "test": "jest",
+    "test:coverage": "jest --coverage --coverageReporters=lcov --coverageReporters=text-summary",
     "type-check": "tsc --noEmit",
     "type-check:watch": "tsc --noEmit --watch",
-    "lint": "eslint lib/**/*.ts __tests__/**/*.ts scripts/**/*.ts",
-    "lint:fix": "pnpm run lint -- --fix",
+    "commit": "cz",
     "format": "prettier --write \"**/*.ts\"",
-    "generate:docs": "scripts/generate-readme/generate-readme.ts",
-    "release": "pnpm run build && pnpm run test && pnpm publish"
+    "lint": "eslint lib/**/*.ts  __tests__/**/*.ts scripts/**/*.ts",
+    "lint:fix": "npm run lint --fix",
+    "audit": "npm audit",
+    "prepare": "husky",
+    "release": "npm run build && npm test && npm publish",
+    "docs:dev": "pnpm --filter ts-ioc-container-docs run dev",
+    "docs:serve": "pnpm --filter ts-ioc-container-docs run dev",
+    "docs:build": "pnpm --filter ts-ioc-container-docs run build",
+    "docs:preview": "pnpm --filter ts-ioc-container-docs run preview"
   },
   "devDependencies": {
+    "@commitlint/cli": "^20.2.0",
+    "@commitlint/config-conventional": "^20.2.0",
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/git": "^10.0.1",
+    "@semantic-release/github": "^12.0.2",
+    "@semantic-release/npm": "^13.1.2",
     "@types/jest": "29.5.14",
-    "@types/node": "^25.1.0",
     "@typescript-eslint/eslint-plugin": "8.29.1",
     "@typescript-eslint/parser": "8.29.1",
+    "cz-conventional-changelog": "^3.3.0",
     "eslint": "9.24.0",
     "eslint-config-prettier": "10.1.1",
     "eslint-plugin-prettier": "5.2.6",
     "handlebars": "^4.7.8",
+    "husky": "^9.1.7",
     "jest": "29.7.0",
+    "lint-staged": "^15.5.0",
     "moq.ts": "^7.4.1",
     "prettier": "3.5.3",
+    "prettier-plugin-astro": "^0.14.1",
     "reflect-metadata": "^0.2.2",
     "rimraf": "6.0.1",
+    "semantic-release": "^25.0.2",
     "ts-jest": "29.3.1",
     "typescript": "5.8.3"
-  }
+  },
+  "lint-staged": {
+    "*.{js,ts,tsx}": [
+      "eslint --fix",
+      "prettier --write"
+    ],
+    "docs/**/*.{js,ts,tsx,mjs,astro}": [
+      "prettier --write"
+    ],
+    "docs/**/*.astro": [
+      "eslint --fix"
+    ]
+  },
+  "gitHead": "ae10f302c7e0f55196b42669040735112479a854",
+  "config": {
+    "commitizen": {
+      "path": "./node_modules/cz-conventional-changelog"
+    }
+  },
+  "packageManager": "pnpm@10.20.0+sha512.cf9998222162dd85864d0a8102e7892e7ba4ceadebbf5a31f9c2fce48dfce317a9c53b9f6464d1ef9042cba2e02ae02a9f7c143a2b438cd93c91840f0192b9dd"
 }

package/typings/hooks/HookContext.d.ts

@@ -5,21 +5,24 @@ export interface IHookContext {
     scope: IContainer;
     methodName?: string;
     resolveArgs(...args: unknown[]): unknown[];
-    invokeMethod({ args }: {
+    invokeMethod(options?: {
         args?: unknown[];
     }): unknown;
     setProperty(fn: InjectionToken): void;
+    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[];
-    invokeMethod({ args }: {
+    invokeMethod({ args }?: {
         args?: unknown[];
     }): unknown;
     setProperty(fn: InjectionToken): void;
+    setInitialArgs(...args: unknown[]): this;
 }
 export type CreateHookContext = (Target: object, scope: IContainer, methodName?: string) => IHookContext;
 export declare const createHookContext: CreateHookContext;

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;