@magic-marker/prosemirror-suggest-changes 0.3.3-wrap-unwrap.13 → 0.3.3-wrap-unwrap.14

package/dist/__tests__/playwrightHelpers.d.ts

@@ -140,9 +140,9 @@ export declare function assertReverted(finalState: EditorState, initialState: Ed
  * This helper replaces the editor document with the provided JSON,
  * clears transactions, and returns initial state.
  */
-export declare function setupDocFromJSON(page: Page, docJSON: unknown): Promise<{
+export declare function setupDocFromJSON(page: Page, docJSON: object): Promise<{
     initialState: EditorState;
-    initialDoc: unknown;
+    initialDoc: object;
 }>;
 /**
  * Assert that document fully reverted to initial state.

package/dist/features/joinOnDelete/index.js

@@ -2,6 +2,7 @@ import { Mark } from "prosemirror-model";
 import { canJoin, Transform } from "prosemirror-transform";
 import { ZWSP } from "../../constants.js";
 import { getSuggestionMarks } from "../../utils.js";
+import { guardStructureMarkAttrs } from "../wrapUnwrap/types.js";
 export function isJoinMarkAttrs(attrs) {
     if (attrs["type"] !== "join") return false;
     if (attrs["data"] == null) return false;
@@ -94,7 +95,9 @@ export function maybeRevertJoinMark(tr, from, to, node, markType) {
             attrs: $endOfNode.nodeAfter.attrs,
             marks: $endOfNode.nodeAfter.marks.map((mark)=>mark.toJSON())
         };
+        const shouldSuppressJoinMark = hasStructureAddMark($endOfNode.nodeBefore) || hasStructureAddMark($endOfNode.nodeAfter);
         transform.join(mappedEndOfNode);
+        if (shouldSuppressJoinMark) return false;
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
         const joinStep = transform.steps[transform.steps.length - 1];
         const joinPos = joinStep.getMap().map(mappedEndOfNode);
@@ -111,6 +114,14 @@ export function maybeRevertJoinMark(tr, from, to, node, markType) {
     });
     return transform;
 }
+function hasStructureAddMark(node) {
+    const { structure } = getSuggestionMarks(node.type.schema);
+    return node.marks.some((mark)=>{
+        if (mark.type !== structure) return false;
+        if (!guardStructureMarkAttrs(mark.attrs)) return false;
+        return mark.attrs.data.op.op === "add";
+    });
+}
 /**
  * Find ZWSP nodes marked as insertions and deletions with the same mark id
  * Delete them from the given range

package/dist/features/wrapUnwrap/__tests__/splitDetection.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/features/wrapUnwrap/buildMaterializedPaths.js

@@ -30,6 +30,7 @@ export function buildMaterializedPaths(doc) {
         };
         paths.set(nodeId, {
             nodeType: node.type.name,
+            node,
             chain: [
                 parent
             ]
@@ -71,6 +72,7 @@ export function buildMaterializedPaths(doc) {
         ];
         paths.set(nodeId, {
             nodeType: node.type.name,
+            node,
             chain
         });
         return true;

package/dist/features/wrapUnwrap/structureChangesPlugin.d.ts

@@ -4,11 +4,14 @@ import { type SuggestionId } from "../../generateId.js";
 import { type StructuralContextPath } from "./types.js";
 import { Transform } from "prosemirror-transform";
 export declare const structureChangesKey: PluginKey<any>;
+export type SuggestStructureChangesReason = "split-derived-add";
+export interface SuggestStructureChangesResult {
+    handled: boolean;
+    transform: Transform;
+    reason?: SuggestStructureChangesReason;
+}
 export declare function structureChangesPlugin(generateId?: (schema: Schema, doc?: Node) => SuggestionId, opts?: {
     experimental_trackStructures?: StructuralContextPath[];
 }): Plugin<any>;
-export declare function suggestStructureChanges(docBefore: Node, docAfter: Node, structuralContextPaths: StructuralContextPath[], generateId?: (schema: Schema, doc?: Node) => SuggestionId): {
-    handled: boolean;
-    transform: Transform;
-};
+export declare function suggestStructureChanges(docBefore: Node, docAfter: Node, structuralContextPaths: StructuralContextPath[], generateId?: (schema: Schema, doc?: Node) => SuggestionId): SuggestStructureChangesResult;
 export declare function getRequiredStructuralContextPaths(structuralContextPaths: StructuralContextPath[] | undefined): StructuralContextPath[];

package/dist/features/wrapUnwrap/structureChangesPlugin.js

@@ -112,11 +112,19 @@ export function suggestStructureChanges(docBefore, docAfter, structuralContextPa
         pathsBefore: Object.fromEntries(pathsBefore.entries()),
         pathsAfter: Object.fromEntries(pathsAfter.entries())
     });
-    const ops = getOps(pathsBefore, pathsAfter, structuralContextPaths);
+    const { ops, reason } = getOps(pathsBefore, pathsAfter, structuralContextPaths);
     trace("suggestStructureChanges", "ops", {
-        ops: Object.fromEntries(ops.entries())
+        ops: Object.fromEntries(ops.entries()),
+        reason
     });
     const transform = new Transform(docAfter);
+    if (reason) {
+        return {
+            handled: false,
+            transform,
+            reason
+        };
+    }
     addMarks(ops, transform, suggestionId);
     return {
         handled: ops.size > 0,
@@ -206,13 +214,22 @@ function getOps(beforePaths, afterPaths, structuralContextPaths) {
         const hasStructuralContext = chainHasStructuralContext(afterPath.chain, structuralContextPaths);
         // node is outside configured structural contexts
         if (!hasStructuralContext) continue;
+        // detect block split - if detected, bail out, and let the main plugin handle it
+        if (isSplitDerivedAdd(id, beforePaths, afterPaths, contextNodeTypes)) {
+            return {
+                ops: new Map(),
+                reason: "split-derived-add"
+            };
+        }
         // node was added
         const op = {
             op: "add"
         };
         ops.set(id, op);
     }
-    return ops;
+    return {
+        ops
+    };
 }
 function getStructuralContextNodeTypes(structuralContextPaths) {
     return new Set(structuralContextPaths.flat());
@@ -233,3 +250,45 @@ function containsContiguousPath(chainNodeTypes, structuralContextPath) {
     }
     return false;
 }
+// detect block split - try to look at the node above, concatenate two text contents,
+// and see if it combines into a single node in the old document
+function isSplitDerivedAdd(newNodeId, beforePaths, afterPaths, contextNodeTypes) {
+    const newNode = afterPaths.get(newNodeId)?.node;
+    if (!newNode || newNode.textContent === "") return false;
+    if (matchesSplitDerivedPair(newNodeId, newNode.textContent, beforePaths, afterPaths)) {
+        return true;
+    }
+    const afterPath = afterPaths.get(newNodeId);
+    if (!afterPath) return false;
+    for (const parent of afterPath.chain){
+        if (parent.nodeType === DOC_NODE_ID) continue;
+        if (!contextNodeTypes.has(parent.nodeType)) continue;
+        const parentNode = afterPaths.get(parent.nodeId)?.node;
+        if (!parentNode || parentNode.textContent === "") continue;
+        if (matchesSplitDerivedPair(parent.nodeId, parentNode.textContent, beforePaths, afterPaths)) {
+            return true;
+        }
+    }
+    return false;
+}
+function matchesSplitDerivedPair(rightNodeId, rightText, beforePaths, afterPaths) {
+    const rightPath = afterPaths.get(rightNodeId);
+    const previousSiblingId = rightPath?.chain[0]?.childSiblingIds[0];
+    if (!previousSiblingId) return false;
+    const previousBefore = beforePaths.has(previousSiblingId) ? beforePaths.get(previousSiblingId)?.node : null;
+    const previousAfter = afterPaths.has(previousSiblingId) ? afterPaths.get(previousSiblingId)?.node : null;
+    if (!previousBefore || !previousAfter) return false;
+    if (hasStructureAddMarkInSubtree(previousBefore)) return false;
+    return previousBefore.textContent === previousAfter.textContent + rightText;
+}
+function hasStructureAddMarkInSubtree(node) {
+    if (hasStructureAddMark(node)) return true;
+    let found = false;
+    node.descendants((descendant)=>{
+        if (descendant.isText) return false;
+        if (!hasStructureAddMark(descendant)) return true;
+        found = true;
+        return false;
+    });
+    return found;
+}

package/dist/features/wrapUnwrap/types.d.ts

@@ -1,4 +1,4 @@
-import { type Attrs } from "prosemirror-model";
+import { type Attrs, type Node } from "prosemirror-model";
 import { type SuggestionId } from "../../generateId.js";
 import { DOC_NODE_ID } from "./constants.js";
 interface NodeParent {
@@ -33,6 +33,7 @@ export type Op = MoveOp | AddOp;
 export type MaterializedPaths = Map<string, {
     chain: Parent[];
     nodeType: string;
+    node: Node;
 }>;
 export declare function guardDocParent(parent: Parent | undefined): parent is DocParent;
 export declare function guardStructureMarkAttrs(attrs: Attrs): attrs is StructureMarkAttrs;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@magic-marker/prosemirror-suggest-changes",
-  "version": "0.3.3-wrap-unwrap.13",
+  "version": "0.3.3-wrap-unwrap.14",
   "license": "MIT",
   "type": "module",
   "module": "dist/index.js",