@atlaskit/editor-core 187.17.6 → 187.18.1

package/dist/es2019/plugins/text-formatting/ui/Toolbar/dropdown-menu.js

@@ -1,66 +0,0 @@
-import React, { useCallback, useMemo, useState } from 'react';
-import { akEditorMenuZIndex } from '@atlaskit/editor-shared-styles';
-import { DropdownMenuWithKeyboardNavigation as DropdownMenu } from '@atlaskit/editor-common/ui-menu';
-import { useMenuState } from './hooks/menu-state';
-import { MoreButton } from './more-button';
-export const FormattingTextDropdownMenu = /*#__PURE__*/React.memo(({
-  editorView,
-  moreButtonLabel,
-  isReducedSpacing,
-  items,
-  hasFormattingActive,
-  popupsBoundariesElement,
-  popupsMountPoint,
-  popupsScrollableElement
-}) => {
-  const [isMenuOpen, toggleMenu, closeMenu] = useMenuState();
-  const [isOpenedByKeyboard, setIsOpenedByKeyboard] = useState(false);
-  const group = useMemo(() => [{
-    items
-  }], [items]);
-  const onItemActivated = useCallback(({
-    item,
-    shouldCloseMenu = true
-  }) => {
-    item.command(editorView.state, editorView.dispatch);
-    if (shouldCloseMenu) {
-      closeMenu();
-    }
-  }, [editorView.state, editorView.dispatch, closeMenu]);
-  return /*#__PURE__*/React.createElement(DropdownMenu, {
-    mountTo: popupsMountPoint,
-    onOpenChange: closeMenu,
-    boundariesElement: popupsBoundariesElement,
-    scrollableElement: popupsScrollableElement,
-    onItemActivated: onItemActivated,
-    isOpen: isMenuOpen,
-    items: group,
-    zIndex: akEditorMenuZIndex,
-    fitHeight: 188,
-    fitWidth: 136,
-    shouldUseDefaultRole: true,
-    shouldFocusFirstItem: () => {
-      if (isOpenedByKeyboard) {
-        setIsOpenedByKeyboard(false);
-      }
-      return isOpenedByKeyboard;
-    }
-  }, /*#__PURE__*/React.createElement(MoreButton, {
-    isSelected: isMenuOpen || hasFormattingActive,
-    label: moreButtonLabel,
-    isReducedSpacing: isReducedSpacing,
-    isDisabled: false,
-    onClick: () => {
-      toggleMenu();
-      setIsOpenedByKeyboard(false);
-    },
-    onKeyDown: event => {
-      if (event.key === 'Enter' || event.key === ' ') {
-        event.preventDefault();
-        toggleMenu();
-        setIsOpenedByKeyboard(true);
-      }
-    },
-    "aria-expanded": isMenuOpen
-  }));
-});

package/dist/es2019/plugins/text-formatting/ui/Toolbar/hooks/clear-formatting-icon.js

@@ -1,42 +0,0 @@
-/** @jsx jsx */
-import { useCallback, useMemo } from 'react';
-import { jsx } from '@emotion/react';
-import { shortcutStyle } from '@atlaskit/editor-shared-styles/shortcut';
-import { toolbarMessages } from '@atlaskit/editor-common/messages';
-import { clearFormattingWithAnalytics } from '../../../commands/clear-formatting';
-import { pluginKey as clearFormattingPluginKey } from '../../../pm-plugins/clear-formatting';
-import { clearFormatting as clearFormattingKeymap, tooltip } from '@atlaskit/editor-common/keymaps';
-import { INPUT_METHOD } from '@atlaskit/editor-common/analytics';
-const useClearFormattingPluginState = editorState => {
-  return useMemo(() => clearFormattingPluginKey.getState(editorState), [editorState]);
-};
-export const useClearIcon = ({
-  intl,
-  editorState,
-  editorAnalyticsAPI
-}) => {
-  const pluginState = useClearFormattingPluginState(editorState);
-  const isPluginAvailable = Boolean(pluginState);
-  const formattingIsPresent = Boolean(pluginState === null || pluginState === void 0 ? void 0 : pluginState.formattingIsPresent);
-  const clearFormattingLabel = intl.formatMessage(toolbarMessages.clearFormatting);
-  const clearFormattingToolbar = useCallback((state, dispatch) => clearFormattingWithAnalytics(INPUT_METHOD.TOOLBAR, editorAnalyticsAPI)(state, dispatch), [editorAnalyticsAPI]);
-  return useMemo(() => {
-    if (!isPluginAvailable) {
-      return null;
-    }
-    return {
-      key: 'clearFormatting',
-      command: clearFormattingToolbar,
-      content: clearFormattingLabel,
-      elemAfter: jsx("div", {
-        css: shortcutStyle
-      }, tooltip(clearFormattingKeymap)),
-      value: {
-        name: 'clearFormatting'
-      },
-      isActive: false,
-      isDisabled: !formattingIsPresent,
-      'aria-label': clearFormattingKeymap ? tooltip(clearFormattingKeymap, String(clearFormattingLabel)) : String(clearFormattingLabel)
-    };
-  }, [isPluginAvailable, clearFormattingToolbar, clearFormattingLabel, formattingIsPresent]);
-};

