@magic-marker/prosemirror-suggest-changes 0.3.3-wrap-unwrap.30 → 0.4.0

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: object): Promise<{
+export declare function setupDocFromJSON(page: Page, docJSON: unknown): Promise<{
     initialState: EditorState;
-    initialDoc: object;
+    initialDoc: unknown;
 }>;
 /**
  * Assert that document fully reverted to initial state.

package/dist/__tests__/playwrightPage.d.ts

@@ -1,63 +1,15 @@
-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, deletionMarksVisibility?: "hidden" | "visible");
+    constructor(page: Page);
     get editor(): Locator;
-    getParagraphText(index: number, childIndexes?: number[]): Promise<string>;
-    getParagraphAt(index: number): Locator;
+    getParagraphText(index: number): Promise<string>;
     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, opts?: {
-        waitForSelectionChange?: boolean;
-    }): 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>;
 }

package/dist/commands.js

@@ -5,9 +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 { 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
@@ -32,7 +29,6 @@ import { applyAllStructureSuggestions, applyStructureSuggestion } from "./featur
             tr.removeNodeMark(0, markTypeToApply);
         }
     }
-    const restoredStructureSuggestionIds = new Set();
     node.descendants((child, pos)=>{
         if (from !== undefined && pos < from) {
             return true;
@@ -64,12 +60,8 @@ import { applyAllStructureSuggestions, applyStructureSuggestion } from "./featur
         const insertionTo = insertionFrom + child.nodeSize;
         if (child.isInline) {
             tr.removeMark(insertionFrom, insertionTo, markTypeToApply);
-            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) {
+            const reverted = maybeRevertJoinMark(tr, insertionFrom, insertionTo, child, markTypeToApply);
+            if (!reverted && child.text === ZWSP) {
                 tr.delete(insertionFrom, insertionTo);
             }
         } else {
@@ -77,50 +69,6 @@ import { applyAllStructureSuggestions, applyStructureSuggestion } from "./featur
         }
         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);
@@ -186,42 +134,20 @@ function applyModificationsToTransform(node, tr, dir, suggestionId, from, to) {
 }
 export function applySuggestionsToNode(node) {
     const { deletion, insertion } = getSuggestionMarks(node.type.schema);
-    // 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;
+    const transform = new Transform(node);
+    applySuggestionsToTransform(node, transform, insertion, deletion);
+    applyModificationsToTransform(node, transform, 1);
+    return transform.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));
-    // 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));
+    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));
 }
 /**
  * Command that applies all tracked changes in a document.
@@ -231,30 +157,13 @@ export function applySuggestionsToRange(doc, from, to) {
  * contents left in the doc.
  */ export function applySuggestions(state, dispatch) {
     const { deletion, insertion } = getSuggestionMarks(state.schema);
-    // 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, {
+    const tr = state.tr;
+    applySuggestionsToTransform(state.doc, tr, insertion, deletion);
+    applyModificationsToTransform(tr.doc, tr, 1);
+    tr.setMeta(suggestChangesKey, {
         skip: true
     });
-    dispatch?.(transaction);
+    dispatch?.(tr);
     return true;
 }
 /**
@@ -266,30 +175,13 @@ export function applySuggestionsToRange(doc, from, to) {
  */ export function applySuggestionsInRange(from, to) {
     return (state, dispatch)=>{
         const { deletion, insertion } = getSuggestionMarks(state.schema);
-        // 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, {
+        const tr = state.tr;
+        applySuggestionsToTransform(state.doc, tr, insertion, deletion, undefined, from, to);
+        applyModificationsToTransform(tr.doc, tr, 1, undefined, from, to);
+        tr.setMeta(suggestChangesKey, {
             skip: true
         });
-        dispatch?.(transaction);
+        dispatch?.(tr);
         return true;
     };
 }
@@ -302,26 +194,14 @@ export function applySuggestionsToRange(doc, from, to) {
  */ export function applySuggestion(suggestionId, from, to) {
     return (state, dispatch)=>{
         const { deletion, insertion } = getSuggestionMarks(state.schema);
-        // 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, {
+        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, {
             skip: true
         });
-        dispatch?.(transaction);
+        dispatch?.(tr);
         return true;
     };
 }
@@ -333,40 +213,13 @@ 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);
-    // 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, {
+    const tr = state.tr;
+    applySuggestionsToTransform(state.doc, tr, deletion, insertion);
+    applyModificationsToTransform(tr.doc, tr, -1);
+    tr.setMeta(suggestChangesKey, {
         skip: true
     });
