@atlaskit/editor-core 171.0.0 → 172.0.1

package/dist/esm/plugins/hyperlink/Toolbar.js

@@ -1,3 +1,4 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
@@ -17,8 +18,9 @@ import { RECENT_SEARCH_HEIGHT_IN_PX, RECENT_SEARCH_WIDTH_IN_PX } from '../../ui/
 import { HyperlinkToolbarAppearance } from './HyperlinkToolbarAppearance';
 import { addAnalytics, ACTION_SUBJECT_ID } from '../analytics';
 import { buildVisitedLinkPayload } from '../../utils/linking-utils';
-/* type guard for edit links */
+import { getCopyButtonConfig, showCopyButton } from '../copy-button/toolbar';
 
+/* type guard for edit links */
 function isEditLink(linkMark) {
   return linkMark.pos !== undefined;
 }
@@ -51,145 +53,152 @@ function getLinkText(activeLinkMark, state) {
   return activeLinkMark.node.text;
 }
 
-export var getToolbarConfig = function getToolbarConfig(state, intl, providerFactory, cardOptions) {
-  var formatMessage = intl.formatMessage;
-  var linkState = stateKey.getState(state);
-
-  if (linkState && linkState.activeLinkMark) {
-    var activeLinkMark = linkState.activeLinkMark;
-    var hyperLinkToolbar = {
-      title: 'Hyperlink floating controls',
-      nodeType: [state.schema.nodes.text, state.schema.nodes.paragraph, state.schema.nodes.heading, state.schema.nodes.taskItem, state.schema.nodes.decisionItem, state.schema.nodes.caption].filter(function (nodeType) {
-        return !!nodeType;
-      }),
-      // Use only the node types existing in the schema ED-6745
-      align: 'left',
-      className: activeLinkMark.type.match('INSERT|EDIT_INSERTED') ? 'hyperlink-floating-toolbar' : ''
-    };
-
-    switch (activeLinkMark.type) {
-      case 'EDIT':
-        {
-          var pos = activeLinkMark.pos,
-              node = activeLinkMark.node;
-          var linkMark = node.marks.filter(function (mark) {
-            return mark.type === state.schema.marks.link;
-          });
-          var link = linkMark[0] && linkMark[0].attrs.href;
-          var isValidUrl = isSafeUrl(link);
-          var labelOpenLink = formatMessage(isValidUrl ? linkMessages.openLink : linkToolbarCommonMessages.unableToOpenLink); // TODO: ED-14403 investigate why these are not translating?
-
-          var labelUnlink = formatMessage(linkToolbarCommonMessages.unlink);
-          var editLink = formatMessage(linkToolbarCommonMessages.editLink);
-          var metadata = {
-            url: link,
-            title: ''
-          };
-
-          if (activeLinkMark.node.text) {
-            metadata.title = activeLinkMark.node.text;
-          }
-
-          return _objectSpread(_objectSpread({}, hyperLinkToolbar), {}, {
-            height: 32,
-            width: 250,
-            items: [{
-              type: 'custom',
-              fallback: [],
-              render: function render(editorView) {
-                return /*#__PURE__*/React.createElement(HyperlinkToolbarAppearance, {
-                  key: "link-appearance",
-                  url: link,
-                  intl: intl,
-                  editorView: editorView,
-                  editorState: state,
-                  cardOptions: cardOptions,
-                  providerFactory: providerFactory // platform={} // TODO: pass platform
-
-                });
-              }
-            }, {
-              id: 'editor.link.edit',
-              type: 'button',
-              onClick: editInsertedLink(),
-              selected: false,
-              title: editLink,
-              showTitle: true,
-              metadata: metadata
-            }, {
-              type: 'separator'
-            }, {
-              id: 'editor.link.openLink',
-              type: 'button',
-              disabled: !isValidUrl,
-              target: '_blank',
-              href: isValidUrl ? link : undefined,
-              onClick: visitHyperlink(),
-              selected: false,
-              title: labelOpenLink,
-              icon: OpenIcon,
-              className: 'hyperlink-open-link',
-              metadata: metadata,
-              tabIndex: null
-            }, {
-              type: 'separator'
-            }, {
-              id: 'editor.link.unlink',
-              type: 'button',
-              onClick: removeLink(pos),
-              selected: false,
-              title: labelUnlink,
-              icon: UnlinkIcon,
-              tabIndex: null
-            }]
-          });
-        }
-
-      case 'EDIT_INSERTED':
-      case 'INSERT':
-        {
-          var _link;
-
-          if (isEditLink(activeLinkMark) && activeLinkMark.node) {
-            var _linkMark = activeLinkMark.node.marks.filter(function (mark) {
+export var getToolbarConfig = function getToolbarConfig(options) {
+  return function (state, intl, providerFactory) {
+    var formatMessage = intl.formatMessage;
+    var linkState = stateKey.getState(state);
+
+    if (linkState && linkState.activeLinkMark) {
+      var activeLinkMark = linkState.activeLinkMark;
+      var hyperLinkToolbar = {
+        title: 'Hyperlink floating controls',
+        nodeType: [state.schema.nodes.text, state.schema.nodes.paragraph, state.schema.nodes.heading, state.schema.nodes.taskItem, state.schema.nodes.decisionItem, state.schema.nodes.caption].filter(function (nodeType) {
+          return !!nodeType;
+        }),
+        // Use only the node types existing in the schema ED-6745
+        align: 'left',
+        className: activeLinkMark.type.match('INSERT|EDIT_INSERTED') ? 'hyperlink-floating-toolbar' : ''
+      };
+
+      switch (activeLinkMark.type) {
+        case 'EDIT':
+          {
+            var pos = activeLinkMark.pos,
+                node = activeLinkMark.node;
+            var linkMark = node.marks.filter(function (mark) {
               return mark.type === state.schema.marks.link;
             });
-
-            _link = _linkMark[0] && _linkMark[0].attrs.href;
-          }
-
-          var displayText = isEditLink(activeLinkMark) ? getLinkText(activeLinkMark, state) : linkState.activeText;
-          return _objectSpread(_objectSpread({}, hyperLinkToolbar), {}, {
-            height: RECENT_SEARCH_HEIGHT_IN_PX,
-            width: RECENT_SEARCH_WIDTH_IN_PX,
-            items: [{
-              type: 'custom',
-              fallback: [],
-              render: function render(view, idx) {
-                if (!view) {
-                  return null;
+            var link = linkMark[0] && linkMark[0].attrs.href;
+            var isValidUrl = isSafeUrl(link);
+            var labelOpenLink = formatMessage(isValidUrl ? linkMessages.openLink : linkToolbarCommonMessages.unableToOpenLink); // TODO: ED-14403 investigate why these are not translating?
+
+            var labelUnlink = formatMessage(linkToolbarCommonMessages.unlink);
+            var editLink = formatMessage(linkToolbarCommonMessages.editLink);
+            var metadata = {
+              url: link,
+              title: ''
+            };
+
+            if (activeLinkMark.node.text) {
+              metadata.title = activeLinkMark.node.text;
+            }
+
+            return _objectSpread(_objectSpread({}, hyperLinkToolbar), {}, {
+              height: 32,
+              width: 250,
+              items: [{
+                type: 'custom',
+                fallback: [],
+                render: function render(editorView) {
+                  return /*#__PURE__*/React.createElement(HyperlinkToolbarAppearance, {
+                    key: "link-appearance",
+                    url: link,
+                    intl: intl,
+                    editorView: editorView,
+                    editorState: state,
+                    cardOptions: options === null || options === void 0 ? void 0 : options.cardOptions,
+                    providerFactory: providerFactory // platform={} // TODO: pass platform
+
+                  });
                 }
+              }, {
+                id: 'editor.link.edit',
+                type: 'button',
+                onClick: editInsertedLink(),
+                selected: false,
+                title: editLink,
+                showTitle: true,
+                metadata: metadata
+              }, {
+                type: 'separator'
+              }, {
+                id: 'editor.link.openLink',
+                type: 'button',
+                disabled: !isValidUrl,
+                target: '_blank',
+                href: isValidUrl ? link : undefined,
+                onClick: visitHyperlink(),
+                selected: false,
+                title: labelOpenLink,
+                icon: OpenIcon,
+                className: 'hyperlink-open-link',
+                metadata: metadata,
+                tabIndex: null
+              }, {
+                type: 'separator'
+              }, {
+                id: 'editor.link.unlink',
+                type: 'button',
+                onClick: removeLink(pos),
+                selected: false,
+                title: labelUnlink,
+                icon: UnlinkIcon,
+                tabIndex: null
+              }].concat(_toConsumableArray(state && showCopyButton(state) ? [{
+                type: 'separator'
+              }, getCopyButtonConfig(state, intl.formatMessage, hyperLinkToolbar.nodeType)] : []))
+            });
+          }
 
-                return /*#__PURE__*/React.createElement(HyperlinkAddToolbar, {
-                  view: view,
-                  key: idx,
-                  displayUrl: _link,
-                  displayText: displayText || '',
-                  providerFactory: providerFactory,
-                  onSubmit: function onSubmit(href) {
-                    var title = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
-                    var displayText = arguments.length > 2 ? arguments[2] : undefined;
-                    var inputMethod = arguments.length > 3 ? arguments[3] : undefined;
-                    isEditLink(activeLinkMark) ? updateLink(href, displayText || title, activeLinkMark.pos)(view.state, view.dispatch) : insertLinkWithAnalytics(inputMethod, activeLinkMark.from, activeLinkMark.to, href, title, displayText, !!(cardOptions && cardOptions.provider))(view.state, view.dispatch);
-                    view.focus();
+        case 'EDIT_INSERTED':
+        case 'INSERT':
+          {
+            var _link;
+
+            if (isEditLink(activeLinkMark) && activeLinkMark.node) {
+              var _linkMark = activeLinkMark.node.marks.filter(function (mark) {
+                return mark.type === state.schema.marks.link;
+              });
+
+              _link = _linkMark[0] && _linkMark[0].attrs.href;
+            }
+
+            var displayText = isEditLink(activeLinkMark) ? getLinkText(activeLinkMark, state) : linkState.activeText;
+            return _objectSpread(_objectSpread({}, hyperLinkToolbar), {}, {
+              height: RECENT_SEARCH_HEIGHT_IN_PX,
+              width: RECENT_SEARCH_WIDTH_IN_PX,
+              items: [{
+                type: 'custom',
+                fallback: [],
+                render: function render(view, idx) {
+                  if (!view) {
+                    return null;
                   }
-                });
-              }
-            }]
-          });
-        }
+
+                  return /*#__PURE__*/React.createElement(HyperlinkAddToolbar, {
+                    view: view,
+                    key: idx,
+                    linkPickerOptions: options === null || options === void 0 ? void 0 : options.linkPicker,
+                    displayUrl: _link,
+                    displayText: displayText || '',
+                    providerFactory: providerFactory,
+                    onSubmit: function onSubmit(href) {
+                      var _options$cardOptions;
+
+                      var title = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+                      var displayText = arguments.length > 2 ? arguments[2] : undefined;
+                      var inputMethod = arguments.length > 3 ? arguments[3] : undefined;
+                      isEditLink(activeLinkMark) ? updateLink(href, displayText || title, activeLinkMark.pos)(view.state, view.dispatch) : insertLinkWithAnalytics(inputMethod, activeLinkMark.from, activeLinkMark.to, href, title, displayText, !!(options !== null && options !== void 0 && (_options$cardOptions = options.cardOptions) !== null && _options$cardOptions !== void 0 && _options$cardOptions.provider))(view.state, view.dispatch);
+                      view.focus();
+                    }
+                  });
+                }
+              }]
+            });
+          }
+      }
     }
-  }
 
-  return;
+    return;
+  };
 };

package/dist/esm/plugins/hyperlink/index.js

@@ -20,9 +20,11 @@ var hyperlinkPlugin = function hyperlinkPlugin(options) {
       }];
     },
     pmPlugins: function pmPlugins() {
+      var _options$cardOptions;
+
       // Skip analytics if card provider is available, as they will be
       // sent on handleRejected upon attempting to resolve smart link.
-      var skipAnalytics = !!options && !!options.provider;
+      var skipAnalytics = !!(options !== null && options !== void 0 && (_options$cardOptions = options.cardOptions) !== null && _options$cardOptions !== void 0 && _options$cardOptions.provider);
       return [{
         name: 'hyperlink',
         plugin: function plugin(_ref) {
@@ -78,9 +80,7 @@ var hyperlinkPlugin = function hyperlinkPlugin(options) {
           }
         }];
       },
-      floatingToolbar: function floatingToolbar(state, intl, providerFactory) {
-        return getToolbarConfig(state, intl, providerFactory, options);
-      }
+      floatingToolbar: getToolbarConfig(options)
     }
   };
 };

package/dist/esm/plugins/hyperlink/ui/EditorLinkPicker/index.js

@@ -0,0 +1,26 @@
+import _extends from "@babel/runtime/helpers/extends";
+import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
+var _excluded = ["view"];
+import React, { useCallback } from 'react';
+import { LinkPicker } from '@atlaskit/link-picker';
+import { hideLinkToolbar as cardHideLinkToolbar } from '../../../card/pm-plugins/actions';
+import { hideLinkToolbar } from '../../commands';
+import { useEscapeClickaway } from './useEscapeClickaway';
+export var EditorLinkPicker = function EditorLinkPicker(_ref) {
+  var view = _ref.view,
+      restProps = _objectWithoutProperties(_ref, _excluded);
+
+  var onEscape = useCallback(function () {
+    hideLinkToolbar()(view.state, view.dispatch);
+    view.dispatch(cardHideLinkToolbar(view.state.tr));
+  }, [view]);
+  var onClickAway = useCallback(function () {
+    hideLinkToolbar()(view.state, view.dispatch);
+  }, [view]);
+  var ref = useEscapeClickaway(onEscape, onClickAway);
+  return /*#__PURE__*/React.createElement("div", {
+    ref: ref
+  }, /*#__PURE__*/React.createElement(LinkPicker, _extends({}, restProps, {
+    onCancel: onEscape
+  })));
+};

package/dist/esm/plugins/hyperlink/ui/EditorLinkPicker/useEscapeClickaway.js

@@ -0,0 +1,28 @@
+import { useEffect, useRef } from 'react';
+export var useEscapeClickaway = function useEscapeClickaway(onEscape, onClickAway) {
+  var ref = useRef(null);
+  useEffect(function () {
+    var handleClickAway = function handleClickAway(event) {
+      var el = ref.current;
+
+      if (event.target instanceof Element && el && !el.contains(event.target)) {
+        onClickAway();
+      }
+    };
+
+    var handleKeydown = function handleKeydown(event) {
+      if (event.key === 'Escape') {
+        event.preventDefault();
+        onEscape();
+      }
+    };
+
+    document.addEventListener('mousedown', handleClickAway);
+    document.addEventListener('keydown', handleKeydown);
+    return function () {
+      document.removeEventListener('mousedown', handleClickAway);
+      document.removeEventListener('keydown', handleKeydown);
+    };
+  }, [onClickAway, onEscape]);
+  return ref;
+};

package/dist/esm/plugins/hyperlink/ui/HyperlinkAddToolbar/index.js

@@ -1,3 +1,4 @@
+import _extends from "@babel/runtime/helpers/extends";
 import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
 import _createClass from "@babel/runtime/helpers/createClass";
 import _inherits from "@babel/runtime/helpers/inherits";
@@ -11,8 +12,25 @@ function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Re
 import React from 'react';
 import { WithProviders } from '@atlaskit/editor-common/provider-factory';
 import HyperlinkAddToolbarComp from './HyperlinkAddToolbar';
+import { INPUT_METHOD } from '../../../analytics';
 import { stateKey as pluginKey } from '../../pm-plugins/main';
 import WithPluginState from '../../../../ui/WithPluginState';
+import { getFeatureFlags } from '../../../feature-flags-context';
+import { EditorLinkPicker } from '../EditorLinkPicker';
+
+/**
+ * Wraps around the editor's onSubmit handler so that the plugin can interface with the link picker
+ */
+var onSubmitInterface = function onSubmitInterface(onSubmit) {
+  return function (_ref) {
+    var url = _ref.url,
+        title = _ref.title,
+        displayText = _ref.displayText,
+        rawUrl = _ref.rawUrl,
+        meta = _ref.meta;
+    onSubmit(url, title !== null && title !== void 0 ? title : rawUrl, displayText || undefined, meta.inputMethod === 'manual' ? INPUT_METHOD.MANUAL : INPUT_METHOD.TYPEAHEAD);
+  };
+};
 
 var HyperlinkAddToolbar = /*#__PURE__*/function (_React$PureComponent) {
   _inherits(HyperlinkAddToolbar, _React$PureComponent);
@@ -29,6 +47,8 @@ var HyperlinkAddToolbar = /*#__PURE__*/function (_React$PureComponent) {
     key: "render",
     value: function render() {
       var _this$props = this.props,
+          _this$props$linkPicke = _this$props.linkPickerOptions,
+          linkPickerOptions = _this$props$linkPicke === void 0 ? {} : _this$props$linkPicke,
           onSubmit = _this$props.onSubmit,
           displayText = _this$props.displayText,
           displayUrl = _this$props.displayUrl,
@@ -37,16 +57,37 @@ var HyperlinkAddToolbar = /*#__PURE__*/function (_React$PureComponent) {
       return /*#__PURE__*/React.createElement(WithProviders, {
         providers: ['activityProvider', 'searchProvider'],
         providerFactory: providerFactory,
-        renderNode: function renderNode(_ref) {
-          var activityProvider = _ref.activityProvider,
-              searchProvider = _ref.searchProvider;
+        renderNode: function renderNode(_ref2) {
+          var activityProvider = _ref2.activityProvider,
+              searchProvider = _ref2.searchProvider;
           return /*#__PURE__*/React.createElement(WithPluginState, {
             editorView: view,
             plugins: {
               hyperlinkPluginState: pluginKey
             },
-            render: function render(_ref2) {
-              var hyperlinkPluginState = _ref2.hyperlinkPluginState;
+            render: function render(_ref3) {
+              var _linkPickerOptions$pl;
+
+              var hyperlinkPluginState = _ref3.hyperlinkPluginState;
+
+              var _getFeatureFlags = getFeatureFlags(view.state),
+                  lpLinkPicker = _getFeatureFlags.lpLinkPicker;
+              /**
+               * If activityProvider or searchProvider are present then only enable if there are plugins supplied to
+               * faciliate providing link search capabilities
+               */
+
+
+              if (lpLinkPicker && (!activityProvider && !searchProvider || Boolean(linkPickerOptions === null || linkPickerOptions === void 0 ? void 0 : (_linkPickerOptions$pl = linkPickerOptions.plugins) === null || _linkPickerOptions$pl === void 0 ? void 0 : _linkPickerOptions$pl.length))) {
+                return /*#__PURE__*/React.createElement(EditorLinkPicker, _extends({
+                  view: view
+                }, linkPickerOptions, {
+                  url: displayUrl,
+                  displayText: displayText,
+                  onSubmit: onSubmitInterface(onSubmit)
+                }));
+              }
+
               return /*#__PURE__*/React.createElement(HyperlinkAddToolbarComp, {
                 activityProvider: activityProvider,
                 searchProvider: searchProvider,

package/dist/esm/plugins/indentation/commands/index.js

@@ -1,10 +1,9 @@
 import { toggleBlockMark } from '../../../commands';
 import { createAnalyticsDispatch } from './utils';
-import { INDENT_DIRECTION } from '../../analytics';
+import { INDENT_DIRECTION, INPUT_METHOD } from '../../analytics';
 import getAttrsWithChangesRecorder from '../../../utils/getAttrsWithChangesRecorder';
-var MAX_INDENTATION_LEVEL = 6;
-
-var isIndentationAllowed = function isIndentationAllowed(schema, node) {
+export var MAX_INDENTATION_LEVEL = 6;
+export var isIndentationAllowed = function isIndentationAllowed(schema, node) {
   var _schema$nodes = schema.nodes,
       paragraph = _schema$nodes.paragraph,
       heading = _schema$nodes.heading,
@@ -28,7 +27,6 @@ var isIndentationAllowed = function isIndentationAllowed(schema, node) {
  * @param getNewIndentationAttrs Function to handle new indentation level
  */
 
-
 function createIndentationCommand(getNewIndentationAttrs) {
   return function (state, dispatch) {
     var indentation = state.schema.marks.indentation;
@@ -36,7 +34,11 @@ function createIndentationCommand(getNewIndentationAttrs) {
   };
 }
 
-function createIndentationCommandWithAnalytics(getNewIndentationAttrs, direction) {
+function createIndentationCommandWithAnalytics(_ref) {
+  var getNewIndentationAttrs = _ref.getNewIndentationAttrs,
+      direction = _ref.direction,
+      inputMethod = _ref.inputMethod;
+
   // Create a new getAttrs function to record the changes
   var _getAttrsWithChangesR = getAttrsWithChangesRecorder(getNewIndentationAttrs, {
     direction: direction
@@ -48,7 +50,12 @@ function createIndentationCommandWithAnalytics(getNewIndentationAttrs, direction
   var indentationCommand = createIndentationCommand(getAttrs); // Return a new command where we change dispatch for our analytics dispatch
 
   return function (state, dispatch) {
-    return indentationCommand(state, createAnalyticsDispatch(getAndResetAttrsChanges, state, dispatch));
+    return indentationCommand(state, createAnalyticsDispatch({
+      getAttrsChanges: getAndResetAttrsChanges,
+      inputMethod: inputMethod,
+      state: state,
+      dispatch: dispatch
+    }));
   };
 }
 /**
@@ -78,7 +85,14 @@ var getIndentAttrs = function getIndentAttrs(oldAttr) {
   }; // Otherwise, increase the level by one
 };
 
-export var indent = createIndentationCommandWithAnalytics(getIndentAttrs, INDENT_DIRECTION.INDENT);
+export var getIndentCommand = function getIndentCommand() {
+  var inputMethod = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : INPUT_METHOD.KEYBOARD;
+  return createIndentationCommandWithAnalytics({
+    getNewIndentationAttrs: getIndentAttrs,
+    direction: INDENT_DIRECTION.INDENT,
+    inputMethod: inputMethod
+  });
+};
 /**
  * Get new level for outdent
  * @param oldAttr Old attributes for the mark, undefined if the mark doesn't exit
@@ -103,7 +117,14 @@ var getOutdentAttrs = function getOutdentAttrs(oldAttr) {
   }; // Decrease the level on other cases
 };
 
-export var outdent = createIndentationCommandWithAnalytics(getOutdentAttrs, INDENT_DIRECTION.OUTDENT);
+export var getOutdentCommand = function getOutdentCommand() {
+  var inputMethod = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : INPUT_METHOD.KEYBOARD;
+  return createIndentationCommandWithAnalytics({
+    getNewIndentationAttrs: getOutdentAttrs,
+    direction: INDENT_DIRECTION.OUTDENT,
+    inputMethod: inputMethod
+  });
+};
 export var removeIndentation = function removeIndentation(state, dispatch) {
   return toggleBlockMark(state.schema.marks.indentation, function () {
     return false;

package/dist/esm/plugins/indentation/commands/utils.js

@@ -1,4 +1,4 @@
-import { addAnalytics, INDENT_TYPE, ACTION, ACTION_SUBJECT, ACTION_SUBJECT_ID, INPUT_METHOD, EVENT_TYPE } from '../../analytics';
+import { addAnalytics, INDENT_TYPE, ACTION, ACTION_SUBJECT, ACTION_SUBJECT_ID, EVENT_TYPE } from '../../analytics';
 var indentTypes = {
   paragraph: INDENT_TYPE.PARAGRAPH,
   heading: INDENT_TYPE.HEADING
@@ -40,17 +40,21 @@ export function getPrevIndentLevel(prevAttrs) {
  * @returns
  */
 
-export function createAnalyticsDispatch(getAttrsChanges, state, dispatch) {
+export function createAnalyticsDispatch(_ref) {
+  var getAttrsChanges = _ref.getAttrsChanges,
+      inputMethod = _ref.inputMethod,
+      state = _ref.state,
+      dispatch = _ref.dispatch;
   return function (tr) {
     var currentTr = tr;
     var changes = getAttrsChanges(); // Get all attributes changes
     // Add analytics event for each change stored.
 
-    changes.forEach(function (_ref) {
-      var node = _ref.node,
-          prevAttrs = _ref.prevAttrs,
-          newAttrs = _ref.newAttrs,
-          direction = _ref.options.direction;
+    changes.forEach(function (_ref2) {
+      var node = _ref2.node,
+          prevAttrs = _ref2.prevAttrs,
+          newAttrs = _ref2.newAttrs,
+          direction = _ref2.options.direction;
       var indentType = indentTypes[node.type.name];
 
       if (!indentType) {
@@ -63,7 +67,7 @@ export function createAnalyticsDispatch(getAttrsChanges, state, dispatch) {
         actionSubjectId: ACTION_SUBJECT_ID.FORMAT_INDENT,
         eventType: EVENT_TYPE.TRACK,
         attributes: {
-          inputMethod: INPUT_METHOD.KEYBOARD,
+          inputMethod: inputMethod,
           previousIndentationLevel: getPrevIndentLevel(prevAttrs),
           newIndentLevel: getNewIndentLevel(prevAttrs, newAttrs),
           direction: direction,

package/dist/esm/plugins/indentation/pm-plugins/keymap.js

@@ -1,16 +1,17 @@
 import { keymap } from 'prosemirror-keymap';
 import * as keymaps from '../../../keymaps';
 import { isTextSelection } from '../../../utils';
-import { indent, outdent } from '../commands';
+import { getIndentCommand, getOutdentCommand } from '../commands';
+import { INPUT_METHOD } from '../../analytics';
 export function keymapPlugin() {
   var list = {};
-  keymaps.bindKeymapWithCommand(keymaps.findShortcutByKeymap(keymaps.indent), indent, list);
-  keymaps.bindKeymapWithCommand(keymaps.findShortcutByKeymap(keymaps.outdent), outdent, list);
+  keymaps.bindKeymapWithCommand(keymaps.findShortcutByKeymap(keymaps.indent), getIndentCommand(INPUT_METHOD.KEYBOARD), list);
+  keymaps.bindKeymapWithCommand(keymaps.findShortcutByKeymap(keymaps.outdent), getOutdentCommand(INPUT_METHOD.KEYBOARD), list);
   keymaps.bindKeymapWithCommand(keymaps.findShortcutByKeymap(keymaps.backspace), function (state, dispatch) {
     var selection = state.selection;
 
     if (isTextSelection(selection) && selection.$cursor && selection.$cursor.parentOffset === 0) {
-      return dispatch ? outdent(state, dispatch) : false;
+      return dispatch ? getOutdentCommand(INPUT_METHOD.KEYBOARD)(state, dispatch) : false;
     }
 
     return false;

package/dist/esm/plugins/layout/toolbar.js

@@ -11,6 +11,7 @@ import { toolbarMessages } from './toolbar-messages';
 import commonMessages from '../../messages';
 import { setPresetLayout, deleteActiveLayoutNode, getPresetLayout } from './actions';
 import { hoverDecoration } from '../base/pm-plugins/decoration';
+import { getCopyButtonConfig, showCopyButton } from '../copy-button/toolbar';
 var LAYOUT_TYPES = [{
   id: 'editor.layout.twoEquals',
   type: 'two_equal',
@@ -93,7 +94,7 @@ export var buildToolbar = function buildToolbar(state, intl, pos, _allowBreakout
         return buildLayoutButton(intl, i, currentLayout);
       })), _toConsumableArray(addSidebarLayouts ? SIDEBAR_LAYOUT_TYPES.map(function (i) {
         return buildLayoutButton(intl, i, currentLayout);
-      }) : []), [separator, deleteButton])
+      }) : []), _toConsumableArray(state && showCopyButton(state) ? [separator, getCopyButtonConfig(state, intl.formatMessage, nodeType)] : []), [separator, deleteButton])
     };
   }