data-structure-typed 2.4.0 → 2.4.2

package/test/unit/data-structures/matrix/navigator.test.ts

@@ -1,244 +0,0 @@
-import { Character, Navigator, NavigatorParams, Turning } from '../../../../src';
-import { isDebugTest } from '../../../config';
-
-const isDebug = isDebugTest;
-const exampleMatrix: number[][] = [
-  [0, 0, 0, 0],
-  [0, 1, 1, 0],
-  [0, 0, 0, 0]
-];
-
-// Create a sample redirect object
-const exampleTurning: Turning = {
-  up: 'right',
-  right: 'down',
-  down: 'left',
-  left: 'up'
-};
-
-// Create a sample move callback function
-const exampleOnMove = () => {
-  expect(true).toBeTruthy();
-  // isDebug && console.log(`Moved to position (${cur[0]}, ${cur[1]})`);
-};
-
-// Create an initial parameter object for the example
-const exampleInit: NavigatorParams<number>['init'] = {
-  cur: [0, 0],
-  charDir: 'right',
-  VISITED: -1
-};
-
-// Create a Navigator Params object
-const exampleNavigatorParams: NavigatorParams<number> = {
-  matrix: exampleMatrix,
-  turning: exampleTurning,
-  onMove: exampleOnMove,
-  init: exampleInit
-};
-
-describe('Character class', () => {
-  it('should create a character with the correct direction', () => {
-    const character = new Character('up', exampleTurning);
-    expect(character.direction).toBe('up');
-  });
-
-  it('should turn the character in the correct direction', () => {
-    const character = new Character('up', exampleTurning);
-    const turnedCharacter = character.turn();
-    expect(turnedCharacter.direction).toBe('right');
-  });
-});
-
-describe('Navigator class', () => {
-  let navigator: Navigator<number>;
-
-  beforeEach(() => {
-    navigator = new Navigator(exampleNavigatorParams);
-  });
-
-  it('should initialize with the correct matrix and current position', () => {
-    expect(navigator['_matrix']).toEqual(exampleMatrix);
-    expect(navigator['_cur']).toEqual(exampleInit.cur);
-  });
-
-  it('should move the character correctly', () => {
-    navigator.move('right');
-    expect(navigator['_cur']).toEqual([0, 1]);
-    expect(navigator['_matrix'][0][1]).toBe(exampleInit.VISITED);
-  });
-
-  it('should turn the character correctly', () => {
-    expect(navigator['_character'].direction).toBe('right');
-  });
-
-  it('should check for valid moves correctly', () => {
-    expect(navigator.check('up')).toBe(false); // Blocked by wall
-    expect(navigator.check('right')).toBe(true); // Open path
-    expect(navigator.check('down')).toBe(true); // Blocked by wall
-    expect(navigator.check('left')).toBe(false); // Open path
-  });
-});
-
-describe('Navigator', () => {
-  it('should correctly navigate the grid', () => {
-    // Define a sample grid and initial parameters
-    const matrix: number[][] = [
-      [0, 0, 1],
-      [0, 1, 0],
-      [0, 0, 0]
-    ];
-
-    const turning: Turning = {
-      up: 'right',
-      right: 'down',
-      down: 'left',
-      left: 'up'
-    };
-
-    const init: NavigatorParams<number>['init'] = {
-      cur: [0, 0], // Initial position
-      charDir: 'right', // Initial character direction
-      VISITED: 2 // Value to mark visited cells
-    };
-
-    // Initialize the navigator
-    const navigator = new Navigator({
-      matrix,
-      turning,
-      init,
-      onMove: cur => cur
-    });
-
-    // Define a function to track visited cells
-    const visitedCells: number[][] = [];
-    const onMove = (cur: number[]) => {
-      visitedCells.push([...cur]);
-    };
-
-    // Attach the onMove function
-    navigator.onMove = onMove;
-
-    // Start the navigation
-    navigator.start();
-
-    // The character should have navigated the grid correctly
-    expect(visitedCells).toEqual([
-      [0, 1],
-      [0, 2],
-      [1, 2],
-      [2, 2],
-      [2, 1],
-      [2, 0],
-      [1, 0],
-      [1, 1]
-    ]);
-  });
-
-  it('should not move if there are no valid moves', () => {
-    // Define a sample grid with no valid moves
-    const matrix: number[][] = [
-      [1, 1],
-      [1, 1]
-    ];
-
-    const turning: Turning = {
-      up: 'right',
-      right: 'down',
-      down: 'left',
-      left: 'up'
-    };
-
-    const init: NavigatorParams<number>['init'] = {
-      cur: [0, 0], // Initial position
-      charDir: 'right', // Initial character direction
-      VISITED: 2 // Value to mark visited cells
-    };
-
-    // Initialize the navigator
-    const navigator = new Navigator({
-      matrix,
-      turning,
-      init,
-      onMove: cur => cur
-    });
-
-    // Define a function to track visited cells
-    const visitedCells: number[][] = [];
-    const onMove = (cur: number[]) => {
-      visitedCells.push([...cur]);
-    };
-
-    // Attach the onMove function
-    navigator.onMove = onMove;
-
-    // Start the navigation
-    navigator.start();
-
-    // The character should not move
-    if (isDebug) console.log(visitedCells);
-    expect(visitedCells).toEqual([
-      [0, 1],
-      [1, 1],
-      [1, 0]
-    ]);
-  });
-
-  it('should handle edge cases and turns correctly', () => {
-    // Define a sample grid with turns and edge cases
-    const matrix: number[][] = [
-      [1, 0, 0, 0],
-      [1, 0, 1, 0],
-      [0, 0, 1, 1]
-    ];
-
-    const turning: Turning = {
-      up: 'right',
-      right: 'down',
-      down: 'left',
-      left: 'up'
-    };
-
-    const init: NavigatorParams<number>['init'] = {
-      cur: [0, 0], // Initial position
-      charDir: 'right', // Initial character direction
-      VISITED: 2 // Value to mark visited cells
-    };
-
-    // Initialize the navigator
-    const navigator = new Navigator({
-      matrix,
-      turning,
-      init,
-      onMove: cur => cur
-    });
-
-    // Define a function to track visited cells
-    const visitedCells: number[][] = [];
-    const onMove = (cur: number[]) => {
-      visitedCells.push([...cur]);
-    };
-
-    // Attach the onMove function
-    navigator.onMove = onMove;
-
-    // Start the navigation
-    navigator.start();
-
-    // The character should have navigated the grid, handled turns, and edge cases
-    if (isDebug) console.log(visitedCells);
-    expect(visitedCells).toEqual([
-      [0, 1],
-      [0, 2],
-      [0, 3],
-      [1, 3],
-      [2, 3],
-      [2, 2],
-      [2, 1],
-      [2, 0],
-      [1, 0],
-      [1, 1],
-      [1, 2]
-    ]);
-  });
-});

