ts-ioc-container 41.0.0 → 41.1.1

package/README.md

@@ -522,7 +522,6 @@ describe('ProxyInjector', function () {
     mockContainer.addRegistration(R.fromClass(Service).bindToKey('service'));
 
     const app = mockContainer.resolveOne(App);
-    console.log('App loggers:', app.loggers);
     expect(app.loggers).toBeInstanceOf(Array);
     expect(app.loggers.length).toBe(1);
     expect(app.loggers[0]).toBe(mockLogger);
@@ -543,34 +542,37 @@ Provider is dependency factory which creates dependency.
 
 ```typescript
 import 'reflect-metadata';
-import { args, argsFn, Container, Provider, scopeAccess, singleton } from 'ts-ioc-container';
+import {
+  args,
+  argsFn,
+  Container,
+  inject,
+  Provider,
+  scopeAccess,
+  singleton,
+  Registration as R,
+  register,
+  asKey,
+  lazy,
+  by,
+} from 'ts-ioc-container';
 
 class Logger {}
+
 class ConfigService {
   constructor(private readonly configPath: string) {}
+
   getPath(): string {
     return this.configPath;
   }
 }
+
 class UserService {}
 
 class TestClass {}
 
 class ClassWithoutTransformers {}
 
-jest.mock('../../lib/provider/IProvider', () => {
-  const originalModule = jest.requireActual('../../lib/provider/IProvider');
-  return {
-    ...originalModule,
-    getTransformers: jest.fn().mockImplementation((target) => {
-      if (target === ClassWithoutTransformers) {
-        return null;
-      }
-      return originalModule.getTransformers(target);
-    }),
-  };
-});
-
 describe('Provider', () => {
   it('can be registered as a function', () => {
     const container = new Container().register('ILogger', new Provider(() => new Logger()));
@@ -719,6 +721,97 @@ describe('Provider', () => {
     const result = container.resolveOne('NoTransformers');
     expect(result).toBe(ClassWithoutTransformers);
   });
+
+  it('allows to register lazy provider', () => {
+    let isLoggerCreated = false;
+
+    @register(asKey('Logger'), lazy())
+    class Logger {
+      private logs: string[] = [];
+
+      constructor() {
+        isLoggerCreated = true;
+      }
+
+      info(message: string, context: Record<string, unknown>): void {
+        this.logs.push(JSON.stringify({ ...context, level: 'info', message }));
+      }
+
+      serialize(): string {
+        return this.logs.join('\n');
+      }
+    }
+
+    class Main {
+      constructor(@inject('Logger') private logger: Logger) {}
+
+      getLogs(): string {
+        return this.logger.serialize();
+      }
+    }
+
+    const root = new Container({ tags: ['root'] }).addRegistration(R.fromClass(Logger));
+    const main = root.resolveClass(Main);
+
+    expect(isLoggerCreated).toBe(false);
+
+    main.getLogs();
+
+    expect(isLoggerCreated).toBe(true);
+  });
+
+  it('allows to resolve with args', () => {
+    @register(asKey('ILogger'))
+    class Logger {
+      readonly channel: string;
+
+      constructor(options: { channel: string }) {
+        this.channel = options.channel;
+      }
+    }
+
+    class Main {
+      constructor(@inject(by.one('ILogger').args({ channel: 'file' })) private logger: Logger) {}
+
+      getChannel(): string {
+        return this.logger.channel;
+      }
+    }
+
+    const root = new Container({ tags: ['root'] }).addRegistration(R.fromClass(Logger));
+    const main = root.resolveClass(Main);
+
+    expect(main.getChannel()).toBe('file');
+  });
+
+  it('allows to resolve with argsFn', () => {
+    @register(asKey('ILogger'))
+    class Logger {
+      readonly channel: string;
+
+      constructor(options: { channel: string }) {
+        this.channel = options.channel;
+      }
+    }
+
+    class Main {
+      constructor(
+        @inject(by.one('ILogger').argsFn((s) => [{ channel: s.resolveOne('channel') }])) private logger: Logger,
+      ) {}
+
+      getChannel(): string {
+        return this.logger.channel;
+      }
+    }
+
+    const root = new Container({ tags: ['root'] })
+      .addRegistration(R.fromValue('file').bindToKey('channel'))
+      .addRegistration(R.fromClass(Logger));
+
+    const main = root.resolveClass(Main);
+
+    expect(main.getChannel()).toBe('file');
+  });
 });
 
 ```
@@ -1458,7 +1551,7 @@ export class MoqContainer extends AutoMockedContainer {
     return this.mocks.get(key) as IMock<T>;
   }
 
-  resolveByClass<T>(target: any, options?: { args?: unknown[] }): T {
+  resolveClass<T>(target: any, options?: { args?: unknown[] }): T {
     throw new Error('Method not implemented.');
   }
 

package/cjm/container/AliasMap.js

@@ -5,7 +5,7 @@ const utils_1 = require("../utils");
 class AliasMap {
     aliasToKeySet = new Map();
     deleteKeyFromAliases(key) {
-        for (const [depKey, aliasSet] of [...this.aliasToKeySet].filter(([k, aliasSet]) => aliasSet.has(key))) {
+        for (const [depKey, aliasSet] of [...this.aliasToKeySet].filter(([, aliasSet]) => aliasSet.has(key))) {
             aliasSet.delete(key);
             if (aliasSet.size === 0) {
                 this.aliasToKeySet.delete(depKey);

package/cjm/container/Container.js

@@ -6,32 +6,34 @@ const EmptyContainer_1 = require("./EmptyContainer");
 const ContainerDisposedError_1 = require("../errors/ContainerDisposedError");
 const MetadataInjector_1 = require("../injector/MetadataInjector");
 const utils_1 = require("../utils");
-const ProviderMap_1 = require("./ProviderMap");
 const AliasMap_1 = require("./AliasMap");
+const DependencyNotFoundError_1 = require("../errors/DependencyNotFoundError");
 class Container {
     isDisposed = false;
     parent;
     scopes = new Set();
     instances = new Set();
     tags;
-    providerMap = new ProviderMap_1.ProviderMap();
-    aliasMap = new AliasMap_1.AliasMap();
+    providers = new Map();
+    aliases = new AliasMap_1.AliasMap();
     registrations = new Set();
     onConstruct;
     onDispose;
     injector;
+    resolveOneStrategy;
     constructor(options = {}) {
         this.injector = options.injector ?? new MetadataInjector_1.MetadataInjector();
         this.parent = options.parent ?? new EmptyContainer_1.EmptyContainer();
         this.tags = new Set(options.tags ?? []);
         this.onConstruct = options.onConstruct ?? (() => { });
         this.onDispose = options.onDispose ?? (() => { });
+        this.resolveOneStrategy = options.resolveOneStrategy ?? IContainer_1.DEFAULT_CONTAINER_RESOLVER;
     }
     register(key, provider, { aliases = [] } = {}) {
         this.validateContainer();
-        this.providerMap.register(key, provider);
-        this.aliasMap.deleteKeyFromAliases(key);
-        this.aliasMap.addAliases(key, aliases);
+        this.providers.set(key, provider);
+        this.aliases.deleteKeyFromAliases(key);
+        this.aliases.addAliases(key, aliases);
         return this;
     }
     addRegistration(registration) {
@@ -42,7 +44,7 @@ class Container {
     getRegistrations() {
         return [...this.parent.getRegistrations(), ...this.registrations];
     }
-    resolveByClass(token, { args = [] } = {}) {
+    resolveClass(token, { args = [] } = {}) {
         this.validateContainer();
         const instance = this.injector.resolve(this, token, { args });
         this.instances.add(instance);
@@ -50,19 +52,19 @@ class Container {
         return instance;
     }
     resolveOne(keyOrAlias, options) {
-        return (0, IContainer_1.DEFAULT_CONTAINER_RESOLVER)(this, keyOrAlias, options);
+        return this.resolveOneStrategy(this, keyOrAlias, options);
     }
     resolveOneByKey(keyOrAlias, { args = [], child = this, lazy } = {}) {
         this.validateContainer();
-        const provider = this.providerMap.findOneByKey(keyOrAlias);
+        const provider = this.providers.get(keyOrAlias);
         return provider?.hasAccess({ invocationScope: child, providerScope: this })
             ? provider.resolve(this, { args, lazy })
             : this.parent.resolveOneByKey(keyOrAlias, { args, child, lazy });
     }
     resolveOneByAlias(keyOrAlias, { args = [], child = this, lazy } = {}) {
         this.validateContainer();
-        const key = this.aliasMap.findLastKeyByAlias(keyOrAlias);
-        const provider = key !== undefined ? this.providerMap.findOneByKeyOrFail(key) : undefined;
+        const key = this.aliases.findLastKeyByAlias(keyOrAlias);
+        const provider = key !== undefined ? this.findProviderByKeyOrFail(key) : undefined;
         return provider?.hasAccess({ invocationScope: child, providerScope: this })
             ? provider.resolve(this, { args, lazy })
             : this.parent.resolveOneByAlias(keyOrAlias, { args, child, lazy });
@@ -71,8 +73,8 @@ class Container {
         this.validateContainer();
         const keys = [];
         const deps = [];
-        for (const key of this.aliasMap.findManyKeysByAlias(alias).filter(utils_1.Filter.exclude(excludedKeys))) {
-            const provider = this.providerMap.findOneByKeyOrFail(key);
+        for (const key of this.aliases.findManyKeysByAlias(alias).filter(utils_1.Filter.exclude(excludedKeys))) {
+            const provider = this.findProviderByKeyOrFail(key);
             if (!provider.hasAccess({ invocationScope: child, providerScope: this })) {
                 continue;
             }
@@ -126,8 +128,8 @@ class Container {
         this.parent.removeScope(this);
         this.parent = new EmptyContainer_1.EmptyContainer();
         // Reset the state
-        this.providerMap.destroy();
-        this.aliasMap.destroy();
+        this.providers.clear();
+        this.aliases.destroy();
         this.instances.clear();
         this.registrations.clear();
         this.onDispose(this);
@@ -145,5 +147,11 @@ class Container {
             throw new ContainerDisposedError_1.ContainerDisposedError('Container is already disposed');
         }
     }
+    findProviderByKeyOrFail(key) {
+        if (!this.providers.has(key)) {
+            throw new DependencyNotFoundError_1.DependencyNotFoundError(`Provider ${key.toString()} does not exist`);
+        }
+        return this.providers.get(key);
+    }
 }
 exports.Container = Container;

package/cjm/container/EmptyContainer.js

@@ -10,7 +10,7 @@ class EmptyContainer {
     getParent() {
         return undefined;
     }
-    resolveByClass(token, options) {
+    resolveClass(token, options) {
         throw new MethodNotImplementedError_1.MethodNotImplementedError();
     }
     getScopes() {

package/cjm/container/IContainer.js

@@ -9,7 +9,7 @@ function isDependencyKey(token) {
 }
 const DEFAULT_CONTAINER_RESOLVER = (scope, keyOrAlias, options) => {
     if ((0, utils_1.isConstructor)(keyOrAlias)) {
-        return scope.resolveByClass(keyOrAlias, options);
+        return scope.resolveClass(keyOrAlias, options);
     }
     try {
         return scope.resolveOneByKey(keyOrAlias, options);

package/cjm/injector/inject.js

@@ -17,7 +17,7 @@ const toInjectFn = (target) => {
         return (s) => target.resolve(s);
     }
     if ((0, utils_1.isConstructor)(target)) {
-        return (scope) => scope.resolveByClass(target);
+        return (scope) => scope.resolveClass(target);
     }
     if ((0, IContainer_1.isDependencyKey)(target)) {
         return (scope) => scope.resolveOne(target);

package/cjm/provider/Provider.js

@@ -6,7 +6,7 @@ const ProviderPipe_1 = require("./ProviderPipe");
 class Provider {
     resolveDependency;
     static fromClass(Target) {
-        return new Provider((container, options) => container.resolveByClass(Target, options));
+        return new Provider((container, options) => container.resolveClass(Target, options));
     }
     static fromValue(value) {
         return new Provider(() => value);

package/esm/container/AliasMap.js

@@ -2,7 +2,7 @@ import { List as L } from '../utils';
 export class AliasMap {
     aliasToKeySet = new Map();
     deleteKeyFromAliases(key) {
-        for (const [depKey, aliasSet] of [...this.aliasToKeySet].filter(([k, aliasSet]) => aliasSet.has(key))) {
+        for (const [depKey, aliasSet] of [...this.aliasToKeySet].filter(([, aliasSet]) => aliasSet.has(key))) {
             aliasSet.delete(key);
             if (aliasSet.size === 0) {
                 this.aliasToKeySet.delete(depKey);

package/esm/container/Container.js

@@ -1,34 +1,36 @@
-import { DEFAULT_CONTAINER_RESOLVER as resolveOne, } from './IContainer';
+import { DEFAULT_CONTAINER_RESOLVER, } from './IContainer';
 import { EmptyContainer } from './EmptyContainer';
 import { ContainerDisposedError } from '../errors/ContainerDisposedError';
 import { MetadataInjector } from '../injector/MetadataInjector';
 import { Filter as F } from '../utils';
-import { ProviderMap } from './ProviderMap';
 import { AliasMap } from './AliasMap';
+import { DependencyNotFoundError } from '../errors/DependencyNotFoundError';
 export class Container {
     isDisposed = false;
     parent;
     scopes = new Set();
     instances = new Set();
     tags;
-    providerMap = new ProviderMap();
-    aliasMap = new AliasMap();
+    providers = new Map();
+    aliases = new AliasMap();
     registrations = new Set();
     onConstruct;
     onDispose;
     injector;
+    resolveOneStrategy;
     constructor(options = {}) {
         this.injector = options.injector ?? new MetadataInjector();
         this.parent = options.parent ?? new EmptyContainer();
         this.tags = new Set(options.tags ?? []);
         this.onConstruct = options.onConstruct ?? (() => { });
         this.onDispose = options.onDispose ?? (() => { });
+        this.resolveOneStrategy = options.resolveOneStrategy ?? DEFAULT_CONTAINER_RESOLVER;
     }
     register(key, provider, { aliases = [] } = {}) {
         this.validateContainer();
-        this.providerMap.register(key, provider);
-        this.aliasMap.deleteKeyFromAliases(key);
-        this.aliasMap.addAliases(key, aliases);
+        this.providers.set(key, provider);
+        this.aliases.deleteKeyFromAliases(key);
+        this.aliases.addAliases(key, aliases);
         return this;
     }
     addRegistration(registration) {
@@ -39,7 +41,7 @@ export class Container {
     getRegistrations() {
         return [...this.parent.getRegistrations(), ...this.registrations];
     }
-    resolveByClass(token, { args = [] } = {}) {
+    resolveClass(token, { args = [] } = {}) {
         this.validateContainer();
         const instance = this.injector.resolve(this, token, { args });
         this.instances.add(instance);
@@ -47,19 +49,19 @@ export class Container {
         return instance;
     }
     resolveOne(keyOrAlias, options) {
-        return resolveOne(this, keyOrAlias, options);
+        return this.resolveOneStrategy(this, keyOrAlias, options);
     }
     resolveOneByKey(keyOrAlias, { args = [], child = this, lazy } = {}) {
         this.validateContainer();
-        const provider = this.providerMap.findOneByKey(keyOrAlias);
+        const provider = this.providers.get(keyOrAlias);
         return provider?.hasAccess({ invocationScope: child, providerScope: this })
             ? provider.resolve(this, { args, lazy })
             : this.parent.resolveOneByKey(keyOrAlias, { args, child, lazy });
     }
     resolveOneByAlias(keyOrAlias, { args = [], child = this, lazy } = {}) {
         this.validateContainer();
-        const key = this.aliasMap.findLastKeyByAlias(keyOrAlias);
-        const provider = key !== undefined ? this.providerMap.findOneByKeyOrFail(key) : undefined;
+        const key = this.aliases.findLastKeyByAlias(keyOrAlias);
+        const provider = key !== undefined ? this.findProviderByKeyOrFail(key) : undefined;
         return provider?.hasAccess({ invocationScope: child, providerScope: this })
             ? provider.resolve(this, { args, lazy })
             : this.parent.resolveOneByAlias(keyOrAlias, { args, child, lazy });
@@ -68,8 +70,8 @@ export class Container {
         this.validateContainer();
         const keys = [];
         const deps = [];
-        for (const key of this.aliasMap.findManyKeysByAlias(alias).filter(F.exclude(excludedKeys))) {
-            const provider = this.providerMap.findOneByKeyOrFail(key);
+        for (const key of this.aliases.findManyKeysByAlias(alias).filter(F.exclude(excludedKeys))) {
+            const provider = this.findProviderByKeyOrFail(key);
             if (!provider.hasAccess({ invocationScope: child, providerScope: this })) {
                 continue;
             }
@@ -123,8 +125,8 @@ export class Container {
         this.parent.removeScope(this);
         this.parent = new EmptyContainer();
         // Reset the state
-        this.providerMap.destroy();
-        this.aliasMap.destroy();
+        this.providers.clear();
+        this.aliases.destroy();
         this.instances.clear();
         this.registrations.clear();
         this.onDispose(this);
@@ -142,4 +144,10 @@ export class Container {
             throw new ContainerDisposedError('Container is already disposed');
         }
     }
+    findProviderByKeyOrFail(key) {
+        if (!this.providers.has(key)) {
+            throw new DependencyNotFoundError(`Provider ${key.toString()} does not exist`);
+        }
+        return this.providers.get(key);
+    }
 }

package/esm/container/EmptyContainer.js

@@ -7,7 +7,7 @@ export class EmptyContainer {
     getParent() {
         return undefined;
     }
-    resolveByClass(token, options) {
+    resolveClass(token, options) {
         throw new MethodNotImplementedError();
     }
     getScopes() {

package/esm/container/IContainer.js

@@ -5,7 +5,7 @@ export function isDependencyKey(token) {
 }
 export const DEFAULT_CONTAINER_RESOLVER = (scope, keyOrAlias, options) => {
     if (isConstructor(keyOrAlias)) {
-        return scope.resolveByClass(keyOrAlias, options);
+        return scope.resolveClass(keyOrAlias, options);
     }
     try {
         return scope.resolveOneByKey(keyOrAlias, options);

package/esm/injector/inject.js

@@ -13,7 +13,7 @@ export const toInjectFn = (target) => {
         return (s) => target.resolve(s);
     }
     if (isConstructor(target)) {
-        return (scope) => scope.resolveByClass(target);
+        return (scope) => scope.resolveClass(target);
     }
     if (isDependencyKey(target)) {
         return (scope) => scope.resolveOne(target);

package/esm/provider/Provider.js

@@ -3,7 +3,7 @@ import { isProviderPipe } from './ProviderPipe';
 export class Provider {
     resolveDependency;
     static fromClass(Target) {
-        return new Provider((container, options) => container.resolveByClass(Target, options));
+        return new Provider((container, options) => container.resolveClass(Target, options));
     }
     static fromValue(value) {
         return new Provider(() => value);

package/esm/resolve.js

@@ -1,4 +1,4 @@
-import { isDependencyKey } from './container/IContainer';
+import { isDependencyKey, } from './container/IContainer';
 import { isDepKey } from './DepKey';
 export class InjectionResolver {
     resolveByOptions;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-ioc-container",
-  "version": "41.0.0",
+  "version": "41.1.1",
   "description": "Typescript IoC container",
   "publishConfig": {
     "access": "public",

package/typings/container/AutoMockedContainer.d.ts

@@ -15,7 +15,7 @@ export declare abstract class AutoMockedContainer implements IContainer {
     getRegistrations(): never[];
     addRegistration(registration: IRegistration): this;
     abstract resolveMany<T>(alias: DependencyKey, options?: ResolveManyOptions): T[];
-    abstract resolveByClass<T>(target: constructor<T>, options?: {
+    abstract resolveClass<T>(target: constructor<T>, options?: {
         args?: unknown[];
     }): T;
     abstract resolveOneByKey<T>(keyOrAlias: DependencyKey, options?: ResolveOneOptions): T;

package/typings/container/Container.d.ts

@@ -3,29 +3,32 @@ import { type IInjector } from '../injector/IInjector';
 import { type IProvider } from '../provider/IProvider';
 import { type IRegistration } from '../registration/IRegistration';
 import { type constructor } from '../utils';
+type ResolveOneStrategy = <T>(scope: IContainer, keyOrAlias: constructor<T> | DependencyKey, options?: ResolveOneOptions) => T;
 export declare class Container implements IContainer {
     isDisposed: boolean;
     private parent;
     private readonly scopes;
     private readonly instances;
     private readonly tags;
-    private readonly providerMap;
-    private readonly aliasMap;
+    private readonly providers;
+    private readonly aliases;
     private readonly registrations;
     private readonly onConstruct;
     private readonly onDispose;
     private readonly injector;
+    private readonly resolveOneStrategy;
     constructor(options?: {
         injector?: IInjector;
         parent?: IContainer;
         tags?: Tag[];
         onConstruct?: (instance: Instance, scope: IContainer) => void;
         onDispose?: (scope: IContainer) => void;
+        resolveOneStrategy?: ResolveOneStrategy;
     });
     register(key: DependencyKey, provider: IProvider, { aliases }?: RegisterOptions): this;
     addRegistration(registration: IRegistration): this;
     getRegistrations(): IRegistration[];
-    resolveByClass<T>(token: constructor<T>, { args }?: {
+    resolveClass<T>(token: constructor<T>, { args }?: {
         args?: unknown[];
     }): T;
     resolveOne<T>(keyOrAlias: constructor<T> | DependencyKey, options?: ResolveOneOptions): T;
@@ -45,4 +48,6 @@ export declare class Container implements IContainer {
      */
     applyRegistrationsFrom(source: Container): void;
     private validateContainer;
+    private findProviderByKeyOrFail;
 }
+export {};

package/typings/container/EmptyContainer.d.ts

@@ -5,7 +5,7 @@ import { type constructor } from '../utils';
 export declare class EmptyContainer implements IContainer {
     get isDisposed(): boolean;
     getParent(): undefined;
-    resolveByClass<T>(token: constructor<T>, options?: {
+    resolveClass<T>(token: constructor<T>, options?: {
         args?: [];
     }): T;
     getScopes(): never[];

package/typings/container/IContainer.d.ts

@@ -36,7 +36,7 @@ export interface IContainer extends Tagged {
     register(key: DependencyKey, value: IProvider, options?: RegisterOptions): this;
     addRegistration(registration: IRegistration): this;
     getRegistrations(): IRegistration[];
-    resolveByClass<T>(target: constructor<T>, options?: {
+    resolveClass<T>(target: constructor<T>, options?: {
         args?: unknown[];
     }): T;
     resolveOne<T>(alias: constructor<T> | DependencyKey, options?: ResolveManyOptions): T;

package/typings/resolve.d.ts

@@ -1,6 +1,6 @@
-import type { CreateScopeOptions, DependencyKey, IContainer, Instance } from './container/IContainer';
-import type { constructor } from './utils';
-import type { DepKey } from './DepKey';
+import { type CreateScopeOptions, type DependencyKey, type IContainer, type Instance } from './container/IContainer';
+import { type constructor } from './utils';
+import { type DepKey } from './DepKey';
 import type { IInjectFnResolver } from './injector/IInjector';
 export type InstancePredicate = (dep: unknown) => boolean;
 export type InjectOptions = {

package/cjm/container/ProviderMap.js

@@ -1,26 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProviderMap = void 0;
-const DependencyNotFoundError_1 = require("../errors/DependencyNotFoundError");
-class ProviderMap {
-    providers = new Map();
-    register(key, provider) {
-        this.providers.set(key, provider);
-    }
-    findOneByKey(key) {
-        return this.providers.get(key);
-    }
-    findOneByKeyOrFail(key) {
-        if (!this.providers.has(key)) {
-            throw new DependencyNotFoundError_1.DependencyNotFoundError(`Provider ${key.toString()} does not exist`);
-        }
-        return this.providers.get(key);
-    }
-    destroy() {
-        this.providers.clear();
-    }
-    has(keyOrAlias) {
-        return this.providers.has(keyOrAlias);
-    }
-}
-exports.ProviderMap = ProviderMap;

package/esm/container/ProviderMap.js

@@ -1,22 +0,0 @@
-import { DependencyNotFoundError } from '../errors/DependencyNotFoundError';
-export class ProviderMap {
-    providers = new Map();
-    register(key, provider) {
-        this.providers.set(key, provider);
-    }
-    findOneByKey(key) {
-        return this.providers.get(key);
-    }
-    findOneByKeyOrFail(key) {
-        if (!this.providers.has(key)) {
-            throw new DependencyNotFoundError(`Provider ${key.toString()} does not exist`);
-        }
-        return this.providers.get(key);
-    }
-    destroy() {
-        this.providers.clear();
-    }
-    has(keyOrAlias) {
-        return this.providers.has(keyOrAlias);
-    }
-}

package/typings/container/ProviderMap.d.ts

@@ -1,10 +0,0 @@
-import { type DependencyKey } from './IContainer';
-import { type IProvider } from '../provider/IProvider';
-export declare class ProviderMap {
-    private readonly providers;
-    register(key: DependencyKey, provider: IProvider): void;
-    findOneByKey<T>(key: DependencyKey): IProvider<T> | undefined;
-    findOneByKeyOrFail<T>(key: DependencyKey): IProvider<T>;
-    destroy(): void;
-    has(keyOrAlias: DependencyKey): boolean;
-}