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

package/dist/withSuggestChanges.js

@@ -1,97 +1,15 @@
-import { AddMarkStep, AddNodeMarkStep, AttrStep, RemoveMarkStep, RemoveNodeMarkStep, ReplaceAroundStep, ReplaceStep } from "prosemirror-transform";
-import { trackAddMarkStep } from "./addMarkStep.js";
-import { trackAddNodeMarkStep } from "./addNodeMarkStep.js";
-import { trackAttrStep } from "./attrStep.js";
-import { suggestRemoveMarkStep } from "./removeMarkStep.js";
-import { suggestRemoveNodeMarkStep } from "./removeNodeMarkStep.js";
-import { suggestReplaceAroundStep } from "./replaceAroundStep.js";
-import { suggestReplaceStep } from "./replaceStep.js";
 import { isSuggestChangesEnabled, suggestChangesKey } from "./plugin.js";
-import { generateNextNumberId } from "./generateId.js";
-import { getSuggestionMarks } from "./utils.js";
 import { prependDeletionsWithZWSP } from "./prependDeletionsWithZWSP.js";
-function getStepHandler(step) {
-    if (step instanceof ReplaceStep) {
-        return suggestReplaceStep;
-    }
-    if (step instanceof ReplaceAroundStep) {
-        return suggestReplaceAroundStep;
-    }
-    if (step instanceof AddMarkStep) {
-        return trackAddMarkStep;
-    }
-    if (step instanceof RemoveMarkStep) {
-        return suggestRemoveMarkStep;
-    }
-    if (step instanceof AddNodeMarkStep) {
-        return trackAddNodeMarkStep;
-    }
-    if (step instanceof RemoveNodeMarkStep) {
-        return suggestRemoveNodeMarkStep;
-    }
-    if (step instanceof AttrStep) {
-        return trackAttrStep;
-    }
-    // Default handler — simply rebase the step onto the
-    // tracked transaction and apply it.
-    return (trackedTransaction, _state, _doc, step, prevSteps)=>{
-        const reset = prevSteps.slice().reverse().reduce((acc, step)=>acc?.map(step.getMap().invert()) ?? null, step);
-        const rebased = trackedTransaction.steps.reduce((acc, step)=>acc?.map(step.getMap()) ?? null, reset);
-        if (rebased) {
-            trackedTransaction.step(rebased);
-        }
-        return false;
-    };
-}
-/**
- * Given a standard transaction from ProseMirror, produce
- * a new transaction that tracks the changes from the original,
- * rather than applying them.
- *
- * For each type of step, we implement custom behavior to prevent
- * deletions from being removed from the document, instead adding
- * deletion marks, and ensuring that all insertions have insertion
- * marks.
- */ export function transformToSuggestionTransaction(originalTransaction, state, generateId) {
-    getSuggestionMarks(state.schema);
-    let suggestionId = generateId ? generateId(state.schema, originalTransaction.docs[0]) : generateNextNumberId(state.schema, originalTransaction.docs[0]);
-    // Create a new transaction from scratch. The original transaction
-    // is going to be dropped in favor of this one.
-    const trackedTransaction = state.tr;
-    for(let i = 0; i < originalTransaction.steps.length; i++){
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        const step = originalTransaction.steps[i];
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        const doc = originalTransaction.docs[i];
-        const stepTracker = getStepHandler(step);
-        if (stepTracker(trackedTransaction, state, doc, step, originalTransaction.steps.slice(0, i), suggestionId) && i < originalTransaction.steps.length - 1) {
-            // If the suggestionId was used by one of the step handlers,
-            // increment it so that it's not reused.
-            if (generateId) {
-                suggestionId = generateId(state.schema, trackedTransaction.doc);
-            } else if (typeof suggestionId === "number") {
-                suggestionId = suggestionId + 1;
-            }
-        }
-        continue;
-    }
-    if (originalTransaction.selectionSet && !trackedTransaction.selectionSet) {
-        // Map the original selection backwards through the original transaction,
-        // and then forwards through the new one.
-        const originalBaseDoc = originalTransaction.docs[0];
-        const base = originalBaseDoc ? originalTransaction.selection.map(originalBaseDoc, originalTransaction.mapping.invert()) : originalTransaction.selection;
-        trackedTransaction.setSelection(base.map(trackedTransaction.doc, trackedTransaction.mapping));
-    }
-    if (originalTransaction.scrolledIntoView) {
-        trackedTransaction.scrollIntoView();
-    }
-    if (originalTransaction.storedMarksSet) {
-        trackedTransaction.setStoredMarks(originalTransaction.storedMarks);
-    }
-    // @ts-expect-error Preserve original transaction meta exactly as-is
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-    trackedTransaction.meta = originalTransaction.meta;
-    return trackedTransaction;
+import { getRequiredStructuralContextPaths, suggestStructureChanges } from "./features/wrapUnwrap/structureChangesPlugin.js";
+import { handleSpecialTransactionShape } from "./features/transactionShaping/index.js";
+import { transformToSuggestionTransaction } from "./transformToSuggestionTransaction.js";
+export { transformToSuggestionTransaction } from "./transformToSuggestionTransaction.js";
+export { suggestStructureChanges } from "./features/wrapUnwrap/structureChangesPlugin.js";
+const TRACE_ENABLED = false;
+function trace(...args) {
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (!TRACE_ENABLED) return;
+    console.log("[withSuggestChanges]", ...args);
 }
 /**
  * A `dispatchTransaction` decorator. Wrap your existing `dispatchTransaction`
@@ -103,13 +21,65 @@ function getStepHandler(step) {
  * These modified transactions will suggest changes instead of directly
  * applying them, e.g. by marking a range with the deletion mark rather
  * than removing it from the document.
- */ export function withSuggestChanges(dispatchTransaction, generateId) {
+ */ export function withSuggestChanges(dispatchTransaction, generateId, opts) {
     const dispatch = dispatchTransaction ?? function(tr) {
         this.updateState(this.state.apply(tr));
     };
     return function dispatchTransaction(tr) {
         const ySyncMeta = tr.getMeta("y-sync$") ?? {};
-        const transaction = isSuggestChangesEnabled(this.state) && !tr.getMeta("history$") && !tr.getMeta("collab$") && !ySyncMeta.isUndoRedoOperation && !ySyncMeta.isChangeOrigin && !("skip" in (tr.getMeta(suggestChangesKey) ?? {})) ? transformToSuggestionTransaction(tr, this.state, generateId) : tr;
+        const isEnabled = isSuggestChangesEnabled(this.state) && !tr.getMeta("history$") && !tr.getMeta("collab$") && !ySyncMeta.isUndoRedoOperation && !ySyncMeta.isChangeOrigin && !("skip" in (tr.getMeta(suggestChangesKey) ?? {}));
+        let transaction = tr;
+        if (isEnabled) {
+            let structureChangesResult = null;
+            const docBefore = transaction.docs[0];
+            const structuralContextPaths = opts?.experimental_trackStructureChanges ? getRequiredStructuralContextPaths(opts.experimental_trackStructures) : null;
+            const ensureUniqueNodeIds = opts?.experimental_ensureUniqueNodeIds;
+            const shapedTransaction = transaction.docChanged ? handleSpecialTransactionShape({
+                transaction,
+                state: this.state,
+                generateId,
+                structuralContextPaths,
+                ensureUniqueNodeIds
+            }) : null;
+            if (!shapedTransaction && 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 = ensureUniqueNodeIds([
+                    transaction
+                ], docBefore, transaction.doc);
+                trace("perf", "structure", "ensureUniqueNodsIds took", Number((performance.now() - perfUid).toFixed(2)), "ms");
+                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 perfStructure = performance.now();
+                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) {
+                    uniqueNodeIdsTransform.steps.forEach((step)=>{
+                        transaction.step(step);
+                    });
+                    structureChangesResult.transform.steps.forEach((step)=>{
+                        transaction.step(step);
+                    });
+                    trace("applied unique id transform and structure changes transform to the transaction", transaction);
+                }
+            }
+            if (shapedTransaction) {
+                transaction = shapedTransaction;
+            } else if (transaction.docChanged && structureChangesResult?.handled !== true) {
+                trace("running the main suggestions plugin...");
+                const perfSuggestions = performance.now();
+                transaction = transformToSuggestionTransaction(tr, this.state, generateId);
+                trace("perf", "suggestions", "transformToSuggestionTransaction took", Number((performance.now() - perfSuggestions).toFixed(2)), "ms");
+                trace("main suggestions plugin completed", transaction);
+            }
+        }
         if (transaction.docChanged) {
             prependDeletionsWithZWSP(transaction);
         }

package/dist/wrappingInputRule.d.ts

@@ -0,0 +1,4 @@
+import { InputRule } from "prosemirror-inputrules";
+import { type Node } from "prosemirror-model";
+import { type Attrs, type NodeType } from "prosemirror-model";
+export declare function wrappingInputRule(regexp: RegExp, nodeType: NodeType, getAttrs?: Attrs | null | ((matches: RegExpMatchArray) => Attrs | null), joinPredicate?: (match: RegExpMatchArray, node: Node) => boolean): InputRule;

package/dist/wrappingInputRule.js

@@ -0,0 +1,28 @@
+import { InputRule } from "prosemirror-inputrules";
+import { canJoin, findWrapping } from "prosemirror-transform";
+import { getSuggestionMarks } from "./utils.js";
+import { ZWSP } from "./constants.js";
+/// return a boolean to indicate whether a join should happen.
+export function wrappingInputRule(regexp, nodeType, getAttrs = null, joinPredicate) {
+    return new InputRule(regexp, (state, match, start, end)=>{
+        const attrs = getAttrs instanceof Function ? getAttrs(match) : getAttrs;
+        const tr = state.tr;
+        // check and try to preserve zwsp
+        const { insertion } = getSuggestionMarks(state.doc.type.schema);
+        let $start = tr.doc.resolve(start);
+        if (insertion.isInSet($start.nodeAfter?.marks ?? []) && match[0].startsWith(ZWSP)) {
+            // preserve a single ZWSP at the start
+            tr.delete(start + 1, end);
+        } else {
+            tr.delete(start, end);
+        }
+        // the rest of the rule unchanged
+        $start = tr.doc.resolve(start);
+        const range = $start.blockRange(), wrapping = range && findWrapping(range, nodeType, attrs);
+        if (!wrapping) return null;
+        tr.wrap(range, wrapping);
+        const before = tr.doc.resolve(start - 1).nodeBefore;
+        if (before && before.type == nodeType && canJoin(tr.doc, start - 1) && (!joinPredicate || joinPredicate(match, before))) tr.join(start - 1);
+        return tr;
+    });
+}

package/package.json

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

package/src/features/joinOnDelete/README.md

@@ -1,8 +0,0 @@
-When nodes are joined using backspace or delete, let the join happen normally,
-but mark former node boundaries with deletion mark of type="join".
-
-Save information about what nodes were at each side of the boundary before the
-join.
-
-Then on restore, use marks at join points to split the node and restore the node
-markup at each side of the split.