@portone/docx-editor 0.2.0 → 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

@@ -2,12 +2,12 @@
  * 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.
  *
- * `transactionAllowed` is the one guard, and it answers for the protection the editor runs under
- * (`./protection`) as well as for the locks, so that a command asking it asks both.
+ * `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 { type EditorState, PluginKey, type Selection, type Transaction } from "prosemirror-state";
-import { type ProtectionState } from "./protection";
+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.
@@ -104,37 +104,10 @@ export declare function selectionShut(selection: Selection, doc: PMNode): boolea
  */
 export declare function replacementShut(selection: Selection, doc: PMNode): boolean;
 /**
- * Whether any step of the transaction reaches a comment node: puts one in, takes one out, or
- * rewrites the one where it stands, which is how a body, a reply and a resolution change.
+ * The locks the document carries, as `./guards` registers them.
  *
- * Every comment lives in its three nodes, so a change that reaches none of them cannot have
- * changed a comment. That is what lets the guard settle the common transaction - typing, and
- * nothing more - over the stretch it rewrote rather than over the whole document.
- *
- * A step of a kind this does not know - one a consumer brought - is answered as reaching one,
- * since what it rewrote is not known either. The whole-document judgement then has the say, and
- * an unknown step costs a comparison rather than a hole in the guard.
- */
-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;
-/**
- * Whether the guard would let this transaction through, decided and nothing else.
- *
- * 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.
- *
- * The protection is judged before the passes and without them: a replayed edit is still an edit,
- * and a pass that lifts a lock lifts no protection. Its judgement is over the whole change rather
- * than step by step, which is what lets it tell a comment from everything else.
+ * 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, state: EditorState): boolean;
+export declare const lockGuard: StepGuard;
 export {};

package/dist/schema/locks.js

@@ -1,7 +1,5 @@
 // src/schema/locks.ts
-import {
-  PluginKey
-} from "prosemirror-state";
+import { PluginKey } from "prosemirror-state";
 import {
   AddMarkStep,
   AddNodeMarkStep,
@@ -12,11 +10,6 @@ import {
   ReplaceStep
 } from "prosemirror-transform";
 import { docxSchema } from "./index.js";
-import {
-  isCommentNode,
-  protectionAllows
-} from "./protection.js";
-import { protectionOf } from "./protectionState.js";
 var unlockAllowed = new PluginKey("docxEditorUnlockAllowed");
 var historyReplay = new PluginKey("docxEditorHistoryReplay");
 var OPEN = { contents: false, deletion: false };
@@ -123,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) {
@@ -192,58 +189,28 @@ function stepAllowed(step, doc) {
   }
   return true;
 }
-function carriesPass(tr) {
-  return tr.getMeta(unlockAllowed) === true || tr.getMeta(historyReplay) === true;
-}
-function rangeHoldsComment(doc, from, to) {
-  let found = false;
-  doc.nodesBetween(from, to, (node) => {
-    if (found) return false;
-    if (isCommentNode(node)) found = true;
-    return !found;
-  });
-  return found;
-}
-function transactionTouchesComments(tr) {
-  return tr.steps.some((step, index) => {
-    const before = tr.docs[index];
-    const after = tr.docs[index + 1] ?? tr.doc;
-    if (step instanceof AttrStep || step instanceof AddNodeMarkStep || step instanceof RemoveNodeMarkStep) {
-      const node = before.nodeAt(step.pos);
-      return node !== null && isCommentNode(node);
-    }
-    if (!(step instanceof ReplaceStep || step instanceof ReplaceAroundStep || step instanceof AddMarkStep || step instanceof RemoveMarkStep)) {
-      return true;
-    }
-    let touched = false;
-    step.getMap().forEach((oldStart, oldEnd, newStart, newEnd) => {
-      touched ||= rangeHoldsComment(before, oldStart, oldEnd) || rangeHoldsComment(after, newStart, newEnd);
-    });
-    return touched;
-  });
-}
-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);
+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 = rules.protection;
+      const unmodelled = intent;
       return unmodelled;
     }
   }
 }
-function transactionAllowed(tr, state) {
-  if (!tr.docChanged) return true;
-  if (!protectionAllowsTransaction(tr, protectionOf(state))) return false;
-  if (carriesPass(tr)) return true;
-  return tr.steps.every(
-    (step, index) => stepAllowed(step, tr.docs[index] ?? state.doc)
-  );
-}
+var lockGuard = {
+  name: "lock",
+  liftedBy: [unlockAllowed, historyReplay],
+  step: (step, before) => stepAllowed(step, before),
+  shuts: (intent, state) => intentShut(state.doc, intent)
+};
 export {
   carriesLock,
   controlSpans,
@@ -251,12 +218,10 @@ export {
   insertionInsideLocked,
   insideLockedCell,
   isLockedCell,
+  lockGuard,
   lockedMarkOf,
-  protectionAllowsTransaction,
   rangeTouchesLocked,
   replacementShut,
   selectionShut,
-  transactionAllowed,
-  transactionTouchesComments,
   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

@@ -11,9 +11,9 @@
  *
  * 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 (`transactionAllowed` in
- * `./locks`) asks the judgements here. They take documents alone, so that the `./core` entry can
- * make the same judgement over a file without an editor.
+ * 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";
@@ -31,6 +31,13 @@ export interface ProtectionState {
 }
 /** 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;
 /**

package/dist/schema/protection.js

@@ -166,5 +166,6 @@ export {
   commentIdentitiesKept,
   commentOwned,
   isCommentNode,
-  protectionAllows
+  protectionAllows,
+  withoutComments
 };

package/dist/schema/sourceEquality.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Whether two nodes would be written back as the same XML.
+ *
+ * `Node.eq` answers a different question: whether they are the same node, display values and all.
+ * That is the right question inside an editing session, where both sides came from one import and
+ * a difference can only be an edit. It is the wrong one across a re-derivation, because the values
+ * worked out from the surroundings (`./attrRoles`) move without the document moving, and a block
+ * judged changed is a block rewritten, which costs it the markup the writer does not model.
+ *
+ * So the comparison is `Node.eq` with the display attrs left out, and nothing else left out: the
+ * type, the text, the marks and the source and session attrs all have to agree, and the recursion
+ * runs the same way, so a node that says the same thing in a different shape is still a change.
+ */
+import { type Node as PMNode } from "prosemirror-model";
+/**
+ * Whether the two would write the same XML: the same type, text, marks and source attrs, all the
+ * way down. What the editor works out for the screen is not compared.
+ */
+export declare function sameSource(a: PMNode, b: PMNode): boolean;
+/**
+ * The node with every worked-out attr back at the value the schema starts it on, on itself and on
+ * everything inside it.
+ *
+ * `sameSource` needs no such copy, and takes none. This is for a caller that has to hand a whole
+ * document to something comparing the ordinary way.
+ */
+export declare function withoutDisplayAttrs(node: PMNode): PMNode;

package/dist/schema/sourceEquality.js

@@ -0,0 +1,65 @@
+// src/schema/sourceEquality.ts
+import {
+  Fragment
+} from "prosemirror-model";
+import { displayAttrsOf } from "./attrRoles.js";
+function sameValue(a, b) {
+  if (a === b) return true;
+  if (Array.isArray(a) || Array.isArray(b)) {
+    return Array.isArray(a) && Array.isArray(b) && a.length === b.length && a.every((item, at) => sameValue(item, b[at]));
+  }
+  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) {
+    return false;
+  }
+  const left = Object.entries(a);
+  return left.length === Object.keys(b).length && left.every(
+    ([key, value]) => key in b && sameValue(value, b[key])
+  );
+}
+function sameAttrs(display, a, b) {
+  return Object.keys(a).filter((name) => !display.includes(name)).every((name) => sameValue(a[name], b[name]));
+}
+function sameMarks(a, b) {
+  return a.length === b.length && a.every((mark, at) => {
+    const other = b[at];
+    return other !== void 0 && mark.type === other.type && sameAttrs(displayAttrsOf(mark.type), mark.attrs, other.attrs);
+  });
+}
+function sameSource(a, b) {
+  if (a === b) return true;
+  if (a.type !== b.type || !sameMarks(a.marks, b.marks) || !sameAttrs(displayAttrsOf(a.type), a.attrs, b.attrs)) {
+    return false;
+  }
+  if (a.isText) return a.text === b.text;
+  if (a.childCount !== b.childCount) return false;
+  for (let at = 0; at < a.childCount; at += 1) {
+    if (!sameSource(a.child(at), b.child(at))) return false;
+  }
+  return true;
+}
+function withoutDisplay(type, attrs) {
+  return Object.fromEntries(
+    Object.entries(attrs).map(
+      ([name, value]) => displayAttrsOf(type).includes(name) ? [name, type.spec.attrs?.[name]?.default ?? null] : [name, value]
+    )
+  );
+}
+function withoutDisplayMarkAttrs(mark) {
+  return displayAttrsOf(mark.type).length === 0 ? mark : mark.type.create(withoutDisplay(mark.type, mark.attrs));
+}
+var childrenOf = (node) => Array.from({ length: node.childCount }, (_, at) => node.child(at));
+function withoutDisplayAttrs(node) {
+  const marks = node.marks.map(withoutDisplayMarkAttrs);
+  if (node.isText) return node.mark(marks);
+  return node.type.create(
+    withoutDisplay(node.type, node.attrs),
+    Fragment.fromArray(
+      childrenOf(node).map((child) => withoutDisplayAttrs(child))
+    ),
+    marks
+  );
+}
+export {
+  sameSource,
+  withoutDisplayAttrs
+};

package/dist/table/cellFormatting.js

@@ -8,7 +8,8 @@ import {
   NO_FILL,
   toCellFormat
 } from "../model/format.js";
-import { isLockedCell, transactionAllowed } from "../schema/locks.js";
+import { transactionAllowed } from "../schema/guards.js";
+import { isLockedCell } from "../schema/locks.js";
 import { editsShut } from "../schema/protectionState.js";
 import { cellDefaultsAt, tableCellSources } from "./gridBorders.js";
 function text(value) {

package/dist/table/commands.d.ts

@@ -1,8 +1,8 @@
 /**
  * Building a transaction and running it are kept apart.
  * Following the ProseMirror convention, calling a command without `dispatch` only
- * reports whether it can run right now, and that answer takes in the lock guard
- * (`schema/locks`), so no caller has to ask about locks separately.
+ * reports whether it can run right now, and that answer takes in every guard an edit
+ * is judged by (`schema/guards`), so no caller has to ask about them separately.
  */
 import type { EditorState, Transaction } from "prosemirror-state";
 export type TableCommand = (state: EditorState, dispatch?: (tr: Transaction) => void) => boolean;

package/dist/table/commands.js

@@ -3,7 +3,7 @@ import {
   deleteTable as pmDeleteTable,
   isInTable as pmIsInTable
 } from "prosemirror-tables";
-import { transactionAllowed } from "../schema/locks.js";
+import { transactionAllowed } from "../schema/guards.js";
 import {
   buildAddColumnAfterTransaction,
   buildAddColumnBeforeTransaction,

package/dist/table/index.d.ts

@@ -3,8 +3,8 @@
  *
  * Only what the toolbar needs is exported. Following the ProseMirror convention,
  * calling a command without `dispatch` only reports whether it can run right now, and that answer
- * takes in the lock: a structural edit that would carry a locked cell off reports that it does not
- * apply, rather than being refused after the click (`schema/locks`).
+ * takes in every guard an edit is judged by (`schema/guards`): a structural edit that would carry a
+ * locked cell off reports that it does not apply, rather than being refused after the click.
  *
  * Everything here works on a table already in the document; putting a new one into the body is
  * `insertTable` in `./commands`, which reads the page geometry the editor holds.

package/dist/table/merge.d.ts

@@ -6,7 +6,7 @@ import type { EditorState, Transaction } from "prosemirror-state";
 /**
  * Whether several cells can be merged into one.
  * The selection has to be a rectangle spanning more than one cell, no merged cell may stick out
- * past that rectangle, and the lock guard has to let the merge through: a locked cell may not be
+ * past that rectangle, and the guards have to let the merge through: a locked cell may not be
  * swallowed by another (`schema/locks`).
  *
  * The two queries are defined from the very transaction the commands run, so they cannot drift
@@ -16,7 +16,7 @@ import type { EditorState, Transaction } from "prosemirror-state";
 export declare function canMergeCells(state: EditorState): boolean;
 /**
  * Whether a split is possible. The cursor has to sit inside a cell that is merged horizontally or
- * vertically, and the lock guard has to let the split through: the cells a split makes would each
+ * vertically, and the guards have to let the split through: the cells a split makes would each
  * carry the original's lock, which is a lock planted in places it was never put (`schema/locks`).
  */
 export declare function canSplitCell(state: EditorState): boolean;

package/dist/table/merge.js

@@ -11,7 +11,7 @@ import {
   widthNumber,
   withWidthNumber
 } from "../model/format.js";
-import { transactionAllowed } from "../schema/locks.js";
+import { transactionAllowed } from "../schema/guards.js";
 import { inheritCellAttrs } from "./format.js";
 import { cellWidthForGridCol, gridSpanWidth, tableGridCols } from "./widths.js";
 function tableAfter(tr, tableStart) {