@magic-marker/prosemirror-suggest-changes 0.2.1-wrap-unwrap.2 → 0.3.1

package/dist/features/wrapUnwrap/revertStructureSuggestion.js

@@ -1,368 +0,0 @@
-import { suggestChangesKey } from "../../plugin.js";
-import { getSuggestionMarks } from "../../utils.js";
-import { Slice } from "prosemirror-model";
-import { ReplaceAroundStep, ReplaceStep } from "prosemirror-transform";
-export function isStructureSuggestion(suggestionId, tr) {
-    try {
-        findStructureMarkGroupBySuggestionId(suggestionId, tr);
-        return true;
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    } catch (error) {
-        return false;
-    }
-}
-export function revertAllStructureSuggestions(doc, tr) {
-    const { structure } = getSuggestionMarks(doc.type.schema);
-    // find structure mark in the doc
-    // if found, revert it, produce a new doc
-    // find next structure mark in the new doc
-    // easier than going nodesBetween on the original doc,
-    //    and then mapping the position, figuring out if the node is present in the new doc or was deleted
-    const findStructureMark = (doc)=>{
-        let structureMark = null;
-        doc.nodesBetween(0, doc.content.size, (node)=>{
-            structureMark = structureMark ?? structure.isInSet(node.marks) ?? null;
-            return structureMark === null;
-        });
-        return structureMark;
-    };
-    let curDoc = doc;
-    let structureMark = findStructureMark(doc);
-    while(structureMark !== null){
-        const suggestionId = structureMark.attrs["id"];
-        performStructureRevert(suggestionId, tr);
-        curDoc = tr.doc;
-        structureMark = findStructureMark(curDoc);
-    }
-}
-export function revertStructureSuggestion(suggestionId) {
-    return (state, dispatch)=>{
-        const tr = state.tr;
-        performStructureRevert(suggestionId, tr);
-        if (!tr.steps.length) return false;
-        tr.setMeta(suggestChangesKey, {
-            skip: true
-        });
-        dispatch?.(tr);
-        return true;
-    };
-}
-export function applyStructureSuggestion(suggestionId) {
-    return (state, dispatch)=>{
-        const tr = state.tr;
-        performStructureRevert(suggestionId, tr, "apply");
-        if (!tr.steps.length) return false;
-        tr.setMeta(suggestChangesKey, {
-            skip: true
-        });
-        dispatch?.(tr);
-        return true;
-    };
-}
-export function revertStructureSuggestions(suggestionIds) {
-    return (state, dispatch)=>{
-        const tr = state.tr;
-        suggestionIds.forEach((suggestionId)=>{
-            performStructureRevert(suggestionId, tr);
-        });
-        if (!tr.steps.length) return false;
-        tr.setMeta(suggestChangesKey, {
-            skip: true
-        });
-        dispatch?.(tr);
-        return true;
-    };
-}
-function performStructureRevert(suggestionId, tr, direction = "revert") {
-    console.groupCollapsed(// eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-    `performStructureRevert, suggestionId = ${suggestionId}`);
-    const { structure } = getSuggestionMarks(tr.doc.type.schema);
-    // find main suggestion from and to
-    const { markFrom, markTo, markGapFrom, markGapTo } = findStructureMarkGroupBySuggestionId(suggestionId, tr);
-    const from = getPosFromMark(markFrom.mark, markFrom.pos, markFrom.node);
-    const to = getPosFromMark(markTo.mark, markTo.pos, markTo.node);
-    if (from == null || to == null) {
-        throw new Error(`Could not find all positions for suggestion`);
-    }
-    // find all other structure suggestions within from and to interval of the main suggestion
-    const structureMarkGroups = new Set();
-    structureMarkGroups.add(suggestionId);
-    if (markGapFrom != null) {
-        const gapFrom = getPosFromMark(markGapFrom.mark, markGapFrom.pos, markGapFrom.node);
-        const gapTo = getPosFromMark(markGapTo.mark, markGapTo.pos, markGapTo.node);
-        if (gapFrom == null || gapTo == null) {
-            throw new Error(`Could not find all positions for suggestion`);
-        }
-        tr.doc.nodesBetween(from, to, (node, pos)=>{
-            node.marks.forEach((mark)=>{
-                if (mark.type !== structure) return;
-                const markData = mark.attrs["data"];
-                if (!markData) return;
-                const id = mark.attrs["id"];
-                if (id === suggestionId) return;
-                const startsInGap = gapFrom <= pos && pos <= gapTo;
-                const endsInGap = gapFrom <= pos + node.nodeSize && pos + node.nodeSize <= gapTo;
-                if (startsInGap && endsInGap) {
-                    console.log("ignored mark", {
-                        node,
-                        pos,
-                        end: pos + node.nodeSize,
-                        mark
-                    }, " - starts and ends in gap", "from-gapFrom-gapTo-to", {
-                        from,
-                        gapFrom,
-                        gapTo,
-                        to
-                    });
-                    return;
-                }
-                const startsInRange = from <= pos && pos <= gapFrom || gapTo <= pos && pos <= to;
-                const endsInRange = from <= pos + node.nodeSize && pos + node.nodeSize <= gapFrom || gapTo <= pos + node.nodeSize && pos + node.nodeSize <= to;
-                if (!startsInRange && !endsInRange) {
-                    console.log("ignored mark", {
-                        node,
-                        pos,
-                        end: pos + node.nodeSize,
-                        mark
-                    }, " - does not start or end in range", "from-gapFrom-gapTo-to", {
-                        from,
-                        gapFrom,
-                        gapTo,
-                        to
-                    });
-                    return;
-                }
-                console.log("found nested structure mark", {
-                    id,
-                    node,
-                    pos,
-                    nodeStart: pos,
-                    nodeEnd: pos + node.nodeSize
-                }, "from-gapFrom-gapTo-to", {
-                    from,
-                    gapFrom,
-                    gapTo,
-                    to
-                });
-                structureMarkGroups.add(id);
-            });
-        });
-    } else {
-        tr.doc.nodesBetween(from, to, (node, pos)=>{
-            node.marks.forEach((mark)=>{
-                if (mark.type !== structure) return;
-                const markData = mark.attrs["data"];
-                if (!markData) return;
-                const id = mark.attrs["id"];
-                if (id === suggestionId) return;
-                const startsInRange = from <= pos && pos <= to;
-                const endsInRange = from <= pos + node.nodeSize && pos + node.nodeSize <= to;
-                if (!startsInRange && !endsInRange) {
-                    console.log("ignored mark", {
-                        node,
-                        pos,
-                        end: pos + node.nodeSize,
-                        mark
-                    }, " - does not start or end in range", "from-to", {
-                        from,
-                        to
-                    });
-                    return;
-                }
-                console.log("found nested structure mark", {
-                    id,
-                    node,
-                    pos,
-                    nodeStart: pos,
-                    nodeEnd: pos + node.nodeSize
-                }, "from-to", {
-                    from,
-                    to
-                });
-                structureMarkGroups.add(id);
-            });
-            return true;
-        });
-    }
-    // revert structure mark groups in decreasing order of their ids
-    const markIds = Array.from(structureMarkGroups.values()).sort((a, b)=>Number(b) - Number(a));
-    markIds.forEach((id)=>{
-        const group = findStructureMarkGroupBySuggestionId(id, tr);
-        if (direction === "apply") {
-            applyStructureMarkGroup(group, tr);
-        } else {
-            revertStructureMarkGroup(group, tr);
-        }
-    });
-    console.groupEnd();
-}
-function getPosFromMark(mark, pos, node) {
-    const markData = mark.attrs["data"];
-    if (!markData) return null;
-    if (markData.position === "start") {
-        return pos;
-    }
-    if (markData.position === "end") {
-        return pos + node.nodeSize;
-    }
-    if (markData.position === "innerStart") {
-        return pos + 1;
-    }
-    if (markData.position === "innerEnd") {
-        return pos + node.nodeSize - 1;
-    }
-    return null;
-}
-export function applyStructureMarkGroup(group, tr) {
-    console.groupCollapsed("apply structure group, id = ", group.markFrom.mark.attrs["id"]);
-    console.log({
-        group
-    });
-    if (group.type === "replace") {
-        const { markFrom, markTo } = group;
-        tr.removeNodeMark(markFrom.pos, markFrom.mark);
-        tr.removeNodeMark(markTo.pos, markTo.mark);
-        console.groupEnd();
-        return;
-    }
-    const { markFrom, markTo, markGapFrom, markGapTo } = group;
-    tr.removeNodeMark(markFrom.pos, markFrom.mark);
-    tr.removeNodeMark(markTo.pos, markTo.mark);
-    tr.removeNodeMark(markGapFrom.pos, markGapFrom.mark);
-    tr.removeNodeMark(markGapTo.pos, markGapTo.mark);
-    console.groupEnd();
-}
-function revertStructureMarkGroup(group, tr) {
-    console.groupCollapsed("revert structure group, id = ", group.markFrom.mark.attrs["id"]);
-    console.log({
-        group
-    });
-    if (group.type === "replace") {
-        const { markFrom, markTo } = group;
-        // extract positions from, to, gapFrom and gapTo from marks
-        // the positions are either the mark's start, or the mark's end
-        const from = getPosFromMark(markFrom.mark, markFrom.pos, markFrom.node);
-        const to = getPosFromMark(markTo.mark, markTo.pos, markTo.node);
-        if (from === null || to === null) {
-            throw new Error(`Could not find all positions for suggestion`);
-        }
-        // extract the rest of the data required to reconstruct the step: slice, and structure
-        // any of those 2 marks can be used for that, this data is identical in all of them
-        const mark = markFrom.mark;
-        const markData = mark.attrs["data"];
-        if (!markData) {
-            throw new Error(`Missing mark data for suggestion`);
-        }
-        const slice = markData.slice ? Slice.fromJSON(tr.doc.type.schema, markData.slice) : Slice.empty;
-        const isStepStructural = markData.structure ?? false;
-        // reconstruct the step
-        // this is the inverse step of the step that created this change
-        const step = new ReplaceStep(from, to, slice, isStepStructural);
-        console.log({
-            step
-        });
-        tr.removeNodeMark(markFrom.pos, markFrom.mark);
-        tr.removeNodeMark(markTo.pos, markTo.mark);
-        tr.step(step);
-        console.groupEnd();
-        return;
-    }
-    const { markFrom, markTo, markGapFrom, markGapTo } = group;
-    // extract positions from, to, gapFrom and gapTo from marks
-    // the positions are either the mark's start, or the mark's end
-    const from = getPosFromMark(markFrom.mark, markFrom.pos, markFrom.node);
-    const to = getPosFromMark(markTo.mark, markTo.pos, markTo.node);
-    const gapFrom = getPosFromMark(markGapFrom.mark, markGapFrom.pos, markGapFrom.node);
-    const gapTo = getPosFromMark(markGapTo.mark, markGapTo.pos, markGapTo.node);
-    if (from === null || to === null || gapFrom === null || gapTo === null) {
-        throw new Error(`Could not find all positions for suggestion`);
-    }
-    // extract the rest of the data required to reconstruct the step: insert, slice, and structure
-    // any of those 4 marks can be used for that, this data is identical in all of them
-    const mark = markGapFrom.mark;
-    const markData = mark.attrs["data"];
-    if (markData?.insert == null) {
-        throw new Error(`Missing insert for suggestion`);
-    }
-    const slice = markData.slice ? Slice.fromJSON(tr.doc.type.schema, markData.slice) : Slice.empty;
-    const insert = markData.insert;
-    const isStepStructural = markData.structure ?? false;
-    // reconstruct the step
-    // this is the inverse step of the step that created this change
-    const step = new ReplaceAroundStep(from, to, gapFrom, gapTo, slice, insert, isStepStructural);
-    console.log({
-        step
-    });
-    tr.removeNodeMark(markFrom.pos, markFrom.mark);
-    tr.removeNodeMark(markTo.pos, markTo.mark);
-    tr.removeNodeMark(markGapFrom.pos, markGapFrom.mark);
-    tr.removeNodeMark(markGapTo.pos, markGapTo.mark);
-    tr.step(step);
-    console.groupEnd();
-}
-function findStructureMarkGroupBySuggestionId(suggestionId, tr) {
-    const { structure } = getSuggestionMarks(tr.doc.type.schema);
-    let markFrom = null;
-    let markTo = null;
-    let markGapFrom = null;
-    let markGapTo = null;
-    // using suggestionId, find 4 marks: from, to, gapFrom and gapTo
-    tr.doc.nodesBetween(0, tr.doc.content.size, (node, pos)=>{
-        node.marks.forEach((mark)=>{
-            if (mark.type !== structure) return;
-            if (mark.attrs["id"] !== suggestionId) return;
-            const markData = mark.attrs["data"];
-            if (!markData) return;
-            if (markData.value === "from") {
-                markFrom = {
-                    pos,
-                    node,
-                    mark
-                };
-            }
-            if (markData.value === "to") {
-                markTo = {
-                    pos,
-                    node,
-                    mark
-                };
-            }
-            if (markData.value === "gapFrom") {
-                markGapFrom = {
-                    pos,
-                    node,
-                    mark
-                };
-            }
-            if (markData.value === "gapTo") {
-                markGapTo = {
-                    pos,
-                    node,
-                    mark
-                };
-            }
-        });
-        return markFrom == null || markTo == null || markGapFrom == null || markGapTo == null;
-    });
-    if (markFrom == null || markTo == null) {
-        throw new Error(`Could not find all marks for suggestion id ${suggestionId}`);
-    }
-    const type = markFrom.mark.attrs["data"]?.type;
-    if (type === "replace") {
-        return {
-            type: "replace",
-            markFrom,
-            markTo
-        };
-    }
-    if (markGapFrom == null || markGapTo == null) {
-        throw new Error(`Could not find all gap marks for replace around suggestion id ${suggestionId}`);
-    }
-    return {
-        type: "replaceAround",
-        markFrom,
-        markTo,
-        markGapFrom,
-        markGapTo
-    };
-}

package/dist/rebaseStep.d.ts

@@ -1,9 +0,0 @@
-import { type Step } from "prosemirror-transform";
-/**
- * Rebase a step onto a new lineage of steps
- *
- * @param step The step to rebase
- * @param back The old steps to undo, in the order they were originally applied
- * @param forth The new steps to map through
- */
-export declare function rebaseStep(step: Step, back: Step[], forth: Step[]): Step | null;

package/dist/rebaseStep.js

@@ -1,11 +0,0 @@
-/**
- * Rebase a step onto a new lineage of steps
- *
- * @param step The step to rebase
- * @param back The old steps to undo, in the order they were originally applied
- * @param forth The new steps to map through
- */ export function rebaseStep(step, back, forth) {
-    const reset = back.slice().reverse().reduce((acc, step)=>acc?.map(step.getMap().invert()) ?? null, step);
-    const rebased = forth.reduce((acc, step)=>acc?.map(step.getMap()) ?? null, reset);
-    return rebased;
-}

package/src/features/wrapUnwrap/README.md

@@ -1,198 +0,0 @@
-# Structure Suggestion Tracking & Reversal
-
-## Purpose
-
-Track structural changes (wrap/unwrap in blockquotes, list item lift/sink) in
-ProseMirror as "suggestions" that can be reverted later, without losing the
-ability to reconstruct the original document state.
-
----
-
-## Why Marks on Nodes?
-
-**The Problem**: Document positions are ephemeral. A position like `from: 10`
-becomes invalid after any edit before it.
-
-**The Solution**: Anchor positions to **actual nodes** in the document using
-marks. To recover a position:
-
-1. Find the marked node (which moves with document edits)
-2. Compute position from node's current `pos` + the `position` attribute:
-   - `position: "start"` → use `pos`
-   - `position: "end"` → use `pos + node.nodeSize`
-
-This way, positions are **self-healing** — they remain valid as long as the
-marked nodes exist.
-
-**Why "start" vs "end"?** Because the 4 positions of a `ReplaceAroundStep` don't
-always align with node boundaries in the same way. The mark must be placed on a
-node that **exists in the final document**, and the position must be derivable
-from that node's boundaries.
-
----
-
-## Mark Structure
-
-### For `ReplaceAroundStep` (4 marks)
-
-Each mark contains:
-
-| Field       | Purpose                                                 |
-| ----------- | ------------------------------------------------------- |
-| `id`        | Suggestion ID (groups marks together)                   |
-| `value`     | `"from"` \| `"to"` \| `"gapFrom"` \| `"gapTo"`          |
-| `position`  | `"start"` \| `"end"` (how to derive position from node) |
-| `type`      | `"replaceAround"`                                       |
-| `slice`     | JSON of the slice for the **inverse** step              |
-| `insert`    | Where gap content goes in the slice                     |
-| `structure` | Boolean flag for structural step                        |
-
-### For `ReplaceStep` (2 marks)
-
-Only `from` and `to` marks are needed (no gap positions).
-
-| Field       | Purpose                                    |
-| ----------- | ------------------------------------------ |
-| `id`        | Suggestion ID                              |
-| `value`     | `"from"` \| `"to"`                         |
-| `position`  | `"start"` \| `"end"`                       |
-| `type`      | `"replace"`                                |
-| `slice`     | JSON of the slice for the **inverse** step |
-| `structure` | Boolean flag                               |
-
-### Mark Nesting
-
-Marks are nested around content in the document:
-
-```javascript
-doc(
-  structure[from, position:start](
-    structure[to, position:end](
-      blockquote(
-        structure[gapFrom, position:start](
-          structure[gapTo, position:end](
-            paragraph("Hello World")
-          ))))))
-```
-
-When traversing with `nodesBetween`, we find each marked node and compute
-positions from it.
-
----
-
-## How Reversal Works
-
-The `revertStructureSuggestion(suggestionId)` command:
-
-```
-1. FIND the main suggestion's marks
-   └── findStructureMarkGroupBySuggestionId(suggestionId)
-       └── Scan document for marks with matching ID
-       └── Collect: markFrom, markTo, [markGapFrom, markGapTo]
-
-2. FIND nested suggestions within the range
-   └── nodesBetween(from, to) to find all structure marks
-   └── Collect all unique suggestion IDs
-
-3. SORT by decreasing ID (revert newest first)
-   └── [3, 2, 1] — important for nested changes!
-
-4. For EACH suggestion, REVERT:
-   └── Compute positions: getPosFromMark(mark, pos, node)
-   └── Deserialize slice from JSON
-   └── Reconstruct inverse step:
-       - ReplaceAroundStep(from, to, gapFrom, gapTo, slice, insert, structure)
-       - or ReplaceStep(from, to, slice, structure)
-   └── Remove the marks
-   └── Apply the step
-```
-
-**Why reverse order?** If step 1 created structure A, and step 2 modified within
-A, you must undo step 2 before step 1, otherwise positions break.
-
----
-
-## How Tests Work
-
-Each test file has 3 data structures:
-
-```typescript
-// 1. Initial document state (before any changes)
-const initialState = doc(paragraph("Hello World"));
-
-// 2. Final state (after applying steps, NO marks)
-const finalState = doc(blockquote(paragraph("Hello World")));
-
-// 3. Final state WITH structure marks embedded
-//    (manually constructed to simulate what forward tracking would produce)
-const finalStateWithMarks = doc(
-  structure({ id: 1, data: { value: "from", position: "start", ... } },
-    structure({ id: 1, data: { value: "to", position: "end", ... } },
-      blockquote(
-        structure({ id: 1, data: { value: "gapFrom", ... } },
-          structure({ id: 1, data: { value: "gapTo", ... } },
-            paragraph("Hello World")
-          )))))
-);
-
-// The steps that transform initial → final
-const steps = [{ stepType: "replaceAround", from: 0, to: 13, ... }];
-
-// The inverse steps that transform final → initial
-const inverseSteps = [{ stepType: "replaceAround", from: 0, to: 15, ... }];
-```
-
-Three test cases per scenario:
-
-```typescript
-// Test 1: Forward transformation works
-it("applies steps correctly", () => {
-  assertDocumentChanged(initialState, finalState, applySteps(steps));
-});
-
-// Test 2: Inverse steps work (sanity check)
-it("applies inverse steps correctly", () => {
-  assertDocumentChanged(
-    finalState,
-    initialState,
-    applySteps(inverseSteps.reverse()),
-  );
-});
-
-// Test 3: THE MAIN TEST - revert from marks works
-it("reverts via structure suggestion", () => {
-  assertDocumentChanged(
-    finalStateWithMarks,
-    initialState,
-    revertStructureSuggestion(1),
-  );
-});
-```
-
----
-
-## What's Missing: Forward Tracking
-
-The code that would:
-
-1. Intercept `ReplaceAroundStep` / `ReplaceStep` in suggest-changes mode
-2. Apply the step to get the new document
-3. Compute the inverse step
-4. Place structure marks on appropriate nodes with:
-   - Position encoding (which node, start vs end)
-   - Inverse step data (slice, insert, structure flag)
-
-Currently `suggestReplaceAroundStep` in `replaceAroundStep.ts` converts
-structural operations to `ReplaceStep` and uses insertion/deletion marks
-instead, losing the structural information needed for proper reversal.
-
----
-
-## Additional Notes
-
-### Offset Fields
-
-The marks contain offset fields (`gapFromOffset`, `fromOffset`, `toOffset`,
-`gapToOffset`) and a `debug` object with computed inverse positions. These are
-present in test data but **not currently used** by the revert code — positions
-are computed purely from node position + `position` field.