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

package/dist/features/wrapUnwrap/revert/revertStructureSuggestions.js

@@ -1,236 +0,0 @@
-import { getSuggestionMarks } from "../../../utils.js";
-import { getNodeId } from "../getNodeId.js";
-import { Transform } from "prosemirror-transform";
-import { guardStructureMarkAttrs } from "../types.js";
-import { sameParentChain } from "../sameParentChain.js";
-import { buildMaterializedPaths } from "../buildMaterializedPaths.js";
-import { revertAddOp } from "./revertAddOp.js";
-import { revertMoveOp } from "./revertMoveOp.js";
-const TRACE_ENABLED = false;
-function trace(...args) {
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-    if (!TRACE_ENABLED) return;
-    console.log("[revertStructureSuggestions]", ...args);
-}
-export function revertStructureSuggestionsInDoc({ tr, suggestionId, from, to }) {
-    if (suggestionId) {
-        // when suggestionId is given, just revert it, no other logic required
-        revertStructureSuggestionWithPrerequisites(tr, suggestionId);
-        return;
-    }
-    if (from || to) {
-        // when range is given, find suggestion ids inside that range,
-        // but make sure to revert furthermost suggestions first
-        // todo: most likely a better strategy would be to search for the next suggestion in the updated doc after each reversal (and map from and to)
-        const { structure } = getSuggestionMarks(tr.doc.type.schema);
-        const structureMarks = [];
-        tr.doc.descendants((node, pos)=>{
-            if (from !== undefined && pos < from) {
-                return true;
-            }
-            if (to !== undefined && pos > to) {
-                return false;
-            }
-            if (node.isText) return true;
-            if (!structure.isInSet(node.marks)) return true;
-            node.marks.forEach((mark)=>{
-                if (mark.type !== structure) return;
-                structureMarks.push({
-                    mark,
-                    node,
-                    pos
-                });
-            });
-            return true;
-        });
-        structureMarks.sort((a, b)=>b.pos - a.pos);
-        const suggestionIds = new Set();
-        structureMarks.forEach(({ mark })=>{
-            suggestionIds.add(mark.attrs["id"]);
-        });
-        for (const suggestionId of suggestionIds){
-            revertStructureSuggestionWithPrerequisites(tr, suggestionId);
-        }
-        return;
-    }
-    // if no suggestion id nor range is given, revert all suggestions one by one, always take furthermost first
-    // after each reversal, the next suggestion is searched in the new doc after the previous reversal
-    let nextSuggestionId = findNextStructureSuggestion(tr.doc);
-    while(nextSuggestionId != null){
-        revertStructureSuggestionWithPrerequisites(tr, nextSuggestionId);
-        nextSuggestionId = findNextStructureSuggestion(tr.doc);
-    }
-}
-function revertStructureSuggestionWithPrerequisites(tr, suggestionId) {
-    const suggestionIds = buildOrderedSuggestionIds(tr.doc, suggestionId, buildMaterializedPaths(tr.doc));
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-    if (TRACE_ENABLED) console.group("reverting structure suggestions", suggestionIds);
-    for (const suggestionId of suggestionIds){
-        revertOneStructureSuggestion(tr, suggestionId);
-    }
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-    if (TRACE_ENABLED) console.groupEnd();
-}
-function revertOneStructureSuggestion(tr, suggestionId) {
-    let count = 0;
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-    if (TRACE_ENABLED) console.groupCollapsed("reverting structure suggestion", suggestionId);
-    let structureMark = findNextStructureMark(tr.doc, suggestionId);
-    while(structureMark !== null){
-        trace("reverting structure suggestion", suggestionId, "structure mark", structureMark.mark, "at pos", structureMark.pos, "at node", structureMark.node.toString());
-        revertStructureMark(tr, structureMark.mark, structureMark.pos);
-        structureMark = findNextStructureMark(tr.doc, suggestionId);
-        count++;
-    }
-    trace("reverted", count, "structure marks for suggestion", suggestionId);
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-    if (TRACE_ENABLED) console.groupEnd();
-}
-export function revertStructureMark(tr, mark, pos) {
-    const transform = new Transform(tr.doc);
-    transform.removeNodeMark(pos, mark);
-    const node = transform.doc.nodeAt(pos);
-    if (!node) {
-        throw new Error(`Node not found at position ${String(pos)}`);
-    }
-    const attrs = mark.attrs;
-    if (!guardStructureMarkAttrs(attrs)) {
-        console.warn("revertStructureMark", "invalid shape of structure mark attrs", {
-            attrs
-        });
-        return;
-    }
-    const op = attrs.data.op;
-    trace("reverting structure mark with suggestion id", attrs.id, "at node", node.toString(), "at pos", pos, "with op", op.op, {
-        mark,
-        node,
-        $pos: transform.doc.resolve(pos),
-        op
-    });
-    switch(op.op){
-        case "add":
-            {
-                revertAddOp(op, transform, node, pos);
-                break;
-            }
-        case "move":
-            {
-                revertMoveOp(op, transform, node, pos);
-                break;
-            }
-        default:
-            console.warn("revertStructureMark", "unknown op", {
-                op
-            });
-            break;
-    }
-    transform.steps.forEach((step)=>{
-        tr.step(step);
-    });
-}
-// given a suggestion id
-// return an array of suggestion ids to revert
-// resolve suggestion dependencies, meaning,
-// if to revert suggestion id 1 you need to revert 2, and to revert 2 you need to revert 3
-// it will return [3,2,1]
-// todo: this should probably use topological sort at some point
-function buildOrderedSuggestionIds(node, suggestionId, materializedPaths) {
-    const { structure } = getSuggestionMarks(node.type.schema);
-    // collect marks with the given suggestionId
-    const markGroup = [];
-    node.descendants((descendant, pos)=>{
-        if (descendant.isText) return true;
-        if (!structure.isInSet(descendant.marks)) return true;
-        descendant.marks.forEach((mark)=>{
-            if (mark.type !== structure) return;
-            if (mark.attrs["id"] !== suggestionId) return;
-            markGroup.push({
-                mark,
-                node: descendant,
-                pos
-            });
-        });
-        return true;
-    });
-    const suggestionIds = new Set();
-    suggestionIds.add(suggestionId);
-    // find first mark that doesn't have a matching op.to
-    const mismatch = markGroup.find((mark)=>{
-        const nodeId = getNodeId(mark.node);
-        if (nodeId == null) return false;
-        const parentChain = materializedPaths.get(nodeId);
-        if (parentChain == null) return false;
-        const { attrs } = mark.mark;
-        if (!guardStructureMarkAttrs(attrs)) return false;
-        if (attrs.data.op.op !== "move") return false;
-        return !sameParentChain(attrs.data.op.to, parentChain.chain);
-    });
-    if (mismatch == null) {
-        return Array.from(suggestionIds).reverse();
-    }
-    // find first mark on the node that does have a matching op.to
-    const match = mismatch.node.marks.find((mark)=>{
-        if (mark.type !== structure) return false;
-        const { attrs } = mark;
-        if (!guardStructureMarkAttrs(attrs)) return false;
-        if (attrs.data.op.op !== "move") return false;
-        const nodeId = getNodeId(mismatch.node);
-        if (nodeId == null) return false;
-        const parentChain = materializedPaths.get(nodeId);
-        if (parentChain == null) return false;
-        return sameParentChain(attrs.data.op.to, parentChain.chain);
-    });
-    if (match) {
-        trace("suggestion", match.attrs["id"], "is a prerequisite for suggestion", suggestionId);
-        suggestionIds.add(match.attrs["id"]);
-    }
-    return Array.from(suggestionIds).reverse();
-}
-function findNextStructureSuggestion(doc) {
-    const { structure } = getSuggestionMarks(doc.type.schema);
-    const structureMarks = [];
-    doc.descendants((node, pos)=>{
-        if (node.isText) return true;
-        if (!structure.isInSet(node.marks)) return true;
-        node.marks.forEach((mark)=>{
-            if (mark.type !== structure) return;
-            structureMarks.push({
-                mark,
-                node,
-                pos
-            });
-        });
-        return true;
-    });
-    structureMarks.sort((a, b)=>b.pos - a.pos);
-    return structureMarks[0]?.mark.attrs["id"];
-}
-// given a suggestion id, find next structure mark to revert that belongs to that suggestion
-// always take furthermost mark first
-function findNextStructureMark(node, suggestionId) {
-    const { structure } = getSuggestionMarks(node.type.schema);
-    const structureMarks = [];
-    node.descendants((descendant, pos)=>{
-        // the assumption here is that a single node cannot have multiple structure marks with the same suggestion id
-        // check the invariant
-        const suggestionIds = new Set();
-        descendant.marks.forEach((mark)=>{
-            if (mark.type !== structure) return;
-            const markSuggestionId = mark.attrs["id"];
-            if (suggestionIds.has(markSuggestionId)) {
-                console.warn("node", node, "has multiple structure marks with the same suggestion id", markSuggestionId);
-            }
-            suggestionIds.add(markSuggestionId);
-        });
-        const mark = descendant.marks.find((mark)=>mark.type === structure && mark.attrs["id"] === suggestionId);
-        if (mark == null) return true;
-        structureMarks.push({
-            mark,
-            node: descendant,
-            pos
-        });
-        return true;
-    });
-    structureMarks.sort((a, b)=>b.pos - a.pos);
-    return structureMarks[0] ?? null;
-}

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

