ts-ioc-container 49.0.0 → 50.0.0

package/README.md

@@ -1461,51 +1461,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 +1485,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 +1530,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 +1549,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 +1565,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');
-  });
 });
 
 ```
@@ -1934,17 +1862,16 @@ const userToken = ApiToken.args('https://users.api.com', 1000);
 
 ```typescript
 import {
-  setArgs,
-  setArgsFn,
+  args,
   bindTo,
   Container,
   inject,
-  args,
-  MultiCache,
   register,
   Registration as R,
-  singleton,
+  setArgs,
+  setArgsFn,
   SingleToken,
+  singleton,
 } from 'ts-ioc-container';
 
 /**
@@ -2044,7 +1971,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 +2501,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
+ *
+ * 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.
  *
- * 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.
+ * 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;
+  }
+
+  getCurrentUserId(): string | null {
+    return this.userId;
+  }
+}
+
+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'] });
 
-    // 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');
+    // Each request has its own SessionService instance
+    const session1 = request1Scope.resolve<SessionService>('ISessionService');
+    const session2 = request2Scope.resolve<SessionService>('ISessionService');
 
-    expect(appState).toBe(requestState);
+    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 +2722,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 +2735,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 +2743,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 +2758,7 @@ describe('onConstruct', function () {
 ### OnDispose
 
 ```typescript
+import 'reflect-metadata';
 import {
   AddOnDisposeHookModule,
   bindTo,
@@ -2829,10 +2786,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 +2801,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 +2813,7 @@ describe('onDispose', function () {
 
     container.dispose();
 
-    expect(logsRepo.savedLogs.join(',')).toBe('Hello,world');
+    expect(logsRepo.savedLogs).toEqual(['Hello']);
   });
 });
 

package/cjm/index.js

@@ -1,7 +1,7 @@
 "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.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;
+exports.SingleToken = exports.ClassToken = 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.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 = void 0;
 // Containers
 var IContainer_1 = require("./container/IContainer");
 Object.defineProperty(exports, "isDependencyKey", { enumerable: true, get: function () { return IContainer_1.isDependencyKey; } });
@@ -35,9 +35,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,11 +15,8 @@ const args = (index) => (c, { args = [] }) => {
 exports.args = args;
 const argsFn = (fn) => (c, options) => fn(...(options.args ?? []));
 exports.argsFn = argsFn;
-const resolveTokens = (scope, deps) => deps.map((v) => ((0, InjectionToken_1.isInjectionToken)(v) ? v : new ConstantToken_1.ConstantToken(v))).map((t) => t.resolve(scope));
 const resolveArgs = (Target, methodName) => {
-    const argsMetaTokens = (0, parameter_1.getParamMeta)(hookMetaKey(methodName), Target);
-    return (scope, { args = [], lazy }) => {
-        return argsMetaTokens.map((fn) => fn.resolve(scope, { args: resolveTokens(scope, args), lazy }));
-    };
+    const tokens = (0, parameter_1.getParamMeta)(hookMetaKey(methodName), Target);
+    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/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

@@ -12,7 +12,6 @@ export { ProxyInjector } from './injector/ProxyInjector';
 export { scopeAccess, lazy, 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,10 +9,7 @@ export const args = (index) => (c, { args = [] }) => {
     return args[index];
 };
 export const argsFn = (fn) => (c, options) => fn(...(options.args ?? []));
-const resolveTokens = (scope, deps) => deps.map((v) => (isInjectionToken(v) ? v : new ConstantToken(v))).map((t) => t.resolve(scope));
 export const resolveArgs = (Target, methodName) => {
-    const argsMetaTokens = getParamMeta(hookMetaKey(methodName), Target);
-    return (scope, { args = [], lazy }) => {
-        return argsMetaTokens.map((fn) => fn.resolve(scope, { args: resolveTokens(scope, args), lazy }));
-    };
+    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/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.0.0",
+  "version": "50.0.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"

package/typings/index.d.ts

@@ -9,7 +9,6 @@ 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 { 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/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;
-}