ts-ioc-container 56.1.0 → 56.2.0

package/esm/container/EmptyContainer.js

@@ -0,0 +1,67 @@
+import { MethodNotImplementedError } from '../errors/MethodNotImplementedError.js';
+import { DependencyNotFoundError } from '../errors/DependencyNotFoundError.js';
+import { ContainerNotFoundError } from '../errors/ContainerNotFoundError.js';
+export class EmptyContainer {
+    get isDisposed() {
+        throw new MethodNotImplementedError();
+    }
+    addInstance(instance) { }
+    getParent() {
+        return undefined;
+    }
+    getScopes() {
+        return [];
+    }
+    getScopeByInstanceOrFail(instance) {
+        throw new ContainerNotFoundError('Cannot find scope for the given instance');
+    }
+    getInstances() {
+        return [];
+    }
+    hasInstance(instance) {
+        return false;
+    }
+    createScope() {
+        throw new MethodNotImplementedError();
+    }
+    dispose() {
+        throw new MethodNotImplementedError();
+    }
+    register(key, value) {
+        throw new MethodNotImplementedError();
+    }
+    hasTag(tag) {
+        throw new MethodNotImplementedError();
+    }
+    addTags(...tags) {
+        throw new MethodNotImplementedError();
+    }
+    getRegistrations() {
+        return [];
+    }
+    hasRegistration(key) {
+        return false;
+    }
+    removeScope() { }
+    useModule(module) {
+        throw new MethodNotImplementedError();
+    }
+    addRegistration(registration) {
+        throw new MethodNotImplementedError();
+    }
+    resolve(key, options) {
+        throw new DependencyNotFoundError(`Cannot find ${key.toString()}`);
+    }
+    resolveByAlias(alias, options) {
+        return [];
+    }
+    resolveOneByAlias(alias, options) {
+        throw new DependencyNotFoundError(`Cannot find alias ${alias.toString()}`);
+    }
+    addOnDisposeHook(...hooks) {
+        throw new MethodNotImplementedError();
+    }
+    addOnConstructHook(...hooks) {
+        throw new MethodNotImplementedError();
+    }
+}

package/esm/container/IContainer.js

@@ -0,0 +1,3 @@
+export function isDependencyKey(target) {
+    return typeof target === 'symbol' || typeof target === 'string';
+}

package/esm/errors/CannonSingletonApplyTwiceError.js

@@ -0,0 +1,13 @@
+import { ContainerError } from './ContainerError.js';
+export class CannonSingletonApplyTwiceError extends ContainerError {
+    name = 'CannonSingletonApplyTwiceError';
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, CannonSingletonApplyTwiceError.prototype);
+    }
+    static assert(isTrue, failMessage) {
+        if (!isTrue) {
+            throw new CannonSingletonApplyTwiceError(failMessage);
+        }
+    }
+}

package/esm/errors/ContainerDisposedError.js

@@ -0,0 +1,8 @@
+import { ContainerError } from './ContainerError.js';
+export class ContainerDisposedError extends ContainerError {
+    name = 'ContainerDisposedError';
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, ContainerDisposedError.prototype);
+    }
+}

package/esm/errors/ContainerError.js

@@ -0,0 +1,7 @@
+export class ContainerError extends Error {
+    name = 'ContainerError';
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, ContainerError.prototype);
+    }
+}

package/esm/errors/ContainerNotFoundError.js

@@ -0,0 +1,8 @@
+import { ContainerError } from './ContainerError.js';
+export class ContainerNotFoundError extends ContainerError {
+    name = 'ContainerNotFoundError';
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, ContainerNotFoundError.prototype);
+    }
+}

package/esm/errors/DependencyMissingKeyError.js

@@ -0,0 +1,8 @@
+import { ContainerError } from './ContainerError.js';
+export class DependencyMissingKeyError extends ContainerError {
+    name = 'DependencyMissingKeyError';
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, DependencyMissingKeyError.prototype);
+    }
+}

package/esm/errors/DependencyNotFoundError.js

@@ -0,0 +1,8 @@
+import { ContainerError } from './ContainerError.js';
+export class DependencyNotFoundError extends ContainerError {
+    name = 'DependencyNotFoundError';
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, DependencyNotFoundError.prototype);
+    }
+}

