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

package/dist/withSuggestChanges.js

@@ -1,15 +1,97 @@
+import { AddMarkStep, AddNodeMarkStep, AttrStep, RemoveMarkStep, RemoveNodeMarkStep, ReplaceAroundStep, ReplaceStep } from "prosemirror-transform";
+import { trackAddMarkStep } from "./addMarkStep.js";
+import { trackAddNodeMarkStep } from "./addNodeMarkStep.js";
+import { trackAttrStep } from "./attrStep.js";
+import { suggestRemoveMarkStep } from "./removeMarkStep.js";
+import { suggestRemoveNodeMarkStep } from "./removeNodeMarkStep.js";
+import { suggestReplaceAroundStep } from "./replaceAroundStep.js";
+import { suggestReplaceStep } from "./replaceStep.js";
 import { isSuggestChangesEnabled, suggestChangesKey } from "./plugin.js";
+import { generateNextNumberId } from "./generateId.js";
+import { getSuggestionMarks } from "./utils.js";
 import { prependDeletionsWithZWSP } from "./prependDeletionsWithZWSP.js";
-import { getRequiredStructuralContextPaths, suggestStructureChanges } from "./features/wrapUnwrap/structureChangesPlugin.js";
-import { handleSpecialTransactionShape } from "./features/transactionShaping/index.js";
-import { transformToSuggestionTransaction } from "./transformToSuggestionTransaction.js";
-export { transformToSuggestionTransaction } from "./transformToSuggestionTransaction.js";
-export { suggestStructureChanges } from "./features/wrapUnwrap/structureChangesPlugin.js";
-const TRACE_ENABLED = false;
-function trace(...args) {
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-    if (!TRACE_ENABLED) return;
-    console.log("[withSuggestChanges]", ...args);
+function getStepHandler(step) {
+    if (step instanceof ReplaceStep) {
+        return suggestReplaceStep;
+    }
+    if (step instanceof ReplaceAroundStep) {
+        return suggestReplaceAroundStep;
+    }
+    if (step instanceof AddMarkStep) {
+        return trackAddMarkStep;
+    }
+    if (step instanceof RemoveMarkStep) {
+        return suggestRemoveMarkStep;
+    }
+    if (step instanceof AddNodeMarkStep) {
+        return trackAddNodeMarkStep;
+    }
+    if (step instanceof RemoveNodeMarkStep) {
+        return suggestRemoveNodeMarkStep;
+    }
+    if (step instanceof AttrStep) {
+        return trackAttrStep;
+    }
+    // Default handler — simply rebase the step onto the
+    // tracked transaction and apply it.
+    return (trackedTransaction, _state, _doc, step, prevSteps)=>{
+        const reset = prevSteps.slice().reverse().reduce((acc, step)=>acc?.map(step.getMap().invert()) ?? null, step);
+        const rebased = trackedTransaction.steps.reduce((acc, step)=>acc?.map(step.getMap()) ?? null, reset);
+        if (rebased) {
+            trackedTransaction.step(rebased);
+        }
+        return false;
+    };
+}
+/**
+ * Given a standard transaction from ProseMirror, produce
+ * a new transaction that tracks the changes from the original,
+ * rather than applying them.
+ *
+ * For each type of step, we implement custom behavior to prevent
+ * deletions from being removed from the document, instead adding
+ * deletion marks, and ensuring that all insertions have insertion
+ * marks.
+ */ export function transformToSuggestionTransaction(originalTransaction, state, generateId) {
+    getSuggestionMarks(state.schema);
+    let suggestionId = generateId ? generateId(state.schema, originalTransaction.docs[0]) : generateNextNumberId(state.schema, originalTransaction.docs[0]);
+    // Create a new transaction from scratch. The original transaction
+    // is going to be dropped in favor of this one.
+    const trackedTransaction = state.tr;
+    for(let i = 0; i < originalTransaction.steps.length; i++){
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const step = originalTransaction.steps[i];
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const doc = originalTransaction.docs[i];
+        const stepTracker = getStepHandler(step);
+        if (stepTracker(trackedTransaction, state, doc, step, originalTransaction.steps.slice(0, i), suggestionId) && i < originalTransaction.steps.length - 1) {
+            // If the suggestionId was used by one of the step handlers,
+            // increment it so that it's not reused.
+            if (generateId) {
+                suggestionId = generateId(state.schema, trackedTransaction.doc);
+            } else if (typeof suggestionId === "number") {
+                suggestionId = suggestionId + 1;
+            }
+        }
+        continue;
+    }
+    if (originalTransaction.selectionSet && !trackedTransaction.selectionSet) {
+        // Map the original selection backwards through the original transaction,
+        // and then forwards through the new one.
+        const originalBaseDoc = originalTransaction.docs[0];
+        const base = originalBaseDoc ? originalTransaction.selection.map(originalBaseDoc, originalTransaction.mapping.invert()) : originalTransaction.selection;
+        trackedTransaction.setSelection(base.map(trackedTransaction.doc, trackedTransaction.mapping));
+    }
+    if (originalTransaction.scrolledIntoView) {
+        trackedTransaction.scrollIntoView();
+    }
+    if (originalTransaction.storedMarksSet) {
+        trackedTransaction.setStoredMarks(originalTransaction.storedMarks);
+    }
+    // @ts-expect-error Preserve original transaction meta exactly as-is
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    trackedTransaction.meta = originalTransaction.meta;
+    return trackedTransaction;
 }
 /**
  * A `dispatchTransaction` decorator. Wrap your existing `dispatchTransaction`
@@ -21,65 +103,13 @@ function trace(...args) {
  * These modified transactions will suggest changes instead of directly
  * applying them, e.g. by marking a range with the deletion mark rather
  * than removing it from the document.
- */ export function withSuggestChanges(dispatchTransaction, generateId, opts) {
+ */ export function withSuggestChanges(dispatchTransaction, generateId) {
     const dispatch = dispatchTransaction ?? function(tr) {
         this.updateState(this.state.apply(tr));
     };
     return function dispatchTransaction(tr) {
         const ySyncMeta = tr.getMeta("y-sync$") ?? {};
-        const isEnabled = isSuggestChangesEnabled(this.state) && !tr.getMeta("history$") && !tr.getMeta("collab$") && !ySyncMeta.isUndoRedoOperation && !ySyncMeta.isChangeOrigin && !("skip" in (tr.getMeta(suggestChangesKey) ?? {}));
-        let transaction = tr;
-        if (isEnabled) {
-            let structureChangesResult = null;
-            const docBefore = transaction.docs[0];
-            const structuralContextPaths = opts?.experimental_trackStructureChanges ? getRequiredStructuralContextPaths(opts.experimental_trackStructures) : null;
-            const ensureUniqueNodeIds = opts?.experimental_ensureUniqueNodeIds;
-            const shapedTransaction = transaction.docChanged ? handleSpecialTransactionShape({
-                transaction,
-                state: this.state,
-                generateId,
-                structuralContextPaths,
-                ensureUniqueNodeIds
-            }) : null;
-            if (!shapedTransaction && transaction.docChanged && docBefore && structuralContextPaths && typeof ensureUniqueNodeIds === "function") {
-                trace("trying to track structure changes first...");
-                // after a transaction, some nodes may not yet have unique ids (they were just added, and the unique id plugin has not yet run)
-                // this hook allows to "post-process" the transaction and add the missing ids
-                // basically it allows to run the core logic of the unique ids plugin earlier
-                const perfUid = performance.now();
-                const uniqueNodeIdsTransform = ensureUniqueNodeIds([
-                    transaction
-                ], docBefore, transaction.doc);
-                trace("perf", "structure", "ensureUniqueNodsIds took", Number((performance.now() - perfUid).toFixed(2)), "ms");
-                const docAfter = uniqueNodeIdsTransform.doc;
-                trace("unique node ids set", docAfter);
-                // try running structure changes first
-                // if handled, then ignore the main plugin
-                // otherwise use the main plugin
-                const perfStructure = performance.now();
-                structureChangesResult = suggestStructureChanges(docBefore, docAfter, structuralContextPaths, generateId);
-                trace("perf", "structure", "suggestStructureChanges took", Number((performance.now() - perfStructure).toFixed(2)), "ms");
-                trace("structure changes transform completed", structureChangesResult.transform);
-                if (structureChangesResult.handled) {
-                    uniqueNodeIdsTransform.steps.forEach((step)=>{
-                        transaction.step(step);
-                    });
-                    structureChangesResult.transform.steps.forEach((step)=>{
-                        transaction.step(step);
-                    });
-                    trace("applied unique id transform and structure changes transform to the transaction", transaction);
-                }
-            }
-            if (shapedTransaction) {
-                transaction = shapedTransaction;
-            } else if (transaction.docChanged && structureChangesResult?.handled !== true) {
-                trace("running the main suggestions plugin...");
-                const perfSuggestions = performance.now();
-                transaction = transformToSuggestionTransaction(tr, this.state, generateId);
-                trace("perf", "suggestions", "transformToSuggestionTransaction took", Number((performance.now() - perfSuggestions).toFixed(2)), "ms");
-                trace("main suggestions plugin completed", transaction);
-            }
-        }
+        const transaction = isSuggestChangesEnabled(this.state) && !tr.getMeta("history$") && !tr.getMeta("collab$") && !ySyncMeta.isUndoRedoOperation && !ySyncMeta.isChangeOrigin && !("skip" in (tr.getMeta(suggestChangesKey) ?? {})) ? transformToSuggestionTransaction(tr, this.state, generateId) : tr;
         if (transaction.docChanged) {
             prependDeletionsWithZWSP(transaction);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@magic-marker/prosemirror-suggest-changes",
-  "version": "0.3.3-wrap-unwrap.29",
+  "version": "0.4.0",
   "license": "MIT",
   "type": "module",
   "module": "dist/index.js",

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.

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

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

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

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

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

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

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

@@ -1,6 +0,0 @@
-import { type JoinMarkAttrs } from "./types.js";
-export declare const MAX_BLOCK_JOIN_DEPTH = 2;
-export declare function normalizeJoinNodesMetadata(attrs: JoinMarkAttrs): false | {
-    leftNodes: import("./types.js").SerializedJoinNode[];
-    rightNodes: import("./types.js").SerializedJoinNode[];
-};

package/dist/features/joinOnDelete/normalizeJoinNodesMetadata.js

@@ -1,24 +0,0 @@
-import { isSerializedJoinNode } from "./types.js";
-// Block join suggestion metadata/revert currently supports the depth TipTap uses
-// when Backspace joins both list-item paragraphs and their parent list items.
-export const MAX_BLOCK_JOIN_DEPTH = 2;
-export function normalizeJoinNodesMetadata(attrs) {
-    const data = attrs.data;
-    // Normalize legacy metadata so revert can use the same array path.
-    const leftNodes = data.leftNodes ?? (data.leftNode ? [
-        data.leftNode
-    ] : null);
-    const rightNodes = data.rightNodes ?? (data.rightNode ? [
-        data.rightNode
-    ] : null);
-    if (!Array.isArray(leftNodes) || !Array.isArray(rightNodes)) return false;
-    if (leftNodes.length === 0 || leftNodes.length !== rightNodes.length) return false;
-    // Reject unsupported depths instead of partially reverting unknown structure.
-    if (leftNodes.length > MAX_BLOCK_JOIN_DEPTH) return false;
-    if (!leftNodes.every(isSerializedJoinNode)) return false;
-    if (!rightNodes.every(isSerializedJoinNode)) return false;
-    return {
-        leftNodes,
-        rightNodes
-    };
-}

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

@@ -1,34 +0,0 @@
-import { type Mark, type Attrs, type Node } from "prosemirror-model";
-export interface SerializedJoinNode {
-    type: string;
-    attrs: object;
-    marks: {
-        attrs: Record<string, unknown>;
-    }[];
-}
-export interface JoinMarkAttrs {
-    type: "join";
-    data: {
-        leftNode?: SerializedJoinNode;
-        rightNode?: SerializedJoinNode;
-        leftNodes?: SerializedJoinNode[];
-        rightNodes?: SerializedJoinNode[];
-    };
-}
-export interface JoinPair {
-    leftNode: Node;
-    rightNode: Node;
-}
-export interface JoinCandidate {
-    joinPos: number;
-    leftNodes: Node[];
-    rightNodes: Node[];
-}
-export declare function isSerializedJoinNode(node: unknown): node is SerializedJoinNode;
-export declare function isJoinMarkAttrs(attrs: Attrs): attrs is JoinMarkAttrs;
-export declare function isJoinMarkObject(mark: unknown): mark is Omit<Mark, "attrs"> & {
-    attrs: JoinMarkAttrs;
-};
-export declare function isJoinMark(mark: Mark): mark is Omit<Mark, "attrs"> & {
-    attrs: JoinMarkAttrs;
-};

package/dist/features/joinOnDelete/types.js

@@ -1,20 +0,0 @@
-import { getSuggestionMarks } from "../../utils.js";
-export function isSerializedJoinNode(node) {
-    if (node === null || typeof node !== "object") return false;
-    const data = node;
-    return typeof data.type === "string" && typeof data.attrs === "object" && data.attrs !== null && Array.isArray(data.marks);
-}
-export function isJoinMarkAttrs(attrs) {
-    if (attrs["type"] !== "join") return false;
-    if (attrs["data"] == null) return false;
-    return true;
-}
-export function isJoinMarkObject(mark) {
-    if (mark === null || typeof mark !== "object") return false;
-    if (!("attrs" in mark)) return false;
-    return isJoinMarkAttrs(mark.attrs);
-}
-export function isJoinMark(mark) {
-    const { deletion } = getSuggestionMarks(mark.type.schema);
-    return mark.type === deletion && isJoinMarkAttrs(mark.attrs);
-}

package/dist/features/transactionShaping/detectSpecialTransactionShape.d.ts

@@ -1,3 +0,0 @@
-import { type Transaction } from "prosemirror-state";
-import { type SpecialTransactionShape } from "./types.js";
-export declare function detectSpecialTransactionShape(transaction: Transaction): SpecialTransactionShape | null;

package/dist/features/transactionShaping/detectSpecialTransactionShape.js

@@ -1,4 +0,0 @@
-import { detectTipTapParagraphIntoListJoin } from "./tipTapParagraphIntoListJoin/detectTipTapParagraphIntoListJoin.js";
-export function detectSpecialTransactionShape(transaction) {
-    return detectTipTapParagraphIntoListJoin(transaction);
-}

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

@@ -1,3 +0,0 @@
-import { type Transaction } from "prosemirror-state";
-import { type HandleSpecialTransactionShapeArgs } from "./types.js";
-export declare function handleSpecialTransactionShape(args: HandleSpecialTransactionShapeArgs): Transaction | null;

package/dist/features/transactionShaping/index.js

@@ -1,11 +0,0 @@
-import { handleTipTapParagraphIntoListJoin } from "./tipTapParagraphIntoListJoin/index.js";
-const specialTransactionShapeHandlers = [
-    handleTipTapParagraphIntoListJoin
-];
-export function handleSpecialTransactionShape(args) {
-    for (const handler of specialTransactionShapeHandlers){
-        const transaction = handler(args);
-        if (transaction) return transaction;
-    }
-    return null;
-}

package/dist/features/transactionShaping/tipTapParagraphIntoListJoin/detectTipTapParagraphIntoListJoin.d.ts

@@ -1,3 +0,0 @@
-import { type Transaction } from "prosemirror-state";
-import { type TipTapParagraphIntoListJoinShape } from "../types.js";
-export declare function detectTipTapParagraphIntoListJoin(transaction: Transaction): TipTapParagraphIntoListJoinShape | null;

package/dist/features/transactionShaping/tipTapParagraphIntoListJoin/detectTipTapParagraphIntoListJoin.js

@@ -1,48 +0,0 @@
-import { ReplaceStep, Transform } from "prosemirror-transform";
-import { getNodeId } from "../../wrapUnwrap/getNodeId.js";
-// detect a very specific TipTap pattern where joining a paragraph into a list above it
-// causes a 3-step transaction, which is different from normal prosemirror where you just get 1 step
-// see unit test for details
-export function detectTipTapParagraphIntoListJoin(transaction) {
-    if (transaction.steps.length !== 3) return null;
-    const [deleteStep, insertStep, joinStep] = transaction.steps;
-    if (!(deleteStep instanceof ReplaceStep) || !(insertStep instanceof ReplaceStep) || !(joinStep instanceof ReplaceStep)) {
-        return null;
-    }
-    if (deleteStep.slice.content.size !== 0) return null;
-    if (insertStep.from !== insertStep.to) return null;
-    if (insertStep.slice.openStart !== 0 || insertStep.slice.openEnd !== 0) return null;
-    if (insertStep.slice.content.childCount !== 1) return null;
-    if (joinStep.slice.content.size !== 0) return null;
-    if (joinStep.structure !== true) return null;
-    const docBefore = transaction.docs[0];
-    if (!docBefore) return null;
-    const movedNode = docBefore.nodeAt(deleteStep.from);
-    if (!movedNode || !movedNode.isTextblock || movedNode.nodeSize !== deleteStep.to - deleteStep.from) {
-        return null;
-    }
-    const insertedNode = insertStep.slice.content.firstChild;
-    if (!insertedNode?.isTextblock) return null;
-    if (insertedNode.type !== movedNode.type) return null;
-    if (insertedNode.textContent !== movedNode.textContent) return null;
-    const movedNodeId = getNodeId(movedNode);
-    if (!movedNodeId || getNodeId(insertedNode) !== movedNodeId) return null;
-    const previousSibling = docBefore.resolve(deleteStep.from).nodeBefore;
-    if (!previousSibling || previousSibling.isInline) return null;
-    try {
-        const preview = new Transform(docBefore);
-        preview.step(deleteStep);
-        preview.step(insertStep);
-        new Transform(preview.doc).step(joinStep);
-    } catch  {
-        return null;
-    }
-    console.warn("[prosemirror-suggest-changes]", "detected TipTap paragraph into list join shape");
-    return {
-        type: "tipTapParagraphIntoListJoin",
-        deleteStep,
-        insertStep,
-        joinStep,
-        movedNode
-    };
-}

package/dist/features/transactionShaping/tipTapParagraphIntoListJoin/detectTipTapParagraphIntoListJoin.test.d.ts

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

package/dist/features/transactionShaping/tipTapParagraphIntoListJoin/detectTipTapParagraphIntoListJoin.test.js

@@ -1,188 +0,0 @@
-import { EditorState } from "prosemirror-state";
-import { Step } from "prosemirror-transform";
-import { describe, expect, it } from "vitest";
-import { createSchema } from "../../../testing/e2eTestSchema.js";
-import { detectTipTapParagraphIntoListJoin } from "./detectTipTapParagraphIntoListJoin.js";
-const schema = createSchema();
-// when joining a paragraph into a list above it,
-// TipTap List extension overrides the default ProseMirror behavior
-// by default, ProseMirror puts the paragraph to the end of list as a separate list item
-// TipTap instead joins the paragraph with the paragraph of the last list item
-const TIPTAP_PARAGRAPH_INTO_LIST_STEPS = [
-    // first step deletes the paragraph that we're joining
-    {
-        stepType: "replace",
-        from: 42,
-        to: 60
-    },
-    // second step inserts that paragraph into the last list item
-    {
-        stepType: "replace",
-        from: 40,
-        to: 40,
-        slice: {
-            content: [
-                {
-                    type: "paragraph",
-                    attrs: {
-                        id: "node-9",
-                        textAlign: null
-                    },
-                    content: [
-                        {
-                            type: "text",
-                            text: "sample paragraph"
-                        }
-                    ]
-                }
-            ]
-        }
-    },
-    // third step joins the two paragraphs in the list item
-    {
-        stepType: "replace",
-        from: 39,
-        to: 41,
-        structure: true
-    }
-];
-const TIPTAP_PARAGRAPH_INTO_LIST_DOC = {
-    type: "doc",
-    content: [
-        {
-            type: "orderedList",
-            attrs: {
-                order: 1,
-                id: "node-0"
-            },
-            content: [
-                {
-                    type: "listItem",
-                    attrs: {
-                        id: "node-1"
-                    },
-                    content: [
-                        {
-                            type: "paragraph",
-                            attrs: {
-                                id: "node-2"
-                            },
-                            content: [
-                                {
-                                    type: "text",
-                                    text: "Item 1"
-                                }
-                            ]
-                        }
-                    ]
-                },
-                {
-                    type: "listItem",
-                    attrs: {
-                        id: "node-3"
-                    },
-                    content: [
-                        {
-                            type: "paragraph",
-                            attrs: {
-                                id: "node-4"
-                            },
-                            content: [
-                                {
-                                    type: "text",
-                                    text: "Item 2"
-                                }
-                            ]
-                        }
-                    ]
-                },
-                {
-                    type: "listItem",
-                    attrs: {
-                        id: "node-5"
-                    },
-                    content: [
-                        {
-                            type: "paragraph",
-                            attrs: {
-                                id: "node-6"
-                            },
-                            content: [
-                                {
-                                    type: "text",
-                                    text: "Item 3"
-                                }
-                            ]
-                        }
-                    ]
-                },
-                {
-                    type: "listItem",
-                    attrs: {
-                        id: "node-7"
-                    },
-                    content: [
-                        {
-                            type: "paragraph",
-                            attrs: {
-                                id: "node-8"
-                            },
-                            content: [
-                                {
-                                    type: "text",
-                                    text: "Item 4"
-                                }
-                            ]
-                        }
-                    ]
-                }
-            ]
-        },
-        {
-            type: "paragraph",
-            attrs: {
-                id: "node-9"
-            },
-            content: [
-                {
-                    type: "text",
-                    text: "sample paragraph"
-                }
-            ]
-        }
-    ]
-};
-describe("detectTipTapParagraphIntoListJoin", ()=>{
-    it("detects TipTap's three-step paragraph-into-list join shape", ()=>{
-        const doc = schema.nodeFromJSON(TIPTAP_PARAGRAPH_INTO_LIST_DOC);
-        const state = EditorState.create({
-            doc
-        });
-        const transaction = state.tr;
-        TIPTAP_PARAGRAPH_INTO_LIST_STEPS.forEach((stepJSON)=>{
-            transaction.step(Step.fromJSON(schema, stepJSON));
-        });
-        const shape = detectTipTapParagraphIntoListJoin(transaction);
-        expect(shape).toMatchObject({
-            type: "tipTapParagraphIntoListJoin",
-            deleteStep: {
-                from: 42,
-                to: 60
-            },
-            insertStep: {
-                from: 40,
-                to: 40
-            },
-            joinStep: {
-                from: 39,
-                to: 41
-            },
-            movedNode: {
-                attrs: {
-                    id: "node-9"
-                }
-            }
-        });
-        expect(shape?.movedNode.textContent).toBe("sample paragraph");
-    });
-});

package/dist/features/transactionShaping/tipTapParagraphIntoListJoin/handleTipTapParagraphIntoListJoin.d.ts

@@ -1,3 +0,0 @@
-import { type Transaction } from "prosemirror-state";
-import { type HandleSpecialTransactionShapeArgs } from "../types.js";
-export declare function handleTipTapParagraphIntoListJoin(args: HandleSpecialTransactionShapeArgs): Transaction | null;

package/dist/features/transactionShaping/tipTapParagraphIntoListJoin/handleTipTapParagraphIntoListJoin.js

@@ -1,64 +0,0 @@
-import { EditorState } from "prosemirror-state";
-import { preserveTransactionData, transformToSuggestionTransaction } from "../../../transformToSuggestionTransaction.js";
-import { generateNextNumberId } from "../../../generateId.js";
-import { suggestStructureChanges } from "../../wrapUnwrap/structureChangesPlugin.js";
-import { detectSpecialTransactionShape } from "../detectSpecialTransactionShape.js";
-// handle the specific TipTap pattern when backspacing from a paragraph into a list above
-// causes a transaction with 3 steps
-// "slice" the transaction into two pieces, first piece is the first 2 steps, second piece is the last step
-// first piece "moves" the paragraph - handled by structure change tracking - a structure "move" suggestion
-// second piece joins two paragraphs - handled by the main plugin join-on-delete feature - deletion type="join" mark
-export function handleTipTapParagraphIntoListJoin(args) {
-    const shape = detectSpecialTransactionShape(args.transaction);
-    if (!isTipTapParagraphIntoListJoinShape(shape)) return null;
-    if (!args.structuralContextPaths || !args.ensureUniqueNodeIds) return null;
-    const docBefore = args.transaction.docs[0];
-    if (!docBefore) return null;
-    const trackedTransaction = args.state.tr;
-    const sharedSuggestionId = args.generateId ? args.generateId(args.state.schema, docBefore) : generateNextNumberId(args.state.schema, docBefore);
-    const generateSharedSuggestionId = ()=>sharedSuggestionId;
-    try {
-        trackedTransaction.step(shape.deleteStep);
-        trackedTransaction.step(shape.insertStep);
-    } catch  {
-        return null;
-    }
-    const uniqueNodeIdsTransform = args.ensureUniqueNodeIds([
-        args.transaction
-    ], docBefore, trackedTransaction.doc);
-    uniqueNodeIdsTransform.steps.forEach((step)=>{
-        trackedTransaction.step(step);
-    });
-    const structureChangesResult = suggestStructureChanges(docBefore, uniqueNodeIdsTransform.doc, args.structuralContextPaths, generateSharedSuggestionId);
-    if (!structureChangesResult.handled) {
-        return null;
-    }
-    structureChangesResult.transform.steps.forEach((step)=>{
-        trackedTransaction.step(step);
-    });
-    const intermediateState = EditorState.create({
-        schema: args.state.schema,
-        doc: trackedTransaction.doc
-    });
-    const joinTransaction = intermediateState.tr;
-    try {
-        joinTransaction.step(shape.joinStep);
-    } catch  {
-        return null;
-    }
-    const trackedJoinTransaction = transformToSuggestionTransaction(joinTransaction, intermediateState, generateSharedSuggestionId);
-    trackedJoinTransaction.steps.forEach((step)=>{
-        trackedTransaction.step(step);
-    });
-    preserveTransactionData(trackedTransaction, trackedJoinTransaction, {
-        selection: "currentDocument",
-        preserveScroll: false,
-        preserveStoredMarks: false,
-        preserveMeta: false
-    });
-    preserveTransactionData(trackedTransaction, args.transaction);
-    return trackedTransaction;
-}
-function isTipTapParagraphIntoListJoinShape(shape) {
-    return shape?.type === "tipTapParagraphIntoListJoin";
-}

package/dist/features/transactionShaping/tipTapParagraphIntoListJoin/index.d.ts

@@ -1,2 +0,0 @@
-export { detectTipTapParagraphIntoListJoin } from "./detectTipTapParagraphIntoListJoin.js";
-export { handleTipTapParagraphIntoListJoin } from "./handleTipTapParagraphIntoListJoin.js";

package/dist/features/transactionShaping/tipTapParagraphIntoListJoin/index.js

@@ -1,2 +0,0 @@
-export { detectTipTapParagraphIntoListJoin } from "./detectTipTapParagraphIntoListJoin.js";
-export { handleTipTapParagraphIntoListJoin } from "./handleTipTapParagraphIntoListJoin.js";