ts-ioc-container 32.0.0 → 32.0.2

package/README.md

@@ -25,6 +25,7 @@
     - [Scope](#scope) `tags`
     - [Instances](#instances)
     - [Dispose](#dispose)
+    - [Lazy](#lazy)
 - [Injector](#injector)
     - [Metadata](#metadata) `@inject`
     - [Simple](#simple)
@@ -34,7 +35,7 @@
     - [Arguments](#arguments) `args`
     - [Visibility](#visibility) `visible`
     - [Alias](#alias) `alias`
-    - [Lazy](#lazy) `lazy`
+    - [Decorator](#decorator)
 - [Registration](#registration) `@register`
     - [Key](#key) `key`
     - [Scope](#scope) `scope`
@@ -251,6 +252,102 @@ describe('Disposing', function () {
 
 ```
 
+### Lazy
+Sometimes you want to create dependency only when somebody want to invoke it's method or property. This is what `lazy` is for.
+
+```typescript
+import { by, Container, inject, MetadataInjector, provider, Registration as R, singleton } from 'ts-ioc-container';
+
+describe('lazy provider', () => {
+  @provider(singleton())
+  class Flag {
+    isSet = false;
+
+    set() {
+      this.isSet = true;
+    }
+  }
+
+  class Service {
+    name = 'Service';
+
+    constructor(@inject(by.key('Flag')) private flag: Flag) {
+      this.flag.set();
+    }
+
+    greet() {
+      return 'Hello';
+    }
+  }
+
+  class App {
+    constructor(@inject(by.key('Service', { lazy: true })) public service: Service) {}
+
+    run() {
+      return this.service.greet();
+    }
+  }
+
+  function createContainer() {
+    const container = new Container(new MetadataInjector());
+    container.add(R.fromClass(Flag)).add(R.fromClass(Service));
+    return container;
+  }
+
+  it('should not create an instance until method is not invoked', () => {
+    // Arrange
+    const container = createContainer();
+
+    // Act
+    const app = container.resolve(App);
+    const flag = container.resolve<Flag>('Flag');
+
+    // Assert
+    expect(flag.isSet).toBe(false);
+  });
+
+  it('should create an instance only when some method/property is invoked', () => {
+    // Arrange
+    const container = createContainer();
+
+    // Act
+    const app = container.resolve(App);
+    const flag = container.resolve<Flag>('Flag');
+
+    // Assert
+    expect(app.run()).toBe('Hello');
+    expect(flag.isSet).toBe(true);
+  });
+
+  it('should not create instance on every method invoked', () => {
+    // Arrange
+    const container = createContainer();
+
+    // Act
+    const app = container.resolve(App);
+
+    // Assert
+    expect(app.run()).toBe('Hello');
+    expect(app.run()).toBe('Hello');
+    expect(container.getInstances().filter((x) => x instanceof Service).length).toBe(1);
+  });
+
+  it('should create instance when property is invoked', () => {
+    // Arrange
+    const container = createContainer();
+
+    // Act
+    const app = container.resolve(App);
+    const flag = container.resolve<Flag>('Flag');
+
+    // Assert
+    expect(app.service.name).toBe('Service');
+    expect(flag.isSet).toBe(true);
+  });
+});
+
+```
+
 ## Injector
 `IInjector` is used to describe how dependencies should be injected to constructor.
 
@@ -810,91 +907,96 @@ describe('alias', () => {
 
 ```
 
-### Lazy
-Sometimes you want to create dependency only when somebody want to invoke it's method or property. This is what `LazyProvider` is for.
-- `@provider(lazy)`
+### Decorator
+Sometimes you want to decorate you class with some logic. This is what `DecoratorProvider` is for.
+- `@provider(decorate((instance, container) => new LoggerDecorator(instance)))`
 
 ```typescript
-import { lazy, Container, inject, MetadataInjector, provider, Registration as R, singleton, by } from 'ts-ioc-container';
+import {
+  by,
+  Container,
+  decorate,
+  IContainer,
+  inject,
+  key,
+  MetadataInjector,
+  provider,
+  register,
+  Registration as R,
+  singleton,
+} from 'ts-ioc-container';
 
 describe('lazy provider', () => {
   @provider(singleton())
-  class Flag {
-    isSet = false;
-
-    set() {
-      this.isSet = true;
-    }
-  }
-
-  @provider(lazy)
-  class Service {
-    name = 'Service';
+  class Logger {
+    private logs: string[] = [];
 
-    constructor(@inject(by.key('Flag')) private flag: Flag) {
-      this.flag.set();
+    log(message: string) {
+      this.logs.push(message);
     }
 
-    greet() {
-      return 'Hello';
+    printLogs() {
+      return this.logs.join(',');
     }
   }
 
-  function createContainer() {
-    const container = new Container(new MetadataInjector());
-    container.add(R.fromClass(Flag)).add(R.fromClass(Service));
-    return container;
+  interface IRepository {
+    save(item: Todo): Promise<void>;
   }
 
-  it('should not create an instance until method is not invoked', () => {
-    // Arrange
-    const container = createContainer();
-
-    // Act
-    const service = container.resolve<Service>('Service');
-    const flag = container.resolve<Flag>('Flag');
+  interface Todo {
+    id: string;
+    text: string;
+  }
 
-    // Assert
-    expect(flag.isSet).toBe(false);
-  });
+  class LogRepository implements IRepository {
+    constructor(
+      private repository: IRepository,
+      @inject(by.key('Logger')) private logger: Logger,
+    ) {}
 
-  it('should create an instance only when some method/property is invoked', () => {
-    // Arrange
-    const container = createContainer();
+    async save(item: Todo): Promise<void> {
+      this.logger.log(item.id);
+      return this.repository.save(item);
+    }
+  }
 
-    // Act
-    const service = container.resolve<Service>('Service');
-    const flag = container.resolve<Flag>('Flag');
+  const logRepo = (dep: IRepository, scope: IContainer) => scope.resolve(LogRepository, { args: [dep] });
 
-    // Assert
-    expect(service.greet()).toBe('Hello');
-    expect(flag.isSet).toBe(true);
-  });
+  @register(key('IRepository'))
+  @provider(decorate(logRepo))
+  class TodoRepository implements IRepository {
+    async save(item: Todo): Promise<void> {
+      console.log('Saving todo item', item);
+    }
+  }
 
-  it('should not create instance on every method invoked', () => {
-    // Arrange
-    const container = createContainer();
+  class App {
+    constructor(@inject(by.key('IRepository')) public repository: IRepository) {}
 
-    // Act
-    const service = container.resolve<Service>('Service');
+    async run() {
+      await this.repository.save({ id: '1', text: 'Hello' });
+      await this.repository.save({ id: '2', text: 'Hello' });
+    }
+  }
 
-    // Assert
-    expect(service.greet()).toBe('Hello');
-    expect(service.greet()).toBe('Hello');
-    expect(container.getInstances().filter((x) => x instanceof Service).length).toBe(1);
-  });
+  function createContainer() {
+    const container = new Container(new MetadataInjector());
+    container.add(R.fromClass(TodoRepository)).add(R.fromClass(Logger));
+    return container;
+  }
 
-  it('should create instance when property is invoked', () => {
+  it('should decorate repo by logger middleware', async () => {
     // Arrange
     const container = createContainer();
 
     // Act
-    const service = container.resolve<Service>('Service');
-    const flag = container.resolve<Flag>('Flag');
+    const app = container.resolve(App);
+    const logger = container.resolve<Logger>('Logger');
+    await app.run();
 
     // Assert
-    expect(service.name).toBe('Service');
-    expect(flag.isSet).toBe(true);
+    expect(logger.printLogs()).toBe('1,2');
   });
 });
 

package/cjm/container/Container.js

@@ -4,7 +4,6 @@ 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;
@@ -29,20 +28,15 @@ class Container {
     resolve(token, { args = [], child = this, lazy } = {}) {
         this.validateContainer();
         if ((0, IContainer_1.isConstructor)(token)) {
-            return lazy
-                ? (0, utils_1.lazyInstance)(() => this.resolveByInjector(token, { args }))
-                : this.resolveByInjector(token, { args });
+            const instance = this.injector.resolve(this, token, { args });
+            this.instances.add(instance);
+            return instance;
         }
         const provider = this.providers.get(token);
         return provider?.isVisible(this, 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();
         const scope = new Container(this.injector, { parent: this, tags });

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.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;
+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.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;
 // Containers
 var IContainer_1 = require("./container/IContainer");
 Object.defineProperty(exports, "isDependencyKey", { enumerable: true, get: function () { return IContainer_1.isDependencyKey; } });
@@ -24,7 +24,6 @@ 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,8 +33,6 @@ Object.defineProperty(exports, "SingletonProvider", { enumerable: true, get: fun
 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, "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/provider/DecoratorProvider.js

@@ -8,7 +8,7 @@ class DecoratorProvider extends IProvider_1.ProviderDecorator {
         this.provider = provider;
         this.decorateFn = decorateFn;
     }
-    resolve(scope, options) {
+    resolveInstantly(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.lazy = exports.argsFn = exports.args = void 0;
+exports.ProviderDecorator = exports.visible = exports.alias = exports.getTransformers = exports.provider = exports.argsFn = exports.args = void 0;
 const utils_1 = require("../utils");
 const metadata_1 = require("../metadata");
 function args(...extraArgs) {
@@ -11,8 +11,6 @@ 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;
@@ -34,7 +32,7 @@ class ProviderDecorator {
         return this.decorated.isVisible(parent, child);
     }
     resolve(container, options) {
-        return this.decorated.resolve(container, options);
+        return (0, utils_1.lazyInstance)(() => this.resolveInstantly(container, options), options.lazy);
     }
     pipe(...mappers) {
         return (0, utils_1.pipe)(...mappers)(this);
@@ -50,9 +48,5 @@ class ProviderDecorator {
         this.decorated.setArgs(argsFn);
         return this;
     }
-    setLazy(lazy) {
-        this.decorated.setLazy(lazy);
-        return this;
-    }
 }
 exports.ProviderDecorator = ProviderDecorator;

package/cjm/provider/Provider.js

@@ -16,26 +16,18 @@ 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, lazy }) {
-        return this.resolveDependency(container, {
-            args: [...this.argsFn(container, ...args), ...args],
-            lazy: lazy ?? this.isLazy ?? false,
-        });
+        return (0, utils_1.lazyInstance)(() => this.resolveDependency(container, { args: [...this.argsFn(container, ...args), ...args] }), lazy);
     }
     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,7 +13,7 @@ class SingletonProvider extends IProvider_1.ProviderDecorator {
         this.provider = provider;
         this.cache = cache;
     }
-    resolve(container, options) {
+    resolveInstantly(container, options) {
         const key = this.cache.getKey(...options.args);
         if (!this.cache.hasValue(key)) {
             this.cache.setValue(key, this.provider.resolve(container, options));

package/cjm/utils.js

@@ -18,7 +18,10 @@ const constant = (value) => () => value;
 exports.constant = constant;
 const isConstructor = (T) => typeof T === 'function' && !!T.prototype;
 exports.isConstructor = isConstructor;
-function lazyInstance(resolveInstance) {
+function lazyInstance(resolveInstance, isLazy) {
+    if (!isLazy) {
+        return resolveInstance();
+    }
     let instance;
     return new Proxy({}, {
         get: (_, prop) => {

package/esm/container/Container.js

@@ -1,7 +1,6 @@
 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;
@@ -26,20 +25,15 @@ export class Container {
     resolve(token, { args = [], child = this, lazy } = {}) {
         this.validateContainer();
         if (isConstructor(token)) {
-            return lazy
-                ? lazyInstance(() => this.resolveByInjector(token, { args }))
-                : this.resolveByInjector(token, { args });
+            const instance = this.injector.resolve(this, token, { args });
+            this.instances.add(instance);
+            return instance;
         }
         const provider = this.providers.get(token);
         return provider?.isVisible(this, 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();
         const scope = new Container(this.injector, { parent: this, tags });

package/esm/index.js

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

package/esm/provider/DecoratorProvider.js

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

package/esm/provider/IProvider.js

@@ -1,4 +1,4 @@
-import { pipe } from '../utils';
+import { lazyInstance, pipe } from '../utils';
 import { getMetadata, setMetadata } from '../metadata';
 export function args(...extraArgs) {
     return (provider) => provider.setArgs(() => extraArgs);
@@ -6,7 +6,6 @@ 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) ?? [];
@@ -24,7 +23,7 @@ export class ProviderDecorator {
         return this.decorated.isVisible(parent, child);
     }
     resolve(container, options) {
-        return this.decorated.resolve(container, options);
+        return lazyInstance(() => this.resolveInstantly(container, options), options.lazy);
     }
     pipe(...mappers) {
         return pipe(...mappers)(this);
@@ -40,8 +39,4 @@ export class ProviderDecorator {
         this.decorated.setArgs(argsFn);
         return this;
     }
-    setLazy(lazy) {
-        this.decorated.setLazy(lazy);
-        return this;
-    }
 }

package/esm/provider/Provider.js

@@ -1,5 +1,5 @@
 import { getTransformers, } from './IProvider';
-import { isConstructor, pipe } from '../utils';
+import { isConstructor, lazyInstance, pipe } from '../utils';
 export class Provider {
     static fromClass(Target) {
         const transformers = getTransformers(Target);
@@ -13,26 +13,18 @@ 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, lazy }) {
-        return this.resolveDependency(container, {
-            args: [...this.argsFn(container, ...args), ...args],
-            lazy: lazy ?? this.isLazy ?? false,
-        });
+        return lazyInstance(() => this.resolveDependency(container, { args: [...this.argsFn(container, ...args), ...args] }), lazy);
     }
     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,7 +9,7 @@ export class SingletonProvider extends ProviderDecorator {
         this.provider = provider;
         this.cache = cache;
     }
-    resolve(container, options) {
+    resolveInstantly(container, options) {
         const key = this.cache.getKey(...options.args);
         if (!this.cache.hasValue(key)) {
             this.cache.setValue(key, this.provider.resolve(container, options));

package/esm/utils.js

@@ -11,7 +11,10 @@ export function fillEmptyIndexes(baseArr, insertArr) {
 }
 export const constant = (value) => () => value;
 export const isConstructor = (T) => typeof T === 'function' && !!T.prototype;
-export function lazyInstance(resolveInstance) {
+export function lazyInstance(resolveInstance, isLazy) {
+    if (!isLazy) {
+        return resolveInstance();
+    }
     let instance;
     return new Proxy({}, {
         get: (_, prop) => {

package/package.json

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

package/typings/container/Container.d.ts

@@ -18,7 +18,6 @@ export declare class Container implements IContainer {
     add(registration: IRegistration): this;
     register(key: DependencyKey, provider: IProvider): this;
     resolve<T>(token: InjectionToken<T>, { args, child, lazy }?: ResolveOptions): T;
-    private resolveByInjector;
     createScope(...tags: Tag[]): Container;
     dispose(): void;
     getInstances(): unknown[];

package/typings/index.d.ts

@@ -6,12 +6,11 @@ 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, lazy, ProviderDecorator, } from './provider/IProvider';
+export { ResolveDependency, IProvider, provider, visible, alias, argsFn, args, ArgsFn, ProviderDecorator, InstantDependencyOptions, ProviderResolveOptions, } 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 { 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/provider/DecoratorProvider.d.ts

@@ -1,10 +1,10 @@
 import { IContainer } from '../container/IContainer';
-import { IProvider, ProviderDecorator, ProviderResolveOptions } from './IProvider';
+import { InstantDependencyOptions, IProvider, ProviderDecorator } 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, options: ProviderResolveOptions): Instance;
+    resolveInstantly(scope: IContainer, options: InstantDependencyOptions): Instance;
 }
 export declare const decorate: <Instance>(decorateFn: DecorateFn<Instance>) => (provider: IProvider<Instance>) => DecoratorProvider<Instance>;

package/typings/provider/IProvider.d.ts

@@ -4,6 +4,7 @@ export type ProviderResolveOptions = {
     args: unknown[];
     lazy?: boolean;
 };
+export type InstantDependencyOptions = Omit<ProviderResolveOptions, 'lazy'>;
 export type ResolveDependency<T = unknown> = (container: IContainer, options: ProviderResolveOptions) => T;
 export type ChildrenVisibilityPredicate = (options: {
     child: Tagged;
@@ -12,7 +13,6 @@ 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, options: ProviderResolveOptions): T;
     isVisible(parent: Tagged, child: Tagged): boolean;
@@ -21,9 +21,8 @@ export interface IProvider<T = unknown> {
     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 provider: <Instance>(...mappers: MapFn<IProvider<Instance>>[]) => ClassDecorator;
 export declare const getTransformers: <T>(Target: constructor<T>) => MapFn<IProvider<T>>[];
 export declare const alias: (...aliases: Alias[]) => MapFn<IProvider>;
 export declare const visible: (isVisibleWhen: ChildrenVisibilityPredicate) => MapFn<IProvider>;
@@ -33,9 +32,9 @@ export declare abstract class ProviderDecorator<T> implements IProvider<T> {
     setVisibility(predicate: ChildrenVisibilityPredicate): this;
     isVisible(parent: IContainer, child: Tagged): boolean;
     resolve(container: IContainer, options: ProviderResolveOptions): T;
+    protected abstract resolveInstantly(container: IContainer, options: InstantDependencyOptions): 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/Provider.d.ts

@@ -7,13 +7,11 @@ 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, 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, ProviderResolveOptions } from '../IProvider';
+import { InstantDependencyOptions, IProvider, ProviderDecorator } 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, options: ProviderResolveOptions): T;
+    resolveInstantly(container: IContainer, options: InstantDependencyOptions): T;
 }

package/typings/utils.d.ts

@@ -4,4 +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;
+export declare function lazyInstance<T>(resolveInstance: () => T, isLazy?: boolean): T;

package/cjm/provider/LazyProvider.js

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-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, options) {
-        return (0, utils_1.lazyInstance)(() => this.provider.resolve(container, options));
-    }
-}
-exports.LazyProvider = LazyProvider;
-const makeProviderLazy = (provider) => new LazyProvider(provider);
-exports.makeProviderLazy = makeProviderLazy;

package/esm/provider/LazyProvider.js

@@ -1,12 +0,0 @@
-import { ProviderDecorator } from './IProvider';
-import { lazyInstance } from '../utils';
-export class LazyProvider extends ProviderDecorator {
-    constructor(provider) {
-        super(provider);
-        this.provider = provider;
-    }
-    resolve(container, options) {
-        return lazyInstance(() => this.provider.resolve(container, options));
-    }
-}
-export const makeProviderLazy = (provider) => new LazyProvider(provider);

package/typings/provider/LazyProvider.d.ts

@@ -1,8 +0,0 @@
-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, options: ProviderResolveOptions): Instance;
-}
-export declare const makeProviderLazy: <Instance>(provider: IProvider<Instance>) => LazyProvider<Instance>;