@atlaskit/editor-plugin-floating-toolbar 0.5.1 → 0.6.1

package/dist/es2019/ui/messages.js

@@ -0,0 +1,48 @@
+import { defineMessages } from 'react-intl-next';
+export default defineMessages({
+  confirmModalDefaultHeading: {
+    id: 'fabric.editor.floatingToolbar.confirmModalHeading',
+    defaultMessage: 'Are you sure?',
+    description: 'Default heading of floating toolbar confirmation modal.'
+  },
+  confirmModalOK: {
+    id: 'fabric.editor.floatingToolbar.confirmModalOK',
+    defaultMessage: 'OK',
+    description: 'OK button for floating toolbar confirmation modal.'
+  },
+  confirmModalCancel: {
+    id: 'fabric.editor.floatingToolbar.confirmModalCancel',
+    defaultMessage: 'Cancel',
+    description: 'Cancel button for floating toolbar confirmation modal.'
+  },
+  confirmModalListUnit: {
+    id: 'fabric.editor.floatingToolbar.confirmModalConnectedUnit',
+    defaultMessage: '{name}{amount, plural, =0 {} one { (+1 connected element)} other { (+# connected elements)}}',
+    description: 'Text displayed in confirmation modal which highlights the nodes and the amount of connected nodes that will be deleted'
+  },
+  confirmDeleteLinkedModalMessage: {
+    id: 'fabric.editor.extension.confirmDeleteLinkedModalMessage',
+    defaultMessage: 'Deleting {nodeName} will break anything connected to it.',
+    description: 'Message for confirm modal when deleting a extension linked to an data consumer.'
+  },
+  floatingToolbarAriaLabel: {
+    id: 'fabric.editor.floatingToolbar.floatingToolbarAriaLabel',
+    defaultMessage: 'Floating Toolbar',
+    description: "a floating toolbar's aria label"
+  },
+  floatingToolbarAnnouncer: {
+    id: 'fabric.editor.floatingToolbar.floatingToolbarAnnouncer',
+    defaultMessage: 'Floating toolbar controls have been opened',
+    description: 'message that will be announced to screenreaders that the floating toolbar is opened'
+  },
+  floatingToolbarScrollLeft: {
+    id: 'fabric.editor.floatingToolbar.scrollLeft',
+    defaultMessage: 'Scroll left',
+    description: 'Button to scroll left when the toolbar is in the overflow state'
+  },
+  floatingToolbarScrollRight: {
+    id: 'fabric.editor.floatingToolbar.scrollRight',
+    defaultMessage: 'Scroll right',
+    description: 'Button to scroll right when the toolbar is in the overflow state'
+  }
+});

package/dist/es2019/ui/styles.js

@@ -0,0 +1,64 @@
+import { hexToRgba } from '@atlaskit/adf-schema';
+import * as colors from '@atlaskit/theme/colors';
+const background = {
+  danger: {
+    default: {
+      light: 'inherit',
+      dark: 'inherit'
+    },
+    hover: {
+      light: `var(--ds-background-neutral-subtle-hovered, ${colors.N30A})`,
+      dark: `var(--ds-background-neutral-subtle-hovered, ${colors.N30A})`
+    },
+    active: {
+      light: `var(--ds-background-neutral-pressed, ${`${hexToRgba(colors.B75, 0.6)}`})`,
+      dark: `var(--ds-background-neutral-pressed, ${`${hexToRgba(colors.B75, 0.6)}`})`
+    }
+  }
+};
+const color = {
+  danger: {
+    default: {
+      light: `var(--ds-icon, ${colors.N400})`,
+      dark: `var(--ds-icon, ${colors.DN400})`
+    },
+    hover: {
+      light: `var(--ds-icon-danger, ${colors.R400})`,
+      dark: `var(--ds-icon-danger, ${colors.R400})`
+    },
+    active: {
+      light: `var(--ds-icon-danger, ${colors.R400})`,
+      dark: `var(--ds-icon-danger, ${colors.R400})`
+    }
+  }
+};
+const getStyles = (property, {
+  appearance = 'default',
+  state = 'default',
+  mode = 'light'
+}) => {
+  if (!property[appearance] || !property[appearance][state]) {
+    return 'initial';
+  }
+  return property[appearance][state][mode];
+};
+export const iconOnlySpacing = {
+  '&&': {
+    padding: '0px',
+    /**
+      Increased specificity here because css for .hyperlink-open-link defined in
+      packages/editor/editor-core/src/ui/ContentStyles/index.tsx file
+      overrides padding left-right 2px with 4px.
+    */
+    '&&[href]': {
+      padding: '0 2px'
+    }
+  },
+  '& > span': {
+    margin: '0px'
+  }
+};
+export const getButtonStyles = props => ({
+  background: getStyles(background, props),
+  color: getStyles(color, props)
+});

