data-structure-typed 1.49.8 → 1.50.0

package/dist/mjs/data-structures/binary-tree/rb-tree.d.ts

@@ -79,13 +79,6 @@ export declare class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K
      * Space Complexity: O(1)
      */
     isRealNode(node: N | undefined): node is N;
-    /**
-     * The function "isNotNodeInstance" checks if a potential key is a K.
-     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
-     * data type.
-     * @returns a boolean value indicating whether the potentialKey is of type number or not.
-     */
-    isNotNodeInstance(potentialKey: KeyOrNodeOrEntry<K, V, N>): potentialKey is K;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)

package/dist/mjs/data-structures/binary-tree/rb-tree.js

@@ -101,7 +101,7 @@ export class RedBlackTree extends BST {
                 node = this.createNode(key, value, RBTNColor.RED);
             }
         }
-        else if (this.isNotNodeInstance(keyOrNodeOrEntry)) {
+        else if (!this.isNode(keyOrNodeOrEntry)) {
             node = this.createNode(keyOrNodeOrEntry, value, RBTNColor.RED);
         }
         else {
@@ -127,15 +127,6 @@ export class RedBlackTree extends BST {
             return false;
         return node instanceof RedBlackTreeNode;
     }
-    /**
-     * The function "isNotNodeInstance" checks if a potential key is a K.
-     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
-     * data type.
-     * @returns a boolean value indicating whether the potentialKey is of type number or not.
-     */
-    isNotNodeInstance(potentialKey) {
-        return !(potentialKey instanceof RedBlackTreeNode);
-    }
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)

package/dist/mjs/data-structures/binary-tree/tree-multimap.d.ts

@@ -60,13 +60,6 @@ export declare class TreeMultimap<K = any, V = any, N extends TreeMultimapNode<K
      * class.
      */
     isNode(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, N>): keyOrNodeOrEntry is N;
-    /**
-     * The function "isNotNodeInstance" checks if a potential key is a K.
-     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
-     * data type.
-     * @returns a boolean value indicating whether the potentialKey is of type number or not.
-     */
-    isNotNodeInstance(potentialKey: KeyOrNodeOrEntry<K, V, N>): potentialKey is K;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)

package/dist/mjs/data-structures/binary-tree/tree-multimap.js

@@ -30,7 +30,7 @@ export class TreeMultimap extends AVLTree {
     // TODO the _count is not accurate after nodes count modified
     get count() {
         let sum = 0;
-        this.subTreeTraverse(node => (sum += node.count));
+        this.dfs(node => (sum += node.count));
         return sum;
     }
     /**
@@ -80,7 +80,7 @@ export class TreeMultimap extends AVLTree {
                 node = this.createNode(key, value, count);
             }
         }
-        else if (this.isNotNodeInstance(keyOrNodeOrEntry)) {
+        else if (!this.isNode(keyOrNodeOrEntry)) {
             node = this.createNode(keyOrNodeOrEntry, value, count);
         }
         else {
@@ -97,15 +97,6 @@ export class TreeMultimap extends AVLTree {
     isNode(keyOrNodeOrEntry) {
         return keyOrNodeOrEntry instanceof TreeMultimapNode;
     }
-    /**
-     * The function "isNotNodeInstance" checks if a potential key is a K.
-     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
-     * data type.
-     * @returns a boolean value indicating whether the potentialKey is of type number or not.
-     */
-    isNotNodeInstance(potentialKey) {
-        return !(potentialKey instanceof TreeMultimapNode);
-    }
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)

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

@@ -13,22 +13,24 @@ import { IterableEntryBase } from '../base';
  * 3. Unique Keys: Keys are unique. If you try to insert another entry with the same key, the old entry will be replaced by the new one.
  * 4. Unordered Collection: HashMap does not guarantee the order of entries, and the order may change over time.
  */
