@magic-marker/prosemirror-suggest-changes 0.2.0 → 0.2.1-block-join.0

package/dist/{features/joinBlocks/__tests__ → __tests__}/playwrightHelpers.d.ts

@@ -3,12 +3,14 @@
  * These helpers reduce test duplication while keeping actual keyboard events.
  */
 import type { Page } from "@playwright/test";
+import { type Mark } from "prosemirror-model";
 export interface EditorState {
     paragraphCount: number;
     textContent: string;
     cursorFrom: number;
     cursorTo: number;
     blockCount?: number;
+    marks: Mark[];
 }
 /**
  * Common test pattern: Enter then Backspace
@@ -20,6 +22,7 @@ export declare function testEnterThenBackspace(page: Page): Promise<{
         textContent: string;
         cursorFrom: number;
         cursorTo: number;
+        marks: Mark[];
     };
     afterEnterState: {
         paragraphCount: number;
@@ -27,6 +30,7 @@ export declare function testEnterThenBackspace(page: Page): Promise<{
         textContent: string;
         cursorFrom: number;
         cursorTo: number;
+        marks: Mark[];
     };
     finalState: {
         paragraphCount: number;
@@ -34,6 +38,7 @@ export declare function testEnterThenBackspace(page: Page): Promise<{
         textContent: string;
         cursorFrom: number;
         cursorTo: number;
+        marks: Mark[];
     };
 }>;
 /**
@@ -46,6 +51,7 @@ export declare function testDoubleEnterDoubleBackspace(page: Page): Promise<{
         textContent: string;
         cursorFrom: number;
         cursorTo: number;
+        marks: Mark[];
     };
     afterFirstEnter: {
         paragraphCount: number;
@@ -53,6 +59,7 @@ export declare function testDoubleEnterDoubleBackspace(page: Page): Promise<{
         textContent: string;
         cursorFrom: number;
         cursorTo: number;
+        marks: Mark[];
     };
     afterSecondEnter: {
         paragraphCount: number;
@@ -60,6 +67,7 @@ export declare function testDoubleEnterDoubleBackspace(page: Page): Promise<{
         textContent: string;
         cursorFrom: number;
         cursorTo: number;
+        marks: Mark[];
     };
     afterFirstBackspace: {
         paragraphCount: number;
@@ -67,6 +75,7 @@ export declare function testDoubleEnterDoubleBackspace(page: Page): Promise<{
         textContent: string;
         cursorFrom: number;
         cursorTo: number;
+        marks: Mark[];
     };
     finalState: {
         paragraphCount: number;
@@ -74,6 +83,7 @@ export declare function testDoubleEnterDoubleBackspace(page: Page): Promise<{
         textContent: string;
         cursorFrom: number;
         cursorTo: number;
+        marks: Mark[];
     };
 }>;
 /**
@@ -86,6 +96,7 @@ export declare function testEnterThenDeleteFromFirst(page: Page): Promise<{
         textContent: string;
         cursorFrom: number;
         cursorTo: number;
+        marks: Mark[];
     };
     afterEnter: {
         paragraphCount: number;
@@ -93,6 +104,7 @@ export declare function testEnterThenDeleteFromFirst(page: Page): Promise<{
         textContent: string;
         cursorFrom: number;
         cursorTo: number;
+        marks: Mark[];
     };
     finalState: {
         paragraphCount: number;
@@ -100,6 +112,7 @@ export declare function testEnterThenDeleteFromFirst(page: Page): Promise<{
         textContent: string;
         cursorFrom: number;
         cursorTo: number;
+        marks: Mark[];
     };
 }>;
 /**

package/dist/commands.js

@@ -3,6 +3,8 @@ import { Transform } from "prosemirror-transform";
 import { findSuggestionMarkEnd } from "./findSuggestionMarkEnd.js";
 import { suggestChangesKey } from "./plugin.js";
 import { getSuggestionMarks } from "./utils.js";
+import { ZWSP } from "./constants.js";
+import { maybeRevertJoinMark } from "./features/joinOnDelete/index.js";
 /**
  * Given a node and a transform, add a set of steps to the
  * transform that applies all marks of type markTypeToApply
@@ -58,7 +60,8 @@ import { getSuggestionMarks } from "./utils.js";
         const insertionTo = insertionFrom + child.nodeSize;
         if (child.isInline) {
             tr.removeMark(insertionFrom, insertionTo, markTypeToApply);
-            if (child.text === "\u200B") {
+            const reverted = maybeRevertJoinMark(tr, insertionFrom, insertionTo, child, markTypeToApply);
+            if (!reverted && child.text === ZWSP) {
                 tr.delete(insertionFrom, insertionTo);
             }
         } else {

package/dist/constants.d.ts

@@ -0,0 +1 @@
+export declare const ZWSP = "\u200B";

package/dist/constants.js

@@ -0,0 +1 @@
+export const ZWSP = "\u200B";

package/dist/features/joinOnDelete/__tests__/joinOnDelete.playwright.test.d.ts

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

package/dist/features/joinOnDelete/__tests__/joinOnDelete.test.d.ts

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

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

@@ -0,0 +1,37 @@
+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";
+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
+ */
+export declare function removeZWSPDeletions(trackedTransaction: Transaction, from: number, to: number): Transform;
+/**
+ * Join nodes in the given range,
+ * add deletion marks of type="join" at the join points
+ */
+export declare function joinNodesAndMarkJoinPoints(trackedTransaction: Transaction, from: number, to: number, markId: SuggestionId): Transform;
+/**
+ * Find ZWSP nodes marked as insertions and deletions with the same mark id
+ * Delete them from the given range
+ */
+export declare function collapseZWSPNodes(trackedTransaction: Transaction, from: number, to: number): Transform;
+export declare function findJoinMark(pos: ResolvedPos): Mark | null;
+export {};

