data-structure-typed 2.2.8 → 2.3.0

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

@@ -0,0 +1,417 @@
+import { LinearBase, LinearLinkedBase, LinkedListNode,  } from '../../../../src/data-structures/base/linear-base';
+import {
+  DoublyLinkedListNode,
+  DoublyLinkedListOptions,
+  ElementCallback,
+  IterableElementBase,
+  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-counter.more-branches-3.coverage.test.ts

@@ -0,0 +1,146 @@
+import { AVLTreeCounter } from '../../../../src';
+
+describe('AVLTreeCounter remaining reachable branch coverage (batch 3)', () => {
+  it('perfectlyBalance returns false for empty tree (n===0 branch)', () => {
+    const t = new AVLTreeCounter<number, number>();
+    expect(t.perfectlyBalance()).toBe(false);
+  });
+
+  it('clone covers non-mapMode branch (bfs sets values)', () => {
+    const t = new AVLTreeCounter<number, string>([], { isMapMode: false });
+    t.set(1, 'a', 3);
+
+    const c = t.clone();
+    expect(c.get(1)).toBe('a');
+    expect((c as any).getNode(1).count).toBe(3);
+  });
+
+  it('_createLike hits default iter=[] parameter', () => {
+    const t = new AVLTreeCounter<number, number>();
+    const like = (t as any)._createLike();
+    expect(like).toBeInstanceOf(AVLTreeCounter);
+    expect(like.size).toBe(0);
+  });
+
+  it('_keyValueNodeOrEntryToNodeAndValue entry with undefined key returns [undefined, undefined]', () => {
+    const t = new AVLTreeCounter<number, number>();
+    const out = (t as any)._keyValueNodeOrEntryToNodeAndValue([undefined, 123]);
+    expect(out).toEqual([undefined, undefined]);
+  });
+
+  it('_swapProperties covers mapMode branches where value assignments are skipped', () => {
+    const t = new AVLTreeCounter<number, string>([], { isMapMode: true });
+
+    const n1 = t.createNode(1, 's', 1) as any;
+    const n2 = t.createNode(2, 'd', 2) as any;
+
+    // Ensure values are present so we can assert they were NOT reassigned.
+    n1.value = 's';
+    n2.value = 'd';
+    n1.height = 10;
+    n2.height = 20;
+
+    const swapped = (t as any)._swapProperties(n1, n2);
+    expect(swapped).toBe(n2);
+
+    // keys/counts/heights swap...
+    expect(n2.key).toBe(1);
+    expect(n2.count).toBe(1);
+    expect(n2.height).toBe(10);
+
+    expect(n1.key).toBe(2);
+    expect(n1.count).toBe(2);
+    expect(n1.height).toBe(20);
+
+    // ...but values should be untouched in map mode.
+    expect(n1.value).toBe('s');
+    expect(n2.value).toBe('d');
+  });
+
+  it('_swapProperties covers non-mapMode branches where value assignments occur', () => {
+    const t = new AVLTreeCounter<number, string>([], { isMapMode: false });
+
+    const n1 = t.createNode(1, 's', 1) as any;
+    const n2 = t.createNode(2, 'd', 2) as any;
+    n1.height = 10;
+    n2.height = 20;
+
+    const swapped = (t as any)._swapProperties(n1, n2);
+    expect(swapped).toBe(n2);
+
+    expect(n2.key).toBe(1);
+    expect(n2.value).toBe('s');
+    expect(n2.count).toBe(1);
+
+    expect(n1.key).toBe(2);
+    expect(n1.value).toBe('d');
+    expect(n1.count).toBe(2);
+  });
+
+  it('delete() hits `curr.left ? getRightMost(...) : undefined` false-arm via left getter side-effect', () => {
+    const t = new AVLTreeCounter<number, number>();
+    t.setMany([
+      [2, 2],
+      [1, 1],
+      [3, 3]
+    ]);
+
+    const node2 = (t as any).getNode(2);
+    const realLeft = node2.left;
+
+    let reads = 0;
+    Object.defineProperty(node2, 'left', {
+      configurable: true,
+      get() {
+        reads++;
+        // First read (in `if (!curr.left)`) must be truthy to reach the else-branch.
+        if (reads === 1) return realLeft;
+        // Second read (in ternary) returns undefined to hit the false-arm.
+        return undefined;
+      }
+    });
+
+    try {
+      expect(() => t.delete(2)).not.toThrow();
+    } finally {
+      // Restore a normal data property to avoid polluting later tests.
+      Object.defineProperty(node2, 'left', {
+        configurable: true,
+        writable: true,
+        value: realLeft
+      });
+    }
+  });
+
+  it('perfectlyBalance hits `nd ? nd.count : 0` false-arm via proxy iterator yielding undefined', () => {
+    const t = new AVLTreeCounter<number, number>();
+    t.setMany([
+      [2, 2],
+      [1, 1],
+      [3, 3]
+    ]);
+
+    const origDfs = (t as any).dfs;
+    (t as any).dfs = (...args: any[]) => {
+      const nodes: any[] = origDfs.apply(t, args);
+      // Proxy: keep indexing intact, but iteration yields an initial undefined.
+      return new Proxy(nodes, {
+        get(target, prop, receiver) {
+          if (prop === Symbol.iterator) {
+            return function* () {
+              yield undefined;
+              yield* target;
+            };
+          }
+          return Reflect.get(target, prop, receiver);
+        }
+      });
+    };
+
+    try {
+      expect(t.perfectlyBalance()).toBe(true);
+    } finally {
+      (t as any).dfs = origDfs;
+    }
+  });
+});

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

@@ -0,0 +1,93 @@
+import { AVLTreeCounter, AVLTreeCounterNode } from '../../../../src';
+
+describe('AVLTreeCounter additional branch coverage', () => {
+  it('AVLTreeCounterNode constructor uses default count=1', () => {
+    const n = new AVLTreeCounterNode(1, 'v');
+    expect(n.count).toBe(1);
+  });
+
+  it('AVLTreeCounterNode familyPosition covers ISOLATED/ROOT/LEFT/ROOT_LEFT/RIGHT/ROOT_RIGHT/MAL_NODE', () => {
+    const a = new AVLTreeCounterNode(1);
+    expect(a.familyPosition).toBe('ISOLATED');
+
+    // root-like: no parent, but has child
+    const root = new AVLTreeCounterNode(10);
+    root.left = new AVLTreeCounterNode(5);
+    expect(root.familyPosition).toBe('ROOT');
+
+    const p = new AVLTreeCounterNode(0);
+    const left = new AVLTreeCounterNode(-1);
+    const right = new AVLTreeCounterNode(1);
+    p.left = left;
+    p.right = right;
+
+    expect(left.familyPosition).toBe('LEFT');
+    expect(right.familyPosition).toBe('RIGHT');
+
+    // root-left/right variants: node has its own child
+    left.left = new AVLTreeCounterNode(-2);
+    right.right = new AVLTreeCounterNode(2);
+    expect(left.familyPosition).toBe('ROOT_LEFT');
+    expect(right.familyPosition).toBe('ROOT_RIGHT');
+
+    // MAL_NODE: has parent but parent does not reference it
+    const mal = new AVLTreeCounterNode(99);
+    mal.parent = p;
+    expect(mal.familyPosition).toBe('MAL_NODE');
+  });
+
+  it('set() returns false when keyNodeOrEntry is null/undefined (covers newNode===undefined early return)', () => {
+    const t = new AVLTreeCounter<number, number>([], { isMapMode: false });
+    expect(t.set(undefined as any)).toBe(false);
+    expect(t.set(null as any)).toBe(false);
+  });
+
+  it('set() with count=0 exercises orgNodeCount==0 branch without changing aggregate count', () => {
+    const t = new AVLTreeCounter<number, number>([], { isMapMode: false });
+    expect(t.count).toBe(0);
+
+    t.set(1, 1, 0);
+    expect(t.count).toBe(0);
+
+    // normal insert should increase count
+    t.set(2, 2);
+    expect(t.count).toBe(1);
+  });
+
+  it('delete() returns [] when tree is empty or key missing', () => {
+    const t = new AVLTreeCounter<number, number>([], { isMapMode: false });
+    expect(t.delete(1)).toEqual([]);
+
+    t.set(1, 1);
+    expect(t.delete(999)).toEqual([]);
+  });
+
+  it('delete() decrements count when node.count>1 and ignoreCount=false', () => {
+    const t = new AVLTreeCounter<number, number>([], { isMapMode: false });
+    t.set(1, 1);
+    t.set(1, 1); // duplicate increments count in _replaceNode
+
+    const n = t.getNode(1)!;
+    expect(n.count).toBe(2);
+    expect(t.count).toBe(2);
+
+    const res = t.delete(1, false);
+    expect(res.length).toBe(1);
+    expect(t.getNode(1)!.count).toBe(1);
+    expect(t.count).toBe(1);
+  });
+
+  it('delete() removes root when it has no left child and no parent (covers parent-null root replacement)', () => {
+    const t = new AVLTreeCounter<number, number>([], { isMapMode: false });
+    t.set(1, 1);
+    t.set(2, 2);
+
+    // force root to have no left (common in AVL after balancing for two nodes)
+    const root = t.root!;
+    root.left = undefined;
+
+    const res = t.delete(root.key, true);
+    expect(res.length).toBe(1);
+    expect(t.root).toBeDefined();
+  });
+});