Options
All
  • Public
  • Public/Protected
  • All
Menu

@udecode/plate - v13.5.0

Index

Enumerations

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

AnyFunction

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

Any function.

Type declaration

    • (...args: any): any
    • Parameters

      • Rest ...args: any

      Returns any

As

As<P>: ElementType<P>

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

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

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

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

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())

  • 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.

  • trigger: string

    Trigger that activates the combobox.

ComboboxStoreById

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

Type parameters

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

Type declaration

    • Type parameters

      • T: As<any> = NonNullable<O["as"]>

      Parameters

      Returns null | Element

    • Parameters

      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

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

Type declaration

DOMHandlerReturnType

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

Type parameters

  • EV = {}

Type declaration

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

DecorateEntry

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

Type parameters

Type declaration

    • Parameters

      Returns Range[] | undefined

DeepPartial

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

Type parameters

  • T

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

  • T

DefaultPlatePluginKey

DefaultPlatePluginKey: typeof ELEMENT_BLOCKQUOTE | typeof ELEMENT_CODE_BLOCK | typeof ELEMENT_CODE_LINE | typeof ELEMENT_H1 | typeof ELEMENT_H2 | typeof ELEMENT_H3 | typeof ELEMENT_H4 | typeof ELEMENT_H5 | typeof ELEMENT_H6 | typeof ELEMENT_IMAGE | typeof ELEMENT_LI | typeof ELEMENT_LINK | typeof ELEMENT_MEDIA_EMBED | typeof ELEMENT_MENTION | typeof ELEMENT_MENTION_INPUT | typeof ELEMENT_OL | typeof ELEMENT_PARAGRAPH | typeof ELEMENT_TABLE | typeof ELEMENT_TD | typeof ELEMENT_TH | typeof ELEMENT_TODO_LI | typeof ELEMENT_TR | typeof ELEMENT_UL | typeof MARK_BOLD | typeof MARK_CODE | typeof MARK_HIGHLIGHT | typeof MARK_ITALIC | typeof MARK_KBD | typeof MARK_SEARCH_HIGHLIGHT | typeof MARK_STRIKETHROUGH | typeof MARK_SUBSCRIPT | typeof MARK_SUPERSCRIPT | typeof MARK_UNDERLINE

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

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.

  • 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

DeserializeHtmlNodeReturnType

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

De

Type parameters

DropDirection

DropDirection: "top" | "bottom" | undefined

DropLineDirection

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

EAncestor

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

Ancestor of an editor.

Type parameters

EAncestorEntry

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

Ancestor entry from an editor.

Type parameters

EDescendant

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

Descendant of an editor.

Type parameters

EDescendantEntry

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

Descendant entry of a value.

Type parameters

EElement

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

Element of an editor.

Type parameters

EElementEntry

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

Element entry of a value.

Type parameters

EElementOrText

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

Element or text of an editor. Differs from EDescendant.

Type parameters

EMarks

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

Type parameters

ENode

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

Node of an editor.

Type parameters

ENodeEntry

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

Node entry from an editor.

Type parameters

ENodeMatch

ENodeMatch<N>: Predicate<N>

Type parameters

EText

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

Text node of an editor.

Type parameters

ETextEntry

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

Text node entry of a value.

Type parameters

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

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

FunctionProperties

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

Get the properties from an interface which are functions

Type parameters

  • T

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

  • T

GetAboveNodeOptions

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

Type parameters

GetLevelsOptions

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

Type parameters

GetMatchPointsReturnType

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

GetNextNodeOptions

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

Type parameters

GetNodeEntriesOptions

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

Type parameters

GetPreviousNodeOptions

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

Type parameters

GetTableGridAboveOptions

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

Type parameters

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

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

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'

InjectComponent

InjectComponent<V>: (props: InjectComponentProps<V>) => InjectComponentReturnType

Type parameters

Type declaration

InjectComponentReturnType

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

Type parameters

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

JotaiProviderProps

JotaiProviderProps: ComponentProps<typeof Provider>

KeyboardEventHandler

KeyboardEventHandler: (event: KeyboardEvent) => HandlerReturnType

Type declaration

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

MarkKeysOf

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

Type parameters

MarksOf

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

Type parameters

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

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

Modify

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

Type parameters

  • T

  • R

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

MoveListItemsOptions

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

Type declaration

MoveNodesOptions

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

Type parameters

NoData

NoData: undefined

