@atlaskit/editor-core 183.0.0 → 183.0.6

package/dist/types-ts4.0/plugins/find-replace/types.d.ts

@@ -0,0 +1,44 @@
+import { DecorationSet } from 'prosemirror-view';
+import { PluginKey } from 'prosemirror-state';
+export interface FindReplacePluginState {
+    /** Whether find/replace is active, i.e. displayed */
+    isActive: boolean;
+    /**
+     * Whether we should set focus into and select all text of find textfield
+     * This will be true if user highlights a word and hits cmd+f
+     */
+    shouldFocus: boolean;
+    /** Search keyword */
+    findText: string;
+    /** Text to replace with */
+    replaceText: string;
+    /** Index of selected word in array of matches, this gets updated as user finds next/prev */
+    index: number;
+    /** Positions of find results */
+    matches: Match[];
+    /** Decorations for the search results */
+    decorationSet: DecorationSet;
+    /** Whether find/replace should match case when searching for results */
+    shouldMatchCase: boolean;
+}
+export declare const findReplacePluginKey: PluginKey<FindReplacePluginState, any>;
+export declare type Match = {
+    /** Start position */
+    start: number;
+    /** End position */
+    end: number;
+};
+export declare type TextGrouping = {
+    /** The concatenated text across nodes */
+    text: string;
+    /** Start position */
+    pos: number;
+} | null;
+export declare type FindReplaceOptions = {
+    allowMatchCase?: boolean;
+};
+export declare type MatchCaseProps = {
+    allowMatchCase?: boolean;
+    shouldMatchCase?: boolean;
+    onToggleMatchCase?: () => void;
+};

package/dist/types-ts4.0/plugins/find-replace/ui/Find.d.ts

@@ -0,0 +1,70 @@
+/** @jsx jsx */
+import React from 'react';
+import { WrappedComponentProps } from 'react-intl-next';
+import { TRIGGER_METHOD } from '../../analytics/types';
+import { MatchCaseProps } from '../types';
+export declare type FindProps = {
+    findText?: string;
+    count: {
+        index: number;
+        total: number;
+    };
+    shouldFocus: boolean;
+    onFindBlur: () => void;
+    onFind: (findText?: string) => void;
+    onFindNext: ({ triggerMethod, }: {
+        triggerMethod: TRIGGER_METHOD.KEYBOARD | TRIGGER_METHOD.BUTTON;
+    }) => void;
+    onFindPrev: ({ triggerMethod, }: {
+        triggerMethod: TRIGGER_METHOD.KEYBOARD | TRIGGER_METHOD.BUTTON;
+    }) => void;
+    onFindTextfieldRefSet: (ref: React.RefObject<HTMLInputElement>) => void;
+    onCancel: ({ triggerMethod, }: {
+        triggerMethod: TRIGGER_METHOD.KEYBOARD | TRIGGER_METHOD.TOOLBAR | TRIGGER_METHOD.BUTTON;
+    }) => void;
+    onArrowDown: () => void;
+} & MatchCaseProps;
+declare const _default: React.FC<import("react-intl-next").WithIntlProps<{
+    findText?: string | undefined;
+    count: {
+        index: number;
+        total: number;
+    };
+    shouldFocus: boolean;
+    onFindBlur: () => void;
+    onFind: (findText?: string | undefined) => void;
+    onFindNext: ({ triggerMethod, }: {
+        triggerMethod: TRIGGER_METHOD.BUTTON | TRIGGER_METHOD.KEYBOARD;
+    }) => void;
+    onFindPrev: ({ triggerMethod, }: {
+        triggerMethod: TRIGGER_METHOD.BUTTON | TRIGGER_METHOD.KEYBOARD;
+    }) => void;
+    onFindTextfieldRefSet: (ref: React.RefObject<HTMLInputElement>) => void;
+    onCancel: ({ triggerMethod, }: {
+        triggerMethod: TRIGGER_METHOD.BUTTON | TRIGGER_METHOD.KEYBOARD | TRIGGER_METHOD.TOOLBAR;
+    }) => void;
+    onArrowDown: () => void;
+} & MatchCaseProps & WrappedComponentProps<"intl">>> & {
+    WrappedComponent: React.ComponentType<{
+        findText?: string | undefined;
+        count: {
+            index: number;
+            total: number;
+        };
+        shouldFocus: boolean;
+        onFindBlur: () => void;
+        onFind: (findText?: string | undefined) => void;
+        onFindNext: ({ triggerMethod, }: {
+            triggerMethod: TRIGGER_METHOD.BUTTON | TRIGGER_METHOD.KEYBOARD;
+        }) => void;
+        onFindPrev: ({ triggerMethod, }: {
+            triggerMethod: TRIGGER_METHOD.BUTTON | TRIGGER_METHOD.KEYBOARD;
+        }) => void;
+        onFindTextfieldRefSet: (ref: React.RefObject<HTMLInputElement>) => void;
+        onCancel: ({ triggerMethod, }: {
+            triggerMethod: TRIGGER_METHOD.BUTTON | TRIGGER_METHOD.KEYBOARD | TRIGGER_METHOD.TOOLBAR;
+        }) => void;
+        onArrowDown: () => void;
+    } & MatchCaseProps & WrappedComponentProps<"intl">>;
+};
+export default _default;

