data-structure-typed 1.46.3 → 1.46.5

package/dist/umd/data-structure-typed.js

@@ -100,8 +100,6 @@ var dataStructureTyped = (() => {
     BinaryTreeNode: () => BinaryTreeNode,
     CP: () => CP,
     Character: () => Character,
-    CoordinateMap: () => CoordinateMap,
-    CoordinateSet: () => CoordinateSet,
     Deque: () => Deque,
     DirectedEdge: () => DirectedEdge,
     DirectedGraph: () => DirectedGraph,
@@ -142,11 +140,9 @@ var dataStructureTyped = (() => {
     SkipListNode: () => SkipListNode,
     Stack: () => Stack,
     THUNK_SYMBOL: () => THUNK_SYMBOL,
-    TreeMap: () => TreeMap,
     TreeMultimap: () => TreeMultimap,
     TreeMultimapNode: () => TreeMultimapNode,
     TreeNode: () => TreeNode,
-    TreeSet: () => TreeSet,
     Trie: () => Trie,
     TrieNode: () => TrieNode,
     UndirectedEdge: () => UndirectedEdge,
@@ -156,8 +152,8 @@ var dataStructureTyped = (() => {
     arrayRemove: () => arrayRemove,
     calcMinUnitsRequired: () => calcMinUnitsRequired,
     getMSB: () => getMSB,
-    isObjOrFunc: () => isObjOrFunc,
     isThunk: () => isThunk,
+    isWeakKey: () => isWeakKey,
     rangeCheck: () => rangeCheck,
     throwRangeError: () => throwRangeError,
     toThunk: () => toThunk,
@@ -388,110 +384,6 @@ var dataStructureTyped = (() => {
   __publicField(_HashTable, "LOAD_FACTOR", 0.75);
   var HashTable = _HashTable;
 
-  // src/data-structures/hash/coordinate-map.ts
-  var CoordinateMap = class extends Map {
-    constructor(joint) {
-      super();
-      __publicField(this, "_joint", "_");
-      if (joint !== void 0)
-        this._joint = joint;
-    }
-    get joint() {
-      return this._joint;
-    }
-    /**
-     * The "has" function overrides the base class's "has" function and checks if a key exists in the map by joining the
-     * key array with a specified delimiter.
-     * @param {number[]} key - The parameter "key" is an array of numbers.
-     * @returns The `has` method is being overridden to return the result of calling the `has` method of the superclass
-     * (`super.has`) with the `key` array joined together using the `_joint` property.
-     */
-    has(key) {
-      return super.has(key.join(this._joint));
-    }
-    /**
-     * The function overrides the set method of a Map object to convert the key from an array to a string using a specified
-     * delimiter before calling the original set method.
-     * @param {number[]} key - The key parameter is an array of numbers.
-     * @param {V} value - The value parameter is the value that you want to associate with the specified key.
-     * @returns The `set` method is returning the result of calling the `set` method of the superclass
-     * (`super.set(key.join(this._joint), value)`).
-     */
-    set(key, value) {
-      return super.set(key.join(this._joint), value);
-    }
-    /**
-     * The function overrides the get method to join the key array with a specified joint and then calls the super get
-     * method.
-     * @param {number[]} key - An array of numbers
-     * @returns The code is returning the value associated with the specified key in the map.
-     */
-    get(key) {
-      return super.get(key.join(this._joint));
-    }
-    /**
-     * The function overrides the delete method and joins the key array using a specified joint character before calling
-     * the super delete method.
-     * @param {number[]} key - An array of numbers that represents the key to be deleted.
-     * @returns The `delete` method is returning the result of calling the `delete` method on the superclass, with the
-     * `key` array joined together using the `_joint` property.
-     */
-    delete(key) {
-      return super.delete(key.join(this._joint));
-    }
-  };
-
-  // src/data-structures/hash/coordinate-set.ts
-  var CoordinateSet = class extends Set {
-    constructor(joint) {
-      super();
-      __publicField(this, "_joint", "_");
-      if (joint !== void 0)
-        this._joint = joint;
-    }
-    get joint() {
-      return this._joint;
-    }
-    /**
-     * The "has" function overrides the "has" method of the superclass and checks if a value exists in an array after
-     * joining its elements with a specified separator.
-     * @param {number[]} value - The parameter "value" is an array of numbers.
-     * @returns The overridden `has` method is returning the result of calling the `has` method of the superclass, passing
-     * in the joined value as an argument.
-     */
-    has(value) {
-      return super.has(value.join(this._joint));
-    }
-    /**
-     * The "add" function overrides the parent class's "add" function by joining the elements of the input array with a
-     * specified delimiter before calling the parent class's "add" function.
-     * @param {number[]} value - An array of numbers
-     * @returns The overridden `add` method is returning the result of calling the `add` method of the superclass
-     * (`super.add`) with the joined string representation of the `value` array (`value.join(this._joint)`).
-     */
-    add(value) {
-      return super.add(value.join(this._joint));
-    }
-    /**
-     * The function overrides the delete method and deletes an element from a Set by joining the elements of the input
-     * array with a specified joint and then calling the delete method of the parent class.
-     * @param {number[]} value - An array of numbers
-     * @returns The `delete` method is returning the result of calling the `delete` method of the superclass, with the
-     * `value` array joined together using the `_joint` property.
-     */
-    delete(value) {
-      return super.delete(value.join(this._joint));
-    }
-  };
-
-  // src/data-structures/hash/tree-map.ts
-  var TreeMap = class {
-  };
-
-  // src/data-structures/hash/tree-set.ts
-  var TreeSet = class {
-  };
-
   // src/utils/utils.ts
   var uuidV4 = function() {
     return "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx".replace(/[x]/g, function(c) {
@@ -560,33 +452,41 @@ var dataStructureTyped = (() => {
   var throwRangeError = (message = "The value is off-limits.") => {
     throw new RangeError(message);
   };
-  var isObjOrFunc = (input) => {
+  var isWeakKey = (input) => {
     const inputType = typeof input;
     return inputType === "object" && input !== null || inputType === "function";
   };
   var calcMinUnitsRequired = (totalQuantity, unitSize) => Math.floor((totalQuantity + unitSize - 1) / unitSize);
 
   // src/data-structures/hash/hash-map.ts
-  var HashMap = class {
+  var HashMap = class _HashMap {
     /**
-     * The constructor initializes a HashMap object with an optional initial set of key-value pairs.
-     * @param {Iterable<[K, V]>} elements - The `hashMap` parameter is an optional parameter of type `HashMapOptions<[K,
-     * V]>`. It is an array of key-value pairs, where each pair is represented as an array `[K, V]`. The
-     * `K` represents the type of the key and `V` represents the
+     * The constructor initializes a HashMapLinkedNode with an optional iterable of key-value pairs.
+     * @param options - The `options` parameter is an object that contains the `elements` property. The
+     * `elements` property is an iterable that contains key-value pairs represented as arrays `[K, V]`.
      */
-    constructor(elements = []) {
-      __publicField(this, "OBJ_KEY_INDEX", Symbol("OBJ_KEY_INDEX"));
-      __publicField(this, "_nodes", []);
-      __publicField(this, "_orgMap", {});
+    constructor(options = {
+      elements: [],
+      hashFn: (key) => String(key),
+      objHashFn: (key) => key
+    }) {
+      __publicField(this, "_noObjMap", {});
+      __publicField(this, "_objMap", /* @__PURE__ */ new WeakMap());
       __publicField(this, "_head");
       __publicField(this, "_tail");
       __publicField(this, "_sentinel");
+      __publicField(this, "_hashFn");
+      __publicField(this, "_objHashFn");
       __publicField(this, "_size", 0);
-      Object.setPrototypeOf(this._orgMap, null);
       this._sentinel = {};
       this._sentinel.prev = this._sentinel.next = this._head = this._tail = this._sentinel;
-      for (const el of elements) {
-        this.set(el[0], el[1]);
+      const { elements, hashFn, objHashFn } = options;
+      this._hashFn = hashFn;
+      this._objHashFn = objHashFn;
+      if (elements) {
+        for (const el of elements) {
+          this.set(el[0], el[1]);
+        }
       }
     }
     get size() {
@@ -649,50 +549,43 @@ var dataStructureTyped = (() => {
      * type, but typically it is a string or symbol.
      * @param {V} [value] - The `value` parameter is an optional parameter of type `V`. It represents the
      * value associated with the key being set in the data structure.
-     * @param {boolean} isObjectKey - A boolean flag indicating whether the key is an object key or not.
      * @returns the size of the data structure after the key-value pair has been set.
      */
-    set(key, value, isObjectKey = isObjOrFunc(key)) {
-      let newTail;
-      if (isObjectKey) {
-        const index = key[this.OBJ_KEY_INDEX];
-        if (index !== void 0) {
-          this._nodes[index].value = value;
-          return this._size;
-        }
-        Object.defineProperty(key, this.OBJ_KEY_INDEX, {
-          value: this._nodes.length,
-          configurable: true
-        });
-        newTail = {
-          key,
-          value,
-          prev: this._tail,
-          next: this._sentinel
-        };
-        this._nodes.push(newTail);
+    set(key, value) {
+      let node;
+      if (isWeakKey(key)) {
+        const hash = this._objHashFn(key);
+        node = this._objMap.get(hash);
+        if (node) {
+          node.value = value;
+        } else {
+          node = { key: hash, value, prev: this._tail, next: this._sentinel };
+          this._objMap.set(hash, node);
+        }
       } else {
-        const node = this._orgMap[key];
+        const hash = this._hashFn(key);
+        node = this._noObjMap[hash];
         if (node) {
           node.value = value;
-          return this._size;
+        } else {
+          this._noObjMap[hash] = node = {
+            key,
+            value,
+            prev: this._tail,
+            next: this._sentinel
+          };
         }
-        this._orgMap[key] = newTail = {
-          key,
-          value,
-          prev: this._tail,
-          next: this._sentinel
-        };
       }
       if (this._size === 0) {
-        this._head = newTail;
-        this._sentinel.next = newTail;
+        this._head = node;
+        this._sentinel.next = node;
       } else {
-        this._tail.next = newTail;
+        this._tail.next = node;
       }
-      this._tail = newTail;
-      this._sentinel.prev = newTail;
-      return ++this._size;
+      this._tail = node;
+      this._sentinel.prev = node;
+      this._size++;
+      return this._size;
     }
     /**
      * Time Complexity: O(1)
@@ -702,21 +595,21 @@ var dataStructureTyped = (() => {
      * key directly or by using an index stored in the key object.
      * @param {K} key - The `key` parameter is the key used to retrieve a value from the map. It can be
      * of any type, but typically it is a string or symbol.
-     * @param {boolean} isObjectKey - The `isObjectKey` parameter is a boolean flag that indicates
-     * whether the `key` parameter is an object key or not. If `isObjectKey` is `true`, it means that
-     * `key` is an object key. If `isObjectKey` is `false`, it means that `key`
      * @returns The value associated with the given key is being returned. If the key is an object key,
      * the value is retrieved from the `_nodes` array using the index stored in the `OBJ_KEY_INDEX`
-     * property of the key. If the key is a string key, the value is retrieved from the `_orgMap` object
+     * property of the key. If the key is a string key, the value is retrieved from the `_noObjMap` object
      * using the key itself. If the key is not found, `undefined` is
      */
-    get(key, isObjectKey = isObjOrFunc(key)) {
-      if (isObjectKey) {
-        const index = key[this.OBJ_KEY_INDEX];
-        return index !== void 0 ? this._nodes[index].value : void 0;
+    get(key) {
+      if (isWeakKey(key)) {
+        const hash = this._objHashFn(key);
+        const node = this._objMap.get(hash);
+        return node ? node.value : void 0;
+      } else {
+        const hash = this._hashFn(key);
+        const node = this._noObjMap[hash];
+        return node ? node.value : void 0;
       }
-      const node = this._orgMap[key];
-      return node ? node.value : void 0;
     }
     /**
      * Time Complexity: O(n), where n is the index.
@@ -744,26 +637,25 @@ var dataStructureTyped = (() => {
      * The `delete` function removes a key-value pair from a map-like data structure.
      * @param {K} key - The `key` parameter is the key that you want to delete from the data structure.
      * It can be of any type, but typically it is a string or an object.
-     * @param {boolean} isObjectKey - The `isObjectKey` parameter is a boolean flag that indicates
-     * whether the `key` parameter is an object key or not. If `isObjectKey` is `true`, it means that the
-     * `key` parameter is an object key. If `isObjectKey` is `false`, it means that the
      * @returns a boolean value. It returns `true` if the deletion was successful, and `false` if the key
      * was not found.
      */
-    delete(key, isObjectKey = isObjOrFunc(key)) {
+    delete(key) {
       let node;
-      if (isObjectKey) {
-        const index = key[this.OBJ_KEY_INDEX];
-        if (index === void 0)
+      if (isWeakKey(key)) {
+        const hash = this._objHashFn(key);
+        node = this._objMap.get(hash);
+        if (!node) {
           return false;
-        delete key[this.OBJ_KEY_INDEX];
-        node = this._nodes[index];
-        delete this._nodes[index];
+        }
+        this._objMap.delete(hash);
       } else {
-        node = this._orgMap[key];
-        if (node === void 0)
+        const hash = this._hashFn(key);
+        node = this._noObjMap[hash];
+        if (!node) {
           return false;
-        delete this._orgMap[key];
+        }
+        delete this._noObjMap[hash];
       }
       this._deleteNode(node);
       return true;
@@ -804,9 +696,7 @@ var dataStructureTyped = (() => {
      * The `clear` function clears all the elements in a data structure and resets its properties.
      */
     clear() {
-      this._nodes = [];
-      this._orgMap = {};
-      Object.setPrototypeOf(this._orgMap, null);
+      this._noObjMap = {};
       this._size = 0;
       this._head = this._tail = this._sentinel.prev = this._sentinel.next = this._sentinel;
     }
@@ -827,6 +717,30 @@ var dataStructureTyped = (() => {
         node = node.next;
       }
     }
+    filter(predicate) {
+      const filteredMap = new _HashMap();
+      for (const [key, value] of this) {
+        if (predicate([key, value], this)) {
+          filteredMap.set(key, value);
+        }
+      }
+      return filteredMap;
+    }
+    map(callback) {
+      const mappedMap = new _HashMap();
+      for (const [key, value] of this) {
+        const newValue = callback([key, value], this);
+        mappedMap.set(key, newValue);
+      }
+      return mappedMap;
+    }
+    reduce(callback, initialValue) {
+      let accumulator = initialValue;
+      for (const element of this) {
+        accumulator = callback(accumulator, element, this);
+      }
+      return accumulator;
+    }
     /**
      * Time Complexity: O(n), where n is the number of elements in the HashMap.
      * Space Complexity: O(1)