@magic-marker/prosemirror-suggest-changes 0.1.8

package/dist/replaceStep.d.ts

@@ -0,0 +1,35 @@
+import { type Node } from "prosemirror-model";
+import { type EditorState, type Transaction } from "prosemirror-state";
+import { type ReplaceStep, type Step } from "prosemirror-transform";
+import { type SuggestionId } from "./generateId.js";
+/**
+ * Transform a replace step into its equivalent tracked steps.
+ *
+ * Any deletions of slices that are _not_ within existing
+ * insertion marks will be replaced with addMark steps that add
+ * deletion marks to those ranges.
+ *
+ * Any deletions of slices that _are_ within existing insertion
+ * marks will actually be deleted.
+ *
+ * Any slices that are to be inserted will also be marked with
+ * insertion marks.
+ *
+ * If a deletion begins at the very end of a textblock, a zero-width
+ * space will be inserted at the end of that texblock and given
+ * a deletion mark.
+ *
+ * Similarly, if a deletion ends at the very beginning fo a textblock,
+ * a zero-width space will be inserted at the beginning of that
+ * textblock and given a deletion mark.
+ *
+ * If an insertion slice is open on either end, and there is no content
+ * adjacent to the open end(s), zero-width spaces
+ * will be added at the open end(s) and given insertion marks.
+ *
+ * After all of the above have been evaluated, if the resulting
+ * insertion or deletion marks abut or join existing marks, they
+ * will be joined and given the same ids. Any no-longer-necessary
+ * zero-width spaces will be removed.
+ */
+export declare function suggestReplaceStep(trackedTransaction: Transaction, state: EditorState, doc: Node, step: ReplaceStep, prevSteps: Step[], suggestionId: SuggestionId): boolean;

package/dist/replaceStep.js