package/test/unit/data-structures/priority-queue/max-priority-queue.more-branches.coverage.test.ts

@@ -1,10 +0,0 @@
-import { MaxPriorityQueue } from '../../../../src';
-
-describe('MaxPriorityQueue remaining branch coverage', () => {
-  it('default comparator throws when comparing object elements', () => {
-    const pq = new MaxPriorityQueue<any>();
-    // call comparator directly to deterministically hit the throw branch
-    const cmp = (pq as any).comparator as (a: any, b: any) => number;
-    expect(() => cmp({ a: 1 }, { b: 2 })).toThrow(TypeError);
-  });
-});

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

@@ -1,160 +0,0 @@
-import { MaxPriorityQueue } from '../../../../src';
-
-describe('MaxPriorityQueue Operation Test', () => {
-  it('should add elements and maintain heap property', () => {
-    const priorityQueue = new MaxPriorityQueue<number>();
-
-    priorityQueue.add(5);
-    priorityQueue.add(3);
-    priorityQueue.add(7);
-    priorityQueue.add(1);
-
-    expect(priorityQueue.poll()).toBe(7);
-    expect(priorityQueue.poll()).toBe(5);
-    expect(priorityQueue.poll()).toBe(3);
-    expect(priorityQueue.poll()).toBe(1);
-  });
-
-  it('should add elements and maintain heap property in a object MaxPriorityQueue', () => {
-    const priorityQueue = new MaxPriorityQueue<{
-      keyA: number;
-    }>([], {
-      comparator: (a, b) => b.keyA - a.keyA
-    });
-    priorityQueue.refill([{ keyA: 5 }, { keyA: 3 }, { keyA: 1 }]);
-    priorityQueue.add({ keyA: 7 });
-
-    expect(priorityQueue.poll()?.keyA).toBe(7);
-    expect(priorityQueue.poll()?.keyA).toBe(5);
-    expect(priorityQueue.poll()?.keyA).toBe(3);
-    expect(priorityQueue.poll()?.keyA).toBe(1);
-  });
-
-  it('should return and delete the smallest element', () => {
-    const priorityQueue = new MaxPriorityQueue<number>();
-    priorityQueue.add(5);
-    priorityQueue.add(3);
-    priorityQueue.add(7);
-
-    expect(priorityQueue.poll()).toBe(7);
-    expect(priorityQueue.poll()).toBe(5);
-    expect(priorityQueue.size).toBe(1);
-  });
-
-  it('should create a clone of the priority queue', () => {
-    const priorityQueue = new MaxPriorityQueue<number>();
-    priorityQueue.add(5);
-    priorityQueue.add(3);
-    priorityQueue.add(7);
-
-    const clone = priorityQueue.clone();
-    expect(clone.poll()).toBe(7);
-    expect(clone.poll()).toBe(5);
-    expect(clone.poll()).toBe(3);
-    expect(clone.isEmpty()).toBe(true);
-  });
-
-  it('should correctly heapify an array', () => {
-    const array = [5, 3, 7, 1];
-    const heap = MaxPriorityQueue.heapify<number>(array, {
-      comparator: (a, b) => b - a
-    });
-    heap.refill(array);
-
-    expect(heap.poll()).toBe(7);
-    expect(heap.poll()).toBe(5);
-    expect(heap.poll()).toBe(3);
-    expect(heap.poll()).toBe(1);
-  });
-
-  it('should correctly heapify an object array', () => {
-    const elements = [{ keyA: 5 }, { keyA: 3 }, { keyA: 7 }, { keyA: 1 }];
-    debugger;
-    const maxPQ = MaxPriorityQueue.heapify<{
-      keyA: number;
-    }>(elements, {
-      comparator: (a, b) => b.keyA - a.keyA
-    });
-
-    expect(maxPQ.poll()?.keyA).toBe(7);
-    expect(maxPQ.poll()?.keyA).toBe(5);
-    expect(maxPQ.poll()?.keyA).toBe(3);
-    expect(maxPQ.poll()?.keyA).toBe(1);
-  });
-
-  it('should object priority queue', () => {
-    const maxPQ = new MaxPriorityQueue<{
-      rawItem: { id: number };
-    }>(
-      [
-        { rawItem: { id: 4 } },
-        { rawItem: { id: 8 } },
-        { rawItem: { id: 6 } },
-        { rawItem: { id: 7 } },
-        { rawItem: { id: 1 } },
-        { rawItem: { id: 3 } },
-        { rawItem: { id: 5 } }
-      ],
-      {
-        comparator: (a, b) => b.rawItem.id - a.rawItem.id
-      }
-    );
-
-    expect([...maxPQ.sort()]).toEqual([
-      { rawItem: { id: 8 } },
-      { rawItem: { id: 7 } },
-      { rawItem: { id: 6 } },
-      { rawItem: { id: 5 } },
-      { rawItem: { id: 4 } },
-      { rawItem: { id: 3 } },
-      { rawItem: { id: 1 } }
-    ]);
-  });
-
-  it('should toElementFn', () => {
-    const maxPQ = new MaxPriorityQueue<number, { rawItem: { id: number } }>(
-      [
-        { rawItem: { id: 4 } },
-        { rawItem: { id: 8 } },
-        { rawItem: { id: 6 } },
-        { rawItem: { id: 7 } },
-        { rawItem: { id: 1 } },
-        { rawItem: { id: 3 } },
-        { rawItem: { id: 5 } }
-      ],
-      {
-        toElementFn: rawElement => rawElement.rawItem.id
-      }
-    );
-
-    expect([...maxPQ.sort()]).toEqual([8, 7, 6, 5, 4, 3, 1]);
-  });
-
-  it('should MaxPriorityQueue filter, map work well', function () {
-    const minPQ2 = new MaxPriorityQueue<number>([]);
-    minPQ2.refill([2, 5, 8, 1, 6, 7, 4]);
-
-    const cloned = minPQ2.clone();
-    const filtered = cloned.filter(item => item % 2 === 1);
-    expect(filtered instanceof MaxPriorityQueue).toBe(true);
-    expect([...filtered]).toEqual([7, 1, 5]);
-
-    const mapped = filtered.map(item => ({ key: item }), { comparator: (a, b) => b.key - a.key });
-    expect(mapped instanceof MaxPriorityQueue).toBe(true);
-    expect([...mapped]).toEqual([{ key: 7 }, { key: 1 }, { key: 5 }]);
-  });
-
-  // it('should MaxPriorityQueue throw an error while initialed with object data', function () {
-  //   expect(() => {
-  //     new MaxPriorityQueue<{ key: number }>([{ key: 7 }, { key: 1 }, { key: 7 }]);
-  //   }).toThrow(
-  //     "When comparing object types, a custom comparator must be defined in the constructor's options parameter."
-  //   );
-  // });
-
-  it('should MaxPriorityQueue comparator return 0 when equal values are added', function () {
-    const duplicated = new MaxPriorityQueue<number>([7, 1, 7, 7]);
-    expect(duplicated.size).toBe(4);
-    expect([...duplicated]).toEqual([7, 7, 7, 1]);
-  });
-});

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

