@beyondwork/docx-react-component 1.0.28 → 1.0.30

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

@@ -16,6 +16,11 @@ export interface SerializedRuntimeRevisionsResult {
   skippedRevisionIds: string[];
 }
 
+const STORY_WRAPPER_PREFIX =
+  `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>` +
+  `<w:document xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"><w:body>`;
+const STORY_WRAPPER_SUFFIX = `</w:body></w:document>`;
+
 export function serializeRuntimeRevisionsIntoDocumentXml(
   documentXml: string,
   revisions: readonly RevisionRecord[],
@@ -34,6 +39,17 @@ export function serializeRuntimeRevisionsIntoDocumentXml(
       continue;
     }
 
+    if (revision.kind === "property-change") {
+      const propertyChangeReplacement = createPropertyChangeReplacement(documentXml, boundaries, revision);
+      if (!propertyChangeReplacement) {
+        skippedRevisionIds.push(revision.revisionId);
+        continue;
+      }
+      replacements.push(propertyChangeReplacement);
+      serializedRevisionIds.push(revision.revisionId);
+      continue;
+    }
+
     if (revision.kind !== "insertion" && revision.kind !== "deletion") {
       continue;
     }
@@ -89,6 +105,136 @@ export function serializeRuntimeRevisionsIntoDocumentXml(
   };
 }
 
