Types

A collection of types.

Basics

KeyValue

type KeyValue = { [key: string]: string };

NativeRange

type NativeRange = Range;

NativeSelection

type NativeSelection = Selection;

TwoParts

type TwoParts = {
  start: Nodes | null;
  end: Nodes | null;
};

ThreeParts

type type ThreeParts = TwoParts & {
  center: Nodes | null;
};

Point

type Point = {
  node: Nodes;
  offset: number;
};

NodePath

type NodePath = number[];

ActiveItem

type ActiveItem = {
  node: Nodes;
  name: string;
  attributes: KeyValue;
  styles: KeyValue;
};

SelectionState

type SelectionState = {
  activeItems: ActiveItem[];
  disabledNameMap?: Map<string, boolean>;
  selectedNameMap?: Map<string, boolean>;
  selectedValuesMap?: Map<string, string[]>;
};

Box

BoxType

type BoxType = 'inline' | 'block';

BoxValue

type BoxValue = { [key: string]: any };

BoxRender

type BoxRender = (box: Box) => Nodes | string | void;

BoxHTML

type BoxHTML = (box: Box) => string;

BoxComponent

type BoxComponent = {
  type: BoxType;
  name: string;
  value?: BoxValue;
  render: BoxRender;
  html?: BoxHTML;
};

Command

CommandItem

type CommandItem = {
  isDisabled?: (activeItems: ActiveItem[]) => boolean;
  isSelected?: (activeItems: ActiveItem[]) => boolean;
  selectedValues?: (activeItems: ActiveItem[]) => string[];
  execute: (...data: any[]) => void;
};

Plugin

UnmountPlugin

type UnmountPlugin = () => void;

InitializePlugin

type InitializePlugin = (editor: Editor) => UnmountPlugin | void;

Button

ButtonConfig

type ButtonConfig = {
  // An element to which the button is appended.
  root: Nodes;
  // The name of the button.
  name: string;
  // The type of the button.
  type?: 'primary' | 'default';
  // The icon of the button.
  icon?: string;
  // The text of the button.
  text?: string;
  // The tooltip of the button.
  tooltip?: string;
  // The tab order of the button.
  tabIndex?: number;
  // The function triggered when clicked.
  onClick: () => void;
};

Dropdown

DropdownLocation

type DropdownLocation = 'local' | 'global';

DropdownDirection

type DropdownDirection = 'top' | 'bottom' | 'auto';

DropdownMenuType

type DropdownMenuType = 'list' | 'icon' | 'character' | 'color';

DropdownMenuItem

type DropdownMenuItem = {
  value: string;
  icon?: string;
  text: string | ((locale: TranslationFunctions) => string);
};

DropdownItem

type DropdownItem = {
  name: string;
  icon?: string;
  accentIcon?: string;
  downIcon?: string;
  defaultValue?: string;
  tooltip: string | ((locale: TranslationFunctions) => string);
  width?: string;
  menuType: DropdownMenuType;
  menuItems: DropdownMenuItem[];
  menuWidth?: string;
  menuHeight?: string;
  menuCheck?: boolean;
};

DropdownConfig

type DropdownConfig = DropdownItem & {
  root: Nodes;
  locale?: TranslationFunctions;
  tabIndex?: number;
  location?: DropdownLocation;
  direction?: DropdownDirection;
  onSelect: (value: string) => void;
};

Toolbar

ToolbarButtonItem

type ToolbarButtonItem = {
  name: string;
  type: 'button';
  icon?: string;
  tooltip: string | ((locale: TranslationFunctions) => string);
  isSelected?: (activeItems: ActiveItem[]) => boolean;
  isDisabled?: (activeItems: ActiveItem[]) => boolean;
  onClick: (editor: Editor, value: string) => void;
};

ToolbarDropdownItem

type ToolbarDropdownItem = DropdownItem & {
  name: string;
  type: 'dropdown';
  selectedValues?: (activeItems: ActiveItem[]) => string[];
  isDisabled?: (activeItems: ActiveItem[]) => boolean;
  onSelect: (editor: Editor, value: string) => void;
}

ToolbarUploadItem

type ToolbarUploadItem = {
  name: string;
  type: 'upload';
  icon?: string;
  tooltip: string | ((locale: TranslationFunctions) => string);
  accept?: string;
  multiple?: boolean;
};

ToolbarItem

type ToolbarItem = ToolbarButtonItem | ToolbarDropdownItem | ToolbarUploadItem;

CornerToolbarItem

type CornerToolbarItem = {
  name: string;
  icon?: string;
  tooltip: string | ((locale: TranslationFunctions) => string);
  onClick: (event: Event) => void;
};

Upload

BeforeUploadFileType

type BeforeUploadFileType = File | Blob | boolean | string;

UploadRequestMethod

type UploadRequestMethod = 'GET' | 'POST' | 'PUT' | 'PATCH';

UploadRequestHeader

type UploadRequestHeader = Record<string, string>;

UploadRequestError

interface UploadRequestError extends Error {
  status?: number;
  method?: UploadRequestMethod;
  url?: string;
}

UploadRequestOption

interface UploadRequestOption<T = any> {
  method: UploadRequestMethod;
  action: string;
  file?: Exclude<BeforeUploadFileType, File | boolean> | File;
  onSuccess?: (body: T, xhr?: XMLHttpRequest) => void;
  onProgress?: (event: ProgressEvent) => void;
  onError?: (event: UploadRequestError | ProgressEvent, body?: T) => void;
  data?: Record<string, unknown>;
  filename?: string;
  withCredentials?: boolean;
  headers?: UploadRequestHeader;
}