data-structure-typed 1.33.0 → 1.33.5

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

@@ -0,0 +1,130 @@
+import {Deque, ArrayDeque, ObjectDeque} from '../../../../src';
+
+describe('Deque Tests', () => {
+  // Test cases for the Deque class (DoublyLinkedList-based)
+  describe('Deque (DoublyLinkedList-based)', () => {
+    let deque: Deque<number>;
+
+    beforeEach(() => {
+      deque = new Deque<number>();
+    });
+
+    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);
+    });
+
+    it('should remove elements from the beginning and end', () => {
+      deque.addFirst(1);
+      deque.addLast(2);
+      deque.pollFirst();
+      deque.pollLast();
+      expect(deque.isEmpty()).toBe(true);
+    });
+
+    it('should handle edge case when removing from an empty deque', () => {
+      const result = deque.pollFirst();
+      expect(result).toBeUndefined();
+    });
+
+    it('should correctly report its size', () => {
+      deque.addFirst(1);
+      deque.addLast(2);
+      expect(deque.size).toBe(2);
+    });
+
+    it('should handle adding and removing elements alternately', () => {
+      deque.addFirst(1);
+      expect(deque.pollFirst()).toBe(1);
+      deque.addLast(2);
+      expect(deque.pollLast()).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);
+      deque.addFirst(3);
+      expect(deque.pollLast()).toBe(2);
+      expect(deque.size).toBe(1);
+    });
+    // Add more test cases as needed
+  });
+
+  // Test cases for the ObjectDeque class
+  describe('ObjectDeque', () => {
+    let objectDeque: ObjectDeque<string>;
+
+    beforeEach(() => {
+      objectDeque = new ObjectDeque<string>();
+    });
+
+    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');
+    });
+
+    it('should remove elements from the beginning and end', () => {
+      objectDeque.addFirst('one');
+      objectDeque.addLast('two');
+      objectDeque.pollFirst();
+      objectDeque.pollLast();
+      expect(objectDeque.isEmpty()).toBe(true);
+    });
+
+    it('should handle edge case when removing from an empty deque', () => {
+      const result = objectDeque.pollFirst();
+      expect(result).toBeUndefined();
+    });
+
+    it('should correctly report its size', () => {
+      objectDeque.addFirst('one');
+      objectDeque.addLast('two');
+      expect(objectDeque.size).toBe(2);
+    });
+
+    // Add more test cases as needed
+  });
+
+  // Test cases for the ArrayDeque class
+  describe('ArrayDeque', () => {
+    let arrayDeque: ArrayDeque<number>;
+
+    beforeEach(() => {
+      arrayDeque = new ArrayDeque<number>();
+    });
+
+    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);
+    });
+
+    it('should remove elements from the beginning and end', () => {
+      arrayDeque.addFirst(1);
+      arrayDeque.addLast(2);
+      arrayDeque.pollFirst();
+      arrayDeque.pollLast();
+      expect(arrayDeque.isEmpty()).toBe(true);
+    });
+
+    it('should handle edge case when removing from an empty deque', () => {
+      const result = arrayDeque.pollFirst();
+      expect(result).toBeNull();
+    });
+
+    it('should correctly report its size', () => {
+      arrayDeque.addFirst(1);
+      arrayDeque.addLast(2);
+      expect(arrayDeque.size).toBe(2);
+    });
+
+    // Add more test cases as needed
+  });
+});

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

