@eigenpal/docx-editor-core/prosemirror/commands

acceptAllChangesfunctionSource ↗

Accept every tracked change in the document — inline marks plus structural revisions (paragraph-mark, row, cell, property changes).

Dispatches one transaction per distinct revisionId so each revision remains individually undoable. The acceptance order follows document order; later transactions read fresh state and skip ids whose sites were already removed.

declare function acceptAllChanges(): Command;

```ts
import { acceptAllChanges } from '@eigenpal/docx-editor-core/prosemirror/commands';
acceptAllChanges()(view.state, view.dispatch);
```

acceptChangefunctionSource ↗

Accept a tracked change at the given range. - Insertion: remove mark, keep text - Deletion: remove mark AND text

Use [acceptChangeById](acceptChangeById) when accepting a coalesced revision — a single editing session can scatter sites across multiple paragraphs and only the by-id resolver walks every site.

declare function acceptChange(from: number, to: number): Command;

```ts
import { acceptChange } from '@eigenpal/docx-editor-core/prosemirror/commands';
acceptChange(from, to)(view.state, view.dispatch);
```

acceptChangeByIdfunctionSource ↗

Accept every site of a tracked revision in one PM transaction. Walks the doc for all sites carrying revisionId — inline insertion/ deletion marks, paragraph-mark pPrIns / pPrDel, paragraph property changes, table row / cell / table revisions — and applies the accept semantics each requires.

This is the right command for any coalesced revision (Enter chains, replace pairs, multi-paragraph runs) because one editing session can scatter sites across the doc; the range-based [acceptChange](acceptChange) only clears sites within its (from, to).

Returns false (no-op) if the id is not present.

declare function acceptChangeById(revisionId: number): Command;

```ts
import { acceptChangeById } from '@eigenpal/docx-editor-core/prosemirror/commands';
acceptChangeById(revisionId)(view.state, view.dispatch);
```

addColumnLeftfunctionSource ↗

declare function addColumnLeft(state: EditorState, dispatch?: (tr: Transaction) => void): boolean;

addColumnRightfunctionSource ↗

declare function addColumnRight(state: EditorState, dispatch?: (tr: Transaction) => void): boolean;

addCommentMarkfunctionSource ↗

Add a comment mark to the current selection.

declare function addCommentMark(commentId: number): Command;

addRowAbovefunctionSource ↗

declare function addRowAbove(state: EditorState, dispatch?: (tr: Transaction) => void): boolean;

addRowBelowfunctionSource ↗

declare function addRowBelow(state: EditorState, dispatch?: (tr: Transaction) => void): boolean;

addTabStopfunctionSource ↗

declare function addTabStop(position: number, alignment?: TabStopAlignment, leader?: TabLeader): Command;

applyStylefunctionSource ↗

declare function applyStyle(styleId: string, resolvedAttrs?: ResolvedStyleAttrs): Command;

applyTableStylefunctionSource ↗

declare function applyTableStyle(styleData: {
    styleId: string;
    tableBorders?: Record<string, unknown>;
    conditionals?: Record<string, unknown>;
    look?: Record<string, boolean>;
}): (state: EditorState, dispatch?: (tr: Transaction) => void) => boolean;

autoFitContentsfunctionSource ↗

declare function autoFitContents(): (state: EditorState, dispatch?: (tr: Transaction) => void) => boolean;

createRemoveMarkCommandfunctionSource ↗

Create a command that removes a mark from the selection

declare function createRemoveMarkCommand(markType: MarkType): Command;

createSetMarkCommandfunctionSource ↗

Create a command that sets a mark on the selection

declare function createSetMarkCommand(markType: MarkType, attrs?: Record<string, unknown>): Command;

decreaseIndentfunctionSource ↗

declare function decreaseIndent(amount?: number): Command;

deleteColumnfunctionSource ↗

declare function deleteColumn(state: EditorState, dispatch?: (tr: Transaction) => void): boolean;

deleteRowfunctionSource ↗

declare function deleteRow(state: EditorState, dispatch?: (tr: Transaction) => void): boolean;

deleteTablefunctionSource ↗

declare function deleteTable(state: EditorState, dispatch?: (tr: Transaction) => void): boolean;

distributeColumnsfunctionSource ↗

declare function distributeColumns(): (state: EditorState, dispatch?: (tr: Transaction) => void) => boolean;

findHyperlinkRangeAtfunctionSource ↗

