@magic-marker/prosemirror-suggest-changes 0.4.0 → 0.4.1-wrap-unwrap.2

package/dist/features/ensureValidSelection/ensureSelectionPlugin.test.js

@@ -0,0 +1,112 @@
+import { EditorState, NodeSelection, TextSelection } from "prosemirror-state";
+import { assert, describe, it } from "vitest";
+import { ZWSP } from "../../constants.js";
+import { testBuilders } from "../../testing/testBuilders.js";
+import { ensureSelection } from "./ensureSelectionPlugin.js";
+function createState(doc, selection) {
+    return EditorState.create({
+        doc,
+        selection,
+        plugins: [
+            ensureSelection()
+        ]
+    });
+}
+function applyTextSelection(state, anchor, head = anchor) {
+    const selection = TextSelection.create(state.doc, anchor, head);
+    const transaction = state.tr.setSelection(selection);
+    return state.apply(transaction);
+}
+function assertTextSelection(state, anchor, head = anchor) {
+    assert(state.selection instanceof TextSelection);
+    assert.equal(state.selection.anchor, anchor);
+    assert.equal(state.selection.head, head);
+}
+function getTag(doc, tag) {
+    const pos = doc.tag[tag];
+    assert(pos !== undefined, `Expected tag "${tag}" to exist`);
+    return pos;
+}
+describe("ensureSelection", ()=>{
+    it("leaves valid text selections unchanged", ()=>{
+        const doc = testBuilders.doc(testBuilders.paragraph("one<from>"), testBuilders.paragraph("two<to>"));
+        const state = createState(doc, TextSelection.create(doc, getTag(doc, "from")));
+        const nextState = applyTextSelection(state, getTag(doc, "to"));
+        assertTextSelection(nextState, getTag(doc, "to"));
+    });
+    it("ignores non-text selections", ()=>{
+        const doc = testBuilders.doc(testBuilders.image({
+            src: "https://example.com/image.png"
+        }), testBuilders.paragraph("after<cursor>"));
+        const state = createState(doc, TextSelection.create(doc, getTag(doc, "cursor")));
+        const nextState = state.apply(state.tr.setSelection(NodeSelection.create(doc, 0)));
+        assert(nextState.selection instanceof NodeSelection);
+        assert.equal(nextState.selection.anchor, 0);
+    });
+    it("prefers a valid position in the destination textblock for selection-only movement", ()=>{
+        const doc = testBuilders.doc(testBuilders.paragraph("Item 2<old>"), testBuilders.paragraph(testBuilders.insertion({
+            id: 1
+        }, "<invalid>" + ZWSP + "<valid>")), testBuilders.paragraph(testBuilders.insertion({
+            id: 1
+        }, ZWSP), "Item 3"));
+        const state = createState(doc, TextSelection.create(doc, getTag(doc, "old")));
+        const nextState = applyTextSelection(state, getTag(doc, "invalid"));
+        assertTextSelection(nextState, getTag(doc, "valid"));
+    });
+    it("uses direction fallback when the transaction changes the document", ()=>{
+        const doc = testBuilders.doc(testBuilders.paragraph("<markStart>A<expected><markEnd>"), testBuilders.paragraph(testBuilders.insertion({
+            id: 1
+        }, "<invalid>" + ZWSP + "<sameParent>")), testBuilders.paragraph(testBuilders.insertion({
+            id: 1
+        }, ZWSP), "<old>Item 3"));
+        const state = createState(doc, TextSelection.create(doc, getTag(doc, "old")));
+        const transaction = state.tr;
+        transaction.addMark(getTag(doc, "markStart"), getTag(doc, "markEnd"), testBuilders.schema.marks.strong.create());
+        transaction.setSelection(TextSelection.create(transaction.doc, getTag(doc, "invalid")));
+        const nextState = state.apply(transaction);
+        assertTextSelection(nextState, getTag(doc, "expected"));
+    });
+    it("uses direction fallback for invalid positions in the same textblock", ()=>{
+        const doc = testBuilders.doc(testBuilders.paragraph("A", testBuilders.deletion({
+            id: 1
+        }, "<expected>B<invalid>"), "C<old>"));
+        const state = createState(doc, TextSelection.create(doc, getTag(doc, "old")));
+        const nextState = applyTextSelection(state, getTag(doc, "invalid"));
+        assertTextSelection(nextState, getTag(doc, "expected"));
+    });
+    it("keeps deletion anchor and non-anchor deletion positions continuous", ()=>{
+        const doc = testBuilders.doc(testBuilders.paragraph(testBuilders.deletion({
+            id: 1,
+            type: "anchor"
+        }, "<expected>" + ZWSP + "<invalid>"), testBuilders.deletion({
+            id: 1
+        }, "deleted"), "visible<old>"));
+        const state = createState(doc, TextSelection.create(doc, getTag(doc, "old")));
+        const nextState = applyTextSelection(state, getTag(doc, "invalid"));
+        assertTextSelection(nextState, getTag(doc, "expected"));
+    });
+    it("moves hidden-deletion-style boundary positions to visible content", ()=>{
+        const doc = testBuilders.doc(testBuilders.paragraph("before<old>"), testBuilders.paragraph(testBuilders.deletion({
+            id: 1
+        }, "<invalid>deleted"), "v<expected>isible"));
+        const state = createState(doc, TextSelection.create(doc, getTag(doc, "old")));
+        const nextState = applyTextSelection(state, getTag(doc, "invalid"));
+        assertTextSelection(nextState, getTag(doc, "expected"));
+    });
+    it("keeps paired split marker positions attached to textblock boundaries", ()=>{
+        const doc = testBuilders.doc(testBuilders.paragraph("before<old>"), testBuilders.paragraph("content<expected>", testBuilders.insertion({
+            id: 1
+        }, ZWSP + "<invalid>")));
+        const state = createState(doc, TextSelection.create(doc, getTag(doc, "old")));
+        const nextState = applyTextSelection(state, getTag(doc, "invalid"));
+        assertTextSelection(nextState, getTag(doc, "expected"));
+    });
+    it("moves positions between adjacent insertion ZWSPs to a valid neighbor", ()=>{
+        const doc = testBuilders.doc(testBuilders.paragraph("before<old>", testBuilders.insertion({
+            id: 1
+        }, "<expected>" + ZWSP + "<invalid>" + ZWSP), "<valid>after"));
+        const state = createState(doc, TextSelection.create(doc, getTag(doc, "old")));
+        const nextState = applyTextSelection(state, getTag(doc, "invalid"));
+        assertTextSelection(nextState, getTag(doc, "valid"));
+    });
+});