@@ -1,8 +1,7 @@
-import {Queue} from '../../../../src';
+import {Queue, LinkedListQueue} from '../../../../src';
 import {bigO, magnitude} from '../../../utils';
 
 describe('Queue Operation Test', () => {
-
   it('should validate a queue', () => {
     const queue = new Queue<number>();
     for (let i = 0; i < 1000; i++) {
@@ -14,7 +13,6 @@ describe('Queue Operation Test', () => {
     }
     expect(last).toBe(999);
   });
-
 });
 
 describe('Queue Performance Test', () => {
@@ -31,6 +29,171 @@ describe('Queue Performance Test', () => {
     }
     expect(last).toBe(magnitude.LINEAR - 1);
     expect(performance.now() - startTime).toBeLessThan(bigO.LINEAR * 100);
+  });
+});
+
+describe('Queue', () => {
+  let queue: Queue<number>;
+
+  beforeEach(() => {
+    queue = new Queue<number>();
+  });
+
+  it('should initialize an empty queue', () => {
+    expect(queue.size).toBe(0);
+  });
+
+  it('should push elements to the end of the queue', () => {
+    queue.push(1);
+    queue.push(2);
+    expect(queue.peek()).toBe(1);
+    expect(queue.size).toBe(2);
+  });
+
+  // it('should shift elements from the front of the queue', () => {
+  //   queue.push(1);
+  //   queue.push(2);
+  //   const shifted = queue.shift();
+  //   expect(shifted).toBe(1);
+  //   expect(queue.peek()).toBe(2);
+  //   expect(queue.size).toBe(1);
+  // });
+  //
+  // it('should peek at the front of the queue', () => {
+  //   queue.push(1);
+  //   queue.push(2);
+  //   expect(queue.peek()).toBe(1);
+  // });
+
+  // Add more test cases for other methods of Queue.
+});
+describe('Queue', () => {
+  let queue: Queue<number>;
+
+  beforeEach(() => {
+    queue = new Queue<number>();
+  });
+
+  it('should initialize an empty queue', () => {
+    expect(queue.size).toBe(0);
+    expect(queue.isEmpty()).toBe(true);
+  });
+
+  it('should push elements to the end of the queue', () => {
+    queue.push(1);
+    queue.push(2);
+    expect(queue.size).toBe(2);
+    expect(queue.peek()).toBe(1);
+    expect(queue.peekLast()).toBe(2);
+  });
+
+  it('should shift elements from the front of the queue', () => {
+    queue.push(1);
+    queue.push(2);
+    const shifted = queue.shift();
+    expect(shifted).toBe(1);
+    expect(queue.size).toBe(1);
+    expect(queue.peek()).toBe(2);
+    expect(queue.peekLast()).toBe(2);
+  });
+
+  it('should handle shifting when queue reaches half size', () => {
+    for (let i = 1; i <= 5; i++) {
+      queue.push(i);
+    }
+    for (let i = 1; i <= 3; i++) {
+      queue.shift();
+    }
+    // Queue size should be 2, but internal array size is still 5.
+    // Test that shifting optimizes the internal array.
+    expect(queue.size).toBe(2);
+    expect(queue.nodes.length).toBe(2);
+    expect(queue.peek()).toBe(4);
+  });
 
+  it('should peek at the front and end of the queue', () => {
+    queue.push(1);
+    queue.push(2);
+    expect(queue.peek()).toBe(1);
+    expect(queue.peekLast()).toBe(2);
   });
-})
+
+  it('should handle shifting when the queue is empty', () => {
+    const shifted = queue.shift();
+    expect(shifted).toBeUndefined();
+    expect(queue.size).toBe(0);
+    expect(queue.peek()).toBeUndefined();
+  });
+
+  it('should handle peeking when the queue is empty', () => {
+    expect(queue.peek()).toBeUndefined();
+    expect(queue.peekLast()).toBeUndefined();
+  });
+
+  it('should handle clearing the queue', () => {
+    for (let i = 1; i <= 3; i++) {
+      queue.push(i);
+    }
+    queue.clear();
+    expect(queue.size).toBe(0);
+    expect(queue.peek()).toBeUndefined();
+    expect(queue.peekLast()).toBeUndefined();
+  });
+
+  it('should clone the queue', () => {
+    for (let i = 1; i <= 3; i++) {
+      queue.push(i);
+    }
+    const clonedQueue = queue.clone();
+    expect(clonedQueue.size).toBe(3);
+    expect(clonedQueue.peek()).toBe(1);
+    expect(clonedQueue.peekLast()).toBe(3);
+  });
+
+  it('should handle creating a queue from an array', () => {
+    const elements = [1, 2, 3, 4, 5];
+    const newQueue = Queue.fromArray(elements);
+    expect(newQueue.size).toBe(5);
+    expect(newQueue.peek()).toBe(1);
+    expect(newQueue.peekLast()).toBe(5);
+  });
+
+  it('should iterate through the queue', () => {
+    for (let i = 1; i <= 3; i++) {
+      queue.push(i);
+    }
+    const values = Array.from(queue);
+    expect(values).toEqual([1, 2, 3]);
+  });
+});
+describe('LinkedListQueue', () => {
+  let queue: LinkedListQueue<string>;
+
+  beforeEach(() => {
+    queue = new LinkedListQueue<string>();
+  });
+
+  it('should enqueue elements to the end of the queue', () => {
+    queue.enqueue('A');
+    queue.enqueue('B');
+    expect(queue.peek()).toBe('A');
+    expect(queue.length).toBe(2);
+  });
+
+  it('should dequeue elements from the front of the queue', () => {
+    queue.enqueue('A');
+    queue.enqueue('B');
+    const dequeued = queue.dequeue();
+    expect(dequeued).toBe('A');
+    expect(queue.peek()).toBe('B');
+    expect(queue.length).toBe(1);
+  });
+
+  it('should peek at the front of the queue', () => {
+    queue.enqueue('A');
+    queue.enqueue('B');
+    expect(queue.peek()).toBe('A');
+  });
+
+  // Add more test cases for other methods of LinkedListQueue.
+});

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