Resolve the hyperlink mark + contiguous range that surrounds the current cursor. Used by edit/remove popup actions in both adapters.

Resolution order for the mark itself: 1. $from.marks() — the normal active-marks lookup 2. $from.nodeAfter/nodeBefore marks — boundary positions don't report active marks via marks() 3. (optional) text-node search by fallbackHref — last resort when the popup knows the href but the cursor sits at a gap

The returned range walks the parent block grouping consecutive text nodes that share the same href, and returns whichever range contains the cursor.

declare function findHyperlinkRangeAt(state: EditorState, fallbackHref?: string): {
    mark: Mark;
    start: number;
    end: number;
} | null;

findNextChangefunctionSource ↗

Find the next tracked-change range (inline insertion / deletion mark) after startPos. Wraps to the document start when no later change is found. Useful for "next change" / "previous change" toolbar buttons.

Only walks inline marks — structural revisions (pPrIns / pPrDel / row / cell) are not surfaced here. Use [extractTrackedChanges](extractTrackedChanges) for a complete revision list.

declare function findNextChange(state: EditorState, startPos: number): ChangeRange | null;

findPreviousChangefunctionSource ↗

Find the previous tracked-change range (inline insertion / deletion mark) before startPos. Wraps to the document end when no earlier change is found. Counterpart to [findNextChange](findNextChange).

declare function findPreviousChange(state: EditorState, startPos: number): ChangeRange | null;

getHyperlinkAttrsfunctionSource ↗

declare function getHyperlinkAttrs(state: EditorState): {
    href: string;
    tooltip?: string;
} | null;

getListInfofunctionSource ↗

declare function getListInfo(state: EditorState): {
    numId: number;
    ilvl: number;
} | null;

getMarkAttrfunctionSource ↗

Get the current value of a mark attribute

declare function getMarkAttr(state: EditorState, markType: MarkType, attr: string): unknown | null;

getParagraphAlignmentfunctionSource ↗

declare function getParagraphAlignment(state: EditorState): ParagraphAlignment | null;

getParagraphBidifunctionSource ↗

declare function getParagraphBidi(state: EditorState): boolean;

getSelectedTextfunctionSource ↗

declare function getSelectedText(state: EditorState): string;

getSplitCellDialogConfigfunctionSource ↗

declare function getSplitCellDialogConfig(state: EditorState): SplitCellDialogConfig | null;

getStyleIdfunctionSource ↗

declare function getStyleId(state: EditorState): string | null;

getTableContextfunctionSource ↗

declare function getTableContext(state: EditorState): TableContextInfo;

getWatermarkFromStatefunctionSource ↗

Read the current watermark from a ProseMirror state's doc attrs.

declare function getWatermarkFromState(state: EditorState): Watermark | null;

increaseIndentfunctionSource ↗

declare function increaseIndent(amount?: number): Command;

insertHyperlinkfunctionSource ↗

declare function insertHyperlink(text: string, href: string, tooltip?: string): Command;

insertImageFromFilefunctionSource ↗

Read an image File (from a file picker or drop), fit it to the page width, and insert it inline at the current selection. This is the single source of truth for "insert an image from a file" — the React and Vue adapters both call it, so insertion behaves identically: no intermediate dialog, the image is sized to fit the column, and it round-trips as an inline drawing (with the insertion mark applied in suggesting mode, via [insertImageNode](insertImageNode)).

The decode is async (FileReader → Image); onError reports a failed read or decode, and onInserted runs after the node lands (e.g. to refocus).

declare function insertImageFromFile(view: EditorView, file: File, opts?: {
    maxWidth?: number;
    onError?: (error: unknown) => void;
    onInserted?: () => void;
}): void;

insertImageNodefunctionSource ↗

Insert an image node at pos, wrapping with the insertion mark when suggesting mode is active. Centralizes the tracked-image-insert flow so React useFileIO, Vue useImageActions, and clipboard-paste paths all share one source of truth — adding a fresh image in suggesting mode always round-trips as <w:ins>{run with drawing}</w:ins>.

Caller responsibility: produce the image node via schema.nodes.image.create. This helper handles the dispatch + optional mark application.

declare function insertImageNode(state: EditorState, dispatch: ((tr: Transaction) => void) | undefined, imageNode: Node, pos: number): boolean;

insertTablefunctionSource ↗

declare function insertTable(rows: number, cols: number): (state: EditorState, dispatch?: (tr: Transaction) => void) => boolean;

isHyperlinkActivefunctionSource ↗

