@magic-marker/prosemirror-suggest-changes 0.4.0 → 0.4.1-wrap-unwrap.2

package/dist/features/wrapUnwrap/structureChangesPlugin.js

@@ -0,0 +1,299 @@
+import { Plugin, PluginKey } from "prosemirror-state";
+import { getSuggestionMarks } from "../../utils.js";
+import { generateNextNumberId } from "../../generateId.js";
+import { getNodeId } from "./getNodeId.js";
+import { guardStructureMarkAttrs } from "./types.js";
+import { DOC_NODE_ID, STRUCTURE_CHANGES_ADD_MARKS } from "./constants.js";
+import { Transform } from "prosemirror-transform";
+import { isSuggestChangesEnabled, suggestChangesKey } from "../../plugin.js";
+import { buildMaterializedPaths } from "./buildMaterializedPaths.js";
+import { sameParentChain } from "./sameParentChain.js";
+const TRACE_ENABLED = false;
+function trace(...args) {
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (!TRACE_ENABLED) return;
+    console.log("[structureChanges]", ...args);
+}
+export const structureChangesKey = new PluginKey("@handlewithcare/prosemirror-suggest-changes-structure-changes");
+export function structureChangesPlugin(generateId, opts) {
+    const structuralContextPaths = getRequiredStructuralContextPaths(opts?.experimental_trackStructures);
+    return new Plugin({
+        key: structureChangesKey,
+        appendTransaction (transactions, _oldState, newState) {
+            if (transactions.some((tr)=>!isEnabled(tr, newState))) {
+                console.warn("structureChangesPlugin", "tracking changes is disabled, skipping structure changes plugin", [
+                    ...transactions
+                ]);
+                return;
+            }
+            // do nothing if doc hasn't changed
+            const docChanged = transactions.some((transaction)=>transaction.docChanged);
+            if (!docChanged) {
+                console.warn("structureChangesPlugin", "doc not changed, skipping", [
+                    ...transactions
+                ]);
+                return;
+            }
+            const firstTr = transactions[0];
+            const lastTr = transactions[transactions.length - 1];
+            const oldDoc = firstTr?.docs[0];
+            const newDoc = lastTr?.doc;
+            // do nothing if there isn't a pair of docs to compare
+            if (!oldDoc || !newDoc) {
+                console.warn("structureChangesPlugin", "old or new doc is missing, skipping", {
+                    oldDoc,
+                    newDoc,
+                    transactions: [
+                        ...transactions
+                    ]
+                });
+                return;
+            }
+            let idsSettled = true;
+            newDoc.descendants((node, pos)=>{
+                if (node.isText) return true;
+                const nodeId = getNodeId(node);
+                if (nodeId == null) {
+                    console.warn("structureChangesPlugin", "node", node.type.name, "at pos", pos, "is missing a unique id", {
+                        id: node.attrs["id"]
+                    });
+                    idsSettled = false;
+                    return true;
+                }
+                return true;
+            });
+            oldDoc.descendants((node, pos)=>{
+                if (node.isText) return true;
+                const nodeId = getNodeId(node);
+                if (nodeId == null) {
+                    console.warn("structureChangesPlugin", "node", node.type.name, "at pos", pos, "is missing a unique id", {
+                        id: node.attrs["id"]
+                    });
+                    idsSettled = false;
+                    return true;
+                }
+                return true;
+            });
+            // do nothing if some nodes are missing unique ids - the diff is not possible then
+            if (!idsSettled) {
+                console.warn("structureChangesPlugin", "ids not settled, skipping", {
+                    oldDoc,
+                    newDoc,
+                    transactions: [
+                        ...transactions
+                    ]
+                });
+                return;
+            }
+            trace("structureChangesPlugin", "appendTransaction", [
+                ...transactions
+            ]);
+            const { transform } = suggestStructureChanges(oldDoc, newDoc, structuralContextPaths, generateId);
+            const tr = newState.tr;
+            transform.steps.forEach((step)=>{
+                tr.step(step);
+            });
+            if (!tr.steps.length) return;
+            tr.setMeta(structureChangesKey, STRUCTURE_CHANGES_ADD_MARKS);
+            return tr;
+        }
+    });
+}
+function isEnabled(tr, editorState) {
+    const ySyncMeta = tr.getMeta("y-sync$") ?? {};
+    const isEnabled = isSuggestChangesEnabled(editorState) && !tr.getMeta("history$") && !tr.getMeta("collab$") && !ySyncMeta.isUndoRedoOperation && !ySyncMeta.isChangeOrigin && !("skip" in (tr.getMeta(suggestChangesKey) ?? {}));
+    return isEnabled;
+}
+export function suggestStructureChanges(docBefore, docAfter, structuralContextPaths, generateId) {
+    const suggestionId = generateId ? generateId(docBefore.type.schema, docBefore) : generateNextNumberId(docBefore.type.schema, docBefore);
+    const pathsBefore = buildMaterializedPaths(docBefore);
+    const pathsAfter = buildMaterializedPaths(docAfter);
+    trace("suggestStructureChanges", "materialized paths", {
+        pathsBefore: Object.fromEntries(pathsBefore.entries()),
+        pathsAfter: Object.fromEntries(pathsAfter.entries())
+    });
+    const { ops, reason } = getOps(pathsBefore, pathsAfter, structuralContextPaths);
+    trace("suggestStructureChanges", "ops", {
+        ops: Object.fromEntries(ops.entries()),
+        reason
+    });
+    const transform = new Transform(docAfter);
+    if (reason) {
+        return {
+            handled: false,
+            transform,
+            reason
+        };
+    }
+    addMarks(ops, transform, suggestionId);
+    return {
+        handled: ops.size > 0,
+        transform
+    };
+}
+export function getRequiredStructuralContextPaths(structuralContextPaths) {
+    if (!structuralContextPaths?.length) {
+        throw new Error("experimental_trackStructures must be provided when structure tracking is enabled");
+    }
+    return structuralContextPaths;
+}
+function addMarks(ops, tr, suggestionId) {
+    const perfAddMarks = performance.now();
+    const { structure } = getSuggestionMarks(tr.doc.type.schema);
+    tr.doc.descendants((node, pos)=>{
+        if (node.isText) return true;
+        const nodeId = getNodeId(node);
+        if (nodeId == null) return true;
+        const op = ops.get(nodeId);
+        if (op == null) return true;
+        if (op.op === "move") {
+            if (hasStructureAddMark(node)) return true;
+            const inverseMoveMark = findInverseStructureMoveMark(node, op);
+            if (inverseMoveMark) {
+                tr.removeNodeMark(pos, inverseMoveMark);
+                return true;
+            }
+        }
+        tr.addNodeMark(pos, structure.create({
+            id: suggestionId,
+            data: {
+                op
+            }
+        }));
+        return true;
+    });
+    trace("perf", "addMarks", "took", Number((performance.now() - perfAddMarks).toFixed(2)), "ms");
+}
+function findInverseStructureMoveMark(node, op) {
+    const { structure } = getSuggestionMarks(node.type.schema);
+    return node.marks.find((mark)=>{
+        if (mark.type !== structure) return false;
+        if (!guardStructureMarkAttrs(mark.attrs)) return false;
+        const existingOp = mark.attrs.data.op;
+        if (existingOp.op !== "move") return false;
+        return sameParentChain(existingOp.from, op.to) && sameParentChain(existingOp.to, op.from);
+    });
+}
+function hasStructureAddMark(node) {
+    const { structure } = getSuggestionMarks(node.type.schema);
+    return node.marks.some((mark)=>{
+        if (mark.type !== structure) return false;
+        if (!guardStructureMarkAttrs(mark.attrs)) return false;
+        return mark.attrs.data.op.op === "add";
+    });
+}
+function getOps(beforePaths, afterPaths, structuralContextPaths) {
+    const ops = new Map();
+    const contextNodeTypes = getStructuralContextNodeTypes(structuralContextPaths);
+    // first take care of nodes that exist in both
+    for (const [id, beforePath] of beforePaths){
+        if (contextNodeTypes.has(beforePath.nodeType)) continue;
+        const afterPath = afterPaths.get(id);
+        // node was removed - do nothing
+        if (afterPath == null) continue;
+        if (contextNodeTypes.has(afterPath.nodeType)) continue;
+        const sameChain = sameParentChain(beforePath.chain, afterPath.chain);
+        // node did not move anywhere - do nothing
+        if (sameChain) continue;
+        const hasStructuralContext = chainHasStructuralContext(beforePath.chain, structuralContextPaths) || chainHasStructuralContext(afterPath.chain, structuralContextPaths);
+        // node is outside configured structural contexts
+        if (!hasStructuralContext) continue;
+        const op = {
+            op: "move",
+            from: beforePath.chain,
+            to: afterPath.chain
+        };
+        ops.set(id, op);
+    }
+    // now take care of nodes that exist only in afterPaths
+    // (we don't care about nodes that exist only in beforePaths - they were deleted)
+    for (const [id, afterPath] of afterPaths){
+        if (contextNodeTypes.has(afterPath.nodeType)) continue;
+        // ignore nodes that also exist in beforePaths - they are already handled
+        if (beforePaths.has(id)) continue;
+        const hasStructuralContext = chainHasStructuralContext(afterPath.chain, structuralContextPaths);
+        // node is outside configured structural contexts
+        if (!hasStructuralContext) continue;
+        // detect block split - if detected, bail out, and let the main plugin handle it
+        if (isSplitDerivedAdd(id, beforePaths, afterPaths, contextNodeTypes)) {
+            return {
+                ops: new Map(),
+                reason: "split-derived-add"
+            };
+        }
+        // node was added
+        const op = {
+            op: "add"
+        };
+        ops.set(id, op);
+    }
+    return {
+        ops
+    };
+}
+function getStructuralContextNodeTypes(structuralContextPaths) {
+    return new Set(structuralContextPaths.flat());
+}
+function chainHasStructuralContext(chain, structuralContextPaths) {
+    const topDownChain = [
+        ...chain
+    ].reverse().filter((parent)=>parent.nodeType !== DOC_NODE_ID).map((parent)=>parent.nodeType);
+    return structuralContextPaths.some((path)=>containsContiguousPath(topDownChain, path));
+}
+// does a chain like: nodeTypeA->nodeTypeB->nodeTypeC
+// end with a structural context path like nodeTypeB->nodeTypeC ?
+function containsContiguousPath(chainNodeTypes, structuralContextPath) {
+    if (structuralContextPath.length > chainNodeTypes.length) return false;
+    let structuralPathPointer = structuralContextPath.length - 1;
+    let chainPointer = chainNodeTypes.length - 1;
+    while(structuralPathPointer >= 0){
+        if (structuralContextPath[structuralPathPointer] !== chainNodeTypes[chainPointer]) {
+            return false;
+        }
+        structuralPathPointer--;
+        chainPointer--;
+    }
+    return true;
+}
+// detect block split - try to look at the node above, concatenate two text contents,
+// and see if it combines into a single node in the old document
+function isSplitDerivedAdd(newNodeId, beforePaths, afterPaths, contextNodeTypes) {
+    const newNode = afterPaths.get(newNodeId)?.node;
+    if (!newNode || newNode.textContent === "") return false;
+    if (matchesSplitDerivedPair(newNodeId, newNode.textContent, beforePaths, afterPaths)) {
+        return true;
+    }
+    const afterPath = afterPaths.get(newNodeId);
+    if (!afterPath) return false;
+    for (const parent of afterPath.chain){
+        if (parent.nodeType === DOC_NODE_ID) continue;
+        if (!contextNodeTypes.has(parent.nodeType)) continue;
+        const parentNode = afterPaths.get(parent.nodeId)?.node;
+        if (!parentNode || parentNode.textContent === "") continue;
+        if (matchesSplitDerivedPair(parent.nodeId, parentNode.textContent, beforePaths, afterPaths)) {
+            return true;
+        }
+    }
+    return false;
+}
+function matchesSplitDerivedPair(rightNodeId, rightText, beforePaths, afterPaths) {
+    const rightPath = afterPaths.get(rightNodeId);
+    const previousSiblingId = rightPath?.chain[0]?.childSiblingIds[0];
+    if (!previousSiblingId) return false;
+    const previousBefore = beforePaths.has(previousSiblingId) ? beforePaths.get(previousSiblingId)?.node : null;
+    const previousAfter = afterPaths.has(previousSiblingId) ? afterPaths.get(previousSiblingId)?.node : null;
+    if (!previousBefore || !previousAfter) return false;
+    if (hasStructureAddMarkInSubtree(previousBefore)) return false;
+    return previousBefore.textContent === previousAfter.textContent + rightText;
+}
+function hasStructureAddMarkInSubtree(node) {
+    if (hasStructureAddMark(node)) return true;
+    let found = false;
+    node.descendants((descendant)=>{
+        if (descendant.isText) return false;
+        if (!hasStructureAddMark(descendant)) return true;
+        found = true;
+        return false;
+    });
+    return found;
+}

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

