@tstdl/base 0.86.0-beta2 → 0.86.0-beta3

package/container/container.js

@@ -1,428 +0,0 @@
-import { CircularBuffer } from '../data-structures/circular-buffer.js';
-import { MultiKeyMap } from '../data-structures/multi-key-map.js';
-import { reflectionRegistry } from '../reflection/index.js';
-import { mapAsync } from '../utils/async-iterable-helpers/map.js';
-import { toArrayAsync } from '../utils/async-iterable-helpers/to-array.js';
-import { ForwardRef } from '../utils/object/forward-ref.js';
-import { objectEntries } from '../utils/object/object.js';
-import { isDefined, isFunction, isPromise, isUndefined } from '../utils/type-guards.js';
-import { Subject } from 'rxjs';
-import { afterResolve } from './interfaces.js';
-import { isClassProvider, isFactoryProvider, isTokenProvider, isValueProvider } from './provider.js';
-import { ResolveChain } from './resolve-chain.js';
-import { ResolveError } from './resolve.error.js';
-import { getTokenName } from './token.js';
-import { isStubClass } from './utils.js';
-export const injectMetadataSymbol = Symbol('Inject metadata');
-export class Container {
-    registrationMap;
-    registrationSubject;
-    /** emits on new registration */
-    registration$;
-    /** all registrations */
-    get registrations() {
-        return this.registrationMap.values();
-    }
-    constructor() {
-        this.registrationMap = new Map();
-        this.registrationSubject = new Subject();
-        this.registration$ = this.registrationSubject.asObservable();
-    }
-    /**
-     * register a provider for a token
-     * @param token token to register
-     * @param provider provider used to resolve the token
-     * @param options registration options
-     */
-    register(token, provider, options = {}) {
-        if (isClassProvider(provider) && !isStubClass(provider.useClass)) {
-            const injectable = reflectionRegistry.getMetadata(provider.useClass)?.data.has(injectMetadataSymbol) ?? false;
-            if (!injectable) {
-                throw new Error(`${provider.useClass.name} is not injectable.`);
-            }
-        }
-        const registration = {
-            token,
-            provider,
-            options,
-            instances: new Map()
-        };
-        this.registrationMap.set(token, registration);
-        this.registrationSubject.next(registration);
-    }
-    /**
-     * register a provider for a token as a singleton. Alias for {@link register} with `singleton` lifecycle
-     * @param token token to register
-     * @param provider provider used to resolve the token
-     * @param options registration options
-     */
-    registerSingleton(token, provider, options) {
-        this.register(token, provider, { ...options, lifecycle: 'singleton' });
-    }
-    /**
-     * check if token has a registered provider
-     * @param token token check
-     */
-    hasRegistration(token) {
-        return this.registrationMap.has(token);
-    }
-    /**
-     * get registration
-     * @param token token to get registration for
-     */
-    getRegistration(token) {
-        const registration = this.registrationMap.get(token);
-        if (isUndefined(registration)) {
-            const tokenName = getTokenName(token);
-            throw new Error(`No provider for ${tokenName} registered.`);
-        }
-        return registration;
-    }
-    /**
-     * try to get registration
-     * @param token token to get registration for
-     */
-    tryGetRegistration(token) {
-        return this.registrationMap.get(token);
-    }
-    /**
-     * resolve a token
-     * @param token token to resolve
-     * @param argument argument used for resolving (overrides token and default arguments)
-     * @returns
-     */
-    resolve(token, argument, instances) {
-        const context = {
-            isAsync: false,
-            resolves: 0,
-            forwardRefQueue: new CircularBuffer(),
-            resolutions: [],
-            forwardRefs: new Set(),
-            providedInstances: new Map(instances),
-            instances: new MultiKeyMap(),
-            resolving: new MultiKeyMap()
-        };
-        return this._resolve(token, false, argument, context, ResolveChain.startWith(token), true);
-    }
-    /**
-     * resolve a token
-     * @param token token to resolve
-     * @param argument argument used for resolving (overrides token and default arguments)
-     * @returns
-     */
-    async resolveAsync(token, argument, instances) {
-        const context = {
-            isAsync: true,
-            resolves: 0,
-            forwardRefQueue: new CircularBuffer(),
-            resolutions: [],
-            forwardRefs: new Set(),
-            providedInstances: new Map(instances),
-            instances: new MultiKeyMap(),
-            resolving: new MultiKeyMap()
-        };
-        return this._resolveAsync(token, false, argument, context, ResolveChain.startWith(token), true);
-    }
-    // eslint-disable-next-line max-statements, max-lines-per-function, complexity
-    _resolve(token, optional, _argument, context, chain, isFirst) {
-        if ((chain.length > 750) || (++context.resolves > 750)) {
-            throw new ResolveError('Resolve stack overflow. This can happen on circular dependencies with transient lifecycles and self reference. Use scoped or singleton lifecycle instead or @forwardRef().', chain);
-        }
-        if (isUndefined(token)) {
-            throw new ResolveError('Token is undefined - this might be because of circular dependencies, use alias or forwardRef in this case.', chain);
-        }
-        if (context.providedInstances.has(token)) {
-            return context.providedInstances.get(token);
-        }
-        const registration = this.tryGetRegistration(token);
-        if (isUndefined(registration)) {
-            if (optional == true) {
-                return undefined;
-            }
-            throw new ResolveError(`No provider for ${getTokenName(token)} registered.`, chain);
-        }
-        const resolveArgument = _argument ?? registration.options.defaultArgument ?? registration.options.defaultArgumentProvider?.(this.getResolveContext(context, chain));
-        if (isPromise(resolveArgument)) {
-            throw new ResolveError(`Cannot evaluate async argument provider for token ${getTokenName(token)} in synchronous resolve, use resolveAsync instead.`, chain);
-        }
-        const argumentIdentity = (isDefined(registration.options.argumentIdentityProvider) && ((registration.options.lifecycle == 'resolution') || (registration.options.lifecycle == 'singleton')))
-            ? registration.options.argumentIdentityProvider(resolveArgument)
-            : resolveArgument;
-        if (isPromise(argumentIdentity)) {
-            throw new ResolveError(`Cannot evaluate async argument identity provider for token ${getTokenName(token)} in synchronous resolve, use resolveAsync instead.`, chain);
-        }
-        if ((registration.options.lifecycle == 'resolution') && context.instances.has([token, argumentIdentity])) {
-            return context.instances.get([token, argumentIdentity]);
-        }
-        if ((registration.options.lifecycle == 'singleton') && registration.instances.has(argumentIdentity)) {
-            return registration.instances.get(argumentIdentity);
-        }
-        if (context.resolving.has([token, argumentIdentity])) {
-            throw new ResolveError('Circular dependency to itself detected. Please check your registrations and providers. @forwardRef might be a solution.', chain);
-        }
-        context.resolving.set([token, argumentIdentity], true);
-        let instance;
-        if (isClassProvider(registration.provider)) {
-            const typeMetadata = reflectionRegistry.getMetadata(registration.provider.useClass);
-            if (isUndefined(typeMetadata) || !typeMetadata.data.has(injectMetadataSymbol)) {
-                throw new ResolveError(`${registration.provider.useClass.name} is not injectable.`, chain);
-            }
-            if (isStubClass(typeMetadata.constructor)) {
-                throw new ResolveError(`No provider for ${getTokenName(token)} registered.`, chain);
-            }
-            const parameters = (typeMetadata.parameters ?? []).map((metadata) => this.resolveInjection(token, context, typeMetadata, metadata, resolveArgument, chain));
-            instance = new typeMetadata.constructor(...parameters);
-            for (const [property, metadata] of typeMetadata.properties) {
-                if (!metadata.data.has(injectMetadataSymbol)) {
-                    continue;
-                }
-                instance[property] = this.resolveInjection(token, context, typeMetadata, metadata, resolveArgument, chain);
-            }
-        }
-        if (isValueProvider(registration.provider)) {
-            instance = registration.provider.useValue;
-        }
-        if (isTokenProvider(registration.provider)) {
-            const arg = resolveArgument ?? registration.provider.argument ?? registration.provider.argumentProvider?.();
-            const innerToken = registration.provider.useToken ?? registration.provider.useTokenProvider();
-            if (isPromise(arg)) {
-                throw new ResolveError(`Cannot evaluate async argument provider for token ${getTokenName(token)} in synchronous resolve, use resolveAsync instead.`, chain);
-            }
-            if (isPromise(innerToken)) {
-                throw new ResolveError(`Cannot evaluate async token provider for token ${getTokenName(token)} in synchronous resolve, use resolveAsync instead.`, chain);
-            }
-            instance = this._resolve(innerToken, false, arg, context, chain.addToken(innerToken), false);
-        }
-        if (isFactoryProvider(registration.provider)) {
-            try {
-                const result = registration.provider.useFactory(resolveArgument, this.getResolveContext(context, chain));
-                if (isPromise(result)) {
-                    throw new ResolveError(`Cannot evaluate async factory provider for token ${getTokenName(token)} in synchronous resolve, use resolveAsync instead.`, chain);
-                }
-                instance = result;
-            }
-            catch (error) {
-                throw new ResolveError('Error in factory.', chain, error);
-            }
-        }
-        if (registration.options.lifecycle == 'resolution') {
-            context.instances.set([token, argumentIdentity], instance);
-        }
-        if (registration.options.lifecycle == 'singleton') {
-            registration.instances.set(argumentIdentity, instance);
-        }
-        context.resolutions.push({ instance, registration });
-        context.resolving.delete([token, argumentIdentity]);
-        if (isFirst) {
-            for (const fn of context.forwardRefQueue.consume()) {
-                fn();
-            }
-            derefForwardRefs(context);
-            for (let i = context.resolutions.length - 1; i >= 0; i--) {
-                const resolution = context.resolutions[i];
-                if (isFunction(resolution.instance?.[afterResolve])) {
-                    const returnValue = resolution.instance[afterResolve]();
-                    if (isPromise(returnValue)) {
-                        throw new ResolveError(`Cannot execute async [afterResolve] for token ${getTokenName(token)} in synchronous resolve, use resolveAsync instead.`, chain);
-                    }
-                }
-                if (isDefined(resolution.registration.options.initializer)) {
-                    const returnValue = resolution.registration.options.initializer(resolution.instance);
-                    if (isPromise(returnValue)) {
-                        throw new ResolveError(`Cannot execute async initializer for token ${getTokenName(token)} in synchronous resolve, use resolveAsync instead.`, chain);
-                    }
-                }
-            }
-        }
-        return instance;
-    }
-    // eslint-disable-next-line max-statements, max-lines-per-function, complexity
-    async _resolveAsync(token, optional, _argument, context, chain, isFirst) {
-        if ((chain.length > 750) || (++context.resolves > 750)) {
-            throw new ResolveError('Resolve stack overflow. This can happen on circular dependencies with transient lifecycles and self reference. Use scoped or singleton lifecycle instead or @forwardRef().', chain);
-        }
-        if (isUndefined(token)) {
-            throw new ResolveError('Token is undefined - this might be because of circular dependencies, use alias or forwardRef in this case.', chain);
-        }
-        if (context.providedInstances.has(token)) {
-            return context.providedInstances.get(token);
-        }
-        const registration = this.tryGetRegistration(token);
-        if (isUndefined(registration)) {
-            if (optional == true) {
-                return undefined;
-            }
-            throw new ResolveError(`No provider for ${getTokenName(token)} registered.`, chain);
-        }
-        const resolveArgument = _argument ?? registration.options.defaultArgument ?? (await registration.options.defaultArgumentProvider?.(this.getResolveContext(context, chain)));
-        const argumentIdentity = (isDefined(registration.options.argumentIdentityProvider) && ((registration.options.lifecycle == 'resolution') || (registration.options.lifecycle == 'singleton')))
-            ? await registration.options.argumentIdentityProvider(resolveArgument)
-            : resolveArgument;
-        if ((registration.options.lifecycle == 'resolution') && context.instances.has([token, argumentIdentity])) {
-            return context.instances.get([token, argumentIdentity]);
-        }
-        if ((registration.options.lifecycle == 'singleton') && registration.instances.has(argumentIdentity)) {
-            return registration.instances.get(argumentIdentity);
-        }
-        if (context.resolving.has([token, argumentIdentity])) {
-            throw new ResolveError('Circular dependency to itself detected. Please check your registrations and providers. @forwardRef might be a solution.', chain);
-        }
-        context.resolving.set([token, argumentIdentity], true);
-        let instance;
-        if (isClassProvider(registration.provider)) {
-            const typeMetadata = reflectionRegistry.getMetadata(registration.provider.useClass);
-            if (isUndefined(typeMetadata) || !typeMetadata.data.has(injectMetadataSymbol)) {
-                throw new ResolveError(`${registration.provider.useClass.name} is not injectable.`, chain);
-            }
-            if (isStubClass(typeMetadata.constructor)) {
-                throw new ResolveError(`No provider for ${getTokenName(token)} registered.`, chain);
-            }
-            const boxedParameters = await toArrayAsync(mapAsync(typeMetadata.parameters ?? [], async (metadata) => this.resolveInjectionAsync(context, typeMetadata, metadata, resolveArgument, chain)));
-            const parameters = boxedParameters.map((box) => box.resolved);
-            instance = new typeMetadata.constructor(...parameters);
-            for (const [property, metadata] of typeMetadata.properties) {
-                if (!metadata.data.has(injectMetadataSymbol)) {
-                    continue;
-                }
-                instance[property] = (await this.resolveInjectionAsync(context, typeMetadata, metadata, resolveArgument, chain)).resolved;
-            }
-        }
-        if (isValueProvider(registration.provider)) {
-            instance = registration.provider.useValue;
-        }
-        if (isTokenProvider(registration.provider)) {
-            const arg = resolveArgument ?? registration.provider.argument ?? await registration.provider.argumentProvider?.();
-            const innerToken = registration.provider.useToken ?? await registration.provider.useTokenProvider();
-            instance = await this._resolveAsync(innerToken, false, arg, context, chain.addToken(innerToken), false);
-        }
-        if (isFactoryProvider(registration.provider)) {
-            try {
-                instance = await registration.provider.useFactory(resolveArgument, this.getResolveContext(context, chain));
-            }
-            catch (error) {
-                throw new ResolveError('Error in factory.', chain, error);
-            }
-        }
-        if (registration.options.lifecycle == 'resolution') {
-            context.instances.set([token, argumentIdentity], instance);
-        }
-        if (registration.options.lifecycle == 'singleton') {
-            registration.instances.set(argumentIdentity, instance);
-        }
-        context.resolutions.push({ instance, registration });
-        context.resolving.delete([token, argumentIdentity]);
-        if (isFirst) {
-            for (const fn of context.forwardRefQueue.consume()) {
-                await fn();
-            }
-            derefForwardRefs(context);
-            for (let i = context.resolutions.length - 1; i >= 0; i--) {
-                const resolution = context.resolutions[i];
-                if (isFunction(resolution.instance?.[afterResolve])) {
-                    await resolution.instance[afterResolve]();
-                }
-                if (isDefined(resolution.registration.options.initializer)) {
-                    await resolution.registration.options.initializer(resolution.instance);
-                }
-            }
-        }
-        return instance;
-    }
-    resolveInjection(token, context, typeMetadata, metadata, resolveArgument, chain) {
-        const getChain = (metadata.metadataType == 'constructor-parameter')
-            ? (injectToken) => chain.addParameter(typeMetadata.constructor, metadata.index, injectToken).addToken(injectToken)
-            : (injectToken) => chain.addProperty(typeMetadata.constructor, metadata.key, injectToken).addToken(injectToken);
-        const injectMetadata = metadata.data.tryGet(injectMetadataSymbol) ?? {};
-        const injectToken = (injectMetadata.injectToken ?? metadata.type);
-        if (isDefined(injectMetadata.injectArgumentMapper) && (!this.hasRegistration(injectToken) || isDefined(resolveArgument) || isUndefined(injectToken))) {
-            const mapped = injectMetadata.injectArgumentMapper(resolveArgument);
-            if (isPromise(mapped)) {
-                throw new ResolveError(`Cannot evaluate async argument mapper for token ${getTokenName(token)} in synchronous resolve, use resolveAsync instead.`, getChain(injectToken));
-            }
-            return mapped;
-        }
-        const parameterResolveArgument = injectMetadata.forwardArgumentMapper?.(resolveArgument) ?? injectMetadata.resolveArgumentProvider?.(this.getResolveContext(context, getChain(injectToken)));
-        if (isPromise(parameterResolveArgument)) {
-            throw new ResolveError(`Cannot evaluate async argument provider for token ${getTokenName(token)} in synchronous resolve, use resolveAsync instead.`, getChain(injectToken));
-        }
-        if (isDefined(injectMetadata.forwardRefToken)) {
-            const forwardRef = ForwardRef.create();
-            const forwardRefToken = injectMetadata.forwardRefToken;
-            context.forwardRefQueue.add(() => {
-                const forwardToken = isFunction(forwardRefToken) ? forwardRefToken() : forwardRefToken;
-                if (isDefined(injectMetadata.mapper)) {
-                    throw new ResolveError('Cannot use inject mapper with forwardRef.', getChain(forwardToken));
-                }
-                const resolved = this._resolve(forwardToken, injectMetadata.optional, parameterResolveArgument, context, getChain(forwardToken), false);
-                ForwardRef.setRef(forwardRef, resolved);
-            });
-            context.forwardRefs.add(forwardRef);
-            return forwardRef;
-        }
-        const resolved = this._resolve(injectToken, injectMetadata.optional, parameterResolveArgument, context, getChain(injectToken), false);
-        return isDefined(injectMetadata.mapper) ? injectMetadata.mapper(resolved) : resolved;
-    }
-    async resolveInjectionAsync(context, typeMetadata, metadata, resolveArgument, chain) {
-        const getChain = (metadata.metadataType == 'constructor-parameter')
-            ? (injectToken) => chain.addParameter(typeMetadata.constructor, metadata.index, injectToken).addToken(injectToken)
-            : (injectToken) => chain.addProperty(typeMetadata.constructor, metadata.key, injectToken).addToken(injectToken);
-        const injectMetadata = metadata.data.tryGet(injectMetadataSymbol) ?? {};
-        const injectToken = (injectMetadata.injectToken ?? metadata.type);
-        if (isDefined(injectMetadata.injectArgumentMapper) && (!this.hasRegistration(injectToken) || isDefined(resolveArgument) || isUndefined(injectToken))) {
-            return { resolved: injectMetadata.injectArgumentMapper(resolveArgument) };
-        }
-        const parameterResolveArgument = await (injectMetadata.forwardArgumentMapper?.(resolveArgument) ?? injectMetadata.resolveArgumentProvider?.(this.getResolveContext(context, getChain(injectToken))));
-        if (isDefined(injectMetadata.forwardRefToken)) {
-            const forwardRef = ForwardRef.create();
-            const forwardRefToken = injectMetadata.forwardRefToken;
-            context.forwardRefQueue.add(async () => {
-                const forwardToken = isFunction(forwardRefToken) ? forwardRefToken() : forwardRefToken;
-                if (isDefined(injectMetadata.mapper)) {
-                    throw new ResolveError('Cannot use inject mapper with forwardRef.', getChain(forwardToken));
-                }
-                const resolved = await this._resolveAsync(forwardToken, injectMetadata.optional, parameterResolveArgument, context, getChain(forwardToken), false);
-                ForwardRef.setRef(forwardRef, resolved);
-            });
-            context.forwardRefs.add(forwardRef);
-            return { resolved: forwardRef };
-        }
-        const resolved = await this._resolveAsync(injectToken, injectMetadata.optional, parameterResolveArgument, context, getChain(injectToken), false);
-        return { resolved: isDefined(injectMetadata.mapper) ? injectMetadata.mapper(resolved) : resolved };
-    }
-    getResolveContext(resolveContext, chain) {
-        const context = {
-            isAsync: resolveContext.isAsync,
-            resolve: (token, argument, instances) => {
-                this.addInstancesToResolveContext(instances, resolveContext);
-                return this._resolve(token, false, argument, resolveContext, chain.addToken(token), false);
-            },
-            resolveAsync: async (token, argument, instances) => {
-                this.addInstancesToResolveContext(instances, resolveContext);
-                return this._resolveAsync(token, false, argument, resolveContext, chain.addToken(token), false);
-            }
-        };
-        return context;
-    }
-    addInstancesToResolveContext(instances, resolveContext) {
-        if (isUndefined(instances)) {
-            return;
-        }
-        for (const [instanceToken, instance] of instances) {
-            resolveContext.providedInstances.set(instanceToken, instance);
-        }
-    }
-}
-function derefForwardRefs(context) {
-    for (const resolution of context.resolutions) {
-        if (!(typeof resolution.instance == 'object')) {
-            continue;
-        }
-        for (const [key, value] of objectEntries(resolution.instance)) {
-            if (!context.forwardRefs.has(value)) {
-                continue;
-            }
-            resolution.instance[key] = ForwardRef.deref(value);
-        }
-    }
-}
-export const container = new Container();

