data-structure-typed 2.1.1 → 2.1.2

package/jest.integration.config.js

@@ -1,8 +1,12 @@
 module.exports = {
   preset: 'ts-jest',
   testEnvironment: 'node',
-  testMatch: ['<rootDir>/test/integration/**/*.test.ts', '<rootDir>/test/integration/**/*.test.js'],
+  testMatch: [
+    '<rootDir>/test/integration/**/*.test.ts',
+    '<rootDir>/test/integration/**/*.test.js',
+    '<rootDir>/test/integration/**/*.test.mjs'
+  ],
   transform: {
-    '^.+\\.(ts|tsx)$': ['ts-jest', { tsconfig: 'tsconfig.test.json' }],
-  },
+    '^.+\\.(ts|tsx)$': ['ts-jest', { tsconfig: 'tsconfig.test.json' }]
+  }
 };

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "data-structure-typed",
-  "version": "2.1.1",
+  "version": "2.1.2",
   "description": "Standard data structure",
   "browser": "dist/umd/data-structure-typed.min.js",
   "umd:main": "dist/umd/data-structure-typed.min.js",
   "main": "dist/cjs/index.cjs",
-  "module": "./dist/esm/index.mjs",
+  "module": "dist/esm/index.mjs",
   "types": "dist/types/index.d.ts",
   "exports": {
     ".": {
@@ -15,18 +15,22 @@
     }
   },
   "sideEffects": false,
+  "engines": {
+    "node": ">=12.20.0",
+    "npm": ">=6.14.0"
+  },
   "scripts": {
     "build": "npm run build:ecu && npm run build:docs-class",
-    "build:node": "tsup --config tsup.node.config.ts",
-    "build:types": "rm -rf dist/types && tsc -p tsconfig-types.json",
+    "build:node": "tsup --config tsup.node.config.js",
+    "build:types": "rm -rf dist/types && tsc -p tsconfig.types.json",
     "build:umd": "tsup",
     "build:ecu": "npm run build:node && npm run build:types && npm run build:umd",
     "build:docs": "npm run gen:examples && typedoc --out docs ./src",
     "build:docs-class": "npm run gen:examples && typedoc --out docs ./src/data-structures",
-    "gen:examples": "ts-node scripts/testToExample.ts",
+    "gen:examples": "ts-node scripts/test-to-example.ts",
     "test:in-band": "jest --runInBand",
     "test": "npm run test:in-band",
-    "test:integration": "npm run update:subs && jest --config jest.integration.config.js && tsc test/integration/compile.ts && node test/integration/compile.mjs",
+    "test:integration": "npm run update:subs && jest --config jest.integration.config.js && tsc test/integration/compile.test.ts && node test/integration/compile.mjs",
     "test:perf": "npm run build:ecu && ts-node test/performance/benchmark-runner.ts --isolate --gc --cooldown-ms=80",
     "check": "tsc --noEmit",
     "check:circular-refs": "dependency-cruiser src",
@@ -77,7 +81,7 @@
     "benchmark": "^2.1.4",
     "binary-tree-typed": "^1.54.3",
     "bst-typed": "^1.54.3",
-    "data-structure-typed": "^1.54.3",
+    "data-structure-typed": "^2.1.1",
     "dependency-cruiser": "^16.5.0",
     "doctoc": "^2.2.1",
     "eslint": "^9.13.0",

package/src/data-structures/binary-tree/avl-tree-counter.ts

@@ -130,7 +130,7 @@ export class AVLTreeCounter<K = any, V = any, R = any> extends AVLTree<K, V, R>
     return sum;
   }
 