@@ -0,0 +1,54 @@
+import { type Attrs, type Node } from "prosemirror-model";
+import { type SuggestionId } from "../../generateId.js";
+import { DOC_NODE_ID } from "./constants.js";
+interface NodeParent {
+    nodeId: string;
+    nodeType: string;
+    nodeAttrs: object;
+    nodeMarks: object[];
+    childSiblingIds: [string | null, string | null];
+    childIndex: number;
+}
+interface StructureMoveMarkAttrs {
+    id: SuggestionId;
+    data: {
+        op: MoveOp;
+    };
+}
+interface StructureAddMarkAttrs {
+    id: SuggestionId;
+    data: {
+        op: AddOp;
+    };
+}
+export type StructureMarkAttrs = StructureMoveMarkAttrs | StructureAddMarkAttrs;
+export type StructuralContextPath = readonly [string, ...string[]];
+export interface DocParent extends Omit<NodeParent, "nodeId"> {
+    nodeId: typeof DOC_NODE_ID;
+    nodeType: typeof DOC_NODE_ID;
+}
+export type Parent = NodeParent | DocParent;
+export interface MoveOp {
+    op: "move";
+    from: Parent[];
+    to: Parent[];
+}
+export interface AddOp {
+    op: "add";
+}
+export type Op = MoveOp | AddOp;
+export type MaterializedPaths = Map<string, {
+    chain: Parent[];
+    nodeType: string;
+    node: Node;
+}>;
+export declare function guardDocParent(parent: Parent | undefined): parent is DocParent;
+export declare function guardStructureMarkAttrs(attrs: Attrs): attrs is StructureMarkAttrs;
+export declare function guardStructureMoveMarkAttrs(attrs: Attrs): attrs is StructureMoveMarkAttrs;
+export declare function guardStructureAddMarkAttrs(attrs: Attrs): attrs is StructureAddMarkAttrs;
+export interface StructureMarkObject {
+    type: "structure";
+    attrs: StructureMarkAttrs;
+}
+export declare function guardStructureMarkObject(mark: unknown): mark is StructureMarkObject;
+export {};

