ts-ioc-container 47.4.0 → 47.5.0

package/README.md

@@ -248,9 +248,14 @@ describe('Basic usage', function () {
 ### Scope
 Sometimes you need to create a scope of container. For example, when you want to create a scope per request in web application. You can assign tags to scope and provider and resolve dependencies only from certain scope.
 
-- NOTICE: remember that when scope doesn't have dependency then it will be resolved from parent container
-- NOTICE: when you create a scope of container then all providers are cloned to new scope. For that reason every provider has methods `clone` and `isValid` to clone itself and check if it's valid for certain scope accordingly.
-- NOTICE: when you create a scope then we clone ONLY tags-matched providers.
+> [!IMPORTANT]
+> Scope creation is snapshot-like. Existing parent registrations are applied to the child scope when `createScope()` is called, and when a scope doesn't have a dependency it resolves from the parent container.
+
+> [!WARNING]
+> Registrations added to a parent after a child scope has already been created are not automatically applied to that existing child. Create a new scope or add the registration to the child explicitly.
+
+> [!WARNING]
+> Scope matching happens when a registration is applied to a container. Only registrations whose scope rules match that container are registered there.
 
 ```typescript
 import 'reflect-metadata';
@@ -347,10 +352,12 @@ describe('Scopes', function () {
 You can dynamically add tags to a container after it's been created using the `addTags()` method. This is useful for environment-based configuration, feature flags, and progressive container setup.
 
 - Tags can be added one at a time or multiple at once
-- Tags must be added **before** registrations are applied - scope matching happens at registration time
 - Useful for conditional configuration based on `NODE_ENV` or runtime flags
 - Container can be configured incrementally as the application initializes
 
+> [!WARNING]
+> Tags must be added **before** registrations are applied. Scope matching happens at registration time, so adding tags later does not retroactively make providers available.
+
 ```typescript
 import { bindTo, Container, register, Registration as R, scope } from 'ts-ioc-container';
 
@@ -636,11 +643,13 @@ describe('hasRegistration', function () {
 ```
 
 ### Dispose
-Sometimes you want to dispose container and all its scopes. For example, when you want to prevent memory leaks. Or you want to ensure that nobody can use container after it was disposed.
+Sometimes you want to dispose a container or scope. For example, when a request, page, widget, or other local lifecycle ends.
 
 - container can be disposed
-- when container is disposed then all scopes are disposed too
-- when container is disposed then it unregisters all providers and remove all instances
+- when container is disposed then it runs its `onDispose` hooks, unregisters its providers, removes its local instances, and detaches from its parent
+
+> [!IMPORTANT]
+> Dispose is local to the container being disposed. Child scopes are not disposed automatically; dispose them explicitly when their own lifecycle ends.
 
 ```typescript
 import 'reflect-metadata';
@@ -744,6 +753,14 @@ describe('Disposing', function () {
 ### Lazy
 Sometimes you want to create dependency only when somebody want to invoke it's method or property. This is what `lazy` is for.
 
+- Lazy class instances are wrapped in a JavaScript `Proxy`; the real class instance is created on first property or method access.
+
+> [!IMPORTANT]
+> `lazy` is designed only for class instances resolved from class providers.
+
+> [!WARNING]
+> Do not use `lazy` for primitive values, plain values, functions, or non-class provider results.
+
 ```typescript
 import 'reflect-metadata';
 import { Container, inject, register, Registration as R, select as s, singleton } from 'ts-ioc-container';
@@ -869,7 +886,7 @@ describe('lazy provider', () => {
 ```
 
 ### Lazy with registerPipe
-The `lazy()` registerPipe can be used in two ways: with the `@register` decorator or directly on the `Provider` pipe. This allows you to defer expensive service initialization until first access.
+The `lazy()` registerPipe can be used in two ways: with the `@register` decorator or directly on the `Provider` pipe. This allows you to defer expensive class instance initialization until first access.
 
 **Use cases:**
 - Defer expensive initialization (database connections, SMTP, external APIs)
@@ -1466,22 +1483,12 @@ describe('SimpleInjector', function () {
 ### Proxy
 This type of injector injects dependencies as dictionary `Record<string, unknown>`.
 
+- **`args` reserved keyword**: accessing `deps.args` returns the raw `args[]` array passed at resolve time
+- **Alias convention**: any property name containing `"alias"` (case-insensitive) is resolved via `resolveByAlias` instead of `resolve`
+
 ```typescript
 import { Container, ProxyInjector, Registration as R } from 'ts-ioc-container';
 
-/**
- * Clean Architecture - Proxy Injector
- *
- * The ProxyInjector injects dependencies as a single object (props/options pattern).
- * This is popular in modern JavaScript/TypeScript (like React props or destructuring).
- *
- * Advantages:
- * - Named parameters are more readable than positional arguments
- * - Order of arguments doesn't matter
- * - Easy to add/remove dependencies without breaking inheritance chains
- * - Works well with "Clean Architecture" adapters
- */
-
 describe('ProxyInjector', function () {
   it('should inject dependencies as a props object', function () {
     class Logger {
@@ -1490,13 +1497,11 @@ describe('ProxyInjector', function () {
       }
     }
 
-    // Dependencies defined as an interface
     interface UserControllerDeps {
       logger: Logger;
       prefix: string;
     }
 
-    // Controller receives all dependencies in a single object
     class UserController {
       private logger: Logger;
       private prefix: string;
@@ -1521,19 +1526,20 @@ describe('ProxyInjector', function () {
     expect(controller.createUser('bob')).toBe('Logged: USER: bob');
   });
 
-  it('should support mixing injected dependencies with runtime arguments', function () {
+  it('should expose runtime args through the reserved "args" property', function () {
     class Database {}
 
-    interface ReportGeneratorDeps {
+    class ReportGenerator {
       database: Database;
-      format: string; // Runtime argument
-    }
+      format: string;
 
-    class ReportGenerator {
-      constructor(public deps: ReportGeneratorDeps) {}
+      constructor({ database, args }: { database: Database; args: string[] }) {
+        this.database = database;
+        this.format = args[0];
+      }
 
       generate(): string {
-        return `Report in ${this.deps.format}`;
+        return `Report in ${this.format}`;
       }
     }
 
@@ -1541,24 +1547,20 @@ describe('ProxyInjector', function () {
       .addRegistration(R.fromClass(Database).bindToKey('database'))
       .addRegistration(R.fromClass(ReportGenerator).bindToKey('ReportGenerator'));
 
-    // "format" is passed at resolution time
     const generator = container.resolve<ReportGenerator>('ReportGenerator', {
-      args: [{ format: 'PDF' }],
+      args: ['PDF'],
     });
 
-    expect(generator.deps.database).toBeInstanceOf(Database);
+    expect(generator.database).toBeInstanceOf(Database);
     expect(generator.generate()).toBe('Report in PDF');
   });
 
-  it('should resolve array dependencies by alias (convention over configuration)', function () {
-    // If a property is named "loggersArray", it looks for alias "loggersArray"
-    // and resolves it as an array of all matches.
-
+  it('should resolve dependencies by alias when property name contains "alias"', function () {
     class FileLogger {}
     class ConsoleLogger {}
 
     interface AppDeps {
-      loggersArray: any[]; // Injected as array of all loggers
+      loggersAlias: any[];
     }
 
     class App {
@@ -1567,17 +1569,13 @@ describe('ProxyInjector', function () {
 
     const container = new Container({ injector: new ProxyInjector() });
 
-    // Mocking the behavior for this specific test as ProxyInjector uses resolveByAlias
-    // which delegates to the container.
-    // In a real scenario, you'd register multiple loggers with the same alias.
     const mockLoggers = [new FileLogger(), new ConsoleLogger()];
-
     container.resolveByAlias = vi.fn().mockReturnValue(mockLoggers);
 
     const app = container.resolve(App);
 
-    expect(app.deps.loggersArray).toBe(mockLoggers);
-    expect(container.resolveByAlias).toHaveBeenCalledWith('loggersArray');
+    expect(app.deps.loggersAlias).toBe(mockLoggers);
+    expect(container.resolveByAlias).toHaveBeenCalledWith('loggersAlias');
   });
 });
 
@@ -1740,7 +1738,9 @@ describe('Provider', () => {
 Sometimes you need to create only one instance of dependency per scope. For example, you want to create only one logger per scope.
 
 - Singleton provider creates only one instance in every scope where it's resolved.
-- NOTICE: if you create a scope 'A' of container 'root' then Logger of A !== Logger of root.
+
+> [!IMPORTANT]
+> Singleton means one instance per scope. If you create a scope `A` of container `root`, then `Logger` of `A` !== `Logger` of `root`.
 
 ```typescript
 import 'reflect-metadata';
@@ -1831,13 +1831,28 @@ Sometimes you want to bind some arguments to provider. This is what `ArgsProvide
 - `provider(setArgs('someArgument'))`
 - `provider(setArgsFn((container) => [container.resolve(Logger), 'someValue']))`
 - `Provider.fromClass(Logger).pipe(setArgs('someArgument'))`
-- NOTICE: args from this provider has higher priority than args from `resolve` method.
+- Use `setArgsFn(resolveByArgs)` to resolve `InjectionToken` args at resolution time (tokens are resolved, primitives pass through)
+
+### Token as argument
+When passing args via `token.args(...)`, if an argument is an `InjectionToken` and the provider uses `setArgsFn(resolveByArgs)`, the token is resolved to its value rather than wrapped as a constant.
+- `ServiceToken.args(ValueToken)` — `ValueToken` is resolved from the container, its value is passed as arg
+- `ServiceToken.args('literal')` — literal value passed directly
 
 ### Positional arg injection with `args(index)`
 Use `@inject(args(index))` to explicitly bind a constructor parameter to a positional argument from `ProviderOptions`. This is useful when combining `setArgsFn(resolveByArgs)` with token-based arg passing.
 - `@inject(args(0))` — resolves the first element of the `args` array passed at resolution time
 - Works together with `token.args(...)` to pass typed dependencies through the args context
 
+### Immutable token chaining
+`token.args(...)`, `token.argsFn(...)`, and `token.lazy()` all return **new token instances** — the parent token is never mutated. This allows the same token to be specialized in multiple independent ways (one-way linked list: parent → many children).
+
+```typescript
+const ApiToken = new SingleToken<IApiClient>('IApiClient');
+// Independent children — ApiToken is unchanged
+const dataToken = ApiToken.args('https://data.api.com', 5000);
+const userToken = ApiToken.args('https://users.api.com', 1000);
+```
+
 ```typescript
 import {
   setArgs,
@@ -2008,6 +2023,10 @@ describe('ArgsProvider', function () {
 
 ### Visibility
 Sometimes you want to hide dependency if somebody wants to resolve it from certain scope. This uses `ScopeAccessRule` to control access.
+
+> [!IMPORTANT]
+> Use `scope()` to decide where a provider is registered. Use `scopeAccess()` to decide which invocation scopes can see an already registered provider.
+
 - `provider(scopeAccess(({ invocationScope, providerScope }) => invocationScope === providerScope))` - dependency will be accessible only from the scope where it's registered
 - `Provider.fromClass(Logger).pipe(scopeAccess(({ invocationScope, providerScope }) => invocationScope === providerScope))`
 
@@ -2808,4 +2827,3 @@ describe('inject property', () => {
 - [MethodNotImplementedError.ts](..%2F..%2Flib%2Ferrors%2FMethodNotImplementedError.ts)
 - [DependencyMissingKeyError.ts](..%2F..%2Flib%2Ferrors%2FDependencyMissingKeyError.ts)
 - [ContainerDisposedError.ts](..%2F..%2Flib%2Ferrors%2FContainerDisposedError.ts)
-

package/cjm/container/Container.js

@@ -67,7 +67,7 @@ class Container {
         const provider = key ? this.findProviderByKeyOrFail(key) : undefined;
         return provider?.hasAccess({ invocationScope: child, providerScope: this })
             ? provider.resolve(this, { args, lazy })
-            : this.parent.resolveOneByAlias(key, { args, child, lazy });
+            : this.parent.resolveOneByAlias(alias, { args, child, lazy });
     }
     createScope({ tags } = {}) {
         this.validateContainer();

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.resolveByArgs = exports.ProviderDecorator = exports.setArgs = exports.setArgsFn = exports.lazy = exports.scopeAccess = exports.ProxyInjector = exports.SimpleInjector = exports.MetadataInjector = exports.Injector = 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.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.resolveByArgs = 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 = exports.toSingleAlias = void 0;
 // Containers
 var IContainer_1 = require("./container/IContainer");
 Object.defineProperty(exports, "isDependencyKey", { enumerable: true, get: function () { return IContainer_1.isDependencyKey; } });
@@ -14,6 +14,7 @@ var inject_1 = require("./injector/inject");
 Object.defineProperty(exports, "inject", { enumerable: true, get: function () { return inject_1.inject; } });
 Object.defineProperty(exports, "resolveArgs", { enumerable: true, get: function () { return inject_1.resolveArgs; } });
 Object.defineProperty(exports, "args", { enumerable: true, get: function () { return inject_1.args; } });
+Object.defineProperty(exports, "argsFn", { enumerable: true, get: function () { return inject_1.argsFn; } });
 var IInjector_1 = require("./injector/IInjector");
 Object.defineProperty(exports, "Injector", { enumerable: true, get: function () { return IInjector_1.Injector; } });
 var MetadataInjector_1 = require("./injector/MetadataInjector");

package/cjm/injector/ProxyInjector.js

@@ -2,21 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProxyInjector = void 0;
 const IInjector_1 = require("./IInjector");
-function getProp(target, key) {
-    // @ts-ignore
-    return target[key];
-}
 class ProxyInjector extends IInjector_1.Injector {
-    createInstance(scope, Target, { args: deps = [] } = {}) {
-        const args = deps.reduce((acc, it) => ({ ...acc, ...it }), {});
+    createInstance(scope, Target, { args = [] } = {}) {
         const proxy = new Proxy({}, {
             get(target, prop) {
-                // eslint-disable-next-line no-prototype-builtins
-                return args.hasOwnProperty(prop)
-                    ? getProp(args, prop)
-                    : prop.toString().search(/array/gi) >= 0
-                        ? scope.resolveByAlias(prop)
-                        : scope.resolve(prop);
+                if (prop === 'args') {
+                    return args;
+                }
+                return prop.toString().search(/alias/gi) >= 0 ? scope.resolveByAlias(prop) : scope.resolve(prop);
             },
         });
         return new Target(proxy);

package/cjm/injector/inject.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveArgs = exports.args = exports.inject = void 0;
+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 array_1 = require("../utils/array");
@@ -15,10 +16,14 @@ const args = (index) => (c, { args = [] }) => {
     return args[index];
 };
 exports.args = args;
+const argsFn = (fn) => (c, options) => fn(options.args ?? []);
+exports.argsFn = argsFn;
 const resolveArgs = (Target, methodName) => {
     const argsTokens = (0, parameter_1.getParamMeta)(hookMetaKey(methodName), Target);
     return (scope, { args = [], lazy }) => {
-        const depsTokens = args.map((v) => new ConstantToken_1.ConstantToken(v));
+        const depsTokens = args.map((v) => {
+            return !(0, InjectionToken_1.isInjectionToken)(v) ? new ConstantToken_1.ConstantToken(v) : v;
+        });
         const allTokens = (0, array_1.fillEmptyIndexes)(argsTokens, depsTokens);
         return allTokens.map((fn) => fn.resolve(scope, { args, lazy }));
     };

package/cjm/provider/IProvider.js

@@ -8,7 +8,7 @@ const setArgs = (...extraArgs) => (0, ProviderPipe_1.registerPipe)((p) => p.setA
 exports.setArgs = setArgs;
 const setArgsFn = (fn) => (0, ProviderPipe_1.registerPipe)((p) => p.setArgs(fn));
 exports.setArgsFn = setArgsFn;
-const resolveByArgs = (s, ...deps) => deps.map((d) => {
+const resolveByArgs = (s, { args = [] } = {}) => args.map((d) => {
     if (d instanceof InjectionToken_1.InjectionToken) {
         return d.resolve(s);
     }

package/cjm/provider/Provider.js

@@ -14,7 +14,7 @@ class Provider {
     static fromKey(key) {
         return new Provider((c) => c.resolve(key));
     }
-    argsFn = () => [];
+    argsFn = (s, { args = [] } = {}) => args;
     checkAccess = () => true;
     isLazy = false;
     constructor(resolveDependency) {
@@ -26,7 +26,7 @@ class Provider {
     }
     resolve(container, { args = [], lazy } = {}) {
         return this.resolveDependency(container, {
-            args: [...this.argsFn(container, ...args), ...args],
+            args: this.argsFn(container, { args }),
             lazy: lazy ?? this.isLazy,
         });
     }

package/cjm/registration/Registration.js

@@ -13,9 +13,9 @@ class Registration {
     createProvider;
     key;
     scopeRules;
-    static fromClass(Target) {
+    static fromClass(Target, { name } = {}) {
         const transform = (0, fp_1.pipe)(...(0, IRegistration_1.getTransformers)(Target));
-        return transform(new Registration(() => Provider_1.Provider.fromClass(Target), Target.name));
+        return transform(new Registration(() => Provider_1.Provider.fromClass(Target), name ?? Target.name));
     }
     static fromValue(value) {
         if (basic_1.Is.constructor(value)) {

package/cjm/token/ClassToken.js

@@ -3,33 +3,43 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ClassToken = void 0;
 const InjectionToken_1 = require("./InjectionToken");
 class ClassToken extends InjectionToken_1.InjectionToken {
-    token;
-    options;
-    constructor(token, options = {}) {
+    target;
+    _getArgsFn;
+    _isLazy;
+    constructor(target, { getArgsFn = () => [], isLazy = false } = {}) {
         super();
-        this.token = token;
-        this.options = options;
+        this.target = target;
+        this._getArgsFn = getArgsFn;
+        this._isLazy = isLazy;
     }
     select(fn) {
         return (s) => fn(this.resolve(s));
     }
-    resolve(s) {
-        const argsFn = this.options.argsFn ?? (0, InjectionToken_1.setArgs)();
-        return s.resolve(this.token, {
-            args: argsFn(s),
-            lazy: this.options.lazy,
+    resolve(s, { args = [], lazy } = {}) {
+        return s.resolve(this.target, {
+            args: this._getArgsFn(s, { args }),
+            lazy: this._isLazy || lazy,
         });
     }
-    args(...args) {
-        const argsFn = this.options.argsFn ?? (0, InjectionToken_1.setArgs)();
-        return new ClassToken(this.token, { ...this.options, argsFn: (s) => [...argsFn(s), ...args] });
+    args(...newArgs) {
+        const parentFn = this._getArgsFn;
+        return new ClassToken(this.target, {
+            getArgsFn: (s, opts) => [...parentFn(s, opts), ...newArgs],
+            isLazy: this._isLazy,
+        });
     }
-    argsFn(getArgsFn) {
-        const argsFn = this.options.argsFn ?? (0, InjectionToken_1.setArgs)();
-        return new ClassToken(this.token, { ...this.options, argsFn: (s) => [...argsFn(s), ...getArgsFn(s)] });
+    argsFn(fn) {
+        const parentFn = this._getArgsFn;
+        return new ClassToken(this.target, {
+            getArgsFn: (s, opts) => [...parentFn(s, opts), ...fn(s)],
+            isLazy: this._isLazy,
+        });
     }
     lazy() {
-        return new ClassToken(this.token, { ...this.options, lazy: true });
+        return new ClassToken(this.target, {
+            getArgsFn: this._getArgsFn,
+            isLazy: true,
+        });
     }
 }
 exports.ClassToken = ClassToken;

package/cjm/token/FunctionToken.js

@@ -4,29 +4,39 @@ exports.FunctionToken = void 0;
 const InjectionToken_1 = require("./InjectionToken");
 class FunctionToken extends InjectionToken_1.InjectionToken {
     fn;
-    getArgsFn = () => [];
-    isLazy = false;
-    constructor(fn) {
+    _getArgsFn;
+    _isLazy;
+    constructor(fn, { getArgsFn = (_, { args = [] } = {}) => args, isLazy = false } = {}) {
         super();
         this.fn = fn;
+        this._getArgsFn = getArgsFn;
+        this._isLazy = isLazy;
     }
-    resolve(s, { args = [], lazy = false } = {}) {
+    resolve(s, { args = [], lazy } = {}) {
         return this.fn(s, {
-            args: [...args, ...this.getArgsFn(s)],
-            lazy: this.isLazy || lazy,
+            args: this._getArgsFn(s, { args }),
+            lazy: this._isLazy || lazy,
         });
     }
-    args(...deps) {
-        this.getArgsFn = () => deps;
-        return this;
+    args(...newArgs) {
+        const parentFn = this._getArgsFn;
+        return new FunctionToken(this.fn, {
+            getArgsFn: (s, opts) => [...parentFn(s, opts), ...newArgs],
+            isLazy: this._isLazy,
+        });
     }
-    argsFn(getArgsFn) {
-        this.getArgsFn = getArgsFn;
-        return this;
+    argsFn(fn) {
+        const parentFn = this._getArgsFn;
+        return new FunctionToken(this.fn, {
+            getArgsFn: (s, opts) => [...parentFn(s, opts), ...fn(s)],
+            isLazy: this._isLazy,
+        });
     }
-    lazy(isLazy = true) {
-        this.isLazy = isLazy;
-        return this;
+    lazy() {
+        return new FunctionToken(this.fn, {
+            getArgsFn: this._getArgsFn,
+            isLazy: true,
+        });
     }
 }
 exports.FunctionToken = FunctionToken;

package/cjm/token/GroupAliasToken.js

@@ -4,43 +4,44 @@ exports.toGroupAlias = exports.GroupAliasToken = void 0;
 const InjectionToken_1 = require("./InjectionToken");
 class GroupAliasToken extends InjectionToken_1.InjectionToken {
     token;
-    options;
-    constructor(token, options = {}) {
+    _getArgsFn;
+    _isLazy;
+    constructor(token, { getArgsFn = () => [], isLazy = false } = {}) {
         super();
         this.token = token;
-        this.options = options;
+        this._getArgsFn = getArgsFn;
+        this._isLazy = isLazy;
     }
     select(fn) {
         return (s) => fn(this.resolve(s));
     }
-    resolve(s) {
-        const argsFn = this.options.argsFn ?? (0, InjectionToken_1.setArgs)();
+    resolve(s, { args = [], lazy } = {}) {
         return s.resolveByAlias(this.token, {
-            args: argsFn(s),
-            lazy: this.options.lazy,
+            args: this._getArgsFn(s, { args }),
+            lazy: this._isLazy || lazy,
         });
     }
     bindTo(r) {
         r.bindToAlias(this.token);
     }
-    args(...args) {
-        const argsFn = this.options.argsFn ?? (0, InjectionToken_1.setArgs)();
+    args(...newArgs) {
+        const parentFn = this._getArgsFn;
         return new GroupAliasToken(this.token, {
-            ...this.options,
-            argsFn: (s) => [...argsFn(s), ...args],
+            getArgsFn: (s, opts) => [...parentFn(s, opts), ...newArgs],
+            isLazy: this._isLazy,
         });
     }
-    argsFn(getArgsFn) {
-        const argsFn = this.options.argsFn ?? (0, InjectionToken_1.setArgs)();
+    argsFn(fn) {
+        const parentFn = this._getArgsFn;
         return new GroupAliasToken(this.token, {
-            ...this.options,
-            argsFn: (s) => [...argsFn(s), ...getArgsFn(s)],
+            getArgsFn: (s, opts) => [...parentFn(s, opts), ...fn(s)],
+            isLazy: this._isLazy,
         });
     }
     lazy() {
         return new GroupAliasToken(this.token, {
-            ...this.options,
-            lazy: true,
+            getArgsFn: this._getArgsFn,
+            isLazy: true,
         });
     }
 }

package/cjm/token/InjectionToken.js

@@ -1,8 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setArgs = exports.InjectionToken = void 0;
+exports.isInjectionToken = isInjectionToken;
+const basic_1 = require("../utils/basic");
 class InjectionToken {
 }
 exports.InjectionToken = InjectionToken;
 const setArgs = (...args) => (s) => args;
 exports.setArgs = setArgs;
+function isInjectionToken(target) {
+    return basic_1.Is.object(target) && 'resolve' in target && 'args' in target && 'argsFn' in target && 'lazy' in target;
+}

package/cjm/token/SingleAliasToken.js

@@ -4,43 +4,44 @@ exports.toSingleAlias = exports.SingleAliasToken = void 0;
 const InjectionToken_1 = require("./InjectionToken");
 class SingleAliasToken extends InjectionToken_1.InjectionToken {
     token;
-    options;
-    constructor(token, options = {}) {
+    _getArgsFn;
+    _isLazy;
+    constructor(token, { getArgsFn = () => [], isLazy = false } = {}) {
         super();
         this.token = token;
-        this.options = options;
+        this._getArgsFn = getArgsFn;
+        this._isLazy = isLazy;
     }
     select(fn) {
         return (s) => fn(this.resolve(s));
     }
-    resolve(s) {
-        const argsFn = this.options.argsFn ?? (0, InjectionToken_1.setArgs)();
+    resolve(s, { args = [], lazy } = {}) {
         return s.resolveOneByAlias(this.token, {
-            args: argsFn(s),
-            lazy: this.options.lazy,
+            args: this._getArgsFn(s, { args }),
+            lazy: this._isLazy || lazy,
         });
     }
     bindTo(r) {
         r.bindToAlias(this.token);
     }
-    args(...args) {
-        const argsFn = this.options.argsFn ?? (0, InjectionToken_1.setArgs)();
+    args(...newArgs) {
+        const parentFn = this._getArgsFn;
         return new SingleAliasToken(this.token, {
-            ...this.options,
-            argsFn: (s) => [...argsFn(s), ...args],
+            getArgsFn: (s, opts) => [...parentFn(s, opts), ...newArgs],
+            isLazy: this._isLazy,
         });
     }
-    argsFn(getArgsFn) {
-        const argsFn = this.options.argsFn ?? (0, InjectionToken_1.setArgs)();
+    argsFn(fn) {
+        const parentFn = this._getArgsFn;
         return new SingleAliasToken(this.token, {
-            ...this.options,
-            argsFn: (s) => [...argsFn(s), ...getArgsFn(s)],
+            getArgsFn: (s, opts) => [...parentFn(s, opts), ...fn(s)],
+            isLazy: this._isLazy,
         });
     }
     lazy() {
         return new SingleAliasToken(this.token, {
-            ...this.options,
-            lazy: true,
+            getArgsFn: this._getArgsFn,
+            isLazy: true,
         });
     }
 }