data-structure-typed 2.4.0 → 2.4.2

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

@@ -1,414 +0,0 @@
-import { LinearBase, LinearLinkedBase, LinkedListNode } from '../../../../src/data-structures/base/linear-base';
-import {
-  ElementCallback,
-  IterableElementBaseOptions
-} from '../../../../src';
-
-class ArrayLinear extends LinearBase<number, any> {
-  private _arr: number[] = [];
-
-  get length(): number {
-    return this._arr.length;
-  }
-
-  override clone(): this {
-    const out = this._createInstance();
-    for (const v of this._arr) out.push(v);
-    return out;
-  }
-
-  reverse(): this {
-    this._arr.reverse();
-    return this;
-  }
-
-  push(elementOrNode: number | LinkedListNode<number>): boolean {
-    const v = elementOrNode instanceof LinkedListNode ? elementOrNode.value : elementOrNode;
-    this._arr.push(v);
-    return true;
-  }
-
-  pushMany(elements: Iterable<number> | Iterable<any> | Iterable<LinkedListNode<number>>): boolean[] {
-    const ans: boolean[] = [];
-    for (const el of elements as any) ans.push(this.push(el));
-    return ans;
-  }
-
-  delete(elementOrNode: number | LinkedListNode<number> | undefined): boolean {
-    if (elementOrNode === undefined) return false;
-    const v = elementOrNode instanceof LinkedListNode ? elementOrNode.value : elementOrNode;
-    const i = this._arr.indexOf(v);
-    if (i < 0) return false;
-    this._arr.splice(i, 1);
-    return true;
-  }
-
-  at(index: number): number | undefined {
-    return this._arr[index];
-  }
-
-  deleteAt(pos: number): number | undefined {
-    if (pos < 0 || pos >= this._arr.length) return undefined;
-    return this._arr.splice(pos, 1)[0];
-  }
-
-  addAt(index: number, newElementOrNode: number | LinkedListNode<number>): boolean {
-    const v = newElementOrNode instanceof LinkedListNode ? newElementOrNode.value : newElementOrNode;
-    this._arr.splice(index, 0, v);
-    return true;
-  }
-
-  setAt(index: number, value: number): boolean {
-    if (index < 0 || index >= this._arr.length) return false;
-    this._arr[index] = value;
-    return true;
-  }
-
-  clear(): void {
-    this._arr = [];
-  }
-
-  protected _createInstance(): this {
-    return new (this.constructor as any)();
-  }
-
-  protected *_getIterator(): IterableIterator<number> {
-    yield* this._arr;
-  }
-
-  protected *_getReverseIterator(): IterableIterator<number> {
-    for (let i = this._arr.length - 1; i >= 0; i--) yield this._arr[i];
-  }
-
-  isEmpty(): boolean {
-    return false;
-  }
-
-  filter(_predicate: ElementCallback<number, any, boolean>, _thisArg?: any): this {
-    const out = this._createInstance();
-
-    return out;
-  }
-
-  // @ts-ignore
-  map(_callback: ElementCallback<number, any, number>, options: IterableElementBaseOptions<number, any> | undefined, _thisArg: unknown | undefined): ArrayLinear {
-    const out = this._createLike([], { ...(options ?? {}) });
-    return out;
-  }
-
-  mapSame(_callback: ElementCallback<number, any, number>, _thisArg: unknown | undefined): this {
-    const out = this._createInstance();
-
-    return out;
-  }
-
-  protected _createLike(
-    elements: Iterable<number> | Iterable<any>  = [],
-    options?: IterableElementBaseOptions<number, any>
-  ): ArrayLinear {
-    const Ctor = this.constructor as new (
-      elements?: Iterable<number> | Iterable<any> ,
-      options?: IterableElementBaseOptions<number, any>
-    ) => ArrayLinear;
-    return new Ctor(elements, options);
-  }
-}
-
-class NodeLinear extends LinearLinkedBase<number, any, LinkedListNode<number>> {
-  private _head: LinkedListNode<number> | undefined;
-  private _tail: LinkedListNode<number> | undefined;
-  private _len = 0;
-
-  get length(): number {
-    return this._len;
-  }
-
-  override clone(): this {
-    const out = this._createInstance();
-    for (const v of this) out.push(v);
-    return out;
-  }
-
-  reverse(): this {
-    // simple rebuild
-    const arr = [...this].reverse();
-    this.clear();
-    for (const v of arr) this.push(v);
-    return this;
-  }
-
-  push(elementOrNode: number | LinkedListNode<number>): boolean {
-    const n = elementOrNode instanceof LinkedListNode ? elementOrNode : new LinkedListNode(elementOrNode);
-    n.next = undefined;
-    if (!this._head) {
-      this._head = this._tail = n;
-    } else {
-      (this._tail as any).next = n;
-      this._tail = n;
-    }
-    this._len++;
-    return true;
-  }
-
-  pushMany(elements: Iterable<number> | Iterable<any> | Iterable<LinkedListNode<number>>): boolean[] {
-    const ans: boolean[] = [];
-    for (const el of elements as any) ans.push(this.push(el));
-    return ans;
-  }
-
-  delete(elementOrNode: number | LinkedListNode<number> | undefined): boolean {
-    if (elementOrNode === undefined) return false;
-    const target = elementOrNode instanceof LinkedListNode ? elementOrNode : undefined;
-    const value = elementOrNode instanceof LinkedListNode ? elementOrNode.value : elementOrNode;
-
-    let prev: LinkedListNode<number> | undefined;
-    let cur = this._head;
-    while (cur) {
-      const match = target ? cur === target : cur.value === value;
-      if (match) {
-        if (!prev) {
-          this._head = cur.next;
-          if (this._tail === cur) this._tail = this._head;
-        } else {
-          prev.next = cur.next;
-          if (this._tail === cur) this._tail = prev;
-        }
-        this._len--;
-        return true;
-      }
-      prev = cur;
-      cur = cur.next;
-    }
-    return false;
-  }
-
-  at(index: number): number | undefined {
-    return this.getNodeAt(index)?.value;
-  }
-
-  deleteAt(pos: number): number | undefined {
-    const n = this.getNodeAt(pos);
-    if (!n) return undefined;
-    const v = n.value;
-    this.delete(n);
-    return v;
-  }
-
-  addAt(index: number, newElementOrNode: number | LinkedListNode<number>): boolean {
-    const node = newElementOrNode instanceof LinkedListNode ? newElementOrNode : new LinkedListNode(newElementOrNode);
-    if (index <= 0 || !this._head) {
-      node.next = this._head;
-      this._head = node;
-      if (!this._tail) this._tail = node;
-      this._len++;
-      return true;
-    }
-    const prev = this.getNodeAt(index - 1);
-    if (!prev) return false;
-    node.next = prev.next;
-    prev.next = node;
-    if (this._tail === prev) this._tail = node;
-    this._len++;
-    return true;
-  }
-
-  setAt(index: number, value: number): boolean {
-    const n = this.getNodeAt(index);
-    if (!n) return false;
-    n.value = value;
-    return true;
-  }
-  protected _ensurePredicate(
-    elementNodeOrPredicate: number | LinkedListNode<number> | ((node: LinkedListNode<number>) => boolean)
-  ): (node: LinkedListNode<number>) => boolean {
-    if (elementNodeOrPredicate instanceof LinkedListNode) {
-      const target = elementNodeOrPredicate;
-      return (node: LinkedListNode<number>) => node === target;
-    }
-    if (typeof elementNodeOrPredicate === 'function') {
-      return elementNodeOrPredicate as (node: LinkedListNode<number>) => boolean;
-    }
-    const value = elementNodeOrPredicate as number;
-    return (node: LinkedListNode<number>) => node.value === value;
-  }
-
-  getNode(
-    elementNodeOrPredicate: number | LinkedListNode<number> | ((node: LinkedListNode<number>) => boolean) | undefined
-  ): LinkedListNode<number> | undefined {
-    if (elementNodeOrPredicate === undefined) return;
-
-    if ( elementNodeOrPredicate instanceof LinkedListNode) {
-      const target = elementNodeOrPredicate;
-
-      let cur = this._head;
-      while (cur) {
-        if (cur === target) return target;
-        cur = cur.next;
-      }
-
-      const isMatch = (node: LinkedListNode<number>) => node.value === target.value;
-      cur = this._head;
-      while (cur) {
-        if (isMatch(cur)) return cur;
-        cur = cur.next;
-      }
-      return undefined;
-    }
-
-    const predicate = this._ensurePredicate(elementNodeOrPredicate);
-    let current = this._head;
-    while (current) {
-      if (predicate(current)) return current;
-      current = current.next;
-    }
-    return undefined;
-  }
-
-  addBefore(existing: number | LinkedListNode<number>, neu: number | LinkedListNode<number>): boolean {
-    const node = this.getNode(existing);
-    if (!node) return false;
-    const prev = this._getPrevNode(node);
-    const nn = neu instanceof LinkedListNode ? neu : new LinkedListNode(neu);
-    if (!prev) {
-      nn.next = this._head;
-      this._head = nn;
-      if (!this._tail) this._tail = nn;
-    } else {
-      prev.next = nn;
-      nn.next = node;
-    }
-    this._len++;
-    return true;
-  }
-
-  addAfter(existing: number | LinkedListNode<number>, neu: number | LinkedListNode<number>): boolean {
-    const node = this.getNode(existing);
-    if (!node) return false;
-    const nn = neu instanceof LinkedListNode ? neu : new LinkedListNode(neu);
-    nn.next = node.next;
-    node.next = nn;
-    if (this._tail === node) this._tail = nn;
-    this._len++;
-    return true;
-  }
-
-  getNodeAt(index: number): LinkedListNode<number> | undefined {
-    if (index < 0 || index >= this._len) return undefined;
-    let cur = this._head;
-    let i = 0;
-    while (cur && i < index) {
-      cur = cur.next;
-      i++;
-    }
-    return cur;
-  }
-
-  clear(): void {
-    this._head = this._tail = undefined;
-    this._len = 0;
-  }
-
-  protected _createInstance(): this {
-    return new (this.constructor as any)();
-  }
-
-  protected *_getIterator(): IterableIterator<number> {
-    let cur = this._head;
-    while (cur) {
-      yield cur.value;
-      cur = cur.next;
-    }
-  }
-
-  protected *_getReverseIterator(): IterableIterator<number> {
-    const arr = [...this].reverse();
-    for (const v of arr) yield v;
-  }
-
-  protected *_getNodeIterator(): IterableIterator<LinkedListNode<number>> {
-    let cur = this._head;
-    while (cur) {
-      yield cur;
-      cur = cur.next;
-    }
-  }
-
-  protected _getPrevNode(node: LinkedListNode<number>): LinkedListNode<number> | undefined {
-    if (!this._head || this._head === node) return undefined;
-    let cur = this._head;
-    while (cur.next && cur.next !== node) cur = cur.next;
-    return cur.next === node ? cur : undefined;
-  }
-
-  isEmpty(): boolean {
-    return false;
-  }
-
-
-
-  filter(_predicate: ElementCallback<number, any, boolean>, _thisArg?: any): this {
-    const out = this._createInstance();
-
-    return out;
-  }
-
-  // @ts-ignore
-  map(callback: ElementCallback<number, any, number>, options: IterableElementBaseOptions<number, any> | undefined, _thisArg: unknown | undefined): ArrayLinear {
-    const out = this._createLike([], { ...(options ?? {}) });
-    return out;
-  }
-
-  mapSame(_callback: ElementCallback<number, any, number>, _thisArg: unknown | undefined): this {
-    const out = this._createInstance();
-
-    return out;
-  }
-
-  protected _createLike(
-    elements: Iterable<number> | Iterable<any>  = [],
-    options?: IterableElementBaseOptions<number, any>
-  ): ArrayLinear {
-    const Ctor = this.constructor as new (
-      elements?: Iterable<number> | Iterable<any> ,
-      options?: IterableElementBaseOptions<number, any>
-    ) => ArrayLinear;
-    return new Ctor(elements, options);
-  }
-}
-
-describe('LinearBase additional branch coverage', () => {
-  it('splice() covers default deleteCount and start<0 false arm; reduceRight covers initialValue ?? fallback', () => {
-    const l = new ArrayLinear();
-    l.pushMany([1, 2, 3]);
-
-    // default deleteCount=0 + start>=0 (false arm of start<0 ? ...)
-    const removed = l.splice(1);
-    expect([...removed]).toEqual([]);
-
-    // reduceRight: initialValue undefined => uses 0; and defined path
-    const sum0 = (l as any).reduceRight((acc: number, v: number) => acc + v, undefined);
-    expect(sum0).toBe(6);
-    const sum10 = l.reduceRight((acc, v) => acc + v, 10);
-    expect(sum10).toBe(16);
-  });
-
-  it('slice() covers default args start=0,end=length; concat covers non-LinearBase else arm', () => {
-    const l = new ArrayLinear();
-    l.pushMany([1, 2, 3]);
-
-    expect([...l.slice()]).toEqual([1, 2, 3]);
-
-    const c = l.concat(4 as any);
-    expect([...c]).toEqual([1, 2, 3, 4]);
-  });
-
-  it('LinearLinkedBase slice uses negative start arm; splice uses default deleteCount', () => {
-    const l = new NodeLinear();
-    l.pushMany([1, 2, 3, 4]);
-
-    expect([...l.slice(-2)]).toEqual([3, 4]);
-
-    const removed = l.splice(2);
-    expect([...removed]).toEqual([]);
-  });
-});

