data-structure-typed 2.1.1 → 2.2.0

package/test/integration/compile.test.ts

@@ -0,0 +1,176 @@
+import {
+  AVLTree,
+  BinaryTree,
+  BST,
+  Deque,
+  DoublyLinkedList,
+  HashMap,
+  Heap,
+  MaxPriorityQueue,
+  MinHeap,
+  MinPriorityQueue,
+  Queue,
+  RedBlackTree,
+  SinglyLinkedList,
+  Stack,
+  TreeMultiMap,
+  Trie
+} from 'data-structure-typed';
+
+describe('compile', () => {
+  it('compiles an empty array', () => {
+    const orgArr = [6, 1, 2, 7, 5, 3, 4, 9, 8];
+    const orgStrArr = ['trie', 'trial', 'trick', 'trip', 'tree', 'trend', 'triangle', 'track', 'trace', 'transmit'];
+    const entries: [number, string][] = [
+      [6, '6'],
+      [1, '1'],
+      [2, '2'],
+      [7, '7'],
+      [5, '5'],
+      [3, '3'],
+      [4, '4'],
+      [9, '9'],
+      [8, '8']
+    ];
+
+    const queue = new Queue(orgArr);
+    queue.print();
+    // [6, 1, 2, 7, 5, 3, 4, 9, 8]
+
+    const deque = new Deque(orgArr);
+    deque.print();
+    // [6, 1, 2, 7, 5, 3, 4, 9, 8]
+
+    const sList = new SinglyLinkedList(orgArr);
+    sList.print();
+    // [6, 1, 2, 7, 5, 3, 4, 9, 8]
+
+    const dList = new DoublyLinkedList(orgArr);
+    dList.print();
+    // [6, 1, 2, 7, 5, 3, 4, 9, 8]
+
+    const stack = new Stack(orgArr);
+    stack.print();
+    // [6, 1, 2, 7, 5, 3, 4, 9, 8]
+
+    const minHeap = new MinHeap(orgArr);
+    minHeap.print();
+    // [1, 5, 2, 7, 6, 3, 4, 9, 8]
+
+    const maxPQ = new MaxPriorityQueue(orgArr);
+    maxPQ.print();
+    // [9, 8, 4, 7, 5, 2, 3, 1, 6]
+
+    const biTree = new BinaryTree(entries);
+    biTree.print();
+    //         ___6___
+    //        /       \
+    //     ___1_     _2_
+    //    /     \   /   \
+    //   _7_    5   3   4
+    //  /   \
+    //  9   8
+
+    const bst = new BST(entries);
+    bst.print();
+    //     _____5___
+    //    /         \
+    //   _2_       _7_
+    //  /   \     /   \
+    //  1   3_    6   8_
+    //        \         \
+    //        4         9
+
+    const rbTree = new RedBlackTree(entries);
+    rbTree.print();
+    //     ___4___
+    //    /       \
+    //   _2_     _6___
+    //  /   \   /     \
+    //  1   3   5    _8_
+    //              /   \
+    //              7   9
+
+    const avl = new AVLTree(entries);
+    avl.print();
+    //     ___4___
+    //    /       \
+    //   _2_     _6___
+    //  /   \   /     \
+    //  1   3   5    _8_
+    //              /   \
+    //              7   9
+
+    const treeMulti = new TreeMultiMap(entries);
+    treeMulti.print();
+    //     ___4___
+    //    /       \
+    //   _2_     _6___
+    //  /   \   /     \
+    //  1   3   5    _8_
+    //              /   \
+    //              7   9
+
+    const hm = new HashMap(entries);
+    hm.print();
+    // [[6, "6"], [1, "1"], [2, "2"], [7, "7"], [5, "5"], [3, "3"], [4, "4"], [9, "9"], [8, "8"]]
+
+    const rbTreeH = new RedBlackTree(hm);
+    rbTreeH.print();
+    //     ___4___
+    //    /       \
+    //   _2_     _6___
+    //  /   \   /     \
+    //  1   3   5    _8_
+    //              /   \
+    //              7   9
+
+    const pq = new MinPriorityQueue(orgArr);
+    pq.print();
+    // [1, 5, 2, 7, 6, 3, 4, 9, 8]
+
+    const bst1 = new BST(pq);
+    bst1.print();
+    //     _____5___
+    //    /         \
+    //   _2_       _7_
+    //  /   \     /   \
+    //  1   3_    6   8_
+    //        \         \
+    //        4         9
+
+    const dq1 = new Deque(orgArr);
+    dq1.print();
+    // [6, 1, 2, 7, 5, 3, 4, 9, 8]
+    const rbTree1 = new RedBlackTree(dq1);
+    rbTree1.print();
+    //    _____5___
+    //   /         \
+    //  _2___     _7___
+    // /     \   /     \
+    // 1    _4   6    _9
+    //      /         /
+    //      3         8
+
+    const trie2 = new Trie(orgStrArr);
+    trie2.print();
+    // ['trie', 'trial', 'triangle', 'trick', 'trip', 'tree', 'trend', 'track', 'trace', 'transmit']
+    const heap2 = new Heap(trie2, { comparator: (a, b) => Number(a) - Number(b) });
+    heap2.print();
+    // ['transmit', 'trace', 'tree', 'trend', 'track', 'trial', 'trip', 'trie', 'trick', 'triangle']
+    const dq2 = new Deque(heap2);
+    dq2.print();
+    // ['transmit', 'trace', 'tree', 'trend', 'track', 'trial', 'trip', 'trie', 'trick', 'triangle']
+    const entries2 = dq2.map((el, i) => [i, el]);
+    const avl2 = new AVLTree(entries2);
+    avl2.print();
+    //     ___3_______
+    //    /           \
+    //   _1_       ___7_
+    //  /   \     /     \
+    //  0   2    _5_    8_
+    //          /   \     \
+    //          4   6     9
+    expect(avl2.size).toBe(10);
+  });
+});

