data-structure-typed 2.4.0 → 2.4.2

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

@@ -1,112 +0,0 @@
-import { Stack } from '../../../../src';
-
-describe('Stack coverage', () => {
-  it('fromArray + basic ops cover isEmpty/peek/pop on empty', () => {
-    // constructor default params branch
-    const empty = new Stack<number>();
-    expect(empty.size).toBe(0);
-
-    const s = Stack.fromArray([1, 2, 3]);
-    expect([...s]).toEqual([1, 2, 3]);
-
-    expect(s.peek()).toBe(3);
-    expect(s.pop()).toBe(3);
-    expect(s.pop()).toBe(2);
-    expect(s.pop()).toBe(1);
-
-    expect(s.isEmpty()).toBe(true);
-    expect(s.peek()).toBeUndefined();
-    expect(s.pop()).toBeUndefined();
-  });
-
-  it('pushMany uses toElementFn conversion branch', () => {
-    const s = new Stack<number, { v: number }>([], { toElementFn: r => r.v });
-    const res = s.pushMany([{ v: 1 }, { v: 2 }]);
-    expect(res).toEqual([true, true]);
-    expect([...s]).toEqual([1, 2]);
-  });
-
-  it('delete/deleteAt cover not-found and bounds', () => {
-    const s = new Stack<number>([1, 2, 3, 2]);
-
-    // not found => _indexOfByEquals returns -1 => deleteAt(-1) false
-    expect(s.delete(999)).toBe(false);
-
-    // bounds
-    expect(s.deleteAt(-1)).toBe(false);
-    expect(s.deleteAt(999)).toBe(false);
-
-    // delete first matching occurrence (bottom-up)
-    expect(s.delete(2)).toBe(true);
-    expect([...s]).toEqual([1, 3, 2]);
-
-    // deleteAt valid
-    expect(s.deleteAt(1)).toBe(true);
-    expect([...s]).toEqual([1, 2]);
-  });
-
-  it('deleteWhere covers both match and no-match branches', () => {
-    const s = new Stack<number>([1, 2, 3]);
-    expect(s.deleteWhere(v => v === 2)).toBe(true);
-    expect([...s]).toEqual([1, 3]);
-
-    expect(s.deleteWhere(v => v === 999)).toBe(false);
-    expect([...s]).toEqual([1, 3]);
-  });
-
-  it('clear/clone/filter/mapSame/map cover instance factories and thisArg call path', () => {
-    const raw = [{ v: 1 }, { v: 2 }, { v: 3 }];
-    const s = new Stack<number, { v: number }>(raw, { toElementFn: r => r.v });
-
-    const cloned = s.clone();
-    expect([...cloned]).toEqual([1, 2, 3]);
-
-    const filtered = s.filter(v => v % 2 === 1);
-    expect([...filtered]).toEqual([1, 3]);
-
-    const mappedSame = s.mapSame(v => v * 2);
-    expect([...mappedSame]).toEqual([2, 4, 6]);
-
-    // mapSame with thisArg branch
-    const ctx2 = { mul: 3 };
-    const mappedSame2 = s.mapSame(function (v) {
-      // @ts-ignore
-      return v * this.mul;
-    }, ctx2);
-    expect([...mappedSame2]).toEqual([3, 6, 9]);
-
-
-    // map with thisArg branch
-    const ctx = { inc: 10 };
-    const mapped = s.map(function (v) {
-      // @ts-ignore
-      return v + this.inc;
-    }, undefined, ctx);
-    expect([...mapped]).toEqual([11, 12, 13]);
-
-    // map with undefined thisArg branch
-    const mapped2 = s.map(v => v + 1);
-    expect([...mapped2]).toEqual([2, 3, 4]);
-
-    // _createLike default elements branch (protected)
-    const like = (s as any)._createLike();
-    expect(like.size).toBe(0);
-
-    s.clear();
-    expect(s.size).toBe(0);
-  });
-
-  it('setEquality affects delete/search semantics', () => {
-    type Obj = { id: number };
-    const a = { id: 1 };
-    const b = { id: 2 };
-    const s = new Stack<Obj>([a, b]);
-
-    // default Object.is: new object not found
-    expect(s.delete({ id: 1 } as any)).toBe(false);
-
-    s.setEquality((x, y) => x.id === y.id);
-    expect(s.delete({ id: 1 } as any)).toBe(true);
-    expect([...s].map(x => x.id)).toEqual([2]);
-  });
-});

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

