@ai-matrx/office 0.8.53 → 0.8.55

package/CHANGELOG.md

@@ -1,10 +1,27 @@
 # Changelog
 
-## 0.8.53
+## 0.8.55
 
 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.54
+
+- `univerDocToMarkdown` now backslash-escapes typed text that a markdown reader would take for HTML (`<b>`, `<A22-klm>`) or an
+  entity (`&amp;`), so Word, HTML, EPUB, PDF, ODT and RTF downloads and print keep the text a person typed (they dropped it before).
+  A plain `<` or `&` (`A < B`, `a&b`) is untouched. Consumer action: a caller that wants the raw characters (the Google push, an agent
+  reading the passage, a source view) passes `{ escapeMarkup: false }`.
+
+## 0.8.53
+
+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 1847f8934e cd73e23915 -- apps/shared/office/src`
+
+Changed shipped source files (2):
+- `apps/shared/office/src/pdf/panels.tsx`
+- `apps/shared/office/src/pdf/ports.ts`
+
 ## 0.8.52
 
 Automatic changed-only republish (docs/metadata drift since the last published version; verified: `git diff bc6abc5d4e 1847f8934e -- apps/shared/office/src`

package/dist/collab-sheets-transform.cjs

@@ -77,6 +77,12 @@ var SHEET_MUTATIONS = {
   "sheet.mutation.set-worksheet-row-is-auto-height": covered("size", "ranges", "autoHeightInfo"),
   "sheet.mutation.set-worksheet-row-auto-height": covered("size", "rowsAutoHeightInfo"),
   "sheet.mutation.set-worksheet-col-width": covered("size", "ranges", "colWidth"),
+  // a row or column's hidden flag (`hd`): per index like a size, the later of two wins (the gate's F5: Make table
+  // hides its Record ID column, which was rolled back as "not shared" in a room)
+  "sheet.mutation.set-row-hidden": covered("size", "ranges"),
+  "sheet.mutation.set-row-visible": covered("size", "ranges"),
+  "sheet.mutation.set-col-hidden": covered("size", "ranges"),
+  "sheet.mutation.set-col-visible": covered("size", "ranges"),
   "sheet.mutation.set-worksheet-name": covered("name", "name"),
   // ── covered (C5c) ────────────────────────────────────────────────────────────────────────────────
   "sheet.mutation.set.numfmt": covered("numfmt", "values", "refMap"),
@@ -133,10 +139,6 @@ var SHEET_MUTATIONS = {
   "sheet.mutation.set-frozen": barrier("X", "absolute frozen indices: not in C5a"),
   "sheet.mutation.set-row-data": barrier("X", "row properties by index: not in C5a"),
   "sheet.mutation.set-col-data": barrier("X", "column properties by index: not in C5a"),
-  "sheet.mutation.set-row-hidden": barrier("X", "row visibility: not in C5a"),
-  "sheet.mutation.set-row-visible": barrier("X", "row visibility: not in C5a"),
-  "sheet.mutation.set-col-hidden": barrier("X", "column visibility: not in C5a"),
-  "sheet.mutation.set-col-visible": barrier("X", "column visibility: not in C5a"),
   "sheet.mutation.add-range-protection": barrier("X", "permissions: not in C5a"),
   "sheet.mutation.set-range-protection": barrier("X", "permissions: not in C5a"),
   "sheet.mutation.delete-range-protection": barrier("X", "permissions: not in C5a"),
@@ -808,6 +810,10 @@ var ID = {
   rowIsAuto: "sheet.mutation.set-worksheet-row-is-auto-height",
   rowAutoHeight: "sheet.mutation.set-worksheet-row-auto-height",
   colWidth: "sheet.mutation.set-worksheet-col-width",
+  colHidden: "sheet.mutation.set-col-hidden",
+  colVisible: "sheet.mutation.set-col-visible",
+  rowHidden: "sheet.mutation.set-row-hidden",
+  rowVisible: "sheet.mutation.set-row-visible",
   name: "sheet.mutation.set-worksheet-name",
   setName: "formula.mutation.set-defined-name",
   removeName: "formula.mutation.remove-defined-name",
@@ -1106,7 +1112,8 @@ function transformCell(X, Y, side) {
       out.s = { ...outS && typeof outS === "object" ? outS : {}, n: null };
     } else if (side === "right" && outS && typeof outS === "object" && "n" in outS) {
       const rest = withoutStyleKeys(outS, /* @__PURE__ */ new Set(["n"]));
-      if (rest) out.s = rest;
+      if (!has(Y.s) && Y.s !== null) out.s = { ...rest ?? {}, n: null };
+      else if (rest) out.s = rest;
       else delete out.s;
       xLost = true;
     }
@@ -1144,6 +1151,34 @@ function transformCellsOverCells(x, y, side) {
   const op = passes.filter((p) => !isEmptyMatrix(p)).map((p) => cellsMutation(x, p));
   return ok2(op, lost, dropped);
 }
+var coveredByMerge = (ranges, r, c) => ranges.some((q) => q.startRow <= r && r <= q.endRow && q.startColumn <= c && c <= q.endColumn && !(r === q.startRow && c === q.startColumn));
+var EMPTY_CONTENT = Object.fromEntries(CONTENT_KEYS.filter((k) => k !== "t").map((k) => [k, null]));
+function valuesUnderMerge(x, y) {
+  const ranges = mergeRanges(y);
+  const out = {};
+  const dropped = [];
+  let changed = false;
+  forEachCell(cellsOf(x), (r, c, v) => {
+    if (v === null || !hasContent(v) || !coveredByMerge(ranges, r, c)) return putCell(out, r, c, v);
+    changed = true;
+    if (!isDerived(x)) dropped.push(cellRef(sheetOf(x), r, c));
+    if ("s" in v) putCell(out, r, c, { s: v.s });
+  });
+  if (!changed) return ok2([x]);
+  return ok2(isEmptyMatrix(out) ? [] : [cellsMutation(x, out)], [], dropped);
+}
+function mergeOverValues(x, y) {
+  const ranges = mergeRanges(x);
+  const clear = {};
+  const lost = [];
+  forEachCell(cellsOf(y), (r, c, v) => {
+    if (v === null || !hasContent(v) || !coveredByMerge(ranges, r, c)) return;
+    putCell(clear, r, c, { ...EMPTY_CONTENT });
+    if (!isDerived(y)) lost.push(cellRef(sheetOf(y), r, c));
+  });
+  if (isEmptyMatrix(clear)) return ok2([x]);
+  return ok2([x, { id: ID.values, params: { subUnitId: sheetOf(x), cellValue: clear, derived: true } }], lost);
+}
 var SIDE_CAR_PARAMS = ["refSheets", "previousName", "derived", "sheetIndex", "sheetsLeft"];
 var isDerived = (m) => m.params.derived === true;
 function derivedSide(x, y, side) {
@@ -1360,9 +1395,21 @@ function annotateFormulas(group, sheets, definedNames) {
     return m;
   });
 }
+var HIDE_SHOW = {
+  [ID.colHidden]: { axis: "col", hidden: true },
+  [ID.colVisible]: { axis: "col", hidden: false },
+  [ID.rowHidden]: { axis: "row", hidden: true },
+  [ID.rowVisible]: { axis: "row", hidden: false }
+};
 function sizeOf(m) {
   const p = m.params;
   const values = /* @__PURE__ */ new Map();
+  const hs = HIDE_SHOW[m.id];
+  if (hs) {
+    const [a02, a12] = S(hs.axis);
+    for (const r of p.ranges ?? []) for (let i = r[a02]; i <= r[a12]; i++) values.set(i, hs.hidden);
+    return { axis: hs.axis, attr: "hd", values };
+  }
   if (m.id === ID.rowAutoHeight) {
     for (const { row, autoHeight } of p.rowsAutoHeightInfo ?? []) values.set(row, autoHeight);
     return { axis: "row", attr: "ah", values };
@@ -1382,6 +1429,12 @@ function sizeOf(m) {
 function buildSize(template, values) {
   if (values.size === 0) return null;
   const p = template.params;
+  const hs = HIDE_SHOW[template.id];
+  if (hs) {
+    const [a02, a12] = S(hs.axis);
+    const first2 = (p.ranges ?? [])[0] ?? { startRow: 0, endRow: 0, startColumn: 0, endColumn: 0 };
+    return { id: template.id, params: { ...p, ranges: runs(values.keys()).map((r) => ({ ...first2, [a02]: r.start, [a12]: r.start + r.count - 1 })) } };
+  }
   if (template.id === ID.rowAutoHeight)
     return { id: template.id, params: { ...p, rowsAutoHeightInfo: [...values].sort((a, b) => a[0] - b[0]).map(([row, autoHeight]) => ({ row, autoHeight })) } };
   const axis = template.id === ID.colWidth ? "col" : "row";
@@ -1927,6 +1980,8 @@ function transformMutation(x, y, side) {
     return ok2([...pre, x, ...mid, ...add.length ? [mergeMutation(ID.addMerge, sheet, add)] : []], lostMerges);
   }
   if (fx === "cell" && fy === "cell") return transformCellsOverCells(x, y, side);
+  if (x.id === ID.values && y.id === ID.addMerge) return valuesUnderMerge(x, y);
+  if (x.id === ID.addMerge && y.id === ID.values) return mergeOverValues(x, y);
   if (fx === "merge" && fy === "merge") {
     const xr = mergeRanges(x);
     const yr = mergeRanges(y);