@portone/docx-editor 0.1.1 → 0.2.1

package/dist/schema/guards.d.ts

@@ -0,0 +1,68 @@
+/**
+ * The one list an edit is judged against.
+ *
+ * A guard answers, for one rule, whether an edit would leave the document in a state the file
+ * cannot be written back from. `transactionAllowed` runs the list over a built transaction, both
+ * where an edit is dispatched (`editor/plugins/lockedContent`) and where a command is dry-run
+ * (`editor/commands/canRunCommand`), and `editShut` runs it over the intent a command has before
+ * it builds anything. Both ask the same list, which is what keeps a disabled control and a refused
+ * edit saying the same thing.
+ *
+ * What a guard is written against - `EditGuard`, `EditIntent` and the reach primitives - stands in
+ * `./editGuard` so that a module writing a guard need not read this one, and is handed on from
+ * here so that a caller has one door to the whole seam.
+ *
+ * `editShut` is not yet what every command asks. Only `editor/commands/breakCommands`,
+ * `editor/commands/tabCommands` and `editor/insertImage` ask it today; the rest still compose
+ * `editsShut` with a lock predicate of their own (`./locks`), and each decides for itself whether
+ * a stretch a guard shuts is trimmed out of the edit or refuses the whole of it. Until they move
+ * over, a guard added to the list below reaches those commands through `transactionAllowed` alone,
+ * which refuses the transaction they built rather than telling them not to build it.
+ */
+import type { EditorState, Selection, Transaction } from "prosemirror-state";
+import { type EditGuard, type EditIntent } from "./editGuard";
+import { type ProtectionState } from "./protection";
+export type { EditGuard, EditGuardName, EditIntent } from "./editGuard";
+export { stepReaches } from "./editGuard";
+/**
+ * Whether the transaction reaches a comment node, which is how a body, a reply and a resolution
+ * change. Every comment lives in its three nodes, so a change that reaches none of them cannot
+ * have changed a comment.
+ */
+export declare function transactionTouchesComments(tr: Transaction): boolean;
+/**
+ * Whether the protection lets this transaction through (`./protection`).
+ *
+ * The whole-document judgement is reached for only when a comment is touched at all
+ * (`transactionTouchesComments`). A change that touches none is a body edit: through under `none`,
+ * refused under `comments`, and nothing about ownership to ask.
+ */
+export declare function protectionAllowsTransaction(tr: Transaction, rules: ProtectionState): boolean;
+export declare const EDIT_GUARDS: readonly EditGuard[];
+/**
+ * Whether every guard would let this transaction through, decided and nothing else.
+ *
+ * The refusal a guard itself answers with carries a side effect - the composition it ends
+ * (`editor/plugins/lockedContent`) - which a query about a button's state may not set off, so the
+ * decision stands apart from it and every caller building an edit asks this rather than handing
+ * the transaction to a state.
+ *
+ * The whole-change judgements come first and take no pass, since a pass lifts one guard's reading
+ * of a step rather than another guard's reading of the change. What is left is judged step by
+ * step, each step over the document it was built against.
+ */
+export declare function transactionAllowed(tr: Transaction, state: EditorState): boolean;
+/**
+ * Whether any guard shuts this intent where it stands.
+ *
+ * This is what a command asks before it reports that it applies: a command reporting true and then
+ * being refused by the guard draws a live control that swallows the click.
+ */
+export declare function editShut(state: EditorState, intent: EditIntent): boolean;
+/**
+ * What a command doing this to whatever is selected means to do, one intent per selected stretch.
+ *
+ * A stretch of no length holds nothing to mark or to put away, so whatever the command would do to
+ * a stretch it is an insertion there.
+ */
+export declare function selectionIntents(selection: Selection, kind: "mark" | "replace"): EditIntent[];

package/dist/schema/guards.js

