serializable-bptree 3.0.0 → 3.1.0

package/README.md

@@ -129,11 +129,45 @@ class AgeComparator extends ValueComparator<MyObject> {
   asc(a: MyObject, b: MyObject): number {
     return a.age - b.age
   }
+
+  match(value: MyObject): string {
+    return value.age
+  }
 }
 ```
 
+#### asc
+
 The **asc** method should return values in ascending order. If the return value is negative, it means that the parameter **a** is smaller than **b**. If the return value is positive, it means that **a** is greater than **b**. If the return value is **0**, it indicates that **a** and **b** are of the same size.
 
+#### match
+
+The `match` method is used for the **LIKE** operator. This method specifies which value to test against a regular expression. For example, if you have a tree with values of the structure `{ country: string, capital: number }`, and you want to perform a **LIKE** operation based on the **capital** value, the method should return **value.capital**. In this case, you **CANNOT** perform a **LIKE** operation based on the **country** attribute. The returned value must be a string.
+
+```typescript
+interface MyObject {
+  country: string
+  capital: string
+}
+
+class CompositeComparator extends ValueComparator<MyObject> {
+  ...
+  match(value: MyObject): string {
+    return value.capital
+  }
+}
+```
+
+For a tree with simple structure, without complex nesting, returning the value directly would be sufficient.
+
+```typescript
+class StringComparator extends ValueComparator<string> {
+  match(value: string): string {
+    return value
+  }
+}
+```
+
 ### Serialize strategy
 
 A B+tree instance is made up of numerous nodes. You would want to store this value when such nodes are created or updated. Let's assume you want to save it to a file.
@@ -371,7 +405,7 @@ The implementation method for asynchronous operations is not significantly diffe
 
 The serializable-bptree minimizes file I/O by storing loaded nodes in-memory. This approach works well in situations where there is a 1:1 relationship between the remote storage and the client. However, in a 1:n scenario, where multiple clients read from and write to a single remote storage, data inconsistency between the remote storage and the clients can occur.
 
-To solve this issue, it's necessary to update the cached nodes. The forceUpdate method was created for this purpose. It allows for the update of specific nodes, but when updating a node ID, a signal must be sent to all clients connected to the remote storage, informing them that the node has been updated. Clients must receive this signal and call the forceUpdate method to update the node. This logic goes beyond the scope of the library, so it must be implemented directly.
+To solve this problem, it's necessary to update the cached nodes. The forceUpdate method was created for this purpose. It fetches the node data cached in the tree instance again. To use this feature, when you save data to the remote storage, you must send a signal to all clients connected to that remote storage indicating that the node has been updated. Clients must receive this signal and configure logic to call the **forceUpdate** method; however, this goes beyond the scope of the library, so you must implement it yourself.
 
 ### Concurrency Issue in Asynchronous Trees
 

package/dist/cjs/index.js

@@ -32,8 +32,48 @@ __export(src_exports, {
 });
 module.exports = __toCommonJS(src_exports);
 
+// src/base/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;
+  }
+  match(value) {
+    return value.toString();
+  }
+};
+var StringComparator = class extends ValueComparator {
+  asc(a, b) {
+    return a.localeCompare(b);
+  }
+  match(value) {
+    return value;
+  }
+};
+
+// src/utils/CacheStorage.ts
+var CacheStorage = class extends Map {
+  ensure(key, generator) {
+    if (!this.has(key)) {
+      this.set(key, generator());
+    }
+    return this.get(key);
+  }
+};
+
 // src/base/BPTree.ts
 var BPTree = class {
+  _regexpCache;
   strategy;
   comparator;
   nodes;
@@ -51,11 +91,13 @@ var BPTree = class {
     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);
+      const nodeValue = this.comparator.match(nv);
+      const value = this.comparator.match(v);
+      const regexp = this._regexpCache.ensure(value, () => {
+        const pattern = value.replace(/%/g, ".*").replace(/_/g, ".");
+        return new RegExp(`^${pattern}$`, "i");
+      });
+      return regexp.test(nodeValue);
     }
   };
   verifierStartNode = {
@@ -76,7 +118,7 @@ var BPTree = class {
     notEqual: 1,
     like: 1
   };
-  verifierFullSearch = {
+  verifierFullScan = {
     gt: false,
     gte: false,
     lt: false,
@@ -96,6 +138,7 @@ var BPTree = class {
     };
   }
   constructor(strategy, comparator) {
+    this._regexpCache = new CacheStorage();
     this._headBuffer = null;
     this._nodeCreateBuffer = /* @__PURE__ */ new Map();
     this._nodeUpdateBuffer = /* @__PURE__ */ new Map();
@@ -594,9 +637,9 @@ var BPTreeSync = class extends BPTree {
       const value = condition[key];
       const startNode = this.verifierStartNode[key](value);
       const direction = this.verifierDirection[key];
-      const fullSearch = this.verifierFullSearch[key];
+      const fullScan = this.verifierFullScan[key];
       const comparator = this.verifierMap[key];
-      const pairs = this.getPairs(value, startNode, fullSearch, comparator, direction);
+      const pairs = this.getPairs(value, startNode, fullScan, comparator, direction);
       if (result === null) {
         result = pairs.map((pair) => pair.key);
       } else {
@@ -612,9 +655,9 @@ var BPTreeSync = class extends BPTree {
       const value = condition[key];
       const startNode = this.verifierStartNode[key](value);
       const direction = this.verifierDirection[key];
-      const fullSearch = this.verifierFullSearch[key];
+      const fullScan = this.verifierFullScan[key];
       const comparator = this.verifierMap[key];
-      const pairs = this.getPairs(value, startNode, fullSearch, comparator, direction);
+      const pairs = this.getPairs(value, startNode, fullScan, comparator, direction);
       if (result === null) {
         result = pairs;
       } else {
@@ -700,13 +743,14 @@ var BPTreeSync = class extends BPTree {
     this.bufferForHeadUpdate(this.headState);
     this.commitHeadBuffer();
   }
-  forceUpdate(nodeId = null) {
-    const ids = nodeId === null ? [...this.nodes.keys()] : [nodeId];
-    for (const id of ids) {
-      this.nodes.delete(id);
-      this.getNode(id);
+  forceUpdate() {
+    const keys = [...this.nodes.keys()];
+    this.nodes.clear();
+    this.init();
+    for (const key of keys) {
+      this.getNode(key);
     }
-    return ids.length;
+    return keys.length;
   }
 };
 
@@ -1128,9 +1172,9 @@ var BPTreeAsync = class extends BPTree {
       const value = condition[key];
       const startNode = await this.verifierStartNode[key](value);
       const direction = this.verifierDirection[key];
-      const fullSearch = this.verifierFullSearch[key];
+      const fullScan = this.verifierFullScan[key];
       const comparator = this.verifierMap[key];
-      const pairs = await this.getPairs(value, startNode, fullSearch, comparator, direction);
+      const pairs = await this.getPairs(value, startNode, fullScan, comparator, direction);
       if (result === null) {
         result = pairs.map((pair) => pair.key);
       } else {
@@ -1146,9 +1190,9 @@ var BPTreeAsync = class extends BPTree {
       const value = condition[key];
       const startNode = await this.verifierStartNode[key](value);
       const direction = this.verifierDirection[key];
-      const fullSearch = this.verifierFullSearch[key];
+      const fullScan = this.verifierFullScan[key];
       const comparator = this.verifierMap[key];
-      const pairs = await this.getPairs(value, startNode, fullSearch, comparator, direction);
+      const pairs = await this.getPairs(value, startNode, fullScan, comparator, direction);
       if (result === null) {
         result = pairs;
       } else {
@@ -1234,13 +1278,14 @@ var BPTreeAsync = class extends BPTree {
     this.bufferForHeadUpdate(this.headState);
     await this.commitHeadBuffer();
   }
-  async forceUpdate(nodeId = null) {
-    const ids = nodeId === null ? [...this.nodes.keys()] : [nodeId];
-    for (const id of ids) {
-      this.nodes.delete(id);
-      await this.getNode(id);
+  async forceUpdate() {
+    const keys = [...this.nodes.keys()];
+    this.nodes.clear();
+    await this.init();
+    for (const key of keys) {
+      await this.getNode(key);
     }
-    return ids.length;
+    return keys.length;
   }
 };
 
@@ -1315,26 +1360,3 @@ var InMemoryStoreStrategyAsync = class extends SerializeStrategyAsync {
     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);
-  }
-};

package/dist/esm/index.js

@@ -1,5 +1,45 @@
+// src/base/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;
+  }
+  match(value) {
+    return value.toString();
+  }
+};
+var StringComparator = class extends ValueComparator {
+  asc(a, b) {
+    return a.localeCompare(b);
+  }
+  match(value) {
+    return value;
+  }
+};
+
+// src/utils/CacheStorage.ts
+var CacheStorage = class extends Map {
+  ensure(key, generator) {
+    if (!this.has(key)) {
+      this.set(key, generator());
+    }
+    return this.get(key);
+  }
+};
+
 // src/base/BPTree.ts
 var BPTree = class {
+  _regexpCache;
   strategy;
   comparator;
   nodes;
@@ -17,11 +57,13 @@ var BPTree = class {
     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);
+      const nodeValue = this.comparator.match(nv);
+      const value = this.comparator.match(v);
+      const regexp = this._regexpCache.ensure(value, () => {
+        const pattern = value.replace(/%/g, ".*").replace(/_/g, ".");
+        return new RegExp(`^${pattern}$`, "i");
+      });
+      return regexp.test(nodeValue);
     }
   };
   verifierStartNode = {
@@ -42,7 +84,7 @@ var BPTree = class {
     notEqual: 1,
     like: 1
   };
-  verifierFullSearch = {
+  verifierFullScan = {
     gt: false,
     gte: false,
     lt: false,
@@ -62,6 +104,7 @@ var BPTree = class {
     };
   }
   constructor(strategy, comparator) {
+    this._regexpCache = new CacheStorage();
     this._headBuffer = null;
     this._nodeCreateBuffer = /* @__PURE__ */ new Map();
     this._nodeUpdateBuffer = /* @__PURE__ */ new Map();
@@ -560,9 +603,9 @@ var BPTreeSync = class extends BPTree {
       const value = condition[key];
       const startNode = this.verifierStartNode[key](value);
       const direction = this.verifierDirection[key];
-      const fullSearch = this.verifierFullSearch[key];
+      const fullScan = this.verifierFullScan[key];
       const comparator = this.verifierMap[key];
-      const pairs = this.getPairs(value, startNode, fullSearch, comparator, direction);
+      const pairs = this.getPairs(value, startNode, fullScan, comparator, direction);
       if (result === null) {
         result = pairs.map((pair) => pair.key);
       } else {
@@ -578,9 +621,9 @@ var BPTreeSync = class extends BPTree {
       const value = condition[key];
       const startNode = this.verifierStartNode[key](value);
       const direction = this.verifierDirection[key];
-      const fullSearch = this.verifierFullSearch[key];
+      const fullScan = this.verifierFullScan[key];
       const comparator = this.verifierMap[key];
-      const pairs = this.getPairs(value, startNode, fullSearch, comparator, direction);
+      const pairs = this.getPairs(value, startNode, fullScan, comparator, direction);
       if (result === null) {
         result = pairs;
       } else {
@@ -666,13 +709,14 @@ var BPTreeSync = class extends BPTree {
     this.bufferForHeadUpdate(this.headState);
     this.commitHeadBuffer();
   }
-  forceUpdate(nodeId = null) {
-    const ids = nodeId === null ? [...this.nodes.keys()] : [nodeId];
-    for (const id of ids) {
-      this.nodes.delete(id);
-      this.getNode(id);
+  forceUpdate() {
+    const keys = [...this.nodes.keys()];
+    this.nodes.clear();
+    this.init();
+    for (const key of keys) {
+      this.getNode(key);
     }
-    return ids.length;
+    return keys.length;
   }
 };
 
@@ -1094,9 +1138,9 @@ var BPTreeAsync = class extends BPTree {
       const value = condition[key];
       const startNode = await this.verifierStartNode[key](value);
       const direction = this.verifierDirection[key];
-      const fullSearch = this.verifierFullSearch[key];
+      const fullScan = this.verifierFullScan[key];
       const comparator = this.verifierMap[key];
-      const pairs = await this.getPairs(value, startNode, fullSearch, comparator, direction);
+      const pairs = await this.getPairs(value, startNode, fullScan, comparator, direction);
       if (result === null) {
         result = pairs.map((pair) => pair.key);
       } else {
@@ -1112,9 +1156,9 @@ var BPTreeAsync = class extends BPTree {
       const value = condition[key];
       const startNode = await this.verifierStartNode[key](value);
       const direction = this.verifierDirection[key];
-      const fullSearch = this.verifierFullSearch[key];
+      const fullScan = this.verifierFullScan[key];
       const comparator = this.verifierMap[key];
-      const pairs = await this.getPairs(value, startNode, fullSearch, comparator, direction);
+      const pairs = await this.getPairs(value, startNode, fullScan, comparator, direction);
       if (result === null) {
         result = pairs;
       } else {
@@ -1200,13 +1244,14 @@ var BPTreeAsync = class extends BPTree {
     this.bufferForHeadUpdate(this.headState);
     await this.commitHeadBuffer();
   }
-  async forceUpdate(nodeId = null) {
-    const ids = nodeId === null ? [...this.nodes.keys()] : [nodeId];
-    for (const id of ids) {
-      this.nodes.delete(id);
-      await this.getNode(id);
+  async forceUpdate() {
+    const keys = [...this.nodes.keys()];
+    this.nodes.clear();
+    await this.init();
+    for (const key of keys) {
+      await this.getNode(key);
     }
-    return ids.length;
+    return keys.length;
   }
 };
 
@@ -1281,29 +1326,6 @@ var InMemoryStoreStrategyAsync = class extends SerializeStrategyAsync {
     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 {
   BPTreeAsync,
   BPTreeSync,

package/dist/typings/BPTreeAsync.d.ts

@@ -1,7 +1,7 @@
 import type { Json } from './utils/types';
-import { BPTree, BPTreeLeafNode, BPTreePair, BPTreeNodeKey, BPTreeUnknownNode } from './base/BPTree';
+import { BPTree, BPTreeCondition, BPTreeLeafNode, BPTreePair, BPTreeNodeKey, BPTreeUnknownNode } from './base/BPTree';
 import { SerializeStrategyAsync } from './SerializeStrategyAsync';
-import { ValueComparator } from './ValueComparator';
+import { ValueComparator } from './base/ValueComparator';
 export declare class BPTreeAsync<K, V> extends BPTree<K, V> {
     protected readonly strategy: SerializeStrategyAsync<K, V>;
     constructor(strategy: SerializeStrategyAsync<K, V>, comparator: ValueComparator<V>);
@@ -19,27 +19,11 @@ export declare class BPTreeAsync<K, V> extends BPTree<K, V> {
     protected commitHeadBuffer(): Promise<void>;
     protected commitNodeCreateBuffer(): Promise<void>;
     protected commitNodeUpdateBuffer(): Promise<void>;
-    keys(condition: Partial<{
-        gt: V;
-        lt: V;
-        gte: V;
-        lte: V;
-        equal: V;
-        notEqual: V;
-        like: V;
-    }>): Promise<Set<K>>;
-    where(condition: Partial<{
-        gt: V;
-        lt: V;
-        gte: V;
-        lte: V;
-        equal: V;
-        notEqual: V;
-        like: V;
-    }>): Promise<BPTreePair<K, V>[]>;
+    keys(condition: BPTreeCondition<V>): Promise<Set<K>>;
+    where(condition: BPTreeCondition<V>): Promise<BPTreePair<K, V>[]>;
     insert(key: K, value: V): Promise<void>;
     delete(key: K, value: V): Promise<void>;
     exists(key: K, value: V): Promise<boolean>;
     setHeadData(data: Record<string, Json>): Promise<void>;
-    forceUpdate(nodeId?: number | null): Promise<number>;
+    forceUpdate(): Promise<number>;
 }

package/dist/typings/BPTreeSync.d.ts

@@ -1,7 +1,7 @@
 import type { Json } from './utils/types';
-import { BPTree, BPTreeLeafNode, BPTreePair, BPTreeNodeKey, BPTreeUnknownNode } from './base/BPTree';
+import { BPTree, BPTreeCondition, BPTreeLeafNode, BPTreePair, BPTreeNodeKey, BPTreeUnknownNode } from './base/BPTree';
 import { SerializeStrategySync } from './SerializeStrategySync';
-import { ValueComparator } from './ValueComparator';
+import { ValueComparator } from './base/ValueComparator';
 export declare class BPTreeSync<K, V> extends BPTree<K, V> {
     protected readonly strategy: SerializeStrategySync<K, V>;
     constructor(strategy: SerializeStrategySync<K, V>, comparator: ValueComparator<V>);
@@ -20,27 +20,11 @@ export declare class BPTreeSync<K, V> extends BPTree<K, V> {
     protected commitHeadBuffer(): void;
     protected commitNodeCreateBuffer(): void;
     protected commitNodeUpdateBuffer(): void;
-    keys(condition: Partial<{
-        gt: V;
-        lt: V;
-        gte: V;
-        lte: V;
-        equal: V;
-        notEqual: V;
-        like: V;
-    }>): Set<K>;
-    where(condition: Partial<{
-        gt: V;
-        lt: V;
-        gte: V;
-        lte: V;
-        equal: V;
-        notEqual: V;
-        like: V;
-    }>): BPTreePair<K, V>[];
+    keys(condition: BPTreeCondition<V>): Set<K>;
+    where(condition: BPTreeCondition<V>): BPTreePair<K, V>[];
     insert(key: K, value: V): void;
     delete(key: K, value: V): void;
     exists(key: K, value: V): boolean;
     setHeadData(data: Record<string, Json>): void;
-    forceUpdate(nodeId?: number | null): number;
+    forceUpdate(): number;
 }

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

@@ -1,5 +1,5 @@
 import type { Json } from '../utils/types';
-import { ValueComparator } from '../ValueComparator';
+import { ValueComparator } from './ValueComparator';
 import { SerializeStrategy, SerializeStrategyHead } from './SerializeStrategy';
 type Sync<T> = T;
 type Async<T> = Promise<T>;
@@ -7,19 +7,19 @@ type Deferred<T> = Sync<T> | Async<T>;
 export type BPTreeNodeKey<K> = number | K;
 export type BPTreeCondition<V> = Partial<{
     /** Searches for pairs greater than the given value. */
-    gt: V;
+    gt: Partial<V>;
     /** Searches for pairs less than the given value. */
-    lt: V;
+    lt: Partial<V>;
     /** Searches for pairs greater than or equal to the given value. */
-    gte: V;
+    gte: Partial<V>;
     /** Searches for pairs less than or equal to the given value. */
-    lte: V;
+    lte: Partial<V>;
     /** "Searches for pairs equal to the given value. */
-    equal: V;
+    equal: Partial<V>;
     /** Searches for pairs not equal to the given value. */
-    notEqual: V;
+    notEqual: Partial<V>;
     /** Searches for values matching the given pattern. '%' matches zero or more characters, and '_' matches exactly one character. */
-    like: V;
+    like: Partial<V>;
 }>;
 export type BPTreePair<K, V> = {
     key: K;
@@ -44,6 +44,7 @@ export interface BPTreeLeafNode<K, V> extends BPTreeNode<K, V> {
     keys: K[][];
 }
 export declare abstract class BPTree<K, V> {
+    private readonly _regexpCache;
     protected readonly strategy: SerializeStrategy<K, V>;
     protected readonly comparator: ValueComparator<V>;
     protected readonly nodes: Map<number, BPTreeUnknownNode<K, V>>;
@@ -56,7 +57,7 @@ export declare abstract class BPTree<K, V> {
     protected readonly verifierMap: Record<keyof BPTreeCondition<V>, (nodeValue: V, value: V) => boolean>;
     protected readonly verifierStartNode: Record<keyof BPTreeCondition<V>, (value: V) => Deferred<BPTreeLeafNode<K, V>>>;
     protected readonly verifierDirection: Record<keyof BPTreeCondition<V>, -1 | 1>;
-    protected readonly verifierFullSearch: Record<keyof BPTreeCondition<V>, boolean>;
+    protected readonly verifierFullScan: Record<keyof BPTreeCondition<V>, boolean>;
     protected get headState(): SerializeStrategyHead;
     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>[]>;
@@ -120,7 +121,6 @@ export declare abstract class BPTree<K, V> {
     /**
      * This method deletes nodes cached in-memory and caches new nodes from the stored nodes.
      * 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.
-     * @param nodeId The node ID to update. If no parameters are passed, it updates all currently cached nodes.
      * @returns The return value is the total number of nodes updated.
      */
     abstract forceUpdate(nodeId: number): Deferred<number>;

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

@@ -0,0 +1,56 @@
+export declare abstract class ValueComparator<V> {
+    /**
+     * Implement an algorithm that sorts values in ascending order.
+     * If it returns a negative number, a is less than b. If it returns 0, the two values are equal. If it returns a positive number, a is greater than b.
+     * @param a Value a.
+     * @param b Value b.
+     */
+    abstract asc(a: V, b: V): number;
+    /**
+     * The `match` method is used for the **LIKE** operator.
+     * This method specifies which value to test against a regular expression.
+     *
+     * For example, if you have a tree with values of the structure `{ country: string, capital: number }`,
+     * and you want to perform a **LIKE** operation based on the **capital** value, the method should return **value.capital**.
+     * In this case, you **CANNOT** perform a **LIKE** operation based on the **country** attribute.
+     * The returned value must be a string.
+     *
+     * ```
+     * interface MyObject {
+     *   country: string
+     *   capital: string
+     * }
+     *
+     * class CompositeComparator extends ValueComparator<MyObject> {
+     *   match(value: MyObject): string {
+     *     return value.capital
+     *   }
+     * }
+     * ```
+     *
+     * For a tree with simple structure, without complex nesting, returning the value directly would be sufficient.
+     *
+     * ```
+     * class StringComparator extends ValueComparator<string> {
+     *   match(value: string): string {
+     *     return value
+     *   }
+     * }
+     * ```
+     *
+     * @param value The inserted value.
+     * @returns The value to test against a regular expression.
+     */
+    abstract match(value: V): string;
+    isLower(value: V, than: V): boolean;
+    isSame(value: V, than: V): boolean;
+    isHigher(value: V, than: V): boolean;
+}
+export declare class NumericComparator extends ValueComparator<number> {
+    asc(a: number, b: number): number;
+    match(value: number): string;
+}
+export declare class StringComparator extends ValueComparator<string> {
+    asc(a: string, b: string): number;
+    match(value: string): string;
+}

package/dist/typings/index.d.ts

@@ -1,7 +1,7 @@
 export type { BPTreeNode } from './base/BPTree';
 export type { SerializeStrategyHead } from './base/SerializeStrategy';
+export { ValueComparator, NumericComparator, StringComparator } from './base/ValueComparator';
 export { BPTreeSync } from './BPTreeSync';
 export { BPTreeAsync } from './BPTreeAsync';
 export { SerializeStrategySync, InMemoryStoreStrategySync } from './SerializeStrategySync';
 export { SerializeStrategyAsync, InMemoryStoreStrategyAsync } from './SerializeStrategyAsync';
-export { ValueComparator, NumericComparator, StringComparator } from './ValueComparator';

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

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

package/package.json

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

package/dist/typings/ValueComparator.d.ts

@@ -1,18 +0,0 @@
-export declare abstract class ValueComparator<V> {
-    /**
-     * Implement an algorithm that sorts values in ascending order.
-     * If it returns a negative number, a is less than b. If it returns 0, the two values are equal. If it returns a positive number, a is greater than b.
-     * @param a Value a.
-     * @param b Value b.
-     */
-    abstract asc(a: V, b: V): number;
-    isLower(value: V, than: V): boolean;
-    isSame(value: V, than: V): boolean;
-    isHigher(value: V, than: V): boolean;
-}
-export declare class NumericComparator extends ValueComparator<number> {
-    asc(a: number, b: number): number;
-}
-export declare class StringComparator extends ValueComparator<string> {
-    asc(a: string, b: string): number;
-}