@beyondwork/docx-react-component 1.0.0 → 1.0.1

package/src/io/ooxml/parse-comments.ts

@@ -1,779 +0,0 @@
-import type { CommentThread } from "../../review/store/comment-store.ts";
-import { createImportedCommentThread } from "../../review/store/comment-thread.ts";
-
-interface XmlElementNode {
-  type: "element";
-  name: string;
-  attributes: Record<string, string>;
-  children: XmlNode[];
-  start: number;
-  end: number;
-}
-
-interface XmlTextNode {
-  type: "text";
-  text: string;
-  start: number;
-  end: number;
-}
-
-type XmlNode = XmlElementNode | XmlTextNode;
-
-export interface ParsedCommentsInput {
-  commentsXml: string;
-  commentsExtendedXml?: string;
-  commentsIdsXml?: string;
-  peopleXml?: string;
-}
-
-export interface ImportedCommentDefinition {
-  commentId: string;
-  authorId?: string;
-  createdAt?: string;
-  body: string;
-  rawXml: string;
-  order: number;
-  initials?: string;
-  paraId?: string;
-  parentParaId?: string;
-  durableId?: string;
-  isDone?: boolean;
-}
-
-interface CommentAnchorBounds {
-  start?: number;
-  end?: number;
-  startParagraphIndex?: number;
-  endParagraphIndex?: number;
-  referenceAt?: number;
-  referenceParagraphIndex?: number;
-}
-
-interface CommentExtensionRecord {
-  paraId: string;
-  parentParaId?: string;
-  isDone?: boolean;
-}
-
-export interface CommentImportDiagnostic {
-  commentId: string;
-  code:
-    | "missing_comment_definition"
-    | "missing_anchor_reference"
-    | "multi_paragraph_anchor_preserve_only"
-    | "opaque_anchor_preserve_only"
-    | "preserve_only_revision_overlap";
-  message: string;
-  featureClass: "preserve-only";
-}
-
-export interface ParsedCommentsResult {
-  threads: CommentThread[];
-  diagnostics: CommentImportDiagnostic[];
-  definitions: ImportedCommentDefinition[];
-  sourceRootTag?: string;
-  sourceExtendedRootTag?: string;
-  sourceIdsRootTag?: string;
-  sourcePeopleRootTag?: string;
-  peopleAuthors: string[];
-}
-
-export function parseCommentsFromOoxml(
-  documentXml: string,
-  input: string | ParsedCommentsInput,
-): ParsedCommentsResult {
-  const parts = normalizeInput(input);
-  const commentExtensions = parseCommentExtensions(parts.commentsExtendedXml);
-  const durableIds = parseCommentDurableIds(parts.commentsIdsXml);
-  const peopleAuthors = parsePeopleAuthors(parts.peopleXml);
-  const definitions = parseCommentDefinitions(parts.commentsXml, commentExtensions, durableIds);
-  const definitionsById = new Map(definitions.map((definition) => [definition.commentId, definition]));
-  const definitionsByParaId = new Map(
-    definitions
-      .filter((definition) => typeof definition.paraId === "string")
-      .map((definition) => [definition.paraId!, definition]),
-  );
-  const anchors = parseCommentAnchors(documentXml);
-  const diagnostics: CommentImportDiagnostic[] = [];
-  const threadDefinitions = groupThreadDefinitions(definitions, definitionsByParaId);
-  const threads: CommentThread[] = [];
-
-  for (const [rootCommentId, groupedDefinitions] of threadDefinitions) {
-    const rootDefinition = groupedDefinitions[0];
-    if (!rootDefinition) {
-      continue;
-    }
-
-    const anchor = anchors.get(rootCommentId);
-    const start = anchor?.start ?? anchor?.referenceAt;
-    const end = anchor?.end ?? anchor?.referenceAt;
-    const startParagraphIndex = anchor?.startParagraphIndex ?? anchor?.referenceParagraphIndex;
-    const endParagraphIndex = anchor?.endParagraphIndex ?? anchor?.referenceParagraphIndex;
-    const entries = groupedDefinitions.map((definition, index) => ({
-      entryId: `${rootCommentId}-entry-${index + 1}`,
-      authorId: definition.authorId ?? "unknown",
-      body: definition.body,
-      createdAt: definition.createdAt ?? "1970-01-01T00:00:00.000Z",
-      metadata: {
-        ooxmlCommentId: definition.commentId,
-        paraId: definition.paraId,
-        parentParaId: definition.parentParaId,
-        durableId: definition.durableId,
-        initials: definition.initials,
-      },
-    }));
-    const createdBy = rootDefinition.authorId ?? entries[0]?.authorId ?? "unknown";
-    const createdAt = rootDefinition.createdAt ?? entries[0]?.createdAt ?? "1970-01-01T00:00:00.000Z";
-    const resolution =
-      rootDefinition.isDone
-        ? {
-            resolvedAt: entries.at(-1)?.createdAt ?? createdAt,
-            resolvedBy: entries.at(-1)?.authorId ?? createdBy,
-          }
-        : undefined;
-    const detachedRange = toDetachedRange(anchor);
-
-    if (
-      start === undefined ||
-      end === undefined ||
-      startParagraphIndex === undefined ||
-      endParagraphIndex === undefined
-    ) {
-      diagnostics.push({
-        commentId: rootCommentId,
-        code: "missing_anchor_reference",
-        message: "Comment anchor markers are incomplete and remain preserve-only.",
-        featureClass: "preserve-only",
-      });
-      threads.push(
-        createImportedCommentThread({
-          commentId: rootCommentId,
-          body: rootDefinition.body,
-          createdBy,
-          createdAt,
-          range: detachedRange,
-          entries,
-          status: "detached",
-          resolution,
-          metadata: {
-            source: "import",
-            rootOoxmlCommentId: rootDefinition.commentId,
-            rootParaId: rootDefinition.paraId,
-          },
-        }),
-      );
-      continue;
-    }
-
-    if (startParagraphIndex !== endParagraphIndex) {
-      diagnostics.push({
-        commentId: rootCommentId,
-        code: "multi_paragraph_anchor_preserve_only",
-        message:
-          "Comment anchor spans multiple paragraphs and remains preserve-only for Wave 5.",
-        featureClass: "preserve-only",
-      });
-      threads.push(
-        createImportedCommentThread({
-          commentId: rootCommentId,
-          body: rootDefinition.body,
-          createdBy,
-          createdAt,
-          range: detachedRange,
-          entries,
-          status: "detached",
-          resolution,
-          metadata: {
-            source: "import",
-            rootOoxmlCommentId: rootDefinition.commentId,
-            rootParaId: rootDefinition.paraId,
-          },
-        }),
-      );
-      continue;
-    }
-
-    threads.push(
-      createImportedCommentThread({
-        commentId: rootCommentId,
-        body: rootDefinition.body,
-        createdBy,
-        createdAt,
-        range: {
-          from: Math.min(start, end),
-          to: Math.max(start, end),
-        },
-        entries,
-        status: resolution ? "resolved" : "open",
-        resolution,
-        metadata: {
-          source: "import",
-          rootOoxmlCommentId: rootDefinition.commentId,
-          rootParaId: rootDefinition.paraId,
-        },
-      }),
-    );
-  }
-
-  for (const commentId of anchors.keys()) {
-    if (definitionsById.has(commentId)) {
-      continue;
-    }
-
-    diagnostics.push({
-      commentId,
-      code: "missing_comment_definition",
-      message: "Document anchor markers reference a comment id missing from comments.xml.",
-      featureClass: "preserve-only",
-    });
-  }
-
-  threads.sort(compareThreadsByAnchor);
-
-  return {
-    threads,
-    diagnostics,
-    definitions,
-    sourceRootTag: extractRootTag(parts.commentsXml, "comments"),
-    sourceExtendedRootTag: extractRootTag(parts.commentsExtendedXml, "commentsEx"),
-    sourceIdsRootTag: extractRootTag(parts.commentsIdsXml, "commentsIds"),
-    sourcePeopleRootTag: extractRootTag(parts.peopleXml, "people"),
-    peopleAuthors,
-  };
-}
-
-function normalizeInput(input: string | ParsedCommentsInput): ParsedCommentsInput {
-  return typeof input === "string"
-    ? {
-        commentsXml: input,
-      }
-    : input;
-}
-
-function groupThreadDefinitions(
-  definitions: ImportedCommentDefinition[],
-  definitionsByParaId: Map<string, ImportedCommentDefinition>,
-): Map<string, ImportedCommentDefinition[]> {
-  const grouped = new Map<string, ImportedCommentDefinition[]>();
-
-  for (const definition of definitions) {
-    const rootCommentId = resolveRootCommentId(definition, definitionsByParaId);
-    const group = grouped.get(rootCommentId);
-    if (group) {
-      group.push(definition);
-    } else {
-      grouped.set(rootCommentId, [definition]);
-    }
-  }
-
-  for (const group of grouped.values()) {
-    group.sort((left, right) => left.order - right.order);
-    const rootIndex = group.findIndex((definition) => !definition.parentParaId);
-    if (rootIndex > 0) {
-      const [rootDefinition] = group.splice(rootIndex, 1);
-      if (rootDefinition) {
-        group.unshift(rootDefinition);
-      }
-    }
-  }
-
-  return new Map(
-    [...grouped.entries()].sort(([leftId], [rightId]) => leftId.localeCompare(rightId)),
-  );
-}
-
-function resolveRootCommentId(
-  definition: ImportedCommentDefinition,
-  definitionsByParaId: Map<string, ImportedCommentDefinition>,
-): string {
-  const visited = new Set<string>();
-  let current: ImportedCommentDefinition | undefined = definition;
-
-  while (current?.parentParaId) {
-    if (visited.has(current.parentParaId)) {
-      break;
-    }
-    visited.add(current.parentParaId);
-    const parent = definitionsByParaId.get(current.parentParaId);
-    if (!parent) {
-      break;
-    }
-    current = parent;
-  }
-
-  return current?.commentId ?? definition.commentId;
-}
-
-function parseCommentDefinitions(
-  commentsXml: string,
-  extensions: Map<string, CommentExtensionRecord>,
-  durableIds: Map<string, string>,
-): ImportedCommentDefinition[] {
-  if (commentsXml.trim().length === 0) {
-    return [];
-  }
-
-  const root = parseXml(commentsXml);
-  const commentsElement = findChildElement(root, "comments");
-  const definitions: ImportedCommentDefinition[] = [];
-  let order = 0;
-
-  for (const child of commentsElement.children) {
-    if (child.type !== "element" || localName(child.name) !== "comment") {
-      continue;
-    }
-
-    const commentId = child.attributes["w:id"] ?? child.attributes.id;
-    if (!commentId) {
-      continue;
-    }
-
-    const authorId = child.attributes["w:author"] ?? child.attributes.author;
-    const createdAt = normalizeImportedTimestamp(
-      child.attributes["w:date"] ?? child.attributes.date,
-    );
-    const initials = child.attributes["w:initials"] ?? child.attributes.initials;
-    const paragraphNodes = child.children.filter(
-      (node): node is XmlElementNode => node.type === "element" && localName(node.name) === "p",
-    );
-    const body = paragraphNodes
-      .map(extractParagraphText)
-      .join("\n");
-    const paraId = paragraphNodes[0]?.attributes["w14:paraId"] ?? paragraphNodes[0]?.attributes.paraId;
-    const extension = paraId ? extensions.get(paraId) : undefined;
-
-    definitions.push({
-      commentId,
-      authorId,
-      createdAt,
-      body,
-      rawXml: commentsXml.slice(child.start, child.end),
-      order,
-      initials,
-      paraId,
-      parentParaId: extension?.parentParaId,
-      durableId: paraId ? durableIds.get(paraId) : undefined,
-      isDone: extension?.isDone,
-    });
-    order += 1;
-  }
-
-  return definitions;
-}
-
-function normalizeImportedTimestamp(value: string | undefined): string | undefined {
-  if (!value) {
-    return undefined;
-  }
-
-  const parsed = new Date(value);
-  if (Number.isNaN(parsed.valueOf())) {
-    return undefined;
-  }
-
-  return parsed.toISOString();
-}
-
-function parseCommentExtensions(xml: string | undefined): Map<string, CommentExtensionRecord> {
-  if (!xml || xml.trim().length === 0) {
-    return new Map();
-  }
-
-  const root = parseXml(xml);
-  const commentsElement = findChildElement(root, "commentsEx");
-  const extensions = new Map<string, CommentExtensionRecord>();
-
-  for (const child of commentsElement.children) {
-    if (child.type !== "element" || localName(child.name) !== "commentEx") {
-      continue;
-    }
-
-    const paraId = child.attributes["w15:paraId"] ?? child.attributes.paraId;
-    if (!paraId) {
-      continue;
-    }
-
-    const parentParaId = child.attributes["w15:paraIdParent"] ?? child.attributes.paraIdParent;
-    const doneValue = child.attributes["w15:done"] ?? child.attributes.done;
-    extensions.set(paraId, {
-      paraId,
-      parentParaId,
-      isDone:
-        typeof doneValue === "string"
-          ? doneValue.toLowerCase() === "true" || doneValue === "1"
-          : undefined,
-    });
-  }
-
-  return extensions;
-}
-
-function parseCommentDurableIds(xml: string | undefined): Map<string, string> {
-  if (!xml || xml.trim().length === 0) {
-    return new Map();
-  }
-
-  const root = parseXml(xml);
-  const commentsIdsElement = findChildElement(root, "commentsIds");
-  const durableIds = new Map<string, string>();
-
-  for (const child of commentsIdsElement.children) {
-    if (child.type !== "element" || localName(child.name) !== "commentId") {
-      continue;
-    }
-
-    const paraId = child.attributes["w16cid:paraId"] ?? child.attributes.paraId;
-    const durableId = child.attributes["w16cid:durableId"] ?? child.attributes.durableId;
-    if (paraId && durableId) {
-      durableIds.set(paraId, durableId);
-    }
-  }
-
-  return durableIds;
-}
-
-function parsePeopleAuthors(xml: string | undefined): string[] {
-  if (!xml || xml.trim().length === 0) {
-    return [];
-  }
-
-  const root = parseXml(xml);
-  const peopleElement = findChildElement(root, "people");
-  const authors = new Set<string>();
-
-  for (const child of peopleElement.children) {
-    if (child.type !== "element" || localName(child.name) !== "person") {
-      continue;
-    }
-
-    const author = child.attributes["w15:author"] ?? child.attributes.author;
-    if (author) {
-      authors.add(author);
-    }
-  }
-
-  return [...authors].sort((left, right) => left.localeCompare(right));
-}
-
-function extractRootTag(xml: string | undefined, localTagName: string): string | undefined {
-  if (!xml) {
-    return undefined;
-  }
-
-  const pattern = new RegExp(`<[^>]*:?${localTagName}\\b[^>]*>`, "u");
-  return pattern.exec(xml)?.[0];
-}
-
-function parseCommentAnchors(documentXml: string): Map<string, CommentAnchorBounds> {
-  const root = parseXml(documentXml);
-  const documentElement = findChildElement(root, "document");
-  const bodyElement = findChildElement(documentElement, "body");
-  const anchors = new Map<string, CommentAnchorBounds>();
-  let cursor = 0;
-  let paragraphIndex = -1;
-  let previousWasParagraph = false;
-
-  for (const child of bodyElement.children) {
-    if (child.type !== "element") {
-      continue;
-    }
-
-    if (localName(child.name) !== "p") {
-      cursor += 1;
-      previousWasParagraph = false;
-      continue;
-    }
-
-    if (previousWasParagraph) {
-      cursor += 1;
-    }
-    paragraphIndex += 1;
-    walkParagraph(child, paragraphIndex, anchors, () => cursor, (next) => {
-      cursor = next;
-    });
-    previousWasParagraph = true;
-  }
-
-  return anchors;
-}
-
-function walkParagraph(
-  paragraph: XmlElementNode,
-  paragraphIndex: number,
-  anchors: Map<string, CommentAnchorBounds>,
-  getCursor: () => number,
-  setCursor: (next: number) => void,
-): void {
-  for (const child of paragraph.children) {
-    walkInlineNode(child, paragraphIndex, anchors, getCursor, setCursor);
-  }
-}
-
-function walkInlineNode(
-  node: XmlNode,
-  paragraphIndex: number,
-  anchors: Map<string, CommentAnchorBounds>,
-  getCursor: () => number,
-  setCursor: (next: number) => void,
-): void {
-  if (node.type !== "element") {
-    return;
-  }
-
-  switch (localName(node.name)) {
-    case "commentRangeStart": {
-      const commentId = node.attributes["w:id"] ?? node.attributes.id;
-      if (commentId) {
-        const bounds = ensureCommentAnchor(anchors, commentId);
-        bounds.start = getCursor();
-        bounds.startParagraphIndex = paragraphIndex;
-      }
-      return;
-    }
-    case "commentRangeEnd": {
-      const commentId = node.attributes["w:id"] ?? node.attributes.id;
-      if (commentId) {
-        const bounds = ensureCommentAnchor(anchors, commentId);
-        bounds.end = getCursor();
-        bounds.endParagraphIndex = paragraphIndex;
-      }
-      return;
-    }
-    case "commentReference": {
-      const commentId = node.attributes["w:id"] ?? node.attributes.id;
-      if (commentId) {
-        const bounds = ensureCommentAnchor(anchors, commentId);
-        bounds.referenceAt = getCursor();
-        bounds.referenceParagraphIndex = paragraphIndex;
-      }
-      return;
-    }
-    case "t": {
-      const text = node.children
-        .filter((child): child is XmlTextNode => child.type === "text")
-        .map((child) => child.text)
-        .join("");
-      setCursor(getCursor() + text.length);
-      return;
-    }
-    case "tab":
-    case "br":
-      setCursor(getCursor() + 1);
-      return;
-    default:
-      for (const child of node.children) {
-        walkInlineNode(child, paragraphIndex, anchors, getCursor, setCursor);
-      }
-  }
-}
-
-function ensureCommentAnchor(
-  anchors: Map<string, CommentAnchorBounds>,
-  commentId: string,
-): CommentAnchorBounds {
-  const existing = anchors.get(commentId);
-  if (existing) {
-    return existing;
-  }
-
-  const next: CommentAnchorBounds = {};
-  anchors.set(commentId, next);
-  return next;
-}
-
-function extractParagraphText(paragraph: XmlElementNode): string {
-  let text = "";
-
-  for (const child of paragraph.children) {
-    text += extractNodeText(child);
-  }
-
-  return text;
-}
-
-function extractNodeText(node: XmlNode): string {
-  if (node.type === "text") {
-    return node.text;
-  }
-
-  switch (localName(node.name)) {
-    case "t":
-      return node.children.map(extractNodeText).join("");
-    case "tab":
-      return "\t";
-    case "br":
-      return "\n";
-    default:
-      return node.children.map(extractNodeText).join("");
-  }
-}
-
-function compareThreadsByAnchor(left: CommentThread, right: CommentThread): number {
-  const leftStart =
-    left.anchor.kind === "range" ? left.anchor.range.from : Number.MAX_SAFE_INTEGER;
-  const rightStart =
-    right.anchor.kind === "range" ? right.anchor.range.from : Number.MAX_SAFE_INTEGER;
-
-  if (leftStart !== rightStart) {
-    return leftStart - rightStart;
-  }
-
-  return left.commentId.localeCompare(right.commentId);
-}
-
-function toDetachedRange(anchor: CommentAnchorBounds): { from: number; to: number } | undefined {
-  const positions = [anchor.start, anchor.end, anchor.referenceAt].filter(
-    (value): value is number => typeof value === "number",
-  );
-  if (positions.length === 0) {
-    return undefined;
-  }
-  return {
-    from: Math.min(...positions),
-    to: Math.max(...positions),
-  };
-}
-
-function parseXml(xml: string): XmlElementNode {
-  const root: XmlElementNode = {
-    type: "element",
-    name: "#document",
-    attributes: {},
-    children: [],
-    start: 0,
-    end: xml.length,
-  };
-  const stack: XmlElementNode[] = [root];
-  const tokenPattern =
-    /<!--[\s\S]*?-->|<\?[\s\S]*?\?>|<!DOCTYPE[\s\S]*?>|<!\[CDATA\[[\s\S]*?\]\]>|<[^>]+>|[^<]+/gu;
-
-  for (const match of xml.matchAll(tokenPattern)) {
-    const token = match[0] ?? "";
-    const start = match.index ?? 0;
-    const end = start + token.length;
-
-    if (token.startsWith("<?") || token.startsWith("<!DOCTYPE") || token.startsWith("<!--")) {
-      continue;
-    }
-
-    if (token.startsWith("<![CDATA[")) {
-      const text = token.slice(9, -3);
-      stack[stack.length - 1]?.children.push({
-        type: "text",
-        text,
-        start,
-        end,
-      });
-      continue;
-    }
-
-    if (token.startsWith("</")) {
-      const node = stack.pop();
-      if (!node) {
-        throw new Error("Malformed XML: unexpected closing tag.");
-      }
-      node.end = end;
-      continue;
-    }
-
-    if (token.startsWith("<")) {
-      const selfClosing = /\/>$/.test(token);
-      const tagBody = token.slice(1, token.length - (selfClosing ? 2 : 1)).trim();
-      const { name, attributes } = parseTag(tagBody);
-      const node: XmlElementNode = {
-        type: "element",
-        name,
-        attributes,
-        children: [],
-        start,
-        end,
-      };
-      stack[stack.length - 1]?.children.push(node);
-      if (!selfClosing) {
-        stack.push(node);
-      }
-      continue;
-    }
-
-    const text = decodeXmlText(token);
-    if (text.length > 0) {
-      stack[stack.length - 1]?.children.push({
-        type: "text",
-        text,
-        start,
-        end,
-      });
-    }
-  }
-
-  if (stack.length !== 1) {
-    throw new Error("Malformed XML: unclosed tag.");
-  }
-
-  return root;
-}
-
-function parseTag(tagBody: string): { name: string; attributes: Record<string, string> } {
-  const whitespaceIndex = tagBody.search(/\s/u);
-  const name = whitespaceIndex === -1 ? tagBody : tagBody.slice(0, whitespaceIndex);
-  const rawAttributes = whitespaceIndex === -1 ? "" : tagBody.slice(whitespaceIndex + 1);
-  const attributes: Record<string, string> = {};
-  const pattern = /([A-Za-z_][A-Za-z0-9:._-]*)\s*=\s*("([^"]*)"|'([^']*)')/gu;
-
-  for (const match of rawAttributes.matchAll(pattern)) {
-    const key = match[1];
-    const value = match[3] ?? match[4] ?? "";
-    if (key) {
-      attributes[key] = decodeXmlText(value);
-    }
-  }
-
-  return { name, attributes };
-}
-
-function findChildElement(node: XmlElementNode, name: string): XmlElementNode {
-  const match = node.children.find(
-    (child): child is XmlElementNode =>
-      child.type === "element" && localName(child.name) === name,
-  );
-
-  if (!match) {
-    throw new Error(`Expected XML element ${name}.`);
-  }
-
-  return match;
-}
-
-function localName(name: string): string {
-  const index = name.indexOf(":");
-  return index === -1 ? name : name.slice(index + 1);
-}
-
-function decodeXmlText(text: string): string {
-  return text.replace(
-    /&(?:#x([0-9A-Fa-f]+)|#([0-9]+)|([A-Za-z]+));/gu,
-    (_, hex, dec, named) => {
-      if (hex) {
-        return String.fromCodePoint(Number.parseInt(hex, 16));
-      }
-      if (dec) {
-        return String.fromCodePoint(Number.parseInt(dec, 10));
-      }
-
-      switch (named) {
-        case "amp":
-          return "&";
-        case "lt":
-          return "<";
-        case "gt":
-          return ">";
-        case "quot":
-          return "\"";
-        case "apos":
-          return "'";
-        default:
-          return `&${named};`;
-      }
-    },
-  );
-}