@beyondwork/docx-react-component 1.0.1 → 1.0.3

package/src/io/export/serialize-runtime-revisions.ts

@@ -0,0 +1,265 @@
+import type { RevisionRecord } from "../../review/store/revision-types.ts";
+import {
+  mapRevisionBoundaries,
+  type RevisionParagraphBoundary,
+} from "../ooxml/revision-boundaries.ts";
+
+interface XmlReplacement {
+  start: number;
+  end: number;
+  replacement: string;
+}
+
+export interface SerializedRuntimeRevisionsResult {
+  documentXml: string;
+  serializedRevisionIds: string[];
+  skippedRevisionIds: string[];
+}
+
+export function serializeRuntimeRevisionsIntoDocumentXml(
+  documentXml: string,
+  revisions: readonly RevisionRecord[],
+  boundaries: readonly RevisionParagraphBoundary[] = mapRevisionBoundaries(documentXml),
+): SerializedRuntimeRevisionsResult {
+  const replacements: XmlReplacement[] = [];
+  const serializedRevisionIds: string[] = [];
+  const skippedRevisionIds: string[] = [];
+  const paragraphMarkers = new Map<
+    number,
+    { boundary: RevisionParagraphBoundary; markers: string[]; revisionIds: string[] }
+  >();
+
+  for (const revision of revisions) {
+    if (revision.status !== "active" || revision.anchor.kind !== "range") {
+      continue;
+    }
+
+    if (revision.kind !== "insertion" && revision.kind !== "deletion") {
+      continue;
+    }
+
+    const form = revision.metadata.importedRevisionForm;
+    if (form === "paragraph-insertion" || form === "paragraph-deletion") {
+      const paragraphBoundary = findParagraphBoundaryForAnchor(boundaries, revision);
+      if (!paragraphBoundary) {
+        skippedRevisionIds.push(revision.revisionId);
+        continue;
+      }
+
+      const entry = paragraphMarkers.get(paragraphBoundary.paragraphIndex) ?? {
+        boundary: paragraphBoundary,
+        markers: [],
+        revisionIds: [],
+      };
+      entry.markers.push(createParagraphRevisionMarker(revision));
+      entry.revisionIds.push(revision.revisionId);
+      paragraphMarkers.set(paragraphBoundary.paragraphIndex, entry);
+      serializedRevisionIds.push(revision.revisionId);
+      continue;
+    }
+
+    const rangeReplacement = createRangeRevisionReplacement(documentXml, boundaries, revision);
+    if (!rangeReplacement) {
+      skippedRevisionIds.push(revision.revisionId);
+      continue;
+    }
+
+    replacements.push(rangeReplacement);
+    serializedRevisionIds.push(revision.revisionId);
+  }
+
+  for (const { boundary, markers, revisionIds } of paragraphMarkers.values()) {
+    const paragraphInsertion = createParagraphRevisionInsertion(
+      documentXml,
+      boundary,
+      markers,
+    );
+    if (!paragraphInsertion) {
+      skippedRevisionIds.push(...revisionIds);
+      continue;
+    }
+
+    replacements.push(paragraphInsertion);
+  }
+
+  return {
+    documentXml: applyReplacements(documentXml, replacements),
+    serializedRevisionIds,
+    skippedRevisionIds,
+  };
+}
+
+function createRangeRevisionReplacement(
+  documentXml: string,
+  boundaries: readonly RevisionParagraphBoundary[],
+  revision: RevisionRecord,
+): XmlReplacement | undefined {
+  const paragraphBoundary = findParagraphBoundaryForRange(boundaries, revision.anchor.range.from, revision.anchor.range.to);
+  if (!paragraphBoundary) {
+    return undefined;
+  }
+
+  const startIndex = paragraphBoundary.boundaries.get(revision.anchor.range.from);
+  const endIndex = paragraphBoundary.boundaries.get(revision.anchor.range.to);
+  if (startIndex === undefined || endIndex === undefined || endIndex < startIndex) {
+    return undefined;
+  }
+
+  const xml = documentXml.slice(startIndex, endIndex);
+  const attributes = serializeRevisionAttributes(revision);
+  return {
+    start: startIndex,
+    end: endIndex,
+    replacement:
+      revision.kind === "insertion"
+        ? `<w:ins${attributes}>${xml}</w:ins>`
+        : `<w:del${attributes}>${convertRunsToDeletedContent(xml)}</w:del>`,
+  };
+}
+
+function createParagraphRevisionMarker(revision: RevisionRecord): string {
+  const markerName = revision.kind === "insertion" ? "w:ins" : "w:del";
+  return `<${markerName}${serializeRevisionAttributes(revision)}/>`;
+}
+
+function createParagraphRevisionInsertion(
+  documentXml: string,
+  paragraphBoundary: RevisionParagraphBoundary,
+  markers: readonly string[],
+): XmlReplacement | undefined {
+  const paragraphXml = documentXml.slice(
+    paragraphBoundary.paragraphStart,
+    paragraphBoundary.paragraphEnd,
+  );
+  const markerXml = markers.join("");
+  const paragraphRunPropertiesInsertionIndex = findClosingTagInsertionIndex(
+    documentXml,
+    paragraphBoundary.paragraphRunPropertiesStart,
+    paragraphBoundary.paragraphRunPropertiesEnd,
+    "w:rPr",
+  );
+  if (paragraphRunPropertiesInsertionIndex !== undefined) {
+    return {
+      start: paragraphRunPropertiesInsertionIndex,
+      end: paragraphRunPropertiesInsertionIndex,
+      replacement: markerXml,
+    };
+  }
+
+  const paragraphPropertiesInsertionIndex = findClosingTagInsertionIndex(
+    documentXml,
+    paragraphBoundary.paragraphPropertiesStart,
+    paragraphBoundary.paragraphPropertiesEnd,
+    "w:pPr",
+  );
+  if (paragraphPropertiesInsertionIndex !== undefined) {
+    return {
+      start: paragraphPropertiesInsertionIndex,
+      end: paragraphPropertiesInsertionIndex,
+      replacement: `<w:rPr>${markerXml}</w:rPr>`,
+    };
+  }
+
+  if (!/<w:p[\s>]/u.test(paragraphXml)) {
+    return undefined;
+  }
+
+  return {
+    start: paragraphBoundary.paragraphStartTagEnd,
+    end: paragraphBoundary.paragraphStartTagEnd,
+    replacement: `<w:pPr><w:rPr>${markerXml}</w:rPr></w:pPr>`,
+  };
+}
+
+function findParagraphBoundaryForRange(
+  boundaries: readonly RevisionParagraphBoundary[],
+  from: number,
+  to: number,
+): RevisionParagraphBoundary | undefined {
+  return boundaries.find(
+    (boundary) => from >= boundary.start && to <= boundary.end,
+  );
+}
+
+function findParagraphBoundaryForAnchor(
+  boundaries: readonly RevisionParagraphBoundary[],
+  revision: RevisionRecord,
+): RevisionParagraphBoundary | undefined {
+  const anchor = revision.anchor.kind === "range" ? revision.anchor.range.from : undefined;
+  if (anchor === undefined) {
+    return undefined;
+  }
+
+  return boundaries.find(
+    (boundary) =>
+      boundary.end === anchor ||
+      (anchor >= boundary.start && anchor <= boundary.end),
+  );
+}
+
+function serializeRevisionAttributes(revision: RevisionRecord): string {
+  const attributes = {
+    "w:id": revision.metadata.ooxmlRevisionId ?? sanitizeRevisionId(revision.revisionId),
+    "w:author": revision.authorId,
+    "w:date": revision.createdAt,
+  };
+
+  return Object.entries(attributes)
+    .filter(([, value]) => value && value.length > 0)
+    .map(([name, value]) => ` ${name}="${escapeAttribute(value)}"`)
+    .join("");
+}
+
+function findClosingTagInsertionIndex(
+  documentXml: string,
+  start: number | undefined,
+  end: number | undefined,
+  tagName: string,
+): number | undefined {
+  if (start === undefined || end === undefined) {
+    return undefined;
+  }
+
+  const closingTag = `</${tagName}>`;
+  const closingIndex = documentXml.lastIndexOf(closingTag, end);
+  if (closingIndex < start) {
+    return undefined;
+  }
+
+  return closingIndex;
+}
+
+function sanitizeRevisionId(revisionId: string): string {
+  const numericTail = /(\d+)$/.exec(revisionId)?.[1];
+  return numericTail ?? revisionId.replace(/[^A-Za-z0-9._-]/g, "-");
+}
+
+function convertRunsToDeletedContent(xml: string): string {
+  return xml
+    .replace(/<(\/?)w:t\b/g, "<$1w:delText")
+    .replace(/<(\/?)w:instrText\b/g, "<$1w:delInstrText");
+}
+
+function applyReplacements(documentXml: string, replacements: readonly XmlReplacement[]): string {
+  const sorted = replacements
+    .slice()
+    .sort((left, right) => right.start - left.start || right.end - left.end);
+  let output = documentXml;
+
+  for (const replacement of sorted) {
+    output =
+      output.slice(0, replacement.start) +
+      replacement.replacement +
+      output.slice(replacement.end);
+  }
+
+  return output;
+}
+
+function escapeAttribute(value: string): string {
+  return value
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;");
+}

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

