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

package/dist/features/wrapUnwrap/__tests__/tripleBlockquoteLiftOneNodeFromMiddle.data.d.ts

@@ -0,0 +1,46 @@
+export declare const initialDoc: import("prosemirror-model").Node & {
+    tag: {
+        [tag: string]: number;
+    };
+};
+export declare const finalDoc: import("prosemirror-model").Node & {
+    tag: {
+        [tag: string]: number;
+    };
+};
+export declare const finalDocWithMarks: import("prosemirror-model").Node & {
+    tag: {
+        [tag: string]: number;
+    };
+};
+export declare const steps: {
+    stepType: string;
+    from: number;
+    to: number;
+    gapFrom: number;
+    gapTo: number;
+    insert: number;
+    slice: {
+        content: {
+            type: string;
+            content: {
+                type: string;
+                content: {
+                    type: string;
+                }[];
+            }[];
+        }[];
+        openStart: number;
+        openEnd: number;
+    };
+    structure: boolean;
+}[];
+export declare const inverseSteps: {
+    stepType: string;
+    from: number;
+    to: number;
+    gapFrom: number;
+    gapTo: number;
+    insert: number;
+    structure: boolean;
+}[];

package/dist/features/wrapUnwrap/__tests__/tripleBlockquoteLiftOneNodeFromMiddle.playwright.test.d.ts

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

package/dist/features/wrapUnwrap/__tests__/tripleBlockquoteLiftOneNodeFromMiddle.test.d.ts

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

package/dist/features/wrapUnwrap/__tests__/tripleBlockquoteLiftOneNodeToTheTop.data.d.ts

@@ -0,0 +1,57 @@
+export declare const initialDoc: import("prosemirror-model").Node & {
+    tag: {
+        [tag: string]: number;
+    };
+};
+export declare const finalDoc: import("prosemirror-model").Node & {
+    tag: {
+        [tag: string]: number;
+    };
+};
+export declare const finalDocWithMarks: import("prosemirror-model").Node & {
+    tag: {
+        [tag: string]: number;
+    };
+};
+export declare const steps: {
+    stepType: string;
+    from: number;
+    to: number;
+    gapFrom: number;
+    gapTo: number;
+    insert: number;
+    slice: {
+        content: {
+            type: string;
+            content: {
+                type: string;
+                content: {
+                    type: string;
+                }[];
+            }[];
+        }[];
+        openStart: number;
+    };
+    structure: boolean;
+}[];
+export declare const inverseSteps: {
+    stepType: string;
+    from: number;
+    to: number;
+    gapFrom: number;
+    gapTo: number;
+    insert: number;
+    slice: {
+        content: {
+            type: string;
+            content: {
+                type: string;
+                content: {
+                    type: string;
+                }[];
+            }[];
+        }[];
+        openStart: number;
+    };
+    structure: boolean;
+}[];

package/dist/features/wrapUnwrap/__tests__/tripleBlockquoteLiftOneNodeToTheTop.playwright.test.d.ts

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

package/dist/features/wrapUnwrap/__tests__/tripleBlockquoteLiftOneNodeToTheTop.test.d.ts

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

package/dist/features/wrapUnwrap/__tests__/tripleBlockquoteLiftOneNodeUp.data.d.ts

@@ -0,0 +1,45 @@
+export declare const initialDoc: import("prosemirror-model").Node & {
+    tag: {
+        [tag: string]: number;
+    };
+};
+export declare const finalDoc: import("prosemirror-model").Node & {
+    tag: {
+        [tag: string]: number;
+    };
+};
+export declare const finalDocWithMarks: import("prosemirror-model").Node & {
+    tag: {
+        [tag: string]: number;
+    };
+};
+export declare const steps: {
+    stepType: string;
+    from: number;
+    to: number;
+    gapFrom: number;
+    gapTo: number;
+    insert: number;
+    slice: {
+        content: {
+            type: string;
+        }[];
+        openStart: number;
+    };
+    structure: boolean;
+}[];
+export declare const inverseSteps: {
+    stepType: string;
+    from: number;
+    to: number;
+    gapFrom: number;
+    gapTo: number;
+    insert: number;
+    slice: {
+        content: {
+            type: string;
+        }[];
+        openStart: number;
+    };
+    structure: boolean;
+}[];

