@tstdl/base 0.85.13 → 0.86.0-beta1

package/container/decorators.js

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

package/container/index.js

@@ -1,27 +1,10 @@
-"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);
+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/interfaces.js

@@ -1,26 +1,2 @@
-"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");
+export const resolveArgumentType = Symbol('resolveArgumentType');
+export const afterResolve = Symbol('after resolve');

package/container/provider.js

@@ -1,60 +1,29 @@
-"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));
+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,105 +1,80 @@
-"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       [...]";
+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;
     }
-    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}`);
-      }
+    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]);
     }
-    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++;
-      }
+    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);
     }
-    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}`);
-  }
+    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,36 +1,11 @@
-"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
-    });
-  }
+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
+        });
+    }
 }