@atlaskit/editor-plugin-insert-block 4.3.2 → 4.3.4

package/dist/types/ui/ToolbarInsertBlock/types.d.ts

@@ -9,58 +9,58 @@ import type { EmojiProvider } from '@atlaskit/emoji';
 import type { InsertBlockPlugin } from '../../index';
 import type { BlockMenuItem } from './create-items';
 export interface Props {
-    buttons: number;
-    showElementBrowser: boolean;
-    isReducedSpacing: boolean;
-    isDisabled?: boolean;
-    isTypeAheadAllowed?: boolean;
-    editorView: EditorView;
-    editorActions?: EditorActions;
-    tableSupported?: boolean;
-    tableSelectorSupported?: boolean;
     actionSupported?: boolean;
+    availableWrapperBlockTypes?: BlockType[];
+    buttons: number;
+    dateEnabled?: boolean;
     decisionSupported?: boolean;
-    mentionsSupported?: boolean;
-    mediaUploadsEnabled?: boolean;
-    mediaSupported?: boolean;
-    isEditorOffline?: boolean;
-    imageUploadSupported?: boolean;
-    imageUploadEnabled?: boolean;
+    dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
+    editorActions?: EditorActions;
+    editorAppearance?: EditorAppearance;
+    editorView: EditorView;
+    emojiDisabled?: boolean;
+    emojiProvider?: Promise<EmojiProvider>;
+    expandEnabled?: boolean;
     handleImageUpload?: (event?: ImageUploadPluginReferenceEvent) => Command;
-    dateEnabled?: boolean;
     horizontalRuleEnabled?: boolean;
-    placeholderTextEnabled?: boolean;
+    imageUploadEnabled?: boolean;
+    imageUploadSupported?: boolean;
+    insertMenuItems?: MenuItem[];
+    isDisabled?: boolean;
+    isEditorOffline?: boolean;
+    isReducedSpacing: boolean;
+    isTypeAheadAllowed?: boolean;
     layoutSectionEnabled?: boolean;
-    expandEnabled?: boolean;
-    emojiProvider?: Promise<EmojiProvider>;
-    availableWrapperBlockTypes?: BlockType[];
-    linkSupported?: boolean;
     linkDisabled?: boolean;
-    emojiDisabled?: boolean;
+    linkSupported?: boolean;
+    mediaSupported?: boolean;
+    mediaUploadsEnabled?: boolean;
+    mentionsDisabled?: boolean;
+    mentionsSupported?: boolean;
     nativeStatusSupported?: boolean;
-    popupsMountPoint?: HTMLElement;
-    popupsBoundariesElement?: HTMLElement;
-    popupsScrollableElement?: HTMLElement;
-    insertMenuItems?: MenuItem[];
-    showElementBrowserLink?: boolean;
-    showSeparator?: boolean;
+    onInsertBlockType?: (name: string) => Command;
+    onInsertMacroFromMacroBrowser?: (macroProvider: MacroProvider, node?: PMNode, isEditing?: boolean) => (view: EditorView) => void;
     onShowMediaPicker?: (mountInfo?: {
-        ref: HTMLElement;
         mountPoint: HTMLElement;
+        ref: HTMLElement;
     }) => void;
-    onInsertBlockType?: (name: string) => Command;
-    onInsertMacroFromMacroBrowser?: (macroProvider: MacroProvider, node?: PMNode, isEditing?: boolean) => (view: EditorView) => void;
-    dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
+    placeholderTextEnabled?: boolean;
     pluginInjectionApi: ExtractInjectionAPI<InsertBlockPlugin> | undefined;
-    mentionsDisabled?: boolean;
-    editorAppearance?: EditorAppearance;
+    popupsBoundariesElement?: HTMLElement;
+    popupsMountPoint?: HTMLElement;
+    popupsScrollableElement?: HTMLElement;
+    showElementBrowser: boolean;
+    showElementBrowserLink?: boolean;
+    showSeparator?: boolean;
+    tableSelectorSupported?: boolean;
+    tableSupported?: boolean;
 }
 export interface State {
-    isPlusMenuOpen: boolean;
-    emojiPickerOpen: boolean;
     buttons: BlockMenuItem[];
     dropdownItems: BlockMenuItem[];
+    emojiPickerOpen: boolean;
     isOpenedByKeyboard: boolean;
+    isPlusMenuOpen: boolean;
     isTableSelectorOpen: boolean;
     isTableSelectorOpenedByKeyboard: boolean;
 }

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

