npm - data-structure-typed - Versions diffs - 1.33.0 → 1.33.2 - Mend

data-structure-typed 1.33.0 → 1.33.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (93) hide show

package/test/integration/index.html CHANGED Viewed

@@ -1,13 +1,13 @@
 <!DOCTYPE html>
-<html lang="en">
+<html lang='en'>
 <head>
-  <meta charset="UTF-8">
+  <meta charset='UTF-8'>
   <title>CDN Test</title>
-  <script src="https://cdn.jsdelivr.net/npm/data-structure-typed/umd/bundle.min.js"></script>
+  <script src='https://cdn.jsdelivr.net/npm/data-structure-typed/umd/bundle.min.js'></script>
 </head>
 <body>
-<div id="app">
-  <ul class="modules">
+<div id='app'>
+  <ul class='modules'>
   </ul>
 </div>
@@ -36,7 +36,7 @@
     last = queue.dequeue();
   }
-  console.log(performance.now() - startTime)
+  console.log(performance.now() - startTime);
 </script>
 </body>

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

@@ -0,0 +1,146 @@
+import {BinaryTreeNode} from '../../../../src';
+import {BinaryTree} from 'binary-tree-typed';
+describe('BinaryTreeNode', () => {
+  it('should create an instance of BinaryTreeNode', () => {
+    const node = new BinaryTreeNode<number>(1);
+    expect(node).toBeInstanceOf(BinaryTreeNode);
+  });
+  it('should set and get the ID correctly', () => {
+    const node = new BinaryTreeNode<number>(1);
+    expect(node.id).toBe(1);
+    node.id = 2;
+    expect(node.id).toBe(2);
+  });
+  it('should set and get the value correctly', () => {
+    const node = new BinaryTreeNode<number>(1, 42);
+    expect(node.val).toBe(42);
+    node.val = 55;
+    expect(node.val).toBe(55);
+  });
+  it('should set and get the left child correctly', () => {
+    const node1 = new BinaryTreeNode<number>(1);
+    const node2 = new BinaryTreeNode<number>(2);
+    node1.left = node2;
+    expect(node1.left).toBe(node2);
+    expect(node2.parent).toBe(node1);
+  });
+  it('should set and get the right child correctly', () => {
+    const node1 = new BinaryTreeNode<number>(1);
+    const node2 = new BinaryTreeNode<number>(2);
+    node1.right = node2;
+    expect(node1.right).toBe(node2);
+    expect(node2.parent).toBe(node1);
+  });
+  it('should set and get the parent correctly', () => {
+    const node1 = new BinaryTreeNode<number>(1);
+    const node2 = new BinaryTreeNode<number>(2);
+    node1.left = node2;
+    expect(node2.parent).toBe(node1);
+    expect(node1.left).toBe(node2);
+  });
+  it('should set and get the height correctly', () => {
+    const node = new BinaryTreeNode<number>(1);
+    expect(node.height).toBe(0);
+    node.height = 3;
+    expect(node.height).toBe(3);
+  });
+  it('should determine family position correctly', () => {
+    const root = new BinaryTreeNode<number>(1);
+    const leftChild = new BinaryTreeNode<number>(2);
+    const rightChild = new BinaryTreeNode<number>(3);
+    root.left = leftChild;
+    root.right = rightChild;
+    expect(leftChild.familyPosition).toBe('LEFT');
+    expect(rightChild.familyPosition).toBe('RIGHT');
+    expect(root.familyPosition).toBe('ROOT');
+  });
+});
+describe('BinaryTree', () => {
+  let binaryTree: BinaryTree;
+  beforeEach(() => {
+    binaryTree = new BinaryTree();
+  });
+  afterEach(() => {
+    binaryTree.clear();
+  });
+  test('should add a node', () => {
+    const node = binaryTree.add(1);
+    expect(node).not.toBeNull();
+    expect(binaryTree.size).toBe(1);
+  });
+  test('should remove a node', () => {
+    const node = binaryTree.add(1);
+    expect(binaryTree.size).toBe(1);
+    if (node) {
+      const result = binaryTree.remove(node);
+      expect(result).toHaveLength(1);
+      expect(binaryTree.size).toBe(0);
+    }
+  });
+  test('should add and find nodes', () => {
+    binaryTree.add(1);
+    binaryTree.add(2);
+    binaryTree.add(3);
+    expect(binaryTree.has(1)).toBe(true);
+    expect(binaryTree.has(2)).toBe(true);
+    expect(binaryTree.has(3)).toBe(true);
+    expect(binaryTree.has(4)).toBe(false);
+  });
+  test('should traverse in-order', () => {
+    binaryTree.add(4);
+    binaryTree.add(2);
+    binaryTree.add(6);
+    binaryTree.add(1);
+    binaryTree.add(3);
+    binaryTree.add(5);
+    binaryTree.add(7);
+    const inOrder = binaryTree.DFS('in');
+    expect(inOrder).toEqual([1, 2, 3, 4, 5, 6, 7]);
+  });
+  test('should clear the tree', () => {
+    binaryTree.add(1);
+    binaryTree.add(2);
+    expect(binaryTree.size).toBe(2);
+    binaryTree.clear();
+    expect(binaryTree.size).toBe(0);
+    expect(binaryTree.root).toBeNull();
+  });
+});

