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

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
+    };
+}

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

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

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

@@ -0,0 +1,188 @@
+import { EditorState } from "prosemirror-state";
+import { Step } from "prosemirror-transform";
+import { describe, expect, it } from "vitest";
+import { createSchema } from "../../../testing/e2eTestSchema.js";
+import { detectTipTapParagraphIntoListJoin } from "./detectTipTapParagraphIntoListJoin.js";
+const schema = createSchema();
+// when joining a paragraph into a list above it,
+// TipTap List extension overrides the default ProseMirror behavior
+// by default, ProseMirror puts the paragraph to the end of list as a separate list item
+// TipTap instead joins the paragraph with the paragraph of the last list item
+const TIPTAP_PARAGRAPH_INTO_LIST_STEPS = [
+    // first step deletes the paragraph that we're joining
+    {
+        stepType: "replace",
+        from: 42,
+        to: 60
+    },
+    // second step inserts that paragraph into the last list item
+    {
+        stepType: "replace",
+        from: 40,
+        to: 40,
+        slice: {
+            content: [
+                {
+                    type: "paragraph",
+                    attrs: {
+                        id: "node-9",
+                        textAlign: null
+                    },
+                    content: [
+                        {
+                            type: "text",
+                            text: "sample paragraph"
+                        }
+                    ]
+                }
+            ]
+        }
+    },
+    // third step joins the two paragraphs in the list item
+    {
+        stepType: "replace",
+        from: 39,
+        to: 41,
+        structure: true
+    }
+];
+const TIPTAP_PARAGRAPH_INTO_LIST_DOC = {
+    type: "doc",
+    content: [
+        {
+            type: "orderedList",
+            attrs: {
+                order: 1,
+                id: "node-0"
+            },
+            content: [
+                {
+                    type: "listItem",
+                    attrs: {
+                        id: "node-1"
+                    },
+                    content: [
+                        {
+                            type: "paragraph",
+                            attrs: {
+                                id: "node-2"
+                            },
+                            content: [
+                                {
+                                    type: "text",
+                                    text: "Item 1"
+                                }
+                            ]
+                        }
+                    ]
+                },
+                {
+                    type: "listItem",
+                    attrs: {
+                        id: "node-3"
+                    },
+                    content: [
+                        {
+                            type: "paragraph",
+                            attrs: {
+                                id: "node-4"
+                            },
+                            content: [
+                                {
+                                    type: "text",
+                                    text: "Item 2"
+                                }
+                            ]
+                        }
+                    ]
+                },
+                {
+                    type: "listItem",
+                    attrs: {
+                        id: "node-5"
+                    },
+                    content: [
+                        {
+                            type: "paragraph",
+                            attrs: {
+                                id: "node-6"
+                            },
+                            content: [
+                                {
+                                    type: "text",
+                                    text: "Item 3"
+                                }
+                            ]
+                        }
+                    ]
+                },
+                {
+                    type: "listItem",
+                    attrs: {
+                        id: "node-7"
+                    },
+                    content: [
+                        {
+                            type: "paragraph",
+                            attrs: {
+                                id: "node-8"
+                            },
+                            content: [
+                                {
+                                    type: "text",
+                                    text: "Item 4"
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ]
+        },
+        {
+            type: "paragraph",
+            attrs: {
+                id: "node-9"
+            },
+            content: [
+                {
+                    type: "text",
+                    text: "sample paragraph"
+                }
+            ]
+        }
+    ]
+};
+describe("detectTipTapParagraphIntoListJoin", ()=>{
+    it("detects TipTap's three-step paragraph-into-list join shape", ()=>{
+        const doc = schema.nodeFromJSON(TIPTAP_PARAGRAPH_INTO_LIST_DOC);
+        const state = EditorState.create({
+            doc
+        });
+        const transaction = state.tr;
+        TIPTAP_PARAGRAPH_INTO_LIST_STEPS.forEach((stepJSON)=>{
+            transaction.step(Step.fromJSON(schema, stepJSON));
+        });
+        const shape = detectTipTapParagraphIntoListJoin(transaction);
+        expect(shape).toMatchObject({
+            type: "tipTapParagraphIntoListJoin",
+            deleteStep: {
+                from: 42,
+                to: 60
+            },
+            insertStep: {
+                from: 40,
+                to: 40
+            },
+            joinStep: {
+                from: 39,
+                to: 41
+            },
+            movedNode: {
+                attrs: {
+                    id: "node-9"
+                }
+            }
+        });
+        expect(shape?.movedNode.textContent).toBe("sample paragraph");
+    });
+});

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

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