@magic-marker/prosemirror-suggest-changes 0.1.8

package/dist/features/joinBlocks/index.js

@@ -0,0 +1,64 @@
+import { getZWSPPairsInRange } from "./utils/getZWSPPairsInRange.js";
+import { canJoin, Mapping } from "prosemirror-transform";
+const calculateDepthAndPos = (from, to)=>{
+    return {
+        pos: (from + to) / 2,
+        depth: (to - from) / 2
+    };
+};
+export const joinBlocks = (trackedTransaction, stepFrom, stepTo, insertionMarkType)=>{
+    const doc = trackedTransaction.doc;
+    // Record the step index before we start deleting
+    const startStep = trackedTransaction.steps.length;
+    // step 1 find pairs
+    const { pairs, ZWSPAtToBoundary, ZWSPAtFromBoundary } = getZWSPPairsInRange(doc, stepFrom, stepTo, insertionMarkType);
+    // Step 2: Find all insertion-marked content in the deletion range
+    // These ranges will be actually deleted (reverting the insertion)
+    // Remove ZWSPs on the boundaries if they are in the list pairs
+    const insertedRanges = [];
+    if (ZWSPAtFromBoundary) {
+        const from = ZWSPAtFromBoundary.pos;
+        insertedRanges.push({
+            from,
+            to: from + 1
+        });
+    }
+    doc.nodesBetween(stepFrom, stepTo, (node, pos)=>{
+        if (insertionMarkType.isInSet(node.marks)) {
+            insertedRanges.push({
+                from: Math.max(pos, stepFrom),
+                to: Math.min(pos + node.nodeSize, stepTo)
+            });
+            return false;
+        }
+        return true;
+    });
+    if (ZWSPAtToBoundary) {
+        const from = ZWSPAtToBoundary.pos;
+        insertedRanges.push({
+            from,
+            to: from + 1
+        });
+    }
+    pairs.reverse();
+    insertedRanges.reverse();
+    // step 3: join blocks at multiple depths as needed
+    for (const p of pairs){
+        const fromPos = p.left?.pos;
+        const toPos = p.right?.pos;
+        if (!fromPos || !toPos) {
+            continue;
+        }
+        const { depth, pos } = calculateDepthAndPos(fromPos + 1, toPos);
+        if (canJoin(trackedTransaction.doc, pos)) {
+            trackedTransaction.join(pos, depth);
+        }
+    }
+    // step 4: remove inserted ranges
+    const joinSteps = trackedTransaction.steps.slice(startStep);
+    const joinMapping = new Mapping(joinSteps.map((s)=>s.getMap()));
+    for (const range of insertedRanges){
+        trackedTransaction.delete(joinMapping.map(range.from), joinMapping.map(range.to));
+    }
+    return !!pairs.length;
+};

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

@@ -0,0 +1,11 @@
+import type { Node } from "prosemirror-model";
+import type { SuggestionId } from "../../generateId.js";
+export interface CharResult {
+    char: string;
+    node: Node;
+    pos: number;
+}
+export interface ZWSPWithPos extends CharResult {
+    id: SuggestionId;
+}
+export declare const ZWSP = "\u200B";

package/dist/features/joinBlocks/types.js

@@ -0,0 +1 @@
+export const ZWSP = "\u200B";

package/dist/features/joinBlocks/utils/boundary.d.ts

@@ -0,0 +1,10 @@
+import type { MarkType, Node } from "prosemirror-model";
+import type { CharResult, ZWSPWithPos } from "../types.js";
+/**
+ * Finds the previous character and its containing text node.
+ * Handles being inside a node, at a node boundary, or across block boundaries.
+ */
+export declare function getPreviousCharAndNode(doc: Node, pos: number): CharResult | null;
+export declare function getNextCharAndNode(doc: Node, pos: number): CharResult | null;
+export declare const getNextZWSP: (doc: Node, pos: number, insertionMarkType: MarkType) => ZWSPWithPos | undefined;
+export declare const getPreviousZWSP: (doc: Node, pos: number, insertionMarkType: MarkType) => ZWSPWithPos | undefined;

