@atlaskit/editor-core 189.3.22 → 189.3.24

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

@@ -1,6 +1,9 @@
 import { indentation } from '@atlaskit/adf-schema';
 import { keymapPlugin } from './pm-plugins/keymap';
+import { getOutdentCommand, getIndentCommand, isIndentationAllowed } from './commands';
+import { MAX_INDENTATION_LEVEL } from '@atlaskit/editor-common/indentation';
 var indentationPlugin = function indentationPlugin(_ref) {
+  var _api$analytics, _api$analytics2;
   var api = _ref.api;
   return {
     name: 'indentation',
@@ -10,12 +13,33 @@ var indentationPlugin = function indentationPlugin(_ref) {
         mark: indentation
       }];
     },
+    actions: {
+      indentParagraphOrHeading: getIndentCommand(api === null || api === void 0 || (_api$analytics = api.analytics) === null || _api$analytics === void 0 ? void 0 : _api$analytics.actions),
+      outdentParagraphOrHeading: getOutdentCommand(api === null || api === void 0 || (_api$analytics2 = api.analytics) === null || _api$analytics2 === void 0 ? void 0 : _api$analytics2.actions)
+    },
+    getSharedState: function getSharedState(editorState) {
+      var _ref2;
+      if (!editorState) {
+        return undefined;
+      }
+      var selection = editorState.tr.selection,
+        indentation = editorState.schema.marks.indentation;
+      var node = selection.$from.node();
+      var indentationMark = node.marks.find(function (mark) {
+        return mark.type === indentation;
+      });
+      return {
+        isIndentationAllowed: isIndentationAllowed(editorState.schema, node),
+        indentDisabled: (_ref2 = (indentationMark === null || indentationMark === void 0 ? void 0 : indentationMark.attrs.level) >= MAX_INDENTATION_LEVEL) !== null && _ref2 !== void 0 ? _ref2 : false,
+        outdentDisabled: !indentationMark
+      };
+    },
     pmPlugins: function pmPlugins() {
       return [{
         name: 'indentationKeymap',
         plugin: function plugin() {
-          var _api$analytics;
-          return keymapPlugin(api === null || api === void 0 || (_api$analytics = api.analytics) === null || _api$analytics === void 0 ? void 0 : _api$analytics.actions);
+          var _api$analytics3;
+          return keymapPlugin(api === null || api === void 0 || (_api$analytics3 = api.analytics) === null || _api$analytics3 === void 0 ? void 0 : _api$analytics3.actions);
         }
       }];
     }

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

@@ -1,6 +1,6 @@
 import { keymap } from '@atlaskit/editor-prosemirror/keymap';
 import { bindKeymapWithCommand, findShortcutByKeymap, outdent, indent, backspace } from '@atlaskit/editor-common/keymaps';