@@ -1,78 +0,0 @@
-import { MinPriorityQueue } from '../../../../src';
-
-describe('MinPriorityQueue Operation Test', () => {
-  it('should check if a node exists in the queue', () => {
-    const priorityQueue = new MinPriorityQueue<number>();
-    priorityQueue.add(5);
-
-    expect(priorityQueue.has(5)).toBe(true);
-    expect(priorityQueue.has(3)).toBe(false);
-  });
-
-  it('should return the smallest element without removing it', () => {
-    const priorityQueue = new MinPriorityQueue<number>();
-    priorityQueue.add(5);
-    priorityQueue.add(3);
-    priorityQueue.add(7);
-
-    expect(priorityQueue.peek()).toBe(3);
-    expect(priorityQueue.size).toBe(3);
-  });
-
-  it('should return the last element', () => {
-    const priorityQueue = new MinPriorityQueue<number>();
-    priorityQueue.add(5);
-    priorityQueue.add(3);
-    priorityQueue.add(7);
-
-    expect(priorityQueue.leaf).toBe(7);
-  });
-
-  it('should check if the queue is empty', () => {
-    const priorityQueue = new MinPriorityQueue<number>();
-
-    expect(priorityQueue.isEmpty()).toBe(true);
-
-    priorityQueue.add(5);
-
-    expect(priorityQueue.isEmpty()).toBe(false);
-  });
-
-  it('should clear the queue', () => {
-    const priorityQueue = new MinPriorityQueue<number>();
-    priorityQueue.add(5);
-    priorityQueue.add(3);
-    priorityQueue.add(7);
-
-    priorityQueue.clear();
-
-    expect(priorityQueue.size).toBe(0);
-    expect(priorityQueue.isEmpty()).toBe(true);
-  });
-
-  it('should sort the elements', () => {
-    const priorityQueue = new MinPriorityQueue<number>();
-    priorityQueue.add(5);
-    priorityQueue.add(3);
-    priorityQueue.add(7);
-    priorityQueue.add(1);
-
-    const sortedArray = priorityQueue.sort();
-    expect(sortedArray).toEqual([1, 3, 5, 7]);
-  });
-
-  it('should MinPriorityQueue filter, map work well', function () {
-    const minPQ2 = new MinPriorityQueue<number>([]);
-    minPQ2.refill([2, 5, 8, 1, 6, 7, 4]);
-
-    const cloned = minPQ2.clone();
-    const filtered = cloned.filter(item => item % 2 === 1);
-    expect(filtered instanceof MinPriorityQueue).toBe(true);
-    expect([...filtered]).toEqual([1, 5, 7]);
-
-    const mapped = filtered.map(item => ({ key: item }), { comparator: (a, b) => a.key - b.key });
-    expect(mapped instanceof MinPriorityQueue).toBe(true);
-    expect([...mapped]).toEqual([{ key: 1 }, { key: 5 }, { key: 7 }]);
-    expect(mapped.toVisual()).toEqual([{ key: 1 }, { key: 5 }, { key: 7 }]);
-  });
-});

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

