serializable-bptree 4.0.5 → 5.0.1

package/README.md

@@ -59,10 +59,10 @@ tree.insert('c', 3)
 
 tree.delete('b', 2)
 
-tree.where({ equal: 1 }) // [{ key: 'a', value: 1 }]
-tree.where({ gt: 1 }) // [{ key: 'c', value: 3 }]
-tree.where({ lt: 2 }) // [{ key: 'a', value: 1 }]
-tree.where({ gt: 0, lt: 4 }) // [{ key: 'a', value: 1 }, { key: 'c', value: 3 }]
+tree.where({ equal: 1 }) // Map([{ key: 'a', value: 1 }])
+tree.where({ gt: 1 }) // Map([{ key: 'c', value: 3 }])
+tree.where({ lt: 2 }) // Map([{ key: 'a', value: 1 }])
+tree.where({ gt: 0, lt: 4 }) // Map([{ key: 'a', value: 1 }, { key: 'c', value: 3 }])
 ```
 
 ## Why use a `serializable-bptree`?
@@ -102,7 +102,7 @@ import {
     ValueComparator,
     NumericComparator,
     StringComparator
-  } from 'https://cdn.jsdelivr.net/npm/serializable-bptree@4.x.x/dist/esm/index.min.js'
+  } from 'https://cdn.jsdelivr.net/npm/serializable-bptree@5.x.x/dist/esm/index.min.js'
 </script>
 ```
 
@@ -417,10 +417,10 @@ await tree.insert('c', 3)
 
 await tree.delete('b', 2)
 
