data-structure-typed 2.2.8 → 2.3.0

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

@@ -0,0 +1,39 @@
+import { Deque } from '../../../../src';
+
+describe('Deque remaining branch coverage (batch 2)', () => {
+  it('unshiftMany covers toElementFn branch (and is executed at all)', () => {
+    const d = new Deque<number, { v: number }>([], {
+      toElementFn: (r: { v: number }) => r.v
+    });
+
+    expect(d.unshiftMany([{ v: 1 }, { v: 2 }])).toEqual([true, true]);
+    expect(d.toArray()).toEqual([2, 1]);
+  });
+
+  it('splice(start) uses default deleteCount = length - start', () => {
+    const d = new Deque<number>();
+    d.pushMany([1, 2, 3, 4]);
+
+    // omit deleteCount to hit the default-arg branch
+    const removed = d.splice(1);
+
+    expect(removed.toArray()).toEqual([2, 3, 4]);
+    expect(d.toArray()).toEqual([1]);
+  });
+
+  it('shrinkToFit covers wrap-around bucketFirst > bucketLast branch', () => {
+    const d = new Deque<number>();
+
+    // Force an internal wrap-around layout (reachable-only: test-side corruption).
+    (d as any)._length = 1;
+    (d as any)._bucketFirst = 2;
+    (d as any)._bucketLast = 1;
+    (d as any)._bucketCount = 4;
+    (d as any)._buckets = [[0], [1], [2], [3]];
+
+    expect(() => d.shrinkToFit()).not.toThrow();
+    expect((d as any)._bucketFirst).toBe(0);
+    expect((d as any)._bucketLast).toBe(3);
+    expect((d as any)._buckets.length).toBe(4);
+  });
+});

package/test/unit/data-structures/queue/deque.more-branches-3.coverage.test.ts

@@ -0,0 +1,9 @@
+import { Deque } from '../../../../src';
+
+describe('Deque remaining branch coverage (batch 3)', () => {
+  it('unshiftMany covers else-branch when toElementFn is not provided', () => {
+    const d = new Deque<number>();
+    expect(d.unshiftMany([1, 2])).toEqual([true, true]);
+    expect(d.toArray()).toEqual([2, 1]);
+  });
+});

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

@@ -0,0 +1,95 @@
+import { Deque } from '../../../../src';
+
+describe('Deque additional branch coverage', () => {
+  it('unshiftMany() default-arg empty iterable returns []', () => {
+    const d = new Deque<number>();
+    expect(d.unshiftMany()).toEqual([]);
+  });
+
+  it('splice clamps deleteCount when negative / too large (covers both clamp branches)', () => {
+    const d = new Deque<number>();
+    d.pushMany([1, 2, 3, 4]);
+
+    // deleteCount < 0 => clamp to 0
+    const r0 = d.splice(1, -1, 99);
+    expect(r0.toArray()).toEqual([]);
+
+    // deleteCount too large => clamp to length-start
+    const r1 = d.splice(1, 999);
+    expect(r1.toArray()).toEqual([99, 2, 3, 4]);
+    expect(d.toArray()).toEqual([1]);
+  });
+
+  it('shrinkToFit returns early when bucketFirst===bucketLast (covers that return branch)', () => {
+    const d = new Deque<number>();
+    d.push(1);
+    // Force bucketFirst===bucketLast and length>0
+    (d as any)._bucketFirst = 0;
+    (d as any)._bucketLast = 0;
+    d.shrinkToFit();
+    expect(d.length).toBe(1);
+  });
+
+  it('mapSame uses the thisArg===undefined branch', () => {
+    const d = new Deque<number>();
+    d.pushMany([1, 2, 3]);
+    const out = d.mapSame(v => v * 2);
+    expect(out.toArray()).toEqual([2, 4, 6]);
+  });
+
+  it('map() uses thisArg branch and also covers options??{} merge path', () => {
+    const d = new Deque<number>();
+    d.pushMany([1, 2]);
+    const ctx = { add: 10 };
+
+    const out = d.map(
+      function (this: any, v: number) {
+        return v + this.add;
+      },
+      undefined,
+      ctx
+    );
+
+    expect(out.toArray()).toEqual([11, 12]);
+  });
+
+  it('_setBucketSize does not reinit buckets when length>0 (covers length===0 false branch)', () => {
+    const d = new Deque<number>();
+    d.pushMany([1, 2, 3]);
+    const before = (d as any)._buckets;
+    (d as any)._setBucketSize((d as any)._bucketSize);
+    expect((d as any)._buckets).toBe(before);
+  });
+
+  it('_getIterator yields only defined values (covers v!==undefined true branch)', () => {
+    const d = new Deque<number>();
+    d.pushMany([1, 2, 3]);
+    // Corrupt one slot to undefined; _getIterator should skip it.
+    const loc = (d as any)._getBucketAndPosition(1);
+    (d as any)._buckets[loc.bucketIndex][loc.indexInBucket] = undefined;
+
+    const got: number[] = [];
+    for (const v of d) got.push(v);
+    expect(got).toEqual([1, 3]);
+  });
+
+  it('_createLike default-arg path can be called with no args', () => {
+    const d = new Deque<number>();
+    const like = (d as any)._createLike();
+    expect(like.length).toBe(0);
+  });
+
+  it('_getReverseIterator handles v===undefined by not yielding it', () => {
+    const d = new Deque<number>();
+    d.pushMany([1, 2, 3]);
+
+    // Make last element undefined
+    const loc = (d as any)._getBucketAndPosition(2);
+    (d as any)._buckets[loc.bucketIndex][loc.indexInBucket] = undefined;
+
+    const it = (d as any)._getReverseIterator();
+    const got: number[] = [];
+    for (const v of it) got.push(v);
+    expect(got).toEqual([2, 1]);
+  });
+});

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