@@ -0,0 +1,82 @@
+// src/schema/guards.ts
+import {
+  transactionReaches
+} from "./editGuard.js";
+import { lockGuard } from "./locks.js";
+import { bookmarkGuard, noteGuard } from "./preservedGuards.js";
+import {
+  isCommentNode,
+  protectionAllows
+} from "./protection.js";
+import { editsShut, protectionOf } from "./protectionState.js";
+import { stepReaches } from "./editGuard.js";
+function transactionTouchesComments(tr) {
+  return transactionReaches(tr, isCommentNode);
+}
+function protectionAllowsTransaction(tr, rules) {
+  switch (rules.protection) {
+    case "readOnly":
+      return false;
+    case "none":
+      return !transactionTouchesComments(tr) || protectionAllows(tr.before, tr.doc, rules);
+    case "comments":
+      return transactionTouchesComments(tr) && protectionAllows(tr.before, tr.doc, rules);
+    default: {
+      const unmodelled = rules.protection;
+      return unmodelled;
+    }
+  }
+}
+var protectionGuard = {
+  name: "protection",
+  change: (tr, state) => protectionAllowsTransaction(tr, protectionOf(state)),
+  shuts: (_intent, state) => editsShut(state)
+};
+var EDIT_GUARDS = [
+  protectionGuard,
+  lockGuard,
+  bookmarkGuard,
+  noteGuard
+];
+function judgesSteps(guard) {
+  return guard.step !== void 0;
+}
+function lifted(guard, tr) {
+  return guard.liftedBy?.some((pass) => tr.getMeta(pass) === true) === true;
+}
+function transactionAllowed(tr, state) {
+  if (!tr.docChanged) return true;
+  if (EDIT_GUARDS.some((guard) => guard.change?.(tr, state) === false)) {
+    return false;
+  }
+  return EDIT_GUARDS.filter(judgesSteps).filter((guard) => !lifted(guard, tr)).every(
+    (guard) => (
+      // Each step counts positions in the document it was built against, which `docs` holds
+      tr.steps.every(
+        (step, index) => guard.step(
+          step,
+          tr.docs[index] ?? state.doc,
+          tr.docs[index + 1] ?? tr.doc,
+          state
+        )
+      )
+    )
+  );
+}
+function editShut(state, intent) {
+  return EDIT_GUARDS.some((guard) => guard.shuts(intent, state));
+}
+function selectionIntents(selection, kind) {
+  return selection.ranges.map(
+    (range) => range.$from.pos === range.$to.pos ? { kind: "insert", at: range.$from.pos } : { kind, from: range.$from.pos, to: range.$to.pos }
+  );
+}
+export {
+  EDIT_GUARDS,
+  editShut,
+  protectionAllowsTransaction,
+  selectionIntents,
+  stepReaches,
+  transactionAllowed,
+  transactionTouchesComments
+};

package/dist/schema/locks.d.ts

@@ -1,9 +1,13 @@
 /**
  * Evaluates OOXML content and deletion locks for inline controls and whole table cells. Commands
  * query these predicates before editing; `editor/plugins/lockedContent` enforces them at runtime.
+ *
+ * `lockGuard` is what `./guards` registers all of this as, so that a caller asking the one guard
+ * list asks the locks along with every other rule an edit is judged by.
  */
 import type { Mark, Node as PMNode } from "prosemirror-model";
-import { PluginKey, type Selection, type Transaction } from "prosemirror-state";
+import { PluginKey, type Selection } from "prosemirror-state";
+import type { StepGuard } from "./editGuard";
 /**
  * The pass that lets a transaction through the guard, which is how a lock can be lifted at all.
  * A plugin key is used as the name so that it cannot collide with a consumer's own metadata.
@@ -100,13 +104,10 @@ export declare function selectionShut(selection: Selection, doc: PMNode): boolea
  */
 export declare function replacementShut(selection: Selection, doc: PMNode): boolean;
 /**
- * Whether the guard would let this transaction through, decided and nothing else.
+ * The locks the document carries, as `./guards` registers them.
  *
- * The refusal the guard itself answers with carries a side effect - the composition it ends
- * (`editor/plugins/lockedContent`) - which a query about a button's state may not set off, so the
- * decision stands apart from it and every caller building an edit asks this rather than handing
- * the transaction to a state.
- * `doc` only stands in for a step the transaction kept no document for.
+ * Both passes lift it: unlocking is the one edit that may reach into a lock, and every step the
+ * history replays is the reverse of a step that passed the guard when it was made.
  */
