ts-ioc-container 56.1.0 → 56.2.0

package/cjm/token/FunctionToken.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FunctionToken = void 0;
+const InjectionToken_1 = require("./InjectionToken");
+class FunctionToken extends InjectionToken_1.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,
+        });
+    }
+}
+exports.FunctionToken = FunctionToken;

package/cjm/token/GroupAliasToken.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toGroupAlias = exports.GroupAliasToken = void 0;
+const InjectionToken_1 = require("./InjectionToken");
+class GroupAliasToken extends InjectionToken_1.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,
+        });
+    }
+}
+exports.GroupAliasToken = GroupAliasToken;
+const toGroupAlias = (token) => new GroupAliasToken(token);
+exports.toGroupAlias = toGroupAlias;

package/cjm/token/GroupInstanceToken.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroupInstanceToken = void 0;
+const InjectionToken_1 = require("./InjectionToken");
+const MethodNotImplementedError_1 = require("../errors/MethodNotImplementedError");
+class GroupInstanceToken extends InjectionToken_1.InjectionToken {
+    predicate;
+    isCascade = true;
+    constructor(predicate) {
+        super();
+        this.predicate = predicate;
+    }
+    select(fn) {
+        return (s) => this.resolve(s).map(fn);
+    }
+    args(...deps) {
+        throw new MethodNotImplementedError_1.MethodNotImplementedError('not implemented');
+    }
+    argsFn(getArgsFn) {
+        throw new MethodNotImplementedError_1.MethodNotImplementedError('not implemented');
+    }
+    lazy() {
+        throw new MethodNotImplementedError_1.MethodNotImplementedError('not implemented');
+    }
+    cascade(isTrue) {
+        this.isCascade = isTrue;
+        return this;
+    }
+    resolve(c) {
+        return c.getInstances(this.isCascade).filter(this.predicate);
+    }
+}
+exports.GroupInstanceToken = GroupInstanceToken;

package/cjm/token/InjectionToken.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InjectionToken = void 0;
+exports.isInjectionToken = isInjectionToken;
+const basic_1 = require("../utils/basic");
+class InjectionToken {
+}
+exports.InjectionToken = InjectionToken;
+function isInjectionToken(target) {
+    return basic_1.Is.object(target) && 'resolve' in target && 'args' in target && 'argsFn' in target && 'lazy' in target;
+}

package/cjm/token/SingleAliasToken.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toSingleAlias = exports.SingleAliasToken = void 0;
+const InjectionToken_1 = require("./InjectionToken");
+class SingleAliasToken extends InjectionToken_1.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,
+        });
+    }
+}
+exports.SingleAliasToken = SingleAliasToken;
+const toSingleAlias = (token) => new SingleAliasToken(token);
+exports.toSingleAlias = toSingleAlias;

package/cjm/token/SingleToken.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SingleToken = void 0;
+const InjectionToken_1 = require("./InjectionToken");
+class SingleToken extends InjectionToken_1.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,
+        });
+    }
+}
+exports.SingleToken = SingleToken;

package/cjm/token/toToken.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.argToToken = exports.toToken = void 0;
+const IContainer_1 = require("../container/IContainer");
+const SingleToken_1 = require("./SingleToken");
+const ClassToken_1 = require("./ClassToken");
+const FunctionToken_1 = require("./FunctionToken");
+const UnsupportedTokenTypeError_1 = require("../errors/UnsupportedTokenTypeError");
+const InjectionToken_1 = require("./InjectionToken");
+const basic_1 = require("../utils/basic");
+const ConstantToken_1 = require("./ConstantToken");
+const toToken = (token) => {
+    if (token instanceof InjectionToken_1.InjectionToken) {
+        return token;
+    }
+    if ((0, IContainer_1.isDependencyKey)(token)) {
+        return new SingleToken_1.SingleToken(token);
+    }
+    if (basic_1.Is.constructor(token)) {
+        return new ClassToken_1.ClassToken(token);
+    }
+    if (typeof token === 'function') {
+        return new FunctionToken_1.FunctionToken(token);
+    }
+    throw new UnsupportedTokenTypeError_1.UnsupportedTokenTypeError(`Unknown token ${token}`);
+};
+exports.toToken = toToken;
+const argToToken = (v) => ((0, InjectionToken_1.isInjectionToken)(v) ? v : new ConstantToken_1.ConstantToken(v));
+exports.argToToken = argToToken;

package/cjm/utils/array.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Filter = void 0;
+exports.Filter = {
+    exclude: (arr) => {
+        const excludeSet = arr instanceof Array ? new Set(arr) : arr;
+        return (v) => !excludeSet.has(v);
+    },
+};

