ts-ioc-container 71.0.0 → 72.0.0

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.0.0",
   "description": "Fast, lightweight TypeScript dependency injection container with a clean API, scoped lifecycles, decorators, tokens, hooks, lazy injection, customizable providers, and no global container objects.",
   "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';

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/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>;

package/typings/token/FunctionToken.d.ts

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

package/typings/token/GroupAliasToken.d.ts

@@ -2,7 +2,7 @@ import { DependencyKey, IContainer } from '../container/IContainer.js';
 import { InjectionToken } from './InjectionToken.js';
 import { IRegistration } from '../registration/IRegistration.js';
 import { BindToken } from './BindToken.js';
-import { ArgsFn, ProviderOptions } from '../provider/IProvider.js';
+import { ArgsFn, ResolveOptions } from '../provider/IProvider.js';
 import { Serializable } from '../utils/basic.js';
 export declare class GroupAliasToken<T = any> extends InjectionToken<T[]> implements BindToken<T>, Serializable {
     readonly token: DependencyKey;
@@ -14,7 +14,7 @@ export declare class GroupAliasToken<T = any> extends InjectionToken<T[]> implem
         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[];
     bindTo(r: IRegistration<T>): void;
     args(...newArgs: unknown[]): GroupAliasToken<T>;
     argsFn(fn: (s: IContainer) => unknown[]): GroupAliasToken<T>;

package/typings/token/InjectionToken.d.ts

@@ -1,10 +1,10 @@
 import { type IContainer, type Tag } from '../container/IContainer.js';
-import { ArgsFn, ProviderOptions } from '../provider/IProvider.js';
+import { ArgsFn, ResolveOptions } from '../provider/IProvider.js';
 export declare const forwardArgs: ArgsFn;
 export declare abstract class InjectionToken<T = any> {
     private readonly tags;
     protected constructor(tags?: Tag[]);
-    abstract resolve(s: IContainer, options?: ProviderOptions): T;
+    abstract resolve(s: IContainer, options?: ResolveOptions): T;
     abstract args(...deps: unknown[]): InjectionToken<T>;
     abstract argsFn(getArgsFn: (s: IContainer) => unknown[]): InjectionToken<T>;
     abstract lazy(): InjectionToken<T>;

package/typings/token/SingleAliasToken.d.ts

@@ -1,8 +1,8 @@
-import { DependencyKey, IContainer, ResolveOneOptions } from '../container/IContainer.js';
+import { DependencyKey, IContainer } from '../container/IContainer.js';
 import { InjectionToken } from './InjectionToken.js';
 import { IRegistration } from '../registration/IRegistration.js';
 import { BindToken } from './BindToken.js';
-import { ArgsFn } from '../provider/IProvider.js';
+import { ArgsFn, ResolveOptions } from '../provider/IProvider.js';
 import { Serializable } from '../utils/basic.js';
 export declare class SingleAliasToken<T = any> extends InjectionToken<T> implements BindToken<T>, Serializable {
     readonly token: DependencyKey;
@@ -14,7 +14,7 @@ export declare class SingleAliasToken<T = any> extends InjectionToken<T> impleme
         tags?: string[];
     });
     select<R>(fn: (target: T) => R): (s: IContainer) => R;
-    resolve(s: IContainer, { args, lazy }?: ResolveOneOptions): T;
+    resolve(s: IContainer, { args, lazy }?: ResolveOptions): T;
     bindTo(r: IRegistration<T>): void;
     args(...newArgs: unknown[]): SingleAliasToken<T>;
     argsFn(fn: (s: IContainer) => unknown[]): SingleAliasToken<T>;

package/typings/token/SingleToken.d.ts

@@ -1,7 +1,7 @@
 import { DependencyKey, IContainer } from '../container/IContainer.js';
 import { InjectionToken } from './InjectionToken.js';
 import { IRegistration } from '../registration/IRegistration.js';
-import { ArgsFn, ProviderOptions } from '../provider/IProvider.js';
+import { ArgsFn, ResolveOptions } from '../provider/IProvider.js';
 import { Serializable } from '../utils/basic.js';
 export declare class SingleToken<T = any> extends InjectionToken<T> implements Serializable {
     token: DependencyKey;
@@ -13,7 +13,7 @@ export declare class SingleToken<T = any> extends InjectionToken<T> implements S
         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;
     bindTo(r: IRegistration<T>): void;
     args(...newArgs: unknown[]): SingleToken<T>;
     argsFn(fn: (s: IContainer) => unknown[]): SingleToken<T>;

package/typings/token/toToken.d.ts

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