-export declare function transactionAllowed(tr: Transaction, doc: PMNode): boolean;
+export declare const lockGuard: StepGuard;
 export {};

package/dist/schema/locks.js

@@ -116,17 +116,21 @@ function insertionInsideLocked(doc, pos) {
   const after = lockedMarkOf($pos.nodeAfter);
   return before !== null && after !== null && before.eq(after);
 }
+function markShut(doc, from, to) {
+  return from === to ? insertionInsideLocked(doc, from) : rangeTouchesLocked(doc, from, to);
+}
+function replaceShut(doc, from, to) {
+  return from === to ? insertionInsideLocked(doc, from) : rangeShut(doc, { from, to, takesAway: true });
+}
 function selectionShut(selection, doc) {
   return selection.ranges.some(
-    (range) => range.$from.pos === range.$to.pos ? insertionInsideLocked(doc, range.$from.pos) : rangeTouchesLocked(doc, range.$from.pos, range.$to.pos)
+    (range) => markShut(doc, range.$from.pos, range.$to.pos)
   );
 }
 function replacementShut(selection, doc) {
-  return selection.ranges.some((range) => {
-    const from = range.$from.pos;
-    const to = range.$to.pos;
-    return from === to ? insertionInsideLocked(doc, from) : rangeShut(doc, { from, to, takesAway: true });
-  });
+  return selection.ranges.some(
+    (range) => replaceShut(doc, range.$from.pos, range.$to.pos)
+  );
 }
 function editedRanges(step) {
   if (step instanceof ReplaceAroundStep) {
@@ -185,16 +189,28 @@ function stepAllowed(step, doc) {
   }
   return true;
 }
-function carriesPass(tr) {
-  return tr.getMeta(unlockAllowed) === true || tr.getMeta(historyReplay) === true;
-}
-function transactionAllowed(tr, doc) {
-  if (!tr.docChanged) return true;
-  if (carriesPass(tr)) return true;
-  return tr.steps.every(
-    (step, index) => stepAllowed(step, tr.docs[index] ?? doc)
-  );
+function intentShut(doc, intent) {
+  switch (intent.kind) {
+    case "insert":
+      return insertionInsideLocked(doc, intent.at);
+    case "block":
+      return insideLockedCell(doc, intent.at);
+    case "mark":
+      return markShut(doc, intent.from, intent.to);
+    case "replace":
+      return replaceShut(doc, intent.from, intent.to);
+    default: {
+      const unmodelled = intent;
+      return unmodelled;
+    }
+  }
 }
+var lockGuard = {
+  name: "lock",
+  liftedBy: [unlockAllowed, historyReplay],
+  step: (step, before) => stepAllowed(step, before),
+  shuts: (intent, state) => intentShut(state.doc, intent)
+};
 export {
   carriesLock,
   controlSpans,
@@ -202,10 +218,10 @@ export {
   insertionInsideLocked,
   insideLockedCell,
   isLockedCell,
+  lockGuard,
   lockedMarkOf,
   rangeTouchesLocked,
   replacementShut,
   selectionShut,
-  transactionAllowed,
   unlockAllowed
 };

package/dist/schema/preservedGuards.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The guards over the nodes a document is opened with and the editor only preserves: the two ends
+ * of a bookmark range, and the reference standing where a footnote or an endnote is called.
+ *
+ * Neither is content the editor writes, so nothing in it can put such a node back once it is gone,
+ * and a document that lost one of a bookmark's two ends cannot be written back as a file at all
+ * (`docx/exportDocx` refuses it). What each guard holds is therefore the whole list of the nodes it
+ * answers for, in the order the document carries them.
+ */
+import type { Node as PMNode } from "prosemirror-model";
+import { type ChangeGuard, type EditGuardName } from "./editGuard";
+/** Everything about one preserved node that has to read the same after a change as before it */
+type Signature = (node: PMNode) => string;
+/**
+ * A guard that lets a change through only while it leaves the list of these nodes reading exactly
+ * as it did, which holds their number, their contents and their order at once.
+ *
+ * The comparison walks the whole document, so it is reached for only once a step of the change has
+ * touched such a node: ordinary typing costs the stretches its own steps rewrote and nothing more.
+ * It is judged over the change rather than step by step because a marker moved whole is two steps,
+ * one taking it out and one putting it back, and neither of them alone leaves the list as it was.
+ *
+ * Nothing lifts it. A pass is how an edit reaches past a lock the document put on itself, and
+ * there is no such thing to reach past here: the file simply has no way to say what a lost marker
+ * was.
+ */
+export declare function preservedNodeGuard(name: EditGuardName, holds: (node: PMNode) => boolean, signature: Signature): ChangeGuard;
+export declare const bookmarkGuard: ChangeGuard;
+export declare const noteGuard: ChangeGuard;
+export {};

package/dist/schema/preservedGuards.js

@@ -0,0 +1,50 @@
+// src/schema/preservedGuards.ts
+import {
+  rangeHolds,
+  transactionReaches
+} from "./editGuard.js";
+function signatures(doc, holds, signature) {
+  const found = [];
+  doc.descendants((node) => {
+    if (holds(node)) found.push(signature(node));
+    return true;
+  });
+  return found;
+}
+function same(a, b) {
+  return a.length === b.length && a.every((value, index) => value === b[index]);
+}
+function preservedNodeGuard(name, holds, signature) {
+  const listOf = (doc) => signatures(doc, holds, signature);
+  return {
+    name,
+    change: (tr) => !transactionReaches(tr, holds) || same(listOf(tr.before), listOf(tr.doc)),
+    shuts: (intent, state) => intent.kind === "replace" && rangeHolds(state.doc, intent.from, intent.to, holds)
+  };
+}
+var BOOKMARK_XML = /<(?:[\w.-]+:)?bookmark(?:Start|End)\b/;
+function isBookmarkMarker(node) {
+  if (node.type.name === "bookmarkBlock") return true;
+  return node.type.name === "rawInline" && typeof node.attrs.xml === "string" && BOOKMARK_XML.test(node.attrs.xml);
+}
+function bookmarkSignature(node) {
+  return node.type.name === "bookmarkBlock" ? `block:${node.attrs.srcId}:${node.attrs.name}` : `inline:${node.attrs.xml}`;
+}
+var bookmarkGuard = preservedNodeGuard(
+  "bookmark",
+  isBookmarkMarker,
+  bookmarkSignature
+);
+function isNoteReference(node) {
+  return node.type.name === "noteReference";
+}
+var noteGuard = preservedNodeGuard(
+  "note",
+  isNoteReference,
+  (node) => JSON.stringify(node.attrs)
+);
+export {
+  bookmarkGuard,
+  noteGuard,
+  preservedNodeGuard
+};

package/dist/schema/protection.d.ts

@@ -0,0 +1,84 @@
+/**
+ * The protection an editor runs under: what the document as a whole may receive, over and above
+ * the locks its own controls carry (`./locks`).
+ *
+ * The levels are named after OOXML `ST_DocProtect`, the enumeration `w:documentProtection/@w:edit`
+ * takes (ECMA-376 Part 1 §17.15.1.29): `readOnly` takes no edit at all, `comments` takes comments
+ * and nothing else, `none` takes every body edit. No level lifts the ownership rule over comments:
+ * whose comment may be edited is `editableComments`' question at every level, `none` included.
+ * `trackedChanges` and `forms`, the two values of the enumeration not modelled yet, would be added
+ * here.
+ *
+ * The protection is editor state rather than document state: it is the reader's standing, not the
+ * file's, so nothing here is written to or read from OOXML. `editor/plugins/documentProtection`
+ * holds it in the state and `./protectionState` reads it back; the guard list (`./guards`) asks the
+ * judgements here. They take documents alone, so that the `./core` entry can make the same
+ * judgement over a file without an editor.
+ */
+import { type Node as PMNode } from "prosemirror-model";
+export type EditingProtection = "none" | "readOnly" | "comments";
+/**
+ * Whose comments may be edited or deleted. `own` is a comment carrying no recognised identity, or
+ * the very identity comments are being written under; `all` is every comment there is, which is
+ * the standing of a moderator.
+ */
+export type EditableComments = "own" | "all";
+export interface ProtectionState {
+    protection: EditingProtection;
+    /** The identity comments are written under. Null where nobody is writing any, a reader above all */
+    authorId: string | null;
+    editableComments: EditableComments;
+}
+/** Whether this node is one of the three a comment stands in the story as */
+export declare function isCommentNode(node: PMNode): boolean;
+/**
+ * The document with every comment taken out of it.
+ *
+ * `Fragment.fromArray` joins the text a marker had split, so a document a comment was put into
+ * reads the same as it did before the comment, and the two compare equal.
+ */
+export declare function withoutComments(node: PMNode): PMNode;
+/** Whether the two documents differ in nothing but their comments */
+export declare function changesOnlyComments(before: PMNode, after: PMNode): boolean;
+/**
+ * Whether a comment written under this identity may be edited or deleted.
+ *
+ * A comment carrying no recognised identity belongs to nobody in particular and stays open to
+ * everyone, which is what every comment was before identities were recorded and what a comment
+ * made in Word is; one carrying an identity is its author's alone.
+ */
+export declare function commentOwned(rules: ProtectionState, authorId: string | null): boolean;
+/**
+ * Whether every comment and reply that was already there kept the identity it was written under.
+ *
+ * An identity is not an edit anyone may make, its own author included: a comment rewritten into
+ * another author's name would be that author's to edit from then on, and one rewritten into
+ * nobody's would be everyone's. Only a comment that appears carries an identity chosen for it.
+ */
+export declare function commentIdentitiesKept(before: PMNode, after: PMNode): boolean;
+/**
+ * Whether every comment edited, moved or taken away between the two documents belonged to whoever
+ * did it. Adding a comment, replying, and settling a thread as resolved or open belong to
+ * everyone.
+ *
+ * Moving a comment onto other text is an edit of that comment rather than of the body, since the
+ * body reads the same afterwards, and it is the owner's to make.
+ * A root taken away takes its replies with it whoever wrote them: a thread hangs off its root,
+ * and the root's owner may take the thread down.
+ */
+export declare function commentEditsOwned(before: PMNode, after: PMNode, rules: ProtectionState): boolean;
+/**
+ * Whether the protection lets a document go from `before` to `after`.
+ *
+ * Ownership is judged only over a change that is nothing but comments. A body edit that sweeps a
+ * comment away with the text it was anchored to is a body edit, and the standing to make one is
+ * the protection's question; under `comments` no such edit goes through in the first place.
+ */
+export declare function protectionAllows(before: PMNode, after: PMNode, rules: ProtectionState): boolean;
+/**
+ * Whether every comment and reply that appeared between the two documents was written under this
+ * identity, and every one that was already there kept the identity it was written under. The
+ * editor takes an addition from anyone, since it writes the author itself; a server taking a file
+ * back does not, since the file could claim any author.
+ */
+export declare function commentAdditionsBy(before: PMNode, after: PMNode, authorId: string): boolean;

package/dist/schema/protection.js

@@ -0,0 +1,171 @@
+// src/schema/protection.ts
+import { Fragment } from "prosemirror-model";
+var COMMENT_NODES = /* @__PURE__ */ new Set([
+  "commentStart",
+  "commentEnd",
+  "commentReference"
+]);
+function isCommentNode(node) {
+  return COMMENT_NODES.has(node.type.name);
+}
+function withoutComments(node) {
+  if (node.isLeaf) return node;
+  const kept = [];
+  node.forEach((child) => {
+    if (!isCommentNode(child)) kept.push(withoutComments(child));
+  });
+  return node.copy(Fragment.fromArray(kept));
+}
+function changesOnlyComments(before, after) {
+  return withoutComments(before).eq(withoutComments(after));
+}
+function stringOrNull(value) {
+  return typeof value === "string" ? value : null;
+}
+function bodyOf(attrs) {
+  return {
+    authorId: stringOrNull(attrs.authorId),
+    author: stringOrNull(attrs.author),
+    initials: stringOrNull(attrs.initials),
+    date: stringOrNull(attrs.date),
+    text: stringOrNull(attrs.text) ?? ""
+  };
+}
+function replyBodies(value) {
+  const replies = /* @__PURE__ */ new Map();
+  if (!Array.isArray(value)) return replies;
+  for (const entry of value) {
+    if (typeof entry !== "object" || entry === null) continue;
+    const reply = entry;
+    const id = stringOrNull(reply.id);
+    if (id === null) continue;
+    replies.set(id, bodyOf(reply));
+  }
+  return replies;
+}
+function threadsIn(doc) {
+  const threads = /* @__PURE__ */ new Map();
+  doc.descendants((node) => {
+    if (node.type.name !== "commentReference") return true;
+    const id = stringOrNull(node.attrs.id);
+    if (id === null || threads.has(id)) return true;
+    threads.set(id, {
+      ...bodyOf(node.attrs),
+      replies: replyBodies(node.attrs.replies)
+    });
+    return true;
+  });
+  return threads;
+}
+function commentOwned(rules, authorId) {
+  if (rules.editableComments === "all") return true;
+  return authorId === null || authorId === rules.authorId;
+}
+function commentAnchors(doc) {
+  const markers = /* @__PURE__ */ new Map();
+  const visit = (node, start) => {
+    if (isCommentNode(node)) {
+      const id = stringOrNull(node.attrs.id);
+      if (id !== null) {
+        const at = markers.get(id) ?? [];
+        at.push(`${node.type.name}@${start}`);
+        markers.set(id, at);
+      }
+      return 0;
+    }
+    if (node.isLeaf) return node.nodeSize;
+    let content = 0;
+    node.forEach((child) => {
+      content += visit(child, start + 1 + content);
+    });
+    return content + 2;
+  };
+  visit(doc, -1);
+  return new Map(
+    Array.from(markers, ([id, at]) => [id, at.join(" ")])
+  );
+}
+function sameIdentity(was, now) {
+  return was.authorId === now.authorId && was.author === now.author;
+}
+function sameWords(was, now) {
+  return was.text === now.text && was.initials === now.initials && was.date === now.date;
+}
+function commentIdentitiesKept(before, after) {
+  const now = threadsIn(after);
+  for (const [id, thread] of threadsIn(before)) {
+    const current = now.get(id);
+    if (current === void 0) continue;
+    if (!sameIdentity(thread, current)) return false;
+    for (const [replyId, reply] of thread.replies) {
+      const currentReply = current.replies.get(replyId);
+      if (currentReply !== void 0 && !sameIdentity(reply, currentReply)) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+function commentEditsOwned(before, after, rules) {
+  if (!commentIdentitiesKept(before, after)) return false;
+  if (rules.editableComments === "all") return true;
+  const now = threadsIn(after);
+  const anchoredBefore = commentAnchors(before);
+  const anchoredAfter = commentAnchors(after);
+  for (const [id, thread] of threadsIn(before)) {
+    const current = now.get(id);
+    const changed = current === void 0 || !sameWords(thread, current) || anchoredBefore.get(id) !== anchoredAfter.get(id);
+    if (changed && !commentOwned(rules, thread.authorId)) return false;
+    if (current === void 0) continue;
+    for (const [replyId, reply] of thread.replies) {
+      const currentReply = current.replies.get(replyId);
+      const replyChanged = currentReply === void 0 || !sameWords(reply, currentReply);
+      if (replyChanged && !commentOwned(rules, reply.authorId)) return false;
+    }
+  }
+  return true;
+}
+function protectionAllows(before, after, rules) {
+  switch (rules.protection) {
+    case "readOnly":
+      return false;
+    case "comments":
+      return changesOnlyComments(before, after) && commentEditsOwned(before, after, rules);
+    case "none":
+      return !changesOnlyComments(before, after) || commentEditsOwned(before, after, rules);
+    default: {
+      const unmodelled = rules.protection;
+      return unmodelled;
+    }
+  }
+}
+function commentAdditionsBy(before, after, authorId) {
+  if (!commentIdentitiesKept(before, after)) return false;
+  const was = threadsIn(before);
+  for (const [id, thread] of threadsIn(after)) {
+    const earlier = was.get(id);
+    if (earlier === void 0) {
+      if (thread.authorId !== authorId) return false;
+      for (const reply of thread.replies.values()) {
+        if (reply.authorId !== authorId) return false;
+      }
+      continue;
+    }
+    for (const [replyId, reply] of thread.replies) {
+      if (!earlier.replies.has(replyId) && reply.authorId !== authorId) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+export {
+  changesOnlyComments,
+  commentAdditionsBy,
+  commentEditsOwned,
+  commentIdentitiesKept,
+  commentOwned,
+  isCommentNode,
+  protectionAllows,
+  withoutComments
+};

package/dist/schema/protectionState.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Where the protection (`./protection`) stands in an editor state, and the questions commands ask
+ * of it. Kept apart from the judgements so that those stay free of editor state for the `./core`
+ * entry.
+ */
+import { type EditorState, PluginKey } from "prosemirror-state";
+import type { EditingProtection, ProtectionState } from "./protection";
+/** What a state built without the protection plugin runs under, which is what every consumer had before it existed */
+export declare const UNPROTECTED: ProtectionState;
+export declare const protectionKey: PluginKey<ProtectionState>;
+export declare function protectionOf(state: EditorState): ProtectionState;
+export declare function editingProtection(state: EditorState): EditingProtection;
+/**
+ * Whether the protection shuts every edit to the body, comments aside.
+ *
+ * This is the question a command that changes text, formatting or structure asks before it reports
+ * that it applies, the way it asks the lock predicates (`./locks`): a command reporting true and
+ * then being refused by the guard draws a live control that swallows the click.
+ */
+export declare function editsShut(state: EditorState): boolean;

package/dist/schema/protectionState.js

@@ -0,0 +1,37 @@
+// src/schema/protectionState.ts
+import { PluginKey } from "prosemirror-state";
+var UNPROTECTED = {
+  protection: "none",
+  authorId: null,
+  editableComments: "own"
+};
+var protectionKey = new PluginKey(
+  "docxEditorProtection"
+);
+function protectionOf(state) {
+  return protectionKey.getState(state) ?? UNPROTECTED;
+}
+function editingProtection(state) {
+  return protectionOf(state).protection;
+}
+function editsShut(state) {
+  const protection = editingProtection(state);
+  switch (protection) {
+    case "none":
+      return false;
+    case "readOnly":
+    case "comments":
+      return true;
+    default: {
+      const unmodelled = protection;
+      return unmodelled;
+    }
+  }
+}
+export {
+  UNPROTECTED,
+  editingProtection,
+  editsShut,
+  protectionKey,
+  protectionOf
+};