@beyondwork/docx-react-component 1.0.0

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

@@ -0,0 +1,320 @@
+import { inflateRawSync } from "node:zlib";
+
+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 archive = Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const centralDirectory = readCentralDirectory(archive);
+  const parts = new Map<string, OpcPackagePart>();
+
+  for (const entry of centralDirectory) {
+    if (entry.path.endsWith("/")) {
+      continue;
+    }
+
+    const storedBytes = readZipEntry(archive, 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: Buffer): ZipCentralDirectoryEntry[] {
+  const eocdOffset = findEndOfCentralDirectory(archive);
+  const entryCount = archive.readUInt16LE(eocdOffset + 10);
+  const centralDirectoryOffset = archive.readUInt32LE(eocdOffset + 16);
+  const entries: ZipCentralDirectoryEntry[] = [];
+  let offset = centralDirectoryOffset;
+
+  for (let index = 0; index < entryCount; index += 1) {
+    const signature = archive.readUInt32LE(offset);
+    if (signature !== CENTRAL_DIRECTORY_SIGNATURE) {
+      throw new Error(`Invalid ZIP central directory signature at offset ${offset}.`);
+    }
+
+    const generalPurposeBitFlag = archive.readUInt16LE(offset + 8);
+    const compressionMethod = archive.readUInt16LE(offset + 10);
+    const crc32 = archive.readUInt32LE(offset + 16);
+    const compressedSize = archive.readUInt32LE(offset + 20);
+    const uncompressedSize = archive.readUInt32LE(offset + 24);
+    const fileNameLength = archive.readUInt16LE(offset + 28);
+    const extraFieldLength = archive.readUInt16LE(offset + 30);
+    const fileCommentLength = archive.readUInt16LE(offset + 32);
+    const localHeaderOffset = archive.readUInt32LE(offset + 42);
+    const fileNameOffset = offset + 46;
+    const fileName = archive.subarray(fileNameOffset, fileNameOffset + fileNameLength).toString("utf8");
+
+    entries.push({
+      path: fileName,
+      compression: mapCompressionMethod(compressionMethod),
+      crc32,
+      compressedSize,
+      uncompressedSize,
+      localHeaderOffset,
+      generalPurposeBitFlag,
+    });
+
+    offset += 46 + fileNameLength + extraFieldLength + fileCommentLength;
+  }
+
+  return entries;
+}
+
+function findEndOfCentralDirectory(archive: Buffer): 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 (archive.readUInt32LE(offset) === EOCD_SIGNATURE) {
+      return offset;
+    }
+  }
+
+  throw new Error("Invalid ZIP archive: end of central directory not found.");
+}
+
+function readZipEntry(archive: Buffer, entry: ZipCentralDirectoryEntry): Uint8Array {
+  const headerOffset = entry.localHeaderOffset;
+  const signature = archive.readUInt32LE(headerOffset);
+  if (signature !== LOCAL_FILE_HEADER_SIGNATURE) {
+    throw new Error(`Invalid ZIP local file header signature at offset ${headerOffset}.`);
+  }
+
+  const fileNameLength = archive.readUInt16LE(headerOffset + 26);
+  const extraFieldLength = archive.readUInt16LE(headerOffset + 28);
+  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 new Uint8Array(inflateRawSync(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 Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength).toString("utf8");
+}
+
+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(`<${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:.-]*)="([^"]*)"/g;
+  let match: RegExpExecArray | null = attributePattern.exec(rawAttributes);
+
+  while (match) {
+    attributes[match[1]] = decodeXmlEntities(match[2]);
+    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 };

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

@@ -0,0 +1,273 @@
+import {
+  CONTENT_TYPES_PATH,
+  OpcCompressionMethod,
+  OpcPackageManifest,
+  OpcPackagePart,
+  OpcRelationship,
+  PACKAGE_RELATIONSHIPS_PATH,
+  comparePartPaths,
+  getExtension,
+  getRelationshipsPartPath,
+  normalizePartPath,
+} from "../ooxml/part-manifest.ts";
+import type { OpcPackage } from "./package-reader.ts";
+
+interface ZipEntryPayload {
+  path: string;
+  compression: OpcCompressionMethod;
+  uncompressedBytes: Uint8Array;
+  compressedBytes: Uint8Array;
+  crc32: number;
+}
+
+export function writeOpcPackage(input: OpcPackage | { manifest: OpcPackageManifest; parts: Map<string, OpcPackagePart> }): Uint8Array {
+  const entries = collectZipEntries(input.manifest, input.parts);
+  return buildZipArchive(entries);
+}
+
+function collectZipEntries(
+  manifest: OpcPackageManifest,
+  parts: Map<string, OpcPackagePart>,
+): ZipEntryPayload[] {
+  const entries: ZipEntryPayload[] = [];
+  const contentParts = [...parts.values()]
+    .filter((part) => part.surfaceKind === "content")
+    .sort((left, right) => comparePartPaths(left.path, right.path));
+
+  entries.push(createZipPayload(CONTENT_TYPES_PATH, "deflate", encodeXml(buildContentTypesXml(manifest, contentParts))));
+  entries.push(
+    createZipPayload(
+      PACKAGE_RELATIONSHIPS_PATH,
+      "deflate",
+      encodeXml(buildRelationshipsXml(manifest.packageRelationships)),
+    ),
+  );
+
+  for (const part of contentParts) {
+    entries.push(createZipPayload(part.path, part.compression, part.bytes));
+
+    if (part.relationships.length > 0) {
+      entries.push(
+        createZipPayload(
+          getRelationshipsPartPath(part.path),
+          "deflate",
+          encodeXml(buildRelationshipsXml(part.relationships)),
+        ),
+      );
+    }
+  }
+
+  return entries.sort((left, right) => comparePartPaths(left.path, right.path));
+}
+
+function buildContentTypesXml(
+  manifest: OpcPackageManifest,
+  parts: OpcPackagePart[],
+): string {
+  const defaults: Record<string, string> = {
+    ...manifest.contentTypes.defaults,
+    rels: manifest.contentTypes.defaults.rels ?? "application/vnd.openxmlformats-package.relationships+xml",
+    xml: manifest.contentTypes.defaults.xml ?? "application/xml",
+  };
+
+  const overrides = { ...manifest.contentTypes.overrides };
+
+  for (const part of parts) {
+    if (!part.contentType) {
+      throw new Error(`Cannot write OPC package: missing content type for ${part.path}.`);
+    }
+
+    const extension = getExtension(part.path);
+    if (!extension) {
+      overrides[part.path] = part.contentType;
+      continue;
+    }
+
+    const defaultContentType = defaults[extension];
+    if (!defaultContentType) {
+      defaults[extension] = part.contentType;
+      delete overrides[part.path];
+      continue;
+    }
+
+    if (defaultContentType === part.contentType) {
+      delete overrides[part.path];
+      continue;
+    }
+
+    overrides[part.path] = part.contentType;
+  }
+
+  const defaultEntries = Object.entries(defaults).sort(([left], [right]) => left.localeCompare(right));
+  const overrideEntries = Object.entries(overrides).sort(([left], [right]) => comparePartPaths(left, right));
+
+  const defaultXml = defaultEntries
+    .map(([extension, contentType]) => `  <Default Extension="${escapeXml(extension)}" ContentType="${escapeXml(contentType)}"/>`)
+    .join("\n");
+  const overrideXml = overrideEntries
+    .map(([partName, contentType]) => `  <Override PartName="${escapeXml(partName)}" ContentType="${escapeXml(contentType)}"/>`)
+    .join("\n");
+  const body = [defaultXml, overrideXml].filter((value) => value.length > 0).join("\n");
+
+  return [
+    `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>`,
+    `<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">`,
+    body,
+    `</Types>`,
+  ].join("\n");
+}
+
+function buildRelationshipsXml(relationships: OpcRelationship[]): string {
+  const relationshipXml = [...relationships]
+    .sort((left, right) => left.id.localeCompare(right.id))
+    .map((relationship) => {
+      const targetMode =
+        relationship.targetMode === "external"
+          ? ` TargetMode="External"`
+          : "";
+      return `  <Relationship Id="${escapeXml(relationship.id)}" Type="${escapeXml(relationship.type)}" Target="${escapeXml(relationship.target)}"${targetMode}/>`;
+    })
+    .join("\n");
+
+  return [
+    `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>`,
+    `<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">`,
+    relationshipXml,
+    `</Relationships>`,
+  ].join("\n");
+}
+
+function createZipPayload(
+  path: string,
+  compression: OpcCompressionMethod,
+  bytes: Uint8Array,
+): ZipEntryPayload {
+  const normalizedPath = normalizePartPath(path).slice(1);
+  const uncompressedBytes = new Uint8Array(bytes);
+  // Keep export browser-safe by storing entries without Node-only compression primitives.
+  const compressedBytes = uncompressedBytes;
+  const effectiveCompression: OpcCompressionMethod = "store";
+
+  return {
+    path: normalizedPath,
+    compression: effectiveCompression,
+    uncompressedBytes,
+    compressedBytes,
+    crc32: calculateCrc32(uncompressedBytes),
+  };
+}
+
+function buildZipArchive(entries: ZipEntryPayload[]): Uint8Array {
+  const localChunks: Uint8Array[] = [];
+  const centralChunks: Uint8Array[] = [];
+  let localOffset = 0;
+
+  for (const entry of entries) {
+    const fileName = encodeUtf8(entry.path);
+    const localHeader = createByteBuffer(30 + fileName.length);
+    const localHeaderView = new DataView(localHeader.buffer);
+    localHeaderView.setUint32(0, 0x04034b50, true);
+    localHeaderView.setUint16(4, 20, true);
+    localHeaderView.setUint16(6, 0, true);
+    localHeaderView.setUint16(8, entry.compression === "store" ? 0 : 8, true);
+    localHeaderView.setUint16(10, 0, true);
+    localHeaderView.setUint16(12, 0, true);
+    localHeaderView.setUint32(14, entry.crc32 >>> 0, true);
+    localHeaderView.setUint32(18, entry.compressedBytes.byteLength, true);
+    localHeaderView.setUint32(22, entry.uncompressedBytes.byteLength, true);
+    localHeaderView.setUint16(26, fileName.length, true);
+    localHeaderView.setUint16(28, 0, true);
+    localHeader.set(fileName, 30);
+
+    localChunks.push(localHeader, entry.compressedBytes);
+
+    const centralHeader = createByteBuffer(46 + fileName.length);
+    const centralHeaderView = new DataView(centralHeader.buffer);
+    centralHeaderView.setUint32(0, 0x02014b50, true);
+    centralHeaderView.setUint16(4, 20, true);
+    centralHeaderView.setUint16(6, 20, true);
+    centralHeaderView.setUint16(8, 0, true);
+    centralHeaderView.setUint16(10, entry.compression === "store" ? 0 : 8, true);
+    centralHeaderView.setUint16(12, 0, true);
+    centralHeaderView.setUint16(14, 0, true);
+    centralHeaderView.setUint32(16, entry.crc32 >>> 0, true);
+    centralHeaderView.setUint32(20, entry.compressedBytes.byteLength, true);
+    centralHeaderView.setUint32(24, entry.uncompressedBytes.byteLength, true);
+    centralHeaderView.setUint16(28, fileName.length, true);
+    centralHeaderView.setUint16(30, 0, true);
+    centralHeaderView.setUint16(32, 0, true);
+    centralHeaderView.setUint16(34, 0, true);
+    centralHeaderView.setUint16(36, 0, true);
+    centralHeaderView.setUint32(38, 0, true);
+    centralHeaderView.setUint32(42, localOffset, true);
+    centralHeader.set(fileName, 46);
+    centralChunks.push(centralHeader);
+
+    localOffset += localHeader.byteLength + entry.compressedBytes.byteLength;
+  }
+
+  const centralDirectoryOffset = localOffset;
+  const centralDirectory = concatByteArrays(centralChunks);
+  const endOfCentralDirectory = createByteBuffer(22);
+  const endOfCentralDirectoryView = new DataView(endOfCentralDirectory.buffer);
+  endOfCentralDirectoryView.setUint32(0, 0x06054b50, true);
+  endOfCentralDirectoryView.setUint16(4, 0, true);
+  endOfCentralDirectoryView.setUint16(6, 0, true);
+  endOfCentralDirectoryView.setUint16(8, entries.length, true);
+  endOfCentralDirectoryView.setUint16(10, entries.length, true);
+  endOfCentralDirectoryView.setUint32(12, centralDirectory.byteLength, true);
+  endOfCentralDirectoryView.setUint32(16, centralDirectoryOffset, true);
+  endOfCentralDirectoryView.setUint16(20, 0, true);
+
+  return concatByteArrays([...localChunks, centralDirectory, endOfCentralDirectory]);
+}
+
+function encodeXml(xml: string): Uint8Array {
+  return encodeUtf8(xml);
+}
+
+function escapeXml(value: string): string {
+  return value
+    .replace(/&/g, "&amp;")
+    .replace(/"/g, "&quot;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/'/g, "&apos;");
+}
+
+function calculateCrc32(bytes: Uint8Array): number {
+  let crc = 0xffffffff;
+
+  for (const byte of bytes) {
+    crc ^= byte;
+    for (let bit = 0; bit < 8; bit += 1) {
+      const mask = -(crc & 1);
+      crc = (crc >>> 1) ^ (0xedb88320 & mask);
+    }
+  }
+
+  return (crc ^ 0xffffffff) >>> 0;
+}
+
+function createByteBuffer(size: number): Uint8Array {
+  return new Uint8Array(size);
+}
+
+function concatByteArrays(chunks: readonly Uint8Array[]): Uint8Array {
+  const totalLength = chunks.reduce((sum, chunk) => sum + chunk.byteLength, 0);
+  const combined = new Uint8Array(totalLength);
+  let offset = 0;
+
+  for (const chunk of chunks) {
+    combined.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+
+  return combined;
+}
+
+function encodeUtf8(value: string): Uint8Array {
+  return new TextEncoder().encode(value);
+}
+
+export { buildContentTypesXml, buildRelationshipsXml, calculateCrc32 };

package/src/model/README.md

@@ -0,0 +1,3 @@
+# Model
+
+Canonical document envelope types, schema versions, persisted snapshots, and migration contracts belong here.