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

package/dist/esm/ui/toolbar-components/hooks/useInsertButtonState.js

@@ -0,0 +1,82 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import { useIntl } from 'react-intl-next';
+import { useSharedPluginStateSelector } from '@atlaskit/editor-common/use-shared-plugin-state-selector';
+import { createItems } from '../../ToolbarInsertBlock/create-items';
+export var useInsertButtonState = function useInsertButtonState(_ref) {
+  var api = _ref.api,
+    editorView = _ref.editorView,
+    horizontalRuleEnabled = _ref.horizontalRuleEnabled,
+    insertMenuItems = _ref.insertMenuItems,
+    nativeStatusSupported = _ref.nativeStatusSupported,
+    numberOfButtons = _ref.numberOfButtons,
+    tableSelectorSupported = _ref.tableSelectorSupported,
+    expandEnabled = _ref.expandEnabled,
+    showElementBrowserLink = _ref.showElementBrowserLink;
+  var _useIntl = useIntl(),
+    formatMessage = _useIntl.formatMessage;
+  var isTypeAheadAllowed = useSharedPluginStateSelector(api, 'typeAhead.isAllowed');
+  var imageUploadEnabled = useSharedPluginStateSelector(api, 'imageUpload.enabled');
+  var mentionsSupported = !!useSharedPluginStateSelector(api, 'mention.mentionProvider');
+  var canInsertMention = useSharedPluginStateSelector(api, 'mention.canInsertMention');
+  var dateEnabled = useSharedPluginStateSelector(api, 'date.isInitialised');
+  var placeholderTextEnabled = useSharedPluginStateSelector(api, 'placeholderText.allowInserting');
+  var mediaAllowsUploads = useSharedPluginStateSelector(api, 'media.allowsUploads');
+  var canInsertLink = useSharedPluginStateSelector(api, 'hyperlink.canInsertLink');
+  var activeLinkMark = useSharedPluginStateSelector(api, 'hyperlink.activeLinkMark');
+  var connectivityMode = useSharedPluginStateSelector(api, 'connectivity.mode');
+  var emojiProvider = useSharedPluginStateSelector(api, 'emoji.emojiProvider');
+  var availableWrapperBlockTypes = useSharedPluginStateSelector(api, 'blockType.availableWrapperBlockTypes');
+
+  // Computed values
+  var mediaUploadsEnabled = mediaAllowsUploads;
+  var mediaSupported = mediaAllowsUploads !== undefined;
+  var isEditorOffline = connectivityMode === 'offline';
+  var imageUploadSupported = !!(api !== null && api !== void 0 && api.imageUpload);
+  var mentionsDisabled = !canInsertMention;
+  var linkSupported = canInsertLink !== undefined;
+  var linkDisabled = !canInsertLink || !!activeLinkMark;
+  var emojiDisabled = !emojiProvider;
+  var actionSupported = !!(editorView !== null && editorView !== void 0 && editorView.state.schema.nodes.taskItem);
+  var decisionSupported = !!(editorView !== null && editorView !== void 0 && editorView.state.schema.nodes.decisionItem);
+  var layoutSectionEnabled = !!(api !== null && api !== void 0 && api.layout);
+  var _ref2 = editorView !== null && editorView !== void 0 && editorView.state.schema ? createItems({
+      isTypeAheadAllowed: isTypeAheadAllowed,
+      tableSupported: !!(editorView !== null && editorView !== void 0 && editorView.state.schema.nodes.table),
+      tableSelectorSupported: tableSelectorSupported,
+      mediaUploadsEnabled: mediaUploadsEnabled,
+      mediaSupported: mediaSupported,
+      isEditorOffline: isEditorOffline,
+      imageUploadSupported: imageUploadSupported,
+      imageUploadEnabled: imageUploadEnabled,
+      mentionsSupported: mentionsSupported,
+      mentionsDisabled: mentionsDisabled,
+      actionSupported: actionSupported,
+      decisionSupported: decisionSupported,
+      linkSupported: linkSupported,
+      linkDisabled: linkDisabled,
+      emojiDisabled: emojiDisabled,
+      hasEmojiPlugin: !!(api !== null && api !== void 0 && api.emoji),
+      hasMentionsPlugin: !!(api !== null && api !== void 0 && api.mention),
+      hasMediaPlugin: !!(api !== null && api !== void 0 && api.media),
+      nativeStatusSupported: nativeStatusSupported,
+      dateEnabled: dateEnabled,
+      placeholderTextEnabled: placeholderTextEnabled,
+      horizontalRuleEnabled: horizontalRuleEnabled,
+      layoutSectionEnabled: layoutSectionEnabled,
+      expandEnabled: expandEnabled,
+      showElementBrowserLink: showElementBrowserLink,
+      emojiProvider: emojiProvider,
+      availableWrapperBlockTypes: availableWrapperBlockTypes,
+      insertMenuItems: insertMenuItems,
+      schema: editorView === null || editorView === void 0 ? void 0 : editorView.state.schema,
+      numberOfButtons: numberOfButtons || 0,
+      formatMessage: formatMessage
+    }) : [, []],
+    _ref3 = _slicedToArray(_ref2, 2),
+    dropdownItems = _ref3[1];
+  return {
+    dropdownItems: dropdownItems,
+    emojiProvider: emojiProvider,
+    isTypeAheadAllowed: isTypeAheadAllowed
+  };
+};

