@magic-marker/prosemirror-suggest-changes 0.3.3-wrap-unwrap.1 → 0.3.3-wrap-unwrap.2

package/dist/ensureSelectionPlugin.js

@@ -48,7 +48,6 @@ export function ensureSelection() {
             }
         },
         appendTransaction (_transactions, oldState, newState) {
-            console.log("ensureSelectionPlugin.appendTransaction", newState.selection.toJSON());
             const pluginState = ensureSelectionKey.getState(newState);
             if (!(newState.selection instanceof TextSelection)) {
                 return null;

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

@@ -0,0 +1 @@
+export declare function generateUniqueNodeId(): string;

package/dist/features/wrapUnwrap/{generateNodeId.js → generateUniqueNodeId.js}

@@ -1,4 +1,4 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */ export function generateNodeId(_node, _pos, _parent, _index) {
+export function generateUniqueNodeId() {
     if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
         return crypto.randomUUID();
     }

package/dist/features/wrapUnwrap/revertStructureSuggestions.js

@@ -101,19 +101,19 @@ function applyStructureMarkGroup(tr, suggestionId) {
     });
 }
 function revertStructureMarkGroupInOrder(tr, suggestionId) {
-    console.group("reverting structure mark group", suggestionId);
+    console.group("revertStructureMarkGroupInOrder", "reverting structure mark group", suggestionId);
     const suggestionIds = findOrderedSuggestionIdsToRevert(tr.doc, suggestionId, buildMaterializedPaths(tr.doc));
-    console.log("suggestion groups to revert", suggestionIds);
+    console.log("revertStructureMarkGroupInOrder", "suggestion groups to revert", suggestionIds);
     for (const suggestionId of suggestionIds){
         revertStructureMarkGroup(tr, suggestionId);
     }
     console.groupEnd();
 }
 function revertStructureMarkGroup(tr, suggestionId) {
-    console.group("reverting structure suggestion", suggestionId);
+    console.group("revertStructureMarkGroup", "reverting structure suggestion", suggestionId);
     let structureMark = findNextStructureMark(tr.doc, suggestionId);
     while(structureMark !== null){
-        console.groupCollapsed("reverting structure mark", structureMark.mark.attrs["id"], "at pos", structureMark.pos, "at node", structureMark.node.toString(), {
+        console.groupCollapsed("revertStructureMarkGroup", "reverting structure mark", structureMark.mark.attrs["id"], "at pos", structureMark.pos, "at node", structureMark.node.toString(), {
             structureMark
         });
         revertStructureMark(tr, structureMark.mark, structureMark.pos);
@@ -232,7 +232,7 @@ function findOrderedSuggestionIdsToRevert(node, suggestionId, materializedPaths)
         if (attrs.data.op.op !== "move") return false;
         return !sameParentChain(attrs.data.op.to, parentChain.chain);
     });
-    console.log("mismatch?", mismatch);
+    console.log("findOrderedSuggestionIdsToRevert", "mismatch?", mismatch);
     if (mismatch == null) {
         return Array.from(suggestionIds).reverse();
     }

package/dist/features/wrapUnwrap/structureChangesPlugin.js

@@ -18,7 +18,7 @@ export function structureChangesPlugin(generateId) {
         key: structureChangesKey,
         appendTransaction (transactions, _oldState, newState) {
             if (transactions.some((tr)=>!isEnabled(tr, newState))) {
-                console.warn("tracking changes is disabled, skipping structure changes plugin", [
+                console.warn("structureChangesPlugin", "tracking changes is disabled, skipping structure changes plugin", [
                     ...transactions
                 ]);
                 return;
@@ -26,7 +26,7 @@ export function structureChangesPlugin(generateId) {
             // do nothing if doc hasn't changed
             const docChanged = transactions.some((transaction)=>transaction.docChanged);
             if (!docChanged) {
-                console.warn("doc not changed, skipping structure changes plugin", [
+                console.warn("structureChangesPlugin", "doc not changed, skipping", [
                     ...transactions
                 ]);
                 return;
@@ -37,7 +37,7 @@ export function structureChangesPlugin(generateId) {
             const newDoc = lastTr?.doc;
             // do nothing if there isn't a pair of docs to compare
             if (!oldDoc || !newDoc) {
-                console.warn("old or new doc is missing, skipping structure changes plugin", {
+                console.warn("structureChangesPlugin", "old or new doc is missing, skipping", {
                     oldDoc,
                     newDoc,
                     transactions: [
@@ -51,7 +51,7 @@ export function structureChangesPlugin(generateId) {
                 if (node.isText) return true;
                 const nodeId = getNodeId(node);
                 if (nodeId == null) {
-                    console.warn("node", node.type.name, "at pos", pos, "is missing a stable id", {
+                    console.warn("structureChangesPlugin", "node", node.type.name, "at pos", pos, "is missing a unique id", {
                         id: node.attrs["id"]
                     });
                     idsSettled = false;
@@ -63,7 +63,7 @@ export function structureChangesPlugin(generateId) {
                 if (node.isText) return true;
                 const nodeId = getNodeId(node);
                 if (nodeId == null) {
-                    console.warn("node", node.type.name, "at pos", pos, "is missing a stable id", {
+                    console.warn("structureChangesPlugin", "node", node.type.name, "at pos", pos, "is missing a unique id", {
                         id: node.attrs["id"]
                     });
                     idsSettled = false;
@@ -71,9 +71,9 @@ export function structureChangesPlugin(generateId) {
                 }
                 return true;
             });
-            // do nothing if some nodes are missing stable ids - the diff is not possible then
+            // do nothing if some nodes are missing unique ids - the diff is not possible then
             if (!idsSettled) {
-                console.warn("ids not settled, skipping structure changes plugin", {
+                console.warn("structureChangesPlugin", "ids not settled, skipping", {
                     oldDoc,
                     newDoc,
                     transactions: [
@@ -105,12 +105,12 @@ export function suggestStructureChanges(docBefore, docAfter, generateId) {
     const suggestionId = generateId ? generateId(docBefore.type.schema, docBefore) : generateNextNumberId(docBefore.type.schema, docBefore);
     const pathsBefore = buildMaterializedPaths(docBefore);
     const pathsAfter = buildMaterializedPaths(docAfter);
-    console.log("materialized paths", {
+    console.log("suggestStructureChanges", "materialized paths", {
         pathsBefore: Object.fromEntries(pathsBefore.entries()),
         pathsAfter: Object.fromEntries(pathsAfter.entries())
     });
     const ops = getOps(pathsBefore, pathsAfter);
-    console.log("ops", {
+    console.log("suggestStructureChanges", "ops", {
         ops: Object.fromEntries(ops.entries())
     });
     const transform = new Transform(docAfter);

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

@@ -1,5 +1,4 @@
 import { type Attrs, type Node } from "prosemirror-model";
-export type NodeIdGenerator = (node: Node, pos: number, parent: Node | null, index: number) => string;
 interface NonDocNodeWithChildren {
     node: Node;
     pos: number;

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/{stableNodeIdsPlugin.js → uniqueNodeIdsPlugin.js}

@@ -1,38 +1,41 @@
 import { Plugin, PluginKey } from "prosemirror-state";
 import { getNodeId } from "./getNodeId.js";
 import { Transform } from "prosemirror-transform";
-// stable ids plugin
+// 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 stableNodeIdsKey = new PluginKey("@handlewithcare/prosemirror-suggest-changes-stable-node-ids");
-export const STABLE_NODE_IDS_PLUGIN_META = "stable-node-ids-plugin";
-export function stableNodeIds(generateNodeId) {
+export const uniqueNodeIdsPluginKey = new PluginKey("@handlewithcare/prosemirror-suggest-changes-unique-node-ids");
+export const UNIQUE_NODE_IDS_PLUGIN_META = "unique-node-ids-plugin";
+export function uniqueNodeIdsPlugin({ attributeName, generateID }) {
     return new Plugin({
-        key: stableNodeIdsKey,
-        appendTransaction (transactions, _oldState, newState) {
-            console.log("stableNodeIdsPlugin.appendTransaction");
-            const pluginState = stableNodeIdsKey.getState(newState);
+        key: uniqueNodeIdsPluginKey,
+        appendTransaction (transactions, oldState, newState) {
+            console.log("uniqueNodeIdsPlugin.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) {
-                console.warn("doc not changed, skipping stable node ids plugin", [
+                console.warn("uniqueNodeIdsPlugin", "doc not changed, skipping", [
                     ...transactions
                 ]);
                 return;
             }
-            console.groupCollapsed("stableNodeIdsPlugin", "appendTransaction");
-            console.log("stableNodeIdsPlugin", "appendTransaction", [
+            console.groupCollapsed("uniqueNodeIdsPlugin", "appendTransaction");
+            console.log("uniqueNodeIdsPlugin", "appendTransaction", [
                 ...transactions
             ]);
             const tr = newState.tr;
-            const transform = ensureStableIds(tr.doc, generateNodeId);
+            const transform = ensureUniqueNodeIds(transactions, oldState.doc, newState.doc, {
+                attributeName,
+                generateID
+            });
             transform.steps.forEach((step)=>{
                 tr.step(step);
             });
-            console.log("tr steps", tr.steps);
+            console.log("ensureUniqueNodeIdsPlugin", "tr steps", tr.steps);
             console.groupEnd();
             if (!tr.steps.length) return;
-            tr.setMeta(stableNodeIdsKey, STABLE_NODE_IDS_PLUGIN_META);
+            tr.setMeta(uniqueNodeIdsPluginKey, UNIQUE_NODE_IDS_PLUGIN_META);
             return tr;
         },
         state: {
@@ -42,8 +45,8 @@ export function stableNodeIds(generateNodeId) {
                 };
             },
             apply (tr, value) {
-                const meta = tr.getMeta(stableNodeIdsKey);
-                if (meta === STABLE_NODE_IDS_PLUGIN_META && !value.completedInitialRun) {
+                const meta = tr.getMeta(uniqueNodeIdsPluginKey);
+                if (meta === UNIQUE_NODE_IDS_PLUGIN_META && !value.completedInitialRun) {
                     return {
                         completedInitialRun: true
                     };
@@ -53,10 +56,10 @@ export function stableNodeIds(generateNodeId) {
         }
     });
 }
-export function ensureStableIds(doc, generateNodeId) {
-    const tr = new Transform(doc);
+export function ensureUniqueNodeIds(_transactions, _oldDoc, newDoc, options) {
+    const tr = new Transform(newDoc);
     const nodeIds = new Set();
-    tr.doc.descendants((node, pos, parent, index)=>{
+    tr.doc.descendants((node, pos)=>{
         if (node.isText) return false;
         const nodeId = getNodeId(node);
         // nodeId is set and is not duplicated
@@ -66,13 +69,13 @@ export function ensureStableIds(doc, generateNodeId) {
         }
         // nodeId is set and it is duplicated
         if (nodeId != null && nodeIds.has(nodeId)) {
-            const id = generateNodeId(node, pos, parent, index);
+            const id = options.generateID();
             nodeIds.add(id);
             tr.setNodeMarkup(pos, node.type, {
                 ...node.attrs,
-                id
+                [options.attributeName]: id
             }, node.marks);
-            console.log("fixed duplicate id", id, "for node", node.type.name, "at pos", pos, {
+            console.log("ensureUniqueNodeIds", "fixed duplicate id", id, "for node", node.type.name, "at pos", pos, {
                 was: nodeId,
                 is: id
             });
@@ -80,13 +83,13 @@ export function ensureStableIds(doc, generateNodeId) {
         }
         // node id is not set
         if (nodeId == null) {
-            const id = generateNodeId(node, pos, parent, index);
+            const id = options.generateID();
             nodeIds.add(id);
             tr.setNodeMarkup(pos, node.type, {
                 ...node.attrs,
-                id
+                [options.attributeName]: id
             }, node.marks);
-            console.log("set stable id", id, "for node", node.type.name, "at pos", pos);
+            console.log("ensureUniqueNodeIds", "set unique id", id, "for node", node.type.name, "at pos", pos);
             return true;
         }
         return true;

package/dist/index.d.ts

@@ -3,5 +3,5 @@ export { selectSuggestion, revertSuggestion, revertSuggestions, applySuggestion,
 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 { stableNodeIds as experimental_stableNodeIds, stableNodeIdsKey as experimental_stableNodeIdsKey, } from "./features/wrapUnwrap/stableNodeIdsPlugin.js";
+export { uniqueNodeIdsPlugin as experimental_uniqueNodeIdsPlugin, uniqueNodeIdsPluginKey as experimental_uniqueNodeIdsPluginKey, } from "./features/wrapUnwrap/uniqueNodeIdsPlugin.js";
 export { structureChangesPlugin as experimental_structureChangesPlugin, structureChangesKey as experimental_structureChangesKey, } from "./features/wrapUnwrap/structureChangesPlugin.js";

package/dist/index.js

@@ -3,5 +3,5 @@ export { selectSuggestion, revertSuggestion, revertSuggestions, applySuggestion,
 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 { stableNodeIds as experimental_stableNodeIds, stableNodeIdsKey as experimental_stableNodeIdsKey } from "./features/wrapUnwrap/stableNodeIdsPlugin.js";
+export { uniqueNodeIdsPlugin as experimental_uniqueNodeIdsPlugin, uniqueNodeIdsPluginKey as experimental_uniqueNodeIdsPluginKey } from "./features/wrapUnwrap/uniqueNodeIdsPlugin.js";
 export { structureChangesPlugin as experimental_structureChangesPlugin, structureChangesKey as experimental_structureChangesKey } from "./features/wrapUnwrap/structureChangesPlugin.js";

package/dist/withSuggestChanges.d.ts

@@ -1,8 +1,8 @@
 import { type Schema, type Node } from "prosemirror-model";
 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 NodeIdGenerator } from "./features/wrapUnwrap/types.js";
 /**
  * Given a standard transaction from ProseMirror, produce
  * a new transaction that tracks the changes from the original,
@@ -27,5 +27,5 @@ export declare function transformToSuggestionTransaction(originalTransaction: Tr
  */
 export declare function withSuggestChanges(dispatchTransaction?: EditorView["dispatch"], generateId?: (schema: Schema, doc?: Node) => SuggestionId, opts?: {
     experimental_trackStructureChanges?: boolean;
-    experimental_generateNodeId?: NodeIdGenerator;
+    experimental_ensureUniqueNodeIds?: (transactions: Transaction[], oldDoc: Node, newDoc: Node) => Transform;
 }): EditorView["dispatch"];

package/dist/withSuggestChanges.js

@@ -11,7 +11,12 @@ import { generateNextNumberId } from "./generateId.js";
 import { getSuggestionMarks } from "./utils.js";
 import { prependDeletionsWithZWSP } from "./prependDeletionsWithZWSP.js";
 import { suggestStructureChanges } from "./features/wrapUnwrap/structureChangesPlugin.js";
-import { ensureStableIds } from "./features/wrapUnwrap/stableNodeIdsPlugin.js";
+const TRACE_ENABLED = true;
+function trace(...args) {
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (!TRACE_ENABLED) return;
+    console.log("[withSuggestChanges]", ...args);
+}
 function getStepHandler(step) {
     if (step instanceof ReplaceStep) {
         return suggestReplaceStep;
@@ -115,41 +120,41 @@ function getStepHandler(step) {
         let transaction = tr;
         if (isEnabled) {
             let structureChangesTransform = null;
-            if (opts?.experimental_trackStructureChanges && typeof opts.experimental_generateNodeId === "function") {
-                const stableIdsTransform = ensureStableIds(tr.doc, opts.experimental_generateNodeId);
+            const docBefore = tr.docs[0];
+            if (tr.docChanged && docBefore && opts?.experimental_trackStructureChanges && typeof opts.experimental_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 uniqueNodeIdsTransform = opts.experimental_ensureUniqueNodeIds([
+                    tr
+                ], docBefore, tr.doc);
+                const docAfter = uniqueNodeIdsTransform.doc;
+                trace("unique node ids set", docAfter);
                 // try running structure changes first
                 // if handled, then ignore the main plugin
                 // otherwise use the main plugin
-                const docBefore = tr.docs[0];
-                const docAfter = stableIdsTransform.doc;
-                if (docBefore && tr.docChanged) {
-                    structureChangesTransform = suggestStructureChanges(docBefore, docAfter, generateId);
-                    if (structureChangesTransform.steps.length > 0) {
-                        console.log("withSuggestChanges", "structure changes, applying transform", {
-                            structureChangesTransform
-                        });
-                        stableIdsTransform.steps.forEach((step)=>{
-                            transaction.step(step);
-                        });
-                        structureChangesTransform.steps.forEach((step)=>{
-                            transaction.step(step);
-                        });
-                    }
+                structureChangesTransform = suggestStructureChanges(docBefore, docAfter, generateId);
+                trace("structure changes transform completed", structureChangesTransform);
+                if (structureChangesTransform.steps.length > 0) {
+                    uniqueNodeIdsTransform.steps.forEach((step)=>{
+                        transaction.step(step);
+                    });
+                    structureChangesTransform.steps.forEach((step)=>{
+                        transaction.step(step);
+                    });
+                    trace("applied unique id transform and structure changes transform to the transaction", transaction);
                 }
             }
             if (structureChangesTransform == null || structureChangesTransform.steps.length === 0) {
-                console.log("withSuggestChanges", "no structure changes, using main plugin", {
-                    structureChangesTransform
-                });
+                trace("running the main suggestions plugin...");
                 transaction = transformToSuggestionTransaction(tr, this.state, generateId);
+                trace("main suggestions plugin completed", transaction);
             }
         }
         if (transaction.docChanged) {
             prependDeletionsWithZWSP(transaction);
         }
-        console.log("withSuggestChanges", "final transaction", {
-            transaction
-        });
         dispatch.call(this, transaction);
     };
 }

package/package.json

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

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

@@ -1,2 +0,0 @@
-import { type Node } from "prosemirror-model";
-export declare function generateNodeId(_node: Node, _pos: number, _parent: Node | null, _index: number): string;

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

@@ -1,12 +0,0 @@
-import { type Node } from "prosemirror-model";
-import { Plugin, PluginKey } from "prosemirror-state";
-import { Transform } from "prosemirror-transform";
-import { type NodeIdGenerator } from "./types.js";
-export declare const stableNodeIdsKey: PluginKey<{
-    completedInitialRun: boolean;
-}>;
-export declare const STABLE_NODE_IDS_PLUGIN_META = "stable-node-ids-plugin";
-export declare function stableNodeIds(generateNodeId: NodeIdGenerator): Plugin<{
-    completedInitialRun: boolean;
-}>;
-export declare function ensureStableIds(doc: Node, generateNodeId: NodeIdGenerator): Transform;