package/test/unit/data-structures/binary-tree/rb-tree.test.ts ADDED Viewed

@@ -0,0 +1,44 @@
+// import {RBTree, RBTreeNode} from '../../../../src';
+describe('Red-Black Tree Tests', () => {
+  // let tree: RBTree<RBTreeNode<number>>;
+  //
+  // beforeEach(() => {
+  //   tree = new RBTree<RBTreeNode<number>>();
+  // });
+  test('Insertion and In-order Traversal', () => {
+    // tree.add(5);
+    // tree.add(3);
+    // tree.add(7);
+    // tree.add(2);
+    // tree.add(4);
+    // tree.add(6);
+    // tree.add(8);
+    //
+    // const inOrderTraversal: number[] = tree.DFS('in')
+    //
+    // expect(inOrderTraversal).toEqual([2, 3, 4, 5, 6, 7, 8]);
+  });
+  test('Deletion', () => {
+    // tree.add(5);
+    // tree.add(3);
+    // tree.add(7);
+    // tree.add(2);
+    // tree.add(4);
+    // tree.add(6);
+    // tree.add(8);
+    //
+    // // Delete a node (e.g., 3) and check if it's gone
+    // tree.remove(3);
+    // expect(tree.has(3)).toBe(false);
+    //
+    // // Perform in-order traversal to check if the tree is still balanced
+    // const inOrderTraversal: number[] = tree.DFS('in');
+    //
+    //
+    // expect(inOrderTraversal).toEqual([2, 4, 5, 6, 7, 8]);
+  });
+});

package/test/unit/data-structures/hash/coordinate-map.test.ts ADDED Viewed

@@ -0,0 +1,54 @@
+import {CoordinateMap} from '../../../../src';
+describe('CoordinateMap', () => {
+  it('should set and get values correctly', () => {
+    const coordinateMap = new CoordinateMap<string>();
+    const key = [1, 2, 3];
+    const value = 'TestValue';
+    coordinateMap.set(key, value);
+    const retrievedValue = coordinateMap.get(key);
+    expect(retrievedValue).toBe(value);
+  });
+  it('should return true when key exists', () => {
+    const coordinateMap = new CoordinateMap<string>();
+    const key = [1, 2, 3];
+    const value = 'TestValue';
+    coordinateMap.set(key, value);
+    expect(coordinateMap.has(key)).toBe(true);
+  });
+  it('should return false when key does not exist', () => {
+    const coordinateMap = new CoordinateMap<string>();
+    const key = [1, 2, 3];
+    expect(coordinateMap.has(key)).toBe(false);
+  });
+  it('should delete key-value pair correctly', () => {
+    const coordinateMap = new CoordinateMap<string>();
+    const key = [1, 2, 3];
+    const value = 'TestValue';
+    coordinateMap.set(key, value);
+    coordinateMap.delete(key);
+    expect(coordinateMap.has(key)).toBe(false);
+  });
+  it('should allow changing the joint character', () => {
+    const coordinateMap = new CoordinateMap<string>();
+    const key = [1, 2, 3];
+    const value = 'TestValue';
+    coordinateMap.set(key, value);
+    const newKey = [1, 2, 3];
+    const retrievedValue = coordinateMap.get(newKey);
+    expect(retrievedValue).toBe(value);
+  });
+});

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

