Interface ExtendableConfig<Options, Storage, Config, PMType>

interface ExtendableConfig<
    Options = any,
    Storage = any,
    Config extends

            | ExtensionConfig<Options, Storage>
            | NodeConfig<Options, Storage>
            | MarkConfig<Options, Storage>
            | ExtendableConfig<Options, Storage> = ExtendableConfig<
        Options,
        Storage,
        any,
        any,
    >,
    PMType = any,
> {
    addCommands?: (
        this: {
            editor: Editor;
            name: string;
            options: Options;
            parent: Partial<
                {
                    [P in string
                    | number
                    | symbol]: Required<Config>[P] extends (...args: any) => any
                        ? (...args: Parameters<any[any]>) => ReturnType<any[any]>
                        : Config[P]
                },
            >["addCommands"];
            storage: Storage;
            type: PMType;
        },
    ) => Partial<RawCommands>;
    addExtensions?: (
        this: {
            name: string;
            options: Options;
            parent: Partial<
                {
                    [P in string
                    | number
                    | symbol]: Required<Config>[P] extends (...args: any) => any
                        ? (...args: Parameters<any[any]>) => ReturnType<any[any]>
                        : Config[P]
                },
            >["addExtensions"];
            storage: Storage;
        },
    ) => Extensions;
    addGlobalAttributes?: (
        this: {
            extensions: (Mark<any, any> | Node<any, any>)[];
            name: string;
            options: Options;
            parent: Partial<
                {
                    [P in string
                    | number
                    | symbol]: Required<Config>[P] extends (...args: any) => any
                        ? (...args: Parameters<any[any]>) => ReturnType<any[any]>
                        : Config[P]
                },
            >["addGlobalAttributes"];
            storage: Storage;
        },
    ) => GlobalAttributes;
    addInputRules?: (
        this: {
            editor: Editor;
            name: string;
            options: Options;
            parent: Partial<
                {
                    [P in string
                    | number
                    | symbol]: Required<Config>[P] extends (...args: any) => any
                        ? (...args: Parameters<any[any]>) => ReturnType<any[any]>
                        : Config[P]
                },
            >["addInputRules"];
            storage: Storage;
            type: PMType;
        },
    ) => InputRule[];
    addKeyboardShortcuts?: (
        this: {
            editor: Editor;
            name: string;
            options: Options;
            parent: Partial<
                {
                    [P in string
                    | number
                    | symbol]: Required<Config>[P] extends (...args: any) => any
                        ? (...args: Parameters<any[any]>) => ReturnType<any[any]>
                        : Config[P]
                },
            >["addKeyboardShortcuts"];
            storage: Storage;
            type: PMType;
        },
    ) => { [key: string]: KeyboardShortcutCommand };
    addOptions?: (
        this: {
            name: string;
            parent: Partial<
                {
                    [P in string
                    | number
                    | symbol]: Required<Config>[P] extends (...args: any) => any
                        ? (...args: Parameters<any[any]>) => ReturnType<any[any]>
                        : Config[P]
                },
            >["addOptions"];
        },
    ) => Options;
    addPasteRules?: (
        this: {
            editor: Editor;
            name: string;
            options: Options;
            parent: Partial<
                {
                    [P in string
                    | number
                    | symbol]: Required<Config>[P] extends (...args: any) => any
                        ? (...args: Parameters<any[any]>) => ReturnType<any[any]>
                        : Config[P]
                },
            >["addPasteRules"];
            storage: Storage;
            type: PMType;
        },
    ) => PasteRule[];
    addProseMirrorPlugins?: (
        this: {
            editor: Editor;
            name: string;
            options: Options;
            parent: Partial<
                {
                    [P in string
                    | number
                    | symbol]: Required<Config>[P] extends (...args: any) => any
                        ? (...args: Parameters<any[any]>) => ReturnType<any[any]>
                        : Config[P]
                },
            >["addProseMirrorPlugins"];
            storage: Storage;
            type: PMType;
        },
    ) => Plugin<any>[];
    addStorage?: (
        this: {
            name: string;
            options: Options;
            parent: Partial<
                {
                    [P in string
                    | number
                    | symbol]: Required<Config>[P] extends (...args: any) => any
                        ? (...args: Parameters<any[any]>) => ReturnType<any[any]>
                        : Config[P]
                },
            >["addStorage"];
        },
    ) => Storage;
    dispatchTransaction?: | null
    | (
        (
            this: {
                editor: Editor;
                name: string;
                options: Options;
                parent: Partial<
                    {
                        [P in string
                        | number
                        | symbol]: Required<Config>[P] extends (...args: any) => any
                            ? (...args: Parameters<any[any]>) => ReturnType<any[any]>
                            : Config[P]
                    },
                >["dispatchTransaction"];
                storage: Storage;
                type: PMType;
            },
            props: DispatchTransactionProps,
        ) => void
    );
    extendMarkSchema?:
        | null
        | (
            (
                this: {
                    name: string;
                    options: Options;
                    parent: Partial<
                        {
                            [P in string
                            | number
                            | symbol]: Required<Config>[P] extends (...args: any) => any
                                ? (...args: Parameters<any[any]>) => ReturnType<any[any]>
                                : Config[P]
                        },
                    >["extendMarkSchema"];
                    storage: Storage;
                },
                extension: Mark,
            ) => Record<string, any>
        );
    extendNodeSchema?:
        | null
        | (
            (
                this: {
                    name: string;
                    options: Options;
                    parent: Partial<
                        {
                            [P in string
                            | number
                            | symbol]: Required<Config>[P] extends (...args: any) => any
                                ? (...args: Parameters<any[any]>) => ReturnType<any[any]>
                                : Config[P]
                        },
                    >["extendNodeSchema"];
                    storage: Storage;
                },
                extension: Node,
            ) => Record<string, any>
        );
    markdownOptions?: { indentsContent?: boolean };
    markdownTokenizer?: MarkdownTokenizer;
    markdownTokenName?: string;
    name: string;
    onBeforeCreate?:
        | null
        | (
            (
                this: {
                    editor: Editor;
                    name: string;
                    options: Options;
                    parent: Partial<
                        {
                            [P in string
                            | number
                            | symbol]: Required<Config>[P] extends (...args: any) => any
                                ? (...args: Parameters<any[any]>) => ReturnType<any[any]>
                                : Config[P]
                        },
                    >["onBeforeCreate"];
                    storage: Storage;
                    type: PMType;
                },
                event: { editor: Editor },
            ) => void
        );
    onBlur?:
        | null
        | (
            (
                this: {
                    editor: Editor;
                    name: string;
                    options: Options;
                    parent: Partial<
                        {
                            [P in string
                            | number
                            | symbol]: Required<Config>[P] extends (...args: any) => any
                                ? (...args: Parameters<any[any]>) => ReturnType<any[any]>
                                : Config[P]
                        },
                    >["onBlur"];
                    storage: Storage;
                    type: PMType;
                },
                event: { editor: Editor; event: FocusEvent; transaction: Transaction },
            ) => void
        );
    onCreate?:
        | null
        | (
            (
                this: {
                    editor: Editor;
                    name: string;
                    options: Options;
                    parent: Partial<
                        {
                            [P in string
                            | number
                            | symbol]: Required<Config>[P] extends (...args: any) => any
                                ? (...args: Parameters<any[any]>) => ReturnType<any[any]>
                                : Config[P]
                        },
                    >["onCreate"];
                    storage: Storage;
                    type: PMType;
                },
                event: { editor: Editor },
            ) => void
        );
    onDestroy?:
        | null
        | (
            (
                this: {
                    editor: Editor;
                    name: string;
                    options: Options;
                    parent: Partial<
                        {
                            [P in string
                            | number
                            | symbol]: Required<Config>[P] extends (...args: any) => any
                                ? (...args: Parameters<any[any]>) => ReturnType<any[any]>
                                : Config[P]
                        },
                    >["onDestroy"];
                    storage: Storage;
                    type: PMType;
                },
                event: void,
            ) => void
        );
    onFocus?:
        | null
        | (
            (
                this: {
                    editor: Editor;
                    name: string;
                    options: Options;
                    parent: Partial<
                        {
                            [P in string
                            | number
                            | symbol]: Required<Config>[P] extends (...args: any) => any
                                ? (...args: Parameters<any[any]>) => ReturnType<any[any]>
                                : Config[P]
                        },
                    >["onFocus"];
                    storage: Storage;
                    type: PMType;
                },
                event: { editor: Editor; event: FocusEvent; transaction: Transaction },
            ) => void
        );
    onSelectionUpdate?:
        | null
        | (
            (
                this: {
                    editor: Editor;
                    name: string;
                    options: Options;
                    parent: Partial<
                        {
                            [P in string
                            | number
                            | symbol]: Required<Config>[P] extends (...args: any) => any
                                ? (...args: Parameters<any[any]>) => ReturnType<any[any]>
                                : Config[P]
                        },
                    >["onSelectionUpdate"];
                    storage: Storage;
                    type: PMType;
                },
                event: { editor: Editor; transaction: Transaction },
            ) => void
        );
    onTransaction?:
        | null
        | (
            (
                this: {
                    editor: Editor;
                    name: string;
                    options: Options;
                    parent: Partial<
                        {
                            [P in string
                            | number
                            | symbol]: Required<Config>[P] extends (...args: any) => any
                                ? (...args: Parameters<any[any]>) => ReturnType<any[any]>
                                : Config[P]
                        },
                    >["onTransaction"];
                    storage: Storage;
                    type: PMType;
                },
                event: {
                    appendedTransactions: Transaction[];
                    editor: Editor;
                    transaction: Transaction;
                },
            ) => void
        );
    onUpdate?: | null
    | (
        (
            this: {
                editor: Editor;
                name: string;
                options: Options;
                parent: Partial<
                    {
                        [P in string
                        | number
                        | symbol]: Required<Config>[P] extends (...args: any) => any
                            ? (...args: Parameters<any[any]>) => ReturnType<any[any]>
                            : Config[P]
                    },
                >["onUpdate"];
                storage: Storage;
                type: PMType;
            },
            event: {
                appendedTransactions: Transaction[];
                editor: Editor;
                transaction: Transaction;
            },
        ) => void
    );
    parseMarkdown?: (
        token: MarkdownToken,
        helpers: MarkdownParseHelpers,
    ) => MarkdownParseResult;
    priority?: number;
    renderMarkdown?: (
        node: JSONContent,
        helpers: MarkdownRendererHelpers,
        ctx: RenderContext,
    ) => string;
}

