@portone/docx-editor 0.1.0

package/dist/docx/scan.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Finds the span each individual body block occupies in the raw document.xml text and slices it out.
+ *
+ * A block that was not edited is exported by writing this fragment back out untouched,
+ * which keeps its original bytes intact.
+ */
+export interface BodyBlockSlice {
+    /** The tag name exactly as written (e.g. "w:p", "w:tbl", "w:sectPr") */
+    name: string;
+    /** The original XML fragment. It also carries the whitespace that sat between this block and the one before it */
+    xml: string;
+}
+export interface BodyScan {
+    /** Everything in the raw text before the first block */
+    prefix: string;
+    blocks: BodyBlockSlice[];
+    /** Everything in the raw text after the last block */
+    suffix: string;
+}
+export declare function scanBody(source: string): BodyScan;

package/dist/docx/scan.js

@@ -0,0 +1,110 @@
+// src/docx/scan.ts
+import { DocxImportError } from "../ooxml/errors.js";
+import { localPart } from "../ooxml/xml.js";
+function skipPast(source, from, marker) {
+  const at = source.indexOf(marker, from);
+  if (at === -1) {
+    throw new DocxImportError("malformed-xml", `no ${marker} to close a tag`);
+  }
+  return at + marker.length;
+}
+function skipNonTag(source, lt) {
+  if (source.startsWith("<?", lt)) return skipPast(source, lt, "?>");
+  if (source.startsWith("<!--", lt)) return skipPast(source, lt, "-->");
+  if (source.startsWith("<![CDATA[", lt)) return skipPast(source, lt, "]]>");
+  if (source.startsWith("<!", lt)) return skipPast(source, lt, ">");
+  return null;
+}
+function readOpenTag(source, lt) {
+  let i = lt + 1;
+  const nameStart = i;
+  while (i < source.length && !" 	\r\n/>".includes(source[i])) i += 1;
+  const name = source.slice(nameStart, i);
+  if (!name)
+    throw new DocxImportError("malformed-xml", "a tag has an empty name");
+  let quote = null;
+  while (i < source.length) {
+    const ch = source[i];
+    if (quote !== null) {
+      if (ch === quote) quote = null;
+    } else if (ch === '"' || ch === "'") {
+      quote = ch;
+    } else if (ch === ">") {
+      return { name, end: i + 1, selfClosing: source[i - 1] === "/" };
+    }
+    i += 1;
+  }
+  throw new DocxImportError("malformed-xml", "a tag is left unclosed");
+}
+function readCloseTag(source, lt) {
+  const gt = source.indexOf(">", lt);
+  if (gt === -1)
+    throw new DocxImportError("malformed-xml", "a tag is left unclosed");
+  return { name: source.slice(lt + 2, gt).trim(), end: gt + 1 };
+}
+function isBodyTag(tag, depth) {
+  return localPart(tag.name) === "body" && depth === 1 && !tag.selfClosing;
+}
+function scanBody(source) {
+  const stack = [];
+  const blocks = [];
+  let bodyDepth = null;
+  let contentStart = -1;
+  let sliceStart = -1;
+  const atBodyLevel = () => bodyDepth !== null && stack.length === bodyDepth;
+  const takeBlock = (name, end) => {
+    blocks.push({ name, xml: source.slice(sliceStart, end) });
+    sliceStart = end;
+  };
+  let i = 0;
+  while (i < source.length) {
+    const lt = source.indexOf("<", i);
+    if (lt === -1) break;
+    const skipped = skipNonTag(source, lt);
+    if (skipped !== null) {
+      i = skipped;
+      continue;
+    }
+    if (source.startsWith("</", lt)) {
+      const tag2 = readCloseTag(source, lt);
+      const opened = stack.pop();
+      if (opened !== tag2.name) {
+        throw new DocxImportError(
+          "malformed-xml",
+          `mismatched tags: ${opened} vs ${tag2.name}`
+        );
+      }
+      if (atBodyLevel()) takeBlock(tag2.name, tag2.end);
+      i = tag2.end;
+      continue;
+    }
+    const tag = readOpenTag(source, lt);
+    if (bodyDepth === null && isBodyTag(tag, stack.length)) {
+      stack.push(tag.name);
+      bodyDepth = stack.length;
+      contentStart = tag.end;
+      sliceStart = tag.end;
+    } else {
+      if (atBodyLevel() && tag.selfClosing) takeBlock(tag.name, tag.end);
+      if (!tag.selfClosing) stack.push(tag.name);
+    }
+    i = tag.end;
+  }
+  if (bodyDepth === null) {
+    throw new DocxImportError("missing-body", "document has no w:body");
+  }
+  if (stack.length > 0) {
+    throw new DocxImportError(
+      "malformed-xml",
+      `elements are left unclosed: ${stack.join(", ")}`
+    );
+  }
+  return {
+    prefix: source.slice(0, contentStart),
+    blocks,
+    suffix: source.slice(sliceStart)
+  };
+}
+export {
+  scanBody
+};

