@portone/docx-editor 0.2.1 → 0.4.0

package/dist/docx/tableFormatting/reading.js

@@ -1,31 +1,46 @@
 // src/docx/tableFormatting/reading.ts
+import {
+  TABLE_STYLE_CONDITIONS
+} from "../../model/format.js";
+import { parsePropsXml } from "../../ooxml/props.js";
+import {
+  ST_DecimalNumber,
+  ST_MeasurementOrPercent,
+  ST_SignedTwipsMeasure,
+  ST_TwipsMeasure
+} from "../../ooxml/simpleTypes.js";
 import {
   ALIGN_BY_JC,
+  borderLineCss,
   borderSide,
   childValue,
   isOn,
   shadingOf,
-  toNumber,
   twipsToPt,
   wAttr
 } from "../../ooxml/units.js";
 import { childByLocalName } from "../../ooxml/xml.js";
-import { parsePropsXml } from "../propsXml.js";
+var FIFTIETHS_PER_PERCENT = 50;
 function readTableWidth(parent, name) {
   const el = parent ? childByLocalName(parent, name) : null;
   if (!el) return null;
   const type = wAttr(el, "type") ?? "dxa";
+  const width = ST_MeasurementOrPercent.parse(wAttr(el, "w"));
+  if (width?.kind === "percent") {
+    const fiftieths = Math.round(width.value * FIFTIETHS_PER_PERCENT);
+    return Number.isFinite(fiftieths) ? { type: "pct", fiftieths } : null;
+  }
   if (type === "auto") return { type: "auto" };
   if (type === "nil") return { type: "nil" };
-  const raw = wAttr(el, "w");
-  const value = toNumber(raw);
-  if (value === null) return null;
-  if (type === "dxa") return { type: "dxa", twips: value };
+  if (width === null) return null;
+  if (type === "dxa") {
+    return { type: "dxa", twips: width.value };
+  }
   if (type === "pct") {
-    const isPercentText = raw?.endsWith("%") === true;
+    if (width.kind === "twips") return null;
     return {
       type: "pct",
-      fiftieths: isPercentText ? Math.round(value * 50) : value
+      fiftieths: width.value
     };
   }
   return null;
@@ -35,7 +50,7 @@ function readGridCols(tblGrid) {
   const cols = [];
   for (const child of Array.from(tblGrid.children)) {
     if (child.localName !== "gridCol") continue;
-    const w = toNumber(wAttr(child, "w"));
+    const w = ST_TwipsMeasure.parse(wAttr(child, "w"));
     if (w !== null) cols.push(w);
   }
   return cols;
@@ -69,7 +84,7 @@ function marginSide(margins, names) {
     if (!el) continue;
     const type = wAttr(el, "type") ?? "dxa";
     if (type === "nil") return 0;
-    return type === "dxa" ? twipsToPt(wAttr(el, "w")) : null;
+    return type === "dxa" ? twipsToPt(ST_TwipsMeasure.parse(wAttr(el, "w"))) : null;
   }
   return null;
 }
@@ -97,22 +112,89 @@ var NO_BORDER_DEFAULTS = {
   left: null,
   right: null
 };
-function gridEdgesOf(rect, grid) {
+var NO_CELL_DEFAULTS = {
+  borders: NO_BORDER_DEFAULTS,
+  margins: NO_CELL_MARGINS,
+  background: null,
+  verticalAlign: null,
+  placement: { tableStyleId: null, conditions: [] }
+};
+var NO_BAND_SIZES = { row: null, col: null };
+function bandSize(tblPr, name) {
+  const count = ST_DecimalNumber.parse(childValue(tblPr, name));
+  return count !== null && count > 0 ? count : null;
+}
+function readBandSizes(tblPr) {
+  if (!tblPr) return NO_BAND_SIZES;
+  return {
+    row: bandSize(tblPr, "tblStyleRowBandSize"),
+    col: bandSize(tblPr, "tblStyleColBandSize")
+  };
+}
+function layerBandSizes(style, over) {
+  return { row: over.row ?? style.row, col: over.col ?? style.col };
+}
+var NO_CELL_STYLE_BORDERS = {
+  top: null,
+  bottom: null,
+  left: null,
+  right: null
+};
+var NO_CELL_STYLE_FORMAT = {
+  background: null,
+  borders: NO_CELL_STYLE_BORDERS,
+  inside: NO_INSIDE_BORDERS,
+  margins: NO_CELL_MARGINS,
+  verticalAlign: null
+};
+var NO_TABLE_STYLE_CONDITIONS = {};
+function conditionBorders(tcBorders, table) {
+  return {
+    top: borderSide(tcBorders, "top") ?? table.borderTop ?? null,
+    bottom: borderSide(tcBorders, "bottom") ?? table.borderBottom ?? null,
+    left: borderSide(tcBorders, "left") ?? borderSide(tcBorders, "start") ?? table.borderLeft ?? null,
+    right: borderSide(tcBorders, "right") ?? borderSide(tcBorders, "end") ?? table.borderRight ?? null
+  };
+}
+function readCellStyleFormat(tcPr, tblPr) {
+  const table = readTableFormat(tblPr) ?? {};
+  const tcBorders = tcPr ? childByLocalName(tcPr, "tcBorders") : null;
+  return {
+    background: (tcPr ? shadingOf(tcPr) : null) ?? table.background ?? null,
+    borders: conditionBorders(tcBorders, table),
+    inside: layerInsideBorders(readInsideBorders(tblPr), {
+      horizontal: borderSide(tcBorders, "insideH"),
+      vertical: borderSide(tcBorders, "insideV")
+    }),
+    margins: readCellMarginsOf(tcPr, "tcMar"),
+    verticalAlign: tcPr ? cellVerticalAlignOf(tcPr) : null
+  };
+}
+function layerCellStyleBorders(base, over) {
   return {
-    top: rect.top === 0,
-    bottom: rect.bottom === grid.rows,
-    left: rect.left === 0,
-    right: rect.right === grid.cols
+    top: over.top ?? base.top,
+    bottom: over.bottom ?? base.bottom,
+    left: over.left ?? base.left,
+    right: over.right ?? base.right
   };
 }
-function cellBorderDefaults(edges, outer, inside) {
+function layerCellStyleFormat(base, over) {
   return {
-    top: edges.top ? outer?.borderTop ?? null : inside.horizontal,
-    bottom: edges.bottom ? outer?.borderBottom ?? null : inside.horizontal,
-    left: edges.left ? outer?.borderLeft ?? null : inside.vertical,
-    right: edges.right ? outer?.borderRight ?? null : inside.vertical
+    background: over.background ?? base.background,
+    borders: layerCellStyleBorders(base.borders, over.borders),
+    inside: layerInsideBorders(base.inside, over.inside),
+    margins: layerCellMargins(base.margins, over.margins),
+    verticalAlign: over.verticalAlign ?? base.verticalAlign
   };
 }
+function cellConditionsOf(conditions) {
+  const cells = {};
+  for (const type of TABLE_STYLE_CONDITIONS) {
+    const format = conditions[type];
+    if (format) cells[type] = format.cell;
+  }
+  return cells;
+}
 function tblStyleIdOf(tblPr) {
   return tblPr ? childValue(tblPr, "tblStyle") : null;
 }
@@ -133,12 +215,12 @@ function readTableFormat(tblPr) {
   const align = ALIGN_BY_JC[childValue(tblPr, "jc") ?? ""];
   if (align) format.align = align;
   const tblInd = childByLocalName(tblPr, "tblInd");
-  const indentLeftPt = tblInd ? twipsToPt(wAttr(tblInd, "w")) : null;
+  const indentLeftPt = tblInd ? twipsToPt(ST_SignedTwipsMeasure.parse(wAttr(tblInd, "w"))) : null;
   if (indentLeftPt !== null) format.indentLeftPt = indentLeftPt;
   return format;
 }
 function readRowHeight(trHeight) {
-  const pt = twipsToPt(wAttr(trHeight, "val"));
+  const pt = twipsToPt(ST_TwipsMeasure.parse(wAttr(trHeight, "val")));
   if (pt === null || pt <= 0) return null;
   const rule = wAttr(trHeight, "hRule") === "exact" ? "exact" : "atLeast";
   return { rule, pt };
@@ -158,6 +240,9 @@ var CELL_VERTICAL_ALIGN_BY_VAL = {
   center: "center",
   bottom: "bottom"
 };
+function cellVerticalAlignOf(tcPr) {
+  return CELL_VERTICAL_ALIGN_BY_VAL[childValue(tcPr, "vAlign") ?? ""] ?? null;
+}
 function readCellPadding(tcPr, margins) {
   const padding = layerCellMargins(margins, readCellMarginsOf(tcPr, "tcMar"));
   const format = {};
@@ -167,24 +252,26 @@ function readCellPadding(tcPr, margins) {
   if (padding.leftPt !== null) format.paddingLeftPt = padding.leftPt;
   return format;
 }
-function readCellFormat(tcPr, defaults, margins = NO_CELL_MARGINS) {
+function readCellFormat(tcPr, defaults = NO_CELL_DEFAULTS) {
   const borders = tcPr ? childByLocalName(tcPr, "tcBorders") : null;
+  const lines = defaults.borders;
   const format = {};
-  const top = borderSide(borders, "top") ?? defaults.top;
+  const top = borderSide(borders, "top") ?? borderLineCss(lines.top);
   if (top) format.borderTop = top;
-  const bottom = borderSide(borders, "bottom") ?? defaults.bottom;
+  const bottom = borderSide(borders, "bottom") ?? borderLineCss(lines.bottom);
   if (bottom) format.borderBottom = bottom;
-  const left = borderSide(borders, "left") ?? borderSide(borders, "start") ?? defaults.left;
+  const left = borderSide(borders, "left") ?? borderSide(borders, "start") ?? borderLineCss(lines.left);
   if (left) format.borderLeft = left;
-  const right = borderSide(borders, "right") ?? borderSide(borders, "end") ?? defaults.right;
+  const right = borderSide(borders, "right") ?? borderSide(borders, "end") ?? borderLineCss(lines.right);
   if (right) format.borderRight = right;
-  if (tcPr) {
-    const background = shadingOf(tcPr);
-    if (background) format.background = background;
-    const verticalAlign = CELL_VERTICAL_ALIGN_BY_VAL[childValue(tcPr, "vAlign") ?? ""];
-    if (verticalAlign) format.verticalAlign = verticalAlign;
-  }
-  const padded = { ...format, ...readCellPadding(tcPr, margins) };
+  const background = (tcPr ? shadingOf(tcPr) : null) ?? defaults.background;
+  if (background) format.background = background;
+  const verticalAlign = (tcPr ? cellVerticalAlignOf(tcPr) : null) ?? defaults.verticalAlign;
+  if (verticalAlign) format.verticalAlign = verticalAlign;
+  const padded = {
+    ...format,
+    ...readCellPadding(tcPr, defaults.margins)
+  };
   return Object.keys(padded).length > 0 ? padded : null;
 }
 function insideBordersOf(tblPr) {
@@ -195,23 +282,30 @@ function cellMarginsOf(tblPr) {
   const el = tblPr === null ? null : parsePropsXml(tblPr);
   return readCellMarginsOf(el, "tblCellMar");
 }
-function readCellProps(tcPr, defaults, margins = NO_CELL_MARGINS) {
+function readCellProps(tcPr, defaults = NO_CELL_DEFAULTS) {
   const el = tcPr === null ? null : parsePropsXml(tcPr);
-  return readCellFormat(el, defaults, margins);
+  return readCellFormat(el, defaults);
 }
 export {
+  NO_BAND_SIZES,
   NO_BORDER_DEFAULTS,
+  NO_CELL_DEFAULTS,
   NO_CELL_MARGINS,
+  NO_CELL_STYLE_FORMAT,
   NO_INSIDE_BORDERS,
-  cellBorderDefaults,
+  NO_TABLE_STYLE_CONDITIONS,
+  cellConditionsOf,
   cellMarginsOf,
-  gridEdgesOf,
   insideBordersOf,
+  layerBandSizes,
   layerCellMargins,
+  layerCellStyleFormat,
   layerInsideBorders,
+  readBandSizes,
   readCellFormat,
   readCellMarginsOf,
   readCellProps,
+  readCellStyleFormat,
   readGridCols,
   readInsideBorders,
   readRowFormat,

package/dist/docx/tableFormatting.d.ts

@@ -1,2 +1,3 @@
+export * from "./tableFormatting/conditions";
 export * from "./tableFormatting/editing";
 export * from "./tableFormatting/reading";

package/dist/docx/tableFormatting.js

@@ -1,3 +1,4 @@
 // src/docx/tableFormatting.ts
+export * from "./tableFormatting/conditions.js";
 export * from "./tableFormatting/editing.js";
 export * from "./tableFormatting/reading.js";

package/dist/docx/tableTemplate.js

@@ -1,13 +1,12 @@
 // src/docx/tableTemplate.ts
 import { elementXml } from "../ooxml/element.js";
 import { wName } from "../ooxml/names.js";
+import { orderedElement, parsePropsXml } from "../ooxml/props.js";
 import { docxSchema } from "../schema/index.js";
 import { A4_PORTRAIT, bodyWidth } from "./pageGeometry.js";
-import { parsePropsXml } from "./propsXml.js";
 import {
-  cellBorderDefaults,
-  gridEdgesOf,
-  NO_CELL_MARGINS,
+  cellDefaultsFor,
+  NO_CELL_SOURCES,
   readCellFormat,
   readInsideBorders,
   readTableFormat,
@@ -35,14 +34,21 @@ function borderXml(side) {
   ]);
 }
 function tablePropsXml(width) {
-  const borders = BORDER_SIDES.map(borderXml).join("");
-  return elementXml(
+  const borders = orderedElement(
+    wName("tblBorders"),
+    [],
+    BORDER_SIDES.map((side) => ({ name: side, xml: borderXml(side) }))
+  );
+  return orderedElement(
     wName("tblPr"),
     [],
     [
-      widthXml("tblW", width),
-      elementXml(wName("tblBorders"), [], [borders]),
-      elementXml(wName("tblLayout"), [[wName("type"), "fixed"]])
+      { name: "tblW", xml: widthXml("tblW", width) },
+      { name: "tblBorders", xml: borders },
+      {
+        name: "tblLayout",
+        xml: elementXml(wName("tblLayout"), [[wName("type"), "fixed"]])
+      }
     ]
   );
 }
@@ -53,7 +59,11 @@ function widthXml(name, width) {
   ]);
 }
 function cellPropsXml(width) {
-  return elementXml(wName("tcPr"), [], [widthXml("tcW", width)]);
+  return orderedElement(
+    wName("tcPr"),
+    [],
+    [{ name: "tcW", xml: widthXml("tcW", width) }]
+  );
 }
 function evenGridCols(cols, total) {
   const base = Math.floor(total / cols);
@@ -70,7 +80,7 @@ function cellTemplate(width, defaults) {
     tcPr,
     tcW: readTableWidth(el, "tcW"),
     // A new table writes no `tblCellMar`, so its cells take their padding from the stylesheet
-    format: readCellFormat(el, defaults, NO_CELL_MARGINS)
+    format: readCellFormat(el, defaults)
   };
 }
 function cellNode(props) {
@@ -98,17 +108,18 @@ function createTableNode(rows, cols, geometry = A4_PORTRAIT) {
   const gridCols = evenGridCols(cols, total);
   const tblPr = tablePropsXml(total);
   const tblPrEl = parsePropsXml(tblPr);
-  const inside = readInsideBorders(tblPrEl);
   const outer = readTableFormat(tblPrEl);
+  const sources = {
+    ...NO_CELL_SOURCES,
+    outer,
+    inside: readInsideBorders(tblPrEl)
+  };
   const cellAt = (row, col) => cellTemplate(
     gridCols[col],
-    cellBorderDefaults(
-      gridEdgesOf(
-        { top: row, bottom: row + 1, left: col, right: col + 1 },
-        { rows, cols }
-      ),
-      outer,
-      inside
+    cellDefaultsFor(
+      { top: row, bottom: row + 1, left: col, right: col + 1 },
+      { rows, cols },
+      sources
     )
   );
   return docxSchema.nodes.table.create(

package/dist/download.d.ts

@@ -6,6 +6,7 @@
  */
 import type { Node as PMNode } from "prosemirror-model";
 import type { DocxEditorHandle } from "./DocxEditor";
+import type { ExportProblem } from "./docx/invariants";
 export declare const DOCX_MIME_TYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
 export interface DownloadDocxOptions {
     /** The name to save under. The `.docx` suffix may be there or not */
@@ -19,6 +20,9 @@ export type DownloadDocxResult = {
     status: "unavailable";
 } | {
     status: "empty";
+} | {
+    status: "blocked";
+    problems: readonly ExportProblem[];
 };
 /** Settles the end of the name on exactly one `.docx` */
 export declare function withDocxExtension(fileName: string): string;
@@ -48,10 +52,9 @@ export declare function hasExportableContent(doc: PMNode): boolean;
  * Downloads the edited document as a docx file.
  *
  * `unavailable` when the editor is not mounted yet or the document could not be
- * opened, `empty` when there is nothing to export, and `exported` once a file has
- * gone out.
- * If writing the document back is blocked (a new list in a document without
- * numbering.xml, and the like), it is not passed over silently: `DocxExportError`
- * is rethrown as is.
+ * opened, `empty` when there is nothing to export, `blocked` with every reason
+ * when the document cannot be written back (a new list in a document without
+ * numbering.xml, and the like), and `exported` once a file has gone out.
+ * A refusal the check did not foresee is still thrown as `DocxExportError`.
  */
 export declare function downloadDocx(editor: DocxEditorHandle | null | undefined, options: DownloadDocxOptions): DownloadDocxResult;

package/dist/download.js

@@ -29,6 +29,8 @@ function hasExportableContent(doc) {
 function downloadDocx(editor, options) {
   if (!editor) return { status: "unavailable" };
   if (!hasExportableContent(editor.view.state.doc)) return { status: "empty" };
+  const problems = editor.exportProblems();
+  if (problems.length > 0) return { status: "blocked", problems };
   const bytes = editor.exportBytes();
   const fileName = withDocxExtension(options.fileName);
   downloadBlob(createDocxBlob(bytes), fileName);

package/dist/editor/clipboard/inlineFormatting.js

@@ -1,5 +1,7 @@
 // src/editor/clipboard/inlineFormatting.ts
-import { editRunProps } from "../../docx/runProps.js";
+import { rPrOf } from "../../docx/formatting.js";
+import { readRunProps } from "../../docx/runProps.js";
+import { HALF_POINTS_PER_PT, ST_HpsMeasure } from "../../ooxml/simpleTypes.js";
 import { docxSchema } from "../../schema/index.js";
 import { editorClassNames } from "../../styles/classNames.js";
 var IGNORED_TAGS = /* @__PURE__ */ new Set([
@@ -76,8 +78,8 @@ function fontSizePt(value) {
   const amount = Number.parseFloat(match[1] ?? "");
   if (!Number.isFinite(amount) || amount <= 0) return null;
   const points = match[2]?.toLowerCase() === "px" ? amount * 0.75 : amount;
-  const rounded = Math.round(points * 2) / 2;
-  return rounded > 0 && rounded <= 819 ? rounded : null;
+  const half = Math.round(points * HALF_POINTS_PER_PT);
+  return ST_HpsMeasure.format(half) === null ? null : half / HALF_POINTS_PER_PT;
 }
 function legacyFontSize(value) {
   const sizes = [8, 10, 12, 14, 18, 24, 36];
@@ -150,34 +152,21 @@ function contextFor(parent, element, readElementStyle = true) {
 function withInlineStyle(context, style) {
   return { ...context, style: { ...context.style, ...style } };
 }
+function settingsOf(style) {
+  const settings = {};
+  if (style.bold) settings.bold = true;
+  if (style.italic) settings.italic = true;
+  if (style.underline) settings.underline = "single";
+  if (style.strike) settings.strike = true;
+  if (style.fontSizePt !== void 0) settings.fontSizePt = style.fontSizePt;
+  if (style.fontFamily !== void 0) settings.fontFamily = style.fontFamily;
+  if (style.color !== void 0) settings.color = style.color;
+  if (style.background !== void 0) settings.background = style.background;
+  return settings;
+}
 function runMark(style) {
-  const edits = [];
-  if (style.bold) edits.push({ kind: "toggle", toggle: "bold", on: true });
-  if (style.italic) edits.push({ kind: "toggle", toggle: "italic", on: true });
-  if (style.underline) {
-    edits.push({ kind: "toggle", toggle: "underline", on: true });
-  }
-  if (style.strike) edits.push({ kind: "toggle", toggle: "strike", on: true });
-  if (style.fontSizePt !== void 0) {
-    edits.push({ kind: "fontSize", pt: style.fontSizePt });
-  }
-  if (style.fontFamily !== void 0) {
-    edits.push({ kind: "fontFamily", name: style.fontFamily });
-  }
-  if (style.color !== void 0)
-    edits.push({ kind: "color", hex: style.color });
-  if (style.background !== void 0) {
-    edits.push({ kind: "background", hex: style.background });
-  }
-  let props = {
-    rPr: null,
-    format: null
-  };
-  for (const edit of edits) {
-    const next = editRunProps(props, null, edit);
-    if (next) props = next;
-  }
-  return props.rPr === null ? null : docxSchema.marks.run.create({ rPr: props.rPr, format: props.format });
+  const rPr = rPrOf(settingsOf(style));
+  return rPr === null ? null : docxSchema.marks.run.create({ rPr, format: readRunProps(rPr) });
 }
 function marksFor(context) {
   const marks = [];

package/dist/editor/commands/comments/editing.d.ts

@@ -1,10 +1,14 @@
 /** Edits Word comments through their range markers and reference nodes. */
 import { type Command, type EditorState } from "prosemirror-state";
 import type { NewComment } from "./model";
-/** Whether a non-empty selection in one paragraph can receive a comment. */
-export declare function canAddComment(state: EditorState): boolean;
 /** Adds a plain-text comment to the current text selection. */
 export declare function addComment(comment: NewComment): Command;
+/**
+ * Whether a non-empty selection in one paragraph can receive a comment.
+ * This is the command itself asked without a dispatch, over a comment standing in for the one the
+ * user would write, so the button and the click cannot answer differently.
+ */
+export declare function canAddComment(state: EditorState): boolean;
 /** Replaces the plain-text body of one comment, retaining its author and anchor. */
 export declare function updateComment(id: string, text: string): Command;
 /** Marks a comment thread resolved or open without deleting it. */

package/dist/editor/commands/comments/editing.js

@@ -4,11 +4,11 @@ import {
 } from "prosemirror-state";
 import { commentParaId } from "../../../docx/comments.js";
 import { docxSchema } from "../../../schema/index.js";
-import { transactionAllowed } from "../../../schema/guards.js";
+import { guardedCommand } from "../../../schema/guards.js";
 import {
   reservedCommentIds,
   reservedCommentParaIds
-} from "../../plugins/commentReservations.js";
+} from "../../editorDocument.js";
 import { documentComments, repliesAttr, stringAttr } from "./reading.js";
 function validCommentSelection(state) {
   const { selection } = state;
@@ -113,27 +113,21 @@ function addCommentTransaction(state, comment) {
     null,
     startMarks
   );
-  const transaction = state.tr.insert(to, end).insert(to + 1, reference).insert(from, start);
-  return transactionAllowed(transaction, state) ? transaction : null;
+  return state.tr.insert(to, end).insert(to + 1, reference).insert(from, start);
+}
+function addComment(comment) {
+  return guardedCommand((state) => addCommentTransaction(state, comment));
 }
 function canAddComment(state) {
-  return addCommentTransaction(state, {
+  return addComment({
     text: "comment",
     author: "Author",
     date: "1970-01-01T00:00:00.000Z"
-  }) !== null;
-}
-function addComment(comment) {
-  return (state, dispatch) => {
-    const transaction = addCommentTransaction(state, comment);
-    if (!transaction) return false;
-    dispatch?.(transaction);
-    return true;
-  };
+  })(state);
 }
 function updateComment(id, text) {
-  return (state, dispatch) => {
-    if (text.trim().length === 0) return false;
+  return guardedCommand((state) => {
+    if (text.trim().length === 0) return null;
     let transaction = state.tr;
     let changed = false;
     state.doc.descendants((node, pos) => {
@@ -148,13 +142,11 @@ function updateComment(id, text) {
       }
       return true;
     });
-    if (!changed || !transactionAllowed(transaction, state)) return false;
-    dispatch?.(transaction);
-    return true;
-  };
+    return changed ? transaction : null;
+  });
 }
 function updateReference(id, change) {
-  return (state, dispatch) => {
+  return guardedCommand((state) => {
     let transaction = state.tr;
     let changed = false;
     state.doc.descendants((node, pos) => {
@@ -168,10 +160,8 @@ function updateReference(id, change) {
       }
       return false;
     });
-    if (!changed || !transactionAllowed(transaction, state)) return false;
-    dispatch?.(transaction);
-    return true;
-  };
+    return changed ? transaction : null;
+  });
 }
 function setCommentResolved(id, resolved) {
   return (state, dispatch) => updateReference(id, (node) => {
@@ -261,7 +251,7 @@ function removeCommentReply(commentId, replyId) {
   });
 }
 function removeComment(id) {
-  return (state, dispatch) => {
+  return guardedCommand((state) => {
     const positions = [];
     state.doc.descendants((node, pos) => {
       if ((node.type.name === "commentStart" || node.type.name === "commentEnd" || node.type.name === "commentReference") && stringAttr(node.attrs.id) === id) {
@@ -269,15 +259,13 @@ function removeComment(id) {
       }
       return true;
     });
-    if (positions.length === 0) return false;
+    if (positions.length === 0) return null;
     const transaction = state.tr;
     for (const marker of positions.sort((a, b) => b.pos - a.pos)) {
       transaction.delete(marker.pos, marker.pos + marker.size);
     }
-    if (!transactionAllowed(transaction, state)) return false;
-    dispatch?.(transaction);
-    return true;
-  };
+    return transaction;
+  });
 }
 function selectComment(id) {
   return (state, dispatch) => {

package/dist/editor/commands/exportQueries.d.ts

@@ -0,0 +1,15 @@
+/** Document-level readers for whether the document as it stands can be written back. */
+import type { EditorState } from "prosemirror-state";
+import { type ExportProblem } from "../../docx/invariants";
+export type { ExportProblem } from "../../docx/invariants";
+/**
+ * Every reason writing the document back would be refused, in the order `exportDocx` would raise
+ * them, each with the code and message the refusal would carry and the position in the document
+ * where there is one. Empty when the file would be written.
+ *
+ * A state built without an opened document has no file to write back into, so nothing about it
+ * can be refused and it reports no problem.
+ */
+export declare function documentExportProblems(state: EditorState): readonly ExportProblem[];
+/** Whether the document as it stands can be written back, which is what an export control is drawn from */
+export declare function canExport(state: EditorState): boolean;

package/dist/editor/commands/exportQueries.js

@@ -0,0 +1,14 @@
+// src/editor/commands/exportQueries.ts
+import { exportProblems } from "../../docx/invariants.js";
+import { documentOf } from "../editorDocument.js";
+function documentExportProblems(state) {
+  const { session } = documentOf(state);
+  return session === null ? [] : exportProblems(state.doc, session);
+}
+function canExport(state) {
+  return documentExportProblems(state).length === 0;
+}
+export {
+  canExport,
+  documentExportProblems
+};

package/dist/editor/commands/fidelityQueries.d.ts

@@ -0,0 +1,12 @@
+/** Document-level reader for what the open document holds that the editor cannot model. */
+import type { EditorState } from "prosemirror-state";
+import { type FidelityNote } from "../../docx/fidelity";
+export type { FidelityCode, FidelityNote, FidelitySeverity, } from "../../docx/fidelity";
+/**
+ * What the document standing in the editor hides, stands a placeholder in front of, or approximates.
+ *
+ * The notes are read off the document as it is now, so a note goes away as soon as an edit removes
+ * what it was about. `part` is null: an editor state carries the document and not the file it came
+ * from, and `importDocx` is where a note can name the part it belongs to.
+ */
+export declare function documentFidelity(state: EditorState): readonly FidelityNote[];

package/dist/editor/commands/fidelityQueries.js

@@ -0,0 +1,8 @@
+// src/editor/commands/fidelityQueries.ts
+import { fidelityNotesOf } from "../../docx/fidelity.js";
+function documentFidelity(state) {
+  return fidelityNotesOf(state.doc, null);
+}
+export {
+  documentFidelity
+};