package/dist/features/joinOnDelete/index.js

@@ -0,0 +1,157 @@
+import { Mark } from "prosemirror-model";
+import { canJoin, Transform } from "prosemirror-transform";
+import { ZWSP } from "../../constants.js";
+import { getSuggestionMarks } from "../../utils.js";
+export function isJoinMarkAttrs(attrs) {
+    if (attrs["type"] !== "join") return false;
+    if (attrs["data"] == null) return false;
+    const data = attrs["data"];
+    if (data.leftNode == null || data.rightNode == null) return false;
+    if (typeof data.leftNode.type !== "string" || typeof data.rightNode.type !== "string") return false;
+    if (typeof data.leftNode.attrs !== "object" || typeof data.rightNode.attrs !== "object") return false;
+    if (!Array.isArray(data.leftNode.marks) || !Array.isArray(data.rightNode.marks)) return false;
+    return true;
+}
+export function maybeRevertJoinMark(tr, from, to, node, markType) {
+    const mark = node.marks.find((mark)=>mark.type === markType);
+    if (!mark || mark.attrs["type"] !== "join" || node.text !== ZWSP) return false;
+    // this is a mark of type join
+    // split the current node at this mark position
+    // delete this mark together with its zwsp content
+    // assign left and right node (after the split) properties from the mark's data
+    tr.delete(from, to);
+    tr.split(from);
+    // insertionFrom is now at the end of the left node (but before the closing token)
+    // after() will give us the position after the closing token (but before the next opening token) - exactly the split pos
+    const $insertionFrom = tr.doc.resolve(from);
+    const $splitPos = tr.doc.resolve($insertionFrom.after());
+    const { attrs } = mark;
+    if (!isJoinMarkAttrs(attrs) || !$splitPos.nodeBefore || !$splitPos.nodeAfter) return false;
+    // restore left and right node type, attrs and marks, as they were before the join
+    const { leftNode, rightNode } = attrs.data;
+    const leftNodeType = tr.doc.type.schema.nodes[leftNode.type];
+    const rightNodeType = tr.doc.type.schema.nodes[rightNode.type];
+    const leftNodeMarks = leftNode.marks.map((markData)=>Mark.fromJSON(tr.doc.type.schema, markData));
+    const rightNodeMarks = rightNode.marks.map((markData)=>Mark.fromJSON(tr.doc.type.schema, markData));
+    if (!leftNodeType || !rightNodeType) return false;
+    tr.setNodeMarkup($splitPos.pos - $splitPos.nodeBefore.nodeSize, leftNodeType, leftNode.attrs, leftNodeMarks);
+    tr.setNodeMarkup($splitPos.pos, rightNodeType, rightNode.attrs, rightNodeMarks);
+    return true;
+}
+/**
+ * Remove ZWSP text nodes marked as deletions (except for type=join) from the given range
+ */ export function removeZWSPDeletions(trackedTransaction, from, to) {
+    const transform = new Transform(trackedTransaction.doc);
+    const $from = transform.doc.resolve(from);
+    const $to = transform.doc.resolve(to);
+    const blockRange = $from.blockRange($to);
+    const doc = transform.doc;
+    if (!blockRange) return transform;
+    const { deletion } = getSuggestionMarks(transform.doc.type.schema);
+    doc.nodesBetween(blockRange.start, blockRange.end, (node, pos)=>{
+        const joinMark = node.marks.find((mark)=>mark.type === deletion && mark.attrs["type"] === "join");
+        const isZWSPNode = node.isText && node.text === ZWSP && deletion.isInSet(node.marks) && joinMark == null;
+        if (!isZWSPNode) return true;
+        const mappedPos = transform.mapping.map(pos);
+        transform.delete(mappedPos, mappedPos + node.nodeSize);
+        return true;
+    });
+    return transform;
+}
+/**
+ * Join nodes in the given range,
+ * add deletion marks of type="join" at the join points
+ */ export function joinNodesAndMarkJoinPoints(trackedTransaction, from, to, markId) {
+    const transform = new Transform(trackedTransaction.doc);
+    const $from = transform.doc.resolve(from);
+    const $to = transform.doc.resolve(to);
+    const blockRange = $from.blockRange($to);
+    const doc = transform.doc;
+    if (!blockRange) return transform;
+    const { deletion } = getSuggestionMarks(transform.doc.type.schema);
+    doc.nodesBetween(blockRange.start, blockRange.end, (node, pos)=>{
+        if (node.isInline) return false;
+        const endOfNode = pos + node.nodeSize;
+        // make sure the node ends within the range
+        if (endOfNode >= blockRange.$to.pos) return true;
+        const $endOfNode = doc.resolve(endOfNode);
+        // make sure we are between two nodes
+        if (!$endOfNode.nodeBefore || !$endOfNode.nodeAfter) return false;
+        // we cannot insert zwsp text nodes into non-textblock nodes
+        if (!$endOfNode.nodeBefore.isTextblock || !$endOfNode.nodeAfter.isTextblock) return true;
+        const mappedEndOfNode = transform.mapping.map(endOfNode);
+        const $mappedEndOfNode = transform.doc.resolve(mappedEndOfNode);
+        if (!canJoin(transform.doc, mappedEndOfNode) || !$mappedEndOfNode.nodeBefore || !$mappedEndOfNode.nodeAfter) {
+            return true;
+        }
+        const leftNode = {
+            type: $endOfNode.nodeBefore.type.name,
+            attrs: $endOfNode.nodeBefore.attrs,
+            marks: $endOfNode.nodeBefore.marks.map((mark)=>mark.toJSON())
+        };
+        const rightNode = {
+            type: $endOfNode.nodeAfter.type.name,
+            attrs: $endOfNode.nodeAfter.attrs,
+            marks: $endOfNode.nodeAfter.marks.map((mark)=>mark.toJSON())
+        };
+        transform.join(mappedEndOfNode);
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const joinStep = transform.steps[transform.steps.length - 1];
+        const joinPos = joinStep.getMap().map(mappedEndOfNode);
+        transform.insert(joinPos, transform.doc.type.schema.text(ZWSP));
+        transform.addMark(joinPos, joinPos + 1, deletion.create({
+            id: markId,
+            type: "join",
+            data: {
+                leftNode,
+                rightNode
+            }
+        }));
+        return false;
+    });
+    return transform;
+}
+/**
+ * Find ZWSP nodes marked as insertions and deletions with the same mark id
+ * Delete them from the given range
+ */ export function collapseZWSPNodes(trackedTransaction, from, to) {
+    const transform = new Transform(trackedTransaction.doc);
+    const $from = transform.doc.resolve(from);
+    const $to = transform.doc.resolve(to);
+    const blockRange = $from.blockRange($to);
+    if (!blockRange) return transform;
+    const { insertion } = getSuggestionMarks(transform.doc.type.schema);
+    let joinPos = null;
+    let insertionPos = null;
+    let insertionPairPos = null;
+    transform.doc.nodesBetween(blockRange.start, blockRange.end, (node, pos)=>{
+        const { deletion } = getSuggestionMarks(transform.doc.type.schema);
+        const joinZWSP = node.marks.find((mark)=>mark.type === deletion && mark.attrs["type"] === "join");
+        if (joinZWSP && joinPos === null) joinPos = pos;
+        const insertionZWSP = node.marks.find((mark)=>mark.type === insertion);
+        if (insertionZWSP && insertionPos !== null && insertionPairPos === null) insertionPairPos = pos;
+        if (insertionZWSP && insertionPos === null) insertionPos = pos;
+        return joinPos == null || insertionPos == null || insertionPairPos == null;
+    });
+    if (joinPos !== null && insertionPos !== null && insertionPairPos !== null) {
+        const between = transform.doc.textBetween(joinPos, insertionPairPos + 1, "__BLOCK__", "__LEAF__");
+        if (between === `${ZWSP}${ZWSP}__BLOCK__${ZWSP}`) {
+            // delete only if there is no real content in between the join and insertion zwsp marks
+            const toDelete = [
+                joinPos,
+                insertionPos,
+                insertionPairPos
+            ];
+            for (const pos of toDelete){
+                const mappedPos = transform.mapping.map(pos);
+                transform.delete(mappedPos, mappedPos + 1);
+            }
+        }
+    }
+    return transform;
+}
+export function findJoinMark(pos) {
+    if (!pos.nodeAfter) return null;
+    const { deletion } = getSuggestionMarks(pos.doc.type.schema);
+    return pos.nodeAfter.marks.find((mark)=>mark.type === deletion && mark.attrs["type"] === "join") ?? null;
+}

