serializable-bptree 3.2.1 → 3.2.3

package/README.md

@@ -130,7 +130,7 @@ class AgeComparator extends ValueComparator<MyObject> {
   }
 
   match(value: MyObject): string {
-    return value.age
+    return value.age.toString()
   }
 }
 ```
@@ -141,7 +141,7 @@ The **asc** method should return values in ascending order. If the return value
 
 #### 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.
+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: string }`, 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 {

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}`);
     }
@@ -610,8 +610,7 @@ var BPTreeSync = class extends BPTree {
     }
     this._nodeUpdateBuffer.clear();
   }
-  keys(condition) {
-    let result = null;
+  keys(condition, filterValues) {
     for (const k in condition) {
       const key = k;
       const value = condition[key];
@@ -620,13 +619,19 @@ var BPTreeSync = class extends BPTree {
       const fullScan = this.verifierFullScan[key];
       const comparator = this.verifierMap[key];
       const pairs = this.getPairs(value, startNode, fullScan, comparator, direction);
-      if (result === null) {
-        result = pairs.map((pair) => pair.key);
+      if (!filterValues) {
+        filterValues = 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 (filterValues.has(pair.key)) {
+            intersections.add(pair.key);
+          }
+        }
+        filterValues = intersections;
       }
     }
-    return new Set(result ?? []);
+    return filterValues ?? /* @__PURE__ */ new Set([]);
   }
   where(condition) {
     let result = null;
@@ -641,7 +646,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 ?? [];
@@ -1140,8 +1151,7 @@ var BPTreeAsync = class extends BPTree {
     }
     this._nodeUpdateBuffer.clear();
   }
-  async keys(condition) {
-    let result = null;
+  async keys(condition, filterValues) {
     for (const k in condition) {
       const key = k;
       const value = condition[key];
@@ -1150,13 +1160,19 @@ var BPTreeAsync = class extends BPTree {
       const fullScan = this.verifierFullScan[key];
       const comparator = this.verifierMap[key];
       const pairs = await this.getPairs(value, startNode, fullScan, comparator, direction);
-      if (result === null) {
-        result = pairs.map((pair) => pair.key);
+      if (!filterValues) {
+        filterValues = 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 (filterValues.has(pair.key)) {
+            intersections.add(pair.key);
+          }
+        }
+        filterValues = intersections;
       }
     }
-    return new Set(result ?? []);
+    return filterValues ?? /* @__PURE__ */ new Set([]);
   }
   async where(condition) {
     let result = null;
@@ -1171,7 +1187,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}`);
     }
@@ -576,8 +576,7 @@ var BPTreeSync = class extends BPTree {
     }
     this._nodeUpdateBuffer.clear();
   }
-  keys(condition) {
-    let result = null;
+  keys(condition, filterValues) {
     for (const k in condition) {
       const key = k;
       const value = condition[key];
@@ -586,13 +585,19 @@ var BPTreeSync = class extends BPTree {
       const fullScan = this.verifierFullScan[key];
       const comparator = this.verifierMap[key];
       const pairs = this.getPairs(value, startNode, fullScan, comparator, direction);
-      if (result === null) {
-        result = pairs.map((pair) => pair.key);
+      if (!filterValues) {
+        filterValues = 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 (filterValues.has(pair.key)) {
+            intersections.add(pair.key);
+          }
+        }
+        filterValues = intersections;
       }
     }
-    return new Set(result ?? []);
+    return filterValues ?? /* @__PURE__ */ new Set([]);
   }
   where(condition) {
     let result = null;
@@ -607,7 +612,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 ?? [];
@@ -1106,8 +1117,7 @@ var BPTreeAsync = class extends BPTree {
     }
     this._nodeUpdateBuffer.clear();
   }
-  async keys(condition) {
-    let result = null;
+  async keys(condition, filterValues) {
     for (const k in condition) {
       const key = k;
       const value = condition[key];
@@ -1116,13 +1126,19 @@ var BPTreeAsync = class extends BPTree {
       const fullScan = this.verifierFullScan[key];
       const comparator = this.verifierMap[key];
       const pairs = await this.getPairs(value, startNode, fullScan, comparator, direction);
-      if (result === null) {
-        result = pairs.map((pair) => pair.key);
+      if (!filterValues) {
+        filterValues = 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 (filterValues.has(pair.key)) {
+            intersections.add(pair.key);
+          }
+        }
+        filterValues = intersections;
       }
     }
-    return new Set(result ?? []);
+    return filterValues ?? /* @__PURE__ */ new Set([]);
   }
   async where(condition) {
     let result = null;
@@ -1137,7 +1153,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/BPTreeAsync.d.ts

@@ -19,7 +19,7 @@ export declare class BPTreeAsync<K, V> extends BPTree<K, V> {
     protected commitHeadBuffer(): Promise<void>;
     protected commitNodeCreateBuffer(): Promise<void>;
     protected commitNodeUpdateBuffer(): Promise<void>;
-    keys(condition: BPTreeCondition<V>): Promise<Set<K>>;
+    keys(condition: BPTreeCondition<V>, filterValues?: Set<K>): 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>;

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;
@@ -20,7 +20,7 @@ export declare class BPTreeSync<K, V> extends BPTree<K, V> {
     protected commitHeadBuffer(): void;
     protected commitNodeCreateBuffer(): void;
     protected commitNodeUpdateBuffer(): void;
-    keys(condition: BPTreeCondition<V>): Set<K>;
+    keys(condition: BPTreeCondition<V>, filterValues?: Set<K>): Set<K>;
     where(condition: BPTreeCondition<V>): BPTreePair<K, V>[];
     insert(key: K, value: V): void;
     delete(key: K, value: V): void;

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

@@ -80,8 +80,11 @@ export declare abstract class BPTree<K, V> {
      * 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`, `gte`, `lte`, `equal`, `notEqual`, `like` condition statements.
+     * @param filterValues The `Set` containing values to check for intersection.
+     * Returns a `Set` containing values that are common to both the input `Set` and the intersection `Set`.
+     * If this parameter is not provided, it searches for all keys inserted into the tree.
      */
-    abstract keys(condition: BPTreeCondition<V>): Deferred<Set<K>>;
+    abstract keys(condition: BPTreeCondition<V>, filterValues?: Set<K>): Deferred<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`, `gte`, `lte`, `equal`, `notEqual`, `like` condition statements.

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

@@ -10,7 +10,7 @@ export declare abstract class ValueComparator<V> {
      * 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 }`,
+     * For example, if you have a tree with values of the structure `{ country: string, capital: string }`,
      * 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.

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.3",
   "description": "Store the B+tree flexibly, not only in-memory.",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",