@tiptap/y-tiptap 3.0.6 → 3.0.7

package/dist/y-tiptap.js

@@ -281,6 +281,31 @@ const ySyncPlugin = (yXmlFragment, {
   return plugin
 };
 
+/**
+ * Resolves one text-selection endpoint after a remote update. Falls back to
+ * content-based matching when the Yjs resolution is missing or lands in the
+ * wrong block, and keeps the Yjs resolution when the fallback finds nothing.
+ *
+ * @param {import('prosemirror-model').Node} newDoc
+ * @param {import('prosemirror-model').Node} oldDoc
+ * @param {number|null|undefined} oldAbs
+ * @param {number|null} resolved
+ * @return {number|null}
+ */
+const recoverSelectionEndpoint = (newDoc, oldDoc, oldAbs, resolved) => {
+  if (oldAbs == null) {
+    return resolved
+  }
+  const misresolved = resolved === null ||
+    (oldAbs > 1 && resolved <= 1) ||
+    isMisresolvedAfterStructuralChange(oldDoc, newDoc, oldAbs, resolved);
+  if (!misresolved) {
+    return resolved
+  }
+  const recovered = findAbsolutePositionAfterStructuralChange(oldDoc, newDoc, oldAbs);
+  return recovered !== null ? recovered : resolved
+};
+
 /**
  * @param {import('prosemirror-state').Transaction} tr
  * @param {ReturnType<typeof getRelativeSelection>} relSel
@@ -333,28 +358,17 @@ const restoreRelativeSelection = (tr, relSel, binding, oldDoc) => {
         relSel.head,
         binding.mapping
       );
-      const needsContentFallback = oldDoc != null &&
-        relSel.absAnchor != null &&
-        relSel.absHead != null &&
-        (
-          anchor === null ||
-          head === null ||
-          (relSel.absAnchor > 1 && anchor !== null && anchor <= 1) ||
-          (relSel.absHead > 1 && head !== null && head <= 1) ||
-          isMisresolvedAfterStructuralChange(oldDoc, tr.doc, relSel.absAnchor, anchor) ||
-          isMisresolvedAfterStructuralChange(oldDoc, tr.doc, relSel.absHead, head)
-        );
-      if (needsContentFallback) {
-        anchor = findAbsolutePositionAfterStructuralChange(
-          oldDoc,
-          tr.doc,
-          relSel.absAnchor
-        );
-        head = findAbsolutePositionAfterStructuralChange(
-          oldDoc,
-          tr.doc,
-          relSel.absHead
-        );
+      if (oldDoc != null) {
+        anchor = recoverSelectionEndpoint(tr.doc, oldDoc, relSel.absAnchor, anchor);
+        head = recoverSelectionEndpoint(tr.doc, oldDoc, relSel.absHead, head);
+      }
+      // Collapse to the surviving endpoint instead of dropping the selection;
+      // an unset selection maps through the full-doc replace to the doc start.
+      if (anchor === null) {
+        anchor = head;
+      }
+      if (head === null) {
+        head = anchor;
       }
       if (anchor !== null && head !== null) {
         tr.setSelection(TextSelection.between(tr.doc.resolve(anchor), tr.doc.resolve(head)));
@@ -1770,6 +1784,73 @@ const relativePositionToAbsolutePosition = (y, documentType, relPos, mapping) =>
   return absPos
 };
 
+/**
+ * Shallow attrs comparison. Attr values are primitives in most schemas;
+ * non-primitive values fail the check and callers fall back to text matching.
+ *
+ * @param {Object<string, any>} a
+ * @param {Object<string, any>} b
+ * @return {boolean}
+ */
+const attrsEqual = (a, b) => {
+  if (a === b) {
+    return true
+  }
+  const aKeys = Object.keys(a);
+  return aKeys.length === Object.keys(b).length && aKeys.every((k) => a[k] === b[k])
+};
+
+/**
+ * Returns true when any attr deviates from its spec default or has none.
+ * Default-only attrs cannot tell same-type siblings apart.
+ *
+ * @param {import('prosemirror-model').Node} node
+ * @return {boolean}
+ */
+const hasDistinctiveAttrs = (node) => {
+  const specAttrs = node.type.spec.attrs || {};
+  return Object.keys(node.attrs).some((key) => {
+    const spec = specAttrs[key];
+    return spec == null ||
+      !Object.prototype.hasOwnProperty.call(spec, 'default') ||
+      spec.default !== node.attrs[key]
+  })
+};
+
+/**
+ * Remaps a position into a matched block by walking the same child-index path
+ * it had in the old block. A raw byte offset would overshoot into a sibling
+ * inner textblock when the old block contains local keystrokes that are not
+ * yet part of the rebuilt document.
+ *
+ * @param {import('prosemirror-model').ResolvedPos} $oldPos
+ * @param {number} newBlockStart
+ * @param {import('prosemirror-model').Node} newBlock
+ * @return {number|null}
+ */
+const remapIntoBlock = ($oldPos, newBlockStart, newBlock) => {
+  let pos = newBlockStart + 1;
+  let node = newBlock;
+  for (let depth = 1; depth < $oldPos.depth; depth++) {
+    const idx = $oldPos.index(depth);
+    if (idx >= node.childCount) {
+      return null
+    }
+    for (let i = 0; i < idx; i++) {
+      pos += node.child(i).nodeSize;
+    }
+    pos += 1;
+    node = node.child(idx);
+    if (node.type !== $oldPos.node(depth + 1).type) {
+      return null
+    }
+  }
+  if (!node.isTextblock) {
+    return null
+  }
+  return pos + Math.min($oldPos.parentOffset, node.content.size)
+};
+
 /**
  * @param {import('prosemirror-model').Node} oldDoc
  * @param {import('prosemirror-model').Node} newDoc
@@ -1790,32 +1871,100 @@ const findAbsolutePositionAfterStructuralChange = (oldDoc, newDoc, absPos) => {
     return null
   }
   const targetChild = oldDoc.child(targetIdx);
-  const offsetInChild = absPos - pos;
+  const $oldPos = oldDoc.resolve(absPos);
 
-  let occurrence = 0;
-  for (let i = 0; i <= targetIdx; i++) {
-    const child = oldDoc.child(i);
-    if (child.type === targetChild.type && child.textContent === targetChild.textContent) {
-      occurrence++;
+  /**
+   * @param {number} newBlockStart
+   * @param {import('prosemirror-model').Node} newBlock
+   * @return {number|null}
+   */
+  const place = (newBlockStart, newBlock) => {
+    // Positions between top-level blocks carry no inner path; clamp them just
+    // inside the matched block like the previous raw-offset remap did.
+    if ($oldPos.depth === 0) {
+      const remapped = newBlockStart + (absPos - pos);
+      const contentStart = newBlockStart + 1;
+      const contentEnd = newBlockStart + newBlock.nodeSize - 1;
+      return Math.max(contentStart, Math.min(remapped, contentEnd))
     }
-  }
+    return remapIntoBlock($oldPos, newBlockStart, newBlock)
+  };
 
