@beyondwork/docx-react-component 1.0.18 → 1.0.19

package/src/io/ooxml/parse-settings.ts

@@ -0,0 +1,184 @@
+import type { DocumentSettings } from "../../model/canonical-document.ts";
+
+interface XmlElementNode {
+  type: "element";
+  name: string;
+  attributes: Record<string, string>;
+  children: XmlNode[];
+}
+
+interface XmlTextNode {
+  type: "text";
+  text: string;
+}
+
+type XmlNode = XmlElementNode | XmlTextNode;
+
+export function parseSettingsXml(xml: string): DocumentSettings {
+  if (!xml.trim()) {
+    return {};
+  }
+
+  const root = parseXml(xml);
+  const settingsElement = findChildElementOptional(root, "settings");
+  if (!settingsElement) {
+    return {};
+  }
+
+  const evenAndOddHeaders = findChildElementOptional(settingsElement, "evenAndOddHeaders");
+  const zoom = findChildElementOptional(settingsElement, "zoom");
+
+  return {
+    ...(evenAndOddHeaders
+      ? {
+          evenAndOddHeaders: readOnOffValue(evenAndOddHeaders, true),
+        }
+      : {}),
+    ...(zoom ? readZoomLevel(zoom) : {}),
+  };
+}
+
+function findChildElementOptional(
+  node: XmlElementNode,
+  childLocalName: string,
+): XmlElementNode | undefined {
+  return node.children.find(
+    (entry): entry is XmlElementNode =>
+      entry.type === "element" && localName(entry.name) === childLocalName,
+  );
+}
+
+function localName(name: string): string {
+  const idx = name.indexOf(":");
+  return idx >= 0 ? name.slice(idx + 1) : name;
+}
+
+function readOnOffValue(
+  element: XmlElementNode,
+  defaultValue: boolean,
+): boolean {
+  const value =
+    element.attributes["w:val"] ??
+    element.attributes.val ??
+    (defaultValue ? "true" : "false");
+  return value !== "0" && value !== "false";
+}
+
+function readZoomLevel(
+  element: XmlElementNode,
+): Pick<DocumentSettings, "zoomLevel"> {
+  const rawValue = element.attributes["w:val"] ?? element.attributes.val;
+  if (rawValue === "bestFit") {
+    return { zoomLevel: "pageWidth" };
+  }
+  if (rawValue === "fullPage") {
+    return { zoomLevel: "onePage" };
+  }
+
+  const rawPercent =
+    element.attributes["w:percent"] ??
+    element.attributes.percent;
+  if (!rawPercent) {
+    return {};
+  }
+
+  const normalizedPercent = rawPercent.trim().replace(/%$/u, "");
+  const parsed = Number.parseInt(normalizedPercent, 10);
+  if (!Number.isFinite(parsed)) {
+    return {};
+  }
+
+  return { zoomLevel: parsed };
+}
+
+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;
+    }
+
+    const nextLt = xml.indexOf("<", cursor);
+    if (nextLt < 0) {
+      pushText(xml.slice(cursor));
+      break;
+    }
+
+    if (nextLt > cursor) {
+      pushText(xml.slice(cursor, nextLt));
+    }
+
+    if (xml.startsWith("</", nextLt)) {
+      const end = xml.indexOf(">", nextLt);
+      if (end < 0) break;
+      if (stack.length > 1) {
+        stack.pop();
+      }
+      cursor = end + 1;
+      continue;
+    }
+
+    const end = xml.indexOf(">", nextLt);
+    if (end < 0) {
+      break;
+    }
+
+    const rawTag = xml.slice(nextLt + 1, end).trim();
+    const selfClosing = rawTag.endsWith("/");
+    const tagBody = selfClosing ? rawTag.slice(0, -1).trim() : rawTag;
+    const spaceIndex = tagBody.search(/\s/u);
+    const name =
+      spaceIndex >= 0 ? tagBody.slice(0, spaceIndex) : tagBody;
+    const attrs = spaceIndex >= 0 ? tagBody.slice(spaceIndex + 1) : "";
+    const element: XmlElementNode = {
+      type: "element",
+      name,
+      attributes: parseAttributes(attrs),
+      children: [],
+    };
+    stack[stack.length - 1]?.children.push(element);
+    if (!selfClosing) {
+      stack.push(element);
+    }
+    cursor = end + 1;
+  }
+
+  return root;
+
+  function pushText(raw: string): void {
+    const normalized = raw.replace(/\r\n?/gu, "\n");
+    if (!normalized.trim()) {
+      return;
+    }
+    stack[stack.length - 1]?.children.push({
+      type: "text",
+      text: normalized,
+    });
+  }
+}
+
+function parseAttributes(raw: string): Record<string, string> {
+  const attributes: Record<string, string> = {};
+  const pattern = /([^\s=]+)\s*=\s*("([^"]*)"|'([^']*)')/gu;
+  for (const match of raw.matchAll(pattern)) {
+    const [, name, , dq, sq] = match;
+    attributes[name] = dq ?? sq ?? "";
+  }
+  return attributes;
+}