@@ -0,0 +1,41 @@
+import {CoordinateSet} from '../../../../src';
+describe('CoordinateSet', () => {
+  it('should add and check values correctly', () => {
+    const coordinateSet = new CoordinateSet();
+    const value = [1, 2, 3];
+    coordinateSet.add(value);
+    const hasValue = coordinateSet.has(value);
+    expect(hasValue).toBe(true);
+  });
+  it('should return false when value does not exist', () => {
+    const coordinateSet = new CoordinateSet();
+    const value = [1, 2, 3];
+    expect(coordinateSet.has(value)).toBe(false);
+  });
+  it('should delete value correctly', () => {
+    const coordinateSet = new CoordinateSet();
+    const value = [1, 2, 3];
+    coordinateSet.add(value);
+    coordinateSet.delete(value);
+    expect(coordinateSet.has(value)).toBe(false);
+  });
+  it('should allow changing the joint character', () => {
+    const coordinateSet = new CoordinateSet();
+    const value = [1, 2, 3];
+    coordinateSet.add(value);
+    const newValue = [1, 2, 3];
+    const hasValue = coordinateSet.has(newValue);
+    expect(hasValue).toBe(true);
+  });
+});

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

@@ -0,0 +1,97 @@
+import {HashNode, HashTable} from '../../../../src';
+describe('HashNode', () => {
+  it('should create a HashNode with key and value', () => {
+    const key = 'testKey';
+    const value = 'testValue';
+    const hashNode = new HashNode(key, value);
+    expect(hashNode.key).toBe(key);
+    expect(hashNode.val).toBe(value);
+    expect(hashNode.next).toBe(null);
+  });
+});
+describe('HashTable', () => {
+  it('should initialize with default capacity', () => {
+    const hashTable = new HashTable<string, string>();
+    expect(hashTable.capacity).toBe(1000);
+    expect(hashTable.size).toBe(0);
+    expect(hashTable.buckets.length).toBe(1000);
+  });
+  it('should initialize with custom capacity', () => {
+    const customCapacity = 500;
+    const hashTable = new HashTable<string, string>(customCapacity);
+    expect(hashTable.capacity).toBe(customCapacity);
+    expect(hashTable.size).toBe(0);
+    expect(hashTable.buckets.length).toBe(customCapacity);
+  });
+  it('should put and get values correctly', () => {
+    const hashTable = new HashTable<string, string>();
+    const key = 'testKey';
+    const value = 'testValue';
+    hashTable.put(key, value);
+    const retrievedValue = hashTable.get(key);
+    expect(retrievedValue).toBe(value);
+  });
+  it('should handle collisions by chaining', () => {
+    const hashTable = new HashTable<string, string>();
+    const key1 = 'testKey1';
+    const value1 = 'testValue1';
+    const key2 = 'testKey2';
+    const value2 = 'testValue2';
+    hashTable.put(key1, value1);
+    hashTable.put(key2, value2);
+    const retrievedValue1 = hashTable.get(key1);
+    const retrievedValue2 = hashTable.get(key2);
+    expect(retrievedValue1).toBe(value1);
+    expect(retrievedValue2).toBe(value2);
+  });
+  it('should update value for an existing key', () => {
+    const hashTable = new HashTable<string, string>();
+    const key = 'testKey';
+    const initialValue = 'testValue1';
+    const updatedValue = 'testValue2';
+    hashTable.put(key, initialValue);
+    hashTable.put(key, updatedValue);
+    const retrievedValue = hashTable.get(key);
+    expect(retrievedValue).toBe(updatedValue);
+  });
+  it('should return undefined for non-existent key', () => {
+    const hashTable = new HashTable<string, string>();
+    const key = 'nonExistentKey';
+    const retrievedValue = hashTable.get(key);
+    expect(retrievedValue).toBeUndefined();
+  });
+  it('should remove key-value pair correctly', () => {
+    const hashTable = new HashTable<string, string>();
+    const key = 'testKey';
+    const value = 'testValue';
+    hashTable.put(key, value);
+    hashTable.remove(key);
+    const retrievedValue = hashTable.get(key);
+    expect(retrievedValue).toBeUndefined();
+    expect(hashTable.size).toBe(0);
+  });
+});

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

