@ai-matrx/office 0.8.26 → 0.8.28

package/CHANGELOG.md

@@ -1,6 +1,35 @@
 # Changelog
 
+## 0.8.28
+
+UNVERIFIED: this release has no Unreleased entry and the source comparison could not be made (the caller supplied no source comparison). Whether source changed is unknown; consumer action is unknown.
+Check the package's gitHead on npm against this version's gitHead: `git diff <previous gitHead> <this gitHead> -- apps/shared/office/src`.
+
 ## 0.8.26
+
+SOURCE CHANGED WITH NO RELEASE NOTE. This release shipped source changes that nobody described in an Unreleased entry,
+so they may include breaking API changes. Consumer action is UNKNOWN: read the diff before upgrading.
+Diff: `git diff 4c54b44dc8 5f2e7d1bcc -- apps/shared/office/src`
+
+Changed shipped source files (4):
+- `apps/shared/office/src/docs/document-service.ts`
+- `apps/shared/office/src/docs/ports.ts`
+- `apps/shared/office/src/sheets/ports.ts`
+- `apps/shared/office/src/sheets/workbook-service.ts`
+
+## 0.8.25
+
+SOURCE CHANGED WITH NO RELEASE NOTE. This release shipped source changes that nobody described in an Unreleased entry,
+so they may include breaking API changes. Consumer action is UNKNOWN: read the diff before upgrading.
+Diff: `git diff 766ad5513a 4c54b44dc8 -- apps/shared/office/src`
+
+Changed shipped source files (4):
+- `apps/shared/office/src/collab/sheets/transform/fuzz/seats.ts`
+- `apps/shared/office/src/univer/collab/fold/fold.ts`
+- `apps/shared/office/src/univer/collab/sheets-ot/room.ts`
+- `apps/shared/office/src/univer/collab/sheets-ot/univer-port.ts`
+
+## 0.8.24
 ### 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/collab-sheets-transform.cjs

