@tstdl/base 0.86.0-beta1 → 0.86.0-beta10

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);
+  }
 }

package/data-structures/cache.js

@@ -1,46 +1,69 @@
-export class Cache {
-    cache;
-    _capacity;
-    get capacity() {
-        return this._capacity;
+"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 cache_exports = {};
+__export(cache_exports, {
+  Cache: () => Cache
+});
+module.exports = __toCommonJS(cache_exports);
+class Cache {
+  cache;
+  _capacity;
+  get capacity() {
+    return this._capacity;
+  }
+  set capacity(capacity) {
+    this.removeEntries(this._capacity - capacity);
+    this._capacity = capacity;
+  }
+  constructor(capacity) {
+    this._capacity = capacity;
+    this.cache = /* @__PURE__ */ new Map();
+  }
+  get(key) {
+    if (!this.cache.has(key)) {
+      return void 0;
     }
-    set capacity(capacity) {
-        this.removeEntries(this._capacity - capacity);
-        this._capacity = capacity;
+    const value = this.cache.get(key);
+    this.cache.delete(key);
+    this.cache.set(key, value);
+    return value;
+  }
+  set(key, value) {
+    const isNew = !this.cache.has(key);
+    if (isNew && this.cache.size >= this.capacity) {
+      this.removeEntries(1);
     }
-    constructor(capacity) {
-        this._capacity = capacity;
-        this.cache = new Map();
+    this.cache.set(key, value);
+  }
+  delete(key) {
+    this.delete(key);
+  }
+  removeEntries(count) {
+    if (count <= 0) {
+      return;
     }
-    get(key) {
-        if (!this.cache.has(key)) {
-            return undefined;
-        }
-        const value = this.cache.get(key);
-        this.cache.delete(key);
-        this.cache.set(key, value);
-        return value;
-    }
-    set(key, value) {
-        const isNew = !this.cache.has(key);
-        if (isNew && (this.cache.size >= this.capacity)) {
-            this.removeEntries(1);
-        }
-        this.cache.set(key, value);
-    }
-    delete(key) {
-        this.delete(key);
-    }
-    removeEntries(count) {
-        if (count <= 0) {
-            return;
-        }
-        let left = count;
-        for (const key of this.cache.keys()) {
-            if (left-- <= 0) {
-                return;
-            }
-            this.cache.delete(key);
-        }
+    let left = count;
+    for (const key of this.cache.keys()) {
+      if (left-- <= 0) {
+        return;
+      }
+      this.cache.delete(key);
     }
+  }
 }