@magic-marker/prosemirror-suggest-changes 0.3.3-wrap-unwrap.11 → 0.3.3-wrap-unwrap.13

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

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

package/dist/features/wrapUnwrap/buildMaterializedPaths.js

@@ -1,4 +1,5 @@
 import { getNodeId } from "./getNodeId.js";
+import { DOC_NODE_ID } from "./constants.js";
 const TRACE_ENABLED = true;
 function trace(...args) {
     // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
@@ -17,8 +18,8 @@ export function buildMaterializedPaths(doc) {
         const rightSibling = children[index + 1];
         const rightSiblingId = rightSibling ? getNodeId(rightSibling) : null;
         const parent = {
-            nodeId: "__doc__",
-            nodeType: "__doc__",
+            nodeId: DOC_NODE_ID,
+            nodeType: DOC_NODE_ID,
             nodeAttrs: {},
             nodeMarks: [],
             childSiblingIds: [

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

@@ -1,3 +1,3 @@
+export declare const DOC_NODE_ID = "__doc__";
 export declare const STRUCTURE_CHANGES_ADD_MARKS = "structure-changes-add-mark-type";
 export declare const STRUCTURE_CHANGES_REVERT_MARKS = "structure-changes-revert-mark-type";
-export declare const LIST_NODES: string[];

package/dist/features/wrapUnwrap/constants.js

@@ -1,7 +1,3 @@
+export const DOC_NODE_ID = "__doc__";
 export const STRUCTURE_CHANGES_ADD_MARKS = "structure-changes-add-mark-type";
 export const STRUCTURE_CHANGES_REVERT_MARKS = "structure-changes-revert-mark-type";
-export const LIST_NODES = [
-    "orderedList",
-    "bulletList",
-    "listItem"
-];

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

@@ -118,5 +118,5 @@ export function findInsertionPos(node, pos, parent, child) {
         return leftSibling.pos + leftSibling.node.nodeSize;
     }
     // insert at end of node
-    return pos != null ? pos + node.nodeSize - 1 : node.nodeSize - 1;
+    return pos != null ? pos + node.nodeSize - 1 : node.content.size;
 }

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

@@ -1,10 +1,14 @@
 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 declare function structureChangesPlugin(generateId?: (schema: Schema, doc?: Node) => SuggestionId): Plugin<any>;
-export declare function suggestStructureChanges(docBefore: Node, docAfter: Node, generateId?: (schema: Schema, doc?: Node) => SuggestionId): {
+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): {
     handled: boolean;
     transform: Transform;
 };
+export declare function getRequiredStructuralContextPaths(structuralContextPaths: StructuralContextPath[] | undefined): StructuralContextPath[];

package/dist/features/wrapUnwrap/structureChangesPlugin.js

@@ -3,7 +3,7 @@ import { getSuggestionMarks } from "../../utils.js";
 import { generateNextNumberId } from "../../generateId.js";
 import { getNodeId } from "./getNodeId.js";
 import { guardStructureMarkAttrs } from "./types.js";
-import { LIST_NODES, STRUCTURE_CHANGES_ADD_MARKS } from "./constants.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";
@@ -15,12 +15,8 @@ function trace(...args) {
     console.log("[structureChanges]", ...args);
 }
 export const structureChangesKey = new PluginKey("@handlewithcare/prosemirror-suggest-changes-structure-changes");
-// const listStructure = {
-//   type: [LIST_NODE],
-//   children: [{ type: [LIST_ITEM_NODE] }],
-// };
-// const structures = [listStructure];
-export function structureChangesPlugin(generateId) {
+export function structureChangesPlugin(generateId, opts) {
+    const structuralContextPaths = getRequiredStructuralContextPaths(opts?.experimental_trackStructures);
     return new Plugin({
         key: structureChangesKey,
         appendTransaction (transactions, _oldState, newState) {
@@ -92,7 +88,7 @@ export function structureChangesPlugin(generateId) {
             trace("structureChangesPlugin", "appendTransaction", [
                 ...transactions
             ]);
-            const { transform } = suggestStructureChanges(oldDoc, newDoc, generateId);
+            const { transform } = suggestStructureChanges(oldDoc, newDoc, structuralContextPaths, generateId);
             const tr = newState.tr;
             transform.steps.forEach((step)=>{
                 tr.step(step);
@@ -108,7 +104,7 @@ function isEnabled(tr, editorState) {
     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, generateId) {
+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);
@@ -116,7 +112,7 @@ export function suggestStructureChanges(docBefore, docAfter, generateId) {
         pathsBefore: Object.fromEntries(pathsBefore.entries()),
         pathsAfter: Object.fromEntries(pathsAfter.entries())
     });
-    const ops = getOps(pathsBefore, pathsAfter);
+    const ops = getOps(pathsBefore, pathsAfter, structuralContextPaths);
     trace("suggestStructureChanges", "ops", {
         ops: Object.fromEntries(ops.entries())
     });
@@ -127,6 +123,12 @@ export function suggestStructureChanges(docBefore, docAfter, generateId) {
         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);
@@ -136,7 +138,14 @@ function addMarks(ops, tr, suggestionId) {
         if (nodeId == null) return true;
         const op = ops.get(nodeId);
         if (op == null) return true;
-        if (op.op === "move" && hasStructureAddMark(node)) 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: {
@@ -147,6 +156,16 @@ function addMarks(ops, tr, suggestionId) {
     });
     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)=>{
@@ -155,20 +174,22 @@ function hasStructureAddMark(node) {
         return mark.attrs.data.op.op === "add";
     });
 }
-function getOps(beforePaths, afterPaths) {
+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 (LIST_NODES.includes(beforePath.nodeType)) continue;
+        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 hasList = beforePath.chain.some((parent)=>LIST_NODES.includes(parent.nodeType)) || afterPath.chain.some((parent)=>LIST_NODES.includes(parent.nodeType));
-        // node is outside lists
-        if (!hasList) 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,
@@ -179,12 +200,12 @@ function getOps(beforePaths, afterPaths) {
     // 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 (LIST_NODES.includes(afterPath.nodeType)) continue;
+        if (contextNodeTypes.has(afterPath.nodeType)) continue;
         // ignore nodes that also exist in beforePaths - they are already handled
         if (beforePaths.has(id)) continue;
-        const hasList = afterPath.chain.some((parent)=>LIST_NODES.includes(parent.nodeType));
-        // node is outside lists
-        if (!hasList) continue;
+        const hasStructuralContext = chainHasStructuralContext(afterPath.chain, structuralContextPaths);
+        // node is outside configured structural contexts
+        if (!hasStructuralContext) continue;
         // node was added
         const op = {
             op: "add"
@@ -193,3 +214,22 @@ function getOps(beforePaths, afterPaths) {
     }
     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: __doc__->nodeTypeA->nodeTypeB->nodeTypeC->nodeTypeD
+// contain a structural context path (a "sub chain") like nodeTypeB->nodeTypeC ?
+function containsContiguousPath(chainNodeTypes, structuralContextPath) {
+    if (structuralContextPath.length > chainNodeTypes.length) return false;
+    for(let start = 0; start <= chainNodeTypes.length - structuralContextPath.length; start++){
+        const matches = structuralContextPath.every((nodeType, index)=>chainNodeTypes[start + index] === nodeType);
+        if (matches) return true;
+    }
+    return false;
+}

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

@@ -1,5 +1,6 @@
 import { type Attrs } from "prosemirror-model";
 import { type SuggestionId } from "../../generateId.js";
+import { DOC_NODE_ID } from "./constants.js";
 interface NodeParent {
     nodeId: string;
     nodeType: string;
@@ -14,9 +15,10 @@ export interface StructureMarkAttrs {
         op: Op;
     };
 }
+export type StructuralContextPath = readonly [string, ...string[]];
 export interface DocParent extends Omit<NodeParent, "nodeId"> {
-    nodeId: "__doc__";
-    nodeType: "__doc__";
+    nodeId: typeof DOC_NODE_ID;
+    nodeType: typeof DOC_NODE_ID;
 }
 export type Parent = NodeParent | DocParent;
 export interface MoveOp {

package/dist/features/wrapUnwrap/types.js

@@ -1,5 +1,6 @@
+import { DOC_NODE_ID } from "./constants.js";
 export function guardDocParent(parent) {
-    return parent != null && parent.nodeId === "__doc__" && parent.nodeType === "__doc__";
+    return parent != null && parent.nodeId === DOC_NODE_ID && parent.nodeType === DOC_NODE_ID;
 }
 export function guardStructureMarkAttrs(attrs) {
     if (!("data" in attrs)) return false;

package/dist/index.d.ts

@@ -4,5 +4,5 @@ export { suggestChanges, suggestChangesKey, isSuggestChangesEnabled, } from "./p
 export { withSuggestChanges, transformToSuggestionTransaction, } from "./withSuggestChanges.js";
 export { ensureSelection as experimental_ensureSelection, ensureSelectionKey as experimental_ensureSelectionKey, isEnsureSelectionEnabled as experimental_isEnsureSelectionEnabled, } from "./ensureSelectionPlugin.js";
 export { guardStructureMarkAttrs } from "./features/wrapUnwrap/types.js";
-export type { Op as StructureOp, StructureMarkAttrs, } 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/testing/e2eTestSchema.d.ts

@@ -1,2 +1,2 @@
 import { Schema } from "prosemirror-model";
-export declare function createSchema(deletionMarksVisibility?: "hidden" | "visible"): Schema<"blockquote" | "text" | "orderedList" | "bulletList" | "listItem" | "doc" | "paragraph" | "horizontal_rule" | "heading" | "code_block" | "image" | "hard_break", "insertion" | "deletion" | "modification" | "structure" | "code" | "em" | "link" | "strong">;
+export declare function createSchema(deletionMarksVisibility?: "hidden" | "visible"): Schema<"blockquote" | "text" | "doc" | "paragraph" | "horizontal_rule" | "heading" | "code_block" | "image" | "hard_break" | "orderedList" | "bulletList" | "listItem", "insertion" | "deletion" | "modification" | "structure" | "code" | "em" | "link" | "strong">;

package/dist/testing/testBuilders.d.ts

@@ -1,6 +1,6 @@
 import { Schema, type Node } from "prosemirror-model";
 import { type MarkBuilder, type NodeBuilder } from "prosemirror-test-builder";
-export declare const schema: Schema<"blockquote" | "text" | "orderedList" | "bulletList" | "listItem" | "doc" | "paragraph" | "horizontal_rule" | "heading" | "code_block" | "image" | "hard_break", "insertion" | "deletion" | "modification" | "structure" | "code" | "em" | "link" | "strong" | "difficulty">;
+export declare const schema: Schema<"blockquote" | "text" | "doc" | "paragraph" | "horizontal_rule" | "heading" | "code_block" | "image" | "hard_break" | "orderedList" | "bulletList" | "listItem", "insertion" | "deletion" | "modification" | "structure" | "code" | "em" | "link" | "strong" | "difficulty">;
 export declare const testBuilders: { [NodeTypeName in keyof (typeof schema)["nodes"]]: NodeBuilder; } & { [MarkTypeName in keyof (typeof schema)["marks"]]: MarkBuilder; } & {
     schema: typeof schema;
 };

package/dist/withSuggestChanges.d.ts

@@ -3,6 +3,7 @@ import { type EditorState, type Transaction } from "prosemirror-state";
 import { type Transform } from "prosemirror-transform";
 import { type EditorView } from "prosemirror-view";
 import { type SuggestionId } from "./generateId.js";
+import { type StructuralContextPath } from "./features/wrapUnwrap/types.js";
 /**
  * Given a standard transaction from ProseMirror, produce
  * a new transaction that tracks the changes from the original,
@@ -27,5 +28,6 @@ export declare function transformToSuggestionTransaction(originalTransaction: Tr
  */
 export declare function withSuggestChanges(dispatchTransaction?: EditorView["dispatch"], generateId?: (schema: Schema, doc?: Node) => SuggestionId, opts?: {
     experimental_trackStructureChanges?: boolean;
+    experimental_trackStructures?: StructuralContextPath[];
     experimental_ensureUniqueNodeIds?: (transactions: Transaction[], oldDoc: Node, newDoc: Node) => Transform;
 }): EditorView["dispatch"];

package/dist/withSuggestChanges.js

@@ -10,7 +10,7 @@ import { isSuggestChangesEnabled, suggestChangesKey } from "./plugin.js";
 import { generateNextNumberId } from "./generateId.js";
 import { getSuggestionMarks } from "./utils.js";
 import { prependDeletionsWithZWSP } from "./prependDeletionsWithZWSP.js";
-import { suggestStructureChanges } from "./features/wrapUnwrap/structureChangesPlugin.js";
+import { getRequiredStructuralContextPaths, suggestStructureChanges } from "./features/wrapUnwrap/structureChangesPlugin.js";
 const TRACE_ENABLED = true;
 function trace(...args) {
     // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
@@ -121,13 +121,15 @@ function getStepHandler(step) {
         if (isEnabled) {
             let structureChangesResult = null;
             const docBefore = transaction.docs[0];
-            if (transaction.docChanged && docBefore && opts?.experimental_trackStructureChanges && typeof opts.experimental_ensureUniqueNodeIds === "function") {
+            const structuralContextPaths = opts?.experimental_trackStructureChanges ? getRequiredStructuralContextPaths(opts.experimental_trackStructures) : null;
+            const ensureUniqueNodeIds = opts?.experimental_ensureUniqueNodeIds;
+            if (transaction.docChanged && docBefore && structuralContextPaths && typeof ensureUniqueNodeIds === "function") {
                 trace("trying to track structure changes first...");
                 // after a transaction, some nodes may not yet have unique ids (they were just added, and the unique id plugin has not yet run)
                 // this hook allows to "post-process" the transaction and add the missing ids
                 // basically it allows to run the core logic of the unique ids plugin earlier
                 const perfUid = performance.now();
-                const uniqueNodeIdsTransform = opts.experimental_ensureUniqueNodeIds([
+                const uniqueNodeIdsTransform = ensureUniqueNodeIds([
                     transaction
                 ], docBefore, transaction.doc);
                 trace("perf", "structure", "ensureUniqueNodsIds took", Number((performance.now() - perfUid).toFixed(2)), "ms");
@@ -137,7 +139,7 @@ function getStepHandler(step) {
                 // if handled, then ignore the main plugin
                 // otherwise use the main plugin
                 const perfStructure = performance.now();
-                structureChangesResult = suggestStructureChanges(docBefore, docAfter, generateId);
+                structureChangesResult = suggestStructureChanges(docBefore, docAfter, structuralContextPaths, generateId);
                 trace("perf", "structure", "suggestStructureChanges took", Number((performance.now() - perfStructure).toFixed(2)), "ms");
                 trace("structure changes transform completed", structureChangesResult.transform);
                 if (structureChangesResult.handled) {

package/package.json

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