data-structure-typed 1.49.1 → 1.49.2

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

@@ -6,7 +6,7 @@ const suite = new Benchmark.Suite();
 const { HUNDRED_THOUSAND, TEN_THOUSAND } = magnitude;
 
 suite
-  .add(`${HUNDRED_THOUSAND.toLocaleString()} add & pop`, () => {
+  .add(`${HUNDRED_THOUSAND.toLocaleString()} add & poll`, () => {
     const heap = new Heap<number>([], { comparator: (a, b) => b - a });
 
     for (let i = 0; i < HUNDRED_THOUSAND; i++) {
@@ -14,7 +14,7 @@ suite
     }
 
     for (let i = 0; i < HUNDRED_THOUSAND; i++) {
-      heap.pop();
+      heap.poll();
     }
   })
   .add(`${HUNDRED_THOUSAND.toLocaleString()} add & dfs`, () => {

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

@@ -55,7 +55,7 @@ suite
       list.shift();
     }
   })
-  .add(`${LINEAR.toLocaleString()} insertBefore`, () => {
+  .add(`${LINEAR.toLocaleString()} addBefore`, () => {
     const doublyList = new DoublyLinkedList<number>();
     let midNode: DoublyLinkedListNode | undefined;
     const midIndex = Math.floor(LINEAR / 2);
@@ -64,7 +64,7 @@ suite
       if (i === midIndex) {
         midNode = doublyList.getNode(i);
       } else if (i > midIndex && midNode) {
-        doublyList.insertBefore(midNode, i);
+        doublyList.addBefore(midNode, i);
       }
     }
   });

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

@@ -28,7 +28,7 @@ suite
       list.pop();
     }
   })
