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

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;

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

@@ -0,0 +1,69 @@
+import { EditorState, Selection } from "prosemirror-state";
+import { preserveTransactionData, transformToSuggestionTransaction } from "../../../transformToSuggestionTransaction.js";
+import { generateNextNumberId } from "../../../generateId.js";
+import { suggestStructureChanges } from "../../wrapUnwrap/structureChangesPlugin.js";
+import { detectSpecialTransactionShape } from "../detectSpecialTransactionShape.js";
+// handle the specific TipTap pattern when backspacing from a paragraph into a list above
+// causes a transaction with 3 steps
+// "slice" the transaction into two pieces, first piece is the first 2 steps, second piece is the last step
+// first piece "moves" the paragraph - handled by structure change tracking - a structure "move" suggestion
+// second piece joins two paragraphs - handled by the main plugin join-on-delete feature - deletion type="join" mark
+export function handleTipTapParagraphIntoListJoin(args) {
+    const shape = detectSpecialTransactionShape(args.transaction);
+    if (!isTipTapParagraphIntoListJoinShape(shape)) return null;
+    if (!args.structuralContextPaths || !args.ensureUniqueNodeIds) return null;
+    const docBefore = args.transaction.docs[0];
+    if (!docBefore) return null;
+    const trackedTransaction = args.state.tr;
+    const sharedSuggestionId = args.generateId ? args.generateId(args.state.schema, docBefore) : generateNextNumberId(args.state.schema, docBefore);
+    const generateSharedSuggestionId = ()=>sharedSuggestionId;
+    try {
+        trackedTransaction.step(shape.deleteStep);
+        trackedTransaction.step(shape.insertStep);
+    } catch  {
+        return null;
+    }
+    const uniqueNodeIdsTransform = args.ensureUniqueNodeIds([
+        args.transaction
+    ], docBefore, trackedTransaction.doc);
+    uniqueNodeIdsTransform.steps.forEach((step)=>{
+        trackedTransaction.step(step);
+    });
+    const structureChangesResult = suggestStructureChanges(docBefore, uniqueNodeIdsTransform.doc, args.structuralContextPaths, generateSharedSuggestionId);
+    if (!structureChangesResult.handled) {
+        return null;
+    }
+    structureChangesResult.transform.steps.forEach((step)=>{
+        trackedTransaction.step(step);
+    });
+    const intermediateState = EditorState.create({
+        schema: args.state.schema,
+        doc: trackedTransaction.doc
+    });
+    const joinTransaction = intermediateState.tr;
+    try {
+        joinTransaction.step(shape.joinStep);
+    } catch  {
+        return null;
+    }
+    const trackedJoinTransaction = transformToSuggestionTransaction(joinTransaction, intermediateState, generateSharedSuggestionId);
+    trackedJoinTransaction.steps.forEach((step)=>{
+        trackedTransaction.step(step);
+    });
+    preserveTransactionData(trackedTransaction, trackedJoinTransaction, {
+        selection: false,
+        preserveScroll: false,
+        preserveStoredMarks: false,
+        preserveMeta: false
+    });
+    preserveTransactionData(trackedTransaction, args.transaction, {
+        selection: false
+    });
+    if (args.transaction.selectionSet) {
+        trackedTransaction.setSelection(Selection.fromJSON(trackedTransaction.doc, args.transaction.selection.toJSON()));
+    }
+    return trackedTransaction;
+}
+function isTipTapParagraphIntoListJoinShape(shape) {
+    return shape?.type === "tipTapParagraphIntoListJoin";
+}

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

@@ -0,0 +1,2 @@
+export { detectTipTapParagraphIntoListJoin } from "./detectTipTapParagraphIntoListJoin.js";
+export { handleTipTapParagraphIntoListJoin } from "./handleTipTapParagraphIntoListJoin.js";

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

@@ -0,0 +1,2 @@
+export { detectTipTapParagraphIntoListJoin } from "./detectTipTapParagraphIntoListJoin.js";
+export { handleTipTapParagraphIntoListJoin } from "./handleTipTapParagraphIntoListJoin.js";

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

