@beyondwork/docx-react-component 1.0.0

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

@@ -0,0 +1,658 @@
+import { createDetachedAnchor } from "../../core/selection/mapping.ts";
+import {
+  createRevisionRecord,
+  type RevisionRecord,
+} from "../../review/store/revision-store.ts";
+import {
+  createRevisionRangeAnchor,
+  type MoveData,
+  type PropertyChangeData,
+  type RevisionKind,
+} from "../../review/store/revision-types.ts";
+import {
+  findChildElement,
+  findRequiredChildElement,
+  localName,
+  mapRevisionBoundaries,
+  parseXmlWithPositions,
+  type RevisionParagraphBoundary,
+  type XmlElementNode,
+  type XmlNode,
+} from "./revision-boundaries.ts";
+
+export interface PreservedRevisionMarkup {
+  revisionId: string;
+  rawXml: string;
+  xmlStart: number;
+  xmlEnd: number;
+  originalRevisionType: string;
+  paragraphIndex?: number;
+  containerXmlStart?: number;
+  containerXmlEnd?: number;
+  beforeContainerXml?: string;
+}
+
+export interface RevisionImportDiagnostic {
+  revisionId: string;
+  code:
+    | "preserve_only_move_revision"
+    | "preserve_only_formatting_revision"
+    | "nested_revision_preserve_only"
+    | "ambiguous_revision_anchor";
+  message: string;
+  featureClass: "preserve-only";
+}
+
+export interface ParsedRevisionsResult {
+  revisions: RevisionRecord[];
+  preservedMarkup: PreservedRevisionMarkup[];
+  diagnostics: RevisionImportDiagnostic[];
+  boundaries: RevisionParagraphBoundary[];
+}
+
+interface ParseState {
+  documentXml: string;
+  boundaries: RevisionParagraphBoundary[];
+  revisions: RevisionRecord[];
+  preservedMarkup: PreservedRevisionMarkup[];
+  diagnostics: RevisionImportDiagnostic[];
+  nextGeneratedIndex: number;
+}
+
+interface RevisionMetadata {
+  revisionId: string;
+  ooxmlRevisionId?: string;
+  authorId: string;
+  createdAt: string;
+}
+
+const SUPPORTED_CONTAINER_TYPES = new Set(["ins", "del"]);
+const PRESERVE_ONLY_CONTAINER_TYPES = new Set(["moveFrom", "moveTo"]);
+const FORMATTING_REVISION_TYPES = new Set(["rPrChange", "pPrChange"]);
+
+export function parseRevisionsFromDocumentXml(
+  documentXml: string,
+): ParsedRevisionsResult {
+  const root = parseXmlWithPositions(documentXml);
+  const documentElement = findRequiredChildElement(root, "document");
+  const bodyElement = findRequiredChildElement(documentElement, "body");
+  const boundaries = mapRevisionBoundaries(documentXml);
+  const state: ParseState = {
+    documentXml,
+    boundaries,
+    revisions: [],
+    preservedMarkup: [],
+    diagnostics: [],
+    nextGeneratedIndex: 1,
+  };
+
+  let paragraphIndex = -1;
+  let cursor = 0;
+  let previousWasParagraph = false;
+
+  for (const child of bodyElement.children) {
+    if (child.type !== "element") {
+      continue;
+    }
+
+    const childType = localName(child.name);
+
+    if (childType !== "p") {
+      if (childType === "tbl") {
+        parseTblPropertyRevisions(child, cursor, state);
+      } else if (childType === "sectPr") {
+        parseSectPrRevisions(child, cursor, state);
+      }
+      cursor += 1;
+      previousWasParagraph = false;
+      continue;
+    }
+
+    if (previousWasParagraph) {
+      cursor += 1;
+    }
+    paragraphIndex += 1;
+    const paragraphBoundary = boundaries[paragraphIndex];
+    if (!paragraphBoundary) {
+      continue;
+    }
+
+    parseParagraphMarkRevisions(child, paragraphBoundary, state);
+    walkParagraphContent(child.children, paragraphIndex, state, () => cursor, (next) => {
+      cursor = next;
+    });
+    previousWasParagraph = true;
+  }
+
+  return {
+    revisions: state.revisions,
+    preservedMarkup: state.preservedMarkup.sort((left, right) => left.xmlStart - right.xmlStart),
+    diagnostics: state.diagnostics,
+    boundaries,
+  };
+}
+
+function parseParagraphMarkRevisions(
+  paragraph: XmlElementNode,
+  boundary: RevisionParagraphBoundary,
+  state: ParseState,
+): void {
+  const paragraphProperties = findChildElement(paragraph, "pPr");
+  const paragraphRunProperties = paragraphProperties
+    ? findChildElement(paragraphProperties, "rPr")
+    : undefined;
+
+  if (!paragraphProperties) {
+    return;
+  }
+
+  const paragraphRange =
+    boundary.start === boundary.end
+      ? createRevisionRangeAnchor(boundary.end, boundary.end)
+      : createRevisionRangeAnchor(boundary.start, boundary.end);
+
+  for (const child of paragraphProperties.children) {
+    if (child.type !== "element") {
+      continue;
+    }
+
+    const type = localName(child.name);
+    if (type === "pPrChange") {
+      const metadata = readRevisionMetadata(child, state, "formatting");
+      const innerPPr = findChildElement(child, "pPr");
+      const propertyChangeData: PropertyChangeData = {
+        xmlTag: "pPrChange",
+        beforeXml: innerPPr ? state.documentXml.slice(innerPPr.start, innerPPr.end) : "",
+      };
+      state.revisions.push(
+        createRevisionRecord({
+          revisionId: metadata.revisionId,
+          kind: "formatting",
+          anchor: paragraphRange,
+          authorId: metadata.authorId,
+          createdAt: metadata.createdAt,
+          metadata: {
+            source: "import",
+            originalRevisionType: "pPrChange",
+            ooxmlRevisionId: metadata.ooxmlRevisionId,
+            preserveOnlyReason: "Imported preserve-only revision.",
+            propertyChangeData,
+          },
+        }),
+      );
+      state.preservedMarkup.push({
+        revisionId: metadata.revisionId,
+        rawXml: state.documentXml.slice(child.start, child.end),
+        xmlStart: child.start,
+        xmlEnd: child.end,
+        originalRevisionType: "pPrChange",
+      });
+      state.diagnostics.push({
+        revisionId: metadata.revisionId,
+        code: "preserve_only_formatting_revision",
+        message: "Paragraph property revisions remain preserve-only for Wave 6.",
+        featureClass: "preserve-only",
+      });
+    }
+  }
+
+  if (!paragraphRunProperties) {
+    return;
+  }
+
+  for (const child of paragraphRunProperties.children) {
+    if (child.type !== "element") {
+      continue;
+    }
+
+    const type = localName(child.name);
+    if (!SUPPORTED_CONTAINER_TYPES.has(type)) {
+      continue;
+    }
+
+    const metadata = readRevisionMetadata(child, state, type);
+    state.revisions.push(
+        createRevisionRecord({
+          revisionId: metadata.revisionId,
+          kind: type === "ins" ? "insertion" : "deletion",
+          anchor: createRevisionRangeAnchor(boundary.end, boundary.end),
+          authorId: metadata.authorId,
+          createdAt: metadata.createdAt,
+          metadata: {
+            source: "import",
+            importedRevisionForm:
+              type === "ins" ? "paragraph-insertion" : "paragraph-deletion",
+            originalRevisionType: `paragraph-${type}`,
+            ooxmlRevisionId: metadata.ooxmlRevisionId,
+          },
+        }),
+    );
+    state.preservedMarkup.push({
+      revisionId: metadata.revisionId,
+      rawXml: state.documentXml.slice(child.start, child.end),
+      xmlStart: child.start,
+      xmlEnd: child.end,
+      originalRevisionType: `paragraph-${type}`,
+      paragraphIndex: boundary.paragraphIndex,
+    });
+  }
+}
+
+function walkParagraphContent(
+  nodes: XmlNode[],
+  paragraphIndex: number,
+  state: ParseState,
+  getCursor: () => number,
+  setCursor: (next: number) => void,
+): void {
+  for (const node of nodes) {
+    walkContentNode(node, paragraphIndex, state, getCursor, setCursor);
+  }
+}
+
+function walkContentNode(
+  node: XmlNode,
+  paragraphIndex: number,
+  state: ParseState,
+  getCursor: () => number,
+  setCursor: (next: number) => void,
+): void {
+  if (node.type !== "element") {
+    return;
+  }
+
+  const type = localName(node.name);
+  if (type === "pPr") {
+    return;
+  }
+
+  if (type === "r") {
+    parseRunFormattingRevisions(node, paragraphIndex, state, getCursor());
+    for (const child of node.children) {
+      walkContentNode(child, paragraphIndex, state, getCursor, setCursor);
+    }
+    return;
+  }
+
+  if (SUPPORTED_CONTAINER_TYPES.has(type) || PRESERVE_ONLY_CONTAINER_TYPES.has(type)) {
+    const start = getCursor();
+    const length = measureStoryLength(node);
+    const end = start + length;
+    const hasNestedRevision = containsNestedRevision(node);
+    const metadata = readRevisionMetadata(
+      node,
+      state,
+      type === "moveFrom" || type === "moveTo" ? "move" : type,
+    );
+
+    if (hasNestedRevision) {
+      const nestedKind = type === "ins" ? "insertion" : type === "del" ? "deletion" : "move";
+      state.revisions.push(
+        createRevisionRecord({
+          revisionId: metadata.revisionId,
+          kind: nestedKind,
+          anchor:
+            length > 0
+              ? createRevisionRangeAnchor(start, end)
+              : createDetachedAnchor({ from: start, to: end }, "importAmbiguity"),
+          authorId: metadata.authorId,
+          createdAt: metadata.createdAt,
+          metadata: {
+            source: "import",
+            originalRevisionType: type,
+            ooxmlRevisionId: metadata.ooxmlRevisionId,
+            preserveOnlyReason: "Nested revision markup remains preserve-only.",
+          },
+        }),
+      );
+      state.preservedMarkup.push({
+        revisionId: metadata.revisionId,
+        rawXml: state.documentXml.slice(node.start, node.end),
+        xmlStart: node.start,
+        xmlEnd: node.end,
+        originalRevisionType: type,
+      });
+      state.diagnostics.push({
+        revisionId: metadata.revisionId,
+        code: "nested_revision_preserve_only",
+        message: "Nested revision markup remains preserve-only and is exported unchanged.",
+        featureClass: "preserve-only",
+      });
+      advanceCursor(node, setCursor, getCursor);
+      return;
+    }
+
+    if (type === "moveFrom" || type === "moveTo") {
+      const moveData: MoveData = {
+        moveId: metadata.ooxmlRevisionId ?? `generated-${metadata.revisionId}`,
+        direction: type === "moveFrom" ? "from" : "to",
+      };
+      state.revisions.push(
+        createRevisionRecord({
+          revisionId: metadata.revisionId,
+          kind: "move",
+          anchor:
+            length > 0
+              ? createRevisionRangeAnchor(start, end)
+              : createDetachedAnchor({ from: start, to: end }, "importAmbiguity"),
+          authorId: metadata.authorId,
+          createdAt: metadata.createdAt,
+          metadata: {
+            source: "import",
+            originalRevisionType: type,
+            ooxmlRevisionId: metadata.ooxmlRevisionId,
+            preserveOnlyReason: "Imported preserve-only revision.",
+            moveData,
+          },
+        }),
+      );
+      state.preservedMarkup.push({
+        revisionId: metadata.revisionId,
+        rawXml: state.documentXml.slice(node.start, node.end),
+        xmlStart: node.start,
+        xmlEnd: node.end,
+        originalRevisionType: type,
+      });
+      state.diagnostics.push({
+        revisionId: metadata.revisionId,
+        code: "preserve_only_move_revision",
+        message: "Tracked move revisions remain preserve-only for Wave 6.",
+        featureClass: "preserve-only",
+      });
+      advanceCursor(node, setCursor, getCursor);
+      return;
+    }
+
+    state.revisions.push(
+        createRevisionRecord({
+          revisionId: metadata.revisionId,
+          kind: type === "ins" ? "insertion" : "deletion",
+          anchor: createRevisionRangeAnchor(start, end),
+          authorId: metadata.authorId,
+          createdAt: metadata.createdAt,
+          metadata: {
+            source: "import",
+            importedRevisionForm:
+              type === "ins" ? "run-insertion" : "run-deletion",
+            originalRevisionType: type,
+            ooxmlRevisionId: metadata.ooxmlRevisionId,
+          },
+        }),
+    );
+    state.preservedMarkup.push({
+      revisionId: metadata.revisionId,
+      rawXml: state.documentXml.slice(node.start, node.end),
+      xmlStart: node.start,
+      xmlEnd: node.end,
+      originalRevisionType: type,
+    });
+    advanceCursor(node, setCursor, getCursor);
+    return;
+  }
+
+  switch (type) {
+    case "t":
+    case "delText":
+    case "instrText":
+    case "delInstrText": {
+      const text = node.children
+        .filter((child): child is XmlElementNode["children"][number] & { type: "text" } => child.type === "text")
+        .map((child) => child.text)
+        .join("");
+      setCursor(getCursor() + text.length);
+      return;
+    }
+    case "tab":
+    case "br":
+    case "cr":
+      setCursor(getCursor() + 1);
+      return;
+    default:
+      for (const child of node.children) {
+        walkContentNode(child, paragraphIndex, state, getCursor, setCursor);
+      }
+  }
+}
+
+function parseRunFormattingRevisions(
+  run: XmlElementNode,
+  _paragraphIndex: number,
+  state: ParseState,
+  runStart: number,
+): void {
+  const runProperties = findChildElement(run, "rPr");
+  if (!runProperties) {
+    return;
+  }
+
+  const runLength = measureStoryLength(run);
+  const anchor =
+    runLength > 0
+      ? createRevisionRangeAnchor(runStart, runStart + runLength)
+      : createDetachedAnchor({ from: runStart, to: runStart }, "importAmbiguity");
+
+  for (const child of runProperties.children) {
+    if (child.type !== "element" || !FORMATTING_REVISION_TYPES.has(localName(child.name))) {
+      continue;
+    }
+
+    const childLocalName = localName(child.name) as "rPrChange" | "pPrChange";
+    const metadata = readRevisionMetadata(child, state, "formatting");
+    const innerRPr = findChildElement(child, "rPr");
+    const propertyChangeData: PropertyChangeData = {
+      xmlTag: childLocalName === "rPrChange" ? "rPrChange" : "pPrChange",
+      beforeXml: innerRPr ? state.documentXml.slice(innerRPr.start, innerRPr.end) : "",
+    };
+    state.revisions.push(
+      createRevisionRecord({
+        revisionId: metadata.revisionId,
+        kind: "formatting",
+        anchor,
+        authorId: metadata.authorId,
+        createdAt: metadata.createdAt,
+        metadata: {
+          source: "import",
+          originalRevisionType: childLocalName,
+          ooxmlRevisionId: metadata.ooxmlRevisionId,
+          preserveOnlyReason: "Imported preserve-only revision.",
+          propertyChangeData,
+        },
+      }),
+    );
+    state.preservedMarkup.push({
+      revisionId: metadata.revisionId,
+      rawXml: state.documentXml.slice(child.start, child.end),
+      xmlStart: child.start,
+      xmlEnd: child.end,
+      originalRevisionType: childLocalName,
+    });
+    state.diagnostics.push({
+      revisionId: metadata.revisionId,
+      code: "preserve_only_formatting_revision",
+      message: "Formatting revisions remain preserve-only for Wave 6.",
+      featureClass: "preserve-only",
+    });
+  }
+}
+
+function parseTblPropertyRevisions(
+  table: XmlElementNode,
+  position: number,
+  state: ParseState,
+): void {
+  const tblPr = findChildElement(table, "tblPr");
+  if (!tblPr) {
+    return;
+  }
+
+  const tblPrChange = findChildElement(tblPr, "tblPrChange");
+  if (!tblPrChange) {
+    return;
+  }
+
+  const metadata = readRevisionMetadata(tblPrChange, state, "property-change");
+  const innerTblPr = findChildElement(tblPrChange, "tblPr");
+  const beforeXml = innerTblPr ? state.documentXml.slice(innerTblPr.start, innerTblPr.end) : "";
+  const propertyChangeData: PropertyChangeData = { xmlTag: "tblPrChange", beforeXml };
+
+  state.revisions.push(
+    createRevisionRecord({
+      revisionId: metadata.revisionId,
+      kind: "property-change",
+      anchor: createRevisionRangeAnchor(position, position),
+      authorId: metadata.authorId,
+      createdAt: metadata.createdAt,
+      metadata: {
+        source: "import",
+        originalRevisionType: "tblPrChange",
+        ooxmlRevisionId: metadata.ooxmlRevisionId,
+        propertyChangeData,
+      },
+    }),
+  );
+  state.preservedMarkup.push({
+    revisionId: metadata.revisionId,
+    rawXml: state.documentXml.slice(tblPrChange.start, tblPrChange.end),
+    xmlStart: tblPrChange.start,
+    xmlEnd: tblPrChange.end,
+    originalRevisionType: "tblPrChange",
+    containerXmlStart: tblPr.start,
+    containerXmlEnd: tblPr.end,
+    beforeContainerXml: beforeXml,
+  });
+}
+
+function parseSectPrRevisions(
+  sectPr: XmlElementNode,
+  position: number,
+  state: ParseState,
+): void {
+  const sectPrChange = findChildElement(sectPr, "sectPrChange");
+  if (!sectPrChange) {
+    return;
+  }
+
+  const metadata = readRevisionMetadata(sectPrChange, state, "property-change");
+  const innerSectPr = findChildElement(sectPrChange, "sectPr");
+  const beforeXml = innerSectPr ? state.documentXml.slice(innerSectPr.start, innerSectPr.end) : "";
+  const propertyChangeData: PropertyChangeData = { xmlTag: "sectPrChange", beforeXml };
+
+  state.revisions.push(
+    createRevisionRecord({
+      revisionId: metadata.revisionId,
+      kind: "property-change",
+      anchor: createRevisionRangeAnchor(position, position),
+      authorId: metadata.authorId,
+      createdAt: metadata.createdAt,
+      metadata: {
+        source: "import",
+        originalRevisionType: "sectPrChange",
+        ooxmlRevisionId: metadata.ooxmlRevisionId,
+        propertyChangeData,
+      },
+    }),
+  );
+  state.preservedMarkup.push({
+    revisionId: metadata.revisionId,
+    rawXml: state.documentXml.slice(sectPrChange.start, sectPrChange.end),
+    xmlStart: sectPrChange.start,
+    xmlEnd: sectPrChange.end,
+    originalRevisionType: "sectPrChange",
+    containerXmlStart: sectPr.start,
+    containerXmlEnd: sectPr.end,
+    beforeContainerXml: beforeXml,
+  });
+}
+
+function readRevisionMetadata(
+  node: XmlElementNode,
+  state: ParseState,
+  prefix: string,
+): RevisionMetadata {
+  const rawId = node.attributes["w:id"] ?? node.attributes.id;
+  const ooxmlRevisionId = rawId ? rawId : undefined;
+  const revisionId = rawId
+    ? `revision:${sanitizeRevisionToken(prefix)}-${sanitizeRevisionToken(rawId)}`
+    : `revision:${sanitizeRevisionToken(prefix)}-generated-${state.nextGeneratedIndex++}`;
+  const authorId =
+    node.attributes["w:author"] ??
+    node.attributes.author ??
+    "word:unknown-author";
+  const createdAt =
+    normalizeImportedTimestamp(
+      node.attributes["w:date"] ?? node.attributes.date,
+    ) ??
+    "1970-01-01T00:00:00.000Z";
+
+  return {
+    revisionId,
+    ooxmlRevisionId,
+    authorId,
+    createdAt,
+  };
+}
+
+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 sanitizeRevisionToken(value: string): string {
+  const sanitized = value.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+  return sanitized.length > 0 ? sanitized : "unknown";
+}
+
+function containsNestedRevision(node: XmlElementNode): boolean {
+  return node.children.some(
+    (child) =>
+      child.type === "element" &&
+      (SUPPORTED_CONTAINER_TYPES.has(localName(child.name)) ||
+        PRESERVE_ONLY_CONTAINER_TYPES.has(localName(child.name)) ||
+        FORMATTING_REVISION_TYPES.has(localName(child.name)) ||
+        containsNestedRevision(child)),
+  );
+}
+
+function advanceCursor(
+  node: XmlElementNode,
+  setCursor: (next: number) => void,
+  getCursor: () => number,
+): void {
+  setCursor(getCursor() + measureStoryLength(node));
+}
+
+function measureStoryLength(node: XmlNode): number {
+  if (node.type !== "element") {
+    return 0;
+  }
+
+  switch (localName(node.name)) {
+    case "t":
+    case "delText":
+    case "instrText":
+    case "delInstrText":
+      return node.children
+        .filter((child): child is XmlElementNode["children"][number] & { type: "text" } => child.type === "text")
+        .map((child) => child.text.length)
+        .reduce((total, length) => total + length, 0);
+    case "tab":
+    case "br":
+    case "cr":
+      return 1;
+    case "pPr":
+    case "rPr":
+    case "rPrChange":
+    case "pPrChange":
+      return 0;
+    default:
+      return node.children.reduce((total, child) => total + measureStoryLength(child), 0);
+  }
+}