package/dist/es2019/utils.js

@@ -0,0 +1,16 @@
+// find node in descendants by condition
+export function findNode(parent, predicate) {
+  let matchedNode;
+  parent.descendants(node => {
+    // dont run predicate if node already found
+    if (matchedNode) {
+      return false;
+    }
+    if (predicate(node)) {
+      matchedNode = node;
+      return false;
+    }
+    return true;
+  });
+  return matchedNode;
+}

package/dist/esm/index.js

@@ -1 +1 @@
-export {};
+export { floatingToolbarPlugin } from './plugin';

package/dist/esm/plugin.js

@@ -0,0 +1,373 @@
+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 React from 'react';
+import camelCase from 'lodash/camelCase';
+import { ACTION, ACTION_SUBJECT, CONTENT_COMPONENT, EVENT_TYPE } from '@atlaskit/editor-common/analytics';
+import { ErrorBoundary } from '@atlaskit/editor-common/error-boundary';
+import { useSharedPluginState } from '@atlaskit/editor-common/hooks';
+import { WithProviders } from '@atlaskit/editor-common/provider-factory';
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { Popup } from '@atlaskit/editor-common/ui';
+import { AllSelection, PluginKey } from '@atlaskit/editor-prosemirror/state';
+import { findDomRefAtPos, findSelectedNodeOfType } from '@atlaskit/editor-prosemirror/utils';
+import forceFocusPlugin, { forceFocusSelector } from './pm-plugins/force-focus';
+import { hideConfirmDialog } from './pm-plugins/toolbar-data/commands';
+import { createPlugin as floatingToolbarDataPluginFactory } from './pm-plugins/toolbar-data/plugin';
+import { pluginKey as dataPluginKey } from './pm-plugins/toolbar-data/plugin-key';
+import { ConfirmationModal } from './ui/ConfirmationModal';
+import { ToolbarLoader } from './ui/ToolbarLoader';
+import { findNode } from './utils';
+
+// AFP-2532 TODO: Fix automatic suppressions below
+export var getRelevantConfig = function getRelevantConfig(selection, configs) {
+  // node selections always take precedence, see if
+  var configPair;
+  configs.find(function (config) {
+    var node = findSelectedNodeOfType(config.nodeType)(selection);
+    if (node) {
+      configPair = {
+        node: node.node,
+        pos: node.pos,
+        config: config
+      };
+    }
+    return !!node;
+  });
+  if (configPair) {
+    return configPair;
+  }
+
+  // create mapping of node type name to configs
+  var configByNodeType = {};
+  configs.forEach(function (config) {
+    if (Array.isArray(config.nodeType)) {
+      config.nodeType.forEach(function (nodeType) {
+        configByNodeType[nodeType.name] = config;
+      });
+    } else {
+      configByNodeType[config.nodeType.name] = config;
+    }
+  });
+
+  // search up the tree from selection
+  var $from = selection.$from;
+  for (var i = $from.depth; i > 0; i--) {
+    var node = $from.node(i);
+    var matchedConfig = configByNodeType[node.type.name];
+    if (matchedConfig) {
+      return {
+        config: matchedConfig,
+        node: node,
+        pos: $from.pos
+      };
+    }
+  }
+
+  // if it is AllSelection (can be result of Cmd+A) - use first node
+  if (selection instanceof AllSelection) {
+    var docNode = $from.node(0);
+    var _matchedConfig = null;
+    var firstChild = findNode(docNode, function (node) {
+      _matchedConfig = configByNodeType[node.type.name];
+      return !!_matchedConfig;
+    });
+    if (firstChild && _matchedConfig) {
+      return {
+        config: _matchedConfig,
+        node: firstChild,
+        pos: $from.pos
+      };
+    }
+  }
+  return;
+};
+var getDomRefFromSelection = function getDomRefFromSelection(view, dispatchAnalyticsEvent) {
+  try {
+    return findDomRefAtPos(view.state.selection.from, view.domAtPos.bind(view));
+  } catch (error) {
+    // eslint-disable-next-line no-console
+    console.warn(error);
+    if (dispatchAnalyticsEvent) {
+      var payload = {
+        action: ACTION.ERRORED,
+        actionSubject: ACTION_SUBJECT.CONTENT_COMPONENT,
+        eventType: EVENT_TYPE.OPERATIONAL,
+        attributes: {
+          component: CONTENT_COMPONENT.FLOATING_TOOLBAR,
+          selection: view.state.selection.toJSON(),
+          position: view.state.selection.from,
+          docSize: view.state.doc.nodeSize,
+          error: error.toString(),
+          errorStack: error.stack || undefined
+        }
+      };
+      dispatchAnalyticsEvent(payload);
+    }
+  }
+};
+function filterUndefined(x) {
+  return !!x;
+}
+export var floatingToolbarPlugin = function floatingToolbarPlugin(_ref) {
+  var api = _ref.api;
+  return {
+    name: 'floatingToolbar',
+    pmPlugins: function pmPlugins() {
+      var floatingToolbarHandlers = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+      return [{
+        // Should be after all toolbar plugins
+        name: 'floatingToolbar',
+        plugin: function plugin(_ref2) {
+          var dispatch = _ref2.dispatch,
+            providerFactory = _ref2.providerFactory,
+            getIntl = _ref2.getIntl;
+          return floatingToolbarPluginFactory({
+            floatingToolbarHandlers: floatingToolbarHandlers,
+            dispatch: dispatch,
+            providerFactory: providerFactory,
+            getIntl: getIntl
+          });
+        }
+      }, {
+        name: 'floatingToolbarData',
+        plugin: function plugin(_ref3) {
+          var dispatch = _ref3.dispatch;
+          return floatingToolbarDataPluginFactory(dispatch);
+        }
+      }, {
+        name: 'forceFocus',
+        plugin: function plugin() {
+          return forceFocusPlugin();
+        }
+      }];
+    },
+    actions: {
+      forceFocusSelector: forceFocusSelector
+    },
+    getSharedState: function getSharedState(editorState) {
+      var _pluginKey$getState$g, _pluginKey$getState, _pluginKey$getState$g2;
+      if (!editorState) {
+        return undefined;
+      }
+      var configWithNodeInfo = (_pluginKey$getState$g = (_pluginKey$getState = pluginKey.getState(editorState)) === null || _pluginKey$getState === void 0 ? void 0 : (_pluginKey$getState$g2 = _pluginKey$getState.getConfigWithNodeInfo) === null || _pluginKey$getState$g2 === void 0 ? void 0 : _pluginKey$getState$g2.call(_pluginKey$getState, editorState)) !== null && _pluginKey$getState$g !== void 0 ? _pluginKey$getState$g : undefined;
+      return {
+        configWithNodeInfo: configWithNodeInfo,
+        floatingToolbarData: dataPluginKey.getState(editorState)
+      };
+    },
+    contentComponent: function contentComponent(_ref4) {
+      var popupsMountPoint = _ref4.popupsMountPoint,
+        popupsBoundariesElement = _ref4.popupsBoundariesElement,
+        popupsScrollableElement = _ref4.popupsScrollableElement,
+        editorView = _ref4.editorView,
+        providerFactory = _ref4.providerFactory,
+        dispatchAnalyticsEvent = _ref4.dispatchAnalyticsEvent;
+      return /*#__PURE__*/React.createElement(ContentComponent, {
+        editorView: editorView,
+        pluginInjectionApi: api,
+        popupsMountPoint: popupsMountPoint,
+        popupsBoundariesElement: popupsBoundariesElement,
+        popupsScrollableElement: popupsScrollableElement,
+        providerFactory: providerFactory,
+        dispatchAnalyticsEvent: dispatchAnalyticsEvent
+      });
+    }
+  };
+};
+function ContentComponent(_ref5) {
+  var _pluginInjectionApi$f, _configWithNodeInfo$c, _configWithNodeInfo$c2;
+  var pluginInjectionApi = _ref5.pluginInjectionApi,
+    editorView = _ref5.editorView,
+    popupsMountPoint = _ref5.popupsMountPoint,
+    popupsBoundariesElement = _ref5.popupsBoundariesElement,
+    popupsScrollableElement = _ref5.popupsScrollableElement,
+    providerFactory = _ref5.providerFactory,
+    dispatchAnalyticsEvent = _ref5.dispatchAnalyticsEvent;
+  var featureFlags = (pluginInjectionApi === null || pluginInjectionApi === void 0 ? void 0 : (_pluginInjectionApi$f = pluginInjectionApi.featureFlags) === null || _pluginInjectionApi$f === void 0 ? void 0 : _pluginInjectionApi$f.sharedState.currentState()) || {};
+  var _useSharedPluginState = useSharedPluginState(pluginInjectionApi, ['floatingToolbar', 'editorDisabled']),
+    floatingToolbarState = _useSharedPluginState.floatingToolbarState,
+    editorDisabledState = _useSharedPluginState.editorDisabledState;
+  var _ref6 = floatingToolbarState !== null && floatingToolbarState !== void 0 ? floatingToolbarState : {},
+    configWithNodeInfo = _ref6.configWithNodeInfo,
+    floatingToolbarData = _ref6.floatingToolbarData;
+  if (!configWithNodeInfo || !configWithNodeInfo.config || typeof ((_configWithNodeInfo$c = configWithNodeInfo.config) === null || _configWithNodeInfo$c === void 0 ? void 0 : _configWithNodeInfo$c.visible) !== 'undefined' && !((_configWithNodeInfo$c2 = configWithNodeInfo.config) !== null && _configWithNodeInfo$c2 !== void 0 && _configWithNodeInfo$c2.visible)) {
+    return null;
+  }
+  var config = configWithNodeInfo.config,
+    node = configWithNodeInfo.node;
+  var title = config.title,
+    _config$getDomRef = config.getDomRef,
+    getDomRef = _config$getDomRef === void 0 ? getDomRefFromSelection : _config$getDomRef,
+    items = config.items,
+    _config$align = config.align,
+    align = _config$align === void 0 ? 'center' : _config$align,
+    _config$className = config.className,
+    className = _config$className === void 0 ? '' : _config$className,
+    height = config.height,
+    width = config.width,
+    zIndex = config.zIndex,
+    _config$offset = config.offset,
+    offset = _config$offset === void 0 ? [0, 12] : _config$offset,
+    forcePlacement = config.forcePlacement,
+    preventPopupOverflow = config.preventPopupOverflow,
+    onPositionCalculated = config.onPositionCalculated,
+    _config$absoluteOffse = config.absoluteOffset,
+    absoluteOffset = _config$absoluteOffse === void 0 ? {
+      top: 0,
+      left: 0,
+      right: 0,
+      bottom: 0
+    } : _config$absoluteOffse,
+    focusTrap = config.focusTrap;
+  var targetRef = getDomRef(editorView, dispatchAnalyticsEvent);
+  if (!targetRef || editorDisabledState && editorDisabledState.editorDisabled) {
+    return null;
+  }
+  var customPositionCalculation;
+  var toolbarItems = pluginInjectionApi === null || pluginInjectionApi === void 0 ? void 0 : pluginInjectionApi.copyButton.actions.processCopyButtonItems(editorView.state)(Array.isArray(items) ? items : items(node), pluginInjectionApi === null || pluginInjectionApi === void 0 ? void 0 : pluginInjectionApi.decorations.actions.hoverDecoration);
+  if (onPositionCalculated) {
+    customPositionCalculation = function customPositionCalculation(nextPos) {
+      return onPositionCalculated(editorView, nextPos);
+    };
+  }
+  var dispatchCommand = function dispatchCommand(fn) {
+    return fn && fn(editorView.state, editorView.dispatch, editorView);
+  };
+
+  // Confirm dialog
+  var _ref7 = floatingToolbarData || {},
+    confirmDialogForItem = _ref7.confirmDialogForItem;
+  var confirmButtonItem = confirmDialogForItem ? toolbarItems[confirmDialogForItem] : undefined;
+  var scrollable = config.scrollable;
+  var confirmDialogOptions = typeof (confirmButtonItem === null || confirmButtonItem === void 0 ? void 0 : confirmButtonItem.confirmDialog) === 'function' ? confirmButtonItem === null || confirmButtonItem === void 0 ? void 0 : confirmButtonItem.confirmDialog() : confirmButtonItem === null || confirmButtonItem === void 0 ? void 0 : confirmButtonItem.confirmDialog;
+  return /*#__PURE__*/React.createElement(ErrorBoundary, {
+    component: ACTION_SUBJECT.FLOATING_TOOLBAR_PLUGIN,
+    componentId: camelCase(title),
+    dispatchAnalyticsEvent: dispatchAnalyticsEvent,
+    fallbackComponent: null
+  }, /*#__PURE__*/React.createElement(Popup, {
+    ariaLabel: title,
+    offset: offset,
+    target: targetRef,
+    alignY: "bottom",
+    forcePlacement: forcePlacement,
+    fitHeight: height,
+    fitWidth: width,
+    absoluteOffset: absoluteOffset,
+    alignX: align,
+    stick: true,
+    zIndex: zIndex,
+    mountTo: popupsMountPoint,
+    boundariesElement: popupsBoundariesElement,
+    scrollableElement: popupsScrollableElement,
+    onPositionCalculated: customPositionCalculation,
+    style: scrollable ? {
+      maxWidth: '100%'
+    } : {},
+    focusTrap: focusTrap,
+    preventOverflow: preventPopupOverflow
+  }, /*#__PURE__*/React.createElement(WithProviders, {
+    providerFactory: providerFactory,
+    providers: ['extensionProvider'],
+    renderNode: function renderNode(providers) {
+      return /*#__PURE__*/React.createElement(ToolbarLoader, {
+        target: targetRef,
+        items: toolbarItems,
+        node: node,
+        dispatchCommand: dispatchCommand,
+        editorView: editorView,
+        className: className,
+        focusEditor: function focusEditor() {
+          return editorView.focus();
+        },
+        providerFactory: providerFactory,
+        popupsMountPoint: popupsMountPoint,
+        popupsBoundariesElement: popupsBoundariesElement,
+        popupsScrollableElement: popupsScrollableElement,
+        dispatchAnalyticsEvent: dispatchAnalyticsEvent,
+        extensionsProvider: providers.extensionProvider,
+        scrollable: scrollable,
+        featureFlags: featureFlags,
+        api: pluginInjectionApi
+      });
+    }
+  })), /*#__PURE__*/React.createElement(ConfirmationModal, {
+    testId: "ak-floating-toolbar-confirmation-modal",
+    options: confirmDialogOptions,
+    onConfirm: function onConfirm() {
+      var isChecked = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+      if (!!confirmDialogOptions.onConfirm) {
+        dispatchCommand(confirmDialogOptions.onConfirm(isChecked));
+      } else {
+        dispatchCommand(confirmButtonItem.onClick);
+      }
+    },
+    onClose: function onClose() {
+      dispatchCommand(hideConfirmDialog());
+      // Need to set focus to Editor here,
+      // As when the Confirmation dialog pop up, and user interacts with the dialog, Editor loses focus.
+      // So when Confirmation dialog is closed, Editor does not have the focus, then cursor goes to the position 1 of the doc,
+      // instead of the cursor position before the dialog pop up.
+      if (!editorView.hasFocus()) {
+        editorView.focus();
+      }
+    }
+  }));
+}
+
+/**
+ *
+ * ProseMirror Plugin
+ *
+ */
+// We throttle update of this plugin with RAF.
+// So from other plugins you will always get the previous state.
+export var pluginKey = new PluginKey('floatingToolbarPluginKey');
+
+/**
+ * Clean up floating toolbar configs from undesired properties.
+ */
+function sanitizeFloatingToolbarConfig(config) {
+  // Cleanup from non existing node types
+  if (Array.isArray(config.nodeType)) {
+    return _objectSpread(_objectSpread({}, config), {}, {
+      nodeType: config.nodeType.filter(filterUndefined)
+    });
+  }
+  return config;
+}
+function floatingToolbarPluginFactory(options) {
+  var floatingToolbarHandlers = options.floatingToolbarHandlers,
+    providerFactory = options.providerFactory,
+    getIntl = options.getIntl;
+  var intl = getIntl();
+  var getConfigWithNodeInfo = function getConfigWithNodeInfo(editorState) {
+    var activeConfigs = floatingToolbarHandlers.map(function (handler) {
+      return handler(editorState, intl, providerFactory);
+    }).filter(filterUndefined).map(function (config) {
+      return sanitizeFloatingToolbarConfig(config);
+    });
+    var relevantConfig = activeConfigs && getRelevantConfig(editorState.selection, activeConfigs);
+    return relevantConfig;
+  };
+  var apply = function apply(tr, pluginState) {
+    var newPluginState = {
+      getConfigWithNodeInfo: getConfigWithNodeInfo
+    };
+    return newPluginState;
+  };
+  return new SafePlugin({
+    key: pluginKey,
+    state: {
+      init: function init() {
+        // Use this point to preload the UI
+        ToolbarLoader.preload();
+        return {
+          getConfigWithNodeInfo: getConfigWithNodeInfo
+        };
+      },
+      apply: apply
+    }
+  });
+}