@@ -1,2 +0,0 @@
-import { type Parent } from "./types.js";
-export declare function sameParentChain(parentChainA: Parent[], parentChainB: Parent[]): boolean;

package/dist/features/wrapUnwrap/sameParentChain.js

@@ -1,4 +0,0 @@
-export function sameParentChain(parentChainA, parentChainB) {
-    if (parentChainA.length !== parentChainB.length) return false;
-    return parentChainA.every((parent, index)=>parent.nodeId === parentChainB[index]?.nodeId);
-}

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

@@ -1,17 +0,0 @@
-import { type Schema, type Node } from "prosemirror-model";
-import { Plugin, PluginKey } from "prosemirror-state";
-import { type SuggestionId } from "../../generateId.js";
-import { type StructuralContextPath } from "./types.js";
-import { Transform } from "prosemirror-transform";
-export declare const structureChangesKey: PluginKey<any>;
-export type SuggestStructureChangesReason = "split-derived-add";
-export interface SuggestStructureChangesResult {
-    handled: boolean;
-    transform: Transform;
-    reason?: SuggestStructureChangesReason;
-}
-export declare function structureChangesPlugin(generateId?: (schema: Schema, doc?: Node) => SuggestionId, opts?: {
-    experimental_trackStructures?: StructuralContextPath[];
-}): Plugin<any>;
-export declare function suggestStructureChanges(docBefore: Node, docAfter: Node, structuralContextPaths: StructuralContextPath[], generateId?: (schema: Schema, doc?: Node) => SuggestionId): SuggestStructureChangesResult;
-export declare function getRequiredStructuralContextPaths(structuralContextPaths: StructuralContextPath[] | undefined): StructuralContextPath[];

package/dist/features/wrapUnwrap/structureChangesPlugin.js

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

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

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

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