@magic-marker/prosemirror-suggest-changes 0.3.3-wrap-unwrap.7 → 0.3.3-wrap-unwrap.8

package/dist/commands.js

@@ -5,7 +5,8 @@ import { suggestChangesKey } from "./plugin.js";
 import { getSuggestionMarks } from "./utils.js";
 import { ZWSP } from "./constants.js";
 import { maybeRevertJoinMark } from "./features/joinOnDelete/index.js";
-import { applyAllStructureSuggestions, applyAllStructureSuggestionsOnNode, applyOneStructureSuggestion, revertAllStructureSuggestions, revertAllStructureSuggestionsOnNode, revertOneStructureSuggestion } from "./features/wrapUnwrap/revertStructureSuggestions.js";
+import { revertAllStructureSuggestions, revertStructureSuggestion } from "./features/wrapUnwrap/revert/index.js";
+import { applyAllStructureSuggestions, applyStructureSuggestion } from "./features/wrapUnwrap/apply/index.js";
 /**
  * Given a node and a transform, add a set of steps to the
  * transform that applies all marks of type markTypeToApply
@@ -136,7 +137,7 @@ function applyModificationsToTransform(node, tr, dir, suggestionId, from, to) {
 export function applySuggestionsToNode(node) {
     const { deletion, insertion } = getSuggestionMarks(node.type.schema);
     // first, create a structure transform that applies all structure changes on the given node
-    const structureTransform = applyAllStructureSuggestionsOnNode(node);
+    const structureTransform = applyAllStructureSuggestions(node);
     // then start a clear transform from the document where the structure changes are applied
     const suggestionsTransform = new Transform(structureTransform.doc);
     applySuggestionsToTransform(suggestionsTransform.doc, suggestionsTransform, insertion, deletion);
@@ -153,7 +154,7 @@ export function applySuggestionsToRange(doc, from, to) {
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     const nodeRange = doc.resolve(from).blockRange(doc.resolve(to));
     // create a structure transform that applies all structure changes on the given node range
-    const structureTransform = applyAllStructureSuggestionsOnNode(doc, nodeRange.start, nodeRange.end);
+    const structureTransform = applyAllStructureSuggestions(doc, nodeRange.start, nodeRange.end);
     // then start a clear transform from the document where the structure changes are applied
     const suggestionsTransform = new Transform(structureTransform.doc);
     applySuggestionsToTransform(suggestionsTransform.doc, suggestionsTransform, insertion, deletion, undefined, nodeRange.start, nodeRange.end);
@@ -204,7 +205,7 @@ export function applySuggestionsToRange(doc, from, to) {
     return (state, dispatch)=>{
         const { deletion, insertion } = getSuggestionMarks(state.schema);
         // create a structure transform that applies all structure changes on the given node range
-        const structureTransform = applyAllStructureSuggestionsOnNode(state.doc, from, to);
+        const structureTransform = applyAllStructureSuggestions(state.doc, from, to);
         // then start a clear transform from the document where the structure changes are applied
         const suggestionsTransform = new Transform(structureTransform.doc);
         applySuggestionsToTransform(suggestionsTransform.doc, suggestionsTransform, insertion, deletion, undefined, from, to);
@@ -236,7 +237,7 @@ export function applySuggestionsToRange(doc, from, to) {
     return (state, dispatch)=>{
         const { deletion, insertion } = getSuggestionMarks(state.schema);
         // create a structure transform that applies the given structure change on the given node
-        const structureTransform = applyOneStructureSuggestion(state.doc, suggestionId);
+        const structureTransform = applyStructureSuggestion(state.doc, suggestionId);
         // then start a clear transform from the document where the structure changes are applied
         const suggestionsTransform = new Transform(structureTransform.doc);
         applySuggestionsToTransform(suggestionsTransform.doc, suggestionsTransform, insertion, deletion, suggestionId, from, to);
@@ -298,7 +299,7 @@ export function applySuggestionsToRange(doc, from, to) {
     return (state, dispatch)=>{
         const { deletion, insertion } = getSuggestionMarks(state.schema);
         // create a structure transform that reverts all structure changes on the given node range
-        const structureTransform = revertAllStructureSuggestionsOnNode(state.doc, from, to);
+        const structureTransform = revertAllStructureSuggestions(state.doc, from, to);
         // then start a clear transform from the document where the structure changes are reverted
         const suggestionsTransform = new Transform(structureTransform.doc);
         applySuggestionsToTransform(suggestionsTransform.doc, suggestionsTransform, deletion, insertion, undefined, from, to);
@@ -330,7 +331,7 @@ export function applySuggestionsToRange(doc, from, to) {
     return (state, dispatch)=>{
         const { deletion, insertion } = getSuggestionMarks(state.schema);
         // create a structure transform that reverts the given structure change on the given node
-        const structureTransform = revertOneStructureSuggestion(state.doc, suggestionId);
+        const structureTransform = revertStructureSuggestion(state.doc, suggestionId);
         // then start a clear transform from the document where the structure changes are reverted
         const suggestionsTransform = new Transform(structureTransform.doc);
         applySuggestionsToTransform(suggestionsTransform.doc, suggestionsTransform, deletion, insertion, suggestionId, from, to);

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/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,31 @@
+// 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);
+    let deleteFrom = $mappedPos.pos;
+    let deleteTo = $mappedPos.pos + node.nodeSize;
+    console.log("deleteNodeUpwards", "initial delete range covers node", node.toString(), {
+        deleteFrom,
+        deleteTo,
+        $mappedPos
+    });
+    while($mappedPos.depth > 0){
+        const $nextMappedPos = transform.doc.resolve($mappedPos.before());
+        console.log("deleteNodeUpwards", "considering", $nextMappedPos.nodeAfter?.toString(), "for deletion", "childCount is", $nextMappedPos.nodeAfter?.childCount);
+        if ($nextMappedPos.nodeAfter?.childCount !== 1) break;
+        console.log("deleteNodeUpwards", "expanding to deleting node", $nextMappedPos.nodeAfter.toString());
+        $mappedPos = $nextMappedPos;
+        deleteFrom = $nextMappedPos.pos;
+        deleteTo = $nextMappedPos.pos + $nextMappedPos.nodeAfter.nodeSize;
+        console.log("deleteNodeUpwards", "expanded delete range to cover node", $nextMappedPos.nodeAfter.toString(), {
+            deleteFrom,
+            deleteTo,
+            $mappedPos: $nextMappedPos
+        });
+    }
+    console.log("deleteNodeUpwards", "final delete range covers node", $mappedPos.nodeAfter?.toString(), {
+        deleteFrom,
+        deleteTo,
+        $mappedPos
+    });
+    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(node: Node, from?: number, to?: number): Transform;
+export declare function revertStructureSuggestion(node: Node, suggestionId: SuggestionId): Transform;

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

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

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

@@ -0,0 +1,4 @@
+import { type Transform } from "prosemirror-transform";
+import { type AddOp } from "../types.js";
+import { type Node } from "prosemirror-model";
+export declare function revertAddOp(op: AddOp, tr: Transform, node: Node, pos: number): void;

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

@@ -0,0 +1,9 @@
+import { deleteNodeUpwards } from "./deleteNodeUpwards.js";
+export function revertAddOp(op, tr, node, pos) {
+    console.log("revertAddOp", "node", node.toString(), "was added at", pos, {
+        op,
+        node,
+        pos
+    });
+    deleteNodeUpwards(tr, node, pos);
+}

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

@@ -0,0 +1,14 @@
+import { type Transform } from "prosemirror-transform";
+import { type MoveOp } from "../types.js";
+import { type Node } from "prosemirror-model";
+import { type NodeWithChildren, type Parent } from "../types.js";
+export declare function revertMoveOp(op: MoveOp, tr: Transform, node: Node, pos: number): void;
+export declare function getNodesWithChildren(doc: Node): Map<string, NodeWithChildren>;
+export declare function getDeepestSurvivingParent(parentChain: Parent[], doc: Node): {
+    parent: Parent;
+    node: Node;
+    pos: number | null;
+    remainingChain: Parent[];
+};
+export declare function wrapNodeInParentChain(parentChain: Parent[], node: Node): Node;
+export declare function findInsertionPos(node: Node, pos: number | null, parent: Parent): number;

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

@@ -0,0 +1,149 @@
+import { deleteNodeUpwards } from "./deleteNodeUpwards.js";
+import { getNodeId } from "../getNodeId.js";
+import { guardDocParent, guardDocWithChildren } from "../types.js";
+export function revertMoveOp(op, tr, node, pos) {
+    console.log("revertMoveOp", "node", node.toString(), "was moved from", op.from, {
+        op,
+        node
+    });
+    const parent = getDeepestSurvivingParent(op.from, tr.doc);
+    console.log("revertMoveOp", "deepest surviving parent is", parent.node.toString(), {
+        parent
+    });
+    const child = wrapNodeInParentChain(parent.remainingChain, node);
+    console.log("revertMoveOp", "wrapped node in parent chain is", child.toString(), {
+        child
+    });
+    const insertionPos = findInsertionPos(parent.node, parent.pos, parent.parent);
+    console.log("revertMoveOp", "insertion pos", {
+        insertionPos
+    });
+    tr.insert(insertionPos, child);
+    const mappedPos = tr.mapping.map(pos);
+    deleteNodeUpwards(tr, node, mappedPos);
+}
+export function getNodesWithChildren(doc) {
+    const nodesWithChildren = new Map();
+    const docWithChildren = {
+        node: doc,
+        pos: null,
+        children: new Set()
+    };
+    doc.children.forEach((child)=>{
+        const nodeId = getNodeId(child);
+        if (nodeId == null) return;
+        docWithChildren.children.add(nodeId);
+    });
+    nodesWithChildren.set("__doc__", docWithChildren);
+    doc.descendants((node, pos)=>{
+        if (node.isText) return true;
+        const nodeId = getNodeId(node);
+        if (nodeId == null) return true;
+        if (nodesWithChildren.has(nodeId)) return true;
+        const children = node.children.reduce((acc, child)=>{
+            const childId = getNodeId(child);
+            if (childId == null) return acc;
+            acc.add(childId);
+            return acc;
+        }, new Set());
+        nodesWithChildren.set(nodeId, {
+            node,
+            pos,
+            children
+        });
+        return true;
+    });
+    return nodesWithChildren;
+}
+// given a chain of parent node descriptors, follow the chain from top to bottom as long as nodes exist
+// return the deepest existing parent node descriptor, along with the actual node and the pos in the current document
+// also return the remaining part of the chain
+export function getDeepestSurvivingParent(parentChain, doc) {
+    const chain = [
+        ...parentChain
+    ].reverse();
+    const currentNodes = getNodesWithChildren(doc);
+    let currentNode = currentNodes.get("__doc__"); // get doc node with children from current doc
+    if (!guardDocWithChildren(currentNode)) {
+        throw new Error("doc not found in nodesWithChildren");
+    }
+    let parent = chain.shift(); // get doc node descriptor from parent chain
+    if (!guardDocParent(parent)) {
+        throw new Error("doc parent not found in op chain");
+    }
+    let remainingChain = [];
+    for (const [index, nextParent] of chain.entries()){
+        const nextNodeWithChildren = currentNodes.get(nextParent.nodeId);
+        // nextParent does not exist in the current document at all
+        if (nextNodeWithChildren == null) {
+            remainingChain = chain.slice(index);
+            break;
+        }
+        // nextParent exists in the document, but in a different parent chain
+        if (!currentNode.children.has(nextParent.nodeId)) {
+            remainingChain = chain.slice(index);
+            break;
+        }
+        currentNode = nextNodeWithChildren;
+        parent = nextParent;
+    }
+    return {
+        parent,
+        node: currentNode.node,
+        pos: currentNode.pos,
+        remainingChain: [
+            ...remainingChain
+        ].reverse()
+    };
+}
+// given a chain of parent node descriptors and a node
+// wrap the node in the parent chain
+export function wrapNodeInParentChain(parentChain, node) {
+    let child = node.copy(node.content);
+    for (const parent of parentChain){
+        const schema = node.type.schema;
+        const nodeType = schema.nodes[parent.nodeType];
+        if (!nodeType) {
+            throw new Error(`node type ${parent.nodeType} not found in schema`);
+        }
+        const marks = parent.nodeMarks.map((mark)=>schema.markFromJSON(mark));
+        child = nodeType.create(parent.nodeAttrs, child, marks);
+    }
+    return child;
+}
+// given a node, its position, and a parent descriptor of this node in some parent chain,
+// use the info from the descriptor to find the insertion position in the node
+// first try to find siblings, fallback to end of node
+export function findInsertionPos(node, pos, parent) {
+    let leftSibling = null;
+    let rightSibling = null;
+    node.descendants((child, localChildPos)=>{
+        const childId = getNodeId(child);
+        if (childId == null) return false;
+        const globalChildPos = pos != null ? pos + 1 + localChildPos : localChildPos;
+        if (parent.childSiblingIds[0] === childId) {
+            leftSibling = {
+                node: child,
+                pos: globalChildPos
+            };
+        }
+        if (parent.childSiblingIds[1] === childId) {
+            rightSibling = {
+                node: child,
+                pos: globalChildPos
+            };
+        }
+        // iterate only direct children
+        return false;
+    });
+    if (rightSibling != null) {
+        // insert before right sibling
+        return rightSibling.pos;
+    }
+    if (leftSibling != null) {
+        // insert after left sibling
+        return leftSibling.pos + leftSibling.node.nodeSize;
+    }
+    // insert at end of node
+    return pos != null ? pos + node.nodeSize - 1 : node.nodeSize - 1;
+}

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

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

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

@@ -0,0 +1,180 @@
+import { getSuggestionMarks } from "../../../utils.js";
+import { getNodeId } from "../getNodeId.js";
+import { Transform } from "prosemirror-transform";
+import { guardStructureMarkAttrs } from "../types.js";
+import { sameParentChain } from "../sameParentChain.js";
+import { buildMaterializedPaths } from "../buildMaterializedPaths.js";
+import { revertAddOp } from "./revertAddOp.js";
+import { revertMoveOp } from "./revertMoveOp.js";
+export function revertStructureSuggestionsInNode({ tr, node, suggestionId, from, to }) {
+    const { structure } = getSuggestionMarks(node.type.schema);
+    // collect all structure mark ids
+    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){
+        revertStructureSuggestionWithPrerequisites(tr, suggestionId);
+    }
+}
+function revertStructureSuggestionWithPrerequisites(tr, suggestionId) {
+    console.group("revertStructureMarkGroupInOrder", "reverting structure mark group", suggestionId);
+    const suggestionIds = buildOrderedSuggestionIds(tr.doc, suggestionId, buildMaterializedPaths(tr.doc));
+    console.log("revertStructureMarkGroupInOrder", "suggestion groups to revert", suggestionIds);
+    for (const suggestionId of suggestionIds){
+        revertOneStructureSuggestion(tr, suggestionId);
+    }
+    console.groupEnd();
+}
+function revertOneStructureSuggestion(tr, suggestionId) {
+    console.group("revertStructureSuggestion", "reverting structure suggestion", suggestionId);
+    let structureMark = findNextStructureMark(tr.doc, suggestionId);
+    while(structureMark != null){
+        console.groupCollapsed("revertStructureSuggestion", "reverting structure mark", structureMark.mark.attrs["id"], "at pos", structureMark.$pos.pos, "at node", structureMark.node.toString(), {
+            structureMark
+        });
+        revertStructureMark(tr, structureMark.mark, structureMark.$pos.pos);
+        console.groupEnd();
+        structureMark = findNextStructureMark(tr.doc, suggestionId);
+    }
+    console.groupEnd();
+}
+export function revertStructureMark(tr, mark, pos) {
+    const transform = new Transform(tr.doc);
+    transform.removeNodeMark(pos, mark);
+    const node = transform.doc.nodeAt(pos);
+    if (!node) {
+        throw new Error(`Node not found at position ${String(pos)}`);
+    }
+    console.log("revertStructureMark", mark.attrs["id"], "at node", node.toString(), {
+        node,
+        mark,
+        pos
+    });
+    const attrs = mark.attrs;
+    if (!guardStructureMarkAttrs(attrs)) {
+        console.warn("revertStructureMark", "invalid shape of structure mark attrs", {
+            attrs
+        });
+        return;
+    }
+    const op = attrs.data.op;
+    switch(op.op){
+        case "add":
+            {
+                revertAddOp(op, transform, node, pos);
+                break;
+            }
+        case "move":
+            {
+                revertMoveOp(op, transform, node, pos);
+                break;
+            }
+        default:
+            console.warn("revertStructureMark", "unknown op", {
+                op
+            });
+            break;
+    }
+    transform.steps.forEach((step)=>{
+        tr.step(step);
+    });
+}
+// given a suggestion id
+// return an array of suggestion ids to revert
+// resolve suggestion dependencies, meaning,
+// if to revert suggestion id 1 you need to revert 2, and to revert 2 you need to revert 3
+// it will return [3,2,1]
+// todo: this should probably use topological sort at some point
+function buildOrderedSuggestionIds(node, suggestionId, materializedPaths) {
+    const { structure } = getSuggestionMarks(node.type.schema);
+    // collect marks with the given suggestionId
+    const markGroup = [];
+    node.descendants((descendant, pos)=>{
+        if (descendant.isText) return true;
+        if (!structure.isInSet(descendant.marks)) return true;
+        descendant.marks.forEach((mark)=>{
+            if (mark.type !== structure) return;
+            if (mark.attrs["id"] !== suggestionId) return;
+            markGroup.push({
+                mark,
+                node: descendant,
+                pos
+            });
+        });
+        return true;
+    });
+    const suggestionIds = new Set();
+    suggestionIds.add(suggestionId);
+    // find first mark that doesn't have a matching op.to
+    const mismatch = markGroup.find((mark)=>{
+        const nodeId = getNodeId(mark.node);
+        if (nodeId == null) return false;
+        const parentChain = materializedPaths.get(nodeId);
+        if (parentChain == null) return false;
+        const { attrs } = mark.mark;
+        if (!guardStructureMarkAttrs(attrs)) return false;
+        if (attrs.data.op.op !== "move") return false;
+        return !sameParentChain(attrs.data.op.to, parentChain.chain);
+    });
+    if (mismatch == null) {
+        return Array.from(suggestionIds).reverse();
+    }
+    console.log("findOrderedSuggestionIdsToRevert", "suggestion", suggestionId, "contains mark with a mismatched 'to':", mismatch, "searching a different suggestion with the matching 'to'...");
+    // find first mark on the node that does have a matching op.to
+    const match = mismatch.node.marks.find((mark)=>{
+        if (mark.type !== structure) return false;
+        const { attrs } = mark;
+        if (!guardStructureMarkAttrs(attrs)) return false;
+        if (attrs.data.op.op !== "move") return false;
+        const nodeId = getNodeId(mismatch.node);
+        if (nodeId == null) return false;
+        const parentChain = materializedPaths.get(nodeId);
+        if (parentChain == null) return false;
+        return sameParentChain(attrs.data.op.to, parentChain.chain);
+    });
+    if (match) {
+        console.log("findOrderedSuggestionIdsToRevert", "found suggestin with matching 'to'", match);
+        suggestionIds.add(match.attrs["id"]);
+    }
+    return Array.from(suggestionIds).reverse();
+}
+function findNextStructureMark(node, suggestionId) {
+    console.log("findNextStructureMark", suggestionId);
+    const { structure } = getSuggestionMarks(node.type.schema);
+    const structureMarks = [];
+    node.descendants((descendant, pos)=>{
+        const mark = descendant.marks.find((mark)=>mark.type === structure && mark.attrs["id"] === suggestionId);
+        if (mark == null) return true;
+        structureMarks.push({
+            mark,
+            node: descendant,
+            $pos: node.resolve(pos)
+        });
+        return true;
+    });
+    structureMarks.sort((a, b)=>b.$pos.depth - a.$pos.depth);
+    if (structureMarks[0]) {
+        console.log("findStructureMark", "found structure mark with id", suggestionId, {
+            structureMark: structureMarks[0],
+            suggestionId
+        });
+    } else {
+        console.log("findStructureMark", "no structure mark found with id", suggestionId);
+    }
+    return structureMarks[0];
+}

package/package.json

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

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

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

package/dist/features/wrapUnwrap/revertStructureSuggestions.js

@@ -1,434 +0,0 @@
-import { getSuggestionMarks } from "../../utils.js";
-import { getNodeId } from "./getNodeId.js";
-import { Transform } from "prosemirror-transform";
-import { guardDocParent, guardDocWithChildren, guardStructureMarkAttrs } from "./types.js";
-import { sameParentChain } from "./sameParentChain.js";
-import { buildMaterializedPaths } from "./buildMaterializedPaths.js";
-/* public */ export function applyAllStructureSuggestions(node) {
-    const tr = new Transform(node);
-    applyAllStructureMarks(tr);
-    return tr;
-}
-export function revertAllStructureSuggestions(node) {
-    const tr = new Transform(node);
-    revertAllStructureMarks(tr);
-    return tr;
-}
-export function applyOneStructureSuggestion(node, suggestionId) {
-    const tr = new Transform(node);
-    applyStructureMarkGroup(tr, suggestionId);
-    return tr;
-}
-export function revertOneStructureSuggestion(node, suggestionId) {
-    const tr = new Transform(node);
-    revertStructureMarkGroupInOrder(tr, suggestionId);
-    return tr;
-}
-export function applyAllStructureSuggestionsOnNode(node, from, to) {
-    const tr = new Transform(node);
-    applyAllStructureMarksOnNode(tr, node, from, to);
-    return tr;
-}
-export function revertAllStructureSuggestionsOnNode(node, from, to) {
-    const tr = new Transform(node);
-    revertAllStructureMarksOnNode(tr, node, from, to);
-    return tr;
-}
-/* private */ function applyAllStructureMarks(tr) {
-    applyAllStructureMarksOnNode(tr, tr.doc);
-}
-function revertAllStructureMarks(tr) {
-    revertAllStructureMarksOnNode(tr, tr.doc);
-}
-function applyAllStructureMarksOnNode(tr, node, 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 suggestionId = mark.attrs["id"];
-            suggestionIds.add(suggestionId);
-        });
-        return true;
-    });
-    for (const suggestionId of suggestionIds){
-        applyStructureMarkGroup(tr, suggestionId);
-    }
-}
-function revertAllStructureMarksOnNode(tr, node, from, to) {
-    const { structure } = getSuggestionMarks(node.type.schema);
-    // collect all structure mark ids
-    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 suggestionId = mark.attrs["id"];
-            suggestionIds.add(suggestionId);
-        });
-        return true;
-    });
-    for (const suggestionId of suggestionIds){
-        revertStructureMarkGroupInOrder(tr, suggestionId);
-    }
-}
-function applyStructureMarkGroup(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 revertStructureMarkGroupInOrder(tr, suggestionId) {
-    console.group("revertStructureMarkGroupInOrder", "reverting structure mark group", suggestionId);
-    const suggestionIds = findOrderedSuggestionIdsToRevert(tr.doc, suggestionId, buildMaterializedPaths(tr.doc));
-    console.log("revertStructureMarkGroupInOrder", "suggestion groups to revert", suggestionIds);
-    for (const suggestionId of suggestionIds){
-        revertStructureMarkGroup(tr, suggestionId);
-    }
-    console.groupEnd();
-}
-function revertStructureMarkGroup(tr, suggestionId) {
-    console.group("revertStructureMarkGroup", "reverting structure suggestion", suggestionId);
-    let structureMark = findNextStructureMark(tr.doc, suggestionId);
-    while(structureMark !== null){
-        console.groupCollapsed("revertStructureMarkGroup", "reverting structure mark", structureMark.mark.attrs["id"], "at pos", structureMark.pos, "at node", structureMark.node.toString(), {
-            structureMark
-        });
-        revertStructureMark(tr, structureMark.mark, structureMark.pos);
-        console.groupEnd();
-        structureMark = findNextStructureMark(tr.doc, suggestionId);
-    }
-    console.groupEnd();
-}
-function applyStructureMark(tr, mark, pos) {
-    tr.removeNodeMark(pos, mark);
-}
-function revertStructureMark(tr, mark, pos) {
-    const transform = new Transform(tr.doc);
-    transform.removeNodeMark(pos, mark);
-    const node = transform.doc.nodeAt(pos);
-    if (!node) {
-        throw new Error(`Node not found at position ${String(pos)}`);
-    }
-    console.log("revertStructureMark", mark.attrs["id"], "at node", node.toString(), {
-        node,
-        mark,
-        pos
-    });
-    const attrs = mark.attrs;
-    if (!guardStructureMarkAttrs(attrs)) {
-        console.warn("revertStructureMark", "invalid shape of structure mark attrs", {
-            attrs
-        });
-        return;
-    }
-    const op = attrs.data.op;
-    switch(op.op){
-        case "add":
-            {
-                revertAdd(op, transform, node, pos);
-                break;
-            }
-        case "move":
-            {
-                revertMove(op, transform, node, pos);
-                break;
-            }
-        default:
-            console.warn("revertStructureMark", "unknown op", {
-                op
-            });
-            break;
-    }
-    transform.steps.forEach((step)=>{
-        tr.step(step);
-    });
-}
-function revertAdd(op, tr, node, pos) {
-    console.log("revertAdd", "node", node.toString(), "was added at", pos, {
-        op,
-        node,
-        pos
-    });
-    deleteNodeWithParents(tr, node, pos);
-}
-function revertMove(op, tr, node, pos) {
-    console.log("revertMove", "node", node.toString(), "was moved from", op.from, {
-        op,
-        node
-    });
-    const parent = getDeepestSurvivingParent(op.from, tr.doc);
-    console.log("revertMove", "deepest surviving parent is", parent.node.toString(), {
-        parent
-    });
-    const child = wrapNodeInParentChain(parent.remainingChain, node);
-    console.log("revertMove", "wrapped node in parent chain is", child.toString(), {
-        child
-    });
-    const insertionPos = findInsertionPos(parent.node, parent.pos, parent.parent);
-    console.log("revertMove", "insertion pos", {
-        insertionPos
-    });
-    tr.insert(insertionPos, child);
-    const mappedPos = tr.mapping.map(pos);
-    deleteNodeWithParents(tr, node, mappedPos);
-}
-// given a suggestion id
-// return an array of suggestion ids to revert
-// resolve suggestion dependencies, meaning,
-// if to revert suggestion id 1 you need to revert 2, and to revert 2 you need to revert 3
-// it will return [3,2,1]
-// todo: this should probably use topological sort at some point
-function findOrderedSuggestionIdsToRevert(node, suggestionId, materializedPaths) {
-    const { structure } = getSuggestionMarks(node.type.schema);
-    // collect marks with the given suggestionId
-    const markGroup = [];
-    node.descendants((descendant, pos)=>{
-        if (descendant.isText) return true;
-        if (!structure.isInSet(descendant.marks)) return true;
-        descendant.marks.forEach((mark)=>{
-            if (mark.type !== structure) return;
-            if (mark.attrs["id"] !== suggestionId) return;
-            markGroup.push({
-                mark,
-                node: descendant,
-                pos
-            });
-        });
-        return true;
-    });
-    const suggestionIds = new Set();
-    suggestionIds.add(suggestionId);
-    // find first mark that doesn't have a matching op.to
-    const mismatch = markGroup.find((mark)=>{
-        const nodeId = getNodeId(mark.node);
-        if (nodeId == null) return false;
-        const parentChain = materializedPaths.get(nodeId);
-        if (parentChain == null) return false;
-        const { attrs } = mark.mark;
-        if (!guardStructureMarkAttrs(attrs)) return false;
-        if (attrs.data.op.op !== "move") return false;
-        return !sameParentChain(attrs.data.op.to, parentChain.chain);
-    });
-    if (mismatch == null) {
-        return Array.from(suggestionIds).reverse();
-    }
-    console.log("findOrderedSuggestionIdsToRevert", "suggestion", suggestionId, "contains mark with a mismatched 'to':", mismatch, "searching a different suggestion with the matching 'to'...");
-    // find first mark on the node that does have a matching op.to
-    const match = mismatch.node.marks.find((mark)=>{
-        if (mark.type !== structure) return false;
-        const { attrs } = mark;
-        if (!guardStructureMarkAttrs(attrs)) return false;
-        if (attrs.data.op.op !== "move") return false;
-        const nodeId = getNodeId(mismatch.node);
-        if (nodeId == null) return false;
-        const parentChain = materializedPaths.get(nodeId);
-        if (parentChain == null) return false;
-        return sameParentChain(attrs.data.op.to, parentChain.chain);
-    });
-    if (match) {
-        console.log("findOrderedSuggestionIdsToRevert", "found suggestin with matching 'to'", match);
-        suggestionIds.add(match.attrs["id"]);
-    }
-    return Array.from(suggestionIds).reverse();
-}
-function findNextStructureMark(doc, suggestionId) {
-    console.log("findNextStructureMark", suggestionId);
-    const { structure } = getSuggestionMarks(doc.type.schema);
-    let structureMark = null;
-    doc.nodesBetween(0, doc.content.size, (node, pos)=>{
-        const mark = node.marks.find((mark)=>mark.type === structure && mark.attrs["id"] === suggestionId);
-        if (mark) {
-            structureMark = {
-                mark,
-                node,
-                pos
-            };
-        }
-        return structureMark === null;
-    });
-    if (structureMark) {
-        console.log("findStructureMark", "found structure mark with id", suggestionId, {
-            structureMark,
-            suggestionId
-        });
-    } else {
-        console.log("findStructureMark", "no structure mark found with id", suggestionId);
-    }
-    return structureMark;
-}
-function getNodesWithChildren(doc) {
-    const nodesWithChildren = new Map();
-    const docWithChildren = {
-        node: doc,
-        pos: null,
-        children: new Set()
-    };
-    doc.children.forEach((child)=>{
-        const nodeId = getNodeId(child);
-        if (nodeId == null) return;
-        docWithChildren.children.add(nodeId);
-    });
-    nodesWithChildren.set("__doc__", docWithChildren);
-    doc.descendants((node, pos)=>{
-        if (node.isText) return true;
-        const nodeId = getNodeId(node);
-        if (nodeId == null) return true;
-        if (nodesWithChildren.has(nodeId)) return true;
-        const children = node.children.reduce((acc, child)=>{
-            const childId = getNodeId(child);
-            if (childId == null) return acc;
-            acc.add(childId);
-            return acc;
-        }, new Set());
-        nodesWithChildren.set(nodeId, {
-            node,
-            pos,
-            children
-        });
-        return true;
-    });
-    return nodesWithChildren;
-}
-// given a chain of parent node descriptors, follow the chain from top to bottom as long as nodes exist
-// return the deepest existing parent node descriptor, along with the actual node and the pos in the current document
-// also return the remaining part of the chain
-function getDeepestSurvivingParent(parentChain, doc) {
-    const chain = [
-        ...parentChain
-    ].reverse();
-    const currentNodes = getNodesWithChildren(doc);
-    let currentNode = currentNodes.get("__doc__"); // get doc node with children from current doc
-    if (!guardDocWithChildren(currentNode)) {
-        throw new Error("doc not found in nodesWithChildren");
-    }
-    let parent = chain.shift(); // get doc node descriptor from parent chain
-    if (!guardDocParent(parent)) {
-        throw new Error("doc parent not found in op chain");
-    }
-    let remainingChain = [];
-    for (const [index, nextParent] of chain.entries()){
-        const nextNodeWithChildren = currentNodes.get(nextParent.nodeId);
-        // nextParent does not exist in the current document at all
-        if (nextNodeWithChildren == null) {
-            remainingChain = chain.slice(index);
-            break;
-        }
-        // nextParent exists in the document, but in a different parent chain
-        if (!currentNode.children.has(nextParent.nodeId)) {
-            remainingChain = chain.slice(index);
-            break;
-        }
-        currentNode = nextNodeWithChildren;
-        parent = nextParent;
-    }
-    return {
-        parent,
-        node: currentNode.node,
-        pos: currentNode.pos,
-        remainingChain: [
-            ...remainingChain
-        ].reverse()
-    };
-}
-// given a chain of parent node descriptors and a node
-// wrap the node in the parent chain
-function wrapNodeInParentChain(parentChain, node) {
-    let child = node.copy(node.content);
-    for (const parent of parentChain){
-        const schema = node.type.schema;
-        const nodeType = schema.nodes[parent.nodeType];
-        if (!nodeType) {
-            throw new Error(`node type ${parent.nodeType} not found in schema`);
-        }
-        const marks = parent.nodeMarks.map((mark)=>schema.markFromJSON(mark));
-        child = nodeType.create(parent.nodeAttrs, child, marks);
-    }
-    return child;
-}
-// given a node, its position, and a parent descriptor of this node in some parent chain,
-// use the info from the descriptor to find the insertion position in the node
-// first try to find siblings, fallback to end of node
-function findInsertionPos(node, pos, parent) {
-    let leftSibling = null;
-    let rightSibling = null;
-    node.descendants((child, localChildPos)=>{
-        const childId = getNodeId(child);
-        if (childId == null) return false;
-        const globalChildPos = pos != null ? pos + 1 + localChildPos : localChildPos;
-        if (parent.childSiblingIds[0] === childId) {
-            leftSibling = {
-                node: child,
-                pos: globalChildPos
-            };
-        }
-        if (parent.childSiblingIds[1] === childId) {
-            rightSibling = {
-                node: child,
-                pos: globalChildPos
-            };
-        }
-        // iterate only direct children
-        return false;
-    });
-    if (rightSibling != null) {
-        // insert before right sibling
-        return rightSibling.pos;
-    }
-    if (leftSibling != null) {
-        // insert after left sibling
-        return leftSibling.pos + leftSibling.node.nodeSize;
-    }
-    // insert at end of node
-    return pos != null ? pos + node.nodeSize - 1 : node.nodeSize - 1;
-}
-// delete a given node, and traverse upwards deleting parent nodes if they are now empty
-function deleteNodeWithParents(transform, node, pos) {
-    let $mappedPos = transform.doc.resolve(pos);
-    let deleteFrom = $mappedPos.pos;
-    let deleteTo = $mappedPos.pos + node.nodeSize;
-    console.log("deleteNodeWithParents", "initial delete range covers node", node.toString(), {
-        deleteFrom,
-        deleteTo,
-        $mappedPos
-    });
-    while($mappedPos.depth > 0){
-        $mappedPos = transform.doc.resolve($mappedPos.before());
-        if ($mappedPos.nodeAfter?.childCount !== 1) break;
-        deleteFrom = $mappedPos.pos;
-        deleteTo = $mappedPos.pos + $mappedPos.nodeAfter.nodeSize;
-        console.log("deleteNodeWithParents", "expanded delete range to cover node", $mappedPos.nodeAfter.toString(), {
-            deleteFrom,
-            deleteTo,
-            $mappedPos
-        });
-    }
-    console.log("deleteNodeWithParents", "final delete range covers node", $mappedPos.nodeAfter?.toString(), {
-        deleteFrom,
-        deleteTo,
-        $mappedPos
-    });
-    transform.delete(deleteFrom, deleteTo);
-}