@eigenpal/docx-editor-core/prosemirror

addColumnLeftfunctionSource ↗

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

addColumnRightfunctionSource ↗

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

addRepeatingSectionItemTrfunctionSource ↗

Build a transaction that adds a repeating-section item by cloning the item at itemPos (its blockSdt before position) and inserting the copy after it. Throws [RepeatingSectionError](RepeatingSectionError) if itemPos isn't a repeating item.

declare function addRepeatingSectionItemTr(state: EditorState, itemPos: number): Transaction;

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;

createDocumentContextPluginfunctionSource ↗

Create the plugin holding [DocumentContext](DocumentContext) for the lifetime of the EditorState. Separate from the resolver plugin so the resolver's public documentStylesKey shape stays stable. The table-insert command reads the theme + default-table styleId from here to bake an inserted table the same way convertTable does on import.

declare function createDocumentContextPlugin(options?: Partial<DocumentContext>): Plugin;

createDocumentStylesPluginfunctionSource ↗

Create the plugin holding a StyleResolver for the document's styles for the lifetime of the EditorState. The resolver is fixed per document load; loading a new document recreates the state (and thus this plugin) with a fresh resolver. Accepts a pre-built resolver too, for callers that already have one.

declare function createDocumentStylesPlugin(styles: StyleDefinitions | StyleResolver | null | undefined): Plugin;

createEmptyDocfunctionSource ↗

Create an empty ProseMirror document

declare function createEmptyDoc(): Node;

createSelectionTrackerPluginfunctionSource ↗

Create selection tracker plugin

declare function createSelectionTrackerPlugin(onSelectionChange?: SelectionChangeCallback): Plugin;

createStyleResolverfunctionSource ↗

Create a style resolver from document's style definitions

declare function createStyleResolver(styleDefinitions: StyleDefinitions | undefined): StyleResolver;

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;

ensureParaIdsInStatefunctionSource ↗

Allocate any missing / duplicate paragraph ids on a freshly-created state, returning the corrected state. Apply this to the initial EditorState (before wiring the view) so the load doesn't dispatch a transaction — hosts see ids without a spurious onChange. No-op when every paragraph already has a unique id.

declare function ensureParaIdsInState(state: EditorState): EditorState;

extractSelectionContextfunctionSource ↗

Extract selection context from editor state

declare function extractSelectionContext(state: EditorState): SelectionContext;

extractSelectionStatefunctionSource ↗

Extract selection state from editor state. Used by PagedEditor integration in DocxEditor for toolbar state.

declare function extractSelectionState(state: EditorState): SelectionState | null;

findContentControlPosfunctionSource ↗

PM position of the first control matching filter, or null.

declare function findContentControlPos(doc: Node, filter: ContentControlFilter): number | null;

findContentControlsInPMfunctionSource ↗

All content controls in the PM doc (document order), optionally filtered.

declare function findContentControlsInPM(doc: Node, filter?: ContentControlFilter): PMContentControl[];

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;

findParagraphByParaIdfunctionSource ↗

ProseMirror position range for the paragraph (or any textblock) whose paraId attribute equals paraId. Returns the inclusive from and exclusive to positions, plus the node, so callers can both target the paragraph (e.g. addMark over its text range) and inspect it.

from is the position immediately before the textblock; to is from + node.nodeSize. The text content lives at [from + 1, to - 1].

Returns null if no textblock with that paraId exists.

declare function findParagraphByParaId(doc: Node, paraId: string): {
    node: Node;
    from: number;
    to: number;
} | null;

findStartPosForParaIdfunctionSource ↗

ProseMirror position immediately before the first textblock whose paraId attribute equals paraId (Word w14:paraId / OOXML paragraph id).

Match is strict string equality on node.attrs.paraId.

declare function findStartPosForParaId(doc: Node, paraId: string): number | null;

footnoteToProseDocfunctionSource ↗

