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

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

@@ -0,0 +1,19 @@
+import { Transform } from "prosemirror-transform";
+import { revertStructureSuggestionsInDoc } from "./revertStructureSuggestions.js";
+export function revertAllStructureSuggestions(doc, from, to) {
+    const tr = new Transform(doc);
+    revertStructureSuggestionsInDoc({
+        tr,
+        from,
+        to
+    });
+    return tr;
+}
+export function revertStructureSuggestion(doc, suggestionId) {
+    const tr = new Transform(doc);
+    revertStructureSuggestionsInDoc({
+        tr,
+        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,4 @@
+import { deleteNodeUpwards } from "./deleteNodeUpwards.js";
+export function revertAddOp(_op, tr, node, pos) {
+    deleteNodeUpwards(tr, node, pos);
+}

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

@@ -0,0 +1,16 @@
+import { type Transform } from "prosemirror-transform";
+import { type MoveOp } from "../types.js";
+import { type Node } from "prosemirror-model";
+import { type Parent } from "../types.js";
+export declare function revertMoveOp(op: MoveOp, tr: Transform, node: Node, pos: number): void;
+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, child: Node): number | {
+    from: number;
+    to: number;
+};

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

@@ -0,0 +1,122 @@
+import { deleteNodeUpwards } from "./deleteNodeUpwards.js";
+import { getNodeId } from "../getNodeId.js";
+export function revertMoveOp(op, tr, node, pos) {
+    const parent = getDeepestSurvivingParent(op.from, tr.doc);
+    const child = wrapNodeInParentChain(parent.remainingChain, node);
+    const insertTo = findInsertionPos(parent.node, parent.pos, parent.parent, child);
+    if (typeof insertTo === "number") {
+        tr.insert(insertTo, child);
+    } else {
+        tr.replaceWith(insertTo.from, insertTo.to, child);
+    }
+    const mappedPos = tr.mapping.map(pos);
+    deleteNodeUpwards(tr, node, mappedPos);
+}
+// 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 root = chain.shift();
+    if (root == null) {
+        throw new Error("Parent chain is empty");
+    }
+    let result = {
+        parent: root,
+        node: doc,
+        pos: null
+    };
+    let remainingChain = [
+        ...chain
+    ];
+    // follow the chain up-down
+    // look for the node with the matching id in the children of the previously found node
+    for (const [index, item] of chain.entries()){
+        let found = false;
+        result.node.forEach((child, offset)=>{
+            if (found) return;
+            if (child.attrs["id"] !== item.nodeId) return;
+            found = true;
+            const pos = result.pos == null ? offset : result.pos + 1 + offset;
+            result = {
+                parent: item,
+                node: child,
+                pos
+            };
+            remainingChain = chain.slice(index + 1);
+        });
+        if (!found) break;
+    }
+    return {
+        parent: result.parent,
+        node: result.node,
+        pos: result.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));
+        const parentNode = nodeType.createAndFill(parent.nodeAttrs, child, marks);
+        if (parentNode == null) throw new Error(`Unable to create node ${nodeType.name} with child ${child.toString()}`);
+        child = parentNode;
+        child.check();
+    }
+    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, child) {
+    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) {
+        // special case: we need to insert as the first child, but the existing first child is an empty node of the same type
+        // in this case, we need to replace the existing first child with the new node
+        const firstChild = node.children[0];
+        if (parent.childSiblingIds[0] == null && firstChild?.type === child.type && firstChild.textContent === "") {
+            const from = pos != null ? pos + 1 : 0;
+            return {
+                from,
+                to: from + firstChild.nodeSize
+            };
+        }
+        // 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.content.size;
+}

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

