npm - data-structure-typed - Versions diffs - 1.41.6 → 1.41.8 - Mend

data-structure-typed 1.41.6 → 1.41.8

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 (115) hide show

package/test/performance/reportor.ts ADDED Viewed

@@ -0,0 +1,185 @@
+import * as Benchmark from 'benchmark';
+import * as path from 'path';
+import * as fs from 'fs';
+import * as fastGlob from 'fast-glob';
+import {Color, numberFix, render} from '../utils';
+import {PerformanceTest} from './types';
+const reportDistPath = 'benchmark';
+const testDir = path.join(__dirname, 'data-structures');
+const testFiles = fastGlob.sync(path.join(testDir, '**', '*.test.ts'));
+const report: {[key: string]: any} = {};
+let completedCount = 0;
+const performanceTests: PerformanceTest[] = [];
+const {GREEN, BOLD, END, YELLOW, GRAY, CYAN, BG_YELLOW} = Color;
+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>`;
+  replaceMarkdownContent(
+    '[//]: # (Start of Replace Section)', // Start tag
+    '[//]: # (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`);
+};
+function replaceMarkdownContent(startMarker: string, endMarker: string, newText: string) {
+  const parentDirectory = path.resolve(__dirname, '../..'); // The path to the parent directory
+  const filePath = path.join(parentDirectory, 'README.md'); // Path to README.md file
+  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 ${filePath}!`);
+      }
+    });
+  });
+}
+performanceTests.forEach(item => {
+  const {suite, testName, file} = item;
+  const relativeFilePath = path.relative(__dirname, file);
+  const directory = path.dirname(relativeFilePath);
+  const fileName = path.basename(relativeFilePath);
+  console.log(`${BG_YELLOW} Running ${END} ${GRAY}${directory}/${END}${CYAN}${fileName}${END}`);
+  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 === performanceTests.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}${
+            performanceTests.length
+          }${END}`,
+          `Time: ${isTimeWarn ? YELLOW : GREEN}${runTime}s${END}`
+        );
+        if (isDone) {
+          composeReport();
+        }
+      })
+      .run({async: false});
+  }
+});

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

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

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

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

package/test/types/index.ts ADDED Viewed

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

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

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

package/test/types/utils/index.ts ADDED Viewed

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

package/test/types/utils/json2html.ts ADDED Viewed

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

package/test/unit/data-structures/binary-tree/avl-tree.test.ts ADDED Viewed

