serializable-bptree 1.0.4 → 2.0.0

package/dist/esm/index.js

@@ -61,10 +61,56 @@ var BPTree = class {
   search;
   order;
   nodes;
+  data;
   root;
   _creates;
   _updates;
   _updatedHead;
+  _verifierMap = {
+    gt: (nv, v) => this.comparator.isHigher(nv, v),
+    gte: (nv, v) => this.comparator.isHigher(nv, v) || this.comparator.isSame(nv, v),
+    lt: (nv, v) => this.comparator.isLower(nv, v),
+    lte: (nv, v) => this.comparator.isLower(nv, v) || this.comparator.isSame(nv, v),
+    equal: (nv, v) => this.comparator.isSame(nv, v),
+    notEqual: (nv, v) => this.comparator.isSame(nv, v) === false,
+    like: (nv, v) => {
+      const nodeValue = nv.toString();
+      const value = v.toString();
+      const pattern = value.replace(/%/g, ".*").replace(/_/g, ".");
+      const regex = new RegExp(`^${pattern}$`, "i");
+      return regex.test(nodeValue);
+    }
+  };
+  _verifierStartNode = {
+    gt: (v) => this.insertableNode(v),
+    gte: (v) => this.insertableNode(v),
+    // todo
+    lt: (v) => this.insertableNode(v),
+    lte: (v) => this.insertableNode(v),
+    // todo
+    equal: (v) => this.insertableNode(v),
+    notEqual: (v) => this.leftestNode(),
+    like: (v) => this.leftestNode()
+    // todo
+  };
+  _verifierDirection = {
+    gt: 1,
+    gte: 1,
+    lt: -1,
+    lte: -1,
+    equal: 1,
+    notEqual: 1,
+    like: 1
+  };
+  _verifierFullSearch = {
+    gt: false,
+    gte: false,
+    lt: false,
+    lte: false,
+    equal: false,
+    notEqual: true,
+    like: true
+  };
   _createNodeId() {
     const id = this.strategy.id();
     if (id === 0) {
@@ -72,7 +118,7 @@ var BPTree = class {
     }
     return id;
   }
-  _createNode(keys, values, leaf = false, parent = 0, next = 0) {
+  _createNode(keys, values, leaf = false, parent = 0, next = 0, prev = 0) {
     const id = this._createNodeId();
     const node = {
       id,
@@ -80,7 +126,8 @@ var BPTree = class {
       values,
       leaf,
       parent,
-      next
+      next,
+      prev
     };
     this.nodes.set(id, node);
     return node;
@@ -100,14 +147,16 @@ var BPTree = class {
     this.comparator = comparator;
     if (head === null) {
       this.order = strategy.order;
+      this.data = {};
       this.root = this._createNode([], [], true);
       this._setHeadUpdate(this._headState);
       this._setCreates(this.root);
       this._emitHeadUpdates();
       this._emitCreates();
     } else {
-      const { root, order } = head;
+      const { root, order, data } = head;
       this.order = order;
+      this.data = data ?? {};
       this.root = this.getNode(root);
     }
     if (this.order < 3) {
@@ -117,9 +166,11 @@ var BPTree = class {
   get _headState() {
     const root = this.root.id;
     const order = this.order;
+    const data = this.data;
     return {
       root,
-      order
+      order,
+      data
     };
   }
   _setHeadUpdate(head) {
@@ -163,7 +214,7 @@ var BPTree = class {
     }
     return node;
   }
-  _insertableNode(value) {
+  insertableNode(value) {
     let node = this.root;
     while (!node.leaf) {
       for (let i = 0, len = node.values.length; i < len; i++) {
@@ -189,7 +240,7 @@ var BPTree = class {
    * @param value The value to search for.
    */
   exists(key, value) {
-    const node = this._insertableNode(value);
+    const node = this.insertableNode(value);
     for (let i = 0, len = node.values.length; i < len; i++) {
       const nValue = node.values[i];
       if (this.comparator.isSame(value, nValue)) {
@@ -275,218 +326,50 @@ var BPTree = class {
       }
     }
   }
-  _equalCondition(condition) {
-    return Object.prototype.hasOwnProperty.call(condition, "equal");
-  }
-  _notEqualCondition(condition) {
-    return Object.prototype.hasOwnProperty.call(condition, "notEqual");
-  }
-  _onlyGtCondition(condition) {
-    return Object.prototype.hasOwnProperty.call(condition, "gt") && !Object.prototype.hasOwnProperty.call(condition, "lt");
-  }
-  _onlyLtCondition(condition) {
-    return Object.prototype.hasOwnProperty.call(condition, "lt") && !Object.prototype.hasOwnProperty.call(condition, "gt");
-  }
-  _rangeCondition(condition) {
-    return Object.prototype.hasOwnProperty.call(condition, "gt") && Object.prototype.hasOwnProperty.call(condition, "lt");
-  }
-  _getKeysFromValue(value) {
-    const keys = /* @__PURE__ */ new Set();
-    const node = this._insertableNode(value);
-    const [start, end] = this.search.range(node.values, value);
-    if (start === -1) {
-      return keys;
-    }
-    for (let i = start; i < end; i++) {
-      const pairKeys = node.keys[i];
-      for (const key of pairKeys) {
-        keys.add(key);
-      }
-    }
-    return keys;
-  }
-  _getKeysFromNEValue(value) {
-    const keys = /* @__PURE__ */ new Set();
-    let node = this.leftestNode();
-    let done = false;
-    while (!done) {
-      for (let i = 0, len = node.values.length; i < len; i++) {
-        const nValue = node.values[i];
-        const pairKeys = node.keys[i];
-        if (this.comparator.isSame(nValue, value) === false) {
-          for (const key of pairKeys) {
-            keys.add(key);
-          }
-        }
-      }
-      if (!node.next) {
-        done = true;
-        break;
-      }
-      node = this.getNode(node.next);
-    }
-    return keys;
-  }
-  _getKeysFromRange(gt, lt) {
-    const keys = /* @__PURE__ */ new Set();
-    let node = this._insertableNode(gt);
-    let done = false;
-    let found = false;
-    while (!done) {
-      for (let i = 0, len = node.values.length; i < len; i++) {
-        const nValue = node.values[i];
-        const localKeys = node.keys[i];
-        if (this.comparator.isHigher(nValue, gt) && this.comparator.isLower(nValue, lt)) {
-          found = true;
-          for (const key of localKeys) {
-            keys.add(key);
-          }
-        } else if (found) {
-          done = true;
-          break;
-        }
-      }
-      if (!node.next) {
-        done = true;
-        break;
-      }
-      node = this.getNode(node.next);
-    }
-    return keys;
-  }
-  _getKeysFromGt(gt) {
-    const keys = /* @__PURE__ */ new Set();
-    let node = this._insertableNode(gt);
-    let done = false;
-    let found = false;
-    while (!done) {
-      for (let i = 0, len = node.values.length; i < len; i++) {
-        const nValue = node.values[i];
-        const localKeys = node.keys[i];
-        if (this.comparator.isHigher(nValue, gt)) {
-          found = true;
-          for (const key of localKeys) {
-            keys.add(key);
-          }
-        } else if (found) {
-          done = true;
-          break;
-        }
-      }
-      if (!node.next) {
-        done = true;
-        break;
-      }
-      node = this.getNode(node.next);
-    }
-    return keys;
-  }
-  _getKeysFromLt(lt) {
-    const keys = /* @__PURE__ */ new Set();
-    let node = this.leftestNode();
-    let done = false;
-    let found = false;
-    while (!done) {
-      for (let i = 0, len = node.values.length; i < len; i++) {
-        const nValue = node.values[i];
-        const localKeys = node.keys[i];
-        if (this.comparator.isLower(nValue, lt)) {
-          found = true;
-          for (const key of localKeys) {
-            keys.add(key);
-          }
-        } else if (found) {
-          done = true;
-          break;
-        }
-      }
-      if (!node.next) {
-        done = true;
-        break;
-      }
-      node = this.getNode(node.next);
-    }
-    return keys;
-  }
-  _getPairsFromValue(value) {
-    const node = this._insertableNode(value);
-    const [start, end] = this.search.range(node.values, value);
-    if (start === -1) {
-      return [];
-    }
-    const pairs = [];
-    for (let i = start; i < end; i++) {
-      const keys = node.keys[i];
-      for (const key of keys) {
-        pairs.push({ key, value });
-      }
-    }
-    return pairs;
-  }
-  _getPairsFromNEValue(value) {
+  _getPairsRightToLeft(value, startNode, fullSearch, comparator) {
     const pairs = [];
-    let node = this.leftestNode();
-    let done = false;
-    while (!done) {
-      for (let i = 0, len = node.values.length; i < len; i++) {
-        const nValue = node.values[i];
-        const keys = node.keys[i];
-        if (this.comparator.isSame(nValue, value) === false) {
-          for (const key of keys) {
-            pairs.push({ key, value: nValue });
-          }
-        }
-      }
-      if (!node.next) {
-        done = true;
-        break;
-      }
-      node = this.getNode(node.next);
-    }
-    return pairs;
-  }
-  _getPairsFromRange(gt, lt) {
-    const pairs = [];
-    let node = this._insertableNode(gt);
+    let node = startNode;
     let done = false;
     let found = false;
     while (!done) {
-      for (let i = 0, len = node.values.length; i < len; i++) {
+      let i = node.values.length;
+      while (i--) {
         const nValue = node.values[i];
         const keys = node.keys[i];
-        if (this.comparator.isHigher(nValue, gt) && this.comparator.isLower(nValue, lt)) {
+        if (comparator(nValue, value)) {
           found = true;
-          for (const key of keys) {
-            pairs.push({ key, value: nValue });
+          let j = keys.length;
+          while (j--) {
+            pairs.push({ key: keys[j], value: nValue });
           }
-        } else if (found) {
+        } else if (found && !fullSearch) {
           done = true;
           break;
         }
       }
-      if (!node.next) {
+      if (!node.prev) {
         done = true;
         break;
       }
-      node = this.getNode(node.next);
+      node = this.getNode(node.prev);
     }
-    return pairs;
+    return pairs.reverse();
   }
-  _getPairsFromGt(gt) {
+  _getPairsLeftToRight(value, startNode, fullSearch, comparator) {
     const pairs = [];
-    let node = this._insertableNode(gt);
+    let node = startNode;
     let done = false;
     let found = false;
     while (!done) {
       for (let i = 0, len = node.values.length; i < len; i++) {
         const nValue = node.values[i];
         const keys = node.keys[i];
-        if (this.comparator.isHigher(nValue, gt)) {
+        if (comparator(nValue, value)) {
           found = true;
           for (const key of keys) {
             pairs.push({ key, value: nValue });
           }
-        } else if (found) {
+        } else if (found && !fullSearch) {
           done = true;
           break;
         }
@@ -499,75 +382,62 @@ var BPTree = class {
     }
     return pairs;
   }
-  _getPairsFromLt(lt) {
-    const pairs = [];
-    let node = this.leftestNode();
-    let done = false;
-    let found = false;
-    while (!done) {
-      for (let i = 0, len = node.values.length; i < len; i++) {
-        const nValue = node.values[i];
-        const keys = node.keys[i];
-        if (this.comparator.isLower(nValue, lt)) {
-          found = true;
-          for (const key of keys) {
-            pairs.push({ key, value: nValue });
-          }
-        } else if (found) {
-          done = true;
-          break;
-        }
-      }
-      if (!node.next) {
-        done = true;
-        break;
-      }
-      node = this.getNode(node.next);
+  getPairs(value, startNode, fullSearch, comparator, direction) {
+    switch (direction) {
+      case -1:
+        return this._getPairsRightToLeft(value, startNode, fullSearch, comparator);
+      case 1:
+        return this._getPairsLeftToRight(value, startNode, fullSearch, comparator);
+      default:
+        throw new Error(`Direction must be -1 or 1. but got a ${direction}`);
     }
-    return pairs;
   }
   /**
    * It searches for a key within the tree. The result is returned as an array sorted in ascending order based on the value.  
-   * The result is key set instance, and you can use the `gt`, `lt`, `equal`, `notEqual` condition statements.
+   * The result is key set instance, and you can use the `gt`, `lt`, `gte`, `lte`, `equal`, `notEqual`, `like` condition statements.
    * This method operates much faster than first searching with `where` and then retrieving only the key list.
-   * @param condition You can use the `gt`, `lt`, `equal`, `notEqual` condition statements.
+   * @param condition You can use the `gt`, `lt`, `gte`, `lte`, `equal`, `notEqual`, `like` condition statements.
    */
   keys(condition) {
-    if (this._equalCondition(condition)) {
-      return this._getKeysFromValue(condition.equal);
-    } else if (this._notEqualCondition(condition)) {
-      return this._getKeysFromNEValue(condition.notEqual);
-    } else if (this._rangeCondition(condition)) {
-      const { gt, lt } = condition;
-      return this._getKeysFromRange(gt, lt);
-    } else if (this._onlyGtCondition(condition)) {
-      return this._getKeysFromGt(condition.gt);
-    } else if (this._onlyLtCondition(condition)) {
-      return this._getKeysFromLt(condition.lt);
-    } else {
-      throw new Error(`The 'condition' parameter is invalid.`);
+    let result = null;
+    for (const k in condition) {
+      const key = k;
+      const value = condition[key];
+      const startNode = this._verifierStartNode[key](value);
+      const direction = this._verifierDirection[key];
+      const fullSearch = this._verifierFullSearch[key];
+      const comparator = this._verifierMap[key];
+      const pairs = this.getPairs(value, startNode, fullSearch, comparator, direction);
+      if (result === null) {
+        result = pairs.map((pair) => pair.key);
+      } else {
+        result = result.filter((key2) => pairs.find((p) => p.key === key2));
+      }
     }
+    return new Set(result ?? []);
   }
   /**
    * It searches for a value within the tree. The result is returned as an array sorted in ascending order based on the value.  
-   * The result includes the key and value attributes, and you can use the `gt`, `lt`, `equal`, `notEqual` condition statements.
-   * @param condition You can use the `gt`, `lt`, `equal`, `notEqual` condition statements.
+   * The result includes the key and value attributes, and you can use the `gt`, `lt`, `gte`, `lte`, `equal`, `notEqual`, `like` condition statements.
+   * @param condition You can use the `gt`, `lt`, `gte`, `lte`, `equal`, `notEqual`, `like` condition statements.
    */
   where(condition) {
-    if (this._equalCondition(condition)) {
-      return this._getPairsFromValue(condition.equal);
-    } else if (this._notEqualCondition(condition)) {
-      return this._getPairsFromNEValue(condition.notEqual);
-    } else if (this._rangeCondition(condition)) {
-      const { gt, lt } = condition;
-      return this._getPairsFromRange(gt, lt);
-    } else if (this._onlyGtCondition(condition)) {
-      return this._getPairsFromGt(condition.gt);
-    } else if (this._onlyLtCondition(condition)) {
-      return this._getPairsFromLt(condition.lt);
-    } else {
-      throw new Error(`The 'condition' parameter is invalid.`);
+    let result = null;
+    for (const k in condition) {
+      const key = k;
+      const value = condition[key];
+      const startNode = this._verifierStartNode[key](value);
+      const direction = this._verifierDirection[key];
+      const fullSearch = this._verifierFullSearch[key];
+      const comparator = this._verifierMap[key];
+      const pairs = this.getPairs(value, startNode, fullSearch, comparator, direction);
+      if (result === null) {
+        result = pairs;
+      } else {
+        result = result.filter((pair) => pairs.find((p) => p.key === pair.key));
+      }
     }
+    return result ?? [];
   }
   /**
    * You enter the key and value as a pair. You can later search for the pair by value.
@@ -576,7 +446,7 @@ var BPTree = class {
    * @param value The value of the pair.
    */
   insert(key, value) {
-    const before = this._insertableNode(value);
+    const before = this.insertableNode(value);
     this._insertAtLeaf(before, key, value);
     if (before.values.length === this.order) {
       const after = this._createNode(
@@ -584,14 +454,21 @@ var BPTree = class {
         [],
         true,
         before.parent,
-        before.next
+        before.next,
+        before.id
       );
       const mid = Math.ceil(this.order / 2) - 1;
+      const beforeNext = before.next;
       after.values = before.values.slice(mid + 1);
       after.keys = before.keys.slice(mid + 1);
       before.values = before.values.slice(0, mid + 1);
       before.keys = before.keys.slice(0, mid + 1);
       before.next = after.id;
+      if (beforeNext) {
+        const node = this.getNode(beforeNext);
+        node.prev = after.id;
+        this._setUpdates(node);
+      }
       this._insertInParent(before, after.values[0], after);
       this._setCreates(after);
       this._setUpdates(before);
@@ -606,7 +483,7 @@ var BPTree = class {
    * @param value The value of the pair.
    */
   delete(key, value) {
-    const node = this._insertableNode(value);
+    const node = this.insertableNode(value);
     let i = node.values.length;
     while (i--) {
       const nValue = node.values[i];
@@ -667,18 +544,18 @@ var BPTree = class {
       let parentNode = this.getNode(node.parent);
       let prevNode = null;
       let nextNode = null;
-      let prevK = null;
-      let postK = null;
+      let prevValue = null;
+      let postValue = null;
       for (let i = 0, len = parentNode.keys.length; i < len; i++) {
         const nKey = parentNode.keys[i];
         if (nKey === node.id) {
           if (i > 0) {
             prevNode = this.getNode(parentNode.keys[i - 1]);
-            prevK = parentNode.values[i - 1];
+            prevValue = parentNode.values[i - 1];
           }
           if (i < parentNode.keys.length - 1) {
             nextNode = this.getNode(parentNode.keys[i + 1]);
-            postK = parentNode.values[i];
+            postValue = parentNode.values[i];
           }
         }
       }
@@ -686,19 +563,19 @@ var BPTree = class {
       let guess;
       if (prevNode === null) {
         pointer = nextNode;
-        guess = postK;
+        guess = postValue;
       } else if (nextNode === null) {
         isPredecessor = true;
         pointer = prevNode;
-        guess = prevK;
+        guess = prevValue;
       } else {
         if (node.values.length + nextNode.values.length < this.order) {
           pointer = nextNode;
-          guess = postK;
+          guess = postValue;
         } else {
           isPredecessor = true;
           pointer = prevNode;
-          guess = prevK;
+          guess = prevValue;
         }
       }
       if (node.values.length + pointer.values.length < this.order) {
@@ -712,6 +589,20 @@ var BPTree = class {
           pointer.values.push(guess);
         } else {
           pointer.next = node.next;
+          pointer.prev = node.id;
+          if (pointer.next) {
+            const n = this.getNode(node.next);
+            n.prev = pointer.id;
+            this._setUpdates(n);
+          }
+          if (pointer.prev) {
+            const n = this.getNode(node.id);
+            n.next = pointer.id;
+            this._setUpdates(n);
+          }
+          if (isPredecessor) {
+            pointer.prev = 0;
+          }
         }
         pointer.values.push(...node.values);
         if (!pointer.leaf) {
@@ -818,6 +709,25 @@ var BPTree = class {
       }
     }
   }
+  /**
+   * Returns the user-defined data stored in the head of the tree.
+   * This value can be set using the `setHeadData` method. If no data has been previously inserted, the default value is returned, and the default value is `{}`.
+   * @returns User-defined data stored in the head of the tree.
+   */
+  getHeadData() {
+    return this.data;
+  }
+  /**
+   * Inserts user-defined data into the head of the tree.
+   * This feature is useful when you need to store separate, non-volatile information in the tree.
+   * For example, you can store information such as the last update time and the number of insertions.
+   * @param data User-defined data to be stored in the head of the tree.
+   */
+  setHeadData(data) {
+    this.data = data;
+    this._updatedHead = this._headState;
+    this._emitHeadUpdates();
+  }
 };
 
 // src/SerializeStrategy.ts