@@ -1,21 +0,0 @@
-import { PriorityQueue } from '../../../../src';
-
-/**
- * Coverage-focused test for PriorityQueue thin wrapper.
- * Keep existing @example tests intact.
- */
-describe('PriorityQueue coverage', () => {
-  it('constructs and supports basic add/poll via Heap API', () => {
-    const pq = new PriorityQueue<number>();
-    pq.add(3);
-    pq.add(1);
-    pq.add(2);
-
-    // Default PriorityQueue here behaves as a min-heap.
-    expect(pq.peek()).toBe(1);
-    expect(pq.poll()).toBe(1);
-    expect(pq.poll()).toBe(2);
-    expect(pq.poll()).toBe(3);
-    expect(pq.poll()).toBe(undefined);
-  });
-});

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

@@ -1,101 +0,0 @@
-import { PriorityQueue } from '../../../../src';
-import { PriorityQueue as CPriorityQueue } from 'js-sdsl';
-import { isDebugTest } from '../../../config';
-
-const isDebug = isDebugTest;
-describe('PriorityQueue Operation Test', () => {
-  it('should PriorityQueue poll, pee, heapify, toArray work well', function () {
-    const minPQ = new PriorityQueue<number>([], {
-      comparator: (a, b) => a - b
-    });
-    minPQ.refill([5, 2, 3, 4, 6, 1]);
-    expect(minPQ.toArray()).toEqual([1, 2, 3, 4, 6, 5]);
-    minPQ.poll();
-    minPQ.poll();
-    minPQ.poll();
-    expect(minPQ.toArray()).toEqual([4, 5, 6]);
-    expect(minPQ.peek()).toBe(4);
-    expect(
-      PriorityQueue.heapify([3, 2, 1, 5, 6, 7, 8, 9, 10], {
-        comparator: (a, b) => a - b
-      }).toArray()
-    ).toEqual([1, 3, 2, 5, 6, 7, 8, 9, 10]);
-  });
-
-  it('should Max PriorityQueue poll, peek, heapify, toArray work well', function () {
-    const maxPriorityQueue = new PriorityQueue<number>([], {
-      comparator: (a, b) => b - a
-    });
-    maxPriorityQueue.refill([5, 2, 3, 4, 6, 1]);
-    expect(maxPriorityQueue.toArray()).toEqual([6, 5, 3, 4, 2, 1]);
-    maxPriorityQueue.poll();
-    maxPriorityQueue.poll();
-    maxPriorityQueue.poll();
-    expect(maxPriorityQueue.toArray()).toEqual([3, 2, 1]);
-    expect(maxPriorityQueue.peek()).toBe(3);
-    expect(
-      PriorityQueue.heapify([3, 2, 1, 5, 6, 7, 8, 9, 10], {
-        comparator: (a, b) => a - b
-      }).toArray()
-    ).toEqual([1, 3, 2, 5, 6, 7, 8, 9, 10]);
-  });
-
-  it('should PriorityQueue clone, sort, getNodes, dfs work well', function () {
-    const minPQ1 = new PriorityQueue<number>([], {
-      comparator: (a, b) => a - b
-    });
-    minPQ1.refill([2, 5, 8, 3, 1, 6, 7, 4]);
-    const clonedPriorityQueue = minPQ1.clone();
-    expect(clonedPriorityQueue.elements).toEqual(minPQ1.elements);
-    expect(clonedPriorityQueue.sort()).toEqual([1, 2, 3, 4, 5, 6, 7, 8]);
-    expect(minPQ1.dfs('IN')).toEqual([4, 3, 2, 5, 1, 8, 6, 7]);
-    expect(minPQ1.dfs('POST')).toEqual([4, 3, 5, 2, 8, 7, 6, 1]);
-    expect(minPQ1.dfs('PRE')).toEqual([1, 2, 3, 4, 5, 6, 8, 7]);
-  });
-
-  it('should PriorityQueue filter, map work well', function () {
-    const minPQ2 = new PriorityQueue<number>([], {
-      comparator: (a, b) => a - b
-    });
-    minPQ2.refill([2, 5, 8, 3, 1, 6, 7, 4]);
-    const filtered = minPQ2.filter(item => item % 2 === 1);
-    expect(filtered instanceof PriorityQueue).toBe(true);
-    expect([...filtered]).toEqual([1, 3, 5, 7]);
-
-    const mapped = filtered.map(item => ({ key: item }), { comparator: (a, b) => a.key - b.key });
-    expect(mapped instanceof PriorityQueue).toBe(true);
-    expect([...mapped]).toEqual([{ key: 1 }, { key: 3 }, { key: 5 }, { key: 7 }]);
-  });
-});
-
-describe('Priority Queue Performance Test', () => {
-  it('should numeric heap work well', function () {
-    const pq = new PriorityQueue<number>([], {
-      comparator: (a, b) => b - a
-    });
-
-    const tS = performance.now();
-
-    for (let i = 0; i < 100000; i++) {
-      pq.add(i);
-    }
-
-    // for (let i = 0; i < 10000; i++) {
-    //   pq.pop();
-    // }
-    if (isDebug) console.log(performance.now() - tS);
-    if (isDebug) console.log(pq.size);
-    const cS = performance.now();
-    const cpq = new CPriorityQueue();
-
-    for (let i = 0; i < 100000; i++) {
-      cpq.push(i);
-    }
-    //
-    // for (let i = 0; i < 10000; i++) {
-    //   cpq.pop();
-    // }
-    if (isDebug) console.log(performance.now() - cS);
-    if (isDebug) console.log(cpq.size());
-  });
-});