@udecode/plate - v13.5.0

Index

Enumerations

ListStyleType

Interfaces

Type aliases

Variables

Functions

Type aliases

Alignment

Alignment: "left" | "center" | "right" | "justify"

AncestorOf

AncestorOf<N>: TEditor extends N ? TEditor | TElement : TElement extends N ? TElement : N extends TEditor ? N | N["children"][number] | ElementOf<N["children"][number]> : N extends TElement ? N | ElementOf<N> : never

A utility type to get all the ancestor node types from a root node type.

Type parameters

N: TNode

AnyFunction

AnyFunction: (...args: any) => any

Any function.

Type declaration

- (...args: any): any
- Parameters
  - Rest ...args: any
  Returns any

As

As: ElementType

The as prop.

Type parameters

P = any

Props

AsProps

AsProps<T>: { as?: T; asChild?: boolean }

Props with the as prop.

example: type ButtonAsProps = AsProps<"button">;

Type parameters

T: As = As

The as prop

Type declaration

Optional as?: T
Optional asChild?: boolean

AtomStoreApi

AtomStoreApi<T, N>: { name: N } & {[ key in keyof Record<NameStore<N>, {}>]: { atom: AtomRecord<T>; extend: <ET, EN>(extendedState: ET, options?: Omit<CreateAtomStoreOptions<{}, EN extends string ? EN : N>, "initialStore">) => AtomStoreApi<T & ET, EN extends string ? EN : N> } } & {[ key in keyof Record<UseNameStore<N>, {}>]: () => { get: GetRecord<T>; set: SetRecord<T>; use: UseRecord<T> } }

Type parameters

T
N: string = ""

AutoformatRule

AutoformatRule<V, E>: AutoformatBlockRule<V, E> | AutoformatMarkRule<V, E> | AutoformatTextRule<V, E>

Type parameters

V: Value = Value
E: PlateEditor<V> = PlateEditor<V>

CaretPosition

CaretPosition: { height: number; left: number; top: number }

Type declaration

height: number
left: number
top: number

ChildOf

ChildOf<N, I>: N extends TEditor ? N["children"][I] : N extends TElement ? N["children"][I] : never

A utility type to get the child node types from a root node type.

Type parameters

N: TNode
I: number = number

Children

Children<T>: ReactNode | RenderProp<HTMLAttributes<T> & RefAttributes<T>>

The children prop that supports a function.

Type parameters

T = any

Element type.

ColorInputStyles

ColorInputStyles: { input?: CSSProp }

Type declaration

Optional input?: CSSProp

Input.

ColorType

ColorType: { isBrightColor: boolean; name: string; value: string }

Type declaration

isBrightColor: boolean
name: string
value: string

ComboboxOnSelectItem

ComboboxOnSelectItem<TData>: <V>(editor: PlateEditor<V>, item: TComboboxItem<TData>) => any

Type parameters

TData

Type declaration

- <V>(editor: PlateEditor<V>, item: TComboboxItem<TData>): any
- Type parameters
 - V: Value
 Parameters
 - editor: PlateEditor<V>
 - item: TComboboxItem<TData>
 Returns any

ComboboxState

ComboboxState<TData>: { activeId: string | null; byId: Record<string, ComboboxStoreById>; filteredItems: TComboboxItem<TData>[]; highlightedIndex: number; items: TComboboxItem<TData>[]; popperContainer?: Document | HTMLElement; popperOptions?: any; targetRange: Range | null; text: string | null }

Type parameters

TData = NoData

Type declaration

activeId: string | null

Active id (combobox id which is opened).
byId: Record<string, ComboboxStoreById>

Object whose keys are combobox ids and values are config stores (e.g. one for tag, one for mention,...).
filteredItems: TComboboxItem<TData>[]

Filtered items
highlightedIndex: number

Highlighted index.
items: TComboboxItem<TData>[]

Unfiltered items.
Optional popperContainer?: Document | HTMLElement

Parent element of the popper element (the one that has the scroll).

default

document
Optional popperOptions?: any

Overrides usePopper options.
targetRange: Range | null

Range from the trigger to the cursor.
text: string | null

Text after the trigger.

ComboboxStateById

ComboboxStateById<TData>: { controlled?: boolean; filter?: (search: string) => (item: TComboboxItem<TData>) => boolean; id: string; maxSuggestions?: number; onSelectItem: ComboboxOnSelectItem<TData> | null; searchPattern?: string; sort?: (search: string) => (a: TComboboxItem<TData>, b: TComboboxItem<TData>) => number; trigger: string }

Type parameters

TData = NoData

Type declaration

Optional controlled?: boolean

Is opening/closing the combobox controlled by the client.
Optional filter?: (search: string) => (item: TComboboxItem<TData>) => boolean

Items filter function by text.

default

(value) => value.text.toLowerCase().startsWith(search.toLowerCase())
- - (search: string): (item: TComboboxItem<TData>) => boolean
 - Parameters
 - search: string
 Returns (item: TComboboxItem<TData>) => boolean
 - - (item: TComboboxItem<TData>): boolean
 - Parameters
 
 item: TComboboxItem<TData>
 
 Returns boolean
id: string

Combobox id.
Optional maxSuggestions?: number

Max number of items.

default

items.length
onSelectItem: ComboboxOnSelectItem<TData> | null

Called when an item is selected.
Optional searchPattern?: string

Regular expression for search, for example to allow whitespace
Optional sort?: (search: string) => (a: TComboboxItem<TData>, b: TComboboxItem<TData>) => number

Sort filtered items before applying maxSuggestions.
- - (search: string): (a: TComboboxItem<TData>, b: TComboboxItem<TData>) => number
 - Parameters
 - search: string
 Returns (a: TComboboxItem<TData>, b: TComboboxItem<TData>) => number
 - - (a: TComboboxItem<TData>, b: TComboboxItem<TData>): number
 - Parameters
 
 a: TComboboxItem<TData>
 
 b: TComboboxItem<TData>
 
 Returns number
trigger: string

Trigger that activates the combobox.

ComboboxStoreById

ComboboxStoreById<TData>: StoreApi<string, ComboboxStateById<TData>, StateActions<ComboboxStateById<TData>>>

Type parameters

TData = NoData

Component

Component<O>: { displayName?: string }

A component that supports the as prop and the children prop as a function.

see: https://github.com/ariakit/ariakit/blob/9977b070180e27be40068e0cc464e78dda68d594/packages/ariakit-utils/src/types.ts#L117
example: type ButtonComponent = Component<AsProps<"button">>;

Type parameters

O: AsProps

AsProps

Type declaration

- <T>(props: Omit<O, "as"> & Omit<HTMLProps<AsProps<T>>, keyof O> & AsProps<T>): null | Element
- (props: Props<O>): null | Element
- Type parameters
 - T: As<any> = NonNullable<O["as"]>
 Parameters
 - props: Omit<O, "as"> & Omit<HTMLProps<AsProps<T>>, keyof O> & AsProps<T>
 Returns null | Element
- Parameters
 - props: Props<O>
 Returns null | Element
Optional displayName?: string

CursorData

CursorData: { selectionStyle?: CSSProperties; style?: CSSProperties }

Type declaration

Optional selectionStyle?: CSSProperties
Optional style?: CSSProperties

CursorState

CursorState<TCursorData>: { data?: TCursorData; key?: any; selection: Range | null }

Type parameters

TCursorData: UnknownObject = UnknownObject

Type declaration

Optional data?: TCursorData
Optional key?: any
selection: Range | null

DOMHandler

DOMHandler<P, V, E, EV>: (editor: E, plugin: WithPlatePlugin<P, V, E>) => DOMHandlerReturnType<EV>

Type parameters

P = PluginOptions
V: Value = Value
E: PlateEditor<V> = PlateEditor<V>
EV = {}

Type declaration

- (editor: E, plugin: WithPlatePlugin<P, V, E>): DOMHandlerReturnType<EV>
- Parameters
 - editor: E
 - plugin: WithPlatePlugin<P, V, E>
 Returns DOMHandlerReturnType<EV>

DOMHandlerReturnType

DOMHandlerReturnType<EV>: (event: EV) => HandlerReturnType

Type parameters

EV = {}

Type declaration

- (event: EV): HandlerReturnType
- Parameters
  - event: EV
  Returns HandlerReturnType

Data

Data: unknown

Decorate

Decorate<P, V, E>: (editor: PlateEditor<V>, plugin: WithPlatePlugin<P, V, E>) => DecorateEntry<V>

Property used by Plate to decorate editor ranges. If the function returns undefined then no ranges are modified. If the function returns an array the returned ranges are merged with the ranges called by other plugins.

Type parameters

Type declaration

- (editor: PlateEditor<V>, plugin: WithPlatePlugin<P, V, E>): DecorateEntry<V>
- Parameters
 - editor: PlateEditor<V>
 - plugin: WithPlatePlugin<P, V, E>
 Returns DecorateEntry<V>

DecorateEntry

DecorateEntry<V>: (entry: ENodeEntry<V>) => Range[] | undefined

Type parameters

V: Value = Value

Type declaration

- (entry: ENodeEntry<V>): Range[] | undefined
- Parameters
 - entry: ENodeEntry<V>
 Returns Range[] | undefined

DeepPartial

DeepPartial<T>: T extends infer U[] ? DeepPartial[] : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial> : T extends {[ key in keyof T]: T[key] } ? {[ K in keyof T]: DeepPartial<T[K]> } : T

Type parameters

DeepPartialAny

DeepPartialAny<T>: {[ P in keyof T]: T[P] extends AnyObject ? DeepPartialAny<T[P]> : any }

Makes each property optional and turns each leaf property into any, allowing for type overrides by narrowing any.

Type parameters

DefaultPlatePluginKey

DescendantOf

DescendantOf<N>: N extends TEditor ? ElementOf<N> | TextOf<N> : N extends TElement ? ElementOf<N["children"][number]> | TextOf<N> : never

A utility type to get all the descendant node types from a root node type.

Type parameters

N: TNode

DeserializeHtml

DeserializeHtml: { attributeNames?: string[]; getNode?: (element: HTMLElement, node: AnyObject) => AnyObject | undefined | void; isElement?: boolean; isLeaf?: boolean; query?: (element: HTMLElement) => boolean; rules?: { validAttribute?: string | {}; validClassName?: string; validNodeName?: string | string[]; validStyle?: Partial<Record<keyof CSSStyleDeclaration, string | string[] | undefined>> }[]; withoutChildren?: boolean }

Type declaration

Optional attributeNames?: string[]

List of HTML attribute names to store their values in node.attributes.
Optional getNode?: (element: HTMLElement, node: AnyObject) => AnyObject | undefined | void

Deserialize html element to slate node.
- - (element: HTMLElement, node: AnyObject): AnyObject | undefined | void
  - Parameters
    - element: HTMLElement
    - node: AnyObject
    Returns AnyObject | undefined | void
Optional isElement?: boolean

Deserialize an element. Use this instead of plugin.isElement if you don't want the plugin to renderElement.

default

plugin.isElement
Optional isLeaf?: boolean

Deserialize a leaf. Use this instead of plugin.isLeaf if you don't want the plugin to renderLeaf.

default

plugin.isLeaf
Optional query?: (element: HTMLElement) => boolean
- - (element: HTMLElement): boolean
  - Parameters
    - element: HTMLElement
    Returns boolean
