@beyondwork/docx-react-component 1.0.29 → 1.0.30

package/src/io/ooxml/revision-boundaries.ts

@@ -0,0 +1,475 @@
+export interface XmlElementNode {
+  type: "element";
+  name: string;
+  attributes: Record<string, string>;
+  children: XmlNode[];
+  start: number;
+  end: number;
+  openingTagEnd: number;
+  closingTagStart: number;
+}
+
+export interface XmlTextNode {
+  type: "text";
+  text: string;
+  start: number;
+  end: number;
+}
+
+export type XmlNode = XmlElementNode | XmlTextNode;
+
+export interface RevisionParagraphBoundary {
+  paragraphIndex: number;
+  start: number;
+  end: number;
+  boundaries: Map<number, number>;
+  paragraphStart: number;
+  paragraphStartTagEnd: number;
+  paragraphEndTagStart: number;
+  paragraphEnd: number;
+  paragraphPropertiesStart?: number;
+  paragraphPropertiesEnd?: number;
+  paragraphRunPropertiesStart?: number;
+  paragraphRunPropertiesEnd?: number;
+}
+
+export function mapRevisionBoundaries(
+  documentXml: string,
+): RevisionParagraphBoundary[] {
+  const root = parseXmlWithPositions(documentXml);
+  const documentElement = findRequiredChildElement(root, "document");
+  const bodyElement = findRequiredChildElement(documentElement, "body");
+  const paragraphs: RevisionParagraphBoundary[] = [];
+  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") {
+      if (localName(child.name) === "tbl") {
+        const nested = collectNestedParagraphBoundaries(
+          child.children,
+          paragraphIndex,
+          cursor,
+          previousWasParagraph,
+        );
+        paragraphIndex = nested.paragraphIndex;
+        cursor = nested.cursor;
+        previousWasParagraph = nested.previousWasParagraph;
+        paragraphs.push(...nested.paragraphs);
+      } else {
+        cursor += 1;
+        previousWasParagraph = false;
+      }
+      continue;
+    }
+
+    if (previousWasParagraph) {
+      cursor += 1;
+    }
+    paragraphIndex += 1;
+    const boundaries = new Map<number, number>();
+    boundaries.set(cursor, child.openingTagEnd);
+
+    const paragraphProperties = findChildElement(child, "pPr");
+    const paragraphRunProperties = paragraphProperties
+      ? findChildElement(paragraphProperties, "rPr")
+      : undefined;
+
+    walkStoryNodesForBoundaries(
+      child.children,
+      boundaries,
+      () => cursor,
+      (next) => {
+        cursor = next;
+      },
+    );
+
+    boundaries.set(cursor, child.closingTagStart);
+    paragraphs.push({
+      paragraphIndex,
+      start: Math.min(...boundaries.keys()),
+      end: Math.max(...boundaries.keys()),
+      boundaries,
+      paragraphStart: child.start,
+      paragraphStartTagEnd: child.openingTagEnd,
+      paragraphEndTagStart: child.closingTagStart,
+      paragraphEnd: child.end,
+      ...(paragraphProperties
+        ? {
+            paragraphPropertiesStart: paragraphProperties.start,
+            paragraphPropertiesEnd: paragraphProperties.end,
+          }
+        : {}),
+      ...(paragraphRunProperties
+        ? {
+            paragraphRunPropertiesStart: paragraphRunProperties.start,
+            paragraphRunPropertiesEnd: paragraphRunProperties.end,
+          }
+        : {}),
+    });
+    previousWasParagraph = true;
+  }
+
+  return paragraphs;
+}
+
+function collectNestedParagraphBoundaries(
+  nodes: XmlNode[],
+  paragraphIndex: number,
+  cursor: number,
+  previousWasParagraph: boolean,
+): {
+  paragraphs: RevisionParagraphBoundary[];
+  paragraphIndex: number;
+  cursor: number;
+  previousWasParagraph: boolean;
+} {
+  const paragraphs: RevisionParagraphBoundary[] = [];
+  let nextParagraphIndex = paragraphIndex;
+  let nextCursor = cursor;
+  let nextPreviousWasParagraph = previousWasParagraph;
+
+  for (const node of nodes) {
+    if (node.type !== "element") {
+      continue;
+    }
+    const type = localName(node.name);
+
+    if (type === "p") {
+      nextParagraphIndex += 1;
+      const boundaries = new Map<number, number>();
+      boundaries.set(nextCursor, node.openingTagEnd);
+
+      const paragraphProperties = findChildElement(node, "pPr");
+      const paragraphRunProperties = paragraphProperties
+        ? findChildElement(paragraphProperties, "rPr")
+        : undefined;
+
+      walkStoryNodesForBoundaries(
+        node.children,
+        boundaries,
+        () => nextCursor,
+        (next) => {
+          nextCursor = next;
+        },
+      );
+
+      boundaries.set(nextCursor, node.closingTagStart);
+      paragraphs.push({
+        paragraphIndex: nextParagraphIndex,
+        start: Math.min(...boundaries.keys()),
+        end: Math.max(...boundaries.keys()),
+        boundaries,
+        paragraphStart: node.start,
+        paragraphStartTagEnd: node.openingTagEnd,
+        paragraphEndTagStart: node.closingTagStart,
+        paragraphEnd: node.end,
+        ...(paragraphProperties
+          ? {
+              paragraphPropertiesStart: paragraphProperties.start,
+              paragraphPropertiesEnd: paragraphProperties.end,
+            }
+          : {}),
+        ...(paragraphRunProperties
+          ? {
+              paragraphRunPropertiesStart: paragraphRunProperties.start,
+              paragraphRunPropertiesEnd: paragraphRunProperties.end,
+            }
+          : {}),
+      });
+      nextPreviousWasParagraph = false;
+      continue;
+    }
+
+    if (
+      type === "tbl" ||
+      type === "tr" ||
+      type === "tc" ||
+      type === "sdtContent" ||
+      type === "customXml" ||
+      type === "smartTag"
+    ) {
+      const nested = collectNestedParagraphBoundaries(
+        node.children,
+        nextParagraphIndex,
+        nextCursor,
+        nextPreviousWasParagraph,
+      );
+      nextParagraphIndex = nested.paragraphIndex;
+      nextCursor = nested.cursor;
+      nextPreviousWasParagraph = nested.previousWasParagraph;
+      paragraphs.push(...nested.paragraphs);
+      continue;
+    }
+
+    if (
+      type === "tblPr" ||
+      type === "tblGrid" ||
+      type === "gridCol" ||
+      type === "trPr" ||
+      type === "tcPr"
+    ) {
+      continue;
+    }
+
+    nextCursor += 1;
+    nextPreviousWasParagraph = false;
+  }
+
+  return {
+    paragraphs,
+    paragraphIndex: nextParagraphIndex,
+    cursor: nextCursor,
+    previousWasParagraph: nextPreviousWasParagraph,
+  };
+}
+
+function walkStoryNodesForBoundaries(
+  nodes: XmlNode[],
+  boundaries: Map<number, number>,
+  getCursor: () => number,
+  setCursor: (next: number) => void,
+): void {
+  for (const node of nodes) {
+    walkStoryNodeForBoundaries(node, boundaries, getCursor, setCursor);
+  }
+}
+
+function walkStoryNodeForBoundaries(
+  node: XmlNode,
+  boundaries: Map<number, number>,
+  getCursor: () => number,
+  setCursor: (next: number) => void,
+): void {
+  if (node.type !== "element") {
+    return;
+  }
+
+  switch (localName(node.name)) {
+    case "pPr":
+      return;
+    case "r":
+      boundaries.set(getCursor(), node.start);
+      for (const child of node.children) {
+        walkStoryNodeForBoundaries(child, boundaries, getCursor, setCursor);
+      }
+      boundaries.set(getCursor(), node.end);
+      return;
+    case "ins":
+    case "del":
+    case "moveFrom":
+    case "moveTo":
+    case "hyperlink":
+    case "smartTag":
+    case "sdtContent":
+    case "customXml":
+      for (const child of node.children) {
+        walkStoryNodeForBoundaries(child, boundaries, getCursor, setCursor);
+      }
+      return;
+    case "t":
+    case "delText":
+    case "instrText":
+    case "delInstrText": {
+      const text = node.children
+        .filter((child): child is XmlTextNode => child.type === "text")
+        .map((child) => child.text)
+        .join("");
+      if (text.length === 0) {
+        return;
+      }
+
+      if (!boundaries.has(getCursor())) {
+        boundaries.set(getCursor(), node.start);
+      }
+      setCursor(getCursor() + Array.from(text).length);
+      boundaries.set(getCursor(), node.end);
+      return;
+    }
+    case "tab":
+    case "br":
+    case "cr":
+      if (!boundaries.has(getCursor())) {
+        boundaries.set(getCursor(), node.start);
+      }
+      setCursor(getCursor() + 1);
+      boundaries.set(getCursor(), node.end);
+      return;
+    default:
+      for (const child of node.children) {
+        walkStoryNodeForBoundaries(child, boundaries, getCursor, setCursor);
+      }
+  }
+}
+
+export function parseXmlWithPositions(xml: string): XmlElementNode {
+  const root: XmlElementNode = {
+    type: "element",
+    name: "__root__",
+    attributes: {},
+    children: [],
+    start: 0,
+    end: xml.length,
+    openingTagEnd: 0,
+    closingTagStart: xml.length,
+  };
+  const stack: XmlElementNode[] = [root];
+  let cursor = 0;
+
+  while (cursor < xml.length) {
+    if (xml.startsWith("<!--", cursor)) {
+      const end = xml.indexOf("-->", cursor);
+      cursor = end >= 0 ? end + 3 : xml.length;
+      continue;
+    }
+
+    if (xml.startsWith("<?", cursor)) {
+      const end = xml.indexOf("?>", cursor);
+      cursor = end >= 0 ? end + 2 : xml.length;
+      continue;
+    }
+
+    if (xml.startsWith("<![CDATA[", cursor)) {
+      const end = xml.indexOf("]]>", cursor);
+      const textEnd = end >= 0 ? end : xml.length;
+      stack[stack.length - 1]?.children.push({
+        type: "text",
+        text: xml.slice(cursor + 9, textEnd),
+        start: cursor,
+        end: textEnd,
+      });
+      cursor = end >= 0 ? end + 3 : xml.length;
+      continue;
+    }
+
+    if (xml[cursor] !== "<") {
+      const nextTag = xml.indexOf("<", cursor);
+      const end = nextTag >= 0 ? nextTag : xml.length;
+      const text = decodeXmlEntities(xml.slice(cursor, end));
+      if (text.length > 0) {
+        stack[stack.length - 1]?.children.push({
+          type: "text",
+          text,
+          start: cursor,
+          end,
+        });
+      }
+      cursor = end;
+      continue;
+    }
+
+    if (xml[cursor + 1] === "/") {
+      const tagEnd = xml.indexOf(">", cursor);
+      if (tagEnd < 0) {
+        throw new Error("Malformed XML: unterminated closing tag.");
+      }
+
+      const node = stack.pop();
+      if (!node || stack.length === 0) {
+        throw new Error("Malformed XML: unexpected closing tag.");
+      }
+
+      node.closingTagStart = cursor;
+      node.end = tagEnd + 1;
+      cursor = tagEnd + 1;
+      continue;
+    }
+
+    const tagEnd = xml.indexOf(">", cursor);
+    if (tagEnd < 0) {
+      throw new Error("Malformed XML: unterminated opening tag.");
+    }
+
+    const rawTag = xml.slice(cursor + 1, tagEnd);
+    const selfClosing = /\/\s*$/.test(rawTag);
+    const normalizedTag = selfClosing ? rawTag.replace(/\/\s*$/, "") : rawTag;
+    const parts = normalizedTag.trim().split(/\s+/, 1);
+    const name = parts[0];
+    if (!name) {
+      throw new Error("Malformed XML: empty tag name.");
+    }
+
+    const attributes = parseAttributes(normalizedTag.slice(name.length));
+    const node: XmlElementNode = {
+      type: "element",
+      name,
+      attributes,
+      children: [],
+      start: cursor,
+      end: selfClosing ? tagEnd + 1 : xml.length,
+      openingTagEnd: tagEnd + 1,
+      closingTagStart: tagEnd + 1,
+    };
+
+    stack[stack.length - 1]?.children.push(node);
+    cursor = tagEnd + 1;
+
+    if (!selfClosing) {
+      stack.push(node);
+    }
+  }
+
+  if (stack.length !== 1) {
+    throw new Error("Malformed XML: unclosed element.");
+  }
+
+  return root;
+}
+
+export function findRequiredChildElement(
+  node: XmlElementNode,
+  childLocalName: string,
+): XmlElementNode {
+  const child = findChildElement(node, childLocalName);
+  if (!child) {
+    throw new Error(`Expected <${childLocalName}> element.`);
+  }
+
+  return child;
+}
+
+export function findChildElement(
+  node: XmlElementNode,
+  childLocalName: string,
+): XmlElementNode | undefined {
+  return node.children.find(
+    (entry): entry is XmlElementNode =>
+      entry.type === "element" && localName(entry.name) === childLocalName,
+  );
+}
+
+export function localName(name: string): string {
+  const separatorIndex = name.indexOf(":");
+  return separatorIndex >= 0 ? name.slice(separatorIndex + 1) : name;
+}
+
+function parseAttributes(source: string): Record<string, string> {
+  const attributes: Record<string, string> = {};
+  const attributePattern = /([A-Za-z_][A-Za-z0-9:._-]*)\s*=\s*("([^"]*)"|'([^']*)')/g;
+
+  for (const match of source.matchAll(attributePattern)) {
+    const key = match[1];
+    if (!key) {
+      continue;
+    }
+
+    const rawValue = match[3] ?? match[4] ?? "";
+    attributes[key] = decodeXmlEntities(rawValue);
+  }
+
+  return attributes;
+}
+
+function decodeXmlEntities(value: string): string {
+  return value
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">")
+    .replace(/&quot;/g, "\"")
+    .replace(/&apos;/g, "'")
+    .replace(/&amp;/g, "&");
+}