Type Parameters

Options = any
Storage = any
Config extends
    | ExtensionConfig<Options, Storage>
    | NodeConfig<Options, Storage>
    | MarkConfig<Options, Storage>
    | ExtendableConfig<Options, Storage> = ExtendableConfig<Options, Storage, any, any>
PMType = any

Hierarchy (View Summary)

ExtendableConfig

Properties

`Optional`addCommands

addCommands?: (
    this: {
        editor: Editor;
        name: string;
        options: Options;
        parent: Partial<
            {
                [P in string
                | number
                | symbol]: Required<Config>[P] extends (...args: any) => any
                    ? (...args: Parameters<any[any]>) => ReturnType<any[any]>
                    : Config[P]
            },
        >["addCommands"];
        storage: Storage;
        type: PMType;
    },
) => Partial<RawCommands>

This function adds commands to the editor

See

https://tiptap.dev/docs/editor/guide/custom-extensions#commands

Example

addCommands() {
  return {
    myCommand: () => ({ chain }) => chain().setMark('type', 'foo').run(),
  }
}

`Optional`addExtensions

addExtensions?: (
    this: {
        name: string;
        options: Options;
        parent: Partial<
            {
                [P in string
                | number
                | symbol]: Required<Config>[P] extends (...args: any) => any
                    ? (...args: Parameters<any[any]>) => ReturnType<any[any]>
                    : Config[P]
            },
        >["addExtensions"];
        storage: Storage;
    },
) => Extensions

