@magic-marker/prosemirror-suggest-changes 0.1.8

package/dist/commands.js

@@ -0,0 +1,314 @@
+import { TextSelection } from "prosemirror-state";
+import { Transform } from "prosemirror-transform";
+import { findSuggestionMarkEnd } from "./findSuggestionMarkEnd.js";
+import { suggestChangesKey } from "./plugin.js";
+import { getSuggestionMarks } from "./utils.js";
+/**
+ * Given a node and a transform, add a set of steps to the
+ * transform that applies all marks of type markTypeToApply
+ * and reverts all marks of type markTypeToRevert.
+ *
+ * If suggestionId is provided, will only add steps that impact
+ * deletions, insertions, and modifications with that id.
+ */ function applySuggestionsToTransform(node, tr, markTypeToApply, markTypeToRevert, suggestionId, from, to) {
+    const toApplyIsInSet = suggestionId === undefined ? (marks)=>markTypeToApply.isInSet(marks) : (marks)=>{
+        const mark = markTypeToApply.isInSet(marks);
+        return mark && mark.attrs["id"] === suggestionId ? mark : undefined;
+    };
+    const toRevertIsInSet = suggestionId === undefined ? (marks)=>markTypeToRevert.isInSet(marks) : (marks)=>{
+        const mark = markTypeToRevert.isInSet(marks);
+        return mark && mark.attrs["id"] === suggestionId ? mark : undefined;
+    };
+    const isToApply = toApplyIsInSet(node.marks);
+    if (isToApply) {
+        if (node.isInline) {
+            tr.removeMark(0, node.nodeSize, markTypeToApply);
+        } else {
+            tr.removeNodeMark(0, markTypeToApply);
+        }
+    }
+    node.descendants((child, pos)=>{
+        if (from !== undefined && pos < from) {
+            return true;
+        }
+        if (to !== undefined && pos > to) {
+            return false;
+        }
+        const isToRevert = toRevertIsInSet(child.marks);
+        const isToApply = toApplyIsInSet(child.marks);
+        if (!isToRevert && !isToApply) {
+            return true;
+        }
+        if (isToRevert) {
+            const { pos: deletionFrom, deleted } = tr.mapping.mapResult(pos);
+            if (deleted) return false;
+            const deletionTo = findSuggestionMarkEnd(tr.doc.resolve(deletionFrom + child.nodeSize), markTypeToRevert);
+            // check if the previous and the next text part is a space
+            // if so, we can delete the whole text part
+            const prevChar = tr.doc.textBetween(deletionFrom - 1, deletionFrom, "x", "x");
+            const nextChar = // textBetween is fine with negative positions (??),
+            // but it errors if passed a position greater than the
+            // size of the doc
+            deletionTo <= tr.doc.content.size ? tr.doc.textBetween(deletionTo, deletionTo + 1, "x", "x") : "";
+            const addedRange = prevChar === " " && nextChar === " " ? 1 : 0;
+            tr.deleteRange(deletionFrom, deletionTo + addedRange);
+            return false;
+        }
+        const insertionFrom = tr.mapping.map(pos);
+        const insertionTo = insertionFrom + child.nodeSize;
+        if (child.isInline) {
+            tr.removeMark(insertionFrom, insertionTo, markTypeToApply);
+            if (child.text === "\u200B") {
+                tr.delete(insertionFrom, insertionTo);
+            }
+        } else {
+            tr.removeNodeMark(insertionFrom, markTypeToApply);
+        }
+        return true;
+    });
+}
+function revertModifications(node, pos, tr) {
+    const { modification } = getSuggestionMarks(node.type.schema);
+    const existingMods = node.marks.filter((mark)=>mark.type === modification);
+    for (const mod of existingMods){
+        if (mod.attrs["type"] === "attr" && typeof mod.attrs["attrName"] === "string") {
+            tr.setNodeAttribute(pos, mod.attrs["attrName"], mod.attrs["previousValue"]);
+        } else if (mod.attrs["type"] === "mark") {
+            if (mod.attrs["previousValue"]) {
+                tr.addNodeMark(0, node.type.schema.markFromJSON(mod.attrs["previousValue"]));
+            } else {
+                tr.removeNodeMark(pos, node.type.schema.markFromJSON(mod.attrs["previousValue"]));
+            }
+        } else if (mod.attrs["type"] === "nodeType") {
+            tr.setNodeMarkup(pos, node.type.schema.nodes[mod.attrs["previousValue"]], null);
+        } else {
+            throw new Error("Unknown modification type");
+        }
+    }
+}
+function modificationIsInSet(modification, id, marks) {
+    const mark = modification.isInSet(marks);
+    if (id === undefined) return mark;
+    if (mark?.attrs["id"] === id) return mark;
+    return undefined;
+}
+function applyModificationsToTransform(node, tr, dir, suggestionId, from, to) {
+    const { modification } = getSuggestionMarks(node.type.schema);
+    const isModification = modificationIsInSet(modification, suggestionId, node.marks);
+    if (isModification) {
+        let prevLength;
+        do {
+            // https://github.com/ProseMirror/prosemirror/issues/1525
+            prevLength = tr.steps.length;
+            tr.removeNodeMark(0, modification);
+        }while (tr.steps.length > prevLength);
+        if (dir < 0) {
+            revertModifications(node, 0, tr);
+        }
+    }
+    node.descendants((child, pos)=>{
+        if (from !== undefined && pos < from) {
+            return true;
+        }
+        if (to !== undefined && pos > to) {
+            return false;
+        }
+        const isModification = modificationIsInSet(modification, suggestionId, child.marks);
+        if (!isModification) {
+            return true;
+        }
+        let prevLength;
+        do {
+            // https://github.com/ProseMirror/prosemirror/issues/1525
+            prevLength = tr.steps.length;
+            tr.removeNodeMark(pos, modification);
+        }while (tr.steps.length > prevLength);
+        if (dir < 0) {
+            revertModifications(child, pos, tr);
+        }
+        return true;
+    });
+}
+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;
+}
+export function applySuggestionsToRange(doc, from, to) {
+    // 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));
+}
+/**
+ * Command that applies all tracked changes in a document.
+ *
+ * This means that all content within deletion marks will be deleted.
+ * Insertion marks and modification marks will be removed, and their
+ * 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, {
+        skip: true
+    });
+    dispatch?.(tr);
+    return true;
+}
+/**
+ * Command that applies all tracked changes in specified range.
+ *
+ * This means that all content within deletion marks will be deleted.
+ * Insertion marks and modification marks will be removed, and their
+ * contents left in the doc.
+ */ 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, {
+            skip: true
+        });
+        dispatch?.(tr);
+        return true;
+    };
+}
+/**
+ * Command that applies a given tracked change to a document.
+ *
+ * This means that all content within the deletion mark will be deleted.
+ * The insertion mark and modification mark will be removed, and their
+ * contents left in the doc.
+ */ 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, {
+            skip: true
+        });
+        dispatch?.(tr);
+        return true;
+    };
+}
+/**
+ * Command that reverts all tracked changes in a document.
+ *
+ * This means that all content within insertion marks will be deleted.
+ * Deletion marks will be removed, and their contents left in the doc.
+ * 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, {
+        skip: true
+    });
+    dispatch?.(tr);
+    return true;
+}
+/**
+ * Command that reverts all tracked changes in specified range.
+ *
+ * This means that all content within insertion marks will be deleted.
+ * Deletion marks will be removed, and their contents left in the doc.
+ * Modifications tracked in modification marks will be reverted.
+ */ 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, {
+            skip: true
+        });
+        dispatch?.(tr);
+        return true;
+    };
+}
+/**
+ * Command that reverts a given tracked change in a document.
+ *
+ * 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) {
+    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, {
+            skip: true
+        });
+        applyModificationsToTransform(tr.doc, tr, -1, undefined, from, to);
+        dispatch?.(tr);
+        return true;
+    };
+}
+/**
+ * Command that updates the selection to cover an existing change.
+ */ export function selectSuggestion(suggestionId) {
+    return (state, dispatch)=>{
+        const { deletion, insertion, modification } = getSuggestionMarks(state.schema);
+        let changeStart = null;
+        let changeEnd = null;
+        state.doc.descendants((node, pos)=>{
+            const mark = node.marks.find((mark)=>mark.type === insertion || mark.type === deletion || mark.type === modification);
+            if (mark?.attrs["id"] !== suggestionId) return true;
+            if (changeStart === null) {
+                changeStart = pos;
+                changeEnd = pos + node.nodeSize;
+                return false;
+            }
+            changeEnd = pos + node.nodeSize;
+            return false;
+        });
+        if (changeStart === null || changeEnd === null) {
+            return false;
+        }
+        if (!dispatch) return true;
+        dispatch(state.tr.setSelection(TextSelection.create(state.doc, changeStart, changeEnd)).scrollIntoView());
+        return true;
+    };
+}
+/** Command that enables suggest changes */ export function enableSuggestChanges(state, dispatch) {
+    if (!suggestChangesKey.getState(state)) return false;
+    if (!dispatch) return true;
+    dispatch(state.tr.setMeta(suggestChangesKey, {
+        skip: true,
+        enabled: true
+    }));
+    return true;
+}
+/** Command that disables suggest changes */ export function disableSuggestChanges(state, dispatch) {
+    if (!suggestChangesKey.getState(state)) return false;
+    if (!dispatch) return true;
+    dispatch(state.tr.setMeta(suggestChangesKey, {
+        skip: true,
+        enabled: false
+    }));
+    return true;
+}
+/** Command that toggles suggest changes on or off */ export function toggleSuggestChanges(state, dispatch) {
+    const pluginState = suggestChangesKey.getState(state);
+    if (!pluginState) return false;
+    if (!dispatch) return true;
+    dispatch(state.tr.setMeta(suggestChangesKey, {
+        skip: true,
+        enabled: !pluginState.enabled
+    }));
+    return true;
+}