package/dist/es2019/plugins/text-formatting/ui/Toolbar/hooks/formatting-icons.js

@@ -1,210 +0,0 @@
-/** @jsx jsx */
-import React, { useMemo } from 'react';
-import { jsx } from '@emotion/react';
-import BoldIcon from '@atlaskit/icon/glyph/editor/bold';
-import ItalicIcon from '@atlaskit/icon/glyph/editor/italic';
-import { shortcutStyle } from '@atlaskit/editor-shared-styles/shortcut';
-import { toolbarMessages } from '@atlaskit/editor-common/messages';
-import { toggleStrongWithAnalytics, toggleEmWithAnalytics, toggleCodeWithAnalytics, toggleStrikeWithAnalytics, toggleSubscriptWithAnalytics, toggleSuperscriptWithAnalytics, toggleUnderlineWithAnalytics } from '../../../actions';
-import { TOOLBAR_ACTION_SUBJECT_ID, INPUT_METHOD } from '@atlaskit/editor-common/analytics';
-import { pluginKey as textFormattingPluginKey } from '../../../pm-plugins/plugin-key';
-import { toggleCode, toggleStrikethrough, toggleUnderline, tooltip, toggleBold, toggleItalic, toggleSubscript, toggleSuperscript, ToolTipContent, getAriaKeyshortcuts } from '@atlaskit/editor-common/keymaps';
-import { IconTypes } from '../types';
-const withToolbarInputMethod = func => func({
-  inputMethod: INPUT_METHOD.TOOLBAR
-});
-const IconButtons = editorAnalyticsAPI => ({
-  strong: {
-    buttonId: TOOLBAR_ACTION_SUBJECT_ID.TEXT_FORMATTING_STRONG,
-    command: withToolbarInputMethod(toggleStrongWithAnalytics(editorAnalyticsAPI)),
-    message: toolbarMessages.bold,
-    tooltipKeymap: toggleBold,
-    component: () => jsx(BoldIcon, {
-      label: ""
-    })
-  },
-  em: {
-    buttonId: TOOLBAR_ACTION_SUBJECT_ID.TEXT_FORMATTING_ITALIC,
-    command: withToolbarInputMethod(toggleEmWithAnalytics(editorAnalyticsAPI)),
-    message: toolbarMessages.italic,
-    tooltipKeymap: toggleItalic,
-    component: () => jsx(ItalicIcon, {
-      label: ""
-    })
-  },
-  underline: {
-    command: withToolbarInputMethod(toggleUnderlineWithAnalytics(editorAnalyticsAPI)),
-    message: toolbarMessages.underline,
-    tooltipKeymap: toggleUnderline
-  },
-  strike: {
-    command: withToolbarInputMethod(toggleStrikeWithAnalytics(editorAnalyticsAPI)),
-    message: toolbarMessages.strike,
-    tooltipKeymap: toggleStrikethrough
-  },
-  code: {
-    command: withToolbarInputMethod(toggleCodeWithAnalytics(editorAnalyticsAPI)),
-    message: toolbarMessages.code,
-    tooltipKeymap: toggleCode
-  },
-  subscript: {
-    command: withToolbarInputMethod(toggleSubscriptWithAnalytics(editorAnalyticsAPI)),
-    message: toolbarMessages.subscript,
-    tooltipKeymap: toggleSubscript
-  },
-  superscript: {
-    command: withToolbarInputMethod(toggleSuperscriptWithAnalytics(editorAnalyticsAPI)),
-    message: toolbarMessages.superscript,
-    tooltipKeymap: toggleSuperscript
-  }
-});
-const getIcon = ({
-  iconType,
-  isDisabled,
-  isActive,
-  intl,
-  editorAnalyticsAPI
-}) => {
-  const icon = IconButtons(editorAnalyticsAPI)[iconType];
-  const content = intl.formatMessage(icon.message);
-  const {
-    tooltipKeymap
-  } = icon;
-  return {
-    content,
-    buttonId: icon.buttonId,
-    iconMark: iconType,
-    key: iconType,
-    command: icon.command,
-    iconElement: icon.component ? icon.component() : undefined,
-    tooltipElement: tooltipKeymap ? jsx(ToolTipContent, {
-      description: content,
-      keymap: tooltipKeymap
-    }) : undefined,
-    elemAfter: tooltipKeymap ? jsx("div", {
-      css: shortcutStyle
-    }, tooltip(tooltipKeymap)) : undefined,
-    value: {
-      name: iconType
-    },
-    isActive,
-    isDisabled,
-    'aria-label': tooltipKeymap ? tooltip(tooltipKeymap, String(content)) : String(content),
-    'aria-keyshortcuts': getAriaKeyshortcuts(tooltipKeymap)
-  };
-};
-const IconsMarkSchema = {
-  [IconTypes.strong]: 'strong',
-  [IconTypes.em]: 'em',
-  [IconTypes.strike]: 'strike',
-  [IconTypes.code]: 'code',
-  [IconTypes.underline]: 'underline',
-  [IconTypes.superscript]: 'subsup',
-  [IconTypes.subscript]: 'subsup'
-};
-const buildMenuIconState = iconMark => ({
-  schema,
-  textFormattingPluginState
-}) => {
-  const hasPluginState = Boolean(Object.keys(textFormattingPluginState || {}).length);
-  const markSchema = IconsMarkSchema[iconMark];
-  const hasSchemaMark = Boolean(schema.marks[markSchema]);
-  if (!hasPluginState) {
-    return {
-      isActive: false,
-      isDisabled: true,
-      isHidden: false,
-      hasSchemaMark
-    };
-  }
-  const isActive = textFormattingPluginState[`${iconMark}Active`];
-  const isDisabled = textFormattingPluginState[`${iconMark}Disabled`];
-  const isHidden = textFormattingPluginState[`${iconMark}Hidden`];
-  return {
-    isActive: Boolean(isActive),
-    isDisabled: Boolean(isDisabled),
-    isHidden: Boolean(isHidden),
-    hasSchemaMark
-  };
-};
-const buildIcon = (iconMark, editorAnalyticsAPI) => {
-  const getState = buildMenuIconState(iconMark);
-  return ({
-    schema,
-    textFormattingPluginState,
-    intl,
-    isToolbarDisabled
-  }) => {
-    const iconState = getState({
-      schema,
-      textFormattingPluginState
-    });
-    const {
-      isActive,
-      isDisabled,
-      isHidden,
-      hasSchemaMark
-    } = iconState;
-    const iconComponent = useMemo(() => getIcon({
-      iconType: IconTypes[iconMark],
-      isDisabled: isToolbarDisabled || isDisabled,
-      isActive,
-      intl,
-      editorAnalyticsAPI
-    }), [isToolbarDisabled, isDisabled, isActive, intl]);
-    const shouldRenderIcon = hasSchemaMark && !isHidden;
-    return useMemo(() => shouldRenderIcon ? iconComponent : null, [shouldRenderIcon, iconComponent]);
-  };
-};
-const useTextFormattingPluginState = editorState => useMemo(() => {
-  const pluginState = textFormattingPluginKey.getState(editorState);
-
-  // TODO: ED-13910 for reasons that goes beyond my knowledge. This is the only way to make the current unit tests happy. Even thought this was wrong before
-  return pluginState;
-}, [editorState]);
-export const useFormattingIcons = ({
-  isToolbarDisabled,
-  editorState,
-  intl,
-  editorAnalyticsAPI
-}) => {
-  const textFormattingPluginState = useTextFormattingPluginState(editorState);
-  const {
-    schema
-  } = editorState;
-  const props = {
-    schema,
-    textFormattingPluginState,
-    intl,
-    isToolbarDisabled: Boolean(isToolbarDisabled)
-  };
-  const buildStrongIcon = buildIcon(IconTypes.strong, editorAnalyticsAPI);
-  const buildEmIcon = buildIcon(IconTypes.em, editorAnalyticsAPI);
-  const buildUnderlineIcon = buildIcon(IconTypes.underline, editorAnalyticsAPI);
-  const buildStrikeIcon = buildIcon(IconTypes.strike, editorAnalyticsAPI);
-  const buildCodeIcon = buildIcon(IconTypes.code, editorAnalyticsAPI);
-  const buildSubscriptIcon = buildIcon(IconTypes.subscript, editorAnalyticsAPI);
-  const buildSuperscriptIcon = buildIcon(IconTypes.superscript, editorAnalyticsAPI);
-  const strongIcon = buildStrongIcon(props);
-  const emIcon = buildEmIcon(props);
-  const underlineIcon = buildUnderlineIcon(props);
-  const strikeIcon = buildStrikeIcon(props);
-  const codeIcon = buildCodeIcon(props);
-  const subscriptIcon = buildSubscriptIcon(props);
-  const superscriptIcon = buildSuperscriptIcon(props);
-  const result = useMemo(() => [strongIcon, emIcon, underlineIcon, strikeIcon, codeIcon, subscriptIcon, superscriptIcon], [strongIcon, emIcon, underlineIcon, strikeIcon, codeIcon, subscriptIcon, superscriptIcon]);
-  return result;
-};
-export const useHasFormattingActived = ({
-  editorState,
-  iconTypeList
-}) => {
-  const textFormattingPluginState = useTextFormattingPluginState(editorState);
-  const hasActiveFormatting = useMemo(() => {
-    if (!textFormattingPluginState) {
-      return false;
-    }
-    return iconTypeList.some(iconType => textFormattingPluginState[`${iconType}Active`]);
-  }, [textFormattingPluginState, iconTypeList]);
-  return hasActiveFormatting;
-};

