serializable-bptree 3.2.1 → 3.2.2

package/dist/cjs/index.js

@@ -181,7 +181,7 @@ var BPTreeSync = class extends BPTree {
   constructor(strategy, comparator) {
     super(strategy, comparator);
   }
-  _getPairsRightToLeft(value, startNode, fullSearch, comparator) {
+  _getPairsRightToLeft(value, startNode, fullScan, comparator) {
     const pairs = [];
     let node = startNode;
     let done = false;
@@ -197,7 +197,7 @@ var BPTreeSync = class extends BPTree {
           while (j--) {
             pairs.push({ key: keys[j], value: nValue });
           }
-        } else if (found && !fullSearch) {
+        } else if (found && !fullScan) {
           done = true;
           break;
         }
@@ -210,7 +210,7 @@ var BPTreeSync = class extends BPTree {
     }
     return pairs.reverse();
   }
-  _getPairsLeftToRight(value, startNode, fullSearch, comparator) {
+  _getPairsLeftToRight(value, startNode, fullScan, comparator) {
     const pairs = [];
     let node = startNode;
     let done = false;
@@ -224,7 +224,7 @@ var BPTreeSync = class extends BPTree {
           for (const key of keys) {
             pairs.push({ key, value: nValue });
           }
-        } else if (found && !fullSearch) {
+        } else if (found && !fullScan) {
           done = true;
           break;
         }
@@ -237,12 +237,12 @@ var BPTreeSync = class extends BPTree {
     }
     return pairs;
   }
-  getPairs(value, startNode, fullSearch, comparator, direction) {
+  getPairs(value, startNode, fullScan, comparator, direction) {
     switch (direction) {
       case -1:
-        return this._getPairsRightToLeft(value, startNode, fullSearch, comparator);
+        return this._getPairsRightToLeft(value, startNode, fullScan, comparator);
       case 1:
-        return this._getPairsLeftToRight(value, startNode, fullSearch, comparator);
+        return this._getPairsLeftToRight(value, startNode, fullScan, comparator);
       default:
         throw new Error(`Direction must be -1 or 1. but got a ${direction}`);
     }
@@ -621,12 +621,18 @@ var BPTreeSync = class extends BPTree {
       const comparator = this.verifierMap[key];
       const pairs = this.getPairs(value, startNode, fullScan, comparator, direction);
       if (result === null) {
-        result = pairs.map((pair) => pair.key);
+        result = new Set(pairs.map((pair) => pair.key));
       } else {
-        result = result.filter((key2) => pairs.find((p) => p.key === key2));
+        const intersections = /* @__PURE__ */ new Set();
+        for (const pair of pairs) {
+          if (result.has(pair.key)) {
+            intersections.add(pair.key);
+          }
+        }
+        result = intersections;
       }
     }
-    return new Set(result ?? []);
+    return result ?? /* @__PURE__ */ new Set([]);
   }
   where(condition) {
     let result = null;
@@ -641,7 +647,13 @@ var BPTreeSync = class extends BPTree {
       if (result === null) {
         result = pairs;
       } else {
-        result = result.filter((pair) => pairs.find((p) => p.key === pair.key));
+        const intersection = [];
+        for (const pair of pairs) {
+          if (result.find((p) => p.key === pair.key)) {
+            intersection.push(pair);
+          }
+        }
+        result = intersection;
       }
     }
     return result ?? [];
@@ -1151,12 +1163,18 @@ var BPTreeAsync = class extends BPTree {
       const comparator = this.verifierMap[key];
       const pairs = await this.getPairs(value, startNode, fullScan, comparator, direction);
       if (result === null) {
-        result = pairs.map((pair) => pair.key);
+        result = new Set(pairs.map((pair) => pair.key));
       } else {
-        result = result.filter((key2) => pairs.find((p) => p.key === key2));
+        const intersections = /* @__PURE__ */ new Set();
+        for (const pair of pairs) {
+          if (result.has(pair.key)) {
+            intersections.add(pair.key);
+          }
+        }
+        result = intersections;
       }
     }
-    return new Set(result ?? []);
+    return result ?? /* @__PURE__ */ new Set([]);
   }
   async where(condition) {
     let result = null;
@@ -1171,7 +1189,13 @@ var BPTreeAsync = class extends BPTree {
       if (result === null) {
         result = pairs;
       } else {
-        result = result.filter((pair) => pairs.find((p) => p.key === pair.key));
+        const intersection = [];
+        for (const pair of pairs) {
+          if (result.find((p) => p.key === pair.key)) {
+            intersection.push(pair);
+          }
+        }
+        result = intersection;
       }
     }
     return result ?? [];

package/dist/esm/index.js

@@ -147,7 +147,7 @@ var BPTreeSync = class extends BPTree {
   constructor(strategy, comparator) {
     super(strategy, comparator);
   }
-  _getPairsRightToLeft(value, startNode, fullSearch, comparator) {
+  _getPairsRightToLeft(value, startNode, fullScan, comparator) {
     const pairs = [];
     let node = startNode;
     let done = false;
@@ -163,7 +163,7 @@ var BPTreeSync = class extends BPTree {
           while (j--) {
             pairs.push({ key: keys[j], value: nValue });
           }
-        } else if (found && !fullSearch) {
+        } else if (found && !fullScan) {
           done = true;
           break;
         }
@@ -176,7 +176,7 @@ var BPTreeSync = class extends BPTree {
     }
     return pairs.reverse();
   }
-  _getPairsLeftToRight(value, startNode, fullSearch, comparator) {
+  _getPairsLeftToRight(value, startNode, fullScan, comparator) {
     const pairs = [];
     let node = startNode;
     let done = false;
@@ -190,7 +190,7 @@ var BPTreeSync = class extends BPTree {
           for (const key of keys) {
             pairs.push({ key, value: nValue });
           }
-        } else if (found && !fullSearch) {
+        } else if (found && !fullScan) {
           done = true;
           break;
         }
@@ -203,12 +203,12 @@ var BPTreeSync = class extends BPTree {
     }
     return pairs;
   }
-  getPairs(value, startNode, fullSearch, comparator, direction) {
+  getPairs(value, startNode, fullScan, comparator, direction) {
     switch (direction) {
       case -1:
-        return this._getPairsRightToLeft(value, startNode, fullSearch, comparator);
+        return this._getPairsRightToLeft(value, startNode, fullScan, comparator);
       case 1:
-        return this._getPairsLeftToRight(value, startNode, fullSearch, comparator);
+        return this._getPairsLeftToRight(value, startNode, fullScan, comparator);
       default:
         throw new Error(`Direction must be -1 or 1. but got a ${direction}`);
     }
@@ -587,12 +587,18 @@ var BPTreeSync = class extends BPTree {
       const comparator = this.verifierMap[key];
       const pairs = this.getPairs(value, startNode, fullScan, comparator, direction);
       if (result === null) {
-        result = pairs.map((pair) => pair.key);
+        result = new Set(pairs.map((pair) => pair.key));
       } else {
-        result = result.filter((key2) => pairs.find((p) => p.key === key2));
+        const intersections = /* @__PURE__ */ new Set();
+        for (const pair of pairs) {
+          if (result.has(pair.key)) {
+            intersections.add(pair.key);
+          }
+        }
+        result = intersections;
       }
     }
-    return new Set(result ?? []);
+    return result ?? /* @__PURE__ */ new Set([]);
   }
   where(condition) {
     let result = null;
@@ -607,7 +613,13 @@ var BPTreeSync = class extends BPTree {
       if (result === null) {
         result = pairs;
       } else {
-        result = result.filter((pair) => pairs.find((p) => p.key === pair.key));
+        const intersection = [];
+        for (const pair of pairs) {
+          if (result.find((p) => p.key === pair.key)) {
+            intersection.push(pair);
+          }
+        }
+        result = intersection;
       }
     }
     return result ?? [];
@@ -1117,12 +1129,18 @@ var BPTreeAsync = class extends BPTree {
       const comparator = this.verifierMap[key];
       const pairs = await this.getPairs(value, startNode, fullScan, comparator, direction);
       if (result === null) {
-        result = pairs.map((pair) => pair.key);
+        result = new Set(pairs.map((pair) => pair.key));
       } else {
-        result = result.filter((key2) => pairs.find((p) => p.key === key2));
+        const intersections = /* @__PURE__ */ new Set();
+        for (const pair of pairs) {
+          if (result.has(pair.key)) {
+            intersections.add(pair.key);
+          }
+        }
+        result = intersections;
       }
     }
-    return new Set(result ?? []);
+    return result ?? /* @__PURE__ */ new Set([]);
   }
   async where(condition) {
     let result = null;
@@ -1137,7 +1155,13 @@ var BPTreeAsync = class extends BPTree {
       if (result === null) {
         result = pairs;
       } else {
-        result = result.filter((pair) => pairs.find((p) => p.key === pair.key));
+        const intersection = [];
+        for (const pair of pairs) {
+          if (result.find((p) => p.key === pair.key)) {
+            intersection.push(pair);
+          }
+        }
+        result = intersection;
       }
     }
     return result ?? [];

package/dist/typings/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>, fullSearch: boolean, comparator: (nodeValue: V, value: V) => boolean): BPTreePair<K, V>[];
-    protected _getPairsLeftToRight(value: V, startNode: BPTreeLeafNode<K, V>, fullSearch: boolean, comparator: (nodeValue: V, value: V) => boolean): BPTreePair<K, V>[];
-    protected getPairs(value: V, startNode: BPTreeLeafNode<K, V>, fullSearch: 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(): 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;

package/dist/typings/index.d.ts

@@ -1,5 +1,5 @@
-export type { BPTreeNode } from './base/BPTree';
-export type { SerializeStrategyHead } from './base/SerializeStrategy';
+export type { BPTreeNode, BPTreeCondition } from './base/BPTree';
+export type { SerializeStrategyHead, SerializableData } from './base/SerializeStrategy';
 export { ValueComparator, NumericComparator, StringComparator } from './base/ValueComparator';
 export { BPTreeSync } from './BPTreeSync';
 export { BPTreeAsync } from './BPTreeAsync';

package/package.json

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