data-structure-typed 2.4.1 → 2.4.3

package/test/performance/runner-config.json

@@ -1,51 +0,0 @@
-{
-  "label": "default-plan",
-  "include": [
-    "binary-tree/avl-tree.test.mjs",
-    "binary-tree/binary-tree.test.mjs",
-    "binary-tree/bst.test.mjs",
-    "binary-tree/red-black-tree.test.mjs",
-    "binary-tree/tree-set.test.mjs",
-    "binary-tree/tree-map.test.mjs",
-    "binary-tree/tree-multi-set.test.mjs",
-    "binary-tree/tree-multi-map.test.mjs",
-    "binary-tree/**/*.test.cpp",
-    "graph/**",
-    "hash/**",
-    "queue/queue.test.mjs",
-    "queue/deque.test.mjs",
-    "linked-list/**",
-    "stack/**",
-    "priority-queue/**",
-    "trie/**"
-  ],
-  "exclude": [
-    "**/experimental/**",
-    "heap/**",
-    "**/max-priority-queue*"
-  ],
-  "order": [
-    "doubly-linked-list",
-    "singly-linked-list",
-    "linked-hash-map",
-    "hash-map",
-    "queue",
-    "deque",
-    "priority-queue",
-    "stack",
-    "red-black-tree",
-    "avl-tree",
-    "tree-set",
-    "tree-map",
-    "tree-multi-set",
-    "tree-multi-map",
-    "bst",
-    "binary-tree",
-    "binary-tree-overall",
-    "trie",
-    "graph",
-    "directed-graph",
-    "undirected-graph",
-    "map-graph"
-  ]
-}

package/test/types/index.ts

@@ -1 +0,0 @@
-export * from './utils';

package/test/types/utils/big-o.ts

@@ -1 +0,0 @@
-export type AnyFunction = (...args: any[]) => any;

package/test/types/utils/index.ts

@@ -1,2 +0,0 @@
-export * from './big-o';
-export * from './json2html';

package/test/types/utils/json2html.ts

@@ -1,5 +0,0 @@
-export type Json2htmlOptions = {
-  plainHtml?: boolean;
-} & Partial<{
-  [key: string]: any;
-}>;

package/test/unit/data-structures/base/iterable-element-base.coverage.test.ts

