priority-queue-typed 1.46.3 → 1.46.4

package/dist/data-structures/hash/hash-map.d.ts

@@ -5,21 +5,21 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import { HashMapLinkedNode, IterableWithSizeOrLength } from '../../types';
+import { HashMapLinkedNode, HashMapOptions } from '../../types';
 export declare class HashMap<K = any, V = any> {
-    readonly OBJ_KEY_INDEX: symbol;
-    protected _nodes: HashMapLinkedNode<K, V>[];
-    protected _orgMap: Record<string, HashMapLinkedNode<K, V>>;
-    protected _head: HashMapLinkedNode<K, V>;
-    protected _tail: HashMapLinkedNode<K, V>;
-    protected readonly _sentinel: HashMapLinkedNode<K, V>;
+    protected _noObjMap: Record<string, HashMapLinkedNode<K, V | undefined>>;
+    protected _objMap: WeakMap<WeakKey, HashMapLinkedNode<K, V | undefined>>;
+    protected _head: HashMapLinkedNode<K, V | undefined>;
+    protected _tail: HashMapLinkedNode<K, V | undefined>;
+    protected readonly _sentinel: HashMapLinkedNode<K, V | undefined>;
+    protected _hashFn: (key: K) => string;
+    protected _objHashFn: (key: K) => WeakKey;
     /**
-     * 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?: IterableWithSizeOrLength<[K, V]>);
+    constructor(options?: HashMapOptions<K, V>);
     protected _size: number;
     get size(): number;
     /**
@@ -43,12 +43,12 @@ export declare class HashMap<K = any, V = any> {
     /**
      * The `begin()` function in TypeScript iterates over a linked list and yields key-value pairs.
      */
-    begin(): Generator<(K | V)[], void, unknown>;
+    begin(): Generator<(K | V | undefined)[], void, unknown>;
     /**
      * The function `reverseBegin()` iterates over a linked list in reverse order, yielding each node's
      * key and value.
      */
-    reverseBegin(): Generator<(K | V)[], void, unknown>;
+    reverseBegin(): Generator<(K | V | undefined)[], void, unknown>;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -59,10 +59,9 @@ export declare class HashMap<K = any, V = any> {
      * 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: K, value?: V, isObjectKey?: boolean): number;
+    set(key: K, value?: V): number;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -71,15 +70,12 @@ export declare class HashMap<K = any, V = any> {
      * 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: K, isObjectKey?: boolean): V | undefined;
+    get(key: K): V | undefined;
     /**
      * Time Complexity: O(n), where n is the index.
      * Space Complexity: O(1)
@@ -99,13 +95,10 @@ export declare class HashMap<K = any, V = any> {
      * 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: K, isObjectKey?: boolean): boolean;
+    delete(key: K): boolean;
     /**
      * Time Complexity: O(n), where n is the index.
      * Space Complexity: O(1)
@@ -142,6 +135,9 @@ export declare class HashMap<K = any, V = any> {
      * HashMap. It takes three arguments:
      */
     forEach(callback: (element: [K, V], index: number, hashMap: HashMap<K, V>) => void): void;
+    filter(predicate: (element: [K, V], map: HashMap<K, V>) => boolean): HashMap<K, V>;
+    map<NV>(callback: (element: [K, V], map: HashMap<K, V>) => NV): HashMap<K, NV>;
+    reduce<A>(callback: (accumulator: A, element: [K, V], map: HashMap<K, V>) => A, initialValue: A): A;
     /**
      * Time Complexity: O(n), where n is the number of elements in the HashMap.
      * Space Complexity: O(1)
@@ -159,5 +155,5 @@ export declare class HashMap<K = any, V = any> {
      * represents a node in a linked list. It contains a key-value pair and references to the previous
      * and next nodes in the list.
      */
-    protected _deleteNode(node: HashMapLinkedNode<K, V>): void;
+    protected _deleteNode(node: HashMapLinkedNode<K, V | undefined>): void;
 }

