npm - data-structure-typed - Versions diffs - 2.3.0 → 2.4.0 - Mend

data-structure-typed 2.3.0 → 2.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (676) hide show

package/test/performance/reportor.ts DELETED Viewed

@@ -1,279 +0,0 @@
-import * as Benchmark from 'benchmark';
-import * as path from 'path';
-import * as fs from 'fs';
-import * as fastGlob from 'fast-glob';
-import { ConsoleColor, numberFix, render } from '../utils';
-import { PerformanceTest } from './types';
-const args = process.argv.slice(2);
-const { GREEN, BOLD, END, YELLOW, GRAY, CYAN, BG_YELLOW } = ConsoleColor;
-const isOnlyOrdered = true;
-const runOrder = [
-  'heap',
-  'avl-tree',
-  'red-black-tree',
-  'doubly-linked-list',
-  'directed-graph',
-  'queue',
-  'deque',
-  'hash-map',
-  'trie',
-  'stack'
-  // 'singly-linked-list',
-  // 'priority-queue',
-  // 'binary-tree-overall'
-];
-const getRelativePath = (file: string) => {
-  return path.relative(__dirname, file);
-};
-const coloredLabeled = (label: string, file: string) => {
-  const relativeFilePath = getRelativePath(file);
-  const directory = path.dirname(relativeFilePath);
-  const fileName = path.basename(relativeFilePath);
-  return `${BG_YELLOW} ${label} ${END} ${GRAY}${directory}/${END}${CYAN}${fileName}${END}`;
-};
-const parentDirectory = path.resolve(__dirname, '../..');
-const reportDistPath = path.join(parentDirectory, 'benchmark');
-const testDir = path.join(__dirname, 'data-structures');
-const allFiles = fastGlob.sync(path.join(testDir, '**', '*.test.ts'));
-let testFiles: string[];
-let isIndividual = false;
-if (args.length > 0) {
-  console.log(`arguments: ${args.join(' ')}`);
-  testFiles = allFiles.filter(file => args.every(word => file.includes(word)));
-  isIndividual = true;
-  console.log(
-    `${testFiles.map(file => coloredLabeled('Found', file)).join(`
-`)}`
-  );
-} else {
-  isIndividual = false;
-  testFiles = allFiles;
-}
-const report: { [key: string]: any } = {};
-let completedCount = 0;
-const performanceTests: PerformanceTest[] = [];
-testFiles.forEach((file: string) => {
-  const testName = path.basename(file, '.test.ts');
-  const testFunction = require(file);
-  const { suite } = testFunction;
-  if (suite)
-    performanceTests.push({
-      testName,
-      suite,
-      file
-    });
-});
-const composeReport = () => {
-  if (!fs.existsSync(reportDistPath))
-    fs.mkdirSync(reportDistPath, {
-      recursive: true
-    });
-  const filePath = path.join(reportDistPath, 'report.json');
-  const htmlFilePath = path.join(reportDistPath, 'report.html');
-  fs.writeFileSync(filePath, JSON.stringify(report, null, 2));
-  let html = `<!DOCTYPE html>
-                        <html lang="en">
-                        <head>
-                          <meta charset="UTF-8">
-                          <title>performance of data-structure-typed</title>
-                          <style>
-                          *{
-                          box-sizing: border-box;
-                          }
-                                #json-to-html {
-                                padding: 0 10px 20px;
-                                }
-                                .json-to-html-label {
-                                    font-size: 2rem;
-                                    margin: 2rem 0 0 3px;
-                                }
-                               .content table {
-                                  width: 100%;
-                                  table-layout: fixed;
-                                  border-collapse: collapse;
-                                  margin-top: 10px;
-                                  font-size: 16px;
-                                }
-                                .content table th,
-                                .content table td {
-                                  padding: 8px 12px;
-                                  text-align: left;
-                                  border: 1px solid #ddd;
-                                }
-                                .content table th {
-                                  background-color: #f2f2f2;
-                                  font-weight: bold;
-                                }
-                                .content table tr:nth-child(odd) {
-                                  background-color: #ffffff;
-                                }
-                            </style>
-                        </head>
-                        <body>
-                        <div id="json-to-html">`;
-  let htmlTables = '';
-  for (const r in report) {
-    if (report.hasOwnProperty(r)) {
-      htmlTables += render(report[r].testName, report[r].benchmarks, {
-        plainHtml: true,
-        '<>': 'table',
-        html: [
-          {
-            '<>': 'tr',
-            html: [
-              {
-                '<>': 'td',
-                html: '${name}'
-              },
-              {
-                '<>': 'td',
-                html: '${periodMS}'
-              },
-              {
-                '<>': 'td',
-                html: '${mean}'
-              }
-            ]
-          }
-        ]
-      });
-    }
-  }
-  htmlTables += `
-`;
-  html += htmlTables;
-  html += `</div>
-                    </body>
-                  </html>`;
-  if (!isIndividual)
-    replaceMarkdownContent(
-      '[//]: # (No deletion!!! Start of Replace Section)', // Start tag
-      '[//]: # (No deletion!!! End of Replace Section)', // end identifier
-      htmlTables // New content to be inserted
-    );
-  fs.writeFileSync(htmlFilePath, html);
-  console.log(`Performance ${BOLD}${GREEN}report${END} file generated in file://${BOLD}${GREEN}${htmlFilePath}${END}`);
-};
-function replaceMarkdownContent(startMarker: string, endMarker: string, newText: string) {
-  const filePath = path.join(parentDirectory, '/docs/PERFORMANCE.md'); // Path to PERFORMANCE.md file
-  console.log(`Replacing ${filePath}`);
-  fs.readFile(filePath, 'utf8', (err, data) => {
-    if (err) {
-      console.error(`Unable to read ${filePath}:`, err);
-      return;
-    }
-    // Find the start and end markers in the content
-    const startIndex = data.indexOf(startMarker);
-    const endIndex = data.indexOf(endMarker, startIndex + 1);
-    if (startIndex === -1 || endIndex === -1) {
-      console.error('Unable to find start or end marker');
-      return;
-    }
-    // Replace the old content with the new text
-    const updatedMarkdown = data.slice(0, startIndex + startMarker.length) + '\n' + newText + data.slice(endIndex);
-    // Try writing the modified content back to the file
-    fs.writeFile(filePath, updatedMarkdown, 'utf8', err => {
-      if (err) {
-        console.error(`Unable to write to ${filePath}:`, err);
-      } else {
-        console.log(`The content has been successfully replaced in file://${BOLD}${GREEN}${filePath}${END}`);
-      }
-    });
-  });
-}
-const sortedPerformanceTests = (
-  isOnlyOrdered ? [...performanceTests].filter(test => runOrder.includes(test.testName)) : [...performanceTests]
-).sort((a, b) => {
-  const indexA = runOrder.indexOf(a.testName);
-  const indexB = runOrder.indexOf(b.testName);
-  // If both a and b are in the runOrder, sort them according to their indices in the runOrder.
-  if (indexA !== -1 && indexB !== -1) {
-    return indexA - indexB;
-  }
-  // If there is only 'a' in the runOrder, then place 'b' in front.
-  if (indexA !== -1) {
-    return 1;
-  }
-  // If only b is in the runOrder, then a should be placed before it.
-  if (indexB !== -1) {
-    return -1;
-  }
-  // If neither a nor b are in runOrder, keep their original runOrder
-  return 0;
-});
-console.log(
-  `${GREEN} Matched Suites (${performanceTests.length})${END}: ${performanceTests.map(test => test.testName)}`
-);
-console.log(
-  `${GREEN} Running Suites (${sortedPerformanceTests.length})${END}: ${sortedPerformanceTests.map(test => test.testName)}`
-);
-sortedPerformanceTests.forEach(item => {
-  const { suite, testName, file } = item;
-  console.log(coloredLabeled('Running', file));
-  if (suite) {
-    let runTime = 0;
-    suite
-      .on('complete', function (this: Benchmark.Suite) {
-        completedCount++;
-        report[testName] = {};
-        report[testName].benchmarks = this.map((benchmark: Benchmark) => {
-          runTime += benchmark.times.elapsed;
-          return {
-            'test name': benchmark.name,
-            'time taken (ms)': numberFix(benchmark.times.period * 1000, 2),
-            // 'executions per sec': numberFix(benchmark.hz, 2),
-            // 'executed times': numberFix(benchmark.count, 0),
-            'sample mean (secs)': numberFix(benchmark.stats.mean, 2),
-            'sample deviation': numberFix(benchmark.stats.deviation, 2)
-          };
-        });
-        report[testName].testName = testName;
-        const isDone = completedCount === sortedPerformanceTests.length;
-        runTime = Number(runTime.toFixed(2));
-        const isTimeWarn = runTime > 120;
-        console.log(
-          // `Files: ${GREEN}${testFileCount}${END} `,
-          // `Suites: ${GREEN}${performanceTests.length}${END} `,
-          `Suites Progress: ${isDone ? GREEN : YELLOW}${completedCount}${END}/${isDone ? GREEN : YELLOW}${sortedPerformanceTests.length}${END}`,
-          `Time Costs: ${isTimeWarn ? YELLOW : GREEN}${runTime}s${END}`
-        );
-        if (isDone) {
-          composeReport();
-        }
-      })
-      .run({ async: false });
-  }
-});

