@lotics/docx 0.1.0

package/src/pm/docx_to_pm.ts

@@ -0,0 +1,643 @@
+import { Mark, Node as PMNode } from "prosemirror-model";
+import {
+  getChildren,
+  getTagName,
+  getTextContent,
+  isTextNode,
+  type XmlElement,
+} from "@lotics/ooxml/xml";
+import {
+  EMPTY_PARAGRAPH_PROPERTIES,
+  EMPTY_RUN_PROPERTIES,
+  extractParagraphProperties,
+  extractRunProperties,
+  type ParagraphProperties,
+  type RunProperties,
+} from "../model/properties";
+import { parseSectionProperties } from "../parse/sections";
+import { parseDrawing } from "../parse/drawing";
+import {
+  resolveParagraphProperties,
+  resolveRunProperties,
+} from "../model/style_resolution";
+import type { StyleTable } from "../model/style_table";
+import type { NumberingTable } from "../model/numbering_table";
+import {
+  computeLabel,
+  createNumberingState,
+} from "../render/numbering_counter";
+import type { Block, DocxDocument, Inline, Run, RunChild } from "../model/types";
+import { docxSchema } from "./schema";
+import { xmlToTableNode } from "./table_convert";
+import { parseBlockXml } from "../parse/parser";
+
+const MARK_PROPERTY_TAGS = new Set([
+  "w:rStyle",
+  "w:b",
+  "w:i",
+  "w:u",
+  "w:strike",
+  "w:dstrike",
+  "w:caps",
+  "w:smallCaps",
+  "w:color",
+  "w:highlight",
+  "w:sz",
+  "w:rFonts",
+  "w:vertAlign",
+]);
+
+function partitionRunProperties(
+  rPr: readonly XmlElement[] | null,
+): { recognized: RunProperties; unknown: XmlElement[] } {
+  if (rPr === null) {
+    return { recognized: { ...EMPTY_RUN_PROPERTIES }, unknown: [] };
+  }
+  const recognizedEls: XmlElement[] = [];
+  const unknown: XmlElement[] = [];
+  for (const el of rPr) {
+    const tag = getTagName(el);
+    if (tag && MARK_PROPERTY_TAGS.has(tag)) {
+      recognizedEls.push(el);
+    } else {
+      unknown.push(el);
+    }
+  }
+  return { recognized: extractRunProperties(recognizedEls), unknown };
+}
+
+const PARAGRAPH_PROPERTY_TAGS = new Set([
+  "w:pStyle",
+  "w:jc",
+  "w:ind",
+  "w:spacing",
+  "w:numPr",
+  "w:pageBreakBefore",
+  "w:keepLines",
+  "w:keepNext",
+  "w:widowControl",
+  "w:outlineLvl",
+]);
+
+function partitionParagraphProperties(
+  pPr: readonly XmlElement[] | null,
+): { recognized: ParagraphProperties; unknown: XmlElement[] } {
+  if (pPr === null) {
+    return { recognized: { ...EMPTY_PARAGRAPH_PROPERTIES }, unknown: [] };
+  }
+  const recognizedEls: XmlElement[] = [];
+  const unknown: XmlElement[] = [];
+  for (const el of pPr) {
+    const tag = getTagName(el);
+    if (tag === "w:sectPr") continue;
+    if (tag && PARAGRAPH_PROPERTY_TAGS.has(tag)) {
+      recognizedEls.push(el);
+    } else {
+      unknown.push(el);
+    }
+  }
+  return { recognized: extractParagraphProperties(recognizedEls), unknown };
+}
+
+function findInlineSectPr(pPr: readonly XmlElement[] | null): XmlElement | null {
+  if (pPr === null) return null;
+  for (const el of pPr) {
+    if (getTagName(el) === "w:sectPr") return el;
+  }
+  return null;
+}
+
+function marksFromRunProperties(props: RunProperties): readonly Mark[] {
+  const out: Mark[] = [];
+  const m = docxSchema.marks;
+  if (props.bold === true) out.push(m.bold.create());
+  if (props.italic === true) out.push(m.italic.create());
+  if (props.underline !== null) out.push(m.underline.create());
+  if (props.strike === true) out.push(m.strike.create());
+  if (props.doubleStrike === true) out.push(m.doubleStrike.create());
+  if (props.caps === true) out.push(m.caps.create());
+  if (props.smallCaps === true) out.push(m.smallCaps.create());
+  if (props.vertAlign === "superscript") out.push(m.superscript.create());
+  if (props.vertAlign === "subscript") out.push(m.subscript.create());
+  if (props.color !== null) out.push(m.color.create({ value: props.color }));
+  if (props.highlight !== null) {
+    out.push(m.highlight.create({ value: props.highlight }));
+  }
+  if (
+    props.fontAscii !== null ||
+    props.fontHAnsi !== null ||
+    props.fontEastAsia !== null ||
+    props.fontComplexScript !== null
+  ) {
+    out.push(
+      m.font.create({
+        ascii: props.fontAscii,
+        hAnsi: props.fontHAnsi,
+        eastAsia: props.fontEastAsia,
+        complexScript: props.fontComplexScript,
+      }),
+    );
+  }
+  if (props.size !== null) {
+    out.push(m.size.create({ halfPoints: props.size }));
+  }
+  if (props.styleId !== null) {
+    out.push(m.styleRef.create({ styleId: props.styleId }));
+  }
+  return out;
+}
+
+type ConvertState = {
+  footnoteNumberFor(id: string): number;
+};
+
+function createConvertState(): ConvertState {
+  const counter = new Map<string, number>();
+  let next = 1;
+  return {
+    footnoteNumberFor(id: string): number {
+      const cached = counter.get(id);
+      if (cached !== undefined) return cached;
+      const n = next++;
+      counter.set(id, n);
+      return n;
+    },
+  };
+}
+
+function convertRunChild(
+  child: RunChild,
+  marks: readonly Mark[],
+  state: ConvertState,
+): PMNode[] {
+  if (child.kind === "text") {
+    if (child.value.length === 0) return [];
+    return [docxSchema.text(child.value, marks)];
+  }
+  const tag = getTagName(child.xml);
+  if (tag === "w:br") {
+    const attrs = (child.xml[":@"] ?? {}) as Record<string, string>;
+    const rawType = attrs["@_w:type"];
+    const breakType =
+      rawType === "page" || rawType === "column" ? rawType : "line";
+    return [
+      docxSchema.nodes.hard_break.create({ breakType }, undefined, marks),
+    ];
+  }
+  if (tag === "w:footnoteReference") {
+    const attrs = (child.xml[":@"] ?? {}) as Record<string, string>;
+    const id = attrs["@_w:id"] ?? "";
+    return [
+      docxSchema.nodes.footnote_ref.create(
+        { footnoteId: id, number: state.footnoteNumberFor(id) },
+        undefined,
+        marks,
+      ),
+    ];
+  }
+  if (tag === "w:drawing") {
+    const info = parseDrawing(child.xml);
+    if (info) {
+      return [
+        docxSchema.nodes.image_inline.create(
+          {
+            relationshipId: info.relationshipId,
+            widthEmu: info.widthEmu,
+            heightEmu: info.heightEmu,
+            alt: info.alt,
+            originalXml: child.xml,
+            wrap: info.wrap,
+            floatSide: info.floatSide,
+            behindDoc: info.behindDoc,
+            offsetXEmu: info.offsetXEmu,
+            offsetYEmu: info.offsetYEmu,
+          },
+          undefined,
+          marks,
+        ),
+      ];
+    }
+  }
+  return [
+    docxSchema.nodes.opaque_inline.create({ xml: child.xml }, undefined, marks),
+  ];
+}
+
+function convertRun(run: Run, state: ConvertState): PMNode[] {
+  const partitioned = partitionRunProperties(run.properties);
+  const marks = marksFromRunProperties(partitioned.recognized);
+  const out: PMNode[] = [];
+  for (const child of run.content) {
+    for (const node of convertRunChild(child, marks, state)) {
+      out.push(node);
+    }
+  }
+  return out;
+}
+
+function getAttrFromXml(xml: XmlElement, key: string): string | undefined {
+  const attrs = xml[":@"] as Record<string, string> | undefined;
+  return attrs?.[`@_${key}`];
+}
+
+function convertHyperlink(xml: XmlElement): PMNode[] {
+  const relationshipId = getAttrFromXml(xml, "r:id") ?? null;
+  const anchor = getAttrFromXml(xml, "w:anchor") ?? null;
+
+  const linkMark = docxSchema.marks.link.create({
+    relationshipId,
+    anchor,
+  });
+
+  const out: PMNode[] = [];
+  for (const child of getChildren(xml)) {
+    if (getTagName(child) !== "w:r") continue;
+
+    const runProps: XmlElement[] = [];
+
+    let runPropertiesElems: XmlElement[] | null = null;
+    const runChildren: XmlElement[] = [];
+    for (const rc of getChildren(child)) {
+      if (isTextNode(rc)) continue;
+      if (getTagName(rc) === "w:rPr") {
+        runPropertiesElems = getChildren(rc).filter((p) => !isTextNode(p));
+      } else {
+        runChildren.push(rc);
+      }
+    }
+
+    if (runPropertiesElems) {
+      for (const rp of runPropertiesElems) runProps.push(rp);
+    }
+
+    const partitionedRun = partitionRunProperties(
+      runPropertiesElems !== null ? runProps : null,
+    );
+    const baseMarks = marksFromRunProperties(partitionedRun.recognized);
+    const allMarks = [...baseMarks, linkMark];
+
+    for (const rcXml of runChildren) {
+      const rcTag = getTagName(rcXml);
+      if (rcTag === "w:t") {
+        const value = getTextContent(rcXml);
+        if (value.length > 0) out.push(docxSchema.text(value, allMarks));
+        continue;
+      }
+      if (rcTag === "w:br") {
+        const attrs = (rcXml[":@"] ?? {}) as Record<string, string>;
+        const rawType = attrs["@_w:type"];
+        const breakType =
+          rawType === "page" || rawType === "column" ? rawType : "line";
+        out.push(
+          docxSchema.nodes.hard_break.create(
+            { breakType },
+            undefined,
+            allMarks,
+          ),
+        );
+        continue;
+      }
+      out.push(
+        docxSchema.nodes.opaque_inline.create({ xml: rcXml }, undefined, allMarks),
+      );
+    }
+  }
+  return out;
+}
+
+function convertBookmarkStart(xml: XmlElement): PMNode {
+  const attrs = (xml[":@"] ?? {}) as Record<string, string>;
+  return docxSchema.nodes.bookmark_start.create({
+    bookmarkId: attrs["@_w:id"] ?? "",
+    name: attrs["@_w:name"] ?? "",
+  });
+}
+
+function convertBookmarkEnd(xml: XmlElement): PMNode {
+  const attrs = (xml[":@"] ?? {}) as Record<string, string>;
+  return docxSchema.nodes.bookmark_end.create({
+    bookmarkId: attrs["@_w:id"] ?? "",
+  });
+}
+
+function parseInnerRun(runXml: XmlElement): Run {
+  const properties: XmlElement[] = [];
+  const content: RunChild[] = [];
+  let propertiesSeen = false;
+
+  for (const child of getChildren(runXml)) {
+    if (isTextNode(child)) continue;
+    const tag = getTagName(child);
+    if (tag === "w:rPr") {
+      propertiesSeen = true;
+      for (const propEl of getChildren(child)) {
+        if (isTextNode(propEl)) continue;
+        properties.push(propEl);
+      }
+      continue;
+    }
+    if (tag === "w:t") {
+      const attrs = (child[":@"] ?? {}) as Record<string, string>;
+      content.push({
+        kind: "text",
+        value: getTextContent(child),
+        preserveSpace: attrs["@_xml:space"] === "preserve",
+      });
+      continue;
+    }
+    content.push({ kind: "opaque_run_child", xml: child });
+  }
+
+  return {
+    kind: "run",
+    properties: propertiesSeen ? properties : null,
+    content,
+  };
+}
+
+function convertTrackedWrapper(
+  xml: XmlElement,
+  markName: "insertion" | "deletion",
+  state: ConvertState,
+): PMNode[] {
+  const tagName = Object.keys(xml).find((k) => k !== ":@");
+  if (!tagName) return [];
+  const attrs = (xml[":@"] ?? {}) as Record<string, string>;
+  const mark = docxSchema.marks[markName].create({
+    author: attrs["@_w:author"] ?? null,
+    date: attrs["@_w:date"] ?? null,
+    revisionId: attrs["@_w:id"] ?? null,
+  });
+  const inner: PMNode[] = [];
+  const children = (xml[tagName] as XmlElement[]) ?? [];
+  for (const child of children) {
+    const childTag = Object.keys(child).find((k) => k !== ":@");
+    if (childTag !== "w:r") continue;
+    const run = parseInnerRun(child);
+    for (const node of convertRun(run, state)) {
+      inner.push(node.mark(node.marks.concat(mark)));
+    }
+  }
+  return inner;
+}
+
+function convertInline(inline: Inline, state: ConvertState): PMNode[] {
+  if (inline.kind === "run") return convertRun(inline, state);
+  const tag = getTagName(inline.xml);
+  if (tag === "w:hyperlink") {
+    return convertHyperlink(inline.xml);
+  }
+  if (tag === "w:bookmarkStart") {
+    return [convertBookmarkStart(inline.xml)];
+  }
+  if (tag === "w:bookmarkEnd") {
+    return [convertBookmarkEnd(inline.xml)];
+  }
+  if (tag === "w:ins") {
+    return convertTrackedWrapper(inline.xml, "insertion", state);
+  }
+  if (tag === "w:del") {
+    return convertTrackedWrapper(inline.xml, "deletion", state);
+  }
+  return [docxSchema.nodes.opaque_inline.create({ xml: inline.xml })];
+}
+
+type FldPhase = "instruction" | "result";
+
+function inlineFldCharType(
+  inline: Inline,
+): "begin" | "separate" | "end" | null {
+  if (inline.kind !== "run") return null;
+  for (const c of inline.content) {
+    if (c.kind === "opaque_run_child") {
+      const tag = getTagName(c.xml);
+      if (tag === "w:fldChar") {
+        const attrs = (c.xml[":@"] ?? {}) as Record<string, string>;
+        const t = attrs["@_w:fldCharType"];
+        if (t === "begin" || t === "separate" || t === "end") return t;
+      }
+    }
+  }
+  return null;
+}
+
+function instrTextFromRun(inline: Inline): string {
+  if (inline.kind !== "run") return "";
+  let out = "";
+  for (const c of inline.content) {
+    if (c.kind === "opaque_run_child" && getTagName(c.xml) === "w:instrText") {
+      out += getTextContent(c.xml);
+    }
+  }
+  return out;
+}
+
+function textFromRunForFieldResult(inline: Inline): string {
+  if (inline.kind !== "run") return "";
+  let out = "";
+  for (const c of inline.content) {
+    if (c.kind === "text") out += c.value;
+  }
+  return out;
+}
+
+function buildFieldInline(
+  instruction: string,
+  cachedResult: string,
+): PMNode {
+  return docxSchema.nodes.field_inline.create({
+    instruction: instruction.trim(),
+    cachedResult,
+  });
+}
+
+function convertParagraphInlines(
+  content: readonly Inline[],
+  state: ConvertState,
+): PMNode[] {
+  const out: PMNode[] = [];
+  let i = 0;
+  while (i < content.length) {
+    const inline = content[i];
+    if (inlineFldCharType(inline) === "begin") {
+      let j = i + 1;
+      let phase: FldPhase = "instruction";
+      let instruction = "";
+      let cachedResult = "";
+      while (j < content.length) {
+        const next = content[j];
+        const t = inlineFldCharType(next);
+        if (t === "separate") {
+          phase = "result";
+          j += 1;
+          continue;
+        }
+        if (t === "end") {
+          j += 1;
+          break;
+        }
+        if (phase === "instruction") {
+          instruction += instrTextFromRun(next);
+        } else {
+          cachedResult += textFromRunForFieldResult(next);
+        }
+        j += 1;
+      }
+      out.push(buildFieldInline(instruction, cachedResult));
+      i = j;
+      continue;
+    }
+    for (const node of convertInline(inline, state)) {
+      out.push(node);
+    }
+    i += 1;
+  }
+  return out;
+}
+
+function convertParagraph(
+  block: Extract<Block, { kind: "paragraph" }>,
+  styleTable: StyleTable | null,
+  numberingLabel: string | null,
+  state: ConvertState,
+): PMNode {
+  const partitioned = partitionParagraphProperties(block.properties);
+  const inline = convertParagraphInlines(block.content, state);
+  const resolvedProperties = styleTable
+    ? resolveParagraphProperties(styleTable, partitioned.recognized)
+    : null;
+  const resolvedBaseRun = styleTable
+    ? resolveRunProperties(
+        styleTable,
+        partitioned.recognized.styleId,
+        { ...EMPTY_RUN_PROPERTIES },
+      )
+    : null;
+  return docxSchema.nodes.paragraph.create(
+    {
+      properties: partitioned.recognized,
+      unknownProperties: partitioned.unknown,
+      resolvedProperties,
+      resolvedBaseRun,
+      numberingLabel,
+    },
+    inline,
+  );
+}
+
+function convertOpaqueBlock(xml: XmlElement): PMNode {
+  return docxSchema.nodes.opaque_block.create({ xml });
+}
+
+function convertSectionBreak(xml: XmlElement, isFinal: boolean): PMNode {
+  return docxSchema.nodes.section_break.create({
+    properties: parseSectionProperties(xml),
+    isFinal,
+  });
+}
+
+export type DocxToPmContext = {
+  styleTable?: StyleTable | null;
+  numberingTable?: NumberingTable | null;
+};
+
+export function docxToPm(
+  doc: DocxDocument,
+  context: DocxToPmContext = {},
+): PMNode {
+  const styleTable = context.styleTable ?? null;
+  const numberingTable = context.numberingTable ?? null;
+  const numberingState = createNumberingState();
+  const state = createConvertState();
+
+  const out: PMNode[] = [];
+
+  for (let i = 0; i < doc.body.children.length; i++) {
+    const block = doc.body.children[i];
+
+    if (block.kind === "paragraph") {
+      const partitioned = partitionParagraphProperties(block.properties);
+      let label: string | null = null;
+      if (numberingTable && partitioned.recognized.numbering) {
+        label = computeLabel(
+          numberingState,
+          numberingTable,
+          partitioned.recognized.numbering.numId,
+          partitioned.recognized.numbering.ilvl,
+        );
+      }
+      out.push(convertParagraph(block, styleTable, label, state));
+      const inlineSect = findInlineSectPr(block.properties);
+      if (inlineSect !== null) {
+        out.push(convertSectionBreak(inlineSect, false));
+      }
+      continue;
+    }
+
+    if (block.kind === "body_sect_pr") {
+      out.push(convertSectionBreak(block.xml, true));
+      continue;
+    }
+
+    const tag = getTagName(block.xml);
+    if (tag === "w:tbl") {
+      const tableNode = xmlToTableNode(block.xml, (xml) =>
+        convertBlockFromXml(
+          xml,
+          styleTable,
+          numberingTable,
+          numberingState,
+          state,
+        ),
+      );
+      if (tableNode) {
+        out.push(tableNode);
+        continue;
+      }
+    }
+    out.push(convertOpaqueBlock(block.xml));
+  }
+
+  if (out.length === 0) {
+    out.push(docxSchema.nodes.paragraph.create());
+  }
+
+  return docxSchema.nodes.doc.createChecked(null, out);
+}
+
+function convertBlockFromXml(
+  xml: XmlElement,
+  styleTable: StyleTable | null,
+  numberingTable: NumberingTable | null,
+  numberingState: ReturnType<typeof createNumberingState>,
+  state: ConvertState,
+): PMNode | null {
+  const tag = getTagName(xml);
+  if (tag === "w:p") {
+    const block = parseBlockXml(xml);
+    if (block.kind !== "paragraph") return null;
+    const partitioned = partitionParagraphProperties(block.properties);
+    let label: string | null = null;
+    if (numberingTable && partitioned.recognized.numbering) {
+      label = computeLabel(
+        numberingState,
+        numberingTable,
+        partitioned.recognized.numbering.numId,
+        partitioned.recognized.numbering.ilvl,
+      );
+    }
+    return convertParagraph(block, styleTable, label, state);
+  }
+  if (tag === "w:tbl") {
+    return xmlToTableNode(xml, (childXml) =>
+      convertBlockFromXml(
+        childXml,
+        styleTable,
+        numberingTable,
+        numberingState,
+        state,
+      ),
+    );
+  }
+  return null;
+}