package/dist/features/wrapUnwrap/__tests__/tripleBlockquoteLiftOneNodeUp.playwright.test.d.ts

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

package/dist/features/wrapUnwrap/__tests__/tripleBlockquoteLiftOneNodeUp.test.d.ts

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

package/dist/features/wrapUnwrap/__tests__/tripleBlockquoteWrap.data.d.ts

@@ -0,0 +1,44 @@
+export declare const initialDoc: import("prosemirror-model").Node & {
+    tag: {
+        [tag: string]: number;
+    };
+};
+export declare const finalDoc: import("prosemirror-model").Node & {
+    tag: {
+        [tag: string]: number;
+    };
+};
+export declare const finalDocWithMarks: import("prosemirror-model").Node & {
+    tag: {
+        [tag: string]: number;
+    };
+};
+export declare const steps: {
+    stepType: string;
+    from: number;
+    to: number;
+    gapFrom: number;
+    gapTo: number;
+    insert: number;
+    slice: {
+        content: {
+            type: string;
+            content: {
+                type: string;
+                content: {
+                    type: string;
+                }[];
+            }[];
+        }[];
+    };
+    structure: boolean;
+}[];
+export declare const inverseSteps: {
+    stepType: string;
+    from: number;
+    to: number;
+    gapFrom: number;
+    gapTo: number;
+    insert: number;
+    structure: boolean;
+}[];

package/dist/features/wrapUnwrap/__tests__/tripleBlockquoteWrap.playwright.test.d.ts

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

package/dist/features/wrapUnwrap/__tests__/tripleBlockquoteWrap.test.d.ts

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

package/dist/features/wrapUnwrap/__tests__/tripleBlockquoteWrapMultiple.data.d.ts

@@ -0,0 +1,44 @@
+export declare const initialDoc: import("prosemirror-model").Node & {
+    tag: {
+        [tag: string]: number;
+    };
+};
+export declare const finalDoc: import("prosemirror-model").Node & {
+    tag: {
+        [tag: string]: number;
+    };
+};
+export declare const finalDocWithMarks: import("prosemirror-model").Node & {
+    tag: {
+        [tag: string]: number;
+    };
+};
+export declare const steps: {
+    stepType: string;
+    from: number;
+    to: number;
+    gapFrom: number;
+    gapTo: number;
+    insert: number;
+    slice: {
+        content: {
+            type: string;
+            content: {
+                type: string;
+                content: {
+                    type: string;
+                }[];
+            }[];
+        }[];
+    };
+    structure: boolean;
+}[];
+export declare const inverseSteps: {
+    stepType: string;
+    from: number;
+    to: number;
+    gapFrom: number;
+    gapTo: number;
+    insert: number;
+    structure: boolean;
+}[];

package/dist/features/wrapUnwrap/__tests__/tripleBlockquoteWrapMultiple.playwright.test.d.ts

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

package/dist/features/wrapUnwrap/__tests__/tripleBlockquoteWrapMultiple.test.d.ts

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

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

