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

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);
```

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);
```

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);
```

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

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

Add a comment mark to the current selection.

declare function addCommentMark(commentId: number): Command;

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

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

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

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

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;

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

Create a command that removes a mark from the selection

declare function createRemoveMarkCommand(markType: MarkType): Command;

Create a command that sets a mark on the selection

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

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

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

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

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

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

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;

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;

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;

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

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

Get the current value of a mark attribute

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

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

declare function getParagraphBidi(state: EditorState): boolean;

declare function getSelectedText(state: EditorState): string;

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

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

declare function getTableContext(state: EditorState): TableContextInfo;

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

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

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

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

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;

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

declare function isHyperlinkActive(state: EditorState): boolean;

declare function isInList(state: EditorState): boolean;

declare function isInTableCell(state: EditorState): boolean;

Check if a mark is active in the current selection

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

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

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

declare function rejectAllChanges(): Command;

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;

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;

Remove a comment mark by ID from the entire document.

declare function removeCommentMark(commentId: number): Command;

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

declare function removeTabStop(position: number): Command;

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

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

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

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;

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

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;

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

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

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

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

declare function setFontFamily(fontName: string): Command;

declare function setFontSize(size: number): Command;

declare function setHighlight(color: string): Command;

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

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;

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

declare function setIndentLeft(twips: number): Command;

declare function setIndentRight(twips: number): Command;

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

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

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

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

declare function setSpaceAfter(twips: number): Command;

declare function setSpaceBefore(twips: number): Command;

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

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

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

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

declare function setTextColor(attrs: TextColorAttrs): Command;

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

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

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

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

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

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

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

interface ResolvedStyleAttrs

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

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

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

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

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

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';

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';

alignCenter: Command

alignJustify: Command

alignLeft: Command

alignRight: Command

clearFontFamily: Command

clearFontSize: Command

Clear all text formatting (remove all marks)

clearFormatting: Command

clearHighlight: Command

clearStyle: Command

clearTextColor: Command

decreaseListLevel: Command

doubleSpacing: Command

generateTOC: Command

increaseListLevel: Command

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

insertPageBreak: Command

oneAndHalfSpacing: Command

removeHyperlink: Command

removeList: Command

setLtr: Command

setRtl: Command

singleSpacing: Command

toggleBold: Command

toggleBulletList: Command

toggleItalic: Command

toggleNumberedList: Command

toggleStrike: Command

toggleSubscript: Command

toggleSuperscript: Command

toggleUnderline: Command