@@ -0,0 +1,269 @@
+import {AVLTree, AVLTreeNode, CP, IterationType} from '../../../../src';
+describe('AVL Tree Test', () => {
+  it('should perform various operations on a AVL Tree', () => {
+    const arr = [11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
+    const tree = new AVLTree<number>();
+    for (const i of arr) tree.add(i, i);
+    const node6 = tree.getNode(6);
+    expect(node6 && tree.getHeight(node6)).toBe(3);
+    expect(node6 && tree.getDepth(node6)).toBe(1);
+    const getNodeById = tree.getNode(10);
+    expect(getNodeById?.key).toBe(10);
+    const getMinNodeByRoot = tree.getLeftMost();
+    expect(getMinNodeByRoot?.key).toBe(1);
+    const node15 = tree.getNode(15);
+    const getMinNodeBySpecificNode = node15 && tree.getLeftMost(node15);
+    expect(getMinNodeBySpecificNode?.key).toBe(12);
+    let subTreeSum = 0;
+    node15 && tree.subTreeTraverse(node => (subTreeSum += node.key), node15);
+    expect(subTreeSum).toBe(70);
+    let lesserSum = 0;
+    tree.lesserOrGreaterTraverse(node => (lesserSum += node.key), CP.lt, 10);
+    expect(lesserSum).toBe(45);
+    // node15 has type problem. After the uniform design, the generics of containers (DirectedGraph, BST) are based on the type of value. However, this design has a drawback: when I attempt to inherit from the Vertex or BSTNode classes, the types of the results obtained by all methods are those of the parent class.
+    expect(node15?.value).toBe(15);
+    const dfs = tree.dfs(node => node, 'in');
+    expect(dfs[0].key).toBe(1);
+    expect(dfs[dfs.length - 1].key).toBe(16);
+    tree.perfectlyBalance();
+    const bfs = tree.bfs(node => node);
+    expect(tree.isPerfectlyBalanced()).toBe(true);
+    expect(bfs[0].key).toBe(8);
+    expect(bfs[bfs.length - 1].key).toBe(16);
+    expect(tree.delete(11)[0].deleted?.key).toBe(11);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(node15 && tree.getHeight(node15)).toBe(2);
+    expect(tree.delete(1)[0].deleted?.key).toBe(1);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(4);
+    expect(tree.delete(4)[0].deleted?.key).toBe(4);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(4);
+    expect(tree.delete(10)[0].deleted?.key).toBe(10);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(3);
+    expect(tree.delete(15)[0].deleted?.key).toBe(15);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(3);
+    expect(tree.delete(5)[0].deleted?.key).toBe(5);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(3);
+    expect(tree.delete(13)[0].deleted?.key).toBe(13);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(3);
+    expect(tree.delete(3)[0].deleted?.key).toBe(3);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(3);
+    expect(tree.delete(8)[0].deleted?.key).toBe(8);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(3);
+    expect(tree.delete(6)[0].deleted?.key).toBe(6);
+    expect(tree.delete(6).length).toBe(0);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(2);
+    expect(tree.delete(7)[0].deleted?.key).toBe(7);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(2);
+    expect(tree.delete(9)[0].deleted?.key).toBe(9);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(2);
+    expect(tree.delete(14)[0].deleted?.key).toBe(14);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(1);
+    expect(tree.isAVLBalanced()).toBe(true);
+    const lastBFSIds = tree.bfs();
+    expect(lastBFSIds[0]).toBe(12);
+    expect(lastBFSIds[1]).toBe(2);
+    expect(lastBFSIds[2]).toBe(16);
+    const lastBFSNodes = tree.bfs(node => node);
+    expect(lastBFSNodes[0].key).toBe(12);
+    expect(lastBFSNodes[1].key).toBe(2);
+    expect(lastBFSNodes[2].key).toBe(16);
+  });
+});
+describe('AVL Tree Test recursively', () => {
+  it('should perform various operations on a AVL Tree', () => {
+    const arr = [11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
+    const tree = new AVLTree<number>({iterationType: IterationType.RECURSIVE});
+    for (const i of arr) tree.add(i, i);
+    const node6 = tree.getNode(6);
+    expect(node6 && tree.getHeight(node6)).toBe(3);
+    expect(node6 && tree.getDepth(node6)).toBe(1);
+    const getNodeById = tree.getNode(10);
+    expect(getNodeById?.key).toBe(10);
+    const getMinNodeByRoot = tree.getLeftMost();
+    expect(getMinNodeByRoot?.key).toBe(1);
+    const node15 = tree.getNode(15);
+    const getMinNodeBySpecificNode = node15 && tree.getLeftMost(node15);
+    expect(getMinNodeBySpecificNode?.key).toBe(12);
+    let subTreeSum = 0;
+    node15 && tree.subTreeTraverse(node => (subTreeSum += node.key), node15);
+    expect(subTreeSum).toBe(70);
+    let lesserSum = 0;
+    tree.lesserOrGreaterTraverse(node => (lesserSum += node.key), CP.lt, 10);
+    expect(lesserSum).toBe(45);
+    // node15 has type problem. After the uniform design, the generics of containers (DirectedGraph, BST) are based on the type of value. However, this design has a drawback: when I attempt to inherit from the Vertex or BSTNode classes, the types of the results obtained by all methods are those of the parent class.
+    expect(node15?.value).toBe(15);
+    const dfs = tree.dfs(node => node, 'in');
+    expect(dfs[0].key).toBe(1);
+    expect(dfs[dfs.length - 1].key).toBe(16);
+    tree.perfectlyBalance();
+    const bfs = tree.bfs(node => node);
+    expect(tree.isPerfectlyBalanced()).toBe(true);
+    expect(bfs[0].key).toBe(8);
+    expect(bfs[bfs.length - 1].key).toBe(16);
+    expect(tree.delete(11)[0].deleted?.key).toBe(11);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(node15 && tree.getHeight(node15)).toBe(2);
+    expect(tree.delete(1)[0].deleted?.key).toBe(1);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(4);
+    expect(tree.delete(4)[0].deleted?.key).toBe(4);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(4);
+    expect(tree.delete(10)[0].deleted?.key).toBe(10);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(3);
+    expect(tree.delete(15)[0].deleted?.key).toBe(15);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(3);
+    expect(tree.delete(5)[0].deleted?.key).toBe(5);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(3);
+    expect(tree.delete(13)[0].deleted?.key).toBe(13);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(3);
+    expect(tree.delete(3)[0].deleted?.key).toBe(3);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(3);
+    expect(tree.delete(8)[0].deleted?.key).toBe(8);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(3);
+    expect(tree.delete(6)[0].deleted?.key).toBe(6);
+    expect(tree.delete(6).length).toBe(0);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(2);
+    expect(tree.delete(7)[0].deleted?.key).toBe(7);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(2);
+    expect(tree.delete(9)[0].deleted?.key).toBe(9);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(2);
+    expect(tree.delete(14)[0].deleted?.key).toBe(14);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(1);
+    expect(tree.isAVLBalanced()).toBe(true);
+    const lastBFSIds = tree.bfs();
+    expect(lastBFSIds[0]).toBe(12);
+    expect(lastBFSIds[1]).toBe(2);
+    expect(lastBFSIds[2]).toBe(16);
+    const lastBFSNodes = tree.bfs(node => node);
+    expect(lastBFSNodes[0].key).toBe(12);
+    expect(lastBFSNodes[1].key).toBe(2);
+    expect(lastBFSNodes[2].key).toBe(16);
+  });
+});
+describe('AVLTree APIs test', () => {
+  const avl = new AVLTree<{id: number; text: string}>();
+  beforeEach(() => {
+    avl.clear();
+  });
+  it('add', () => {
+    avl.add(1);
+    const node2 = new AVLTreeNode(2);
+    avl.add(node2);
+    const node3 = new AVLTreeNode(3, {id: 3, text: 'text3'});
+    avl.add(node3);
+    avl.add(node3, {id: 3, text: 'text33'});
+    const bfsRes = avl.bfs(node => node.key);
+    expect(bfsRes[0]).toBe(2);
+  });
+});
+describe('AVLTree', () => {
+  it('should balance the tree using _balanceLR when nodes are added', () => {
+    const avlTree = new AVLTree();
+    avlTree.add(10, 'A');
+    avlTree.add(5, 'B');
+    avlTree.add(15, 'C');
+    avlTree.add(3, 'D');
+    avlTree.add(7, 'E');
+    // Adding nodes to trigger _balanceLR
+    avlTree.add(12, 'F');
+    // You can add more specific assertions to check the tree's balance and structure.
+  });
+  it('should balance the tree using _balanceLR when nodes are deleted', () => {
+    const avlTree = new AVLTree();
+    avlTree.add(10, 'A');
+    avlTree.add(5, 'B');
+    avlTree.add(15, 'C');
+    avlTree.add(3, 'D');
+    avlTree.add(7, 'E');
+    avlTree.add(12, 'F');
+    // Deleting nodes to trigger _balanceLR
+    avlTree.delete(3);
+    // You can add more specific assertions to check the tree's balance and structure.
+  });
+});