@beyondwork/docx-react-component 1.0.29 → 1.0.31

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

@@ -0,0 +1,356 @@
+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;
+  }
+
+  return {
+    type: "doc",
+    children: splitBlockNodes(content.children, splitPositions, 0, true).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 += measureInlineNodeForReviewBoundaries(child);
+  }
+
+  return {
+    paragraph: {
+      ...paragraph,
+      children,
+    },
+    cursor: nextCursor,
+  };
+}
+
+function splitBlockNodes(
+  blocks: readonly DocumentRootNode["children"][number][],
+  splitPositions: ReadonlySet<number>,
+  cursor: number,
+  useSurfaceParagraphSeparators: boolean,
+): {
+  children: DocumentRootNode["children"];
+  cursor: number;
+} {
+  const children: DocumentRootNode["children"] = [];
+  let nextCursor = cursor;
+  for (const [index, block] of blocks.entries()) {
+    if (block.type === "paragraph") {
+      if (useSurfaceParagraphSeparators && index > 0) {
+        nextCursor += 1;
+      }
+      const next = splitParagraph(block, splitPositions, nextCursor);
+      children.push(next.paragraph);
+      nextCursor = next.cursor;
+      continue;
+    }
+
+    if (block.type === "table") {
+      const next = splitTableAtReviewBoundaries(block, splitPositions, nextCursor);
+      children.push(next.table);
+      nextCursor = next.cursor;
+      continue;
+    }
+
+    if (block.type === "sdt") {
+      const next = splitBlockNodes(block.children, splitPositions, nextCursor, false);
+      children.push({
+        ...block,
+        children: next.children,
+      });
+      nextCursor = next.cursor;
+      continue;
+    }
+
+    if (block.type === "custom_xml") {
+      children.push(block);
+      nextCursor += 1;
+      continue;
+    }
+
+    children.push(block);
+    nextCursor += 1;
+  }
+
+  return {
+    children,
+    cursor: nextCursor,
+  };
+}
+
+function splitTableAtReviewBoundaries(
+  table: Extract<DocumentRootNode["children"][number], { type: "table" }>,
+  splitPositions: ReadonlySet<number>,
+  cursor: number,
+): {
+  table: Extract<DocumentRootNode["children"][number], { type: "table" }>;
+  cursor: number;
+} {
+  let nextCursor = cursor;
+  const rows = table.rows.map((row) => ({
+    ...row,
+    cells: row.cells.map((cell) => {
+      const next = splitBlockNodes(cell.children, splitPositions, nextCursor, false);
+      nextCursor = next.cursor;
+      return {
+        ...cell,
+        children: next.children,
+      };
+    }),
+  }));
+
+  return {
+    table: {
+      ...table,
+      rows,
+    },
+    cursor: nextCursor,
+  };
+}
+
+function advanceCursorThroughTable(
+  table: Extract<DocumentRootNode["children"][number], { type: "table" }>,
+  cursor: number,
+): number {
+  let nextCursor = cursor;
+  for (const row of table.rows) {
+    for (const cell of row.cells) {
+      nextCursor = measureBlockNodesForReviewBoundaries(cell.children, nextCursor, false);
+    }
+  }
+  return nextCursor;
+}
+
+function measureBlockNodesForReviewBoundaries(
+  blocks: readonly DocumentRootNode["children"][number][],
+  cursor: number,
+  useSurfaceParagraphSeparators: boolean,
+): number {
+  let nextCursor = cursor;
+  for (const [index, block] of blocks.entries()) {
+    if (block.type === "paragraph") {
+      if (useSurfaceParagraphSeparators && index > 0) {
+        nextCursor += 1;
+      }
+      nextCursor += block.children.reduce(
+        (size, child) => size + measureInlineNodeForReviewBoundaries(child),
+        0,
+      );
+      continue;
+    }
+
+    if (block.type === "table") {
+      nextCursor = advanceCursorThroughTable(block, nextCursor);
+      continue;
+    }
+
+    if (block.type === "sdt") {
+      nextCursor = measureBlockNodesForReviewBoundaries(
+        block.children,
+        nextCursor,
+        false,
+      );
+      continue;
+    }
+
+    if (block.type === "custom_xml") {
+      nextCursor += 1;
+      continue;
+    }
+
+    nextCursor += 1;
+  }
+
+  return 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 += measureInlineNodeForReviewBoundaries(child);
+    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,
+  };
+}
+
+function measureInlineNodeForReviewBoundaries(node: InlineNode): number {
+  switch (node.type) {
+    case "text":
+      return Array.from(node.text).length;
+    case "bookmark_start":
+    case "bookmark_end":
+      return 0;
+    case "hyperlink":
+      return node.children.reduce(
+        (size, child) => size + measureInlineNodeForReviewBoundaries(child),
+        0,
+      );
+    case "field": {
+      const childWidth = node.children.reduce(
+        (size, child) => size + measureInlineNodeForReviewBoundaries(child),
+        0,
+      );
+      return childWidth > 0 ? childWidth : 1;
+    }
+    case "tab":
+    case "hard_break":
+    case "column_break":
+    case "footnote_ref":
+    case "image":
+    case "opaque_inline":
+    case "chart_preview":
+    case "smartart_preview":
+    case "shape":
+    case "wordart":
+    case "vml_shape":
+    case "symbol":
+      return 1;
+    default:
+      return 1;
+  }
+}

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 };
+  }
+}