package/cjm/utils/basic.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Is = void 0;
+exports.resolveConstructor = resolveConstructor;
+exports.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,
+};
+function resolveConstructor(target) {
+    return exports.Is.constructor(target) ? target : target.constructor;
+}

package/cjm/utils/debounce.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.debounce = void 0;
+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;
+};
+exports.debounce = debounce;

package/cjm/utils/errorHandler.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleError = exports.handleAsyncError = void 0;
+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;
+};
+exports.handleAsyncError = handleAsyncError;
+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;
+};
+exports.handleError = handleError;

package/cjm/utils/fp.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pipe = pipe;
+function pipe(...mappers) {
+    return (value) => mappers.reduce((acc, current) => current(acc), value);
+}

package/cjm/utils/once.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.once = void 0;
+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;
+};
+exports.once = once;

package/cjm/utils/promise.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promisify = void 0;
+const promisify = (arg) => (arg instanceof Promise ? arg : Promise.resolve(arg));
+exports.promisify = promisify;

package/cjm/utils/proxy.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isProxy = isProxy;
+exports.getProxyTarget = getProxyTarget;
+exports.lazyProxy = lazyProxy;
+exports.toLazyIf = toLazyIf;
+const proxyStateMap = new WeakMap();
+const unwrapProxyTarget = (value) => {
+    return isProxy(value) ? getProxyTarget(value) : value;
+};
+function isProxy(value) {
+    return proxyStateMap.has(value);
+}
+function getProxyTarget(value) {
+    return proxyStateMap.get(value).getTarget();
+}
+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;
+}
+function toLazyIf(resolveInstance, isLazy = false) {
+    if (isLazy) {
+        return lazyProxy(resolveInstance);
+    }
+    return resolveInstance();
+}

package/cjm/utils/shallowCache.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shallowCache = void 0;
+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;
+};
+exports.shallowCache = shallowCache;

package/cjm/utils/throttle.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.throttle = void 0;
+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;
+};
+exports.throttle = throttle;

package/esm/ExecutionContext.js

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

package/esm/container/AliasMap.js

@@ -0,0 +1,21 @@
+export class AliasMap {
+    aliasToKeySet = new Map();
+    getKeysByAlias(alias) {
+        return [...(this.aliasToKeySet.get(alias) ?? [])];
+    }
+    setAliasesByKey(key, aliases) {
+        for (const [alias, keySet] of this.aliasToKeySet) {
+            keySet.delete(key);
+            if (keySet.size === 0) {
+                this.aliasToKeySet.delete(alias);
+            }
+        }
+        for (const alias of aliases) {
+            const dependencyKeySet = this.aliasToKeySet.get(alias) ?? new Set();
+            this.aliasToKeySet.set(alias, dependencyKeySet.add(key));
+        }
+    }
+    destroy() {
+        this.aliasToKeySet.clear();
+    }
+}

package/esm/container/Container.js