package/dist/docx/sdt.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Reading the `w:sdt` content controls a document wraps its settled parts in, and naming a
+ * control that has to go out more than once.
+ *
+ * Only the shape we can write back out unchanged is taken apart: the `w:` prefix on both tags
+ * we write ourselves, a `w:sdtPr`, and a `w:sdtContent` that carries no attribute of its own
+ * and stands last. Everything else is null, which leaves whatever held the control preserved
+ * together with its original fragment.
+ *
+ * What sits inside the control is the caller's business. A whole cell (`docx/importTable`) and
+ * a stretch of runs inside a paragraph (`docx/importParagraph`) each read the content their
+ * own way, and the wrapper they put back on export is the same string in both cases.
+ */
+/** The opening of a content control taken apart, and the content it wraps */
+export interface SdtWrapper {
+    /** The `<w:sdt>` opening tag followed by everything that stood ahead of `<w:sdtContent>` */
+    prefix: string;
+    content: Element;
+    /** Whether the control says its contents may not be edited */
+    contentsLocked: boolean;
+    /** Whether the control says it may not be deleted, not even whole */
+    deletionLocked: boolean;
+}
+/** Takes a `w:sdt` apart into the wrapper to put back on export and the content to read. null for a shape we do not write ourselves */
+export declare function readSdtWrapper(el: Element): SdtWrapper | null;
+/**
+ * The number Word writes on every control. Nothing reads it back and it only has to differ
+ * from the other controls in the document, so a draw out of the whole 32 bit range is enough.
+ */
+export declare function newControlId(): number;
+/** What text one child of the control's `w:sdtPr` is to be changed to. A null xml removes that child */
+export type SdtPrEdit = readonly [name: string, xml: string | null];
+/**
+ * Whether the control says nothing about itself beyond its id and its lock: no alias or tag, no
+ * `w:dataBinding`, no type of its own.
+ * A lock may take such a control over a wider stretch, since the stretch is all it ever meant. One
+ * Word named keeps the stretch it was given, or the name would come to cover other text.
+ */
+export declare function namesNothing(prefix: string): boolean;
+/**
+ * The opening of a control with a few children of its `w:sdtPr` swapped out and everything else
+ * it carries left exactly as it came.
+ * null for a prefix whose shape cannot be made out, which leaves the caller to back out.
+ */
+export declare function editSdtPrefix(prefix: string, edits: readonly SdtPrEdit[]): string | null;
+/**
+ * The opening of a control that is going out for the second time, under a name of its own.
+ *
+ * Two controls sharing an id are merely untidy, but two sharing a `w:dataBinding` are a
+ * document Word keeps in step by itself: typing in the one would change the other. So the
+ * binding stays with the first copy alone.
+ *
+ * A prefix whose shape cannot be made out is handed back untouched, since writing the copy
+ * as it came is still better than refusing to export at all.
+ */
+export declare function copiedControlPrefix(prefix: string, id: number): string;

package/dist/docx/sdt.js

