ts-ioc-container 48.0.0 → 49.1.0

package/README.md

@@ -1912,13 +1912,15 @@ When you pass an `InjectionToken` via `token.args(...)`, the container resolves
 - `ServiceToken.args(new ClassToken(SomeService))` — `SomeService` is constructed by the container
 - `ServiceToken.args('literal')` — literal value passed directly
 
-### Positional arg injection with `args(index)`
+### Positional arg injection with `args(index)` and `argsFn`
 
 Constructor parameters that should pick up positional args from `ProviderOptions` must be annotated with `@inject(args(index))`. Parameters without `@inject` resolve to `undefined`.
 
 - `@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
 
+`args(index)` and `argsFn(fn)` are thin shortcuts for an `InjectFn`. Every `InjectFn` receives `(scope, options)`, where `options.args` is the runtime args array — so `args(0)` is just `(scope, { args = [] }) => args[0]`, and `argsFn(fn)` is `(scope, { args = [] }) => fn(...args)` (the runtime args are spread into your callback as positional parameters).
+
 ### 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).
@@ -1962,12 +1964,13 @@ describe('ArgsProvider', function () {
 
   describe('Static Arguments', () => {
     it('can pass static arguments to constructor', function () {
+      // Pre-configure the logger with a filename
+      @register(setArgs('/var/log/app.log'))
       class FileLogger {
         constructor(@inject(args(0)) public filename: string) {}
       }
 
-      // Pre-configure the logger with a filename
-      const root = createContainer().addRegistration(R.fromClass(FileLogger).pipe(setArgs('/var/log/app.log')));
+      const root = createContainer().addRegistration(R.fromClass(FileLogger));
 
       // Resolve by class name (default key) to use the registered provider
       const logger = root.resolve<FileLogger>('FileLogger');
@@ -1975,15 +1978,15 @@ describe('ArgsProvider', function () {
     });
 
     it('prioritizes provided args over resolve args', function () {
+      // 'FixedContext' wins over any runtime args
+      @register(setArgs('FixedContext'))
       class Logger {
         constructor(@inject(args(0)) public context: string) {}
       }
 
-      // 'FixedContext' wins over any runtime args
-      const root = createContainer().addRegistration(R.fromClass(Logger).pipe(setArgs('FixedContext')));
+      const root = createContainer().addRegistration(R.fromClass(Logger));
 
       // Even if we ask for 'RuntimeContext', we get 'FixedContext'
-      // Resolve by class name to use the registered provider
       const logger = root.resolve<Logger>('Logger', { args: ['RuntimeContext'] });
 
       expect(logger.context).toBe('FixedContext');
@@ -1996,19 +1999,15 @@ describe('ArgsProvider', function () {
         env = 'production';
       }
 
+      // Extract 'env' from Config service dynamically
+      @register(setArgsFn((scope) => [scope.resolve<Config>('Config').env]))
       class Service {
         constructor(@inject(args(0)) public env: string) {}
       }
 
       const root = createContainer()
         .addRegistration(R.fromClass(Config)) // Key: 'Config'
-        .addRegistration(
-          R.fromClass(Service).pipe(
-            // Extract 'env' from Config service dynamically
-            // Note: We resolve 'Config' by string key to get the registered instance (if it were singleton)
-            setArgsFn((scope) => [scope.resolve<Config>('Config').env]),
-          ),
-        );
+        .addRegistration(R.fromClass(Service));
 
       const service = root.resolve<Service>('Service');
       expect(service.env).toBe('production');

package/cjm/injector/inject.js

@@ -15,13 +15,11 @@ const args = (index) => (c, { args = [] }) => {
     return args[index];
 };
 exports.args = args;
-const argsFn = (fn) => (c, options) => fn(options.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 argToToken = (v) => ((0, InjectionToken_1.isInjectionToken)(v) ? v : new ConstantToken_1.ConstantToken(v));
 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(argToToken).map((t) => t.resolve(scope)), lazy }));
 };
 exports.resolveArgs = resolveArgs;

package/esm/injector/inject.js

@@ -10,11 +10,9 @@ export const inject = (fn) => (target, propertyKey, parameterIndex) => {
 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 argsFn = (fn) => (c, options) => fn(...(options.args ?? []));
+const argToToken = (v) => (isInjectionToken(v) ? v : new ConstantToken(v));
 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-ioc-container",
-  "version": "48.0.0",
+  "version": "49.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"

package/typings/injector/inject.d.ts

@@ -5,5 +5,5 @@ import { type constructor } from '../utils/basic';
 import { ProviderOptions } from '../provider/IProvider';
 export declare const inject: <T>(fn: InjectionToken<T> | InjectFn<T> | symbol | string | constructor<T>) => ParameterDecorator;
 export declare const args: (index: number) => InjectFn;
-export declare const argsFn: <T>(fn: (args: unknown[]) => T) => InjectFn<T>;
+export declare const argsFn: <T>(fn: (...args: unknown[]) => T) => InjectFn<T>;
 export declare const resolveArgs: (Target: constructor<unknown>, methodName?: string) => (scope: IContainer, { args, lazy }: ProviderOptions) => unknown[];