serializable-bptree 1.0.0

package/dist/esm/index.js

@@ -0,0 +1,741 @@
+// src/utils/BinarySearch.ts
+var BinarySearch = class {
+  comparator;
+  constructor(comparator) {
+    this.comparator = comparator;
+  }
+  _withRange(array, value, left = 0, right = array.length - 1) {
+    while (left <= right) {
+      const mid = Math.floor((left + right) / 2);
+      const guess = array[mid];
+      if (this.comparator.isSame(guess, value)) {
+        return mid;
+      } else if (this.comparator.isLower(guess, value)) {
+        left = mid + 1;
+        continue;
+      } else {
+        right = mid - 1;
+        continue;
+      }
+    }
+    return -1;
+  }
+  leftest(array, value) {
+    let i = this._withRange(array, value);
+    if (i === -1) {
+      return -1;
+    }
+    while (i > 0) {
+      if (!this.comparator.isSame(array[i - 1], value)) {
+        break;
+      }
+      i--;
+    }
+    return i;
+  }
+  rightest(array, value) {
+    let i = this._withRange(array, value);
+    if (i === -1) {
+      return -1;
+    }
+    const max = array.length - 1;
+    while (i < max) {
+      if (!this.comparator.isSame(array[i + 1], value)) {
+        break;
+      }
+      i++;
+    }
+    return i;
+  }
+  range(array, value) {
+    const left = this.leftest(array, value);
+    const right = this.rightest(array, value) + 1;
+    return [left, right];
+  }
+};
+
+// src/BPTree.ts
+var BPTree = class {
+  strategy;
+  comparator;
+  search;
+  order;
+  nodes;
+  root;
+  _creates;
+  _updates;
+  _updatedHead;
+  _createNodeId() {
+    const id = this.strategy.id();
+    if (id === 0) {
+      throw new Error(`The node's id should never be 0.`);
+    }
+    return id;
+  }
+  _createNode(keys, values, leaf = false, parent = 0, next = 0) {
+    const id = this._createNodeId();
+    const node = {
+      id,
+      keys,
+      values,
+      leaf,
+      parent,
+      next
+    };
+    this.nodes.set(id, node);
+    return node;
+  }
+  /**
+   * @param strategy An instance of a strategy that manages the read/write state of a node.
+   * @param comparator An instance of a comparator that compares the size of values.
+   */
+  constructor(strategy, comparator) {
+    const head = strategy.readHead();
+    this._creates = /* @__PURE__ */ new Map();
+    this._updates = /* @__PURE__ */ new Map();
+    this._updatedHead = null;
+    this.nodes = /* @__PURE__ */ new Map();
+    this.search = new BinarySearch(comparator);
+    this.strategy = strategy;
+    this.comparator = comparator;
+    if (head === null) {
+      this.order = strategy.order;
+      this.root = this._createNode([], [], true);
+      this._setHeadUpdate(this._headState);
+      this._setCreates(this.root);
+      this._emitHeadUpdates();
+      this._emitCreates();
+    } else {
+      const { root, order } = head;
+      this.order = order;
+      this.root = this.getNode(root);
+    }
+    if (this.order < 3) {
+      throw new Error(`The 'order' parameter must be greater than 2. but got a '${this.order}'.`);
+    }
+  }
+  get _headState() {
+    const root = this.root.id;
+    const order = this.order;
+    return {
+      root,
+      order
+    };
+  }
+  _setHeadUpdate(head) {
+    this._updatedHead = head;
+  }
+  _setCreates(node) {
+    this._creates.set(node.id, node);
+  }
+  _setUpdates(node) {
+    this._updates.set(node.id, node);
+  }
+  _emitHeadUpdates() {
+    if (this._updatedHead !== null) {
+      this.strategy.writeHead(this._updatedHead);
+    }
+    this._updatedHead = null;
+  }
+  _emitCreates() {
+    for (const node of this._creates.values()) {
+      this.strategy.write(node.id, node);
+    }
+    this._creates.clear();
+  }
+  _emitUpdates() {
+    for (const node of this._updates.values()) {
+      this.strategy.write(node.id, node);
+    }
+    this._updates.clear();
+  }
+  getNode(id) {
+    if (!this.nodes.has(id)) {
+      this.nodes.set(id, this.strategy.read(id));
+    }
+    return this.nodes.get(id);
+  }
+  leftestNode() {
+    let node = this.root;
+    while (!node.leaf) {
+      node = node.keys[0];
+    }
+    return node;
+  }
+  _insertableNode(value) {
+    let node = this.root;
+    while (!node.leaf) {
+      for (let i = 0, len = node.values.length; i < len; i++) {
+        const nValue = node.values[i];
+        if (this.comparator.isSame(value, nValue)) {
+          node = node.keys[i + 1];
+          break;
+        } else if (this.comparator.isLower(value, nValue)) {
+          node = node.keys[i];
+          break;
+        } else if (i + 1 === node.values.length) {
+          node = node.keys[i + 1];
+          break;
+        }
+      }
+    }
+    return node;
+  }
+  /**
+   * It returns whether there is a value in the tree.
+   * @param key The key value to search for.
+   * @param value The value to search for.
+   */
+  exists(key, 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)) {
+        const keys = node.keys[i];
+        return keys.includes(key);
+      }
+    }
+    return false;
+  }
+  _insertAtLeaf(node, key, value) {
+    if (node.values.length) {
+      for (let i = 0, len = node.values.length; i < len; i++) {
+        const nValue = node.values[i];
+        if (this.comparator.isSame(value, nValue)) {
+          const keys = node.keys[i];
+          keys.push(key);
+          this._setUpdates(node);
+          break;
+        } else if (this.comparator.isLower(value, nValue)) {
+          node.values.splice(i, 0, value);
+          node.keys.splice(i, 0, [key]);
+          this._setUpdates(node);
+          break;
+        } else if (i + 1 === node.values.length) {
+          node.values.push(value);
+          node.keys.push([key]);
+          this._setUpdates(node);
+          break;
+        }
+      }
+    } else {
+      node.values = [value];
+      node.keys = [[key]];
+      this._setUpdates(node);
+    }
+  }
+  _insertInParent(node, value, pointer) {
+    if (this.root === node) {
+      const root = this._createNode([node, pointer], [value]);
+      this.root = root;
+      node.parent = root.id;
+      pointer.parent = root.id;
+      this._setHeadUpdate(this._headState);
+      this._setCreates(root);
+      this._setUpdates(node);
+      this._setUpdates(pointer);
+      return;
+    }
+    const parentNode = this.getNode(node.parent);
+    for (let i = 0, len = parentNode.keys.length; i < len; i++) {
+      const nKeys = parentNode.keys[i];
+      if (nKeys === node) {
+        parentNode.values.splice(i, 0, value);
+        parentNode.keys.splice(i + 1, 0, pointer);
+        this._setUpdates(parentNode);
+        if (parentNode.keys.length > this.order) {
+          const parentPointer = this._createNode([], []);
+          parentPointer.parent = parentNode.parent;
+          const mid = Math.ceil(this.order / 2) - 1;
+          parentPointer.values = parentNode.values.slice(mid + 1);
+          parentPointer.keys = parentNode.keys.slice(mid + 1);
+          const midValue = parentNode.values[mid];
+          if (mid === 0) {
+            parentNode.values = parentNode.values.slice(0, mid + 1);
+          } else {
+            parentNode.values = parentNode.values.slice(0, mid);
+          }
+          parentNode.keys = parentNode.keys.slice(0, mid + 1);
+          for (const k of parentNode.keys) {
+            const key = k;
+            key.parent = parentNode.id;
+          }
+          for (const k of parentPointer.keys) {
+            const key = k;
+            key.parent = parentPointer.id;
+          }
+          this._insertInParent(parentNode, midValue, parentPointer);
+          this._setCreates(parentPointer);
+          this._setUpdates(parentNode);
+        }
+      }
+    }
+  }
+  _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");
+  }
+  _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) {
+    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 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) && 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);
+    }
+    return pairs;
+  }
+  _getPairsFromGt(gt) {
+    const pairs = [];
+    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 keys = node.keys[i];
+        if (this.comparator.isHigher(nValue, gt)) {
+          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);
+    }
+    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);
+    }
+    return pairs;
+  }
+  /**
+   * 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.
+   */
+  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.`);
+    }
+  }
+  /**
+   * You enter the key and value as a pair. You can later search for the pair by value.
+   * This data is stored in the tree, sorted in ascending order of value.
+   * @param key The key of the pair.
+   * @param value The value of the pair.
+   */
+  insert(key, value) {
+    const before = this._insertableNode(value);
+    this._insertAtLeaf(before, key, value);
+    if (before.values.length === this.order) {
+      const after = this._createNode(
+        [],
+        [],
+        true,
+        before.parent,
+        before.next
+      );
+      const mid = Math.ceil(this.order / 2) - 1;
+      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;
+      this._insertInParent(before, after.values[0], after);
+      this._setCreates(after);
+      this._setUpdates(before);
+    }
+    this._emitHeadUpdates();
+    this._emitCreates();
+    this._emitUpdates();
+  }
+  /**
+   * Deletes the pair that matches the key and value.
+   * @param key The key of the pair.
+   * @param value The value of the pair.
+   */
+  delete(key, 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)) {
+        const keys = node.keys[i];
+        if (keys.includes(key)) {
+          if (keys.length > 1) {
+            keys.splice(keys.indexOf(key), 1);
+            this._setUpdates(node);
+          } else if (node === this.root) {
+            node.values.splice(i, 1);
+            node.keys.splice(i, 1);
+            this._setUpdates(node);
+          } else {
+            keys.splice(keys.indexOf(key), 1);
+            node.keys.splice(i, 1);
+            node.values.splice(node.values.indexOf(value), 1);
+            this._deleteEntry(node, key, value);
+            this._setUpdates(node);
+          }
+        }
+      }
+    }
+    this._emitHeadUpdates();
+    this._emitCreates();
+    this._emitUpdates();
+  }
+  _deleteEntry(node, key, value) {
+    if (!node.leaf) {
+      for (let i = 0, len = node.keys.length; i < len; i++) {
+        const nKey = node.keys[i];
+        if (nKey === key) {
+          node.keys.splice(i, 1);
+          this._setUpdates(node);
+          break;
+        }
+      }
+      for (let i = 0, len = node.values.length; i < len; i++) {
+        const nValue = node.values[i];
+        if (this.comparator.isSame(value, nValue)) {
+          node.values.splice(i, 1);
+          this._setUpdates(node);
+          break;
+        }
+      }
+    }
+    if (this.root === node && node.keys.length === 1) {
+      const keys = node.keys;
+      this.root = keys[0];
+      this.root.parent = 0;
+      this._setHeadUpdate(this._headState);
+      this._setUpdates(this.root);
+      return;
+    } else if (this.root === node) {
+      return;
+    } else if (node.keys.length < Math.ceil(this.order / 2) && !node.leaf || node.values.length < Math.ceil((this.order - 1) / 2) && node.leaf) {
+      let isPredecessor = false;
+      let parentNode = this.getNode(node.parent);
+      let prevNode = null;
+      let nextNode = null;
+      let prevK = null;
+      let postK = null;
+      for (let i = 0, len = parentNode.keys.length; i < len; i++) {
+        const nKey = parentNode.keys[i];
+        if (nKey === node) {
+          if (i > 0) {
+            prevNode = parentNode.keys[i - 1];
+            prevK = parentNode.values[i - 1];
+          }
+          if (i < parentNode.keys.length - 1) {
+            nextNode = parentNode.keys[i + 1];
+            postK = parentNode.values[i];
+          }
+        }
+      }
+      let pointer;
+      let guess;
+      if (prevNode === null) {
+        pointer = nextNode;
+        guess = postK;
+      } else if (nextNode === null) {
+        isPredecessor = true;
+        pointer = prevNode;
+        guess = prevK;
+      } else {
+        if (node.values.length + nextNode.values.length < this.order) {
+          pointer = nextNode;
+          guess = postK;
+        } else {
+          isPredecessor = true;
+          pointer = prevNode;
+          guess = prevK;
+        }
+      }
+      if (node.values.length + pointer.values.length < this.order) {
+        if (!isPredecessor) {
+          const pTemp = pointer;
+          pointer = node;
+          node = pTemp;
+        }
+        pointer.keys.push(...node.keys);
+        if (!node.leaf) {
+          pointer.values.push(guess);
+        } else {
+          pointer.next = node.next;
+        }
+        pointer.values.push(...node.values);
+        if (!pointer.leaf) {
+          const keys = pointer.keys;
+          for (const key2 of keys) {
+            key2.parent = pointer.id;
+          }
+        }
+        this._deleteEntry(this.getNode(node.parent), node, guess);
+        this._setUpdates(pointer);
+      } else {
+        if (isPredecessor) {
+          let pointerPm;
+          let pointerKm;
+          if (!node.leaf) {
+            pointerPm = pointer.keys.splice(-1)[0];
+            pointerKm = pointer.values.splice(-1)[0];
+            node.keys = [pointerPm, ...node.keys];
+            node.values = [guess, ...node.values];
+            parentNode = this.getNode(node.parent);
+            for (let i = 0, len = parentNode.values.length; i < len; i++) {
+              const nValue = parentNode.values[i];
+              if (this.comparator.isSame(guess, nValue)) {
+                parentNode.values[i] = pointerKm;
+                this._setUpdates(parentNode);
+                break;
+              }
+            }
+          } else {
+            pointerPm = pointer.keys.splice(-1)[0];
+            pointerKm = pointer.values.splice(-1)[0];
+            node.keys = [pointerPm, ...node.keys];
+            node.values = [pointerKm, ...node.values];
+            parentNode = this.getNode(node.parent);
+            for (let i = 0, len = parentNode.values.length; i < len; i++) {
+              const nValue = parentNode.values[i];
+              if (this.comparator.isSame(guess, nValue)) {
+                parentNode.values[i] = pointerKm;
+                this._setUpdates(parentNode);
+                break;
+              }
+            }
+          }
+          this._setUpdates(node);
+          this._setUpdates(pointer);
+        } else {
+          let pointerP0;
+          let pointerK0;
+          if (!node.leaf) {
+            pointerP0 = pointer.keys.splice(0, 1)[0];
+            pointerK0 = pointer.values.splice(0, 1)[0];
+            node.keys = [...node.keys, pointerP0];
+            node.values = [...node.values, guess];
+            parentNode = this.getNode(node.parent);
+            for (let i = 0, len = parentNode.values.length; i < len; i++) {
+              const nValue = parentNode.values[i];
+              if (this.comparator.isSame(guess, nValue)) {
+                parentNode.values[i] = pointerK0;
+                this._setUpdates(parentNode);
+                break;
+              }
+            }
+          } else {
+            pointerP0 = pointer.keys.splice(0, 1)[0];
+            pointerK0 = pointer.values.splice(0, 1)[0];
+            node.keys = [...node.keys, pointerP0];
+            node.values = [...node.values, pointerK0];
+            parentNode = this.getNode(node.parent);
+            for (let i = 0, len = parentNode.values.length; i < len; i++) {
+              const nValue = parentNode.values[i];
+              if (this.comparator.isSame(guess, nValue)) {
+                parentNode.values[i] = pointer.values[0];
+                this._setUpdates(parentNode);
+                break;
+              }
+            }
+          }
+          this._setUpdates(node);
+          this._setUpdates(pointer);
+        }
+        if (!pointer.leaf) {
+          const keys = pointer.keys;
+          for (const key2 of keys) {
+            key2.parent = pointer.id;
+            this._setUpdates(pointer);
+          }
+        }
+        if (!node.leaf) {
+          const keys = node.keys;
+          for (const key2 of keys) {
+            key2.parent = node.id;
+            this._setUpdates(node);
+          }
+        }
+        if (!parentNode.leaf) {
+          const keys = parentNode.keys;
+          for (const key2 of keys) {
+            key2.parent = parentNode.id;
+            this._setUpdates(parentNode);
+          }
+        }
+      }
+    }
+  }
+};
+
+// src/SerializeStrategy.ts
+var SerializeStrategy = class {
+  order;
+  constructor(order) {
+    this.order = order;
+  }
+};
+var InMemoryStoreStrategy = class extends SerializeStrategy {
+  data;
+  constructor(order) {
+    super(order);
+    this.data = {
+      head: null,
+      node: {}
+    };
+  }
+  id() {
+    return Math.ceil(Math.random() * Number.MAX_SAFE_INTEGER - 1);
+  }
+  read(id) {
+    if (Object.prototype.hasOwnProperty.call(this.data, id)) {
+      throw new Error(`The tree attempted to reference node '${id}', but couldn't find the corresponding node.`);
+    }
+    return this.data.node[id];
+  }
+  write(id, node) {
+    this.data.node[id] = node;
+  }
+  readHead() {
+    return this.data.head;
+  }
+  writeHead(head) {
+    this.data.head = head;
+  }
+};
+
+// src/ValueComparator.ts
+var ValueComparator = class {
+  isLower(value, than) {
+    return this.asc(value, than) < 0;
+  }
+  isSame(value, than) {
+    return this.asc(value, than) === 0;
+  }
+  isHigher(value, than) {
+    return this.asc(value, than) > 0;
+  }
+};
+var NumericComparator = class extends ValueComparator {
+  asc(a, b) {
+    return a - b;
+  }
+};
+var StringComparator = class extends ValueComparator {
+  asc(a, b) {
+    return a.localeCompare(b);
+  }
+};
+export {
+  BPTree,
+  InMemoryStoreStrategy,
+  NumericComparator,
+  SerializeStrategy,
+  StringComparator,
+  ValueComparator
+};