Optional rules?: { validAttribute?: string | {}; validClassName?: string; validNodeName?: string | string[]; validStyle?: Partial<Record<keyof CSSStyleDeclaration, string | string[] | undefined>> }[]
Optional withoutChildren?: boolean

Whether or not to include deserialized children on this node

DeserializeHtmlChildren

DeserializeHtmlChildren<N>: ChildNode | N | string | null

Type parameters

N: TDescendant

DeserializeHtmlNodeReturnType

DeserializeHtmlNodeReturnType<N>: string | null | N[] | N | DeserializeHtmlChildren<N>[]

Type parameters

N: TDescendant

DropDirection

DropDirection: "top" | "bottom" | undefined

DropLineDirection

DropLineDirection: "" | "top" | "bottom"

EAncestor

EAncestor<V>: AncestorOf<TEditor<V>>

Ancestor of an editor.

Type parameters

V: Value

EAncestorEntry

EAncestorEntry<V>: TAncestorEntry<TEditor<V>>

Ancestor entry from an editor.

Type parameters

V: Value

EDescendant

EDescendant<V>: DescendantOf<TEditor<V>>

Descendant of an editor.

Type parameters

V: Value

EDescendantEntry

EDescendantEntry<V>: TNodeEntry<EDescendant<V>>

Descendant entry of a value.

Type parameters

V: Value

EElement

EElement<V>: ElementOf<TEditor<V>>

Element of an editor.

Type parameters

V: Value

EElementEntry

EElementEntry<V>: TNodeEntry<EElement<V>>

Element entry of a value.

Type parameters

V: Value

EElementOrText

EElementOrText<V>: EElement<V> | EText<V>

Element or text of an editor. Differs from EDescendant.

Type parameters

V: Value

EMarks

EMarks<V>: MarksOf<TEditor<V>>

Type parameters

V: Value

ENode

ENode<V>: NodeOf<TEditor<V>>

Node of an editor.

Type parameters

V: Value

ENodeEntry

ENodeEntry<V>: TNodeEntry<ENode<V>>

Node entry from an editor.

Type parameters

V: Value

ENodeMatch

ENodeMatch<N>: Predicate<N>

Type parameters

N: TNode

EText

EText<V>: TextOf<TEditor<V>>

Text node of an editor.

Type parameters

V: Value

ETextEntry

ETextEntry<V>: TNodeEntry<EText<V>>

Text node entry of a value.

Type parameters

V: Value

EditorId

EditorId: string | null | undefined

A unique id used to store the editor state by id. Required if rendering multiple Plate. Optional otherwise.

default: 'main'

ElementOf

ElementOf<N>: TEditor extends N ? TElement : TElement extends N ? TElement : N extends TEditor ? Extract<N["children"][number], TElement> | ElementOf<N["children"][number]> : N extends TElement ? N | Extract<N["children"][number], TElement> | ElementOf<N["children"][number]> : never

A utility type to get all the element nodes type from a root node.

Type parameters

N: TNode

EmbedUrlData

EmbedUrlData: { id?: string; provider?: "twitter"; url?: string }

Type declaration

Optional id?: string
Optional provider?: "twitter"
Optional url?: string

EventEditorState

EventEditorState: { blur: string | null; focus: string | null; last: string | null }

Type declaration

blur: string | null

Last editor id that has been blurred.
focus: string | null

Editor id that is currently being focused.
last: string | null

Last editor id.

FindNodeOptions

FindNodeOptions<V>: GetNodeEntriesOptions<V>

Type parameters

V: Value = Value

FunctionProperties

FunctionProperties<T>: Pick<T, FunctionPropertyNames<T>>

Get the properties from an interface which are functions

Type parameters

FunctionPropertyNames

FunctionPropertyNames<T>: {[ K in keyof T]: T[K] extends Function ? K : never }[keyof T]

Get the property names from an interface which are functions

Type parameters

GetAboveNodeOptions

GetAboveNodeOptions<V>: Modify<NonNullable<EditorAboveOptions<TAncestor>>, ENodeMatchOptions<V>>

Type parameters

V: Value = Value

GetLevelsOptions

GetLevelsOptions<V>: Modify<NonNullable<EditorLevelsOptions<TNode>>, { match?: TNodeMatch<ENode<V>> }>

Type parameters

V: Value = Value

GetMatchPointsReturnType

GetMatchPointsReturnType: undefined | { afterStartMatchPoint: Point | undefined; beforeEndMatchPoint: Point; beforeStartMatchPoint: Point | undefined }

GetNextNodeOptions

GetNextNodeOptions<V>: Modify<NonNullable<EditorNextOptions<TDescendant>>, { match?: TNodeMatch<ENode<V>> }>

Type parameters

V: Value = Value

GetNodeEntriesOptions

GetNodeEntriesOptions<V>: Modify<NonNullable<EditorNodesOptions<TNode>>, ENodeMatchOptions<V>> & UnhangRangeOptions

Type parameters

V: Value = Value

GetPreviousNodeOptions

GetPreviousNodeOptions<V>: Modify<NonNullable<EditorPreviousOptions<TNode>>, { match?: TNodeMatch<ENode<V>> }>

Type parameters

V: Value = Value

GetTableGridAboveOptions

GetTableGridAboveOptions<V>: GetAboveNodeOptions<V> & Pick<GetTableGridByRangeOptions, "format">

Type parameters

V: Value = Value

HTMLProps

HTMLProps<O>: { children?: Children; wrapElement?: WrapElement } & Omit<ComponentPropsWithRef<NonNullable<O["as"]>>, keyof O | "children">

Props that automatically includes HTML props based on the as prop.

example: type ButtonHTMLProps = HTMLProps<AsProps<"button">>;

Type parameters

O: AsProps

AsProps

HTMLPropsAs

HTMLPropsAs<T>: AsProps<T> & HTMLProps<AsProps<T>>

Type parameters

T: As = any

HandlerReturnType

HandlerReturnType: boolean | void

If true, the next handlers will be skipped.

HotkeyPlugin

HotkeyPlugin: { hotkey?: string | string[] }

Type declaration

Optional hotkey?: string | string[]

Hotkeys to listen to trigger a plugin action.

ImageProps

ImageProps: PlateRenderElementProps<Value, TImageElement> & HTMLPropsAs<"div">

IndentPlugin

IndentPlugin: { indentMax?: number; offset?: number; unit?: string }

Type declaration

Optional indentMax?: number

Maximum number of indentation.
Optional offset?: number

Indentation offset used in (offset * element.indent) + unit.

default

40
Optional unit?: string

Indentation unit used in (offset * element.indent) + unit.

default

'px'

InjectComponentReturnType

InjectComponentReturnType<V>: RenderFunction<PlateRenderElementProps<V>> | undefined

Type parameters

V: Value = Value

InjectedPlugin

InjectedPlugin<P, V, E>: Partial<PlatePlugin<P, V, E>>

Type parameters

InsertNodesOptions

InsertNodesOptions<V>: Modify<NonNullable<Parameters<typeof Transforms.insertNodes>[2]>, NodeMatchOption<V>>

Type parameters

V: Value = Value

JotaiProviderProps

JotaiProviderProps: ComponentProps<typeof Provider>

KeyboardEventHandler

KeyboardEventHandler: (event: KeyboardEvent) => HandlerReturnType

Type declaration

- (event: KeyboardEvent): HandlerReturnType
- Parameters
  - event: KeyboardEvent
  Returns HandlerReturnType

KeyboardHandler

KeyboardHandler<P, V, E>: DOMHandler<P, V, E, KeyboardEvent>

Type parameters

KeyboardHandlerReturnType

KeyboardHandlerReturnType: DOMHandlerReturnType<KeyboardEvent>

LiftNodesOptions

LiftNodesOptions<V>: Modify<NonNullable<Parameters<typeof Transforms.liftNodes>[1]>, NodeMatchOption<V>>

Type parameters

V: Value = Value

MarkKeysOf

MarkKeysOf<N>: {} extends MarksOf<N> ? unknown : keyof MarksOf<N>

Type parameters

N: TNode

MarksOf

MarksOf<N>: Simplify<UnionToIntersection<TNodeProps<TextOf<N>>>>

A utility type to get all the mark types from a root node type.

Type parameters

N: TNode

MediaEmbedElementProps

MediaEmbedElementProps<V>: StyledElementProps<V, TMediaEmbedElement, MediaEmbedElementStyles> & { disableInput?: boolean; disableUnknownProviders?: boolean; getIframeProps?: (options: { element: TMediaEmbedElement; embedUrlData: EmbedUrlData }) => HTMLAttributes<HTMLIFrameElement>; inputProps?: Partial<MediaEmbedUrlInputProps>; tweetProps?: Partial<TweetProps> }

Type parameters

V: Value

MergeNodesOptions

MergeNodesOptions<V>: Modify<NonNullable<Parameters<typeof Transforms.mergeNodes>[1]>, NodeMatchOption<V>> & { mergeNode?: (editor: TEditor<V>, options: { at: Path; to: Path }) => void; removeEmptyAncestor?: (editor: TEditor<V>, options: { at: Path }) => void }

Type parameters

V: Value = Value

Modify

Modify<T, R>: Omit<T, keyof R> & R

Modify type properties. https://stackoverflow.com/a/55032655/6689201

Type parameters

ModifyDeep

ModifyDeep<A, B>: {[ K in keyof A]: B[K] extends never ? A[K] : B[K] extends AnyObject ? ModifyDeep<A[K], B[K]> : B[K] } & A extends AnyObject ? Omit<B, keyof A> : A

Modify deep type properties. https://stackoverflow.com/a/65561287/6689201

Type parameters

A: AnyObject
B: DeepPartialAny<A>

MoveListItemsOptions

MoveListItemsOptions: { at?: GetNodeEntriesOptions["at"]; increase?: boolean }

Type declaration

Optional at?: GetNodeEntriesOptions["at"]
Optional increase?: boolean

MoveNodesOptions

MoveNodesOptions<V>: Modify<NonNullable<Parameters<typeof Transforms.moveNodes>[1]>, NodeMatchOption<V>>

Type parameters

V: Value = Value

NoData

NoData: undefined

NoInfer

NoInfer<T>: [T][T extends any ? 0 : never]

Type parameters

NodeOf

NodeOf<N>: N | ElementOf<N> | TextOf<N>

A utility type to get all the node types from a root node type.

Type parameters

N: TNode

Nullable

Nullable<T>: {[ P in keyof T]: T[P] | null }

Type parameters

OnChange

OnChange<P, V, E>: (editor: E, plugin: WithPlatePlugin<P, V, E>) => (value: V) => HandlerReturnType

Function called whenever a change occurs in the editor. Return false to prevent calling the next plugin handler.

see: {@link SlatePropsOnChange}

Type parameters

Type declaration

- (editor: E, plugin: WithPlatePlugin<P, V, E>): (value: V) => HandlerReturnType
- Parameters
 - editor: E
 - plugin: WithPlatePlugin<P, V, E>
 Returns (value: V) => HandlerReturnType
 - - (value: V): HandlerReturnType
 - Parameters
 - value: V
 Returns HandlerReturnType

OnError

OnError: (err: any) => void

Type declaration

- (err: any): void
- Parameters
  - err: any
  Returns void

Options

