@beyondwork/docx-react-component 1.0.0

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

@@ -0,0 +1,437 @@
+import type {
+  AltChunkNode,
+  BlockNode,
+  CustomXmlNode,
+  DiagnosticStore,
+  DocumentRootNode,
+  InlineNode,
+  MediaCatalog,
+  OpaqueBlockNode,
+  OpaqueFragmentRecord,
+  OpaqueInlineNode,
+  ParagraphNode,
+  PreservationStore,
+  TableCellNode,
+  TableNode,
+  TableRowNode,
+  TextMark,
+  TextNode,
+  SdtNode,
+} from "../../model/canonical-document.ts";
+import type {
+  ParsedAltChunkNode,
+  ParsedBlockNode,
+  ParsedCustomXmlNode,
+  ParsedHyperlinkNode,
+  ParsedInlineNode,
+  ParsedImageNode,
+  ParsedMainDocument,
+  ParsedParagraphNode,
+  ParsedSdtNode,
+  ParsedTableBlockNode,
+  ParsedTableCellNode,
+  ParsedTableRowNode,
+} from "../ooxml/parse-main-document.ts";
+
+export interface NormalizedTextDocument {
+  content: DocumentRootNode;
+  media: MediaCatalog;
+  preservation: PreservationStore;
+  diagnostics: DiagnosticStore;
+}
+
+interface NormalizationState {
+  nextFragmentIndex: number;
+  nextWarningIndex: number;
+  nextDiagnosticIndex: number;
+  cursor: number;
+  media: MediaCatalog;
+  preservation: PreservationStore;
+  diagnostics: DiagnosticStore;
+}
+
+export function normalizeParsedTextDocument(
+  document: ParsedMainDocument,
+  packagePartName = "/word/document.xml",
+): NormalizedTextDocument {
+  const state: NormalizationState = {
+    nextFragmentIndex: 1,
+    nextWarningIndex: 1,
+    nextDiagnosticIndex: 1,
+    cursor: 0,
+    media: {
+      items: {},
+    },
+    preservation: {
+      opaqueFragments: {},
+      packageParts: {},
+    },
+    diagnostics: {
+      warnings: [],
+      errors: [],
+    },
+  };
+
+  const children = document.blocks.map((block, index) => {
+    if (
+      index > 0 &&
+      document.blocks[index - 1]?.type === "paragraph" &&
+      block.type === "paragraph"
+    ) {
+      state.cursor += 1;
+    }
+
+    return normalizeBlock(block, state, packagePartName);
+  });
+
+  return {
+    content: {
+      type: "doc",
+      children,
+    },
+    media: state.media,
+    preservation: state.preservation,
+    diagnostics: state.diagnostics,
+  };
+}
+
+function normalizeBlock(
+  block: ParsedBlockNode,
+  state: NormalizationState,
+  packagePartName: string,
+): 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,
+    };
+  }
+
+  if (block.type === "table") {
+    return normalizeTable(block, state, packagePartName);
+  }
+
+  if (block.type === "sdt") {
+    return normalizeSdt(block, state, packagePartName);
+  }
+
+  if (block.type === "custom_xml") {
+    return normalizeCustomXml(block, state, packagePartName);
+  }
+
+  if (block.type === "alt_chunk") {
+    return normalizeAltChunk(block, state);
+  }
+
+  return normalizeParagraph(block, state, packagePartName);
+}
+
+function normalizeParagraph(
+  paragraph: ParsedParagraphNode,
+  state: NormalizationState,
+  packagePartName: string,
+): ParagraphNode {
+  const children = normalizeInlineChildren(paragraph.children, state, packagePartName);
+  return {
+    type: "paragraph",
+    ...(paragraph.styleId ? { styleId: paragraph.styleId } : {}),
+    ...(paragraph.numbering ? { numbering: paragraph.numbering } : {}),
+    ...(paragraph.alignment ? { alignment: paragraph.alignment } : {}),
+    ...(paragraph.spacing ? { spacing: paragraph.spacing } : {}),
+    ...(paragraph.indentation ? { indentation: paragraph.indentation } : {}),
+    ...(paragraph.tabStops && paragraph.tabStops.length > 0 ? { tabStops: paragraph.tabStops } : {}),
+    ...(paragraph.keepNext ? { keepNext: paragraph.keepNext } : {}),
+    ...(paragraph.keepLines ? { keepLines: paragraph.keepLines } : {}),
+    ...(paragraph.outlineLevel !== undefined ? { outlineLevel: paragraph.outlineLevel } : {}),
+    ...(paragraph.pageBreakBefore ? { pageBreakBefore: paragraph.pageBreakBefore } : {}),
+    children,
+  };
+}
+
+function normalizeTable(
+  table: ParsedTableBlockNode,
+  state: NormalizationState,
+  packagePartName: string,
+): TableNode {
+  const rows = table.rows.map((row) => normalizeTableRow(row, state, packagePartName));
+  state.cursor += 1;
+  return {
+    type: "table",
+    ...(table.styleId ? { styleId: table.styleId } : {}),
+    ...(table.propertiesXml ? { propertiesXml: table.propertiesXml } : {}),
+    gridColumns: table.gridColumns,
+    rows,
+  };
+}
+
+function normalizeTableRow(
+  row: ParsedTableRowNode,
+  state: NormalizationState,
+  packagePartName: string,
+): TableRowNode {
+  const cells = row.cells.map((cell) => normalizeTableCell(cell, state, packagePartName));
+  return {
+    type: "table_row",
+    ...(row.propertiesXml ? { propertiesXml: row.propertiesXml } : {}),
+    cells,
+  };
+}
+
+function normalizeTableCell(
+  cell: ParsedTableCellNode,
+  state: NormalizationState,
+  packagePartName: string,
+): TableCellNode {
+  const children: BlockNode[] = [];
+  for (const block of cell.children) {
+    children.push(normalizeBlock(block, state, packagePartName));
+  }
+  // Ensure at least one child (OOXML requires at least one <w:p> per cell)
+  if (children.length === 0) {
+    children.push({ type: "paragraph", children: [] });
+  }
+  return {
+    type: "table_cell",
+    ...(cell.propertiesXml ? { propertiesXml: cell.propertiesXml } : {}),
+    ...(cell.gridSpan ? { gridSpan: cell.gridSpan } : {}),
+    ...(cell.verticalMerge ? { verticalMerge: cell.verticalMerge } : {}),
+    children,
+  };
+}
+
+function normalizeSdt(
+  block: ParsedSdtNode,
+  state: NormalizationState,
+  packagePartName: string,
+): SdtNode {
+  return {
+    type: "sdt",
+    properties: { ...block.properties },
+    children: block.children.map((child) => normalizeBlock(child, state, packagePartName)),
+  };
+}
+
+function normalizeCustomXml(
+  block: ParsedCustomXmlNode,
+  state: NormalizationState,
+  packagePartName: string,
+): CustomXmlNode {
+  return {
+    type: "custom_xml",
+    ...(block.uri ? { uri: block.uri } : {}),
+    ...(block.element ? { element: block.element } : {}),
+    children: block.children.map((child) => normalizeBlock(child, state, packagePartName)),
+  };
+}
+
+function normalizeAltChunk(
+  block: ParsedAltChunkNode,
+  state: NormalizationState,
+): AltChunkNode {
+  state.cursor += 1;
+  return {
+    type: "alt_chunk",
+    relationshipId: block.relationshipId,
+  };
+}
+
+function normalizeInlineChildren(
+  nodes: ParsedInlineNode[],
+  state: NormalizationState,
+  packagePartName: string,
+): InlineNode[] {
+  const normalized: InlineNode[] = [];
+
+  for (const node of nodes) {
+    switch (node.type) {
+      case "text": {
+        if (node.text.length === 0) {
+          continue;
+        }
+
+        const previous = normalized[normalized.length - 1];
+        if (previous?.type === "text" && sameMarks(previous.marks, node.marks)) {
+          previous.text += node.text;
+        } else {
+          normalized.push({
+            type: "text",
+            text: node.text,
+            ...(node.marks && node.marks.length > 0 ? { marks: node.marks } : {}),
+          });
+        }
+        state.cursor += node.text.length;
+        break;
+      }
+      case "tab":
+        normalized.push({ type: "tab" });
+        state.cursor += 1;
+        break;
+      case "hard_break":
+        normalized.push({ type: "hard_break" });
+        state.cursor += 1;
+        break;
+      case "image":
+        normalized.push(normalizeImageNode(node, state));
+        state.cursor += 1;
+        break;
+      case "hyperlink":
+        normalized.push(normalizeHyperlink(node));
+        state.cursor += measureHyperlink(node);
+        break;
+      case "opaque_inline": {
+        const opaque = recordOpaqueFragment("opaque_inline", node.rawXml, state, packagePartName);
+        normalized.push(opaque as OpaqueInlineNode);
+        state.cursor += 1;
+        break;
+      }
+    }
+  }
+
+  return normalized;
+}
+
+function normalizeImageNode(
+  node: ParsedImageNode,
+  state: NormalizationState,
+): InlineNode {
+  if (!state.media.items[node.mediaId]) {
+    const packagePartName =
+      typeof node.packagePartName === "string" && node.packagePartName.length > 0
+        ? node.packagePartName
+        : `/${node.mediaId.slice("media:".length)}`;
+    const filename =
+      typeof node.filename === "string" && node.filename.length > 0
+        ? node.filename
+        : packagePartName.slice(packagePartName.lastIndexOf("/") + 1) || "image.bin";
+    state.media.items[node.mediaId] = {
+      mediaId: node.mediaId,
+      contentType: node.contentType ?? "application/octet-stream",
+      filename,
+      packagePartName,
+      ...(node.relationshipId ? { relationshipId: node.relationshipId } : {}),
+      ...(node.altText ? { altText: node.altText } : {}),
+    };
+  }
+
+  return {
+    type: "image",
+    mediaId: node.mediaId,
+    ...(node.altText ? { altText: node.altText } : {}),
+    ...(node.placementXml ? { placementXml: node.placementXml } : {}),
+    ...(node.display ? { display: node.display } : {}),
+    ...(node.floating ? { floating: node.floating } : {}),
+  };
+}
+
+function normalizeHyperlink(node: ParsedHyperlinkNode): {
+  type: "hyperlink";
+  href: string;
+  children: Array<TextNode | { type: "hard_break" } | { type: "tab" }>;
+} {
+  const children: Array<TextNode | { type: "hard_break" } | { type: "tab" }> = [];
+
+  for (const child of node.children) {
+    switch (child.type) {
+      case "text": {
+        if (child.text.length === 0) {
+          continue;
+        }
+        const previous = children[children.length - 1];
+        if (previous?.type === "text" && sameMarks(previous.marks, child.marks)) {
+          previous.text += child.text;
+        } else {
+          children.push({
+            type: "text",
+            text: child.text,
+            ...(child.marks && child.marks.length > 0 ? { marks: child.marks } : {}),
+          });
+        }
+        break;
+      }
+      case "tab":
+        children.push({ type: "tab" });
+        break;
+      case "hard_break":
+        children.push({ type: "hard_break" });
+        break;
+    }
+  }
+
+  return {
+    type: "hyperlink",
+    href: node.href,
+    children,
+  };
+}
+
+function measureHyperlink(node: ParsedHyperlinkNode): number {
+  return node.children.reduce((size, child) => {
+    switch (child.type) {
+      case "text":
+        return size + child.text.length;
+      case "tab":
+      case "hard_break":
+        return size + 1;
+    }
+  }, 0);
+}
+
+function sameMarks(left: TextMark[] | undefined, right: TextMark[] | undefined): boolean {
+  const leftMarks = normalizeMarks(left);
+  const rightMarks = normalizeMarks(right);
+  return leftMarks.length === rightMarks.length && leftMarks.every((mark, index) => mark === rightMarks[index]);
+}
+
+function normalizeMarks(marks: TextMark[] | undefined): string[] {
+  return [...(marks ?? []).map((mark) => mark.type)].sort();
+}
+
+function recordOpaqueFragment(
+  nodeType: "opaque_inline" | "opaque_block",
+  rawXml: string,
+  state: NormalizationState,
+  packagePartName: string,
+): { type: "opaque_inline" | "opaque_block"; fragmentId: string; warningId: string } {
+  const fragmentId = `fragment:import-${state.nextFragmentIndex}`;
+  state.nextFragmentIndex += 1;
+  const warningId = `warning:import-${state.nextWarningIndex}`;
+  state.nextWarningIndex += 1;
+  const diagnosticId = `diagnostic:import-${state.nextDiagnosticIndex}`;
+  state.nextDiagnosticIndex += 1;
+
+  const rangeStart = state.cursor;
+  const rangeEnd = state.cursor + 1;
+
+  const record: OpaqueFragmentRecord = {
+    fragmentId,
+    payloadKind: "xml-subtree",
+    payloadReference: rawXml,
+    featureClass: "preserve-only",
+    lastKnownRange: {
+      from: rangeStart,
+      to: rangeEnd,
+    },
+    warningId,
+    packagePartName,
+  };
+
+  state.preservation.opaqueFragments[fragmentId] = record;
+  state.diagnostics.warnings.push({
+    diagnosticId,
+    warningId,
+    source: "import",
+    message:
+      nodeType === "opaque_inline"
+        ? "Unsupported inline OOXML was preserved as an opaque placeholder."
+        : "Unsupported block OOXML was preserved as an opaque placeholder.",
+  });
+
+  return {
+    type: nodeType,
+    fragmentId,
+    warningId,
+  };
+}

package/src/io/ooxml/README.md

@@ -0,0 +1,3 @@
+# IO OOXML
+
+WordprocessingML parsing and intermediate OOXML structures belong here.