package/dist/features/joinBlocks/utils/boundary.js

@@ -0,0 +1,147 @@
+import { ZWSP } from "../types.js";
+/**
+ * Finds the previous character and its containing text node.
+ * Handles being inside a node, at a node boundary, or across block boundaries.
+ */ export function getPreviousCharAndNode(doc, pos) {
+    const $pos = doc.resolve(pos);
+    // SCENARIO A: We are inside a text node
+    // (nodeBefore is null because we aren't at a boundary, but textOffset > 0)
+    if (!$pos.nodeBefore && $pos.parent.isTextblock && $pos.textOffset > 0) {
+        const innerNode = $pos.parent.child($pos.index());
+        if (innerNode.isText && innerNode.text) {
+            return {
+                char: innerNode.text.charAt($pos.textOffset - 1),
+                node: innerNode,
+                pos: pos - 1
+            };
+        }
+    }
+    // SCENARIO B: We are at a boundary, and the node immediately before is text
+    // Example: <strong>Bold</strong>|Plain
+    if ($pos.nodeBefore?.isText && $pos.nodeBefore.text) {
+        return {
+            char: $pos.nodeBefore.text.slice(-1),
+            node: $pos.nodeBefore,
+            pos: pos - 1
+        };
+    }
+    // SCENARIO C: We are at the start of a block or after a non-text node (Image, etc.)
+    // We need to traverse backwards up the tree.
+    return findLastTextNodeBackwards(doc, pos);
+}
+/**
+ * Helper: Recursively scans backwards from a position to find the nearest text node.
+ */ function findLastTextNodeBackwards(doc, startPos) {
+    let pos = startPos;
+    while(pos > 0){
+        const $pos = doc.resolve(pos);
+        const { nodeBefore } = $pos;
+        // 1. Found a text node
+        if (nodeBefore?.isText && nodeBefore.text) {
+            return {
+                char: nodeBefore.text.slice(-1),
+                node: nodeBefore,
+                pos: pos - 1
+            };
+        }
+        // 2. Start of a block -> Move out to parent
+        if (!nodeBefore) {
+            if ($pos.depth === 0) break; // Top of doc
+            pos = $pos.before();
+            continue;
+        }
+        // 3. Previous node is an Element (Paragraph, etc) -> Enter it
+        if (!nodeBefore.isLeaf) {
+            pos -= 1; // Enter the block from the end
+        } else {
+            pos -= nodeBefore.nodeSize;
+        }
+    }
+    return null;
+}
+export function getNextCharAndNode(doc, pos) {
+    const $pos = doc.resolve(pos);
+    const parent = $pos.parent;
+    // SCENARIO A: We are inside a text node (Inline)
+    // We check if there is text "after" our current offset within the current child node.
+    if (parent.isTextblock && !$pos.nodeAfter) {
+        const index = $pos.index();
+        const child = parent.maybeChild(index); // Get child at current index
+        // Check if we are inside a text node and NOT at the very end of it
+        if (child?.text && $pos.textOffset < child.nodeSize) {
+            return {
+                char: child.text.charAt($pos.textOffset),
+                node: child,
+                pos: pos
+            };
+        }
+    }
+    // SCENARIO B: We are at a boundary, and the node immediately after is text
+    // Example: <p>End|<strong>Bold</strong></p>
+    if ($pos.nodeAfter?.text) {
+        return {
+            char: $pos.nodeAfter.text.charAt(0),
+            node: $pos.nodeAfter,
+            pos: pos
+        };
+    }
+    // SCENARIO C: Recursive search forward
+    return findNextTextNodeForwards(doc, pos);
+}
+/**
+ * Helper: Recursively scans forwards to find the nearest text node.
+ */ function findNextTextNodeForwards(doc, startPos) {
+    let pos = startPos;
+    const docSize = doc.content.size;
+    while(pos < docSize){
+        const $pos = doc.resolve(pos);
+        const { nodeAfter } = $pos;
+        // 1. Found a text node
+        if (nodeAfter?.text) {
+            return {
+                char: nodeAfter.text.charAt(0),
+                node: nodeAfter,
+                pos: pos
+            };
+        }
+        // 2. End of a block (nodeAfter is null) -> Move out to parent
+        // Example: <p>Text|</p> -> Move to after </p>
+        if (!nodeAfter) {
+            if ($pos.depth === 0) break; // End of doc
+            pos = $pos.after();
+            continue;
+        }
+        // 3. Next node is an Element (Paragraph, Blockquote) -> Enter it
+        if (!nodeAfter.isLeaf) {
+            pos += 1; // Enter the block from the start
+        } else {
+            pos += nodeAfter.nodeSize;
+        }
+    }
+    return null;
+}
+// TODO: Unify with next
+export const getNextZWSP = (doc, pos, insertionMarkType)=>{
+    // check if we have an insertion mark on the node
+    const nextCharInfo = getNextCharAndNode(doc, pos);
+    if (nextCharInfo?.char !== ZWSP) return;
+    const insertionMark = insertionMarkType.isInSet(nextCharInfo.node.marks);
+    const id = insertionMark?.attrs["id"];
+    if (!id) return;
+    return {
+        ...nextCharInfo,
+        id
+    };
+};
+export const getPreviousZWSP = (doc, pos, insertionMarkType)=>{
+    // check if we have an insertion mark on the node
+    const nextCharInfo = getPreviousCharAndNode(doc, pos);
+    if (nextCharInfo?.char !== ZWSP) return;
+    const insertionMark = insertionMarkType.isInSet(nextCharInfo.node.marks);
+    const id = insertionMark?.attrs["id"];
+    if (!id) return;
+    return {
+        ...nextCharInfo,
+        id
+    };
+};

