@lotics/xlsx 0.1.0

package/src/ooxml_table.ts

@@ -0,0 +1,131 @@
+// =============================================================================
+// OOXML Table Parser
+// =============================================================================
+//
+// Parses xl/tables/tableN.xml files into ParsedTable objects.
+// Structured tables in Excel define header rows, totals rows, banded styling,
+// auto-filters, and column definitions with structured references.
+// =============================================================================
+
+import type { ParsedTable, TableColumn } from "./ooxml_chart_types";
+
+// =============================================================================
+// Parser
+// =============================================================================
+
+/**
+ * Parse a table XML string into a ParsedTable object.
+ */
+export function parseTableXml(
+  xml: string,
+  parseXml: (xml: string) => Record<string, unknown>,
+): ParsedTable {
+  const doc = parseXml(xml);
+  const table = doc["table"] ?? doc;
+  const t = table as Record<string, unknown>;
+
+  const name = strAttr(t, "name") ?? "Table1";
+  const displayName = strAttr(t, "displayName") ?? name;
+  const ref = strAttr(t, "ref") ?? "A1:A1";
+
+  // Header/totals row
+  const headerRowCount = parseInt(strAttr(t, "headerRowCount") ?? "1", 10);
+  const totalsRowCount = parseInt(strAttr(t, "totalsRowCount") ?? "0", 10);
+
+  // Auto filter
+  const autoFilter = t["autoFilter"] !== undefined;
+
+  // Style
+  const tableStyleInfo = t["tableStyleInfo"];
+  let styleName: string | undefined;
+  if (tableStyleInfo && typeof tableStyleInfo === "object") {
+    const raw = (tableStyleInfo as Record<string, unknown>)["@_name"];
+    styleName = typeof raw === "string" ? raw : undefined;
+  }
+
+  // Columns
+  const columns = parseTableColumns(t);
+
+  return {
+    name,
+    displayName,
+    ref,
+    columns,
+    headerRow: headerRowCount > 0,
+    totalsRow: totalsRowCount > 0,
+    styleName,
+    autoFilter,
+  };
+}
+
+// =============================================================================
+// Column parsing
+// =============================================================================
+
+function parseTableColumns(table: Record<string, unknown>): TableColumn[] {
+  const cols: TableColumn[] = [];
+  const tableCols = table["tableColumns"];
+  if (!tableCols || typeof tableCols !== "object") return cols;
+
+  const colNodes = ensureArray((tableCols as Record<string, unknown>)["tableColumn"]);
+  for (const colNode of colNodes) {
+    if (!colNode || typeof colNode !== "object") continue;
+    const c = colNode as Record<string, unknown>;
+
+    const id = parseInt(strAttr(c, "id") ?? "0", 10);
+    const name = strAttr(c, "name") ?? `Column${id}`;
+    const totalsFunction = strAttr(c, "totalsRowFunction");
+    const rawFormula = c["totalsRowFormula"];
+    const totalsFormula = typeof rawFormula === "string" ? rawFormula : undefined;
+
+    cols.push({ id, name, totalsFunction, totalsFormula });
+  }
+
+  return cols;
+}
+
+// =============================================================================
+// Relationship helpers
+// =============================================================================
+
+/**
+ * Parse table relationships from a sheet rels file.
+ * Returns a map of rId → table path.
+ */
+export function extractTableRIds(
+  rels: Record<string, unknown>,
+): Map<string, string> {
+  const result = new Map<string, string>();
+  const relationships = rels["Relationships"];
+  if (!relationships || typeof relationships !== "object") return result;
+
+  const relNodes = ensureArray((relationships as Record<string, unknown>)["Relationship"]);
+  for (const rel of relNodes) {
+    if (!rel || typeof rel !== "object") continue;
+    const r = rel as Record<string, unknown>;
+    const type = r["@_Type"] as string | undefined;
+    if (type?.includes("/table")) {
+      const id = r["@_Id"] as string | undefined;
+      const target = r["@_Target"] as string | undefined;
+      if (id && target) {
+        result.set(id, target);
+      }
+    }
+  }
+
+  return result;
+}
+
+// =============================================================================
+// Helpers
+// =============================================================================
+
+function strAttr(obj: Record<string, unknown>, attr: string): string | undefined {
+  const val = obj[`@_${attr}`];
+  return typeof val === "string" ? val : undefined;
+}
+
+function ensureArray(val: unknown): unknown[] {
+  if (val === undefined || val === null) return [];
+  return Array.isArray(val) ? val : [val];
+}