NoInfer

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

Type parameters

  • T

NodeOf

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

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

Type parameters

Nullable

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

Type parameters

  • T

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

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

  • T

OverrideByKey

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

Type parameters

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

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

Type declaration

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

PlateRenderElementProps

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

Element props passed by Plate

Type parameters

PlateRenderLeafProps

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

Leaf props passed by Plate

Type parameters

PlateStoreApi

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

Type parameters

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

PlatesStoreState

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

Type parameters

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

PredicateFn

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

Type parameters

Type declaration

    • (obj: T, path: TPath): boolean
    • Parameters

      Returns boolean

PredicateObj

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

Props

Props<O>: O & HTMLProps<O>

AsProps & HTMLProps

example

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

Type parameters

RemoveNodesOptions

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

Type parameters

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

RenderElementFn

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

Type parameters

Type declaration

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

RenderLeafFn

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

Type parameters

Type declaration

RenderProp

RenderProp<P>: (props: P) => ReactNode

Render prop type.

example

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

Type parameters

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

SelectionRect

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

Type declaration

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

SerializeHtml

Type parameters

SetNodesOptions

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

Type parameters

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

  • T

SplitNodesOptions

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

Type parameters

StyledElementProps

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

Type parameters

StyledLeafProps

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

Type parameters

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

TComboboxItem

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

Type parameters

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

TEditableProps

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

Type parameters

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

TElementEntry

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

Element entry from a node.

Type parameters

THistoryEditor

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

Type parameters

TInsertNodeOperation

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

Type parameters

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

TNodeChildEntry

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

Child node entry from a node.

Type parameters

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

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

TNodeOperation

Type parameters

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

TOperation

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

TPath

TPath: Path

TRange

TRange: Range

TReactEditor

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

Type parameters

TRemoveNodeOperation

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

Type parameters

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

TRenderLeafProps

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

Type parameters

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

TTextOperation

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

TodoListElementProps

Type parameters

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>: (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never

Turn a union type into an intersection.

Type parameters

  • U

UnsetNodesOptions

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

Type parameters

UnwrapNodesOptions

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

Type parameters

UsePlateStoreEffects

UsePlateStoreEffects<V, E>: Pick<PlateProps<V, E>, "id" | "value" | "enabled" | "onChange" | "editableProps" | "plugins" | "decorate" | "renderElement" | "renderLeaf">

Type parameters

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

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

Type declaration

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

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

Const Button

  • Parameters

    Returns Element

Const ChevronDownIcon

  • Parameters

    Returns Element

Const CodeBlockElement

Const CodeBlockSelectElement

  • CodeBlockSelectElement(__namedParameters: { className?: string; css?: CSSProp<any>; lang?: string; onChange: Function }): null | Element
  • 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

Const CodeSyntaxLeaf

  • CodeSyntaxLeaf(props: any, defaultRender?: (props?: any) => null | Element): null | Element
  • 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
  • Parameters

    • __namedParameters: ColorButtonProps

    Returns Element

Const ColorInput

  • ColorInput(__namedParameters: PropsWithChildren<ColorInputProps>): Element
  • Parameters

    Returns Element

Const Colors

  • Colors(__namedParameters: ColorsProps): Element
  • Parameters

    • __namedParameters: ColorsProps

    Returns Element

Const Combobox

  • Combobox<TData>(__namedParameters: ComboboxProps<TData>): null | Element
  • Register the combobox id, trigger, onSelectItem Renders the combobox if active.

    Type parameters

    • TData: unknown = undefined

    Parameters

    Returns null | Element

Const Cursor

  • Parameters

    Returns null | Element

Const CursorOverlay

Const CursorOverlayContent

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

Const CustomColors

  • CustomColors(__namedParameters: CustomColorsProps): Element
  • Parameters

    • __namedParameters: CustomColorsProps

    Returns Element

Const DefaultLeaf

Const DeleteIcon

  • Parameters

    Returns Element

Const Divider

  • Divider(props: HTMLAttributes<HTMLDivElement>): Element
  • Parameters

    • props: HTMLAttributes<HTMLDivElement>

    Returns Element

Const Draggable

  • Type parameters

    Parameters

    Returns Element

Const EditablePlugins

  • {@link Editable} with plugins support.

    Type parameters

    Parameters

    Returns Element

Const EditorRefEffect

  • Parameters

    Returns Element

Const EditorRefPluginEffect

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
  • 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> ?