Convert footnote/endnote content (array of Paragraph/Table blocks) to a ProseMirror document. Mirrors headerFooterToProseDoc so footnotes flow through the same body pipeline (toFlowBlocks → measureBlocks → renderFragment) and inherit its block support — paragraph + table + image + textBox + fields. Pre-PR, footnoteLayout's convertFootnoteToContent re-implemented run/paragraph conversion by hand and silently dropped tables, images, and fields nested inside a footnote.

declare function footnoteToProseDoc(content: BlockContent[], options?: ToProseDocOptions & {
    theme?: Theme | null;
}): Node;

fromProseDocfunctionSource ↗

Convert a ProseMirror document to our Document type

declare function fromProseDoc(pmDoc: Node, baseDocument?: Document): Document;

getDefaultTableStyleIdfunctionSource ↗

Read w:defaultTableStyle (styleId for new tables), or null.

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

getDocumentStyleResolverfunctionSource ↗

Read the document's StyleResolver, or null when the plugin isn't installed.

declare function getDocumentStyleResolver(state: EditorState): StyleResolver | null;

getDocumentThemefunctionSource ↗

Read the document theme, or null when the context plugin isn't installed.

declare function getDocumentTheme(state: EditorState): Theme | 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;

getSelectionContextfunctionSource ↗

Get current selection context from editor state

declare function getSelectionContext(state: EditorState): SelectionContext | null;

getStyleIdfunctionSource ↗

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

getTableContextfunctionSource ↗

declare function getTableContext(state: EditorState): TableContextInfo;

headerFooterToProseDocfunctionSource ↗

Convert HeaderFooter content (array of Paragraph/Table blocks) to a ProseMirror document. Used for editing headers/footers in their own ProseMirror editor and for the unified header/footer render pipeline. theme must be threaded for themeColor resolution in cell shading (<w:shd w:themeFill=...>) — without it, themed fills in HF tables fall back to the unresolved theme key.

declare function headerFooterToProseDoc(content: BlockContent[], options?: ToProseDocOptions & {
    theme?: Theme | null;
}): Node;

increaseIndentfunctionSource ↗

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

insertHyperlinkfunctionSource ↗

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

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;

removeContentControlTrfunctionSource ↗

Build a transaction that removes the first matching control. With keepContent the inner blocks are unwrapped in place; otherwise the whole region is deleted. Throws if nothing matches or the control is deletion-locked (unless force).

declare function removeContentControlTr(state: EditorState, filter: ContentControlFilter, options?: {
    force?: boolean;
    keepContent?: boolean;
}): Transaction;

removeRepeatingSectionItemTrfunctionSource ↗

Build a transaction that removes the repeating-section item at itemPos. Throws [RepeatingSectionError](RepeatingSectionError) if it isn't an item or is the only one in its section.

declare function removeRepeatingSectionItemTr(state: EditorState, itemPos: number): Transaction;

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;

setContentControlContentTrfunctionSource ↗

Build a transaction that replaces the first matching control's content with text (newlines become paragraphs; a plainText control stays one paragraph). Throws if nothing matches, the control is content-locked, a typed (dropdown/date/…) control, or data-bound (unless force). The control's identity/raw props are kept; a w:showingPlcHdr placeholder flag is cleared so the new content isn't rendered as placeholder.

declare function setContentControlContentTr(state: EditorState, filter: ContentControlFilter, text: string, options?: {
    force?: boolean;
}): Transaction;

setContentControlValueAtPosTrfunctionSource ↗

Build a transaction that applies a typed value to the content control at a specific PM node position. This is used by painted inline widgets because Word templates may repeat or omit w:tag values.

declare function setContentControlValueAtPosTr(state: EditorState, pos: number, value: ContentControlValue, options?: {
    force?: boolean;
}): Transaction;

setContentControlValueTrfunctionSource ↗

Build a transaction that applies a typed value (dropdown selection, checkbox toggle, or date) to the first control matching filter, updating both the visible content and the control's structured attrs (checked / raw w:sdtPr). Reuses the headless value-applier so the live editor and headless paths agree. Throws as the headless [setContentControlValue](setContentControlValue) does.

declare function setContentControlValueTr(state: EditorState, filter: ContentControlFilter, value: ContentControlValue, options?: {
    force?: boolean;
}): Transaction;

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;

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;

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;

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;

