ts-ioc-container 56.1.0 → 56.2.0

package/esm/registration/Registration.js

@@ -0,0 +1,81 @@
+import { isDependencyKey } from '../container/IContainer.js';
+import { Provider } from '../provider/Provider.js';
+import { DependencyMissingKeyError } from '../errors/DependencyMissingKeyError.js';
+import { isProviderPipe } from './IRegistration.js';
+import { getTransformers } from './IRegistration.js';
+import { SingleToken } from '../token/SingleToken.js';
+import { pipe } from '../utils/fp.js';
+import { Is } from '../utils/basic.js';
+export class Registration {
+    createProvider;
+    key;
+    scopeRules;
+    static fromClass(Target, { name } = {}) {
+        const transform = pipe(...getTransformers(Target));
+        return transform(new Registration(() => Provider.fromClass(Target), name ?? Target.name));
+    }
+    static fromValue(value) {
+        if (Is.constructor(value)) {
+            const transform = pipe(...getTransformers(value));
+            return transform(new Registration(() => Provider.fromValue(value), value.name));
+        }
+        return new Registration(() => Provider.fromValue(value));
+    }
+    static fromFn(fn) {
+        return new Registration(() => new Provider(fn));
+    }
+    static fromKey(key) {
+        return new Registration(() => Provider.fromKey(key));
+    }
+    mappers = [];
+    aliases = new Set();
+    constructor(createProvider, key, scopeRules = []) {
+        this.createProvider = createProvider;
+        this.key = key;
+        this.scopeRules = scopeRules;
+    }
+    bindToKey(key) {
+        this.key = key;
+        return this;
+    }
+    bindToAlias(alias) {
+        this.aliases.add(alias);
+        return this;
+    }
+    pipe(...mappers) {
+        const fns = mappers.map((m) => (isProviderPipe(m) ? m.mapProvider.bind(m) : m));
+        this.mappers.push(...fns);
+        return this;
+    }
+    when(...predicates) {
+        this.scopeRules.push(...predicates);
+        return this;
+    }
+    bindTo(key) {
+        if (isDependencyKey(key)) {
+            new SingleToken(key).bindTo(this);
+            return this;
+        }
+        key.bindTo(this);
+        return this;
+    }
+    matchScope(container) {
+        return this.scopeRules.reduce((prev, curr) => curr(container, prev), true);
+    }
+    applyTo(container) {
+        if (!this.matchScope(container)) {
+            return;
+        }
+        if (!this.key) {
+            throw new DependencyMissingKeyError('No key provided for registration');
+        }
+        const provider = this.mappers.reduce((p, m) => m(p), this.createProvider());
+        container.register(this.key, provider, { aliases: [...this.aliases] });
+    }
+    getKeyOrFail() {
+        if (!this.key) {
+            throw new DependencyMissingKeyError('No key provided for registration');
+        }
+        return this.key;
+    }
+}

package/esm/select.js

@@ -0,0 +1,13 @@
+import { toGroupAlias } from './token/GroupAliasToken.js';
+import { FunctionToken } from './token/FunctionToken.js';
+import { GroupInstanceToken } from './token/GroupInstanceToken.js';
+import { toToken } from './token/toToken.js';
+export const select = {
+    alias: toGroupAlias,
+    token: toToken,
+    instances: (predicate = () => true) => new GroupInstanceToken(predicate),
+    scope: {
+        current: new FunctionToken((s) => s),
+        create: (options) => new FunctionToken((s) => s.createScope(options)),
+    },
+};

package/esm/token/BindToken.js

@@ -0,0 +1,4 @@
+import { Is } from '../utils/basic.js';
+export function isBindToken(token) {
+    return !Is.nullish(token) && typeof token === 'object' && 'bindTo' in token;
+}

package/esm/token/ClassToken.js

