@tstdl/base 0.86.0-beta9 → 0.86.1

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

package/_container/interfaces.d.ts

@@ -1,16 +0,0 @@
-export declare const resolveArgumentType: unique symbol;
-export declare const afterResolve: unique symbol;
-export type InjectableArgument<T, Fallback> = T extends Injectable<infer A> ? A : Fallback;
-export interface Injectable<T = unknown> {
-    /**
-     * type of resolve argument
-     * @deprecated only used for type inference
-     */
-    readonly [resolveArgumentType]: T;
-}
-export interface AfterResolve {
-    /**
-     * called after resolve through container
-     */
-    [afterResolve](): void | Promise<void>;
-}

package/_container/interfaces.js

@@ -1,26 +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 interfaces_exports = {};
-__export(interfaces_exports, {
-  afterResolve: () => afterResolve,
-  resolveArgumentType: () => resolveArgumentType
-});
-module.exports = __toCommonJS(interfaces_exports);
-const resolveArgumentType = Symbol("resolveArgumentType");
-const afterResolve = Symbol("after resolve");

package/_container/provider.d.ts

@@ -1,35 +0,0 @@
-import type { Constructor } from '../types.js';
-import type { InjectableArgument } from './interfaces.js';
-import type { InjectionToken } from './token.js';
-import type { ResolveContext } from './types.js';
-export type Factory<T, A = any> = (argument: InjectableArgument<T, A> | undefined, context: ResolveContext) => T | Promise<T>;
-export type Provider<T = any, A = any> = ClassProvider<T> | ValueProvider<T> | TokenProvider<T, A> | FactoryProvider<T, A>;
-export type ClassProvider<T = any> = {
-    useClass: Constructor<T>;
-};
-export type ValueProvider<T = any> = {
-    useValue: T;
-};
-export type TokenProvider<T = any, A = any> = {
-    useToken: InjectionToken<T, A>;
-    useTokenProvider?: undefined;
-    argument?: InjectableArgument<T, A>;
-    argumentProvider?: () => InjectableArgument<T, A> | Promise<InjectableArgument<T, A>>;
-} | {
-    useToken?: undefined;
-    useTokenProvider: () => InjectionToken<T, A> | Promise<InjectionToken<T, A>>;
-    argument?: InjectableArgument<T, A>;
-    argumentProvider?: () => InjectableArgument<T, A> | Promise<InjectableArgument<T, A>>;
-};
-export type FactoryProvider<T = any, A = unknown> = {
-    useFactory: Factory<T, A>;
-};
-export declare function classProvider<T>(constructor: Constructor<T>): ClassProvider<T>;
-export declare function valueProvider<T>(value: T): ValueProvider<T>;
-export declare function tokenProvider<T, A>(token: InjectionToken<T, A>, argument?: InjectableArgument<T, A>): TokenProvider<T>;
-export declare function factoryProvider<T, A>(factory: Factory<T, A>): FactoryProvider<T, A>;
-export declare function isClassProvider<T>(value: unknown): value is ClassProvider<T>;
-export declare function isValueProvider<T>(value: unknown): value is ValueProvider<T>;
-export declare function isTokenProvider<T>(value: unknown): value is TokenProvider<T>;
-export declare function isFactoryProvider<T, A>(value: unknown): value is FactoryProvider<T, A>;
-export declare function isProvider<T, A>(value: unknown): value is Provider<T, A>;

package/_container/provider.js

