@storacha/md-merge 0.7.0 → 0.8.0

package/dist/diff.js

@@ -109,14 +109,19 @@ function diffGap(oldNodes, newNodes, oldStartIdx, newStartIdx, pathPrefix) {
         });
         oi++;
     }
-    // Remaining new = inserts
-    while (ni < newNodes.length) {
+    // Remaining new = inserts (batched into a single change)
+    if (ni < newNodes.length) {
+        const insertNodes = [];
+        const insertIdx = newStartIdx + ni;
+        while (ni < newNodes.length) {
+            insertNodes.push(newNodes[ni]);
+            ni++;
+        }
         changes.push({
             type: "insert",
-            path: [...pathPrefix, newStartIdx + ni],
-            nodes: [newNodes[ni]],
+            path: [...pathPrefix, insertIdx],
+            nodes: insertNodes,
         });
-        ni++;
     }
     return changes;
 }

package/dist/rga-tree.js

@@ -189,18 +189,20 @@ export function applyRGAChangeSet(root, changeset, compareEvents) {
                 break;
             }
             case "insert": {
+                let afterId = change.afterId;
                 for (const node of change.nodes ?? []) {
                     const rgaNode = convertNode(node, changeset.event, compareEvents);
-                    currentRGA.insert(change.afterId, rgaNode, changeset.event);
+                    afterId = currentRGA.insert(afterId, rgaNode, changeset.event);
                 }
                 break;
             }
             case "modify": {
                 if (change.targetId)
                     currentRGA.delete(change.targetId);
+                let afterId = change.afterId;
                 for (const node of change.nodes ?? []) {
                     const rgaNode = convertNode(node, changeset.event, compareEvents);
-                    currentRGA.insert(change.afterId, rgaNode, changeset.event);
+                    afterId = currentRGA.insert(afterId, rgaNode, changeset.event);
                 }
                 break;
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@storacha/md-merge",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/diff.ts

@@ -131,14 +131,19 @@ function diffGap(
     });
     oi++;
   }
-  // Remaining new = inserts
-  while (ni < newNodes.length) {
+  // Remaining new = inserts (batched into a single change)
+  if (ni < newNodes.length) {
+    const insertNodes: RootContent[] = [];
+    const insertIdx = newStartIdx + ni;
+    while (ni < newNodes.length) {
+      insertNodes.push(newNodes[ni] as RootContent);
+      ni++;
+    }
     changes.push({
       type: "insert",
-      path: [...pathPrefix, newStartIdx + ni],
-      nodes: [newNodes[ni] as RootContent],
+      path: [...pathPrefix, insertIdx],
+      nodes: insertNodes,
     });
-    ni++;
   }
   return changes;
 }

package/src/rga-tree.ts

@@ -272,25 +272,27 @@ export function applyRGAChangeSet<E extends RGAEvent>(
         break;
       }
       case "insert": {
+        let afterId = change.afterId;
         for (const node of change.nodes ?? []) {
           const rgaNode = convertNode(
             node as Node,
             changeset.event,
             compareEvents,
           );
-          currentRGA.insert(change.afterId, rgaNode, changeset.event);
+          afterId = currentRGA.insert(afterId, rgaNode, changeset.event);
         }
         break;
       }
       case "modify": {
         if (change.targetId) currentRGA.delete(change.targetId);
+        let afterId = change.afterId;
         for (const node of change.nodes ?? []) {
           const rgaNode = convertNode(
             node as Node,
             changeset.event,
             compareEvents,
           );
-          currentRGA.insert(change.afterId, rgaNode, changeset.event);
+          afterId = currentRGA.insert(afterId, rgaNode, changeset.event);
         }
         break;
       }

package/test/rga-tree.test.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect } from "vitest";
 import { parse, stringify } from "../src/parse.js";
-import { toRGATree, toMdast, applyMdastToRGATree, mergeRGATrees } from "../src/rga-tree.js";
+import { toRGATree, toMdast, applyMdastToRGATree, mergeRGATrees, applyRGAChangeSet } from "../src/rga-tree.js";
 import {
   RGA,
   type RGAEvent,
@@ -321,3 +321,129 @@ describe("mergeRGATrees", () => {
     expect(tree2.children.nodes.size).toBe(origSize2);
   });
 });
