@magic-marker/prosemirror-suggest-changes 0.3.2 → 0.3.3-wrap-unwrap.1

package/dist/features/wrapUnwrap/revertStructureSuggestions.js

@@ -0,0 +1,433 @@
+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("reverting structure mark group", suggestionId);
+    const suggestionIds = findOrderedSuggestionIdsToRevert(tr.doc, suggestionId, buildMaterializedPaths(tr.doc));
+    console.log("suggestion groups to revert", suggestionIds);
+    for (const suggestionId of suggestionIds){
+        revertStructureMarkGroup(tr, suggestionId);
+    }
+    console.groupEnd();
+}
+function revertStructureMarkGroup(tr, suggestionId) {
+    console.group("reverting structure suggestion", suggestionId);
+    let structureMark = findNextStructureMark(tr.doc, suggestionId);
+    while(structureMark !== null){
+        console.groupCollapsed("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);
+    });
+    console.log("mismatch?", mismatch);
+    if (mismatch == null) {
+        return Array.from(suggestionIds).reverse();
+    }
+    // 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) {
+        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);
+}

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

@@ -0,0 +1,2 @@
+import { type Parent } from "./types.js";
+export declare function sameParentChain(parentChainA: Parent[], parentChainB: Parent[]): boolean;

package/dist/features/wrapUnwrap/sameParentChain.js

@@ -0,0 +1,4 @@
+export function sameParentChain(parentChainA, parentChainB) {
+    if (parentChainA.length !== parentChainB.length) return false;
+    return parentChainA.every((parent, index)=>parent.nodeId === parentChainB[index]?.nodeId);
+}

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

@@ -0,0 +1,12 @@
+import { type Node } from "prosemirror-model";
+import { Plugin, PluginKey } from "prosemirror-state";
+import { Transform } from "prosemirror-transform";
+import { type NodeIdGenerator } from "./types.js";
+export declare const stableNodeIdsKey: PluginKey<{
+    completedInitialRun: boolean;
+}>;
+export declare const STABLE_NODE_IDS_PLUGIN_META = "stable-node-ids-plugin";
+export declare function stableNodeIds(generateNodeId: NodeIdGenerator): Plugin<{
+    completedInitialRun: boolean;
+}>;
+export declare function ensureStableIds(doc: Node, generateNodeId: NodeIdGenerator): Transform;

package/dist/features/wrapUnwrap/stableNodeIdsPlugin.js

@@ -0,0 +1,95 @@
+import { Plugin, PluginKey } from "prosemirror-state";
+import { getNodeId } from "./getNodeId.js";
+import { Transform } from "prosemirror-transform";
+// stable ids plugin
+// https://discuss.prosemirror.net/t/how-to-avoid-copying-attributes-to-new-paragraph/4568/2
+// (also checks and fix duplicates that inevitably appear)
+export const stableNodeIdsKey = new PluginKey("@handlewithcare/prosemirror-suggest-changes-stable-node-ids");
+export const STABLE_NODE_IDS_PLUGIN_META = "stable-node-ids-plugin";
+export function stableNodeIds(generateNodeId) {
+    return new Plugin({
+        key: stableNodeIdsKey,
+        appendTransaction (transactions, _oldState, newState) {
+            console.log("stableNodeIdsPlugin.appendTransaction");
+            const pluginState = stableNodeIdsKey.getState(newState);
+            // do nothing if doc hasn't changed (but make sure it runs initially)
+            const docChanged = transactions.some((transaction)=>transaction.docChanged);
+            if (!docChanged && pluginState?.completedInitialRun) {
+                console.warn("doc not changed, skipping stable node ids plugin", [
+                    ...transactions
+                ]);
+                return;
+            }
+            console.groupCollapsed("stableNodeIdsPlugin", "appendTransaction");
+            console.log("stableNodeIdsPlugin", "appendTransaction", [
+                ...transactions
+            ]);
+            const tr = newState.tr;
+            const transform = ensureStableIds(tr.doc, generateNodeId);
+            transform.steps.forEach((step)=>{
+                tr.step(step);
+            });
+            console.log("tr steps", tr.steps);
+            console.groupEnd();
+            if (!tr.steps.length) return;
+            tr.setMeta(stableNodeIdsKey, STABLE_NODE_IDS_PLUGIN_META);
+            return tr;
+        },
+        state: {
+            init () {
+                return {
+                    completedInitialRun: false
+                };
+            },
+            apply (tr, value) {
+                const meta = tr.getMeta(stableNodeIdsKey);
+                if (meta === STABLE_NODE_IDS_PLUGIN_META && !value.completedInitialRun) {
+                    return {
+                        completedInitialRun: true
+                    };
+                }
+                return value;
+            }
+        }
+    });
+}
+export function ensureStableIds(doc, generateNodeId) {
+    const tr = new Transform(doc);
+    const nodeIds = new Set();
+    tr.doc.descendants((node, pos, parent, index)=>{
+        if (node.isText) return false;
+        const nodeId = getNodeId(node);
+        // nodeId is set and is not duplicated
+        if (nodeId != null && !nodeIds.has(nodeId)) {
+            nodeIds.add(nodeId);
+            return true;
+        }
+        // nodeId is set and it is duplicated
+        if (nodeId != null && nodeIds.has(nodeId)) {
+            const id = generateNodeId(node, pos, parent, index);
+            nodeIds.add(id);
+            tr.setNodeMarkup(pos, node.type, {
+                ...node.attrs,
+                id
+            }, node.marks);
+            console.log("fixed duplicate id", id, "for node", node.type.name, "at pos", pos, {
+                was: nodeId,
+                is: id
+            });
+            return true;
+        }
+        // node id is not set
+        if (nodeId == null) {
+            const id = generateNodeId(node, pos, parent, index);
+            nodeIds.add(id);
+            tr.setNodeMarkup(pos, node.type, {
+                ...node.attrs,
+                id
+            }, node.marks);
+            console.log("set stable id", id, "for node", node.type.name, "at pos", pos);
+            return true;
+        }
+        return true;
+    });
+    return tr;
+}

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

@@ -0,0 +1,7 @@
+import { type Schema, type Node } from "prosemirror-model";
+import { Plugin, PluginKey } from "prosemirror-state";
+import { type SuggestionId } from "../../generateId.js";
+import { Transform } from "prosemirror-transform";
+export declare const structureChangesKey: PluginKey<any>;
+export declare function structureChangesPlugin(generateId?: (schema: Schema, doc?: Node) => SuggestionId): Plugin<any>;
+export declare function suggestStructureChanges(docBefore: Node, docAfter: Node, generateId?: (schema: Schema, doc?: Node) => SuggestionId): Transform;