@tstdl/base 0.86.0-beta9 → 0.86.0

package/_container/container.js

@@ -1,443 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var container_exports = {};
-__export(container_exports, {
-  Container: () => Container,
-  container: () => container,
-  injectMetadataSymbol: () => injectMetadataSymbol
-});
-module.exports = __toCommonJS(container_exports);
-var import_circular_buffer = require("../data-structures/circular-buffer.js");
-var import_multi_key_map = require("../data-structures/multi-key-map.js");
-var import_reflection = require("../reflection/index.js");
-var import_map = require("../utils/async-iterable-helpers/map.js");
-var import_to_array = require("../utils/async-iterable-helpers/to-array.js");
-var import_forward_ref = require("../utils/object/forward-ref.js");
-var import_object = require("../utils/object/object.js");
-var import_type_guards = require("../utils/type-guards.js");
-var import_rxjs = require("rxjs");
-var import_interfaces = require("./interfaces.js");
-var import_provider = require("./provider.js");
-var import_resolve_chain = require("./resolve-chain.js");
-var import_resolve_error = require("./resolve.error.js");
-var import_token = require("./token.js");
-var import_utils = require("./utils.js");
-const injectMetadataSymbol = Symbol("Inject metadata");
-class Container {
-  registrationMap;
-  registrationSubject;
-  /** emits on new registration */
-  registration$;
-  /** all registrations */
-  get registrations() {
-    return this.registrationMap.values();
-  }
-  constructor() {
-    this.registrationMap = /* @__PURE__ */ new Map();
-    this.registrationSubject = new import_rxjs.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 ((0, import_provider.isClassProvider)(provider) && !(0, import_utils.isStubClass)(provider.useClass)) {
-      const injectable = import_reflection.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: /* @__PURE__ */ 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 ((0, import_type_guards.isUndefined)(registration)) {
-      const tokenName = (0, import_token.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 import_circular_buffer.CircularBuffer(),
-      resolutions: [],
-      forwardRefs: /* @__PURE__ */ new Set(),
-      providedInstances: new Map(instances),
-      instances: new import_multi_key_map.MultiKeyMap(),
-      resolving: new import_multi_key_map.MultiKeyMap()
-    };
-    return this._resolve(token, false, argument, context, import_resolve_chain.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 import_circular_buffer.CircularBuffer(),
-      resolutions: [],
-      forwardRefs: /* @__PURE__ */ new Set(),
-      providedInstances: new Map(instances),
-      instances: new import_multi_key_map.MultiKeyMap(),
-      resolving: new import_multi_key_map.MultiKeyMap()
-    };
-    return this._resolveAsync(token, false, argument, context, import_resolve_chain.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 import_resolve_error.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 ((0, import_type_guards.isUndefined)(token)) {
-      throw new import_resolve_error.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 ((0, import_type_guards.isUndefined)(registration)) {
-      if (optional == true) {
-        return void 0;
-      }
-      throw new import_resolve_error.ResolveError(`No provider for ${(0, import_token.getTokenName)(token)} registered.`, chain);
-    }
-    const resolveArgument = _argument ?? registration.options.defaultArgument ?? registration.options.defaultArgumentProvider?.(this.getResolveContext(context, chain));
-    if ((0, import_type_guards.isPromise)(resolveArgument)) {
-      throw new import_resolve_error.ResolveError(`Cannot evaluate async argument provider for token ${(0, import_token.getTokenName)(token)} in synchronous resolve, use resolveAsync instead.`, chain);
-    }
-    const argumentIdentity = (0, import_type_guards.isDefined)(registration.options.argumentIdentityProvider) && (registration.options.lifecycle == "resolution" || registration.options.lifecycle == "singleton") ? registration.options.argumentIdentityProvider(resolveArgument) : resolveArgument;
-    if ((0, import_type_guards.isPromise)(argumentIdentity)) {
-      throw new import_resolve_error.ResolveError(`Cannot evaluate async argument identity provider for token ${(0, import_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 import_resolve_error.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 ((0, import_provider.isClassProvider)(registration.provider)) {
-      const typeMetadata = import_reflection.reflectionRegistry.getMetadata(registration.provider.useClass);
-      if ((0, import_type_guards.isUndefined)(typeMetadata) || !typeMetadata.data.has(injectMetadataSymbol)) {
-        throw new import_resolve_error.ResolveError(`${registration.provider.useClass.name} is not injectable.`, chain);
-      }
-      if ((0, import_utils.isStubClass)(typeMetadata.constructor)) {
-        throw new import_resolve_error.ResolveError(`No provider for ${(0, import_token.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 ((0, import_provider.isValueProvider)(registration.provider)) {
-      instance = registration.provider.useValue;
-    }
-    if ((0, import_provider.isTokenProvider)(registration.provider)) {
-      const arg = resolveArgument ?? registration.provider.argument ?? registration.provider.argumentProvider?.();
-      const innerToken = registration.provider.useToken ?? registration.provider.useTokenProvider();
-      if ((0, import_type_guards.isPromise)(arg)) {
-        throw new import_resolve_error.ResolveError(`Cannot evaluate async argument provider for token ${(0, import_token.getTokenName)(token)} in synchronous resolve, use resolveAsync instead.`, chain);
-      }
-      if ((0, import_type_guards.isPromise)(innerToken)) {
-        throw new import_resolve_error.ResolveError(`Cannot evaluate async token provider for token ${(0, import_token.getTokenName)(token)} in synchronous resolve, use resolveAsync instead.`, chain);
-      }
-      instance = this._resolve(innerToken, false, arg, context, chain.addToken(innerToken), false);
-    }
-    if ((0, import_provider.isFactoryProvider)(registration.provider)) {
-      try {
-        const result = registration.provider.useFactory(resolveArgument, this.getResolveContext(context, chain));
-        if ((0, import_type_guards.isPromise)(result)) {
-          throw new import_resolve_error.ResolveError(`Cannot evaluate async factory provider for token ${(0, import_token.getTokenName)(token)} in synchronous resolve, use resolveAsync instead.`, chain);
-        }
-        instance = result;
-      } catch (error) {
-        throw new import_resolve_error.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 ((0, import_type_guards.isFunction)(resolution.instance?.[import_interfaces.afterResolve])) {
-          const returnValue = resolution.instance[import_interfaces.afterResolve]();
-          if ((0, import_type_guards.isPromise)(returnValue)) {
-            throw new import_resolve_error.ResolveError(`Cannot execute async [afterResolve] for token ${(0, import_token.getTokenName)(token)} in synchronous resolve, use resolveAsync instead.`, chain);
-          }
-        }
-        if ((0, import_type_guards.isDefined)(resolution.registration.options.initializer)) {
-          const returnValue = resolution.registration.options.initializer(resolution.instance);
-          if ((0, import_type_guards.isPromise)(returnValue)) {
-            throw new import_resolve_error.ResolveError(`Cannot execute async initializer for token ${(0, import_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 import_resolve_error.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 ((0, import_type_guards.isUndefined)(token)) {
-      throw new import_resolve_error.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 ((0, import_type_guards.isUndefined)(registration)) {
-      if (optional == true) {
-        return void 0;
-      }
-      throw new import_resolve_error.ResolveError(`No provider for ${(0, import_token.getTokenName)(token)} registered.`, chain);
-    }
-    const resolveArgument = _argument ?? registration.options.defaultArgument ?? await registration.options.defaultArgumentProvider?.(this.getResolveContext(context, chain));
-    const argumentIdentity = (0, import_type_guards.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 import_resolve_error.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 ((0, import_provider.isClassProvider)(registration.provider)) {
-      const typeMetadata = import_reflection.reflectionRegistry.getMetadata(registration.provider.useClass);
-      if ((0, import_type_guards.isUndefined)(typeMetadata) || !typeMetadata.data.has(injectMetadataSymbol)) {
-        throw new import_resolve_error.ResolveError(`${registration.provider.useClass.name} is not injectable.`, chain);
-      }
-      if ((0, import_utils.isStubClass)(typeMetadata.constructor)) {
-        throw new import_resolve_error.ResolveError(`No provider for ${(0, import_token.getTokenName)(token)} registered.`, chain);
-      }
-      const boxedParameters = await (0, import_to_array.toArrayAsync)((0, import_map.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 ((0, import_provider.isValueProvider)(registration.provider)) {
-      instance = registration.provider.useValue;
-    }
-    if ((0, import_provider.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 ((0, import_provider.isFactoryProvider)(registration.provider)) {
-      try {
-        instance = await registration.provider.useFactory(resolveArgument, this.getResolveContext(context, chain));
-      } catch (error) {
-        throw new import_resolve_error.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 ((0, import_type_guards.isFunction)(resolution.instance?.[import_interfaces.afterResolve])) {
-          await resolution.instance[import_interfaces.afterResolve]();
-        }
-        if ((0, import_type_guards.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" ? (injectToken2) => chain.addParameter(typeMetadata.constructor, metadata.index, injectToken2).addToken(injectToken2) : (injectToken2) => chain.addProperty(typeMetadata.constructor, metadata.key, injectToken2).addToken(injectToken2);
-    const injectMetadata = metadata.data.tryGet(injectMetadataSymbol) ?? {};
-    const injectToken = injectMetadata.injectToken ?? metadata.type;
-    if ((0, import_type_guards.isDefined)(injectMetadata.injectArgumentMapper) && (!this.hasRegistration(injectToken) || (0, import_type_guards.isDefined)(resolveArgument) || (0, import_type_guards.isUndefined)(injectToken))) {
-      const mapped = injectMetadata.injectArgumentMapper(resolveArgument);
-      if ((0, import_type_guards.isPromise)(mapped)) {
-        throw new import_resolve_error.ResolveError(`Cannot evaluate async argument mapper for token ${(0, import_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 ((0, import_type_guards.isPromise)(parameterResolveArgument)) {
-      throw new import_resolve_error.ResolveError(`Cannot evaluate async argument provider for token ${(0, import_token.getTokenName)(token)} in synchronous resolve, use resolveAsync instead.`, getChain(injectToken));
-    }
-    if ((0, import_type_guards.isDefined)(injectMetadata.forwardRefToken)) {
-      const forwardRef = import_forward_ref.ForwardRef.create();
-      const forwardRefToken = injectMetadata.forwardRefToken;
-      context.forwardRefQueue.add(() => {
-        const forwardToken = (0, import_type_guards.isFunction)(forwardRefToken) ? forwardRefToken() : forwardRefToken;
-        if ((0, import_type_guards.isDefined)(injectMetadata.mapper)) {
-          throw new import_resolve_error.ResolveError("Cannot use inject mapper with forwardRef.", getChain(forwardToken));
-        }
-        const resolved2 = this._resolve(forwardToken, injectMetadata.optional, parameterResolveArgument, context, getChain(forwardToken), false);
-        import_forward_ref.ForwardRef.setRef(forwardRef, resolved2);
-      });
-      context.forwardRefs.add(forwardRef);
-      return forwardRef;
-    }
-    const resolved = this._resolve(injectToken, injectMetadata.optional, parameterResolveArgument, context, getChain(injectToken), false);
-    return (0, import_type_guards.isDefined)(injectMetadata.mapper) ? injectMetadata.mapper(resolved) : resolved;
-  }
-  async resolveInjectionAsync(context, typeMetadata, metadata, resolveArgument, chain) {
-    const getChain = metadata.metadataType == "constructor-parameter" ? (injectToken2) => chain.addParameter(typeMetadata.constructor, metadata.index, injectToken2).addToken(injectToken2) : (injectToken2) => chain.addProperty(typeMetadata.constructor, metadata.key, injectToken2).addToken(injectToken2);
-    const injectMetadata = metadata.data.tryGet(injectMetadataSymbol) ?? {};
-    const injectToken = injectMetadata.injectToken ?? metadata.type;
-    if ((0, import_type_guards.isDefined)(injectMetadata.injectArgumentMapper) && (!this.hasRegistration(injectToken) || (0, import_type_guards.isDefined)(resolveArgument) || (0, import_type_guards.isUndefined)(injectToken))) {
-      return { resolved: injectMetadata.injectArgumentMapper(resolveArgument) };
-    }
-    const parameterResolveArgument = await (injectMetadata.forwardArgumentMapper?.(resolveArgument) ?? injectMetadata.resolveArgumentProvider?.(this.getResolveContext(context, getChain(injectToken))));
-    if ((0, import_type_guards.isDefined)(injectMetadata.forwardRefToken)) {
-      const forwardRef = import_forward_ref.ForwardRef.create();
-      const forwardRefToken = injectMetadata.forwardRefToken;
-      context.forwardRefQueue.add(async () => {
-        const forwardToken = (0, import_type_guards.isFunction)(forwardRefToken) ? forwardRefToken() : forwardRefToken;
-        if ((0, import_type_guards.isDefined)(injectMetadata.mapper)) {
-          throw new import_resolve_error.ResolveError("Cannot use inject mapper with forwardRef.", getChain(forwardToken));
-        }
-        const resolved2 = await this._resolveAsync(forwardToken, injectMetadata.optional, parameterResolveArgument, context, getChain(forwardToken), false);
-        import_forward_ref.ForwardRef.setRef(forwardRef, resolved2);
-      });
-      context.forwardRefs.add(forwardRef);
-      return { resolved: forwardRef };
-    }
-    const resolved = await this._resolveAsync(injectToken, injectMetadata.optional, parameterResolveArgument, context, getChain(injectToken), false);
-    return { resolved: (0, import_type_guards.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 ((0, import_type_guards.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 (0, import_object.objectEntries)(resolution.instance)) {
-      if (!context.forwardRefs.has(value)) {
-        continue;
-      }
-      resolution.instance[key] = import_forward_ref.ForwardRef.deref(value);
-    }
-  }
-}
-const container = new Container();

package/_container/decorators.d.ts

@@ -1,76 +0,0 @@
-import type { Decorator } from '../reflection/index.js';
-import type { Constructor, OneOrMany, Simplify, TypedOmit } from '../types.js';
-import type { RegistrationOptions } from './container.js';
-import type { Provider } from './provider.js';
-import type { InjectionToken } from './token.js';
-import type { ArgumentProvider, ForwardRefInjectionToken, Mapper } from './types.js';
-type InjectDecorator = Decorator<'property' | 'accessor' | 'constructorParameter'>;
-export type InjectableOptions<T, A> = RegistrationOptions<T> & {
-    /** aliases (tokens) for the class. Useful for example for circular dependencies when you can't use the class itself as a token */
-    alias?: OneOrMany<InjectionToken>;
-    /** custom provider. Useful for example if initialization is required */
-    provider?: Provider<T, A>;
-};
-export type InjectableOptionsWithoutLifecycle<T, A> = Simplify<TypedOmit<InjectableOptions<T, A>, 'lifecycle'>>;
-/**
- * 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 declare function replaceClass<T>(constructor: Constructor<T>): ClassDecorator;
-/**
- * registers the class in the global container. Decorated class is not modified in any way
- * @param options registration options
- */
-export declare function injectable<T = any, A = any>(options?: InjectableOptions<T, A>): ClassDecorator;
-/**
- * registers the class in the global container with singleton lifecycle. Decorated class is not modified in any way
- * @param options registration options
- */
-export declare function singleton<T = any, A = any>(options?: InjectableOptionsWithoutLifecycle<T, A>): ClassDecorator;
-/**
- * registers the class in the global container with scoped lifecycle. Decorated class is not modified in any way
- * @param options registration options
- */
-export declare function scoped<T = any, A = any>(lifecycle: 'resolution', options?: InjectableOptionsWithoutLifecycle<T, A>): ClassDecorator;
-/**
- * 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 declare function inject<T, A>(token?: InjectionToken<T, A>, argument?: A, mapperOrKey?: Mapper<T> | keyof T): InjectDecorator;
-/**
- * sets the argument used for resolving the parameter
- * @param argument
- */
-export declare function resolveArg<T>(argument: T): InjectDecorator;
-/**
- * sets the argument provider used for resolving the parameter
- * @param argumentProvider
- */
-export declare function resolveArgProvider<T>(argumentProvider: ArgumentProvider<T>): InjectDecorator;
-/**
- * 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 declare function injectArg<T>(mapperOrKey?: Mapper<T> | keyof T): InjectDecorator;
-/**
- * sets the argument used for resolving the decorated parameter to the the argument provided for parent resolve
- * @param mapper map the argument (for example to select a property instead of forwarding the whole object)
- */
-export declare function forwardArg(): InjectDecorator;
-export declare function forwardArg<T, U>(mapper: Mapper<T, U>): InjectDecorator;
-/**
- * marks the argument as optional
- * @param argument
- */
-export declare function optional(): InjectDecorator;
-/**
- * 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 declare function forwardRef<T extends object, A>(token: ForwardRefInjectionToken<T>, argument?: A): InjectDecorator;
-export {};

package/_container/decorators.js

@@ -1,110 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var decorators_exports = {};
-__export(decorators_exports, {
-  forwardArg: () => forwardArg,
-  forwardRef: () => forwardRef,
-  inject: () => inject,
-  injectArg: () => injectArg,
-  injectable: () => injectable,
-  optional: () => optional,
-  replaceClass: () => replaceClass,
-  resolveArg: () => resolveArg,
-  resolveArgProvider: () => resolveArgProvider,
-  scoped: () => scoped,
-  singleton: () => singleton
-});
-module.exports = __toCommonJS(decorators_exports);
-var import_reflection = require("../reflection/index.js");
-var import_array = require("../utils/array/array.js");
-var import_type_guards = require("../utils/type-guards.js");
-var import_container = require("./container.js");
-function replaceClass(constructor) {
-  return (0, import_reflection.createClassDecorator)({ handler: () => constructor });
-}
-function injectable(options = {}) {
-  return (0, import_reflection.createClassDecorator)({
-    data: { [import_container.injectMetadataSymbol]: {} },
-    mergeData: true,
-    handler: (data) => {
-      const { alias: aliases, provider, ...registrationOptions } = options;
-      const targetProvider = provider ?? { useClass: data.constructor };
-      import_container.container.register(data.constructor, targetProvider, registrationOptions);
-      if ((0, import_type_guards.isDefined)(aliases)) {
-        for (const alias of (0, import_array.toArray)(aliases)) {
-          import_container.container.register(alias, { useToken: data.constructor }, registrationOptions);
-        }
-      }
-    }
-  });
-}
-function singleton(options = {}) {
-  return injectable({ ...options, lifecycle: "singleton" });
-}
-function scoped(lifecycle, options = {}) {
-  return injectable({ ...options, lifecycle });
-}
-function inject(token, argument, mapperOrKey) {
-  const injectMetadata = {};
-  if ((0, import_type_guards.isDefined)(token)) {
-    injectMetadata.injectToken = token;
-  }
-  if ((0, import_type_guards.isDefined)(argument)) {
-    injectMetadata.resolveArgumentProvider = () => argument;
-  }
-  if ((0, import_type_guards.isDefined)(mapperOrKey)) {
-    injectMetadata.mapper = (0, import_type_guards.isFunction)(mapperOrKey) ? mapperOrKey : (value) => value[mapperOrKey];
-  }
-  return createInjectDecorator(injectMetadata);
-}
-function resolveArg(argument) {
-  return resolveArgProvider(() => argument);
-}
-function resolveArgProvider(argumentProvider) {
-  return createInjectDecorator({ resolveArgumentProvider: argumentProvider });
-}
-function injectArg(mapperOrKey) {
-  return createInjectDecorator({
-    injectArgumentMapper: (0, import_type_guards.isFunction)(mapperOrKey) ? mapperOrKey : (0, import_type_guards.isDefined)(mapperOrKey) ? (value) => value[mapperOrKey] : (value) => value
-  });
-}
-function forwardArg(mapper = (value) => value) {
-  return createInjectDecorator({ forwardArgumentMapper: mapper });
-}
-function optional() {
-  return createInjectDecorator({ optional: true });
-}
-function forwardRef(token, argument) {
-  const injectMetadata = {
-    forwardRefToken: token
-  };
-  if ((0, import_type_guards.isDefined)(argument)) {
-    injectMetadata.resolveArgumentProvider = () => argument;
-  }
-  return createInjectDecorator(injectMetadata);
-}
-function createInjectDecorator(metadata) {
-  return (0, import_reflection.createDecorator)({
-    property: true,
-    accessor: true,
-    constructorParameter: true,
-    data: { [import_container.injectMetadataSymbol]: metadata },
-    mergeData: true
-  });
-}

package/_container/index.d.ts

@@ -1,10 +0,0 @@
-export * from './container.js';
-export * from './decorators.js';
-export * from './interfaces.js';
-export * from './provider.js';
-export * from './resolve-chain.js';
-export * from './resolve.error.js';
-export * from './token.js';
-export * from './type-info.js';
-export * from './types.js';
-export * from './utils.js';

package/_container/index.js

@@ -1,27 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var container_exports = {};
-module.exports = __toCommonJS(container_exports);
-__reExport(container_exports, require("./container.js"), module.exports);
-__reExport(container_exports, require("./decorators.js"), module.exports);
-__reExport(container_exports, require("./interfaces.js"), module.exports);
-__reExport(container_exports, require("./provider.js"), module.exports);
-__reExport(container_exports, require("./resolve-chain.js"), module.exports);
-__reExport(container_exports, require("./resolve.error.js"), module.exports);
-__reExport(container_exports, require("./token.js"), module.exports);
-__reExport(container_exports, require("./type-info.js"), module.exports);
-__reExport(container_exports, require("./types.js"), module.exports);
-__reExport(container_exports, require("./utils.js"), module.exports);