package/src/io/ooxml/parse-shapes.ts

@@ -15,8 +15,12 @@ const WPS_SHAPE_GRAPHIC_URI =
 
 export interface ParsedWpsShape {
   type: "shape";
+  /** True if this shape is a text box (geometry=rect with txbx content). */
+  isTextBox?: boolean;
   /** Extracted text content from wps:txbx for display. */
   text?: string;
+  /** Raw txbxContent XML for structured re-rendering. */
+  txbxContentXml?: string;
   /** DrawML geometry preset, e.g. "rect", "roundRect". */
   geometry?: string;
   /** Original drawing XML for lossless round-trip export. */
@@ -81,9 +85,17 @@ export function parseShapeXml(drawingXml: string): ParsedWpsShape | ParsedWordAr
     };
   }
 
+  // Text box detection: rect or no geometry with text content
+  const isTextBox = Boolean(txbxContent && (!prst || prst === "rect"));
+
+  // Extract raw txbxContent XML for structured re-rendering of text boxes
+  const txbxContentXml = txbxContent ? extractRawXml(txbxContent, drawingXml) : undefined;
+
   return {
     type: "shape",
+    ...(isTextBox ? { isTextBox: true } : {}),
     ...(text ? { text } : {}),
+    ...(txbxContentXml ? { txbxContentXml } : {}),
     ...(prst ? { geometry: prst } : {}),
     rawXml: drawingXml,
   };
@@ -131,6 +143,19 @@ export function parseVmlXml(pictXml: string): ParsedVmlShape | null {
   };
 }
 