@@ -0,0 +1,104 @@
+// src/docx/sdt.ts
+import { wAttr } from "../ooxml/units.js";
+import { attrString, elementChildren, serializeXml } from "../ooxml/xml.js";
+import {
+  parseProps,
+  propsChild,
+  renderProps,
+  setPropsChild
+} from "./propsXml.js";
+var CONTENTS_LOCKED = ["contentLocked", "sdtContentLocked"];
+var DELETION_LOCKED = ["sdtLocked", "sdtContentLocked"];
+function lockValue(sdtPr) {
+  const lock = elementChildren(sdtPr).find(
+    (child) => child.localName === "lock"
+  );
+  return lock ? wAttr(lock, "val") : null;
+}
+function readSdtWrapper(el) {
+  if (el.nodeName !== "w:sdt") return null;
+  const children = elementChildren(el);
+  const contentAt = children.findIndex(
+    (child) => child.localName === "sdtContent"
+  );
+  const content = contentAt === -1 ? null : children[contentAt];
+  if (!content || content.nodeName !== "w:sdtContent") return null;
+  if (content.attributes.length > 0) return null;
+  if (contentAt !== children.length - 1) return null;
+  const head = children.slice(0, contentAt);
+  const sdtPr = head.find((child) => child.localName === "sdtPr");
+  if (!sdtPr) return null;
+  const attrs = attrString(el);
+  const val = lockValue(sdtPr);
+  return {
+    prefix: (attrs ? `<w:sdt ${attrs}>` : "<w:sdt>") + head.map(serializeXml).join(""),
+    content,
+    contentsLocked: val !== null && CONTENTS_LOCKED.includes(val),
+    deletionLocked: val !== null && DELETION_LOCKED.includes(val)
+  };
+}
+var SDT_ORDER = ["sdtPr", "sdtEndPr", "sdtContent"];
+var SDT_PR_ORDER = [
+  "rPr",
+  "alias",
+  "tag",
+  "id",
+  "lock",
+  "placeholder",
+  "showingPlcHdr",
+  "dataBinding",
+  "temporary"
+];
+function newControlId() {
+  return Math.floor(Math.random() * 2147483647);
+}
+function renderPrefix(props) {
+  const open = props.attrs ? `<${props.tag} ${props.attrs}>` : `<${props.tag}>`;
+  return open + props.children.map((child) => child.xml).join("");
+}
+var NAMES_NOTHING = ["id", "lock"];
+function namesNothing(prefix) {
+  const sdt = parseProps(`${prefix}</w:sdt>`);
+  if (!sdt || sdt.attrs !== null) return false;
+  const sdtPr = propsChild(sdt.children, "sdtPr");
+  const props = sdtPr ? parseProps(sdtPr.xml) : null;
+  if (!props || sdt.children.length !== 1) return false;
+  return props.children.every((child) => NAMES_NOTHING.includes(child.name));
+}
+function emptyProps(props) {
+  return props.attrs ? `<${props.tag} ${props.attrs}/>` : `<${props.tag}/>`;
+}
+function editSdtPrefix(prefix, edits) {
+  const sdt = parseProps(`${prefix}</w:sdt>`);
+  const sdtPr = sdt && propsChild(sdt.children, "sdtPr");
+  const props = sdtPr ? parseProps(sdtPr.xml) : null;
+  if (!sdt || !props) return null;
+  const children = edits.reduce(
+    (kept, [name, xml]) => setPropsChild(kept, name, xml, SDT_PR_ORDER),
+    props.children
+  );
+  const rendered = renderProps({ ...props, children });
+  return renderPrefix({
+    ...sdt,
+    children: setPropsChild(
+      sdt.children,
+      "sdtPr",
+      rendered === "" ? emptyProps(props) : rendered,
+      SDT_ORDER
+    )
+  });
+}
+function copiedControlPrefix(prefix, id) {
+  const copied = editSdtPrefix(prefix, [
+    ["id", `<w:id w:val="${id}"/>`],
+    ["dataBinding", null]
+  ]);
+  return copied ?? prefix;
+}
+export {
+  copiedControlPrefix,
+  editSdtPrefix,
+  namesNothing,
+  newControlId,
+  readSdtWrapper
+};

