data-structure-typed 1.41.0 → 1.41.1

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

@@ -26,7 +26,6 @@ export abstract class AbstractVertex<V = any> {
     this.key = key;
     this.value = value;
   }
-
 }
 
 export abstract class AbstractEdge<E = any> {
@@ -65,7 +64,8 @@ export abstract class AbstractGraph<
   E = any,
   VO extends AbstractVertex<V> = AbstractVertex<V>,
   EO extends AbstractEdge<E> = AbstractEdge<E>
-> implements IGraph<V, E, VO, EO> {
+> implements IGraph<V, E, VO, EO>
+{
   protected _vertices: Map<VertexKey, VO> = new Map<VertexKey, VO>();
 
   get vertices(): Map<VertexKey, VO> {
@@ -513,14 +513,14 @@ export abstract class AbstractGraph<
     }
 
     getMinDist &&
-    distMap.forEach((d, v) => {
-      if (v !== srcVertex) {
-        if (d < minDist) {
-          minDist = d;
-          if (genPaths) minDest = v;
+      distMap.forEach((d, v) => {
+        if (v !== srcVertex) {
+          if (d < minDist) {
+            minDist = d;
+            if (genPaths) minDest = v;
+          }
         }
-      }
-    });
+      });
 
     genPaths && getPaths(minDest);
 
@@ -582,7 +582,7 @@ export abstract class AbstractGraph<
       if (vertexOrKey instanceof AbstractVertex) distMap.set(vertexOrKey, Infinity);
     }
 
-    const heap = new PriorityQueue<{ key: number; value: VO }>({comparator: (a, b) => a.key - b.key});
+    const heap = new PriorityQueue<{key: number; value: VO}>({comparator: (a, b) => a.key - b.key});
     heap.add({key: 0, value: srcVertex});
 
     distMap.set(srcVertex, 0);
@@ -811,7 +811,7 @@ export abstract class AbstractGraph<
    * `predecessor` property is a 2D array of vertices (or `null`) representing the predecessor vertices in the shortest
    * path between vertices in the
    */
-  floyd(): { costs: number[][]; predecessor: (VO | null)[][] } {
+  floyd(): {costs: number[][]; predecessor: (VO | null)[][]} {
     const idAndVertices = [...this._vertices];
     const n = idAndVertices.length;
 
@@ -996,5 +996,4 @@ export abstract class AbstractGraph<
   protected _getVertexKey(vertexOrKey: VO | VertexKey): VertexKey {
     return vertexOrKey instanceof AbstractVertex ? vertexOrKey.key : vertexOrKey;
   }
-
 }

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

@@ -46,13 +46,14 @@ export class DirectedEdge<E = any> extends AbstractEdge<E> {
 }
 
 export class DirectedGraph<
-  V = any,
-  E = any,
-  VO extends DirectedVertex<V> = DirectedVertex<V>,
-  EO extends DirectedEdge<E> = DirectedEdge<E>
->
+    V = any,
+    E = any,
+    VO extends DirectedVertex<V> = DirectedVertex<V>,
+    EO extends DirectedEdge<E> = DirectedEdge<E>
+  >
   extends AbstractGraph<V, E, VO, EO>
-  implements IGraph<V, E, VO, EO> {
+  implements IGraph<V, E, VO, EO>
+{
   /**
    * The constructor function initializes an instance of a class.
    */

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

@@ -43,13 +43,14 @@ export class UndirectedEdge<E = number> extends AbstractEdge<E> {
 }
 
 export class UndirectedGraph<
-  V = any,
-  E = any,
-  VO extends UndirectedVertex<V> = UndirectedVertex<V>,
-  EO extends UndirectedEdge<E> = UndirectedEdge<E>
->
+    V = any,
+    E = any,
+    VO extends UndirectedVertex<V> = UndirectedVertex<V>,
+    EO extends UndirectedEdge<E> = UndirectedEdge<E>
+  >
   extends AbstractGraph<V, E, VO, EO>
-  implements IGraph<V, E, VO, EO> {
+  implements IGraph<V, E, VO, EO>
+{
   /**
    * The constructor initializes a new Map object to store edges.
    */

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

@@ -133,7 +133,7 @@ export class HashMap<K, V> {
     }
   }
 
-  * entries(): IterableIterator<[K, V]> {
+  *entries(): IterableIterator<[K, V]> {
     for (const bucket of this.table) {
       if (bucket) {
         for (const [key, value] of bucket) {

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

@@ -1,2 +1 @@
-export class TreeMap {
-}
+export class TreeMap {}

package/src/data-structures/hash/tree-set.ts

@@ -1,2 +1 @@
-export class TreeSet {
-}
+export class TreeSet {}

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

@@ -8,7 +8,7 @@
 import type {Comparator, DFSOrderPattern} from '../../types';
 
 export class Heap<E = any> {
-  constructor(options: { comparator: Comparator<E>; nodes?: E[] }) {
+  constructor(options: {comparator: Comparator<E>; nodes?: E[]}) {
     this._comparator = options.comparator;
     if (options.nodes && options.nodes.length > 0) {
       this._nodes = options.nodes;
@@ -48,7 +48,7 @@ export class Heap<E = any> {
    * @returns A new Heap instance.
    * @param options
    */
-  static heapify<E>(options: { nodes: E[]; comparator: Comparator<E> }): Heap<E> {
+  static heapify<E>(options: {nodes: E[]; comparator: Comparator<E>}): Heap<E> {
     return new Heap<E>(options);
   }
 

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

@@ -11,7 +11,7 @@ import type {Comparator} from '../../types';
 
 export class MaxHeap<E = any> extends Heap<E> {
   constructor(
-    options: { comparator: Comparator<E>; nodes?: E[] } = {
+    options: {comparator: Comparator<E>; nodes?: E[]} = {
       comparator: (a: E, b: E) => {
         if (!(typeof a === 'number' && typeof b === 'number')) {
           throw new Error('The a, b params of compare function must be number');

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

@@ -11,7 +11,7 @@ import type {Comparator} from '../../types';
 
 export class MinHeap<E = any> extends Heap<E> {
   constructor(
-    options: { comparator: Comparator<E>; nodes?: E[] } = {
+    options: {comparator: Comparator<E>; nodes?: E[]} = {
       comparator: (a: E, b: E) => {
         if (!(typeof a === 'number' && typeof b === 'number')) {
           throw new Error('The a, b params of compare function must be number');

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

@@ -594,7 +594,7 @@ export class DoublyLinkedList<E = any> {
   /**
    * The function returns an iterator that iterates over the values of a linked list.
    */
-  * [Symbol.iterator]() {
+  *[Symbol.iterator]() {
     let current = this.head;
 
     while (current) {

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

@@ -565,7 +565,7 @@ export class SinglyLinkedList<E = any> {
   /**
    * The function returns an iterator that iterates over the values of a linked list.
    */
-  * [Symbol.iterator]() {
+  *[Symbol.iterator]() {
     let current = this.head;
 
     while (current) {

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

@@ -14,7 +14,7 @@ export class MatrixNTI2D<V = any> {
    * given initial value or 0 if not provided.
    * @param options - An object containing the following properties:
    */
-  constructor(options: { row: number; col: number; initialVal?: V }) {
+  constructor(options: {row: number; col: number; initialVal?: V}) {
     const {row, col, initialVal} = options;
     this._matrix = new Array(row).fill(undefined).map(() => new Array(col).fill(initialVal || 0));
   }

package/src/data-structures/matrix/vector2d.ts

@@ -10,8 +10,7 @@ export class Vector2D {
     public x: number = 0,
     public y: number = 0,
     public w: number = 1 // needed for matrix multiplication
-  ) {
-  }
+  ) {}
 
   /**
    * The function checks if the x and y values of a point are both zero.

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

@@ -10,7 +10,7 @@ import type {Comparator} from '../../types';
 
 export class MaxPriorityQueue<E = any> extends PriorityQueue<E> {
   constructor(
-    options: { comparator: Comparator<E>; nodes?: E[] } = {
+    options: {comparator: Comparator<E>; nodes?: E[]} = {
       comparator: (a: E, b: E) => {
         if (!(typeof a === 'number' && typeof b === 'number')) {
           throw new Error('The a, b params of compare function must be number');

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

@@ -10,7 +10,7 @@ import type {Comparator} from '../../types';
 
 export class MinPriorityQueue<E = any> extends PriorityQueue<E> {
   constructor(
-    options: { comparator: Comparator<E>; nodes?: E[] } = {
+    options: {comparator: Comparator<E>; nodes?: E[]} = {
       comparator: (a: E, b: E) => {
         if (!(typeof a === 'number' && typeof b === 'number')) {
           throw new Error('The a, b params of compare function must be number');

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

@@ -10,7 +10,7 @@ import {Heap} from '../heap';
 import {Comparator} from '../../types';
 
 export class PriorityQueue<E = any> extends Heap<E> {
-  constructor(options: { comparator: Comparator<E>; nodes?: E[] }) {
+  constructor(options: {comparator: Comparator<E>; nodes?: E[]}) {
     super(options);
   }
 }

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

@@ -9,8 +9,7 @@ import {DoublyLinkedList} from '../linked-list';
 
 // O(n) time complexity of obtaining the value
 // O(1) time complexity of adding at the beginning and the end
-export class Deque<E = any> extends DoublyLinkedList<E> {
-}
+export class Deque<E = any> extends DoublyLinkedList<E> {}
 
 // O(1) time complexity of obtaining the value
 // O(n) time complexity of adding at the beginning and the end
@@ -20,9 +19,9 @@ export class ObjectDeque<E = number> {
     if (capacity !== undefined) this._capacity = capacity;
   }
 
-  protected _nodes: { [key: number]: E } = {};
+  protected _nodes: {[key: number]: E} = {};
 
-  get nodes(): { [p: number]: E } {
+  get nodes(): {[p: number]: E} {
     return this._nodes;
   }
 

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

@@ -201,7 +201,7 @@ export class Queue<E = any> {
     return new Queue(this.nodes.slice(this.offset));
   }
 
-  * [Symbol.iterator]() {
+  *[Symbol.iterator]() {
     for (const item of this.nodes) {
       yield item;
     }

package/src/types/data-structures/matrix/navigator.ts

@@ -1,6 +1,6 @@
 export type Direction = 'up' | 'right' | 'down' | 'left';
 
-export type Turning = { [key in Direction]: Direction };
+export type Turning = {[key in Direction]: Direction};
 
 export type NavigatorParams<T = any> = {
   matrix: T[][];

package/src/types/utils/utils.ts

@@ -1,5 +1,5 @@
 export type ToThunkFn = () => ReturnType<TrlFn>;
-export type Thunk = () => ReturnType<ToThunkFn> & { __THUNK__: symbol };
+export type Thunk = () => ReturnType<ToThunkFn> & {__THUNK__: symbol};
 export type TrlFn = (...args: any[]) => any;
 export type TrlAsyncFn = (...args: any[]) => any;
 

package/src/types/utils/validate-type.ts

@@ -1,6 +1,6 @@
-export type KeyValueObject = { [key: string]: any };
+export type KeyValueObject = {[key: string]: any};
 
-export type KeyValueObjectWithKey = { [key: string]: any; key: string | number | symbol };
+export type KeyValueObjectWithKey = {[key: string]: any; key: string | number | symbol};
 
 export type NonNumberNonObjectButDefined = string | boolean | symbol | null;
 

package/test/unit/data-structures/binary-tree/avl-tree.test.ts

@@ -7,18 +7,18 @@ describe('AVL Tree Test', () => {
 
     for (const i of arr) tree.add(i, i);
 
-    const node6 = tree.get(6);
+    const node6 = tree.getNode(6);
 
     expect(node6 && tree.getHeight(node6)).toBe(3);
     expect(node6 && tree.getDepth(node6)).toBe(1);
 
-    const getNodeById = tree.get(10);
+    const getNodeById = tree.getNode(10);
     expect(getNodeById?.key).toBe(10);
 
     const getMinNodeByRoot = tree.getLeftMost();
     expect(getMinNodeByRoot?.key).toBe(1);
 
-    const node15 = tree.get(15);
+    const node15 = tree.getNode(15);
     const getMinNodeBySpecificNode = node15 && tree.getLeftMost(node15);
     expect(getMinNodeBySpecificNode?.key).toBe(12);
 
@@ -116,18 +116,18 @@ describe('AVL Tree Test recursively', () => {
 
     for (const i of arr) tree.add(i, i);
 
-    const node6 = tree.get(6);
+    const node6 = tree.getNode(6);
 
     expect(node6 && tree.getHeight(node6)).toBe(3);
     expect(node6 && tree.getDepth(node6)).toBe(1);
 
-    const getNodeById = tree.get(10);
+    const getNodeById = tree.getNode(10);
     expect(getNodeById?.key).toBe(10);
 
     const getMinNodeByRoot = tree.getLeftMost();
     expect(getMinNodeByRoot?.key).toBe(1);
 
-    const node15 = tree.get(15);
+    const node15 = tree.getNode(15);
     const getMinNodeBySpecificNode = node15 && tree.getLeftMost(node15);
     expect(getMinNodeBySpecificNode?.key).toBe(12);
 

package/test/unit/data-structures/binary-tree/binary-tree.test.ts

@@ -107,7 +107,7 @@ describe('BinaryTree', () => {
     expect(tree.has(2)).toBe(true);
     expect(tree.has(3)).toBe(true);
     expect(tree.has(4)).toBe(false);
-    const node4 = tree.get(4);
+    const node4 = tree.getNode(4);
     expect(tree.has(node4)).toBe(false);
     expect(tree.has(node4, node => node)).toBe(false);
     expect(tree.has('3', node => node.value?.toString())).toBe(true);
@@ -169,13 +169,13 @@ describe('BinaryTree', () => {
       new BinaryTreeNode(4, 4)
     ]);
 
-    expect(tree.isSubtreeBST(tree.get(4), IterationType.RECURSIVE)).toBe(true);
-    expect(tree.isSubtreeBST(tree.get(4), IterationType.ITERATIVE)).toBe(true);
+    expect(tree.isSubtreeBST(tree.getNode(4), IterationType.RECURSIVE)).toBe(true);
+    expect(tree.isSubtreeBST(tree.getNode(4), IterationType.ITERATIVE)).toBe(true);
   });
 
   it('should subTreeTraverse', () => {
     tree.addMany([4, 2, 6, 1, 3, 5, 7]);
-    expect(tree.subTreeTraverse(node => node.key, tree.get(6), IterationType.RECURSIVE)).toEqual([6, 5, 7]);
+    expect(tree.subTreeTraverse(node => node.key, tree.getNode(6), IterationType.RECURSIVE)).toEqual([6, 5, 7]);
   });
 
   it('should clear the tree', () => {
@@ -234,9 +234,9 @@ describe('BinaryTree Morris Traversal', () => {
   });
 
   it('after morris traversals should the structure of the tree be correct', () => {
-    const node1 = tree.get(1);
-    const node2 = tree.get(2);
-    const node3 = tree.get(3);
+    const node1 = tree.getNode(1);
+    const node2 = tree.getNode(2);
+    const node3 = tree.getNode(3);
     expect(node1?.left).toBe(node2);
     expect(node1?.right).toBe(node3);
   });
@@ -339,8 +339,8 @@ describe('BinaryTree', () => {
     tree.add(3, 'B');
     tree.add(7, 'C');
 
-    const nodeA = tree.get(5);
-    const nodeB = tree.get(3);
+    const nodeA = tree.getNode(5);
+    const nodeB = tree.getNode(3);
 
     expect(nodeA?.key).toBe(5);
     expect(nodeA?.value).toBe('A');
@@ -351,7 +351,7 @@ describe('BinaryTree', () => {
   it('should return null when getting a non-existent node', () => {
     tree.add(5, 'A');
 
-    const node = tree.get(3);
+    const node = tree.getNode(3);
 
     expect(node).toBe(null);
   });
@@ -421,7 +421,7 @@ describe('BinaryTree', () => {
     tree.delete(3);
 
     expect(tree.size).toBe(2);
-    expect(tree.get(3)).toBe(null);
+    expect(tree.getNode(3)).toBe(null);
   });
 
   it('should check if the tree is perfectly balanced', () => {

package/test/unit/data-structures/binary-tree/bst.test.ts

@@ -19,20 +19,20 @@ describe('BST operations test', () => {
 
     expect(bst.has(6)).toBe(true);
 
-    const node6 = bst.get(6);
+    const node6 = bst.getNode(6);
     expect(node6 && bst.getHeight(6)).toBe(2);
     expect(node6 && bst.getDepth(6)).toBe(3);
 
-    const nodeId10 = bst.get(10);
+    const nodeId10 = bst.getNode(10);
     expect(nodeId10?.key).toBe(10);
 
-    const nodeVal9 = bst.get(9, node => node.value);
+    const nodeVal9 = bst.getNode(9, node => node.value);
     expect(nodeVal9?.key).toBe(9);
 
     const leftMost = bst.getLeftMost();
     expect(leftMost?.key).toBe(1);
 
-    const node15 = bst.get(15);
+    const node15 = bst.getNode(15);
     const minNodeBySpecificNode = node15 && bst.getLeftMost(node15);
     expect(minNodeBySpecificNode?.key).toBe(12);
 
@@ -46,7 +46,7 @@ describe('BST operations test', () => {
 
     expect(node15).toBeInstanceOf(BSTNode);
 
-    const node11 = bst.get(11);
+    const node11 = bst.getNode(11);
     expect(node11).toBeInstanceOf(BSTNode);
 
     const dfsInorderNodes = bst.dfs(node => node, 'in');
@@ -222,20 +222,20 @@ describe('BST operations test', () => {
 
     expect(objBST.has(6)).toBe(true);
 
-    const node6 = objBST.get(6);
+    const node6 = objBST.getNode(6);
     expect(node6 && objBST.getHeight(node6)).toBe(2);
     expect(node6 && objBST.getDepth(node6)).toBe(3);
 
-    const nodeId10 = objBST.get(10);
+    const nodeId10 = objBST.getNode(10);
     expect(nodeId10?.key).toBe(10);
 
-    const nodeVal9 = objBST.get(9);
+    const nodeVal9 = objBST.getNode(9);
     expect(nodeVal9?.key).toBe(9);
 
     const leftMost = objBST.getLeftMost();
     expect(leftMost?.key).toBe(1);
 
-    const node15 = objBST.get(15);
+    const node15 = objBST.getNode(15);
     expect(node15?.value).toEqual({key: 15, keyA: 15});
     const minNodeBySpecificNode = node15 && objBST.getLeftMost(node15);
     expect(minNodeBySpecificNode?.key).toBe(12);
@@ -250,7 +250,7 @@ describe('BST operations test', () => {
 
     expect(node15).toBeInstanceOf(BSTNode);
 
-    const node11 = objBST.get(11);
+    const node11 = objBST.getNode(11);
     expect(node11).toBeInstanceOf(BSTNode);
 
     const dfsInorderNodes = objBST.dfs(node => node, 'in');
@@ -409,20 +409,21 @@ describe('BST operations test recursively', () => {
 
     expect(bst.has(6)).toBe(true);
 
-    const node6 = bst.get(6);
+    const node6 = bst.getNode(6);
     expect(node6 && bst.getHeight(6)).toBe(2);
     expect(node6 && bst.getDepth(6)).toBe(3);
 
-    const nodeId10 = bst.get(10);
+    const nodeId10 = bst.getNode(10);
+    expect(bst.get(10)).toBe(10);
     expect(nodeId10?.key).toBe(10);
 
-    const nodeVal9 = bst.get(9, node => node.value);
+    const nodeVal9 = bst.getNode(9, node => node.value);
     expect(nodeVal9?.key).toBe(9);
 
     const leftMost = bst.getLeftMost();
     expect(leftMost?.key).toBe(1);
 
-    const node15 = bst.get(15);
+    const node15 = bst.getNode(15);
     const minNodeBySpecificNode = node15 && bst.getLeftMost(node15);
     expect(minNodeBySpecificNode?.key).toBe(12);
 
@@ -436,7 +437,7 @@ describe('BST operations test recursively', () => {
 
     expect(node15).toBeInstanceOf(BSTNode);
 
-    const node11 = bst.get(11);
+    const node11 = bst.getNode(11);
     expect(node11).toBeInstanceOf(BSTNode);
 
     const dfsInorderNodes = bst.dfs(node => node, 'in');
@@ -612,20 +613,21 @@ describe('BST operations test recursively', () => {
 
     expect(objBST.has(6)).toBe(true);
 
-    const node6 = objBST.get(6);
+    const node6 = objBST.getNode(6);
+    expect(objBST.get(6)).toEqual({key: 6, keyA: 6});
     expect(node6 && objBST.getHeight(node6)).toBe(2);
     expect(node6 && objBST.getDepth(node6)).toBe(3);
 
-    const nodeId10 = objBST.get(10);
+    const nodeId10 = objBST.getNode(10);
     expect(nodeId10?.key).toBe(10);
 
-    const nodeVal9 = objBST.get(9);
+    const nodeVal9 = objBST.getNode(9);
     expect(nodeVal9?.key).toBe(9);
 
     const leftMost = objBST.getLeftMost();
     expect(leftMost?.key).toBe(1);
 
-    const node15 = objBST.get(15);
+    const node15 = objBST.getNode(15);
     expect(node15?.value).toEqual({key: 15, keyA: 15});
     const minNodeBySpecificNode = node15 && objBST.getLeftMost(node15);
     expect(minNodeBySpecificNode?.key).toBe(12);
@@ -640,7 +642,7 @@ describe('BST operations test recursively', () => {
 
     expect(node15).toBeInstanceOf(BSTNode);
 
-    const node11 = objBST.get(11);
+    const node11 = objBST.getNode(11);
     expect(node11).toBeInstanceOf(BSTNode);
 
     const dfsInorderNodes = objBST.dfs(node => node, 'in');

package/test/unit/data-structures/binary-tree/overall.test.ts

@@ -20,8 +20,8 @@ describe('Overall BinaryTree Test', () => {
     leftMost?.key === 1; // true
     expect(leftMost?.key).toBe(1);
     bst.delete(6);
-    bst.get(6); // null
-    expect(bst.get(6)).toBeNull();
+    bst.getNode(6); // null
+    expect(bst.getNode(6)).toBeNull();
     bst.isAVLBalanced(); // true or false
     expect(bst.isAVLBalanced()).toBe(true);
     const bfsIDs: number[] = [];