@portone/docx-editor 0.1.1 → 0.2.1

package/dist/docx/storyProjection.d.ts

@@ -0,0 +1,36 @@
+/**
+ * The document story as the parts of the package see it: which blocks the editor models and
+ * writes back itself, and the text those blocks go back out as.
+ *
+ * Two files saying the same thing can spell it differently. A block carries the XML it arrived
+ * as on its attrs, so a table Word wrote (`w:w` before `w:type` inside a `w:tcW`) and the same
+ * table this editor wrote (the other way round) compare unequal attr for attr, and a comparison
+ * over the model would call that a body edit. Writing both stories out through the one writer
+ * takes the wording out of the comparison and leaves what the story says, because the writer
+ * reaches a fixed point on its own output: opening what it wrote and writing it again gives the
+ * same text (the test beside this file holds that over every fixture).
+ *
+ * What falls out of the comparison is of two kinds, and the test beside this file keeps them
+ * apart. One is two spellings of a single thing, which the writer settles on one of; forgiving
+ * those is the point, and the set of them is open. The other is content the writer builds afresh
+ * instead of reading, a table's grid and a drawing's extent among it, which the comparison cannot
+ * report because it can no longer see it. That second set is enumerated and meant to shrink: a
+ * case joining it is a preservation defect in the writer, not a detail of the comparison.
+ */
+import type { Node as PMNode } from "prosemirror-model";
+import type { SessionStore } from "./session";
+/** A document and the package it was opened from, which is what writing it back out takes */
+export interface Story {
+    readonly doc: PMNode;
+    readonly session: SessionStore;
+}
+/** Whether this is a block the editor takes apart and writes back itself, rather than one it keeps as it came */
+export declare function isModelledBlock(node: PMNode): boolean;
+/**
+ * Every top-level block as the writer puts it out, with the markup that is allowed to have
+ * changed taken away first.
+ *
+ * null where a block cannot be written back at all, which is a story no comparison can be held
+ * over: a caller judging two files answers such a story the way it answers a changed one.
+ */
+export declare function comparableStory(story: Story, strip: (node: PMNode) => PMNode): readonly string[] | null;

package/dist/docx/storyProjection.js

@@ -0,0 +1,23 @@
+// src/docx/storyProjection.ts
+import { DocxExportError } from "../ooxml/errors.js";
+import { NO_EXPORT_REFS } from "./exportRefs.js";
+import { serializeBlock } from "./serializeBlock.js";
+function isModelledBlock(node) {
+  return node.type.isInGroup("modelled");
+}
+function comparableStory(story, strip) {
+  const blocks = [];
+  try {
+    story.doc.forEach((block) => {
+      blocks.push(serializeBlock(strip(block), story.session, NO_EXPORT_REFS));
+    });
+  } catch (error) {
+    if (error instanceof DocxExportError) return null;
+    throw error;
+  }
+  return blocks;
+}
+export {
+  comparableStory,
+  isModelledBlock
+};

package/dist/docx/tableFormatting/editing.js

@@ -1,6 +1,9 @@
 // src/docx/tableFormatting/editing.ts
+import { attrPairs, elementXml } from "../../ooxml/element.js";
+import { wName } from "../../ooxml/names.js";
+import { setAttr } from "../../ooxml/precedence.js";
 import { normalizeHex, wAttr } from "../../ooxml/units.js";