package/dist/types-ts4.0/plugins/find-replace/ui/FindReplace.d.ts

@@ -0,0 +1,43 @@
+/** @jsx jsx */
+import React from 'react';
+import { jsx } from '@emotion/react';
+import { TRIGGER_METHOD, DispatchAnalyticsEvent } from '../../analytics/types';
+import { MatchCaseProps } from '../types';
+export declare type FindReplaceProps = {
+    findText?: string;
+    replaceText?: string;
+    count: {
+        index: number;
+        total: number;
+    };
+    shouldFocus: boolean;
+    onFindBlur: () => void;
+    onFind: (findText?: string) => void;
+    onFindNext: ({ triggerMethod, }: {
+        triggerMethod: TRIGGER_METHOD.KEYBOARD | TRIGGER_METHOD.BUTTON;
+    }) => void;
+    onFindPrev: ({ triggerMethod, }: {
+        triggerMethod: TRIGGER_METHOD.KEYBOARD | TRIGGER_METHOD.BUTTON;
+    }) => void;
+    onReplace: ({ triggerMethod, replaceText, }: {
+        triggerMethod: TRIGGER_METHOD.KEYBOARD | TRIGGER_METHOD.BUTTON;
+        replaceText: string;
+    }) => void;
+    onReplaceAll: ({ replaceText }: {
+        replaceText: string;
+    }) => void;
+    onCancel: ({ triggerMethod, }: {
+        triggerMethod: TRIGGER_METHOD.KEYBOARD | TRIGGER_METHOD.TOOLBAR | TRIGGER_METHOD.BUTTON;
+    }) => void;
+    dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
+} & MatchCaseProps;
+declare class FindReplace extends React.PureComponent<FindReplaceProps> {
+    private findTextfield;
+    private replaceTextfield?;
+    setFindTextfieldRef: (findTextfieldRef: React.RefObject<HTMLInputElement>) => void;
+    setReplaceTextfieldRef: (replaceTextfieldRef: React.RefObject<HTMLInputElement>) => void;
+    setFocusToFind: () => void;
+    setFocusToReplace: () => void;
+    render(): jsx.JSX.Element;
+}
+export default FindReplace;

package/dist/types-ts4.0/plugins/find-replace/ui/FindReplaceToolbarButton.d.ts

