@tstdl/base 0.86.0-beta1 → 0.86.0-beta10

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

package/container/type-info.js

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

package/container/types.js

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

package/container/utils.js

@@ -1,20 +0,0 @@
-import { isString } from '../utils/type-guards.js';
-import { container } from './container.js';
-const isStubClassSymbol = Symbol('Stub class');
-export function stubClass(forClass) {
-    const forClassName = isString(forClass) ? forClass : forClass.name;
-    const stubName = `${forClassName}Stub`;
-    const stub = {
-        [stubName]: class {
-            constructor() {
-                throw new Error(`Stub class for ${forClassName} not instantiable.`);
-            }
-        }
-    }[stubName];
-    stub[isStubClassSymbol] = true;
-    container.register(stub, { useClass: stub });
-    return stub;
-}
-export function isStubClass(target) {
-    return target[isStubClassSymbol] === true;
-}

package/data-structures/set.js

@@ -1,56 +0,0 @@
-import { Collection } from './collection.js';
-export class Set extends Collection {
-    backingSet;
-    [Symbol.toStringTag] = 'Set';
-    constructor(items) {
-        super();
-        this.backingSet = new globalThis.Set(items);
-        this.updateSize();
-    }
-    includes(item) {
-        return this.has(item);
-    }
-    add(item) {
-        this.backingSet.add(item);
-        this.updateSize();
-        return this;
-    }
-    addMany(items) {
-        for (const item of items) {
-            this.backingSet.add(item);
-        }
-        this.updateSize();
-    }
-    clone() {
-        return new Set(this);
-    }
-    items() {
-        return this.backingSet.values();
-    }
-    delete(item) {
-        const result = this.backingSet.delete(item);
-        this.updateSize();
-        return result;
-    }
-    forEach(callbackfn, thisArg) {
-        this.backingSet.forEach(callbackfn, thisArg);
-    }
-    has(item) {
-        return this.backingSet.has(item);
-    }
-    entries() {
-        return this.backingSet.entries();
-    }
-    keys() {
-        return this.backingSet.keys();
-    }
-    values() {
-        return this.backingSet.values();
-    }
-    _clear() {
-        this.backingSet.clear();
-    }
-    updateSize() {
-        this.setSize(this.backingSet.size);
-    }
-}