@oimdb/core 3.2.0 → 3.4.0

package/dist/index.js

@@ -545,7 +545,7 @@ var OIMCarrierKeyedEmitter = class {
   }
   destroy() {
     if (this.isFlushEnqueued) {
-      this.queue.cancelTask(this.onFlush);
+      this.queue.cancel(this.onFlush);
       this.isFlushEnqueued = false;
     }
     this.subscribedCarriers.forEach((carrier) => {
@@ -569,7 +569,7 @@ var OIMCarrierKeyedEmitter = class {
   scheduleFlush() {
     if (this.isFlushEnqueued) return;
     this.isFlushEnqueued = true;
-    this.queue.enqueueTask(this.onFlush);
+    this.queue.enqueue(this.onFlush);
   }
   notify(carrier) {
     const subscribers = carrier.subscribers;
@@ -865,12 +865,15 @@ var OIMCollectionStoreMapDriven = class extends OIMCollectionStore {
   }
 };
 
+// src/core/createMergeEntityUpdater.ts
+function createMergeEntityUpdater() {
+  return (draft, prev) => ({ ...prev, ...draft });
+}
+
 // src/core/OIMEntityUpdaterFactory.ts
 var OIMEntityUpdaterFactory = class {
   createMergeEntityUpdater() {
-    return (draft, prev) => {
-      return { ...prev, ...draft };
-    };
+    return createMergeEntityUpdater();
   }
 };
 
@@ -1134,12 +1137,12 @@ var OIMReactiveCollection = class extends OIMCollection {
   ensureAnyUpdateEnqueued() {
     if (this.isAnyUpdateScheduled) return;
     this.isAnyUpdateScheduled = true;
-    this.queue.enqueueTask(this.runAnyUpdate);
+    this.queue.enqueue(this.runAnyUpdate);
   }
   destroy() {
     this.updateEmitter.destroy();
     if (this.isAnyUpdateScheduled) {
-      this.queue.cancelTask(this.runAnyUpdate);
+      this.queue.cancel(this.runAnyUpdate);
       this.isAnyUpdateScheduled = false;
     }
     this.anyUpdateHandlers.clear();
@@ -1189,6 +1192,22 @@ var OIMIndexManualOrderedArrayBased = class extends OIMIndexArrayBased {
     this.emitUpdate([key]);
     return removed;
   }
+  /**
+   * Remove up to `count` consecutive slots starting at `index`.
+   * Returns the number actually removed (clamped to bounds; 0 if nothing).
+   */
+  removeRange(key, index, count) {
+    const list = this.store.getOneByKey(key);
+    if (!list) return 0;
+    if (index < 0 || index >= list.length || count <= 0) return 0;
+    const actual = Math.min(count, list.length - index);
+    list.splice(index, actual);
+    if (list.length === 0) {
+      this.store.removeOneByKey(key);
+    }
+    this.emitUpdate([key]);
+    return actual;
+  }
   move(key, fromIndex, toIndex) {
     const list = this.store.getOneByKey(key);
     if (!list) return void 0;
@@ -1201,6 +1220,32 @@ var OIMIndexManualOrderedArrayBased = class extends OIMIndexArrayBased {
     this.emitUpdate([key]);
     return slot;
   }
+  /** Replace the slot at `index` in place. Returns the safe index, or -1. */
+  setSlotAt(key, index, slot) {
+    const list = this.store.getOneByKey(key);
+    if (!list) return -1;
+    if (index < 0 || index >= list.length) return -1;
+    list[index] = slot;
+    this.emitUpdate([key]);
+    return index;
+  }
+  /**
+   * Move up to `count` consecutive slots from `from` to `to`. `to` is in the
+   * coordinate space *after* the block is extracted (same as single `move`).
+   * Returns the number actually moved (0 if a no-op / out of bounds).
+   */
+  moveRange(key, from, to, count) {
+    const list = this.store.getOneByKey(key);
+    if (!list) return 0;
+    if (from < 0 || from >= list.length || count <= 0) return 0;
+    const actual = Math.min(count, list.length - from);
+    const insertAt = Math.max(0, Math.min(to, list.length - actual));
+    if (insertAt === from) return 0;
+    const block = list.splice(from, actual);
+    list.splice(insertAt, 0, ...block);
+    this.emitUpdate([key]);
+    return actual;
+  }
   resetSlots(key, slots) {
     if (slots.length === 0) {
       if (this.store.getOneByKey(key) !== void 0) {
@@ -1334,7 +1379,7 @@ var OIMUpdateEventEmitter = class {
     }
     if (this.isFlushEnqueued) return;
     this.isFlushEnqueued = true;
-    this.queue.enqueueTask(this.onFlush);
+    this.queue.enqueue(this.onFlush);
   }
   markUpdatedKey(key) {
     if (this.deliveryMode === "queue" && this.queue.isInFlush) {
@@ -1356,7 +1401,7 @@ var OIMUpdateEventEmitter = class {
     }
     if (this.isFlushEnqueued) return;
     this.isFlushEnqueued = true;
-    this.queue.enqueueTask(this.onFlush);
+    this.queue.enqueue(this.onFlush);
   }
   markAllUpdated() {
     if (this.deliveryMode === "queue" && this.queue.isInFlush) {
@@ -1378,7 +1423,7 @@ var OIMUpdateEventEmitter = class {
     }
     if (this.isFlushEnqueued) return;
     this.isFlushEnqueued = true;
-    this.queue.enqueueTask(this.onFlush);
+    this.queue.enqueue(this.onFlush);
   }
   deliverImmediate() {
     this.runSinglePass();
@@ -1411,15 +1456,15 @@ var OIMUpdateEventEmitter = class {
     const flushingKeys = this.updatedKeys;
     this.updatedKeys = /* @__PURE__ */ new Set();
     if (this.keyHandlers.size === 0 || flushingKeys.size === 0) return;
-    if (flushingKeys.size * 2 < this.keyHandlers.size) {
-      flushingKeys.forEach((key) => {
-        const handlers = this.keyHandlers.get(key);
+    if (flushingKeys.size === this.keyHandlers.size) {
+      this.keyHandlers.forEach((handlers, key) => {
+        if (!flushingKeys.has(key)) return;
         if (!handlers || handlers.size === 0) return;
         this.notifyHandlers(handlers);
       });
     } else {
-      this.keyHandlers.forEach((handlers, key) => {
-        if (!flushingKeys.has(key)) return;
+      flushingKeys.forEach((key) => {
+        const handlers = this.keyHandlers.get(key);
         if (!handlers || handlers.size === 0) return;
         this.notifyHandlers(handlers);
       });
@@ -1427,7 +1472,7 @@ var OIMUpdateEventEmitter = class {
   }
   destroy() {
     if (this.isFlushEnqueued) {
-      this.queue.cancelTask(this.onFlush);
+      this.queue.cancel(this.onFlush);
       this.isFlushEnqueued = false;
     }
     if (this.unsubscribeAfterFlushDelivery) {
@@ -1487,7 +1532,7 @@ var OIMUpdateEventEmitter = class {
     if (this.keyHandlers.size === 0) {
       this.updatedKeys.clear();
       if (this.isFlushEnqueued) {
-        this.queue.cancelTask(this.onFlush);
+        this.queue.cancel(this.onFlush);
       }
       this.isFlushEnqueued = false;
     }
@@ -1531,7 +1576,7 @@ var OIMOrderedListCommandStream = class {
       if (payload.keys.length === 0) return;
       for (let i = 0; i < payload.keys.length; i++) {
         const key = payload.keys[i];
-        this.appendSetCommand(key, this.getSlotsByKey(key));
+        this.appendResetCommand(key, this.getSlotsByKey(key));
       }
     };
     this.commandsEventEmitter = new OIMUpdateEventEmitter(
@@ -1568,12 +1613,7 @@ var OIMOrderedListCommandStream = class {
   pushSlot(key, slot) {
     this.withWrite(() => {
       const index = this.index.pushSlot(key, slot);
-      this.appendCommand(key, {
-        type: "insert",
-        pk: slot.pk,
-        slot,
-        index
-      });
+      this.appendCommand(key, { type: "insert", index, item: slot });
     });
   }
   insertSlotAt(key, index, slot) {
@@ -1581,9 +1621,20 @@ var OIMOrderedListCommandStream = class {
       const safeIndex = this.index.insertSlotAt(key, index, slot);
       this.appendCommand(key, {
         type: "insert",
-        pk: slot.pk,
-        slot,
-        index: safeIndex
+        index: safeIndex,
+        item: slot
+      });
+    });
+  }
+  /** Replace the slot at `index` in place. */
+  setSlotAt(key, index, slot) {
+    this.withWrite(() => {
+      const safeIndex = this.index.setSlotAt(key, index, slot);
+      if (safeIndex < 0) return;
+      this.appendCommand(key, {
+        type: "set",
+        index: safeIndex,
+        item: slot
       });
     });
   }
@@ -1591,12 +1642,15 @@ var OIMOrderedListCommandStream = class {
     this.withWrite(() => {
       const slot = this.index.removeAt(key, index);
       if (slot === void 0) return;
-      this.appendCommand(key, {
-        type: "remove",
-        pk: slot.pk,
-        slot,
-        index
-      });
+      this.appendCommand(key, { type: "remove", index });
+    });
+  }
+  /** Remove `count` consecutive elements from `index`; emits `remove` with `count`. */
+  removeRange(key, index, count) {
+    this.withWrite(() => {
+      const removed = this.index.removeRange(key, index, count);
+      if (removed <= 0) return;
+      this.appendCommand(key, { type: "remove", index, count: removed });
     });
   }
   move(key, fromIndex, toIndex) {
@@ -1605,17 +1659,26 @@ var OIMOrderedListCommandStream = class {
       if (slot === void 0) return;
       this.appendCommand(key, {
         type: "move",
-        pk: slot.pk,
-        slot,
-        fromIndex,
-        toIndex
+        from: fromIndex,
+        to: toIndex
       });
     });
   }
+  /**
+   * Move `count` consecutive elements from `from` to `to`; emits `move` with
+   * `count`. `to` is in the post-extraction coordinate space (as single `move`).
+   */
+  moveRange(key, from, to, count) {
+    this.withWrite(() => {
+      const moved = this.index.moveRange(key, from, to, count);
+      if (moved <= 0) return;
+      this.appendCommand(key, { type: "move", from, to, count: moved });
+    });
+  }
   setSlots(key, slots) {
     this.withWrite(() => {
       this.index.resetSlots(key, slots);
-      this.appendSetCommand(key, slots);
+      this.appendResetCommand(key, slots);
     });
   }
   getBufferedCommands(key) {
@@ -1659,26 +1722,21 @@ var OIMOrderedListCommandStream = class {
       cmds = [];
       this.commandsByKey.set(key, cmds);
     }
-    if (cmd.type === "set") {
+    if (cmd.type === "reset") {
       cmds.length = 0;
       cmds.push(cmd);
-    } else if (cmds.length > 0 && cmds[0].type === "set") {
-      const slots = this.getSlotsByKey(key);
-      cmds[0] = this.createSetCommand(slots);
+    } else if (cmds.length > 0 && cmds[0].type === "reset") {
+      cmds[0] = this.createResetCommand(this.getSlotsByKey(key));
     } else {
       cmds.push(cmd);
     }
     this.commandsEventEmitter.markUpdatedKeys([key]);
   }
-  appendSetCommand(key, slots) {
-    this.appendCommand(key, this.createSetCommand(slots));
+  appendResetCommand(key, slots) {
+    this.appendCommand(key, this.createResetCommand(slots));
   }
-  createSetCommand(slots) {
-    return {
-      type: "set",
-      pks: slots.map((slot) => slot.pk),
-      slots
-    };
+  createResetCommand(slots) {
+    return { type: "reset", items: slots };
   }
 };
 
@@ -1695,12 +1753,7 @@ var OIMCollectionOrderedListCommandStream = class extends OIMOrderedListCommandS
     this.withWrite(() => {
       const slot = this.resolvePk(pk);
       const index = this.index.pushSlot(key, slot);
-      this.appendCommand(key, {
-        type: "insert",
-        pk,
-        slot,
-        index
-      });
+      this.appendCommand(key, { type: "insert", index, item: slot });
     });
   }
   insertAt(key, index, pk) {
@@ -1709,9 +1762,21 @@ var OIMCollectionOrderedListCommandStream = class extends OIMOrderedListCommandS
       const safeIndex = this.index.insertSlotAt(key, index, slot);
       this.appendCommand(key, {
         type: "insert",
-        pk,
-        slot,
-        index: safeIndex
+        index: safeIndex,
+        item: slot
+      });
+    });
+  }
+  /** Replace the element at `index` with the slot for `pk`, in place. */
+  setAt(key, index, pk) {
+    this.withWrite(() => {
+      const slot = this.resolvePk(pk);
+      const safeIndex = this.index.setSlotAt(key, index, slot);
+      if (safeIndex < 0) return;
+      this.appendCommand(key, {
+        type: "set",
+        index: safeIndex,
+        item: slot
       });
     });
   }
@@ -1719,7 +1784,7 @@ var OIMCollectionOrderedListCommandStream = class extends OIMOrderedListCommandS
     this.withWrite(() => {
       const slots = pks.map((pk) => this.resolvePk(pk));
       this.index.resetSlots(key, slots);
-      this.appendSetCommand(key, slots);
+      this.appendResetCommand(key, slots);
     });
   }
   getSlotsByKey(key) {
@@ -2635,48 +2700,23 @@ var OIMEventQueue = class {
     }
   }
   /**
-   * Enqueue a one-shot task to be executed on the next flush.
-   * Returns a dequeue function that can be called to cancel the task before it runs.
+   * Enqueue a one-shot task to run on the next flush. The function is stored
+   * directly (no wrapper, no returned closure) and cancelled via {@link cancel}
+   * by passing the same reference. Enqueuing the same reference twice is
+   * idempotent — it is Set-deduped and runs once per flush.
    */
   enqueue(fn) {
-    let isActive = true;
-    const task = () => {
-      if (!isActive) return;
-      fn();
-    };
-    this.tasks.add(task);
-    this.ensureScheduled();
-    return () => {
-      if (!isActive) return;
-      isActive = false;
-      this.tasks.delete(task);
-    };
-  }
-  /**
-   * Allocation-free enqueue for a **stable** function reference (e.g. a bound
-   * `onFlush` method). The function is stored directly — no wrapper, no
-   * returned closure — and cancelled via {@link cancelTask}. Enqueuing the
-   * same reference twice is idempotent (Set-deduped); callers that may run a
-   * task more than once per flush should use {@link enqueue} instead.
-   */
-  enqueueTask(fn) {
     this.tasks.add(fn);
     this.ensureScheduled();
   }
-  /** Cancel a task scheduled via {@link enqueueTask}; safe to call mid-flush. */
-  cancelTask(fn) {
+  /** Cancel a previously enqueued task by its reference; safe to call mid-flush. */
+  cancel(fn) {
     this.tasks.delete(fn);
     this.flushing?.delete(fn);
   }
   get isInFlush() {
     return this.isFlushing;
   }
-  /**
-   * Dequeue (cancel) a previously enqueued task by its dequeue function.
-   */
-  dequeue(dequeueFn) {
-    dequeueFn();
-  }
   /**
    * Execute all pending tasks.
    *
@@ -3323,20 +3363,27 @@ var OIMCollectionChangedFields = class {
   constructor(queue, collection, opts) {
     this.isInWrite = false;
     this.lastEntitySnapshotByPk = /* @__PURE__ */ new Map();
+    // PKs written through this wrapper during the current flush. Their fields are
+    // already tracked accurately via trackPatch, so the flush-time external-write
+    // handler skips them — no redundant diff + snapshot re-clone. Cleared per flush.
+    this.writtenThroughThisFlush = /* @__PURE__ */ new Set();
     this.changedFieldsByPk = /* @__PURE__ */ new Map();
     this.changedPksByField = /* @__PURE__ */ new Map();
     this.onAfterFlush = () => {
       this.clear();
+      this.writtenThroughThisFlush.clear();
     };
     this.onCollectionUpdate = (payload) => {
       if (this.isInWrite) return;
       if (payload.pks.length === 0) return;
       for (let i = 0; i < payload.pks.length; i++) {
         const pk = payload.pks[i];
+        if (this.writtenThroughThisFlush.has(pk)) continue;
         this.trackExternalMutationByPk(pk);
       }
     };
     this.collection = collection;
+    this.detectExternalMutations = opts?.detectExternalMutations !== false;
     this.selectPk = opts?.selectPk ?? (() => {
       throw new Error(
         `[OIMCollectionChangedFields]: selectPk was not provided. Use upsertOneByPk(...) or pass opts.selectPk.`
@@ -3351,15 +3398,17 @@ var OIMCollectionChangedFields = class {
       0 /* AFTER_FLUSH */,
       this.onAfterFlush
     );
-    const maybeReactive = collection;
-    this.unsubscribeFromCollectionEmitter = maybeReactive.subscribeOnAnyUpdate ? maybeReactive.subscribeOnAnyUpdate((pks) => {
-      this.onCollectionUpdate({
-        pks
-      });
-    }) : collection.emitter.on(
-      0 /* UPDATE */,
-      this.onCollectionUpdate
-    );
+    if (this.detectExternalMutations) {
+      const maybeReactive = collection;
+      this.unsubscribeFromCollectionEmitter = maybeReactive.subscribeOnAnyUpdate ? maybeReactive.subscribeOnAnyUpdate((pks) => {
+        this.onCollectionUpdate({
+          pks
+        });
+      }) : collection.emitter.on(
+        0 /* UPDATE */,
+        this.onCollectionUpdate
+      );
+    }
   }
   upsertOneByPk(pk, patch) {
     const slot = this.withWrite(() => {
@@ -3415,7 +3464,7 @@ var OIMCollectionChangedFields = class {
     this.changedPksEventEmitter.destroy();
     this.changedFieldsEventEmitter.destroy();
     this.unsubscribeAfterFlush();
-    this.unsubscribeFromCollectionEmitter();
+    this.unsubscribeFromCollectionEmitter?.();
     this.clear();
   }
   withWrite(fn) {
@@ -3457,6 +3506,8 @@ var OIMCollectionChangedFields = class {
     return changed;
   }
   updateEntitySnapshot(pk) {
+    if (!this.detectExternalMutations) return;
+    this.writtenThroughThisFlush.add(pk);
     const entity = this.collection.getOneByPk(pk);
     if (!entity) {
       this.lastEntitySnapshotByPk.delete(pk);
@@ -4140,6 +4191,7 @@ export {
   OIMReactiveObject,
   OIMSelector,
   createInPlaceEntityUpdater,
+  createMergeEntityUpdater,
   createOIMCollectionIndexFactory,
   createOIMCollectionKit
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oimdb/core",
-  "version": "3.2.0",
+  "version": "3.4.0",
   "description": "Core in-memory data library with type-safe indices, reactive subscriptions, and event processing",
   "type": "module",
   "main": "./dist/index.cjs",