declare function isHyperlinkActive(state: EditorState): boolean;

isInListfunctionSource ↗

declare function isInList(state: EditorState): boolean;

isInTablefunctionSource ↗

declare function isInTableCell(state: EditorState): boolean;

isMarkActivefunctionSource ↗

Check if a mark is active in the current selection

declare function isMarkActive(state: EditorState, markType: MarkType, attrs?: Record<string, unknown>): boolean;

mergeCellsfunctionSource ↗

declare function mergeCells(state: EditorState, dispatch?: (tr: Transaction) => void): boolean;

rejectAllChangesfunctionSource ↗

Reject all tracked changes in the document — inverse of acceptAllChanges.

declare function rejectAllChanges(): Command;

rejectChangefunctionSource ↗

Reject a tracked change at the given range. - Insertion: remove mark AND text - Deletion: remove mark, keep text

Use [rejectChangeById](rejectChangeById) when rejecting a coalesced revision.

declare function rejectChange(from: number, to: number): Command;

rejectChangeByIdfunctionSource ↗

Reject every site of a tracked revision in one PM transaction. Inverse of [acceptChangeById](acceptChangeById) — inserts are removed, deletions keep their text, paragraph-mark insertions join paragraphs back, paragraph-mark deletions stay split, paragraph property changes restore prior values, and tracked row insertions are removed.

declare function rejectChangeById(revisionId: number): Command;

removeCommentMarkfunctionSource ↗

Remove a comment mark by ID from the entire document.

declare function removeCommentMark(commentId: number): Command;

removeTableBordersfunctionSource ↗

declare function removeTableBorders(state: EditorState, dispatch?: (tr: Transaction) => void): boolean;

removeTabStopfunctionSource ↗

declare function removeTabStop(position: number): Command;

selectColumnfunctionSource ↗

declare function selectColumn(state: EditorState, dispatch?: (tr: Transaction) => void): boolean;

selectRowfunctionSource ↗

declare function selectRow(state: EditorState, dispatch?: (tr: Transaction) => void): boolean;

selectTablefunctionSource ↗

declare function selectTable(state: EditorState, dispatch?: (tr: Transaction) => void): boolean;

setAlignmentfunctionSource ↗

Paragraph Formatting Commands — thin re-exports from extension system

Alignment, line spacing, indentation, lists, paragraph styles. All implementations live in extensions/; this file re-exports for backward compatibility.

declare function setAlignment(alignment: ParagraphAlignment): Command;

setAllTableBordersfunctionSource ↗

declare function setAllTableBorders(state: EditorState, dispatch?: (tr: Transaction) => void, borderSpec?: {
    style: string;
    size: number;
    color: {
        rgb: string;
    };
}): boolean;

setCellBorderfunctionSource ↗

declare function setCellBorder(side: 'top' | 'bottom' | 'left' | 'right' | 'all', spec: {
    style: string;
    size?: number;
    color?: {
        rgb: string;
    };
} | null, clearOthers?: boolean): (state: EditorState, dispatch?: (tr: Transaction) => void) => boolean;

setCellFillColorfunctionSource ↗

declare function setCellFillColor(color: string | null): (state: EditorState, dispatch?: (tr: Transaction) => void) => boolean;

setCellMarginsfunctionSource ↗

declare function setCellMargins(margins: {
    top?: number;
    bottom?: number;
    left?: number;
    right?: number;
}): (state: EditorState, dispatch?: (tr: Transaction) => void) => boolean;

setCellTextDirectionfunctionSource ↗

declare function setCellTextDirection(direction: string | null): (state: EditorState, dispatch?: (tr: Transaction) => void) => boolean;

setCellVerticalAlignfunctionSource ↗

declare function setCellVerticalAlign(align: 'top' | 'center' | 'bottom'): (state: EditorState, dispatch?: (tr: Transaction) => void) => boolean;

setFontFamilyfunctionSource ↗

declare function setFontFamily(fontName: string): Command;

setFontSizefunctionSource ↗

declare function setFontSize(size: number): Command;

setHighlightfunctionSource ↗

declare function setHighlight(color: string): Command;

setHyperlinkfunctionSource ↗

declare function setHyperlink(href: string, tooltip?: string): Command;

setImageWrapTypefunctionSource ↗

Change a floating image's wrap layout. pos is the PM document position of the image node; target is either an OOXML wrap type (square / tight / topAndBottom / behind / inFront / inline) or a directional convenience choice (squareLeft / squareRight).