package/container/decorators.js

@@ -1,126 +0,0 @@
-import { createClassDecorator, createDecorator } from '../reflection/index.js';
-import { toArray } from '../utils/array/array.js';
-import { isDefined, isFunction } from '../utils/type-guards.js';
-import { container, injectMetadataSymbol } from './container.js';
-/**
- * Helper decorator to replace a class definition with an other
- * can be used for example to type external classes with the {@link Injectable} interface
- * @param constructor class to replace with
- */
-export function replaceClass(constructor) {
-    return createClassDecorator({ handler: () => constructor });
-}
-/**
- * registers the class in the global container. Decorated class is not modified in any way
- * @param options registration options
- */
-export function injectable(options = {}) {
-    return createClassDecorator({
-        data: { [injectMetadataSymbol]: {} },
-        mergeData: true,
-        handler: (data) => {
-            const { alias: aliases, provider, ...registrationOptions } = options;
-            const targetProvider = provider ?? { useClass: data.constructor };
-            container.register(data.constructor, targetProvider, registrationOptions);
-            if (isDefined(aliases)) {
-                for (const alias of toArray(aliases)) {
-                    container.register(alias, { useToken: data.constructor }, registrationOptions);
-                }
-            }
-        }
-    });
-}
-/**
- * registers the class in the global container with singleton lifecycle. Decorated class is not modified in any way
- * @param options registration options
- */
-export function singleton(options = {}) {
-    return injectable({ ...options, lifecycle: 'singleton' });
-}
-/**
- * registers the class in the global container with scoped lifecycle. Decorated class is not modified in any way
- * @param options registration options
- */
-export function scoped(lifecycle, options = {}) {
-    return injectable({ ...options, lifecycle });
-}
-/**
- * sets the token used to resolve the parameter
- * @param token token used for resolving
- * @param argument resolve argument
- * @param mapperOrKey map the resolved value. If {@link PropertyKey} is provided, that property of the resolved value will be injected
- */
-export function inject(token, argument, mapperOrKey) {
-    const injectMetadata = {};
-    if (isDefined(token)) {
-        injectMetadata.injectToken = token;
-    }
-    if (isDefined(argument)) {
-        injectMetadata.resolveArgumentProvider = () => argument;
-    }
-    if (isDefined(mapperOrKey)) {
-        injectMetadata.mapper = isFunction(mapperOrKey) ? mapperOrKey : ((value) => value[mapperOrKey]);
-    }
-    return createInjectDecorator(injectMetadata);
-}
-/**
- * sets the argument used for resolving the parameter
- * @param argument
- */
-export function resolveArg(argument) {
-    return resolveArgProvider(() => argument);
-}
-/**
- * sets the argument provider used for resolving the parameter
- * @param argumentProvider
- */
-export function resolveArgProvider(argumentProvider) {
-    return createInjectDecorator({ resolveArgumentProvider: argumentProvider });
-}
-/**
- * injects the argument used for resolving the class instead of resolving the parameter
- * @param argument
- * @param mapperOrKey map the resolved value. If {@link PropertyKey} is provided, that property of the resolved value will be injected
- */
-export function injectArg(mapperOrKey) {
-    return createInjectDecorator({
-        injectArgumentMapper: isFunction(mapperOrKey)
-            ? mapperOrKey
-            : isDefined(mapperOrKey)
-                ? ((value) => value[mapperOrKey])
-                : ((value) => value)
-    });
-}
-export function forwardArg(mapper = (value) => value) {
-    return createInjectDecorator({ forwardArgumentMapper: mapper });
-}
-/**
- * marks the argument as optional
- * @param argument
- */
-export function optional() {
-    return createInjectDecorator({ optional: true });
-}
-/**
- * resolve using ForwardRef to handle circular dependencies. Resolve logic derefs all ForwardRefs which are direct properties of resolved instances automatically
- * @param token token to resolve
- * @param argument resolve argument
- */
-export function forwardRef(token, argument) {
-    const injectMetadata = {
-        forwardRefToken: token
-    };
-    if (isDefined(argument)) {
-        injectMetadata.resolveArgumentProvider = () => argument;
-    }
-    return createInjectDecorator(injectMetadata);
-}
-function createInjectDecorator(metadata) {
-    return createDecorator({
-        property: true,
-        accessor: true,
-        constructorParameter: true,
-        data: { [injectMetadataSymbol]: metadata },
-        mergeData: true
-    });
-}

