@beyondwork/docx-react-component 1.0.28 → 1.0.30

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

@@ -1,4 +1,13 @@
-import type { NumberingCatalog, NumberingLevelDefinition, NumberingLevelOverride } from "../../model/canonical-document.ts";
+import type {
+  NumberingCatalog,
+  NumberingLevelDefinition,
+  NumberingLevelParagraphGeometry,
+  NumberingLevelOverride,
+  NumberingLevelOverrideDefinition,
+  ParagraphSpacing,
+  ParagraphIndentation,
+  TabStop,
+} from "../../model/canonical-document.ts";
 
 export interface ParsedParagraphNumberingReference {
   paragraphIndex: number;
@@ -136,32 +145,12 @@ function readLevels(abstractNode: XmlElementNode): NumberingLevelDefinition[] {
     if (level === undefined) {
       continue;
     }
+    const definition = readLevelDefinition(child, level);
+    if (!definition) {
+      continue;
+    }
 
-    const startNode = findChildElementOptional(child, "start");
-    const formatNode = findChildElementOptional(child, "numFmt");
-    const textNode = findChildElementOptional(child, "lvlText");
-    const paragraphStyleNode = findChildElementOptional(child, "pStyle");
-    const rawStart = startNode?.attributes["w:val"] ?? startNode?.attributes.val;
-    const startAt = rawStart === undefined ? undefined : parseInteger(rawStart);
-    const format = formatNode?.attributes["w:val"] ?? formatNode?.attributes.val ?? "decimal";
-    const text = textNode?.attributes["w:val"] ?? textNode?.attributes.val ?? `%${level + 1}.`;
-    const paragraphStyleId =
-      paragraphStyleNode?.attributes["w:val"] ?? paragraphStyleNode?.attributes.val;
-    const isLegalNode = findChildElementOptional(child, "isLgl");
-    const isLegalNumbering = isLegalNode !== undefined;
-    const suffixNode = findChildElementOptional(child, "suff");
-    const suffixVal = suffixNode?.attributes["w:val"] ?? suffixNode?.attributes.val;
-    const suffix = suffixVal === "space" || suffixVal === "nothing" ? suffixVal : suffixVal === "tab" ? "tab" : undefined;
-
-    levels.push({
-      level,
-      format,
-      text,
-      ...(startAt !== undefined ? { startAt } : {}),
-      ...(paragraphStyleId ? { paragraphStyleId } : {}),
-      ...(isLegalNumbering ? { isLegalNumbering } : {}),
-      ...(suffix ? { suffix } : {}),
-    });
+    levels.push(definition);
   }
 
   return levels.sort((left, right) => left.level - right.level);
@@ -184,16 +173,342 @@ function readOverrides(numNode: XmlElementNode): NumberingLevelOverride[] {
     const startOverrideNode = findChildElementOptional(child, "startOverride");
     const rawStart = startOverrideNode?.attributes["w:val"] ?? startOverrideNode?.attributes.val;
     const startAt = rawStart === undefined ? undefined : parseInteger(rawStart);
+    const levelDefinitionNode = findChildElementOptional(child, "lvl");
+    const levelDefinition = levelDefinitionNode
+      ? readLevelOverrideDefinition(levelDefinitionNode, level)
+      : undefined;
 
     overrides.push({
       level,
       ...(startAt !== undefined ? { startAt } : {}),
+      ...(levelDefinition ? { levelDefinition } : {}),
     });
   }
 
   return overrides.sort((left, right) => left.level - right.level);
 }
 
