@tstdl/base 0.86.0-beta2 → 0.86.0-beta3

package/cookie/index.js

@@ -1 +1,18 @@
-export * from './cookie.js';
+"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 cookie_exports = {};
+module.exports = __toCommonJS(cookie_exports);
+__reExport(cookie_exports, require("./cookie.js"), module.exports);

package/core.d.ts

@@ -1,8 +1,10 @@
-import type { InjectionToken } from './container/index.js';
 import { AsyncDisposer } from './disposable/async-disposer.js';
+import { Injector } from './injector/injector.js';
+import type { InjectionToken } from './injector/token.js';
 import type { LoggerArgument } from './logger/index.js';
 import { LogLevel, Logger } from './logger/index.js';
-export declare const CORE_LOGGER: InjectionToken<Logger, any>;
+export declare const CORE_LOGGER: InjectionToken<Logger, never>;
+export declare const rootInjector: Injector;
 export declare const disposer: AsyncDisposer;
 export declare function isDevMode(): boolean;
 export declare function isProdMode(): boolean;

package/core.js

@@ -1,55 +1,91 @@
-import { container, injectionToken } from './container/index.js';
-import { AsyncDisposer } from './disposable/async-disposer.js';
-import { ConsoleLogger } from './logger/console/logger.js';
-import { LogLevel, Logger } from './logger/index.js';
-import { timeout } from './utils/timing.js';
-import { assertDefinedPass, isDefined } from './utils/type-guards.js';
-export const CORE_LOGGER = injectionToken('core logger');
-export const disposer = new AsyncDisposer();
+"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 core_exports = {};
+__export(core_exports, {
+  CORE_LOGGER: () => CORE_LOGGER,
+  configureTstdl: () => configureTstdl,
+  connect: () => connect,
+  disposeInstances: () => disposeInstances,
+  disposer: () => disposer,
+  enableProdMode: () => enableProdMode,
+  isDevMode: () => isDevMode,
+  isProdMode: () => isProdMode,
+  rootInjector: () => rootInjector
+});
+module.exports = __toCommonJS(core_exports);
+var import_async_disposer = require("./disposable/async-disposer.js");
+var import_injector = require("./injector/injector.js");
+var import_token = require("./injector/token.js");
+var import_logger = require("./logger/console/logger.js");
+var import_logger2 = require("./logger/index.js");
+var import_process_shutdown = require("./process-shutdown.js");
+var import_timing = require("./utils/timing.js");
+var import_type_guards = require("./utils/type-guards.js");
+const CORE_LOGGER = (0, import_token.injectionToken)("core logger");
+const rootInjector = new import_injector.Injector("RootInjector");
+const disposer = new import_async_disposer.AsyncDisposer();
 let _isDevMode = true;