+// ---- Raw XML extraction helpers ----
+
+function extractRawXml(node: XmlElementNode, sourceXml: string): string | undefined {
+  // Find the txbxContent element boundaries in the source XML by tag name
+  const tagName = node.name;
+  const openIdx = sourceXml.indexOf(`<${tagName}`);
+  if (openIdx < 0) return undefined;
+  const closeTag = `</${tagName}>`;
+  const closeIdx = sourceXml.indexOf(closeTag, openIdx);
+  if (closeIdx < 0) return undefined;
+  return sourceXml.slice(openIdx, closeIdx + closeTag.length);
+}
+
 // ---- Text extraction helpers ----
 
 function extractAllText(node: XmlElementNode): string {

package/src/io/ooxml/parse-styles.ts

@@ -0,0 +1,463 @@
+/**
+ * Parse styles.xml into the canonical StylesCatalog.
+ *
+ * Reads paragraph, character, and table style definitions plus latent-style
+ * metadata from the package styles part. This makes styles.xml the canonical
+ * source of style truth instead of synthesizing display names from referenced
+ * styleId values.
+ */
+
+import type {
+  CharacterStyleDefinition,
+  LatentStyleDefinition,
+  ParagraphStyleDefinition,
+  StylesCatalog,
+  TableStyleDefinition,
+} from "../../model/canonical-document.ts";
+
+// ---------------------------------------------------------------------------
+// Inline XML node types (same pattern as parse-numbering.ts)
+// ---------------------------------------------------------------------------
+
+interface XmlElementNode {
+  type: "element";
+  name: string;
+  attributes: Record<string, string>;
+  children: XmlNode[];
+}
+
+interface XmlTextNode {
+  type: "text";
+  text: string;
+}
+
+type XmlNode = XmlElementNode | XmlTextNode;
+
+// ---------------------------------------------------------------------------
+// Public interface
+// ---------------------------------------------------------------------------
+
+export interface ParseStylesResult {
+  catalog: StylesCatalog;
+  /** True when the catalog was parsed from actual styles.xml content. */
+  fromPackage: boolean;
+  /** Diagnostic notes for logging/proof. */
+  diagnostics: string[];
+}
+
+/**
+ * Parse a styles.xml string into a canonical StylesCatalog.
+ *
+ * Returns `fromPackage: false` when the input is empty or structurally empty,
+ * in which case the catalog fields will be empty records.
+ */
+export function parseStylesXml(xml: string): ParseStylesResult {
+  const diagnostics: string[] = [];
+
+  if (!xml || xml.trim().length === 0) {
+    diagnostics.push("styles.xml is empty; synthetic fallback will be used");
+    return {
+      catalog: { paragraphs: {}, characters: {}, tables: {} },
+      fromPackage: false,
+      diagnostics,
+    };
+  }
+
+  let root: XmlElementNode;
+  try {
+    root = parseXml(xml);
+  } catch {
+    diagnostics.push("styles.xml could not be parsed; synthetic fallback will be used");
+    return {
+      catalog: { paragraphs: {}, characters: {}, tables: {} },
+      fromPackage: false,
+      diagnostics,
+    };
+  }
+
+  const stylesElement = findChildElementOptional(root, "styles");
+  if (!stylesElement) {
+    diagnostics.push("styles.xml has no <w:styles> root; synthetic fallback will be used");
+    return {
+      catalog: { paragraphs: {}, characters: {}, tables: {} },
+      fromPackage: false,
+      diagnostics,
+    };
+  }
+
+  const paragraphs: Record<string, ParagraphStyleDefinition> = {};
+  const characters: Record<string, CharacterStyleDefinition> = {};
+  const tables: Record<string, TableStyleDefinition> = {};
+  const latentStyles: Record<string, LatentStyleDefinition> = {};
+
+  for (const child of stylesElement.children) {
+    if (child.type !== "element") continue;
+    const local = localName(child.name);
+
+    if (local === "style") {
+      const styleType = child.attributes["w:type"] ?? child.attributes.type;
+      const styleId = child.attributes["w:styleId"] ?? child.attributes.styleId;
+      if (!styleId) continue;
+
+      const displayName = readStyleDisplayName(child) ?? styleId;
+      const basedOn = readLinkedStyleId(child, "basedOn");
+      const isDefault = (child.attributes["w:default"] ?? child.attributes.default) === "1";
+
+      switch (styleType) {
+        case "paragraph": {
+          const nextStyle = readLinkedStyleId(child, "next");
+          const outlineLevel = readParagraphStyleOutlineLevel(child);
+          paragraphs[styleId] = {
+            styleId,
+            displayName,
+            kind: "paragraph",
+            isDefault,
+            ...(basedOn ? { basedOn } : {}),
+            ...(nextStyle ? { nextStyle } : {}),
+            ...(outlineLevel !== undefined ? { outlineLevel } : {}),
+          };
+          break;
+        }
+        case "character": {
+          characters[styleId] = {
+            styleId,
+            displayName,
+            kind: "character",
+            isDefault,
+            ...(basedOn ? { basedOn } : {}),
+          };
+          break;
+        }
+        case "table": {
+          tables[styleId] = {
+            styleId,
+            displayName,
+            kind: "table",
+            isDefault,
+            ...(basedOn ? { basedOn } : {}),
+          };
+          break;
+        }
+        default:
+          // numbering/list styles are not part of the canonical catalog
+          break;
+      }
+    } else if (local === "latentStyles") {
+      readLatentStyles(child, latentStyles);
+    }
+  }
+
+  const hasLatent = Object.keys(latentStyles).length > 0;
+  diagnostics.push(
+    `parsed ${Object.keys(paragraphs).length} paragraph, ` +
+      `${Object.keys(characters).length} character, ` +
+      `${Object.keys(tables).length} table styles` +
+      (hasLatent ? `, ${Object.keys(latentStyles).length} latent styles` : ""),
+  );
+
+  return {
+    catalog: {
+      paragraphs,
+      characters,
+      tables,
+      ...(hasLatent ? { latentStyles } : {}),
+    },
+    fromPackage: true,
+    diagnostics,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function readStyleDisplayName(styleNode: XmlElementNode): string | undefined {
+  const nameEl = findChildElementOptional(styleNode, "name");
+  if (!nameEl) return undefined;
+  return nameEl.attributes["w:val"] ?? nameEl.attributes.val ?? undefined;
+}
+
+function readLinkedStyleId(
+  styleNode: XmlElementNode,
+  elementLocalName: string,
+): string | undefined {
+  const el = findChildElementOptional(styleNode, elementLocalName);
+  if (!el) return undefined;
+  return el.attributes["w:val"] ?? el.attributes.val ?? undefined;
+}
+
+function readParagraphStyleOutlineLevel(
+  styleNode: XmlElementNode,
+): number | undefined {
+  const paragraphProperties = findChildElementOptional(styleNode, "pPr");
+  if (!paragraphProperties) {
+    return undefined;
+  }
+
+  const outlineLevel = findChildElementOptional(paragraphProperties, "outlineLvl");
+  if (!outlineLevel) {
+    return undefined;
+  }
+
+  const rawValue = outlineLevel.attributes["w:val"] ?? outlineLevel.attributes.val;
+  const parsed = rawValue !== undefined ? Number.parseInt(rawValue, 10) : Number.NaN;
+  return Number.isInteger(parsed) && parsed >= 0 ? parsed : undefined;
+}
+
+function readLatentStyles(
+  latentNode: XmlElementNode,
+  out: Record<string, LatentStyleDefinition>,
+): void {
+  for (const child of latentNode.children) {
+    if (child.type !== "element" || localName(child.name) !== "lsdException") continue;
+
+    const name = child.attributes["w:name"] ?? child.attributes.name;
+    if (!name) continue;
+
+    const locked = readBoolAttr(child, "locked");
+    const semiHidden = readBoolAttr(child, "semiHidden");
+    const unhideWhenUsed = readBoolAttr(child, "unhideWhenUsed");
+    const qFormat = readBoolAttr(child, "qFormat");
+    const rawPriority = child.attributes["w:uiPriority"] ?? child.attributes.uiPriority;
+    const uiPriority = rawPriority !== undefined ? Number.parseInt(rawPriority, 10) : undefined;
+
+    out[name] = {
+      name,
+      ...(locked !== undefined ? { locked } : {}),
+      ...(semiHidden !== undefined ? { semiHidden } : {}),
+      ...(unhideWhenUsed !== undefined ? { unhideWhenUsed } : {}),
+      ...(qFormat !== undefined ? { qFormat } : {}),
+      ...(uiPriority !== undefined && !Number.isNaN(uiPriority) ? { uiPriority } : {}),
+    };
+  }
+}
+
+function readBoolAttr(node: XmlElementNode, attrLocalName: string): boolean | undefined {
+  const val = node.attributes[`w:${attrLocalName}`] ?? node.attributes[attrLocalName];
+  if (val === undefined) return undefined;
+  return val === "1" || val === "true";
+}
+
+// ---------------------------------------------------------------------------
+// Inline XML parser (same implementation as parse-numbering.ts)
+// ---------------------------------------------------------------------------
+
+function findChildElementOptional(
+  node: XmlElementNode,
+  childLocalName: string,
+): XmlElementNode | undefined {
+  return node.children.find(
+    (entry): entry is XmlElementNode =>
+      entry.type === "element" && localName(entry.name) === childLocalName,
+  );
+}
+
+function localName(name: string): string {
+  const separatorIndex = name.indexOf(":");
+  return separatorIndex >= 0 ? name.slice(separatorIndex + 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.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),
+      });
+      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,
+        });
+      }
+      cursor = end;
+      continue;
+    }
+
+    if (xml[cursor + 1] === "/") {
+      const end = xml.indexOf(">", cursor);
+      if (end < 0) {
+        throw new Error("Malformed XML: missing closing >.");
+      }
+
+      const name = xml.slice(cursor + 2, end).trim();
+      const current = stack.pop();
+      if (!current || localName(current.name) !== localName(name)) {
+        throw new Error(`Malformed XML: unexpected closing tag </${name}>.`);
+      }
+
+      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;
+  }
+
+  if (stack.length !== 1) {
+    throw new Error("Malformed XML: unclosed element.");
+  }
+
+  return root;
+}
+
+function parseTag(tagBody: string): { name: string; attributes: Record<string, string> } {
+  let cursor = 0;
+  while (cursor < tagBody.length && /\s/.test(tagBody[cursor] ?? "")) {
+    cursor += 1;
+  }
+
+  const nameStart = cursor;
+  while (cursor < tagBody.length && !/\s/.test(tagBody[cursor] ?? "")) {
+    cursor += 1;
+  }
+
+  const name = tagBody.slice(nameStart, cursor);
+  const attributes: Record<string, string> = {};
+
+  while (cursor < tagBody.length) {
+    while (cursor < tagBody.length && /\s/.test(tagBody[cursor] ?? "")) {
+      cursor += 1;
+    }
+    if (cursor >= tagBody.length) {
+      break;
+    }
+
+    const keyStart = cursor;
+    while (cursor < tagBody.length && !/[\s=]/.test(tagBody[cursor] ?? "")) {
+      cursor += 1;
+    }
+    const key = tagBody.slice(keyStart, cursor);
+
+    while (cursor < tagBody.length && /\s/.test(tagBody[cursor] ?? "")) {
+      cursor += 1;
+    }
+
+    if (tagBody[cursor] !== "=") {
+      attributes[key] = "";
+      continue;
+    }
+    cursor += 1;
+
+    while (cursor < tagBody.length && /\s/.test(tagBody[cursor] ?? "")) {
+      cursor += 1;
+    }
+
+    const quote = tagBody[cursor];
+    if (quote !== `"` && quote !== `'`) {
+      throw new Error(`Malformed XML attribute ${key}.`);
+    }
+    cursor += 1;
+
+    const valueStart = cursor;
+    while (cursor < tagBody.length && tagBody[cursor] !== quote) {
+      cursor += 1;
+    }
+    const rawValue = tagBody.slice(valueStart, cursor);
+    attributes[key] = decodeXmlEntities(rawValue);
+    cursor += 1;
+  }
+
+  return { name, attributes };
+}
+
+function findTagEnd(xml: string, start: number): number {
+  let cursor = start + 1;
+  let quote: string | null = null;
+
+  while (cursor < xml.length) {
+    const current = xml[cursor];
+    if (quote) {
+      if (current === quote) {
+        quote = null;
+      }
+      cursor += 1;
+      continue;
+    }
+
+    if (current === `"` || current === `'`) {
+      quote = current;
+      cursor += 1;
+      continue;
+    }
+
+    if (current === ">") {
+      return cursor;
+    }
+
+    cursor += 1;
+  }
+
+  throw new Error("Malformed XML: missing >.");
+}
+
+function decodeXmlEntities(value: string): string {
+  return value.replace(/&(#x[0-9a-fA-F]+|#\d+|amp|lt|gt|quot|apos);/g, (match, entity) => {
+    switch (entity) {
+      case "amp":
+        return "&";
+      case "lt":
+        return "<";
+      case "gt":
+        return ">";
+      case "quot":
+        return `"`;
+      case "apos":
+        return "'";
+      default:
+        if (entity.startsWith("#x")) {
+          return String.fromCodePoint(Number.parseInt(entity.slice(2), 16));
+        }
+        if (entity.startsWith("#")) {
+          return String.fromCodePoint(Number.parseInt(entity.slice(1), 10));
+        }
+        return match;
+    }
+  });
+}