package/dist/esm/ui/toolbar-components/hooks/usePopupManager.js

@@ -0,0 +1,58 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import { useState, useCallback } from 'react';
+import { isDetachedElement } from '../utils/utils';
+export var usePopupManager = function usePopupManager() {
+  var config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var _useState = useState(false),
+    _useState2 = _slicedToArray(_useState, 2),
+    isOpen = _useState2[0],
+    setIsOpen = _useState2[1];
+  var _useState3 = useState(false),
+    _useState4 = _slicedToArray(_useState3, 2),
+    isOpenedByKeyboard = _useState4[0],
+    setIsOpenedByKeyboard = _useState4[1];
+  var toggle = useCallback(function (inputMethod) {
+    var _config$analytics, _config$analytics$onT;
+    var newState = !isOpen;
+    setIsOpen(newState);
+    if (newState) {
+      var _config$onOpen;
+      (_config$onOpen = config.onOpen) === null || _config$onOpen === void 0 || _config$onOpen.call(config, inputMethod);
+    } else {
+      var _config$onClose;
+      (_config$onClose = config.onClose) === null || _config$onClose === void 0 || _config$onClose.call(config);
+    }
+    (_config$analytics = config.analytics) === null || _config$analytics === void 0 || (_config$analytics$onT = _config$analytics.onToggle) === null || _config$analytics$onT === void 0 || _config$analytics$onT.call(_config$analytics, newState, inputMethod);
+  }, [isOpen, config]);
+  var close = useCallback(function () {
+    var _config$onClose2, _config$analytics2, _config$analytics2$on;
+    setIsOpen(false);
+    (_config$onClose2 = config.onClose) === null || _config$onClose2 === void 0 || _config$onClose2.call(config);
+    (_config$analytics2 = config.analytics) === null || _config$analytics2 === void 0 || (_config$analytics2$on = _config$analytics2.onToggle) === null || _config$analytics2$on === void 0 || _config$analytics2$on.call(_config$analytics2, false);
+  }, [config]);
+  var handleEscapeKeydown = useCallback(function () {
+    var _config$focusTarget;
+    close();
+    (_config$focusTarget = config.focusTarget) === null || _config$focusTarget === void 0 || (_config$focusTarget = _config$focusTarget.current) === null || _config$focusTarget === void 0 || _config$focusTarget.focus();
+  }, [close, config.focusTarget]);
+  var handleClickOutside = useCallback(function (e) {
+    if (e.target instanceof HTMLElement && !isDetachedElement(e.target)) {
+      close();
+    }
+  }, [close]);
+  var handleKeyboardOpen = useCallback(function (event) {
+    if (event.key === 'Enter' || event.key === ' ') {
+      setIsOpenedByKeyboard(true);
+      event.preventDefault();
+    }
+  }, []);
+  return {
+    isOpen: isOpen,
+    isOpenedByKeyboard: isOpenedByKeyboard,
+    toggle: toggle,
+    close: close,
+    handleEscapeKeydown: handleEscapeKeydown,
+    handleClickOutside: handleClickOutside,
+    handleKeyboardOpen: handleKeyboardOpen
+  };
+};