@@ -0,0 +1,247 @@
+import { TextSelection } from "prosemirror-state";
+import { findSuggestionMarkEnd } from "./findSuggestionMarkEnd.js";
+import { rebasePos } from "./rebasePos.js";
+import { getSuggestionMarks } from "./utils.js";
+import { joinBlocks } from "./features/joinBlocks/index.js";
+/**
+ * Transform a replace step into its equivalent tracked steps.
+ *
+ * Any deletions of slices that are _not_ within existing
+ * insertion marks will be replaced with addMark steps that add
+ * deletion marks to those ranges.
+ *
+ * Any deletions of slices that _are_ within existing insertion
+ * marks will actually be deleted.
+ *
+ * Any slices that are to be inserted will also be marked with
+ * insertion marks.
+ *
+ * If a deletion begins at the very end of a textblock, a zero-width
+ * space will be inserted at the end of that texblock and given
+ * a deletion mark.
+ *
+ * Similarly, if a deletion ends at the very beginning fo a textblock,
+ * a zero-width space will be inserted at the beginning of that
+ * textblock and given a deletion mark.
+ *
+ * If an insertion slice is open on either end, and there is no content
+ * adjacent to the open end(s), zero-width spaces
+ * will be added at the open end(s) and given insertion marks.
+ *
+ * After all of the above have been evaluated, if the resulting
+ * insertion or deletion marks abut or join existing marks, they
+ * will be joined and given the same ids. Any no-longer-necessary
+ * zero-width spaces will be removed.
+ */ export function suggestReplaceStep(trackedTransaction, state, doc, step, prevSteps, suggestionId) {
+    const { deletion, insertion } = getSuggestionMarks(state.schema);
+    // Check for insertion and deletion marks directly
+    // adjacent to this step's boundaries. If they exist,
+    // we'll use their ids, rather than producing a new one
+    const nodeBefore = doc.resolve(step.from).nodeBefore;
+    const markBefore = nodeBefore?.marks.find((mark)=>mark.type === deletion || mark.type === insertion) ?? null;
+    const nodeAfter = doc.resolve(step.to).nodeAfter;
+    const markAfter = nodeAfter?.marks.find((mark)=>mark.type === deletion || mark.type === insertion) ?? null;
+    let markId = markBefore?.attrs["id"] ?? markAfter?.attrs["id"] ?? suggestionId;
+    // Rebase this step's boundaries onto the newest doc
+    let stepFrom = rebasePos(step.from, prevSteps, trackedTransaction.steps);
+    let stepTo = rebasePos(step.to, prevSteps, trackedTransaction.steps);
+    if (state.selection.empty && stepFrom !== stepTo) {
+        trackedTransaction.setSelection(TextSelection.near(trackedTransaction.doc.resolve(stepFrom)));
+    }
+    // Process block joins and delete insertion-marked content
+    // Only do this when actually deleting (stepFrom !== stepTo)
+    // Don't do this when inserting (step.slice.content.size > 0 with stepFrom === stepTo)
+    let didBlockJoin = false;
+    if (stepFrom !== stepTo) {
+        didBlockJoin = joinBlocks(trackedTransaction, stepFrom, stepTo, insertion);
+    }
+    // Update the step boundaries, since we may have just changed
+    // the document
+    stepFrom = rebasePos(step.from, prevSteps, trackedTransaction.steps);
+    stepTo = rebasePos(step.to, prevSteps, trackedTransaction.steps);
+    // Re-resolve nodeAfter and markAfter if we did a block join
+    // The original values are stale after joinBlocks modifies the document
+    let nodeAfterResolved = nodeAfter;
+    let markAfterResolved = markAfter;
+    if (didBlockJoin) {
+        const $stepTo = trackedTransaction.doc.resolve(stepTo);
+        nodeAfterResolved = $stepTo.nodeAfter;
+        markAfterResolved = nodeAfterResolved?.marks.find((mark)=>mark.type === deletion || mark.type === insertion) ?? null;
+        // When inserting new content after a block join, use the suggestionId parameter
+        // instead of reusing adjacent mark IDs. The suggestionId represents a new operation.
+        const sliceHasNewContent = step.slice.openStart === 0 && step.slice.openEnd === 0;
+        if (sliceHasNewContent && step.slice.content.size) {
+            markId = suggestionId;
+        }
+    }
+    // If there's a deletion, we need to check for and handle
+    // the case where it crosses a block boundary, so that we
+    // can leave zero-width spaces as markers if there's no other
+    // content to anchor the deletion to.
+    if (stepFrom !== stepTo) {
+        let $stepFrom = trackedTransaction.doc.resolve(stepFrom);
+        let $stepTo = trackedTransaction.doc.resolve(stepTo);
+        // When there are no characters to mark with deletions before
+        // the end of a block, we add zero-width, non-printable
+        // characters as markers to indicate that a deletion exists
+        // and crosses a block boundary. This allows us to render the
+        // deleted boundary with a widget, as well as properly handle
+        // future, adjacent deletions and insertions.
+        if (!$stepFrom.nodeAfter && !deletion.isInSet($stepFrom.nodeBefore?.marks ?? [])) {
+            trackedTransaction.insertText("\u200B", stepFrom);
+            stepTo++;
+            $stepTo = trackedTransaction.doc.resolve(stepTo);
+        }
+        if (!$stepTo.nodeBefore && !deletion.isInSet($stepTo.nodeAfter?.marks ?? [])) {
+            trackedTransaction.insertText("\u200B", stepTo);
+            stepTo++;
+            $stepTo = trackedTransaction.doc.resolve(stepTo);
+        }
+        // When we produce a deletion mark that directly abuts
+        // an existing mark with a zero-width space, we delete
+        // that space. We'll join the marks later, and can use
+        // the joined marks to find deletions across the block
+        // boundary
+        if ($stepFrom.nodeBefore?.text?.endsWith("\u200B") && !$stepTo.nodeAfter?.text?.startsWith("\u200B")) {
+            trackedTransaction.delete(stepFrom - 1, stepFrom);
+            stepFrom--;
+            stepTo--;
+            $stepFrom = trackedTransaction.doc.resolve(stepFrom);
+            $stepTo = trackedTransaction.doc.resolve(stepTo);
+        }
+        if ($stepTo.nodeAfter?.text?.startsWith("\u200B") && !$stepFrom.nodeBefore?.text?.endsWith("\u200B")) {
+            trackedTransaction.delete(stepTo, stepTo + 1);
+        }
+        // If the user is deleting exactly a zero-width space,
+        // delete the space and also shift the range back by one,
+        // so that they actually mark the character before the
+        // zero-width space as deleted. The user doesn't know
+        // the zero-width space is there, so deleting it would
+        // appear to do nothing
+        if ($stepFrom.nodeBefore && stepTo - stepFrom === 1 && trackedTransaction.doc.textBetween(stepFrom, stepTo) === "\u200B") {
+            trackedTransaction.delete(stepFrom, stepTo);
+            stepFrom--;
+            stepTo--;
+            $stepFrom = trackedTransaction.doc.resolve(stepFrom);
+            $stepTo = trackedTransaction.doc.resolve(stepTo);
+            trackedTransaction.setSelection(TextSelection.near($stepFrom));
+        }
+    }
+    // TODO: Even if the range doesn't map to a block
+    // range, check whether it contains any whole
+    // blocks, so that we can use node marks on those.
+    //
+    // If the deleted range maps precisely to a block
+    // range. If they do, add node marks to the nodes
+    // in the range, rather than using inline marks
+    // on the content.
+    const blockRange = trackedTransaction.doc.resolve(stepFrom).blockRange(trackedTransaction.doc.resolve(stepTo));
+    if (!blockRange || blockRange.start !== stepFrom || blockRange.end !== stepTo) {
+        trackedTransaction.addMark(stepFrom, stepTo, deletion.create({
+            id: markId
+        }));
+    } else {
+        trackedTransaction.doc.nodesBetween(blockRange.start, blockRange.end, (_, pos)=>{
+            if (pos < blockRange.start) return true;
+            trackedTransaction.addNodeMark(pos, deletion.create({
+                id: markId
+            }));
+            return false;
+        });
+    }
+    // TODO: This could break if there's already a deletion-insertion-deletion-insertion combination
+    // This is the code that creates those combinations, doing this twice in a row could break it
+    // Detect when a new mark directly abuts an existing mark with
+    // a different id and merge them
+    // Use re-resolved values if we did a block join
+    if (nodeAfterResolved && markAfterResolved && markAfterResolved.attrs["id"] !== markId) {
+        const $nodeAfterStart = trackedTransaction.doc.resolve(stepTo);
+        const nodeAfterEnd = $nodeAfterStart.pos + nodeAfterResolved.nodeSize;
+        trackedTransaction.removeMark(stepTo, nodeAfterEnd, markAfterResolved.type);
+        trackedTransaction.addMark(stepTo, nodeAfterEnd, markAfterResolved.type.create({
+            id: markId
+        }));
+        if (markAfterResolved.type === deletion) {
+            const insertionNode = trackedTransaction.doc.resolve(nodeAfterEnd).nodeAfter;
+            if (insertionNode && insertion.isInSet(insertionNode.marks)) {
+                const insertionNodeEnd = nodeAfterEnd + insertionNode.nodeSize;
+                trackedTransaction.removeMark(nodeAfterEnd, insertionNodeEnd, insertion);
+                trackedTransaction.addMark(nodeAfterEnd, insertionNodeEnd, insertion.create({
+                    id: markId
+                }));
+            }
+        }
+    }
+    // Handle insertions
+    // When didBlockJoin is true, only process insertions if the slice contains
+    // actual new content (closed slice) rather than just structural info for the join (open slice).
+    // Open slices have openStart > 0 or openEnd > 0 and represent block structure.
+    // Closed slices have openStart = 0 and openEnd = 0 and contain new user content.
+    // TODO: Done with AI, not 100% sure about the argument but it works. Kind of.
+    // The replaced content is not equivalent to what would happen without suggestions, just with insertions
+    // but it's workable. Only issues are with deleting between different depths ( for ex. between list and root level paragraph )
+    const sliceHasNewContent = step.slice.openStart === 0 && step.slice.openEnd === 0;
+    const shouldProcessInsertion = step.slice.content.size && (!didBlockJoin || sliceHasNewContent);
+    if (shouldProcessInsertion) {
+        const $to = trackedTransaction.doc.resolve(stepTo);
+        // Don't allow inserting content within an existing deletion
+        // mark. Instead, shift the proposed insertion to the end
+        // of the deletion.
+        const insertFrom = findSuggestionMarkEnd($to, deletion);
+        // We execute the insertion normally, on top of all of the existing
+        // tracked changes.
+        trackedTransaction.replace(insertFrom, insertFrom, step.slice);
+        const insertStep = // We just created this step, so it we can assert that it exists
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        trackedTransaction.steps[trackedTransaction.steps.length - 1];
+        let insertedTo = insertStep.getMap().map(insertFrom);
+        // Then, we iterate through the newly inserted content and mark it
+        // as inserted.
+        trackedTransaction.doc.nodesBetween(insertFrom, insertedTo, (node, pos)=>{
+            const $pos = trackedTransaction.doc.resolve(pos);
+            // If any of this node's ancestors are already marked as insertions,
+            // we can skip it
+            for(let d = $pos.depth; d >= 0; d--){
+                if (insertion.isInSet($pos.node(d).marks)) return;
+            }
+            // When an insertion constitutes only part of a node,
+            // use inline marks to mark only the inserted portion
+            const shouldAddInlineMarks = pos < insertFrom || pos + node.nodeSize > insertedTo || node.isInline;
+            if (shouldAddInlineMarks) {
+                trackedTransaction.addMark(Math.max(pos, insertFrom), Math.min(pos + node.nodeSize, insertedTo), insertion.create({
+                    id: markId
+                }));
+                return;
+            }
+            // Use a node mark when an entire node was newly inserted.
+            trackedTransaction.addNodeMark(pos, insertion.create({
+                id: markId
+            }));
+        });
+        const $insertFrom = trackedTransaction.doc.resolve(insertFrom);
+        let $insertedTo = trackedTransaction.doc.resolve(insertedTo);
+        // Like with deletions, identify when we've inserted a
+        // node boundary and add zero-width spaces as anchors on
+        // either side.
+        if (!$insertFrom.nodeAfter) {
+            trackedTransaction.insertText("\u200B", insertFrom);
+            trackedTransaction.addMark(insertFrom, insertFrom + 1, insertion.create({
+                id: markId
+            }));
+            insertedTo++;
+            $insertedTo = trackedTransaction.doc.resolve(insertedTo);
+        }
+        if (!$insertedTo.nodeBefore) {
+            trackedTransaction.insertText("\u200B", insertedTo);
+            trackedTransaction.addMark(insertedTo, insertedTo + 1, insertion.create({
+                id: markId
+            }));
+            insertedTo++;
+            $insertedTo = trackedTransaction.doc.resolve(insertedTo);
+        }
+        if (insertFrom !== $to.pos) {
+            trackedTransaction.setSelection(TextSelection.near(trackedTransaction.doc.resolve(insertFrom + step.slice.size)));
+        }
+    }
+    return markId === suggestionId;
+}

