data-structure-typed 1.33.7 → 1.33.9

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

@@ -1,54 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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-map.test.ts

@@ -1,104 +0,0 @@
-import {HashMap} from '../../../../src';
-
-describe('HashMap', () => {
-  let hashMap: HashMap<string, number>;
-
-  beforeEach(() => {
-    hashMap = new HashMap<string, number>();
-  });
-
-  it('should initialize correctly', () => {
-    expect(hashMap.size).toBe(0);
-    expect(hashMap.table.length).toBe(16);
-    expect(hashMap.loadFactor).toBe(0.75);
-    expect(hashMap.capacityMultiplier).toBe(2);
-    expect(hashMap.initialCapacity).toBe(16);
-    expect(hashMap.isEmpty()).toBe(true);
-  });
-
-  it('should put and get values', () => {
-    hashMap.set('one', 1);
-    hashMap.set('two', 2);
-    hashMap.set('three', 3);
-
-    expect(hashMap.get('one')).toBe(1);
-    expect(hashMap.get('two')).toBe(2);
-    expect(hashMap.get('three')).toBe(3);
-  });
-
-  it('should handle key collisions', () => {
-    // Force a collision by setting two different keys to the same bucket
-    hashMap.hashFn = () => 0; // Override hash function to return the same index
-    hashMap.set('key1', 1);
-    hashMap.set('key2', 2);
-
-    expect(hashMap.get('key1')).toBe(1);
-    expect(hashMap.get('key2')).toBe(2);
-  });
-
-  it('should remove values', () => {
-    hashMap.set('one', 1);
-    hashMap.set('two', 2);
-
-    hashMap.remove('one');
-    expect(hashMap.get('one')).toBeUndefined();
-    expect(hashMap.size).toBe(1);
-  });
-
-  it('should clear the HashMap', () => {
-    hashMap.set('one', 1);
-    hashMap.set('two', 2);
-
-    hashMap.clear();
-    expect(hashMap.size).toBe(0);
-    expect(hashMap.isEmpty()).toBe(true);
-  });
-
-  it('should iterate over entries', () => {
-    hashMap.set('one', 1);
-    hashMap.set('two', 2);
-    hashMap.set('three', 3);
-
-    const entries = Array.from(hashMap.entries());
-    expect(entries).toEqual(
-      expect.arrayContaining([
-        ['one', 1],
-        ['two', 2],
-        ['three', 3]
-      ])
-    );
-  });
-
-  it('should resize the table when load factor is exceeded', () => {
-    // Set a small initial capacity for testing resizing
-    hashMap = new HashMap<string, number>(4, 0.5);
-
-    hashMap.set('one', 1);
-    hashMap.set('two', 2);
-    hashMap.set('three', 3);
-    hashMap.set('four', 4); // This should trigger a resize
-
-    expect(hashMap.table.length).toBe(8);
-    expect(hashMap.get('one')).toBe(1);
-    expect(hashMap.get('two')).toBe(2);
-    expect(hashMap.get('three')).toBe(3);
-    expect(hashMap.get('four')).toBe(4);
-  });
-
-  it('should allow using a custom hash function', () => {
-    const customHashFn = () => {
-      // A simple custom hash function that always returns 0
-      return 0;
-    };
-    hashMap = new HashMap<string, number>(16, 0.75, customHashFn);
-
-    hashMap.set('one', 1);
-    hashMap.set('two', 2);
-
-    expect(hashMap.get('one')).toBe(1);
-    expect(hashMap.get('two')).toBe(2);
-    // Since the custom hash function always returns 0, these keys will collide.
-    // Make sure they are stored separately.
-    expect(hashMap.table[0].length).toBe(2);
-  });
-});

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

