min-heap-typed 1.48.0 → 1.48.2

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

@@ -7,13 +7,235 @@
  * @license MIT License
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HashMap = void 0;
+exports.LinkedHashMap = exports.HashMap = void 0;
 const utils_1 = require("../../utils");
-class HashMap {
+const base_1 = require("../base");
+class HashMap extends base_1.IterablePairBase {
+    /**
+     * The constructor function initializes a new instance of a class with optional elements and options.
+     * @param elements - The `elements` parameter is an iterable containing key-value pairs `[K, V]`. It
+     * is optional and defaults to an empty array `[]`. This parameter is used to initialize the map with
+     * key-value pairs.
+     * @param [options] - The `options` parameter is an optional object that can contain additional
+     * configuration options for the constructor. In this case, it has one property:
+     */
+    constructor(elements = [], options) {
+        super();
+        this._store = {};
+        this._objMap = new Map();
+        this._size = 0;
+        this._hashFn = (key) => String(key);
+        if (options) {
+            const { hashFn } = options;
+            if (hashFn) {
+                this._hashFn = hashFn;
+            }
+        }
+        if (elements) {
+            this.setMany(elements);
+        }
+    }
+    get size() {
+        return this._size;
+    }
+    isEmpty() {
+        return this.size === 0;
+    }
+    clear() {
+        this._store = {};
+        this._objMap.clear();
+        this._size = 0;
+    }
+    /**
+     * The `set` function adds a key-value pair to a map-like data structure, incrementing the size if
+     * the key is not already present.
+     * @param {K} key - The key parameter is the key used to identify the value in the data structure. It
+     * can be of any type, but if it is an object, it will be stored in a Map, otherwise it will be
+     * stored in a regular JavaScript object.
+     * @param {V} value - The value parameter represents the value that you want to associate with the
+     * key in the data structure.
+     */
+    set(key, value) {
+        if (this._isObjKey(key)) {
+            if (!this._objMap.has(key)) {
+                this._size++;
+            }
+            this._objMap.set(key, value);
+        }
+        else {
+            const strKey = this._getNoObjKey(key);
+            if (this._store[strKey] === undefined) {
+                this._size++;
+            }
+            this._store[strKey] = { key, value };
+        }
+    }
+    /**
+     * The function "setMany" sets multiple key-value pairs in a map.
+     * @param elements - The `elements` parameter is an iterable containing key-value pairs. Each
+     * key-value pair is represented as an array with two elements: the key and the value.
+     */
+    setMany(elements) {
+        for (const [key, value] of elements)
+            this.set(key, value);
+    }
+    /**
+     * The `get` function retrieves a value from a map based on a given key, either from an object map or
+     * a string map.
+     * @param {K} key - The `key` parameter is the key used to retrieve a value from the map. It can be
+     * of any type, but it should be compatible with the key type used when the map was created.
+     * @returns The method `get(key: K)` returns a value of type `V` if the key exists in the `_objMap`
+     * or `_store`, otherwise it returns `undefined`.
+     */
+    get(key) {
+        var _a;
+        if (this._isObjKey(key)) {
+            return this._objMap.get(key);
+        }
+        else {
+            const strKey = this._getNoObjKey(key);
+            return (_a = this._store[strKey]) === null || _a === void 0 ? void 0 : _a.value;
+        }
+    }
+    /**
+     * The `has` function checks if a given key exists in the `_objMap` or `_store` based on whether it
+     * is an object key or not.
+     * @param {K} key - The parameter "key" is of type K, which means it can be any type.
+     * @returns The `has` method is returning a boolean value.
+     */
+    has(key) {
+        if (this._isObjKey(key)) {
+            return this._objMap.has(key);
+        }
+        else {
+            const strKey = this._getNoObjKey(key);
+            return strKey in this._store;
+        }
+    }
+    /**
+     * The `delete` function removes an element from a map-like data structure based on the provided key.
+     * @param {K} key - The `key` parameter is the key of the element that you want to delete from the
+     * data structure.
+     * @returns The `delete` method returns a boolean value. It returns `true` if the key was
+     * successfully deleted from the map, and `false` if the key was not found in the map.
+     */
+    delete(key) {
+        if (this._isObjKey(key)) {
+            if (this._objMap.has(key)) {
+                this._size--;
+            }
+            return this._objMap.delete(key);
+        }
+        else {
+            const strKey = this._getNoObjKey(key);
+            if (strKey in this._store) {
+                delete this._store[strKey];
+                this._size--;
+                return true;
+            }
+            return false;
+        }
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `map` function in TypeScript creates a new HashMap by applying a callback function to each
+     * key-value pair in the original HashMap.
+     * @param callbackfn - The callback function that will be called for each key-value pair in the
+     * HashMap. It takes four parameters:
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+     * to be used as `this` when executing the `callbackfn` function. If `thisArg` is provided, it will
+     * be passed as the `this` value to the `callbackfn` function. If `thisArg
+     * @returns The `map` method is returning a new `HashMap` object with the transformed values based on
+     * the provided callback function.
+     */
+    map(callbackfn, thisArg) {
+        const resultMap = new HashMap();
+        let index = 0;
+        for (const [key, value] of this) {
+            resultMap.set(key, callbackfn.call(thisArg, value, key, index++, this));
+        }
+        return resultMap;
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `filter` function creates a new HashMap containing key-value pairs from the original HashMap
+     * that satisfy a given predicate function.
+     * @param predicate - The predicate parameter is a function that takes four arguments: value, key,
+     * index, and map. It is used to determine whether an element should be included in the filtered map
+     * or not. The function should return a boolean value - true if the element should be included, and
+     * false otherwise.
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+     * to be used as `this` when executing the `predicate` function. If `thisArg` is provided, it will be
+     * passed as the `this` value to the `predicate` function. If `thisArg` is
+     * @returns The `filter` method is returning a new `HashMap` object that contains the key-value pairs
+     * from the original `HashMap` that pass the provided `predicate` function.
+     */
+    filter(predicate, thisArg) {
+        const filteredMap = new HashMap();
+        let index = 0;
+        for (const [key, value] of this) {
+            if (predicate.call(thisArg, value, key, index++, this)) {
+                filteredMap.set(key, value);
+            }
+        }
+        return filteredMap;
+    }
+    print() {
+        console.log([...this.entries()]);
+    }
+    /**
+     * The function returns an iterator that yields key-value pairs from both an object store and an
+     * object map.
+     */
+    *_getIterator() {
+        for (const node of Object.values(this._store)) {
+            yield [node.key, node.value];
+        }
+        for (const node of this._objMap) {
+            yield node;
+        }
+    }
+    _isObjKey(key) {
+        const keyType = typeof key;
+        return (keyType === 'object' || keyType === 'function') && key !== null;
+    }
+    _getNoObjKey(key) {
+        const keyType = typeof key;
+        let strKey;
+        if (keyType !== "string" && keyType !== "number" && keyType !== "symbol") {
+            strKey = this._hashFn(key);
+        }
+        else {
+            if (keyType === "number") {
+                // TODO numeric key should has its own hash
+                strKey = key;
+            }
+            else {
+                strKey = key;
+            }
+        }
+        return strKey;
+    }
+}
+exports.HashMap = HashMap;
+class LinkedHashMap extends base_1.IterablePairBase {
     constructor(elements, options = {
         hashFn: (key) => String(key),
         objHashFn: (key) => key
     }) {
+        super();
         this._noObjMap = {};
         this._objMap = new WeakMap();
         this._size = 0;
@@ -92,47 +314,62 @@ class HashMap {
      */
     set(key, value) {
         let node;
+        const isNewKey = !this.has(key); // Check if the key is new
         if ((0, utils_1.isWeakKey)(key)) {
             const hash = this._objHashFn(key);
             node = this._objMap.get(hash);
-            if (node) {
-                // If the node already exists, update its value
-                node.value = value;
-            }
-            else {
+            if (!node && isNewKey) {
                 // 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);
             }
+            else if (node) {
+                // Update the value of an existing node
+                node.value = value;
+            }
         }
         else {
             const hash = this._hashFn(key);
-            // Non-object keys are handled in the same way as the original implementation
             node = this._noObjMap[hash];
-            if (node) {
+            if (!node && isNewKey) {
+                this._noObjMap[hash] = node = { key, value, prev: this._tail, next: this._sentinel };
+            }
+            else if (node) {
+                // Update the value of an existing node
                 node.value = value;
             }
+        }
+        if (node && isNewKey) {
+            // Update the head and tail of the linked list
+            if (this._size === 0) {
+                this._head = node;
+                this._sentinel.next = node;
+            }
             else {
-                this._noObjMap[hash] = node = {
-                    key,
-                    value,
-                    prev: this._tail,
-                    next: this._sentinel
-                };
+                this._tail.next = node;
+                node.prev = this._tail; // Make sure that the prev of the new node points to the current tail node
             }
+            this._tail = node;
+            this._sentinel.prev = node;
+            this._size++;
         }
-        if (this._size === 0) {
-            this._head = node;
-            this._sentinel.next = node;
+        return this._size;
+    }
+    has(key) {
+        if ((0, utils_1.isWeakKey)(key)) {
+            const hash = this._objHashFn(key);
+            return this._objMap.has(hash);
         }
         else {
-            this._tail.next = node;
+            const hash = this._hashFn(key);
+            return hash in this._noObjMap;
+        }
+    }
+    setMany(entries) {
+        for (const entry of entries) {
+            const [key, value] = entry;
+            this.set(key, value);
         }
-        this._tail = node;
-        this._sentinel.prev = node;
-        this._size++;
-        return this._size;
     }
     /**
      * Time Complexity: O(1)
@@ -254,36 +491,38 @@ class HashMap {
         this._size = 0;
         this._head = this._tail = this._sentinel.prev = this._sentinel.next = this._sentinel;
     }
-    /**
-     * Time Complexity: O(n), where n is the number of elements in the HashMap.
-     * Space Complexity: O(1)
-     *
-     * The `forEach` function iterates over each element in a HashMap and executes a callback function on
-     * each element.
-     * @param callback - The callback parameter is a function that will be called for each element in the
-     * HashMap. It takes three arguments:
-     */
-    forEach(callback) {
-        let index = 0;
-        let node = this._head;
-        while (node !== this._sentinel) {
-            callback([node.key, node.value], index++, this);
-            node = node.next;
+    clone() {
+        const cloned = new LinkedHashMap([], { hashFn: this._hashFn, objHashFn: this._objHashFn });
+        for (const entry of this) {
+            const [key, value] = entry;
+            cloned.set(key, value);
         }
+        return cloned;
     }
     /**
-     * The `filter` function takes a predicate function and returns a new HashMap containing only the
-     * key-value pairs that satisfy the predicate.
-     * @param predicate - The `predicate` parameter is a function that takes two arguments: `element` and
-     * `map`.
-     * @returns a new HashMap object that contains the key-value pairs from the original HashMap that
-     * satisfy the given predicate function.
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
      */
-    filter(predicate) {
-        const filteredMap = new HashMap();
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `filter` function creates a new `LinkedHashMap` containing key-value pairs from the original
+     * map that satisfy a given predicate function.
+     * @param predicate - The `predicate` parameter is a callback function that takes four arguments:
+     * `value`, `key`, `index`, and `this`. It should return a boolean value indicating whether the
+     * current element should be included in the filtered map or not.
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
+     * specify the value of `this` within the `predicate` function. It is used when you want to bind a
+     * specific object as the context for the `predicate` function. If `thisArg` is not provided, `this
+     * @returns a new `LinkedHashMap` object that contains the key-value pairs from the original
+     * `LinkedHashMap` object that satisfy the given predicate function.
+     */
+    filter(predicate, thisArg) {
+        const filteredMap = new LinkedHashMap();
         let index = 0;
         for (const [key, value] of this) {
-            if (predicate([key, value], index, this)) {
+            if (predicate.call(thisArg, value, key, index, this)) {
                 filteredMap.set(key, value);
             }
             index++;
@@ -291,59 +530,52 @@ class HashMap {
         return filteredMap;
     }
     /**
-     * The `map` function takes a callback function and returns a new HashMap with the values transformed
-     * by the callback.
-     * @param callback - The `callback` parameter is a function that takes two arguments: `element` and
-     * `map`.
-     * @returns a new HashMap object with the values mapped according to the provided callback function.
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `map` function in TypeScript creates a new `LinkedHashMap` by applying a callback function to
+     * each key-value pair in the original map.
+     * @param callback - The callback parameter is a function that will be called for each key-value pair
+     * in the map. It takes four arguments: the value of the current key-value pair, the key of the
+     * current key-value pair, the index of the current key-value pair, and the map itself. The callback
+     * function should
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
+     * specify the value of `this` within the callback function. If provided, the callback function will
+     * be called with `thisArg` as its `this` value. If not provided, `this` will refer to the current
+     * map
+     * @returns a new `LinkedHashMap` object with the values mapped according to the provided callback
+     * function.
      */
-    map(callback) {
-        const mappedMap = new HashMap();
+    map(callback, thisArg) {
+        const mappedMap = new LinkedHashMap();
         let index = 0;
         for (const [key, value] of this) {
-            const newValue = callback([key, value], index, this);
+            const newValue = callback.call(thisArg, value, key, index, this);
             mappedMap.set(key, newValue);
             index++;
         }
         return mappedMap;
     }
-    /**
-     * The `reduce` function iterates over the elements of a HashMap and applies a callback function to
-     * each element, accumulating a single value.
-     * @param callback - The callback parameter is a function that takes three arguments: accumulator,
-     * element, and map. It is called for each element in the HashMap and is used to accumulate a single
-     * result.
-     * @param {A} initialValue - The `initialValue` parameter is the initial value of the accumulator. It
-     * is the value that will be passed as the first argument to the `callback` function when reducing
-     * the elements of the map.
-     * @returns The `reduce` function is returning the final value of the accumulator after iterating
-     * over all the elements in the HashMap and applying the callback function to each element.
-     */
-    reduce(callback, initialValue) {
-        let accumulator = initialValue;
-        let index = 0;
-        for (const entry of this) {
-            accumulator = callback(accumulator, entry, index, this);
-            index++;
-        }
-        return accumulator;
+    print() {
+        console.log([...this]);
     }
     /**
-     * Time Complexity: O(n), where n is the number of elements in the HashMap.
+     * Time Complexity: O(n), where n is the number of elements in the LinkedHashMap.
      * Space Complexity: O(1)
      *
      * The above function is an iterator that yields key-value pairs from a linked list.
      */
-    *[Symbol.iterator]() {
+    *_getIterator() {
         let node = this._head;
         while (node !== this._sentinel) {
             yield [node.key, node.value];
             node = node.next;
         }
     }
-    print() {
-        console.log([...this]);
-    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -367,4 +599,4 @@ class HashMap {
         this._size -= 1;
     }
 }
-exports.HashMap = HashMap;
+exports.LinkedHashMap = LinkedHashMap;

package/dist/data-structures/heap/heap.d.ts

@@ -4,9 +4,10 @@
  * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>
  * @license MIT License
  */
-import type { Comparator, DFSOrderPattern } from '../../types';
+import type { Comparator, DFSOrderPattern, ElementCallback } from '../../types';
 import { HeapOptions } from "../../types";
-export declare class Heap<E = any> {
+import { IterableElementBase } from "../base";
+export declare class Heap<E = any> extends IterableElementBase<E> {
     options: HeapOptions<E>;
     constructor(elements?: Iterable<E>, options?: HeapOptions<E>);
     protected _elements: E[];
@@ -192,16 +193,58 @@ export declare class Heap<E = any> {
      * Fix the entire heap to maintain heap properties.
      */
     fix(): void;
-    [Symbol.iterator](): Generator<E, void, unknown>;
-    forEach(callback: (element: E, index: number, heap: this) => void): void;
-    filter(predicate: (element: E, index: number, heap: Heap<E>) => boolean): Heap<E>;
-    map<T>(callback: (element: E, index: number, heap: Heap<E>) => T, comparator: Comparator<T>): Heap<T>;
-    reduce<T>(callback: (accumulator: T, currentValue: E, currentIndex: number, heap: Heap<E>) => T, initialValue: T): T;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `filter` function creates a new Heap object containing elements that pass a given callback
+     * function.
+     * @param callback - The `callback` parameter is a function that will be called for each element in
+     * the heap. It takes three arguments: the current element, the index of the current element, and the
+     * heap itself. The callback function should return a boolean value indicating whether the current
+     * element should be included in the filtered list
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+     * to be used as `this` when executing the `callback` function. If `thisArg` is provided, it will be
+     * passed as the `this` value to the `callback` function. If `thisArg` is
+     * @returns The `filter` method is returning a new `Heap` object that contains the elements that pass
+     * the filter condition specified by the `callback` function.
+     */
+    filter(callback: ElementCallback<E, boolean>, thisArg?: any): Heap<E>;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `map` function creates a new heap by applying a callback function to each element of the
+     * original heap.
+     * @param callback - The callback parameter is a function that will be called for each element in the
+     * original heap. It takes three arguments: the current element, the index of the current element,
+     * and the original heap itself. The callback function should return a value of type T, which will be
+     * added to the mapped heap.
+     * @param comparator - The `comparator` parameter is a function that is used to compare elements in
+     * the heap. It takes two arguments, `a` and `b`, and returns a negative number if `a` is less than
+     * `b`, a positive number if `a` is greater than `b`, or
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
+     * specify the value of `this` within the callback function. It is used when you want to bind a
+     * specific object as the context for the callback function. If `thisArg` is not provided,
+     * `undefined` is used as
+     * @returns a new instance of the Heap class, which is created using the mapped elements from the
+     * original Heap.
+     */
+    map<T>(callback: ElementCallback<E, T>, comparator: Comparator<T>, thisArg?: any): Heap<T>;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      */
     print(): void;
+    protected _getIterator(): Generator<E, void, unknown>;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)

package/dist/data-structures/heap/heap.js

@@ -7,8 +7,10 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FibonacciHeap = exports.FibonacciHeapNode = exports.Heap = void 0;
-class Heap {
+const base_1 = require("../base");
+class Heap extends base_1.IterableElementBase {
     constructor(elements, options) {
+        super();
         this._elements = [];
         const defaultComparator = (a, b) => {
             if (!(typeof a === 'number' && typeof b === 'number')) {
@@ -310,47 +312,70 @@ class Heap {
         for (let i = Math.floor(this.size / 2); i >= 0; i--)
             this._sinkDown(i, this.elements.length >> 1);
     }
-    *[Symbol.iterator]() {
-        for (const element of this.elements) {
-            yield element;
-        }
-    }
-    forEach(callback) {
-        let index = 0;
-        for (const el of this) {
-            callback(el, index, this);
-            index++;
-        }
-    }
-    filter(predicate) {
-        const filteredHeap = new Heap([], this.options);
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `filter` function creates a new Heap object containing elements that pass a given callback
+     * function.
+     * @param callback - The `callback` parameter is a function that will be called for each element in
+     * the heap. It takes three arguments: the current element, the index of the current element, and the
+     * heap itself. The callback function should return a boolean value indicating whether the current
+     * element should be included in the filtered list
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+     * to be used as `this` when executing the `callback` function. If `thisArg` is provided, it will be
+     * passed as the `this` value to the `callback` function. If `thisArg` is
+     * @returns The `filter` method is returning a new `Heap` object that contains the elements that pass
+     * the filter condition specified by the `callback` function.
+     */
+    filter(callback, thisArg) {
+        const filteredList = new Heap();
         let index = 0;
-        for (const el of this) {
-            if (predicate(el, index, this)) {
-                filteredHeap.push(el);
+        for (const current of this) {
+            if (callback.call(thisArg, current, index, this)) {
+                filteredList.push(current);
             }
             index++;
         }
-        return filteredHeap;
+        return filteredList;
     }
-    map(callback, comparator) {
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `map` function creates a new heap by applying a callback function to each element of the
+     * original heap.
+     * @param callback - The callback parameter is a function that will be called for each element in the
+     * original heap. It takes three arguments: the current element, the index of the current element,
+     * and the original heap itself. The callback function should return a value of type T, which will be
+     * added to the mapped heap.
+     * @param comparator - The `comparator` parameter is a function that is used to compare elements in
+     * the heap. It takes two arguments, `a` and `b`, and returns a negative number if `a` is less than
+     * `b`, a positive number if `a` is greater than `b`, or
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
+     * specify the value of `this` within the callback function. It is used when you want to bind a
+     * specific object as the context for the callback function. If `thisArg` is not provided,
+     * `undefined` is used as
+     * @returns a new instance of the Heap class, which is created using the mapped elements from the
+     * original Heap.
+     */
+    map(callback, comparator, thisArg) {
         const mappedHeap = new Heap([], { comparator: comparator });
         let index = 0;
         for (const el of this) {
-            mappedHeap.add(callback(el, index, this));
+            mappedHeap.add(callback.call(thisArg, el, index, this));
             index++;
         }
         return mappedHeap;
     }
-    reduce(callback, initialValue) {
-        let accumulator = initialValue;
-        let index = 0;
-        for (const el of this) {
-            accumulator = callback(accumulator, el, index, this);
-            index++;
-        }
-        return accumulator;
-    }
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -358,6 +383,11 @@ class Heap {
     print() {
         console.log([...this]);
     }
+    *_getIterator() {
+        for (const element of this.elements) {
+            yield element;
+        }
+    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)

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

@@ -9,3 +9,4 @@ export * from './heap';
 export * from './priority-queue';
 export * from './matrix';
 export * from './trie';
+export * from './base';