@@ -0,0 +1,21 @@
+/** @jsx jsx */
+import React from 'react';
+import { WrappedComponentProps } from 'react-intl-next';
+import { FindReplaceProps } from './FindReplace';
+import { DispatchAnalyticsEvent } from '../../analytics/types';
+export interface FindReplaceToolbarButtonProps extends Omit<FindReplaceProps, 'count'> {
+    index: number;
+    numMatches: number;
+    isActive: boolean;
+    onActivate: () => void;
+    isReducedSpacing?: boolean;
+    popupsMountPoint?: HTMLElement;
+    popupsBoundariesElement?: HTMLElement;
+    popupsScrollableElement?: HTMLElement;
+    dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
+    takeFullWidth: boolean;
+}
+declare const _default: React.FC<import("react-intl-next").WithIntlProps<FindReplaceToolbarButtonProps & WrappedComponentProps<"intl">>> & {
+    WrappedComponent: React.ComponentType<FindReplaceToolbarButtonProps & WrappedComponentProps<"intl">>;
+};
+export default _default;

package/dist/types-ts4.0/plugins/find-replace/ui/FindReplaceTooltipButton.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+interface Props {
+    title: string;
+    icon: JSX.Element;
+    keymapDescription: string;
+    onClick: (ref: React.RefObject<HTMLButtonElement>) => void;
+    disabled?: boolean;
+    isPressed?: boolean;
+}
+export declare class FindReplaceTooltipButton extends React.PureComponent<Props> {
+    private buttonRef;
+    static defaultProps: {
+        keymapDescription: string;
+    };
+    handleClick: () => void;
+    render(): JSX.Element;
+}
+export {};

package/dist/types-ts4.0/plugins/find-replace/ui/Replace.d.ts

@@ -0,0 +1,26 @@
+/** @jsx jsx */
+import React from 'react';
+import { WrappedComponentProps } from 'react-intl-next';
+import { TRIGGER_METHOD, DispatchAnalyticsEvent } from '../../analytics/types';
+export declare type ReplaceProps = {
+    canReplace: boolean;
+    replaceText?: string;
+    onReplace: ({ triggerMethod, replaceText, }: {
+        triggerMethod: TRIGGER_METHOD.KEYBOARD | TRIGGER_METHOD.BUTTON;
+        replaceText: string;
+    }) => void;
+    onReplaceAll: ({ replaceText }: {
+        replaceText: string;
+    }) => void;
+    onReplaceTextfieldRefSet: (ref: React.RefObject<HTMLInputElement>) => void;
+    onArrowUp: () => void;
+    dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
+};
+export declare type ReplaceState = {
+    replaceText: string;
+    isComposing: boolean;
+};
+declare const _default: React.FC<import("react-intl-next").WithIntlProps<ReplaceProps & WrappedComponentProps<"intl">>> & {
+    WrappedComponent: React.ComponentType<ReplaceProps & WrappedComponentProps<"intl">>;
+};
+export default _default;

package/dist/types-ts4.0/plugins/find-replace/ui/styles.d.ts

@@ -0,0 +1,5 @@
+export declare const replaceSectionButtonStyles: import("@emotion/react").SerializedStyles;
+export declare const ruleStyles: import("@emotion/react").SerializedStyles;
+export declare const wrapperStyles: import("@emotion/react").SerializedStyles;
+export declare const sectionWrapperStyles: import("@emotion/react").SerializedStyles;
+export declare const countStyles: import("@emotion/react").SerializedStyles;

package/dist/types-ts4.0/plugins/find-replace/utils/batch-decorations.d.ts

@@ -0,0 +1,36 @@
+import { EditorView, Decoration } from 'prosemirror-view';
+/**
+ * Provides support for applying search match highlight decorations in batches
+ */
+declare class BatchDecorations {
+    private rafId?;
+    private addDecorations?;
+    private removeDecorations?;
+    stop(): void;
+    /**
+     * Applies the decorations needed for the current search results
+     * It does so async, splitting them up into batches to help with performance
+     */
+    applyAllSearchDecorations(editorView: EditorView, containerElement: HTMLElement | null, addDecorations: (decorations: Decoration[]) => void, removeDecorations: (decorations: Decoration[]) => void): Promise<void>;
+    private updateDecorationsBetween;
+    private addDecorationsBetween;
+    private removeDecorationsBetween;
+    /**
+     * Calculates Prosemirror start and end positions we want to apply the decorations
+     * between
+     * Also calculates the positions the are the start and end of the user's viewport
+     * so we can apply decorations there first and work outwards
+     */
+    private calcDecorationPositions;
+    private getStartPos;
+    private getEndPos;
+    /**
+     * Util to batch function calls by animation frames
+     * A counter will start at 0 and increment by provided value until reaches limit
+     * Passed in fn receives the counter as a param, return false to skip waiting
+     * for the animation frame for the next call
+     */
+    private batchRequests;
+}
+declare const batchDecorations: BatchDecorations;
+export default batchDecorations;

