@portone/docx-editor 0.2.0 → 0.3.0

package/dist/docx/identities.js

@@ -0,0 +1,174 @@
+// src/docx/identities.ts
+import { Fragment } from "prosemirror-model";
+import { DocxExportError } from "../ooxml/errors.js";
+import { qualify } from "../ooxml/names.js";
+import { parseAttrs } from "../ooxml/tagScan.js";
+import { docxSchema } from "../schema/index.js";
+import { withoutParagraphIds } from "./cloning.js";
+import { copiedControlPrefix, newControlId } from "./sdt.js";
+var sourceBlockRule = {
+  name: "sourceBlock",
+  visit(block, written) {
+    const srcId = block.attrs.srcId;
+    if (typeof srcId !== "string" && typeof srcId !== "number") return block;
+    const name = String(srcId);
+    if (!written.has(name)) {
+      written.add(name);
+      return block;
+    }
+    if (block.type.isInGroup("preserved")) return null;
+    return block.type.create(
+      { ...block.attrs, srcId: null },
+      block.content,
+      block.marks
+    );
+  }
+};
+var PARA_ID = qualify("w14", "paraId");
+var LONG_HEX = /^[0-9A-Fa-f]{8}$/;
+function paragraphIdOf(pAttrs) {
+  if (typeof pAttrs !== "string") return null;
+  const value = parseAttrs(pAttrs)?.find(([name]) => name === PARA_ID)?.[1];
+  if (value === void 0 || !LONG_HEX.test(value)) return null;
+  const id = Number.parseInt(value, 16);
+  return id > 0 && id < 2147483648 ? id : null;
+}
+var paragraphIdRule = {
+  name: "paragraphId",
+  visit(block, written) {
+    if (block.type !== docxSchema.nodes.paragraph) return block;
+    const id = paragraphIdOf(block.attrs.pAttrs);
+    if (id === null) return block;
+    const name = String(id);
+    if (!written.has(name)) {
+      written.add(name);
+      return block;
+    }
+    return block.type.create(
+      { ...block.attrs, pAttrs: withoutParagraphIds(block.attrs.pAttrs) },
+      block.content,
+      block.marks
+    );
+  }
+};
+function sdtMarkOf(node) {
+  return node.marks.find((mark) => mark.type === docxSchema.marks.sdt) ?? null;
+}
+function controlName(mark) {
+  const key = mark.attrs.sdtKey;
+  const prefix = mark.attrs.sdtPrefix;
+  return `${typeof key === "number" ? key : 0} ${typeof prefix === "string" ? prefix : ""}`;
+}
+function copiedMark(mark) {
+  const prefix = mark.attrs.sdtPrefix;
+  if (typeof prefix !== "string") return mark;
+  return mark.type.create({
+    ...mark.attrs,
+    sdtPrefix: copiedControlPrefix(prefix, newControlId())
+  });
+}
+function claim(mark, written) {
+  const name = controlName(mark);
+  const copy = written.has(name) ? copiedMark(mark) : null;
+  written.add(name);
+  return { mark, copy };
+}
+function rewriteParagraph(paragraph, written) {
+  const inline = [];
+  let running = null;
+  let renamed = false;
+  paragraph.forEach((child) => {
+    const mark = sdtMarkOf(child);
+    if (!mark) {
+      running = null;
+      inline.push(child);
+      return;
+    }
+    const control = running?.mark.eq(mark) ? running : claim(mark, written);
+    running = control;
+    if (!control.copy) {
+      inline.push(child);
+      return;
+    }
+    renamed = true;
+    inline.push(
+      child.mark(control.copy.addToSet(mark.removeFromSet(child.marks)))
+    );
+  });
+  return renamed ? paragraph.copy(Fragment.fromArray(inline)) : paragraph;
+}
+var controlRule = {
+  name: "control",
+  visit(block, written) {
+    return block.type === docxSchema.nodes.paragraph ? rewriteParagraph(block, written) : block;
+  }
+};
+var IDENTITY_RULES = [
+  sourceBlockRule,
+  paragraphIdRule,
+  controlRule
+];
+function refusalOf(block, pos) {
+  return {
+    code: "unsupported-content",
+    message: `a preserved block stands in two places (${block.type.name})`,
+    pos
+  };
+}
+function visitBlock(block, pos, walk) {
+  let current = block;
+  for (const [index, rule] of walk.rules.entries()) {
+    const next = rule.visit(current, walk.written[index]);
+    if (next === null) {
+      walk.refuse(refusalOf(block, pos));
+      return current;
+    }
+    current = next;
+  }
+  return current;
+}
+function rewriteBlock(block, pos, walk) {
+  const visited = visitBlock(block, pos, walk);
+  if (visited.inlineContent || visited.childCount === 0) return visited;
+  const children = [];
+  let changed = false;
+  visited.forEach((child, offset) => {
+    const next = rewriteBlock(child, pos + 1 + offset, walk);
+    changed ||= next !== child;
+    children.push(next);
+  });
+  return changed ? visited.copy(Fragment.fromArray(children)) : visited;
+}
+function walkBlocks(doc, rules, refuse) {
+  const walk = {
+    rules,
+    written: rules.map(() => /* @__PURE__ */ new Set()),
+    refuse
+  };
+  const blocks = [];
+  let changed = false;
+  doc.forEach((block, offset) => {
+    const next = rewriteBlock(block, offset, walk);
+    changed ||= next !== block;
+    blocks.push(next);
+  });
+  return changed ? doc.copy(Fragment.fromArray(blocks)) : doc;
+}
+function withUniqueIdentities(doc, rules = IDENTITY_RULES) {
+  return walkBlocks(doc, rules, (problem) => {
+    throw new DocxExportError(problem.code, problem.message);
+  });
+}
+function identityProblems(doc, rules = IDENTITY_RULES) {
+  const problems = [];
+  walkBlocks(doc, rules, (problem) => problems.push(problem));
+  return problems;
+}
+export {
+  IDENTITY_RULES,
+  controlRule,
+  identityProblems,
+  paragraphIdRule,
+  sourceBlockRule,
+  withUniqueIdentities
+};