package/dist/es2019/plugins/text-formatting/ui/Toolbar/hooks/menu-state.js

@@ -1,11 +0,0 @@
-import { useCallback, useState } from 'react';
-export const useMenuState = () => {
-  const [isMenuOpen, setIsMenuOpened] = useState(false);
-  const toggleMenu = useCallback(() => {
-    setIsMenuOpened(!isMenuOpen);
-  }, [isMenuOpen]);
-  const closeMenu = useCallback(() => {
-    setIsMenuOpened(false);
-  }, []);
-  return [isMenuOpen, toggleMenu, closeMenu];
-};

package/dist/es2019/plugins/text-formatting/ui/Toolbar/hooks/responsive-toolbar-buttons.js

@@ -1,48 +0,0 @@
-import { useMemo } from 'react';
-import { ResponsiveCustomButtonToolbar, ResponsiveCustomMenu, DefaultButtonsMenu, DefaultButtonsToolbar } from '../constants';
-export const useResponsiveIconTypeButtons = ({
-  toolbarSize,
-  responsivenessEnabled
-}) => {
-  const iconTypeList = useMemo(() => ResponsiveCustomButtonToolbar[toolbarSize], [toolbarSize]);
-  return responsivenessEnabled ? iconTypeList : DefaultButtonsToolbar;
-};
-export const useResponsiveIconTypeMenu = ({
-  toolbarSize,
-  responsivenessEnabled
-}) => {
-  const iconTypeList = useMemo(() => ResponsiveCustomMenu[toolbarSize], [toolbarSize]);
-  return responsivenessEnabled ? iconTypeList : DefaultButtonsMenu;
-};
-export const useResponsiveToolbarButtons = ({
-  icons,
-  toolbarSize,
-  responsivenessEnabled
-}) => {
-  const iconTypeList = useResponsiveIconTypeButtons({
-    toolbarSize,
-    responsivenessEnabled
-  });
-  const iconsPosition = useMemo(() => {
-    return icons.reduce((acc, icon) => {
-      if (!icon || !icon.iconMark) {
-        return acc;
-      }
-      const isIconSingleButton = iconTypeList.includes(icon.iconMark);
-      if (isIconSingleButton) {
-        return {
-          dropdownItems: acc.dropdownItems,
-          singleItems: [...acc.singleItems, icon]
-        };
-      }
-      return {
-        dropdownItems: [...acc.dropdownItems, icon],
-        singleItems: acc.singleItems
-      };
-    }, {
-      dropdownItems: [],
-      singleItems: []
-    });
-  }, [icons, iconTypeList]);
-  return iconsPosition;
-};

