@tiptap/y-tiptap 3.0.3 → 3.0.5

package/dist/src/plugins/sync-plugin.d.ts

@@ -6,6 +6,7 @@ export function isVisible(item: Y.Item, snapshot?: Y.Snapshot): boolean;
 export function ySyncPlugin(yXmlFragment: Y.XmlFragment, { colors, colorMapping, permanentUserData, onFirstRender, mapping }?: YSyncOpts): any;
 export function getRelativeSelection(pmbinding: ProsemirrorBinding, state: import('prosemirror-state').EditorState): {
     type: any;
+    depth: any;
     anchor: any;
     head: any;
 };
@@ -44,6 +45,7 @@ export class ProsemirrorBinding {
      */
     beforeTransactionSelection: {
         type: any;
+        depth: any;
         anchor: any;
         head: any;
     };

package/dist/y-tiptap.cjs

@@ -330,7 +330,28 @@ const restoreRelativeSelection = (tr, relSel, binding) => {
         relSel.anchor,
         binding.mapping
       );
-      tr.setSelection(createSafeNodeSelection(tr, anchor));
+      // anchor is null when the referenced node was deleted or moved out of
+      // binding.type by a remote update; resolving null would throw.
+      if (anchor !== null) {
+        tr.setSelection(createSafeNodeSelection(tr, anchor));
+      }
+    } else if (relSel.type === 'nodeRange') {
+      const anchor = relativePositionToAbsolutePosition(
+        binding.doc,
+        binding.type,
+        relSel.anchor,
+        binding.mapping
+      );
+      const head = relativePositionToAbsolutePosition(
+        binding.doc,
+        binding.type,
+        relSel.head,
+        binding.mapping
+      );
+      const selection = createSafeNodeRangeSelection(tr, anchor, head, relSel.depth);
+      if (selection !== null) {
+        tr.setSelection(selection);
+      }
     } else {
       const anchor = relativePositionToAbsolutePosition(
         binding.doc,
@@ -368,23 +389,65 @@ const createSafeNodeSelection = (tr, pos) => {
   }
 };
 
+/**
+ * Safely reconstructs a NodeRangeSelection from resolved absolute positions.
+ *
+ * @param {import('prosemirror-state').Transaction} tr - The transaction whose document provides resolved positions.
+ * @param {number|null} anchor - Absolute document position marking the start (boundary) of the node range.
+ *        Use `relativePositionToAbsolutePosition` before calling this function.
+ * @param {number|null} head - Absolute document position marking the end (boundary) of the node range.
+ *        Use `relativePositionToAbsolutePosition` before calling this function.
+ * @param {number|undefined} depth - The nesting depth at which the range operates (e.g. 0 for
+ *        top-level blocks, 1 for blocks nested inside a wrapper). Passed through to
+ *        `Selection.fromJSON`; ignored by `@tiptap/extension-node-range` < v2.29 but
+ *        properly stored starting from that version.
+ * @returns {import('prosemirror-state').Selection|null} Reconstructed selection, or null if
+ *          anchor/head could not be resolved.
+ */
+const createSafeNodeRangeSelection = (tr, anchor, head, depth) => {
+  if (anchor === null || head === null) {
+    return null
+  }
+  const clampedAnchor = Math.min(Math.max(anchor, 0), tr.doc.content.size);
+  const clampedHead = Math.min(Math.max(head, 0), tr.doc.content.size);
+  try {
+    const selection = prosemirrorState.Selection.fromJSON(tr.doc, {
+      type: 'nodeRange',
+      anchor: clampedAnchor,
+      head: clampedHead,
+      depth
+    });
+    if (!selection.ranges.length) {
+      return prosemirrorState.TextSelection.near(tr.doc.resolve(clampedAnchor))
+    }
+    return selection
+  } catch (e) {
+    return prosemirrorState.TextSelection.near(tr.doc.resolve(clampedAnchor))
+  }
+};
+
 /**
  * @param {ProsemirrorBinding} pmbinding
  * @param {import('prosemirror-state').EditorState} state
  */
-const getRelativeSelection = (pmbinding, state) => ({
-  type: /** @type {any} */ (state.selection).jsonID,
-  anchor: absolutePositionToRelativePosition(
-    state.selection.anchor,
-    pmbinding.type,
-    pmbinding.mapping
-  ),
-  head: absolutePositionToRelativePosition(
-    state.selection.head,
-    pmbinding.type,
-    pmbinding.mapping
-  )
-});
+const getRelativeSelection = (pmbinding, state) => {
+  const type = /** @type {any} */ (state.selection).jsonID;
+  return {
+    type,
+    // `depth` is only meaningful for NodeRangeSelection; undefined for every other type.
+    depth: type === 'nodeRange' ? /** @type {any} */ (state.selection).depth : undefined,
+    anchor: absolutePositionToRelativePosition(
+      state.selection.anchor,
+      pmbinding.type,
+      pmbinding.mapping
+    ),
+    head: absolutePositionToRelativePosition(
+      state.selection.head,
+      pmbinding.type,
+      pmbinding.mapping
+    )
+  }
+};
 
 /**
  * Binding for prosemirror.
@@ -1643,7 +1706,11 @@ const relativePositionToAbsolutePosition = (y, documentType, relPos, mapping) =>
         if (t instanceof Y__namespace.XmlText) {
           pos += t._length;
         } else {
-          pos += /** @type {any} */ (mapping.get(t)).nodeSize;
+          const mapped = mapping.get(t);
+          if (mapped == null) {
+            return null
+          }
+          pos += /** @type {any} */ (mapped).nodeSize;
         }
       }
       n = /** @type {Y.Item} */ (n.right);
