@beyondwork/docx-react-component 1.0.18 → 1.0.20

package/src/io/export/serialize-comments.ts

@@ -577,56 +577,126 @@ function parseOoxmlNumericId(value: string): number | undefined {
   return Number.isFinite(numericId) ? numericId : undefined;
 }
 
-function mapParagraphBoundaries(documentXml: string): ParagraphBoundaryMap[] {
+export function mapParagraphBoundaries(documentXml: string): ParagraphBoundaryMap[] {
   const root = parseXml(documentXml);
   const documentElement = findChildElement(root, "document");
   const bodyElement = findChildElement(documentElement, "body");
   const paragraphs: ParagraphBoundaryMap[] = [];
-  let globalCursor = 0;
-  let paragraphIndex = -1;
-  let previousWasParagraph = false;
+  walkBlockNodesForParagraphBoundaries(
+    bodyElement.children,
+    documentXml,
+    paragraphs,
+    0,
+    -1,
+    true,
+  );
+
+  return paragraphs;
+}
+
+function walkBlockNodesForParagraphBoundaries(
+  nodes: readonly XmlNode[],
+  documentXml: string,
+  paragraphs: ParagraphBoundaryMap[],
+  globalCursor: number,
+  paragraphIndex: number,
+  useSurfaceParagraphSeparators: boolean,
+): {
+  globalCursor: number;
+  paragraphIndex: number;
+} {
+  let nextCursor = globalCursor;
+  let nextParagraphIndex = paragraphIndex;
+  let elementIndex = -1;
 
-  for (const child of bodyElement.children) {
-    if (child.type !== "element") {
+  for (const node of nodes) {
+    if (node.type !== "element") {
+      continue;
+    }
+    elementIndex += 1;
+
+    const name = localName(node.name);
+    if (name === "p") {
+      if (useSurfaceParagraphSeparators && elementIndex > 0) {
+        nextCursor += 1;
+      }
+      nextParagraphIndex += 1;
+      const boundaries = new Map<number, number>();
+      boundaries.set(nextCursor, node.start + openingTagLength(documentXml, node.start));
+
+      walkParagraphForBoundaries(
+        node,
+        documentXml,
+        boundaries,
+        () => nextCursor,
+        (next) => {
+          nextCursor = next;
+        },
+      );
+
+      if (!boundaries.has(nextCursor)) {
+        boundaries.set(nextCursor, node.end - 4);
+      }
+      paragraphs.push({
+        paragraphIndex: nextParagraphIndex,
+        start: Math.min(...boundaries.keys()),
+        end: Math.max(...boundaries.keys()),
+        boundaries,
+      });
       continue;
     }
 
-    if (localName(child.name) !== "p") {
-      globalCursor += 1;
-      previousWasParagraph = false;
+    if (name === "tbl") {
+      for (const child of node.children) {
+        if (child.type !== "element" || localName(child.name) !== "tr") {
+          continue;
+        }
+        for (const rowChild of child.children) {
+          if (rowChild.type !== "element" || localName(rowChild.name) !== "tc") {
+            continue;
+          }
+          const result = walkBlockNodesForParagraphBoundaries(
+            rowChild.children,
+            documentXml,
+            paragraphs,
+            nextCursor,
+            nextParagraphIndex,
+            false,
+          );
+          nextCursor = result.globalCursor;
+          nextParagraphIndex = result.paragraphIndex;
+        }
+      }
       continue;
     }
 
-    if (previousWasParagraph) {
-      globalCursor += 1;
+    if (name === "sdt") {
+      const sdtContent = findChildElement(node, "sdtContent");
+      const result = walkBlockNodesForParagraphBoundaries(
+        sdtContent.children,
+        documentXml,
+        paragraphs,
+        nextCursor,
+        nextParagraphIndex,
+        false,
+      );
+      nextCursor = result.globalCursor;
+      nextParagraphIndex = result.paragraphIndex;
+      continue;
     }
-    paragraphIndex += 1;
-    const boundaries = new Map<number, number>();
-    boundaries.set(globalCursor, child.start + openingTagLength(documentXml, child.start));
-
-    walkParagraphForBoundaries(
-      child,
-      documentXml,
-      boundaries,
-      () => globalCursor,
-      (next) => {
-        globalCursor = next;
-      },
-    );
 
-    if (!boundaries.has(globalCursor)) {
-      boundaries.set(globalCursor, child.end - 4);
+    if (name === "customXml") {
+      nextCursor += 1;
+      continue;
     }
-    paragraphs.push({
-      paragraphIndex,
-      start: Math.min(...boundaries.keys()),
-      end: Math.max(...boundaries.keys()),
-      boundaries,
-    });
-    previousWasParagraph = true;
+
+    nextCursor += 0;
   }
 
-  return paragraphs;
+  return {
+    globalCursor: nextCursor,
+    paragraphIndex: nextParagraphIndex,
+  };
 }
 
 function walkParagraphForBoundaries(

package/src/io/export/serialize-footnotes.ts

@@ -3,6 +3,9 @@ import type {
   FootnoteDefinition,
   InlineNode,
   ParagraphNode,
+  TableCellNode,
+  TableNode,
+  TableRowNode,
   TextMark,
 } from "../../model/canonical-document.ts";
 
@@ -71,6 +74,12 @@ function serializeNoteDefinition(
       if (block.type === "paragraph") {
         return serializeParagraph(block);
       }
+      if (block.type === "table") {
+        return serializeTable(block);
+      }
+      if (block.type === "opaque_block" && typeof block.rawXml === "string") {
+        return block.rawXml;
+      }
       throw new Error(`Cannot safely serialize ${block.type} content in note sub-parts.`);
     })
     .join("");
@@ -96,6 +105,54 @@ function serializeParagraph(paragraph: ParagraphNode): string {
   return xml;
 }
 
+function serializeTable(table: TableNode): string {
+  let xml = "<w:tbl>";
+  if (table.propertiesXml) {
+    xml += table.propertiesXml;
+  }
+  if (table.gridColumns.length > 0) {
+    xml += "<w:tblGrid>";
+    for (const width of table.gridColumns) {
+      xml += `<w:gridCol w:w="${width}"/>`;
+    }
+    xml += "</w:tblGrid>";
+  }
+  for (const row of table.rows) {
+    xml += serializeTableRow(row);
+  }
+  xml += "</w:tbl>";
+  return xml;
+}
+
+function serializeTableRow(row: TableRowNode): string {
+  let xml = "<w:tr>";
+  if (row.propertiesXml) {
+    xml += wrapPropertiesXml("w:trPr", row.propertiesXml);
+  }
+  for (const cell of row.cells) {
+    xml += serializeTableCell(cell);
+  }
+  xml += "</w:tr>";
+  return xml;
+}
+
+function serializeTableCell(cell: TableCellNode): string {
+  let xml = "<w:tc>";
+  const propertiesXml = buildTableCellPropertiesXml(cell);
+  if (propertiesXml) {
+    xml += propertiesXml;
+  }
+  for (const child of cell.children) {
+    if (child.type === "paragraph") {
+      xml += serializeParagraph(child);
+    } else {
+      throw new Error(`Cannot safely serialize ${child.type} content in note table cells.`);
+    }
+  }
+  xml += "</w:tc>";
+  return xml;
+}
+
 function buildParagraphPropertiesXml(paragraph: ParagraphNode): string {
   const parts: string[] = [];
 
@@ -105,6 +162,26 @@ function buildParagraphPropertiesXml(paragraph: ParagraphNode): string {
   if (paragraph.alignment) {
     parts.push(`<w:jc w:val="${escapeAttribute(paragraph.alignment)}"/>`);
   }
+  if (paragraph.spacing) {
+    const attrs: string[] = [];
+    if (paragraph.spacing.before !== undefined) attrs.push(`w:before="${paragraph.spacing.before}"`);
+    if (paragraph.spacing.after !== undefined) attrs.push(`w:after="${paragraph.spacing.after}"`);
+    if (paragraph.spacing.line !== undefined) attrs.push(`w:line="${paragraph.spacing.line}"`);
+    if (paragraph.spacing.lineRule) attrs.push(`w:lineRule="${escapeAttribute(paragraph.spacing.lineRule)}"`);
+    if (attrs.length > 0) {
+      parts.push(`<w:spacing ${attrs.join(" ")}/>`);
+    }
+  }
+  if (paragraph.indentation) {
+    const attrs: string[] = [];
+    if (paragraph.indentation.left !== undefined) attrs.push(`w:left="${paragraph.indentation.left}"`);
+    if (paragraph.indentation.right !== undefined) attrs.push(`w:right="${paragraph.indentation.right}"`);
+    if (paragraph.indentation.firstLine !== undefined) attrs.push(`w:firstLine="${paragraph.indentation.firstLine}"`);
+    if (paragraph.indentation.hanging !== undefined) attrs.push(`w:hanging="${paragraph.indentation.hanging}"`);
+    if (attrs.length > 0) {
+      parts.push(`<w:ind ${attrs.join(" ")}/>`);
+    }
+  }
 
   return parts.length > 0 ? `<w:pPr>${parts.join("")}</w:pPr>` : "";
 }
@@ -133,9 +210,62 @@ function serializeInlineNode(node: InlineNode): string {
           : "EndnoteReference";
       return `<w:r><w:rPr><w:rStyle w:val="${styleVal}"/></w:rPr>${refElement}</w:r>`;
     }
+    case "bookmark_start":
+      return `<w:bookmarkStart w:id="${escapeAttribute(node.bookmarkId)}" w:name="${escapeAttribute(node.name)}"/>`;
+    case "bookmark_end":
+      return `<w:bookmarkEnd w:id="${escapeAttribute(node.bookmarkId)}"/>`;
+    case "field":
+      if (node.children && node.children.length > 0) {
+        const childrenXml = node.children.map((child) => serializeInlineNode(child)).join("");
+        if (node.fieldType === "complex") {
+          return (
+            `<w:r><w:fldChar w:fldCharType="begin"/></w:r>` +
+            `<w:r><w:instrText xml:space="preserve">${escapeXml(node.instruction)}</w:instrText></w:r>` +
+            `<w:r><w:fldChar w:fldCharType="separate"/></w:r>` +
+            childrenXml +
+            `<w:r><w:fldChar w:fldCharType="end"/></w:r>`
+          );
+        }
+        return `<w:fldSimple w:instr="${escapeAttribute(node.instruction)}">${childrenXml}</w:fldSimple>`;
+      }
+      if (node.fieldType === "simple") {
+        return `<w:fldSimple w:instr="${escapeAttribute(node.instruction)}"/>`;
+      }
+      return (
+        `<w:r><w:fldChar w:fldCharType="begin"/></w:r>` +
+        `<w:r><w:instrText xml:space="preserve">${escapeXml(node.instruction)}</w:instrText></w:r>` +
+        `<w:r><w:fldChar w:fldCharType="separate"/></w:r>` +
+        `<w:r><w:fldChar w:fldCharType="end"/></w:r>`
+      );
+    case "hyperlink":
+      return serializeHyperlinkNode(node);
+    case "field":
+      if (node.children && node.children.length > 0) {
+        const childrenXml = node.children.map((child) => serializeInlineNode(child)).join("");
+        if (node.fieldType === "complex") {
+          return (
+            `<w:r><w:fldChar w:fldCharType="begin"/></w:r>` +
+            `<w:r><w:instrText xml:space="preserve">${escapeXml(node.instruction)}</w:instrText></w:r>` +
+            `<w:r><w:fldChar w:fldCharType="separate"/></w:r>` +
+            childrenXml +
+            `<w:r><w:fldChar w:fldCharType="end"/></w:r>`
+          );
+        }
+        return `<w:fldSimple w:instr="${escapeAttribute(node.instruction)}">${childrenXml}</w:fldSimple>`;
+      }
+      if (node.fieldType === "simple") {
+        return `<w:fldSimple w:instr="${escapeAttribute(node.instruction)}"/>`;
+      }
+      return (
+        `<w:r><w:fldChar w:fldCharType="begin"/></w:r>` +
+        `<w:r><w:instrText xml:space="preserve">${escapeXml(node.instruction)}</w:instrText></w:r>` +
+        `<w:r><w:fldChar w:fldCharType="separate"/></w:r>` +
+        `<w:r><w:fldChar w:fldCharType="end"/></w:r>`
+      );
+    case "hyperlink":
+      return serializeHyperlinkNode(node);
     case "opaque_inline":
       throw new Error(`Cannot safely serialize ${node.type} content in note sub-parts.`);
-    case "hyperlink":
     default:
       throw new Error(`Cannot safely serialize ${node.type} content in note sub-parts.`);
   }
@@ -164,6 +294,23 @@ function buildRunPropertiesXml(marks: TextMark[] | undefined): string {
       case "doubleStrikethrough":
         parts.push("<w:dstrike/>");
         break;
+      case "fontFamily":
+        parts.push(
+          `<w:rFonts w:ascii="${escapeAttribute(mark.val)}" w:hAnsi="${escapeAttribute(mark.val)}"/>`,
+        );
+        break;
+      case "fontSize":
+        parts.push(`<w:sz w:val="${mark.val}"/>`);
+        break;
+      case "textColor":
+        parts.push(`<w:color w:val="${escapeAttribute(mark.color)}"/>`);
+        break;
+      case "smallCaps":
+        parts.push("<w:smallCaps/>");
+        break;
+      case "allCaps":
+        parts.push("<w:caps/>");
+        break;
       default:
         throw new Error(`Cannot safely serialize ${mark.type} marks in note sub-parts.`);
     }
@@ -200,3 +347,53 @@ function escapeAttribute(value: string): string {
     .replace(/>/g, "&gt;")
     .replace(/"/g, "&quot;");
 }
+
+function serializeHyperlinkNode(node: Extract<InlineNode, { type: "hyperlink" }>): string {
+  const childrenXml = node.children.map((child) => serializeInlineNode(child)).join("");
+  if (node.href.startsWith("#")) {
+    return `<w:hyperlink w:anchor="${escapeAttribute(node.href.slice(1))}">${childrenXml}</w:hyperlink>`;
+  }
+  if (!/^rId[A-Za-z0-9._-]+$/u.test(node.href)) {
+    throw new Error("Cannot safely serialize URL-backed note hyperlinks without relationship context.");
+  }
+  return `<w:hyperlink r:id="${escapeAttribute(node.href)}">${childrenXml}</w:hyperlink>`;
+}
+
+function wrapPropertiesXml(tagName: "w:trPr" | "w:tcPr", xml: string): string {
+  const trimmed = xml.trim();
+  if (trimmed.startsWith(`<${tagName}`)) {
+    return trimmed;
+  }
+  return `<${tagName}>${trimmed}</${tagName}>`;
+}
+
+function extractWrappedChildren(tagName: "w:tcPr", xml: string | undefined): string {
+  if (!xml) {
+    return "";
+  }
+  const trimmed = xml.trim();
+  const wrapped = new RegExp(`^<${tagName}\\b[^>]*>([\\s\\S]*)</${tagName}>$`, "u").exec(trimmed);
+  return wrapped?.[1] ?? trimmed;
+}
+
+function buildTableCellPropertiesXml(cell: TableCellNode): string {
+  const innerXml = extractWrappedChildren("w:tcPr", cell.propertiesXml)
+    .replace(/<w:gridSpan\b[^>]*\/>/gu, "")
+    .replace(/<w:vMerge\b[^>]*\/>/gu, "")
+    .trim();
+  const parts: string[] = [];
+  if (cell.gridSpan && cell.gridSpan > 1) {
+    parts.push(`<w:gridSpan w:val="${cell.gridSpan}"/>`);
+  }
+  if (cell.verticalMerge) {
+    parts.push(
+      cell.verticalMerge === "restart"
+        ? `<w:vMerge w:val="restart"/>`
+        : `<w:vMerge/>`,
+    );
+  }
+  if (innerXml.length > 0) {
+    parts.push(innerXml);
+  }
+  return parts.length > 0 ? `<w:tcPr>${parts.join("")}</w:tcPr>` : "";
+}