package/dist/docx/importDocx.d.ts

@@ -4,6 +4,8 @@
  * This module knows nothing about the screen. All it knows is the file and the document model.
  */
 import { type Node as PMNode } from "prosemirror-model";
+import { type XmlParser } from "../ooxml/xml";
+import { type FidelityNote } from "./fidelity";
 import { SessionStore } from "./session";
 /** A docx file as bytes, however it arrived (file input, fetch, filesystem) */
 export type DocxBytes = ArrayBuffer | Uint8Array;
@@ -15,7 +17,16 @@ export type DocxBytes = ArrayBuffer | Uint8Array;
  * engine on `./core` stays synchronous and bytes-only.
  */
 export type DocxSource = DocxBytes | Blob;
-export declare function importDocx(input: DocxBytes): {
+/** What a caller may say about a read beyond handing over the bytes */
+export interface ImportOptions {
+    /**
+     * The parser every part of the package is read through. Left out, the `DOMParser` global is
+     * used, and a runtime carrying none refuses the read with `no-xml-parser`.
+     */
+    xmlParser?: XmlParser;
+}
+export declare function importDocx(input: DocxBytes, options?: ImportOptions): {
     doc: PMNode;
     session: SessionStore;
+    notes: FidelityNote[];
 };

package/dist/docx/importDocx.js

@@ -1,6 +1,5 @@
 // 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 {
@@ -9,24 +8,26 @@ import {
   elementChildren,
   localPart,
   parseXml,
-  R_NS
+  R_NS,
+  withXmlParser
 } 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,
+  DEFAULT_TAB_STOP_PT,
+  readCompatSettings,
+  readDefaultTabStop
+} from "./documentSettings.js";
+import { fidelityNotesOf } from "./fidelity.js";
+import {
+  formattingContextOf,
   NO_DOCUMENT_DEFAULTS,
-  NO_STYLES,
-  readDefaultParagraphFormat,
+  paragraphAttrsOf,
   readDocumentDefaults,
   readParagraphStyles,
-  readStyles
+  resolveParagraph,
+  runMarkUnder
 } from "./formatting.js";
 import { readHeadersFooters } from "./headersFooters.js";
 import { readLinkTargets } from "./hyperlink.js";
@@ -34,28 +35,26 @@ import { buildParagraph } from "./importParagraph.js";
 import { buildTable } from "./importTable.js";
 import { readImageSources } from "./media.js";
 import { readNotes } from "./notes.js";
+import { readPart, relatedPartPath } from "./packageParts.js";
 import { readBodyGeometry } from "./pageGeometry.js";
-import { resolveTarget } from "./relationships.js";
+import { readRelationships } from "./relationships.js";
 import { scanBody } from "./scan.js";