@@ -0,0 +1,20 @@
+import { type Node, type Schema } from "prosemirror-model";
+import { type EditorState, type Transaction } from "prosemirror-state";
+import { type ReplaceStep, type Transform } from "prosemirror-transform";
+import { type SuggestionId } from "../../generateId.js";
+import { type StructuralContextPath } from "../wrapUnwrap/types.js";
+export interface TipTapParagraphIntoListJoinShape {
+    type: "tipTapParagraphIntoListJoin";
+    deleteStep: ReplaceStep;
+    insertStep: ReplaceStep;
+    joinStep: ReplaceStep;
+    movedNode: Node;
+}
+export type SpecialTransactionShape = TipTapParagraphIntoListJoinShape;
+export interface HandleSpecialTransactionShapeArgs {
+    transaction: Transaction;
+    state: EditorState;
+    generateId: ((schema: Schema, doc?: Node) => SuggestionId) | undefined;
+    structuralContextPaths: StructuralContextPath[] | null;
+    ensureUniqueNodeIds: ((transactions: Transaction[], oldDoc: Node, newDoc: Node) => Transform) | undefined;
+}

package/dist/features/transactionShaping/types.js

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

package/dist/features/wrapUnwrap/__tests__/blockquoteStructure.playwright.test.d.ts

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

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

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

package/dist/features/wrapUnwrap/__tests__/listStructure.playwright.test.d.ts

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

package/dist/features/wrapUnwrap/__tests__/listStructureTextEdits.playwright.test.d.ts

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

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

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

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

@@ -0,0 +1,2 @@
+import { type NodeSpec } from "prosemirror-model";
+export declare const addIdAttr: (nodeSpec: NodeSpec) => NodeSpec;

package/dist/features/wrapUnwrap/addIdAttr.js

@@ -0,0 +1,60 @@
+export const addIdAttr = (nodeSpec)=>{
+    const { toDOM, parseDOM } = nodeSpec;
+    if (!toDOM || !parseDOM) {
+        return nodeSpec;
+    }
+    const newNodeSpec = {
+        ...nodeSpec,
+        attrs: {
+            ...nodeSpec.attrs ?? {},
+            id: {
+                default: null
+            }
+        },
+        toDOM (node) {
+            const domOutputSpec = toDOM(node);
+            if (!Array.isArray(domOutputSpec)) {
+                console.warn("addIdAttr", "domOutputSpec is not an array, id is not added", domOutputSpec);
+                return domOutputSpec;
+            }
+            const id = typeof node.attrs["id"] === "string" ? node.attrs["id"] : null;
+            const attrs = domOutputSpec[1];
+            if (!Array.isArray(attrs) && typeof attrs === "object" && attrs !== null) {
+                const theRest = domOutputSpec.slice(2);
+                const result = [
+                    domOutputSpec[0],
+                    id ? {
+                        ...attrs,
+                        "data-id": id
+                    } : attrs,
+                    ...theRest
+                ];
+                return result;
+            }
+            const theRest = domOutputSpec.slice(1);
+            const result = [
+                domOutputSpec[0],
+                id ? {
+                    "data-id": id
+                } : {},
+                ...theRest
+            ];
+            return result;
+        },
+        parseDOM: [
+            ...parseDOM.map((tagParseRule)=>({
+                    ...tagParseRule,
+                    getAttrs (dom) {
+                        const id = dom.getAttribute("data-id");
+                        return tagParseRule.getAttrs ? {
+                            ...tagParseRule.getAttrs(dom),
+                            id
+                        } : {
+                            id
+                        };
+                    }
+                }))
+        ]
+    };
+    return newNodeSpec;
+};

package/dist/features/wrapUnwrap/apply/applyStructureSuggestions.d.ts

@@ -0,0 +1,10 @@
+import { type Node } from "prosemirror-model";
+import { type Transform } from "prosemirror-transform";
+import { type SuggestionId } from "../../../generateId.js";
+export declare function applyStructureSuggestionsInNode({ tr, node, suggestionId, from, to, }: {
+    tr: Transform;
+    node: Node;
+    suggestionId?: SuggestionId;
+    from?: number | undefined;
+    to?: number | undefined;
+}): void;

package/dist/features/wrapUnwrap/apply/applyStructureSuggestions.js