package/esm/errors/MethodNotImplementedError.js

@@ -0,0 +1,8 @@
+import { ContainerError } from './ContainerError.js';
+export class MethodNotImplementedError extends ContainerError {
+    name = 'MethodNotImplementedError';
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, MethodNotImplementedError.prototype);
+    }
+}

package/esm/errors/ProviderDisposedError.js

@@ -0,0 +1,13 @@
+import { ContainerError } from './ContainerError.js';
+export class ProviderDisposedError extends ContainerError {
+    name = 'ProviderDisposedError';
+    static assert(isTrue, failMessage) {
+        if (!isTrue) {
+            throw new ProviderDisposedError(failMessage);
+        }
+    }
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, ProviderDisposedError.prototype);
+    }
+}

package/esm/errors/UnexpectedHookResultError.js

@@ -0,0 +1,8 @@
+import { ContainerError } from './ContainerError.js';
+export class UnexpectedHookResultError extends ContainerError {
+    name = 'UnexpectedHookResultError';
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, UnexpectedHookResultError.prototype);
+    }
+}

package/esm/errors/UnsupportedTokenTypeError.js

@@ -0,0 +1,8 @@
+import { ContainerError } from './ContainerError.js';
+export class UnsupportedTokenTypeError extends ContainerError {
+    name = 'UnsupportedTokenTypeError';
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, UnsupportedTokenTypeError.prototype);
+    }
+}

package/esm/hooks/HookContext.js

@@ -0,0 +1,36 @@
+import { getProxyTarget, isProxy } from '../utils/proxy.js';
+import { resolveArgs } from '../injector/MetadataInjector.js';
+export class HookContext {
+    scope;
+    methodName;
+    instance;
+    initialArgs = [];
+    constructor(instance, scope, methodName) {
+        this.scope = scope;
+        this.methodName = methodName;
+        this.instance = isProxy(instance) ? getProxyTarget(instance) : instance;
+    }
+    resolveArgs(...args) {
+        return resolveArgs(this.instance.constructor, this.methodName)(this.scope, {
+            args: [...this.initialArgs, ...args],
+        });
+    }
+    invokeMethod({ args = this.resolveArgs() } = {}) {
+        return this.instance[this.methodName](...args);
+    }
+    setProperty(fn) {
+        this.instance[this.methodName] = fn.resolve(this.scope);
+    }
+    getProperty() {
+        return this.instance[this.methodName];
+    }
+    setInitialArgs(...args) {
+        this.initialArgs = args;
+        return this;
+    }
+    getInitialArgs() {
+        return this.initialArgs;
+    }
+}
+export const createHookContext = (Target, scope, methodName = 'constructor') => new HookContext(Target, scope, methodName);
+export const createHookContextFactory = ({ args = [] } = {}) => (Target, scope, methodName) => createHookContext(Target, scope, methodName).setInitialArgs(...args);

package/esm/hooks/HooksRunner.js

@@ -0,0 +1,38 @@
+import { createHookContext } from './HookContext.js';
+import { getHooks, hasHooks, toHookFn } from './hook.js';
+import { UnexpectedHookResultError } from '../errors/UnexpectedHookResultError.js';
+import { promisify } from '../utils/promise.js';
+export class HooksRunner {
+    key;
+    constructor(key) {
+        this.key = key;
+    }
+    hasHooks(target) {
+        return hasHooks(target, this.key);
+    }
+    execute(target, { scope, createContext = createHookContext, mapContext = (context) => context, predicate = () => true, }) {
+        const hooks = Array.from(getHooks(target, this.key).entries()).filter(([methodName]) => predicate(methodName));
+        const runMethodHooks = (methodName, executions) => {
+            const context = mapContext(createContext(target, scope, methodName));
+            for (const execute of executions) {
+                const result = execute(context);
+                if (result instanceof Promise) {
+                    throw new UnexpectedHookResultError(`Hook ${methodName} returned a promise, use runHooksAsync instead`);
+                }
+            }
+        };
+        for (const [methodName, executions] of hooks) {
+            runMethodHooks(methodName, executions.map(toHookFn));
+        }
+    }
+    async executeAsync(target, { scope, createContext = createHookContext, mapContext = (context) => context, predicate = () => true, }) {
+        const hooks = Array.from(getHooks(target, this.key).entries()).filter(([methodName]) => predicate(methodName));
+        const runMethodHooks = async (methodName, executions) => {
+            const context = mapContext(createContext(target, scope, methodName));
+            for (const execute of executions) {
+                await promisify(execute(context));
+            }
+        };
+        return Promise.all(hooks.map(([methodName, executions]) => runMethodHooks(methodName, executions.map(toHookFn))));
+    }
+}