package/dist/esm/ui/toolbar-components/hooks/useTableSelectorPopup.js

@@ -0,0 +1,28 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+import { useCallback } from 'react';
+import { INPUT_METHOD } from '@atlaskit/editor-common/analytics';
+import { usePopupManager } from './usePopupManager';
+export var useTableSelectorPopup = function useTableSelectorPopup(_ref) {
+  var api = _ref.api,
+    buttonRef = _ref.buttonRef;
+  var popupManager = usePopupManager({
+    focusTarget: buttonRef
+  });
+  var handleSelectedTableSize = useCallback(function (rowsCount, colsCount) {
+    // workaround to solve race condition where cursor is not placed correctly inside table
+    queueMicrotask(function () {
+      var _api$core, _api$table;
+      api === null || api === void 0 || (_api$core = api.core) === null || _api$core === void 0 || _api$core.actions.execute(api === null || api === void 0 || (_api$table = api.table) === null || _api$table === void 0 ? void 0 : _api$table.commands.insertTableWithSize(rowsCount, colsCount, INPUT_METHOD.PICKER));
+    });
+    popupManager.close();
+  }, [api, popupManager]);
+  var onPopupUnmount = useCallback(function () {
+    api === null || api === void 0 || api.core.actions.focus();
+  }, [api]);
+  return _objectSpread(_objectSpread({}, popupManager), {}, {
+    handleSelectedTableSize: handleSelectedTableSize,
+    onPopupUnmount: onPopupUnmount
+  });
+};

package/dist/esm/ui/toolbar-components/popups/EmojiPickerPopup.js

@@ -0,0 +1,46 @@
+import React from 'react';
+import { Popup } from '@atlaskit/editor-common/ui';
+import { OutsideClickTargetRefContext, withReactEditorViewOuterListeners as withOuterListeners } from '@atlaskit/editor-common/ui-react';
+import { akEditorMenuZIndex } from '@atlaskit/editor-shared-styles';
+import { EmojiPicker as AkEmojiPicker } from '@atlaskit/emoji/picker';
+var EmojiPicker = function EmojiPicker(props) {
+  var setOutsideClickTargetRef = React.useContext(OutsideClickTargetRefContext);
+  return /*#__PURE__*/React.createElement(AkEmojiPicker, {
+    onPickerRef: setOutsideClickTargetRef,
+    emojiProvider: props.emojiProvider,
+    onSelection: props.onSelection
+  });
+};
+var EmojiPickerWithListeners = withOuterListeners(EmojiPicker);
+export var EmojiPickerPopup = function EmojiPickerPopup(_ref) {
+  var isOpen = _ref.isOpen,
+    targetRef = _ref.targetRef,
+    emojiProvider = _ref.emojiProvider,
+    onSelection = _ref.onSelection,
+    onClickOutside = _ref.onClickOutside,
+    onEscapeKeydown = _ref.onEscapeKeydown,
+    onUnmount = _ref.onUnmount,
+    popupsMountPoint = _ref.popupsMountPoint,
+    popupsBoundariesElement = _ref.popupsBoundariesElement,
+    popupsScrollableElement = _ref.popupsScrollableElement;
+  if (!isOpen || !targetRef.current || !emojiProvider) {
+    return null;
+  }
+  return /*#__PURE__*/React.createElement(Popup, {
+    target: targetRef.current,
+    fitHeight: 350,
+    fitWidth: 350,
+    offset: [0, 3],
+    mountTo: popupsMountPoint,
+    boundariesElement: popupsBoundariesElement,
+    scrollableElement: popupsScrollableElement,
+    onUnmount: onUnmount,
+    focusTrap: true,
+    zIndex: akEditorMenuZIndex
+  }, /*#__PURE__*/React.createElement(EmojiPickerWithListeners, {
+    emojiProvider: emojiProvider,
+    onSelection: onSelection,
+    handleClickOutside: onClickOutside,
+    handleEscapeKeydown: onEscapeKeydown
+  }));
+};

