@blueprintjs/core

@blueprintjs/core

Version 4.17.7
Published 4 days ago
5.5 MB
11 dependencies
Apache-2.0 license

Install

npm i @blueprintjs/core

yarn add @blueprintjs/core

pnpm add @blueprintjs/core

Overview

Core styles & components

Index

Variables

variable Alignment

const Alignment: { CENTER: 'center'; LEFT: 'left'; RIGHT: 'right' };

Alignment along the horizontal axis.

variable Blockquote

const Blockquote: React.FC<any>;

variable Boundary

const Boundary: { START: 'start'; END: 'end' };

Boundary of a one-dimensional interval.

const Breadcrumb: React.FC<IBreadcrumbProps>;

Breadcrumb component.
See Also
- https://blueprintjs.com/docs/#core/components/breadcrumbs

variable Code

const Code: React.FC<any>;

variable ContextMenu

const ContextMenu: typeof contextMenu;

variable DISPLAYNAME_PREFIX

const DISPLAYNAME_PREFIX: string;

variable Elevation

const Elevation: { ZERO: 0; ONE: 1; TWO: 2; THREE: 3; FOUR: 4 };

variable Expander

const Expander: React.FC;

variable FocusStyleManager

const FocusStyleManager: {
    alwaysShowFocus: () => boolean | void;
    isActive: () => boolean;
    onlyShowFocusOnTabs: () => boolean | void;
};

variable H1

const H1: React.FC<any>;

variable H2

const H2: React.FC<any>;

variable H3

const H3: React.FC<any>;

variable H4

const H4: React.FC<any>;

variable H5

const H5: React.FC<any>;

variable H6

const H6: React.FC<any>;

variable HandleInteractionKind

const HandleInteractionKind: { LOCK: 'lock'; PUSH: 'push'; NONE: 'none' };

variable HandleType

const HandleType: { FULL: 'full'; START: 'start'; END: 'end' };

variable HotkeysContext

const HotkeysContext: React.Context<HotkeysContextInstance>;