@@ -21,7 +21,6 @@ describe('LinkedList Performance Test', () => {
     const singlyList = new SinglyLinkedList<number>();
     let midSinglyNode: SinglyLinkedListNode | null = null;
-    const startSinglyPushTime = performance.now();
     for (let i = 0; i < magnitude.SQUARED; i++) {
       singlyList.push(i);
       if (i === midIndex) {
@@ -31,7 +30,6 @@ describe('LinkedList Performance Test', () => {
       }
     }
-    const singlyListPushCost = performance.now() - startSinglyPushTime;
-    expect(doublyListPushCost).toBeLessThan(bigO.SQUARED * 2);
+    expect(doublyListPushCost).toBeLessThan(bigO.SQUARED * 5);
   });
 });

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

@@ -399,3 +399,56 @@ describe('SinglyLinkedList Performance Test', () => {
     expect(performance.now() - startPopTime).toBeLessThan(bigO.LINEAR * 300);
   });
 });
+describe('SinglyLinkedList', () => {
+  let list: SinglyLinkedList<number>;
+  beforeEach(() => {
+    list = new SinglyLinkedList<number>();
+  });
+  it('should initialize an empty list', () => {
+    expect(list.head).toBeNull();
+    expect(list.tail).toBeNull();
+    expect(list.length).toBe(0);
+  });
+  it('should push elements to the end of the list', () => {
+    list.push(1);
+    list.push(2);
+    expect(list.head!.val).toBe(1);
+    expect(list.tail!.val).toBe(2);
+    expect(list.length).toBe(2);
+  });
+  it('should pop elements from the end of the list', () => {
+    list.push(1);
+    list.push(2);
+    const popped = list.pop();
+    expect(popped).toBe(2);
+    expect(list.head!.val).toBe(1);
+    expect(list.tail!.val).toBe(1);
+    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);
+    list.push(2);
+    list.push(3);
+    list.reverse();
+    expect(list.head!.val).toBe(3);
+    expect(list.tail!.val).toBe(1);
+    // 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);
+    list.push(2);
+    list.push(3);
+    const array = list.toArray();
+    expect(array).toEqual([1, 2, 3]);
+  });
+});

package/test/unit/data-structures/matrix/matrix.test.ts ADDED Viewed

@@ -0,0 +1,54 @@
+import {MatrixNTI2D} from '../../../../src';
+describe('MatrixNTI2D', () => {
+  it('should initialize a matrix with rows and columns', () => {
+    const numRows = 3;
+    const numCols = 4;
+    const matrix = new MatrixNTI2D({ row: numRows, col: numCols });
+    expect(matrix.toArray().length).toBe(numRows);
+    expect(matrix.toArray()[0].length).toBe(numCols);
+  });
+  it('should initialize all elements with the provided initial value', () => {
+    const numRows = 3;
+    const numCols = 4;
+    const initialValue = 42;
+    const matrix = new MatrixNTI2D({ row: numRows, col: numCols, initialVal: initialValue });
+    const matrixArray = matrix.toArray();
+    for (let i = 0; i < numRows; i++) {
+      for (let j = 0; j < numCols; j++) {
+        expect(matrixArray[i][j]).toBe(initialValue);
+      }
+    }
+  });
+  it('should initialize all elements with 0 if no initial value is provided', () => {
+    const numRows = 3;
+    const numCols = 4;
+    const matrix = new MatrixNTI2D({ row: numRows, col: numCols });
+    const matrixArray = matrix.toArray();
+    for (let i = 0; i < numRows; i++) {
+      for (let j = 0; j < numCols; j++) {
+        expect(matrixArray[i][j]).toBe(0);
+      }
+    }
+  });
+  it('should convert the matrix to a two-dimensional array', () => {
+    const numRows = 2;
+    const numCols = 3;
+    const matrix = new MatrixNTI2D({ row: numRows, col: numCols, initialVal: 1 });
+    const matrixArray = matrix.toArray();
+    expect(matrixArray.length).toBe(numRows);
+    for (let i = 0; i < numRows; i++) {
+      expect(matrixArray[i].length).toBe(numCols);
+      for (let j = 0; j < numCols; j++) {
+        expect(matrixArray[i][j]).toBe(1);
+      }
+    }
+  });
+});