package/dist/esm/ui/toolbar-components/popups/TableSelectorPopupWrapper.js

@@ -0,0 +1,29 @@
+import React from 'react';
+import { TableSelectorPopup } from '@atlaskit/editor-common/ui';
+export var TableSelectorPopupWrapper = function TableSelectorPopupWrapper(_ref) {
+  var isOpen = _ref.isOpen,
+    targetRef = _ref.targetRef,
+    isOpenedByKeyboard = _ref.isOpenedByKeyboard,
+    onSelection = _ref.onSelection,
+    onClickOutside = _ref.onClickOutside,
+    onEscapeKeydown = _ref.onEscapeKeydown,
+    onUnmount = _ref.onUnmount,
+    popupsMountPoint = _ref.popupsMountPoint,
+    popupsBoundariesElement = _ref.popupsBoundariesElement,
+    popupsScrollableElement = _ref.popupsScrollableElement;
+  if (!isOpen || !targetRef.current) {
+    return null;
+  }
+  return /*#__PURE__*/React.createElement(TableSelectorPopup, {
+    allowOutsideSelection: true,
+    target: targetRef.current,
+    onUnmount: onUnmount,
+    onSelection: onSelection,
+    popupsMountPoint: popupsMountPoint,
+    popupsBoundariesElement: popupsBoundariesElement,
+    popupsScrollableElement: popupsScrollableElement,
+    handleClickOutside: onClickOutside,
+    handleEscapeKeydown: onEscapeKeydown,
+    isOpenedByKeyboard: isOpenedByKeyboard
+  });
+};

package/dist/esm/ui/toolbar-components/shared/constants.js

@@ -0,0 +1,12 @@
+export var POPUP_Z_INDEX = 'akEditorMenuZIndex';
+export var POPUP_DIMENSIONS = {
+  EMOJI_PICKER: {
+    fitHeight: 350,
+    fitWidth: 350,
+    offset: [0, 3]
+  }
+};
+export var FOCUS_DELAY = {
+  ANIMATION_FRAME: 'requestAnimationFrame',
+  MICROTASK: 'queueMicrotask'
+};

package/dist/esm/ui/toolbar-components/shared/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/ui/toolbar-components.js

@@ -1,8 +1,9 @@
 import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
 import React from 'react';
-import { INSERT_BLOCK_SECTION, TASK_LIST_GROUP, MEDIA_GROUP, INSERT_BLOCK_SECTION_RANK, TASK_LIST_BUTTON, TASK_LIST_GROUP_RANK, MEDIA_BUTTON, MENTION_GROUP, MEDIA_GROUP_RANK, MENTION_BUTTON, MENTION_GROUP_RANK, EMOJI_GROUP, EMOJI_BUTTON, EMOJI_GROUP_RANK, LAYOUT_GROUP, LAYOUT_BUTTON, LAYOUT_GROUP_RANK, TABLE_GROUP_RANK, TABLE_BUTTON, TABLE_GROUP, TABLE_SIZE_PICKER } from '@atlaskit/editor-common/toolbar';
+import { INSERT_BLOCK_SECTION, TASK_LIST_GROUP, MEDIA_GROUP, INSERT_BLOCK_SECTION_RANK, TASK_LIST_BUTTON, TASK_LIST_GROUP_RANK, MEDIA_BUTTON, MENTION_GROUP, MEDIA_GROUP_RANK, MENTION_BUTTON, MENTION_GROUP_RANK, EMOJI_GROUP, EMOJI_BUTTON, EMOJI_GROUP_RANK, LAYOUT_GROUP, LAYOUT_BUTTON, LAYOUT_GROUP_RANK, TABLE_GROUP_RANK, TABLE_BUTTON, TABLE_GROUP, TABLE_SIZE_PICKER, INSERT_GROUP, INSERT_BUTTON, INSERT_GROUP_RANK } from '@atlaskit/editor-common/toolbar';
 import { EmojiButton } from './toolbar-components/EmojiButton';
 import { ImageButton } from './toolbar-components/ImageButton';