@@ -0,0 +1,147 @@
+import type {
+  ParsedBorderSpec,
+  ParsedCellMargins,
+  ParsedCellShading,
+  ParsedTable,
+  ParsedTableBorders,
+  ParsedTableCell,
+  ParsedTableCellBorders,
+  ParsedTableRow,
+  ParsedTableWidth,
+} from "../ooxml/parse-tables.ts";
+
+export function serializeTable(table: ParsedTable): string {
+  const propertiesXml = table.propertiesXml ?? buildTablePropertiesXml(table);
+  const gridXml =
+    table.gridColumns.length > 0
+      ? `<w:tblGrid>${table.gridColumns
+          .map((width) => `<w:gridCol w:w="${width}"/>`)
+          .join("")}</w:tblGrid>`
+      : "";
+  const rowsXml = table.rows.map(serializeRow).join("");
+
+  return `<w:tbl>${propertiesXml}${gridXml}${rowsXml}</w:tbl>`;
+}
+
+function serializeRow(row: ParsedTableRow): string {
+  const propertiesXml = row.propertiesXml ?? buildRowPropertiesXml(row);
+  return `<w:tr>${propertiesXml}${row.cells.map(serializeCell).join("")}</w:tr>`;
+}
+
+function serializeCell(cell: ParsedTableCell): string {
+  const propertiesXml = ensureCellProperties(cell);
+  const blocksXml = cell.blocksXml.length > 0 ? cell.blocksXml.join("") : "<w:p/>";
+  return `<w:tc>${propertiesXml}${blocksXml}</w:tc>`;
+}
+
+function buildTablePropertiesXml(table: ParsedTable): string {
+  const children: string[] = [];
+  if (table.width) {
+    children.push(serializeWidth("tblW", table.width));
+  }
+  if (table.alignment) {
+    children.push(`<w:jc w:val="${table.alignment}"/>`);
+  }
+  if (table.borders) {
+    const bordersXml = serializeTableBorders(table.borders);
+    if (bordersXml) children.push(`<w:tblBorders>${bordersXml}</w:tblBorders>`);
+  }
+  if (table.cellMargins) {
+    const marginsXml = serializeTableCellMargins(table.cellMargins);
+    if (marginsXml) children.push(`<w:tblCellMar>${marginsXml}</w:tblCellMar>`);
+  }
+  return children.length > 0 ? `<w:tblPr>${children.join("")}</w:tblPr>` : "";
+}
+
+function buildRowPropertiesXml(row: ParsedTableRow): string {
+  const children: string[] = [];
+  if (row.height !== undefined) {
+    const hRuleAttr = row.heightRule ? ` w:hRule="${row.heightRule}"` : "";
+    children.push(`<w:trHeight w:val="${row.height}"${hRuleAttr}/>`);
+  }
+  if (row.isHeader) {
+    children.push(`<w:tblHeader/>`);
+  }
+  return children.length > 0 ? `<w:trPr>${children.join("")}</w:trPr>` : "";
+}
+
+function ensureCellProperties(cell: ParsedTableCell): string {
+  if (cell.propertiesXml) {
+    return cell.propertiesXml;
+  }
+
+  const children: string[] = [];
+  if (cell.width) {
+    children.push(serializeWidth("tcW", cell.width));
+  }
+  if (cell.gridSpan && cell.gridSpan > 1) {
+    children.push(`<w:gridSpan w:val="${cell.gridSpan}"/>`);
+  }
+  if (cell.verticalMerge) {
+    children.push(
+      cell.verticalMerge === "restart"
+        ? `<w:vMerge w:val="restart"/>`
+        : `<w:vMerge/>`,
+    );
+  }
+  if (cell.borders) {
+    const bordersXml = serializeCellBorders(cell.borders);
+    if (bordersXml) children.push(`<w:tcBorders>${bordersXml}</w:tcBorders>`);
+  }
+  if (cell.shading) {
+    children.push(serializeCellShading(cell.shading));
+  }
+  if (cell.verticalAlign) {
+    children.push(`<w:vAlign w:val="${cell.verticalAlign}"/>`);
+  }
+
+  return children.length > 0 ? `<w:tcPr>${children.join("")}</w:tcPr>` : "";
+}
+
+function serializeWidth(element: string, width: ParsedTableWidth): string {
+  return `<w:${element} w:w="${width.value}" w:type="${width.type}"/>`;
+}
+
+function serializeBorderSpec(element: string, spec: ParsedBorderSpec): string {
+  const attrs: string[] = [];
+  if (spec.value) attrs.push(`w:val="${spec.value}"`);
+  if (spec.size !== undefined) attrs.push(`w:sz="${spec.size}"`);
+  if (spec.space !== undefined) attrs.push(`w:space="${spec.space}"`);
+  if (spec.color) attrs.push(`w:color="${spec.color}"`);
+  const attrsStr = attrs.length > 0 ? ` ${attrs.join(" ")}` : "";
+  return `<w:${element}${attrsStr}/>`;
+}
+
+function serializeTableBorders(borders: ParsedTableBorders): string {
+  const sides = ["top", "left", "bottom", "right", "insideH", "insideV"] as const;
+  return sides
+    .filter((side) => borders[side] !== undefined)
+    .map((side) => serializeBorderSpec(side, borders[side]!))
+    .join("");
+}
+
+function serializeCellBorders(borders: ParsedTableCellBorders): string {
+  const sides = ["top", "left", "bottom", "right", "insideH", "insideV"] as const;
+  return sides
+    .filter((side) => borders[side] !== undefined)
+    .map((side) => serializeBorderSpec(side, borders[side]!))
+    .join("");
+}
+
+function serializeCellShading(shading: ParsedCellShading): string {
+  const attrs: string[] = [];
+  if (shading.val) attrs.push(`w:val="${shading.val}"`);
+  if (shading.color) attrs.push(`w:color="${shading.color}"`);
+  if (shading.fill) attrs.push(`w:fill="${shading.fill}"`);
+  const attrsStr = attrs.length > 0 ? ` ${attrs.join(" ")}` : "";
+  return `<w:shd${attrsStr}/>`;
+}
+
+function serializeTableCellMargins(margins: ParsedCellMargins): string {
+  const parts: string[] = [];
+  if (margins.top !== undefined) parts.push(`<w:top w:w="${margins.top}" w:type="dxa"/>`);
+  if (margins.left !== undefined) parts.push(`<w:left w:w="${margins.left}" w:type="dxa"/>`);
+  if (margins.bottom !== undefined) parts.push(`<w:bottom w:w="${margins.bottom}" w:type="dxa"/>`);
+  if (margins.right !== undefined) parts.push(`<w:right w:w="${margins.right}" w:type="dxa"/>`);
+  return parts.join("");
+}

