@magic-marker/prosemirror-suggest-changes 0.3.3-wrap-unwrap.0 → 0.3.3-wrap-unwrap.2

package/dist/__tests__/playwrightPage.d.ts

@@ -1,8 +1,9 @@
 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>;
     getParagraphCount(): Promise<number>;
@@ -12,4 +13,10 @@ export declare class EditorPage {
         head: number;
     }>;
     getDOMTextContentOfChildAtIndex(index: number): Promise<string>;
+    getDocJSON(): Promise<object>;
+    getCurrentAndExpectedDoc(expectedDocJSON: object): Promise<{
+        currentDoc: import("prosemirror-model").Node;
+        expectedDoc: import("prosemirror-model").Node;
+    }>;
+    revertAll(): Promise<void>;
 }

package/dist/commands.d.ts

@@ -51,9 +51,7 @@ export declare function revertSuggestionsInRange(from?: number, to?: number): Co
  * The deletion mark will be removed, and their contents left in the doc.
  * Modifications tracked in modification marks will be reverted.
  */
-export declare function revertSuggestion(suggestionId: SuggestionId, from?: number, to?: number, opts?: {
-    structure: boolean;
-}): Command;
+export declare function revertSuggestion(suggestionId: SuggestionId, from?: number, to?: number): Command;
 /**
  * Command that updates the selection to cover an existing change.
  */

package/dist/commands.js

@@ -5,7 +5,7 @@ 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";
+import { applyAllStructureSuggestions, applyAllStructureSuggestionsOnNode, applyOneStructureSuggestion, revertAllStructureSuggestions, revertAllStructureSuggestionsOnNode, revertOneStructureSuggestion } from "./features/wrapUnwrap/revertStructureSuggestions.js";
 /**
  * Given a node and a transform, add a set of steps to the
  * transform that applies all marks of type markTypeToApply
@@ -135,20 +135,34 @@ 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 = applyAllStructureSuggestionsOnNode(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);
+    });
+    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 = applyAllStructureSuggestionsOnNode(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);
+    });
+    return structureTransform.doc.slice(structureTransform.mapping.map(from), structureTransform.mapping.map(to));
 }
 /**
  * Command that applies all tracked changes in a document.
@@ -158,13 +172,26 @@ 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);
+    });
+    // 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;
 }
 /**
@@ -176,13 +203,26 @@ 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 = applyAllStructureSuggestionsOnNode(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);
+        });
+        // 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,18 +234,27 @@ 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);
-        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 = applyOneStructureSuggestion(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;
     };
 }
@@ -217,15 +266,26 @@ 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;
-    const doc = state.doc;
-    revertAllStructureSuggestions(doc, tr);
-    applySuggestionsToTransform(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);
+    // 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);
+    applyModificationsToTransform(suggestionsTransform.doc, suggestionsTransform, -1);
+    // 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;
 }
 /**
@@ -237,13 +297,26 @@ 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 = revertAllStructureSuggestionsOnNode(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);
+        });
+        // 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;
     };
 }
@@ -253,23 +326,29 @@ export function applySuggestionsToRange(doc, from, to) {
  * This means that all content within the insertion mark will be deleted.
  * The deletion mark will be removed, and their contents left in the doc.
  * Modifications tracked in modification marks will be reverted.
- */ export function revertSuggestion(suggestionId, from, to, opts) {
+ */ export function revertSuggestion(suggestionId, from, to) {
     return (state, dispatch)=>{
-        if (opts?.structure === true) {
-            return revertStructureSuggestion(suggestionId)(state, dispatch);
-        }
-        if (opts?.structure !== false && 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);
-        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 = revertOneStructureSuggestion(state.doc, suggestionId);
+        // 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, 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
         });
-        applyModificationsToTransform(tr.doc, tr, -1, undefined, from, to);
-        dispatch?.(tr);
+        dispatch?.(transaction);
         return true;
     };
 }

package/dist/ensureSelectionPlugin.js

@@ -1,7 +1,7 @@
 import { Plugin, PluginKey, TextSelection } from "prosemirror-state";
 import { getSuggestionMarks } from "./utils.js";
 import { ZWSP } from "./constants.js";