-  let matchCount = 0;
-  let newPos = 0;
-  for (let i = 0; i < newDoc.childCount; i++) {
-    const child = newDoc.child(i);
-    if (child.type === targetChild.type && child.textContent === targetChild.textContent) {
-      matchCount++;
-      if (matchCount === occurrence) {
-        const remapped = newPos + offsetInChild;
-        const contentStart = newPos + 1;
-        const contentEnd = newPos + child.nodeSize - 1;
-        return Math.max(contentStart, Math.min(remapped, contentEnd))
+  /**
+   * Finds the Nth block in newDoc matching `pred`, where N is the number of
+   * matching blocks in oldDoc up to and including the target block.
+   *
+   * @param {function(import('prosemirror-model').Node): boolean} pred
+   * @param {boolean} requireUnique
+   * @return {number|null}
+   */
+  const findByPredicate = (pred, requireUnique = false) => {
+    let occurrence = 0;
+    for (let i = 0; i <= targetIdx; i++) {
+      if (pred(oldDoc.child(i))) {
+        occurrence++;
       }
     }
-    newPos += child.nodeSize;
+    let matchCount = 0;
+    let matchStart = -1;
+    let matchBlock = null;
+    let newPos = 0;
+    for (let i = 0; i < newDoc.childCount; i++) {
+      const child = newDoc.child(i);
+      if (pred(child)) {
+        matchCount++;
+        if (matchCount === occurrence) {
+          matchStart = newPos;
+          matchBlock = child;
+        }
+      }
+      newPos += child.nodeSize;
+    }
+    if (matchBlock === null || (requireUnique && (occurrence !== 1 || matchCount !== 1))) {
+      return null
+    }
+    return place(matchStart, matchBlock)
+  };
+
+  /**
+   * @param {import('prosemirror-model').Node} child
+   * @return {boolean}
+   */
+  const sameTypeAndAttrs = (child) =>
+    child.type === targetChild.type && attrsEqual(child.attrs, targetChild.attrs);
+  const oldText = targetChild.textContent;
+
+  const byAll = findByPredicate((child) => sameTypeAndAttrs(child) && child.textContent === oldText);
+  if (byAll !== null) {
+    return byAll
+  }
+
+  // Text must be matched before attrs: after a remote attr-only edit, the
+  // attrs pass would steer the cursor into a sibling that kept the old attrs.
+  const byText = findByPredicate(
+    (child) => child.type === targetChild.type && child.textContent === oldText
+  );
+  if (byText !== null) {
+    return byText
+  }
+
+  // In-flight local typing diverges the text between both docs. Distinctive
+  // attrs still identify the block; default-only attrs match every sibling.
+  if (hasDistinctiveAttrs(targetChild)) {
+    const byAttrs = findByPredicate(sameTypeAndAttrs, true);
+    if (byAttrs !== null) {
+      return byAttrs
+    }
   }
-  return null
+
+  // Trailing in-flight keystrokes leave a prefix relation between old and new
+  // text. Empty text is a prefix of everything and must never match.
+  return findByPredicate(
+    (child) => sameTypeAndAttrs(child) &&
+      oldText !== '' && child.textContent !== '' &&
+      (oldText.startsWith(child.textContent) || child.textContent.startsWith(oldText)),
+    true
+  )
 };
 
 /**
@@ -1876,16 +2025,27 @@ const isMisresolvedAfterStructuralChange = (oldDoc, newDoc, oldAbs, resolvedAbs)
   }
   const $old = oldDoc.resolve(oldAbs);
   const $new = newDoc.resolve(resolvedAbs);
-  if (!$old.parent.isTextblock || !$new.parent.isTextblock) {
+  if (!$old.parent.isTextblock) {
     return false
   }
+  // A textblock cursor cannot legitimately resolve into a non-textblock;
+  // a structural reorder replaced the block via delete + insert.
+  if (!$new.parent.isTextblock) {
+    return true
+  }
   if ($old.parent.textContent !== $new.parent.textContent) {
     return true
   }
   if ($old.parentOffset !== 0 && $new.parentOffset === 0) {
     return true
   }
-  if ($old.parentOffset === 0 && $new.parentOffset === 0) {
+  const bothAtStart = $old.parentOffset === 0 && $new.parentOffset === 0;
+  // A changed offset, type or attrs hints at a same-text sibling. When all
+  // of them agree there is no signal left and the Yjs resolution must win.
+  const suspicious = $old.parentOffset !== $new.parentOffset ||
+    $old.parent.type !== $new.parent.type ||
+    !attrsEqual($old.parent.attrs, $new.parent.attrs);
+  if (bothAtStart || suspicious) {
     const expected = findAbsolutePositionAfterStructuralChange(oldDoc, newDoc, oldAbs);
     return expected !== null && expected !== resolvedAbs
   }
@@ -2311,8 +2471,18 @@ const yCursorPlugin = (
       apply (tr, prevState, oldState, newState) {
         const ystate = ySyncPluginKey.getState(newState);
         const yCursorState = tr.getMeta(yCursorPluginKey);
+        const isRemoteChange = ystate && ystate.isChangeOrigin;
         if (
-          (ystate && ystate.isChangeOrigin) ||
+          tr.docChanged &&
+          !isRemoteChange &&
+          isStructuralTransaction(tr, oldState.doc)
+        ) {
+          // The ProseMirror document leads the Yjs mapping during local moves.
+          // Hide stale awareness until the collaborator publishes its new cursor.
+          return DecorationSet.empty
+        }
+        if (
+          isRemoteChange ||
           (yCursorState && yCursorState.awarenessUpdated)
         ) {
           return createDecorations(
@@ -2324,15 +2494,6 @@ const yCursorPlugin = (
           )
         }
         if (tr.docChanged) {
-          if (isStructuralTransaction(tr, oldState.doc)) {
-            return createDecorations(
-              newState,
-              awareness,
-              awarenessStateFilter,
-              cursorBuilder,
-              selectionBuilder
-            )
-          }
           return prevState.map(tr.mapping, tr.doc)
         }
         return prevState