@@ -1,8 +1,3 @@
 import React from 'react';
-import type { ExtractInjectionAPI } from '@atlaskit/editor-common/types';
-import type { InsertBlockPlugin } from '../../insertBlockPluginType';
-type EmojiButtonProps = {
-    api?: ExtractInjectionAPI<InsertBlockPlugin>;
-};
-export declare const EmojiButton: ({ api }: EmojiButtonProps) => React.JSX.Element | null;
-export {};
+import type { BaseToolbarButtonProps } from './shared/types';
+export declare const EmojiButton: ({ api, popupsMountPoint, popupsBoundariesElement, popupsScrollableElement }: BaseToolbarButtonProps) => React.JSX.Element | null;

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

@@ -0,0 +1,18 @@
+import React from 'react';
+import type { ExtractInjectionAPI, Command } from '@atlaskit/editor-common/types';
+import type { MenuItem } from '@atlaskit/editor-common/ui-menu';
+import type { InsertBlockPlugin } from '../../insertBlockPluginType';
+type InsertButtonProps = {
+    api?: ExtractInjectionAPI<InsertBlockPlugin>;
+    expandEnabled?: boolean;
+    horizontalRuleEnabled?: boolean;
+    insertMenuItems?: MenuItem[];
+    isFullPageAppearance?: boolean;
+    nativeStatusSupported?: boolean;
+    numberOfButtons?: number;
+    onInsertBlockType?: (name: string) => Command;
+    showElementBrowserLink?: boolean;
+    tableSelectorSupported?: boolean;
+};
+export declare const InsertButton: ({ api, showElementBrowserLink, isFullPageAppearance, tableSelectorSupported, nativeStatusSupported, horizontalRuleEnabled, expandEnabled, insertMenuItems, numberOfButtons, onInsertBlockType, }: InsertButtonProps) => React.JSX.Element | null;
+export {};

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

@@ -1,9 +1,7 @@
 import React from 'react';
-import type { ExtractInjectionAPI } from '@atlaskit/editor-common/types';
-import type { InsertBlockPlugin } from '../../insertBlockPluginType';
-type TableSizePickerProps = {
-    api?: ExtractInjectionAPI<InsertBlockPlugin>;
+import type { BaseToolbarButtonProps } from './shared/types';
+interface TableSizePickerProps extends BaseToolbarButtonProps {
     tableSelectorSupported?: boolean;
-};
+}
 export declare const TableSizePicker: ({ api, tableSelectorSupported }: TableSizePickerProps) => React.JSX.Element | null;
 export {};

package/dist/types/ui/toolbar-components/hooks/useEmojiPickerPopup.d.ts

@@ -0,0 +1,20 @@
+import { INPUT_METHOD } from '@atlaskit/editor-common/analytics';
+import type { ExtractInjectionAPI } from '@atlaskit/editor-common/types';
+import type { EmojiId } from '@atlaskit/emoji/types';
+import type { InsertBlockPlugin } from '../../../insertBlockPluginType';
+interface UseEmojiPickerPopupProps {
+    api?: ExtractInjectionAPI<InsertBlockPlugin>;
+    buttonRef: React.RefObject<HTMLElement>;
+}
+export declare const useEmojiPickerPopup: ({ api, buttonRef }: UseEmojiPickerPopupProps) => {
+    handleSelectedEmoji: (emojiId: EmojiId) => true;
+    onPopupUnmount: () => void;
+    isOpen: boolean;
+    isOpenedByKeyboard: boolean;
+    toggle: (inputMethod?: import("@atlaskit/editor-common/types").TOOLBAR_MENU_TYPE | INPUT_METHOD) => void;
+    close: () => void;
+    handleEscapeKeydown: () => void;
+    handleClickOutside: (e: MouseEvent) => void;
+    handleKeyboardOpen: (event: React.KeyboardEvent) => void;
+};
+export {};

package/dist/types/ui/toolbar-components/hooks/useInsertButtonState.d.ts