package/dist/esm/pm-plugins/force-focus/index.js

@@ -0,0 +1,64 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { PluginKey } from '@atlaskit/editor-prosemirror/state';
+export var forceFocusStateKey = new PluginKey('forceFocusStatePlugin');
+/**
+ * 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 (function () {
+  return new SafePlugin({
+    key: forceFocusStateKey,
+    state: {
+      init: function init() {
+        return {
+          selector: null
+        };
+      },
+      apply: function apply(tr, prevState) {
+        var meta = tr.getMeta(forceFocusStateKey);
+        if (meta && 'selector' in meta) {
+          return {
+            selector: meta.selector
+          };
+        }
+        return prevState;
+      }
+    }
+  });
+});
+
+/**
+ * The provided selector should be the floating toolbar button that needs focus.
+ */
+export var forceFocusSelector = function forceFocusSelector(selector) {
+  return function (tr) {
+    return tr.setMeta(forceFocusStateKey, {
+      selector: selector
+    });
+  };
+};
+
+/**
+ * If a selector is set and the element exists, focus it.
+ */
+export function checkShouldForceFocusAndApply(view) {
+  var state = view === null || view === void 0 ? void 0 : view.state;
+  if (state) {
+    var _forceFocusStateKey$g = forceFocusStateKey.getState(state),
+      selector = _forceFocusStateKey$g.selector;
+    if (selector) {
+      var focusableElement = document.querySelector(selector);
+      if (focusableElement) {
+        focusableElement.scrollIntoView({
+          behavior: 'smooth',
+          block: 'center',
+          inline: 'nearest'
+        });
+        focusableElement.focus();
+        var tr = view.state.tr,
+          dispatch = view.dispatch;
+        dispatch(forceFocusSelector(null)(tr));
+      }
+    }
+  }
+}