@@ -0,0 +1,41 @@
+import { getSuggestionMarks } from "../../../utils.js";
+export function applyStructureSuggestionsInNode({ tr, node, suggestionId, from, to }) {
+    const { structure } = getSuggestionMarks(node.type.schema);
+    const suggestionIds = new Set();
+    node.descendants((node, pos)=>{
+        if (from !== undefined && pos < from) {
+            return true;
+        }
+        if (to !== undefined && pos > to) {
+            return false;
+        }
+        if (node.isText) return true;
+        if (!structure.isInSet(node.marks)) return true;
+        node.marks.forEach((mark)=>{
+            if (mark.type !== structure) return;
+            const markSuggestionId = mark.attrs["id"];
+            if (suggestionId != null && markSuggestionId !== suggestionId) return;
+            suggestionIds.add(markSuggestionId);
+        });
+        return true;
+    });
+    for (const suggestionId of suggestionIds){
+        applyOneStructureSuggestion(tr, suggestionId);
+    }
+}
+function applyOneStructureSuggestion(tr, suggestionId) {
+    const { structure } = getSuggestionMarks(tr.doc.type.schema);
+    tr.doc.descendants((node, pos)=>{
+        if (node.isText) return true;
+        if (!structure.isInSet(node.marks)) return true;
+        node.marks.forEach((mark)=>{
+            if (mark.type !== structure) return;
+            if (mark.attrs["id"] !== suggestionId) return;
+            applyStructureMark(tr, mark, pos);
+        });
+        return true;
+    });
+}
+function applyStructureMark(tr, mark, pos) {
+    tr.removeNodeMark(pos, mark);
+}

package/dist/features/wrapUnwrap/apply/index.d.ts

@@ -0,0 +1,5 @@
+import { Transform } from "prosemirror-transform";
+import { type Node } from "prosemirror-model";
+import { type SuggestionId } from "../../../generateId.js";
+export declare function applyAllStructureSuggestions(node: Node, from?: number, to?: number): Transform;
+export declare function applyStructureSuggestion(node: Node, suggestionId: SuggestionId): Transform;

package/dist/features/wrapUnwrap/apply/index.js

@@ -0,0 +1,21 @@
+import { Transform } from "prosemirror-transform";
+import { applyStructureSuggestionsInNode } from "./applyStructureSuggestions.js";
+export function applyAllStructureSuggestions(node, from, to) {
+    const tr = new Transform(node);
+    applyStructureSuggestionsInNode({
+        tr,
+        node: tr.doc,
+        from,
+        to
+    });
+    return tr;
+}
+export function applyStructureSuggestion(node, suggestionId) {
+    const tr = new Transform(node);
+    applyStructureSuggestionsInNode({
+        tr,
+        node: tr.doc,
+        suggestionId
+    });
+    return tr;
+}

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

@@ -0,0 +1,2 @@
+import { type Mark } from "prosemirror-model";
+export declare function areEquivalentStructureMarks(a: Mark, b: Mark): boolean;

package/dist/features/wrapUnwrap/areEquivalentStructureMarks.js

@@ -0,0 +1,17 @@
+import { sameParentChain } from "./sameParentChain.js";
+import { guardStructureMarkAttrs } from "./types.js";
+export function areEquivalentStructureMarks(a, b) {
+    if (a.type !== b.type) return false;
+    if (!guardStructureMarkAttrs(a.attrs)) return false;
+    if (!guardStructureMarkAttrs(b.attrs)) return false;
+    const aOp = a.attrs.data.op;
+    const bOp = b.attrs.data.op;
+    if (aOp.op !== bOp.op) return false;
+    if (aOp.op === "add" && bOp.op === "add") {
+        return a.attrs.id === b.attrs.id;
+    }
+    if (aOp.op === "move" && bOp.op === "move") {
+        return sameParentChain(aOp.from, bOp.from) && sameParentChain(aOp.to, bOp.to);
+    }
+    return false;
+}

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

@@ -0,0 +1,3 @@
+import { type MaterializedPaths } from "./types.js";
+import { type Node } from "prosemirror-model";
+export declare function buildMaterializedPaths(doc: Node): MaterializedPaths;