+
+describe("multi-append", () => {
+  it("handles appending multiple nodes at once", () => {
+    const oldMd = "# Hello\n\nOriginal.\n";
+    const newMd = "# Hello\n\nOriginal.\n\nSecond.\n\nThird.\n";
+    const oldRoot = parse(oldMd);
+    const newRoot = parse(newMd);
+    const tree = toRGATree(oldRoot, r1, cmp);
+
+    const r2 = new TestEvent("r2");
+    const updated = applyMdastToRGATree(tree, newRoot, r2, cmp);
+    const result = stringify(toMdast(updated));
+
+    expect(result).toContain("Original.");
+    expect(result).toContain("Second.");
+    expect(result).toContain("Third.");
+    // Verify order is preserved
+    const origIdx = result.indexOf("Original.");
+    const secIdx = result.indexOf("Second.");
+    const thirdIdx = result.indexOf("Third.");
+    expect(origIdx).toBeLessThan(secIdx);
+    expect(secIdx).toBeLessThan(thirdIdx);
+  });
+
+  it("handles appending to an empty children array", () => {
+    const oldMd = "";
+    const newMd = "# Hello\n\nWorld.\n";
+    const oldRoot = parse(oldMd);
+    const newRoot = parse(newMd);
+    const tree = toRGATree(oldRoot, r1, cmp);
+
+    const r2 = new TestEvent("r2");
+    const updated = applyMdastToRGATree(tree, newRoot, r2, cmp);
+    const result = stringify(toMdast(updated));
+
+    expect(result).toContain("Hello");
+    expect(result).toContain("World.");
+  });
+});
+
+describe("applyRGAChangeSet multi-node", () => {
+  const r2 = new TestEvent("r2");
+
+  it("insert with multiple nodes preserves order", () => {
+    const tree = toRGATree(parse("# Hello\n"), r1, cmp);
+    const afterId = tree.children.toNodes()[0].id; // after the heading
+
+    const changeset = {
+      event: r2,
+      changes: [{
+        type: "insert" as const,
+        parentPath: [],
+        afterId,
+        nodes: [
+          { type: "paragraph", children: [{ type: "text", value: "First" }] },
+          { type: "paragraph", children: [{ type: "text", value: "Second" }] },
+          { type: "paragraph", children: [{ type: "text", value: "Third" }] },
+        ] as any,
+      }],
+    };
+
+    const result = applyRGAChangeSet(tree, changeset, cmp);
+    const md = stringify(toMdast(result));
+
+    expect(md).toContain("First");
+    expect(md).toContain("Second");
+    expect(md).toContain("Third");
+    expect(md.indexOf("First")).toBeLessThan(md.indexOf("Second"));
+    expect(md.indexOf("Second")).toBeLessThan(md.indexOf("Third"));
+  });
+
+  it("modify with multiple replacement nodes preserves order", () => {
+    const tree = toRGATree(parse("# Hello\n\nOriginal.\n"), r1, cmp);
+    const nodes = tree.children.toNodes();
+    const targetId = nodes[1].id; // the paragraph
+    const afterId = nodes[0].id; // after the heading
+
+    const changeset = {
+      event: r2,
+      changes: [{
+        type: "modify" as const,
+        parentPath: [],
+        targetId,
+        afterId,
+        nodes: [
+          { type: "paragraph", children: [{ type: "text", value: "Replacement A" }] },
+          { type: "paragraph", children: [{ type: "text", value: "Replacement B" }] },
+        ] as any,
+      }],
+    };
+
+    const result = applyRGAChangeSet(tree, changeset, cmp);
+    const md = stringify(toMdast(result));
+
+    expect(md).not.toContain("Original.");
+    expect(md).toContain("Replacement A");
+    expect(md).toContain("Replacement B");
+    expect(md.indexOf("Replacement A")).toBeLessThan(md.indexOf("Replacement B"));
+  });
+
+  it("insert at start (no afterId) with multiple nodes preserves relative order", () => {
+    // Insert two nodes at root with no afterId. RGA ordering means they
+    // appear after existing r1 nodes (r2 > r1), but their relative order
+    // (A before B) is preserved via chained afterIds.
+    const tree = toRGATree(parse("# Existing\n"), r1, cmp);
+
+    const changeset = {
+      event: r2,
+      changes: [{
+        type: "insert" as const,
+        parentPath: [],
+        afterId: undefined,
+        nodes: [
+          { type: "paragraph", children: [{ type: "text", value: "Added A" }] },
+          { type: "paragraph", children: [{ type: "text", value: "Added B" }] },
+        ] as any,
+      }],
+    };
+
+    const result = applyRGAChangeSet(tree, changeset, cmp);
+    const md = stringify(toMdast(result));
+
+    // Relative order of the inserted nodes is preserved
+    expect(md.indexOf("Added A")).toBeLessThan(md.indexOf("Added B"));
+  });
+});