@@ -1,60 +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 provider_exports = {};
-__export(provider_exports, {
-  classProvider: () => classProvider,
-  factoryProvider: () => factoryProvider,
-  isClassProvider: () => isClassProvider,
-  isFactoryProvider: () => isFactoryProvider,
-  isProvider: () => isProvider,
-  isTokenProvider: () => isTokenProvider,
-  isValueProvider: () => isValueProvider,
-  tokenProvider: () => tokenProvider,
-  valueProvider: () => valueProvider
-});
-module.exports = __toCommonJS(provider_exports);
-var import_object = require("../utils/object/object.js");
-var import_type_guards = require("../utils/type-guards.js");
-function classProvider(constructor) {
-  return { useClass: constructor };
-}
-function valueProvider(value) {
-  return { useValue: value };
-}
-function tokenProvider(token, argument) {
-  return { useToken: token, argument };
-}
-function factoryProvider(factory) {
-  return { useFactory: factory };
-}
-function isClassProvider(value) {
-  return (0, import_type_guards.isObject)(value) && (0, import_object.hasOwnProperty)(value, "useClass");
-}
-function isValueProvider(value) {
-  return (0, import_type_guards.isObject)(value) && (0, import_object.hasOwnProperty)(value, "useValue");
-}
-function isTokenProvider(value) {
-  return (0, import_type_guards.isObject)(value) && ((0, import_object.hasOwnProperty)(value, "useToken") || (0, import_object.hasOwnProperty)(value, "useTokenProvider"));
-}
-function isFactoryProvider(value) {
-  return (0, import_type_guards.isObject)(value) && (0, import_object.hasOwnProperty)(value, "useFactory");
-}
-function isProvider(value) {
-  return (0, import_type_guards.isObject)(value) && (isClassProvider(value) || isValueProvider(value) || isTokenProvider(value) || isFactoryProvider(value));
-}

package/_container/resolve-chain.d.ts

@@ -1,27 +0,0 @@
-import type { AbstractConstructor } from '../types.js';
-import type { InjectionToken } from './token.js';
-export type ResolveChainNodeBase<Type extends string> = {
-    type: Type;
-};
-export type ResolveChainNode = ResolveChainNodeBase<'token'> & {
-    token: InjectionToken;
-} | ResolveChainNodeBase<'parameter'> & {
-    constructor: AbstractConstructor;
-    index: number;
-    token: InjectionToken;
-} | ResolveChainNodeBase<'property'> & {
-    constructor: AbstractConstructor;
-    property: PropertyKey;
-    token: InjectionToken;
-};
-export declare class ResolveChain {
-    readonly nodes: readonly ResolveChainNode[];
-    get length(): number;
-    constructor(nodes?: ResolveChainNode[]);
-    static startWith(token: InjectionToken): ResolveChain;
-    addToken(token: InjectionToken): ResolveChain;
-    addParameter(constructor: AbstractConstructor, index: number, token: InjectionToken): ResolveChain;
-    addProperty(constructor: AbstractConstructor, property: PropertyKey, token: InjectionToken): ResolveChain;
-    format(truncate?: number): string;
-    truncate(tokenCount: number): ResolveChain;
-}

package/_container/resolve-chain.js