@@ -1,106 +0,0 @@
-import { IterableElementBase } from '../../../../src/data-structures/base/iterable-element-base';
-
-class TestIterable extends IterableElementBase<number, number> {
-  private _arr: number[];
-
-  constructor(arr: number[] = [], opts?: any) {
-    super(opts);
-    this._arr = [...arr];
-  }
-
-  protected *_getIterator(): IterableIterator<number> {
-    yield* this._arr;
-  }
-
-  isEmpty(): boolean {
-    return this._arr.length === 0;
-  }
-
-  clear(): void {
-    this._arr.length = 0;
-  }
-
-  clone(): this {
-    return new TestIterable(this._arr, { toElementFn: this.toElementFn }) as unknown as this;
-  }
-
-  map<EM, RM>(cb: any, options?: any, thisArg?: unknown): IterableElementBase<EM, RM> {
-    const out = this._arr.map((v, i) => cb.call(thisArg, v, i, this));
-    // For tests we keep it minimal; toElementFn unused.
-    return new TestIterable(out as any, options) as any;
-  }
-
-  mapSame(cb: any, thisArg?: unknown): this {
-    return new TestIterable(this._arr.map((v, i) => cb.call(thisArg, v, i, this))) as unknown as this;
-  }
-
-  filter(pred: any, thisArg?: unknown): this {
-    const out: number[] = [];
-    let i = 0;
-    for (const v of this) {
-      if (pred.call(thisArg, v, i++, this)) out.push(v);
-    }
-    return new TestIterable(out) as unknown as this;
-  }
-}
-
-/**
- * Coverage-focused tests for IterableElementBase.
- * Keep existing @example tests intact.
- */
-describe('IterableElementBase coverage', () => {
-  it('constructor rejects non-function toElementFn when truthy', () => {
-    expect(() => new TestIterable([], { toElementFn: 123 as any })).toThrow(TypeError);
-  });
-
-  it('every/some/forEach/find cover thisArg and non-thisArg paths', () => {
-    const t = new TestIterable([1, 2, 3]);
-
-    // thisArg === undefined path
-    expect(t.every(v => v > 0)).toBe(true);
-    expect(t.some(v => v === 2)).toBe(true);
-
-    // thisArg path
-    const ctx = { mul: 2, seen: [] as number[] };
-    expect(
-      t.every(function (this: any, v: number) {
-        return v * this.mul > 0;
-      }, ctx)
-    ).toBe(true);
-
-    t.forEach(function (this: any, v: number) {
-      this.seen.push(v);
-    }, ctx);
-    expect(ctx.seen).toEqual([1, 2, 3]);
-
-    const found = t.find(function (this: any, v: number) {
-      return v === 3;
-    }, ctx);
-    expect(found).toBe(3);
-  });
-
-  it('reduce throws on empty without initialValue, works with/without initialValue', () => {
-    const empty = new TestIterable([]);
-    expect(() => empty.reduce((acc: number, v: number) => acc + v)).toThrow(TypeError);
-
-    const t = new TestIterable([1, 2, 3]);
-    expect(t.reduce((acc: number, v: number) => acc + v, 0)).toBe(6);
-
-    // no initialValue uses first element
-    expect(t.reduce((acc: number, v: number) => acc + v)).toBe(6);
-  });
-
-  it('values/toArray/toVisual/print/has basics', () => {
-    const t = new TestIterable([1, 2]);
-    expect([...t.values()]).toEqual([1, 2]);
-    expect(t.toArray()).toEqual([1, 2]);
-    expect(t.toVisual()).toEqual([1, 2]);
-    expect(t.has(2)).toBe(true);
-    expect(t.has(3)).toBe(false);
-
-    const spy = jest.spyOn(console, 'log').mockImplementation(() => undefined);
-    t.print();
-    expect(spy).toHaveBeenCalled();
-    spy.mockRestore();
-  });
-});

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

@@ -1,61 +0,0 @@
-import { ElementCallback, IterableElementBaseOptions } from 'src';
-import { IterableElementBase } from '../../../../src/data-structures/base/iterable-element-base';
-
-class NumIter extends IterableElementBase<number, number> {
-  override isEmpty(): boolean {
-    throw new Error('Method not implemented.');
-  }
-  override clear(): void {
-    throw new Error('Method not implemented.');
-  }
-  override clone(): this {
-    throw new Error('Method not implemented.');
-  }
-  override map<EM, RM>(
-    _callback: ElementCallback<number, number, EM>,
-    _options?: IterableElementBaseOptions<EM, RM> | undefined,
-    _thisArg?: unknown
-  ): IterableElementBase<EM, RM> {
-    throw new Error('Method not implemented.');
-  }
-  override mapSame(_callback: ElementCallback<number, number, number>, _thisArg?: unknown): this {
-    throw new Error('Method not implemented.');
-  }
-  override filter(_predicate: ElementCallback<number, number, boolean>, _thisArg?: unknown): this {
-    throw new Error('Method not implemented.');
-  }
-  protected override _getIterator(..._args: unknown[]): IterableIterator<number> {
-    throw new Error('Method not implemented.');
-  }
-  constructor(private readonly data: number[]) {
-    super();
-  }
-
-  override *[Symbol.iterator](): IterableIterator<number> {
-    for (const n of this.data) yield n;
-  }
-}
-
-describe('IterableElementBase remaining branch coverage', () => {
-  it('every() uses thisArg branch (fn.call) and can early-return false', () => {
-    const it = new NumIter([1, 2, 3]);
-
-    const ctx = { limit: 2 };
-    const res = it.every(function (this: any, v: number) {
-      return v <= this.limit;
-    }, ctx);
-
-    expect(res).toBe(false);
-  });
-
-  it('some() uses thisArg branch (fn.call) and can early-return true', () => {
-    const it = new NumIter([1, 2, 3]);
-
-    const ctx = { pick: 2 };
-    const res = it.some(function (this: any, v: number) {
-      return v === this.pick;
-    }, ctx);
-
-    expect(res).toBe(true);
-  });
-});

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