@@ -0,0 +1,41 @@
+import { InjectionToken } from './InjectionToken.js';
+export class ClassToken extends InjectionToken {
+    target;
+    _getArgsFn;
+    _isLazy;
+    constructor(target, { getArgsFn = () => [], isLazy = false } = {}) {
+        super();
+        this.target = target;
+        this._getArgsFn = getArgsFn;
+        this._isLazy = isLazy;
+    }
+    select(fn) {
+        return (s) => fn(this.resolve(s));
+    }
+    resolve(s, { args = [], lazy } = {}) {
+        return s.resolve(this.target, {
+            args: this._getArgsFn(s, { args }),
+            lazy: this._isLazy || lazy,
+        });
+    }
+    args(...newArgs) {
+        const parentFn = this._getArgsFn;
+        return new ClassToken(this.target, {
+            getArgsFn: (s, opts) => [...parentFn(s, opts), ...newArgs],
+            isLazy: this._isLazy,
+        });
+    }
+    argsFn(fn) {
+        const parentFn = this._getArgsFn;
+        return new ClassToken(this.target, {
+            getArgsFn: (s, opts) => [...parentFn(s, opts), ...fn(s)],
+            isLazy: this._isLazy,
+        });
+    }
+    lazy() {
+        return new ClassToken(this.target, {
+            getArgsFn: this._getArgsFn,
+            isLazy: true,
+        });
+    }
+}

package/esm/token/ConstantToken.js

@@ -0,0 +1,21 @@
+import { InjectionToken } from './InjectionToken.js';
+import { MethodNotImplementedError } from '../errors/MethodNotImplementedError.js';
+export class ConstantToken extends InjectionToken {
+    token;
+    constructor(token) {
+        super();
+        this.token = token;
+    }
+    resolve(s) {
+        return this.token;
+    }
+    args(...deps) {
+        throw new MethodNotImplementedError('not implemented');
+    }
+    argsFn(getArgsFn) {
+        throw new MethodNotImplementedError('not implemented');
+    }
+    lazy() {
+        throw new MethodNotImplementedError('not implemented');
+    }
+}

package/esm/token/FunctionToken.js

@@ -0,0 +1,38 @@
+import { InjectionToken } from './InjectionToken.js';
+export class FunctionToken extends InjectionToken {
+    fn;
+    _getArgsFn;
+    _isLazy;
+    constructor(fn, { getArgsFn = (_, { args = [] } = {}) => args, isLazy = false } = {}) {
+        super();
+        this.fn = fn;
+        this._getArgsFn = getArgsFn;
+        this._isLazy = isLazy;
+    }
+    resolve(s, { args = [], lazy } = {}) {
+        return this.fn(s, {
+            args: this._getArgsFn(s, { args }),
+            lazy: this._isLazy || lazy,
+        });
+    }
+    args(...newArgs) {
+        const parentFn = this._getArgsFn;
+        return new FunctionToken(this.fn, {
+            getArgsFn: (s, opts) => [...parentFn(s, opts), ...newArgs],
+            isLazy: this._isLazy,
+        });
+    }
+    argsFn(fn) {
+        const parentFn = this._getArgsFn;
+        return new FunctionToken(this.fn, {
+            getArgsFn: (s, opts) => [...parentFn(s, opts), ...fn(s)],
+            isLazy: this._isLazy,
+        });
+    }
+    lazy() {
+        return new FunctionToken(this.fn, {
+            getArgsFn: this._getArgsFn,
+            isLazy: true,
+        });
+    }
+}

package/esm/token/GroupAliasToken.js

@@ -0,0 +1,45 @@
+import { InjectionToken } from './InjectionToken.js';
+export class GroupAliasToken extends InjectionToken {
+    token;
+    _getArgsFn;
+    _isLazy;
+    constructor(token, { getArgsFn = () => [], isLazy = false } = {}) {
+        super();
+        this.token = token;
+        this._getArgsFn = getArgsFn;
+        this._isLazy = isLazy;
+    }
+    select(fn) {
+        return (s) => fn(this.resolve(s));
+    }
+    resolve(s, { args = [], lazy } = {}) {
+        return s.resolveByAlias(this.token, {
+            args: this._getArgsFn(s, { args }),
+            lazy: this._isLazy || lazy,
+        });
+    }
+    bindTo(r) {
+        r.bindToAlias(this.token);
+    }
+    args(...newArgs) {
+        const parentFn = this._getArgsFn;
+        return new GroupAliasToken(this.token, {
+            getArgsFn: (s, opts) => [...parentFn(s, opts), ...newArgs],
+            isLazy: this._isLazy,
+        });
+    }
+    argsFn(fn) {
+        const parentFn = this._getArgsFn;
+        return new GroupAliasToken(this.token, {
+            getArgsFn: (s, opts) => [...parentFn(s, opts), ...fn(s)],
+            isLazy: this._isLazy,
+        });
+    }
+    lazy() {
+        return new GroupAliasToken(this.token, {
+            getArgsFn: this._getArgsFn,
+            isLazy: true,
+        });
+    }
+}
+export const toGroupAlias = (token) => new GroupAliasToken(token);

