@tstdl/base 0.86.0-beta8 → 0.86.0

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

package/_container/types.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 types_exports = {};
-module.exports = __toCommonJS(types_exports);

package/_container/utils.d.ts

@@ -1,3 +0,0 @@
-import type { AbstractType, Type } from '../types.js';
-export declare function stubClass<T>(forClass: string | AbstractType<T>): Type<T>;
-export declare function isStubClass(target: object): boolean;

package/_container/utils.js

@@ -1,44 +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 utils_exports = {};
-__export(utils_exports, {
-  isStubClass: () => isStubClass,
-  stubClass: () => stubClass
-});
-module.exports = __toCommonJS(utils_exports);
-var import_type_guards = require("../utils/type-guards.js");
-var import_container = require("./container.js");
-const isStubClassSymbol = Symbol("Stub class");
-function stubClass(forClass) {
-  const forClassName = (0, import_type_guards.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;
-  import_container.container.register(stub, { useClass: stub });
-  return stub;
-}
-function isStubClass(target) {
-  return target[isStubClassSymbol] === true;
-}