package/dist/decorations.d.ts

@@ -0,0 +1,3 @@
+import type { EditorState } from "prosemirror-state";
+import { type DecorationSource } from "prosemirror-view";
+export declare function getSuggestionDecorations(state: EditorState): DecorationSource;

package/dist/decorations.js

@@ -0,0 +1,73 @@
+import { Decoration, DecorationSet } from "prosemirror-view";
+import { getSuggestionMarks } from "./utils.js";
+function pilcrow() {
+    const span = document.createElement("span");
+    span.appendChild(document.createTextNode("¶"));
+    return span;
+}
+export function getSuggestionDecorations(state) {
+    const { deletion, insertion } = getSuggestionMarks(state.schema);
+    const changeDecorations = [];
+    let lastParentNode = null;
+    let lastTextNode = null;
+    let lastTextNodeEndPos = 0;
+    state.doc.descendants((node, pos, parent)=>{
+        if (node.isTextblock && node.childCount) {
+            if (node.children.every((child)=>deletion.isInSet(child.marks))) {
+                changeDecorations.push(Decoration.node(pos, pos + node.nodeSize, {
+                    "data-node-deletion": "true"
+                }));
+            }
+            if (node.children.every((child)=>insertion.isInSet(child.marks))) {
+                changeDecorations.push(Decoration.node(pos, pos + node.nodeSize, {
+                    "data-node-insertion": "true"
+                }));
+            }
+        }
+        if (node.type.name !== "text") return true;
+        const currentDeletionMark = node.marks.find((mark)=>mark.type === deletion);
+        const currentInsertionMark = node.marks.find((mark)=>mark.type === insertion);
+        const lastDeletionMark = lastTextNode?.marks.find((mark)=>mark.type === deletion);
+        const lastInsertionMark = lastTextNode?.marks.find((mark)=>mark.type === insertion);
+        const widgetPos = lastTextNodeEndPos;
+        lastTextNode = node;
+        lastTextNodeEndPos = pos + node.nodeSize;
+        if (parent === lastParentNode) {
+            lastParentNode = parent;
+            return true;
+        }
+        lastParentNode = parent;
+        if ((!currentDeletionMark || !lastDeletionMark) && (!currentInsertionMark || !lastInsertionMark)) {
+            return true;
+        }
+        if (currentDeletionMark?.attrs["id"] !== lastDeletionMark?.attrs["id"] && currentInsertionMark?.attrs["id"] !== lastInsertionMark?.attrs["id"]) {
+            return true;
+        }
+        if (currentDeletionMark) {
+            changeDecorations.push(Decoration.widget(widgetPos, pilcrow, {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                key: currentDeletionMark.attrs["id"],
+                marks: [
+                    deletion.create({
+                        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                        id: currentDeletionMark.attrs["id"]
+                    })
+                ]
+            }));
+        }
+        if (currentInsertionMark) {
+            changeDecorations.push(Decoration.widget(widgetPos, pilcrow, {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                key: currentInsertionMark.attrs["id"],
+                marks: [
+                    insertion.create({
+                        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                        id: currentInsertionMark.attrs["id"]
+                    })
+                ]
+            }));
+        }
+        return true;
+    });
+    return DecorationSet.create(state.doc, changeDecorations);
+}