-  override _createNode(key: K, value?: V, count?: number): AVLTreeCounterNode<K, V> {
+  override createNode(key: K, value?: V, count?: number): AVLTreeCounterNode<K, V> {
     return new AVLTreeCounterNode(key, this._isMapMode ? undefined : value, count) as AVLTreeCounterNode<K, V>;
   }
 
@@ -391,10 +391,10 @@ export class AVLTreeCounter<K = any, V = any, R = any> extends AVLTree<K, V, R>
       const [key, entryValue] = keyNodeOrEntry;
       if (key === undefined || key === null) return [undefined, undefined];
       const finalValue = value ?? entryValue;
-      return [this._createNode(key, finalValue, count), finalValue];
+      return [this.createNode(key, finalValue, count), finalValue];
     }
 
-    return [this._createNode(keyNodeOrEntry, value, count), value];
+    return [this.createNode(keyNodeOrEntry, value, count), value];
   }
 
   /**
@@ -412,7 +412,7 @@ export class AVLTreeCounter<K = any, V = any, R = any> extends AVLTree<K, V, R>
     destNode = this.ensureNode(destNode);
     if (srcNode && destNode) {
       const { key, value, count, height } = destNode;
-      const tempNode = this._createNode(key, value, count);
+      const tempNode = this.createNode(key, value, count);
       if (tempNode) {
         tempNode.height = height;
 

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

@@ -113,7 +113,7 @@ export class AVLTreeMultiMap<K = any, V = any, R = any> extends AVLTree<K, V[],
     }
   }
 
-  override _createNode(key: K, value: V[] = []): AVLTreeMultiMapNode<K, V> {
+  override createNode(key: K, value: V[] = []): AVLTreeMultiMapNode<K, V> {
     return new AVLTreeMultiMapNode<K, V>(key, this._isMapMode ? [] : value);
   }
 

package/src/data-structures/binary-tree/avl-tree.ts

@@ -196,7 +196,7 @@ export class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> implements
    * @param [value] - The value for the new node.
    * @returns The newly created AVLTreeNode.
    */
