ts-ioc-container 47.0.0 → 47.0.1

package/README.md

@@ -2626,7 +2626,7 @@ Sometimes you need to invoke methods after construct or dispose of class. This i
 import {
   AddOnConstructHookModule,
   Container,
-  HookContext,
+  IHookContext,
   HookFn,
   inject,
   onConstruct,
@@ -2646,7 +2646,7 @@ import {
  * Note: You must register the AddOnConstructHookModule or manually add the hook runner.
  */
 
-const execute: HookFn = (ctx: HookContext) => {
+const execute: HookFn = (ctx: IHookContext) => {
   ctx.invokeMethod({ args: ctx.resolveArgs() });
 };
 

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

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FunctionToken = exports.SingleToken = exports.ClassToken = exports.toSingleAlias = exports.SingleAliasToken = exports.toGroupAlias = exports.GroupAliasToken = exports.InjectionToken = exports.HooksRunner = exports.AddOnDisposeHookModule = exports.onDispose = exports.onDisposeHooksRunner = exports.AddOnConstructHookModule = exports.onConstruct = exports.onConstructHooksRunner = exports.injectProp = exports.HookContext = exports.hasHooks = exports.hook = exports.getHooks = exports.UnexpectedHookResultError = exports.ContainerDisposedError = exports.MethodNotImplementedError = exports.DependencyMissingKeyError = exports.DependencyNotFoundError = exports.Registration = exports.bindTo = exports.register = exports.scope = exports.decorate = exports.MultiCache = exports.multiCache = exports.SingletonProvider = exports.singleton = exports.Provider = exports.resolveByArgs = exports.ProviderDecorator = exports.args = exports.argsFn = exports.lazy = exports.scopeAccess = exports.ProxyInjector = exports.SimpleInjector = exports.MetadataInjector = exports.Injector = exports.resolveArgs = exports.inject = exports.EmptyContainer = exports.Container = exports.isDependencyKey = void 0;
-exports.setMethodMetadata = exports.getMethodMetadata = exports.setParameterMetadata = exports.getParameterMetadata = exports.setClassMetadata = exports.getClassMetadata = exports.Is = exports.pipe = exports.select = exports.GroupInstanceToken = exports.ConstantToken = void 0;
+exports.resolveConstructor = exports.Is = exports.pipe = exports.select = exports.getMethodTags = exports.methodTag = exports.getMethodLabels = exports.methodLabel = exports.getMethodMeta = exports.methodMeta = exports.getParamTags = exports.paramTag = exports.getParamLabels = exports.paramLabel = exports.getParamMeta = exports.paramMeta = exports.getClassTags = exports.classTag = exports.getClassLabels = exports.classLabel = exports.getClassMeta = exports.classMeta = exports.handleAsyncError = exports.handleError = exports.GroupInstanceToken = exports.ConstantToken = void 0;
 // Containers
 var IContainer_1 = require("./container/IContainer");
 Object.defineProperty(exports, "isDependencyKey", { enumerable: true, get: function () { return IContainer_1.isDependencyKey; } });
@@ -76,8 +76,7 @@ Object.defineProperty(exports, "onDispose", { enumerable: true, get: function ()
 Object.defineProperty(exports, "AddOnDisposeHookModule", { enumerable: true, get: function () { return onDispose_1.AddOnDisposeHookModule; } });
 var HooksRunner_1 = require("./hooks/HooksRunner");
 Object.defineProperty(exports, "HooksRunner", { enumerable: true, get: function () { return HooksRunner_1.HooksRunner; } });
-// Metadata
-// InjectionToken
+// Tokens
 var InjectionToken_1 = require("./token/InjectionToken");
 Object.defineProperty(exports, "InjectionToken", { enumerable: true, get: function () { return InjectionToken_1.InjectionToken; } });
 var GroupAliasToken_1 = require("./token/GroupAliasToken");
@@ -96,22 +95,36 @@ var ConstantToken_1 = require("./token/ConstantToken");
 Object.defineProperty(exports, "ConstantToken", { enumerable: true, get: function () { return ConstantToken_1.ConstantToken; } });
 var GroupInstanceToken_1 = require("./token/GroupInstanceToken");
 Object.defineProperty(exports, "GroupInstanceToken", { enumerable: true, get: function () { return GroupInstanceToken_1.GroupInstanceToken; } });
-// Others
+// Metadata
+var errorHandler_1 = require("./metadata/errorHandler");
+Object.defineProperty(exports, "handleError", { enumerable: true, get: function () { return errorHandler_1.handleError; } });
+Object.defineProperty(exports, "handleAsyncError", { enumerable: true, get: function () { return errorHandler_1.handleAsyncError; } });
+var class_1 = require("./metadata/class");
+Object.defineProperty(exports, "classMeta", { enumerable: true, get: function () { return class_1.classMeta; } });
+Object.defineProperty(exports, "getClassMeta", { enumerable: true, get: function () { return class_1.getClassMeta; } });
+Object.defineProperty(exports, "classLabel", { enumerable: true, get: function () { return class_1.classLabel; } });
+Object.defineProperty(exports, "getClassLabels", { enumerable: true, get: function () { return class_1.getClassLabels; } });
+Object.defineProperty(exports, "classTag", { enumerable: true, get: function () { return class_1.classTag; } });
+Object.defineProperty(exports, "getClassTags", { enumerable: true, get: function () { return class_1.getClassTags; } });
+var parameter_1 = require("./metadata/parameter");
+Object.defineProperty(exports, "paramMeta", { enumerable: true, get: function () { return parameter_1.paramMeta; } });
+Object.defineProperty(exports, "getParamMeta", { enumerable: true, get: function () { return parameter_1.getParamMeta; } });
+Object.defineProperty(exports, "paramLabel", { enumerable: true, get: function () { return parameter_1.paramLabel; } });
+Object.defineProperty(exports, "getParamLabels", { enumerable: true, get: function () { return parameter_1.getParamLabels; } });
+Object.defineProperty(exports, "paramTag", { enumerable: true, get: function () { return parameter_1.paramTag; } });
+Object.defineProperty(exports, "getParamTags", { enumerable: true, get: function () { return parameter_1.getParamTags; } });
+var method_1 = require("./metadata/method");
+Object.defineProperty(exports, "methodMeta", { enumerable: true, get: function () { return method_1.methodMeta; } });
+Object.defineProperty(exports, "getMethodMeta", { enumerable: true, get: function () { return method_1.getMethodMeta; } });
+Object.defineProperty(exports, "methodLabel", { enumerable: true, get: function () { return method_1.methodLabel; } });
+Object.defineProperty(exports, "getMethodLabels", { enumerable: true, get: function () { return method_1.getMethodLabels; } });
+Object.defineProperty(exports, "methodTag", { enumerable: true, get: function () { return method_1.methodTag; } });
+Object.defineProperty(exports, "getMethodTags", { enumerable: true, get: function () { return method_1.getMethodTags; } });
+// Utils
 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 basic_1 = require("./utils/basic");
 Object.defineProperty(exports, "Is", { enumerable: true, get: function () { return basic_1.Is; } });
-var class_1 = require("./metadata/class");
-Object.defineProperty(exports, "getClassMetadata", { enumerable: true, get: function () { return class_1.getClassMetadata; } });
-var class_2 = require("./metadata/class");
-Object.defineProperty(exports, "setClassMetadata", { enumerable: true, get: function () { return class_2.setClassMetadata; } });
-var parameter_1 = require("./metadata/parameter");
-Object.defineProperty(exports, "getParameterMetadata", { enumerable: true, get: function () { return parameter_1.getParameterMetadata; } });
-var parameter_2 = require("./metadata/parameter");
-Object.defineProperty(exports, "setParameterMetadata", { enumerable: true, get: function () { return parameter_2.setParameterMetadata; } });
-var method_1 = require("./metadata/method");
-Object.defineProperty(exports, "getMethodMetadata", { enumerable: true, get: function () { return method_1.getMethodMetadata; } });
-var method_2 = require("./metadata/method");
-Object.defineProperty(exports, "setMethodMetadata", { enumerable: true, get: function () { return method_2.setMethodMetadata; } });
+Object.defineProperty(exports, "resolveConstructor", { enumerable: true, get: function () { return basic_1.resolveConstructor; } });

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/injector/inject.js

@@ -8,11 +8,11 @@ const basic_1 = require("../utils/basic");
 const parameter_1 = require("../metadata/parameter");
 const hookMetaKey = (methodName = 'constructor') => `inject:${methodName}`;
 const inject = (fn) => (target, propertyKey, parameterIndex) => {
-    (0, parameter_1.setParameterMetadata)(hookMetaKey(propertyKey), () => (0, toToken_1.toToken)(fn))(basic_1.Is.instance(target) ? target.constructor : target, propertyKey, parameterIndex);
+    (0, parameter_1.paramMeta)(hookMetaKey(propertyKey), () => (0, toToken_1.toToken)(fn))(basic_1.Is.instance(target) ? target.constructor : target, propertyKey, parameterIndex);
 };
 exports.inject = inject;
 const resolveArgs = (Target, methodName) => {
-    const argsTokens = (0, parameter_1.getParameterMetadata)(hookMetaKey(methodName), Target);
+    const argsTokens = (0, parameter_1.getParamMeta)(hookMetaKey(methodName), Target);
     return (scope, ...deps) => {
         const depsTokens = deps.map((v) => new ConstantToken_1.ConstantToken(v));
         const allTokens = (0, array_1.fillEmptyIndexes)(argsTokens, depsTokens);

package/cjm/metadata/class.js

@@ -1,12 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.setClassMetadata = void 0;
-exports.getClassMetadata = getClassMetadata;
-const setClassMetadata = (key, mapFn) => (target) => {
+exports.getClassTags = exports.classTag = exports.getClassLabels = exports.classLabel = exports.classMeta = void 0;
+exports.getClassMeta = getClassMeta;
+const basic_1 = require("../utils/basic");
+const classMeta = (key, mapFn) => (target) => {
     const value = Reflect.getOwnMetadata(key, target);
     Reflect.defineMetadata(key, mapFn(value), target);
 };
-exports.setClassMetadata = setClassMetadata;
-function getClassMetadata(target, key) {
-    return Reflect.getOwnMetadata(key, target);
+exports.classMeta = classMeta;
+function getClassMeta(target, key) {
+    return Reflect.getOwnMetadata(key, (0, basic_1.resolveConstructor)(target));
 }
+const classLabel = (key, label) => (0, exports.classMeta)('label', (prev = new Map()) => prev.set(key, label));
+exports.classLabel = classLabel;
+const getClassLabels = (target) => getClassMeta(target, 'label') ?? new Map();
+exports.getClassLabels = getClassLabels;
+const classTag = (tag) => (0, exports.classMeta)('tag', (prev = new Set()) => prev.add(tag));
+exports.classTag = classTag;
+const getClassTags = (target) => getClassMeta(target, 'tag') ?? new Set();
+exports.getClassTags = getClassTags;

package/cjm/metadata/errorHandler.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleError = exports.handleAsyncError = void 0;
+const handleAsyncError = (errorHandler) => (target, propertyKey, descriptor) => {
+    const originalMethod = descriptor.value;
+    descriptor.value = async function (...args) {
+        try {
+            return await originalMethod.apply(this, args);
+        }
+        catch (e) {
+            errorHandler(e, { target: target.constructor.name, method: propertyKey });
+        }
+    };
+    return descriptor;
+};
+exports.handleAsyncError = handleAsyncError;
+const handleError = (errorHandler) => (target, propertyKey, descriptor) => {
+    const originalMethod = descriptor.value;
+    descriptor.value = function (...args) {
+        try {
+            return originalMethod.apply(this, args);
+        }
+        catch (e) {
+            errorHandler(e, { target: target.constructor.name, method: propertyKey });
+        }
+    };
+    return descriptor;
+};
+exports.handleError = handleError;

package/cjm/metadata/method.js

@@ -1,10 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getMethodMetadata = exports.setMethodMetadata = void 0;
-const setMethodMetadata = (key, mapFn) => (target, propertyKey) => {
+exports.getMethodTags = exports.methodTag = exports.getMethodLabels = exports.methodLabel = exports.getMethodMeta = exports.methodMeta = void 0;
+const basic_1 = require("../utils/basic");
+const methodMeta = (key, mapFn) => (target, propertyKey) => {
     const metadata = Reflect.getMetadata(key, target.constructor, propertyKey);
     Reflect.defineMetadata(key, mapFn(metadata), target.constructor, propertyKey);
 };
-exports.setMethodMetadata = setMethodMetadata;
-const getMethodMetadata = (key, target, propertyKey) => Reflect.getMetadata(key, target.constructor, propertyKey);
-exports.getMethodMetadata = getMethodMetadata;
+exports.methodMeta = methodMeta;
+const getMethodMeta = (key, target, propertyKey) => Reflect.getMetadata(key, (0, basic_1.resolveConstructor)(target), propertyKey);
+exports.getMethodMeta = getMethodMeta;
+const methodLabel = (key, label) => (0, exports.methodMeta)('label', (prev = new Map()) => prev.set(key, label));
+exports.methodLabel = methodLabel;
+const getMethodLabels = (target, propertyKey) => (0, exports.getMethodMeta)('label', target, propertyKey) ?? new Map();
+exports.getMethodLabels = getMethodLabels;
+const methodTag = (tag) => (0, exports.methodMeta)('tag', (prev = new Set()) => prev.add(tag));
+exports.methodTag = methodTag;
+const getMethodTags = (target, propertyKey) => (0, exports.getMethodMeta)('tag', target, propertyKey) ?? new Set();
+exports.getMethodTags = getMethodTags;

package/cjm/metadata/parameter.js

@@ -1,13 +1,34 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getParameterMetadata = exports.setParameterMetadata = void 0;
-const setParameterMetadata = (key, mapFn) => (target, _, parameterIndex) => {
+exports.getParamTags = exports.paramTag = exports.getParamLabels = exports.paramLabel = exports.getParamMeta = exports.paramMeta = void 0;
+const basic_1 = require("../utils/basic");
+const paramMeta = (key, mapFn) => (target, _, parameterIndex) => {
     const metadata = Reflect.getOwnMetadata(key, target) ?? [];
     metadata[parameterIndex] = mapFn(metadata[parameterIndex]);
     Reflect.defineMetadata(key, metadata, target);
 };
-exports.setParameterMetadata = setParameterMetadata;
-const getParameterMetadata = (key, target) => {
-    return Reflect.getOwnMetadata(key, target) ?? [];
+exports.paramMeta = paramMeta;
+const getParamMeta = (key, target) => {
+    return Reflect.getOwnMetadata(key, (0, basic_1.resolveConstructor)(target)) ?? [];
 };
-exports.getParameterMetadata = getParameterMetadata;
+exports.getParamMeta = getParamMeta;
+const paramLabel = (key, label) => (0, exports.paramMeta)('label', (prev) => {
+    const map = prev ?? new Map();
+    return map.set(key, label);
+});
+exports.paramLabel = paramLabel;
+const getParamLabels = (target, parameterIndex) => {
+    const all = (0, exports.getParamMeta)('label', target);
+    return all[parameterIndex] ?? new Map();
+};
+exports.getParamLabels = getParamLabels;
+const paramTag = (tag) => (0, exports.paramMeta)('tag', (prev) => {
+    const set = prev ?? new Set();
+    return set.add(tag);
+});
+exports.paramTag = paramTag;
+const getParamTags = (target, parameterIndex) => {
+    const all = (0, exports.getParamMeta)('tag', target);
+    return all[parameterIndex] ?? new Set();
+};
+exports.getParamTags = getParamTags;

package/cjm/registration/IRegistration.js

@@ -8,9 +8,9 @@ const class_1 = require("../metadata/class");
 const scope = (...rules) => (r) => r.when(...rules);
 exports.scope = scope;
 const METADATA_KEY = 'registration';
-const getTransformers = (Target) => (0, class_1.getClassMetadata)(Target, METADATA_KEY) ?? [];
+const getTransformers = (Target) => (0, class_1.getClassMeta)(Target, METADATA_KEY) ?? [];
 exports.getTransformers = getTransformers;
-const register = (...mappers) => (0, class_1.setClassMetadata)(METADATA_KEY, (acc) => {
+const register = (...mappers) => (0, class_1.classMeta)(METADATA_KEY, (acc) => {
     const result = mappers.map((m) => (0, ProviderPipe_1.isProviderPipe)(m) ? (r) => m.mapRegistration(r) : m);
     return acc ? [...result, ...acc] : result;
 });

package/cjm/utils/basic.js

@@ -1,9 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Is = void 0;
+exports.resolveConstructor = resolveConstructor;
 exports.Is = {
     nullish: (value) => value === undefined || value === null,
     object: (target) => target !== null && typeof target === 'object',
     instance: (target) => Object.prototype.hasOwnProperty.call(target, 'constructor'),
     constructor: (target) => typeof target === 'function' && !!target.prototype,
 };
+function resolveConstructor(target) {
+    return exports.Is.constructor(target) ? target : target.constructor;
+}

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

@@ -30,8 +30,7 @@ export { injectProp } from './hooks/injectProp';
 export { onConstructHooksRunner, onConstruct, AddOnConstructHookModule } from './hooks/onConstruct';
 export { onDisposeHooksRunner, onDispose, AddOnDisposeHookModule } from './hooks/onDispose';
 export { HooksRunner } from './hooks/HooksRunner';
-// Metadata
-// InjectionToken
+// Tokens
 export { InjectionToken } from './token/InjectionToken';
 export { GroupAliasToken, toGroupAlias } from './token/GroupAliasToken';
 export { SingleAliasToken, toSingleAlias } from './token/SingleAliasToken';
@@ -40,13 +39,12 @@ export { SingleToken } from './token/SingleToken';
 export { FunctionToken } from './token/FunctionToken';
 export { ConstantToken } from './token/ConstantToken';
 export { GroupInstanceToken } from './token/GroupInstanceToken';
-// Others
+// Metadata
+export { handleError, handleAsyncError } from './metadata/errorHandler';
+export { classMeta, getClassMeta, classLabel, getClassLabels, classTag, getClassTags } from './metadata/class';
+export { paramMeta, getParamMeta, paramLabel, getParamLabels, paramTag, getParamTags } from './metadata/parameter';
+export { methodMeta, getMethodMeta, methodLabel, getMethodLabels, methodTag, getMethodTags } from './metadata/method';
+// Utils
 export { select } from './select';
 export { pipe } from './utils/fp';
-export { Is } from './utils/basic';
-export { getClassMetadata } from './metadata/class';
-export { setClassMetadata } from './metadata/class';
-export { getParameterMetadata } from './metadata/parameter';
-export { setParameterMetadata } from './metadata/parameter';
-export { getMethodMetadata } from './metadata/method';
-export { setMethodMetadata } from './metadata/method';
+export { Is, resolveConstructor } from './utils/basic';

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/injector/inject.js

@@ -2,13 +2,13 @@ import { ConstantToken } from '../token/ConstantToken';
 import { toToken } from '../token/toToken';
 import { fillEmptyIndexes } from '../utils/array';
 import { Is } from '../utils/basic';
-import { getParameterMetadata, setParameterMetadata } from '../metadata/parameter';
+import { getParamMeta, paramMeta } from '../metadata/parameter';
 const hookMetaKey = (methodName = 'constructor') => `inject:${methodName}`;
 export const inject = (fn) => (target, propertyKey, parameterIndex) => {
-    setParameterMetadata(hookMetaKey(propertyKey), () => toToken(fn))(Is.instance(target) ? target.constructor : target, propertyKey, parameterIndex);
+    paramMeta(hookMetaKey(propertyKey), () => toToken(fn))(Is.instance(target) ? target.constructor : target, propertyKey, parameterIndex);
 };
 export const resolveArgs = (Target, methodName) => {
-    const argsTokens = getParameterMetadata(hookMetaKey(methodName), Target);
+    const argsTokens = getParamMeta(hookMetaKey(methodName), Target);
     return (scope, ...deps) => {
         const depsTokens = deps.map((v) => new ConstantToken(v));
         const allTokens = fillEmptyIndexes(argsTokens, depsTokens);

package/esm/metadata/class.js

@@ -1,7 +1,12 @@
-export const setClassMetadata = (key, mapFn) => (target) => {
+import { resolveConstructor } from '../utils/basic';
+export const classMeta = (key, mapFn) => (target) => {
     const value = Reflect.getOwnMetadata(key, target);
     Reflect.defineMetadata(key, mapFn(value), target);
 };
-export function getClassMetadata(target, key) {
-    return Reflect.getOwnMetadata(key, target);
+export function getClassMeta(target, key) {
+    return Reflect.getOwnMetadata(key, resolveConstructor(target));
 }
+export const classLabel = (key, label) => classMeta('label', (prev = new Map()) => prev.set(key, label));
+export const getClassLabels = (target) => getClassMeta(target, 'label') ?? new Map();
+export const classTag = (tag) => classMeta('tag', (prev = new Set()) => prev.add(tag));
+export const getClassTags = (target) => getClassMeta(target, 'tag') ?? new Set();

package/esm/metadata/errorHandler.js

@@ -0,0 +1,24 @@
+export const handleAsyncError = (errorHandler) => (target, propertyKey, descriptor) => {
+    const originalMethod = descriptor.value;
+    descriptor.value = async function (...args) {
+        try {
+            return await originalMethod.apply(this, args);
+        }
+        catch (e) {
+            errorHandler(e, { target: target.constructor.name, method: propertyKey });
+        }
+    };
+    return descriptor;
+};
+export const handleError = (errorHandler) => (target, propertyKey, descriptor) => {
+    const originalMethod = descriptor.value;
+    descriptor.value = function (...args) {
+        try {
+            return originalMethod.apply(this, args);
+        }
+        catch (e) {
+            errorHandler(e, { target: target.constructor.name, method: propertyKey });
+        }
+    };
+    return descriptor;
+};

package/esm/metadata/method.js

@@ -1,5 +1,10 @@
-export const setMethodMetadata = (key, mapFn) => (target, propertyKey) => {
+import { resolveConstructor } from '../utils/basic';
+export const methodMeta = (key, mapFn) => (target, propertyKey) => {
     const metadata = Reflect.getMetadata(key, target.constructor, propertyKey);
     Reflect.defineMetadata(key, mapFn(metadata), target.constructor, propertyKey);
 };
-export const getMethodMetadata = (key, target, propertyKey) => Reflect.getMetadata(key, target.constructor, propertyKey);
+export const getMethodMeta = (key, target, propertyKey) => Reflect.getMetadata(key, resolveConstructor(target), propertyKey);
+export const methodLabel = (key, label) => methodMeta('label', (prev = new Map()) => prev.set(key, label));
+export const getMethodLabels = (target, propertyKey) => getMethodMeta('label', target, propertyKey) ?? new Map();
+export const methodTag = (tag) => methodMeta('tag', (prev = new Set()) => prev.add(tag));
+export const getMethodTags = (target, propertyKey) => getMethodMeta('tag', target, propertyKey) ?? new Set();

package/esm/metadata/parameter.js

@@ -1,8 +1,25 @@
-export const setParameterMetadata = (key, mapFn) => (target, _, parameterIndex) => {
+import { resolveConstructor } from '../utils/basic';
+export const paramMeta = (key, mapFn) => (target, _, parameterIndex) => {
     const metadata = Reflect.getOwnMetadata(key, target) ?? [];
     metadata[parameterIndex] = mapFn(metadata[parameterIndex]);
     Reflect.defineMetadata(key, metadata, target);
 };
-export const getParameterMetadata = (key, target) => {
-    return Reflect.getOwnMetadata(key, target) ?? [];
+export const getParamMeta = (key, target) => {
+    return Reflect.getOwnMetadata(key, resolveConstructor(target)) ?? [];
+};
+export const paramLabel = (key, label) => paramMeta('label', (prev) => {
+    const map = prev ?? new Map();
+    return map.set(key, label);
+});
+export const getParamLabels = (target, parameterIndex) => {
+    const all = getParamMeta('label', target);
+    return all[parameterIndex] ?? new Map();
+};
+export const paramTag = (tag) => paramMeta('tag', (prev) => {
+    const set = prev ?? new Set();
+    return set.add(tag);
+});
+export const getParamTags = (target, parameterIndex) => {
+    const all = getParamMeta('tag', target);
+    return all[parameterIndex] ?? new Set();
 };

package/esm/registration/IRegistration.js

@@ -1,11 +1,11 @@
 import { isProviderPipe } from '../provider/ProviderPipe';
 import { SingleToken } from '../token/SingleToken';
 import { isBindToken } from '../token/BindToken';
-import { getClassMetadata, setClassMetadata } from '../metadata/class';
+import { getClassMeta, classMeta } from '../metadata/class';
 export const scope = (...rules) => (r) => r.when(...rules);
 const METADATA_KEY = 'registration';
-export const getTransformers = (Target) => getClassMetadata(Target, METADATA_KEY) ?? [];
-export const register = (...mappers) => setClassMetadata(METADATA_KEY, (acc) => {
+export const getTransformers = (Target) => getClassMeta(Target, METADATA_KEY) ?? [];
+export const register = (...mappers) => classMeta(METADATA_KEY, (acc) => {
     const result = mappers.map((m) => isProviderPipe(m) ? (r) => m.mapRegistration(r) : m);
     return acc ? [...result, ...acc] : result;
 });

package/esm/utils/basic.js

@@ -4,3 +4,6 @@ export const Is = {
     instance: (target) => Object.prototype.hasOwnProperty.call(target, 'constructor'),
     constructor: (target) => typeof target === 'function' && !!target.prototype,
 };
+export function resolveConstructor(target) {
+    return Is.constructor(target) ? target : target.constructor;
+}

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": "47.0.0",
+  "version": "47.0.1",
   "description": "Typescript IoC container",
+  "workspaces": [
+    "docs"
+  ],
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org/"
@@ -35,40 +38,81 @@
   ],
   "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",
+    "@eslint/eslintrc": "^3.3.5",
+    "@eslint/js": "^9.24.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",
+    "@types/node": "^25.5.2",
     "@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",
+    "tsx": "^4.21.0",
     "typescript": "5.8.3"
   },
-  "gitHead": "a69936f0186667124169b27700f2e6da7b48dc93"
+  "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",
+  "engines": {
+    "node": ">= 22.14.0"
+  }
 }

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

@@ -19,13 +19,12 @@ export { DependencyMissingKeyError } from './errors/DependencyMissingKeyError';
 export { MethodNotImplementedError } from './errors/MethodNotImplementedError';
 export { ContainerDisposedError } from './errors/ContainerDisposedError';
 export { UnexpectedHookResultError } from './errors/UnexpectedHookResultError';
-export { getHooks, hook, hasHooks, type HookFn, type HookClass } from './hooks/hook';
+export { getHooks, hook, hasHooks, type HookFn, type HookClass, type InjectFn } from './hooks/hook';
 export { HookContext, type IHookContext } from './hooks/HookContext';
 export { injectProp } from './hooks/injectProp';
 export { onConstructHooksRunner, onConstruct, AddOnConstructHookModule } from './hooks/onConstruct';
 export { onDisposeHooksRunner, onDispose, AddOnDisposeHookModule } from './hooks/onDispose';
-export type { HooksRunnerContext } from './hooks/HooksRunner';
-export { HooksRunner } from './hooks/HooksRunner';
+export { HooksRunner, type HooksRunnerContext } from './hooks/HooksRunner';
 export { InjectionToken } from './token/InjectionToken';
 export { GroupAliasToken, toGroupAlias } from './token/GroupAliasToken';
 export { SingleAliasToken, toSingleAlias } from './token/SingleAliasToken';
@@ -34,14 +33,10 @@ export { SingleToken } from './token/SingleToken';
 export { FunctionToken } from './token/FunctionToken';
 export { ConstantToken } from './token/ConstantToken';
 export { type InstancePredicate, GroupInstanceToken } from './token/GroupInstanceToken';
+export { handleError, handleAsyncError, type HandleErrorParams } from './metadata/errorHandler';
+export { classMeta, getClassMeta, classLabel, getClassLabels, classTag, getClassTags } from './metadata/class';
+export { paramMeta, getParamMeta, paramLabel, getParamLabels, paramTag, getParamTags } from './metadata/parameter';
+export { methodMeta, getMethodMeta, methodLabel, getMethodLabels, methodTag, getMethodTags } from './metadata/method';
 export { select } from './select';
 export { pipe, type MapFn } from './utils/fp';
-export type { InjectFn } from './hooks/hook';
-export { type constructor, type Instance } from './utils/basic';
-export { Is } from './utils/basic';
-export { getClassMetadata } from './metadata/class';
-export { setClassMetadata } from './metadata/class';
-export { getParameterMetadata } from './metadata/parameter';
-export { setParameterMetadata } from './metadata/parameter';
-export { getMethodMetadata } from './metadata/method';
-export { setMethodMetadata } from './metadata/method';
+export { type constructor, type Instance, Is, resolveConstructor } from './utils/basic';

package/typings/metadata/class.d.ts

@@ -1,2 +1,6 @@
-export declare const setClassMetadata: <T>(key: string | symbol, mapFn: (prev: T | undefined) => T) => ClassDecorator;
-export declare function getClassMetadata<T>(target: object, key: string | symbol): T | undefined;
+export declare const classMeta: <T>(key: string | symbol, mapFn: (prev: T | undefined) => T) => ClassDecorator;
+export declare function getClassMeta<T>(target: object, key: string | symbol): T | undefined;
+export declare const classLabel: (key: string, label: string) => ClassDecorator;
+export declare const getClassLabels: (target: object) => Map<string, string>;
+export declare const classTag: (tag: string) => ClassDecorator;
+export declare const getClassTags: (target: object) => Set<string>;

package/typings/metadata/errorHandler.d.ts

@@ -0,0 +1,6 @@
+export type HandleErrorParams = (error: unknown, context: {
+    target: string;
+    method: string;
+}) => void;
+export declare const handleAsyncError: (errorHandler: HandleErrorParams) => MethodDecorator;
+export declare const handleError: (errorHandler: HandleErrorParams) => MethodDecorator;

package/typings/metadata/method.d.ts

@@ -1,2 +1,6 @@
-export declare const setMethodMetadata: <T>(key: string, mapFn: (prev: T | undefined) => T) => MethodDecorator;
-export declare const getMethodMetadata: (key: string, target: object, propertyKey: string) => unknown;
+export declare const methodMeta: <T>(key: string, mapFn: (prev: T | undefined) => T) => MethodDecorator;
+export declare const getMethodMeta: (key: string, target: object, propertyKey: string) => unknown;
+export declare const methodLabel: (key: string, label: string) => MethodDecorator;
+export declare const getMethodLabels: (target: object, propertyKey: string) => Map<string, string>;
+export declare const methodTag: (tag: string) => MethodDecorator;
+export declare const getMethodTags: (target: object, propertyKey: string) => Set<string>;

package/typings/metadata/parameter.d.ts

@@ -1,3 +1,6 @@
-import { type constructor } from '../utils/basic';
-export declare const setParameterMetadata: (key: string | symbol, mapFn: (prev: unknown) => unknown) => ParameterDecorator;
-export declare const getParameterMetadata: (key: string | symbol, target: constructor<unknown>) => unknown[];
+export declare const paramMeta: (key: string | symbol, mapFn: (prev: unknown) => unknown) => ParameterDecorator;
+export declare const getParamMeta: (key: string | symbol, target: object) => unknown[];
+export declare const paramLabel: (key: string, label: string) => ParameterDecorator;
+export declare const getParamLabels: (target: object, parameterIndex: number) => Map<string, string>;
+export declare const paramTag: (tag: string) => ParameterDecorator;
+export declare const getParamTags: (target: object, parameterIndex: number) => Set<string>;

package/typings/utils/basic.d.ts

@@ -11,3 +11,4 @@ export declare const Is: {
     instance: (target: unknown) => target is InstanceOfClass;
     constructor: (target: unknown) => target is constructor<unknown>;
 };
+export declare function resolveConstructor(target: object): object;

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;