data-structure-typed 1.44.1 → 1.45.1

package/test/performance/data-structures/binary-tree/bst.test.ts

@@ -1,10 +1,10 @@
-import {BST} from '../../../../src';
+import { BST } from '../../../../src';
 import * as Benchmark from 'benchmark';
-import {getRandomIntArray, magnitude} from '../../../utils';
+import { getRandomIntArray, magnitude } from '../../../utils';
 
 const suite = new Benchmark.Suite();
 const bst = new BST<number>();
-const {TEN_THOUSAND} = magnitude;
+const { TEN_THOUSAND } = magnitude;
 const arr = getRandomIntArray(TEN_THOUSAND, 0, TEN_THOUSAND, true);
 
 suite
@@ -33,4 +33,4 @@ suite
     }
   });
 
-export {suite};
+export { suite };

package/test/performance/data-structures/binary-tree/rb-tree.test.ts

@@ -1,12 +1,12 @@
-import {RedBlackTree} from '../../../../src';
+import { RedBlackTree } from '../../../../src';
 import * as Benchmark from 'benchmark';
-import {getRandomIntArray, magnitude} from '../../../utils';
-import {OrderedMap} from 'js-sdsl';
-import {isCompetitor} from '../../../config';
+import { getRandomIntArray, magnitude } from '../../../utils';
+import { OrderedMap } from 'js-sdsl';
+import { isCompetitor } from '../../../config';
 
 const suite = new Benchmark.Suite();
 const rbTree = new RedBlackTree();
-const {HUNDRED_THOUSAND} = magnitude;
+const { HUNDRED_THOUSAND } = magnitude;
 const arr = getRandomIntArray(HUNDRED_THOUSAND, 0, HUNDRED_THOUSAND, true);
 const competitor = new OrderedMap<number, number>();
 
@@ -41,4 +41,4 @@ suite
     }
   });
 
-export {suite};
+export { suite };

package/test/performance/data-structures/graph/directed-graph.test.ts

@@ -1,9 +1,9 @@
-import {DirectedGraph} from '../../../../src';
+import { DirectedGraph } from '../../../../src';
 import * as Benchmark from 'benchmark';
-import {getRandomIndex, getRandomWords, magnitude} from '../../../utils';
+import { getRandomIndex, getRandomWords, magnitude } from '../../../utils';
 
 const suite = new Benchmark.Suite();
-const {THOUSAND} = magnitude;
+const { THOUSAND } = magnitude;
 const graph = new DirectedGraph<number, number>();
 const vertexes = getRandomWords(THOUSAND);
 
@@ -46,4 +46,4 @@ suite
     // }
   });
 
-export {suite};
+export { suite };

package/test/performance/data-structures/hash/hash-map.test.ts

@@ -1,11 +1,11 @@
-import {HashMap} from '../../../../src';
-import {HashMap as CHashMap} from 'js-sdsl';
+import { HashMap } from '../../../../src';
+import { HashMap as CHashMap } from 'js-sdsl';
 import * as Benchmark from 'benchmark';
-import {magnitude} from '../../../utils';
-import {isCompetitor} from '../../../config';
+import { magnitude } from '../../../utils';
+import { isCompetitor } from '../../../config';
 
 const suite = new Benchmark.Suite();
-const {TEN_THOUSAND} = magnitude;
+const { TEN_THOUSAND } = magnitude;
 
 suite.add(`${TEN_THOUSAND.toLocaleString()} set`, () => {
   const hm = new HashMap<number, number>();
@@ -45,4 +45,4 @@ if (isCompetitor) {
     }
   });
 }
-export {suite};
+export { suite };

package/test/performance/data-structures/heap/heap.test.ts

@@ -1,13 +1,13 @@
-import {FibonacciHeap, Heap} from '../../../../src';
+import { FibonacciHeap, Heap } from '../../../../src';
 import * as Benchmark from 'benchmark';
-import {magnitude} from '../../../utils';
+import { magnitude } from '../../../utils';
 
 const suite = new Benchmark.Suite();
-const {TEN_THOUSAND} = magnitude;
+const { TEN_THOUSAND } = magnitude;
 
 suite
   .add(`${TEN_THOUSAND.toLocaleString()} add & pop`, () => {
-    const heap = new Heap<number>({comparator: (a, b) => b - a});
+    const heap = new Heap<number>({ comparator: (a, b) => b - a });
 
     for (let i = 0; i < TEN_THOUSAND; i++) {
       heap.add(i);
@@ -27,4 +27,4 @@ suite
     }
   });
 