package/test/unit/data-structures/matrix/matrix2d.test.ts ADDED Viewed

@@ -0,0 +1,138 @@
+import {Matrix2D, Vector2D} from '../../../../src';
+describe('Matrix2D', () => {
+  it('should initialize with default identity matrix', () => {
+    const matrix = new Matrix2D();
+    const expectedMatrix = Matrix2D.identity;
+    expect(matrix.m).toEqual(expectedMatrix);
+  });
+  it('should initialize with provided 2D array', () => {
+    const inputMatrix = [
+      [2, 0, 0],
+      [0, 3, 0],
+      [0, 0, 1]
+    ];
+    const matrix = new Matrix2D(inputMatrix);
+    expect(matrix.m).toEqual(inputMatrix);
+  });
+  it('should initialize with provided Vector2D', () => {
+    expect(true).toBeTruthy();
+  });
+  it('should add two matrices correctly', () => {
+    const matrix1 = new Matrix2D([
+      [1, 2, 3],
+      [4, 5, 6],
+      [7, 8, 9]
+    ]);
+    const matrix2 = new Matrix2D([
+      [9, 8, 7],
+      [6, 5, 4],
+      [3, 2, 1]
+    ]);
+    const expectedMatrix = [
+      [10, 10, 10],
+      [10, 10, 10],
+      [10, 10, 10]
+    ];
+    const result = Matrix2D.add(matrix1, matrix2);
+    expect(result.m).toEqual(expectedMatrix);
+  });
+  it('should subtract two matrices correctly', () => {
+    const matrix1 = new Matrix2D([
+      [9, 8, 7],
+      [6, 5, 4],
+      [3, 2, 1]
+    ]);
+    const matrix2 = new Matrix2D([
+      [1, 2, 3],
+      [4, 5, 6],
+      [7, 8, 9]
+    ]);
+    const expectedMatrix = [
+      [8, 6, 4],
+      [2, 0, -2],
+      [-4, -6, -8]
+    ];
+    const result = Matrix2D.subtract(matrix1, matrix2);
+    expect(result.m).toEqual(expectedMatrix);
+  });
+  it('should multiply two matrices correctly', () => {
+    const matrix1 = new Matrix2D([
+      [1, 2, 3],
+      [4, 5, 6],
+      [7, 8, 9]
+    ]);
+    const matrix2 = new Matrix2D([
+      [9, 8, 7],
+      [6, 5, 4],
+      [3, 2, 1]
+    ]);
+    const expectedMatrix = [
+      [30, 24, 18],
+      [84, 69, 54],
+      [138, 114, 90]
+    ];
+    const result = Matrix2D.multiply(matrix1, matrix2);
+    expect(result.m).toEqual(expectedMatrix);
+  });
+  it('should multiply a matrix by a Vector2D correctly', () => {
+    expect(true).toBeTruthy();
+  });
+  it('should scale a matrix by a value correctly', () => {
+    expect(true).toBeTruthy();
+  });
+  it('should rotate a matrix by radians correctly', () => {
+    expect(true).toBeTruthy();
+  });
+  it('should translate a matrix by a Vector2D correctly', () => {
+    const translationVector = new Vector2D(2, 3);
+    const expectedMatrix = [
+      [1, 0, 2],
+      [0, 1, 3],
+      [0, 0, 1]
+    ];
+    const result = Matrix2D.translate(translationVector);
+    expect(result.m).toEqual(expectedMatrix);
+  });
+  it('should create a view matrix correctly', () => {
+    expect(true).toBeTruthy();
+  });
+  it('should multiply a matrix by a value correctly', () => {
+    const matrix = new Matrix2D([
+      [1, 2, 3],
+      [4, 5, 6],
+      [7, 8, 9]
+    ]);
+    const value = 2;
+    const expectedMatrix = [
+      [2, 4, 6],
+      [8, 10, 12],
+      [14, 16, 18]
+    ];
+    const result = Matrix2D.multiplyByValue(matrix, value);
+    expect(result.m).toEqual(expectedMatrix);
+  });
+});