data-structure-typed 2.3.0 → 2.4.0

package/eslint.config.mjs

@@ -42,7 +42,11 @@ export default [{
 
   rules: {
     "import/no-anonymous-default-export": "off",
-    "@typescript-eslint/no-unused-vars": "warn",
+    "@typescript-eslint/no-unused-vars": ["warn", { 
+      "argsIgnorePattern": "^_",
+      "varsIgnorePattern": "^_",
+      "caughtErrorsIgnorePattern": "^_"
+    }],
     "@typescript-eslint/ban-ts-comment": "off",
     "@typescript-eslint/no-explicit-any": "off",
     "@typescript-eslint/no-var-requires": "off",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-structure-typed",
-  "version": "2.3.0",
+  "version": "2.4.0",
   "description": "Standard data structure",
   "browser": "dist/umd/data-structure-typed.min.js",
   "umd:main": "dist/umd/data-structure-typed.min.js",
@@ -50,7 +50,8 @@
     "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.test.ts && node test/integration/compile.mjs",
-    "test:perf": "npm run build:ecut && ts-node test/performance/benchmark-runner.ts --isolate --gc --cooldown-ms=80",
+    "test:perf": "npm run build:ecut && NODE_OPTIONS='--expose-gc --max-old-space-size=8192' node test/performance/benchmark-runner-enhanced.mjs",
+    "test:perf:report": "node test/performance/reportor-enhanced.mjs",
     "test:coverage": "jest --runInBand --coverage",
     "check": "npm run check:src && npm run check:test",
     "check:src": "tsc --noEmit",
@@ -103,7 +104,7 @@
     "benchmark": "^2.1.4",
     "binary-tree-typed": "^1.54.3",
     "bst-typed": "^1.54.3",
-    "data-structure-typed": "^2.2.8",
+    "data-structure-typed": "^2.3.0",
     "dependency-cruiser": "^16.5.0",
     "doctoc": "^2.2.1",
     "eslint": "^9.13.0",

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

@@ -383,7 +383,7 @@ export class AVLTree<K = any, V = any, R = any> extends BST<K, V, R> implements
    * @returns The newly created AVLTreeNode.
    */
   override createNode(key: K, value?: V): AVLTreeNode<K, V> {
-    return new AVLTreeNode<K, V>(key, this._isMapMode ? undefined : value) as AVLTreeNode<K, V>;
+    return new AVLTreeNode<K, V>(key, value) as AVLTreeNode<K, V>;
   }
 
   /**

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

@@ -401,7 +401,10 @@ export class BinaryTree<K = any, V = any, R = any>
     return this._isDuplicate;
   }
 
-  protected _store = new Map<K, V | undefined>();
+  // Map mode acceleration store:
+  // - isMapMode=false: unused
+  // - isMapMode=true: key -> node reference (O(1) has/getNode + fast get)
+  protected _store = new Map<K, BinaryTreeNode<K, V>>();
 
   /**
    * Gets the external value store (used in Map mode).
@@ -470,7 +473,7 @@ export class BinaryTree<K = any, V = any, R = any>
    * @returns The newly created node.
    */
   createNode(key: K, value?: V): BinaryTreeNode<K, V> {
-    return new BinaryTreeNode<K, V>(key, this._isMapMode ? undefined : value);
+    return new BinaryTreeNode<K, V>(key, value);
   }
 
   /**
@@ -661,12 +664,12 @@ export class BinaryTree<K = any, V = any, R = any>
     value?: V
   ): boolean {
 
-    const [newNode, newValue] = this._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value);
+    const [newNode] = this._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value);
     if (newNode === undefined) return false;
 
     if (!this._root) {
       this._setRoot(newNode);
-      if (this._isMapMode) this._setValue(newNode?.key, newValue);
+      if (this._isMapMode && newNode !== null && newNode !== undefined) this._store.set(newNode.key, newNode);
       this._size = 1;
       return true;
     }
@@ -681,7 +684,7 @@ export class BinaryTree<K = any, V = any, R = any>
       if (!this._isDuplicate) {
         if (newNode !== null && cur.key === newNode.key) {
           this._replaceNode(cur, newNode);
-          if (this._isMapMode) this._setValue(cur.key, newValue);
+          if (this._isMapMode && newNode !== null) this._store.set(cur.key, newNode);
           return true; // Replaced existing node
         }
       }
@@ -704,7 +707,7 @@ export class BinaryTree<K = any, V = any, R = any>
       } else if (potentialParent.right === undefined) {
         potentialParent.right = newNode;
       }
-      if (this._isMapMode) this._setValue(newNode?.key, newValue);
+      if (this._isMapMode && newNode !== null && newNode !== undefined) this._store.set(newNode.key, newNode);
       this._size++;
       return true;
     }
@@ -822,6 +825,13 @@ export class BinaryTree<K = any, V = any, R = any>
         const parentOfLeftSubTreeMax = leftSubTreeRightMost.parent;
         // Swap properties
         orgCurrent = this._swapProperties(curr, leftSubTreeRightMost);
+
+        // Map mode store tracks key -> node reference; after swapping keys we must re-index both nodes.
+        if (this._isMapMode) {
+          this._store.set(curr.key, curr);
+          this._store.set(leftSubTreeRightMost.key, leftSubTreeRightMost);
+        }
+
         // `orgCurrent` is now the node to be physically deleted (which was the rightmost)
         if (parentOfLeftSubTreeMax) {
           // Unlink the rightmost node
@@ -1002,6 +1012,13 @@ export class BinaryTree<K = any, V = any, R = any>
     startNode: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined = this._root,
     iterationType: IterationType = this.iterationType
   ): BinaryTreeNode<K, V> | null | undefined {
+    if (this._isMapMode && keyNodeEntryOrPredicate !== null && keyNodeEntryOrPredicate !== undefined) {
+      if (!this._isPredicate(keyNodeEntryOrPredicate)) {
+        const key = this._extractKey(keyNodeEntryOrPredicate as any);
+        if (key === null || key === undefined) return;
+        return this._store.get(key);
+      }
+    }
     return this.search(keyNodeEntryOrPredicate, true, node => node, startNode, iterationType)[0];
   }
 
@@ -1022,7 +1039,7 @@ export class BinaryTree<K = any, V = any, R = any>
     if (this._isMapMode) {
       const key = this._extractKey(keyNodeEntryOrPredicate);
       if (key === null || key === undefined) return;
-      return this._store.get(key);
+      return this._store.get(key)?.value;
     }
     return this.getNode(keyNodeEntryOrPredicate, startNode, iterationType)?.value;
   }
@@ -1059,6 +1076,13 @@ export class BinaryTree<K = any, V = any, R = any>
     startNode: K | BinaryTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined = this._root,
     iterationType: IterationType = this.iterationType
   ): boolean {
+    if (this._isMapMode && keyNodeEntryOrPredicate !== undefined && keyNodeEntryOrPredicate !== null) {
+      if (!this._isPredicate(keyNodeEntryOrPredicate)) {
+        const key = this._extractKey(keyNodeEntryOrPredicate as any);
+        if (key === null || key === undefined) return false;
+        return this._store.has(key);
+      }
+    }
     return this.search(keyNodeEntryOrPredicate, true, node => node, startNode, iterationType).length > 0;
   }
 
@@ -2086,8 +2110,7 @@ export class BinaryTree<K = any, V = any, R = any>
         current = stack.pop();
 
         if (this.isRealNode(current)) {
-          if (this._isMapMode) yield [current.key, this._store.get(current.key)];
-          else yield [current.key, current.value];
+          yield [current.key, current.value];
           // Move to the right subtree
           current = current.right;
         }
@@ -2098,8 +2121,7 @@ export class BinaryTree<K = any, V = any, R = any>
         yield* this[Symbol.iterator](node.left);
       }
 
-      if (this._isMapMode) yield [node.key, this._store.get(node.key)];
-      else yield [node.key, node.value];
+      yield [node.key, node.value];
 
       if (node.right && this.isRealNode(node)) {
         yield* this[Symbol.iterator](node.right);
@@ -2212,15 +2234,14 @@ export class BinaryTree<K = any, V = any, R = any>
       node => {
         if (node === null) cloned.set(null);
         else {
-          if (this._isMapMode) cloned.set([node.key, this._store.get(node.key)]);
-          else cloned.set([node.key, node.value]);
+          cloned.set([node.key, node.value]);
         }
       },
       this._root,
       this.iterationType,
       true // Include nulls
     );
-    if (this._isMapMode) cloned._store = this._store;
+    // Map mode: store is rebuilt via set() calls above.
   }
 
   /**
@@ -2468,8 +2489,11 @@ export class BinaryTree<K = any, V = any, R = any>
    */
   protected _setValue(key: K | null | undefined, value: V | undefined) {
     if (key === null || key === undefined) return false;
-    if (value === undefined) return false; // Or allow setting undefined?
-    return this._store.set(key, value);
+    // Map mode stores node references; update the node value in-place.
+    const node = this._store.get(key);
+    if (!node) return false;
+    node.value = value as V;
+    return true;
   }
 
   /**

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

@@ -412,7 +412,7 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
    * @returns The newly created BSTNode.
    */
   override createNode(key: K, value?: V): BSTNode<K, V> {
-    return new BSTNode<K, V>(key, this._isMapMode ? undefined : value);
+    return new BSTNode<K, V>(key, value);
   }
 
   /**
@@ -799,12 +799,12 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
     keyNodeOrEntry: K | BSTNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
     value?: V
   ): boolean {
-    const [newNode, newValue] = this._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value);
+    const [newNode] = this._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value);
     if (newNode === undefined) return false;
 
     if (this._root === undefined) {
       this._setRoot(newNode);
-      if (this._isMapMode) this._setValue(newNode?.key, newValue);
+      if (this._isMapMode && this.isRealNode(newNode)) this._store.set(newNode.key, newNode);
       this._size++;
       return true;
     }
@@ -814,13 +814,13 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
       if (this._compare(current.key, newNode.key) === 0) {
         // Key exists, replace node
         this._replaceNode(current, newNode);
-        if (this._isMapMode) this._setValue(current.key, newValue);
+        if (this._isMapMode && this.isRealNode(newNode)) this._store.set(current.key, newNode);
         return true;
       } else if (this._compare(current.key, newNode.key) > 0) {
         // Go left
         if (current.left === undefined) {
           current.left = newNode;
-          if (this._isMapMode) this._setValue(newNode?.key, newValue);
+          if (this._isMapMode && this.isRealNode(newNode)) this._store.set(newNode.key, newNode);
           this._size++;
           return true;
         }
@@ -829,7 +829,7 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
         // Go right
         if (current.right === undefined) {
           current.right = newNode;
-          if (this._isMapMode) this._setValue(newNode?.key, newValue);
+          if (this._isMapMode && this.isRealNode(newNode)) this._store.set(newNode.key, newNode);
           this._size++;
           return true;
         }

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

@@ -4,7 +4,7 @@ export * from './binary-indexed-tree';
 export * from './segment-tree';
 export * from './avl-tree';
 export * from './red-black-tree';
-export * from './avl-tree-multi-map';
 export * from './tree-multi-map';
-export * from './tree-counter';
-export * from './avl-tree-counter';
+export * from './tree-set';
+export * from './tree-map';
+export * from './tree-multi-set';

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

@@ -343,7 +343,7 @@ export class RedBlackTree<K = any, V = any, R = any> extends BST<K, V, R> implem
    * @returns A new RedBlackTreeNode instance.
    */
   override createNode(key: K, value?: V, color: RBTNColor = 'BLACK'): RedBlackTreeNode<K, V> {
-    return new RedBlackTreeNode<K, V>(key, this._isMapMode ? undefined : value, color);
+    return new RedBlackTreeNode<K, V>(key, value, color);
   }
 
   /**
@@ -509,10 +509,8 @@ export class RedBlackTree<K = any, V = any, R = any> extends BST<K, V, R> implem
     if (minN !== NIL) {
       const cMin = comparator(key, minN.key);
       if (cMin === 0) {
-        if (this._isMapMode) {
-          if (nextValue !== undefined) this._store.set(key, nextValue);
-          else this._setValue(key, nextValue);
-        } else minN.value = nextValue as V;
+        minN.value = nextValue as V;
+        if (this._isMapMode) this._store.set(key, minN);
         return { node: minN, created: false };
       }
       // Boundary attach: if key is smaller than current min and min has no left child.
@@ -521,10 +519,7 @@ export class RedBlackTree<K = any, V = any, R = any> extends BST<K, V, R> implem
       if (cMin < 0 && (minL === NIL || minL === null || minL === undefined)) {
         const newNode = this.createNode(key, nextValue);
         this._attachNewNode(minN, 'left', newNode);
-        if (this._isMapMode) {
-          if (nextValue !== undefined) this._store.set(newNode.key, nextValue);
-          else this._setValue(newNode.key, nextValue);
-        }
+        if (this._isMapMode) this._store.set(newNode.key, newNode);
         this._size++;
         this._setMinCache(newNode);
         // If max is not initialized yet (tree had 0/1 nodes), mirror max too.
@@ -538,20 +533,15 @@ export class RedBlackTree<K = any, V = any, R = any> extends BST<K, V, R> implem
         // Boundary attach: if key is greater than current max and max has no right child.
         const cMax = comparator(key, maxN.key);
         if (cMax === 0) {
-          if (this._isMapMode) {
-            if (nextValue !== undefined) this._store.set(key, nextValue);
-            else this._setValue(key, nextValue);
-          } else maxN.value = nextValue as V;
+          maxN.value = nextValue as V;
+          if (this._isMapMode) this._store.set(key, maxN);
           return { node: maxN, created: false };
         }
         const maxR = maxN.right;
         if (cMax > 0 && (maxR === NIL || maxR === null || maxR === undefined)) {
           const newNode = this.createNode(key, nextValue);
           this._attachNewNode(maxN, 'right', newNode);
-          if (this._isMapMode) {
-            if (nextValue !== undefined) this._store.set(newNode.key, nextValue);
-            else this._setValue(newNode.key, nextValue);
-          }
+          if (this._isMapMode) this._store.set(newNode.key, newNode);
           this._size++;
           this._setMaxCache(newNode);
           if (header._left === NIL) this._setMinCache(newNode);
@@ -575,12 +565,8 @@ export class RedBlackTree<K = any, V = any, R = any> extends BST<K, V, R> implem
       else if (lastCompared > 0) current = current.right ?? NIL;
       else {
         // Update existing.
-        if (isMapMode) {
-          if (nextValue !== undefined) store.set(key, nextValue);
-          else this._setValue(key, nextValue);
-        } else {
-          current.value = nextValue as V;
-        }
+        current.value = nextValue as V;
+        if (isMapMode) store.set(key, current);
         return { node: current, created: false };
       }
     }
@@ -606,10 +592,7 @@ export class RedBlackTree<K = any, V = any, R = any> extends BST<K, V, R> implem
     if (this.isRealNode(this._root)) this._root.color = 'BLACK';
     else return undefined;
 
-    if (isMapMode) {
-      if (nextValue !== undefined) store.set(newNode.key, nextValue);
-      else this._setValue(newNode.key, nextValue);
-    }
+    if (isMapMode) store.set(newNode.key, newNode);
     this._size++;
 
     // Maintain min/max caches on insertion (header.left/right are canonical).
@@ -643,10 +626,11 @@ export class RedBlackTree<K = any, V = any, R = any> extends BST<K, V, R> implem
    * @remarks Time O(log n) average, Space O(1)
    */
   protected _setKV(key: K, nextValue?: V): boolean {
-    if (this._isMapMode && nextValue !== undefined) {
+    if (this._isMapMode) {
       const store = this._store;
-      if (store.has(key)) {
-        store.set(key, nextValue);
+      const node = store.get(key);
+      if (node) {
+        node.value = nextValue as V;
         return true;
       }
     }
@@ -673,10 +657,8 @@ export class RedBlackTree<K = any, V = any, R = any> extends BST<K, V, R> implem
     const cmp = this._compare.bind(this);
     const c0 = cmp(key, hint.key);
     if (c0 === 0) {
-      if (this._isMapMode) {
-        if (value !== undefined) this._store.set(key , value );
-        else this._setValue(key, value);
-      } else hint.value = value;
+      hint.value = value;
+      if (this._isMapMode) this._store.set(key, hint);
       return hint;
     }
 
@@ -686,10 +668,7 @@ export class RedBlackTree<K = any, V = any, R = any> extends BST<K, V, R> implem
         const newNode = this.createNode(key, value);
         if (!this.isRealNode(newNode)) return undefined;
         this._attachNewNode(hint, 'left', newNode);
-        if (this._isMapMode) {
-          if (value !== undefined) this._store.set(key , value );
-          else this._setValue(key, value);
-        }
+        if (this._isMapMode) this._store.set(key, newNode);
         this._size++;
         // Maintain header/min/max caches.
         const NIL = this.NIL;
@@ -710,10 +689,7 @@ export class RedBlackTree<K = any, V = any, R = any> extends BST<K, V, R> implem
         const newNode = this.createNode(key, value);
         if (!this.isRealNode(newNode)) return undefined;
         this._attachNewNode(pred, 'right', newNode);
-        if (this._isMapMode) {
-          if (value !== undefined) this._store.set(key , value );
-          else this._setValue(key, value);
-        }
+        if (this._isMapMode) this._store.set(key, newNode);
         this._size++;
         // Maintain header/min/max caches.
         const NIL = this.NIL;
@@ -733,10 +709,7 @@ export class RedBlackTree<K = any, V = any, R = any> extends BST<K, V, R> implem
       const newNode = this.createNode(key, value);
       if (!this.isRealNode(newNode)) return undefined;
       this._attachNewNode(hint, 'right', newNode);
-      if (this._isMapMode) {
-        if (value !== undefined) this._store.set(key , value );
-        else this._setValue(key, value);
-      }
+      if (this._isMapMode) this._store.set(key, newNode);
       this._size++;
       // Maintain header/min/max caches.
       const NIL = this.NIL;
@@ -756,10 +729,7 @@ export class RedBlackTree<K = any, V = any, R = any> extends BST<K, V, R> implem
       const newNode = this.createNode(key, value);
       if (!this.isRealNode(newNode)) return undefined;
       this._attachNewNode(succ, 'left', newNode);
-      if (this._isMapMode) {
-        if (value !== undefined) this._store.set(key , value );
-        else this._setValue(key, value);
-      }
+      if (this._isMapMode) this._store.set(key, newNode);
       this._size++;
       // Maintain header/min/max caches.
       const NIL = this.NIL;
@@ -821,12 +791,24 @@ export class RedBlackTree<K = any, V = any, R = any> extends BST<K, V, R> implem
       } else {
         return false;
       }
-      if (this._isMapMode) this._setValue(newNode.key, newValue);
+      if (this._isMapMode) {
+        const n = this.getNode(newNode.key);
+        if (this.isRealNode(n)) {
+          n.value = newValue as V;
+          this._store.set(n.key, n);
+        }
+      }
       this._size++;
       return true;
     }
     if (insertStatus === 'UPDATED') {
-      if (this._isMapMode) this._setValue(newNode.key, newValue);
+      if (this._isMapMode) {
+        const n = this.getNode(newNode.key);
+        if (this.isRealNode(n)) {
+          n.value = newValue as V;
+          this._store.set(n.key, n);
+        }
+      }
       return true;
     }
     return false;