@@ -155,16 +155,17 @@ var SHEET_MUTATIONS = {
   "formula.mutation.remove-super-table": barrier("C5c", "table names in structured references belong to tables (C5c)"),
   "formula.mutation.set-super-table-option": barrier("C5c", "table names in structured references belong to tables (C5c)"),
   // ── barriers until C5c (ranged resources) ────────────────────────────────────────────────────────
-  "sheet.mutation.add-conditional-rule": barrier("C5c", RESOURCE),
-  "sheet.mutation.set-conditional-rule": barrier("C5c", RESOURCE),
-  "sheet.mutation.delete-conditional-rule": barrier("C5c", RESOURCE),
+  // ── covered (C5d): ranged resources, transformed by ranged-resources.ts ──
+  "sheet.mutation.add-conditional-rule": covered("cf", "rule", "derived"),
+  "sheet.mutation.set-conditional-rule": covered("cf", "cfId", "rule", "derived"),
+  "sheet.mutation.delete-conditional-rule": covered("cf", "cfId", "derived"),
   "sheet.mutation.move-conditional-rule": barrier("C5c", "conditional-format priority (ordered list)"),
-  "data-validation.mutation.addRule": barrier("C5c", RESOURCE),
-  "data-validation.mutation.updateRule": barrier("C5c", RESOURCE),
-  "data-validation.mutation.removeRule": barrier("C5c", RESOURCE),
-  "sheet.mutation.set-filter-range": barrier("C5c", RESOURCE),
-  "sheet.mutation.set-filter-criteria": barrier("C5c", RESOURCE),
-  "sheet.mutation.remove-filter": barrier("C5c", RESOURCE),
+  "data-validation.mutation.addRule": covered("dv", "rule", "index", "source", "derived"),
+  "data-validation.mutation.updateRule": covered("dv", "ruleId", "payload", "source", "derived"),
+  "data-validation.mutation.removeRule": covered("dv", "ruleId", "source", "derived"),
+  "sheet.mutation.set-filter-range": covered("filter", "range", "derived"),
+  "sheet.mutation.set-filter-criteria": covered("filter", "col", "criteria", "reCalc", "derived"),
+  "sheet.mutation.remove-filter": covered("filter", "derived"),
   "sheet.mutation.add-table": barrier("C5c", RESOURCE),
   "sheet.mutation.delete-table": barrier("C5c", RESOURCE),
   "sheet.mutation.set-sheet-table": barrier("C5c", RESOURCE),
@@ -497,6 +498,9 @@ function rewriteFormula(text, ctx, change) {
     if (change.kind === "rename") {
       if (!sheetName) continue;
       token = (0, import_engine_formula.serializeRangeToRefString)({ range, sheetName: change.name, unitId });
+    } else if (change.kind === "remove-sheet") {
+      if (!sheetName) continue;
+      token = REF_ERROR;
     } else {
       const moved = moveRange(import_core.Rectangle.moveOffset(range, 0, 0), change.axis, change.op);
       if (moved === void 0) continue;
@@ -515,6 +519,10 @@ function rewriteFormula(text, ctx, change) {
   return { text: out, changed: out !== text };
 }
 function refSheetsAfter(refSheets, change) {
+  if (change.kind === "remove-sheet" && refSheets) {
+    if (!Object.values(refSheets).includes(change.sheet)) return refSheets;
+    return Object.fromEntries(Object.entries(refSheets).map(([n, id]) => [n, id === change.sheet ? null : id]));
+  }
   if (change.kind !== "rename" || !refSheets) return refSheets;
   const entries = Object.entries(refSheets);
   if (!entries.some(([name, id]) => id === change.sheet || name === change.name)) return refSheets;
@@ -598,8 +606,111 @@ function transformCommentAnchor(x, y, side) {
   return ok([moved === cell ? x : { id: x.id, params: { ...x.params, cell: moved } }]);
 }
 
+// src/collab/sheets/transform/ranged-resources.ts
+var specs = /* @__PURE__ */ new Map();
+var byId = /* @__PURE__ */ new Map();
+function registerRangedResource(spec) {
+  specs.set(spec.family, spec);
+  for (const id of Object.keys(spec.ids)) byId.set(id, spec);
+}
+var rangedSpecOf = (id) => byId.get(id);
+var cfRule = (m) => m.params.rule ?? {};
+var CF_FORMULA = (r) => {
+  const rule = r.rule ?? {};
+  if (rule.type === "highlightCell" && rule.subType === "formula") return true;
+  return JSON.stringify(rule).includes('"type":"formula"');
+};
+registerRangedResource({
+  family: "cf",
+  ids: { "sheet.mutation.add-conditional-rule": "add", "sheet.mutation.set-conditional-rule": "set", "sheet.mutation.delete-conditional-rule": "remove" },
+  keys: (m) => [String(m.id === "sheet.mutation.add-conditional-rule" ? cfRule(m).cfId : m.params.cfId)],
+  rects: (m) => cfRule(m).ranges ?? null,
+  withRects: (m, rects) => ({ id: m.id, params: { ...m.params, rule: { ...cfRule(m), ranges: rects } } }),
+  setFor: (m, rects) => ({
+    id: "sheet.mutation.set-conditional-rule",
+    params: { subUnitId: m.params.subUnitId, cfId: cfRule(m).cfId ?? m.params.cfId, rule: { ...cfRule(m), ranges: rects }, derived: true }
+  }),
+  removeOf: (sheet, key) => ({ id: "sheet.mutation.delete-conditional-rule", params: { subUnitId: sheet, cfId: key, derived: true } }),
+  hasFormula: (m) => CF_FORMULA(cfRule(m)),
+  orderedAdds: true
+});
+var DV = { add: "data-validation.mutation.addRule", update: "data-validation.mutation.updateRule", remove: "data-validation.mutation.removeRule" };
+var DV_RANGE = 1;
+var DV_FACETS = { 0: "setting", 1: "range", 2: "options", 3: "all" };
+var dvPayload = (m) => m.params.payload ?? {};
+var dvFormula = (o) => !!o && [o.formula1, o.formula2].some((f) => typeof f === "string" && f.trim().startsWith("="));
+registerRangedResource({
+  family: "dv",
+  ids: { [DV.add]: "add", [DV.update]: "set", [DV.remove]: "remove" },
+  keys: (m) => {
+    if (m.id === DV.add) return [String((m.params.rule ?? {}).uid)];
+    const id = m.params.ruleId;
+    return Array.isArray(id) ? id.map(String) : [String(id)];
+  },
+  facet: (m) => m.id === DV.update ? DV_FACETS[Number(dvPayload(m).type)] ?? "all" : "all",
+  rects: (m) => {
+    if (m.id === DV.add) return m.params.rule?.ranges ?? null;
+    if (m.id === DV.update && dvPayload(m).type === DV_RANGE) return dvPayload(m).payload ?? null;
+    if (m.id === DV.update && dvPayload(m).type === 3) return (dvPayload(m).payload ?? {}).ranges ?? null;
+    return null;
+  },
+  withRects: (m, rects) => {
+    if (m.id === DV.add) return { id: m.id, params: { ...m.params, rule: { ...m.params.rule, ranges: rects } } };
+    const p = dvPayload(m);
+    return { id: m.id, params: { ...m.params, payload: p.type === DV_RANGE ? { ...p, payload: rects } : { ...p, payload: { ...p.payload, ranges: rects } } } };
+  },
+  setFor: (m, rects) => ({
+    id: DV.update,
+    params: { subUnitId: m.params.subUnitId, ruleId: m.id === DV.add ? (m.params.rule ?? {}).uid : m.params.ruleId, payload: { type: DV_RANGE, payload: rects }, derived: true }
+  }),
+  removeOf: (sheet, key) => ({ id: DV.remove, params: { subUnitId: sheet, ruleId: key, derived: true } }),
+  withoutKeys: (m, keys) => {
+    const left = (Array.isArray(m.params.ruleId) ? m.params.ruleId : [m.params.ruleId]).filter((k) => !keys.includes(String(k)));
+    return left.length ? { id: m.id, params: { ...m.params, ruleId: Array.isArray(m.params.ruleId) ? left : left[0] } } : null;
+  },
+  hasFormula: (m) => {
+    if (m.id === DV.add) return dvFormula(m.params.rule);
+    const p = dvPayload(m);
+    return p.type === 0 || p.type === 3 ? dvFormula(p.payload) : false;
+  },
+  orderedAdds: true,
+  // an ALL update (the ref-range handler restates the whole rule) losing to a setting/options change keeps its ranges
+  narrow: (m, lost) => {
+    if (m.id !== DV.update || dvPayload(m).type !== 3 || lost === "range") return null;
+    const ranges = (dvPayload(m).payload ?? {}).ranges;
+    return Array.isArray(ranges) ? { id: m.id, params: { ...m.params, payload: { type: DV_RANGE, payload: ranges } } } : null;
+  }
+});
+var FILTER = { range: "sheet.mutation.set-filter-range", criteria: "sheet.mutation.set-filter-criteria", remove: "sheet.mutation.remove-filter" };
+var hull = (rects) => ({
+  startRow: Math.min(...rects.map((r) => r.startRow)),
+  endRow: Math.max(...rects.map((r) => r.endRow)),
+  startColumn: Math.min(...rects.map((r) => r.startColumn)),
+  endColumn: Math.max(...rects.map((r) => r.endColumn))
+});
+var filterWith = (m, rects) => m.id === FILTER.range ? { id: m.id, params: { ...m.params, range: hull(rects) } } : { id: m.id, params: { ...m.params, col: rects[0].startColumn } };
+var colRect = (col) => ({ startRow: 0, endRow: 1e9, startColumn: col, endColumn: col });
+registerRangedResource({
+  family: "filter",
+  ids: { [FILTER.range]: "set", [FILTER.criteria]: "set", [FILTER.remove]: "remove" },
+  keys: () => ["filter"],
+  facet: (m) => m.id === FILTER.criteria ? `col:${String(m.params.col)}` : "range",
+  rects: (m) => m.id === FILTER.range ? [m.params.range] : m.id === FILTER.criteria ? [colRect(Number(m.params.col))] : null,
+  withRects: (m, rects) => filterWith(m, rects),
+  setFor: (m, rects) => {
+    const f = filterWith(m, rects);
+    return { id: f.id, params: { ...f.params, derived: true } };
+  },
+  removeOf: (sheet) => ({ id: FILTER.remove, params: { subUnitId: sheet, derived: true } }),
+  /** a criteria column that was removed takes only its criteria with it, never the filter */
+  emptyDrops: (m) => m.id === FILTER.criteria,
+  // a column move can carry a criteria column out of the filter's range (the model refuses it): not yet
+  // where a criteria column lands depends on how the filter's own range moved (Univer's rule at its edges): not yet
+  barrierOver: (m, axis) => m.id === FILTER.criteria && axis === "col" ? "filter: a column's criteria against a column insert, remove or move" : null
+});
+
 // src/collab/sheets/transform/transform.ts
-var SHEET_TRANSFORMER_VERSION = "c5c-1";
+var SHEET_TRANSFORMER_VERSION = "c5d-1";
 var ID = {
   values: "sheet.mutation.set-range-values",
   insertRow: "sheet.mutation.insert-row",
@@ -1374,19 +1485,44 @@ function sheetPair(x, y, side) {
   if (ys) {
     if (y.id !== ID.removeSheet) return ok2([x]);
     const gone2 = sheetOf(y);
-    if (namesSheet(x, gone2)) return barrier2("a formula names a sheet removed at the same time");
     if (sheetOf(x) === gone2 && x.id !== ID.setName && x.id !== ID.removeName)
       return ok2([], [], isDerived(x) ? [] : [`${gone2}: the sheet was removed`]);
+    if (namesSheet(x, gone2)) {
+      const ch = { kind: "remove-sheet", sheet: gone2 };
+      if (x.id === ID.values) return cellsOverChange(x, ch);
+      const r = definedNameThrough(x, ch);
+      return typeof r === "string" ? barrier2(r) : ok2([r.op]);
+    }
     return ok2([x]);
   }
   if (x.id !== ID.removeSheet) return ok2([x]);
   const gone = sheetOf(x);
-  if (namesSheet(y, gone)) return barrier2("a formula names a sheet removed at the same time");
-  return ok2([x], sheetOf(y) === gone && !isDerived(y) && y.id !== ID.setName && y.id !== ID.removeName ? [`${gone}: the sheet was removed`] : []);
+  const ry = rangedSpecOf(y.id);
+  if (ry && sheetOf(y) === gone && ry.ids[y.id] !== "remove")
+    return ok2([...ry.keys(y).map((k) => ({ id: ry.removeOf(gone, k).id, params: { ...ry.removeOf(gone, k).params } })), x]);
+  const lost = sheetOf(y) === gone && !isDerived(y) && y.id !== ID.setName && y.id !== ID.removeName ? [`${gone}: the sheet was removed`] : [];
+  if (sheetOf(y) !== gone && namesSheet(y, gone)) {
+    const ch = { kind: "remove-sheet", sheet: gone };
+    if (y.id === ID.values) {
+      const add = rewritesOf(y, ch);
+      if (typeof add === "string") return barrier2(add);
+      return ok2(add ? [x, add] : [x], lost);
+    }
+    const r = definedNameThrough(y, ch);
+    if (typeof r === "string") return barrier2(r);
+    return ok2(r.changed ? [x, asDerived(r.op)] : [x], lost);
+  }
+  return ok2([x], lost);
 }
 function annotateSheetOps(group, sheetOrder) {
+  return cleanupsBeforeSheetRemoval(annotateSheetOpsInOrder(group, sheetOrder));
+}
+function annotateSheetOpsInOrder(group, sheetOrder) {
   const order = [...sheetOrder];
-  return group.map((m) => {
+  let structural = false;
+  return group.map((m0) => {
+    if (structuralOf(m0)) structural = true;
+    const m = structural && rangedSpecOf(m0.id) && !isDerived(m0) ? { id: m0.id, params: { ...m0.params, derived: true } } : m0;
     if (m.id === ID.insertSheet) {
       const index = typeof m.params.index === "number" ? Math.min(m.params.index, order.length) : order.length;
       order.splice(index, 0, sheetIdOf(m));
@@ -1405,6 +1541,16 @@ function annotateSheetOps(group, sheetOrder) {
     return m;
   });
 }
+function cleanupsBeforeSheetRemoval(group) {
+  const at = group.findIndex((m) => m.id === ID.removeSheet);
+  if (at < 0) return group;
+  const gone = sheetOf(group[at]);
+  const moved = group.filter((m, k2) => k2 > at && rangedSpecOf(m.id) && sheetOf(m) === gone);
+  if (!moved.length) return group;
+  const rest = group.filter((m) => !moved.includes(m));
+  const k = rest.indexOf(group[at]);
+  return [...rest.slice(0, k), ...moved, ...rest.slice(k)];
+}
 function inlineSheetStyles(sheet, styleOf) {
   const out = JSON.parse(JSON.stringify(sheet));
   const fix = (o) => {
@@ -1534,6 +1680,59 @@ function sortPair(x, y, sx, sy) {
   }
   return ok2([x]);
 }
+function rangedPair(x, y, side, sx, sy) {
+  const px = rangedSpecOf(x.id);
+  const py = rangedSpecOf(y.id);
+  if (!px && !py) return null;
+  const told = (m, what) => isDerived(m) ? [] : [`${sheetOf(m)}: ${what}`];
+  if (px && sy) {
+    const role = px.ids[x.id];
+    const rects = role === "remove" ? null : px.rects(x);
+    if (!rects) return ok2([x]);
+    const why = px.barrierOver?.(x, sy.axis, sy.op.kind);
+    if (why) return barrier2(why);
+    if (px.hasFormula?.(x)) return barrier2(`${px.family}: a rule with formula text against a row or column change (its formulas do not move yet)`);
+    const moved = rectsThrough(sy, rects);
+    if (moved.length) return ok2([px.withRects(x, moved)]);
+    if (role === "add" || px.emptyDrops?.(x)) return ok2([], [], told(x, `${px.family} ${px.keys(x).join(",")}: its cells were removed`));
+    return ok2(px.keys(x).map((k) => px.removeOf(sheetOf(x), k)), [], told(x, `${px.family} ${px.keys(x).join(",")}: its cells were removed`));
+  }
+  if (py && sx) {
+    const role = py.ids[y.id];
+    const rects = role === "remove" ? null : py.rects(y);
+    if (!rects) return ok2([x]);
+    const why = py.barrierOver?.(y, sx.axis, sx.op.kind);
+    if (why) return barrier2(why);
+    if (py.hasFormula?.(y)) return barrier2(`${py.family}: a rule with formula text against a row or column change (its formulas do not move yet)`);
+    const moved = rectsThrough(sx, rects);
+    if (!moved.length && py.emptyDrops?.(y)) return ok2([x], told(y, `${py.family} ${py.keys(y).join(",")}: its cells were removed`));
+    return ok2([x, ...moved.length ? [py.setFor(y, moved)] : py.keys(y).map((k) => py.removeOf(sheetOf(y), k))], moved.length ? [] : told(y, `${py.family} ${py.keys(y).join(",")}: its cells were removed`));
+  }
+  if (!px || !py || px !== py) return ok2([x]);
+  const rx = px.ids[x.id];
+  const ry = py.ids[y.id];
+  const ky = py.keys(y);
+  const common = px.keys(x).filter((k) => ky.includes(k));
+  if (!common.length) {
+    if (rx === "add" && ry === "add" && px.orderedAdds) return barrier2(`${px.family}: two added to one sheet at once (their order is state)`);
+    return ok2([x]);
+  }
+  if (rx === "remove") {
+    if (ry !== "remove") return ok2([x]);
+    const rest = px.withoutKeys ? px.withoutKeys(x, common) : null;
+    return ok2(rest ? [rest] : []);
+  }
+  if (ry === "remove") return ok2([], [], told(x, `${px.family} ${common.join(",")}: removed at the same time`));
+  const fx = px.facet?.(x) ?? "all";
+  const fy = py.facet?.(y) ?? "all";
+  if (fx !== fy && fx !== "all" && fy !== "all") return ok2([x]);
+  const dx = isDerived(x);
+  const dy = isDerived(y);
+  const xWins = dx !== dy ? !dx : side === "left";
+  if (xWins) return ok2([x], told(y, `${py.family} ${common.join(",")}`));
+  const narrowed = fx === "all" && fy !== "all" ? px.narrow?.(x, fy) : null;
+  return ok2(narrowed ? [narrowed] : [], [], told(x, `${px.family} ${common.join(",")}`));
+}
 function familyOf(id) {
   const e = SHEET_MUTATIONS[id];
   return e && e.kind === "covered" ? e.family : "";
@@ -1561,6 +1760,8 @@ function transformMutation(x, y, side) {
   const fy = familyOf(y.id);
   const sy = structuralOf(y);
   const sx = structuralOf(x);
+  const rp = rangedPair(x, y, side, sx, sy);
+  if (rp) return rp;
   const sortp = sortPair(x, y, sx, sy);
   if (sortp) return sortp;
   const cp = countPair(x, y, sy);