opts.initialPositionEmu is used when promoting an inline image to an anchor — the caller measures the image's current rendered offset relative to the column origin in EMUs and passes it through, so the new float lands exactly where the inline glyph used to sit (matches Word's behavior).

declare function setImageWrapType(pos: number, target: ImageLayoutTarget, opts?: SetImageWrapTypeOptions): Command;

setIndentFirstLinefunctionSource ↗

declare function setIndentFirstLine(twips: number, hanging?: boolean): Command;

setIndentLeftfunctionSource ↗

declare function setIndentLeft(twips: number): Command;

setIndentRightfunctionSource ↗

declare function setIndentRight(twips: number): Command;

setInsideTableBordersfunctionSource ↗

declare function setInsideTableBorders(state: EditorState, dispatch?: (tr: Transaction) => void, borderSpec?: {
    style: string;
    size: number;
    color: {
        rgb: string;
    };
}): boolean;

setLineSpacingfunctionSource ↗

declare function setLineSpacing(value: number, rule?: LineSpacingRule): Command;

setOutsideTableBordersfunctionSource ↗

declare function setOutsideTableBorders(state: EditorState, dispatch?: (tr: Transaction) => void, borderSpec?: {
    style: string;
    size: number;
    color: {
        rgb: string;
    };
}): boolean;

setRowHeightfunctionSource ↗

declare function setRowHeight(height: number | null, rule?: 'auto' | 'atLeast' | 'exact'): (state: EditorState, dispatch?: (tr: Transaction) => void) => boolean;

setSpaceAfterfunctionSource ↗

declare function setSpaceAfter(twips: number): Command;

setSpaceBeforefunctionSource ↗

declare function setSpaceBefore(twips: number): Command;

setTableBorderColorfunctionSource ↗

declare function setTableBorderColor(color: string): (state: EditorState, dispatch?: (tr: Transaction) => void) => boolean;

setTableBordersfunctionSource ↗

declare function setTableBorders(preset: BorderPreset, borderSpec?: {
    style: string;
    size: number;
    color: {
        rgb: string;
    };
}): (state: EditorState, dispatch?: (tr: Transaction) => void) => boolean;

setTableBorderWidthfunctionSource ↗

declare function setTableBorderWidth(size: number): (state: EditorState, dispatch?: (tr: Transaction) => void) => boolean;

setTablePropertiesfunctionSource ↗

declare function setTableProperties(props: {
    width?: number | null;
    widthType?: string | null;
    justification?: 'left' | 'center' | 'right' | null;
}): (state: EditorState, dispatch?: (tr: Transaction) => void) => boolean;

setTextColorfunctionSource ↗

declare function setTextColor(attrs: TextColorAttrs): Command;

setUnderlineStylefunctionSource ↗

declare function setUnderlineStyle(style: string, color?: TextColorAttrs): Command;

setWatermarkfunctionSource ↗

Set (or clear, with null) the document watermark. Dispatches a setDocAttribute transaction so the change is undoable.

declare function setWatermark(watermark: Watermark | null): Command;

splitActiveTableCellfunctionSource ↗

declare function splitActiveTableCell(state: EditorState, dispatch: ((tr: Transaction) => void) | undefined, rows: number, cols: number, 
targetRow?: number, targetCol?: number): boolean;

splitCellfunctionSource ↗

declare function splitCell(state: EditorState, dispatch?: (tr: Transaction) => void): boolean;

toggleHeaderRowfunctionSource ↗

declare function toggleHeaderRow(): (state: EditorState, dispatch?: (tr: Transaction) => void) => boolean;

toggleNoWrapfunctionSource ↗

declare function toggleNoWrap(): (state: EditorState, dispatch?: (tr: Transaction) => void) => boolean;

ResolvedStyleAttrsinterfaceSource ↗

interface ResolvedStyleAttrs

SetImageWrapTypeOptionsinterfaceSource ↗

Optional context for setImageWrapType transitions:

