@beyondwork/docx-react-component 1.0.27 → 1.0.29

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

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

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

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