-export function isDevMode() {
-    return _isDevMode;
+function isDevMode() {
+  return _isDevMode;
 }
-export function isProdMode() {
-    return !_isDevMode;
+function isProdMode() {
+  return !_isDevMode;
 }
-export function enableProdMode() {
-    _isDevMode = false;
+function enableProdMode() {
+  _isDevMode = false;
 }
-export async function connect(name, connectFunction, logger, maxTries = 5) {
-    let triesLeft = maxTries;
-    let success = false;
-    while (!success && !disposer.disposing && triesLeft-- > 0) {
-        try {
-            logger.verbose(`connecting to ${name}...`);
-            await connectFunction();
-            success = true;
-            logger.info(`connected to ${name}`);
-        }
-        catch (error) {
-            logger.verbose(`error connecting to ${name}${triesLeft > 0 ? ', trying again...' : ''}`);
-            logger.error(error);
-            if (triesLeft == 0) {
-                throw new Error(`Failed to connect to ${name} - no tries left.`);
-            }
-            await timeout(3000);
-        }
+async function connect(name, connectFunction, logger, maxTries = 5) {
+  let triesLeft = maxTries;
+  let success = false;
+  while (!success && !disposer.disposing && triesLeft-- > 0) {
+    try {
+      logger.verbose(`connecting to ${name}...`);
+      await connectFunction();
+      success = true;
+      logger.info(`connected to ${name}`);
+    } catch (error) {
+      logger.verbose(`error connecting to ${name}${triesLeft > 0 ? ", trying again..." : ""}`);
+      logger.error(error);
+      if (triesLeft == 0) {
+        throw new Error(`Failed to connect to ${name} - no tries left.`);
+      }
+      await (0, import_timing.timeout)(3e3);
     }
+  }
 }
-export async function disposeInstances() {
-    await disposer.dispose();
+async function disposeInstances() {
+  await disposer.dispose();
 }
 let coreLogPrefix;
-export function configureTstdl(config = {}) {
-    if (config.production == true) {
-        enableProdMode();
-    }
-    container.register(Logger, { useToken: config.logger ?? ConsoleLogger });
-    container.registerSingleton(LogLevel, { useFactory: (level) => assertDefinedPass(level, 'LogLevel argument not provided') }, { defaultArgumentProvider: () => config.logLevel ?? LogLevel.Trace });
-    if (isDefined(config.coreLogPrefix)) {
-        coreLogPrefix = config.coreLogPrefix;
-    }
+function configureTstdl(config = {}) {
+  if (config.production == true) {
+    enableProdMode();
+  }
+  const logger = rootInjector.resolve(CORE_LOGGER);
+  (0, import_process_shutdown.setProcessShutdownLogger)(logger);
+  (0, import_process_shutdown.initializeSignals)();
+  import_injector.Injector.register(import_logger2.Logger, { useToken: config.logger ?? import_logger.ConsoleLogger });
+  import_injector.Injector.registerSingleton(import_logger2.LogLevel, { useFactory: (level) => (0, import_type_guards.assertDefinedPass)(level, "LogLevel argument not provided") }, { defaultArgumentProvider: () => config.logLevel ?? import_logger2.LogLevel.Trace });
+  if ((0, import_type_guards.isDefined)(config.coreLogPrefix)) {
+    coreLogPrefix = config.coreLogPrefix;
+  }
 }
-container.register(Logger, { useToken: ConsoleLogger });
-container.register(LogLevel, { useValue: LogLevel.Trace });
-container.register(CORE_LOGGER, { useToken: Logger, argumentProvider: () => coreLogPrefix });
+import_injector.Injector.register(import_logger2.Logger, { useToken: import_logger.ConsoleLogger });
+import_injector.Injector.register(import_logger2.LogLevel, { useValue: import_logger2.LogLevel.Trace });
+import_injector.Injector.register(CORE_LOGGER, { useToken: import_logger2.Logger, defaultArgumentProvider: () => coreLogPrefix });

package/data-structures/array-dictionary.js

@@ -1,97 +1,118 @@
-import { isDefined } from '../utils/type-guards.js';
-import { Dictionary } from './dictionary.js';
-export class ArrayDictionary extends Dictionary {
-    keyArray;
-    valueArray;
-    [Symbol.toStringTag] = 'ArrayDictionary';
-    constructor(items) {
-        super();
-        this.keyArray = [];
-        this.valueArray = [];
-        if (isDefined(items)) {
-            this.addMany(items);
-            this.updateSize();
-        }
+"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 array_dictionary_exports = {};
+__export(array_dictionary_exports, {
+  ArrayDictionary: () => ArrayDictionary
+});
+module.exports = __toCommonJS(array_dictionary_exports);
+var import_type_guards = require("../utils/type-guards.js");
+var import_dictionary = require("./dictionary.js");
+class ArrayDictionary extends import_dictionary.Dictionary {
+  keyArray;
+  valueArray;
+  [Symbol.toStringTag] = "ArrayDictionary";
+  constructor(items) {
+    super();
+    this.keyArray = [];
+    this.valueArray = [];
+    if ((0, import_type_guards.isDefined)(items)) {
+      this.addMany(items);
+      this.updateSize();
     }
-    has(key) {
-        return this.keyArray.includes(key);
+  }
+  has(key) {
+    return this.keyArray.includes(key);
+  }
+  get(key) {
+    const index = this.keyArray.indexOf(key);
+    if (index == -1) {
+      return void 0;
     }
-    get(key) {
-        const index = this.keyArray.indexOf(key);
-        if (index == -1) {
-            return undefined;
-        }
-        return this.valueArray[index];
+    return this.valueArray[index];
+  }
+  set(key, value) {
+    const index = this.keyArray.indexOf(key);
+    if (index == -1) {
+      this.keyArray.push(key);
+      this.valueArray.push(value);
+    } else {
+      this.valueArray[index] = value;
     }
-    set(key, value) {
-        const index = this.keyArray.indexOf(key);
-        if (index == -1) {
-            this.keyArray.push(key);
-            this.valueArray.push(value);
-        }
-        else {
-            this.valueArray[index] = value;
-        }
-        this.updateSize();
+    this.updateSize();
+  }
+  delete(key) {
+    const index = this.keyArray.indexOf(key);
+    if (index == -1) {
+      return false;
     }
-    delete(key) {
-        const index = this.keyArray.indexOf(key);
-        if (index == -1) {
-            return false;
-        }
-        this.keyArray[index] = this.keyArray[this.keyArray.length - 1];
-        this.valueArray[index] = this.valueArray[this.valueArray.length - 1];
-        this.keyArray.length -= 1;
-        this.valueArray.length -= 1;
-        this.updateSize();
-        return true;
+    this.keyArray[index] = this.keyArray[this.keyArray.length - 1];
+    this.valueArray[index] = this.valueArray[this.valueArray.length - 1];
+    this.keyArray.length -= 1;
+    this.valueArray.length -= 1;
+    this.updateSize();
+    return true;
+  }
+  includes([key, value]) {
+    const index = this.keyArray.indexOf(key);
+    if (index == -1) {
+      return false;
     }
-    includes([key, value]) {
-        const index = this.keyArray.indexOf(key);
-        if (index == -1) {
-            return false;
-        }
-        return this.valueArray[index] == value;
+    return this.valueArray[index] == value;
+  }
+  add(item) {
+    this.set(item[0], item[1]);
+  }
+  addMany(items) {
+    for (const [key, value] of items) {
+      const index = this.keyArray.indexOf(key);
+      if (index == -1) {
+        this.keyArray.push(key);
+        this.valueArray.push(value);
+      } else {
+        this.valueArray[index] = value;
+      }
     }
-    add(item) {
-        this.set(item[0], item[1]);
-    }
-    addMany(items) {
-        for (const [key, value] of items) {
-            const index = this.keyArray.indexOf(key);
-            if (index == -1) {
-                this.keyArray.push(key);
-                this.valueArray.push(value);
-            }
-            else {
-                this.valueArray[index] = value;
-            }
-        }
-        this.updateSize();
-    }
-    clone() {
-        const arrayDictionary = new ArrayDictionary();
-        arrayDictionary.keyArray = [...this.keyArray];
-        arrayDictionary.valueArray = [...this.valueArray];
-        arrayDictionary.updateSize();
-        return arrayDictionary;
-    }
-    *items() {
-        for (let i = 0; i < this.keyArray.length; i++) {
-            yield [this.keyArray[i], this.valueArray[i]];
-        }
-    }
-    keys() {
-        return this.keyArray[Symbol.iterator]();
-    }
-    values() {
-        return this.valueArray[Symbol.iterator]();
-    }
-    _clear() {
-        this.keyArray = [];
-        this.valueArray = [];
-    }
-    updateSize() {
-        this.setSize(this.keyArray.length / 2);
+    this.updateSize();
+  }
+  clone() {
+    const arrayDictionary = new ArrayDictionary();
+    arrayDictionary.keyArray = [...this.keyArray];
+    arrayDictionary.valueArray = [...this.valueArray];
+    arrayDictionary.updateSize();
+    return arrayDictionary;
+  }
+  *items() {
+    for (let i = 0; i < this.keyArray.length; i++) {
+      yield [this.keyArray[i], this.valueArray[i]];
     }
+  }
+  keys() {
+    return this.keyArray[Symbol.iterator]();
+  }
+  values() {
+    return this.valueArray[Symbol.iterator]();
+  }
+  _clear() {
+    this.keyArray = [];
+    this.valueArray = [];
+  }
+  updateSize() {
+    this.setSize(this.keyArray.length / 2);
+  }
 }

package/data-structures/array-list.d.ts

@@ -21,7 +21,7 @@ export declare class ArrayList<T> extends List<T, ArrayList<T>> {
     protected _set(index: number, item: T): void;
     remove(item: T): boolean;
     protected _removeAt(index: number): T;
-    protected _removeManyAt(index: number, count?: number): T[];
+    protected _removeManyAt(index: number, count: number): T[];
     clone(): ArrayList<T>;
     items(): IterableIterator<T>;
     itemsReverse(): IterableIterator<T>;

package/data-structures/array-list.js

@@ -1,106 +1,129 @@
-import { List } from './list.js';
-export class ArrayList extends List {
-    backingArray;
-    constructor(items = []) {
-        super();
-        this.backingArray = [...items];
-        this.updateSize();
-    }
-    /**
-     * creates a new {@link ArrayList} from existing array without copying data
-     * @param array array to use as new backing array for this {@link ArrayList}
-     */
-    static fromArray(array) {
-        const arrayList = new ArrayList();
-        arrayList.backingArray = array;
-        arrayList.updateSize();
-        return arrayList;
-    }
-    _at(index) {
-        this.ensureBounds(index);
-        return this.backingArray[index];
-    }
-    _indexOf(item, fromIndex) {
-        const index = this.backingArray.indexOf(item, fromIndex);
-        if (index == -1) {
-            return undefined;
-        }
-        return index;
-    }
-    findIndex(predicate) {
-        return this.backingArray.findIndex((item, index) => predicate(item, index));
-    }
-    _lastIndexOf(item, fromIndex) {
-        const index = this.backingArray.lastIndexOf(item, fromIndex);
-        if (index == -1) {
-            return undefined;
-        }
-        return index;
-    }
-    findLastIndex(predicate) {
-        for (let i = this.size - 1; i >= 0; i--) {
-            if (predicate(this.backingArray[i], i)) {
-                return i;
-            }
-        }
-        return undefined;
-    }
-    includes(item) {
-        return this.backingArray.includes(item);
-    }
-    prepend(item) {
-        this.backingArray.unshift(item);
-        this.updateSize();
-    }
-    prependMany(items) {
-        this.backingArray.unshift(...items);
-        this.updateSize();
-    }
-    add(item) {
-        this.backingArray.push(item);
-        this.updateSize();
-    }
-    addMany(items) {
-        this.backingArray.push(...items);
-        this.updateSize();
-    }
-    _set(index, item) {
-        this.ensureBounds(index);
-        this.backingArray[index] = item;
-        this.emitChange();
-    }
-    remove(item) {
-        const index = this.backingArray.indexOf(item);
-        if (index == -1) {
-            return false;
-        }
-        this.removeAt(index);
-        return true;
-    }
-    _removeAt(index) {
-        return this.removeManyAt(index, 1)[0];
-    }
-    _removeManyAt(index, count = this.size - index) {
-        this.ensureBounds(index, count);
-        const removed = this.backingArray.splice(index, count);
-        this.updateSize();
-        return removed;
-    }
-    clone() {
-        return new ArrayList(this.backingArray);
-    }
-    *items() {
-        yield* this.backingArray;
-    }
-    *itemsReverse() {
-        for (let i = this.size - 1; i >= 0; i--) {
-            yield this.backingArray[i];
-        }
-    }
-    _clear() {
-        this.backingArray.splice(0, this.backingArray.length);
-    }
-    updateSize() {
-        this.setSize(this.backingArray.length);
-    }
+"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 array_list_exports = {};
+__export(array_list_exports, {
+  ArrayList: () => ArrayList
+});
+module.exports = __toCommonJS(array_list_exports);
+var import_list = require("./list.js");
+class ArrayList extends import_list.List {
+  backingArray;
+  constructor(items = []) {
+    super();
+    this.backingArray = [...items];
+    this.updateSize();
+  }
+  /**
+   * creates a new {@link ArrayList} from existing array without copying data
+   * @param array array to use as new backing array for this {@link ArrayList}
+   */
+  static fromArray(array) {
+    const arrayList = new ArrayList();
+    arrayList.backingArray = array;
+    arrayList.updateSize();
+    return arrayList;
+  }
+  _at(index) {
+    return this.backingArray[index];
+  }
+  _indexOf(item, fromIndex) {
+    const index = this.backingArray.indexOf(item, fromIndex);
+    if (index == -1) {
+      return void 0;
+    }
+    return index;
+  }
+  findIndex(predicate) {
+    return this.backingArray.findIndex((item, index) => predicate(item, index));
+  }
+  _lastIndexOf(item, fromIndex) {
+    const index = this.backingArray.lastIndexOf(item, fromIndex);
+    if (index == -1) {
+      return void 0;
+    }
+    return index;
+  }
+  findLastIndex(predicate) {
+    for (let i = this.size - 1; i >= 0; i--) {
+      if (predicate(this.backingArray[i], i)) {
+        return i;
+      }
+    }
+    return void 0;
+  }
+  includes(item) {
+    return this.backingArray.includes(item);
+  }
+  prepend(item) {
+    this.backingArray.unshift(item);
+    this.updateSize();
+  }
+  prependMany(items) {
+    this.backingArray.unshift(...items);
+    this.updateSize();
+  }
+  add(item) {
+    this.backingArray.push(item);
+    this.updateSize();
+  }
+  addMany(items) {
+    this.backingArray.push(...items);
+    this.updateSize();
+  }
+  _set(index, item) {
+    this.backingArray[index] = item;
+    this.emitChange();
+  }
+  remove(item) {
+    const index = this.backingArray.indexOf(item);
+    if (index == -1) {
+      return false;
+    }
+    this.removeAt(index);
+    return true;
+  }
+  _removeAt(index) {
+    if (index == 0) {
+      return this.backingArray.shift();
+    }
+    return this.removeManyAt(index, 1)[0];
+  }
+  _removeManyAt(index, count) {
+    const removed = this.backingArray.splice(index, count);
+    this.updateSize();
+    return removed;
+  }
+  clone() {
+    return new ArrayList(this.backingArray);
+  }
+  *items() {
+    yield* this.backingArray;
+  }
+  *itemsReverse() {
+    for (let i = this.size - 1; i >= 0; i--) {
+      yield this.backingArray[i];
+    }
+  }
+  _clear() {
+    this.backingArray.splice(0, this.backingArray.length);
+  }
+  updateSize() {
+    this.setSize(this.backingArray.length);
+  }
 }