ts-ioc-container 31.10.0 → 32.0.0

package/README.md

@@ -99,7 +99,7 @@ describe('Basic usage', function () {
 
   it('should inject multiple dependencies', function () {
     class App {
-      constructor(@inject(by.keys('ILogger1', 'ILogger2')) public loggers: Logger[]) {}
+      constructor(@inject(by.keys(['ILogger1', 'ILogger2'])) public loggers: Logger[]) {}
     }
 
     const container = new Container(new MetadataInjector())
@@ -770,9 +770,9 @@ describe('alias', () => {
       .add(R.fromClass(FileLogger))
       .add(R.fromClass(DbLogger));
 
-    const result1 = by.alias((aliases) => aliases.has('ILogger'), constant('ILogger'))(container);
+    const result1 = by.alias((aliases) => aliases.has('ILogger'), { memoize: constant('ILogger') })(container);
     const child = container.createScope('child');
-    const result2 = by.alias((aliases) => aliases.has('ILogger'), constant('ILogger'))(child);
+    const result2 = by.alias((aliases) => aliases.has('ILogger'), { memoize: constant('ILogger') })(child);
     const result3 = by.alias((aliases) => aliases.has('ILogger'))(child);
 
     expect(result1).toBeInstanceOf(FileLogger);
@@ -791,7 +791,9 @@ describe('alias', () => {
     class DbLogger implements ILogger {}
 
     class App {
-      constructor(@inject(by.aliases((it) => it.has('ILogger'), constant('ILogger'))) public loggers: ILogger[]) {}
+      constructor(
+        @inject(by.aliases((it) => it.has('ILogger'), { memoize: constant('ILogger') })) public loggers: ILogger[],
+      ) {}
     }
 
     const container = new Container(new MetadataInjector())

package/cjm/by.js

@@ -5,64 +5,54 @@ const all = () => true;
 exports.all = all;
 exports.IMemoKey = Symbol('IMemo');
 exports.by = {
-    aliases: (predicate, memoize) => (c, ...args) => {
+    aliases: (predicate, { memoize, lazy } = {}) => (c, ...args) => {
         const predicateFn = (aliases) => predicate(aliases, c);
         const memoKey = memoize?.(c);
-        if (memoKey) {
-            const memo = c.resolve(exports.IMemoKey);
-            const memoized = memo.get(memoKey);
-            if (memoized) {
-                return memoized.map((key) => c.resolve(key, { args }));
-            }
-            const result = c.resolveManyByAlias(predicateFn, { args });
-            memo.set(memoKey, Array.from(result.keys()));
-            return Array.from(result.values());
+        if (memoKey === undefined) {
+            return Array.from(c.resolveManyByAlias(predicateFn, { args, lazy }).values());
         }
-        return Array.from(c.resolveManyByAlias(predicateFn, { args }).values());
+        const memo = c.resolve(exports.IMemoKey);
+        const memoized = memo.get(memoKey);
+        if (memoized) {
+            return memoized.map((key) => c.resolve(key, { args, lazy }));
+        }
+        const result = c.resolveManyByAlias(predicateFn, { args, lazy });
+        memo.set(memoKey, Array.from(result.keys()));
+        return Array.from(result.values());
     },
     /**
      * Get the instance that matches the given alias or fail
      * @param predicate
      * @param memoize
      */
-    alias: (predicate, memoize) => (c, ...args) => {
+    alias: (predicate, { memoize, lazy } = {}) => (c, ...args) => {
         const predicateFn = (aliases) => predicate(aliases, c);
         const memoKey = memoize?.(c);
-        if (memoKey) {
-            const memo = c.resolve(exports.IMemoKey);
-            const memoized = memo.get(memoKey);
-            if (memoized) {
-                return c.resolve(memoized[0], { args });
-            }
-            const [key, result] = c.resolveOneByAlias(predicateFn, { args });
-            memo.set(memoKey, [key]);
-            return result;
+        if (memoKey === undefined) {
+            return c.resolveOneByAlias(predicateFn, { args, lazy })[1];
+        }
+        const memo = c.resolve(exports.IMemoKey);
+        const memoized = memo.get(memoKey);
+        if (memoized) {
+            return c.resolve(memoized[0], { args, lazy });
         }
-        return c.resolveOneByAlias(predicateFn, { args })[1];
+        const [key, result] = c.resolveOneByAlias(predicateFn, { args, lazy });
+        memo.set(memoKey, [key]);
+        return result;
     },
     /**
      * Get all instances that match the given keys
      * @param keys
+     * @param lazy
      */
-    keys: (...keys) => (с, ...args) => keys.map((t) => с.resolve(t, { args })),
+    keys: (keys, { lazy } = {}) => (с, ...args) => keys.map((t) => с.resolve(t, { args, lazy })),
     /**
      * Get the instance that matches the given key
      * @param key
      * @param deps
+     * @param lazy
      */
-    key: (key, ...deps) => (c, ...args) => c.resolve(key, { args: [...deps, ...args] }),
-    lazy: {
-        key: (key, ...deps) => (c, ...args) => {
-            let instance;
-            return new Proxy({}, {
-                get: (_, prop) => {
-                    instance = instance ?? c.resolve(key, { args: [...deps, ...args] });
-                    // @ts-ignore
-                    return instance[prop];
-                },
-            });
-        },
-    },
+    key: (key, { args: deps = [], lazy } = {}) => (c, ...args) => c.resolve(key, { args: [...deps, ...args], lazy }),
     /**
      * Get all instances that match the given predicate
      * @param predicate

package/cjm/container/Container.js

@@ -4,6 +4,7 @@ exports.Container = void 0;
 const IContainer_1 = require("./IContainer");
 const EmptyContainer_1 = require("./EmptyContainer");
 const ContainerDisposedError_1 = require("../errors/ContainerDisposedError");
+const utils_1 = require("../utils");
 class Container {
     constructor(injector, options = {}) {
         this.injector = injector;
@@ -25,17 +26,22 @@ class Container {
         this.providers.set(key, provider);
         return this;
     }
-    resolve(token, { args = [], child = this } = {}) {
+    resolve(token, { args = [], child = this, lazy } = {}) {
         this.validateContainer();
         if ((0, IContainer_1.isConstructor)(token)) {
-            const instance = this.injector.resolve(this, token, ...args);
-            this.instances.add(instance);
-            return instance;
+            return lazy
+                ? (0, utils_1.lazyInstance)(() => this.resolveByInjector(token, { args }))
+                : this.resolveByInjector(token, { args });
         }
         const provider = this.providers.get(token);
         return provider?.isVisible(this, child)
-            ? provider.resolve(this, ...args)
-            : this.parent.resolve(token, { args, child });
+            ? provider.resolve(this, { args, lazy })
+            : this.parent.resolve(token, { args, child, lazy });
+    }
+    resolveByInjector(token, options) {
+        const instance = this.injector.resolve(this, token, options);
+        this.instances.add(instance);
+        return instance;
     }
     createScope(...tags) {
         this.validateContainer();
@@ -73,21 +79,21 @@ class Container {
     hasDependency(key) {
         return this.providers.has(key) ?? this.parent.hasDependency(key);
     }
-    resolveManyByAlias(predicate, { args = [], child = this } = {}, result = new Map()) {
+    resolveManyByAlias(predicate, { args = [], child = this, lazy } = {}, result = new Map()) {
         for (const [key, provider] of this.providers.entries()) {
             if (!result.has(key) && provider.matchAliases(predicate) && provider.isVisible(this, child)) {
-                result.set(key, provider.resolve(this, ...args));
+                result.set(key, provider.resolve(this, { args, lazy }));
             }
         }
-        return this.parent.resolveManyByAlias(predicate, { args, child }, result);
+        return this.parent.resolveManyByAlias(predicate, { args, child, lazy }, result);
     }
-    resolveOneByAlias(predicate, { args = [], child = this } = {}) {
+    resolveOneByAlias(predicate, { args = [], child = this, lazy } = {}) {
         for (const [key, provider] of this.providers.entries()) {
             if (provider.matchAliases(predicate) && provider.isVisible(this, child)) {
-                return [key, provider.resolve(this, ...args)];
+                return [key, provider.resolve(this, { args, lazy })];
             }
         }
-        return this.parent.resolveOneByAlias(predicate, { args, child });
+        return this.parent.resolveOneByAlias(predicate, { args, child, lazy });
     }
     /**
      * @private

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.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.lazy = 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.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.makeProviderLazy = exports.multiCache = exports.MultiCache = exports.SingletonProvider = exports.singleton = exports.Provider = exports.ProviderDecorator = exports.lazy = 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;
 // Containers
 var IContainer_1 = require("./container/IContainer");
 Object.defineProperty(exports, "isDependencyKey", { enumerable: true, get: function () { return IContainer_1.isDependencyKey; } });
@@ -24,6 +24,7 @@ Object.defineProperty(exports, "visible", { enumerable: true, get: function () {
 Object.defineProperty(exports, "alias", { enumerable: true, get: function () { return IProvider_1.alias; } });
 Object.defineProperty(exports, "argsFn", { enumerable: true, get: function () { return IProvider_1.argsFn; } });
 Object.defineProperty(exports, "args", { enumerable: true, get: function () { return IProvider_1.args; } });
+Object.defineProperty(exports, "lazy", { enumerable: true, get: function () { return IProvider_1.lazy; } });
 Object.defineProperty(exports, "ProviderDecorator", { enumerable: true, get: function () { return IProvider_1.ProviderDecorator; } });
 var Provider_1 = require("./provider/Provider");
 Object.defineProperty(exports, "Provider", { enumerable: true, get: function () { return Provider_1.Provider; } });
@@ -34,7 +35,7 @@ var MultiCache_1 = require("./provider/singleton/MultiCache");
 Object.defineProperty(exports, "MultiCache", { enumerable: true, get: function () { return MultiCache_1.MultiCache; } });
 Object.defineProperty(exports, "multiCache", { enumerable: true, get: function () { return MultiCache_1.multiCache; } });
 var LazyProvider_1 = require("./provider/LazyProvider");
-Object.defineProperty(exports, "lazy", { enumerable: true, get: function () { return LazyProvider_1.lazy; } });
+Object.defineProperty(exports, "makeProviderLazy", { enumerable: true, get: function () { return LazyProvider_1.makeProviderLazy; } });
 var DecoratorProvider_1 = require("./provider/DecoratorProvider");
 Object.defineProperty(exports, "decorate", { enumerable: true, get: function () { return DecoratorProvider_1.decorate; } });
 // Registrations

package/cjm/injector/MetadataInjector.js

@@ -8,7 +8,7 @@ const getInjectFns = (Target) => (0, metadata_1.getParameterMetadata)(METADATA_K
 const inject = (fn) => (0, metadata_1.setParameterMetadata)(METADATA_KEY, fn);
 exports.inject = inject;
 class MetadataInjector {
-    resolve(container, Target, ...deps) {
+    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));
         return new Target(...args);

package/cjm/injector/ProxyInjector.js

@@ -8,7 +8,7 @@ function getProp(target, key) {
 }
 class ProxyInjector {
     // eslint-disable-next-line @typescript-eslint/ban-types
-    resolve(container, Target, ...deps) {
+    resolve(container, Target, { args: deps }) {
         const args = deps.reduce((acc, it) => ({ ...acc, ...it }), {});
         const proxy = new Proxy({}, {
             // eslint-disable-next-line @typescript-eslint/ban-types

package/cjm/injector/SimpleInjector.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SimpleInjector = void 0;
 class SimpleInjector {
-    resolve(container, Target, ...deps) {
+    resolve(container, Target, { args: deps }) {
         return new Target(container, ...deps);
     }
 }

package/cjm/provider/DecoratorProvider.js

@@ -8,8 +8,8 @@ class DecoratorProvider extends IProvider_1.ProviderDecorator {
         this.provider = provider;
         this.decorateFn = decorateFn;
     }
-    resolve(scope, ...args) {
-        const dependency = this.provider.resolve(scope, ...args);
+    resolve(scope, options) {
+        const dependency = this.provider.resolve(scope, options);
         return this.decorateFn(dependency, scope);
     }
 }

package/cjm/provider/IProvider.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProviderDecorator = exports.visible = exports.alias = exports.getTransformers = exports.provider = exports.argsFn = exports.args = void 0;
+exports.ProviderDecorator = exports.visible = exports.alias = exports.getTransformers = exports.provider = exports.lazy = exports.argsFn = exports.args = void 0;
 const utils_1 = require("../utils");
 const metadata_1 = require("../metadata");
 function args(...extraArgs) {
@@ -11,6 +11,8 @@ function argsFn(fn) {
     return (provider) => provider.setArgs(fn);
 }
 exports.argsFn = argsFn;
+const lazy = (provider) => provider.setLazy(true);
+exports.lazy = lazy;
 const METADATA_KEY = 'provider';
 const provider = (...mappers) => (0, metadata_1.setMetadata)(METADATA_KEY, mappers);
 exports.provider = provider;
@@ -31,8 +33,8 @@ class ProviderDecorator {
     isVisible(parent, child) {
         return this.decorated.isVisible(parent, child);
     }
-    resolve(container, ...args) {
-        return this.decorated.resolve(container, ...args);
+    resolve(container, options) {
+        return this.decorated.resolve(container, options);
     }
     pipe(...mappers) {
         return (0, utils_1.pipe)(...mappers)(this);
@@ -48,5 +50,9 @@ class ProviderDecorator {
         this.decorated.setArgs(argsFn);
         return this;
     }
+    setLazy(lazy) {
+        this.decorated.setLazy(lazy);
+        return this;
+    }
 }
 exports.ProviderDecorator = ProviderDecorator;

package/cjm/provider/LazyProvider.js

@@ -1,23 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.lazy = exports.LazyProvider = void 0;
+exports.makeProviderLazy = exports.LazyProvider = void 0;
 const IProvider_1 = require("./IProvider");
+const utils_1 = require("../utils");
 class LazyProvider extends IProvider_1.ProviderDecorator {
     constructor(provider) {
         super(provider);
         this.provider = provider;
     }
-    resolve(container, ...args) {
-        let instance;
-        return new Proxy({}, {
-            get: (_, prop) => {
-                instance = instance ?? this.provider.resolve(container, ...args);
-                // @ts-ignore
-                return instance[prop];
-            },
-        });
+    resolve(container, options) {
+        return (0, utils_1.lazyInstance)(() => this.provider.resolve(container, options));
     }
 }
 exports.LazyProvider = LazyProvider;
-const lazy = (provider) => new LazyProvider(provider);
-exports.lazy = lazy;
+const makeProviderLazy = (provider) => new LazyProvider(provider);
+exports.makeProviderLazy = makeProviderLazy;

package/cjm/provider/Provider.js

@@ -6,7 +6,7 @@ const utils_1 = require("../utils");
 class Provider {
     static fromClass(Target) {
         const transformers = (0, IProvider_1.getTransformers)(Target);
-        return new Provider((container, ...args) => container.resolve(Target, { args })).pipe(...transformers);
+        return new Provider((container, options) => container.resolve(Target, options)).pipe(...transformers);
     }
     static fromValue(value) {
         const mappers = (0, utils_1.isConstructor)(value) ? (0, IProvider_1.getTransformers)(value) ?? [] : [];
@@ -16,18 +16,26 @@ class Provider {
         this.resolveDependency = resolveDependency;
         this.aliases = new Set();
         this.argsFn = () => [];
+        this.isLazy = false;
         this.isVisibleWhen = () => true;
     }
     pipe(...mappers) {
         return (0, utils_1.pipe)(...mappers)(this);
     }
-    resolve(container, ...args) {
-        return this.resolveDependency(container, ...this.argsFn(container, ...args), ...args);
+    resolve(container, { args, lazy }) {
+        return this.resolveDependency(container, {
+            args: [...this.argsFn(container, ...args), ...args],
+            lazy: lazy ?? this.isLazy ?? false,
+        });
     }
     setVisibility(predicate) {
         this.isVisibleWhen = predicate;
         return this;
     }
+    setLazy(lazy) {
+        this.isLazy = lazy;
+        return this;
+    }
     setArgs(argsFn) {
         this.argsFn = argsFn;
         return this;

package/cjm/provider/singleton/SingletonProvider.js

@@ -13,10 +13,10 @@ class SingletonProvider extends IProvider_1.ProviderDecorator {
         this.provider = provider;
         this.cache = cache;
     }
-    resolve(container, ...args) {
-        const key = this.cache.getKey(...args);
+    resolve(container, options) {
+        const key = this.cache.getKey(...options.args);
         if (!this.cache.hasValue(key)) {
-            this.cache.setValue(key, this.provider.resolve(container, ...args));
+            this.cache.setValue(key, this.provider.resolve(container, options));
         }
         return this.cache.getValue(key);
     }

package/cjm/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isConstructor = exports.constant = exports.fillEmptyIndexes = exports.pipe = void 0;
+exports.lazyInstance = exports.isConstructor = exports.constant = exports.fillEmptyIndexes = exports.pipe = void 0;
 const pipe = (...mappers) => (value) => mappers.reduce((acc, current) => current(acc), value);
 exports.pipe = pipe;
 function fillEmptyIndexes(baseArr, insertArr) {
@@ -18,3 +18,14 @@ const constant = (value) => () => value;
 exports.constant = constant;
 const isConstructor = (T) => typeof T === 'function' && !!T.prototype;
 exports.isConstructor = isConstructor;
+function lazyInstance(resolveInstance) {
+    let instance;
+    return new Proxy({}, {
+        get: (_, prop) => {
+            instance = instance ?? resolveInstance();
+            // @ts-ignore
+            return instance[prop];
+        },
+    });
+}
+exports.lazyInstance = lazyInstance;

package/esm/by.js

@@ -1,64 +1,54 @@
 export const all = () => true;
 export const IMemoKey = Symbol('IMemo');
 export const by = {
-    aliases: (predicate, memoize) => (c, ...args) => {
+    aliases: (predicate, { memoize, lazy } = {}) => (c, ...args) => {
         const predicateFn = (aliases) => predicate(aliases, c);
         const memoKey = memoize?.(c);
-        if (memoKey) {
-            const memo = c.resolve(IMemoKey);
-            const memoized = memo.get(memoKey);
-            if (memoized) {
-                return memoized.map((key) => c.resolve(key, { args }));
-            }
-            const result = c.resolveManyByAlias(predicateFn, { args });
-            memo.set(memoKey, Array.from(result.keys()));
-            return Array.from(result.values());
+        if (memoKey === undefined) {
+            return Array.from(c.resolveManyByAlias(predicateFn, { args, lazy }).values());
         }
-        return Array.from(c.resolveManyByAlias(predicateFn, { args }).values());
+        const memo = c.resolve(IMemoKey);
+        const memoized = memo.get(memoKey);
+        if (memoized) {
+            return memoized.map((key) => c.resolve(key, { args, lazy }));
+        }
+        const result = c.resolveManyByAlias(predicateFn, { args, lazy });
+        memo.set(memoKey, Array.from(result.keys()));
+        return Array.from(result.values());
     },
     /**
      * Get the instance that matches the given alias or fail
      * @param predicate
      * @param memoize
      */
-    alias: (predicate, memoize) => (c, ...args) => {
+    alias: (predicate, { memoize, lazy } = {}) => (c, ...args) => {
         const predicateFn = (aliases) => predicate(aliases, c);
         const memoKey = memoize?.(c);
-        if (memoKey) {
-            const memo = c.resolve(IMemoKey);
-            const memoized = memo.get(memoKey);
-            if (memoized) {
-                return c.resolve(memoized[0], { args });
-            }
-            const [key, result] = c.resolveOneByAlias(predicateFn, { args });
-            memo.set(memoKey, [key]);
-            return result;
+        if (memoKey === undefined) {
+            return c.resolveOneByAlias(predicateFn, { args, lazy })[1];
+        }
+        const memo = c.resolve(IMemoKey);
+        const memoized = memo.get(memoKey);
+        if (memoized) {
+            return c.resolve(memoized[0], { args, lazy });
         }
-        return c.resolveOneByAlias(predicateFn, { args })[1];
+        const [key, result] = c.resolveOneByAlias(predicateFn, { args, lazy });
+        memo.set(memoKey, [key]);
+        return result;
     },
     /**
      * Get all instances that match the given keys
      * @param keys
+     * @param lazy
      */
-    keys: (...keys) => (с, ...args) => keys.map((t) => с.resolve(t, { args })),
+    keys: (keys, { lazy } = {}) => (с, ...args) => keys.map((t) => с.resolve(t, { args, lazy })),
     /**
      * Get the instance that matches the given key
      * @param key
      * @param deps
+     * @param lazy
      */
-    key: (key, ...deps) => (c, ...args) => c.resolve(key, { args: [...deps, ...args] }),
-    lazy: {
-        key: (key, ...deps) => (c, ...args) => {
-            let instance;
-            return new Proxy({}, {
-                get: (_, prop) => {
-                    instance = instance ?? c.resolve(key, { args: [...deps, ...args] });
-                    // @ts-ignore
-                    return instance[prop];
-                },
-            });
-        },
-    },
+    key: (key, { args: deps = [], lazy } = {}) => (c, ...args) => c.resolve(key, { args: [...deps, ...args], lazy }),
     /**
      * Get all instances that match the given predicate
      * @param predicate

package/esm/container/Container.js

@@ -1,6 +1,7 @@
 import { isConstructor, } from './IContainer';
 import { EmptyContainer } from './EmptyContainer';
 import { ContainerDisposedError } from '../errors/ContainerDisposedError';
+import { lazyInstance } from '../utils';
 export class Container {
     constructor(injector, options = {}) {
         this.injector = injector;
@@ -22,17 +23,22 @@ export class Container {
         this.providers.set(key, provider);
         return this;
     }
-    resolve(token, { args = [], child = this } = {}) {
+    resolve(token, { args = [], child = this, lazy } = {}) {
         this.validateContainer();
         if (isConstructor(token)) {
-            const instance = this.injector.resolve(this, token, ...args);
-            this.instances.add(instance);
-            return instance;
+            return lazy
+                ? lazyInstance(() => this.resolveByInjector(token, { args }))
+                : this.resolveByInjector(token, { args });
         }
         const provider = this.providers.get(token);
         return provider?.isVisible(this, child)
-            ? provider.resolve(this, ...args)
-            : this.parent.resolve(token, { args, child });
+            ? provider.resolve(this, { args, lazy })
+            : this.parent.resolve(token, { args, child, lazy });
+    }
+    resolveByInjector(token, options) {
+        const instance = this.injector.resolve(this, token, options);
+        this.instances.add(instance);
+        return instance;
     }
     createScope(...tags) {
         this.validateContainer();
@@ -70,21 +76,21 @@ export class Container {
     hasDependency(key) {
         return this.providers.has(key) ?? this.parent.hasDependency(key);
     }
-    resolveManyByAlias(predicate, { args = [], child = this } = {}, result = new Map()) {
+    resolveManyByAlias(predicate, { args = [], child = this, lazy } = {}, result = new Map()) {
         for (const [key, provider] of this.providers.entries()) {
             if (!result.has(key) && provider.matchAliases(predicate) && provider.isVisible(this, child)) {
-                result.set(key, provider.resolve(this, ...args));
+                result.set(key, provider.resolve(this, { args, lazy }));
             }
         }
-        return this.parent.resolveManyByAlias(predicate, { args, child }, result);
+        return this.parent.resolveManyByAlias(predicate, { args, child, lazy }, result);
     }
-    resolveOneByAlias(predicate, { args = [], child = this } = {}) {
+    resolveOneByAlias(predicate, { args = [], child = this, lazy } = {}) {
         for (const [key, provider] of this.providers.entries()) {
             if (provider.matchAliases(predicate) && provider.isVisible(this, child)) {
-                return [key, provider.resolve(this, ...args)];
+                return [key, provider.resolve(this, { args, lazy })];
             }
         }
-        return this.parent.resolveOneByAlias(predicate, { args, child });
+        return this.parent.resolveOneByAlias(predicate, { args, child, lazy });
     }
     /**
      * @private

package/esm/index.js

@@ -7,11 +7,11 @@ export { MetadataInjector, inject } from './injector/MetadataInjector';
 export { SimpleInjector } from './injector/SimpleInjector';
 export { ProxyInjector } from './injector/ProxyInjector';
 // Providers
-export { provider, visible, alias, argsFn, args, ProviderDecorator, } from './provider/IProvider';
+export { provider, visible, alias, argsFn, args, lazy, ProviderDecorator, } from './provider/IProvider';
 export { Provider } from './provider/Provider';
 export { singleton, SingletonProvider } from './provider/singleton/SingletonProvider';
 export { MultiCache, multiCache } from './provider/singleton/MultiCache';
-export { lazy } from './provider/LazyProvider';
+export { makeProviderLazy } from './provider/LazyProvider';
 export { decorate } from './provider/DecoratorProvider';
 // Registrations
 export { key, scope, register } from './registration/IRegistration';

package/esm/injector/MetadataInjector.js

@@ -4,7 +4,7 @@ const METADATA_KEY = 'inject';
 const getInjectFns = (Target) => getParameterMetadata(METADATA_KEY, Target);
 export const inject = (fn) => setParameterMetadata(METADATA_KEY, fn);
 export class MetadataInjector {
-    resolve(container, Target, ...deps) {
+    resolve(container, Target, { args: deps }) {
         const injectionFns = getInjectFns(Target);
         const args = fillEmptyIndexes(injectionFns, deps.map(constant)).map((fn) => fn(container));
         return new Target(...args);

package/esm/injector/ProxyInjector.js

@@ -5,7 +5,7 @@ function getProp(target, key) {
 }
 export class ProxyInjector {
     // eslint-disable-next-line @typescript-eslint/ban-types
-    resolve(container, Target, ...deps) {
+    resolve(container, Target, { args: deps }) {
         const args = deps.reduce((acc, it) => ({ ...acc, ...it }), {});
         const proxy = new Proxy({}, {
             // eslint-disable-next-line @typescript-eslint/ban-types

package/esm/injector/SimpleInjector.js

@@ -1,5 +1,5 @@
 export class SimpleInjector {
-    resolve(container, Target, ...deps) {
+    resolve(container, Target, { args: deps }) {
         return new Target(container, ...deps);
     }
 }

package/esm/provider/DecoratorProvider.js

@@ -5,8 +5,8 @@ export class DecoratorProvider extends ProviderDecorator {
         this.provider = provider;
         this.decorateFn = decorateFn;
     }
-    resolve(scope, ...args) {
-        const dependency = this.provider.resolve(scope, ...args);
+    resolve(scope, options) {
+        const dependency = this.provider.resolve(scope, options);
         return this.decorateFn(dependency, scope);
     }
 }

package/esm/provider/IProvider.js

@@ -6,6 +6,7 @@ export function args(...extraArgs) {
 export function argsFn(fn) {
     return (provider) => provider.setArgs(fn);
 }
+export const lazy = (provider) => provider.setLazy(true);
 const METADATA_KEY = 'provider';
 export const provider = (...mappers) => setMetadata(METADATA_KEY, mappers);
 export const getTransformers = (Target) => getMetadata(Target, METADATA_KEY) ?? [];
@@ -22,8 +23,8 @@ export class ProviderDecorator {
     isVisible(parent, child) {
         return this.decorated.isVisible(parent, child);
     }
-    resolve(container, ...args) {
-        return this.decorated.resolve(container, ...args);
+    resolve(container, options) {
+        return this.decorated.resolve(container, options);
     }
     pipe(...mappers) {
         return pipe(...mappers)(this);
@@ -39,4 +40,8 @@ export class ProviderDecorator {
         this.decorated.setArgs(argsFn);
         return this;
     }
+    setLazy(lazy) {
+        this.decorated.setLazy(lazy);
+        return this;
+    }
 }

package/esm/provider/LazyProvider.js

@@ -1,18 +1,12 @@
 import { ProviderDecorator } from './IProvider';
+import { lazyInstance } from '../utils';
 export class LazyProvider extends ProviderDecorator {
     constructor(provider) {
         super(provider);
         this.provider = provider;
     }
-    resolve(container, ...args) {
-        let instance;
-        return new Proxy({}, {
-            get: (_, prop) => {
-                instance = instance ?? this.provider.resolve(container, ...args);
-                // @ts-ignore
-                return instance[prop];
-            },
-        });
+    resolve(container, options) {
+        return lazyInstance(() => this.provider.resolve(container, options));
     }
 }
-export const lazy = (provider) => new LazyProvider(provider);
+export const makeProviderLazy = (provider) => new LazyProvider(provider);

package/esm/provider/Provider.js

@@ -1,9 +1,9 @@
-import { getTransformers } from './IProvider';
+import { getTransformers, } from './IProvider';
 import { isConstructor, pipe } from '../utils';
 export class Provider {
     static fromClass(Target) {
         const transformers = getTransformers(Target);
-        return new Provider((container, ...args) => container.resolve(Target, { args })).pipe(...transformers);
+        return new Provider((container, options) => container.resolve(Target, options)).pipe(...transformers);
     }
     static fromValue(value) {
         const mappers = isConstructor(value) ? getTransformers(value) ?? [] : [];
@@ -13,18 +13,26 @@ export class Provider {
         this.resolveDependency = resolveDependency;
         this.aliases = new Set();
         this.argsFn = () => [];
+        this.isLazy = false;
         this.isVisibleWhen = () => true;
     }
     pipe(...mappers) {
         return pipe(...mappers)(this);
     }
-    resolve(container, ...args) {
-        return this.resolveDependency(container, ...this.argsFn(container, ...args), ...args);
+    resolve(container, { args, lazy }) {
+        return this.resolveDependency(container, {
+            args: [...this.argsFn(container, ...args), ...args],
+            lazy: lazy ?? this.isLazy ?? false,
+        });
     }
     setVisibility(predicate) {
         this.isVisibleWhen = predicate;
         return this;
     }
+    setLazy(lazy) {
+        this.isLazy = lazy;
+        return this;
+    }
     setArgs(argsFn) {
         this.argsFn = argsFn;
         return this;

package/esm/provider/singleton/SingletonProvider.js

@@ -9,10 +9,10 @@ export class SingletonProvider extends ProviderDecorator {
         this.provider = provider;
         this.cache = cache;
     }
-    resolve(container, ...args) {
-        const key = this.cache.getKey(...args);
+    resolve(container, options) {
+        const key = this.cache.getKey(...options.args);
         if (!this.cache.hasValue(key)) {
-            this.cache.setValue(key, this.provider.resolve(container, ...args));
+            this.cache.setValue(key, this.provider.resolve(container, options));
         }
         return this.cache.getValue(key);
     }

package/esm/utils.js

@@ -11,3 +11,13 @@ export function fillEmptyIndexes(baseArr, insertArr) {
 }
 export const constant = (value) => () => value;
 export const isConstructor = (T) => typeof T === 'function' && !!T.prototype;
+export function lazyInstance(resolveInstance) {
+    let instance;
+    return new Proxy({}, {
+        get: (_, prop) => {
+            instance = instance ?? resolveInstance();
+            // @ts-ignore
+            return instance[prop];
+        },
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-ioc-container",
-  "version": "31.10.0",
+  "version": "32.0.0",
   "description": "Typescript IoC container",
   "publishConfig": {
     "access": "public",
@@ -59,5 +59,5 @@
     "ts-node": "^10.9.1",
     "typescript": "5.4.3"
   },
-  "gitHead": "af0d6c1a013ba9289fd62f21b9493719d02a330c"
+  "gitHead": "4bdbd1e91d3f7ea7b1b671bc2140d193748ce2a1"
 }

package/typings/by.d.ts

@@ -1,30 +1,39 @@
 import { DependencyKey, IContainer, InjectionToken } from './container/IContainer';
+import { ProviderResolveOptions } from './provider/IProvider';
 export type InstancePredicate = (dep: unknown) => boolean;
 export declare const all: InstancePredicate;
 export type IMemo = Map<string, DependencyKey[]>;
 export declare const IMemoKey: unique symbol;
 export declare const by: {
-    aliases: (predicate: (it: Set<string>, s: IContainer) => boolean, memoize?: ((c: IContainer) => string) | undefined) => (c: IContainer, ...args: unknown[]) => unknown[];
+    aliases: (predicate: (it: Set<string>, s: IContainer) => boolean, { memoize, lazy }?: {
+        memoize?: ((c: IContainer) => string) | undefined;
+        lazy?: boolean | undefined;
+    }) => (c: IContainer, ...args: unknown[]) => unknown[];
     /**
      * Get the instance that matches the given alias or fail
      * @param predicate
      * @param memoize
      */
-    alias: (predicate: (it: Set<string>, s: IContainer) => boolean, memoize?: ((c: IContainer) => string) | undefined) => (c: IContainer, ...args: unknown[]) => unknown;
+    alias: (predicate: (it: Set<string>, s: IContainer) => boolean, { memoize, lazy }?: {
+        memoize?: ((c: IContainer) => string) | undefined;
+        lazy?: boolean | undefined;
+    }) => (c: IContainer, ...args: unknown[]) => unknown;
     /**
      * Get all instances that match the given keys
      * @param keys
+     * @param lazy
      */
-    keys: (...keys: InjectionToken[]) => (с: IContainer, ...args: unknown[]) => unknown[];
+    keys: (keys: InjectionToken[], { lazy }?: Pick<ProviderResolveOptions, 'lazy'>) => (с: IContainer, ...args: unknown[]) => unknown[];
     /**
      * Get the instance that matches the given key
      * @param key
      * @param deps
+     * @param lazy
      */
-    key: <T>(key: InjectionToken<T>, ...deps: unknown[]) => (c: IContainer, ...args: unknown[]) => T;
-    lazy: {
-        key: <T_1 extends object>(key: InjectionToken<T_1>, ...deps: unknown[]) => (c: IContainer, ...args: unknown[]) => T_1;
-    };
+    key: <T>(key: InjectionToken<T>, { args: deps, lazy }?: {
+        args?: unknown[] | undefined;
+        lazy?: boolean | undefined;
+    }) => (c: IContainer, ...args: unknown[]) => T;
     /**
      * Get all instances that match the given predicate
      * @param predicate

package/typings/container/Container.d.ts

@@ -17,15 +17,16 @@ export declare class Container implements IContainer {
     });
     add(registration: IRegistration): this;
     register(key: DependencyKey, provider: IProvider): this;
-    resolve<T>(token: InjectionToken<T>, { args, child }?: ResolveOptions): T;
+    resolve<T>(token: InjectionToken<T>, { args, child, lazy }?: ResolveOptions): T;
+    private resolveByInjector;
     createScope(...tags: Tag[]): Container;
     dispose(): void;
     getInstances(): unknown[];
     hasTag(tag: Tag): boolean;
     use(module: IContainerModule): this;
     hasDependency(key: DependencyKey): boolean;
-    resolveManyByAlias(predicate: AliasPredicate, { args, child }?: ResolveOptions, result?: Map<DependencyKey, unknown>): Map<DependencyKey, unknown>;
-    resolveOneByAlias<T>(predicate: AliasPredicate, { args, child }?: ResolveOptions): [DependencyKey, T];
+    resolveManyByAlias(predicate: AliasPredicate, { args, child, lazy }?: ResolveOptions, result?: Map<DependencyKey, unknown>): Map<DependencyKey, unknown>;
+    resolveOneByAlias<T>(predicate: AliasPredicate, { args, child, lazy }?: ResolveOptions): [DependencyKey, T];
     /**
      * @private
      */

package/typings/container/IContainer.d.ts

@@ -9,6 +9,7 @@ export type InjectionToken<T = unknown> = constructor<T> | DependencyKey;
 export type ResolveOptions = {
     args?: unknown[];
     child?: Tagged;
+    lazy?: boolean;
 };
 export interface Resolvable {
     resolve<T>(key: InjectionToken<T>, options?: ResolveOptions): T;

package/typings/index.d.ts

@@ -6,12 +6,12 @@ export { IInjector } from './injector/IInjector';
 export { MetadataInjector, inject } from './injector/MetadataInjector';
 export { SimpleInjector } from './injector/SimpleInjector';
 export { ProxyInjector } from './injector/ProxyInjector';
-export { ResolveDependency, IProvider, provider, visible, alias, argsFn, args, ArgsFn, ProviderDecorator, } from './provider/IProvider';
+export { ResolveDependency, IProvider, provider, visible, alias, argsFn, args, ArgsFn, lazy, ProviderDecorator, } from './provider/IProvider';
 export { Provider } from './provider/Provider';
 export { singleton, SingletonProvider } from './provider/singleton/SingletonProvider';
 export { MultiCache, multiCache } from './provider/singleton/MultiCache';
 export { Cache } from './provider/singleton/Cache';
-export { lazy } from './provider/LazyProvider';
+export { makeProviderLazy } from './provider/LazyProvider';
 export { decorate, DecorateFn } from './provider/DecoratorProvider';
 export { key, IRegistration, scope, register } from './registration/IRegistration';
 export { Registration } from './registration/Registration';

package/typings/injector/IInjector.d.ts

@@ -1,5 +1,8 @@
 import { constructor } from '../utils';
 import { IContainer } from '../container/IContainer';
+export type InjectOptions = {
+    args: unknown[];
+};
 export interface IInjector {
-    resolve<T>(container: IContainer, value: constructor<T>, ...deps: unknown[]): T;
+    resolve<T>(container: IContainer, value: constructor<T>, options: InjectOptions): T;
 }

package/typings/injector/MetadataInjector.d.ts

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

package/typings/injector/ProxyInjector.d.ts

@@ -1,6 +1,6 @@
-import { IInjector } from './IInjector';
+import { IInjector, InjectOptions } from './IInjector';
 import { IContainer } from '../container/IContainer';
 import { constructor } from '../utils';
 export declare class ProxyInjector implements IInjector {
-    resolve<T>(container: IContainer, Target: constructor<T>, ...deps: object[]): T;
+    resolve<T>(container: IContainer, Target: constructor<T>, { args: deps }: InjectOptions): T;
 }

package/typings/injector/SimpleInjector.d.ts

@@ -1,6 +1,6 @@
-import { IInjector } from './IInjector';
+import { IInjector, InjectOptions } from './IInjector';
 import { IContainer } from '../container/IContainer';
 import { constructor } from '../utils';
 export declare class SimpleInjector implements IInjector {
-    resolve<T>(container: IContainer, Target: constructor<T>, ...deps: unknown[]): T;
+    resolve<T>(container: IContainer, Target: constructor<T>, { args: deps }: InjectOptions): T;
 }

package/typings/provider/DecoratorProvider.d.ts

@@ -1,10 +1,10 @@
 import { IContainer } from '../container/IContainer';
-import { IProvider, ProviderDecorator } from './IProvider';
+import { IProvider, ProviderDecorator, ProviderResolveOptions } from './IProvider';
 export type DecorateFn<Instance> = (dep: Instance, scope: IContainer) => Instance;
 export declare class DecoratorProvider<Instance> extends ProviderDecorator<Instance> {
     private provider;
     private decorateFn;
     constructor(provider: IProvider<Instance>, decorateFn: DecorateFn<Instance>);
-    resolve(scope: IContainer, ...args: unknown[]): Instance;
+    resolve(scope: IContainer, options: ProviderResolveOptions): Instance;
 }
 export declare const decorate: <Instance>(decorateFn: DecorateFn<Instance>) => (provider: IProvider<Instance>) => DecoratorProvider<Instance>;

package/typings/provider/IProvider.d.ts

@@ -1,6 +1,10 @@
 import { Alias, AliasPredicate, IContainer, Tagged } from '../container/IContainer';
 import { constructor, MapFn } from '../utils';
-export type ResolveDependency<T = unknown> = (container: IContainer, ...args: unknown[]) => T;
+export type ProviderResolveOptions = {
+    args: unknown[];
+    lazy?: boolean;
+};
+export type ResolveDependency<T = unknown> = (container: IContainer, options: ProviderResolveOptions) => T;
 export type ChildrenVisibilityPredicate = (options: {
     child: Tagged;
     isParent: boolean;
@@ -8,14 +12,16 @@ export type ChildrenVisibilityPredicate = (options: {
 export type ArgsFn = (l: IContainer, ...args: unknown[]) => unknown[];
 export declare function args<T = unknown>(...extraArgs: unknown[]): MapFn<IProvider<T>>;
 export declare function argsFn<T = unknown>(fn: ArgsFn): MapFn<IProvider<T>>;
+export declare const lazy: <T>(provider: IProvider<T>) => IProvider<T>;
 export interface IProvider<T = unknown> {
-    resolve(container: IContainer, ...args: unknown[]): T;
+    resolve(container: IContainer, options: ProviderResolveOptions): T;
     isVisible(parent: Tagged, child: Tagged): boolean;
     pipe(...mappers: MapFn<IProvider<T>>[]): IProvider<T>;
     setVisibility(isVisibleWhen: ChildrenVisibilityPredicate): this;
     setArgs(argsFn: ArgsFn): this;
     matchAliases(predicate: AliasPredicate): boolean;
     addAliases(...aliases: Alias[]): this;
+    setLazy(lazy: boolean): this;
 }
 export declare const provider: (...mappers: MapFn<IProvider>[]) => ClassDecorator;
 export declare const getTransformers: <T>(Target: constructor<T>) => MapFn<IProvider<T>>[];
@@ -26,9 +32,10 @@ export declare abstract class ProviderDecorator<T> implements IProvider<T> {
     protected constructor(decorated: IProvider<T>);
     setVisibility(predicate: ChildrenVisibilityPredicate): this;
     isVisible(parent: IContainer, child: Tagged): boolean;
-    resolve(container: IContainer, ...args: unknown[]): T;
+    resolve(container: IContainer, options: ProviderResolveOptions): T;
     pipe(...mappers: MapFn<IProvider<T>>[]): IProvider<T>;
     matchAliases(predicate: AliasPredicate): boolean;
     addAliases(...aliases: Alias[]): this;
     setArgs(argsFn: ArgsFn): this;
+    setLazy(lazy: boolean): this;
 }

package/typings/provider/LazyProvider.d.ts

@@ -1,8 +1,8 @@
-import { IProvider, ProviderDecorator } from './IProvider';
+import { IProvider, ProviderDecorator, ProviderResolveOptions } from './IProvider';
 import { IContainer } from '../container/IContainer';
 export declare class LazyProvider<Instance> extends ProviderDecorator<Instance> {
     private provider;
     constructor(provider: IProvider<Instance>);
-    resolve(container: IContainer, ...args: unknown[]): Instance;
+    resolve(container: IContainer, options: ProviderResolveOptions): Instance;
 }
-export declare const lazy: <Instance>(provider: IProvider<Instance>) => LazyProvider<Instance>;
+export declare const makeProviderLazy: <Instance>(provider: IProvider<Instance>) => LazyProvider<Instance>;

package/typings/provider/Provider.d.ts

@@ -1,4 +1,4 @@
-import { ArgsFn, ChildrenVisibilityPredicate, IProvider, ResolveDependency } from './IProvider';
+import { ArgsFn, ChildrenVisibilityPredicate, IProvider, ProviderResolveOptions, ResolveDependency } from './IProvider';
 import { Alias, AliasPredicate, IContainer, Tagged } from '../container/IContainer';
 import { constructor, MapFn } from '../utils';
 export declare class Provider<T> implements IProvider<T> {
@@ -7,11 +7,13 @@ export declare class Provider<T> implements IProvider<T> {
     static fromValue<T>(value: T): IProvider<T>;
     private readonly aliases;
     private argsFn;
+    private isLazy;
     private isVisibleWhen;
     constructor(resolveDependency: ResolveDependency<T>);
     pipe(...mappers: MapFn<IProvider<T>>[]): IProvider<T>;
-    resolve(container: IContainer, ...args: unknown[]): T;
+    resolve(container: IContainer, { args, lazy }: ProviderResolveOptions): T;
     setVisibility(predicate: ChildrenVisibilityPredicate): this;
+    setLazy(lazy: boolean): this;
     setArgs(argsFn: ArgsFn): this;
     isVisible(parent: Tagged, child: Tagged): boolean;
     matchAliases(predicate: AliasPredicate): boolean;

package/typings/provider/singleton/SingletonProvider.d.ts

@@ -1,5 +1,5 @@
 import { IContainer } from '../../container/IContainer';
-import { IProvider, ProviderDecorator } from '../IProvider';
+import { IProvider, ProviderDecorator, ProviderResolveOptions } from '../IProvider';
 import { MapFn } from '../../utils';
 import { Cache } from './Cache';
 export declare function singleton<T = unknown>(cacheProvider?: () => Cache<unknown, T>): MapFn<IProvider<T>>;
@@ -7,5 +7,5 @@ export declare class SingletonProvider<T> extends ProviderDecorator<T> {
     private readonly provider;
     private readonly cache;
     constructor(provider: IProvider<T>, cache: Cache<unknown, T>);
-    resolve(container: IContainer, ...args: unknown[]): T;
+    resolve(container: IContainer, options: ProviderResolveOptions): T;
 }

package/typings/utils.d.ts

@@ -4,3 +4,4 @@ export declare const pipe: <T>(...mappers: MapFn<T>[]) => MapFn<T>;
 export declare function fillEmptyIndexes<T>(baseArr: (T | undefined)[], insertArr: T[]): T[];
 export declare const constant: <T>(value: T) => () => T;
 export declare const isConstructor: (T: unknown) => T is constructor<unknown>;
+export declare function lazyInstance<T>(resolveInstance: () => T): T;