@portone/docx-editor 0.1.0 → 0.2.0

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

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/formatting/reading.js

@@ -5,6 +5,7 @@ import {
   toRunFormat
 } from "../../../model/format.js";
 import {
+  comparableFontName,
   DEFAULT_FONT_FALLBACKS
 } from "../../../styles/fontStack.js";
 import {
@@ -40,22 +41,30 @@ function defaultFontName(state, fontFallbacks) {
 function activeFontFamily(state, fontFallbacks = DEFAULT_FONT_FALLBACKS) {
   const names = activePieces(state).map((target) => fontNameOf(target.format));
   const first = names[0] ?? null;
-  if (names.some((name) => name !== first)) return { kind: "mixed" };
+  const keys = names.map(
+    (name) => name === null ? null : comparableFontName(name)
+  );
+  if (keys.some((key) => key !== keys[0])) return { kind: "mixed" };
   if (first !== null) return { kind: "font", name: first };
   return { kind: "default", name: defaultFontName(state, fontFallbacks) };
 }
 function documentFontNames(doc, defaults) {
-  const names = new Set(fontNamesOf(defaults.fontFamily));
+  const names = /* @__PURE__ */ new Map();
+  const collect = (name) => {
+    const comparable = comparableFontName(name);
+    if (!names.has(comparable)) names.set(comparable, name);
+  };
+  for (const name of fontNamesOf(defaults.fontFamily)) collect(name);
   doc.descendants((node) => {
     const mark = runMarkOf(node.marks);
     for (const name of fontNamesOf(
       toRunFormat(mark?.attrs.format)?.fontFamily
     )) {
-      names.add(name);
+      collect(name);
     }
     return true;
   });
-  return Array.from(names).sort((a, b) => a.localeCompare(b));
+  return Array.from(names.values()).sort((a, b) => a.localeCompare(b));
 }
 function activeTextColor(state) {
   return sharedValue(

package/dist/editor/commands/historyCommands.js

@@ -1,12 +1,20 @@
 // src/editor/commands/historyCommands.ts
 import { redo as historyRedo, undo as historyUndo } from "prosemirror-history";
-import { historyReplay } from "../../schema/locks.js";
+import { historyReplay, transactionAllowed } 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

@@ -13,6 +13,7 @@ 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>`,
@@ -88,6 +89,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

@@ -5,6 +5,7 @@ import {
 import { toParagraphFormat } from "../../model/format.js";
 import { docxSchema } from "../../schema/index.js";
 import { replacementShut } from "../../schema/locks.js";
+import { editsShut } from "../../schema/protectionState.js";
 function isOrdinaryParagraph(state) {
   const { $from } = state.selection;
   if ($from.parent.type !== docxSchema.nodes.paragraph || toParagraphFormat($from.parent.attrs.format)?.numbering) {
@@ -17,7 +18,7 @@ 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) || editsShut(state) || replacementShut(selection, state.doc)) {
     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
@@ -28,8 +29,9 @@ 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";
@@ -57,7 +59,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),
@@ -68,7 +73,9 @@ function createEditorState(doc, {
       ...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.
+      // The same guard refuses what the protection below shuts.
       lockedContent(),
+      documentProtection({ protection, author, editableComments }),
       // 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.
@@ -77,6 +84,7 @@ function createEditorState(doc, {
       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 +136,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/insertImage.js

@@ -3,8 +3,11 @@ 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 { editsShut } from "../schema/protectionState.js";
 function insertPosition(state) {
-  if (replacementShut(state.selection, state.doc)) return null;
+  if (editsShut(state) || replacementShut(state.selection, state.doc)) {
+    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 guard
+ * and the commands read it. The guard itself stands in `lockedContent`, which enforces
+ * `transactionAllowed` for locks and protection 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
+};

package/dist/editor/plugins/imagePaste.js

@@ -3,6 +3,7 @@ import { isHistoryTransaction } from "prosemirror-history";
 import { Plugin, PluginKey } from "prosemirror-state";
 import { Decoration, DecorationSet } from "prosemirror-view";
 import { replacementShut } from "../../schema/locks.js";
+import { editsShut } from "../../schema/protectionState.js";
 import {
   hasResolvableClipboardImages,
   resolveClipboardImages
@@ -222,7 +223,9 @@ function imagePaste() {
     props: {
       decorations: (state) => imagePasteKey.getState(state)?.decorations,
       handlePaste(view, event) {
-        if (replacementShut(view.state.selection, view.state.doc)) return false;
+        if (editsShut(view.state) || replacementShut(view.state.selection, view.state.doc)) {
+          return false;
+        }
         if (view.state.selection.ranges.length > 1) return false;
         const html = event.clipboardData?.getData("text/html") ?? "";
         if (!hasResolvableClipboardImages(view.dom.ownerDocument, html)) {

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

@@ -1,5 +1,15 @@
 /**
  * Keys not handled here are taken by ProseMirror's base keymap.
  */
-import type { Command } from "prosemirror-state";
+import { type Command, Plugin } from "prosemirror-state";
+/**
+ * Keeps undo and redo on their keys where the keymap above cannot reach them.
+ *
+ * A view that took editing away drops every keydown before the keymap plugin sees it
+ * (`view.editable || !(event.type in editHandlers)` in prosemirror-view), so a commenter, who is
+ * given no caret, would have no way to take a comment back. A DOM handler is asked ahead of that
+ * check. An editable view leaves the keys to the keymap plugin, which would otherwise run them a
+ * second time.
+ */
+export declare function historyKeys(): Plugin;
 export declare const docxKeymap: Record<string, Command>;

package/dist/editor/plugins/keymap.js

@@ -1,6 +1,8 @@
 // src/editor/plugins/keymap.ts
 import { chainCommands } from "prosemirror-commands";
 import { undoInputRule } from "prosemirror-inputrules";
+import { keydownHandler } from "prosemirror-keymap";
+import { Plugin } from "prosemirror-state";
 import { goToNextCell } from "prosemirror-tables";
 import { canSplit } from "prosemirror-transform";
 import { toParagraphFormat } from "../../model/format.js";
@@ -55,6 +57,25 @@ var preserveTableFollowingParagraph = (state) => {
   const paragraphIndex = $from.index(0);
   return paragraphIndex > 0 && state.doc.child(paragraphIndex - 1).type.spec.tableRole === "table";
 };
+var historyKeymap = {
+  "Mod-z": undo,
+  "Mod-y": redo,
+  "Shift-Mod-z": redo
+};
+function historyKeys() {
+  const runHistoryKeys = keydownHandler(historyKeymap);
+  return new Plugin({
+    props: {
+      handleDOMEvents: {
+        keydown: (view, event) => {
+          if (view.editable || !runHistoryKeys(view, event)) return false;
+          event.preventDefault();
+          return true;
+        }
+      }
+    }
+  });
+}
 var docxKeymap = {
   Enter: chainCommands(leaveEmptyListItem, splitParagraph),
   "Shift-Enter": insertLineBreak,
@@ -62,9 +83,7 @@ var docxKeymap = {
   "Mod-Enter": insertPageBreak,
   // The paragraph keeps adjacent tables separate without changing imported documents.
   Backspace: chainCommands(preserveTableFollowingParagraph, undoInputRule),
-  "Mod-z": undo,
-  "Mod-y": redo,
-  "Shift-Mod-z": redo,
+  ...historyKeymap,
   "Mod-b": toggleBold,
   "Mod-i": toggleItalic,
   "Mod-u": toggleUnderline,
@@ -90,5 +109,6 @@ var docxKeymap = {
   "Shift-ArrowRight": moveAcrossTab("right", true)
 };
 export {
-  docxKeymap
+  docxKeymap,
+  historyKeys
 };

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

@@ -1,6 +1,8 @@
 /**
- * Rejects transactions disallowed by `schema/locks`. A rejected IME edit also ends the browser
- * composition on the next frame so ProseMirror cannot remain stuck in composing state.
+ * Rejects transactions disallowed by the guard in `schema/locks`, which answers for the locks the
+ * document carries and for the protection the editor runs under (`schema/protection`) alike. A
+ * rejected IME edit also ends the browser composition on the next frame so ProseMirror cannot
+ * remain stuck in composing state.
  */
 import { Plugin } from "prosemirror-state";
 export declare function lockedContent(): Plugin;

package/dist/editor/plugins/lockedContent.js

@@ -30,7 +30,7 @@ function lockedContent() {
       };
     },
     filterTransaction(tr, state) {
-      const allowed = transactionAllowed(tr, state.doc);
+      const allowed = transactionAllowed(tr, state);
       if (!allowed) afterRefusal();
       return allowed;
     }

package/dist/editor/plugins/tableContextMenu.js

@@ -4,6 +4,7 @@ import {
   PluginKey,
   TextSelection
 } from "prosemirror-state";
+import { editsShut } from "../../schema/protectionState.js";
 var CLOSE = "close";
 var menuKey = new PluginKey("docxEditorTableMenu");
 function isRecord(value) {
@@ -67,7 +68,7 @@ function tableContextMenu() {
     props: {
       handleDOMEvents: {
         contextmenu(view, event) {
-          if (!view.editable) return false;
+          if (editsShut(view.state)) return false;
           const cellPos = cellAtEvent(view, event.target);
           if (cellPos === null) return false;
           event.preventDefault();

package/dist/editor/plugins/textContextMenu.js

@@ -5,6 +5,7 @@ import {
   TextSelection
 } from "prosemirror-state";
 import { CellSelection } from "prosemirror-tables";
+import { editingProtection, editsShut } from "../../schema/protectionState.js";
 var CLOSE = "close";
 var menuKey = new PluginKey("docxEditorTextMenu");
 function isRecord(value) {
@@ -44,6 +45,7 @@ function isInSelection(state, spot) {
   );
 }
 function forTableMenu(view, target, spot) {
+  if (editsShut(view.state)) return false;
   const aboutCells = view.state.selection instanceof CellSelection || !isInSelection(view.state, spot);
   return aboutCells && isInTableCell(view, target);
 }
@@ -71,9 +73,12 @@ function textContextMenu() {
     props: {
       handleDOMEvents: {
         contextmenu(view, event) {
-          if (!view.editable) return false;
+          if (editingProtection(view.state) === "readOnly") return false;
           if (!isInEditor(view, event.target)) return false;
           const spot = clickedSpot(view, event);
+          if (editsShut(view.state) && !isInSelection(view.state, spot)) {
+            return false;
+          }
           if (forTableMenu(view, event.target, spot)) return false;
           event.preventDefault();
           view.dispatch(openMenu(view.state, event, spot));