@@ -0,0 +1,24 @@
+import type { ExtractInjectionAPI } from '@atlaskit/editor-common/types';
+import type { MenuItem } from '@atlaskit/editor-common/ui-menu';
+import type { EditorView } from '@atlaskit/editor-prosemirror/dist/types/view';
+import type { EmojiProvider } from '@atlaskit/emoji';
+import type { InsertBlockPlugin } from '../../../insertBlockPluginType';
+import type { BlockMenuItem } from '../../ToolbarInsertBlock/create-items';
+interface UseInsertButtonStateProps {
+    api?: ExtractInjectionAPI<InsertBlockPlugin>;
+    editorView?: EditorView;
+    expandEnabled?: boolean;
+    horizontalRuleEnabled?: boolean;
+    insertMenuItems?: MenuItem[];
+    nativeStatusSupported?: boolean;
+    numberOfButtons?: number;
+    showElementBrowserLink?: boolean;
+    tableSelectorSupported?: boolean;
+}
+export interface InsertButtonState {
+    dropdownItems: BlockMenuItem[];
+    emojiProvider?: EmojiProvider;
+    isTypeAheadAllowed?: boolean;
+}
+export declare const useInsertButtonState: ({ api, editorView, horizontalRuleEnabled, insertMenuItems, nativeStatusSupported, numberOfButtons, tableSelectorSupported, expandEnabled, showElementBrowserLink }: UseInsertButtonStateProps) => InsertButtonState;
+export {};

package/dist/types/ui/toolbar-components/hooks/usePopupManager.d.ts

@@ -0,0 +1,21 @@
+import type { RefObject } from 'react';
+import type { INPUT_METHOD } from '@atlaskit/editor-common/analytics';
+import type { TOOLBAR_MENU_TYPE } from '@atlaskit/editor-common/types';
+interface PopupManagerConfig {
+    analytics?: {
+        onToggle?: (isOpen: boolean, inputMethod?: TOOLBAR_MENU_TYPE | INPUT_METHOD) => void;
+    };
+    focusTarget?: RefObject<HTMLElement>;
+    onClose?: () => void;
+    onOpen?: (inputMethod?: TOOLBAR_MENU_TYPE | INPUT_METHOD) => void;
+}
+export declare const usePopupManager: (config?: PopupManagerConfig) => {
+    isOpen: boolean;
+    isOpenedByKeyboard: boolean;
+    toggle: (inputMethod?: TOOLBAR_MENU_TYPE | INPUT_METHOD) => void;
+    close: () => void;
+    handleEscapeKeydown: () => void;
+    handleClickOutside: (e: MouseEvent) => void;
+    handleKeyboardOpen: (event: React.KeyboardEvent) => void;
+};
+export {};

package/dist/types/ui/toolbar-components/hooks/useTableSelectorPopup.d.ts

@@ -0,0 +1,19 @@
+import { INPUT_METHOD } from '@atlaskit/editor-common/analytics';
+import type { ExtractInjectionAPI } from '@atlaskit/editor-common/types';
+import type { InsertBlockPlugin } from '../../../insertBlockPluginType';
+interface UseTableSelectorPopupProps {
+    api?: ExtractInjectionAPI<InsertBlockPlugin>;
+    buttonRef: React.RefObject<HTMLElement>;
+}
+export declare const useTableSelectorPopup: ({ api, buttonRef }: UseTableSelectorPopupProps) => {
+    handleSelectedTableSize: (rowsCount: number, colsCount: number) => void;
+    onPopupUnmount: () => void;
+    isOpen: boolean;
+    isOpenedByKeyboard: boolean;
+    toggle: (inputMethod?: import("@atlaskit/editor-common/types").TOOLBAR_MENU_TYPE | INPUT_METHOD) => void;
+    close: () => void;
+    handleEscapeKeydown: () => void;
+    handleClickOutside: (e: MouseEvent) => void;
+    handleKeyboardOpen: (event: React.KeyboardEvent) => void;
+};
+export {};

