@tstdl/base 0.87.13 → 0.88.0-alpha1

package/collections/sorted-array-list.js

@@ -1,180 +1,157 @@
-"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 sorted_array_list_exports = {};
-__export(sorted_array_list_exports, {
-  SortedArrayList: () => SortedArrayList
-});
-module.exports = __toCommonJS(sorted_array_list_exports);
-var import_comparison = require("../utils/comparison.js");
-var import_type_guards = require("../utils/type-guards.js");
-var import_binary_search = require("../utils/binary-search.js");
-class SortedArrayList {
-  comparator;
-  backingArray;
-  get length() {
-    return this.backingArray.length;
-  }
-  constructor(comparator = import_comparison.compareByValue) {
-    this.comparator = comparator;
-    this.backingArray = [];
-  }
-  static from(iterable, comparator = import_comparison.compareByValue) {
-    const list = new SortedArrayList(comparator);
-    list.backingArray = [...iterable].sort(comparator);
-    return list;
-  }
-  [Symbol.iterator]() {
-    return this.backingArray[Symbol.iterator]();
-  }
-  clear() {
-    this.backingArray = [];
-  }
-  get(index) {
-    this.verifyIndexIsInBounds(index);
-    return this.backingArray[index];
-  }
-  getFirst() {
-    return this.get(0);
-  }
-  getLast() {
-    return this.get(this.length - 1);
-  }
-  getByComparison(value) {
-    const index = this.indexOfByComparison(value);
-    return (0, import_type_guards.isDefined)(index) ? this.get(index) : void 0;
-  }
-  getRangeByComparison(from, to) {
-    const left = this.findFirstIndexEqualOrLargerThan(from);
-    const right = this.findLastIndexEqualOrSmallerThan(to);
-    if ((0, import_type_guards.isUndefined)(left) || (0, import_type_guards.isUndefined)(right)) {
-      return [];
-    }
-    return this.backingArray.slice(left, right + 1);
-  }
-  set(_index, _value) {
-    throw new Error("Assignment by index not allowed in sorted collections.");
-  }
-  add(value) {
-    const index = (0, import_binary_search.binarySearchInsertionIndex)(this.backingArray, value, this.comparator);
-    this.backingArray.splice(index, 0, value);
-  }
-  addMany(values) {
-    for (const value of values) {
-      this.add(value);
-    }
-  }
-  addAt(_index, ..._values) {
-    throw new Error("Adding at index not allowed in sorted collections.");
-  }
-  removeFirst() {
-    return this.removeAt(0);
-  }
-  removeLast() {
-    return this.removeAt(this.length - 1);
-  }
-  has(value) {
-    const index = this.indexOf(value);
-    return index != void 0;
-  }
-  hasByComparison(value) {
-    const index = this.indexOfByComparison(value);
-    return index != void 0;
-  }
-  remove(value) {
-    const index = this.indexOf(value);
-    if (index == void 0 || this.backingArray[index] != value) {
-      return false;
-    }
-    this.backingArray.splice(index, 1);
-    return true;
-  }
-  removeMany(values) {
-    let counter = 0;
-    for (const value of values) {
-      const removed = this.remove(value);
-      if (removed) {
-        counter++;
-      }
-    }
-    return counter;
-  }
-  removeAt(index) {
-    this.verifyIndexIsInBounds(index);
-    return this.backingArray.splice(index, 1)[0];
-  }
-  removeRange(index, count) {
-    this.verifyIndexIsInBounds(index);
-    this.verifyIndexIsInBounds(index + count - 1);
-    return this.backingArray.splice(index, count);
-  }
-  removeRangeByComparison(from, to) {
-    const left = this.findFirstIndexEqualOrLargerThan(from);
-    const right = this.findLastIndexEqualOrSmallerThan(to);
-    if ((0, import_type_guards.isUndefined)(left) || (0, import_type_guards.isUndefined)(right)) {
-      return [];
-    }
-    return this.removeRange(left, right - left + 1);
-  }
-  indexOf(value) {
-    const left = this.findFirstIndexEqualOrLargerThan(value);
-    const right = this.findLastIndexEqualOrSmallerThan(value);
-    if ((0, import_type_guards.isUndefined)(left) || (0, import_type_guards.isUndefined)(right)) {
-      return void 0;
-    }
-    for (let i = left; i <= right; i++) {
-      if (this.backingArray[i] == value) {
-        return i;
-      }
-    }
-    return void 0;
-  }
-  lastIndexOf(value) {
-    const left = this.findFirstIndexEqualOrLargerThan(value);
-    const right = this.findLastIndexEqualOrSmallerThan(value);
-    if ((0, import_type_guards.isUndefined)(left) || (0, import_type_guards.isUndefined)(right)) {
-      return void 0;
-    }
-    for (let i = right; i >= left; i--) {
-      if (this.backingArray[i] == value) {
-        return i;
-      }
-    }
-    return void 0;
-  }
-  indexOfByComparison(value) {
-    return (0, import_binary_search.binarySearch)(this.backingArray, value, this.comparator);
-  }
-  firstIndexOfByComparison(value) {
-    return (0, import_binary_search.binarySearchFirst)(this.backingArray, value, this.comparator);
-  }
-  lastIndexOfByComparison(value) {
-    return (0, import_binary_search.binarySearchLast)(this.backingArray, value, this.comparator);
-  }
-  findFirstIndexEqualOrLargerThan(value) {
-    return (0, import_binary_search.binarySearchFirstIndexEqualOrLarger)(this.backingArray, value, this.comparator);
-  }
-  findLastIndexEqualOrSmallerThan(value) {
-    return (0, import_binary_search.binarySearchLastIndexEqualOrSmaller)(this.backingArray, value, this.comparator);
-  }
-  verifyIndexIsInBounds(index) {
-    if (index < 0 || index > this.backingArray.length - 1) {
-      throw new Error("Index out of bounds.");
-    }
-  }
+import { compareByValue } from '../utils/comparison.js';
+import { isDefined, isUndefined } from '../utils/type-guards.js';
+import { binarySearch, binarySearchFirst, binarySearchFirstIndexEqualOrLarger, binarySearchInsertionIndex, binarySearchLast, binarySearchLastIndexEqualOrSmaller } from '../utils/binary-search.js';
+export class SortedArrayList {
+    comparator;
+    backingArray;
+    get length() {
+        return this.backingArray.length;
+    }
+    constructor(comparator = compareByValue) {
+        this.comparator = comparator;
+        this.backingArray = [];
+    }
+    static from(iterable, comparator = compareByValue) {
+        const list = new SortedArrayList(comparator);
+        list.backingArray = [...iterable].sort(comparator);
+        return list;
+    }
+    [Symbol.iterator]() {
+        return this.backingArray[Symbol.iterator]();
+    }
+    clear() {
+        this.backingArray = [];
+    }
+    get(index) {
+        this.verifyIndexIsInBounds(index);
+        return this.backingArray[index];
+    }
+    getFirst() {
+        return this.get(0);
+    }
+    getLast() {
+        return this.get(this.length - 1);
+    }
+    getByComparison(value) {
+        const index = this.indexOfByComparison(value);
+        return isDefined(index) ? this.get(index) : undefined;
+    }
+    getRangeByComparison(from, to) {
+        const left = this.findFirstIndexEqualOrLargerThan(from);
+        const right = this.findLastIndexEqualOrSmallerThan(to);
+        if (isUndefined(left) || isUndefined(right)) {
+            return [];
+        }
+        return this.backingArray.slice(left, right + 1);
+    }
+    set(_index, _value) {
+        throw new Error('Assignment by index not allowed in sorted collections.');
+    }
+    add(value) {
+        const index = binarySearchInsertionIndex(this.backingArray, value, this.comparator);
+        this.backingArray.splice(index, 0, value);
+    }
+    addMany(values) {
+        for (const value of values) {
+            this.add(value);
+        }
+    }
+    addAt(_index, ..._values) {
+        throw new Error('Adding at index not allowed in sorted collections.');
+    }
+    removeFirst() {
+        return this.removeAt(0);
+    }
+    removeLast() {
+        return this.removeAt(this.length - 1);
+    }
+    has(value) {
+        const index = this.indexOf(value);
+        return index != undefined;
+    }
+    hasByComparison(value) {
+        const index = this.indexOfByComparison(value);
+        return index != undefined;
+    }
+    remove(value) {
+        const index = this.indexOf(value);
+        if ((index == undefined) || (this.backingArray[index] != value)) {
+            return false;
+        }
+        this.backingArray.splice(index, 1);
+        return true;
+    }
+    removeMany(values) {
+        let counter = 0;
+        for (const value of values) {
+            const removed = this.remove(value);
+            if (removed) {
+                counter++;
+            }
+        }
+        return counter;
+    }
+    removeAt(index) {
+        this.verifyIndexIsInBounds(index);
+        return this.backingArray.splice(index, 1)[0];
+    }
+    removeRange(index, count) {
+        this.verifyIndexIsInBounds(index);
+        this.verifyIndexIsInBounds(index + count - 1);
+        return this.backingArray.splice(index, count);
+    }
+    removeRangeByComparison(from, to) {
+        const left = this.findFirstIndexEqualOrLargerThan(from);
+        const right = this.findLastIndexEqualOrSmallerThan(to);
+        if (isUndefined(left) || isUndefined(right)) {
+            return [];
+        }
+        return this.removeRange(left, (right - left) + 1);
+    }
+    indexOf(value) {
+        const left = this.findFirstIndexEqualOrLargerThan(value);
+        const right = this.findLastIndexEqualOrSmallerThan(value);
+        if (isUndefined(left) || isUndefined(right)) {
+            return undefined;
+        }
+        for (let i = left; i <= right; i++) {
+            if (this.backingArray[i] == value) {
+                return i;
+            }
+        }
+        return undefined;
+    }
+    lastIndexOf(value) {
+        const left = this.findFirstIndexEqualOrLargerThan(value);
+        const right = this.findLastIndexEqualOrSmallerThan(value);
+        if (isUndefined(left) || isUndefined(right)) {
+            return undefined;
+        }
+        for (let i = right; i >= left; i--) {
+            if (this.backingArray[i] == value) {
+                return i;
+            }
+        }
+        return undefined;
+    }
+    indexOfByComparison(value) {
+        return binarySearch(this.backingArray, value, this.comparator);
+    }
+    firstIndexOfByComparison(value) {
+        return binarySearchFirst(this.backingArray, value, this.comparator);
+    }
+    lastIndexOfByComparison(value) {
+        return binarySearchLast(this.backingArray, value, this.comparator);
+    }
+    findFirstIndexEqualOrLargerThan(value) {
+        return binarySearchFirstIndexEqualOrLarger(this.backingArray, value, this.comparator);
+    }
+    findLastIndexEqualOrSmallerThan(value) {
+        return binarySearchLastIndexEqualOrSmaller(this.backingArray, value, this.comparator);
+    }
+    verifyIndexIsInBounds(index) {
+        if ((index < 0) || (index > (this.backingArray.length - 1))) {
+            throw new Error('Index out of bounds.');
+        }
+    }
 }

package/collections/sorted-list.js

@@ -1,16 +1 @@
-"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 sorted_list_exports = {};
-module.exports = __toCommonJS(sorted_list_exports);
+export {};

package/collections/sorted-map.js

@@ -1,99 +1,76 @@
-"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 sorted_map_exports = {};
-__export(sorted_map_exports, {
-  SortedMap: () => SortedMap
-});
-module.exports = __toCommonJS(sorted_map_exports);
-var import_comparison = require("../utils/comparison.js");
-var import_map = require("../utils/iterable-helpers/map.js");
-var import_sorted_array_list = require("./sorted-array-list.js");
-class SortedMap {
-  comparator;
-  backingMap;
-  backingSortedArray;
-  get size() {
-    return this.backingSortedArray.length;
-  }
-  constructor(comparator = import_comparison.compareByValue) {
-    this.comparator = ([key1], [key2]) => comparator(key1, key2);
-    this.backingMap = /* @__PURE__ */ new Map();
-    this.backingSortedArray = new import_sorted_array_list.SortedArrayList(this.comparator);
-  }
-  [Symbol.iterator]() {
-    return this.backingSortedArray[Symbol.iterator]();
-  }
-  *keys() {
-    yield* (0, import_map.map)(this.backingSortedArray, ([key]) => key);
-  }
-  *values() {
-    yield* (0, import_map.map)(this.backingSortedArray, ([, value]) => value);
-  }
-  clear() {
-    this.backingSortedArray.clear();
-    this.backingMap.clear();
-  }
-  set(key, value) {
-    const item = [key, value];
-    this.backingMap.set(key, item);
-    this.backingSortedArray.add(item);
-  }
-  get(key) {
-    return this.backingMap.get(key)?.[1];
-  }
-  has(key) {
-    return this.backingMap.has(key);
-  }
-  delete(key) {
-    const item = this.backingMap.get(key);
-    if (item == void 0) {
-      return void 0;
+import { compareByValue } from '../utils/comparison.js';
+import { map } from '../utils/iterable-helpers/map.js';
+import { SortedArrayList } from './sorted-array-list.js';
+export class SortedMap {
+    comparator;
+    backingMap;
+    backingSortedArray;
+    get size() {
+        return this.backingSortedArray.length;
     }
-    this.backingMap.delete(key);
-    this.backingSortedArray.remove(item);
-    return item[1];
-  }
-  removeAt(index) {
-    const item = this.backingSortedArray.removeAt(index);
-    this.backingMap.delete(item[0]);
-    return item;
-  }
-  removeRange(index, count) {
-    if (index < 0 || index + count > this.backingSortedArray.length - 1) {
-      throw new Error("Out of bounds.");
+    constructor(comparator = compareByValue) {
+        this.comparator = ([key1], [key2]) => comparator(key1, key2);
+        this.backingMap = new Map();
+        this.backingSortedArray = new SortedArrayList(this.comparator);
     }
-    const items = this.backingSortedArray.removeRange(index, count);
-    for (const [key] of items) {
-      this.backingMap.delete(key);
+    [Symbol.iterator]() {
+        return this.backingSortedArray[Symbol.iterator]();
     }
-    return items;
-  }
-  removeRangeByComparison(from, to) {
-    const left = this.backingSortedArray.findFirstIndexEqualOrLargerThan([from, void 0]);
-    const right = this.backingSortedArray.findLastIndexEqualOrSmallerThan([to, void 0]);
-    if (left != void 0 && right != void 0) {
-      const items = this.backingSortedArray.removeRange(left, right - left + 1);
-      for (const [key] of items) {
+    *keys() {
+        yield* map(this.backingSortedArray, ([key]) => key);
+    }
+    *values() {
+        yield* map(this.backingSortedArray, ([, value]) => value);
+    }
+    clear() {
+        this.backingSortedArray.clear();
+        this.backingMap.clear();
+    }
+    set(key, value) {
+        const item = [key, value];
+        this.backingMap.set(key, item);
+        this.backingSortedArray.add(item);
+    }
+    get(key) {
+        return this.backingMap.get(key)?.[1];
+    }
+    has(key) {
+        return this.backingMap.has(key);
+    }
+    delete(key) {
+        const item = this.backingMap.get(key);
+        if (item == undefined) {
+            return undefined;
+        }
         this.backingMap.delete(key);
-      }
-      return items;
+        this.backingSortedArray.remove(item);
+        return item[1];
+    }
+    removeAt(index) {
+        const item = this.backingSortedArray.removeAt(index);
+        this.backingMap.delete(item[0]);
+        return item;
+    }
+    removeRange(index, count) {
+        if (index < 0 || (index + count) > (this.backingSortedArray.length - 1)) {
+            throw new Error('Out of bounds.');
+        }
+        const items = this.backingSortedArray.removeRange(index, count);
+        for (const [key] of items) {
+            this.backingMap.delete(key);
+        }
+        return items;
+    }
+    removeRangeByComparison(from, to) {
+        const left = this.backingSortedArray.findFirstIndexEqualOrLargerThan([from, undefined]);
+        const right = this.backingSortedArray.findLastIndexEqualOrSmallerThan([to, undefined]);
+        if (left != undefined && right != undefined) {
+            const items = this.backingSortedArray.removeRange(left, (right - left) + 1);
+            for (const [key] of items) {
+                this.backingMap.delete(key);
+            }
+            return items;
+        }
+        return [];
     }
-    return [];
-  }
 }

package/container/decorators.js

@@ -1,34 +1 @@
-"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: () => import_decorators.ForwardArg,
-  forwardRef: () => import_decorators.ForwardRef,
-  inject: () => import_decorators.Inject,
-  injectArg: () => import_decorators.InjectArg,
-  injectable: () => import_decorators.Injectable,
-  optional: () => import_decorators.Optional,
-  replaceClass: () => import_decorators.ReplaceClass,
-  resolveArg: () => import_decorators.ResolveArg,
-  resolveArgProvider: () => import_decorators.ResolveArgProvider,
-  scoped: () => import_decorators.Scoped,
-  singleton: () => import_decorators.Singleton
-});
-module.exports = __toCommonJS(decorators_exports);
-var import_decorators = require("../injector/decorators.js");
+export { ForwardArg as forwardArg, ForwardRef as forwardRef, Inject as inject, InjectArg as injectArg, Injectable as injectable, Optional as optional, ReplaceClass as replaceClass, ResolveArg as resolveArg, ResolveArgProvider as resolveArgProvider, Scoped as scoped, Singleton as singleton } from '../injector/decorators.js';

package/container/index.js

@@ -1,20 +1,3 @@
-"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("./decorators.js"), module.exports);
-__reExport(container_exports, require("./interfaces.js"), module.exports);
-__reExport(container_exports, require("./token.js"), module.exports);
+export * from './decorators.js';
+export * from './interfaces.js';
+export * from './token.js';

package/container/interfaces.js

@@ -1,25 +1 @@
-"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: () => import_interfaces.afterResolve,
-  resolveArgumentType: () => import_interfaces.resolveArgumentType
-});
-module.exports = __toCommonJS(interfaces_exports);
-var import_interfaces = require("../injector/interfaces.js");
+export { afterResolve, resolveArgumentType } from '../injector/interfaces.js';

package/container/token.js

@@ -1,26 +1 @@
-"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: () => import_token.ReifyingInjectionToken,
-  getTokenName: () => import_token.getTokenName,
-  injectionToken: () => import_token.injectionToken
-});
-module.exports = __toCommonJS(token_exports);
-var import_token = require("../injector/token.js");
+export { ReifyingInjectionToken, getTokenName, injectionToken } from '../injector/token.js';