serializable-bptree 3.1.0 → 3.2.1

package/README.md

@@ -15,8 +15,7 @@ import {
 
 class FileStoreStrategySync extends SerializeStrategySync<K, V> {
   id(): number {
-    const random = Math.ceil(Math.random()*1000000)
-    return random
+    return this.autoIncrement('index', 1)
   }
 
   read(id: number): BPTreeNode<K, V> {
@@ -202,7 +201,25 @@ id(): number {
 
 Or, you could use file input/output to save and load the value of the **before** variable.
 
-This method is called before a node is created in the tree. Therefore, it can also be used to allocate space for storing the node.
+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 {
+  const current = this.getHeadData('index', 1) as number
+  this.setHeadData('index', current+1)
+  return current
+}
+```
+
+Additionally, there is a more user-friendly usage of this code.
+
+```typescript
+id(): number {
+  return this.autoIncrement('index', 1)
+}
+```
+
+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>`
 
@@ -350,8 +367,7 @@ import {
 
 class FileStoreStrategyAsync extends SerializeStrategyAsync<K, V> {
   async id(): Promise<number> {
-    const random = Math.ceil(Math.random()*1000000)
-    return random
+    return await this.autoIncrement('index', 1)
   }
 
   async read(id: number): Promise<BPTreeNode<K, V>> {

package/dist/cjs/index.js

@@ -78,11 +78,9 @@ var BPTree = class {
   comparator;
   nodes;
   order;
-  data;
   root;
   _nodeCreateBuffer;
   _nodeUpdateBuffer;
-  _headBuffer;
   verifierMap = {
     gt: (nv, v) => this.comparator.isHigher(nv, v),
     gte: (nv, v) => this.comparator.isHigher(nv, v) || this.comparator.isSame(nv, v),
@@ -127,19 +125,8 @@ var BPTree = class {
     notEqual: true,
     like: true
   };
-  get headState() {
-    const root = this.root.id;
-    const order = this.order;
-    const data = this.data;
-    return {
-      root,
-      order,
-      data
-    };
-  }
   constructor(strategy, comparator) {
     this._regexpCache = new CacheStorage();
-    this._headBuffer = null;
     this._nodeCreateBuffer = /* @__PURE__ */ new Map();
     this._nodeUpdateBuffer = /* @__PURE__ */ new Map();
     this.nodes = /* @__PURE__ */ new Map();
@@ -173,9 +160,6 @@ var BPTree = class {
       this.bufferForNodeUpdate(node);
     }
   }
-  bufferForHeadUpdate(head) {
-    this._headBuffer = head;
-  }
   bufferForNodeCreate(node) {
     this._nodeCreateBuffer.set(node.id, node);
   }
@@ -188,7 +172,7 @@ var BPTree = class {
    * @returns User-defined data stored in the head of the tree.
    */
   getHeadData() {
-    return this.data;
+    return this.strategy.head.data;
   }
 };
 
@@ -307,7 +291,7 @@ var BPTreeSync = class extends BPTree {
       const keys = node.keys;
       this.root = this.getNode(keys[0]);
       this.root.parent = 0;
-      this.bufferForHeadUpdate(this.headState);
+      this.strategy.head.root = this.root.id;
       this.bufferForNodeUpdate(this.root);
       return;
     } else if (this.root === node) {
@@ -513,9 +497,9 @@ var BPTreeSync = class extends BPTree {
     if (this.root === node) {
       const root = this._createNode([node.id, pointer.id], [value]);
       this.root = root;
+      this.strategy.head.root = root.id;
       node.parent = root.id;
       pointer.parent = root.id;
-      this.bufferForHeadUpdate(this.headState);
       this.bufferForNodeCreate(root);
       this.bufferForNodeUpdate(node);
       this.bufferForNodeUpdate(pointer);
@@ -562,16 +546,15 @@ var BPTreeSync = class extends BPTree {
     const head = this.strategy.readHead();
     if (head === null) {
       this.order = this.strategy.order;
-      this.data = {};
       this.root = this._createNode([], [], true);
-      this.bufferForHeadUpdate(this.headState);
+      this.strategy.head.root = this.root.id;
       this.bufferForNodeCreate(this.root);
       this.commitHeadBuffer();
       this.commitNodeCreateBuffer();
     } else {
-      const { root, order, data } = head;
+      const { root, order } = head;
+      this.strategy.head = head;
       this.order = order;
-      this.data = data ?? {};
       this.root = this.getNode(root);
     }
     if (this.order < 3) {
@@ -613,10 +596,7 @@ var BPTreeSync = class extends BPTree {
     return node;
   }
   commitHeadBuffer() {
-    if (this._headBuffer !== null) {
-      this.strategy.writeHead(this._headBuffer);
-    }
-    this.bufferForHeadUpdate(null);
+    this.strategy.writeHead(this.strategy.head);
   }
   commitNodeCreateBuffer() {
     for (const node of this._nodeCreateBuffer.values()) {
@@ -739,8 +719,7 @@ var BPTreeSync = class extends BPTree {
     return false;
   }
   setHeadData(data) {
-    this.data = data;
-    this.bufferForHeadUpdate(this.headState);
+    this.strategy.head.data = data;
     this.commitHeadBuffer();
   }
   forceUpdate() {
@@ -869,7 +848,7 @@ var BPTreeAsync = class extends BPTree {
       const keys = node.keys;
       this.root = await this.getNode(keys[0]);
       this.root.parent = 0;
-      this.bufferForHeadUpdate(this.headState);
+      this.strategy.head.root = this.root.id;
       this.bufferForNodeUpdate(this.root);
       return;
     } else if (this.root === node) {
@@ -1048,9 +1027,9 @@ var BPTreeAsync = class extends BPTree {
     if (this.root === node) {
       const root = await this._createNode([node.id, pointer.id], [value]);
       this.root = root;
+      this.strategy.head.root = root.id;
       node.parent = root.id;
       pointer.parent = root.id;
-      this.bufferForHeadUpdate(this.headState);
       this.bufferForNodeCreate(root);
       this.bufferForNodeUpdate(node);
       this.bufferForNodeUpdate(pointer);
@@ -1097,16 +1076,15 @@ var BPTreeAsync = class extends BPTree {
     const head = await this.strategy.readHead();
     if (head === null) {
       this.order = this.strategy.order;
-      this.data = {};
       this.root = await this._createNode([], [], true);
-      this.bufferForHeadUpdate(this.headState);
+      this.strategy.head.root = this.root.id;
       this.bufferForNodeCreate(this.root);
       this.commitHeadBuffer();
       this.commitNodeCreateBuffer();
     } else {
-      const { root, order, data } = head;
+      const { root, order } = head;
+      this.strategy.head = head;
       this.order = order;
-      this.data = data ?? {};
       this.root = await this.getNode(root);
     }
     if (this.order < 3) {
@@ -1148,10 +1126,7 @@ var BPTreeAsync = class extends BPTree {
     return node;
   }
   async commitHeadBuffer() {
-    if (this._headBuffer !== null) {
-      await this.strategy.writeHead(this._headBuffer);
-    }
-    this.bufferForHeadUpdate(null);
+    await this.strategy.writeHead(this.strategy.head);
   }
   async commitNodeCreateBuffer() {
     for (const node of this._nodeCreateBuffer.values()) {
@@ -1274,8 +1249,7 @@ var BPTreeAsync = class extends BPTree {
     return false;
   }
   async setHeadData(data) {
-    this.data = data;
-    this.bufferForHeadUpdate(this.headState);
+    this.strategy.head.data = data;
     await this.commitHeadBuffer();
   }
   async forceUpdate() {
@@ -1292,71 +1266,109 @@ var BPTreeAsync = class extends BPTree {
 // src/base/SerializeStrategy.ts
 var SerializeStrategy = class {
   order;
+  head;
   constructor(order) {
     this.order = order;
+    this.head = {
+      order,
+      root: 0,
+      data: {}
+    };
   }
 };
 
 // src/SerializeStrategySync.ts
 var SerializeStrategySync = class extends SerializeStrategy {
+  getHeadData(key, defaultValue) {
+    if (!Object.hasOwn(this.head.data, key)) {
+      return defaultValue;
+    }
+    return this.head.data[key];
+  }
+  setHeadData(key, data) {
+    this.head.data[key] = data;
+    this.writeHead(this.head);
+  }
+  autoIncrement(key, defaultValue) {
+    const current = this.getHeadData(key, defaultValue);
+    const next = current + 1;
+    this.setHeadData(key, next);
+    return current;
+  }
 };
 var InMemoryStoreStrategySync = class extends SerializeStrategySync {
-  data;
+  node;
   constructor(order) {
     super(order);
-    this.data = {
-      head: null,
-      node: {}
-    };
+    this.node = {};
   }
   id() {
-    return Math.ceil(Math.random() * Number.MAX_SAFE_INTEGER - 1);
+    return this.autoIncrement("index", 1);
   }
   read(id) {
-    if (!Object.prototype.hasOwnProperty.call(this.data.node, id)) {
+    if (!Object.hasOwn(this.node, id)) {
       throw new Error(`The tree attempted to reference node '${id}', but couldn't find the corresponding node.`);
     }
-    return this.data.node[id];
+    return this.node[id];
   }
   write(id, node) {
-    this.data.node[id] = node;
+    this.node[id] = node;
   }
   readHead() {
-    return this.data.head;
+    if (this.head.root === 0) {
+      return null;
+    }
+    return this.head;
   }
   writeHead(head) {
-    this.data.head = head;
+    this.head = head;
   }
 };
 
 // src/SerializeStrategyAsync.ts
 var SerializeStrategyAsync = class extends SerializeStrategy {
+  async getHeadData(key, defaultValue) {
+    if (!Object.hasOwn(this.head.data, key)) {
+      return defaultValue;
+    }
+    return this.head.data[key];
+  }
+  async setHeadData(key, data) {
+    this.head.data[key] = data;
+    await this.writeHead(this.head);
+  }
+  async autoIncrement(key, defaultValue) {
+    const current = await this.getHeadData(key, defaultValue);
+    const next = current + 1;
+    await this.setHeadData(key, next);
+    return current;
+  }
 };
 var InMemoryStoreStrategyAsync = class extends SerializeStrategyAsync {
-  data;
+  node;
   constructor(order) {
     super(order);
-    this.data = {
-      head: null,
-      node: {}
-    };
+    this.node = {};
   }
   async id() {
-    return Math.ceil(Math.random() * Number.MAX_SAFE_INTEGER - 1);
+    return await this.autoIncrement("index", 1);
   }
   async read(id) {
-    if (!Object.prototype.hasOwnProperty.call(this.data.node, id)) {
+    if (!Object.hasOwn(this.node, id)) {
       throw new Error(`The tree attempted to reference node '${id}', but couldn't find the corresponding node.`);
     }
-    return this.data.node[id];
+    return this.node[id];
   }
   async write(id, node) {
-    this.data.node[id] = node;
+    this.node[id] = node;
   }
   async readHead() {
-    return this.data.head;
+    if (this.head.root === 0) {
+      return null;
+    }
+    return this.head;
   }
   async writeHead(head) {
-    this.data.head = head;
+    this.head = head;
   }
 };

package/dist/esm/index.js

@@ -44,11 +44,9 @@ var BPTree = class {
   comparator;
   nodes;
   order;
-  data;
   root;
   _nodeCreateBuffer;
   _nodeUpdateBuffer;
-  _headBuffer;
   verifierMap = {
     gt: (nv, v) => this.comparator.isHigher(nv, v),
     gte: (nv, v) => this.comparator.isHigher(nv, v) || this.comparator.isSame(nv, v),
@@ -93,19 +91,8 @@ var BPTree = class {
     notEqual: true,
     like: true
   };
-  get headState() {
-    const root = this.root.id;
-    const order = this.order;
-    const data = this.data;
-    return {
-      root,
-      order,
-      data
-    };
-  }
   constructor(strategy, comparator) {
     this._regexpCache = new CacheStorage();
-    this._headBuffer = null;
     this._nodeCreateBuffer = /* @__PURE__ */ new Map();
     this._nodeUpdateBuffer = /* @__PURE__ */ new Map();
     this.nodes = /* @__PURE__ */ new Map();
@@ -139,9 +126,6 @@ var BPTree = class {
       this.bufferForNodeUpdate(node);
     }
   }
-  bufferForHeadUpdate(head) {
-    this._headBuffer = head;
-  }
   bufferForNodeCreate(node) {
     this._nodeCreateBuffer.set(node.id, node);
   }
@@ -154,7 +138,7 @@ var BPTree = class {
    * @returns User-defined data stored in the head of the tree.
    */
   getHeadData() {
-    return this.data;
+    return this.strategy.head.data;
   }
 };
 
@@ -273,7 +257,7 @@ var BPTreeSync = class extends BPTree {
       const keys = node.keys;
       this.root = this.getNode(keys[0]);
       this.root.parent = 0;
-      this.bufferForHeadUpdate(this.headState);
+      this.strategy.head.root = this.root.id;
       this.bufferForNodeUpdate(this.root);
       return;
     } else if (this.root === node) {
@@ -479,9 +463,9 @@ var BPTreeSync = class extends BPTree {
     if (this.root === node) {
       const root = this._createNode([node.id, pointer.id], [value]);
       this.root = root;
+      this.strategy.head.root = root.id;
       node.parent = root.id;
       pointer.parent = root.id;
-      this.bufferForHeadUpdate(this.headState);
       this.bufferForNodeCreate(root);
       this.bufferForNodeUpdate(node);
       this.bufferForNodeUpdate(pointer);
@@ -528,16 +512,15 @@ var BPTreeSync = class extends BPTree {
     const head = this.strategy.readHead();
     if (head === null) {
       this.order = this.strategy.order;
-      this.data = {};
       this.root = this._createNode([], [], true);
-      this.bufferForHeadUpdate(this.headState);
+      this.strategy.head.root = this.root.id;
       this.bufferForNodeCreate(this.root);
       this.commitHeadBuffer();
       this.commitNodeCreateBuffer();
     } else {
-      const { root, order, data } = head;
+      const { root, order } = head;
+      this.strategy.head = head;
       this.order = order;
-      this.data = data ?? {};
       this.root = this.getNode(root);
     }
     if (this.order < 3) {
@@ -579,10 +562,7 @@ var BPTreeSync = class extends BPTree {
     return node;
   }
   commitHeadBuffer() {
-    if (this._headBuffer !== null) {
-      this.strategy.writeHead(this._headBuffer);
-    }
-    this.bufferForHeadUpdate(null);
+    this.strategy.writeHead(this.strategy.head);
   }
   commitNodeCreateBuffer() {
     for (const node of this._nodeCreateBuffer.values()) {
@@ -705,8 +685,7 @@ var BPTreeSync = class extends BPTree {
     return false;
   }
   setHeadData(data) {
-    this.data = data;
-    this.bufferForHeadUpdate(this.headState);
+    this.strategy.head.data = data;
     this.commitHeadBuffer();
   }
   forceUpdate() {
@@ -835,7 +814,7 @@ var BPTreeAsync = class extends BPTree {
       const keys = node.keys;
       this.root = await this.getNode(keys[0]);
       this.root.parent = 0;
-      this.bufferForHeadUpdate(this.headState);
+      this.strategy.head.root = this.root.id;
       this.bufferForNodeUpdate(this.root);
       return;
     } else if (this.root === node) {
@@ -1014,9 +993,9 @@ var BPTreeAsync = class extends BPTree {
     if (this.root === node) {
       const root = await this._createNode([node.id, pointer.id], [value]);
       this.root = root;
+      this.strategy.head.root = root.id;
       node.parent = root.id;
       pointer.parent = root.id;
-      this.bufferForHeadUpdate(this.headState);
       this.bufferForNodeCreate(root);
       this.bufferForNodeUpdate(node);
       this.bufferForNodeUpdate(pointer);
@@ -1063,16 +1042,15 @@ var BPTreeAsync = class extends BPTree {
     const head = await this.strategy.readHead();
     if (head === null) {
       this.order = this.strategy.order;
-      this.data = {};
       this.root = await this._createNode([], [], true);
-      this.bufferForHeadUpdate(this.headState);
+      this.strategy.head.root = this.root.id;
       this.bufferForNodeCreate(this.root);
       this.commitHeadBuffer();
       this.commitNodeCreateBuffer();
     } else {
-      const { root, order, data } = head;
+      const { root, order } = head;
+      this.strategy.head = head;
       this.order = order;
-      this.data = data ?? {};
       this.root = await this.getNode(root);
     }
     if (this.order < 3) {
@@ -1114,10 +1092,7 @@ var BPTreeAsync = class extends BPTree {
     return node;
   }
   async commitHeadBuffer() {
-    if (this._headBuffer !== null) {
-      await this.strategy.writeHead(this._headBuffer);
-    }
-    this.bufferForHeadUpdate(null);
+    await this.strategy.writeHead(this.strategy.head);
   }
   async commitNodeCreateBuffer() {
     for (const node of this._nodeCreateBuffer.values()) {
@@ -1240,8 +1215,7 @@ var BPTreeAsync = class extends BPTree {
     return false;
   }
   async setHeadData(data) {
-    this.data = data;
-    this.bufferForHeadUpdate(this.headState);
+    this.strategy.head.data = data;
     await this.commitHeadBuffer();
   }
   async forceUpdate() {
@@ -1258,72 +1232,110 @@ var BPTreeAsync = class extends BPTree {
 // src/base/SerializeStrategy.ts
 var SerializeStrategy = class {
   order;
+  head;
   constructor(order) {
     this.order = order;
+    this.head = {
+      order,
+      root: 0,
+      data: {}
+    };
   }
 };
 
 // src/SerializeStrategySync.ts
 var SerializeStrategySync = class extends SerializeStrategy {
+  getHeadData(key, defaultValue) {
+    if (!Object.hasOwn(this.head.data, key)) {
+      return defaultValue;
+    }
+    return this.head.data[key];
+  }
+  setHeadData(key, data) {
+    this.head.data[key] = data;
+    this.writeHead(this.head);
+  }
+  autoIncrement(key, defaultValue) {
+    const current = this.getHeadData(key, defaultValue);
+    const next = current + 1;
+    this.setHeadData(key, next);
+    return current;
+  }
 };
 var InMemoryStoreStrategySync = class extends SerializeStrategySync {
-  data;
+  node;
   constructor(order) {
     super(order);
-    this.data = {
-      head: null,
-      node: {}
-    };
+    this.node = {};
   }
   id() {
-    return Math.ceil(Math.random() * Number.MAX_SAFE_INTEGER - 1);
+    return this.autoIncrement("index", 1);
   }
   read(id) {
-    if (!Object.prototype.hasOwnProperty.call(this.data.node, id)) {
+    if (!Object.hasOwn(this.node, id)) {
       throw new Error(`The tree attempted to reference node '${id}', but couldn't find the corresponding node.`);
     }
-    return this.data.node[id];
+    return this.node[id];
   }
   write(id, node) {
-    this.data.node[id] = node;
+    this.node[id] = node;
   }
   readHead() {
-    return this.data.head;
+    if (this.head.root === 0) {
+      return null;
+    }
+    return this.head;
   }
   writeHead(head) {
-    this.data.head = head;
+    this.head = head;
   }
 };
 
 // src/SerializeStrategyAsync.ts
 var SerializeStrategyAsync = class extends SerializeStrategy {
+  async getHeadData(key, defaultValue) {
+    if (!Object.hasOwn(this.head.data, key)) {
+      return defaultValue;
+    }
+    return this.head.data[key];
+  }
+  async setHeadData(key, data) {
+    this.head.data[key] = data;
+    await this.writeHead(this.head);
+  }
+  async autoIncrement(key, defaultValue) {
+    const current = await this.getHeadData(key, defaultValue);
+    const next = current + 1;
+    await this.setHeadData(key, next);
+    return current;
+  }
 };
 var InMemoryStoreStrategyAsync = class extends SerializeStrategyAsync {
-  data;
+  node;
   constructor(order) {
     super(order);
-    this.data = {
-      head: null,
-      node: {}
-    };
+    this.node = {};
   }
   async id() {
-    return Math.ceil(Math.random() * Number.MAX_SAFE_INTEGER - 1);
+    return await this.autoIncrement("index", 1);
   }
   async read(id) {
-    if (!Object.prototype.hasOwnProperty.call(this.data.node, id)) {
+    if (!Object.hasOwn(this.node, id)) {
       throw new Error(`The tree attempted to reference node '${id}', but couldn't find the corresponding node.`);
     }
-    return this.data.node[id];
+    return this.node[id];
   }
   async write(id, node) {
-    this.data.node[id] = node;
+    this.node[id] = node;
   }
   async readHead() {
-    return this.data.head;
+    if (this.head.root === 0) {
+      return null;
+    }
+    return this.head;
   }
   async writeHead(head) {
-    this.data.head = head;
+    this.head = head;
   }
 };
 export {

package/dist/typings/BPTreeAsync.d.ts

@@ -1,7 +1,7 @@
-import type { Json } from './utils/types';
 import { BPTree, BPTreeCondition, BPTreeLeafNode, BPTreePair, BPTreeNodeKey, BPTreeUnknownNode } from './base/BPTree';
 import { SerializeStrategyAsync } from './SerializeStrategyAsync';
 import { ValueComparator } from './base/ValueComparator';
+import { SerializableData } from './base/SerializeStrategy';
 export declare class BPTreeAsync<K, V> extends BPTree<K, V> {
     protected readonly strategy: SerializeStrategyAsync<K, V>;
     constructor(strategy: SerializeStrategyAsync<K, V>, comparator: ValueComparator<V>);
@@ -24,6 +24,6 @@ export declare class BPTreeAsync<K, V> extends BPTree<K, V> {
     insert(key: K, value: V): Promise<void>;
     delete(key: K, value: V): Promise<void>;
     exists(key: K, value: V): Promise<boolean>;
-    setHeadData(data: Record<string, Json>): Promise<void>;
+    setHeadData(data: SerializableData): Promise<void>;
     forceUpdate(): Promise<number>;
 }

package/dist/typings/BPTreeSync.d.ts

@@ -1,7 +1,7 @@
-import type { Json } from './utils/types';
 import { BPTree, BPTreeCondition, BPTreeLeafNode, BPTreePair, BPTreeNodeKey, BPTreeUnknownNode } from './base/BPTree';
 import { SerializeStrategySync } from './SerializeStrategySync';
 import { ValueComparator } from './base/ValueComparator';
+import { SerializableData } from './base/SerializeStrategy';
 export declare class BPTreeSync<K, V> extends BPTree<K, V> {
     protected readonly strategy: SerializeStrategySync<K, V>;
     constructor(strategy: SerializeStrategySync<K, V>, comparator: ValueComparator<V>);
@@ -25,6 +25,6 @@ export declare class BPTreeSync<K, V> extends BPTree<K, V> {
     insert(key: K, value: V): void;
     delete(key: K, value: V): void;
     exists(key: K, value: V): boolean;
-    setHeadData(data: Record<string, Json>): void;
+    setHeadData(data: SerializableData): void;
     forceUpdate(): number;
 }

package/dist/typings/SerializeStrategyAsync.d.ts

@@ -1,17 +1,18 @@
 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 read(id: number): Promise<BPTreeNode<K, V>>;
     abstract write(id: number, node: BPTreeNode<K, V>): Promise<void>;
     abstract readHead(): Promise<SerializeStrategyHead | null>;
     abstract writeHead(head: SerializeStrategyHead): Promise<void>;
+    getHeadData(key: string, defaultValue: Json): Promise<Json>;
+    setHeadData(key: string, data: Json): Promise<void>;
+    autoIncrement(key: string, defaultValue: number): Promise<number>;
 }
 export declare class InMemoryStoreStrategyAsync<K, V> extends SerializeStrategyAsync<K, V> {
-    protected readonly data: {
-        head: SerializeStrategyHead | null;
-        node: Record<number, BPTreeNode<K, V>>;
-    };
+    protected readonly node: Record<number, BPTreeNode<K, V>>;
     constructor(order: number);
     id(): Promise<number>;
     read(id: number): Promise<BPTreeNode<K, V>>;

package/dist/typings/SerializeStrategySync.d.ts

@@ -1,17 +1,18 @@
 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 read(id: number): BPTreeNode<K, V>;
     abstract write(id: number, node: BPTreeNode<K, V>): void;
     abstract readHead(): SerializeStrategyHead | null;
     abstract writeHead(head: SerializeStrategyHead): void;
+    getHeadData(key: string, defaultValue: Json): Json;
+    setHeadData(key: string, data: Json): void;
+    autoIncrement(key: string, defaultValue: number): number;
 }
 export declare class InMemoryStoreStrategySync<K, V> extends SerializeStrategySync<K, V> {
-    protected readonly data: {
-        head: SerializeStrategyHead | null;
-        node: Record<number, BPTreeNode<K, V>>;
-    };
+    protected readonly node: Record<number, BPTreeNode<K, V>>;
     constructor(order: number);
     id(): number;
     read(id: number): BPTreeNode<K, V>;

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

@@ -1,6 +1,5 @@
-import type { Json } from '../utils/types';
 import { ValueComparator } from './ValueComparator';
-import { SerializeStrategy, SerializeStrategyHead } from './SerializeStrategy';
+import { SerializableData, SerializeStrategy } from './SerializeStrategy';
 type Sync<T> = T;
 type Async<T> = Promise<T>;
 type Deferred<T> = Sync<T> | Async<T>;
@@ -49,16 +48,13 @@ export declare abstract class BPTree<K, V> {
     protected readonly comparator: ValueComparator<V>;
     protected readonly nodes: Map<number, BPTreeUnknownNode<K, V>>;
     protected order: number;
-    protected data: Record<string, Json>;
     protected root: BPTreeUnknownNode<K, V>;
     protected readonly _nodeCreateBuffer: Map<number, BPTreeUnknownNode<K, V>>;
     protected readonly _nodeUpdateBuffer: Map<number, BPTreeUnknownNode<K, V>>;
-    protected _headBuffer: SerializeStrategyHead | null;
     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>;
     protected readonly verifierFullScan: Record<keyof BPTreeCondition<V>, boolean>;
-    protected get headState(): SerializeStrategyHead;
     protected constructor(strategy: SerializeStrategy<K, V>, comparator: ValueComparator<V>);
     protected abstract _getPairsRightToLeft(value: V, startNode: BPTreeLeafNode<K, V>, fullSearch: boolean, comparator: (nodeValue: V, value: V) => boolean): Deferred<BPTreePair<K, V>[]>;
     protected abstract _getPairsLeftToRight(value: V, startNode: BPTreeLeafNode<K, V>, fullSearch: boolean, comparator: (nodeValue: V, value: V) => boolean): Deferred<BPTreePair<K, V>[]>;
@@ -117,7 +113,7 @@ export declare abstract class BPTree<K, V> {
     * For example, you can store information such as the last update time and the number of insertions.
     * @param data User-defined data to be stored in the head of the tree.
     */
-    abstract setHeadData(data: Record<string, Json>): Deferred<void>;
+    abstract setHeadData(data: SerializableData): Deferred<void>;
     /**
      * This method deletes nodes cached in-memory and caches new nodes from the stored nodes.
      * Typically, there's no need to use this method, but it can be used to synchronize data in scenarios where the remote storage and the client are in a 1:n relationship.
@@ -125,7 +121,6 @@ export declare abstract class BPTree<K, V> {
      */
     abstract forceUpdate(nodeId: number): Deferred<number>;
     protected _insertAtLeaf(node: BPTreeLeafNode<K, V>, key: K, value: V): void;
-    protected bufferForHeadUpdate(head: SerializeStrategyHead | null): Deferred<void>;
     protected bufferForNodeCreate(node: BPTreeUnknownNode<K, V>): Deferred<void>;
     protected bufferForNodeUpdate(node: BPTreeUnknownNode<K, V>): Deferred<void>;
     /**
@@ -133,6 +128,6 @@ export declare abstract class BPTree<K, V> {
      * 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 `{}`.
      * @returns User-defined data stored in the head of the tree.
      */
-    getHeadData(): Record<string, Json>;
+    getHeadData(): SerializableData;
 }
 export {};

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

@@ -1,12 +1,14 @@
 import { BPTreeNode } from './BPTree';
 import type { Json } from '../utils/types';
+export type SerializableData = Record<string, Json>;
 export interface SerializeStrategyHead {
     root: number;
     order: number;
-    data: Record<string, Json>;
+    data: SerializableData;
 }
 export declare abstract class SerializeStrategy<K, V> {
     readonly order: number;
+    head: SerializeStrategyHead;
     constructor(order: number);
     /**
      * The rule for generating node IDs is set.
@@ -42,4 +44,28 @@ export declare abstract class SerializeStrategy<K, V> {
      * @param head This is the current state of the tree.
      */
     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`.
+     * @param key The key of the data stored in the tree.
+     */
+    abstract getHeadData(key: string, defaultValue: Json): Json | Promise<Json>;
+    /**
+     * Stores data in the tree.
+     * This data is permanently stored in the head.
+     * The stored data can be retrieved later using the `getHeadData` method.
+     * @param key The key of the data to be stored in the tree.
+     * @param data The data to be stored in the tree.
+     */
+    abstract setHeadData(key: string, data: Json): void | Promise<void>;
+    /**
+     * This method returns a numeric value and increments it by `1`, storing it in the tree's header.
+     * Therefore, when called again, the value incremented by `+1` is returned.
+     *
+     * This is a syntactic sugar for using the `setHeadData` and `getHeadData` methods.
+     * It assists in simplifying the implementation of node ID generation in the `id` method.
+     * @param key The key of the data to be stored in the tree.
+     * @param defaultValue The data to be stored in the tree.
+     */
+    abstract autoIncrement(key: string, defaultValue: number): number | Promise<number>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "serializable-bptree",
-  "version": "3.1.0",
+  "version": "3.2.1",
   "description": "Store the B+tree flexibly, not only in-memory.",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",