A React context used to register and deregister hotkeys as components are mounted and unmounted in an application. Users should take care to make sure that only _one_ of these is instantiated and used within an application, especially if using global hotkeys.
You will likely not be using this HotkeysContext directly, except in cases where you need to get a direct handle on an existing context instance for advanced use cases involving nested HotkeysProviders.
For more information, see the [HotkeysProvider documentation](https://blueprintjs.com/docs/#core/context/hotkeys-provider).

variable HotkeysDialog2

const HotkeysDialog2: React.FC<HotkeysDialog2Props>;

variable Intent

const Intent: {
    NONE: 'none';
    PRIMARY: 'primary';
    SUCCESS: 'success';
    WARNING: 'warning';
    DANGER: 'danger';
};

The four basic intents.

variable Label

const Label: React.FC<any>;

variable OL

const OL: React.FC<any>;

variable OverlayToaster

const OverlayToaster: typeof Toaster;

variable PanelStack2

const PanelStack2: PanelStack2Component;

Panel stack (v2) component.
See Also
- https://blueprintjs.com/docs/#core/components/panel-stack2 T type union of all possible panels in this stack

variable PopoverInteractionKind

const PopoverInteractionKind: {
    CLICK: 'click';
    CLICK_TARGET_ONLY: 'click-target';
    HOVER: 'hover';
    HOVER_TARGET_ONLY: 'hover-target';
};

variable PopoverPosition

const PopoverPosition: {
    AUTO: 'auto';
    AUTO_END: 'auto-end';
    AUTO_START: 'auto-start';
    BOTTOM: 'bottom';
    BOTTOM_LEFT: 'bottom-left';
    BOTTOM_RIGHT: 'bottom-right';
    LEFT: 'left';
    LEFT_BOTTOM: 'left-bottom';
    LEFT_TOP: 'left-top';
    RIGHT: 'right';
    RIGHT_BOTTOM: 'right-bottom';
    RIGHT_TOP: 'right-top';
    TOP: 'top';
    TOP_LEFT: 'top-left';
    TOP_RIGHT: 'top-right';
};

Position with "auto" values, used by Popover and Tooltip.

variable PortalContext

const PortalContext: React.Context<PortalContextOptions>;

A React context to set options for all portals in a given subtree. Do not use this PortalContext directly, instead use PortalProvider to set the options.

variable Position

const Position: {
    BOTTOM: 'bottom';
    BOTTOM_LEFT: 'bottom-left';
    BOTTOM_RIGHT: 'bottom-right';
    LEFT: 'left';
    LEFT_BOTTOM: 'left-bottom';
    LEFT_TOP: 'left-top';
    RIGHT: 'right';
    RIGHT_BOTTOM: 'right-bottom';
    RIGHT_TOP: 'right-top';
    TOP: 'top';
    TOP_LEFT: 'top-left';
    TOP_RIGHT: 'top-right';
};

variable Pre

const Pre: React.FC<any>;

variable UL

const UL: React.FC<any>;

Functions

function combineRefs

combineRefs: <T>(
    ref1: React.RefCallback<T>,
    ref2: React.RefCallback<T>
) => (instance: T | null) => void;

Deprecated
use mergeRefs() instead

function comboMatches

comboMatches: (a: IKeyCombo, b: IKeyCombo) => boolean;

function ContextMenuTarget

ContextMenuTarget: <T extends IConstructor<IContextMenuTargetComponent>>(
    WrappedComponent: T
) => {
    new (...args: any[]): {
        render():
            | React.ReactElement<any, string | React.JSXElementConstructor<any>>
            | null
            | undefined;
        renderContextMenu: (
            e: React.MouseEvent<HTMLElement, MouseEvent>
        ) => JSX.Element | undefined;
        onContextMenuClose?: (() => void) | undefined;
        context: any;
        setState<K extends never>(
            state:
                | {}
                | ((
                      prevState: Readonly<{}>,
                      props: Readonly<{}>
                  ) => {} | Pick<{}, K>)
                | Pick<{}, K>,
            callback?: (() => void) | undefined
        ): void;
        forceUpdate(callback?: (() => void) | undefined): void;
        readonly props: Readonly<{}> & Readonly<{ children?: React.ReactNode }>;
        state: Readonly<{}>;
        refs: { [key: string]: React.ReactInstance };
        componentDidMount?(): void;
        shouldComponentUpdate?(
            nextProps: Readonly<{}>,
            nextState: Readonly<{}>,
            nextContext: any
        ): boolean;
        componentWillUnmount?(): void;
        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
        getSnapshotBeforeUpdate?(
            prevProps: Readonly<{}>,
            prevState: Readonly<{}>
        ): any;
        componentDidUpdate?(
            prevProps: Readonly<{}>,
            prevState: Readonly<{}>,
            snapshot?: any
        ): void;
        componentWillMount?(): void;
        UNSAFE_componentWillMount?(): void;
        componentWillReceiveProps?(nextProps: Readonly<{}>, nextContext: any): void;
        UNSAFE_componentWillReceiveProps?(
            nextProps: Readonly<{}>,
            nextContext: any
        ): void;
        componentWillUpdate?(
            nextProps: Readonly<{}>,
            nextState: Readonly<{}>,
            nextContext: any
        ): void;
        UNSAFE_componentWillUpdate?(
            nextProps: Readonly<{}>,
            nextState: Readonly<{}>,
            nextContext: any
        ): void;
    };
    displayName: string;
} & T;

ContextMenuTarget decorator.
See Also
- https://blueprintjs.com/docs/#core/components/context-menu.decorator-usage
Deprecated
use ContextMenu2

function getKeyCombo

getKeyCombo: (e: KeyboardEvent) => IKeyCombo;

Determines the key combo object from the given keyboard event. Again, a key combo includes zero or more modifiers (represented by a bitmask) and one action key, which we determine from the e.which property of the keyboard event.

function getKeyComboString

getKeyComboString: (e: KeyboardEvent) => string;

Converts a keyboard event into a valid combo prop string

function getPositionIgnoreAngles

getPositionIgnoreAngles: (
    position: Position
) => 'left' | 'right' | 'bottom' | 'top';

function getRef

getRef: <T>(ref: T | React.RefObject<T> | null) => T | null;

function hideHotkeysDialog

hideHotkeysDialog: () => void;

function HotkeysProvider

HotkeysProvider: ({
    children,
    dialogProps,
    renderDialog,
    value,
}: HotkeysProviderProps) => JSX.Element;

Hotkeys context provider, necessary for the useHotkeys hook.
See Also
- https://blueprintjs.com/docs/#core/context/hotkeys-provider

function HotkeysTarget

HotkeysTarget: <T extends IConstructor<IHotkeysTargetComponent>>(
    WrappedComponent: T
) => {
    new (...args: any[]): {
        globalHotkeysEvents: HotkeysEvents;
        localHotkeysEvents: HotkeysEvents;
        componentDidMount(): void;
        componentWillUnmount(): void;
        render(): JSX.Element;
        renderHotkeys: () => React.ReactElement<
            IHotkeysProps,
            string | React.JSXElementConstructor<any>
        >;
        context: any;
        setState<K extends never>(
            state:
                | {}
                | ((
                      prevState: Readonly<{}>,
                      props: Readonly<{}>
                  ) => {} | Pick<{}, K>)
                | Pick<{}, K>,
            callback?: (() => void) | undefined
        ): void;
        forceUpdate(callback?: (() => void) | undefined): void;
        readonly props: Readonly<{}> & Readonly<{ children?: React.ReactNode }>;
        state: Readonly<{}>;
        refs: { [key: string]: React.ReactInstance };
        shouldComponentUpdate?(
            nextProps: Readonly<{}>,
            nextState: Readonly<{}>,
            nextContext: any
        ): boolean;
        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
        getSnapshotBeforeUpdate?(
            prevProps: Readonly<{}>,
            prevState: Readonly<{}>
        ): any;
        componentDidUpdate?(
            prevProps: Readonly<{}>,
            prevState: Readonly<{}>,
            snapshot?: any
        ): void;
        componentWillMount?(): void;
        UNSAFE_componentWillMount?(): void;
        componentWillReceiveProps?(nextProps: Readonly<{}>, nextContext: any): void;
        UNSAFE_componentWillReceiveProps?(
            nextProps: Readonly<{}>,
            nextContext: any
        ): void;
        componentWillUpdate?(
            nextProps: Readonly<{}>,
            nextState: Readonly<{}>,
            nextContext: any
        ): void;
        UNSAFE_componentWillUpdate?(
            nextProps: Readonly<{}>,
            nextState: Readonly<{}>,
            nextContext: any
        ): void;
    };
    displayName: string;
} & T;

Deprecated
use useHotkeys hook or <HotkeysTarget2> component

function HotkeysTarget2

HotkeysTarget2: ({
    children,
    hotkeys,
    options,
}: HotkeysTarget2Props) => JSX.Element;

Utility component which allows consumers to use the new useHotkeys hook inside React component classes. The implementation simply passes through to the hook.

function isPositionHorizontal

isPositionHorizontal: (position: Position) => boolean;

function isPositionVertical

isPositionVertical: (position: Position) => boolean;

function isRefCallback

isRefCallback: <T>(
    value: React.Ref<T> | undefined
) => value is React.RefCallback<T>;

function isRefObject

isRefObject: <T>(value: React.Ref<T> | undefined) => value is React.RefObject<T>;

function mergeRefs

mergeRefs: <T>(...refs: Array<React.Ref<T>>) => React.RefCallback<T>;

Utility for merging refs into one singular callback ref. If using in a functional component, would recomend using useMemo to preserve function identity.

function parseKeyCombo

parseKeyCombo: (combo: string) => IKeyCombo;

Converts a key combo string into a key combo object. Key combos include zero or more modifier keys, such as shift or alt, and exactly one action key, such as A, enter, or left.
For action keys that require a shift, e.g. @ or |, we inlude the necessary shift modifier and automatically convert the action key to the unshifted version. For example, @ is equivalent to shift+2.

function PortalProvider

PortalProvider: ({
    children,
    ...options
}: React.PropsWithChildren<PortalContextOptions>) => JSX.Element;

Portal context provider.
See Also
- https://blueprintjs.com/docs/#core/context/portal-provider

function refHandler

refHandler: <T extends HTMLElement, K extends string>(
    refTargetParent: { [k in K]: T },
    refTargetKey: K,
    refProp?: React.Ref<T> | undefined
) => React.RefCallback<T>;

Creates a ref handler which assigns the ref returned by React for a mounted component to a field on the target object. The target object is usually a component class.
If provided, it will also update the given refProp with the value of the ref.

function removeNonHTMLProps

removeNonHTMLProps: (
    props: { [key: string]: any },
    invalidProps?: string[],
    shouldMerge?: boolean
) => { [key: string]: any };

Typically applied to HTMLElements to filter out disallowed props. When applied to a Component, can filter props from being passed down to the children. Can also filter by a combined list of supplied prop keys and the denylist (only appropriate for HTMLElements).
Parameter props
The original props object to filter down.
Parameter invalidProps
If supplied, overwrites the default denylist.
Parameter shouldMerge
If true, will merge supplied invalidProps and denylist together.

function setHotkeysDialogProps

setHotkeysDialogProps: (props: Partial<IHotkeysDialogProps>) => void;

function setRef

setRef: <T>(refTarget: React.Ref<T> | undefined, ref: T | null) => void;

Assign the given ref to a target, either a React ref object or a callback which takes the ref as its first argument.

function useHotkeys

useHotkeys: (
    keys: readonly HotkeyConfig[],
    options?: UseHotkeysOptions
) => UseHotkeysReturnValue;

React hook to register global and local hotkeys for a component.
Parameter keys
list of hotkeys to configure
Parameter options
hook options
See Also
- https://blueprintjs.com/docs/#core/hooks/use-hotkeys

Classes

class AbstractComponent

abstract class AbstractComponent<P, S> extends React.Component<P, S> {}

An abstract component that Blueprint components can extend in order to add some common functionality like runtime props validation.
Deprecated
componentWillReceiveProps is deprecated in React 16.9; use AbstractComponent2 instead

constructor

constructor(props: {}, context?: any);

property clearTimeouts

clearTimeouts: () => void;

Clear all known timeouts.

property displayName

protected displayName: never;

Component displayName should be public static. This property exists to prevent incorrect usage.

method componentWillReceiveProps

componentWillReceiveProps: (
    nextProps: P & { children?: React.ReactNode }
) => void;

method componentWillUnmount

componentWillUnmount: () => void;

method setTimeout

setTimeout: (callback: () => void, timeout?: number) => () => void;

Set a timeout and remember its ID. All stored timeouts will be cleared when component unmounts.
Returns
a "cancel" function that will clear timeout when invoked.

method validateProps

protected validateProps: (_: P & { children?: React.ReactNode }) => void;

Ensures that the props specified for a component are valid. Implementations should check that props are valid and usually throw an Error if they are not. Implementations should not duplicate checks that the type system already guarantees.
This method should be used instead of React's [propTypes](https://facebook.github.io/react/docs/reusable-components.html#prop-validation) feature. Like propTypes, these runtime checks run only in development mode.

class AbstractComponent2

abstract class AbstractComponent2<P, S = {}, SS = {}> extends React.Component<
    P,
    S,
    SS
> {}

An abstract component that Blueprint components can extend in order to add some common functionality like runtime props validation.

constructor

constructor(props: {}, context?: any);

property cancelAnimationFrames

cancelAnimationFrames: () => void;

Clear all known animation frame requests.

property clearTimeouts

clearTimeouts: () => void;

Clear all known timeouts.

property componentWillMount

componentWillMount: never;

property componentWillReceiveProps

componentWillReceiveProps: never;

property componentWillUpdate

componentWillUpdate: never;

property displayName

protected displayName: never;

Component displayName should be public static. This property exists to prevent incorrect usage.

property getDerivedStateFromProps

getDerivedStateFromProps: never;

method componentDidUpdate

componentDidUpdate: (_prevProps: P, _prevState: S, _snapshot?: SS) => void;

method componentWillUnmount

componentWillUnmount: () => void;

method requestAnimationFrame

requestAnimationFrame: (callback: () => void) => () => void;

Request an animation frame and remember its ID. All pending requests will be canceled when component unmounts.
Returns
a "cancel" function that will cancel the request when invoked.

method setTimeout

setTimeout: (callback: () => void, timeout?: number) => () => void;

Set a timeout and remember its ID. All stored timeouts will be cleared when component unmounts.
Returns
a "cancel" function that will clear timeout when invoked.

method validateProps

protected validateProps: (_props: P) => void;

Ensures that the props specified for a component are valid. Implementations should check that props are valid and usually throw an Error if they are not. Implementations should not duplicate checks that the type system already guarantees.
This method should be used instead of React's [propTypes](https://facebook.github.io/react/docs/reusable-components.html#prop-validation) feature. Like propTypes, these runtime checks run only in development mode.

class AbstractPureComponent

abstract class AbstractPureComponent<P, S = {}> extends React.PureComponent<P, S> {}

An abstract component that Blueprint components can extend in order to add some common functionality like runtime props validation.
Deprecated
componentWillReceiveProps is deprecated in React 16.9; use AbstractPureComponent2 instead

constructor

constructor(props: {}, context?: any);

property clearTimeouts

clearTimeouts: () => void;

Clear all known timeouts.

property displayName

protected displayName: never;

Component displayName should be public static. This property exists to prevent incorrect usage.

method componentWillReceiveProps

componentWillReceiveProps: (
    nextProps: P & { children?: React.ReactNode }
) => void;

method componentWillUnmount

componentWillUnmount: () => void;

method setTimeout

setTimeout: (callback: () => void, timeout?: number) => () => void;

Set a timeout and remember its ID. All stored timeouts will be cleared when component unmounts.
Returns
a "cancel" function that will clear timeout when invoked.

method validateProps

protected validateProps: (_props: P & { children?: React.ReactNode }) => void;

Ensures that the props specified for a component are valid. Implementations should check that props are valid and usually throw an Error if they are not. Implementations should not duplicate checks that the type system already guarantees.
This method should be used instead of React's [propTypes](https://facebook.github.io/react/docs/reusable-components.html#prop-validation) feature. Like propTypes, these runtime checks run only in development mode.

class AbstractPureComponent2

abstract class AbstractPureComponent2<
    P,
    S = {},
    SS = {}
> extends React.PureComponent<P, S, SS> {}

An abstract component that Blueprint components can extend in order to add some common functionality like runtime props validation.

constructor

constructor(props: {}, context?: any);

property cancelAnimationFrames

cancelAnimationFrames: () => void;

Clear all known animation frame requests.

property clearTimeouts

clearTimeouts: () => void;

Clear all known timeouts.

property componentWillMount

componentWillMount: never;

property componentWillReceiveProps

componentWillReceiveProps: never;

property componentWillUpdate

componentWillUpdate: never;

property displayName

protected displayName: never;

Component displayName should be public static. This property exists to prevent incorrect usage.

property getDerivedStateFromProps

getDerivedStateFromProps: never;

method componentDidUpdate

componentDidUpdate: (_prevProps: P, _prevState: S, _snapshot?: SS) => void;

method componentWillUnmount

componentWillUnmount: () => void;

method requestAnimationFrame

requestAnimationFrame: (callback: () => void) => () => void;

Request an animation frame and remember its ID. All pending requests will be canceled when component unmounts.
Returns
a "cancel" function that will cancel the request when invoked.

method setTimeout

setTimeout: (callback: () => void, timeout?: number) => () => void;

Set a timeout and remember its ID. All pending timeouts will be cleared when component unmounts.
Returns
a "cancel" function that will clear timeout when invoked.

method validateProps

protected validateProps: (_props: P) => void;

Ensures that the props specified for a component are valid. Implementations should check that props are valid and usually throw an Error if they are not. Implementations should not duplicate checks that the type system already guarantees.
This method should be used instead of React's [propTypes](https://facebook.github.io/react/docs/reusable-components.html#prop-validation) feature. Like propTypes, these runtime checks run only in development mode.

class Alert

class Alert extends AbstractPureComponent2<AlertProps> {}

Alert component.
See Also
- https://blueprintjs.com/docs/#core/components/alert

property defaultProps

static defaultProps: IAlertProps;

property displayName

static displayName: string;

method render

render: () => JSX.Element;

method validateProps

protected validateProps: (props: AlertProps) => void;

class AnchorButton

class AnchorButton extends AbstractButton<HTMLAnchorElement> {}

AnchorButton component.
See Also
- https://blueprintjs.com/docs/#core/components/button

property buttonRef

buttonRef: HTMLAnchorElement;

property displayName

static displayName: string;

property handleRef

protected handleRef: React.Ref<HTMLAnchorElement>;

method componentDidUpdate

componentDidUpdate: (prevProps: AnchorButtonProps) => void;

method render

render: () => JSX.Element;

class Breadcrumbs extends AbstractPureComponent2<BreadcrumbsProps> {}

Breadcrumbs component.
See Also
- https://blueprintjs.com/docs/#core/components/breadcrumbs
Deprecated
use { Breadcrumbs2 } from "@blueprintjs/popover2"

static defaultProps: Partial<IBreadcrumbsProps>;

render: () => JSX.Element;

class Button

class Button extends AbstractButton<HTMLButtonElement> {}

Button component.
See Also
- https://blueprintjs.com/docs/#core/components/button

property buttonRef

buttonRef: HTMLButtonElement;

property displayName

static displayName: string;

property handleRef

protected handleRef: React.Ref<HTMLButtonElement>;

method componentDidUpdate

componentDidUpdate: (prevProps: ButtonProps) => void;

method render

render: () => JSX.Element;

class ButtonGroup

class ButtonGroup extends AbstractPureComponent2<ButtonGroupProps> {}

Button group component.
See Also
- https://blueprintjs.com/docs/#core/components/button-group

property displayName

static displayName: string;

method render

render: () => JSX.Element;

class Callout

class Callout extends AbstractPureComponent2<CalloutProps> {}

Callout component.
See Also
- https://blueprintjs.com/docs/#core/components/callout

property displayName

static displayName: string;

method render

render: () => JSX.Element;

class Card

class Card extends AbstractPureComponent2<CardProps> {}

Card component.
See Also
- https://blueprintjs.com/docs/#core/components/card

property defaultProps

static defaultProps: ICardProps;

property displayName

static displayName: string;

method render

render: () => JSX.Element;

class Checkbox

class Checkbox extends AbstractPureComponent2<CheckboxProps, ICheckboxState> {}

Checkbox component.
See Also
- https://blueprintjs.com/docs/#core/components/checkbox

property displayName

static displayName: string;

property input

input: HTMLInputElement;

property state

state: ICheckboxState;

method componentDidMount

componentDidMount: () => void;

method componentDidUpdate

componentDidUpdate: (prevProps: CheckboxProps) => void;

method getDerivedStateFromProps

static getDerivedStateFromProps: ({
    indeterminate,
}: CheckboxProps) => ICheckboxState | null;

method render

render: () => JSX.Element;

class Collapse

class Collapse extends AbstractPureComponent2<CollapseProps, ICollapseState> {}

Collapse component.
See Also
- https://blueprintjs.com/docs/#core/components/collapse

property defaultProps

static defaultProps: Partial<ICollapseProps>;

property displayName

static displayName: string;

property state

state: ICollapseState;

method componentDidMount

componentDidMount: () => void;

method componentDidUpdate

componentDidUpdate: () => void;

method getDerivedStateFromProps

static getDerivedStateFromProps: (
    props: CollapseProps,
    state: ICollapseState
) =>
    | { animationState: AnimationStates; height?: undefined }
    | { animationState: AnimationStates; height: string }
    | null;

method render

render: () => React.ReactElement<any, any>;

class CollapsibleList

class CollapsibleList extends React.Component<CollapsibleListProps> {}

CollapsibleList component.
See Also
- https://blueprintjs.com/docs/#core/components/collapsible-list
Deprecated
use <OverflowList> for automatic overflow based on available space.

property defaultProps

static defaultProps: Partial<ICollapsibleListProps>;

property displayName

static displayName: string;

method render

render: () => JSX.Element;

class ControlGroup

class ControlGroup extends AbstractPureComponent2<ControlGroupProps> {}

Control group component.
See Also
- https://blueprintjs.com/docs/#core/components/control-group

property displayName

static displayName: string;

method render

render: () => JSX.Element;

class Dialog

class Dialog extends AbstractPureComponent2<DialogProps> {}

Dialog component.
See Also
- https://blueprintjs.com/docs/#core/components/dialog

constructor

constructor(props: IDialogProps);

property defaultProps

static defaultProps: IDialogProps;

property displayName

static displayName: string;

method render

render: () => JSX.Element;

method validateProps

protected validateProps: (props: DialogProps) => void;

class DialogBody

class DialogBody extends AbstractPureComponent2<DialogBodyProps> {}

Dialog body component.
See Also
- https://blueprintjs.com/docs/#core/components/dialog.dialog-body-props

property defaultProps

static defaultProps: DialogBodyProps;

method render

render: () => JSX.Element;

class DialogFooter

class DialogFooter extends AbstractPureComponent2<DialogFooterProps> {}

Dialog footer component.
See Also
- https://blueprintjs.com/docs/#core/components/dialog.dialog-footer-props

property defaultProps

static defaultProps: DialogFooterProps;

method render

render: () => JSX.Element;

class DialogStep

class DialogStep extends AbstractPureComponent2<DialogStepProps> {}

Dialog step component.
See Also
- https://blueprintjs.com/docs/#core/components/dialog.dialogstep

property displayName

static displayName: string;

method render

render: () => JSX.Element;

class Divider

class Divider extends AbstractPureComponent2<IDividerProps> {}

Divider component.
See Also
- https://blueprintjs.com/docs/#core/components/divider

property displayName

static displayName: string;

method render

render: () => JSX.Element;

class Drawer

class Drawer extends AbstractPureComponent2<DrawerProps> {}

Drawer component.
See Also
- https://blueprintjs.com/docs/#core/components/drawer

property defaultProps

static defaultProps: IDrawerProps;

property displayName

static displayName: string;

method render

render: () => JSX.Element;

method validateProps

protected validateProps: (props: DrawerProps) => void;

class EditableText

class EditableText extends AbstractPureComponent2<
    EditableTextProps,
    IEditableTextState
> {}

EditableText component.
See Also
- https://blueprintjs.com/docs/#core/components/editable-text

constructor

constructor(props: IEditableTextProps, context?: any);

property cancelEditing

cancelEditing: () => void;

property defaultProps

static defaultProps: IEditableTextProps;

property displayName

static displayName: string;

property toggleEditing

toggleEditing: () => void;

method componentDidMount

componentDidMount: () => void;

method componentDidUpdate

componentDidUpdate: (
    prevProps: EditableTextProps,
    prevState: IEditableTextState
) => void;

method render

render: () => JSX.Element;

class FileInput

class FileInput extends AbstractPureComponent2<FileInputProps> {}

File input component.
See Also
- https://blueprintjs.com/docs/#core/components/file-input

property defaultProps

static defaultProps: IFileInputProps;

property displayName

static displayName: string;

method render

render: () => JSX.Element;

class FormGroup

class FormGroup extends AbstractPureComponent2<FormGroupProps> {}

Form group component.
See Also
- https://blueprintjs.com/docs/#core/components/form-group

property displayName

static displayName: string;

method render

render: () => JSX.Element;

class Hotkey

class Hotkey extends AbstractPureComponent2<IHotkeyProps> {}

Hotkey component.
See Also
- https://blueprintjs.com/docs/#core/components/hotkeys

property defaultProps

static defaultProps: {
    allowInInput: boolean;
    disabled: boolean;
    global: boolean;
    preventDefault: boolean;
    stopPropagation: boolean;
};

property displayName

static displayName: string;

method render

render: () => JSX.Element;

method validateProps

protected validateProps: (props: IHotkeyProps) => void;

class Hotkeys

class Hotkeys extends AbstractPureComponent2<IHotkeysProps> {}

Hotkeys component.
See Also
- https://blueprintjs.com/docs/#core/components/hotkeys

property defaultProps

static defaultProps: { tabIndex: number };

property displayName

static displayName: string;

method render

render: () => JSX.Element | null;

method validateProps

protected validateProps: (
    props: IHotkeysProps & { children: React.ReactNode }
) => void;

class HTMLSelect

class HTMLSelect extends AbstractPureComponent2<HTMLSelectProps> {}

HTML select component
See Also
- https://blueprintjs.com/docs/#core/components/html-select

method render

render: () => JSX.Element;

class HTMLTable

class HTMLTable extends AbstractPureComponent2<HTMLTableProps> {}

HTML table component.
See Also
- https://blueprintjs.com/docs/#core/components/html-table

method render

render: () => JSX.Element;

class Icon

class Icon extends AbstractPureComponent2<
    IconProps & Omit<React.HTMLAttributes<HTMLElement>, 'title'>
> {}

Icon component.
See Also
- https://blueprintjs.com/docs/#core/components/icon

property displayName

static displayName: string;

method render

render: () => JSX.Element | null;

class InputGroup

class InputGroup extends AbstractPureComponent2<
    InputGroupProps2,
    IInputGroupState
> {}

Input group component.
See Also
- https://blueprintjs.com/docs/#core/components/text-inputs.input-group

property displayName

static displayName: string;

property state

state: IInputGroupState;

method componentDidMount

componentDidMount: () => void;

method componentDidUpdate

componentDidUpdate: (prevProps: InputGroupProps2) => void;

method render

render: () => React.ReactElement<{ className: string }, any>;

method validateProps

protected validateProps: (props: InputGroupProps2) => void;

class KeyCombo

class KeyCombo extends AbstractPureComponent2<KeyComboTagProps> {}

property displayName

static displayName: string;

method render

render: () => JSX.Element;

class Menu extends AbstractPureComponent2<MenuProps> {}

Menu component.
See Also
- https://blueprintjs.com/docs/#core/components/menu

static displayName: string;

render: () => JSX.Element;

class MenuDivider

class MenuDivider extends React.Component<MenuDividerProps> {}

Menu divider component.
See Also
- https://blueprintjs.com/docs/#core/components/menu.menu-divider

property displayName

static displayName: string;

method render

render: () => JSX.Element;

class MenuItem

class MenuItem extends AbstractPureComponent2<
    MenuItemProps & React.AnchorHTMLAttributes<HTMLAnchorElement>
> {}

Menu item component.
See Also
- https://blueprintjs.com/docs/#core/components/menu.menu-item

property defaultProps

static defaultProps: MenuItemProps;

property displayName

static displayName: string;

method render

render: () => JSX.Element;

class MultiSlider

class MultiSlider extends AbstractPureComponent2<MultiSliderProps, ISliderState> {}

Multi slider component.
See Also
- https://blueprintjs.com/docs/#core/components/sliders.multi-slider

property defaultProps

static defaultProps: IMultiSliderProps;

property defaultSliderProps

static defaultSliderProps: ISliderBaseProps;

property displayName

static displayName: string;

property Handle

static Handle: React.FC<IHandleProps>;

property state

state: ISliderState;

method componentDidMount

componentDidMount: () => void;

method componentDidUpdate

componentDidUpdate: (
    prevProps: MultiSliderProps,
    prevState: ISliderState
) => void;

method getDerivedStateFromProps

static getDerivedStateFromProps: (props: MultiSliderProps) => {
    labelPrecision: number;
};

method getSnapshotBeforeUpdate

getSnapshotBeforeUpdate: (prevProps: MultiSliderProps) => null;

method render

render: () => JSX.Element;

method validateProps

protected validateProps: (
    props: React.PropsWithChildren<IMultiSliderProps>
) => void;

class MultistepDialog

class MultistepDialog extends AbstractPureComponent2<
    MultistepDialogProps,
    IMultistepDialogState
> {}

Multi-step dialog component.
See Also
- https://blueprintjs.com/docs/#core/components/dialog.multistep-dialog

property defaultProps

static defaultProps: Partial<IMultistepDialogProps>;

property displayName

static displayName: string;

property state

state: IMultistepDialogState;

method componentDidUpdate

componentDidUpdate: (prevProps: MultistepDialogProps) => void;

method render

render: () => JSX.Element;

class Navbar extends AbstractPureComponent2<NavbarProps> {}

Navbar component.
See Also
- https://blueprintjs.com/docs/#core/components/navbar

static displayName: string;

static Divider: typeof NavbarDivider;

static Group: typeof NavbarGroup;

static Heading: typeof NavbarHeading;

render: () => JSX.Element;

class NavbarDivider

class NavbarDivider extends AbstractPureComponent2<NavbarDividerProps> {}

property displayName

static displayName: string;

method render

render: () => JSX.Element;

class NavbarGroup

class NavbarGroup extends AbstractPureComponent2<NavbarGroupProps> {}

property defaultProps

static defaultProps: INavbarGroupProps;

property displayName

static displayName: string;

method render

render: () => JSX.Element;

class NavbarHeading

class NavbarHeading extends AbstractPureComponent2<NavbarHeadingProps> {}

property displayName

static displayName: string;

method render

render: () => JSX.Element;

class NonIdealState

class NonIdealState extends AbstractPureComponent2<NonIdealStateProps> {}

Non-ideal state component.
See Also
- https://blueprintjs.com/docs/#core/components/non-ideal-state

property defaultProps

static defaultProps: Partial<INonIdealStateProps>;

property displayName

static displayName: string;

method render

render: () => JSX.Element;

class NumericInput

class NumericInput extends AbstractPureComponent2<
    HTMLInputProps & NumericInputProps,
    INumericInputState
> {}

Numeric input component.
See Also
- https://blueprintjs.com/docs/#core/components/numeric-input

property defaultProps

static defaultProps: INumericInputProps;

property displayName

static displayName: string;

property inputElement

inputElement: HTMLInputElement;

property state

state: INumericInputState;

property VALUE_EMPTY

static VALUE_EMPTY: string;

property VALUE_ZERO

static VALUE_ZERO: string;

method componentDidUpdate

componentDidUpdate: (
    prevProps: NumericInputProps,
    prevState: INumericInputState
) => void;

method getDerivedStateFromProps

static getDerivedStateFromProps: (
    props: NumericInputProps,
    state: INumericInputState
) => {
    stepMaxPrecision: number;
    value: string;
    prevMaxProp: number | undefined;
    prevMinProp: number | undefined;
};

method render

render: () => JSX.Element;

method validateProps

protected validateProps: (nextProps: HTMLInputProps & NumericInputProps) => void;

class OverflowList

class OverflowList<T> extends React.Component<
    OverflowListProps<T>,
    IOverflowListState<T>
> {}

Overflow list component.
See Also
- https://blueprintjs.com/docs/#core/components/overflow-list

property defaultProps

static defaultProps: Partial<OverflowListProps<any>>;

property displayName

static displayName: string;

property state

state: IOverflowListState<T>;

method componentDidMount

componentDidMount: () => void;

method componentDidUpdate

componentDidUpdate: (
    prevProps: OverflowListProps<T>,
    prevState: IOverflowListState<T>
) => void;

method ofType

static ofType: <U>() => new (props: OverflowListProps<U>) => OverflowList<U>;

method render

render: () => JSX.Element;

method shouldComponentUpdate

shouldComponentUpdate: (
    nextProps: OverflowListProps<T>,
    nextState: IOverflowListState<T>
) => boolean;

class Overlay

class Overlay extends AbstractPureComponent2<OverlayProps, IOverlayState> {}

Overlay component.
See Also
- https://blueprintjs.com/docs/#core/components/overlay

property containerElement

containerElement: HTMLElement;

property defaultProps

static defaultProps: IOverlayProps;

property displayName

static displayName: string;

property state

state: IOverlayState;

method componentDidMount

componentDidMount: () => void;

method componentDidUpdate

componentDidUpdate: (prevProps: OverlayProps) => void;

method componentWillUnmount

componentWillUnmount: () => void;

method getDerivedStateFromProps

static getDerivedStateFromProps: ({
    isOpen: hasEverOpened,
}: OverlayProps) => { hasEverOpened: true } | null;

method render

render: () => JSX.Element | null;

class PanelStack

class PanelStack extends AbstractPureComponent2<
    IPanelStackProps,
    IPanelStackState
> {}

Panel stack component.
See Also
- https://blueprintjs.com/docs/#core/components/panel-stack
Deprecated
use PanelStack2<T>

property state

state: IPanelStackState;

method componentDidUpdate

componentDidUpdate: (
    prevProps: IPanelStackProps,
    prevState: IPanelStackState
) => void;

method render

render: () => JSX.Element;

method validateProps

protected validateProps: (props: IPanelStackProps) => void;

class Popover extends AbstractPureComponent2<IPopoverProps, IPopoverState> {}

Popover component.
See Also
- https://blueprintjs.com/docs/#core/components/popover
Deprecated
use { Popover2 } from "@blueprintjs/popover2"

property defaultProps

static defaultProps: IPopoverProps;

property displayName

static displayName: string;

property popoverElement

popoverElement: HTMLElement;

DOM element that contains the popover. When usePortal={true}, this element will be portaled outside the usual DOM flow, so this reference can be very useful for testing.

property reposition

reposition: () => void | undefined;

Instance method to instruct the Popover to recompute its position.
This method should only be used if you are updating the target in a way that does not cause it to re-render, such as changing its _position_ without changing its _size_ (since Popover already repositions when it detects a resize).

property state

state: IPopoverState;

property targetElement

targetElement: HTMLElement;

DOM element that contains the target.

method componentDidMount

componentDidMount: () => void;

method componentDidUpdate

componentDidUpdate: (prevProps: IPopoverProps, prevState: IPopoverState) => void;

method render

render: () => JSX.Element;

method validateProps

protected validateProps: (
    props: IPopoverProps & { children?: React.ReactNode }
) => void;

class Portal

class Portal extends React.Component<PortalProps, IPortalState> {}

Portal component.
This component detaches its contents and re-attaches them to document.body. Use it when you need to circumvent DOM z-stacking (for dialogs, popovers, etc.). Any class names passed to this element will be propagated to the new container element on document.body.
See Also
- https://blueprintjs.com/docs/#core/components/portal

property context

context: PortalLegacyContext;

property contextTypes

static contextTypes: ValidationMap<PortalLegacyContext>;

property defaultProps

static defaultProps: Partial<IPortalProps>;

property displayName

static displayName: string;

property state

state: IPortalState;

method componentDidMount

componentDidMount: () => void;

method componentDidUpdate

componentDidUpdate: (prevProps: PortalProps) => void;

method componentWillUnmount

componentWillUnmount: () => void;

method render

render: () => React.ReactPortal | null;

class ProgressBar

class ProgressBar extends AbstractPureComponent2<ProgressBarProps> {}

Progress bar component.
See Also
- https://blueprintjs.com/docs/#core/components/progress-bar

property displayName

static displayName: string;

method render

render: () => JSX.Element;

class Radio

class Radio extends AbstractPureComponent2<RadioProps> {}

Radio component.
See Also
- https://blueprintjs.com/docs/#core/components/radio

property displayName

static displayName: string;

method render

render: () => JSX.Element;

class RadioGroup

class RadioGroup extends AbstractPureComponent2<RadioGroupProps> {}

Radio group component.
See Also
- https://blueprintjs.com/docs/#core/components/radio.radiogroup

property displayName

static displayName: string;

method render

render: () => JSX.Element;

method validateProps

protected validateProps: () => void;

class RangeSlider

class RangeSlider extends AbstractPureComponent2<RangeSliderProps> {}

Range slider component.
See Also
- https://blueprintjs.com/docs/#core/components/sliders.range-slider

property defaultProps

static defaultProps: IRangeSliderProps;

property displayName

static displayName: string;

method render

render: () => JSX.Element;

method validateProps

protected validateProps: (props: RangeSliderProps) => void;

class ResizeSensor

class ResizeSensor extends AbstractPureComponent2<ResizeSensorProps> {}

Resize sensor component.
It requires a single DOM element child and will error otherwise.
See Also
- https://blueprintjs.com/docs/#core/components/resize-sensor

property displayName

static displayName: string;

method componentDidMount

componentDidMount: () => void;

method componentDidUpdate

componentDidUpdate: (prevProps: ResizeSensorProps) => void;

method componentWillUnmount

componentWillUnmount: () => void;

method render

render: () => React.ReactNode;

class Slider

class Slider extends AbstractPureComponent2<SliderProps> {}

Slider component.
See Also
- https://blueprintjs.com/docs/#core/components/sliders.slider

property defaultProps

static defaultProps: ISliderProps;

property displayName

static displayName: string;

method render

render: () => JSX.Element;

class Spinner

class Spinner extends AbstractPureComponent2<SpinnerProps> {}

Spinner component.
See Also
- https://blueprintjs.com/docs/#core/components/spinner

property displayName

static displayName: string;

method componentDidUpdate

componentDidUpdate: (prevProps: SpinnerProps) => void;

method render

render: () => React.DOMElement<
    | {
          size?: number | undefined;
          defaultChecked?: boolean | undefined;
          defaultValue?: string | number | readonly string[] | undefined;
          suppressContentEditableWarning?: boolean | undefined;
          suppressHydrationWarning?: boolean | undefined;
          accessKey?: string | undefined;
          contentEditable?: (boolean | 'true' | 'false') | 'inherit' | undefined;
          contextMenu?: string | undefined;
          dir?: string | undefined;
          draggable?: (boolean | 'true' | 'false') | undefined;
          hidden?: boolean | undefined;
          id?: string | undefined;
          lang?: string | undefined;
          placeholder?: string | undefined;
          slot?: string | undefined;
          spellCheck?: (boolean | 'true' | 'false') | undefined;
          style?: React.CSSProperties | undefined;
          tabIndex?: number | undefined;
          title?: string | undefined;
          translate?: 'yes' | 'no' | undefined;
          radioGroup?: string | undefined;
          role: string;
          about?: string | undefined;
          datatype?: string | undefined;
          inlist?: any;
          prefix?: string | undefined;
          property?: string | undefined;
          resource?: string | undefined;
          typeof?: string | undefined;
          vocab?: string | undefined;
          autoCapitalize?: string | undefined;
          autoCorrect?: string | undefined;
          autoSave?: string | undefined;
          color?: string | undefined;
          itemProp?: string | undefined;
          itemScope?: boolean | undefined;
          itemType?: string | undefined;
          itemID?: string | undefined;
          itemRef?: string | undefined;
          results?: number | undefined;
          security?: string | undefined;
          unselectable?: 'on' | 'off' | undefined;
          inputMode?:
              | 'none'
              | 'text'
              | 'search'
              | 'tel'
              | 'url'
              | 'email'
              | 'numeric'
              | 'decimal'
              | undefined;
          is?: string | undefined;
          'aria-activedescendant'?: string | undefined;
          'aria-atomic'?: boolean | 'true' | 'false' | undefined;
          'aria-autocomplete'?: 'none' | 'list' | 'inline' | 'both' | undefined;
          'aria-busy'?: boolean | 'true' | 'false' | undefined;
          'aria-checked'?: boolean | 'true' | 'false' | 'mixed' | undefined;
          'aria-colcount'?: number | undefined;
          'aria-colindex'?: number | undefined;
          'aria-colspan'?: number | undefined;
          'aria-controls'?: string | undefined;
          'aria-current'?:
              | boolean
              | 'time'
              | 'true'
              | 'false'
              | 'page'
              | 'step'
              | 'location'
              | 'date'
              | undefined;
          'aria-describedby'?: string | undefined;
          'aria-details'?: string | undefined;
          'aria-disabled'?: boolean | 'true' | 'false' | undefined;
          'aria-dropeffect'?:
              | 'none'
              | 'link'
              | 'move'
              | 'copy'
              | 'execute'
              | 'popup'
              | undefined;
          'aria-errormessage'?: string | undefined;
          'aria-expanded'?: boolean | 'true' | 'false' | undefined;
          'aria-flowto'?: string | undefined;
          'aria-grabbed'?: boolean | 'true' | 'false' | undefined;
          'aria-haspopup'?:
              | boolean
              | 'grid'
              | 'menu'
              | 'tree'
              | 'true'
              | 'false'
              | 'dialog'
              | 'listbox'
              | undefined;
          'aria-hidden'?: boolean | 'true' | 'false' | undefined;
          'aria-invalid'?:
              | boolean
              | 'true'
              | 'false'
              | 'grammar'
              | 'spelling'
              | undefined;
          'aria-keyshortcuts'?: string | undefined;
          'aria-label'?: string | undefined;
          'aria-labelledby'?: string | undefined;
          'aria-level'?: number | undefined;
          'aria-live'?: 'off' | 'assertive' | 'polite' | undefined;
          'aria-modal'?: boolean | 'true' | 'false' | undefined;
          'aria-multiline'?: boolean | 'true' | 'false' | undefined;
          'aria-multiselectable'?: boolean | 'true' | 'false' | undefined;
          'aria-orientation'?: 'horizontal' | 'vertical' | undefined;
          'aria-owns'?: string | undefined;
          'aria-placeholder'?: string | undefined;
          'aria-posinset'?: number | undefined;
          'aria-pressed'?: boolean | 'true' | 'false' | 'mixed' | undefined;
          'aria-readonly'?: boolean | 'true' | 'false' | undefined;
          'aria-relevant'?:
              | 'text'
              | 'additions'
              | 'additions removals'
              | 'additions text'
              | 'all'
              | 'removals'
              | 'removals additions'
              | 'removals text'
              | 'text additions'
              | 'text removals'
              | undefined;
          'aria-required'?: boolean | 'true' | 'false' | undefined;
          'aria-roledescription'?: string | undefined;
          'aria-rowcount'?: number | undefined;
          'aria-rowindex'?: number | undefined;
          'aria-rowspan'?: number | undefined;
          'aria-selected'?: boolean | 'true' | 'false' | undefined;
          'aria-setsize'?: number | undefined;
          'aria-sort'?:
              | 'none'
              | 'ascending'
              | 'descending'
              | 'other'
              | undefined;
          'aria-valuemax': number;
          'aria-valuemin': number;
          'aria-valuenow': number | undefined;
          'aria-valuetext'?: string | undefined;
          children?: React.ReactNode;
          dangerouslySetInnerHTML?: { __html: string } | undefined;
          onCopy?: React.ClipboardEventHandler<any> | undefined;
          onCopyCapture?: React.ClipboardEventHandler<any> | undefined;
          onCut?: React.ClipboardEventHandler<any> | undefined;
          onCutCapture?: React.ClipboardEventHandler<any> | undefined;
          onPaste?: React.ClipboardEventHandler<any> | undefined;
          onPasteCapture?: React.ClipboardEventHandler<any> | undefined;
          onCompositionEnd?: React.CompositionEventHandler<any> | undefined;
          onCompositionEndCapture?:
              | React.CompositionEventHandler<any>
              | undefined;
          onCompositionStart?: React.CompositionEventHandler<any> | undefined;
          onCompositionStartCapture?:
              | React.CompositionEventHandler<any>
              | undefined;
          onCompositionUpdate?: React.CompositionEventHandler<any> | undefined;
          onCompositionUpdateCapture?:
              | React.CompositionEventHandler<any>
              | undefined;
          onFocus?: React.FocusEventHandler<any> | undefined;
          onFocusCapture?: React.FocusEventHandler<any> | undefined;
          onBlur?: React.FocusEventHandler<any> | undefined;
          onBlurCapture?: React.FocusEventHandler<any> | undefined;
          onChange?: React.FormEventHandler<any> | undefined;
          onChangeCapture?: React.FormEventHandler<any> | undefined;
          onBeforeInput?: React.FormEventHandler<any> | undefined;
          onBeforeInputCapture?: React.FormEventHandler<any> | undefined;
          onInput?: React.FormEventHandler<any> | undefined;
          onInputCapture?: React.FormEventHandler<any> | undefined;
          onReset?: React.FormEventHandler<any> | undefined;
          onResetCapture?: React.FormEventHandler<any> | undefined;
          onSubmit?: React.FormEventHandler<any> | undefined;
          onSubmitCapture?: React.FormEventHandler<any> | undefined;
          onInvalid?: React.FormEventHandler<any> | undefined;
          onInvalidCapture?: React.FormEventHandler<any> | undefined;
          onLoad?: React.ReactEventHandler<any> | undefined;
          onLoadCapture?: React.ReactEventHandler<any> | undefined;
          onError?: React.ReactEventHandler<any> | undefined;
          onErrorCapture?: React.ReactEventHandler<any> | undefined;
          onKeyDown?: React.KeyboardEventHandler<any> | undefined;
          onKeyDownCapture?: React.KeyboardEventHandler<any> | undefined;
          onKeyPress?: React.KeyboardEventHandler<any> | undefined;
          onKeyPressCapture?: React.KeyboardEventHandler<any> | undefined;
          onKeyUp?: React.KeyboardEventHandler<any> | undefined;
          onKeyUpCapture?: React.KeyboardEventHandler<any> | undefined;
          onAbort?: React.ReactEventHandler<any> | undefined;
          onAbortCapture?: React.ReactEventHandler<any> | undefined;
          onCanPlay?: React.ReactEventHandler<any> | undefined;
          onCanPlayCapture?: React.ReactEventHandler<any> | undefined;
          onCanPlayThrough?: React.ReactEventHandler<any> | undefined;
          onCanPlayThroughCapture?: React.ReactEventHandler<any> | undefined;
          onDurationChange?: React.ReactEventHandler<any> | undefined;
          onDurationChangeCapture?: React.ReactEventHandler<any> | undefined;
          onEmptied?: React.ReactEventHandler<any> | undefined;
          onEmptiedCapture?: React.ReactEventHandler<any> | undefined;
          onEncrypted?: React.ReactEventHandler<any> | undefined;
          onEncryptedCapture?: React.ReactEventHandler<any> | undefined;
          onEnded?: React.ReactEventHandler<any> | undefined;
          onEndedCapture?: React.ReactEventHandler<any> | undefined;
          onLoadedData?: React.ReactEventHandler<any> | undefined;
          onLoadedDataCapture?: React.ReactEventHandler<any> | undefined;
          onLoadedMetadata?: React.ReactEventHandler<any> | undefined;
          onLoadedMetadataCapture?: React.ReactEventHandler<any> | undefined;
          onLoadStart?: React.ReactEventHandler<any> | undefined;
          onLoadStartCapture?: React.ReactEventHandler<any> | undefined;
          onPause?: React.ReactEventHandler<any> | undefined;
          onPauseCapture?: React.ReactEventHandler<any> | undefined;
          onPlay?: React.ReactEventHandler<any> | undefined;
          onPlayCapture?: React.ReactEventHandler<any> | undefined;
          onPlaying?: React.ReactEventHandler<any> | undefined;
          onPlayingCapture?: React.ReactEventHandler<any> | undefined;
          onProgress?: React.ReactEventHandler<any> | undefined;
          onProgressCapture?: React.ReactEventHandler<any> | undefined;
          onRateChange?: React.ReactEventHandler<any> | undefined;
          onRateChangeCapture?: React.ReactEventHandler<any> | undefined;
          onSeeked?: React.ReactEventHandler<any> | undefined;
          onSeekedCapture?: React.ReactEventHandler<any> | undefined;
          onSeeking?: React.ReactEventHandler<any> | undefined;
          onSeekingCapture?: React.ReactEventHandler<any> | undefined;
          onStalled?: React.ReactEventHandler<any> | undefined;
          onStalledCapture?: React.ReactEventHandler<any> | undefined;
          onSuspend?: React.ReactEventHandler<any> | undefined;
          onSuspendCapture?: React.ReactEventHandler<any> | undefined;
          onTimeUpdate?: React.ReactEventHandler<any> | undefined;
          onTimeUpdateCapture?: React.ReactEventHandler<any> | undefined;
          onVolumeChange?: React.ReactEventHandler<any> | undefined;
          onVolumeChangeCapture?: React.ReactEventHandler<any> | undefined;
          onWaiting?: React.ReactEventHandler<any> | undefined;
          onWaitingCapture?: React.ReactEventHandler<any> | undefined;
          onAuxClick?: React.MouseEventHandler<any> | undefined;
          onAuxClickCapture?: React.MouseEventHandler<any> | undefined;
          onClick?: React.MouseEventHandler<any> | undefined;
          onClickCapture?: React.MouseEventHandler<any> | undefined;
          onContextMenu?: React.MouseEventHandler<any> | undefined;
          onContextMenuCapture?: React.MouseEventHandler<any> | undefined;
          onDoubleClick?: React.MouseEventHandler<any> | undefined;
          onDoubleClickCapture?: React.MouseEventHandler<any> | undefined;
          onDrag?: React.DragEventHandler<any> | undefined;
          onDragCapture?: React.DragEventHandler<any> | undefined;
          onDragEnd?: React.DragEventHandler<any> | undefined;
          onDragEndCapture?: React.DragEventHandler<any> | undefined;
          onDragEnter?: React.DragEventHandler<any> | undefined;
          onDragEnterCapture?: Rea

@blueprintjs/core

Install

Overview

Index

Variables

Functions

Classes

Interfaces

Enums

Type Aliases

Namespaces

Variables

variable Alignment

variable Blockquote

variable Boundary

variable Breadcrumb

See Also

variable Code

variable ContextMenu

variable DISPLAYNAME_PREFIX

variable Elevation

variable Expander

variable FocusStyleManager

variable H1

variable H2

variable H3

variable H4

variable H5

variable H6

variable HandleInteractionKind

variable HandleType

variable HotkeysContext

variable HotkeysDialog2

variable Intent

variable Label

variable OL

variable OverlayToaster

variable PanelStack2

See Also

variable PopoverInteractionKind

variable PopoverPosition

variable PortalContext

variable Position

variable Pre

variable UL

Functions

function combineRefs

Deprecated

function comboMatches

function ContextMenuTarget

See Also

Deprecated

function getKeyCombo

function getKeyComboString

function getPositionIgnoreAngles

function getRef

function hideHotkeysDialog

function HotkeysProvider

See Also

function HotkeysTarget

Deprecated

function HotkeysTarget2

function isPositionHorizontal

function isPositionVertical

function isRefCallback

function isRefObject

function mergeRefs

function parseKeyCombo

function PortalProvider

See Also

function refHandler

function removeNonHTMLProps

Parameter props

Parameter invalidProps

Parameter shouldMerge

function setHotkeysDialogProps

function setRef

function useHotkeys

Parameter keys

Parameter options