-import { childByLocalName, escapeXml, localPart } from "../../ooxml/xml.js";
+import { childByLocalName } from "../../ooxml/xml.js";
 import {
   parseProps,
   parsePropsXml,
@@ -41,55 +44,34 @@ var SIDE_NAMES = {
   right: ["right", "end"]
 };
 var PRESET_BORDER_EIGHTHS = 4;
-var THEME_COLOR_ATTRS = ["themeColor", "themeTint", "themeShade"];
-var THEME_FILL_ATTRS = ["themeFill", "themeFillTint", "themeFillShade"];
 var EMPTY_TC_PR = { tag: "w:tcPr", attrs: null, children: [] };
-function attrsOf(el) {
-  return el ? Array.from(el.attributes).map((attr) => [attr.name, attr.value]) : [];
-}
-function withAttr(attrs, name, value, overridden = []) {
-  const kept = attrs.filter(([attr]) => !overridden.includes(localPart(attr)));
-  const at = kept.findIndex(([attr]) => localPart(attr) === name);
-  if (at === -1) return [...kept, [`w:${name}`, value]];
-  return kept.map(
-    (attr, index) => index === at ? [attr[0], value] : attr
-  );
-}
-function elementXml(tag, attrs) {
-  const text = attrs.map(([name, value]) => `${name}="${escapeXml(value)}"`).join(" ");
-  return `<${tag} ${text}/>`;
-}
 function drawsLine(side) {
   if (!side) return false;
   const val = wAttr(side, "val");
   return val !== null && val !== "nil" && val !== "none";
 }
-function sideAttrs(current, edit, fallback = null) {
+function sideAttrs(name, current, edit, fallback = null) {
   if (edit.kind === "color") {
     if (!drawsLine(current)) {
       if (current || !fallback || fallback === "none") return null;
       return inheritedBorderAttrs(fallback, edit.hex);
     }
-    return withAttr(
-      attrsOf(current),
-      "color",
-      edit.hex ?? "auto",
-      THEME_COLOR_ATTRS
-    );
+    return setAttr(attrPairs(current), name, "color", edit.hex ?? "auto");
   }
   if (edit.line === "none") {
-    return current ? withAttr(attrsOf(current), "val", "none") : [["w:val", "none"]];
+    return current ? setAttr(attrPairs(current), name, "val", "none") : [[wName("val"), "none"]];
   }
   if (!current) {
     return [
-      ["w:val", "single"],
-      ["w:sz", `${PRESET_BORDER_EIGHTHS}`],
-      ["w:space", "0"],
-      ["w:color", "auto"]
+      [wName("val"), "single"],
+      [wName("sz"), `${PRESET_BORDER_EIGHTHS}`],
+      [wName("space"), "0"],
+      [wName("color"), "auto"]
     ];
   }
-  return withAttr(
-    withAttr(attrsOf(current), "val", "single"),
+  return setAttr(
+    setAttr(attrPairs(current), name, "val", "single"),
+    name,
     "sz",
     `${PRESET_BORDER_EIGHTHS}`
   );
@@ -110,10 +92,10 @@ function inheritedBorderAttrs(border, hex) {
   const eighths = Math.round(Number.parseFloat(widthText) * 8);
   if (!Number.isSafeInteger(eighths) || eighths <= 0) return null;
   return [
-    ["w:val", BORDER_VAL_BY_CSS_STYLE[style.toLowerCase()]],
-    ["w:sz", `${eighths}`],
-    ["w:space", "0"],
-    ["w:color", hex ?? "auto"]
+    [wName("val"), BORDER_VAL_BY_CSS_STYLE[style.toLowerCase()]],
+    [wName("sz"), `${eighths}`],
+    [wName("space"), "0"],
+    [wName("color"), hex ?? "auto"]
   ];
 }
 function sideNames(borders, side) {
@@ -127,12 +109,12 @@ function editedBorders(current, edit, defaults = NO_BORDER_DEFAULTS) {
   const borders = current === null ? null : parsePropsXml(current);
   if (!props || current !== null && !borders) return null;
   const sides = edit.kind === "line" ? edit.sides : ALL_CELL_SIDES;
-  const children = sides.reduce((kept, side) => {
+  const edited = sides.reduce((kept, side) => {
     const { write, drop } = sideNames(borders, side);
     const currentSide = borders ? childByLocalName(borders, write) : null;
-    const attrs = sideAttrs(currentSide, edit, defaults[side]);
+    const attrs = sideAttrs(write, currentSide, edit, defaults[side]);
     if (!attrs) return kept;
-    const tag = currentSide?.nodeName ?? `w:${write}`;
+    const tag = currentSide?.nodeName ?? wName(write);
     const written = setPropsChild(
       kept,
       write,
@@ -140,8 +122,8 @@ function editedBorders(current, edit, defaults = NO_BORDER_DEFAULTS) {
       TC_BORDERS_ORDER
     );
     return drop === null ? written : setPropsChild(written, drop, null, TC_BORDERS_ORDER);
-  }, props.children);
-  const xml = renderProps({ ...props, children });
+  }, props);
+  const xml = renderProps(edited);
   return { xml: xml === "" ? null : xml };
 }
 function hasPattern(shd) {
@@ -149,23 +131,20 @@ function hasPattern(shd) {
   return val !== null && val !== "clear" && val !== "nil";
 }
 function editedShading(current, fill) {
-  const tag = current?.nodeName ?? "w:shd";
+  const tag = current?.nodeName ?? wName("shd");
   if (fill === null) {
     if (!hasPattern(current)) return null;
-    return elementXml(
-      tag,
-      withAttr(attrsOf(current), "fill", "auto", THEME_FILL_ATTRS)
-    );
+    return elementXml(tag, setAttr(attrPairs(current), "shd", "fill", "auto"));
   }
   if (!current) {
     return elementXml(tag, [
-      ["w:val", "clear"],
-      ["w:color", "auto"],
-      ["w:fill", fill]
+      [wName("val"), "clear"],
+      [wName("color"), "auto"],
+      [wName("fill"), fill]
     ]);
   }
-  const painting = hasPattern(current) ? attrsOf(current) : withAttr(attrsOf(current), "val", "clear");
-  return elementXml(tag, withAttr(painting, "fill", fill, THEME_FILL_ATTRS));
+  const painting = hasPattern(current) ? attrPairs(current) : setAttr(attrPairs(current), "shd", "val", "clear");
+  return elementXml(tag, setAttr(painting, "shd", "fill", fill));
 }
 function bordersChange(props, edit, defaults) {
   const current = propsChild(props.children, "tcBorders")?.xml ?? null;
@@ -191,7 +170,7 @@ function paddingChange(props, values) {
   const margins = current === null ? null : parsePropsXml(current);
   const parsed = current === null ? { tag: "w:tcMar", attrs: null, children: [] } : parseProps(current);
   if (!parsed || current !== null && !margins) return null;
-  let children = parsed.children;
+  let edited = parsed;
   let wrote = false;
   for (const side of ALL_CELL_SIDES) {
     const points = values[side];
@@ -202,21 +181,22 @@ function paddingChange(props, values) {
     }
     const existing = margins ? MARGIN_SIDE_NAMES[side].map((name2) => childByLocalName(margins, name2)).find((element) => element !== null) ?? null : null;
     const name = existing?.localName ?? side;
-    const attrs = withAttr(
-      withAttr(attrsOf(existing), "w", `${twips}`),
+    const attrs = setAttr(
+      setAttr(attrPairs(existing), name, "w", `${twips}`),
+      name,
       "type",
       "dxa"
     );
-    children = setPropsChild(
-      children,
+    edited = setPropsChild(
+      edited,
       name,
-      elementXml(existing?.nodeName ?? `w:${side}`, attrs),
+      elementXml(existing?.nodeName ?? wName(side), attrs),
       TC_MAR_ORDER
     );
     wrote = true;
   }
   if (!wrote) return null;
-  return { name: "tcMar", xml: renderProps({ ...parsed, children }) };
+  return { name: "tcMar", xml: renderProps(edited) };
 }
 function childChange(edit, props, defaults) {
   switch (edit.kind) {
@@ -250,8 +230,8 @@ function childChange(edit, props, defaults) {
       return {
         name: "vAlign",
         xml: elementXml(
-          element?.nodeName ?? "w:vAlign",
-          withAttr(attrsOf(element), "val", edit.align)
+          element?.nodeName ?? wName("vAlign"),
+          setAttr(attrPairs(element), "vAlign", "val", edit.align)
         )
       };
     }
@@ -264,13 +244,9 @@ function editCellProps(tcPr, edit, defaults = NO_BORDER_DEFAULTS, margins = NO_C
   if (!props) return null;
   const change = childChange(edit, props, defaults);
   if (!change) return null;
-  const children = setPropsChild(
-    props.children,
-    change.name,
-    change.xml,
-    TC_PR_ORDER
+  const rendered = renderProps(
+    setPropsChild(props, change.name, change.xml, TC_PR_ORDER)
   );
-  const rendered = renderProps({ ...props, children });
   const next = rendered === "" ? null : rendered;
   if (next === tcPr) return null;
   return { tcPr: next, format: readCellProps(next, defaults, margins) };
@@ -294,17 +270,17 @@ function editRowHeight(trPr, heightPt) {
   const element = current === null ? null : parsePropsXml(current);
   if (current !== null && !element) return null;
   const writtenRule = element ? wAttr(element, "hRule") : null;
-  const attrs = withAttr(attrsOf(element), "val", `${twips}`);
-  const nextAttrs = withAttr(
+  const attrs = setAttr(attrPairs(element), "trHeight", "val", `${twips}`);
+  const nextAttrs = setAttr(
     attrs,
+    "trHeight",
     "hRule",
     writtenRule === "exact" ? "exact" : "atLeast"
   );
-  const child = elementXml(element?.nodeName ?? "w:trHeight", nextAttrs);
-  const rendered = renderProps({
-    ...props,
-    children: setPropsChild(props.children, "trHeight", child, TR_PR_ORDER)
-  });
+  const child = elementXml(element?.nodeName ?? wName("trHeight"), nextAttrs);
+  const rendered = renderProps(
+    setPropsChild(props, "trHeight", child, TR_PR_ORDER)
+  );
   if (rendered === trPr) return null;
   const parsed = parsePropsXml(rendered);
   const format = parsed ? readRowFormat(parsed) : null;

package/dist/docx/tableTemplate.js

@@ -1,4 +1,6 @@
 // src/docx/tableTemplate.ts
+import { elementXml } from "../ooxml/element.js";
+import { wName } from "../ooxml/names.js";
 import { docxSchema } from "../schema/index.js";
 import { A4_PORTRAIT, bodyWidth } from "./pageGeometry.js";
 import { parsePropsXml } from "./propsXml.js";
@@ -25,14 +27,33 @@ var BORDER_SIDES = [
   "insideV"
 ];
 function borderXml(side) {
-  return `<w:${side} w:val="single" w:sz="${BORDER_EIGHTHS}" w:space="0" w:color="000000"/>`;
+  return elementXml(wName(side), [
+    [wName("val"), "single"],
+    [wName("sz"), `${BORDER_EIGHTHS}`],
+    [wName("space"), "0"],
+    [wName("color"), "000000"]
+  ]);
 }
 function tablePropsXml(width) {
   const borders = BORDER_SIDES.map(borderXml).join("");
-  return `<w:tblPr><w:tblW w:w="${width}" w:type="dxa"/><w:tblBorders>${borders}</w:tblBorders><w:tblLayout w:type="fixed"/></w:tblPr>`;
+  return elementXml(
+    wName("tblPr"),
+    [],
+    [
+      widthXml("tblW", width),
+      elementXml(wName("tblBorders"), [], [borders]),
+      elementXml(wName("tblLayout"), [[wName("type"), "fixed"]])
+    ]
+  );
+}
+function widthXml(name, width) {
+  return elementXml(wName(name), [
+    [wName("w"), `${width}`],
+    [wName("type"), "dxa"]
+  ]);
 }
 function cellPropsXml(width) {
-  return `<w:tcPr><w:tcW w:w="${width}" w:type="dxa"/></w:tcPr>`;
+  return elementXml(wName("tcPr"), [], [widthXml("tcW", width)]);
 }
 function evenGridCols(cols, total) {
   const base = Math.floor(total / cols);

package/dist/docx/theme.d.ts

@@ -21,12 +21,6 @@ export interface ThemeFonts {
 }
 /** What applies to a document with no theme part, or one whose theme names no font */
 export declare const NO_THEME_FONTS: ThemeFonts;
-/**
- * The theme attribute paired with each font slot.
- * A theme reference and a name in the same slot cannot both apply, so the name wins,
- * the way Word reads them.
- */
-export declare const THEME_ATTRS: Record<string, readonly string[]>;
 /** The font one theme reference stands for. null for a reference we cannot resolve */
 export declare function themeFontName(fonts: ThemeFonts, value: string | null): string | null;
 /**

package/dist/docx/theme.js

@@ -9,13 +9,6 @@ var NO_THEME_FONTS = {
   major: NO_FONT_SCHEME,
   minor: NO_FONT_SCHEME
 };
-var THEME_ATTRS = {
-  ascii: ["asciiTheme"],
-  hAnsi: ["hAnsiTheme"],
-  eastAsia: ["eastAsiaTheme"],
-  // This is the slot whose capitalization varies from document to document
-  cs: ["cstheme", "csTheme"]
-};
 var THEME_SLOTS = {
   majorascii: { scheme: "major", script: "latin" },
   majorhansi: { scheme: "major", script: "latin" },
@@ -55,7 +48,6 @@ function readThemeFonts(theme) {
 }
 export {
   NO_THEME_FONTS,
-  THEME_ATTRS,
   readThemeFonts,
   themeFontName
 };

package/dist/editor/clipboard/images.js

@@ -1,6 +1,11 @@
 // src/editor/clipboard/images.ts
 import { MAX_IMAGE_BYTES } from "../../docx/media.js";
-import { isImageMime, toImageExtent, toImageSrc } from "../../ooxml/image.js";
+import {
+  isImageMime,
+  pxToEmu,
+  toImageExtent,
+  toImageSrc
+} from "../../ooxml/image.js";
 import { editorClassNames } from "../../styles/classNames.js";
 import {
   boundedImageSrc,
@@ -9,8 +14,7 @@ import {
   readImageSource
 } from "../imageFiles.js";
 var PASTED_IMAGE_ATTRIBUTE = "data-docx-pasted-image";
-function extentAttribute(element) {
-  if (!element.classList.contains(editorClassNames.image)) return null;
+function declaredExtent(element) {
   try {
     return toImageExtent(
       JSON.parse(element.getAttribute("data-extent") ?? "null")
@@ -19,6 +23,16 @@ function extentAttribute(element) {
     return null;
   }
 }
+function renderedExtent(element) {
+  const width = Number.parseInt(element.getAttribute("width") ?? "", 10);
+  const height = Number.parseInt(element.getAttribute("height") ?? "", 10);
+  if (!Number.isFinite(width) || !Number.isFinite(height)) return null;
+  return toImageExtent({ cx: pxToEmu(width), cy: pxToEmu(height) });
+}
+function extentAttribute(element) {
+  if (!element.classList.contains(editorClassNames.image)) return null;
+  return declaredExtent(element) ?? renderedExtent(element);
+}
 function fetchableUrl(source) {
   try {
     const url = new URL(source);

package/dist/editor/clipboard/inlineFormatting.d.ts

@@ -15,6 +15,13 @@ export interface InlineContext {
     preserveWhitespace: boolean;
 }
 export type InlineElementReader = (target: PMNode[], element: HTMLElement, context: InlineContext) => boolean;
+/**
+ * The address a link may carry, whichever way it travels.
+ *
+ * A copy writes one out and a paste reads one in, and an address this rule turns down is one
+ * neither end should act on, so both ask here.
+ */
+export declare function safeHref(value: string | null): string | null;
 export declare function contextFor(parent: InlineContext, element: HTMLElement, readElementStyle?: boolean): InlineContext;
 export declare function withInlineStyle(context: InlineContext, style: InlineStyle): InlineContext;
 export declare function marksFor(context: InlineContext): Mark[];

package/dist/editor/clipboard/inlineFormatting.js

@@ -228,5 +228,6 @@ export {
   appendInline,
   contextFor,
   marksFor,
+  safeHref,
   withInlineStyle
 };

package/dist/editor/commands/breakCommands.js

@@ -1,9 +1,13 @@
 // src/editor/commands/breakCommands.ts
 import { docxSchema } from "../../schema/index.js";
-import { replacementShut } from "../../schema/locks.js";
+import { editShut, selectionIntents } from "../../schema/guards.js";
 function insertBreak(brAttrs) {
   return (state, dispatch) => {
-    if (replacementShut(state.selection, state.doc)) return false;
+    if (selectionIntents(state.selection, "replace").some(
+      (intent) => editShut(state, intent)
+    )) {
+      return false;
+    }
     if (dispatch) {
       const br = docxSchema.nodes.hardBreak.create({ brAttrs });
       dispatch(state.tr.replaceSelectionWith(br).scrollIntoView());

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

@@ -1,6 +1,7 @@
 /**
- * Dry-runs external commands and checks every produced transaction against document locks without
- * dispatching them or triggering the locked-content plugin's side effects.
+ * Dry-runs external commands and checks every produced transaction against every guard
+ * (`schema/guards`) without dispatching them or triggering the locked-content plugin's side
+ * effects.
  */
 import type { Command, EditorState } from "prosemirror-state";
 export declare function canRunCommand(command: Command, state: EditorState): boolean;

package/dist/editor/commands/canRunCommand.js

@@ -1,9 +1,9 @@
 // src/editor/commands/canRunCommand.ts
-import { transactionAllowed } from "../../schema/locks.js";
+import { transactionAllowed } from "../../schema/guards.js";
 function canRunCommand(command, state) {
   const built = [];
   if (!command(state, (tr) => built.push(tr))) return false;
-  return built.every((tr) => transactionAllowed(tr, state.doc));
+  return built.every((tr) => transactionAllowed(tr, state));
 }
 export {
   canRunCommand

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

@@ -4,7 +4,7 @@ import {
 } from "prosemirror-state";
 import { commentParaId } from "../../../docx/comments.js";
 import { docxSchema } from "../../../schema/index.js";
-import { transactionAllowed } from "../../../schema/locks.js";
+import { transactionAllowed } from "../../../schema/guards.js";
 import {
   reservedCommentIds,
   reservedCommentParaIds
@@ -93,6 +93,7 @@ function addCommentTransaction(state, comment) {
       id,
       referenceXml: null,
       author: comment.author,
+      authorId: comment.authorId ?? null,
       initials: comment.initials ?? null,
       date,
       text: comment.text,
@@ -113,7 +114,7 @@ function addCommentTransaction(state, comment) {
     startMarks
   );
   const transaction = state.tr.insert(to, end).insert(to + 1, reference).insert(from, start);
-  return transactionAllowed(transaction, state.doc) ? transaction : null;
+  return transactionAllowed(transaction, state) ? transaction : null;
 }
 function canAddComment(state) {
   return addCommentTransaction(state, {
@@ -147,7 +148,7 @@ function updateComment(id, text) {
       }
       return true;
     });
-    if (!changed || !transactionAllowed(transaction, state.doc)) return false;
+    if (!changed || !transactionAllowed(transaction, state)) return false;
     dispatch?.(transaction);
     return true;
   };
@@ -167,7 +168,7 @@ function updateReference(id, change) {
       }
       return false;
     });
-    if (!changed || !transactionAllowed(transaction, state.doc)) return false;
+    if (!changed || !transactionAllowed(transaction, state)) return false;
     dispatch?.(transaction);
     return true;
   };
@@ -177,11 +178,9 @@ function setCommentResolved(id, resolved) {
     if (node.attrs.resolved === resolved) return null;
     return {
       ...node.attrs,
-      paraId: node.attrs.threadImported === true && node.attrs.extensionXml === null ? nextCommentParaId(state, `comment-${id}`) : node.attrs.paraId,
       resolved,
       extensionXml: null,
-      threadImported: false,
-      imported: node.attrs.commentXml !== null && node.attrs.extensionXml === null ? false : node.attrs.imported
+      threadImported: false
     };
   })(state, dispatch);
 }
@@ -191,7 +190,7 @@ function addCommentReply(id, reply) {
     const replyId = nextCommentId(state);
     const date = reply.date ?? (/* @__PURE__ */ new Date()).toISOString();
     return updateReference(id, (node) => {
-      const parentParaId = node.attrs.threadImported === true && node.attrs.extensionXml === null ? nextCommentParaId(state, `comment-${id}`) : stringAttr(node.attrs.paraId) ?? nextCommentParaId(state, `comment-${id}`);
+      const parentParaId = stringAttr(node.attrs.paraId) ?? nextCommentParaId(state, `comment-${id}`);
       const paraId = nextCommentParaId(state, `comment-${replyId}-${date}`, [
         parentParaId
       ]);
@@ -201,12 +200,12 @@ function addCommentReply(id, reply) {
         resolved: false,
         extensionXml: null,
         threadImported: false,
-        imported: node.attrs.commentXml !== null && node.attrs.extensionXml === null ? false : node.attrs.imported,
         replies: [
           ...repliesAttr(node.attrs.replies),
           {
             id: replyId,
             author: reply.author,
+            authorId: reply.authorId ?? null,
             initials: reply.initials ?? null,
             date,
             text: reply.text,
@@ -275,7 +274,7 @@ function removeComment(id) {
     for (const marker of positions.sort((a, b) => b.pos - a.pos)) {
       transaction.delete(marker.pos, marker.pos + marker.size);
     }
-    if (!transactionAllowed(transaction, state.doc)) return false;
+    if (!transactionAllowed(transaction, state)) return false;
     dispatch?.(transaction);
     return true;
   };

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

@@ -1,11 +1,18 @@
 /** Public comment values and shared attribute readers. */
 export interface CommentAuthor {
+    /**
+     * The identity behind the name, an opaque string the host application chooses. Recorded in the
+     * document's people part, and what decides whose comment a comment is (`schema/protection`).
+     */
+    id: string;
     name: string;
     initials?: string;
 }
 export interface NewComment {
     text: string;
     author: string;
+    /** The identity behind `author`. A comment written without one belongs to nobody in particular */
+    authorId?: string;
     initials?: string;
     /** ISO 8601 timestamp. The current time is used when omitted. */
     date?: string;
@@ -13,6 +20,7 @@ export interface NewComment {
 export interface DocumentComment {
     id: string;
     author: string | null;
+    authorId: string | null;
     initials: string | null;
     date: string | null;
     text: string;
@@ -25,6 +33,7 @@ export interface DocumentComment {
 export interface DocumentCommentReply {
     id: string;
     author: string | null;
+    authorId: string | null;
     initials: string | null;
     date: string | null;
     text: string;

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

@@ -6,3 +6,10 @@ export declare function stringAttr(value: unknown): string | null;
 export declare function repliesAttr(value: unknown): readonly CommentReplyData[];
 /** Comments in document order, including point comments that have no explicit range. */
 export declare function documentComments(state: EditorState): readonly DocumentComment[];
+/**
+ * Whether the body of this comment, or of one of its replies, may be edited or deleted here: the
+ * protection lets comments be edited at all, and the body is one of one's own to edit
+ * (`schema/protection`). Replying and settling a thread are not governed by this; a comment command
+ * asked without `dispatch` answers for those.
+ */
+export declare function canEditComment(state: EditorState, commentId: string, replyId?: string | null): boolean;

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

@@ -1,4 +1,6 @@
 // src/editor/commands/comments/reading.ts
+import { commentOwned } from "../../../schema/protection.js";
+import { protectionOf } from "../../../schema/protectionState.js";
 function stringAttr(value) {
   return typeof value === "string" ? value : null;
 }
@@ -34,6 +36,7 @@ function documentComments(state) {
     return {
       id,
       author: stringAttr(node.attrs.author),
+      authorId: stringAttr(node.attrs.authorId),
       initials: stringAttr(node.attrs.initials),
       date: stringAttr(node.attrs.date),
       text: stringAttr(node.attrs.text) ?? "",
@@ -44,6 +47,7 @@ function documentComments(state) {
       replies: repliesAttr(node.attrs.replies).map((reply) => ({
         id: reply.id,
         author: reply.author,
+        authorId: reply.authorId,
         initials: reply.initials,
         date: reply.date,
         text: reply.text
@@ -51,7 +55,17 @@ function documentComments(state) {
     };
   });
 }
+function canEditComment(state, commentId, replyId = null) {
+  const rules = protectionOf(state);
+  if (rules.protection === "readOnly") return false;
+  const comment = documentComments(state).find(
+    (entry) => entry.id === commentId
+  );
+  const body = replyId === null ? comment : comment?.replies.find((reply) => reply.id === replyId);
+  return body !== void 0 && commentOwned(rules, body.authorId);
+}
 export {
+  canEditComment,
   documentComments,
   repliesAttr,
   stringAttr