@beyondwork/docx-react-component 1.0.19 → 1.0.21

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

@@ -3,7 +3,9 @@ import type {
   FootnoteCollection,
   FootnoteDefinition,
   InlineNode,
+  ParagraphIndentation,
   ParagraphNode,
+  ParagraphSpacing,
   TableCellNode,
   TableNode,
   TableRowNode,
@@ -149,6 +151,7 @@ function parseNoteElement(
           type: "opaque_block",
           fragmentId: `fragment:note-tbl-${noteId}`,
           warningId: `warning:note-opaque-table`,
+          rawXml: serializeElementToXml(child),
         });
       }
     } else {
@@ -156,6 +159,7 @@ function parseNoteElement(
         type: "opaque_block",
         fragmentId: `fragment:note-opaque-${noteId}`,
         warningId: `warning:note-opaque-block`,
+        rawXml: serializeElementToXml(child),
       });
     }
   }
@@ -165,7 +169,15 @@ function parseNoteElement(
 
 function parseParagraphElement(pElement: XmlElementNode): ParagraphNode {
   let styleId: string | undefined;
+  let alignment: ParagraphNode["alignment"];
+  let spacing: ParagraphNode["spacing"];
+  let indentation: ParagraphNode["indentation"];
   const children: InlineNode[] = [];
+  let activeComplexField: {
+    instruction: string;
+    children: InlineNode[];
+    mode: "instruction" | "result";
+  } | null = null;
 
   for (const child of pElement.children) {
     if (child.type !== "element") {
@@ -177,24 +189,141 @@ function parseParagraphElement(pElement: XmlElementNode): ParagraphNode {
     if (name === "pPr") {
       const pStyle = findChildElementOptional(child, "pStyle");
       styleId = pStyle?.attributes["w:val"] ?? pStyle?.attributes.val;
+      const jc = findChildElementOptional(child, "jc");
+      const jcVal = jc?.attributes["w:val"] ?? jc?.attributes.val;
+      if (jcVal === "left" || jcVal === "center" || jcVal === "right" || jcVal === "both" || jcVal === "distribute") {
+        alignment = jcVal;
+      }
+      spacing = readParagraphSpacing(child);
+      indentation = readParagraphIndentation(child);
     } else if (name === "r") {
-      children.push(...parseRunElement(child));
+      activeComplexField = appendRunNodes(child, children, activeComplexField);
     } else if (name === "hyperlink") {
+      if (activeComplexField && activeComplexField.instruction.trim().length > 0) {
+        children.push({
+          type: "field",
+          fieldType: "complex",
+          instruction: activeComplexField.instruction,
+          children: activeComplexField.children,
+        });
+        activeComplexField = null;
+      }
       children.push(parseHyperlinkElement(child));
     } else if (name === "bookmarkStart" || name === "bookmarkEnd") {
-      children.push(parseBookmarkElement(child));
+      const bookmarkNode = parseBookmarkElement(child);
+      if (activeComplexField?.mode === "result") {
+        activeComplexField.children.push(bookmarkNode);
+      } else {
+        if (activeComplexField && activeComplexField.instruction.trim().length > 0) {
+          children.push({
+            type: "field",
+            fieldType: "complex",
+            instruction: activeComplexField.instruction,
+            children: activeComplexField.children,
+          });
+          activeComplexField = null;
+        }
+        children.push(bookmarkNode);
+      }
     } else if (name === "fldSimple") {
+      if (activeComplexField && activeComplexField.instruction.trim().length > 0) {
+        children.push({
+          type: "field",
+          fieldType: "complex",
+          instruction: activeComplexField.instruction,
+          children: activeComplexField.children,
+        });
+        activeComplexField = null;
+      }
       pushFieldNode(children, child, "simple");
     }
   }
 
+  if (activeComplexField && activeComplexField.instruction.trim().length > 0) {
+    children.push({
+      type: "field",
+      fieldType: "complex",
+      instruction: activeComplexField.instruction,
+      children: activeComplexField.children,
+    });
+  }
+
   return {
     type: "paragraph",
     ...(styleId ? { styleId } : {}),
+    ...(alignment ? { alignment } : {}),
+    ...(spacing ? { spacing } : {}),
+    ...(indentation ? { indentation } : {}),
     children,
   };
 }
 
+function appendRunNodes(
+  rElement: XmlElementNode,
+  nodes: InlineNode[],
+  activeComplexField: {
+    instruction: string;
+    children: InlineNode[];
+    mode: "instruction" | "result";
+  } | null,
+): {
+  instruction: string;
+  children: InlineNode[];
+  mode: "instruction" | "result";
+} | null {
+  const marks: TextMark[] = parseRunProperties(rElement);
+
+  for (const child of rElement.children) {
+    if (child.type !== "element") {
+      continue;
+    }
+
+    const name = localName(child.name);
+    if (name === "fldChar") {
+      const fldType = child.attributes["w:fldCharType"] ?? child.attributes.fldCharType;
+      if (fldType === "begin") {
+        activeComplexField = { instruction: "", children: [], mode: "instruction" };
+      } else if (fldType === "separate" && activeComplexField) {
+        activeComplexField.mode = "result";
+      } else if (fldType === "end" && activeComplexField) {
+        if (activeComplexField.instruction.trim().length > 0) {
+          nodes.push({
+            type: "field",
+            fieldType: "complex",
+            instruction: activeComplexField.instruction,
+            children: activeComplexField.children,
+          });
+        }
+        activeComplexField = null;
+      }
+      continue;
+    }
+
+    if (name === "instrText") {
+      if (activeComplexField) {
+        activeComplexField.instruction += extractTextContent(child);
+      } else {
+        pushFieldNode(nodes, child, "complex");
+      }
+      continue;
+    }
+
+    const inlineNode = parseRunChildNode(child, marks);
+    if (!inlineNode) {
+      continue;
+    }
+
+    if (activeComplexField?.mode === "result") {
+      activeComplexField.children.push(inlineNode);
+      continue;
+    }
+
+    nodes.push(inlineNode);
+  }
+
+  return activeComplexField;
+}
+
 function parseRunElement(rElement: XmlElementNode): InlineNode[] {
   const nodes: InlineNode[] = [];
   const marks: TextMark[] = parseRunProperties(rElement);
@@ -243,6 +372,52 @@ function parseRunElement(rElement: XmlElementNode): InlineNode[] {
   return nodes;
 }
 
+function parseRunChildNode(
+  child: XmlElementNode,
+  marks: TextMark[],
+): InlineNode | null {
+  const name = localName(child.name);
+
+  if (name === "t") {
+    const text = extractTextContent(child);
+    if (text.length > 0) {
+      return {
+        type: "text",
+        text,
+        ...(marks.length > 0 ? { marks } : {}),
+      };
+    }
+    return null;
+  }
+  if (name === "br") {
+    return { type: "hard_break" };
+  }
+  if (name === "tab") {
+    return { type: "tab" };
+  }
+  if (name === "footnoteReference") {
+    const noteId =
+      child.attributes["w:id"] ?? child.attributes.id ?? "";
+    if (noteId) {
+      return { type: "footnote_ref", noteId, noteKind: "footnote" };
+    }
+    return null;
+  }
+  if (name === "endnoteReference") {
+    const noteId =
+      child.attributes["w:id"] ?? child.attributes.id ?? "";
+    if (noteId) {
+      return { type: "footnote_ref", noteId, noteKind: "endnote" };
+    }
+    return null;
+  }
+  if (name === "bookmarkStart" || name === "bookmarkEnd") {
+    return parseBookmarkElement(child);
+  }
+
+  return null;
+}
+
 function parseHyperlinkElement(element: XmlElementNode): Extract<InlineNode, { type: "hyperlink" }> {
   const href = element.attributes["w:anchor"]
     ? `#${element.attributes["w:anchor"]}`
@@ -339,12 +514,75 @@ function parseRunProperties(rElement: XmlElementNode): TextMark[] {
       case "strike":
         if (val !== "0" && val !== "false") marks.push({ type: "strikethrough" });
         break;
+      case "dstrike":
+        if (val !== "0" && val !== "false") marks.push({ type: "doubleStrikethrough" });
+        break;
+      case "rFonts": {
+        const family =
+          child.attributes["w:ascii"] ??
+          child.attributes["w:hAnsi"] ??
+          child.attributes.ascii ??
+          child.attributes.hAnsi;
+        if (family) marks.push({ type: "fontFamily", val: family });
+        break;
+      }
+      case "sz": {
+        const szVal = child.attributes["w:val"] ?? child.attributes.val;
+        if (szVal) {
+          const size = Number.parseInt(szVal, 10);
+          if (Number.isFinite(size) && size > 0) marks.push({ type: "fontSize", val: size });
+        }
+        break;
+      }
+      case "color": {
+        const colorVal = child.attributes["w:val"] ?? child.attributes.val;
+        if (colorVal && colorVal !== "auto") marks.push({ type: "textColor", color: colorVal });
+        break;
+      }
+      case "smallCaps":
+        if (val !== "0" && val !== "false") marks.push({ type: "smallCaps" });
+        break;
+      case "caps":
+        if (val !== "0" && val !== "false") marks.push({ type: "allCaps" });
+        break;
     }
   }
 
   return marks;
 }
 
+function readParagraphSpacing(pPr: XmlElementNode): ParagraphSpacing | undefined {
+  const spacingNode = findChildElementOptional(pPr, "spacing");
+  if (!spacingNode) return undefined;
+  const result: ParagraphSpacing = {};
+  const before = spacingNode.attributes["w:before"] ?? spacingNode.attributes.before;
+  if (before) result.before = Number.parseInt(before, 10);
+  const after = spacingNode.attributes["w:after"] ?? spacingNode.attributes.after;
+  if (after) result.after = Number.parseInt(after, 10);
+  const line = spacingNode.attributes["w:line"] ?? spacingNode.attributes.line;
+  if (line) result.line = Number.parseInt(line, 10);
+  const lineRule = spacingNode.attributes["w:lineRule"] ?? spacingNode.attributes.lineRule;
+  if (lineRule === "auto" || lineRule === "exact" || lineRule === "atLeast") {
+    result.lineRule = lineRule;
+  }
+  return Object.keys(result).length > 0 ? result : undefined;
+}
+
+function readParagraphIndentation(pPr: XmlElementNode): ParagraphIndentation | undefined {
+  const indNode = findChildElementOptional(pPr, "ind");
+  if (!indNode) return undefined;
+  const result: ParagraphIndentation = {};
+  const left = indNode.attributes["w:left"] ?? indNode.attributes.left;
+  if (left) result.left = Number.parseInt(left, 10);
+  const right = indNode.attributes["w:right"] ?? indNode.attributes.right;
+  if (right) result.right = Number.parseInt(right, 10);
+  const firstLine = indNode.attributes["w:firstLine"] ?? indNode.attributes.firstLine;
+  if (firstLine) result.firstLine = Number.parseInt(firstLine, 10);
+  const hanging = indNode.attributes["w:hanging"] ?? indNode.attributes.hanging;
+  if (hanging) result.hanging = Number.parseInt(hanging, 10);
+  return Object.keys(result).length > 0 ? result : undefined;
+}
+
 function extractTextContent(tElement: XmlElementNode): string {
   let text = "";
   for (const child of tElement.children) {