@arbidocs/blocks 0.4.155 → 0.4.157

package/node_modules/@arbidocs/coedit/dist/index.cjs

@@ -1276,7 +1276,6 @@ function applyJournal(doc, registry, journal, origin, context) {
 
 // src/sync.ts
 var LOCAL_ORIGIN = /* @__PURE__ */ Symbol("arbi-coedit/local");
-var DEFAULT_REMOTE_DELAY_MS = 40;
 var MirrorSync = class {
   doc;
   registry = new NodeRegistry();
@@ -1285,14 +1284,11 @@ var MirrorSync = class {
   actorId;
   onFailure;
   onLocalJournal;
+  aroundRemote;
   disposers = [];
-  remoteDelayMs;
   operation = 0;
   applyingRemote = false;
   failed = false;
-  remoteDirty = false;
-  remoteOrigin;
-  remoteTimer;
   /** Parts whose node ids must be re-registered before the next local journal; true means all. */
   staleParts = null;
   constructor(options) {
@@ -1301,7 +1297,7 @@ var MirrorSync = class {
     this.actorId = options.actorId;
     this.onFailure = options.onFailure;
     this.onLocalJournal = options.onLocalJournal;
-    this.remoteDelayMs = options.remoteDelayMs ?? DEFAULT_REMOTE_DELAY_MS;
+    this.aroundRemote = options.aroundRemote;
     registerMirror(this.doc, this.registry);
     this.cache = new MaterializeCache(this.doc);
     this.disposers.push(() => this.cache.destroy());
@@ -1322,16 +1318,10 @@ var MirrorSync = class {
     const onAfterTransaction = (transaction) => {
       if (transaction.origin === LOCAL_ORIGIN || this.failed) return;
       if (transaction.changed.size === 0 && transaction.changedParentTypes.size === 0) return;
-      this.remoteDirty = true;
-      this.remoteOrigin = transaction.origin;
-      if (this.remoteDelayMs <= 0) this.flushRemote();
-      else if (this.remoteTimer === void 0) {
-        this.remoteTimer = setTimeout(() => this.flushRemote(), this.remoteDelayMs);
-      }
+      this.publishRemote(transaction.origin);
     };
     this.doc.on("afterTransaction", onAfterTransaction);
     this.disposers.push(() => this.doc.off("afterTransaction", onAfterTransaction));
-    this.disposers.push(() => clearTimeout(this.remoteTimer));
   }
   get hasFailed() {
     return this.failed;
@@ -1340,17 +1330,8 @@ var MirrorSync = class {
   beforeRemote() {
     this.port.flushPendingJournals();
   }
-  /** Publish any waiting remote change now. Call before a local operation runs. */
-  flushRemote() {
-    clearTimeout(this.remoteTimer);
-    this.remoteTimer = void 0;
-    if (!this.remoteDirty || this.failed) return;
-    this.remoteDirty = false;
-    this.publishRemote(this.remoteOrigin);
-  }
   /** Make the local tree equal to the room: used when the editor opened an older snapshot of it. */
   adopt() {
-    this.remoteDirty = false;
     this.publishRemote(void 0);
   }
   /** Re-register node ids for parts a remote publication replaced; deferred until a local edit needs them. */
@@ -1360,23 +1341,29 @@ var MirrorSync = class {
     this.staleParts = null;
   }
   publishRemote(origin) {
+    if (this.failed) return;
+    const published = this.aroundRemote?.();
     this.applyingRemote = true;
     const changed = this.cache.take();
+    let ok = false;
     try {
       const result = this.port.applyRemotePackage(materialize(this.doc, this.cache, changed), {
-        origin: "dev.docx-editor.collaboration.remote",
+        // The editor's own origin for a peer's change: it carries the local caret only across those.
+        origin: store.ORIGIN_IDS.mutationRemote,
         actorId: typeof origin === "string" ? origin : this.actorId,
         operationId: `${this.actorId}:remote:${this.operation++}`
       });
       if (!result.ok) throw new JournalError(result.reason);
       if (changed === null || this.staleParts === true) this.staleParts = true;
       else this.staleParts = /* @__PURE__ */ new Set([...this.staleParts ?? [], ...changed]);
+      ok = true;
     } catch (error) {
       this.cache.restore(changed);
       this.fail(error instanceof MaterializeError ? "materialize" : "apply", error);
     } finally {
       this.applyingRemote = false;
     }
+    if (ok) published?.();
   }
   fail(code, error) {
     if (this.failed) return;
@@ -1430,7 +1417,6 @@ var DocxCollaborationSession = class {
   doc;
   awareness;
   offlineEditing;
-  remoteDelayMs;
   tracker = collaboration.createCollaborationStatusTracker("initializing");
   statusListeners = /* @__PURE__ */ new Set();
   participantListeners = /* @__PURE__ */ new Set();
@@ -1443,6 +1429,10 @@ var DocxCollaborationSession = class {
   selectionsCache = [];
   selectionsKey = "[]";
   baselineVector;
+  /** The selection the editor last published, carried across the remote changes since. */
+  carried = null;
+  selectionMove = null;
+  inputFlush = null;
   disposers = [];
   constructor(options) {
     this.documentId = options.documentId;
@@ -1451,7 +1441,6 @@ var DocxCollaborationSession = class {
     this.doc = options.doc;
     this.awareness = options.awareness;
     this.offlineEditing = options.offlineEditing ?? false;
-    this.remoteDelayMs = options.remoteDelayMs;
     this.undoManager = new Y3__namespace.UndoManager(
       [
         this.doc.getMap("parts"),
@@ -1513,7 +1502,6 @@ var DocxCollaborationSession = class {
     return this.port !== void 0;
   }
   gateOperations() {
-    this.sync?.flushRemote();
     switch (this.status()) {
       case "ready":
         return this.port ? null : "collaboration-session-not-attached";
@@ -1542,7 +1530,7 @@ var DocxCollaborationSession = class {
       doc: this.doc,
       port,
       actorId: this.identity.actorId,
-      remoteDelayMs: this.remoteDelayMs,
+      aroundRemote: () => this.carrySelection(),
       onFailure: (code, detail) => {
         this.markFailed(code === "journal" ? "local-mirror-failed" : "remote-apply-failed", detail);
       },
@@ -1566,8 +1554,21 @@ var DocxCollaborationSession = class {
   }
   /** Transport hook: call before integrating inbound Yjs data so queued local edits are mirrored first. */
   beforeRemote() {
+    this.inputFlush?.();
     this.sync?.beforeRemote();
   }
+  /**
+   * Bind the editor's pending-input flush (`PaginatedSurface.flushPendingInput`). The session writes
+   * below the editor's input buffer, so it lands queued typing before a remote change and lays the
+   * change out right after it: the editor carries its caret at that layout, and a keystroke before
+   * it would otherwise use the caret from before the change. Returns the unbind function.
+   */
+  bindEditorInput(flush) {
+    this.inputFlush = flush;
+    return () => {
+      if (this.inputFlush === flush) this.inputFlush = null;
+    };
+  }
   // ── Undo ─────────────────────────────────────────────────────────────────
   canUndo() {
     return this.undoManager.undoStack.length > 0;
@@ -1580,7 +1581,6 @@ var DocxCollaborationSession = class {
     if (this.gateOperations() !== null || !this.canUndo()) return false;
     this.undoManager.stopCapturing();
     this.undoManager.undo();
-    this.sync?.flushRemote();
     return true;
   }
   redo() {
@@ -1588,13 +1588,79 @@ var DocxCollaborationSession = class {
     if (this.gateOperations() !== null || !this.canRedo()) return false;
     this.undoManager.stopCapturing();
     this.undoManager.redo();
-    this.sync?.flushRemote();
     return true;
   }
   // ── Presence ─────────────────────────────────────────────────────────────
   setLocalSelection(selection) {
+    this.carried = selection && selection.kind !== "cells" ? { from: null, selection } : null;
+    this.selectionMove = null;
     this.awareness.setLocalStateField("selection", selection);
   }
+  /** Where the last remote change carried the local selection; see `carrySelection`. */
+  remoteSelectionMove() {
+    return this.selectionMove;
+  }
+  /**
+   * Called before a remote change reaches the port: notes the selection's paragraphs and their text,
+   * and returns what carries it across the change once the port holds the new tree. The editor
+   * takes the carried selection when a local edit was coalesced with the remote change, where it
+   * cannot map its caret by the text alone. Several remote changes before the editor publishes its
+   * selection again chain, all from the selection it published.
+   */
+  carrySelection() {
+    const port = this.port;
+    const carried = this.carried;
+    const settle = () => this.inputFlush?.();
+    if (!port || !carried) return settle;
+    const before = (address) => {
+      const paragraph = port.paragraphByStableId(address.paragraphId);
+      if (!paragraph) return null;
+      const offset = Math.min(address.offset, paragraph.text.length);
+      return { nodeId: paragraph.nodeId, text: paragraph.text, offset };
+    };
+    const anchor = before(carried.selection.anchor);
+    const head = before(carried.selection.head);
+    if (!anchor || !head) {
+      this.carried = null;
+      this.selectionMove = null;
+      return settle;
+    }
+    const from = carried.from ?? {
+      anchor: { nodeId: anchor.nodeId, offset: anchor.offset },
+      head: { nodeId: head.nodeId, offset: head.offset }
+    };
+    return () => {
+      const after = (address, was) => {
+        const paragraph = port.paragraphByStableId(address.paragraphId);
+        if (!paragraph) return null;
+        const offset = replication.mapOffsetAcrossText(was.offset, was.text, paragraph.text);
+        return { paragraphId: address.paragraphId, nodeId: paragraph.nodeId, offset };
+      };
+      const nextAnchor = after(carried.selection.anchor, anchor);
+      const nextHead = after(carried.selection.head, head);
+      if (!nextAnchor || !nextHead) {
+        this.carried = null;
+        this.selectionMove = null;
+      } else {
+        this.carried = {
+          from,
+          selection: {
+            ...carried.selection,
+            anchor: { paragraphId: nextAnchor.paragraphId, offset: nextAnchor.offset },
+            head: { paragraphId: nextHead.paragraphId, offset: nextHead.offset }
+          }
+        };
+        this.selectionMove = {
+          from,
+          to: {
+            anchor: { nodeId: nextAnchor.nodeId, offset: nextAnchor.offset },
+            head: { nodeId: nextHead.nodeId, offset: nextHead.offset }
+          }
+        };
+      }
+      settle();
+    };
+  }
   participants() {
     return this.participantsCache;
   }
@@ -1666,6 +1732,7 @@ var DocxCollaborationSession = class {
     this.sync?.destroy();
     this.sync = void 0;
     this.port = void 0;
+    this.inputFlush = null;
     this.undoManager.destroy();
     this.awareness.setLocalState(null);
     for (const dispose of this.disposers.splice(0)) dispose();