package/dist/types-ts4.0/plugins/find-replace/utils/index.d.ts

@@ -0,0 +1,49 @@
+import { Fragment, Node as PmNode, Slice } from 'prosemirror-model';
+import { Decoration, DecorationSet } from 'prosemirror-view';
+import { TextSelection, ReadonlyTransaction, Selection } from 'prosemirror-state';
+import { Step } from 'prosemirror-transform';
+import { Match } from '../types';
+export declare function getSelectedText(selection: TextSelection): string;
+export declare const createDecorations: (selectedIndex: number, matches: {
+    start: number;
+    end: number;
+}[]) => Decoration[];
+export declare const createDecoration: (start: number, end: number, isSelected?: boolean | undefined) => Decoration<{
+    [key: string]: any;
+} & import("prosemirror-view").InlineDecorationSpec>;
+export declare function findMatches(content: PmNode | Fragment, searchText: string, shouldMatchCase: boolean, contentIndex?: number): Match[];
+/**
+ * Finds index of first item in matches array that comes after user's cursor pos.
+ * If `backward` is `true`, finds index of first item that comes before instead.
+ */
+export declare function findSearchIndex(selectionPos: number, matches: Match[], backward?: boolean): number;
+export declare const nextIndex: (currentIndex: number, total: number) => number;
+export declare const prevIndex: (currentIndex: number, total: number) => number;
+export declare const getSelectionForMatch: (selection: Selection, doc: PmNode, index: number, matches: Match[], offset?: number) => TextSelection;
+export declare const findDecorationFromMatch: (decorationSet: DecorationSet, match: Match) => Decoration | undefined;
+export declare const removeDecorationsFromSet: (decorationSet: DecorationSet, decorationsToRemove: Decoration[], doc: PmNode) => DecorationSet;
+export declare const removeMatchesFromSet: (decorationSet: DecorationSet, matches: Match[], doc: PmNode) => DecorationSet<any>;
+/**
+ * Finds decorations in prevDecorations that are not in newDecorations or decorationsToRemove
+ * These decorations have been lost by Prosemirror during an over eager decoration removal
+ * We need to be smart to cope with thousands of decorations without crashing everything
+ */
+export declare const findLostAdjacentDecorations: (decorationsToRemove: Decoration[], prevDecorations: Decoration[], newDecorations: Decoration[]) => Decoration[];
+/**
+ * Searches through array in bumps of 100 to return the index of the first
+ * decoration whose 'from' value is before or equal to the position
+ */
+export declare const findIndexBeforePosition: (items: Decoration[], position: number) => number;
+/**
+ * Determines whether a find/replace text Match will be changed as a result
+ * of a Step modification to the document. This is evaluated by checking
+ * both mapped and unmapped versions of the Step as in different cases the
+ * matches will match.
+ *
+ * **Note:** Match state received here is after step has been applied.
+ */
+export declare const isMatchAffectedByStep: (match: Match, step: Step<any> & {
+    from: number;
+    to: number;
+    slice: Slice;
+}, tr: ReadonlyTransaction) => boolean;

package/dist/types-ts4.0/plugins/floating-toolbar/index.d.ts