@@ -1,438 +0,0 @@
-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 has and get', () => {
-    const stack = new Stack<number, { id: number; name: string }>([], { toElementFn: rawElement => rawElement.id });
-    expect(stack.has(1)).toBe(false);
-    expect(stack.size).toBe(0);
-  });
-
-  it('should peek at the top element without removing it', () => {
-    expect(stack.peek()).toBe(undefined);
-    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 clone', function () {
-    const stack = new Stack<string>();
-    stack.push('1');
-    stack.push('6');
-    stack.push('2');
-    stack.push('0');
-    stack.push('5');
-    stack.push('9');
-    stack.delete('2');
-    expect([...stack]).toEqual(['1', '6', '0', '5', '9']);
-    const cloned = stack.clone();
-    expect([...cloned]).toEqual(['1', '6', '0', '5', '9']);
-    stack.delete('5');
-    expect([...stack]).toEqual(['1', '6', '0', '9']);
-    expect([...cloned]).toEqual(['1', '6', '0', '5', '9']);
-  });
-
-  it('should return undefined when popping from an empty stack', () => {
-    const poppedElement = stack.pop();
-    expect(poppedElement).toBe(undefined);
-  });
-
-  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);
-  });
-});
-
-describe('Stack iterative methods', () => {
-  let stack: Stack<number>; // Declare a Stack instance
-
-  beforeEach(() => {
-    stack = new Stack<number>(); // Create a new Stack instance before each test
-    stack.push(1);
-    stack.push(2);
-    stack.push(3);
-  });
-
-  it('should iterate through the stack', () => {
-    const result: number[] = [];
-    for (const element of stack) {
-      result.push(element);
-    }
-
-    expect(result).toEqual([1, 2, 3]); // iteration should start from the top of the stack
-  });
-
-  it('should apply forEach to the stack', () => {
-    const result: number[] = [];
-    stack.forEach(element => {
-      result.push(element);
-    });
-
-    expect(result).toEqual([1, 2, 3]);
-  });
-
-  it('should filter elements in the stack', () => {
-    const filteredStack = stack.filter(element => element > 1);
-
-    expect(filteredStack.size).toBe(2);
-    expect([...filteredStack]).toEqual([2, 3]);
-  });
-
-  it('should map elements in the stack', () => {
-    const mappedStack = stack.map(element => element * 2);
-
-    expect(mappedStack.size).toBe(3);
-    expect([...mappedStack]).toEqual([2, 4, 6]);
-  });
-
-  it('should reduce elements in the stack', () => {
-    const sum = stack.reduce((accumulator, element) => accumulator + element, 0);
-
-    expect(sum).toBe(6);
-  });
-
-  it('should toElementFn', () => {
-    const stack = new Stack([{ key: 1 }, { key: 2 }, { key: 5 }, { key: 3 }], { toElementFn: item => item.key });
-    expect(stack.size).toBe(4);
-    expect([...stack]).toEqual([1, 2, 5, 3]);
-  });
-
-  it('should fromArray', () => {
-    const stack = Stack.fromArray([1, 2, 5, 3]);
-    expect(stack instanceof Stack).toBe(true);
-    expect(stack.size).toBe(4);
-    expect([...stack]).toEqual([1, 2, 5, 3]);
-  });
-
-  it('should iterable-element-base toElementFn', () => {
-    const stack = new Stack<{ key: number }>([1, 2, 5, 3], { toElementFn: key => ({ key }) });
-    expect([...stack]).toEqual([{ key: 1 }, { key: 2 }, { key: 5 }, { key: 3 }]);
-    expect(() => {
-      new Stack<{ key: number }>([1, 2, 5, 3], {
-        // @ts-ignore
-        toElementFn: {}
-      });
-    }).toThrow('toElementFn must be a function type');
-  });
-});
-
-describe('classic uses', () => {
-  it('@example basic Stack creation and push operation', () => {
-    // Create a simple Stack with initial values
-    const stack = new Stack([1, 2, 3, 4, 5]);
-
-    // Verify the stack maintains insertion order (LIFO will be shown in pop)
-    expect([...stack]).toEqual([1, 2, 3, 4, 5]);
-
-    // Check length
-    expect(stack.size).toBe(5);
-
-    // Push a new element to the top
-    stack.push(6);
-    expect(stack.size).toBe(6);
-  });
-
-  it('@example Stack pop operation (LIFO - Last In First Out)', () => {
-    const stack = new Stack<number>([10, 20, 30, 40, 50]);
-
-    // Peek at the top element without removing
-    const top = stack.peek();
-    expect(top).toBe(50);
-
-    // Pop removes from the top (LIFO order)
-    const popped = stack.pop();
-    expect(popped).toBe(50);
-
-    // Next pop gets the previous element
-    const next = stack.pop();
-    expect(next).toBe(40);
-
-    // Verify length decreased
-    expect(stack.size).toBe(3);
-  });
-
-  it('@example Function Call Stack', () => {
-    const functionStack = new Stack<string>();
-    functionStack.push('main');
-    functionStack.push('foo');
-    functionStack.push('bar');
-    expect(functionStack.pop()).toBe('bar');
-    expect(functionStack.pop()).toBe('foo');
-    expect(functionStack.pop()).toBe('main');
-  });
-
-  it('@example Balanced Parentheses or Brackets', () => {
-    type ValidCharacters = ')' | '(' | ']' | '[' | '}' | '{';
-
-    const stack = new Stack<string>();
-    const input: ValidCharacters[] = '[({})]'.split('') as ValidCharacters[];
-    const matches: { [key in ValidCharacters]?: ValidCharacters } = { ')': '(', ']': '[', '}': '{' };
-    for (const char of input) {
-      if ('([{'.includes(char)) {
-        stack.push(char);
-      } else if (')]}'.includes(char)) {
-        if (stack.pop() !== matches[char]) {
-          fail('Parentheses are not balanced');
-        }
-      }
-    }
-    expect(stack.isEmpty()).toBe(true);
-  });
-
-  it('@example Expression Evaluation and Conversion', () => {
-    const stack = new Stack<number>();
-    const expression = [5, 3, '+']; // Equivalent to 5 + 3
-    expression.forEach(token => {
-      if (typeof token === 'number') {
-        stack.push(token);
-      } else {
-        const b = stack.pop()!;
-        const a = stack.pop()!;
-        stack.push(token === '+' ? a + b : 0); // Only handling '+' here
-      }
-    });
-    expect(stack.pop()).toBe(8);
-  });
-
-  it('@example Backtracking Algorithms', () => {
-    const stack = new Stack<[number, number]>();
-    const maze = [
-      ['S', ' ', 'X'],
-      ['X', ' ', 'X'],
-      [' ', ' ', 'E']
-    ];
-    const start: [number, number] = [0, 0];
-    const end = [2, 2];
-    const directions = [
-      [0, 1], // To the right
-      [1, 0], // down
-      [0, -1], // left
-      [-1, 0] // up
-    ];
-
-    const visited = new Set<string>(); // Used to record visited nodes
-    stack.push(start);
-    const path: number[][] = [];
-
-    while (!stack.isEmpty()) {
-      const [x, y] = stack.pop()!;
-      if (visited.has(`${x},${y}`)) continue; // Skip already visited nodes
-      visited.add(`${x},${y}`);
-
-      path.push([x, y]);
-
-      if (x === end[0] && y === end[1]) {
-        break; // Find the end point and exit
-      }
-
-      for (const [dx, dy] of directions) {
-        const nx = x + dx;
-        const ny = y + dy;
-        if (
-          maze[nx]?.[ny] === ' ' || // feasible path
-          maze[nx]?.[ny] === 'E' // destination
-        ) {
-          stack.push([nx, ny]);
-        }
-      }
-    }
-
-    expect(path).toContainEqual(end);
-  });
-
-  it('@example Stock Span Problem', () => {
-    const stack = new Stack<number>();
-    const prices = [100, 80, 60, 70, 60, 75, 85];
-    const spans: number[] = [];
-    prices.forEach((price, i) => {
-      while (!stack.isEmpty() && prices[stack.peek()!] <= price) {
-        stack.pop();
-      }
-      spans.push(stack.isEmpty() ? i + 1 : i - stack.peek()!);
-      stack.push(i);
-    });
-    expect(spans).toEqual([1, 1, 1, 2, 1, 4, 6]);
-  });
-
-  it('@example Simplify File Paths', () => {
-    const stack = new Stack<string>();
-    const path = '/a/./b/../../c';
-    path.split('/').forEach(segment => {
-      if (segment === '..') stack.pop();
-      else if (segment && segment !== '.') stack.push(segment);
-    });
-    expect(stack.elements.join('/')).toBe('c');
-  });
-
-  it('Stack for function call stack simulation', () => {
-    interface CallFrame {
-      functionName: string;
-      lineNumber: number;
-      variables: Record<string, unknown>;
-      timestamp: number;
-    }
-
-    // Simulate a call stack for debugging/tracing
-    const callStack = new Stack<CallFrame>();
-
-    // Simulate function calls pushing frames onto stack
-    callStack.push({
-      functionName: 'main',
-      lineNumber: 1,
-      variables: { x: 10, y: 20 },
-      timestamp: 1000
-    });
-
-    callStack.push({
-      functionName: 'calculateSum',
-      lineNumber: 5,
-      variables: { a: 10, b: 20 },
-      timestamp: 1100
-    });
-
-    callStack.push({
-      functionName: 'helper',
-      lineNumber: 12,
-      variables: { result: 30 },
-      timestamp: 1200
-    });
-
-    // Verify current call frame
-    expect(callStack.size).toBe(3);
-    const currentFrame = callStack.peek();
-    expect(currentFrame?.functionName).toBe('helper');
-    expect(currentFrame?.lineNumber).toBe(12);
-
-    // Simulate function returns popping from stack (LIFO)
-    const returnedFrame = callStack.pop();
-    expect(returnedFrame?.functionName).toBe('helper');
-    expect(callStack.size).toBe(2);
-
-    // Next return
-    const nextReturn = callStack.pop();
-    expect(nextReturn?.functionName).toBe('calculateSum');
-
-    // Back to main
-    const mainFrame = callStack.pop();
-    expect(mainFrame?.functionName).toBe('main');
-
-    // Stack empty after all returns
-    expect(callStack.size).toBe(0);
-  });
-
-  it('Stack for...of iteration and isEmpty', () => {
-    const stack = new Stack<string>(['A', 'B', 'C', 'D']);
-
-    // Iterate through stack
-    const elements: string[] = [];
-    for (const item of stack) {
-      elements.push(item);
-    }
-    expect(elements).toEqual(['A', 'B', 'C', 'D']);
-
-    // Clear the stack
-    while (stack.size > 0) {
-      stack.pop();
-    }
-
-    // Stack is now empty
-    expect(stack.size).toBe(0);
-  });
-
-  it('Depth-First Search (DFS)', () => {
-    const stack = new Stack<number>();
-    const graph: { [key in number]: number[] } = { 1: [2, 3], 2: [4], 3: [5], 4: [], 5: [] };
-    const visited: number[] = [];
-    stack.push(1);
-    while (!stack.isEmpty()) {
-      const node = stack.pop()!;
-      if (!visited.includes(node)) {
-        visited.push(node);
-        graph[node].forEach(neighbor => stack.push(neighbor));
-      }
-    }
-    expect(visited).toEqual([1, 3, 5, 2, 4]); // Example DFS order
-  });
-
-  it('Browser Navigation', () => {
-    const backStack = new Stack<string>();
-    const forwardStack = new Stack<string>();
-    backStack.push('Page 1');
-    backStack.push('Page 2');
-    forwardStack.push(backStack.pop()!);
-    expect(backStack.size).toBe(1);
-    expect(forwardStack.size).toBe(1);
-  });
-
-  it('String Reversal', () => {
-    const stack = new Stack<string>();
-    const input = 'hello';
-    const reversed = [];
-    input.split('').forEach(char => stack.push(char));
-    while (!stack.isEmpty()) {
-      reversed.push(stack.pop());
-    }
-    expect(reversed.join('')).toBe('olleh');
-  });
-
-  it('Next Greater Element', () => {
-    const stack = new Stack<number>();
-    const array = [4, 5, 2, 25];
-    const nextGreater = new Array(array.length).fill(-1);
-    array.forEach((_, i) => {
-      while (!stack.isEmpty() && array[stack.peek()!] < array[i]) {
-        const idx = stack.pop()!;
-        nextGreater[idx] = array[i];
-      }
-      stack.push(i);
-    });
-    expect(nextGreater).toEqual([5, 25, 25, -1]);
-  });
-});