package/src/ooxml_workbook.test.ts

@@ -0,0 +1,40 @@
+import { describe, it, expect } from "vitest";
+import { parseWorkbook } from "./ooxml_workbook";
+
+describe("parseWorkbook", () => {
+  it("reads calcPr.fullCalcOnLoad=1", () => {
+    const xml = `<?xml version="1.0" encoding="UTF-8"?>
+<workbook xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
+<sheets><sheet name="Sheet1" sheetId="1" r:id="rId1"/></sheets>
+<calcPr fullCalcOnLoad="1"/>
+</workbook>`;
+    const info = parseWorkbook(xml);
+    expect(info.fullCalcOnLoad).toBe(true);
+  });
+
+  it("treats calcPr.fullCalcOnLoad=true as truthy", () => {
+    const xml = `<?xml version="1.0" encoding="UTF-8"?>
+<workbook xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
+<sheets><sheet name="Sheet1" sheetId="1" r:id="rId1"/></sheets>
+<calcPr fullCalcOnLoad="true"/>
+</workbook>`;
+    expect(parseWorkbook(xml).fullCalcOnLoad).toBe(true);
+  });
+
+  it("defaults fullCalcOnLoad=false when calcPr is absent", () => {
+    const xml = `<?xml version="1.0" encoding="UTF-8"?>
+<workbook xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
+<sheets><sheet name="Sheet1" sheetId="1" r:id="rId1"/></sheets>
+</workbook>`;
+    expect(parseWorkbook(xml).fullCalcOnLoad).toBe(false);
+  });
+
+  it("defaults fullCalcOnLoad=false when calcPr omits the attribute", () => {
+    const xml = `<?xml version="1.0" encoding="UTF-8"?>
+<workbook xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
+<sheets><sheet name="Sheet1" sheetId="1" r:id="rId1"/></sheets>
+<calcPr calcMode="auto"/>
+</workbook>`;
+    expect(parseWorkbook(xml).fullCalcOnLoad).toBe(false);
+  });
+});

package/src/ooxml_workbook.ts