- initialPositionEmu: when promoting an inline image to an anchor, the caller passes the inline image's current rendered position relative to the column origin in EMUs. The command stores this as the anchor's wp:positionH / wp:positionV so Word renders the new float exactly where the inline image used to sit (Word's own behavior).

interface SetImageWrapTypeOptions

SplitCellDialogConfiginterfaceSource ↗

ProseMirror table cell splitting — dialog-backed split with explicit row/column input.

Uses the shared split algorithm from utils/tableSplitAlgorithm.ts for the core layout computation, then maps the result back into ProseMirror transactions.

interface SplitCellDialogConfig

TableContextInfointerfaceSource ↗

Table selection context + navigation helpers.

getTableContext walks the selection up from $from and reports which table / row / cell the cursor is in, plus the table's row/column counts, whether a multi-cell selection is active, and the current cell's border + fill colors (so the toolbar's color pickers can show the live values).

goToNextCell / goToPrevCell are tab-stop-style cell navigation commands registered by the plugin extension.

interface TableContextInfo

AnchorWrapTypetypeSource ↗

Anchored wrap-type targets — the OOXML wrap types except inline.

type AnchorWrapType = Exclude<WrapType, 'inline'>;

BorderPresettypeSource ↗

Cell-border commands. Each command applies a preset / individual side / color / width to the cells targeted by the current selection (single cursor cell or active CellSelection).

All four commands use the shared buildTableGrid lookup to find each cell's neighbours in the grid, then sync the matching edge on the adjacent cell — Google-Docs style edge-symmetric border editing.

Schema-free: only attribute updates via tr.setNodeMarkup.

type BorderPreset = 'all' | 'outside' | 'inside' | 'none';

ImageLayoutTargettypeSource ↗

User-facing layout choices that mirror Word's Wrap Text menu. These are directional shortcuts that fold (wrapType, cssFloat) into a single picker option:

- squareLeft — image floats left, text wraps on the right - squareRight — image floats right, text wraps on the left - inline — image flows in the line as a glyph - the other targets are 1:1 with their OOXML wrap types

setImageWrapType accepts both raw OOXML targets (square / tight / through / topAndBottom / behind / inFront / inline) and the directional convenience targets.

type ImageLayoutTarget = AnchorWrapType | 'squareLeft' | 'squareRight' | 'inline';

alignCenterconstSource ↗

alignCenter: Command

alignJustifyconstSource ↗

alignJustify: Command

alignLeftconstSource ↗

alignLeft: Command

alignRightconstSource ↗

alignRight: Command

clearFontFamilyconstSource ↗

clearFontFamily: Command

clearFontSizeconstSource ↗

clearFontSize: Command

clearFormattingconstSource ↗

Clear all text formatting (remove all marks)

clearFormatting: Command

clearHighlightconstSource ↗

clearHighlight: Command

clearStyleconstSource ↗

clearStyle: Command

clearTextColorconstSource ↗

clearTextColor: Command

decreaseListLevelconstSource ↗

decreaseListLevel: Command

doubleSpacingconstSource ↗

doubleSpacing: Command

generateTOCconstSource ↗

generateTOC: Command

increaseListLevelconstSource ↗

increaseListLevel: Command

INSERT_IMAGE_MAX_WIDTH_PXconstSource ↗

Default max width (px) for an image inserted from a file picker — the content area of a US Letter page at 96dpi (~6.375in). Images wider than this are scaled down to fit the column, matching Word and keeping the painter's max-width: 100% from shrinking the rendered height out from under the reserved line height (which would leave a gap below the image).

INSERT_IMAGE_MAX_WIDTH_PX = 612

insertPageBreakconstSource ↗

Insert a page break at the current cursor position. Always ensures a paragraph follows the page break and places the cursor there.

insertPageBreak: Command

insertSectionBreakContinuousconstSource ↗

Insert a "continuous" section break at the cursor — starts a new section on the same page.

insertSectionBreakContinuous: Command

insertSectionBreakNextPageconstSource ↗

Insert a "next page" section break at the cursor — starts a new section on a new page.

insertSectionBreakNextPage: Command

oneAndHalfSpacingconstSource ↗

oneAndHalfSpacing: Command

removeHyperlinkconstSource ↗

removeHyperlink: Command

removeListconstSource ↗

removeList: Command

setLtrconstSource ↗

setLtr: Command

setRtlconstSource ↗

setRtl: Command

singleSpacingconstSource ↗

singleSpacing: Command

toggleBoldconstSource ↗

toggleBold: Command

toggleBulletListconstSource ↗

toggleBulletList: Command

toggleItalicconstSource ↗

toggleItalic: Command

toggleNumberedListconstSource ↗

toggleNumberedList: Command

toggleStrikeconstSource ↗

toggleStrike: Command

toggleSubscriptconstSource ↗

toggleSubscript: Command

toggleSuperscriptconstSource ↗

toggleSuperscript: Command

toggleUnderlineconstSource ↗

toggleUnderline: Command