package/dist/docx/sdtProps.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Turning the lock of a content control on and off inside the opening XML it goes back out as.
+ *
+ * Nothing but the `w:lock` child of the `w:sdtPr` moves. The id Word gave the control, the alias
+ * and tag it goes by, and the `w:dataBinding` that ties it to the file's own XML all stay, which
+ * is what tells lifting a lock apart from throwing the control away.
+ *
+ * One child carries both clauses of the lock, so the two move together here: shutting writes the
+ * value that shuts both, and lifting takes the child away, which leaves the control with neither.
+ * A control Word gave nothing but a guard against deletion (`sdtLocked`) is therefore shut by
+ * being given the stricter value, and lifting that lock afterwards opens both clauses.
+ */
+/**
+ * The opening of the control with its lock shut or lifted.
+ * null for a prefix whose shape cannot be made out, which leaves the caller to decide what to do
+ * with a control it cannot rewrite.
+ */
+export declare function withContentLock(sdtPrefix: string, locked: boolean): string | null;

package/dist/docx/sdtProps.js

@@ -0,0 +1,11 @@
+// src/docx/sdtProps.ts
+import { editSdtPrefix } from "./sdt.js";
+var LOCK_BOTH_CLAUSES = '<w:lock w:val="sdtContentLocked"/>';
+function withContentLock(sdtPrefix, locked) {
+  return editSdtPrefix(sdtPrefix, [
+    ["lock", locked ? LOCK_BOTH_CLAUSES : null]
+  ]);
+}
+export {
+  withContentLock
+};

package/dist/docx/serializeBlock.d.ts

@@ -0,0 +1,4 @@
+import type { Node as PMNode } from "prosemirror-model";
+import { type ExportRefs } from "./exportRefs";
+import { type SessionStore } from "./session";
+export declare function serializeBlock(node: PMNode, session: SessionStore, refs?: ExportRefs): string;

package/dist/docx/serializeBlock.js

@@ -0,0 +1,30 @@
+// src/docx/serializeBlock.ts
+import { DocxExportError } from "../ooxml/errors.js";
+import { NO_EXPORT_REFS } from "./exportRefs.js";
+import { preservedXml, serializeParagraph } from "./serializeParagraph.js";
+import { serializeTable } from "./serializeTable.js";
+import { originalBlock } from "./session.js";
+function serializeRaw(node, session) {
+  const imported = originalBlock(node, session);
+  if (!imported) {
+    throw new DocxExportError(
+      "lost-original",
+      "a preserved block has lost its original XML"
+    );
+  }
+  return imported.xml;
+}
+function serializeBlock(node, session, refs = NO_EXPORT_REFS) {
+  if (node.type.name === "paragraph") return serializeParagraph(node, refs);
+  if (node.type.name === "table") return serializeTable(node, refs);
+  if (node.type.name === "rawBlock") return preservedXml(node);
+  if (node.type.name === "bookmarkBlock") return serializeRaw(node, session);
+  if (node.type.name === "docxRaw") return serializeRaw(node, session);
+  throw new DocxExportError(
+    "unsupported-content",
+    `block we cannot serialize: ${node.type.name}`
+  );
+}
+export {
+  serializeBlock
+};

package/dist/docx/serializeParagraph.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Rebuilds an edited paragraph back into OOXML.
+ *
+ * Body paragraphs and paragraphs inside table cells take the same path.
+ *
+ * The inlines are grouped three times over: neighbours that share their formatting become one run,
+ * the runs that share a hyperlink (`w:hyperlink`) go back inside it, and the links and runs that
+ * share a content control (`w:sdt`) go back inside the wrapper that mark carries. The control is
+ * the outer of the two wrappers, which is the nesting the mark order records (`schema`).
+ */
+import type { Node as PMNode } from "prosemirror-model";
+import { type ExportRefs } from "./exportRefs";
+export declare function openTag(name: string, attrs: unknown): string;
+export declare function preservedXml(node: PMNode): string;
+export declare function serializeParagraph(node: PMNode, refs?: ExportRefs): string;

package/dist/docx/serializeParagraph.js