package/test/performance/single-suite-runner.ts DELETED Viewed

@@ -1,72 +0,0 @@
-import * as path from 'path';
-import * as url from 'url';
-import * as Benchmark from 'benchmark';
-import { numberFix } from '../utils';
-function fileToURL(file: string) {
-  return url.pathToFileURL(file).href;
-}
-async function loadTestModule(file: string): Promise<any> {
-  if (file.endsWith('.mjs')) {
-    return await import(fileToURL(file));
-  }
-  try {
-    // @ts-ignore
-    return require(file);
-  } catch (e: any) {
-    if (e && e.code === 'ERR_REQUIRE_ESM') {
-      return await import(fileToURL(file));
-    }
-    throw e;
-  }
-}
-const file = process.argv[2];
-if (!file) {
-  console.error('single-suite-runner requires a test file path.');
-  process.exit(1);
-}
-(async () => {
-  const testName = path.basename(file).replace(/\.test\.[^.]+$/, '');
-  const mod = await loadTestModule(file);
-  const suite: Benchmark.Suite | undefined = mod?.suite || mod?.default?.suite;
-  if (!suite) {
-    if (process.send) process.send({ testName, benchmarks: [], file });
-    process.exit(0);
-  }
-  try {
-    suite.forEach((b: any) => {
-      if (typeof b.fn === 'function') b.fn.call(b);
-    });
-  } catch {}
-  if (global.gc) global.gc();
-  let runTime = 0;
-  suite
-    .on('complete', function (this: Benchmark.Suite) {
-      const benchmarks = this.map((benchmark: any) => {
-        runTime += benchmark.times.elapsed;
-        return {
-          'Test Case': benchmark.name,
-          'Latency Avg (ms)': numberFix(benchmark.stats.mean * 1000, 2), // Average time
-          'Min (ms)': numberFix(Math.min(...benchmark.stats.sample) * 1000, 2),
-          'Max (ms)': numberFix(Math.max(...benchmark.stats.sample) * 1000, 2),
-          Stability: `±${numberFix(benchmark.stats.rme, 2)}%` // Relative error (better to understand than deviation)
-          // 'Samples': benchmark.stats.sample.length,                           // Number of samples
-          // 'Ops/Sec': Math.round(benchmark.hz).toLocaleString(),               // Operations per second
-        };
-      });
-      runTime = Number(runTime.toFixed(2));
-      if (process.send) process.send({ testName, benchmarks, runTime, file });
-      process.exit(0);
-    })
-    .run({ async: false });
-})().catch(err => {
-  console.error(err);
-  process.exit(1);
-});

package/test/performance/types/index.ts DELETED Viewed

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

package/test/performance/types/reportor.ts DELETED Viewed

@@ -1,7 +0,0 @@
-import * as Benchmark from 'benchmark';
-export type PerformanceTest = {
-  testName: string;
-  suite: Benchmark.Suite;
-  file: string;
-};

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

@@ -1,146 +0,0 @@
-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 DELETED Viewed

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