serializable-bptree 3.4.0-alpha.0 → 4.0.0

package/README.md

@@ -6,7 +6,7 @@
 This is a B+tree that's totally okay with duplicate values. If you need to keep track of the B+ tree's state, don't just leave it in memory - make sure you write it down.
 
 ```typescript
-import { readFileSync, writeFileSync, existsSync } from 'fs'
+import { readFileSync, writeFileSync, unlinkSync, existsSync } from 'fs'
 import {
   BPTreeSync,
   SerializeStrategySync,
@@ -14,18 +14,22 @@ import {
 } from 'serializable-bptree'
 
 class FileStoreStrategySync extends SerializeStrategySync<K, V> {
-  id(): number {
-    return this.autoIncrement('index', 1)
+  id(): string {
+    return this.autoIncrement('index', 1).toString()
   }
 
-  read(id: number): BPTreeNode<K, V> {
-    const raw = readFileSync(id.toString(), 'utf8')
+  read(id: string): BPTreeNode<K, V> {
+    const raw = readFileSync(id, 'utf8')
     return JSON.parse(raw)
   }
 
-  write(id: number, node: BPTreeNode<K, V>): void {
+  write(id: string, node: BPTreeNode<K, V>): void {
     const stringify = JSON.stringify(node)
-    writeFileSync(id.toString(), stringify, 'utf8')
+    writeFileSync(id, stringify, 'utf8')
+  }
+
+  delete(id: string): void {
+    unlinkSync(id)
   }
 
   readHead(): SerializeStrategyHead|null {
@@ -98,7 +102,7 @@ import {
     ValueComparator,
     NumericComparator,
     StringComparator
-  } from 'https://cdn.jsdelivr.net/npm/serializable-bptree@3.x.x/dist/esm/index.min.js'
+  } from 'https://cdn.jsdelivr.net/npm/serializable-bptree@4.x.x/dist/esm/index.min.js'
 </script>
 ```
 
@@ -177,9 +181,10 @@ You need to construct a logic for input/output from the file by inheriting the S
 import { SerializeStrategySync } from 'serializable-bptree'
 
 class MyFileIOStrategySync extends SerializeStrategySync {
-  id(): number
-  read(id: number): BPTreeNode<K, V>
-  write(id: number, node: BPTreeNode<K, V>): void
+  id(): string
+  read(id: string): BPTreeNode<K, V>
+  write(id: string, node: BPTreeNode<K, V>): void
+  delete(id: string): void
   readHead(): SerializeStrategyHead|null
   writeHead(head: SerializeStrategyHead): void
 }
@@ -187,49 +192,39 @@ class MyFileIOStrategySync extends SerializeStrategySync {
 
 What does this method mean? And why do we need to construct such a method?
 
-#### 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(isLeaf: boolean): number {
-  const current = before + 1
-  before = current
-  return current
-}
-```
+#### id(isLeaf: `boolean`): `string`
 
-Or, you could use file input/output to save and load the value of the **before** variable.
+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.
 
 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(isLeaf: boolean): number {
+id(isLeaf: boolean): string {
   const current = this.getHeadData('index', 1) as number
   this.setHeadData('index', current+1)
-  return current
+  return current.toString()
 }
 ```
 
-Additionally, there is a more user-friendly usage of this code.
+Additionally, there is a more dev-friendly usage of this code.
 
 ```typescript
-id(isLeaf: boolean): number {
-  return this.autoIncrement('index', 1)
+id(isLeaf: boolean): string {
+  return this.autoIncrement('index', 1).toString()
 }
 ```
 
 The **id** method is called before a node is created in the tree. Therefore, it can also be used to allocate space for storing the node.
 
