ts-ioc-container 56.2.0 → 56.3.0

package/README.md

@@ -38,6 +38,7 @@ provider pipelines, aliases, and custom injector strategies.
   - [Lazy with registerPipe](#lazy-with-registerpipe) `lazy()`
 - [Injector](#injector)
   - [Metadata](#metadata) `@inject`
+  - [Mapping injected values](#mapping-injected-values)
   - [Simple](#simple)
   - [Proxy](#proxy)
 - [Provider](#provider) `provider`
@@ -157,7 +158,8 @@ describe('Quickstart', function () {
 - Current scope token: `select.scope.current`
 - Lazy token: `select.token('Service').lazy()`
 - Inject decorator: `@inject('Key')`
-- Property inject: `injectProp(target, 'propName', select.token('Key'))`
+- Map an injected value: `@inject('Key', sanitize(), validate())`
+- Property inject: `@hook('onInit', append(injectProp('Key')))`
 
 > [!TIP]
 > For classes, prefer the `@register(bindTo('Key'))` decorator over the fluent
@@ -1187,6 +1189,78 @@ describe('Metadata Injector', function () {
 
 ```
 
+### Mapping injected values
+
+Every argument after the first one is a **mapper** applied to the resolved
+instance, left to right — the value the last mapper returns is what reaches the
+constructor parameter:
+
+```typescript
+@inject('Config', takeApiUrl(), stripTrailingSlash(), requireHttps())
+```
+
+A mapper is a plain `(value) => value` function, so mappers compose into named,
+reusable steps (selecting a member, sanitizing, validating) and each step's
+parameter type is inferred from the previous one. With no mapper the resolved
+instance is injected untouched.
+
+`injectProp` takes the same rest parameters: `injectProp('Config', takeApiUrl())`.
+
+```typescript
+import 'reflect-metadata';
+import { Container, inject, Registration as R } from 'ts-ioc-container';
+
+/**
+ * Mapping injected values
+ *
+ * Every argument after the first one passed to `@inject` (or `injectProp`) is a
+ * mapper applied to the resolved instance, left to right. Mappers are plain
+ * functions, so they compose into reusable, named steps.
+ */
+
+interface Config {
+  apiUrl: string;
+  retries: number;
+}
+
+// Reusable mappers, each returning a `(value) => value` function
+const takeApiUrl = () => (config: Config) => config.apiUrl;
+const stripTrailingSlash = () => (url: string) => url.replace(/\/$/, '');
+const requireHttps = () => (url: string) => {
+  if (!url.startsWith('https://')) {
+    throw new Error(`Insecure api url: ${url}`);
+  }
+  return url;
+};
+
+describe('inject mappers', () => {
+  it('should pipe the resolved dependency through every mapper', () => {
+    class ApiClient {
+      constructor(@inject('Config', takeApiUrl(), stripTrailingSlash(), requireHttps()) readonly apiUrl: string) {}
+    }
+
+    const container = new Container().addRegistration(
+      R.fromValue<Config>({ apiUrl: 'https://api.com/', retries: 3 }).bindToKey('Config'),
+    );
+
+    expect(container.resolve(ApiClient).apiUrl).toBe('https://api.com');
+  });
+
+  it('should throw from a mapper when the resolved value is not acceptable', () => {
+    class ApiClient {
+      constructor(@inject('Config', takeApiUrl(), requireHttps()) readonly apiUrl: string) {}
+    }
+
+    const container = new Container().addRegistration(
+      R.fromValue<Config>({ apiUrl: 'http://api.com', retries: 3 }).bindToKey('Config'),
+    );
+
+    expect(() => container.resolve(ApiClient)).toThrow('Insecure api url: http://api.com');
+  });
+});
+
+```
+
 ### Simple
 
 This type of injector just passes container to constructor with others arguments.

package/cjm/hooks/injectProp.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.injectProp = void 0;
-const toToken_1 = require("../token/toToken");
-const injectProp = (fn) => (context) => context.setProperty((0, toToken_1.toToken)(fn));
 exports.injectProp = injectProp;
+const toToken_1 = require("../token/toToken");
+function injectProp(fn, ...mappers) {
+    return (context) => context.setProperty((0, toToken_1.toMappedToken)(fn, mappers));
+}

package/cjm/index.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.onContainerDisposedHooksRunner = exports.AddOnConstructAsyncHookModule = exports.onConstructAsync = exports.onConstructAsyncHooksRunner = exports.AddOnConstructHookModule = exports.onConstruct = exports.onConstructHooksRunner = exports.injectProp = exports.createHookContext = exports.createHookContextFactory = exports.HookContext = exports.prepend = exports.append = exports.prependHooks = exports.appendHooks = exports.hasHooks = exports.hook = exports.getHooks = exports.UnsupportedTokenTypeError = exports.CannonSingletonApplyTwiceError = exports.UnexpectedHookResultError = exports.ProviderDisposedError = exports.ContainerDisposedError = exports.MethodNotImplementedError = exports.DependencyMissingKeyError = exports.ContainerNotFoundError = exports.DependencyNotFoundError = exports.ContainerError = exports.Registration = exports.appendArgsFn = exports.appendArgs = exports.decorate = exports.singleton = exports.lazy = exports.scopeAccess = exports.scope = exports.bindTo = exports.register = exports.Provider = exports.ProxyInjector = exports.SimpleInjector = exports.resolveArgs = exports.argsFn = exports.args = exports.inject = exports.MetadataInjector = exports.Injector = 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.addMethodTag = exports.getMethodLabels = exports.addMethodLabel = exports.getMethodMeta = exports.addMethodMeta = exports.getParamTags = exports.addParamTag = exports.getParamLabels = exports.addParamLabel = exports.getParamMeta = exports.addParamMeta = exports.getClassTags = exports.addClassTag = exports.getClassLabels = exports.addClassLabel = exports.getClassMeta = exports.addClassMeta = exports.GroupInstanceToken = exports.ConstantToken = exports.FunctionToken = exports.SingleToken = exports.ClassToken = exports.toSingleAlias = exports.SingleAliasToken = exports.toGroupAlias = exports.GroupAliasToken = exports.InjectionToken = exports.HooksRunner = exports.AddOnDisposeHookModule = exports.onContainerDisposed = 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.addMethodTag = exports.getMethodLabels = exports.addMethodLabel = exports.getMethodMeta = exports.addMethodMeta = exports.getParamTags = exports.addParamTag = exports.getParamLabels = exports.addParamLabel = exports.getParamMeta = exports.addParamMeta = exports.getClassTags = exports.addClassTag = exports.getClassLabels = exports.addClassLabel = exports.getClassMeta = exports.addClassMeta = exports.GroupInstanceToken = exports.ConstantToken = exports.FunctionToken = exports.SingleToken = exports.ClassToken = exports.toSingleAlias = exports.SingleAliasToken = exports.toGroupAlias = exports.GroupAliasToken = exports.argToToken = exports.toMappedToken = exports.toToken = exports.InjectionToken = exports.HooksRunner = exports.AddOnDisposeHookModule = exports.onContainerDisposed = void 0;
 var IContainer_1 = require("./container/IContainer");
 Object.defineProperty(exports, "isDependencyKey", { enumerable: true, get: function () { return IContainer_1.isDependencyKey; } });
 var Container_1 = require("./container/Container");
@@ -84,6 +84,10 @@ var HooksRunner_1 = require("./hooks/HooksRunner");
 Object.defineProperty(exports, "HooksRunner", { enumerable: true, get: function () { return HooksRunner_1.HooksRunner; } });
 var InjectionToken_1 = require("./token/InjectionToken");
 Object.defineProperty(exports, "InjectionToken", { enumerable: true, get: function () { return InjectionToken_1.InjectionToken; } });
+var toToken_1 = require("./token/toToken");
+Object.defineProperty(exports, "toToken", { enumerable: true, get: function () { return toToken_1.toToken; } });
+Object.defineProperty(exports, "toMappedToken", { enumerable: true, get: function () { return toToken_1.toMappedToken; } });
+Object.defineProperty(exports, "argToToken", { enumerable: true, get: function () { return toToken_1.argToToken; } });
 var GroupAliasToken_1 = require("./token/GroupAliasToken");
 Object.defineProperty(exports, "GroupAliasToken", { enumerable: true, get: function () { return GroupAliasToken_1.GroupAliasToken; } });
 Object.defineProperty(exports, "toGroupAlias", { enumerable: true, get: function () { return GroupAliasToken_1.toGroupAlias; } });

package/cjm/injector/MetadataInjector.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveArgs = exports.args = exports.argsFn = exports.inject = exports.MetadataInjector = void 0;
+exports.resolveArgs = exports.args = exports.argsFn = exports.MetadataInjector = void 0;
+exports.inject = inject;
 const IInjector_1 = require("./IInjector");
 const basic_1 = require("../utils/basic");
 const parameter_1 = require("../metadata/parameter");
 const toToken_1 = require("../token/toToken");
-const FunctionToken_1 = require("../token/FunctionToken");
 class MetadataInjector extends IInjector_1.Injector {
     createInstance(scope, Target, { args: deps = [] } = {}) {
         const args = (0, exports.resolveArgs)(Target)(scope, { args: deps });
@@ -14,14 +14,11 @@ class MetadataInjector extends IInjector_1.Injector {
 }
 exports.MetadataInjector = MetadataInjector;
 const hookMetaKey = (methodName = 'constructor') => `inject:${methodName}`;
-const inject = (fn, selectFn = (instance) => instance) => (target, propertyKey, parameterIndex) => {
-    const toSelectedToken = () => {
-        const token = (0, toToken_1.toToken)(fn);
-        return new FunctionToken_1.FunctionToken((scope, options) => selectFn(token.resolve(scope, options)));
+function inject(fn, ...mappers) {
+    return (target, propertyKey, parameterIndex) => {
+        (0, parameter_1.addParamMeta)(hookMetaKey(propertyKey), () => (0, toToken_1.toMappedToken)(fn, mappers))(basic_1.Is.instance(target) ? target.constructor : target, propertyKey, parameterIndex);
     };
-    (0, parameter_1.addParamMeta)(hookMetaKey(propertyKey), toSelectedToken)(basic_1.Is.instance(target) ? target.constructor : target, propertyKey, parameterIndex);
-};
-exports.inject = inject;
+}
 const argsFn = (predicate) => (c, { args = [] }) => args.find((value, index) => predicate(value, index));
 exports.argsFn = argsFn;
 const args = (index) => (0, exports.argsFn)((value, i) => i === index);

package/cjm/token/toToken.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.argToToken = exports.toToken = void 0;
+exports.toMappedToken = exports.argToToken = exports.toToken = void 0;
 const IContainer_1 = require("../container/IContainer");
 const SingleToken_1 = require("./SingleToken");
 const ClassToken_1 = require("./ClassToken");
@@ -9,6 +9,7 @@ const UnsupportedTokenTypeError_1 = require("../errors/UnsupportedTokenTypeError
 const InjectionToken_1 = require("./InjectionToken");
 const basic_1 = require("../utils/basic");
 const ConstantToken_1 = require("./ConstantToken");
+const fp_1 = require("../utils/fp");
 const toToken = (token) => {
     if (token instanceof InjectionToken_1.InjectionToken) {
         return token;
@@ -27,3 +28,9 @@ const toToken = (token) => {
 exports.toToken = toToken;
 const argToToken = (v) => ((0, InjectionToken_1.isInjectionToken)(v) ? v : new ConstantToken_1.ConstantToken(v));
 exports.argToToken = argToToken;
+const toMappedToken = (token, mappers) => {
+    const source = (0, exports.toToken)(token);
+    const mapInstance = (0, fp_1.pipe)(...mappers);
+    return new FunctionToken_1.FunctionToken((scope, options) => mapInstance(source.resolve(scope, options)));
+};
+exports.toMappedToken = toMappedToken;

package/esm/hooks/injectProp.js

@@ -1,2 +1,4 @@
-import { toToken } from '../token/toToken.js';
-export const injectProp = (fn) => (context) => context.setProperty(toToken(fn));
+import { toMappedToken } from '../token/toToken.js';
+export function injectProp(fn, ...mappers) {
+    return (context) => context.setProperty(toMappedToken(fn, mappers));
+}

package/esm/index.js

@@ -26,6 +26,7 @@ export { onConstructAsyncHooksRunner, onConstructAsync, AddOnConstructAsyncHookM
 export { onContainerDisposedHooksRunner, onContainerDisposed, AddOnDisposeHookModule, } from './hooks/onContainerDisposed.js';
 export { HooksRunner } from './hooks/HooksRunner.js';
 export { InjectionToken } from './token/InjectionToken.js';
+export { toToken, toMappedToken, argToToken } from './token/toToken.js';
 export { GroupAliasToken, toGroupAlias } from './token/GroupAliasToken.js';
 export { SingleAliasToken, toSingleAlias } from './token/SingleAliasToken.js';
 export { ClassToken } from './token/ClassToken.js';

package/esm/injector/MetadataInjector.js

@@ -1,8 +1,7 @@
 import { Injector } from './IInjector.js';
 import { Is } from '../utils/basic.js';
 import { getParamMeta, addParamMeta } from '../metadata/parameter.js';
-import { argToToken, toToken } from '../token/toToken.js';
-import { FunctionToken } from '../token/FunctionToken.js';
+import { argToToken, toMappedToken } from '../token/toToken.js';
 export class MetadataInjector extends Injector {
     createInstance(scope, Target, { args: deps = [] } = {}) {
         const args = resolveArgs(Target)(scope, { args: deps });
@@ -10,13 +9,11 @@ export class MetadataInjector extends Injector {
     }
 }
 const hookMetaKey = (methodName = 'constructor') => `inject:${methodName}`;
-export const inject = (fn, selectFn = (instance) => instance) => (target, propertyKey, parameterIndex) => {
-    const toSelectedToken = () => {
-        const token = toToken(fn);
-        return new FunctionToken((scope, options) => selectFn(token.resolve(scope, options)));
+export function inject(fn, ...mappers) {
+    return (target, propertyKey, parameterIndex) => {
+        addParamMeta(hookMetaKey(propertyKey), () => toMappedToken(fn, mappers))(Is.instance(target) ? target.constructor : target, propertyKey, parameterIndex);
     };
-    addParamMeta(hookMetaKey(propertyKey), toSelectedToken)(Is.instance(target) ? target.constructor : target, propertyKey, parameterIndex);
-};
+}
 export const argsFn = (predicate) => (c, { args = [] }) => args.find((value, index) => predicate(value, index));
 export const args = (index) => argsFn((value, i) => i === index);
 export const resolveArgs = (Target, methodName) => {

package/esm/token/toToken.js

@@ -6,6 +6,7 @@ import { UnsupportedTokenTypeError } from '../errors/UnsupportedTokenTypeError.j
 import { InjectionToken, isInjectionToken } from './InjectionToken.js';
 import { Is } from '../utils/basic.js';
 import { ConstantToken } from './ConstantToken.js';
+import { pipe } from '../utils/fp.js';
 export const toToken = (token) => {
     if (token instanceof InjectionToken) {
         return token;
@@ -22,3 +23,8 @@ export const toToken = (token) => {
     throw new UnsupportedTokenTypeError(`Unknown token ${token}`);
 };
 export const argToToken = (v) => (isInjectionToken(v) ? v : new ConstantToken(v));
+export const toMappedToken = (token, mappers) => {
+    const source = toToken(token);
+    const mapInstance = pipe(...mappers);
+    return new FunctionToken((scope, options) => mapInstance(source.resolve(scope, options)));
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-ioc-container",
-  "version": "56.2.0",
+  "version": "56.3.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.",
   "publishConfig": {
     "access": "public",
@@ -79,7 +79,7 @@
     "typescript": "5.8.3",
     "unplugin-swc": "^1.5.9",
     "vite": "^6.4.1",
-    "vitest": "^4.1.2"
+    "vitest": "^4.1.11"
   },
   "engines": {
     "node": ">= 18"

package/typings/hooks/injectProp.d.ts

@@ -1,5 +1,14 @@
-import { DependencyKey } from '../container/IContainer.js';
-import { HookFn, InjectFn } from './hook.js';
-import { InjectionToken } from '../token/InjectionToken.js';
-import { type constructor } from '../utils/basic.js';
-export declare const injectProp: (fn: InjectFn | InjectionToken | DependencyKey | constructor<unknown>) => HookFn;
+import { HookFn } from './hook.js';
+import { type Injectable } from '../token/toToken.js';
+import { type MapFn } from '../utils/fp.js';
+export declare function injectProp<T, B>(fn: Injectable<T>, fn1: MapFn<T, B>): HookFn;
+export declare function injectProp<T, B, C>(fn: Injectable<T>, fn1: MapFn<T, B>, fn2: MapFn<B, C>): HookFn;
+export declare function injectProp<T, B, C, D>(fn: Injectable<T>, fn1: MapFn<T, B>, fn2: MapFn<B, C>, fn3: MapFn<C, D>): HookFn;
+export declare function injectProp<T, B, C, D, E>(fn: Injectable<T>, fn1: MapFn<T, B>, fn2: MapFn<B, C>, fn3: MapFn<C, D>, fn4: MapFn<D, E>): HookFn;
+export declare function injectProp<T, B, C, D, E, F>(fn: Injectable<T>, fn1: MapFn<T, B>, fn2: MapFn<B, C>, fn3: MapFn<C, D>, fn4: MapFn<D, E>, fn5: MapFn<E, F>): HookFn;
+export declare function injectProp<T, B, C, D, E, F, G>(fn: Injectable<T>, fn1: MapFn<T, B>, fn2: MapFn<B, C>, fn3: MapFn<C, D>, fn4: MapFn<D, E>, fn5: MapFn<E, F>, fn6: MapFn<F, G>): HookFn;
+export declare function injectProp<T, B, C, D, E, F, G, H>(fn: Injectable<T>, fn1: MapFn<T, B>, fn2: MapFn<B, C>, fn3: MapFn<C, D>, fn4: MapFn<D, E>, fn5: MapFn<E, F>, fn6: MapFn<F, G>, fn7: MapFn<G, H>): HookFn;
+export declare function injectProp<T, B, C, D, E, F, G, H, I>(fn: Injectable<T>, fn1: MapFn<T, B>, fn2: MapFn<B, C>, fn3: MapFn<C, D>, fn4: MapFn<D, E>, fn5: MapFn<E, F>, fn6: MapFn<F, G>, fn7: MapFn<G, H>, fn8: MapFn<H, I>): HookFn;
+export declare function injectProp<T, B, C, D, E, F, G, H, I, J>(fn: Injectable<T>, fn1: MapFn<T, B>, fn2: MapFn<B, C>, fn3: MapFn<C, D>, fn4: MapFn<D, E>, fn5: MapFn<E, F>, fn6: MapFn<F, G>, fn7: MapFn<G, H>, fn8: MapFn<H, I>, fn9: MapFn<I, J>): HookFn;
+export declare function injectProp<T, B, C, D, E, F, G, H, I, J, K>(fn: Injectable<T>, fn1: MapFn<T, B>, fn2: MapFn<B, C>, fn3: MapFn<C, D>, fn4: MapFn<D, E>, fn5: MapFn<E, F>, fn6: MapFn<F, G>, fn7: MapFn<G, H>, fn8: MapFn<H, I>, fn9: MapFn<I, J>, fn10: MapFn<J, K>): HookFn;
+export declare function injectProp<T>(fn: Injectable<T>, ...mappers: MapFn<T>[]): HookFn;

package/typings/index.d.ts

@@ -27,6 +27,7 @@ export { onConstructAsyncHooksRunner, onConstructAsync, AddOnConstructAsyncHookM
 export { onContainerDisposedHooksRunner, onContainerDisposed, AddOnDisposeHookModule, } from './hooks/onContainerDisposed.js';
 export { HooksRunner, type HooksRunnerContext, type MapHookContext } from './hooks/HooksRunner.js';
 export { InjectionToken } from './token/InjectionToken.js';
+export { type Injectable, toToken, toMappedToken, argToToken } from './token/toToken.js';
 export { GroupAliasToken, toGroupAlias } from './token/GroupAliasToken.js';
 export { SingleAliasToken, toSingleAlias } from './token/SingleAliasToken.js';
 export { ClassToken } from './token/ClassToken.js';

package/typings/injector/MetadataInjector.d.ts

@@ -1,13 +1,24 @@
 import { IInjector, InjectOptions, Injector } from './IInjector.js';
 import type { IContainer } from '../container/IContainer.js';
 import { type constructor } from '../utils/basic.js';
-import { InjectionToken } from '../token/InjectionToken.js';
 import { ProviderOptions } from '../provider/IProvider.js';
+import { type Injectable } from '../token/toToken.js';
 import { InjectFn } from '../hooks/hook.js';
+import { type MapFn } from '../utils/fp.js';
 export declare class MetadataInjector extends Injector implements IInjector {
     protected createInstance<T>(scope: IContainer, Target: constructor<T>, { args: deps }?: InjectOptions): T;
 }
-export declare const inject: <T, R = T>(fn: InjectionToken<T> | InjectFn<T> | symbol | string | constructor<T>, selectFn?: (instance: T) => R) => ParameterDecorator;
+export declare function inject<T, B>(fn: Injectable<T>, fn1: MapFn<T, B>): ParameterDecorator;
+export declare function inject<T, B, C>(fn: Injectable<T>, fn1: MapFn<T, B>, fn2: MapFn<B, C>): ParameterDecorator;
+export declare function inject<T, B, C, D>(fn: Injectable<T>, fn1: MapFn<T, B>, fn2: MapFn<B, C>, fn3: MapFn<C, D>): ParameterDecorator;
+export declare function inject<T, B, C, D, E>(fn: Injectable<T>, fn1: MapFn<T, B>, fn2: MapFn<B, C>, fn3: MapFn<C, D>, fn4: MapFn<D, E>): ParameterDecorator;
+export declare function inject<T, B, C, D, E, F>(fn: Injectable<T>, fn1: MapFn<T, B>, fn2: MapFn<B, C>, fn3: MapFn<C, D>, fn4: MapFn<D, E>, fn5: MapFn<E, F>): ParameterDecorator;
+export declare function inject<T, B, C, D, E, F, G>(fn: Injectable<T>, fn1: MapFn<T, B>, fn2: MapFn<B, C>, fn3: MapFn<C, D>, fn4: MapFn<D, E>, fn5: MapFn<E, F>, fn6: MapFn<F, G>): ParameterDecorator;
+export declare function inject<T, B, C, D, E, F, G, H>(fn: Injectable<T>, fn1: MapFn<T, B>, fn2: MapFn<B, C>, fn3: MapFn<C, D>, fn4: MapFn<D, E>, fn5: MapFn<E, F>, fn6: MapFn<F, G>, fn7: MapFn<G, H>): ParameterDecorator;
+export declare function inject<T, B, C, D, E, F, G, H, I>(fn: Injectable<T>, fn1: MapFn<T, B>, fn2: MapFn<B, C>, fn3: MapFn<C, D>, fn4: MapFn<D, E>, fn5: MapFn<E, F>, fn6: MapFn<F, G>, fn7: MapFn<G, H>, fn8: MapFn<H, I>): ParameterDecorator;
+export declare function inject<T, B, C, D, E, F, G, H, I, J>(fn: Injectable<T>, fn1: MapFn<T, B>, fn2: MapFn<B, C>, fn3: MapFn<C, D>, fn4: MapFn<D, E>, fn5: MapFn<E, F>, fn6: MapFn<F, G>, fn7: MapFn<G, H>, fn8: MapFn<H, I>, fn9: MapFn<I, J>): ParameterDecorator;
+export declare function inject<T, B, C, D, E, F, G, H, I, J, K>(fn: Injectable<T>, fn1: MapFn<T, B>, fn2: MapFn<B, C>, fn3: MapFn<C, D>, fn4: MapFn<D, E>, fn5: MapFn<E, F>, fn6: MapFn<F, G>, fn7: MapFn<G, H>, fn8: MapFn<H, I>, fn9: MapFn<I, J>, fn10: MapFn<J, K>): ParameterDecorator;
+export declare function inject<T>(fn: Injectable<T>, ...mappers: MapFn<T>[]): ParameterDecorator;
 export declare const argsFn: <T = unknown>(predicate: (value: unknown, index: number) => boolean) => InjectFn<T>;
 export declare const args: <T = unknown>(index: number) => InjectFn<T>;
 export declare const resolveArgs: (Target: constructor<unknown>, methodName?: string) => (scope: IContainer, { args, lazy }: ProviderOptions) => unknown[];

package/typings/select.d.ts

@@ -3,7 +3,7 @@ import { FunctionToken } from './token/FunctionToken.js';
 import { GroupInstanceToken, InstancePredicate } from './token/GroupInstanceToken.js';
 export declare const select: {
     alias: <T>(token: import("./container/IContainer.js").DependencyKey) => import("./token/GroupAliasToken.js").GroupAliasToken<T>;
-    token: <T = any>(token: import(".").InjectFn<T> | import(".").InjectionToken<T> | import("./container/IContainer.js").DependencyKey | import(".").constructor<T>) => import(".").InjectionToken<T>;
+    token: <T = any>(token: import("./token/toToken.js").Injectable<T>) => import(".").InjectionToken<T>;
     instances: (predicate?: InstancePredicate) => GroupInstanceToken;
     scope: {
         current: FunctionToken<IContainer>;

package/typings/token/toToken.d.ts

@@ -2,5 +2,8 @@ import { DependencyKey } from '../container/IContainer.js';
 import { InjectionToken } from './InjectionToken.js';
 import { InjectFn } from '../hooks/hook.js';
 import { type constructor } from '../utils/basic.js';
-export declare const toToken: <T = any>(token: InjectFn<T> | InjectionToken<T> | DependencyKey | constructor<T>) => InjectionToken<T>;
+import { type MapFn } from '../utils/fp.js';
+export type Injectable<T = any> = InjectFn<T> | InjectionToken<T> | DependencyKey | constructor<T>;
+export declare const toToken: <T = any>(token: Injectable<T>) => InjectionToken<T>;
 export declare const argToToken: (v: unknown) => InjectionToken<unknown>;
+export declare const toMappedToken: <T = any, R = T>(token: Injectable<T>, mappers: MapFn<any, any>[]) => InjectionToken<R>;