package/dist/schema.d.ts

@@ -0,0 +1,9 @@
+import { type MarkSpec } from "prosemirror-model";
+export declare const deletion: MarkSpec;
+export declare const insertion: MarkSpec;
+export declare const modification: MarkSpec;
+/**
+ * Add the deletion, insertion, and modification marks to
+ * the provided MarkSpec map.
+ */
+export declare function addSuggestionMarks<Marks extends string>(marks: Record<Marks, MarkSpec>): Record<Marks | "deletion" | "insertion" | "modification", MarkSpec>;

package/dist/schema.js

@@ -0,0 +1,139 @@
+import { suggestionIdValidate } from "./generateId.js";
+export const deletion = {
+    inclusive: false,
+    excludes: "insertion modification deletion",
+    attrs: {
+        id: {
+            validate: suggestionIdValidate
+        }
+    },
+    toDOM (mark, inline) {
+        return [
+            "del",
+            {
+                "data-id": JSON.stringify(mark.attrs["id"]),
+                "data-inline": String(inline),
+                ...!inline && {
+                    style: "display: block"
+                }
+            },
+            0
+        ];
+    },
+    parseDOM: [
+        {
+            tag: "del",
+            getAttrs (node) {
+                if (!node.dataset["id"]) return false;
+                return {
+                    id: JSON.parse(node.dataset["id"])
+                };
+            }
+        }
+    ]
+};
+export const insertion = {
+    inclusive: false,
+    excludes: "deletion modification insertion",
+    attrs: {
+        id: {
+            validate: suggestionIdValidate
+        }
+    },
+    toDOM (mark, inline) {
+        return [
+            "ins",
+            {
+                "data-id": JSON.stringify(mark.attrs["id"]),
+                "data-inline": String(inline),
+                ...!inline && {
+                    style: "display: block"
+                }
+            },
+            0
+        ];
+    },
+    parseDOM: [
+        {
+            tag: "ins",
+            getAttrs (node) {
+                if (!node.dataset["id"]) return false;
+                return {
+                    id: JSON.parse(node.dataset["id"])
+                };
+            }
+        }
+    ]
+};
+export const modification = {
+    inclusive: false,
+    excludes: "deletion insertion",
+    attrs: {
+        id: {
+            validate: suggestionIdValidate
+        },
+        type: {
+            validate: "string"
+        },
+        attrName: {
+            default: null,
+            validate: "string|null"
+        },
+        previousValue: {
+            default: null
+        },
+        newValue: {
+            default: null
+        }
+    },
+    toDOM (mark, inline) {
+        return [
+            inline ? "span" : "div",
+            {
+                "data-type": "modification",
+                "data-id": JSON.stringify(mark.attrs["id"]),
+                "data-mod-type": mark.attrs["type"],
+                "data-mod-prev-val": JSON.stringify(mark.attrs["previousValue"]),
+                // TODO: Try to serialize marks with toJSON?
+                "data-mod-new-val": JSON.stringify(mark.attrs["newValue"])
+            },
+            0
+        ];
+    },
+    parseDOM: [
+        {
+            tag: "span[data-type='modification']",
+            getAttrs (node) {
+                if (!node.dataset["id"]) return false;
+                return {
+                    id: JSON.parse(node.dataset["id"]),
+                    type: node.dataset["modType"],
+                    previousValue: node.dataset["modPrevVal"],
+                    newValue: node.dataset["modNewVal"]
+                };
+            }
+        },
+        {
+            tag: "div[data-type='modification']",
+            getAttrs (node) {
+                if (!node.dataset["id"]) return false;
+                return {
+                    id: JSON.parse(node.dataset["id"]),
+                    type: node.dataset["modType"],
+                    previousValue: node.dataset["modPrevVal"]
+                };
+            }
+        }
+    ]
+};
+/**
+ * Add the deletion, insertion, and modification marks to
+ * the provided MarkSpec map.
+ */ export function addSuggestionMarks(marks) {
+    return {
+        ...marks,
+        deletion,
+        insertion,
+        modification
+    };
+}

