@beyondwork/docx-react-component 1.0.18 → 1.0.19

package/src/io/export/serialize-main-document.ts

@@ -8,6 +8,7 @@ import type {
   ParagraphNode,
   PreservationStore,
   SdtNode,
+  SectionProperties,
   TableNode,
   TableCellNode,
   TextMark,
@@ -30,6 +31,7 @@ export interface SerializedMainDocument {
 export interface SerializeMainDocumentOptions {
   documentAttributes?: Record<string, string>;
   media?: MediaCatalog;
+  finalSectionProperties?: SectionProperties;
 }
 
 interface SerializationState {
@@ -90,7 +92,9 @@ export function serializeMainDocument(
   const bodyPieces: string[] = [];
   const paragraphBoundaries: RevisionParagraphBoundary[] = [];
   let bodyLength = 0;
-  let sectionPropertiesXml = "<w:sectPr/>";
+  let sectionPropertiesXml = options.finalSectionProperties
+    ? serializeSectionPropertiesXml(options.finalSectionProperties)
+    : "<w:sectPr/>";
   let cursor = 0;
   let paragraphIndex = -1;
   let previousWasParagraph = false;
@@ -154,9 +158,20 @@ export function serializeMainDocument(
     }
 
     if (block.type === "section_break") {
-      if (block.propertiesXml) {
-        sectionPropertiesXml = block.propertiesXml;
+      // Inline section breaks must be emitted as a paragraph with <w:sectPr>
+      // in its <w:pPr> element (OOXML compliance). The body-level <w:sectPr>
+      // is reserved for the final section only.
+      let inlineSectPr: string;
+      if (block.sectionPropertiesXml ?? block.propertiesXml) {
+        inlineSectPr = block.sectionPropertiesXml ?? block.propertiesXml!;
+      } else if (block.sectionProperties) {
+        inlineSectPr = serializeSectionPropertiesXml(block.sectionProperties);
+      } else {
+        inlineSectPr = "<w:sectPr/>";
       }
+      const sectionParagraphXml = `<w:p><w:pPr>${inlineSectPr}</w:pPr></w:p>`;
+      bodyPieces.push(sectionParagraphXml);
+      bodyLength += sectionParagraphXml.length;
       cursor += 1;
       previousWasParagraph = false;
       continue;
@@ -242,7 +257,11 @@ function serializeBlockNode(
     case "opaque_block":
       return lookupOpaqueXml(block.fragmentId, state);
     case "section_break":
-      return block.propertiesXml ?? "<w:sectPr/>";
+      if (block.sectionPropertiesXml ?? block.propertiesXml) {
+        return block.sectionPropertiesXml ?? block.propertiesXml!;
+      }
+      if (block.sectionProperties) return serializeSectionPropertiesXml(block.sectionProperties);
+      return "<w:sectPr/>";
   }
 }
 
@@ -303,7 +322,40 @@ function buildSdtPropertiesXml(block: SdtNode): string {
   if (block.properties.lock) {
     children.push(`<w:lock w:val="${escapeAttribute(block.properties.lock)}"/>`);
   }
-  if (block.properties.sdtType) {
+  if (block.properties.showingPlcHdr) {
+    children.push(`<w:showingPlcHdr/>`);
+  }
+  if (block.properties.checkbox) {
+    const cb = block.properties.checkbox;
+    const cbParts: string[] = [];
+    cbParts.push(`<w14:checked w14:val="${cb.checked ? "1" : "0"}"/>`);
+    if (cb.checkedChar) cbParts.push(`<w14:checkedState w14:val="${escapeAttribute(cb.checkedChar)}"/>`);
+    if (cb.uncheckedChar) cbParts.push(`<w14:uncheckedState w14:val="${escapeAttribute(cb.uncheckedChar)}"/>`);
+    children.push(`<w14:checkbox>${cbParts.join("")}</w14:checkbox>`);
+  } else if (block.properties.datePicker) {
+    const dp = block.properties.datePicker;
+    const dateAttrs = dp.fullDate ? ` w:fullDate="${escapeAttribute(dp.fullDate)}"` : "";
+    const dpParts: string[] = [];
+    if (dp.dateFormat) dpParts.push(`<w:dateFormat w:val="${escapeAttribute(dp.dateFormat)}"/>`);
+    if (dp.lid) dpParts.push(`<w:lid w:val="${escapeAttribute(dp.lid)}"/>`);
+    children.push(dpParts.length > 0 ? `<w:date${dateAttrs}>${dpParts.join("")}</w:date>` : `<w:date${dateAttrs}/>`);
+  } else if (block.properties.dropdownList) {
+    const items = block.properties.dropdownList.map((item) => {
+      const dt = item.displayText ? ` w:displayText="${escapeAttribute(item.displayText)}"` : "";
+      return `<w:listItem${dt} w:value="${escapeAttribute(item.value)}"/>`;
+    }).join("");
+    children.push(`<w:dropDownList>${items}</w:dropDownList>`);
+  } else if (block.properties.comboBox) {
+    const items = block.properties.comboBox.map((item) => {
+      const dt = item.displayText ? ` w:displayText="${escapeAttribute(item.displayText)}"` : "";
+      return `<w:listItem${dt} w:value="${escapeAttribute(item.value)}"/>`;
+    }).join("");
+    children.push(`<w:comboBox>${items}</w:comboBox>`);
+  } else if (block.properties.sdtType === "plainText") {
+    children.push(`<w:text/>`);
+  } else if (block.properties.sdtType === "richText") {
+    children.push(`<w:richText/>`);
+  } else if (block.properties.sdtType) {
     children.push(`<w:${block.properties.sdtType}/>`);
   }
   return children.length > 0 ? `<w:sdtPr>${children.join("")}</w:sdtPr>` : "<w:sdtPr/>";
@@ -1049,6 +1101,151 @@ function serializeDocumentAttributes(
     .join("");
 }
 
+export function serializeSectionPropertiesXml(props: SectionProperties): string {
+  const children: string[] = [];
+
+  // Header references
+  if (props.headerReferences) {
+    for (const ref of props.headerReferences) {
+      children.push(`<w:headerReference w:type="${escapeAttribute(ref.variant)}" r:id="${escapeAttribute(ref.relationshipId)}"/>`);
+    }
+  }
+
+  // Footer references
+  if (props.footerReferences) {
+    for (const ref of props.footerReferences) {
+      children.push(`<w:footerReference w:type="${escapeAttribute(ref.variant)}" r:id="${escapeAttribute(ref.relationshipId)}"/>`);
+    }
+  }
+
+  // Section type
+  if (props.sectionType) {
+    children.push(`<w:type w:val="${escapeAttribute(props.sectionType)}"/>`);
+  }
+
+  // Page size
+  if (props.pageSize) {
+    let pgSz = `<w:pgSz w:w="${props.pageSize.width}" w:h="${props.pageSize.height}"`;
+    if (props.pageSize.orientation) {
+      pgSz += ` w:orient="${props.pageSize.orientation}"`;
+    }
+    pgSz += "/>";
+    children.push(pgSz);
+  }
+
+  // Page margins
+  if (props.pageMargins) {
+    let pgMar = `<w:pgMar w:top="${props.pageMargins.top}" w:right="${props.pageMargins.right}" w:bottom="${props.pageMargins.bottom}" w:left="${props.pageMargins.left}"`;
+    if (props.pageMargins.header !== undefined) pgMar += ` w:header="${props.pageMargins.header}"`;
+    if (props.pageMargins.footer !== undefined) pgMar += ` w:footer="${props.pageMargins.footer}"`;
+    if (props.pageMargins.gutter !== undefined) pgMar += ` w:gutter="${props.pageMargins.gutter}"`;
+    pgMar += "/>";
+    children.push(pgMar);
+  }
+
+  // Columns
+  if (props.columns) {
+    let cols = "<w:cols";
+    if (props.columns.count !== undefined) cols += ` w:num="${props.columns.count}"`;
+    if (props.columns.space !== undefined) cols += ` w:space="${props.columns.space}"`;
+    if (props.columns.equalWidth !== undefined) cols += ` w:equalWidth="${props.columns.equalWidth ? "1" : "0"}"`;
+    if (props.columns.separator) cols += ` w:sep="1"`;
+    if (props.columns.columns && props.columns.columns.length > 0) {
+      cols += ">";
+      for (const col of props.columns.columns) {
+        let colXml = `<w:col w:w="${col.width}"`;
+        if (col.space !== undefined) colXml += ` w:space="${col.space}"`;
+        colXml += "/>";
+        cols += colXml;
+      }
+      cols += "</w:cols>";
+    } else {
+      cols += "/>";
+    }
+    children.push(cols);
+  }
+
+  // Page numbering
+  if (props.pageNumbering) {
+    let pgNum = "<w:pgNumType";
+    if (props.pageNumbering.format) pgNum += ` w:fmt="${escapeAttribute(props.pageNumbering.format)}"`;
+    if (props.pageNumbering.start !== undefined) pgNum += ` w:start="${props.pageNumbering.start}"`;
+    if (props.pageNumbering.chapStyle) pgNum += ` w:chapStyle="${escapeAttribute(props.pageNumbering.chapStyle)}"`;
+    if (props.pageNumbering.chapSep) pgNum += ` w:chapSep="${escapeAttribute(props.pageNumbering.chapSep)}"`;
+    pgNum += "/>";
+    children.push(pgNum);
+  }
+
+  if (props.lineNumbering) {
+    let lineNumbering = "<w:lnNumType";
+    if (props.lineNumbering.countBy !== undefined) {
+      lineNumbering += ` w:countBy="${props.lineNumbering.countBy}"`;
+    }
+    if (props.lineNumbering.start !== undefined) {
+      lineNumbering += ` w:start="${props.lineNumbering.start}"`;
+    }
+    if (props.lineNumbering.distance !== undefined) {
+      lineNumbering += ` w:distance="${props.lineNumbering.distance}"`;
+    }
+    if (props.lineNumbering.restart) {
+      lineNumbering += ` w:restart="${escapeAttribute(props.lineNumbering.restart)}"`;
+    }
+    lineNumbering += "/>";
+    children.push(lineNumbering);
+  }
+
+  if (props.pageBorders) {
+    const attrs: string[] = [];
+    if (props.pageBorders.offsetFrom) {
+      attrs.push(`w:offsetFrom="${escapeAttribute(props.pageBorders.offsetFrom)}"`);
+    }
+    if (props.pageBorders.display) {
+      attrs.push(`w:display="${escapeAttribute(props.pageBorders.display)}"`);
+    }
+    if (props.pageBorders.zOrder) {
+      attrs.push(`w:zOrder="${escapeAttribute(props.pageBorders.zOrder)}"`);
+    }
+    const borderXml = [
+      serializeBorder("top", props.pageBorders.top),
+      serializeBorder("left", props.pageBorders.left),
+      serializeBorder("bottom", props.pageBorders.bottom),
+      serializeBorder("right", props.pageBorders.right),
+    ].filter((entry) => entry.length > 0);
+    if (attrs.length > 0 || borderXml.length > 0) {
+      children.push(
+        `<w:pgBorders${attrs.length > 0 ? ` ${attrs.join(" ")}` : ""}>${borderXml.join("")}</w:pgBorders>`,
+      );
+    }
+  }
+
+  // Title page
+  if (props.titlePage) {
+    children.push("<w:titlePg/>");
+  }
+
+  if (props.documentGrid) {
+    const attrs: string[] = [];
+    if (props.documentGrid.type) {
+      attrs.push(`w:type="${escapeAttribute(props.documentGrid.type)}"`);
+    }
+    if (props.documentGrid.linePitch !== undefined) {
+      attrs.push(`w:linePitch="${props.documentGrid.linePitch}"`);
+    }
+    if (props.documentGrid.charSpace !== undefined) {
+      attrs.push(`w:charSpace="${props.documentGrid.charSpace}"`);
+    }
+    if (attrs.length > 0) {
+      children.push(`<w:docGrid ${attrs.join(" ")}/>`);
+    }
+  }
+
+  if (children.length === 0) {
+    return "<w:sectPr/>";
+  }
+
+  return `<w:sectPr>${children.join("")}</w:sectPr>`;
+}
+
 function documentNeedsW14Namespace(content: DocumentRootNode): boolean {
   const blockQueue = [...content.children];
   while (blockQueue.length > 0) {

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

@@ -1,15 +1,23 @@
 import type { NumberingCatalog, ParagraphNode } from "../../model/canonical-document.ts";
+import {
+  isSyntheticDocxNullAbstractDefinition,
+  isSyntheticDocxNullNumberingInstance,
+} from "../ooxml/numbering-sentinels.ts";
 
 export const WORD_NUMBERING_CONTENT_TYPE =
   "application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml";
 
 export function serializeNumberingXml(catalog: NumberingCatalog): string {
-  const abstractDefinitions = Object.values(catalog.abstractDefinitions).sort((left, right) =>
-    compareSerializedIds(left.abstractNumberingId, right.abstractNumberingId),
-  );
-  const instances = Object.values(catalog.instances).sort((left, right) =>
-    compareSerializedIds(left.numberingInstanceId, right.numberingInstanceId),
-  );
+  const abstractDefinitions = Object.values(catalog.abstractDefinitions)
+    .filter((definition) => !isSyntheticDocxNullAbstractDefinition(definition))
+    .sort((left, right) =>
+      compareSerializedIds(left.abstractNumberingId, right.abstractNumberingId),
+    );
+  const instances = Object.values(catalog.instances)
+    .filter((instance) => !isSyntheticDocxNullNumberingInstance(instance))
+    .sort((left, right) =>
+      compareSerializedIds(left.numberingInstanceId, right.numberingInstanceId),
+    );
 
   const body = [
     ...abstractDefinitions.map((definition) => serializeAbstractDefinition(definition)),
@@ -22,6 +30,17 @@ export function serializeNumberingXml(catalog: NumberingCatalog): string {
   ].join("\n");
 }
 
+export function hasSerializableNumberingEntries(catalog: NumberingCatalog): boolean {
+  return (
+    Object.values(catalog.abstractDefinitions).some(
+      (definition) => !isSyntheticDocxNullAbstractDefinition(definition),
+    ) ||
+    Object.values(catalog.instances).some(
+      (instance) => !isSyntheticDocxNullNumberingInstance(instance),
+    )
+  );
+}
+
 export function serializeParagraphNumberingProperties(
   numbering: ParagraphNode["numbering"],
 ): string {
@@ -51,10 +70,12 @@ function serializeLevel(level: NumberingCatalog["abstractDefinitions"][string]["
   const paragraphStyle = level.paragraphStyleId
     ? `<w:pStyle w:val="${escapeAttribute(level.paragraphStyleId)}"/>`
     : "";
+  const isLegal = level.isLegalNumbering ? "<w:isLgl/>" : "";
+  const suffix = level.suffix ? `<w:suff w:val="${escapeAttribute(level.suffix)}"/>` : "";
 
   return `<w:lvl w:ilvl="${level.level}">${start}<w:numFmt w:val="${escapeAttribute(
     level.format,
-  )}"/><w:lvlText w:val="${escapeAttribute(level.text)}"/>${paragraphStyle}</w:lvl>`;
+  )}"/><w:lvlText w:val="${escapeAttribute(level.text)}"/>${paragraphStyle}${isLegal}${suffix}</w:lvl>`;
 }
 
 function serializeInstance(instance: NumberingCatalog["instances"][string]): string {

package/src/io/normalize/normalize-text.ts

@@ -11,6 +11,7 @@ import type {
   OpaqueInlineNode,
   ParagraphNode,
   PreservationStore,
+  SectionBreakNode,
   TableCellNode,
   TableNode,
   TableRowNode,
@@ -27,6 +28,7 @@ import type {
   ParsedImageNode,
   ParsedMainDocument,
   ParsedParagraphNode,
+  ParsedSectionBreakNode,
   ParsedSdtNode,
   ParsedTableBlockNode,
   ParsedTableCellNode,
@@ -38,6 +40,7 @@ export interface NormalizedTextDocument {
   media: MediaCatalog;
   preservation: PreservationStore;
   diagnostics: DiagnosticStore;
+  finalSectionProperties?: ParsedMainDocument["finalSectionProperties"];
 }
 
 interface NormalizationState {
@@ -72,17 +75,19 @@ export function normalizeParsedTextDocument(
     },
   };
 
-  const children = document.blocks.map((block, index) => {
-    if (
-      index > 0 &&
-      document.blocks[index - 1]?.type === "paragraph" &&
-      block.type === "paragraph"
-    ) {
-      state.cursor += 1;
-    }
+  const children: BlockNode[] = [];
+  let previousParagraph = false;
 
-    return normalizeBlock(block, state, packagePartName);
-  });
+  for (const block of document.blocks) {
+    const normalizedBlocks = normalizeBlocks(block, state, packagePartName);
+    for (const normalizedBlock of normalizedBlocks) {
+      if (previousParagraph && normalizedBlock.type === "paragraph") {
+        state.cursor += 1;
+      }
+      children.push(normalizedBlock);
+      previousParagraph = normalizedBlock.type === "paragraph";
+    }
+  }
 
   return {
     content: {
@@ -92,41 +97,53 @@ export function normalizeParsedTextDocument(
     media: state.media,
     preservation: state.preservation,
     diagnostics: state.diagnostics,
+    ...(document.finalSectionProperties !== undefined
+      ? { finalSectionProperties: document.finalSectionProperties }
+      : {}),
   };
 }
 
-function normalizeBlock(
+function normalizeBlocks(
   block: ParsedBlockNode,
   state: NormalizationState,
   packagePartName: string,
-): BlockNode {
+): BlockNode[] {
   if (block.type === "opaque_block") {
     const opaque = recordOpaqueFragment("opaque_block", block.rawXml, state, packagePartName);
     state.cursor += 1;
-    return {
-      type: "opaque_block",
-      fragmentId: opaque.fragmentId,
-      warningId: opaque.warningId,
-    };
+    return [
+      {
+        type: "opaque_block",
+        fragmentId: opaque.fragmentId,
+        warningId: opaque.warningId,
+      },
+    ];
   }
 
   if (block.type === "table") {
-    return normalizeTable(block, state, packagePartName);
+    return [normalizeTable(block, state, packagePartName)];
   }
 
   if (block.type === "sdt") {
-    return normalizeSdt(block, state, packagePartName);
+    return [normalizeSdt(block, state, packagePartName)];
   }
 
   if (block.type === "custom_xml") {
-    return normalizeCustomXml(block, state, packagePartName);
+    return [normalizeCustomXml(block, state, packagePartName)];
   }
 
   if (block.type === "alt_chunk") {
-    return normalizeAltChunk(block, state);
+    return [normalizeAltChunk(block, state)];
+  }
+
+  if (block.type === "section_break") {
+    return [normalizeSectionBreak(block)];
   }
 
-  return normalizeParagraph(block, state, packagePartName);
+  const normalizedParagraph = normalizeParagraph(block, state, packagePartName);
+  return block.sectionProperties
+    ? [normalizedParagraph, normalizeInlineSectionBreak(block)]
+    : [normalizedParagraph];
 }
 
 function normalizeParagraph(
@@ -190,7 +207,7 @@ function normalizeTableCell(
 ): TableCellNode {
   const children: BlockNode[] = [];
   for (const block of cell.children) {
-    children.push(normalizeBlock(block, state, packagePartName));
+    children.push(...normalizeBlocks(block, state, packagePartName));
   }
   // Ensure at least one child (OOXML requires at least one <w:p> per cell)
   if (children.length === 0) {
@@ -213,7 +230,7 @@ function normalizeSdt(
   return {
     type: "sdt",
     properties: { ...block.properties },
-    children: block.children.map((child) => normalizeBlock(child, state, packagePartName)),
+    children: block.children.flatMap((child) => normalizeBlocks(child, state, packagePartName)),
   };
 }
 
@@ -226,7 +243,27 @@ function normalizeCustomXml(
     type: "custom_xml",
     ...(block.uri ? { uri: block.uri } : {}),
     ...(block.element ? { element: block.element } : {}),
-    children: block.children.map((child) => normalizeBlock(child, state, packagePartName)),
+    children: block.children.flatMap((child) => normalizeBlocks(child, state, packagePartName)),
+  };
+}
+
+function normalizeSectionBreak(block: ParsedSectionBreakNode): SectionBreakNode {
+  return {
+    type: "section_break",
+    sectionPropertiesXml: block.sectionPropertiesXml,
+    sectionProperties: block.sectionProperties,
+  };
+}
+
+function normalizeInlineSectionBreak(
+  paragraph: ParsedParagraphNode,
+): SectionBreakNode {
+  return {
+    type: "section_break",
+    ...(paragraph.sectionPropertiesXml
+      ? { sectionPropertiesXml: paragraph.sectionPropertiesXml }
+      : {}),
+    sectionProperties: paragraph.sectionProperties!,
   };
 }
 
@@ -324,6 +361,7 @@ function normalizeInlineChildren(
           type: "shape",
           ...(node.text ? { text: node.text } : {}),
           ...(node.geometry ? { geometry: node.geometry } : {}),
+          ...(node.isTextBox ? { isTextBox: true } : {}),
           rawXml: node.rawXml,
         });
         state.cursor += 1;

package/src/io/ooxml/numbering-sentinels.ts

@@ -0,0 +1,44 @@
+import type { NumberingCatalog } from "../../model/canonical-document.ts";
+
+export const DOCX_NULL_NUMBERING_INSTANCE_ID = "num:0";
+export const DOCX_NULL_ABSTRACT_NUMBERING_ID = "abstract-num:__docx-import-null__";
+
+export function createSyntheticDocxNullNumberingCatalog(): Pick<
+  NumberingCatalog,
+  "abstractDefinitions" | "instances"
+> {
+  return {
+    abstractDefinitions: {
+      [DOCX_NULL_ABSTRACT_NUMBERING_ID]: {
+        abstractNumberingId: DOCX_NULL_ABSTRACT_NUMBERING_ID,
+        levels: Array.from({ length: 9 }, (_unused, level) => ({
+          level,
+          format: "none",
+          text: "",
+        })),
+      },
+    },
+    instances: {
+      [DOCX_NULL_NUMBERING_INSTANCE_ID]: {
+        numberingInstanceId: DOCX_NULL_NUMBERING_INSTANCE_ID,
+        abstractNumberingId: DOCX_NULL_ABSTRACT_NUMBERING_ID,
+        overrides: [],
+      },
+    },
+  };
+}
+
+export function isSyntheticDocxNullAbstractDefinition(
+  definition: NumberingCatalog["abstractDefinitions"][string],
+): boolean {
+  return definition.abstractNumberingId === DOCX_NULL_ABSTRACT_NUMBERING_ID;
+}
+
+export function isSyntheticDocxNullNumberingInstance(
+  instance: NumberingCatalog["instances"][string],
+): boolean {
+  return (
+    instance.numberingInstanceId === DOCX_NULL_NUMBERING_INSTANCE_ID &&
+    instance.abstractNumberingId === DOCX_NULL_ABSTRACT_NUMBERING_ID
+  );
+}