data-structure-typed 2.0.4 → 2.1.0

package/test/performance/reportor.mjs

@@ -3,31 +3,31 @@ import * as fs from 'fs';
 import fastGlob from 'fast-glob';
 import { fileURLToPath } from 'url';
 
-const isNumber = (value) => {
+const isNumber = value => {
   return typeof value === 'number';
 };
-const isString = (value) => {
+const isString = value => {
   return typeof value === 'string';
 };
-const isBoolean = (value) => {
+const isBoolean = value => {
   return typeof value === 'boolean';
 };
-const isDate = (value) => {
+const isDate = value => {
   return value instanceof Date;
 };
-const isNull = (value) => {
+const isNull = value => {
   return value === null;
 };
-const isUndefined = (value) => {
+const isUndefined = value => {
   return typeof value === 'undefined';
 };
-const isFunction = (value) => {
+const isFunction = value => {
   return typeof value === 'function';
 };
-const isObject = (value) => {
+const isObject = value => {
   return typeof value === 'object';
 };
-const isArray = (value) => {
+const isArray = value => {
   return Array.isArray(value);
 };
 const isEqual = (objA, objB) => {
@@ -56,38 +56,35 @@ const isEqual = (objA, objB) => {
 function toggleJS(options) {
   if (options === null || options === void 0 ? void 0 : options.plainHtml) {
     return '';
-  }
-  else {
+  } else {
     return 'onclick="json-to-html.toggleVisibility(this);return false"';
   }
 }
+
 function makeLabelDiv(options, level, keyName, datatype) {
   if (typeof keyName === 'number') {
     return `<div class='index'><span class='json-to-html-label'>${keyName}&nbsp;</span></div>`;
-  }
-  else if (typeof keyName === 'string') {
+  } else if (typeof keyName === 'string') {
     if (datatype === 'array') {
       return `<div class='collapsible level${level}' ${toggleJS(options)}><span class='json-to-html-label'>${keyName}</span></div>`;
-    }
-    else if (datatype === 'object') {
+    } else if (datatype === 'object') {
       return `<div class='attribute collapsible level${level}' ${toggleJS(options)}><span class='json-to-html-label'>${keyName}:</span></div>`;
-    }
-    else {
+    } else {
       return `<div class='leaf level${level}'><span class='json-to-html-label'>${keyName}:</span></div>`;
     }
-  }
-  else {
+  } else {
     return '';
   }
 }
+
 function getContentClass(keyName) {
   if (typeof keyName === 'string') {
     return 'content';
-  }
-  else {
+  } else {
     return '';
   }
 }
+
 function isPlainObject(val) {
   let lastKey;
   let lastOwnKey;
@@ -101,8 +98,10 @@ function isPlainObject(val) {
   }
   return lastOwnKey === lastKey;
 }
+
 function isLeafValue(val) {
-  return (isNumber(val) ||
+  return (
+    isNumber(val) ||
     isString(val) ||
     isBoolean(val) ||
     isDate(val) ||
@@ -110,8 +109,10 @@ function isLeafValue(val) {
     isUndefined(val) ||
     isNaN(val) ||
     isFunction(val) ||
-    !isPlainObject(val));
+    !isPlainObject(val)
+  );
 }
+
 function isLeafObject(obj) {
   if (!isObject(obj)) {
     return false;
@@ -124,35 +125,37 @@ function isLeafObject(obj) {
   }
   return true;
 }
+
 function isTable(arr) {
   if (!isArray(arr)) {
     return false;
   }
   if (arr.length === 0 || !isObject(arr[0])) {
     return false;
-  }
-  else {
+  } else {
     let nonCompliant = arr.find(row => !isLeafObject(row));
     if (nonCompliant) {
       return false;
-    }
-    else {
+    } else {
       const cols = Object.keys(arr[0]);
-      nonCompliant = arr.find((row) => !isEqual(cols, Object.keys(row)));
+      nonCompliant = arr.find(row => !isEqual(cols, Object.keys(row)));
       return !nonCompliant;
     }
   }
 }
+
 function drawTable(arr) {
   function drawRow(headers, rowObj) {
     return '<td>' + headers.map(header => rowObj[header]).join('</td><td>') + '</td>';
   }
+
   const cols = Object.keys(arr[0]);
   const content = arr.map(rowObj => drawRow(cols, rowObj));
   const headingHtml = '<tr><th>' + cols.join('</th><th>') + '</th></tr>';
   const contentHtml = '<tr>' + content.join('</tr><tr>') + '</tr>';
   return '<table style="display: table; width:100%; table-layout: fixed;">' + headingHtml + contentHtml + '</table>';
 }
+
 function _render(name, data, options, level, altRow) {
   const contentClass = getContentClass(name);
   if (isArray(data)) {
@@ -160,8 +163,7 @@ function _render(name, data, options, level, altRow) {
     let subs;
     if (isTable(data)) {
       subs = drawTable(data);
-    }
-    else {
+    } else {
       subs =
         "<div class='altRows'>" +
         data
@@ -173,28 +175,24 @@ function _render(name, data, options, level, altRow) {
       ${title}
       <div class="${contentClass}">${subs}</div>
     </div>`;
-  }
-  else if (isLeafValue(data)) {
+  } else if (isLeafValue(data)) {
     const title = makeLabelDiv(options, level, name);
     if (isFunction(data)) {
       return `${title}<span class='json-to-html-value'>&nbsp;&nbsp;-function() can't _render-</span>`;
-    }
-    else if (!isPlainObject(data)) {
+    } else if (!isPlainObject(data)) {
       if (isFunction(data.toString)) {
         return `${title}<span class='json-to-html-value'>&nbsp;&nbsp;${data.toString()}</span>`;
-      }
-      else {
+      } else {
         return `${title}<span class='json-to-html-value'>&nbsp;&nbsp;-instance object, can't render-</span>`;
       }
-    }
-    else {
+    } else {
       return `${title}<span class='json-to-html-value'>&nbsp;&nbsp;${data}</span>`;
     }
-  }
-  else {
+  } else {
     const title = makeLabelDiv(options, level, name, 'object');
     let count = 0;
-    const subs = '<div>' +
+    const subs =
+      '<div>' +
       Object.entries(data)
         .map(([key, val]) => _render(key, val, options, level + 1, count++ % 2))
         .join('</div><div>') +
@@ -208,11 +206,11 @@ function _render(name, data, options, level, altRow) {
       ${level === 0 ? '</div>' : ''}`;
   }
 }
+
 export function render(name, json, options) {
   return `${_render(name, json, options, 0, 0)}`;
 }
 
-
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
@@ -225,6 +223,7 @@ function numberFix(num, decimalPlaces) {
     return num.toFixed(decimalPlaces);
   }
 }
+
 const ConsoleColor = {
   END: '\x1b[0m',
   BOLD: '\x1b[1m',
@@ -278,7 +277,6 @@ const getRelativePath = file => {
   return path.relative(__dirname, file);
 };
 const coloredLabeled = (label, file) => {
-
   const relativeFilePath = getRelativePath(file);
   const directory = path.dirname(relativeFilePath);
   const fileName = path.basename(relativeFilePath);
@@ -414,6 +412,7 @@ const composeReport = () => {
   fs.writeFileSync(htmlFilePath, html);
   console.log(`Performance ${BOLD}${GREEN}report${END} file generated in file://${BOLD}${GREEN}${htmlFilePath}${END}`);
 };
+
 function replaceMarkdownContent(startMarker, endMarker, newText) {
   const filePath = path.join(parentDirectory, 'README.md'); // Path to README.md file
   fs.readFile(filePath, 'utf8', (err, data) => {
@@ -440,6 +439,7 @@ function replaceMarkdownContent(startMarker, endMarker, newText) {
     });
   });
 }
+
 const sortedPerformanceTests = (
   isOnlyOrdered ? [...performanceTests].filter(test => runOrder.includes(test.testName)) : [...performanceTests]
 ).sort((a, b) => {

package/test/performance/runner-config.json

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

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

@@ -0,0 +1,69 @@
+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 name': benchmark.name,
+          'time taken (ms)': numberFix(benchmark.times.period * 1000, 2),
+          'sample mean (secs)': numberFix(benchmark.stats.mean, 2),
+          'sample deviation': numberFix(benchmark.stats.deviation, 2)
+        };
+      });
+      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/unit/data-structures/binary-tree/avl-tree-counter.test.ts

@@ -1,4 +1,4 @@
-import { AVLTreeCounter, AVLTreeCounterNode, AVLTreeNode, BinaryTreeNode, BSTNode } from '../../../../src';
+import { AVLTreeCounter, AVLTreeCounterNode, AVLTreeNode, BinaryTreeNode, BSTNode, IBinaryTree } from '../../../../src';
 import { isDebugTest } from '../../../config';
 
 const isDebug = isDebugTest;
@@ -571,7 +571,7 @@ describe('AVLTreeCounter Performance test', function () {
   });
 
   it('should the clone method', () => {
-    function checkTreeStructure(avlCounter: AVLTreeCounter<string, number>) {
+    function checkTreeStructure(avlCounter: IBinaryTree<string, number>) {
       expect(avlCounter.size).toBe(4);
       expect(avlCounter.root?.key).toBe('2');
       expect(avlCounter.root?.left?.key).toBe('1');
@@ -738,7 +738,7 @@ describe('AVLTreeCounter toEntryFn', () => {
           { obj: { id: 5 } }
         ])
     ).toThrowError(
-      `When comparing object types, a custom specifyComparable must be defined in the constructor's options parameter.`
+      `When comparing object types, a custom specifyComparable must be defined in the constructor's options.`
     );
   });
 

package/test/unit/data-structures/binary-tree/avl-tree-multi-map.test.ts

@@ -1,4 +1,4 @@
-import { AVLTreeMultiMap, AVLTreeMultiMapNode } from '../../../../src';
+import { AVLTreeMultiMap, AVLTreeMultiMapNode, IBinaryTree } from '../../../../src';
 // import { isDebugTest } from '../../../config';
 
 // const isDebug = isDebugTest;
@@ -70,7 +70,7 @@ describe('AVLTreeMultiMap Test', () => {
 
     expect(avlTmm.delete(avlTmm.getNode(11))[0].deleted?.key).toBe(11);
     expect(avlTmm.isAVLBalanced()).toBe(true);
-    expect(node15 && avlTmm.getHeight(node15)).toBe(2);
+    expect(node15 && avlTmm.getHeight(node15)).toBe(1);
 
     expect(avlTmm.delete(1)[0].deleted?.key).toBe(1);
     expect(avlTmm.isAVLBalanced()).toBe(true);
@@ -198,7 +198,7 @@ describe('AVLTreeMultiMap Test recursively', () => {
 
     expect(avlTmm.delete(11)[0].deleted?.key).toBe(11);
     expect(avlTmm.isAVLBalanced()).toBe(true);
-    expect(node15 && avlTmm.getHeight(node15)).toBe(2);
+    expect(node15 && avlTmm.getHeight(node15)).toBe(1);
 
     expect(avlTmm.delete(1)[0].deleted?.key).toBe(1);
     expect(avlTmm.isAVLBalanced()).toBe(true);
@@ -286,7 +286,7 @@ describe('AVLTreeMultiMap APIs test', () => {
   });
 
   it('should the clone method', () => {
-    function checkTreeStructure(avlTmm: AVLTreeMultiMap<string, number>) {
+    function checkTreeStructure(avlTmm: IBinaryTree<string, number[]>) {
       expect(avlTmm.size).toBe(4);
       expect(avlTmm.root?.key).toBe('2');
       expect(avlTmm.root?.left?.key).toBe('1');
@@ -399,7 +399,7 @@ describe('AVLTreeMultiMap', () => {
 });
 
 describe('AVLTreeMultiMap iterative methods test', () => {
-  let avlTmm: AVLTreeMultiMap<number, string, object, string, string, object>;
+  let avlTmm: AVLTreeMultiMap<number, string, object>;
   beforeEach(() => {
     avlTmm = new AVLTreeMultiMap();
     avlTmm.add([1, ['a']]);

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

@@ -1,4 +1,4 @@
-import { AVLTree, AVLTreeNode, BinaryTreeNode, BSTNode } from '../../../../src';
+import { AVLTree, AVLTreeNode, BinaryTreeNode, BSTNode, IBinaryTree } from '../../../../src';
 
 describe('AVL Tree Test', () => {
   it('should perform various operations on a AVL Tree', () => {
@@ -44,7 +44,7 @@ describe('AVL Tree Test', () => {
 
     expect(avlTree.delete(avlTree.getNode(11))[0].deleted?.key).toBe(11);
     expect(avlTree.isAVLBalanced()).toBe(true);
-    expect(node15 && avlTree.getHeight(node15)).toBe(2);
+    expect(node15 && avlTree.getHeight(node15)).toBe(1);
 
     expect(avlTree.delete(1)[0].deleted?.key).toBe(1);
     expect(avlTree.isAVLBalanced()).toBe(true);
@@ -172,7 +172,7 @@ describe('AVL Tree Test recursively', () => {
 
     expect(avlTree.delete(11)[0].deleted?.key).toBe(11);
     expect(avlTree.isAVLBalanced()).toBe(true);
-    expect(node15 && avlTree.getHeight(node15)).toBe(2);
+    expect(node15 && avlTree.getHeight(node15)).toBe(1);
 
     expect(avlTree.delete(1)[0].deleted?.key).toBe(1);
     expect(avlTree.isAVLBalanced()).toBe(true);
@@ -258,7 +258,7 @@ describe('AVLTree APIs test', () => {
   });
 
   it('should the clone method', () => {
-    function checkTreeStructure(avlTree: AVLTree<string, number>) {
+    function checkTreeStructure(avlTree: IBinaryTree<string, number>) {
       expect(avlTree.size).toBe(4);
       expect(avlTree.root?.key).toBe('2');
       expect(avlTree.root?.left?.key).toBe('1');