package/dist/features/wrapUnwrap/buildMaterializedPaths.js

@@ -0,0 +1,82 @@
+import { getNodeId } from "./getNodeId.js";
+import { DOC_NODE_ID } from "./constants.js";
+const TRACE_ENABLED = false;
+function trace(...args) {
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (!TRACE_ENABLED) return;
+    console.log("[structureChanges]", ...args);
+}
+export function buildMaterializedPaths(doc) {
+    const perfPaths = performance.now();
+    const paths = new Map();
+    // add direct doc children first since they have a specific parent signature due to doc not having an ID
+    doc.children.forEach((node, index, children)=>{
+        const nodeId = getNodeId(node);
+        if (nodeId == null) return;
+        const leftSibling = children[index - 1];
+        const leftSiblingId = leftSibling ? getNodeId(leftSibling) : null;
+        const rightSibling = children[index + 1];
+        const rightSiblingId = rightSibling ? getNodeId(rightSibling) : null;
+        const parent = {
+            nodeId: DOC_NODE_ID,
+            nodeType: DOC_NODE_ID,
+            nodeAttrs: {},
+            nodeMarks: [],
+            childSiblingIds: [
+                leftSiblingId,
+                rightSiblingId
+            ],
+            childIndex: index
+        };
+        paths.set(nodeId, {
+            nodeType: node.type.name,
+            node,
+            chain: [
+                parent
+            ]
+        });
+    });
+    // now add the rest of the nodes
+    doc.descendants((node, _pos, parent, childIndex)=>{
+        if (node.isInline) return false;
+        const nodeId = getNodeId(node);
+        if (nodeId == null) return true;
+        // this is to avoid processing direct doc children twice
+        if (paths.has(nodeId)) return true;
+        if (parent == null) return true;
+        const parentId = getNodeId(parent);
+        if (parentId == null) return true;
+        // by definition, for any node it's parent chain should already exist
+        // because we go downwards
+        const parentChain = paths.get(parentId);
+        if (parentChain == null) return true;
+        const leftSibling = parent.children[childIndex - 1];
+        const leftSiblingId = leftSibling ? getNodeId(leftSibling) : null;
+        const rightSibling = parent.children[childIndex + 1];
+        const rightSiblingId = rightSibling ? getNodeId(rightSibling) : null;
+        // (this node parent chain) is (parent chain of the parent node) + (the parent node itself)
+        const parentDesc = {
+            nodeId: parentId,
+            nodeType: parent.type.name,
+            nodeAttrs: parent.attrs,
+            nodeMarks: parent.marks.map((mark)=>mark.toJSON()),
+            childSiblingIds: [
+                leftSiblingId,
+                rightSiblingId
+            ],
+            childIndex: childIndex
+        };
+        const chain = [
+            parentDesc,
+            ...parentChain.chain
+        ];
+        paths.set(nodeId, {
+            nodeType: node.type.name,
+            node,
+            chain
+        });
+        return true;
+    });
+    trace("perf", "buildMaterializedPaths", "took", Number((performance.now() - perfPaths).toFixed(2)), "ms");
+    return paths;
+}

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

@@ -0,0 +1,3 @@
+export declare const DOC_NODE_ID = "__doc__";
+export declare const STRUCTURE_CHANGES_ADD_MARKS = "structure-changes-add-mark-type";
+export declare const STRUCTURE_CHANGES_REVERT_MARKS = "structure-changes-revert-mark-type";

package/dist/features/wrapUnwrap/constants.js

@@ -0,0 +1,3 @@
+export const DOC_NODE_ID = "__doc__";
+export const STRUCTURE_CHANGES_ADD_MARKS = "structure-changes-add-mark-type";
+export const STRUCTURE_CHANGES_REVERT_MARKS = "structure-changes-revert-mark-type";

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

@@ -0,0 +1 @@
+export declare function generateUniqueNodeId(): string;

package/dist/features/wrapUnwrap/generateUniqueNodeId.js

@@ -0,0 +1,6 @@
+export function generateUniqueNodeId() {
+    if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+        return crypto.randomUUID();
+    }
+    return `node-${Math.random().toString(36).slice(2)}`;
+}

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

