@atlaskit/editor-plugin-block-menu 1.0.0 → 1.0.2

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @atlaskit/editor-plugin-block-menu
 
+## 1.0.2
+
+### Patch Changes
+
+- [`32434f817d714`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/32434f817d714) -
+  ED-29126: Convert list to block nodes
+- [`255837cfba315`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/255837cfba315) -
+  Internal changes to how border radius is applied.
+- Updated dependencies
+
+## 1.0.1
+
+### Patch Changes
+
+- [`ecae39119dc4b`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/ecae39119dc4b) -
+  [ux] ED-28558 Wrap block nodes inside container nodes
+- Updated dependencies
+
 ## 1.0.0
 
 ### Patch Changes

package/dist/cjs/editor-commands/formatNode.js

@@ -27,19 +27,22 @@ var formatNode = exports.formatNode = function formatNode(targetType) {
       nodePos = selectedNode.pos;
     } else {
       // Try to find parent node (including list parents)
-      var parentNode = (0, _utils.findParentNodeOfType)([nodes.blockquote, nodes.panel, nodes.expand, nodes.codeBlock, nodes.listItem, nodes.layoutSection])(selection);
+      var parentNode = (0, _utils.findParentNodeOfType)([nodes.blockquote, nodes.panel, nodes.expand, nodes.codeBlock, nodes.listItem, nodes.taskItem, nodes.layoutSection])(selection);
       if (parentNode) {
         nodeToFormat = parentNode.node;
         nodePos = parentNode.pos;
-
+        var paragraphOrHeadingNode = (0, _utils.findParentNodeOfType)([nodes.paragraph, nodes.heading])(selection);
         // Special case: if we found a listItem, check if we need the parent list instead
-        if (parentNode.node.type === nodes.listItem) {
+        if (parentNode.node.type === nodes.listItem || parentNode.node.type === nodes.taskItem) {
           var listParent = (0, _utils.findParentNodeOfType)([nodes.bulletList, nodes.orderedList, nodes.taskList])(selection);
           if (listParent) {
             // For list transformations, we want the list parent, not the listItem
             nodeToFormat = listParent.node;
             nodePos = listParent.pos;
           }
+        } else if (paragraphOrHeadingNode) {
+          nodeToFormat = paragraphOrHeadingNode.node;
+          nodePos = paragraphOrHeadingNode.pos;
         }
       }
     }

package/dist/cjs/editor-commands/transforms/block-transforms.js

@@ -5,33 +5,45 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.transformBlockNode = void 0;
 var _containerTransforms = require("./container-transforms");
+var _inlineNodeTransforms = require("./inline-node-transforms");
 var _listTransforms = require("./list-transforms");
 var _utils = require("./utils");
 /**
  * Transform block nodes (paragraph, heading, codeblock)
  */
 var transformBlockNode = exports.transformBlockNode = function transformBlockNode(context) {
-  var tr = context.tr,
-    targetNodeType = context.targetNodeType,
-    targetAttrs = context.targetAttrs;
-  var selection = tr.selection;
-  var $from = selection.$from,
-    $to = selection.$to;
+  var targetNodeType = context.targetNodeType;
 
   // Handle transformation to list types
   if ((0, _utils.isListNodeType)(targetNodeType)) {
-    return (0, _listTransforms.transformToList)(context);
+    return (0, _listTransforms.transformBlockToList)(context);
   }
 
   // Handle transformation to container types (panel, expand, blockquote)
   if ((0, _utils.isContainerNodeType)(targetNodeType)) {
-    return (0, _containerTransforms.transformToContainer)();
+    return (0, _containerTransforms.transformToContainer)(context);
   }
 
   // Handle block type transformation (paragraph, heading, codeblock)
   if ((0, _utils.isBlockNodeType)(targetNodeType)) {
-    tr.setBlockType($from.pos, $to.pos, targetNodeType, targetAttrs);
-    return tr;
+    return transformToBlockNode(context);
   }
   return null;
+};
+var transformToBlockNode = function transformToBlockNode(context) {
+  var tr = context.tr,
+    targetNodeType = context.targetNodeType,
+    targetAttrs = context.targetAttrs;
+  var selection = tr.selection,
+    doc = tr.doc;
+  var $from = selection.$from,
+    $to = selection.$to;
+  var schema = doc.type.schema;
+  if (targetNodeType === schema.nodes.codeBlock) {
+    var textContent = (0, _inlineNodeTransforms.getInlineNodeTextContent)(selection.content().content, tr);
+    var node = schema.nodes.codeBlock.createChecked(undefined, textContent);
+    return tr.replaceRangeWith(selection.from, selection.to, node);
+  }
+  tr.setBlockType($from.pos, $to.pos, targetNodeType, targetAttrs);
+  return tr;
 };

package/dist/cjs/editor-commands/transforms/container-transforms.js

@@ -4,22 +4,55 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.unwrapAndConvertToList = exports.unwrapAndConvertToBlockType = exports.transformToContainer = exports.transformContainerNode = void 0;
+var _model = require("@atlaskit/editor-prosemirror/model");
 var _utils = require("./utils");
+var convertInvalidNodeToValidNodeType = function convertInvalidNodeToValidNodeType(sourceContent, sourceNodeType, validNodeType, withMarks) {
+  var validTransformedContent = [];
+  // Headings are not valid inside headings so convert heading nodes to paragraphs
+  sourceContent.forEach(function (node) {
+    if (sourceNodeType === node.type) {
+      validTransformedContent.push(validNodeType.createChecked(node.attrs, node.content, withMarks ? node.marks : undefined));
+    } else {
+      validTransformedContent.push(node);
+    }
+  });
+  return _model.Fragment.from(validTransformedContent);
+};
+
 /**
  * Transform selection to container type
  */
-var transformToContainer = exports.transformToContainer = function transformToContainer() {
-  return null;
+var transformToContainer = exports.transformToContainer = function transformToContainer(_ref) {
+  var tr = _ref.tr,
+    sourceNode = _ref.sourceNode,
+    targetNodeType = _ref.targetNodeType,
+    targetAttrs = _ref.targetAttrs;
+  var selection = tr.selection;
+  var schema = tr.doc.type.schema;
+  var content = selection.content().content;
+  var transformedContent = content;
+  if (sourceNode.type === schema.nodes.codeBlock) {
+    transformedContent = convertInvalidNodeToValidNodeType(transformedContent, schema.nodes.codeBlock, schema.nodes.paragraph);
+  }
+  if (targetNodeType === schema.nodes.blockquote) {
+    transformedContent = convertInvalidNodeToValidNodeType(transformedContent, schema.nodes.heading, schema.nodes.paragraph, true);
+  }
+  var newNode = targetNodeType.createAndFill(targetAttrs, transformedContent);
+  if (!newNode) {
+    return null;
+  }
+  tr.replaceRangeWith(selection.from, selection.to, newNode);
+  return tr;
 };
 
 /**
  * Transform container nodes (panel, expand, blockquote)
  */
-var transformContainerNode = exports.transformContainerNode = function transformContainerNode(_ref) {
-  var tr = _ref.tr,
-    sourcePos = _ref.sourcePos,
-    targetNodeType = _ref.targetNodeType,
-    targetAttrs = _ref.targetAttrs;
+var transformContainerNode = exports.transformContainerNode = function transformContainerNode(_ref2) {
+  var tr = _ref2.tr,
+    sourcePos = _ref2.sourcePos,
+    targetNodeType = _ref2.targetNodeType,
+    targetAttrs = _ref2.targetAttrs;
   if (sourcePos === null) {
     return null;
   }

package/dist/cjs/editor-commands/transforms/inline-node-transforms.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getInlineNodeTextContent = void 0;
+var getInlineNodeTextContent = exports.getInlineNodeTextContent = function getInlineNodeTextContent(sourceContent, tr) {
+  var validTransformedContent = '';
+  var schema = tr.doc.type.schema;
+  if (sourceContent.content.length > 1) {
+    return;
+  }
+  // Headings are not valid inside headings so convert heading nodes to paragraphs
+  sourceContent.forEach(function (node) {
+    if (['paragraph', 'heading'].includes(node.type.name)) {
+      node.content.forEach(function (inlineNode) {
+        if (inlineNode.type.name === 'status') {
+          validTransformedContent += inlineNode.attrs.text;
+        } else {
+          validTransformedContent += "".concat(inlineNode.textContent);
+        }
+      });
+      validTransformedContent;
+    }
+  });
+  return schema.text(validTransformedContent);
+};

package/dist/cjs/editor-commands/transforms/list/transformBetweenListTypes.js

@@ -0,0 +1,102 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.transformListStructure = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+/**
+ * Extract all inline content from a node
+ */
+var extractInlineContent = function extractInlineContent(node) {
+  var inlineContent = [];
+  for (var i = 0; i < node.childCount; i++) {
+    inlineContent.push(node.child(i));
+  }
+  return inlineContent;
+};
+
+/**
+ * Transform list structure
+ */
+var transformListStructure = exports.transformListStructure = function transformListStructure(tr, listNode, targetNodeType, nodes) {
+  try {
+    var sourceList = listNode.node,
+      listPos = listNode.pos;
+    var bulletList = nodes.bulletList,
+      orderedList = nodes.orderedList,
+      taskList = nodes.taskList,
+      listItem = nodes.listItem,
+      taskItem = nodes.taskItem,
+      paragraph = nodes.paragraph;
+    var isSourceBulletOrOrdered = sourceList.type === bulletList || sourceList.type === orderedList;
+    var isTargetTask = targetNodeType === taskList;
+    var isSourceTask = sourceList.type === taskList;
+    var newListItems = [];
+    var listStart = listPos;
+    var listEnd = listPos + sourceList.nodeSize;
+
+    // Use nodesBetween to efficiently traverse the list structure
+    tr.doc.nodesBetween(listStart, listEnd, function (node, pos, parent) {
+      // Only process direct children of the list (depth 1)
+      if (parent !== sourceList) {
+        return true; // Continue traversal
+      }
+      if (isSourceBulletOrOrdered && isTargetTask) {
+        // Converting from bullet/ordered list to task list
+        // Extract inline content from all children within listItem
+        if (node.type === listItem) {
+          var inlineContent = [];
+
+          // Extract all inline content from all child nodes
+          for (var i = 0; i < node.childCount; i++) {
+            var child = node.child(i);
+            if (child.type === paragraph) {
+              // Extract inline content from paragraphs
+              inlineContent.push.apply(inlineContent, (0, _toConsumableArray2.default)(extractInlineContent(child)));
+            } else if (child.isBlock) {
+              // For other block content types eg. codeBlock, extract their text content and create text nodes
+              var textContent = child.textContent;
+              if (textContent) {
+                var textNode = tr.doc.type.schema.text(textContent);
+                inlineContent.push(textNode);
+              }
+            } else {
+              // Already inline content, add directly
+              inlineContent.push(child);
+            }
+          }
+          if (inlineContent.length > 0) {
+            var newItem = taskItem.create(null, inlineContent);
+            newListItems.push(newItem);
+          }
+        }
+      } else if (isSourceTask && !isTargetTask) {
+        // Converting from task list to bullet/ordered list
+        // Structure: taskItem > inline content -> listItem > paragraph > inline content
+        if (node.type === taskItem) {
+          var _inlineContent = extractInlineContent(node);
+          if (_inlineContent.length > 0) {
+            var paragraphNode = paragraph.create(null, _inlineContent);
+            var newListItem = listItem.create(null, paragraphNode);
+            newListItems.push(newListItem);
+          }
+        }
+      }
+      return false; // Don't traverse into children of list items
+    });
+    if (newListItems.length === 0) {
+      return tr;
+    }
+
+    // Create new list with transformed items
+    var newList = targetNodeType.create(null, newListItems);
+
+    // Replace the entire list
+    tr.replaceWith(listStart, listEnd, newList);
+    return tr;
+  } catch (_unused) {
+    return tr;
+  }
+};

package/dist/cjs/editor-commands/transforms/list/transformOrderedUnorderedListToBlockNodes.js

@@ -0,0 +1,54 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.transformOrderedUnorderedListToBlockNodes = void 0;
+var _model = require("@atlaskit/editor-prosemirror/model");
+var _utils = require("@atlaskit/editor-prosemirror/utils");
+var transformOrderedUnorderedListToBlockNodes = exports.transformOrderedUnorderedListToBlockNodes = function transformOrderedUnorderedListToBlockNodes(context) {
+  var tr = context.tr,
+    targetNodeType = context.targetNodeType,
+    targetAttrs = context.targetAttrs,
+    sourceNode = context.sourceNode,
+    sourcePos = context.sourcePos;
+  var selection = tr.selection;
+  var schema = selection.$from.doc.type.schema;
+  // find all paragraph nodes inside the list node
+  var paragraphs = (0, _utils.findChildrenByType)(sourceNode, schema.nodes.paragraph);
+  var paragraphNodes = paragraphs.map(function (paragraph) {
+    return paragraph.node;
+  });
+  var targetNodes = paragraphNodes;
+
+  // Convert paragraphs to headings if target is heading
+  if (targetNodeType === schema.nodes.heading && targetAttrs) {
+    var targetHeadingLevel = targetAttrs.level;
+    targetNodes = paragraphNodes.map(function (paragraphNode) {
+      return schema.nodes.heading.createChecked({
+        level: targetHeadingLevel
+      }, paragraphNode.content);
+    });
+  }
+
+  // Convert paragraphs to code block if target is code block
+  if (targetNodeType === schema.nodes.codeBlock) {
+    // convert the paragraphNodes to one code block
+    var listItemsResult = (0, _utils.findChildrenByType)(sourceNode, schema.nodes.listItem);
+    var listItems = listItemsResult.map(function (item) {
+      return item.node;
+    });
+    var listItemFragments = listItems.map(function (listItem) {
+      return listItem.content;
+    });
+    var codeBlockContent = listItemFragments.map(function (fragment) {
+      return fragment.textBetween(0, fragment.size, '\n');
+    }).join('\n');
+    targetNodes = [schema.nodes.codeBlock.createChecked({}, schema.text(codeBlockContent))];
+  }
+  var fragment = _model.Fragment.fromArray(targetNodes);
+  var slice = new _model.Slice(fragment, 0, 0);
+  var rangeStart = sourcePos !== null ? sourcePos : selection.from;
+  tr.replaceRange(rangeStart, rangeStart + sourceNode.nodeSize, slice);
+  return tr;
+};

package/dist/cjs/editor-commands/transforms/list/transformTaskListToBlockNodes.js

@@ -0,0 +1,59 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.transformTaskListToBlockNodes = void 0;
+var _model = require("@atlaskit/editor-prosemirror/model");
+var _utils = require("@atlaskit/editor-prosemirror/utils");
+var transformTaskListToBlockNodes = exports.transformTaskListToBlockNodes = function transformTaskListToBlockNodes(context) {
+  var tr = context.tr,
+    targetNodeType = context.targetNodeType,
+    targetAttrs = context.targetAttrs,
+    sourceNode = context.sourceNode,
+    sourcePos = context.sourcePos;
+  var selection = tr.selection;
+  var schema = selection.$from.doc.type.schema;
+  var taskItemsResult = (0, _utils.findChildrenByType)(sourceNode, schema.nodes.taskItem);
+  var taskItems = taskItemsResult.map(function (item) {
+    return item.node;
+  });
+  var taskItemFragments = taskItems.map(function (taskItem) {
+    return taskItem.content;
+  });
+  var targetNodes = [];
+
+  // Convert fragments to headings if target is heading
+  if (targetNodeType === schema.nodes.heading && targetAttrs) {
+    // convert the fragments to headings
+    var targetHeadingLevel = targetAttrs.level;
+    targetNodes = taskItemFragments.map(function (fragment) {
+      return schema.nodes.heading.createChecked({
+        level: targetHeadingLevel
+      }, fragment.content);
+    });
+  }
+
+  // Convert fragments to paragraphs if target is paragraphs
+  if (targetNodeType === schema.nodes.paragraph) {
+    // convert the fragments to paragraphs
+    targetNodes = taskItemFragments.map(function (fragment) {
+      return schema.nodes.paragraph.createChecked({}, fragment.content);
+    });
+  }
+
+  // Convert fragments to code block if target is code block
+  if (targetNodeType === schema.nodes.codeBlock) {
+    // convert the fragments to one code block
+    var codeBlockContent = taskItemFragments.map(function (fragment) {
+      return fragment.textBetween(0, fragment.size, '\n');
+    }).join('\n');
+    targetNodes = [schema.nodes.codeBlock.createChecked({}, schema.text(codeBlockContent))];
+  }
+
+  // Replace the task list node with the new content in the transaction
+  var slice = new _model.Slice(_model.Fragment.fromArray(targetNodes), 0, 0);
+  var rangeStart = sourcePos !== null ? sourcePos : selection.from;
+  tr.replaceRange(rangeStart, rangeStart + sourceNode.nodeSize, slice);
+  return tr;
+};

package/dist/cjs/editor-commands/transforms/list-transforms.js

@@ -3,18 +3,20 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.transformToList = exports.transformListNode = exports.transformBetweenListTypes = exports.liftListToBlockType = void 0;
+exports.transformListToBlockNodes = exports.transformListNode = exports.transformBlockToList = exports.transformBetweenListTypes = exports.liftListToBlockType = void 0;
 var _transform = require("@atlaskit/editor-prosemirror/transform");
 var _utils = require("@atlaskit/editor-prosemirror/utils");
+var _transformBetweenListTypes = require("./list/transformBetweenListTypes");
+var _transformOrderedUnorderedListToBlockNodes = require("./list/transformOrderedUnorderedListToBlockNodes");
+var _transformTaskListToBlockNodes = require("./list/transformTaskListToBlockNodes");
 var _utils2 = require("./utils");
 /**
  * Transform selection to list type
  */
-var transformToList = exports.transformToList = function transformToList(_ref) {
-  var tr = _ref.tr,
-    targetNodeType = _ref.targetNodeType,
-    targetAttrs = _ref.targetAttrs;
-  // Wrap selection in list of target type
+var transformBlockToList = exports.transformBlockToList = function transformBlockToList(context) {
+  var tr = context.tr,
+    targetNodeType = context.targetNodeType,
+    targetAttrs = context.targetAttrs;
   var _tr$selection = tr.selection,
     $from = _tr$selection.$from,
     $to = _tr$selection.$to;
@@ -22,16 +24,45 @@ var transformToList = exports.transformToList = function transformToList(_ref) {
   if (!range) {
     return null;
   }
+  var nodes = tr.doc.type.schema.nodes;
+  var isTargetTask = targetNodeType === nodes.taskList;
+
+  // Handle task lists differently due to their structure
+  // TODO: ED-29152 - Implement task list transformation
+  if (isTargetTask) {
+    return null;
+  }
 
-  // Find if we can wrap the selection in the target list type
-  var wrapping = (0, _transform.findWrapping)(range, targetNodeType, targetAttrs);
+  // For headings, convert to paragraph first since headings cannot be direct children of list items
+  var sourceNode = tr.doc.nodeAt(range.start);
+  if (sourceNode && sourceNode.type.name.startsWith('heading')) {
+    tr.setBlockType(range.start, range.end, nodes.paragraph);
+  }
+
+  // Get the current range (updated if we converted from heading)
+  var currentRange = tr.selection.$from.blockRange(tr.selection.$to) || range;
+
+  // Wrap in the target list type
+  var wrapping = (0, _transform.findWrapping)(currentRange, targetNodeType, targetAttrs);
   if (!wrapping) {
     return null;
   }
-  tr.wrap(range, wrapping);
+  tr.wrap(currentRange, wrapping);
   return tr;
 };
 
+/**
+ * Transform list to block nodes
+ */
+var transformListToBlockNodes = exports.transformListToBlockNodes = function transformListToBlockNodes(context) {
+  var sourceNode = context.sourceNode;
+  if (sourceNode.type.name === 'taskList') {
+    return (0, _transformTaskListToBlockNodes.transformTaskListToBlockNodes)(context);
+  } else {
+    return (0, _transformOrderedUnorderedListToBlockNodes.transformOrderedUnorderedListToBlockNodes)(context);
+  }
+};
+
 /**
  * Transform list nodes
  */
@@ -40,7 +71,7 @@ var transformListNode = exports.transformListNode = function transformListNode(c
   // Transform list to block type
   if ((0, _utils2.isBlockNodeType)(targetNodeType)) {
     // Lift list items out of the list and convert to target block type
-    return null;
+    return transformListToBlockNodes(context);
   }
 
   // Transform list to container type
@@ -67,22 +98,37 @@ var liftListToBlockType = exports.liftListToBlockType = function liftListToBlock
 /**
  * Transform between different list types
  */
-var transformBetweenListTypes = exports.transformBetweenListTypes = function transformBetweenListTypes(_ref2) {
-  var tr = _ref2.tr,
-    targetNodeType = _ref2.targetNodeType;
-  var selection = tr.selection;
+var transformBetweenListTypes = exports.transformBetweenListTypes = function transformBetweenListTypes(_ref) {
+  var tr = _ref.tr,
+    targetNodeType = _ref.targetNodeType;
+  var _tr = tr,
+    selection = _tr.selection;
   var nodes = tr.doc.type.schema.nodes;
 
-  // Find the list node
-  var listNode = (0, _utils.findParentNodeOfType)([nodes.bulletList, nodes.orderedList, nodes.taskList])(selection);
+  // Find the list node - support bullet lists, ordered lists, and task lists
+  var supportedListTypes = [nodes.bulletList, nodes.orderedList, nodes.taskList].filter(Boolean); // Filter out undefined nodes in case some schemas don't have all types
+
+  var listNode = (0, _utils.findParentNodeOfType)(supportedListTypes)(selection);
   if (!listNode) {
     return null;
   }
+  var sourceListType = listNode.node.type;
+  var isSourceBulletOrOrdered = sourceListType === nodes.bulletList || sourceListType === nodes.orderedList;
+  var isTargetTask = targetNodeType === nodes.taskList;
+  var isSourceTask = sourceListType === nodes.taskList;
+  var isTargetBulletOrOrdered = targetNodeType === nodes.bulletList || targetNodeType === nodes.orderedList;
+
+  // Check if we need structure transformation
+  var needsStructureTransform = isSourceBulletOrOrdered && isTargetTask || isSourceTask && isTargetBulletOrOrdered;
   try {
-    // Change the list type while preserving content
-    tr.setNodeMarkup(listNode.pos, targetNodeType);
-    return tr;
-  } catch (e) {
+    if (!needsStructureTransform) {
+      // Simple type change for same structure lists (bullet <-> ordered)
+      tr.setNodeMarkup(listNode.pos, targetNodeType);
+    } else {
+      tr = (0, _transformBetweenListTypes.transformListStructure)(tr, listNode, targetNodeType, nodes);
+    }
+  } catch (_unused) {
     return null;
   }
+  return tr;
 };

package/dist/cjs/ui/block-menu-components.js

@@ -11,7 +11,6 @@ var _blockMenu = require("@atlaskit/editor-common/block-menu");
 var _editorToolbar = require("@atlaskit/editor-toolbar");
 var _changes = _interopRequireDefault(require("@atlaskit/icon/core/changes"));
 var _chevronRight = _interopRequireDefault(require("@atlaskit/icon/core/chevron-right"));
-var _platformFeatureFlags = require("@atlaskit/platform-feature-flags");
 var _copyBlock = _interopRequireDefault(require("./copy-block"));
 var _copyLink = require("./copy-link");
 var _deleteButton = require("./delete-button");
@@ -98,7 +97,7 @@ var getFormatMenuComponents = function getFormatMenuComponents() {
 var getBlockMenuComponents = exports.getBlockMenuComponents = function getBlockMenuComponents(_ref4) {
   var api = _ref4.api,
     config = _ref4.config;
-  return [].concat((0, _toConsumableArray2.default)((0, _platformFeatureFlags.fg)('platform_editor_block_menu_format') ? getFormatMenuComponents() : []), [{
+  return [].concat((0, _toConsumableArray2.default)(getFormatMenuComponents()), [{
     type: 'block-menu-section',
     key: _blockMenu.COPY_MENU_SECTION.key,
     rank: _blockMenu.BLOCK_MENU_SECTION_RANK[_blockMenu.COPY_MENU_SECTION.key],

package/dist/cjs/ui/block-menu.compiled.css

@@ -1,3 +1,3 @@
 
-._2rkoglpi{border-radius:var(--ds-border-radius,4px)}._16qs1cd0{box-shadow:var(--ds-shadow-overlay,0 8px 9pt #091e4226,0 0 1px #091e424f)}
+._2rko12b0{border-radius:var(--ds-radius-small,4px)}._16qs1cd0{box-shadow:var(--ds-shadow-overlay,0 8px 9pt #091e4226,0 0 1px #091e424f)}
 ._bfhk1bhr{background-color:var(--ds-surface-overlay,#fff)}

package/dist/cjs/ui/block-menu.js

@@ -21,7 +21,7 @@ var _compiled = require("@atlaskit/primitives/compiled");
 var _blockMenuRenderer = require("./block-menu-renderer");
 function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != _typeof(e) && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
 var styles = {
-  base: "_2rkoglpi _bfhk1bhr _16qs1cd0"
+  base: "_2rko12b0 _bfhk1bhr _16qs1cd0"
 };
 var DEFAULT_MENU_WIDTH = 230;
 var DRAG_HANDLE_OFFSET_PADDING = 5;

package/dist/es2019/editor-commands/formatNode.js

@@ -26,19 +26,22 @@ export const formatNode = targetType => {
       nodePos = selectedNode.pos;
     } else {
       // Try to find parent node (including list parents)
-      const parentNode = findParentNodeOfType([nodes.blockquote, nodes.panel, nodes.expand, nodes.codeBlock, nodes.listItem, nodes.layoutSection])(selection);
+      const parentNode = findParentNodeOfType([nodes.blockquote, nodes.panel, nodes.expand, nodes.codeBlock, nodes.listItem, nodes.taskItem, nodes.layoutSection])(selection);
       if (parentNode) {
         nodeToFormat = parentNode.node;
         nodePos = parentNode.pos;
-
+        const paragraphOrHeadingNode = findParentNodeOfType([nodes.paragraph, nodes.heading])(selection);
         // Special case: if we found a listItem, check if we need the parent list instead
-        if (parentNode.node.type === nodes.listItem) {
+        if (parentNode.node.type === nodes.listItem || parentNode.node.type === nodes.taskItem) {
           const listParent = findParentNodeOfType([nodes.bulletList, nodes.orderedList, nodes.taskList])(selection);
           if (listParent) {
             // For list transformations, we want the list parent, not the listItem
             nodeToFormat = listParent.node;
             nodePos = listParent.pos;
           }
+        } else if (paragraphOrHeadingNode) {
+          nodeToFormat = paragraphOrHeadingNode.node;
+          nodePos = paragraphOrHeadingNode.pos;
         }
       }
     }