-await tree.where({ equal: 1 }) // [{ key: 'a', value: 1 }]
-await tree.where({ gt: 1 }) // [{ key: 'c', value: 3 }]
-await tree.where({ lt: 2 }) // [{ key: 'a', value: 1 }]
-await tree.where({ gt: 0, lt: 4 }) // [{ key: 'a', value: 1 }, { key: 'c', value: 3 }]
+await tree.where({ equal: 1 }) // Map([{ key: 'a', value: 1 }])
+await tree.where({ gt: 1 }) // Map([{ key: 'c', value: 3 }])
+await tree.where({ lt: 2 }) // Map([{ key: 'a', value: 1 }])
+await tree.where({ gt: 0, lt: 4 }) // Map([{ key: 'a', value: 1 }, { key: 'c', value: 3 }])
 ```
 
 The implementation method for asynchronous operations is not significantly different. The **-Async** suffix is used instead of the **-Sync** suffix in the **BPTree** and **SerializeStrategy** classes. The only difference is that the methods become asynchronous. The **ValueComparator** class and similar value comparators do not use asynchronous operations.

package/dist/cjs/index.cjs

@@ -102,6 +102,7 @@ var BPTree = class {
   nodes;
   order;
   root;
+  _strategyDirty;
   _nodeCreateBuffer;
   _nodeUpdateBuffer;
   _nodeDeleteBuffer;
@@ -152,6 +153,7 @@ var BPTree = class {
     like: true
   };
   constructor(strategy, comparator) {
+    this._strategyDirty = false;
     this._cachedRegexp = new InvertedWeakMap();
     this._nodeCreateBuffer = /* @__PURE__ */ new Map();
     this._nodeUpdateBuffer = /* @__PURE__ */ new Map();
@@ -211,7 +213,7 @@ var BPTreeSync = class extends BPTree {
   constructor(strategy, comparator) {
     super(strategy, comparator);
   }
-  _getPairsRightToLeft(value, startNode, fullScan, comparator) {
+  getPairsRightToLeft(value, startNode, fullScan, comparator) {
     const pairs = [];
     let node = startNode;
     let done = false;
@@ -225,7 +227,7 @@ var BPTreeSync = class extends BPTree {
           found = true;
           let j = keys.length;
           while (j--) {
-            pairs.push({ key: keys[j], value: nValue });
+            pairs.push([keys[j], nValue]);
           }
         } else if (found && !fullScan) {
           done = true;
@@ -238,9 +240,9 @@ var BPTreeSync = class extends BPTree {
       }
       node = this.getNode(node.prev);
     }
-    return pairs.reverse();
+    return new Map(pairs.reverse());
   }
-  _getPairsLeftToRight(value, startNode, fullScan, comparator) {
+  getPairsLeftToRight(value, startNode, fullScan, comparator) {
     const pairs = [];
     let node = startNode;
     let done = false;
@@ -251,8 +253,9 @@ var BPTreeSync = class extends BPTree {
         const keys = node.keys[i];
         if (comparator(nValue, value)) {
           found = true;
-          for (const key of keys) {
-            pairs.push({ key, value: nValue });
+          for (let j = 0, len2 = keys.length; j < len2; j++) {
+            const key = keys[j];
+            pairs.push([key, nValue]);
           }
         } else if (found && !fullScan) {
           done = true;
@@ -265,14 +268,14 @@ var BPTreeSync = class extends BPTree {
       }
       node = this.getNode(node.next);
     }
-    return pairs;
+    return new Map(pairs);
   }
   getPairs(value, startNode, fullScan, comparator, direction) {
     switch (direction) {
       case -1:
-        return this._getPairsRightToLeft(value, startNode, fullScan, comparator);
+        return this.getPairsRightToLeft(value, startNode, fullScan, comparator);
       case 1:
-        return this._getPairsLeftToRight(value, startNode, fullScan, comparator);
+        return this.getPairsLeftToRight(value, startNode, fullScan, comparator);
       default:
         throw new Error(`Direction must be -1 or 1. but got a ${direction}`);
     }
@@ -323,6 +326,7 @@ var BPTreeSync = class extends BPTree {
       this.root = this.getNode(keys[0]);
       this.root.parent = null;
       this.strategy.head.root = this.root.id;
+      this._strategyDirty = true;
       this.bufferForNodeUpdate(this.root);
       return;
     } else if (this.root === node) {
@@ -506,6 +510,7 @@ var BPTreeSync = class extends BPTree {
       const root = this._createNode(false, [node.id, pointer.id], [value]);
       this.root = root;
       this.strategy.head.root = root.id;
+      this._strategyDirty = true;
       node.parent = root.id;
       pointer.parent = root.id;
       this.bufferForNodeCreate(root);
@@ -604,6 +609,10 @@ var BPTreeSync = class extends BPTree {
     return node;
   }
   commitHeadBuffer() {
+    if (!this._strategyDirty) {
+      return;
+    }
+    this._strategyDirty = false;
     this.strategy.writeHead(this.strategy.head);
   }
   commitNodeCreateBuffer() {
@@ -634,11 +643,11 @@ var BPTreeSync = class extends BPTree {
       const comparator = this.verifierMap[key];
       const pairs = this.getPairs(value, startNode, fullScan, comparator, direction);
       if (!filterValues) {
-        filterValues = new Set(pairs.map((pair) => pair.key));
+        filterValues = new Set(pairs.keys());
       } else {
         const intersections = /* @__PURE__ */ new Set();
         for (const key2 of filterValues) {
-          const has = pairs.some((pair) => pair.key === key2);
+          const has = pairs.has(key2);
           if (has) {
             intersections.add(key2);
           }
@@ -661,16 +670,16 @@ var BPTreeSync = class extends BPTree {
       if (result === null) {
         result = pairs;
       } else {
-        const intersection = [];
-        for (const pair of pairs) {
-          if (result.find((p) => p.key === pair.key)) {
-            intersection.push(pair);
+        const intersection = /* @__PURE__ */ new Map();
+        for (const [k2, v] of pairs) {
+          if (result.has(k2)) {
+            intersection.set(k2, v);
           }
         }
         result = intersection;
       }
     }
-    return result ?? [];
+    return result ?? /* @__PURE__ */ new Map();
   }
   insert(key, value) {
     const before = this.insertableNode(value);
@@ -748,6 +757,7 @@ var BPTreeSync = class extends BPTree {
   }
   setHeadData(data) {
     this.strategy.head.data = data;
+    this._strategyDirty = true;
     this.commitHeadBuffer();
   }
   forceUpdate() {
@@ -766,7 +776,7 @@ var BPTreeAsync = class extends BPTree {
   constructor(strategy, comparator) {
     super(strategy, comparator);
   }
-  async _getPairsRightToLeft(value, startNode, fullScan, comparator) {
+  async getPairsRightToLeft(value, startNode, fullScan, comparator) {
     const pairs = [];
     let node = startNode;
     let done = false;
@@ -780,7 +790,7 @@ var BPTreeAsync = class extends BPTree {
           found = true;
           let j = keys.length;
           while (j--) {
-            pairs.push({ key: keys[j], value: nValue });
+            pairs.push([keys[j], nValue]);
           }
         } else if (found && !fullScan) {
           done = true;
@@ -793,9 +803,9 @@ var BPTreeAsync = class extends BPTree {
       }
       node = await this.getNode(node.prev);
     }
-    return pairs.reverse();
+    return new Map(pairs.reverse());
   }
-  async _getPairsLeftToRight(value, startNode, fullScan, comparator) {
+  async getPairsLeftToRight(value, startNode, fullScan, comparator) {
     const pairs = [];
     let node = startNode;
     let done = false;
@@ -806,8 +816,9 @@ var BPTreeAsync = class extends BPTree {
         const keys = node.keys[i];
         if (comparator(nValue, value)) {
           found = true;
-          for (const key of keys) {
-            pairs.push({ key, value: nValue });
+          for (let j = 0, len2 = keys.length; j < len2; j++) {
+            const key = keys[j];
+            pairs.push([key, nValue]);
           }
         } else if (found && !fullScan) {
           done = true;
@@ -820,14 +831,14 @@ var BPTreeAsync = class extends BPTree {
       }
       node = await this.getNode(node.next);
     }
-    return pairs;
+    return new Map(pairs);
   }
   async getPairs(value, startNode, fullScan, comparator, direction) {
     switch (direction) {
       case -1:
-        return await this._getPairsRightToLeft(value, startNode, fullScan, comparator);
+        return await this.getPairsRightToLeft(value, startNode, fullScan, comparator);
       case 1:
-        return await this._getPairsLeftToRight(value, startNode, fullScan, comparator);
+        return await this.getPairsLeftToRight(value, startNode, fullScan, comparator);
       default:
         throw new Error(`Direction must be -1 or 1. but got a ${direction}`);
     }
@@ -878,6 +889,7 @@ var BPTreeAsync = class extends BPTree {
       this.root = await this.getNode(keys[0]);
       this.root.parent = null;
       this.strategy.head.root = this.root.id;
+      this._strategyDirty = true;
       this.bufferForNodeUpdate(this.root);
       return;
     } else if (this.root === node) {
@@ -1061,6 +1073,7 @@ var BPTreeAsync = class extends BPTree {
       const root = await this._createNode(false, [node.id, pointer.id], [value]);
       this.root = root;
       this.strategy.head.root = root.id;
+      this._strategyDirty = true;
       node.parent = root.id;
       pointer.parent = root.id;
       this.bufferForNodeCreate(root);
@@ -1159,6 +1172,10 @@ var BPTreeAsync = class extends BPTree {
     return node;
   }
   async commitHeadBuffer() {
+    if (!this._strategyDirty) {
+      return;
+    }
+    this._strategyDirty = false;
     await this.strategy.writeHead(this.strategy.head);
   }
   async commitNodeCreateBuffer() {
@@ -1189,11 +1206,11 @@ var BPTreeAsync = class extends BPTree {
       const comparator = this.verifierMap[key];
       const pairs = await this.getPairs(value, startNode, fullScan, comparator, direction);
       if (!filterValues) {
-        filterValues = new Set(pairs.map((pair) => pair.key));
+        filterValues = new Set(pairs.keys());
       } else {
         const intersections = /* @__PURE__ */ new Set();
         for (const key2 of filterValues) {
-          const has = pairs.some((pair) => pair.key === key2);
+          const has = pairs.has(key2);
           if (has) {
             intersections.add(key2);
           }
@@ -1216,16 +1233,16 @@ var BPTreeAsync = class extends BPTree {
       if (result === null) {
         result = pairs;
       } else {
-        const intersection = [];
-        for (const pair of pairs) {
-          if (result.find((p) => p.key === pair.key)) {
-            intersection.push(pair);
+        const intersection = /* @__PURE__ */ new Map();
+        for (const [k2, v] of pairs) {
+          if (result.has(k2)) {
+            intersection.set(k2, v);
           }
         }
         result = intersection;
       }
     }
-    return result ?? [];
+    return result ?? /* @__PURE__ */ new Map();
   }
   async insert(key, value) {
     const before = await this.insertableNode(value);
@@ -1303,6 +1320,7 @@ var BPTreeAsync = class extends BPTree {
   }
   async setHeadData(data) {
     this.strategy.head.data = data;
+    this._strategyDirty = true;
     await this.commitHeadBuffer();
   }
   async forceUpdate() {

package/dist/esm/index.mjs

@@ -68,6 +68,7 @@ var BPTree = class {
   nodes;
   order;
   root;
+  _strategyDirty;
   _nodeCreateBuffer;
   _nodeUpdateBuffer;
   _nodeDeleteBuffer;
@@ -118,6 +119,7 @@ var BPTree = class {
     like: true
   };
   constructor(strategy, comparator) {
+    this._strategyDirty = false;
     this._cachedRegexp = new InvertedWeakMap();
     this._nodeCreateBuffer = /* @__PURE__ */ new Map();
     this._nodeUpdateBuffer = /* @__PURE__ */ new Map();
@@ -177,7 +179,7 @@ var BPTreeSync = class extends BPTree {
   constructor(strategy, comparator) {
     super(strategy, comparator);
   }
-  _getPairsRightToLeft(value, startNode, fullScan, comparator) {
+  getPairsRightToLeft(value, startNode, fullScan, comparator) {
     const pairs = [];
     let node = startNode;
     let done = false;
@@ -191,7 +193,7 @@ var BPTreeSync = class extends BPTree {
           found = true;
           let j = keys.length;
           while (j--) {
-            pairs.push({ key: keys[j], value: nValue });
+            pairs.push([keys[j], nValue]);
           }
         } else if (found && !fullScan) {
           done = true;
@@ -204,9 +206,9 @@ var BPTreeSync = class extends BPTree {
       }
       node = this.getNode(node.prev);
     }
-    return pairs.reverse();
+    return new Map(pairs.reverse());
   }
-  _getPairsLeftToRight(value, startNode, fullScan, comparator) {
+  getPairsLeftToRight(value, startNode, fullScan, comparator) {
     const pairs = [];
     let node = startNode;
     let done = false;
@@ -217,8 +219,9 @@ var BPTreeSync = class extends BPTree {
         const keys = node.keys[i];
         if (comparator(nValue, value)) {
           found = true;
-          for (const key of keys) {
-            pairs.push({ key, value: nValue });
+          for (let j = 0, len2 = keys.length; j < len2; j++) {
+            const key = keys[j];
+            pairs.push([key, nValue]);
           }
         } else if (found && !fullScan) {
           done = true;
@@ -231,14 +234,14 @@ var BPTreeSync = class extends BPTree {
       }
       node = this.getNode(node.next);
     }
-    return pairs;
+    return new Map(pairs);
   }
   getPairs(value, startNode, fullScan, comparator, direction) {
     switch (direction) {
       case -1:
-        return this._getPairsRightToLeft(value, startNode, fullScan, comparator);
+        return this.getPairsRightToLeft(value, startNode, fullScan, comparator);
       case 1:
-        return this._getPairsLeftToRight(value, startNode, fullScan, comparator);
+        return this.getPairsLeftToRight(value, startNode, fullScan, comparator);
       default:
         throw new Error(`Direction must be -1 or 1. but got a ${direction}`);
     }
@@ -289,6 +292,7 @@ var BPTreeSync = class extends BPTree {
       this.root = this.getNode(keys[0]);
       this.root.parent = null;
       this.strategy.head.root = this.root.id;
+      this._strategyDirty = true;
       this.bufferForNodeUpdate(this.root);
       return;
     } else if (this.root === node) {
@@ -472,6 +476,7 @@ var BPTreeSync = class extends BPTree {
       const root = this._createNode(false, [node.id, pointer.id], [value]);
       this.root = root;
       this.strategy.head.root = root.id;
+      this._strategyDirty = true;
       node.parent = root.id;
       pointer.parent = root.id;
       this.bufferForNodeCreate(root);
@@ -570,6 +575,10 @@ var BPTreeSync = class extends BPTree {
     return node;
   }
   commitHeadBuffer() {
+    if (!this._strategyDirty) {
+      return;
+    }
+    this._strategyDirty = false;
     this.strategy.writeHead(this.strategy.head);
   }
   commitNodeCreateBuffer() {
@@ -600,11 +609,11 @@ var BPTreeSync = class extends BPTree {
       const comparator = this.verifierMap[key];
       const pairs = this.getPairs(value, startNode, fullScan, comparator, direction);
       if (!filterValues) {
-        filterValues = new Set(pairs.map((pair) => pair.key));
+        filterValues = new Set(pairs.keys());
       } else {
         const intersections = /* @__PURE__ */ new Set();
         for (const key2 of filterValues) {
-          const has = pairs.some((pair) => pair.key === key2);
+          const has = pairs.has(key2);
           if (has) {
             intersections.add(key2);
           }
@@ -627,16 +636,16 @@ var BPTreeSync = class extends BPTree {
       if (result === null) {
         result = pairs;
       } else {
-        const intersection = [];
-        for (const pair of pairs) {
-          if (result.find((p) => p.key === pair.key)) {
-            intersection.push(pair);
+        const intersection = /* @__PURE__ */ new Map();
+        for (const [k2, v] of pairs) {
+          if (result.has(k2)) {
+            intersection.set(k2, v);
           }
         }
         result = intersection;
       }
     }
-    return result ?? [];
+    return result ?? /* @__PURE__ */ new Map();
   }
   insert(key, value) {
     const before = this.insertableNode(value);
@@ -714,6 +723,7 @@ var BPTreeSync = class extends BPTree {
   }
   setHeadData(data) {
     this.strategy.head.data = data;
+    this._strategyDirty = true;
     this.commitHeadBuffer();
   }
   forceUpdate() {
@@ -732,7 +742,7 @@ var BPTreeAsync = class extends BPTree {
   constructor(strategy, comparator) {
     super(strategy, comparator);
   }
-  async _getPairsRightToLeft(value, startNode, fullScan, comparator) {
+  async getPairsRightToLeft(value, startNode, fullScan, comparator) {
     const pairs = [];
     let node = startNode;
     let done = false;
@@ -746,7 +756,7 @@ var BPTreeAsync = class extends BPTree {
           found = true;
           let j = keys.length;
           while (j--) {
-            pairs.push({ key: keys[j], value: nValue });
+            pairs.push([keys[j], nValue]);
           }
         } else if (found && !fullScan) {
           done = true;
@@ -759,9 +769,9 @@ var BPTreeAsync = class extends BPTree {
       }
       node = await this.getNode(node.prev);
     }
-    return pairs.reverse();
+    return new Map(pairs.reverse());
   }
-  async _getPairsLeftToRight(value, startNode, fullScan, comparator) {
+  async getPairsLeftToRight(value, startNode, fullScan, comparator) {
     const pairs = [];
     let node = startNode;
     let done = false;
@@ -772,8 +782,9 @@ var BPTreeAsync = class extends BPTree {
         const keys = node.keys[i];
         if (comparator(nValue, value)) {
           found = true;
-          for (const key of keys) {
-            pairs.push({ key, value: nValue });
+          for (let j = 0, len2 = keys.length; j < len2; j++) {
+            const key = keys[j];
+            pairs.push([key, nValue]);
           }
         } else if (found && !fullScan) {
           done = true;
@@ -786,14 +797,14 @@ var BPTreeAsync = class extends BPTree {
       }
       node = await this.getNode(node.next);
     }
-    return pairs;
+    return new Map(pairs);
   }
   async getPairs(value, startNode, fullScan, comparator, direction) {
     switch (direction) {
       case -1:
-        return await this._getPairsRightToLeft(value, startNode, fullScan, comparator);
+        return await this.getPairsRightToLeft(value, startNode, fullScan, comparator);
       case 1:
-        return await this._getPairsLeftToRight(value, startNode, fullScan, comparator);
+        return await this.getPairsLeftToRight(value, startNode, fullScan, comparator);
       default:
         throw new Error(`Direction must be -1 or 1. but got a ${direction}`);
     }
@@ -844,6 +855,7 @@ var BPTreeAsync = class extends BPTree {
       this.root = await this.getNode(keys[0]);
       this.root.parent = null;
       this.strategy.head.root = this.root.id;
+      this._strategyDirty = true;
       this.bufferForNodeUpdate(this.root);
       return;
     } else if (this.root === node) {
@@ -1027,6 +1039,7 @@ var BPTreeAsync = class extends BPTree {
       const root = await this._createNode(false, [node.id, pointer.id], [value]);
       this.root = root;
       this.strategy.head.root = root.id;
+      this._strategyDirty = true;
       node.parent = root.id;
       pointer.parent = root.id;
       this.bufferForNodeCreate(root);
@@ -1125,6 +1138,10 @@ var BPTreeAsync = class extends BPTree {
     return node;
   }
   async commitHeadBuffer() {
+    if (!this._strategyDirty) {
+      return;
+    }
+    this._strategyDirty = false;
     await this.strategy.writeHead(this.strategy.head);
   }
   async commitNodeCreateBuffer() {
@@ -1155,11 +1172,11 @@ var BPTreeAsync = class extends BPTree {
       const comparator = this.verifierMap[key];
       const pairs = await this.getPairs(value, startNode, fullScan, comparator, direction);
       if (!filterValues) {
-        filterValues = new Set(pairs.map((pair) => pair.key));
+        filterValues = new Set(pairs.keys());
       } else {
         const intersections = /* @__PURE__ */ new Set();
         for (const key2 of filterValues) {
-          const has = pairs.some((pair) => pair.key === key2);
+          const has = pairs.has(key2);
           if (has) {
             intersections.add(key2);
           }
@@ -1182,16 +1199,16 @@ var BPTreeAsync = class extends BPTree {
       if (result === null) {
         result = pairs;
       } else {
-        const intersection = [];
-        for (const pair of pairs) {
-          if (result.find((p) => p.key === pair.key)) {
-            intersection.push(pair);
+        const intersection = /* @__PURE__ */ new Map();
+        for (const [k2, v] of pairs) {
+          if (result.has(k2)) {
+            intersection.set(k2, v);
           }
         }
         result = intersection;
       }
     }
-    return result ?? [];
+    return result ?? /* @__PURE__ */ new Map();
   }
   async insert(key, value) {
     const before = await this.insertableNode(value);
@@ -1269,6 +1286,7 @@ var BPTreeAsync = class extends BPTree {
   }
   async setHeadData(data) {
     this.strategy.head.data = data;
+    this._strategyDirty = true;
     await this.commitHeadBuffer();
   }
   async forceUpdate() {

package/dist/types/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>, 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 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(isLeaf: boolean): Promise<string>;
     protected _createNode(isLeaf: boolean, keys: string[] | K[][], values: V[], leaf?: boolean, parent?: string | null, next?: string | null, prev?: string | null): Promise<BPTreeUnknownNode<K, V>>;
     protected _deleteEntry(node: BPTreeUnknownNode<K, V>, key: BPTreeNodeKey<K>, value: V): Promise<void>;
@@ -21,7 +21,7 @@ export declare class BPTreeAsync<K, V> extends BPTree<K, V> {
     protected commitNodeUpdateBuffer(): Promise<void>;
     protected commitNodeDeleteBuffer(): Promise<void>;
     keys(condition: BPTreeCondition<V>, filterValues?: Set<K>): Promise<Set<K>>;
-    where(condition: BPTreeCondition<V>): Promise<BPTreePair<K, V>[]>;
+    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>;

package/dist/types/BPTreeSync.d.ts

@@ -5,9 +5,9 @@ import { SerializableData } from './base/SerializeStrategy';
 export declare class BPTreeSync<K, V> extends BPTree<K, V> {
     protected readonly strategy: SerializeStrategySync<K, V>;
     constructor(strategy: SerializeStrategySync<K, V>, comparator: ValueComparator<V>);
-    protected _getPairsRightToLeft(value: V, startNode: BPTreeLeafNode<K, V>, fullScan: boolean, comparator: (nodeValue: V, value: V) => boolean): BPTreePair<K, V>[];
-    protected _getPairsLeftToRight(value: V, startNode: BPTreeLeafNode<K, V>, fullScan: boolean, comparator: (nodeValue: V, value: V) => boolean): BPTreePair<K, V>[];
-    protected getPairs(value: V, startNode: BPTreeLeafNode<K, V>, fullScan: boolean, comparator: (nodeValue: V, value: V) => boolean, direction: 1 | -1): BPTreePair<K, V>[];
+    protected getPairsRightToLeft(value: V, startNode: BPTreeLeafNode<K, V>, fullScan: boolean, comparator: (nodeValue: V, value: V) => boolean): BPTreePair<K, V>;
+    protected getPairsLeftToRight(value: V, startNode: BPTreeLeafNode<K, V>, fullScan: boolean, comparator: (nodeValue: V, value: V) => boolean): BPTreePair<K, V>;
+    protected getPairs(value: V, startNode: BPTreeLeafNode<K, V>, fullScan: boolean, comparator: (nodeValue: V, value: V) => boolean, direction: 1 | -1): BPTreePair<K, V>;
     protected _createNodeId(isLeaf: boolean): string;
     protected _createNode(isLeaf: boolean, keys: string[] | K[][], values: V[], leaf?: boolean, parent?: string | null, next?: string | null, prev?: string | null): BPTreeUnknownNode<K, V>;
     protected _deleteEntry(node: BPTreeUnknownNode<K, V>, key: BPTreeNodeKey<K>, value: V): void;
@@ -21,7 +21,7 @@ export declare class BPTreeSync<K, V> extends BPTree<K, V> {
     protected commitNodeUpdateBuffer(): void;
     protected commitNodeDeleteBuffer(): void;
     keys(condition: BPTreeCondition<V>, filterValues?: Set<K>): Set<K>;
-    where(condition: BPTreeCondition<V>): BPTreePair<K, V>[];
+    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;

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

@@ -21,10 +21,7 @@ export type BPTreeCondition<V> = Partial<{
     /** Searches for values matching the given pattern. '%' matches zero or more characters, and '_' matches exactly one character. */
     like: Partial<V>;
 }>;
-export type BPTreePair<K, V> = {
-    key: K;
-    value: V;
-};
+export type BPTreePair<K, V> = Map<K, V>;
 export type BPTreeUnknownNode<K, V> = BPTreeInternalNode<K, V> | BPTreeLeafNode<K, V>;
 export interface BPTreeNode<K, V> {
     id: string;
@@ -50,6 +47,7 @@ export declare abstract class BPTree<K, V> {
     protected readonly nodes: InvertedWeakMap<string, BPTreeUnknownNode<K, V>>;
     protected order: number;
     protected root: BPTreeUnknownNode<K, V>;
+    protected _strategyDirty: boolean;
     protected readonly _nodeCreateBuffer: Map<string, BPTreeUnknownNode<K, V>>;
     protected readonly _nodeUpdateBuffer: Map<string, BPTreeUnknownNode<K, V>>;
     protected readonly _nodeDeleteBuffer: Map<string, BPTreeUnknownNode<K, V>>;
@@ -58,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>, 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 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(isLeaf: boolean): Deferred<string>;
     protected abstract _createNode(isLeaf: boolean, keys: string[] | K[][], values: V[], leaf?: boolean, parent?: string | null, next?: string | null, prev?: string | null): Deferred<BPTreeUnknownNode<K, V>>;
     protected abstract _deleteEntry(node: BPTreeUnknownNode<K, V>, key: BPTreeNodeKey<K>, value: V): Deferred<void>;
@@ -92,7 +90,7 @@ export declare abstract class BPTree<K, V> {
      * 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.
      */
-    abstract where(condition: BPTreeCondition<V>): Deferred<BPTreePair<K, V>[]>;
+    abstract where(condition: BPTreeCondition<V>): Deferred<BPTreePair<K, V>>;
     /**
      * 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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "serializable-bptree",
-  "version": "4.0.5",
+  "version": "5.0.1",
   "description": "Store the B+tree flexibly, not only in-memory.",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.cjs",