@@ -1,105 +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 resolve_chain_exports = {};
-__export(resolve_chain_exports, {
-  ResolveChain: () => ResolveChain
-});
-module.exports = __toCommonJS(resolve_chain_exports);
-var import_reflection = require("../reflection/index.js");
-var import_type_guards = require("../utils/type-guards.js");
-var import_token = require("./token.js");
-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 = (0, import_type_guards.isDefined)(truncate) ? this.truncate(truncate) : this;
-    if (chain.length < this.length) {
-      chainString += "\n       [...]";
-    }
-    for (const node of chain.nodes) {
-      const tokenName = (0, import_token.getTokenName)(node.token);
-      switch (node.type) {
-        case "token":
-          chainString += `
-    -> ${tokenName}`;
-          break;
-        case "parameter":
-          const metadata = import_reflection.reflectionRegistry.getMetadata(node.constructor);
-          const prefix = "_, ".repeat(node.index);
-          const suffix = ", _".repeat((0, import_type_guards.assertDefinedPass)(metadata?.parameters, "missing parameters metadata").length - node.index - 1);
-          chainString += `(${prefix}${tokenName}${suffix})`;
-          break;
-        case "property":
-          const constructorName = (0, import_token.getTokenName)(node.constructor);
-          const key = getPropertyKeyString(node.property);
-          chainString += `
-    -> ${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.d.ts

@@ -1,5 +0,0 @@
-import { CustomError } from '../error/custom.error.js';
-import type { ResolveChain } from './resolve-chain.js';
-export declare class ResolveError extends CustomError {
-    constructor(message: string, chain: ResolveChain, cause?: Error);
-}

package/_container/resolve.error.js

@@ -1,36 +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 resolve_error_exports = {};
-__export(resolve_error_exports, {
-  ResolveError: () => ResolveError
-});
-module.exports = __toCommonJS(resolve_error_exports);
-var import_custom_error = require("../error/custom.error.js");
-var import_type_guards = require("../utils/type-guards.js");
-class ResolveError extends import_custom_error.CustomError {
-  constructor(message, chain, cause) {
-    const causeMessage = (0, import_type_guards.isDefined)(cause) ? `
-  cause: ${cause.message}` : "";
-    super({
-      message: `${message}${causeMessage}
-  chain: ${chain.format(15)}`,
-      cause
-    });
-  }
-}

package/_container/token.d.ts

@@ -1,18 +0,0 @@
-import type { AbstractConstructor, EnumerationObject } from '../types.js';
-declare const type: unique symbol;
-declare const argument: unique symbol;
-export type ArgumentedInjectionToken<T, A> = SimpleInjectionToken<T> & {
-    [argument]?: A;
-};
-export type SimpleInjectionToken<T> = AbstractConstructor<T> | EnumerationObject;
-export type InjectionToken<T = any, A = any> = SimpleInjectionToken<T> | ArgumentedInjectionToken<T, A> | ReifyingInjectionToken<T, A>;
-export declare class ReifyingInjectionToken<T = any, A = any> {
-    private readonly [type];
-    private readonly [argument];
-    readonly description: string;
-    constructor(description: string);
-    toString(): string;
-}
-export declare function injectionToken<T, A = any>(description: string): InjectionToken<T, A>;
-export declare function getTokenName(token: InjectionToken | undefined): string;
-export {};

package/_container/token.js

@@ -1,41 +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 token_exports = {};
-__export(token_exports, {
-  ReifyingInjectionToken: () => ReifyingInjectionToken,
-  getTokenName: () => getTokenName,
-  injectionToken: () => injectionToken
-});
-module.exports = __toCommonJS(token_exports);
-var import_type_guards = require("../utils/type-guards.js");
-class ReifyingInjectionToken {
-  description;
-  constructor(description) {
-    this.description = description;
-  }
-  toString() {
-    return `InjectionToken["${this.description}"]`;
-  }
-}
-function injectionToken(description) {
-  return new ReifyingInjectionToken(description);
-}
-function getTokenName(token) {
-  return (0, import_type_guards.isFunction)(token) ? token.name : (0, import_type_guards.isString)(token) ? `"${token}"` : String(token);
-}

package/_container/type-info.d.ts

@@ -1,18 +0,0 @@
-import type { InjectionToken } from './token.js';
-import type { ArgumentProvider, ForwardRefInjectionToken, Mapper } from './types.js';
-export type InjectMetadata = {
-    /** token overwrite by inject decorator */
-    injectToken?: InjectionToken;
-    /** if defined, resolve the ForwardRefToken using ForwardRef strategy instead resolving the token */
-    forwardRefToken?: ForwardRefInjectionToken;
-    /** whether injection is optional if token is not registered. Set by optional decorator */
-    optional?: boolean;
-    /** mapper to map resolved value */
-    mapper?: Mapper;
-    /** provider to get resolve argument */
-    resolveArgumentProvider?: ArgumentProvider;
-    /** if defined, map the resolve argument and use the returned value as the value to inject */
-    injectArgumentMapper?: Mapper;
-    /** if defined, use the provided argument, map it and pass it to the resolution of the token */
-    forwardArgumentMapper?: Mapper;
-};

package/_container/type-info.js

@@ -1,16 +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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var type_info_exports = {};
-module.exports = __toCommonJS(type_info_exports);

package/_container/types.d.ts

@@ -1,9 +0,0 @@
-import type { AbstractConstructor } from '../types.js';
-import type { Container } from './container.js';
-import type { InjectionToken } from './token.js';
-export type ResolveContext = Pick<Container, 'resolve' | 'resolveAsync'> & {
-    isAsync: boolean;
-};
-export type Mapper<T = any, U = unknown> = (value: T) => U | Promise<U>;
-export type ArgumentProvider<T = unknown> = (context: ResolveContext) => T | Promise<T>;
-export type ForwardRefInjectionToken<T = any, A = any> = Exclude<InjectionToken<T, A>, AbstractConstructor> | (() => InjectionToken<T, A>);