+import { InsertButton } from './toolbar-components/InsertButton';
 import { LayoutButton } from './toolbar-components/LayoutButton';
 import { MediaButton } from './toolbar-components/MediaButton';
 import { MentionButton } from './toolbar-components/MentionButton';
@@ -12,8 +13,42 @@ import { TaskListButton } from './toolbar-components/TaskListButton';
 export var getToolbarComponents = function getToolbarComponents(_ref) {
   var api = _ref.api,
     tableSelectorSupported = _ref.tableSelectorSupported,
-    toolbarShowPlusInsertOnly = _ref.toolbarShowPlusInsertOnly;
-  return _toConsumableArray(toolbarShowPlusInsertOnly ? [] : [{
+    toolbarShowPlusInsertOnly = _ref.toolbarShowPlusInsertOnly,
+    showElementBrowserLink = _ref.showElementBrowserLink,
+    onInsertBlockType = _ref.onInsertBlockType,
+    nativeStatusSupported = _ref.nativeStatusSupported,
+    horizontalRuleEnabled = _ref.horizontalRuleEnabled,
+    expandEnabled = _ref.expandEnabled,
+    insertMenuItems = _ref.insertMenuItems;
+  return _toConsumableArray(toolbarShowPlusInsertOnly ? [{
+    type: INSERT_GROUP.type,
+    key: INSERT_GROUP.key,
+    parents: [{
+      type: INSERT_BLOCK_SECTION.type,
+      key: INSERT_BLOCK_SECTION.key,
+      rank: INSERT_BLOCK_SECTION_RANK[INSERT_GROUP.key]
+    }]
+  }, {
+    type: INSERT_BUTTON.type,
+    key: INSERT_BUTTON.key,
+    parents: [{
+      type: INSERT_GROUP.type,
+      key: INSERT_GROUP.key,
+      rank: INSERT_GROUP_RANK[INSERT_BUTTON.key]
+    }],
+    component: function component() {
+      return /*#__PURE__*/React.createElement(InsertButton, {
+        api: api,
+        showElementBrowserLink: showElementBrowserLink,
+        tableSelectorSupported: tableSelectorSupported,
+        onInsertBlockType: onInsertBlockType,
+        nativeStatusSupported: nativeStatusSupported,
+        horizontalRuleEnabled: horizontalRuleEnabled,
+        expandEnabled: expandEnabled,
+        insertMenuItems: insertMenuItems
+      });
+    }
+  }] : [{
     type: TASK_LIST_GROUP.type,
     key: TASK_LIST_GROUP.key,
     parents: [{
@@ -155,5 +190,34 @@ export var getToolbarComponents = function getToolbarComponents(_ref) {
         tableSelectorSupported: tableSelectorSupported
       });
     }
+  }, {
+    type: INSERT_GROUP.type,
+    key: INSERT_GROUP.key,
+    parents: [{
+      type: INSERT_BLOCK_SECTION.type,
+      key: INSERT_BLOCK_SECTION.key,
+      rank: INSERT_BLOCK_SECTION_RANK[INSERT_GROUP.key]
+    }]
+  }, {
+    type: INSERT_BUTTON.type,
+    key: INSERT_BUTTON.key,
+    parents: [{
+      type: INSERT_GROUP.type,
+      key: INSERT_GROUP.key,
+      rank: INSERT_GROUP_RANK[INSERT_BUTTON.key]
+    }],
+    component: function component() {
+      return /*#__PURE__*/React.createElement(InsertButton, {
+        api: api,
+        showElementBrowserLink: showElementBrowserLink,
+        tableSelectorSupported: tableSelectorSupported,
+        onInsertBlockType: onInsertBlockType,
+        nativeStatusSupported: nativeStatusSupported,
+        horizontalRuleEnabled: horizontalRuleEnabled,
+        expandEnabled: expandEnabled,
+        insertMenuItems: insertMenuItems,
+        numberOfButtons: 7 // TODO: ED-28759 - Default to 7 buttons - Remove this once we have a proper way to do toolbar responsiveness
+      });
+    }
   }]);
 };

package/dist/types/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/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/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/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/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/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/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/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/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>;