@beyondwork/docx-react-component 1.0.29 → 1.0.31

package/src/formats/xlsx/io/serialize-sheet.ts

@@ -0,0 +1,333 @@
+import type { CellKey, CellValue, FormulaCell } from "../model/cell.ts";
+import { parseCellKey } from "../model/cell.ts";
+import type { CanonicalSheet, MergeRange, SheetPaneState } from "../model/sheet.ts";
+
+const WORKSHEET_NAMESPACE = "http://schemas.openxmlformats.org/spreadsheetml/2006/main";
+
+export interface SheetSerializationOptions {
+  sharedStringIndexByValue?: ReadonlyMap<string, number>;
+}
+
+export function serializeSheetXml(
+  sheet: CanonicalSheet,
+  options: SheetSerializationOptions = {},
+): string {
+  const rows = groupCellsByRow(sheet);
+  const rowIndices = new Set<number>([
+    ...rows.keys(),
+    ...sheet.rowProps.keys(),
+  ]);
+  const sortedRowIndices = [...rowIndices].sort((left, right) => left - right);
+  const lines = [
+    `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>`,
+    `<worksheet xmlns="${WORKSHEET_NAMESPACE}">`,
+    `  <dimension ref="${computeDimensionRef(sheet)}"/>`,
+    ...serializeSheetViews(sheet.paneState),
+    ...serializeColumns(sheet),
+  ];
+
+  if (sortedRowIndices.length === 0) {
+    lines.push(`  <sheetData/>`);
+  } else {
+    lines.push(`  <sheetData>`);
+    for (const rowIndex of sortedRowIndices) {
+      const rowProps = sheet.rowProps.get(rowIndex);
+      const rowCells = rows.get(rowIndex) ?? [];
+      const rowAttributes = [
+        `r="${rowIndex + 1}"`,
+      ];
+
+      if (rowProps?.heightPt !== undefined) {
+        rowAttributes.push(`ht="${formatNumber(rowProps.heightPt)}"`);
+      }
+      if (rowProps?.hidden) {
+        rowAttributes.push(`hidden="1"`);
+      }
+      if (rowProps?.customHeight) {
+        rowAttributes.push(`customHeight="1"`);
+      }
+      if (rowProps?.styleRef) {
+        rowAttributes.push(`s="${rowProps.styleRef.xfIndex}"`, `customFormat="1"`);
+      }
+
+      if (rowCells.length === 0) {
+        lines.push(`    <row ${rowAttributes.join(" ")}></row>`);
+        continue;
+      }
+
+      lines.push(`    <row ${rowAttributes.join(" ")}>`);
+      for (const cellEntry of rowCells) {
+        lines.push(`      ${serializeCellXml(cellEntry, options.sharedStringIndexByValue)}`);
+      }
+      lines.push(`    </row>`);
+    }
+    lines.push(`  </sheetData>`);
+  }
+
+  if (sheet.merges.length > 0) {
+    lines.push(`  <mergeCells count="${sheet.merges.length}">`);
+    for (const merge of [...sheet.merges].sort(compareMergeRanges)) {
+      lines.push(`    <mergeCell ref="${formatMergeRef(merge)}"/>`);
+    }
+    lines.push(`  </mergeCells>`);
+  }
+
+  lines.push(`</worksheet>`);
+  return lines.join("\n");
+}
+
+function groupCellsByRow(
+  sheet: CanonicalSheet,
+): Map<number, Array<[CellKey, CellValue]>> {
+  const rows = new Map<number, Array<[CellKey, CellValue]>>();
+  const sortedCells = [...sheet.cells.entries()].sort(
+    ([leftKey], [rightKey]) => compareCellKeys(leftKey, rightKey),
+  );
+
+  for (const entry of sortedCells) {
+    const { row } = parseCellKey(entry[0]);
+    const rowEntries = rows.get(row) ?? [];
+    rowEntries.push(entry);
+    rows.set(row, rowEntries);
+  }
+
+  return rows;
+}
+
+function serializeSheetViews(paneState: SheetPaneState | undefined): string[] {
+  if (!paneState || (paneState.frozenRows <= 0 && paneState.frozenCols <= 0)) {
+    return [];
+  }
+
+  const paneAttributes = [
+    `state="frozen"`,
+    `topLeftCell="${formatCellRef(paneState.frozenRows, paneState.frozenCols)}"`,
+    `activePane="${resolveActivePane(paneState)}"`,
+  ];
+
+  if (paneState.frozenCols > 0) {
+    paneAttributes.push(`xSplit="${paneState.frozenCols}"`);
+  }
+  if (paneState.frozenRows > 0) {
+    paneAttributes.push(`ySplit="${paneState.frozenRows}"`);
+  }
+
+  return [
+    `  <sheetViews>`,
+    `    <sheetView workbookViewId="0">`,
+    `      <pane ${paneAttributes.join(" ")}/>`,
+    `    </sheetView>`,
+    `  </sheetViews>`,
+  ];
+}
+
+function resolveActivePane(paneState: SheetPaneState): string {
+  if (paneState.frozenRows > 0 && paneState.frozenCols > 0) {
+    return "bottomRight";
+  }
+  if (paneState.frozenRows > 0) {
+    return "bottomLeft";
+  }
+  return "topRight";
+}
+
+function serializeColumns(sheet: CanonicalSheet): string[] {
+  const columns = [...sheet.colProps.values()].sort(
+    (left, right) => left.colIndex - right.colIndex,
+  );
+  if (columns.length === 0) {
+    return [];
+  }
+
+  const lines = [`  <cols>`];
+  for (const column of columns) {
+    const attributes = [
+      `min="${column.colIndex + 1}"`,
+      `max="${column.colIndex + 1}"`,
+    ];
+
+    if (column.widthChars !== undefined) {
+      attributes.push(`width="${formatNumber(column.widthChars)}"`);
+    }
+    if (column.hidden) {
+      attributes.push(`hidden="1"`);
+    }
+    if (column.customWidth) {
+      attributes.push(`customWidth="1"`);
+    }
+    if (column.styleRef) {
+      attributes.push(`style="${column.styleRef.xfIndex}"`);
+    }
+
+    lines.push(`    <col ${attributes.join(" ")}/>`);
+  }
+  lines.push(`  </cols>`);
+  return lines;
+}
+
+function serializeCellXml(
+  [key, cell]: [CellKey, CellValue],
+  sharedStringIndexByValue: ReadonlyMap<string, number> | undefined,
+): string {
+  const { row, col } = parseCellKey(key);
+  const ref = formatCellRef(row, col);
+  const styleAttr = cell.styleRef ? ` s="${cell.styleRef.xfIndex}"` : "";
+
+  switch (cell.kind) {
+    case "blank":
+      return `<c r="${ref}"${styleAttr}/>`;
+
+    case "text": {
+      if (sharedStringIndexByValue && sharedStringIndexByValue.has(cell.value)) {
+        return `<c r="${ref}"${styleAttr} t="s"><v>${sharedStringIndexByValue.get(cell.value)}</v></c>`;
+      }
+
+      const preserveSpace = requiresPreservedSpace(cell.value) ? ` xml:space="preserve"` : "";
+      return `<c r="${ref}"${styleAttr} t="inlineStr"><is><t${preserveSpace}>${escapeXml(cell.value)}</t></is></c>`;
+    }
+
+    case "number":
+      return `<c r="${ref}"${styleAttr}><v>${formatNumber(cell.value)}</v></c>`;
+
+    case "boolean":
+      return `<c r="${ref}"${styleAttr} t="b"><v>${cell.value ? "1" : "0"}</v></c>`;
+
+    case "error":
+      return `<c r="${ref}"${styleAttr} t="e"><v>${escapeXml(cell.errorCode)}</v></c>`;
+
+    case "formula":
+      return serializeFormulaCellXml(ref, styleAttr, cell);
+  }
+}
+
+function serializeFormulaCellXml(
+  ref: string,
+  styleAttr: string,
+  cell: FormulaCell,
+): string {
+  const cachedValue = serializeFormulaCachedValue(cell);
+  const typeAttr = cachedValue.typeCode ? ` t="${cachedValue.typeCode}"` : "";
+  const valueXml = cachedValue.valueXml ? `<v>${cachedValue.valueXml}</v>` : "";
+  return `<c r="${ref}"${styleAttr}${typeAttr}><f>${escapeXml(cell.formula)}</f>${valueXml}</c>`;
+}
+
+function serializeFormulaCachedValue(
+  cell: FormulaCell,
+): { typeCode?: string; valueXml?: string } {
+  if (!cell.cachedValue) {
+    return {};
+  }
+
+  switch (cell.cachedValue.type) {
+    case "blank":
+      return {};
+
+    case "number":
+      return { valueXml: formatNumber(cell.cachedValue.value) };
+
+    case "text":
+      return { typeCode: "str", valueXml: escapeXml(cell.cachedValue.value) };
+
+    case "boolean":
+      return { typeCode: "b", valueXml: cell.cachedValue.value ? "1" : "0" };
+
+    case "error":
+      return { typeCode: "e", valueXml: escapeXml(cell.cachedValue.errorCode) };
+  }
+}
+
+function computeDimensionRef(sheet: CanonicalSheet): string {
+  let minRow = Infinity;
+  let minCol = Infinity;
+  let maxRow = -Infinity;
+  let maxCol = -Infinity;
+
+  for (const key of sheet.cells.keys()) {
+    const { row, col } = parseCellKey(key);
+    minRow = Math.min(minRow, row);
+    minCol = Math.min(minCol, col);
+    maxRow = Math.max(maxRow, row);
+    maxCol = Math.max(maxCol, col);
+  }
+
+  for (const merge of sheet.merges) {
+    minRow = Math.min(minRow, merge.startRow);
+    minCol = Math.min(minCol, merge.startCol);
+    maxRow = Math.max(maxRow, merge.endRow);
+    maxCol = Math.max(maxCol, merge.endCol);
+  }
+
+  if (!Number.isFinite(minRow) || !Number.isFinite(minCol)) {
+    return "A1";
+  }
+
+  const start = formatCellRef(minRow, minCol);
+  const end = formatCellRef(maxRow, maxCol);
+  return start === end ? start : `${start}:${end}`;
+}
+
+function formatMergeRef(merge: MergeRange): string {
+  return `${formatCellRef(merge.startRow, merge.startCol)}:${formatCellRef(merge.endRow, merge.endCol)}`;
+}
+
+function formatCellRef(row: number, col: number): string {
+  return `${columnNumberToName(col)}${row + 1}`;
+}
+
+function columnNumberToName(col: number): string {
+  let index = col + 1;
+  let result = "";
+
+  while (index > 0) {
+    const remainder = (index - 1) % 26;
+    result = String.fromCharCode(65 + remainder) + result;
+    index = Math.floor((index - 1) / 26);
+  }
+
+  return result;
+}
+
+function compareCellKeys(left: CellKey, right: CellKey): number {
+  const leftAddress = parseCellKey(left);
+  const rightAddress = parseCellKey(right);
+
+  if (leftAddress.row !== rightAddress.row) {
+    return leftAddress.row - rightAddress.row;
+  }
+
+  return leftAddress.col - rightAddress.col;
+}
+
+function compareMergeRanges(left: MergeRange, right: MergeRange): number {
+  if (left.startRow !== right.startRow) {
+    return left.startRow - right.startRow;
+  }
+  if (left.startCol !== right.startCol) {
+    return left.startCol - right.startCol;
+  }
+  if (left.endRow !== right.endRow) {
+    return left.endRow - right.endRow;
+  }
+  return left.endCol - right.endCol;
+}
+
+function formatNumber(value: number): string {
+  if (!Number.isFinite(value)) {
+    throw new Error(`Cannot serialize non-finite numeric cell value ${value}.`);
+  }
+
+  return String(value);
+}
+
+function requiresPreservedSpace(value: string): boolean {
+  return /^\s/.test(value) || /\s$/.test(value);
+}
+
+function escapeXml(value: string): string {
+  return value
+    .replace(/&/g, "&amp;")
+    .replace(/"/g, "&quot;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/'/g, "&apos;");
+}

package/src/formats/xlsx/io/serialize-styles.ts

@@ -0,0 +1,98 @@
+import type { WorkbookStyleRegistry, XfRecord } from "../model/styles.ts";
+
+const STYLES_NAMESPACE = "http://schemas.openxmlformats.org/spreadsheetml/2006/main";
+
+export function serializeStylesXml(registry: WorkbookStyleRegistry): string {
+  const numFormats = [...registry.numFormats.values()].sort(
+    (left, right) => left.numFmtId - right.numFmtId,
+  );
+  const cellFormats = registry.cellFormats;
+  const fontCount = Math.max(1, ...cellFormats.map((format) => format.fontId + 1));
+  const fillCount = Math.max(2, ...cellFormats.map((format) => format.fillId + 1));
+  const borderCount = Math.max(1, ...cellFormats.map((format) => format.borderId + 1));
+
+  const lines = [
+    `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>`,
+    `<styleSheet xmlns="${STYLES_NAMESPACE}">`,
+  ];
+
+  if (numFormats.length > 0) {
+    lines.push(`  <numFmts count="${numFormats.length}">`);
+    for (const format of numFormats) {
+      lines.push(
+        `    <numFmt numFmtId="${format.numFmtId}" formatCode="${escapeXml(format.formatCode)}"/>`,
+      );
+    }
+    lines.push(`  </numFmts>`);
+  }
+
+  lines.push(`  <fonts count="${fontCount}">`);
+  for (let index = 0; index < fontCount; index += 1) {
+    lines.push(`    <font/>`);
+  }
+  lines.push(`  </fonts>`);
+
+  lines.push(`  <fills count="${fillCount}">`);
+  for (let index = 0; index < fillCount; index += 1) {
+    if (index === 0) {
+      lines.push(`    <fill><patternFill patternType="none"/></fill>`);
+      continue;
+    }
+    if (index === 1) {
+      lines.push(`    <fill><patternFill patternType="gray125"/></fill>`);
+      continue;
+    }
+    lines.push(`    <fill><patternFill patternType="none"/></fill>`);
+  }
+  lines.push(`  </fills>`);
+
+  lines.push(`  <borders count="${borderCount}">`);
+  for (let index = 0; index < borderCount; index += 1) {
+    lines.push(`    <border><left/><right/><top/><bottom/><diagonal/></border>`);
+  }
+  lines.push(`  </borders>`);
+
+  lines.push(`  <cellStyleXfs count="1">`);
+  lines.push(`    <xf numFmtId="0" fontId="0" fillId="0" borderId="0"/>`);
+  lines.push(`  </cellStyleXfs>`);
+
+  lines.push(`  <cellXfs count="${cellFormats.length}">`);
+  for (const format of cellFormats) {
+    lines.push(`    <xf ${serializeXfAttributes(format)}/>`);
+  }
+  lines.push(`  </cellXfs>`);
+
+  lines.push(`  <cellStyles count="1">`);
+  lines.push(`    <cellStyle name="Normal" xfId="0" builtinId="0"/>`);
+  lines.push(`  </cellStyles>`);
+  lines.push(`</styleSheet>`);
+
+  return lines.join("\n");
+}
+
+function serializeXfAttributes(format: XfRecord): string {
+  const attributes = new Map<string, string>(Object.entries(format.rawAttributes));
+  attributes.set("numFmtId", attributes.get("numFmtId") ?? String(format.numFmtId));
+  attributes.set("fontId", attributes.get("fontId") ?? String(format.fontId));
+  attributes.set("fillId", attributes.get("fillId") ?? String(format.fillId));
+  attributes.set("borderId", attributes.get("borderId") ?? String(format.borderId));
+
+  const priority = ["numFmtId", "fontId", "fillId", "borderId"];
+  const orderedKeys = [
+    ...priority.filter((key) => attributes.has(key)),
+    ...[...attributes.keys()].filter((key) => !priority.includes(key)),
+  ];
+
+  return orderedKeys
+    .map((key) => `${key}="${escapeXml(attributes.get(key) ?? "")}"`)
+    .join(" ");
+}
+
+function escapeXml(value: string): string {
+  return value
+    .replace(/&/g, "&amp;")
+    .replace(/"/g, "&quot;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/'/g, "&apos;");
+}