@tstdl/base 0.87.13 → 0.88.0-alpha1

package/data-structures/multi-key-set.js

@@ -1,81 +1,58 @@
-"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 multi_key_set_exports = {};
-__export(multi_key_set_exports, {
-  MultiKeySet: () => MultiKeySet
-});
-module.exports = __toCommonJS(multi_key_set_exports);
-var import_distinct_collection = require("./distinct-collection.js");
-var import_multi_key_map = require("./multi-key-map.js");
-class MultiKeySet extends import_distinct_collection.DistinctCollection {
-  #map;
-  [Symbol.toStringTag] = "MultiKeySet";
-  constructor(newMapProvider) {
-    super();
-    this.#map = new import_multi_key_map.MultiKeyMap(newMapProvider);
-  }
-  includes(value) {
-    return this.#map.has(value);
-  }
-  addFlat(...value) {
-    this.#map.set(value, true);
-    this.updateSize();
-  }
-  add(value) {
-    this.#map.set(value, true);
-    this.updateSize();
-  }
-  addMany(values) {
-    for (const value of values) {
-      this.#map.set(value, true);
+import { DistinctCollection } from './distinct-collection.js';
+import { MultiKeyMap } from './multi-key-map.js';
+export class MultiKeySet extends DistinctCollection {
+    #map;
+    [Symbol.toStringTag] = 'MultiKeySet';
+    constructor(newMapProvider) {
+        super();
+        this.#map = new MultiKeyMap(newMapProvider);
+    }
+    includes(value) {
+        return this.#map.has(value);
+    }
+    addFlat(...value) {
+        this.#map.set(value, true);
+        this.updateSize();
+    }
+    add(value) {
+        this.#map.set(value, true);
+        this.updateSize();
+    }
+    addMany(values) {
+        for (const value of values) {
+            this.#map.set(value, true);
+        }
+        this.updateSize();
+    }
+    hasFlat(...value) {
+        return this.#map.has(value);
+    }
+    has(value) {
+        return this.#map.has(value);
+    }
+    deleteFlat(...value) {
+        const deleted = this.#map.delete(value);
+        this.updateSize();
+        return deleted;
+    }
+    delete(value) {
+        const deleted = this.#map.delete(value);
+        this.updateSize();
+        return deleted;
+    }
+    clone() {
+        const clone = new MultiKeySet();
+        clone.addMany(this);
+        return clone;
+    }
+    items() {
+        return this.#map.keys();
+    }
+    _clear() {
+        this.#map.clear();
+        this.updateSize();
+    }
+    updateSize() {
+        this.setSize(this.#map.size);
     }
-    this.updateSize();
-  }
-  hasFlat(...value) {
-    return this.#map.has(value);
-  }
-  has(value) {
-    return this.#map.has(value);
-  }
-  deleteFlat(...value) {
-    const deleted = this.#map.delete(value);
-    this.updateSize();
-    return deleted;
-  }
-  delete(value) {
-    const deleted = this.#map.delete(value);
-    this.updateSize();
-    return deleted;
-  }
-  clone() {
-    const clone = new MultiKeySet();
-    clone.addMany(this);
-    return clone;
-  }
-  items() {
-    return this.#map.keys();
-  }
-  _clear() {
-    this.#map.clear();
-    this.updateSize();
-  }
-  updateSize() {
-    this.setSize(this.#map.size);
-  }
 }

package/data-structures/set-collection.js

@@ -1,79 +1,56 @@
-"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 set_collection_exports = {};
-__export(set_collection_exports, {
-  SetCollection: () => SetCollection
-});
-module.exports = __toCommonJS(set_collection_exports);
-var import_distinct_collection = require("./distinct-collection.js");
-class SetCollection extends import_distinct_collection.DistinctCollection {
-  backingSet;
-  [Symbol.toStringTag] = "Set";
-  constructor(items) {
-    super();
-    this.backingSet = new globalThis.Set(items);
-    this.updateSize();
-  }
-  includes(item) {
-    return this.has(item);
-  }
-  add(item) {
-    this.backingSet.add(item);
-    this.updateSize();
-    return this;
-  }
-  addMany(items) {
-    for (const item of items) {
-      this.backingSet.add(item);
+import { DistinctCollection } from './distinct-collection.js';
+export class SetCollection extends DistinctCollection {
+    backingSet;
+    [Symbol.toStringTag] = 'Set';
+    constructor(items) {
+        super();
+        this.backingSet = new globalThis.Set(items);
+        this.updateSize();
+    }
+    includes(item) {
+        return this.has(item);
+    }
+    add(item) {
+        this.backingSet.add(item);
+        this.updateSize();
+        return this;
+    }
+    addMany(items) {
+        for (const item of items) {
+            this.backingSet.add(item);
+        }
+        this.updateSize();
+    }
+    clone() {
+        return new SetCollection(this);
+    }
+    items() {
+        return this.backingSet.values();
+    }
+    delete(item) {
+        const result = this.backingSet.delete(item);
+        this.updateSize();
+        return result;
+    }
+    forEach(callbackfn, thisArg) {
+        this.backingSet.forEach(callbackfn, thisArg);
+    }
+    has(item) {
+        return this.backingSet.has(item);
+    }
+    entries() {
+        return this.backingSet.entries();
+    }
+    keys() {
+        return this.backingSet.keys();
+    }
+    values() {
+        return this.backingSet.values();
+    }
+    _clear() {
+        this.backingSet.clear();
+    }
+    updateSize() {
+        this.setSize(this.backingSet.size);
     }
-    this.updateSize();
-  }
-  clone() {
-    return new SetCollection(this);
-  }
-  items() {
-    return this.backingSet.values();
-  }
-  delete(item) {
-    const result = this.backingSet.delete(item);
-    this.updateSize();
-    return result;
-  }
-  forEach(callbackfn, thisArg) {
-    this.backingSet.forEach(callbackfn, thisArg);
-  }
-  has(item) {
-    return this.backingSet.has(item);
-  }
-  entries() {
-    return this.backingSet.entries();
-  }
-  keys() {
-    return this.backingSet.keys();
-  }
-  values() {
-    return this.backingSet.values();
-  }
-  _clear() {
-    this.backingSet.clear();
-  }
-  updateSize() {
-    this.setSize(this.backingSet.size);
-  }
 }

package/data-structures/sorted-array-list.js

@@ -1,172 +1,146 @@
-"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 __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-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_not_implemented_error = require("../error/not-implemented.error.js");
-var import_serializable = require("../serializer/serializable.js");
-var import_binary_search = require("../utils/binary-search.js");
-var import_comparison = require("../utils/comparison.js");
-var import_type_guards = require("../utils/type-guards.js");
-var import_list = require("./list.js");
-var __decorate = function(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
-    r = Reflect.decorate(decorators, target, key, desc);
-  else
-    for (var i = decorators.length - 1; i >= 0; i--)
-      if (d = decorators[i])
-        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = function(k, v) {
-  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
-    return Reflect.metadata(k, v);
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 var SortedArrayList_1;
-let SortedArrayList = SortedArrayList_1 = class SortedArrayList2 extends import_list.List {
-  comparator;
-  backingArray;
-  constructor(items = [], comparator = import_comparison.compareByValue) {
-    super();
-    this.comparator = comparator;
-    this.backingArray = [...items].sort(comparator);
-    this.updateSize();
-  }
-  /**
-   * creates a new {@link SortedArrayList} from existing *sorted* array without copying data.
-   * If an unsorted array is provided, behaviour is undefined
-   * @param array array to use as new backing array for this {@link SortedArrayList}
-   */
-  static fromSortedArray(array) {
-    const sortedArrayList = new SortedArrayList_1();
-    sortedArrayList.backingArray = array;
-    sortedArrayList.updateSize();
-    return sortedArrayList;
-  }
-  [import_serializable.Serializable.serialize](instance) {
-    return instance.backingArray;
-  }
-  [import_serializable.Serializable.deserialize](data, tryDereference) {
-    for (let i = 0; i < data.length; i++) {
-      tryDereference(data[i], (dereferenced) => data[i] = dereferenced);
-    }
-    return SortedArrayList_1.fromSortedArray(data);
-  }
-  _at(index) {
-    return this.backingArray[index];
-  }
-  /** find index of item, can be any occurrence of it */
-  fastIndexOf(item, fromIndex) {
-    return (0, import_binary_search.binarySearch)(this.backingArray, item, this.comparator, { min: fromIndex });
-  }
-  _indexOf(item, fromIndex) {
-    return (0, import_binary_search.binarySearchFirst)(this.backingArray, item, this.comparator, { min: fromIndex });
-  }
-  findIndex(predicate) {
-    return this.backingArray.findIndex((item, index) => predicate(item, index));
-  }
-  _lastIndexOf(item, fromIndex) {
-    return (0, import_binary_search.binarySearchLast)(this.backingArray, item, this.comparator, { max: fromIndex });
-  }
-  findLastIndex(predicate) {
-    for (let i = this.size - 1; i >= 0; i--) {
-      if (predicate(this.backingArray[i], i)) {
-        return i;
-      }
-    }
-    return void 0;
-  }
-  includes(item) {
-    const index = this.fastIndexOf(item);
-    return (0, import_type_guards.isDefined)(index);
-  }
-  /** same as {@link add} as it is sorted */
-  prepend(item) {
-    this.add(item);
-  }
-  /** same as {@link addMany} as it is sorted */
-  prependMany(items) {
-    this.addMany(items);
-  }
-  add(item) {
-    const index = (0, import_binary_search.binarySearchInsertionIndex)(this.backingArray, item, this.comparator);
-    this.backingArray.splice(index, 0, item);
-    this.updateSize();
-  }
-  addMany(items) {
-    for (const item of items) {
-      const index = (0, import_binary_search.binarySearchInsertionIndex)(this.backingArray, item, this.comparator);
-      this.backingArray.splice(index, 0, item);
-    }
-    this.updateSize();
-  }
-  /** same as `removeAt(index); add(item);` as it is sorted */
-  _set(index, item) {
-    this.backingArray.splice(index, 1);
-    this.add(item);
-  }
-  remove(item) {
-    const index = this.indexOf(item);
-    if ((0, import_type_guards.isUndefined)(index)) {
-      return false;
-    }
-    this.removeAt(index);
-    return true;
-  }
-  _removeAt(index) {
-    return this.removeManyAt(index, 1)[0];
-  }
-  _removeManyAt(index, count) {
-    const removed = this.backingArray.splice(index, count);
-    this.updateSize();
-    return removed;
-  }
-  /**
-   * remove items
-   * @param from
-   * @param to
-   */
-  removeRangeByComparison(_from, _fromType, _to, _toType) {
-    throw new import_not_implemented_error.NotImplementedError();
-  }
-  clone() {
-    return SortedArrayList_1.fromSortedArray([...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);
-  }
+/* eslint-disable @typescript-eslint/member-ordering */
+import { NotImplementedError } from '../error/not-implemented.error.js';
+import { Serializable, serializable } from '../serializer/serializable.js';
+import { binarySearch, binarySearchFirst, binarySearchInsertionIndex, binarySearchLast } from '../utils/binary-search.js';
+import { compareByValue } from '../utils/comparison.js';
+import { isDefined, isUndefined } from '../utils/type-guards.js';
+import { List } from './list.js';
+let SortedArrayList = SortedArrayList_1 = class SortedArrayList extends List {
+    comparator;
+    backingArray;
+    constructor(items = [], comparator = compareByValue) {
+        super();
+        this.comparator = comparator;
+        this.backingArray = [...items].sort(comparator);
+        this.updateSize();
+    }
+    /**
+     * creates a new {@link SortedArrayList} from existing *sorted* array without copying data.
+     * If an unsorted array is provided, behaviour is undefined
+     * @param array array to use as new backing array for this {@link SortedArrayList}
+     */
+    static fromSortedArray(array) {
+        const sortedArrayList = new SortedArrayList_1();
+        sortedArrayList.backingArray = array;
+        sortedArrayList.updateSize();
+        return sortedArrayList;
+    }
+    [Serializable.serialize](instance) {
+        return instance.backingArray;
+    }
+    [Serializable.deserialize](data, tryDereference) {
+        for (let i = 0; i < data.length; i++) {
+            tryDereference(data[i], (dereferenced) => (data[i] = dereferenced));
+        }
+        return SortedArrayList_1.fromSortedArray(data);
+    }
+    _at(index) {
+        return this.backingArray[index];
+    }
+    /** find index of item, can be any occurrence of it */
+    fastIndexOf(item, fromIndex) {
+        return binarySearch(this.backingArray, item, this.comparator, { min: fromIndex });
+    }
+    _indexOf(item, fromIndex) {
+        return binarySearchFirst(this.backingArray, item, this.comparator, { min: fromIndex });
+    }
+    findIndex(predicate) {
+        return this.backingArray.findIndex((item, index) => predicate(item, index));
+    }
+    _lastIndexOf(item, fromIndex) {
+        return binarySearchLast(this.backingArray, item, this.comparator, { max: fromIndex });
+    }
+    findLastIndex(predicate) {
+        for (let i = this.size - 1; i >= 0; i--) {
+            if (predicate(this.backingArray[i], i)) {
+                return i;
+            }
+        }
+        return undefined;
+    }
+    includes(item) {
+        const index = this.fastIndexOf(item);
+        return isDefined(index);
+    }
+    /** same as {@link add} as it is sorted */
+    prepend(item) {
+        this.add(item);
+    }
+    /** same as {@link addMany} as it is sorted */
+    prependMany(items) {
+        this.addMany(items);
+    }
+    add(item) {
+        const index = binarySearchInsertionIndex(this.backingArray, item, this.comparator);
+        this.backingArray.splice(index, 0, item);
+        this.updateSize();
+    }
+    addMany(items) {
+        for (const item of items) {
+            const index = binarySearchInsertionIndex(this.backingArray, item, this.comparator);
+            this.backingArray.splice(index, 0, item);
+        }
+        this.updateSize();
+    }
+    /** same as `removeAt(index); add(item);` as it is sorted */
+    _set(index, item) {
+        this.backingArray.splice(index, 1);
+        this.add(item);
+    }
+    remove(item) {
+        const index = this.indexOf(item);
+        if (isUndefined(index)) {
+            return false;
+        }
+        this.removeAt(index);
+        return true;
+    }
+    _removeAt(index) {
+        return this.removeManyAt(index, 1)[0];
+    }
+    _removeManyAt(index, count) {
+        const removed = this.backingArray.splice(index, count);
+        this.updateSize();
+        return removed;
+    }
+    /**
+     * remove items
+     * @param from
+     * @param to
+     */
+    removeRangeByComparison(_from, _fromType, _to, _toType) {
+        throw new NotImplementedError();
+    }
+    clone() {
+        return SortedArrayList_1.fromSortedArray([...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);
+    }
 };
 SortedArrayList = SortedArrayList_1 = __decorate([
-  (0, import_serializable.serializable)("SortedArrayList"),
-  __metadata("design:paramtypes", [Object, Function])
+    serializable('SortedArrayList'),
+    __metadata("design:paramtypes", [Object, Function])
 ], SortedArrayList);
+export { SortedArrayList };