@@ -1667,7 +1734,11 @@ const relativePositionToAbsolutePosition = (y, documentType, relPos, mapping) =>
           if (contentType instanceof Y__namespace.XmlText) {
             pos += contentType._length;
           } else {
-            pos += /** @type {any} */ (mapping.get(contentType)).nodeSize;
+            const mapped = mapping.get(contentType);
+            if (mapped == null) {
+              return null
+            }
+            pos += /** @type {any} */ (mapped).nodeSize;
           }
         }
         n = n.right;
@@ -2009,7 +2080,9 @@ const createDecorations = (
       return
     }
 
-    if (aw.cursor != null) {
+    // `aw` can be null when a client disconnects, so we guard against it
+    // before reading `cursor` to avoid a TypeError.
+    if (aw && aw.cursor != null) {
       const user = aw.user || {};
       if (user.color == null) {
         user.color = '#ffa500';
@@ -2124,6 +2197,9 @@ const yCursorPlugin = (
       };
       const updateCursorInfo = () => {
         const ystate = ySyncPluginKey.getState(view.state);
+        // `ystate` is undefined during sync-plugin init and Y.Doc transitions;
+        // reading from it here would throw and break cursor tracking for the view.
+        if (!ystate || !ystate.binding) return
         // @note We make implicit checks when checking for the cursor property
         const current = awareness.getLocalState() || {};
         if (view.hasFocus()) {
@@ -2218,11 +2294,26 @@ const yUndoPlugin = ({ protectedNodes = defaultProtectedNodes, trackedOrigins =
     init: (initargs, state) => {
       // TODO: check if plugin order matches and fix
       const ystate = ySyncPluginKey.getState(state);
-      const _undoManager = undoManager || new Y.UndoManager(ystate.type, {
-        trackedOrigins: new Set([ySyncPluginKey].concat(trackedOrigins)),
-        deleteFilter: (item) => defaultDeleteFilter(item, protectedNodes),
-        captureTransaction: tr => tr.meta.get('addToHistory') !== false
-      });
+      let _undoManager = undoManager;
+      if (!_undoManager) {
+        // Y.UndoManager registers a `doc.on('destroy', …)` listener in its
+        // constructor that UndoManager.destroy() never removes. When the doc
+        // outlives the editor (e.g. several editors sharing one provider), that
+        // listener keeps the UndoManager — and everything it references —
+        // reachable from the doc, leaking memory on every editor destroy.
+        // We only own the lifecycle of a manager we create here, so capture the
+        // listener(s) it adds and remove them when the plugin view is destroyed.
+        const doc = ystate.doc;
+        const destroyListenersBefore = new Set(doc ? doc._observers.get('destroy') : []);
+        _undoManager = new Y.UndoManager(ystate.type, {
+          trackedOrigins: new Set([ySyncPluginKey].concat(trackedOrigins)),
+          deleteFilter: (item) => defaultDeleteFilter(item, protectedNodes),
+          captureTransaction: tr => tr.meta.get('addToHistory') !== false
+        });
+        const destroyListenersAfter = doc ? doc._observers.get('destroy') : new Set();
+        _undoManager._yTiptapDocDestroyListeners = Array.from(destroyListenersAfter || [])
+          .filter(listener => !destroyListenersBefore.has(listener));
+      }
       return {
         undoManager: _undoManager,
         prevSel: null,
@@ -2275,6 +2366,13 @@ const yUndoPlugin = ({ protectedNodes = defaultProtectedNodes, trackedOrigins =
     return {
       destroy: () => {
         undoManager.destroy();
+        // Remove the doc 'destroy' listener Y.UndoManager fails to clean up
+        // (only for managers we created — see state.init above).
+        const leakedDestroyListeners = undoManager._yTiptapDocDestroyListeners;
+        if (leakedDestroyListeners && undoManager.doc) {
+          leakedDestroyListeners.forEach(listener => undoManager.doc.off('destroy', listener));
+          undoManager._yTiptapDocDestroyListeners = null;
+        }
       }
     }
   }