@magic-marker/prosemirror-suggest-changes 0.2.1-wrap-unwrap.2 → 0.3.0

package/dist/__tests__/playwrightBaseTest.d.ts

@@ -0,0 +1,6 @@
+import { expect } from "@playwright/test";
+export interface TestOptions {
+    deletionMarksVisibility: "hidden" | "visible";
+}
+export declare const test: import("@playwright/test").TestType<import("@playwright/test").PlaywrightTestArgs & import("@playwright/test").PlaywrightTestOptions & TestOptions, import("@playwright/test").PlaywrightWorkerArgs & import("@playwright/test").PlaywrightWorkerOptions>;
+export { expect };

package/dist/__tests__/playwrightPage.d.ts

@@ -0,0 +1,15 @@
+import { type Locator, type Page } from "@playwright/test";
+export declare class EditorPage {
+    readonly page: Page;
+    private readonly selectors;
+    constructor(page: Page);
+    get editor(): Locator;
+    getParagraphText(index: number): Promise<string>;
+    getParagraphCount(): Promise<number>;
+    getProseMirrorMarkCount(name: string): Promise<number>;
+    getProseMirrorSelection(): Promise<{
+        anchor: number;
+        head: number;
+    }>;
+    getDOMTextContentOfChildAtIndex(index: number): Promise<string>;
+}

package/dist/commands.js

@@ -5,7 +5,6 @@ import { suggestChangesKey } from "./plugin.js";
 import { getSuggestionMarks } from "./utils.js";
 import { ZWSP } from "./constants.js";
 import { maybeRevertJoinMark } from "./features/joinOnDelete/index.js";
