@ai-matrx/office 0.8.24 → 0.8.25

package/dist/univer-collab.d.cts

@@ -605,6 +605,12 @@ interface SheetsOtPort {
         service: unknown;
         unitId: string;
     }>;
+    /**
+     * Run `fn` right before this seat takes an undo or redo (synchronously, before the command reads its stack). With
+     * it the room rebases the undo stack lazily: a remote op only queues, and an undo catches its stack up first.
+     * Without it every remote op rebases the whole stack at once.
+     */
+    beforeUndo?(fn: () => void): () => void;
     /** Ask for a save (the record's one coalesced save). */
     markDirty(): void;
 }
@@ -657,6 +663,8 @@ declare function rebaseSheetUndoStack(items: UndoItem[], remote: SheetOp, unitId
 interface SheetsOtAdapterHooks {
     /** Called once per applied remote op that rebased this seat's undo stacks (for tests and logs). */
     onUndoRebased?: (dropped: number) => void;
+    /** Called with the milliseconds of undo bookkeeping each remote op (and each catch-up) cost (tests, logs). */
+    onUndoWork?: (ms: number, kind: "remote" | "catch_up") => void;
     /**
      * The state hash of a snapshot (default `sheetsStateHash`, Web Crypto). A seeded test passes a synchronous one:
      * Web Crypto resolves on a worker thread, outside a virtual clock, so the same seed would not replay.

package/dist/univer-collab.d.ts

@@ -605,6 +605,12 @@ interface SheetsOtPort {
         service: unknown;
         unitId: string;
     }>;
+    /**
+     * Run `fn` right before this seat takes an undo or redo (synchronously, before the command reads its stack). With
+     * it the room rebases the undo stack lazily: a remote op only queues, and an undo catches its stack up first.
+     * Without it every remote op rebases the whole stack at once.
+     */
+    beforeUndo?(fn: () => void): () => void;
     /** Ask for a save (the record's one coalesced save). */
     markDirty(): void;
 }
@@ -657,6 +663,8 @@ declare function rebaseSheetUndoStack(items: UndoItem[], remote: SheetOp, unitId
 interface SheetsOtAdapterHooks {
     /** Called once per applied remote op that rebased this seat's undo stacks (for tests and logs). */
     onUndoRebased?: (dropped: number) => void;
+    /** Called with the milliseconds of undo bookkeeping each remote op (and each catch-up) cost (tests, logs). */
+    onUndoWork?: (ms: number, kind: "remote" | "catch_up") => void;
     /**
      * The state hash of a snapshot (default `sheetsStateHash`, Web Crypto). A seeded test passes a synchronous one:
      * Web Crypto resolves on a worker thread, outside a virtual clock, so the same seed would not replay.

package/dist/univer-collab.js

@@ -3500,17 +3500,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();
   };
@@ -3548,6 +3596,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() {
@@ -3735,6 +3786,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) => {
@@ -3744,6 +3797,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() };
@@ -3800,6 +3854,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);
@@ -4057,8 +4112,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();