serializable-bptree 3.2.3 → 3.3.0

package/dist/typings/BPTreeAsync.d.ts

@@ -5,9 +5,9 @@ import { SerializableData } from './base/SerializeStrategy';
 export declare class BPTreeAsync<K, V> extends BPTree<K, V> {
     protected readonly strategy: SerializeStrategyAsync<K, V>;
     constructor(strategy: SerializeStrategyAsync<K, V>, comparator: ValueComparator<V>);
-    protected _getPairsRightToLeft(value: V, startNode: BPTreeLeafNode<K, V>, fullSearch: boolean, comparator: (nodeValue: V, value: V) => boolean): Promise<BPTreePair<K, V>[]>;
-    protected _getPairsLeftToRight(value: V, startNode: BPTreeLeafNode<K, V>, fullSearch: boolean, comparator: (nodeValue: V, value: V) => boolean): Promise<BPTreePair<K, V>[]>;
-    protected getPairs(value: V, startNode: BPTreeLeafNode<K, V>, fullSearch: boolean, comparator: (nodeValue: V, value: V) => boolean, direction: 1 | -1): Promise<BPTreePair<K, V>[]>;
+    protected _getPairsRightToLeft(value: V, startNode: BPTreeLeafNode<K, V>, fullScan: boolean, comparator: (nodeValue: V, value: V) => boolean): Promise<BPTreePair<K, V>[]>;
+    protected _getPairsLeftToRight(value: V, startNode: BPTreeLeafNode<K, V>, fullScan: boolean, comparator: (nodeValue: V, value: V) => boolean): Promise<BPTreePair<K, V>[]>;
+    protected getPairs(value: V, startNode: BPTreeLeafNode<K, V>, fullScan: boolean, comparator: (nodeValue: V, value: V) => boolean, direction: 1 | -1): Promise<BPTreePair<K, V>[]>;
     protected _createNodeId(): Promise<number>;
     protected _createNode(keys: number[] | K[][], values: V[], leaf?: boolean, parent?: number, next?: number, prev?: number): Promise<BPTreeUnknownNode<K, V>>;
     protected _deleteEntry(node: BPTreeUnknownNode<K, V>, key: BPTreeNodeKey<K>, value: V): Promise<void>;

package/dist/typings/BPTreeSync.d.ts

@@ -11,7 +11,6 @@ export declare class BPTreeSync<K, V> extends BPTree<K, V> {
     protected _createNodeId(): number;
     protected _createNode(keys: number[] | K[][], values: V[], leaf?: boolean, parent?: number, next?: number, prev?: number): BPTreeUnknownNode<K, V>;
     protected _deleteEntry(node: BPTreeUnknownNode<K, V>, key: BPTreeNodeKey<K>, value: V): void;
-    protected _insertAtLeaf(node: BPTreeLeafNode<K, V>, key: K, value: V): void;
     protected _insertInParent(node: BPTreeUnknownNode<K, V>, value: V, pointer: BPTreeUnknownNode<K, V>): void;
     init(): void;
     protected getNode(id: number): BPTreeUnknownNode<K, V>;

package/dist/typings/base/BPTree.d.ts

@@ -43,7 +43,7 @@ export interface BPTreeLeafNode<K, V> extends BPTreeNode<K, V> {
     keys: K[][];
 }
 export declare abstract class BPTree<K, V> {
-    private readonly _regexpCache;
+    private readonly _cachedRegexp;
     protected readonly strategy: SerializeStrategy<K, V>;
     protected readonly comparator: ValueComparator<V>;
     protected readonly nodes: Map<number, BPTreeUnknownNode<K, V>>;
@@ -56,9 +56,9 @@ export declare abstract class BPTree<K, V> {
     protected readonly verifierDirection: Record<keyof BPTreeCondition<V>, -1 | 1>;
     protected readonly verifierFullScan: Record<keyof BPTreeCondition<V>, boolean>;
     protected constructor(strategy: SerializeStrategy<K, V>, comparator: ValueComparator<V>);
-    protected abstract _getPairsRightToLeft(value: V, startNode: BPTreeLeafNode<K, V>, fullSearch: boolean, comparator: (nodeValue: V, value: V) => boolean): Deferred<BPTreePair<K, V>[]>;
-    protected abstract _getPairsLeftToRight(value: V, startNode: BPTreeLeafNode<K, V>, fullSearch: boolean, comparator: (nodeValue: V, value: V) => boolean): Deferred<BPTreePair<K, V>[]>;
-    protected abstract getPairs(value: V, startNode: BPTreeLeafNode<K, V>, fullSearch: boolean, comparator: (nodeValue: V, value: V) => boolean, direction: -1 | 1): Deferred<BPTreePair<K, V>[]>;
+    protected abstract _getPairsRightToLeft(value: V, startNode: BPTreeLeafNode<K, V>, fullScan: boolean, comparator: (nodeValue: V, value: V) => boolean): Deferred<BPTreePair<K, V>[]>;
+    protected abstract _getPairsLeftToRight(value: V, startNode: BPTreeLeafNode<K, V>, fullScan: boolean, comparator: (nodeValue: V, value: V) => boolean): Deferred<BPTreePair<K, V>[]>;
+    protected abstract getPairs(value: V, startNode: BPTreeLeafNode<K, V>, fullScan: boolean, comparator: (nodeValue: V, value: V) => boolean, direction: -1 | 1): Deferred<BPTreePair<K, V>[]>;
     protected abstract _createNodeId(): Deferred<number>;
     protected abstract _createNode(keys: number[] | K[][], values: V[], leaf?: boolean, parent?: number, next?: number, prev?: number): Deferred<BPTreeUnknownNode<K, V>>;
     protected abstract _deleteEntry(node: BPTreeUnknownNode<K, V>, key: BPTreeNodeKey<K>, value: V): Deferred<void>;
@@ -122,7 +122,7 @@ export declare abstract class BPTree<K, V> {
      * Typically, there's no need to use this method, but it can be used to synchronize data in scenarios where the remote storage and the client are in a 1:n relationship.
      * @returns The return value is the total number of nodes updated.
      */
-    abstract forceUpdate(nodeId: number): Deferred<number>;
+    abstract forceUpdate(): Deferred<number>;
     protected _insertAtLeaf(node: BPTreeLeafNode<K, V>, key: K, value: V): void;
     protected bufferForNodeCreate(node: BPTreeUnknownNode<K, V>): Deferred<void>;
     protected bufferForNodeUpdate(node: BPTreeUnknownNode<K, V>): Deferred<void>;

package/dist/typings/base/SerializeStrategy.d.ts

@@ -63,6 +63,7 @@ export declare abstract class SerializeStrategy<K, V> {
      * Therefore, when called again, the value incremented by `+1` is returned.
      *
      * This is a syntactic sugar for using the `setHeadData` and `getHeadData` methods.
+     * Therefore, the value specified by this key can be retrieved using the `getHeadData(key)` method or by accessing it directly through `this.head.data[key]`.
      * It assists in simplifying the implementation of node ID generation in the `id` method.
      * @param key The key of the data to be stored in the tree.
      * @param defaultValue The data to be stored in the tree.

package/package.json

@@ -1,10 +1,17 @@
 {
   "name": "serializable-bptree",
-  "version": "3.2.3",
+  "version": "3.3.0",
   "description": "Store the B+tree flexibly, not only in-memory.",
-  "main": "dist/cjs/index.js",
-  "module": "dist/esm/index.js",
+  "main": "dist/cjs/index.cjs",
+  "module": "dist/esm/index.mjs",
   "typings": "dist/typings/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/esm/index.mjs",
+      "require": "./dist/cjs/index.cjs",
+      "types": "./dist/typings/index.d.ts"
+    }
+  },
   "files": [
     "dist/**/*"
   ],
@@ -34,5 +41,8 @@
     "jest": "^29.7.0",
     "ts-jest": "^29.1.1",
     "typescript": "^5.2.2"
+  },
+  "dependencies": {
+    "cachebranch": "^1.2.0"
   }
 }

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

@@ -1,3 +0,0 @@
-export declare class CacheStorage<K, V> extends Map<K, V> {
-    ensure(key: K, generator: () => V): V;
-}