serializable-bptree 1.0.3 → 1.1.0

package/dist/cjs/index.js

@@ -92,6 +92,7 @@ var BPTree = class {
   search;
   order;
   nodes;
+  data;
   root;
   _creates;
   _updates;
@@ -131,14 +132,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) {
@@ -148,9 +151,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) {
@@ -321,6 +326,124 @@ var BPTree = class {
   _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);
@@ -439,6 +562,28 @@ var BPTree = class {
     }
     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.
+   * 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.
+   */
+  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.`);
+    }
+  }
   /**
    * 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.
@@ -709,6 +854,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

package/dist/esm/index.js

@@ -61,6 +61,7 @@ var BPTree = class {
   search;
   order;
   nodes;
+  data;
   root;
   _creates;
   _updates;
@@ -100,14 +101,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 +120,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) {
@@ -290,6 +295,124 @@ var BPTree = class {
   _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);
@@ -408,6 +531,28 @@ var BPTree = class {
     }
     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.
+   * 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.
+   */
+  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.`);
+    }
+  }
   /**
    * 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.
@@ -678,6 +823,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

package/dist/typings/BPTree.d.ts

@@ -1,3 +1,4 @@
+import type { Json } from './utils/types';
 import { BinarySearch } from './utils/BinarySearch';
 import { ValueComparator } from './ValueComparator';
 import { SerializeStrategy } from './SerializeStrategy';
@@ -36,6 +37,7 @@ export declare class BPTree<K, V> {
     protected readonly search: BinarySearch<V>;
     protected readonly order: number;
     protected readonly nodes: Map<number, BPTreeUnknownNode<K, V>>;
+    protected data: Record<string, Json>;
     protected root: BPTreeUnknownNode<K, V>;
     private readonly _creates;
     private readonly _updates;
@@ -70,11 +72,23 @@ export declare class BPTree<K, V> {
     private _onlyGtCondition;
     private _onlyLtCondition;
     private _rangeCondition;
+    private _getKeysFromValue;
+    private _getKeysFromNEValue;
+    private _getKeysFromRange;
+    private _getKeysFromGt;
+    private _getKeysFromLt;
     private _getPairsFromValue;
     private _getPairsFromNEValue;
     private _getPairsFromRange;
     private _getPairsFromGt;
     private _getPairsFromLt;
+    /**
+     * 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.
+     * 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.
+     */
+    keys(condition: BPTreeCondition<V>): Set<K>;
     /**
      * 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.
@@ -95,5 +109,18 @@ export declare class BPTree<K, V> {
      */
     delete(key: K, value: V): void;
     private _deleteEntry;
+    /**
+     * 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(): Record<string, Json>;
+    /**
+     * 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: Record<string, Json>): void;
 }
 export {};

package/dist/typings/SerializeStrategy.d.ts

@@ -1,7 +1,9 @@
 import { BPTreeNode } from './BPTree';
+import type { Json } from './utils/types';
 export interface SerializeStrategyHead {
     root: number;
     order: number;
+    data: Record<string, Json>;
 }
 export declare abstract class SerializeStrategy<K, V> {
     readonly order: number;

package/dist/typings/utils/types.d.ts

@@ -0,0 +1,5 @@
+type Primitive = string | number | null | boolean;
+type Json = Primitive | Primitive[] | Json[] | {
+    [key: string]: Json;
+};
+export type { Json };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "serializable-bptree",
-  "version": "1.0.3",
+  "version": "1.1.0",
   "description": "Store the B+tree flexibly, not only in-memory.",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",