@remirror/pm

Functions

• chainableEditorState()
• chainCommands()
• convertCommand()
• nonChainable()

Interfaces

• CommandFunctionProps

  • dispatch
  • state
  • tr
  • view

Type Aliases

• CommandFunction
• Decoration
• DecorationSet
• DispatchFunction
• EditorSchema
• EditorState
• EditorView
• Fragment
• InputRule
• Mapping
• Mark
• MarkType
• NodeType
• NodeView
• NonChainableCommandFunction
• PluginKey
• ProsemirrorCommandFunction
• ProsemirrorNode
• ProsemirrorPlugin
• ResolvedPos
• Selection
• Slice
• Transaction

function chainableEditorState

chainableEditorState: (tr: Transaction$1, state: EditorState$1) => EditorState$1;

• Creates a fake state that can be used on ProseMirror library commands to make them chainable. The provided Transaction tr can be a shared one.

  Parameter tr

  the chainable transaction that should be amended.

  Parameter state

  the state of the editor (available via view.state).

  This should not be used other than for passing to prosemirror-* library commands.

function chainCommands

chainCommands: <Extra extends object = object>(
    ...commands: Array<CommandFunction<Extra>>
) => CommandFunction<Extra>;

• Similar to the chainCommands from the prosemirror-commands library. Allows multiple commands to be chained together and runs until one of them returns true.

function convertCommand

convertCommand: <Extra extends object = object>(
    commandFunction: ProsemirrorCommandFunction
) => CommandFunction<Extra>;

• Wraps the default [[ProsemirrorCommandFunction]] and makes it compatible with the default **remirror** [[CommandFunction]] call signature.

  It extracts all the public APIs of the state object and assigns the chainable transaction to the state.tr property to support chaining.

function nonChainable

nonChainable: <Extra extends object = object>(
    commandFunction: CommandFunction<Extra>
) => NonChainableCommandFunction<Extra>;

• Marks a command function as non chainable. It will throw an error when chaining is attempted.

  Remarks

  const command = nonChainable(({ state, dispatch }) => {...});

type CommandFunction

type CommandFunction<ExtraProps extends object = object> = (
    params: CommandFunctionProps & ExtraProps
) => boolean;

• A command method for running commands in your editor.

  Remarks

  This groups all the prosemirror command arguments into a single parameter.

  tldr; When dispatch=undefined make sure the command function is **idempotent**.

  One thing to be aware of is that when creating a command function the tr should only be updated when the dispatch method is available. This is because by convention calling the command function with dispatch=undefined is used to check if the function returns true, an indicator that it is enabled, or returns false to indicate it is not enabled.

  If the transaction has been updated outside of the dispatch=true condition then running the command again will result in multiple transaction updates and unpredictable behavior.

  See Also

  • ProsemirrorCommandFunction

type Decoration

type Decoration = Decoration$1;

type DecorationSet

type DecorationSet = DecorationSet$1;

type DispatchFunction

type DispatchFunction = (tr: Transaction) => void;

• Used to apply the Prosemirror transaction to the current EditorState.

type EditorSchema

type EditorSchema = Schema;

type EditorState

type EditorState = Readonly<EditorState$1>;

type EditorView

type EditorView = EditorView$1;

type Fragment

type Fragment = Fragment$1;

type InputRule

type InputRule = InputRule$1;

type Mapping

type Mapping = Mapping$1;

type Mark

type Mark = Mark$1;

type MarkType

type MarkType = MarkType$1;

type NodeType

type NodeType = NodeType$1;

type NodeView

type NodeView = NodeView$1;

type NonChainableCommandFunction

type NonChainableCommandFunction<Extra extends object = object> = Brand<
    CommandFunction<Extra>,
    'non-chainable'
>;

• Brands a command as non chainable so that it can be excluded from the inferred chainable commands.

type PluginKey

type PluginKey<PluginState = any> = PluginKey$1<PluginState>;

type ProsemirrorCommandFunction

type ProsemirrorCommandFunction = (
    state: EditorState,
    dispatch: DispatchFunction | undefined,
    view: EditorView | undefined
) => boolean;

• This is the type signature for commands within the prosemirror editor.

  Remarks

  A command function takes an editor state and optionally a dispatch function that it can use to dispatch a transaction. It should return a boolean that indicates whether it could perform any action.

  When no dispatch callback is passed, the command should do a 'dry run', determining whether it is applicable, but not actually performing any action.

type ProsemirrorNode

type ProsemirrorNode = Node;

type ProsemirrorPlugin

type ProsemirrorPlugin<PluginState = any> = Plugin<PluginState>;

type ResolvedPos

type ResolvedPos = ResolvedPos$1;

type Selection

type Selection = Selection$1;

type Slice

type Slice = Slice$1;

type Transaction

type Transaction = Transaction$1;