package/dist/types/ui/toolbar-components/popups/EmojiPickerPopup.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+import type { EmojiId, EmojiProvider } from '@atlaskit/emoji/types';
+interface EmojiPickerPopupProps {
+    emojiProvider?: Promise<EmojiProvider>;
+    isOpen: boolean;
+    onClickOutside: (e: MouseEvent) => void;
+    onEscapeKeydown: () => void;
+    onSelection: (emojiId: EmojiId) => boolean;
+    onUnmount: () => void;
+    popupsBoundariesElement?: HTMLElement;
+    popupsMountPoint?: HTMLElement;
+    popupsScrollableElement?: HTMLElement;
+    targetRef: React.RefObject<HTMLElement>;
+}
+export declare const EmojiPickerPopup: ({ isOpen, targetRef, emojiProvider, onSelection, onClickOutside, onEscapeKeydown, onUnmount, popupsMountPoint, popupsBoundariesElement, popupsScrollableElement, }: EmojiPickerPopupProps) => React.JSX.Element | null;
+export {};

package/dist/types/ui/toolbar-components/popups/TableSelectorPopupWrapper.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+interface TableSelectorPopupWrapperProps {
+    isOpen: boolean;
+    isOpenedByKeyboard: boolean;
+    onClickOutside: (e: MouseEvent) => void;
+    onEscapeKeydown: () => void;
+    onSelection: (rowsCount: number, colsCount: number) => void;
+    onUnmount: () => void;
+    popupsBoundariesElement?: HTMLElement;
+    popupsMountPoint?: HTMLElement;
+    popupsScrollableElement?: HTMLElement;
+    targetRef: React.RefObject<HTMLElement>;
+}
+export declare const TableSelectorPopupWrapper: ({ isOpen, targetRef, isOpenedByKeyboard, onSelection, onClickOutside, onEscapeKeydown, onUnmount, popupsMountPoint, popupsBoundariesElement, popupsScrollableElement, }: TableSelectorPopupWrapperProps) => React.JSX.Element | null;
+export {};

package/dist/types/ui/toolbar-components/shared/constants.d.ts

@@ -0,0 +1,12 @@
+export declare const POPUP_Z_INDEX = "akEditorMenuZIndex";
+export declare const POPUP_DIMENSIONS: {
+    readonly EMOJI_PICKER: {
+        readonly fitHeight: 350;
+        readonly fitWidth: 350;
+        readonly offset: [number, number];
+    };
+};
+export declare const FOCUS_DELAY: {
+    readonly ANIMATION_FRAME: "requestAnimationFrame";
+    readonly MICROTASK: "queueMicrotask";
+};

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

@@ -0,0 +1,8 @@
+import type { ExtractInjectionAPI } from '@atlaskit/editor-common/types';
+import type { InsertBlockPlugin } from '../../../insertBlockPluginType';
+export interface BaseToolbarButtonProps {
+    api?: ExtractInjectionAPI<InsertBlockPlugin>;
+    popupsBoundariesElement?: HTMLElement;
+    popupsMountPoint?: HTMLElement;
+    popupsScrollableElement?: HTMLElement;
+}

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

@@ -1,10 +1,17 @@
-import type { ExtractInjectionAPI } from '@atlaskit/editor-common/types';
+import type { Command, ExtractInjectionAPI } from '@atlaskit/editor-common/types';
+import type { MenuItem } from '@atlaskit/editor-common/ui-menu';
 import type { RegisterComponent } from '@atlaskit/editor-toolbar-model';
 import type { InsertBlockPlugin } from '../insertBlockPluginType';
 type GetToolbarComponentsProps = {
     api?: ExtractInjectionAPI<InsertBlockPlugin>;
+    expandEnabled?: boolean;
+    horizontalRuleEnabled?: boolean;
+    insertMenuItems?: MenuItem[];
+    nativeStatusSupported?: boolean;
+    onInsertBlockType?: (name: string) => Command;
+    showElementBrowserLink?: boolean;
     tableSelectorSupported?: boolean;
     toolbarShowPlusInsertOnly?: boolean;
 };
-export declare const getToolbarComponents: ({ api, tableSelectorSupported, toolbarShowPlusInsertOnly, }: GetToolbarComponentsProps) => RegisterComponent[];
+export declare const getToolbarComponents: ({ api, tableSelectorSupported, toolbarShowPlusInsertOnly, showElementBrowserLink, onInsertBlockType, nativeStatusSupported, horizontalRuleEnabled, expandEnabled, insertMenuItems, }: GetToolbarComponentsProps) => RegisterComponent[];
 export {};