This function adds additional extensions to the editor. This is useful for building extension kits.

Example

addExtensions() {
  return [
    BulletList,
    OrderedList,
    ListItem
  ]
}

`Optional`addGlobalAttributes

addGlobalAttributes?: (
    this: {
        extensions: (Mark<any, any> | Node<any, any>)[];
        name: string;
        options: Options;
        parent: Partial<
            {
                [P in string
                | number
                | symbol]: Required<Config>[P] extends (...args: any) => any
                    ? (...args: Parameters<any[any]>) => ReturnType<any[any]>
                    : Config[P]
            },
        >["addGlobalAttributes"];
        storage: Storage;
    },
) => GlobalAttributes

This function adds globalAttributes to specific nodes.

See

https://tiptap.dev/docs/editor/guide/custom-extensions#global-attributes

Example

addGlobalAttributes() {
  return [
    {
        // Extend the following extensions
      types: [
        'heading',
        'paragraph',
      ],
      // … with those attributes
      attributes: {
        textAlign: {
          default: 'left',
          renderHTML: attributes => ({
            style: `text-align: ${attributes.textAlign}`,
          }),
          parseHTML: element => element.style.textAlign || 'left',
        },
      },
    },
  ]
}

`Optional`addInputRules

addInputRules?: (
    this: {
        editor: Editor;
        name: string;
        options: Options;
        parent: Partial<
            {
                [P in string
                | number
                | symbol]: Required<Config>[P] extends (...args: any) => any
                    ? (...args: Parameters<any[any]>) => ReturnType<any[any]>
                    : Config[P]
            },
        >["addInputRules"];
        storage: Storage;
        type: PMType;
    },
) => InputRule[]