Options<T>: Partial<T> & AnyObject & { key?: string; keys?: string[] }

Type parameters

OverrideByKey

OverrideByKey<V, E>: Record<PluginKey, Partial<PlatePlugin<{}, V, E>>>

Type parameters

V: Value = Value
E: PlateEditor<V> = PlateEditor<V>

PartialPick

PartialPick<T, K>: {[ P in K]: T[P] }

Type parameters

T
K: keyof T

PlateChangeKey

PlateChangeKey: "keyEditor" | "keyPlugins" | "keySelection"

PlateEditor

PlateEditor<V>: TEditor<V> & THistoryEditor<V> & TReactEditor<V> & { id: string; key: any; plugins: WithPlatePlugin<{}, V>[]; pluginsByKey: Record<PluginKey, WithPlatePlugin<{}, V>> }

Type parameters

V: Value = Value

PlatePlugin

PlatePlugin<P, V, E>: Required<PlatePluginKey> & { editor?: Nullable<{ insertData?: PlatePluginInsertData<V> }>; handlers?: Nullable<DOMHandlers<P, V, E> & { onChange?: OnChange<P, V, E> }>; inject?: Nullable<{ aboveComponent?: InjectComponent<V>; belowComponent?: InjectComponent<V>; pluginsByKey?: Record<PluginKey, Partial<PlatePlugin<PluginOptions, V, E>>> }>; isElement?: boolean; isInline?: boolean; isLeaf?: boolean; isVoid?: boolean; options?: P; type?: string } & InjectProps<V> & Nullable<{ component?: PlatePluginComponent; decorate?: Decorate<P, V, E>; deserializeHtml?: Nullable<DeserializeHtml>; overrideByKey?: Record<PluginKey, Partial<PlatePlugin<PluginOptions, V, E>>>; plugins?: PlatePlugin<PluginOptions, V, E>[]; props?: PlatePluginProps<V>; serializeHtml?: SerializeHtml<V>; then?: (editor: E, plugin: WithPlatePlugin<P, V, E>) => Partial<PlatePlugin<P, V, E>> | void; useHooks?: (editor: E, plugin: WithPlatePlugin<P, V, E>) => void; withOverrides?: WithOverride<P, V, E> }>

The PlatePlugin interface is a base interface for all plugins.

Type parameters

PlatePluginComponent

PlatePluginComponent<T>: RenderFunction<T>

The plate plugin component.

Type parameters

T = any

PlatePluginInsertData

PlatePluginInsertData<V>: { format?: string; getFragment?: (options: PlatePluginInsertDataOptions) => EElementOrText<V>[] | undefined; preInsert?: (fragment: EElementOrText<V>[], options: PlatePluginInsertDataOptions) => HandlerReturnType; query?: (options: PlatePluginInsertDataOptions) => boolean; transformData?: (data: string, options: { dataTransfer: DataTransfer }) => string; transformFragment?: (fragment: EElementOrText<V>[], options: PlatePluginInsertDataOptions) => EElementOrText<V>[] }

Type parameters

V: Value = Value

Type declaration

Optional format?: string

Format to get data. Example data types are text/plain and text/uri-list.
Optional getFragment?: (options: PlatePluginInsertDataOptions) => EElementOrText<V>[] | undefined

Deserialize data to fragment
- - (options: PlatePluginInsertDataOptions): EElementOrText<V>[] | undefined
 - Parameters
 - options: PlatePluginInsertDataOptions
 Returns EElementOrText<V>[] | undefined
Optional preInsert?: (fragment: EElementOrText<V>[], options: PlatePluginInsertDataOptions) => HandlerReturnType

Function called on editor.insertData just before editor.insertFragment. Default: if the block above the selection is empty and the first fragment node type is not inline, set the selected node type to the first fragment node type.

returns

if true, the next handlers will be skipped.
- - (fragment: EElementOrText<V>[], options: PlatePluginInsertDataOptions): HandlerReturnType
 - Parameters
 - fragment: EElementOrText<V>[]
 - options: PlatePluginInsertDataOptions
 Returns HandlerReturnType
Optional query?: (options: PlatePluginInsertDataOptions) => boolean

Query to skip this plugin.
- - (options: PlatePluginInsertDataOptions): boolean
  - Parameters
    - options: PlatePluginInsertDataOptions
    Returns boolean
Optional transformData?: (data: string, options: { dataTransfer: DataTransfer }) => string

Transform the inserted data.
- - (data: string, options: { dataTransfer: DataTransfer }): string
  - Parameters
    - data: string
    - options: { dataTransfer: DataTransfer }
      - dataTransfer: DataTransfer
    Returns string
Optional transformFragment?: (fragment: EElementOrText<V>[], options: PlatePluginInsertDataOptions) => EElementOrText<V>[]

Transform the fragment to insert.
- - (fragment: EElementOrText<V>[], options: PlatePluginInsertDataOptions): EElementOrText<V>[]
 - Parameters
 - fragment: EElementOrText<V>[]
 - options: PlatePluginInsertDataOptions
 Returns EElementOrText<V>[]

PlatePluginInsertDataOptions

PlatePluginInsertDataOptions: { data: string; dataTransfer: DataTransfer }

Type declaration

data: string
dataTransfer: DataTransfer

PlatePluginProps

PlatePluginProps<V>: AnyObject | ((props: PlateRenderElementProps<V> & PlateRenderLeafProps<V>) => AnyObject | undefined)

Props object or function returning props object.

Type parameters

V: Value = Value

PlateRenderElementProps

PlateRenderElementProps<V, N>: PlateRenderNodeProps<V> & TRenderElementProps<V, N>

Element props passed by Plate

Type parameters

V: Value = Value
N: TElement = EElement<V>

PlateRenderLeafProps

PlateRenderLeafProps<V, N>: PlateRenderNodeProps<V> & TRenderLeafProps<V, N>

Leaf props passed by Plate

Type parameters

V: Value = Value
N: TText = EText<V>

PlateStoreApi

PlateStoreApi<V, E>: Helper<V, E>["Return"]

Type parameters

V: Value = Value
E: PlateEditor<V> = PlateEditor<V>

PlateStoreState

PlateStoreState<V, E>: { id: string; plugins: PlatePlugin<PluginOptions, V, E>[] } & Required<Nullable<Pick<TEditableProps<V>, "decorate" | "renderElement" | "renderLeaf">>> & Nullable<{ editableProps: TEditableProps<V>; editor: E; enabled: boolean; isRendered: boolean; keyEditor: number; keyPlugins: number; keySelection: number; onChange: (value: V) => void; value: V }>

Type parameters

V: Value = Value
E: PlateEditor<V> = PlateEditor<V>

PlatesStoreState

PlatesStoreState<V>: Record<string, PlateStoreApi<V>>

Type parameters

V: Value = Value

PluginKey

PluginKey: string

Unique key to store the plugins by key.

PluginOptions

PluginOptions: AnyObject

PortalBodyProps

PortalBodyProps: { children: ReactNode; element?: Element }

Type declaration

children: ReactNode
Optional element?: Element

Predicate

Predicate<T>: PredicateObj | PredicateFn<T>

Type parameters

T: TNode

PredicateFn

PredicateFn<T>: (obj: T, path: TPath) => boolean

Type parameters

T: TNode

Type declaration

- (obj: T, path: TPath): boolean
- Parameters
  - obj: T
  - path: TPath
  Returns boolean

PredicateObj

PredicateObj: Record<string, any | any[]>

Props

Props<O>: O & HTMLProps<O>

AsProps & HTMLProps

example: type ButtonProps = Props<AsProps<"button">>;

Type parameters

O: AsProps

AsProps

RemoveNodesOptions

RemoveNodesOptions<V>: Modify<NonNullable<Parameters<typeof Transforms.removeNodes>[1]>, NodeMatchOption<V>>

Type parameters

V: Value = Value

RenderElement

RenderElement: <V>(props: PlateRenderElementProps<V>) => JSX.Element | undefined

Function used to render an element. If the function returns undefined then the next RenderElement function is called. If the function renders a JSX element then that JSX element is rendered.

Type declaration

- <V>(props: PlateRenderElementProps<V>): JSX.Element | undefined
- Type parameters
 - V: Value
 Parameters
 - props: PlateRenderElementProps<V>
 Returns JSX.Element | undefined

RenderElementFn

RenderElementFn<V>: (props: TRenderElementProps<V>) => JSX.Element

Type parameters

V: Value = Value

Type declaration

- (props: TRenderElementProps<V>): JSX.Element
- Parameters
 - props: TRenderElementProps<V>
 Returns JSX.Element

RenderLeaf

RenderLeaf: <V>(props: PlateRenderLeafProps<V>) => JSX.Element

Function used to render the children of a leaf. If the function returns undefined then the next RenderLeaf function is called and the current children are not modified. The children passed to the function may be the result of a previous plugin. To wrap the previous plugin simply return the passed children. You do not need to add the attributes to your return value. The attributes are added by default. RenderLeaf always returns a JSX element (even if unmodified) to support multiple marks on a node.

Type declaration

- <V>(props: PlateRenderLeafProps<V>): JSX.Element
- Type parameters
 - V: Value = Value
 Parameters
 - props: PlateRenderLeafProps<V>
 Returns JSX.Element

RenderLeafFn

RenderLeafFn<V>: (props: TRenderLeafProps<V>) => JSX.Element

Type parameters

V: Value = Value

Type declaration

- (props: TRenderLeafProps<V>): JSX.Element
- Parameters
 - props: TRenderLeafProps<V>
 Returns JSX.Element

RenderProp

RenderProp: (props: P) => ReactNode

Render prop type.

example: const children: RenderProp = (props) => <div {...props} />;

Type parameters

P = AnyObject

Props

Type declaration

- (props: P): ReactNode
- Parameters
  - props: P
  Returns ReactNode

RtfImagesMap

RtfImagesMap: Record<RtfImage["spid"], RtfImage>

Scope

Scope: symbol | string | number

SelectOnBackspacePlugin

SelectOnBackspacePlugin: { query?: QueryNodeOptions }

Type declaration

Optional query?: QueryNodeOptions

SelectionRect

SelectionRect: { height: number; left: number; top: number; width: number }

Type declaration

height: number
left: number
top: number
width: number

SerializeHtml

SerializeHtml<V>: RenderFunction<PlateRenderElementProps<V> & PlateRenderLeafProps<V>>

Type parameters

V: Value = Value

SetNodesOptions

SetNodesOptions<V>: Modify<NonNullable<Parameters<typeof Transforms.setNodes>[2]>, NodeMatchOption<V>>

Type parameters

V: Value = Value

Simplify

Simplify<T>: T extends any[] | Date ? T : {[ K in keyof T]: T[K] } & {}

Simplify a complex type expression into a single object.

Type parameters

SplitNodesOptions

SplitNodesOptions<V>: Modify<NonNullable<Parameters<typeof Transforms.splitNodes>[1]>, NodeMatchOption<V>>

Type parameters

V: Value = Value

StyledElementProps

StyledElementProps<V, N, TStyles>: PlateRenderElementProps<V, N> & StyledProps<TStyles> & HTMLAttributes<HTMLElement>

Type parameters

V: Value = Value
N: TElement = EElement<V>
TStyles = {}

StyledLeafProps