@@ -0,0 +1,138 @@
+import { Queue } from '../../../../src';
+
+describe('Queue coverage', () => {
+  it('constructor options set autoCompactRatio and push respects maxLen via shift', () => {
+    const q = new Queue<number>([], { maxLen: 2, autoCompactRatio: 1 });
+    expect(q.autoCompactRatio).toBe(1);
+
+    q.push(1);
+    q.push(2);
+    q.push(3); // maxLen overflow triggers shift()
+
+    expect([...q]).toEqual([2, 3]);
+    expect(q.length).toBe(2);
+    expect(q.first).toBe(2);
+    expect(q.last).toBe(3);
+  });
+
+  it('pushMany uses toElementFn branch', () => {
+    const q = new Queue<number, { v: number }>([], { toElementFn: r => r.v });
+    expect(q.pushMany([{ v: 1 }, { v: 2 }])).toEqual([true, true]);
+    expect([...q]).toEqual([1, 2]);
+  });
+
+  it('shift covers empty branch and compaction trigger', () => {
+    const q = new Queue<number>();
+    expect(q.shift()).toBeUndefined();
+
+    // Force compaction quickly.
+    q.autoCompactRatio = 0.25;
+    q.pushMany([1, 2, 3, 4]);
+
+    expect(q.shift()).toBe(1);
+    // offset=1, elements.length=4 => 0.25, not strictly greater
+    expect(q.offset).toBe(1);
+
+    expect(q.shift()).toBe(2);
+    // offset=2, elements.length=4 => 0.5 > 0.25 => compact()
+    expect(q.offset).toBe(0);
+    expect(q.elements).toEqual([3, 4]);
+  });
+
+  it('delete/deleteAt/addAt/setAt cover bounds and success', () => {
+    const q = new Queue<number>([1, 2, 3, 4]);
+    // consume one to introduce offset
+    expect(q.shift()).toBe(1);
+
+    expect(q.delete(999)).toBe(false);
+    expect(q.delete(3)).toBe(true);
+    expect([...q]).toEqual([2, 4]);
+
+    expect(q.at(-1)).toBeUndefined();
+    expect(q.at(999)).toBeUndefined();
+    expect(q.at(0)).toBe(2);
+
+    expect(q.deleteAt(-1)).toBeUndefined();
+    expect(q.deleteAt(999)).toBeUndefined();
+    expect(q.deleteAt(0)).toBe(2);
+    expect([...q]).toEqual([4]);
+
+    expect(q.addAt(-1, 0)).toBe(false);
+    expect(q.addAt(999, 0)).toBe(false);
+    expect(q.addAt(0, 3)).toBe(true);
+    expect([...q]).toEqual([3, 4]);
+
+    expect(q.setAt(-1, 0)).toBe(false);
+    expect(q.setAt(999, 0)).toBe(false);
+    expect(q.setAt(1, 40)).toBe(true);
+    expect([...q]).toEqual([3, 40]);
+  });
+
+  it('reverse/clear/compact basic behaviors', () => {
+    const q = new Queue<number>([1, 2, 3]);
+    q.shift();
+    expect(q.offset).toBe(1);
+
+    q.reverse();
+    expect(q.offset).toBe(0);
+    expect([...q]).toEqual([3, 2]);
+
+    q.clear();
+    expect(q.length).toBe(0);
+    expect(q.offset).toBe(0);
+
+    q.pushMany([1, 2]);
+    q.shift();
+    expect(q.compact()).toBe(true);
+    expect(q.offset).toBe(0);
+  });
+
+  it('splice triggers optional compaction and returns removed queue with copied ratio', () => {
+    const q = new Queue<number>([1, 2, 3, 4, 5], { autoCompactRatio: 0.2 });
+    q.shift();
+    q.shift(); // offset=2, len=5 => 0.4 > 0.2 would compact on next splice
+
+    const removed = q.splice(1, 2, 9, 8);
+    expect([...removed]).toEqual([4, 5]);
+    expect(removed.autoCompactRatio).toBe(q.autoCompactRatio);
+
+    expect([...q]).toEqual([3, 9, 8]);
+    expect(q.offset).toBe(0);
+  });
+
+  it('map/mapSame cover thisArg and default branches, and _createLike default elements branch', () => {
+    const q = new Queue<number>([1, 2, 3], { autoCompactRatio: 0.9 });
+
+    const mapped1 = q.map(v => v + 1);
+    expect([...mapped1]).toEqual([2, 3, 4]);
+
+    const ctx = { mul: 2 };
+    const mapped2 = q.map(function (v) {
+      // @ts-ignore
+      return v * this.mul;
+    }, undefined, ctx);
+    expect([...mapped2]).toEqual([2, 4, 6]);
+
+    const same1 = q.mapSame(v => v * 10);
+    expect([...same1]).toEqual([10, 20, 30]);
+
+    const same2 = q.mapSame(function (v) {
+      // @ts-ignore
+      return v + this.inc;
+    }, { inc: 5 });
+    expect([...same2]).toEqual([6, 7, 8]);
+
+    const like = (q as any)._createLike();
+    expect(like.length).toBe(0);
+  });
+
+  it('_getReverseIterator skips undefined items', () => {
+    const q = new Queue<number | undefined>([1, undefined, 2]);
+    expect([...q.toReversedArray()]).toEqual([2, undefined, 1]);
+
+    const rev: (number | undefined)[] = [];
+    for (const v of (q as any)._getReverseIterator()) rev.push(v);
+    // undefined is skipped by implementation
+    expect(rev).toEqual([2, 1]);
+  });
+});

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