package/dist/types-ts4.5/insertBlockPluginType.d.ts

@@ -1,10 +1,10 @@
 import type { NextEditorPlugin } from '@atlaskit/editor-common/types';
 import type { InsertBlockPluginOptions, InsertBlockPluginDependencies, InsertBlockPluginState } from './types';
 export type InsertBlockPlugin = NextEditorPlugin<'insertBlock', {
-    pluginConfiguration: InsertBlockPluginOptions | undefined;
-    dependencies: InsertBlockPluginDependencies;
     actions: {
         toggleAdditionalMenu: () => void;
     };
+    dependencies: InsertBlockPluginDependencies;
+    pluginConfiguration: InsertBlockPluginOptions | undefined;
     sharedState: InsertBlockPluginState | undefined;
 }>;

package/dist/types-ts4.5/types/index.d.ts

@@ -56,10 +56,11 @@ export type InsertBlockPluginDependencies = [
     OptionalPlugin<ToolbarPlugin>
 ];
 export interface InsertBlockPluginOptions {
-    allowTables?: boolean;
     allowExpand?: boolean;
-    insertMenuItems?: any;
+    allowTables?: boolean;
+    appearance?: EditorAppearance;
     horizontalRuleEnabled?: boolean;
+    insertMenuItems?: any;
     nativeStatusSupported?: boolean;
     /**
      * To hide the element browser "view more" button in the
@@ -68,7 +69,6 @@ export interface InsertBlockPluginOptions {
      */
     showElementBrowserLink?: boolean;
     tableSelectorSupported?: boolean;
-    appearance?: EditorAppearance;
     /**
      * To hide the individual insert block buttons in the toolbar
      * and only show the plus button

package/dist/types-ts4.5/ui/ElementBrowser/types.d.ts

@@ -8,11 +8,11 @@ type SimpleEventHandler<T> = (event?: T) => void;
 export interface InsertMenuProps {
     dropdownItems: BlockMenuItem[];
     editorView: EditorView;
-    showElementBrowserLink: boolean;
-    toggleVisiblity: SimpleEventHandler<MouseEvent | KeyboardEvent>;
+    isFullPageAppearance?: boolean;
     onInsert: OnInsert;
     pluginInjectionApi: ExtractInjectionAPI<InsertBlockPlugin> | undefined;
-    isFullPageAppearance?: boolean;
+    showElementBrowserLink: boolean;
+    toggleVisiblity: SimpleEventHandler<MouseEvent | KeyboardEvent>;
 }
 export type SvgGetterParams = {
     name: string;

package/dist/types-ts4.5/ui/ToolbarInsertBlock/block-insert-element-browser.d.ts

@@ -8,22 +8,22 @@ type SimpleEventHandler<T> = (event?: T) => void;
 export interface BlockInsertElementBrowserProps {
     disabled: boolean;
     editorView: EditorView;
+    isFullPageAppearance?: boolean;
     items: BlockMenuItem[];
-    spacing: 'none' | 'default';
     label: string;
+    onClick: React.MouseEventHandler;
+    onInsert: OnInsert;
+    onKeyDown?: React.KeyboardEventHandler;
+    onRef(el: HTMLElement): void;
     open: boolean;
+    pluginInjectionApi: ExtractInjectionAPI<InsertBlockPlugin> | undefined;
+    plusButtonRef?: HTMLElement;
     popupsBoundariesElement?: HTMLElement;
     popupsMountPoint?: HTMLElement;
     popupsScrollableElement?: HTMLElement;
-    plusButtonRef?: HTMLElement;
     showElementBrowserLink: boolean;
-    onRef(el: HTMLElement): void;
-    onClick: React.MouseEventHandler;
-    onKeyDown?: React.KeyboardEventHandler;
-    onInsert: OnInsert;
+    spacing: 'none' | 'default';
     togglePlusMenuVisibility: SimpleEventHandler<MouseEvent | KeyboardEvent>;
-    pluginInjectionApi: ExtractInjectionAPI<InsertBlockPlugin> | undefined;
-    isFullPageAppearance?: boolean;
 }
 export declare const BlockInsertElementBrowser: (props: BlockInsertElementBrowserProps) => React.JSX.Element;
 export {};

package/dist/types-ts4.5/ui/ToolbarInsertBlock/block-insert-menu.d.ts

@@ -8,26 +8,26 @@ import type { BlockMenuItem } from './create-items';
 export interface BlockInsertMenuProps {
     disabled: boolean;
     editorView: EditorView;
+    isFullPageAppearance?: boolean;
     items: BlockMenuItem[];
     label: string;
+    onClick: React.MouseEventHandler;
+    onInsert: OnInsert;
+    onItemActivated?: (attrs: {
+        item: MenuItem;
+    }) => void;
+    onKeyDown?: React.KeyboardEventHandler;
+    onOpenChange?: (attrs: any) => void;
+    onPlusButtonRef(el: HTMLElement): void;
+    onRef(el: HTMLElement): void;
     open: boolean;
+    pluginInjectionApi: ExtractInjectionAPI<InsertBlockPlugin> | undefined;
     plusButtonRef?: HTMLElement;
     popupsBoundariesElement?: HTMLElement;
     popupsMountPoint?: HTMLElement;
     popupsScrollableElement?: HTMLElement;
-    spacing: 'none' | 'default';
     showElementBrowserLink: boolean;
-    onRef(el: HTMLElement): void;
-    onPlusButtonRef(el: HTMLElement): void;
-    onClick: React.MouseEventHandler;
-    onItemActivated?: (attrs: {
-        item: MenuItem;
-    }) => void;
-    onInsert: OnInsert;
-    onOpenChange?: (attrs: any) => void;
+    spacing: 'none' | 'default';
     togglePlusMenuVisibility(): void;
-    onKeyDown?: React.KeyboardEventHandler;
-    pluginInjectionApi: ExtractInjectionAPI<InsertBlockPlugin> | undefined;
-    isFullPageAppearance?: boolean;
 }
 export declare const BlockInsertMenu: (props: BlockInsertMenuProps) => React.JSX.Element | null;

package/dist/types-ts4.5/ui/ToolbarInsertBlock/create-items.d.ts

@@ -4,38 +4,38 @@ import type { BlockType } from '@atlaskit/editor-plugin-block-type';
 import type { Schema } from '@atlaskit/editor-prosemirror/model';
 import type { EmojiProvider } from '@atlaskit/emoji/resource';
 export interface CreateItemsConfig {
-    isTypeAheadAllowed?: boolean;
-    tableSupported?: boolean;
-    tableSelectorSupported?: boolean;
-    mediaUploadsEnabled?: boolean;
-    mediaSupported?: boolean;
-    imageUploadSupported?: boolean;
-    imageUploadEnabled?: boolean;
-    mentionsSupported?: boolean;
-    mentionsDisabled?: boolean;
-    availableWrapperBlockTypes?: BlockType[];
     actionSupported?: boolean;
+    availableWrapperBlockTypes?: BlockType[];
+    dateEnabled?: boolean;
     decisionSupported?: boolean;
-    linkSupported?: boolean;
-    linkDisabled?: boolean;
     emojiDisabled?: boolean;
+    emojiProvider?: Promise<EmojiProvider> | EmojiProvider;
+    expandEnabled?: boolean;
+    formatMessage: WrappedComponentProps['intl']['formatMessage'];
     hasEmojiPlugin?: boolean;
-    hasMentionsPlugin?: boolean;
     hasMediaPlugin?: boolean;
-    nativeStatusSupported?: boolean;
-    dateEnabled?: boolean;
-    placeholderTextEnabled?: boolean;
+    hasMentionsPlugin?: boolean;
     horizontalRuleEnabled?: boolean;
-    layoutSectionEnabled?: boolean;
-    showElementBrowserLink?: boolean;
-    expandEnabled?: boolean;
+    imageUploadEnabled?: boolean;
+    imageUploadSupported?: boolean;
     insertMenuItems?: MenuItem[];
-    emojiProvider?: Promise<EmojiProvider> | EmojiProvider;
-    schema: Schema;
-    numberOfButtons: number;
-    formatMessage: WrappedComponentProps['intl']['formatMessage'];
-    isNewMenuEnabled?: boolean;
     isEditorOffline?: boolean;
+    isNewMenuEnabled?: boolean;
+    isTypeAheadAllowed?: boolean;
+    layoutSectionEnabled?: boolean;
+    linkDisabled?: boolean;
+    linkSupported?: boolean;
+    mediaSupported?: boolean;
+    mediaUploadsEnabled?: boolean;
+    mentionsDisabled?: boolean;
+    mentionsSupported?: boolean;
+    nativeStatusSupported?: boolean;
+    numberOfButtons: number;
+    placeholderTextEnabled?: boolean;
+    schema: Schema;
+    showElementBrowserLink?: boolean;
+    tableSelectorSupported?: boolean;
+    tableSupported?: boolean;
 }
 export interface BlockMenuItem extends MenuItem {
     title: JSX.Element | null;

package/dist/types-ts4.5/ui/ToolbarInsertBlock/dropdown-button.d.ts

@@ -6,15 +6,15 @@ import React from 'react';
 import { jsx } from '@emotion/react';
 import type { ToolbarButtonRef } from '@atlaskit/editor-common/ui-menu';
 export interface DropDownButtonProps {
-    label: string;
-    selected: boolean;
-    disabled?: boolean;
     'aria-expanded': React.AriaAttributes['aria-expanded'];
     'aria-haspopup': React.AriaAttributes['aria-haspopup'];
     'aria-keyshortcuts'?: React.AriaAttributes['aria-keyshortcuts'];
+    disabled?: boolean;
+    handleRef(el: ToolbarButtonRef): void;
+    label: string;
     onClick: React.MouseEventHandler;
     onKeyDown?: React.KeyboardEventHandler;
+    selected: boolean;
     spacing: 'none' | 'default';
-    handleRef(el: ToolbarButtonRef): void;
 }
 export declare const DropDownButton: React.MemoExoticComponent<(props: DropDownButtonProps) => jsx.JSX.Element>;

package/dist/types-ts4.5/ui/ToolbarInsertBlock/index.d.ts

@@ -7,8 +7,8 @@ import { jsx } from '@emotion/react';
 import type { WrappedComponentProps } from 'react-intl-next';
 import type { Props, State } from './types';
 export declare const tableButtonWrapper: ({ isTableSelectorOpen, isButtonDisabled, }: {
-    isTableSelectorOpen: boolean;
     isButtonDisabled: boolean | undefined;
+    isTableSelectorOpen: boolean;
 }) => import("@emotion/react").SerializedStyles;
 export declare class ToolbarInsertBlock extends React.PureComponent<Props & WrappedComponentProps, State> {
     private dropdownButtonRef?;

package/dist/types-ts4.5/ui/ToolbarInsertBlock/item.d.ts

@@ -6,11 +6,11 @@ import React from 'react';
 import type { MemoizedFn } from 'memoize-one';
 import type { MenuItem } from '@atlaskit/editor-common/ui-menu';
 export interface CreateInit {
+    'aria-haspopup'?: React.AriaAttributes['aria-haspopup'];
+    'aria-label'?: React.AriaAttributes['aria-label'];
     content: string;
     disabled: boolean;
     tooltipDescription?: string;
-    'aria-label'?: React.AriaAttributes['aria-label'];
-    'aria-haspopup'?: React.AriaAttributes['aria-haspopup'];
 }
 export declare const action: MemoizedFn<(init: CreateInit) => MenuItem>;
 export declare const link: MemoizedFn<(init: CreateInit) => MenuItem>;

package/dist/types-ts4.5/ui/ToolbarInsertBlock/types.d.ts

@@ -9,58 +9,58 @@ import type { EmojiProvider } from '@atlaskit/emoji';
 import type { InsertBlockPlugin } from '../../index';
 import type { BlockMenuItem } from './create-items';
 export interface Props {
-    buttons: number;
-    showElementBrowser: boolean;
-    isReducedSpacing: boolean;
-    isDisabled?: boolean;
-    isTypeAheadAllowed?: boolean;
-    editorView: EditorView;
-    editorActions?: EditorActions;
-    tableSupported?: boolean;
-    tableSelectorSupported?: boolean;
     actionSupported?: boolean;
+    availableWrapperBlockTypes?: BlockType[];
+    buttons: number;
+    dateEnabled?: boolean;
     decisionSupported?: boolean;
-    mentionsSupported?: boolean;
-    mediaUploadsEnabled?: boolean;
-    mediaSupported?: boolean;
-    isEditorOffline?: boolean;
-    imageUploadSupported?: boolean;
-    imageUploadEnabled?: boolean;
+    dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
+    editorActions?: EditorActions;
+    editorAppearance?: EditorAppearance;
+    editorView: EditorView;
+    emojiDisabled?: boolean;
+    emojiProvider?: Promise<EmojiProvider>;
+    expandEnabled?: boolean;
     handleImageUpload?: (event?: ImageUploadPluginReferenceEvent) => Command;
-    dateEnabled?: boolean;
     horizontalRuleEnabled?: boolean;
-    placeholderTextEnabled?: boolean;
+    imageUploadEnabled?: boolean;
+    imageUploadSupported?: boolean;
+    insertMenuItems?: MenuItem[];
+    isDisabled?: boolean;
+    isEditorOffline?: boolean;
+    isReducedSpacing: boolean;
+    isTypeAheadAllowed?: boolean;
     layoutSectionEnabled?: boolean;
-    expandEnabled?: boolean;
-    emojiProvider?: Promise<EmojiProvider>;
-    availableWrapperBlockTypes?: BlockType[];
-    linkSupported?: boolean;
     linkDisabled?: boolean;
-    emojiDisabled?: boolean;
+    linkSupported?: boolean;
+    mediaSupported?: boolean;
+    mediaUploadsEnabled?: boolean;
+    mentionsDisabled?: boolean;
+    mentionsSupported?: boolean;
     nativeStatusSupported?: boolean;
-    popupsMountPoint?: HTMLElement;
-    popupsBoundariesElement?: HTMLElement;
-    popupsScrollableElement?: HTMLElement;
-    insertMenuItems?: MenuItem[];
-    showElementBrowserLink?: boolean;
-    showSeparator?: boolean;
+    onInsertBlockType?: (name: string) => Command;
+    onInsertMacroFromMacroBrowser?: (macroProvider: MacroProvider, node?: PMNode, isEditing?: boolean) => (view: EditorView) => void;
     onShowMediaPicker?: (mountInfo?: {
-        ref: HTMLElement;
         mountPoint: HTMLElement;
+        ref: HTMLElement;
     }) => void;
-    onInsertBlockType?: (name: string) => Command;
-    onInsertMacroFromMacroBrowser?: (macroProvider: MacroProvider, node?: PMNode, isEditing?: boolean) => (view: EditorView) => void;
-    dispatchAnalyticsEvent?: DispatchAnalyticsEvent;
+    placeholderTextEnabled?: boolean;
     pluginInjectionApi: ExtractInjectionAPI<InsertBlockPlugin> | undefined;
-    mentionsDisabled?: boolean;
-    editorAppearance?: EditorAppearance;
+    popupsBoundariesElement?: HTMLElement;
+    popupsMountPoint?: HTMLElement;
+    popupsScrollableElement?: HTMLElement;
+    showElementBrowser: boolean;
+    showElementBrowserLink?: boolean;
+    showSeparator?: boolean;
+    tableSelectorSupported?: boolean;
+    tableSupported?: boolean;
 }
 export interface State {
-    isPlusMenuOpen: boolean;
-    emojiPickerOpen: boolean;
     buttons: BlockMenuItem[];
     dropdownItems: BlockMenuItem[];
+    emojiPickerOpen: boolean;
     isOpenedByKeyboard: boolean;
+    isPlusMenuOpen: boolean;
     isTableSelectorOpen: boolean;
     isTableSelectorOpenedByKeyboard: boolean;
 }

package/dist/types-ts4.5/ui/toolbar-components/EmojiButton.d.ts

@@ -1,8 +1,3 @@
 import React from 'react';
-import type { ExtractInjectionAPI } from '@atlaskit/editor-common/types';
-import type { InsertBlockPlugin } from '../../insertBlockPluginType';
-type EmojiButtonProps = {
-    api?: ExtractInjectionAPI<InsertBlockPlugin>;
-};
-export declare const EmojiButton: ({ api }: EmojiButtonProps) => React.JSX.Element | null;
-export {};
+import type { BaseToolbarButtonProps } from './shared/types';
+export declare const EmojiButton: ({ api, popupsMountPoint, popupsBoundariesElement, popupsScrollableElement }: BaseToolbarButtonProps) => React.JSX.Element | null;