data-structure-typed 1.39.2 → 1.39.4

package/src/interfaces/binary-tree.ts

@@ -1,10 +1,10 @@
 import {BinaryTreeNode} from '../data-structures';
-import {BinaryTreeDeletedResult, BinaryTreeNodeKey, BinaryTreeNodeNested, OneParamCallback} from '../types';
+import {BinaryTreeDeletedResult, BTNKey, BinaryTreeNodeNested, BTNCallback} from '../types';
 
 export interface IBinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNodeNested<V>> {
-  createNode(key: BinaryTreeNodeKey, val?: N['val']): N;
+  createNode(key: BTNKey, val?: N['val']): N;
 
-  add(keyOrNode: BinaryTreeNodeKey | N | null, val?: N['val']): N | null | undefined;
+  add(keyOrNode: BTNKey | N | null, val?: N['val']): N | null | undefined;
 
-  delete<C extends OneParamCallback<N>>(identifier: ReturnType<C> | null, callback: C): BinaryTreeDeletedResult<N>[];
+  delete<C extends BTNCallback<N>>(identifier: ReturnType<C> | null, callback: C): BinaryTreeDeletedResult<N>[];
 }

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

@@ -22,7 +22,7 @@ export enum FamilyPosition {
   MAL_NODE = 'MAL_NODE'
 }
 
-export type BinaryTreeNodeKey = number;
+export type BTNKey = number;
 
 export type BinaryTreeDeletedResult<N> = { deleted: N | null | undefined; needBalanced: N | null };
 

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

@@ -1,7 +1,7 @@
 import {BSTNode} from '../../../data-structures';
-import type {BinaryTreeNodeKey, BinaryTreeOptions} from './binary-tree';
+import type {BTNKey, BinaryTreeOptions} from './binary-tree';
 
-export type BSTComparator = (a: BinaryTreeNodeKey, b: BinaryTreeNodeKey) => number;
+export type BSTComparator = (a: BTNKey, b: BTNKey) => number;
 
 // prettier-ignore
 export type BSTNodeNested<T> = BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

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/helpers.ts

@@ -2,7 +2,7 @@ export type Comparator<T> = (a: T, b: T) => number;
 
 export type DFSOrderPattern = 'pre' | 'in' | 'post';
 
