serializable-bptree 1.0.4 → 2.0.0

package/dist/typings/BPTree.d.ts

@@ -1,14 +1,23 @@
+import type { Json } from './utils/types';
 import { BinarySearch } from './utils/BinarySearch';
 import { ValueComparator } from './ValueComparator';
 import { SerializeStrategy } from './SerializeStrategy';
-type BPTreeCondition<V> = {
-    gt?: V;
-    lt?: V;
-} | {
+type BPTreeCondition<V> = Partial<{
+    /** Searches for pairs greater than the given value. */
+    gt: V;
+    /** Searches for pairs less than the given value. */
+    lt: V;
+    /** Searches for pairs greater than or equal to the given value. */
+    gte: V;
+    /** Searches for pairs less than or equal to the given value. */
+    lte: V;
+    /** "Searches for pairs equal to the given value. */
     equal: V;
-} | {
+    /** Searches for pairs not equal to the given value. */
     notEqual: V;
-};
+    /** Searches for values matching the given pattern. '%' matches zero or more characters, and '_' matches exactly one character. */
+    like: V;
+}>;
 type BPTreePair<K, V> = {
     key: K;
     value: V;
@@ -21,6 +30,7 @@ export interface BPTreeNode<K, V> {
     leaf: boolean;
     parent: number;
     next: number;
+    prev: number;
 }
 export interface BPTreeInternalNode<K, V> extends BPTreeNode<K, V> {
     leaf: false;
@@ -36,10 +46,15 @@ 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;
     private _updatedHead;
+    private readonly _verifierMap;
+    private readonly _verifierStartNode;
+    private readonly _verifierDirection;
+    private readonly _verifierFullSearch;
     private _createNodeId;
     private _createNode;
     /**
@@ -56,7 +71,7 @@ export declare class BPTree<K, V> {
     private _emitUpdates;
     protected getNode(id: number): BPTreeUnknownNode<K, V>;
     protected leftestNode(): BPTreeLeafNode<K, V>;
-    private _insertableNode;
+    protected insertableNode(value: V): BPTreeLeafNode<K, V>;
     /**
      * It returns whether there is a value in the tree.
      * @param key The key value to search for.
@@ -65,32 +80,20 @@ export declare class BPTree<K, V> {
     exists(key: K, value: V): boolean;
     private _insertAtLeaf;
     private _insertInParent;
-    private _equalCondition;
-    private _notEqualCondition;
-    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;
+    private _getPairsRightToLeft;
+    private _getPairsLeftToRight;
+    protected getPairs(value: V, startNode: BPTreeLeafNode<K, V>, fullSearch: boolean, comparator: (nodeValue: V, value: V) => boolean, direction: -1 | 1): BPTreePair<K, V>[];
     /**
      * 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: 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.
-     * @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: BPTreeCondition<V>): BPTreePair<K, V>[];
     /**
@@ -107,5 +110,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.4",
+  "version": "2.0.0",
   "description": "Store the B+tree flexibly, not only in-memory.",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
@@ -17,6 +17,7 @@
     "serializable-bptree",
     "b-plus-tree",
     "serialize",
+    "serialization",
     "store",
     "btree",
     "bptree",