-export {suite};
+export { suite };

package/test/performance/data-structures/linked-list/doubly-linked-list.test.ts

@@ -1,11 +1,11 @@
-import {DoublyLinkedList, DoublyLinkedListNode} from '../../../../src';
-import {LinkList as CLinkedList} from 'js-sdsl';
+import { DoublyLinkedList, DoublyLinkedListNode } from '../../../../src';
+import { LinkList as CLinkedList } from 'js-sdsl';
 import * as Benchmark from 'benchmark';
-import {magnitude} from '../../../utils';
-import {isCompetitor} from '../../../config';
+import { magnitude } from '../../../utils';
+import { isCompetitor } from '../../../config';
 
 const suite = new Benchmark.Suite();
-const {LINEAR} = magnitude;
+const { LINEAR } = magnitude;
 
 suite.add(`${LINEAR.toLocaleString()} unshift`, () => {
   const list = new DoublyLinkedList<number>();
@@ -48,4 +48,4 @@ suite
     }
   });
 
-export {suite};
+export { suite };

package/test/performance/data-structures/linked-list/singly-linked-list.test.ts

@@ -1,9 +1,9 @@
-import {SinglyLinkedList, SinglyLinkedListNode} from '../../../../src';
+import { SinglyLinkedList, SinglyLinkedListNode } from '../../../../src';
 import * as Benchmark from 'benchmark';
-import {magnitude} from '../../../utils';
+import { magnitude } from '../../../utils';
 
 const suite = new Benchmark.Suite();
-const {TEN_THOUSAND} = magnitude;
+const { TEN_THOUSAND } = magnitude;
 
 suite
   .add(`${TEN_THOUSAND.toLocaleString()} push & pop`, () => {
@@ -31,4 +31,4 @@ suite
     }
   });
 
-export {suite};
+export { suite };

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

@@ -1,12 +1,14 @@
-import {MaxPriorityQueue} from '../../../../src';
+import { MaxPriorityQueue } from '../../../../src';
 import * as Benchmark from 'benchmark';
-import {magnitude} from '../../../utils';
+import { magnitude } from '../../../utils';
 
 const suite = new Benchmark.Suite();