@@ -0,0 +1,24 @@
+import { PluginKey, Selection, EditorState } from 'prosemirror-state';
+import { Node } from 'prosemirror-model';
+import { NextEditorPlugin } from '@atlaskit/editor-common/types';
+import { FloatingToolbarConfig } from './types';
+import type featureFlagsPlugin from '@atlaskit/editor-plugin-feature-flags';
+export declare type FloatingToolbarPluginState = Record<'getConfigWithNodeInfo', (state: EditorState) => ConfigWithNodeInfo | null | undefined>;
+export declare type ConfigWithNodeInfo = {
+    config: FloatingToolbarConfig | undefined;
+    pos: number;
+    node: Node;
+};
+export declare const getRelevantConfig: (selection: Selection<any>, configs: Array<FloatingToolbarConfig>) => ConfigWithNodeInfo | undefined;
+declare const floatingToolbarPlugin: NextEditorPlugin<'floatingToolbar', {
+    dependencies: [
+        typeof featureFlagsPlugin
+    ];
+}>;
+export default floatingToolbarPlugin;
+/**
+ *
+ * ProseMirror Plugin
+ *
+ */
+export declare const pluginKey: PluginKey<FloatingToolbarPluginState, any>;

package/dist/types-ts4.0/plugins/floating-toolbar/pm-plugins/force-focus/index.d.ts

@@ -0,0 +1,18 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { PluginKey } from 'prosemirror-state';
+import { EditorView } from 'prosemirror-view';
+export declare const forceFocusStateKey: PluginKey<any, any>;
+declare const _default: () => SafePlugin<any, any>;
+/**
+ * Used in cases where a floating toolbar button opens a submenu which destroys
+ * the button, but the user has pressed ESC to close the submenu and focus needs
+ * to move back to the button. */
+export default _default;
+/**
+ * The provided selector should be the floating toolbar button that needs focus.
+ */
+export declare function forceFocusSelector(selector: string | null, view?: EditorView): void;
+/**
+ * If a selector is set and the element exists, focus it.
+ */
+export declare function checkShouldForceFocusAndApply(view?: EditorView): void;

package/dist/types-ts4.0/plugins/floating-toolbar/pm-plugins/toolbar-data/commands.d.ts

@@ -0,0 +1,3 @@
+import { Command } from '../../../../types/command';
+export declare const showConfirmDialog: (buttonIndex: number) => Command;
+export declare const hideConfirmDialog: () => Command;

package/dist/types-ts4.0/plugins/floating-toolbar/pm-plugins/toolbar-data/plugin-factory.d.ts

@@ -0,0 +1 @@
+export declare const createPluginState: (dispatch: import("@atlaskit/editor-common/event-dispatcher").Dispatch<any>, initialState: import("./types").FloatingToolbarPluginData | ((state: import("prosemirror-state").EditorState<any>) => import("./types").FloatingToolbarPluginData)) => import("prosemirror-state").SafeStateField<import("./types").FloatingToolbarPluginData, import("prosemirror-model").Schema<any, any>>, createCommand: <A = import("./types").FloatingToolbarPluginAction>(action: A | ((state: Readonly<import("prosemirror-state").EditorState<any>>) => false | A), transform?: ((tr: import("prosemirror-state").Transaction<any>, state: import("prosemirror-state").EditorState<any>) => import("prosemirror-state").Transaction<any>) | undefined) => import("@atlaskit/editor-common/types").Command, getPluginState: (state: import("prosemirror-state").EditorState<any>) => import("./types").FloatingToolbarPluginData;

package/dist/types-ts4.0/plugins/floating-toolbar/pm-plugins/toolbar-data/plugin-key.d.ts

@@ -0,0 +1,3 @@
+import { PluginKey } from 'prosemirror-state';
+import { FloatingToolbarPluginData } from './types';
+export declare const pluginKey: PluginKey<FloatingToolbarPluginData, any>;

package/dist/types-ts4.0/plugins/floating-toolbar/pm-plugins/toolbar-data/plugin.d.ts

@@ -0,0 +1,3 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { Dispatch } from '../../../../event-dispatcher';
+export declare const createPlugin: (dispatch: Dispatch) => SafePlugin<import("./types").FloatingToolbarPluginData, import("prosemirror-model").Schema<any, any>>;