-  .add(`${TEN_THOUSAND.toLocaleString()} insertBefore`, () => {
+  .add(`${TEN_THOUSAND.toLocaleString()} addBefore`, () => {
     const singlyList = new SinglyLinkedList<number>();
     let midSinglyNode: SinglyLinkedListNode | undefined;
     const midIndex = Math.floor(TEN_THOUSAND / 2);
@@ -37,7 +37,7 @@ suite
       if (i === midIndex) {
         midSinglyNode = singlyList.getNode(i);
       } else if (i > midIndex && midSinglyNode) {
-        singlyList.insertBefore(midSinglyNode.value, i);
+        singlyList.addBefore(midSinglyNode.value, i);
       }
     }
   });

package/test/performance/data-structures/priority-queue/priority-queue.test.ts

@@ -7,7 +7,7 @@ import { isCompetitor } from '../../../config';
 const suite = new Benchmark.Suite();
 const { HUNDRED_THOUSAND } = magnitude;
 
-suite.add(`${HUNDRED_THOUSAND.toLocaleString()} add & pop`, () => {
+suite.add(`${HUNDRED_THOUSAND.toLocaleString()} add & poll`, () => {
   const pq = new PriorityQueue<number>([], { comparator: (a, b) => b - a });
 
   for (let i = 0; i < HUNDRED_THOUSAND; i++) {
@@ -15,7 +15,7 @@ suite.add(`${HUNDRED_THOUSAND.toLocaleString()} add & pop`, () => {
   }
 
   for (let i = 0; i < HUNDRED_THOUSAND; i++) {
-    pq.pop();
+    pq.poll();
   }
 });
 if (isCompetitor) {

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

@@ -1,8 +1,8 @@
 import { BinaryTree, BinaryTreeNode, FamilyPosition, IterationType } from '../../../../src';
 import { getRandomIntArray } from '../../../utils';
-import { isDebugTest } from '../../../config';
+// import { isDebugTest } from '../../../config';
 
-const isDebug = isDebugTest;
+// const isDebug = isDebugTest;
 
 describe('BinaryTreeNode', () => {
   it('should create an instance of BinaryTreeNode', () => {

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

@@ -453,7 +453,7 @@ describe('LinkedHashMap Test2', () => {
         expect(hashMap.last).toEqual([key, value]);
         expect(hashMap.reverseBegin().next().value).toEqual([key, value]);
       } else if (index <= 1000) {
-        expect(hashMap.getAt(index)).toEqual([key, value]);
+        expect(hashMap.getAt(index)).toBe(value);
       }
       expect(hashMap.get(key)).toEqual(value);
       index++;
@@ -502,7 +502,7 @@ describe('LinkedHashMap Test2', () => {
   test('should get element at specific index', () => {
     hashMap.set('key1', 'value1');
     hashMap.set('key2', 'value2');
-    expect(hashMap.getAt(1)).toEqual(['key2', 'value2']);
+    expect(hashMap.getAt(1)).toBe('value2');
   });
 });
 

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

@@ -5,7 +5,7 @@ import { logBigOMetricsWrap } from '../../../utils';
 describe('Heap Operation Test', () => {
   it('should numeric heap work well', function () {
     const minNumHeap = new MinHeap<number>();
-    minNumHeap.add(1).add(6).add(2).add(0).add(5).add(9);
+    minNumHeap.add(1);minNumHeap.add(6);minNumHeap.add(2);minNumHeap.add(0);minNumHeap.add(5);minNumHeap.add(9);
     expect(minNumHeap.has(1)).toBe(true);
     expect(minNumHeap.has(2)).toBe(true);
     expect(minNumHeap.poll()).toBe(0);

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

@@ -55,7 +55,7 @@ describe('MinHeap', () => {
 
   it('should push & dfs', () => {
     for (let i = 0; i < n; i++) {
-      minHeap.push(i);
+      minHeap.add(i);
     }
     expect(minHeap.dfs()[0]).toBe(0)
     expect(minHeap.dfs()[999]).toBe(4126)

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

@@ -19,11 +19,11 @@ describe('DoublyLinkedList Operation Test', () => {
   it('should out of bound index', () => {
     expect(list.getNodeAt(-1)).toBe(undefined);
     expect(list.getNodeAt(5)).toBe(undefined);
-    expect(list.insertAt(5, 6)).toBe(true);
+    expect(list.addAt(5, 6)).toBe(true);
   });
 
-  it('should insertBefore', () => {
-    expect(list.insertBefore(1, 0)).toBe(true);
+  it('should addBefore', () => {
+    expect(list.addBefore(1, 0)).toBe(true);
   });
 
   it('should deleteAt', () => {
@@ -49,11 +49,11 @@ describe('DoublyLinkedList Operation Test', () => {
     expect(list.findBackward(value => value === 0)).toBe(undefined);
   });
 
-  it('should insertAfter tail', () => {
-    expect(list.insertAfter(list.tail!, 6)).toBe(true);
+  it('should addAfter tail', () => {
+    expect(list.addAfter(list.tail!, 6)).toBe(true);
   });
 
-  it('should insertAfter tail', () => {
+  it('should addAfter tail', () => {
     expect([...list]).toEqual([1, 2, 3, 4, 5]);
   });
 });
@@ -68,7 +68,7 @@ describe('DoublyLinkedList Operation Test', () => {
   });
 
   it('should initialize an empty list', () => {
-    expect(list.length).toBe(0);
+    expect(list.size).toBe(0);
     expect(list.head).toBe(undefined);
     expect(list.tail).toBe(undefined);
   });
@@ -77,7 +77,7 @@ describe('DoublyLinkedList Operation Test', () => {
     list.push(1);
     list.push(2);
     list.push(3);
-    expect(list.length).toBe(3);
+    expect(list.size).toBe(3);
     expect(list.head!.value).toBe(1);
     expect(list.tail!.value).toBe(3);
   });
@@ -87,7 +87,7 @@ describe('DoublyLinkedList Operation Test', () => {
     list.push(2);
     const poppedValue = list.pop();
     expect(poppedValue).toBe(2);
-    expect(list.length).toBe(1);
+    expect(list.size).toBe(1);
     expect(list.head!.value).toBe(1);
     expect(list.tail!.value).toBe(1);
   });
@@ -97,20 +97,20 @@ describe('DoublyLinkedList Operation Test', () => {
     list.push(3);
 
     // Inserting at the beginning
-    list.insertAt(0, 0);
-    expect(list.length).toBe(4);
+    list.addAt(0, 0);
+    expect(list.size).toBe(4);
     expect(list.getAt(0)).toBe(0);
     expect(list.getAt(1)).toBe(1);
 
     // Inserting in the middle
-    list.insertAt(2, 1.5);
-    expect(list.length).toBe(5);
+    list.addAt(2, 1.5);
+    expect(list.size).toBe(5);
     expect(list.getAt(2)).toBe(1.5);
     expect(list.getAt(3)).toBe(2);
 
     // Inserting at the end
-    list.insertAt(5, 4);
-    expect(list.length).toBe(6);
+    list.addAt(5, 4);
+    expect(list.size).toBe(6);
     expect(list.getAt(5)).toBe(4);
     expect(list.tail!.value).toBe(4);
   });
@@ -122,18 +122,18 @@ describe('DoublyLinkedList Operation Test', () => {
 
     // Deleting from the beginning
     const deletedValue = list.deleteAt(0);
-    expect(deletedValue).toBe(1);
-    expect(list.length).toBe(2);
+    expect(deletedValue).toBe(true);
+    expect(list.size).toBe(2);
     expect(list.head!.value).toBe(2);
 
     // Deleting from the middle
     list.deleteAt(0); // Deleting the second element
-    expect(list.length).toBe(1);
+    expect(list.size).toBe(1);
     expect(list.head!.value).toBe(3);
 
     // Deleting from the end
     list.deleteAt(0);
-    expect(list.length).toBe(0);
+    expect(list.size).toBe(0);
     expect(list.head).toBe(undefined);
     expect(list.tail).toBe(undefined);
   });
@@ -144,16 +144,16 @@ describe('DoublyLinkedList Operation Test', () => {
     list.push(3);
 
     list.delete(2);
-    expect(list.length).toBe(2);
+    expect(list.size).toBe(2);
     expect(list.head!.value).toBe(1);
     expect(list.tail!.value).toBe(3);
 
     list.delete(1);
-    expect(list.length).toBe(1);
+    expect(list.size).toBe(1);
     expect(list.head!.value).toBe(3);
 
     list.delete(3);
-    expect(list.length).toBe(0);
+    expect(list.size).toBe(0);
     expect(list.head).toBe(undefined);
     expect(list.tail).toBe(undefined);
   });
@@ -206,7 +206,7 @@ describe('DoublyLinkedList Operation Test', () => {
     list.push(2);
     list.push(3);
 
-    list.insertAfter(2, 2.5);
+    list.addAfter(2, 2.5);
 
     expect(list.toArray()).toEqual([1, 2, 2.5, 3]);
   });
@@ -216,7 +216,7 @@ describe('DoublyLinkedList Operation Test', () => {
     list.push(2);
     list.push(3);
 
-    list.insertBefore(2, 1.5);
+    list.addBefore(2, 1.5);
 
     expect(list.toArray()).toEqual([1, 1.5, 2, 3]);
   });
@@ -258,7 +258,7 @@ describe('DoublyLinkedList Operation Test', () => {
 
     list.clear();
 
-    expect(list.length).toBe(0);
+    expect(list.size).toBe(0);
     expect(list.head).toBe(undefined);
     expect(list.tail).toBe(undefined);
   });
@@ -334,7 +334,7 @@ describe('DoublyLinkedList Operation Test', () => {
     list.push(2);
     list.push(3);
 
-    const success = list.insertAfter(2, 4);
+    const success = list.addAfter(2, 4);
     expect(success).toBe(true);
     expect(list.toArray()).toEqual([1, 2, 4, 3]);
   });
@@ -344,7 +344,7 @@ describe('DoublyLinkedList Operation Test', () => {
     list.push(2);
     list.push(3);
 
-    const success = list.insertBefore(2, 0);
+    const success = list.addBefore(2, 0);
     expect(success).toBe(true);
     expect(list.toArray()).toEqual([1, 0, 2, 3]);
   });
@@ -354,7 +354,7 @@ describe('DoublyLinkedList Operation Test', () => {
     list.push(2);
     list.push(3);
 
-    const success = list.insertAfter(4, 5);
+    const success = list.addAfter(4, 5);
     expect(success).toBe(false);
     expect(list.toArray()).toEqual([1, 2, 3]);
   });
@@ -364,7 +364,7 @@ describe('DoublyLinkedList Operation Test', () => {
     list.push(2);
     list.push(3);
 
-    const success = list.insertBefore(4, 0);
+    const success = list.addBefore(4, 0);
     expect(success).toBe(false);
     expect(list.toArray()).toEqual([1, 2, 3]);
   });
@@ -381,7 +381,7 @@ describe('DoublyLinkedList Operation Test', () => {
     expect(objectList.toArray()).toEqual([obj1, obj2, obj3]);
 
     const newObj = { keyA: 25 }; // Corrected newObj value
-    const insertSuccess = objectList.insertBefore(obj2, newObj);
+    const insertSuccess = objectList.addBefore(obj2, newObj);
     expect(insertSuccess).toBe(true);
 
     const getNode = objectList.getNode(newObj); // Use newObj instead of obj2

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

@@ -2,7 +2,7 @@
 // import {bigO, magnitude} from '../../../utils';
 
 describe('LinkedList Performance Test', () => {
-  it('should DoublyLinkedList insertBefore faster than SinglyLinkedList', () => {
+  it('should DoublyLinkedList addBefore faster than SinglyLinkedList', () => {
     expect(1).toBe(1);
   });
 });

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

@@ -84,12 +84,12 @@ describe('SinglyLinkedList Operation Test', () => {
     });
   });
 
-  describe('insertAfter', () => {
+  describe('addAfter', () => {
     it('should insert an element after an existing value', () => {
       list.push(1);
       list.push(2);
       list.push(3);
-      list.insertAfter(2, 4);
+      list.addAfter(2, 4);
       expect(list.toArray()).toEqual([1, 2, 4, 3]);
     });
 
@@ -97,7 +97,7 @@ describe('SinglyLinkedList Operation Test', () => {
       list.push(1);
       list.push(2);
       list.push(3);
-      const result = list.insertAfter(5, 4);
+      const result = list.addAfter(5, 4);
       expect(result).toBe(false);
       expect(list.toArray()).toEqual([1, 2, 3]);
     });
@@ -164,7 +164,7 @@ describe('SinglyLinkedList Operation Test', () => {
       list.push(3);
       list.clear();
       expect(list.toArray()).toEqual([]);
-      expect(list.length).toBe(0);
+      expect(list.size).toBe(0);
       expect(list.isEmpty()).toBe(true);
     });
   });
@@ -223,19 +223,19 @@ describe('SinglyLinkedList Operation Test', () => {
     });
   });
 
-  describe('insertBefore', () => {
+  describe('addBefore', () => {
     it('should insert an element before an existing value', () => {
       list.push(1);
       list.push(2);
       list.push(3);
-      list.insertBefore(2, 4);
+      list.addBefore(2, 4);
       expect(list.toArray()).toEqual([1, 4, 2, 3]);
     });
 
     it('should insert an element at the beginning', () => {
       list.push(1);
       list.push(2);
-      list.insertBefore(1, 3);
+      list.addBefore(1, 3);
       expect(list.toArray()).toEqual([3, 1, 2]);
     });
 
@@ -243,7 +243,7 @@ describe('SinglyLinkedList Operation Test', () => {
       list.push(1);
       list.push(2);
       list.push(3);
-      const result = list.insertBefore(5, 4);
+      const result = list.addBefore(5, 4);
       expect(result).toBe(false);
       expect(list.toArray()).toEqual([1, 2, 3]);
     });
@@ -251,10 +251,10 @@ describe('SinglyLinkedList Operation Test', () => {
 
   describe('getLength', () => {
     it('should return the correct length of the list', () => {
-      expect(list.length).toBe(0);
+      expect(list.size).toBe(0);
       list.push(1);
       list.push(2);
-      expect(list.length).toBe(2);
+      expect(list.size).toBe(2);
     });
   });
 
@@ -264,21 +264,21 @@ describe('SinglyLinkedList Operation Test', () => {
       list.push(2);
       list.push(3);
       const removed = list.deleteAt(1);
-      expect(removed).toBe(2);
+      expect(removed).toBe(true);
       expect(list.toArray()).toEqual([1, 3]);
     });
 
     it('should return undefined for an out-of-bounds index', () => {
       list.push(1);
       const removed = list.deleteAt(1);
-      expect(removed).toBeUndefined();
+      expect(removed).toBe(false);
     });
 
     it('should delete and return the first element', () => {
       list.push(1);
       list.push(2);
       const removed = list.deleteAt(0);
-      expect(removed).toBe(1);
+      expect(removed).toBe(true);
       expect(list.toArray()).toEqual([2]);
     });
 
@@ -286,7 +286,7 @@ describe('SinglyLinkedList Operation Test', () => {
       list.push(1);
       list.push(2);
       const removed = list.deleteAt(1);
-      expect(removed).toBe(2);
+      expect(removed).toBe(true);
       expect(list.toArray()).toEqual([1]);
     });
   });
@@ -313,9 +313,9 @@ describe('SinglyLinkedList Operation Test', () => {
 
   describe('insert and toArray', () => {
     it('should insert elements and return array correctly', () => {
-      list.insertAt(0, 1);
-      list.insertAt(1, 3);
-      list.insertAt(1, 2);
+      list.addAt(0, 1);
+      list.addAt(1, 3);
+      list.addAt(1, 2);
       expect(list.toArray()).toEqual([1, 2, 3]);
     });
   });
@@ -377,7 +377,7 @@ describe('SinglyLinkedList Operation Test', () => {
     expect(objectList.toArray()).toEqual([obj1, obj2, obj3]);
 
     const newObj = { keyA: 2.5 }; // Corrected newObj value
-    const insertSuccess = objectList.insertBefore(obj2, newObj);
+    const insertSuccess = objectList.addBefore(obj2, newObj);
     expect(insertSuccess).toBe(true);
 
     const getNode = objectList.getNode(newObj); // Use newObj instead of obj2
@@ -404,7 +404,7 @@ describe('SinglyLinkedList', () => {
   it('should initialize an empty list', () => {
     expect(list.head).toBe(undefined);
     expect(list.tail).toBe(undefined);
-    expect(list.length).toBe(0);
+    expect(list.size).toBe(0);
   });
 
   it('should push elements to the end of the list', () => {
@@ -412,7 +412,7 @@ describe('SinglyLinkedList', () => {
     list.push(2);
     expect(list.head!.value).toBe(1);
     expect(list.tail!.value).toBe(2);
-    expect(list.length).toBe(2);
+    expect(list.size).toBe(2);
   });
 
   it('should pop elements from the end of the list', () => {
@@ -422,7 +422,7 @@ describe('SinglyLinkedList', () => {
     expect(popped).toBe(2);
     expect(list.head!.value).toBe(1);
     expect(list.tail!.value).toBe(1);
-    expect(list.length).toBe(1);
+    expect(list.size).toBe(1);
   });
 
   it('should reverse the list', () => {

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

@@ -66,11 +66,11 @@ describe('SkipList', () => {
   });
 
   it('getFirst() should return the getFirst element', () => {
-    expect(skipList.getFirst()).toBe('One');
+    expect(skipList.first).toBe('One');
   });
 
   it('getLast() should return the getLast element', () => {
-    expect(skipList.getLast()).toBe('Four');
+    expect(skipList.last).toBe('Four');
   });
 
   it('higher(key) should return the getFirst element greater than the given key', () => {

package/test/unit/data-structures/queue/deque.test.ts

@@ -1,7 +1,7 @@
 import { Deque } from '../../../../src';
-import { isDebugTest } from '../../../config';
+// import { isDebugTest } from '../../../config';
 
-const isDebug = isDebugTest;
+// const isDebug = isDebugTest;
 
 describe('Deque - Basic Operations', () => {
   let deque: Deque<number>;
@@ -57,10 +57,10 @@ describe('Deque - Complex Operations', () => {
     deque = new Deque<number>();
   });
 
-  test('insertAt should insert elements at the specified position', () => {
+  test('addAt should insert elements at the specified position', () => {
     deque.push(1);
     deque.push(3);
-    deque.insertAt(1, 2);
+    deque.addAt(1, 2);
     expect(deque.toArray()).toEqual([1, 2, 3]);
   });
 
@@ -111,7 +111,7 @@ describe('Deque - Complex Operations', () => {
     deque.push(1);
     deque.push(2);
     deque.sort((a, b) => a - b);
-    expect(deque.toArray()).toEqual([1, 2, 3]);
+    expect([...deque]).toEqual([1, 2, 3]);
   });
 
   test('shrinkToFit should reduce the memory footprint', () => {

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

@@ -1,7 +1,7 @@
 import { LinkedListQueue, Queue } from '../../../../src';
-import { isDebugTest } from '../../../config';
+// import { isDebugTest } from '../../../config';
 
-const isDebug = isDebugTest;
+// const isDebug = isDebugTest;
 
 describe('Queue', () => {
   let queue: Queue<number>;
@@ -224,7 +224,7 @@ describe('LinkedListQueue', () => {
     queue.enqueue('A');
     queue.enqueue('B');
     expect(queue.peek()).toBe('A');
-    expect(queue.length).toBe(2);
+    expect(queue.size).toBe(2);
   });
 
   it('should dequeue elements from the front of the queue', () => {
@@ -233,7 +233,7 @@ describe('LinkedListQueue', () => {
     const dequeued = queue.dequeue();
     expect(dequeued).toBe('A');
     expect(queue.peek()).toBe('B');
-    expect(queue.length).toBe(1);
+    expect(queue.size).toBe(1);
   });
 
   it('should peek at the front of the queue', () => {

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

@@ -843,7 +843,7 @@ describe('Trie class', () => {
 
   test('filter should return words that satisfy the predicate', () => {
     const filteredWords = trie.filter(word => word.startsWith('ba'));
-    expect(filteredWords).toEqual(['banana', 'band', 'bandana']);
+    expect([...filteredWords]).toEqual(['banana', 'band', 'bandana']);
   });
 
   test('map should apply a function to each word', () => {