@beyondwork/docx-react-component 1.0.29 → 1.0.31

package/src/io/opc/corrupt-package.ts

@@ -0,0 +1,166 @@
+import type { EditorError } from "../../api/public-types.ts";
+
+export const CORRUPT_PACKAGE_REASONS = [
+  "zip-structure",
+  "content-types-missing",
+  "main-document-missing",
+  "broken-relationship-graph",
+  "malformed-xml",
+  "unsupported-compression",
+  "unreadable-package",
+] as const;
+
+export type CorruptPackageReason = (typeof CORRUPT_PACKAGE_REASONS)[number];
+
+export interface CorruptPackageIssue {
+  reason: CorruptPackageReason;
+  message: string;
+  partPath?: string;
+  relationshipSourcePath?: string;
+  relationshipId?: string;
+  targetPartPath?: string;
+  details?: Record<string, unknown>;
+}
+
+export interface CorruptPackageErrorDetails extends Record<string, unknown> {
+  stage: "package";
+  reason: CorruptPackageReason;
+  diagnosticsToken: string;
+  partPath?: string;
+  relationshipSourcePath?: string;
+  relationshipId?: string;
+  targetPartPath?: string;
+}
+
+export function createCorruptPackageError(
+  issue: CorruptPackageIssue,
+): EditorError {
+  return {
+    errorId: `error:package_corrupt:${createCorruptPackageDiagnosticsToken(issue)}`,
+    code: "package_corrupt",
+    message: issue.message,
+    isFatal: true,
+    source: "import",
+    details: {
+      stage: "package",
+      reason: issue.reason,
+      diagnosticsToken: createCorruptPackageDiagnosticsToken(issue),
+      ...(issue.partPath ? { partPath: issue.partPath } : {}),
+      ...(issue.relationshipSourcePath
+        ? { relationshipSourcePath: issue.relationshipSourcePath }
+        : {}),
+      ...(issue.relationshipId ? { relationshipId: issue.relationshipId } : {}),
+      ...(issue.targetPartPath ? { targetPartPath: issue.targetPartPath } : {}),
+      ...(issue.details ?? {}),
+    } satisfies CorruptPackageErrorDetails,
+  };
+}
+
+export function createMissingPartIssue(partPath: string): CorruptPackageIssue {
+  return {
+    reason:
+      partPath === "/[Content_Types].xml"
+        ? "content-types-missing"
+        : partPath === "/word/document.xml"
+          ? "main-document-missing"
+          : "unreadable-package",
+    message: `DOCX package is missing required part ${partPath}.`,
+    partPath,
+  };
+}
+
+export function createBrokenRelationshipIssue(input: {
+  relationshipSourcePath: string | null;
+  relationshipId: string;
+  targetPartPath: string;
+}): CorruptPackageIssue {
+  return {
+    reason: "broken-relationship-graph",
+    message:
+      input.relationshipSourcePath === null
+        ? `DOCX package relationship ${input.relationshipId} points to missing part ${input.targetPartPath}.`
+        : `DOCX part ${input.relationshipSourcePath} has unresolved relationship ${input.relationshipId} targeting ${input.targetPartPath}.`,
+    relationshipSourcePath: input.relationshipSourcePath ?? undefined,
+    relationshipId: input.relationshipId,
+    targetPartPath: input.targetPartPath,
+  };
+}
+
+export function classifyCorruptPackageError(error: unknown): CorruptPackageIssue {
+  const message =
+    error instanceof Error
+      ? error.message
+      : typeof error === "string"
+        ? error
+        : "DOCX package could not be read safely.";
+  const normalized = message.toLowerCase();
+
+  if (
+    normalized.includes("end of central directory") ||
+    normalized.includes("zip archive") ||
+    normalized.includes("central directory signature") ||
+    normalized.includes("local file header signature")
+  ) {
+    return {
+      reason: "zip-structure",
+      message,
+    };
+  }
+
+  if (normalized.includes("compression")) {
+    return {
+      reason: "unsupported-compression",
+      message,
+    };
+  }
+
+  if (normalized.includes("relationship")) {
+    return {
+      reason: "broken-relationship-graph",
+      message,
+    };
+  }
+
+  if (normalized.includes("/[content_types].xml")) {
+    return createMissingPartIssue("/[Content_Types].xml");
+  }
+
+  if (normalized.includes("/word/document.xml")) {
+    return createMissingPartIssue("/word/document.xml");
+  }
+
+  if (normalized.includes("xml")) {
+    return {
+      reason: "malformed-xml",
+      message,
+    };
+  }
+
+  return {
+    reason: "unreadable-package",
+    message,
+  };
+}
+
+export function createCorruptPackageDiagnosticsToken(
+  issue: CorruptPackageIssue,
+): string {
+  const fields = [
+    issue.reason,
+    issue.message,
+    issue.partPath ?? "",
+    issue.relationshipSourcePath ?? "",
+    issue.relationshipId ?? "",
+    issue.targetPartPath ?? "",
+  ];
+
+  let hash = 2166136261;
+  for (const field of fields) {
+    for (let index = 0; index < field.length; index += 1) {
+      hash ^= field.charCodeAt(index);
+      hash = Math.imul(hash, 16777619) >>> 0;
+    }
+  }
+
+  return `pkg-${hash.toString(16).padStart(8, "0")}`;
+}

