data-structure-typed 1.52.1 → 1.52.3

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

@@ -11,10 +11,14 @@ describe('SinglyLinkedListNode', () => {
 
 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', () => {

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

@@ -16,7 +16,11 @@ 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 });
 
@@ -52,7 +56,9 @@ describe('MaxPriorityQueue Operation Test', () => {
 
   it('should correctly heapify an array', () => {
     const array = [5, 3, 7, 1];
-    const heap = MaxPriorityQueue.heapify<number>(array, { comparator: (a, b) => b - a });
+    const heap = MaxPriorityQueue.heapify<number>(array, {
+      comparator: (a, b) => b - a
+    });
     heap.refill(array);
 
     expect(heap.poll()).toBe(7);
@@ -64,7 +70,11 @@ describe('MaxPriorityQueue Operation Test', () => {
   it('should correctly heapify an object array', () => {
     const elements = [{ keyA: 5 }, { keyA: 3 }, { keyA: 7 }, { keyA: 1 }];
     debugger;
-    const maxPQ = MaxPriorityQueue.heapify<{ keyA: number }>(elements, { comparator: (a, b) => b.keyA - a.keyA });
+    const maxPQ = MaxPriorityQueue.heapify<{
+      keyA: number;
+    }>(elements, {
+      comparator: (a, b) => b.keyA - a.keyA
+    });
 
     expect(maxPQ.poll()?.keyA).toBe(7);
     expect(maxPQ.poll()?.keyA).toBe(5);
@@ -73,7 +83,9 @@ describe('MaxPriorityQueue Operation Test', () => {
   });
 
   it('should object priority queue', () => {
-    const maxPQ = new MaxPriorityQueue<{ rawItem: { id: number } }>(
+    const maxPQ = new MaxPriorityQueue<{
+      rawItem: { id: number };
+    }>(
       [
         { rawItem: { id: 4 } },
         { rawItem: { id: 8 } },
@@ -83,7 +95,9 @@ describe('MaxPriorityQueue Operation Test', () => {
         { rawItem: { id: 3 } },
         { rawItem: { id: 5 } }
       ],
-      { comparator: (a, b) => b.rawItem.id - a.rawItem.id }
+      {
+        comparator: (a, b) => b.rawItem.id - a.rawItem.id
+      }
     );
 
     expect([...maxPQ.sort()]).toEqual([
@@ -108,7 +122,9 @@ describe('MaxPriorityQueue Operation Test', () => {
         { rawItem: { id: 3 } },
         { rawItem: { id: 5 } }
       ],
-      { toElementFn: rawElement => rawElement.rawItem.id }
+      {
+        toElementFn: rawElement => rawElement.rawItem.id
+      }
     );
 
     expect([...maxPQ.sort()]).toEqual([8, 7, 6, 5, 4, 3, 1]);

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

@@ -5,7 +5,9 @@ import { isDebugTest } from '../../../config';
 const isDebug = isDebugTest;
 describe('PriorityQueue Operation Test', () => {
   it('should PriorityQueue poll, pee, heapify, toArray work well', function () {
-    const minPQ = new PriorityQueue<number>([], { comparator: (a, b) => a - b });
+    const minPQ = new PriorityQueue<number>([], {
+      comparator: (a, b) => a - b
+    });
     minPQ.refill([5, 2, 3, 4, 6, 1]);
     expect(minPQ.toArray()).toEqual([1, 2, 3, 4, 6, 5]);
     minPQ.poll();
@@ -21,7 +23,9 @@ describe('PriorityQueue Operation Test', () => {
   });
 
   it('should Max PriorityQueue poll, peek, heapify, toArray work well', function () {
-    const maxPriorityQueue = new PriorityQueue<number>([], { comparator: (a, b) => b - a });
+    const maxPriorityQueue = new PriorityQueue<number>([], {
+      comparator: (a, b) => b - a
+    });
     maxPriorityQueue.refill([5, 2, 3, 4, 6, 1]);
     expect(maxPriorityQueue.toArray()).toEqual([6, 5, 3, 4, 2, 1]);
     maxPriorityQueue.poll();
@@ -37,7 +41,9 @@ describe('PriorityQueue Operation Test', () => {
   });
 
   it('should PriorityQueue clone, sort, getNodes, dfs work well', function () {
-    const minPQ1 = new PriorityQueue<number>([], { comparator: (a, b) => a - b });
+    const minPQ1 = new PriorityQueue<number>([], {
+      comparator: (a, b) => a - b
+    });
     minPQ1.refill([2, 5, 8, 3, 1, 6, 7, 4]);
     const clonedPriorityQueue = minPQ1.clone();
     expect(clonedPriorityQueue.elements).toEqual(minPQ1.elements);
@@ -50,7 +56,9 @@ describe('PriorityQueue Operation Test', () => {
 
 describe('Priority Queue Performance Test', () => {
   it('should numeric heap work well', function () {
-    const pq = new PriorityQueue<number>([], { comparator: (a, b) => b - a });
+    const pq = new PriorityQueue<number>([], {
+      comparator: (a, b) => b - a
+    });
 
     const tS = performance.now();
 

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

@@ -204,8 +204,7 @@ describe('Deque - Complex Operations', () => {
     expect([...deque]).toEqual([1, 2, 3]);
   });
 
-  test('shrinkToFit should reduce the memory footprint', () => {
-  });
+  test('shrinkToFit should reduce the memory footprint', () => {});
 });
 describe('Deque - Utility Operations', () => {
   let deque: Deque<number>;
@@ -264,7 +263,7 @@ describe('Deque - Utility Operations', () => {
   test('should maxLen work well', () => {
     const dequeMaxLen = new Deque([3, 4, 5, 6, 7], { maxLen: 3 });
     expect(dequeMaxLen.size).toBe(3);
-    expect(dequeMaxLen.toArray()).toEqual([5, 6 ,7]);
+    expect(dequeMaxLen.toArray()).toEqual([5, 6, 7]);
     dequeMaxLen.unshift(4);
     dequeMaxLen.unshift(3);
     expect(dequeMaxLen.size).toBe(3);
@@ -277,7 +276,6 @@ describe('Deque - Utility Operations', () => {
     dequeNoMaxLen.unshift(3);
     expect(dequeNoMaxLen.size).toBe(7);
     expect(dequeNoMaxLen.toArray()).toEqual([3, 4, 3, 4, 5, 6, 7]);
-
   });
 });
 
@@ -344,7 +342,9 @@ describe('Deque - push Method', () => {
   const bucketSize = 10;
 
   beforeEach(() => {
-    deque = new Deque<number>([], { bucketSize });
+    deque = new Deque<number>([], {
+      bucketSize
+    });
   });
 
   test('push should add an element when deque is empty', () => {
@@ -386,7 +386,9 @@ describe('Deque - pop Method', () => {
   const bucketSize = 10;
 
   beforeEach(() => {
-    deque = new Deque<number>([], { bucketSize });
+    deque = new Deque<number>([], {
+      bucketSize
+    });
   });
 
   test('pop should remove and return the last element', () => {
@@ -417,7 +419,9 @@ describe('Deque - unshift Method', () => {
   const bucketSize = 10;
 
   beforeEach(() => {
-    deque = new Deque<number>([], { bucketSize });
+    deque = new Deque<number>([], {
+      bucketSize
+    });
   });
 
   test('unshift should add an element to the beginning when deque is empty', () => {
@@ -449,7 +453,9 @@ describe('Deque - shift Method', () => {
   const bucketSize = 10;
 
   beforeEach(() => {
-    deque = new Deque<number>([], { bucketSize });
+    deque = new Deque<number>([], {
+      bucketSize
+    });
   });
 
   test('shift should remove and return the first element', () => {

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

@@ -90,6 +90,16 @@ describe('Queue', () => {
     expect(queue.isEmpty()).toBeTruthy();
   });
 
+  test('compact method should work well', () => {
+    for (let i = 0; i < 1000; i++) queue.push(i);
+
+    for (let i = 0; i < 499; i++) queue.shift();
+
+    expect(queue.elements.length).toBe(1000);
+    queue.compact();
+    expect(queue.elements.length).toBe(501);
+  });
+
   test('should at after shifting', () => {
     for (let i = 0; i < 100; i++) {
       queue.push(i);
@@ -116,7 +126,10 @@ describe('Queue', () => {
   });
 
   it('should object queue map & filter', function () {
-    const queue = new Queue<{ a: string; key: number }>([
+    const queue = new Queue<{
+      a: string;
+      key: number;
+    }>([
       { key: 1, a: 'a1' },
       { key: 6, a: 'a6' },
       { key: 5, a: 'a5' },

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

@@ -795,7 +795,9 @@ describe('Trie operations', () => {
   });
 
   it('Case Sensitivity', () => {
-    const caseInsensitiveTrie = new Trie(['apple', 'Banana'], { caseSensitive: false });
+    const caseInsensitiveTrie = new Trie(['apple', 'Banana'], {
+      caseSensitive: false
+    });
     expect(caseInsensitiveTrie.has('APPLE')).toBe(true);
     expect(caseInsensitiveTrie.has('banana')).toBe(true);
     expect(caseInsensitiveTrie.has('Cherry')).toBe(false);
@@ -834,6 +836,22 @@ describe('Trie operations', () => {
     expect(words).toEqual(['apple', 'appetizer']);
   });
 
+  it('Get no words when prefix not found, with no match from the first character', () => {
+    trie.add('apple');
+    trie.add('appetizer');
+    trie.add('banana');
+    const words = trie.getWords('cd');
+    expect(words).toEqual([]);
+  });
+
+  it('Get no words when prefix not found, with no match from the second character', () => {
+    trie.add('apple');
+    trie.add('appetizer');
+    trie.add('banana');
+    const words = trie.getWords('ab');
+    expect(words).toEqual([]);
+  });
+
   it('Tree Height', () => {
     trie.add('apple');
     trie.add('banana');

package/test/unit/unrestricted-interconversion.test.ts

@@ -245,7 +245,9 @@ describe('conversions', () => {
     const trie = new Trie(orgStrArr);
     expect(trie.size).toBe(10);
     isDebug && trie.print();
-    const heap = new Heap<string>(trie, { comparator: (a, b) => Number(a) - Number(b) });
+    const heap = new Heap<string>(trie, {
+      comparator: (a, b) => Number(a) - Number(b)
+    });
     expect(heap.size).toBe(10);
     isDebug && heap.print();
     expect([...heap]).toEqual([

package/test/utils/big-o.ts

@@ -32,7 +32,9 @@ 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)) {

package/test/utils/json2html.ts

@@ -14,13 +14,9 @@ function makeLabelDiv(options: any, level: number, keyName: string | number, dat
     return `<div class='index'><span class='json-to-html-label'>${keyName}&nbsp;</span></div>`;
   } else if (typeof keyName === 'string') {
     if (datatype === 'array') {
-      return `<div class='collapsible level${level}' ${toggleJS(
-        options
-      )}><span class='json-to-html-label'>${keyName}</span></div>`;
+      return `<div class='collapsible level${level}' ${toggleJS(options)}><span class='json-to-html-label'>${keyName}</span></div>`;
     } else if (datatype === 'object') {
-      return `<div class='attribute collapsible level${level}' ${toggleJS(
-        options
-      )}><span class='json-to-html-label'>${keyName}:</span></div>`;
+      return `<div class='attribute collapsible level${level}' ${toggleJS(options)}><span class='json-to-html-label'>${keyName}:</span></div>`;
     } else {
       return `<div class='leaf level${level}'><span class='json-to-html-label'>${keyName}:</span></div>`;
     }