@atlaskit/editor-plugin-block-menu 5.2.8 → 5.2.9

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # @atlaskit/editor-plugin-block-menu
 
+## 5.2.9
+
+### Patch Changes
+
+- [`3d03e8b001dab`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/3d03e8b001dab) -
+  Add logic to handle unsupported content for list to task/decision list
+- [`b831109342cdf`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/b831109342cdf) -
+  EDITOR-3880 Register block menu selection extensions statically
+
 ## 5.2.8
 
 ### Patch Changes

package/dist/cjs/editor-actions/index.js

@@ -1,9 +1,11 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createBlockMenuRegistry = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 /**
  * Create a simple registry for block menu components.
  *
@@ -54,19 +56,7 @@ exports.createBlockMenuRegistry = void 0;
 var createBlockMenuRegistry = exports.createBlockMenuRegistry = function createBlockMenuRegistry() {
   var components = [];
   var register = function register(blockMenuComponents) {
-    blockMenuComponents.forEach(function (newComponent) {
-      // Find if a component with the same key already exists
-      var existingIndex = components.findIndex(function (comp) {
-        return comp.key === newComponent.key;
-      });
-      if (existingIndex !== -1) {
-        // Replace the existing component
-        components[existingIndex] = newComponent;
-      } else {
-        // Add new component
-        components.push(newComponent);
-      }
-    });
+    components.push.apply(components, (0, _toConsumableArray2.default)(blockMenuComponents));
   };
   return {
     register: register,

package/dist/cjs/editor-commands/transform-node-utils/steps/listToDecisionListStep.js

@@ -1,10 +1,11 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.listToDecisionListStep = void 0;
-var _model = require("@atlaskit/editor-prosemirror/model");
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 var _utils = require("../utils");
 /**
  * Transforms a bulletList, orderedList, or taskList into a decisionList.
@@ -32,7 +33,8 @@ var _utils = require("../utils");
 var listToDecisionListStep = exports.listToDecisionListStep = function listToDecisionListStep(nodes, context) {
   var schema = context.schema;
   var paragraphType = schema.nodes.paragraph;
-  return nodes.map(function (node) {
+  var unsupportedContent = [];
+  var transformedNodes = nodes.map(function (node) {
     if (!(0, _utils.isListType)(node, schema)) {
       return node;
     }
@@ -42,20 +44,18 @@ var listToDecisionListStep = exports.listToDecisionListStep = function listToDec
       item.forEach(function (child) {
         if (child.type === paragraphType) {
           // paragraph may contain hard breaks etc.
-          child.content.forEach(function (inline) {
-            itemContent.push(inline);
-          });
-        } else {
+          itemContent.push.apply(itemContent, (0, _toConsumableArray2.default)(child.children));
+        } else if (child.isText) {
           itemContent.push(child);
+        } else if (!(0, _utils.isListType)(child, schema)) {
+          unsupportedContent.push(child);
         }
-        // TODO: EDITOR-3887 - Skip mediaSingle, codeBlock, and nested lists
       });
-      var decisionItem = schema.nodes.decisionItem.create({}, _model.Fragment.from(itemContent));
-      if (decisionItem) {
-        decisionItems.push(decisionItem);
-      }
+      var decisionItem = schema.nodes.decisionItem.create({}, itemContent);
+      decisionItems.push(decisionItem);
     });
-    var decisionList = schema.nodes.decisionList.create({}, _model.Fragment.from(decisionItems));
+    var decisionList = schema.nodes.decisionList.create({}, decisionItems);
     return decisionList || node;
   });
+  return [].concat((0, _toConsumableArray2.default)(transformedNodes), unsupportedContent);
 };

package/dist/cjs/editor-commands/transform-node-utils/steps/listToListStep.js

@@ -1,153 +1,128 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.listToListStep = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 var _model = require("@atlaskit/editor-prosemirror/model");
 var _utils = require("../utils");
 /**
- * Converts FROM taskList structure TO bulletList/orderedList structure.
- */
-var convertFromTaskListStructure = function convertFromTaskListStructure(node, targetListType, targetItemType) {
-  var schema = node.type.schema;
-  var targetListNodeType = schema.nodes[targetListType];
-  var convertedItems = [];
-  node.content.forEach(function (child) {
-    if ((0, _utils.isListType)(child, schema)) {
-      // This is a nested list - it should become a child of the previous item
-      if (convertedItems.length > 0) {
-        var previousItem = convertedItems[convertedItems.length - 1];
-        // Convert the nested list and add it to the previous item's content
-        var convertedNestedList = _transformList(child, targetListType, targetItemType);
-        var newContent = previousItem.content.append(_model.Fragment.from([convertedNestedList]));
-        var updatedItem = previousItem.type.create(previousItem.attrs, newContent);
-        convertedItems[convertedItems.length - 1] = updatedItem;
-      }
-      // If there's no previous item, skip this nested list (orphaned)
-    } else {
-      var convertedItem = transformListItem(child, targetItemType, targetListType);
-      if (convertedItem) {
-        convertedItems.push(convertedItem);
-      }
-    }
-  });
-  return targetListNodeType.create(node.attrs, _model.Fragment.from(convertedItems));
-};
-
-/**
- * Converts FROM bulletList/orderedList structure TO taskList structure.
+ * Recursively converts nested lists to the target list type.
+ * This function handles the conversion of both the list container and its items,
+ * including any nested lists within those items.
+ *
+ * Important: taskList has a different nesting structure than bulletList/orderedList:
+ * - taskList: nested taskLists are SIBLINGS of taskItems in the parent taskList
+ * - bulletList/orderedList: nested lists are CHILDREN of listItems
  */
