Options
All
  • Public
  • Public/Protected
  • All
Menu

Interface PlatePluginElement<T>

Type parameters

Hierarchy

Index

Properties

Properties

Optional decorate

decorate: Decorate<T>
see

Decorate

Optional deserialize

deserialize: Deserialize<T>
see

{@link DeserializeHtml}

Optional inlineTypes

inlineTypes: (editor: T) => string[]

Inline element types.

Type declaration

    • (editor: T): string[]
    • Parameters

      • editor: T

      Returns string[]

Optional onAbort

onAbort: (editor: T) => (event: SyntheticEvent<Element, Event>) => HandlerReturnType

Type declaration

Optional onAbortCapture

onAbortCapture: (editor: T) => (event: SyntheticEvent<Element, Event>) => HandlerReturnType

Type declaration

Optional onAnimationEnd

onAnimationEnd: (editor: T) => (event: AnimationEvent<Element>) => HandlerReturnType

Type declaration

Optional onAnimationEndCapture

onAnimationEndCapture: (editor: T) => (event: AnimationEvent<Element>) => HandlerReturnType

Type declaration

Optional onAnimationIteration

onAnimationIteration: (editor: T) => (event: AnimationEvent<Element>) => HandlerReturnType

Type declaration

Optional onAnimationIterationCapture

onAnimationIterationCapture: (editor: T) => (event: AnimationEvent<Element>) => HandlerReturnType

Type declaration

Optional onAnimationStart

onAnimationStart: (editor: T) => (event: AnimationEvent<Element>) => HandlerReturnType

Type declaration

Optional onAnimationStartCapture

onAnimationStartCapture: (editor: T) => (event: AnimationEvent<Element>) => HandlerReturnType

Type declaration

Optional onAuxClick

onAuxClick: (editor: T) => (event: MouseEvent<Element, MouseEvent>) => HandlerReturnType

Type declaration

Optional onAuxClickCapture

onAuxClickCapture: (editor: T) => (event: MouseEvent<Element, MouseEvent>) => HandlerReturnType

Type declaration

Optional onBeforeInput

onBeforeInput: (editor: T) => (event: FormEvent<Element>) => HandlerReturnType

Type declaration

Optional onBeforeInputCapture

onBeforeInputCapture: (editor: T) => (event: FormEvent<Element>) => HandlerReturnType

Type declaration

Optional onBlur

onBlur: (editor: T) => (event: FocusEvent<Element>) => HandlerReturnType

Type declaration

Optional onBlurCapture

onBlurCapture: (editor: T) => (event: FocusEvent<Element>) => HandlerReturnType

Type declaration

Optional onCanPlay

onCanPlay: (editor: T) => (event: SyntheticEvent<Element, Event>) => HandlerReturnType

Type declaration

Optional onCanPlayCapture

onCanPlayCapture: (editor: T) => (event: SyntheticEvent<Element, Event>) => HandlerReturnType

Type declaration

Optional onCanPlayThrough

onCanPlayThrough: (editor: T) => (event: SyntheticEvent<Element, Event>) => HandlerReturnType

Type declaration

Optional onCanPlayThroughCapture

onCanPlayThroughCapture: (editor: T) => (event: SyntheticEvent<Element, Event>) => HandlerReturnType

Type declaration

Optional onChange

onChange: OnChange<T>
see

OnChange

Optional onClick

onClick: (editor: T) => (event: MouseEvent<Element, MouseEvent>) => HandlerReturnType

Type declaration

Optional onClickCapture

onClickCapture: (editor: T) => (event: MouseEvent<Element, MouseEvent>) => HandlerReturnType

Type declaration

Optional onCompositionEnd

onCompositionEnd: (editor: T) => (event: CompositionEvent<Element>) => HandlerReturnType

Type declaration

Optional onCompositionEndCapture

onCompositionEndCapture: (editor: T) => (event: CompositionEvent<Element>) => HandlerReturnType

Type declaration

Optional onCompositionStart

onCompositionStart: (editor: T) => (event: CompositionEvent<Element>) => HandlerReturnType

Type declaration

Optional onCompositionStartCapture