package/dist/features/joinBlocks/__tests__/blockJoin.playwright.test.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Playwright E2E Tests for Block Join Behavior
+ *
+ * These tests use real keyboard events in a browser environment to verify
+ * that the suggestChanges plugin correctly handles block splitting and joining
+ * operations.
+ *
+ * Key differences from JSDOM tests:
+ * - Uses real browser (via Playwright)
+ * - Uses real keyboard events (page.keyboard.press)
+ * - Tests actual user interactions
+ * - Catches bugs that manual transactions would hide
+ */
+export {};

package/dist/features/joinBlocks/__tests__/crossBlockReplace.test.d.ts

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

package/dist/features/joinBlocks/__tests__/getZWSPPairsInRange.test.d.ts

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

package/dist/features/joinBlocks/__tests__/multiStepBlockJoin.test.d.ts

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

package/dist/features/joinBlocks/__tests__/nestedBlockJoin.test.d.ts

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

package/dist/features/joinBlocks/__tests__/paragraphBackspace.test.d.ts

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

package/dist/features/joinBlocks/__tests__/playwrightHelpers.d.ts

@@ -0,0 +1,143 @@
+/**
+ * Helper functions for Playwright E2E tests.
+ * These helpers reduce test duplication while keeping actual keyboard events.
+ */
+import type { Page } from "@playwright/test";
+export interface EditorState {
+    paragraphCount: number;
+    textContent: string;
+    cursorFrom: number;
+    cursorTo: number;
+    blockCount?: number;
+}
+/**
+ * Common test pattern: Enter then Backspace
+ */
+export declare function testEnterThenBackspace(page: Page): Promise<{
+    initialState: {
+        paragraphCount: number;
+        blockCount: number;
+        textContent: string;
+        cursorFrom: number;
+        cursorTo: number;
+    };
+    afterEnterState: {
+        paragraphCount: number;
+        blockCount: number;
+        textContent: string;
+        cursorFrom: number;
+        cursorTo: number;
+    };
+    finalState: {
+        paragraphCount: number;
+        blockCount: number;
+        textContent: string;
+        cursorFrom: number;
+        cursorTo: number;
+    };
+}>;
+/**
+ * Common test pattern: Enter twice then Backspace twice
+ */
+export declare function testDoubleEnterDoubleBackspace(page: Page): Promise<{
+    initialState: {
+        paragraphCount: number;
+        blockCount: number;
+        textContent: string;
+        cursorFrom: number;
+        cursorTo: number;
+    };
+    afterFirstEnter: {
+        paragraphCount: number;
+        blockCount: number;
+        textContent: string;
+        cursorFrom: number;
+        cursorTo: number;
+    };
+    afterSecondEnter: {
+        paragraphCount: number;
+        blockCount: number;
+        textContent: string;
+        cursorFrom: number;
+        cursorTo: number;
+    };
+    afterFirstBackspace: {
+        paragraphCount: number;
+        blockCount: number;
+        textContent: string;
+        cursorFrom: number;
+        cursorTo: number;
+    };
+    finalState: {
+        paragraphCount: number;
+        blockCount: number;
+        textContent: string;
+        cursorFrom: number;
+        cursorTo: number;
+    };
+}>;
+/**
+ * Common test pattern: Enter then Delete from first block
+ */
+export declare function testEnterThenDeleteFromFirst(page: Page): Promise<{
+    initialState: {
+        paragraphCount: number;
+        blockCount: number;
+        textContent: string;
+        cursorFrom: number;
+        cursorTo: number;
+    };
+    afterEnter: {
+        paragraphCount: number;
+        blockCount: number;
+        textContent: string;
+        cursorFrom: number;
+        cursorTo: number;
+    };
+    finalState: {
+        paragraphCount: number;
+        blockCount: number;
+        textContent: string;
+        cursorFrom: number;
+        cursorTo: number;
+    };
+}>;
+/**
+ * Helper to get current editor state
+ */
+export declare function getEditorState(page: Page): Promise<EditorState>;
+/**
+ * Helper to perform Enter at position
+ */
+export declare function pressEnterAt(page: Page, position: number): Promise<void>;
+/**
+ * Helper to perform Backspace
+ */
+export declare function pressBackspace(page: Page): Promise<void>;
+/**
+ * Helper to perform Delete
+ */
+export declare function pressDelete(page: Page): Promise<void>;
+/**
+ * Common assertion: verify document reverted to original
+ */
+export declare function assertReverted(finalState: EditorState, initialState: EditorState): void;
+/**
+ * Setup document from JSON and get initial state.
+ * 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<{
+    initialState: EditorState;
+    initialDoc: unknown;
+}>;
+/**
+ * Assert that document fully reverted to initial state.
+ * Combines text content and JSON structure assertions.
+ */
+export declare function assertDocFullyReverted(finalState: EditorState, finalDoc: unknown, initialState: EditorState, initialDoc: unknown): void;
+/**
+ * Perform a single Enter/Backspace cycle.
+ * Useful for testing multiple rapid sequences.
+ */
+export declare function performEnterBackspaceCycle(page: Page): Promise<void>;