package/container/interfaces.js

@@ -1,2 +0,0 @@
-export const resolveArgumentType = Symbol('resolveArgumentType');
-export const afterResolve = Symbol('after resolve');

package/container/provider.js

@@ -1,29 +0,0 @@
-import { hasOwnProperty } from '../utils/object/object.js';
-import { isObject } from '../utils/type-guards.js';
-export function classProvider(constructor) {
-    return { useClass: constructor };
-}
-export function valueProvider(value) {
-    return { useValue: value };
-}
-export function tokenProvider(token, argument) {
-    return { useToken: token, argument };
-}
-export function factoryProvider(factory) {
-    return { useFactory: factory };
-}
-export function isClassProvider(value) {
-    return isObject(value) && hasOwnProperty(value, 'useClass');
-}
-export function isValueProvider(value) {
-    return isObject(value) && hasOwnProperty(value, 'useValue');
-}
-export function isTokenProvider(value) {
-    return isObject(value) && (hasOwnProperty(value, 'useToken') || hasOwnProperty(value, 'useTokenProvider'));
-}
-export function isFactoryProvider(value) {
-    return isObject(value) && hasOwnProperty(value, 'useFactory');
-}
-export function isProvider(value) {
-    return isObject(value) && (isClassProvider(value) || isValueProvider(value) || isTokenProvider(value) || isFactoryProvider(value));
-}