package/dist/types-ts4.0/plugins/floating-toolbar/pm-plugins/toolbar-data/reducer.d.ts

@@ -0,0 +1,2 @@
+import { FloatingToolbarPluginAction, FloatingToolbarPluginData } from './types';
+export declare const reducer: (pluginState: FloatingToolbarPluginData, action: FloatingToolbarPluginAction) => FloatingToolbarPluginData;

package/dist/types-ts4.0/plugins/floating-toolbar/pm-plugins/toolbar-data/types.d.ts

@@ -0,0 +1,11 @@
+export declare type FloatingToolbarPluginData = {
+    confirmDialogForItem?: number;
+};
+export declare type FloatingToolbarPluginAction = {
+    type: 'SHOW_CONFIRM_DIALOG';
+    data: {
+        buttonIndex: number;
+    };
+} | {
+    type: 'HIDE_CONFIRM_DIALOG';
+};

package/dist/types-ts4.0/plugins/floating-toolbar/types.d.ts

@@ -0,0 +1 @@
+export type { Icon, RenderOptionsProps, AlignType, ConfirmDialogOptions, FloatingToolbarButton, FloatingToolbarCopyButton, FloatingToolbarInput, FloatingToolbarCustom, FloatingToolbarListPicker, FloatingToolbarColorPicker, FloatingToolbarEmojiPicker, FloatingToolbarDatePicker, FloatingToolbarSelect, FloatingToolbarSeparator, FloatingToolbarDropdown, FloatingToolbarFallbackItem, FloatingToolbarItem, FloatingToolbarConfig, FloatingToolbarHandler, Command, MarkOptions, NodeOptions, } from '@atlaskit/editor-common/types';

package/dist/types-ts4.0/plugins/floating-toolbar/ui/Button.d.ts

@@ -0,0 +1,30 @@
+import React from 'react';
+import type { ButtonAppearance } from '@atlaskit/editor-common/types';
+export type { ButtonAppearance };
+export interface Props {
+    title?: string;
+    icon?: React.ReactElement<any>;
+    iconAfter?: React.ReactElement<any>;
+    onClick?: React.MouseEventHandler;
+    onKeyDown?: React.KeyboardEventHandler;
+    onMouseEnter?: <T>(event: React.MouseEvent<T>) => void;
+    onMouseLeave?: <T>(event: React.MouseEvent<T>) => void;
+    onFocus?: <T>(event: React.FocusEvent<T>) => void;
+    onBlur?: <T>(event: React.FocusEvent<T>) => void;
+    selected?: boolean;
+    disabled?: boolean;
+    appearance?: ButtonAppearance;
+    ariaHasPopup?: boolean | 'dialog' | 'menu' | 'listbox' | 'tree' | 'grid' | undefined;
+    ariaLabel?: string;
+    href?: string;
+    target?: string;
+    children?: React.ReactNode;
+    className?: string;
+    tooltipContent?: React.ReactNode;
+    testId?: string;
+    hideTooltipOnClick?: boolean;
+    tabIndex?: number | null | undefined;
+    areaControls?: string;
+}
+declare const _default: ({ title, icon, iconAfter, onClick, onKeyDown, onMouseEnter, onMouseLeave, onFocus, onBlur, selected, disabled, href, target, appearance, children, className, tooltipContent, testId, hideTooltipOnClick, ariaHasPopup, tabIndex, areaControls, ariaLabel, }: Props) => JSX.Element;
+export default _default;

package/dist/types-ts4.0/plugins/floating-toolbar/ui/CheckboxModal.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import { WrappedComponentProps } from 'react-intl-next';
+import { ConfirmationDialogProps } from './types';
+export declare const CheckboxModal: (props: ConfirmationDialogProps & WrappedComponentProps) => JSX.Element;

