@tstdl/base 0.86.0-beta2 → 0.86.0-beta3

package/_container/decorators.js

@@ -0,0 +1,110 @@
+"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.js

@@ -0,0 +1,27 @@
+"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.js

@@ -0,0 +1,26 @@
+"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.js

@@ -0,0 +1,60 @@
+"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.js

@@ -0,0 +1,105 @@
+"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.js

@@ -0,0 +1,36 @@
+"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.js

@@ -0,0 +1,41 @@
+"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.js

@@ -0,0 +1,16 @@
+"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.js

@@ -0,0 +1,16 @@
+"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.js

@@ -0,0 +1,44 @@
+"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;
+}

package/api/client/client.d.ts

@@ -1,8 +1,8 @@
-import type { Injectable } from '../../container/index.js';
 import type { HttpClientOptions } from '../../http/client/index.js';
 import { HttpClient } from '../../http/client/index.js';
+import type { Resolvable } from '../../injector/interfaces.js';
 import type { ApiClientImplementation, ApiDefinition, ApiEndpointDefinition } from '../types.js';
-export type ApiClient<T extends ApiDefinition> = new (httpClient: HttpClient) => ApiClientImplementation<T> & Injectable<HttpClientOptions>;
+export type ApiClient<T extends ApiDefinition> = new (httpClient: HttpClient) => ApiClientImplementation<T> & Resolvable<HttpClientOptions>;
 export type ClientOptions = {
     /**
      * url prefix