This function adds input rules to the editor.

See

https://tiptap.dev/docs/editor/guide/custom-extensions#input-rules

Example

addInputRules() {
  return [
    markInputRule({
      find: inputRegex,
      type: this.type,
    }),
  ]
},

`Optional`addKeyboardShortcuts

addKeyboardShortcuts?: (
    this: {
        editor: Editor;
        name: string;
        options: Options;
        parent: Partial<
            {
                [P in string
                | number
                | symbol]: Required<Config>[P] extends (...args: any) => any
                    ? (...args: Parameters<any[any]>) => ReturnType<any[any]>
                    : Config[P]
            },
        >["addKeyboardShortcuts"];
        storage: Storage;
        type: PMType;
    },
) => { [key: string]: KeyboardShortcutCommand }

This function registers keyboard shortcuts.

See

https://tiptap.dev/docs/editor/guide/custom-extensions#keyboard-shortcuts

Example

addKeyboardShortcuts() {
  return {
    'Mod-l': () => this.editor.commands.toggleBulletList(),
  }
},

`Optional`addOptions

addOptions?: (
    this: {
        name: string;
        parent: Partial<
            {
                [P in string
                | number
                | symbol]: Required<Config>[P] extends (...args: any) => any
                    ? (...args: Parameters<any[any]>) => ReturnType<any[any]>
                    : Config[P]
            },
        >["addOptions"];
    },
) => Options

This method will add options to this extension

See

https://tiptap.dev/docs/editor/guide/custom-extensions#settings

Example