package/dist/testing/difficultyMark.d.ts

@@ -0,0 +1,2 @@
+import { type MarkSpec } from "prosemirror-model";
+export declare const difficulty: MarkSpec;

package/dist/testing/testBuilders.d.ts

@@ -0,0 +1,11 @@
+import { Schema, type Node } from "prosemirror-model";
+import { type MarkBuilder, type NodeBuilder } from "prosemirror-test-builder";
+declare const schema: Schema<"blockquote" | "text" | "doc" | "paragraph" | "image" | "orderedList" | "bulletList" | "listItem" | "horizontal_rule" | "heading" | "code_block" | "hard_break", "insertion" | "deletion" | "modification" | "code" | "em" | "link" | "strong" | "difficulty">;
+export declare const testBuilders: { [NodeTypeName in keyof (typeof schema)["nodes"]]: NodeBuilder; } & { [MarkTypeName in keyof (typeof schema)["marks"]]: MarkBuilder; } & {
+    schema: typeof schema;
+};
+export type TaggedNode = Node & {
+    flat: Node;
+    tag: Record<string, number>;
+};
+export {};

package/dist/utils.d.ts

@@ -0,0 +1,11 @@
+import { type MarkType, type Schema } from "prosemirror-model";
+export interface SuggestionMarks {
+    insertion: MarkType;
+    deletion: MarkType;
+    modification: MarkType;
+}
+/**
+ * Get the suggestion mark types from a schema, with proper error handling.
+ * Throws an error if any of the required marks are not found.
+ */
+export declare function getSuggestionMarks(schema: Schema): SuggestionMarks;