package/dist/es2019/plugins/text-formatting/ui/Toolbar/index.js

@@ -1,168 +0,0 @@
-/** @jsx jsx */
-import React, { useMemo, useState, useEffect } from 'react';
-import { jsx } from '@emotion/react';
-import { injectIntl } from 'react-intl-next';
-import { separatorStyles, buttonGroupStyle, wrapperStyle } from '@atlaskit/editor-common/styles';
-import { useFormattingIcons, useHasFormattingActived } from './hooks/formatting-icons';
-import { useClearIcon } from './hooks/clear-formatting-icon';
-import { useResponsiveToolbarButtons, useResponsiveIconTypeMenu } from './hooks/responsive-toolbar-buttons';
-import { SingleToolbarButtons } from './single-toolbar-buttons';
-import { MoreButton } from './more-button';
-import { FormattingTextDropdownMenu } from './dropdown-menu';
-import { toolbarMessages } from '@atlaskit/editor-common/messages';
-import { compareItemsArrays, isArrayContainsContent } from '../../utils';
-import { Announcer } from '@atlaskit/editor-common/ui';
-import { usePreviousState } from '@atlaskit/editor-common/hooks';
-const ToolbarFormatting = ({
-  shouldUseResponsiveToolbar,
-  popupsMountPoint,
-  popupsBoundariesElement,
-  popupsScrollableElement,
-  editorView,
-  toolbarSize,
-  isReducedSpacing,
-  isToolbarDisabled,
-  intl,
-  editorAnalyticsAPI
-}) => {
-  var _usePreviousState;
-  const editorState = useMemo(() => editorView.state, [editorView.state]);
-  const [message, setMessage] = useState('');
-  const defaultIcons = useFormattingIcons({
-    editorState,
-    intl,
-    isToolbarDisabled,
-    editorAnalyticsAPI
-  });
-  const clearIcon = useClearIcon({
-    editorState,
-    intl,
-    editorAnalyticsAPI
-  });
-  const menuIconTypeList = useResponsiveIconTypeMenu({
-    toolbarSize,
-    responsivenessEnabled: shouldUseResponsiveToolbar
-  });
-  const hasFormattingActive = useHasFormattingActived({
-    editorState: editorView.state,
-    iconTypeList: menuIconTypeList
-  });
-  const {
-    dropdownItems,
-    singleItems
-  } = useResponsiveToolbarButtons({
-    icons: defaultIcons,
-    toolbarSize,
-    responsivenessEnabled: shouldUseResponsiveToolbar
-  });
-  const clearFormattingStatus = intl.formatMessage(toolbarMessages.textFormattingOff);
-  const superscriptOffSubscriptOnStatus = intl.formatMessage(toolbarMessages.superscriptOffSubscriptOn);
-  const subscriptOffSuperscriptOnStatus = intl.formatMessage(toolbarMessages.subscriptOffSuperscriptOn);
-  const activeItems = [...dropdownItems, ...singleItems].filter(item => item.isActive);
-  const prevActiveItems = (_usePreviousState = usePreviousState(activeItems)) !== null && _usePreviousState !== void 0 ? _usePreviousState : [];
-  const fromSuperscriptToSubscript = isArrayContainsContent(activeItems, 'Subscript') && isArrayContainsContent(prevActiveItems, 'Superscript');
-  const fromSubscriptToSuperscript = isArrayContainsContent(activeItems, 'Superscript') && isArrayContainsContent(prevActiveItems, 'Subscript');
-  let comparedItems;
-  let screenReaderMessage = '';
-  if (prevActiveItems && activeItems.length > prevActiveItems.length) {
-    comparedItems = compareItemsArrays(activeItems, prevActiveItems);
-    screenReaderMessage = intl.formatMessage(toolbarMessages.on, {
-      formattingType: comparedItems[0].content
-    });
-  } else {
-    comparedItems = compareItemsArrays(prevActiveItems, activeItems);
-    if (comparedItems && comparedItems.length) {
-      var _activeItems$;
-      screenReaderMessage = intl.formatMessage(toolbarMessages.off, {
-        formattingType: comparedItems[0].content
-      });
-      if (((_activeItems$ = activeItems[0]) === null || _activeItems$ === void 0 ? void 0 : _activeItems$.content) === 'Code') {
-        screenReaderMessage = intl.formatMessage(toolbarMessages.codeOn, {
-          textFormattingOff: (prevActiveItems === null || prevActiveItems === void 0 ? void 0 : prevActiveItems.length) > 1 ? clearFormattingStatus : screenReaderMessage
-        });
-      }
-      if (fromSuperscriptToSubscript) {
-        screenReaderMessage = superscriptOffSubscriptOnStatus;
-      }
-      if (fromSubscriptToSuperscript) {
-        screenReaderMessage = subscriptOffSuperscriptOnStatus;
-      }
-    }
-  }
-
-  // handle 'Clear formatting' status for screen readers
-  if (!(activeItems !== null && activeItems !== void 0 && activeItems.length) && (prevActiveItems === null || prevActiveItems === void 0 ? void 0 : prevActiveItems.length) > 1) {
-    screenReaderMessage = clearFormattingStatus;
-  }
-  const items = useMemo(() => {
-    if (!clearIcon) {
-      return dropdownItems;
-    }
-    return [...dropdownItems, clearIcon];
-  }, [clearIcon, dropdownItems]);
-  const moreFormattingButtonLabel = intl.formatMessage(toolbarMessages.moreFormatting);
-  useEffect(() => {
-    if (screenReaderMessage) {
-      setMessage(screenReaderMessage);
-    }
-  }, [screenReaderMessage]);
-  return jsx("span", {
-    css: buttonGroupStyle
-  }, message && jsx(Announcer, {
-    ariaLive: "assertive",
-    text: message,
-    ariaRelevant: "additions",
-    delay: 250
-  }), jsx(SingleToolbarButtons, {
-    items: singleItems,
-    editorView: editorView,
-    isReducedSpacing: isReducedSpacing
-  }), jsx("span", {
-    css: wrapperStyle
-  }, isToolbarDisabled ? jsx("div", null, jsx(MoreButton, {
-    label: moreFormattingButtonLabel,
-    isReducedSpacing: isReducedSpacing,
-    isDisabled: true,
-    isSelected: false,
-    "aria-expanded": undefined,
-    "aria-pressed": undefined
-  })) : jsx(FormattingTextDropdownMenu, {
-    popupsMountPoint: popupsMountPoint,
-    popupsBoundariesElement: popupsBoundariesElement,
-    popupsScrollableElement: popupsScrollableElement,
-    editorView: editorView,
-    isReducedSpacing: isReducedSpacing,
-    moreButtonLabel: moreFormattingButtonLabel,
-    hasFormattingActive: hasFormattingActive,
-    items: items
-  }), jsx("span", {
-    css: separatorStyles
-  })));
-};
-class Toolbar extends React.PureComponent {
-  render() {
-    const {
-      popupsMountPoint,
-      popupsScrollableElement,
-      toolbarSize,
-      isReducedSpacing,
-      editorView,
-      isToolbarDisabled,
-      shouldUseResponsiveToolbar,
-      intl,
-      editorAnalyticsAPI
-    } = this.props;
-    return jsx(ToolbarFormatting, {
-      popupsMountPoint: popupsMountPoint,
-      popupsScrollableElement: popupsScrollableElement,
-      toolbarSize: toolbarSize,
-      isReducedSpacing: isReducedSpacing,
-      editorView: editorView,
-      isToolbarDisabled: isToolbarDisabled,
-      shouldUseResponsiveToolbar: shouldUseResponsiveToolbar,
-      intl: intl,
-      editorAnalyticsAPI: editorAnalyticsAPI
-    });
-  }
-}
-export default injectIntl(Toolbar);