@@ -0,0 +1,67 @@
+import {Stack} from '../../../../src';
+
+describe('Stack', () => {
+  let stack: Stack<number>;
+
+  beforeEach(() => {
+    stack = new Stack<number>();
+  });
+
+  it('should be empty when initialized', () => {
+    expect(stack.isEmpty()).toBe(true);
+  });
+
+  it('should push elements onto the stack', () => {
+    stack.push(1);
+    stack.push(2);
+    stack.push(3);
+    expect(stack.size()).toBe(3);
+  });
+
+  it('should peek at the top element without removing it', () => {
+    stack.push(1);
+    stack.push(2);
+    stack.push(3);
+    expect(stack.peek()).toBe(3);
+    expect(stack.size()).toBe(3);
+  });
+
+  it('should pop elements from the stack', () => {
+    stack.push(1);
+    stack.push(2);
+    stack.push(3);
+    const poppedElement = stack.pop();
+    expect(poppedElement).toBe(3);
+    expect(stack.size()).toBe(2);
+  });
+
+  it('should return null when popping from an empty stack', () => {
+    const poppedElement = stack.pop();
+    expect(poppedElement).toBeNull();
+  });
+
+  it('should convert the stack to an array', () => {
+    stack.push(1);
+    stack.push(2);
+    stack.push(3);
+    const stackArray = stack.toArray();
+    expect(stackArray).toEqual([1, 2, 3]);
+  });
+
+  it('should clear all elements from the stack', () => {
+    stack.push(1);
+    stack.push(2);
+    stack.push(3);
+    stack.clear();
+    expect(stack.size()).toBe(0);
+    expect(stack.isEmpty()).toBe(true);
+  });
+
+  it('should clone the stack', () => {
+    stack.push(1);
+    stack.push(2);
+    const clonedStack = stack.clone();
+    expect(clonedStack.size()).toBe(2);
+    expect(clonedStack.pop()).toBe(2);
+  });
+});

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

@@ -0,0 +1,39 @@
+import {TreeNode} from '../../../../src';
+
+describe('TreeNode', () => {
+  it('should create a TreeNode with the given id and value', () => {
+    const node = new TreeNode<string>('1', 'Node 1');
+    expect(node.id).toBe('1');
+    expect(node.value).toBe('Node 1');
+    expect(node.children).toEqual([]);
+  });
+
+  it('should add children to the TreeNode', () => {
+    const parentNode = new TreeNode<string>('1', 'Parent Node');
+    const child1 = new TreeNode<string>('2', 'Child 1');
+    const child2 = new TreeNode<string>('3', 'Child 2');
+
+    parentNode.addChildren([child1, child2]);
+
+    expect(parentNode.children).toEqual([child1, child2]);
+  });
+
+  it('should calculate the height of the tree correctly', () => {
+    const rootNode = new TreeNode<string>('1', 'Root Node');
+    const child1 = new TreeNode<string>('2', 'Child 1');
+    const child2 = new TreeNode<string>('3', 'Child 2');
+    const grandchild1 = new TreeNode<string>('4', 'Grandchild 1');
+    const grandchild2 = new TreeNode<string>('5', 'Grandchild 2');
+
+    rootNode.addChildren([child1, child2]);
+    child1.addChildren([grandchild1]);
+    child2.addChildren([grandchild2]);
+
+    expect(rootNode.getHeight()).toBe(3); // Height of the tree should be 3
+  });
+
+  it('should handle nodes without children when calculating height', () => {
+    const rootNode = new TreeNode<string>('1', 'Root Node');
+    expect(rootNode.getHeight()).toBe(1); // Height of a single node should be 1
+  });
+});

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

