@tstdl/base 0.86.0-beta2 → 0.86.0-beta3

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

@@ -0,0 +1,81 @@
+"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);
+    }
+    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.d.ts → set-collection.d.ts}

@@ -1,12 +1,12 @@
-import { Collection } from './collection.js';
-export declare class Set<T> extends Collection<T, Set<T>> implements globalThis.Set<T> {
+import { DistinctCollection } from './distinct-collection.js';
+export declare class SetCollection<T> extends DistinctCollection<T, SetCollection<T>> implements globalThis.Set<T> {
     private readonly backingSet;
     readonly [Symbol.toStringTag]: string;
     constructor(items?: Iterable<T>);
     includes(item: T): boolean;
     add(item: T): this;
     addMany(items: Iterable<T>): void;
-    clone(): Set<T>;
+    clone(): SetCollection<T>;
     items(): IterableIterator<T>;
     delete(item: T): boolean;
     forEach(callbackfn: (value: T, value2: T, set: globalThis.Set<T>) => void, thisArg?: any): void;

package/data-structures/set-collection.js

@@ -0,0 +1,79 @@
+"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);
+    }
+    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.d.ts

@@ -34,7 +34,7 @@ export declare class SortedArrayList<T extends TComparator, TComparator = T> ext
     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[];
     /**
      * remove items
      * @param from

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

@@ -1,148 +1,172 @@
-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;
+"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 __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+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 SortedArrayList_1;
-/* 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';
-export 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) {
-        this.ensureBounds(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.ensureBounds(index);
-        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 = this.size - index) {
-        this.ensureBounds(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);
-    }
+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);
+  }
 };
 SortedArrayList = SortedArrayList_1 = __decorate([
-    serializable('SortedArrayList'),
-    __metadata("design:paramtypes", [Object, Function])
+  (0, import_serializable.serializable)("SortedArrayList"),
+  __metadata("design:paramtypes", [Object, Function])
 ], SortedArrayList);