@beyondwork/docx-react-component 1.0.29 → 1.0.30

package/src/io/export/README.md

@@ -0,0 +1,3 @@
+# IO Export
+
+OOXML serialization, part regeneration, and package writing helpers belong here.

package/src/io/export/export-session.ts

@@ -0,0 +1,220 @@
+import {
+  CONTENT_TYPES_PATH,
+  PACKAGE_RELATIONSHIPS_PATH,
+  OpcCompressionMethod,
+  OpcPackagePart,
+  OpcRelationship,
+  comparePartPaths,
+  getRelationshipsPartPath,
+  normalizePartPath,
+  resolveRelationshipTarget,
+} from "../ooxml/part-manifest.ts";
+import type { OpcPackage } from "../opc/package-reader.ts";
+import { writeOpcPackage } from "../opc/package-writer.ts";
+import { reattachPreservedParts } from "./reattach-preserved-parts.ts";
+
+export interface ExportPartReplacement {
+  path: string;
+  bytes: Uint8Array;
+  contentType: string;
+  relationships?: OpcRelationship[];
+  compression?: OpcCompressionMethod;
+}
+
+export interface ExportSessionSnapshot {
+  manifest: OpcPackage["manifest"];
+  parts: Map<string, OpcPackagePart>;
+}
+
+export class ExportSession {
+  private readonly ownedPaths: Set<string>;
+  private readonly workingParts: Map<string, OpcPackagePart>;
+  private readonly packageRelationships: OpcRelationship[];
+
+  public constructor(private readonly sourcePackage: OpcPackage, ownedOutputPaths: Iterable<string>) {
+    this.ownedPaths = new Set(
+      [...ownedOutputPaths].map((path) => {
+        const normalized = normalizePartPath(path);
+        if (normalized === CONTENT_TYPES_PATH || normalized.endsWith(".rels") || normalized === PACKAGE_RELATIONSHIPS_PATH) {
+          throw new Error(`ExportSession cannot directly own reserved OPC manifest path ${normalized}.`);
+        }
+
+        return normalized;
+      }),
+    );
+    this.workingParts = cloneParts(sourcePackage.parts);
+    this.packageRelationships = sourcePackage.manifest.packageRelationships.map(cloneRelationship);
+  }
+
+  public replaceOwnedPart(replacement: ExportPartReplacement): void {
+    const normalizedPath = normalizePartPath(replacement.path);
+    if (!this.ownedPaths.has(normalizedPath)) {
+      throw new Error(`Attempted to rewrite non-owned OPC path ${normalizedPath}.`);
+    }
+
+    const existing = this.workingParts.get(normalizedPath);
+    const nextPart: OpcPackagePart = {
+      path: normalizedPath,
+      surfaceKind: "content",
+      contentType: replacement.contentType,
+      relationshipsPartPath: getRelationshipsPartPath(normalizedPath),
+      relationships: (replacement.relationships ?? existing?.relationships ?? []).map(cloneRelationship),
+      compression: replacement.compression ?? existing?.compression ?? "deflate",
+      bytes: new Uint8Array(replacement.bytes),
+      crc32: 0,
+    };
+
+    this.workingParts.set(normalizedPath, nextPart);
+  }
+
+  public withOwnedPart(replacement: ExportPartReplacement): ExportSession {
+    this.replaceOwnedPart(replacement);
+    return this;
+  }
+
+  public ensurePackageRelationship(input: {
+    type: string;
+    target: string;
+    targetMode?: OpcRelationship["targetMode"];
+    preferredId?: string;
+  }): void {
+    const targetMode = input.targetMode ?? "internal";
+    const normalizedTarget =
+      targetMode === "internal" ? normalizePartPath(input.target) : input.target;
+    const existing = this.packageRelationships.find((relationship) => {
+      if (relationship.type !== input.type || relationship.targetMode !== targetMode) {
+        return false;
+      }
+
+      return targetMode === "internal"
+        ? resolveRelationshipTarget(null, relationship) === normalizedTarget
+        : relationship.target === normalizedTarget;
+    });
+    if (existing) {
+      return;
+    }
+
+    const relationshipId = createUniqueRelationshipId(
+      new Set(this.packageRelationships.map((relationship) => relationship.id)),
+      input.preferredId ?? "rIdPackage1",
+    );
+    this.packageRelationships.push({
+      id: relationshipId,
+      type: input.type,
+      target:
+        targetMode === "internal"
+          ? toPackageRelationshipTarget(normalizedTarget)
+          : normalizedTarget,
+      targetMode,
+    });
+  }
+
+  public toPackage(): OpcPackage {
+    reattachPreservedParts(
+      this.sourcePackage,
+      this.workingParts,
+      this.packageRelationships,
+      this.ownedPaths,
+    );
+    const parts = pruneReservedManifestParts(this.workingParts);
+    const manifest = buildManifest(parts, this.packageRelationships, this.sourcePackage.manifest.contentTypes);
+    return {
+      manifest,
+      parts,
+      sourceByteLength: this.sourcePackage.sourceByteLength,
+    };
+  }
+
+  public serialize(): Uint8Array {
+    return writeOpcPackage(this.toPackage());
+  }
+}
+
+export function createExportSession(
+  sourcePackage: OpcPackage,
+  ownedOutputPaths: Iterable<string>,
+): ExportSession {
+  return new ExportSession(sourcePackage, ownedOutputPaths);
+}
+
+function cloneParts(parts: Map<string, OpcPackagePart>): Map<string, OpcPackagePart> {
+  return new Map(
+    [...parts.entries()].map(([path, part]) => [
+      path,
+      {
+        ...part,
+        relationships: part.relationships.map(cloneRelationship),
+        bytes: new Uint8Array(part.bytes),
+      },
+    ]),
+  );
+}
+
+function pruneReservedManifestParts(parts: Map<string, OpcPackagePart>): Map<string, OpcPackagePart> {
+  return new Map(
+    [...parts.entries()].filter(([path]) => path !== CONTENT_TYPES_PATH && path !== PACKAGE_RELATIONSHIPS_PATH && !path.includes("/_rels/")),
+  );
+}
+
+function buildManifest(
+  parts: Map<string, OpcPackagePart>,
+  packageRelationships: OpcRelationship[],
+  contentTypesSeed: OpcPackage["manifest"]["contentTypes"],
+): OpcPackage["manifest"] {
+  const partsList = [...parts.values()].sort((left, right) => comparePartPaths(left.path, right.path));
+
+  const overrides = { ...contentTypesSeed.overrides };
+  for (const key of Object.keys(overrides)) {
+    if (!parts.has(normalizePartPath(key))) {
+      delete overrides[key];
+    }
+  }
+
+  for (const part of partsList) {
+    if (!part.contentType) {
+      throw new Error(`Cannot export part without content type: ${part.path}`);
+    }
+
+    overrides[part.path] = part.contentType;
+  }
+
+  return {
+    contentTypes: {
+      defaults: { ...contentTypesSeed.defaults },
+      overrides,
+    },
+    packageRelationships: packageRelationships.map(cloneRelationship),
+    parts: partsList.map((part) => ({
+      path: part.path,
+      surfaceKind: part.surfaceKind,
+      contentType: part.contentType,
+      relationshipsPartPath: part.relationshipsPartPath,
+      relationships: part.relationships.map(cloneRelationship),
+      compression: part.compression,
+      byteLength: part.bytes.byteLength,
+    })),
+  };
+}
+
+function cloneRelationship(relationship: OpcRelationship): OpcRelationship {
+  return { ...relationship };
+}
+
+function createUniqueRelationshipId(existingIds: ReadonlySet<string>, preferredId: string): string {
+  if (!existingIds.has(preferredId)) {
+    return preferredId;
+  }
+
+  let nextIndex = 2;
+  while (existingIds.has(`${preferredId}-${nextIndex}`)) {
+    nextIndex += 1;
+  }
+
+  return `${preferredId}-${nextIndex}`;
+}
+
+function toPackageRelationshipTarget(partPath: string): string {
+  return normalizePartPath(partPath).slice(1);
+}
+
+export { buildManifest };