onCompositionStartCapture: (editor: T) => (event: CompositionEvent<Element>) => HandlerReturnType

Type declaration

Optional onCompositionUpdate

onCompositionUpdate: (editor: T) => (event: CompositionEvent<Element>) => HandlerReturnType

Type declaration

Optional onCompositionUpdateCapture

onCompositionUpdateCapture: (editor: T) => (event: CompositionEvent<Element>) => HandlerReturnType

Type declaration

Optional onContextMenu

onContextMenu: (editor: T) => (event: MouseEvent<Element, MouseEvent>) => HandlerReturnType

Type declaration

Optional onContextMenuCapture

onContextMenuCapture: (editor: T) => (event: MouseEvent<Element, MouseEvent>) => HandlerReturnType

Type declaration

Optional onCopy

onCopy: (editor: T) => (event: ClipboardEvent<Element>) => HandlerReturnType

Type declaration

Optional onCopyCapture

onCopyCapture: (editor: T) => (event: ClipboardEvent<Element>) => HandlerReturnType

Type declaration

Optional onCut

onCut: (editor: T) => (event: ClipboardEvent<Element>) => HandlerReturnType

Type declaration

Optional onCutCapture

onCutCapture: (editor: T) => (event: ClipboardEvent<Element>) => HandlerReturnType

Type declaration

Optional onDOMBeforeInput

onDOMBeforeInput: (editor: T) => (event: Event) => HandlerReturnType

Type declaration

Optional onDoubleClick

onDoubleClick: (editor: T) => (event: MouseEvent<Element, MouseEvent>) => HandlerReturnType

Type declaration

Optional onDoubleClickCapture

onDoubleClickCapture: (editor: T) => (event: MouseEvent<Element, MouseEvent>) => HandlerReturnType

Type declaration

Optional onDrag

onDrag: (editor: T) => (event: DragEvent<Element>) => HandlerReturnType

Type declaration

Optional onDragCapture

onDragCapture: (editor: T) => (event: DragEvent<Element>) => HandlerReturnType

Type declaration

Optional onDragEnd

onDragEnd: (editor: T) => (event: DragEvent<Element>) => HandlerReturnType

Type declaration

Optional onDragEndCapture

onDragEndCapture: (editor: T) => (event: DragEvent<Element>) => HandlerReturnType

Type declaration

Optional onDragEnter

onDragEnter: (editor: T) => (event: DragEvent<Element>) => HandlerReturnType

Type declaration

Optional onDragEnterCapture

onDragEnterCapture: (editor: T) => (event: DragEvent<Element>) => HandlerReturnType

Type declaration

Optional onDragExit

onDragExit: (editor: T) => (event: DragEvent<Element>) => HandlerReturnType

Type declaration

Optional onDragExitCapture

onDragExitCapture: (editor: T) => (event: DragEvent<Element>) => HandlerReturnType

Type declaration

Optional onDragLeave

onDragLeave: (editor: T) => (event: DragEvent<Element>) => HandlerReturnType

Type declaration

Optional onDragLeaveCapture

onDragLeaveCapture: (editor: T) => (event: DragEvent<Element>) => HandlerReturnType

Type declaration

Optional onDragOver

onDragOver: (editor: T) => (event: DragEvent<Element>) => HandlerReturnType

Type declaration

Optional onDragOverCapture

onDragOverCapture: (editor: T) => (event: DragEvent<Element>) => HandlerReturnType

Type declaration

Optional onDragStart

onDragStart: (editor: T) => (event: DragEvent<Element>) => HandlerReturnType

Type declaration

Optional onDragStartCapture

onDragStartCapture: (editor: T) => (event: DragEvent<Element>) => HandlerReturnType

Type declaration

Optional onDrop

onDrop: (editor: T) => (event: DragEvent<Element>) => HandlerReturnType

Type declaration

Optional onDropCapture

onDropCapture: (editor: T) => (event: DragEvent<Element>) => HandlerReturnType

Type declaration

Optional onDurationChange

onDurationChange: (editor: T) => (event: SyntheticEvent<Element, Event>) => HandlerReturnType

Type declaration

Optional onDurationChangeCapture