@@ -0,0 +1,259 @@
+import { XMLParser } from "fast-xml-parser";
+import type { RichTextPart, RichTextFont } from "./types";
+import type { ThemeData, OoxmlColor } from "./ooxml_color";
+import { parseColorElement, resolveColor, prefixHex } from "./ooxml_color";
+import { decodeXmlEntities } from "./xml_entities";
+
+// =============================================================================
+// Types
+// =============================================================================
+
+export interface WorkbookInfo {
+  sheets: { name: string; rId: string; state?: string }[];
+  activeSheetIndex: number;
+  date1904: boolean;
+  namedRanges: Map<string, string>;
+  /** Sheet-scoped `_xlnm.Print_Titles` raw reference strings, keyed by sheet index. */
+  printTitlesBySheet: Map<number, string>;
+  /**
+   * Excel's `<calcPr fullCalcOnLoad="1"/>` flag. When true, consumers must
+   * recompute every formula on file open — cached `<v>` values cannot be
+   * trusted. Writers set this when they can't guarantee cache freshness
+   * (e.g. our template-substitution pipeline before the formula engine
+   * was wired in, or files produced by tools that never compute).
+   */
+  fullCalcOnLoad: boolean;
+}
+
+export interface SharedStringEntry {
+  text: string;
+  richText?: RichTextPart[];
+}
+
+// =============================================================================
+// XML parser
+// =============================================================================
+
+const xmlParser = new XMLParser({
+  ignoreAttributes: false,
+  attributeNamePrefix: "@_",
+  trimValues: false,
+  processEntities: false,
+  isArray: (tagName) =>
+    tagName === "sheet" ||
+    tagName === "si" ||
+    tagName === "r" ||
+    tagName === "Relationship" ||
+    tagName === "definedName",
+});
+
+// =============================================================================
+// Workbook parsing
+// =============================================================================
+
+export function parseWorkbook(workbookXml: string): WorkbookInfo {
+  const doc = xmlParser.parse(workbookXml);
+  const wb = doc?.["workbook"];
+  if (!wb) return { sheets: [], activeSheetIndex: 0, date1904: false, namedRanges: new Map(), printTitlesBySheet: new Map(), fullCalcOnLoad: false };
+
+  // Sheets
+  const sheetsEl = wb["sheets"];
+  const sheetArr = sheetsEl?.["sheet"] as Array<Record<string, string>> | undefined;
+  const sheets = (sheetArr ?? []).map((s) => ({
+    name: decodeXmlEntities(s["@_name"] ?? "Sheet"),
+    rId: s["@_r:id"] ?? "",
+    state: s["@_state"],
+  }));
+
+  // Active sheet
+  let activeSheetIndex = 0;
+  const bookViews = wb["bookViews"];
+  if (bookViews) {
+    const wbView = bookViews["workbookView"];
+    if (wbView) {
+      const activeTab = (Array.isArray(wbView) ? wbView[0] : wbView)?.["@_activeTab"];
+      if (activeTab !== undefined) {
+        activeSheetIndex = parseInt(activeTab, 10);
+        if (isNaN(activeSheetIndex)) activeSheetIndex = 0;
+      }
+    }
+  }
+
+  // Date system
+  const wp = wb["workbookPr"];
+  const date1904 = wp?.["@_date1904"] === "1" || wp?.["@_date1904"] === "true";
+
+  // Recompute-on-load flag
+  const calcPr = wb["calcPr"] as Record<string, string> | undefined;
+  const fullCalcOnLoad = calcPr?.["@_fullCalcOnLoad"] === "1" || calcPr?.["@_fullCalcOnLoad"] === "true";
+
+  // Named ranges (definedNames) — workbook-scoped names plus sheet-scoped
+  // built-ins like `_xlnm.Print_Titles` (duplicated per sheet via localSheetId).
+  const namedRanges = new Map<string, string>();
+  const printTitlesBySheet = new Map<number, string>();
+  const defNamesEl = wb["definedNames"] as Record<string, unknown> | undefined;
+  if (defNamesEl) {
+    const raw = defNamesEl["definedName"];
+    const defArr: Array<Record<string, unknown>> = Array.isArray(raw)
+      ? (raw as Array<Record<string, unknown>>)
+      : raw && typeof raw === "object"
+        ? [raw as Record<string, unknown>]
+        : [];
+    for (const dn of defArr) {
+      const nameRaw = dn["@_name"] as string | undefined;
+      const textRaw = dn["#text"] as string | undefined;
+      if (!nameRaw || !textRaw) continue;
+      const name = decodeXmlEntities(nameRaw);
+      const text = decodeXmlEntities(textRaw);
+      const localSheetIdRaw = dn["@_localSheetId"] as string | undefined;
+      if (name === "_xlnm.Print_Titles" && localSheetIdRaw !== undefined) {
+        const idx = parseInt(localSheetIdRaw, 10);
+        if (!Number.isNaN(idx)) printTitlesBySheet.set(idx, text);
+        continue;
+      }
+      namedRanges.set(name, text);
+    }
+  }
+
+  return { sheets, activeSheetIndex, date1904, namedRanges, printTitlesBySheet, fullCalcOnLoad };
+}
+
+// =============================================================================
+// Workbook relationships
+// =============================================================================
+
+export function parseWorkbookRels(relsXml: string): Map<string, string> {
+  const doc = xmlParser.parse(relsXml);
+  const rels = doc?.["Relationships"];
+  if (!rels) return new Map();
+
+  const relArr = rels["Relationship"] as Array<Record<string, string>> | undefined;
+  if (!relArr) return new Map();
+
+  const map = new Map<string, string>();
+  for (const rel of relArr) {
+    const id = rel["@_Id"];
+    const target = rel["@_Target"];
+    if (id && target) {
+      map.set(id, decodeXmlEntities(target));
+    }
+  }
+  return map;
+}
+
+// =============================================================================
+// Shared strings
+// =============================================================================
+
+export function parseSharedStrings(
+  ssXml: string,
+  theme: ThemeData,
+  indexedColors: string[],
+): SharedStringEntry[] {
+  const doc = xmlParser.parse(ssXml);
+  const sst = doc?.["sst"];
+  if (!sst) return [];
+
+  const siArr = sst["si"] as Array<Record<string, unknown>> | undefined;
+  if (!siArr) return [];
+
+  return siArr.map((si) => parseSharedStringItem(si, theme, indexedColors));
+}
+
+function parseSharedStringItem(
+  si: Record<string, unknown>,
+  theme: ThemeData,
+  indexedColors: string[],
+): SharedStringEntry {
+  // Plain text: <si><t>text</t></si>
+  const t = si["t"];
+  if (t !== undefined) {
+    const raw = typeof t === "object" && t !== null ? (t as Record<string, string>)["#text"] ?? "" : String(t);
+    return { text: decodeXmlEntities(raw) };
+  }
+
+  // Rich text: <si><r><rPr>...</rPr><t>text</t></r>...</si>
+  const rArr = si["r"] as Array<Record<string, unknown>> | undefined;
+  if (!rArr) return { text: "" };
+
+  const parts: RichTextPart[] = [];
+  let fullText = "";
+
+  for (const run of rArr) {
+    const runT = run["t"];
+    const rawRun = typeof runT === "object" && runT !== null ? (runT as Record<string, string>)["#text"] ?? "" : String(runT ?? "");
+    const text = decodeXmlEntities(rawRun);
+    fullText += text;
+
+    const rPr = run["rPr"] as Record<string, unknown> | undefined;
+    const part: RichTextPart = { text };
+
+    if (rPr) {
+      const font = parseRichTextFont(rPr, theme, indexedColors);
+      if (font) part.font = font;
+    }
+
+    parts.push(part);
+  }
+
+  // If no runs have font properties, treat as plain text
+  const hasFormatting = parts.some((p) => p.font !== undefined);
+  if (!hasFormatting) {
+    return { text: fullText };
+  }
+
+  return { text: fullText, richText: parts };
+}
+
+function parseRichTextFont(
+  rPr: Record<string, unknown>,
+  theme: ThemeData,
+  indexedColors: string[],
+): RichTextFont | undefined {
+  const result: RichTextFont = {};
+  let hasProps = false;
+
+  if (rPr["b"] !== undefined) { result.bold = true; hasProps = true; }
+  if (rPr["i"] !== undefined) { result.italic = true; hasProps = true; }
+  if (rPr["strike"] !== undefined) { result.strike = true; hasProps = true; }
+
+  const u = rPr["u"] as Record<string, string> | string | undefined;
+  if (u !== undefined) {
+    if (typeof u === "object" && u["@_val"] === "double") {
+      result.underline = "double";
+    } else {
+      result.underline = "single";
+    }
+    hasProps = true;
+  }
+
+  const va = rPr["vertAlign"] as Record<string, string> | undefined;
+  if (va?.["@_val"] === "superscript" || va?.["@_val"] === "subscript") {
+    result.vertAlign = va["@_val"];
+    hasProps = true;
+  }
+
+  const sz = rPr["sz"] as Record<string, string> | undefined;
+  if (sz?.["@_val"]) {
+    result.size = parseFloat(sz["@_val"]);
+    hasProps = true;
+  }
+
+  const name = rPr["rFont"] as Record<string, string> | undefined;
+  if (name?.["@_val"]) {
+    result.name = name["@_val"];
+    hasProps = true;
+  }
+
+  const colorEl = rPr["color"] as Record<string, string> | undefined;
+  if (colorEl) {
+    const ooxmlColor: OoxmlColor = parseColorElement(colorEl);
+    const hex = resolveColor(ooxmlColor, theme, indexedColors, "font");
+    if (hex) {
+      result.color = prefixHex(hex);
+      hasProps = true;
+    }
+  }
+
+  return hasProps ? result : undefined;
+}