@@ -0,0 +1,171 @@
+import { EmptyContainer } from './EmptyContainer.js';
+import { ContainerDisposedError } from '../errors/ContainerDisposedError.js';
+import { MetadataInjector } from '../injector/MetadataInjector.js';
+import { AliasMap } from './AliasMap.js';
+import { DependencyNotFoundError } from '../errors/DependencyNotFoundError.js';
+import { Is } from '../utils/basic.js';
+import { Filter as F } from '../utils/array.js';
+export class Container {
+    isDisposed = false;
+    parent;
+    scopes = [];
+    instances = [];
+    registrations = [];
+    tags;
+    providers = new Map();
+    aliases = new AliasMap();
+    injector;
+    onConstructHookList = [];
+    onDisposeHookList = [];
+    constructor(options = {}) {
+        this.injector = options.injector ?? new MetadataInjector();
+        this.parent = options.parent ?? new EmptyContainer();
+        this.tags = new Set(options.tags ?? []);
+    }
+    register(key, provider, { aliases = [] } = {}) {
+        this.validateContainer();
+        this.providers.set(key, provider);
+        this.aliases.setAliasesByKey(key, aliases);
+        return this;
+    }
+    resolve(target, { args = [], child = this, lazy } = {}) {
+        this.validateContainer();
+        if (Is.constructor(target)) {
+            return this.injector.resolve(this, target, { args, lazy });
+        }
+        const provider = this.providers.get(target);
+        return provider?.hasAccess({ invocationScope: child, providerScope: this, args })
+            ? provider.resolve(this, { args, lazy })
+            : this.parent.resolve(target, { args, child, lazy });
+    }
+    resolveByAlias(alias, { args = [], child = this, lazy, excludedKeys = [] } = {}) {
+        this.validateContainer();
+        const keys = [];
+        const deps = [];
+        for (const key of this.aliases.getKeysByAlias(alias).filter(F.exclude(excludedKeys))) {
+            const provider = this.findProviderByKeyOrFail(key);
+            if (!provider.hasAccess({ invocationScope: child, providerScope: this, args })) {
+                continue;
+            }
+            keys.push(key);
+            deps.push(provider.resolve(this, { args, lazy }));
+        }
+        const parentDeps = this.parent.resolveByAlias(alias, {
+            args,
+            child,
+            lazy,
+            excludedKeys: [...excludedKeys, ...keys],
+        });
+        return [...deps, ...parentDeps];
+    }
+    resolveOneByAlias(alias, { args = [], child = this, lazy } = {}) {
+        this.validateContainer();
+        const [key] = this.aliases.getKeysByAlias(alias);
+        const provider = key ? this.findProviderByKeyOrFail(key) : undefined;
+        return provider?.hasAccess({ invocationScope: child, providerScope: this, args })
+            ? provider.resolve(this, { args, lazy })
+            : this.parent.resolveOneByAlias(alias, { args, child, lazy });
+    }
+    createScope({ tags } = {}) {
+        this.validateContainer();
+        const scope = new Container({ injector: this.injector, parent: this, tags })
+            .addOnConstructHook(...this.onConstructHookList)
+            .addOnDisposeHook(...this.onDisposeHookList);
+        for (const registration of this.getRegistrations()) {
+            registration.applyTo(scope);
+        }
+        this.scopes.push(scope);
+        return scope;
+    }
+    dispose() {
+        this.validateContainer();
+        this.isDisposed = true;
+        while (this.onDisposeHookList.length) {
+            const onDispose = this.onDisposeHookList.shift();
+            onDispose(this);
+        }
+        this.parent.removeScope(this);
+        this.parent = new EmptyContainer();
+        for (const provider of this.providers.values()) {
+            provider.dispose();
+        }
+        this.providers.clear();
+        this.aliases.destroy();
+        this.instances = [];
+        this.registrations = [];
+        this.onConstructHookList.length = 0;
+    }
+    addRegistration(registration) {
+        this.registrations.push(registration);
+        registration.applyTo(this);
+        return this;
+    }
+    getRegistrations() {
+        return [...this.parent.getRegistrations(), ...this.registrations];
+    }
+    hasRegistration(key) {
+        return this.registrations.some((r) => r.getKeyOrFail() === key) || this.parent.hasRegistration(key);
+    }
+    addOnConstructHook(...hooks) {
+        this.onConstructHookList.push(...hooks);
+        return this;
+    }
+    addOnDisposeHook(...hooks) {
+        this.onDisposeHookList.push(...hooks);
+        return this;
+    }
+    addInstance(instance) {
+        this.instances.push(instance);
+        for (const onConstruct of this.onConstructHookList) {
+            onConstruct(instance, this);
+        }
+    }
+    getScopes() {
+        return [...this.scopes];
+    }
+    hasInstance(instance) {
+        return this.instances.includes(instance);
+    }
+    getScopeByInstanceOrFail(instance) {
+        this.validateContainer();
+        if (this.hasInstance(instance)) {
+            return this;
+        }
+        return this.parent.getScopeByInstanceOrFail(instance);
+    }
+    removeScope(child) {
+        this.scopes = this.scopes.filter((s) => s !== child);
+    }
+    useModule(module) {
+        module.applyTo(this);
+        return this;
+    }
+    getParent() {
+        return this.parent;
+    }
+    getInstances(cascade = false) {
+        if (!cascade) {
+            return [...this.instances];
+        }
+        return [...this.instances, ...this.scopes.flatMap((s) => s.getInstances(true))];
+    }
+    hasTag(tag) {
+        return this.tags.has(tag);
+    }
+    addTags(...tags) {
+        for (const tag of tags) {
+            this.tags.add(tag);
+        }
+    }
+    validateContainer() {
+        if (this.isDisposed) {
+            throw new ContainerDisposedError('Container is already disposed');
+        }
+    }
+    findProviderByKeyOrFail(key) {
+        if (!this.providers.has(key)) {
+            throw new DependencyNotFoundError(`Provider ${key.toString()} does not exist`);
+        }
+        return this.providers.get(key);
+    }
+}