data-structure-typed 2.5.0 → 2.5.2

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

@@ -15,7 +15,7 @@ import type {
 } from '../../types';
 import { IterableEntryBase } from '../base';
 import { isWeakKey, rangeCheck } from '../../utils';
-import { ERR } from '../../common';
+import { ERR, raise } from '../../common';
 
 /**
  * Hash-based map. Supports object keys and custom hashing; offers O(1) average set/get/has.
@@ -181,6 +181,29 @@ export class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Check if empty
  *  const map = new HashMap();
@@ -204,6 +227,29 @@ export class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Remove all entries
  *  const map = new HashMap<string, number>([['a', 1], ['b', 2]]);
@@ -221,7 +267,7 @@ export class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
    * @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] {
     return Array.isArray(rawElement) && rawElement.length === 2;
   }
 
@@ -251,6 +297,52 @@ export class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
    
    
    
@@ -301,6 +393,29 @@ export class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Add multiple entries
  *  const map = new HashMap<string, number>();
@@ -335,6 +450,29 @@ export class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // HashMap get and has operations
  *  const map = new HashMap<string, number>([
@@ -380,6 +518,29 @@ export class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Check key existence
  *  const map = new HashMap<string, number>([['a', 1], ['b', 2]]);
@@ -410,6 +571,29 @@ export class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Remove entries by key
  *  const map = new HashMap<string, number>([['x', 10], ['y', 20], ['z', 30]]);
@@ -459,6 +643,29 @@ export class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Create independent copy
  *  const map = new HashMap<string, number>([['a', 1]]);
@@ -490,6 +697,29 @@ export class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // Transform all values
  *  const prices = new HashMap<string, number>([['apple', 1], ['banana', 2]]);
@@ -498,8 +728,8 @@ export class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
  *     console.log(doubled.get('apple')); // 2;
  *     console.log(doubled.get('banana')); // 4;
    */
-  map<VM>(callbackfn: EntryCallback<K, V, VM>, thisArg?: any): any {
-    const out = this._createLike<K, VM, [K, VM]>();
+  map<VM>(callbackfn: EntryCallback<K, V, VM>, thisArg?: unknown): HashMap<K, VM> {
+    const out = this._createLike<K, VM, [K, VM]>() as unknown as HashMap<K, VM>;
     let index = 0;
     for (const [key, value] of this) out.set(key, callbackfn.call(thisArg, value, key, index++, this));
     return out;
@@ -523,6 +753,29 @@ export class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
    
    
    
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
     * @example
  * // HashMap iteration and filter operations
  *  const map = new HashMap<number, string>([
@@ -550,7 +803,7 @@ export class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
  *     console.log(values); // contains 7;
    */
 
-  filter(predicate: EntryCallback<K, V, boolean>, thisArg?: any): any {
+  filter(predicate: EntryCallback<K, V, boolean>, thisArg?: unknown): any {
     const out = this._createLike<K, V, [K, V]>();
     let index = 0;
     for (const [key, value] of this) if (predicate.call(thisArg, value, key, index++, this)) out.set(key, value);
@@ -567,8 +820,8 @@ export class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
    * @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 {
-    const Ctor = this.constructor as new (e?: Iterable<[TK, TV] | TR>, o?: any) => any;
+  protected _createLike<TK = K, TV = V, TR = [TK, TV]>(entries: Iterable<[TK, TV] | TR> = [], options?: Record<string, unknown>): this {
+    const Ctor = this.constructor as new (e?: Iterable<[TK, TV] | TR>, o?: Record<string, unknown>) => this;
     return new Ctor(entries, options);
   }
 
@@ -586,7 +839,7 @@ export class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
     for (const node of this.objMap) yield node as [K, V];
   }
 
-  protected _isObjKey(key: any): key is object | ((...args: any[]) => any) {
+  protected _isObjKey(key: unknown): key is object | ((...args: unknown[]) => unknown) {
     const keyType = typeof key;
     return (keyType === 'object' || keyType === 'function') && key !== null;
   }
@@ -699,9 +952,7 @@ export class LinkedHashMap<K = any, V = any, R = [K, V]> extends IterableEntryBa
     if (this.isEntry(rawElement)) {
       return rawElement;
     }
-    throw new TypeError(
-      ERR.invalidArgument('If elements do not adhere to [key, value], provide options.toEntryFn to transform raw records.', 'HashMap')
-    );
+    raise(TypeError, ERR.invalidArgument('If elements do not adhere to [key, value], provide options.toEntryFn to transform raw records.', 'HashMap'));
   };
 
   get toEntryFn() {
@@ -908,7 +1159,7 @@ export class LinkedHashMap<K = any, V = any, R = [K, V]> extends IterableEntryBa
     return this._size === 0;
   }
 
-  isEntry(rawElement: any): rawElement is [K, V] {
+  isEntry(rawElement: unknown): rawElement is [K, V] {
     return Array.isArray(rawElement) && rawElement.length === 2;
   }
 
@@ -918,12 +1169,12 @@ export class LinkedHashMap<K = any, V = any, R = [K, V]> extends IterableEntryBa
     this._head = this._tail = this._sentinel.prev = this._sentinel.next = this._sentinel;
   }
 
-  clone(): any {
+  clone(): this {
     const opts = { hashFn: this._hashFn, objHashFn: this._objHashFn };
-    return this._createLike<[K, V], [K, V], [K, V]>(this, opts);
+    return this._createLike<K, V, [K, V]>(this, opts);
   }
 
-  filter(predicate: EntryCallback<K, V, boolean>, thisArg?: any): any {
+  filter(predicate: EntryCallback<K, V, boolean>, thisArg?: unknown): this {
     const out = this._createLike<K, V, [K, V]>();
     let index = 0;
     for (const [key, value] of this) {
@@ -942,8 +1193,8 @@ export class LinkedHashMap<K = any, V = any, R = [K, V]> extends IterableEntryBa
    * @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 {
-    const out = this._createLike<MK, MV, [MK, MV]>();
+  map<MK, MV>(callback: EntryCallback<K, V, [MK, MV]>, thisArg?: unknown): LinkedHashMap<MK, MV> {
+    const out = this._createLike<MK, MV, [MK, MV]>() as unknown as LinkedHashMap<MK, MV>;
     let index = 0;
     for (const [key, value] of this) {
       const [newKey, newValue] = callback.call(thisArg, value, key, index, this);
@@ -983,8 +1234,8 @@ export class LinkedHashMap<K = any, V = any, R = [K, V]> extends IterableEntryBa
     return true;
   }
 
-  protected _createLike<TK = K, TV = V, TR = [TK, TV]>(entries: Iterable<[TK, TV] | TR> = [], options?: any): any {
-    const Ctor = this.constructor as new (e?: Iterable<[TK, TV] | TR>, o?: any) => any;
+  protected _createLike<TK = K, TV = V, TR = [TK, TV]>(entries: Iterable<[TK, TV] | TR> = [], options?: Record<string, unknown>): this {
+    const Ctor = this.constructor as new (e?: Iterable<[TK, TV] | TR>, o?: Record<string, unknown>) => this;
     return new Ctor(entries, options);
   }
 }