package/esm/hooks/hook.js

@@ -0,0 +1,46 @@
+import { Is } from '../utils/basic.js';
+import { getProxyTarget, isProxy } from '../utils/proxy.js';
+export const appendHooks = (...fns) => (...prev) => [...prev, ...fns];
+export const prependHooks = (...fns) => (...prev) => [...fns, ...prev];
+export const append = appendHooks;
+export const prepend = prependHooks;
+const isHookClassConstructor = (execute) => {
+    return Is.constructor(execute) && execute.prototype.execute;
+};
+export const toHookFn = (execute) => isHookClassConstructor(execute) ? (context) => context.scope.resolve(execute).execute(context) : execute;
+const getReflectionTarget = (target) => {
+    return isProxy(target) ? getProxyTarget(target) : target;
+};
+const getConstructorChain = (ctor) => {
+    const chain = [];
+    let current = ctor;
+    while (typeof current === 'function' && current !== Function.prototype) {
+        chain.push(current);
+        current = Object.getPrototypeOf(current);
+    }
+    return chain;
+};
+export function getHooks(target, key) {
+    const reflectionTarget = getReflectionTarget(target);
+    const merged = new Map();
+    for (const ctor of getConstructorChain(reflectionTarget.constructor).reverse()) {
+        const ownHooks = Reflect.getOwnMetadata(key, ctor);
+        if (ownHooks) {
+            for (const [methodName, fns] of ownHooks) {
+                merged.set(methodName, fns);
+            }
+        }
+    }
+    return merged;
+}
+export function hasHooks(target, key) {
+    const reflectionTarget = getReflectionTarget(target);
+    return getConstructorChain(reflectionTarget.constructor).some((ctor) => Reflect.hasOwnMetadata(key, ctor));
+}
+export const hook = (key, mapFn) => (target, propertyKey) => {
+    const hooks = Reflect.hasOwnMetadata(key, target.constructor)
+        ? Reflect.getOwnMetadata(key, target.constructor)
+        : new Map();
+    hooks.set(propertyKey, mapFn(...(hooks.get(propertyKey) ?? [])));
+    Reflect.defineMetadata(key, hooks, target.constructor);
+};

package/esm/hooks/injectProp.js

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

package/esm/hooks/onConstruct.js

@@ -0,0 +1,23 @@
+import { hook, prependHooks } from './hook.js';
+import { HooksRunner } from './HooksRunner.js';
+export const onConstructHooksRunner = new HooksRunner('onConstruct');
+export const onConstruct = (...fns) => hook('onConstruct', prependHooks(...fns));
+export class AddOnConstructHookModule {
+    onException;
+    constructor(onException) {
+        this.onException = onException;
+    }
+    applyTo(container) {
+        container.addOnConstructHook((instance, scope) => {
+            try {
+                onConstructHooksRunner.execute(instance, { scope });
+            }
+            catch (ex) {
+                if (!this.onException) {
+                    throw ex;
+                }
+                this.onException(ex, { scope });
+            }
+        });
+    }
+}

package/esm/hooks/onConstructAsync.js

@@ -0,0 +1,23 @@
+import { hook, prependHooks } from './hook.js';
+import { HooksRunner } from './HooksRunner.js';
+export const onConstructAsyncHooksRunner = new HooksRunner('onConstructAsync');
+export const onConstructAsync = (...fns) => hook('onConstructAsync', prependHooks(...fns));
+export class AddOnConstructAsyncHookModule {
+    onException;
+    constructor(onException) {
+        this.onException = onException;
+    }
+    applyTo(container) {
+        container.addOnConstructHook((instance, scope) => {
+            if (!onConstructAsyncHooksRunner.hasHooks(instance)) {
+                return;
+            }
+            onConstructAsyncHooksRunner.executeAsync(instance, { scope }).catch((ex) => {
+                if (!this.onException) {
+                    throw ex;
+                }
+                this.onException(ex, { scope });
+            });
+        });
+    }
+}

