priority-queue-typed 2.4.2 → 2.4.4

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

@@ -111,7 +111,7 @@ export class MapGraph<
    * @remarks Time O(1), Space O(1)
    */
   protected override _snapshotOptions(): Record<string, unknown> {
-    return { ...(super._snapshotOptions() as any), originCoord: this.originCoord, bottomRight: this.bottomRight };
+    return { ...super._snapshotOptions(), originCoord: this.originCoord, bottomRight: this.bottomRight };
   }
 
   /**

package/src/data-structures/graph/undirected-graph.ts

@@ -232,8 +232,8 @@ export class UndirectedGraph<
    */
   static fromKeys<K extends VertexKey>(
     keys: Iterable<K>
-  ): UndirectedGraph<K, any, UndirectedVertex<K>, UndirectedEdge<any>> {
-    const g: UndirectedGraph<K, any, UndirectedVertex<K>, UndirectedEdge<any>> = new UndirectedGraph<K, any>({
+  ): UndirectedGraph<K, undefined, UndirectedVertex<K>, UndirectedEdge<undefined>> {
+    const g: UndirectedGraph<K, undefined, UndirectedVertex<K>, UndirectedEdge<undefined>> = new UndirectedGraph<K, undefined>({
       vertexValueInitializer: (k: VertexKey) => k as K
     });
     for (const k of keys) g.addVertex(k);
@@ -249,8 +249,8 @@ export class UndirectedGraph<
    */
   static fromEntries<V>(
     entries: Iterable<[VertexKey, V]>
-  ): UndirectedGraph<V, any, UndirectedVertex<V>, UndirectedEdge<any>> {
-    const g: UndirectedGraph<V, any, UndirectedVertex<V>, UndirectedEdge<any>> = new UndirectedGraph<V, any>();
+  ): UndirectedGraph<V, undefined, UndirectedVertex<V>, UndirectedEdge<undefined>> {
+    const g: UndirectedGraph<V, undefined, UndirectedVertex<V>, UndirectedEdge<undefined>> = new UndirectedGraph<V, undefined>();
     for (const [k, v] of entries) g.addVertex(k, v);
     return g;
   }

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

@@ -197,7 +197,7 @@ export class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
     return this._objMap;
   }
 
-  protected _toEntryFn?: (rawElement: R) => [K, V];
+  protected readonly _toEntryFn?: (rawElement: R) => [K, V];
 
   /**
    * Get the raw→entry converter function if present.
@@ -530,7 +530,7 @@ export class LinkedHashMap<K = any, V = any, R = [K, V]> extends IterableEntryBa
     return this._tail;
   }
 
-  protected _toEntryFn?: (rawElement: R) => [K, V] = (rawElement: R) => {
+  protected readonly _toEntryFn?: (rawElement: R) => [K, V] = (rawElement: R) => {
     if (this.isEntry(rawElement)) {
       return rawElement;
     }
@@ -538,6 +538,7 @@ export class LinkedHashMap<K = any, V = any, R = [K, V]> extends IterableEntryBa
       'If `entryOrRawElements` does not adhere to [key,value], provide `options.toEntryFn` to transform raw records.'
     );
   };
+
   get toEntryFn() {
     return this._toEntryFn;
   }
@@ -712,8 +713,9 @@ export class LinkedHashMap<K = any, V = any, R = [K, V]> extends IterableEntryBa
       const cur = node;
       node = node.next;
       if (predicate(cur.key as K, cur.value as V | undefined, i++, this)) {
-        if (isWeakKey(cur.key as unknown as object)) {
-          this._objMap.delete(cur.key as unknown as object);
+        const keyToCheck: unknown = cur.key;
+        if (isWeakKey(keyToCheck)) {
+          this._objMap.delete(keyToCheck);
         } else {
           const hash = this._hashFn(cur.key as K);
           delete this._noObjMap[hash];

package/src/data-structures/heap/heap.ts

@@ -639,20 +639,17 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
     return out;
   }
 
-  protected _DEFAULT_COMPARATOR = (a: E, b: E): number => {
+  protected readonly _DEFAULT_COMPARATOR: Comparator<E> = (a: E, b: E): number => {
     if (typeof a === 'object' || typeof b === 'object') {
       throw TypeError('When comparing object types, define a custom comparator in options.');
     }
-    if ((a as unknown as number) > (b as unknown as number)) return 1;
-    if ((a as unknown as number) < (b as unknown as number)) return -1;
+    if (a > b) return 1;
+    if (a < b) return -1;
     return 0;
   };
 
-  protected _comparator: Comparator<E> = this._DEFAULT_COMPARATOR; /**
-   * Get the comparator used to order elements.
-   * @remarks Time O(1), Space O(1)
-   * @returns Comparator function.
-   */
+  protected readonly _comparator: Comparator<E> = this._DEFAULT_COMPARATOR;
+
   /**
    * Get the comparator used to order elements.
    * @remarks Time O(1), Space O(1)
@@ -706,9 +703,11 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
    */
 
   protected _createInstance(options?: HeapOptions<E, R>): this {
-    const Ctor: any = this.constructor;
-    const next: any = new Ctor([], { comparator: this.comparator, toElementFn: this.toElementFn, ...(options ?? {}) });
-    return next as this;
+    const Ctor = this.constructor as new (
+      elements?: Iterable<E> | Iterable<R>,
+      options?: HeapOptions<E, R>
+    ) => this;
+    return new Ctor([], { comparator: this.comparator, toElementFn: this.toElementFn, ...(options ?? {}) });
   }
 
   /**
@@ -725,8 +724,11 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
     elements: Iterable<EM> | Iterable<RM> = [],
     options?: HeapOptions<EM, RM>
   ): Heap<EM, RM> {
-    const Ctor: any = this.constructor;
-    return new Ctor(elements, options) as Heap<EM, RM>;
+    const Ctor = this.constructor as new (
+      elements?: Iterable<EM> | Iterable<RM>,
+      options?: HeapOptions<EM, RM>
+    ) => Heap<EM, RM>;
+    return new Ctor(elements, options);
   }
 
   /**
@@ -813,7 +815,8 @@ export class FibonacciHeap<E> {
     return this._min;
   }
 
-  protected _comparator: Comparator<E>;
+  protected readonly _comparator: Comparator<E>;
+
   get comparator(): Comparator<E> {
     return this._comparator;
   }

package/src/data-structures/linked-list/doubly-linked-list.ts

@@ -182,7 +182,7 @@ export class DoublyLinkedListNode<E = any> extends LinkedListNode<E> {
  *     console.log(foundEntry?.value); // 'Bob';
  */
 export class DoublyLinkedList<E = any, R = any> extends LinearLinkedBase<E, R, DoublyLinkedListNode<E>> {
-  protected _equals: (a: E, b: E) => boolean = Object.is as unknown as (a: E, b: E) => boolean;
+  protected _equals: (a: E, b: E) => boolean = (a, b) => Object.is(a, b);
 
   /**
    * Create a DoublyLinkedList and optionally bulk-insert elements.
@@ -423,8 +423,8 @@ export class DoublyLinkedList<E = any, R = any> extends LinearLinkedBase<E, R, D
   at(index: number): E | undefined {
     if (index < 0 || index >= this._length) return undefined;
     let current = this.head;
-    for (let i = 0; i < index; i++) current = current!.next;
-    return current!.value;
+    for (let i = 0; i < index && current; i++) current = current.next;
+    return current?.value;
   }
 
   /**
@@ -437,7 +437,7 @@ export class DoublyLinkedList<E = any, R = any> extends LinearLinkedBase<E, R, D
   getNodeAt(index: number): DoublyLinkedListNode<E> | undefined {
     if (index < 0 || index >= this._length) return undefined;
     let current = this.head;
-    for (let i = 0; i < index; i++) current = current!.next;
+    for (let i = 0; i < index && current; i++) current = current.next;
     return current;
   }
 

package/src/data-structures/linked-list/singly-linked-list.ts

@@ -246,7 +246,7 @@ export class SinglyLinkedListNode<E = any> extends LinkedListNode<E> {
  *     console.log(editor.getText()); // 'Haello';
  */
 export class SinglyLinkedList<E = any, R = any> extends LinearLinkedBase<E, R, SinglyLinkedListNode<E>> {
-  protected _equals: (a: E, b: E) => boolean = Object.is as unknown as (a: E, b: E) => boolean;
+  protected _equals: (a: E, b: E) => boolean = (a, b) => Object.is(a, b);
 
   /**
    * Create a SinglyLinkedList and optionally bulk-insert elements.
@@ -381,8 +381,8 @@ export class SinglyLinkedList<E = any, R = any> extends LinearLinkedBase<E, R, S
       return value;
     }
     let current = this.head;
-    while (current.next !== this.tail) current = current.next!;
-    const value = this.tail!.value;
+    while (current.next && current.next !== this.tail) current = current.next;
+    const value = this.tail?.value;
     current.next = undefined;
     this._tail = current;
     this._length--;
@@ -484,8 +484,8 @@ export class SinglyLinkedList<E = any, R = any> extends LinearLinkedBase<E, R, S
   at(index: number): E | undefined {
     if (index < 0 || index >= this._length) return undefined;
     let current = this.head;
-    for (let i = 0; i < index; i++) current = current!.next;
-    return current!.value;
+    for (let i = 0; i < index && current; i++) current = current.next;
+    return current?.value;
   }
 
   /**
@@ -511,7 +511,7 @@ export class SinglyLinkedList<E = any, R = any> extends LinearLinkedBase<E, R, S
   getNodeAt(index: number): SinglyLinkedListNode<E> | undefined {
     if (index < 0 || index >= this._length) return undefined;
     let current = this.head;
-    for (let i = 0; i < index; i++) current = current!.next;
+    for (let i = 0; i < index && current; i++) current = current.next;
     return current;
   }
 
@@ -1003,7 +1003,10 @@ export class SinglyLinkedList<E = any, R = any> extends LinearLinkedBase<E, R, S
    */
 
   protected _createInstance(options?: SinglyLinkedListOptions<E, R>): this {
-    const Ctor: any = this.constructor;
+    const Ctor = this.constructor as new (
+      elements?: Iterable<E> | Iterable<R> | Iterable<SinglyLinkedListNode<E>>,
+      options?: SinglyLinkedListOptions<E, R>
+    ) => this;
     return new Ctor([], options);
   }
 
@@ -1021,8 +1024,11 @@ export class SinglyLinkedList<E = any, R = any> extends LinearLinkedBase<E, R, S
     elements: Iterable<EM> | Iterable<RM> | Iterable<SinglyLinkedListNode<EM>> = [],
     options?: SinglyLinkedListOptions<EM, RM>
   ): SinglyLinkedList<EM, RM> {
-    const Ctor: any = this.constructor;
-    return new Ctor(elements, options) as SinglyLinkedList<EM, RM>;
+    const Ctor = this.constructor as new (
+      elements?: Iterable<EM> | Iterable<RM> | Iterable<SinglyLinkedListNode<EM>>,
+      options?: SinglyLinkedListOptions<EM, RM>
+    ) => SinglyLinkedList<EM, RM>;
+    return new Ctor(elements, options);
   }
 
   /**

package/src/data-structures/queue/deque.ts

@@ -144,7 +144,7 @@ import { LinearBase } from '../base/linear-base';
  *     console.log(dataWindow.length); // 3;
  */
 export class Deque<E = any, R = any> extends LinearBase<E, R> {
-  protected _equals: (a: E, b: E) => boolean = Object.is as unknown as (a: E, b: E) => boolean;
+  protected _equals: (a: E, b: E) => boolean = (a, b) => Object.is(a, b);
 
   /**
    * Create a Deque and optionally bulk-insert elements.

package/src/data-structures/stack/stack.ts

@@ -161,7 +161,7 @@ import { IterableElementBase } from '../base';
  *     console.log(stack.elements.join('/')); // 'c';
  */
 export class Stack<E = any, R = any> extends IterableElementBase<E, R> {
-  protected _equals: (a: E, b: E) => boolean = Object.is as unknown as (a: E, b: E) => boolean;
+  protected _equals: (a: E, b: E) => boolean = (a, b) => Object.is(a, b);
 
   /**
    * Create a Stack and optionally bulk-push elements.

package/src/data-structures/trie/trie.ts

@@ -684,13 +684,15 @@ export class Trie<R = any> extends IterableElementBase<string, R> {
    */
 
   protected _createInstance(options?: TrieOptions<R>): this {
-    const Ctor: any = this.constructor;
-    const next: any = new Ctor([], {
+    const Ctor = this.constructor as new (
+      elements?: Iterable<string> | Iterable<R>,
+      options?: TrieOptions<R>
+    ) => this;
+    return new Ctor([], {
       toElementFn: this.toElementFn,
       caseSensitive: this.caseSensitive,
       ...(options ?? {})
     });
-    return next as this;
   }
 
   /**
@@ -703,8 +705,11 @@ export class Trie<R = any> extends IterableElementBase<string, R> {
    */
 
   protected _createLike<RM>(elements: Iterable<string> | Iterable<RM> = [], options?: TrieOptions<RM>): Trie<RM> {
-    const Ctor: any = this.constructor;
-    return new Ctor(elements, options) as Trie<RM>;
+    const Ctor = this.constructor as new (
+      elements?: Iterable<string> | Iterable<RM>,
+      options?: TrieOptions<RM>
+    ) => Trie<RM>;
+    return new Ctor(elements, options);
   }
 
   /**

package/src/types/data-structures/binary-tree/avl-tree.ts

@@ -1,3 +1,3 @@
 import { BSTOptions } from './bst';
 
-export type AVLTreeOptions<K, V, R> = BSTOptions<K, V, R> & {};
+export type AVLTreeOptions<K, V, R> = BSTOptions<K, V, R>;

package/src/types/data-structures/binary-tree/red-black-tree.ts

@@ -2,4 +2,4 @@ import type { BSTOptions } from './bst';
 
 export type RBTNColor = 'RED' | 'BLACK';
 
-export type RedBlackTreeOptions<K, V, R> = BSTOptions<K, V, R> & {};
+export type RedBlackTreeOptions<K, V, R> = BSTOptions<K, V, R>;

package/src/types/data-structures/linked-list/doubly-linked-list.ts

@@ -1,3 +1,3 @@
 import { LinearBaseOptions } from '../base';
 
-export type DoublyLinkedListOptions<E, R> = LinearBaseOptions<E, R> & {};
+export type DoublyLinkedListOptions<E, R> = LinearBaseOptions<E, R>;

package/src/types/data-structures/linked-list/singly-linked-list.ts

@@ -1,3 +1,3 @@
 import { LinearBaseOptions } from '../base';
 
-export type SinglyLinkedListOptions<E, R> = LinearBaseOptions<E, R> & {};
+export type SinglyLinkedListOptions<E, R> = LinearBaseOptions<E, R>;

package/src/types/data-structures/priority-queue/priority-queue.ts

@@ -1,3 +1,3 @@
 import { HeapOptions } from '../heap';
 
-export type PriorityQueueOptions<E, R> = HeapOptions<E, R> & {};
+export type PriorityQueueOptions<E, R> = HeapOptions<E, R>;

package/src/types/data-structures/stack/stack.ts

@@ -1,3 +1,3 @@
 import { IterableElementBaseOptions } from '../base';
 
-export type StackOptions<E, R> = IterableElementBaseOptions<E, R> & {};
+export type StackOptions<E, R> = IterableElementBaseOptions<E, R>;