data-structure-typed 1.52.4 → 1.52.6

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

@@ -10,68 +10,68 @@ describe('Queue', () => {
     queue = new Queue<number>();
   });
 
-  test('new Queue() should create an empty queue', () => {
+  it('new Queue() should create an empty queue', () => {
     expect(queue.size).toBe(0);
     expect(queue.isEmpty()).toBeTruthy();
   });
 
-  test('push should add elements to the queue', () => {
+  it('push should add elements to the queue', () => {
     queue.push(1);
     queue.push(2);
     expect(queue.size).toBe(2);
   });
 
-  test('shift should remove the first element', () => {
+  it('shift should remove the first element', () => {
     queue.push(1);
     queue.push(2);
     expect(queue.shift()).toBe(1);
     expect(queue.size).toBe(1);
   });
 
-  test('shift should return undefined if queue is empty', () => {
+  it('shift should return undefined if queue is empty', () => {
     expect(queue.shift()).toBeUndefined();
   });
 
-  test('first should return the first element without removing it', () => {
+  it('first should return the first element without removing it', () => {
     queue.push(1);
     queue.push(2);
     expect(queue.first).toBe(1);
     expect(queue.size).toBe(2);
   });
 
-  test('first should return undefined if queue is empty', () => {
+  it('first should return undefined if queue is empty', () => {
     expect(queue.first).toBeUndefined();
   });
 
-  test('size should return the number of elements', () => {
+  it('size should return the number of elements', () => {
     queue.push(1);
     queue.push(2);
     expect(queue.size).toBe(2);
   });
 
-  test('isEmpty should return true if the queue is empty', () => {
+  it('isEmpty should return true if the queue is empty', () => {
     expect(queue.isEmpty()).toBeTruthy();
   });
 
-  test('isEmpty should return false if the queue is not empty', () => {
+  it('isEmpty should return false if the queue is not empty', () => {
     queue.push(1);
     expect(queue.isEmpty()).toBeFalsy();
   });
 
-  test('toArray should return an array of queue elements', () => {
+  it('toArray should return an array of queue elements', () => {
     queue.push(1);
     queue.push(2);
     expect(queue.toArray()).toEqual([1, 2]);
   });
 
-  test('clear should remove all elements from the queue', () => {
+  it('clear should remove all elements from the queue', () => {
     queue.push(1);
     queue.push(2);
     queue.clear();
     expect(queue.size).toBe(0);
   });
 
-  test('forEach should iterate over all elements', () => {
+  it('forEach should iterate over all elements', () => {
     const arr: number[] = [];
     queue.push(1);
     queue.push(2);
@@ -80,7 +80,7 @@ describe('Queue', () => {
   });
 
   // Boundary value testing
-  test('push and shift with many elements', () => {
+  it('push and shift with many elements', () => {
     for (let i = 0; i < 1000; i++) {
       queue.push(i);
     }
@@ -90,7 +90,7 @@ describe('Queue', () => {
     expect(queue.isEmpty()).toBeTruthy();
   });
 
-  test('compact method should work well', () => {
+  it('compact method should work well', () => {
     for (let i = 0; i < 1000; i++) queue.push(i);
 
     for (let i = 0; i < 499; i++) queue.shift();
@@ -100,7 +100,7 @@ describe('Queue', () => {
     expect(queue.elements.length).toBe(501);
   });
 
-  test('should at after shifting', () => {
+  it('should at after shifting', () => {
     for (let i = 0; i < 100; i++) {
       queue.push(i);
     }
@@ -114,7 +114,7 @@ describe('Queue', () => {
     }
   });
 
-  test('should toElementFn', () => {
+  it('should toElementFn', () => {
     const queue = new Queue<string, { id: string }>([{ id: '1' }, { id: '5' }, { id: '3' }, { id: '4' }, { id: '2' }], {
       toElementFn: rawElement => rawElement.id
     });
@@ -177,6 +177,29 @@ describe('Queue', () => {
     expect([...queue]).toEqual(['1', '6', '9']);
     expect([...cloned]).toEqual(['1', '6', '0', '5', '9']);
   });
+
+  it('should set autoCompactRatio', function () {
+    const queue = new Queue<number>();
+
+    queue.autoCompactRatio = 0.3;
+    queue.push(1);
+    queue.push(2);
+    queue.push(3);
+    queue.push(4);
+    queue.push(5);
+    queue.push(6);
+    queue.push(7);
+    queue.push(8);
+    queue.push(9);
+    queue.push(10);
+    expect(queue.elements.length).toBe(10);
+    while (queue.size > 7) queue.shift();
+    expect(queue.size).toBe(7);
+    expect(queue.elements.length).toBe(10);
+    queue.shift();
+    expect(queue.size).toBe(6);
+    expect(queue.elements.length).toBe(6);
+  });
 });
 
 describe('Queue - Advanced Methods', () => {
@@ -186,7 +209,7 @@ describe('Queue - Advanced Methods', () => {
     queue = new Queue<number>();
   });
 
-  test('reduce should apply a function against an accumulator and each element', () => {
+  it('reduce should apply a function against an accumulator and each element', () => {
     queue.push(1);
     queue.push(2);
     queue.push(3);
@@ -194,13 +217,13 @@ describe('Queue - Advanced Methods', () => {
     expect(sum).toBe(6);
   });
 
-  test('reduce should return initial value for empty queue', () => {
+  it('reduce should return initial value for empty queue', () => {
     const initialValue = 0;
     const sum = queue.reduce((acc, val) => acc + val, initialValue);
     expect(sum).toBe(initialValue);
   });
 
-  test('filter should return a new queue with all elements that pass the test implemented by provided function', () => {
+  it('filter should return a new queue with all elements that pass the test implemented by provided function', () => {
     queue.push(1);
     queue.push(2);
     queue.push(3);
@@ -208,12 +231,12 @@ describe('Queue - Advanced Methods', () => {
     expect(filteredQueue.toArray()).toEqual([2, 3]);
   });
 
-  test('filter should return an empty queue for empty queue', () => {
+  it('filter should return an empty queue for empty queue', () => {
     const filteredQueue = queue.filter(val => val > 1);
     expect(filteredQueue.isEmpty()).toBeTruthy();
   });
 
-  test('map should create a new queue with the results of calling a provided function on every element', () => {
+  it('map should create a new queue with the results of calling a provided function on every element', () => {
     queue.push(1);
     queue.push(2);
     queue.push(3);
@@ -221,7 +244,7 @@ describe('Queue - Advanced Methods', () => {
     expect(mappedQueue.toArray()).toEqual([2, 4, 6]);
   });
 
-  test('map should return an empty queue for empty queue', () => {
+  it('map should return an empty queue for empty queue', () => {
     const mappedQueue = queue.map(val => val * 2);
     expect(mappedQueue.isEmpty()).toBeTruthy();
   });
@@ -233,31 +256,31 @@ describe('Queue - Additional Methods', () => {
     queue = new Queue<number>();
   });
 
-  test('peekLast should return the last element without removing it', () => {
+  it('peekLast should return the last element without removing it', () => {
     queue.push(1);
     queue.push(2);
     expect(queue.last).toBe(2);
     expect(queue.size).toBe(2);
   });
 
-  test('peekLast should return undefined if queue is empty', () => {
+  it('peekLast should return undefined if queue is empty', () => {
     expect(queue.last).toBeUndefined();
   });
 
-  test('at should return the element at the specified index', () => {
+  it('at should return the element at the specified index', () => {
     queue.push(1);
     queue.push(2);
     queue.push(3);
     expect(queue.at(1)).toBe(2);
   });
 
-  test('at should return undefined for an invalid index', () => {
+  it('at should return undefined for an invalid index', () => {
     queue.push(1);
     expect(queue.at(3)).toBeUndefined();
     expect(queue.at(-1)).toBeUndefined();
   });
 
-  test('print should not throw any errors', () => {
+  it('print should not throw any errors', () => {
     expect(() => {
       queue.push(1);
       // queue.print();
@@ -266,19 +289,19 @@ describe('Queue - Additional Methods', () => {
 });
 
 describe('Queue - Static and Clone Methods', () => {
-  test('fromArray should create a new queue from an array', () => {
+  it('fromArray should create a new queue from an array', () => {
     const array = [1, 2, 3];
     const queue = Queue.fromArray(array);
     expect(queue.toArray()).toEqual(array);
     expect(queue.size).toBe(array.length);
   });
 
-  test('fromArray should create an empty queue from an empty array', () => {
+  it('fromArray should create an empty queue from an empty array', () => {
     const queue = Queue.fromArray([]);
     expect(queue.isEmpty()).toBeTruthy();
   });
 
-  test('clone should create a new queue with the same elements', () => {
+  it('clone should create a new queue with the same elements', () => {
     const originalQueue = new Queue<number>();
     originalQueue.push(1);
     originalQueue.push(2);
@@ -288,7 +311,7 @@ describe('Queue - Static and Clone Methods', () => {
     expect(clonedQueue.size).toBe(originalQueue.size);
   });
 
-  test('clone should not affect the original queue when mutated', () => {
+  it('clone should not affect the original queue when mutated', () => {
     const originalQueue = new Queue<number>();
     originalQueue.push(1);
     originalQueue.push(2);
@@ -306,18 +329,16 @@ describe('LinkedListQueue', () => {
 
   beforeEach(() => {
     queue = new LinkedListQueue<string>();
+    queue.push('A');
+    queue.push('B');
   });
 
   it('should push elements to the end of the queue', () => {
-    queue.push('A');
-    queue.push('B');
     expect(queue.first).toBe('A');
     expect(queue.size).toBe(2);
   });
 
   it('should shift elements from the front of the queue', () => {
-    queue.push('A');
-    queue.push('B');
     const dequeued = queue.shift();
     expect(dequeued).toBe('A');
     expect(queue.first).toBe('B');
@@ -325,8 +346,12 @@ describe('LinkedListQueue', () => {
   });
 
   it('should peek at the front of the queue', () => {
-    queue.push('A');
-    queue.push('B');
     expect(queue.first).toBe('A');
   });
+
+  it('should clone method work correctly', () => {
+    const cloned = queue.clone();
+    expect(cloned instanceof LinkedListQueue).toBe(true);
+    expect(cloned.size).toBe(2);
+  });
 });

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

@@ -19,6 +19,7 @@ describe('Stack', () => {
   });
 
   it('should peek at the top element without removing it', () => {
+    expect(stack.peek()).toBe(undefined);
     stack.push(1);
     stack.push(2);
     stack.push(3);
@@ -93,7 +94,7 @@ describe('Stack iterative methods', () => {
     stack.push(3);
   });
 
-  test('should iterate through the stack', () => {
+  it('should iterate through the stack', () => {
     const result: number[] = [];
     for (const element of stack) {
       result.push(element);
@@ -102,7 +103,7 @@ describe('Stack iterative methods', () => {
     expect(result).toEqual([1, 2, 3]); // iteration should start from the top of the stack
   });
 
-  test('should apply forEach to the stack', () => {
+  it('should apply forEach to the stack', () => {
     const result: number[] = [];
     stack.forEach(element => {
       result.push(element);
@@ -111,23 +112,47 @@ describe('Stack iterative methods', () => {
     expect(result).toEqual([1, 2, 3]);
   });
 
-  test('should filter elements in the stack', () => {
+  it('should filter elements in the stack', () => {
     const filteredStack = stack.filter(element => element > 1);
 
     expect(filteredStack.size).toBe(2);
     expect([...filteredStack]).toEqual([2, 3]);
   });
 
-  test('should map elements in the stack', () => {
+  it('should map elements in the stack', () => {
     const mappedStack = stack.map(element => element * 2);
 
     expect(mappedStack.size).toBe(3);
     expect([...mappedStack]).toEqual([2, 4, 6]);
   });
 
-  test('should reduce elements in the stack', () => {
+  it('should reduce elements in the stack', () => {
     const sum = stack.reduce((accumulator, element) => accumulator + element, 0);
 
     expect(sum).toBe(6);
   });
+
+  it('should toElementFn', () => {
+    const stack = new Stack([{ key: 1 }, { key: 2 }, { key: 5 }, { key: 3 }], { toElementFn: item => item.key });
+    expect(stack.size).toBe(4);
+    expect([...stack]).toEqual([1, 2, 5, 3]);
+  });
+
+  it('should fromArray', () => {
+    const stack = Stack.fromArray([1, 2, 5, 3]);
+    expect(stack instanceof Stack).toBe(true);
+    expect(stack.size).toBe(4);
+    expect([...stack]).toEqual([1, 2, 5, 3]);
+  });
+
+  it('should iterable-element-base toElementFn', () => {
+    const stack = new Stack<{ key: number }>([1, 2, 5, 3], { toElementFn: key => ({ key }) });
+    expect([...stack]).toEqual([{ key: 1 }, { key: 2 }, { key: 5 }, { key: 3 }]);
+    expect(() => {
+      new Stack<{ key: number }>([1, 2, 5, 3], {
+        // @ts-ignore
+        toElementFn: {}
+      });
+    }).toThrow('toElementFn must be a function type');
+  });
 });

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

@@ -0,0 +1,58 @@
+import { TreeNode } from '../../../../src';
+
+describe('TreeNode', () => {
+  it('should create a tree node with key and value', () => {
+    const node = new TreeNode<string>('root', 'RootValue');
+    expect(node.key).toBe('root');
+    expect(node.value).toBe('RootValue');
+    expect(node.children).toEqual(undefined);
+  });
+
+  it('should allow setting and getting key and value', () => {
+    const node = new TreeNode<string>('node1', 'Value1');
+    node.key = 'newKey';
+    node.value = 'newValue';
+    expect(node.key).toBe('newKey');
+    expect(node.value).toBe('newValue');
+  });
+
+  it('should add a single child node', () => {
+    const parent = new TreeNode<string>('parent');
+    const child = new TreeNode<string>('child', 'ChildValue');
+
+    parent.addChildren(child);
+
+    expect(parent.children).toHaveLength(1);
+    expect(parent.children?.[0].key).toBe('child');
+    expect(parent.children?.[0].value).toBe('ChildValue');
+  });
+
+  it('should add multiple children nodes', () => {
+    const parent = new TreeNode<string>('parent');
+    const child1 = new TreeNode<string>('child1');
+    const child2 = new TreeNode<string>('child2');
+
+    parent.addChildren([child1, child2]);
+
+    expect(parent.children).toHaveLength(2);
+    expect(parent.children?.[0].key).toBe('child1');
+    expect(parent.children?.[1].key).toBe('child2');
+    parent.children = [];
+
+    expect(parent.children[0]).toBe(undefined);
+    expect(parent.children[1]).toBe(undefined);
+  });
+
+  it('should calculate the correct height of the tree', () => {
+    const root = new TreeNode<string>('root');
+    const child1 = new TreeNode<string>('child1');
+    const child2 = new TreeNode<string>('child2');
+    const grandChild = new TreeNode<string>('grandChild');
+
+    root.addChildren(child1);
+    root.addChildren(child2);
+    child1.addChildren(grandChild);
+
+    expect(root.getHeight()).toBe(2); // root -> child1 -> grandChild (height = 2)
+  });
+});

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

@@ -22,6 +22,31 @@ describe('TrieNode', () => {
     node.isEnd = true;
     expect(node.isEnd).toBe(true);
   });
+
+  it('should set key property correctly', () => {
+    const node = new TrieNode('a');
+    node.isEnd = false;
+    expect(node).toEqual({
+      _children: new Map(),
+      _isEnd: false,
+      _key: 'a'
+    });
+    node.key = 'b';
+    expect(node.key).toBe('b');
+    expect(node).toEqual({
+      _children: new Map(),
+      _isEnd: false,
+      _key: 'b'
+    });
+  });
+
+  it('should set children property correctly', () => {
+    const node = new TrieNode('a');
+    node.isEnd = false;
+    const children = new Map<string, TrieNode>([['p', new TrieNode('p')]]);
+    node.children = children;
+    expect(node.children).toEqual(children);
+  });
 });
 
 describe('Trie', () => {
@@ -865,29 +890,45 @@ describe('Trie class', () => {
     trie = new Trie(['apple', 'app', 'banana', 'band', 'bandana']);
   });
 
-  test('[Symbol.iterator] should iterate over all words', () => {
+  it('[Symbol.iterator] should iterate over all words', () => {
     const words = [...trie];
     expect(words).toEqual(['app', 'apple', 'banana', 'band', 'bandana']);
   });
 
-  test('forEach should execute a callback for each word', () => {
+  it('forEach should execute a callback for each word', () => {
     const mockCallback = jest.fn();
     trie.forEach(mockCallback);
     expect(mockCallback).toHaveBeenCalledTimes(5);
   });
 
-  test('filter should return words that satisfy the predicate', () => {
+  it('filter should return words that satisfy the predicate', () => {
     const filteredWords = trie.filter(word => word.startsWith('ba'));
     expect([...filteredWords]).toEqual(['banana', 'band', 'bandana']);
   });
 
-  test('map should apply a function to each word', () => {
+  it('map should apply a function to each word', () => {
     const mappedWords = trie.map(word => word.length.toString());
     expect([...mappedWords]).toEqual(['3', '5', '6', '4', '7']);
   });
 
-  test('reduce should reduce the words to a single value', () => {
+  it('reduce should reduce the words to a single value', () => {
     const concatenatedWords = trie.reduce((acc, word) => acc + word, '');
     expect(concatenatedWords).toEqual('appapplebananabandbandana');
   });
+
+  it('reduce should new Trie with toElementFn be correct', () => {
+    const trieB = new Trie([{ name: 'apple' }, { name: 'app' }, { name: 'arm' }], { toElementFn: item => item.name });
+    expect(trieB.isEmpty()).toBe(false);
+    expect(trieB.size).toBe(3);
+    expect(trieB.has('apple')).toBe(true);
+    expect(trieB.has('app')).toBe(true);
+    expect(trieB.has('arm')).toBe(true);
+    expect(trieB.hasPrefix('ap')).toBe(true);
+    trieB.clear();
+    expect(trieB.size).toBe(0);
+    expect(trieB.has('apple')).toBe(false);
+    expect(trieB.has('app')).toBe(false);
+    expect(trieB.has('arm')).toBe(false);
+    expect(trieB.hasPrefix('ap')).toBe(false);
+  });
 });

package/test/unit/utils/utils.test.ts

@@ -3,3 +3,172 @@ describe('isNaN', () => {
     expect(isNaN('string' as unknown as number)).toBe(true);
   });
 });
+
+import { isComparable } from '../../../src';
+
+describe('isComparable', () => {
+  describe('primitive types', () => {
+    it('numbers should be comparable', () => {
+      expect(isComparable(42)).toBe(true);
+      expect(isComparable(0)).toBe(true);
+      expect(isComparable(-1)).toBe(true);
+      expect(isComparable(Infinity)).toBe(true);
+      expect(isComparable(-Infinity)).toBe(true);
+    });
+
+    it('NaN should not be comparable', () => {
+      expect(isComparable(NaN)).toBe(false);
+    });
+
+    it('strings should be comparable', () => {
+      expect(isComparable('hello')).toBe(true);
+      expect(isComparable('')).toBe(true);
+      expect(isComparable('123')).toBe(true);
+    });
+
+    it('BigInt should be comparable', () => {
+      expect(isComparable(BigInt(42))).toBe(true);
+      expect(isComparable(BigInt(0))).toBe(true);
+      expect(isComparable(BigInt(-1))).toBe(true);
+    });
+
+    it('boolean should not be comparable', () => {
+      expect(isComparable(true)).toBe(true);
+      expect(isComparable(false)).toBe(true);
+    });
+
+    it('null and undefined should not be comparable', () => {
+      expect(isComparable(null)).toBe(false);
+      expect(isComparable(undefined)).toBe(false);
+    });
+
+    it('symbols should not be comparable', () => {
+      expect(isComparable(Symbol('test'))).toBe(false);
+      expect(isComparable(Symbol.for('test'))).toBe(false);
+    });
+  });
+
+  describe('Date objects', () => {
+    it('valid Date objects should be comparable', () => {
+      expect(isComparable(new Date())).toBe(true);
+      expect(isComparable(new Date('2024-01-01'))).toBe(true);
+    });
+
+    it('invalid Date objects should not be comparable', () => {
+      expect(isComparable(new Date('invalid'))).toBe(false);
+    });
+  });
+
+  describe('arrays', () => {
+    it('arrays should be comparable as they convert to string', () => {
+      expect(isComparable([])).toBe(true);
+      expect(isComparable([1, 2, 3])).toBe(true);
+      expect(isComparable(['a', 'b', 'c'])).toBe(true);
+    });
+  });
+
+  describe('plain objects', () => {
+    it('plain objects should not be comparable', () => {
+      expect(isComparable({})).toBe(false);
+      expect(isComparable({ a: 1 })).toBe(false);
+    });
+  });
+
+  describe('custom objects', () => {
+    it('objects with numeric valueOf should be comparable', () => {
+      expect(isComparable({ valueOf: () => 42 })).toBe(true);
+    });
+
+    it('objects with string valueOf should be comparable', () => {
+      expect(isComparable({ valueOf: () => 'test' })).toBe(true);
+    });
+
+    it('objects with boolean valueOf should not be comparable', () => {
+      expect(isComparable({ valueOf: () => true })).toBe(true);
+    });
+
+    it('objects with nested valueOf/toString should be comparable', () => {
+      expect(
+        isComparable({
+          valueOf: () => ({ toString: () => '42' })
+        })
+      ).toBe(true);
+    });
+  });
+
+  describe('deeply nested objects', () => {
+    it('objects with deeply nested valueOf should be comparable', () => {
+      const deeplyNested = {
+        valueOf: () => ({
+          valueOf: () => 42
+        })
+      };
+      expect(isComparable(deeplyNested)).toBe(true);
+    });
+
+    it('objects with very deeply nested conversion should be comparable', () => {
+      const veryDeeplyNested = {
+        valueOf: () => ({
+          valueOf: () => ({
+            toString: () => '42'
+          })
+        })
+      };
+      expect(isComparable(veryDeeplyNested)).toBe(true);
+    });
+
+    it('objects with circular references should not be comparable', () => {
+      const circular: any = {
+        valueOf: () => circular
+      };
+      expect(isComparable(circular)).toBe(false);
+    });
+  });
+
+  describe('edge cases', () => {
+    it('objects returning non-primitive values should be handled correctly', () => {
+      const complexObject = {
+        valueOf: () => ({
+          toString: () => ({
+            valueOf: () => 'valid'
+          })
+        })
+      };
+      expect(isComparable(complexObject)).toBe(false);
+    });
+
+    it('objects returning primitive values should be handled correctly', () => {
+      const complexObject = {
+        valueOf: () => ({
+          valueOf: () => ({
+            valueOf: () => ({
+              valueOf: () => ({
+                toString: () => `{
+                                   valueOf: () => 'valid'
+                                 }`
+              })
+            })
+          })
+        })
+      };
+      expect(isComparable(complexObject)).toBe(true);
+    });
+  });
+
+  describe('type checking', () => {
+    // it('should narrow types correctly', () => {
+    //   const value: unknown = 42;
+    //   if (isComparable(value)) {
+    //     // Type narrowing here should succeed
+    //     const result = value > 0;
+    //     expect(result).toBe(true);
+    //   }
+    // });
+
+    it('should work with type guard in array methods', () => {
+      const values: unknown[] = [42, 'test', true, null, undefined, new Date()];
+      const comparableValues = values.filter(item => isComparable(item));
+      expect(comparableValues.length).toBe(4);
+    });
+  });
+});