ts-ioc-container 71.0.0 → 72.1.0

package/esm/injector/MetadataInjector.js

@@ -1,23 +1,27 @@
 import { Injector } from './IInjector.js';
 import { resolveConstructor } from '../metadata/target.js';
 import { addParamMeta, getParamMeta } from '../metadata/parameter.js';
-import { toMappedToken } from '../token/toToken.js';
+import { toToken } from '../token/toToken.js';
 export class MetadataInjector extends Injector {
-    createInstance(scope, Target, { args: deps = [] } = {}) {
-        const args = resolveArgs(Target)(scope, { args: deps });
+    createInstance(Target, { scope, args: deps = [] }) {
+        const args = resolveArgs(Target)({ scope, args: deps });
         return new Target(...args);
     }
 }
 const hookMetaKey = (methodName = 'constructor') => `inject:${methodName}`;
-export function inject(fn, ...mappers) {
+export function inject(fn) {
     return (target, propertyKey, parameterIndex) => {
-        addParamMeta(hookMetaKey(propertyKey), () => toMappedToken(fn, mappers))(resolveConstructor(target), propertyKey, parameterIndex);
+        addParamMeta(hookMetaKey(propertyKey), () => fn)(resolveConstructor(target), propertyKey, parameterIndex);
     };
 }
-export const argsFn = (predicate) => (c, { args = [] }) => args.find((value, index) => predicate(value, index));
+export const by = (target) => {
+    const token = toToken(target);
+    return ({ scope, ...options }) => token.resolve(scope, options);
+};
+export const argsFn = (predicate) => ({ args = [] }) => args.find((value, index) => predicate(value, index));
 export const arg = (index) => argsFn((value, i) => i === index);
-export const args = (c, { args = [] }) => args;
+export const args = ({ args = [] }) => args;
 export const resolveArgs = (target, methodName) => {
-    const tokens = getParamMeta(hookMetaKey(methodName), target);
-    return (scope, { args = [], lazy }) => tokens.map((fn) => fn.resolve(scope, { args, lazy }));
+    const fns = getParamMeta(hookMetaKey(methodName), target);
+    return (options) => fns.map((fn) => fn(options));
 };

package/esm/injector/ProxyInjector.js

@@ -1,6 +1,6 @@
 import { Injector } from './IInjector.js';
 export class ProxyInjector extends Injector {
-    createInstance(scope, Target, { args = [] } = {}) {
+    createInstance(Target, { scope, args = [] }) {
         const proxy = new Proxy({}, {
             get(target, prop) {
                 if (prop === 'args') {

package/esm/injector/SimpleInjector.js

@@ -1,6 +1,6 @@
 import { Injector } from './IInjector.js';
 export class SimpleInjector extends Injector {
-    createInstance(container, Target, { args = [] } = {}) {
-        return new Target(container, ...args);
+    createInstance(Target, { scope, args = [] }) {
+        return new Target(scope, ...args);
     }
 }

package/esm/metadata/class.js

@@ -10,3 +10,4 @@ export const addClassLabel = (key, label) => addClassMeta('label', (prev = new M
 export const getClassLabels = (target) => getClassMeta(target, 'label') ?? new Map();
 export const addClassTag = (tag) => addClassMeta('tag', (prev = new Set()) => prev.add(tag));
 export const getClassTags = (target) => getClassMeta(target, 'tag') ?? new Set();
+export const createComposeClassDecorator = (...decorators) => (target) => decorators.reduceRight((acc, decorate) => decorate(acc) ?? acc, target);

package/esm/metadata/method.js

@@ -8,3 +8,4 @@ export const addMethodLabel = (key, label) => addMethodMeta('label', (prev = new
 export const getMethodLabels = (target, propertyKey) => getMethodMeta('label', target, propertyKey) ?? new Map();
 export const addMethodTag = (tag) => addMethodMeta('tag', (prev = new Set()) => prev.add(tag));
 export const getMethodTags = (target, propertyKey) => getMethodMeta('tag', target, propertyKey) ?? new Set();
+export const createComposeMethodDecorator = (...decorators) => (target, propertyKey, descriptor) => decorators.reduceRight((acc, decorate) => decorate(target, propertyKey, acc) ?? acc, descriptor);

package/esm/metadata/parameter.js

@@ -23,3 +23,8 @@ export const getParamTags = (target, parameterIndex) => {
     const all = getParamMeta('tag', target);
     return all[parameterIndex] ?? new Set();
 };
+export const createComposeParameterDecorator = (...decorators) => (target, propertyKey, parameterIndex) => {
+    for (let i = decorators.length - 1; i >= 0; i--) {
+        decorators[i](target, propertyKey, parameterIndex);
+    }
+};

package/esm/provider/Provider.js

@@ -4,13 +4,13 @@ import { ProviderDisposedError } from '../errors/ProviderDisposedError.js';
 export class Provider {
     resolveDependency;
     static fromClass(Target) {
-        return new Provider((container, options) => container.resolve(Target, options));
+        return new Provider(({ scope, ...options }) => scope.resolve(Target, options));
     }
     static fromValue(value) {
         return new Provider(() => value);
     }
     static fromKey(key) {
-        return new Provider((c) => c.resolve(key));
+        return new Provider(({ scope }) => scope.resolve(key));
     }
     argsFnList = [];
     accessRules = [];
@@ -24,20 +24,21 @@ export class Provider {
     constructor(resolveDependency) {
         this.resolveDependency = resolveDependency;
     }
-    resolve(scope, options) {
+    resolve(options) {
         ProviderDisposedError.assert(!this.isDisposed, 'Provider is already disposed');
         if (!this.getKey) {
-            return this.resolveDep(scope, options);
+            return this.resolveDep(options);
         }
         const key = toString(this.getKey(options.args ?? []));
         if (!this.cache.has(key)) {
-            this.cache.set(key, this.resolveDep(scope, options));
+            this.cache.set(key, this.resolveDep(options));
         }
         return this.cache.get(key);
     }
-    resolveDep(scope, { args = [], lazy } = {}) {
-        let dependency = this.resolveDependency(scope, {
-            args: this.argsFnList.reduce((acc, current) => current(scope, { args: acc }), args),
+    resolveDep({ scope, args = [], lazy }) {
+        let dependency = this.resolveDependency({
+            scope,
+            args: this.argsFnList.reduce((acc, current) => current({ scope, args: acc }), args),
             lazy: lazy ?? this.isLazy,
         });
         dependency = this.mappers.reduce((acc, current) => current(acc, scope), dependency);

package/esm/registration/IRegistration.js

@@ -28,8 +28,8 @@ export const bindTo = (...tokens) => (r) => {
     return r;
 };
 export const scope = (...rules) => (r) => r.when(...rules);
-export const appendArgs = (...extraArgs) => registerPipe((p) => p.addArgsFn((_, { args = [] } = {}) => [...args, ...extraArgs]));
-export const appendArgsFn = (fn) => registerPipe((p) => p.addArgsFn((scope, options) => [...(options?.args ?? []), ...fn(scope, options)]));
+export const appendArgs = (...extraArgs) => registerPipe((p) => p.addArgsFn(({ args = [] }) => [...args, ...extraArgs]));
+export const appendArgsFn = (fn) => registerPipe((p) => p.addArgsFn((options) => [...(options.args ?? []), ...fn(options)]));
 export const scopeAccess = (rule) => registerPipe((p) => p.addAccessRule(rule));
 export const lazy = () => registerPipe((p) => p.lazy());
 export const autoResolve = () => registerPipe((p) => p.autoResolve());

package/esm/select.js

@@ -7,7 +7,7 @@ export const select = {
     token: toToken,
     instances: (predicate = () => true) => new GroupInstanceToken(predicate),
     scope: {
-        current: new FunctionToken((s) => s),
-        create: (options) => new FunctionToken((s) => s.createScope(options)),
+        current: new FunctionToken(({ scope }) => scope),
+        create: (options) => new FunctionToken(({ scope }) => scope.createScope(options)),
     },
 };

package/esm/token/ClassToken.js

@@ -14,14 +14,14 @@ export class ClassToken extends InjectionToken {
     }
     resolve(s, { args = [], lazy } = {}) {
         return s.resolve(this.target, {
-            args: this._getArgsFn(s, { args }),
+            args: this._getArgsFn({ scope: s, args }),
             lazy: this._isLazy || lazy,
         });
     }
     args(...newArgs) {
         const parentFn = this._getArgsFn;
         return new ClassToken(this.target, {
-            getArgsFn: (s, opts) => [...parentFn(s, opts), ...newArgs],
+            getArgsFn: (options) => [...parentFn(options), ...newArgs],
             isLazy: this._isLazy,
             tags: this.getTags(),
         });
@@ -29,7 +29,7 @@ export class ClassToken extends InjectionToken {
     argsFn(fn) {
         const parentFn = this._getArgsFn;
         return new ClassToken(this.target, {
-            getArgsFn: (s, opts) => [...parentFn(s, opts), ...fn(s)],
+            getArgsFn: (options) => [...parentFn(options), ...fn(options.scope)],
             isLazy: this._isLazy,
             tags: this.getTags(),
         });

package/esm/token/FunctionToken.js

@@ -11,15 +11,16 @@ export class FunctionToken extends InjectionToken {
         this._isLazy = isLazy;
     }
     resolve(s, { args = [], lazy } = {}) {
-        return this.fn(s, {
-            args: this._getArgsFn(s, { args }),
+        return this.fn({
+            scope: s,
+            args: this._getArgsFn({ scope: s, args }),
             lazy: this._isLazy || lazy,
         });
     }
     args(...newArgs) {
         const parentFn = this._getArgsFn;
         return new FunctionToken(this.fn, {
-            getArgsFn: (s, opts) => [...parentFn(s, opts), ...newArgs],
+            getArgsFn: (options) => [...parentFn(options), ...newArgs],
             isLazy: this._isLazy,
             tags: this.getTags(),
         });
@@ -27,7 +28,7 @@ export class FunctionToken extends InjectionToken {
     argsFn(fn) {
         const parentFn = this._getArgsFn;
         return new FunctionToken(this.fn, {
-            getArgsFn: (s, opts) => [...parentFn(s, opts), ...fn(s)],
+            getArgsFn: (options) => [...parentFn(options), ...fn(options.scope)],
             isLazy: this._isLazy,
             tags: this.getTags(),
         });

package/esm/token/GroupAliasToken.js

@@ -14,7 +14,7 @@ export class GroupAliasToken extends InjectionToken {
     }
     resolve(s, { args = [], lazy } = {}) {
         return s.resolveByAlias(this.token, {
-            args: this._getArgsFn(s, { args }),
+            args: this._getArgsFn({ scope: s, args }),
             lazy: this._isLazy || lazy,
         });
     }
@@ -24,7 +24,7 @@ export class GroupAliasToken extends InjectionToken {
     args(...newArgs) {
         const parentFn = this._getArgsFn;
         return new GroupAliasToken(this.token, {
-            getArgsFn: (s, opts) => [...parentFn(s, opts), ...newArgs],
+            getArgsFn: (options) => [...parentFn(options), ...newArgs],
             isLazy: this._isLazy,
             tags: this.getTags(),
         });
@@ -32,7 +32,7 @@ export class GroupAliasToken extends InjectionToken {
     argsFn(fn) {
         const parentFn = this._getArgsFn;
         return new GroupAliasToken(this.token, {
-            getArgsFn: (s, opts) => [...parentFn(s, opts), ...fn(s)],
+            getArgsFn: (options) => [...parentFn(options), ...fn(options.scope)],
             isLazy: this._isLazy,
             tags: this.getTags(),
         });

package/esm/token/InjectionToken.js

@@ -1,5 +1,5 @@
 import { Is } from '../utils/basic.js';
-export const forwardArgs = (_, { args = [] } = {}) => args;
+export const forwardArgs = ({ args = [] }) => args;
 export class InjectionToken {
     tags;
     constructor(tags = []) {

package/esm/token/SingleAliasToken.js

@@ -14,7 +14,7 @@ export class SingleAliasToken extends InjectionToken {
     }
     resolve(s, { args = [], lazy } = {}) {
         return s.resolveOneByAlias(this.token, {
-            args: this._getArgsFn(s, { args }),
+            args: this._getArgsFn({ scope: s, args }),
             lazy: this._isLazy || lazy,
         });
     }
@@ -24,7 +24,7 @@ export class SingleAliasToken extends InjectionToken {
     args(...newArgs) {
         const parentFn = this._getArgsFn;
         return new SingleAliasToken(this.token, {
-            getArgsFn: (s, opts) => [...parentFn(s, opts), ...newArgs],
+            getArgsFn: (options) => [...parentFn(options), ...newArgs],
             isLazy: this._isLazy,
             tags: this.getTags(),
         });
@@ -32,7 +32,7 @@ export class SingleAliasToken extends InjectionToken {
     argsFn(fn) {
         const parentFn = this._getArgsFn;
         return new SingleAliasToken(this.token, {
-            getArgsFn: (s, opts) => [...parentFn(s, opts), ...fn(s)],
+            getArgsFn: (options) => [...parentFn(options), ...fn(options.scope)],
             isLazy: this._isLazy,
             tags: this.getTags(),
         });

package/esm/token/SingleToken.js

@@ -14,7 +14,7 @@ export class SingleToken extends InjectionToken {
     }
     resolve(s, { args = [], lazy } = {}) {
         return s.resolve(this.token, {
-            args: this._getArgsFn(s, { args }),
+            args: this._getArgsFn({ scope: s, args }),
             lazy: this._isLazy || lazy,
         });
     }
@@ -24,7 +24,7 @@ export class SingleToken extends InjectionToken {
     args(...newArgs) {
         const parentFn = this._getArgsFn;
         return new SingleToken(this.token, {
-            getArgsFn: (s, opts) => [...parentFn(s, opts), ...newArgs],
+            getArgsFn: (options) => [...parentFn(options), ...newArgs],
             isLazy: this._isLazy,
             tags: this.getTags(),
         });
@@ -32,7 +32,7 @@ export class SingleToken extends InjectionToken {
     argsFn(fn) {
         const parentFn = this._getArgsFn;
         return new SingleToken(this.token, {
-            getArgsFn: (s, opts) => [...parentFn(s, opts), ...fn(s)],
+            getArgsFn: (options) => [...parentFn(options), ...fn(options.scope)],
             isLazy: this._isLazy,
             tags: this.getTags(),
         });

package/esm/token/toToken.js

@@ -6,7 +6,6 @@ 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;
@@ -23,8 +22,3 @@ 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": "71.0.0",
+  "version": "72.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.",
   "publishConfig": {
     "access": "public",

package/typings/container/IContainer.d.ts

@@ -1,4 +1,4 @@
-import { type IProvider, ProviderOptions } from '../provider/IProvider.js';
+import { type IProvider, ResolveOptions } from '../provider/IProvider.js';
 import { type IRegistration } from '../registration/IRegistration.js';
 import { IInjector, type WithArgs } from '../injector/IInjector.js';
 import { type constructor, Instance } from '../utils/basic.js';
@@ -19,7 +19,7 @@ export interface Tagged {
     hasTag(tag: Tag): boolean;
     addTags(...tags: Tag[]): void;
 }
-export type ResolveOneOptions = ProviderOptions & Partial<WithChild>;
+export type ResolveOneOptions = ResolveOptions & Partial<WithChild>;
 export type ResolveManyOptions = ResolveOneOptions & Partial<WithExcludedKeys>;
 export interface Resolvable {
     resolve<T>(key: constructor<T> | DependencyKey, options?: ResolveOneOptions): T;

package/typings/hooks/HookContext.d.ts

@@ -1,6 +1,6 @@
 import type { IContainer } from '../container/IContainer.js';
-import { InjectionToken } from '../token/InjectionToken.js';
 import { type Instance } from '../utils/basic.js';
+import { type InjectFn } from './hook.js';
 export interface IHookContext {
     instance: Instance;
     scope: IContainer;
@@ -9,7 +9,7 @@ export interface IHookContext {
     invokeMethod(options?: {
         args?: unknown[];
     }): unknown;
-    setProperty(fn: InjectionToken): void;
+    setProperty(fn: InjectFn): void;
     getProperty(): unknown;
     setInitialArgs(...args: unknown[]): this;
     getInitialArgs(): unknown[];
@@ -24,7 +24,7 @@ export declare class HookContext implements IHookContext {
     invokeMethod({ args }?: {
         args?: unknown[];
     }): unknown;
-    setProperty(fn: InjectionToken): void;
+    setProperty(fn: InjectFn): void;
     getProperty(): unknown;
     setInitialArgs(...args: unknown[]): this;
     getInitialArgs(): unknown[];

package/typings/hooks/hook.d.ts

@@ -1,8 +1,7 @@
 import { type IHookContext } from './HookContext.js';
-import type { IContainer } from '../container/IContainer.js';
 import { type constructor, type Instance } from '../utils/basic.js';
 import { ProviderOptions } from '../provider/IProvider.js';
-export type InjectFn<T = unknown> = (s: IContainer, options: ProviderOptions) => T;
+export type InjectFn<T = unknown> = (options: ProviderOptions) => T;
 export type HookFn<T extends IHookContext = IHookContext> = (context: T) => void | Promise<void>;
 export interface HookClass<T extends IHookContext = IHookContext> {
     execute(context: Omit<T, 'scope'>): void | Promise<void>;

package/typings/hooks/injectProp.d.ts

@@ -1,14 +1,2 @@
-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;
+import { HookFn, InjectFn } from './hook.js';
+export declare const injectProp: <T>(fn: InjectFn<T>) => HookFn;

package/typings/index.d.ts

@@ -2,11 +2,11 @@ export { type IContainer, type Resolvable, type IContainerModule, type Dependenc
 export { Container } from './container/Container.js';
 export { AutoResolveModule } from './container/AutoResolveModule.js';
 export { EmptyContainer } from './container/EmptyContainer.js';
-export { type IInjector, type InjectOptions, type IInjectFnResolver, type IInjectorModule, type InjectorHook, Injector, } from './injector/IInjector.js';
-export { MetadataInjector, inject, arg, args, argsFn, resolveArgs } from './injector/MetadataInjector.js';
+export { type IInjector, type InjectOptions, type WithScope, type WithArgs, type IInjectFnResolver, type IInjectorModule, type InjectorHook, Injector, } from './injector/IInjector.js';
+export { MetadataInjector, inject, arg, args, argsFn, by, resolveArgs } from './injector/MetadataInjector.js';
 export { SimpleInjector } from './injector/SimpleInjector.js';
 export { ProxyInjector } from './injector/ProxyInjector.js';
-export { type ResolveDependency, type IProvider, type DecorateFn, type ArgsFn, type ProviderOptions, type GetCacheKey, type ScopeAccessOptions, type ScopeAccessRule, type ProviderHook, } from './provider/IProvider.js';
+export { type ResolveDependency, type IProvider, type DecorateFn, type ArgsFn, type ProviderOptions, type ResolveOptions, type GetCacheKey, type ScopeAccessOptions, type ScopeAccessRule, type ProviderHook, } from './provider/IProvider.js';
 export { Provider } from './provider/Provider.js';
 export { type IRegistration, type ReturnTypeOfRegistration, type ScopeMatchRule, type ProviderPipe, type Bindable, type ProviderMapper, type RegistrationMapper, isProviderPipe, registerPipe, toBindToken, toProviderFn, toRegistrationFn, register, bindTo, scope, scopeAccess, lazy, autoResolve, singleton, decorate, appendArgs, appendArgsFn, onResolve, } from './registration/IRegistration.js';
 export { Registration } from './registration/Registration.js';
@@ -27,7 +27,7 @@ export { injectProp } from './hooks/injectProp.js';
 export { sequential, parallel, oncePerInstance, type ResolvedObjectHook } from './hooks/combinators.js';
 export { HookCollector, toTask, type HookAction, type HookCollectionContext, type HookCollectorOptions, type HookCollectorProps, type MapHookExecutionContext, } from './hooks/HookCollector.js';
 export { InjectionToken, isInjectionToken, forwardArgs } from './token/InjectionToken.js';
-export { type Injectable, toToken, toMappedToken, argToToken } from './token/toToken.js';
+export { type Injectable, toToken, 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';
@@ -36,9 +36,9 @@ export { FunctionToken } from './token/FunctionToken.js';
 export { ConstantToken } from './token/ConstantToken.js';
 export { type InstancePredicate, GroupInstanceToken } from './token/GroupInstanceToken.js';
 export { resolveConstructor } from './metadata/target.js';
-export { addClassMeta, getClassMeta, addClassLabel, getClassLabels, addClassTag, getClassTags } from './metadata/class.js';
-export { addParamMeta, getParamMeta, addParamLabel, getParamLabels, addParamTag, getParamTags, } from './metadata/parameter.js';
-export { addMethodMeta, getMethodMeta, addMethodLabel, getMethodLabels, addMethodTag, getMethodTags, } from './metadata/method.js';
+export { addClassMeta, getClassMeta, addClassLabel, getClassLabels, addClassTag, getClassTags, createComposeClassDecorator, } from './metadata/class.js';
+export { addParamMeta, getParamMeta, addParamLabel, getParamLabels, addParamTag, getParamTags, createComposeParameterDecorator, } from './metadata/parameter.js';
+export { addMethodMeta, getMethodMeta, addMethodLabel, getMethodLabels, addMethodTag, getMethodTags, createComposeMethodDecorator, } from './metadata/method.js';
 export { handleError, handleAsyncError, type HandleErrorParams } from './utils/errorHandler.js';
 export { runInOrder, runAtOnce, type Task } from './utils/task.js';
 export { throttle } from './utils/throttle.js';

package/typings/injector/IInjector.d.ts

@@ -2,13 +2,16 @@ import { type IContainer, ResolveOneOptions } from '../container/IContainer.js';
 import { ProviderOptions } from '../provider/IProvider.js';
 import { type IProxyRegistry } from '../utils/ProxyRegistry.js';
 import { type constructor, Instance } from '../utils/basic.js';
+export type WithScope = {
+    scope: IContainer;
+};
 export type WithArgs = {
     args: unknown[];
 };
-export type InjectOptions = Partial<WithArgs>;
+export type InjectOptions = WithScope & Partial<WithArgs>;
 export type InjectorHook = (instance: Instance, scope: IContainer) => void;
 export interface IInjector {
-    resolve<T>(container: IContainer, value: constructor<T>, options?: ProviderOptions): T;
+    resolve<T>(Target: constructor<T>, options: ProviderOptions): T;
     onConstructed(...hooks: InjectorHook[]): this;
 }
 export interface IInjectorModule {
@@ -21,8 +24,8 @@ export declare abstract class Injector {
     private readonly proxyRegistry;
     private readonly onConstructedHookList;
     constructor(proxyRegistry?: IProxyRegistry);
-    resolve<T>(scope: IContainer, Target: constructor<T>, { args, lazy }?: ProviderOptions): T;
+    resolve<T>(Target: constructor<T>, { scope, args, lazy }: ProviderOptions): T;
     onConstructed(...hooks: InjectorHook[]): this;
     useModule(module: IInjectorModule): this;
-    protected abstract createInstance<T>(scope: IContainer, Target: constructor<T>, options?: InjectOptions): T;
+    protected abstract createInstance<T>(Target: constructor<T>, options: InjectOptions): T;
 }

package/typings/injector/MetadataInjector.d.ts

@@ -1,25 +1,15 @@
 import { IInjector, InjectOptions, Injector } from './IInjector.js';
-import type { IContainer } from '../container/IContainer.js';
 import { type constructor, type Instance } from '../utils/basic.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';
+import { type DependencyKey } from '../container/IContainer.js';
+import { type InjectionToken } from '../token/InjectionToken.js';
 export declare class MetadataInjector extends Injector implements IInjector {
-    protected createInstance<T>(scope: IContainer, Target: constructor<T>, { args: deps }?: InjectOptions): T;
+    protected createInstance<T>(Target: constructor<T>, { scope, args: deps }: InjectOptions): T;
 }
-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 function inject<T>(fn: InjectFn<T>): ParameterDecorator;
+export declare const by: <T>(target: InjectionToken<T> | DependencyKey | constructor<T>) => InjectFn<T>;
 export declare const argsFn: <T = unknown>(predicate: (value: unknown, index: number) => boolean) => InjectFn<T>;
 export declare const arg: <T = unknown>(index: number) => InjectFn<T>;
 export declare const args: InjectFn<unknown[]>;
-export declare const resolveArgs: (target: constructor<unknown> | Instance, methodName?: string) => (scope: IContainer, { args, lazy }: ProviderOptions) => unknown[];
+export declare const resolveArgs: (target: constructor<unknown> | Instance, methodName?: string) => (options: ProviderOptions) => unknown[];

package/typings/injector/ProxyInjector.d.ts

@@ -1,6 +1,5 @@
 import { IInjector, InjectOptions, Injector } from './IInjector.js';
-import type { IContainer } from '../container/IContainer.js';
 import { type constructor } from '../utils/basic.js';
 export declare class ProxyInjector extends Injector implements IInjector {
-    protected createInstance<T>(scope: IContainer, Target: constructor<T>, { args }?: InjectOptions): T;
+    protected createInstance<T>(Target: constructor<T>, { scope, args }: InjectOptions): T;
 }

package/typings/injector/SimpleInjector.d.ts

@@ -1,6 +1,5 @@
 import { IInjector, InjectOptions, Injector } from './IInjector.js';
-import type { IContainer } from '../container/IContainer.js';
 import { type constructor } from '../utils/basic.js';
 export declare class SimpleInjector extends Injector implements IInjector {
-    protected createInstance<T>(container: IContainer, Target: constructor<T>, { args }?: InjectOptions): T;
+    protected createInstance<T>(Target: constructor<T>, { scope, args }: InjectOptions): T;
 }

package/typings/metadata/class.d.ts

@@ -4,3 +4,4 @@ export declare const addClassLabel: (key: string, label: string) => ClassDecorat
 export declare const getClassLabels: (target: object) => Map<string, string>;
 export declare const addClassTag: (tag: string) => ClassDecorator;
 export declare const getClassTags: (target: object) => Set<string>;
+export declare const createComposeClassDecorator: (...decorators: ClassDecorator[]) => ClassDecorator;

package/typings/metadata/method.d.ts

@@ -4,3 +4,4 @@ export declare const addMethodLabel: (key: string, label: string) => MethodDecor
 export declare const getMethodLabels: (target: object, propertyKey: string) => Map<string, string>;
 export declare const addMethodTag: (tag: string) => MethodDecorator;
 export declare const getMethodTags: (target: object, propertyKey: string) => Set<string>;
+export declare const createComposeMethodDecorator: (...decorators: MethodDecorator[]) => MethodDecorator;

package/typings/metadata/parameter.d.ts

@@ -4,3 +4,4 @@ export declare const addParamLabel: (key: string, label: string) => ParameterDec
 export declare const getParamLabels: (target: object, parameterIndex: number) => Map<string, string>;
 export declare const addParamTag: (tag: string) => ParameterDecorator;
 export declare const getParamTags: (target: object, parameterIndex: number) => Set<string>;
+export declare const createComposeParameterDecorator: (...decorators: ParameterDecorator[]) => ParameterDecorator;

package/typings/provider/IProvider.d.ts

@@ -1,23 +1,24 @@
 import { IContainer, Tagged } from '../container/IContainer.js';
-import { InjectOptions } from '../injector/IInjector.js';
+import { InjectOptions, WithScope } from '../injector/IInjector.js';
 import { Serializable } from '../utils/basic.js';
 export type WithLazy = {
     lazy: boolean;
 };
 export type ProviderOptions = InjectOptions & Partial<WithLazy>;
-export type ResolveDependency<T = unknown> = (container: IContainer, options: ProviderOptions) => T;
+export type ResolveOptions = Omit<ProviderOptions, keyof WithScope>;
+export type ResolveDependency<T = unknown> = (options: ProviderOptions) => T;
 export type ScopeAccessOptions = {
     invocationScope: Tagged;
     providerScope: Tagged;
     args: unknown[];
 };
 export type ScopeAccessRule = (options: ScopeAccessOptions, prev: boolean) => boolean;
-export type ArgsFn = (l: IContainer, options?: InjectOptions) => unknown[];
+export type ArgsFn = (options: InjectOptions) => unknown[];
 export type GetCacheKey = (args: unknown[]) => string | Serializable;
 export type DecorateFn<Instance = any> = (dep: Instance, scope: IContainer) => Instance;
 export type ProviderHook = (dependency: unknown, scope: IContainer) => void;
 export interface IProvider<T = any> {
-    resolve(container: IContainer, options: ProviderOptions): T;
+    resolve(options: ProviderOptions): T;
     hasAccess(options: ScopeAccessOptions): boolean;
     map(...mappers: DecorateFn<T>[]): this;
     addAccessRule(...rules: ScopeAccessRule[]): this;

package/typings/provider/Provider.d.ts

@@ -1,5 +1,5 @@
 import { type ArgsFn, type DecorateFn, type GetCacheKey, type IProvider, type ProviderOptions, type ResolveDependency, type ScopeAccessOptions, type ScopeAccessRule, type ProviderHook } from './IProvider.js';
-import type { DependencyKey, IContainer } from '../container/IContainer.js';
+import type { DependencyKey } from '../container/IContainer.js';
 import { type constructor } from '../utils/basic.js';
 export declare class Provider<T = any> implements IProvider<T> {
     private readonly resolveDependency;
@@ -16,7 +16,7 @@ export declare class Provider<T = any> implements IProvider<T> {
     private isDisposed;
     private readonly onResolvedHookList;
     constructor(resolveDependency: ResolveDependency<T>);
-    resolve(scope: IContainer, options: ProviderOptions): T;
+    resolve(options: ProviderOptions): T;
     private resolveDep;
     map(...mappers: DecorateFn<T>[]): this;
     addAccessRule(...rules: ScopeAccessRule[]): this;

package/typings/select.d.ts

@@ -1,4 +1,4 @@
-import { type CreateScopeOptions, type IContainer } from './container/IContainer.js';
+import { type CreateScopeOptions } from './container/IContainer.js';
 import { FunctionToken } from './token/FunctionToken.js';
 import { GroupInstanceToken, InstancePredicate } from './token/GroupInstanceToken.js';
 export declare const select: {
@@ -6,7 +6,7 @@ export declare const select: {
     token: <T = any>(token: import("./token/toToken.js").Injectable<T>) => import(".").InjectionToken<T>;
     instances: (predicate?: InstancePredicate) => GroupInstanceToken;
     scope: {
-        current: FunctionToken<IContainer>;
-        create: (options: CreateScopeOptions) => FunctionToken<IContainer>;
+        current: FunctionToken<import("./container/IContainer.js").IContainer>;
+        create: (options: CreateScopeOptions) => FunctionToken<import("./container/IContainer.js").IContainer>;
     };
 };

package/typings/token/ClassToken.d.ts

@@ -1,7 +1,7 @@
 import { IContainer } from '../container/IContainer.js';
 import { InjectionToken } from './InjectionToken.js';
 import { type constructor, Serializable } from '../utils/basic.js';
-import { ArgsFn, ProviderOptions } from '../provider/IProvider.js';
+import { ArgsFn, ResolveOptions } from '../provider/IProvider.js';
 export declare class ClassToken<T = any> extends InjectionToken<T> implements Serializable {
     private readonly target;
     private readonly _getArgsFn;
@@ -12,7 +12,7 @@ export declare class ClassToken<T = any> extends InjectionToken<T> implements Se
         tags?: string[];
     });
     select<R>(fn: (target: T) => R): (s: IContainer) => R;
-    resolve(s: IContainer, { args, lazy }?: ProviderOptions): T;
+    resolve(s: IContainer, { args, lazy }?: ResolveOptions): T;
     args(...newArgs: unknown[]): ClassToken<T>;
     argsFn(fn: (s: IContainer) => unknown[]): ClassToken<T>;
     lazy(): ClassToken<T>;