data-structure-typed 1.39.1 → 1.39.2

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

@@ -39,3 +39,28 @@ describe('CoordinateSet', () => {
     expect(hasValue).toBe(true);
   });
 });
+
+describe('MyCoordinateSet', () => {
+  class MyCoordinateSet extends CoordinateSet {
+    constructor(joint?: string) {
+      super(joint);
+      this._setJoint(joint += '-')
+    }
+  }
+
+  const mySet = new MyCoordinateSet('*');
+
+  beforeEach(() => {
+    mySet.add([0, 0]);
+    mySet.add([0, 1]);
+    mySet.add([1, 1]);
+  })
+  it('should joint to be *-', () => {
+    expect(mySet.joint).toBe('*-');
+  });
+
+  it('should has, delete', () => {
+    mySet.delete([0, 1]);
+    expect(mySet.has([0, 1])).toBe(false);
+  });
+});

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

@@ -15,7 +15,9 @@ describe('HashNode', () => {
 describe('HashTable', () => {
   it('should initialize with default capacity', () => {
     const hashTable = new HashTable<string, string>();
-
+    hashTable.capacity = hashTable.capacity;
+    hashTable.buckets = hashTable.buckets;
+    hashTable.hashFn = hashTable.hashFn;
     expect(hashTable.capacity).toBe(16);
     expect(hashTable.size).toBe(0);
     expect(hashTable.buckets.length).toBe(16);

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

@@ -1,9 +1,72 @@
-import {DoublyLinkedList} from '../../../../src';
+import {DoublyLinkedList, DoublyLinkedListNode} from '../../../../src';
 import {bigO, magnitude} from '../../../utils';
 
+describe('DoublyLinkedListNode', () => {
+  it('should DoublyLinkedListNode', () => {
+    const node1 = new DoublyLinkedListNode<number>(2);
+    expect(node1.val).toBe(2);
+    node1.val = 1;
+    expect(node1.val).toBe(1);
+  })
+});
+
+describe('DoublyLinkedList Operation Test', () => {
+  let list: DoublyLinkedList<number>;
+
+  beforeEach(() => {
+    list = DoublyLinkedList.fromArray([1, 2, 3, 4, 5]);
+  });
+
+  it('should out of bound index', () => {
+    expect(list.getNodeAt(-1)).toBe(null);
+    expect(list.getNodeAt(5)).toBe(null);
+    expect(list.insertAt(5, 6)).toBe(true);
+  });
+
+  it('should insertBefore', () => {
+    expect(list.insertBefore(1, 0)).toBe(true);
+  });
+
+  it('should deleteAt', () => {
+    expect(list.deleteAt(1)).toBeTruthy();
+  });
+
+  it('should delete tail', () => {
+    expect(list.delete(list.tail)).toBe(true);
+    expect(list.tail?.val).toBe(4);
+    expect(list.delete(6)).toBe(false);
+    expect(list.tail?.val).toBe(4);
+  });
+
+
+  it('should find null', () => {
+    expect(list.find(val => val === 6)).toBe(null);
+
+  });
+
+  it('should indexOf -1', () => {
+    expect(list.indexOf(6)).toBe(-1);
+  });
+
+  it('should findBackward null', () => {
+    expect(list.findBackward(val => val === 0)).toBe(null);
+  });
+
+  it('should insertAfter tail', () => {
+    expect(list.insertAfter(list.tail!, 6)).toBe(true);
+  });
+
+  it('should insertAfter tail', () => {
+    // @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();
@@ -109,7 +172,7 @@ describe('DoublyLinkedList Operation Test', () => {
     list.reverse();
 
     expect(list.toArray()).toEqual([3, 2, 1]);
-    expect(list.toArrayReverse()).toEqual([1, 2, 3]);
+    expect(list.toArrayBackward()).toEqual([1, 2, 3]);
   });
 
   it('should map elements using a callback function', () => {
@@ -189,7 +252,7 @@ describe('DoublyLinkedList Operation Test', () => {
     list.push(3);
     list.push(4);
 
-    const lastEven = list.findLast(val => val % 2 === 0);
+    const lastEven = list.findBackward(val => val % 2 === 0);
 
     expect(lastEven).toBe(4);
   });
@@ -211,7 +274,7 @@ describe('DoublyLinkedList Operation Test', () => {
     list.push(2);
     list.push(3);
 
-    const reversedArray = list.toArrayReverse();
+    const reversedArray = list.toArrayBackward();
 
     expect(reversedArray).toEqual([3, 2, 1]);
   });
@@ -327,8 +390,8 @@ describe('DoublyLinkedList Operation Test', () => {
     const insertSuccess = objectList.insertBefore(obj2, newObj);
     expect(insertSuccess).toBe(true);
 
-    const findNode = objectList.findNode(newObj); // Use newObj instead of obj2
-    expect(findNode?.val).toEqual(newObj);
+    const getNode = objectList.getNode(newObj); // Use newObj instead of obj2
+    expect(getNode?.val).toEqual(newObj);
 
     const deleted = objectList.delete(newObj); // Use newObj instead of obj2
     expect(deleted).toBe(true);

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

@@ -11,7 +11,7 @@ describe('LinkedList Performance Test', () => {
     for (let i = 0; i < magnitude.SQUARED; i++) {
       doublyList.push(i);
       if (i === midIndex) {
-        midNode = doublyList.findNode(i);
+        midNode = doublyList.getNode(i);
       } else if (i > midIndex && midNode) {
         doublyList.insertBefore(midNode, i);
       }
@@ -24,7 +24,7 @@ describe('LinkedList Performance Test', () => {
     for (let i = 0; i < magnitude.SQUARED; i++) {
       singlyList.push(i);
       if (i === midIndex) {
-        midSinglyNode = singlyList.findNode(i);
+        midSinglyNode = singlyList.getNode(i);
       } else if (i > midIndex && midSinglyNode) {
         singlyList.insertBefore(midSinglyNode.val, i);
       }

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

@@ -1,12 +1,21 @@
-import {SinglyLinkedList} from '../../../../src';
+import {SinglyLinkedList, SinglyLinkedListNode} from '../../../../src';
 import {bigO, magnitude} from '../../../utils';
 
+describe('SinglyLinkedListNode', () => {
+  it('should SinglyLinkedList', () => {
+    const node1 = new SinglyLinkedListNode<number>(2);
+    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', () => {
@@ -21,8 +30,10 @@ describe('SinglyLinkedList Operation Test', () => {
     it('should delete and return the last element of the list', () => {
       list.push(1);
       list.push(2);
+      list.push(3);
       const popped = list.pop();
-      expect(popped).toBe(2);
+      expect(popped).toBe(3);
+      expect(list.popLast()).toBe(2);
       expect(list.toArray()).toEqual([1]);
     });
 
@@ -36,9 +47,11 @@ describe('SinglyLinkedList Operation Test', () => {
     it('should delete and return the first element of the list', () => {
       list.push(1);
       list.push(2);
+      list.push(3);
       const shifted = list.shift();
       expect(shifted).toBe(1);
-      expect(list.toArray()).toEqual([2]);
+      expect(list.popFirst()).toBe(2);
+      expect(list.toArray()).toEqual([3]);
     });
 
     it('should return undefined if the list is empty', () => {
@@ -50,7 +63,7 @@ describe('SinglyLinkedList Operation Test', () => {
   describe('unshift', () => {
     it('should add elements to the beginning of the list', () => {
       list.unshift(1);
-      list.unshift(2);
+      list.addFirst(2);
       expect(list.toArray()).toEqual([2, 1]);
     });
   });
@@ -62,6 +75,7 @@ describe('SinglyLinkedList Operation Test', () => {
       list.push(3);
       const element = list.getAt(1);
       expect(element).toBe(2);
+      expect(list.getNodeAt(2)?.val).toBe(3);
     });
 
     it('should return undefined for an out-of-bounds index', () => {
@@ -113,9 +127,14 @@ describe('SinglyLinkedList Operation Test', () => {
       list.push(1);
       list.push(2);
       list.push(3);
-      const removed = list.delete(2);
-      expect(removed).toBe(true);
-      expect(list.toArray()).toEqual([1, 3]);
+      list.push(4);
+      list.push(5);
+      expect(list.delete(2)).toBe(true);
+      expect(list.toArray()).toEqual([1, 3, 4, 5]);
+      expect(list.delete(1)).toBe(true);
+      expect(list.toArray()).toEqual([3, 4, 5]);
+      expect(list.delete(5)).toBe(true);
+      expect(list.toArray()).toEqual([3, 4]);
     });
 
     it('should return false if the value is not found', () => {
@@ -362,8 +381,8 @@ describe('SinglyLinkedList Operation Test', () => {
     const insertSuccess = objectList.insertBefore(obj2, newObj);
     expect(insertSuccess).toBe(true);
 
-    const findNode = objectList.findNode(newObj); // Use newObj instead of obj2
-    expect(findNode?.val).toEqual(newObj);
+    const getNode = objectList.getNode(newObj); // Use newObj instead of obj2
+    expect(getNode?.val).toEqual(newObj);
 
     const deleted = objectList.delete(newObj); // Use newObj instead of obj2
     expect(deleted).toBe(true);
@@ -427,7 +446,6 @@ describe('SinglyLinkedList', () => {
     expect(list.length).toBe(1);
   });
 
-  // Add more test cases for other methods like shift, unshift, getAt, deleteAt, and more.
 
   it('should reverse the list', () => {
     list.push(1);
@@ -439,7 +457,6 @@ describe('SinglyLinkedList', () => {
     // Add more assertions for reversed order.
   });
 
-  // Add more test cases for other methods like find, indexOf, and more.
 
   it('should convert the list to an array', () => {
     list.push(1);
@@ -447,5 +464,35 @@ describe('SinglyLinkedList', () => {
     list.push(3);
     const array = list.toArray();
     expect(array).toEqual([1, 2, 3]);
+    // @ts-ignore
+    expect([...list]).toEqual([1, 2, 3]);
+  });
+
+  it('should filter the list', () => {
+    list.push(1);
+    list.push(2);
+    list.push(3);
+    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])
+  });
+
+  it('should map the list', () => {
+    list.addLast(1);
+    list.push(2);
+    list.push(3);
+    expect(list.map(val => val * 2).toArray()).toEqual([2, 4, 6]);
+  });
+
+  it('should reduce the list', () => {
+    const list1 = SinglyLinkedList.fromArray([1, 2, 3]);
+    expect(list1.reduce((acc, val) => acc + val, 0)).toEqual(6);
   });
 });

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/unit/data-structures/queue/deque.test.ts

@@ -15,20 +15,20 @@ describe('Deque Tests', () => {
     it('should add elements at the beginning and end', () => {
       deque.addFirst(1);
       deque.addLast(2);
-      expect(deque.peekFirst()).toBe(1);
-      expect(deque.peekLast()).toBe(2);
+      expect(deque.getFirst()).toBe(1);
+      expect(deque.getLast()).toBe(2);
     });
 
     it('should delete elements from the beginning and end', () => {
       deque.addFirst(1);
       deque.addLast(2);
-      deque.pollFirst();
-      deque.pollLast();
+      deque.popFirst();
+      deque.popLast();
       expect(deque.isEmpty()).toBe(true);
     });
 
     it('should handle edge case when removing from an empty deque', () => {
-      const result = deque.pollFirst();
+      const result = deque.popFirst();
       expect(result).toBeUndefined();
     });
 
@@ -40,18 +40,18 @@ describe('Deque Tests', () => {
 
     it('should handle adding and removing elements alternately', () => {
       deque.addFirst(1);
-      expect(deque.pollFirst()).toBe(1);
+      expect(deque.popFirst()).toBe(1);
       deque.addLast(2);
-      expect(deque.pollLast()).toBe(2);
+      expect(deque.popLast()).toBe(2);
       expect(deque.isEmpty()).toBe(true);
     });
 
     it('should handle adding and removing elements in a cyclic manner', () => {
       deque.addFirst(1);
       deque.addLast(2);
-      expect(deque.pollFirst()).toBe(1);
+      expect(deque.popFirst()).toBe(1);
       deque.addFirst(3);
-      expect(deque.pollLast()).toBe(2);
+      expect(deque.popLast()).toBe(2);
       expect(deque.size).toBe(1);
     });
     // Add more test cases as needed
@@ -68,20 +68,20 @@ describe('Deque Tests', () => {
     it('should add elements at the beginning and end', () => {
       objectDeque.addFirst('one');
       objectDeque.addLast('two');
-      expect(objectDeque.peekFirst()).toBe('one');
-      expect(objectDeque.peekLast()).toBe('two');
+      expect(objectDeque.getFirst()).toBe('one');
+      expect(objectDeque.getLast()).toBe('two');
     });
 
     it('should delete elements from the beginning and end', () => {
       objectDeque.addFirst('one');
       objectDeque.addLast('two');
-      objectDeque.pollFirst();
-      objectDeque.pollLast();
+      objectDeque.popFirst();
+      objectDeque.popLast();
       expect(objectDeque.isEmpty()).toBe(true);
     });
 
     it('should handle edge case when removing from an empty deque', () => {
-      const result = objectDeque.pollFirst();
+      const result = objectDeque.popFirst();
       expect(result).toBeUndefined();
     });
 
@@ -105,20 +105,20 @@ describe('Deque Tests', () => {
     it('should add elements at the beginning and end', () => {
       arrayDeque.addFirst(1);
       arrayDeque.addLast(2);
-      expect(arrayDeque.peekFirst()).toBe(1);
-      expect(arrayDeque.peekLast()).toBe(2);
+      expect(arrayDeque.getFirst()).toBe(1);
+      expect(arrayDeque.getLast()).toBe(2);
     });
 
     it('should delete elements from the beginning and end', () => {
       arrayDeque.addFirst(1);
       arrayDeque.addLast(2);
-      arrayDeque.pollFirst();
-      arrayDeque.pollLast();
+      arrayDeque.popFirst();
+      arrayDeque.popLast();
       expect(arrayDeque.isEmpty()).toBe(true);
     });
 
     it('should handle edge case when removing from an empty deque', () => {
-      const result = arrayDeque.pollFirst();
+      const result = arrayDeque.popFirst();
       expect(result).toBeNull();
     });
 
@@ -165,16 +165,16 @@ describe('Deque', () => {
     deque.addLast(2);
 
     expect(deque.size).toBe(2);
-    expect(deque.peekFirst()).toBe(1);
-    expect(deque.peekLast()).toBe(2);
+    expect(deque.getFirst()).toBe(1);
+    expect(deque.getLast()).toBe(2);
   });
 
   test('should remove elements from the front and back', () => {
     deque.addFirst(1);
     deque.addLast(2);
 
-    const firstElement = deque.pollFirst();
-    const lastElement = deque.pollLast();
+    const firstElement = deque.popFirst();
+    const lastElement = deque.popLast();
 
     expect(deque.size).toBe(0);
     expect(firstElement).toBe(1);
@@ -203,7 +203,7 @@ describe('Deque', () => {
     deque.addLast(1);
     expect(deque.isEmpty()).toBe(false);
 
-    deque.pollFirst();
+    deque.popFirst();
     expect(deque.isEmpty()).toBe(true);
   });
 });
@@ -225,16 +225,16 @@ describe('ArrayDeque', () => {
     deque.addLast(2);
 
     expect(deque.size).toBe(2);
-    expect(deque.peekFirst()).toBe(1);
-    expect(deque.peekLast()).toBe(2);
+    expect(deque.getFirst()).toBe(1);
+    expect(deque.getLast()).toBe(2);
   });
 
   test('should remove elements from the front and back', () => {
     deque.addFirst(1);
     deque.addLast(2);
 
-    const firstElement = deque.pollFirst();
-    const lastElement = deque.pollLast();
+    const firstElement = deque.popFirst();
+    const lastElement = deque.popLast();
 
     expect(deque.size).toBe(0);
     expect(firstElement).toBe(1);
@@ -263,7 +263,7 @@ describe('ArrayDeque', () => {
     deque.addLast(1);
     expect(deque.isEmpty()).toBe(false);
 
-    deque.pollFirst();
+    deque.popFirst();
     expect(deque.isEmpty()).toBe(true);
   });
 
@@ -319,8 +319,8 @@ describe('ObjectDeque', () => {
     deque.addFirst(2);
 
     expect(deque.size).toBe(2);
-    expect(deque.peekFirst()).toBe(2);
-    expect(deque.peekLast()).toBe(1);
+    expect(deque.getFirst()).toBe(2);
+    expect(deque.getLast()).toBe(1);
   });
 
   test('should add elements to the end of the deque', () => {
@@ -328,37 +328,37 @@ describe('ObjectDeque', () => {
     deque.addLast(2);
 
     expect(deque.size).toBe(2);
-    expect(deque.peekFirst()).toBe(1);
-    expect(deque.peekLast()).toBe(2);
+    expect(deque.getFirst()).toBe(1);
+    expect(deque.getLast()).toBe(2);
   });
 
   test('should remove elements from the front of the deque', () => {
     deque.addLast(1);
     deque.addLast(2);
 
-    const removedElement = deque.pollFirst();
+    const removedElement = deque.popFirst();
 
     expect(deque.size).toBe(1);
     expect(removedElement).toBe(1);
-    expect(deque.peekFirst()).toBe(2);
+    expect(deque.getFirst()).toBe(2);
   });
 
   test('should remove elements from the end of the deque', () => {
     deque.addLast(1);
     deque.addLast(2);
 
-    const removedElement = deque.pollFirst();
+    const removedElement = deque.popFirst();
 
     expect(deque.size).toBe(1);
     expect(removedElement).toBe(1);
-    expect(deque.peekLast()).toBe(2);
+    expect(deque.getLast()).toBe(2);
   });
 
   test('should return the element at the front of the deque without removing it', () => {
     deque.addFirst(1);
     deque.addFirst(2);
 
-    expect(deque.peekFirst()).toBe(2);
+    expect(deque.getFirst()).toBe(2);
     expect(deque.size).toBe(2);
   });
 
@@ -366,7 +366,7 @@ describe('ObjectDeque', () => {
     deque.addLast(1);
     deque.addLast(2);
 
-    expect(deque.peekLast()).toBe(2);
+    expect(deque.getLast()).toBe(2);
     expect(deque.size).toBe(2);
   });
 
@@ -391,9 +391,9 @@ describe('ObjectDeque', () => {
     deque.addLast(2);
     deque.addLast(3);
 
-    expect(deque.peekFirst()).toBe(1);
+    expect(deque.getFirst()).toBe(1);
     expect(deque.get(1)).toBe(2);
-    expect(deque.peekLast()).toBe(3);
+    expect(deque.getLast()).toBe(3);
   });
 
   test('should insert elements at a specific index', () => {
@@ -402,9 +402,9 @@ describe('ObjectDeque', () => {
     deque.addLast(3);
 
     expect(deque.size).toBe(3);
-    expect(deque.peekFirst()).toBe(1);
+    expect(deque.getFirst()).toBe(1);
     expect(deque.get(1)).toBe(2);
     expect(deque.get(2)).toBe(3);
-    expect(deque.peekLast()).toBe(3);
+    expect(deque.getLast()).toBe(3);
   });
 });

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

@@ -86,7 +86,7 @@ describe('Queue', () => {
     queue.push(2);
     expect(queue.size).toBe(2);
     expect(queue.peek()).toBe(1);
-    expect(queue.peekLast()).toBe(2);
+    expect(queue.getLast()).toBe(2);
   });
 
   it('should shift elements from the front of the queue', () => {
@@ -96,7 +96,7 @@ describe('Queue', () => {
     expect(shifted).toBe(1);
     expect(queue.size).toBe(1);
     expect(queue.peek()).toBe(2);
-    expect(queue.peekLast()).toBe(2);
+    expect(queue.getLast()).toBe(2);
   });
 
   it('should handle shifting when queue reaches half size', () => {
@@ -117,7 +117,7 @@ describe('Queue', () => {
     queue.push(1);
     queue.push(2);
     expect(queue.peek()).toBe(1);
-    expect(queue.peekLast()).toBe(2);
+    expect(queue.getLast()).toBe(2);
   });
 
   it('should handle shifting when the queue is empty', () => {
@@ -129,7 +129,7 @@ describe('Queue', () => {
 
   it('should handle peeking when the queue is empty', () => {
     expect(queue.peek()).toBeUndefined();
-    expect(queue.peekLast()).toBeUndefined();
+    expect(queue.getLast()).toBeUndefined();
   });
 
   it('should handle clearing the queue', () => {
@@ -139,7 +139,7 @@ describe('Queue', () => {
     queue.clear();
     expect(queue.size).toBe(0);
     expect(queue.peek()).toBeUndefined();
-    expect(queue.peekLast()).toBeUndefined();
+    expect(queue.getLast()).toBeUndefined();
   });
 
   it('should clone the queue', () => {
@@ -149,7 +149,7 @@ describe('Queue', () => {
     const clonedQueue = queue.clone();
     expect(clonedQueue.size).toBe(3);
     expect(clonedQueue.peek()).toBe(1);
-    expect(clonedQueue.peekLast()).toBe(3);
+    expect(clonedQueue.getLast()).toBe(3);
   });
 
   it('should handle creating a queue from an array', () => {
@@ -157,7 +157,7 @@ describe('Queue', () => {
     const newQueue = Queue.fromArray(elements);
     expect(newQueue.size).toBe(5);
     expect(newQueue.peek()).toBe(1);
-    expect(newQueue.peekLast()).toBe(5);
+    expect(newQueue.getLast()).toBe(5);
   });
 
   it('should iterate through the queue', () => {

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)) {