avl-tree-typed 2.4.0 → 2.4.1

package/dist/cjs/index.cjs

@@ -1226,6 +1226,9 @@ var BinaryTree = class extends IterableEntryBase {
   get isDuplicate() {
     return this._isDuplicate;
   }
+  // Map mode acceleration store:
+  // - isMapMode=false: unused
+  // - isMapMode=true: key -> node reference (O(1) has/getNode + fast get)
   _store = /* @__PURE__ */ new Map();
   /**
    * Gets the external value store (used in Map mode).
@@ -1285,7 +1288,7 @@ var BinaryTree = class extends IterableEntryBase {
    * @returns The newly created node.
    */
   createNode(key, value) {
-    return new BinaryTreeNode(key, this._isMapMode ? void 0 : value);
+    return new BinaryTreeNode(key, value);
   }
   /**
    * Creates a new, empty tree of the same type and configuration.
@@ -1432,11 +1435,11 @@ var BinaryTree = class extends IterableEntryBase {
    * @returns True if the addition was successful, false otherwise.
    */
   set(keyNodeOrEntry, value) {
-    const [newNode, newValue] = this._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value);
+    const [newNode] = this._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value);
     if (newNode === void 0) return false;
     if (!this._root) {
       this._setRoot(newNode);
-      if (this._isMapMode) this._setValue(newNode?.key, newValue);
+      if (this._isMapMode && newNode !== null && newNode !== void 0) this._store.set(newNode.key, newNode);
       this._size = 1;
       return true;
     }
@@ -1448,7 +1451,7 @@ var BinaryTree = class extends IterableEntryBase {
       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;
         }
       }
@@ -1468,7 +1471,7 @@ var BinaryTree = class extends IterableEntryBase {
       } else if (potentialParent.right === void 0) {
         potentialParent.right = newNode;
       }
-      if (this._isMapMode) this._setValue(newNode?.key, newValue);
+      if (this._isMapMode && newNode !== null && newNode !== void 0) this._store.set(newNode.key, newNode);
       this._size++;
       return true;
     }