package/dist/data-structures/hash/hash-map.js

@@ -11,21 +11,27 @@ exports.HashMap = void 0;
 const utils_1 = require("../../utils");
 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 = []) {
-        this.OBJ_KEY_INDEX = Symbol('OBJ_KEY_INDEX');
-        this._nodes = [];
-        this._orgMap = {};
+    constructor(options = {
+        elements: [],
+        hashFn: (key) => String(key),
+        objHashFn: (key) => key
+    }) {
+        this._noObjMap = {};
+        this._objMap = new WeakMap();
         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() {
@@ -88,52 +94,52 @@ class HashMap {
      * 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 = (0, utils_1.isObjOrFunc)(key)) {
-        let newTail;
-        if (isObjectKey) {
-            const index = key[this.OBJ_KEY_INDEX];
-            if (index !== undefined) {
-                this._nodes[index].value = value;
-                return this._size;
+    set(key, value) {
+        let node;
+        if ((0, utils_1.isWeakKey)(key)) {
+            // const hash = this._objHashFn(key);
+            const hash = key;
+            node = this._objMap.get(hash);
+            if (node) {
+                // If the node already exists, update its value
+                node.value = value;
+            }
+            else {
+                // Create new node
+                node = { key: hash, value, prev: this._tail, next: this._sentinel };
+                // Add new nodes to _objMap and linked list
+                this._objMap.set(hash, node);
             }
-            Object.defineProperty(key, this.OBJ_KEY_INDEX, {
-                value: this._nodes.length,
-                configurable: true
-            });
-            newTail = {
-                key: key,
-                value: value,
-                prev: this._tail,
-                next: this._sentinel
-            };
-            this._nodes.push(newTail);
         }
         else {
-            const node = this._orgMap[key];
+            const hash = this._hashFn(key);
+            // Non-object keys are handled in the same way as the original implementation
+            node = this._noObjMap[hash];
             if (node) {
                 node.value = value;
-                return this._size;
             }
-            this._orgMap[key] = newTail = {
-                key: key,
-                value: value,
-                prev: this._tail,
-                next: this._sentinel
-            };
+            else {
+                this._noObjMap[hash] = node = {
+                    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)
@@ -143,21 +149,22 @@ class HashMap {
      * 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 = (0, utils_1.isObjOrFunc)(key)) {
-        if (isObjectKey) {
-            const index = key[this.OBJ_KEY_INDEX];
-            return index !== undefined ? this._nodes[index].value : undefined;
+    get(key) {
+        if ((0, utils_1.isWeakKey)(key)) {
+            const hash = this._objHashFn(key);
+            const node = this._objMap.get(hash);
+            return node ? node.value : undefined;
+        }
+        else {
+            const hash = this._hashFn(key);
+            const node = this._noObjMap[hash];
+            return node ? node.value : undefined;
         }
-        const node = this._orgMap[key];
-        return node ? node.value : undefined;
     }
     /**
      * Time Complexity: O(n), where n is the index.
@@ -185,28 +192,32 @@ class HashMap {
      * 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 = (0, utils_1.isObjOrFunc)(key)) {
+    delete(key) {
         let node;
-        if (isObjectKey) {
-            const index = key[this.OBJ_KEY_INDEX];
-            if (index === undefined)
-                return false;
-            delete key[this.OBJ_KEY_INDEX];
-            node = this._nodes[index];
-            delete this._nodes[index];
+        if ((0, utils_1.isWeakKey)(key)) {
+            const hash = this._objHashFn(key);
+            // Get nodes from WeakMap
+            node = this._objMap.get(hash);
+            if (!node) {
+                return false; // If the node does not exist, return false
+            }
+            // Remove nodes from WeakMap
+            this._objMap.delete(hash);
         }
         else {
-            node = this._orgMap[key];
-            if (node === undefined)
-                return false;
-            delete this._orgMap[key];
+            const hash = this._hashFn(key);
+            // Get nodes from noObjMap
+            node = this._noObjMap[hash];
+            if (!node) {
+                return false; // If the node does not exist, return false
+            }
+            // Remove nodes from orgMap
+            delete this._noObjMap[hash];
         }
+        // Remove node from doubly linked list
         this._deleteNode(node);
         return true;
     }
@@ -246,13 +257,7 @@ class HashMap {
      * The `clear` function clears all the elements in a data structure and resets its properties.
      */
     clear() {
-        // const OBJ_KEY_INDEX = this.OBJ_KEY_INDEX;
-        // this._nodes.forEach(el => {
-        //   delete (<Record<symbol, number>><unknown>el.key)[OBJ_KEY_INDEX];
-        // });
-        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;
     }
@@ -273,6 +278,30 @@ class HashMap {
             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)

package/dist/data-structures/hash/index.d.ts

@@ -1,6 +1,2 @@
 export * from './hash-table';
-export * from './coordinate-map';
-export * from './coordinate-set';
-export * from './tree-map';
-export * from './tree-set';
 export * from './hash-map';

package/dist/data-structures/hash/index.js

@@ -15,8 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./hash-table"), exports);
-__exportStar(require("./coordinate-map"), exports);
-__exportStar(require("./coordinate-set"), exports);
-__exportStar(require("./tree-map"), exports);
-__exportStar(require("./tree-set"), exports);
 __exportStar(require("./hash-map"), exports);

package/dist/types/data-structures/hash/hash-map.d.ts

@@ -4,3 +4,8 @@ export type HashMapLinkedNode<K, V> = {
     next: HashMapLinkedNode<K, V>;
     prev: HashMapLinkedNode<K, V>;
 };
+export type HashMapOptions<K, V> = {
+    elements: Iterable<[K, V]>;
+    hashFn: (key: K) => string;
+    objHashFn: (key: K) => WeakKey;
+};

package/dist/types/data-structures/hash/index.d.ts

@@ -1,7 +1,3 @@
-export * from './coordinate-map';
-export * from './coordinate-set';
 export * from './hash-map';
 export * from './hash-table';
-export * from './tree-map';
-export * from './tree-set';
 export type HashFunction<K> = (key: K) => number;

package/dist/types/data-structures/hash/index.js

@@ -14,9 +14,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./coordinate-map"), exports);
-__exportStar(require("./coordinate-set"), exports);
 __exportStar(require("./hash-map"), exports);
 __exportStar(require("./hash-table"), exports);
-__exportStar(require("./tree-map"), exports);
-__exportStar(require("./tree-set"), exports);

package/dist/utils/utils.d.ts

@@ -20,5 +20,5 @@ export declare const trampolineAsync: (fn: TrlAsyncFn) => ((...args: [...Paramet
 export declare const getMSB: (value: number) => number;
 export declare const rangeCheck: (index: number, min: number, max: number, message?: string) => void;
 export declare const throwRangeError: (message?: string) => void;
-export declare const isObjOrFunc: (input: unknown) => input is Record<string, unknown> | ((...args: any[]) => any);
+export declare const isWeakKey: (input: unknown) => input is WeakKey;
 export declare const calcMinUnitsRequired: (totalQuantity: number, unitSize: number) => number;

package/dist/utils/utils.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calcMinUnitsRequired = exports.isObjOrFunc = exports.throwRangeError = exports.rangeCheck = exports.getMSB = exports.trampolineAsync = exports.trampoline = exports.toThunk = exports.isThunk = exports.THUNK_SYMBOL = exports.arrayRemove = exports.uuidV4 = void 0;
+exports.calcMinUnitsRequired = exports.isWeakKey = exports.throwRangeError = exports.rangeCheck = exports.getMSB = exports.trampolineAsync = exports.trampoline = exports.toThunk = exports.isThunk = exports.THUNK_SYMBOL = exports.arrayRemove = exports.uuidV4 = void 0;
 const uuidV4 = function () {
     return 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'.replace(/[x]/g, function (c) {
         const r = (Math.random() * 16) | 0, v = c == 'x' ? r : (r & 0x3) | 0x8;
@@ -80,10 +80,10 @@ const throwRangeError = (message = 'The value is off-limits.') => {
     throw new RangeError(message);
 };
 exports.throwRangeError = throwRangeError;
-const isObjOrFunc = (input) => {
+const isWeakKey = (input) => {
     const inputType = typeof input;
     return (inputType === 'object' && input !== null) || inputType === 'function';
 };
-exports.isObjOrFunc = isObjOrFunc;
+exports.isWeakKey = isWeakKey;
 const calcMinUnitsRequired = (totalQuantity, unitSize) => Math.floor((totalQuantity + unitSize - 1) / unitSize);
 exports.calcMinUnitsRequired = calcMinUnitsRequired;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "priority-queue-typed",
-  "version": "1.46.3",
+  "version": "1.46.4",
   "description": "Priority Queue, Min Priority Queue, Max Priority Queue. Javascript & Typescript Data Structure.",
   "main": "dist/index.js",
   "scripts": {
@@ -120,6 +120,6 @@
     "typedoc": "^0.25.1"
   },
   "dependencies": {
-    "data-structure-typed": "^1.46.3"
+    "data-structure-typed": "^1.46.4"
   }
 }

package/src/data-structures/hash/hash-map.ts

@@ -6,31 +6,41 @@
  * @license MIT License
  */
 
-import { isObjOrFunc, rangeCheck } from '../../utils';
-import { HashMapLinkedNode, IterableWithSizeOrLength } from '../../types';
+import { isWeakKey, rangeCheck } from '../../utils';
+import { HashMapLinkedNode, HashMapOptions } from '../../types';
 
 export class HashMap<K = any, V = any> {
-  readonly OBJ_KEY_INDEX = Symbol('OBJ_KEY_INDEX');
-  protected _nodes: HashMapLinkedNode<K, V>[] = [];
-  protected _orgMap: Record<string, HashMapLinkedNode<K, V>> = {};
-  protected _head: HashMapLinkedNode<K, V>;
-  protected _tail: HashMapLinkedNode<K, V>;
-  protected readonly _sentinel: HashMapLinkedNode<K, V>;
+
+  protected _noObjMap: Record<string, HashMapLinkedNode<K, V | undefined>> = {};
+  protected _objMap = new WeakMap<WeakKey, HashMapLinkedNode<K, V | undefined>>();
+  protected _head: HashMapLinkedNode<K, V | undefined>;
+  protected _tail: HashMapLinkedNode<K, V | undefined>;
+  protected readonly _sentinel: HashMapLinkedNode<K, V | undefined>;
+  protected _hashFn: (key: K) => string;
+  protected _objHashFn: (key: K) => WeakKey;
 
   /**
-   * 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: IterableWithSizeOrLength<[K, V]> = []) {
-    Object.setPrototypeOf(this._orgMap, null);
+  constructor(options: HashMapOptions<K, V> = {
+    elements: [],
+    hashFn: (key: K) => String(key),
+    objHashFn: (key: K) => (<WeakKey>key)
+  }) {
     this._sentinel = <HashMapLinkedNode<K, V>>{};
     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]);
+      }
     }
+
   }
 
   protected _size = 0;
@@ -98,50 +108,54 @@ export class HashMap<K = any, V = any> {
    * 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: K, value?: V, isObjectKey: boolean = isObjOrFunc(key)) {
-    let newTail;
-    if (isObjectKey) {
-      const index = (<Record<symbol, number>>(<unknown>key))[this.OBJ_KEY_INDEX];
-      if (index !== undefined) {
-        this._nodes[<number>index].value = <V>value;
-        return this._size;
+  set(key: K, value?: V) {
+    let node;
+
+    if (isWeakKey(key)) {
+      // const hash = this._objHashFn(key);
+      const hash = key;
+      node = this._objMap.get(hash);
+
+      if (node) {
+        // If the node already exists, update its value
+        node.value = value;
+      } else {
+        // Create new node
+        node = { key: <K>hash, value, prev: this._tail, next: this._sentinel };
+
+        // Add new nodes to _objMap and linked list
+        this._objMap.set(hash, node);
       }
-      Object.defineProperty(key, this.OBJ_KEY_INDEX, {
-        value: this._nodes.length,
-        configurable: true
-      });
-      newTail = {
-        key: key,
-        value: <V>value,
-        prev: this._tail,
-        next: this._sentinel
-      };
-      this._nodes.push(newTail);
     } else {
-      const node = this._orgMap[<string>(<unknown>key)];
+      const hash = this._hashFn(key);
+      // Non-object keys are handled in the same way as the original implementation
+      node = this._noObjMap[hash];
       if (node) {
-        node.value = <V>value;
-        return this._size;
+        node.value = value;
+      } else {
+        this._noObjMap[hash] = node = {
+          key,
+          value,
+          prev: this._tail,
+          next: this._sentinel
+        };
       }
-      this._orgMap[<string>(<unknown>key)] = newTail = {
-        key: key,
-        value: <V>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;
   }
 
   /**
@@ -152,21 +166,21 @@ export class HashMap<K = any, V = any> {
    * 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: K, isObjectKey: boolean = isObjOrFunc(key)) {
-    if (isObjectKey) {
-      const index = (<Record<symbol, number>>(<unknown>key))[this.OBJ_KEY_INDEX];
-      return index !== undefined ? this._nodes[index].value : undefined;
+  get(key: K): V | undefined {
+    if (isWeakKey(key)) {
+      const hash = this._objHashFn(key);
+      const node = this._objMap.get(hash);
+      return node ? node.value : undefined;
+    } else {
+      const hash = this._hashFn(key);
+      const node = this._noObjMap[hash];
+      return node ? node.value : undefined;
     }
-    const node = this._orgMap[<string>(<unknown>key)];
-    return node ? node.value : undefined;
   }
 
   /**
@@ -196,25 +210,37 @@ export class HashMap<K = any, V = any> {
    * 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: K, isObjectKey: boolean = isObjOrFunc(key)) {
+  delete(key: K) {
     let node;
-    if (isObjectKey) {
-      const index = (<Record<symbol, number>>(<unknown>key))[this.OBJ_KEY_INDEX];
-      if (index === undefined) return false;
-      delete (<Record<symbol, number>>(<unknown>key))[this.OBJ_KEY_INDEX];
-      node = this._nodes[index];
-      delete this._nodes[index];
+
+    if (isWeakKey(key)) {
+      const hash = this._objHashFn(key);
+      // Get nodes from WeakMap
+      node = this._objMap.get(hash);
+
+      if (!node) {
+        return false; // If the node does not exist, return false
+      }
+
+      // Remove nodes from WeakMap
+      this._objMap.delete(hash);
     } else {
-      node = this._orgMap[<string>(<unknown>key)];
-      if (node === undefined) return false;
-      delete this._orgMap[<string>(<unknown>key)];
+      const hash = this._hashFn(key);
+      // Get nodes from noObjMap
+      node = this._noObjMap[hash];
+
+      if (!node) {
+        return false; // If the node does not exist, return false
+      }
+
+      // Remove nodes from orgMap
+      delete this._noObjMap[hash];
     }
+
+    // Remove node from doubly linked list
     this._deleteNode(node);
     return true;
   }
@@ -257,13 +283,7 @@ export class HashMap<K = any, V = any> {
    * The `clear` function clears all the elements in a data structure and resets its properties.
    */
   clear() {
-    // const OBJ_KEY_INDEX = this.OBJ_KEY_INDEX;
-    // this._nodes.forEach(el => {
-    //   delete (<Record<symbol, number>><unknown>el.key)[OBJ_KEY_INDEX];
-    // });
-    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;
   }
@@ -286,6 +306,33 @@ export class HashMap<K = any, V = any> {
     }
   }
 
+  filter(predicate: (element: [K, V], map: HashMap<K, V>) => boolean): HashMap<K, V> {
+    const filteredMap = new HashMap<K, V>();
+    for (const [key, value] of this) {
+      if (predicate([key, value], this)) {
+        filteredMap.set(key, value);
+      }
+    }
+    return filteredMap;
+  }
+
+  map<NV>(callback: (element: [K, V], map: HashMap<K, V>) => NV): HashMap<K, NV> {
+    const mappedMap = new HashMap<K, NV>();
+    for (const [key, value] of this) {
+      const newValue = callback([key, value], this);
+      mappedMap.set(key, newValue);
+    }
+    return mappedMap;
+  }
+
+  reduce<A>(callback: (accumulator: A, element: [K, V], map: HashMap<K, V>) => A, initialValue: A): A {
+    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)
@@ -310,16 +357,19 @@ export class HashMap<K = any, V = any> {
    * represents a node in a linked list. It contains a key-value pair and references to the previous
    * and next nodes in the list.
    */
-  protected _deleteNode(node: HashMapLinkedNode<K, V>) {
+  protected _deleteNode(node: HashMapLinkedNode<K, V | undefined>) {
     const { prev, next } = node;
     prev.next = next;
     next.prev = prev;
+
     if (node === this._head) {
       this._head = next;
     }
+
     if (node === this._tail) {
       this._tail = prev;
     }
+
     this._size -= 1;
   }
 }

package/src/data-structures/hash/index.ts

@@ -1,6 +1,2 @@
 export * from './hash-table';
-export * from './coordinate-map';
-export * from './coordinate-set';
-export * from './tree-map';
-export * from './tree-set';
 export * from './hash-map';

package/src/types/data-structures/hash/hash-map.ts

@@ -4,3 +4,9 @@ export type HashMapLinkedNode<K, V> = {
   next: HashMapLinkedNode<K, V>;
   prev: HashMapLinkedNode<K, V>;
 };
+
+export type HashMapOptions<K, V> = {
+  elements: Iterable<[K, V]>;
+  hashFn: (key: K) => string;
+  objHashFn: (key: K) => WeakKey
+}

package/src/types/data-structures/hash/index.ts

@@ -1,8 +1,4 @@
-export * from './coordinate-map';
-export * from './coordinate-set';
 export * from './hash-map';
 export * from './hash-table';
-export * from './tree-map';
-export * from './tree-set';
 
 export type HashFunction<K> = (key: K) => number;

package/src/utils/utils.ts

@@ -93,7 +93,7 @@ export const throwRangeError = (message = 'The value is off-limits.'): void => {
   throw new RangeError(message);
 };
 
-export const isObjOrFunc = (input: unknown): input is Record<string, unknown> | ((...args: any[]) => any) => {
+export const isWeakKey = (input: unknown): input is WeakKey => {
   const inputType = typeof input;
   return (inputType === 'object' && input !== null) || inputType === 'function';
 };

package/dist/data-structures/hash/coordinate-map.d.ts

@@ -1,44 +0,0 @@
-/**
- * data-structure-typed
- *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
-export declare class CoordinateMap<V> extends Map<any, V> {
-    constructor(joint?: string);
-    protected _joint: string;
-    get joint(): string;
-    /**
-     * 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: number[]): boolean;
-    /**
-     * 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: number[], value: V): this;
-    /**
-     * 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: number[]): V | undefined;
-    /**
-     * 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: number[]): boolean;
-}

package/dist/data-structures/hash/coordinate-map.js

@@ -1,62 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CoordinateMap = void 0;
-/**
- * data-structure-typed
- *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
-class CoordinateMap extends Map {
-    constructor(joint) {
-        super();
-        this._joint = '_';
-        if (joint !== undefined)
-            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));
-    }
-}
-exports.CoordinateMap = CoordinateMap;

package/dist/data-structures/hash/coordinate-set.d.ts

@@ -1,36 +0,0 @@
-/**
- * data-structure-typed
- *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
-export declare class CoordinateSet extends Set<any> {
-    constructor(joint?: string);
-    protected _joint: string;
-    get joint(): string;
-    /**
-     * 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: number[]): boolean;
-    /**
-     * 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: number[]): this;
-    /**
-     * 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: number[]): boolean;
-}

package/dist/data-structures/hash/coordinate-set.js

@@ -1,52 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CoordinateSet = void 0;
-/**
- * data-structure-typed
- *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
-class CoordinateSet extends Set {
-    constructor(joint) {
-        super();
-        this._joint = '_';
-        if (joint !== undefined)
-            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));
-    }
-}
-exports.CoordinateSet = CoordinateSet;

package/dist/data-structures/hash/tree-map.d.ts

@@ -1,2 +0,0 @@
-export declare class TreeMap {
-}

package/dist/data-structures/hash/tree-map.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TreeMap = void 0;
-class TreeMap {
-}
-exports.TreeMap = TreeMap;

package/dist/data-structures/hash/tree-set.d.ts

@@ -1,2 +0,0 @@
-export declare class TreeSet {
-}

package/dist/data-structures/hash/tree-set.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TreeSet = void 0;
-class TreeSet {
-}
-exports.TreeSet = TreeSet;

package/dist/types/data-structures/hash/coordinate-map.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/types/data-structures/hash/coordinate-map.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/data-structures/hash/coordinate-set.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/types/data-structures/hash/coordinate-set.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/data-structures/hash/tree-map.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/types/data-structures/hash/tree-map.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/data-structures/hash/tree-set.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/types/data-structures/hash/tree-set.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/src/data-structures/hash/coordinate-map.ts

@@ -1,63 +0,0 @@
-/**
- * data-structure-typed
- *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
-export class CoordinateMap<V> extends Map<any, V> {
-  constructor(joint?: string) {
-    super();
-    if (joint !== undefined) this._joint = joint;
-  }
-
-  protected _joint = '_';
-
-  get joint(): string {
-    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.
-   */
-  override has(key: number[]) {
-    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)`).
-   */
-  override set(key: number[], value: V) {
-    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.
-   */
-  override get(key: number[]) {
-    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.
-   */
-  override delete(key: number[]) {
-    return super.delete(key.join(this._joint));
-  }
-}

package/src/data-structures/hash/coordinate-set.ts

@@ -1,52 +0,0 @@
-/**
- * data-structure-typed
- *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
-export class CoordinateSet extends Set<any> {
-  constructor(joint?: string) {
-    super();
-    if (joint !== undefined) this._joint = joint;
-  }
-
-  protected _joint = '_';
-
-  get joint(): string {
-    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.
-   */
-  override has(value: number[]) {
-    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)`).
-   */
-  override add(value: number[]) {
-    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.
-   */
-  override delete(value: number[]) {
-    return super.delete(value.join(this._joint));
-  }
-}

package/src/data-structures/hash/tree-map.ts

@@ -1,2 +0,0 @@
-export class TreeMap {
-}

package/src/data-structures/hash/tree-set.ts

@@ -1,2 +0,0 @@
-export class TreeSet {
-}

package/src/types/data-structures/hash/coordinate-map.ts

@@ -1 +0,0 @@
-export {};

package/src/types/data-structures/hash/coordinate-set.ts

@@ -1 +0,0 @@
-export {};

package/src/types/data-structures/hash/tree-map.ts

@@ -1 +0,0 @@
-export {};

package/src/types/data-structures/hash/tree-set.ts

@@ -1 +0,0 @@
-export {};