package/dist/utils.js

@@ -0,0 +1,20 @@
+/**
+ * Get the suggestion mark types from a schema, with proper error handling.
+ * Throws an error if any of the required marks are not found.
+ */ export function getSuggestionMarks(schema) {
+    const { insertion, deletion, modification } = schema.marks;
+    if (!insertion) {
+        throw new Error("Failed to find insertion mark in schema. Did you forget to add it?");
+    }
+    if (!deletion) {
+        throw new Error("Failed to find deletion mark in schema. Did you forget to add it?");
+    }
+    if (!modification) {
+        throw new Error("Failed to find modification mark in schema. Did you forget to add it?");
+    }
+    return {
+        insertion,
+        deletion,
+        modification
+    };
+}

package/dist/withSuggestChanges.d.ts

@@ -0,0 +1,27 @@
+import { type Schema, type Node } from "prosemirror-model";
+import { type EditorState, type Transaction } from "prosemirror-state";
+import { type EditorView } from "prosemirror-view";
+import { type SuggestionId } from "./generateId.js";
+/**
+ * Given a standard transaction from ProseMirror, produce
+ * a new transaction that tracks the changes from the original,
+ * rather than applying them.
+ *
+ * For each type of step, we implement custom behavior to prevent
+ * deletions from being removed from the document, instead adding
+ * deletion marks, and ensuring that all insertions have insertion
+ * marks.
+ */
+export declare function transformToSuggestionTransaction(originalTransaction: Transaction, state: EditorState, generateId?: (schema: Schema, doc?: Node) => SuggestionId): Transaction;
+/**
+ * A `dispatchTransaction` decorator. Wrap your existing `dispatchTransaction`
+ * function with `withSuggestChanges`, or pass no arguments to use the default
+ * implementation (`view.setState(view.state.apply(tr))`).
+ *
+ * The result is a `dispatchTransaction` function that will intercept
+ * and modify incoming transactions when suggest changes is enabled.
+ * These modified transactions will suggest changes instead of directly
+ * applying them, e.g. by marking a range with the deletion mark rather
+ * than removing it from the document.
+ */
+export declare function withSuggestChanges(dispatchTransaction?: EditorView["dispatch"], generateId?: (schema: Schema, doc?: Node) => SuggestionId): EditorView["dispatch"];

