@portone/docx-editor 0.1.0

package/dist/docx/importDocx.js

@@ -0,0 +1,263 @@
+// src/docx/importDocx.ts
+import { Fragment } from "prosemirror-model";
+import { toRunFormat } from "../model/format.js";
+import { parseNumbering } from "../numbering/parseNumbering.js";
+import { DocxImportError } from "../ooxml/errors.js";
+import {
+  childByLocalName,
+  decodeUtf8,
+  elementChildren,
+  localPart,
+  parseXml,
+  R_NS
+} from "../ooxml/xml.js";
+import { docxSchema } from "../schema/index.js";
+import { commentReferencesIn, readComments } from "./comments.js";
+import { openParts } from "./container.js";
+import { DEFAULT_TAB_STOP_PT, readDefaultTabStop } from "./documentSettings.js";
+import {
+  defaultParagraphStyleIdOf,
+  defaultTableStyleIdOf,
+  effectiveParagraphFormat,
+  effectiveParagraphStyle,
+  layerRunFormat,
+  NO_DOCUMENT_DEFAULTS,
+  NO_STYLES,
+  readDefaultParagraphFormat,
+  readDocumentDefaults,
+  readParagraphStyles,
+  readStyles
+} from "./formatting.js";
+import { readHeadersFooters } from "./headersFooters.js";
+import { readLinkTargets } from "./hyperlink.js";
+import { buildParagraph } from "./importParagraph.js";
+import { buildTable } from "./importTable.js";
+import { readImageSources } from "./media.js";
+import { readNotes } from "./notes.js";
+import { readBodyGeometry } from "./pageGeometry.js";
+import { resolveTarget } from "./relationships.js";
+import { scanBody } from "./scan.js";
+import { SessionStore } from "./session.js";
+import { NO_THEME_FONTS, readThemeFonts } from "./theme.js";
+var OFFICE_DOCUMENT_REL = `${R_NS}/officeDocument`;
+var STYLES_REL = `${R_NS}/styles`;
+var NUMBERING_REL = `${R_NS}/numbering`;
+var THEME_REL = `${R_NS}/theme`;
+var SETTINGS_REL = `${R_NS}/settings`;
+function relationshipTarget(parts, relsPath, type) {
+  const rels = parts.get(relsPath);
+  if (!rels) return null;
+  for (const rel of elementChildren(
+    parseXml(decodeUtf8(rels).text).documentElement
+  )) {
+    if (rel.getAttribute("Type") === type) return rel.getAttribute("Target");
+  }
+  return null;
+}
+function findMainPartPath(parts) {
+  const target = relationshipTarget(parts, "_rels/.rels", OFFICE_DOCUMENT_REL);
+  if (!target) {
+    throw new DocxImportError(
+      "missing-part",
+      "no relationship pointing at the main document part"
+    );
+  }
+  return target.replace(/^\//, "");
+}
+function relatedPartPath(parts, mainPartPath, type) {
+  const directory = mainPartPath.replace(/[^/]+$/, "");
+  const fileName = mainPartPath.slice(directory.length);
+  const target = relationshipTarget(
+    parts,
+    `${directory}_rels/${fileName}.rels`,
+    type
+  );
+  if (!target) return null;
+  return resolveTarget(mainPartPath, target);
+}
+function readPart(parts, path) {
+  const bytes = path === null ? void 0 : parts.get(path);
+  return bytes ? decodeUtf8(bytes).text : null;
+}
+function buildBlock(el, srcId, sources, styles, defaultTableStyleId) {
+  if (el.localName === "bookmarkStart" || el.localName === "bookmarkEnd") {
+    return docxSchema.nodes.bookmarkBlock.create({
+      srcId,
+      name: el.nodeName
+    });
+  }
+  if (el.localName === "p") {
+    const paragraph = buildParagraph(el, srcId, sources);
+    if (paragraph) return paragraph;
+  }
+  if (el.localName === "tbl") {
+    const table = buildTable(el, srcId, sources, styles, defaultTableStyleId);
+    if (table) return table;
+  }
+  return docxSchema.nodes.docxRaw.create({ srcId, name: el.nodeName });
+}
+function styledInline(node, style) {
+  const mark = node.marks.find((entry) => entry.type === docxSchema.marks.run);
+  if (!mark) return node;
+  const format = layerRunFormat(style, toRunFormat(mark.attrs.format));
+  const next = mark.type.create({ ...mark.attrs, format });
+  return node.mark(next.addToSet(node.marks));
+}
+function styledParagraph(node, context) {
+  const style = effectiveParagraphStyle(node.attrs.pPr, context);
+  const inline = style ? node.children.map((child) => styledInline(child, style.run)) : node.children;
+  return node.type.create(
+    {
+      ...node.attrs,
+      format: effectiveParagraphFormat(node.attrs.pPr, context),
+      styleRun: style ? layerRunFormat(style.run, null) : null
+    },
+    Fragment.fromArray(inline),
+    node.marks
+  );
+}
+function withStyleFormats(node, context) {
+  if (node.type === docxSchema.nodes.paragraph) {
+    return styledParagraph(node, context);
+  }
+  if (node.childCount === 0) return node;
+  const children = node.children.map(
+    (child) => withStyleFormats(child, context)
+  );
+  if (children.every((child, i) => child === node.child(i))) return node;
+  return node.copy(Fragment.fromArray(children));
+}
+function assertScanMatchesDom(children, scan) {
+  if (children.length !== scan.blocks.length) {
+    throw new DocxImportError(
+      "malformed-xml",
+      "the body block count differs between the scan and the DOM"
+    );
+  }
+  children.forEach((el, i) => {
+    if (el.nodeName !== scan.blocks[i].name) {
+      throw new DocxImportError(
+        "malformed-xml",
+        `body block names disagree: ${el.nodeName} vs ${scan.blocks[i].name}`
+      );
+    }
+  });
+}
+function foldTrailingSectPr(scan) {
+  const last = scan.blocks.at(-1);
+  if (scan.blocks.length < 2 || !last) return scan;
+  if (localPart(last.name) !== "sectPr") return scan;
+  return {
+    prefix: scan.prefix,
+    blocks: scan.blocks.slice(0, -1),
+    suffix: last.xml + scan.suffix
+  };
+}
+function importDocx(input) {
+  const bytes = input instanceof Uint8Array ? input : new Uint8Array(input);
+  const parts = openParts(bytes);
+  const mainPartPath = findMainPartPath(parts);
+  const mainPart = parts.get(mainPartPath);
+  if (!mainPart) {
+    throw new DocxImportError("missing-part", `${mainPartPath} is missing`);
+  }
+  const { text: source, hadBom } = decodeUtf8(mainPart);
+  const scanned = scanBody(source);
+  const dom = parseXml(source);
+  const body = childByLocalName(dom.documentElement, "body");
+  if (!body) {
+    throw new DocxImportError("missing-body", "document has no w:body");
+  }
+  const children = elementChildren(body);
+  assertScanMatchesDom(children, scanned);
+  const geometry = readBodyGeometry(body);
+  const scan = foldTrailingSectPr(scanned);
+  const blockElements = children.slice(0, scan.blocks.length);
+  const stylesXml = readPart(
+    parts,
+    relatedPartPath(parts, mainPartPath, STYLES_REL)
+  );
+  const stylesDom = stylesXml === null ? null : parseXml(stylesXml);
+  const settingsXml = readPart(
+    parts,
+    relatedPartPath(parts, mainPartPath, SETTINGS_REL)
+  );
+  const defaultTabStopPt = readDefaultTabStop(settingsXml === null ? null : parseXml(settingsXml)) ?? DEFAULT_TAB_STOP_PT;
+  const numberingPartPath = relatedPartPath(parts, mainPartPath, NUMBERING_REL);
+  const themeXml = readPart(
+    parts,
+    relatedPartPath(parts, mainPartPath, THEME_REL)
+  );
+  const themeFonts = themeXml === null ? NO_THEME_FONTS : readThemeFonts(parseXml(themeXml));
+  const styles = stylesDom ? readStyles(stylesDom, themeFonts) : NO_STYLES;
+  const defaultTableStyleId = stylesDom ? defaultTableStyleIdOf(stylesDom) : null;
+  const defaultParagraphStyleId = stylesDom ? defaultParagraphStyleIdOf(stylesDom) : null;
+  const paragraphDefaults = stylesDom ? readDefaultParagraphFormat(stylesDom) : {};
+  const numberingXml = readPart(parts, numberingPartPath);
+  const numbering = parseNumbering(numberingXml);
+  const paragraphFormatting = {
+    styles,
+    defaultStyleId: defaultParagraphStyleId,
+    defaults: paragraphDefaults,
+    numbering
+  };
+  const comments = readComments(parts, mainPartPath);
+  const notes = readNotes(parts, mainPartPath);
+  const noteLabels = {
+    footnote: /* @__PURE__ */ new Map(),
+    endnote: /* @__PURE__ */ new Map()
+  };
+  const noteLabel = (kind, id) => {
+    const labels = noteLabels[kind];
+    const existing = labels.get(id);
+    if (existing) return existing;
+    const label = `${labels.size + 1}`;
+    labels.set(id, label);
+    return label;
+  };
+  const headersFooters = readHeadersFooters(parts, mainPartPath, body);
+  const sources = {
+    images: readImageSources(parts, mainPartPath),
+    themeFonts,
+    links: readLinkTargets(parts, mainPartPath),
+    comments,
+    notes,
+    noteLabel
+  };
+  const blockNodes = blockElements.map(
+    (el, i) => withStyleFormats(
+      buildBlock(el, i, sources, styles, defaultTableStyleId),
+      paragraphFormatting
+    )
+  );
+  return {
+    doc: docxSchema.nodes.doc.create(null, blockNodes),
+    session: new SessionStore({
+      parts,
+      mainPartPath,
+      documentPrefix: scan.prefix,
+      documentSuffix: scan.suffix,
+      documentHadBom: hadBom,
+      blocks: blockNodes.map((node, i) => ({ xml: scan.blocks[i].xml, node })),
+      defaults: stylesDom ? readDocumentDefaults(stylesDom, themeFonts) : NO_DOCUMENT_DEFAULTS,
+      defaultTabStopPt,
+      paragraphDefaults,
+      geometry,
+      styles,
+      paragraphStyles: stylesDom ? readParagraphStyles(stylesDom) : [],
+      defaultParagraphStyleId,
+      numberingXml,
+      numberingPartPath,
+      comments,
+      commentReferenceIds: new Set(
+        commentReferencesIn(
+          docxSchema.nodes.doc.create(null, blockNodes)
+        ).keys()
+      ),
+      headersFooters
+    })
+  };
+}
+export {
+  importDocx
+};

package/dist/docx/importParagraph.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Moves a single `<w:p>` into an editable paragraph node.
+ *
+ * Body paragraphs and paragraphs inside table cells take the same path.
+ *
+ * A `w:sdt` content control and a `w:hyperlink` standing inside the paragraph are both unwrapped, so
+ * the text they hold stays editable, and the wrapper each came in rides along on a mark to go back
+ * out around the same text. A control may hold a link; a link holding a control is a nesting the
+ * marks cannot record in that order, so the paragraph stays preserved.
+ */
+import type { Node as PMNode } from "prosemirror-model";
+import { type ImportedComments } from "./comments";
+import { type LinkTargets } from "./hyperlink";
+import type { ImageSources } from "./media";
+import { type ImportedNotes, type NoteKind } from "./notes";
+import { type ThemeFonts } from "./theme";
+/**
+ * What the body is read with: the images its drawings can point at, the fonts a theme reference
+ * resolves to, the addresses its links can point at, and the bodies of its comments and notes.
+ * They travel together from `docx/importDocx` down through the tables to here.
+ */
+export interface ImportSources {
+    images: ImageSources;
+    themeFonts: ThemeFonts;
+    links: LinkTargets;
+    comments: ImportedComments;
+    notes: ImportedNotes;
+    noteLabel: (kind: NoteKind, id: string) => string;
+}
+export declare const NO_IMPORT_SOURCES: ImportSources;
+/** Moves a paragraph into an editable node. null if it holds content we do not model */
+export declare function buildParagraph(el: Element, srcId: number | null, sources?: ImportSources): PMNode | null;

package/dist/docx/importParagraph.js

@@ -0,0 +1,308 @@
+// src/docx/importParagraph.ts
+import { readDrawingPicture } from "../ooxml/image.js";
+import {
+  attrString,
+  childByLocalName,
+  elementChildren,
+  serializeXml
+} from "../ooxml/xml.js";
+import { docxSchema } from "../schema/index.js";
+import {
+  commentParaId,
+  importedCommentReplies,
+  NO_COMMENTS
+} from "./comments.js";
+import { readParagraphFormat, readRunFormat } from "./formatting.js";
+import {
+  NO_LINK_TARGETS,
+  readHyperlinkWrapper
+} from "./hyperlink.js";
+import { NO_IMAGES } from "./media.js";
+import { NO_NOTES, noteById } from "./notes.js";
+import { readSdtWrapper } from "./sdt.js";
+import { NO_THEME_FONTS } from "./theme.js";
+function runMark(run, themeFonts) {
+  const rPr = childByLocalName(run, "rPr");
+  return docxSchema.marks.run.create({
+    rPr: rPr ? serializeXml(rPr) : null,
+    rAttrs: attrString(run),
+    format: readRunFormat(rPr, themeFonts)
+  });
+}
+function buildImage(el, marks, images) {
+  const picture = readDrawingPicture(el);
+  if (!picture) return null;
+  const src = images.get(picture.relId);
+  if (src === void 0) return null;
+  return docxSchema.nodes.image.create(
+    {
+      src,
+      extent: picture.extent,
+      alt: picture.alt,
+      xml: serializeXml(el)
+    },
+    null,
+    marks
+  );
+}
+function buildRunChild(el, marks, images, comments, notes, noteLabel) {
+  switch (el.localName) {
+    case "t": {
+      const text = el.textContent ?? "";
+      return text ? [docxSchema.text(text, marks)] : [];
+    }
+    case "br":
+      return [
+        docxSchema.nodes.hardBreak.create(
+          { brAttrs: attrString(el) },
+          null,
+          marks
+        )
+      ];
+    case "tab":
+      return [
+        docxSchema.text(
+          "	",
+          docxSchema.marks.tab.create({ tabAttrs: attrString(el) }).addToSet(marks)
+        )
+      ];
+    case "drawing": {
+      const image = buildImage(el, marks, images);
+      return image === null ? null : [image];
+    }
+    case "commentReference": {
+      const id = annotationId(el);
+      if (id === null) return null;
+      const comment = comments.byId.get(id);
+      const paraId = comment?.paraId ?? commentParaId(`comment-${id}`);
+      return [
+        docxSchema.nodes.commentReference.create(
+          {
+            id,
+            referenceXml: serializeXml(el),
+            author: comment?.author ?? null,
+            initials: comment?.initials ?? null,
+            date: comment?.date ?? null,
+            text: comment?.text ?? "",
+            commentXml: comment?.xml ?? null,
+            imported: true,
+            paraId,
+            resolved: comment?.resolved ?? false,
+            extensionXml: comment?.extensionXml ?? null,
+            threadImported: true,
+            replies: importedCommentReplies(comments, id)
+          },
+          null,
+          marks
+        )
+      ];
+    }
+    case "footnoteReference":
+    case "endnoteReference": {
+      const id = annotationId(el);
+      if (id === null) return null;
+      const kind = el.localName === "footnoteReference" ? "footnote" : "endnote";
+      const note = noteById(notes, kind, id);
+      const customMarkFollows = Array.from(el.attributes).some(
+        (entry) => entry.localName === "customMarkFollows" && !["0", "false", "off"].includes(entry.value)
+      );
+      return [
+        docxSchema.nodes.noteReference.create(
+          {
+            kind,
+            id,
+            label: note ? noteLabel(kind, id) : "?",
+            text: note?.text ?? "",
+            customMarkFollows,
+            referenceXml: serializeXml(el)
+          },
+          null,
+          marks
+        )
+      ];
+    }
+    default:
+      return null;
+  }
+}
+function buildRunNodes(run, images, themeFonts, comments, notes, noteLabel, wrappers = []) {
+  const mark = runMark(run, themeFonts);
+  const marks = wrappers.reduce(
+    (set, wrapper) => wrapper.addToSet(set),
+    [mark]
+  );
+  const nodes = [];
+  for (const child of elementChildren(run)) {
+    if (child.localName === "rPr") continue;
+    const built = buildRunChild(
+      child,
+      marks,
+      images,
+      comments,
+      notes,
+      noteLabel
+    );
+    if (built === null) return null;
+    nodes.push(...built);
+  }
+  if (nodes.length === 0) {
+    return [
+      docxSchema.nodes.rawInline.create(
+        { xml: serializeXml(run) },
+        null,
+        // The wrappers have to close again around this XML on export, so their marks ride along here too
+        wrappers
+      )
+    ];
+  }
+  return nodes;
+}
+var controlCounts = /* @__PURE__ */ new WeakMap();
+var linkCounts = /* @__PURE__ */ new WeakMap();
+function nextKey(counts, el) {
+  const key = counts.get(el.ownerDocument) ?? 0;
+  counts.set(el.ownerDocument, key + 1);
+  return key;
+}
+var NOTHING_ON_SCREEN = [
+  "bookmarkStart",
+  "bookmarkEnd",
+  "proofErr",
+  "permStart",
+  "permEnd"
+];
+function annotationId(el) {
+  return Array.from(el.attributes).find((attribute) => attribute.localName === "id")?.value ?? null;
+}
+function commentRangeNode(el, marks = []) {
+  const id = annotationId(el);
+  if (id === null) return null;
+  const type = el.localName === "commentRangeStart" ? docxSchema.nodes.commentStart : el.localName === "commentRangeEnd" ? docxSchema.nodes.commentEnd : null;
+  return type?.create({ id, xml: serializeXml(el) }, null, marks) ?? null;
+}
+var NO_IMPORT_SOURCES = {
+  images: NO_IMAGES,
+  themeFonts: NO_THEME_FONTS,
+  links: NO_LINK_TARGETS,
+  comments: NO_COMMENTS,
+  notes: NO_NOTES,
+  noteLabel: () => "?"
+};
+function buildWrappedNodes(content, sources, wrappers, linkAllowed) {
+  const nodes = [];
+  for (const child of elementChildren(content)) {
+    if (child.localName === "r") {
+      const built = buildRunNodes(
+        child,
+        sources.images,
+        sources.themeFonts,
+        sources.comments,
+        sources.notes,
+        sources.noteLabel,
+        wrappers
+      );
+      if (built === null) return null;
+      nodes.push(...built);
+      continue;
+    }
+    if (child.localName === "hyperlink" && linkAllowed) {
+      const built = buildHyperlinkNodes(child, sources, wrappers);
+      if (built === null) return null;
+      nodes.push(...built);
+      continue;
+    }
+    const commentMarker = commentRangeNode(child, wrappers);
+    if (commentMarker) {
+      nodes.push(commentMarker);
+      continue;
+    }
+    if (!NOTHING_ON_SCREEN.includes(child.localName)) return null;
+    nodes.push(
+      docxSchema.nodes.rawInline.create(
+        { xml: serializeXml(child) },
+        null,
+        wrappers
+      )
+    );
+  }
+  if (nodes.length === 0) return null;
+  return nodes;
+}
+function buildHyperlinkNodes(el, sources, wrappers) {
+  const wrapper = readHyperlinkWrapper(el);
+  if (!wrapper) return null;
+  const mark = docxSchema.marks.link.create({
+    linkPrefix: wrapper.prefix,
+    href: wrapper.relId === null ? null : sources.links.get(wrapper.relId) ?? null,
+    linkKey: nextKey(linkCounts, el)
+  });
+  return buildWrappedNodes(el, sources, [...wrappers, mark], false);
+}
+function buildSdtNodes(el, sources) {
+  const wrapper = readSdtWrapper(el);
+  if (!wrapper) return null;
+  const mark = docxSchema.marks.sdt.create({
+    sdtPrefix: wrapper.prefix,
+    sdtKey: nextKey(controlCounts, el),
+    contentsLocked: wrapper.contentsLocked,
+    deletionLocked: wrapper.deletionLocked
+  });
+  return buildWrappedNodes(wrapper.content, sources, [mark], true);
+}
+function buildParagraph(el, srcId, sources = NO_IMPORT_SOURCES) {
+  const { images, themeFonts } = sources;
+  const inline = [];
+  let pPrElement = null;
+  for (const child of elementChildren(el)) {
+    if (child.localName === "pPr") {
+      pPrElement = child;
+      continue;
+    }
+    if (child.localName === "r") {
+      const runNodes = buildRunNodes(
+        child,
+        images,
+        themeFonts,
+        sources.comments,
+        sources.notes,
+        sources.noteLabel
+      );
+      if (runNodes === null) return null;
+      inline.push(...runNodes);
+      continue;
+    }
+    if (child.localName === "sdt") {
+      const sdtNodes = buildSdtNodes(child, sources);
+      if (sdtNodes === null) return null;
+      inline.push(...sdtNodes);
+      continue;
+    }
+    if (child.localName === "hyperlink") {
+      const linkNodes = buildHyperlinkNodes(child, sources, []);
+      if (linkNodes === null) return null;
+      inline.push(...linkNodes);
+      continue;
+    }
+    const commentMarker = commentRangeNode(child);
+    if (commentMarker) {
+      inline.push(commentMarker);
+      continue;
+    }
+    inline.push(
+      docxSchema.nodes.rawInline.create({ xml: serializeXml(child) })
+    );
+  }
+  return docxSchema.nodes.paragraph.create(
+    {
+      srcId,
+      pAttrs: attrString(el),
+      pPr: pPrElement ? serializeXml(pPrElement) : null,
+      format: readParagraphFormat(pPrElement)
+    },
+    inline
+  );
+}
+export {
+  NO_IMPORT_SOURCES,
+  buildParagraph
+};

package/dist/docx/importTable.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Imports one OOXML table, converting vertical merge continuations to rowspans and layering style
+ * values for display. Unsupported grids return null so the caller can preserve their source XML.
+ */
+import type { Node as PMNode } from "prosemirror-model";
+import { type StyleTable } from "./formatting";
+import { type ImportSources } from "./importParagraph";
+/** Moves a `<w:tbl>` into a table node. null if it cannot be modelled */
+export declare function buildTable(el: Element, srcId: number | null, sources?: ImportSources, styles?: StyleTable, defaultTableStyleId?: string | null): PMNode | null;