Class Editor

constructor

• new Editor(options: EditorOptions): Editor

  Parameters

  • options: EditorOptions

  Returns Editor

Readonlycommands

state

view

canRedo

• get canRedo(): boolean

  Returns boolean

canUndo

• get canUndo(): boolean

  Returns boolean

isDestroyed

• get isDestroyed(): boolean

  Returns boolean

isEditable

• get isEditable(): boolean

  Returns boolean

schema

• get schema(): Schema

  Returns Schema

addDispatchTransform

• addDispatchTransform(transform: DispatchTransform): () => void

  Register a transform that can rewrite transactions before they apply.

  Parameters

  • transform: DispatchTransform

  Returns () => void

chain

• chain(): Chain

  Start a chained command sequence: editor.chain().focus().setHeading(2).run().

  Returns Chain

clearHistory

• clearHistory(): void

  Forget every undo and redo group.

  Returns void

destroy

• destroy(): void

  Returns void

dispatch

• dispatch(tr: Transaction): void

  Parameters

  • tr: Transaction

  Returns void

exec

• exec(command: Command): boolean

  Run a command against the current state; dispatches when it applies.

  Parameters

  • command: Command

  Returns boolean

getCharacterCount

• getCharacterCount(): number

  Returns number

getHTML

• getHTML(): string

  Returns string

getJSON

• getJSON(): NodeJSON

  Returns NodeJSON

getParagraphCount

• getParagraphCount(): number

  Returns number

getSentenceCount

• getSentenceCount(): number

  Returns number

getSnapshot

• getSnapshot(): EditorSnapshot

  Toolbar-facing snapshot.

  Reference-stable while its contents are unchanged, not merely between transactions, so typing a character returns the very same object, and a toolbar subscribed through useSyncExternalStore, a signal or a store does not re-render on every keystroke. It changes identity when something a toolbar would actually draw differently changes: a mark, the block type, whether undo is available.

  Subscribers are still notified per transaction; what this decides is whether they have anything new to look at.

  Returns EditorSnapshot

getText

• getText(): string

  Returns string

getWordCount

• getWordCount(): number

  Returns number

historyEntries

• historyEntries(): {
      redo: readonly HistoryEntry[];
      undo: readonly HistoryEntry[];
  }

  The undo and redo stacks as a history panel lists them.

  Returns { redo: readonly HistoryEntry[]; undo: readonly HistoryEntry[] }

isActive

• isActive(markName: string): boolean

  Parameters

  • markName: string

  Returns boolean

on

• on(event: EditorEvent, listener: () => void): () => void

  Parameters

  • event: EditorEvent
  • listener: () => void

  Returns () => void

onTransaction

• onTransaction(listener: (event: TransactionEvent) => void): () => void

  Listen to applied transactions with their before/after states.

  Parameters

  • listener: (event: TransactionEvent) => void

  Returns () => void

redo

• redo(): boolean

  Returns boolean

setContent

• setContent(content: NodeJSON | EditorNode, options?: SetContentOptions): void

  Replace the whole document: loading a saved file, switching documents, restoring a draft. That is not an edit of the current text, so by default the change stays out of the undo history and the history is cleared; pass addToHistory: true to make the replacement undoable instead.

  Parameters

  • content: NodeJSON | EditorNode
  • options: SetContentOptions = {}

  Returns void

setEditable

• setEditable(editable: boolean): void

  Toggle read-only mode on the attached view.

  Parameters

  • editable: boolean

  Returns void

setSpellcheck

• setSpellcheck(enabled: boolean): void

  Turn the browser's spell checking of the editing surface on or off.

  Parameters

  • enabled: boolean

  Returns void

subscribe

• subscribe(listener: () => void): () => void

  Subscribe to state changes (the contract external stores expect).

  Parameters

  • listener: () => void

  Returns () => void

undo

• undo(): boolean

  Returns boolean