package/esm/token/GroupInstanceToken.js

@@ -0,0 +1,29 @@
+import { InjectionToken } from './InjectionToken.js';
+import { MethodNotImplementedError } from '../errors/MethodNotImplementedError.js';
+export class GroupInstanceToken extends InjectionToken {
+    predicate;
+    isCascade = true;
+    constructor(predicate) {
+        super();
+        this.predicate = predicate;
+    }
+    select(fn) {
+        return (s) => this.resolve(s).map(fn);
+    }
+    args(...deps) {
+        throw new MethodNotImplementedError('not implemented');
+    }
+    argsFn(getArgsFn) {
+        throw new MethodNotImplementedError('not implemented');
+    }
+    lazy() {
+        throw new MethodNotImplementedError('not implemented');
+    }
+    cascade(isTrue) {
+        this.isCascade = isTrue;
+        return this;
+    }
+    resolve(c) {
+        return c.getInstances(this.isCascade).filter(this.predicate);
+    }
+}

package/esm/token/InjectionToken.js

@@ -0,0 +1,6 @@
+import { Is } from '../utils/basic.js';
+export class InjectionToken {
+}
+export function isInjectionToken(target) {
+    return Is.object(target) && 'resolve' in target && 'args' in target && 'argsFn' in target && 'lazy' in target;
+}

package/esm/token/SingleAliasToken.js

@@ -0,0 +1,45 @@
+import { InjectionToken } from './InjectionToken.js';
+export class SingleAliasToken extends InjectionToken {
+    token;
+    _getArgsFn;
+    _isLazy;
+    constructor(token, { getArgsFn = () => [], isLazy = false } = {}) {
+        super();
+        this.token = token;
+        this._getArgsFn = getArgsFn;
+        this._isLazy = isLazy;
+    }
+    select(fn) {
+        return (s) => fn(this.resolve(s));
+    }
+    resolve(s, { args = [], lazy } = {}) {
+        return s.resolveOneByAlias(this.token, {
+            args: this._getArgsFn(s, { args }),
+            lazy: this._isLazy || lazy,
+        });
+    }
+    bindTo(r) {
+        r.bindToAlias(this.token);
+    }
+    args(...newArgs) {
+        const parentFn = this._getArgsFn;
+        return new SingleAliasToken(this.token, {
+            getArgsFn: (s, opts) => [...parentFn(s, opts), ...newArgs],
+            isLazy: this._isLazy,
+        });
+    }
+    argsFn(fn) {
+        const parentFn = this._getArgsFn;
+        return new SingleAliasToken(this.token, {
+            getArgsFn: (s, opts) => [...parentFn(s, opts), ...fn(s)],
+            isLazy: this._isLazy,
+        });
+    }
+    lazy() {
+        return new SingleAliasToken(this.token, {
+            getArgsFn: this._getArgsFn,
+            isLazy: true,
+        });
+    }
+}
+export const toSingleAlias = (token) => new SingleAliasToken(token);

package/esm/token/SingleToken.js

