ts-ioc-container 32.0.7 → 32.1.0

package/README.md

@@ -1207,7 +1207,6 @@ import {
   MetadataInjector,
   register,
 } from 'ts-ioc-container';
-import * as console from 'node:console';
 
 @register(key('logsRepo'))
 @provider(singleton())
@@ -1225,7 +1224,7 @@ class Logger {
 
   constructor(@inject(by.key('logsRepo')) private logsRepo: LogsRepo) {}
 
-  log(message: string): void {
+  log(@inject(by.key('logsRepo')) message: string): void {
     this.messages.push(message);
   }
 

package/cjm/{utils/autorun.js → autorun.js}

@@ -1,7 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.startAutorun = exports.getAutorunHooks = exports.autorun = void 0;
+exports.startAutorun = exports.getAutorunHooks = exports.autorun = exports.AutorunContext = void 0;
+const MetadataInjector_1 = require("./injector/MetadataInjector");
 const METADATA_KEY = 'autorun';
+class AutorunContext {
+    constructor(instance, methodName, scope) {
+        this.instance = instance;
+        this.methodName = methodName;
+        this.scope = scope;
+    }
+    resolveArgs(...args) {
+        return (0, MetadataInjector_1.resolveArgs)(this.instance.constructor, this.methodName)(this.scope, ...args);
+    }
+    invokeMethod({ args = this.resolveArgs() }) {
+        // @ts-ignore
+        return this.instance[this.methodName](...args);
+    }
+}
+exports.AutorunContext = AutorunContext;
 const createStore = () => new Map();
 const autorun = (execute) => (target, propertyKey) => {
     const hooks = Reflect.hasMetadata(METADATA_KEY, target.constructor)
@@ -17,9 +33,9 @@ const getAutorunHooks = (target) => {
         : new Map();
 };
 exports.getAutorunHooks = getAutorunHooks;
-const startAutorun = (target, createContext = (c) => c) => {
+const startAutorun = (target, scope, createContext = (c) => c) => {
     for (const [methodName, execute] of (0, exports.getAutorunHooks)(target)) {
-        execute(createContext({ instance: target, methodName }));
+        execute(createContext(new AutorunContext(target, methodName, scope)));
     }
 };
 exports.startAutorun = startAutorun;

package/cjm/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getParameterMetadata = exports.getMethodMetadata = exports.setMethodMetadata = exports.setParameterMetadata = exports.getMetadata = exports.setMetadata = exports.startAutorun = exports.autorun = exports.byAliases = exports.byAlias = exports.IMemoKey = exports.by = exports.hasHooks = exports.hook = exports.getHooks = exports.ContainerDisposedError = exports.MethodNotImplementedError = exports.DependencyNotFoundError = exports.Registration = exports.register = exports.scope = exports.key = exports.decorate = exports.multiCache = exports.MultiCache = exports.SingletonProvider = exports.singleton = exports.Provider = exports.ProviderDecorator = exports.args = exports.argsFn = exports.alias = exports.visible = exports.provider = exports.ProxyInjector = exports.SimpleInjector = exports.inject = exports.MetadataInjector = exports.AutoMockedContainer = exports.EmptyContainer = exports.Container = exports.isDependencyKey = void 0;
+exports.getParameterMetadata = exports.getMethodMetadata = exports.setMethodMetadata = exports.setParameterMetadata = exports.getMetadata = exports.setMetadata = exports.AutorunContext = exports.startAutorun = exports.autorun = exports.byAliases = exports.byAlias = exports.IMemoKey = exports.by = exports.hasHooks = exports.hook = exports.getHooks = exports.ContainerDisposedError = exports.MethodNotImplementedError = exports.DependencyNotFoundError = exports.Registration = exports.register = exports.scope = exports.key = exports.decorate = exports.multiCache = exports.MultiCache = exports.SingletonProvider = exports.singleton = exports.Provider = exports.ProviderDecorator = exports.args = exports.argsFn = exports.alias = exports.visible = exports.provider = exports.ProxyInjector = exports.SimpleInjector = exports.getInjectFns = exports.resolveArgs = exports.inject = exports.MetadataInjector = exports.AutoMockedContainer = exports.EmptyContainer = exports.Container = exports.isDependencyKey = void 0;
 // Containers
 var IContainer_1 = require("./container/IContainer");
 Object.defineProperty(exports, "isDependencyKey", { enumerable: true, get: function () { return IContainer_1.isDependencyKey; } });
@@ -13,6 +13,8 @@ Object.defineProperty(exports, "AutoMockedContainer", { enumerable: true, get: f
 var MetadataInjector_1 = require("./injector/MetadataInjector");
 Object.defineProperty(exports, "MetadataInjector", { enumerable: true, get: function () { return MetadataInjector_1.MetadataInjector; } });
 Object.defineProperty(exports, "inject", { enumerable: true, get: function () { return MetadataInjector_1.inject; } });
+Object.defineProperty(exports, "resolveArgs", { enumerable: true, get: function () { return MetadataInjector_1.resolveArgs; } });
+Object.defineProperty(exports, "getInjectFns", { enumerable: true, get: function () { return MetadataInjector_1.getInjectFns; } });
 var SimpleInjector_1 = require("./injector/SimpleInjector");
 Object.defineProperty(exports, "SimpleInjector", { enumerable: true, get: function () { return SimpleInjector_1.SimpleInjector; } });
 var ProxyInjector_1 = require("./injector/ProxyInjector");
@@ -59,9 +61,10 @@ Object.defineProperty(exports, "by", { enumerable: true, get: function () { retu
 Object.defineProperty(exports, "IMemoKey", { enumerable: true, get: function () { return by_1.IMemoKey; } });
 Object.defineProperty(exports, "byAlias", { enumerable: true, get: function () { return by_1.byAlias; } });
 Object.defineProperty(exports, "byAliases", { enumerable: true, get: function () { return by_1.byAliases; } });
-var autorun_1 = require("./utils/autorun");
+var autorun_1 = require("./autorun");
 Object.defineProperty(exports, "autorun", { enumerable: true, get: function () { return autorun_1.autorun; } });
 Object.defineProperty(exports, "startAutorun", { enumerable: true, get: function () { return autorun_1.startAutorun; } });
+Object.defineProperty(exports, "AutorunContext", { enumerable: true, get: function () { return autorun_1.AutorunContext; } });
 var metadata_1 = require("./metadata");
 Object.defineProperty(exports, "setMetadata", { enumerable: true, get: function () { return metadata_1.setMetadata; } });
 Object.defineProperty(exports, "getMetadata", { enumerable: true, get: function () { return metadata_1.getMetadata; } });

package/cjm/injector/MetadataInjector.js

@@ -1,16 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MetadataInjector = exports.inject = void 0;
+exports.MetadataInjector = exports.resolveArgs = exports.inject = exports.getInjectFns = void 0;
 const utils_1 = require("../utils");
 const metadata_1 = require("../metadata");
 const METADATA_KEY = 'inject';
-const getInjectFns = (Target) => (0, metadata_1.getParameterMetadata)(METADATA_KEY, Target);
-const inject = (fn) => (0, metadata_1.setParameterMetadata)(METADATA_KEY, fn);
+const getInjectFns = (Target, methodName) => (0, metadata_1.getParameterMetadata)(metaKey(methodName), Target);
+exports.getInjectFns = getInjectFns;
+const metaKey = (methodName = 'constructor') => `${METADATA_KEY}:${methodName}`;
+const inject = (fn) => (target, propertyKey, parameterIndex) => (0, metadata_1.setParameterMetadata)(metaKey(propertyKey), fn)(target, propertyKey, parameterIndex);
 exports.inject = inject;
+const resolveArgs = (Target, methodName) => {
+    const argsFns = (0, exports.getInjectFns)(Target, methodName);
+    return (scope, ...deps) => (0, utils_1.fillEmptyIndexes)(argsFns, deps.map(utils_1.constant)).map((fn) => fn(scope));
+};
+exports.resolveArgs = resolveArgs;
 class MetadataInjector {
     resolve(container, Target, { args: deps }) {
-        const injectionFns = getInjectFns(Target);
-        const args = (0, utils_1.fillEmptyIndexes)(injectionFns, deps.map(utils_1.constant)).map((fn) => fn(container));
+        const args = (0, exports.resolveArgs)(Target)(container, ...deps);
         return new Target(...args);
     }
 }

package/esm/{utils/autorun.js → autorun.js}

@@ -1,4 +1,19 @@
+import { resolveArgs } from './injector/MetadataInjector';
 const METADATA_KEY = 'autorun';
+export class AutorunContext {
+    constructor(instance, methodName, scope) {
+        this.instance = instance;
+        this.methodName = methodName;
+        this.scope = scope;
+    }
+    resolveArgs(...args) {
+        return resolveArgs(this.instance.constructor, this.methodName)(this.scope, ...args);
+    }
+    invokeMethod({ args = this.resolveArgs() }) {
+        // @ts-ignore
+        return this.instance[this.methodName](...args);
+    }
+}
 const createStore = () => new Map();
 export const autorun = (execute) => (target, propertyKey) => {
     const hooks = Reflect.hasMetadata(METADATA_KEY, target.constructor)
@@ -12,8 +27,8 @@ export const getAutorunHooks = (target) => {
         ? Reflect.getMetadata(METADATA_KEY, target.constructor)
         : new Map();
 };
-export const startAutorun = (target, createContext = (c) => c) => {
+export const startAutorun = (target, scope, createContext = (c) => c) => {
     for (const [methodName, execute] of getAutorunHooks(target)) {
-        execute(createContext({ instance: target, methodName }));
+        execute(createContext(new AutorunContext(target, methodName, scope)));
     }
 };

package/esm/index.js

@@ -3,7 +3,7 @@ export { isDependencyKey, } from './container/IContainer';
 export { Container } from './container/Container';
 export { EmptyContainer } from './container/EmptyContainer';
 export { AutoMockedContainer } from './container/AutoMockedContainer';
-export { MetadataInjector, inject } from './injector/MetadataInjector';
+export { MetadataInjector, inject, resolveArgs, getInjectFns } from './injector/MetadataInjector';
 export { SimpleInjector } from './injector/SimpleInjector';
 export { ProxyInjector } from './injector/ProxyInjector';
 // Providers
@@ -22,5 +22,5 @@ export { ContainerDisposedError } from './errors/ContainerDisposedError';
 // Others
 export { getHooks, hook, hasHooks } from './hook';
 export { by, IMemoKey, byAlias, byAliases } from './by';
-export { autorun, startAutorun } from './utils/autorun';
+export { autorun, startAutorun, AutorunContext } from './autorun';
 export { setMetadata, getMetadata, setParameterMetadata, setMethodMetadata, getMethodMetadata, getParameterMetadata, } from './metadata';

package/esm/injector/MetadataInjector.js

@@ -1,12 +1,16 @@
 import { constant, fillEmptyIndexes } from '../utils';
 import { setParameterMetadata, getParameterMetadata } from '../metadata';
 const METADATA_KEY = 'inject';
-const getInjectFns = (Target) => getParameterMetadata(METADATA_KEY, Target);
-export const inject = (fn) => setParameterMetadata(METADATA_KEY, fn);
+export const getInjectFns = (Target, methodName) => getParameterMetadata(metaKey(methodName), Target);
+const metaKey = (methodName = 'constructor') => `${METADATA_KEY}:${methodName}`;
+export const inject = (fn) => (target, propertyKey, parameterIndex) => setParameterMetadata(metaKey(propertyKey), fn)(target, propertyKey, parameterIndex);
+export const resolveArgs = (Target, methodName) => {
+    const argsFns = getInjectFns(Target, methodName);
+    return (scope, ...deps) => fillEmptyIndexes(argsFns, deps.map(constant)).map((fn) => fn(scope));
+};
 export class MetadataInjector {
     resolve(container, Target, { args: deps }) {
-        const injectionFns = getInjectFns(Target);
-        const args = fillEmptyIndexes(injectionFns, deps.map(constant)).map((fn) => fn(container));
+        const args = resolveArgs(Target)(container, ...deps);
         return new Target(...args);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-ioc-container",
-  "version": "32.0.7",
+  "version": "32.1.0",
   "description": "Typescript IoC container",
   "publishConfig": {
     "access": "public",
@@ -59,5 +59,5 @@
     "ts-node": "^10.9.1",
     "typescript": "5.4.3"
   },
-  "gitHead": "b8a57d6ba85affdbb5e743ac4653dbc6e65b3bc4"
+  "gitHead": "79eba3d3a19747339a7b078592f719f00c869f59"
 }

package/typings/autorun.d.ts

@@ -0,0 +1,16 @@
+import { IContainer } from './container/IContainer';
+export declare class AutorunContext {
+    instance: object;
+    methodName: string;
+    private scope;
+    constructor(instance: object, methodName: string, scope: IContainer);
+    resolveArgs(...args: unknown[]): unknown[];
+    invokeMethod({ args }: {
+        args: unknown[];
+    }): unknown;
+}
+type AutorunHandler = <T extends AutorunContext>(context: T) => void;
+export declare const autorun: (execute: AutorunHandler) => MethodDecorator;
+export declare const getAutorunHooks: (target: object) => Map<string, AutorunHandler>;
+export declare const startAutorun: <Context extends AutorunContext>(target: object, scope: IContainer, createContext?: (c: AutorunContext) => Context) => void;
+export {};

package/typings/index.d.ts

@@ -3,7 +3,7 @@ export { Container } from './container/Container';
 export { EmptyContainer } from './container/EmptyContainer';
 export { AutoMockedContainer } from './container/AutoMockedContainer';
 export { IInjector } from './injector/IInjector';
-export { MetadataInjector, inject } from './injector/MetadataInjector';
+export { MetadataInjector, inject, resolveArgs, getInjectFns, InjectFn } from './injector/MetadataInjector';
 export { SimpleInjector } from './injector/SimpleInjector';
 export { ProxyInjector } from './injector/ProxyInjector';
 export { ResolveDependency, IProvider, provider, visible, alias, argsFn, args, ArgsFn, ProviderDecorator, InstantDependencyOptions, ProviderResolveOptions, } from './provider/IProvider';
@@ -20,5 +20,5 @@ export { ContainerDisposedError } from './errors/ContainerDisposedError';
 export { getHooks, hook, hasHooks } from './hook';
 export { by, InstancePredicate, IMemo, IMemoKey, byAlias, byAliases } from './by';
 export { constructor } from './utils';
-export { autorun, startAutorun } from './utils/autorun';
+export { autorun, startAutorun, AutorunContext } from './autorun';
 export { setMetadata, getMetadata, setParameterMetadata, setMethodMetadata, getMethodMetadata, getParameterMetadata, } from './metadata';

package/typings/injector/MetadataInjector.d.ts

@@ -2,7 +2,9 @@ import { IInjector, InjectOptions } from './IInjector';
 import { IContainer } from '../container/IContainer';
 import { constructor } from '../utils';
 export type InjectFn<T = unknown> = (l: IContainer) => T;
+export declare const getInjectFns: (Target: constructor<unknown>, methodName?: string) => InjectFn<unknown>[];
 export declare const inject: (fn: InjectFn) => ParameterDecorator;
+export declare const resolveArgs: (Target: constructor<unknown>, methodName?: string) => (scope: IContainer, ...deps: unknown[]) => unknown[];
 export declare class MetadataInjector implements IInjector {
     resolve<T>(container: IContainer, Target: constructor<T>, { args: deps }: InjectOptions): T;
 }

package/typings/utils/autorun.d.ts

@@ -1,12 +0,0 @@
-interface AutorunContext {
-    instance: object;
-    methodName: string;
-}
-type AutorunHandler = <T extends AutorunContext>(context: T) => void;
-export declare const autorun: (execute: AutorunHandler) => MethodDecorator;
-export declare const getAutorunHooks: (target: object) => Map<string, AutorunHandler>;
-export declare const startAutorun: <Context extends AutorunContext>(target: object, createContext?: (props: {
-    instance: object;
-    methodName: string;
-}) => Context) => void;
-export {};