package/esm/hooks/onContainerDisposed.js

@@ -0,0 +1,13 @@
+import { hook, prependHooks } from './hook.js';
+import { HooksRunner } from './HooksRunner.js';
+export const onContainerDisposedHooksRunner = new HooksRunner('onContainerDisposed');
+export const onContainerDisposed = (...fns) => hook('onContainerDisposed', prependHooks(...fns));
+export class AddOnDisposeHookModule {
+    applyTo(container) {
+        container.addOnDisposeHook((scope) => {
+            for (const instance of scope.getInstances()) {
+                onContainerDisposedHooksRunner.execute(instance, { scope });
+            }
+        });
+    }
+}

package/esm/index.js

@@ -0,0 +1,46 @@
+export { isDependencyKey, } from './container/IContainer.js';
+export { Container } from './container/Container.js';
+export { EmptyContainer } from './container/EmptyContainer.js';
+export { Injector } from './injector/IInjector.js';
+export { MetadataInjector, inject, args, argsFn, resolveArgs } from './injector/MetadataInjector.js';
+export { SimpleInjector } from './injector/SimpleInjector.js';
+export { ProxyInjector } from './injector/ProxyInjector.js';
+export { Provider } from './provider/Provider.js';
+export { register, bindTo, scope, scopeAccess, lazy, singleton, decorate, appendArgs, appendArgsFn, } from './registration/IRegistration.js';
+export { Registration } from './registration/Registration.js';
+export { ContainerError } from './errors/ContainerError.js';
+export { DependencyNotFoundError } from './errors/DependencyNotFoundError.js';
+export { ContainerNotFoundError } from './errors/ContainerNotFoundError.js';
+export { DependencyMissingKeyError } from './errors/DependencyMissingKeyError.js';
+export { MethodNotImplementedError } from './errors/MethodNotImplementedError.js';
+export { ContainerDisposedError } from './errors/ContainerDisposedError.js';
+export { ProviderDisposedError } from './errors/ProviderDisposedError.js';
+export { UnexpectedHookResultError } from './errors/UnexpectedHookResultError.js';
+export { CannonSingletonApplyTwiceError } from './errors/CannonSingletonApplyTwiceError.js';
+export { UnsupportedTokenTypeError } from './errors/UnsupportedTokenTypeError.js';
+export { getHooks, hook, hasHooks, appendHooks, prependHooks, append, prepend, } from './hooks/hook.js';
+export { HookContext, createHookContextFactory, createHookContext } from './hooks/HookContext.js';
+export { injectProp } from './hooks/injectProp.js';
+export { onConstructHooksRunner, onConstruct, AddOnConstructHookModule, } from './hooks/onConstruct.js';
+export { onConstructAsyncHooksRunner, onConstructAsync, AddOnConstructAsyncHookModule } from './hooks/onConstructAsync.js';
+export { onContainerDisposedHooksRunner, onContainerDisposed, AddOnDisposeHookModule, } from './hooks/onContainerDisposed.js';
+export { HooksRunner } from './hooks/HooksRunner.js';
+export { InjectionToken } from './token/InjectionToken.js';
+export { GroupAliasToken, toGroupAlias } from './token/GroupAliasToken.js';
+export { SingleAliasToken, toSingleAlias } from './token/SingleAliasToken.js';
+export { ClassToken } from './token/ClassToken.js';
+export { SingleToken } from './token/SingleToken.js';
+export { FunctionToken } from './token/FunctionToken.js';
+export { ConstantToken } from './token/ConstantToken.js';
+export { GroupInstanceToken } from './token/GroupInstanceToken.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 { handleError, handleAsyncError } from './utils/errorHandler.js';
+export { throttle } from './utils/throttle.js';
+export { debounce } from './utils/debounce.js';
+export { shallowCache } from './utils/shallowCache.js';
+export { once } from './utils/once.js';
+export { select } from './select.js';
+export { pipe } from './utils/fp.js';
+export { Is, resolveConstructor } from './utils/basic.js';