@@ -0,0 +1,41 @@
+import { type Transaction } from "prosemirror-state";
+import { type SuggestionId } from "../../generateId.js";
+import { type MatchingNodeSide } from "./findMatchingNodeSides.js";
+import { type Slice } from "prosemirror-model";
+type ReplaceAroundData = {
+    type: "replaceAround";
+    slice: Slice;
+    insert: number;
+    structure: boolean;
+    debug?: object;
+} & ({
+    value: "gapFrom";
+    position: MatchingNodeSide;
+    fromOffset: number;
+} | {
+    value: "gapTo";
+    position: MatchingNodeSide;
+    toOffset: number;
+} | {
+    value: "from";
+    position: MatchingNodeSide;
+    gapFromOffset: number;
+} | {
+    value: "to";
+    position: MatchingNodeSide;
+    gapToOffset: number;
+});
+type ReplaceData = {
+    type: "replace";
+    slice: Slice;
+    structure: boolean;
+    debug?: object;
+} & ({
+    value: "from";
+    position: MatchingNodeSide;
+} | {
+    value: "to";
+    position: MatchingNodeSide;
+});
+export declare function addStructureMark(suggestionId: SuggestionId, pos: number, payload: ReplaceAroundData | ReplaceData, transaction: Transaction): void;
+export {};

package/dist/features/wrapUnwrap/addStructureMark.js

@@ -0,0 +1,15 @@
+import { getSuggestionMarks } from "../../utils.js";
+export function addStructureMark(suggestionId, pos, payload, transaction) {
+    const { structure } = getSuggestionMarks(transaction.doc.type.schema);
+    transaction.addNodeMark(pos, structure.create({
+        id: suggestionId,
+        data: {
+            ...payload,
+            slice: payload.slice.toJSON()
+        }
+    }));
+    console.log("added structure mark", {
+        suggestionId,
+        payload
+    });
+}

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

@@ -0,0 +1,15 @@
+import { type Node, type NodeRange } from "prosemirror-model";
+export type MatchingNodeSide = "start" | "innerStart" | "end" | "innerEnd";
+export declare function findMatchingNodeSides(doc: Node, range: NodeRange, positions: {
+    from: number;
+    to: number;
+}): {
+    from: {
+        side: MatchingNodeSide;
+        pos: number;
+    };
+    to: {
+        side: MatchingNodeSide;
+        pos: number;
+    };
+};

package/dist/features/wrapUnwrap/findMatchingNodeSides.js