@@ -0,0 +1,44 @@
+import { InjectionToken } from './InjectionToken.js';
+export class SingleToken extends InjectionToken {
+    token;
+    _getArgsFn;
+    _isLazy;
+    constructor(token, { getArgsFn = () => [], isLazy = false } = {}) {
+        super();
+        this.token = token;
+        this._getArgsFn = getArgsFn;
+        this._isLazy = isLazy;
+    }
+    select(fn) {
+        return (s) => fn(this.resolve(s));
+    }
+    resolve(s, { args = [], lazy } = {}) {
+        return s.resolve(this.token, {
+            args: this._getArgsFn(s, { args }),
+            lazy: this._isLazy || lazy,
+        });
+    }
+    bindTo(r) {
+        r.bindToKey(this.token);
+    }
+    args(...newArgs) {
+        const parentFn = this._getArgsFn;
+        return new SingleToken(this.token, {
+            getArgsFn: (s, opts) => [...parentFn(s, opts), ...newArgs],
+            isLazy: this._isLazy,
+        });
+    }
+    argsFn(fn) {
+        const parentFn = this._getArgsFn;
+        return new SingleToken(this.token, {
+            getArgsFn: (s, opts) => [...parentFn(s, opts), ...fn(s)],
+            isLazy: this._isLazy,
+        });
+    }
+    lazy() {
+        return new SingleToken(this.token, {
+            getArgsFn: this._getArgsFn,
+            isLazy: true,
+        });
+    }
+}

package/esm/token/toToken.js

@@ -0,0 +1,24 @@
+import { isDependencyKey } from '../container/IContainer.js';
+import { SingleToken } from './SingleToken.js';
+import { ClassToken } from './ClassToken.js';
+import { FunctionToken } from './FunctionToken.js';
+import { UnsupportedTokenTypeError } from '../errors/UnsupportedTokenTypeError.js';
+import { InjectionToken, isInjectionToken } from './InjectionToken.js';
+import { Is } from '../utils/basic.js';
+import { ConstantToken } from './ConstantToken.js';
+export const toToken = (token) => {
+    if (token instanceof InjectionToken) {
+        return token;
+    }
+    if (isDependencyKey(token)) {
+        return new SingleToken(token);
+    }
+    if (Is.constructor(token)) {
+        return new ClassToken(token);
+    }
+    if (typeof token === 'function') {
+        return new FunctionToken(token);
+    }
+    throw new UnsupportedTokenTypeError(`Unknown token ${token}`);
+};
+export const argToToken = (v) => (isInjectionToken(v) ? v : new ConstantToken(v));

package/esm/utils/array.js

@@ -0,0 +1,6 @@
+export const Filter = {
+    exclude: (arr) => {
+        const excludeSet = arr instanceof Array ? new Set(arr) : arr;
+        return (v) => !excludeSet.has(v);
+    },
+};

package/esm/utils/basic.js

@@ -0,0 +1,9 @@
+export const Is = {
+    nullish: (value) => value === undefined || value === null,
+    object: (target) => target !== null && typeof target === 'object',
+    instance: (target) => Object.prototype.hasOwnProperty.call(target, 'constructor'),
+    constructor: (target) => typeof target === 'function' && !!target.prototype,
+};
+export function resolveConstructor(target) {
+    return Is.constructor(target) ? target : target.constructor;
+}

package/esm/utils/debounce.js

@@ -0,0 +1,12 @@
+export const debounce = (ms) => (target, propertyKey, descriptor) => {
+    const originalMethod = descriptor.value;
+    const timerMap = new WeakMap();
+    descriptor.value = function (...args) {
+        const prev = timerMap.get(this);
+        if (prev !== undefined) {
+            clearTimeout(prev);
+        }
+        timerMap.set(this, setTimeout(() => originalMethod.apply(this, args), ms));
+    };
+    return descriptor;
+};

package/esm/utils/errorHandler.js

@@ -0,0 +1,24 @@
+export const handleAsyncError = (errorHandler) => (target, propertyKey, descriptor) => {
+    const originalMethod = descriptor.value;
+    descriptor.value = async function (...args) {
+        try {
+            return await originalMethod.apply(this, args);
+        }
+        catch (e) {
+            errorHandler(e, { target: target.constructor.name, method: propertyKey });
+        }
+    };
+    return descriptor;
+};
+export const handleError = (errorHandler) => (target, propertyKey, descriptor) => {
+    const originalMethod = descriptor.value;
+    descriptor.value = function (...args) {
+        try {
+            return originalMethod.apply(this, args);
+        }
+        catch (e) {
+            errorHandler(e, { target: target.constructor.name, method: propertyKey });
+        }
+    };
+    return descriptor;
+};

package/esm/utils/fp.js