package/dist/withSuggestChanges.js

@@ -0,0 +1,114 @@
+import { AddMarkStep, AddNodeMarkStep, AttrStep, RemoveMarkStep, RemoveNodeMarkStep, ReplaceAroundStep, ReplaceStep } from "prosemirror-transform";
+import { trackAddMarkStep } from "./addMarkStep.js";
+import { trackAddNodeMarkStep } from "./addNodeMarkStep.js";
+import { trackAttrStep } from "./attrStep.js";
+import { suggestRemoveMarkStep } from "./removeMarkStep.js";
+import { suggestRemoveNodeMarkStep } from "./removeNodeMarkStep.js";
+import { suggestReplaceAroundStep } from "./replaceAroundStep.js";
+import { suggestReplaceStep } from "./replaceStep.js";
+import { isSuggestChangesEnabled, suggestChangesKey } from "./plugin.js";
+import { generateNextNumberId } from "./generateId.js";
+import { getSuggestionMarks } from "./utils.js";
+function getStepHandler(step) {
+    if (step instanceof ReplaceStep) {
+        return suggestReplaceStep;
+    }
+    if (step instanceof ReplaceAroundStep) {
+        return suggestReplaceAroundStep;
+    }
+    if (step instanceof AddMarkStep) {
+        return trackAddMarkStep;
+    }
+    if (step instanceof RemoveMarkStep) {
+        return suggestRemoveMarkStep;
+    }
+    if (step instanceof AddNodeMarkStep) {
+        return trackAddNodeMarkStep;
+    }
+    if (step instanceof RemoveNodeMarkStep) {
+        return suggestRemoveNodeMarkStep;
+    }
+    if (step instanceof AttrStep) {
+        return trackAttrStep;
+    }
+    // Default handler — simply rebase the step onto the
+    // tracked transaction and apply it.
+    return (trackedTransaction, _state, _doc, step, prevSteps)=>{
+        const reset = prevSteps.slice().reverse().reduce((acc, step)=>acc?.map(step.getMap().invert()) ?? null, step);
+        const rebased = trackedTransaction.steps.reduce((acc, step)=>acc?.map(step.getMap()) ?? null, reset);
+        if (rebased) {
+            trackedTransaction.step(rebased);
+        }
+        return false;
+    };
+}
+/**
+ * Given a standard transaction from ProseMirror, produce
+ * a new transaction that tracks the changes from the original,
+ * rather than applying them.
+ *
+ * For each type of step, we implement custom behavior to prevent
+ * deletions from being removed from the document, instead adding
+ * deletion marks, and ensuring that all insertions have insertion
+ * marks.
+ */ export function transformToSuggestionTransaction(originalTransaction, state, generateId) {
+    getSuggestionMarks(state.schema);
+    let suggestionId = generateId ? generateId(state.schema, originalTransaction.docs[0]) : generateNextNumberId(state.schema, originalTransaction.docs[0]);
+    // Create a new transaction from scratch. The original transaction
+    // is going to be dropped in favor of this one.
+    const trackedTransaction = state.tr;
+    for(let i = 0; i < originalTransaction.steps.length; i++){
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const step = originalTransaction.steps[i];
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const doc = originalTransaction.docs[i];
+        const stepTracker = getStepHandler(step);
+        if (stepTracker(trackedTransaction, state, doc, step, originalTransaction.steps.slice(0, i), suggestionId) && i < originalTransaction.steps.length - 1) {
+            // If the suggestionId was used by one of the step handlers,
+            // increment it so that it's not reused.
+            if (generateId) {
+                suggestionId = generateId(state.schema, trackedTransaction.doc);
+            } else if (typeof suggestionId === "number") {
+                suggestionId = suggestionId + 1;
+            }
+        }
+        continue;
+    }
+    if (originalTransaction.selectionSet && !trackedTransaction.selectionSet) {
+        // Map the original selection backwards through the original transaction,
+        // and then forwards through the new one.
+        const originalBaseDoc = originalTransaction.docs[0];
+        const base = originalBaseDoc ? originalTransaction.selection.map(originalBaseDoc, originalTransaction.mapping.invert()) : originalTransaction.selection;
+        trackedTransaction.setSelection(base.map(trackedTransaction.doc, trackedTransaction.mapping));
+    }
+    if (originalTransaction.scrolledIntoView) {
+        trackedTransaction.scrollIntoView();
+    }
+    if (originalTransaction.storedMarksSet) {
+        trackedTransaction.setStoredMarks(originalTransaction.storedMarks);
+    }
+    // @ts-expect-error Preserve original transaction meta exactly as-is
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    trackedTransaction.meta = originalTransaction.meta;
+    return trackedTransaction;
+}
+/**
+ * A `dispatchTransaction` decorator. Wrap your existing `dispatchTransaction`
+ * function with `withSuggestChanges`, or pass no arguments to use the default
+ * implementation (`view.setState(view.state.apply(tr))`).
+ *
+ * The result is a `dispatchTransaction` function that will intercept
+ * and modify incoming transactions when suggest changes is enabled.
+ * These modified transactions will suggest changes instead of directly
+ * applying them, e.g. by marking a range with the deletion mark rather
+ * than removing it from the document.
+ */ export function withSuggestChanges(dispatchTransaction, generateId) {
+    const dispatch = dispatchTransaction ?? function(tr) {
+        this.updateState(this.state.apply(tr));
+    };
+    return function dispatchTransaction(tr) {
+        const ySyncMeta = tr.getMeta("y-sync$") ?? {};
+        const transaction = isSuggestChangesEnabled(this.state) && !tr.getMeta("history$") && !tr.getMeta("collab$") && !ySyncMeta.isUndoRedoOperation && !ySyncMeta.isChangeOrigin && !("skip" in (tr.getMeta(suggestChangesKey) ?? {})) ? transformToSuggestionTransaction(tr, this.state, generateId) : tr;
+        dispatch.call(this, transaction);
+    };
+}