package/dist/types-ts4.0/plugins/floating-toolbar/ui/ConfirmationModal.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import { WrappedComponentProps } from 'react-intl-next';
+import { ConfirmationDialogProps } from './types';
+export declare const ConfirmationModal: React.FC<import("react-intl-next").WithIntlProps<ConfirmationDialogProps & WrappedComponentProps<"intl">>> & {
+    WrappedComponent: React.ComponentType<ConfirmationDialogProps & WrappedComponentProps<"intl">>;
+};

package/dist/types-ts4.0/plugins/floating-toolbar/ui/Dropdown.d.ts

@@ -0,0 +1,39 @@
+/** @jsx jsx */
+import React, { Component, ReactElement } from 'react';
+import { jsx } from '@emotion/react';
+import { DropdownOptions } from './types';
+import { EditorView } from 'prosemirror-view';
+export interface Props {
+    title: string;
+    icon?: ReactElement<any>;
+    hideExpandIcon?: boolean;
+    options: DropdownOptions<Function>;
+    dispatchCommand: (command: Function) => void;
+    mountPoint?: HTMLElement;
+    boundariesElement?: HTMLElement;
+    scrollableElement?: HTMLElement;
+    disabled?: boolean;
+    tooltip?: string;
+    buttonTestId?: string;
+    dropdownWidth?: number;
+    showSelected?: boolean;
+    setDisableParentScroll?: (disable: boolean) => void;
+    editorView?: EditorView;
+    dropdownListId?: string;
+}
+export interface State {
+    isOpen: boolean;
+    isOpenedByKeyboard: boolean;
+}
+export default class Dropdown extends Component<Props, State> {
+    state: State;
+    triggerRef: React.RefObject<HTMLDivElement>;
+    render(): jsx.JSX.Element;
+    private renderArrayOptions;
+    private toggleOpen;
+    private toggleOpenByKeyboard;
+    private hide;
+    private hideOnEsc;
+    private onOpenChanged;
+    componentDidUpdate(prevProps: Props, prevState: State): void;
+}

package/dist/types-ts4.0/plugins/floating-toolbar/ui/DropdownMenu.d.ts

@@ -0,0 +1,29 @@
+/// <reference types="react" />
+import { ButtonItemProps } from '@atlaskit/menu';
+import { DropdownOptionT } from './types';
+import { WrappedComponentProps } from 'react-intl-next';
+import { EditorView } from 'prosemirror-view';
+export declare const menuItemDimensions: {
+    width: number;
+    height: number;
+};
+export declare const itemSpacing: number;
+export interface Props {
+    hide: Function;
+    dispatchCommand: Function;
+    items: Array<DropdownOptionT<Function>>;
+    showSelected?: boolean;
+    editorView?: EditorView;
+}
+export interface DropdownButtonItemProps extends ButtonItemProps {
+    onMouseEnter?: (event: React.MouseEvent | React.KeyboardEvent) => void;
+    onMouseOver?: (event: React.MouseEvent | React.KeyboardEvent) => void;
+    onMouseLeave?: (event: React.MouseEvent | React.KeyboardEvent) => void;
+    onMouseOut?: (event: React.MouseEvent | React.KeyboardEvent) => void;
+    onFocus?: (event: React.MouseEvent | React.KeyboardEvent) => void;
+    onBlur?: (event: React.MouseEvent | React.KeyboardEvent) => void;
+}
+declare const _default: import("react").FC<import("react-intl-next").WithIntlProps<Props & WrappedComponentProps<"intl">>> & {
+    WrappedComponent: import("react").ComponentType<Props & WrappedComponentProps<"intl">>;
+};
+export default _default;

package/dist/types-ts4.0/plugins/floating-toolbar/ui/EditorEmojiAddIcon.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export default function EditorEmojiAddIcon(): JSX.Element;