package/test/unit/data-structures/tree/tree.more-branches.coverage.test.ts

@@ -1,9 +0,0 @@
-import { TreeNode } from '../../../../src';
-
-describe('TreeNode remaining branch coverage', () => {
-  it('constructor assigns children when provided (covers if(children) branch)', () => {
-    const child = new TreeNode('c');
-    const root = new TreeNode('r', undefined, [child]);
-    expect(root.children).toEqual([child]);
-  });
-});

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

@@ -1,58 +0,0 @@
-import { TreeNode } from '../../../../src';
-
-describe('TreeNode', () => {
-  it('should create a tree node with key and value', () => {
-    const node = new TreeNode<string>('root', 'RootValue');
-    expect(node.key).toBe('root');
-    expect(node.value).toBe('RootValue');
-    expect(node.children).toEqual(undefined);
-  });
-
-  it('should allow setting and getting key and value', () => {
-    const node = new TreeNode<string>('node1', 'Value1');
-    node.key = 'newKey';
-    node.value = 'newValue';
-    expect(node.key).toBe('newKey');
-    expect(node.value).toBe('newValue');
-  });
-
-  it('should add a single child node', () => {
-    const parent = new TreeNode<string>('parent');
-    const child = new TreeNode<string>('child', 'ChildValue');
-
-    parent.addChildren(child);
-
-    expect(parent.children).toHaveLength(1);
-    expect(parent.children?.[0].key).toBe('child');
-    expect(parent.children?.[0].value).toBe('ChildValue');
-  });
-
-  it('should add multiple children nodes', () => {
-    const parent = new TreeNode<string>('parent');
-    const child1 = new TreeNode<string>('child1');
-    const child2 = new TreeNode<string>('child2');
-
-    parent.addChildren([child1, child2]);
-
-    expect(parent.children).toHaveLength(2);
-    expect(parent.children?.[0].key).toBe('child1');
-    expect(parent.children?.[1].key).toBe('child2');
-    parent.children = [];
-
-    expect(parent.children[0]).toBe(undefined);
-    expect(parent.children[1]).toBe(undefined);
-  });
-
-  it('should calculate the correct height of the tree', () => {
-    const root = new TreeNode<string>('root');
-    const child1 = new TreeNode<string>('child1');
-    const child2 = new TreeNode<string>('child2');
-    const grandChild = new TreeNode<string>('grandChild');
-
-    root.addChildren(child1);
-    root.addChildren(child2);
-    child1.addChildren(grandChild);
-
-    expect(root.getHeight()).toBe(2); // root -> child1 -> grandChild (height = 2)
-  });
-});

