@beyondwork/docx-react-component 1.0.58 → 1.0.60

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

@@ -12,6 +12,14 @@
 
 import type { ShapeContent } from "../../model/canonical-document.ts";
 import { parseFill } from "./parse-fill.ts";
+import {
+  type XmlElementNode,
+  findFirstChild,
+  findFirstDescendant,
+  localName,
+  parseXml,
+  serializeXmlNode,
+} from "./_mini-xml.ts";
 
 const WPS_SHAPE_GRAPHIC_URI =
   "http://schemas.microsoft.com/office/word/2010/wordprocessingShape";
@@ -88,11 +96,13 @@ export function parseShapeXml(drawingXml: string): ParsedWpsShape | ParsedWordAr
     };
   }
 
-  // Text box detection: rect or no geometry with text content
-  const isTextBox = Boolean(txbxContent && (!prst || prst === "rect"));
+  // Phase 1.2 B6 — text-box detection is defined by presence of txbxContent.
+  // Geometry is styling (rect, roundRect, ellipse, callouts, custom flowchart
+  // shapes) and any of them can legitimately hold editable text.
+  const isTextBox = Boolean(txbxContent);
 
   // Extract raw txbxContent XML for structured re-rendering of text boxes
-  const txbxContentXml = txbxContent ? extractRawXml(txbxContent, drawingXml) : undefined;
+  const txbxContentXml = txbxContent ? extractRawXml(txbxContent) : undefined;
 
   return {
     type: "shape",
@@ -148,15 +158,8 @@ 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);
+function extractRawXml(node: XmlElementNode): string {
+  return serializeXmlNode(node);
 }
 
 // ---- Text extraction helpers ----
@@ -174,129 +177,9 @@ function extractAllText(node: XmlElementNode): string {
     .join("");
 }
 
-// ---- 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;
-}
+// Phase 6 — XML helpers imported from ./_mini-xml.ts (consolidates the
+// previously-duplicated parser across parse-anchor/parse-drawing/parse-picture/
+// parse-shapes). See that module for B4 throw-on-unterminated-tag contract.
 
 // ───────────────────────────────────────────────────────────────────────────
 // CO4.3 — parseShapeContent: wps:wsp → ShapeContent (geometry, fill, line,
@@ -327,7 +210,7 @@ export function parseShapeContent(
   // optional blockParser callback (CO4 F3.3) to populate txbxBlocks.
   const txbx = findFirstChild(wsp, "txbx");
   const txbxContent = txbx ? findFirstDescendant(txbx, "txbxContent") : undefined;
-  const txbxContentXml = txbxContent ? extractRawXml(txbxContent, drawingRawXml) : undefined;
+  const txbxContentXml = txbxContent ? extractRawXml(txbxContent) : undefined;
 
   let txbxBlocks: ReadonlyArray<{ type: string; [key: string]: unknown }> | undefined;
   if (txbxContentXml && blockParser) {
@@ -340,10 +223,12 @@ export function parseShapeContent(
     }
   }
 
-  // WordArt heuristic: geometry starting with "text" is a WordArt preset —
-  // those flow through parseShapeXml/WordArtNode. parseShapeContent covers
-  // rectangular shapes + text boxes.
-  const isTextBox = Boolean(txbxContent && (!geometry || geometry === "rect"));
+  // Phase 1.2 B6 — text-box detection is defined by presence of txbxContent.
+  // Geometry is styling (rect, roundRect, ellipse, callouts, custom flowchart
+  // shapes) and any of them can legitimately hold editable text. Previously
+  // only "rect" or missing geometry qualified, mis-classifying Word's default
+  // roundRect text boxes + callout/ellipse shapes as non-text.
+  const isTextBox = Boolean(txbxContent);
 
   const result: ShapeContent = { type: "shape", rawXml: drawingRawXml };
   if (geometry) result.geometry = geometry;

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

@@ -41,6 +41,8 @@ import {
 import { toCanonicalNumberingInstanceId } from "./parse-numbering.ts";
 import { readRunProperties } from "./parse-run-formatting.ts";
 import { readParagraphProperties } from "./parse-paragraph-formatting.ts";
+import { parseXmlWithOffsets } from "./xml-parser.ts";
+import { localName } from "./xml-attr-helpers.ts";
 
 // ---------------------------------------------------------------------------
 // Inline XML node types (same pattern as parse-numbering.ts)
@@ -96,7 +98,7 @@ export function parseStylesXml(xml: string): ParseStylesResult {
 
   let root: XmlElementNode;
   try {
-    root = parseXml(xml);
+    root = parseXmlWithOffsets(xml) as XmlElementNode;
   } catch {
     diagnostics.push("styles.xml could not be parsed; synthetic fallback will be used");
     return {
@@ -588,221 +590,4 @@ function findChildElementOptional(
   );
 }
 
-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: [],
-    start: 0,
-    end: 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: end >= 0 ? end + 3 : xml.length,
-      });
-      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 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}>.`);
-      }
-      current.end = end + 1;
-
-      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: [],
-      start: cursor,
-      end: tagEnd + 1,
-    };
-    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;
-    }
-  });
-}