package/src/io/export/minimal-docx.ts

@@ -0,0 +1,115 @@
+import type { PersistedEditorSnapshot } from "../../api/public-types";
+import {
+  DOCX_DOCUMENT_CONTENT_TYPE,
+  DOCX_DOCUMENT_RELATIONSHIP_TYPE,
+  writeDocxPackage,
+} from "../opc/docx-package.ts";
+
+export function exportSnapshotToMinimalDocx(
+  snapshot: PersistedEditorSnapshot,
+): Uint8Array {
+  const paragraphs = collectParagraphTexts(snapshot.canonicalDocument.content);
+  const documentXml = buildDocumentXml(paragraphs);
+
+  return writeDocxPackage({
+    documentXml,
+    documentContentType: DOCX_DOCUMENT_CONTENT_TYPE,
+    packageRelationshipType: DOCX_DOCUMENT_RELATIONSHIP_TYPE,
+  });
+}
+
+function collectParagraphTexts(content: unknown): string[] {
+  const paragraphs = collectParagraphs(content).map((paragraph) =>
+    paragraph.length > 0 ? paragraph : "",
+  );
+  return paragraphs.length > 0 ? paragraphs : [""];
+}
+
+function collectParagraphs(value: unknown): string[] {
+  if (Array.isArray(value)) {
+    return value.flatMap((entry) => collectParagraphs(entry));
+  }
+
+  if (typeof value === "string") {
+    return [value];
+  }
+
+  if (!isRecord(value)) {
+    return [];
+  }
+
+  if (value.type === "doc" && Array.isArray(value.children)) {
+    return value.children.flatMap((entry) => collectParagraphs(entry));
+  }
+
+  if (value.type === "paragraph") {
+    return [collectInlineText(value.children)];
+  }
+
+  return [];
+}
+
+function collectInlineText(value: unknown): string {
+  if (Array.isArray(value)) {
+    return value.map((entry) => collectInlineText(entry)).join("");
+  }
+
+  if (typeof value === "string") {
+    return value;
+  }
+
+  if (!isRecord(value)) {
+    return "";
+  }
+
+  switch (value.type) {
+    case "text":
+      return typeof value.text === "string" ? value.text : "";
+    case "tab":
+      return "\t";
+    case "hard_break":
+      return "\n";
+    case "hyperlink":
+      return collectInlineText(value.children);
+    case "image":
+      return typeof value.altText === "string" ? value.altText : "[Image]";
+    case "opaque_inline":
+      return "[Preserved content]";
+    default:
+      return Array.isArray(value.children) ? collectInlineText(value.children) : "";
+  }
+}
+
+function buildDocumentXml(paragraphs: string[]): string {
+  const body = paragraphs
+    .map(
+      (paragraph) =>
+        `    <w:p><w:r><w:t xml:space="preserve">${escapeXml(
+          paragraph,
+        )}</w:t></w:r></w:p>`,
+    )
+    .join("\n");
+
+  return [
+    `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>`,
+    `<w:document xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main">`,
+    `  <w:body>`,
+    body,
+    `    <w:sectPr/>`,
+    `  </w:body>`,
+    `</w:document>`,
+  ].join("\n");
+}
+
+function escapeXml(value: string): string {
+  return value
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&apos;");
+}
+
+function isRecord(value: unknown): value is Record<string, any> {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}