package/dist/features/wrapUnwrap/types.js

@@ -0,0 +1,23 @@
+import { DOC_NODE_ID } from "./constants.js";
+export function guardDocParent(parent) {
+    return parent != null && parent.nodeId === DOC_NODE_ID && parent.nodeType === DOC_NODE_ID;
+}
+export function guardStructureMarkAttrs(attrs) {
+    if (!("data" in attrs)) return false;
+    const data = attrs["data"];
+    if (data === null || typeof data !== "object") return false;
+    if (!("op" in data)) return false;
+    return true;
+}
+export function guardStructureMoveMarkAttrs(attrs) {
+    return guardStructureMarkAttrs(attrs) && attrs.data.op.op === "move";
+}
+export function guardStructureAddMarkAttrs(attrs) {
+    return guardStructureMarkAttrs(attrs) && attrs.data.op.op === "add";
+}
+export function guardStructureMarkObject(mark) {
+    if (mark === null || typeof mark !== "object") return false;
+    if (!("type" in mark) || mark.type !== "structure") return false;
+    if (!("attrs" in mark)) return false;
+    return guardStructureMarkAttrs(mark.attrs);
+}

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

@@ -0,0 +1,17 @@
+import { type Node } from "prosemirror-model";
+import { Plugin, PluginKey, type Transaction } from "prosemirror-state";
+import { Transform } from "prosemirror-transform";
+export declare const uniqueNodeIdsPluginKey: PluginKey<{
+    completedInitialRun: boolean;
+}>;
+export declare const UNIQUE_NODE_IDS_PLUGIN_META = "unique-node-ids-plugin";
+export declare function uniqueNodeIdsPlugin({ attributeName, generateID, }: {
+    attributeName: string;
+    generateID: () => string;
+}): Plugin<{
+    completedInitialRun: boolean;
+}>;
+export declare function ensureUniqueNodeIds(_transactions: Transaction[], _oldDoc: Node, newDoc: Node, options: {
+    attributeName: string;
+    generateID: () => string;
+}): Transform;

