ts-ioc-container 49.1.0 → 50.1.0

package/README.md

@@ -36,7 +36,7 @@ no global container objects.
 - [Setup](#setup)
 - [Quickstart](#quickstart)
 - [Cheatsheet](#cheatsheet)
-- [Spec-driven workflow](#spec-driven-workflow)
+- [Specs-driven workflow](#specs-driven-workflow)
   - [Product capability map](#product-capability-map)
   - [Acceptance specs](#acceptance-specs)
 - [tsyringe alternative](https://igorbabkin.github.io/ts-ioc-container/tsyringe-alternative)
@@ -144,7 +144,7 @@ container.resolve(App).start();
 > for `R.fromValue(...)` and `R.fromFn(...)` (which have no class to decorate)
 > or for third-party classes you don't own.
 
-## Spec-driven workflow
+## Specs-driven workflow
 
 Public behavior is described as product capabilities before it is implemented.
 The repository keeps the same chain visible in specs, tests, docs, and this
@@ -184,49 +184,203 @@ tests stay in the feature folders under `__tests__/`.
 
 ### Express/Next handler (per-request scope)
 
-```typescript
-const app = new Container({ tags: ['application'] }).addRegistration(R.fromClass(Logger).pipe(singleton()));
+import 'reflect-metadata';
+import { bindTo, Container, inject, register, Registration as R, singleton } from 'ts-ioc-container';
+
+/**
+ * Web Framework Integration - Per-Request Scope
+ *
+ * In Express/Next.js applications, each HTTP request typically gets its own
+ * scope. This ensures request-specific state (logger context, current user,
+ * correlation IDs) is isolated between concurrent requests.
+ *
+ * Scope hierarchy:
+ *   Application (singleton services — live for entire app lifetime)
+ *     └── Request (per-request services — created and disposed per request)
+ */
 
-function handleRequest() {
-  const requestScope = app.createScope({ tags: ['request'] });
-  const logger = requestScope.resolve<Logger>('Logger');
-  logger.log('req started');
+@register(bindTo('ILogger'), singleton())
+class Logger {
+  readonly messages: string[] = [];
+
+  log(message: string) {
+    this.messages.push(message);
+  }
 }
-```
+
+describe('Express/Next per-request scope', () => {
+  it('should give each request its own Logger instance', () => {
+    const app = new Container({ tags: ['application'] }).addRegistration(R.fromClass(Logger));
+
+    // Simulate two concurrent HTTP requests
+    const request1Scope = app.createScope({ tags: ['request'] });
+    const request2Scope = app.createScope({ tags: ['request'] });
+
+    const logger1 = request1Scope.resolve<Logger>('ILogger');
+    const logger2 = request2Scope.resolve<Logger>('ILogger');
+
+    logger1.log('req 1 started');
+    logger2.log('req 2 started');
+
+    // Each request has its own Logger — logs don't leak between requests
+    expect(logger1.messages).toEqual(['req 1 started']);
+    expect(logger2.messages).toEqual(['req 2 started']);
+    expect(logger1).not.toBe(logger2);
+  });
+
+  it('should resolve the same Logger within a single request', () => {
+    const app = new Container({ tags: ['application'] }).addRegistration(R.fromClass(Logger));
+
+    const requestScope = app.createScope({ tags: ['request'] });
+
+    const logger1 = requestScope.resolve<Logger>('ILogger');
+    const logger2 = requestScope.resolve<Logger>('ILogger');
+
+    // Within one request, singleton is maintained
+    expect(logger1).toBe(logger2);
+  });
+});
+
 
 ### Background worker (singleton client, transient jobs)
 
-```typescript
+import 'reflect-metadata';
+import { Container, inject, register, Registration as R, singleton } from 'ts-ioc-container';
+
+/**
+ * Background Worker - Singleton Client, Transient Jobs
+ *
+ * A queue worker typically needs:
+ * - A single shared QueueClient (expensive to create, holds connections)
+ * - A new JobHandler per job (stateful — holds job-specific data)
+ *
+ * singleton() on QueueClient ensures one shared connection pool.
+ * No singleton on JobHandler gives a fresh instance per resolve.
+ */
+
 @register(singleton())
-class QueueClient {}
+class QueueClient {
+  readonly connected = true;
+
+  dequeue(): string {
+    return 'job-payload';
+  }
+}
 
 class JobHandler {
-  constructor(@inject('QueueClient') private queue: QueueClient) {}
+  readonly result: string;
+
+  constructor(@inject('QueueClient') private queue: QueueClient) {
+    this.result = this.queue.dequeue();
+  }
 }
 
-const worker = new Container({ tags: ['worker'] })
-  .addRegistration(R.fromClass(QueueClient))
-  .addRegistration(R.fromClass(JobHandler));
-```
+describe('Background worker', () => {
+  function createWorker() {
+    return new Container({ tags: ['worker'] })
+      .addRegistration(R.fromClass(QueueClient))
+      .addRegistration(R.fromClass(JobHandler));
+  }
+
+  it('should share a single QueueClient across all job handlers', () => {
+    const worker = createWorker();
+
+    const handler1 = worker.resolve(JobHandler);
+    const handler2 = worker.resolve(JobHandler);
+
+    const client1 = worker.resolve<QueueClient>('QueueClient');
+    const client2 = worker.resolve<QueueClient>('QueueClient');
+
+    // QueueClient is a singleton — same connection shared everywhere
+    expect(client1).toBe(client2);
+    expect(client1.connected).toBe(true);
+
+    // JobHandler is transient — fresh instance per job
+    expect(handler1).not.toBe(handler2);
+  });
+
+  it('should inject the shared QueueClient into each JobHandler', () => {
+    const worker = createWorker();
+
+    const handler = worker.resolve(JobHandler);
+
+    expect(handler.result).toBe('job-payload');
+  });
+});
+
 
 ### Frontend widget/page scope with lazy dependency
 
-```typescript
+import 'reflect-metadata';
+import { bindTo, Container, inject, register, Registration as R, select, singleton } from 'ts-ioc-container';
+
+/**
+ * Frontend Widget - Page Scope with Lazy Dependency
+ *
+ * In frontend applications, feature flags are fetched once per page load
+ * (singleton per page scope) but a widget may not need them on every render.
+ * Lazy injection defers instantiation until the widget actually reads the flags,
+ * avoiding unnecessary work for widgets that never display flag-gated content.
+ *
+ * Scope hierarchy:
+ *   Application
+ *     └── Page (singleton flags fetched once)
+ *           └── Widget (lazy flag access)
+ */
+
 @register(bindTo('FeatureFlags'), singleton())
 class FeatureFlags {
-  load() {
-    /* fetch flags */
+  load(): Record<string, boolean> {
+    return { newDashboard: true };
   }
 }
 
 class Widget {
-  constructor(@inject(select.token('FeatureFlags').lazy()) private flags: FeatureFlags) {}
+  constructor(@inject(select.token('FeatureFlags').lazy()) public flags: FeatureFlags) {}
 }
 
-const page = new Container({ tags: ['page'] })
-  .addRegistration(R.fromClass(FeatureFlags))
-  .addRegistration(R.fromClass(Widget));
-```
+describe('Frontend widget/page scope with lazy dependency', () => {
+  function createPage() {
+    return new Container({ tags: ['page'] })
+      .addRegistration(R.fromClass(FeatureFlags))
+      .addRegistration(R.fromClass(Widget));
+  }
+
+  it('should not instantiate FeatureFlags until the widget actually accesses it', () => {
+    const page = createPage();
+
+    const widget = page.resolve(Widget);
+
+    // Widget is resolved, but FeatureFlags has not been instantiated yet
+    let instances = Array.from(page.getInstances()).filter((x) => x instanceof FeatureFlags);
+    expect(instances).toHaveLength(0);
+
+    // Accessing any property on the lazy proxy triggers instantiation
+    const _load = widget.flags.load;
+    expect(_load).toBeDefined();
+
+    instances = Array.from(page.getInstances()).filter((x) => x instanceof FeatureFlags);
+    expect(instances).toHaveLength(1);
+  });
+
+  it('should share the same FeatureFlags singleton across widgets on the same page', () => {
+    const page = createPage();
+
+    const widget1 = page.resolve(Widget);
+    const widget2 = page.resolve(Widget);
+
+    // Trigger instantiation through both widgets
+    const _load1 = widget1.flags.load;
+    const _load2 = widget2.flags.load;
+    expect(_load1).toBeDefined();
+    expect(_load2).toBeDefined();
+
+    // Only one FeatureFlags instance was created across the whole page scope
+    const instances = Array.from(page.getInstances()).filter((x) => x instanceof FeatureFlags);
+    expect(instances).toHaveLength(1);
+  });
+});
+
 
 ## Container
 
@@ -1461,51 +1615,22 @@ This type of injector just passes container to constructor with others arguments
 ```typescript
 import { bindTo, Container, type IContainer, register, Registration as R, SimpleInjector } from 'ts-ioc-container';
 
-/**
- * Command Pattern - Simple Injector
- *
- * The SimpleInjector passes the container itself as the first argument to the constructor.
- * This is useful for:
- * - Service Locators (like Command Dispatchers or Routers)
- * - Factory classes that need to resolve dependencies dynamically
- * - Legacy code migration where passing the container is common
- *
- * In this example, a CommandDispatcher uses the container to dynamically
- * resolve the correct handler for each command type.
- */
-
-interface ICommand {
-  type: string;
-}
-
-interface ICommandHandler {
-  handle(command: ICommand): string;
-}
-
-class CreateUserCommand implements ICommand {
-  readonly type = 'CreateUser';
-  constructor(readonly username: string) {}
-}
-
 @register(bindTo('HandlerCreateUser'))
-class CreateUserHandler implements ICommandHandler {
-  handle(command: CreateUserCommand): string {
-    return `User ${command.username} created`;
+class CreateUserHandler {
+  handle(username: string): string {
+    return `User ${username} created`;
   }
 }
 
 describe('SimpleInjector', function () {
-  it('should inject container to allow dynamic resolution (Service Locator pattern)', function () {
-    // Dispatcher needs the container to find handlers dynamically based on command type
+  it('should inject container to allow dynamic resolution', function () {
     @register(bindTo('Dispatcher'))
     class CommandDispatcher {
       constructor(private container: IContainer) {}
 
-      dispatch(command: ICommand): string {
-        // Dynamically resolve handler: "Handler" + "CreateUser"
-        const handlerKey = `Handler${command.type}`;
-        const handler = this.container.resolve<ICommandHandler>(handlerKey);
-        return handler.handle(command);
+      dispatch(type: string, payload: string): string {
+        const handler = this.container.resolve<CreateUserHandler>(`Handler${type}`);
+        return handler.handle(payload);
       }
     }
 
@@ -1514,30 +1639,27 @@ describe('SimpleInjector', function () {
       .addRegistration(R.fromClass(CreateUserHandler));
 
     const dispatcher = container.resolve<CommandDispatcher>('Dispatcher');
-    const result = dispatcher.dispatch(new CreateUserCommand('alice'));
 
-    expect(result).toBe('User alice created');
+    expect(dispatcher.dispatch('CreateUser', 'alice')).toBe('User alice created');
   });
 
   it('should pass additional arguments alongside the container', function () {
-    // Factory that creates widgets with a specific theme
     class WidgetFactory {
       constructor(
         private container: IContainer,
-        private theme: string, // Passed as argument during resolve
+        private theme: string,
       ) {}
 
       createWidget(name: string): string {
-        return `Widget ${name} with ${this.theme} theme (Container available: ${!!this.container})`;
+        return `Widget ${name} with ${this.theme} theme (container: ${!!this.container})`;
       }
     }
 
     const container = new Container({ injector: new SimpleInjector() }).addRegistration(R.fromClass(WidgetFactory));
 
-    // Pass "dark" as the theme argument
     const factory = container.resolve<WidgetFactory>('WidgetFactory', { args: ['dark'] });
 
-    expect(factory.createWidget('Button')).toBe('Widget Button with dark theme (Container available: true)');
+    expect(factory.createWidget('Button')).toBe('Widget Button with dark theme (container: true)');
   });
 });
 
@@ -1562,16 +1684,11 @@ describe('ProxyInjector', function () {
       }
     }
 
-    interface UserControllerDeps {
-      logger: Logger;
-      prefix: string;
-    }
-
     class UserController {
       private logger: Logger;
       private prefix: string;
 
-      constructor({ logger, prefix }: UserControllerDeps) {
+      constructor({ logger, prefix }: { logger: Logger; prefix: string }) {
         this.logger = logger;
         this.prefix = prefix;
       }
@@ -1586,21 +1703,14 @@ describe('ProxyInjector', function () {
       .addRegistration(R.fromValue('USER:').bindToKey('prefix'))
       .addRegistration(R.fromClass(UserController));
 
-    const controller = container.resolve<UserController>('UserController');
-
-    expect(controller.createUser('bob')).toBe('Logged: USER: bob');
+    expect(container.resolve<UserController>('UserController').createUser('bob')).toBe('Logged: USER: bob');
   });
 
   it('should expose runtime args through the reserved "args" property', function () {
-    @register(bindTo('database'))
-    class Database {}
-
     class ReportGenerator {
-      database: Database;
       format: string;
 
-      constructor({ database, args }: { database: Database; args: string[] }) {
-        this.database = database;
+      constructor({ args }: { args: string[] }) {
         this.format = args[0];
       }
 
@@ -1609,40 +1719,12 @@ describe('ProxyInjector', function () {
       }
     }
 
-    const container = new Container({ injector: new ProxyInjector() })
-      .addRegistration(R.fromClass(Database))
-      .addRegistration(R.fromClass(ReportGenerator));
+    const container = new Container({ injector: new ProxyInjector() }).addRegistration(R.fromClass(ReportGenerator));
 
-    const generator = container.resolve<ReportGenerator>('ReportGenerator', {
-      args: ['PDF'],
-    });
+    const generator = container.resolve<ReportGenerator>('ReportGenerator', { args: ['PDF'] });
 
-    expect(generator.database).toBeInstanceOf(Database);
     expect(generator.generate()).toBe('Report in PDF');
   });
-
-  it('should resolve dependencies by alias when property name contains "alias"', function () {
-    class FileLogger {}
-    class ConsoleLogger {}
-
-    interface AppDeps {
-      loggersAlias: any[];
-    }
-
-    class App {
-      constructor(public deps: AppDeps) {}
-    }
-
-    const container = new Container({ injector: new ProxyInjector() });
-
-    const mockLoggers = [new FileLogger(), new ConsoleLogger()];
-    container.resolveByAlias = vi.fn().mockReturnValue(mockLoggers);
-
-    const app = container.resolve(App);
-
-    expect(app.deps.loggersAlias).toBe(mockLoggers);
-    expect(container.resolveByAlias).toHaveBeenCalledWith('loggersAlias');
-  });
 });
 
 ```
@@ -1898,7 +1980,7 @@ describe('Singleton', function () {
 
 ### Arguments
 
-Sometimes you want to bind some arguments to provider. This is what `ArgsProvider` is for.
+Sometimes you want to bind some arguments to provider.
 
 - `provider(setArgs('someArgument'))`
 - `provider(setArgsFn((container) => [container.resolve(Logger), 'someValue']))`
@@ -1934,17 +2016,18 @@ const userToken = ApiToken.args('https://users.api.com', 1000);
 
 ```typescript
 import {
-  setArgs,
-  setArgsFn,
+  addArgs,
+  addArgsFn,
+  args,
   bindTo,
   Container,
   inject,
-  args,
-  MultiCache,
   register,
   Registration as R,
-  singleton,
+  setArgs,
+  setArgsFn,
   SingleToken,
+  singleton,
 } from 'ts-ioc-container';
 
 /**
@@ -1957,7 +2040,7 @@ import {
  * - Generic classes (like Repositories) that need to know what they are managing
  */
 
-describe('ArgsProvider', function () {
+describe('IProvider', function () {
   function createContainer() {
     return new Container();
   }
@@ -2014,6 +2097,49 @@ describe('ArgsProvider', function () {
     });
   });
 
+  describe('Appending Arguments', () => {
+    it('can append static arguments after existing resolve arguments', function () {
+      @register(addArgs('configured'))
+      class Service {
+        constructor(
+          @inject(args(0)) public runtime: string,
+          @inject(args(1)) public configured: string,
+        ) {}
+      }
+
+      const root = createContainer().addRegistration(R.fromClass(Service));
+
+      const service = root.resolve<Service>('Service', { args: ['runtime'] });
+      expect(service.runtime).toBe('runtime');
+      expect(service.configured).toBe('configured');
+    });
+
+    it('can append dynamic arguments after an existing argsFn', function () {
+      class Config {
+        tenant = 'tenant-a';
+      }
+
+      @register(
+        setArgs('fixed'),
+        addArgsFn((scope, { args = [] } = {}) => [scope.resolve<Config>('Config').tenant, ...args]),
+      )
+      class Service {
+        constructor(
+          @inject(args(0)) public fixed: string,
+          @inject(args(1)) public tenant: string,
+          @inject(args(2)) public runtime: string,
+        ) {}
+      }
+
+      const root = createContainer().addRegistration(R.fromClass(Config)).addRegistration(R.fromClass(Service));
+
+      const service = root.resolve<Service>('Service', { args: ['runtime'] });
+      expect(service.fixed).toBe('fixed');
+      expect(service.tenant).toBe('tenant-a');
+      expect(service.runtime).toBe('runtime');
+    });
+  });
+
   describe('Generic Repositories (Advanced Pattern)', () => {
     // This example demonstrates how to implement the Generic Repository pattern
     // where a generic EntityManager needs to know WHICH repository to use.
@@ -2044,7 +2170,7 @@ describe('ArgsProvider', function () {
 
     @register(
       bindTo(EntityManagerToken),
-      singleton(MultiCache.fromFirstArg), // Cache unique instance per repository type
+      singleton((arg1) => (arg1 as SingleToken).token), // Cache unique instance per repository type
     )
     class EntityManager {
       constructor(@inject(args(0)) public repository: IRepository) {}
@@ -2574,37 +2700,91 @@ Sometimes you need to register provider only in scope which matches to certain c
 - `Registration.fromClass(Logger).when((container) => container.hasTag('root'))`
 
 ```typescript
-import { bindTo, Container, register, Registration as R, scope, singleton } from 'ts-ioc-container';
+import 'reflect-metadata';
+import {
+  bindTo,
+  Container,
+  DependencyNotFoundError,
+  type IContainer,
+  inject,
+  register,
+  Registration as R,
+  scope,
+  select,
+  singleton,
+} from 'ts-ioc-container';
 
 /**
- * Scoping - Scope Match Rule
+ * User Management Domain - Request Scopes
  *
- * You can restrict WHERE a provider is registered.
- * This is useful for singleton services that should only exist in the root scope,
- * or per-request services that should only exist in request scopes.
+ * In web applications, each HTTP request typically gets its own scope.
+ * This allows request-specific data (current user, request ID, etc.)
+ * to be isolated between concurrent requests.
+ *
+ * Scope hierarchy:
+ *   Application (singleton services)
+ *     └── Request (per-request services)
+ *           └── Transaction (database transaction boundary)
  */
 
-describe('ScopeProvider', function () {
-  it('should register provider only in matching scope', function () {
-    // SharedState should be a singleton in the root 'application' scope
-    // It will be visible to all child scopes, but physically resides in 'application'
-    @register(
-      bindTo('SharedState'),
-      scope((s) => s.hasTag('application')), // Only register in application scope
-      singleton(), // One instance per application
-    )
-    class SharedState {
-      data = 'shared';
-    }
+// SessionService is only available in request scope - not at application level
+@register(bindTo('ISessionService'), scope((s) => s.hasTag('request')), singleton())
+class SessionService {
+  private userId: string | null = null;
 
-    const appContainer = new Container({ tags: ['application'] }).addRegistration(R.fromClass(SharedState));
-    const requestScope = appContainer.createScope({ tags: ['request'] });
+  setCurrentUser(userId: string) {
+    this.userId = userId;
+  }
 
-    // Both resolve to the SAME instance because it's a singleton in the app scope
-    const appState = appContainer.resolve('SharedState');
-    const requestState = requestScope.resolve('SharedState');
+  getCurrentUserId(): string | null {
+    return this.userId;
+  }
+}
 
-    expect(appState).toBe(requestState);
+describe('Scopes', function () {
+  it('should isolate request-scoped services', function () {
+    // Application container - lives for entire app lifetime
+    const appContainer = new Container({ tags: ['application'] }).addRegistration(R.fromClass(SessionService));
+
+    // Simulate two concurrent HTTP requests
+    const request1Scope = appContainer.createScope({ tags: ['request'] });
+    const request2Scope = appContainer.createScope({ tags: ['request'] });
+
+    // Each request has its own SessionService instance
+    const session1 = request1Scope.resolve<SessionService>('ISessionService');
+    const session2 = request2Scope.resolve<SessionService>('ISessionService');
+
+    session1.setCurrentUser('user-1');
+    session2.setCurrentUser('user-2');
+
+    // Sessions are isolated - user data doesn't leak between requests
+    expect(session1.getCurrentUserId()).toBe('user-1');
+    expect(session2.getCurrentUserId()).toBe('user-2');
+    expect(session1).not.toBe(session2);
+
+    // SessionService is NOT available at application level (security!)
+    expect(() => appContainer.resolve('ISessionService')).toThrow(DependencyNotFoundError);
+  });
+
+  it('should create child scopes for transactions', function () {
+    const appContainer = new Container({ tags: ['application'] });
+
+    // RequestHandler can create a transaction scope for database operations
+    class RequestHandler {
+      constructor(@inject(select.scope.create({ tags: ['transaction'] })) public transactionScope: IContainer) {}
+
+      executeInTransaction(): boolean {
+        // Transaction scope inherits from request scope
+        // Database operations can be rolled back together
+        return this.transactionScope.hasTag('transaction');
+      }
+    }
+
+    const handler = appContainer.resolve(RequestHandler);
+
+    expect(handler.transactionScope).not.toBe(appContainer);
+    expect(handler.transactionScope.hasTag('transaction')).toBe(true);
+    expect(handler.executeInTransaction()).toBe(true);
   });
 });
 
@@ -2741,30 +2921,10 @@ Sometimes you need to invoke methods after construct or dispose of class. This i
 ### OnConstruct
 
 ```typescript
-import {
-  AddOnConstructHookModule,
-  Container,
-  IHookContext,
-  HookFn,
-  inject,
-  onConstruct,
-  Registration as R,
-} from 'ts-ioc-container';
-
-/**
- * Lifecycle - OnConstruct Hook
- *
- * The @onConstruct hook allows you to run logic immediately after an object is created.
- * This is useful for:
- * - Initialization logic that depends on injected services
- * - Setting up event listeners
- * - Establishing connections (though lazy is often better)
- * - Computing initial state
- *
- * Note: You must register the AddOnConstructHookModule or manually add the hook runner.
- */
+import 'reflect-metadata';
+import { AddOnConstructHookModule, Container, type HookFn, inject, onConstruct, Registration as R } from 'ts-ioc-container';
 
-const execute: HookFn = (ctx: IHookContext) => {
+const execute: HookFn = (ctx) => {
   ctx.invokeMethod({ args: ctx.resolveArgs() });
 };
 
@@ -2774,8 +2934,6 @@ describe('onConstruct', function () {
       isConnected = false;
       connectionString = '';
 
-      // @onConstruct marks this method to be called after instantiation
-      // Arguments are resolved from the container like constructor params
       @onConstruct(execute)
       connect(@inject('ConnectionString') connectionString: string) {
         this.connectionString = connectionString;
@@ -2784,12 +2942,9 @@ describe('onConstruct', function () {
     }
 
     const container = new Container()
-      // Enable @onConstruct support
       .useModule(new AddOnConstructHookModule())
-      // Register config
       .addRegistration(R.fromValue('postgres://localhost:5432').bindTo('ConnectionString'));
 
-    // Resolve class - constructor is called, then @onConstruct method
     const db = container.resolve(DatabaseConnection);
 
     expect(db.isConnected).toBe(true);
@@ -2802,6 +2957,7 @@ describe('onConstruct', function () {
 ### OnDispose
 
 ```typescript
+import 'reflect-metadata';
 import {
   AddOnDisposeHookModule,
   bindTo,
@@ -2829,10 +2985,6 @@ class LogsRepo {
 
 @register(bindTo('logger'))
 class Logger {
-  @onDispose(({ instance, methodName }) => {
-    // @ts-ignore
-    instance[methodName].push('world');
-  }) // <--- or extract it to @onDispose
   private messages: string[] = [];
 
   constructor(@inject('logsRepo') private logsRepo: LogsRepo) {}
@@ -2848,7 +3000,7 @@ class Logger {
 }
 
 describe('onDispose', function () {
-  it('should invoke hooks on all instances', function () {
+  it('should invoke hooks on all instances when container is disposed', function () {
     const container = new Container()
       .useModule(new AddOnDisposeHookModule())
       .addRegistration(R.fromClass(Logger))
@@ -2860,7 +3012,7 @@ describe('onDispose', function () {
 
     container.dispose();
 
-    expect(logsRepo.savedLogs.join(',')).toBe('Hello,world');
+    expect(logsRepo.savedLogs).toEqual(['Hello']);
   });
 });
 

package/cjm/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toSingleAlias = exports.SingleAliasToken = exports.toGroupAlias = exports.GroupAliasToken = exports.InjectionToken = exports.HooksRunner = exports.AddOnDisposeHookModule = exports.onDispose = exports.onDisposeHooksRunner = exports.AddOnConstructHookModule = exports.onConstruct = exports.onConstructHooksRunner = exports.injectProp = exports.createHookContext = exports.createHookContextFactory = exports.HookContext = exports.hasHooks = exports.hook = exports.getHooks = exports.UnexpectedHookResultError = exports.ContainerDisposedError = exports.MethodNotImplementedError = exports.DependencyMissingKeyError = exports.DependencyNotFoundError = exports.Registration = exports.bindTo = exports.register = exports.scope = exports.decorate = exports.MultiCache = exports.multiCache = exports.SingletonProvider = exports.singleton = exports.Provider = exports.ProviderDecorator = exports.setArgs = exports.setArgsFn = exports.lazy = exports.scopeAccess = exports.ProxyInjector = exports.SimpleInjector = exports.MetadataInjector = exports.Injector = exports.argsFn = exports.args = exports.resolveArgs = exports.inject = exports.EmptyContainer = exports.Container = exports.isDependencyKey = void 0;
+exports.toSingleAlias = exports.SingleAliasToken = exports.toGroupAlias = exports.GroupAliasToken = exports.InjectionToken = exports.HooksRunner = exports.AddOnDisposeHookModule = exports.onDispose = exports.onDisposeHooksRunner = exports.AddOnConstructHookModule = exports.onConstruct = exports.onConstructHooksRunner = exports.injectProp = exports.createHookContext = exports.createHookContextFactory = exports.HookContext = exports.hasHooks = exports.hook = exports.getHooks = exports.UnexpectedHookResultError = exports.ContainerDisposedError = exports.MethodNotImplementedError = exports.DependencyMissingKeyError = exports.DependencyNotFoundError = exports.Registration = exports.bindTo = exports.register = exports.scope = exports.decorate = exports.SingletonProvider = exports.singleton = exports.Provider = exports.ProviderDecorator = exports.setArgs = exports.setArgsFn = exports.addArgsFn = exports.addArgs = exports.lazy = exports.scopeAccess = exports.ProxyInjector = exports.SimpleInjector = exports.MetadataInjector = exports.Injector = exports.argsFn = exports.args = exports.resolveArgs = exports.inject = exports.EmptyContainer = exports.Container = exports.isDependencyKey = void 0;
 exports.resolveConstructor = exports.Is = exports.pipe = exports.select = exports.once = exports.shallowCache = exports.debounce = exports.throttle = exports.handleAsyncError = exports.handleError = exports.getMethodTags = exports.methodTag = exports.getMethodLabels = exports.methodLabel = exports.getMethodMeta = exports.methodMeta = exports.getParamTags = exports.paramTag = exports.getParamLabels = exports.paramLabel = exports.getParamMeta = exports.paramMeta = exports.getClassTags = exports.classTag = exports.getClassLabels = exports.classLabel = exports.getClassMeta = exports.classMeta = exports.GroupInstanceToken = exports.ConstantToken = exports.FunctionToken = exports.SingleToken = exports.ClassToken = void 0;
 // Containers
 var IContainer_1 = require("./container/IContainer");
@@ -27,6 +27,8 @@ Object.defineProperty(exports, "ProxyInjector", { enumerable: true, get: functio
 var IProvider_1 = require("./provider/IProvider");
 Object.defineProperty(exports, "scopeAccess", { enumerable: true, get: function () { return IProvider_1.scopeAccess; } });
 Object.defineProperty(exports, "lazy", { enumerable: true, get: function () { return IProvider_1.lazy; } });
+Object.defineProperty(exports, "addArgs", { enumerable: true, get: function () { return IProvider_1.addArgs; } });
+Object.defineProperty(exports, "addArgsFn", { enumerable: true, get: function () { return IProvider_1.addArgsFn; } });
 Object.defineProperty(exports, "setArgsFn", { enumerable: true, get: function () { return IProvider_1.setArgsFn; } });
 Object.defineProperty(exports, "setArgs", { enumerable: true, get: function () { return IProvider_1.setArgs; } });
 Object.defineProperty(exports, "ProviderDecorator", { enumerable: true, get: function () { return IProvider_1.ProviderDecorator; } });
@@ -35,9 +37,6 @@ Object.defineProperty(exports, "Provider", { enumerable: true, get: function ()
 var SingletonProvider_1 = require("./provider/SingletonProvider");
 Object.defineProperty(exports, "singleton", { enumerable: true, get: function () { return SingletonProvider_1.singleton; } });
 Object.defineProperty(exports, "SingletonProvider", { enumerable: true, get: function () { return SingletonProvider_1.SingletonProvider; } });
-var Cache_1 = require("./provider/Cache");
-Object.defineProperty(exports, "multiCache", { enumerable: true, get: function () { return Cache_1.multiCache; } });
-Object.defineProperty(exports, "MultiCache", { enumerable: true, get: function () { return Cache_1.MultiCache; } });
 var DecoratorProvider_1 = require("./provider/DecoratorProvider");
 Object.defineProperty(exports, "decorate", { enumerable: true, get: function () { return DecoratorProvider_1.decorate; } });
 // Registrations

package/cjm/injector/inject.js

@@ -1,8 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveArgs = exports.argsFn = exports.args = exports.inject = void 0;
-const InjectionToken_1 = require("../token/InjectionToken");
-const ConstantToken_1 = require("../token/ConstantToken");
 const toToken_1 = require("../token/toToken");
 const basic_1 = require("../utils/basic");
 const parameter_1 = require("../metadata/parameter");
@@ -17,9 +15,8 @@ const args = (index) => (c, { args = [] }) => {
 exports.args = args;
 const argsFn = (fn) => (c, options) => fn(...(options.args ?? []));
 exports.argsFn = argsFn;
-const argToToken = (v) => ((0, InjectionToken_1.isInjectionToken)(v) ? v : new ConstantToken_1.ConstantToken(v));
 const resolveArgs = (Target, methodName) => {
     const tokens = (0, parameter_1.getParamMeta)(hookMetaKey(methodName), Target);
-    return (scope, { args = [], lazy }) => tokens.map((fn) => fn.resolve(scope, { args: args.map(argToToken).map((t) => t.resolve(scope)), lazy }));
+    return (scope, { args = [], lazy }) => tokens.map((fn) => fn.resolve(scope, { args: args.map(toToken_1.argToToken).map((t) => t.resolve(scope)), lazy }));
 };
 exports.resolveArgs = resolveArgs;

package/cjm/provider/IProvider.js

@@ -1,11 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProviderDecorator = exports.lazy = exports.scopeAccess = exports.setArgsFn = exports.setArgs = void 0;
+exports.ProviderDecorator = exports.lazy = exports.scopeAccess = exports.addArgsFn = exports.addArgs = exports.setArgsFn = exports.setArgs = void 0;
 const ProviderPipe_1 = require("./ProviderPipe");
 const setArgs = (...extraArgs) => (0, ProviderPipe_1.registerPipe)((p) => p.setArgs(() => extraArgs));
 exports.setArgs = setArgs;
 const setArgsFn = (fn) => (0, ProviderPipe_1.registerPipe)((p) => p.setArgs(fn));
 exports.setArgsFn = setArgsFn;
+const addArgs = (...extraArgs) => (0, ProviderPipe_1.registerPipe)((p) => p.addArgs(...extraArgs));
+exports.addArgs = addArgs;
+const addArgsFn = (fn) => (0, ProviderPipe_1.registerPipe)((p) => p.addArgsFn(fn));
+exports.addArgsFn = addArgsFn;
 const scopeAccess = (rule) => (0, ProviderPipe_1.registerPipe)((p) => p.setAccessRule(rule));
 exports.scopeAccess = scopeAccess;
 const lazy = () => (0, ProviderPipe_1.registerPipe)((p) => p.lazy());
@@ -39,6 +43,14 @@ class ProviderDecorator {
         this.decorated.setArgs(argsFn);
         return this;
     }
+    addArgs(...extraArgs) {
+        this.decorated.addArgs(...extraArgs);
+        return this;
+    }
+    addArgsFn(argsFn) {
+        this.decorated.addArgsFn(argsFn);
+        return this;
+    }
     lazy() {
         this.decorated.lazy();
         return this;

package/cjm/provider/Provider.js

@@ -42,6 +42,16 @@ class Provider {
         this.argsFn = argsFn;
         return this;
     }
+    addArgs(...extraArgs) {
+        const parentFn = this.argsFn;
+        this.argsFn = (container, options) => [...parentFn(container, options), ...extraArgs];
+        return this;
+    }
+    addArgsFn(argsFn) {
+        const parentFn = this.argsFn;
+        this.argsFn = (container, options) => [...parentFn(container, options), ...argsFn(container, options)];
+        return this;
+    }
     hasAccess(options) {
         return this.checkAccess(options);
     }

package/cjm/provider/SingletonProvider.js

@@ -2,25 +2,25 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.singleton = exports.SingletonProvider = void 0;
 const IProvider_1 = require("./IProvider");
-const Cache_1 = require("./Cache");
 const ProviderPipe_1 = require("./ProviderPipe");
 class SingletonProvider extends IProvider_1.ProviderDecorator {
     provider;
-    cache;
-    constructor(provider, cache) {
+    getKey;
+    cache = new Map();
+    constructor(provider, getKey) {
         super(provider);
         this.provider = provider;
-        this.cache = cache;
+        this.getKey = getKey;
     }
     resolve(container, options) {
         const { args = [] } = options;
-        const key = this.cache.getKey(...args);
-        if (!this.cache.hasValue(key)) {
-            this.cache.setValue(key, this.provider.resolve(container, options));
+        const key = this.getKey(...args);
+        if (!this.cache.has(key)) {
+            this.cache.set(key, this.provider.resolve(container, options));
         }
-        return this.cache.getValue(key);
+        return this.cache.get(key);
     }
 }
 exports.SingletonProvider = SingletonProvider;
-const singleton = (cacheProvider) => (0, ProviderPipe_1.registerPipe)((p) => new SingletonProvider(p, cacheProvider ? cacheProvider() : new Cache_1.SingleCache()));
+const singleton = (getCacheKey = () => '1') => (0, ProviderPipe_1.registerPipe)((p) => new SingletonProvider(p, getCacheKey));
 exports.singleton = singleton;

package/cjm/token/toToken.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toToken = void 0;
+exports.argToToken = exports.toToken = void 0;
 const IContainer_1 = require("../container/IContainer");
 const SingleToken_1 = require("./SingleToken");
 const ClassToken_1 = require("./ClassToken");
@@ -8,6 +8,7 @@ const FunctionToken_1 = require("./FunctionToken");
 const UnsupportedTokenTypeError_1 = require("../errors/UnsupportedTokenTypeError");
 const InjectionToken_1 = require("./InjectionToken");
 const basic_1 = require("../utils/basic");
+const ConstantToken_1 = require("./ConstantToken");
 const toToken = (token) => {
     if (token instanceof InjectionToken_1.InjectionToken) {
         return token;
@@ -24,3 +25,5 @@ const toToken = (token) => {
     throw new UnsupportedTokenTypeError_1.UnsupportedTokenTypeError(`Unknown token ${token}`);
 };
 exports.toToken = toToken;
+const argToToken = (v) => ((0, InjectionToken_1.isInjectionToken)(v) ? v : new ConstantToken_1.ConstantToken(v));
+exports.argToToken = argToToken;

package/esm/index.js

@@ -9,10 +9,9 @@ export { MetadataInjector } from './injector/MetadataInjector';
 export { SimpleInjector } from './injector/SimpleInjector';
 export { ProxyInjector } from './injector/ProxyInjector';
 // Providers
-export { scopeAccess, lazy, setArgsFn, setArgs, ProviderDecorator, } from './provider/IProvider';
+export { scopeAccess, lazy, addArgs, addArgsFn, setArgsFn, setArgs, ProviderDecorator, } from './provider/IProvider';
 export { Provider } from './provider/Provider';
 export { singleton, SingletonProvider } from './provider/SingletonProvider';
-export { multiCache, MultiCache } from './provider/Cache';
 export { decorate } from './provider/DecoratorProvider';
 // Registrations
 export { scope, register, bindTo, } from './registration/IRegistration';

package/esm/injector/inject.js

@@ -1,6 +1,4 @@
-import { isInjectionToken } from '../token/InjectionToken';
-import { ConstantToken } from '../token/ConstantToken';
-import { toToken } from '../token/toToken';
+import { argToToken, toToken } from '../token/toToken';
 import { Is } from '../utils/basic';
 import { getParamMeta, paramMeta } from '../metadata/parameter';
 const hookMetaKey = (methodName = 'constructor') => `inject:${methodName}`;
@@ -11,7 +9,6 @@ export const args = (index) => (c, { args = [] }) => {
     return args[index];
 };
 export const argsFn = (fn) => (c, options) => fn(...(options.args ?? []));
-const argToToken = (v) => (isInjectionToken(v) ? v : new ConstantToken(v));
 export const resolveArgs = (Target, methodName) => {
     const tokens = getParamMeta(hookMetaKey(methodName), Target);
     return (scope, { args = [], lazy }) => tokens.map((fn) => fn.resolve(scope, { args: args.map(argToToken).map((t) => t.resolve(scope)), lazy }));

package/esm/provider/IProvider.js

@@ -1,6 +1,8 @@
 import { isProviderPipe, registerPipe } from './ProviderPipe';
 export const setArgs = (...extraArgs) => registerPipe((p) => p.setArgs(() => extraArgs));
 export const setArgsFn = (fn) => registerPipe((p) => p.setArgs(fn));
+export const addArgs = (...extraArgs) => registerPipe((p) => p.addArgs(...extraArgs));
+export const addArgsFn = (fn) => registerPipe((p) => p.addArgsFn(fn));
 export const scopeAccess = (rule) => registerPipe((p) => p.setAccessRule(rule));
 export const lazy = () => registerPipe((p) => p.lazy());
 export class ProviderDecorator {
@@ -32,6 +34,14 @@ export class ProviderDecorator {
         this.decorated.setArgs(argsFn);
         return this;
     }
+    addArgs(...extraArgs) {
+        this.decorated.addArgs(...extraArgs);
+        return this;
+    }
+    addArgsFn(argsFn) {
+        this.decorated.addArgsFn(argsFn);
+        return this;
+    }
     lazy() {
         this.decorated.lazy();
         return this;

package/esm/provider/Provider.js

@@ -39,6 +39,16 @@ export class Provider {
         this.argsFn = argsFn;
         return this;
     }
+    addArgs(...extraArgs) {
+        const parentFn = this.argsFn;
+        this.argsFn = (container, options) => [...parentFn(container, options), ...extraArgs];
+        return this;
+    }
+    addArgsFn(argsFn) {
+        const parentFn = this.argsFn;
+        this.argsFn = (container, options) => [...parentFn(container, options), ...argsFn(container, options)];
+        return this;
+    }
     hasAccess(options) {
         return this.checkAccess(options);
     }

package/esm/provider/SingletonProvider.js

@@ -1,21 +1,21 @@
 import { ProviderDecorator } from './IProvider';
-import { SingleCache } from './Cache';
 import { registerPipe } from './ProviderPipe';
 export class SingletonProvider extends ProviderDecorator {
     provider;
-    cache;
-    constructor(provider, cache) {
+    getKey;
+    cache = new Map();
+    constructor(provider, getKey) {
         super(provider);
         this.provider = provider;
-        this.cache = cache;
+        this.getKey = getKey;
     }
     resolve(container, options) {
         const { args = [] } = options;
-        const key = this.cache.getKey(...args);
-        if (!this.cache.hasValue(key)) {
-            this.cache.setValue(key, this.provider.resolve(container, options));
+        const key = this.getKey(...args);
+        if (!this.cache.has(key)) {
+            this.cache.set(key, this.provider.resolve(container, options));
         }
-        return this.cache.getValue(key);
+        return this.cache.get(key);
     }
 }
-export const singleton = (cacheProvider) => registerPipe((p) => new SingletonProvider(p, cacheProvider ? cacheProvider() : new SingleCache()));
+export const singleton = (getCacheKey = () => '1') => registerPipe((p) => new SingletonProvider(p, getCacheKey));

package/esm/token/toToken.js

@@ -3,8 +3,9 @@ import { SingleToken } from './SingleToken';
 import { ClassToken } from './ClassToken';
 import { FunctionToken } from './FunctionToken';
 import { UnsupportedTokenTypeError } from '../errors/UnsupportedTokenTypeError';
-import { InjectionToken } from './InjectionToken';
+import { InjectionToken, isInjectionToken } from './InjectionToken';
 import { Is } from '../utils/basic';
+import { ConstantToken } from './ConstantToken';
 export const toToken = (token) => {
     if (token instanceof InjectionToken) {
         return token;
@@ -20,3 +21,4 @@ export const toToken = (token) => {
     }
     throw new UnsupportedTokenTypeError(`Unknown token ${token}`);
 };
+export const argToToken = (v) => (isInjectionToken(v) ? v : new ConstantToken(v));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-ioc-container",
-  "version": "49.1.0",
+  "version": "50.1.0",
   "description": "Fast, lightweight TypeScript dependency injection container with a clean API, scoped lifecycles, decorators, tokens, hooks, lazy injection, customizable providers, and no global container objects.",
   "workspaces": [
     "docs"
@@ -90,11 +90,11 @@
     "@swc/core": "^1.15.24",
     "@types/node": "^25.5.2",
     "@typescript-eslint/eslint-plugin": "8.32.1",
-    "@typescript-eslint/parser": "8.29.1",
+    "@typescript-eslint/parser": "8.58.2",
     "@vitest/coverage-v8": "^4.1.2",
     "cz-conventional-changelog": "^3.3.0",
     "eslint": "9.24.0",
-    "eslint-config-prettier": "10.1.1",
+    "eslint-config-prettier": "10.1.8",
     "eslint-plugin-prettier": "5.2.6",
     "handlebars": "^4.7.8",
     "husky": "^9.1.7",

package/typings/index.d.ts

@@ -6,10 +6,9 @@ export { type IInjector, type InjectOptions, type IInjectFnResolver, Injector }
 export { MetadataInjector } from './injector/MetadataInjector';
 export { SimpleInjector } from './injector/SimpleInjector';
 export { ProxyInjector } from './injector/ProxyInjector';
-export { type ResolveDependency, type IProvider, scopeAccess, lazy, setArgsFn, setArgs, type ArgsFn, ProviderDecorator, type IMapper, type ProviderOptions, } from './provider/IProvider';
+export { type ResolveDependency, type IProvider, scopeAccess, lazy, addArgs, addArgsFn, setArgsFn, setArgs, type ArgsFn, ProviderDecorator, type IMapper, type ProviderOptions, } from './provider/IProvider';
 export { Provider } from './provider/Provider';
 export { singleton, SingletonProvider } from './provider/SingletonProvider';
-export { type Cache, multiCache, MultiCache } from './provider/Cache';
 export { decorate, type DecorateFn } from './provider/DecoratorProvider';
 export { type ProviderPipe } from './provider/ProviderPipe';
 export { type IRegistration, type ReturnTypeOfRegistration, scope, register, type ScopeMatchRule, bindTo, } from './registration/IRegistration';

package/typings/provider/IProvider.d.ts

@@ -22,10 +22,14 @@ export interface IProvider<T = any> {
     pipe(...mappers: (MapFn<IProvider<T>> | ProviderPipe<T>)[]): IProvider<T>;
     setAccessRule(hasAccessWhen: ScopeAccessRule): this;
     setArgs(argsFn: ArgsFn): this;
+    addArgs(...extraArgs: unknown[]): this;
+    addArgsFn(argsFn: ArgsFn): this;
     lazy(): this;
 }
 export declare const setArgs: <T>(...extraArgs: unknown[]) => ProviderPipe<T>;
 export declare const setArgsFn: <T>(fn: ArgsFn) => ProviderPipe<T>;
+export declare const addArgs: <T>(...extraArgs: unknown[]) => ProviderPipe<T>;
+export declare const addArgsFn: <T>(fn: ArgsFn) => ProviderPipe<T>;
 export declare const scopeAccess: <T>(rule: ScopeAccessRule) => ProviderPipe<T>;
 export declare const lazy: <T>() => ProviderPipe<T>;
 export declare abstract class ProviderDecorator<T> implements IProvider<T> {
@@ -36,5 +40,7 @@ export declare abstract class ProviderDecorator<T> implements IProvider<T> {
     resolve(container: IContainer, options: ProviderOptions): T;
     pipe(...mappers: (MapFn<IProvider<T>> | ProviderPipe<T>)[]): IProvider<T>;
     setArgs(argsFn: ArgsFn): this;
+    addArgs(...extraArgs: unknown[]): this;
+    addArgsFn(argsFn: ArgsFn): this;
     lazy(): this;
 }

package/typings/provider/Provider.d.ts

@@ -17,5 +17,7 @@ export declare class Provider<T = any> implements IProvider<T> {
     setAccessRule(predicate: ScopeAccessRule): this;
     lazy(): this;
     setArgs(argsFn: ArgsFn): this;
+    addArgs(...extraArgs: unknown[]): this;
+    addArgsFn(argsFn: ArgsFn): this;
     hasAccess(options: ScopeAccessOptions): boolean;
 }

package/typings/provider/SingletonProvider.d.ts

@@ -1,12 +1,14 @@
 import type { IContainer } from '../container/IContainer';
 import type { IProvider } from './IProvider';
 import { ProviderDecorator } from './IProvider';
-import type { Cache } from './Cache';
 import { InjectOptions } from '../injector/IInjector';
+type GetCacheKey = (...args: unknown[]) => string | symbol;
 export declare class SingletonProvider<T> extends ProviderDecorator<T> {
-    private readonly provider;
-    private readonly cache;
-    constructor(provider: IProvider<T>, cache: Cache<unknown, T>);
+    private provider;
+    private getKey;
+    private cache;
+    constructor(provider: IProvider<T>, getKey: GetCacheKey);
     resolve(container: IContainer, options: InjectOptions): T;
 }
-export declare const singleton: <T = unknown>(cacheProvider?: () => Cache<unknown, T>) => import("./ProviderPipe").ProviderPipe<T>;
+export declare const singleton: <T = unknown>(getCacheKey?: GetCacheKey) => import("./ProviderPipe").ProviderPipe<T>;
+export {};

package/typings/token/toToken.d.ts

@@ -3,3 +3,4 @@ import { InjectionToken } from './InjectionToken';
 import { InjectFn } from '../hooks/hook';
 import { type constructor } from '../utils/basic';
 export declare const toToken: <T = any>(token: InjectFn<T> | InjectionToken<T> | DependencyKey | constructor<T>) => InjectionToken<T>;
+export declare const argToToken: (v: unknown) => InjectionToken<unknown>;

package/cjm/provider/Cache.js

@@ -1,41 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SingleCache = exports.multiCache = exports.MultiCache = void 0;
-class MultiCache {
-    getKey;
-    instances = new Map();
-    static fromFirstArg() {
-        return new MultiCache((key) => key);
-    }
-    constructor(getKey = () => '1') {
-        this.getKey = getKey;
-    }
-    hasValue(token) {
-        return this.instances.has(token);
-    }
-    getValue(token) {
-        return this.instances.get(token);
-    }
-    setValue(token, value) {
-        this.instances.set(token, value);
-    }
-}
-exports.MultiCache = MultiCache;
-const multiCache = (getKey) => new MultiCache(getKey);
-exports.multiCache = multiCache;
-class SingleCache {
-    instance;
-    getKey(...args) {
-        return '1';
-    }
-    getValue(key) {
-        return this.instance.value;
-    }
-    hasValue(key) {
-        return this.instance !== undefined;
-    }
-    setValue(key, value) {
-        this.instance = { value };
-    }
-}
-exports.SingleCache = SingleCache;

package/esm/provider/Cache.js

@@ -1,35 +0,0 @@
-export class MultiCache {
-    getKey;
-    instances = new Map();
-    static fromFirstArg() {
-        return new MultiCache((key) => key);
-    }
-    constructor(getKey = () => '1') {
-        this.getKey = getKey;
-    }
-    hasValue(token) {
-        return this.instances.has(token);
-    }
-    getValue(token) {
-        return this.instances.get(token);
-    }
-    setValue(token, value) {
-        this.instances.set(token, value);
-    }
-}
-export const multiCache = (getKey) => new MultiCache(getKey);
-export class SingleCache {
-    instance;
-    getKey(...args) {
-        return '1';
-    }
-    getValue(key) {
-        return this.instance.value;
-    }
-    hasValue(key) {
-        return this.instance !== undefined;
-    }
-    setValue(key, value) {
-        this.instance = { value };
-    }
-}

package/typings/provider/Cache.d.ts

@@ -1,24 +0,0 @@
-import type { DependencyKey } from '../container/IContainer';
-export interface Cache<K, V> {
-    getKey(...args: unknown[]): K;
-    hasValue(key: K): boolean;
-    getValue(key: K): V;
-    setValue(key: K, value: V): void;
-}
-export declare class MultiCache<K, V> implements Cache<K, V> {
-    readonly getKey: (...args: unknown[]) => K;
-    private instances;
-    static fromFirstArg(): MultiCache<DependencyKey, unknown>;
-    constructor(getKey?: (...args: unknown[]) => K);
-    hasValue(token: K): boolean;
-    getValue(token: K): V;
-    setValue(token: K, value: V): void;
-}
-export declare const multiCache: <K, V>(getKey: (...args: unknown[]) => K) => MultiCache<K, V>;
-export declare class SingleCache<V> implements Cache<string, V> {
-    private instance?;
-    getKey(...args: unknown[]): string;
-    getValue(key: string): V;
-    hasValue(key: string): boolean;
-    setValue(key: string, value: V): void;
-}