-export type OneParamCallback<N, D = any> = (node: N) => D;
+export type BTNCallback<N, D = any> = (node: N) => D;
 
 export enum CP {
   lt = 'lt',

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/integration/bst.test.ts

@@ -183,7 +183,7 @@ describe('Individual package BST operations test', () => {
   });
 
   it('should perform various operations on a Binary Search Tree with object values', () => {
-    const objBST = new BST<{ key: number; keyA: number }>();
+    const objBST = new BST<{key: number; keyA: number}>();
     expect(objBST).toBeInstanceOf(BST);
     objBST.add(11, {key: 11, keyA: 11});
     objBST.add(3, {key: 3, keyA: 3});

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

@@ -219,7 +219,7 @@ describe('AVL Tree Test recursively', () => {
 });
 
 describe('AVLTree APIs test', () => {
-  const avl = new AVLTree<{ id: number; text: string }>();
+  const avl = new AVLTree<{id: number; text: string}>();
   beforeEach(() => {
     avl.clear();
   });

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

@@ -71,10 +71,10 @@ describe('BinaryTreeNode', () => {
 });
 
 describe('BinaryTree', () => {
-  let tree: BinaryTree;
+  let tree: BinaryTree<number>;
 
   beforeEach(() => {
-    tree = new BinaryTree();
+    tree = new BinaryTree<number>();
   });
 
   afterEach(() => {
@@ -99,16 +99,18 @@ describe('BinaryTree', () => {
   });
 
   it('should add and find nodes', () => {
-    tree.add(1);
-    tree.add(2);
-    tree.add(3);
+    tree.add(1, 1);
+    tree.add(2, 2);
+    tree.add(3, 3);
 
     expect(tree.has(1)).toBe(true);
     expect(tree.has(2)).toBe(true);
     expect(tree.has(3)).toBe(true);
     expect(tree.has(4)).toBe(false);
     const node4 = tree.get(4);
+    expect(tree.has(node4)).toBe(false);
     expect(tree.has(node4, node => node)).toBe(false);
+    expect(tree.has('3', node => node.val?.toString())).toBe(true);
   });
 
   it('should getDepth return correct depth', () => {
@@ -241,7 +243,7 @@ describe('BinaryTree Morris Traversal', () => {
 });
 
 describe('BinaryTree APIs test', () => {
-  const avl = new AVLTree<{ id: number; text: string }>();
+  const avl = new AVLTree<{id: number; text: string}>();
   beforeEach(() => {
     avl.clear();
   });
@@ -265,10 +267,14 @@ describe('BinaryTree traversals', () => {
   const arr = [35, 20, 40, 15, 29, null, 50, null, 16, 28, 30, 45, 55];
   tree.refill(arr);
   expect(tree.dfs(node => node.key, 'pre')).toEqual([35, 20, 15, 16, 29, 28, 30, 40, 50, 45, 55]);
-  expect(tree.dfs(node => node.key, 'pre', tree.root, IterationType.RECURSIVE)).toEqual([35, 20, 15, 16, 29, 28, 30, 40, 50, 45, 55]);
+  expect(tree.dfs(node => node.key, 'pre', tree.root, IterationType.RECURSIVE)).toEqual([
+    35, 20, 15, 16, 29, 28, 30, 40, 50, 45, 55
+  ]);
   expect(tree.dfs(node => node.key, 'in')).toEqual([15, 16, 20, 28, 29, 30, 35, 40, 45, 50, 55]);
   expect(tree.dfs(node => node.key, 'post')).toEqual([16, 15, 28, 30, 29, 20, 45, 55, 50, 40, 35]);
-  expect(tree.dfs(node => node.key, 'post', tree.root, IterationType.RECURSIVE)).toEqual([16, 15, 28, 30, 29, 20, 45, 55, 50, 40, 35]);
+  expect(tree.dfs(node => node.key, 'post', tree.root, IterationType.RECURSIVE)).toEqual([
+    16, 15, 28, 30, 29, 20, 45, 55, 50, 40, 35
+  ]);
   expect(tree.bfs(node => node.key, tree.root, IterationType.RECURSIVE)).toEqual([
     35, 20, 40, 15, 29, 50, 16, 28, 30, 45, 55
   ]);
@@ -474,7 +480,6 @@ describe('BinaryTree', () => {
     tree.delete(5);
     tree.delete(7);
     tree.delete(3);
-
     expect(tree.root).toBe(null);
     expect(tree.getHeight()).toBe(-1);
   });

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

@@ -189,7 +189,7 @@ describe('BST operations test', () => {
   });
 
   it('should perform various operations on a Binary Search Tree with object values', () => {
-    const objBST = new BST<{ key: number; keyA: number }>();
+    const objBST = new BST<{key: number; keyA: number}>();
     expect(objBST).toBeInstanceOf(BST);
     objBST.add(11, {key: 11, keyA: 11});
     objBST.add(3, {key: 3, keyA: 3});
@@ -260,7 +260,7 @@ describe('BST operations test', () => {
     objBST.perfectlyBalance();
     expect(objBST.isPerfectlyBalanced()).toBe(true);
 
-    const bfsNodesAfterBalanced: BSTNode<{ key: number; keyA: number }>[] = [];
+    const bfsNodesAfterBalanced: BSTNode<{key: number; keyA: number}>[] = [];
     objBST.bfs(node => bfsNodesAfterBalanced.push(node));
     expect(bfsNodesAfterBalanced[0].key).toBe(8);
     expect(bfsNodesAfterBalanced[bfsNodesAfterBalanced.length - 1].key).toBe(16);
@@ -385,7 +385,7 @@ describe('BST operations test', () => {
     expect(bfsIDs[1]).toBe(12);
     expect(bfsIDs[2]).toBe(16);
 
-    const bfsNodes: BSTNode<{ key: number; keyA: number }>[] = [];
+    const bfsNodes: BSTNode<{key: number; keyA: number}>[] = [];
     objBST.bfs(node => bfsNodes.push(node));
     expect(bfsNodes[0].key).toBe(2);
     expect(bfsNodes[1].key).toBe(12);
@@ -579,7 +579,7 @@ describe('BST operations test recursively', () => {
   });
 
   it('should perform various operations on a Binary Search Tree with object values', () => {
-    const objBST = new BST<{ key: number; keyA: number }>();
+    const objBST = new BST<{key: number; keyA: number}>();
     expect(objBST).toBeInstanceOf(BST);
     objBST.add(11, {key: 11, keyA: 11});
     objBST.add(3, {key: 3, keyA: 3});
@@ -650,7 +650,7 @@ describe('BST operations test recursively', () => {
     objBST.perfectlyBalance();
     expect(objBST.isPerfectlyBalanced()).toBe(true);
 
-    const bfsNodesAfterBalanced: BSTNode<{ key: number; keyA: number }>[] = [];
+    const bfsNodesAfterBalanced: BSTNode<{key: number; keyA: number}>[] = [];
     objBST.bfs(node => bfsNodesAfterBalanced.push(node));
     expect(bfsNodesAfterBalanced[0].key).toBe(8);
     expect(bfsNodesAfterBalanced[bfsNodesAfterBalanced.length - 1].key).toBe(16);
@@ -775,7 +775,7 @@ describe('BST operations test recursively', () => {
     expect(bfsIDs[1]).toBe(12);
     expect(bfsIDs[2]).toBe(16);
 
-    const bfsNodes: BSTNode<{ key: number; keyA: number }>[] = [];
+    const bfsNodes: BSTNode<{key: number; keyA: number}>[] = [];
     objBST.bfs(node => bfsNodes.push(node));
     expect(bfsNodes[0].key).toBe(2);
     expect(bfsNodes[1].key).toBe(12);

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

@@ -29,7 +29,7 @@ describe('Overall BinaryTree Test', () => {
     bfsIDs[0] === 11; // true
     expect(bfsIDs[0]).toBe(11);
 
-    const objBST = new BST<{ key: number; keyA: number }>();
+    const objBST = new BST<{key: number; keyA: number}>();
     objBST.add(11, {key: 11, keyA: 11});
     objBST.add(3, {key: 3, keyA: 3});
 

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

@@ -207,7 +207,7 @@ describe('TreeMultiset operations test', () => {
   });
 
   it('should perform various operations on a Binary Search Tree with object values', () => {
-    const objTreeMultiset = new TreeMultiset<{ key: number; keyA: number }>();
+    const objTreeMultiset = new TreeMultiset<{key: number; keyA: number}>();
     expect(objTreeMultiset).toBeInstanceOf(TreeMultiset);
     objTreeMultiset.add(11, {key: 11, keyA: 11});
     objTreeMultiset.add(3, {key: 3, keyA: 3});
@@ -447,7 +447,7 @@ describe('TreeMultiset operations test recursively', () => {
   });
 
   it('should perform various operations on a Binary Search Tree with object values', () => {
-    const objTreeMultiset = new TreeMultiset<{ key: number; keyA: number }>();
+    const objTreeMultiset = new TreeMultiset<{key: number; keyA: number}>();
     expect(objTreeMultiset).toBeInstanceOf(TreeMultiset);
     objTreeMultiset.add(11, {key: 11, keyA: 11});
     objTreeMultiset.add(3, {key: 3, keyA: 3});

package/test/unit/data-structures/hash/coordinate-map.test.ts

@@ -57,7 +57,7 @@ describe('CoordinateMap', () => {
   class MyCoordinateMap<V = any> extends CoordinateMap<V> {
     constructor(joint?: string) {
       super(joint);
-      this._setJoint(joint += '-')
+      this._setJoint((joint += '-'));
     }
   }
 
@@ -67,7 +67,7 @@ describe('CoordinateMap', () => {
     cMap.set([0, 0], 0);
     cMap.set([0, 1], 1);
     cMap.set([1, 1], 11);
-  })
+  });
   it('should joint to be *-', () => {
     expect(cMap.joint).toBe('*-');
   });

package/test/unit/data-structures/hash/coordinate-set.test.ts

@@ -44,7 +44,7 @@ describe('MyCoordinateSet', () => {
   class MyCoordinateSet extends CoordinateSet {
     constructor(joint?: string) {
       super(joint);
-      this._setJoint(joint += '-')
+      this._setJoint((joint += '-'));
     }
   }
 
@@ -54,7 +54,7 @@ describe('MyCoordinateSet', () => {
     mySet.add([0, 0]);
     mySet.add([0, 1]);
     mySet.add([1, 1]);
-  })
+  });
   it('should joint to be *-', () => {
     expect(mySet.joint).toBe('*-');
   });

package/test/unit/data-structures/heap/heap.test.ts

@@ -22,7 +22,7 @@ describe('Heap Operation Test', () => {
   });
 
   it('should object heap work well', function () {
-    const minHeap = new MinHeap<{ a: string; key: number }>({comparator: (a, b) => a.key - b.key});
+    const minHeap = new MinHeap<{a: string; key: number}>({comparator: (a, b) => a.key - b.key});
     minHeap.add({key: 1, a: 'a1'});
     minHeap.add({key: 6, a: 'a6'});
     minHeap.add({key: 2, a: 'a2'});
@@ -37,7 +37,7 @@ describe('Heap Operation Test', () => {
       i++;
     }
 
-    const maxHeap = new MaxHeap<{ key: number; a: string }>({comparator: (a, b) => b.key - a.key});
+    const maxHeap = new MaxHeap<{key: number; a: string}>({comparator: (a, b) => b.key - a.key});
     maxHeap.add({key: 1, a: 'a1'});
     maxHeap.add({key: 6, a: 'a6'});
     maxHeap.add({key: 5, a: 'a5'});

package/test/unit/data-structures/linked-list/doubly-linked-list.test.ts

@@ -7,7 +7,7 @@ describe('DoublyLinkedListNode', () => {
     expect(node1.val).toBe(2);
     node1.val = 1;
     expect(node1.val).toBe(1);
-  })
+  });
 });
 
 describe('DoublyLinkedList Operation Test', () => {
@@ -38,10 +38,8 @@ describe('DoublyLinkedList Operation Test', () => {
     expect(list.tail?.val).toBe(4);
   });
 
-
   it('should find null', () => {
     expect(list.find(val => val === 6)).toBe(null);
-
   });
 
   it('should indexOf -1', () => {
@@ -60,13 +58,11 @@ describe('DoublyLinkedList Operation Test', () => {
     // @ts-ignore
     expect([...list]).toEqual([1, 2, 3, 4, 5]);
   });
-
-
 });
 
 describe('DoublyLinkedList Operation Test', () => {
   let list: DoublyLinkedList<number>;
-  let objectList: DoublyLinkedList<{ keyA: number }>;
+  let objectList: DoublyLinkedList<{keyA: number}>;
 
   beforeEach(() => {
     list = new DoublyLinkedList();

package/test/unit/data-structures/linked-list/singly-linked-list.test.ts

@@ -7,15 +7,15 @@ describe('SinglyLinkedListNode', () => {
     expect(node1.val).toBe(2);
     node1.val = 1;
     expect(node1.val).toBe(1);
-  })
+  });
 });
 
 describe('SinglyLinkedList Operation Test', () => {
   let list: SinglyLinkedList<number>;
-  let objectList: SinglyLinkedList<{ keyA: number }>;
+  let objectList: SinglyLinkedList<{keyA: number}>;
   beforeEach(() => {
     list = new SinglyLinkedList<number>();
-    objectList = new SinglyLinkedList<{ keyA: number }>();
+    objectList = new SinglyLinkedList<{keyA: number}>();
   });
 
   describe('push', () => {
@@ -446,7 +446,6 @@ describe('SinglyLinkedList', () => {
     expect(list.length).toBe(1);
   });
 
-
   it('should reverse the list', () => {
     list.push(1);
     list.push(2);
@@ -457,7 +456,6 @@ describe('SinglyLinkedList', () => {
     // Add more assertions for reversed order.
   });
 
-
   it('should convert the list to an array', () => {
     list.push(1);
     list.push(2);
@@ -475,13 +473,12 @@ describe('SinglyLinkedList', () => {
     expect(list.filter(val => val !== 2).toArray()).toEqual([1, 3]);
   });
 
-
   it('should forEach the list', () => {
     list.push(1);
     list.push(2);
     list.push(3);
     list.forEach(val => val++);
-    expect(list.toArray()).toEqual([1, 2, 3])
+    expect(list.toArray()).toEqual([1, 2, 3]);
   });
 
   it('should map the list', () => {

package/test/unit/data-structures/priority-queue/max-priority-queue.test.ts

@@ -17,7 +17,7 @@ describe('MaxPriorityQueue Operation Test', () => {
   });
 
   it('should add elements and maintain heap property in a object MaxPriorityQueue', () => {
-    const priorityQueue = new MaxPriorityQueue<{ keyA: number }>({comparator: (a, b) => b.keyA - a.keyA});
+    const priorityQueue = new MaxPriorityQueue<{keyA: number}>({comparator: (a, b) => b.keyA - a.keyA});
     priorityQueue.refill([{keyA: 5}, {keyA: 3}, {keyA: 1}]);
     priorityQueue.add({keyA: 7});
 
@@ -64,7 +64,7 @@ describe('MaxPriorityQueue Operation Test', () => {
 
   it('should correctly heapify an object array', () => {
     const nodes = [{keyA: 5}, {keyA: 3}, {keyA: 7}, {keyA: 1}];
-    const maxPQ = MaxPriorityQueue.heapify<{ keyA: number }>({nodes: nodes, comparator: (a, b) => b.keyA - a.keyA});
+    const maxPQ = MaxPriorityQueue.heapify<{keyA: number}>({nodes: nodes, comparator: (a, b) => b.keyA - a.keyA});
 
     expect(maxPQ.poll()?.keyA).toBe(7);
     expect(maxPQ.poll()?.keyA).toBe(5);

package/test/utils/big-o.ts

@@ -26,7 +26,7 @@ export const bigO = {
 
 function findPotentialN(input: any): number {
   let longestArray: any[] = [];
-  let mostProperties: { [key: string]: any } = {};
+  let mostProperties: {[key: string]: any} = {};
 
   function recurse(obj: any) {
     if (Array.isArray(obj)) {