package/dist/features/wrapUnwrap/uniqueNodeIdsPlugin.js

@@ -0,0 +1,106 @@
+import { Plugin, PluginKey } from "prosemirror-state";
+import { getNodeId } from "./getNodeId.js";
+import { Transform } from "prosemirror-transform";
+// unique ids plugin
+// https://discuss.prosemirror.net/t/how-to-avoid-copying-attributes-to-new-paragraph/4568/2
+// (also checks and fix duplicates that inevitably appear)
+export const uniqueNodeIdsPluginKey = new PluginKey("@handlewithcare/prosemirror-suggest-changes-unique-node-ids");
+export const UNIQUE_NODE_IDS_PLUGIN_META = "unique-node-ids-plugin";
+const TRACE_ENABLED = false;
+function trace(...args) {
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (!TRACE_ENABLED) return;
+    console.log("[uniqueNodeIdsPlugin]", ...args);
+}
+export function uniqueNodeIdsPlugin({ attributeName, generateID }) {
+    return new Plugin({
+        key: uniqueNodeIdsPluginKey,
+        appendTransaction (transactions, oldState, newState) {
+            trace("appendTransaction");
+            const pluginState = uniqueNodeIdsPluginKey.getState(newState);
+            // do nothing if doc hasn't changed (but make sure it runs initially)
+            const docChanged = transactions.some((transaction)=>transaction.docChanged);
+            if (!docChanged && pluginState?.completedInitialRun) {
+                trace("doc not changed, skipping", [
+                    ...transactions
+                ]);
+                return;
+            }
+            trace("appendTransaction", [
+                ...transactions
+            ]);
+            const tr = newState.tr;
+            const transform = ensureUniqueNodeIds(transactions, oldState.doc, newState.doc, {
+                attributeName,
+                generateID
+            });
+            transform.steps.forEach((step)=>{
+                tr.step(step);
+            });
+            trace("tr steps", tr.steps);
+            if (!tr.steps.length) return;
+            tr.setMeta(uniqueNodeIdsPluginKey, UNIQUE_NODE_IDS_PLUGIN_META);
+            return tr;
+        },
+        state: {
+            init () {
+                return {
+                    completedInitialRun: false
+                };
+            },
+            apply (tr, value) {
+                const meta = tr.getMeta(uniqueNodeIdsPluginKey);
+                if (meta === UNIQUE_NODE_IDS_PLUGIN_META && !value.completedInitialRun) {
+                    return {
+                        completedInitialRun: true
+                    };
+                }
+                return value;
+            }
+        }
+    });
+}
+export function ensureUniqueNodeIds(_transactions, _oldDoc, newDoc, options) {
+    const tr = new Transform(newDoc);
+    const nodeIds = new Set();
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (TRACE_ENABLED) console.groupCollapsed("ensureUniqueNodeIds");
+    tr.doc.descendants((node, pos)=>{
+        if (node.isText) return false;
+        const nodeId = getNodeId(node);
+        // nodeId is set and is not duplicated
+        if (nodeId != null && !nodeIds.has(nodeId)) {
+            nodeIds.add(nodeId);
+            return true;
+        }
+        // nodeId is set and it is duplicated
+        if (nodeId != null && nodeIds.has(nodeId)) {
+            const id = options.generateID();
+            nodeIds.add(id);
+            tr.setNodeMarkup(pos, node.type, {
+                ...node.attrs,
+                [options.attributeName]: id
+            }, node.marks);
+            trace("fixed duplicate id", id, "for node", node.type.name, "at pos", pos, {
+                was: nodeId,
+                is: id
+            });
+            return true;
+        }
+        // node id is not set
+        if (nodeId == null) {
+            const id = options.generateID();
+            nodeIds.add(id);
+            tr.setNodeMarkup(pos, node.type, {
+                ...node.attrs,
+                [options.attributeName]: id
+            }, node.marks);
+            trace("set unique id", id, "for node", node.type.name, "at pos", pos);
+            return true;
+        }
+        return true;
+    });
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (TRACE_ENABLED) console.groupEnd();
+    return tr;
+}

