@ai-matrx/office 0.8.12 → 0.8.13

package/dist/univer-collab.cjs

@@ -53,6 +53,7 @@ __export(collab_exports, {
   normalizeDocsOp: () => normalizeDocsOp,
   openDocsOtRoom: () => openDocsOtRoom,
   rebaseUndoStack: () => rebaseUndoStack,
+  restoreDocumentSnapshot: () => restoreDocumentSnapshot,
   stampCovered: () => stampCovered,
   stampDeterministicIds: () => stampDeterministicIds,
   stripSenderView: () => stripSenderView,
@@ -963,10 +964,10 @@ function canonicalRuns(runs) {
   }
   return out;
 }
-function foldPieces(items, keyOf) {
+function foldPieces(items, keyOf2) {
   const groups = /* @__PURE__ */ new Map();
   for (const it of items ?? []) {
-    const k = keyOf(it);
+    const k = keyOf2(it);
     const g = groups.get(k) ?? [];
     g.push(it);
     groups.set(k, g);
@@ -1277,6 +1278,120 @@ var Y2 = __toESM(require("yjs"), 1);
 var import_awareness2 = require("y-protocols/awareness");
 var import_collab3 = require("@ai-matrx/data/realtime/collab");
 
+// src/docs/document-model.ts
+var import_core2 = require("@univerjs/core");
+
+// src/univer/openEditorContent.ts
+var replacers = /* @__PURE__ */ new Map();
+var keyOf = (kind, recordId) => `${kind}:${recordId}`;
+function hasOpenEditorContent(kind, recordId) {
+  return replacers.has(keyOf(kind, recordId));
+}
+async function showSavedSnapshot(kind, recordId, row) {
+  const replace = replacers.get(keyOf(kind, recordId));
+  if (!replace) return false;
+  await replace(row);
+  return true;
+}
+
+// src/docs/document-model.ts
+function moveRangesThroughBodyEdit(ranges, actions) {
+  const a = actions;
+  if (!Array.isArray(a) || a[0] !== "body") return null;
+  const sub = a[1];
+  if (!sub || sub.et !== "text-x" || !Array.isArray(sub.e)) return null;
+  const e = sub.e;
+  return ranges.map((r) => {
+    const collapsed = r.startOffset === r.endOffset;
+    const startOffset = import_core2.TextX.transformPosition(e, r.startOffset, collapsed);
+    return { startOffset, endOffset: collapsed ? startOffset : import_core2.TextX.transformPosition(e, r.endOffset, true) };
+  });
+}
+
+// src/docs/remote-carets.ts
+var CARET_HEARTBEAT_MS = 2e3;
+var CARET_STALE_MS = 12e3;
+var CARET_MAX_RANGES = 4;
+function publishedCaretFromSelection(sel, now) {
+  if (!sel || sel.length === 0) return null;
+  if (sel.some((r) => r.segmentId)) return null;
+  const ranges = sel.slice(0, CARET_MAX_RANGES).map((r) => ({ start: Math.min(r.startOffset, r.endOffset), end: Math.max(r.startOffset, r.endOffset) }));
+  return { ranges, at: now };
+}
+var sameRanges = (a, b) => a.length === b.length && a.every((r, i) => r.start === b[i].start && r.end === b[i].end);
+function readCaret(raw) {
+  const c = raw?.caret;
+  if (!c || !Array.isArray(c.ranges) || typeof c.at !== "number") return null;
+  const ranges = [];
+  for (const r of c.ranges.slice(0, CARET_MAX_RANGES)) {
+    const s = r?.start;
+    const e = r?.end;
+    if (typeof s !== "number" || typeof e !== "number" || !Number.isFinite(s) || !Number.isFinite(e) || s < 0 || e < 0) return null;
+    ranges.push({ start: s, end: e });
+  }
+  return ranges.length ? { ranges, at: c.at } : null;
+}
+var RemoteCaretBook = class {
+  constructor(selfClientId, now = Date.now) {
+    this.selfClientId = selfClientId;
+    this.now = now;
+  }
+  selfClientId;
+  now;
+  carets = /* @__PURE__ */ new Map();
+  /** Take the room's awareness states: new or republished carets replace ours, seats that left are dropped. Returns whether anything changed. */
+  ingest(states) {
+    let changed = false;
+    const seen = /* @__PURE__ */ new Set();
+    states.forEach((raw, id) => {
+      if (id === this.selfClientId) return;
+      const s = raw;
+      const caret = readCaret(raw);
+      if (!s || typeof s.uid !== "string" || !caret) return;
+      const key = String(id);
+      seen.add(key);
+      const prev = this.carets.get(key);
+      const name = typeof s.name === "string" && s.name ? s.name : "Someone";
+      const color = typeof s.color === "string" && s.color ? s.color : "#3b82f6";
+      if (prev && prev.at === caret.at && prev.name === name && prev.color === color) return;
+      this.carets.set(key, { key, uid: s.uid, name, color, ranges: caret.ranges, at: caret.at, seenAt: this.now() });
+      changed = true;
+    });
+    for (const key of [...this.carets.keys()]) {
+      if (!seen.has(key)) {
+        this.carets.delete(key);
+        changed = true;
+      }
+    }
+    return changed;
+  }
+  /** Move every caret through one body edit that was just applied (`actions` of a rich-text mutation). Returns whether any moved. */
+  shiftThrough(actions) {
+    let moved = false;
+    for (const c of this.carets.values()) {
+      const next = moveRangesThroughBodyEdit(c.ranges.map((r) => ({ startOffset: r.start, endOffset: r.end })), actions);
+      if (!next) return false;
+      const ranges = next.map((r) => ({ start: r.startOffset, end: r.endOffset }));
+      if (!sameRanges(ranges, c.ranges)) {
+        c.ranges = ranges;
+        moved = true;
+      }
+    }
+    return moved;
+  }
+  /** The carets to draw now (stale ones left out). */
+  list() {
+    const t = this.now();
+    const out = [];
+    for (const c of this.carets.values()) {
+      if (t - c.seenAt > CARET_STALE_MS) continue;
+      out.push({ key: c.key, uid: c.uid, name: c.name, color: c.color, ranges: c.ranges.map((r) => ({ ...r })) });
+    }
+    out.sort((a, b) => a.key.localeCompare(b.key));
+    return out;
+  }
+};
+
 // src/docs/document-service.ts
 var import_api = require("@ai-matrx/api");
 var import_auth = require("@ai-matrx/auth");
@@ -1349,11 +1464,11 @@ function pickColor2(uid) {
   return palette[Math.abs(h) % palette.length] ?? "#ec4899";
 }
 function documentOtFactory(o) {
-  return async (port, onAwareness) => {
+  return async (basePort, onAwareness) => {
     const latest = await getLatestDocumentSnapshot(o.documentId);
     if (!latest.success) throw new Error(latest.error);
     if (!latest.data) {
-      const mounted = port.snapshot();
+      const mounted = basePort.snapshot();
       if (mounted) {
         const saved = await saveDocumentSnapshot({ documentId: o.documentId, snapshot: mounted, origin: "autosave" });
         if (!saved.success) throw new Error(saved.error);
@@ -1362,7 +1477,31 @@ function documentOtFactory(o) {
     const doc = new Y2.Doc();
     const awareness = new import_awareness2.Awareness(doc);
     awareness.setLocalState({ uid: o.uid, clientId: o.clientId, name: o.displayName ?? o.uid.slice(0, 8), color: pickColor2(o.uid), ts: Date.now() });
-    const publishAwareness = () => onAwareness({ states: new Map(awareness.getStates()), selfUid: o.uid });
+    const carets = new RemoteCaretBook(awareness.clientID);
+    const emit = () => onAwareness({ states: new Map(awareness.getStates()), selfUid: o.uid, carets: carets.list() });
+    const publishAwareness = () => {
+      carets.ingest(awareness.getStates());
+      emit();
+    };
+    const bodyActions = (params) => {
+      const p = params;
+      return p && !p.segmentId ? p.actions : void 0;
+    };
+    const port = {
+      ...basePort,
+      applyRemote(id, params) {
+        basePort.applyRemote(id, params);
+        const a = bodyActions(params);
+        if (a !== void 0 && carets.shiftThrough(a)) emit();
+      },
+      onLocal: (listener) => basePort.onLocal((m) => {
+        if (m.id === RICH_TEXT_EDITING) {
+          const a = bodyActions(m.params);
+          if (a !== void 0 && carets.shiftThrough(a)) emit();
+        }
+        listener(m);
+      })
+    };
     awareness.on("change", publishAwareness);
     const provider = new import_collab3.SupabaseYjsProvider({
       workbookId: o.documentId,
@@ -1398,11 +1537,31 @@ function documentOtFactory(o) {
       ...o.onStatus ? { onStatus: o.onStatus } : {}
     });
     await room.session.ready;
+    let lastKey = "";
+    let lastAt = 0;
+    const publishCaret = () => {
+      if (typeof document !== "undefined" && document.hidden) return;
+      let sel = null;
+      try {
+        sel = port.selection?.() ?? null;
+      } catch {
+        sel = null;
+      }
+      const t = Date.now();
+      const c = publishedCaretFromSelection(sel, t);
+      const key = c ? JSON.stringify(c.ranges) : "";
+      if (key === lastKey && (key === "" || t - lastAt < CARET_HEARTBEAT_MS)) return;
+      lastKey = key;
+      lastAt = t;
+      awareness.setLocalStateField("caret", c);
+    };
+    const caretTimer = setInterval(publishCaret, 120);
     return {
       isSaver: () => room.isSaver(),
       write: (reason) => room.write(reason),
       replace: (snapshot) => room.replace(snapshot),
       stop: () => {
+        clearInterval(caretTimer);
         room.stop();
         awareness.off("change", publishAwareness);
         provider.disconnect();
@@ -1412,4 +1571,41 @@ function documentOtFactory(o) {
     };
   };
 }
+
+// src/docs/document-restore.ts
+var import_collab4 = require("@ai-matrx/data/realtime/collab");
+var defaultDeps = {
+  client: () => getDocsHost().getSupabase(),
+  roomExists: import_collab4.collabRoomExists,
+  replace: import_collab4.collabReplace,
+  stateHash: (snapshot) => docsStateHash(snapshot),
+  hasOpenEditor: (documentId) => hasOpenEditorContent("document", documentId),
+  showInOpenEditor: (documentId, row) => showSavedSnapshot("document", documentId, row),
+  async saveRow(args) {
+    const res = await saveDocumentSnapshot({ documentId: args.documentId, snapshot: args.snapshot, origin: "restored", label: args.label });
+    if (!res.success) throw new Error(res.error);
+    return { id: res.data.id };
+  }
+};
+async function restoreDocumentSnapshot(args, deps = {}) {
+  const d = { ...defaultDeps, ...deps };
+  if (d.hasOpenEditor(args.documentId)) {
+    const row2 = await d.saveRow(args);
+    await d.showInOpenEditor(args.documentId, { id: row2.id, snapshot: args.snapshot });
+    return { via: "open_editor", snapshotId: row2.id };
+  }
+  const client = d.client();
+  if (await d.roomExists(client, args.documentId)) {
+    const next = stampDeterministicIds(structuredClone(args.snapshot ?? {}));
+    const out = await d.replace(client, {
+      roomId: args.documentId,
+      snapshot: next,
+      stateHash: await d.stateHash(next),
+      origin: "restore"
+    });
+    return { via: "room", rev: out.rev, snapshotId: out.ref };
+  }
+  const row = await d.saveRow(args);
+  return { via: "saved", snapshotId: row.id };
+}
 //# sourceMappingURL=univer-collab.cjs.map