@beyondwork/docx-react-component 1.0.27 → 1.0.29

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

@@ -1,356 +0,0 @@
-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/normalize/README.md

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