@tstdl/base 0.87.13 → 0.88.0-alpha1

package/data-structures/list.js

@@ -1,115 +1,92 @@
-"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 list_exports = {};
-__export(list_exports, {
-  List: () => List
-});
-module.exports = __toCommonJS(list_exports);
-var import_type_guards = require("../utils/type-guards.js");
-var import_collection = require("./collection.js");
-var import_index_out_of_bounds_error = require("./index-out-of-bounds.error.js");
-class List extends import_collection.Collection {
-  /** get item at index */
-  at(index) {
-    const normalizedIndex = this.normalizeIndex(index);
-    this.ensureBounds(normalizedIndex);
-    return this._at(normalizedIndex);
-  }
-  /**
-   * find index of first occurrence of item
-   * @param item item to search for
-   * @param fromIndex index to start search at
-   */
-  indexOf(item, fromIndex) {
-    return this._indexOf(item, (0, import_type_guards.isDefined)(fromIndex) ? this.normalizeIndex(fromIndex) : fromIndex);
-  }
-  /** index of item (last occurrence) */
-  /**
-   * find index of last occurrence of item
-   * @param item item to search for
-   * @param fromIndex index to start from (backwards)
-   */
-  lastIndexOf(item, fromIndex) {
-    return this._lastIndexOf(item, (0, import_type_guards.isDefined)(fromIndex) ? this.normalizeIndex(fromIndex) : fromIndex);
-  }
-  /** set item at index */
-  set(index, item) {
-    const normalizedIndex = this.normalizeIndex(index);
-    this.ensureBounds(normalizedIndex);
-    this._set(normalizedIndex, item);
-  }
-  /** remove item at index */
-  removeAt(index) {
-    const normalizedIndex = this.normalizeIndex(index);
-    this.ensureBounds(normalizedIndex);
-    return this._removeAt(normalizedIndex);
-  }
-  /** remove first item */
-  removeFirst() {
-    return this.removeAt(0);
-  }
-  /** remove last item */
-  removeLast() {
-    return this.removeAt(-1);
-  }
-  /**
-   * remove many items at index
-   * @param index index to start removing at
-   * @param count how many items to remove. If not defined, all items starting at `index` are removed
-   */
-  removeManyAt(index, count = this.size - index) {
-    const normalizedIndex = this.normalizeIndex(index);
-    this.ensureBounds(normalizedIndex, count);
-    return this._removeManyAt(normalizedIndex, count);
-  }
-  /**
-   * remove range of items at `fromIndex` to `toIndex`
-   * @param fromIndex index to start removing at
-   * @param toIndex index to remove to
-   */
-  removeRange(fromIndex, toIndex) {
-    const from = this.normalizeIndex(fromIndex);
-    const to = this.normalizeIndex(toIndex);
-    const count = 1 + (to - from);
-    if (count < 1) {
-      throw new Error("toIndex can't be less than fromIndex");
+import { isDefined } from '../utils/type-guards.js';
+import { Collection } from './collection.js';
+import { IndexOutOfBoundsError } from './index-out-of-bounds.error.js';
+export class List extends Collection {
+    /** get item at index */
+    at(index) {
+        const normalizedIndex = this.normalizeIndex(index);
+        this.ensureBounds(normalizedIndex);
+        return this._at(normalizedIndex);
     }
-    return this._removeManyAt(from, count);
-  }
-  ensureBounds(index, count) {
-    if (index < 0 || index > this.size - 1) {
-      throw new import_index_out_of_bounds_error.IndexOutOfBoundsError({ index, count, size: this.size });
+    /**
+     * find index of first occurrence of item
+     * @param item item to search for
+     * @param fromIndex index to start search at
+     */
+    indexOf(item, fromIndex) {
+        return this._indexOf(item, isDefined(fromIndex) ? this.normalizeIndex(fromIndex) : fromIndex);
     }
-    if ((0, import_type_guards.isDefined)(count) && count < 0) {
-      throw new Error("count can't be negative");
+    /** index of item (last occurrence) */
+    /**
+     * find index of last occurrence of item
+     * @param item item to search for
+     * @param fromIndex index to start from (backwards)
+     */
+    lastIndexOf(item, fromIndex) {
+        return this._lastIndexOf(item, isDefined(fromIndex) ? this.normalizeIndex(fromIndex) : fromIndex);
     }
-    if ((0, import_type_guards.isDefined)(count)) {
-      const endIndex = index + (count - 1);
-      if (endIndex < 0 || endIndex > this.size - 1) {
-        throw new import_index_out_of_bounds_error.IndexOutOfBoundsError({ index, count, size: this.size });
-      }
+    /** set item at index */
+    set(index, item) {
+        const normalizedIndex = this.normalizeIndex(index);
+        this.ensureBounds(normalizedIndex);
+        this._set(normalizedIndex, item);
     }
-  }
-  normalizeIndex(index) {
-    if (index < 0) {
-      return this.size + index;
+    /** remove item at index */
+    removeAt(index) {
+        const normalizedIndex = this.normalizeIndex(index);
+        this.ensureBounds(normalizedIndex);
+        return this._removeAt(normalizedIndex);
+    }
+    /** remove first item */
+    removeFirst() {
+        return this.removeAt(0);
+    }
+    /** remove last item */
+    removeLast() {
+        return this.removeAt(-1);
+    }
+    /**
+     * remove many items at index
+     * @param index index to start removing at
+     * @param count how many items to remove. If not defined, all items starting at `index` are removed
+     */
+    removeManyAt(index, count = this.size - index) {
+        const normalizedIndex = this.normalizeIndex(index);
+        this.ensureBounds(normalizedIndex, count);
+        return this._removeManyAt(normalizedIndex, count);
+    }
+    /**
+     * remove range of items at `fromIndex` to `toIndex`
+     * @param fromIndex index to start removing at
+     * @param toIndex index to remove to
+     */
+    removeRange(fromIndex, toIndex) {
+        const from = this.normalizeIndex(fromIndex);
+        const to = this.normalizeIndex(toIndex);
+        const count = 1 + (to - from);
+        if (count < 1) {
+            throw new Error('toIndex can\'t be less than fromIndex');
+        }
+        return this._removeManyAt(from, count);
+    }
+    ensureBounds(index, count) {
+        if ((index < 0) || (index > (this.size - 1))) {
+            throw new IndexOutOfBoundsError({ index, count, size: this.size });
+        }
+        if (isDefined(count) && (count < 0)) {
+            throw new Error('count can\'t be negative');
+        }
+        if (isDefined(count)) {
+            const endIndex = index + (count - 1);
+            if ((endIndex < 0) || (endIndex > (this.size - 1))) {
+                throw new IndexOutOfBoundsError({ index, count, size: this.size });
+            }
+        }
+    }
+    normalizeIndex(index) {
+        if (index < 0) {
+            return this.size + index;
+        }
+        return index;
     }
-    return index;
-  }
 }

package/data-structures/map-dictionary.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 map_dictionary_exports = {};
-__export(map_dictionary_exports, {
-  MapDictionary: () => MapDictionary
-});
-module.exports = __toCommonJS(map_dictionary_exports);
-var import_dictionary = require("./dictionary.js");
-class MapDictionary extends import_dictionary.Dictionary {
-  backingMap;
-  [Symbol.toStringTag] = "MapDictionary";
-  constructor(items) {
-    super();
-    this.backingMap = new Map(items);
-    this.updateSize();
-  }
-  has(key) {
-    return this.backingMap.has(key);
-  }
-  get(key) {
-    return this.backingMap.get(key);
-  }
-  set(key, value) {
-    this.backingMap.set(key, value);
-    this.updateSize();
-  }
-  delete(key) {
-    const result = this.backingMap.delete(key);
-    this.updateSize();
-    return result;
-  }
-  includes([key, value]) {
-    if (!this.has(key)) {
-      return false;
+import { Dictionary } from './dictionary.js';
+export class MapDictionary extends Dictionary {
+    backingMap;
+    [Symbol.toStringTag] = 'MapDictionary';
+    constructor(items) {
+        super();
+        this.backingMap = new Map(items);
+        this.updateSize();
     }
-    return this.get(key) == value;
-  }
-  add(item) {
-    this.set(item[0], item[1]);
-  }
-  addMany(items) {
-    for (const item of items) {
-      this.backingMap.set(item[0], item[1]);
+    has(key) {
+        return this.backingMap.has(key);
+    }
+    get(key) {
+        return this.backingMap.get(key);
+    }
+    set(key, value) {
+        this.backingMap.set(key, value);
+        this.updateSize();
+    }
+    delete(key) {
+        const result = this.backingMap.delete(key);
+        this.updateSize();
+        return result;
+    }
+    includes([key, value]) {
+        if (!this.has(key)) {
+            return false;
+        }
+        return this.get(key) == value;
+    }
+    add(item) {
+        this.set(item[0], item[1]);
+    }
+    addMany(items) {
+        for (const item of items) {
+            this.backingMap.set(item[0], item[1]);
+        }
+        this.updateSize();
+    }
+    clone() {
+        return new MapDictionary(this);
+    }
+    items() {
+        return this.backingMap.entries();
+    }
+    keys() {
+        return this.backingMap.keys();
+    }
+    values() {
+        return this.backingMap.values();
+    }
+    _clear() {
+        this.backingMap.clear();
+    }
+    updateSize() {
+        this.setSize(this.backingMap.size);
     }
-    this.updateSize();
-  }
-  clone() {
-    return new MapDictionary(this);
-  }
-  items() {
-    return this.backingMap.entries();
-  }
-  keys() {
-    return this.backingMap.keys();
-  }
-  values() {
-    return this.backingMap.values();
-  }
-  _clear() {
-    this.backingMap.clear();
-  }
-  updateSize() {
-    this.setSize(this.backingMap.size);
-  }
 }

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

@@ -1,169 +1,147 @@
-"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_map_exports = {};
-__export(multi_key_map_exports, {
-  MultiKeyMap: () => MultiKeyMap
-});
-module.exports = __toCommonJS(multi_key_map_exports);
-var import_type_guards = require("../utils/type-guards.js");
-var import_circular_buffer = require("./circular-buffer.js");
-var import_dictionary = require("./dictionary.js");
-class MultiKeyMap extends import_dictionary.Dictionary {
-  newMapProvider;
-  rootNode;
-  [Symbol.toStringTag] = "MultiKeyMap";
-  constructor(newMapProvider = () => /* @__PURE__ */ new Map()) {
-    super();
-    this.newMapProvider = newMapProvider;
-    this.rootNode = createNode(void 0, void 0);
-  }
-  includes([key, value]) {
-    if (!this.has(key)) {
-      return false;
-    }
-    return this.get(key) == value;
-  }
-  add(value) {
-    this.set(value[0], value[1]);
-  }
-  addMany(values) {
-    for (const value of values) {
-      this.set(value[0], value[1]);
-    }
-  }
-  setFlat(...keyAndValue) {
-    const key = keyAndValue.slice(0, -1);
-    this.set(key, keyAndValue[keyAndValue.length - 1]);
-  }
-  set(key, value) {
-    const node = this.getNode(key, true);
-    node.value = value;
-    if (!node.hasValue) {
-      node.hasValue = true;
-      this.incrementSize();
-    } else {
-      this.emitChange();
-    }
-  }
-  hasFlat(...key) {
-    return this.has(key);
-  }
-  has(key) {
-    const node = this.getNode(key);
-    return (0, import_type_guards.isDefined)(node) && node.hasValue;
-  }
-  getFlat(...key) {
-    return this.get(key);
-  }
-  get(key) {
-    const node = this.getNode(key);
-    if ((0, import_type_guards.isUndefined)(node)) {
-      return void 0;
-    }
-    return node.value;
-  }
-  deleteFlat(...key) {
-    return this.delete(key);
-  }
-  delete(key) {
-    const node = this.getNode(key);
-    if ((0, import_type_guards.isUndefined)(node)) {
-      return false;
-    }
-    const deleted = node.hasValue;
-    node.hasValue = false;
-    node.value = void 0;
-    this.deleteNodeIfEmpty(node);
-    if (deleted) {
-      this.decrementSize();
-    }
-    return deleted;
-  }
-  clone() {
-    const clone = new MultiKeyMap();
-    clone.addMany(this);
-    return clone;
-  }
-  *keys() {
-    for (const item of this) {
-      yield item[0];
-    }
-  }
-  *values() {
-    for (const item of this) {
-      yield item[1];
-    }
-  }
-  *items() {
-    const queue = new import_circular_buffer.CircularBuffer();
-    queue.add([[], this.rootNode]);
-    while (queue.size > 0) {
-      const [key, node] = queue.remove();
-      if (node.hasValue) {
-        yield [key, node.value];
-      }
-      if ((0, import_type_guards.isDefined)(node.children)) {
-        for (const innerNode of node.children.values()) {
-          queue.add([[...key, innerNode.nodeKey], innerNode]);
+import { isDefined, isUndefined } from '../utils/type-guards.js';
+import { CircularBuffer } from './circular-buffer.js';
+import { Dictionary } from './dictionary.js';
+export class MultiKeyMap extends Dictionary {
+    newMapProvider;
+    rootNode;
+    [Symbol.toStringTag] = 'MultiKeyMap';
+    constructor(newMapProvider = () => new Map()) {
+        super();
+        this.newMapProvider = newMapProvider;
+        this.rootNode = createNode(undefined, undefined);
+    }
+    includes([key, value]) {
+        if (!this.has(key)) {
+            return false;
+        }
+        return this.get(key) == value;
+    }
+    add(value) {
+        this.set(value[0], value[1]);
+    }
+    addMany(values) {
+        for (const value of values) {
+            this.set(value[0], value[1]);
+        }
+    }
+    setFlat(...keyAndValue) {
+        const key = keyAndValue.slice(0, -1);
+        this.set(key, keyAndValue[keyAndValue.length - 1]);
+    }
+    set(key, value) {
+        const node = this.getNode(key, true);
+        node.value = value;
+        if (!node.hasValue) {
+            node.hasValue = true;
+            this.incrementSize();
+        }
+        else {
+            this.emitChange();
+        }
+    }
+    hasFlat(...key) {
+        return this.has(key);
+    }
+    has(key) {
+        const node = this.getNode(key);
+        return isDefined(node) && node.hasValue;
+    }
+    getFlat(...key) {
+        return this.get(key);
+    }
+    get(key) {
+        const node = this.getNode(key);
+        if (isUndefined(node)) {
+            return undefined;
+        }
+        return node.value;
+    }
+    deleteFlat(...key) {
+        return this.delete(key);
+    }
+    delete(key) {
+        const node = this.getNode(key);
+        if (isUndefined(node)) {
+            return false;
+        }
+        const deleted = node.hasValue;
+        node.hasValue = false;
+        node.value = undefined;
+        this.deleteNodeIfEmpty(node);
+        if (deleted) {
+            this.decrementSize();
+        }
+        return deleted;
+    }
+    clone() {
+        const clone = new MultiKeyMap();
+        clone.addMany(this);
+        return clone;
+    }
+    *keys() {
+        for (const item of this) {
+            yield item[0];
+        }
+    }
+    *values() {
+        for (const item of this) {
+            yield item[1];
         }
-      }
-    }
-  }
-  _clear() {
-    this.rootNode = createNode(void 0, void 0);
-    this.setSize(0);
-  }
-  getNode(key, create = false) {
-    let node = this.rootNode;
-    for (const nodeKey of key) {
-      if ((0, import_type_guards.isUndefined)(node.children)) {
-        if (!create) {
-          return void 0;
+    }
+    *items() {
+        const queue = new CircularBuffer();
+        queue.add([[], this.rootNode]);
+        while (queue.size > 0) {
+            const [key, node] = queue.remove();
+            if (node.hasValue) {
+                yield [key, node.value];
+            }
+            if (isDefined(node.children)) {
+                for (const innerNode of node.children.values()) {
+                    queue.add([[...key, innerNode.nodeKey], innerNode]);
+                }
+            }
         }
-        node.children = this.newMapProvider();
-      }
-      let childNode = node.children.get(nodeKey);
-      if ((0, import_type_guards.isUndefined)(childNode)) {
-        if (!create) {
-          return void 0;
+    }
+    _clear() {
+        this.rootNode = createNode(undefined, undefined);
+        this.setSize(0);
+    }
+    getNode(key, create = false) {
+        let node = this.rootNode;
+        for (const nodeKey of key) {
+            if (isUndefined(node.children)) {
+                if (!create) {
+                    return undefined;
+                }
+                node.children = this.newMapProvider();
+            }
+            let childNode = node.children.get(nodeKey);
+            if (isUndefined(childNode)) {
+                if (!create) {
+                    return undefined;
+                }
+                childNode = createNode(nodeKey, node);
+                node.children.set(nodeKey, childNode);
+            }
+            node = childNode;
         }
-        childNode = createNode(nodeKey, node);
-        node.children.set(nodeKey, childNode);
-      }
-      node = childNode;
-    }
-    return node;
-  }
-  deleteNodeIfEmpty(node) {
-    if (node.hasValue || (0, import_type_guards.isDefined)(node.children) && node.children.size > 0 || (0, import_type_guards.isUndefined)(node.parentNode)) {
-      return;
-    }
-    node.parentNode.children.delete(node.nodeKey);
-    this.deleteNodeIfEmpty(node.parentNode);
-  }
+        return node;
+    }
+    deleteNodeIfEmpty(node) {
+        if (node.hasValue || (isDefined(node.children) && (node.children.size > 0)) || isUndefined(node.parentNode)) {
+            return;
+        }
+        node.parentNode.children.delete(node.nodeKey);
+        this.deleteNodeIfEmpty(node.parentNode);
+    }
 }
 function createNode(nodeKey, parentNode) {
-  return {
-    nodeKey,
-    parentNode,
-    children: void 0,
-    hasValue: false,
-    value: void 0
-  };
+    return {
+        nodeKey,
+        parentNode,
+        children: undefined,
+        hasValue: false,
+        value: undefined
+    };
 }