serializable-bptree 3.3.0 → 3.3.1

package/README.md

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

package/dist/cjs/index.cjs

@@ -602,15 +602,15 @@ var BPTreeSync = class extends BPTree {
         throw new Error(`Direction must be -1 or 1. but got a ${direction}`);
     }
   }
-  _createNodeId() {
-    const id = this.strategy.id();
+  _createNodeId(isLeaf) {
+    const id = this.strategy.id(isLeaf);
     if (id === 0) {
       throw new Error(`The node's id should never be 0.`);
     }
     return id;
   }
-  _createNode(keys2, values, leaf = false, parent = 0, next = 0, prev = 0) {
-    const id = this._createNodeId();
+  _createNode(isLeaf, keys2, values, leaf = false, parent = 0, next = 0, prev = 0) {
+    const id = this._createNodeId(isLeaf);
     const node = {
       id,
       keys: keys2,
@@ -823,7 +823,7 @@ var BPTreeSync = class extends BPTree {
   }
   _insertInParent(node, value, pointer) {
     if (this.root === node) {
-      const root = this._createNode([node.id, pointer.id], [value]);
+      const root = this._createNode(false, [node.id, pointer.id], [value]);
       this.root = root;
       this.strategy.head.root = root.id;
       node.parent = root.id;
@@ -841,7 +841,7 @@ var BPTreeSync = class extends BPTree {
         parentNode.keys.splice(i + 1, 0, pointer.id);
         this.bufferForNodeUpdate(parentNode);
         if (parentNode.keys.length > this.order) {
-          const parentPointer = this._createNode([], []);
+          const parentPointer = this._createNode(false, [], []);
           parentPointer.parent = parentNode.parent;
           const mid = Math.ceil(this.order / 2) - 1;
           parentPointer.values = parentNode.values.slice(mid + 1);
@@ -874,7 +874,7 @@ var BPTreeSync = class extends BPTree {
     const head = this.strategy.readHead();
     if (head === null) {
       this.order = this.strategy.order;
-      this.root = this._createNode([], [], true);
+      this.root = this._createNode(true, [], [], true);
       this.strategy.head.root = this.root.id;
       this.bufferForNodeCreate(this.root);
       this.commitHeadBuffer();
@@ -990,6 +990,7 @@ var BPTreeSync = class extends BPTree {
     this._insertAtLeaf(before, key, value);
     if (before.values.length === this.order) {
       const after = this._createNode(
+        true,
         [],
         [],
         true,
@@ -1143,15 +1144,15 @@ var BPTreeAsync = class extends BPTree {
         throw new Error(`Direction must be -1 or 1. but got a ${direction}`);
     }
   }
-  async _createNodeId() {
-    const id = await this.strategy.id();
+  async _createNodeId(isLeaf) {
+    const id = await this.strategy.id(isLeaf);
     if (id === 0) {
       throw new Error(`The node's id should never be 0.`);
     }
     return id;
   }
-  async _createNode(keys2, values, leaf = false, parent = 0, next = 0, prev = 0) {
-    const id = await this._createNodeId();
+  async _createNode(isLeaf, keys2, values, leaf = false, parent = 0, next = 0, prev = 0) {
+    const id = await this._createNodeId(isLeaf);
     const node = {
       id,
       keys: keys2,
@@ -1364,7 +1365,7 @@ var BPTreeAsync = class extends BPTree {
   }
   async _insertInParent(node, value, pointer) {
     if (this.root === node) {
-      const root = await this._createNode([node.id, pointer.id], [value]);
+      const root = await this._createNode(false, [node.id, pointer.id], [value]);
       this.root = root;
       this.strategy.head.root = root.id;
       node.parent = root.id;
@@ -1382,7 +1383,7 @@ var BPTreeAsync = class extends BPTree {
         parentNode.keys.splice(i + 1, 0, pointer.id);
         this.bufferForNodeUpdate(parentNode);
         if (parentNode.keys.length > this.order) {
-          const parentPointer = await this._createNode([], []);
+          const parentPointer = await this._createNode(false, [], []);
           parentPointer.parent = parentNode.parent;
           const mid = Math.ceil(this.order / 2) - 1;
           parentPointer.values = parentNode.values.slice(mid + 1);
@@ -1415,7 +1416,7 @@ var BPTreeAsync = class extends BPTree {
     const head = await this.strategy.readHead();
     if (head === null) {
       this.order = this.strategy.order;
-      this.root = await this._createNode([], [], true);
+      this.root = await this._createNode(true, [], [], true);
       this.strategy.head.root = this.root.id;
       this.bufferForNodeCreate(this.root);
       this.commitHeadBuffer();
@@ -1531,6 +1532,7 @@ var BPTreeAsync = class extends BPTree {
     this._insertAtLeaf(before, key, value);
     if (before.values.length === this.order) {
       const after = await this._createNode(
+        true,
         [],
         [],
         true,
@@ -1652,7 +1654,7 @@ var InMemoryStoreStrategySync = class extends SerializeStrategySync {
     super(order);
     this.node = {};
   }
-  id() {
+  id(isLeaf) {
     return this.autoIncrement("index", 1);
   }
   read(id) {
@@ -1700,7 +1702,7 @@ var InMemoryStoreStrategyAsync = class extends SerializeStrategyAsync {
     super(order);
     this.node = {};
   }
-  async id() {
+  async id(isLeaf) {
     return await this.autoIncrement("index", 1);
   }
   async read(id) {

package/dist/esm/index.mjs

@@ -568,15 +568,15 @@ var BPTreeSync = class extends BPTree {
         throw new Error(`Direction must be -1 or 1. but got a ${direction}`);
     }
   }
-  _createNodeId() {
-    const id = this.strategy.id();
+  _createNodeId(isLeaf) {
+    const id = this.strategy.id(isLeaf);
     if (id === 0) {
       throw new Error(`The node's id should never be 0.`);
     }
     return id;
   }
-  _createNode(keys2, values, leaf = false, parent = 0, next = 0, prev = 0) {
-    const id = this._createNodeId();
+  _createNode(isLeaf, keys2, values, leaf = false, parent = 0, next = 0, prev = 0) {
+    const id = this._createNodeId(isLeaf);
     const node = {
       id,
       keys: keys2,
@@ -789,7 +789,7 @@ var BPTreeSync = class extends BPTree {
   }
   _insertInParent(node, value, pointer) {
     if (this.root === node) {
-      const root = this._createNode([node.id, pointer.id], [value]);
+      const root = this._createNode(false, [node.id, pointer.id], [value]);
       this.root = root;
       this.strategy.head.root = root.id;
       node.parent = root.id;
@@ -807,7 +807,7 @@ var BPTreeSync = class extends BPTree {
         parentNode.keys.splice(i + 1, 0, pointer.id);
         this.bufferForNodeUpdate(parentNode);
         if (parentNode.keys.length > this.order) {
-          const parentPointer = this._createNode([], []);
+          const parentPointer = this._createNode(false, [], []);
           parentPointer.parent = parentNode.parent;
           const mid = Math.ceil(this.order / 2) - 1;
           parentPointer.values = parentNode.values.slice(mid + 1);
@@ -840,7 +840,7 @@ var BPTreeSync = class extends BPTree {
     const head = this.strategy.readHead();
     if (head === null) {
       this.order = this.strategy.order;
-      this.root = this._createNode([], [], true);
+      this.root = this._createNode(true, [], [], true);
       this.strategy.head.root = this.root.id;
       this.bufferForNodeCreate(this.root);
       this.commitHeadBuffer();
@@ -956,6 +956,7 @@ var BPTreeSync = class extends BPTree {
     this._insertAtLeaf(before, key, value);
     if (before.values.length === this.order) {
       const after = this._createNode(
+        true,
         [],
         [],
         true,
@@ -1109,15 +1110,15 @@ var BPTreeAsync = class extends BPTree {
         throw new Error(`Direction must be -1 or 1. but got a ${direction}`);
     }
   }
-  async _createNodeId() {
-    const id = await this.strategy.id();
+  async _createNodeId(isLeaf) {
+    const id = await this.strategy.id(isLeaf);
     if (id === 0) {
       throw new Error(`The node's id should never be 0.`);
     }
     return id;
   }
-  async _createNode(keys2, values, leaf = false, parent = 0, next = 0, prev = 0) {
-    const id = await this._createNodeId();
+  async _createNode(isLeaf, keys2, values, leaf = false, parent = 0, next = 0, prev = 0) {
+    const id = await this._createNodeId(isLeaf);
     const node = {
       id,
       keys: keys2,
@@ -1330,7 +1331,7 @@ var BPTreeAsync = class extends BPTree {
   }
   async _insertInParent(node, value, pointer) {
     if (this.root === node) {
-      const root = await this._createNode([node.id, pointer.id], [value]);
+      const root = await this._createNode(false, [node.id, pointer.id], [value]);
       this.root = root;
       this.strategy.head.root = root.id;
       node.parent = root.id;
@@ -1348,7 +1349,7 @@ var BPTreeAsync = class extends BPTree {
         parentNode.keys.splice(i + 1, 0, pointer.id);
         this.bufferForNodeUpdate(parentNode);
         if (parentNode.keys.length > this.order) {
-          const parentPointer = await this._createNode([], []);
+          const parentPointer = await this._createNode(false, [], []);
           parentPointer.parent = parentNode.parent;
           const mid = Math.ceil(this.order / 2) - 1;
           parentPointer.values = parentNode.values.slice(mid + 1);
@@ -1381,7 +1382,7 @@ var BPTreeAsync = class extends BPTree {
     const head = await this.strategy.readHead();
     if (head === null) {
       this.order = this.strategy.order;
-      this.root = await this._createNode([], [], true);
+      this.root = await this._createNode(true, [], [], true);
       this.strategy.head.root = this.root.id;
       this.bufferForNodeCreate(this.root);
       this.commitHeadBuffer();
@@ -1497,6 +1498,7 @@ var BPTreeAsync = class extends BPTree {
     this._insertAtLeaf(before, key, value);
     if (before.values.length === this.order) {
       const after = await this._createNode(
+        true,
         [],
         [],
         true,
@@ -1618,7 +1620,7 @@ var InMemoryStoreStrategySync = class extends SerializeStrategySync {
     super(order);
     this.node = {};
   }
-  id() {
+  id(isLeaf) {
     return this.autoIncrement("index", 1);
   }
   read(id) {
@@ -1666,7 +1668,7 @@ var InMemoryStoreStrategyAsync = class extends SerializeStrategyAsync {
     super(order);
     this.node = {};
   }
-  async id() {
+  async id(isLeaf) {
     return await this.autoIncrement("index", 1);
   }
   async read(id) {

package/dist/typings/BPTreeAsync.d.ts

@@ -8,8 +8,8 @@ export declare class BPTreeAsync<K, V> extends BPTree<K, V> {
     protected _getPairsRightToLeft(value: V, startNode: BPTreeLeafNode<K, V>, fullScan: boolean, comparator: (nodeValue: V, value: V) => boolean): Promise<BPTreePair<K, V>[]>;
     protected _getPairsLeftToRight(value: V, startNode: BPTreeLeafNode<K, V>, fullScan: boolean, comparator: (nodeValue: V, value: V) => boolean): Promise<BPTreePair<K, V>[]>;
     protected getPairs(value: V, startNode: BPTreeLeafNode<K, V>, fullScan: boolean, comparator: (nodeValue: V, value: V) => boolean, direction: 1 | -1): Promise<BPTreePair<K, V>[]>;
-    protected _createNodeId(): Promise<number>;
-    protected _createNode(keys: number[] | K[][], values: V[], leaf?: boolean, parent?: number, next?: number, prev?: number): Promise<BPTreeUnknownNode<K, V>>;
+    protected _createNodeId(isLeaf: boolean): Promise<number>;
+    protected _createNode(isLeaf: boolean, keys: number[] | K[][], values: V[], leaf?: boolean, parent?: number, next?: number, prev?: number): Promise<BPTreeUnknownNode<K, V>>;
     protected _deleteEntry(node: BPTreeUnknownNode<K, V>, key: BPTreeNodeKey<K>, value: V): Promise<void>;
     protected _insertInParent(node: BPTreeUnknownNode<K, V>, value: V, pointer: BPTreeUnknownNode<K, V>): Promise<void>;
     init(): Promise<void>;

package/dist/typings/BPTreeSync.d.ts

@@ -8,8 +8,8 @@ export declare class BPTreeSync<K, V> extends BPTree<K, V> {
     protected _getPairsRightToLeft(value: V, startNode: BPTreeLeafNode<K, V>, fullScan: boolean, comparator: (nodeValue: V, value: V) => boolean): BPTreePair<K, V>[];
     protected _getPairsLeftToRight(value: V, startNode: BPTreeLeafNode<K, V>, fullScan: boolean, comparator: (nodeValue: V, value: V) => boolean): BPTreePair<K, V>[];
     protected getPairs(value: V, startNode: BPTreeLeafNode<K, V>, fullScan: boolean, comparator: (nodeValue: V, value: V) => boolean, direction: 1 | -1): BPTreePair<K, V>[];
-    protected _createNodeId(): number;
-    protected _createNode(keys: number[] | K[][], values: V[], leaf?: boolean, parent?: number, next?: number, prev?: number): BPTreeUnknownNode<K, V>;
+    protected _createNodeId(isLeaf: boolean): number;
+    protected _createNode(isLeaf: boolean, keys: number[] | K[][], values: V[], leaf?: boolean, parent?: number, next?: number, prev?: number): BPTreeUnknownNode<K, V>;
     protected _deleteEntry(node: BPTreeUnknownNode<K, V>, key: BPTreeNodeKey<K>, value: V): void;
     protected _insertInParent(node: BPTreeUnknownNode<K, V>, value: V, pointer: BPTreeUnknownNode<K, V>): void;
     init(): void;

package/dist/typings/SerializeStrategyAsync.d.ts

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

package/dist/typings/SerializeStrategySync.d.ts

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

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

@@ -59,8 +59,8 @@ export declare abstract class BPTree<K, V> {
     protected abstract _getPairsRightToLeft(value: V, startNode: BPTreeLeafNode<K, V>, fullScan: boolean, comparator: (nodeValue: V, value: V) => boolean): Deferred<BPTreePair<K, V>[]>;
     protected abstract _getPairsLeftToRight(value: V, startNode: BPTreeLeafNode<K, V>, fullScan: boolean, comparator: (nodeValue: V, value: V) => boolean): Deferred<BPTreePair<K, V>[]>;
     protected abstract getPairs(value: V, startNode: BPTreeLeafNode<K, V>, fullScan: boolean, comparator: (nodeValue: V, value: V) => boolean, direction: -1 | 1): Deferred<BPTreePair<K, V>[]>;
-    protected abstract _createNodeId(): Deferred<number>;
-    protected abstract _createNode(keys: number[] | K[][], values: V[], leaf?: boolean, parent?: number, next?: number, prev?: number): Deferred<BPTreeUnknownNode<K, V>>;
+    protected abstract _createNodeId(isLeaf: boolean): Deferred<number>;
+    protected abstract _createNode(isLeaf: boolean, keys: number[] | K[][], values: V[], leaf?: boolean, parent?: number, next?: number, prev?: number): Deferred<BPTreeUnknownNode<K, V>>;
     protected abstract _deleteEntry(node: BPTreeUnknownNode<K, V>, key: BPTreeNodeKey<K>, value: V): Deferred<void>;
     protected abstract _insertInParent(node: BPTreeUnknownNode<K, V>, value: V, pointer: BPTreeUnknownNode<K, V>): Deferred<void>;
     protected abstract getNode(id: number): Deferred<BPTreeUnknownNode<K, V>>;

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

@@ -15,8 +15,9 @@ export declare abstract class SerializeStrategy<K, V> {
      * When a new node is created within the tree, the value returned by this method becomes the node's ID.
      *
      * **WARNING!** The return value should never be `0`.
+     * @param isLeaf This is a flag that indicates whether the node is a leaf node or not.
      */
-    abstract id(): number | Promise<number>;
+    abstract id(isLeaf: boolean): number | Promise<number>;
     /**
      * Read the stored node from the ID.
      * The JSON object of the read node should be returned.

package/package.json

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