toProseDocfunctionSource ↗

Convert a Document to a ProseMirror document

declare function toProseDoc(document: Document, options?: ToProseDocOptions): Node;

updateDocumentContentfunctionSource ↗

Update a Document with content from a ProseMirror document Preserves all non-content parts of the original document

declare function updateDocumentContent(originalDocument: Document, pmDoc: Node): Document;

LayoutSelectionGateclassSource ↗

LayoutSelectionGate coordinates the timing between document edits and layout reflow so that selection overlays are only painted against current DOM geometry.

Workflow: 1. Document changes → setStateSeq(++seq) 2. Layout starts → onLayoutStart() 3. Layout completes → onLayoutComplete(seq) 4. Selection update requested → requestRender() 5. If safe → callback is called

declare class LayoutSelectionGate

StyleResolverclassSource ↗

StyleResolver provides efficient access to resolved style properties

declare class StyleResolver

DocumentContextinterfaceSource ↗

Extra document-level context parked alongside the StyleResolver.

interface DocumentContext

FontFamilyAttrsinterfaceSource ↗

Font family mark attributes

interface FontFamilyAttrs

FontSizeAttrsinterfaceSource ↗

Font size mark attributes

interface FontSizeAttrs

HyperlinkAttrsinterfaceSource ↗

Hyperlink mark attributes

interface HyperlinkAttrs

ImageAttrsinterfaceSource ↗

Image node attributes

interface ImageAttrs

ParagraphAttrsinterfaceSource ↗

Paragraph node attributes - maps to ParagraphFormatting

interface ParagraphAttrs

PMContentControlinterfaceSource ↗

A control discovered in the PM doc, with its PM position for scroll/edit.

interface PMContentControl

ResolvedParagraphStyleinterfaceSource ↗

Resolved style properties ready for rendering

interface ResolvedParagraphStyle

SelectionContextinterfaceSource ↗

Selection context for toolbar state

interface SelectionContext

SelectionStateinterfaceSource ↗

Selection state for toolbar integration

interface SelectionState

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

TextColorAttrsinterfaceSource ↗

Text color mark attributes

interface TextColorAttrs

ToProseDocOptionsinterfaceSource ↗

Options for document conversion

interface ToProseDocOptions

UnderlineAttrsinterfaceSource ↗

Underline mark attributes

interface UnderlineAttrs

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

SelectionChangeCallbacktypeSource ↗

Callback type for selection changes

type SelectionChangeCallback = (context: SelectionContext) => void;

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

documentContextKeyconstSource ↗

documentContextKey: PluginKey<DocumentContext>

documentStylesKeyconstSource ↗

documentStyles plugin — makes the document's StyleResolver reachable from ProseMirror commands.

Styles otherwise flow one way (Document → PM) at load time: toProseDoc bakes resolved formatting into nodes and discards the resolver. Some commands need the live style table though — the Enter handler looks up a paragraph style's w:next to switch to body text after a heading. This plugin parks the resolver in plugin state so those commands can read it via getDocumentStyleResolver(state).

A sibling documentContext plugin (below) carries the extra document-level context the table-insert command needs — the theme and the settings w:defaultTableStyle — without changing this resolver plugin's shape.

The host (React HiddenProseMirror / HiddenHeaderFooterPMs, Vue useDocxEditor) passes the same styles it hands to toProseDoc and adds these plugins when creating the EditorState. When absent, style-aware commands fall back to their style-agnostic behavior.

documentStylesKey: PluginKey<StyleResolver | null>

generateTOCconstSource ↗

generateTOC: Command

increaseListLevelconstSource ↗

increaseListLevel: Command

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

removeHyperlinkconstSource ↗

removeHyperlink: Command

removeListconstSource ↗

removeList: Command

schemaconstSource ↗

schema: prosemirror_model.Schema<any, any>

selectionTrackerKeyconstSource ↗

Plugin key for accessing selection tracker state

selectionTrackerKey: PluginKey<SelectionContext>

setLtrconstSource ↗

setLtr: Command

setRtlconstSource ↗

setRtl: 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