@mmstack/primitives 22.8.0 → 22.8.1

package/fesm2022/mmstack-primitives.mjs

@@ -4385,12 +4385,9 @@ function invertBatch(batch) {
         if (op.kind === 'clear')
             continue;
         if (op.kind === 'delete') {
-            inverted.push({
-                kind: 'set',
-                path: op.path,
-                next: op.prev,
-                prev: undefined,
-            });
+            // no `prev`: the key is ABSENT once the delete applied, so this inverse is an add —
+            // inverting it again yields the delete back (redo removes the key, not sets undefined)
+            inverted.push({ kind: 'set', path: op.path, next: op.prev });
             continue;
         }
         if (!Object.hasOwn(op, 'prev')) {
@@ -6233,6 +6230,8 @@ function evenPositions(n) {
     return out;
 }
 
+const PATH_SEP = '';
+const OP_SEP = '';
 /**
  * Undo/redo for a copy-on-write store, built on the op-log: each tracked change is stored as
  * its inverse batch, so `undo()` is one `apply` and history costs only the diffs, not full
@@ -6241,21 +6240,54 @@ function evenPositions(n) {
  *
  * Composes with sync for collaborative undo: pass `track: syncClient` so only YOUR writes are
  * undoable, while `undo()` emits a normal op that propagates to peers (it writes through the
- * store, which the sync client picks up).
+ * store, which the sync client picks up). Coalescing groups only this stack's entries — what
+ * goes over the wire is untouched.
  */
 function storeHistory(source, opt) {
     const limit = opt?.limit ?? 100;
+    const coalesce = opt?.coalesce;
+    const now = opt?.now ?? Date.now;
     const logOpt = { origin: opt?.origin };
     if (opt?.driver)
         logOpt.driver = opt.driver;
     else
-        logOpt.injector = opt?.injector ?? inject(Injector);
+        logOpt.injector =
+            opt?.injector ?? inject(Injector);
     const log = opLog(source, logOpt);
     const undoStack = [];
     const redoStack = [];
     const version = signal(0, /* @ts-ignore */
     ...(ngDevMode ? [{ debugName: "version" }] : /* istanbul ignore next */ [])); // monotonic: bumps on every mutation so the computeds recompute
     let applying = false;
+    let runOpen = false;
+    let lastAt = 0;
+    let lastSig = '';
+    const sigOf = (ops) => ops.map((o) => `${o.kind}:${o.path.join(PATH_SEP)}`).join(OP_SEP);
+    const mergeInto = (entry, incoming) => {
+        const merged = [...entry];
+        const rest = [];
+        for (const inc of incoming) {
+            const key = inc.path.join(PATH_SEP);
+            const at = merged.findIndex((o) => o.path.join(PATH_SEP) === key);
+            const cur = at >= 0 ? merged[at] : undefined;
+            if (cur && cur.kind === 'set' && inc.kind === 'set') {
+                const composed = {
+                    kind: 'set',
+                    path: cur.path,
+                    next: cur.next,
+                };
+                // absent `prev` means the composed inverse is an add (inverts to a delete): the newest
+                // forward op removed the key, so redo must remove it again
+                if (Object.hasOwn(inc, 'prev'))
+                    composed.prev = inc.prev;
+                merged[at] = composed;
+            }
+            else {
+                rest.push(inc);
+            }
+        }
+        return rest.length ? [...rest, ...merged] : merged;
+    };
     const push = (stack, inverse) => {
         stack.push(inverse);
         if (stack.length > limit)
@@ -6266,20 +6298,39 @@ function storeHistory(source, opt) {
             return; // an undo/redo's own emission must not re-enter history
         if (!batch.ops.length)
             return;
-        push(undoStack, invertBatch(batch));
+        const inverse = invertBatch(batch);
+        const at = now();
+        const sig = coalesce ? sigOf(batch.ops) : '';
+        if (coalesce &&
+            runOpen &&
+            undoStack.length > 0 &&
+            at - lastAt <= coalesce.ms &&
+            (coalesce.samePath === false || sig === lastSig)) {
+            undoStack[undoStack.length - 1] = mergeInto(undoStack[undoStack.length - 1], inverse);
+        }
+        else {
+            push(undoStack, inverse);
+        }
+        runOpen = true;
+        lastAt = at;
+        lastSig = sig;
         redoStack.length = 0; // a fresh edit forks the timeline
         version.update((v) => v + 1);
     };
     // track the sync client's local stream when given, else self-diff every store change
     const unsub = (opt?.track ?? log).subscribe(record);
+    const flushTrack = () => opt?.track?.flush?.();
     const run = (from, to) => {
+        flushTrack();
+        log.flush();
         const inverse = from.pop();
         if (!inverse)
             return;
-        log.flush(); // settle pending local writes before applying
+        runOpen = false; // stepping through history is a boundary: the next edit starts fresh
         applying = true;
         try {
             log.apply(inverse);
+            flushTrack();
         }
         finally {
             applying = false;
@@ -6292,7 +6343,11 @@ function storeHistory(source, opt) {
         canRedo: computed(() => (version(), redoStack.length > 0)),
         undo: () => run(undoStack, redoStack),
         redo: () => run(redoStack, undoStack),
+        checkpoint: () => {
+            runOpen = false;
+        },
         clear: () => {
+            runOpen = false;
             undoStack.length = 0;
             redoStack.length = 0;
             version.update((v) => v + 1);