@tstdl/base 0.85.14 → 0.85.16

package/injector/resolve-chain.js

@@ -0,0 +1,113 @@
+"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]);
+  }
+  addInject(token, index) {
+    const node = { type: "inject", token, index };
+    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 "inject":
+          chainString += `
+    -> inject(${tokenName}) #${node.index + 1}`;
+          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/injector/resolve.error.d.ts

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

package/injector/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/injector/symbols.d.ts

@@ -0,0 +1,2 @@
+export declare const injectableMetadataSymbol: unique symbol;
+export declare const injectMetadataSymbol: unique symbol;

package/injector/symbols.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 symbols_exports = {};
+__export(symbols_exports, {
+  injectMetadataSymbol: () => injectMetadataSymbol,
+  injectableMetadataSymbol: () => injectableMetadataSymbol
+});
+module.exports = __toCommonJS(symbols_exports);
+const injectableMetadataSymbol = Symbol("Injectable metadata");
+const injectMetadataSymbol = Symbol("Inject metadata");

package/injector/token.d.ts

@@ -0,0 +1,18 @@
+import type { AbstractConstructor } 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> | object;
+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 = never>(description: string): InjectionToken<T, A>;
+export declare function getTokenName(token: InjectionToken | undefined): string;
+export {};

package/injector/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/injector/type-info.d.ts

@@ -0,0 +1,26 @@
+import type { OneOrMany } from '../types.js';
+import type { Provider } from './provider.js';
+import type { InjectionToken } from './token.js';
+import type { ArgumentProvider, ForwardRefInjectionToken, Mapper, RegistrationOptions } from './types.js';
+export type InjectableMetadata<T, A> = RegistrationOptions<T, A> & {
+    /** 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 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/injector/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/injector/types.d.ts

@@ -0,0 +1,43 @@
+import type { Record } from '../types.js';
+import type { Injector } from './injector.js';
+import type { ResolveArgument } from './interfaces.js';
+import type { InjectionToken } from './token.js';
+/**
+ * transient: new resolution for every resolve
+ * resolution: one resolution per resolve tree
+ * injector: one resolution per injector
+ * singleton: one resolution at injector where token is registered
+ */
+export type Lifecycle = 'transient' | 'resolution' | 'injector' | 'singleton';
+export type ResolveContext = Pick<Injector, 'resolve' | 'resolveAll'>;
+export type Mapper<T = any, U = unknown> = (value: T) => U;
+export type ArgumentProvider<T = unknown> = (context: ResolveContext) => T;
+export type ForwardRefInjectionToken<T = any, A = any> = Exclude<InjectionToken<T, A>, Function> | (() => InjectionToken<T, A>);
+export type ResolveOptions = {
+    optional?: boolean;
+    skipSelf?: boolean;
+    onlySelf?: boolean;
+};
+export type RegistrationOptions<T, A = unknown> = {
+    lifecycle?: Lifecycle;
+    /** Default resolve argument used when neither token nor explicit resolve argument is provided */
+    defaultArgument?: ResolveArgument<T, A>;
+    /** Default resolve argument used when neither token nor explicit resolve argument is provided */
+    defaultArgumentProvider?: ArgumentProvider<ResolveArgument<T, A>>;
+    /**
+     * Value to distinguish scoped and singleton instances based on argument
+     * by default it uses strict equality (===) on the original argument,
+     * so modifications to argument objects and literal objects in the call
+     * may not yield the expected result.
+     *
+     * Hint: {@link JSON.stringify} is a simple solution for many use cases,
+     * but will fail if properties have different order
+     */
+    argumentIdentityProvider?: Mapper<ResolveArgument<T, A>>;
+    /** Function which gets called after a resolve */
+    afterResolve?: (instance: T, argument: ResolveArgument<T, A>) => any;
+    /** Whether multiple values can be resolved or not (used with {@link Injector.resolveAll}). If false, previous registrations are removed */
+    multi?: boolean;
+    /** Custom metadata */
+    metadata?: Record;
+};

package/injector/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.85.14",
+  "version": "0.85.16",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -23,7 +23,7 @@
     "luxon": "^3.3",
     "reflect-metadata": "^0.1",
     "rxjs": "^7.8",
-    "type-fest": "^3.12"
+    "type-fest": "^4.0"
   },
   "devDependencies": {
     "@types/chroma-js": "2.4",
@@ -33,11 +33,11 @@
     "@types/mjml": "4.7",
     "@types/node": "20",
     "@types/nodemailer": "6.4",
-    "@typescript-eslint/eslint-plugin": "5.61",
-    "@typescript-eslint/parser": "5.61",
+    "@typescript-eslint/eslint-plugin": "6.2",
+    "@typescript-eslint/parser": "6.2",
     "concurrently": "8.2",
     "esbuild": "0.18",
-    "eslint": "8.44",
+    "eslint": "8.45",
     "eslint-import-resolver-typescript": "3.5",
     "eslint-plugin-import": "2.27",
     "tsc-alias": "1.8",
@@ -54,15 +54,15 @@
     "@zxcvbn-ts/language-en": "^3.0",
     "chroma-js": "^2.4",
     "handlebars": "^4.7",
-    "knex": "^2.4",
+    "knex": "^2.5",
     "koa": "^2.14",
     "minio": "^7.1",
     "mjml": "^4.14",
     "mongodb": "^5.7",
     "nodemailer": "^6.9",
-    "playwright": "^1.35",
-    "preact": "^10.15",
-    "preact-render-to-string": "^6.1",
+    "playwright": "^1.36",
+    "preact": "^10.16",
+    "preact-render-to-string": "^6.2",
     "undici": "^5.22",
     "urlpattern-polyfill": "^9.0"
   },

package/pool/pool.js

@@ -22,7 +22,7 @@ __export(pool_exports, {
 });
 module.exports = __toCommonJS(pool_exports);
 var import_array_list = require("../data-structures/array-list.js");
-var import_set = require("../data-structures/set.js");
+var import_set_collection = require("../data-structures/set-collection.js");
 var import_disposable = require("../disposable/disposable.js");
 var import_environment = require("../environment.js");
 var import_type_guards = require("../utils/type-guards.js");
@@ -46,7 +46,7 @@ class Pool {
     this.logger = logger;
     this.disposeOnError = options?.disposeOnError ?? false;
     this.freeInstances = new import_array_list.ArrayList();
-    this.usedInstances = new import_set.Set();
+    this.usedInstances = new import_set_collection.SetCollection();
     this.placeholderInstances = 0;
     this.disposed = false;
   }

package/utils/type-guards.js

@@ -298,7 +298,7 @@ function isUndefined(value) {
   return value === void 0;
 }
 function isDefined(value) {
-  return !isUndefined(value);
+  return value !== void 0;
 }
 function assertUndefined(value, message = "Expected value to be undefined.") {
   assert(isUndefined(value), message);
@@ -318,7 +318,7 @@ function isNull(value) {
   return value === null;
 }
 function isNotNull(value) {
-  return !isNull(value);
+  return value !== null;
 }
 function assertNull(value, message = "Expected value to be null.") {
   assert(isNull(value), message);