@portone/docx-editor 0.2.0 → 0.3.0

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

@@ -1,130 +1,48 @@
 // src/editor/commands/formatting/editing.ts
-import {
-  editRunProps,
-  isRunToggleOn,
-  matchesRunEdit
-} from "../../../docx/runProps.js";
-import { docxSchema } from "../../../schema/index.js";
-import {
-  insertionInsideLocked,
-  rangeTouchesLocked
-} from "../../../schema/locks.js";
-import { editsShut } from "../../../schema/protectionState.js";
-import {
-  activePieces,
-  caretPiece,
-  text,
-  textPieces
-} from "./shared.js";
-function editedMark(target, edit) {
-  const next = editRunProps(
-    { rPr: text(target.mark?.attrs.rPr), format: target.format },
-    target.pPr,
-    edit
-  );
-  if (!next) return null;
-  return docxSchema.marks.run.create({
-    ...target.mark?.attrs,
-    rPr: next.rPr,
-    format: next.format
-  });
-}
-function planChanges(pieces, edit) {
-  const changes = [];
-  for (const target of pieces) {
-    const mark = editedMark(target, edit);
-    if (!mark) return null;
-    changes.push({ from: target.from, to: target.to, mark });
-  }
-  return changes;
-}
-function applyToSelection(state, dispatch, edit) {
-  const pieces = textPieces(state).filter(
-    (target) => (
-      // Text already in the desired state is left untouched, so its original XML survives
-      !matchesRunEdit(target.format, edit) && // A locked stretch is left out rather than refused: the guard turns down the whole
-      // transaction, so asking for it would leave the rest of the selection unformatted too
-      !rangeTouchesLocked(state.doc, target.from, target.to)
-    )
-  );
-  const changes = pieces.length > 0 ? planChanges(pieces, edit) : null;
-  if (!changes) return false;
-  if (dispatch) {
-    const tr = state.tr;
-    for (const change of changes) {
-      tr.addMark(change.from, change.to, change.mark);
-    }
-    dispatch(tr);
-  }
-  return true;
-}
-function applyToCaret(state, dispatch, edit) {
-  const target = caretPiece(state);
-  if (matchesRunEdit(target.format, edit)) return false;
-  const mark = editedMark(target, edit);
-  if (!mark) return false;
-  if (dispatch) {
-    const marks = state.storedMarks ?? state.selection.$from.marks();
-    dispatch(state.tr.setStoredMarks(mark.addToSet(marks)));
-  }
-  return true;
-}
-function runEditCommand(edit) {
-  return (state, dispatch) => {
-    if (editsShut(state)) return false;
-    return state.selection.empty ? applyToCaret(state, dispatch, edit) : applyToSelection(state, dispatch, edit);
-  };
-}
+import { editShut, openStretches } from "../../../schema/guards.js";
+import { runPropertyCommands } from "./propertyCommands.js";
+import { textPieces } from "./shared.js";
 function canFormatText(state) {
-  if (editsShut(state)) return false;
   if (state.selection.empty) {
-    return !insertionInsideLocked(state.doc, state.selection.from);
+    return !editShut(state, { kind: "insert", at: state.selection.from });
   }
-  return textPieces(state).some(
-    (target) => !rangeTouchesLocked(state.doc, target.from, target.to)
-  );
-}
-function isToggleActive(state, toggle) {
-  const pieces = activePieces(state);
-  return pieces.length > 0 && pieces.every((target) => isRunToggleOn(target.format, toggle));
-}
-function toggleCommand(toggle) {
-  return (state, dispatch) => {
-    const edit = {
-      kind: "toggle",
-      toggle,
-      on: !isToggleActive(state, toggle)
-    };
-    return runEditCommand(edit)(state, dispatch);
-  };
-}
-var toggleBold = toggleCommand("bold");
-var toggleItalic = toggleCommand("italic");
-var toggleUnderline = toggleCommand("underline");
-var toggleStrike = toggleCommand("strike");
+  return openStretches(state, textPieces(state), "mark").length > 0;
+}
+var bold = runPropertyCommands("bold");
+var italic = runPropertyCommands("italic");
+var underline = runPropertyCommands("underline");
+var strike = runPropertyCommands("strike");
+var fontSize = runPropertyCommands("fontSizePt");
+var fontFamily = runPropertyCommands("fontFamily");
+var textColor = runPropertyCommands("color");
+var textBackground = runPropertyCommands("background");
+var toggleBold = bold.toggle(true);
+var toggleItalic = italic.toggle(true);
+var toggleUnderline = underline.toggle("single");
+var toggleStrike = strike.toggle(true);
 function setFontSize(pt) {
-  return runEditCommand({ kind: "fontSize", pt });
+  return fontSize.set(pt);
 }
 function setFontFamily(name) {
-  return runEditCommand({ kind: "fontFamily", name });
+  return fontFamily.set(name);
 }
 function setTextColor(hex) {
-  return runEditCommand({ kind: "color", hex });
+  return textColor.set(hex);
 }
 function setTextBackground(hex) {
-  return runEditCommand({ kind: "background", hex });
+  return textBackground.set(hex);
 }
 function isBoldActive(state) {
-  return isToggleActive(state, "bold");
+  return bold.isActive(state);
 }
 function isItalicActive(state) {
-  return isToggleActive(state, "italic");
+  return italic.isActive(state);
 }
 function isUnderlineActive(state) {
-  return isToggleActive(state, "underline");
+  return underline.isActive(state);
 }
 function isStrikeActive(state) {
-  return isToggleActive(state, "strike");
+  return strike.isActive(state);
 }
 export {
   canFormatText,

package/dist/editor/commands/formatting/propertyCommands.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The commands and the query one run property is edited and read through, built from the
+ * property's row in the run property table.
+ *
+ * Each edit preserves the run's untouched XML: the row says which children of the rPr change,
+ * and the mark keeps every other attr it wore.
+ */
+import type { Command, EditorState } from "prosemirror-state";
+import { type EditableRunKey, type RunSetting } from "../../../docx/formatting";
+export interface RunPropertyCommands<K extends EditableRunKey> {
+    /** Writes the value into the selection. Null withdraws the run's own setting, so the layers below decide again */
+    set(value: RunSetting<K> | null): Command;
+    /** Whether the property is on where the selection stands. It counts as on only when it is on everywhere */
+    isActive(state: EditorState): boolean;
+    /**
+     * The same toggle convention as Word: if every character in the selection is already on, turn
+     * them all off; otherwise switch them all on as `on`.
+     */
+    toggle(on: RunSetting<K>): Command;
+}
+export declare function runPropertyCommands<K extends EditableRunKey>(key: K): RunPropertyCommands<K>;

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

@@ -0,0 +1,103 @@
+// src/editor/commands/formatting/propertyCommands.ts
+import {
+  inheritedRunFormat,
+  RUN_PROPERTIES,
+  resolveParagraph,
+  resolveRun
+} from "../../../docx/formatting.js";
+import {
+  editRunProps,
+  matchesRunEdit
+} from "../../../docx/runProps.js";
+import { docxSchema } from "../../../schema/index.js";
+import { editShut, openStretches } from "../../../schema/guards.js";
+import { documentFormatting } from "../../documentStyles.js";
+import {
+  activePieces,
+  caretPiece,
+  text,
+  textPieces
+} from "./shared.js";
+function editedMark(state, target, edit) {
+  const context = documentFormatting(state);
+  const rPr = text(target.mark?.attrs.rPr);
+  const paragraph = resolveParagraph(target.pPr, context);
+  const next = editRunProps(
+    { rPr, format: target.format },
+    inheritedRunFormat(rPr, paragraph, context),
+    edit
+  );
+  if (!next) return null;
+  return docxSchema.marks.run.create({
+    ...target.mark?.attrs,
+    rPr: next.rPr,
+    format: resolveRun(next.rPr, paragraph, context)
+  });
+}
+function planChanges(state, pieces, edit) {
+  const changes = [];
+  for (const target of pieces) {
+    const mark = editedMark(state, target, edit);
+    if (!mark) return null;
+    changes.push({ from: target.from, to: target.to, mark });
+  }
+  return changes;
+}
+function applyToSelection(state, dispatch, edit) {
+  const pieces = openStretches(
+    state,
+    // Text already in the desired state is left untouched, so its original XML survives
+    textPieces(state).filter((target) => !matchesRunEdit(target.format, edit)),
+    "mark"
+  );
+  const changes = pieces.length > 0 ? planChanges(state, pieces, edit) : null;
+  if (!changes) return false;
+  if (dispatch) {
+    const tr = state.tr;
+    for (const change of changes) {
+      tr.addMark(change.from, change.to, change.mark);
+    }
+    dispatch(tr);
+  }
+  return true;
+}
+function applyToCaret(state, dispatch, edit) {
+  if (editShut(state, { kind: "insert", at: state.selection.from })) {
+    return false;
+  }
+  const target = caretPiece(state);
+  if (matchesRunEdit(target.format, edit)) return false;
+  const mark = editedMark(state, target, edit);
+  if (!mark) return false;
+  if (dispatch) {
+    const marks = state.storedMarks ?? state.selection.$from.marks();
+    dispatch(state.tr.setStoredMarks(mark.addToSet(marks)));
+  }
+  return true;
+}
+function runEditCommand(edit) {
+  return (state, dispatch) => state.selection.empty ? applyToCaret(state, dispatch, edit) : applyToSelection(state, dispatch, edit);
+}
+function runPropertyCommands(key) {
+  const property = RUN_PROPERTIES[key];
+  const isOn = (target) => property.isOn(target.format ?? {});
+  const set = (value) => runEditCommand({ key, value });
+  return {
+    set,
+    isActive: (state) => {
+      const pieces = activePieces(state);
+      return pieces.length > 0 && pieces.every(isOn);
+    },
+    toggle: (on) => (state, dispatch) => {
+      const pieces = openStretches(
+        state,
+        state.selection.empty ? [caretPiece(state)] : textPieces(state),
+        "mark"
+      );
+      return set(pieces.every(isOn) ? null : on)(state, dispatch);
+    }
+  };
+}
+export {
+  runPropertyCommands
+};

package/dist/editor/commands/formatting/shared.d.ts

@@ -25,8 +25,8 @@ export declare function textPieces(state: EditorState): TextPiece[];
 /** When the selection is collapsed, the formatting that text typed next will follow */
 export declare function caretPiece(state: EditorState): TextPiece;
 /**
- * The places formatting currently applies to: a single caret, or the text pieces of the selection
- * a lock leaves open. It has to leave out what `applyToSelection` leaves out, or a toggle reads off
- * for text that is already on and can never turn it off.
+ * The formatting a toolbar reads, excluding locked text as it does during editing.
+ * Document protection prevents edits, but must not hide the selected text's actual formatting.
+ * Commands separately ask all guards before deciding what they can change.
  */
 export declare function activePieces(state: EditorState): TextPiece[];

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

@@ -1,7 +1,7 @@
 // src/editor/commands/formatting/shared.ts
 import { toRunFormat } from "../../../model/format.js";
 import { docxSchema } from "../../../schema/index.js";
-import { rangeTouchesLocked } from "../../../schema/locks.js";
+import { lockGuard } from "../../../schema/locks.js";
 function text(value) {
   return typeof value === "string" ? value : null;
 }
@@ -41,7 +41,10 @@ function caretPiece(state) {
 function activePieces(state) {
   if (state.selection.empty) return [caretPiece(state)];
   return textPieces(state).filter(
-    (target) => !rangeTouchesLocked(state.doc, target.from, target.to)
+    (target) => !lockGuard.shuts(
+      { kind: "mark", from: target.from, to: target.to },
+      state
+    )
   );
 }
 export {

package/dist/editor/commands/historyCommands.js

@@ -1,6 +1,7 @@
 // src/editor/commands/historyCommands.ts
 import { redo as historyRedo, undo as historyUndo } from "prosemirror-history";
-import { historyReplay, transactionAllowed } from "../../schema/locks.js";
+import { transactionAllowed } from "../../schema/guards.js";
+import { historyReplay } from "../../schema/locks.js";
 function replaying(command) {
   return (state, dispatch, view) => {
     const built = [];

package/dist/editor/commands/indentCommands.js

@@ -1,6 +1,7 @@
 // src/editor/commands/indentCommands.ts
 import { withLeftIndent, withListNumbering } from "../../docx/paraProps.js";
 import { toParagraphFormat } from "../../model/format.js";
+import { TWIPS_PER_PT } from "../../ooxml/simpleTypes.js";
 import { editParagraphs, paragraphPPr } from "../paragraphEdits.js";
 import { documentNumbering } from "../plugins/numberingDecorations.js";
 import { listLevelChange, listRefOf } from "./listCommands.js";
@@ -8,7 +9,7 @@ var STEP_TWIPS = 720;
 function leftIndentTwips(node) {
   const format = toParagraphFormat(node.attrs.format);
   const pt = format?.indentStartPt ?? format?.indentLeftPt ?? 0;
-  return Math.round(pt * 20);
+  return Math.round(pt * TWIPS_PER_PT);
 }
 function steppedLeftTwips(node, delta) {
   const left = leftIndentTwips(node);
@@ -18,13 +19,13 @@ function steppedLeftTwips(node, delta) {
 function indentStep(delta) {
   return (state, dispatch) => {
     const numbering = documentNumbering(state);
-    return editParagraphs(state, dispatch, (node, styles, defaultStyleId) => {
+    return editParagraphs(state, dispatch, (node) => {
       if (listRefOf(node)) {
         const change = listLevelChange(numbering, node, delta);
-        return change && withListNumbering(paragraphPPr(node), change, styles, defaultStyleId);
+        return change && withListNumbering(paragraphPPr(node), change);
       }
       const left = steppedLeftTwips(node, delta);
-      return left === null ? null : withLeftIndent(paragraphPPr(node), left, styles, defaultStyleId);
+      return left === null ? null : withLeftIndent(paragraphPPr(node), left);
     });
   };
 }

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

@@ -13,6 +13,8 @@ export type { ParagraphStyleOption } from "../../docx/formatting";
 export type { RunToggle } from "../../docx/runProps";
 export type { LineSpacing, ParagraphAlign } from "../../model/format";
 export type { ListKind } from "../../numbering/listTemplate";
+/** The codes a problem below is reported under, which are the ones `DocxExportError` is thrown with */
+export type { DocxExportErrorCode } from "../../ooxml/errors";
 /** The size an image is shown at, which the insert command asks for */
 export type { ImageExtent } from "../../ooxml/image";
 /**
@@ -56,6 +58,15 @@ export { insertLineBreak, insertPageBreak } from "./breakCommands";
 export { canRunCommand } from "./canRunCommand";
 export type { CommentAuthor, DocumentComment, DocumentCommentReply, NewComment, } from "./commentCommands";
 export { addComment, addCommentReply, canAddComment, canEditComment, documentComments, removeComment, removeCommentReply, selectComment, setCommentResolved, updateComment, updateCommentReply, } from "./commentCommands";
+/**
+ * Whether the document as it stands can be written back, and every reason it could not, each
+ * with the code `exportDocx` would throw it under. `canExport` is what an export control is
+ * drawn from, and `downloadDocx` answers `blocked` with the same list.
+ */
+export type { ExportProblem } from "./exportQueries";
+export { canExport, documentExportProblems } from "./exportQueries";
+export type { FidelityCode, FidelityNote, FidelitySeverity, } from "./fidelityQueries";
+export { documentFidelity } from "./fidelityQueries";
 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

@@ -29,6 +29,8 @@ import {
   updateComment,
   updateCommentReply
 } from "./commentCommands.js";
+import { canExport, documentExportProblems } from "./exportQueries.js";
+import { documentFidelity } from "./fidelityQueries.js";
 import {
   activeFontFamily,
   activeFontSize,
@@ -111,6 +113,7 @@ export {
   canAddComment,
   canDecreaseIndent,
   canEditComment,
+  canExport,
   canFormatText,
   canIncreaseIndent,
   canInsertImage,
@@ -124,6 +127,8 @@ export {
   documentBodyWidthPx,
   documentComments,
   documentDefaults,
+  documentExportProblems,
+  documentFidelity,
   documentFontNames,
   documentHasLocked,
   documentNotes,

package/dist/editor/commands/linkCommands.js

@@ -1,7 +1,6 @@
 // src/editor/commands/linkCommands.ts
 import { docxSchema } from "../../schema/index.js";
-import { rangeTouchesLocked } from "../../schema/locks.js";
-import { editsShut } from "../../schema/protectionState.js";
+import { openStretches } from "../../schema/guards.js";
 var linkType = docxSchema.marks.link;
 function text(value) {
   return typeof value === "string" ? value : null;
@@ -75,10 +74,10 @@ 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)
+  return openStretches(
+    state,
+    state.selection.empty ? caretPieces(state) : selectionPieces(state),
+    "mark"
   );
 }
 function caretPieces(state) {

package/dist/editor/commands/listCommands.js

@@ -25,9 +25,9 @@ function listRefOf(node) {
   return toParagraphFormat(node.attrs.format)?.numbering ?? null;
 }
 function changeParagraphs(state, dispatch, plan) {
-  return editParagraphs(state, dispatch, (node, styles, defaultStyleId) => {
+  return editParagraphs(state, dispatch, (node) => {
     const change = plan(node);
-    return change && withListNumbering(paragraphPPr(node), change, styles, defaultStyleId);
+    return change && withListNumbering(paragraphPPr(node), change);
   });
 }
 function indentForLevel(numbering, node, ref) {
@@ -107,15 +107,13 @@ function isInList(state) {
     (spot) => listRefOf(spot.node) !== null
   );
 }
-var leaveListAtLineStart = (state, dispatch) => editParagraphs(state, dispatch, (node, styles, defaultStyleId) => {
+var leaveListAtLineStart = (state, dispatch) => editParagraphs(state, dispatch, (node) => {
   if (!listRefOf(node)) return null;
-  const unlisted = withListNumbering(
-    paragraphPPr(node),
-    { numbering: null, indent: { kind: "clearHanging" } },
-    styles,
-    defaultStyleId
-  );
-  return unlisted && withLeftIndent(unlisted.pPr, 0, styles, defaultStyleId);
+  const unlisted = withListNumbering(paragraphPPr(node), {
+    numbering: null,
+    indent: { kind: "clearHanging" }
+  });
+  return unlisted && withLeftIndent(unlisted.pPr, 0);
 });
 var leaveEmptyListItem = (state, dispatch) => {
   const { empty, $from } = state.selection;

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

@@ -25,7 +25,13 @@ export declare function selectionLock(state: EditorState): SelectionLock;
  * A selection that also reaches a lock still locks what that lock leaves open.
  */
 export declare const lockSelection: Command;
-/** Lifts the lock off every control the selection reaches, over that control's whole stretch */
+/**
+ * Lifts the lock off every control the selection reaches, over that control's whole stretch.
+ *
+ * The transaction carries the pass that lets it reach past the very locks it lifts, which is the
+ * one thing the pass is for; every other guard still has its say, so lifting a lock stays shut
+ * under a protection that shuts the body (`schema/guards`).
+ */
 export declare const unlockSelection: Command;
 /**
  * Whether editing where the selection stands is shut.

package/dist/editor/commands/lockCommands.js

@@ -3,20 +3,20 @@ import {
   TextSelection
 } from "prosemirror-state";
 import { namesNothing, newControlId } from "../../docx/sdt.js";
-import { withContentLock } from "../../docx/sdtProps.js";
+import { lockedControlPrefix, withContentLock } from "../../docx/sdtProps.js";
 import { docxSchema } from "../../schema/index.js";
+import { guardedCommand, openStretches } from "../../schema/guards.js";
 import {
   carriesLock,
   controlSpans,
   isLockedCell,
-  rangeTouchesLocked,
   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: lockedControlPrefix(id),
     contentsLocked: true,
     deletionLocked: true
   });
@@ -67,29 +67,33 @@ function takeover(met, stretch, open) {
   if (!only || isLocked(only.mark) || !prefix || !namesNothing(prefix)) {
     return null;
   }
-  const mark = open(stretch) ? withLock(only.mark, true) : null;
+  const mark = open ? withLock(only.mark, true) : null;
   return mark ? {
     from: Math.min(stretch.from, only.from),
     to: Math.max(stretch.to, only.to),
     mark
   } : null;
 }
-function blockLockEdits(doc, block, spans, reach) {
+function blockLockEdits(state, block, spans, reach) {
   const stretch = stretchIn(block, reach);
   if (!stretch) return [];
-  const open = (at) => !rangeTouchesLocked(doc, at.from, at.to);
+  const open = (of) => openStretches(state, of, "mark");
   const met = spans.filter((span) => overlaps(span, stretch));
-  const taken = takeover(met, stretch, open);
+  const taken = takeover(met, stretch, open([stretch]).length > 0);
   if (taken) return [taken];
-  const shut = met.filter((span) => !isLocked(span.mark) && open(span)).flatMap((span) => {
-    const mark = withLock(span.mark, true);
-    return mark ? [{ from: span.from, to: span.to, mark }] : [];
-  });
-  const fresh = gapsIn(stretch, spans).filter(open).map((gap) => ({ ...gap, mark: lockedControlMark(newControlId()) }));
+  const shut = open(met.filter((span) => !isLocked(span.mark))).flatMap(
+    (span) => {
+      const mark = withLock(span.mark, true);
+      return mark ? [{ from: span.from, to: span.to, mark }] : [];
+    }
+  );
+  const fresh = open(gapsIn(stretch, spans)).map((gap) => ({
+    ...gap,
+    mark: lockedControlMark(newControlId())
+  }));
   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 = [];
@@ -106,7 +110,7 @@ function selectionLockDetail(state) {
         if (isLocked(span.mark) && reaches(span, reach)) spans.push(span);
       }
       if (locking) {
-        edits.push(...blockLockEdits(state.doc, block, controls, reach));
+        edits.push(...blockLockEdits(state, block, controls, reach));
       }
       return false;
     });
@@ -122,7 +126,7 @@ function selectionLockDetail(state) {
   return anyLocked ? { kind: "mixed", edits, ...locked } : { kind: "lockable", edits };
 }
 function selectionLock(state) {
-  return selectionLockDetail(state).kind;
+  return editsShut(state) ? "none" : selectionLockDetail(state).kind;
 }
 function lockEditsOf(lock) {
   switch (lock.kind) {
@@ -145,16 +149,13 @@ function lockedOf(lock) {
       return NOTHING_LOCKED;
   }
 }
-var lockSelection = (state, dispatch) => {
+var lockSelection = guardedCommand((state) => {
   const edits = lockEditsOf(selectionLockDetail(state));
-  if (edits.length === 0) return false;
-  if (dispatch) {
-    const tr = state.tr;
-    for (const edit of edits) tr.addMark(edit.from, edit.to, edit.mark);
-    dispatch(tr);
-  }
-  return true;
-};
+  if (edits.length === 0) return null;
+  const tr = state.tr;
+  for (const edit of edits) tr.addMark(edit.from, edit.to, edit.mark);
+  return tr;
+});
 function unlockCell(tr, cell) {
   const prefix = prefixOf(cell.node.attrs);
   tr.setNodeMarkup(cell.pos, null, {
@@ -164,21 +165,18 @@ function unlockCell(tr, cell) {
     sdtDeletionLocked: false
   });
 }
-var unlockSelection = (state, dispatch) => {
+var unlockSelection = guardedCommand((state) => {
   const { spans, cells } = lockedOf(selectionLockDetail(state));
-  if (spans.length === 0 && cells.length === 0) return false;
-  if (dispatch) {
-    const tr = state.tr.setMeta(unlockAllowed, true);
-    for (const span of spans) {
-      const opened = withLock(span.mark, false);
-      if (opened) tr.addMark(span.from, span.to, opened);
-      else tr.removeMark(span.from, span.to, span.mark);
-    }
-    for (const cell of cells) unlockCell(tr, cell);
-    dispatch(tr);
+  if (spans.length === 0 && cells.length === 0) return null;
+  const tr = state.tr.setMeta(unlockAllowed, true);
+  for (const span of spans) {
+    const opened = withLock(span.mark, false);
+    if (opened) tr.addMark(span.from, span.to, opened);
+    else tr.removeMark(span.from, span.to, span.mark);
   }
-  return true;
-};
+  for (const cell of cells) unlockCell(tr, cell);
+  return tr;
+});
 function selectionTouchesLocked(state) {
   return selectionShut(state.selection, state.doc);
 }