@@ -0,0 +1,3 @@
+export function pipe(...mappers) {
+    return (value) => mappers.reduce((acc, current) => current(acc), value);
+}

package/esm/utils/once.js

@@ -0,0 +1,16 @@
+export const once = ({ onRepeat } = {}) => (target, propertyKey, descriptor) => {
+    const originalMethod = descriptor.value;
+    const cacheMap = new WeakMap();
+    let index = 0;
+    descriptor.value = function (...args) {
+        index++;
+        if (cacheMap.has(this)) {
+            onRepeat?.({ index: index - 1, args });
+            return cacheMap.get(this);
+        }
+        const result = originalMethod.apply(this, args);
+        cacheMap.set(this, result);
+        return result;
+    };
+    return descriptor;
+};

package/esm/utils/promise.js

@@ -0,0 +1 @@
+export const promisify = (arg) => (arg instanceof Promise ? arg : Promise.resolve(arg));

package/esm/utils/proxy.js

@@ -0,0 +1,33 @@
+const proxyStateMap = new WeakMap();
+const unwrapProxyTarget = (value) => {
+    return isProxy(value) ? getProxyTarget(value) : value;
+};
+export function isProxy(value) {
+    return proxyStateMap.has(value);
+}
+export function getProxyTarget(value) {
+    return proxyStateMap.get(value).getTarget();
+}
+export function lazyProxy(resolveInstance) {
+    let instance;
+    const state = {
+        getTarget: () => {
+            instance = instance ?? unwrapProxyTarget(resolveInstance());
+            return instance;
+        },
+    };
+    const proxy = new Proxy({}, {
+        get: (_, prop) => {
+            const target = state.getTarget();
+            return target[prop];
+        },
+    });
+    proxyStateMap.set(proxy, state);
+    return proxy;
+}
+export function toLazyIf(resolveInstance, isLazy = false) {
+    if (isLazy) {
+        return lazyProxy(resolveInstance);
+    }
+    return resolveInstance();
+}

package/esm/utils/shallowCache.js

@@ -0,0 +1,19 @@
+export const shallowCache = (getKeyByArgs) => (target, propertyKey, descriptor) => {
+    const originalMethod = descriptor.value;
+    const cacheMap = new WeakMap();
+    descriptor.value = function (...args) {
+        let cache = cacheMap.get(this);
+        if (cache === undefined) {
+            cache = new Map();
+            cacheMap.set(this, cache);
+        }
+        const key = getKeyByArgs(...args);
+        if (cache.has(key)) {
+            return cache.get(key);
+        }
+        const result = originalMethod.apply(this, args);
+        cache.set(key, result);
+        return result;
+    };
+    return descriptor;
+};

package/esm/utils/throttle.js