@@ -0,0 +1,27 @@
+import { Queue } from '../../../../src';
+
+describe('Queue remaining branch coverage (batch 2)', () => {
+  it('splice(start) hits default deleteCount=0 and can trigger auto-compaction branch', () => {
+    const q = new Queue<number>();
+    q.pushMany([1, 2, 3]);
+
+    // Prevent auto-compaction during the shifts; we want a non-zero offset.
+    q.autoCompactRatio = 1;
+
+    // Create offset > 0 while keeping underlying elements array non-empty.
+    expect(q.shift()).toBe(1);
+    expect(q.shift()).toBe(2);
+    expect(q.offset).toBe(2);
+
+    // Now ensure the condition `offset/elements.length > autoCompactRatio` is true at splice-time.
+    q.autoCompactRatio = 0;
+
+    // Omit deleteCount to hit the default-arg branch.
+    const removed = q.splice(0, undefined as any, 9);
+
+    // Should have compacted (offset reset) and inserted item.
+    expect(q.offset).toBe(0);
+    expect(q.toArray()).toEqual([9, 3]);
+    expect(removed.toArray()).toEqual([]);
+  });
+});

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

@@ -0,0 +1,112 @@
+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/tree/tree.more-branches.coverage.test.ts

@@ -0,0 +1,9 @@
+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/trie/trie.more-branches-2.coverage.test.ts

@@ -0,0 +1,51 @@
+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);
+  });
+});

package/test/utils/patch.ts

@@ -0,0 +1,33 @@
+export async function withMutedConsole<T>(fn: () => T | Promise<T>): Promise<T> {
+  const originalLog = console.log;
+  const originalWarn = console.warn;
+  const originalError = console.error;
+
+  // Keep it minimal: silence during the callback, always restore.
+  console.log = (message?: any, ...optionalParams: any[]) => undefined;
+  console.warn = (message?: any, ...optionalParams: any[]) => undefined;
+  console.error = (message?: any, ...optionalParams: any[]) => undefined;
+
+  try {
+    return await fn();
+  } finally {
+    console.log = originalLog;
+    console.warn = originalWarn;
+    console.error = originalError;
+  }
+}
+
+export function withPatched<T extends object, K extends keyof T, R>(
+  obj: T,
+  key: K,
+  value: T[K],
+  fn: () => R
+): R {
+  const original = obj[key];
+  (obj as any)[key] = value;
+  try {
+    return fn();
+  } finally {
+    (obj as any)[key] = original;
+  }
+}