@@ -1,184 +0,0 @@
-import {HashTableNode, HashTable} from '../../../../src';
-
-describe('HashNode', () => {
-  it('should create a HashNode with key and value', () => {
-    const key = 'testKey';
-    const value = 'testValue';
-    const hashNode = new HashTableNode(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(16);
-    expect(hashTable.size).toBe(0);
-    expect(hashTable.buckets.length).toBe(16);
-  });
-
-  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.set(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.set(key1, value1);
-    hashTable.set(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.set(key, initialValue);
-    hashTable.set(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.set(key, value);
-    hashTable.remove(key);
-
-    const retrievedValue = hashTable.get(key);
-
-    expect(retrievedValue).toBeUndefined();
-    expect(hashTable.size).toBe(0);
-  });
-});
-
-describe('HashTable', () => {
-  let hashTable: HashTable<string, number>;
-
-  beforeEach(() => {
-    hashTable = new HashTable<string, number>();
-  });
-
-  it('should insert and retrieve values correctly', () => {
-    hashTable.set('one', 1);
-    hashTable.set('two', 2);
-
-    expect(hashTable.get('one')).toBe(1);
-    expect(hashTable.get('two')).toBe(2);
-  });
-
-  it('should update values correctly', () => {
-    hashTable.set('one', 1);
-    expect(hashTable.get('one')).toBe(1);
-
-    hashTable.set('one', 100); // Update the value
-    expect(hashTable.get('one')).toBe(100);
-  });
-
-  it('should handle collisions correctly', () => {
-    hashTable = new HashTable<string, number>(1); // Set a small capacity to force collisions
-    hashTable.set('one', 1);
-    hashTable.set('two', 2);
-
-    expect(hashTable.get('one')).toBe(1);
-    expect(hashTable.get('two')).toBe(2);
-  });
-
-  it('should remove values correctly', () => {
-    hashTable.set('one', 1);
-    hashTable.set('two', 2);
-    hashTable.remove('one');
-
-    expect(hashTable.get('one')).toBeUndefined();
-    expect(hashTable.get('two')).toBe(2);
-  });
-
-  it('should handle non-existent keys correctly', () => {
-    expect(hashTable.get('non-existent')).toBeUndefined();
-    hashTable.remove('non-existent'); // Removing a non-existent key should not cause errors
-  });
-
-  it('should handle custom hash function correctly', () => {
-    // const customHashFn = () => {
-    //   // Custom hash function that returns a fixed value for all keys
-    //   return 42;
-    // };
-
-    hashTable = new HashTable<string, number>(16);
-    hashTable.set('one', 1);
-    expect(hashTable.get('one')).toBe(1);
-    expect(hashTable.get('two')).toBeUndefined();
-  });
-
-  it('should expand when load factor exceeds threshold', () => {
-    hashTable = new HashTable<string, number>(2); // Set a small capacity to trigger expansion
-    hashTable.set('one', 1);
-    hashTable.set('two', 2);
-    hashTable.set('three', 3); // This should trigger an expansion
-
-    expect(hashTable.capacity).toBe(16);
-    expect(hashTable.get('one')).toBe(1);
-    expect(hashTable.get('two')).toBe(2);
-    expect(hashTable.get('three')).toBe(3);
-  });
-});
-
-describe('HashTable performance', function () {
-  it('Items set performance', function () {
-    const mag = 100000;
-    const ht = new HashTable();
-    // const s = performance.now();
-    for (let i = 0; i < mag; i++) {
-      ht.set(i, i);
-    }
-    // const s1 = performance.now();
-    const map = new Map();
-    for (let i = 0; i < mag; i++) {
-      map.set(i, i);
-    }
-  });
-});

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

@@ -1,55 +0,0 @@
-import {MaxHeap, MinHeap} from '../../../../src';
-
-describe('Heap Operation Test', () => {
-  it('should numeric heap work well', function () {
-    const minNumHeap = new MinHeap<number>();
-    minNumHeap.add(1).add(6).add(2).add(0).add(5).add(9);
-    expect(minNumHeap.has(1)).toBe(true);
-    expect(minNumHeap.has(2)).toBe(true);
-    expect(minNumHeap.poll()).toBe(0);
-    expect(minNumHeap.poll()).toBe(1);
-    expect(minNumHeap.peek()).toBe(2);
-    expect(!minNumHeap.has(1));
-    expect(minNumHeap.has(2));
-    const arrFromHeap = minNumHeap.toArray();
-    expect(arrFromHeap.length).toBe(4);
-    expect(arrFromHeap[0]).toBe(2);
-    expect(arrFromHeap[1]).toBe(5);
-    expect(arrFromHeap[2]).toBe(9);
-    expect(arrFromHeap[3]).toBe(6);
-    expect(minNumHeap.sort()).toEqual([2, 5, 6, 9]);
-  });
-
-  it('should object heap work well', function () {
-    const minHeap = new MinHeap<{a: string}>();
-    minHeap.add(1, {a: 'a1'});
-    minHeap.add(6, {a: 'a6'});
-    minHeap.add(2, {a: 'a2'});
-    minHeap.add(0, {a: 'a0'});
-
-    expect(minHeap.peek()).toEqual({a: 'a0'});
-    expect(minHeap.toArray()).toEqual([{a: 'a0'}, {a: 'a1'}, {a: 'a2'}, {a: 'a6'}]);
-    let i = 0;
-    const expectPolled = [{a: 'a0'}, {a: 'a1'}, {a: 'a2'}, {a: 'a6'}];
-    while (minHeap.size > 0) {
-      expect(minHeap.poll()).toEqual(expectPolled[i]);
-      i++;
-    }
-
-    const maxHeap = new MaxHeap<{a: string}>();
-    maxHeap.add(1, {a: 'a1'});
-    maxHeap.add(6, {a: 'a6'});
-    maxHeap.add(5, {a: 'a5'});
-    maxHeap.add(2, {a: 'a2'});
-    maxHeap.add(0, {a: 'a0'});
-    maxHeap.add(9, {a: 'a9'});
-    expect(maxHeap.peek()).toEqual({a: 'a9'});
-    expect(maxHeap.toArray()).toEqual([{a: 'a9'}, {a: 'a2'}, {a: 'a6'}, {a: 'a1'}, {a: 'a0'}, {a: 'a5'}]);
-    const maxExpectPolled = [{a: 'a9'}, {a: 'a6'}, {a: 'a5'}, {a: 'a2'}, {a: 'a1'}, {a: 'a0'}];
-    let maxI = 0;
-    while (maxHeap.size > 0) {
-      expect(maxHeap.poll()).toEqual(maxExpectPolled[maxI]);
-      maxI++;
-    }
-  });
-});

package/test/unit/data-structures/heap/max-heap.test.ts

@@ -1,44 +0,0 @@
-import {HeapItem, MaxHeap} from '../../../../src';
-
-describe('MaxHeap Operation Test', () => {
-  it('should object Max Heap operations be proper', function () {
-    const maxHeap = new MaxHeap<{keyA: string}>();
-    const myObj1 = {keyA: 'a1'},
-      myObj6 = {keyA: 'a6'},
-      myObj5 = {keyA: 'a5'},
-      myObj2 = {keyA: 'a2'},
-      myObj0 = {keyA: 'a0'},
-      myObj9 = {keyA: 'a9'};
-    maxHeap.add(1, myObj1);
-    expect(maxHeap.has(myObj1)).toBe(true);
-    expect(maxHeap.has(myObj9)).toBe(false);
-    maxHeap.add(6, myObj6);
-    expect(maxHeap.has(myObj6)).toBe(true);
-    maxHeap.add(5, myObj5);
-    expect(maxHeap.has(myObj5)).toBe(true);
-    maxHeap.add(2, myObj2);
-    expect(maxHeap.has(myObj2)).toBe(true);
-    expect(maxHeap.has(myObj6)).toBe(true);
-    maxHeap.add(0, myObj0);
-    expect(maxHeap.has(myObj0)).toBe(true);
-    expect(maxHeap.has(myObj9)).toBe(false);
-    maxHeap.add(9, myObj9);
-    expect(maxHeap.has(myObj9)).toBe(true);
-
-    const peek9 = maxHeap.peek(true);
-    peek9 && peek9.val && expect(peek9.val.keyA).toBe('a9');
-
-    const heapToArr = maxHeap.toArray(true);
-    expect(heapToArr.map(item => item?.val?.keyA)).toEqual(['a9', 'a2', 'a6', 'a1', 'a0', 'a5']);
-
-    const values = ['a9', 'a6', 'a5', 'a2', 'a1', 'a0'];
-    let i = 0;
-    while (maxHeap.size > 0) {
-      const polled = maxHeap.poll(true);
-      expect(polled).toBeInstanceOf(HeapItem);
-      polled && expect(polled.val).toHaveProperty('keyA');
-      polled && polled.val && expect(polled.val.keyA).toBe(values[i]);
-      i++;
-    }
-  });
-});

package/test/unit/data-structures/heap/min-heap.test.ts

@@ -1,82 +0,0 @@
-import {HeapItem, MinHeap} from '../../../../src';
-
-describe('MinHeap Operation Test', () => {
-  it('should numeric Min Heap operations be proper', function () {
-    const minNumHeap = new MinHeap<number>();
-    expect(minNumHeap).toBeInstanceOf(MinHeap);
-
-    minNumHeap.add(1);
-    expect(minNumHeap.has(1)).toBe(true);
-    minNumHeap.add(6);
-    expect(minNumHeap.has(2)).toBe(false);
-    expect(minNumHeap.has(6)).toBe(true);
-    minNumHeap.add(2);
-    expect(minNumHeap.has(2)).toBe(true);
-    minNumHeap.add(0);
-    expect(minNumHeap.has(0)).toBe(true);
-    minNumHeap.add(5);
-    expect(minNumHeap.has(5)).toBe(true);
-    minNumHeap.add(9);
-    expect(minNumHeap.has(9)).toBe(true);
-    expect(minNumHeap.size).toBe(6);
-
-    const poll1 = minNumHeap.poll(true);
-    expect(poll1).toBeInstanceOf(HeapItem);
-    poll1 instanceof HeapItem && expect(poll1.val).toBe(0);
-
-    const poll2 = minNumHeap.poll(true);
-    expect(poll2).toBeInstanceOf(HeapItem);
-    poll2 instanceof HeapItem && expect(poll2.val).toBe(1);
-
-    const peek1 = minNumHeap.peek(true);
-    expect(peek1).toBeInstanceOf(HeapItem);
-    peek1 instanceof HeapItem && expect(peek1.val).toBe(2);
-
-    const heapArray = minNumHeap.toArray(true);
-    expect(heapArray).toBeInstanceOf(Array);
-    expect(heapArray.map(item => item?.priority)).toEqual([2, 5, 9, 6]);
-    expect(minNumHeap.size).toBe(4);
-  });
-
-  it('should object Min Heap operations be proper', function () {
-    class MyObject {
-      keyA: string;
-
-      constructor(keyA: string) {
-        this.keyA = keyA;
-      }
-    }
-
-    const minObjHeap = new MinHeap<MyObject>();
-
-    const obj1 = new MyObject('a1'),
-      obj6 = new MyObject('a6'),
-      obj2 = new MyObject('a2'),
-      obj0 = new MyObject('a0');
-    minObjHeap.add(1, obj1);
-    expect(minObjHeap.has(obj1)).toBe(true);
-    expect(minObjHeap.has(obj6)).toBe(false);
-    minObjHeap.add(6, obj6);
-    expect(minObjHeap.has(obj6)).toBe(true);
-    minObjHeap.add(2, obj2);
-    expect(minObjHeap.has(obj2)).toBe(true);
-    minObjHeap.add(0, obj0);
-    expect(minObjHeap.has(obj0)).toBe(true);
-
-    const peek = minObjHeap.peek(true);
-    peek && peek.val && expect(peek.val.keyA).toBe('a0');
-
-    const heapToArr = minObjHeap.toArray(true);
-    expect(heapToArr.map(item => item?.val?.keyA)).toEqual(['a0', 'a1', 'a2', 'a6']);
-
-    const values = ['a0', 'a1', 'a2', 'a6'];
-    let i = 0;
-    while (minObjHeap.size > 0) {
-      const polled = minObjHeap.poll(true);
-      expect(polled).toBeInstanceOf(HeapItem);
-      polled && expect(polled.val).toBeInstanceOf(MyObject);
-      polled && polled.val && expect(polled.val.keyA).toBe(values[i]);
-      i++;
-    }
-  });
-});