package/test/unit/data-structures/binary-tree/avl-tree-node.familyPosition-root-left.coverage.test.ts

@@ -1,17 +0,0 @@
-import { AVLTreeNode } from '../../../../src';
-
-describe('AVLTreeNode familyPosition remaining branch coverage', () => {
-  it('left child with its own child reports ROOT_LEFT', () => {
-    const parent = new AVLTreeNode<number, number>(2);
-    const child = new AVLTreeNode<number, number>(1);
-    const grand = new AVLTreeNode<number, number>(0);
-
-    parent.left = child;
-    child.parent = parent;
-
-    child.left = grand;
-    grand.parent = child;
-
-    expect(child.familyPosition).toBe('ROOT_LEFT');
-  });
-});

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

@@ -1,99 +0,0 @@
-import { AVLTree, AVLTreeNode } from '../../../../src';
-
-describe('AVLTree remaining branch coverage (batch 2)', () => {
-  it('AVLTreeNode.familyPosition covers parent-missing branch and (left||right)? ternary arms', () => {
-    const isolated = new AVLTreeNode<number, number>(1, 1);
-    expect(isolated.familyPosition).toBe('ISOLATED');
-
-    const root = new AVLTreeNode<number, number>(2, 2);
-    root.left = new AVLTreeNode<number, number>(1, 1);
-    expect(root.familyPosition).toBe('ROOT');
-  });
-
-  it('perfectlyBalance returns false on empty tree', () => {
-    const t = new AVLTree<number, number>([], { isMapMode: false });
-    expect(t.perfectlyBalance()).toBe(false);
-  });
-
-  it('_createLike default-arg iter=[] path', () => {
-    const t = new AVLTree<number, number>([], { isMapMode: false });
-    const like = (t as any)._createLike();
-    expect(like.size).toBe(0);
-  });
-
-  it('_swapProperties assigns values when isMapMode=false (covers if(!this._isMapMode) branches)', () => {
-    const t = new AVLTree<number, string>([], { isMapMode: false });
-    t.set(1, 'a');
-    t.set(2, 'b');
-
-    const n1 = t.getNode(1)!;
-    const n2 = t.getNode(2)!;
-
-    (t as any)._swapProperties(n1, n2);
-
-    // Node identities remain; their key/value payloads swap.
-    expect(n1.key).toBe(2);
-    expect(n1.value).toBe('b');
-    expect(n2.key).toBe(1);
-    expect(n2.value).toBe('a');
-  });
-
-  it('_balanceLL executes parentOfA.left===A branch (line ~624)', () => {
-    const t = new AVLTree<number, number>([], { isMapMode: false });
-
-    const P = new AVLTreeNode<number, number>(10, 10);
-    const A = new AVLTreeNode<number, number>(5, 5);
-    const B = new AVLTreeNode<number, number>(2, 2);
-    const Br = new AVLTreeNode<number, number>(3, 3);
-
-    // Build P.left = A, A.left = B, B.right = Br
-    P.left = A;
-    A.parent = P;
-    A.left = B;
-    B.parent = A;
-    B.right = Br;
-    Br.parent = B;
-
-    (t as any)._setRoot(P);
-
-    (t as any)._balanceLL(A);
-
-    // After LL rotation, P.left should now be B
-    expect(P.left?.key).toBe(2);
-    expect((t as any).root.key).toBe(10);
-  });
-
-  it('_balanceLR hits C.left branch and inner parent assignment (lines ~657-658)', () => {
-    const t = new AVLTree<number, number>([], { isMapMode: false });
-
-    const P = new AVLTreeNode<number, number>(10, 10);
-    const A = new AVLTreeNode<number, number>(5, 5);
-    const B = new AVLTreeNode<number, number>(2, 2);
-    const C = new AVLTreeNode<number, number>(3, 3);
-    const CL = new AVLTreeNode<number, number>(2.5 as any, 25);
-    const CR = new AVLTreeNode<number, number>(4 as any, 40);
-
-    // P.left = A, A.left = B, B.right = C, and C has both children
-    P.left = A;
-    A.parent = P;
-    A.left = B;
-    B.parent = A;
-    B.right = C;
-    C.parent = B;
-    C.left = CL;
-    CL.parent = C;
-    C.right = CR;
-    CR.parent = C;
-
-    (t as any)._setRoot(P);
-
-    (t as any)._balanceLR(A);
-
-    // inner branch should have set CL.parent = B
-    expect(CL.parent).toBe(B);
-    // and CR.parent = A
-    expect(CR.parent).toBe(A);
-    // P.left should now be C
-    expect(P.left?.key).toBe(3);
-  });
-});