package/dist/features/ensureValidSelection/selectionPosition.d.ts

@@ -0,0 +1,3 @@
+import { type ResolvedPos } from "prosemirror-model";
+export type InvalidSelectionPositionReason = "not-in-inline-content" | "between-deletion-anchor-and-non-anchor-deletion" | "between-two-non-anchor-deletions" | "between-node-boundary-and-non-anchor-deletion" | "between-non-anchor-deletion-and-node-boundary" | "between-non-anchor-deletion-and-anything" | "between-two-zwsp-insertions" | "between-zwsp-insertion-and-right-node-boundary" | "between-zwsp-insertion-and-left-node-boundary";
+export declare function getInvalidSelectionPositionReason($pos: ResolvedPos): InvalidSelectionPositionReason | null;

package/dist/features/ensureValidSelection/selectionPosition.js

@@ -0,0 +1,50 @@
+import { ZWSP } from "../../constants.js";
+import { getSuggestionMarks } from "../../utils.js";
+export function getInvalidSelectionPositionReason($pos) {
+    // Text selection is only valid in nodes that allow inline content.
+    // https://github.com/ProseMirror/prosemirror-state/blob/1.4.4/src/selection.ts#L219
+    if (!$pos.parent.inlineContent) {
+        return "not-in-inline-content";
+    }
+    const { deletion, insertion } = getSuggestionMarks($pos.doc.type.schema);
+    const deletionBefore = deletion.isInSet($pos.nodeBefore?.marks ?? []);
+    const deletionAfter = deletion.isInSet($pos.nodeAfter?.marks ?? []);
+    const isAnchorBefore = deletionBefore && deletionBefore.attrs["type"] === "anchor";
+    const isAnchorAfter = deletionAfter && deletionAfter.attrs["type"] === "anchor";
+    if (isAnchorBefore && deletionAfter && !isAnchorAfter) {
+        return "between-deletion-anchor-and-non-anchor-deletion";
+    }
+    if (deletionBefore && deletionAfter && !isAnchorBefore && !isAnchorAfter) {
+        return "between-two-non-anchor-deletions";
+    }
+    if ($pos.nodeBefore == null && deletionAfter && !isAnchorAfter) {
+        return "between-node-boundary-and-non-anchor-deletion";
+    }
+    if (deletionBefore && $pos.nodeAfter == null && !isAnchorBefore) {
+        return "between-non-anchor-deletion-and-node-boundary";
+    }
+    if (deletionBefore && !isAnchorBefore && $pos.nodeAfter == null) {
+        return "between-non-anchor-deletion-and-node-boundary";
+    }
+    if (deletionBefore && !isAnchorBefore) {
+        return "between-non-anchor-deletion-and-anything";
+    }
+    const insertionBefore = insertion.isInSet($pos.nodeBefore?.marks ?? []);
+    const insertionAfter = insertion.isInSet($pos.nodeAfter?.marks ?? []);
+    const ZWSP_REGEXP = new RegExp(ZWSP, "g");
+    const isZWSPBefore = $pos.nodeBefore && $pos.nodeBefore.isText && $pos.nodeBefore.textContent.replace(ZWSP_REGEXP, "") === "";
+    const isZWSPAfter = $pos.nodeAfter && $pos.nodeAfter.isText && $pos.nodeAfter.textContent.replace(ZWSP_REGEXP, "") === "";
+    if (insertionBefore && insertionAfter && isZWSPBefore && isZWSPAfter) {
+        return "between-two-zwsp-insertions";
+    }
+    if (insertionBefore && isZWSPBefore && $pos.nodeAfter == null && // A position like this:
+    // <p><insertion>ZWSP</insertion>|</p>
+    // because it means this paragraph was just created and it's empty.
+    $pos.parent.textContent.replace(ZWSP_REGEXP, "") !== "") {
+        return "between-zwsp-insertion-and-right-node-boundary";
+    }
+    if (insertionAfter && isZWSPAfter && $pos.nodeBefore == null) {
+        return "between-zwsp-insertion-and-left-node-boundary";
+    }
+    return null;
+}

