@beyondwork/docx-react-component 1.0.14 → 1.0.16

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

@@ -0,0 +1,429 @@
+import { createExportSession } from "../../../io/export/export-session.ts";
+import {
+  normalizePartPath,
+  resolveRelationshipTarget,
+  type OpcRelationship,
+} from "../../../io/ooxml/part-manifest.ts";
+import type { OpcPackage } from "../../../io/opc/package-reader.ts";
+import { readOpcPackage } from "../../../io/opc/package-reader.ts";
+import type { CanonicalWorkbook } from "../model/workbook.ts";
+import { listSheets } from "../model/workbook.ts";
+import { parseWorkbookXml } from "./parse-workbook.ts";
+import { serializeSheetXml } from "./serialize-sheet.ts";
+import { buildSharedStringsTable } from "./serialize-shared-strings.ts";
+import { serializeStylesXml } from "./serialize-styles.ts";
+
+const XLSX_MAIN_NAMESPACE = "http://schemas.openxmlformats.org/spreadsheetml/2006/main";
+const XLSX_RELATIONSHIPS_NAMESPACE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
+
+export const XLSX_OFFICE_DOCUMENT_REL_TYPE =
+  "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument";
+export const XLSX_WORKSHEET_REL_TYPE =
+  "http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet";
+export const XLSX_SHARED_STRINGS_REL_TYPE =
+  "http://schemas.openxmlformats.org/officeDocument/2006/relationships/sharedStrings";
+export const XLSX_STYLES_REL_TYPE =
+  "http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles";
+
+export const XLSX_WORKBOOK_CONTENT_TYPE =
+  "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml";
+export const XLSX_WORKSHEET_CONTENT_TYPE =
+  "application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml";
+export const XLSX_SHARED_STRINGS_CONTENT_TYPE =
+  "application/vnd.openxmlformats-officedocument.spreadsheetml.sharedStrings+xml";
+export const XLSX_STYLES_CONTENT_TYPE =
+  "application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml";
+
+interface WorkbookSheetBinding {
+  sheetId: string;
+  name: string;
+  relationshipId: string;
+  state: "visible" | "hidden";
+}
+
+interface WorkbookPartBinding {
+  path: string;
+  relationshipId: string;
+}
+
+interface SheetExportBinding extends WorkbookPartBinding {
+  sheet: ReturnType<typeof listSheets>[number];
+  relationships: OpcRelationship[];
+}
+
+interface SourceWorkbookLayout {
+  workbookPath: string;
+  workbookDirectory: string;
+  workbookRelationships: OpcRelationship[];
+  sheetBindingsById: Map<string, WorkbookPartBinding>;
+  sheetRelationshipsByPath: Map<string, OpcRelationship[]>;
+  sharedStringsBinding?: WorkbookPartBinding;
+  stylesBinding?: WorkbookPartBinding;
+}
+
+export function serializeWorkbookXml(
+  workbook: CanonicalWorkbook,
+  sheets: readonly WorkbookSheetBinding[],
+): string {
+  const sheetXml = sheets.map((sheet) => {
+    const stateAttr = sheet.state === "hidden" ? ` state="hidden"` : "";
+    return `    <sheet name="${escapeXml(sheet.name)}" sheetId="${escapeXml(sheet.sheetId)}"${stateAttr} r:id="${sheet.relationshipId}"/>`;
+  });
+  const workbookPr = workbook.metadata.date1904
+    ? `  <workbookPr date1904="1"/>`
+    : null;
+
+  return [
+    `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>`,
+    `<workbook xmlns="${XLSX_MAIN_NAMESPACE}" xmlns:r="${XLSX_RELATIONSHIPS_NAMESPACE}">`,
+    ...(workbookPr ? [workbookPr] : []),
+    `  <sheets>`,
+    ...sheetXml,
+    `  </sheets>`,
+    `</workbook>`,
+  ].join("\n");
+}
+
+export function exportXlsxWorkbook(
+  workbook: CanonicalWorkbook,
+  source: Uint8Array | ArrayBuffer | OpcPackage,
+): Uint8Array {
+  const sourcePackage = toOpcPackage(source);
+  const sourceLayout = resolveSourceWorkbookLayout(sourcePackage);
+  const encoder = new TextEncoder();
+  const sheets = listSheets(workbook);
+  const sharedStrings = buildSharedStringsTable(workbook);
+  const includeSharedStrings =
+    sharedStrings.strings.length > 0 || sourceLayout.sharedStringsBinding !== undefined;
+  const includeStyles =
+    workbook.styles.cellFormats.length > 0 ||
+    workbook.styles.numFormats.size > 0 ||
+    sourceLayout.stylesBinding !== undefined;
+
+  const sheetBindings = allocateSheetBindings(
+    sheets,
+    sourceLayout,
+    new Set(sourcePackage.parts.keys()),
+  );
+  const workbookSheetBindings: WorkbookSheetBinding[] = sheetBindings.map((binding) => ({
+    sheetId: binding.sheet.sheetId,
+    name: binding.sheet.name,
+    relationshipId: binding.relationshipId,
+    state: binding.sheet.hidden ? "hidden" : "visible",
+  }));
+
+  const sharedStringsBinding = includeSharedStrings
+    ? sourceLayout.sharedStringsBinding ?? createWorkbookPartBinding(
+      sourceLayout.workbookDirectory,
+      new Set(sourceLayout.workbookRelationships.map((relationship) => relationship.id)),
+      "sharedStrings.xml",
+      "rIdSharedStrings",
+    )
+    : undefined;
+  const stylesBinding = includeStyles
+    ? sourceLayout.stylesBinding ?? createWorkbookPartBinding(
+      sourceLayout.workbookDirectory,
+      new Set(sourceLayout.workbookRelationships.map((relationship) => relationship.id)),
+      "styles.xml",
+      "rIdStyles",
+    )
+    : undefined;
+
+  const ownedPaths = [
+    sourceLayout.workbookPath,
+    ...sheetBindings.map((binding) => binding.path),
+    ...(sharedStringsBinding ? [sharedStringsBinding.path] : []),
+    ...(stylesBinding ? [stylesBinding.path] : []),
+  ];
+  const exportSession = createExportSession(sourcePackage, ownedPaths);
+
+  for (const binding of sheetBindings) {
+    exportSession.replaceOwnedPart({
+      path: binding.path,
+      bytes: encoder.encode(
+        serializeSheetXml(binding.sheet, {
+          sharedStringIndexByValue: includeSharedStrings
+            ? sharedStrings.indexByValue
+            : undefined,
+        }),
+      ),
+      contentType: XLSX_WORKSHEET_CONTENT_TYPE,
+      relationships: binding.relationships,
+    });
+  }
+
+  if (sharedStringsBinding) {
+    exportSession.replaceOwnedPart({
+      path: sharedStringsBinding.path,
+      bytes: encoder.encode(sharedStrings.xml),
+      contentType: XLSX_SHARED_STRINGS_CONTENT_TYPE,
+      relationships: sourcePackage.parts.get(sharedStringsBinding.path)?.relationships ?? [],
+    });
+  }
+
+  if (stylesBinding) {
+    exportSession.replaceOwnedPart({
+      path: stylesBinding.path,
+      bytes: encoder.encode(serializeStylesXml(workbook.styles)),
+      contentType: XLSX_STYLES_CONTENT_TYPE,
+      relationships: sourcePackage.parts.get(stylesBinding.path)?.relationships ?? [],
+    });
+  }
+
+  const preservedRelationships = sourceLayout.workbookRelationships
+    .filter(
+      (relationship) => ![
+        XLSX_WORKSHEET_REL_TYPE,
+        XLSX_SHARED_STRINGS_REL_TYPE,
+        XLSX_STYLES_REL_TYPE,
+      ].includes(relationship.type),
+    )
+    .map(cloneRelationship);
+  const workbookRelationships = [
+    ...preservedRelationships,
+    ...sheetBindings.map((binding) => ({
+      id: binding.relationshipId,
+      type: XLSX_WORKSHEET_REL_TYPE,
+      target: toRelationshipTarget(sourceLayout.workbookPath, binding.path),
+      targetMode: "internal" as const,
+    })),
+    ...(sharedStringsBinding
+      ? [{
+        id: sharedStringsBinding.relationshipId,
+        type: XLSX_SHARED_STRINGS_REL_TYPE,
+        target: toRelationshipTarget(sourceLayout.workbookPath, sharedStringsBinding.path),
+        targetMode: "internal" as const,
+      }]
+      : []),
+    ...(stylesBinding
+      ? [{
+        id: stylesBinding.relationshipId,
+        type: XLSX_STYLES_REL_TYPE,
+        target: toRelationshipTarget(sourceLayout.workbookPath, stylesBinding.path),
+        targetMode: "internal" as const,
+      }]
+      : []),
+  ].sort((left, right) => left.id.localeCompare(right.id));
+
+  exportSession.replaceOwnedPart({
+    path: sourceLayout.workbookPath,
+    bytes: encoder.encode(serializeWorkbookXml(workbook, workbookSheetBindings)),
+    contentType: sourcePackage.parts.get(sourceLayout.workbookPath)?.contentType ?? XLSX_WORKBOOK_CONTENT_TYPE,
+    relationships: workbookRelationships,
+  });
+
+  return exportSession.serialize();
+}
+
+function allocateSheetBindings(
+  sheets: ReturnType<typeof listSheets>,
+  sourceLayout: SourceWorkbookLayout,
+  usedPathsSeed: ReadonlySet<string>,
+): SheetExportBinding[] {
+  const usedPaths = new Set(usedPathsSeed);
+  const usedRelationshipIds = new Set(
+    sourceLayout.workbookRelationships.map((relationship) => relationship.id),
+  );
+
+  return sheets.map((sheet) => {
+    const existingBinding = sourceLayout.sheetBindingsById.get(sheet.sheetId);
+    if (existingBinding) {
+      return {
+        sheet,
+        path: existingBinding.path,
+        relationshipId: existingBinding.relationshipId,
+        relationships: cloneRelationshipsForPath(sourceLayout, existingBinding.path),
+      };
+    }
+
+    const partPath = createUniqueSheetPath(sourceLayout.workbookDirectory, usedPaths);
+    usedPaths.add(partPath);
+    const relationshipId = createUniqueRelationshipId(usedRelationshipIds, "rIdSheet");
+    usedRelationshipIds.add(relationshipId);
+    return {
+      sheet,
+      path: partPath,
+      relationshipId,
+      relationships: [],
+    };
+  });
+}
+
+function resolveSourceWorkbookLayout(sourcePackage: OpcPackage): SourceWorkbookLayout {
+  const workbookRelationship = sourcePackage.manifest.packageRelationships.find(
+    (relationship) => relationship.type === XLSX_OFFICE_DOCUMENT_REL_TYPE,
+  );
+  if (!workbookRelationship) {
+    throw new Error("Cannot export xlsx workbook: source package is missing officeDocument relationship.");
+  }
+
+  const workbookPath = resolveRelationshipTarget(null, workbookRelationship);
+  const workbookPart = sourcePackage.parts.get(workbookPath);
+  if (!workbookPart) {
+    throw new Error(`Cannot export xlsx workbook: workbook part missing at ${workbookPath}.`);
+  }
+
+  const workbookXml = new TextDecoder("utf-8").decode(workbookPart.bytes);
+  const parsedWorkbook = parseWorkbookXml(workbookXml);
+  const sheetBindingsById = new Map<string, WorkbookPartBinding>();
+  const sheetRelationshipsByPath = new Map<string, OpcRelationship[]>();
+
+  for (const sheet of parsedWorkbook.sheets) {
+    const relationship = workbookPart.relationships.find(
+      (candidate) =>
+        candidate.id === sheet.relationshipId &&
+        candidate.type === XLSX_WORKSHEET_REL_TYPE,
+    );
+    if (!relationship) {
+      continue;
+    }
+
+    const sheetPath = resolveRelationshipTarget(workbookPath, relationship);
+    sheetBindingsById.set(sheet.sheetId, {
+      path: sheetPath,
+      relationshipId: relationship.id,
+    });
+    sheetRelationshipsByPath.set(
+      sheetPath,
+      sourcePackage.parts.get(sheetPath)?.relationships.map(cloneRelationship) ?? [],
+    );
+  }
+
+  const sharedStringsRelationship = workbookPart.relationships.find(
+    (relationship) => relationship.type === XLSX_SHARED_STRINGS_REL_TYPE,
+  );
+  const stylesRelationship = workbookPart.relationships.find(
+    (relationship) => relationship.type === XLSX_STYLES_REL_TYPE,
+  );
+
+  return {
+    workbookPath,
+    workbookDirectory: getDirectoryPath(workbookPath),
+    workbookRelationships: workbookPart.relationships.map(cloneRelationship),
+    sheetBindingsById,
+    sheetRelationshipsByPath,
+    sharedStringsBinding: sharedStringsRelationship
+      ? {
+        path: resolveRelationshipTarget(workbookPath, sharedStringsRelationship),
+        relationshipId: sharedStringsRelationship.id,
+      }
+      : undefined,
+    stylesBinding: stylesRelationship
+      ? {
+        path: resolveRelationshipTarget(workbookPath, stylesRelationship),
+        relationshipId: stylesRelationship.id,
+      }
+      : undefined,
+  };
+}
+
+function cloneRelationshipsForPath(
+  sourceLayout: SourceWorkbookLayout,
+  path: string,
+): OpcRelationship[] {
+  return sourceLayout.sheetRelationshipsByPath.get(path)?.map(cloneRelationship) ?? [];
+}
+
+function toOpcPackage(source: Uint8Array | ArrayBuffer | OpcPackage): OpcPackage {
+  if (source instanceof Uint8Array || source instanceof ArrayBuffer) {
+    return readOpcPackage(source);
+  }
+
+  if (source && typeof source === "object" && source.parts instanceof Map) {
+    return source;
+  }
+
+  throw new Error("Unsupported xlsx export source input.");
+}
+
+function createWorkbookPartBinding(
+  workbookDirectory: string,
+  existingRelationshipIds: Set<string>,
+  filename: string,
+  preferredRelationshipId: string,
+): WorkbookPartBinding {
+  const relationshipId = createUniqueRelationshipId(existingRelationshipIds, preferredRelationshipId);
+  existingRelationshipIds.add(relationshipId);
+
+  return {
+    path: normalizePartPath(`${workbookDirectory}/${filename}`),
+    relationshipId,
+  };
+}
+
+function createUniqueSheetPath(
+  workbookDirectory: string,
+  existingPaths: ReadonlySet<string>,
+): string {
+  let nextIndex = 1;
+
+  while (true) {
+    const candidate = normalizePartPath(`${workbookDirectory}/worksheets/sheet${nextIndex}.xml`);
+    if (!existingPaths.has(candidate)) {
+      return candidate;
+    }
+    nextIndex += 1;
+  }
+}
+
+function createUniqueRelationshipId(
+  existingIds: Set<string>,
+  preferredBase: string,
+): string {
+  if (!existingIds.has(preferredBase)) {
+    return preferredBase;
+  }
+
+  let nextIndex = 1;
+  while (existingIds.has(`${preferredBase}${nextIndex}`)) {
+    nextIndex += 1;
+  }
+
+  return `${preferredBase}${nextIndex}`;
+}
+
+function getDirectoryPath(partPath: string): string {
+  const normalized = normalizePartPath(partPath);
+  const slashIndex = normalized.lastIndexOf("/");
+  return slashIndex <= 0 ? "/" : normalized.slice(0, slashIndex);
+}
+
+function toRelationshipTarget(
+  sourcePartPath: string,
+  targetPartPath: string,
+): string {
+  const sourceDirectorySegments = getDirectoryPath(sourcePartPath)
+    .split("/")
+    .filter(Boolean);
+  const targetSegments = normalizePartPath(targetPartPath)
+    .split("/")
+    .filter(Boolean);
+
+  let sharedIndex = 0;
+  while (
+    sharedIndex < sourceDirectorySegments.length &&
+    sharedIndex < targetSegments.length &&
+    sourceDirectorySegments[sharedIndex] === targetSegments[sharedIndex]
+  ) {
+    sharedIndex += 1;
+  }
+
+  const upSegments = sourceDirectorySegments
+    .slice(sharedIndex)
+    .map(() => "..");
+  const downSegments = targetSegments.slice(sharedIndex);
+  return [...upSegments, ...downSegments].join("/");
+}
+
+function cloneRelationship(relationship: OpcRelationship): OpcRelationship {
+  return { ...relationship };
+}
+
+function escapeXml(value: string): string {
+  return value
+    .replace(/&/g, "&amp;")
+    .replace(/"/g, "&quot;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/'/g, "&apos;");
+}