serializable-bptree 9.0.4-alpha.2 → 9.0.4

package/dist/cjs/index.cjs

@@ -2309,8 +2309,8 @@ function deleteEntry(ops, ctx, node, key, comparator) {
         } else {
           pointerP0 = siblingNode.keys.splice(0, 1)[0];
           pointerK0 = siblingNode.values.splice(0, 1)[0];
-          node.keys = node.keys.concat(pointerP0);
-          node.values = node.values.concat(pointerK0);
+          node.keys = [...node.keys, pointerP0];
+          node.values = [...node.values, pointerK0];
           parentNode = cloneNode(ops.getNode(node.parent));
           const pointerIndex = parentNode.keys.indexOf(siblingNode.id);
           if (pointerIndex > 0) {
@@ -2390,6 +2390,13 @@ function deleteOp(ops, ctx, key, comparator, value) {
     break;
   }
 }
+function batchDeleteOp(ops, ctx, entries, comparator) {
+  if (entries.length === 0) return;
+  for (let i = 0, len = entries.length; i < len; i++) {
+    const [key, value] = entries[i];
+    deleteOp(ops, ctx, key, comparator, value);
+  }
+}
 function batchInsertOp(ops, ctx, entries, comparator) {
   if (entries.length === 0) return;
   const sorted = [...entries].sort((a, b) => comparator.asc(a[1], b[1]));
@@ -3365,6 +3372,9 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
   delete(key, value) {
     deleteOp(this._ops, this._ctx, key, this.comparator, value);
   }
+  batchDelete(entries) {
+    batchDeleteOp(this._ops, this._ctx, entries, this.comparator);
+  }
   // ─── Head Data ───────────────────────────────────────────────────
   getHeadData() {
     const head = this._readHead();
@@ -3490,6 +3500,14 @@ var BPTreeSync = class extends BPTreeSyncTransaction {
       throw new Error(`Transaction failed: ${result.error || "Commit failed due to conflict"}`);
     }
   }
+  batchDelete(entries) {
+    const tx = this.createTransaction();
+    tx.batchDelete(entries);
+    const result = tx.commit();
+    if (!result.success) {
+      throw new Error(`Transaction failed: ${result.error || "Commit failed due to conflict"}`);
+    }
+  }
   batchInsert(entries) {
     const tx = this.createTransaction();
     tx.batchInsert(entries);
@@ -4312,8 +4330,8 @@ async function deleteEntryAsync(ops, ctx, node, key, comparator) {
         } else {
           pointerP0 = siblingNode.keys.splice(0, 1)[0];
           pointerK0 = siblingNode.values.splice(0, 1)[0];
-          node.keys = node.keys.concat(pointerP0);
-          node.values = node.values.concat(pointerK0);
+          node.keys = [...node.keys, pointerP0];
+          node.values = [...node.values, pointerK0];
           parentNode = cloneNode(await ops.getNode(node.parent));
           const pi = parentNode.keys.indexOf(siblingNode.id);
           if (pi > 0) {
@@ -4385,6 +4403,13 @@ async function deleteOpAsync(ops, ctx, key, comparator, value) {
     break;
   }
 }
+async function batchDeleteOpAsync(ops, ctx, entries, comparator) {
+  if (entries.length === 0) return;
+  for (let i = 0, len = entries.length; i < len; i++) {
+    const [key, value] = entries[i];
+    await deleteOpAsync(ops, ctx, key, comparator, value);
+  }
+}
 async function batchInsertOpAsync(ops, ctx, entries, comparator) {
   if (entries.length === 0) return;
   const sorted = [...entries].sort((a, b) => comparator.asc(a[1], b[1]));
@@ -4809,6 +4834,12 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
       await deleteOpAsync(this._ops, this._ctx, key, this.comparator, value);
     });
   }
+  async batchDelete(entries) {
+    if (entries.length === 0) return;
+    return this.writeLock(0, async () => {
+      await batchDeleteOpAsync(this._ops, this._ctx, entries, this.comparator);
+    });
+  }
   // ─── Head Data ───────────────────────────────────────────────────
   async getHeadData() {
     const head = await this._readHead();
@@ -4938,6 +4969,16 @@ var BPTreeAsync = class extends BPTreeAsyncTransaction {
       }
     });
   }