onDurationChangeCapture: (editor: T) => (event: SyntheticEvent<Element, Event>) => HandlerReturnType

Type declaration

Optional onEmptied

onEmptied: (editor: T) => (event: SyntheticEvent<Element, Event>) => HandlerReturnType

Type declaration

Optional onEmptiedCapture

onEmptiedCapture: (editor: T) => (event: SyntheticEvent<Element, Event>) => HandlerReturnType

Type declaration

Optional onEncrypted

onEncrypted: (editor: T) => (event: SyntheticEvent<Element, Event>) => HandlerReturnType

Type declaration

Optional onEncryptedCapture

onEncryptedCapture: (editor: T) => (event: SyntheticEvent<Element, Event>) => HandlerReturnType

Type declaration

Optional onEnded

onEnded: (editor: T) => (event: SyntheticEvent<Element, Event>) => HandlerReturnType

Type declaration

Optional onEndedCapture

onEndedCapture: (editor: T) => (event: SyntheticEvent<Element, Event>) => HandlerReturnType

Type declaration

Optional onError

onError: (editor: T) => (event: SyntheticEvent<Element, Event>) => HandlerReturnType

Type declaration

Optional onErrorCapture

onErrorCapture: (editor: T) => (event: SyntheticEvent<Element, Event>) => HandlerReturnType

Type declaration

Optional onFocus

onFocus: (editor: T) => (event: FocusEvent<Element>) => HandlerReturnType

Type declaration

Optional onFocusCapture

onFocusCapture: (editor: T) => (event: FocusEvent<Element>) => HandlerReturnType

Type declaration

Optional onGotPointerCapture

onGotPointerCapture: (editor: T) => (event: PointerEvent<Element>) => HandlerReturnType

Type declaration

Optional onGotPointerCaptureCapture

onGotPointerCaptureCapture: (editor: T) => (event: PointerEvent<Element>) => HandlerReturnType

Type declaration

Optional onInput

onInput: (editor: T) => (event: FormEvent<Element>) => HandlerReturnType

Type declaration

Optional onInputCapture

onInputCapture: (editor: T) => (event: FormEvent<Element>) => HandlerReturnType

Type declaration

Optional onInvalid

onInvalid: (editor: T) => (event: FormEvent<Element>) => HandlerReturnType

Type declaration

Optional onInvalidCapture

onInvalidCapture: (editor: T) => (event: FormEvent<Element>) => HandlerReturnType

Type declaration

Optional onKeyDown

onKeyDown: (editor: T) => (event: KeyboardEvent<Element>) => HandlerReturnType

Type declaration

Optional onKeyDownCapture

onKeyDownCapture: (editor: T) => (event: KeyboardEvent<Element>) => HandlerReturnType

Type declaration

Optional onKeyPress

onKeyPress: (editor: T) => (event: KeyboardEvent<Element>) => HandlerReturnType

Type declaration

Optional onKeyPressCapture

onKeyPressCapture: (editor: T) => (event: KeyboardEvent<Element>) => HandlerReturnType

Type declaration

Optional onKeyUp

onKeyUp: (editor: T) => (event: KeyboardEvent<Element>) => HandlerReturnType

Type declaration

Optional onKeyUpCapture

onKeyUpCapture: (editor: T) => (event: KeyboardEvent<Element>) => HandlerReturnType

Type declaration

Optional onLoad

onLoad: (editor: T) => (event: SyntheticEvent<Element, Event>) => HandlerReturnType

Type declaration

Optional onLoadCapture

onLoadCapture: (editor: T) => (event: SyntheticEvent<Element, Event>) => HandlerReturnType

Type declaration

Optional onLoadStart

onLoadStart: (editor: T) => (event: SyntheticEvent<Element, Event>) => HandlerReturnType

Type declaration

Optional onLoadStartCapture

onLoadStartCapture: (editor: T) => (event: SyntheticEvent<Element, Event>) => HandlerReturnType

Type declaration

Optional onLoadedData

onLoadedData: (editor: T) => (event: SyntheticEvent<Element, Event>) => HandlerReturnType

Type declaration

Optional onLoadedDataCapture

onLoadedDataCapture: (editor: T) => (event: SyntheticEvent<Element, Event>) => HandlerReturnType