@@ -0,0 +1,133 @@
+export function findMatchingNodeSides(doc, range, positions) {
+    // we make 2 passes
+    // we visit every node in range, and look at its starting (startPos) and inner starting (innerStartPos) positions
+    // (starting - at the start of the node, outside of it, inner starting - inside the node right after its opening token)
+    // we see if "from" and/or "to" match "startPos" or "innerStartPos"
+    // (if "from" matches "startPos" or "innerStartPos", we quickly check if "to" matches "endPos" or "innerEndPos",
+    //     this prioritizes the best case scenario when both "from" and "to" are located at the same node)
+    // second pass we visit every node in range and look at its ending positions in the similar fashion
+    let fromSide = null;
+    let toSide = null;
+    let fromNode = null;
+    let toNode = null;
+    let fromPos = null;
+    let toPos = null;
+    doc.nodesBetween(range.start, range.end, (node, pos)=>{
+        if (node.isInline) return true;
+        const startPos = pos;
+        const innerStartPos = pos + 1;
+        // is from at startPos?
+        if (fromSide === null && startPos === positions.from) {
+            fromSide = "start";
+            fromNode = node;
+            fromPos = pos;
+        }
+        // is from at innerStart pos?
+        if (fromSide === null && innerStartPos === positions.from) {
+            fromSide = "innerStart";
+            fromNode = node;
+            fromPos = pos;
+        }
+        // if we have found from at the starting position of this node, try to find to at the ending positions
+        if (startPos === positions.from || innerStartPos === positions.from) {
+            const endPos = pos + node.nodeSize;
+            const innerEndPos = pos + node.nodeSize - 1;
+            // is to at endPos?
+            if (toSide === null && endPos === positions.to) {
+                toSide = "end";
+                toNode = node;
+                toPos = pos;
+            }
+            // is to at innerEndPos?
+            if (toSide === null && innerEndPos === positions.to) {
+                toSide = "innerEnd";
+                toNode = node;
+                toPos = pos;
+            }
+        }
+        // is to at startPos?
+        if (toSide === null && startPos === positions.to) {
+            toSide = "start";
+            toNode = node;
+            toPos = pos;
+        }
+        // is to at innerStart pos?
+        if (toSide === null && innerStartPos === positions.to) {
+            toSide = "innerStart";
+            toNode = node;
+            toPos = pos;
+        }
+        return true;
+    });
+    doc.nodesBetween(range.start, range.end, (node, pos)=>{
+        if (node.isInline) return true;
+        const endPos = pos + node.nodeSize;
+        const innerEndPos = pos + node.nodeSize - 1;
+        // is from at endPos?
+        if (fromSide === null && endPos === positions.from) {
+            fromSide = "end";
+            fromNode = node;
+            fromPos = pos;
+        }
+        // is from at innerEndPos?
+        if (fromSide === null && innerEndPos === positions.from) {
+            fromSide = "innerEnd";
+            fromNode = node;
+            fromPos = pos;
+        }
+        // is to at endPos?
+        if (toSide === null && endPos === positions.to) {
+            toSide = "end";
+            toNode = node;
+            toPos = pos;
+        }
+        // is to at innerEndPos?
+        if (toSide === null && innerEndPos === positions.to) {
+            toSide = "innerEnd";
+            toNode = node;
+            toPos = pos;
+        }
+        return true;
+    });
+    if (fromSide === null || toSide === null || fromPos === null || toPos === null) {
+        console.error("Not all positions found", {
+            positions,
+            range,
+            from: {
+                side: fromSide,
+                pos: fromPos,
+                node: fromNode
+            },
+            to: {
+                side: toSide,
+                pos: toPos,
+                node: toNode
+            }
+        });
+        throw new Error("Not all positions found");
+    }
+    console.log("found matching node sides", {
+        positions,
+        range,
+        from: {
+            side: fromSide,
+            pos: fromPos,
+            node: fromNode
+        },
+        to: {
+            side: toSide,
+            pos: toPos,
+            node: toNode
+        }
+    });
+    return {
+        from: {
+            side: fromSide,
+            pos: fromPos
+        },
+        to: {
+            side: toSide,
+            pos: toPos
+        }
+    };
+}

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

@@ -0,0 +1,4 @@
+import { type Step } from "prosemirror-transform";
+import { type Transaction } from "prosemirror-state";
+import { type SuggestionId } from "../../generateId.js";
+export declare function handleStructureStep(trackedTransaction: Transaction, step: Step, prevSteps: Step[], suggestionId: SuggestionId): boolean;

package/dist/features/wrapUnwrap/handleStructureStep.js