@@ -0,0 +1,2 @@
+import { type Node } from "prosemirror-model";
+export declare function getNodeId(node: Node): string | null;

package/dist/features/wrapUnwrap/getNodeId.js

@@ -0,0 +1,5 @@
+export function getNodeId(node) {
+    const nodeId = node.attrs["id"];
+    if (typeof nodeId !== "string") return null;
+    return nodeId;
+}

package/dist/features/wrapUnwrap/revert/deleteNodeUpwards.d.ts

@@ -0,0 +1,3 @@
+import { type Transform } from "prosemirror-transform";
+import { type Node } from "prosemirror-model";
+export declare function deleteNodeUpwards(transform: Transform, node: Node, pos: number): void;

package/dist/features/wrapUnwrap/revert/deleteNodeUpwards.js

@@ -0,0 +1,37 @@
+import { getNodeId } from "../getNodeId.js";
+const TRACE_ENABLED = false;
+function trace(...args) {
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (!TRACE_ENABLED) return;
+    console.log("[deleteNodeUpwards]", "\n", ...args);
+}
+// delete a given node, and traverse upwards deleting parent nodes if they are now empty
+export function deleteNodeUpwards(transform, node, pos) {
+    let $mappedPos = transform.doc.resolve(pos);
+    trace("attempting to delete node", node.type.name, getNodeId(node), "\n", "node subtree:\n", node.toString(), "\n", "node parent:", $mappedPos.parent.type.name, getNodeId($mappedPos.parent), "\n", {
+        node,
+        parent: $mappedPos.parent
+    });
+    let deleteFrom = $mappedPos.pos;
+    let deleteTo = $mappedPos.pos + node.nodeSize;
+    while($mappedPos.depth > 0){
+        const $nextMappedPos = transform.doc.resolve($mappedPos.before());
+        if ($nextMappedPos.nodeAfter?.childCount !== 1) {
+            trace("stopping deletion at non-empty node:", $nextMappedPos.nodeAfter?.type.name, $nextMappedPos.nodeAfter == null ? null : getNodeId($nextMappedPos.nodeAfter), "\n", "non-empty node parent:", $nextMappedPos.parent.type.name, getNodeId($nextMappedPos.parent), "\n", "non-empty node subtree:\n", $nextMappedPos.nodeAfter?.toString(), "\n", "non-empty node subtree direct children:\n", $nextMappedPos.nodeAfter?.children.map((child)=>`${child.type.name} ${getNodeId(child) ?? "null"}`).join(", "), {
+                nonEmptyNode: $nextMappedPos.nodeAfter,
+                nonEmptyNodeParent: $nextMappedPos.parent
+            });
+            break;
+        }
+        $mappedPos = $nextMappedPos;
+        deleteFrom = $nextMappedPos.pos;
+        deleteTo = $nextMappedPos.pos + $nextMappedPos.nodeAfter.nodeSize;
+    }
+    trace("deleting subtree:\n", $mappedPos.nodeAfter?.toString(), "\n", "subtree root node:", $mappedPos.nodeAfter?.type.name, $mappedPos.nodeAfter == null ? null : getNodeId($mappedPos.nodeAfter), "\n", "subtree root parent node:", $mappedPos.parent.type.name, getNodeId($mappedPos.parent), "\n", "non-empty node subtree direct children:\n", $mappedPos.nodeAfter?.children.map((child)=>`${child.type.name} (${getNodeId(child) ?? "null"}`).join(", "), "\n", {
+        node: $mappedPos.nodeAfter,
+        parent: $mappedPos.parent,
+        $deleteFrom: $mappedPos.doc.resolve(deleteFrom),
+        $deleteTo: $mappedPos.doc.resolve(deleteTo)
+    });
+    transform.delete(deleteFrom, deleteTo);
+}

package/dist/features/wrapUnwrap/revert/index.d.ts

@@ -0,0 +1,5 @@
+import { Transform } from "prosemirror-transform";
+import { type Node } from "prosemirror-model";
+import { type SuggestionId } from "../../../generateId.js";
+export declare function revertAllStructureSuggestions(doc: Node, from?: number, to?: number): Transform;
+export declare function revertStructureSuggestion(doc: Node, suggestionId: SuggestionId): Transform;