package/test/integration/heap.test.js

@@ -1,4 +1,4 @@
-const { MinHeap } = require('heap-typed');
+const { MinHeap } = require('data-structure-typed');
 
 describe('JS Heap Operation Test', () => {
   it('should numeric heap work well', function () {

package/test/integration/index.html

@@ -86,7 +86,7 @@
     tree.print(undefined, { isShowUndefined: true });
 
     const node3 = tree.getNode(3);
-    if (node3) node3.right = tree._createNode(1);
+    if (node3) node3.right = tree.createNode(1);
     console.log(tree.isPerfectlyBalanced(), `tree.isPerfectlyBalanced()`);
     tree.print();
 

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

@@ -1,4 +1,4 @@
-import { AVLTreeCounter, AVLTreeCounterNode, AVLTreeNode, BinaryTreeNode, BSTNode, IBinaryTree } from '../../../../src';
+import { AVLTreeCounter, AVLTreeCounterNode, IBinaryTree } from '../../../../src';
 import { isDebugTest } from '../../../config';
 
 const isDebug = isDebugTest;
@@ -619,9 +619,10 @@ describe('AVLTreeCounter iterative methods test', () => {
 
   it('The node obtained by get Node should match the node type', () => {
     const node3 = avlCounter.getNode(3);
-    expect(node3).toBeInstanceOf(BinaryTreeNode);
-    expect(node3).toBeInstanceOf(BSTNode);
-    expect(node3).toBeInstanceOf(AVLTreeNode);
+    // expect(node3).toBeInstanceOf(BinaryTreeNode);
+    // expect(node3).toBeInstanceOf(BSTNode);
+    // expect(node3).toBeInstanceOf(AVLTreeNode);
+    expect(node3).toBeInstanceOf(AVLTreeCounterNode);
   });
 
   it('forEach should iterate over all elements', () => {

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

@@ -1,4 +1,4 @@
-import { AVLTree, AVLTreeNode, BinaryTreeNode, BSTNode, IBinaryTree } from '../../../../src';
+import { AVLTree, AVLTreeNode, IBinaryTree } from '../../../../src';
 
 describe('AVL Tree Test', () => {
   it('should perform various operations on a AVL Tree', () => {
@@ -379,8 +379,8 @@ describe('AVLTree iterative methods test', () => {
 
   it('The node obtained by get Node should match the node type', () => {
     const node3 = avlTree.getNode(3);
-    expect(node3).toBeInstanceOf(BinaryTreeNode);
-    expect(node3).toBeInstanceOf(BSTNode);
+    // expect(node3).toBeInstanceOf(BinaryTreeNode);
+    // expect(node3).toBeInstanceOf(BSTNode);
     expect(node3).toBeInstanceOf(AVLTreeNode);
   });
 

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

@@ -152,7 +152,7 @@ describe('BinaryTree', () => {
   it('delete(): leaf/one-child/two-children/missing; updates size and minHeight', () => {
     expect(binTree.getHeight(binTree.root, 'ITERATIVE')).toBe(-1);
     expect(binTree.getMinHeight()).toBe(-1);
-    const node1 = binTree._createNode(1);
+    const node1 = binTree.createNode(1);
     binTree.add(node1);
     expect(binTree.size).toBe(1);
 
@@ -261,7 +261,7 @@ describe('BinaryTree', () => {
     expect(binTree.isPerfectlyBalanced()).toBe(true);
     const node3 = binTree.getNode(3);
 
-    if (node3) node3.right = binTree._createNode(1);
+    if (node3) node3.right = binTree.createNode(1);
     expect(binTree.isPerfectlyBalanced()).toBe(false);
 
     binTree.clear();
@@ -1587,7 +1587,7 @@ describe('Coverage boosters - close remaining uncovered branches', () => {
 
   it('add(): build tree with no undefined child slot -> return false path', () => {
     const t = new BinaryTree<number>();
-    const r = t._createNode(1)!;
+    const r = t.createNode(1)!;
     // explicitly set left/right child pointers to null (not undefined) so BFS finds no insertion slot
     (r as any).left = null;
     (r as any).right = null;

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

@@ -1,4 +1,4 @@
-import { BinaryTreeNode, BST, BSTNode, IBinaryTree, Range } from '../../../../src';
+import { BST, BSTNode, IBinaryTree, Range } from '../../../../src';
 import { isDebugTest, isTestStackOverflow, SYSTEM_MAX_CALL_STACK } from '../../../config';
 
 const isDebug = isDebugTest;
@@ -1103,7 +1103,7 @@ describe('BST iterative methods test', () => {
 
   it('The node obtained by get Node should match the node type', () => {
     const node3 = bst.getNode(3);
-    expect(node3).toBeInstanceOf(BinaryTreeNode);
+    // expect(node3).toBeInstanceOf(BinaryTreeNode);
     expect(node3).toBeInstanceOf(BSTNode);
   });
 

package/test/unit/data-structures/binary-tree/red-black-tree.test.ts

@@ -1,4 +1,4 @@
-import { BinaryTreeNode, BSTNode, IBinaryTree, RedBlackTree, RedBlackTreeNode } from '../../../../src';
+import { IBinaryTree, RedBlackTree, RedBlackTreeNode } from '../../../../src';
 import { getRandomInt, getRandomIntArray, magnitude } from '../../../utils';
 import { OrderedMap } from 'js-sdsl';
 
@@ -641,8 +641,8 @@ describe('RedBlackTree 2', () => {
 
     it('The node obtained by get Node should match the node type', () => {
       const node3 = rbTree.getNode(3);
-      expect(node3).toBeInstanceOf(BinaryTreeNode);
-      expect(node3).toBeInstanceOf(BSTNode);
+      // expect(node3).toBeInstanceOf(BinaryTreeNode);
+      // expect(node3).toBeInstanceOf(BSTNode);
       expect(node3).toBeInstanceOf(RedBlackTreeNode);
     });
 

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

@@ -1,4 +1,4 @@
-import { BinaryTreeNode, BSTNode, IBinaryTree, RedBlackTreeNode, TreeCounter, TreeCounterNode } from '../../../../src';
+import { IBinaryTree, TreeCounter, TreeCounterNode } from '../../../../src';
 import { isDebugTest } from '../../../config';
 import { getRandomInt } from '../../../utils';
 
@@ -757,9 +757,10 @@ describe('TreeCounter iterative methods test', () => {
 
   it('The node obtained by get Node should match the node type', () => {
     const node3 = treeCounter.getNode(3);
-    expect(node3).toBeInstanceOf(BinaryTreeNode);
-    expect(node3).toBeInstanceOf(BSTNode);
-    expect(node3).toBeInstanceOf(RedBlackTreeNode);
+    // expect(node3).toBeInstanceOf(BinaryTreeNode);
+    // expect(node3).toBeInstanceOf(BSTNode);
+    // expect(node3).toBeInstanceOf(RedBlackTreeNode);
+    expect(node3).toBeInstanceOf(TreeCounterNode);
   });
 
   it('forEach should iterate over all elements', () => {

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

@@ -1,6 +1,5 @@
-import { BinaryTreeNode, BSTNode, IBinaryTree, TreeMultiMap, TreeMultiMapNode } from '../../../../src';
+import { IBinaryTree, Range, TreeMultiMap, TreeMultiMapNode } from '../../../../src';
 import { getRandomInt } from '../../../utils';
-import { Range } from '../../../../src';
 import { isDebugTest } from '../../../config';
 import { costOfLiving } from './data/cost-of-living-by-country';
 
@@ -637,8 +636,8 @@ describe('TreeMultiMap 2', () => {
 
     it('The node obtained by get Node should match the node type', () => {
       const node3 = tmm.getNode(3);
-      expect(node3).toBeInstanceOf(BinaryTreeNode);
-      expect(node3).toBeInstanceOf(BSTNode);
+      // expect(node3).toBeInstanceOf(BinaryTreeNode);
+      // expect(node3).toBeInstanceOf(BSTNode);
       expect(node3).toBeInstanceOf(TreeMultiMapNode);
     });
 
@@ -1023,6 +1022,7 @@ function leftKey(tmm: TreeMultiMap<number, Product, Product>): number | undefine
   const v = tmm.getLeftMost();
   return v == null ? undefined : typeof v === 'object' ? v.key : v;
 }
+
 function rightKey(tmm: TreeMultiMap<number, Product, Product>): number | undefined {
   const v = tmm.getRightMost();
   return v == null ? undefined : typeof v === 'object' ? v.key : v;

package/{tsconfig-base.json → tsconfig.base.json}

@@ -16,7 +16,6 @@
     "strict": true,
     "traceResolution": false,
     "noImplicitOverride": true,
-
     "types": ["node"]
   },
   "compileOnSave": false,

package/tsconfig.test.json

@@ -1,6 +1,7 @@
 {
   "extends": "./tsconfig.json",
   "compilerOptions": {
+    "isolatedModules": true,
     "noEmit": true,
     "types": ["node", "jest"]
   },

package/{tsconfig-types.json → tsconfig.types.json}

@@ -1,12 +1,10 @@
 {
-  "extends": "./tsconfig-base.json",
+  "extends": "./tsconfig.base.json",
   "compilerOptions": {
     "target": "ES2018",
     "lib": ["ES2018", "DOM"],
-
     "module": "NodeNext",
     "moduleResolution": "NodeNext",
-
     "declaration": true,
     "emitDeclarationOnly": true,
     "declarationMap": false,

package/tsup.config.js

@@ -3,7 +3,7 @@ import { defineConfig } from 'tsup';
 export default defineConfig([
   {
     entry: { "data-structure-typed": "src/index.ts" },
-    target: 'es6',
+    target: 'es2018',
     format: ["iife"],
     clean: true,
     sourcemap: true,
@@ -13,10 +13,9 @@ export default defineConfig([
     platform: "browser",
     outExtension: () => ({ js: '.min.js' }),
   },
-  // 配置 2: Unminified (开发调试用)
   {
     entry: { "data-structure-typed": "src/index.ts" },
-    target: 'es6',
+    target: 'es2018',
     format: ["iife"],
     clean: false,
     sourcemap: true,

package/tsup.node.config.js

@@ -0,0 +1,71 @@
+import { defineConfig } from "tsup";
+
+export default defineConfig([
+  // ESM (modern) - ES2022
+  {
+    entry: { index: "src/index.ts" },
+    format: ["esm"],
+    outDir: "dist/esm",
+    splitting: false,
+    sourcemap: true,
+    minify: false,
+    keepNames: true,
+    treeshake: true,
+    clean: true,
+    target: "es2022",
+    outExtension() {
+      return { js: ".mjs" };
+    }
+  },
+
+  // ESM (legacy) - ES2018
+  {
+    entry: { index: "src/index.ts" },
+    format: ["esm"],
+    outDir: "dist/esm-legacy",
+    splitting: false,
+    sourcemap: true,
+    minify: false,
+    keepNames: true,
+    treeshake: true,
+    clean: false,
+    target: "es2018",
+    outExtension() {
+      return { js: ".mjs" };
+    }
+  },
+
+  // CJS (modern) - ES2022
+  {
+    entry: { index: "src/index.ts" },
+    format: ["cjs"],
+    outDir: "dist/cjs",
+    splitting: false,
+    sourcemap: true,
+    minify: false,
+    keepNames: true,
+    treeshake: true,
+    clean: false,
+    target: "es2022",
+    outExtension() {
+      return { js: ".cjs" };
+    }
+  },
+
+  // CJS (legacy) - ES2018
+  {
+    entry: { index: "src/index.ts" },
+    format: ["cjs"],
+    outDir: "dist/cjs-legacy",
+    splitting: false,
+    sourcemap: true,
+    minify: false,
+    keepNames: true,
+    treeshake: true,
+    clean: false,
+    target: "es2018",
+    outExtension() {
+      return { js: ".cjs" };
+    }
+  }
+]);