-import { isTextSelection } from '../../../utils';
+import { isTextSelection } from '@atlaskit/editor-common/utils';
 import { getIndentCommand, getOutdentCommand } from '../commands';
 import { INPUT_METHOD } from '@atlaskit/editor-common/analytics';
 export function keymapPlugin(editorAnalyticsAPI) {

package/dist/esm/plugins/tasks-and-decisions/index.js

@@ -13,6 +13,8 @@ import keymap from './pm-plugins/keymaps';
 import { createPlugin } from './pm-plugins/main';
 import ToolbarDecision from './ui/ToolbarDecision';
 import ToolbarTask from './ui/ToolbarTask';
+import { getCurrentIndentLevel, getTaskItemIndex, isInsideTask } from './pm-plugins/helpers';
+import { MAX_INDENTATION_LEVEL } from '@atlaskit/editor-common/indentation';
 var taskDecisionToolbarGroup = css(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  display: flex;\n"])));
 var addItem = function addItem(insert, listType, schema) {
   return function (_ref) {
@@ -57,8 +59,13 @@ var tasksAndDecisionsPlugin = function tasksAndDecisionsPlugin(_ref2) {
         return undefined;
       }
       var pluginState = taskPluginKey.getState(editorState);
+      var indentLevel = getCurrentIndentLevel(editorState.selection) || 0;
+      var itemIndex = getTaskItemIndex(editorState);
       return {
-        focusedTaskItemLocalId: (pluginState === null || pluginState === void 0 ? void 0 : pluginState.focusedTaskItemLocalId) || null
+        focusedTaskItemLocalId: (pluginState === null || pluginState === void 0 ? void 0 : pluginState.focusedTaskItemLocalId) || null,
+        isInsideTask: isInsideTask(editorState),
+        indentDisabled: itemIndex === 0 || indentLevel >= MAX_INDENTATION_LEVEL,
+        outdentDisabled: indentLevel <= 1
       };
     },
     pmPlugins: function pmPlugins() {

package/dist/esm/plugins/toolbar-lists-indentation/index.js

@@ -1,8 +1,8 @@
-import React from 'react';
+import React, { useMemo } from 'react';
 import { useSharedPluginState } from '@atlaskit/editor-common/hooks';
 import ToolbarListsIndentation from './ui';
 import { ToolbarSize } from '../../ui/Toolbar/types';
-import { createPlugin as indentationButtonsPlugin } from './pm-plugins/indentation-buttons';
+import { getIndentationButtonsState } from './pm-plugins/indentation-buttons';
 import { pluginKey as indentationButtonPluginKey } from './pm-plugins/indentation-buttons';
 var toolbarListsIndentationPlugin = function toolbarListsIndentationPlugin(_ref) {
   var _api$featureFlags;
@@ -22,28 +22,14 @@ var toolbarListsIndentationPlugin = function toolbarListsIndentationPlugin(_ref)
       }
       return indentationButtonPluginKey.getState(editorState);
     },
-    pmPlugins: function pmPlugins() {
-      return [{
-        name: 'indentationButtons',
-        plugin: function plugin(_ref3) {
-          var dispatch = _ref3.dispatch;
-          return indentationButtonsPlugin({
-            dispatch: dispatch,
-            showIndentationButtons: showIndentationButtons,
-            allowHeadingAndParagraphIndentation: allowHeadingAndParagraphIndentation,
-            api: api
-          });
-        }
-      }];
-    },
-    primaryToolbarComponent: function primaryToolbarComponent(_ref4) {
-      var editorView = _ref4.editorView,
-        popupsMountPoint = _ref4.popupsMountPoint,
-        popupsBoundariesElement = _ref4.popupsBoundariesElement,
-        popupsScrollableElement = _ref4.popupsScrollableElement,
-        toolbarSize = _ref4.toolbarSize,
-        disabled = _ref4.disabled,
-        isToolbarReducedSpacing = _ref4.isToolbarReducedSpacing;
+    primaryToolbarComponent: function primaryToolbarComponent(_ref3) {
+      var editorView = _ref3.editorView,
+        popupsMountPoint = _ref3.popupsMountPoint,
+        popupsBoundariesElement = _ref3.popupsBoundariesElement,
+        popupsScrollableElement = _ref3.popupsScrollableElement,
+        toolbarSize = _ref3.toolbarSize,
+        disabled = _ref3.disabled,
+        isToolbarReducedSpacing = _ref3.isToolbarReducedSpacing;
       var isSmall = toolbarSize < ToolbarSize.L;
       return /*#__PURE__*/React.createElement(PrimaryToolbarComponent, {
         featureFlags: featureFlags,
@@ -55,25 +41,31 @@ var toolbarListsIndentationPlugin = function toolbarListsIndentationPlugin(_ref)
         disabled: disabled,
         editorView: editorView,
         showIndentationButtons: showIndentationButtons,
-        pluginInjectionApi: api
+        pluginInjectionApi: api,
+        allowHeadingAndParagraphIndentation: allowHeadingAndParagraphIndentation
       });
     }
   };
 };
-function PrimaryToolbarComponent(_ref5) {
-  var featureFlags = _ref5.featureFlags,
-    popupsMountPoint = _ref5.popupsMountPoint,
-    popupsBoundariesElement = _ref5.popupsBoundariesElement,
-    popupsScrollableElement = _ref5.popupsScrollableElement,
-    isSmall = _ref5.isSmall,
-    isToolbarReducedSpacing = _ref5.isToolbarReducedSpacing,
-    disabled = _ref5.disabled,
-    editorView = _ref5.editorView,
-    showIndentationButtons = _ref5.showIndentationButtons,
-    pluginInjectionApi = _ref5.pluginInjectionApi;
-  var _useSharedPluginState = useSharedPluginState(pluginInjectionApi, ['list', 'toolbarListsIndentation']),
+export function PrimaryToolbarComponent(_ref4) {
+  var featureFlags = _ref4.featureFlags,
+    popupsMountPoint = _ref4.popupsMountPoint,
+    popupsBoundariesElement = _ref4.popupsBoundariesElement,
+    popupsScrollableElement = _ref4.popupsScrollableElement,
+    isSmall = _ref4.isSmall,
+    isToolbarReducedSpacing = _ref4.isToolbarReducedSpacing,
+    disabled = _ref4.disabled,
+    editorView = _ref4.editorView,
+    showIndentationButtons = _ref4.showIndentationButtons,
+    pluginInjectionApi = _ref4.pluginInjectionApi,
+    allowHeadingAndParagraphIndentation = _ref4.allowHeadingAndParagraphIndentation;
+  var _useSharedPluginState = useSharedPluginState(pluginInjectionApi, ['list', 'indentation', 'taskDecision']),
     listState = _useSharedPluginState.listState,
-    toolbarListsIndentationState = _useSharedPluginState.toolbarListsIndentationState;
+    indentationState = _useSharedPluginState.indentationState,
+    taskDecisionState = _useSharedPluginState.taskDecisionState;
+  var toolbarListsIndentationState = useMemo(function () {
+    return getIndentationButtonsState(editorView.state, allowHeadingAndParagraphIndentation, taskDecisionState, indentationState, pluginInjectionApi === null || pluginInjectionApi === void 0 ? void 0 : pluginInjectionApi.list.actions.isInsideListItem);
+  }, [editorView.state, allowHeadingAndParagraphIndentation, taskDecisionState, indentationState, pluginInjectionApi === null || pluginInjectionApi === void 0 ? void 0 : pluginInjectionApi.list.actions.isInsideListItem]);
   if (!listState) {
     return null;
   }
@@ -93,6 +85,7 @@ function PrimaryToolbarComponent(_ref5) {
     showIndentationButtons: !!showIndentationButtons,
     indentDisabled: toolbarListsIndentationState.indentDisabled,
     outdentDisabled: toolbarListsIndentationState.outdentDisabled,
+    indentationStateNode: toolbarListsIndentationState === null || toolbarListsIndentationState === void 0 ? void 0 : toolbarListsIndentationState.node,
     pluginInjectionApi: pluginInjectionApi
   });
 }

package/dist/esm/plugins/toolbar-lists-indentation/pm-plugins/indentation-buttons.js

@@ -1,25 +1,22 @@
 import { PluginKey } from '@atlaskit/editor-prosemirror/state';
 import { hasParentNodeOfType } from '@atlaskit/editor-prosemirror/utils';
-import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
-import { shallowEqual } from '@atlaskit/editor-common/utils';
-import { getCurrentIndentLevel as getTaskListIndentLevel, getTaskItemIndex, isInsideTask } from '../../tasks-and-decisions/pm-plugins/helpers';
-import { isIndentationAllowed, MAX_INDENTATION_LEVEL } from '../../indentation/commands';
 import { getListItemAttributes } from '@atlaskit/editor-common/lists';
+import { MAX_INDENTATION_LEVEL } from '@atlaskit/editor-common/indentation';
 export var pluginKey = new PluginKey('indentationButtonsPlugin');
-function getIndentationButtonsState(editorState, allowHeadingAndParagraphIndentation, api) {
+export function getIndentationButtonsState(editorState, allowHeadingAndParagraphIndentation, taskDecisionState, indentationState, isInsideListItem) {
+  var _indentationState$isI;
   var state = {
     indentDisabled: true,
     outdentDisabled: true,
     node: null
   };
   var selection = editorState.selection;
-  var node = selection.$from.node();
 
   // Handle bullet and numbered lists seperately as they do
   // not use the indentation mark.
   // Check for lists before paragraphs and headings in case
   // the selection is in a list nested in a layout column.
-  if (api !== null && api !== void 0 && api.list.actions.isInsideListItem(editorState.tr)) {
+  if (isInsideListItem !== null && isInsideListItem !== void 0 && isInsideListItem(editorState.tr)) {
     var _getListItemAttribute = getListItemAttributes(selection.$head),
       indentLevel = _getListItemAttribute.indentLevel,
       itemIndex = _getListItemAttribute.itemIndex;
@@ -33,12 +30,10 @@ function getIndentationButtonsState(editorState, allowHeadingAndParagraphIndenta
 
   // Handle tasks seperately as they do not use the indentation mark
   // and have different behaviour for outdent compared to lists
-  if (isInsideTask(editorState)) {
-    var _indentLevel = getTaskListIndentLevel(selection) || 0;
-    var _itemIndex = getTaskItemIndex(editorState);
+  if (taskDecisionState !== null && taskDecisionState !== void 0 && taskDecisionState.isInsideTask) {
     return {
-      indentDisabled: _itemIndex === 0 || _indentLevel >= MAX_INDENTATION_LEVEL,
-      outdentDisabled: _indentLevel <= 1,
+      indentDisabled: taskDecisionState.indentDisabled,
+      outdentDisabled: taskDecisionState.outdentDisabled,
       node: 'taskList'
     };
   }
@@ -46,51 +41,12 @@ function getIndentationButtonsState(editorState, allowHeadingAndParagraphIndenta
   var isInLayoutNode = hasParentNodeOfType(editorState.schema.nodes.layoutColumn)(selection) &&
   // depth of non-nested paragraphs and headings in layouts will always be 3
   selection.$from.depth === 3;
-  if (allowHeadingAndParagraphIndentation && isIndentationAllowed(editorState.schema, node) && (isTopLevelParagraphOrHeading || isInLayoutNode)) {
-    var indentationMark = node.marks.find(function (mark) {
-      return mark.type === editorState.schema.marks.indentation;
-    });
-    if (!indentationMark) {
-      return {
-        outdentDisabled: true,
-        indentDisabled: false,
-        node: 'paragraph_heading'
-      };
-    }
+  if (allowHeadingAndParagraphIndentation && ((_indentationState$isI = indentationState === null || indentationState === void 0 ? void 0 : indentationState.isIndentationAllowed) !== null && _indentationState$isI !== void 0 ? _indentationState$isI : false) && (isTopLevelParagraphOrHeading || isInLayoutNode) && indentationState) {
     return {
-      indentDisabled: indentationMark.attrs.level >= MAX_INDENTATION_LEVEL,
-      outdentDisabled: false,
+      indentDisabled: indentationState.indentDisabled,
+      outdentDisabled: indentationState.outdentDisabled,
       node: 'paragraph_heading'
     };
   }
   return state;
-}
-export var createPlugin = function createPlugin(_ref) {
-  var dispatch = _ref.dispatch,
-    showIndentationButtons = _ref.showIndentationButtons,
-    allowHeadingAndParagraphIndentation = _ref.allowHeadingAndParagraphIndentation,
-    api = _ref.api;
-  return new SafePlugin({
-    state: {
-      init: function init(_config, state) {
-        var initialState = {
-          indentDisabled: true,
-          outdentDisabled: true,
-          node: null
-        };
-        return showIndentationButtons ? getIndentationButtonsState(state, allowHeadingAndParagraphIndentation, api) : initialState;
-      },
-      apply: function apply(_tr, pluginState, _oldState, newState) {
-        if (showIndentationButtons) {
-          var state = getIndentationButtonsState(newState, allowHeadingAndParagraphIndentation, api);
-          if (!shallowEqual(pluginState, state)) {
-            dispatch(pluginKey, state);
-            return state;
-          }
-        }
-        return pluginState;
-      }
-    },
-    key: pluginKey
-  });
-};
+}

package/dist/esm/plugins/toolbar-lists-indentation/ui/Toolbar.js

@@ -7,8 +7,7 @@ import IndentIcon from '@atlaskit/icon/glyph/editor/indent';
 import OutdentIcon from '@atlaskit/icon/glyph/editor/outdent';
 import { toggleBulletList as toggleBulletListKeymap, toggleOrderedList as toggleOrderedListKeymap, indent as toggleIndentKeymap, outdent as toggleOutdentKeymap, ToolTipContent, tooltip } from '../../../keymaps';
 import ToolbarButton, { TOOLBAR_BUTTON } from '../../../ui/ToolbarButton';
-import { listMessages as messages } from '@atlaskit/editor-common/messages';
-import { messages as indentationMessages } from '../../indentation/messages';
+import { listMessages as messages, indentationMessages } from '@atlaskit/editor-common/messages';
 import { separatorStyles, buttonGroupStyle } from '@atlaskit/editor-common/styles';
 import { getAriaKeyshortcuts } from '@atlaskit/editor-common/keymaps';
 import { useEffect, useRef } from 'react';

package/dist/esm/plugins/toolbar-lists-indentation/ui/ToolbarDropdown.js

@@ -11,8 +11,7 @@ import ToolbarButton from '../../../ui/ToolbarButton';
 import { shortcutStyle } from '../../../ui/styles';
 import { expandIconWrapperStyle } from '@atlaskit/editor-common/styles';
 import { wrapperStyle, separatorStyles } from '@atlaskit/editor-common/styles';
-import { listMessages } from '@atlaskit/editor-common/messages';
-import { messages as indentationMessages } from '../../indentation/messages';
+import { listMessages, indentationMessages } from '@atlaskit/editor-common/messages';
 export function ToolbarDropdown(props) {
   var _useIntl = useIntl(),
     formatMessage = _useIntl.formatMessage;

package/dist/esm/plugins/toolbar-lists-indentation/ui/index.js

@@ -17,6 +17,7 @@ export default function ToolbarListsIndentation(props) {
     popupsScrollableElement = props.popupsScrollableElement,
     indentDisabled = props.indentDisabled,
     outdentDisabled = props.outdentDisabled,
+    indentationStateNode = props.indentationStateNode,
     featureFlags = props.featureFlags,
     pluginInjectionApi = props.pluginInjectionApi;
   if (isSmall) {
@@ -34,7 +35,7 @@ export default function ToolbarListsIndentation(props) {
       indentDisabled: indentDisabled,
       outdentDisabled: outdentDisabled,
       disabled: disabled,
-      onItemActivated: onItemActivated(pluginInjectionApi),
+      onItemActivated: onItemActivated(pluginInjectionApi, indentationStateNode),
       featureFlags: featureFlags
     });
   }
@@ -49,7 +50,7 @@ export default function ToolbarListsIndentation(props) {
     indentDisabled: indentDisabled,
     outdentDisabled: outdentDisabled,
     disabled: disabled,
-    onItemActivated: onItemActivated(pluginInjectionApi),
+    onItemActivated: onItemActivated(pluginInjectionApi, indentationStateNode),
     featureFlags: featureFlags
   });
 }

package/dist/esm/plugins/toolbar-lists-indentation/ui/onItemActivated.js

@@ -1,8 +1,6 @@
-import { getIndentCommand as indentParagraphOrHeading, getOutdentCommand as outdentParagraphOrHeading } from '../../indentation/commands';
 import { getIndentCommand as indentTaskList, getUnindentCommand as outdentTaskList } from '../../tasks-and-decisions/pm-plugins/keymaps';
 import { INPUT_METHOD } from '@atlaskit/editor-common/analytics';
-import { pluginKey as indentationButtonsPluginKey } from '../pm-plugins/indentation-buttons';
-export var onItemActivated = function onItemActivated(pluginInjectionApi) {
+export var onItemActivated = function onItemActivated(pluginInjectionApi, indentationStateNode) {
   return function (_ref) {
     var buttonName = _ref.buttonName,
       editorView = _ref.editorView;
@@ -15,35 +13,33 @@ export var onItemActivated = function onItemActivated(pluginInjectionApi) {
         break;
       case 'indent':
         {
-          var _indentationButtonsPl;
-          var node = (_indentationButtonsPl = indentationButtonsPluginKey.getState(editorView.state)) === null || _indentationButtonsPl === void 0 ? void 0 : _indentationButtonsPl.node;
+          var node = indentationStateNode;
           if (node === 'paragraph_heading') {
-            var _pluginInjectionApi$a;
-            indentParagraphOrHeading(pluginInjectionApi === null || pluginInjectionApi === void 0 || (_pluginInjectionApi$a = pluginInjectionApi.analytics) === null || _pluginInjectionApi$a === void 0 ? void 0 : _pluginInjectionApi$a.actions)(INPUT_METHOD.TOOLBAR)(editorView.state, editorView.dispatch);
+            var _pluginInjectionApi$i;
+            pluginInjectionApi === null || pluginInjectionApi === void 0 || (_pluginInjectionApi$i = pluginInjectionApi.indentation) === null || _pluginInjectionApi$i === void 0 || _pluginInjectionApi$i.actions.indentParagraphOrHeading(INPUT_METHOD.TOOLBAR)(editorView.state, editorView.dispatch);
           }
           if (node === 'list') {
             pluginInjectionApi === null || pluginInjectionApi === void 0 || pluginInjectionApi.core.actions.execute(pluginInjectionApi === null || pluginInjectionApi === void 0 ? void 0 : pluginInjectionApi.list.commands.indentList(INPUT_METHOD.TOOLBAR));
           }
           if (node === 'taskList') {
-            var _pluginInjectionApi$a2;
-            indentTaskList(pluginInjectionApi === null || pluginInjectionApi === void 0 || (_pluginInjectionApi$a2 = pluginInjectionApi.analytics) === null || _pluginInjectionApi$a2 === void 0 ? void 0 : _pluginInjectionApi$a2.actions)(INPUT_METHOD.TOOLBAR)(editorView.state, editorView.dispatch);
+            var _pluginInjectionApi$a;
+            indentTaskList(pluginInjectionApi === null || pluginInjectionApi === void 0 || (_pluginInjectionApi$a = pluginInjectionApi.analytics) === null || _pluginInjectionApi$a === void 0 ? void 0 : _pluginInjectionApi$a.actions)(INPUT_METHOD.TOOLBAR)(editorView.state, editorView.dispatch);
           }
           break;
         }
       case 'outdent':
         {
-          var _indentationButtonsPl2;
-          var _node = (_indentationButtonsPl2 = indentationButtonsPluginKey.getState(editorView.state)) === null || _indentationButtonsPl2 === void 0 ? void 0 : _indentationButtonsPl2.node;
+          var _node = indentationStateNode;
           if (_node === 'paragraph_heading') {
-            var _pluginInjectionApi$a3;
-            outdentParagraphOrHeading(pluginInjectionApi === null || pluginInjectionApi === void 0 || (_pluginInjectionApi$a3 = pluginInjectionApi.analytics) === null || _pluginInjectionApi$a3 === void 0 ? void 0 : _pluginInjectionApi$a3.actions)(INPUT_METHOD.TOOLBAR)(editorView.state, editorView.dispatch);
+            var _pluginInjectionApi$i2;
+            pluginInjectionApi === null || pluginInjectionApi === void 0 || (_pluginInjectionApi$i2 = pluginInjectionApi.indentation) === null || _pluginInjectionApi$i2 === void 0 || _pluginInjectionApi$i2.actions.outdentParagraphOrHeading(INPUT_METHOD.TOOLBAR)(editorView.state, editorView.dispatch);
           }
           if (_node === 'list') {
             pluginInjectionApi === null || pluginInjectionApi === void 0 || pluginInjectionApi.core.actions.execute(pluginInjectionApi === null || pluginInjectionApi === void 0 ? void 0 : pluginInjectionApi.list.commands.outdentList(INPUT_METHOD.TOOLBAR));
           }
           if (_node === 'taskList') {
-            var _pluginInjectionApi$a4;
-            outdentTaskList(pluginInjectionApi === null || pluginInjectionApi === void 0 || (_pluginInjectionApi$a4 = pluginInjectionApi.analytics) === null || _pluginInjectionApi$a4 === void 0 ? void 0 : _pluginInjectionApi$a4.actions)(INPUT_METHOD.TOOLBAR)(editorView.state, editorView.dispatch);
+            var _pluginInjectionApi$a2;
+            outdentTaskList(pluginInjectionApi === null || pluginInjectionApi === void 0 || (_pluginInjectionApi$a2 = pluginInjectionApi.analytics) === null || _pluginInjectionApi$a2 === void 0 ? void 0 : _pluginInjectionApi$a2.actions)(INPUT_METHOD.TOOLBAR)(editorView.state, editorView.dispatch);
           }
           break;
         }

package/dist/esm/ui/ConfigPanel/ConfigPanel.js

@@ -1,5 +1,4 @@
 import _extends from "@babel/runtime/helpers/extends";
-import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
 import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
 import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
 import _createClass from "@babel/runtime/helpers/createClass";
@@ -8,9 +7,6 @@ import _inherits from "@babel/runtime/helpers/inherits";
 import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
 import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
-var _excluded = ["page", "labels", "types", "name", "width"];
-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 _regeneratorRuntime from "@babel/runtime/regenerator";
 function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
 function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
@@ -35,7 +31,6 @@ import WithPluginState from '../WithPluginState';
 import FormContent from './FormContent';
 import { messages } from './messages';
 import { FormErrorBoundary } from './FormErrorBoundary';
-var LOGGED_MACRO_KEYS = ['children', 'recently-updated', 'excerpt'];
 function ConfigForm(_ref) {
   var canSave = _ref.canSave,
     errorMessage = _ref.errorMessage,
@@ -333,50 +328,15 @@ var ConfigPanel = /*#__PURE__*/function (_React$Component) {
       var _this$props4 = this.props,
         createAnalyticsEvent = _this$props4.createAnalyticsEvent,
         extensionManifest = _this$props4.extensionManifest;
-      var currentParameters = this.state.currentParameters;
-
-      // PGXT-4393 We need to collect configuration analytics for the macros in LOGGED_MACRO_KEYS.
-      // This function takes the parameters and filters out anything which might have UGC.
-      var getMacroParameters = function getMacroParameters() {
-        var page = currentParameters.page,
-          labels = currentParameters.labels,
-          types = currentParameters.types,
-          name = currentParameters.name,
-          width = currentParameters.width,
-          safeParams = _objectWithoutProperties(currentParameters, _excluded);
-        var ugcFreeParams = _objectSpread({}, safeParams);
-        // Parse types field as an array of valid content types and include in the result
-        if (types) {
-          var contentTypes = ['page', 'blogpost', 'comment', 'attachment'];
-          var parsedTypes = types.split(',').map(function (type) {
-            return type.trim();
-          }).filter(function (type) {
-            return contentTypes.includes(type);
-          });
-          ugcFreeParams = _objectSpread({
-            types: parsedTypes
-          }, ugcFreeParams);
-        }
-        // Since width is a raw string input, parse then return
-        if (width) {
-          var parsedWidth = parseFloat(width);
-          ugcFreeParams = _objectSpread({
-            width: parsedWidth
-          }, ugcFreeParams);
-        }
-        return ugcFreeParams;
-      };
       fireAnalyticsEvent(createAnalyticsEvent)({
         payload: {
           action: ACTION.CLOSED,
           actionSubject: ACTION_SUBJECT.CONFIG_PANEL,
           eventType: EVENT_TYPE.UI,
-          attributes: _objectSpread({
+          attributes: {
             extensionKey: extensionManifest === null || extensionManifest === void 0 ? void 0 : extensionManifest.key,
             extensionType: extensionManifest === null || extensionManifest === void 0 ? void 0 : extensionManifest.type
-          }, extensionManifest !== null && extensionManifest !== void 0 && extensionManifest.key && LOGGED_MACRO_KEYS.includes(extensionManifest.key) ? {
-            parameters: getMacroParameters()
-          } : {})
+          }
         }
       });
     }

package/dist/esm/version-wrapper.js

@@ -1,2 +1,2 @@
 export var name = "@atlaskit/editor-core";
-export var version = "189.3.22";
+export var version = "189.3.24";

package/dist/types/plugins/find-replace/ui/styles.d.ts

@@ -3,3 +3,4 @@ export declare const ruleStyles: import("@emotion/react").SerializedStyles;
 export declare const wrapperStyles: import("@emotion/react").SerializedStyles;
 export declare const sectionWrapperStyles: import("@emotion/react").SerializedStyles;
 export declare const countStyles: import("@emotion/react").SerializedStyles;
+export declare const countWrapperStyles: import("@emotion/react").SerializedStyles;

package/dist/types/plugins/indentation/commands/index.d.ts

@@ -1,8 +1,7 @@
 import type { Node as PmNode, Schema } from '@atlaskit/editor-prosemirror/model';
 import type { EditorAnalyticsAPI } from '@atlaskit/editor-common/analytics';
-import type { Command } from '../../../types/command';
+import type { Command } from '@atlaskit/editor-common/types';
 import type { IndentationInputMethod } from './utils';
-export declare const MAX_INDENTATION_LEVEL = 6;
 export declare const isIndentationAllowed: (schema: Schema, node: PmNode) => boolean;
 export declare const getIndentCommand: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => (inputMethod?: IndentationInputMethod) => Command;
 export declare const getOutdentCommand: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => (inputMethod?: IndentationInputMethod) => Command;

package/dist/types/plugins/indentation/commands/utils.d.ts

@@ -1,7 +1,7 @@
 import type { IndentationMarkAttributes } from '@atlaskit/adf-schema';
 import type { INDENT_DIRECTION, INPUT_METHOD, EditorAnalyticsAPI } from '@atlaskit/editor-common/analytics';
 import type { EditorState, Transaction } from '@atlaskit/editor-prosemirror/state';
-import type { GetAttrsChange } from '../../../utils/getAttrsWithChangesRecorder';
+import type { GetAttrsChange } from '../getAttrsWithChangesRecorder';
 export type PrevAttributes = IndentationMarkAttributes | undefined;
 export type NewAttributes = IndentationMarkAttributes | undefined | false;
 export type IndentationChangesOptions = {

package/dist/types/plugins/indentation/index.d.ts

@@ -1,6 +1,18 @@
-import type { NextEditorPlugin, OptionalPlugin } from '@atlaskit/editor-common/types';
+import type { NextEditorPlugin, OptionalPlugin, Command } from '@atlaskit/editor-common/types';
 import type { AnalyticsPlugin } from '@atlaskit/editor-plugin-analytics';
-declare const indentationPlugin: NextEditorPlugin<'indentation', {
+import type { IndentationInputMethod } from './commands/utils';
+type IndentationPluginSharedState = {
+    isIndentationAllowed: boolean;
+    indentDisabled: boolean;
+    outdentDisabled: boolean;
+};
+export type IndentationPlugin = NextEditorPlugin<'indentation', {
     dependencies: [OptionalPlugin<AnalyticsPlugin>];
+    actions: {
+        indentParagraphOrHeading: (inputMethod: IndentationInputMethod) => Command;
+        outdentParagraphOrHeading: (inputMethod: IndentationInputMethod) => Command;
+    };
+    sharedState: IndentationPluginSharedState | undefined;
 }>;
+declare const indentationPlugin: IndentationPlugin;
 export default indentationPlugin;

package/dist/types/plugins/tasks-and-decisions/types.d.ts

@@ -28,6 +28,9 @@ export interface TaskDecisionPluginOptions extends LongPressSelectionPluginOptio
 }
 export type TaskAndDecisionsSharedState = {
     focusedTaskItemLocalId: string | null;
+    indentDisabled: boolean;
+    outdentDisabled: boolean;
+    isInsideTask: boolean;
 };
 export type TaskAndDecisionsPlugin = NextEditorPlugin<'taskDecision', {
     pluginConfiguration: TaskDecisionPluginOptions | undefined;

package/dist/types/plugins/toolbar-lists-indentation/index.d.ts

@@ -1,19 +1,35 @@
-import type { NextEditorPlugin, OptionalPlugin } from '@atlaskit/editor-common/types';
+/// <reference types="react" />
+import type { FeatureFlags, NextEditorPlugin, OptionalPlugin } from '@atlaskit/editor-common/types';
 import type { FeatureFlagsPlugin } from '@atlaskit/editor-plugin-feature-flags';
 import type { AnalyticsPlugin } from '@atlaskit/editor-plugin-analytics';
 import type { ListPlugin } from '@atlaskit/editor-plugin-list';
 import type { IndentationButtons } from './pm-plugins/indentation-buttons';
+import type { ToolbarUiComponentFactoryParams } from '../../types';
+import type { ExtractInjectionAPI } from '@atlaskit/editor-common/types';
+import type { IndentationPlugin } from '../indentation';
+import type { TaskAndDecisionsPlugin } from '../tasks-and-decisions/types';
 type Config = {
     showIndentationButtons: boolean;
     allowHeadingAndParagraphIndentation: boolean;
 };
-declare const toolbarListsIndentationPlugin: NextEditorPlugin<'toolbarListsIndentation', {
+type ToolbarListsIndentationPlugin = NextEditorPlugin<'toolbarListsIndentation', {
     pluginConfiguration: Config;
     dependencies: [
         FeatureFlagsPlugin,
         ListPlugin,
+        OptionalPlugin<IndentationPlugin>,
+        OptionalPlugin<TaskAndDecisionsPlugin>,
         OptionalPlugin<AnalyticsPlugin>
     ];
     sharedState: IndentationButtons | undefined;
 }>;
+declare const toolbarListsIndentationPlugin: ToolbarListsIndentationPlugin;
+type PrimaryToolbarComponentProps = Pick<ToolbarUiComponentFactoryParams, 'editorView' | 'popupsMountPoint' | 'popupsBoundariesElement' | 'popupsScrollableElement' | 'disabled' | 'isToolbarReducedSpacing'> & {
+    featureFlags: FeatureFlags;
+    isSmall: boolean;
+    showIndentationButtons?: boolean;
+    pluginInjectionApi: ExtractInjectionAPI<typeof toolbarListsIndentationPlugin> | undefined;
+    allowHeadingAndParagraphIndentation: boolean;
+};
+export declare function PrimaryToolbarComponent({ featureFlags, popupsMountPoint, popupsBoundariesElement, popupsScrollableElement, isSmall, isToolbarReducedSpacing, disabled, editorView, showIndentationButtons, pluginInjectionApi, allowHeadingAndParagraphIndentation, }: PrimaryToolbarComponentProps): JSX.Element | null;
 export default toolbarListsIndentationPlugin;

package/dist/types/plugins/toolbar-lists-indentation/pm-plugins/indentation-buttons.d.ts

@@ -1,17 +1,21 @@
+import type { EditorState, Transaction } from '@atlaskit/editor-prosemirror/state';
 import { PluginKey } from '@atlaskit/editor-prosemirror/state';
-import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
-import type { Dispatch } from '../../../event-dispatcher';
-import type { ExtractInjectionAPI } from '@atlaskit/editor-common/types';
-import type toolbarListsIndentationPlugin from '../index';
+export type IndentationButtonNode = null | 'paragraph_heading' | 'list' | 'taskList';
 export interface IndentationButtons {
     indentDisabled: boolean;
     outdentDisabled: boolean;
-    node: null | 'paragraph_heading' | 'list' | 'taskList';
+    node: IndentationButtonNode;
 }
 export declare const pluginKey: PluginKey<IndentationButtons>;
-export declare const createPlugin: ({ dispatch, showIndentationButtons, allowHeadingAndParagraphIndentation, api, }: {
-    dispatch: Dispatch;
-    showIndentationButtons: boolean;
-    allowHeadingAndParagraphIndentation: boolean;
-    api: ExtractInjectionAPI<typeof toolbarListsIndentationPlugin> | undefined;
-}) => SafePlugin<IndentationButtons>;
+interface TaskDecisionState {
+    isInsideTask: boolean;
+    indentDisabled: boolean;
+    outdentDisabled: boolean;
+}
+interface IndentationState {
+    isIndentationAllowed: boolean;
+    indentDisabled: boolean;
+    outdentDisabled: boolean;
+}
+export declare function getIndentationButtonsState(editorState: EditorState, allowHeadingAndParagraphIndentation: boolean, taskDecisionState: TaskDecisionState | undefined, indentationState: IndentationState | undefined, isInsideListItem: ((tr: Transaction) => boolean | undefined) | undefined): IndentationButtons;
+export {};

package/dist/types/plugins/toolbar-lists-indentation/ui/index.d.ts

@@ -3,6 +3,7 @@ import { jsx } from '@emotion/react';
 import type { EditorView } from '@atlaskit/editor-prosemirror/view';
 import type { ExtractInjectionAPI, FeatureFlags } from '@atlaskit/editor-common/types';
 import type toolbarListsIndentationPlugin from '../index';
+import type { IndentationButtonNode } from '../pm-plugins/indentation-buttons';
 export interface Props {
     editorView: EditorView;
     featureFlags: FeatureFlags;
@@ -19,6 +20,7 @@ export interface Props {
     showIndentationButtons?: boolean;
     indentDisabled?: boolean;
     outdentDisabled?: boolean;
+    indentationStateNode?: IndentationButtonNode;
     pluginInjectionApi?: ExtractInjectionAPI<typeof toolbarListsIndentationPlugin> | undefined;
 }
 export default function ToolbarListsIndentation(props: Props): jsx.JSX.Element;