-export declare class HashMap<K = any, V = any> extends IterableEntryBase<K, V> {
+export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K, V> {
     protected _store: {
         [key: string]: HashMapStoreItem<K, V>;
     };
     protected _objMap: Map<object, V>;
     /**
-     * The constructor function initializes a new instance of a class with optional entries and options.
-     * @param entries - The `entries` 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:
+     * The constructor function initializes a HashMap object with an optional initial collection and
+     * options.
+     * @param rawCollection - The `rawCollection` parameter is an iterable collection of elements of type
+     * `T`. It is an optional parameter and its default value is an empty array `[]`.
+     * @param [options] - The `options` parameter is an optional object that can contain two properties:
      */
-    constructor(entries?: Iterable<[K, V]>, options?: HashMapOptions<K>);
+    constructor(rawCollection?: Iterable<R>, options?: HashMapOptions<K, V, R>);
+    protected _toEntryFn: (rawElement: R) => [K, V];
+    get toEntryFn(): (rawElement: R) => [K, V];
     protected _size: number;
     get size(): number;
+    isEntry(rawElement: any): rawElement is [K, V];
     isEmpty(): boolean;
     clear(): void;
     /**
@@ -42,11 +44,13 @@ export declare class HashMap<K = any, V = any> extends IterableEntryBase<K, V> {
      */
     set(key: K, value: V): boolean;
     /**
-     * The function "setMany" sets multiple key-value pairs in a map.
-     * @param entries - The `entries` parameter is an iterable containing key-value pairs. Each
-     * key-value pair is represented as an array with two entries: the key and the value.
+     * The function `setMany` takes an iterable collection of objects, maps each object to a key-value
+     * pair using a mapping function, and sets each key-value pair in the current object.
+     * @param rawCollection - The `rawCollection` parameter is an iterable collection of elements of type
+     * `T`.
+     * @returns The `setMany` function is returning an array of booleans.
      */
-    setMany(entries: Iterable<[K, V]>): boolean[];
+    setMany(rawCollection: Iterable<R>): boolean[];
     /**
      * The `get` function retrieves a value from a map based on a given key, either from an object map or
      * a string map.

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

@@ -10,29 +10,46 @@ export class HashMap extends IterableEntryBase {
     _store = {};
     _objMap = new Map();
     /**
-     * The constructor function initializes a new instance of a class with optional entries and options.
-     * @param entries - The `entries` 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:
+     * The constructor function initializes a HashMap object with an optional initial collection and
+     * options.
+     * @param rawCollection - The `rawCollection` parameter is an iterable collection of elements of type
+     * `T`. It is an optional parameter and its default value is an empty array `[]`.
+     * @param [options] - The `options` parameter is an optional object that can contain two properties:
      */
-    constructor(entries = [], options) {
+    constructor(rawCollection = [], options) {
         super();
         if (options) {
-            const { hashFn } = options;
+            const { hashFn, toEntryFn } = options;
             if (hashFn) {
                 this._hashFn = hashFn;
             }
+            if (toEntryFn) {
+                this._toEntryFn = toEntryFn;
+            }
         }
-        if (entries) {
-            this.setMany(entries);
+        if (rawCollection) {
+            this.setMany(rawCollection);
         }
     }
+    _toEntryFn = (rawElement) => {
+        if (this.isEntry(rawElement)) {
+            // TODO, For performance optimization, it may be necessary to only inspect the first element traversed.
+            return rawElement;
+        }
+        else {
+            throw new Error("If the provided rawCollection does not adhere to the [key, value] type format, the toEntryFn in the constructor's options parameter needs to specified.");
+        }
+    };
+    get toEntryFn() {
+        return this._toEntryFn;
+    }
     _size = 0;
     get size() {
         return this._size;
     }
+    isEntry(rawElement) {
+        return Array.isArray(rawElement) && rawElement.length === 2;
+    }
     isEmpty() {
         return this.size === 0;
     }
@@ -67,14 +84,18 @@ export class HashMap extends IterableEntryBase {
         return true;
     }
     /**
-     * The function "setMany" sets multiple key-value pairs in a map.
-     * @param entries - The `entries` parameter is an iterable containing key-value pairs. Each
-     * key-value pair is represented as an array with two entries: the key and the value.
+     * The function `setMany` takes an iterable collection of objects, maps each object to a key-value
+     * pair using a mapping function, and sets each key-value pair in the current object.
+     * @param rawCollection - The `rawCollection` parameter is an iterable collection of elements of type
+     * `T`.
+     * @returns The `setMany` function is returning an array of booleans.
      */
-    setMany(entries) {
+    setMany(rawCollection) {
         const results = [];
-        for (const [key, value] of entries)
+        for (const rawEle of rawCollection) {
+            const [key, value] = this.toEntryFn(rawEle);
             results.push(this.set(key, value));
+        }
         return results;
     }
     /**

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

@@ -8,8 +8,9 @@ export type LinkedHashMapOptions<K> = {
     hashFn?: (key: K) => string;
     objHashFn?: (key: K) => object;
 };
-export type HashMapOptions<K> = {
+export type HashMapOptions<K, V, T> = {
     hashFn?: (key: K) => string;
+    toEntryFn?: (rawElement: T) => [K, V];
 };
 export type HashMapStoreItem<K, V> = {
     key: K;