StyledLeafProps<V, N, TStyles>: PlateRenderLeafProps<V, N> & StyledProps<TStyles>

Type parameters

V: Value = Value
N: TText = EText<V>
TStyles = {}

TAncestor

TAncestor: TEditor | TElement

The Ancestor union type represents nodes that are ancestors in the tree. It is returned as a convenience in certain cases to narrow a value further than the more generic Node union.

TAncestorEntry

TAncestorEntry<N>: TNodeEntry<AncestorOf<N>>

Ancestor entry from a node.

Type parameters

N: TNode = TNode

TComboboxItem

TComboboxItem<TData>: TData extends NoData ? TComboboxItemBase : TComboboxItemWithData<TData>

Type parameters

TData = NoData

TDescendant

TDescendant: TElement | TText

The Descendant union type represents nodes that are descendants in the tree. It is returned as a convenience in certain cases to narrow a value further than the more generic Node union.

TDescendantEntry

TDescendantEntry<N>: TNodeEntry<DescendantOf<N>>

Descendant entry from a node.

Type parameters

N: TNode = TNode

TEditableProps

TEditableProps<V>: Omit<EditableProps, "decorate" | "renderElement" | "renderLeaf"> & { decorate?: (entry: ENodeEntry<V>) => Range[]; renderElement?: RenderElementFn<V>; renderLeaf?: RenderLeafFn<V> }

Type parameters

V: Value = Value

TEditor

TEditor<V>: Modify<Editor, { apply: <N>(operation: TOperation<N>) => void; children: V; getFragment: <N>() => N[]; insertFragment: <N>(fragment: N[]) => void; insertNode: <N>(node: N | N[]) => void; isInline: <N>(element: N) => boolean; isVoid: <N>(element: N) => boolean; marks: Record<string, any> | null; normalizeNode: <N>(entry: TNodeEntry<N>) => void; operations: TOperation[] }> & UnknownObject

Type parameters

V: Value = Value

TElementEntry

TElementEntry<N>: TNodeEntry<ElementOf<N>>

Element entry from a node.

Type parameters

N: TNode = TNode

THistoryEditor

THistoryEditor<V>: TEditor<V> & Pick<HistoryEditor, "history" | "undo" | "redo">

Type parameters

V: Value = Value

TInsertNodeOperation

TInsertNodeOperation<N>: { node: N; path: TPath; type: "insert_node" }

Type parameters

N: TDescendant = TDescendant

Type declaration

[key: string]: unknown
node: N
path: TPath
type: "insert_node"

TInsertTextOperation

TInsertTextOperation: { offset: number; path: TPath; text: string; type: "insert_text" }

Type declaration

[key: string]: unknown
offset: number
path: TPath
text: string
type: "insert_text"

TLocation

TLocation: Location

TMergeNodeOperation

TMergeNodeOperation: { path: TPath; position: number; properties: object; type: "merge_node" }

Type declaration

[key: string]: unknown
path: TPath
position: number
properties: object
type: "merge_node"

TMoveNodeOperation

TMoveNodeOperation: { newPath: TPath; path: TPath; type: "move_node" }

Type declaration

[key: string]: unknown
newPath: TPath
path: TPath
type: "move_node"

TNode

TNode: TEditor | TElement | TText

TNodeChildEntry

TNodeChildEntry<N>: TNodeEntry<ChildOf<N>>

Child node entry from a node.

Type parameters

N: TNode = TNode

TNodeEntry

TNodeEntry<N>: [N, Path]

TNodeEntry objects are returned when iterating over the nodes in a Slate document tree. They consist of the node and its Path relative to the root node in the document.

Type parameters

N: TNode = TNode

TNodeMatch

TNodeMatch<N>: ((node: N, path: Path) => node is N) | ((node: N, path: Path) => boolean)

A helper type for narrowing matched nodes with a predicate.

Type parameters

N: TNode = TNode

TNodeOperation

Type parameters

N: TDescendant = TDescendant

TNodeProps

TNodeProps<N>: N extends TEditor ? Omit<N, "children"> : N extends TElement ? Omit<N, "children"> : Omit<N, "text">

Convenience type for returning the props of a node.

Type parameters

N: TNode

TOperation

TOperation<N>: TNodeOperation<N> | TSelectionOperation | TTextOperation

Operation objects define the low-level instructions that Slate editors use to apply changes to their internal state. Representing all changes as operations is what allows Slate editors to easily implement history, collaboration, and other features.

Type parameters

N: TDescendant = TDescendant

TPath

TPath: Path

TRange

TRange: Range

TReactEditor

TReactEditor<V>: TEditor<V> & Pick<ReactEditor, "insertData" | "insertFragmentData" | "setFragmentData" | "insertTextData" | "hasRange">

Type parameters

V: Value = Value

TRemoveNodeOperation

TRemoveNodeOperation<N>: { node: N; path: TPath; type: "remove_node" }

Type parameters

N: TDescendant = TDescendant

Type declaration

[key: string]: unknown
node: N
path: TPath
type: "remove_node"

TRemoveTextOperation

TRemoveTextOperation: { offset: number; path: TPath; text: string; type: "remove_text" }

Type declaration

[key: string]: unknown
offset: number
path: TPath
text: string
type: "remove_text"

TRenderElementProps

TRenderElementProps<V, N>: Omit<RenderElementProps, "element"> & { element: N }

Type parameters

V: Value = Value
N: TElement = EElement<V>

TRenderLeafProps

TRenderLeafProps<V, N>: Modify<RenderLeafProps, { leaf: N; text: N }>

Type parameters

V: Value = Value
N: TText = EText<V>

TSelection

TSelection: Selection

TSelectionOperation

TSelectionOperation: TSetSelectionOperation

TSetNodeOperation

TSetNodeOperation: { newProperties: object; path: TPath; properties: object; type: "set_node" }

Type declaration

[key: string]: unknown
newProperties: object
path: TPath
properties: object
type: "set_node"

TSetSelectionOperation

TSetSelectionOperation: { newProperties: TRange; properties: null; type: "set_selection" } | { newProperties: Partial<TRange>; properties: Partial<TRange>; type: "set_selection" } | { newProperties: null; properties: TRange; type: "set_selection" }

TSpan

TSpan: Span

TSplitNodeOperation

TSplitNodeOperation: { path: TPath; position: number; properties: object; type: "split_node" }

Type declaration

[key: string]: unknown
path: TPath
position: number
properties: object
type: "split_node"

TTextEntry

TTextEntry<N>: TNodeEntry<TextOf<N>>

Text node entry from a node.

Type parameters

N: TNode = TNode

TTextOperation

TTextOperation: TInsertTextOperation | TRemoveTextOperation

TextOf

TextOf<N>: TEditor extends N ? TText : TElement extends N ? TText : N extends TEditor ? TextOf<N["children"][number]> : N extends TElement ? Extract<N["children"][number], TText> | TextOf<N["children"][number]> : N extends TText ? N : never

A utility type to get all the text node types from a root node type.

Type parameters

N: TNode

TodoListElementProps

TodoListElementProps<V>: StyledElementProps<V, TTodoListItemElement, TodoListElementStyles>

Type parameters

V: Value

TweetProps

TweetProps: Readonly<{ loadingComponent?: JSX.Element | string; onError?: (error: string) => void; onLoad?: () => void; tweetId: string }>

UnhangRangeOptions

UnhangRangeOptions: EditorUnhangRangeOptions & { unhang?: boolean }

UnindentListItemsOptions

UnindentListItemsOptions: Omit<MoveListItemsOptions, "increase">

UnionToIntersection