package/dist/features/joinBlocks/utils/getZWSPPairsInRange.d.ts

@@ -0,0 +1,10 @@
+import { type MarkType, type Node } from "prosemirror-model";
+import type { ZWSPWithPos } from "../types.js";
+export declare const getZWSPPairsInRange: (doc: Node, from: number, to: number, insertionMarkType: MarkType) => {
+    pairs: {
+        left?: ZWSPWithPos;
+        right?: ZWSPWithPos;
+    }[];
+    ZWSPAtFromBoundary: ZWSPWithPos | undefined;
+    ZWSPAtToBoundary: ZWSPWithPos | undefined;
+};

package/dist/features/joinBlocks/utils/getZWSPPairsInRange.js

@@ -0,0 +1,57 @@
+import { ZWSP } from "../types.js";
+import { getNextZWSP, getPreviousZWSP } from "../utils/boundary.js";
+export const getZWSPPairsInRange = (doc, from, to, insertionMarkType)=>{
+    const previousZWSP = getPreviousZWSP(doc, from, insertionMarkType);
+    const nextZWSP = getNextZWSP(doc, to, insertionMarkType);
+    const pairs = [];
+    let currentEndingZWSP = previousZWSP;
+    doc.nodesBetween(from, to, (node, pos, parent, index)=>{
+        // two cases: we have a left in currentPair and we're at 0 index
+        const insertionMarkId = insertionMarkType.isInSet(node.marks)?.attrs["id"];
+        if (currentEndingZWSP && index === 0 && node.text?.[0] === ZWSP && insertionMarkId && currentEndingZWSP.id === insertionMarkId && // Prevent self-pairing: don't pair a ZWSP with itself when both
+        // the previousZWSP and the current node's ZWSP are at the same position
+        currentEndingZWSP.pos !== pos) {
+            // maybe it's pos + 1
+            pairs.push({
+                left: currentEndingZWSP,
+                right: {
+                    pos,
+                    node,
+                    char: ZWSP,
+                    id: insertionMarkId
+                }
+            });
+        // don't return yet, we'll have to check if this text node contains
+        }
+        if (node.isText) {
+            // WE HAVE TO remove ending zwsp anyway. Either we found a pair, on the beginning of the next block
+            // or we did not, but then we don't have a matching pair on a block boundary.
+            currentEndingZWSP = undefined;
+        }
+        const lastTextInParent = node.isText && parent?.childCount === index + 1;
+        const lastCharInNode = node.text?.[node.text.length - 1];
+        if (node.isText && lastTextInParent && lastCharInNode === ZWSP && insertionMarkId) {
+            // unsure about nodesize -1
+            currentEndingZWSP = {
+                pos: pos + node.nodeSize - 1,
+                node,
+                char: ZWSP,
+                id: insertionMarkId
+            };
+        }
+        return true;
+    });
+    if (currentEndingZWSP?.id && currentEndingZWSP.id === nextZWSP?.id) {
+        pairs.push({
+            left: currentEndingZWSP,
+            right: nextZWSP
+        });
+    }
+    const usedFromBoundaryZWSP = pairs[0]?.left === previousZWSP;
+    const usedToBoundaryZWSP = pairs[pairs.length - 1]?.right === nextZWSP;
+    return {
+        pairs,
+        ZWSPAtFromBoundary: usedFromBoundaryZWSP ? previousZWSP : undefined,
+        ZWSPAtToBoundary: usedToBoundaryZWSP ? nextZWSP : undefined
+    };
+};