package/esm/injector/IInjector.js

@@ -0,0 +1,10 @@
+import { toLazyIf } from '../utils/proxy.js';
+export class Injector {
+    resolve(scope, Target, { args, lazy } = {}) {
+        return toLazyIf(() => {
+            const instance = this.createInstance(scope, Target, { args });
+            scope.addInstance(instance);
+            return instance;
+        }, lazy);
+    }
+}

package/esm/injector/MetadataInjector.js

@@ -0,0 +1,25 @@
+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';
+export class MetadataInjector extends Injector {
+    createInstance(scope, Target, { args: deps = [] } = {}) {
+        const args = resolveArgs(Target)(scope, { args: deps });
+        return new Target(...args);
+    }
+}
+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)));
+    };
+    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) => {
+    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/esm/injector/ProxyInjector.js

@@ -0,0 +1,14 @@
+import { Injector } from './IInjector.js';
+export class ProxyInjector extends Injector {
+    createInstance(scope, Target, { args = [] } = {}) {
+        const proxy = new Proxy({}, {
+            get(target, prop) {
+                if (prop === 'args') {
+                    return args;
+                }
+                return prop.toString().search(/alias/gi) >= 0 ? scope.resolveByAlias(prop) : scope.resolve(prop);
+            },
+        });
+        return new Target(proxy);
+    }
+}

package/esm/injector/SimpleInjector.js

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

package/esm/metadata/class.js

@@ -0,0 +1,12 @@
+import { resolveConstructor } from '../utils/basic.js';
+export const addClassMeta = (key, mapFn) => (target) => {
+    const value = Reflect.getOwnMetadata(key, target);
+    Reflect.defineMetadata(key, mapFn(value), target);
+};
+export function getClassMeta(target, key) {
+    return Reflect.getOwnMetadata(key, resolveConstructor(target));
+}
+export const addClassLabel = (key, label) => addClassMeta('label', (prev = new Map()) => prev.set(key, label));
+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();

package/esm/metadata/method.js

@@ -0,0 +1,10 @@
+import { resolveConstructor } from '../utils/basic.js';
+export const addMethodMeta = (key, mapFn) => (target, propertyKey) => {
+    const metadata = Reflect.getMetadata(key, target.constructor, propertyKey);
+    Reflect.defineMetadata(key, mapFn(metadata), target.constructor, propertyKey);
+};
+export const getMethodMeta = (key, target, propertyKey) => Reflect.getMetadata(key, resolveConstructor(target), propertyKey);
+export const addMethodLabel = (key, label) => addMethodMeta('label', (prev = new Map()) => prev.set(key, label));
+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();

package/esm/metadata/parameter.js

@@ -0,0 +1,25 @@
+import { resolveConstructor } from '../utils/basic.js';
+export const addParamMeta = (key, mapFn) => (target, _, parameterIndex) => {
+    const metadata = Reflect.getOwnMetadata(key, target) ?? [];
+    metadata[parameterIndex] = mapFn(metadata[parameterIndex]);
+    Reflect.defineMetadata(key, metadata, target);
+};
+export const getParamMeta = (key, target) => {
+    return Reflect.getOwnMetadata(key, resolveConstructor(target)) ?? [];
+};
+export const addParamLabel = (key, label) => addParamMeta('label', (prev) => {
+    const map = prev ?? new Map();
+    return map.set(key, label);
+});
+export const getParamLabels = (target, parameterIndex) => {
+    const all = getParamMeta('label', target);
+    return all[parameterIndex] ?? new Map();
+};
+export const addParamTag = (tag) => addParamMeta('tag', (prev) => {
+    const set = prev ?? new Set();
+    return set.add(tag);
+});
+export const getParamTags = (target, parameterIndex) => {
+    const all = getParamMeta('tag', target);
+    return all[parameterIndex] ?? new Set();
+};

package/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/esm/provider/IProvider.js

@@ -0,0 +1 @@
+export {};

package/esm/provider/Provider.js

@@ -0,0 +1,76 @@
+import { CannonSingletonApplyTwiceError } from '../errors/CannonSingletonApplyTwiceError.js';
+import { ProviderDisposedError } from '../errors/ProviderDisposedError.js';
+export class Provider {
+    resolveDependency;
+    static fromClass(Target) {
+        return new Provider((container, options) => container.resolve(Target, options));
+    }
+    static fromValue(value) {
+        return new Provider(() => value);
+    }
+    static fromKey(key) {
+        return new Provider((c) => c.resolve(key));
+    }
+    argsFnList = [];
+    accessRules = [];
+    mappers = [];
+    isLazy = false;
+    cache = new Map();
+    getKey;
+    isDisposed = false;
+    constructor(resolveDependency) {
+        this.resolveDependency = resolveDependency;
+    }
+    resolve(scope, options) {
+        ProviderDisposedError.assert(!this.isDisposed, 'Provider is already disposed');
+        if (!this.getKey) {
+            return this.resolveDep(scope, options);
+        }
+        const key = this.getKey(...(options.args ?? []));
+        if (!this.cache.has(key)) {
+            this.cache.set(key, this.resolveDep(scope, options));
+        }
+        return this.cache.get(key);
+    }
+    resolveDep(scope, { args = [], lazy } = {}) {
+        const dependency = this.resolveDependency(scope, {
+            args: this.argsFnList.reduce((acc, current) => current(scope, { args: acc }), args),
+            lazy: lazy ?? this.isLazy,
+        });
+        return this.mappers.reduce((acc, current) => current(acc, scope), dependency);
+    }
+    map(...mappers) {
+        this.mappers.push(...mappers);
+        return this;
+    }
+    addAccessRule(...rules) {
+        this.accessRules.push(...rules);
+        return this;
+    }
+    lazy() {
+        this.isLazy = true;
+        return this;
+    }
+    addArgsFn(...fns) {
+        this.argsFnList.push(...fns);
+        return this;
+    }
+    hasAccess(options) {
+        ProviderDisposedError.assert(!this.isDisposed, 'Provider is already disposed');
+        return this.accessRules.reduce((acc, rule) => rule(options, acc), true);
+    }
+    singleton(getCacheKey = () => '1') {
+        CannonSingletonApplyTwiceError.assert(!this.getKey, 'Provider is already singleton');
+        this.getKey = getCacheKey;
+        return this;
+    }
+    dispose() {
+        ProviderDisposedError.assert(!this.isDisposed, 'Provider is already disposed');
+        this.isDisposed = true;
+        this.getKey = undefined;
+        this.cache.clear();
+        this.accessRules.splice(0, this.accessRules.length);
+        this.mappers.splice(0, this.mappers.length);
+        this.argsFnList.splice(0, this.argsFnList.length);
+    }
+}

package/esm/registration/IRegistration.js

@@ -0,0 +1,35 @@
+import { isDependencyKey } from '../container/IContainer.js';
+import { SingleToken } from '../token/SingleToken.js';
+import { isBindToken } from '../token/BindToken.js';
+import { addClassMeta, getClassMeta } from '../metadata/class.js';
+export const isProviderPipe = (obj) => obj !== null && typeof obj === 'object' && 'mapProvider' in obj;
+export const registerPipe = (mapProvider) => ({
+    mapProvider,
+    mapRegistration: (r) => r.pipe(mapProvider),
+});
+const METADATA_KEY = 'registration';
+export const getTransformers = (Target) => getClassMeta(Target, METADATA_KEY) ?? [];
+export const register = (...mappers) => addClassMeta(METADATA_KEY, (acc) => {
+    const result = mappers.map((m) => {
+        if (isProviderPipe(m))
+            return (r) => m.mapRegistration(r);
+        if (isBindToken(m) || isDependencyKey(m))
+            return bindTo(m);
+        return m;
+    });
+    return acc ? [...result, ...acc] : result;
+});
+export const bindTo = (...tokens) => (r) => {
+    for (const token of tokens) {
+        const targetToken = isBindToken(token) ? token : new SingleToken(token);
+        targetToken.bindTo(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 scopeAccess = (rule) => registerPipe((p) => p.addAccessRule(rule));
+export const lazy = () => registerPipe((p) => p.lazy());
+export const decorate = (...fns) => registerPipe((p) => p.map(...fns));
+export const singleton = (getCacheKey) => registerPipe((p) => p.singleton(getCacheKey));