@@ -0,0 +1,14 @@
+export const throttle = (ms) => (target, propertyKey, descriptor) => {
+    const originalMethod = descriptor.value;
+    const lastCalledMap = new WeakMap();
+    descriptor.value = function (...args) {
+        const now = Date.now();
+        const lastCalled = lastCalledMap.get(this) ?? -Infinity;
+        if (now - lastCalled < ms) {
+            return undefined;
+        }
+        lastCalledMap.set(this, now);
+        return originalMethod.apply(this, args);
+    };
+    return descriptor;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-ioc-container",
-  "version": "56.1.0",
+  "version": "56.2.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/ExecutionContext.d.ts

@@ -0,0 +1,4 @@
+import type { IContainer } from './container/IContainer.js';
+export interface ExecutionContext {
+    scope: IContainer;
+}

package/typings/container/AliasMap.d.ts

@@ -0,0 +1,8 @@
+import { type DependencyKey } from './IContainer.js';
+export type Alias = DependencyKey;
+export declare class AliasMap {
+    private readonly aliasToKeySet;
+    getKeysByAlias(alias: DependencyKey): DependencyKey[];
+    setAliasesByKey(key: DependencyKey, aliases: DependencyKey[]): void;
+    destroy(): void;
+}

package/typings/container/Container.d.ts

@@ -0,0 +1,48 @@
+import { type CreateScopeOptions, type DependencyKey, type IContainer, type IContainerModule, type RegisterOptions, ResolveManyOptions, type ResolveOneOptions, type Tag } from './IContainer.js';
+import { type IInjector } from '../injector/IInjector.js';
+import { type IProvider } from '../provider/IProvider.js';
+import { type IRegistration } from '../registration/IRegistration.js';
+import { OnConstructHook } from '../hooks/onConstruct.js';
+import { OnDisposeHook } from '../hooks/onContainerDisposed.js';
+import { constructor, Instance } from '../utils/basic.js';
+export declare class Container implements IContainer {
+    isDisposed: boolean;
+    private parent;
+    private scopes;
+    private instances;
+    private registrations;
+    private readonly tags;
+    private readonly providers;
+    private readonly aliases;
+    private readonly injector;
+    private readonly onConstructHookList;
+    private readonly onDisposeHookList;
+    constructor(options?: {
+        injector?: IInjector;
+        parent?: IContainer;
+        tags?: Tag[];
+    });
+    register(key: DependencyKey, provider: IProvider, { aliases }?: RegisterOptions): this;
+    resolve<T>(target: constructor<T> | DependencyKey, { args, child, lazy }?: ResolveOneOptions): T;
+    resolveByAlias<T>(alias: DependencyKey, { args, child, lazy, excludedKeys }?: ResolveManyOptions): T[];
+    resolveOneByAlias<T>(alias: DependencyKey, { args, child, lazy }?: ResolveOneOptions): T;
+    createScope({ tags }?: CreateScopeOptions): IContainer;
+    dispose(): void;
+    addRegistration(registration: IRegistration): this;
+    getRegistrations(): IRegistration[];
+    hasRegistration(key: DependencyKey): boolean;
+    addOnConstructHook(...hooks: OnConstructHook[]): this;
+    addOnDisposeHook(...hooks: OnDisposeHook[]): this;
+    addInstance(instance: Instance): void;
+    getScopes(): IContainer[];
+    hasInstance(instance: object): boolean;
+    getScopeByInstanceOrFail(instance: object): IContainer;
+    removeScope(child: IContainer): void;
+    useModule(module: IContainerModule): this;
+    getParent(): IContainer;
+    getInstances(cascade?: boolean): Instance<unknown>[];
+    hasTag(tag: Tag): boolean;
+    addTags(...tags: Tag[]): void;
+    private validateContainer;
+    private findProviderByKeyOrFail;
+}

package/typings/container/EmptyContainer.d.ts

@@ -0,0 +1,30 @@
+import { type DependencyKey, type IContainer, type IContainerModule, type ResolveManyOptions, type ResolveOneOptions, type Tag } from './IContainer.js';
+import { type IProvider } from '../provider/IProvider.js';
+import { type IRegistration } from '../registration/IRegistration.js';
+import { OnDisposeHook } from '../hooks/onContainerDisposed.js';
+import { OnConstructHook } from '../hooks/onConstruct.js';
+import { type constructor, type Instance } from '../utils/basic.js';
+export declare class EmptyContainer implements IContainer {
+    get isDisposed(): boolean;
+    addInstance(instance: Instance): void;
+    getParent(): undefined;
+    getScopes(): never[];
+    getScopeByInstanceOrFail(instance: object): IContainer;
+    getInstances(): never[];
+    hasInstance(instance: object): boolean;
+    createScope(): IContainer;
+    dispose(): void;
+    register(key: DependencyKey, value: IProvider): this;
+    hasTag(tag: Tag): boolean;
+    addTags(...tags: Tag[]): void;
+    getRegistrations(): never[];
+    hasRegistration(key: DependencyKey): boolean;
+    removeScope(): void;
+    useModule(module: IContainerModule): this;
+    addRegistration(registration: IRegistration): this;
+    resolve<T>(key: constructor<T> | DependencyKey, options?: ResolveOneOptions): T;
+    resolveByAlias<T>(alias: DependencyKey, options?: ResolveManyOptions): T[];
+    resolveOneByAlias<T>(alias: DependencyKey, options?: ResolveOneOptions): T;
+    addOnDisposeHook(...hooks: OnDisposeHook[]): this;
+    addOnConstructHook(...hooks: OnConstructHook[]): this;
+}