serializable-bptree 3.3.1 → 3.4.0-alpha.0

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 `{}`.
@@ -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;
@@ -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;
@@ -1046,6 +1059,7 @@ var BPTreeSync = class extends BPTree {
     this.commitHeadBuffer();
     this.commitNodeCreateBuffer();
     this.commitNodeUpdateBuffer();
+    this.commitNodeDeleteBuffer();
   }
   exists(key, value) {
     const node = this.insertableNode(value);
@@ -1186,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;
@@ -1269,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;
@@ -1480,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;
@@ -1588,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);
@@ -1666,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;
@@ -1714,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 `{}`.
@@ -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;
@@ -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;
@@ -1012,6 +1025,7 @@ var BPTreeSync = class extends BPTree {
     this.commitHeadBuffer();
     this.commitNodeCreateBuffer();
     this.commitNodeUpdateBuffer();
+    this.commitNodeDeleteBuffer();
   }
   exists(key, value) {
     const node = this.insertableNode(value);
@@ -1152,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;
@@ -1235,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;
@@ -1446,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;
@@ -1554,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);
@@ -1632,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;
@@ -1680,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

@@ -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

@@ -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

@@ -5,6 +5,7 @@ export declare abstract class SerializeStrategyAsync<K, V> extends SerializeStra
     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>;
@@ -17,6 +18,7 @@ export declare class InMemoryStoreStrategyAsync<K, V> extends SerializeStrategyA
     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

@@ -5,6 +5,7 @@ export declare abstract class SerializeStrategySync<K, V> extends SerializeStrat
     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;
@@ -17,6 +18,7 @@ export declare class InMemoryStoreStrategySync<K, V> extends SerializeStrategySy
     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>;
@@ -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

@@ -31,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.1",
+  "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",