package/dist/findSuggestionMarkEnd.d.ts

@@ -0,0 +1,2 @@
+import { type MarkType, type ResolvedPos } from "prosemirror-model";
+export declare function findSuggestionMarkEnd($pos: ResolvedPos, markType: MarkType): number;

package/dist/findSuggestionMarkEnd.js

@@ -0,0 +1,38 @@
+export function findSuggestionMarkEnd($pos, markType) {
+    const initialDeletionMark = ($pos.nodeAfter ?? $pos.nodeBefore)?.marks.find((mark)=>mark.type === markType);
+    if (!initialDeletionMark) {
+        return $pos.pos;
+    }
+    let afterPos = $pos.pos + ($pos.nodeAfter?.nodeSize ?? 0);
+    // We always return from this while loop
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    while(true){
+        const $afterPos = $pos.doc.resolve(afterPos);
+        if ($afterPos.depth < 1 || $afterPos.nodeAfter && !markType.isInSet($afterPos.marks())) {
+            return $afterPos.pos;
+        }
+        // We're at the end of a node. We need to check
+        // whether there's a matching deletion at the beginning
+        // of the next node
+        let afterParentPos = $afterPos.after();
+        let $afterParentPos = $pos.doc.resolve(afterParentPos);
+        let nextParent = $afterParentPos.nodeAfter;
+        while($afterParentPos.depth > 0 && !nextParent){
+            afterParentPos = $afterPos.after($afterParentPos.depth);
+            $afterParentPos = $pos.doc.resolve(afterParentPos);
+            nextParent = $afterParentPos.nodeAfter;
+        }
+        let cousinStartPos = afterParentPos + 1;
+        let cousin = nextParent?.firstChild;
+        while(cousin && !cousin.isLeaf && !markType.isInSet(cousin.marks)){
+            cousin = cousin.firstChild;
+            cousinStartPos++;
+        }
+        const deletionMark = cousin?.marks.find((mark)=>mark.type === markType);
+        if (!cousin || !deletionMark || deletionMark.attrs["id"] !== initialDeletionMark.attrs["id"]) {
+            return $afterPos.pos;
+        }
+        const $cousinStartPos = $pos.doc.resolve(cousinStartPos);
+        afterPos = $cousinStartPos.pos + ($cousinStartPos.nodeAfter?.nodeSize ?? 0);
+    }
+}

package/dist/generateId.d.ts

