@beyondwork/docx-react-component 1.0.1 → 1.0.3

package/src/io/ooxml/parse-complex-content.ts

@@ -0,0 +1,287 @@
+/**
+ * parse-complex-content.ts
+ *
+ * Parses complex OOXML content embedded in w:drawing elements:
+ * - Charts (c:chart via mc:AlternateContent, extracts fallback preview image)
+ * - SmartArt diagrams (dgm:* via mc:AlternateContent, extracts fallback preview image)
+ *
+ * These content types are rendered as read-only previews. The original XML is
+ * preserved in the canonical node's rawXml field for lossless round-trip export.
+ */
+
+import type { OpcRelationship } from "./part-manifest.ts";
+import { normalizePartPath, resolveRelationshipTarget } from "./part-manifest.ts";
+
+export interface InlineMediaPart {
+  path: string;
+  contentType: string;
+}
+
+export interface ParsedChartContent {
+  type: "chart_preview";
+  /** Media ID of the fallback preview image, if one is present in mc:Fallback. */
+  previewMediaId?: string;
+  /** Original drawing XML slice for lossless round-trip export. */
+  rawXml: string;
+}
+
+export interface ParsedSmartArtContent {
+  type: "smartart_preview";
+  /** Media ID of the fallback preview image, if one is present in mc:Fallback. */
+  previewMediaId?: string;
+  /** Original drawing XML slice for lossless round-trip export. */
+  rawXml: string;
+}
+
+export type ParsedComplexContent = ParsedChartContent | ParsedSmartArtContent;
+
+const CHART_GRAPHIC_URI = "http://schemas.openxmlformats.org/drawingml/2006/chart";
+const CHART_GRAPHIC_URI_ALT = "http://schemas.microsoft.com/office/drawing/2007/8/2/chart";
+const SMARTART_GRAPHIC_URI = "http://schemas.microsoft.com/office/drawing/2007/8/2/diagram";
+const SMARTART_GRAPHIC_URI_ALT = "http://schemas.openxmlformats.org/drawingml/2006/diagram";
+const PICTURE_GRAPHIC_URI = "http://schemas.openxmlformats.org/drawingml/2006/picture";
+
+/**
+ * Attempt to parse a w:drawing XML fragment as chart or SmartArt complex content.
+ *
+ * Returns null if the drawing contains only a plain image (handled by parseInlineMediaXml)
+ * or unrecognised content.
+ */
+export function parseComplexContentXml(
+  drawingXml: string,
+  relationships: readonly OpcRelationship[],
+  mediaParts: ReadonlyMap<string, InlineMediaPart> = new Map(),
+  sourcePartPath = "/word/document.xml",
+): ParsedComplexContent | null {
+  const root = parseXml(drawingXml);
+  const relationshipMap = new Map(relationships.map((r) => [r.id, r]));
+
+  // Look for mc:AlternateContent at any depth
+  const altContent = findFirstDescendant(root, "AlternateContent");
+  if (altContent) {
+    return parseAlternateContent(altContent, drawingXml, relationshipMap, mediaParts, sourcePartPath);
+  }
+
+  // No mc:AlternateContent — look for direct graphic data
+  const graphicData = findFirstDescendant(root, "graphicData");
+  if (!graphicData) {
+    return null;
+  }
+
+  const uri = graphicData.attributes.uri ?? graphicData.attributes["uri"] ?? "";
+  if (isChartUri(uri)) {
+    return { type: "chart_preview", rawXml: drawingXml };
+  }
+  if (isSmartArtUri(uri)) {
+    return { type: "smartart_preview", rawXml: drawingXml };
+  }
+
+  return null;
+}
+
+function parseAlternateContent(
+  altContent: XmlElementNode,
+  fullDrawingXml: string,
+  relationshipMap: Map<string, OpcRelationship>,
+  mediaParts: ReadonlyMap<string, InlineMediaPart>,
+  sourcePartPath: string,
+): ParsedComplexContent | null {
+  const choice = findFirstChild(altContent, "Choice");
+  const fallback = findFirstChild(altContent, "Fallback");
+
+  // Determine content type from Choice element
+  const choiceGraphicData = choice ? findFirstDescendant(choice, "graphicData") : null;
+  const choiceUri = choiceGraphicData?.attributes.uri ?? "";
+
+  let contentType: "chart_preview" | "smartart_preview" | null = null;
+  if (isChartUri(choiceUri)) {
+    contentType = "chart_preview";
+  } else if (isSmartArtUri(choiceUri)) {
+    contentType = "smartart_preview";
+  } else {
+    // Check for chart/SmartArt relationship references in the choice
+    const chartRef = choice ? findFirstDescendant(choice, "chart") : null;
+    if (chartRef) {
+      contentType = "chart_preview";
+    }
+    const dmRef = choice ? findFirstDescendant(choice, "relIds") : null;
+    if (dmRef) {
+      contentType = "smartart_preview";
+    }
+  }
+
+  if (!contentType) {
+    return null;
+  }
+
+  // Extract fallback preview image if present
+  let previewMediaId: string | undefined;
+  if (fallback) {
+    const fallbackBlip = findFirstDescendant(fallback, "blip");
+    if (fallbackBlip) {
+      const rId =
+        fallbackBlip.attributes["r:embed"] ??
+        fallbackBlip.attributes.embed ??
+        fallbackBlip.attributes["r:link"];
+      if (rId) {
+        const rel = relationshipMap.get(rId);
+        if (rel && rel.type.endsWith("/image")) {
+          const packagePartName = normalizePartPath(
+            resolveRelationshipTarget(sourcePartPath, rel),
+          );
+          const mediaPart = mediaParts.get(packagePartName);
+          if (mediaPart) {
+            previewMediaId = `media:${packagePartName.slice(1)}`;
+          }
+        }
+      }
+    }
+  }
+
+  return {
+    type: contentType,
+    ...(previewMediaId ? { previewMediaId } : {}),
+    rawXml: fullDrawingXml,
+  };
+}
+
+function isChartUri(uri: string): boolean {
+  return uri === CHART_GRAPHIC_URI || uri === CHART_GRAPHIC_URI_ALT;
+}
+
+function isSmartArtUri(uri: string): boolean {
+  return (
+    uri === SMARTART_GRAPHIC_URI ||
+    uri === SMARTART_GRAPHIC_URI_ALT ||
+    uri.includes("diagram") ||
+    uri.includes("dgm")
+  );
+}
+
+// ---- Minimal XML parser (local, self-contained) ----
+
+interface XmlElementNode {
+  type: "element";
+  name: string;
+  attributes: Record<string, string>;
+  children: XmlNode[];
+}
+
+interface XmlTextNode {
+  type: "text";
+  text: string;
+}
+
+type XmlNode = XmlElementNode | XmlTextNode;
+
+function findFirstChild(node: XmlElementNode, local: string): XmlElementNode | undefined {
+  for (const child of node.children) {
+    if (child.type === "element" && localName(child.name) === local) {
+      return child;
+    }
+  }
+  return undefined;
+}
+
+function findFirstDescendant(node: XmlElementNode, local: string): XmlElementNode | undefined {
+  for (const child of node.children) {
+    if (child.type !== "element") continue;
+    if (localName(child.name) === local) return child;
+    const nested = findFirstDescendant(child, local);
+    if (nested) return nested;
+  }
+  return undefined;
+}
+
+function localName(name: string): string {
+  const i = name.indexOf(":");
+  return i >= 0 ? name.slice(i + 1) : name;
+}
+
+function parseXml(xml: string): XmlElementNode {
+  const root: XmlElementNode = { type: "element", name: "__root__", attributes: {}, children: [] };
+  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[cursor] !== "<") {
+      const nextTag = xml.indexOf("<", cursor);
+      const end = nextTag >= 0 ? nextTag : xml.length;
+      const text = xml.slice(cursor, end);
+      if (text.length > 0) {
+        stack[stack.length - 1]?.children.push({ type: "text", text });
+      }
+      cursor = end;
+      continue;
+    }
+    if (xml[cursor + 1] === "/") {
+      const end = xml.indexOf(">", cursor);
+      stack.pop();
+      cursor = end + 1;
+      continue;
+    }
+    const tagEnd = findTagEnd(xml, cursor);
+    const tagBody = xml.slice(cursor + 1, tagEnd);
+    const selfClosing = /\/\s*$/.test(tagBody);
+    const { name, attributes } = parseTag(tagBody.replace(/\/\s*$/, "").trim());
+    const element: XmlElementNode = { type: "element", name, attributes, children: [] };
+    stack[stack.length - 1]?.children.push(element);
+    if (!selfClosing) stack.push(element);
+    cursor = tagEnd + 1;
+  }
+
+  return root;
+}
+
+function parseTag(tagBody: string): { name: string; attributes: Record<string, string> } {
+  let cursor = 0;
+  while (cursor < tagBody.length && /\s/.test(tagBody[cursor] ?? "")) cursor++;
+  const nameStart = cursor;
+  while (cursor < tagBody.length && !/\s/.test(tagBody[cursor] ?? "")) cursor++;
+  const name = tagBody.slice(nameStart, cursor);
+  const attributes: Record<string, string> = {};
+
+  while (cursor < tagBody.length) {
+    while (cursor < tagBody.length && /\s/.test(tagBody[cursor] ?? "")) cursor++;
+    if (cursor >= tagBody.length) break;
+    const keyStart = cursor;
+    while (cursor < tagBody.length && !/[\s=]/.test(tagBody[cursor] ?? "")) cursor++;
+    const key = tagBody.slice(keyStart, cursor);
+    while (cursor < tagBody.length && /\s/.test(tagBody[cursor] ?? "")) cursor++;
+    if (tagBody[cursor] !== "=") { attributes[key] = ""; continue; }
+    cursor++;
+    while (cursor < tagBody.length && /\s/.test(tagBody[cursor] ?? "")) cursor++;
+    const quote = tagBody[cursor];
+    if (quote !== `"` && quote !== `'`) break;
+    cursor++;
+    const valueStart = cursor;
+    while (cursor < tagBody.length && tagBody[cursor] !== quote) cursor++;
+    attributes[key] = tagBody.slice(valueStart, cursor);
+    cursor++;
+  }
+
+  return { name, attributes };
+}
+
+function findTagEnd(xml: string, start: number): number {
+  let cursor = start + 1;
+  let quote: string | null = null;
+  while (cursor < xml.length) {
+    const c = xml[cursor];
+    if (quote) { if (c === quote) quote = null; cursor++; continue; }
+    if (c === `"` || c === `'`) { quote = c; cursor++; continue; }
+    if (c === ">") return cursor;
+    cursor++;
+  }
+  return xml.length - 1;
+}