package/src/io/opc/docx-package.ts

@@ -0,0 +1,74 @@
+import {
+  getRelationshipsPartPath,
+  type OpcPackageManifest,
+  type OpcPackagePart,
+} from "../ooxml/part-manifest.ts";
+import { writeOpcPackage } from "./package-writer.ts";
+
+export const DOCX_MIME_TYPE =
+  "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+export const DOCX_DOCUMENT_CONTENT_TYPE =
+  "application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml";
+export const DOCX_DOCUMENT_RELATIONSHIP_TYPE =
+  "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument";
+
+interface WriteDocxPackageInput {
+  documentXml: string;
+  documentContentType?: string;
+  packageRelationshipType?: string;
+}
+
+export function writeDocxPackage(input: WriteDocxPackageInput): Uint8Array {
+  const documentPath = "/word/document.xml";
+  const contentType = input.documentContentType ?? DOCX_DOCUMENT_CONTENT_TYPE;
+  const relationshipType =
+    input.packageRelationshipType ?? DOCX_DOCUMENT_RELATIONSHIP_TYPE;
+  const documentBytes = new TextEncoder().encode(input.documentXml);
+
+  const documentPart: OpcPackagePart = {
+    path: documentPath,
+    surfaceKind: "content",
+    contentType,
+    relationshipsPartPath: getRelationshipsPartPath(documentPath),
+    relationships: [],
+    compression: "deflate",
+    bytes: documentBytes,
+    crc32: 0,
+  };
+
+  const manifest: OpcPackageManifest = {
+    contentTypes: {
+      defaults: {
+        rels: "application/vnd.openxmlformats-package.relationships+xml",
+        xml: "application/xml",
+      },
+      overrides: {
+        [documentPath]: contentType,
+      },
+    },
+    packageRelationships: [
+      {
+        id: "rId1",
+        type: relationshipType,
+        target: "word/document.xml",
+        targetMode: "internal",
+      },
+    ],
+    parts: [
+      {
+        path: documentPart.path,
+        surfaceKind: documentPart.surfaceKind,
+        contentType: documentPart.contentType,
+        relationshipsPartPath: documentPart.relationshipsPartPath,
+        relationships: documentPart.relationships,
+        compression: documentPart.compression,
+        byteLength: documentPart.bytes.byteLength,
+      },
+    ],
+  };
+
+  return writeOpcPackage({
+    manifest,
+    parts: new Map([[documentPart.path, documentPart]]),
+  });
+}

package/src/io/opc/package-reader.ts

