bst-typed 2.4.0 → 2.4.2

package/dist/esm-legacy/index.mjs

@@ -1196,6 +1196,9 @@ var _BinaryTree = class _BinaryTree extends IterableEntryBase {
     __publicField(this, "iterationType", "ITERATIVE");
     __publicField(this, "_isMapMode", true);
     __publicField(this, "_isDuplicate", false);
+    // Map mode acceleration store:
+    // - isMapMode=false: unused
+    // - isMapMode=true: key -> node reference (O(1) has/getNode + fast get)
     __publicField(this, "_store", /* @__PURE__ */ new Map());
     __publicField(this, "_root");
     __publicField(this, "_size", 0);
@@ -1291,7 +1294,7 @@ var _BinaryTree = class _BinaryTree 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.
@@ -1438,11 +1441,11 @@ var _BinaryTree = class _BinaryTree 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 == null ? void 0 : newNode.key, newValue);
+      if (this._isMapMode && newNode !== null && newNode !== void 0) this._store.set(newNode.key, newNode);
       this._size = 1;
       return true;
     }
@@ -1454,7 +1457,7 @@ var _BinaryTree = class _BinaryTree 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;
         }
       }
@@ -1474,7 +1477,7 @@ var _BinaryTree = class _BinaryTree extends IterableEntryBase {
       } else if (potentialParent.right === void 0) {
         potentialParent.right = newNode;
       }
-      if (this._isMapMode) this._setValue(newNode == null ? void 0 : newNode.key, newValue);
+      if (this._isMapMode && newNode !== null && newNode !== void 0) this._store.set(newNode.key, newNode);
       this._size++;
       return true;
     }
@@ -1541,13 +1544,13 @@ var _BinaryTree = class _BinaryTree 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 == null ? void 0 : curr.parent;
     let needBalanced;
@@ -1559,6 +1562,10 @@ var _BinaryTree = class _BinaryTree 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;
@@ -1642,6 +1649,13 @@ var _BinaryTree = class _BinaryTree 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];
   }
   /**
@@ -1654,15 +1668,22 @@ var _BinaryTree = class _BinaryTree extends IterableEntryBase {
    * @returns The associated value, or undefined.
    */
   get(keyNodeEntryOrPredicate, startNode = this._root, iterationType = this.iterationType) {
-    var _a;
+    var _a, _b;
     if (this._isMapMode) {
       const key = this._extractKey(keyNodeEntryOrPredicate);
       if (key === null || key === void 0) return;
-      return this._store.get(key);
+      return (_a = this._store.get(key)) == null ? void 0 : _a.value;
     }
-    return (_a = this.getNode(keyNodeEntryOrPredicate, startNode, iterationType)) == null ? void 0 : _a.value;
+    return (_b = this.getNode(keyNodeEntryOrPredicate, startNode, iterationType)) == null ? void 0 : _b.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;
   }
   /**
@@ -1731,7 +1752,7 @@ var _BinaryTree = class _BinaryTree extends IterableEntryBase {
         }
         return true;
       }, "checkBST");
-      const isStandardBST = checkBST(false);
+      const isStandardBST = checkBST();
       const isInverseBST = checkBST(true);
       return isStandardBST || isInverseBST;
     }
@@ -2407,8 +2428,7 @@ var _BinaryTree = class _BinaryTree 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;
         }
       }
@@ -2416,8 +2436,7 @@ var _BinaryTree = class _BinaryTree 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);
       }
@@ -2495,8 +2514,7 @@ var _BinaryTree = class _BinaryTree 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,
@@ -2504,7 +2522,6 @@ var _BinaryTree = class _BinaryTree extends IterableEntryBase {
       true
       // Include nulls
     );
-    if (this._isMapMode) cloned._store = this._store;
   }
   /**
    * (Protected) Recursive helper for `toVisual`.
@@ -2667,8 +2684,10 @@ var _BinaryTree = class _BinaryTree 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.
@@ -2877,7 +2896,7 @@ var _BST = class _BST 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,8 +2981,40 @@ var _BST = class _BST extends BinaryTree {
    * @returns The first matching node, or undefined if not found.
    */
   getNode(keyNodeEntryOrPredicate, startNode = this._root, iterationType = this.iterationType) {
-    var _a;
-    return (_a = this.getNodes(keyNodeEntryOrPredicate, true, startNode, iterationType)[0]) != null ? _a : void 0;
+    var _a, _b;
+    if (keyNodeEntryOrPredicate === null || keyNodeEntryOrPredicate === void 0) return void 0;
+    if (this._isPredicate(keyNodeEntryOrPredicate)) {
+      return (_a = this.getNodes(keyNodeEntryOrPredicate, true, startNode, iterationType)[0]) != null ? _a : void 0;
+    }
+    if (keyNodeEntryOrPredicate instanceof Range) {
+      return (_b = this.getNodes(
+        keyNodeEntryOrPredicate,
+        true,
+        startNode,
+        iterationType
+      )[0]) != null ? _b : 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.
@@ -2984,8 +3035,30 @@ var _BST = class _BST 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;
@@ -3064,11 +3137,11 @@ var _BST = class _BST 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 == null ? void 0 : newNode.key, newValue);
+      if (this._isMapMode && this.isRealNode(newNode)) this._store.set(newNode.key, newNode);
       this._size++;
       return true;
     }
@@ -3076,12 +3149,12 @@ var _BST = class _BST 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 == null ? void 0 : newNode.key, newValue);
+          if (this._isMapMode && this.isRealNode(newNode)) this._store.set(newNode.key, newNode);
           this._size++;
           return true;
         }
@@ -3089,7 +3162,7 @@ var _BST = class _BST extends BinaryTree {
       } else {
         if (current.right === void 0) {
           current.right = newNode;
-          if (this._isMapMode) this._setValue(newNode == null ? void 0 : newNode.key, newValue);
+          if (this._isMapMode && this.isRealNode(newNode)) this._store.set(newNode.key, newNode);
           this._size++;
           return true;
         }
@@ -3872,7 +3945,6 @@ var _BST = class _BST extends BinaryTree {
    * @returns True if the node was found and deleted, false otherwise.
    */
   _deleteByKey(key) {
-    var _a;
     let node = this._root;
     while (node) {
       const cmp = this._compare(node.key, key);
@@ -3911,7 +3983,7 @@ var _BST = class _BST extends BinaryTree {
       succ.left = node.left;
       if (succ.left) succ.left.parent = succ;
     }
-    this._size = Math.max(0, ((_a = this._size) != null ? _a : 0) - 1);
+    this._size = Math.max(0, this._size - 1);
     return true;
   }
 };