package/src/ooxml_zip.ts

@@ -0,0 +1,33 @@
+import { unzipSync } from "fflate";
+import { PasswordProtectedError } from "./types";
+
+// OLE2 Compound Document magic bytes — used by legacy .xls and encrypted .xlsx
+const OLE2_MAGIC = [0xd0, 0xcf, 0x11, 0xe0, 0xa1, 0xb1, 0x1a, 0xe1];
+
+/**
+ * Unzip an .xlsx file and return a map of entry paths to their raw bytes.
+ * Detects OLE2-encrypted files and throws PasswordProtectedError.
+ */
+export function unzipXlsx(buffer: ArrayBuffer): Record<string, Uint8Array> {
+  const bytes = new Uint8Array(buffer);
+
+  // Check for OLE2 magic (encrypted .xlsx or legacy .xls)
+  if (bytes.length >= 8 && OLE2_MAGIC.every((b, i) => bytes[i] === b)) {
+    throw new PasswordProtectedError();
+  }
+
+  try {
+    return unzipSync(bytes);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (msg.includes("encrypted") || msg.includes("password")) {
+      throw new PasswordProtectedError();
+    }
+    throw new Error(`Failed to unzip .xlsx file: ${msg}`);
+  }
+}
+
+/** Decode a Uint8Array as UTF-8 text. */
+export function decodeUtf8(bytes: Uint8Array): string {
+  return new TextDecoder("utf-8").decode(bytes);
+}

