@atlaskit/editor-common 69.2.2 → 69.3.0

package/dist/types/types/type-ahead.d.ts

@@ -1,9 +1,35 @@
-import { ReactElement } from 'react';
+import type { ReactElement } from 'react';
+import { Fragment, Node as PMNode } from 'prosemirror-model';
+import { EditorState, Transaction } from 'prosemirror-state';
+import type { TypeAheadPayload } from '../analytics/types/type-ahead';
+import type { SelectItemMode, TypeAheadAvailableNodes } from '../type-ahead';
+declare type TypeAheadForceSelectProps = {
+    query: string;
+    items: Array<TypeAheadItem>;
+    editorState: EditorState;
+};
+export interface TypeAheadStats {
+    startedAt: number;
+    endedAt: number;
+    keyCount: {
+        arrowUp: number;
+        arrowDown: number;
+    };
+}
 export declare type TypeAheadItemRenderProps = {
     onClick: () => void;
     onHover: () => void;
     isSelected: boolean;
 };
+export declare type TypeAheadInsert = (node?: PMNode | Object | string | Fragment, opts?: {
+    selectInlineNode?: boolean;
+}) => Transaction;
+export declare type TypeAheadSelectItem = (state: EditorState, item: TypeAheadItem, insert: TypeAheadInsert, meta: {
+    mode: SelectItemMode;
+    stats: TypeAheadStats;
+    query: string;
+    sourceListItem: Array<TypeAheadItem>;
+}) => Transaction | false;
 export declare type TypeAheadItem = {
     title: string;
     description?: string;
@@ -13,3 +39,26 @@ export declare type TypeAheadItem = {
     render?: (props: TypeAheadItemRenderProps) => React.ReactElement<TypeAheadItemRenderProps> | null;
     [key: string]: any;
 };
+export declare type TypeAheadForceSelect = (props: TypeAheadForceSelectProps) => TypeAheadItem | undefined;
+export declare type TypeAheadHandler = {
+    id: TypeAheadAvailableNodes;
+    trigger: string;
+    customRegex?: string;
+    headless?: boolean;
+    forceSelect?: TypeAheadForceSelect;
+    onInvokeAnalytics?: TypeAheadPayload;
+    onOpen?: (editorState: EditorState) => void;
+    getItems: (props: {
+        query: string;
+        editorState: EditorState;
+    }) => Promise<Array<TypeAheadItem>>;
+    selectItem: TypeAheadSelectItem;
+    dismiss?: (props: {
+        editorState: EditorState;
+        query: string;
+        stats: TypeAheadStats;
+        wasItemInserted?: boolean;
+    }) => void;
+    getHighlight?: (state: EditorState) => JSX.Element | null;
+};
+export {};

package/dist/types/types/ui-components.d.ts

@@ -0,0 +1,22 @@
+import type React from 'react';
+import type { EditorView } from 'prosemirror-view';
+import type { DispatchAnalyticsEvent } from '../analytics/types/dispatch-analytics-event';
+import type { EventDispatcher } from '../event-dispatcher';
+import type { ProviderFactory } from '../provider-factory';
+import type { EditorActionsOptions } from './editor-actions';
+import type { EditorAppearance } from './editor-appearance';
+export declare type UiComponentFactoryParams = {
+    editorView: EditorView;
+    editorActions: EditorActionsOptions;
+    eventDispatcher: EventDispatcher;
+    dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
+    providerFactory: ProviderFactory;
+    appearance: EditorAppearance;
+    popupsMountPoint?: HTMLElement;
+    popupsBoundariesElement?: HTMLElement;
+    popupsScrollableElement?: HTMLElement;
+    containerElement: HTMLElement | null;
+    disabled: boolean;
+    wrapperElement: HTMLElement | null;
+};
+export declare type UIComponentFactory = (params: UiComponentFactoryParams) => React.ReactElement<any> | null;

package/dist/types/ui/DropList/index.d.ts

@@ -0,0 +1,19 @@
+/** @jsx jsx */
+import { Component, ReactNode } from 'react';
+import { WithAnalyticsEventsProps } from '@atlaskit/analytics-next';
+interface Props extends WithAnalyticsEventsProps {
+    isOpen?: boolean;
+    trigger?: typeof Component;
+    position: string;
+    onOpenChange?: (event: OpenChangedEvent) => void;
+    onPositioned?: () => void;
+    testId?: string;
+    shouldFitContainer: boolean;
+    children?: ReactNode;
+}
+export declare type OpenChangedEvent = {
+    isOpen: boolean;
+    event: MouseEvent | KeyboardEvent;
+};
+declare const _default: import("react").ForwardRefExoticComponent<Pick<Omit<Props, keyof WithAnalyticsEventsProps> & import("react").RefAttributes<any> & import("@atlaskit/analytics-next").WithContextProps, "children" | "key" | "position" | "trigger" | "testId" | "analyticsContext" | "isOpen" | "onPositioned" | "onOpenChange" | "shouldFitContainer"> & import("react").RefAttributes<any>>;
+export default _default;

package/dist/types/ui/ErrorBoundary/index.d.ts

@@ -0,0 +1,24 @@
+import React from 'react';
+import { ACTION, DispatchAnalyticsEvent, ErrorEventPayload } from '../../analytics';
+declare type ErrorCrashPayload = Extract<ErrorEventPayload, {
+    action: ACTION.EDITOR_CRASHED;
+}>;
+interface ErrorBoundaryProps {
+    component: ErrorCrashPayload['actionSubject'];
+    componentId?: ErrorCrashPayload['actionSubjectId'];
+    dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
+    fallbackComponent?: React.ReactNode;
+}
+interface ErrorBoundaryState {
+    errorCaptured: boolean;
+}
+export declare class ErrorBoundary extends React.Component<ErrorBoundaryProps, ErrorBoundaryState> {
+    state: {
+        errorCaptured: boolean;
+    };
+    hasFallback(): boolean;
+    shouldRecover(): boolean;
+    componentDidCatch(error: Error, errorInfo: React.ErrorInfo): void;
+    render(): React.ReactNode;
+}
+export {};

package/dist/types/ui/Layer/index.d.ts

@@ -0,0 +1,47 @@
+import { Component, ReactNode } from 'react';
+import { Data } from 'popper.js';
+export declare type Props = {
+    content: ReactNode | null;
+    offset: string;
+    position: string;
+    onPositioned: () => void;
+};
+export declare type State = {
+    hasExtractedStyles: boolean;
+    position?: string;
+    transform?: string;
+    offsets: {
+        popper: {
+            left: number;
+            top: number;
+        };
+    };
+    cssPosition: string;
+    originalHeight: number | null;
+    maxHeight: number | null;
+};
+export default class Layer extends Component<Props, State> {
+    private popper;
+    private targetRef;
+    private contentRef;
+    static defaultProps: {
+        boundariesElement: string;
+        children: null;
+        content: null;
+        offset: string;
+        position: string;
+        zIndex: number;
+        lockScroll: boolean;
+        isAlwaysFixed: boolean;
+        onPositioned: () => void;
+    };
+    constructor(props: Props);
+    componentDidMount(): void;
+    UNSAFE_componentWillReceiveProps(nextProps: Props): void;
+    componentDidUpdate(prevProps: Props, prevState: State): void;
+    componentWillUnmount(): void;
+    calculateMaxHeight(originalHeight: number, currentHeight: number, positionTop: number, cssPosition: string): number | null;
+    extractStyles: (state: Data) => void;
+    applyPopper(props: Props): void;
+    render(): JSX.Element;
+}

package/dist/types/ui/Layer/internal/helpers.d.ts

@@ -0,0 +1,5 @@
+export declare const POSITION_ATTRIBUTE_ENUM: {
+    values: string[];
+    default: string;
+};
+export declare function positionPropToPopperPosition(position: string): import("popper.js").default.Placement;

package/dist/types/ui/PortalProvider/PortalProviderThemesProvider.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import type { ThemeModes } from '@atlaskit/theme/types';
+export declare function PortalProviderThemeProviders(props: {
+    mode: ThemeModes;
+    children: React.ReactNode;
+}): JSX.Element;

package/dist/types/ui/PortalProvider/index.d.ts

@@ -0,0 +1,50 @@
+import React from 'react';
+import { IntlShape, WrappedComponentProps } from 'react-intl-next';
+import type { ThemeModes } from '@atlaskit/theme/types';
+import { FireAnalyticsCallback } from '../../analytics';
+import { EventDispatcher } from '../../event-dispatcher';
+export declare type BasePortalProviderProps = {
+    render: (portalProviderAPI: PortalProviderAPI) => React.ReactChild | JSX.Element | null;
+    onAnalyticsEvent?: FireAnalyticsCallback;
+    useAnalyticsContext?: boolean;
+    themeMode?: ThemeModes;
+} & WrappedComponentProps;
+export declare type Portals = Map<HTMLElement, React.ReactChild>;
+export declare type PortalRendererState = {
+    portals: Portals;
+};
+declare type MountedPortal = {
+    children: () => React.ReactChild | null;
+    hasAnalyticsContext: boolean;
+    hasIntlContext: boolean;
+};
+export declare class PortalProviderAPI extends EventDispatcher {
+    portals: Map<HTMLElement, MountedPortal>;
+    context: any;
+    intl: IntlShape;
+    onAnalyticsEvent?: FireAnalyticsCallback;
+    useAnalyticsContext?: boolean;
+    themeMode?: ThemeModes;
+    constructor(intl: IntlShape, onAnalyticsEvent?: FireAnalyticsCallback, analyticsContext?: boolean, themeMode?: ThemeModes);
+    setContext: (context: any) => void;
+    render(children: () => React.ReactChild | JSX.Element | null, container: HTMLElement, hasAnalyticsContext?: boolean, hasIntlContext?: boolean): void;
+    forceUpdate({ intl, themeMode, }: {
+        intl: IntlShape;
+        themeMode: ThemeModes | undefined;
+    }): void;
+    remove(container: HTMLElement): void;
+}
+export declare const PortalProvider: React.FC<import("react-intl-next").WithIntlProps<BasePortalProviderProps>> & {
+    WrappedComponent: React.ComponentType<BasePortalProviderProps>;
+};
+export declare const PortalProviderWithThemeProviders: (props: Omit<BasePortalProviderProps, 'intl' | 'themeMode'>) => JSX.Element;
+export declare class PortalRenderer extends React.Component<{
+    portalProviderAPI: PortalProviderAPI;
+}, PortalRendererState> {
+    constructor(props: {
+        portalProviderAPI: PortalProviderAPI;
+    });
+    handleUpdate: (portals: Portals) => void;
+    render(): JSX.Element;
+}
+export {};

package/dist/types/ui-color/ColorPalette/Color/index.d.ts

@@ -0,0 +1,19 @@
+/** @jsx jsx */
+import React, { PureComponent } from 'react';
+import { jsx } from '@emotion/react';
+export interface Props {
+    value: string;
+    label: string;
+    tabIndex?: number;
+    isSelected?: boolean;
+    onClick: (value: string, label: string) => void;
+    borderColor: string;
+    checkMarkColor?: string;
+    autoFocus?: boolean;
+}
+declare class Color extends PureComponent<Props> {
+    render(): jsx.JSX.Element;
+    onMouseDown: (e: React.MouseEvent<{}>) => void;
+    onClick: (e: React.MouseEvent<{}>) => void;
+}
+export default Color;

package/dist/types/ui-color/ColorPalette/Color/styles.d.ts

@@ -0,0 +1,4 @@
+/** this is not new usage - old code extracted from editor-core */
+export declare const buttonStyle: import("@emotion/react").SerializedStyles;
+/** this is not new usage - old code extracted from editor-core */
+export declare const buttonWrapperStyle: import("@emotion/react").SerializedStyles;

package/dist/types/ui-color/ColorPalette/Palettes/cellBackgroundColorPalette.d.ts

@@ -0,0 +1,3 @@
+import { PaletteColor } from './type';
+declare const cellBackgroundColorPalette: Array<PaletteColor>;
+export default cellBackgroundColorPalette;

package/dist/types/ui-color/ColorPalette/Palettes/common.d.ts

@@ -0,0 +1,2 @@
+/** this is not new usage - old code extracted from editor-core */
+export declare const DEFAULT_BORDER_COLOR: string;

package/dist/types/ui-color/ColorPalette/Palettes/getColorMessage.d.ts

@@ -0,0 +1,2 @@
+import { MessageDescriptor } from 'react-intl-next';
+export default function getColorMessage(messages: Record<string | number, MessageDescriptor>, color: string): MessageDescriptor | undefined;

package/dist/types/ui-color/ColorPalette/Palettes/index.d.ts

@@ -0,0 +1,2 @@
+export type { PaletteColor } from './type';
+export { DEFAULT_BORDER_COLOR } from './common';

package/dist/types/ui-color/ColorPalette/Palettes/paletteMessages.d.ts

@@ -0,0 +1,113 @@
+declare const _default: {
+    white: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    'light-blue': {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    'light-teal': {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    'light-green': {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    'light-yellow': {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    'light-red': {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    'light-purple': {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    'light-gray': {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    blue: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    teal: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    green: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    yellow: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    red: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    orange: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    purple: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    gray: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    'dark-blue': {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    'dark-teal': {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    'dark-green': {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    'dark-yellow': {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    'dark-red': {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    'dark-purple': {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+};
+export default _default;

package/dist/types/ui-color/ColorPalette/Palettes/panelBackgroundPalette.d.ts

@@ -0,0 +1,4 @@
+import { PaletteColor } from './type';
+/** this is not new usage - old code extracted from editor-core */
+export declare const panelBackgroundPalette: PaletteColor[];
+export declare const panelDarkModeBackgroundPalette: PaletteColor[];

package/dist/types/ui-color/ColorPalette/Palettes/statusColorPalette.d.ts

@@ -0,0 +1,4 @@
+import { PaletteColor } from './type';
+/** this is not new usage - old code extracted from editor-core */
+export declare const lightModeStatusColorPalette: PaletteColor[];
+export declare const darkModeStatusColorPalette: PaletteColor[];

package/dist/types/ui-color/ColorPalette/Palettes/textColorPalette.d.ts

@@ -0,0 +1,3 @@
+import { PaletteColor } from './type';
+export declare const textColorPalette: Array<PaletteColor>;
+export declare const textColorPaletteExtended: Array<PaletteColor>;

package/dist/types/ui-color/ColorPalette/Palettes/type.d.ts

@@ -0,0 +1,8 @@
+import { MessageDescriptor } from 'react-intl-next';
+export interface PaletteColor {
+    value: string;
+    label: string;
+    border: string;
+    message?: MessageDescriptor;
+}
+export declare type Palette = Array<PaletteColor>;

package/dist/types/ui-color/ColorPalette/index.d.ts

@@ -0,0 +1,15 @@
+/** @jsx jsx */
+import React from 'react';
+import { WrappedComponentProps } from 'react-intl-next';
+import { PaletteColor } from './Palettes/type';
+interface Props {
+    palette: PaletteColor[];
+    selectedColor: string | null;
+    onClick: (value: string, label: string) => void;
+    cols?: number;
+    className?: string;
+}
+declare const _default: React.FC<import("react-intl-next").WithIntlProps<Props & WrappedComponentProps<"intl">>> & {
+    WrappedComponent: React.ComponentType<Props & WrappedComponentProps<"intl">>;
+};
+export default _default;

package/dist/types/ui-color/ColorPalette/styles.d.ts

@@ -0,0 +1 @@
+export declare const colorPaletteWrapper: import("@emotion/react").SerializedStyles;

package/dist/types/ui-color/index.d.ts

@@ -0,0 +1,9 @@
+export { default as ColorPalette } from './ColorPalette';
+export { default as Color } from './ColorPalette/Color';
+export { default as cellBackgroundColorPalette } from './ColorPalette/Palettes/cellBackgroundColorPalette';
+export { default as colorPaletteMessages } from './ColorPalette/Palettes/paletteMessages';
+export { panelBackgroundPalette, panelDarkModeBackgroundPalette, } from './ColorPalette/Palettes/panelBackgroundPalette';
+export { lightModeStatusColorPalette, darkModeStatusColorPalette, } from './ColorPalette/Palettes/statusColorPalette';
+export { textColorPalette, textColorPaletteExtended, } from './ColorPalette/Palettes/textColorPalette';
+export { DEFAULT_BORDER_COLOR } from './ColorPalette/Palettes/common';
+export type { PaletteColor } from './ColorPalette/Palettes/type';

package/dist/types/ui-menu/Dropdown/index.d.ts

@@ -0,0 +1,32 @@
+import React, { PureComponent } from 'react';
+import { OpenChangedEvent } from '../../ui/DropList';
+export interface Props {
+    mountTo?: HTMLElement;
+    boundariesElement?: HTMLElement;
+    scrollableElement?: HTMLElement;
+    trigger: React.ReactElement<any>;
+    isOpen?: boolean;
+    onOpenChange?: (attrs: OpenChangedEvent) => void;
+    fitWidth?: number;
+    fitHeight?: number;
+    zIndex?: number;
+}
+export interface State {
+    target?: HTMLElement;
+    popupPlacement: [string, string];
+}
+/**
+ * Wrapper around @atlaskit/droplist which uses Popup and Portal to render
+ * droplist outside of "overflow: hidden" containers when needed.
+ *
+ * Also it controls popper's placement.
+ */
+export declare class Dropdown extends PureComponent<Props, State> {
+    constructor(props: Props);
+    private handleRef;
+    private updatePopupPlacement;
+    private renderDropdown;
+    render(): JSX.Element;
+}
+declare const DropdownWithOuterListeners: React.FC<Props & import("../../ui-react/with-react-editor-view-outer-listeners").WithOutsideClickProps>;
+export default DropdownWithOuterListeners;

package/dist/types/ui-menu/DropdownMenu/index.d.ts

@@ -0,0 +1,19 @@
+/** @jsx jsx */
+import { PureComponent } from 'react';
+import { jsx } from '@emotion/react';
+import { Props, State } from './types';
+export type { MenuItem } from './types';
+/**
+ * Wrapper around @atlaskit/droplist which uses Popup and Portal to render
+ * dropdown-menu outside of "overflow: hidden" containers when needed.
+ *
+ * Also it controls popper's placement.
+ */
+export default class DropdownMenuWrapper extends PureComponent<Props, State> {
+    state: State;
+    private handleRef;
+    private updatePopupPlacement;
+    private handleClose;
+    private renderDropdownMenu;
+    render(): jsx.JSX.Element;
+}

package/dist/types/ui-menu/DropdownMenu/types.d.ts

@@ -0,0 +1,43 @@
+import React from 'react';
+import { EditorActionsOptions as EditorActions } from '../../types';
+export interface Props {
+    mountTo?: HTMLElement;
+    boundariesElement?: HTMLElement;
+    scrollableElement?: HTMLElement;
+    isOpen?: boolean;
+    onOpenChange?: (attrs: any) => void;
+    onItemActivated?: (attrs: any) => void;
+    onMouseEnter?: (attrs: any) => void;
+    onMouseLeave?: (attrs: any) => void;
+    fitWidth?: number;
+    fitHeight?: number;
+    offset?: Array<number>;
+    zIndex?: number;
+    items: Array<{
+        items: MenuItem[];
+    }>;
+    shouldUseDefaultRole?: boolean;
+}
+export interface MenuItem {
+    key?: string;
+    content: string | React.ReactChild | React.ReactFragment;
+    value: {
+        name: string;
+    };
+    shortcut?: string;
+    elemBefore?: React.ReactElement<any>;
+    elemAfter?: React.ReactElement<any>;
+    tooltipDescription?: string;
+    tooltipPosition?: string;
+    isActive?: boolean;
+    isDisabled?: boolean;
+    handleRef?: any;
+    className?: string;
+    'aria-label'?: React.AriaAttributes['aria-label'];
+    'aria-haspopup'?: React.AriaAttributes['aria-haspopup'];
+    onClick?: (editorActions: EditorActions) => void;
+}
+export interface State {
+    target?: HTMLElement;
+    popupPlacement: [string, string];
+}

package/dist/types/ui-menu/ToolbarButton/index.d.ts

@@ -0,0 +1,53 @@
+/** @jsx jsx */
+import React from 'react';
+import { ButtonProps } from '@atlaskit/button/types';
+import { PositionType } from '@atlaskit/tooltip';
+import { TOOLBAR_ACTION_SUBJECT_ID } from '../../analytics';
+import { MenuItem } from '../DropdownMenu/types';
+export declare const TOOLBAR_BUTTON: typeof TOOLBAR_ACTION_SUBJECT_ID;
+export declare type Props = {
+    buttonId?: TOOLBAR_ACTION_SUBJECT_ID;
+    className?: string;
+    disabled?: boolean;
+    hideTooltip?: boolean;
+    href?: string;
+    iconAfter?: React.ReactElement<any>;
+    iconBefore?: React.ReactElement<any>;
+    onClick?: (event: React.MouseEvent<HTMLElement>) => void;
+    onItemClick?: (item: MenuItem) => void;
+    selected?: boolean;
+    spacing?: 'default' | 'compact' | 'none';
+    target?: string;
+    title?: React.ReactNode;
+    titlePosition?: PositionType;
+    item?: MenuItem;
+    testId?: string;
+    'aria-label'?: React.AriaAttributes['aria-label'];
+    'aria-expanded'?: React.AriaAttributes['aria-expanded'];
+    'aria-haspopup'?: React.AriaAttributes['aria-haspopup'];
+    'aria-pressed'?: React.AriaAttributes['aria-pressed'];
+} & Pick<ButtonProps, 'aria-label' | 'children'>;
+export declare type ToolbarButtonRef = HTMLElement;
+declare const ToolbarButton: React.ForwardRefExoticComponent<{
+    buttonId?: TOOLBAR_ACTION_SUBJECT_ID | undefined;
+    className?: string | undefined;
+    disabled?: boolean | undefined;
+    hideTooltip?: boolean | undefined;
+    href?: string | undefined;
+    iconAfter?: React.ReactElement<any, string | React.JSXElementConstructor<any>> | undefined;
+    iconBefore?: React.ReactElement<any, string | React.JSXElementConstructor<any>> | undefined;
+    onClick?: ((event: React.MouseEvent<HTMLElement>) => void) | undefined;
+    onItemClick?: ((item: MenuItem) => void) | undefined;
+    selected?: boolean | undefined;
+    spacing?: "default" | "none" | "compact" | undefined;
+    target?: string | undefined;
+    title?: React.ReactNode;
+    titlePosition?: PositionType | undefined;
+    item?: MenuItem | undefined;
+    testId?: string | undefined;
+    'aria-label'?: React.AriaAttributes['aria-label'];
+    'aria-expanded'?: React.AriaAttributes['aria-expanded'];
+    'aria-haspopup'?: React.AriaAttributes['aria-haspopup'];
+    'aria-pressed'?: React.AriaAttributes['aria-pressed'];
+} & Pick<ButtonProps, "children" | "aria-label"> & React.RefAttributes<HTMLElement>>;
+export default ToolbarButton;

package/dist/types/ui-menu/ToolbarButton/styles.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { ButtonProps } from '@atlaskit/button/standard-button';
+declare const _default: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLElement>>;
+export default _default;

package/dist/types/ui-menu/index.d.ts

@@ -0,0 +1,5 @@
+export { default as DropdownMenu } from '../ui-menu/DropdownMenu';
+export type { MenuItem } from '../ui-menu/DropdownMenu';
+export { default as ToolbarButton, TOOLBAR_BUTTON, } from '../ui-menu/ToolbarButton';
+export type { ToolbarButtonRef } from '../ui-menu/ToolbarButton';
+export { default as Dropdown } from './Dropdown';

package/dist/types/ui-react/ReactEditorViewContext.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import { EditorView } from 'prosemirror-view';
+declare type ReactEditorViewContextProps = {
+    editorView?: EditorView;
+    editorRef?: React.RefObject<HTMLDivElement>;
+};
+declare const ReactEditorViewContext: React.Context<ReactEditorViewContextProps>;
+export default ReactEditorViewContext;

package/dist/types/ui-react/index.d.ts

@@ -0,0 +1,2 @@
+export { default as ReactEditorViewContext } from './ReactEditorViewContext';
+export { default as withReactEditorViewOuterListeners } from './with-react-editor-view-outer-listeners';

package/dist/types/ui-react/with-react-editor-view-outer-listeners.d.ts

@@ -0,0 +1,9 @@
+import React, { ComponentClass, StatelessComponent } from 'react';
+declare type SimpleEventHandler<T> = (event: T) => void;
+export interface WithOutsideClickProps {
+    handleClickOutside?: SimpleEventHandler<MouseEvent>;
+    handleEscapeKeydown?: SimpleEventHandler<KeyboardEvent>;
+    handleEnterKeydown?: SimpleEventHandler<KeyboardEvent>;
+}
+export default function withReactEditorViewOuterListeners<P>(Component: ComponentClass<P> | StatelessComponent<P>): React.FC<P & WithOutsideClickProps>;
+export {};