@@ -0,0 +1,95 @@
+import {Trie, TrieNode} from '../../../../src';
+
+describe('TrieNode', () => {
+  it('should create a TrieNode with the given value', () => {
+    const node = new TrieNode('a');
+    expect(node.val).toBe('a');
+    expect(node.isEnd).toBe(false);
+    expect(node.children.size).toBe(0);
+  });
+
+  it('should add a child to TrieNode', () => {
+    const parentNode = new TrieNode('a');
+    const childNode = new TrieNode('b');
+    parentNode.children.set('b', childNode);
+
+    expect(parentNode.children.size).toBe(1);
+    expect(parentNode.children.get('b')).toBe(childNode);
+  });
+
+  it('should set isEnd property correctly', () => {
+    const node = new TrieNode('a');
+    node.isEnd = true;
+    expect(node.isEnd).toBe(true);
+  });
+});
+
+describe('Trie', () => {
+  it('should create an empty Trie', () => {
+    const trie = new Trie();
+    expect(trie.root.val).toBe('');
+    expect(trie.root.children.size).toBe(0);
+  });
+
+  it('should add words to Trie', () => {
+    const trie = new Trie();
+    trie.add('apple');
+    trie.add('app');
+    expect(trie.has('apple')).toBe(true);
+    expect(trie.has('app')).toBe(true);
+    expect(trie.has('banana')).toBe(false);
+  });
+
+  it('should check if a string is an absolute prefix', () => {
+    const trie = new Trie();
+    trie.add('apple');
+    trie.add('app');
+    expect(trie.isAbsPrefix('appl')).toBe(true);
+    expect(trie.isAbsPrefix('apples')).toBe(false);
+  });
+
+  it('should check if a string is a prefix', () => {
+    const trie = new Trie();
+    trie.add('apple');
+    trie.add('app');
+    expect(trie.isPrefix('app')).toBe(true);
+    expect(trie.isPrefix('banana')).toBe(false);
+  });
+
+  it('should check if a string is a common prefix', () => {
+    const trie = new Trie();
+    trie.add('apple');
+    trie.add('app');
+    expect(trie.isCommonPrefix('ap')).toBe(true);
+    expect(trie.isCommonPrefix('app')).toBe(true);
+    expect(trie.isCommonPrefix('b')).toBe(false);
+  });
+
+  it('should get the longest common prefix', () => {
+    const trie = new Trie();
+    trie.add('apple');
+    trie.add('app');
+    expect(trie.getLongestCommonPrefix()).toBe('app');
+  });
+
+  it('should get all words with a given prefix', () => {
+    const trie = new Trie();
+    trie.add('apple');
+    trie.add('app');
+    trie.add('application');
+    const words = trie.getAll('app');
+    expect(words).toEqual(['apple', 'application', 'app']);
+  });
+
+  it('should remove words from Trie', () => {
+    const trie = new Trie();
+    trie.add('apple');
+    trie.add('app');
+    expect(trie.has('apple')).toBe(true);
+    trie.remove('apple');
+    expect(trie.has('apple')).toBe(false);
+    expect(trie.has('app')).toBe(true);
+    trie.remove('app');
+    expect(trie.has('app')).toBe(false);
+  });
+});

package/test/utils/magnitude.ts

@@ -8,14 +8,14 @@ export const magnitude = {
   SQUARED: Math.pow(10, 4 - orderReducedBy),
   CUBED: Math.pow(10, 3 - orderReducedBy),
   FACTORIAL: 20 - orderReducedBy
-}
+};
 
 export const bigO = {
   CONSTANT: magnitude.CONSTANT / 100000,
   LOG_N: Math.log2(magnitude.LOG_N) / 1000,
   LINEAR: magnitude.LINEAR / 1000,
-  N_LOG_N: magnitude.N_LOG_N * Math.log2(magnitude.LOG_N) / 1000,
+  N_LOG_N: (magnitude.N_LOG_N * Math.log2(magnitude.LOG_N)) / 1000,
   SQUARED: Math.pow(magnitude.SQUARED, 2) / 1000,
   CUBED: Math.pow(magnitude.SQUARED, 3) / 1000,
   FACTORIAL: 10000
-}
+};

package/tsconfig.json

@@ -2,12 +2,10 @@
   "compilerOptions": {
     "outDir": "./lib",
     "declaration": true,
-//    "declarationDir": "./lib",
     "module": "ES6",
     "target": "ES6",
     "lib": [
-      "esnext",
-      "dom"
+      "ESNext"
     ],
     "strict": true,
     "esModuleInterop": true,
@@ -15,14 +13,6 @@
     "skipLibCheck": true,
     "downlevelIteration": true,
     "experimentalDecorators": true,
-    //    "removeComments": true,
-    //    "allowJs": true,
-    //    "allowSyntheticDefaultImports": true,
-    //    "forceConsistentCasingInFileNames": true,
-    //    "noFallthroughCasesInSwitch": true,
-    //    "resolveJsonModule": true,
-    //    "isolatedModules": true,
-    //    "noEmit": true,
     "typeRoots": [
       "node_modules/@types"
     ]
@@ -32,7 +22,8 @@
   "exclude": [
     "node_modules",
     "lib",
-    "dist"
+    "dist",
+    "umd"
   ]
 }
 

package/tsconfig.prod.json

@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "target": "ES5",
+    "module": "CommonJS",
+    "outDir": "./dist",
+    "sourceMap": true,
+    "lib": [
+      "ESNext"
+    ],
+    "strict": true,
+    "downlevelIteration": true,
+    "removeComments": true,
+    "typeRoots": [
+      "node_modules/@types"
+    ]
+  },
+  "include": ["src/**/*.ts", "src/**/*.js"],
+  "exclude": [
+    "node_modules",
+    "lib",
+    "dist",
+    "umd"
+  ]
+}
+