@ai-matrx/office 0.8.24 → 0.8.25

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Changelog
 
-## 0.8.24
+## 0.8.25
 ### C9: comment anchors that follow concurrent edits
 
 - **Docs:** `addCommentAnchorActions(body, start, end, id)` anchors a passage with a `COMMENT` custom range (Univer's own builder, so the op has the link family's shape C0 proved); `commentAnchorsOf(body)` reads every anchor back (split pieces joined, Univer's inclusive end as `[start, end)`); `removeCommentAnchorActions` takes a cancelled draft's anchor out; `commentPartAnchor` / `anchorIdOfPartAnchor` are the thread's `part_anchor` (`anchor:<id>`, quote as `label`). Fuzz on the C0 corpora: anchor × every captured family and anchor × anchor, 0 divergences in 180,000 checks at 2,000 seeds; red check without a transform.

package/dist/univer-collab.cjs

@@ -3564,17 +3564,65 @@ function rebaseSheetUndoStack(items, remote, unitId) {
 function createSheetsOtAdapter(port, hooks = {}) {
   let queue = [];
   let draining = false;
+  const lazy = typeof port.beforeUndo === "function";
+  let pending = [];
+  let pendingBase = 0;
+  let applied = 0;
+  let currentAt = /* @__PURE__ */ new WeakMap();
+  const PENDING_CAP = 2e3;
+  const now = () => typeof performance !== "undefined" ? performance.now() : Date.now();
+  const stacksOfTargets = () => port.undoTargets().flatMap((t) => {
+    const stacks = undoStacksOf2(t.service);
+    return stacks ? [stacks.undo, stacks.redo].map((map) => ({ items: map.get(t.unitId), unitId: t.unitId, isUndo: map === stacks.undo })) : [];
+  });
+  const markNew = (items) => {
+    for (let i = items.length - 1; i >= 0 && !currentAt.has(items[i]); i--) currentAt.set(items[i], applied);
+  };
+  const catchUpItem = (item, unitId) => {
+    const from = currentAt.get(item) ?? applied;
+    for (let k = from - pendingBase; k < pending.length; k++) if (rebaseSheetUndoStack([item], pending[k], unitId) > 0) return false;
+    currentAt.set(item, applied);
+    return true;
+  };
+  const catchUp = () => {
+    if (!pending.length) return;
+    const t0 = now();
+    let dropped = 0;
+    for (const { items, unitId } of stacksOfTargets()) {
+      if (!items?.length) continue;
+      for (let i = items.length - 1; i >= 0; i--)
+        if (!catchUpItem(items[i], unitId)) {
+          items.splice(i, 1);
+          dropped++;
+        }
+    }
+    pending = [];
+    pendingBase = applied;
+    hooks.onUndoWork?.(now() - t0, "catch_up");
+    if (dropped) hooks.onUndoRebased?.(dropped);
+  };
+  if (lazy) port.beforeUndo(catchUp);
   const applyNow = (op) => {
     for (const m of op) port.applyRemote(m);
+    const t0 = now();
     let dropped = 0;
-    for (const t of port.undoTargets()) {
-      const stacks = undoStacksOf2(t.service);
-      if (!stacks) continue;
-      for (const map of [stacks.undo, stacks.redo]) {
-        const items = map.get(t.unitId);
-        if (items?.length) dropped += rebaseSheetUndoStack(items, op, t.unitId);
+    if (!lazy) {
+      for (const { items, unitId } of stacksOfTargets()) if (items?.length) dropped += rebaseSheetUndoStack(items, op, unitId);
+    } else if (!isNoopSheetOp(op)) {
+      for (const { items, unitId, isUndo } of stacksOfTargets()) {
+        if (!items?.length) continue;
+        markNew(items);
+        const top = items[items.length - 1];
+        if (isUndo && (!catchUpItem(top, unitId) || rebaseSheetUndoStack([top], op, unitId) > 0)) {
+          items.pop();
+          dropped++;
+        } else if (isUndo) currentAt.set(top, applied + 1);
       }
+      pending.push(op);
+      applied++;
+      if (pending.length > PENDING_CAP) catchUp();
     }
+    hooks.onUndoWork?.(now() - t0, "remote");
     hooks.onUndoRebased?.(dropped);
     port.markDirty();
   };
@@ -3612,6 +3660,9 @@ function createSheetsOtAdapter(port, hooks = {}) {
         stacks?.undo.delete(t.unitId);
         stacks?.redo.delete(t.unitId);
       }
+      pending = [];
+      pendingBase = applied;
+      currentAt = /* @__PURE__ */ new WeakMap();
     },
     snapshot: () => port.snapshot(),
     async hash() {
@@ -3799,6 +3850,8 @@ var REMOVE_MERGE = "sheet.mutation.remove-worksheet-merge";
 var SHEET_NAME = "sheet.mutation.set-worksheet-name";
 var INSERT_SHEET = "sheet.mutation.insert-sheet";
 var RESHAPE = /* @__PURE__ */ new Set(["sheet.mutation.set-worksheet-row-count", "sheet.mutation.set-worksheet-column-count", "sheet.mutation.remove-sheet", INSERT_SHEET]);
+var UNDO = "univer.command.undo";
+var REDO = "univer.command.redo";
 var DEPTH_GUARD = /* @__PURE__ */ Symbol.for("ai-matrx.office.sheets.command-depth-guard");
 var json = (v) => v === void 0 ? v : JSON.parse(JSON.stringify(v));
 var flagged = (options) => {
@@ -3808,6 +3861,7 @@ var flagged = (options) => {
 function univerSheetsOtPort(o) {
   const cs = o.commandService;
   const listeners = /* @__PURE__ */ new Set();
+  const undoWatchers = /* @__PURE__ */ new Set();
   const idle = [];
   const pre = /* @__PURE__ */ new WeakMap();
   const tracker = { stack: [], settle: () => settle() };
@@ -3864,6 +3918,7 @@ function univerSheetsOtPort(o) {
     if (tracker.stack.length === 0 && !group) for (const fn of idle.splice(0)) fn();
   }
   const before = cs.beforeCommandExecuted((info, options) => {
+    if (info.id === UNDO || info.id === REDO) for (const fn of [...undoWatchers]) fn();
     if (info.type === COMMAND) {
       if (tracker.stack.length === 0 && !group) group = openGroup(info.id);
       tracker.stack.push(info.id);
@@ -4121,8 +4176,13 @@ function univerSheetsOtPort(o) {
       const service = o.undoRedo?.();
       return u && service ? [{ service, unitId: u }] : [];
     },
+    beforeUndo(fn) {
+      undoWatchers.add(fn);
+      return () => void undoWatchers.delete(fn);
+    },
     markDirty: () => o.markDirty(),
     dispose() {
+      undoWatchers.clear();
       before.dispose();
       after.dispose();
       collab.dispose();