package/src/io/export/reattach-preserved-parts.ts

@@ -0,0 +1,54 @@
+import type { OpcPackage } from "../opc/package-reader.ts";
+import type { OpcPackagePart, OpcRelationship } from "../ooxml/part-manifest.ts";
+
+export function reattachPreservedParts(
+  sourcePackage: OpcPackage,
+  workingParts: Map<string, OpcPackagePart>,
+  packageRelationships: OpcRelationship[],
+  ownedPaths: ReadonlySet<string>,
+): void {
+  for (const [path, sourcePart] of sourcePackage.parts.entries()) {
+    if (ownedPaths.has(path) || sourcePart.surfaceKind !== "content") {
+      continue;
+    }
+
+    if (!workingParts.has(path)) {
+      workingParts.set(path, clonePart(sourcePart));
+      continue;
+    }
+
+    const currentPart = workingParts.get(path);
+    if (!currentPart) {
+      continue;
+    }
+
+    currentPart.contentType = sourcePart.contentType;
+    currentPart.relationships = sourcePart.relationships.map(cloneRelationship);
+    currentPart.relationshipsPartPath = sourcePart.relationshipsPartPath;
+    currentPart.compression = sourcePart.compression;
+    currentPart.bytes = new Uint8Array(sourcePart.bytes);
+    currentPart.crc32 = sourcePart.crc32;
+  }
+
+  const knownPackageRelationshipIds = new Set(packageRelationships.map((relationship) => relationship.id));
+  for (const relationship of sourcePackage.manifest.packageRelationships) {
+    if (knownPackageRelationshipIds.has(relationship.id)) {
+      continue;
+    }
+
+    packageRelationships.push(cloneRelationship(relationship));
+    knownPackageRelationshipIds.add(relationship.id);
+  }
+}
+
+function clonePart(part: OpcPackagePart): OpcPackagePart {
+  return {
+    ...part,
+    relationships: part.relationships.map(cloneRelationship),
+    bytes: new Uint8Array(part.bytes),
+  };
+}
+
+function cloneRelationship(relationship: OpcRelationship): OpcRelationship {
+  return { ...relationship };
+}