@@ -0,0 +1,208 @@
+// src/docx/serializeParagraph.ts
+import { DocxExportError } from "../ooxml/errors.js";
+import {
+  imageDrawingXml,
+  toImageExtent,
+  toImageSrc,
+  withExtent
+} from "../ooxml/image.js";
+import { escapeXml } from "../ooxml/xml.js";
+import { NO_EXPORT_REFS } from "./exportRefs.js";
+import { relIdIn, withRelId } from "./hyperlink.js";
+function sameMark(a, b) {
+  if (a === null || b === null) return a === b;
+  return a.eq(b);
+}
+function markOf(node, name) {
+  return node.marks.find((mark) => mark.type.name === name) ?? null;
+}
+function openTag(name, attrs) {
+  return typeof attrs === "string" ? `<${name} ${attrs}>` : `<${name}>`;
+}
+function emptyTag(name, attrs) {
+  return typeof attrs === "string" ? `<${name} ${attrs}/>` : `<${name}/>`;
+}
+function renderImage(node, images) {
+  const extent = toImageExtent(node.attrs.extent);
+  const xml = node.attrs.xml;
+  if (typeof xml === "string") return extent ? withExtent(xml, extent) : xml;
+  const src = toImageSrc(node.attrs.src);
+  if (!src || !extent) {
+    throw new DocxExportError(
+      "lost-original",
+      "an image carries neither its original XML nor a size and bytes to rebuild it from"
+    );
+  }
+  const relId = images.relIdOf(src);
+  if (relId === void 0) {
+    throw new DocxExportError(
+      "unsupported-content",
+      "an inserted image has no media relationship; export it through exportDocx"
+    );
+  }
+  return imageDrawingXml({
+    relId,
+    docPrId: images.takeDocPrId(),
+    extent,
+    alt: typeof node.attrs.alt === "string" ? node.attrs.alt : null
+  });
+}
+function renderInline(node, images) {
+  if (node.isText) {
+    const tab = markOf(node, "tab");
+    return (node.text ?? "").split("	").flatMap((text, index, pieces) => {
+      const rendered = text ? [`<w:t xml:space="preserve">${escapeXml(text)}</w:t>`] : [];
+      return index < pieces.length - 1 ? [...rendered, emptyTag("w:tab", tab?.attrs.tabAttrs)] : rendered;
+    }).join("");
+  }
+  if (node.type.name === "hardBreak")
+    return emptyTag("w:br", node.attrs.brAttrs);
+  if (node.type.name === "image") return renderImage(node, images);
+  if (node.type.name === "commentReference") {
+    const original = node.attrs.referenceXml;
+    if (typeof original === "string") return original;
+    const id = node.attrs.id;
+    if (typeof id === "string") {
+      return `<w:commentReference w:id="${escapeXml(id)}"/>`;
+    }
+    throw new DocxExportError(
+      "lost-original",
+      "a comment reference has no id to write"
+    );
+  }
+  if (node.type.name === "noteReference") {
+    const original = node.attrs.referenceXml;
+    if (typeof original === "string") return original;
+    const id = node.attrs.id;
+    const name = node.attrs.kind === "endnote" ? "endnoteReference" : "footnoteReference";
+    if (typeof id === "string") {
+      return `<w:${name} w:id="${escapeXml(id)}"/>`;
+    }
+    throw new DocxExportError(
+      "lost-original",
+      "a note reference has no id to write"
+    );
+  }
+  throw new DocxExportError(
+    "unsupported-content",
+    `inline node we cannot serialize: ${node.type.name}`
+  );
+}
+function preservedXml(node) {
+  const xml = node.attrs.xml;
+  if (typeof xml !== "string") {
+    throw new DocxExportError(
+      "lost-original",
+      "a preserved element has lost its original XML"
+    );
+  }
+  return xml;
+}
+function addInline(parts, child, images) {
+  if (child.type.name === "rawInline") {
+    parts.push({ kind: "raw", xml: preservedXml(child) });
+    return;
+  }
+  if (child.type.name === "commentStart" || child.type.name === "commentEnd") {
+    const original = child.attrs.xml;
+    if (typeof original === "string") {
+      parts.push({ kind: "raw", xml: original });
+      return;
+    }
+    const id = child.attrs.id;
+    if (typeof id !== "string") {
+      throw new DocxExportError(
+        "lost-original",
+        "a comment range marker has no id to write"
+      );
+    }
+    const name = child.type.name === "commentStart" ? "commentRangeStart" : "commentRangeEnd";
+    parts.push({ kind: "raw", xml: `<w:${name} w:id="${escapeXml(id)}"/>` });
+    return;
+  }
+  const piece = renderInline(child, images);
+  const mark = markOf(child, "run");
+  const last = parts.at(-1);
+  if (last?.kind === "run" && sameMark(last.mark, mark)) {
+    last.pieces.push(piece);
+  } else {
+    parts.push({ kind: "run", mark, pieces: [piece] });
+  }
+}
+function splitParagraphGroups(paragraph, refs) {
+  const groups = [];
+  paragraph.forEach((child) => {
+    const sdt = markOf(child, "sdt");
+    const link = markOf(child, "link");
+    let group = groups.at(-1);
+    if (!group || !sameMark(group.sdt, sdt)) {
+      group = { sdt, links: [] };
+      groups.push(group);
+    }
+    let inLink = group.links.at(-1);
+    if (!inLink || !sameMark(inLink.link, link)) {
+      inLink = { link, parts: [] };
+      group.links.push(inLink);
+    }
+    addInline(inLink.parts, child, refs.images);
+  });
+  return groups;
+}
+function renderParagraphPart(part) {
+  if (part.kind === "raw") return part.xml;
+  const open = openTag("w:r", part.mark?.attrs.rAttrs);
+  const rPr = part.mark?.attrs.rPr;
+  return open + (typeof rPr === "string" ? rPr : "") + part.pieces.join("") + "</w:r>";
+}
+function openLinkTag(mark, links) {
+  const prefix = mark.attrs.linkPrefix;
+  const original = typeof prefix === "string" ? prefix : null;
+  const href = mark.attrs.href;
+  if (typeof href !== "string") {
+    if (original !== null) return original;
+    throw new DocxExportError(
+      "lost-original",
+      "a hyperlink carries neither an address nor the opening XML it goes back out as"
+    );
+  }
+  const relId = links.relIdOf(
+    href,
+    original === null ? null : relIdIn(original)
+  );
+  if (relId === void 0) {
+    if (original !== null) return original;
+    throw new DocxExportError(
+      "unsupported-content",
+      "an inserted hyperlink has no relationship to point at; export it through exportDocx"
+    );
+  }
+  return withRelId(original ?? "<w:hyperlink>", relId);
+}
+function renderLinkGroup(group, links) {
+  const body = group.parts.map(renderParagraphPart).join("");
+  if (!group.link) return body;
+  return `${openLinkTag(group.link, links)}${body}</w:hyperlink>`;
+}
+function renderParagraphGroup(group, refs) {
+  const body = group.links.map((inLink) => renderLinkGroup(inLink, refs.links)).join("");
+  if (!group.sdt) return body;
+  const prefix = group.sdt.attrs.sdtPrefix;
+  if (typeof prefix !== "string") {
+    throw new DocxExportError(
+      "lost-original",
+      "a content control has lost the opening XML it goes back out as"
+    );
+  }
+  return `${prefix}<w:sdtContent>${body}</w:sdtContent></w:sdt>`;
+}
+function serializeParagraph(node, refs = NO_EXPORT_REFS) {
+  const open = openTag("w:p", node.attrs.pAttrs);
+  const pPr = node.attrs.pPr;
+  const body = splitParagraphGroups(node, refs).map((group) => renderParagraphGroup(group, refs)).join("");
+  return open + (typeof pPr === "string" ? pPr : "") + body + "</w:p>";
+}
+export {
+  openTag,
+  preservedXml,
+  serializeParagraph
+};

package/dist/docx/serializeTable.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Rebuilds an edited table back into OOXML.
+ *
+ * The editor model holds a vertical merge as a single `rowspan` on the starting cell, but docx has to
+ * write an empty cell out on every continuing row. Those empty cells are recreated here.
+ *
+ * A cell's `<w:tcPr>` is taken from the original with only the merge counts and the width swapped in.
+ * That way, when a horizontal merge shrinks from two cells to one, the `w:gridSpan` goes away with it.
+ */
+import type { Node as PMNode } from "prosemirror-model";
+import { type ExportRefs } from "./exportRefs";
+export declare function serializeTable(table: PMNode, refs?: ExportRefs): string;