@@ -0,0 +1,5 @@
+import { type Node, type Schema } from "prosemirror-model";
+export type SuggestionId = string | number;
+export declare const suggestionIdValidate = "number|string";
+export declare function parseSuggestionId(id: string): SuggestionId;
+export declare function generateNextNumberId(schema: Schema, doc?: Node): number;

package/dist/generateId.js

@@ -0,0 +1,24 @@
+import { getSuggestionMarks } from "./utils.js";
+export const suggestionIdValidate = "number|string";
+export function parseSuggestionId(id) {
+    const parsed = parseInt(id, 10);
+    if (isNaN(parsed)) {
+        return id;
+    }
+    return parsed;
+}
+export function generateNextNumberId(schema, doc) {
+    const { deletion, insertion, modification } = getSuggestionMarks(schema);
+    // Find the highest change id in the document so far,
+    // and use that as the starting point for new changes
+    let suggestionId = 0;
+    doc?.descendants((node)=>{
+        const mark = node.marks.find((mark)=>mark.type === insertion || mark.type === deletion || mark.type === modification);
+        if (mark) {
+            suggestionId = Math.max(suggestionId, mark.attrs["id"]);
+            return false;
+        }
+        return true;
+    });
+    return suggestionId + 1;
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { addSuggestionMarks, insertion, deletion, modification, } from "./schema.js";
+export { selectSuggestion, revertSuggestion, revertSuggestions, applySuggestion, applySuggestions, enableSuggestChanges, disableSuggestChanges, toggleSuggestChanges, } from "./commands.js";
+export { suggestChanges, suggestChangesKey, isSuggestChangesEnabled, } from "./plugin.js";
+export { withSuggestChanges, transformToSuggestionTransaction, } from "./withSuggestChanges.js";

package/dist/index.js

@@ -0,0 +1,4 @@
+export { addSuggestionMarks, insertion, deletion, modification } from "./schema.js";
+export { selectSuggestion, revertSuggestion, revertSuggestions, applySuggestion, applySuggestions, enableSuggestChanges, disableSuggestChanges, toggleSuggestChanges } from "./commands.js";
+export { suggestChanges, suggestChangesKey, isSuggestChangesEnabled } from "./plugin.js";
+export { withSuggestChanges, transformToSuggestionTransaction } from "./withSuggestChanges.js";

package/dist/plugin.d.ts

@@ -0,0 +1,8 @@
+import { type EditorState, Plugin, PluginKey } from "prosemirror-state";
+export declare const suggestChangesKey: PluginKey<{
+    enabled: boolean;
+}>;
+export declare function suggestChanges(): Plugin<{
+    enabled: boolean;
+}>;
+export declare function isSuggestChangesEnabled(state: EditorState): boolean;

package/dist/plugin.js

@@ -0,0 +1,38 @@
+import { Plugin, PluginKey, TextSelection } from "prosemirror-state";
+import { getSuggestionDecorations } from "./decorations.js";
+export const suggestChangesKey = new PluginKey("@handlewithcare/prosemirror-suggest-changes");
+export function suggestChanges() {
+    return new Plugin({
+        key: suggestChangesKey,
+        state: {
+            init () {
+                return {
+                    enabled: false
+                };
+            },
+            apply (tr, value) {
+                const meta = tr.getMeta(suggestChangesKey);
+                if (meta && "enabled" in meta) return meta;
+                return value;
+            }
+        },
+        props: {
+            decorations: getSuggestionDecorations,
+            // Add a custom keydown handler that skips over any zero-width
+            // spaces that we've inserted so that users aren't aware of them
+            handleKeyDown (view, event) {
+                if (event.key === "ArrowRight" && view.state.selection instanceof TextSelection && view.state.selection.empty && view.state.selection.$cursor?.nodeAfter?.text?.startsWith("\u200B")) {
+                    view.dispatch(view.state.tr.setSelection(TextSelection.create(view.state.doc, view.state.selection.$cursor.pos + 1)));
+                }
+                if (event.key === "ArrowLeft" && view.state.selection instanceof TextSelection && view.state.selection.empty && view.state.selection.$cursor?.nodeBefore?.text?.endsWith("\u200B")) {
+                    view.dispatch(view.state.tr.setSelection(TextSelection.create(view.state.doc, view.state.selection.$cursor.pos - 1)));
+                }
+                // Never block any other handlers from running after
+                return false;
+            }
+        }
+    });
+}
+export function isSuggestChangesEnabled(state) {
+    return !!suggestChangesKey.getState(state)?.enabled;
+}

package/dist/rebasePos.d.ts

@@ -0,0 +1,9 @@
+import { type Step } from "prosemirror-transform";
+/**
+ * Rebase a position onto a new lineage of steps
+ *
+ * @param pos The position to rebase
+ * @param back The old steps to undo, in the order they were originally applied
+ * @param forth The new steps to map through
+ */
+export declare function rebasePos(pos: number, back: Step[], forth: Step[]): number;

package/dist/rebasePos.js

@@ -0,0 +1,10 @@
+/**
+ * Rebase a position onto a new lineage of steps
+ *
+ * @param pos The position to rebase
+ * @param back The old steps to undo, in the order they were originally applied
+ * @param forth The new steps to map through
+ */ export function rebasePos(pos, back, forth) {
+    const reset = back.slice().reverse().reduce((acc, step)=>step.getMap().invert().map(acc), pos);
+    return forth.reduce((acc, step)=>step.getMap().map(acc), reset);
+}

package/dist/removeMarkStep.d.ts

@@ -0,0 +1,12 @@
+import { type Node } from "prosemirror-model";
+import { type EditorState, type Transaction } from "prosemirror-state";
+import { type RemoveMarkStep, type Step } from "prosemirror-transform";
+import { type SuggestionId } from "./generateId.js";
+/**
+ * Transform a remove mark step into its equivalent tracked steps.
+ *
+ * Add mark steps are treated as replace steps in this model. An
+ * equivalent replace step will be generated, and then processed via
+ * trackReplaceStep().
+ */
+export declare function suggestRemoveMarkStep(trackedTransaction: Transaction, state: EditorState, doc: Node, step: RemoveMarkStep, prevSteps: Step[], suggestionId: SuggestionId): boolean;

package/dist/removeMarkStep.js

@@ -0,0 +1,17 @@
+import { replaceStep } from "prosemirror-transform";
+import { applySuggestionsToRange } from "./commands.js";
+import { suggestReplaceStep } from "./replaceStep.js";
+/**
+ * Transform a remove mark step into its equivalent tracked steps.
+ *
+ * Add mark steps are treated as replace steps in this model. An
+ * equivalent replace step will be generated, and then processed via
+ * trackReplaceStep().
+ */ export function suggestRemoveMarkStep(trackedTransaction, state, doc, step, prevSteps, suggestionId) {
+    const applied = step.apply(doc).doc;
+    if (!applied) return false;
+    const slice = applySuggestionsToRange(applied, step.from, step.to);
+    const replace = replaceStep(doc, step.from, step.to, slice);
+    if (!replace) return false;
+    return suggestReplaceStep(trackedTransaction, state, doc, replace, prevSteps, suggestionId);
+}

package/dist/removeNodeMarkStep.d.ts

@@ -0,0 +1,11 @@
+import { type Node } from "prosemirror-model";
+import { type EditorState, type Transaction } from "prosemirror-state";
+import { type RemoveNodeMarkStep, type Step } from "prosemirror-transform";
+import { type SuggestionId } from "./generateId.js";
+/**
+ * Transform a remove node mark step into its equivalent tracked steps.
+ *
+ * Remove node mark steps are processed normally, and then a modification
+ * mark is added to the node as well, to track the change.
+ */
+export declare function suggestRemoveNodeMarkStep(trackedTransaction: Transaction, state: EditorState, _doc: Node, step: RemoveNodeMarkStep, prevSteps: Step[], suggestionId: SuggestionId): boolean;

package/dist/removeNodeMarkStep.js

@@ -0,0 +1,30 @@
+import { rebasePos } from "./rebasePos.js";
+import { getSuggestionMarks } from "./utils.js";
+/**
+ * Transform a remove node mark step into its equivalent tracked steps.
+ *
+ * Remove node mark steps are processed normally, and then a modification
+ * mark is added to the node as well, to track the change.
+ */ export function suggestRemoveNodeMarkStep(trackedTransaction, state, _doc, step, prevSteps, suggestionId) {
+    const { modification } = getSuggestionMarks(state.schema);
+    const rebasedPos = rebasePos(step.pos, prevSteps, trackedTransaction.steps);
+    const $pos = trackedTransaction.doc.resolve(rebasedPos);
+    const node = $pos.nodeAfter;
+    let marks = node?.marks ?? [];
+    const existingMod = marks.find((mark)=>mark.type === modification && mark.attrs["type"] === "mark" && mark.attrs["newValue"] && step.mark.eq(state.schema.markFromJSON(mark.attrs["newValue"])));
+    if (existingMod) {
+        trackedTransaction.removeNodeMark(rebasedPos, existingMod);
+        trackedTransaction.removeNodeMark(rebasedPos, state.schema.markFromJSON(existingMod.attrs["newValue"]));
+        return false;
+    }
+    marks = step.mark.removeFromSet(marks);
+    marks = modification.create({
+        id: suggestionId,
+        type: "mark",
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        previousValue: step.mark.toJSON(),
+        newValue: null
+    }).addToSet(marks);
+    trackedTransaction.setNodeMarkup(rebasedPos, null, null, marks);
+    return true;
+}

package/dist/replaceAroundStep.d.ts

@@ -0,0 +1,12 @@
+import { type Node } from "prosemirror-model";
+import { type EditorState, type Transaction } from "prosemirror-state";
+import { type ReplaceAroundStep, type Step } from "prosemirror-transform";
+import { type SuggestionId } from "./generateId.js";
+/**
+ * Transform a replace around step into its equivalent tracked steps.
+ *
+ * Replace around steps are treated as replace steps in this model. An
+ * equivalent replace step will be generated, and then processed via
+ * trackReplaceStep().
+ */
+export declare function suggestReplaceAroundStep(trackedTransaction: Transaction, state: EditorState, doc: Node, step: ReplaceAroundStep, prevSteps: Step[], suggestionId: SuggestionId): boolean;

package/dist/replaceAroundStep.js

@@ -0,0 +1,96 @@
+import { AddNodeMarkStep, AttrStep, RemoveNodeMarkStep, replaceStep } from "prosemirror-transform";
+import { trackAddNodeMarkStep } from "./addNodeMarkStep.js";
+import { trackAttrStep } from "./attrStep.js";
+import { rebasePos } from "./rebasePos.js";
+import { suggestRemoveNodeMarkStep } from "./removeNodeMarkStep.js";
+import { suggestReplaceStep } from "./replaceStep.js";
+import { getSuggestionMarks } from "./utils.js";
+import { applySuggestionsToRange } from "./commands.js";
+/**
+ * This detects and handles changes from `setNodeMarkup` so that these are tracked as a modification
+ * instead of a deletion + insertion
+ * (https://github.com/handlewithcarecollective/prosemirror-suggest-changes/issues/7)
+ */ function suggestSetNodeMarkup(trackedTransaction, state, doc, step, prevSteps, suggestionId) {
+    if (step.insert === 1 && step.slice.size === 2 && step.gapTo === step.to - 1 && step.gapFrom === step.from + 1 && step.structure) {
+        const { modification } = getSuggestionMarks(state.schema);
+        const newNode = step.slice.content.firstChild;
+        let from = rebasePos(step.from, prevSteps, trackedTransaction.steps);
+        let oldNode = trackedTransaction.doc.resolve(from).nodeAfter;
+        if (!newNode || !oldNode) {
+            throw new Error("Failed to apply modifications to node: unexpected ReplaceAroundStep as oldNode / newNode is null");
+        }
+        const addedMarks = newNode.marks.filter((m)=>!oldNode?.marks.some((m2)=>m2.eq(m)));
+        addedMarks.forEach((mark)=>{
+            if (mark.type === modification) {
+                return;
+            }
+            trackAddNodeMarkStep(trackedTransaction, state, doc, new AddNodeMarkStep(step.from, mark), prevSteps, suggestionId);
+        });
+        from = rebasePos(step.from, prevSteps, trackedTransaction.steps);
+        oldNode = trackedTransaction.doc.resolve(step.from).nodeAfter;
+        if (!oldNode) {
+            throw new Error("Failed to apply modifications to node: unexpected ReplaceAroundStep as oldNode is null");
+        }
+        const removedMarks = oldNode.marks.filter((m)=>!newNode.marks.some((m2)=>m2.eq(m)));
+        removedMarks.forEach((mark)=>{
+            if (mark.type === modification) {
+                return;
+            }
+            suggestRemoveNodeMarkStep(trackedTransaction, state, doc, new RemoveNodeMarkStep(step.from, mark), prevSteps, suggestionId);
+        });
+        if (newNode.type.name !== oldNode.type.name) {
+            // Code below is similar to trackAttrStep()
+            const rebasedPos = rebasePos(step.from, prevSteps, trackedTransaction.steps);
+            const $pos = trackedTransaction.doc.resolve(rebasedPos);
+            const node = $pos.nodeAfter;
+            if (!node) {
+                throw new Error("Failed to apply modifications to node: no node found");
+            }
+            let marks = node.marks;
+            const existingMod = marks.find((mark)=>mark.type === modification && mark.attrs["type"] === "nodeType");
+            if (existingMod) {
+                marks = existingMod.removeFromSet(marks);
+            }
+            marks = modification.create({
+                id: suggestionId,
+                type: "nodeType",
+                previousValue: node.type.name,
+                newValue: newNode.type.name
+            }).addToSet(marks);
+            trackedTransaction.setNodeMarkup(rebasedPos, newNode.type, null, marks);
+        }
+        const attrNames = new Set([
+            ...Object.keys(newNode.attrs),
+            ...Object.keys(oldNode.attrs)
+        ]);
+        for (const attr of attrNames){
+            if (newNode.attrs[attr] !== oldNode.attrs[attr]) {
+                // delegate to trackAttrStep to handle the attribute change
+                trackAttrStep(trackedTransaction, state, doc, new AttrStep(step.from, attr, newNode.attrs[attr]), prevSteps, suggestionId);
+            }
+        }
+        return true;
+    }
+    return false;
+}
+/**
+ * Transform a replace around step into its equivalent tracked steps.
+ *
+ * Replace around steps are treated as replace steps in this model. An
+ * equivalent replace step will be generated, and then processed via
+ * trackReplaceStep().
+ */ export function suggestReplaceAroundStep(trackedTransaction, state, doc, step, prevSteps, suggestionId) {
+    const handled = suggestSetNodeMarkup(trackedTransaction, state, doc, step, prevSteps, suggestionId);
+    if (handled) {
+        return true;
+    }
+    const applied = step.apply(doc).doc;
+    if (!applied) return false;
+    const from = step.getMap().map(step.from, -1);
+    const to = step.getMap().map(step.to, 1);
+    const blockRange = applied.resolve(from).blockRange(applied.resolve(to));
+    if (!blockRange) return false;
+    const replace = replaceStep(doc, step.getMap().invert().map(blockRange.start), step.getMap().invert().map(blockRange.end), applySuggestionsToRange(applied, blockRange.start, blockRange.end));
+    if (!replace) return false;
+    return suggestReplaceStep(trackedTransaction, state, doc, replace, prevSteps, suggestionId);
+}