@bigbinary/neeto-editor 1.47.123 → 1.47.125

package/dist/FormikEditor.js

@@ -17,7 +17,7 @@ import 'zustand';
 import 'classnames';
 import './chunk-DDwycKmK.js';
 import '@bigbinary/neetoui/Label';
-import './chunk-Bmhz4YEy.js';
+import './chunk-Be5ikGpm.js';
 import './chunk-Qg4uQqj3.js';
 import './chunk-BFTU3MAI.js';
 import '@bigbinary/neeto-commons-frontend/initializers';

package/dist/{chunk-Bmhz4YEy.js → chunk-Be5ikGpm.js}

@@ -3168,6 +3168,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
@@ -3220,28 +3245,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$1.between(tr.doc.resolve(anchor), tr.doc.resolve(head)));
@@ -4657,6 +4671,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
@@ -4677,32 +4758,100 @@ const findAbsolutePositionAfterStructuralChange = (oldDoc, newDoc, absPos) => {
     return null
   }
   const targetChild = oldDoc.child(targetIdx);
-  const offsetInChild = absPos - pos;
-
-  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++;
-    }
-  }
-
-  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))
+  const $oldPos = oldDoc.resolve(absPos);
+
+  /**
+   * @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)
+  };
+
+  /**
+   * 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
+  )
 };
 
 /**
@@ -4763,16 +4912,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
   }
@@ -4951,8 +5111,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(
@@ -4964,15 +5134,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
@@ -16774,4 +16935,4 @@ var fuzzySearch = function fuzzySearch(items, query) {
 };
 
 export { MODAL_TRANSFORM_X as A, BulletList as B, CharacterCount as C, MODAL_BOTTOM_MARGIN as D, buildArticleFullUrl as E, Focus as F, useEditorWarnings as G, useDeletedArticles as H, Link as L, MODE as M, OrderedList as O, Resizable as R, Table as T, index_default$1 as a, index_default$4 as b, index_default as c, index_default$7 as d, TaskList as e, fuzzySearch as f, TaskItem as g, index_default$a as h, index_default$2 as i, index_default$6 as j, TextStyle as k, index_default$5 as l, index_default$3 as m, TableRow as n, TableHeader as o, TableCell as p, Color as q, ListItem as r, scrollHandler as s, index_default$9 as t, index_default$8 as u, useFetchKbArticles as v, createArticleOptions as w, MODAL_LEFT_OFFSET as x, MODAL_TOP_OFFSET as y, MODAL_TRANSFORM_Y as z };
-//# sourceMappingURL=chunk-Bmhz4YEy.js.map
+//# sourceMappingURL=chunk-Be5ikGpm.js.map