package/dist/generateId.js

@@ -1,4 +1,6 @@
 import { getSuggestionMarks } from "./utils.js";
+import { isJoinMark } from "./features/joinOnDelete/types.js";
+import { normalizeJoinNodesMetadata } from "./features/joinOnDelete/normalizeJoinNodesMetadata.js";
 export const suggestionIdValidate = "number|string";
 export function parseSuggestionId(id) {
     const parsed = parseInt(id, 10);
@@ -8,14 +10,39 @@ export function parseSuggestionId(id) {
     return parsed;
 }
 export function generateNextNumberId(schema, doc) {
-    const { deletion, insertion, modification } = getSuggestionMarks(schema);
+    const { deletion, insertion, modification, structure } = getSuggestionMarks(schema);
     // Find the highest change id in the document so far,
     // and use that as the starting point for new changes
     let suggestionId = 0;
     doc?.descendants((node)=>{
-        const mark = node.marks.find((mark)=>mark.type === insertion || mark.type === deletion || mark.type === modification);
-        if (mark) {
-            suggestionId = Math.max(suggestionId, mark.attrs["id"]);
+        // find max suggestion id across all suggestion marks and across all suggestion marks that are serialized into metadata of the join marks
+        const marks = node.marks.filter((mark)=>mark.type === insertion || mark.type === deletion || mark.type === modification || mark.type === structure);
+        const markIds = marks.map((mark)=>mark.attrs["id"]);
+        // collect suggestion ids of marks that are serialized into join marks metadata
+        const joinMarks = marks.filter((mark)=>isJoinMark(mark));
+        const joinMetadataMarkIds = [];
+        joinMarks.forEach((mark)=>{
+            const joinMetadata = normalizeJoinNodesMetadata(mark.attrs);
+            if (!joinMetadata) return;
+            joinMetadata.leftNodes.forEach((node)=>{
+                node.marks.forEach((mark)=>{
+                    if (!mark.attrs["id"]) return;
+                    joinMetadataMarkIds.push(mark.attrs["id"]);
+                });
+            });
+            joinMetadata.rightNodes.forEach((node)=>{
+                node.marks.forEach((mark)=>{
+                    if (!mark.attrs["id"]) return;
+                    joinMetadataMarkIds.push(mark.attrs["id"]);
+                });
+            });
+        });
+        const allMarkIds = [
+            ...markIds,
+            ...joinMetadataMarkIds
+        ];
+        if (allMarkIds.length > 0) {
+            suggestionId = Math.max(suggestionId, ...allMarkIds);
             return false;
         }
         return true;

package/dist/index.d.ts

@@ -1,5 +1,8 @@
-export { addSuggestionMarks, insertion, deletion, modification, hiddenDeletion, } from "./schema.js";
+export { addSuggestionMarks, insertion, deletion, modification, hiddenDeletion, structure, } from "./schema.js";
 export { selectSuggestion, revertSuggestion, revertSuggestions, applySuggestion, applySuggestions, enableSuggestChanges, disableSuggestChanges, toggleSuggestChanges, } from "./commands.js";
 export { suggestChanges, suggestChangesKey, isSuggestChangesEnabled, } from "./plugin.js";
-export { withSuggestChanges, transformToSuggestionTransaction, } from "./withSuggestChanges.js";
-export { ensureSelection as experimental_ensureSelection, ensureSelectionKey as experimental_ensureSelectionKey, isEnsureSelectionEnabled as experimental_isEnsureSelectionEnabled, } from "./ensureSelectionPlugin.js";
+export { withSuggestChanges, transformToSuggestionTransaction, suggestStructureChanges as experimental_suggestStructureChanges, } from "./withSuggestChanges.js";
+export { ensureSelection as experimental_ensureSelection, ensureSelectionKey as experimental_ensureSelectionKey, isEnsureSelectionEnabled as experimental_isEnsureSelectionEnabled, } from "./features/ensureValidSelection/ensureSelectionPlugin.js";
+export { guardStructureMarkAttrs } from "./features/wrapUnwrap/types.js";
+export type { Op as StructureOp, StructureMarkAttrs, StructuralContextPath, } from "./features/wrapUnwrap/types.js";
+export { wrappingInputRule as experimental_wrappingInputRule } from "./wrappingInputRule.js";

package/dist/index.js

@@ -1,5 +1,7 @@
-export { addSuggestionMarks, insertion, deletion, modification, hiddenDeletion } from "./schema.js";
+export { addSuggestionMarks, insertion, deletion, modification, hiddenDeletion, structure } from "./schema.js";
 export { selectSuggestion, revertSuggestion, revertSuggestions, applySuggestion, applySuggestions, enableSuggestChanges, disableSuggestChanges, toggleSuggestChanges } from "./commands.js";
 export { suggestChanges, suggestChangesKey, isSuggestChangesEnabled } from "./plugin.js";
-export { withSuggestChanges, transformToSuggestionTransaction } from "./withSuggestChanges.js";
-export { ensureSelection as experimental_ensureSelection, ensureSelectionKey as experimental_ensureSelectionKey, isEnsureSelectionEnabled as experimental_isEnsureSelectionEnabled } from "./ensureSelectionPlugin.js";
+export { withSuggestChanges, transformToSuggestionTransaction, suggestStructureChanges as experimental_suggestStructureChanges } from "./withSuggestChanges.js";
+export { ensureSelection as experimental_ensureSelection, ensureSelectionKey as experimental_ensureSelectionKey, isEnsureSelectionEnabled as experimental_isEnsureSelectionEnabled } from "./features/ensureValidSelection/ensureSelectionPlugin.js";
+export { guardStructureMarkAttrs } from "./features/wrapUnwrap/types.js";
+export { wrappingInputRule as experimental_wrappingInputRule } from "./wrappingInputRule.js";

package/dist/listInputRules.d.ts

@@ -0,0 +1,2 @@
+import { type NodeType } from "prosemirror-model";
+export declare function listInputRules(bulletListNodeType: NodeType, orderedListNodeType: NodeType): import("prosemirror-inputrules").InputRule[];

package/dist/listInputRules.js

@@ -0,0 +1,14 @@
+import { wrappingInputRule } from "./wrappingInputRule.js";
+import { ZWSP } from "./constants.js";
+export function listInputRules(bulletListNodeType, orderedListNodeType) {
+    const bulletListInputRule = wrappingInputRule(// ^ string start, [${ZWSP}\\s]* zero or more ZWSP or whitespace, ([-+*]) one of -+* , \\s one whitespace, $ end of string
+    // "u" flag treats \u as unicode code points instead of literal "u"
+    new RegExp(`^[${ZWSP}\\s]*([-+*])\\s$`, "u"), bulletListNodeType);
+    // ^ string start, [${ZWSP}\\s]* zero or more ZWSP or whitespace, ([0-9]+\\.) digit followed by dot, \\s one whitespace, $ end of string
+    // "u" flag treats \u as unicode code points instead of literal "u"
+    const orderedListInputRule = wrappingInputRule(new RegExp(`^[${ZWSP}\\s]*([0-9]+\\.)\\s$`, "u"), orderedListNodeType);
+    return [
+        bulletListInputRule,
+        orderedListInputRule
+    ];
+}

package/dist/rebaseStep.d.ts

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,11 @@
+/**
+ * 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/dist/replaceStep.d.ts

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

package/dist/replaceStep.js

@@ -5,6 +5,7 @@ import { getSuggestionMarks } from "./utils.js";
 import { joinBlocks } from "./features/joinBlocks/index.js";
 import { collapseZWSPNodes, findJoinMark, joinNodesAndMarkJoinPoints, removeZWSPDeletions } from "./features/joinOnDelete/index.js";
 import { adjustForStartToStartTextblockDeletion } from "./features/startToStartTextblockDeletion/index.js";
+// import { rebaseStep } from "./rebaseStep.js";
 /**
  * Transform a replace step into its equivalent tracked steps.
  *

package/dist/schema.d.ts

@@ -3,10 +3,11 @@ export declare const deletion: MarkSpec;
 export declare const hiddenDeletion: MarkSpec;
 export declare const insertion: MarkSpec;
 export declare const modification: MarkSpec;
+export declare const structure: MarkSpec;
 /**
  * Add the deletion, insertion, and modification marks to
  * the provided MarkSpec map.
  */
 export declare function addSuggestionMarks<Marks extends string>(marks: Record<Marks, MarkSpec>, opts?: {
     experimental_deletions?: "hidden" | "visible";
-}): Record<Marks | "deletion" | "insertion" | "modification", MarkSpec>;
+}): Record<Marks | "deletion" | "insertion" | "modification" | "structure", MarkSpec>;