@pm-cm/yjs 0.0.2 → 0.0.4

package/dist/index.js

@@ -1,6 +1,5 @@
 // src/bridge.ts
 import { prosemirrorToYXmlFragment, yXmlFragmentToProseMirrorRootNode, ySyncPluginKey } from "y-prosemirror";
-import { XmlElement as YXmlElement, XmlText as YXmlText } from "yjs";
 
 // src/types.ts
 var ORIGIN_TEXT_TO_PM = "bridge:text-to-prosemirror";
@@ -58,120 +57,10 @@ function replaceSharedProseMirror(doc, fragment, text, origin, config) {
     onError({ code: "parse-error", message: "failed to parse text into ProseMirror document", cause: error });
     return { ok: false, reason: "parse-error" };
   }
-  try {
-    const currentDoc = yXmlFragmentToProseMirrorRootNode(fragment, config.schema);
-    if (currentDoc.eq(nextDoc)) {
-      return { ok: false, reason: "unchanged" };
-    }
-  } catch {
-  }
-  if (!tryIncrementalFragmentUpdate(doc, fragment, nextDoc, origin)) {
-    doc.transact(() => {
-      prosemirrorToYXmlFragment(nextDoc, fragment);
-    }, origin);
-  }
-  return { ok: true };
-}
-function pmNodeToYXmlElement(node) {
-  const xmlEl = new YXmlElement(node.type.name);
-  for (const [key, value] of Object.entries(node.attrs)) {
-    if (value != null) xmlEl.setAttribute(key, value);
-  }
-  const children = [];
-  node.forEach((child) => {
-    if (child.isText && child.text) {
-      const xmlText = new YXmlText();
-      const attrs = {};
-      for (const mark of child.marks) {
-        attrs[mark.type.name] = mark.attrs && Object.keys(mark.attrs).length > 0 ? mark.attrs : true;
-      }
-      xmlText.insert(0, child.text, Object.keys(attrs).length > 0 ? attrs : void 0);
-      children.push(xmlText);
-    } else if (!child.isLeaf) {
-      children.push(pmNodeToYXmlElement(child));
-    }
-  });
-  if (children.length > 0) {
-    xmlEl.insert(0, children);
-  }
-  return xmlEl;
-}
-function getXmlElementText(xmlEl) {
-  let text = "";
-  for (let j = 0; j < xmlEl.length; j++) {
-    const child = xmlEl.get(j);
-    if (child instanceof YXmlText) text += child.toString();
-  }
-  return text;
-}
-function updateXmlElementTextContent(xmlEl, pmNode) {
-  if (xmlEl.length === 0 || !(xmlEl.get(0) instanceof YXmlText)) return;
-  const xmlText = xmlEl.get(0);
-  const oldText = xmlText.toString();
-  const newText = pmNode.textContent;
-  if (oldText === newText) return;
-  let start = 0;
-  const minLen = Math.min(oldText.length, newText.length);
-  while (start < minLen && oldText.charCodeAt(start) === newText.charCodeAt(start)) {
-    start++;
-  }
-  let oldEnd = oldText.length;
-  let newEnd = newText.length;
-  while (oldEnd > start && newEnd > start && oldText.charCodeAt(oldEnd - 1) === newText.charCodeAt(newEnd - 1)) {
-    oldEnd--;
-    newEnd--;
-  }
-  if (oldEnd > start) xmlText.delete(start, oldEnd - start);
-  if (newEnd > start) xmlText.insert(start, newText.slice(start, newEnd));
-}
-function tryIncrementalFragmentUpdate(ydoc, fragment, nextDoc, origin) {
-  const oldCount = fragment.length;
-  const newCount = nextDoc.childCount;
-  for (let i = 0; i < oldCount; i++) {
-    if (!(fragment.get(i) instanceof YXmlElement)) return false;
-  }
-  let prefix = 0;
-  while (prefix < Math.min(oldCount, newCount)) {
-    const oldChild = fragment.get(prefix);
-    const newChild = nextDoc.child(prefix);
-    if (oldChild.nodeName !== newChild.type.name) break;
-    if (getXmlElementText(oldChild) !== newChild.textContent) break;
-    prefix++;
-  }
-  let suffix = 0;
-  while (suffix < Math.min(oldCount - prefix, newCount - prefix)) {
-    const oi = oldCount - 1 - suffix;
-    const ni = newCount - 1 - suffix;
-    const oldChild = fragment.get(oi);
-    const newChild = nextDoc.child(ni);
-    if (oldChild.nodeName !== newChild.type.name) break;
-    if (getXmlElementText(oldChild) !== newChild.textContent) break;
-    suffix++;
-  }
-  const oldMiddleLen = oldCount - prefix - suffix;
-  const newMiddleLen = newCount - prefix - suffix;
-  if (oldMiddleLen === 0 && newMiddleLen === 0) return true;
-  ydoc.transact(() => {
-    const updateCount = Math.min(oldMiddleLen, newMiddleLen);
-    for (let i = 0; i < updateCount; i++) {
-      const idx = prefix + i;
-      const xmlEl = fragment.get(idx);
-      const pmNode = nextDoc.child(idx);
-      if (xmlEl.nodeName === pmNode.type.name) {
-        updateXmlElementTextContent(xmlEl, pmNode);
-      } else {
-        fragment.delete(idx, 1);
-        fragment.insert(idx, [pmNodeToYXmlElement(pmNode)]);
-      }
-    }
-    if (oldMiddleLen > updateCount) {
-      fragment.delete(prefix + updateCount, oldMiddleLen - updateCount);
-    }
-    for (let i = updateCount; i < newMiddleLen; i++) {
-      fragment.insert(prefix + i, [pmNodeToYXmlElement(nextDoc.child(prefix + i))]);
-    }
+  doc.transact(() => {
+    prosemirrorToYXmlFragment(nextDoc, fragment);
   }, origin);
-  return true;
+  return { ok: true };
 }
 function createYjsBridge(config, options) {
   const {
@@ -208,10 +97,10 @@ function createYjsBridge(config, options) {
       normalize,
       onError
     });
-    if (result.ok || result.reason === "unchanged") {
+    if (result.ok) {
       lastBridgedText = text;
     }
-    return result.ok || result.reason === "unchanged";
+    return result.ok;
   };
   const sharedProseMirrorToText = (fragment) => {
     try {
@@ -239,7 +128,13 @@ function createYjsBridge(config, options) {
           return { source: "initial", parseError: true };
         }
         const pmDoc = yXmlFragmentToProseMirrorRootNode(sharedProseMirror, schema);
-        const canonicalText = serialize(pmDoc);
+        let canonicalText;
+        try {
+          canonicalText = serialize(pmDoc);
+        } catch (error) {
+          onError({ code: "serialize-error", message: "failed to serialize ProseMirror document during bootstrap", cause: error });
+          return { source: "initial", parseError: true };
+        }
         replaceSharedText(sharedText, canonicalText, ORIGIN_INIT, normalize);
         lastBridgedText = normalize(canonicalText);
         return { source: "initial" };
@@ -301,7 +196,13 @@ function createYjsBridge(config, options) {
   return {
     bootstrapResult,
     syncToSharedText(doc2) {
-      const text = serialize(doc2);
+      let text;
+      try {
+        text = serialize(doc2);
+      } catch (error) {
+        onError({ code: "serialize-error", message: "failed to serialize ProseMirror document", cause: error });
+        return { ok: false, reason: "serialize-error" };
+      }
       const result = replaceSharedText(sharedText, text, ORIGIN_PM_TO_TEXT, normalize);
       if (result.ok || result.reason === "unchanged") {
         lastBridgedText = normalize(text);
@@ -339,10 +240,12 @@ function createAwarenessProxy(awareness, cursorField = "pmCursor") {
           const states = target.getStates();
           const remapped = /* @__PURE__ */ new Map();
           states.forEach((state, clientId) => {
-            remapped.set(clientId, {
-              ...state,
-              cursor: state[cursorField] ?? null
-            });
+            const s = state;
+            if (cursorField in s) {
+              remapped.set(clientId, { ...s, cursor: s[cursorField] ?? null });
+            } else {
+              remapped.set(clientId, s);
+            }
           });
           return remapped;
         };
@@ -359,14 +262,12 @@ import { initProseMirrorDoc, yCursorPlugin, ySyncPlugin, yUndoPlugin } from "y-p
 // src/bridge-sync-plugin.ts
 import { Plugin, PluginKey } from "prosemirror-state";
 var bridgeSyncPluginKey = new PluginKey("pm-cm-bridge-sync");
-var wiredBridges = /* @__PURE__ */ new WeakSet();
+var wiredBridges = /* @__PURE__ */ new WeakMap();
 var defaultOnWarning = (event) => console.warn(`[pm-cm] ${event.code}: ${event.message}`);
 function createBridgeSyncPlugin(bridge, options = {}) {
   const warn = options.onWarning ?? defaultOnWarning;
-  if (wiredBridges.has(bridge)) {
-    warn({ code: "bridge-already-wired", message: "this bridge is already wired to another plugin instance" });
-  }
-  wiredBridges.add(bridge);
+  let yjsBatchSeen = false;
+  let needsSync = false;
   return new Plugin({
     key: bridgeSyncPluginKey,
     state: {
@@ -374,27 +275,44 @@ function createBridgeSyncPlugin(bridge, options = {}) {
         return { needsSync: false };
       },
       apply(tr, _prev) {
-        if (!tr.docChanged) return { needsSync: false };
-        if (bridge.isYjsSyncChange(tr)) return { needsSync: false };
+        if (!tr.docChanged) return { needsSync };
+        if (bridge.isYjsSyncChange(tr)) {
+          yjsBatchSeen = true;
+          needsSync = false;
+          return { needsSync: false };
+        }
+        if (yjsBatchSeen) {
+          needsSync = false;
+          return { needsSync: false };
+        }
+        needsSync = true;
         return { needsSync: true };
       }
     },
     view() {
+      const count = wiredBridges.get(bridge) ?? 0;
+      if (count > 0) {
+        warn({ code: "bridge-already-wired", message: "this bridge is already wired to another plugin instance" });
+      }
+      wiredBridges.set(bridge, count + 1);
       return {
         update(view) {
-          const state = bridgeSyncPluginKey.getState(view.state);
-          if (state?.needsSync) {
+          if (needsSync) {
             const result = bridge.syncToSharedText(view.state.doc);
             if (!result.ok) {
-              if (result.reason === "detached") {
+              if (result.reason !== "unchanged") {
                 options.onSyncFailure?.(result, view);
                 warn({ code: "sync-failed", message: `bridge sync failed: ${result.reason}` });
               }
             }
           }
+          needsSync = false;
+          yjsBatchSeen = false;
         },
         destroy() {
-          wiredBridges.delete(bridge);
+          const remaining = (wiredBridges.get(bridge) ?? 1) - 1;
+          if (remaining <= 0) wiredBridges.delete(bridge);
+          else wiredBridges.set(bridge, remaining);
         }
       };
     }
@@ -404,7 +322,7 @@ function createBridgeSyncPlugin(bridge, options = {}) {
 // src/cursor-sync-plugin.ts
 import { Plugin as Plugin2, PluginKey as PluginKey2 } from "prosemirror-state";
 import { absolutePositionToRelativePosition, ySyncPluginKey as ySyncPluginKey2 } from "y-prosemirror";
-import { createRelativePositionFromTypeIndex } from "yjs";
+import { createRelativePositionFromTypeIndex, createAbsolutePositionFromRelativePosition } from "yjs";
 import { buildCursorMap, cursorMapLookup, reverseCursorMapLookup } from "@pm-cm/core";
 var cursorSyncPluginKey = new PluginKey2("pm-cm-cursor-sync");
 function getYSyncState(view) {
@@ -445,12 +363,23 @@ function createCursorSyncPlugin(options) {
   const warn = options.onWarning ?? defaultOnWarning2;
   const cursorFieldName = options.cursorFieldName ?? "pmCursor";
   const cmCursorFieldName = options.cmCursorFieldName ?? "cursor";
+  if (sharedText && cursorFieldName === cmCursorFieldName) {
+    throw new Error(
+      `createCursorSyncPlugin: cursorFieldName and cmCursorFieldName must differ when sharedText is provided (both are "${cursorFieldName}")`
+    );
+  }
   let warnedSyncPluginMissing = false;
+  let pendingCmCursor = null;
   let cachedMap = null;
   let cachedMapDoc = null;
   function getOrBuildMap(doc) {
     if (cachedMapDoc !== doc || !cachedMap) {
-      cachedMap = buildCursorMap(doc, serialize);
+      try {
+        cachedMap = buildCursorMap(doc, serialize);
+      } catch (error) {
+        warn({ code: "cursor-map-error", message: "failed to build cursor map \u2014 cursor sync skipped" });
+        cachedMap = null;
+      }
       cachedMapDoc = doc;
     }
     return cachedMap;
@@ -464,62 +393,141 @@ function createCursorSyncPlugin(options) {
       apply(tr, prev, _oldState, newState) {
         const cmMeta = tr.getMeta(cursorSyncPluginKey);
         if (cmMeta) {
-          return { pendingCm: cmMeta, mappedTextOffset: prev.mappedTextOffset };
+          pendingCmCursor = cmMeta;
         }
         let mappedTextOffset = prev.mappedTextOffset;
         if (tr.selectionSet || tr.docChanged) {
           const map = getOrBuildMap(newState.doc);
-          mappedTextOffset = cursorMapLookup(map, newState.selection.anchor);
+          mappedTextOffset = map ? cursorMapLookup(map, newState.selection.anchor) : null;
         }
         return {
-          pendingCm: prev.pendingCm !== null ? null : prev.pendingCm,
+          pendingCm: pendingCmCursor,
           mappedTextOffset
         };
       }
     },
-    view() {
+    view(editorView) {
+      let suppressCmReaction = false;
+      let lastCmAbsAnchor = -1;
+      let lastCmAbsHead = -1;
+      let cmCursorHandledByListener = false;
+      const handleAwarenessUpdate = ({ added, updated }) => {
+        if (suppressCmReaction) return;
+        if (!sharedText?.doc) return;
+        const localId = awareness.clientID;
+        if (!updated.includes(localId) && !added.includes(localId)) return;
+        const localState = awareness.getLocalState();
+        if (!localState) return;
+        const cmCursor = localState[cmCursorFieldName];
+        if (!cmCursor?.anchor || !cmCursor?.head) {
+          if (lastCmAbsAnchor !== -1) {
+            awareness.setLocalStateField(cursorFieldName, null);
+            lastCmAbsAnchor = -1;
+            lastCmAbsHead = -1;
+          }
+          return;
+        }
+        const absAnchor = createAbsolutePositionFromRelativePosition(cmCursor.anchor, sharedText.doc);
+        const absHead = createAbsolutePositionFromRelativePosition(cmCursor.head, sharedText.doc);
+        if (!absAnchor || !absHead) {
+          awareness.setLocalStateField(cursorFieldName, null);
+          lastCmAbsAnchor = -1;
+          lastCmAbsHead = -1;
+          return;
+        }
+        if (absAnchor.index === lastCmAbsAnchor && absHead.index === lastCmAbsHead) return;
+        const map = getOrBuildMap(editorView.state.doc);
+        if (!map) {
+          awareness.setLocalStateField(cursorFieldName, null);
+          return;
+        }
+        const pmAnchor = reverseCursorMapLookup(map, absAnchor.index);
+        const pmHead = reverseCursorMapLookup(map, absHead.index);
+        if (pmAnchor === null || pmHead === null) {
+          awareness.setLocalStateField(cursorFieldName, null);
+          return;
+        }
+        lastCmAbsAnchor = absAnchor.index;
+        lastCmAbsHead = absHead.index;
+        cmCursorHandledByListener = true;
+        const ok = broadcastPmCursor(awareness, cursorFieldName, editorView, pmAnchor, pmHead);
+        if (!ok && !warnedSyncPluginMissing) {
+          warnedSyncPluginMissing = true;
+          warn({ code: "ysync-plugin-missing", message: "ySyncPlugin state not available \u2014 cursor broadcast skipped" });
+        }
+      };
+      if (sharedText) {
+        awareness.on("update", handleAwarenessUpdate);
+      }
       return {
         update(view, prevState) {
-          const pluginState = cursorSyncPluginKey.getState(view.state);
-          const prevPluginState = cursorSyncPluginKey.getState(prevState);
-          if (pluginState?.pendingCm != null && pluginState.pendingCm !== prevPluginState?.pendingCm) {
-            const map = getOrBuildMap(view.state.doc);
-            const pmAnchor = reverseCursorMapLookup(map, pluginState.pendingCm.anchor);
-            const pmHead = reverseCursorMapLookup(map, pluginState.pendingCm.head);
-            if (pmAnchor !== null && pmHead !== null) {
-              const ok = broadcastPmCursor(awareness, cursorFieldName, view, pmAnchor, pmHead);
-              if (!ok && !warnedSyncPluginMissing) {
-                warnedSyncPluginMissing = true;
-                warn({ code: "ysync-plugin-missing", message: "ySyncPlugin state not available \u2014 cursor broadcast skipped" });
-              }
+          if (view.state.doc !== prevState.doc) {
+            lastCmAbsAnchor = -1;
+            lastCmAbsHead = -1;
+            if (sharedText?.doc && !suppressCmReaction) {
+              handleAwarenessUpdate({ added: [awareness.clientID], updated: [], removed: [] });
             }
-            if (sharedText) {
-              broadcastTextCursor(
-                awareness,
-                cmCursorFieldName,
-                sharedText,
-                pluginState.pendingCm.anchor,
-                pluginState.pendingCm.head
-              );
+          }
+          if (pendingCmCursor != null) {
+            const cursor = pendingCmCursor;
+            pendingCmCursor = null;
+            if (!cmCursorHandledByListener) {
+              const map = getOrBuildMap(view.state.doc);
+              const pmAnchor = map ? reverseCursorMapLookup(map, cursor.anchor) : null;
+              const pmHead = map ? reverseCursorMapLookup(map, cursor.head) : null;
+              if (pmAnchor !== null && pmHead !== null) {
+                const ok = broadcastPmCursor(awareness, cursorFieldName, view, pmAnchor, pmHead);
+                if (!ok && !warnedSyncPluginMissing) {
+                  warnedSyncPluginMissing = true;
+                  warn({ code: "ysync-plugin-missing", message: "ySyncPlugin state not available \u2014 cursor broadcast skipped" });
+                }
+                if (sharedText?.doc) {
+                  broadcastTextCursor(
+                    awareness,
+                    cmCursorFieldName,
+                    sharedText,
+                    cursor.anchor,
+                    cursor.head
+                  );
+                }
+              } else {
+                awareness.setLocalStateField(cursorFieldName, null);
+              }
             }
+            cmCursorHandledByListener = false;
             return;
           }
           if (view.hasFocus() && (view.state.selection !== prevState.selection || view.state.doc !== prevState.doc)) {
-            const { anchor, head } = view.state.selection;
-            const ok = broadcastPmCursor(awareness, cursorFieldName, view, anchor, head);
-            if (!ok && !warnedSyncPluginMissing) {
-              warnedSyncPluginMissing = true;
-              warn({ code: "ysync-plugin-missing", message: "ySyncPlugin state not available \u2014 cursor broadcast skipped" });
-            }
-            if (sharedText) {
-              const map = getOrBuildMap(view.state.doc);
-              const textAnchor = cursorMapLookup(map, anchor);
-              const textHead = cursorMapLookup(map, head);
-              if (textAnchor !== null && textHead !== null) {
-                broadcastTextCursor(awareness, cmCursorFieldName, sharedText, textAnchor, textHead);
+            suppressCmReaction = true;
+            try {
+              const { anchor, head } = view.state.selection;
+              const ok = broadcastPmCursor(awareness, cursorFieldName, view, anchor, head);
+              if (!ok && !warnedSyncPluginMissing) {
+                warnedSyncPluginMissing = true;
+                warn({ code: "ysync-plugin-missing", message: "ySyncPlugin state not available \u2014 cursor broadcast skipped" });
+              }
+              if (sharedText?.doc) {
+                const map = getOrBuildMap(view.state.doc);
+                const textAnchor = map ? cursorMapLookup(map, anchor) : null;
+                const textHead = map ? cursorMapLookup(map, head) : null;
+                if (textAnchor !== null && textHead !== null) {
+                  broadcastTextCursor(awareness, cmCursorFieldName, sharedText, textAnchor, textHead);
+                } else {
+                  awareness.setLocalStateField(cmCursorFieldName, null);
+                }
               }
+            } finally {
+              suppressCmReaction = false;
             }
           }
+          cmCursorHandledByListener = false;
+        },
+        destroy() {
+          awareness.setLocalStateField(cursorFieldName, null);
+          if (sharedText) {
+            awareness.setLocalStateField(cmCursorFieldName, null);
+            awareness.off("update", handleAwarenessUpdate);
+          }
         }
       };
     }
@@ -530,7 +538,10 @@ function syncCmCursor(view, anchor, head, onWarning) {
     (onWarning ?? defaultOnWarning2)({ code: "cursor-sync-not-installed", message: "cursor sync plugin is not installed on this EditorView" });
     return;
   }
-  const sanitize = (v) => Math.max(0, Math.floor(v));
+  const sanitize = (v) => {
+    const n = Math.floor(v);
+    return Number.isFinite(n) ? Math.max(0, n) : 0;
+  };
   view.dispatch(
     view.state.tr.setMeta(cursorSyncPluginKey, {
       anchor: sanitize(anchor),