+function readLevelDefinition(
+  levelNode: XmlElementNode,
+  fallbackLevel?: number,
+): NumberingLevelDefinition | undefined {
+  const rawLevel = levelNode.attributes["w:ilvl"] ?? levelNode.attributes.ilvl;
+  const level = rawLevel === undefined ? fallbackLevel : parseInteger(rawLevel);
+  if (level === undefined) {
+    return undefined;
+  }
+
+  const startNode = findChildElementOptional(levelNode, "start");
+  const formatNode = findChildElementOptional(levelNode, "numFmt");
+  const textNode = findChildElementOptional(levelNode, "lvlText");
+  const paragraphStyleNode = findChildElementOptional(levelNode, "pStyle");
+  const rawStart = startNode?.attributes["w:val"] ?? startNode?.attributes.val;
+  const startAt = rawStart === undefined ? undefined : parseInteger(rawStart);
+  const format = formatNode?.attributes["w:val"] ?? formatNode?.attributes.val ?? "decimal";
+  const text = textNode?.attributes["w:val"] ?? textNode?.attributes.val ?? `%${level + 1}.`;
+  const paragraphStyleId =
+    paragraphStyleNode?.attributes["w:val"] ?? paragraphStyleNode?.attributes.val;
+  const isLegalNode = findChildElementOptional(levelNode, "isLgl");
+  const isLegalNumbering = readIsLegalNumberingValue(isLegalNode);
+  const suffixNode = findChildElementOptional(levelNode, "suff");
+  const suffixVal = suffixNode?.attributes["w:val"] ?? suffixNode?.attributes.val;
+  const suffix =
+    suffixVal === "space" || suffixVal === "nothing"
+      ? suffixVal
+      : suffixVal === "tab"
+        ? "tab"
+        : undefined;
+  const paragraphGeometry = readLevelParagraphGeometry(levelNode);
+
+  return {
+    level,
+    format,
+    text,
+    ...(startAt !== undefined ? { startAt } : {}),
+    ...(paragraphStyleId ? { paragraphStyleId } : {}),
+    ...(isLegalNumbering ? { isLegalNumbering: true } : {}),
+    ...(suffix ? { suffix } : {}),
+    ...(paragraphGeometry ? { paragraphGeometry } : {}),
+  };
+}
+
+function readLevelOverrideDefinition(
+  levelNode: XmlElementNode,
+  fallbackLevel?: number,
+): NumberingLevelOverrideDefinition | undefined {
+  const rawLevel = levelNode.attributes["w:ilvl"] ?? levelNode.attributes.ilvl;
+  const level = rawLevel === undefined ? fallbackLevel : parseInteger(rawLevel);
+  if (level === undefined) {
+    return undefined;
+  }
+
+  const startNode = findChildElementOptional(levelNode, "start");
+  const formatNode = findChildElementOptional(levelNode, "numFmt");
+  const textNode = findChildElementOptional(levelNode, "lvlText");
+  const paragraphStyleNode = findChildElementOptional(levelNode, "pStyle");
+  const rawStart = startNode?.attributes["w:val"] ?? startNode?.attributes.val;
+  const startAt = rawStart === undefined ? undefined : parseInteger(rawStart);
+  const format = formatNode?.attributes["w:val"] ?? formatNode?.attributes.val;
+  const text = textNode?.attributes["w:val"] ?? textNode?.attributes.val;
+  const paragraphStyleId =
+    paragraphStyleNode?.attributes["w:val"] ?? paragraphStyleNode?.attributes.val;
+  const isLegalNode = findChildElementOptional(levelNode, "isLgl");
+  const isLegalNumbering = readIsLegalNumberingValue(isLegalNode);
+  const suffixNode = findChildElementOptional(levelNode, "suff");
+  const suffixVal = suffixNode?.attributes["w:val"] ?? suffixNode?.attributes.val;
+  const suffix =
+    suffixVal === "space" || suffixVal === "nothing"
+      ? suffixVal
+      : suffixVal === "tab"
+        ? "tab"
+        : undefined;
+  const paragraphGeometry = readLevelParagraphGeometry(levelNode);
+
+  const hasExplicitFields =
+    startAt !== undefined ||
+    format !== undefined ||
+    text !== undefined ||
+    paragraphStyleId !== undefined ||
+    isLegalNumbering !== undefined ||
+    suffix !== undefined ||
+    paragraphGeometry !== undefined;
+
+  if (!hasExplicitFields) {
+    return undefined;
+  }
+
+  return {
+    level,
+    ...(startAt !== undefined ? { startAt } : {}),
+    ...(format !== undefined ? { format } : {}),
+    ...(text !== undefined ? { text } : {}),
+    ...(paragraphStyleId ? { paragraphStyleId } : {}),
+    ...(isLegalNumbering !== undefined ? { isLegalNumbering } : {}),
+    ...(suffix ? { suffix } : {}),
+    ...(paragraphGeometry ? { paragraphGeometry } : {}),
+  };
+}
+
+function readLevelParagraphGeometry(
+  levelNode: XmlElementNode,
+): NumberingLevelDefinition["paragraphGeometry"] | undefined {
+  const paragraphPropertiesNode = findChildElementOptional(levelNode, "pPr");
+  const justification = readLevelJustification(levelNode);
+  const spacing = paragraphPropertiesNode ? readParagraphSpacing(paragraphPropertiesNode) : undefined;
+  const indentation = paragraphPropertiesNode
+    ? readParagraphIndentation(paragraphPropertiesNode)
+    : undefined;
+  const tabStops = paragraphPropertiesNode ? readParagraphTabStops(paragraphPropertiesNode) : undefined;
+
+  if (!justification && !spacing && !indentation && (!tabStops || tabStops.length === 0)) {
+    return undefined;
+  }
+
+  return {
+    ...(justification ? { justification } : {}),
+    ...(spacing ? { spacing } : {}),
+    ...(indentation ? { indentation } : {}),
+    ...(tabStops && tabStops.length > 0 ? { tabStops } : {}),
+  };
+}
+
+function readLevelJustification(
+  levelNode: XmlElementNode,
+): NumberingLevelParagraphGeometry["justification"] {
+  const justificationNode = findChildElementOptional(levelNode, "lvlJc");
+  if (!justificationNode) {
+    return undefined;
+  }
+
+  const rawValue = (
+    justificationNode.attributes["w:val"] ??
+    justificationNode.attributes.val ??
+    ""
+  ).toLowerCase();
+
+  if (rawValue === "start") {
+    return "left";
+  }
+  if (rawValue === "end") {
+    return "right";
+  }
+  if (
+    rawValue === "left" ||
+    rawValue === "center" ||
+    rawValue === "right" ||
+    rawValue === "both" ||
+    rawValue === "distribute"
+  ) {
+    return rawValue;
+  }
+
+  return undefined;
+}
+
+function readParagraphIndentation(node: XmlElementNode): ParagraphIndentation | undefined {
+  const indNode = findChildElementOptional(node, "ind");
+  if (!indNode) {
+    return undefined;
+  }
+
+  const indentation: ParagraphIndentation = {};
+  const left =
+    indNode.attributes["w:start"] ??
+    indNode.attributes.start ??
+    indNode.attributes["w:left"] ??
+    indNode.attributes.left;
+  const right =
+    indNode.attributes["w:end"] ??
+    indNode.attributes.end ??
+    indNode.attributes["w:right"] ??
+    indNode.attributes.right;
+  const firstLine = indNode.attributes["w:firstLine"] ?? indNode.attributes.firstLine;
+  const hanging = indNode.attributes["w:hanging"] ?? indNode.attributes.hanging;
+
+  if (left !== undefined) {
+    const value = Number.parseInt(left, 10);
+    if (Number.isFinite(value)) indentation.left = value;
+  }
+  if (right !== undefined) {
+    const value = Number.parseInt(right, 10);
+    if (Number.isFinite(value)) indentation.right = value;
+  }
+  if (firstLine !== undefined) {
+    const value = Number.parseInt(firstLine, 10);
+    if (Number.isFinite(value)) indentation.firstLine = value;
+  }
+  if (hanging !== undefined) {
+    const value = Number.parseInt(hanging, 10);
+    if (Number.isFinite(value)) indentation.hanging = value;
+  }
+
+  if (
+    indentation.left === undefined &&
+    indentation.right === undefined &&
+    indentation.firstLine === undefined &&
+    indentation.hanging === undefined
+  ) {
+    return undefined;
+  }
+
+  return indentation;
+}
+
+function readParagraphSpacing(node: XmlElementNode): ParagraphSpacing | undefined {
+  const spacingNode = findChildElementOptional(node, "spacing");
+  if (!spacingNode) {
+    return undefined;
+  }
+
+  const spacing: ParagraphSpacing = {};
+  const before = spacingNode.attributes["w:before"] ?? spacingNode.attributes.before;
+  const after = spacingNode.attributes["w:after"] ?? spacingNode.attributes.after;
+  const line = spacingNode.attributes["w:line"] ?? spacingNode.attributes.line;
+  const lineRule = spacingNode.attributes["w:lineRule"] ?? spacingNode.attributes.lineRule;
+
+  if (before !== undefined) {
+    const value = Number.parseInt(before, 10);
+    if (Number.isFinite(value)) spacing.before = value;
+  }
+  if (after !== undefined) {
+    const value = Number.parseInt(after, 10);
+    if (Number.isFinite(value)) spacing.after = value;
+  }
+  if (line !== undefined) {
+    const value = Number.parseInt(line, 10);
+    if (Number.isFinite(value)) spacing.line = value;
+  }
+  if (lineRule !== undefined) {
+    const normalized = lineRule.toLowerCase();
+    if (normalized === "auto" || normalized === "exact") {
+      spacing.lineRule = normalized;
+    } else if (normalized === "atleast") {
+      spacing.lineRule = "atLeast";
+    }
+  }
+
+  if (
+    spacing.before === undefined &&
+    spacing.after === undefined &&
+    spacing.line === undefined &&
+    spacing.lineRule === undefined
+  ) {
+    return undefined;
+  }
+
+  return spacing;
+}
+
+function readParagraphTabStops(node: XmlElementNode): TabStop[] | undefined {
+  const tabsNode = findChildElementOptional(node, "tabs");
+  if (!tabsNode) {
+    return undefined;
+  }
+
+  const tabStops: TabStop[] = [];
+  for (const child of tabsNode.children) {
+    if (child.type !== "element" || localName(child.name) !== "tab") {
+      continue;
+    }
+
+    const pos = child.attributes["w:pos"] ?? child.attributes.pos;
+    const val = (child.attributes["w:val"] ?? child.attributes.val ?? "left").toLowerCase();
+    const leader = (child.attributes["w:leader"] ?? child.attributes.leader ?? "none").toLowerCase();
+    if (pos === undefined) {
+      continue;
+    }
+
+    const position = Number.parseInt(pos, 10);
+    if (!Number.isFinite(position)) {
+      continue;
+    }
+
+    const align = (["left", "center", "right", "decimal", "num", "bar", "clear"] as const).includes(
+      val as TabStop["align"],
+    )
+      ? (val as TabStop["align"])
+      : "left";
+    const leaderValue =
+      leader === "none" ||
+      leader === "dot" ||
+      leader === "hyphen" ||
+      leader === "underscore" ||
+      leader === "heavy"
+        ? (leader as Exclude<TabStop["leader"], "middleDot">)
+        : leader === "middledot"
+          ? "middleDot"
+          : undefined;
+
+    tabStops.push({
+      position,
+      align,
+      ...(leaderValue && leaderValue !== "none" ? { leader: leaderValue } : {}),
+    });
+  }
+
+  return tabStops.length > 0 ? tabStops : undefined;
+}
+
+function readIsLegalNumberingValue(
+  isLegalNode: XmlElementNode | undefined,
+): boolean | undefined {
+  if (!isLegalNode) {
+    return undefined;
+  }
+
+  const rawValue = (
+    isLegalNode.attributes["w:val"] ??
+    isLegalNode.attributes.val ??
+    "1"
+  ).toLowerCase();
+
+  if (rawValue === "0" || rawValue === "false" || rawValue === "off") {
+    return false;
+  }
+
+  return true;
+}
+
 function findChildElement(node: XmlElementNode, childLocalName: string): XmlElementNode {
   const child = findChildElementOptional(node, childLocalName);
   if (!child) {

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

@@ -106,11 +106,24 @@ export function parseRevisionsFromDocumentXml(
     if (childType !== "p") {
       if (childType === "tbl") {
         parseTblPropertyRevisions(child, cursor, state);
+        const nested = parseNestedParagraphContainers(
+          child.children,
+          paragraphIndex,
+          cursor,
+          previousWasParagraph,
+          state,
+        );
+        paragraphIndex = nested.paragraphIndex;
+        cursor = nested.cursor;
+        previousWasParagraph = nested.previousWasParagraph;
       } else if (childType === "sectPr") {
         parseSectPrRevisions(child, cursor, state);
+        cursor += 1;
+        previousWasParagraph = false;
+      } else {
+        cursor += 1;
+        previousWasParagraph = false;
       }
-      cursor += 1;
-      previousWasParagraph = false;
       continue;
     }
 
@@ -140,6 +153,106 @@ export function parseRevisionsFromDocumentXml(
   };
 }
 
+function parseNestedParagraphContainers(
+  nodes: XmlNode[],
+  paragraphIndex: number,
+  cursor: number,
+  previousWasParagraph: boolean,
+  state: ParseState,
+): {
+  paragraphIndex: number;
+  cursor: number;
+  previousWasParagraph: boolean;
+} {
+  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 paragraphBoundary = state.boundaries[nextParagraphIndex];
+      if (!paragraphBoundary) {
+        continue;
+      }
+      parseParagraphMarkRevisions(node, paragraphBoundary, state);
+      walkParagraphContent(node.children, nextParagraphIndex, state, () => nextCursor, (next) => {
+        nextCursor = next;
+      });
+      nextPreviousWasParagraph = false;
+      continue;
+    }
+
+    if (
+      type === "tbl" ||
+      type === "tr" ||
+      type === "tc" ||
+      type === "sdtContent" ||
+      type === "customXml" ||
+      type === "smartTag"
+    ) {
+      const nested = parseNestedParagraphContainers(
+        node.children,
+        nextParagraphIndex,
+        nextCursor,
+        nextPreviousWasParagraph,
+        state,
+      );
+      nextParagraphIndex = nested.paragraphIndex;
+      nextCursor = nested.cursor;
+      nextPreviousWasParagraph = nested.previousWasParagraph;
+      continue;
+    }
+
+    if (
+      type === "tblPr" ||
+      type === "tblGrid" ||
+      type === "gridCol" ||
+      type === "trPr" ||
+      type === "tcPr"
+    ) {
+      continue;
+    }
+
+    nextCursor += 1;
+    nextPreviousWasParagraph = false;
+  }
+
+  return {
+    paragraphIndex: nextParagraphIndex,
+    cursor: nextCursor,
+    previousWasParagraph: nextPreviousWasParagraph,
+  };
+}
+
+export function parseRevisionsFromStoryXml(
+  storyXml: string,
+): ParsedRevisionsResult {
+  const xmlDeclMatch = storyXml.match(/^<\?xml[\s\S]*?\?>\s*/u);
+  const withoutDecl = xmlDeclMatch ? storyXml.slice(xmlDeclMatch[0].length) : storyXml;
+  const rootMatch = withoutDecl.match(/^<([A-Za-z0-9:._-]+)([^>]*)>([\s\S]*)<\/\1>\s*$/u);
+  if (!rootMatch) {
+    return {
+      revisions: [],
+      preservedMarkup: [],
+      diagnostics: [],
+      boundaries: [],
+    };
+  }
+
+  const innerXml = rootMatch[3] ?? "";
+  const wrapped =
+    `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>` +
+    `<w:document xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main">` +
+    `<w:body>${innerXml}</w:body></w:document>`;
+  return parseRevisionsFromDocumentXml(wrapped);
+}
+
 function parseParagraphMarkRevisions(
   paragraph: XmlElementNode,
   boundary: RevisionParagraphBoundary,
@@ -225,6 +338,7 @@ function parseParagraphMarkRevisions(
           createdAt: metadata.createdAt,
           metadata: {
             source: "import",
+            semanticKind: "structural-change",
             importedRevisionForm:
               type === "ins" ? "paragraph-insertion" : "paragraph-deletion",
             originalRevisionType: `paragraph-${type}`,
@@ -444,7 +558,7 @@ function walkContentNode(
         .filter((child): child is XmlElementNode["children"][number] & { type: "text" } => child.type === "text")
         .map((child) => child.text)
         .join("");
-      setCursor(getCursor() + text.length);
+      setCursor(getCursor() + Array.from(text).length);
       return;
     }
     case "tab":
@@ -914,7 +1028,7 @@ function measureStoryLength(node: XmlNode): number {
     case "delInstrText":
       return node.children
         .filter((child): child is XmlElementNode["children"][number] & { type: "text" } => child.type === "text")
-        .map((child) => child.text.length)
+        .map((child) => Array.from(child.text).length)
         .reduce((total, length) => total + length, 0);
     case "tab":
     case "br":