package/dist/replaceStep.d.ts

@@ -1,6 +1,6 @@
 import { type Node } from "prosemirror-model";
 import { type EditorState, type Transaction } from "prosemirror-state";
-import { type ReplaceStep, type Step } from "prosemirror-transform";
+import { type Step, type ReplaceStep } from "prosemirror-transform";
 import { type SuggestionId } from "./generateId.js";
 /**
  * Transform a replace step into its equivalent tracked steps.

package/dist/replaceStep.js

@@ -3,6 +3,7 @@ import { findSuggestionMarkEnd } from "./findSuggestionMarkEnd.js";
 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";
 /**
  * Transform a replace step into its equivalent tracked steps.
  *
@@ -74,13 +75,13 @@ import { joinBlocks } from "./features/joinBlocks/index.js";
             markId = suggestionId;
         }
     }
+    let $stepFrom = trackedTransaction.doc.resolve(stepFrom);
+    let $stepTo = trackedTransaction.doc.resolve(stepTo);
     // If there's a deletion, we need to check for and handle
     // the case where it crosses a block boundary, so that we
     // can leave zero-width spaces as markers if there's no other
     // content to anchor the deletion to.
     if (stepFrom !== stepTo) {
-        let $stepFrom = trackedTransaction.doc.resolve(stepFrom);
-        let $stepTo = trackedTransaction.doc.resolve(stepTo);
         // When there are no characters to mark with deletions before
         // the end of a block, we add zero-width, non-printable
         // characters as markers to indicate that a deletion exists
@@ -97,21 +98,6 @@ import { joinBlocks } from "./features/joinBlocks/index.js";
             stepTo++;
             $stepTo = trackedTransaction.doc.resolve(stepTo);
         }
-        // When we produce a deletion mark that directly abuts
-        // an existing mark with a zero-width space, we delete
-        // that space. We'll join the marks later, and can use
-        // the joined marks to find deletions across the block
-        // boundary
-        if ($stepFrom.nodeBefore?.text?.endsWith("\u200B") && !$stepTo.nodeAfter?.text?.startsWith("\u200B")) {
-            trackedTransaction.delete(stepFrom - 1, stepFrom);
-            stepFrom--;
-            stepTo--;
-            $stepFrom = trackedTransaction.doc.resolve(stepFrom);
-            $stepTo = trackedTransaction.doc.resolve(stepTo);
-        }
-        if ($stepTo.nodeAfter?.text?.startsWith("\u200B") && !$stepFrom.nodeBefore?.text?.endsWith("\u200B")) {
-            trackedTransaction.delete(stepTo, stepTo + 1);
-        }
         // If the user is deleting exactly a zero-width space,
         // delete the space and also shift the range back by one,
         // so that they actually mark the character before the
@@ -119,7 +105,10 @@ import { joinBlocks } from "./features/joinBlocks/index.js";
         // the zero-width space is there, so deleting it would
         // appear to do nothing
         if ($stepFrom.nodeBefore && stepTo - stepFrom === 1 && trackedTransaction.doc.textBetween(stepFrom, stepTo) === "\u200B") {
-            trackedTransaction.delete(stepFrom, stepTo);
+            const joinMark = findJoinMark($stepFrom);
+            if (joinMark === null) {
+                trackedTransaction.delete(stepFrom, stepTo);
+            }
             stepFrom--;
             stepTo--;
             $stepFrom = trackedTransaction.doc.resolve(stepFrom);
@@ -127,6 +116,8 @@ import { joinBlocks } from "./features/joinBlocks/index.js";
             trackedTransaction.setSelection(TextSelection.near($stepFrom));
         }
     }
+    $stepFrom = trackedTransaction.doc.resolve(stepFrom);
+    $stepTo = trackedTransaction.doc.resolve(stepTo);
     // TODO: Even if the range doesn't map to a block
     // range, check whether it contains any whole
     // blocks, so that we can use node marks on those.
@@ -137,9 +128,20 @@ import { joinBlocks } from "./features/joinBlocks/index.js";
     // on the content.
     const blockRange = trackedTransaction.doc.resolve(stepFrom).blockRange(trackedTransaction.doc.resolve(stepTo));
     if (!blockRange || blockRange.start !== stepFrom || blockRange.end !== stepTo) {
-        trackedTransaction.addMark(stepFrom, stepTo, deletion.create({
-            id: markId
-        }));
+        // add marks on inline nodes in [stepFrom, stepTo] range
+        // preserve their attributes
+        // this is needed for the join mark to be preserved in case a new deletion goes over it
+        trackedTransaction.doc.nodesBetween(stepFrom, stepTo, (node, pos)=>{
+            if (!node.isInline) return true;
+            const rangeFrom = Math.max(stepFrom, pos);
+            const rangeTo = Math.min(stepTo, pos + node.nodeSize);
+            const mark = deletion.isInSet(node.marks);
+            trackedTransaction.addMark(rangeFrom, rangeTo, deletion.create({
+                ...mark?.attrs ?? {},
+                id: markId
+            }));
+            return false;
+        });
     } else {
         trackedTransaction.doc.nodesBetween(blockRange.start, blockRange.end, (_, pos)=>{
             if (pos < blockRange.start) return true;
@@ -172,6 +174,31 @@ import { joinBlocks } from "./features/joinBlocks/index.js";
             }
         }
     }
+    // remove zwsp deletion marks that we don't need
+    // then actually join nodes inside the range
+    // mark join points with zwsp deletion marks of type join
+    // save left/right node data as they were before the join,
+    // so we can restore the node markup on revert (when we split them back)
+    const removeDeletionsTransform = removeZWSPDeletions(trackedTransaction, stepFrom, stepTo);
+    removeDeletionsTransform.steps.forEach((step)=>{
+        trackedTransaction.step(step);
+    });
+    stepFrom = removeDeletionsTransform.mapping.map(stepFrom);
+    stepTo = removeDeletionsTransform.mapping.map(stepTo);
+    $stepFrom = trackedTransaction.doc.resolve(stepFrom);
+    $stepTo = trackedTransaction.doc.resolve(stepTo);
+    const joinNodesTransform = joinNodesAndMarkJoinPoints(trackedTransaction, stepFrom, stepTo, markId);
+    joinNodesTransform.steps.forEach((step)=>{
+        trackedTransaction.step(step);
+    });
+    stepFrom = joinNodesTransform.mapping.map(stepFrom);
+    stepTo = joinNodesTransform.mapping.map(stepTo);
+    $stepFrom = trackedTransaction.doc.resolve(stepFrom);
+    $stepTo = trackedTransaction.doc.resolve(stepTo);
+    // make sure that cursor does not end up "in between" nodes when the replacement is structural
+    if (removeDeletionsTransform.steps.length > 0 && joinNodesTransform.steps.length > 0 && step.structure) {
+        trackedTransaction.setSelection(TextSelection.near(trackedTransaction.doc.resolve($stepFrom.pos - 1)));
+    }
     // Handle insertions
     // When didBlockJoin is true, only process insertions if the slice contains
     // actual new content (closed slice) rather than just structural info for the join (open slice).
@@ -187,7 +214,7 @@ import { joinBlocks } from "./features/joinBlocks/index.js";
         // Don't allow inserting content within an existing deletion
         // mark. Instead, shift the proposed insertion to the end
         // of the deletion.
-        const insertFrom = findSuggestionMarkEnd($to, deletion);
+        let insertFrom = findSuggestionMarkEnd($to, deletion);
         // We execute the insertion normally, on top of all of the existing
         // tracked changes.
         trackedTransaction.replace(insertFrom, insertFrom, step.slice);
@@ -239,9 +266,20 @@ import { joinBlocks } from "./features/joinBlocks/index.js";
             insertedTo++;
             $insertedTo = trackedTransaction.doc.resolve(insertedTo);
         }
+        const collapseZWSPNodesTransform = collapseZWSPNodes(trackedTransaction, stepFrom, insertedTo);
+        collapseZWSPNodesTransform.steps.forEach((step)=>{
+            trackedTransaction.step(step);
+        });
+        insertFrom = collapseZWSPNodesTransform.mapping.map(insertFrom);
+        insertedTo = collapseZWSPNodesTransform.mapping.map(insertedTo);
         if (insertFrom !== $to.pos) {
             trackedTransaction.setSelection(TextSelection.near(trackedTransaction.doc.resolve(insertFrom + step.slice.size)));
         }
+        // when insertion zwsp and a join mark cancel each other out, what happens is a normal editing "split" of a node
+        // so we need to make sure the cursor is set at the start of the split node on the right
+        if (collapseZWSPNodesTransform.steps.length > 0) {
+            trackedTransaction.setSelection(TextSelection.near(trackedTransaction.doc.resolve(insertedTo)));
+        }
     }
     return markId === suggestionId;
 }

package/dist/schema.js

@@ -5,6 +5,13 @@ export const deletion = {
     attrs: {
         id: {
             validate: suggestionIdValidate
+        },
+        type: {
+            default: null,
+            validate: "string|null"
+        },
+        data: {
+            default: null
         }
     },
     toDOM (mark, inline) {
@@ -15,7 +22,9 @@ export const deletion = {
                 "data-inline": String(inline),
                 ...!inline && {
                     style: "display: block"
-                }
+                },
+                "data-type": JSON.stringify(mark.attrs["type"]),
+                "data-data": JSON.stringify(mark.attrs["data"])
             },
             0
         ];
@@ -26,7 +35,9 @@ export const deletion = {
             getAttrs (node) {
                 if (!node.dataset["id"]) return false;
                 return {
-                    id: JSON.parse(node.dataset["id"])
+                    id: JSON.parse(node.dataset["id"]),
+                    type: JSON.parse(node.dataset["type"] ?? "null"),
+                    data: JSON.parse(node.dataset["data"] ?? "null")
                 };
             }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@magic-marker/prosemirror-suggest-changes",
-  "version": "0.2.0",
+  "version": "0.2.1-block-join.0",
   "license": "MIT",
   "type": "module",
   "module": "dist/index.js",
@@ -80,4 +80,4 @@
     "prosemirror-transform": "^1.0.0",
     "prosemirror-view": "^1.0.0"
   }
-}
+}

package/src/features/joinBlocks/README.md

@@ -0,0 +1,7 @@
+Inside the replaced range, between stepFrom and stepTo in replaceStep.ts we will
+join blocks if on the two sides of the block we find matching ZWSP pairs. For
+that we will need a function to find ZWSP in the range and on the boundaries (
+the next content outside our range ) Then we have to make pairs out of them.
+Then find the positions between those pairs. Then try to do block joins between
+those pairs If the block joins were successful then remove the ZWSPs too. We
+might have to do multiple block joins for non-root level zwsp pairs.

package/src/features/joinOnDelete/README.md

@@ -0,0 +1,8 @@
+When nodes are joined using backspace or delete, let the join happen normally,
+but mark former node boundaries with deletion mark of type="join".
+
+Save information about what nodes were at each side of the boundary before the
+join.
+
+Then on restore, use marks at join points to split the node and restore the node
+markup at each side of the split.