addOptions() {
 return {
   myOption: 'foo',
   myOtherOption: 10,
}

`Optional`addPasteRules

addPasteRules?: (
    this: {
        editor: Editor;
        name: string;
        options: Options;
        parent: Partial<
            {
                [P in string
                | number
                | symbol]: Required<Config>[P] extends (...args: any) => any
                    ? (...args: Parameters<any[any]>) => ReturnType<any[any]>
                    : Config[P]
            },
        >["addPasteRules"];
        storage: Storage;
        type: PMType;
    },
) => PasteRule[]

This function adds paste rules to the editor.

See

https://tiptap.dev/docs/editor/guide/custom-extensions#paste-rules

Example

addPasteRules() {
  return [
    markPasteRule({
      find: pasteRegex,
      type: this.type,
    }),
  ]
},

`Optional`addProseMirrorPlugins

addProseMirrorPlugins?: (
    this: {
        editor: Editor;
        name: string;
        options: Options;
        parent: Partial<
            {
                [P in string
                | number
                | symbol]: Required<Config>[P] extends (...args: any) => any
                    ? (...args: Parameters<any[any]>) => ReturnType<any[any]>
                    : Config[P]
            },
        >["addProseMirrorPlugins"];
        storage: Storage;
        type: PMType;
    },
) => Plugin<any>[]

This function adds Prosemirror plugins to the editor

See

https://tiptap.dev/docs/editor/guide/custom-extensions#prosemirror-plugins

Example

addProseMirrorPlugins() {
  return [
    customPlugin(),
  ]
}

`Optional`addStorage

addStorage?: (
    this: {
        name: string;
        options: Options;
        parent: Partial<
            {
                [P in string
                | number
                | symbol]: Required<Config>[P] extends (...args: any) => any
                    ? (...args: Parameters<any[any]>) => ReturnType<any[any]>
                    : Config[P]
            },
        >["addStorage"];
    },
) => Storage

The default storage this extension can save data to.

See

https://tiptap.dev/docs/editor/guide/custom-extensions#storage

Example

defaultStorage: {
  prefetchedUsers: [],
  loading: false,
}

`Optional`dispatchTransaction

dispatchTransaction?:
    | null
    | (
        (
            this: {
                editor: Editor;
                name: string;
                options: Options;
                parent: Partial<
                    {
                        [P in string
                        | number
                        | symbol]: Required<Config>[P] extends (...args: any) => any
                            ? (...args: Parameters<any[any]>) => ReturnType<any[any]>
                            : Config[P]
                    },
                >["dispatchTransaction"];
                storage: Storage;
                type: PMType;
            },
            props: DispatchTransactionProps,
        ) => void
    )

This hook allows you to intercept and modify transactions before they are dispatched.

Example

dispatchTransaction({ transaction, next }) {
  console.log('Dispatching transaction:', transaction)
  next(transaction)
}

Param: props

The dispatch transaction props

`Optional`extendMarkSchema

extendMarkSchema?:
    | null
    | (
        (
            this: {
                name: string;
                options: Options;
                parent: Partial<
                    {
                        [P in string
                        | number
                        | symbol]: Required<Config>[P] extends (...args: any) => any
                            ? (...args: Parameters<any[any]>) => ReturnType<any[any]>
                            : Config[P]
                    },
                >["extendMarkSchema"];
                storage: Storage;
            },
            extension: Mark,
        ) => Record<string, any>
    )

This function extends the schema of the mark.

Example

extendMarkSchema() {
  return {
    group: 'inline',
    selectable: false,
  }
}

`Optional`extendNodeSchema

extendNodeSchema?:
    | null
    | (
        (
            this: {
                name: string;
                options: Options;
                parent: Partial<
                    {
                        [P in string
                        | number
                        | symbol]: Required<Config>[P] extends (...args: any) => any
                            ? (...args: Parameters<any[any]>) => ReturnType<any[any]>
                            : Config[P]
                    },
                >["extendNodeSchema"];
                storage: Storage;
            },
            extension: Node,
        ) => Record<string, any>
    )

This function extends the schema of the node.

Example

extendNodeSchema() {
  return {
    group: 'inline',
    selectable: false,
  }
}

`Optional`markdownOptions

markdownOptions?: { indentsContent?: boolean }

Optional markdown options for indentation

Type Declaration

OptionalindentsContent?: boolean
Defines if this markdown element should indent it's child elements

`Optional`markdownTokenizer

markdownTokenizer?: MarkdownTokenizer

The markdown tokenizer responsible for turning a markdown string into tokens

Custom tokenizers are only needed when you want to parse non-standard markdown token.

`Optional`markdownTokenName

markdownTokenName?: string

The markdown token name

This is the name of the token that this extension uses to parse and render markdown and comes from the Marked Lexer.

See

https://github.com/markedjs/marked/blob/master/src/Tokens.ts

name

name: string

The extension name - this must be unique. It will be used to identify the extension.

Example

'myExtension'

`Optional`onBeforeCreate

onBeforeCreate?:
    | null
    | (
        (
            this: {
                editor: Editor;
                name: string;
                options: Options;
                parent: Partial<
                    {
                        [P in string
                        | number
                        | symbol]: Required<Config>[P] extends (...args: any) => any
                            ? (...args: Parameters<any[any]>) => ReturnType<any[any]>
                            : Config[P]
                    },
                >["onBeforeCreate"];
                storage: Storage;
                type: PMType;
            },
            event: { editor: Editor },
        ) => void
    )

The editor is not ready yet.

`Optional`onBlur

onBlur?:
    | null
    | (
        (
            this: {
                editor: Editor;
                name: string;
                options: Options;
                parent: Partial<
                    {
                        [P in string
                        | number
                        | symbol]: Required<Config>[P] extends (...args: any) => any
                            ? (...args: Parameters<any[any]>) => ReturnType<any[any]>
                            : Config[P]
                    },
                >["onBlur"];
                storage: Storage;
                type: PMType;
            },
            event: { editor: Editor; event: FocusEvent; transaction: Transaction },
        ) => void
    )

The editor isn’t focused anymore.

`Optional`onCreate

onCreate?:
    | null
    | (
        (
            this: {
                editor: Editor;
                name: string;
                options: Options;
                parent: Partial<
                    {
                        [P in string
                        | number
                        | symbol]: Required<Config>[P] extends (...args: any) => any
                            ? (...args: Parameters<any[any]>) => ReturnType<any[any]>
                            : Config[P]
                    },
                >["onCreate"];
                storage: Storage;
                type: PMType;
            },
            event: { editor: Editor },
        ) => void
    )

The editor is ready.

`Optional`onDestroy

onDestroy?:
    | null
    | (
        (
            this: {
                editor: Editor;
                name: string;
                options: Options;
                parent: Partial<
                    {
                        [P in string
                        | number
                        | symbol]: Required<Config>[P] extends (...args: any) => any
                            ? (...args: Parameters<any[any]>) => ReturnType<any[any]>
                            : Config[P]
                    },
                >["onDestroy"];
                storage: Storage;
                type: PMType;
            },
            event: void,
        ) => void
    )

The editor is destroyed.

`Optional`onFocus

onFocus?:
    | null
    | (
        (
            this: {
                editor: Editor;
                name: string;
                options: Options;
                parent: Partial<
                    {
                        [P in string
                        | number
                        | symbol]: Required<Config>[P] extends (...args: any) => any
                            ? (...args: Parameters<any[any]>) => ReturnType<any[any]>
                            : Config[P]
                    },
                >["onFocus"];
                storage: Storage;
                type: PMType;
            },
            event: { editor: Editor; event: FocusEvent; transaction: Transaction },
        ) => void
    )

The editor is focused.

`Optional`onSelectionUpdate

onSelectionUpdate?:
    | null
    | (
        (
            this: {
                editor: Editor;
                name: string;
                options: Options;
                parent: Partial<
                    {
                        [P in string
                        | number
                        | symbol]: Required<Config>[P] extends (...args: any) => any
                            ? (...args: Parameters<any[any]>) => ReturnType<any[any]>
                            : Config[P]
                    },
                >["onSelectionUpdate"];
                storage: Storage;
                type: PMType;
            },
            event: { editor: Editor; transaction: Transaction },
        ) => void
    )

The selection has changed.

`Optional`onTransaction

onTransaction?:
    | null
    | (
        (
            this: {
                editor: Editor;
                name: string;
                options: Options;
                parent: Partial<
                    {
                        [P in string
                        | number
                        | symbol]: Required<Config>[P] extends (...args: any) => any
                            ? (...args: Parameters<any[any]>) => ReturnType<any[any]>
                            : Config[P]
                    },
                >["onTransaction"];
                storage: Storage;
                type: PMType;
            },
            event: {
                appendedTransactions: Transaction[];
                editor: Editor;
                transaction: Transaction;
            },
        ) => void
    )

The editor state has changed.

`Optional`onUpdate

onUpdate?:
    | null
    | (
        (
            this: {
                editor: Editor;
                name: string;
                options: Options;
                parent: Partial<
                    {
                        [P in string
                        | number
                        | symbol]: Required<Config>[P] extends (...args: any) => any
                            ? (...args: Parameters<any[any]>) => ReturnType<any[any]>
                            : Config[P]
                    },
                >["onUpdate"];
                storage: Storage;
                type: PMType;
            },
            event: {
                appendedTransactions: Transaction[];
                editor: Editor;
                transaction: Transaction;
            },
        ) => void
    )

The content has changed.

`Optional`parseMarkdown

parseMarkdown?: (
token: MarkdownToken,
helpers: MarkdownParseHelpers,
) => MarkdownParseResult

The parse function used by the markdown parser to convert markdown tokens to ProseMirror nodes.

`Optional`priority

priority?: number

The priority of your extension. The higher, the earlier it will be called and will take precedence over other extensions with a lower priority.

Default

Example

`Optional`renderMarkdown

renderMarkdown?: (
    node: JSONContent,
    helpers: MarkdownRendererHelpers,
    ctx: RenderContext,
) => string

The serializer function used by the markdown serializer to convert ProseMirror nodes to markdown tokens.

Interface ExtendableConfig<Options, Storage, Config, PMType>

Type Parameters

Hierarchy (View Summary)

Index

Properties

Properties

OptionaladdCommands

See

Example

OptionaladdExtensions

Example

OptionaladdGlobalAttributes

See

Example

OptionaladdInputRules

See

Example

OptionaladdKeyboardShortcuts

See

Example

OptionaladdOptions

See

Example

OptionaladdPasteRules

See

Example

OptionaladdProseMirrorPlugins

See

Example

OptionaladdStorage

See

Example

OptionaldispatchTransaction

Param: props

OptionalextendMarkSchema

Example

OptionalextendNodeSchema

Example

OptionalmarkdownOptions

Type Declaration

OptionalindentsContent?: boolean

OptionalmarkdownTokenizer

OptionalmarkdownTokenName

See

name

Example

OptionalonBeforeCreate

OptionalonBlur

OptionalonCreate

OptionalonDestroy

OptionalonFocus

OptionalonSelectionUpdate

OptionalonTransaction

OptionalonUpdate

OptionalparseMarkdown

Optionalpriority

Default

Example

OptionalrenderMarkdown

Settings

On This Page

`Optional`addCommands

`Optional`addExtensions

`Optional`addGlobalAttributes

`Optional`addInputRules

`Optional`addKeyboardShortcuts

`Optional`addOptions

`Optional`addPasteRules

`Optional`addProseMirrorPlugins

`Optional`addStorage

`Optional`dispatchTransaction

`Optional`extendMarkSchema

`Optional`extendNodeSchema

`Optional`markdownOptions

`Optional`indentsContent?: boolean

`Optional`markdownTokenizer

`Optional`markdownTokenName

`Optional`onBeforeCreate

`Optional`onBlur

`Optional`onCreate

`Optional`onDestroy

`Optional`onFocus

`Optional`onSelectionUpdate

`Optional`onTransaction

`Optional`onUpdate

`Optional`parseMarkdown

`Optional`priority

`Optional`renderMarkdown