@@ -0,0 +1,325 @@
+import { inflateSync } from "fflate";
+
+import {
+  CONTENT_TYPES_PATH,
+  OpcCompressionMethod,
+  OpcPackageManifest,
+  OpcPackagePart,
+  OpcPartManifestEntry,
+  OpcRelationship,
+  PACKAGE_RELATIONSHIPS_PATH,
+  getRelationshipsPartPath,
+  getSourcePartPathFromRelationshipsPart,
+  normalizePartPath,
+} from "../ooxml/part-manifest.ts";
+
+interface ZipCentralDirectoryEntry {
+  path: string;
+  compression: OpcCompressionMethod;
+  crc32: number;
+  compressedSize: number;
+  uncompressedSize: number;
+  localHeaderOffset: number;
+  generalPurposeBitFlag: number;
+}
+
+export interface OpcPackage {
+  manifest: OpcPackageManifest;
+  parts: Map<string, OpcPackagePart>;
+  sourceByteLength: number;
+}
+
+const EOCD_SIGNATURE = 0x06054b50;
+const CENTRAL_DIRECTORY_SIGNATURE = 0x02014b50;
+const LOCAL_FILE_HEADER_SIGNATURE = 0x04034b50;
+
+export function readOpcPackage(source: Uint8Array | ArrayBuffer): OpcPackage {
+  const bytes = source instanceof Uint8Array ? source : new Uint8Array(source);
+  const centralDirectory = readCentralDirectory(bytes);
+  const parts = new Map<string, OpcPackagePart>();
+
+  for (const entry of centralDirectory) {
+    if (entry.path.endsWith("/")) {
+      continue;
+    }
+
+    const storedBytes = readZipEntry(bytes, entry);
+    const normalizedPath = normalizePartPath(entry.path);
+    const surfaceKind = getSurfaceKind(normalizedPath);
+
+    parts.set(normalizedPath, {
+      path: normalizedPath,
+      surfaceKind,
+      contentType: null,
+      relationshipsPartPath:
+        surfaceKind === "content" ? getRelationshipsPartPath(normalizedPath) : null,
+      relationships: [],
+      compression: entry.compression,
+      bytes: storedBytes,
+      crc32: entry.crc32 >>> 0,
+    });
+  }
+
+  const contentTypesPart = parts.get(CONTENT_TYPES_PATH);
+  if (!contentTypesPart) {
+    throw new Error("Invalid OPC package: missing /[Content_Types].xml.");
+  }
+
+  const contentTypes = parseContentTypesXml(decodeXml(contentTypesPart.bytes));
+  const packageRelationshipsPart = parts.get(PACKAGE_RELATIONSHIPS_PATH);
+  const packageRelationships = packageRelationshipsPart
+    ? parseRelationshipsXml(decodeXml(packageRelationshipsPart.bytes))
+    : [];
+
+  const manifestParts: OpcPartManifestEntry[] = [];
+
+  for (const [path, part] of [...parts.entries()].sort(([left], [right]) => left.localeCompare(right))) {
+    const contentType = resolveContentType(path, contentTypes);
+    const relationshipsPartPath = part.surfaceKind === "content" ? getRelationshipsPartPath(path) : null;
+    const relationshipsPart = relationshipsPartPath ? parts.get(relationshipsPartPath) : undefined;
+    const relationships = relationshipsPart
+      ? parseRelationshipsXml(decodeXml(relationshipsPart.bytes))
+      : [];
+
+    const nextPart: OpcPackagePart = {
+      ...part,
+      contentType,
+      relationshipsPartPath,
+      relationships,
+    };
+
+    parts.set(path, nextPart);
+    manifestParts.push({
+      path,
+      surfaceKind: nextPart.surfaceKind,
+      contentType,
+      relationshipsPartPath,
+      relationships,
+      compression: nextPart.compression,
+      byteLength: nextPart.bytes.byteLength,
+    });
+  }
+
+  return {
+    manifest: {
+      contentTypes,
+      packageRelationships,
+      parts: manifestParts,
+    },
+    parts,
+    sourceByteLength: bytes.byteLength,
+  };
+}
+
+function readCentralDirectory(archive: Uint8Array): ZipCentralDirectoryEntry[] {
+  const view = new DataView(archive.buffer, archive.byteOffset, archive.byteLength);
+  const eocdOffset = findEndOfCentralDirectory(archive, view);
+  const entryCount = view.getUint16(eocdOffset + 10, true);
+  const centralDirectoryOffset = view.getUint32(eocdOffset + 16, true);
+  const entries: ZipCentralDirectoryEntry[] = [];
+  let offset = centralDirectoryOffset;
+
+  for (let index = 0; index < entryCount; index += 1) {
+    const signature = view.getUint32(offset, true);
+    if (signature !== CENTRAL_DIRECTORY_SIGNATURE) {
+      throw new Error(`Invalid ZIP central directory signature at offset ${offset}.`);
+    }
+
+    const generalPurposeBitFlag = view.getUint16(offset + 8, true);
+    const compressionMethod = view.getUint16(offset + 10, true);
+    const crc32 = view.getUint32(offset + 16, true);
+    const compressedSize = view.getUint32(offset + 20, true);
+    const uncompressedSize = view.getUint32(offset + 24, true);
+    const fileNameLength = view.getUint16(offset + 28, true);
+    const extraFieldLength = view.getUint16(offset + 30, true);
+    const fileCommentLength = view.getUint16(offset + 32, true);
+    const localHeaderOffset = view.getUint32(offset + 42, true);
+    const fileNameOffset = offset + 46;
+    const fileName = decodeUtf8(archive.subarray(fileNameOffset, fileNameOffset + fileNameLength));
+
+    entries.push({
+      path: fileName,
+      compression: mapCompressionMethod(compressionMethod),
+      crc32,
+      compressedSize,
+      uncompressedSize,
+      localHeaderOffset,
+      generalPurposeBitFlag,
+    });
+
+    offset += 46 + fileNameLength + extraFieldLength + fileCommentLength;
+  }
+
+  return entries;
+}
+
+function findEndOfCentralDirectory(archive: Uint8Array, view: DataView): number {
+  const minimumEocdSize = 22;
+  const maximumCommentSize = 0xffff;
+  const searchStart = Math.max(0, archive.length - minimumEocdSize - maximumCommentSize);
+
+  for (let offset = archive.length - minimumEocdSize; offset >= searchStart; offset -= 1) {
+    if (view.getUint32(offset, true) === EOCD_SIGNATURE) {
+      return offset;
+    }
+  }
+
+  throw new Error("Invalid ZIP archive: end of central directory not found.");
+}
+
+function readZipEntry(archive: Uint8Array, entry: ZipCentralDirectoryEntry): Uint8Array {
+  const view = new DataView(archive.buffer, archive.byteOffset, archive.byteLength);
+  const headerOffset = entry.localHeaderOffset;
+  const signature = view.getUint32(headerOffset, true);
+  if (signature !== LOCAL_FILE_HEADER_SIGNATURE) {
+    throw new Error(`Invalid ZIP local file header signature at offset ${headerOffset}.`);
+  }
+
+  const fileNameLength = view.getUint16(headerOffset + 26, true);
+  const extraFieldLength = view.getUint16(headerOffset + 28, true);
+  const dataOffset = headerOffset + 30 + fileNameLength + extraFieldLength;
+  const compressed = archive.subarray(dataOffset, dataOffset + entry.compressedSize);
+
+  switch (entry.compression) {
+    case "store":
+      return new Uint8Array(compressed);
+    case "deflate":
+      return inflateSync(compressed);
+    default:
+      throw new Error(`Unsupported ZIP compression for ${entry.path}.`);
+  }
+}
+
+function mapCompressionMethod(method: number): OpcCompressionMethod {
+  switch (method) {
+    case 0:
+      return "store";
+    case 8:
+      return "deflate";
+    default:
+      throw new Error(`Unsupported ZIP compression method ${method}.`);
+  }
+}
+
+function getSurfaceKind(path: string): OpcPartManifestEntry["surfaceKind"] {
+  if (path === CONTENT_TYPES_PATH) {
+    return "content-types";
+  }
+
+  if (path === PACKAGE_RELATIONSHIPS_PATH || path.includes("/_rels/")) {
+    return "relationships";
+  }
+
+  return "content";
+}
+
+function decodeXml(bytes: Uint8Array): string {
+  return new TextDecoder("utf-8").decode(bytes);
+}
+
+function decodeUtf8(bytes: Uint8Array): string {
+  return new TextDecoder("utf-8").decode(bytes);
+}
+
+function parseContentTypesXml(xml: string): OpcPackageManifest["contentTypes"] {
+  const defaults: Record<string, string> = {};
+  const overrides: Record<string, string> = {};
+
+  for (const attributes of findTagAttributes(xml, "Default")) {
+    const extension = attributes.Extension?.toLowerCase();
+    const contentType = attributes.ContentType;
+    if (!extension || !contentType) {
+      continue;
+    }
+
+    defaults[extension] = contentType;
+  }
+
+  for (const attributes of findTagAttributes(xml, "Override")) {
+    const partName = attributes.PartName;
+    const contentType = attributes.ContentType;
+    if (!partName || !contentType) {
+      continue;
+    }
+
+    overrides[normalizePartPath(partName)] = contentType;
+  }
+
+  return { defaults, overrides };
+}
+
+function parseRelationshipsXml(xml: string): OpcRelationship[] {
+  const relationships: OpcRelationship[] = [];
+
+  for (const attributes of findTagAttributes(xml, "Relationship")) {
+    const id = attributes.Id;
+    const type = attributes.Type;
+    const target = attributes.Target;
+    if (!id || !type || !target) {
+      continue;
+    }
+
+    relationships.push({
+      id,
+      type,
+      target,
+      targetMode: attributes.TargetMode === "External" ? "external" : "internal",
+    });
+  }
+
+  return relationships;
+}
+
+function findTagAttributes(xml: string, tagName: string): Record<string, string>[] {
+  const tagPattern = new RegExp(`<(?:[A-Za-z_][\\w.-]*:)?${tagName}\\b([^>]*)\\/?>`, "g");
+  const results: Record<string, string>[] = [];
+  let tagMatch: RegExpExecArray | null = tagPattern.exec(xml);
+
+  while (tagMatch) {
+    results.push(parseAttributes(tagMatch[1] ?? ""));
+    tagMatch = tagPattern.exec(xml);
+  }
+
+  return results;
+}
+
+function parseAttributes(rawAttributes: string): Record<string, string> {
+  const attributes: Record<string, string> = {};
+  const attributePattern = /([A-Za-z_][\w:.-]*)\s*=\s*(["'])([\s\S]*?)\2/g;
+  let match: RegExpExecArray | null = attributePattern.exec(rawAttributes);
+
+  while (match) {
+    attributes[match[1]] = decodeXmlEntities(match[3]);
+    match = attributePattern.exec(rawAttributes);
+  }
+
+  return attributes;
+}
+
+function decodeXmlEntities(value: string): string {
+  return value
+    .replace(/&quot;/g, '"')
+    .replace(/&apos;/g, "'")
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">")
+    .replace(/&amp;/g, "&");
+}
+
+function resolveContentType(
+  path: string,
+  contentTypes: OpcPackageManifest["contentTypes"],
+): string | null {
+  if (path === CONTENT_TYPES_PATH) {
+    return "application/xml";
+  }
+
+  const override = contentTypes.overrides[path];
+  if (override) {
+    return override;
+  }
+
+  const extension = path.includes(".") ? path.slice(path.lastIndexOf(".") + 1).toLowerCase() : "";
+  return extension ? contentTypes.defaults[extension] ?? null : null;
+}
+
+export { parseContentTypesXml, parseRelationshipsXml };