package/container/resolve-chain.js

@@ -1,80 +0,0 @@
-import { reflectionRegistry } from '../reflection/index.js';
-import { assertDefinedPass, isDefined } from '../utils/type-guards.js';
-import { getTokenName } from './token.js';
-export class ResolveChain {
-    nodes;
-    get length() {
-        return this.nodes.length;
-    }
-    constructor(nodes) {
-        this.nodes = nodes ?? [];
-    }
-    static startWith(token) {
-        const chain = new ResolveChain();
-        return chain.addToken(token);
-    }
-    addToken(token) {
-        const node = { type: 'token', token };
-        return new ResolveChain([...this.nodes, node]);
-    }
-    addParameter(constructor, index, token) {
-        const node = { type: 'parameter', constructor, index, token };
-        return new ResolveChain([...this.nodes, node]);
-    }
-    addProperty(constructor, property, token) {
-        const node = { type: 'property', constructor, property, token };
-        return new ResolveChain([...this.nodes, node]);
-    }
-    format(truncate) {
-        let chainString = '';
-        const chain = isDefined(truncate) ? this.truncate(truncate) : this;
-        if (chain.length < this.length) {
-            chainString += '\n       [...]';
-        }
-        for (const node of chain.nodes) {
-            const tokenName = getTokenName(node.token);
-            switch (node.type) {
-                case 'token':
-                    chainString += `\n    -> ${tokenName}`;
-                    break;
-                case 'parameter':
-                    const metadata = reflectionRegistry.getMetadata(node.constructor);
-                    const prefix = '_, '.repeat(node.index);
-                    const suffix = ', _'.repeat(assertDefinedPass(metadata?.parameters, 'missing parameters metadata').length - node.index - 1);
-                    chainString += `(${prefix}${tokenName}${suffix})`;
-                    break;
-                case 'property':
-                    const constructorName = getTokenName(node.constructor);
-                    const key = getPropertyKeyString(node.property);
-                    chainString += `\n    -> ${constructorName}[${key}]: ${tokenName}`;
-                    break;
-                default:
-                    throw new Error(`unknown chain node type ${node.type}`);
-            }
-        }
-        return chainString;
-    }
-    truncate(tokenCount) {
-        const truncatedChain = [];
-        let counter = 0;
-        for (let i = this.nodes.length - 1; (i >= 0) && (counter < tokenCount); i--) {
-            const node = this.nodes[i];
-            truncatedChain.unshift(node);
-            if (node.type == 'token') {
-                counter++;
-            }
-        }
-        return new ResolveChain(truncatedChain);
-    }
-}
-function getPropertyKeyString(key) {
-    switch (typeof key) {
-        case 'number':
-        case 'symbol':
-            return key.toString();
-        case 'string':
-            return `'${key}'`;
-        default:
-            throw new Error(`unsupported key type ${typeof key}`);
-    }
-}

package/container/resolve.error.js

@@ -1,11 +0,0 @@
-import { CustomError } from '../error/custom.error.js';
-import { isDefined } from '../utils/type-guards.js';
-export class ResolveError extends CustomError {
-    constructor(message, chain, cause) {
-        const causeMessage = isDefined(cause) ? `\n  cause: ${cause.message}` : '';
-        super({
-            message: `${message}${causeMessage}\n  chain: ${chain.format(15)}`,
-            cause
-        });
-    }
-}