@beyondwork/docx-react-component 1.0.28 → 1.0.29

package/src/io/export/README.md

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

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

@@ -1,220 +0,0 @@
-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

@@ -1,115 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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 };
-}