@@ -0,0 +1,10 @@
+import { type Mark } from "prosemirror-model";
+import { Transform } from "prosemirror-transform";
+import { type SuggestionId } from "../../../generateId.js";
+export declare function revertStructureSuggestionsInDoc({ tr, suggestionId, from, to, }: {
+    tr: Transform;
+    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,236 @@
+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";
+const TRACE_ENABLED = false;
+function trace(...args) {
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (!TRACE_ENABLED) return;
+    console.log("[revertStructureSuggestions]", ...args);
+}
+export function revertStructureSuggestionsInDoc({ tr, suggestionId, from, to }) {
+    if (suggestionId) {
+        // when suggestionId is given, just revert it, no other logic required
+        revertStructureSuggestionWithPrerequisites(tr, suggestionId);
+        return;
+    }
+    if (from || to) {
+        // when range is given, find suggestion ids inside that range,
+        // but make sure to revert furthermost suggestions first
+        // todo: most likely a better strategy would be to search for the next suggestion in the updated doc after each reversal (and map from and to)
+        const { structure } = getSuggestionMarks(tr.doc.type.schema);
+        const structureMarks = [];
+        tr.doc.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;
+                structureMarks.push({
+                    mark,
+                    node,
+                    pos
+                });
+            });
+            return true;
+        });
+        structureMarks.sort((a, b)=>b.pos - a.pos);
+        const suggestionIds = new Set();
+        structureMarks.forEach(({ mark })=>{
+            suggestionIds.add(mark.attrs["id"]);
+        });
+        for (const suggestionId of suggestionIds){
+            revertStructureSuggestionWithPrerequisites(tr, suggestionId);
+        }
+        return;
+    }
+    // if no suggestion id nor range is given, revert all suggestions one by one, always take furthermost first
+    // after each reversal, the next suggestion is searched in the new doc after the previous reversal
+    let nextSuggestionId = findNextStructureSuggestion(tr.doc);
+    while(nextSuggestionId != null){
+        revertStructureSuggestionWithPrerequisites(tr, nextSuggestionId);
+        nextSuggestionId = findNextStructureSuggestion(tr.doc);
+    }
+}
+function revertStructureSuggestionWithPrerequisites(tr, suggestionId) {
+    const suggestionIds = buildOrderedSuggestionIds(tr.doc, suggestionId, buildMaterializedPaths(tr.doc));
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (TRACE_ENABLED) console.group("reverting structure suggestions", suggestionIds);
+    for (const suggestionId of suggestionIds){
+        revertOneStructureSuggestion(tr, suggestionId);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (TRACE_ENABLED) console.groupEnd();
+}
+function revertOneStructureSuggestion(tr, suggestionId) {
+    let count = 0;
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (TRACE_ENABLED) console.groupCollapsed("reverting structure suggestion", suggestionId);
+    let structureMark = findNextStructureMark(tr.doc, suggestionId);
+    while(structureMark !== null){
+        trace("reverting structure suggestion", suggestionId, "structure mark", structureMark.mark, "at pos", structureMark.pos, "at node", structureMark.node.toString());
+        revertStructureMark(tr, structureMark.mark, structureMark.pos);
+        structureMark = findNextStructureMark(tr.doc, suggestionId);
+        count++;
+    }
+    trace("reverted", count, "structure marks for suggestion", suggestionId);
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (TRACE_ENABLED) 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)}`);
+    }
+    const attrs = mark.attrs;
+    if (!guardStructureMarkAttrs(attrs)) {
+        console.warn("revertStructureMark", "invalid shape of structure mark attrs", {
+            attrs
+        });
+        return;
+    }
+    const op = attrs.data.op;
+    trace("reverting structure mark with suggestion id", attrs.id, "at node", node.toString(), "at pos", pos, "with op", op.op, {
+        mark,
+        node,
+        $pos: transform.doc.resolve(pos),
+        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();
+    }
+    // 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) {
+        trace("suggestion", match.attrs["id"], "is a prerequisite for suggestion", suggestionId);
+        suggestionIds.add(match.attrs["id"]);
+    }
+    return Array.from(suggestionIds).reverse();
+}
+function findNextStructureSuggestion(doc) {
+    const { structure } = getSuggestionMarks(doc.type.schema);
+    const structureMarks = [];
+    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;
+            structureMarks.push({
+                mark,
+                node,
+                pos
+            });
+        });
+        return true;
+    });
+    structureMarks.sort((a, b)=>b.pos - a.pos);
+    return structureMarks[0]?.mark.attrs["id"];
+}
+// given a suggestion id, find next structure mark to revert that belongs to that suggestion
+// always take furthermost mark first
+function findNextStructureMark(node, suggestionId) {
+    const { structure } = getSuggestionMarks(node.type.schema);
+    const structureMarks = [];
+    node.descendants((descendant, pos)=>{
+        // the assumption here is that a single node cannot have multiple structure marks with the same suggestion id
+        // check the invariant
+        const suggestionIds = new Set();
+        descendant.marks.forEach((mark)=>{
+            if (mark.type !== structure) return;
+            const markSuggestionId = mark.attrs["id"];
+            if (suggestionIds.has(markSuggestionId)) {
+                console.warn("node", node, "has multiple structure marks with the same suggestion id", markSuggestionId);
+            }
+            suggestionIds.add(markSuggestionId);
+        });
+        const mark = descendant.marks.find((mark)=>mark.type === structure && mark.attrs["id"] === suggestionId);
+        if (mark == null) return true;
+        structureMarks.push({
+            mark,
+            node: descendant,
+            pos
+        });
+        return true;
+    });
+    structureMarks.sort((a, b)=>b.pos - a.pos);
+    return structureMarks[0] ?? null;
+}

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/structureChangesPlugin.d.ts

@@ -0,0 +1,17 @@
+import { type Schema, type Node } from "prosemirror-model";
+import { Plugin, PluginKey } from "prosemirror-state";
+import { type SuggestionId } from "../../generateId.js";
+import { type StructuralContextPath } from "./types.js";
+import { Transform } from "prosemirror-transform";
+export declare const structureChangesKey: PluginKey<any>;
+export type SuggestStructureChangesReason = "split-derived-add";
+export interface SuggestStructureChangesResult {
+    handled: boolean;
+    transform: Transform;
+    reason?: SuggestStructureChangesReason;
+}
+export declare function structureChangesPlugin(generateId?: (schema: Schema, doc?: Node) => SuggestionId, opts?: {
+    experimental_trackStructures?: StructuralContextPath[];
+}): Plugin<any>;
+export declare function suggestStructureChanges(docBefore: Node, docAfter: Node, structuralContextPaths: StructuralContextPath[], generateId?: (schema: Schema, doc?: Node) => SuggestionId): SuggestStructureChangesResult;
+export declare function getRequiredStructuralContextPaths(structuralContextPaths: StructuralContextPath[] | undefined): StructuralContextPath[];