Type declaration

Optional onLoadedMetadata

onLoadedMetadata: (editor: T) => (event: SyntheticEvent<Element, Event>) => HandlerReturnType

Type declaration

Optional onLoadedMetadataCapture

onLoadedMetadataCapture: (editor: T) => (event: SyntheticEvent<Element, Event>) => HandlerReturnType

Type declaration

Optional onLostPointerCapture

onLostPointerCapture: (editor: T) => (event: PointerEvent<Element>) => HandlerReturnType

Type declaration

Optional onLostPointerCaptureCapture

onLostPointerCaptureCapture: (editor: T) => (event: PointerEvent<Element>) => HandlerReturnType

Type declaration

Optional onMouseDown

onMouseDown: (editor: T) => (event: MouseEvent<Element, MouseEvent>) => HandlerReturnType

Type declaration

Optional onMouseDownCapture

onMouseDownCapture: (editor: T) => (event: MouseEvent<Element, MouseEvent>) => HandlerReturnType

Type declaration

Optional onMouseEnter

onMouseEnter: (editor: T) => (event: MouseEvent<Element, MouseEvent>) => HandlerReturnType

Type declaration

Optional onMouseLeave

onMouseLeave: (editor: T) => (event: MouseEvent<Element, MouseEvent>) => HandlerReturnType

Type declaration

Optional onMouseMove

onMouseMove: (editor: T) => (event: MouseEvent<Element, MouseEvent>) => HandlerReturnType

Type declaration

Optional onMouseMoveCapture

onMouseMoveCapture: (editor: T) => (event: MouseEvent<Element, MouseEvent>) => HandlerReturnType

Type declaration

Optional onMouseOut

onMouseOut: (editor: T) => (event: MouseEvent<Element, MouseEvent>) => HandlerReturnType

Type declaration

Optional onMouseOutCapture

onMouseOutCapture: (editor: T) => (event: MouseEvent<Element, MouseEvent>) => HandlerReturnType

Type declaration

Optional onMouseOver

onMouseOver: (editor: T) => (event: MouseEvent<Element, MouseEvent>) => HandlerReturnType

Type declaration

Optional onMouseOverCapture

onMouseOverCapture: (editor: T) => (event: MouseEvent<Element, MouseEvent>) => HandlerReturnType

Type declaration

Optional onMouseUp

onMouseUp: (editor: T) => (event: MouseEvent<Element, MouseEvent>) => HandlerReturnType

Type declaration

Optional onMouseUpCapture

onMouseUpCapture: (editor: T) => (event: MouseEvent<Element, MouseEvent>) => HandlerReturnType

Type declaration

Optional onPaste

onPaste: (editor: T) => (event: ClipboardEvent<Element>) => HandlerReturnType

Type declaration

Optional onPasteCapture

onPasteCapture: (editor: T) => (event: ClipboardEvent<Element>) => HandlerReturnType

Type declaration

Optional onPause

onPause: (editor: T) => (event: SyntheticEvent<Element, Event>) => HandlerReturnType

Type declaration

Optional onPauseCapture

onPauseCapture: (editor: T) => (event: SyntheticEvent<Element, Event>) => HandlerReturnType

Type declaration

Optional onPlay

onPlay: (editor: T) => (event: SyntheticEvent<Element, Event>) => HandlerReturnType

Type declaration

Optional onPlayCapture

onPlayCapture: (editor: T) => (event: SyntheticEvent<Element, Event>) => HandlerReturnType

Type declaration

Optional onPlaying

onPlaying: (editor: T) => (event: SyntheticEvent<Element, Event>) => HandlerReturnType

Type declaration

Optional onPlayingCapture

onPlayingCapture: (editor: T) => (event: SyntheticEvent<Element, Event>) => HandlerReturnType

Type declaration

Optional onPointerCancel

onPointerCancel: (editor: T) => (event: PointerEvent<Element>) => HandlerReturnType

Type declaration

Optional onPointerCancelCapture

onPointerCancelCapture: (editor: T) => (event: PointerEvent<Element>) => HandlerReturnType

Type declaration

Optional onPointerDown