package/src/pivot_model.ts

@@ -0,0 +1,237 @@
+// =============================================================================
+// Pivot Table Model
+// =============================================================================
+//
+// Mutable counterpart of `ParsedPivotTable`. A SheetModel carries one or more
+// of these. Each model owns:
+//   - a static config (axes, fields, layout flags) the user manipulates via
+//     the editor UI
+//   - a reference to the workbook-level cache definition
+//   - a derived `result` grid produced by `recompute()`
+//
+// Recompute is intentionally pull-based and idempotent: callers run it after
+// editing the pivot config, after the source range changes, or before render.
+// The model never mutates the host sheet's cell map; the renderer reads
+// `result` directly and overlays it onto the grid.
+// =============================================================================
+
+import type { ParsedPivotCache, ParsedPivotTable } from "./ooxml_pivot_types";
+import type { WorkbookModel, SheetModel } from "./workbook_model";
+import { refToRowCol, rowColToRef } from "./excel_utils";
+import {
+  recomputePivot,
+  type PivotResultGrid,
+  type PivotSourceData,
+  type PivotSourceRecord,
+} from "./pivot_recompute";
+
+export class PivotTableModel {
+  config: ParsedPivotTable;
+  cache: ParsedPivotCache;
+  /** Last computed result, or undefined before first recompute. */
+  result: PivotResultGrid | undefined;
+
+  constructor(config: ParsedPivotTable, cache: ParsedPivotCache) {
+    this.config = config;
+    this.cache = cache;
+  }
+
+  /**
+   * Recompute the pivot result from the workbook's current source data.
+   * Callers are responsible for triggering recomputation; the model does
+   * not subscribe to workbook changes itself.
+   */
+  recompute(workbook: WorkbookModel): void {
+    const source = readSourceData(workbook, this.cache);
+    if (!source) {
+      this.result = undefined;
+      return;
+    }
+    this.result = recomputePivot(this.config, this.cache, source);
+  }
+}
+
+// =============================================================================
+// Source reader
+// =============================================================================
+
+/**
+ * Read the cache's source range into a `PivotSourceData`. Returns undefined
+ * when the source can't be resolved (external/consolidation/missing sheet).
+ *
+ * Shape: row 1 of the range = header text; rows 2..N = records.
+ */
+export function readSourceData(
+  workbook: WorkbookModel,
+  cache: ParsedPivotCache,
+): PivotSourceData | undefined {
+  if (cache.source.type !== "worksheet") return undefined;
+  const source = cache.source;
+  const sheet = workbook.sheets.find((s) => s.name === source.sheetName);
+  if (!sheet) return undefined;
+
+  const range = parseRange(source.ref);
+  if (!range) return undefined;
+
+  const header: string[] = [];
+  for (let col = range.startCol; col <= range.endCol; col++) {
+    const cell = sheet.getCell(rowColToRef(range.startRow, col));
+    header.push(formatHeader(cell?.value));
+  }
+
+  const records: PivotSourceRecord[] = [];
+  for (let row = range.startRow + 1; row <= range.endRow; row++) {
+    const rec: PivotSourceRecord = [];
+    for (let col = range.startCol; col <= range.endCol; col++) {
+      const cell = sheet.getCell(rowColToRef(row, col));
+      rec.push(coerceValue(cell?.value));
+    }
+    records.push(rec);
+  }
+
+  return { header, records };
+}
+
+function formatHeader(v: unknown): string {
+  if (v === undefined || v === null) return "";
+  return String(v);
+}
+
+function coerceValue(
+  v: unknown,
+): string | number | boolean | null | undefined {
+  if (v === undefined || v === null) return undefined;
+  if (typeof v === "string" || typeof v === "number" || typeof v === "boolean") {
+    return v;
+  }
+  return String(v);
+}
+
+interface ParsedRange {
+  startRow: number;
+  startCol: number;
+  endRow: number;
+  endCol: number;
+}
+
+function parseRange(ref: string): ParsedRange | undefined {
+  // Strip optional "Sheet!" prefix; the caller already resolved the sheet.
+  const range = ref.includes("!") ? ref.split("!")[1] : ref;
+  const cleaned = range.replace(/\$/g, "");
+  const m = cleaned.match(/^([A-Z]+\d+)(?::([A-Z]+\d+))?$/);
+  if (!m) return undefined;
+  const start = refToRowCol(m[1]);
+  if (!start) return undefined;
+  const endRef = m[2] ?? m[1];
+  const end = refToRowCol(endRef);
+  if (!end) return undefined;
+  return {
+    startRow: start.row,
+    startCol: start.col,
+    endRow: end.row,
+    endCol: end.col,
+  };
+}
+
+// =============================================================================
+// SheetModel integration
+// =============================================================================
+
+/**
+ * Whether `(row, col)` falls inside any pivot's anchor range. Used by the
+ * editing layer to block direct cell edits inside a pivot — Excel rejects
+ * such edits and so do we.
+ */
+export function pointInsideAnyPivot(
+  sheet: SheetModel,
+  row: number,
+  col: number,
+): boolean {
+  return findPivotAt(sheet, row, col) !== undefined;
+}
+
+/** Return the pivot covering `(row, col)`, or undefined if none. */
+export function findPivotAt(
+  sheet: SheetModel,
+  row: number,
+  col: number,
+): PivotTableModel | undefined {
+  const pivots = sheet.pivotTables;
+  if (!pivots || pivots.length === 0) return undefined;
+  for (const p of pivots) {
+    const r = parseRange(p.config.ref);
+    if (!r) continue;
+    if (
+      row >= r.startRow &&
+      row <= r.endRow &&
+      col >= r.startCol &&
+      col <= r.endCol
+    ) {
+      return p;
+    }
+  }
+  return undefined;
+}
+
+/**
+ * Look up the pivot result cell at sheet coordinates `(row, col)`. Returns
+ * undefined when there is no pivot, the cell is outside the pivot's
+ * computed grid, or the pivot has not been recomputed.
+ */
+export function getPivotResultCellAt(
+  sheet: SheetModel,
+  row: number,
+  col: number,
+):
+  | {
+      pivot: PivotTableModel;
+      cell: import("./pivot_recompute").PivotResultCell;
+      gridRow: number;
+      gridCol: number;
+    }
+  | undefined {
+  const pivot = findPivotAt(sheet, row, col);
+  if (!pivot || !pivot.result) return undefined;
+  const r = parseRange(pivot.config.ref);
+  if (!r) return undefined;
+  const gridRow = row - r.startRow;
+  const gridCol = col - r.startCol;
+  if (gridRow < 0 || gridCol < 0) return undefined;
+  if (gridRow >= pivot.result.rows || gridCol >= pivot.result.cols) return undefined;
+  const resultRow = pivot.result.cells[gridRow];
+  if (!resultRow) return undefined;
+  const cell = resultRow[gridCol];
+  if (!cell) return undefined;
+  return { pivot, cell, gridRow, gridCol };
+}
+
+/**
+ * Render a `PivotResultCell` to a display string. Number-format hints from
+ * data fields are not honoured yet — values format with a default decimal
+ * representation (matches Excel's "General" for pivot defaults).
+ */
+export function formatPivotCell(
+  cell: import("./pivot_recompute").PivotResultCell,
+): string {
+  switch (cell.kind) {
+    case "blank":
+      return "";
+    case "rowHeader":
+    case "colHeader":
+    case "valueLabel":
+    case "totalLabel":
+      return cell.text;
+    case "value":
+    case "rowTotal":
+    case "colTotal":
+    case "grandTotal":
+      return formatPivotNumber(cell.value);
+  }
+}
+
+function formatPivotNumber(v: number | null): string {
+  if (v === null) return "";
+  if (Number.isInteger(v)) return String(v);
+  // Trim trailing zeros from a 6-digit precision representation.
+  return Number(v.toFixed(6)).toString();
+}