data-structure-typed 2.4.0 → 2.4.2

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

@@ -1,299 +0,0 @@
-import {
-  AVLTree,
-  BinaryTree,
-  BST,
-  Deque,
-  DoublyLinkedList,
-  HashMap,
-  Heap,
-  MaxHeap,
-  MaxPriorityQueue,
-  MinHeap,
-  MinPriorityQueue,
-  Queue,
-  RedBlackTree,
-  SinglyLinkedList,
-  Stack,
-  TreeMultiMap,
-  Trie
-} from '../../src';
-import { isDebugTest } from '../config';
-
-const isDebug = isDebugTest;
-const orgArr: number[] = [6, 1, 2, 7, 5, 3, 4, 9, 8];
-const orgStrArr: string[] = [
-  'trie',
-  'trial',
-  'trick',
-  'trip',
-  'tree',
-  'trend',
-  'triangle',
-  'track',
-  'trace',
-  'transmit'
-];
-const entries: [number, string][] = [
-  [6, '6'],
-  [1, '1'],
-  [2, '2'],
-  [7, '7'],
-  [5, '5'],
-  [3, '3'],
-  [4, '4'],
-  [9, '9'],
-  [8, '8']
-];
-
-describe('conversions', () => {
-  it('Array to Queue', () => {
-    const q = new Queue<number>(orgArr);
-    if (isDebug) q.print();
-    expect([...q]).toEqual([6, 1, 2, 7, 5, 3, 4, 9, 8]);
-  });
-
-  it('Array to Deque', () => {
-    const dq = new Deque<number>(orgArr);
-    if (isDebug) dq.print();
-    expect([...dq]).toEqual([6, 1, 2, 7, 5, 3, 4, 9, 8]);
-  });
-
-  it('Array to SinglyLinkedList', () => {
-    const sl = new SinglyLinkedList<number>(orgArr);
-    if (isDebug) sl.print();
-    expect([...sl]).toEqual([6, 1, 2, 7, 5, 3, 4, 9, 8]);
-  });
-
-  it('Array to DoublyLinkedList', () => {
-    const dl = new DoublyLinkedList<number>(orgArr);
-    if (isDebug) dl.print();
-    expect([...dl]).toEqual([6, 1, 2, 7, 5, 3, 4, 9, 8]);
-  });
-
-  it('Array to Stack', () => {
-    const stack = new Stack<number>(orgArr);
-    if (isDebug) stack.print();
-    expect([...stack]).toEqual([6, 1, 2, 7, 5, 3, 4, 9, 8]);
-  });
-
-  it('Array to MinHeap', () => {
-    const minHeap = new MinHeap<number>(orgArr);
-    if (isDebug) minHeap.print();
-    expect([...minHeap]).toEqual([1, 5, 2, 7, 6, 3, 4, 9, 8]);
-  });
-
-  it('Array to MaxHeap', () => {
-    const maxHeap = new MaxHeap<number>(orgArr);
-    if (isDebug) maxHeap.print();
-    expect([...maxHeap]).toEqual([9, 8, 4, 7, 5, 2, 3, 1, 6]);
-  });
-
-  it('Array to MinPriorityQueue', () => {
-    const minPQ = new MinPriorityQueue<number>(orgArr);
-    if (isDebug) minPQ.print();
-    expect([...minPQ]).toEqual([1, 5, 2, 7, 6, 3, 4, 9, 8]);
-  });
-
-  it('Array to MaxPriorityQueue', () => {
-    const maxPQ = new MaxPriorityQueue<number>(orgArr);
-    if (isDebug) maxPQ.print();
-    expect([...maxPQ]).toEqual([9, 8, 4, 7, 5, 2, 3, 1, 6]);
-  });
-
-  it('Entry Array to BinaryTree', () => {
-    const biTree = new BinaryTree<number>(entries);
-    if (isDebug) biTree.print();
-    expect([...biTree]).toEqual([
-      [9, '9'],
-      [7, '7'],
-      [8, '8'],
-      [1, '1'],
-      [5, '5'],
-      [6, '6'],
-      [3, '3'],
-      [2, '2'],
-      [4, '4']
-    ]);
-  });
-
-  it('Entry Array to BST', () => {
-    const bst = new BST<number>(entries);
-    expect(bst.size).toBe(9);
-    if (isDebug) bst.print();
-    expect([...bst]).toEqual([
-      [1, '1'],
-      [2, '2'],
-      [3, '3'],
-      [4, '4'],
-      [5, '5'],
-      [6, '6'],
-      [7, '7'],
-      [8, '8'],
-      [9, '9']
-    ]);
-  });
-
-  it('Entry Array to RedBlackTree', () => {
-    const rbTree = new RedBlackTree<number>(entries);
-    expect(rbTree.size).toBe(9);
-    if (isDebug) rbTree.print();
-    expect([...rbTree]).toEqual([
-      [1, '1'],
-      [2, '2'],
-      [3, '3'],
-      [4, '4'],
-      [5, '5'],
-      [6, '6'],
-      [7, '7'],
-      [8, '8'],
-      [9, '9']
-    ]);
-  });
-
-  it('Entry Array to AVLTree', () => {
-    const avl = new AVLTree<number>(entries);
-    expect(avl.size).toBe(9);
-    if (isDebug) avl.print();
-    expect([...avl]).toEqual([
-      [1, '1'],
-      [2, '2'],
-      [3, '3'],
-      [4, '4'],
-      [5, '5'],
-      [6, '6'],
-      [7, '7'],
-      [8, '8'],
-      [9, '9']
-    ]);
-  });
-
-  it('Entry Array to TreeMultiMap', () => {
-    // TreeMultiMap uses bucket semantics: [key, values[]]
-    const bucketEntries: [number, string[]][] = entries.map(([k, v]) => [k, [v]]);
-    const treeMulti = new TreeMultiMap<number, string>(bucketEntries);
-    expect(treeMulti.size).toBe(9);
-    if (isDebug) treeMulti.print();
-    expect([...treeMulti]).toEqual([
-      [1, ['1']],
-      [2, ['2']],
-      [3, ['3']],
-      [4, ['4']],
-      [5, ['5']],
-      [6, ['6']],
-      [7, ['7']],
-      [8, ['8']],
-      [9, ['9']]
-    ]);
-  });
-
-  it('HashMap to RedBlackTree', () => {
-    const hm = new HashMap(entries);
-    if (isDebug) hm.print();
-    const rbTree = new RedBlackTree<number>(hm);
-    expect(rbTree.size).toBe(9);
-    if (isDebug) rbTree.print();
-    expect([...rbTree]).toEqual([
-      [1, '1'],
-      [2, '2'],
-      [3, '3'],
-      [4, '4'],
-      [5, '5'],
-      [6, '6'],
-      [7, '7'],
-      [8, '8'],
-      [9, '9']
-    ]);
-  });
-
-  it('PriorityQueue to BST', () => {
-    const pq = new MinPriorityQueue(orgArr);
-    if (isDebug) pq.print();
-    const bst = new BST<number>(pq);
-    expect(bst.size).toBe(9);
-    if (isDebug) bst.print();
-    expect([...bst]).toEqual([
-      [1, undefined],
-      [2, undefined],
-      [3, undefined],
-      [4, undefined],
-      [5, undefined],
-      [6, undefined],
-      [7, undefined],
-      [8, undefined],
-      [9, undefined]
-    ]);
-  });
-
-  it('Deque to RedBlackTree', () => {
-    const dq = new Deque(orgArr);
-    if (isDebug) dq.print();
-    const rbTree = new RedBlackTree<number>(dq);
-    expect(rbTree.size).toBe(9);
-    if (isDebug) rbTree.print();
-    expect([...rbTree]).toEqual([
-      [1, undefined],
-      [2, undefined],
-      [3, undefined],
-      [4, undefined],
-      [5, undefined],
-      [6, undefined],
-      [7, undefined],
-      [8, undefined],
-      [9, undefined]
-    ]);
-  });
-
-  it('Trie to Heap to Deque', () => {
-    const trie = new Trie(orgStrArr);
-    expect(trie.size).toBe(10);
-    if (isDebug) trie.print();
-    const heap = new Heap<string>(trie, {
-      comparator: (a, b) => Number(a) - Number(b)
-    });
-    expect(heap.size).toBe(10);
-    if (isDebug) heap.print();
-    expect([...heap]).toEqual([
-      'transmit',
-      'trace',
-      'tree',
-      'trend',
-      'track',
-      'trial',
-      'trip',
-      'trie',
-      'trick',
-      'triangle'
-    ]);
-    const dq = new Deque<string>(heap);
-    expect(dq.length).toBe(10);
-    if (isDebug) dq.print();
-    expect([...dq]).toEqual([
-      'transmit',
-      'trace',
-      'tree',
-      'trend',
-      'track',
-      'trial',
-      'trip',
-      'trie',
-      'trick',
-      'triangle'
-    ]);
-    const entries = dq.map((el, i) => <[number, string]>[i, el]);
-    const avl = new AVLTree<number, string>(entries);
-    expect(avl.size).toBe(10);
-    if (isDebug) avl.print();
-    expect([...avl]).toEqual([
-      [0, 'transmit'],
-      [1, 'trace'],
-      [2, 'tree'],
-      [3, 'trend'],
-      [4, 'track'],
-      [5, 'trial'],
-      [6, 'trip'],
-      [7, 'trie'],
-      [8, 'trick'],
-      [9, 'triangle']
-    ]);
-  });
-});

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

@@ -1,174 +0,0 @@
-import { isComparable } from '../../../src';
-
-describe('isNaN', () => {
-  it('should isNaN', function () {
-    expect(isNaN('string' as unknown as number)).toBe(true);
-  });
-});
-
-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);
-    });
-  });
-});