+  async batchDelete(entries) {
+    return this.writeLock(1, async () => {
+      const tx = await this.createTransaction();
+      await tx.batchDelete(entries);
+      const result = await tx.commit();
+      if (!result.success) {
+        throw new Error(`Transaction failed: ${result.error || "Commit failed due to conflict"}`);
+      }
+    });
+  }
   async batchInsert(entries) {
     return this.writeLock(1, async () => {
       const tx = await this.createTransaction();
@@ -5045,6 +5086,7 @@ var BPTreePureSync = class {
     };
     function flush() {
       for (const id of deleteBuffer) {
+        writeBuffer.delete(id);
         strategy.delete(id);
       }
       for (const [id, node] of writeBuffer) {
@@ -5181,6 +5223,12 @@ var BPTreePureSync = class {
     deleteOp(ops, ctx, key, this.comparator, value);
     flush();
   }
+  batchDelete(entries) {
+    const { ops, flush } = this._createBufferedOps();
+    const ctx = this._createCtx();
+    batchDeleteOp(ops, ctx, entries, this.comparator);
+    flush();
+  }
   batchInsert(entries) {
     const { ops, flush } = this._createBufferedOps();
     const ctx = this._createCtx();
@@ -5299,6 +5347,7 @@ var BPTreePureAsync = class {
     };
     async function flush() {
       for (const id of deleteBuffer) {
+        writeBuffer.delete(id);
         await strategy.delete(id);
       }
       for (const [id, node] of writeBuffer) {
@@ -5467,6 +5516,14 @@ var BPTreePureAsync = class {
       await flush();
     });
   }
+  async batchDelete(entries) {
+    return this.writeLock(async () => {
+      const { ops, flush } = this._createBufferedOps();
+      const ctx = await this._createCtx();
+      await batchDeleteOpAsync(ops, ctx, entries, this.comparator);
+      await flush();
+    });
+  }
   async bulkLoad(entries) {
     return this.writeLock(async () => {
       const { ops, flush } = this._createBufferedOps();

package/dist/esm/index.mjs

@@ -2271,8 +2271,8 @@ function deleteEntry(ops, ctx, node, key, comparator) {
         } else {
           pointerP0 = siblingNode.keys.splice(0, 1)[0];
           pointerK0 = siblingNode.values.splice(0, 1)[0];
-          node.keys = node.keys.concat(pointerP0);
-          node.values = node.values.concat(pointerK0);
+          node.keys = [...node.keys, pointerP0];
+          node.values = [...node.values, pointerK0];
           parentNode = cloneNode(ops.getNode(node.parent));
           const pointerIndex = parentNode.keys.indexOf(siblingNode.id);
           if (pointerIndex > 0) {
@@ -2352,6 +2352,13 @@ function deleteOp(ops, ctx, key, comparator, value) {
     break;
   }
 }
+function batchDeleteOp(ops, ctx, entries, comparator) {
+  if (entries.length === 0) return;
+  for (let i = 0, len = entries.length; i < len; i++) {
+    const [key, value] = entries[i];
+    deleteOp(ops, ctx, key, comparator, value);
+  }
+}
 function batchInsertOp(ops, ctx, entries, comparator) {
   if (entries.length === 0) return;
   const sorted = [...entries].sort((a, b) => comparator.asc(a[1], b[1]));
@@ -3327,6 +3334,9 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
   delete(key, value) {
     deleteOp(this._ops, this._ctx, key, this.comparator, value);
   }
+  batchDelete(entries) {
+    batchDeleteOp(this._ops, this._ctx, entries, this.comparator);
+  }
   // ─── Head Data ───────────────────────────────────────────────────
   getHeadData() {
     const head = this._readHead();
@@ -3452,6 +3462,14 @@ var BPTreeSync = class extends BPTreeSyncTransaction {
       throw new Error(`Transaction failed: ${result.error || "Commit failed due to conflict"}`);
     }
   }
+  batchDelete(entries) {
+    const tx = this.createTransaction();
+    tx.batchDelete(entries);
+    const result = tx.commit();
+    if (!result.success) {
+      throw new Error(`Transaction failed: ${result.error || "Commit failed due to conflict"}`);
+    }
+  }
   batchInsert(entries) {
     const tx = this.createTransaction();
     tx.batchInsert(entries);
@@ -4274,8 +4292,8 @@ async function deleteEntryAsync(ops, ctx, node, key, comparator) {
         } else {
           pointerP0 = siblingNode.keys.splice(0, 1)[0];
           pointerK0 = siblingNode.values.splice(0, 1)[0];
-          node.keys = node.keys.concat(pointerP0);
-          node.values = node.values.concat(pointerK0);
+          node.keys = [...node.keys, pointerP0];
+          node.values = [...node.values, pointerK0];
           parentNode = cloneNode(await ops.getNode(node.parent));
           const pi = parentNode.keys.indexOf(siblingNode.id);
           if (pi > 0) {
@@ -4347,6 +4365,13 @@ async function deleteOpAsync(ops, ctx, key, comparator, value) {
     break;
   }
 }
+async function batchDeleteOpAsync(ops, ctx, entries, comparator) {
+  if (entries.length === 0) return;
+  for (let i = 0, len = entries.length; i < len; i++) {
+    const [key, value] = entries[i];
+    await deleteOpAsync(ops, ctx, key, comparator, value);
+  }
+}
 async function batchInsertOpAsync(ops, ctx, entries, comparator) {
   if (entries.length === 0) return;
   const sorted = [...entries].sort((a, b) => comparator.asc(a[1], b[1]));
@@ -4771,6 +4796,12 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
       await deleteOpAsync(this._ops, this._ctx, key, this.comparator, value);
     });
   }
+  async batchDelete(entries) {
+    if (entries.length === 0) return;
+    return this.writeLock(0, async () => {
+      await batchDeleteOpAsync(this._ops, this._ctx, entries, this.comparator);
+    });
+  }
   // ─── Head Data ───────────────────────────────────────────────────
   async getHeadData() {
     const head = await this._readHead();
@@ -4900,6 +4931,16 @@ var BPTreeAsync = class extends BPTreeAsyncTransaction {
       }
     });
   }
+  async batchDelete(entries) {
+    return this.writeLock(1, async () => {
+      const tx = await this.createTransaction();
+      await tx.batchDelete(entries);
+      const result = await tx.commit();
+      if (!result.success) {
+        throw new Error(`Transaction failed: ${result.error || "Commit failed due to conflict"}`);
+      }
+    });
+  }
   async batchInsert(entries) {
     return this.writeLock(1, async () => {
       const tx = await this.createTransaction();
@@ -5007,6 +5048,7 @@ var BPTreePureSync = class {
     };
     function flush() {
       for (const id of deleteBuffer) {
+        writeBuffer.delete(id);
         strategy.delete(id);
       }
       for (const [id, node] of writeBuffer) {
@@ -5143,6 +5185,12 @@ var BPTreePureSync = class {
     deleteOp(ops, ctx, key, this.comparator, value);
     flush();
   }
+  batchDelete(entries) {
+    const { ops, flush } = this._createBufferedOps();
+    const ctx = this._createCtx();
+    batchDeleteOp(ops, ctx, entries, this.comparator);
+    flush();
+  }
   batchInsert(entries) {
     const { ops, flush } = this._createBufferedOps();
     const ctx = this._createCtx();
@@ -5261,6 +5309,7 @@ var BPTreePureAsync = class {
     };
     async function flush() {
       for (const id of deleteBuffer) {
+        writeBuffer.delete(id);
         await strategy.delete(id);
       }
       for (const [id, node] of writeBuffer) {
@@ -5429,6 +5478,14 @@ var BPTreePureAsync = class {
       await flush();
     });
   }
+  async batchDelete(entries) {
+    return this.writeLock(async () => {
+      const { ops, flush } = this._createBufferedOps();
+      const ctx = await this._createCtx();
+      await batchDeleteOpAsync(ops, ctx, entries, this.comparator);
+      await flush();
+    });
+  }
   async bulkLoad(entries) {
     return this.writeLock(async () => {
       const { ops, flush } = this._createBufferedOps();

package/dist/types/BPTreeAsync.d.ts

@@ -11,6 +11,7 @@ export declare class BPTreeAsync<K, V> extends BPTreeAsyncTransaction<K, V> {
     createTransaction(): Promise<BPTreeAsyncTransaction<K, V>>;
     insert(key: K, value: V): Promise<void>;
     delete(key: K, value?: V): Promise<void>;
+    batchDelete(entries: [K, V?][]): Promise<void>;
     batchInsert(entries: [K, V][]): Promise<void>;
     bulkLoad(entries: [K, V][]): Promise<void>;
 }

package/dist/types/BPTreePureAsync.d.ts

@@ -32,6 +32,7 @@ export declare class BPTreePureAsync<K, V> implements IBPTree<K, V> {
     insert(key: K, value: V): Promise<void>;
     delete(key: K, value?: V): Promise<void>;
     batchInsert(entries: [K, V][]): Promise<void>;
+    batchDelete(entries: [K, V?][]): Promise<void>;
     bulkLoad(entries: [K, V][]): Promise<void>;
     getHeadData(): Promise<SerializableData>;
     setHeadData(data: SerializableData): Promise<void>;

package/dist/types/BPTreePureSync.d.ts

@@ -28,6 +28,7 @@ export declare class BPTreePureSync<K, V> implements IBPTree<K, V> {
     where(condition: BPTreeCondition<V>, options?: BPTreeSearchOption<K>): BPTreePair<K, V>;
     insert(key: K, value: V): void;
     delete(key: K, value?: V): void;
+    batchDelete(entries: [K, V?][]): void;
     batchInsert(entries: [K, V][]): void;
     bulkLoad(entries: [K, V][]): void;
     getHeadData(): SerializableData;

package/dist/types/BPTreeSync.d.ts

@@ -11,6 +11,7 @@ export declare class BPTreeSync<K, V> extends BPTreeSyncTransaction<K, V> {
     createTransaction(): BPTreeSyncTransaction<K, V>;
     insert(key: K, value: V): void;
     delete(key: K, value?: V): void;
+    batchDelete(entries: [K, V?][]): void;
     batchInsert(entries: [K, V][]): void;
     bulkLoad(entries: [K, V][]): void;
 }

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

@@ -22,6 +22,7 @@ export declare function insertInParentAsync<K, V>(ops: BPTreeNodeOpsAsync<K, V>,
 export declare function insertOpAsync<K, V>(ops: BPTreeNodeOpsAsync<K, V>, ctx: BPTreeAlgoContext<K, V>, key: K, value: V, comparator: ValueComparator<V>): Promise<void>;
 export declare function deleteEntryAsync<K, V>(ops: BPTreeNodeOpsAsync<K, V>, ctx: BPTreeAlgoContext<K, V>, node: BPTreeUnknownNode<K, V>, key: BPTreeNodeKey<K>, comparator: ValueComparator<V>): Promise<BPTreeUnknownNode<K, V>>;
 export declare function deleteOpAsync<K, V>(ops: BPTreeNodeOpsAsync<K, V>, ctx: BPTreeAlgoContext<K, V>, key: K, comparator: ValueComparator<V>, value?: V): Promise<void>;
+export declare function batchDeleteOpAsync<K, V>(ops: BPTreeNodeOpsAsync<K, V>, ctx: BPTreeAlgoContext<K, V>, entries: [K, V?][], comparator: ValueComparator<V>): Promise<void>;
 export declare function batchInsertOpAsync<K, V>(ops: BPTreeNodeOpsAsync<K, V>, ctx: BPTreeAlgoContext<K, V>, entries: [K, V][], comparator: ValueComparator<V>): Promise<void>;
 export declare function bulkLoadOpAsync<K, V>(ops: BPTreeNodeOpsAsync<K, V>, ctx: BPTreeAlgoContext<K, V>, entries: [K, V][], comparator: ValueComparator<V>): Promise<void>;
 export declare function existsOpAsync<K, V>(ops: BPTreeNodeOpsAsync<K, V>, rootId: string, key: K, value: V, comparator: ValueComparator<V>): Promise<boolean>;

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

@@ -35,6 +35,7 @@ export declare function insertInParent<K, V>(ops: BPTreeNodeOps<K, V>, ctx: BPTr
 export declare function insertOp<K, V>(ops: BPTreeNodeOps<K, V>, ctx: BPTreeAlgoContext<K, V>, key: K, value: V, comparator: ValueComparator<V>): void;
 export declare function deleteEntry<K, V>(ops: BPTreeNodeOps<K, V>, ctx: BPTreeAlgoContext<K, V>, node: BPTreeUnknownNode<K, V>, key: BPTreeNodeKey<K>, comparator: ValueComparator<V>): BPTreeUnknownNode<K, V>;
 export declare function deleteOp<K, V>(ops: BPTreeNodeOps<K, V>, ctx: BPTreeAlgoContext<K, V>, key: K, comparator: ValueComparator<V>, value?: V): void;
+export declare function batchDeleteOp<K, V>(ops: BPTreeNodeOps<K, V>, ctx: BPTreeAlgoContext<K, V>, entries: [K, V?][], comparator: ValueComparator<V>): void;
 export declare function batchInsertOp<K, V>(ops: BPTreeNodeOps<K, V>, ctx: BPTreeAlgoContext<K, V>, entries: [K, V][], comparator: ValueComparator<V>): void;
 export declare function bulkLoadOp<K, V>(ops: BPTreeNodeOps<K, V>, ctx: BPTreeAlgoContext<K, V>, entries: [K, V][], comparator: ValueComparator<V>): void;
 export declare function existsOp<K, V>(ops: BPTreeNodeOps<K, V>, rootId: string, key: K, value: V, comparator: ValueComparator<V>): boolean;

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

@@ -111,6 +111,7 @@ export declare abstract class BPTreeTransaction<K, V> implements IBPTree<K, V> {
     abstract batchInsert(entries: [K, V][]): Deferred<void>;
     abstract bulkLoad(entries: [K, V][]): Deferred<void>;
     abstract delete(key: K, value?: V): Deferred<void>;
+    abstract batchDelete(entries: [K, V?][]): Deferred<void>;
     abstract exists(key: K, value: V): Deferred<boolean>;
     abstract setHeadData(data: SerializableData): Deferred<void>;
     abstract getHeadData(): Deferred<SerializableData>;

package/dist/types/transaction/BPTreeAsyncTransaction.d.ts

@@ -51,6 +51,7 @@ export declare class BPTreeAsyncTransaction<K, V> extends BPTreeTransaction<K, V
     bulkLoad(entries: [K, V][]): Promise<void>;
     protected _deleteEntry(node: BPTreeUnknownNode<K, V>, key: BPTreeNodeKey<K>): Promise<BPTreeUnknownNode<K, V>>;
     delete(key: K, value?: V): Promise<void>;
+    batchDelete(entries: [K, V?][]): Promise<void>;
     getHeadData(): Promise<SerializableData>;
     setHeadData(data: SerializableData): Promise<void>;
     commit(label?: string): Promise<TransactionResult<string, BPTreeNode<K, V>>>;

package/dist/types/transaction/BPTreeSyncTransaction.d.ts

@@ -48,6 +48,7 @@ export declare class BPTreeSyncTransaction<K, V> extends BPTreeTransaction<K, V>
     bulkLoad(entries: [K, V][]): void;
     protected _deleteEntry(node: BPTreeUnknownNode<K, V>, key: BPTreeNodeKey<K>): BPTreeUnknownNode<K, V>;
     delete(key: K, value?: V): void;
+    batchDelete(entries: [K, V?][]): void;
     getHeadData(): SerializableData;
     setHeadData(data: SerializableData): void;
     commit(label?: string): TransactionResult<string, BPTreeNode<K, V>>;

package/dist/types/types/index.d.ts

@@ -208,6 +208,12 @@ export interface IBPTree<K, V> {
      * @warning If the 'value' is not specified, a full scan will be performed to find the value associated with the key, which may lead to performance degradation.
      */
     delete(key: K, value?: V): Deferred<void>;
+    /**
+     * Deletes multiple key-value pairs from the tree in a single batch operation.
+     * This is more efficient than calling delete() multiple times.
+     * @param entries Array of [key, value?] pairs to delete. If value is omitted, a full scan will be performed.
+     */
+    batchDelete(entries: [K, V?][]): Deferred<void>;
     /**
      * It returns whether there is a value in the tree.
      * @param key The key value to search for. This key must be unique.

package/package.json

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