-  override _createNode(key: K, value?: V): AVLTreeNode<K, V> {
+  override createNode(key: K, value?: V): AVLTreeNode<K, V> {
     return new AVLTreeNode<K, V>(key, this._isMapMode ? undefined : value) as AVLTreeNode<K, V>;
   }
 
@@ -370,7 +370,7 @@ export class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> implements
 
     if (srcNodeEnsured && destNodeEnsured) {
       const { key, value, height } = destNodeEnsured;
-      const tempNode = this._createNode(key, value);
+      const tempNode = this.createNode(key, value);
 
       if (tempNode) {
         tempNode.height = height;

package/src/data-structures/binary-tree/binary-tree.ts

@@ -390,7 +390,7 @@ export class BinaryTree<K = any, V = any, R = any>
    * @param [value] - The value for the new node (used if not in Map mode).
    * @returns The newly created node.
    */
-  _createNode(key: K, value?: V): BinaryTreeNode<K, V> {
+  createNode(key: K, value?: V): BinaryTreeNode<K, V> {
     return new BinaryTreeNode<K, V>(key, this._isMapMode ? undefined : value);
   }
 
@@ -2019,10 +2019,10 @@ export class BinaryTree<K = any, V = any, R = any>
       if (key === undefined) return [undefined, undefined];
       else if (key === null) return [null, undefined];
       const finalValue = value ?? entryValue;
-      return [this._createNode(key, finalValue), finalValue];
+      return [this.createNode(key, finalValue), finalValue];
     }
 
-    return [this._createNode(keyNodeOrEntry, value), value];
+    return [this.createNode(keyNodeOrEntry, value), value];
   }
 
   /**
@@ -2147,7 +2147,7 @@ export class BinaryTree<K = any, V = any, R = any>
 
     if (srcNode && destNode) {
       const { key, value } = destNode;
-      const tempNode = this._createNode(key, value); // Use a temp node to hold dest properties
+      const tempNode = this.createNode(key, value); // Use a temp node to hold dest properties
 
       if (tempNode) {
         // Copy src to dest

package/src/data-structures/binary-tree/bst.ts

@@ -268,7 +268,7 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
    * @param [value] - The value for the new node (used if not in Map mode).
    * @returns The newly created BSTNode.
    */
-  override _createNode(key: K, value?: V): BSTNode<K, V> {
+  override createNode(key: K, value?: V): BSTNode<K, V> {
     return new BSTNode<K, V>(key, this._isMapMode ? undefined : value);
   }
 

package/src/data-structures/binary-tree/red-black-tree.ts

@@ -89,7 +89,7 @@ export class RedBlackTreeNode<K = any, V = any> extends BSTNode<K, V> {
 }
 
 /**
- * RRRRRRRRRRRRRRRRRRRed-Black Tree (self-balancing BST) supporting map-like mode and stable O(log n) updates.
+ * Represents a Red-Black Tree (self-balancing BST) supporting map-like mode and stable O(log n) updates.
  * @remarks Time O(1), Space O(1)
  * @template K
  * @template V
@@ -176,7 +176,7 @@ export class RedBlackTree<K = any, V = any, R = any> extends BST<K, V, R> implem
    * @param color - See parameter type for details.
    * @returns A new RedBlackTreeNode instance.
    */
-  override _createNode(key: K, value?: V, color: RBTNColor = 'BLACK'): RedBlackTreeNode<K, V> {
+  override createNode(key: K, value?: V, color: RBTNColor = 'BLACK'): RedBlackTreeNode<K, V> {
     return new RedBlackTreeNode<K, V>(key, this._isMapMode ? undefined : value, color);
   }
 

package/src/data-structures/binary-tree/tree-counter.ts

@@ -142,7 +142,7 @@ export class TreeCounter<K = any, V = any, R = any> extends RedBlackTree<K, V, R
     return sum;
   }
 
-  override _createNode(key: K, value?: V, color: RBTNColor = 'BLACK', count?: number): TreeCounterNode<K, V> {
+  override createNode(key: K, value?: V, color: RBTNColor = 'BLACK', count?: number): TreeCounterNode<K, V> {
     return new TreeCounterNode(key, this._isMapMode ? undefined : value, count, color) as TreeCounterNode<K, V>;
   }
 
@@ -427,10 +427,10 @@ export class TreeCounter<K = any, V = any, R = any> extends RedBlackTree<K, V, R
       const [key, entryValue] = keyNodeOrEntry;
       if (key === undefined || key === null) return [undefined, undefined];
       const finalValue = value ?? entryValue;
-      return [this._createNode(key, finalValue, 'BLACK', count), finalValue];
+      return [this.createNode(key, finalValue, 'BLACK', count), finalValue];
     }
 
-    return [this._createNode(keyNodeOrEntry, value, 'BLACK', count), value];
+    return [this.createNode(keyNodeOrEntry, value, 'BLACK', count), value];
   }
 
   /**
@@ -448,7 +448,7 @@ export class TreeCounter<K = any, V = any, R = any> extends RedBlackTree<K, V, R
     destNode = this.ensureNode(destNode);
     if (srcNode && destNode) {
       const { key, value, count, color } = destNode;
-      const tempNode = this._createNode(key, value, color, count);
+      const tempNode = this.createNode(key, value, color, count);
       if (tempNode) {
         tempNode.color = color;
 

package/src/data-structures/binary-tree/tree-multi-map.ts

@@ -270,7 +270,7 @@ export class TreeMultiMap<K = any, V = any, R = any> extends RedBlackTree<K, V[]
     }
   }
 
-  override _createNode(key: K, value: V[] = []): TreeMultiMapNode<K, V> {
+  override createNode(key: K, value: V[] = []): TreeMultiMapNode<K, V> {
     return new TreeMultiMapNode<K, V>(key, this._isMapMode ? [] : value);
   }
 

package/src/data-structures/heap/heap.ts

@@ -190,7 +190,7 @@ import { IterableElementBase } from '../base';
  *     ]);
  *     console.log(scheduleTasks(tasks, 2)); // expectedMap
  */
-export class Heap<E = unknown, R = never> extends IterableElementBase<E, R> {
+export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
   protected _equals: (a: E, b: E) => boolean = Object.is;
 
   /**
@@ -255,7 +255,7 @@ export class Heap<E = unknown, R = never> extends IterableElementBase<E, R> {
    * @returns A new heap instance of this class.
    */
 
-  static from<T, R = never, S extends Heap<T, R> = Heap<T, R>>(
+  static from<T, R = any, S extends Heap<T, R> = Heap<T, R>>(
     this: new (elements?: Iterable<T | R>, options?: HeapOptions<T, R>) => S,
     elements?: Iterable<T | R>,
     options?: HeapOptions<T, R>
@@ -273,7 +273,7 @@ export class Heap<E = unknown, R = never> extends IterableElementBase<E, R> {
    * @returns A new Heap built from elements.
    */
 
-  static heapify<EE = unknown, RR = never>(elements: Iterable<EE>, options: HeapOptions<EE, RR>): Heap<EE, RR> {
+  static heapify<EE = any, RR = any>(elements: Iterable<EE>, options: HeapOptions<EE, RR>): Heap<EE, RR> {
     return new Heap<EE, RR>(elements, options);
   }
 
@@ -788,7 +788,7 @@ export class FibonacciHeap<E> {
    */
 
   push(element: E): this {
-    const node = this._createNode(element);
+    const node = this.createNode(element);
     node.left = node;
     node.right = node;
     this.mergeWithRoot(node);
@@ -900,7 +900,7 @@ export class FibonacciHeap<E> {
     heapToMerge.clear();
   }
 
-  _createNode(element: E): FibonacciHeapNode<E> {
+  createNode(element: E): FibonacciHeapNode<E> {
     return new FibonacciHeapNode<E>(element);
   }
 

package/src/data-structures/linked-list/singly-linked-list.ts

@@ -781,7 +781,7 @@ export class SinglyLinkedList<E = any, R = any> extends LinearLinkedBase<E, R, S
    * @returns A new SinglyLinkedListNode instance.
    */
 
-  protected _createNode(value: E): SinglyLinkedListNode<E> {
+  protected createNode(value: E): SinglyLinkedListNode<E> {
     return new SinglyLinkedListNode<E>(value);
   }
 
@@ -807,7 +807,7 @@ export class SinglyLinkedList<E = any, R = any> extends LinearLinkedBase<E, R, S
 
   protected _ensureNode(elementOrNode: E | SinglyLinkedListNode<E>) {
     if (this.isNode(elementOrNode)) return elementOrNode;
-    return this._createNode(elementOrNode);
+    return this.createNode(elementOrNode);
   }
 
   /**

package/src/interfaces/binary-tree.ts

@@ -32,7 +32,7 @@ export interface IBinaryTree<K = any, V = any, R = any> {
   readonly isDuplicate: boolean;
 
   // ---- construction / mutation ----
-  _createNode(key: K, value?: BinaryTreeNode<K, V>['value']): BinaryTreeNode<K, V>;
+  createNode(key: K, value?: BinaryTreeNode<K, V>['value']): BinaryTreeNode<K, V>;
 
   createTree(options?: Partial<BinaryTreeOptions<K, V, R>>): IBinaryTree<K, V, R>;
 

package/test/integration/compile.test.mjs

@@ -0,0 +1,159 @@
+import {
+  AVLTree,
+  BinaryTree,
+  BST,
+  Deque,
+  DoublyLinkedList,
+  HashMap,
+  Heap,
+  MaxPriorityQueue,
+  MinHeap,
+  MinPriorityQueue,
+  Queue,
+  RedBlackTree,
+  SinglyLinkedList,
+  Stack,
+  TreeMultiMap,
+  Trie
+} from 'data-structure-typed';
+
+describe('', () => {
+  it('', () => {
+    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 = [
+      [6, '6'],
+      [1, '1'],
+      [2, '2'],
+      [7, '7'],
+      [5, '5'],
+      [3, '3'],
+      [4, '4'],
+      [9, '9'],
+      [8, '8']
+    ];
+    const queue = new Queue(orgArr);
+
+    // [6, 1, 2, 7, 5, 3, 4, 9, 8]
+    const deque = new Deque(orgArr);
+
+    // [6, 1, 2, 7, 5, 3, 4, 9, 8]
+    const sList = new SinglyLinkedList(orgArr);
+
+    // [6, 1, 2, 7, 5, 3, 4, 9, 8]
+    const dList = new DoublyLinkedList(orgArr);
+
+    // [6, 1, 2, 7, 5, 3, 4, 9, 8]
+    const stack = new Stack(orgArr);
+
+    // [6, 1, 2, 7, 5, 3, 4, 9, 8]
+    const minHeap = new MinHeap(orgArr);
+
+    // [1, 5, 2, 7, 6, 3, 4, 9, 8]
+    const maxPQ = new MaxPriorityQueue(orgArr);
+
+    // [9, 8, 4, 7, 5, 2, 3, 1, 6]
+    const biTree = new BinaryTree(entries);
+
+    //         ___6___
+    //        /       \
+    //     ___1_     _2_
+    //    /     \   /   \
+    //   _7_    5   3   4
+    //  /   \
+    //  9   8
+    const bst = new BST(entries);
+
+    //     _____5___
+    //    /         \
+    //   _2_       _7_
+    //  /   \     /   \
+    //  1   3_    6   8_
+    //        \         \
+    //        4         9
+    const rbTree = new RedBlackTree(entries);
+
+    //     ___4___
+    //    /       \
+    //   _2_     _6___
+    //  /   \   /     \
+    //  1   3   5    _8_
+    //              /   \
+    //              7   9
+    const avl = new AVLTree(entries);
+
+    //     ___4___
+    //    /       \
+    //   _2_     _6___
+    //  /   \   /     \
+    //  1   3   5    _8_
+    //              /   \
+    //              7   9
+    const treeMulti = new TreeMultiMap(entries);
+
+    //     ___4___
+    //    /       \
+    //   _2_     _6___
+    //  /   \   /     \
+    //  1   3   5    _8_
+    //              /   \
+    //              7   9
+    const hm = new HashMap(entries);
+
+    // [[6, "6"], [1, "1"], [2, "2"], [7, "7"], [5, "5"], [3, "3"], [4, "4"], [9, "9"], [8, "8"]]
+    const rbTreeH = new RedBlackTree(hm);
+
+    //     ___4___
+    //    /       \
+    //   _2_     _6___
+    //  /   \   /     \
+    //  1   3   5    _8_
+    //              /   \
+    //              7   9
+    const pq = new MinPriorityQueue(orgArr);
+
+    // [1, 5, 2, 7, 6, 3, 4, 9, 8]
+    const bst1 = new BST(pq);
+
+    //     _____5___
+    //    /         \
+    //   _2_       _7_
+    //  /   \     /   \
+    //  1   3_    6   8_
+    //        \         \
+    //        4         9
+    const dq1 = new Deque(orgArr);
+
+    // [6, 1, 2, 7, 5, 3, 4, 9, 8]
+    const rbTree1 = new RedBlackTree(dq1);
+
+    //    _____5___
+    //   /         \
+    //  _2___     _7___
+    // /     \   /     \
+    // 1    _4   6    _9
+    //      /         /
+    //      3         8
+    const trie2 = new Trie(orgStrArr);
+
+    // ['trie', 'trial', 'triangle', 'trick', 'trip', 'tree', 'trend', 'track', 'trace', 'transmit']
+    const heap2 = new Heap(trie2, { comparator: (a, b) => Number(a) - Number(b) });
+
+    // ['transmit', 'trace', 'tree', 'trend', 'track', 'trial', 'trip', 'trie', 'trick', 'triangle']
+    const dq2 = new Deque(heap2);
+
+    // ['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/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();