data-structure-typed 1.41.3 → 1.41.4

package/test/unit/data-structures/matrix/matrix2d.test.ts

@@ -315,7 +315,7 @@ describe('Matrix2D', () => {
   it('should correctly rotate a matrix', () => {
     const radians = Math.PI / 4; // 45 degrees
     const rotationMatrix = Matrix2D.rotate(radians);
-    console.log(JSON.stringify(rotationMatrix.m));
+    isDebug && console.log(JSON.stringify(rotationMatrix.m));
     expect(rotationMatrix.m).toEqual([
       [0.7071067811865476, -0.7071067811865475, 0],
       [0.7071067811865475, 0.7071067811865476, 0],

package/test/unit/data-structures/priority-queue/max-priority-queue.test.ts

@@ -1,5 +1,4 @@
 import {MaxPriorityQueue} from '../../../../src';
-import {bigO, magnitude} from '../../../utils';
 
 describe('MaxPriorityQueue Operation Test', () => {
   it('should add elements and maintain heap property', () => {
@@ -72,34 +71,3 @@ describe('MaxPriorityQueue Operation Test', () => {
     expect(maxPQ.poll()?.keyA).toBe(1);
   });
 });
-
-describe('MaxPriorityQueue Performance Test', () => {
-  it('should the poll method adheres to a time complexity of O(log n) and executed correctly under large scale distinct data', () => {
-    const nodes = Array.from(
-      new Set<number>(Array.from(new Array(magnitude.LINEAR), () => Math.floor(Math.random() * magnitude.LINEAR * 100)))
-    );
-    expect(nodes.length).toBeGreaterThan(magnitude.LINEAR / 2);
-    const maxPQ = new MaxPriorityQueue<number>();
-    maxPQ.refill(nodes);
-    let prev = Number.MAX_SAFE_INTEGER;
-    const startTime = performance.now();
-    while (maxPQ.size > 0) {
-      const polled = maxPQ.poll();
-      if (polled) {
-        prev = polled;
-      }
-    }
-    const cost = performance.now() - startTime;
-    expect(cost).toBeLessThan(bigO.LINEAR * 30);
-    expect(prev).toBeGreaterThan(0);
-  });
-
-  it('should sorted.length to be the same as original data', () => {
-    // const magnitude = 1000;
-    // const maxPriorityQueue = new MaxPriorityQueue<number>({nodes: Array.from(new Array<number>(magnitude), () => Math.floor(Math.random() * magnitude))});
-    // const nodeCount = maxPriorityQueue.getNodes().length;
-    // const sorted = maxPriorityQueue.sort();
-    //
-    // expect(sorted.length).toBe(nodeCount); // TODO Plan to support sorting of duplicate elements.
-  });
-});

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

@@ -1,5 +1,5 @@
 import {PriorityQueue} from '../../../../src';
-import {getRandomInt} from '../../../utils';
+import {randomInt} from '../../../utils';
 
 describe('PriorityQueue Operation Test', () => {
   it('should PriorityQueue poll, pee, heapify, toArray work well', function () {
@@ -44,7 +44,7 @@ describe('PriorityQueue Operation Test', () => {
 
 describe('Priority Queue Performance Test', () => {
   it('should numeric heap work well', function () {
-    const values = Array.from(new Array(10000), () => getRandomInt(1, 10000000));
+    const values = Array.from(new Array(10000), () => randomInt(1, 10000000));
     const minPriorityQueue = new PriorityQueue<number>({comparator: (a, b) => a - b});
     minPriorityQueue.refill(values);
     const sorted = minPriorityQueue.sort();

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

@@ -1,5 +1,5 @@
 import {LinkedListQueue, Queue} from '../../../../src';
-import {bigO, magnitude} from '../../../utils';
+import {bigO} from '../../../utils';
 import {isDebugTest} from '../../../config';
 
 const isDebug = isDebugTest;
@@ -17,23 +17,6 @@ describe('Queue Operation Test', () => {
   });
 });
 
-describe('Queue Performance Test', () => {
-  it('should numeric queue performance well', function () {
-    const queue = new Queue<number>();
-    for (let i = 0; i < magnitude.LINEAR; i++) {
-      queue.enqueue(i);
-    }
-    let last: number | undefined = 0;
-
-    const startTime = performance.now();
-    for (let i = 0; i < magnitude.LINEAR; i++) {
-      last = queue.dequeue();
-    }
-    expect(last).toBe(magnitude.LINEAR - 1);
-    expect(performance.now() - startTime).toBeLessThan(bigO.LINEAR * 100);
-  });
-});
-
 describe('Queue', () => {
   let queue: Queue<number>;
 
@@ -51,24 +34,8 @@ describe('Queue', () => {
     expect(queue.peek()).toBe(1);
     expect(queue.size).toBe(2);
   });
-
-  // it('should shift elements from the front of the queue', () => {
-  //   queue.push(1);
-  //   queue.push(2);
-  //   const shifted = queue.shift();
-  //   expect(shifted).toBe(1);
-  //   expect(queue.peek()).toBe(2);
-  //   expect(queue.size).toBe(1);
-  // });
-  //
-  // it('should peek at the front of the queue', () => {
-  //   queue.push(1);
-  //   queue.push(2);
-  //   expect(queue.peek()).toBe(1);
-  // });
-
-  // Add more test cases for other methods of Queue.
 });
+
 describe('Queue', () => {
   let queue: Queue<number>;
 
@@ -196,8 +163,6 @@ describe('LinkedListQueue', () => {
     queue.enqueue('B');
     expect(queue.peek()).toBe('A');
   });
-
-  // Add more test cases for other methods of LinkedListQueue.
 });
 
 describe('Queue Performance Test', () => {
@@ -224,7 +189,6 @@ describe('Queue Performance Test', () => {
     for (let i = 0; i < dataSize; i++) {
       queue2.shift();
     }
-    console.log(`Array Performance Test: ${performance.now() - startTime2} ms`);
     expect(performance.now() - startTime2).toBeLessThan(bigO.CUBED * 100);
   });
 
@@ -237,7 +201,7 @@ describe('Queue Performance Test', () => {
     for (let i = 0; i < dataSize; i++) {
       queue.dequeue();
     }
-    console.log(`LinkedListQueue Performance Test: ${performance.now() - startTime} ms`);
+    // console.log(`LinkedListQueue Performance Test: ${performance.now() - startTime} ms`);
     expect(performance.now() - startTime).toBeLessThan(bigO.LINEAR * 100);
   });
 });

package/test/utils/array.ts

@@ -0,0 +1,5 @@
+import {randomInt} from './number';
+
+export const randomIntArray = (length: number, min: number = -1000, max: number = 1000) => {
+  return new Array<number>(length).fill(0).map(() => randomInt(min, max));
+};

package/test/utils/big-o.ts

@@ -2,15 +2,15 @@ import {AnyFunction} from '../types';
 import {isDebugTest} from '../config';
 
 const isDebug = isDebugTest;
-const orderReducedBy = 2; // reduction of bigO's order compared to the baseline bigO
+const orderReducedBy = 1; // reduction of bigO's order compared to the baseline bigO
 
 export const magnitude = {
-  CONSTANT: Math.floor(Number.MAX_SAFE_INTEGER / Math.pow(10, orderReducedBy)),
-  LOG_N: Math.pow(10, 9 - orderReducedBy),
-  LINEAR: Math.pow(10, 6 - orderReducedBy),
-  N_LOG_N: Math.pow(10, 5 - orderReducedBy),
-  SQUARED: Math.pow(10, 4 - orderReducedBy),
-  CUBED: Math.pow(10, 3 - orderReducedBy),
+  CONSTANT: Math.pow(10, 9),
+  LOG_N: Math.pow(10, 8 - orderReducedBy),
+  LINEAR: Math.pow(10, 7 - orderReducedBy),
+  N_LOG_N: Math.pow(10, 4 - orderReducedBy),
+  SQUARED: Math.pow(10, 3 - orderReducedBy),
+  CUBED: Math.pow(10, 2 - orderReducedBy),
   FACTORIAL: 20 - orderReducedBy
 };
 

package/test/utils/console.ts

@@ -0,0 +1,30 @@
+export const Color = {
+  END: '\x1b[0m',
+  BOLD: '\x1b[1m',
+  DIM: '\x1b[2m',
+  ITALIC: '\x1b[3m',
+  UNDERLINE: '\x1b[4m',
+  INVERSE: '\x1b[7m',
+  STRIKETHROUGH: '\x1b[9m',
+  NO_BOLD: '\x1b[22m',
+  NO_ITALIC: '\x1b[23m',
+  NO_UNDERLINE: '\x1b[24m',
+  NO_INVERSE: '\x1b[27m',
+  NO_STRIKETHROUGH: '\x1b[29m',
+  BLACK: '\x1b[30m',
+  RED: '\x1b[31m',
+  GREEN: '\x1b[32m',
+  YELLOW: '\x1b[33m',
+  BLUE: '\x1b[34m',
+  MAGENTA: '\x1b[35m',
+  CYAN: '\x1b[36m',
+  WHITE: '\x1b[37m',
+  BG_BLACK: '\x1b[40m',
+  BG_RED: '\x1b[41m',
+  BG_GREEN: '\x1b[42m',
+  BG_YELLOW: '\x1b[43m',
+  BG_BLUE: '\x1b[44m',
+  BG_MAGENTA: '\x1b[45m',
+  BG_CYAN: '\x1b[46m',
+  BG_WHITE: '\x1b[47m'
+};

package/test/utils/index.ts

@@ -1,2 +1,6 @@
 export * from './number';
+export * from './array';
 export * from './big-o';
+export * from './json2html';
+export * from './is';
+export * from './console';

package/test/utils/is.ts

@@ -0,0 +1,56 @@
+export const isNumber = (value: any) => {
+  return typeof value === 'number';
+};
+export const isString = (value: any) => {
+  return typeof value === 'string';
+};
+export const isBoolean = (value: any) => {
+  return typeof value === 'boolean';
+};
+export const isDate = (value: any) => {
+  return value instanceof Date;
+};
+export const isNull = (value: any) => {
+  return value === null;
+};
+export const isUndefined = (value: any) => {
+  return typeof value === 'undefined';
+};
+export const isFunction = (value: any) => {
+  return typeof value === 'function';
+};
+export const isObject = (value: any) => {
+  return typeof value === 'object';
+};
+export const isArray = (value: any) => {
+  return Array.isArray(value);
+};
+
+export const isEqual = (objA: any, objB: any): boolean => {
+  if (objA === objB) {
+    return true;
+  }
+
+  if (typeof objA !== 'object' || typeof objB !== 'object' || objA === null || objB === null) {
+    return false;
+  }
+
+  const keysA = Object.keys(objA);
+  const keysB = Object.keys(objB);
+
+  if (keysA.length !== keysB.length) {
+    return false;
+  }
+
+  for (const key of keysA) {
+    if (!keysB.includes(key)) {
+      return false;
+    }
+
+    if (!isEqual(objA[key], objB[key])) {
+      return false;
+    }
+  }
+
+  return true;
+};

package/test/utils/json2html.ts

@@ -0,0 +1,322 @@
+import * as _ from './is';
+import {Json2htmlOptions} from '../types';
+
+function toggleJS(options?: Json2htmlOptions): string {
+  if (options?.plainHtml) {
+    return '';
+  } else {
+    return 'onclick="json-to-html.toggleVisibility(this);return false"';
+  }
+}
+
+function makeLabelDiv(options: any, level: number, keyName: string | number, datatype?: string): string {
+  if (typeof keyName === 'number') {
+    return `<div class='index'><span class='json-to-html-label'>${keyName}&nbsp;</span></div>`;
+  } 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') {
+      return `<div class='attribute collapsible level${level}' ${toggleJS(
+        options
+      )}><span class='json-to-html-label'>${keyName}:</span></div>`;
+    } else {
+      return `<div class='leaf level${level}'><span class='json-to-html-label'>${keyName}:</span></div>`;
+    }
+  } else {
+    return '';
+  }
+}
+
+function getContentClass(keyName: string | number): string {
+  if (typeof keyName === 'string') {
+    return 'content';
+  } else {
+    return '';
+  }
+}
+
+function isPlainObject(val: any): boolean {
+  let lastKey: string | undefined;
+  let lastOwnKey: string | undefined;
+  for (const key in val) {
+    if (val.hasOwnProperty(key)) {
+      lastOwnKey = key;
+    }
+  }
+  for (const key in val) {
+    lastKey = key;
+  }
+  return lastOwnKey === lastKey;
+}
+
+function isLeafValue(val: any): boolean {
+  return (
+    _.isNumber(val) ||
+    _.isString(val) ||
+    _.isBoolean(val) ||
+    _.isDate(val) ||
+    _.isNull(val) ||
+    _.isUndefined(val) ||
+    isNaN(val) ||
+    _.isFunction(val) ||
+    !isPlainObject(val)
+  );
+}
+
+function isLeafObject(obj: any): boolean {
+  if (!_.isObject(obj)) {
+    return false;
+  }
+  for (const key in obj) {
+    const val = obj[key];
+    if (!isLeafValue(val)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function isTable(arr: any[]): boolean {
+  if (!_.isArray(arr)) {
+    return false;
+  }
+  if (arr.length === 0 || !_.isObject(arr[0])) {
+    return false;
+  } else {
+    let nonCompliant = arr.find(row => !isLeafObject(row));
+    if (nonCompliant) {
+      return false;
+    } else {
+      const cols = Object.keys(arr[0]);
+      nonCompliant = arr.find((row: object) => !_.isEqual(cols, Object.keys(row)));
+      if (nonCompliant) {
+        return false;
+      } else {
+        return true;
+      }
+    }
+  }
+}
+
+function drawTable(arr: any[]): string {
+  function drawRow(headers: string[], rowObj: any): string {
+    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>' + headingHtml + contentHtml + '</table>';
+}
+
+function _render(name: string, data: any, options: Json2htmlOptions, level: number, altRow: number): string {
+  const contentClass = getContentClass(name);
+  if (_.isArray(data)) {
+    const title = makeLabelDiv(options, level, `${name}`, 'array');
+    let subs: string;
+    if (isTable(data)) {
+      subs = drawTable(data);
+    } else {
+      subs =
+        "<div class='altRows'>" +
+        data
+          .map((val: any, idx: number) => _render(idx.toString(), val, options, level + 1, idx % 2))
+          .join("</div><div class='altRows'>") +
+        '</div>';
+    }
+    return `<div class="json-to-html-collapse clearfix ${altRow}">
+      ${title}
+      <div class="${contentClass}">${subs}</div>
+    </div>`;
+  } 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)) {
+      if (_.isFunction(data.toString)) {
+        return `${title}<span class='json-to-html-value'>&nbsp;&nbsp;${data.toString()}</span>`;
+      } else {
+        return `${title}<span class='json-to-html-value'>&nbsp;&nbsp;-instance object, can't render-</span>`;
+      }
+    } else {
+      return `${title}<span class='json-to-html-value'>&nbsp;&nbsp;${data}</span>`;
+    }
+  } else {
+    const title = makeLabelDiv(options, level, name, 'object');
+    let count = 0;
+    const subs =
+      '<div>' +
+      Object.entries(data)
+        .map(([key, val]) => _render(key, val, options, level + 1, count++ % 2))
+        .join('</div><div>') +
+      '</div>';
+    const inner = `<div class="json-to-html-expand clearfix ${altRow}">
+      ${title}
+      <div class="${contentClass}">${subs}</div>
+    </div>`;
+    return `${level === 0 ? "<div id='json-to-html'>" : ''}
+      ${inner}
+      ${level === 0 ? '</div>' : ''}`;
+  }
+}
+
+export function render(name: string, json: any, options: Json2htmlOptions): string {
+  // return `${head}${_render('', json, options, 0, 0)}`;
+  return `${_render(name, json, options, 0, 0)}`;
+}
+
+// const head = `<style>
+// #json-to-html table {
+//   border-collapse: collapse;
+// }
+// #json-to-html th {
+//   color: #888;
+// }
+// #json-to-html table,th, td {
+//   border: 1px solid #DDD;
+//   padding: 10px 5px;
+// }
+// #json-to-html th, td {
+//   text-align: center;
+// }
+// #json-to-html .content {
+//   padding-left: 30px;
+//   font-family: Arial;
+// }
+//
+// #json-to-html .index {
+//   font-size: 100%;
+//   color: #999;
+//   float: left;
+// }
+// #json-to-html  .clearfix:after {
+//   content: ".";
+//   display: block;
+//   height: 0;
+//   clear: both;
+//   visibility: hidden;
+// }
+// #json-to-html  .json-to-html-label {
+//   font-family: Helvetica Neue;
+//   color: #333;
+// }
+// #json-to-html  .json-to-html-value {
+//   font-family: Arial;
+//   color: #777;
+// }
+// #json-to-html .collapsible > .json-to-html-label:hover {
+//   text-decoration: underline;
+// }
+// #json-to-html .collapsible > .json-to-html-label {
+//   color: #15C;
+// }
+// #json-to-html  .json-to-html-collapse > div.content {
+//   display: none;
+// }
+// #json-to-html  .json-to-html-collapse > .json-to-html-label {
+//   font-weight: bold;
+// }
+//
+// #json-to-html .json-to-html-expand  > div > .json-to-html-label, #json-to-html .json-to-html-collapse  > div > .json-to-html-label {
+//   background-repeat: no-repeat;
+//   background-position: left;
+//   padding-left: 25px;
+//   margin: 5px 0px 5px 15px;
+//   display: inline-block;
+// }
+//
+// #json-to-html .json-to-html-expand  > div > .json-to-html-label {
+//     width: 30px;
+//   height: 30px;
+//   background-image: url('data:image/svg+xml;utf8,<svg xmlns="http://www.w3.org/2000/svg" width="100" height="100"><polygon points="50,10 10,90 90,90" fill="blue" /></svg>');
+//   background-size: cover;
+//   background-position: center;
+// }
+//
+// #json-to-html .json-to-html-collapse > div > .json-to-html-label {
+//       width: 30px;
+//   height: 30px;
+//   background-image: url('data:image/svg+xml;utf8,<svg xmlns="http://www.w3.org/2000/svg" width="100" height="100"><polygon points="50,10 10,90 90,90" fill="blue" /></svg>');
+//   background-size: cover;
+//   background-position: center;
+// }
+//
+// #json-to-html .json-to-html-collapse > span.collapsible:before {
+//   border-radius: 2px;
+//   border-color: #A44;
+//   border-style: solid;
+//   border-width: 1px;
+//   color: #A44;
+//   content: '+';
+//   display: inline-block;
+//   line-height: 7px;
+//   margin: 0 2px;
+//   overflow: hidden;
+//   padding: 1px;
+//   font-size: 11px;
+// }
+//
+// #json-to-html .json-to-html-expand > span.collapsible:before {
+//   border: none;
+//   color: #A44;
+//   content: '-';
+//   display: inline-block;
+//   line-height: 7px;
+//   margin: 4px;
+//   overflow: hidden;
+//   padding: 1px;
+//   font-size: 11px;
+// }
+//
+// #json-to-html.level0 {
+//   font-size: 25px;
+// }
+// #json-to-html  .level1 {
+//   font-size: 22px;
+// }
+//
+// #json-to-html .leaf {
+//   color: #666;
+//   display: inline;
+// }
+//
+// #json-to-html .altRows:nth-child(odd)    { background-color:#ddd; }
+// #json-to-html .altRows:nth-child(even)    { background-color:#fff; }
+//
+// #json-to-html tr:nth-child(odd)    { background-color:#eee; }
+// #json-to-html tr:nth-child(even)    { background-color:#fff; }
+// </style>
+// <script type="text/javascript">
+//   json-to-html = {
+//     toggleVisibility: function(el, name) {
+//       json-to-html.toggleClass(el.parentElement,'json-to-html-collapse json-to-html-expand');
+//     },
+//     classRe: function(name) {
+//       return new RegExp('(?:^|\\s)'+name+'(?!\\S)');
+//     },
+//     addClass: function(el, name) {
+//       el.className += " "+name;
+//     },
+//     removeClass: function(el, name) {
+//       var re = json-to-html.classRe(name);
+//       el.className  = el.className.replace(json-to-html.classRe(name) , '' )
+//     },
+//     hasClass: function(el, name) {
+//       var re = json-to-html.classRe(name);
+//       return json-to-html.classRe(name).exec(el.className);
+//     },
+//     toggleClass: function(el, name) {
+//       var names = name.split(/\s+/);
+//       for (n in names) {
+//         if (json-to-html.hasClass(el, names[n])) {
+//           json-to-html.removeClass(el, names[n]);
+//         } else {
+//           json-to-html.addClass(el, names[n]);
+//         }
+//       }
+//     }
+//   };
+// </script>`;

package/test/utils/number.ts

@@ -1,3 +1,13 @@
-export function getRandomInt(min: number, max: number) {
+export function randomInt(min: number, max: number) {
   return Math.floor(Math.random() * (max - min + 1)) + min;
 }
+
+export function numberFix(num: number, decimalPlaces: number): string {
+  if (num > 10000 || num < 0.001) {
+    const [mantissa, exponent] = num.toExponential().split('e');
+    const formattedMantissa = Number(mantissa).toFixed(decimalPlaces);
+    return `${formattedMantissa}e${exponent}`;
+  } else {
+    return num.toFixed(decimalPlaces);
+  }
+}

package/test/config.js

@@ -1,4 +0,0 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', {value: true});
-exports.isDebugTest = void 0;
-exports.isDebugTest = false;

package/test/performance/index.ts

@@ -1,47 +0,0 @@
-import * as Benchmark from 'benchmark';
-import * as path from 'path';
-import * as fs from 'fs';
-import * as fastGlob from 'fast-glob';
-
-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 i = 0;
-testFiles.forEach((file: string) => {
-  i++;
-  console.log(`testing file ${file}`);
-  const testName = path.basename(file, '.test.ts');
-  const testFunction = require(file);
-  const {suite} = testFunction;
-
-  if (suite) {
-    suite.on('cycle', (event: any) => {
-      console.log(String(event.target));
-    });
-
-    suite.on('complete', function (this: Benchmark.Suite) {
-      console.log('Fastest is ' + this.filter('fastest').map('name'));
-      report[testName] = this.map((test: Benchmark) => ({
-        name: test.name,
-        periodMS: test.times.period * 1000,
-        hz: test.hz,
-        count: test.count,
-        mean: test.stats.mean,
-        deviation: test.stats.deviation,
-      }));
-      // report[testName] = this;
-      console.log('----i', i, testFiles.length)
-      if (testFiles.length === i) {
-        if (!fs.existsSync(reportDistPath)) fs.mkdirSync(reportDistPath, { recursive: true });
-
-        const filePath = path.join(reportDistPath, 'report.json');
-        fs.writeFileSync(filePath, JSON.stringify(report, null, 2));
-        console.log('Performance test report file generated')
-      }
-    })
-      .run({async: true});
-  }
-});