package/dist/esm/pm-plugins/toolbar-data/commands.js

@@ -0,0 +1,18 @@
+import { createCommand } from './plugin-factory';
+export var showConfirmDialog = function showConfirmDialog(buttonIndex) {
+  return createCommand({
+    type: 'SHOW_CONFIRM_DIALOG',
+    data: {
+      buttonIndex: buttonIndex
+    }
+  }, function (tr) {
+    return tr.setMeta('addToHistory', false);
+  });
+};
+export var hideConfirmDialog = function hideConfirmDialog() {
+  return createCommand({
+    type: 'HIDE_CONFIRM_DIALOG'
+  }, function (tr) {
+    return tr.setMeta('addToHistory', false);
+  });
+};

package/dist/esm/pm-plugins/toolbar-data/plugin-factory.js

@@ -0,0 +1,8 @@
+import { pluginFactory } from '@atlaskit/editor-common/utils';
+import { pluginKey } from './plugin-key';
+import { reducer } from './reducer';
+var _pluginFactory = pluginFactory(pluginKey, reducer),
+  createPluginState = _pluginFactory.createPluginState,
+  createCommand = _pluginFactory.createCommand,
+  getPluginState = _pluginFactory.getPluginState;
+export { createPluginState, createCommand, getPluginState };

package/dist/esm/pm-plugins/toolbar-data/plugin-key.js

@@ -0,0 +1,2 @@
+import { PluginKey } from '@atlaskit/editor-prosemirror/state';
+export var pluginKey = new PluginKey('floatingToolbarData');

package/dist/esm/pm-plugins/toolbar-data/plugin.js

@@ -0,0 +1,9 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { createPluginState } from './plugin-factory';
+import { pluginKey } from './plugin-key';
+export var createPlugin = function createPlugin(dispatch) {
+  return new SafePlugin({
+    state: createPluginState(dispatch, {}),
+    key: pluginKey
+  });
+};

package/dist/esm/pm-plugins/toolbar-data/reducer.js

@@ -0,0 +1,17 @@
+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; }
+export var reducer = function reducer(pluginState, action) {
+  switch (action.type) {
+    case 'SHOW_CONFIRM_DIALOG':
+      return _objectSpread(_objectSpread({}, pluginState), {}, {
+        confirmDialogForItem: action.data.buttonIndex
+      });
+    case 'HIDE_CONFIRM_DIALOG':
+      return _objectSpread(_objectSpread({}, pluginState), {}, {
+        confirmDialogForItem: undefined
+      });
+    default:
+      return pluginState;
+  }
+};

package/dist/esm/pm-plugins/toolbar-data/types.js

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