UnionToIntersection: (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never

Turn a union type into an intersection.

Type parameters

UnsetNodesOptions

UnsetNodesOptions<V>: Modify<NonNullable<Parameters<typeof Transforms.unsetNodes>[2]>, NodeMatchOption<V>>

Type parameters

V: Value = Value

UnwrapNodesOptions

UnwrapNodesOptions<V>: Modify<NonNullable<Parameters<typeof Transforms.unwrapNodes>[1]>, ENodeMatchOptions<V>>

Type parameters

V: Value = Value

UsePlateStoreEffects

Type parameters

V: Value = Value
E: PlateEditor<V> = PlateEditor<V>

UsePopperOptions

UsePopperOptions: Omit<Partial<PopperJS.Options>, "modifiers"> & { createPopper?: typeof PopperJS.createPopper; modifiers?: ReadonlyArray<Partial<Modifier<string, object>>> }

Value

Value: TElement[]

ValueOf

ValueOf<E>: E["children"]

A helper type for getting the value of an editor.

Type parameters

E: TEditor

WithOptional

WithOptional<T, K>: Omit<T, K> & Partial<Pick<T, K>>

Type parameters

T
K: keyof T

WithOverride

WithOverride<P, V, E, EE>: (editor: E, plugin: WithPlatePlugin<P, V, E>) => EE

Plate plugin overriding the editor methods. Naming convention is with*.

Type parameters

P = PluginOptions
V: Value = Value
E: PlateEditor<V> = PlateEditor<V>
EE: E = E

Type declaration

- (editor: E, plugin: WithPlatePlugin<P, V, E>): EE
- Parameters
 - editor: E
 - plugin: WithPlatePlugin<P, V, E>
 Returns EE

WithPartial

WithPartial<T, K>: Omit<T, K> & Partial<T>

Type parameters

T
K: keyof T

WithPlatePlugin

WithPlatePlugin<P, V, E>: WithRequired<PlatePlugin<P, V, E>, "type" | "options" | "inject" | "editor">

Type parameters

WithRequired

WithRequired<T, K>: Omit<T, K> & Required<Pick<T, K>>

Type parameters

T
K: keyof T

WrapElement

WrapElement: (element: ReactElement) => ReactElement

The wrapElement prop.

Type declaration

- (element: ReactElement): ReactElement
- Parameters
  - element: ReactElement
  Returns ReactElement

WrapNodesOptions

WrapNodesOptions<V>: Modify<NonNullable<Parameters<typeof Transforms.wrapNodes>[2]>, NodeMatchOption<V>>

Type parameters

V: Value = Value

Variables

Const AlignToolbarButton

AlignToolbarButton: React.FunctionComponent<AlignToolbarButtonProps>

Const BalloonToolbar

BalloonToolbar: React.FunctionComponent<BalloonToolbarProps>

Const BlockToolbarButton

BlockToolbarButton: React.FunctionComponent<BlockToolbarButtonProps>

Toolbar button to toggle the type of elements in selection.

Const Box

Box: Component

Const CARRIAGE_RETURN

CARRIAGE_RETURN: "\r" = "\r"

Const CODE_BLOCK_LANGUAGES

CODE_BLOCK_LANGUAGES: Record<string, string>

Const CODE_BLOCK_LANGUAGES_POPULAR

CODE_BLOCK_LANGUAGES_POPULAR: Record<string, string>

Const CodeBlockToolbarButton

CodeBlockToolbarButton: React.FunctionComponent<ToolbarButtonProps & { options?: CodeBlockInsertOptions<Value> }>

Const ColorPicker

ColorPicker: React.MemoExoticComponent<({ color, colors, customColors, selectedIcon, updateColor, updateCustomColor, clearColor, }: ColorPickerProps) => JSX.Element>

Const ColorPickerToolbarDropdown

ColorPickerToolbarDropdown: React.FunctionComponent<ColorPickerToolbarDropdownProps & ToolbarButtonProps>

Const DEFAULT_COLORS

DEFAULT_COLORS: { isBrightColor: boolean; name: string; value: string }[]

Const DEFAULT_CUSTOM_COLORS

DEFAULT_CUSTOM_COLORS: { isBrightColor: boolean; name: string; value: string }[]

Const DOM_HANDLERS

DOM_HANDLERS: keyof DOMHandlers[]

Const DRAG_ITEM_BLOCK

DRAG_ITEM_BLOCK: "block" = "block"

Const ELEMENT_BLOCKQUOTE

ELEMENT_BLOCKQUOTE: "blockquote" = "blockquote"

Const ELEMENT_CODE_BLOCK

ELEMENT_CODE_BLOCK: "code_block" = "code_block"

Const ELEMENT_CODE_LINE

ELEMENT_CODE_LINE: "code_line" = "code_line"

Const ELEMENT_CODE_SYNTAX

ELEMENT_CODE_SYNTAX: "code_syntax" = "code_syntax"

Const ELEMENT_DEFAULT

ELEMENT_DEFAULT: "p" = "p"

Const ELEMENT_H1

ELEMENT_H1: "h1" = "h1"

Const ELEMENT_H2

ELEMENT_H2: "h2" = "h2"

Const ELEMENT_H3

ELEMENT_H3: "h3" = "h3"

Const ELEMENT_H4

ELEMENT_H4: "h4" = "h4"

Const ELEMENT_H5

ELEMENT_H5: "h5" = "h5"

Const ELEMENT_H6

ELEMENT_H6: "h6" = "h6"

Const ELEMENT_HR

ELEMENT_HR: "hr" = "hr"

Const ELEMENT_IMAGE

ELEMENT_IMAGE: "img" = "img"

Const ELEMENT_LI

ELEMENT_LI: "li" = "li"

Const ELEMENT_LIC

ELEMENT_LIC: "lic" = "lic"

Const ELEMENT_LINK

ELEMENT_LINK: "a" = "a"

Const ELEMENT_MEDIA_EMBED

ELEMENT_MEDIA_EMBED: "media_embed" = "media_embed"

Const ELEMENT_MENTION

ELEMENT_MENTION: "mention" = "mention"

Const ELEMENT_MENTION_INPUT

ELEMENT_MENTION_INPUT: "mention_input" = "mention_input"

Const ELEMENT_OL

ELEMENT_OL: "ol" = "ol"

Const ELEMENT_PARAGRAPH

ELEMENT_PARAGRAPH: "p" = "p"

Const ELEMENT_TABLE

ELEMENT_TABLE: "table" = "table"

Const ELEMENT_TD

ELEMENT_TD: "td" = "td"

Const ELEMENT_TH

ELEMENT_TH: "th" = "th"

Const ELEMENT_TODO_LI

ELEMENT_TODO_LI: "action_item" = "action_item"

Const ELEMENT_TR

ELEMENT_TR: "tr" = "tr"

Const ELEMENT_UL

ELEMENT_UL: "ul" = "ul"

Const EditorStateEffect

EditorStateEffect: MemoExoticComponent

Const FROZEN_EMPTY_ARRAY

FROZEN_EMPTY_ARRAY: SelectionRect[]

Const HeadingToolbar

HeadingToolbar: React.ForwardRefExoticComponent<ToolbarProps & React.RefAttributes<HTMLDivElement>>

Const Hotkeys

Hotkeys: { isBold: (event: KeyboardEvent) => boolean; isCompose: (event: KeyboardEvent) => boolean; isDeleteBackward: (event: KeyboardEvent) => boolean; isDeleteForward: (event: KeyboardEvent) => boolean; isDeleteLineBackward: (event: KeyboardEvent) => boolean; isDeleteLineForward: (event: KeyboardEvent) => boolean; isDeleteWordBackward: (event: KeyboardEvent) => boolean; isDeleteWordForward: (event: KeyboardEvent) => boolean; isExtendBackward: (event: KeyboardEvent) => boolean; isExtendForward: (event: KeyboardEvent) => boolean; isExtendLineBackward: (event: KeyboardEvent) => boolean; isExtendLineForward: (event: KeyboardEvent) => boolean; isItalic: (event: KeyboardEvent) => boolean; isMoveBackward: (event: KeyboardEvent) => boolean; isMoveForward: (event: KeyboardEvent) => boolean; isMoveLineBackward: (event: KeyboardEvent) => boolean; isMoveLineForward: (event: KeyboardEvent) => boolean; isMoveWordBackward: (event: KeyboardEvent) => boolean; isMoveWordForward: (event: KeyboardEvent) => boolean; isRedo: (event: KeyboardEvent) => boolean; isSoftBreak: (event: KeyboardEvent) => boolean; isSplitBlock: (event: KeyboardEvent) => boolean; isTab: (editor: TReactEditor, event: KeyboardEvent, { composing, }?: { composing?: boolean }) => boolean; isTransposeCharacter: (event: KeyboardEvent) => boolean; isUndo: (event: KeyboardEvent) => boolean; isUntab: (editor: TReactEditor, event: KeyboardEvent, { composing, }?: { composing?: boolean }) => boolean }

Type declaration

isBold: (event: KeyboardEvent) => boolean
- - (event: KeyboardEvent): boolean
  - Parameters
    - event: KeyboardEvent
    Returns boolean
isCompose: (event: KeyboardEvent) => boolean
- - (event: KeyboardEvent): boolean
  - Parameters
    - event: KeyboardEvent
    Returns boolean
isDeleteBackward: (event: KeyboardEvent) => boolean
- - (event: KeyboardEvent): boolean
  - Parameters
    - event: KeyboardEvent
    Returns boolean
isDeleteForward: (event: KeyboardEvent) => boolean
- - (event: KeyboardEvent): boolean
  - Parameters
    - event: KeyboardEvent
    Returns boolean
isDeleteLineBackward: (event: KeyboardEvent) => boolean
- - (event: KeyboardEvent): boolean
  - Parameters
    - event: KeyboardEvent
    Returns boolean
isDeleteLineForward: (event: KeyboardEvent) => boolean
- - (event: KeyboardEvent): boolean
  - Parameters
    - event: KeyboardEvent
    Returns boolean
isDeleteWordBackward: (event: KeyboardEvent) => boolean
- - (event: KeyboardEvent): boolean
  - Parameters
    - event: KeyboardEvent
    Returns boolean
isDeleteWordForward: (event: KeyboardEvent) => boolean
- - (event: KeyboardEvent): boolean
  - Parameters
    - event: KeyboardEvent
    Returns boolean
isExtendBackward: (event: KeyboardEvent) => boolean
- - (event: KeyboardEvent): boolean
  - Parameters
    - event: KeyboardEvent
    Returns boolean
isExtendForward: (event: KeyboardEvent) => boolean
- - (event: KeyboardEvent): boolean
  - Parameters
    - event: KeyboardEvent
    Returns boolean
isExtendLineBackward: (event: KeyboardEvent) => boolean
- - (event: KeyboardEvent): boolean
  - Parameters
    - event: KeyboardEvent
    Returns boolean
isExtendLineForward: (event: KeyboardEvent) => boolean
- - (event: KeyboardEvent): boolean
  - Parameters
    - event: KeyboardEvent
    Returns boolean
isItalic: (event: KeyboardEvent) => boolean
- - (event: KeyboardEvent): boolean
  - Parameters
    - event: KeyboardEvent
    Returns boolean
isMoveBackward: (event: KeyboardEvent) => boolean
- - (event: KeyboardEvent): boolean
  - Parameters
    - event: KeyboardEvent
    Returns boolean
isMoveForward: (event: KeyboardEvent) => boolean
- - (event: KeyboardEvent): boolean
  - Parameters
    - event: KeyboardEvent
    Returns boolean
isMoveLineBackward: (event: KeyboardEvent) => boolean
- - (event: KeyboardEvent): boolean
  - Parameters
    - event: KeyboardEvent
    Returns boolean
isMoveLineForward: (event: KeyboardEvent) => boolean
- - (event: KeyboardEvent): boolean
  - Parameters
    - event: KeyboardEvent
    Returns boolean
isMoveWordBackward: (event: KeyboardEvent) => boolean
- - (event: KeyboardEvent): boolean
  - Parameters
    - event: KeyboardEvent
    Returns boolean
isMoveWordForward: (event: KeyboardEvent) => boolean
- - (event: KeyboardEvent): boolean
  - Parameters
    - event: KeyboardEvent
    Returns boolean
isRedo: (event: KeyboardEvent) => boolean
- - (event: KeyboardEvent): boolean
  - Parameters
    - event: KeyboardEvent
    Returns boolean
isSoftBreak: (event: KeyboardEvent) => boolean
- - (event: KeyboardEvent): boolean
  - Parameters
    - event: KeyboardEvent
    Returns boolean
isSplitBlock: (event: KeyboardEvent) => boolean
- - (event: KeyboardEvent): boolean
  - Parameters
    - event: KeyboardEvent
    Returns boolean
isTab: (editor: TReactEditor, event: KeyboardEvent, { composing, }?: { composing?: boolean }) => boolean
- - (editor: TReactEditor, event: KeyboardEvent, { composing, }?: { composing?: boolean }): boolean
  - Parameters
    - editor: TReactEditor
    - event: KeyboardEvent
    - Optional { composing, }: { composing?: boolean }
      - Optional composing?: boolean
        
        Ignore the event if composing.
    Returns boolean
isTransposeCharacter: (event: KeyboardEvent) => boolean
- - (event: KeyboardEvent): boolean
  - Parameters
    - event: KeyboardEvent
    Returns boolean
isUndo: (event: KeyboardEvent) => boolean
- - (event: KeyboardEvent): boolean
  - Parameters
    - event: KeyboardEvent
    Returns boolean
isUntab: (editor: TReactEditor, event: KeyboardEvent, { composing, }?: { composing?: boolean }) => boolean
- - (editor: TReactEditor, event: KeyboardEvent, { composing, }?: { composing?: boolean }): boolean
  - Parameters
    - editor: TReactEditor
    - event: KeyboardEvent
    - Optional { composing, }: { composing?: boolean }
      - Optional composing?: boolean
        
        Ignore the event if composing.
    Returns boolean

Const IS_APPLE

IS_APPLE: boolean

Const Image

Image: { Caption: Component; CaptionTextarea: Component; Img: Component; Resizable: Component; Root: Component }

Type declaration

Caption: Component
CaptionTextarea: Component
Img: Component
Resizable: Component
Root: Component

Const ImageCaption

ImageCaption: Component

Const ImageCaptionTextarea

ImageCaptionTextarea: Component

Const ImageImg

ImageImg: Component

Const ImageResizable

ImageResizable: Component

Const ImageRoot

ImageRoot: Component

Const KEYS_HEADING

KEYS_HEADING: string[]

Const KEY_ALIGN

KEY_ALIGN: "align" = "align"

Const KEY_AUTOFORMAT

KEY_AUTOFORMAT: "autoformat" = "autoformat"

Const KEY_COMBOBOX

KEY_COMBOBOX: "combobox" = "combobox"

Const KEY_DESERIALIZE_AST

KEY_DESERIALIZE_AST: "deserializeAst" = "deserializeAst"

Const KEY_DESERIALIZE_CSV

KEY_DESERIALIZE_CSV: "deserializeCsv" = "deserializeCsv"

Const KEY_DESERIALIZE_DOCX

KEY_DESERIALIZE_DOCX: "deserializeDocx" = "deserializeDocx"

Const KEY_DESERIALIZE_HTML

KEY_DESERIALIZE_HTML: "deserializeHtml" = "deserializeHtml"

Const KEY_DESERIALIZE_MD

KEY_DESERIALIZE_MD: "deserializeMd" = "deserializeMd"

Const KEY_DND

KEY_DND: "dnd" = "dnd"

Const KEY_EVENT_EDITOR

KEY_EVENT_EDITOR: "event-editor" = "event-editor"

Const KEY_EXIT_BREAK

KEY_EXIT_BREAK: "exitBreak" = "exitBreak"

Const KEY_INDENT

KEY_INDENT: "indent" = "indent"

Const KEY_INLINE_VOID

KEY_INLINE_VOID: "inline-void" = "inline-void"

Const KEY_INSERT_DATA

KEY_INSERT_DATA: "insertData" = "insertData"

Const KEY_LINE_HEIGHT

KEY_LINE_HEIGHT: "lineHeight" = "lineHeight"

Const KEY_LIST_START

KEY_LIST_START: "listStart" = "listStart"

Const KEY_LIST_STYLE_TYPE

KEY_LIST_STYLE_TYPE: "listStyleType" = "listStyleType"

Const KEY_NODE_ID

KEY_NODE_ID: "nodeId" = "nodeId"

Const KEY_NORMALIZE_TYPES

KEY_NORMALIZE_TYPES: "normalizeTypes" = "normalizeTypes"

Const KEY_RESET_NODE

KEY_RESET_NODE: "resetNode" = "resetNode"

Const KEY_SELECT_ON_BACKSPACE

KEY_SELECT_ON_BACKSPACE: "selectOnBackspace" = "selectOnBackspace"

Const KEY_SINGLE_LINE

KEY_SINGLE_LINE: "singleLine" = "singleLine"

Const KEY_SOFT_BREAK

KEY_SOFT_BREAK: "softBreak" = "softBreak"

Const KEY_TEXT_INDENT

KEY_TEXT_INDENT: "textIndent" = "textIndent"

Const KEY_TRAILING_BLOCK

KEY_TRAILING_BLOCK: "trailingBlock" = "trailingBlock"

Const LINE_FEED

LINE_FEED: "\n" = "\n"

Const LineHeightToolbarDropdown

LineHeightToolbarDropdown: React.FunctionComponent<ToolbarButtonProps>

Const LinkToolbarButton

LinkToolbarButton: React.FunctionComponent<LinkToolbarButtonProps>

Const ListToolbarButton

ListToolbarButton: React.FunctionComponent<ToolbarButtonProps & { type?: string }>

Const MARK_BG_COLOR

MARK_BG_COLOR: "backgroundColor" = "backgroundColor"

Const MARK_BOLD

MARK_BOLD: "bold" = "bold"

Const MARK_CODE

MARK_CODE: "code" = "code"

Const MARK_COLOR

MARK_COLOR: "color" = "color"

Const MARK_FONT_FAMILY

MARK_FONT_FAMILY: "fontFamily" = "fontFamily"

Const MARK_FONT_SIZE

MARK_FONT_SIZE: "fontSize" = "fontSize"

Const MARK_FONT_WEIGHT

MARK_FONT_WEIGHT: "fontWeight" = "fontWeight"

Const MARK_HIGHLIGHT

MARK_HIGHLIGHT: "highlight" = "highlight"

Const MARK_ITALIC

MARK_ITALIC: "italic" = "italic"

Const MARK_KBD

MARK_KBD: "kbd" = "kbd"

Const MARK_SEARCH_HIGHLIGHT

MARK_SEARCH_HIGHLIGHT: "search_highlight" = "search_highlight"

Const MARK_STRIKETHROUGH

MARK_STRIKETHROUGH: "strikethrough" = "strikethrough"

Const MARK_SUBSCRIPT

MARK_SUBSCRIPT: "subscript" = "subscript"

Const MARK_SUPERSCRIPT

MARK_SUPERSCRIPT: "superscript" = "superscript"

Const MARK_UNDERLINE

MARK_UNDERLINE: "underline" = "underline"

Const MarkToolbarButton

MarkToolbarButton: React.FunctionComponent<MarkToolbarButtonProps<Value>>

Toolbar button to toggle the mark of the leaves in selection.

Const NO_BREAK_SPACE

NO_BREAK_SPACE: " " = "\u00A0"

Const SCOPE_ELEMENT

SCOPE_ELEMENT: unique symbol

Const SIMULATE_BACKSPACE

SIMULATE_BACKSPACE: any

Const SPACE

SPACE: " " = " "

Const StyledIcon

StyledIcon: StyledComponent

Const TAB

TAB: "\t" = "\t"

Const TableToolbarButton

TableToolbarButton: React.FunctionComponent<TableToolbarButtonProps<Value>>

Const Toolbar

Toolbar: React.ForwardRefExoticComponent<ToolbarProps & React.RefAttributes<HTMLDivElement>>

Const ToolbarBase

ToolbarBase: React.ForwardRefExoticComponent<ToolbarProps & React.RefAttributes<HTMLDivElement>>

Const ZERO_WIDTH_SPACE

ZERO_WIDTH_SPACE: "" = "\u200B"

Const autoformatArrow

autoformatArrow: AutoformatRule[]

Const autoformatComparison

autoformatComparison: AutoformatRule[]

Const autoformatDivision

autoformatDivision: AutoformatRule[]

Const autoformatEquality

autoformatEquality: AutoformatRule[]

Const autoformatFraction

autoformatFraction: AutoformatRule[]

Const autoformatLegal

autoformatLegal: AutoformatRule[]

Const autoformatLegalHtml

autoformatLegalHtml: AutoformatRule[]

Const autoformatMath

autoformatMath: AutoformatRule[]

Const autoformatOperation

autoformatOperation: AutoformatRule[]

Const autoformatPunctuation

autoformatPunctuation: AutoformatRule[]

Const autoformatSmartQuotes

autoformatSmartQuotes: AutoformatRule[]

Const autoformatSubscriptNumbers

autoformatSubscriptNumbers: AutoformatRule[]

Const autoformatSubscriptSymbols

autoformatSubscriptSymbols: AutoformatRule[]

Const autoformatSuperscriptNumbers

autoformatSuperscriptNumbers: AutoformatRule[]

Const autoformatSuperscriptSymbols

autoformatSuperscriptSymbols: AutoformatRule[]

Const comboboxActions

comboboxActions: SetRecord & { mergeState: MergeState; state: SetImmerState } & { open: (state: Pick<ComboboxState, "activeId" | "targetRange" | "text">) => void; reset: () => void; setComboboxById: <TData>(state: ComboboxStateById<TData>) => void }

Const comboboxSelectors

comboboxSelectors: StoreApiGet

Const comboboxStore

comboboxStore: StoreApi<"combobox", ComboboxState<undefined>, SetRecord & { mergeState: MergeState; state: SetImmerState } & { open: (state: Pick<ComboboxState, "activeId" | "targetRange" | "text">) => void; reset: () => void; setComboboxById: <TData>(state: ComboboxStateById<TData>) => void }, { isOpen: () => boolean }>

Const deserializeHtmlCodeBlock

deserializeHtmlCodeBlock: DeserializeHtml

Const elementStore

elementStore: { atom: { element: Atom }; extend: <ET, EN>(extendedState: ET, options?: Omit<CreateAtomStoreOptions, "initialStore">) => AtomStoreApi }

Type declaration

atom: { element: Atom }
- element: Atom
extend: <ET, EN>(extendedState: ET, options?: Omit<CreateAtomStoreOptions, "initialStore">) => AtomStoreApi
- - <ET, EN>(extendedState: ET, options?: Omit<CreateAtomStoreOptions, "initialStore">): AtomStoreApi
 - Type parameters
 - ET
 - EN
 Parameters
 - extendedState: ET
 - Optional options: Omit<CreateAtomStoreOptions, "initialStore">
 Returns AtomStoreApi

Const eventEditorActions

eventEditorActions: StateActions

Const eventEditorSelectors

eventEditorSelectors: StoreApiGet

Const eventEditorStore

eventEditorStore: StoreApi

Store where the keys are event names and the values are editor ids.

Const grabberTooltipProps

grabberTooltipProps: TippyProps

Const hoveredColIndexAtom

hoveredColIndexAtom: Atom & { onMount?: <S>(setAtom: S) => void | (() => void); write: (get: { <Value>(atom: Atom<Value | Promise<Value>>): Value; <Value_1>(atom: Atom<Promise<Value_1>>): Value_1; <Value_2>(atom: Atom<Value_2>): Value_2 extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? any : V : V : V : V : V : V : V : V : V : V : Value_2 } & { <Value_3>(atom: Atom<Value_3 | Promise<Value_3>>, options: { unstable_promise: true }): Value_3 | Promise<Value_3>; <Value_4>(atom: Atom<Promise<Value_4>>, options: { unstable_promise: true }): Value_4 | Promise<Value_4>; <Value_5>(atom: Atom<Value_5>, options: { unstable_promise: true }): (Value_5 extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? any : V : V : V : V : V : V : V : V : V : V : Value_5) | Promise<Value_5 extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? any : V : V : V : V : V : V : V : V : V : V : Value_5> }, set: { <Value_6, Result>(atom: WritableAtom<Value_6, undefined, Result>): Result; <Value_7, Update, Result_1>(atom: WritableAtom<Value_7, Update, Result_1>, update: Update): Result_1 }, update: number | ((prev: number | null) => number | null) | null) => void } & { init: number | null }

Const imageStore

imageStore: { atom: { element: Atom; width: Atom }; extend: <ET, EN>(extendedState: ET, options?: Omit<CreateAtomStoreOptions, "initialStore">) => AtomStoreApi }

Type declaration

atom: { element: Atom; width: Atom }
- element: Atom
- width: Atom
extend: <ET, EN>(extendedState: ET, options?: Omit<CreateAtomStoreOptions, "initialStore">) => AtomStoreApi
- - <ET, EN>(extendedState: ET, options?: Omit<CreateAtomStoreOptions, "initialStore">): AtomStoreApi
 - Type parameters
 - ET
 - EN
 Parameters
 - extendedState: ET
 - Optional options: Omit<CreateAtomStoreOptions, "initialStore">
 Returns AtomStoreApi

Const plateIdAtom

plateIdAtom: Atom & { onMount?: <S>(setAtom: S) => void | (() => void); write: (get: { <Value>(atom: Atom<Value | Promise<Value>>): Value; <Value_1>(atom: Atom<Promise<Value_1>>): Value_1; <Value_2>(atom: Atom<Value_2>): Value_2 extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? any : V : V : V : V : V : V : V : V : V : V : Value_2 } & { <Value_3>(atom: Atom<Value_3 | Promise<Value_3>>, options: { unstable_promise: true }): Value_3 | Promise<Value_3>; <Value_4>(atom: Atom<Promise<Value_4>>, options: { unstable_promise: true }): Value_4 | Promise<Value_4>; <Value_5>(atom: Atom<Value_5>, options: { unstable_promise: true }): (Value_5 extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? any : V : V : V : V : V : V : V : V : V : V : Value_5) | Promise<Value_5 extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? any : V : V : V : V : V : V : V : V : V : V : Value_5> }, set: { <Value_6, Result>(atom: WritableAtom<Value_6, undefined, Result>): Result; <Value_7, Update, Result_1>(atom: WritableAtom<Value_7, Update, Result_1>, update: Update): Result_1 }, update: string | ((prev: string | null) => string | null) | null) => void } & { init: string | null }

Const platesActions

platesActions: SetRecord & { mergeState: MergeState; state: SetImmerState } & { set: <V, E>(id: string, state?: PlateProps<V, E>) => void; unset: (id: string) => void }

Const platesSelectors

platesSelectors: StoreApiGet

Const platesStore

platesStore: StoreApi

Const resizingColAtom

resizingColAtom: Atom & { onMount?: <S>(setAtom: S) => void | (() => void); write: (get: { <Value>(atom: Atom<Value | Promise<Value>>): Value; <Value_1>(atom: Atom<Promise<Value_1>>): Value_1; <Value_2>(atom: Atom<Value_2>): Value_2 extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? any : V : V : V : V : V : V : V : V : V : V : Value_2 } & { <Value_3>(atom: Atom<Value_3 | Promise<Value_3>>, options: { unstable_promise: true }): Value_3 | Promise<Value_3>; <Value_4>(atom: Atom<Promise<Value_4>>, options: { unstable_promise: true }): Value_4 | Promise<Value_4>; <Value_5>(atom: Atom<Value_5>, options: { unstable_promise: true }): (Value_5 extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? any : V : V : V : V : V : V : V : V : V : V : Value_5) | Promise<Value_5 extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? any : V : V : V : V : V : V : V : V : V : V : Value_5> }, set: { <Value_6, Result>(atom: WritableAtom<Value_6, undefined, Result>): Result; <Value_7, Update, Result_1>(atom: WritableAtom<Value_7, Update, Result_1>, update: Update): Result_1 }, update: { index: number; width: number } | ((prev: { index: number; width: number } | null) => { index: number; width: number } | null) | null) => void } & { init: { index: number; width: number } | null }

Const selectedCellsAtom

selectedCellsAtom: Atom & { onMount?: <S>(setAtom: S) => void | (() => void); write: (get: { <Value>(atom: Atom<Value | Promise<Value>>): Value; <Value_1>(atom: Atom<Promise<Value_1>>): Value_1; <Value_2>(atom: Atom<Value_2>): Value_2 extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? any : V : V : V : V : V : V : V : V : V : V : Value_2 } & { <Value_3>(atom: Atom<Value_3 | Promise<Value_3>>, options: { unstable_promise: true }): Value_3 | Promise<Value_3>; <Value_4>(atom: Atom<Promise<Value_4>>, options: { unstable_promise: true }): Value_4 | Promise<Value_4>; <Value_5>(atom: Atom<Value_5>, options: { unstable_promise: true }): (Value_5 extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? any : V : V : V : V : V : V : V : V : V : V : Value_5) | Promise<Value_5 extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? any : V : V : V : V : V : V : V : V : V : V : Value_5> }, set: { <Value_6, Result>(atom: WritableAtom<Value_6, undefined, Result>): Result; <Value_7, Update, Result_1>(atom: WritableAtom<Value_7, Update, Result_1>, update: Update): Result_1 }, update: TElement[] | ((prev: TElement[] | null) => TElement[] | null) | null) => void } & { init: TElement[] | null }

Const useComboboxSelectors

useComboboxSelectors: StoreApiUse

Const useEventEditorSelectors

useEventEditorSelectors: GetRecord

Const usePlatesSelectors

usePlatesSelectors: StoreApiUse

Const virtualReference

virtualReference: PopperJS.VirtualElement

Functions

Const BlockquoteElement

BlockquoteElement<V>(props: StyledElementProps<V, ElementOf<TEditor<V>>, {}>): Element

- Defined in packages/ui/nodes/block-quote/dist/BlockquoteElement/BlockquoteElement.d.ts:4
Type parameters
- V: TElement[]
Parameters
- props: StyledElementProps<V, ElementOf<TEditor<V>>, {}>
Returns Element

Const Button

Button(__namedParameters: ButtonProps): Element

- Defined in packages/ui/button/dist/Button/Button.d.ts:3
Parameters
- __namedParameters: ButtonProps
Returns Element

Const ChevronDownIcon

ChevronDownIcon(props: StyledIconProps): Element

- Defined in packages/ui/button/dist/Icon/ChevronDownIcon.d.ts:3
Parameters
- props: StyledIconProps
Returns Element

Const CodeBlockElement

CodeBlockElement<V>(props: StyledElementProps<V, TCodeBlockElement, {}>): Element

- Defined in packages/ui/nodes/code-block/dist/CodeBlockElement/CodeBlockElement.d.ts:5
Type parameters
- V: TElement[]
Parameters
- props: StyledElementProps<V, TCodeBlockElement, {}>
Returns Element

Const CodeBlockSelectElement

CodeBlockSelectElement(__namedParameters: { className?: string; css?: CSSProp<any>; lang?: string; onChange: Function }): null | Element

- Defined in packages/ui/nodes/code-block/dist/CodeBlockElement/CodeBlockSelectElement.d.ts:3
Parameters
- __namedParameters: { className?: string; css?: CSSProp<any>; lang?: string; onChange: Function }
 - Optional className?: string
 - Optional css?: CSSProp<any>
 - Optional lang?: string
 - onChange: Function
Returns null | Element

Const CodeLineElement

CodeLineElement<V>(props: StyledElementProps<V, ElementOf<TEditor<V>>, {}>): Element

- Defined in packages/ui/nodes/code-block/dist/CodeBlockElement/CodeLineElement.d.ts:4
Type parameters
- V: TElement[]
Parameters
- props: StyledElementProps<V, ElementOf<TEditor<V>>, {}>
Returns Element

Const CodeSyntaxLeaf

CodeSyntaxLeaf(props: any, defaultRender?: (props?: any) => null | Element): null | Element

- Defined in packages/ui/nodes/code-block/dist/CodeBlockElement/CodeSyntaxLeaf.d.ts:2
Parameters
- props: any
- Optional defaultRender: (props?: any) => null | Element
  - - (props?: any): null | Element
    - Parameters
      - Optional props: any
      Returns null | Element
Returns null | Element

Const ColorButton

ColorButton(__namedParameters: ColorButtonProps): Element

- Defined in packages/ui/nodes/font/dist/ColorPicker/ColorButton.d.ts:10
Parameters
- __namedParameters: ColorButtonProps
Returns Element

Const ColorInput

ColorInput(__namedParameters: PropsWithChildren<ColorInputProps>): Element

- Defined in packages/ui/nodes/font/dist/ColorPicker/ColorInput.d.ts:3
Parameters
- __namedParameters: PropsWithChildren<ColorInputProps>
Returns Element

Const Colors

Colors(__namedParameters: ColorsProps): Element

- Defined in packages/ui/nodes/font/dist/ColorPicker/Colors.d.ts:9
Parameters
- __namedParameters: ColorsProps
Returns Element

Const Combobox

Combobox<TData>(__namedParameters: ComboboxProps<TData>): null | Element

- Defined in packages/ui/combobox/dist/Combobox.d.ts:7
Register the combobox id, trigger, onSelectItem Renders the combobox if active.

Type parameters
- TData: unknown = undefined
Parameters
- __namedParameters: ComboboxProps<TData>
Returns null | Element

Const Cursor

Cursor(__namedParameters: CursorProps<CursorData>): null | Element

- Defined in packages/ui/cursor/dist/components/Cursor.d.ts:31
Parameters
- __namedParameters: CursorProps<CursorData>
Returns null | Element

Const CursorOverlay

CursorOverlay<TCursorData>(props: CursorOverlayProps<TCursorData>): null | Element

- Defined in packages/ui/cursor/dist/components/CursorOverlay.d.ts:26
Type parameters
- TCursorData: UnknownObject = UnknownObject
Parameters
- props: CursorOverlayProps<TCursorData>
Returns null | Element

Const CursorOverlayContent

CursorOverlayContent<TCursorData>(__namedParameters: CursorOverlayProps<TCursorData>): Element

- Defined in packages/ui/cursor/dist/components/CursorOverlay.d.ts:25
Type parameters
- TCursorData: UnknownObject = UnknownObject
Parameters
- __namedParameters: CursorOverlayProps<TCursorData>
Returns Element

Const CustomColors

CustomColors(__namedParameters: CustomColorsProps): Element

- Defined in packages/ui/nodes/font/dist/ColorPicker/CustomColors.d.ts:11
Parameters
- __namedParameters: CustomColorsProps
Returns Element

Const DefaultLeaf

DefaultLeaf<V>(__namedParameters: PlateRenderLeafProps<V, TextOf<TEditor<V>>>): Element

- Defined in packages/core/dist/components/plate/DefaultLeaf.d.ts:4
Type parameters
- V: TElement[]
Parameters
- __namedParameters: PlateRenderLeafProps<V, TextOf<TEditor<V>>>
Returns Element

Const DeleteIcon

DeleteIcon(props: StyledIconProps): Element

- Defined in packages/ui/button/dist/Icon/DeleteIcon.d.ts:3
Parameters
- props: StyledIconProps
Returns Element

Const Divider

Divider(props: HTMLAttributes<HTMLDivElement>): Element

- Defined in packages/ui/styled-components/dist/Divider/Divider.d.ts:2
Parameters
- props: HTMLAttributes<HTMLDivElement>
Returns Element

Const Draggable

Draggable<V>(props: DraggableProps<V>): Element

- Defined in packages/ui/dnd/dist/components/Draggable.d.ts:4
Type parameters
- V: TElement[]
Parameters
- props: DraggableProps<V>
Returns Element

Const EditablePlugins

EditablePlugins<V>(props: Pick<PlateProps<V, PlateEditor<V>>, "id">): Element

- Defined in packages/core/dist/components/plate/EditablePlugins.d.ts:7
{@link Editable} with plugins support.

Type parameters
- V: TElement[]
Parameters
- props: Pick<PlateProps<V, PlateEditor<V>>, "id">
Returns Element

Const EditorRefEffect

EditorRefEffect(__namedParameters: Pick<PlateProps<Value, PlateEditor<Value>>, "id">): Element

- Defined in packages/core/dist/components/plate/EditorRefEffect.d.ts:7
Parameters
- __namedParameters: Pick<PlateProps<Value, PlateEditor<Value>>, "id">
Returns Element

Const EditorRefPluginEffect

EditorRefPluginEffect(__namedParameters: { plugin: WithPlatePlugin<AnyObject, Value, PlateEditor<Value>> }): null

- Defined in packages/core/dist/components/plate/EditorRefEffect.d.ts:4
Parameters
- __namedParameters: { plugin: WithPlatePlugin<AnyObject, Value, PlateEditor<Value>> }
 - plugin: WithPlatePlugin<AnyObject, Value, PlateEditor<Value>>
Returns null

Const ElementProvider

ElementProvider(__namedParameters: { initialValues?: Iterable<readonly [Atom<unknown>, unknown]>; scope?: Scope; unstable_createStore?: (initialValues?: Iterable<readonly [{ debugLabel?: string; read: (get: { <Value>(atom: Atom<Value | Promise<Value>>): Value; <Value_1>(atom: Atom<Promise<Value_1>>): Value_1; <Value_2>(atom: Atom<Value_2>): Value_2 extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? any : V : V : V : V : V : V : V : V : V : V : Value_2 }) => unknown; toString: () => string }, unknown]>) => { SECRET_INTERNAL_store: { a: (a: { debugLabel?: string; read: (get: { <Value>(atom: Atom<Value | Promise<Value>>): Value; <Value_1>(atom: Atom<Promise<Value_1>>): Value_1; <Value_2>(atom: Atom<Value_2>): Value_2 extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? any : V : V : V : V : V : V : V : V : V : V : Value_2 }) => unknown; toString: () => string }) => undefined | AtomState<unknown>; c: (_atom: null | { debugLabel?: string; read: (get: { <Value>(atom: Atom<Value | Promise<Value>>): Value; <Value_1>(atom: Atom<Promise<Value_1>>): Value_1; <Value_2>(atom: Atom<Value_2>): Value_2 extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? any : V : V : V : V : V : V : V : V : V : V : Value_2 }) => unknown; toString: () => string }, version?: VersionObject) => void; h: (values: Iterable<readonly [{ debugLabel?: string; read: (get: { <Value>(atom: Atom<Value | Promise<Value>>): Value; <Value_1>(atom: Atom<Promise<Value_1>>): Value_1; <Value_2>(atom: Atom<Value_2>): Value_2 extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? any : V : V : V : V : V : V : V : V : V : V : Value_2 }) => unknown; toString: () => string }, unknown]>, version?: VersionObject) => void; l: () => IterableIterator<{ debugLabel?: string; read: (get: { <Value>(atom: Atom<Value | Promise<Value>>): Value; <Value_1>(atom: Atom<Promise<Value_1>>): Value_1; <Value_2>(atom: Atom<Value_2>): Value_2 extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? any : V : V : V : V : V : V : V : V : V : V : Value_2 }) => unknown; toString: () => string }>; m: (a: { debugLabel?: string; read: (get: { <Value>(atom: Atom<Value | Promise<Value>>): Value; <Value_1>(atom: Atom<Promise<Value_1>>): Value_1; <Value_2>(atom: Atom<Value_2>): Value_2 extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? any : V : V : V : V : V : V : V : V : V : V : Value_2 }) => unknown; toString: () => string }) => undefined | { l: Set<(version?: VersionObject) => void>; t: Set<{ debugLabel?: string; read: (get: { <Value>(atom: Atom<Value | Promise<Value>>): Value; <Value_1>(atom: Atom<Promise<Value_1>>): Value_1; <Value_2>(atom: Atom<Value_2>): Value_2 extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? any : V : V : V : V : V : V : V : V : V : V : Value_2 }) => unknown; toString: () => string }>; u?: () => void }; n: (l: () => void) => () => void; r: <Value_4>(readingAtom: Atom<Value_4>, version?: VersionObject) => AtomState<Value_4>; s: (atom: { debugLabel?: string; read: (get: { <Value>(atom: Atom<Value | Promise<Value>>): Value; <Value_1>(atom: Atom<Promise<Value_1>>): Value_1; <Value_2>(atom: Atom<Value_2>): Value_2 extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? any : V : V : V : V : V : V : V : V : V : V : Value_2 }) => unknown; toString: () => string }, callback: (version?: VersionObject) => void) => () => void; w: <Value_1_1, Update_1, Result_1>(writingAtom: WritableAtom<Value_1_1, Update_1, Result_1>, update: Update_1, version?: VersionObject) => Result_1 } | { a?: undefined; c: (_atom: null | { debugLabel?: string; read: (get: { <Value>(atom: Atom<Value | Promise<Value>>): Value; <Value_1>(atom: Atom<Promise<Value_1>>): Value_1; <Value_2>(atom: Atom<Value_2>): Value_2 extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? any : V : V : V : V : V : V : V : V : V : V : Value_2 }) => unknown; toString: () => string }, version?: VersionObject) => void; h: (values: Iterable<readonly [{ debugLabel?: string; read: (get: { <Value>(atom: Atom<Value | Promise<Value>>): Value; <Value_1>(atom: Atom<Promise<Value_1>>): Value_1; <Value_2>(atom: Atom<Value_2>): Value_2 extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? any : V : V : V : V : V : V : V : V : V : V : Value_2 }) => unknown; toString: () => string }, unknown]>, version?: VersionObject) => void; l?: undefined; m?: undefined; n?: undefined; r: <Value_5>(readingAtom: Atom<Value_5>, version?: VersionObject) => AtomState<Value_5>; s: (atom: { debugLabel?: string; read: (get: { <Value>(atom: Atom<Value | Promise<Value>>): Value; <Value_1>(atom: Atom<Promise<Value_1>>): Value_1; <Value_2>(atom: Atom<Value_2>): Value_2 extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? any : V : V : V : V : V : V : V : V : V : V : Value_2 }) => unknown; toString: () => string }, callback: (version?: VersionObject) => void) => () => void; w: <Value_1_2, Update_2, Result_2>(writingAtom: WritableAtom<Value_1_2, Update_2, Result_2>, update: Update_2, version?: VersionObject) => Result_2 }; asyncGet: <Value_1>(atom: Atom<Value_1>) => Promise<Value_1 extends Promise<V_1> ? V_1 extends Promise<V_1> ? V_1 extends Promise<V_1> ? V_1 extends Promise<V_1> ? V_1 extends Promise<V_1> ? V_1 extends Promise<V_1> ? V_1 extends Promise<V_1> ? V_1 extends Promise<V_1> ? V_1 extends Promise<V_1> ? V_1 extends Promise<V_1> ? V_1 extends Promise<V_1> ? any : V_1 : V_1 : V_1 : V_1 : V_1 : V_1 : V_1 : V_1 : V_1 : V_1 : Value_1>; get: <Value_3>(atom: Atom<Value_3>) => undefined | (Value_3 extends Promise<V_1> ? V_1 extends Promise<V_1> ? V_1 extends Promise<V_1> ? V_1 extends Promise<V_1> ? V_1 extends Promise<V_1> ? V_1 extends Promise<V_1> ? V_1 extends Promise<V_1> ? V_1 extends Promise<V_1> ? V_1 extends Promise<V_1> ? V_1 extends Promise<V_1> ? V_1 extends Promise<V_1> ? any : V_1 : V_1 : V_1 : V_1 : V_1 : V_1 : V_1 : V_1 : V_1 : V_1 : Value_3); set: <Value_2, Update, Result>(atom: WritableAtom<Value_2, Update, Result>, update: Update) => Result; sub: (atom: { debugLabel?: string; read: (get: { <Value>(atom: Atom<Value | Promise<Value>>): Value; <Value_1>(atom: Atom<Promise<Value_1>>): Value_1; <Value_2>(atom: Atom<Value_2>): Value_2 extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? any : V : V : V : V : V : V : V : V : V : V : Value_2 }) => unknown; toString: () => string }, callback: () => void) => () => void }; unstable_enableVersionedWrite?: boolean } & { children?: ReactNode } & { element: TElement }): Element

- Defined in packages/core/dist/atoms/elementAtom.d.ts:30
Parameters
- __namedParameters: { initialValues?: Iterable<readonly [Atom<unknown>, unknown]>; scope?: Scope; unstable_createStore?: (initialValues?: Iterable<readonly [{ debugLabel?: string; read: (get: { <Value>(atom: Atom<Value | Promise<Value>>): Value; <Value_1>(atom: Atom<Promise<Value_1>>): Value_1; <Value_2>(atom: Atom<Value_2>): Value_2 extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? any : V : V : V : V : V : V : V : V : V : V : Value_2 }) => unknown; toString: () => string }, unknown]>) => { SECRET_INTERNAL_store: { a: (a: { debugLabel?: string; read: (get: { <Value>(atom: Atom<Value | Promise<Value>>): Value; <Value_1>(atom: Atom<Promise<Value_1>>): Value_1; <Value_2>(atom: Atom<Value_2>): Value_2 extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? any : V : V : V : V : V : V : V : V : V : V : Value_2 }) => unknown; toString: () => string }) => undefined | AtomState<unknown>; c: (_atom: null | { debugLabel?: string; read: (get: { <Value>(atom: Atom<Value | Promise<Value>>): Value; <Value_1>(atom: Atom<Promise<Value_1>>): Value_1; <Value_2>(atom: Atom<Value_2>): Value_2 extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? any : V : V : V : V : V : V : V : V : V : V : Value_2 }) => unknown; toString: () => string }, version?: VersionObject) => void; h: (values: Iterable<readonly [{ debugLabel?: string; read: (get: { <Value>(atom: Atom<Value | Promise<Value>>): Value; <Value_1>(atom: Atom<Promise<Value_1>>): Value_1; <Value_2>(atom: Atom<Value_2>): Value_2 extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? any : V : V : V : V : V : V : V : V : V : V : Value_2 }) => unknown; toString: () => string }, unknown]>, version?: VersionObject) => void; l: () => IterableIterator<{ debugLabel?: string; read: (get: { <Value>(atom: Atom<Value | Promise<Value>>): Value; <Value_1>(atom: Atom<Promise<Value_1>>): Value_1; <Value_2>(atom: Atom<Value_2>): Value_2 extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? any : V : V : V : V : V : V : V : V : V : V : Value_2 }) => unknown; toString: () => string }>; m: (a: { debugLabel?: string; read: (get: { <Value>(atom: Atom<Value | Promise<Value>>): Value; <Value_1>(atom: Atom<Promise<Value_1>>): Value_1; <Value_2>(atom: Atom<Value_2>): Value_2 extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? V extends Promise<V> ? any : V : V : V : V : V : V

Index

Enumerations

Interfaces

Type aliases

Variables

Functions

Type aliases

Alignment

AncestorOf

Type parameters

N: TNode

AnyFunction

Type declaration

Parameters

Rest ...args: any

Returns any

As

Type parameters

P = any

AsProps

Type parameters

T: As = As

Type declaration

Optional as?: T

Optional asChild?: boolean

AtomStoreApi

Type parameters

T

N: string = ""

AutoformatRule

Type parameters

V: Value = Value

E: PlateEditor<V> = PlateEditor<V>

CaretPosition

Type declaration

height: number

left: number

top: number

ChildOf

Type parameters

N: TNode

I: number = number

Children

Type parameters

T = any

ColorInputStyles

Type declaration

Optional input?: CSSProp

ColorType

Type declaration

isBrightColor: boolean

name: string

value: string

ComboboxOnSelectItem

Type parameters

TData

Type declaration

Type parameters

V: Value

Parameters

editor: PlateEditor<V>

item: TComboboxItem<TData>

Returns any

ComboboxState

Type parameters

TData = NoData

Type declaration

activeId: string | null

byId: Record<string, ComboboxStoreById>

filteredItems: TComboboxItem<TData>[]

highlightedIndex: number

items: TComboboxItem<TData>[]

Optional popperContainer?: Document | HTMLElement

Optional popperOptions?: any

targetRange: Range | null

text: string | null

ComboboxStateById

Type parameters

TData = NoData

Type declaration