@@ -1535,13 +1538,13 @@ var BinaryTree = class extends IterableEntryBase {
    * Deletes a node from the tree.
    * @remarks Time O(log N), For BST, Red-Black Tree, and AVL Tree subclasses, the worst-case time is O(log N). This implementation finds the node, and if it has two children, swaps it with the rightmost node of its left subtree (in-order predecessor) before deleting. Time O(N) in the worst case. O(N) to find the node (`getNode`) and O(H) (which is O(N) worst-case) to find the rightmost node. Space O(1) (if `getNode` is iterative, which it is).
    *
-   * @param keyNodeOrEntry - The node to delete.
+   * @param keyNodeEntryRawOrPredicate - The node to delete.
    * @returns An array containing deletion results (for compatibility with self-balancing trees).
    */
-  delete(keyNodeOrEntry) {
+  delete(keyNodeEntryRawOrPredicate) {
     const deletedResult = [];
     if (!this._root) return deletedResult;
-    const curr = this.getNode(keyNodeOrEntry);
+    const curr = this.getNode(keyNodeEntryRawOrPredicate);
     if (!curr) return deletedResult;
     const parent = curr?.parent;
     let needBalanced;
@@ -1553,6 +1556,10 @@ var BinaryTree = class extends IterableEntryBase {
       if (leftSubTreeRightMost) {
         const parentOfLeftSubTreeMax = leftSubTreeRightMost.parent;
         orgCurrent = this._swapProperties(curr, leftSubTreeRightMost);
+        if (this._isMapMode) {
+          this._store.set(curr.key, curr);
+          this._store.set(leftSubTreeRightMost.key, leftSubTreeRightMost);
+        }
         if (parentOfLeftSubTreeMax) {
           if (parentOfLeftSubTreeMax.right === leftSubTreeRightMost)
             parentOfLeftSubTreeMax.right = leftSubTreeRightMost.left;
@@ -1636,6 +1643,13 @@ var BinaryTree = class extends IterableEntryBase {
    * @returns The first matching node, or undefined if not found.
    */
   getNode(keyNodeEntryOrPredicate, startNode = this._root, iterationType = this.iterationType) {
+    if (this._isMapMode && keyNodeEntryOrPredicate !== null && keyNodeEntryOrPredicate !== void 0) {
+      if (!this._isPredicate(keyNodeEntryOrPredicate)) {
+        const key = this._extractKey(keyNodeEntryOrPredicate);
+        if (key === null || key === void 0) return;
+        return this._store.get(key);
+      }
+    }
     return this.search(keyNodeEntryOrPredicate, true, (node) => node, startNode, iterationType)[0];
   }
   /**
@@ -1651,11 +1665,18 @@ var BinaryTree = class extends IterableEntryBase {
     if (this._isMapMode) {
       const key = this._extractKey(keyNodeEntryOrPredicate);
       if (key === null || key === void 0) return;
-      return this._store.get(key);
+      return this._store.get(key)?.value;
     }
     return this.getNode(keyNodeEntryOrPredicate, startNode, iterationType)?.value;
   }
   has(keyNodeEntryOrPredicate, startNode = this._root, iterationType = this.iterationType) {
+    if (this._isMapMode && keyNodeEntryOrPredicate !== void 0 && keyNodeEntryOrPredicate !== null) {
+      if (!this._isPredicate(keyNodeEntryOrPredicate)) {
+        const key = this._extractKey(keyNodeEntryOrPredicate);
+        if (key === null || key === void 0) return false;
+        return this._store.has(key);
+      }
+    }
     return this.search(keyNodeEntryOrPredicate, true, (node) => node, startNode, iterationType).length > 0;
   }
   /**
@@ -1724,7 +1745,7 @@ var BinaryTree = class extends IterableEntryBase {
         }
         return true;
       }, "checkBST");
-      const isStandardBST = checkBST(false);
+      const isStandardBST = checkBST();
       const isInverseBST = checkBST(true);
       return isStandardBST || isInverseBST;
     }
@@ -2398,8 +2419,7 @@ var BinaryTree = class extends IterableEntryBase {
         }
         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];
           current = current.right;
         }
       }
@@ -2407,8 +2427,7 @@ var BinaryTree = class extends IterableEntryBase {
       if (node.left && this.isRealNode(node)) {
         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);
       }
@@ -2494,8 +2513,7 @@ var BinaryTree = class extends IterableEntryBase {
       (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,
@@ -2503,7 +2521,6 @@ var BinaryTree = class extends IterableEntryBase {
       true
       // Include nulls
     );
-    if (this._isMapMode) cloned._store = this._store;
   }
   /**
    * (Protected) Recursive helper for `toVisual`.
@@ -2666,8 +2683,10 @@ var BinaryTree = class extends IterableEntryBase {
    */
   _setValue(key, value) {
     if (key === null || key === void 0) return false;
-    if (value === void 0) return false;
-    return this._store.set(key, value);
+    const node = this._store.get(key);
+    if (!node) return false;
+    node.value = value;
+    return true;
   }
   /**
    * (Protected) Clears all nodes from the tree.
@@ -2878,7 +2897,7 @@ var BST = class extends BinaryTree {
    * @returns The newly created BSTNode.
    */
   createNode(key, value) {
-    return new BSTNode(key, this._isMapMode ? void 0 : value);
+    return new BSTNode(key, value);
   }
   /**
    * Ensures the input is a node. If it's a key or entry, it searches for the node.
@@ -2962,7 +2981,39 @@ var BST = class extends BinaryTree {
    * @returns The first matching node, or undefined if not found.
    */
   getNode(keyNodeEntryOrPredicate, startNode = this._root, iterationType = this.iterationType) {
-    return this.getNodes(keyNodeEntryOrPredicate, true, startNode, iterationType)[0] ?? void 0;
+    if (keyNodeEntryOrPredicate === null || keyNodeEntryOrPredicate === void 0) return void 0;
+    if (this._isPredicate(keyNodeEntryOrPredicate)) {
+      return this.getNodes(keyNodeEntryOrPredicate, true, startNode, iterationType)[0] ?? void 0;
+    }
+    if (keyNodeEntryOrPredicate instanceof Range) {
+      return this.getNodes(
+        keyNodeEntryOrPredicate,
+        true,
+        startNode,
+        iterationType
+      )[0] ?? void 0;
+    }
+    let targetKey;
+    if (this.isNode(keyNodeEntryOrPredicate)) {
+      targetKey = keyNodeEntryOrPredicate.key;
+    } else if (this.isEntry(keyNodeEntryOrPredicate)) {
+      const k = keyNodeEntryOrPredicate[0];
+      if (k === null || k === void 0) return void 0;
+      targetKey = k;
+    } else {
+      targetKey = keyNodeEntryOrPredicate;
+    }
+    const start = this.ensureNode(startNode);
+    if (!start) return void 0;
+    const NIL = this._NIL;
+    let cur = start;
+    const cmpFn = this._comparator;
+    while (cur && cur !== NIL) {
+      const c = cmpFn(targetKey, cur.key);
+      if (c === 0) return cur;
+      cur = c < 0 ? cur._left : cur._right;
+    }
+    return void 0;
   }
   /**
    * Searches the tree for nodes matching a predicate, key, or range.
@@ -2983,8 +3034,30 @@ var BST = class extends BinaryTree {
     if (keyNodeEntryOrPredicate === null) return [];
     startNode = this.ensureNode(startNode);
     if (!startNode) return [];
-    let predicate;
     const isRange = this.isRange(keyNodeEntryOrPredicate);
+    const isPred = !isRange && this._isPredicate(keyNodeEntryOrPredicate);
+    if (!isRange && !isPred) {
+      let targetKey;
+      if (this.isNode(keyNodeEntryOrPredicate)) {
+        targetKey = keyNodeEntryOrPredicate.key;
+      } else if (this.isEntry(keyNodeEntryOrPredicate)) {
+        const k = keyNodeEntryOrPredicate[0];
+        if (k !== null && k !== void 0) targetKey = k;
+      } else {
+        targetKey = keyNodeEntryOrPredicate;
+      }
+      if (targetKey === void 0) return [];
+      const NIL = this._NIL;
+      const cmpFn = this._comparator;
+      let cur = startNode;
+      while (cur && cur !== NIL) {
+        const c = cmpFn(targetKey, cur.key);
+        if (c === 0) return [callback(cur)];
+        cur = c < 0 ? cur._left : cur._right;
+      }
+      return [];
+    }
+    let predicate;
     if (isRange) {
       predicate = /* @__PURE__ */ __name((node) => {
         if (!node) return false;
@@ -3063,11 +3136,11 @@ var BST = class extends BinaryTree {
    * @returns True if the addition was successful, false otherwise.
    */
   set(keyNodeOrEntry, value) {
-    const [newNode, newValue] = this._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value);
+    const [newNode] = this._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value);
     if (newNode === void 0) return false;
     if (this._root === void 0) {
       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;
     }
@@ -3075,12 +3148,12 @@ var BST = class extends BinaryTree {
     while (current !== void 0) {
       if (this._compare(current.key, newNode.key) === 0) {
         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) {
         if (current.left === void 0) {
           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;
         }
@@ -3088,7 +3161,7 @@ var BST = class extends BinaryTree {
       } else {
         if (current.right === void 0) {
           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;
         }
@@ -3906,7 +3979,7 @@ var BST = class extends BinaryTree {
       succ.left = node.left;
       if (succ.left) succ.left.parent = succ;
     }
-    this._size = Math.max(0, (this._size ?? 0) - 1);
+    this._size = Math.max(0, this._size - 1);
     return true;
   }
 };
@@ -4073,7 +4146,7 @@ var AVLTree = class extends BST {
    * @returns The newly created AVLTreeNode.
    */
   createNode(key, value) {
-    return new AVLTreeNode(key, this._isMapMode ? void 0 : value);
+    return new AVLTreeNode(key, value);
   }
   /**
    * Checks if the given item is an `AVLTreeNode` instance.