package/src/io/export/split-review-boundaries.ts

@@ -0,0 +1,194 @@
+import type {
+  DocumentRootNode,
+  HyperlinkNode,
+  InlineNode,
+  ParagraphNode,
+  TextNode,
+} from "../../model/canonical-document.ts";
+import type { CommentThread } from "../../review/store/comment-store.ts";
+import type { RevisionRecord } from "../../review/store/revision-types.ts";
+
+export function splitDocumentAtReviewBoundaries(
+  content: DocumentRootNode,
+  comments: readonly CommentThread[],
+  revisions: readonly RevisionRecord[],
+): DocumentRootNode {
+  const splitPositions = collectSplitPositions(comments, revisions);
+  if (splitPositions.size === 0) {
+    return content;
+  }
+
+  let cursor = 0;
+  const children = content.children.map((block, index) => {
+    if (index > 0 && content.children[index - 1]?.type === "paragraph" && block.type === "paragraph") {
+      cursor += 1;
+    }
+
+    if (block.type !== "paragraph") {
+      cursor += 1;
+      return block;
+    }
+
+    const next = splitParagraph(block, splitPositions, cursor);
+    cursor = next.cursor;
+    return next.paragraph;
+  });
+
+  return {
+    type: "doc",
+    children,
+  };
+}
+
+function collectSplitPositions(
+  comments: readonly CommentThread[],
+  revisions: readonly RevisionRecord[],
+): Set<number> {
+  const positions = new Set<number>();
+
+  for (const thread of comments) {
+    if (thread.anchor.kind !== "range") {
+      continue;
+    }
+
+    positions.add(thread.anchor.range.from);
+    positions.add(thread.anchor.range.to);
+  }
+
+  for (const revision of revisions) {
+    if (revision.status !== "active" || revision.anchor.kind !== "range") {
+      continue;
+    }
+
+    if (
+      revision.metadata.importedRevisionForm === "paragraph-insertion" ||
+      revision.metadata.importedRevisionForm === "paragraph-deletion"
+    ) {
+      continue;
+    }
+
+    positions.add(revision.anchor.range.from);
+    positions.add(revision.anchor.range.to);
+  }
+
+  return positions;
+}
+
+function splitParagraph(
+  paragraph: ParagraphNode,
+  splitPositions: ReadonlySet<number>,
+  cursor: number,
+): { paragraph: ParagraphNode; cursor: number } {
+  const children: InlineNode[] = [];
+  let nextCursor = cursor;
+
+  for (const child of paragraph.children) {
+    if (child.type === "text") {
+      const split = splitTextNode(child, splitPositions, nextCursor);
+      children.push(...split.children);
+      nextCursor = split.cursor;
+      continue;
+    }
+
+    if (child.type === "hyperlink") {
+      const split = splitHyperlinkNode(child, splitPositions, nextCursor);
+      children.push(...split.children);
+      nextCursor = split.cursor;
+      continue;
+    }
+
+    children.push(child);
+    nextCursor += 1;
+  }
+
+  return {
+    paragraph: {
+      ...paragraph,
+      children,
+    },
+    cursor: nextCursor,
+  };
+}
+
+function splitHyperlinkNode(
+  node: HyperlinkNode,
+  splitPositions: ReadonlySet<number>,
+  cursor: number,
+): { children: HyperlinkNode[]; cursor: number } {
+  let nextCursor = cursor;
+  const groups: Array<HyperlinkNode["children"]> = [[]];
+
+  for (const child of node.children) {
+    if (child.type === "text") {
+      const split = splitTextNode(child, splitPositions, nextCursor);
+      for (const piece of split.children) {
+        groups[groups.length - 1]?.push(piece);
+        nextCursor += Array.from(piece.text).length;
+        if (splitPositions.has(nextCursor)) {
+          groups.push([]);
+        }
+      }
+      continue;
+    }
+
+    groups[groups.length - 1]?.push(child);
+    nextCursor += 1;
+    if (splitPositions.has(nextCursor)) {
+      groups.push([]);
+    }
+  }
+
+  const hyperlinks = groups
+    .filter((children) => children.length > 0)
+    .map((children) => ({
+      type: "hyperlink" as const,
+      href: node.href,
+      children,
+    }));
+
+  return {
+    children: hyperlinks.length > 0 ? hyperlinks : [node],
+    cursor: nextCursor,
+  };
+}
+
+function splitTextNode(
+  node: TextNode,
+  splitPositions: ReadonlySet<number>,
+  cursor: number,
+): { children: TextNode[]; cursor: number } {
+  const codepoints = Array.from(node.text);
+  if (codepoints.length === 0) {
+    return { children: [], cursor };
+  }
+
+  const boundaries = new Set<number>([0, codepoints.length]);
+  for (let index = 1; index < codepoints.length; index += 1) {
+    if (splitPositions.has(cursor + index)) {
+      boundaries.add(index);
+    }
+  }
+
+  const ordered = [...boundaries].sort((left, right) => left - right);
+  const children: TextNode[] = [];
+
+  for (let index = 0; index < ordered.length - 1; index += 1) {
+    const start = ordered[index] ?? 0;
+    const end = ordered[index + 1] ?? codepoints.length;
+    const text = codepoints.slice(start, end).join("");
+    if (text.length === 0) {
+      continue;
+    }
+
+    children.push({
+      type: "text",
+      text,
+      ...(node.marks && node.marks.length > 0 ? { marks: node.marks } : {}),
+    });
+  }
+
+  return {
+    children: children.length > 0 ? children : [node],
+    cursor: cursor + codepoints.length,
+  };
+}

package/src/io/normalize/README.md

@@ -0,0 +1,3 @@
+# IO Normalize
+
+Normalization from OOXML structures into canonical state belongs here.