@@ -1,168 +0,0 @@
-import { IterableElementBase } from 'src';
-import { LinearBase } from '../../../../src/data-structures/base/linear-base';
-import type { ElementCallback, IterableElementBaseOptions, LinearBaseOptions } from '../../../../src/types';
-
-class TestArrayLinear extends LinearBase<number, number> {
-  override isEmpty(): boolean {
-    throw new Error('Method not implemented.');
-  }
-  override map<EM, RM>(
-    _callback: ElementCallback<number, number, EM>,
-    _options?: IterableElementBaseOptions<EM, RM> | undefined,
-    _thisArg?: unknown
-  ): IterableElementBase<EM, RM> {
-    throw new Error('Method not implemented.');
-  }
-  override mapSame(_callback: ElementCallback<number, number, number>, _thisArg?: unknown): this {
-    throw new Error('Method not implemented.');
-  }
-  override filter(_predicate: ElementCallback<number, number, boolean>, _thisArg?: unknown): this {
-    throw new Error('Method not implemented.');
-  }
-  private _arr: number[];
-
-  constructor(values: number[] = [], options?: LinearBaseOptions<number, number>) {
-    super(options);
-    this._arr = values.slice();
-  }
-
-  get length(): number {
-    return this._arr.length;
-  }
-
-  clear(): void {
-    this._arr.length = 0;
-  }
-
-  setAt(index: number, value: number): boolean {
-    if (index < 0 || index >= this._arr.length) return false;
-    this._arr[index] = value;
-    return true;
-  }
-
-  clone(): this {
-    const out = this._createInstance();
-    out.pushMany(this._arr);
-    return out;
-  }
-
-  reverse(): this {
-    this._arr.reverse();
-    return this;
-  }
-
-  push(elementOrNode: number): boolean {
-    if (this.maxLen > 0 && this._arr.length >= this.maxLen) return false;
-    this._arr.push(elementOrNode);
-    return true;
-  }
-
-  pushMany(elements: Iterable<number>): boolean[] {
-    const out: boolean[] = [];
-    for (const e of elements) out.push(this.push(e));
-    return out;
-  }
-
-  delete(elementOrNode: number | undefined): boolean {
-    if (elementOrNode === undefined) return false;
-    const idx = this._arr.indexOf(elementOrNode);
-    if (idx === -1) return false;
-    this._arr.splice(idx, 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): boolean {
-    if (this.maxLen > 0 && this._arr.length >= this.maxLen) return false;
-    if (index < 0) index = 0;
-    if (index > this._arr.length) index = this._arr.length;
-    this._arr.splice(index, 0, newElementOrNode);
-    return true;
-  }
-
-  override toArray(): number[] {
-    return this._arr.slice();
-  }
-
-  protected _createInstance(options?: LinearBaseOptions<number, number>): this {
-    return new TestArrayLinear([], options) as unknown as this;
-  }
-
-  protected *_getIterator(): IterableIterator<number> {
-    for (const v of this._arr) yield v;
-  }
-
-  protected *_getReverseIterator(): IterableIterator<number> {
-    for (let i = this._arr.length - 1; i >= 0; i--) yield this._arr[i];
-  }
-}
-
-describe('LinearBase coverage (array-backed subclass)', () => {
-  it('constructor maxLen branch: accept positive int and ignore non-int/invalid', () => {
-    const a = new TestArrayLinear([], { maxLen: 3 });
-    expect(a.maxLen).toBe(3);
-
-    const b = new TestArrayLinear([], { maxLen: 2.2 } as any);
-    expect(b.maxLen).toBe(-1);
-
-    const c = new TestArrayLinear([], { maxLen: -5 } as any);
-    expect(c.maxLen).toBe(-1);
-  });
-
-  it('indexOf/lastIndexOf cover empty and fromIndex normalization', () => {
-    const empty = new TestArrayLinear();
-    expect(empty.indexOf(1)).toBe(-1);
-    expect(empty.lastIndexOf(1)).toBe(-1);
-
-    const list = new TestArrayLinear([1, 2, 3, 2, 1]);
-
-    expect(list.indexOf(2, -2)).toBe(3); // length + (-2) => 3
-    expect(list.indexOf(1, -999)).toBe(0); // clamp to 0
-    expect(list.lastIndexOf(2, 999)).toBe(3); // clamp to length-1
-
-    // fromIndex < 0 => length + fromIndex (may still be negative) -> returns -1
-    expect(list.lastIndexOf(2, -999)).toBe(-1);
-  });
-
-  it('concat/sort/join/toReversedArray exercise LinearBase helpers', () => {
-    const a = new TestArrayLinear([3, 1, 2]);
-    const b = new TestArrayLinear([9]);
-
-    const c = a.concat(b, 7);
-    expect(c.toArray()).toEqual([3, 1, 2, 9, 7]);
-
-    expect(c.join('-')).toBe('3-1-2-9-7');
-    expect(c.toReversedArray()).toEqual([7, 9, 2, 1, 3]);
-
-    c.sort((x, y) => x - y);
-    expect(c.toArray()).toEqual([1, 2, 3, 7, 9]);
-  });
-
-  it('slice/splice/fill cover negative indices and early-return branches', () => {
-    const list = new TestArrayLinear([1, 2, 3, 4]);
-
-    // slice negative end/start
-    expect(list.slice(1, -1).toArray()).toEqual([2, 3]);
-    expect(list.slice(-1, -1).toArray()).toEqual([]);
-
-    // splice clamps start/deleteCount
-    const removed = list.splice(-2, 999, 8, 9);
-    expect(removed.toArray()).toEqual([3, 4]);
-    expect(list.toArray()).toEqual([1, 2, 8, 9]);
-
-    // fill clamps and early return when start>=end
-    list.fill(0, 3, 2);
-    expect(list.toArray()).toEqual([1, 2, 8, 9]);
-
-    list.fill(5, -999, 999);
-    expect(list.toArray()).toEqual([5, 5, 5, 5]);
-  });
-});

package/test/unit/data-structures/base/linear-base.concat-else.coverage.test.ts

@@ -1,82 +0,0 @@
-import { ElementCallback, IterableElementBaseOptions, IterableElementBase } from 'src';
-import { LinearBase, LinkedListNode } from '../../../../src/data-structures/base/linear-base';
-
-type R = number;
-
-class ArrayLinear extends LinearBase<number, R> {
-  override setAt(_index: number, _value: number): boolean {
-    throw new Error('Method not implemented.');
-  }
-  override reverse(): this {
-    throw new Error('Method not implemented.');
-  }
-  override delete(_elementOrNode: number | LinkedListNode<number> | undefined): boolean {
-    throw new Error('Method not implemented.');
-  }
-  override deleteAt(_pos: number): number | undefined {
-    throw new Error('Method not implemented.');
-  }
-  override addAt(_index: number, _newElementOrNode: number | LinkedListNode<number>): boolean {
-    throw new Error('Method not implemented.');
-  }
-  protected override _getReverseIterator(..._args: any[]): IterableIterator<number> {
-    throw new Error('Method not implemented.');
-  }
-  override isEmpty(): boolean {
-    throw new Error('Method not implemented.');
-  }
-  override clear(): void {
-    throw new Error('Method not implemented.');
-  }
-  override map<EM, RM>(
-    _callback: ElementCallback<number, number, EM>,
-    _options?: IterableElementBaseOptions<EM, RM> | undefined,
-    _thisArg?: unknown
-  ): IterableElementBase<EM, RM> {
-    throw new Error('Method not implemented.');
-  }
-  override mapSame(_callback: ElementCallback<number, number, number>, _thisArg?: unknown): this {
-    throw new Error('Method not implemented.');
-  }
-  override filter(_predicate: ElementCallback<number, number, boolean>, _thisArg?: unknown): this {
-    throw new Error('Method not implemented.');
-  }
-  protected _data: number[];
-  constructor(iter: Iterable<number> = []) {
-    super();
-    this._data = Array.from(iter);
-  }
-  override get length(): number {
-    return this._data.length;
-  }
-  protected _getIterator(): IterableIterator<number> {
-    return this._data[Symbol.iterator]();
-  }
-  protected _createInstance(): this {
-    return new ArrayLinear() as any;
-  }
-  override clone(): this {
-    return new ArrayLinear(this._data) as any;
-  }
-  override push(element: number): boolean {
-    this._data.push(element);
-    return true;
-  }
-  override pushMany(elements: Iterable<number>): boolean[] {
-    const ans: boolean[] = [];
-    for (const e of elements) ans.push(this.push(e));
-    return ans;
-  }
-  override at(index: number): number | undefined {
-    return this._data[index];
-  }
-}
-
-describe('LinearBase concat else-branch coverage', () => {
-  it('concat(item) uses else-branch when item is not a LinearBase', () => {
-    const l = new ArrayLinear([1, 2]);
-    // Use any-call to avoid TS overload narrowing affecting runtime call site.
-    const out = (l as any).concat(3);
-    expect(out.toArray()).toEqual([1, 2, 3]);
-  });
-});

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

@@ -1,72 +0,0 @@
-import { DoublyLinkedList } from '../../../../src';
-
-/**
- * Coverage-focused tests for LinearBase helpers (via DoublyLinkedList).
- * Keep existing @example tests intact.
- */
-describe('LinearBase coverage (via DoublyLinkedList)', () => {
-  it('indexOf/lastIndexOf handle fromIndex bounds and negatives', () => {
-    const list = new DoublyLinkedList<number | undefined>();
-    list.pushMany([1, 2, 3, 2, 1]);
-
-    expect(list.indexOf(2)).toBe(1);
-    expect(list.indexOf(2, 2)).toBe(3);
-
-    // negative fromIndex clamps to 0
-    expect(list.indexOf(1, -999)).toBe(0);
-
-    expect(list.lastIndexOf(2)).toBe(3);
-    // fromIndex >= length clamps to length-1
-    expect(list.lastIndexOf(1, 999)).toBe(4);
-    // negative fromIndex path (current implementation returns -1 for -1 specifically)
-    // (We mainly want to exercise the branch; behavior is asserted as-is.)
-    expect(list.lastIndexOf(2, -1)).toBe(-1);
-  });
-
-  it('findIndex skips undefined elements', () => {
-    const list = new DoublyLinkedList<number | undefined>();
-    list.pushMany([undefined, 1, undefined, 2]);
-
-    const spy = jest.fn((x: number) => x === 2);
-    expect(list.findIndex(spy as any)).toBe(3);
-
-    // predicate should only be called for defined elements
-    expect(spy).toHaveBeenCalledTimes(2);
-  });
-
-  it('slice/splice cover defaults and head-insert path', () => {
-    const list = new DoublyLinkedList<number>();
-    list.pushMany([1, 2, 3, 4]);
-
-    // slice defaults
-    expect(list.slice().toArray()).toEqual([1, 2, 3, 4]);
-    expect(list.slice(1, -1).toArray()).toEqual([2, 3]);
-
-    // splice: insert at head (previousNode undefined)
-    const removed0 = list.splice(0, 0, 9, 8);
-    expect(removed0.toArray()).toEqual([]);
-    expect(list.toArray()).toEqual([9, 8, 1, 2, 3, 4]);
-
-    // splice: delete + insert in middle
-    const removed = list.splice(2, 2, 7);
-    expect(removed.toArray()).toEqual([1, 2]);
-    expect(list.toArray()).toEqual([9, 8, 7, 3, 4]);
-
-    // splice: negative start
-    const removed2 = list.splice(-1, 1);
-    expect(removed2.toArray()).toEqual([4]);
-    expect(list.toArray()).toEqual([9, 8, 7, 3]);
-  });
-
-  it('reduceRight covers initialValue defaulting', () => {
-    const list = new DoublyLinkedList<number>();
-    list.pushMany([1, 2, 3]);
-
-    // no initialValue => accumulator defaults (0 as U)
-    const sum = list.reduceRight((acc: number, x: number) => acc + x);
-    expect(sum).toBe(6);
-
-    const sum2 = list.reduceRight((acc: number, x: number) => acc + x, 10);
-    expect(sum2).toBe(16);
-  });
-});