package/dist/features/joinOnDelete/__tests__/joinOnDeleteInLists.playwright.test.d.ts

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

package/dist/features/joinOnDelete/__tests__/joinOnDeleteInListsTipTapStyle.playwright.test.d.ts

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

package/dist/features/joinOnDelete/__tests__/listWithJoinsAndStructureMarks.playwright.test.d.ts

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

package/dist/features/joinOnDelete/index.d.ts

@@ -1,24 +1,10 @@
-import { Mark, type Node, type Attrs, type MarkType, type ResolvedPos } from "prosemirror-model";
+import { Mark, type Node, type MarkType, type ResolvedPos } from "prosemirror-model";
 import { Transform } from "prosemirror-transform";
 import { type Transaction } from "prosemirror-state";
 import { type SuggestionId } from "../../generateId.js";
-interface JoinMarkAttrs {
-    type: "join";
-    data: {
-        leftNode: {
-            type: string;
-            attrs: object;
-            marks: object[];
-        };
-        rightNode: {
-            type: string;
-            attrs: object;
-            marks: object[];
-        };
-    };
-}
-export declare function isJoinMarkAttrs(attrs: Attrs): attrs is JoinMarkAttrs;
-export declare function maybeRevertJoinMark(tr: Transform, from: number, to: number, node: Node, markType: MarkType): boolean;
+export declare function maybeRevertJoinMark(tr: Transform, from: number, to: number, node: Node, markType: MarkType): false | {
+    restoredStructureSuggestionIds: Set<SuggestionId>;
+};
 /**
  * Remove ZWSP text nodes marked as deletions (except for type=join) from the given range
  */
