@tiptap/y-tiptap 3.0.2 → 3.0.4

package/dist/y-tiptap.js

@@ -1382,24 +1382,115 @@ const matchNodeName = (yElement, pNode) =>
  */
 let viewsToUpdate = null;
 
-const updateMetas = () => {
-  const ups = /** @type {Map<EditorView, Map<any, any>>} */ (viewsToUpdate);
-  viewsToUpdate = null;
-  ups.forEach((metas, view) => {
-    const tr = view.state.tr;
-    const syncState = ySyncPluginKey.getState(view.state);
+class MetaEntry {
+  /**
+   * @param {EditorView} view
+   * @param {any} key
+   * @param {any} value
+   */
+  constructor (view, key, value) {
+    this.view = view;
+    this.key = key;
+    this.value = value;
+  }
+
+  apply () {
+    const syncState = ySyncPluginKey.getState(this.view.state);
     if (syncState && syncState.binding && !syncState.binding.isDestroyed) {
-      metas.forEach((val, key) => {
-        tr.setMeta(key, val);
+      const tr = this.view.state.tr;
+      tr.setMeta(this.key, this.value);
+      this.view.dispatch(tr);
+    }
+  }
+}
+
+class MetaEntriesQueue {
+  /**
+   * @param {Array<MetaEntry>} [entries=[]]
+   */
+  constructor (entries = []) {
+    this.entries = entries;
+  }
+
+  /**
+   * @return {MetaEntry|undefined}
+   */
+  getFirst () {
+    return this.entries[0]
+  }
+
+  /**
+   * @return {MetaEntry|undefined}
+   */
+  dequeueFirst () {
+    return this.entries.shift()
+  }
+
+  /**
+   * @return {boolean}
+   */
+  isEmpty () {
+    return this.entries.length === 0
+  }
+
+  static fromViewsToUpdate () {
+    const ups = /** @type {Map<EditorView, Map<any, any>>} */ (viewsToUpdate);
+    viewsToUpdate = null;
+    const entries = [];
+    ups.forEach((metas, view) => {
+      metas.forEach((value, key) => {
+        entries.push(new MetaEntry(view, key, value));
       });
-      view.dispatch(tr);
+    });
+    return new MetaEntriesQueue(entries)
+  }
+}
+
+/**
+ * Dispatch queued plugin metadata in order, retrying only the remaining
+ * entries if a transaction becomes stale while the async queue is flushing.
+ *
+ * Cursor awareness updates are decoration-only refreshes. If a real document
+ * transaction lands before one of these queued meta transactions is applied,
+ * ProseMirror can reject it with a RangeError. In that case we reschedule the
+ * remaining entries on the next tick. If the first remaining entry fails again
+ * on retry, we drop that entry and continue with the rest of the queue instead
+ * of retrying forever or crashing the editor.
+ *
+ * @param {MetaEntriesQueue} [metaEntries=MetaEntriesQueue.fromViewsToUpdate()]
+ * @param {boolean} [isRetry=false]
+ */
+const updateMetas = (metaEntries = MetaEntriesQueue.fromViewsToUpdate(), isRetry = false) => {
+  let isFirst = true;
+  while (!metaEntries.isEmpty()) {
+    const metaEntry = metaEntries.getFirst();
+    try {
+      metaEntry.apply();
+    } catch (err) {
+      // ProseMirror throws a RangeError when this transaction was created from
+      // an older state and another transaction changed the document before this
+      // meta-only dispatch was applied ("Applying a mismatched transaction").
+      if (err instanceof RangeError) {
+        if (isRetry && isFirst) {
+          // Drop the repeatedly stale entry so the queue can continue flushing.
+          metaEntries.dequeueFirst();
+        }
+        if (!metaEntries.isEmpty()) {
+          eventloop.timeout(0, () => updateMetas(metaEntries, true));
+        }
+        return
+      }
+      throw err
     }
-  });
+    isFirst = false;
+    metaEntries.dequeueFirst();
+  }
 };
 
 const setMeta = (view, key, value) => {
   if (!viewsToUpdate) {
     viewsToUpdate = new Map();
+    // Awareness listeners can fire in bursts, so batch them into one tick.
     eventloop.timeout(0, updateMetas);
   }
   map.setIfUndefined(viewsToUpdate, view, map.create).set(key, value);
@@ -1884,7 +1975,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';
@@ -1999,6 +2092,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()) {
@@ -2093,11 +2189,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 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 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,
@@ -2150,6 +2261,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;
+        }
       }
     }
   }