serializable-bptree 8.3.1 → 8.3.3

package/dist/cjs/index.cjs

@@ -1519,83 +1519,217 @@ var BPTreeTransaction = class _BPTreeTransaction {
       return regexp.test(nodeValue);
     }
   };
-  verifierStartNode = {
-    gt: (v) => this.insertableNodeByPrimary(v),
-    gte: (v) => this.insertableNodeByPrimary(v),
-    lt: (v) => this.insertableNodeByPrimary(v),
-    lte: (v) => this.insertableRightestNodeByPrimary(v),
-    equal: (v) => this.insertableNodeByPrimary(v),
-    notEqual: (v) => this.leftestNode(),
-    or: (v) => this.insertableNodeByPrimary(this.lowestPrimaryValue(this.ensureValues(v))),
-    primaryGt: (v) => this.insertableNodeByPrimary(v),
-    primaryGte: (v) => this.insertableNodeByPrimary(v),
-    primaryLt: (v) => this.insertableNodeByPrimary(v),
-    primaryLte: (v) => this.insertableRightestNodeByPrimary(v),
-    primaryEqual: (v) => this.insertableNodeByPrimary(v),
-    primaryNotEqual: (v) => this.leftestNode(),
-    primaryOr: (v) => this.insertableNodeByPrimary(this.lowestPrimaryValue(this.ensureValues(v))),
-    like: (v) => this.leftestNode()
-  };
-  verifierEndNode = {
-    gt: (v) => null,
-    gte: (v) => null,
-    lt: (v) => null,
-    lte: (v) => null,
-    equal: (v) => this.insertableEndNode(v, this.verifierDirection.equal),
-    notEqual: (v) => null,
-    or: (v) => this.insertableEndNode(
-      this.highestValue(this.ensureValues(v)),
-      this.verifierDirection.or
-    ),
-    primaryGt: (v) => null,
-    primaryGte: (v) => null,
-    primaryLt: (v) => null,
-    primaryLte: (v) => null,
-    primaryEqual: (v) => this.insertableRightestEndNodeByPrimary(v),
-    primaryNotEqual: (v) => null,
-    primaryOr: (v) => this.insertableRightestEndNodeByPrimary(
-      this.highestPrimaryValue(this.ensureValues(v))
-    ),
-    like: (v) => null
-  };
-  verifierDirection = {
-    gt: 1,
-    gte: 1,
-    lt: -1,
-    lte: -1,
-    equal: 1,
-    notEqual: 1,
-    or: 1,
-    primaryGt: 1,
-    primaryGte: 1,
-    primaryLt: -1,
-    primaryLte: -1,
-    primaryEqual: 1,
-    primaryNotEqual: 1,
-    primaryOr: 1,
-    like: 1
-  };
-  /**
-   * Determines whether early termination is allowed for each condition.
-   * When true, the search will stop once a match is found and then a non-match is encountered.
-   * Only applicable for conditions that guarantee contiguous matches in a sorted B+Tree.
-   */
-  verifierEarlyTerminate = {
-    gt: false,
-    gte: false,
-    lt: false,
-    lte: false,
-    equal: true,
-    notEqual: false,
-    or: false,
-    primaryGt: false,
-    primaryGte: false,
-    primaryLt: false,
-    primaryLte: false,
-    primaryEqual: true,
-    primaryNotEqual: false,
-    primaryOr: false,
-    like: false
+  searchConfigs = {
+    gt: {
+      asc: {
+        start: (tx, v) => tx.insertableNodeByPrimary(v[0]),
+        end: () => null,
+        direction: 1,
+        earlyTerminate: false
+      },
+      desc: {
+        start: (tx) => tx.rightestNode(),
+        end: (tx, v) => tx.insertableEndNode(v[0], -1),
+        direction: -1,
+        earlyTerminate: true
+      }
+    },
+    gte: {
+      asc: {
+        start: (tx, v) => tx.insertableNodeByPrimary(v[0]),
+        end: () => null,
+        direction: 1,
+        earlyTerminate: false
+      },
+      desc: {
+        start: (tx) => tx.rightestNode(),
+        end: (tx, v) => tx.insertableEndNode(v[0], -1),
+        direction: -1,
+        earlyTerminate: true
+      }
+    },
+    lt: {
+      asc: {
+        start: (tx) => tx.leftestNode(),
+        end: (tx, v) => tx.insertableEndNode(v[0], 1),
+        direction: 1,
+        earlyTerminate: true
+      },
+      desc: {
+        start: (tx, v) => tx.insertableNodeByPrimary(v[0]),
+        end: () => null,
+        direction: -1,
+        earlyTerminate: false
+      }
+    },
+    lte: {
+      asc: {
+        start: (tx) => tx.leftestNode(),
+        end: (tx, v) => tx.insertableEndNode(v[0], 1),
+        direction: 1,
+        earlyTerminate: true
+      },
+      desc: {
+        start: (tx, v) => tx.insertableRightestNodeByPrimary(v[0]),
+        end: () => null,
+        direction: -1,
+        earlyTerminate: false
+      }
+    },
+    equal: {
+      asc: {
+        start: (tx, v) => tx.insertableNodeByPrimary(v[0]),
+        end: (tx, v) => tx.insertableEndNode(v[0], 1),
+        direction: 1,
+        earlyTerminate: true
+      },
+      desc: {
+        start: (tx, v) => tx.insertableEndNode(v[0], 1),
+        end: (tx, v) => tx.insertableEndNode(v[0], -1),
+        direction: -1,
+        earlyTerminate: true
+      }
+    },
+    notEqual: {
+      asc: {
+        start: (tx) => tx.leftestNode(),
+        end: () => null,
+        direction: 1,
+        earlyTerminate: false
+      },
+      desc: {
+        start: (tx) => tx.rightestNode(),
+        end: () => null,
+        direction: -1,
+        earlyTerminate: false
+      }
+    },
+    or: {
+      asc: {
+        start: (tx, v) => tx.insertableNodeByPrimary(tx.lowestValue(v)),
+        end: (tx, v) => tx.insertableEndNode(tx.highestValue(v), 1),
+        direction: 1,
+        earlyTerminate: false
+      },
+      desc: {
+        start: (tx, v) => tx.insertableEndNode(tx.highestValue(v), 1),
+        end: (tx, v) => tx.insertableEndNode(tx.lowestValue(v), -1),
+        direction: -1,
+        earlyTerminate: false
+      }
+    },
+    primaryGt: {
+      asc: {
+        start: (tx, v) => tx.insertableRightestEndNodeByPrimary(v[0]),
+        end: () => null,
+        direction: 1,
+        earlyTerminate: false
+      },
+      desc: {
+        start: (tx) => tx.rightestNode(),
+        end: (tx, v) => tx.insertableEndNode(v[0], -1),
+        direction: -1,
+        earlyTerminate: true
+      }
+    },
+    primaryGte: {
+      asc: {
+        start: (tx, v) => tx.insertableNodeByPrimary(v[0]),
+        end: () => null,
+        direction: 1,
+        earlyTerminate: false
+      },
+      desc: {
+        start: (tx) => tx.rightestNode(),
+        end: (tx, v) => tx.insertableEndNode(v[0], -1),
+        direction: -1,
+        earlyTerminate: true
+      }
+    },
+    primaryLt: {
+      asc: {
+        start: (tx) => tx.leftestNode(),
+        end: (tx, v) => tx.insertableEndNode(v[0], 1),
+        direction: 1,
+        earlyTerminate: true
+      },
+      desc: {
+        start: (tx, v) => tx.insertableNodeByPrimary(v[0]),
+        end: () => null,
+        direction: -1,
+        earlyTerminate: false
+      }
+    },
+    primaryLte: {
+      asc: {
+        start: (tx) => tx.leftestNode(),
+        end: (tx, v) => tx.insertableEndNode(v[0], 1),
+        direction: 1,
+        earlyTerminate: true
+      },
+      desc: {
+        start: (tx, v) => tx.insertableRightestNodeByPrimary(v[0]),
+        end: () => null,
+        direction: -1,
+        earlyTerminate: false
+      }
+    },
+    primaryEqual: {
+      asc: {
+        start: (tx, v) => tx.insertableNodeByPrimary(v[0]),
+        end: (tx, v) => tx.insertableRightestEndNodeByPrimary(v[0]),
+        direction: 1,
+        earlyTerminate: true
+      },
+      desc: {
+        start: (tx, v) => tx.insertableRightestEndNodeByPrimary(v[0]),
+        end: (tx, v) => tx.insertableEndNode(v[0], -1),
+        direction: -1,
+        earlyTerminate: true
+      }
+    },
+    primaryNotEqual: {
+      asc: {
+        start: (tx) => tx.leftestNode(),
+        end: () => null,
+        direction: 1,
+        earlyTerminate: false
+      },
+      desc: {
+        start: (tx) => tx.rightestNode(),
+        end: () => null,
+        direction: -1,
+        earlyTerminate: false
+      }
+    },
+    primaryOr: {
+      asc: {
+        start: (tx, v) => tx.insertableNodeByPrimary(tx.lowestPrimaryValue(v)),
+        end: (tx, v) => tx.insertableRightestEndNodeByPrimary(tx.highestPrimaryValue(v)),
+        direction: 1,
+        earlyTerminate: false
+      },
+      desc: {
+        start: (tx, v) => tx.insertableRightestEndNodeByPrimary(tx.highestPrimaryValue(v)),
+        end: (tx, v) => tx.insertableEndNode(tx.lowestPrimaryValue(v), -1),
+        direction: -1,
+        earlyTerminate: false
+      }
+    },
+    like: {
+      asc: {
+        start: (tx) => tx.leftestNode(),
+        end: () => null,
+        direction: 1,
+        earlyTerminate: false
+      },
+      desc: {
+        start: (tx) => tx.rightestNode(),
+        end: () => null,
+        direction: -1,
+        earlyTerminate: false
+      }
+    }
   };
   /**
    * Priority map for condition types.
@@ -2027,7 +2161,7 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
     return this.getNode(node.next);
   }
   insertableEndNode(value, direction) {
-    const insertableNode = this.insertableNode(value);
+    const insertableNode = direction === -1 ? this.insertableNodeByPrimary(value) : this.insertableRightestNodeByPrimary(value);
     let key;
     switch (direction) {
       case -1:
@@ -2208,16 +2342,20 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
     const driverKey = this.getDriverKey(condition);
     if (!driverKey) return;
     const value = condition[driverKey];
-    let startNode = this.verifierStartNode[driverKey](value);
-    let endNode = this.verifierEndNode[driverKey](value);
-    let direction = this.verifierDirection[driverKey];
+    const v = this.ensureValues(value);
+    const config = this.searchConfigs[driverKey][order];
+    let startNode = config.start(this, v);
+    let endNode = config.end(this, v);
+    const direction = config.direction;
+    const earlyTerminate = config.earlyTerminate;
+    if (order === "desc" && !startNode) {
+      startNode = this.rightestNode();
+    }
+    if (order === "asc" && !startNode) {
+      startNode = this.leftestNode();
+    }
+    if (!startNode) return;
     const comparator = this.verifierMap[driverKey];
-    const earlyTerminate = this.verifierEarlyTerminate[driverKey];
-    if (order === "desc") {
-      startNode = endNode ?? this.rightestNode();
-      endNode = null;
-      direction *= -1;
-    }
     const generator = this.getPairsGenerator(
       value,
       startNode,
@@ -2229,7 +2367,7 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
     let count = 0;
     const intersection = filterValues && filterValues.size > 0 ? filterValues : null;
     for (const pair of generator) {
-      const [k, v] = pair;
+      const [k, v2] = pair;
       if (intersection && !intersection.has(k)) {
         continue;
       }
@@ -2238,7 +2376,7 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
         if (key === driverKey) continue;
         const verify = this.verifierMap[key];
         const condValue = condition[key];
-        if (!verify(v, condValue)) {
+        if (!verify(v2, condValue)) {
           isMatch = false;
           break;
         }
@@ -3159,7 +3297,7 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
     return await this.getNode(node.next);
   }
   async insertableEndNode(value, direction) {
-    const insertableNode = await this.insertableNode(value);
+    const insertableNode = direction === -1 ? await this.insertableNodeByPrimary(value) : await this.insertableRightestNodeByPrimary(value);
     let key;
     switch (direction) {
       case -1:
@@ -3346,16 +3484,20 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
     const driverKey = this.getDriverKey(condition);
     if (!driverKey) return;
     const value = condition[driverKey];
-    let startNode = await this.verifierStartNode[driverKey](value);
-    let endNode = await this.verifierEndNode[driverKey](value);
-    let direction = this.verifierDirection[driverKey];
+    const v = this.ensureValues(value);
+    const config = this.searchConfigs[driverKey][order];
+    let startNode = await config.start(this, v);
+    let endNode = await config.end(this, v);
+    const direction = config.direction;
+    const earlyTerminate = config.earlyTerminate;
+    if (order === "desc" && !startNode) {
+      startNode = await this.rightestNode();
+    }
+    if (order === "asc" && !startNode) {
+      startNode = await this.leftestNode();
+    }
+    if (!startNode) return;
     const comparator = this.verifierMap[driverKey];
-    const earlyTerminate = this.verifierEarlyTerminate[driverKey];
-    if (order === "desc") {
-      startNode = endNode ?? await this.rightestNode();
-      endNode = null;
-      direction *= -1;
-    }
     const generator = this.getPairsGenerator(
       value,
       startNode,
@@ -3367,7 +3509,7 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
     let count = 0;
     const intersection = filterValues && filterValues.size > 0 ? filterValues : null;
     for await (const pair of generator) {
-      const [k, v] = pair;
+      const [k, v2] = pair;
       if (intersection && !intersection.has(k)) {
         continue;
       }
@@ -3376,7 +3518,7 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
         if (key === driverKey) continue;
         const verify = this.verifierMap[key];
         const condValue = condition[key];
-        if (!verify(v, condValue)) {
+        if (!verify(v2, condValue)) {
           isMatch = false;
           break;
         }

package/dist/esm/index.mjs

@@ -1483,83 +1483,217 @@ var BPTreeTransaction = class _BPTreeTransaction {
       return regexp.test(nodeValue);
     }
   };
-  verifierStartNode = {
-    gt: (v) => this.insertableNodeByPrimary(v),
-    gte: (v) => this.insertableNodeByPrimary(v),
-    lt: (v) => this.insertableNodeByPrimary(v),
-    lte: (v) => this.insertableRightestNodeByPrimary(v),
-    equal: (v) => this.insertableNodeByPrimary(v),
-    notEqual: (v) => this.leftestNode(),
-    or: (v) => this.insertableNodeByPrimary(this.lowestPrimaryValue(this.ensureValues(v))),
-    primaryGt: (v) => this.insertableNodeByPrimary(v),
-    primaryGte: (v) => this.insertableNodeByPrimary(v),
-    primaryLt: (v) => this.insertableNodeByPrimary(v),
-    primaryLte: (v) => this.insertableRightestNodeByPrimary(v),
-    primaryEqual: (v) => this.insertableNodeByPrimary(v),
-    primaryNotEqual: (v) => this.leftestNode(),
-    primaryOr: (v) => this.insertableNodeByPrimary(this.lowestPrimaryValue(this.ensureValues(v))),
-    like: (v) => this.leftestNode()
-  };
-  verifierEndNode = {
-    gt: (v) => null,
-    gte: (v) => null,
-    lt: (v) => null,
-    lte: (v) => null,
-    equal: (v) => this.insertableEndNode(v, this.verifierDirection.equal),
-    notEqual: (v) => null,
-    or: (v) => this.insertableEndNode(
-      this.highestValue(this.ensureValues(v)),
-      this.verifierDirection.or
-    ),
-    primaryGt: (v) => null,
-    primaryGte: (v) => null,
-    primaryLt: (v) => null,
-    primaryLte: (v) => null,
-    primaryEqual: (v) => this.insertableRightestEndNodeByPrimary(v),
-    primaryNotEqual: (v) => null,
-    primaryOr: (v) => this.insertableRightestEndNodeByPrimary(
-      this.highestPrimaryValue(this.ensureValues(v))
-    ),
-    like: (v) => null
-  };
-  verifierDirection = {
-    gt: 1,
-    gte: 1,
-    lt: -1,
-    lte: -1,
-    equal: 1,
-    notEqual: 1,
-    or: 1,
-    primaryGt: 1,
-    primaryGte: 1,
-    primaryLt: -1,
-    primaryLte: -1,
-    primaryEqual: 1,
-    primaryNotEqual: 1,
-    primaryOr: 1,
-    like: 1
-  };
-  /**
-   * Determines whether early termination is allowed for each condition.
-   * When true, the search will stop once a match is found and then a non-match is encountered.
-   * Only applicable for conditions that guarantee contiguous matches in a sorted B+Tree.
-   */
-  verifierEarlyTerminate = {
-    gt: false,
-    gte: false,
-    lt: false,
-    lte: false,
-    equal: true,
-    notEqual: false,
-    or: false,
-    primaryGt: false,
-    primaryGte: false,
-    primaryLt: false,
-    primaryLte: false,
-    primaryEqual: true,
-    primaryNotEqual: false,
-    primaryOr: false,
-    like: false
+  searchConfigs = {
+    gt: {
+      asc: {
+        start: (tx, v) => tx.insertableNodeByPrimary(v[0]),
+        end: () => null,
+        direction: 1,
+        earlyTerminate: false
+      },
+      desc: {
+        start: (tx) => tx.rightestNode(),
+        end: (tx, v) => tx.insertableEndNode(v[0], -1),
+        direction: -1,
+        earlyTerminate: true
+      }
+    },
+    gte: {
+      asc: {
+        start: (tx, v) => tx.insertableNodeByPrimary(v[0]),
+        end: () => null,
+        direction: 1,
+        earlyTerminate: false
+      },
+      desc: {
+        start: (tx) => tx.rightestNode(),
+        end: (tx, v) => tx.insertableEndNode(v[0], -1),
+        direction: -1,
+        earlyTerminate: true
+      }
+    },
+    lt: {
+      asc: {
+        start: (tx) => tx.leftestNode(),
+        end: (tx, v) => tx.insertableEndNode(v[0], 1),
+        direction: 1,
+        earlyTerminate: true
+      },
+      desc: {
+        start: (tx, v) => tx.insertableNodeByPrimary(v[0]),
+        end: () => null,
+        direction: -1,
+        earlyTerminate: false
+      }
+    },
+    lte: {
+      asc: {
+        start: (tx) => tx.leftestNode(),
+        end: (tx, v) => tx.insertableEndNode(v[0], 1),
+        direction: 1,
+        earlyTerminate: true
+      },
+      desc: {
+        start: (tx, v) => tx.insertableRightestNodeByPrimary(v[0]),
+        end: () => null,
+        direction: -1,
+        earlyTerminate: false
+      }
+    },
+    equal: {
+      asc: {
+        start: (tx, v) => tx.insertableNodeByPrimary(v[0]),
+        end: (tx, v) => tx.insertableEndNode(v[0], 1),
+        direction: 1,
+        earlyTerminate: true
+      },
+      desc: {
+        start: (tx, v) => tx.insertableEndNode(v[0], 1),
+        end: (tx, v) => tx.insertableEndNode(v[0], -1),
+        direction: -1,
+        earlyTerminate: true
+      }
+    },
+    notEqual: {
+      asc: {
+        start: (tx) => tx.leftestNode(),
+        end: () => null,
+        direction: 1,
+        earlyTerminate: false
+      },
+      desc: {
+        start: (tx) => tx.rightestNode(),
+        end: () => null,
+        direction: -1,
+        earlyTerminate: false
+      }
+    },
+    or: {
+      asc: {
+        start: (tx, v) => tx.insertableNodeByPrimary(tx.lowestValue(v)),
+        end: (tx, v) => tx.insertableEndNode(tx.highestValue(v), 1),
+        direction: 1,
+        earlyTerminate: false
+      },
+      desc: {
+        start: (tx, v) => tx.insertableEndNode(tx.highestValue(v), 1),
+        end: (tx, v) => tx.insertableEndNode(tx.lowestValue(v), -1),
+        direction: -1,
+        earlyTerminate: false
+      }
+    },
+    primaryGt: {
+      asc: {
+        start: (tx, v) => tx.insertableRightestEndNodeByPrimary(v[0]),
+        end: () => null,
+        direction: 1,
+        earlyTerminate: false
+      },
+      desc: {
+        start: (tx) => tx.rightestNode(),
+        end: (tx, v) => tx.insertableEndNode(v[0], -1),
+        direction: -1,
+        earlyTerminate: true
+      }
+    },
+    primaryGte: {
+      asc: {
+        start: (tx, v) => tx.insertableNodeByPrimary(v[0]),
+        end: () => null,
+        direction: 1,
+        earlyTerminate: false
+      },
+      desc: {
+        start: (tx) => tx.rightestNode(),
+        end: (tx, v) => tx.insertableEndNode(v[0], -1),
+        direction: -1,
+        earlyTerminate: true
+      }
+    },
+    primaryLt: {
+      asc: {
+        start: (tx) => tx.leftestNode(),
+        end: (tx, v) => tx.insertableEndNode(v[0], 1),
+        direction: 1,
+        earlyTerminate: true
+      },
+      desc: {
+        start: (tx, v) => tx.insertableNodeByPrimary(v[0]),
+        end: () => null,
+        direction: -1,
+        earlyTerminate: false
+      }
+    },
+    primaryLte: {
+      asc: {
+        start: (tx) => tx.leftestNode(),
+        end: (tx, v) => tx.insertableEndNode(v[0], 1),
+        direction: 1,
+        earlyTerminate: true
+      },
+      desc: {
+        start: (tx, v) => tx.insertableRightestNodeByPrimary(v[0]),
+        end: () => null,
+        direction: -1,
+        earlyTerminate: false
+      }
+    },
+    primaryEqual: {
+      asc: {
+        start: (tx, v) => tx.insertableNodeByPrimary(v[0]),
+        end: (tx, v) => tx.insertableRightestEndNodeByPrimary(v[0]),
+        direction: 1,
+        earlyTerminate: true
+      },
+      desc: {
+        start: (tx, v) => tx.insertableRightestEndNodeByPrimary(v[0]),
+        end: (tx, v) => tx.insertableEndNode(v[0], -1),
+        direction: -1,
+        earlyTerminate: true
+      }
+    },
+    primaryNotEqual: {
+      asc: {
+        start: (tx) => tx.leftestNode(),
+        end: () => null,
+        direction: 1,
+        earlyTerminate: false
+      },
+      desc: {
+        start: (tx) => tx.rightestNode(),
+        end: () => null,
+        direction: -1,
+        earlyTerminate: false
+      }
+    },
+    primaryOr: {
+      asc: {
+        start: (tx, v) => tx.insertableNodeByPrimary(tx.lowestPrimaryValue(v)),
+        end: (tx, v) => tx.insertableRightestEndNodeByPrimary(tx.highestPrimaryValue(v)),
+        direction: 1,
+        earlyTerminate: false
+      },
+      desc: {
+        start: (tx, v) => tx.insertableRightestEndNodeByPrimary(tx.highestPrimaryValue(v)),
+        end: (tx, v) => tx.insertableEndNode(tx.lowestPrimaryValue(v), -1),
+        direction: -1,
+        earlyTerminate: false
+      }
+    },
+    like: {
+      asc: {
+        start: (tx) => tx.leftestNode(),
+        end: () => null,
+        direction: 1,
+        earlyTerminate: false
+      },
+      desc: {
+        start: (tx) => tx.rightestNode(),
+        end: () => null,
+        direction: -1,
+        earlyTerminate: false
+      }
+    }
   };
   /**
    * Priority map for condition types.
@@ -1991,7 +2125,7 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
     return this.getNode(node.next);
   }
   insertableEndNode(value, direction) {
-    const insertableNode = this.insertableNode(value);
+    const insertableNode = direction === -1 ? this.insertableNodeByPrimary(value) : this.insertableRightestNodeByPrimary(value);
     let key;
     switch (direction) {
       case -1:
@@ -2172,16 +2306,20 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
     const driverKey = this.getDriverKey(condition);
     if (!driverKey) return;
     const value = condition[driverKey];
-    let startNode = this.verifierStartNode[driverKey](value);
-    let endNode = this.verifierEndNode[driverKey](value);
-    let direction = this.verifierDirection[driverKey];
+    const v = this.ensureValues(value);
+    const config = this.searchConfigs[driverKey][order];
+    let startNode = config.start(this, v);
+    let endNode = config.end(this, v);
+    const direction = config.direction;
+    const earlyTerminate = config.earlyTerminate;
+    if (order === "desc" && !startNode) {
+      startNode = this.rightestNode();
+    }
+    if (order === "asc" && !startNode) {
+      startNode = this.leftestNode();
+    }
+    if (!startNode) return;
     const comparator = this.verifierMap[driverKey];
-    const earlyTerminate = this.verifierEarlyTerminate[driverKey];
-    if (order === "desc") {
-      startNode = endNode ?? this.rightestNode();
-      endNode = null;
-      direction *= -1;
-    }
     const generator = this.getPairsGenerator(
       value,
       startNode,
@@ -2193,7 +2331,7 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
     let count = 0;
     const intersection = filterValues && filterValues.size > 0 ? filterValues : null;
     for (const pair of generator) {
-      const [k, v] = pair;
+      const [k, v2] = pair;
       if (intersection && !intersection.has(k)) {
         continue;
       }
@@ -2202,7 +2340,7 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
         if (key === driverKey) continue;
         const verify = this.verifierMap[key];
         const condValue = condition[key];
-        if (!verify(v, condValue)) {
+        if (!verify(v2, condValue)) {
           isMatch = false;
           break;
         }
@@ -3123,7 +3261,7 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
     return await this.getNode(node.next);
   }
   async insertableEndNode(value, direction) {
-    const insertableNode = await this.insertableNode(value);
+    const insertableNode = direction === -1 ? await this.insertableNodeByPrimary(value) : await this.insertableRightestNodeByPrimary(value);
     let key;
     switch (direction) {
       case -1:
@@ -3310,16 +3448,20 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
     const driverKey = this.getDriverKey(condition);
     if (!driverKey) return;
     const value = condition[driverKey];
-    let startNode = await this.verifierStartNode[driverKey](value);
-    let endNode = await this.verifierEndNode[driverKey](value);
-    let direction = this.verifierDirection[driverKey];
+    const v = this.ensureValues(value);
+    const config = this.searchConfigs[driverKey][order];
+    let startNode = await config.start(this, v);
+    let endNode = await config.end(this, v);
+    const direction = config.direction;
+    const earlyTerminate = config.earlyTerminate;
+    if (order === "desc" && !startNode) {
+      startNode = await this.rightestNode();
+    }
+    if (order === "asc" && !startNode) {
+      startNode = await this.leftestNode();
+    }
+    if (!startNode) return;
     const comparator = this.verifierMap[driverKey];
-    const earlyTerminate = this.verifierEarlyTerminate[driverKey];
-    if (order === "desc") {
-      startNode = endNode ?? await this.rightestNode();
-      endNode = null;
-      direction *= -1;
-    }
     const generator = this.getPairsGenerator(
       value,
       startNode,
@@ -3331,7 +3473,7 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
     let count = 0;
     const intersection = filterValues && filterValues.size > 0 ? filterValues : null;
     for await (const pair of generator) {
-      const [k, v] = pair;
+      const [k, v2] = pair;
       if (intersection && !intersection.has(k)) {
         continue;
       }
@@ -3340,7 +3482,7 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
         if (key === driverKey) continue;
         const verify = this.verifierMap[key];
         const condValue = condition[key];
-        if (!verify(v, condValue)) {
+        if (!verify(v2, condValue)) {
           isMatch = false;
           break;
         }

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

@@ -17,15 +17,12 @@ export declare abstract class BPTreeTransaction<K, V> {
     protected isInitialized: boolean;
     protected isDestroyed: boolean;
     protected readonly verifierMap: Record<keyof BPTreeCondition<V>, (nodeValue: V, value: V | V[]) => boolean>;
-    protected readonly verifierStartNode: Record<keyof BPTreeCondition<V>, (value: V) => Deferred<BPTreeLeafNode<K, V>>>;
-    protected readonly verifierEndNode: Record<keyof BPTreeCondition<V>, (value: V) => Deferred<BPTreeLeafNode<K, V> | null>>;
-    protected readonly verifierDirection: Record<keyof BPTreeCondition<V>, -1 | 1>;
-    /**
-     * Determines whether early termination is allowed for each condition.
-     * When true, the search will stop once a match is found and then a non-match is encountered.
-     * Only applicable for conditions that guarantee contiguous matches in a sorted B+Tree.
-     */
-    protected readonly verifierEarlyTerminate: Record<keyof BPTreeCondition<V>, boolean>;
+    protected readonly searchConfigs: Record<keyof BPTreeCondition<V>, Record<'asc' | 'desc', {
+        start: (tx: BPTreeTransaction<K, V>, v: V[]) => Deferred<BPTreeLeafNode<K, V> | null>;
+        end: (tx: BPTreeTransaction<K, V>, v: V[]) => Deferred<BPTreeLeafNode<K, V> | null>;
+        direction: 1 | -1;
+        earlyTerminate: boolean;
+    }>>;
     /**
      * Priority map for condition types.
      * Higher value = higher selectivity (fewer expected results).

package/package.json

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