+function createPropertyChangeReplacement(
+  documentXml: string,
+  boundaries: readonly RevisionParagraphBoundary[],
+  revision: RevisionRecord,
+): XmlReplacement | undefined {
+  const propertyChange = revision.metadata.propertyChangeData;
+  if (!propertyChange) {
+    return undefined;
+  }
+  if (propertyChange.xmlTag === "pPrChange") {
+    return createParagraphPropertyChangeReplacement(documentXml, boundaries, revision, propertyChange.beforeXml);
+  }
+  if (propertyChange.xmlTag === "rPrChange") {
+    return createRunPropertyChangeReplacement(documentXml, boundaries, revision, propertyChange.beforeXml);
+  }
+  return undefined;
+}
+
+function createParagraphPropertyChangeReplacement(
+  documentXml: string,
+  boundaries: readonly RevisionParagraphBoundary[],
+  revision: RevisionRecord,
+  beforeXml: string,
+): XmlReplacement | undefined {
+  if (revision.anchor.kind !== "range") {
+    return undefined;
+  }
+  const paragraphBoundary = findParagraphBoundaryForRange(
+    boundaries,
+    revision.anchor.range.from,
+    revision.anchor.range.to,
+  );
+  if (!paragraphBoundary) {
+    return undefined;
+  }
+  const insertionIndex = findClosingTagInsertionIndex(
+    documentXml,
+    paragraphBoundary.paragraphPropertiesStart,
+    paragraphBoundary.paragraphPropertiesEnd,
+    "w:pPr",
+  );
+  if (insertionIndex === undefined) {
+    return undefined;
+  }
+  return {
+    start: insertionIndex,
+    end: insertionIndex,
+    replacement: `<w:pPrChange${serializeRevisionAttributes(revision)}>${beforeXml}</w:pPrChange>`,
+  };
+}
+
+function createRunPropertyChangeReplacement(
+  documentXml: string,
+  boundaries: readonly RevisionParagraphBoundary[],
+  revision: RevisionRecord,
+  beforeXml: string,
+): XmlReplacement | undefined {
+  if (revision.anchor.kind !== "range") {
+    return 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 runXml = documentXml.slice(startIndex, endIndex);
+  if (!/^<w:r[\s>][\s\S]*<\/w:r>$/u.test(runXml)) {
+    return undefined;
+  }
+  const changeXml = `<w:rPrChange${serializeRevisionAttributes(revision)}>${beforeXml}</w:rPrChange>`;
+  let replacement: string;
+  if (/<w:rPr[\s>][\s\S]*<\/w:rPr>/u.test(runXml)) {
+    replacement = runXml.replace(/<\/w:rPr>/u, `${changeXml}</w:rPr>`);
+  } else {
+    replacement = runXml.replace(/^(<w:r[\s>][^>]*>)/u, `$1<w:rPr>${changeXml}</w:rPr>`);
+  }
+  if (replacement === runXml) {
+    return undefined;
+  }
+  return {
+    start: startIndex,
+    end: endIndex,
+    replacement,
+  };
+}
+
+export function serializeRuntimeRevisionsIntoStoryXml(
+  storyXml: string,
+  revisions: readonly RevisionRecord[],
+): SerializedRuntimeRevisionsResult {
+  if (revisions.length === 0) {
+    return {
+      documentXml: storyXml,
+      serializedRevisionIds: [],
+      skippedRevisionIds: [],
+    };
+  }
+
+  const xmlDeclMatch = storyXml.match(/^<\?xml[\s\S]*?\?>\s*/u);
+  const xmlDecl = xmlDeclMatch?.[0] ?? "";
+  const withoutDecl = xmlDeclMatch ? storyXml.slice(xmlDecl.length) : storyXml;
+  const rootMatch = withoutDecl.match(/^<([A-Za-z0-9:._-]+)([^>]*)>([\s\S]*)<\/\1>\s*$/u);
+  if (!rootMatch) {
+    return serializeRuntimeRevisionsIntoDocumentXml(storyXml, revisions);
+  }
+
+  const [, tagName, attrs = "", innerXml = ""] = rootMatch;
+  const wrapped = `${STORY_WRAPPER_PREFIX}${innerXml}${STORY_WRAPPER_SUFFIX}`;
+  const serialized = serializeRuntimeRevisionsIntoDocumentXml(wrapped, revisions);
+  return {
+    documentXml:
+      `${xmlDecl}<${tagName}${attrs}>` +
+      serialized.documentXml.slice(
+        STORY_WRAPPER_PREFIX.length,
+        serialized.documentXml.length - STORY_WRAPPER_SUFFIX.length,
+      ) +
+      `</${tagName}>`,
+    serializedRevisionIds: serialized.serializedRevisionIds,
+    skippedRevisionIds: serialized.skippedRevisionIds,
+  };
+}
+
 function createRangeRevisionReplacement(
   documentXml: string,
   boundaries: readonly RevisionParagraphBoundary[],
@@ -110,14 +256,18 @@ function createRangeRevisionReplacement(
   }
 
   const xml = documentXml.slice(startIndex, endIndex);
+  const { leadingMarkers, coreXml, trailingMarkers } = peelZeroWidthEdgeMarkers(xml);
+  if (coreXml.length === 0) {
+    return undefined;
+  }
   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>`,
+        ? `${leadingMarkers}<w:ins${attributes}>${coreXml}</w:ins>${trailingMarkers}`
+        : `${leadingMarkers}<w:del${attributes}>${convertRunsToDeletedContent(coreXml)}</w:del>${trailingMarkers}`,
   };
 }
 
@@ -214,6 +364,50 @@ function serializeRevisionAttributes(revision: RevisionRecord): string {
     .join("");
 }
 
+function peelZeroWidthEdgeMarkers(xml: string): {
+  leadingMarkers: string;
+  coreXml: string;
+  trailingMarkers: string;
+} {
+  const markerPattern =
+    /^(?:\s|<(?:\w+:)?(?:bookmarkStart|bookmarkEnd|permStart|permEnd|commentRangeStart|commentRangeEnd|proofErr|lastRenderedPageBreak)\b[^>]*\/>)+$/u;
+  let coreXml = xml;
+  let leadingMarkers = "";
+  let trailingMarkers = "";
+
+  while (true) {
+    const match = coreXml.match(/^\s*(<(?:\w+:)?(?:bookmarkStart|bookmarkEnd|permStart|permEnd|commentRangeStart|commentRangeEnd|proofErr|lastRenderedPageBreak)\b[^>]*\/>)/u);
+    if (!match) {
+      break;
+    }
+    leadingMarkers += match[0];
+    coreXml = coreXml.slice(match[0].length);
+  }
+
+  while (true) {
+    const match = coreXml.match(/(<(?:\w+:)?(?:bookmarkStart|bookmarkEnd|permStart|permEnd|commentRangeStart|commentRangeEnd|proofErr|lastRenderedPageBreak)\b[^>]*\/>)\s*$/u);
+    if (!match) {
+      break;
+    }
+    trailingMarkers = match[0] + trailingMarkers;
+    coreXml = coreXml.slice(0, coreXml.length - match[0].length);
+  }
+
+  if (markerPattern.test(coreXml)) {
+    return {
+      leadingMarkers: xml,
+      coreXml: "",
+      trailingMarkers: "",
+    };
+  }
+
+  return {
+    leadingMarkers,
+    coreXml,
+    trailingMarkers,
+  };
+}
+
 function findClosingTagInsertionIndex(
   documentXml: string,
   start: number | undefined,

package/src/io/export/split-story-blocks-for-runtime-revisions.ts

@@ -0,0 +1,252 @@
+import type {
+  BlockNode,
+  HyperlinkNode,
+  InlineNode,
+  ParagraphNode,
+  TableCellNode,
+  TableNode,
+} from "../../model/canonical-document.ts";
+import type { RevisionRecord } from "../../review/store/revision-types.ts";
+
+interface CursorState {
+  value: number;
+}
+
+type InsertionRangeRevision = RevisionRecord & {
+  kind: "insertion";
+  anchor: Extract<RevisionRecord["anchor"], { kind: "range" }>;
+};
+
+function isInsertionRangeRevision(revision: RevisionRecord): revision is InsertionRangeRevision {
+  return (
+    revision.status === "active" &&
+    revision.kind === "insertion" &&
+    revision.anchor.kind === "range"
+  );
+}
+
+export function splitStoryBlocksForRuntimeRevisions(
+  blocks: readonly BlockNode[],
+  revisions: readonly RevisionRecord[],
+): BlockNode[] {
+  const insertionRevisions = revisions.filter(isInsertionRangeRevision);
+  if (insertionRevisions.length === 0) {
+    return blocks.map(cloneBlock);
+  }
+
+  const cursor: CursorState = { value: 0 };
+  return processBlockSequence(blocks, insertionRevisions, cursor);
+}
+
+function processBlockSequence(
+  blocks: readonly BlockNode[],
+  revisions: readonly InsertionRangeRevision[],
+  cursor: CursorState,
+): BlockNode[] {
+  const nextBlocks: BlockNode[] = [];
+
+  for (let index = 0; index < blocks.length; index += 1) {
+    const block = blocks[index]!;
+    switch (block.type) {
+      case "paragraph":
+        nextBlocks.push(processParagraph(block, revisions, cursor));
+        if (index < blocks.length - 1) {
+          cursor.value += 1;
+        }
+        break;
+      case "table":
+        nextBlocks.push(processTable(block, revisions, cursor));
+        cursor.value += 1;
+        break;
+      case "sdt":
+      case "custom_xml":
+        nextBlocks.push({
+          ...block,
+          children: processBlockSequence(block.children, revisions, cursor),
+        });
+        break;
+      default:
+        nextBlocks.push(cloneBlock(block));
+        cursor.value += 1;
+    }
+  }
+
+  return nextBlocks;
+}
+
+function processTable(
+  table: TableNode,
+  revisions: readonly InsertionRangeRevision[],
+  cursor: CursorState,
+): TableNode {
+  return {
+    ...table,
+    rows: table.rows.map((row) => ({
+      ...row,
+      cells: row.cells.map((cell) => processTableCell(cell, revisions, cursor)),
+    })),
+  };
+}
+
+function processTableCell(
+  cell: TableCellNode,
+  revisions: readonly InsertionRangeRevision[],
+  cursor: CursorState,
+): TableCellNode {
+  return {
+    ...cell,
+    children: processBlockSequence(cell.children, revisions, cursor),
+  };
+}
+
+function processParagraph(
+  paragraph: ParagraphNode,
+  revisions: readonly InsertionRangeRevision[],
+  cursor: CursorState,
+): ParagraphNode {
+  return {
+    ...paragraph,
+    children: processInlineSequence(
+      paragraph.children as readonly InlineNode[],
+      revisions,
+      cursor,
+    ) as ParagraphNode["children"],
+  };
+}
+
+function processInlineSequence(
+  children: readonly InlineNode[],
+  revisions: readonly InsertionRangeRevision[],
+  cursor: CursorState,
+): InlineNode[] {
+  const nextChildren: InlineNode[] = [];
+
+  for (const child of children) {
+    switch (child.type) {
+      case "text": {
+        const start = cursor.value;
+        const end = start + Array.from(child.text).length;
+        const splitPoints = collectSplitPoints(start, end, revisions);
+        if (splitPoints.length === 0) {
+          nextChildren.push({ ...child });
+        } else {
+          const chars = Array.from(child.text);
+          let previous = 0;
+          for (const point of splitPoints) {
+            const localEnd = point - start;
+            if (localEnd > previous) {
+              nextChildren.push({
+                ...child,
+                text: chars.slice(previous, localEnd).join(""),
+              });
+            }
+            previous = localEnd;
+          }
+          if (previous < chars.length) {
+            nextChildren.push({
+              ...child,
+              text: chars.slice(previous).join(""),
+            });
+          }
+        }
+        cursor.value = end;
+        break;
+      }
+      case "hyperlink":
+        nextChildren.push(processHyperlink(child, revisions, cursor));
+        break;
+      case "field":
+        nextChildren.push({
+          ...child,
+          children: processInlineSequence(child.children, revisions, cursor),
+        });
+        break;
+      case "tab":
+      case "hard_break":
+      case "footnote_ref":
+      case "bookmark_start":
+      case "bookmark_end":
+        nextChildren.push({ ...child });
+        cursor.value += inlineLength(child);
+        break;
+      default:
+        nextChildren.push({ ...child });
+        cursor.value += inlineLength(child);
+    }
+  }
+
+  return nextChildren;
+}
+
+function processHyperlink(
+  node: HyperlinkNode,
+  revisions: readonly InsertionRangeRevision[],
+  cursor: CursorState,
+): HyperlinkNode {
+  return {
+    ...node,
+    children: processInlineSequence(
+      node.children as readonly InlineNode[],
+      revisions,
+      cursor,
+    ) as HyperlinkNode["children"],
+  };
+}
+
+function collectSplitPoints(
+  start: number,
+  end: number,
+  revisions: readonly InsertionRangeRevision[],
+): number[] {
+  const points = new Set<number>();
+  for (const revision of revisions) {
+    const from = revision.anchor.range.from;
+    const to = revision.anchor.range.to;
+    if (from > start && from < end) {
+      points.add(from);
+    }
+    if (to > start && to < end) {
+      points.add(to);
+    }
+  }
+  return [...points].sort((left, right) => left - right);
+}
+
+function inlineLength(node: InlineNode): number {
+  switch (node.type) {
+    case "text":
+      return Array.from(node.text).length;
+    case "tab":
+    case "hard_break":
+    case "footnote_ref":
+      return 1;
+    case "hyperlink":
+    case "field":
+      return node.children.reduce((total, child) => total + inlineLength(child), 0);
+    default:
+      return 0;
+  }
+}
+
+function cloneBlock(block: BlockNode): BlockNode {
+  switch (block.type) {
+    case "paragraph":
+      return { ...block, children: block.children.map((child) => ({ ...child })) };
+    case "table":
+      return {
+        ...block,
+        rows: block.rows.map((row) => ({
+          ...row,
+          cells: row.cells.map((cell) => ({
+            ...cell,
+            children: cell.children.map(cloneBlock),
+          })),
+        })),
+      };
+    case "sdt":
+    case "custom_xml":
+      return { ...block, children: block.children.map(cloneBlock) };
+    default:
+      return { ...block };
+  }
+}