@beyondwork/docx-react-component 1.0.1 → 1.0.2

package/src/io/ooxml/revision-boundaries.ts

@@ -0,0 +1,351 @@
+export interface XmlElementNode {
+  type: "element";
+  name: string;
+  attributes: Record<string, string>;
+  children: XmlNode[];
+  start: number;
+  end: number;
+  openingTagEnd: number;
+  closingTagStart: number;
+}
+
+export interface XmlTextNode {
+  type: "text";
+  text: string;
+  start: number;
+  end: number;
+}
+
+export type XmlNode = XmlElementNode | XmlTextNode;
+
+export interface RevisionParagraphBoundary {
+  paragraphIndex: number;
+  start: number;
+  end: number;
+  boundaries: Map<number, number>;
+  paragraphStart: number;
+  paragraphStartTagEnd: number;
+  paragraphEndTagStart: number;
+  paragraphEnd: number;
+  paragraphPropertiesStart?: number;
+  paragraphPropertiesEnd?: number;
+  paragraphRunPropertiesStart?: number;
+  paragraphRunPropertiesEnd?: number;
+}
+
+export function mapRevisionBoundaries(
+  documentXml: string,
+): RevisionParagraphBoundary[] {
+  const root = parseXmlWithPositions(documentXml);
+  const documentElement = findRequiredChildElement(root, "document");
+  const bodyElement = findRequiredChildElement(documentElement, "body");
+  const paragraphs: RevisionParagraphBoundary[] = [];
+  let cursor = 0;
+  let paragraphIndex = -1;
+  let previousWasParagraph = false;
+
+  for (const child of bodyElement.children) {
+    if (child.type !== "element") {
+      continue;
+    }
+
+    if (localName(child.name) !== "p") {
+      cursor += 1;
+      previousWasParagraph = false;
+      continue;
+    }
+
+    if (previousWasParagraph) {
+      cursor += 1;
+    }
+    paragraphIndex += 1;
+    const boundaries = new Map<number, number>();
+    boundaries.set(cursor, child.openingTagEnd);
+
+    const paragraphProperties = findChildElement(child, "pPr");
+    const paragraphRunProperties = paragraphProperties
+      ? findChildElement(paragraphProperties, "rPr")
+      : undefined;
+
+    walkStoryNodesForBoundaries(
+      child.children,
+      boundaries,
+      () => cursor,
+      (next) => {
+        cursor = next;
+      },
+    );
+
+    boundaries.set(cursor, child.closingTagStart);
+    paragraphs.push({
+      paragraphIndex,
+      start: Math.min(...boundaries.keys()),
+      end: Math.max(...boundaries.keys()),
+      boundaries,
+      paragraphStart: child.start,
+      paragraphStartTagEnd: child.openingTagEnd,
+      paragraphEndTagStart: child.closingTagStart,
+      paragraphEnd: child.end,
+      ...(paragraphProperties
+        ? {
+            paragraphPropertiesStart: paragraphProperties.start,
+            paragraphPropertiesEnd: paragraphProperties.end,
+          }
+        : {}),
+      ...(paragraphRunProperties
+        ? {
+            paragraphRunPropertiesStart: paragraphRunProperties.start,
+            paragraphRunPropertiesEnd: paragraphRunProperties.end,
+          }
+        : {}),
+    });
+    previousWasParagraph = true;
+  }
+
+  return paragraphs;
+}
+
+function walkStoryNodesForBoundaries(
+  nodes: XmlNode[],
+  boundaries: Map<number, number>,
+  getCursor: () => number,
+  setCursor: (next: number) => void,
+): void {
+  for (const node of nodes) {
+    walkStoryNodeForBoundaries(node, boundaries, getCursor, setCursor);
+  }
+}
+
+function walkStoryNodeForBoundaries(
+  node: XmlNode,
+  boundaries: Map<number, number>,
+  getCursor: () => number,
+  setCursor: (next: number) => void,
+): void {
+  if (node.type !== "element") {
+    return;
+  }
+
+  switch (localName(node.name)) {
+    case "pPr":
+      return;
+    case "r":
+      boundaries.set(getCursor(), node.start);
+      for (const child of node.children) {
+        walkStoryNodeForBoundaries(child, boundaries, getCursor, setCursor);
+      }
+      boundaries.set(getCursor(), node.end);
+      return;
+    case "ins":
+    case "del":
+    case "moveFrom":
+    case "moveTo":
+    case "hyperlink":
+    case "smartTag":
+    case "sdtContent":
+    case "customXml":
+      for (const child of node.children) {
+        walkStoryNodeForBoundaries(child, boundaries, getCursor, setCursor);
+      }
+      return;
+    case "t":
+    case "delText":
+    case "instrText":
+    case "delInstrText": {
+      const text = node.children
+        .filter((child): child is XmlTextNode => child.type === "text")
+        .map((child) => child.text)
+        .join("");
+      if (text.length === 0) {
+        return;
+      }
+
+      if (!boundaries.has(getCursor())) {
+        boundaries.set(getCursor(), node.start);
+      }
+      setCursor(getCursor() + text.length);
+      boundaries.set(getCursor(), node.end);
+      return;
+    }
+    case "tab":
+    case "br":
+    case "cr":
+      if (!boundaries.has(getCursor())) {
+        boundaries.set(getCursor(), node.start);
+      }
+      setCursor(getCursor() + 1);
+      boundaries.set(getCursor(), node.end);
+      return;
+    default:
+      for (const child of node.children) {
+        walkStoryNodeForBoundaries(child, boundaries, getCursor, setCursor);
+      }
+  }
+}
+
+export function parseXmlWithPositions(xml: string): XmlElementNode {
+  const root: XmlElementNode = {
+    type: "element",
+    name: "__root__",
+    attributes: {},
+    children: [],
+    start: 0,
+    end: xml.length,
+    openingTagEnd: 0,
+    closingTagStart: xml.length,
+  };
+  const stack: XmlElementNode[] = [root];
+  let cursor = 0;
+
+  while (cursor < xml.length) {
+    if (xml.startsWith("<!--", cursor)) {
+      const end = xml.indexOf("-->", cursor);
+      cursor = end >= 0 ? end + 3 : xml.length;
+      continue;
+    }
+
+    if (xml.startsWith("<?", cursor)) {
+      const end = xml.indexOf("?>", cursor);
+      cursor = end >= 0 ? end + 2 : xml.length;
+      continue;
+    }
+
+    if (xml.startsWith("<![CDATA[", cursor)) {
+      const end = xml.indexOf("]]>", cursor);
+      const textEnd = end >= 0 ? end : xml.length;
+      stack[stack.length - 1]?.children.push({
+        type: "text",
+        text: xml.slice(cursor + 9, textEnd),
+        start: cursor,
+        end: textEnd,
+      });
+      cursor = end >= 0 ? end + 3 : xml.length;
+      continue;
+    }
+
+    if (xml[cursor] !== "<") {
+      const nextTag = xml.indexOf("<", cursor);
+      const end = nextTag >= 0 ? nextTag : xml.length;
+      const text = decodeXmlEntities(xml.slice(cursor, end));
+      if (text.length > 0) {
+        stack[stack.length - 1]?.children.push({
+          type: "text",
+          text,
+          start: cursor,
+          end,
+        });
+      }
+      cursor = end;
+      continue;
+    }
+
+    if (xml[cursor + 1] === "/") {
+      const tagEnd = xml.indexOf(">", cursor);
+      if (tagEnd < 0) {
+        throw new Error("Malformed XML: unterminated closing tag.");
+      }
+
+      const node = stack.pop();
+      if (!node || stack.length === 0) {
+        throw new Error("Malformed XML: unexpected closing tag.");
+      }
+
+      node.closingTagStart = cursor;
+      node.end = tagEnd + 1;
+      cursor = tagEnd + 1;
+      continue;
+    }
+
+    const tagEnd = xml.indexOf(">", cursor);
+    if (tagEnd < 0) {
+      throw new Error("Malformed XML: unterminated opening tag.");
+    }
+
+    const rawTag = xml.slice(cursor + 1, tagEnd);
+    const selfClosing = /\/\s*$/.test(rawTag);
+    const normalizedTag = selfClosing ? rawTag.replace(/\/\s*$/, "") : rawTag;
+    const parts = normalizedTag.trim().split(/\s+/, 1);
+    const name = parts[0];
+    if (!name) {
+      throw new Error("Malformed XML: empty tag name.");
+    }
+
+    const attributes = parseAttributes(normalizedTag.slice(name.length));
+    const node: XmlElementNode = {
+      type: "element",
+      name,
+      attributes,
+      children: [],
+      start: cursor,
+      end: selfClosing ? tagEnd + 1 : xml.length,
+      openingTagEnd: tagEnd + 1,
+      closingTagStart: tagEnd + 1,
+    };
+
+    stack[stack.length - 1]?.children.push(node);
+    cursor = tagEnd + 1;
+
+    if (!selfClosing) {
+      stack.push(node);
+    }
+  }
+
+  if (stack.length !== 1) {
+    throw new Error("Malformed XML: unclosed element.");
+  }
+
+  return root;
+}
+
+export function findRequiredChildElement(
+  node: XmlElementNode,
+  childLocalName: string,
+): XmlElementNode {
+  const child = findChildElement(node, childLocalName);
+  if (!child) {
+    throw new Error(`Expected <${childLocalName}> element.`);
+  }
+
+  return child;
+}
+
+export function findChildElement(
+  node: XmlElementNode,
+  childLocalName: string,
+): XmlElementNode | undefined {
+  return node.children.find(
+    (entry): entry is XmlElementNode =>
+      entry.type === "element" && localName(entry.name) === childLocalName,
+  );
+}
+
+export function localName(name: string): string {
+  const separatorIndex = name.indexOf(":");
+  return separatorIndex >= 0 ? name.slice(separatorIndex + 1) : name;
+}
+
+function parseAttributes(source: string): Record<string, string> {
+  const attributes: Record<string, string> = {};
+  const attributePattern = /([A-Za-z_][A-Za-z0-9:._-]*)\s*=\s*("([^"]*)"|'([^']*)')/g;
+
+  for (const match of source.matchAll(attributePattern)) {
+    const key = match[1];
+    if (!key) {
+      continue;
+    }
+
+    const rawValue = match[3] ?? match[4] ?? "";
+    attributes[key] = decodeXmlEntities(rawValue);
+  }
+
+  return attributes;
+}
+
+function decodeXmlEntities(value: string): string {
+  return value
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">")
+    .replace(/&quot;/g, "\"")
+    .replace(/&apos;/g, "'")
+    .replace(/&amp;/g, "&");
+}

package/src/io/opc/README.md

@@ -0,0 +1,3 @@
+# IO OPC
+
+Open Packaging Conventions package reading, part enumeration, and relationship handling belong here.

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]]),
+  });
+}