package/dist/es2019/plugins/text-formatting/ui/Toolbar/more-button.js

@@ -1,32 +0,0 @@
-/** @jsx jsx */
-import React from 'react';
-import { jsx } from '@emotion/react';
-import MoreIcon from '@atlaskit/icon/glyph/editor/more';
-import { triggerWrapperStyles } from '@atlaskit/editor-common/styles';
-import { ToolbarButton } from '@atlaskit/editor-common/ui-menu';
-export const MoreButton = /*#__PURE__*/React.memo(({
-  label,
-  'aria-expanded': ariaExpanded,
-  isReducedSpacing,
-  isSelected,
-  isDisabled,
-  onClick,
-  onKeyDown
-}) => {
-  return jsx(ToolbarButton, {
-    disabled: isDisabled,
-    selected: isSelected,
-    onClick: onClick,
-    onKeyDown: onKeyDown,
-    spacing: isReducedSpacing ? 'none' : 'default',
-    title: label,
-    iconBefore: jsx("div", {
-      css: triggerWrapperStyles
-    }, jsx(MoreIcon, {
-      label: ""
-    })),
-    "aria-expanded": ariaExpanded,
-    "aria-label": label,
-    "aria-haspopup": true
-  });
-});

package/dist/es2019/plugins/text-formatting/ui/Toolbar/single-toolbar-buttons.js

