serializable-bptree 6.2.1 → 6.2.3

package/dist/cjs/index.cjs

@@ -472,7 +472,7 @@ var BPTree = class _BPTree {
   comparator;
   option;
   order;
-  root;
+  rootId;
   _strategyDirty;
   _nodeCreateBuffer;
   _nodeUpdateBuffer;
@@ -501,13 +501,13 @@ var BPTree = class _BPTree {
     }
   };
   verifierStartNode = {
-    gt: (v) => this.insertableNode(v),
-    gte: (v) => this.insertableNode(v),
-    lt: (v) => this.insertableNode(v),
-    lte: (v) => this.insertableNode(v),
-    equal: (v) => this.insertableNode(v),
+    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.insertableNode(this.lowestValue(this.ensureValues(v))),
+    or: (v) => this.insertableNodeByPrimary(this.lowestPrimaryValue(this.ensureValues(v))),
     primaryGt: (v) => this.insertableNodeByPrimary(v),
     primaryGte: (v) => this.insertableNodeByPrimary(v),
     primaryLt: (v) => this.insertableNodeByPrimary(v),
@@ -532,7 +532,7 @@ var BPTree = class _BPTree {
     primaryGte: (v) => null,
     primaryLt: (v) => null,
     primaryLte: (v) => null,
-    primaryEqual: (v) => null,
+    primaryEqual: (v) => this.insertableRightestEndNodeByPrimary(v),
     primaryNotEqual: (v) => null,
     primaryOr: (v) => this.insertableRightestEndNodeByPrimary(
       this.highestPrimaryValue(this.ensureValues(v))
@@ -726,19 +726,19 @@ var BPTree = class _BPTree {
     }
   }
   bufferForNodeCreate(node) {
-    if (node.id === this.root.id) {
+    if (node.id === this.rootId) {
       this._strategyDirty = true;
     }
     this._nodeCreateBuffer.set(node.id, node);
   }
   bufferForNodeUpdate(node) {
-    if (node.id === this.root.id) {
+    if (node.id === this.rootId) {
       this._strategyDirty = true;
     }
     this._nodeUpdateBuffer.set(node.id, node);
   }
   bufferForNodeDelete(node) {
-    if (node.id === this.root.id) {
+    if (node.id === this.rootId) {
       this._strategyDirty = true;
     }
     this._nodeDeleteBuffer.set(node.id, node);
@@ -871,16 +871,18 @@ var BPTreeSync = class extends BPTree {
         }
       }
     }
-    if (this.root.id === node.id && node.keys.length === 1) {
+    if (this.rootId === node.id && node.keys.length === 1) {
       const keys = node.keys;
-      this.bufferForNodeDelete(this.root);
-      this.root = this.getNode(keys[0]);
-      this.root.parent = null;
-      this.strategy.head.root = this.root.id;
-      this.bufferForNodeUpdate(this.root);
+      this.bufferForNodeDelete(node);
+      const newRoot = this.getNode(keys[0]);
+      this.rootId = newRoot.id;
+      newRoot.parent = null;
+      this.strategy.head.root = this.rootId;
+      this.bufferForNodeUpdate(newRoot);
       return;
-    } else if (this.root.id === node.id) {
-      this.bufferForNodeUpdate(this.root);
+    } else if (this.rootId === node.id) {
+      const root = this.getNode(this.rootId);
+      this.bufferForNodeUpdate(root);
       return;
     } else if (node.keys.length < Math.ceil(this.order / 2) && !node.leaf || node.values.length < Math.ceil((this.order - 1) / 2) && node.leaf) {
       if (node.parent === null) {
@@ -1060,9 +1062,9 @@ var BPTreeSync = class extends BPTree {
     }
   }
   _insertInParent(node, value, pointer) {
-    if (this.root.id === node.id) {
+    if (this.rootId === node.id) {
       const root = this._createNode(false, [node.id, pointer.id], [value]);
-      this.root = root;
+      this.rootId = root.id;
       this.strategy.head.root = root.id;
       node.parent = root.id;
       pointer.parent = root.id;
@@ -1131,15 +1133,16 @@ var BPTreeSync = class extends BPTree {
     const head = this.strategy.readHead();
     if (head === null) {
       this.order = this.strategy.order;
-      this.root = this._createNode(true, [], [], true);
-      this.strategy.head.root = this.root.id;
+      const root = this._createNode(true, [], [], true);
+      this.rootId = root.id;
+      this.strategy.head.root = this.rootId;
       this.commitHeadBuffer();
       this.commitNodeCreateBuffer();
     } else {
       const { root, order } = head;
       this.strategy.head = head;
       this.order = order;
-      this.root = this.getNode(root);
+      this.rootId = root;
     }
     if (this.order < 3) {
       throw new Error(`The 'order' parameter must be greater than 2. but got a '${this.order}'.`);
@@ -1156,7 +1159,7 @@ var BPTreeSync = class extends BPTree {
     return cache.raw;
   }
   insertableNode(value) {
-    let node = this.getNode(this.root.id);
+    let node = this.getNode(this.rootId);
     while (!node.leaf) {
       for (let i = 0, len = node.values.length; i < len; i++) {
         const nValue = node.values[i];
@@ -1180,7 +1183,7 @@ var BPTreeSync = class extends BPTree {
    * This allows finding nodes by primary value only, ignoring unique identifiers.
    */
   insertableNodeByPrimary(value) {
-    let node = this.getNode(this.root.id);
+    let node = this.getNode(this.rootId);
     while (!node.leaf) {
       for (let i = 0, len = node.values.length; i < len; i++) {
         const nValue = node.values[i];
@@ -1200,7 +1203,7 @@ var BPTreeSync = class extends BPTree {
     return node;
   }
   insertableRightestNodeByPrimary(value) {
-    let node = this.getNode(this.root.id);
+    let node = this.getNode(this.rootId);
     while (!node.leaf) {
       for (let i = 0, len = node.values.length; i < len; i++) {
         const nValue = node.values[i];
@@ -1244,7 +1247,7 @@ var BPTreeSync = class extends BPTree {
     return this.getNode(guessNode);
   }
   leftestNode() {
-    let node = this.root;
+    let node = this.getNode(this.rootId);
     while (!node.leaf) {
       const keys = node.keys;
       node = this.getNode(keys[0]);
@@ -1252,7 +1255,7 @@ var BPTreeSync = class extends BPTree {
     return node;
   }
   rightestNode() {
-    let node = this.root;
+    let node = this.getNode(this.rootId);
     while (!node.leaf) {
       const keys = node.keys;
       node = this.getNode(keys[keys.length - 1]);
@@ -1265,6 +1268,9 @@ var BPTreeSync = class extends BPTree {
     }
     this._strategyDirty = false;
     this.strategy.writeHead(this.strategy.head);
+    if (this.strategy.head.root) {
+      this.nodes.delete(this.strategy.head.root);
+    }
   }
   commitNodeCreateBuffer() {
     for (const node of this._nodeCreateBuffer.values()) {
@@ -1275,12 +1281,14 @@ var BPTreeSync = class extends BPTree {
   commitNodeUpdateBuffer() {
     for (const node of this._nodeUpdateBuffer.values()) {
       this.strategy.write(node.id, node);
+      this.nodes.delete(node.id);
     }
     this._nodeUpdateBuffer.clear();
   }
   commitNodeDeleteBuffer() {
     for (const node of this._nodeDeleteBuffer.values()) {
       this.strategy.delete(node.id);
+      this.nodes.delete(node.id);
     }
     this._nodeDeleteBuffer.clear();
   }
@@ -1424,7 +1432,7 @@ var BPTreeSync = class extends BPTree {
           if (keys.length > 1) {
             keys.splice(keys.indexOf(key), 1);
             this.bufferForNodeUpdate(node);
-          } else if (node.id === this.root.id) {
+          } else if (node.id === this.rootId) {
             node.values.splice(i, 1);
             node.keys.splice(i, 1);
             this.bufferForNodeUpdate(node);
@@ -1858,16 +1866,18 @@ var BPTreeAsync = class extends BPTree {
         }
       }
     }
-    if (this.root.id === node.id && node.keys.length === 1) {
+    if (this.rootId === node.id && node.keys.length === 1) {
       const keys = node.keys;
-      this.bufferForNodeDelete(this.root);
-      this.root = await this.getNode(keys[0]);
-      this.root.parent = null;
-      this.strategy.head.root = this.root.id;
-      this.bufferForNodeUpdate(this.root);
+      this.bufferForNodeDelete(node);
+      const newRoot = await this.getNode(keys[0]);
+      this.rootId = newRoot.id;
+      newRoot.parent = null;
+      this.strategy.head.root = this.rootId;
+      this.bufferForNodeUpdate(newRoot);
       return;
-    } else if (this.root.id === node.id) {
-      this.bufferForNodeUpdate(this.root);
+    } else if (this.rootId === node.id) {
+      const root = await this.getNode(this.rootId);
+      this.bufferForNodeUpdate(root);
       return;
     } else if (node.keys.length < Math.ceil(this.order / 2) && !node.leaf || node.values.length < Math.ceil((this.order - 1) / 2) && node.leaf) {
       if (node.parent === null) {
@@ -2047,9 +2057,9 @@ var BPTreeAsync = class extends BPTree {
     }
   }
   async _insertInParent(node, value, pointer) {
-    if (this.root.id === node.id) {
+    if (this.rootId === node.id) {
       const root = await this._createNode(false, [node.id, pointer.id], [value]);
-      this.root = root;
+      this.rootId = root.id;
       this.strategy.head.root = root.id;
       node.parent = root.id;
       pointer.parent = root.id;
@@ -2118,15 +2128,16 @@ 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, [], [], true);
-      this.strategy.head.root = this.root.id;
+      const root = await this._createNode(true, [], [], true);
+      this.rootId = root.id;
+      this.strategy.head.root = this.rootId;
       await this.commitHeadBuffer();
       await this.commitNodeCreateBuffer();
     } else {
       const { root, order } = head;
       this.strategy.head = head;
       this.order = order;
-      this.root = await this.getNode(root);
+      this.rootId = root;
     }
     if (this.order < 3) {
       throw new Error(`The 'order' parameter must be greater than 2. but got a '${this.order}'.`);
@@ -2143,7 +2154,7 @@ var BPTreeAsync = class extends BPTree {
     return cache.raw;
   }
   async insertableNode(value) {
-    let node = await this.getNode(this.root.id);
+    let node = await this.getNode(this.rootId);
     while (!node.leaf) {
       for (let i = 0, len = node.values.length; i < len; i++) {
         const nValue = node.values[i];
@@ -2167,7 +2178,7 @@ var BPTreeAsync = class extends BPTree {
    * This allows finding nodes by primary value only, ignoring unique identifiers.
    */
   async insertableNodeByPrimary(value) {
-    let node = await this.getNode(this.root.id);
+    let node = await this.getNode(this.rootId);
     while (!node.leaf) {
       for (let i = 0, len = node.values.length; i < len; i++) {
         const nValue = node.values[i];
@@ -2187,7 +2198,7 @@ var BPTreeAsync = class extends BPTree {
     return node;
   }
   async insertableRightestNodeByPrimary(value) {
-    let node = await this.getNode(this.root.id);
+    let node = await this.getNode(this.rootId);
     while (!node.leaf) {
       for (let i = 0, len = node.values.length; i < len; i++) {
         const nValue = node.values[i];
@@ -2231,7 +2242,7 @@ var BPTreeAsync = class extends BPTree {
     return await this.getNode(guessNode);
   }
   async leftestNode() {
-    let node = this.root;
+    let node = await this.getNode(this.rootId);
     while (!node.leaf) {
       const keys = node.keys;
       node = await this.getNode(keys[0]);
@@ -2239,7 +2250,7 @@ var BPTreeAsync = class extends BPTree {
     return node;
   }
   async rightestNode() {
-    let node = this.root;
+    let node = await this.getNode(this.rootId);
     while (!node.leaf) {
       const keys = node.keys;
       node = await this.getNode(keys[keys.length - 1]);
@@ -2252,6 +2263,9 @@ var BPTreeAsync = class extends BPTree {
     }
     this._strategyDirty = false;
     await this.strategy.writeHead(this.strategy.head);
+    if (this.strategy.head.root) {
+      this.nodes.delete(this.strategy.head.root);
+    }
   }
   async commitNodeCreateBuffer() {
     for (const node of this._nodeCreateBuffer.values()) {
@@ -2262,12 +2276,14 @@ var BPTreeAsync = class extends BPTree {
   async commitNodeUpdateBuffer() {
     for (const node of this._nodeUpdateBuffer.values()) {
       await this.strategy.write(node.id, node);
+      this.nodes.delete(node.id);
     }
     this._nodeUpdateBuffer.clear();
   }
   async commitNodeDeleteBuffer() {
     for (const node of this._nodeDeleteBuffer.values()) {
       await this.strategy.delete(node.id);
+      this.nodes.delete(node.id);
     }
     this._nodeDeleteBuffer.clear();
   }
@@ -2420,7 +2436,7 @@ var BPTreeAsync = class extends BPTree {
             if (keys.length > 1) {
               keys.splice(keys.indexOf(key), 1);
               this.bufferForNodeUpdate(node);
-            } else if (node.id === this.root.id) {
+            } else if (node.id === this.rootId) {
               node.values.splice(i, 1);
               node.keys.splice(i, 1);
               this.bufferForNodeUpdate(node);

package/dist/esm/index.mjs

@@ -438,7 +438,7 @@ var BPTree = class _BPTree {
   comparator;
   option;
   order;
-  root;
+  rootId;
   _strategyDirty;
   _nodeCreateBuffer;
   _nodeUpdateBuffer;
@@ -467,13 +467,13 @@ var BPTree = class _BPTree {
     }
   };
   verifierStartNode = {
-    gt: (v) => this.insertableNode(v),
-    gte: (v) => this.insertableNode(v),
-    lt: (v) => this.insertableNode(v),
-    lte: (v) => this.insertableNode(v),
-    equal: (v) => this.insertableNode(v),
+    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.insertableNode(this.lowestValue(this.ensureValues(v))),
+    or: (v) => this.insertableNodeByPrimary(this.lowestPrimaryValue(this.ensureValues(v))),
     primaryGt: (v) => this.insertableNodeByPrimary(v),
     primaryGte: (v) => this.insertableNodeByPrimary(v),
     primaryLt: (v) => this.insertableNodeByPrimary(v),
@@ -498,7 +498,7 @@ var BPTree = class _BPTree {
     primaryGte: (v) => null,
     primaryLt: (v) => null,
     primaryLte: (v) => null,
-    primaryEqual: (v) => null,
+    primaryEqual: (v) => this.insertableRightestEndNodeByPrimary(v),
     primaryNotEqual: (v) => null,
     primaryOr: (v) => this.insertableRightestEndNodeByPrimary(
       this.highestPrimaryValue(this.ensureValues(v))
@@ -692,19 +692,19 @@ var BPTree = class _BPTree {
     }
   }
   bufferForNodeCreate(node) {
-    if (node.id === this.root.id) {
+    if (node.id === this.rootId) {
       this._strategyDirty = true;
     }
     this._nodeCreateBuffer.set(node.id, node);
   }
   bufferForNodeUpdate(node) {
-    if (node.id === this.root.id) {
+    if (node.id === this.rootId) {
       this._strategyDirty = true;
     }
     this._nodeUpdateBuffer.set(node.id, node);
   }
   bufferForNodeDelete(node) {
-    if (node.id === this.root.id) {
+    if (node.id === this.rootId) {
       this._strategyDirty = true;
     }
     this._nodeDeleteBuffer.set(node.id, node);
@@ -837,16 +837,18 @@ var BPTreeSync = class extends BPTree {
         }
       }
     }
-    if (this.root.id === node.id && node.keys.length === 1) {
+    if (this.rootId === node.id && node.keys.length === 1) {
       const keys = node.keys;
-      this.bufferForNodeDelete(this.root);
-      this.root = this.getNode(keys[0]);
-      this.root.parent = null;
-      this.strategy.head.root = this.root.id;
-      this.bufferForNodeUpdate(this.root);
+      this.bufferForNodeDelete(node);
+      const newRoot = this.getNode(keys[0]);
+      this.rootId = newRoot.id;
+      newRoot.parent = null;
+      this.strategy.head.root = this.rootId;
+      this.bufferForNodeUpdate(newRoot);
       return;
-    } else if (this.root.id === node.id) {
-      this.bufferForNodeUpdate(this.root);
+    } else if (this.rootId === node.id) {
+      const root = this.getNode(this.rootId);
+      this.bufferForNodeUpdate(root);
       return;
     } else if (node.keys.length < Math.ceil(this.order / 2) && !node.leaf || node.values.length < Math.ceil((this.order - 1) / 2) && node.leaf) {
       if (node.parent === null) {
@@ -1026,9 +1028,9 @@ var BPTreeSync = class extends BPTree {
     }
   }
   _insertInParent(node, value, pointer) {
-    if (this.root.id === node.id) {
+    if (this.rootId === node.id) {
       const root = this._createNode(false, [node.id, pointer.id], [value]);
-      this.root = root;
+      this.rootId = root.id;
       this.strategy.head.root = root.id;
       node.parent = root.id;
       pointer.parent = root.id;
@@ -1097,15 +1099,16 @@ var BPTreeSync = class extends BPTree {
     const head = this.strategy.readHead();
     if (head === null) {
       this.order = this.strategy.order;
-      this.root = this._createNode(true, [], [], true);
-      this.strategy.head.root = this.root.id;
+      const root = this._createNode(true, [], [], true);
+      this.rootId = root.id;
+      this.strategy.head.root = this.rootId;
       this.commitHeadBuffer();
       this.commitNodeCreateBuffer();
     } else {
       const { root, order } = head;
       this.strategy.head = head;
       this.order = order;
-      this.root = this.getNode(root);
+      this.rootId = root;
     }
     if (this.order < 3) {
       throw new Error(`The 'order' parameter must be greater than 2. but got a '${this.order}'.`);
@@ -1122,7 +1125,7 @@ var BPTreeSync = class extends BPTree {
     return cache.raw;
   }
   insertableNode(value) {
-    let node = this.getNode(this.root.id);
+    let node = this.getNode(this.rootId);
     while (!node.leaf) {
       for (let i = 0, len = node.values.length; i < len; i++) {
         const nValue = node.values[i];
@@ -1146,7 +1149,7 @@ var BPTreeSync = class extends BPTree {
    * This allows finding nodes by primary value only, ignoring unique identifiers.
    */
   insertableNodeByPrimary(value) {
-    let node = this.getNode(this.root.id);
+    let node = this.getNode(this.rootId);
     while (!node.leaf) {
       for (let i = 0, len = node.values.length; i < len; i++) {
         const nValue = node.values[i];
@@ -1166,7 +1169,7 @@ var BPTreeSync = class extends BPTree {
     return node;
   }
   insertableRightestNodeByPrimary(value) {
-    let node = this.getNode(this.root.id);
+    let node = this.getNode(this.rootId);
     while (!node.leaf) {
       for (let i = 0, len = node.values.length; i < len; i++) {
         const nValue = node.values[i];
@@ -1210,7 +1213,7 @@ var BPTreeSync = class extends BPTree {
     return this.getNode(guessNode);
   }
   leftestNode() {
-    let node = this.root;
+    let node = this.getNode(this.rootId);
     while (!node.leaf) {
       const keys = node.keys;
       node = this.getNode(keys[0]);
@@ -1218,7 +1221,7 @@ var BPTreeSync = class extends BPTree {
     return node;
   }
   rightestNode() {
-    let node = this.root;
+    let node = this.getNode(this.rootId);
     while (!node.leaf) {
       const keys = node.keys;
       node = this.getNode(keys[keys.length - 1]);
@@ -1231,6 +1234,9 @@ var BPTreeSync = class extends BPTree {
     }
     this._strategyDirty = false;
     this.strategy.writeHead(this.strategy.head);
+    if (this.strategy.head.root) {
+      this.nodes.delete(this.strategy.head.root);
+    }
   }
   commitNodeCreateBuffer() {
     for (const node of this._nodeCreateBuffer.values()) {
@@ -1241,12 +1247,14 @@ var BPTreeSync = class extends BPTree {
   commitNodeUpdateBuffer() {
     for (const node of this._nodeUpdateBuffer.values()) {
       this.strategy.write(node.id, node);
+      this.nodes.delete(node.id);
     }
     this._nodeUpdateBuffer.clear();
   }
   commitNodeDeleteBuffer() {
     for (const node of this._nodeDeleteBuffer.values()) {
       this.strategy.delete(node.id);
+      this.nodes.delete(node.id);
     }
     this._nodeDeleteBuffer.clear();
   }
@@ -1390,7 +1398,7 @@ var BPTreeSync = class extends BPTree {
           if (keys.length > 1) {
             keys.splice(keys.indexOf(key), 1);
             this.bufferForNodeUpdate(node);
-          } else if (node.id === this.root.id) {
+          } else if (node.id === this.rootId) {
             node.values.splice(i, 1);
             node.keys.splice(i, 1);
             this.bufferForNodeUpdate(node);
@@ -1824,16 +1832,18 @@ var BPTreeAsync = class extends BPTree {
         }
       }
     }
-    if (this.root.id === node.id && node.keys.length === 1) {
+    if (this.rootId === node.id && node.keys.length === 1) {
       const keys = node.keys;
-      this.bufferForNodeDelete(this.root);
-      this.root = await this.getNode(keys[0]);
-      this.root.parent = null;
-      this.strategy.head.root = this.root.id;
-      this.bufferForNodeUpdate(this.root);
+      this.bufferForNodeDelete(node);
+      const newRoot = await this.getNode(keys[0]);
+      this.rootId = newRoot.id;
+      newRoot.parent = null;
+      this.strategy.head.root = this.rootId;
+      this.bufferForNodeUpdate(newRoot);
       return;
-    } else if (this.root.id === node.id) {
-      this.bufferForNodeUpdate(this.root);
+    } else if (this.rootId === node.id) {
+      const root = await this.getNode(this.rootId);
+      this.bufferForNodeUpdate(root);
       return;
     } else if (node.keys.length < Math.ceil(this.order / 2) && !node.leaf || node.values.length < Math.ceil((this.order - 1) / 2) && node.leaf) {
       if (node.parent === null) {
@@ -2013,9 +2023,9 @@ var BPTreeAsync = class extends BPTree {
     }
   }
   async _insertInParent(node, value, pointer) {
-    if (this.root.id === node.id) {
+    if (this.rootId === node.id) {
       const root = await this._createNode(false, [node.id, pointer.id], [value]);
-      this.root = root;
+      this.rootId = root.id;
       this.strategy.head.root = root.id;
       node.parent = root.id;
       pointer.parent = root.id;
@@ -2084,15 +2094,16 @@ 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, [], [], true);
-      this.strategy.head.root = this.root.id;
+      const root = await this._createNode(true, [], [], true);
+      this.rootId = root.id;
+      this.strategy.head.root = this.rootId;
       await this.commitHeadBuffer();
       await this.commitNodeCreateBuffer();
     } else {
       const { root, order } = head;
       this.strategy.head = head;
       this.order = order;
-      this.root = await this.getNode(root);
+      this.rootId = root;
     }
     if (this.order < 3) {
       throw new Error(`The 'order' parameter must be greater than 2. but got a '${this.order}'.`);
@@ -2109,7 +2120,7 @@ var BPTreeAsync = class extends BPTree {
     return cache.raw;
   }
   async insertableNode(value) {
-    let node = await this.getNode(this.root.id);
+    let node = await this.getNode(this.rootId);
     while (!node.leaf) {
       for (let i = 0, len = node.values.length; i < len; i++) {
         const nValue = node.values[i];
@@ -2133,7 +2144,7 @@ var BPTreeAsync = class extends BPTree {
    * This allows finding nodes by primary value only, ignoring unique identifiers.
    */
   async insertableNodeByPrimary(value) {
-    let node = await this.getNode(this.root.id);
+    let node = await this.getNode(this.rootId);
     while (!node.leaf) {
       for (let i = 0, len = node.values.length; i < len; i++) {
         const nValue = node.values[i];
@@ -2153,7 +2164,7 @@ var BPTreeAsync = class extends BPTree {
     return node;
   }
   async insertableRightestNodeByPrimary(value) {
-    let node = await this.getNode(this.root.id);
+    let node = await this.getNode(this.rootId);
     while (!node.leaf) {
       for (let i = 0, len = node.values.length; i < len; i++) {
         const nValue = node.values[i];
@@ -2197,7 +2208,7 @@ var BPTreeAsync = class extends BPTree {
     return await this.getNode(guessNode);
   }
   async leftestNode() {
-    let node = this.root;
+    let node = await this.getNode(this.rootId);
     while (!node.leaf) {
       const keys = node.keys;
       node = await this.getNode(keys[0]);
@@ -2205,7 +2216,7 @@ var BPTreeAsync = class extends BPTree {
     return node;
   }
   async rightestNode() {
-    let node = this.root;
+    let node = await this.getNode(this.rootId);
     while (!node.leaf) {
       const keys = node.keys;
       node = await this.getNode(keys[keys.length - 1]);
@@ -2218,6 +2229,9 @@ var BPTreeAsync = class extends BPTree {
     }
     this._strategyDirty = false;
     await this.strategy.writeHead(this.strategy.head);
+    if (this.strategy.head.root) {
+      this.nodes.delete(this.strategy.head.root);
+    }
   }
   async commitNodeCreateBuffer() {
     for (const node of this._nodeCreateBuffer.values()) {
@@ -2228,12 +2242,14 @@ var BPTreeAsync = class extends BPTree {
   async commitNodeUpdateBuffer() {
     for (const node of this._nodeUpdateBuffer.values()) {
       await this.strategy.write(node.id, node);
+      this.nodes.delete(node.id);
     }
     this._nodeUpdateBuffer.clear();
   }
   async commitNodeDeleteBuffer() {
     for (const node of this._nodeDeleteBuffer.values()) {
       await this.strategy.delete(node.id);
+      this.nodes.delete(node.id);
     }
     this._nodeDeleteBuffer.clear();
   }
@@ -2386,7 +2402,7 @@ var BPTreeAsync = class extends BPTree {
             if (keys.length > 1) {
               keys.splice(keys.indexOf(key), 1);
               this.bufferForNodeUpdate(node);
-            } else if (node.id === this.root.id) {
+            } else if (node.id === this.rootId) {
               node.values.splice(i, 1);
               node.keys.splice(i, 1);
               this.bufferForNodeUpdate(node);

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

@@ -80,7 +80,7 @@ export declare abstract class BPTree<K, V> {
     protected readonly comparator: ValueComparator<V>;
     protected readonly option: BPTreeConstructorOption;
     protected order: number;
-    protected root: BPTreeUnknownNode<K, V>;
+    protected rootId: string;
     protected _strategyDirty: boolean;
     protected readonly _nodeCreateBuffer: Map<string, BPTreeUnknownNode<K, V>>;
     protected readonly _nodeUpdateBuffer: Map<string, BPTreeUnknownNode<K, V>>;

package/package.json

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