binary-tree-typed 2.4.5 → 2.5.1

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

@@ -19,83 +19,6 @@ import { IterableEntryBase } from '../base';
  * If you try to insert another entry with the same key, the new one will replace the old entry.
  * 4. Unordered Collection: HashMap does not guarantee the order of entries, and the order may change over time.
  * @example
- * // should maintain insertion order
- *  const linkedHashMap = new LinkedHashMap<number, string>();
- *     linkedHashMap.set(1, 'A');
- *     linkedHashMap.set(2, 'B');
- *     linkedHashMap.set(3, 'C');
- *
- *     const result = Array.from(linkedHashMap);
- *     console.log(result); // [
- *  //      [1, 'A'],
- *  //      [2, 'B'],
- *  //      [3, 'C']
- *  //    ];
- * @example
- * // basic HashMap creation and set operation
- *  // Create a simple HashMap with key-value pairs
- *     const map = new HashMap<number, string>([
- *       [1, 'one'],
- *       [2, 'two'],
- *       [3, 'three']
- *     ]);
- *
- *     // Verify size
- *     console.log(map.size); // 3;
- *
- *     // Set a new key-value pair
- *     map.set(4, 'four');
- *     console.log(map.size); // 4;
- *
- *     // Verify entries
- *     console.log([...map.entries()]); // length: 4;
- * @example
- * // HashMap get and has operations
- *  const map = new HashMap<string, number>([
- *       ['apple', 1],
- *       ['banana', 2],
- *       ['cherry', 3]
- *     ]);
- *
- *     // Check if key exists
- *     console.log(map.has('apple')); // true;
- *     console.log(map.has('date')); // false;
- *
- *     // Get value by key
- *     console.log(map.get('banana')); // 2;
- *     console.log(map.get('grape')); // undefined;
- *
- *     // Get all keys and values
- *     const keys = [...map.keys()];
- *     const values = [...map.values()];
- *     console.log(keys); // contains 'apple';
- *     console.log(values); // contains 3;
- * @example
- * // HashMap iteration and filter operations
- *  const map = new HashMap<number, string>([
- *       [1, 'Alice'],
- *       [2, 'Bob'],
- *       [3, 'Charlie'],
- *       [4, 'Diana'],
- *       [5, 'Eve']
- *     ]);
- *
- *     // Iterate through entries
- *     const entries: [number, string][] = [];
- *     for (const [key, value] of map) {
- *       entries.push([key, value]);
- *     }
- *     console.log(entries); // length: 5;
- *
- *     // Filter operation (for iteration with collection methods)
- *     const filtered = [...map].filter(([key]) => key > 2);
- *     console.log(filtered.length); // 3;
- *
- *     // Map operation
- *     const values = [...map.values()].map(v => v.length);
- *     console.log(values); // contains 3; // 'Bob', 'Eve'
- *     console.log(values); // contains 7;
- * @example
  * // HashMap for user session caching O(1) performance
  *  interface UserSession {
  *       userId: number;
@@ -147,6 +70,19 @@ import { IterableEntryBase } from '../base';
  *     // Get all active sessions
  *     const activeCount = [...sessionCache.values()].length;
  *     console.log(activeCount); // 2;
+ * @example
+ * // Aggregate values
+ *  const counts = new HashMap<string, number>([['a', 5], ['b', 3], ['c', 8]]);
+ *
+ *     const total = counts.reduce((sum, v) => sum + (v ?? 0), 0);
+ *     console.log(total); // 16;
+ * @example
+ * // Iterate over entries
+ *  const map = new HashMap<string, number>([['x', 1], ['y', 2]]);
+ *     const keys: string[] = [];
+ *
+ *     map.forEach((v, k) => keys.push(k));
+ *     console.log(keys.sort()); // ['x', 'y'];
  */
 export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K, V> {
     /**
@@ -200,12 +136,81 @@ export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntry
      * Check whether the map is empty.
      * @remarks Time O(1), Space O(1)
      * @returns True if size is 0.
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Check if empty
+   *  const map = new HashMap();
+   *     console.log(map.isEmpty()); // true;
      */
     isEmpty(): boolean;
     /**
      * Remove all entries and reset counters.
      * @remarks Time O(N), Space O(1)
      * @returns void
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Remove all entries
+   *  const map = new HashMap<string, number>([['a', 1], ['b', 2]]);
+   *     map.clear();
+   *     console.log(map.isEmpty()); // true;
      */
     clear(): void;
     /**
@@ -213,13 +218,95 @@ export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntry
      * @remarks Time O(1), Space O(1)
      * @returns True if the value is a 2-tuple.
      */
-    isEntry(rawElement: any): rawElement is [K, V];
+    isEntry(rawElement: unknown): rawElement is [K, V];
     /**
      * Insert or replace a single entry.
      * @remarks Time O(1), Space O(1)
      * @param key - Key.
      * @param value - Value.
      * @returns True when the operation succeeds.
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // basic HashMap creation and set operation
+   *  // Create a simple HashMap with key-value pairs
+   *     const map = new HashMap<number, string>([
+   *       [1, 'one'],
+   *       [2, 'two'],
+   *       [3, 'three']
+   *     ]);
+   *
+   *     // Verify size
+   *     console.log(map.size); // 3;
+   *
+   *     // Set a new key-value pair
+   *     map.set(4, 'four');
+   *     console.log(map.size); // 4;
+   *
+   *     // Verify entries
+   *     console.log([...map.entries()]); // length: 4;
      */
     set(key: K, value: V): boolean;
     /**
@@ -227,6 +314,41 @@ export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntry
      * @remarks Time O(N), Space O(N)
      * @param entryOrRawElements - Iterable of entries or raw elements to insert.
      * @returns Array of per-entry results.
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Add multiple entries
+   *  const map = new HashMap<string, number>();
+   *     map.setMany([['a', 1], ['b', 2], ['c', 3]]);
+   *     console.log(map.size); // 3;
      */
     setMany(entryOrRawElements: Iterable<R | [K, V]>): boolean[];
     /**
@@ -234,6 +356,59 @@ export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntry
      * @remarks Time O(1), Space O(1)
      * @param key - Key to look up.
      * @returns Value or undefined.
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // HashMap get and has operations
+   *  const map = new HashMap<string, number>([
+   *       ['apple', 1],
+   *       ['banana', 2],
+   *       ['cherry', 3]
+   *     ]);
+   *
+   *     // Check if key exists
+   *     console.log(map.has('apple')); // true;
+   *     console.log(map.has('date')); // false;
+   *
+   *     // Get value by key
+   *     console.log(map.get('banana')); // 2;
+   *     console.log(map.get('grape')); // undefined;
+   *
+   *     // Get all keys and values
+   *     const keys = [...map.keys()];
+   *     const values = [...map.values()];
+   *     console.log(keys); // contains 'apple';
+   *     console.log(values); // contains 3;
      */
     get(key: K): V | undefined;
     /**
@@ -241,6 +416,44 @@ export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntry
      * @remarks Time O(1), Space O(1)
      * @param key - Key to test.
      * @returns True if present.
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Check key existence
+   *  const map = new HashMap<string, number>([['a', 1], ['b', 2]]);
+   *
+   *     console.log(map.has('a')); // true;
+   *     console.log(map.has('z')); // false;
      */
     has(key: K): boolean;
     /**
@@ -248,6 +461,45 @@ export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntry
      * @remarks Time O(1), Space O(1)
      * @param key - Key to delete.
      * @returns True if the key was found and removed.
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Remove entries by key
+   *  const map = new HashMap<string, number>([['x', 10], ['y', 20], ['z', 30]]);
+   *
+   *     console.log(map.delete('y')); // true;
+   *     console.log(map.has('y')); // false;
+   *     console.log(map.size); // 2;
      */
     delete(key: K): boolean;
     /**
@@ -261,6 +513,42 @@ export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntry
      * Deep clone this map, preserving hashing behavior.
      * @remarks Time O(N), Space O(N)
      * @returns A new map with the same content.
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Create independent copy
+   *  const map = new HashMap<string, number>([['a', 1]]);
+   *     const copy = map.clone();
+   *     copy.set('a', 99);
+   *     console.log(map.get('a')); // 1;
      */
     clone(): this;
     /**
@@ -270,16 +558,112 @@ export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntry
      * @param callbackfn - Mapping function (key, value, index, map) → newValue.
      * @param [thisArg] - Value for `this` inside the callback.
      * @returns A new map with transformed values.
-     */
-    map<VM>(callbackfn: EntryCallback<K, V, VM>, thisArg?: any): any;
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // Transform all values
+   *  const prices = new HashMap<string, number>([['apple', 1], ['banana', 2]]);
+   *
+   *     const doubled = prices.map(v => (v ?? 0) * 2);
+   *     console.log(doubled.get('apple')); // 2;
+   *     console.log(doubled.get('banana')); // 4;
+     */
+    map<VM>(callbackfn: EntryCallback<K, V, VM>, thisArg?: unknown): HashMap<K, VM>;
     /**
      * Filter entries into a new map.
      * @remarks Time O(N), Space O(N)
      * @param predicate - Predicate (key, value, index, map) → boolean.
      * @param [thisArg] - Value for `this` inside the predicate.
      * @returns A new map containing entries that satisfied the predicate.
-     */
-    filter(predicate: EntryCallback<K, V, boolean>, thisArg?: any): any;
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+      * @example
+   * // HashMap iteration and filter operations
+   *  const map = new HashMap<number, string>([
+   *       [1, 'Alice'],
+   *       [2, 'Bob'],
+   *       [3, 'Charlie'],
+   *       [4, 'Diana'],
+   *       [5, 'Eve']
+   *     ]);
+   *
+   *     // Iterate through entries
+   *     const entries: [number, string][] = [];
+   *     for (const [key, value] of map) {
+   *       entries.push([key, value]);
+   *     }
+   *     console.log(entries); // length: 5;
+   *
+   *     // Filter operation (for iteration with collection methods)
+   *     const filtered = [...map].filter(([key]) => key > 2);
+   *     console.log(filtered.length); // 3;
+   *
+   *     // Map operation
+   *     const values = [...map.values()].map(v => v.length);
+   *     console.log(values); // contains 3; // 'Bob', 'Eve'
+   *     console.log(values); // contains 7;
+     */
+    filter(predicate: EntryCallback<K, V, boolean>, thisArg?: unknown): any;
     /**
      * (Protected) Create a like-kind instance and seed it from an iterable.
      * @remarks Time O(N), Space O(N)
@@ -290,10 +674,10 @@ export declare class HashMap<K = any, V = any, R = [K, V]> extends IterableEntry
      * @param [options] - Options forwarded to the constructor.
      * @returns A like-kind map instance.
      */
-    protected _createLike<TK = K, TV = V, TR = [TK, TV]>(entries?: Iterable<[TK, TV] | TR>, options?: any): any;
+    protected _createLike<TK = K, TV = V, TR = [TK, TV]>(entries?: Iterable<[TK, TV] | TR>, options?: Record<string, unknown>): this;
     protected _rehashNoObj(): void;
     protected _getIterator(): IterableIterator<[K, V]>;
-    protected _isObjKey(key: any): key is object | ((...args: any[]) => any);
+    protected _isObjKey(key: unknown): key is object | ((...args: unknown[]) => unknown);
     protected _getNoObjKey(key: K): string;
 }
 /**
@@ -408,10 +792,10 @@ export declare class LinkedHashMap<K = any, V = any, R = [K, V]> extends Iterabl
      */
     deleteAt(index: number): boolean;
     isEmpty(): boolean;
-    isEntry(rawElement: any): rawElement is [K, V];
+    isEntry(rawElement: unknown): rawElement is [K, V];
     clear(): void;
-    clone(): any;
-    filter(predicate: EntryCallback<K, V, boolean>, thisArg?: any): any;
+    clone(): this;
+    filter(predicate: EntryCallback<K, V, boolean>, thisArg?: unknown): this;
     /**
      * Map each entry to a new [key, value] pair and preserve order.
      * @remarks Time O(N), Space O(N)
@@ -421,8 +805,8 @@ export declare class LinkedHashMap<K = any, V = any, R = [K, V]> extends Iterabl
      * @param [thisArg] - Value for `this` inside the callback.
      * @returns A new map of the same class with transformed entries.
      */
-    map<MK, MV>(callback: EntryCallback<K, V, [MK, MV]>, thisArg?: any): any;
+    map<MK, MV>(callback: EntryCallback<K, V, [MK, MV]>, thisArg?: unknown): LinkedHashMap<MK, MV>;
     protected _getIterator(): IterableIterator<[K, V]>;
     protected _deleteNode(node: HashMapLinkedNode<K, V | undefined>): boolean;
-    protected _createLike<TK = K, TV = V, TR = [TK, TV]>(entries?: Iterable<[TK, TV] | TR>, options?: any): any;
+    protected _createLike<TK = K, TV = V, TR = [TK, TV]>(entries?: Iterable<[TK, TV] | TR>, options?: Record<string, unknown>): this;
 }