serializable-bptree 3.3.0 → 3.4.0-alpha.0

package/README.md

@@ -187,12 +187,12 @@ class MyFileIOStrategySync extends SerializeStrategySync {
 
 What does this method mean? And why do we need to construct such a method?
 
-#### id(): `number`
+#### id(isLeaf: `boolean`): `number`
 
 When a node is created in the B+tree, the node needs a unique value to represent itself. This is the **node.id** attribute, and you can specify this attribute yourself. For example, it could be implemented like this.
 
 ```typescript
-id(): number {
+id(isLeaf: boolean): number {
   const current = before + 1
   before = current
   return current
@@ -204,7 +204,7 @@ Or, you could use file input/output to save and load the value of the **before**
 Typically, such an **id** value increases sequentially, and it would be beneficial to store such a value separately within the tree. For that purpose, the **setHeadData** and **getHeadData** methods are available. These methods are responsible for storing arbitrary data in the tree's header or retrieving stored data. Below is an example of usage:
 
 ```typescript
-id(): number {
+id(isLeaf: boolean): number {
   const current = this.getHeadData('index', 1) as number
   this.setHeadData('index', current+1)
   return current
@@ -214,7 +214,7 @@ id(): number {
 Additionally, there is a more user-friendly usage of this code.
 
 ```typescript
-id(): number {
+id(isLeaf: boolean): number {
   return this.autoIncrement('index', 1)
 }
 ```
@@ -366,7 +366,7 @@ import {
 } from 'serializable-bptree'
 
 class FileStoreStrategyAsync extends SerializeStrategyAsync<K, V> {
-  async id(): Promise<number> {
+  async id(isLeaf: boolean): Promise<number> {
     return await this.autoIncrement('index', 1)
   }
 

package/dist/cjs/index.cjs

@@ -436,6 +436,7 @@ var BPTree = class {
   root;
   _nodeCreateBuffer;
   _nodeUpdateBuffer;
+  _nodeDeleteBuffer;
   verifierMap = {
     gt: (nv, v) => this.comparator.isHigher(nv, v),
     gte: (nv, v) => this.comparator.isHigher(nv, v) || this.comparator.isSame(nv, v),
@@ -484,6 +485,7 @@ var BPTree = class {
     this._cachedRegexp = new CacheBranchSync();
     this._nodeCreateBuffer = /* @__PURE__ */ new Map();
     this._nodeUpdateBuffer = /* @__PURE__ */ new Map();
+    this._nodeDeleteBuffer = /* @__PURE__ */ new Map();
     this.nodes = /* @__PURE__ */ new Map();
     this.strategy = strategy;
     this.comparator = comparator;
@@ -521,6 +523,9 @@ var BPTree = class {
   bufferForNodeUpdate(node) {
     this._nodeUpdateBuffer.set(node.id, node);
   }
+  bufferForNodeDelete(node) {
+    this._nodeDeleteBuffer.set(node.id, node);
+  }
   /**
    * Returns the user-defined data stored in the head of the tree.
    * This value can be set using the `setHeadData` method. If no data has been previously inserted, the default value is returned, and the default value is `{}`.
@@ -602,15 +607,15 @@ var BPTreeSync = class extends BPTree {
         throw new Error(`Direction must be -1 or 1. but got a ${direction}`);
     }
   }
-  _createNodeId() {
-    const id = this.strategy.id();
+  _createNodeId(isLeaf) {
+    const id = this.strategy.id(isLeaf);
     if (id === 0) {
       throw new Error(`The node's id should never be 0.`);
     }
     return id;
   }
-  _createNode(keys2, values, leaf = false, parent = 0, next = 0, prev = 0) {
-    const id = this._createNodeId();
+  _createNode(isLeaf, keys2, values, leaf = false, parent = 0, next = 0, prev = 0) {
+    const id = this._createNodeId(isLeaf);
     const node = {
       id,
       keys: keys2,
@@ -644,6 +649,7 @@ var BPTreeSync = class extends BPTree {
     }
     if (this.root === node && node.keys.length === 1) {
       const keys2 = node.keys;
+      this.bufferForNodeDelete(this.root);
       this.root = this.getNode(keys2[0]);
       this.root.parent = 0;
       this.strategy.head.root = this.root.id;
@@ -727,6 +733,7 @@ var BPTreeSync = class extends BPTree {
         }
         this._deleteEntry(this.getNode(node.parent), node.id, guess);
         this.bufferForNodeUpdate(pointer);
+        this.bufferForNodeDelete(node);
       } else {
         if (isPredecessor) {
           let pointerPm;
@@ -823,7 +830,7 @@ var BPTreeSync = class extends BPTree {
   }
   _insertInParent(node, value, pointer) {
     if (this.root === node) {
-      const root = this._createNode([node.id, pointer.id], [value]);
+      const root = this._createNode(false, [node.id, pointer.id], [value]);
       this.root = root;
       this.strategy.head.root = root.id;
       node.parent = root.id;
@@ -841,7 +848,7 @@ var BPTreeSync = class extends BPTree {
         parentNode.keys.splice(i + 1, 0, pointer.id);
         this.bufferForNodeUpdate(parentNode);
         if (parentNode.keys.length > this.order) {
-          const parentPointer = this._createNode([], []);
+          const parentPointer = this._createNode(false, [], []);
           parentPointer.parent = parentNode.parent;
           const mid = Math.ceil(this.order / 2) - 1;
           parentPointer.values = parentNode.values.slice(mid + 1);
@@ -874,7 +881,7 @@ var BPTreeSync = class extends BPTree {
     const head = this.strategy.readHead();
     if (head === null) {
       this.order = this.strategy.order;
-      this.root = this._createNode([], [], true);
+      this.root = this._createNode(true, [], [], true);
       this.strategy.head.root = this.root.id;
       this.bufferForNodeCreate(this.root);
       this.commitHeadBuffer();
@@ -938,6 +945,12 @@ var BPTreeSync = class extends BPTree {
     }
     this._nodeUpdateBuffer.clear();
   }
+  commitNodeDeleteBuffer() {
+    for (const node of this._nodeDeleteBuffer.values()) {
+      this.strategy.delete(node.id);
+    }
+    this._nodeDeleteBuffer.clear();
+  }
   keys(condition, filterValues) {
     for (const k in condition) {
       const key = k;
@@ -990,6 +1003,7 @@ var BPTreeSync = class extends BPTree {
     this._insertAtLeaf(before, key, value);
     if (before.values.length === this.order) {
       const after = this._createNode(
+        true,
         [],
         [],
         true,
@@ -1045,6 +1059,7 @@ var BPTreeSync = class extends BPTree {
     this.commitHeadBuffer();
     this.commitNodeCreateBuffer();
     this.commitNodeUpdateBuffer();
+    this.commitNodeDeleteBuffer();
   }
   exists(key, value) {
     const node = this.insertableNode(value);
@@ -1143,15 +1158,15 @@ var BPTreeAsync = class extends BPTree {
         throw new Error(`Direction must be -1 or 1. but got a ${direction}`);
     }
   }
-  async _createNodeId() {
-    const id = await this.strategy.id();
+  async _createNodeId(isLeaf) {
+    const id = await this.strategy.id(isLeaf);
     if (id === 0) {
       throw new Error(`The node's id should never be 0.`);
     }
     return id;
   }
-  async _createNode(keys2, values, leaf = false, parent = 0, next = 0, prev = 0) {
-    const id = await this._createNodeId();
+  async _createNode(isLeaf, keys2, values, leaf = false, parent = 0, next = 0, prev = 0) {
+    const id = await this._createNodeId(isLeaf);
     const node = {
       id,
       keys: keys2,
@@ -1185,6 +1200,7 @@ var BPTreeAsync = class extends BPTree {
     }
     if (this.root === node && node.keys.length === 1) {
       const keys2 = node.keys;
+      this.bufferForNodeDelete(this.root);
       this.root = await this.getNode(keys2[0]);
       this.root.parent = 0;
       this.strategy.head.root = this.root.id;
@@ -1268,6 +1284,7 @@ var BPTreeAsync = class extends BPTree {
         }
         await this._deleteEntry(await this.getNode(node.parent), node.id, guess);
         this.bufferForNodeUpdate(pointer);
+        this.bufferForNodeDelete(node);
       } else {
         if (isPredecessor) {
           let pointerPm;
@@ -1364,7 +1381,7 @@ var BPTreeAsync = class extends BPTree {
   }
   async _insertInParent(node, value, pointer) {
     if (this.root === node) {
-      const root = await this._createNode([node.id, pointer.id], [value]);
+      const root = await this._createNode(false, [node.id, pointer.id], [value]);
       this.root = root;
       this.strategy.head.root = root.id;
       node.parent = root.id;
@@ -1382,7 +1399,7 @@ var BPTreeAsync = class extends BPTree {
         parentNode.keys.splice(i + 1, 0, pointer.id);
         this.bufferForNodeUpdate(parentNode);
         if (parentNode.keys.length > this.order) {
-          const parentPointer = await this._createNode([], []);
+          const parentPointer = await this._createNode(false, [], []);
           parentPointer.parent = parentNode.parent;
           const mid = Math.ceil(this.order / 2) - 1;
           parentPointer.values = parentNode.values.slice(mid + 1);
@@ -1415,7 +1432,7 @@ var BPTreeAsync = class extends BPTree {
     const head = await this.strategy.readHead();
     if (head === null) {
       this.order = this.strategy.order;
-      this.root = await this._createNode([], [], true);
+      this.root = await this._createNode(true, [], [], true);
       this.strategy.head.root = this.root.id;
       this.bufferForNodeCreate(this.root);
       this.commitHeadBuffer();
@@ -1479,6 +1496,12 @@ var BPTreeAsync = class extends BPTree {
     }
     this._nodeUpdateBuffer.clear();
   }
+  async commitNodeDeleteBuffer() {
+    for (const node of this._nodeDeleteBuffer.values()) {
+      await this.strategy.delete(node.id);
+    }
+    this._nodeDeleteBuffer.clear();
+  }
   async keys(condition, filterValues) {
     for (const k in condition) {
       const key = k;
@@ -1531,6 +1554,7 @@ var BPTreeAsync = class extends BPTree {
     this._insertAtLeaf(before, key, value);
     if (before.values.length === this.order) {
       const after = await this._createNode(
+        true,
         [],
         [],
         true,
@@ -1586,6 +1610,7 @@ var BPTreeAsync = class extends BPTree {
     await this.commitHeadBuffer();
     await this.commitNodeCreateBuffer();
     await this.commitNodeUpdateBuffer();
+    await this.commitNodeDeleteBuffer();
   }
   async exists(key, value) {
     const node = await this.insertableNode(value);
@@ -1652,7 +1677,7 @@ var InMemoryStoreStrategySync = class extends SerializeStrategySync {
     super(order);
     this.node = {};
   }
-  id() {
+  id(isLeaf) {
     return this.autoIncrement("index", 1);
   }
   read(id) {
@@ -1664,6 +1689,9 @@ var InMemoryStoreStrategySync = class extends SerializeStrategySync {
   write(id, node) {
     this.node[id] = node;
   }
+  delete(id) {
+    delete this.node[id];
+  }
   readHead() {
     if (this.head.root === 0) {
       return null;
@@ -1700,7 +1728,7 @@ var InMemoryStoreStrategyAsync = class extends SerializeStrategyAsync {
     super(order);
     this.node = {};
   }
-  async id() {
+  async id(isLeaf) {
     return await this.autoIncrement("index", 1);
   }
   async read(id) {
@@ -1712,6 +1740,9 @@ var InMemoryStoreStrategyAsync = class extends SerializeStrategyAsync {
   async write(id, node) {
     this.node[id] = node;
   }
+  async delete(id) {
+    delete this.node[id];
+  }
   async readHead() {
     if (this.head.root === 0) {
       return null;

package/dist/esm/index.mjs

@@ -402,6 +402,7 @@ var BPTree = class {
   root;
   _nodeCreateBuffer;
   _nodeUpdateBuffer;
+  _nodeDeleteBuffer;
   verifierMap = {
     gt: (nv, v) => this.comparator.isHigher(nv, v),
     gte: (nv, v) => this.comparator.isHigher(nv, v) || this.comparator.isSame(nv, v),
@@ -450,6 +451,7 @@ var BPTree = class {
     this._cachedRegexp = new CacheBranchSync();
     this._nodeCreateBuffer = /* @__PURE__ */ new Map();
     this._nodeUpdateBuffer = /* @__PURE__ */ new Map();
+    this._nodeDeleteBuffer = /* @__PURE__ */ new Map();
     this.nodes = /* @__PURE__ */ new Map();
     this.strategy = strategy;
     this.comparator = comparator;
@@ -487,6 +489,9 @@ var BPTree = class {
   bufferForNodeUpdate(node) {
     this._nodeUpdateBuffer.set(node.id, node);
   }
+  bufferForNodeDelete(node) {
+    this._nodeDeleteBuffer.set(node.id, node);
+  }
   /**
    * Returns the user-defined data stored in the head of the tree.
    * This value can be set using the `setHeadData` method. If no data has been previously inserted, the default value is returned, and the default value is `{}`.
@@ -568,15 +573,15 @@ var BPTreeSync = class extends BPTree {
         throw new Error(`Direction must be -1 or 1. but got a ${direction}`);
     }
   }
-  _createNodeId() {
-    const id = this.strategy.id();
+  _createNodeId(isLeaf) {
+    const id = this.strategy.id(isLeaf);
     if (id === 0) {
       throw new Error(`The node's id should never be 0.`);
     }
     return id;
   }
-  _createNode(keys2, values, leaf = false, parent = 0, next = 0, prev = 0) {
-    const id = this._createNodeId();
+  _createNode(isLeaf, keys2, values, leaf = false, parent = 0, next = 0, prev = 0) {
+    const id = this._createNodeId(isLeaf);
     const node = {
       id,
       keys: keys2,
@@ -610,6 +615,7 @@ var BPTreeSync = class extends BPTree {
     }
     if (this.root === node && node.keys.length === 1) {
       const keys2 = node.keys;
+      this.bufferForNodeDelete(this.root);
       this.root = this.getNode(keys2[0]);
       this.root.parent = 0;
       this.strategy.head.root = this.root.id;
@@ -693,6 +699,7 @@ var BPTreeSync = class extends BPTree {
         }
         this._deleteEntry(this.getNode(node.parent), node.id, guess);
         this.bufferForNodeUpdate(pointer);
+        this.bufferForNodeDelete(node);
       } else {
         if (isPredecessor) {
           let pointerPm;
@@ -789,7 +796,7 @@ var BPTreeSync = class extends BPTree {
   }
   _insertInParent(node, value, pointer) {
     if (this.root === node) {
-      const root = this._createNode([node.id, pointer.id], [value]);
+      const root = this._createNode(false, [node.id, pointer.id], [value]);
       this.root = root;
       this.strategy.head.root = root.id;
       node.parent = root.id;
@@ -807,7 +814,7 @@ var BPTreeSync = class extends BPTree {
         parentNode.keys.splice(i + 1, 0, pointer.id);
         this.bufferForNodeUpdate(parentNode);
         if (parentNode.keys.length > this.order) {
-          const parentPointer = this._createNode([], []);
+          const parentPointer = this._createNode(false, [], []);
           parentPointer.parent = parentNode.parent;
           const mid = Math.ceil(this.order / 2) - 1;
           parentPointer.values = parentNode.values.slice(mid + 1);
@@ -840,7 +847,7 @@ var BPTreeSync = class extends BPTree {
     const head = this.strategy.readHead();
     if (head === null) {
       this.order = this.strategy.order;
-      this.root = this._createNode([], [], true);
+      this.root = this._createNode(true, [], [], true);
       this.strategy.head.root = this.root.id;
       this.bufferForNodeCreate(this.root);
       this.commitHeadBuffer();
@@ -904,6 +911,12 @@ var BPTreeSync = class extends BPTree {
     }
     this._nodeUpdateBuffer.clear();
   }
+  commitNodeDeleteBuffer() {
+    for (const node of this._nodeDeleteBuffer.values()) {
+      this.strategy.delete(node.id);
+    }
+    this._nodeDeleteBuffer.clear();
+  }
   keys(condition, filterValues) {
     for (const k in condition) {
       const key = k;
@@ -956,6 +969,7 @@ var BPTreeSync = class extends BPTree {
     this._insertAtLeaf(before, key, value);
     if (before.values.length === this.order) {
       const after = this._createNode(
+        true,
         [],
         [],
         true,
@@ -1011,6 +1025,7 @@ var BPTreeSync = class extends BPTree {
     this.commitHeadBuffer();
     this.commitNodeCreateBuffer();
     this.commitNodeUpdateBuffer();
+    this.commitNodeDeleteBuffer();
   }
   exists(key, value) {
     const node = this.insertableNode(value);
@@ -1109,15 +1124,15 @@ var BPTreeAsync = class extends BPTree {
         throw new Error(`Direction must be -1 or 1. but got a ${direction}`);
     }
   }
-  async _createNodeId() {
-    const id = await this.strategy.id();
+  async _createNodeId(isLeaf) {
+    const id = await this.strategy.id(isLeaf);
     if (id === 0) {
       throw new Error(`The node's id should never be 0.`);
     }
     return id;
   }
-  async _createNode(keys2, values, leaf = false, parent = 0, next = 0, prev = 0) {
-    const id = await this._createNodeId();
+  async _createNode(isLeaf, keys2, values, leaf = false, parent = 0, next = 0, prev = 0) {
+    const id = await this._createNodeId(isLeaf);
     const node = {
       id,
       keys: keys2,
@@ -1151,6 +1166,7 @@ var BPTreeAsync = class extends BPTree {
     }
     if (this.root === node && node.keys.length === 1) {
       const keys2 = node.keys;
+      this.bufferForNodeDelete(this.root);
       this.root = await this.getNode(keys2[0]);
       this.root.parent = 0;
       this.strategy.head.root = this.root.id;
@@ -1234,6 +1250,7 @@ var BPTreeAsync = class extends BPTree {
         }
         await this._deleteEntry(await this.getNode(node.parent), node.id, guess);
         this.bufferForNodeUpdate(pointer);
+        this.bufferForNodeDelete(node);
       } else {
         if (isPredecessor) {
           let pointerPm;
@@ -1330,7 +1347,7 @@ var BPTreeAsync = class extends BPTree {
   }
   async _insertInParent(node, value, pointer) {
     if (this.root === node) {
-      const root = await this._createNode([node.id, pointer.id], [value]);
+      const root = await this._createNode(false, [node.id, pointer.id], [value]);
       this.root = root;
       this.strategy.head.root = root.id;
       node.parent = root.id;
@@ -1348,7 +1365,7 @@ var BPTreeAsync = class extends BPTree {
         parentNode.keys.splice(i + 1, 0, pointer.id);
         this.bufferForNodeUpdate(parentNode);
         if (parentNode.keys.length > this.order) {
-          const parentPointer = await this._createNode([], []);
+          const parentPointer = await this._createNode(false, [], []);
           parentPointer.parent = parentNode.parent;
           const mid = Math.ceil(this.order / 2) - 1;
           parentPointer.values = parentNode.values.slice(mid + 1);
@@ -1381,7 +1398,7 @@ var BPTreeAsync = class extends BPTree {
     const head = await this.strategy.readHead();
     if (head === null) {
       this.order = this.strategy.order;
-      this.root = await this._createNode([], [], true);
+      this.root = await this._createNode(true, [], [], true);
       this.strategy.head.root = this.root.id;
       this.bufferForNodeCreate(this.root);
       this.commitHeadBuffer();
@@ -1445,6 +1462,12 @@ var BPTreeAsync = class extends BPTree {
     }
     this._nodeUpdateBuffer.clear();
   }
+  async commitNodeDeleteBuffer() {
+    for (const node of this._nodeDeleteBuffer.values()) {
+      await this.strategy.delete(node.id);
+    }
+    this._nodeDeleteBuffer.clear();
+  }
   async keys(condition, filterValues) {
     for (const k in condition) {
       const key = k;
@@ -1497,6 +1520,7 @@ var BPTreeAsync = class extends BPTree {
     this._insertAtLeaf(before, key, value);
     if (before.values.length === this.order) {
       const after = await this._createNode(
+        true,
         [],
         [],
         true,
@@ -1552,6 +1576,7 @@ var BPTreeAsync = class extends BPTree {
     await this.commitHeadBuffer();
     await this.commitNodeCreateBuffer();
     await this.commitNodeUpdateBuffer();
+    await this.commitNodeDeleteBuffer();
   }
   async exists(key, value) {
     const node = await this.insertableNode(value);
@@ -1618,7 +1643,7 @@ var InMemoryStoreStrategySync = class extends SerializeStrategySync {
     super(order);
     this.node = {};
   }
-  id() {
+  id(isLeaf) {
     return this.autoIncrement("index", 1);
   }
   read(id) {
@@ -1630,6 +1655,9 @@ var InMemoryStoreStrategySync = class extends SerializeStrategySync {
   write(id, node) {
     this.node[id] = node;
   }
+  delete(id) {
+    delete this.node[id];
+  }
   readHead() {
     if (this.head.root === 0) {
       return null;
@@ -1666,7 +1694,7 @@ var InMemoryStoreStrategyAsync = class extends SerializeStrategyAsync {
     super(order);
     this.node = {};
   }
-  async id() {
+  async id(isLeaf) {
     return await this.autoIncrement("index", 1);
   }
   async read(id) {
@@ -1678,6 +1706,9 @@ var InMemoryStoreStrategyAsync = class extends SerializeStrategyAsync {
   async write(id, node) {
     this.node[id] = node;
   }
+  async delete(id) {
+    delete this.node[id];
+  }
   async readHead() {
     if (this.head.root === 0) {
       return null;

package/dist/typings/BPTreeAsync.d.ts

@@ -8,8 +8,8 @@ export declare class BPTreeAsync<K, V> extends BPTree<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(): Promise<number>;
-    protected _createNode(keys: number[] | K[][], values: V[], leaf?: boolean, parent?: number, next?: number, prev?: number): Promise<BPTreeUnknownNode<K, V>>;
+    protected _createNodeId(isLeaf: boolean): Promise<number>;
+    protected _createNode(isLeaf: boolean, keys: number[] | K[][], values: V[], leaf?: boolean, parent?: number, next?: number, prev?: number): Promise<BPTreeUnknownNode<K, V>>;
     protected _deleteEntry(node: BPTreeUnknownNode<K, V>, key: BPTreeNodeKey<K>, value: V): Promise<void>;
     protected _insertInParent(node: BPTreeUnknownNode<K, V>, value: V, pointer: BPTreeUnknownNode<K, V>): Promise<void>;
     init(): Promise<void>;
@@ -19,6 +19,7 @@ export declare class BPTreeAsync<K, V> extends BPTree<K, V> {
     protected commitHeadBuffer(): Promise<void>;
     protected commitNodeCreateBuffer(): Promise<void>;
     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>[]>;
     insert(key: K, value: V): Promise<void>;

package/dist/typings/BPTreeSync.d.ts

@@ -8,8 +8,8 @@ export declare class BPTreeSync<K, V> extends BPTree<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 _createNodeId(isLeaf: boolean): number;
+    protected _createNode(isLeaf: boolean, 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;
     protected _insertInParent(node: BPTreeUnknownNode<K, V>, value: V, pointer: BPTreeUnknownNode<K, V>): void;
     init(): void;
@@ -19,6 +19,7 @@ export declare class BPTreeSync<K, V> extends BPTree<K, V> {
     protected commitHeadBuffer(): void;
     protected commitNodeCreateBuffer(): void;
     protected commitNodeUpdateBuffer(): void;
+    protected commitNodeDeleteBuffer(): void;
     keys(condition: BPTreeCondition<V>, filterValues?: Set<K>): Set<K>;
     where(condition: BPTreeCondition<V>): BPTreePair<K, V>[];
     insert(key: K, value: V): void;

package/dist/typings/SerializeStrategyAsync.d.ts

@@ -2,9 +2,10 @@ import { BPTreeNode } from './base/BPTree';
 import { SerializeStrategy, SerializeStrategyHead } from './base/SerializeStrategy';
 import { Json } from './utils/types';
 export declare abstract class SerializeStrategyAsync<K, V> extends SerializeStrategy<K, V> {
-    abstract id(): Promise<number>;
+    abstract id(isLeaf: boolean): Promise<number>;
     abstract read(id: number): Promise<BPTreeNode<K, V>>;
     abstract write(id: number, node: BPTreeNode<K, V>): Promise<void>;
+    abstract delete(id: number): Promise<void>;
     abstract readHead(): Promise<SerializeStrategyHead | null>;
     abstract writeHead(head: SerializeStrategyHead): Promise<void>;
     getHeadData(key: string, defaultValue: Json): Promise<Json>;
@@ -14,9 +15,10 @@ export declare abstract class SerializeStrategyAsync<K, V> extends SerializeStra
 export declare class InMemoryStoreStrategyAsync<K, V> extends SerializeStrategyAsync<K, V> {
     protected readonly node: Record<number, BPTreeNode<K, V>>;
     constructor(order: number);
-    id(): Promise<number>;
+    id(isLeaf: boolean): Promise<number>;
     read(id: number): Promise<BPTreeNode<K, V>>;
     write(id: number, node: BPTreeNode<K, V>): Promise<void>;
+    delete(id: number): Promise<void>;
     readHead(): Promise<SerializeStrategyHead | null>;
     writeHead(head: SerializeStrategyHead): Promise<void>;
 }

package/dist/typings/SerializeStrategySync.d.ts

@@ -2,9 +2,10 @@ import { BPTreeNode } from './base/BPTree';
 import { SerializeStrategy, SerializeStrategyHead } from './base/SerializeStrategy';
 import { Json } from './utils/types';
 export declare abstract class SerializeStrategySync<K, V> extends SerializeStrategy<K, V> {
-    abstract id(): number;
+    abstract id(isLeaf: boolean): number;
     abstract read(id: number): BPTreeNode<K, V>;
     abstract write(id: number, node: BPTreeNode<K, V>): void;
+    abstract delete(id: number): void;
     abstract readHead(): SerializeStrategyHead | null;
     abstract writeHead(head: SerializeStrategyHead): void;
     getHeadData(key: string, defaultValue: Json): Json;
@@ -14,9 +15,10 @@ export declare abstract class SerializeStrategySync<K, V> extends SerializeStrat
 export declare class InMemoryStoreStrategySync<K, V> extends SerializeStrategySync<K, V> {
     protected readonly node: Record<number, BPTreeNode<K, V>>;
     constructor(order: number);
-    id(): number;
+    id(isLeaf: boolean): number;
     read(id: number): BPTreeNode<K, V>;
     write(id: number, node: BPTreeNode<K, V>): void;
+    delete(id: number): void;
     readHead(): SerializeStrategyHead | null;
     writeHead(head: SerializeStrategyHead): void;
 }

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

@@ -51,6 +51,7 @@ export declare abstract class BPTree<K, V> {
     protected root: BPTreeUnknownNode<K, V>;
     protected readonly _nodeCreateBuffer: Map<number, BPTreeUnknownNode<K, V>>;
     protected readonly _nodeUpdateBuffer: Map<number, BPTreeUnknownNode<K, V>>;
+    protected readonly _nodeDeleteBuffer: Map<number, BPTreeUnknownNode<K, V>>;
     protected readonly verifierMap: Record<keyof BPTreeCondition<V>, (nodeValue: V, value: V) => boolean>;
     protected readonly verifierStartNode: Record<keyof BPTreeCondition<V>, (value: V) => Deferred<BPTreeLeafNode<K, V>>>;
     protected readonly verifierDirection: Record<keyof BPTreeCondition<V>, -1 | 1>;
@@ -59,8 +60,8 @@ export declare abstract class BPTree<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(): Deferred<number>;
-    protected abstract _createNode(keys: number[] | K[][], values: V[], leaf?: boolean, parent?: number, next?: number, prev?: number): Deferred<BPTreeUnknownNode<K, V>>;
+    protected abstract _createNodeId(isLeaf: boolean): Deferred<number>;
+    protected abstract _createNode(isLeaf: boolean, keys: number[] | K[][], values: V[], leaf?: boolean, parent?: number, next?: number, prev?: number): Deferred<BPTreeUnknownNode<K, V>>;
     protected abstract _deleteEntry(node: BPTreeUnknownNode<K, V>, key: BPTreeNodeKey<K>, value: V): Deferred<void>;
     protected abstract _insertInParent(node: BPTreeUnknownNode<K, V>, value: V, pointer: BPTreeUnknownNode<K, V>): Deferred<void>;
     protected abstract getNode(id: number): Deferred<BPTreeUnknownNode<K, V>>;
@@ -124,8 +125,9 @@ export declare abstract class BPTree<K, V> {
      */
     abstract forceUpdate(): Deferred<number>;
     protected _insertAtLeaf(node: BPTreeLeafNode<K, V>, key: K, value: V): void;
-    protected bufferForNodeCreate(node: BPTreeUnknownNode<K, V>): Deferred<void>;
-    protected bufferForNodeUpdate(node: BPTreeUnknownNode<K, V>): Deferred<void>;
+    protected bufferForNodeCreate(node: BPTreeUnknownNode<K, V>): void;
+    protected bufferForNodeUpdate(node: BPTreeUnknownNode<K, V>): void;
+    protected bufferForNodeDelete(node: BPTreeUnknownNode<K, V>): void;
     /**
      * Returns the user-defined data stored in the head of the tree.
      * This value can be set using the `setHeadData` method. If no data has been previously inserted, the default value is returned, and the default value is `{}`.

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

@@ -15,8 +15,9 @@ export declare abstract class SerializeStrategy<K, V> {
      * When a new node is created within the tree, the value returned by this method becomes the node's ID.
      *
      * **WARNING!** The return value should never be `0`.
+     * @param isLeaf This is a flag that indicates whether the node is a leaf node or not.
      */
-    abstract id(): number | Promise<number>;
+    abstract id(isLeaf: boolean): number | Promise<number>;
     /**
      * Read the stored node from the ID.
      * The JSON object of the read node should be returned.
@@ -30,6 +31,12 @@ export declare abstract class SerializeStrategy<K, V> {
      * @param node This is the JSON object of the node to be stored.
      */
     abstract write(id: number, node: BPTreeNode<K, V>): void | Promise<void>;
+    /**
+     * This method is called when previously created nodes become no longer needed due to deletion or other processes.
+     * It can be used to free up space by deleting existing stored nodes.
+     * @param id This is the ID of the node to be deleted.
+     */
+    abstract delete(id: number): void | Promise<void>;
     /**
      * It is called when the `init` method of the tree instance is called.
      * This method should return the information needed to initialize the tree. This information refers to the values stored in the `writeHead` method.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "serializable-bptree",
-  "version": "3.3.0",
+  "version": "3.4.0-alpha.0",
   "description": "Store the B+tree flexibly, not only in-memory.",
   "main": "dist/cjs/index.cjs",
   "module": "dist/esm/index.mjs",