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

package/dist/__tests__/playwrightHelpers.d.ts

@@ -140,9 +140,9 @@ export declare function assertReverted(finalState: EditorState, initialState: Ed
  * This helper replaces the editor document with the provided JSON,
  * clears transactions, and returns initial state.
  */
-export declare function setupDocFromJSON(page: Page, docJSON: unknown): Promise<{
+export declare function setupDocFromJSON(page: Page, docJSON: object): Promise<{
     initialState: EditorState;
-    initialDoc: unknown;
+    initialDoc: object;
 }>;
 /**
  * Assert that document fully reverted to initial state.

package/dist/__tests__/playwrightPage.d.ts

@@ -1,15 +1,66 @@
+import { type Node } from "prosemirror-model";
 import { type Locator, type Page } from "@playwright/test";
 export declare class EditorPage {
     readonly page: Page;
+    readonly deletionMarksVisibility: "hidden" | "visible";
     private readonly selectors;
-    constructor(page: Page);
+    constructor(page: Page, deletionMarksVisibility?: "hidden" | "visible");
     get editor(): Locator;
-    getParagraphText(index: number): Promise<string>;
+    getParagraphText(index: number, childIndexes?: number[]): Promise<string>;
+    getParagraphAt(index: number): Locator;
     getParagraphCount(): Promise<number>;
+    getListItems(): Locator;
+    getParagraphs(): Locator;
+    getListItemCount(): Promise<number>;
     getProseMirrorMarkCount(name: string): Promise<number>;
+    getProseMirrorMarksJSON(): Promise<unknown[]>;
     getProseMirrorSelection(): Promise<{
         anchor: number;
         head: number;
     }>;
     getDOMTextContentOfChildAtIndex(index: number): Promise<string>;
+    getDocJSON(): Promise<object>;
+    getCurrentDoc(): Promise<Node>;
+    getCurrentAndExpectedDoc(expectedDocJSON: object): Promise<{
+        currentDoc: Node;
+        expectedDoc: Node;
+    }>;
+    revertSuggestion(suggestionId: number): Promise<void>;
+    revertAll(): Promise<void>;
+    applyAll(): Promise<void>;
+    /**
+     * Perform an action and wait for ProseMirror state to update.
+     * Stores the current state reference before pressing, then polls until
+     * editor.view.state is a different object (ProseMirror creates a new
+     * immutable state on every transaction).
+     */
+    private doActionAndWaitForState;
+    /**
+     * Press a key and wait for ProseMirror state to update.
+     * Stores the current state reference before pressing, then polls until
+     * editor.view.state is a different object (ProseMirror creates a new
+     * immutable state on every transaction).
+     */
+    pressKey(key: string, opts?: {
+        waitForSelectionChange?: boolean;
+    }): Promise<void>;
+    /**
+     * Insert text and wait for ProseMirror state to update.
+     * Stores the current state reference before pressing, then polls until
+     * editor.view.state is a different object (ProseMirror creates a new
+     * immutable state on every transaction).
+     */
+    insertText(text: string): Promise<void>;
+    /**
+     * Press a key multiple times, waiting for editor state update after each press.
+     */
+    pressKeyMultiple(key: string, count: number, opts?: {
+        waitForSelectionChange?: boolean;
+    }): Promise<void>;
+    setNextNodeId(nextNodeId: number): Promise<void>;
+    enableTrackChanges(): Promise<void>;
+    disableTrackChanges(): Promise<void>;
+    focusEditor(): Promise<void>;
+    setCursorToStart(): Promise<void>;
+    setCursorToEnd(): Promise<void>;
 }

package/dist/commands.js

@@ -5,6 +5,9 @@ import { suggestChangesKey } from "./plugin.js";
 import { getSuggestionMarks } from "./utils.js";
 import { ZWSP } from "./constants.js";
 import { maybeRevertJoinMark } from "./features/joinOnDelete/index.js";
+import { isJoinMark } from "./features/joinOnDelete/types.js";
+import { revertAllStructureSuggestions, revertStructureSuggestion } from "./features/wrapUnwrap/revert/index.js";
+import { applyAllStructureSuggestions, applyStructureSuggestion } from "./features/wrapUnwrap/apply/index.js";
 /**
  * Given a node and a transform, add a set of steps to the
  * transform that applies all marks of type markTypeToApply
@@ -29,6 +32,7 @@ import { maybeRevertJoinMark } from "./features/joinOnDelete/index.js";
             tr.removeNodeMark(0, markTypeToApply);
         }
     }
+    const restoredStructureSuggestionIds = new Set();
     node.descendants((child, pos)=>{
         if (from !== undefined && pos < from) {
             return true;
@@ -60,8 +64,12 @@ import { maybeRevertJoinMark } from "./features/joinOnDelete/index.js";
         const insertionTo = insertionFrom + child.nodeSize;
         if (child.isInline) {
             tr.removeMark(insertionFrom, insertionTo, markTypeToApply);
-            const reverted = maybeRevertJoinMark(tr, insertionFrom, insertionTo, child, markTypeToApply);
-            if (!reverted && child.text === ZWSP) {
+            const joinRevertResult = maybeRevertJoinMark(tr, insertionFrom, insertionTo, child, markTypeToApply);
+            // reverting a join mark may produce new structure marks that were serialized in the join metadata
+            if (joinRevertResult) {
+                joinRevertResult.restoredStructureSuggestionIds.forEach((id)=>restoredStructureSuggestionIds.add(id));
+            }
+            if (!joinRevertResult && child.text === ZWSP) {
                 tr.delete(insertionFrom, insertionTo);
             }
         } else {
@@ -69,6 +77,50 @@ import { maybeRevertJoinMark } from "./features/joinOnDelete/index.js";
         }
         return true;
     });
+    return {
+        restoredStructureSuggestionIds
+    };
+}
+/**
+ * Collect suggestion IDs of join marks in the node
+ *
+ * @param node
+ * @param deletion
+ * @returns an array of suggestion IDs
+ */ function findJoinSuggestionIds(node, deletion) {
+    const joinSuggestionIds = [];
+    node.descendants((child)=>{
+        const mark = deletion.isInSet(child.marks);
+        if (!mark || !isJoinMark(mark)) return true;
+        if (!child.isText || child.text !== ZWSP) return true;
+        joinSuggestionIds.push(mark.attrs.id);
+        return true;
+    });
+    return joinSuggestionIds.reverse();
+}
+/**
+ * Revert suggestions revealed by reverting a join mark
+ * Prioritize reverting revealed suggestions with the same id as the join mark
+ * (that means they are linked to the join mark and has to be reverted together as one)
+ * Revert other revealed suggestions as well so the user doesn't have to revert multiple times at the same place
+ *
+ * @param tr
+ * @param suggestionId
+ * @param restoredStructureSuggestionIds
+ */ function revertRestoredStructureSuggestions(tr, suggestionId, restoredStructureSuggestionIds) {
+    if (restoredStructureSuggestionIds.has(suggestionId)) {
+        const restoredStructureTransform = revertStructureSuggestion(tr.doc, suggestionId);
+        restoredStructureTransform.steps.forEach((step)=>{
+            tr.step(step);
+        });
+    }
+    restoredStructureSuggestionIds.forEach((restoredSuggestionId)=>{
+        if (restoredSuggestionId === suggestionId) return;
+        const restoredStructureTransform = revertStructureSuggestion(tr.doc, restoredSuggestionId);
+        restoredStructureTransform.steps.forEach((step)=>{
+            tr.step(step);
+        });
+    });
 }
 function revertModifications(node, pos, tr) {
     const { modification } = getSuggestionMarks(node.type.schema);
@@ -134,20 +186,42 @@ function applyModificationsToTransform(node, tr, dir, suggestionId, from, to) {
 }
 export function applySuggestionsToNode(node) {
     const { deletion, insertion } = getSuggestionMarks(node.type.schema);
-    const transform = new Transform(node);
-    applySuggestionsToTransform(node, transform, insertion, deletion);
-    applyModificationsToTransform(node, transform, 1);
-    return transform.doc;
+    // first, create a structure transform that applies all structure changes on the given node
+    const structureTransform = applyAllStructureSuggestions(node);
+    // then start a clear transform from the document where the structure changes are applied
+    const suggestionsTransform = new Transform(structureTransform.doc);
+    applySuggestionsToTransform(suggestionsTransform.doc, suggestionsTransform, insertion, deletion);
+    applyModificationsToTransform(suggestionsTransform.doc, suggestionsTransform, 1);
+    // replay suggestion transform on top of the structure transform
+    suggestionsTransform.steps.forEach((step)=>{
+        structureTransform.step(step);
+    });
+    const secondStructureTransform = applyAllStructureSuggestions(structureTransform.doc);
+    secondStructureTransform.steps.forEach((step)=>{
+        structureTransform.step(step);
+    });
+    return structureTransform.doc;
 }
 export function applySuggestionsToRange(doc, from, to) {
+    const { deletion, insertion } = getSuggestionMarks(doc.type.schema);
     // blockRange can only return null if a predicate is provided
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     const nodeRange = doc.resolve(from).blockRange(doc.resolve(to));
-    const { deletion, insertion } = getSuggestionMarks(doc.type.schema);
-    const transform = new Transform(doc);
-    applySuggestionsToTransform(doc, transform, insertion, deletion, undefined, nodeRange.start, nodeRange.end);
-    applyModificationsToTransform(doc, transform, 1, undefined, nodeRange.start, nodeRange.end);
-    return transform.doc.slice(transform.mapping.map(from), transform.mapping.map(to));
+    // create a structure transform that applies all structure changes on the given node range
+    const structureTransform = applyAllStructureSuggestions(doc, nodeRange.start, nodeRange.end);
+    // then start a clear transform from the document where the structure changes are applied
+    const suggestionsTransform = new Transform(structureTransform.doc);
+    applySuggestionsToTransform(suggestionsTransform.doc, suggestionsTransform, insertion, deletion, undefined, nodeRange.start, nodeRange.end);
+    applyModificationsToTransform(suggestionsTransform.doc, suggestionsTransform, 1, undefined, nodeRange.start, nodeRange.end);
+    // replay suggestion transform on top of the structure transform
+    suggestionsTransform.steps.forEach((step)=>{
+        structureTransform.step(step);
+    });
+    const secondStructureTransform = applyAllStructureSuggestions(structureTransform.doc, structureTransform.mapping.map(from), structureTransform.mapping.map(to));
+    secondStructureTransform.steps.forEach((step)=>{
+        structureTransform.step(step);
+    });
+    return structureTransform.doc.slice(structureTransform.mapping.map(from), structureTransform.mapping.map(to));
 }
 /**
  * Command that applies all tracked changes in a document.
@@ -157,13 +231,30 @@ export function applySuggestionsToRange(doc, from, to) {
  * contents left in the doc.
  */ export function applySuggestions(state, dispatch) {
     const { deletion, insertion } = getSuggestionMarks(state.schema);
-    const tr = state.tr;
-    applySuggestionsToTransform(state.doc, tr, insertion, deletion);
-    applyModificationsToTransform(tr.doc, tr, 1);
-    tr.setMeta(suggestChangesKey, {
+    // create a structure transform that applies all structure changes on the given document
+    const structureTransform = applyAllStructureSuggestions(state.doc);
+    // then start a clear transform from the document where the structure changes are applied
+    const suggestionsTransform = new Transform(structureTransform.doc);
+    applySuggestionsToTransform(suggestionsTransform.doc, suggestionsTransform, insertion, deletion);
+    applyModificationsToTransform(suggestionsTransform.doc, suggestionsTransform, 1);
+    // replay suggestion transform on top of the structure transform
+    suggestionsTransform.steps.forEach((step)=>{
+        structureTransform.step(step);
+    });
+    const secondStructureTransform = applyAllStructureSuggestions(structureTransform.doc);
+    secondStructureTransform.steps.forEach((step)=>{
+        structureTransform.step(step);
+    });
+    // apply the structure transform to the transaction
+    const transaction = state.tr;
+    structureTransform.steps.forEach((step)=>{
+        transaction.step(step);
+    });
+    if (!transaction.steps.length) return false;
+    transaction.setMeta(suggestChangesKey, {
         skip: true
     });
-    dispatch?.(tr);
+    dispatch?.(transaction);
     return true;
 }
 /**
@@ -175,13 +266,30 @@ export function applySuggestionsToRange(doc, from, to) {
  */ export function applySuggestionsInRange(from, to) {
     return (state, dispatch)=>{
         const { deletion, insertion } = getSuggestionMarks(state.schema);
-        const tr = state.tr;
-        applySuggestionsToTransform(state.doc, tr, insertion, deletion, undefined, from, to);
-        applyModificationsToTransform(tr.doc, tr, 1, undefined, from, to);
-        tr.setMeta(suggestChangesKey, {
+        // create a structure transform that applies all structure changes on the given node range
+        const structureTransform = applyAllStructureSuggestions(state.doc, from, to);
+        // then start a clear transform from the document where the structure changes are applied
+        const suggestionsTransform = new Transform(structureTransform.doc);
+        applySuggestionsToTransform(suggestionsTransform.doc, suggestionsTransform, insertion, deletion, undefined, from, to);
+        applyModificationsToTransform(suggestionsTransform.doc, suggestionsTransform, 1, undefined, from, to);
+        // replay suggestion transform on top of the structure transform
+        suggestionsTransform.steps.forEach((step)=>{
+            structureTransform.step(step);
+        });
+        const secondStructureTransform = applyAllStructureSuggestions(structureTransform.doc, from === undefined ? undefined : structureTransform.mapping.map(from), to === undefined ? undefined : structureTransform.mapping.map(to));
+        secondStructureTransform.steps.forEach((step)=>{
+            structureTransform.step(step);
+        });
+        // apply the structure transform to the transaction
+        const transaction = state.tr;
+        structureTransform.steps.forEach((step)=>{
+            transaction.step(step);
+        });
+        if (!transaction.steps.length) return false;
+        transaction.setMeta(suggestChangesKey, {
             skip: true
         });
-        dispatch?.(tr);
+        dispatch?.(transaction);
         return true;
     };
 }
@@ -194,14 +302,26 @@ export function applySuggestionsToRange(doc, from, to) {
  */ export function applySuggestion(suggestionId, from, to) {
     return (state, dispatch)=>{
         const { deletion, insertion } = getSuggestionMarks(state.schema);
-        const tr = state.tr;
-        applySuggestionsToTransform(state.doc, tr, insertion, deletion, suggestionId, from, to);
-        applyModificationsToTransform(tr.doc, tr, 1, undefined, from, to);
-        if (!tr.steps.length) return false;
-        tr.setMeta(suggestChangesKey, {
+        // create a structure transform that applies the given structure change on the given node
+        const structureTransform = applyStructureSuggestion(state.doc, suggestionId);
+        // then start a clear transform from the document where the structure changes are applied
+        const suggestionsTransform = new Transform(structureTransform.doc);
+        applySuggestionsToTransform(suggestionsTransform.doc, suggestionsTransform, insertion, deletion, suggestionId, from, to);
+        applyModificationsToTransform(suggestionsTransform.doc, suggestionsTransform, 1, undefined, from, to);
+        // replay suggestion transform on top of the structure transform
+        suggestionsTransform.steps.forEach((step)=>{
+            structureTransform.step(step);
+        });
+        // apply the structure transform to the transaction
+        const transaction = state.tr;
+        structureTransform.steps.forEach((step)=>{
+            transaction.step(step);
+        });
+        if (!transaction.steps.length) return false;
+        transaction.setMeta(suggestChangesKey, {
             skip: true
         });
-        dispatch?.(tr);
+        dispatch?.(transaction);
         return true;
     };
 }
@@ -213,13 +333,40 @@ export function applySuggestionsToRange(doc, from, to) {
  * Modifications tracked in modification marks will be reverted.
  */ export function revertSuggestions(state, dispatch) {
     const { deletion, insertion } = getSuggestionMarks(state.schema);
-    const tr = state.tr;
-    applySuggestionsToTransform(state.doc, tr, deletion, insertion);
-    applyModificationsToTransform(tr.doc, tr, -1);
-    tr.setMeta(suggestChangesKey, {
+    // create a structure transform that reverts all structure changes on the given document
+    const structureTransform = revertAllStructureSuggestions(state.doc);
+    // revert all join marks first as well as any structure marks they contain serialized
+    const joinSuggestionIds = findJoinSuggestionIds(structureTransform.doc, deletion);
+    joinSuggestionIds.forEach((suggestionId)=>{
+        const suggestionsTransform = new Transform(structureTransform.doc);
+        const { restoredStructureSuggestionIds } = applySuggestionsToTransform(suggestionsTransform.doc, suggestionsTransform, deletion, insertion, suggestionId);
+        suggestionsTransform.steps.forEach((step)=>{
+            structureTransform.step(step);
+        });
+        revertRestoredStructureSuggestions(structureTransform, suggestionId, restoredStructureSuggestionIds);
+    });
+    // then start a clear transform from the document where the structure changes and join marks are reverted
+    const suggestionsTransform = new Transform(structureTransform.doc);
+    applySuggestionsToTransform(suggestionsTransform.doc, suggestionsTransform, deletion, insertion);
+    applyModificationsToTransform(suggestionsTransform.doc, suggestionsTransform, -1);
+    // replay suggestion transform on top of the structure transform
+    suggestionsTransform.steps.forEach((step)=>{
+        structureTransform.step(step);
+    });
+    const secondStructureTransform = revertAllStructureSuggestions(structureTransform.doc);
+    secondStructureTransform.steps.forEach((step)=>{
+        structureTransform.step(step);
+    });
+    // apply the structure transform to the transaction
+    const transaction = state.tr;
+    structureTransform.steps.forEach((step)=>{
+        transaction.step(step);
+    });
+    if (!transaction.steps.length) return false;
+    transaction.setMeta(suggestChangesKey, {
         skip: true
     });
-    dispatch?.(tr);
+    dispatch?.(transaction);
     return true;
 }
 /**
@@ -231,13 +378,30 @@ export function applySuggestionsToRange(doc, from, to) {
  */ export function revertSuggestionsInRange(from, to) {
     return (state, dispatch)=>{
         const { deletion, insertion } = getSuggestionMarks(state.schema);
-        const tr = state.tr;
-        applySuggestionsToTransform(state.doc, tr, deletion, insertion, undefined, from, to);
-        applyModificationsToTransform(tr.doc, tr, -1, undefined, from, to);
-        tr.setMeta(suggestChangesKey, {
+        // create a structure transform that reverts all structure changes on the given node range
+        const structureTransform = revertAllStructureSuggestions(state.doc, from, to);
+        // then start a clear transform from the document where the structure changes are reverted
+        const suggestionsTransform = new Transform(structureTransform.doc);
+        applySuggestionsToTransform(suggestionsTransform.doc, suggestionsTransform, deletion, insertion, undefined, from, to);
+        applyModificationsToTransform(suggestionsTransform.doc, suggestionsTransform, -1, undefined, from, to);
+        // replay suggestion transform on top of the structure transform
+        suggestionsTransform.steps.forEach((step)=>{
+            structureTransform.step(step);
+        });
+        const secondStructureTransform = revertAllStructureSuggestions(structureTransform.doc, from === undefined ? undefined : structureTransform.mapping.map(from), to === undefined ? undefined : structureTransform.mapping.map(to));
+        secondStructureTransform.steps.forEach((step)=>{
+            structureTransform.step(step);
+        });
+        // apply the structure transform to the transaction
+        const transaction = state.tr;
+        structureTransform.steps.forEach((step)=>{
+            transaction.step(step);
+        });
+        if (!transaction.steps.length) return false;
+        transaction.setMeta(suggestChangesKey, {
             skip: true
         });
-        dispatch?.(tr);
+        dispatch?.(transaction);
         return true;
     };
 }
@@ -250,14 +414,29 @@ export function applySuggestionsToRange(doc, from, to) {
  */ export function revertSuggestion(suggestionId, from, to) {
     return (state, dispatch)=>{
         const { deletion, insertion } = getSuggestionMarks(state.schema);
-        const tr = state.tr;
-        applySuggestionsToTransform(state.doc, tr, deletion, insertion, suggestionId, from, to);
-        if (!tr.steps.length) return false;
-        tr.setMeta(suggestChangesKey, {
+        // create a structure transform that reverts the given structure change on the given node
+        const structureTransform = revertStructureSuggestion(state.doc, suggestionId);
+        // then start a clear transform from the document where the structure changes are reverted
+        const suggestionsTransform = new Transform(structureTransform.doc);
+        const { restoredStructureSuggestionIds } = applySuggestionsToTransform(suggestionsTransform.doc, suggestionsTransform, deletion, insertion, suggestionId, from, to);
+        applyModificationsToTransform(suggestionsTransform.doc, suggestionsTransform, -1, undefined, from, to);
+        // replay suggestion transform on top of the structure transform
+        suggestionsTransform.steps.forEach((step)=>{
+            structureTransform.step(step);
+        });
+        // in case there are structure marks revealed after join mark revert,
+        // revert them as well
+        revertRestoredStructureSuggestions(structureTransform, suggestionId, restoredStructureSuggestionIds);
+        // apply the structure transform to the transaction
+        const transaction = state.tr;
+        structureTransform.steps.forEach((step)=>{
+            transaction.step(step);
+        });
+        if (!transaction.steps.length) return false;
+        transaction.setMeta(suggestChangesKey, {
             skip: true
         });
-        applyModificationsToTransform(tr.doc, tr, -1, undefined, from, to);
-        dispatch?.(tr);
+        dispatch?.(transaction);
         return true;
     };
 }

package/dist/{ensureSelectionPlugin.js → features/ensureValidSelection/ensureSelectionPlugin.js}

@@ -1,6 +1,5 @@
 import { Plugin, PluginKey, TextSelection } from "prosemirror-state";
-import { getSuggestionMarks } from "./utils.js";
-import { ZWSP } from "./constants.js";
+import { getInvalidSelectionPositionReason } from "./selectionPosition.js";
 const TRACE_ENABLED = false;
 function trace(...args) {
     // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
@@ -47,8 +46,9 @@ export function ensureSelection() {
                 }
             }
         },
-        appendTransaction (_transactions, oldState, newState) {
+        appendTransaction (transactions, oldState, newState) {
             const pluginState = ensureSelectionKey.getState(newState);
+            const isSelectionOnly = transactions.every((tr)=>!tr.docChanged);
             if (!(newState.selection instanceof TextSelection)) {
                 return null;
             }
@@ -58,12 +58,12 @@ export function ensureSelection() {
             // 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));
+            let $newAnchor = getNewValidPos(oldState.selection.$anchor, newState.selection.$anchor, isSelectionOnly, 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));
+            let $newHead = newState.selection.empty ? $newAnchor : getNewValidPos(oldState.selection.$head, newState.selection.$head, isSelectionOnly, pluginState);
             trace("appendTransaction", "new valid $head", $newHead?.pos, {
                 $newHead
             });
@@ -95,77 +95,9 @@ 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", {
+    const invalidReason = getInvalidSelectionPositionReason($pos);
+    if (invalidReason) {
+        trace("isPosValid", $pos.pos, "pos invalid", `reason: ${invalidReason}`, {
             $pos
         });
         return false;
@@ -241,7 +173,38 @@ function findPreviousValidPos($initialPos) {
     }
     return isPosValid($pos) ? $pos : null;
 }
-function getNewValidPos($pos, dir) {
+function findNearestValidPosInSameParent($initialPos) {
+    if (!$initialPos.parent.inlineContent) return null;
+    const start = $initialPos.start();
+    const end = $initialPos.end();
+    const maxDistance = Math.max($initialPos.pos - start, end - $initialPos.pos);
+    for(let distance = 0; distance <= maxDistance; distance++){
+        const nextPos = $initialPos.pos + distance;
+        if (nextPos <= end) {
+            const $nextPos = $initialPos.doc.resolve(nextPos);
+            if (isPosValid($nextPos)) return $nextPos;
+        }
+        const prevPos = $initialPos.pos - distance;
+        if (distance > 0 && prevPos >= start) {
+            const $prevPos = $initialPos.doc.resolve(prevPos);
+            if (isPosValid($prevPos)) return $prevPos;
+        }
+    }
+    return null;
+}
+function getNewValidPosInSelectionDestinationParent($oldPos, $newPos) {
+    if (isPosValid($newPos)) return null;
+    if ($oldPos.parent === $newPos.parent) return null;
+    if (!$newPos.parent.inlineContent) return null;
+    const $sameParentPos = findNearestValidPosInSameParent($newPos);
+    trace("getNewValidPosInSelectionDestinationParent", "$sameParentPos", $sameParentPos?.pos, {
+        $oldPos,
+        $newPos,
+        $sameParentPos
+    });
+    return $sameParentPos;
+}
+function getNewValidPosByDirection($pos, dir) {
     if (isPosValid($pos)) return $pos;
     trace("getNewValidPos for", $pos.pos, {
         $pos,
@@ -298,6 +261,10 @@ function getNewValidPos($pos, dir) {
     const prevDist = Math.abs($pos.pos - $prevValidPos.pos);
     return nextDist <= prevDist ? $nextValidPos : $prevValidPos;
 }
+function getNewValidPos($oldPos, $newPos, isSelectionOnly, pluginState) {
+    const $sameParentPos = isSelectionOnly ? getNewValidPosInSelectionDestinationParent($oldPos, $newPos) : null;
+    return $sameParentPos ?? getNewValidPosByDirection($newPos, getDirection($oldPos, $newPos, pluginState));
+}
 function getDirection($oldPos, $newPos, pluginState) {
     if (pluginState?.handleKeyDown.backspace) return "left";
     if ($newPos.pos > $oldPos.pos) return "right";

package/dist/features/ensureValidSelection/ensureSelectionPlugin.test.d.ts

@@ -0,0 +1 @@
+export {};