onPointerDown: (editor: T) => (event: PointerEvent<Element>) => HandlerReturnType

Type declaration

Optional onPointerDownCapture

onPointerDownCapture: (editor: T) => (event: PointerEvent<Element>) => HandlerReturnType

Type declaration

Optional onPointerEnter

onPointerEnter: (editor: T) => (event: PointerEvent<Element>) => HandlerReturnType

Type declaration

Optional onPointerEnterCapture

onPointerEnterCapture: (editor: T) => (event: PointerEvent<Element>) => HandlerReturnType

Type declaration

Optional onPointerLeave

onPointerLeave: (editor: T) => (event: PointerEvent<Element>) => HandlerReturnType

Type declaration

Optional onPointerLeaveCapture

onPointerLeaveCapture: (editor: T) => (event: PointerEvent<Element>) => HandlerReturnType

Type declaration

Optional onPointerMove

onPointerMove: (editor: T) => (event: PointerEvent<Element>) => HandlerReturnType

Type declaration

Optional onPointerMoveCapture

onPointerMoveCapture: (editor: T) => (event: PointerEvent<Element>) => HandlerReturnType

Type declaration

Optional onPointerOut

onPointerOut: (editor: T) => (event: PointerEvent<Element>) => HandlerReturnType

Type declaration

Optional onPointerOutCapture

onPointerOutCapture: (editor: T) => (event: PointerEvent<Element>) => HandlerReturnType

Type declaration

Optional onPointerOver

onPointerOver: (editor: T) => (event: PointerEvent<Element>) => HandlerReturnType

Type declaration

Optional onPointerOverCapture

onPointerOverCapture: (editor: T) => (event: PointerEvent<Element>) => HandlerReturnType

Type declaration

Optional onPointerUp

onPointerUp: (editor: T) => (event: PointerEvent<Element>) => HandlerReturnType

Type declaration

Optional onPointerUpCapture

onPointerUpCapture: (editor: T) => (event: PointerEvent<Element>) => HandlerReturnType

Type declaration

Optional onProgress

onProgress: (editor: T) => (event: SyntheticEvent<Element, Event>) => HandlerReturnType

Type declaration

Optional onProgressCapture

onProgressCapture: (editor: T) => (event: SyntheticEvent<Element, Event>) => HandlerReturnType

Type declaration

Optional onRateChange

onRateChange: (editor: T) => (event: SyntheticEvent<Element, Event>) => HandlerReturnType

Type declaration

Optional onRateChangeCapture

onRateChangeCapture: (editor: T) => (event: SyntheticEvent<Element, Event>) => HandlerReturnType

Type declaration

Optional onReset

onReset: (editor: T) => (event: FormEvent<Element>) => HandlerReturnType

Type declaration

Optional onResetCapture

onResetCapture: (editor: T) => (event: FormEvent<Element>) => HandlerReturnType

Type declaration

Optional onScroll

onScroll: (editor: T) => (event: UIEvent<Element, UIEvent>) => HandlerReturnType

Type declaration

Optional onScrollCapture

onScrollCapture: (editor: T) => (event: UIEvent<Element, UIEvent>) => HandlerReturnType

Type declaration

Optional onSeeked

onSeeked: (editor: T) => (event: SyntheticEvent<Element, Event>) => HandlerReturnType

Type declaration

Optional onSeekedCapture

onSeekedCapture: (editor: T) => (event: SyntheticEvent<Element, Event>) => HandlerReturnType

Type declaration

Optional onSeeking

onSeeking: (editor: T) => (event: SyntheticEvent<Element, Event>) => HandlerReturnType

Type declaration

Optional onSeekingCapture

onSeekingCapture: (editor: T) => (event: SyntheticEvent<Element, Event>) => HandlerReturnType

Type declaration

Optional onSelect

onSelect: (editor: T) => (event: SyntheticEvent<Element, Event>) => HandlerReturnType

Type declaration

Optional onSelectCapture

onSelectCapture: (editor: T) => (event: SyntheticEvent<Element, Event>) => HandlerReturnType

Type declaration

Optional onStalled

onStalled: (editor: T) => (event: SyntheticEvent<Element, Event>) => HandlerReturnType