@@ -34,4 +20,3 @@ export declare function joinNodesAndMarkJoinPoints(trackedTransaction: Transacti
  */
 export declare function collapseZWSPNodes(trackedTransaction: Transaction, from: number, to: number): Transform;
 export declare function findJoinMark(pos: ResolvedPos): Mark | null;
-export {};

package/dist/features/joinOnDelete/index.js

@@ -2,41 +2,104 @@ import { Mark } from "prosemirror-model";
 import { canJoin, Transform } from "prosemirror-transform";
 import { ZWSP } from "../../constants.js";
 import { getSuggestionMarks } from "../../utils.js";
-export function isJoinMarkAttrs(attrs) {
-    if (attrs["type"] !== "join") return false;
-    if (attrs["data"] == null) return false;
-    const data = attrs["data"];
-    if (data.leftNode == null || data.rightNode == null) return false;
-    if (typeof data.leftNode.type !== "string" || typeof data.rightNode.type !== "string") return false;
-    if (typeof data.leftNode.attrs !== "object" || typeof data.rightNode.attrs !== "object") return false;
-    if (!Array.isArray(data.leftNode.marks) || !Array.isArray(data.rightNode.marks)) return false;
+import { areEquivalentStructureMarks } from "../wrapUnwrap/areEquivalentStructureMarks.js";
+import { guardStructureMarkAttrs } from "../wrapUnwrap/types.js";
+import { MAX_BLOCK_JOIN_DEPTH, normalizeJoinNodesMetadata } from "./normalizeJoinNodesMetadata.js";
+import { isJoinMark } from "./types.js";
+function serializeJoinNode(node) {
+    return {
+        type: node.type.name,
+        attrs: node.attrs,
+        marks: node.marks.map((mark)=>mark.toJSON())
+    };
+}
+function marksFromJSON(schema, markData) {
+    return markData.map((markData)=>Mark.fromJSON(schema, markData));
+}
+// when we revert a block join deletion mark, we restore nodes on both sides of the mark using leftNodes rightNodes metadata
+// but existing left and right nodes may have structure marks that we need to preserve
+function mergeSerializedMarksWithCurrentStructureMarks(tr, pos, serializedMarks) {
+    const currentNode = tr.doc.nodeAt(pos);
+    if (!currentNode) return serializedMarks;
+    const { structure } = getSuggestionMarks(tr.doc.type.schema);
+    const mergedMarks = [
+        ...serializedMarks
+    ];
+    for (const currentMark of currentNode.marks){
+        if (currentMark.type !== structure) continue;
+        const alreadyIncluded = mergedMarks.some((mark)=>mark.type === structure && areEquivalentStructureMarks(mark, currentMark));
+        if (!alreadyIncluded) {
+            mergedMarks.push(currentMark);
+        }
+    }
+    return mergedMarks;
+}
+function restoreNodeMarkup(tr, pos, node) {
+    const nodeType = tr.doc.type.schema.nodes[node.type];
+    if (!nodeType) return false;
+    const marks = mergeSerializedMarksWithCurrentStructureMarks(tr, pos, marksFromJSON(tr.doc.type.schema, node.marks));
+    tr.setNodeMarkup(pos, nodeType, node.attrs, marks);
     return true;
 }
+// collect structure suggestion IDs that will be re-introduced into the document after the join is reverted
+function getRestoredStructureSuggestionIds(joinNodes, schema) {
+    const { structure } = getSuggestionMarks(schema);
+    const restoredStructureSuggestionIds = new Set();
+    for (const node of [
+        ...joinNodes.leftNodes,
+        ...joinNodes.rightNodes
+    ]){
+        const marks = marksFromJSON(schema, node.marks);
+        for (const mark of marks){
+            if (mark.type !== structure) continue;
+            if (!guardStructureMarkAttrs(mark.attrs)) continue;
+            restoredStructureSuggestionIds.add(mark.attrs.id);
+        }
+    }
+    return restoredStructureSuggestionIds;
+}
 export function maybeRevertJoinMark(tr, from, to, node, markType) {
     const mark = node.marks.find((mark)=>mark.type === markType);
-    if (!mark || mark.attrs["type"] !== "join" || node.text !== ZWSP) return false;
-    // this is a mark of type join
-    // split the current node at this mark position
-    // delete this mark together with its zwsp content
-    // assign left and right node (after the split) properties from the mark's data
+    if (!mark || !isJoinMark(mark) || node.text !== ZWSP) return false;
+    const joinNodes = normalizeJoinNodesMetadata(mark.attrs);
+    if (!joinNodes) return false;
+    for (const node of [
+        ...joinNodes.leftNodes,
+        ...joinNodes.rightNodes
+    ]){
+        const nodeType = tr.doc.type.schema.nodes[node.type];
+        if (!nodeType) return false;
+        try {
+            marksFromJSON(tr.doc.type.schema, node.marks);
+        } catch  {
+            return false;
+        }
+    }
+    const restoredStructureSuggestionIds = getRestoredStructureSuggestionIds(joinNodes, tr.doc.type.schema);
+    // Reverting a join marker removes its ZWSP anchor, splits at that position,
+    // and restores markup because ProseMirror split creates nodes with defaults.
+    const joinDepth = joinNodes.leftNodes.length;
     tr.delete(from, to);
-    tr.split(from);
-    // insertionFrom is now at the end of the left node (but before the closing token)
-    // after() will give us the position after the closing token (but before the next opening token) - exactly the split pos
-    const $insertionFrom = tr.doc.resolve(from);
-    const $splitPos = tr.doc.resolve($insertionFrom.after());
-    const { attrs } = mark;
-    if (!isJoinMarkAttrs(attrs) || !$splitPos.nodeBefore || !$splitPos.nodeAfter) return false;
-    // restore left and right node type, attrs and marks, as they were before the join
-    const { leftNode, rightNode } = attrs.data;
-    const leftNodeType = tr.doc.type.schema.nodes[leftNode.type];
-    const rightNodeType = tr.doc.type.schema.nodes[rightNode.type];
-    const leftNodeMarks = leftNode.marks.map((markData)=>Mark.fromJSON(tr.doc.type.schema, markData));
-    const rightNodeMarks = rightNode.marks.map((markData)=>Mark.fromJSON(tr.doc.type.schema, markData));
-    if (!leftNodeType || !rightNodeType) return false;
-    tr.setNodeMarkup($splitPos.pos - $splitPos.nodeBefore.nodeSize, leftNodeType, leftNode.attrs, leftNodeMarks);
-    tr.setNodeMarkup($splitPos.pos, rightNodeType, rightNode.attrs, rightNodeMarks);
-    return true;
+    tr.split(from, joinDepth);
+    const $splitFrom = tr.doc.resolve(from);
+    const baseDepth = $splitFrom.depth;
+    let rightPos = $splitFrom.after(baseDepth - joinDepth + 1);
+    // Metadata is stored child-first, but markup must be restored outer-first so
+    // positions inside the newly split structure remain addressable.
+    for(let index = joinDepth - 1; index >= 0; index -= 1){
+        const leftNode = joinNodes.leftNodes[index];
+        const rightNode = joinNodes.rightNodes[index];
+        if (!leftNode || !rightNode) return false;
+        const leftPos = $splitFrom.before(baseDepth - index);
+        if (!restoreNodeMarkup(tr, leftPos, leftNode) || !restoreNodeMarkup(tr, rightPos, rightNode)) {
+            return false;
+        }
+        // Each deeper right node starts one position inside the right node restored before it.
+        rightPos += 1;
+    }
+    return {
+        restoredStructureSuggestionIds
+    };
 }
 /**
  * Remove ZWSP text nodes marked as deletions (except for type=join) from the given range
@@ -72,45 +135,95 @@ export function maybeRevertJoinMark(tr, from, to, node, markType) {
     doc.nodesBetween(blockRange.start, blockRange.end, (node, pos)=>{
         if (node.isInline) return false;
         const endOfNode = pos + node.nodeSize;
-        // make sure the node ends within the range
         if (endOfNode >= blockRange.$to.pos) return true;
-        const $endOfNode = doc.resolve(endOfNode);
-        // make sure we are between two nodes
-        if (!$endOfNode.nodeBefore || !$endOfNode.nodeAfter) return false;
-        // we cannot insert zwsp text nodes into non-textblock nodes
-        if (!$endOfNode.nodeBefore.isTextblock || !$endOfNode.nodeAfter.isTextblock) return true;
-        const mappedEndOfNode = transform.mapping.map(endOfNode);
-        const $mappedEndOfNode = transform.doc.resolve(mappedEndOfNode);
-        if (!canJoin(transform.doc, mappedEndOfNode) || !$mappedEndOfNode.nodeBefore || !$mappedEndOfNode.nodeAfter) {
+        // List-item joins can start between non-textblock nodes; expand inward to
+        // capture the visible textblock pair and its structural parent pair.
+        const joinCandidate = getJoinCandidateAtBoundary(doc, endOfNode, from, to, MAX_BLOCK_JOIN_DEPTH);
+        if (!joinCandidate) return true;
+        const mappedJoinPos = transform.mapping.map(joinCandidate.joinPos);
+        if (!canApplyJoinCandidate(transform.doc, mappedJoinPos, joinCandidate.leftNodes.length)) {
             return true;
         }
-        const leftNode = {
-            type: $endOfNode.nodeBefore.type.name,
-            attrs: $endOfNode.nodeBefore.attrs,
-            marks: $endOfNode.nodeBefore.marks.map((mark)=>mark.toJSON())
-        };
-        const rightNode = {
-            type: $endOfNode.nodeAfter.type.name,
-            attrs: $endOfNode.nodeAfter.attrs,
-            marks: $endOfNode.nodeAfter.marks.map((mark)=>mark.toJSON())
-        };
-        transform.join(mappedEndOfNode);
+        const shouldSuppressJoinMark = [
+            ...joinCandidate.leftNodes,
+            ...joinCandidate.rightNodes
+        ].some((node)=>hasStructureAddMark(node));
+        transform.join(mappedJoinPos, joinCandidate.leftNodes.length);
+        // Joining provisional structure cancels its pending add instead of creating
+        // a second review artifact for the same user action.
+        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);
+        const joinPos = joinStep.getMap().map(mappedJoinPos);
         transform.insert(joinPos, transform.doc.type.schema.text(ZWSP));
         transform.addMark(joinPos, joinPos + 1, deletion.create({
             id: markId,
             type: "join",
             data: {
-                leftNode,
-                rightNode
+                leftNodes: joinCandidate.leftNodes.map(serializeJoinNode),
+                rightNodes: joinCandidate.rightNodes.map(serializeJoinNode)
             }
         }));
         return false;
     });
     return transform;
 }
+function getJoinCandidateAtBoundary(doc, boundaryPos, from, to, maxJoinDepth) {
+    const $boundary = doc.resolve(boundaryPos);
+    const leftNode = $boundary.nodeBefore;
+    const rightNode = $boundary.nodeAfter;
+    // Multi-depth list joins can begin between structural nodes, not just textblocks.
+    if (!leftNode || !rightNode) return null;
+    if (leftNode.isInline || rightNode.isInline) return null;
+    if (!canJoin(doc, boundaryPos)) return null;
+    const pairs = [
+        {
+            leftNode,
+            rightNode
+        }
+    ];
+    for(let expandBy = 1; pairs.length < maxJoinDepth; expandBy += 1){
+        const left = boundaryPos - expandBy;
+        const right = boundaryPos + expandBy;
+        if (left < from || right > to) break;
+        const $left = doc.resolve(left);
+        const $right = doc.resolve(right);
+        // Once text is adjacent, there is no deeper block pair to capture.
+        if ($left.nodeBefore?.isText || $right.nodeAfter?.isText) break;
+        if ($left.nodeAfter === null && $left.nodeBefore && !$left.nodeBefore.isInline && $right.nodeBefore === null && $right.nodeAfter && !$right.nodeAfter.isInline) {
+            pairs.push({
+                leftNode: $left.nodeBefore,
+                rightNode: $right.nodeAfter
+            });
+            continue;
+        }
+        break;
+    }
+    // canJoin only checks the boundary; the temporary transform verifies depth.
+    if (!canApplyJoinCandidate(doc, boundaryPos, pairs.length)) return null;
+    return {
+        joinPos: boundaryPos,
+        leftNodes: pairs.map((pair)=>pair.leftNode).reverse(),
+        rightNodes: pairs.map((pair)=>pair.rightNode).reverse()
+    };
+}
+function canApplyJoinCandidate(doc, joinPos, depth) {
+    if (!canJoin(doc, joinPos)) return false;
+    try {
+        new Transform(doc).join(joinPos, depth);
+        return true;
+    } catch  {
+        return false;
+    }
+}
+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/joinOnDelete/normalizeJoinNodesMetadata.d.ts

@@ -0,0 +1,6 @@
+import { type JoinMarkAttrs } from "./types.js";
+export declare const MAX_BLOCK_JOIN_DEPTH = 2;
+export declare function normalizeJoinNodesMetadata(attrs: JoinMarkAttrs): false | {
+    leftNodes: import("./types.js").SerializedJoinNode[];
+    rightNodes: import("./types.js").SerializedJoinNode[];
+};

package/dist/features/joinOnDelete/normalizeJoinNodesMetadata.js

@@ -0,0 +1,24 @@
+import { isSerializedJoinNode } from "./types.js";
+// Block join suggestion metadata/revert currently supports the depth TipTap uses
+// when Backspace joins both list-item paragraphs and their parent list items.
+export const MAX_BLOCK_JOIN_DEPTH = 2;
+export function normalizeJoinNodesMetadata(attrs) {
+    const data = attrs.data;
+    // Normalize legacy metadata so revert can use the same array path.
+    const leftNodes = data.leftNodes ?? (data.leftNode ? [
+        data.leftNode
+    ] : null);
+    const rightNodes = data.rightNodes ?? (data.rightNode ? [
+        data.rightNode
+    ] : null);
+    if (!Array.isArray(leftNodes) || !Array.isArray(rightNodes)) return false;
+    if (leftNodes.length === 0 || leftNodes.length !== rightNodes.length) return false;
+    // Reject unsupported depths instead of partially reverting unknown structure.
+    if (leftNodes.length > MAX_BLOCK_JOIN_DEPTH) return false;
+    if (!leftNodes.every(isSerializedJoinNode)) return false;
+    if (!rightNodes.every(isSerializedJoinNode)) return false;
+    return {
+        leftNodes,
+        rightNodes
+    };
+}

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

@@ -0,0 +1,36 @@
+import { type Mark, type Attrs, type Node } from "prosemirror-model";
+import { type SuggestionId } from "../../generateId.js";
+export interface SerializedJoinNode {
+    type: string;
+    attrs: object;
+    marks: {
+        attrs: Record<string, unknown>;
+    }[];
+}
+export interface JoinMarkAttrs {
+    id: SuggestionId;
+    type: "join";
+    data: {
+        leftNode?: SerializedJoinNode;
+        rightNode?: SerializedJoinNode;
+        leftNodes?: SerializedJoinNode[];
+        rightNodes?: SerializedJoinNode[];
+    };
+}
+export interface JoinPair {
+    leftNode: Node;
+    rightNode: Node;
+}
+export interface JoinCandidate {
+    joinPos: number;
+    leftNodes: Node[];
+    rightNodes: Node[];
+}
+export declare function isSerializedJoinNode(node: unknown): node is SerializedJoinNode;
+export declare function isJoinMarkAttrs(attrs: Attrs): attrs is JoinMarkAttrs;
+export declare function isJoinMarkObject(mark: unknown): mark is Omit<Mark, "attrs"> & {
+    attrs: JoinMarkAttrs;
+};
+export declare function isJoinMark(mark: Mark): mark is Omit<Mark, "attrs"> & {
+    attrs: JoinMarkAttrs;
+};

package/dist/features/joinOnDelete/types.js

@@ -0,0 +1,23 @@
+import { getSuggestionMarks } from "../../utils.js";
+export function isSerializedJoinNode(node) {
+    if (node === null || typeof node !== "object") return false;
+    const data = node;
+    return typeof data.type === "string" && typeof data.attrs === "object" && data.attrs !== null && Array.isArray(data.marks);
+}
+export function isJoinMarkAttrs(attrs) {
+    if (typeof attrs["id"] !== "string" && typeof attrs["id"] !== "number") {
+        return false;
+    }
+    if (attrs["type"] !== "join") return false;
+    if (attrs["data"] == null) return false;
+    return true;
+}
+export function isJoinMarkObject(mark) {
+    if (mark === null || typeof mark !== "object") return false;
+    if (!("attrs" in mark)) return false;
+    return isJoinMarkAttrs(mark.attrs);
+}
+export function isJoinMark(mark) {
+    const { deletion } = getSuggestionMarks(mark.type.schema);
+    return mark.type === deletion && isJoinMarkAttrs(mark.attrs);
+}

package/dist/features/transactionShaping/detectSpecialTransactionShape.d.ts

@@ -0,0 +1,3 @@
+import { type Transaction } from "prosemirror-state";
+import { type SpecialTransactionShape } from "./types.js";
+export declare function detectSpecialTransactionShape(transaction: Transaction): SpecialTransactionShape | null;

package/dist/features/transactionShaping/detectSpecialTransactionShape.js

@@ -0,0 +1,4 @@
+import { detectTipTapParagraphIntoListJoin } from "./tipTapParagraphIntoListJoin/detectTipTapParagraphIntoListJoin.js";
+export function detectSpecialTransactionShape(transaction) {
+    return detectTipTapParagraphIntoListJoin(transaction);
+}

package/dist/features/transactionShaping/index.d.ts

@@ -0,0 +1,3 @@
+import { type Transaction } from "prosemirror-state";
+import { type HandleSpecialTransactionShapeArgs } from "./types.js";
+export declare function handleSpecialTransactionShape(args: HandleSpecialTransactionShapeArgs): Transaction | null;

package/dist/features/transactionShaping/index.js

@@ -0,0 +1,11 @@
+import { handleTipTapParagraphIntoListJoin } from "./tipTapParagraphIntoListJoin/index.js";
+const specialTransactionShapeHandlers = [
+    handleTipTapParagraphIntoListJoin
+];
+export function handleSpecialTransactionShape(args) {
+    for (const handler of specialTransactionShapeHandlers){
+        const transaction = handler(args);
+        if (transaction) return transaction;
+    }
+    return null;
+}

package/dist/features/transactionShaping/tipTapParagraphIntoListJoin/detectTipTapParagraphIntoListJoin.d.ts

@@ -0,0 +1,3 @@
+import { type Transaction } from "prosemirror-state";
+import { type TipTapParagraphIntoListJoinShape } from "../types.js";
+export declare function detectTipTapParagraphIntoListJoin(transaction: Transaction): TipTapParagraphIntoListJoinShape | null;

package/dist/features/transactionShaping/tipTapParagraphIntoListJoin/detectTipTapParagraphIntoListJoin.js

@@ -0,0 +1,48 @@
+import { ReplaceStep, Transform } from "prosemirror-transform";
+import { getNodeId } from "../../wrapUnwrap/getNodeId.js";
+// detect a very specific TipTap pattern where joining a paragraph into a list above it
+// causes a 3-step transaction, which is different from normal prosemirror where you just get 1 step
+// see unit test for details
+export function detectTipTapParagraphIntoListJoin(transaction) {
+    if (transaction.steps.length !== 3) return null;
+    const [deleteStep, insertStep, joinStep] = transaction.steps;
+    if (!(deleteStep instanceof ReplaceStep) || !(insertStep instanceof ReplaceStep) || !(joinStep instanceof ReplaceStep)) {
+        return null;
+    }
+    if (deleteStep.slice.content.size !== 0) return null;
+    if (insertStep.from !== insertStep.to) return null;
+    if (insertStep.slice.openStart !== 0 || insertStep.slice.openEnd !== 0) return null;
+    if (insertStep.slice.content.childCount !== 1) return null;
+    if (joinStep.slice.content.size !== 0) return null;
+    if (joinStep.structure !== true) return null;
+    const docBefore = transaction.docs[0];
+    if (!docBefore) return null;
+    const movedNode = docBefore.nodeAt(deleteStep.from);
+    if (!movedNode || !movedNode.isTextblock || movedNode.nodeSize !== deleteStep.to - deleteStep.from) {
+        return null;
+    }
+    const insertedNode = insertStep.slice.content.firstChild;
+    if (!insertedNode?.isTextblock) return null;
+    if (insertedNode.type !== movedNode.type) return null;
+    if (insertedNode.textContent !== movedNode.textContent) return null;
+    const movedNodeId = getNodeId(movedNode);
+    if (!movedNodeId || getNodeId(insertedNode) !== movedNodeId) return null;
+    const previousSibling = docBefore.resolve(deleteStep.from).nodeBefore;
+    if (!previousSibling || previousSibling.isInline) return null;
+    try {
+        const preview = new Transform(docBefore);
+        preview.step(deleteStep);
+        preview.step(insertStep);
+        new Transform(preview.doc).step(joinStep);
+    } catch  {
+        return null;
+    }
+    console.warn("[prosemirror-suggest-changes]", "detected TipTap paragraph into list join shape");
+    return {
+        type: "tipTapParagraphIntoListJoin",
+        deleteStep,
+        insertStep,
+        joinStep,
+        movedNode
+    };
+}