serializable-bptree 9.0.1 → 9.0.2

package/dist/cjs/index.cjs

@@ -4990,8 +4990,6 @@ var BPTreePureSync = class {
   comparator;
   option;
   _cachedRegexp = /* @__PURE__ */ new Map();
-  _ctx;
-  _ops;
   _verifierMap;
   _searchConfigs;
   constructor(strategy, comparator, option) {
@@ -5005,7 +5003,7 @@ var BPTreePureSync = class {
   _ensureValues(v) {
     return Array.isArray(v) ? v : [v];
   }
-  _createOps() {
+  _createReadOps() {
     const strategy = this.strategy;
     return {
       getNode(id) {
@@ -5072,16 +5070,35 @@ var BPTreePureSync = class {
     }
     return { ops, flush };
   }
+  _readCtx() {
+    const head = this.strategy.readHead();
+    if (head === null) {
+      throw new Error("Tree not initialized. Call init() first.");
+    }
+    return { rootId: head.root, order: head.order };
+  }
+  _createCtx() {
+    const strategy = this.strategy;
+    const head = strategy.readHead();
+    if (head === null) {
+      throw new Error("Tree not initialized. Call init() first.");
+    }
+    return {
+      rootId: head.root,
+      order: head.order,
+      headData: () => strategy.head.data
+    };
+  }
   init() {
     const { ops, flush } = this._createBufferedOps();
-    this._ctx = {
+    const ctx = {
       rootId: "",
       order: this.strategy.order,
       headData: () => this.strategy.head.data
     };
     initOp(
       ops,
-      this._ctx,
+      ctx,
       this.strategy.order,
       this.strategy.head,
       (head) => {
@@ -5089,19 +5106,18 @@ var BPTreePureSync = class {
       }
     );
     flush();
-    this._ops = this._createOps();
   }
   /**
    * Returns the ID of the root node.
    */
   getRootId() {
-    return this._ctx.rootId;
+    return this._readCtx().rootId;
   }
   /**
    * Returns the order of the B+Tree.
    */
   getOrder() {
-    return this._ctx.order;
+    return this._readCtx().order;
   }
   /**
    * Verified if the value satisfies the condition.
@@ -5118,15 +5134,18 @@ var BPTreePureSync = class {
   }
   // ─── Query ───────────────────────────────────────────────────────
   get(key) {
-    return getOp(this._ops, this._ctx.rootId, key);
+    const { rootId } = this._readCtx();
+    return getOp(this._createReadOps(), rootId, key);
   }
   exists(key, value) {
-    return existsOp(this._ops, this._ctx.rootId, key, value, this.comparator);
+    const { rootId } = this._readCtx();
+    return existsOp(this._createReadOps(), rootId, key, value, this.comparator);
   }
   *keysStream(condition, options) {
+    const { rootId } = this._readCtx();
     yield* keysStreamOp(
-      this._ops,
-      this._ctx.rootId,
+      this._createReadOps(),
+      rootId,
       condition,
       this.comparator,
       this._verifierMap,
@@ -5136,9 +5155,10 @@ var BPTreePureSync = class {
     );
   }
   *whereStream(condition, options) {
+    const { rootId } = this._readCtx();
     yield* whereStreamOp(
-      this._ops,
-      this._ctx.rootId,
+      this._createReadOps(),
+      rootId,
       condition,
       this.comparator,
       this._verifierMap,
@@ -5164,27 +5184,31 @@ var BPTreePureSync = class {
   // ─── Mutation ────────────────────────────────────────────────────
   insert(key, value) {
     const { ops, flush } = this._createBufferedOps();
-    insertOp(ops, this._ctx, key, value, this.comparator);
+    const ctx = this._createCtx();
+    insertOp(ops, ctx, key, value, this.comparator);
     flush();
   }
   delete(key, value) {
     const { ops, flush } = this._createBufferedOps();
-    deleteOp(ops, this._ctx, key, this.comparator, value);
+    const ctx = this._createCtx();
+    deleteOp(ops, ctx, key, this.comparator, value);
     flush();
   }
   batchInsert(entries) {
     const { ops, flush } = this._createBufferedOps();
-    batchInsertOp(ops, this._ctx, entries, this.comparator);
+    const ctx = this._createCtx();
+    batchInsertOp(ops, ctx, entries, this.comparator);
     flush();
   }
   bulkLoad(entries) {
     const { ops, flush } = this._createBufferedOps();
-    bulkLoadOp(ops, this._ctx, entries, this.comparator);
+    const ctx = this._createCtx();
+    bulkLoadOp(ops, ctx, entries, this.comparator);
     flush();
   }
   // ─── Head Data ───────────────────────────────────────────────────
   getHeadData() {
-    const head = this._ops.readHead();
+    const head = this.strategy.readHead();
     if (head === null) {
       throw new Error("Head not found");
     }
@@ -5214,8 +5238,6 @@ var BPTreePureAsync = class {
   option;
   lock = new Ryoiki2();
   _cachedRegexp = /* @__PURE__ */ new Map();
-  _ctx;
-  _ops;
   _verifierMap;
   _searchConfigs;
   constructor(strategy, comparator, option) {
@@ -5229,7 +5251,7 @@ var BPTreePureAsync = class {
   _ensureValues(v) {
     return Array.isArray(v) ? v : [v];
   }
-  _createOps() {
+  _createReadOps() {
     const strategy = this.strategy;
     return {
       async getNode(id) {
@@ -5296,6 +5318,25 @@ var BPTreePureAsync = class {
     }
     return { ops, flush };
   }
+  async _readCtx() {
+    const head = await this.strategy.readHead();
+    if (head === null) {
+      throw new Error("Tree not initialized. Call init() first.");
+    }
+    return { rootId: head.root, order: head.order };
+  }
+  async _createCtx() {
+    const strategy = this.strategy;
+    const head = await strategy.readHead();
+    if (head === null) {
+      throw new Error("Tree not initialized. Call init() first.");
+    }
+    return {
+      rootId: head.root,
+      order: head.order,
+      headData: () => strategy.head.data
+    };
+  }
   async writeLock(fn) {
     let lockId;
     return this.lock.writeLock(async (_lockId) => {
@@ -5308,14 +5349,14 @@ var BPTreePureAsync = class {
   async init() {
     return this.writeLock(async () => {
       const { ops, flush } = this._createBufferedOps();
-      this._ctx = {
+      const ctx = {
         rootId: "",
         order: this.strategy.order,
         headData: () => this.strategy.head.data
       };
       await initOpAsync(
         ops,
-        this._ctx,
+        ctx,
         this.strategy.order,
         this.strategy.head,
         (head) => {
@@ -5323,14 +5364,13 @@ var BPTreePureAsync = class {
         }
       );
       await flush();
-      this._ops = this._createOps();
     });
   }
-  getRootId() {
-    return this._ctx.rootId;
+  async getRootId() {
+    return (await this._readCtx()).rootId;
   }
-  getOrder() {
-    return this._ctx.order;
+  async getOrder() {
+    return (await this._readCtx()).order;
   }
   verify(nodeValue, condition) {
     for (const key in condition) {
@@ -5342,18 +5382,21 @@ var BPTreePureAsync = class {
   }
   // ─── Query ───────────────────────────────────────────────────────
   async get(key) {
-    return getOpAsync(this._ops, this._ctx.rootId, key);
+    const { rootId } = await this._readCtx();
+    return getOpAsync(this._createReadOps(), rootId, key);
   }
   async exists(key, value) {
-    return existsOpAsync(this._ops, this._ctx.rootId, key, value, this.comparator);
+    const { rootId } = await this._readCtx();
+    return existsOpAsync(this._createReadOps(), rootId, key, value, this.comparator);
   }
   async *keysStream(condition, options) {
     let lockId;
     try {
       lockId = await this.lock.readLock([0, 0.1], async (id) => id);
+      const { rootId } = await this._readCtx();
       yield* keysStreamOpAsync(
-        this._ops,
-        this._ctx.rootId,
+        this._createReadOps(),
+        rootId,
         condition,
         this.comparator,
         this._verifierMap,
@@ -5369,9 +5412,10 @@ var BPTreePureAsync = class {
     let lockId;
     try {
       lockId = await this.lock.readLock([0, 0.1], async (id) => id);
+      const { rootId } = await this._readCtx();
       yield* whereStreamOpAsync(
-        this._ops,
-        this._ctx.rootId,
+        this._createReadOps(),
+        rootId,
         condition,
         this.comparator,
         this._verifierMap,
@@ -5401,34 +5445,38 @@ var BPTreePureAsync = class {
   async insert(key, value) {
     return this.writeLock(async () => {
       const { ops, flush } = this._createBufferedOps();
-      await insertOpAsync(ops, this._ctx, key, value, this.comparator);
+      const ctx = await this._createCtx();
+      await insertOpAsync(ops, ctx, key, value, this.comparator);
       await flush();
     });
   }
   async delete(key, value) {
     return this.writeLock(async () => {
       const { ops, flush } = this._createBufferedOps();
-      await deleteOpAsync(ops, this._ctx, key, this.comparator, value);
+      const ctx = await this._createCtx();
+      await deleteOpAsync(ops, ctx, key, this.comparator, value);
       await flush();
     });
   }
   async batchInsert(entries) {
     return this.writeLock(async () => {
       const { ops, flush } = this._createBufferedOps();
-      await batchInsertOpAsync(ops, this._ctx, entries, this.comparator);
+      const ctx = await this._createCtx();
+      await batchInsertOpAsync(ops, ctx, entries, this.comparator);
       await flush();
     });
   }
   async bulkLoad(entries) {
     return this.writeLock(async () => {
       const { ops, flush } = this._createBufferedOps();
-      await bulkLoadOpAsync(ops, this._ctx, entries, this.comparator);
+      const ctx = await this._createCtx();
+      await bulkLoadOpAsync(ops, ctx, entries, this.comparator);
       await flush();
     });
   }
   // ─── Head Data ───────────────────────────────────────────────────
   async getHeadData() {
-    const head = await this._ops.readHead();
+    const head = await this.strategy.readHead();
     if (head === null) throw new Error("Head not found");
     return head.data;
   }

package/dist/esm/index.mjs

@@ -4952,8 +4952,6 @@ var BPTreePureSync = class {
   comparator;
   option;
   _cachedRegexp = /* @__PURE__ */ new Map();
-  _ctx;
-  _ops;
   _verifierMap;
   _searchConfigs;
   constructor(strategy, comparator, option) {
@@ -4967,7 +4965,7 @@ var BPTreePureSync = class {
   _ensureValues(v) {
     return Array.isArray(v) ? v : [v];
   }
-  _createOps() {
+  _createReadOps() {
     const strategy = this.strategy;
     return {
       getNode(id) {
@@ -5034,16 +5032,35 @@ var BPTreePureSync = class {
     }
     return { ops, flush };
   }
+  _readCtx() {
+    const head = this.strategy.readHead();
+    if (head === null) {
+      throw new Error("Tree not initialized. Call init() first.");
+    }
+    return { rootId: head.root, order: head.order };
+  }
+  _createCtx() {
+    const strategy = this.strategy;
+    const head = strategy.readHead();
+    if (head === null) {
+      throw new Error("Tree not initialized. Call init() first.");
+    }
+    return {
+      rootId: head.root,
+      order: head.order,
+      headData: () => strategy.head.data
+    };
+  }
   init() {
     const { ops, flush } = this._createBufferedOps();
-    this._ctx = {
+    const ctx = {
       rootId: "",
       order: this.strategy.order,
       headData: () => this.strategy.head.data
     };
     initOp(
       ops,
-      this._ctx,
+      ctx,
       this.strategy.order,
       this.strategy.head,
       (head) => {
@@ -5051,19 +5068,18 @@ var BPTreePureSync = class {
       }
     );
     flush();
-    this._ops = this._createOps();
   }
   /**
    * Returns the ID of the root node.
    */
   getRootId() {
-    return this._ctx.rootId;
+    return this._readCtx().rootId;
   }
   /**
    * Returns the order of the B+Tree.
    */
   getOrder() {
-    return this._ctx.order;
+    return this._readCtx().order;
   }
   /**
    * Verified if the value satisfies the condition.
@@ -5080,15 +5096,18 @@ var BPTreePureSync = class {
   }
   // ─── Query ───────────────────────────────────────────────────────
   get(key) {
-    return getOp(this._ops, this._ctx.rootId, key);
+    const { rootId } = this._readCtx();
+    return getOp(this._createReadOps(), rootId, key);
   }
   exists(key, value) {
-    return existsOp(this._ops, this._ctx.rootId, key, value, this.comparator);
+    const { rootId } = this._readCtx();
+    return existsOp(this._createReadOps(), rootId, key, value, this.comparator);
   }
   *keysStream(condition, options) {
+    const { rootId } = this._readCtx();
     yield* keysStreamOp(
-      this._ops,
-      this._ctx.rootId,
+      this._createReadOps(),
+      rootId,
       condition,
       this.comparator,
       this._verifierMap,
@@ -5098,9 +5117,10 @@ var BPTreePureSync = class {
     );
   }
   *whereStream(condition, options) {
+    const { rootId } = this._readCtx();
     yield* whereStreamOp(
-      this._ops,
-      this._ctx.rootId,
+      this._createReadOps(),
+      rootId,
       condition,
       this.comparator,
       this._verifierMap,
@@ -5126,27 +5146,31 @@ var BPTreePureSync = class {
   // ─── Mutation ────────────────────────────────────────────────────
   insert(key, value) {
     const { ops, flush } = this._createBufferedOps();
-    insertOp(ops, this._ctx, key, value, this.comparator);
+    const ctx = this._createCtx();
+    insertOp(ops, ctx, key, value, this.comparator);
     flush();
   }
   delete(key, value) {
     const { ops, flush } = this._createBufferedOps();
-    deleteOp(ops, this._ctx, key, this.comparator, value);
+    const ctx = this._createCtx();
+    deleteOp(ops, ctx, key, this.comparator, value);
     flush();
   }
   batchInsert(entries) {
     const { ops, flush } = this._createBufferedOps();
-    batchInsertOp(ops, this._ctx, entries, this.comparator);
+    const ctx = this._createCtx();
+    batchInsertOp(ops, ctx, entries, this.comparator);
     flush();
   }
   bulkLoad(entries) {
     const { ops, flush } = this._createBufferedOps();
-    bulkLoadOp(ops, this._ctx, entries, this.comparator);
+    const ctx = this._createCtx();
+    bulkLoadOp(ops, ctx, entries, this.comparator);
     flush();
   }
   // ─── Head Data ───────────────────────────────────────────────────
   getHeadData() {
-    const head = this._ops.readHead();
+    const head = this.strategy.readHead();
     if (head === null) {
       throw new Error("Head not found");
     }
@@ -5176,8 +5200,6 @@ var BPTreePureAsync = class {
   option;
   lock = new Ryoiki2();
   _cachedRegexp = /* @__PURE__ */ new Map();
-  _ctx;
-  _ops;
   _verifierMap;
   _searchConfigs;
   constructor(strategy, comparator, option) {
@@ -5191,7 +5213,7 @@ var BPTreePureAsync = class {
   _ensureValues(v) {
     return Array.isArray(v) ? v : [v];
   }
-  _createOps() {
+  _createReadOps() {
     const strategy = this.strategy;
     return {
       async getNode(id) {
@@ -5258,6 +5280,25 @@ var BPTreePureAsync = class {
     }
     return { ops, flush };
   }
+  async _readCtx() {
+    const head = await this.strategy.readHead();
+    if (head === null) {
+      throw new Error("Tree not initialized. Call init() first.");
+    }
+    return { rootId: head.root, order: head.order };
+  }
+  async _createCtx() {
+    const strategy = this.strategy;
+    const head = await strategy.readHead();
+    if (head === null) {
+      throw new Error("Tree not initialized. Call init() first.");
+    }
+    return {
+      rootId: head.root,
+      order: head.order,
+      headData: () => strategy.head.data
+    };
+  }
   async writeLock(fn) {
     let lockId;
     return this.lock.writeLock(async (_lockId) => {
@@ -5270,14 +5311,14 @@ var BPTreePureAsync = class {
   async init() {
     return this.writeLock(async () => {
       const { ops, flush } = this._createBufferedOps();
-      this._ctx = {
+      const ctx = {
         rootId: "",
         order: this.strategy.order,
         headData: () => this.strategy.head.data
       };
       await initOpAsync(
         ops,
-        this._ctx,
+        ctx,
         this.strategy.order,
         this.strategy.head,
         (head) => {
@@ -5285,14 +5326,13 @@ var BPTreePureAsync = class {
         }
       );
       await flush();
-      this._ops = this._createOps();
     });
   }
-  getRootId() {
-    return this._ctx.rootId;
+  async getRootId() {
+    return (await this._readCtx()).rootId;
   }
-  getOrder() {
-    return this._ctx.order;
+  async getOrder() {
+    return (await this._readCtx()).order;
   }
   verify(nodeValue, condition) {
     for (const key in condition) {
@@ -5304,18 +5344,21 @@ var BPTreePureAsync = class {
   }
   // ─── Query ───────────────────────────────────────────────────────
   async get(key) {
-    return getOpAsync(this._ops, this._ctx.rootId, key);
+    const { rootId } = await this._readCtx();
+    return getOpAsync(this._createReadOps(), rootId, key);
   }
   async exists(key, value) {
-    return existsOpAsync(this._ops, this._ctx.rootId, key, value, this.comparator);
+    const { rootId } = await this._readCtx();
+    return existsOpAsync(this._createReadOps(), rootId, key, value, this.comparator);
   }
   async *keysStream(condition, options) {
     let lockId;
     try {
       lockId = await this.lock.readLock([0, 0.1], async (id) => id);
+      const { rootId } = await this._readCtx();
       yield* keysStreamOpAsync(
-        this._ops,
-        this._ctx.rootId,
+        this._createReadOps(),
+        rootId,
         condition,
         this.comparator,
         this._verifierMap,
@@ -5331,9 +5374,10 @@ var BPTreePureAsync = class {
     let lockId;
     try {
       lockId = await this.lock.readLock([0, 0.1], async (id) => id);
+      const { rootId } = await this._readCtx();
       yield* whereStreamOpAsync(
-        this._ops,
-        this._ctx.rootId,
+        this._createReadOps(),
+        rootId,
         condition,
         this.comparator,
         this._verifierMap,
@@ -5363,34 +5407,38 @@ var BPTreePureAsync = class {
   async insert(key, value) {
     return this.writeLock(async () => {
       const { ops, flush } = this._createBufferedOps();
-      await insertOpAsync(ops, this._ctx, key, value, this.comparator);
+      const ctx = await this._createCtx();
+      await insertOpAsync(ops, ctx, key, value, this.comparator);
       await flush();
     });
   }
   async delete(key, value) {
     return this.writeLock(async () => {
       const { ops, flush } = this._createBufferedOps();
-      await deleteOpAsync(ops, this._ctx, key, this.comparator, value);
+      const ctx = await this._createCtx();
+      await deleteOpAsync(ops, ctx, key, this.comparator, value);
       await flush();
     });
   }
   async batchInsert(entries) {
     return this.writeLock(async () => {
       const { ops, flush } = this._createBufferedOps();
-      await batchInsertOpAsync(ops, this._ctx, entries, this.comparator);
+      const ctx = await this._createCtx();
+      await batchInsertOpAsync(ops, ctx, entries, this.comparator);
       await flush();
     });
   }
   async bulkLoad(entries) {
     return this.writeLock(async () => {
       const { ops, flush } = this._createBufferedOps();
-      await bulkLoadOpAsync(ops, this._ctx, entries, this.comparator);
+      const ctx = await this._createCtx();
+      await bulkLoadOpAsync(ops, ctx, entries, this.comparator);
       await flush();
     });
   }
   // ─── Head Data ───────────────────────────────────────────────────
   async getHeadData() {
-    const head = await this._ops.readHead();
+    const head = await this.strategy.readHead();
     if (head === null) throw new Error("Head not found");
     return head.data;
   }

package/dist/types/BPTreePureAsync.d.ts

@@ -9,18 +9,18 @@ export declare class BPTreePureAsync<K, V> {
     protected readonly option: BPTreeConstructorOption;
     protected readonly lock: Ryoiki;
     private readonly _cachedRegexp;
-    private _ctx;
-    private _ops;
     private readonly _verifierMap;
     private readonly _searchConfigs;
     constructor(strategy: SerializeStrategyAsync<K, V>, comparator: ValueComparator<V>, option?: BPTreeConstructorOption);
     private _ensureValues;
-    private _createOps;
+    private _createReadOps;
     private _createBufferedOps;
+    private _readCtx;
+    private _createCtx;
     protected writeLock<T>(fn: () => Promise<T>): Promise<T>;
     init(): Promise<void>;
-    getRootId(): string;
-    getOrder(): number;
+    getRootId(): Promise<string>;
+    getOrder(): Promise<number>;
     verify(nodeValue: V, condition: BPTreeCondition<V>): boolean;
     get(key: K): Promise<V | undefined>;
     exists(key: K, value: V): Promise<boolean>;

package/dist/types/BPTreePureSync.d.ts

@@ -7,14 +7,14 @@ export declare class BPTreePureSync<K, V> {
     protected readonly comparator: ValueComparator<V>;
     protected readonly option: BPTreeConstructorOption;
     private readonly _cachedRegexp;
-    private _ctx;
-    private _ops;
     private readonly _verifierMap;
     private readonly _searchConfigs;
     constructor(strategy: SerializeStrategySync<K, V>, comparator: ValueComparator<V>, option?: BPTreeConstructorOption);
     private _ensureValues;
-    private _createOps;
+    private _createReadOps;
     private _createBufferedOps;
+    private _readCtx;
+    private _createCtx;
     init(): void;
     /**
      * Returns the ID of the root node.

package/package.json

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