@portone/docx-editor 0.1.1 → 0.2.1

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

@@ -9,6 +9,7 @@ import {
   insertionInsideLocked,
   rangeTouchesLocked
 } from "../../../schema/locks.js";
+import { editsShut } from "../../../schema/protectionState.js";
 import {
   activePieces,
   caretPiece,
@@ -69,9 +70,13 @@ function applyToCaret(state, dispatch, edit) {
   return true;
 }
 function runEditCommand(edit) {
-  return (state, dispatch) => state.selection.empty ? applyToCaret(state, dispatch, edit) : applyToSelection(state, dispatch, edit);
+  return (state, dispatch) => {
+    if (editsShut(state)) return false;
+    return state.selection.empty ? applyToCaret(state, dispatch, edit) : applyToSelection(state, dispatch, edit);
+  };
 }
 function canFormatText(state) {
+  if (editsShut(state)) return false;
   if (state.selection.empty) {
     return !insertionInsideLocked(state.doc, state.selection.from);
   }

package/dist/editor/commands/historyCommands.js

@@ -1,12 +1,21 @@
 // src/editor/commands/historyCommands.ts
 import { redo as historyRedo, undo as historyUndo } from "prosemirror-history";
+import { transactionAllowed } from "../../schema/guards.js";
 import { historyReplay } from "../../schema/locks.js";
 function replaying(command) {
-  return (state, dispatch, view) => command(
-    state,
-    dispatch && ((tr) => dispatch(tr.setMeta(historyReplay, true))),
-    view
-  );
+  return (state, dispatch, view) => {
+    const built = [];
+    const answered = command(
+      state,
+      (tr) => built.push(tr.setMeta(historyReplay, true)),
+      view
+    );
+    if (!answered || !built.every((tr) => transactionAllowed(tr, state))) {
+      return false;
+    }
+    if (dispatch) for (const tr of built) dispatch(tr);
+    return true;
+  };
 }
 var undo = replaying(historyUndo);
 var redo = replaying(historyRedo);

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

@@ -15,6 +15,12 @@ export type { LineSpacing, ParagraphAlign } from "../../model/format";
 export type { ListKind } from "../../numbering/listTemplate";
 /** The size an image is shown at, which the insert command asks for */
 export type { ImageExtent } from "../../ooxml/image";
+/**
+ * What the editor as a whole may receive - everything, comments alone, or nothing - which a control
+ * of your own reads before it offers an edit, the way the built-in ones do.
+ */
+export type { EditableComments, EditingProtection, } from "../../schema/protection";
+export { editingProtection } from "../../schema/protectionState";
 /** The fonts to draw with where a document names one the machine does not have, which the font queries read */
 export type { FontFallbacks } from "../../styles/fontStack";
 /**
@@ -49,7 +55,7 @@ export { insertLineBreak, insertPageBreak } from "./breakCommands";
  */
 export { canRunCommand } from "./canRunCommand";
 export type { CommentAuthor, DocumentComment, DocumentCommentReply, NewComment, } from "./commentCommands";
-export { addComment, addCommentReply, canAddComment, documentComments, removeComment, removeCommentReply, selectComment, setCommentResolved, updateComment, updateCommentReply, } from "./commentCommands";
+export { addComment, addCommentReply, canAddComment, canEditComment, documentComments, removeComment, removeCommentReply, selectComment, setCommentResolved, updateComment, updateCommentReply, } from "./commentCommands";
 export type { ActiveFontFamily, ActiveFontSize, } from "./formattingCommands";
 export { activeFontFamily, activeFontSize, activeTextBackground, activeTextColor, canFormatText, documentFontNames, isBoldActive, isItalicActive, isStrikeActive, isUnderlineActive, setFontFamily, setFontSize, setTextBackground, setTextColor, toggleBold, toggleItalic, toggleStrike, toggleUnderline, } from "./formattingCommands";
 /**

package/dist/editor/commands/index.js

@@ -1,4 +1,5 @@
 // src/editor/commands/index.ts
+import { editingProtection } from "../../schema/protectionState.js";
 import {
   documentBodyWidthPx,
   documentDefaults,
@@ -19,6 +20,7 @@ import {
   addComment,
   addCommentReply,
   canAddComment,
+  canEditComment,
   documentComments,
   removeComment,
   removeCommentReply,
@@ -108,6 +110,7 @@ export {
   addCommentReply,
   canAddComment,
   canDecreaseIndent,
+  canEditComment,
   canFormatText,
   canIncreaseIndent,
   canInsertImage,
@@ -125,6 +128,7 @@ export {
   documentHasLocked,
   documentNotes,
   documentParagraphStyles,
+  editingProtection,
   fittedExtent,
   imageFilesIn,
   increaseIndent,

package/dist/editor/commands/linkCommands.js

@@ -1,6 +1,7 @@
 // src/editor/commands/linkCommands.ts
 import { docxSchema } from "../../schema/index.js";
 import { rangeTouchesLocked } from "../../schema/locks.js";
+import { editsShut } from "../../schema/protectionState.js";
 var linkType = docxSchema.marks.link;
 function text(value) {
   return typeof value === "string" ? value : null;
@@ -74,6 +75,7 @@ function linkSpansTouching(doc, from, to) {
   return spans;
 }
 function openPieces(state) {
+  if (editsShut(state)) return [];
   const found = state.selection.empty ? caretPieces(state) : selectionPieces(state);
   return found.filter(
     (piece) => !rangeTouchesLocked(state.doc, piece.from, piece.to)

package/dist/editor/commands/lockCommands.js

@@ -4,6 +4,8 @@ import {
 } from "prosemirror-state";
 import { namesNothing, newControlId } from "../../docx/sdt.js";
 import { withContentLock } from "../../docx/sdtProps.js";
+import { elementXml, openTagXml } from "../../ooxml/element.js";
+import { wName } from "../../ooxml/names.js";
 import { docxSchema } from "../../schema/index.js";
 import {
   carriesLock,
@@ -13,9 +15,17 @@ import {
   selectionShut,
   unlockAllowed
 } from "../../schema/locks.js";
+import { editsShut } from "../../schema/protectionState.js";
 function lockedControlMark(id) {
   return docxSchema.marks.sdt.create({
-    sdtPrefix: `<w:sdt><w:sdtPr><w:id w:val="${id}"/><w:lock w:val="sdtContentLocked"/></w:sdtPr>`,
+    sdtPrefix: openTagXml(wName("sdt"), null) + elementXml(
+      wName("sdtPr"),
+      [],
+      [
+        elementXml(wName("id"), [[wName("val"), `${id}`]]),
+        elementXml(wName("lock"), [[wName("val"), "sdtContentLocked"]])
+      ]
+    ),
     contentsLocked: true,
     deletionLocked: true
   });
@@ -88,6 +98,7 @@ function blockLockEdits(doc, block, spans, reach) {
   return [...shut, ...fresh];
 }
 function selectionLockDetail(state) {
+  if (editsShut(state)) return { kind: "none" };
   const selection = state.selection;
   const locking = !selection.empty && selection instanceof TextSelection;
   const edits = [];

package/dist/editor/commands/tabCommands.js

@@ -4,7 +4,7 @@ import {
 } from "prosemirror-state";
 import { toParagraphFormat } from "../../model/format.js";
 import { docxSchema } from "../../schema/index.js";
-import { replacementShut } from "../../schema/locks.js";
+import { editShut, selectionIntents } from "../../schema/guards.js";
 function isOrdinaryParagraph(state) {
   const { $from } = state.selection;
   if ($from.parent.type !== docxSchema.nodes.paragraph || toParagraphFormat($from.parent.attrs.format)?.numbering) {
@@ -17,7 +17,9 @@ function isOrdinaryParagraph(state) {
 }
 var insertTab = (state, dispatch) => {
   const { selection } = state;
-  if (!(selection instanceof TextSelection) || !selection.$from.sameParent(selection.$to) || !isOrdinaryParagraph(state) || replacementShut(selection, state.doc)) {
+  if (!(selection instanceof TextSelection) || !selection.$from.sameParent(selection.$to) || !isOrdinaryParagraph(state) || selectionIntents(selection, "replace").some(
+    (intent) => editShut(state, intent)
+  )) {
     return false;
   }
   if (dispatch) {

package/dist/editor/createEditor.d.ts

@@ -8,7 +8,9 @@ import { type ParagraphFormatLayer, type ParagraphStyleOption, type StyleTable }
 import { type PageGeometry } from "../docx/pageGeometry";
 import type { DocumentDefaults } from "../model/format";
 import { type Numbering } from "../numbering/parseNumbering";
+import type { EditableComments, EditingProtection } from "../schema/protection";
 import { type FontFallbacks } from "../styles/fontStack";
+import type { CommentAuthor } from "./commands/comments/model";
 export interface EditorStateOptions {
     numbering?: Numbering;
     styles?: StyleTable;
@@ -38,22 +40,30 @@ export interface EditorStateOptions {
     reservedCommentIds?: Iterable<string>;
     /** Every paragraph id present in the opened comment parts, including orphan extension entries. */
     reservedCommentParaIds?: Iterable<string>;
+    /**
+     * What the document as a whole may receive (`schema/protection`): everything, comments alone,
+     * or nothing. Everything when none is given, which is what every state was before.
+     */
+    protection?: EditingProtection;
+    /** Whose comments are written, and so whose may be edited under `editableComments: "own"` */
+    author?: CommentAuthor | null;
+    /** Whose comments may be edited or deleted. One's own when none is given */
+    editableComments?: EditableComments;
 }
 /**
  * Creates a single editing state.
  * The list definitions, the style table, and the document defaults are what the document
  * wrote down, and commands and the toolbar read them through plugins.
  */
-export declare function createEditorState(doc: PMNode, { numbering, styles, defaults, paragraphDefaults, canStartNewList, consumerPlugins, paragraphStyles, contextMenus, geometry, defaultTabStopPt, reservedCommentIds, reservedCommentParaIds, }?: EditorStateOptions): EditorState;
+export declare function createEditorState(doc: PMNode, { numbering, styles, defaults, paragraphDefaults, canStartNewList, consumerPlugins, paragraphStyles, contextMenus, geometry, defaultTabStopPt, reservedCommentIds, reservedCommentParaIds, protection, author, editableComments, }?: EditorStateOptions): EditorState;
 export interface EditorOptions {
     mount: HTMLElement;
     state: EditorState;
     defaults: DocumentDefaults;
     /** The paper the document names. The sheet is drawn from it, A4 where a document names none */
     geometry?: PageGeometry;
-    readOnly: boolean;
     /** The fonts stood in for the ones the document declares. The built-in set when none is given */
     fontFallbacks?: FontFallbacks;
     onStateChange: (state: EditorState) => void;
 }
-export declare function createEditorView({ mount, state, defaults, geometry, readOnly, fontFallbacks, onStateChange, }: EditorOptions): EditorView;
+export declare function createEditorView({ mount, state, defaults, geometry, fontFallbacks, onStateChange, }: EditorOptions): EditorView;

package/dist/editor/createEditor.js

@@ -15,6 +15,7 @@ import { A4_PORTRAIT } from "../docx/pageGeometry.js";
 import { EMPTY_NUMBERING } from "../numbering/parseNumbering.js";
 import { pageDecorations } from "../page/pageDecorations.js";
 import { pageGeometryStyle, pagePixels } from "../page/pageLayout.js";
+import { editsShut } from "../schema/protectionState.js";
 import { editorClassNames } from "../styles/classNames.js";
 import {
   DEFAULT_FONT_FALLBACKS
@@ -24,16 +25,15 @@ import { gridBorders, withDerivedGridBorders } from "../table/gridBorders.js";
 import { documentDefaultTabStopPt, documentStyleTable } from "./documentStyles.js";
 import { externalClipboard } from "./externalClipboard.js";
 import { imageFiles } from "./imageFiles.js";
-import { bookmarkProtection } from "./plugins/bookmarkProtection.js";
 import { columnResize } from "./plugins/columnResize.js";
 import { commentDecorations } from "./plugins/commentDecorations.js";
 import { commentReservations } from "./plugins/commentReservations.js";
+import { documentProtection } from "./plugins/documentProtection.js";
 import { imagePaste } from "./plugins/imagePaste.js";
-import { docxKeymap } from "./plugins/keymap.js";
+import { docxKeymap, historyKeys } from "./plugins/keymap.js";
 import { linkPanel } from "./plugins/linkPanel.js";
 import { listInputRules } from "./plugins/listInputRules.js";
 import { lockedContent } from "./plugins/lockedContent.js";
-import { noteProtection } from "./plugins/noteProtection.js";
 import { numberingMarkers } from "./plugins/numberingDecorations.js";
 import { rowResize } from "./plugins/rowResize.js";
 import { styledParagraphs } from "./plugins/styledParagraphs.js";
@@ -57,7 +57,10 @@ function createEditorState(doc, {
   geometry = A4_PORTRAIT,
   defaultTabStopPt = DEFAULT_TAB_STOP_PT,
   reservedCommentIds = [],
-  reservedCommentParaIds = []
+  reservedCommentParaIds = [],
+  protection = "none",
+  author = null,
+  editableComments = "own"
 } = {}) {
   return EditorState.create({
     doc: withDerivedGridBorders(doc),
@@ -66,17 +69,16 @@ function createEditorState(doc, {
       // first answer for a keypress, a paste, a drop or any other DOM event, so this is the
       // only place from which a consumer handler can win over the built-in one.
       ...consumerPlugins,
-      // Refuses every edit inside a locked content control, whoever asked for it. It is not
-      // optional: a document that locked a part of itself stays locked in every consumer.
+      // Refuses every edit no guard in `schema/guards` lets through, whoever asked for it. It is
+      // not optional: a document that locked a part of itself stays locked in every consumer, and
+      // the preserved bookmark markers and note references stay where the file put them.
       lockedContent(),
-      // Bookmark ranges are preserved rather than edited, so neither half may disappear.
-      bookmarkProtection(),
-      // Note bodies are display-only, so their imported main-story references stay paired.
-      noteProtection(),
+      documentProtection({ protection, author, editableComments }),
       // An orphan Comments-part entry still owns its id and must not be replaced by a new comment.
       commentReservations(reservedCommentIds, reservedCommentParaIds),
       history(),
       keymap(docxKeymap),
+      historyKeys(),
       keymap(baseKeymap),
       // Holds whether the link panel is open, which Cmd+K above and the toolbar button both set
       linkPanel(),
@@ -128,18 +130,24 @@ function createEditorView({
   state,
   defaults,
   geometry = A4_PORTRAIT,
-  readOnly,
   fontFallbacks = DEFAULT_FONT_FALLBACKS,
   onStateChange
 }) {
+  const sheetStyle = `${pageGeometryStyle(pagePixels(geometry))};${documentDefaultsStyle(defaults, fontFallbacks)};`;
   const view = new EditorView(mount, {
     state,
-    editable: () => !readOnly,
-    attributes: {
+    // A protection that shuts the body shuts typing with it, and is read off the state so that a
+    // mode switched on an open document takes effect without a new view. Selecting stays open
+    // either way, which is what a reader marking a stretch for a comment needs
+    editable: (current) => !editsShut(current),
+    attributes: (current) => ({
       class: editorClassNames.sheet,
       // The paper first, so a document that names one is drawn on it from the first frame
-      style: `${pageGeometryStyle(pagePixels(geometry))};${documentDefaultsStyle(defaults, fontFallbacks)};tab-size:${documentDefaultTabStopPt(state)}pt`
-    },
+      style: `${sheetStyle}tab-size:${documentDefaultTabStopPt(current)}pt`,
+      // A sheet that takes no typing is no longer focusable of itself, so a reader or a commenter
+      // is handed the focus another way: the keys reach it, and the selection stays its own
+      ...editsShut(current) ? { tabindex: "0" } : {}
+    }),
     // The schema can only draw a run with the default fallback fonts, so this editor draws its own
     markViews: { run: runMarkView(fontFallbacks) },
     // An image is drawn by a view of its own, which is what carries the resize handles

package/dist/editor/externalClipboard.js

@@ -1,16 +1,23 @@
 // src/editor/externalClipboard.ts
-import { Fragment, Slice } from "prosemirror-model";
+import {
+  DOMSerializer,
+  Fragment,
+  Slice
+} from "prosemirror-model";
 import { Plugin } from "prosemirror-state";
 import { effectiveParagraphFormat, styleIdOf } from "../docx/formatting.js";
 import { withParagraphStyle } from "../docx/paraProps.js";
 import { MAX_ILVL, nextNumId } from "../numbering/listTemplate.js";
-import { docxSchema } from "../schema/index.js";
+import { elementXml } from "../ooxml/element.js";
+import { wName } from "../ooxml/names.js";
+import { docxSchema, isPageBreak } from "../schema/index.js";
 import { editorClassNames } from "../styles/classNames.js";
 import { PASTED_IMAGE_ATTRIBUTE } from "./clipboard/images.js";
 import {
   appendInline,
   contextFor,
   marksFor,
+  safeHref,
   withInlineStyle
 } from "./clipboard/inlineFormatting.js";
 import { listRefOf } from "./commands/listCommands.js";
@@ -59,11 +66,149 @@ var HEADING_FALLBACKS = {
   5: { bold: true, fontSizePt: 10 },
   6: { bold: true, fontSizePt: 8 }
 };
+var PUBLIC_ATTRIBUTES = /* @__PURE__ */ new Set([
+  "alt",
+  "aria-label",
+  "class",
+  "colspan",
+  "height",
+  "href",
+  "lang",
+  "rowspan",
+  "src",
+  "style",
+  "width"
+]);
+var COPIED_STYLE_ATTRIBUTE = "data-style";
+function isAttributes(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Node);
+}
+function publicAttributes(attrs) {
+  return Object.fromEntries(
+    Object.entries(attrs).filter(([name]) => PUBLIC_ATTRIBUTES.has(name))
+  );
+}
+function isSpecArray(value) {
+  return Array.isArray(value) && typeof value[0] === "string";
+}
+function stripPrivateAttributes(spec) {
+  if (!isSpecArray(spec)) return spec;
+  const [tag, ...rest] = spec;
+  const attrs = isAttributes(rest[0]) ? publicAttributes(rest[0]) : null;
+  const children = (attrs === null ? rest : rest.slice(1)).map(
+    (child) => isSpecArray(child) ? stripPrivateAttributes(child) : child
+  );
+  return attrs === null ? [tag, ...children] : [tag, attrs, ...children];
+}
+function withDomAttribute(spec, name, value) {
+  if (!isSpecArray(spec)) return spec;
+  const [tag, ...rest] = spec;
+  return isAttributes(rest[0]) ? [tag, { ...rest[0], [name]: value }, ...rest.slice(1)] : [tag, { [name]: value }, ...rest];
+}
+function asTag(spec, tag) {
+  return isSpecArray(spec) ? [tag, ...spec.slice(1)] : spec;
+}
+function copiedMarkSpec(mark, spec) {
+  const stripped = stripPrivateAttributes(spec);
+  if (mark.type !== docxSchema.marks.link) return stripped;
+  const href = safeHref(
+    typeof mark.attrs.href === "string" ? mark.attrs.href : null
+  );
+  return href === null ? stripped : asTag(withDomAttribute(stripped, "href", href), "a");
+}
+function copiedNodeSpec(node, spec) {
+  const stripped = stripPrivateAttributes(spec);
+  if (node.type !== docxSchema.nodes.paragraph) return stripped;
+  const styleId = styleIdOf(node.attrs.pPr);
+  return styleId === null ? stripped : withDomAttribute(stripped, COPIED_STYLE_ATTRIBUTE, styleId);
+}
+function clipboardSerializer() {
+  const drawn = DOMSerializer.fromSchema(docxSchema);
+  const nodes = Object.fromEntries(
+    Object.entries(drawn.nodes).map(([name, toDOM]) => [
+      name,
+      (node) => copiedNodeSpec(node, toDOM(node))
+    ])
+  );
+  const marks = Object.fromEntries(
+    Object.entries(drawn.marks).map(([name, toDOM]) => [
+      name,
+      (mark, inline) => copiedMarkSpec(mark, toDOM(mark, inline))
+    ])
+  );
+  return new DOMSerializer(nodes, marks);
+}
+var UNREADABLE_BLOCKS = /* @__PURE__ */ new Set([
+  "bookmarkBlock",
+  "docxRaw",
+  "rawBlock"
+]);
+function stringAttr(value) {
+  return typeof value === "string" ? value : "";
+}
+function inlineText(node) {
+  if (node.isText) return node.text ?? "";
+  if (node.type === docxSchema.nodes.hardBreak) {
+    return isPageBreak(node.attrs.brAttrs) ? "\f" : "\n";
+  }
+  if (node.type === docxSchema.nodes.image) return stringAttr(node.attrs.alt);
+  if (node.type === docxSchema.nodes.noteReference) {
+    return node.attrs.customMarkFollows === true ? "" : stringAttr(node.attrs.label);
+  }
+  return "";
+}
+function rowsText(table) {
+  const rows = [];
+  table.forEach((row) => {
+    const cells = [];
+    row.forEach((cell) => {
+      cells.push(fragmentText(cell.content));
+    });
+    rows.push(cells.join("	"));
+  });
+  return rows.join("\n");
+}
+function blockText(node) {
+  if (node.type === docxSchema.nodes.table) return rowsText(node);
+  if (UNREADABLE_BLOCKS.has(node.type.name)) return "";
+  return fragmentText(node.content);
+}
+function fragmentText(fragment) {
+  const pieces = [];
+  fragment.forEach((child) => {
+    pieces.push(child.isInline ? inlineText(child) : blockText(child));
+  });
+  return pieces.join(fragment.firstChild?.isInline === true ? "" : "\n");
+}
+function bareWrappers(content, openStart, openEnd) {
+  const wrapper = content.firstChild;
+  if (openStart <= 1 || openEnd <= 1 || content.childCount !== 1)
+    return content;
+  if (wrapper === null || wrapper.childCount !== 1) return content;
+  return Fragment.from(
+    wrapper.type.create(
+      null,
+      bareWrappers(wrapper.content, openStart - 1, openEnd - 1),
+      wrapper.marks
+    )
+  );
+}
+function copiedSlice(slice) {
+  return new Slice(
+    bareWrappers(slice.content, slice.openStart, slice.openEnd),
+    slice.openStart,
+    slice.openEnd
+  );
+}
+function clipboardText(slice) {
+  return fragmentText(slice.content);
+}
 function normalizedStyleName(value) {
   return value.toLowerCase().replace(/[\s_-]+/g, "");
 }
 function copiedStyleId(element) {
-  return element.classList.contains(editorClassNames.paragraph) ? styleIdOf(element.getAttribute("data-ppr")) : null;
+  if (!element.classList.contains(editorClassNames.paragraph)) return null;
+  return element.getAttribute(COPIED_STYLE_ATTRIBUTE) ?? styleIdOf(element.getAttribute("data-ppr"));
 }
 function headingLevel(element, sourceStyleId) {
   const direct = HEADING_LEVELS[element.tagName];
@@ -116,7 +261,20 @@ function blockContext(state, parent, element, preserveParagraphStyle) {
 function listParagraphAttrs(state, list) {
   if (!list || list.numId === null) return null;
   const ilvl = Math.min(MAX_ILVL, list.level);
-  const pPr = `<w:pPr><w:numPr><w:ilvl w:val="${ilvl}"/><w:numId w:val="${list.numId}"/></w:numPr></w:pPr>`;
+  const pPr = elementXml(
+    wName("pPr"),
+    [],
+    [
+      elementXml(
+        wName("numPr"),
+        [],
+        [
+          elementXml(wName("ilvl"), [[wName("val"), `${ilvl}`]]),
+          elementXml(wName("numId"), [[wName("val"), `${list.numId}`]])
+        ]
+      )
+    ]
+  );
   return {
     pPr,
     format: effectiveParagraphFormat(pPr, documentParagraphFormatting(state))
@@ -294,8 +452,12 @@ function insertClipboardData(view, data) {
   insertPlainText(view, data.text ?? "");
 }
 function externalClipboard() {
+  const serializer = clipboardSerializer();
   return new Plugin({
     props: {
+      clipboardSerializer: serializer,
+      clipboardTextSerializer: clipboardText,
+      transformCopied: copiedSlice,
       handlePaste(view, event) {
         insertClipboardData(view, {
           html: event.clipboardData?.getData("text/html"),

package/dist/editor/insertImage.js

@@ -2,9 +2,13 @@
 import { insertPoint } from "prosemirror-transform";
 import { toImageExtent, toImageSrc } from "../ooxml/image.js";
 import { docxSchema } from "../schema/index.js";
-import { replacementShut } from "../schema/locks.js";
+import { editShut, selectionIntents } from "../schema/guards.js";
 function insertPosition(state) {
-  if (replacementShut(state.selection, state.doc)) return null;
+  if (selectionIntents(state.selection, "replace").some(
+    (intent) => editShut(state, intent)
+  )) {
+    return null;
+  }
   return insertPoint(state.doc, state.selection.from, docxSchema.nodes.image);
 }
 function canInsertImage(state) {

package/dist/editor/insertTable.js

@@ -4,6 +4,7 @@ import {
   TextSelection
 } from "prosemirror-state";
 import { createTableNode, isTableSide } from "../docx/tableTemplate.js";
+import { editsShut } from "../schema/protectionState.js";
 import { documentGeometry } from "./documentStyles.js";
 function isInTable($pos) {
   for (let depth = $pos.depth; depth > 0; depth -= 1) {
@@ -13,7 +14,7 @@ function isInTable($pos) {
 }
 function insertPosition(state) {
   const $from = state.selection.$from;
-  if ($from.depth === 0 || isInTable($from)) return null;
+  if (editsShut(state) || $from.depth === 0 || isInTable($from)) return null;
   return $from.after(1);
 }
 function canInsertTable(state) {

package/dist/editor/paragraphEdits.d.ts

@@ -28,6 +28,8 @@ export declare function selectedParagraphs(state: EditorState): ParagraphSpot[];
  * Only the paragraphs of a locked cell are shut. A paragraph merely holding a locked control keeps
  * its own alignment, indent and style, which is what `insideLockedCell` says and
  * `rangeTouchesLocked` would not (`schema/locks`).
+ *
+ * A protection that shuts the body leaves no paragraph editable (`schema/protection`).
  */
 export declare function editableParagraphs(state: EditorState): ParagraphSpot[];
 /** The original formatting XML this paragraph holds. Null when there is none */

package/dist/editor/paragraphEdits.js

@@ -2,6 +2,7 @@
 import { effectiveParagraphFormat } from "../docx/formatting.js";
 import { docxSchema } from "../schema/index.js";
 import { insideLockedCell } from "../schema/locks.js";
+import { editsShut } from "../schema/protectionState.js";
 import {
   defaultParagraphStyleId,
   documentParagraphFormatting,
@@ -19,6 +20,7 @@ function selectedParagraphs(state) {
   return Array.from(spots, ([pos, node]) => ({ pos, node }));
 }
 function editableParagraphs(state) {
+  if (editsShut(state)) return [];
   return selectedParagraphs(state).filter(
     (spot) => !insideLockedCell(state.doc, spot.pos)
   );

package/dist/editor/plugins/documentProtection.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Holds the protection the editor runs under (`schema/protection`) in the state, where the guards
+ * and the commands read it. The runtime filter stands in `lockedContent`, which enforces every
+ * guard `schema/guards` registers, the protection among them, in one pass.
+ */
+import { Plugin, type Transaction } from "prosemirror-state";
+import type { EditableComments, EditingProtection, ProtectionState } from "../../schema/protection";
+import type { CommentAuthor } from "../commands/comments/model";
+export interface DocumentProtectionOptions {
+    protection: EditingProtection;
+    /** Whose comments are being written. Null where none are, a reader above all */
+    author: CommentAuthor | null;
+    editableComments: EditableComments;
+}
+/**
+ * The transaction that puts the editor under another protection, which is how a mode is switched
+ * on a document already open: `reconfigure` keeps the state a plugin of the same key already
+ * holds, so a new plugin instance would not do it.
+ */
+export declare function setProtection(tr: Transaction, options: DocumentProtectionOptions): Transaction;
+export declare function documentProtection(options: DocumentProtectionOptions): Plugin<ProtectionState>;

package/dist/editor/plugins/documentProtection.js

@@ -0,0 +1,44 @@
+// src/editor/plugins/documentProtection.ts
+import { Plugin } from "prosemirror-state";
+import { protectionKey } from "../../schema/protectionState.js";
+function rulesOf({
+  protection,
+  author,
+  editableComments
+}) {
+  return { protection, authorId: author?.id ?? null, editableComments };
+}
+var PROTECTIONS = [
+  "none",
+  "readOnly",
+  "comments"
+];
+var EDITABLE_COMMENTS = ["own", "all"];
+function isOneOf(values, candidate) {
+  return typeof candidate === "string" && values.some((value) => value === candidate);
+}
+function isRules(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const authorId = Reflect.get(value, "authorId");
+  return isOneOf(PROTECTIONS, Reflect.get(value, "protection")) && (authorId === null || typeof authorId === "string") && isOneOf(EDITABLE_COMMENTS, Reflect.get(value, "editableComments"));
+}
+function setProtection(tr, options) {
+  return tr.setMeta(protectionKey, rulesOf(options));
+}
+function documentProtection(options) {
+  const rules = rulesOf(options);
+  return new Plugin({
+    key: protectionKey,
+    state: {
+      init: () => rules,
+      apply: (transaction, value) => {
+        const next = transaction.getMeta(protectionKey);
+        return isRules(next) ? next : value;
+      }
+    }
+  });
+}
+export {
+  documentProtection,
+  setProtection
+};