-import { applyStructureSuggestion, isStructureSuggestion, revertAllStructureSuggestions, revertStructureSuggestion } from "./features/wrapUnwrap/revertStructureSuggestion.js";
 /**
  * Given a node and a transform, add a set of steps to the
  * transform that applies all marks of type markTypeToApply
@@ -194,9 +193,6 @@ export function applySuggestionsToRange(doc, from, to) {
  * contents left in the doc.
  */ export function applySuggestion(suggestionId, from, to) {
     return (state, dispatch)=>{
-        if (isStructureSuggestion(suggestionId, state.tr)) {
-            return applyStructureSuggestion(suggestionId)(state, dispatch);
-        }
         const { deletion, insertion } = getSuggestionMarks(state.schema);
         const tr = state.tr;
         applySuggestionsToTransform(state.doc, tr, insertion, deletion, suggestionId, from, to);
@@ -218,9 +214,7 @@ export function applySuggestionsToRange(doc, from, to) {
  */ export function revertSuggestions(state, dispatch) {
     const { deletion, insertion } = getSuggestionMarks(state.schema);
     const tr = state.tr;
-    const doc = state.doc;
-    revertAllStructureSuggestions(doc, tr);
-    applySuggestionsToTransform(doc, tr, deletion, insertion);
+    applySuggestionsToTransform(state.doc, tr, deletion, insertion);
     applyModificationsToTransform(tr.doc, tr, -1);
     tr.setMeta(suggestChangesKey, {
         skip: true
@@ -255,9 +249,6 @@ export function applySuggestionsToRange(doc, from, to) {
  * Modifications tracked in modification marks will be reverted.
  */ export function revertSuggestion(suggestionId, from, to) {
     return (state, dispatch)=>{
-        if (isStructureSuggestion(suggestionId, state.tr)) {
-            return revertStructureSuggestion(suggestionId)(state, dispatch);
-        }
         const { deletion, insertion } = getSuggestionMarks(state.schema);
         const tr = state.tr;
         applySuggestionsToTransform(state.doc, tr, deletion, insertion, suggestionId, from, to);

package/dist/constants.d.ts

@@ -1 +1,2 @@
 export declare const ZWSP = "\u200B";
+export declare const PILCROW = "\u00B6";

package/dist/constants.js

@@ -1 +1,2 @@
 export const ZWSP = "\u200B";
+export const PILCROW = "¶";

package/dist/decorations.js

@@ -1,8 +1,9 @@
 import { Decoration, DecorationSet } from "prosemirror-view";
 import { getSuggestionMarks } from "./utils.js";
+import { PILCROW } from "./constants.js";
 function pilcrow() {
     const span = document.createElement("span");
-    span.appendChild(document.createTextNode("¶"));
+    span.appendChild(document.createTextNode(PILCROW));
     return span;
 }
 export function getSuggestionDecorations(state) {
@@ -43,7 +44,7 @@ export function getSuggestionDecorations(state) {
         if (currentDeletionMark?.attrs["id"] !== lastDeletionMark?.attrs["id"] && currentInsertionMark?.attrs["id"] !== lastInsertionMark?.attrs["id"]) {
             return true;
         }
-        if (currentDeletionMark) {
+        if (currentDeletionMark && currentDeletionMark.attrs["id"] === lastDeletionMark?.attrs["id"]) {
             changeDecorations.push(Decoration.widget(widgetPos, pilcrow, {
                 // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
                 key: currentDeletionMark.attrs["id"],
@@ -55,7 +56,7 @@ export function getSuggestionDecorations(state) {
                 ]
             }));
         }
-        if (currentInsertionMark) {
+        if (currentInsertionMark && currentInsertionMark.attrs["id"] === lastInsertionMark?.attrs["id"]) {
             changeDecorations.push(Decoration.widget(widgetPos, pilcrow, {
                 // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
                 key: currentInsertionMark.attrs["id"],

package/dist/ensureSelectionPlugin.d.ts

@@ -0,0 +1,13 @@
+import { Plugin, PluginKey } from "prosemirror-state";
+interface PluginState {
+    handleKeyDown: {
+        backspace: boolean;
+        delete: boolean;
+        arrowLeft: boolean;
+        arrowRight: boolean;
+    };
+}
+export declare const ensureSelectionKey: PluginKey<PluginState>;
+export declare function ensureSelection(): Plugin<PluginState>;
+export declare function isEnsureSelectionEnabled(): boolean;
+export {};

package/dist/ensureSelectionPlugin.js

@@ -0,0 +1,307 @@
+import { Plugin, PluginKey, TextSelection } from "prosemirror-state";
+import { getSuggestionMarks } from "./utils.js";
+import { ZWSP } from "./constants.js";
+// import { ZWSP } from "./constants.js";
+const TRACE_ENABLED = true;
+function trace(...args) {
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (!TRACE_ENABLED) return;
+    console.log("[ensureSelectionPlugin]", ...args);
+}
+export const ensureSelectionKey = new PluginKey("@handlewithcare/prosemirror-suggest-changes-ensure-selection");
+export function ensureSelection() {
+    return new Plugin({
+        key: ensureSelectionKey,
+        state: {
+            apply (tr, state) {
+                const newPluginState = tr.getMeta(ensureSelectionKey);
+                if (newPluginState) {
+                    return newPluginState;
+                }
+                return state;
+            },
+            init () {
+                return {
+                    handleKeyDown: {
+                        backspace: false,
+                        delete: false,
+                        arrowLeft: false,
+                        arrowRight: false
+                    }
+                };
+            }
+        },
+        props: {
+            handleKeyDown (view, event) {
+                const state = this.getState(view.state);
+                if (!state) return;
+                const newState = {
+                    ...state
+                };
+                newState.handleKeyDown.backspace = event.key === "Backspace";
+                newState.handleKeyDown.delete = event.key === "Delete";
+                newState.handleKeyDown.arrowLeft = event.key === "ArrowLeft";
+                newState.handleKeyDown.arrowRight = event.key === "ArrowRight";
+                if (newState.handleKeyDown.backspace !== state.handleKeyDown.backspace || newState.handleKeyDown.delete !== state.handleKeyDown.delete || newState.handleKeyDown.arrowLeft !== state.handleKeyDown.arrowLeft || newState.handleKeyDown.arrowRight !== state.handleKeyDown.arrowRight) {
+                    trace("handleKeyDown newState =", newState);
+                    view.dispatch(view.state.tr.setMeta(ensureSelectionKey, newState));
+                }
+            }
+        },
+        appendTransaction (_transactions, oldState, newState) {
+            const pluginState = ensureSelectionKey.getState(newState);
+            if (!(newState.selection instanceof TextSelection)) {
+                return null;
+            }
+            if (isPosValid(newState.selection.$anchor) && isPosValid(newState.selection.$head)) {
+                return null;
+            }
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+            if (TRACE_ENABLED) console.groupCollapsed("[ensureSelectionPlugin]", "appendTransaction");
+            trace("appendTransaction", "search for new valid $anchor...");
+            let $newAnchor = getNewValidPos(newState.selection.$anchor, getDirection(oldState.selection.$anchor, newState.selection.$anchor, pluginState));
+            trace("appendTransaction", "new valid $anchor", $newAnchor?.pos, {
+                $newAnchor
+            });
+            trace("appendTransaction", "search for new valid $head...");
+            let $newHead = getNewValidPos(newState.selection.$head, getDirection(oldState.selection.$head, newState.selection.$head, pluginState));
+            trace("appendTransaction", "new valid $head", $newHead?.pos, {
+                $newHead
+            });
+            $newAnchor = $newAnchor ?? newState.selection.$anchor;
+            $newHead = $newHead ?? newState.selection.$head;
+            const newSelection = new TextSelection($newAnchor, $newHead);
+            if (newSelection.anchor === newState.selection.anchor && newSelection.head === newState.selection.head) {
+                trace("appendTransaction", "new selection is the same as old selection, skipping", {
+                    $newAnchor,
+                    $newHead,
+                    selection: newSelection
+                });
+                // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                if (TRACE_ENABLED) console.groupEnd();
+                return null;
+            }
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+            if (TRACE_ENABLED) console.groupEnd();
+            trace("appendTransaction", "setting new selection", $newAnchor.pos, $newHead.pos, {
+                $newAnchor,
+                $newHead,
+                selection: newSelection
+            });
+            return newState.tr.setSelection(newSelection);
+        }
+    });
+}
+export function isEnsureSelectionEnabled() {
+    return true;
+}
+function isPosValid($pos) {
+    // text selection is only valid in nodes that allow inline content
+    // https://github.com/ProseMirror/prosemirror-state/blob/1.4.4/src/selection.ts#L219
+    if (!$pos.parent.inlineContent) {
+        trace("isPosValid", $pos.pos, "pos invalid", "reason: not in inlineContent node", {
+            $pos
+        });
+        return false;
+    }
+    const { deletion, insertion } = getSuggestionMarks($pos.doc.type.schema);
+    const deletionBefore = deletion.isInSet($pos.nodeBefore?.marks ?? []);
+    const deletionAfter = deletion.isInSet($pos.nodeAfter?.marks ?? []);
+    const isAnchorBefore = deletionBefore && deletionBefore.attrs["type"] === "anchor";
+    const isAnchorAfter = deletionAfter && deletionAfter.attrs["type"] === "anchor";
+    if (isAnchorBefore && deletionAfter && !isAnchorAfter) {
+        trace("isPosValid", $pos.pos, "pos invalid", "reason: between deletion anchor and non-anchor deletion", {
+            $pos
+        });
+        return false;
+    }
+    if (deletionBefore && deletionAfter && !isAnchorBefore && !isAnchorAfter) {
+        trace("isPosValid", $pos.pos, "pos invalid", "reason: between two non-anchor deletions", {
+            $pos
+        });
+        return false;
+    }
+    if ($pos.nodeBefore == null && deletionAfter && !isAnchorAfter) {
+        trace("isPosValid", $pos.pos, "pos invalid", "reason: between node boundary and non-anchor deletion", {
+            $pos
+        });
+        return false;
+    }
+    if (deletionBefore && $pos.nodeAfter == null && !isAnchorBefore) {
+        trace("isPosValid", $pos.pos, "pos invalid", "reason: between non-anchor deletion and node boundary", {
+            $pos
+        });
+        return false;
+    }
+    if (deletionBefore && !isAnchorBefore && $pos.nodeAfter == null) {
+        trace("isPosValid", $pos.pos, "pos invalid", "reason: between non-anchor deletion and node boundary", {
+            $pos
+        });
+        return false;
+    }
+    if (deletionBefore && !isAnchorBefore) {
+        trace("isPosValid", $pos.pos, "pos invalid", "reason: between non-anchor deletion and anything", {
+            $pos
+        });
+        return false;
+    }
+    const insertionBefore = insertion.isInSet($pos.nodeBefore?.marks ?? []);
+    const insertionAfter = insertion.isInSet($pos.nodeAfter?.marks ?? []);
+    const ZWSP_REGEXP = new RegExp(ZWSP, "g");
+    const isZWSPBefore = $pos.nodeBefore && $pos.nodeBefore.textContent.replace(ZWSP_REGEXP, "") === "";
+    const isZWSPAfter = $pos.nodeAfter && $pos.nodeAfter.textContent.replace(ZWSP_REGEXP, "") === "";
+    if (insertionBefore && insertionAfter && isZWSPBefore && isZWSPAfter) {
+        trace("isPosValid", $pos.pos, "pos invalid", "reason: between two ZWSP insertions", {
+            $pos
+        });
+        return false;
+    }
+    if (insertionBefore && isZWSPBefore && $pos.nodeAfter == null && // a position like this:
+    // <p><insertion>ZWSP</insertion>|</p>
+    // because it means this paragraph was just created and it's empty
+    $pos.parent.textContent.replace(ZWSP_REGEXP, "") !== "") {
+        trace("isPosValid", $pos.pos, "pos invalid", "reason: between ZWSP insertion and right node boundary", {
+            $pos
+        });
+        return false;
+    }
+    if (insertionAfter && isZWSPAfter && $pos.nodeBefore == null) {
+        trace("isPosValid", $pos.pos, "pos invalid", "reason: between ZWSP insertion and left node boundary", {
+            $pos
+        });
+        return false;
+    }
+    return true;
+}
+function findNextValidPos($initialPos) {
+    let $pos = $initialPos;
+    // to keep searching for the next valid pos we need non-null nodeAfter so we can go right or non-root depth so we can go up
+    while(!isPosValid($pos) && ($pos.nodeAfter != null || $pos.depth > 0)){
+        // first check if we can go into nodeAfter
+        if ($pos.nodeAfter != null) {
+            // if nodeAfter is inline, we can step into it and search for the valid pos in it
+            if ($pos.nodeAfter.isInline) {
+                // nodeAfter is inline - move in by one
+                $pos = $pos.doc.resolve($pos.pos + 1);
+            } else {
+                // nodeAfter is not inline - find starting position of the first inline descendant in nodeAfter
+                let localStartPos = null;
+                $pos.nodeAfter.descendants((child, pos)=>{
+                    if (!child.isInline) return true;
+                    if (localStartPos !== null) return false;
+                    localStartPos = pos;
+                    return false;
+                });
+                if (localStartPos !== null) {
+                    // we have a local starting position of the first inline descendant - convert it to global position
+                    // +1 to "enter" the node, and add local pos
+                    $pos = $pos.doc.resolve($pos.pos + 1 + localStartPos);
+                } else {
+                    // unable to find first inline descendant of nodeAfter - just skip nodeAfter altogether
+                    $pos = $pos.doc.resolve($pos.pos + $pos.nodeAfter.nodeSize);
+                }
+            }
+        } else if ($pos.depth > 0) {
+            // nodeAfter is null - go up
+            $pos = $pos.doc.resolve($pos.after());
+        }
+    }
+    return isPosValid($pos) ? $pos : null;
+}
+function findPreviousValidPos($initialPos) {
+    let $pos = $initialPos;
+    // in order to be able to keep searching, we need either nodeBefore so we can go left, or non-root depth so we can go up
+    while(!isPosValid($pos) && ($pos.nodeBefore != null || $pos.depth > 0)){
+        // first check if we can go into nodeBefore
+        if ($pos.nodeBefore != null) {
+            // if nodeBefore is inline, we can step into it and search for the valid pos in it
+            if ($pos.nodeBefore.isInline) {
+                // nodeBefore is inline - move in by one
+                $pos = $pos.doc.resolve($pos.pos - 1);
+            } else {
+                // nodeBefore is not inline - find ending position of the last inline descendant in nodeBefore
+                let localEndPos = null;
+                $pos.nodeBefore.descendants((child, pos)=>{
+                    if (!child.isInline) return true;
+                    localEndPos = pos + child.nodeSize;
+                    return false;
+                });
+                if (localEndPos !== null) {
+                    // we have a local ending position of the last inline descendant - convert it to global position
+                    // move pos to start of node before, add 1 to "enter" nodeBefore, then add local pos
+                    $pos = $pos.doc.resolve($pos.pos - $pos.nodeBefore.nodeSize + 1 + localEndPos);
+                } else {
+                    // unable to find last inline descendant of nodeBefore - just skip nodeBefore altogether
+                    $pos = $pos.doc.resolve($pos.pos - $pos.nodeBefore.nodeSize);
+                }
+            }
+        } else if ($pos.depth > 0) {
+            // nodeBefore is null - go up
+            $pos = $pos.doc.resolve($pos.before());
+        }
+    }
+    return isPosValid($pos) ? $pos : null;
+}
+function getNewValidPos($pos, dir) {
+    if (isPosValid($pos)) return $pos;
+    trace("getNewValidPos for", $pos.pos, {
+        $pos,
+        dir
+    });
+    if (dir === "right") {
+        const $nextValidPos = findNextValidPos($pos);
+        trace("getNewValidPos", "$nextValidPos", $nextValidPos?.pos, {
+            dir,
+            $pos,
+            $nextValidPos
+        });
+        if ($nextValidPos != null) return $nextValidPos;
+        const $prevValidPos = findPreviousValidPos($pos);
+        trace("getNewValidPos", "$prevValidPos", $prevValidPos?.pos, {
+            dir,
+            $pos,
+            $prevValidPos
+        });
+        if ($prevValidPos != null) return $prevValidPos;
+        return null;
+    }
+    if (dir === "left") {
+        const $prevValidPos = findPreviousValidPos($pos);
+        trace("getNewValidPos", "$prevValidPos", $prevValidPos?.pos, {
+            dir,
+            $pos,
+            $prevValidPos
+        });
+        if ($prevValidPos != null) return $prevValidPos;
+        const $nextValidPos = findNextValidPos($pos);
+        trace("getNewValidPos", "$nextValidPos", $nextValidPos?.pos, {
+            dir,
+            $pos,
+            $nextValidPos
+        });
+        if ($nextValidPos != null) return $nextValidPos;
+        return null;
+    }
+    const $nextValidPos = findNextValidPos($pos);
+    const $prevValidPos = findPreviousValidPos($pos);
+    trace("getNewValidPos", "$nextValidPos", $nextValidPos?.pos, "$prevValidPos", $prevValidPos?.pos, {
+        dir,
+        $pos,
+        $nextValidPos,
+        $prevValidPos
+    });
+    if ($nextValidPos == null && $prevValidPos == null) {
+        return null;
+    }
+    if ($nextValidPos == null) return $prevValidPos;
+    if ($prevValidPos == null) return $nextValidPos;
+    const nextDist = Math.abs($pos.pos - $nextValidPos.pos);
+    const prevDist = Math.abs($pos.pos - $prevValidPos.pos);
+    return nextDist <= prevDist ? $nextValidPos : $prevValidPos;
+}
+function getDirection($oldPos, $newPos, pluginState) {
+    if (pluginState?.handleKeyDown.backspace) return "left";
+    if ($newPos.pos > $oldPos.pos) return "right";
+    if ($newPos.pos < $oldPos.pos) return "left";
+    return null;
+}

package/dist/generateId.js

@@ -8,12 +8,12 @@ export function parseSuggestionId(id) {
     return parsed;
 }
 export function generateNextNumberId(schema, doc) {
-    const { deletion, insertion, modification, structure } = getSuggestionMarks(schema);
+    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 || mark.type === structure);
+        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;

package/dist/index.d.ts

@@ -1,4 +1,5 @@
-export { addSuggestionMarks, insertion, deletion, modification, structure, } from "./schema.js";
+export { addSuggestionMarks, insertion, deletion, modification, hiddenDeletion, } 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";
+export { ensureSelection as experimental_ensureSelection, ensureSelectionKey as experimental_ensureSelectionKey, isEnsureSelectionEnabled as experimental_isEnsureSelectionEnabled, } from "./ensureSelectionPlugin.js";

package/dist/index.js

@@ -1,4 +1,5 @@
-export { addSuggestionMarks, insertion, deletion, modification, structure } from "./schema.js";
+export { addSuggestionMarks, insertion, deletion, modification, hiddenDeletion } 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";
+export { ensureSelection as experimental_ensureSelection, ensureSelectionKey as experimental_ensureSelectionKey, isEnsureSelectionEnabled as experimental_isEnsureSelectionEnabled } from "./ensureSelectionPlugin.js";

package/dist/plugin.js

@@ -1,4 +1,4 @@
-import { Plugin, PluginKey, TextSelection } from "prosemirror-state";
+import { Plugin, PluginKey } from "prosemirror-state";
 import { getSuggestionDecorations } from "./decorations.js";
 export const suggestChangesKey = new PluginKey("@handlewithcare/prosemirror-suggest-changes");
 export function suggestChanges() {
@@ -17,19 +17,7 @@ export function suggestChanges() {
             }
         },
         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;
-            }
+            decorations: getSuggestionDecorations
         }
     });
 }

package/dist/prependDeletionsWithZWSP.d.ts

@@ -0,0 +1,2 @@
+import { type Transaction } from "prosemirror-state";
+export declare function prependDeletionsWithZWSP(transaction: Transaction): Transaction;

package/dist/prependDeletionsWithZWSP.js

@@ -0,0 +1,45 @@
+import { getSuggestionMarks } from "./utils.js";
+import { Transform } from "prosemirror-transform";
+import { ZWSP } from "./constants.js";
+const TRACE_ENABLED = true;
+function trace(...args) {
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (!TRACE_ENABLED) return;
+    console.log("[prependDeletionsWithZWSP]", ...args);
+}
+export function prependDeletionsWithZWSP(transaction) {
+    const { deletion } = getSuggestionMarks(transaction.doc.type.schema);
+    let transform = new Transform(transaction.doc);
+    transform.doc.descendants((node, pos)=>{
+        const mark = node.marks.find((mark)=>mark.type === deletion && mark.attrs["type"] === "anchor");
+        if (!node.isText || mark == null) return true;
+        const mappedPos = transform.mapping.map(pos);
+        transform.delete(mappedPos, mappedPos + node.nodeSize);
+        return true;
+    });
+    transform.steps.forEach((step)=>{
+        transaction.step(step);
+    });
+    if (transform.steps.length > 0) trace(`added ${String(transform.steps.length)} remove zwsp steps to tr`, transform);
+    transform = new Transform(transaction.doc);
+    transform.doc.descendants((node, pos)=>{
+        if (!node.inlineContent) return true;
+        const mark = node.firstChild?.marks.find((mark)=>mark.type === deletion);
+        if (mark == null) return true;
+        if (mark.attrs["type"] === "anchor") return true;
+        const zwspNode = transform.doc.type.schema.text(ZWSP, [
+            deletion.create({
+                type: "anchor",
+                id: mark.attrs["id"]
+            })
+        ]);
+        const mappedPos = transform.mapping.map(pos);
+        transform.insert(mappedPos + 1, zwspNode);
+        return true;
+    });
+    transform.steps.forEach((step)=>{
+        transaction.step(step);
+    });
+    if (transform.steps.length > 0) trace(`added ${String(transform.steps.length)} add zwsp steps to tr`, transform);
+    return transaction;
+}

package/dist/replaceAroundStep.js

@@ -6,7 +6,6 @@ import { suggestRemoveNodeMarkStep } from "./removeNodeMarkStep.js";
 import { suggestReplaceStep } from "./replaceStep.js";
 import { getSuggestionMarks } from "./utils.js";
 import { applySuggestionsToRange } from "./commands.js";
-import { handleStructureStep } from "./features/wrapUnwrap/handleStructureStep.js";
 /**
  * This detects and handles changes from `setNodeMarkup` so that these are tracked as a modification
  * instead of a deletion + insertion
@@ -81,11 +80,7 @@ import { handleStructureStep } from "./features/wrapUnwrap/handleStructureStep.j
  * equivalent replace step will be generated, and then processed via
  * trackReplaceStep().
  */ export function suggestReplaceAroundStep(trackedTransaction, state, doc, step, prevSteps, suggestionId) {
-    let handled = handleStructureStep(trackedTransaction, state, step, prevSteps, suggestionId);
-    if (handled) {
-        return true;
-    }
-    handled = suggestSetNodeMarkup(trackedTransaction, state, doc, step, prevSteps, suggestionId);
+    const handled = suggestSetNodeMarkup(trackedTransaction, state, doc, step, prevSteps, suggestionId);
     if (handled) {
         return true;
     }

package/dist/replaceStep.js

@@ -4,7 +4,6 @@ import { rebasePos } from "./rebasePos.js";
 import { getSuggestionMarks } from "./utils.js";
 import { joinBlocks } from "./features/joinBlocks/index.js";
 import { collapseZWSPNodes, findJoinMark, joinNodesAndMarkJoinPoints, removeZWSPDeletions } from "./features/joinOnDelete/index.js";
-import { handleStructureStep } from "./features/wrapUnwrap/handleStructureStep.js";
 /**
  * Transform a replace step into its equivalent tracked steps.
  *
@@ -35,10 +34,6 @@ import { handleStructureStep } from "./features/wrapUnwrap/handleStructureStep.j
  * 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 handled = handleStructureStep(trackedTransaction, state, step, prevSteps, suggestionId);
-    if (handled) {
-        return true;
-    }
     const { deletion, insertion } = getSuggestionMarks(state.schema);
     // Check for insertion and deletion marks directly
     // adjacent to this step's boundaries. If they exist,
@@ -205,15 +200,16 @@ import { handleStructureStep } from "./features/wrapUnwrap/handleStructureStep.j
         trackedTransaction.setSelection(TextSelection.near(trackedTransaction.doc.resolve($stepFrom.pos - 1)));
     }
     // Handle insertions
-    // When didBlockJoin is true, only process insertions if the slice contains
+    // When didBlockJoin is true, or nodes were joined, 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 didJoinNodes = didBlockJoin || joinNodesTransform.steps.length > 0;
     const sliceHasNewContent = step.slice.openStart === 0 && step.slice.openEnd === 0;
-    const shouldProcessInsertion = step.slice.content.size && (!didBlockJoin || sliceHasNewContent);
+    const shouldProcessInsertion = step.slice.content.size && (!didJoinNodes || sliceHasNewContent);
     if (shouldProcessInsertion) {
         const $to = trackedTransaction.doc.resolve(stepTo);
         // Don't allow inserting content within an existing deletion

package/dist/schema.d.ts

@@ -1,10 +1,12 @@
 import { type MarkSpec } from "prosemirror-model";
 export declare const deletion: MarkSpec;
+export declare const hiddenDeletion: MarkSpec;
 export declare const insertion: MarkSpec;
 export declare const modification: MarkSpec;
-export declare const structure: 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" | "structure", MarkSpec>;
+export declare function addSuggestionMarks<Marks extends string>(marks: Record<Marks, MarkSpec>, opts?: {
+    experimental_deletions?: "hidden" | "visible";
+}): Record<Marks | "deletion" | "insertion" | "modification", MarkSpec>;