@@ -0,0 +1,174 @@
+import { ReplaceAroundStep, ReplaceStep, Transform } from "prosemirror-transform";
+import { contentBetween } from "../../contentBetween.js";
+import { rebaseStep } from "../../rebaseStep.js";
+import { findMatchingNodeSides } from "./findMatchingNodeSides.js";
+import { addStructureMark } from "./addStructureMark.js";
+export function handleStructureStep(trackedTransaction, step, prevSteps, suggestionId) {
+    if (step instanceof ReplaceAroundStep) {
+        return handleReplaceAroundStep(trackedTransaction, step, prevSteps, suggestionId);
+    }
+    if (step instanceof ReplaceStep) {
+        return handleReplaceStep(trackedTransaction, step, prevSteps, suggestionId);
+    }
+    return false;
+}
+function handleReplaceAroundStep(trackedTransaction, step, prevSteps, suggestionId) {
+    // consider step structure if structure === true or there is no content in from-gapFrom and gapTo-to
+    // inspired by https://github.com/ProseMirror/prosemirror-transform/blob/1.11.0/src/replace_step.ts#L110
+    const isStructureStep = step.structure || !(contentBetween(trackedTransaction.doc, step.from, step.gapFrom) || contentBetween(trackedTransaction.doc, step.gapTo, step.to));
+    if (!isStructureStep) return false;
+    console.groupCollapsed(`handle structure ReplaceAround step from = ${step.from.toString()}, to = ${step.to.toString()}, gapFrom = ${step.gapFrom.toString()}, gapTo = ${step.gapTo.toString()}`);
+    const rebasedStep = rebaseStep(step, prevSteps, trackedTransaction.steps);
+    if (!rebasedStep || !(rebasedStep instanceof ReplaceAroundStep)) {
+        throw new Error("Failed to rebase replace around step: unexpected step type");
+    }
+    const docBeforeStep = trackedTransaction.doc;
+    trackedTransaction.step(rebasedStep);
+    const inverseStep = rebasedStep.invert(docBeforeStep);
+    console.log({
+        step,
+        rebasedStep,
+        inverseStep
+    });
+    if (!(inverseStep instanceof ReplaceAroundStep)) {
+        throw new Error("Failed to invert replace around step: unexpected step type");
+    }
+    const inverseFrom = inverseStep.from;
+    const inverseTo = inverseStep.to;
+    const $inverseFrom = trackedTransaction.doc.resolve(inverseFrom);
+    const $inverseTo = trackedTransaction.doc.resolve(inverseTo);
+    const inverseGapFrom = inverseStep.gapFrom;
+    const inverseGapTo = inverseStep.gapTo;
+    const $inverseGapFrom = trackedTransaction.doc.resolve(inverseGapFrom);
+    const $inverseGapTo = trackedTransaction.doc.resolve(inverseGapTo);
+    const inverseBlockRange = $inverseFrom.blockRange($inverseTo);
+    const inverseGapBlockRange = $inverseGapFrom.blockRange($inverseGapTo);
+    if (!inverseBlockRange || !inverseGapBlockRange) {
+        throw new Error("Failed to get inverse block range: unexpected range");
+    }
+    const slice = inverseStep.slice;
+    const insert = inverseStep.insert;
+    // positive number - subtract from gapFrom later to reconstruct "from"
+    const fromOffset = inverseGapFrom - inverseFrom;
+    // positive number - add to gapTo on reverse to reconstruct "to"
+    const toOffset = inverseTo - inverseGapTo;
+    // positive number - add to from later to reconstruct "gapFrom"
+    const gapFromOffset = inverseGapFrom - inverseFrom;
+    // positive number - subtract from to later to reconstruct "gapTo"
+    const gapToOffset = inverseTo - inverseGapTo;
+    const isInverseStepStructural = inverseStep.structure;
+    const gapFromToSides = findMatchingNodeSides(trackedTransaction.doc, inverseGapBlockRange, {
+        from: inverseGapFrom,
+        to: inverseGapTo
+    });
+    addStructureMark(suggestionId, gapFromToSides.from.pos, {
+        type: "replaceAround",
+        slice,
+        insert,
+        structure: isInverseStepStructural,
+        value: "gapFrom",
+        position: gapFromToSides.from.side,
+        fromOffset
+    }, trackedTransaction);
+    addStructureMark(suggestionId, gapFromToSides.to.pos, {
+        type: "replaceAround",
+        slice,
+        insert,
+        structure: isInverseStepStructural,
+        value: "gapTo",
+        position: gapFromToSides.to.side,
+        toOffset
+    }, trackedTransaction);
+    const fromToSides = findMatchingNodeSides(trackedTransaction.doc, inverseBlockRange, {
+        from: inverseFrom,
+        to: inverseTo
+    });
+    addStructureMark(suggestionId, fromToSides.from.pos, {
+        type: "replaceAround",
+        slice,
+        insert,
+        structure: isInverseStepStructural,
+        value: "from",
+        position: fromToSides.from.side,
+        gapFromOffset
+    }, trackedTransaction);
+    addStructureMark(suggestionId, fromToSides.to.pos, {
+        type: "replaceAround",
+        slice,
+        insert,
+        structure: isInverseStepStructural,
+        value: "to",
+        position: fromToSides.to.side,
+        gapToOffset
+    }, trackedTransaction);
+    return true;
+}
+function handleReplaceStep(trackedTransaction, step, prevSteps, suggestionId) {
+    const isStructureStep = step.structure || !contentBetween(trackedTransaction.doc, step.from, step.to);
+    if (!isStructureStep) return false;
+    // handle this step as structure step
+    console.groupCollapsed(`handle structure Replace step from = ${step.from.toString()}, to = ${step.to.toString()}`);
+    const rebasedStep = rebaseStep(step, prevSteps, trackedTransaction.steps);
+    if (!rebasedStep || !(rebasedStep instanceof ReplaceStep)) {
+        throw new Error("Failed to rebase replace step: unexpected step type");
+    }
+    const transform = new Transform(trackedTransaction.doc);
+    const $stepFromBefore = trackedTransaction.doc.resolve(rebasedStep.from);
+    const $stepToBefore = trackedTransaction.doc.resolve(rebasedStep.to);
+    console.log({
+        $stepFromBefore,
+        $stepToBefore
+    });
+    transform.step(rebasedStep);
+    const $stepFromAfter = transform.doc.resolve(transform.mapping.map($stepFromBefore.pos));
+    const $stepToAfter = transform.doc.resolve(transform.mapping.map($stepToBefore.pos));
+    console.log({
+        $stepFromAfter,
+        $stepToAfter
+    });
+    // detect join inside textblock so we can bail out
+    // those are not handled with structure marks, those are handled with a ZWSP deletion mark
+    if (!$stepFromBefore.sameParent($stepToBefore) && $stepFromAfter.sameParent($stepToAfter) && $stepFromAfter.pos === $stepToAfter.pos && $stepFromAfter.parent.isTextblock) {
+        console.log("this is a join inside textblock");
+        console.groupEnd();
+        return false;
+    }
+    if (!$stepFromBefore.sameParent($stepToBefore) && $stepFromAfter.sameParent($stepToAfter) && $stepFromAfter.pos === $stepToAfter.pos && !$stepFromAfter.parent.isTextblock) {
+        console.log("this is a join inside non-textblock");
+    }
+    const docBeforeStep = trackedTransaction.doc;
+    trackedTransaction.step(rebasedStep);
+    const inverseStep = rebasedStep.invert(docBeforeStep);
+    if (!(inverseStep instanceof ReplaceStep)) {
+        throw new Error("Failed to invert replace step: unexpected step type");
+    }
+    const inverseFrom = inverseStep.from;
+    const inverseTo = inverseStep.to;
+    const $inverseFrom = trackedTransaction.doc.resolve(inverseFrom);
+    const $inverseTo = trackedTransaction.doc.resolve(inverseTo);
+    const inverseBlockRange = $inverseFrom.blockRange($inverseTo);
+    if (!inverseBlockRange) {
+        throw new Error("Failed to get inverse block range: unexpected range");
+    }
+    const slice = inverseStep.slice;
+    const isInverseStepStructural = inverseStep.structure || !contentBetween(trackedTransaction.doc, inverseFrom, inverseTo);
+    const fromToSides = findMatchingNodeSides(trackedTransaction.doc, inverseBlockRange, {
+        from: inverseFrom,
+        to: inverseTo
+    });
+    addStructureMark(suggestionId, fromToSides.from.pos, {
+        type: "replace",
+        slice,
+        structure: isInverseStepStructural,
+        value: "from",
+        position: fromToSides.from.side
+    }, trackedTransaction);
+    addStructureMark(suggestionId, fromToSides.to.pos, {
+        type: "replace",
+        slice,
+        structure: isInverseStepStructural,
+        value: "to",
+        position: fromToSides.to.side
+    }, trackedTransaction);
+    return true;
+}