package/dist/types-ts4.0/plugins/floating-toolbar/ui/EmojiPickerButton.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import { EditorView } from 'prosemirror-view';
+import { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+import { EmojiId } from '@atlaskit/emoji';
+export declare const EmojiPickerButton: React.FunctionComponent<{
+    className?: string;
+    editorView?: EditorView;
+    idx?: number;
+    providerFactory?: ProviderFactory;
+    title?: string;
+    onChange?: (emoji: EmojiId) => void;
+    isSelected?: boolean;
+    mountPoint?: HTMLElement;
+    setDisableParentScroll?: (disable: boolean) => void;
+}>;

package/dist/types-ts4.0/plugins/floating-toolbar/ui/ExtensionsPlaceholder.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+import { Node as PMNode } from 'prosemirror-model';
+import { EditorView } from 'prosemirror-view';
+import type { ExtensionProvider } from '@atlaskit/editor-common/extensions';
+interface Props {
+    node: PMNode;
+    extensionProvider: ExtensionProvider;
+    editorView: EditorView;
+    separator?: 'start' | 'end' | 'both';
+}
+export declare const ExtensionsPlaceholder: (props: Props) => JSX.Element | null;
+export {};

package/dist/types-ts4.0/plugins/floating-toolbar/ui/Input.d.ts

@@ -0,0 +1,23 @@
+/** @jsx jsx */
+import React from 'react';
+import { jsx } from '@emotion/react';
+import { Component } from 'react';
+export interface Props {
+    mountPoint?: HTMLElement;
+    boundariesElement?: HTMLElement;
+    defaultValue?: string;
+    placeholder?: string;
+    onBlur?: (text: string) => void;
+    onSubmit?: (text: string) => void;
+}
+export interface State {
+    text: string;
+}
+export default class TextField extends Component<Props, State> {
+    constructor(props: Props);
+    UNSAFE_componentWillReceiveProps(nextProps: Props): void;
+    handleChange: (e: React.ChangeEvent<HTMLInputElement>) => void;
+    handleSubmit: (e: React.FormEvent) => void;
+    handleBlur: (e: React.FocusEvent<{}>) => void;
+    render(): jsx.JSX.Element;
+}

package/dist/types-ts4.0/plugins/floating-toolbar/ui/ScrollButtons.d.ts

@@ -0,0 +1,13 @@
+/** @jsx jsx */
+import React from 'react';
+import { jsx } from '@emotion/react';
+import { Node } from 'prosemirror-model';
+import { IntlShape } from 'react-intl-next';
+export interface Props {
+    intl: IntlShape;
+    scrollContainerRef: React.RefObject<HTMLDivElement>;
+    node: Node;
+    disabled: boolean;
+}
+declare const _default: ({ intl, scrollContainerRef, node, disabled }: Props) => jsx.JSX.Element | null;
+export default _default;

package/dist/types-ts4.0/plugins/floating-toolbar/ui/Select.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="react" />
+import { ValueType } from '@atlaskit/select';
+import type { RenderOptionsPropsT, SelectOption } from '@atlaskit/editor-common/types';
+export type { RenderOptionsPropsT, SelectOption };
+export interface Props {
+    hideExpandIcon?: boolean;
+    options: SelectOption[];
+    dispatchCommand: (command: Function) => void;
+    mountPoint?: HTMLElement;
+    boundariesElement?: HTMLElement;
+    scrollableElement?: HTMLElement;
+    defaultValue?: SelectOption | null;
+    placeholder?: string;
+    onChange?: (change: ValueType<SelectOption>) => void;
+    width?: number;
+    filterOption?: ((option: SelectOption, rawInput: string) => boolean) | null;
+    setDisableParentScroll?: (disable: boolean) => void;
+    ariaLabel?: string;
+    classNamePrefix?: string;
+}
+export default function Search(props: Props): JSX.Element;

package/dist/types-ts4.0/plugins/floating-toolbar/ui/Separator.d.ts

@@ -0,0 +1,4 @@
+/** @jsx jsx */
+import { jsx } from '@emotion/react';
+declare const _default: () => jsx.JSX.Element;
+export default _default;

package/dist/types-ts4.0/plugins/floating-toolbar/ui/SimpleModal.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import { WrappedComponentProps } from 'react-intl-next';
+import { ConfirmationDialogProps } from './types';
+export declare const SimpleModal: (props: ConfirmationDialogProps & WrappedComponentProps) => JSX.Element;