-import { SessionStore } from "./session.js";
+import {
+  BODY_STORY_KEY,
+  blockKey,
+  newSessionId,
+  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);
+  const target = readRelationships(parts, "_rels/.rels").find(
+    (rel) => rel.type === OFFICE_DOCUMENT_REL
+  )?.target;
   if (!target) {
     throw new DocxImportError(
       "missing-part",
@@ -64,22 +63,7 @@ function findMainPartPath(parts) {
   }
   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) {
+function buildBlock(el, srcId, sources, context) {
   if (el.localName === "bookmarkStart" || el.localName === "bookmarkEnd") {
     return docxSchema.nodes.bookmarkBlock.create({
       srcId,
@@ -91,27 +75,34 @@ function buildBlock(el, srcId, sources, styles, defaultTableStyleId) {
     if (paragraph) return paragraph;
   }
   if (el.localName === "tbl") {
-    const table = buildTable(el, srcId, sources, styles, defaultTableStyleId);
+    const table = buildTable(
+      el,
+      srcId,
+      sources,
+      context.styles,
+      context.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;
+  const pPr = node.attrs.pPr;
+  const paragraph = resolveParagraph(
+    typeof pPr === "string" ? pPr : null,
+    context
+  );
+  const inline = node.children.map((child) => {
+    const mark = runMarkUnder(
+      child.marks.find((entry) => entry.type === docxSchema.marks.run) ?? null,
+      child.isText,
+      paragraph,
+      context
+    );
+    return mark ? child.mark(mark.addToSet(child.marks)) : child;
+  });
   return node.type.create(
-    {
-      ...node.attrs,
-      format: effectiveParagraphFormat(node.attrs.pPr, context),
-      styleRun: style ? layerRunFormat(style.run, null) : null
-    },
+    { ...node.attrs, ...paragraphAttrsOf(paragraph) },
     Fragment.fromArray(inline),
     node.marks
   );
@@ -153,7 +144,10 @@ function foldTrailingSectPr(scan) {
     suffix: last.xml + scan.suffix
   };
 }
-function importDocx(input) {
+function importDocx(input, options) {
+  return withXmlParser(options?.xmlParser, () => readDocx(input));
+}
+function readDocx(input) {
   const bytes = input instanceof Uint8Array ? input : new Uint8Array(input);
   const parts = openParts(bytes);
   const mainPartPath = findMainPartPath(parts);
@@ -182,25 +176,21 @@ function importDocx(input) {
     parts,
     relatedPartPath(parts, mainPartPath, SETTINGS_REL)
   );
-  const defaultTabStopPt = readDefaultTabStop(settingsXml === null ? null : parseXml(settingsXml)) ?? DEFAULT_TAB_STOP_PT;
+  const settingsDom = settingsXml === null ? null : parseXml(settingsXml);
+  const defaultTabStopPt = readDefaultTabStop(settingsDom) ?? 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 formatting = formattingContextOf(
+    stylesDom,
+    parseNumbering(numberingXml),
+    themeFonts,
+    readCompatSettings(settingsDom)
+  );
   const comments = readComments(parts, mainPartPath);
   const notes = readNotes(parts, mainPartPath);
   const noteLabels = {
@@ -224,15 +214,24 @@ function importDocx(input) {
     notes,
     noteLabel
   };
+  const sessionId = newSessionId();
   const blockNodes = blockElements.map(
     (el, i) => withStyleFormats(
-      buildBlock(el, i, sources, styles, defaultTableStyleId),
-      paragraphFormatting
+      buildBlock(
+        el,
+        blockKey({ sessionId }, BODY_STORY_KEY, i),
+        sources,
+        formatting
+      ),
+      formatting
     )
   );
+  const doc = docxSchema.nodes.doc.create(null, blockNodes);
   return {
-    doc: docxSchema.nodes.doc.create(null, blockNodes),
+    doc,
+    notes: fidelityNotesOf(doc, mainPartPath),
     session: new SessionStore({
+      sessionId,
       parts,
       mainPartPath,
       documentPrefix: scan.prefix,
@@ -241,19 +240,13 @@ function importDocx(input) {
       blocks: blockNodes.map((node, i) => ({ xml: scan.blocks[i].xml, node })),
       defaults: stylesDom ? readDocumentDefaults(stylesDom, themeFonts) : NO_DOCUMENT_DEFAULTS,
       defaultTabStopPt,
-      paragraphDefaults,
       geometry,
-      styles,
+      formatting,
       paragraphStyles: stylesDom ? readParagraphStyles(stylesDom) : [],
-      defaultParagraphStyleId,
       numberingXml,
       numberingPartPath,
       comments,
-      commentReferenceIds: new Set(
-        commentReferencesIn(
-          docxSchema.nodes.doc.create(null, blockNodes)
-        ).keys()
-      ),
+      commentReferenceIds: new Set(commentReferencesIn(doc).keys()),
       headersFooters
     })
   };

package/dist/docx/importParagraph.d.ts

@@ -29,4 +29,4 @@ export interface ImportSources {
 }
 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;
+export declare function buildParagraph(el: Element, srcId: string | null, sources?: ImportSources): PMNode | null;

package/dist/docx/importParagraph.js

@@ -1,6 +1,8 @@
 // src/docx/importParagraph.ts
 import { readDrawingPicture } from "../ooxml/image.js";
+import { ST_OnOff } from "../ooxml/simpleTypes.js";
 import {
+  attributeByLocalName,
   attrString,
   childByLocalName,
   elementChildren,
@@ -104,9 +106,8 @@ function buildRunChild(el, marks, images, comments, notes, noteLabel) {
       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)
-      );
+      const written = attributeByLocalName(el, "customMarkFollows");
+      const customMarkFollows = written !== null && (ST_OnOff.parse(written) ?? true);
       return [
         docxSchema.nodes.noteReference.create(
           {

package/dist/docx/importTable.d.ts

@@ -6,4 +6,4 @@ 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;
+export declare function buildTable(el: Element, srcId: string | null, sources?: ImportSources, styles?: StyleTable, defaultTableStyleId?: string | null): PMNode | null;

package/dist/docx/importTable.js

@@ -86,9 +86,23 @@ function readRow(el) {
   }
   return cells.length > 0 ? { el, tblPrEx, cells } : null;
 }
+function gridRevisionXml(grid) {
+  const revision = childByLocalName(grid, "tblGridChange");
+  if (revision === null) return null;
+  const declarations = Array.from(grid.attributes).filter(
+    (attr) => attr.namespaceURI === "http://www.w3.org/2000/xmlns/" && !revision.hasAttribute(attr.name)
+  );
+  if (declarations.length === 0) return serializeXml(revision);
+  const preserved = revision.ownerDocument.importNode(revision, true);
+  for (const attr of declarations) {
+    preserved.setAttributeNS(attr.namespaceURI, attr.name, attr.value);
+  }
+  return serializeXml(preserved);
+}
 function readTableParts(el) {
   let tblPr = null;
   let tblGrid = null;
+  let gridChange = null;
   const rows = [];
   for (const child of elementChildren(el)) {
     if (child.localName === "tblPr") {
@@ -97,6 +111,7 @@ function readTableParts(el) {
     }
     if (child.localName === "tblGrid") {
       tblGrid = child;
+      gridChange = gridRevisionXml(child);
       continue;
     }
     if (child.localName !== "tr") return null;
@@ -104,7 +119,7 @@ function readTableParts(el) {
     if (!row) return null;
     rows.push(row);
   }
-  return rows.length > 0 ? { tblPr, tblGrid, rows } : null;
+  return rows.length > 0 ? { tblPr, tblGrid, gridChange, rows } : null;
 }
 function resolveVerticalMerges(rows, width) {
   const drafts = [];
@@ -262,6 +277,7 @@ function buildTable(el, srcId, sources = NO_IMPORT_SOURCES, styles = NO_STYLES,
       tblPr: parts.tblPr ? serializeXml(parts.tblPr) : null,
       tblW: readTableWidth(parts.tblPr, "tblW"),
       gridCols,
+      gridChange: parts.gridChange,
       format: tableFormat,
       // The cells need these again whenever an edit derives their display values afresh
       styleInside: toInsideBorders(style?.tableInside),

package/dist/docx/invariants.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Known export refusals, asked of the document before anything is written.
+ *
+ * Each invariant reads what the writer would refuse over and reports it with the code the writer
+ * would throw, so a screen can ask at edit time what `exportDocx` would say. The list is walked in
+ * order and `exportDocx` throws its first entry, which is what keeps the two from disagreeing.
+ *
+ * The checks inspect model attrs and preserved XML without running the writers. Bookmark
+ * fragments and list definitions use the export parser. `assertBookmarkPairs` in `./exportDocx`
+ * and `assertPartsParse` in `./partPlan` remain the final checks over the parts as actually written.
+ */
+import type { Node as PMNode } from "prosemirror-model";
+import type { DocxExportErrorCode } from "../ooxml/errors";
+import type { ExportOptions } from "./exportDocx";
+import { type DocxSession, type SessionStore } from "./session";
+/** One reason the document cannot be written back, with the code `exportDocx` would throw it under */
+export interface ExportProblem {
+    readonly code: DocxExportErrorCode;
+    readonly message: string;
+    /** Where the problem stands in the document. Absent for a problem of the package or of the session */
+    readonly pos?: number;
+}
+/** The problems as the writer sees them, for a caller already inside the writer's parser scope */
+export declare function problemsOf(doc: PMNode, session: SessionStore): readonly ExportProblem[];
+/**
+ * Known reasons writing this document back would be refused, in the order `exportDocx` would
+ * raise them. An empty list does not rule out failures while writing. Each entry carries the code and message the
+ * `DocxExportError` would carry, and the position in the document where there is one.
+ *
+ * The list definitions are read to tell a new list from one the document already had, so this
+ * needs an XML parser the way `exportDocx` does and takes the same option.
+ */
+export declare function exportProblems(doc: PMNode, session: DocxSession, options?: ExportOptions): readonly ExportProblem[];