-#### read(id: `number`): `BPTreeNode<K, V>`
+#### read(id: `string`): `BPTreeNode<K, V>`
 
 This is a method to load the saved value as a tree instance. If you have previously saved the node as a file, you should use this method to convert it back to JavaScript JSON format and return it.
 
 Please refer to the example below:
 
 ```typescript
-read(id: number): BPTreeNode<K, V> {
-  const filePath = `./my-store/${id.toString()}`
+read(id: string): BPTreeNode<K, V> {
+  const filePath = `./my-store/${id}`
   const raw = fs.readFileSync(filePath, 'utf8')
   return JSON.parse(raw)
 }
@@ -237,7 +232,7 @@ read(id: number): BPTreeNode<K, V> {
 
 This method is called only once when loading a node from a tree instance. The loaded node is loaded into memory, and subsequently, when the tree references the node, it operates based on the values in memory **without** re-invoking this method.
 
-#### write(id: `number`, node: `BPTreeNode<K, V>`): `void`
+#### write(id: `string`, node: `BPTreeNode<K, V>`): `void`
 
 This method is called when there are changes in the internal nodes due to the insert or delete operations of the tree instance. In other words, it's a necessary method for synchronizing the in-memory nodes into a file.
 
@@ -247,17 +242,17 @@ Please refer to the example below:
 
 ```typescript
 let queue = 0