-    dispatch?.(transaction);
+    dispatch?.(tr);
     return true;
 }
 /**
@@ -378,30 +231,13 @@ export function applySuggestionsToRange(doc, from, to) {
  */ export function revertSuggestionsInRange(from, to) {
     return (state, dispatch)=>{
         const { deletion, insertion } = getSuggestionMarks(state.schema);
-        // 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, {
+        const tr = state.tr;
+        applySuggestionsToTransform(state.doc, tr, deletion, insertion, undefined, from, to);
+        applyModificationsToTransform(tr.doc, tr, -1, undefined, from, to);
+        tr.setMeta(suggestChangesKey, {
             skip: true
         });
-        dispatch?.(transaction);
+        dispatch?.(tr);
         return true;
     };
 }
@@ -414,29 +250,14 @@ export function applySuggestionsToRange(doc, from, to) {
  */ export function revertSuggestion(suggestionId, from, to) {
     return (state, dispatch)=>{
         const { deletion, insertion } = getSuggestionMarks(state.schema);
-        // 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, {
+        const tr = state.tr;
+        applySuggestionsToTransform(state.doc, tr, deletion, insertion, suggestionId, from, to);
+        if (!tr.steps.length) return false;
+        tr.setMeta(suggestChangesKey, {
             skip: true
         });
-        dispatch?.(transaction);
+        applyModificationsToTransform(tr.doc, tr, -1, undefined, from, to);
+        dispatch?.(tr);
         return true;
     };
 }

package/dist/ensureSelectionPlugin.js

@@ -63,7 +63,7 @@ export function ensureSelection() {
                 $newAnchor
             });
             trace("appendTransaction", "search for new valid $head...");
-            let $newHead = newState.selection.empty ? $newAnchor : getNewValidPos(newState.selection.$head, getDirection(oldState.selection.$head, newState.selection.$head, pluginState));
+            let $newHead = getNewValidPos(newState.selection.$head, getDirection(oldState.selection.$head, newState.selection.$head, pluginState));
             trace("appendTransaction", "new valid $head", $newHead?.pos, {
                 $newHead
             });
@@ -147,8 +147,8 @@ function isPosValid($pos) {
     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.isText && $pos.nodeBefore.textContent.replace(ZWSP_REGEXP, "") === "";
-    const isZWSPAfter = $pos.nodeAfter && $pos.nodeAfter.isText && $pos.nodeAfter.textContent.replace(ZWSP_REGEXP, "") === "";
+    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

package/dist/features/joinOnDelete/index.d.ts

@@ -1,10 +1,24 @@
-import { Mark, type Node, type MarkType, type ResolvedPos } from "prosemirror-model";
+import { Mark, type Node, type Attrs, type MarkType, type ResolvedPos } from "prosemirror-model";
 import { Transform } from "prosemirror-transform";
 import { type Transaction } from "prosemirror-state";
 import { type SuggestionId } from "../../generateId.js";
-export declare function maybeRevertJoinMark(tr: Transform, from: number, to: number, node: Node, markType: MarkType): false | {
-    restoredStructureSuggestionIds: Set<SuggestionId>;
-};
+interface JoinMarkAttrs {
+    type: "join";
+    data: {
+        leftNode: {
+            type: string;
+            attrs: object;
+            marks: object[];
+        };
+        rightNode: {
+            type: string;
+            attrs: object;
+            marks: object[];
+        };
+    };
+}
+export declare function isJoinMarkAttrs(attrs: Attrs): attrs is JoinMarkAttrs;
+export declare function maybeRevertJoinMark(tr: Transform, from: number, to: number, node: Node, markType: MarkType): boolean;
 /**
  * Remove ZWSP text nodes marked as deletions (except for type=join) from the given range
  */
@@ -20,3 +34,4 @@ export declare function joinNodesAndMarkJoinPoints(trackedTransaction: Transacti
  */
 export declare function collapseZWSPNodes(trackedTransaction: Transaction, from: number, to: number): Transform;
 export declare function findJoinMark(pos: ResolvedPos): Mark | null;
+export {};