-const TRACE_ENABLED = false;
+const TRACE_ENABLED = true;
 function trace(...args) {
     // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
     if (!TRACE_ENABLED) return;
@@ -63,7 +63,7 @@ export function ensureSelection() {
                 $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(newState.selection.$head, getDirection(oldState.selection.$head, newState.selection.$head, pluginState));
             trace("appendTransaction", "new valid $head", $newHead?.pos, {
                 $newHead
             });

package/dist/features/wrapUnwrap/addIdAttr.d.ts

@@ -0,0 +1,2 @@
+import { type NodeSpec } from "prosemirror-model";
+export declare const addIdAttr: (nodeSpec: NodeSpec, key: string) => NodeSpec;

package/dist/features/wrapUnwrap/addIdAttr.js

@@ -0,0 +1,62 @@
+export const addIdAttr = (nodeSpec, key)=>{
+    const { toDOM, parseDOM } = nodeSpec;
+    if (!toDOM || !parseDOM) {
+        console.warn("addIdAttr", "ignored node", key, "with nodeSpec", nodeSpec);
+        return nodeSpec;
+    }
+    const newNodeSpec = {
+        ...nodeSpec,
+        attrs: {
+            ...nodeSpec.attrs ?? {},
+            id: {
+                default: null
+            }
+        },
+        toDOM (node) {
+            const domOutputSpec = toDOM(node);
+            if (!Array.isArray(domOutputSpec)) {
+                console.warn("addIdAttr", "domOutputSpec is not an array, id is not added", domOutputSpec);
+                return domOutputSpec;
+            }
+            const id = typeof node.attrs["id"] === "string" ? node.attrs["id"] : null;
+            const attrs = domOutputSpec[1];
+            if (!Array.isArray(attrs) && typeof attrs === "object" && attrs !== null) {
+                const theRest = domOutputSpec.slice(2);
+                const result = [
+                    domOutputSpec[0],
+                    id ? {
+                        ...attrs,
+                        "data-id": id
+                    } : attrs,
+                    ...theRest
+                ];
+                return result;
+            }
+            const theRest = domOutputSpec.slice(1);
+            const result = [
+                domOutputSpec[0],
+                id ? {
+                    "data-id": id
+                } : {},
+                ...theRest
+            ];
+            return result;
+        },
+        parseDOM: [
+            ...parseDOM.map((tagParseRule)=>({
+                    ...tagParseRule,
+                    getAttrs (dom) {
+                        const id = dom.getAttribute("data-id");
+                        return tagParseRule.getAttrs ? {
+                            ...tagParseRule.getAttrs(dom),
+                            id
+                        } : {
+                            id
+                        };
+                    }
+                }))
+        ]
+    };
+    console.info("addIdAttr", "adding id to node", key, "with nodeSpec", nodeSpec, "new nodeSpec", newNodeSpec);
+    return newNodeSpec;
+};

package/dist/features/wrapUnwrap/buildMaterializedPaths.d.ts

@@ -0,0 +1,3 @@
+import { type MaterializedPaths } from "./types.js";
+import { type Node } from "prosemirror-model";
+export declare function buildMaterializedPaths(doc: Node): MaterializedPaths;

package/dist/features/wrapUnwrap/buildMaterializedPaths.js

@@ -0,0 +1,71 @@
+import { getNodeId } from "./getNodeId.js";
+export function buildMaterializedPaths(doc) {
+    const paths = new Map();
+    // add direct doc children first since they have a specific parent signature due to doc not having an ID
+    doc.children.forEach((node, index, children)=>{
+        const nodeId = getNodeId(node);
+        if (nodeId == null) return;
+        const leftSibling = children[index - 1];
+        const leftSiblingId = leftSibling ? getNodeId(leftSibling) : null;
+        const rightSibling = children[index + 1];
+        const rightSiblingId = rightSibling ? getNodeId(rightSibling) : null;
+        const parent = {
+            nodeId: "__doc__",
+            nodeType: "__doc__",
+            nodeAttrs: {},
+            nodeMarks: [],
+            childSiblingIds: [
+                leftSiblingId,
+                rightSiblingId
+            ],
+            childIndex: index
+        };
+        paths.set(nodeId, {
+            nodeType: node.type.name,
+            chain: [
+                parent
+            ]
+        });
+    });
+    // now add the rest of the nodes
+    doc.descendants((node, _pos, parent, childIndex)=>{
+        if (node.isText) return false;
+        const nodeId = getNodeId(node);
+        if (nodeId == null) return true;
+        // this is to avoid processing direct doc children twice
+        if (paths.has(nodeId)) return true;
+        if (parent == null) return true;
+        const parentId = getNodeId(parent);
+        if (parentId == null) return true;
+        // by definition, for any node it's parent chain should already exist
+        // because we go downwards
+        const parentChain = paths.get(parentId);
+        if (parentChain == null) return true;
+        const leftSibling = parent.children[childIndex - 1];
+        const leftSiblingId = leftSibling ? getNodeId(leftSibling) : null;
+        const rightSibling = parent.children[childIndex + 1];
+        const rightSiblingId = rightSibling ? getNodeId(rightSibling) : null;
+        // (this node parent chain) is (parent chain of the parent node) + (the parent node itself)
+        const parentDesc = {
+            nodeId: parentId,
+            nodeType: parent.type.name,
+            nodeAttrs: parent.attrs,
+            nodeMarks: parent.marks.map((mark)=>mark.toJSON()),
+            childSiblingIds: [
+                leftSiblingId,
+                rightSiblingId
+            ],
+            childIndex: childIndex
+        };
+        const chain = [
+            parentDesc,
+            ...parentChain.chain
+        ];
+        paths.set(nodeId, {
+            nodeType: node.type.name,
+            chain
+        });
+        return true;
+    });
+    return paths;
+}

package/dist/features/wrapUnwrap/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const STRUCTURE_CHANGES_ADD_MARKS = "structure-changes-add-mark-type";
+export declare const STRUCTURE_CHANGES_REVERT_MARKS = "structure-changes-revert-mark-type";
+export declare const LIST_NODES: string[];

package/dist/features/wrapUnwrap/constants.js

@@ -0,0 +1,7 @@
+export const STRUCTURE_CHANGES_ADD_MARKS = "structure-changes-add-mark-type";
+export const STRUCTURE_CHANGES_REVERT_MARKS = "structure-changes-revert-mark-type";
+export const LIST_NODES = [
+    "orderedList",
+    "bulletList",
+    "listItem"
+];

package/dist/features/wrapUnwrap/generateUniqueNodeId.d.ts

@@ -0,0 +1 @@
+export declare function generateUniqueNodeId(): string;

package/dist/features/wrapUnwrap/generateUniqueNodeId.js

@@ -0,0 +1,6 @@
+export function generateUniqueNodeId() {
+    if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+        return crypto.randomUUID();
+    }
+    return `node-${Math.random().toString(36).slice(2)}`;
+}

package/dist/features/wrapUnwrap/getNodeId.d.ts

@@ -0,0 +1,2 @@
+import { type Node } from "prosemirror-model";
+export declare function getNodeId(node: Node): string | null;

package/dist/features/wrapUnwrap/getNodeId.js

@@ -0,0 +1,5 @@
+export function getNodeId(node) {
+    const nodeId = node.attrs["id"];
+    if (typeof nodeId !== "string") return null;
+    return nodeId;
+}

package/dist/features/wrapUnwrap/revertStructureSuggestions.d.ts

@@ -0,0 +1,9 @@
+import { type Node } from "prosemirror-model";
+import { Transform } from "prosemirror-transform";
+import { type SuggestionId } from "../../generateId.js";
+export declare function applyAllStructureSuggestions(node: Node): Transform;
+export declare function revertAllStructureSuggestions(node: Node): Transform;
+export declare function applyOneStructureSuggestion(node: Node, suggestionId: SuggestionId): Transform;
+export declare function revertOneStructureSuggestion(node: Node, suggestionId: SuggestionId): Transform;
+export declare function applyAllStructureSuggestionsOnNode(node: Node, from?: number, to?: number): Transform;
+export declare function revertAllStructureSuggestionsOnNode(node: Node, from?: number, to?: number): Transform;