package/test/unit/data-structures/trie/trie.more-branches-2.coverage.test.ts

@@ -1,51 +0,0 @@
-import { Trie } from '../../../../src';
-
-describe('Trie additional branch coverage (batch 2)', () => {
-  it('getWords() default prefix arg and isAllWhenEmptyPrefix behavior', () => {
-    const t = new Trie();
-    t.add('a');
-    t.add('ab');
-
-    // prefix default arg (empty) should not collect unless isAllWhenEmptyPrefix=true
-    expect(t.getWords()).toEqual([]);
-    expect(t.getWords('', 10, true).sort()).toEqual(['a', 'ab']);
-  });
-
-  it('map() covers thisArg branch and non-string return TypeError branch', () => {
-    const t = new Trie();
-    t.add('a');
-
-    const ctx = { suf: 'x' };
-    const mapped = t.map(function (this: any, w: string) {
-      return w + this.suf;
-    }, undefined as any, ctx);
-    expect((mapped as any).has('ax')).toBe(true);
-
-    expect(() =>
-      t.map(() => 123 as any)
-    ).toThrow(/must return string/i);
-  });
-
-  it('mapSame covers both ternary arms and _spawnLike/_createLike default-arg branches', () => {
-    const t = new Trie();
-    t.add('a');
-
-    // thisArg === undefined arm
-    const t2 = t.mapSame(w => w + 'b');
-    expect(t2.has('ab')).toBe(true);
-
-    // thisArg provided arm
-    const ctx = { p: 'z' };
-    const t3 = t.mapSame(function (this: any, w: string) {
-      return this.p + w;
-    }, ctx);
-    expect(t3.has('za')).toBe(true);
-
-    // protected helpers default args
-    const like = (t as any)._createLike();
-    expect(like.size).toBe(0);
-
-    const spawned = (t as any)._spawnLike();
-    expect(spawned.size).toBe(0);
-  });
-});