Type declaration

Optional onStalledCapture

onStalledCapture: (editor: T) => (event: SyntheticEvent<Element, Event>) => HandlerReturnType

Type declaration

Optional onSubmit

onSubmit: (editor: T) => (event: FormEvent<Element>) => HandlerReturnType

Type declaration

Optional onSubmitCapture

onSubmitCapture: (editor: T) => (event: FormEvent<Element>) => HandlerReturnType

Type declaration

Optional onSuspend

onSuspend: (editor: T) => (event: SyntheticEvent<Element, Event>) => HandlerReturnType

Type declaration

Optional onSuspendCapture

onSuspendCapture: (editor: T) => (event: SyntheticEvent<Element, Event>) => HandlerReturnType

Type declaration

Optional onTimeUpdate

onTimeUpdate: (editor: T) => (event: SyntheticEvent<Element, Event>) => HandlerReturnType

Type declaration

Optional onTimeUpdateCapture

onTimeUpdateCapture: (editor: T) => (event: SyntheticEvent<Element, Event>) => HandlerReturnType

Type declaration

Optional onTouchCancel

onTouchCancel: (editor: T) => (event: TouchEvent<Element>) => HandlerReturnType

Type declaration

Optional onTouchCancelCapture

onTouchCancelCapture: (editor: T) => (event: TouchEvent<Element>) => HandlerReturnType

Type declaration

Optional onTouchEnd

onTouchEnd: (editor: T) => (event: TouchEvent<Element>) => HandlerReturnType

Type declaration

Optional onTouchEndCapture

onTouchEndCapture: (editor: T) => (event: TouchEvent<Element>) => HandlerReturnType

Type declaration

Optional onTouchMove

onTouchMove: (editor: T) => (event: TouchEvent<Element>) => HandlerReturnType

Type declaration

Optional onTouchMoveCapture

onTouchMoveCapture: (editor: T) => (event: TouchEvent<Element>) => HandlerReturnType

Type declaration

Optional onTouchStart

onTouchStart: (editor: T) => (event: TouchEvent<Element>) => HandlerReturnType

Type declaration

Optional onTouchStartCapture

onTouchStartCapture: (editor: T) => (event: TouchEvent<Element>) => HandlerReturnType

Type declaration

Optional onTransitionEnd

onTransitionEnd: (editor: T) => (event: TransitionEvent<Element>) => HandlerReturnType

Type declaration

Optional onTransitionEndCapture

onTransitionEndCapture: (editor: T) => (event: TransitionEvent<Element>) => HandlerReturnType

Type declaration

Optional onVolumeChange

onVolumeChange: (editor: T) => (event: SyntheticEvent<Element, Event>) => HandlerReturnType

Type declaration

Optional onVolumeChangeCapture

onVolumeChangeCapture: (editor: T) => (event: SyntheticEvent<Element, Event>) => HandlerReturnType

Type declaration

Optional onWaiting

onWaiting: (editor: T) => (event: SyntheticEvent<Element, Event>) => HandlerReturnType

Type declaration

Optional onWaitingCapture

onWaitingCapture: (editor: T) => (event: SyntheticEvent<Element, Event>) => HandlerReturnType

Type declaration

Optional onWheel

onWheel: (editor: T) => (event: WheelEvent<Element>) => HandlerReturnType

Type declaration

Optional onWheelCapture

onWheelCapture: (editor: T) => (event: WheelEvent<Element>) => HandlerReturnType

Type declaration

Optional overrideProps

overrideProps: OverrideProps<T>

Overrides rendered node props (shallow merge).

Optional pluginKeys

pluginKeys: string | string[]

Plugin keys to support configuration.

Optional renderElement

renderElement: RenderElement<T>

Optional serialize

serialize: Serialize
see

{@link SerializeHtml}

Optional voidTypes

voidTypes: (editor: T) => string[]

Void element types.

Type declaration

    • (editor: T): string[]
    • Parameters

      • editor: T

      Returns string[]

Optional withOverrides

withOverrides: WithOverride<T, {}> | WithOverride<T, {}>[]

Editor method overriders.

Generated using TypeDoc