-var convertToTaskListStructure = function convertToTaskListStructure(node, targetListType, targetItemType) {
+var _transformList = function transformList(node, targetListType, targetItemType, unsupportedContent) {
   var schema = node.type.schema;
-  var targetListNodeType = schema.nodes[targetListType];
-  var transformedContent = [];
-  node.content.forEach(function (itemNode) {
-    var transformedItem = transformListItem(itemNode, targetItemType, targetListType, true);
-    if (transformedItem) {
-      transformedContent.push(transformedItem);
-    }
-    itemNode.content.forEach(function (child) {
+  var taskListType = schema.nodes.taskList;
+  var isSourceTaskList = node.type === taskListType;
+  var isTargetTaskList = targetListType === 'taskList';
+  var convertFromTaskListStructure = function convertFromTaskListStructure(node, targetListType, targetItemType) {
+    var schema = node.type.schema;
+    var targetListNodeType = schema.nodes[targetListType];
+    var transformedContent = [];
+    node.forEach(function (child) {
       if ((0, _utils.isListType)(child, schema)) {
-        var transformedNestedList = _transformList(child, targetListType, targetItemType);
-        transformedContent.push(transformedNestedList);
+        // This is a nested list - it should become a child of the previous item
+        if (transformedContent.length > 0) {
+          var previousItem = transformedContent[transformedContent.length - 1];
+          // Convert the nested list and add it to the previous item's content
+          var transformedNestedList = _transformList(child, targetListType, targetItemType, unsupportedContent);
+          var newContent = previousItem.content.append(_model.Fragment.from([transformedNestedList]));
+          var updatedItem = previousItem.type.create(previousItem.attrs, newContent);
+          transformedContent[transformedContent.length - 1] = updatedItem;
+        }
+        // If there's no previous item, skip this nested list (orphaned)
+      } else {
+        var transformedItem = transformListItem(child, targetItemType, targetListType);
+        if (transformedItem) {
+          transformedContent.push(transformedItem);
+        }
       }
     });
-  });
-  return targetListNodeType.create(node.attrs, _model.Fragment.from(transformedContent));
-};
-
-/**
- * Converts a single list item (listItem or taskItem) to the target item type.
- * Handles content transformation based on the target type's requirements.
- * @param itemNode - The list item node to convert
- * @param targetItemType - The target item type (listItem or taskItem)
- * @param targetListType - The target list type (bulletList, orderedList, or taskList)
- * @param excludeNestedLists - When true, nested lists are excluded from the item's content
- *                             (used when converting to taskList where nested lists become siblings)
- */
-var transformListItem = function transformListItem(itemNode, targetItemType, targetListType) {
-  var excludeNestedLists = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
-  var schema = itemNode.type.schema;
-  var targetItemNodeType = schema.nodes[targetItemType];
-  var isTargetTaskItem = targetItemType === 'taskItem';
-  var isSourceTaskItem = itemNode.type.name === 'taskItem';
-  var paragraphType = schema.nodes.paragraph;
-  if (!targetItemNodeType) {
-    return null;
-  }
-  if (isTargetTaskItem) {
-    var inlineContent = [];
-    itemNode.content.forEach(function (child) {
-      if (child.type === paragraphType) {
-        child.content.forEach(function (inline) {
-          inlineContent.push(inline);
-        });
-      }
-      if (child.isText) {
-        inlineContent.push(child);
+    return targetListNodeType.create(node.attrs, transformedContent);
+  };
+  var convertToTaskListStructure = function convertToTaskListStructure(node, targetListType, targetItemType) {
+    var schema = node.type.schema;
+    var targetListNodeType = schema.nodes[targetListType];
+    var transformedContent = [];
+    node.forEach(function (itemNode) {
+      var transformedItem = transformListItem(itemNode, targetItemType, targetListType, true);
+      if (transformedItem) {
+        transformedContent.push(transformedItem);
       }
-      // TODO: EDITOR-3887 - Skip mediaSingle, codeBlock, and nested lists
-      // Nested lists will be extracted and placed as siblings in the taskList
+      itemNode.forEach(function (child) {
+        if ((0, _utils.isListType)(child, schema)) {
+          transformedContent.push(_transformList(child, targetListType, targetItemType, unsupportedContent));
+        }
+      });
     });
-    return targetItemNodeType.create({}, _model.Fragment.from(inlineContent));
-  } else {
-    var newContent = [];
+    return targetListNodeType.create(node.attrs, transformedContent);
+  };
+  var transformListItem = function transformListItem(itemNode, targetItemType, targetListType) {
+    var excludeNestedLists = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+    var schema = itemNode.type.schema;
+    var targetItemNodeType = schema.nodes[targetItemType];
+    var isTargetTaskItem = targetItemType === 'taskItem';
+    var isSourceTaskItem = itemNode.type.name === 'taskItem';
+    var paragraphType = schema.nodes.paragraph;
+    if (isTargetTaskItem) {
+      var inlineContent = [];
+      itemNode.forEach(function (child) {
+        if (child.type === paragraphType) {
+          inlineContent.push.apply(inlineContent, (0, _toConsumableArray2.default)(child.children));
+        } else if (child.isText) {
+          inlineContent.push(child);
+          // Nested lists will be extracted and placed as siblings in the taskList
+        } else if (!(0, _utils.isListType)(child, schema)) {
+          unsupportedContent.push(child);
+        }
+      });
+      return targetItemNodeType.create({}, inlineContent);
+    }
+    var transformedContent = [];
     if (isSourceTaskItem) {
-      newContent.push(paragraphType.create(null, itemNode.content));
+      transformedContent.push(paragraphType.create(null, itemNode.content));
     } else {
-      itemNode.content.forEach(function (child) {
+      itemNode.forEach(function (child) {
         if ((0, _utils.isListType)(child, schema)) {
           if (excludeNestedLists) {
             // Skip nested lists - they will be handled separately as siblings
             return;
           }
-          newContent.push(_transformList(child, targetListType, targetItemType));
+          transformedContent.push(_transformList(child, targetListType, targetItemType, unsupportedContent));
         } else {
-          newContent.push(child);
+          transformedContent.push(child);
         }
       });
     }
-    if (newContent.length === 0) {
-      newContent.push(paragraphType.create());
+    if (transformedContent.length === 0) {
+      transformedContent.push(paragraphType.create());
     }
-    return targetItemNodeType.create({}, _model.Fragment.from(newContent));
-  }
-};
-
-/**
- * Recursively converts nested lists to the target list type.
- * This function handles the conversion of both the list container and its items,
- * including any nested lists within those items.
- *
- * Important: taskList has a different nesting structure than bulletList/orderedList:
- * - taskList: nested taskLists are SIBLINGS of taskItems in the parent taskList
- * - bulletList/orderedList: nested lists are CHILDREN of listItems
- */
-var _transformList = function transformList(node, targetListType, targetItemType) {
-  var schema = node.type.schema;
-  var targetListNodeType = schema.nodes[targetListType];
-  var targetItemNodeType = schema.nodes[targetItemType];
-  var taskListType = schema.nodes.taskList;
-  if (!targetListNodeType || !targetItemNodeType) {
-    return node;
-  }
-  var isSourceTaskList = node.type === taskListType;
-  var isTargetTaskList = targetListType === 'taskList';
+    return targetItemNodeType.create({}, transformedContent);
+  };
+  var convertList = function convertList(node, schema, targetListType, targetItemType) {
+    var targetListNodeType = schema.nodes[targetListType];
+    var transformedContent = [];
+    node.forEach(function (childNode) {
+      var transformedItem = (0, _utils.isListType)(childNode, schema) ? _transformList(childNode, targetListType, targetItemType, unsupportedContent) : transformListItem(childNode, targetItemType, targetListType);
+      if (transformedItem) {
+        transformedContent.push(transformedItem);
+      }
+    });
+    return targetListNodeType.create(node.attrs, transformedContent);
+  };
   if (isSourceTaskList && !isTargetTaskList) {
     return convertFromTaskListStructure(node, targetListType, targetItemType);
   } else if (!isSourceTaskList && isTargetTaskList) {
     return convertToTaskListStructure(node, targetListType, targetItemType);
-  } else {
-    var transformedItems = [];
-    node.content.forEach(function (childNode) {
-      var transformedItem = (0, _utils.isListType)(childNode, schema) ? _transformList(childNode, targetListType, targetItemType) : transformListItem(childNode, targetItemType, targetListType);
-      if (transformedItem) {
-        transformedItems.push(transformedItem);
-      }
-    });
-    return targetListNodeType.create(node.attrs, _model.Fragment.from(transformedItems));
   }
+  return convertList(node, schema, targetListType, targetItemType);
 };
 
 /**
@@ -216,11 +191,13 @@ var _transformList = function transformList(node, targetListType, targetItemType
 var listToListStep = exports.listToListStep = function listToListStep(nodes, context) {
   var schema = context.schema,
     targetNodeTypeName = context.targetNodeTypeName;
-  return nodes.map(function (node) {
+  var unsupportedContent = [];
+  var transformedNodes = nodes.map(function (node) {
     if ((0, _utils.isListType)(node, schema)) {
       var targetItemType = targetNodeTypeName === 'taskList' ? 'taskItem' : 'listItem';
-      return _transformList(node, targetNodeTypeName, targetItemType);
+      return _transformList(node, targetNodeTypeName, targetItemType, unsupportedContent);
     }
     return node;
   });
+  return [].concat((0, _toConsumableArray2.default)(transformedNodes), unsupportedContent);
 };

package/dist/es2019/editor-actions/index.js

@@ -48,17 +48,7 @@
 export const createBlockMenuRegistry = () => {
   const components = [];
   const register = blockMenuComponents => {
-    blockMenuComponents.forEach(newComponent => {
-      // Find if a component with the same key already exists
-      const existingIndex = components.findIndex(comp => comp.key === newComponent.key);
-      if (existingIndex !== -1) {
-        // Replace the existing component
-        components[existingIndex] = newComponent;
-      } else {
-        // Add new component
-        components.push(newComponent);
-      }
-    });
+    components.push(...blockMenuComponents);
   };
   return {
     register,

package/dist/es2019/editor-commands/transform-node-utils/steps/listToDecisionListStep.js

@@ -1,4 +1,3 @@
-import { Fragment } from '@atlaskit/editor-prosemirror/model';
 import { isListType } from '../utils';
 
 /**
@@ -29,7 +28,8 @@ export const listToDecisionListStep = (nodes, context) => {
     schema
   } = context;
   const paragraphType = schema.nodes.paragraph;
-  return nodes.map(node => {
+  const unsupportedContent = [];
+  const transformedNodes = nodes.map(node => {
     if (!isListType(node, schema)) {
       return node;
     }
@@ -39,20 +39,18 @@ export const listToDecisionListStep = (nodes, context) => {
       item.forEach(child => {
         if (child.type === paragraphType) {
           // paragraph may contain hard breaks etc.
-          child.content.forEach(inline => {
-            itemContent.push(inline);
-          });
-        } else {
+          itemContent.push(...child.children);
+        } else if (child.isText) {
           itemContent.push(child);
+        } else if (!isListType(child, schema)) {
+          unsupportedContent.push(child);
         }
-        // TODO: EDITOR-3887 - Skip mediaSingle, codeBlock, and nested lists
       });
-      const decisionItem = schema.nodes.decisionItem.create({}, Fragment.from(itemContent));
-      if (decisionItem) {
-        decisionItems.push(decisionItem);
-      }
+      const decisionItem = schema.nodes.decisionItem.create({}, itemContent);
+      decisionItems.push(decisionItem);
     });
-    const decisionList = schema.nodes.decisionList.create({}, Fragment.from(decisionItems));
+    const decisionList = schema.nodes.decisionList.create({}, decisionItems);
     return decisionList || node;
   });
+  return [...transformedNodes, ...unsupportedContent];
 };

package/dist/es2019/editor-commands/transform-node-utils/steps/listToListStep.js

@@ -2,146 +2,119 @@ import { Fragment } from '@atlaskit/editor-prosemirror/model';
 import { isListType } from '../utils';
 
 /**
- * Converts FROM taskList structure TO bulletList/orderedList structure.
- */
-const convertFromTaskListStructure = (node, targetListType, targetItemType) => {
-  const schema = node.type.schema;
-  const targetListNodeType = schema.nodes[targetListType];
-  const convertedItems = [];
-  node.content.forEach(child => {
-    if (isListType(child, schema)) {
-      // This is a nested list - it should become a child of the previous item
-      if (convertedItems.length > 0) {
-        const previousItem = convertedItems[convertedItems.length - 1];
-        // Convert the nested list and add it to the previous item's content
-        const convertedNestedList = transformList(child, targetListType, targetItemType);
-        const newContent = previousItem.content.append(Fragment.from([convertedNestedList]));
-        const updatedItem = previousItem.type.create(previousItem.attrs, newContent);
-        convertedItems[convertedItems.length - 1] = updatedItem;
-      }
-      // If there's no previous item, skip this nested list (orphaned)
-    } else {
-      const convertedItem = transformListItem(child, targetItemType, targetListType);
-      if (convertedItem) {
-        convertedItems.push(convertedItem);
-      }
-    }
-  });
-  return targetListNodeType.create(node.attrs, Fragment.from(convertedItems));
-};
-
-/**
- * Converts FROM bulletList/orderedList structure TO taskList structure.
+ * Recursively converts nested lists to the target list type.
+ * This function handles the conversion of both the list container and its items,
+ * including any nested lists within those items.
+ *
+ * Important: taskList has a different nesting structure than bulletList/orderedList:
+ * - taskList: nested taskLists are SIBLINGS of taskItems in the parent taskList
+ * - bulletList/orderedList: nested lists are CHILDREN of listItems
  */
-const convertToTaskListStructure = (node, targetListType, targetItemType) => {
+const transformList = (node, targetListType, targetItemType, unsupportedContent) => {
   const schema = node.type.schema;
-  const targetListNodeType = schema.nodes[targetListType];
-  const transformedContent = [];
-  node.content.forEach(itemNode => {
-    const transformedItem = transformListItem(itemNode, targetItemType, targetListType, true);
-    if (transformedItem) {
-      transformedContent.push(transformedItem);
-    }
-    itemNode.content.forEach(child => {
+  const taskListType = schema.nodes.taskList;
+  const isSourceTaskList = node.type === taskListType;
+  const isTargetTaskList = targetListType === 'taskList';
+  const convertFromTaskListStructure = (node, targetListType, targetItemType) => {
+    const schema = node.type.schema;
+    const targetListNodeType = schema.nodes[targetListType];
+    const transformedContent = [];
+    node.forEach(child => {
       if (isListType(child, schema)) {
-        const transformedNestedList = transformList(child, targetListType, targetItemType);
-        transformedContent.push(transformedNestedList);
+        // This is a nested list - it should become a child of the previous item
+        if (transformedContent.length > 0) {
+          const previousItem = transformedContent[transformedContent.length - 1];
+          // Convert the nested list and add it to the previous item's content
+          const transformedNestedList = transformList(child, targetListType, targetItemType, unsupportedContent);
+          const newContent = previousItem.content.append(Fragment.from([transformedNestedList]));
+          const updatedItem = previousItem.type.create(previousItem.attrs, newContent);
+          transformedContent[transformedContent.length - 1] = updatedItem;
+        }
+        // If there's no previous item, skip this nested list (orphaned)
+      } else {
+        const transformedItem = transformListItem(child, targetItemType, targetListType);
+        if (transformedItem) {
+          transformedContent.push(transformedItem);
+        }
       }
     });
-  });
-  return targetListNodeType.create(node.attrs, Fragment.from(transformedContent));
-};
-
-/**
- * Converts a single list item (listItem or taskItem) to the target item type.
- * Handles content transformation based on the target type's requirements.
- * @param itemNode - The list item node to convert
- * @param targetItemType - The target item type (listItem or taskItem)
- * @param targetListType - The target list type (bulletList, orderedList, or taskList)
- * @param excludeNestedLists - When true, nested lists are excluded from the item's content
- *                             (used when converting to taskList where nested lists become siblings)
- */
-const transformListItem = (itemNode, targetItemType, targetListType, excludeNestedLists = false) => {
-  const schema = itemNode.type.schema;
-  const targetItemNodeType = schema.nodes[targetItemType];
-  const isTargetTaskItem = targetItemType === 'taskItem';
-  const isSourceTaskItem = itemNode.type.name === 'taskItem';
-  const paragraphType = schema.nodes.paragraph;
-  if (!targetItemNodeType) {
-    return null;
-  }
-  if (isTargetTaskItem) {
-    const inlineContent = [];
-    itemNode.content.forEach(child => {
-      if (child.type === paragraphType) {
-        child.content.forEach(inline => {
-          inlineContent.push(inline);
-        });
-      }
-      if (child.isText) {
-        inlineContent.push(child);
+    return targetListNodeType.create(node.attrs, transformedContent);
+  };
+  const convertToTaskListStructure = (node, targetListType, targetItemType) => {
+    const schema = node.type.schema;
+    const targetListNodeType = schema.nodes[targetListType];
+    const transformedContent = [];
+    node.forEach(itemNode => {
+      const transformedItem = transformListItem(itemNode, targetItemType, targetListType, true);
+      if (transformedItem) {
+        transformedContent.push(transformedItem);
       }
-      // TODO: EDITOR-3887 - Skip mediaSingle, codeBlock, and nested lists
-      // Nested lists will be extracted and placed as siblings in the taskList
+      itemNode.forEach(child => {
+        if (isListType(child, schema)) {
+          transformedContent.push(transformList(child, targetListType, targetItemType, unsupportedContent));
+        }
+      });
     });
-    return targetItemNodeType.create({}, Fragment.from(inlineContent));
-  } else {
-    const newContent = [];
+    return targetListNodeType.create(node.attrs, transformedContent);
+  };
+  const transformListItem = (itemNode, targetItemType, targetListType, excludeNestedLists = false) => {
+    const schema = itemNode.type.schema;
+    const targetItemNodeType = schema.nodes[targetItemType];
+    const isTargetTaskItem = targetItemType === 'taskItem';
+    const isSourceTaskItem = itemNode.type.name === 'taskItem';
+    const paragraphType = schema.nodes.paragraph;
+    if (isTargetTaskItem) {
+      const inlineContent = [];
+      itemNode.forEach(child => {
+        if (child.type === paragraphType) {
+          inlineContent.push(...child.children);
+        } else if (child.isText) {
+          inlineContent.push(child);
+          // Nested lists will be extracted and placed as siblings in the taskList
+        } else if (!isListType(child, schema)) {
+          unsupportedContent.push(child);
+        }
+      });
+      return targetItemNodeType.create({}, inlineContent);
+    }
+    const transformedContent = [];
     if (isSourceTaskItem) {
-      newContent.push(paragraphType.create(null, itemNode.content));
+      transformedContent.push(paragraphType.create(null, itemNode.content));
     } else {
-      itemNode.content.forEach(child => {
+      itemNode.forEach(child => {
         if (isListType(child, schema)) {
           if (excludeNestedLists) {
             // Skip nested lists - they will be handled separately as siblings
             return;
           }
-          newContent.push(transformList(child, targetListType, targetItemType));
+          transformedContent.push(transformList(child, targetListType, targetItemType, unsupportedContent));
         } else {
-          newContent.push(child);
+          transformedContent.push(child);
         }
       });
     }
-    if (newContent.length === 0) {
-      newContent.push(paragraphType.create());
+    if (transformedContent.length === 0) {
+      transformedContent.push(paragraphType.create());
     }
-    return targetItemNodeType.create({}, Fragment.from(newContent));
-  }
-};
-
-/**
- * Recursively converts nested lists to the target list type.
- * This function handles the conversion of both the list container and its items,
- * including any nested lists within those items.
- *
- * Important: taskList has a different nesting structure than bulletList/orderedList:
- * - taskList: nested taskLists are SIBLINGS of taskItems in the parent taskList
- * - bulletList/orderedList: nested lists are CHILDREN of listItems
- */
-const transformList = (node, targetListType, targetItemType) => {
-  const schema = node.type.schema;
-  const targetListNodeType = schema.nodes[targetListType];
-  const targetItemNodeType = schema.nodes[targetItemType];
-  const taskListType = schema.nodes.taskList;
-  if (!targetListNodeType || !targetItemNodeType) {
-    return node;
-  }
-  const isSourceTaskList = node.type === taskListType;
-  const isTargetTaskList = targetListType === 'taskList';
+    return targetItemNodeType.create({}, transformedContent);
+  };
+  const convertList = (node, schema, targetListType, targetItemType) => {
+    const targetListNodeType = schema.nodes[targetListType];
+    const transformedContent = [];
+    node.forEach(childNode => {
+      const transformedItem = isListType(childNode, schema) ? transformList(childNode, targetListType, targetItemType, unsupportedContent) : transformListItem(childNode, targetItemType, targetListType);
+      if (transformedItem) {
+        transformedContent.push(transformedItem);
+      }
+    });
+    return targetListNodeType.create(node.attrs, transformedContent);
+  };
   if (isSourceTaskList && !isTargetTaskList) {
     return convertFromTaskListStructure(node, targetListType, targetItemType);
   } else if (!isSourceTaskList && isTargetTaskList) {
     return convertToTaskListStructure(node, targetListType, targetItemType);
-  } else {
-    const transformedItems = [];
-    node.content.forEach(childNode => {
-      const transformedItem = isListType(childNode, schema) ? transformList(childNode, targetListType, targetItemType) : transformListItem(childNode, targetItemType, targetListType);
-      if (transformedItem) {
-        transformedItems.push(transformedItem);
-      }
-    });
-    return targetListNodeType.create(node.attrs, Fragment.from(transformedItems));
   }
+  return convertList(node, schema, targetListType, targetItemType);
 };
 
 /**
@@ -212,11 +185,13 @@ export const listToListStep = (nodes, context) => {
     schema,
     targetNodeTypeName
   } = context;
-  return nodes.map(node => {
+  const unsupportedContent = [];
+  const transformedNodes = nodes.map(node => {
     if (isListType(node, schema)) {
       const targetItemType = targetNodeTypeName === 'taskList' ? 'taskItem' : 'listItem';
-      return transformList(node, targetNodeTypeName, targetItemType);
+      return transformList(node, targetNodeTypeName, targetItemType, unsupportedContent);
     }
     return node;
   });
+  return [...transformedNodes, ...unsupportedContent];
 };

package/dist/esm/editor-actions/index.js

@@ -1,3 +1,4 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
 /**
  * Create a simple registry for block menu components.
  *
@@ -48,19 +49,7 @@
 export var createBlockMenuRegistry = function createBlockMenuRegistry() {
   var components = [];
   var register = function register(blockMenuComponents) {
-    blockMenuComponents.forEach(function (newComponent) {
-      // Find if a component with the same key already exists
-      var existingIndex = components.findIndex(function (comp) {
-        return comp.key === newComponent.key;
-      });
-      if (existingIndex !== -1) {
-        // Replace the existing component
-        components[existingIndex] = newComponent;
-      } else {
-        // Add new component
-        components.push(newComponent);
-      }
-    });
+    components.push.apply(components, _toConsumableArray(blockMenuComponents));
   };
   return {
     register: register,

package/dist/esm/editor-commands/transform-node-utils/steps/listToDecisionListStep.js

@@ -1,4 +1,4 @@
-import { Fragment } from '@atlaskit/editor-prosemirror/model';
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
 import { isListType } from '../utils';
 
 /**
@@ -27,7 +27,8 @@ import { isListType } from '../utils';
 export var listToDecisionListStep = function listToDecisionListStep(nodes, context) {
   var schema = context.schema;
   var paragraphType = schema.nodes.paragraph;
-  return nodes.map(function (node) {
+  var unsupportedContent = [];
+  var transformedNodes = nodes.map(function (node) {
     if (!isListType(node, schema)) {
       return node;
     }
@@ -37,20 +38,18 @@ export var listToDecisionListStep = function listToDecisionListStep(nodes, conte
       item.forEach(function (child) {
         if (child.type === paragraphType) {
           // paragraph may contain hard breaks etc.
-          child.content.forEach(function (inline) {
-            itemContent.push(inline);
-          });
-        } else {
+          itemContent.push.apply(itemContent, _toConsumableArray(child.children));
+        } else if (child.isText) {
           itemContent.push(child);
+        } else if (!isListType(child, schema)) {
+          unsupportedContent.push(child);
         }
-        // TODO: EDITOR-3887 - Skip mediaSingle, codeBlock, and nested lists
       });
-      var decisionItem = schema.nodes.decisionItem.create({}, Fragment.from(itemContent));
-      if (decisionItem) {
-        decisionItems.push(decisionItem);
-      }
+      var decisionItem = schema.nodes.decisionItem.create({}, itemContent);
+      decisionItems.push(decisionItem);
     });
-    var decisionList = schema.nodes.decisionList.create({}, Fragment.from(decisionItems));
+    var decisionList = schema.nodes.decisionList.create({}, decisionItems);
     return decisionList || node;
   });
+  return [].concat(_toConsumableArray(transformedNodes), unsupportedContent);
 };

package/dist/esm/editor-commands/transform-node-utils/steps/listToListStep.js

@@ -1,148 +1,122 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
 import { Fragment } from '@atlaskit/editor-prosemirror/model';
 import { isListType } from '../utils';
 
 /**
- * Converts FROM taskList structure TO bulletList/orderedList structure.
- */
-var convertFromTaskListStructure = function convertFromTaskListStructure(node, targetListType, targetItemType) {
-  var schema = node.type.schema;
-  var targetListNodeType = schema.nodes[targetListType];
-  var convertedItems = [];
-  node.content.forEach(function (child) {
-    if (isListType(child, schema)) {
-      // This is a nested list - it should become a child of the previous item
-      if (convertedItems.length > 0) {
-        var previousItem = convertedItems[convertedItems.length - 1];
-        // Convert the nested list and add it to the previous item's content
-        var convertedNestedList = _transformList(child, targetListType, targetItemType);
-        var newContent = previousItem.content.append(Fragment.from([convertedNestedList]));
-        var updatedItem = previousItem.type.create(previousItem.attrs, newContent);
-        convertedItems[convertedItems.length - 1] = updatedItem;
-      }
-      // If there's no previous item, skip this nested list (orphaned)
-    } else {
-      var convertedItem = transformListItem(child, targetItemType, targetListType);
-      if (convertedItem) {
-        convertedItems.push(convertedItem);
-      }
-    }
-  });
-  return targetListNodeType.create(node.attrs, Fragment.from(convertedItems));
-};
-
-/**
- * Converts FROM bulletList/orderedList structure TO taskList structure.
+ * Recursively converts nested lists to the target list type.
+ * This function handles the conversion of both the list container and its items,
+ * including any nested lists within those items.
+ *
+ * Important: taskList has a different nesting structure than bulletList/orderedList:
+ * - taskList: nested taskLists are SIBLINGS of taskItems in the parent taskList
+ * - bulletList/orderedList: nested lists are CHILDREN of listItems
  */
-var convertToTaskListStructure = function convertToTaskListStructure(node, targetListType, targetItemType) {
+var _transformList = function transformList(node, targetListType, targetItemType, unsupportedContent) {
   var schema = node.type.schema;
-  var targetListNodeType = schema.nodes[targetListType];
-  var transformedContent = [];
-  node.content.forEach(function (itemNode) {
-    var transformedItem = transformListItem(itemNode, targetItemType, targetListType, true);
-    if (transformedItem) {
-      transformedContent.push(transformedItem);
-    }
-    itemNode.content.forEach(function (child) {
+  var taskListType = schema.nodes.taskList;
+  var isSourceTaskList = node.type === taskListType;
+  var isTargetTaskList = targetListType === 'taskList';
+  var convertFromTaskListStructure = function convertFromTaskListStructure(node, targetListType, targetItemType) {
+    var schema = node.type.schema;
+    var targetListNodeType = schema.nodes[targetListType];
+    var transformedContent = [];
+    node.forEach(function (child) {
       if (isListType(child, schema)) {
-        var transformedNestedList = _transformList(child, targetListType, targetItemType);
-        transformedContent.push(transformedNestedList);
+        // This is a nested list - it should become a child of the previous item
+        if (transformedContent.length > 0) {
+          var previousItem = transformedContent[transformedContent.length - 1];
+          // Convert the nested list and add it to the previous item's content
+          var transformedNestedList = _transformList(child, targetListType, targetItemType, unsupportedContent);
+          var newContent = previousItem.content.append(Fragment.from([transformedNestedList]));
+          var updatedItem = previousItem.type.create(previousItem.attrs, newContent);
+          transformedContent[transformedContent.length - 1] = updatedItem;
+        }
+        // If there's no previous item, skip this nested list (orphaned)
+      } else {
+        var transformedItem = transformListItem(child, targetItemType, targetListType);
+        if (transformedItem) {
+          transformedContent.push(transformedItem);
+        }
       }
     });
-  });
-  return targetListNodeType.create(node.attrs, Fragment.from(transformedContent));
-};
-
-/**
- * Converts a single list item (listItem or taskItem) to the target item type.
- * Handles content transformation based on the target type's requirements.
- * @param itemNode - The list item node to convert
- * @param targetItemType - The target item type (listItem or taskItem)
- * @param targetListType - The target list type (bulletList, orderedList, or taskList)
- * @param excludeNestedLists - When true, nested lists are excluded from the item's content
- *                             (used when converting to taskList where nested lists become siblings)
- */
-var transformListItem = function transformListItem(itemNode, targetItemType, targetListType) {
-  var excludeNestedLists = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
-  var schema = itemNode.type.schema;
-  var targetItemNodeType = schema.nodes[targetItemType];
-  var isTargetTaskItem = targetItemType === 'taskItem';
-  var isSourceTaskItem = itemNode.type.name === 'taskItem';
-  var paragraphType = schema.nodes.paragraph;
-  if (!targetItemNodeType) {
-    return null;
-  }
-  if (isTargetTaskItem) {
-    var inlineContent = [];
-    itemNode.content.forEach(function (child) {
-      if (child.type === paragraphType) {
-        child.content.forEach(function (inline) {
-          inlineContent.push(inline);
-        });
-      }
-      if (child.isText) {
-        inlineContent.push(child);
+    return targetListNodeType.create(node.attrs, transformedContent);
+  };
+  var convertToTaskListStructure = function convertToTaskListStructure(node, targetListType, targetItemType) {
+    var schema = node.type.schema;
+    var targetListNodeType = schema.nodes[targetListType];
+    var transformedContent = [];
+    node.forEach(function (itemNode) {
+      var transformedItem = transformListItem(itemNode, targetItemType, targetListType, true);
+      if (transformedItem) {
+        transformedContent.push(transformedItem);
       }
-      // TODO: EDITOR-3887 - Skip mediaSingle, codeBlock, and nested lists
-      // Nested lists will be extracted and placed as siblings in the taskList
+      itemNode.forEach(function (child) {
+        if (isListType(child, schema)) {
+          transformedContent.push(_transformList(child, targetListType, targetItemType, unsupportedContent));
+        }
+      });
     });
-    return targetItemNodeType.create({}, Fragment.from(inlineContent));
-  } else {
-    var newContent = [];
+    return targetListNodeType.create(node.attrs, transformedContent);
+  };
+  var transformListItem = function transformListItem(itemNode, targetItemType, targetListType) {
+    var excludeNestedLists = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+    var schema = itemNode.type.schema;
+    var targetItemNodeType = schema.nodes[targetItemType];
+    var isTargetTaskItem = targetItemType === 'taskItem';
+    var isSourceTaskItem = itemNode.type.name === 'taskItem';
+    var paragraphType = schema.nodes.paragraph;
+    if (isTargetTaskItem) {
+      var inlineContent = [];
+      itemNode.forEach(function (child) {
+        if (child.type === paragraphType) {
+          inlineContent.push.apply(inlineContent, _toConsumableArray(child.children));
+        } else if (child.isText) {
+          inlineContent.push(child);
+          // Nested lists will be extracted and placed as siblings in the taskList
+        } else if (!isListType(child, schema)) {
+          unsupportedContent.push(child);
+        }
+      });
+      return targetItemNodeType.create({}, inlineContent);
+    }
+    var transformedContent = [];
     if (isSourceTaskItem) {
-      newContent.push(paragraphType.create(null, itemNode.content));
+      transformedContent.push(paragraphType.create(null, itemNode.content));
     } else {
-      itemNode.content.forEach(function (child) {
+      itemNode.forEach(function (child) {
         if (isListType(child, schema)) {
           if (excludeNestedLists) {
             // Skip nested lists - they will be handled separately as siblings
             return;
           }
-          newContent.push(_transformList(child, targetListType, targetItemType));
+          transformedContent.push(_transformList(child, targetListType, targetItemType, unsupportedContent));
         } else {
-          newContent.push(child);
+          transformedContent.push(child);
         }
       });
     }
-    if (newContent.length === 0) {
-      newContent.push(paragraphType.create());
+    if (transformedContent.length === 0) {
+      transformedContent.push(paragraphType.create());
     }
-    return targetItemNodeType.create({}, Fragment.from(newContent));
-  }
-};
-
-/**
- * Recursively converts nested lists to the target list type.
- * This function handles the conversion of both the list container and its items,
- * including any nested lists within those items.
- *
- * Important: taskList has a different nesting structure than bulletList/orderedList:
- * - taskList: nested taskLists are SIBLINGS of taskItems in the parent taskList
- * - bulletList/orderedList: nested lists are CHILDREN of listItems
- */
-var _transformList = function transformList(node, targetListType, targetItemType) {
-  var schema = node.type.schema;
-  var targetListNodeType = schema.nodes[targetListType];
-  var targetItemNodeType = schema.nodes[targetItemType];
-  var taskListType = schema.nodes.taskList;
-  if (!targetListNodeType || !targetItemNodeType) {
-    return node;
-  }
-  var isSourceTaskList = node.type === taskListType;
-  var isTargetTaskList = targetListType === 'taskList';
+    return targetItemNodeType.create({}, transformedContent);
+  };
+  var convertList = function convertList(node, schema, targetListType, targetItemType) {
+    var targetListNodeType = schema.nodes[targetListType];
+    var transformedContent = [];
+    node.forEach(function (childNode) {
+      var transformedItem = isListType(childNode, schema) ? _transformList(childNode, targetListType, targetItemType, unsupportedContent) : transformListItem(childNode, targetItemType, targetListType);
+      if (transformedItem) {
+        transformedContent.push(transformedItem);
+      }
+    });
+    return targetListNodeType.create(node.attrs, transformedContent);
+  };
   if (isSourceTaskList && !isTargetTaskList) {
     return convertFromTaskListStructure(node, targetListType, targetItemType);
   } else if (!isSourceTaskList && isTargetTaskList) {
     return convertToTaskListStructure(node, targetListType, targetItemType);
-  } else {
-    var transformedItems = [];
-    node.content.forEach(function (childNode) {
-      var transformedItem = isListType(childNode, schema) ? _transformList(childNode, targetListType, targetItemType) : transformListItem(childNode, targetItemType, targetListType);
-      if (transformedItem) {
-        transformedItems.push(transformedItem);
-      }
-    });
-    return targetListNodeType.create(node.attrs, Fragment.from(transformedItems));
   }
+  return convertList(node, schema, targetListType, targetItemType);
 };
 
 /**
@@ -211,11 +185,13 @@ var _transformList = function transformList(node, targetListType, targetItemType
 export var listToListStep = function listToListStep(nodes, context) {
   var schema = context.schema,
     targetNodeTypeName = context.targetNodeTypeName;
-  return nodes.map(function (node) {
+  var unsupportedContent = [];
+  var transformedNodes = nodes.map(function (node) {
     if (isListType(node, schema)) {
       var targetItemType = targetNodeTypeName === 'taskList' ? 'taskItem' : 'listItem';
-      return _transformList(node, targetNodeTypeName, targetItemType);
+      return _transformList(node, targetNodeTypeName, targetItemType, unsupportedContent);
     }
     return node;
   });
+  return [].concat(_toConsumableArray(transformedNodes), unsupportedContent);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@atlaskit/editor-plugin-block-menu",
-	"version": "5.2.8",
+	"version": "5.2.9",
 	"description": "BlockMenu plugin for @atlaskit/editor-core",
 	"author": "Atlassian Pty Ltd",
 	"license": "Apache-2.0",