package/dist/features/joinBlocks/__tests__/testHelpers.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Test helper functions for creating pre-split documents with ZWSPs.
+ * These helpers create documents that are already in a split state,
+ * eliminating the need for tests to programmatically create splits.
+ */
+import { EditorState } from "prosemirror-state";
+import type { MarkType } from "prosemirror-model";
+import { type TaggedNode } from "../../../testing/testBuilders.js";
+export interface SplitDocResult {
+    doc: TaggedNode;
+    state: EditorState;
+    insertion: MarkType;
+}
+/**
+ * Creates two paragraphs with a ZWSP marker at the boundary between them.
+ * This simulates the state after an Enter key press at the end of the first paragraph.
+ *
+ * @param text1 - Text for the first paragraph
+ * @param text2 - Text for the second paragraph (optional, defaults to empty)
+ * @param suggestionId - The suggestion ID for the ZWSPs and split content
+ * @returns Object containing the document, editor state, and insertion mark type
+ */
+export declare const createSplitParagraphs: (text1: string, text2?: string, suggestionId?: number) => {
+    doc: import("prosemirror-model").Node & {
+        tag: {
+            [tag: string]: number;
+        };
+    };
+    state: EditorState;
+    insertion: MarkType;
+};
+/**
+ * Creates a list (bullet or ordered) with two list items and ZWSP markers at the boundary.
+ * This simulates the state after an Enter key press at the end of the first list item.
+ *
+ * @param listType - Type of list to create ('bullet' or 'ordered')
+ * @param item1Text - Text for the first list item
+ * @param item2Text - Text for the second list item (optional, defaults to empty)
+ * @param suggestionId - The suggestion ID for the ZWSPs and split content
+ * @returns Object containing the document, editor state, and insertion mark type
+ */
+export declare const createSplitList: (listType: "bullet" | "ordered", item1Text: string, item2Text?: string, suggestionId?: number) => {
+    doc: import("prosemirror-model").Node & {
+        tag: {
+            [tag: string]: number;
+        };
+    };
+    state: EditorState;
+    insertion: MarkType;
+};
+/**
+ * Creates a bullet list with three list items after two sequential splits.
+ * This simulates pressing Enter twice, creating three list items with all ZWSPs in place.
+ *
+ * @param item1Text - Text for the first list item
+ * @param suggestionId - The suggestion ID for all ZWSPs
+ * @returns Object containing the document, editor state, and insertion mark type
+ */
+export declare const createDoubleSplitBulletList: (item1Text: string, suggestionId?: number) => {
+    doc: import("prosemirror-model").Node & {
+        tag: {
+            [tag: string]: number;
+        };
+    };
+    state: EditorState;
+    insertion: MarkType;
+};
+/**
+ * Creates three paragraphs after two sequential splits.
+ * This simulates pressing Enter twice, creating three paragraphs with all ZWSPs in place.
+ *
+ * @param text1 - Text for the first paragraph
+ * @param suggestionId - The suggestion ID for all ZWSPs
+ * @returns Object containing the document, editor state, and insertion mark type
+ */
+export declare const createDoubleSplitParagraphs: (text1: string, suggestionId?: number) => {
+    doc: import("prosemirror-model").Node & {
+        tag: {
+            [tag: string]: number;
+        };
+    };
+    state: EditorState;
+    insertion: MarkType;
+};
+/**
+ * Applies a backspace step at a tagged position in the document.
+ * This helper eliminates boilerplate for the common pattern of backspacing at a ZWSP marker.
+ *
+ * @param doc - The document with a tag marking the backspace position
+ * @param state - The editor state
+ * @param tagName - The tag name to backspace at (defaults to "zwsp")
+ * @param suggestionId - The suggestion ID for this operation
+ * @returns The new editor state after applying the backspace
+ */
+export declare const applyBackspaceAtTag: (doc: TaggedNode, state: EditorState, tagName?: string, suggestionId?: number) => EditorState;
+/**
+ * Applies a forward delete step at a tagged position in the document.
+ * This helper eliminates boilerplate for the common pattern of deleting at a position.
+ *
+ * @param doc - The document with a tag marking the delete position
+ * @param state - The editor state
+ * @param tagName - The tag name to delete at
+ * @param suggestionId - The suggestion ID for this operation
+ * @returns The new editor state after applying the delete
+ */
+export declare const applyDeleteAtTag: (doc: TaggedNode, state: EditorState, tagName: string, suggestionId?: number) => EditorState;

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

@@ -0,0 +1,3 @@
+import type { Transaction } from "prosemirror-state";
+import type { MarkType } from "prosemirror-model";
+export declare const joinBlocks: (trackedTransaction: Transaction, stepFrom: number, stepTo: number, insertionMarkType: MarkType) => boolean;