-const {TEN_THOUSAND} = magnitude;
+const { TEN_THOUSAND } = magnitude;
 
 suite.add(`${TEN_THOUSAND.toLocaleString()} refill & poll`, () => {
-  const nodes = Array.from(new Set<number>(Array.from(new Array(TEN_THOUSAND), () => Math.floor(Math.random() * TEN_THOUSAND * 100))));
+  const nodes = Array.from(
+    new Set<number>(Array.from(new Array(TEN_THOUSAND), () => Math.floor(Math.random() * TEN_THOUSAND * 100)))
+  );
   const maxPQ = new MaxPriorityQueue<number>();
   maxPQ.refill(nodes);
   while (maxPQ.size > 0) {
@@ -14,4 +16,4 @@ suite.add(`${TEN_THOUSAND.toLocaleString()} refill & poll`, () => {
   }
 });
 
-export {suite};
+export { suite };

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

@@ -1,14 +1,14 @@
-import {PriorityQueue as CPriorityQueue} from 'js-sdsl';
-import {PriorityQueue} from '../../../../src';
+import { PriorityQueue as CPriorityQueue } from 'js-sdsl';
+import { PriorityQueue } from '../../../../src';
 import * as Benchmark from 'benchmark';
-import {magnitude} from '../../../utils';
-import {isCompetitor} from '../../../config';
+import { magnitude } from '../../../utils';
+import { isCompetitor } from '../../../config';
 
 const suite = new Benchmark.Suite();
-const {TEN_THOUSAND} = magnitude;
+const { TEN_THOUSAND } = magnitude;
 
 suite.add(`${TEN_THOUSAND.toLocaleString()} add & pop`, () => {
-  const pq = new PriorityQueue<number>({comparator: (a, b) => b - a});
+  const pq = new PriorityQueue<number>({ comparator: (a, b) => b - a });
 
   for (let i = 0; i < TEN_THOUSAND; i++) {
     pq.add(i);
@@ -32,4 +32,4 @@ if (isCompetitor) {
   });
 }
 
-export {suite};
+export { suite };

package/test/performance/data-structures/queue/deque.test.ts

@@ -1,11 +1,11 @@
-import {Deque} from '../../../../src';
-import {Deque as CDeque} from 'js-sdsl';
+import { Deque } from '../../../../src';
+import { Deque as CDeque } from 'js-sdsl';
 import * as Benchmark from 'benchmark';
-import {magnitude} from '../../../utils';
-import {isCompetitor} from '../../../config';
+import { magnitude } from '../../../utils';
+import { isCompetitor } from '../../../config';
 
 export const suite = new Benchmark.Suite();
-const {LINEAR} = magnitude;
+const { LINEAR } = magnitude;
 
 suite.add(`${LINEAR.toLocaleString()} push`, () => {
   const deque = new Deque<number>();

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

@@ -1,11 +1,11 @@
-import {Queue} from '../../../../src';
-import {Queue as CQueue} from 'js-sdsl';
+import { Queue } from '../../../../src';
+import { Queue as CQueue } from 'js-sdsl';
 import * as Benchmark from 'benchmark';
-import {magnitude} from '../../../utils';
-import {isCompetitor} from '../../../config';
+import { magnitude } from '../../../utils';
+import { isCompetitor } from '../../../config';
 
 const suite = new Benchmark.Suite();
-const {LINEAR} = magnitude;
+const { LINEAR } = magnitude;
 
 suite.add(`${LINEAR.toLocaleString()} push`, () => {
   const queue = new Queue<number>();
@@ -32,4 +32,4 @@ suite.add(`${LINEAR.toLocaleString()} push & shift`, () => {
   }
 });
 
-export {suite};
+export { suite };

package/test/performance/data-structures/stack/stack.test.ts

@@ -1,11 +1,11 @@
-import {Stack} from '../../../../src';
-import {Stack as CStack} from 'js-sdsl';
+import { Stack } from '../../../../src';
+import { Stack as CStack } from 'js-sdsl';
 import * as Benchmark from 'benchmark';
-import {magnitude} from '../../../utils';
-import {isCompetitor} from '../../../config';
+import { magnitude } from '../../../utils';
+import { isCompetitor } from '../../../config';
 
 const suite = new Benchmark.Suite();
-const {LINEAR} = magnitude;
+const { LINEAR } = magnitude;
 
 suite.add(`${LINEAR.toLocaleString()} push`, () => {
   const stack = new Stack<number>();
@@ -46,4 +46,4 @@ if (isCompetitor) {
   });
 }
 
-export {suite};
+export { suite };

package/test/performance/data-structures/trie/trie.test.ts

@@ -1,9 +1,9 @@
-import {Trie} from '../../../../src';
+import { Trie } from '../../../../src';
 import * as Benchmark from 'benchmark';
-import {getRandomWords, magnitude} from '../../../utils';
+import { getRandomWords, magnitude } from '../../../utils';
 
 const suite = new Benchmark.Suite();
-const {HUNDRED_THOUSAND} = magnitude;
+const { HUNDRED_THOUSAND } = magnitude;
 const trie = new Trie();
 const randomWords = getRandomWords(HUNDRED_THOUSAND, false);
 
@@ -19,4 +19,4 @@ suite
     }
   });
 
-export {suite};
+export { suite };

package/test/performance/reportor.ts

@@ -2,8 +2,8 @@ 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';
+import { Color, numberFix, render } from '../utils';
+import { PerformanceTest } from './types';
 
 const parentDirectory = path.resolve(__dirname, '../..');
 const reportDistPath = path.join(parentDirectory, 'benchmark');
@@ -11,22 +11,22 @@ const reportDistPath = path.join(parentDirectory, 'benchmark');
 const testDir = path.join(__dirname, 'data-structures');
 const testFiles = fastGlob.sync(path.join(testDir, '**', '*.test.ts'));
 
-const report: {[key: string]: any} = {};
+const report: { [key: string]: any } = {};
 
 let completedCount = 0;
 
 const performanceTests: PerformanceTest[] = [];
-const {GREEN, BOLD, END, YELLOW, GRAY, CYAN, BG_YELLOW} = Color;
+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 { suite } = testFunction;
+  if (suite) performanceTests.push({ testName, suite, file });
 });
 
 const composeReport = () => {
-  if (!fs.existsSync(reportDistPath)) fs.mkdirSync(reportDistPath, {recursive: true});
+  if (!fs.existsSync(reportDistPath)) fs.mkdirSync(reportDistPath, { recursive: true });
 
   const filePath = path.join(reportDistPath, 'report.json');
   const htmlFilePath = path.join(reportDistPath, 'report.html');
@@ -85,9 +85,9 @@ const composeReport = () => {
           {
             '<>': 'tr',
             html: [
-              {'<>': 'td', html: '${name}'},
-              {'<>': 'td', html: '${periodMS}'},
-              {'<>': 'td', html: '${mean}'}
+              { '<>': 'td', html: '${name}' },
+              { '<>': 'td', html: '${periodMS}' },
+              { '<>': 'td', html: '${mean}' }
             ]
           }
         ]
@@ -142,7 +142,7 @@ function replaceMarkdownContent(startMarker: string, endMarker: string, newText:
 }
 
 performanceTests.forEach(item => {
-  const {suite, testName, file} = item;
+  const { suite, testName, file } = item;
   const relativeFilePath = path.relative(__dirname, file);
   const directory = path.dirname(relativeFilePath);
   const fileName = path.basename(relativeFilePath);
@@ -173,13 +173,15 @@ performanceTests.forEach(item => {
         console.log(
           // `Files: ${GREEN}${testFileCount}${END} `,
           // `Suites: ${GREEN}${performanceTests.length}${END} `,
-          `Suites Progress: ${isDone ? GREEN : YELLOW}${completedCount}${END}/${isDone ? GREEN : YELLOW}${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});
+      .run({ async: false });
   }
 });

package/test/performance/types/reportor.ts

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

package/test/types/utils/json2html.ts

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

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

@@ -1,4 +1,4 @@
-import {AVLTree, AVLTreeNode, CP, IterationType} from '../../../../src';
+import { AVLTree, AVLTreeNode, CP, IterationType } from '../../../../src';
 
 describe('AVL Tree Test', () => {
   it('should perform various operations on a AVL Tree', () => {
@@ -112,7 +112,7 @@ describe('AVL Tree Test', () => {
 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});
+    const tree = new AVLTree<number>({ iterationType: IterationType.RECURSIVE });
 
     for (const i of arr) tree.add(i, i);
 
@@ -219,7 +219,7 @@ describe('AVL Tree Test recursively', () => {
 });
 
 describe('AVLTree APIs test', () => {
-  const avl = new AVLTree<{id: number; text: string}>();
+  const avl = new AVLTree<{ id: number; text: string }>();
   beforeEach(() => {
     avl.clear();
   });
@@ -228,9 +228,9 @@ describe('AVLTree APIs test', () => {
     avl.add(1);
     const node2 = new AVLTreeNode(2);
     avl.add(node2);
-    const node3 = new AVLTreeNode(3, {id: 3, text: 'text3'});
+    const node3 = new AVLTreeNode(3, { id: 3, text: 'text3' });
     avl.add(node3);
-    avl.add(node3, {id: 3, text: 'text33'});
+    avl.add(node3, { id: 3, text: 'text33' });
 
     const bfsRes = avl.bfs(node => node.key);
     expect(bfsRes[0]).toBe(2);
@@ -268,7 +268,7 @@ describe('AVLTree', () => {
   });
 
   describe('BinaryTree APIs test', () => {
-    const avl = new AVLTree<{id: number; text: string}>();
+    const avl = new AVLTree<{ id: number; text: string }>();
     beforeEach(() => {
       avl.clear();
     });
@@ -277,9 +277,9 @@ describe('AVLTree', () => {
       avl.add(1);
       const node2 = new AVLTreeNode(2);
       avl.add(node2);
-      const node3 = new AVLTreeNode(3, {id: 3, text: 'text3'});
+      const node3 = new AVLTreeNode(3, { id: 3, text: 'text3' });
       avl.add(node3);
-      avl.add(node3, {id: 3, text: 'text33'});
+      avl.add(node3, { id: 3, text: 'text33' });
 
       const bfsRes = avl.bfs(node => node);
       expect(bfsRes[0]?.key).toBe(2);

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

@@ -1,4 +1,4 @@
-import {BinaryIndexedTree} from '../../../../src';
+import { BinaryIndexedTree } from '../../../../src';
 // import {isDebugTest} from '../../../config';
 
 // const isDebug = isDebugTest;
@@ -8,13 +8,13 @@ describe('BinaryIndexedTree simple', () => {
 
   beforeEach(() => {
     //Create a new BinaryIndexedTree instance before each test case
-    bit = new BinaryIndexedTree({frequency: 0, max: 10}); // Modify the value of max as needed
+    bit = new BinaryIndexedTree({ frequency: 0, max: 10 }); // Modify the value of max as needed
   });
 
   it('should initialize correctly', () => {
     expect(bit.freq).toBe(0);
     expect(bit.max).toBe(10);
-    expect(bit.freqMap).toEqual({0: 0}); // Modify the initialized record value according to the actual situation
+    expect(bit.freqMap).toEqual({ 0: 0 }); // Modify the initialized record value according to the actual situation
     // More initialization checks can be added
   });
 
@@ -54,7 +54,7 @@ describe('BinaryIndexedTree', () => {
   let bit: BinaryIndexedTree;
 
   beforeEach(function () {
-    bit = new BinaryIndexedTree({frequency, max});
+    bit = new BinaryIndexedTree({ frequency, max });
   });
   it('should validate the index', function () {
     expect(() => bit.readSingle(-1)).toThrow('Index out of range');
@@ -73,7 +73,7 @@ describe('BinaryIndexedTree', () => {
   it('should frequency and max', function () {
     const frequency = 200;
     const max = 1000;
-    const bit = new BinaryIndexedTree({frequency, max});
+    const bit = new BinaryIndexedTree({ frequency, max });
 
     expect(bit.freq).toBe(frequency);
     expect(bit.max).toBe(max);
@@ -123,7 +123,7 @@ describe('designated values', function () {
   let bit: BinaryIndexedTree;
 
   beforeEach(function () {
-    bit = new BinaryIndexedTree({max: array.length});
+    bit = new BinaryIndexedTree({ max: array.length });
     array.forEach((value, i) => bit.writeSingle(i, value));
   });
 
@@ -182,7 +182,7 @@ describe('descending sequence', function () {
   let bit: BinaryIndexedTree;
 
   beforeEach(function () {
-    bit = new BinaryIndexedTree({max: array.length});
+    bit = new BinaryIndexedTree({ max: array.length });
     array.forEach((value, i) => bit.writeSingle(i, value));
   });
 
@@ -219,7 +219,7 @@ describe('descending sequence', function () {
 
 describe('BinaryIndexedTree additional tests', () => {
   it('should handle read method correctly', () => {
-    const bit = new BinaryIndexedTree({max: 10});
+    const bit = new BinaryIndexedTree({ max: 10 });
     bit.writeSingle(2, 10);
     bit.writeSingle(5, 20);
     bit.writeSingle(8, 30);
@@ -227,7 +227,7 @@ describe('BinaryIndexedTree additional tests', () => {
   });
 
   it('should handle consecutive operations', () => {
-    const bit = new BinaryIndexedTree({max: 10});
+    const bit = new BinaryIndexedTree({ max: 10 });
     bit.writeSingle(2, 10);
     bit.update(2, 5);
     expect(bit.readSingle(2)).toBe(15);
@@ -237,7 +237,7 @@ describe('BinaryIndexedTree additional tests', () => {
   });
 
   it('should handle frequent increment updates', () => {
-    const bit = new BinaryIndexedTree({max: 10});
+    const bit = new BinaryIndexedTree({ max: 10 });
     for (let i = 0; i < 10; i++) {
       bit.update(2, 5);
     }
@@ -245,7 +245,7 @@ describe('BinaryIndexedTree additional tests', () => {
   });
 
   it('should handle edge cases', () => {
-    const bit = new BinaryIndexedTree({max: 10});
+    const bit = new BinaryIndexedTree({ max: 10 });
     bit.writeSingle(9, 100);
     expect(bit.readSingle(9)).toBe(100);
     expect(bit.lowerBound(200)).toBe(10);
@@ -291,7 +291,7 @@ describe('', () => {
 
     constructor(nums: number[]) {
       this._nums = nums;
-      this._tree = new BinaryIndexedTree({max: nums.length + 1});
+      this._tree = new BinaryIndexedTree({ max: nums.length + 1 });
       for (let i = 0; i < nums.length; i++) {
         this._tree.update(i + 1, nums[i]);
       }