@@ -1,36 +0,0 @@
-/** @jsx jsx */
-import React, { useCallback } from 'react';
-import { jsx } from '@emotion/react';
-import { ToolbarButton } from '@atlaskit/editor-common/ui-menu';
-import { buttonGroupStyle } from '@atlaskit/editor-common/styles';
-export const SingleToolbarButtons = /*#__PURE__*/React.memo(({
-  items,
-  isReducedSpacing,
-  editorView
-}) => {
-  const onClick = useCallback(command => {
-    return () => {
-      command(editorView.state, editorView.dispatch);
-      return false;
-    };
-  }, [editorView.state, editorView.dispatch]);
-  return jsx("span", {
-    css: buttonGroupStyle
-  }, items.map(item => {
-    var _item$ariaLabel;
-    return jsx(ToolbarButton, {
-      key: item.key,
-      testId: `editor-toolbar__${String(item.content)}`,
-      buttonId: item.buttonId,
-      spacing: isReducedSpacing ? 'none' : 'default',
-      onClick: onClick(item.command),
-      selected: item.isActive,
-      disabled: item.isDisabled,
-      title: item.tooltipElement,
-      iconBefore: item.iconElement,
-      "aria-pressed": item.isActive,
-      "aria-label": (_item$ariaLabel = item['aria-label']) !== null && _item$ariaLabel !== void 0 ? _item$ariaLabel : String(item.content),
-      "aria-keyshortcuts": item['aria-keyshortcuts']
-    });
-  }));
-});

package/dist/es2019/plugins/text-formatting/ui/Toolbar/types.js

@@ -1,10 +0,0 @@
-export let IconTypes = /*#__PURE__*/function (IconTypes) {
-  IconTypes["strong"] = "strong";
-  IconTypes["em"] = "em";
-  IconTypes["underline"] = "underline";
-  IconTypes["strike"] = "strike";
-  IconTypes["code"] = "code";
-  IconTypes["subscript"] = "subscript";
-  IconTypes["superscript"] = "superscript";
-  return IconTypes;
-}({});

package/dist/es2019/plugins/text-formatting/utils/cell-selection.js

@@ -1,5 +0,0 @@
-export const cellSelectionNodesBetween = (selection, doc, f, startPos) => {
-  selection.forEachCell((cell, cellPos) => {
-    doc.nodesBetween(cellPos, cellPos + cell.nodeSize, f, startPos);
-  });
-};