-function writeBack(id: number, node: BPTreeNode<K, V>, timer: number) {
+function writeBack(id: string, node: BPTreeNode<K, V>, timer: number) {
   clearTimeout(queue)
   queue = setTimeout(() => {
-    const filePath = `./my-store/${id.toString()}`
+    const filePath = `./my-store/${id}`
     const stringify = JSON.stringify(node)
     writeFileSync(filePath, stringify, 'utf8')
   }, timer)
 }
 
 ...
-write(id: number, node: BPTreeNode<K, V>): void {
+write(id: string, node: BPTreeNode<K, V>): void {
   const writeBackInterval = 10
   writeBack(id, node, writeBackInterval)
 }
@@ -265,6 +260,17 @@ write(id: number, node: BPTreeNode<K, V>): void {
 
 This kind of delay writing should ideally occur within a few milliseconds. If this is not feasible, consider other approaches.
 
+#### delete(id: `string`): `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.
+
+```typescript
+delete(id: string): void {
+  const filePath = `./my-store/${id}`
+  fs.unlinkSync(filePath)
+}
+```
+
 #### readHead(): `SerializeStrategyHead`|`null`
 
 This method is called only once when the tree is created. It's a method to restore the saved tree information. If it is the initial creation and there is no stored root node, it should return **null**.
@@ -357,7 +363,7 @@ Support for asynchronous trees has been available since version 3.0.0. Asynchron
 
 ```typescript
 import { existsSync } from 'fs'
-import { readFile, writeFile } from 'fs/promises'
+import { readFile, writeFile, unlink } from 'fs/promises'
 import {
   BPTreeAsync,
   SerializeStrategyAsync,
@@ -366,18 +372,22 @@ import {
 } from 'serializable-bptree'
 
 class FileStoreStrategyAsync extends SerializeStrategyAsync<K, V> {
-  async id(isLeaf: boolean): Promise<number> {
-    return await this.autoIncrement('index', 1)
+  async id(isLeaf: boolean): Promise<string> {
+    return await this.autoIncrement('index', 1).toString()
   }
 
-  async read(id: number): Promise<BPTreeNode<K, V>> {
-    const raw = await readFile(id.toString(), 'utf8')
+  async read(id: string): Promise<BPTreeNode<K, V>> {
+    const raw = await readFile(id, 'utf8')
     return JSON.parse(raw)
   }
 
-  async write(id: number, node: BPTreeNode<K, V>): Promise<void> {
+  async write(id: string, node: BPTreeNode<K, V>): Promise<void> {
     const stringify = JSON.stringify(node)
-    await writeFile(id.toString(), stringify, 'utf8')
+    await writeFile(id, stringify, 'utf8')
+  }
+
+  async delete(id: string): Promise<void> {
+    await unlink(id)
   }
 
   async readHead(): Promise<SerializeStrategyHead|null> {

package/dist/cjs/index.cjs

@@ -609,12 +609,12 @@ var BPTreeSync = class extends BPTree {
   }
   _createNodeId(isLeaf) {
     const id = this.strategy.id(isLeaf);
-    if (id === 0) {
-      throw new Error(`The node's id should never be 0.`);
+    if (id === null) {
+      throw new Error(`The node's id should never be null.`);
     }
     return id;
   }
-  _createNode(isLeaf, keys2, values, leaf = false, parent = 0, next = 0, prev = 0) {
+  _createNode(isLeaf, keys2, values, leaf = false, parent = null, next = null, prev = null) {
     const id = this._createNodeId(isLeaf);
     const node = {
       id,
@@ -651,7 +651,7 @@ var BPTreeSync = class extends BPTree {
       const keys2 = node.keys;
       this.bufferForNodeDelete(this.root);
       this.root = this.getNode(keys2[0]);
-      this.root.parent = 0;
+      this.root.parent = null;
       this.strategy.head.root = this.root.id;
       this.bufferForNodeUpdate(this.root);
       return;
@@ -719,7 +719,7 @@ var BPTreeSync = class extends BPTree {
             this.bufferForNodeUpdate(n);
           }
           if (isPredecessor) {
-            pointer.prev = 0;
+            pointer.prev = null;
           }
         }
         pointer.values.push(...node.values);
@@ -1160,12 +1160,12 @@ var BPTreeAsync = class extends BPTree {
   }
   async _createNodeId(isLeaf) {
     const id = await this.strategy.id(isLeaf);
-    if (id === 0) {
-      throw new Error(`The node's id should never be 0.`);
+    if (id === null) {
+      throw new Error(`The node's id should never be null.`);
     }
     return id;
   }
-  async _createNode(isLeaf, keys2, values, leaf = false, parent = 0, next = 0, prev = 0) {
+  async _createNode(isLeaf, keys2, values, leaf = false, parent = null, next = null, prev = null) {
     const id = await this._createNodeId(isLeaf);
     const node = {
       id,
@@ -1202,7 +1202,7 @@ var BPTreeAsync = class extends BPTree {
       const keys2 = node.keys;
       this.bufferForNodeDelete(this.root);
       this.root = await this.getNode(keys2[0]);
-      this.root.parent = 0;
+      this.root.parent = null;
       this.strategy.head.root = this.root.id;
       this.bufferForNodeUpdate(this.root);
       return;
@@ -1270,7 +1270,7 @@ var BPTreeAsync = class extends BPTree {
             this.bufferForNodeUpdate(n);
           }
           if (isPredecessor) {
-            pointer.prev = 0;
+            pointer.prev = null;
           }
         }
         pointer.values.push(...node.values);
@@ -1646,7 +1646,7 @@ var SerializeStrategy = class {
     this.order = order;
     this.head = {
       order,
-      root: 0,
+      root: null,
       data: {}
     };
   }
@@ -1656,7 +1656,7 @@ var SerializeStrategy = class {
 var SerializeStrategySync = class extends SerializeStrategy {
   getHeadData(key, defaultValue) {
     if (!Object.hasOwn(this.head.data, key)) {
-      return defaultValue;
+      this.setHeadData(key, defaultValue);
     }
     return this.head.data[key];
   }
@@ -1678,7 +1678,7 @@ var InMemoryStoreStrategySync = class extends SerializeStrategySync {
     this.node = {};
   }
   id(isLeaf) {
-    return this.autoIncrement("index", 1);
+    return this.autoIncrement("index", 1).toString();
   }
   read(id) {
     if (!Object.hasOwn(this.node, id)) {
@@ -1693,7 +1693,7 @@ var InMemoryStoreStrategySync = class extends SerializeStrategySync {
     delete this.node[id];
   }
   readHead() {
-    if (this.head.root === 0) {
+    if (this.head.root === null) {
       return null;
     }
     return this.head;
@@ -1707,7 +1707,7 @@ var InMemoryStoreStrategySync = class extends SerializeStrategySync {
 var SerializeStrategyAsync = class extends SerializeStrategy {
   async getHeadData(key, defaultValue) {
     if (!Object.hasOwn(this.head.data, key)) {
-      return defaultValue;
+      await this.setHeadData(key, defaultValue);
     }
     return this.head.data[key];
   }
@@ -1729,7 +1729,7 @@ var InMemoryStoreStrategyAsync = class extends SerializeStrategyAsync {
     this.node = {};
   }
   async id(isLeaf) {
-    return await this.autoIncrement("index", 1);
+    return (await this.autoIncrement("index", 1)).toString();
   }
   async read(id) {
     if (!Object.hasOwn(this.node, id)) {
@@ -1744,7 +1744,7 @@ var InMemoryStoreStrategyAsync = class extends SerializeStrategyAsync {
     delete this.node[id];
   }
   async readHead() {
-    if (this.head.root === 0) {
+    if (this.head.root === null) {
       return null;
     }
     return this.head;

package/dist/esm/index.mjs

@@ -575,12 +575,12 @@ var BPTreeSync = class extends BPTree {
   }
   _createNodeId(isLeaf) {
     const id = this.strategy.id(isLeaf);
-    if (id === 0) {
-      throw new Error(`The node's id should never be 0.`);
+    if (id === null) {
+      throw new Error(`The node's id should never be null.`);
     }
     return id;
   }
-  _createNode(isLeaf, keys2, values, leaf = false, parent = 0, next = 0, prev = 0) {
+  _createNode(isLeaf, keys2, values, leaf = false, parent = null, next = null, prev = null) {
     const id = this._createNodeId(isLeaf);
     const node = {
       id,
@@ -617,7 +617,7 @@ var BPTreeSync = class extends BPTree {
       const keys2 = node.keys;
       this.bufferForNodeDelete(this.root);
       this.root = this.getNode(keys2[0]);
-      this.root.parent = 0;
+      this.root.parent = null;
       this.strategy.head.root = this.root.id;
       this.bufferForNodeUpdate(this.root);
       return;
@@ -685,7 +685,7 @@ var BPTreeSync = class extends BPTree {
             this.bufferForNodeUpdate(n);
           }
           if (isPredecessor) {
-            pointer.prev = 0;
+            pointer.prev = null;
           }
         }
         pointer.values.push(...node.values);
@@ -1126,12 +1126,12 @@ var BPTreeAsync = class extends BPTree {
   }
   async _createNodeId(isLeaf) {
     const id = await this.strategy.id(isLeaf);
-    if (id === 0) {
-      throw new Error(`The node's id should never be 0.`);
+    if (id === null) {
+      throw new Error(`The node's id should never be null.`);
     }
     return id;
   }
-  async _createNode(isLeaf, keys2, values, leaf = false, parent = 0, next = 0, prev = 0) {
+  async _createNode(isLeaf, keys2, values, leaf = false, parent = null, next = null, prev = null) {
     const id = await this._createNodeId(isLeaf);
     const node = {
       id,
@@ -1168,7 +1168,7 @@ var BPTreeAsync = class extends BPTree {
       const keys2 = node.keys;
       this.bufferForNodeDelete(this.root);
       this.root = await this.getNode(keys2[0]);
-      this.root.parent = 0;
+      this.root.parent = null;
       this.strategy.head.root = this.root.id;
       this.bufferForNodeUpdate(this.root);
       return;
@@ -1236,7 +1236,7 @@ var BPTreeAsync = class extends BPTree {
             this.bufferForNodeUpdate(n);
           }
           if (isPredecessor) {
-            pointer.prev = 0;
+            pointer.prev = null;
           }
         }
         pointer.values.push(...node.values);
@@ -1612,7 +1612,7 @@ var SerializeStrategy = class {
     this.order = order;
     this.head = {
       order,
-      root: 0,
+      root: null,
       data: {}
     };
   }
@@ -1622,7 +1622,7 @@ var SerializeStrategy = class {
 var SerializeStrategySync = class extends SerializeStrategy {
   getHeadData(key, defaultValue) {
     if (!Object.hasOwn(this.head.data, key)) {
-      return defaultValue;
+      this.setHeadData(key, defaultValue);
     }
     return this.head.data[key];
   }
@@ -1644,7 +1644,7 @@ var InMemoryStoreStrategySync = class extends SerializeStrategySync {
     this.node = {};
   }
   id(isLeaf) {
-    return this.autoIncrement("index", 1);
+    return this.autoIncrement("index", 1).toString();
   }
   read(id) {
     if (!Object.hasOwn(this.node, id)) {
@@ -1659,7 +1659,7 @@ var InMemoryStoreStrategySync = class extends SerializeStrategySync {
     delete this.node[id];
   }
   readHead() {
-    if (this.head.root === 0) {
+    if (this.head.root === null) {
       return null;
     }
     return this.head;
@@ -1673,7 +1673,7 @@ var InMemoryStoreStrategySync = class extends SerializeStrategySync {
 var SerializeStrategyAsync = class extends SerializeStrategy {
   async getHeadData(key, defaultValue) {
     if (!Object.hasOwn(this.head.data, key)) {
-      return defaultValue;
+      await this.setHeadData(key, defaultValue);
     }
     return this.head.data[key];
   }
@@ -1695,7 +1695,7 @@ var InMemoryStoreStrategyAsync = class extends SerializeStrategyAsync {
     this.node = {};
   }
   async id(isLeaf) {
-    return await this.autoIncrement("index", 1);
+    return (await this.autoIncrement("index", 1)).toString();
   }
   async read(id) {
     if (!Object.hasOwn(this.node, id)) {
@@ -1710,7 +1710,7 @@ var InMemoryStoreStrategyAsync = class extends SerializeStrategyAsync {
     delete this.node[id];
   }
   async readHead() {
-    if (this.head.root === 0) {
+    if (this.head.root === null) {
       return null;
     }
     return this.head;

package/dist/typings/BPTreeAsync.d.ts

@@ -8,12 +8,12 @@ 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(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 _createNodeId(isLeaf: boolean): Promise<string>;
+    protected _createNode(isLeaf: boolean, keys: string[] | K[][], values: V[], leaf?: boolean, parent?: string | null, next?: string | null, prev?: string | null): 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>;
-    protected getNode(id: number): Promise<BPTreeUnknownNode<K, V>>;
+    protected getNode(id: string): Promise<BPTreeUnknownNode<K, V>>;
     protected insertableNode(value: V): Promise<BPTreeLeafNode<K, V>>;
     protected leftestNode(): Promise<BPTreeLeafNode<K, V>>;
     protected commitHeadBuffer(): Promise<void>;

package/dist/typings/BPTreeSync.d.ts

@@ -8,12 +8,12 @@ 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(isLeaf: boolean): number;
-    protected _createNode(isLeaf: boolean, keys: number[] | K[][], values: V[], leaf?: boolean, parent?: number, next?: number, prev?: number): BPTreeUnknownNode<K, V>;
+    protected _createNodeId(isLeaf: boolean): string;
+    protected _createNode(isLeaf: boolean, keys: string[] | K[][], values: V[], leaf?: boolean, parent?: string | null, next?: string | null, prev?: string | null): 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;
-    protected getNode(id: number): BPTreeUnknownNode<K, V>;
+    protected getNode(id: string): BPTreeUnknownNode<K, V>;
     protected insertableNode(value: V): BPTreeLeafNode<K, V>;
     protected leftestNode(): BPTreeLeafNode<K, V>;
     protected commitHeadBuffer(): void;

package/dist/typings/SerializeStrategyAsync.d.ts

@@ -2,10 +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(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 id(isLeaf: boolean): Promise<string>;
+    abstract read(id: string): Promise<BPTreeNode<K, V>>;
+    abstract write(id: string, node: BPTreeNode<K, V>): Promise<void>;
+    abstract delete(id: string): Promise<void>;
     abstract readHead(): Promise<SerializeStrategyHead | null>;
     abstract writeHead(head: SerializeStrategyHead): Promise<void>;
     getHeadData(key: string, defaultValue: Json): Promise<Json>;
@@ -13,12 +13,12 @@ export declare abstract class SerializeStrategyAsync<K, V> extends SerializeStra
     autoIncrement(key: string, defaultValue: number): Promise<number>;
 }
 export declare class InMemoryStoreStrategyAsync<K, V> extends SerializeStrategyAsync<K, V> {
-    protected readonly node: Record<number, BPTreeNode<K, V>>;
+    protected readonly node: Record<string, BPTreeNode<K, V>>;
     constructor(order: 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>;
+    id(isLeaf: boolean): Promise<string>;
+    read(id: string): Promise<BPTreeNode<K, V>>;
+    write(id: string, node: BPTreeNode<K, V>): Promise<void>;
+    delete(id: string): Promise<void>;
     readHead(): Promise<SerializeStrategyHead | null>;
     writeHead(head: SerializeStrategyHead): Promise<void>;
 }

package/dist/typings/SerializeStrategySync.d.ts

@@ -2,10 +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(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 id(isLeaf: boolean): string;
+    abstract read(id: string): BPTreeNode<K, V>;
+    abstract write(id: string, node: BPTreeNode<K, V>): void;
+    abstract delete(id: string): void;
     abstract readHead(): SerializeStrategyHead | null;
     abstract writeHead(head: SerializeStrategyHead): void;
     getHeadData(key: string, defaultValue: Json): Json;
@@ -13,12 +13,12 @@ export declare abstract class SerializeStrategySync<K, V> extends SerializeStrat
     autoIncrement(key: string, defaultValue: number): number;
 }
 export declare class InMemoryStoreStrategySync<K, V> extends SerializeStrategySync<K, V> {
-    protected readonly node: Record<number, BPTreeNode<K, V>>;
+    protected readonly node: Record<string, BPTreeNode<K, V>>;
     constructor(order: number);
-    id(isLeaf: boolean): number;
-    read(id: number): BPTreeNode<K, V>;
-    write(id: number, node: BPTreeNode<K, V>): void;
-    delete(id: number): void;
+    id(isLeaf: boolean): string;
+    read(id: string): BPTreeNode<K, V>;
+    write(id: string, node: BPTreeNode<K, V>): void;
+    delete(id: string): void;
     readHead(): SerializeStrategyHead | null;
     writeHead(head: SerializeStrategyHead): void;
 }

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

@@ -3,7 +3,7 @@ import { SerializableData, SerializeStrategy } from './SerializeStrategy';
 type Sync<T> = T;
 type Async<T> = Promise<T>;
 type Deferred<T> = Sync<T> | Async<T>;
-export type BPTreeNodeKey<K> = number | K;
+export type BPTreeNodeKey<K> = string | K;
 export type BPTreeCondition<V> = Partial<{
     /** Searches for pairs greater than the given value. */
     gt: Partial<V>;
@@ -26,17 +26,17 @@ export type BPTreePair<K, V> = {
 };
 export type BPTreeUnknownNode<K, V> = BPTreeInternalNode<K, V> | BPTreeLeafNode<K, V>;
 export interface BPTreeNode<K, V> {
-    id: number;
-    keys: number[] | K[][];
+    id: string;
+    keys: string[] | K[][];
     values: V[];
     leaf: boolean;
-    parent: number;
-    next: number;
-    prev: number;
+    parent: string | null;
+    next: string | null;
+    prev: string | null;
 }
 export interface BPTreeInternalNode<K, V> extends BPTreeNode<K, V> {
     leaf: false;
-    keys: number[];
+    keys: string[];
 }
 export interface BPTreeLeafNode<K, V> extends BPTreeNode<K, V> {
     leaf: true;
@@ -46,12 +46,12 @@ export declare abstract class BPTree<K, V> {
     private readonly _cachedRegexp;
     protected readonly strategy: SerializeStrategy<K, V>;
     protected readonly comparator: ValueComparator<V>;
-    protected readonly nodes: Map<number, BPTreeUnknownNode<K, V>>;
+    protected readonly nodes: Map<string, BPTreeUnknownNode<K, V>>;
     protected order: number;
     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 _nodeCreateBuffer: Map<string, BPTreeUnknownNode<K, V>>;
+    protected readonly _nodeUpdateBuffer: Map<string, BPTreeUnknownNode<K, V>>;
+    protected readonly _nodeDeleteBuffer: Map<string, 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>;
@@ -60,11 +60,11 @@ 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(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 _createNodeId(isLeaf: boolean): Deferred<string>;
+    protected abstract _createNode(isLeaf: boolean, keys: string[] | K[][], values: V[], leaf?: boolean, parent?: string | null, next?: string | null, prev?: string | null): 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>>;
+    protected abstract getNode(id: string): Deferred<BPTreeUnknownNode<K, V>>;
     protected abstract insertableNode(value: V): Deferred<BPTreeLeafNode<K, V>>;
     protected abstract leftestNode(): Deferred<BPTreeLeafNode<K, V>>;
     protected abstract commitHeadBuffer(): Deferred<void>;

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

@@ -2,7 +2,7 @@ import { BPTreeNode } from './BPTree';
 import type { Json } from '../utils/types';
 export type SerializableData = Record<string, Json>;
 export interface SerializeStrategyHead {
-    root: number;
+    root: string | null;
     order: number;
     data: SerializableData;
 }
@@ -14,29 +14,29 @@ export declare abstract class SerializeStrategy<K, V> {
      * The rule for generating node IDs is set.
      * 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`.
+     * **WARNING!** The return value should never be `null`.
      * @param isLeaf This is a flag that indicates whether the node is a leaf node or not.
      */
-    abstract id(isLeaf: boolean): number | Promise<number>;
+    abstract id(isLeaf: boolean): string | Promise<string>;
     /**
      * Read the stored node from the ID.
      * The JSON object of the read node should be returned.
      * @param id This is the ID of the node to be read.
      */
-    abstract read(id: number): BPTreeNode<K, V> | Promise<BPTreeNode<K, V>>;
+    abstract read(id: string): BPTreeNode<K, V> | Promise<BPTreeNode<K, V>>;
     /**
      * It is called when a node is created or updated and needs to be stored.
      * The node ID and the node JSON object are passed as parameters. Use this to store the data.
      * @param id This is the ID of the node to be stored.
      * @param node This is the JSON object of the node to be stored.
      */
-    abstract write(id: number, node: BPTreeNode<K, V>): void | Promise<void>;
+    abstract write(id: string, 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>;
+    abstract delete(id: string): 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.
@@ -53,7 +53,7 @@ export declare abstract class SerializeStrategy<K, V> {
     abstract writeHead(head: SerializeStrategyHead): void | Promise<void>;
     /**
      * Retrieves the data stored in the tree.
-     * If there are no values stored in the tree, it returns the `defaultValue`.
+     * If no value is stored in the tree, it stores a `defaultValue` and then returns that value.
      * @param key The key of the data stored in the tree.
      */
     abstract getHeadData(key: string, defaultValue: Json): Json | Promise<Json>;

package/package.json

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