@atlaskit/editor-plugin-block-menu 5.2.2 → 5.2.3

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @atlaskit/editor-plugin-block-menu
 
+## 5.2.3
+
+### Patch Changes
+
+- [`d0857f52fd866`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/d0857f52fd866) -
+  Add list-to-list transformation support in block menu
+
 ## 5.2.2
 
 ### Patch Changes

package/dist/cjs/editor-commands/transform-node-utils/{flattenListStep.js → steps/flattenListStep.js}

@@ -20,12 +20,10 @@ var extractNestedLists = function extractNestedLists(node, listTypes, itemTypes,
             return grandChild.type === type;
           })) {
             nestedLists.push(grandChild);
+          } else if (grandChild.isText) {
+            contentWithoutNestedLists.push(paragraph.createAndFill({}, grandChild));
           } else {
-            if (grandChild.isText) {
-              contentWithoutNestedLists.push(paragraph.createAndFill({}, grandChild));
-            } else {
-              contentWithoutNestedLists.push(grandChild);
-            }
+            contentWithoutNestedLists.push(grandChild);
           }
         });
         items.push(child.copy(_model.Fragment.from(contentWithoutNestedLists)));

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

@@ -0,0 +1,232 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.listToListStep = void 0;
+var _model = require("@atlaskit/editor-prosemirror/model");
+var isListType = function isListType(node, schema) {
+  var lists = [schema.nodes.taskList, schema.nodes.bulletList, schema.nodes.orderedList];
+  return lists.some(function (list) {
+    return list === node.type;
+  });
+};
+
+/**
+ * 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(_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.
+ */
+var convertToTaskListStructure = function convertToTaskListStructure(node, targetListType, targetItemType) {
+  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) {
+      if (isListType(child, schema)) {
+        var transformedNestedList = _transformList(child, targetListType, targetItemType);
+        transformedContent.push(transformedNestedList);
+      }
+    });
+  });
+  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);
+      }
+      // TODO: EDITOR-3887 - Skip mediaSingle, codeBlock, and nested lists
+      // Nested lists will be extracted and placed as siblings in the taskList
+    });
+    return targetItemNodeType.create({}, _model.Fragment.from(inlineContent));
+  } else {
+    var newContent = [];
+    if (isSourceTaskItem) {
+      newContent.push(paragraphType.create(null, itemNode.content));
+    } else {
+      itemNode.content.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));
+        } else {
+          newContent.push(child);
+        }
+      });
+    }
+    if (newContent.length === 0) {
+      newContent.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';
+  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, _model.Fragment.from(transformedItems));
+  }
+};
+
+/**
+ * Transform step that converts between bulletList, orderedList, and taskList types.
+ * This step maintains the order and indentation of the list by recursively
+ * converting all nested lists while preserving the structure. It also handles
+ * conversion between listItem and taskItem types.
+ *
+ * When converting to taskList/taskItem, unsupported content (images, codeBlocks) is filtered out.
+ *
+ * @example
+ * Input (bulletList with nested bulletList):
+ * - bulletList
+ *   - listItem "1"
+ *     - bulletList
+ *       - listItem "1.1"
+ *         - bulletList
+ *           - listItem "1.1.1"
+ *       - listItem "1.2"
+ *   - listItem "2"
+ *
+ * Output (orderedList with nested orderedList):
+ * 1. orderedList
+ *    1. listItem "1"
+ *       1. orderedList
+ *          1. listItem "1.1"
+ *             1. orderedList
+ *                1. listItem "1.1.1"
+ *          2. listItem "1.2"
+ *    2. listItem "2"
+ *
+ * @example
+ * Input (bulletList with nested taskList):
+ * - bulletList
+ *   - listItem "Regular item"
+ *     - taskList
+ *       - taskItem "Task 1" (checked)
+ *       - taskItem "Task 2" (unchecked)
+ *
+ * Output (orderedList with nested orderedList, taskItems converted to listItems):
+ * 1. orderedList
+ *    1. listItem "Regular item"
+ *       1. orderedList
+ *          1. listItem "Task 1"
+ *          2. listItem "Task 2"
+ *
+ * @example
+ * Input (bulletList to taskList, with paragraph extraction):
+ * - bulletList
+ *   - listItem
+ *     - paragraph "Text content"
+ *   - listItem
+ *     - paragraph "Text"
+ *     - codeBlock "code"
+ *     - mediaSingle (image)
+ *
+ * Output (taskList with text extracted from paragraphs, unsupported content filtered):
+ * - taskList
+ *   - taskItem "Text content" (text extracted from paragraph)
+ *   - taskItem "Text" (text extracted, codeBlock and image filtered out)
+ *
+ * @param nodes - The nodes to transform
+ * @param context - The transformation context containing schema and target node type
+ * @returns The transformed nodes
+ */
+var listToListStep = exports.listToListStep = function listToListStep(nodes, context) {
+  var schema = context.schema,
+    targetNodeTypeName = context.targetNodeTypeName;
+  return nodes.map(function (node) {
+    if (isListType(node, schema)) {
+      var targetItemType = targetNodeTypeName === 'taskList' ? 'taskItem' : 'listItem';
+      return _transformList(node, targetNodeTypeName, targetItemType);
+    }
+    return node;
+  });
+};

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

@@ -5,16 +5,17 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.getOutputNodes = void 0;
 var _utils = require("../transform-node-utils/utils");
-var _flattenListStep = require("./flattenListStep");
 var _flattenStep = require("./flattenStep");
 var _convertBulletListToTextStep = require("./steps/convertBulletListToTextStep");
 var _convertOrderedListToTextStep = require("./steps/convertOrderedListToTextStep");
 var _convertTaskListToTextStep = require("./steps/convertTaskListToTextStep");
+var _flattenListStep = require("./steps/flattenListStep");
+var _listToListStep = require("./steps/listToListStep");
 var _unwrapLayoutStep = require("./steps/unwrapLayoutStep");
+var _unwrapListStep = require("./steps/unwrapListStep");
 var _stubStep = require("./stubStep");
 var _types = require("./types");
 var _unwrapExpandStep = require("./unwrapExpandStep");
-var _unwrapListStep = require("./unwrapListStep");
 var _unwrapStep = require("./unwrapStep");
 var _wrapIntoLayoutStep = require("./wrapIntoLayoutStep");
 var _wrapMixedContentStep = require("./wrapMixedContentStep");
@@ -44,7 +45,7 @@ var TRANSFORM_STEPS = {
   list: {
     atomic: undefined,
     container: [_wrapStep.wrapStep],
-    list: [_stubStep.stubStep],
+    list: [_listToListStep.listToListStep],
     text: [_flattenListStep.flattenListStep, _unwrapListStep.unwrapListStep]
   },
   text: {

package/dist/es2019/editor-commands/transform-node-utils/{flattenListStep.js → steps/flattenListStep.js}

@@ -10,12 +10,10 @@ const extractNestedLists = (node, listTypes, itemTypes, schema) => {
         child.forEach(grandChild => {
           if (listTypes.some(type => grandChild.type === type)) {
             nestedLists.push(grandChild);
+          } else if (grandChild.isText) {
+            contentWithoutNestedLists.push(paragraph.createAndFill({}, grandChild));
           } else {
-            if (grandChild.isText) {
-              contentWithoutNestedLists.push(paragraph.createAndFill({}, grandChild));
-            } else {
-              contentWithoutNestedLists.push(grandChild);
-            }
+            contentWithoutNestedLists.push(grandChild);
           }
         });
         items.push(child.copy(Fragment.from(contentWithoutNestedLists)));

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

@@ -0,0 +1,225 @@
+import { Fragment } from '@atlaskit/editor-prosemirror/model';
+const isListType = (node, schema) => {
+  const lists = [schema.nodes.taskList, schema.nodes.bulletList, schema.nodes.orderedList];
+  return lists.some(list => list === node.type);
+};
+
+/**
+ * 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.
+ */
+const convertToTaskListStructure = (node, targetListType, targetItemType) => {
+  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 => {
+      if (isListType(child, schema)) {
+        const transformedNestedList = transformList(child, targetListType, targetItemType);
+        transformedContent.push(transformedNestedList);
+      }
+    });
+  });
+  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);
+      }
+      // TODO: EDITOR-3887 - Skip mediaSingle, codeBlock, and nested lists
+      // Nested lists will be extracted and placed as siblings in the taskList
+    });
+    return targetItemNodeType.create({}, Fragment.from(inlineContent));
+  } else {
+    const newContent = [];
+    if (isSourceTaskItem) {
+      newContent.push(paragraphType.create(null, itemNode.content));
+    } else {
+      itemNode.content.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));
+        } else {
+          newContent.push(child);
+        }
+      });
+    }
+    if (newContent.length === 0) {
+      newContent.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';
+  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));
+  }
+};
+
+/**
+ * Transform step that converts between bulletList, orderedList, and taskList types.
+ * This step maintains the order and indentation of the list by recursively
+ * converting all nested lists while preserving the structure. It also handles
+ * conversion between listItem and taskItem types.
+ *
+ * When converting to taskList/taskItem, unsupported content (images, codeBlocks) is filtered out.
+ *
+ * @example
+ * Input (bulletList with nested bulletList):
+ * - bulletList
+ *   - listItem "1"
+ *     - bulletList
+ *       - listItem "1.1"
+ *         - bulletList
+ *           - listItem "1.1.1"
+ *       - listItem "1.2"
+ *   - listItem "2"
+ *
+ * Output (orderedList with nested orderedList):
+ * 1. orderedList
+ *    1. listItem "1"
+ *       1. orderedList
+ *          1. listItem "1.1"
+ *             1. orderedList
+ *                1. listItem "1.1.1"
+ *          2. listItem "1.2"
+ *    2. listItem "2"
+ *
+ * @example
+ * Input (bulletList with nested taskList):
+ * - bulletList
+ *   - listItem "Regular item"
+ *     - taskList
+ *       - taskItem "Task 1" (checked)
+ *       - taskItem "Task 2" (unchecked)
+ *
+ * Output (orderedList with nested orderedList, taskItems converted to listItems):
+ * 1. orderedList
+ *    1. listItem "Regular item"
+ *       1. orderedList
+ *          1. listItem "Task 1"
+ *          2. listItem "Task 2"
+ *
+ * @example
+ * Input (bulletList to taskList, with paragraph extraction):
+ * - bulletList
+ *   - listItem
+ *     - paragraph "Text content"
+ *   - listItem
+ *     - paragraph "Text"
+ *     - codeBlock "code"
+ *     - mediaSingle (image)
+ *
+ * Output (taskList with text extracted from paragraphs, unsupported content filtered):
+ * - taskList
+ *   - taskItem "Text content" (text extracted from paragraph)
+ *   - taskItem "Text" (text extracted, codeBlock and image filtered out)
+ *
+ * @param nodes - The nodes to transform
+ * @param context - The transformation context containing schema and target node type
+ * @returns The transformed nodes
+ */
+export const listToListStep = (nodes, context) => {
+  const {
+    schema,
+    targetNodeTypeName
+  } = context;
+  return nodes.map(node => {
+    if (isListType(node, schema)) {
+      const targetItemType = targetNodeTypeName === 'taskList' ? 'taskItem' : 'listItem';
+      return transformList(node, targetNodeTypeName, targetItemType);
+    }
+    return node;
+  });
+};

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

@@ -1,14 +1,15 @@
 import { getTargetNodeTypeNameInContext } from '../transform-node-utils/utils';
-import { flattenListStep } from './flattenListStep';
 import { flattenStep } from './flattenStep';
 import { convertBulletListToTextStep } from './steps/convertBulletListToTextStep';
 import { convertOrderedListToTextStep } from './steps/convertOrderedListToTextStep';
 import { convertTaskListToTextStep } from './steps/convertTaskListToTextStep';
+import { flattenListStep } from './steps/flattenListStep';
+import { listToListStep } from './steps/listToListStep';
 import { unwrapLayoutStep } from './steps/unwrapLayoutStep';
+import { unwrapListStep } from './steps/unwrapListStep';
 import { stubStep } from './stubStep';
 import { NODE_CATEGORY_BY_TYPE, toNodeTypeValue } from './types';
 import { unwrapExpandStep } from './unwrapExpandStep';
-import { unwrapListStep } from './unwrapListStep';
 import { unwrapStep } from './unwrapStep';
 import { wrapIntoLayoutStep } from './wrapIntoLayoutStep';
 import { wrapMixedContentStep } from './wrapMixedContentStep';
@@ -39,7 +40,7 @@ const TRANSFORM_STEPS = {
   list: {
     atomic: undefined,
     container: [wrapStep],
-    list: [stubStep],
+    list: [listToListStep],
     text: [flattenListStep, unwrapListStep]
   },
   text: {

package/dist/esm/editor-commands/transform-node-utils/{flattenListStep.js → steps/flattenListStep.js}

@@ -14,12 +14,10 @@ var extractNestedLists = function extractNestedLists(node, listTypes, itemTypes,
             return grandChild.type === type;
           })) {
             nestedLists.push(grandChild);
+          } else if (grandChild.isText) {
+            contentWithoutNestedLists.push(paragraph.createAndFill({}, grandChild));
           } else {
-            if (grandChild.isText) {
-              contentWithoutNestedLists.push(paragraph.createAndFill({}, grandChild));
-            } else {
-              contentWithoutNestedLists.push(grandChild);
-            }
+            contentWithoutNestedLists.push(grandChild);
           }
         });
         items.push(child.copy(Fragment.from(contentWithoutNestedLists)));

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

@@ -0,0 +1,226 @@
+import { Fragment } from '@atlaskit/editor-prosemirror/model';
+var isListType = function isListType(node, schema) {
+  var lists = [schema.nodes.taskList, schema.nodes.bulletList, schema.nodes.orderedList];
+  return lists.some(function (list) {
+    return list === node.type;
+  });
+};
+
+/**
+ * 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.
+ */
+var convertToTaskListStructure = function convertToTaskListStructure(node, targetListType, targetItemType) {
+  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) {
+      if (isListType(child, schema)) {
+        var transformedNestedList = _transformList(child, targetListType, targetItemType);
+        transformedContent.push(transformedNestedList);
+      }
+    });
+  });
+  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);
+      }
+      // TODO: EDITOR-3887 - Skip mediaSingle, codeBlock, and nested lists
+      // Nested lists will be extracted and placed as siblings in the taskList
+    });
+    return targetItemNodeType.create({}, Fragment.from(inlineContent));
+  } else {
+    var newContent = [];
+    if (isSourceTaskItem) {
+      newContent.push(paragraphType.create(null, itemNode.content));
+    } else {
+      itemNode.content.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));
+        } else {
+          newContent.push(child);
+        }
+      });
+    }
+    if (newContent.length === 0) {
+      newContent.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';
+  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));
+  }
+};
+
+/**
+ * Transform step that converts between bulletList, orderedList, and taskList types.
+ * This step maintains the order and indentation of the list by recursively
+ * converting all nested lists while preserving the structure. It also handles
+ * conversion between listItem and taskItem types.
+ *
+ * When converting to taskList/taskItem, unsupported content (images, codeBlocks) is filtered out.
+ *
+ * @example
+ * Input (bulletList with nested bulletList):
+ * - bulletList
+ *   - listItem "1"
+ *     - bulletList
+ *       - listItem "1.1"
+ *         - bulletList
+ *           - listItem "1.1.1"
+ *       - listItem "1.2"
+ *   - listItem "2"
+ *
+ * Output (orderedList with nested orderedList):
+ * 1. orderedList
+ *    1. listItem "1"
+ *       1. orderedList
+ *          1. listItem "1.1"
+ *             1. orderedList
+ *                1. listItem "1.1.1"
+ *          2. listItem "1.2"
+ *    2. listItem "2"
+ *
+ * @example
+ * Input (bulletList with nested taskList):
+ * - bulletList
+ *   - listItem "Regular item"
+ *     - taskList
+ *       - taskItem "Task 1" (checked)
+ *       - taskItem "Task 2" (unchecked)
+ *
+ * Output (orderedList with nested orderedList, taskItems converted to listItems):
+ * 1. orderedList
+ *    1. listItem "Regular item"
+ *       1. orderedList
+ *          1. listItem "Task 1"
+ *          2. listItem "Task 2"
+ *
+ * @example
+ * Input (bulletList to taskList, with paragraph extraction):
+ * - bulletList
+ *   - listItem
+ *     - paragraph "Text content"
+ *   - listItem
+ *     - paragraph "Text"
+ *     - codeBlock "code"
+ *     - mediaSingle (image)
+ *
+ * Output (taskList with text extracted from paragraphs, unsupported content filtered):
+ * - taskList
+ *   - taskItem "Text content" (text extracted from paragraph)
+ *   - taskItem "Text" (text extracted, codeBlock and image filtered out)
+ *
+ * @param nodes - The nodes to transform
+ * @param context - The transformation context containing schema and target node type
+ * @returns The transformed nodes
+ */
+export var listToListStep = function listToListStep(nodes, context) {
+  var schema = context.schema,
+    targetNodeTypeName = context.targetNodeTypeName;
+  return nodes.map(function (node) {
+    if (isListType(node, schema)) {
+      var targetItemType = targetNodeTypeName === 'taskList' ? 'taskItem' : 'listItem';
+      return _transformList(node, targetNodeTypeName, targetItemType);
+    }
+    return node;
+  });
+};

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

@@ -1,14 +1,15 @@
 import { getTargetNodeTypeNameInContext } from '../transform-node-utils/utils';
-import { flattenListStep } from './flattenListStep';
 import { flattenStep } from './flattenStep';
 import { convertBulletListToTextStep } from './steps/convertBulletListToTextStep';
 import { convertOrderedListToTextStep } from './steps/convertOrderedListToTextStep';
 import { convertTaskListToTextStep } from './steps/convertTaskListToTextStep';
+import { flattenListStep } from './steps/flattenListStep';
+import { listToListStep } from './steps/listToListStep';
 import { unwrapLayoutStep } from './steps/unwrapLayoutStep';
+import { unwrapListStep } from './steps/unwrapListStep';
 import { stubStep } from './stubStep';
 import { NODE_CATEGORY_BY_TYPE, toNodeTypeValue } from './types';
 import { unwrapExpandStep } from './unwrapExpandStep';
-import { unwrapListStep } from './unwrapListStep';
 import { unwrapStep } from './unwrapStep';
 import { wrapIntoLayoutStep } from './wrapIntoLayoutStep';
 import { wrapMixedContentStep } from './wrapMixedContentStep';
@@ -39,7 +40,7 @@ var TRANSFORM_STEPS = {
   list: {
     atomic: undefined,
     container: [wrapStep],
-    list: [stubStep],
+    list: [listToListStep],
     text: [flattenListStep, unwrapListStep]
   },
   text: {

package/dist/{types-ts4.5/editor-commands/transform-node-utils → types/editor-commands/transform-node-utils/steps}/flattenListStep.d.ts

@@ -1,4 +1,4 @@
-import type { TransformStep } from './types';
+import type { TransformStep } from '../types';
 /**
  * Given an array of nodes, returns an array with the flattened children of any list node
  * to it's first ancestor list, maintaining document order.

package/dist/types/editor-commands/transform-node-utils/steps/listToListStep.d.ts

@@ -0,0 +1,65 @@
+import type { TransformStep } from '../types';
+/**
+ * Transform step that converts between bulletList, orderedList, and taskList types.
+ * This step maintains the order and indentation of the list by recursively
+ * converting all nested lists while preserving the structure. It also handles
+ * conversion between listItem and taskItem types.
+ *
+ * When converting to taskList/taskItem, unsupported content (images, codeBlocks) is filtered out.
+ *
+ * @example
+ * Input (bulletList with nested bulletList):
+ * - bulletList
+ *   - listItem "1"
+ *     - bulletList
+ *       - listItem "1.1"
+ *         - bulletList
+ *           - listItem "1.1.1"
+ *       - listItem "1.2"
+ *   - listItem "2"
+ *
+ * Output (orderedList with nested orderedList):
+ * 1. orderedList
+ *    1. listItem "1"
+ *       1. orderedList
+ *          1. listItem "1.1"
+ *             1. orderedList
+ *                1. listItem "1.1.1"
+ *          2. listItem "1.2"
+ *    2. listItem "2"
+ *
+ * @example
+ * Input (bulletList with nested taskList):
+ * - bulletList
+ *   - listItem "Regular item"
+ *     - taskList
+ *       - taskItem "Task 1" (checked)
+ *       - taskItem "Task 2" (unchecked)
+ *
+ * Output (orderedList with nested orderedList, taskItems converted to listItems):
+ * 1. orderedList
+ *    1. listItem "Regular item"
+ *       1. orderedList
+ *          1. listItem "Task 1"
+ *          2. listItem "Task 2"
+ *
+ * @example
+ * Input (bulletList to taskList, with paragraph extraction):
+ * - bulletList
+ *   - listItem
+ *     - paragraph "Text content"
+ *   - listItem
+ *     - paragraph "Text"
+ *     - codeBlock "code"
+ *     - mediaSingle (image)
+ *
+ * Output (taskList with text extracted from paragraphs, unsupported content filtered):
+ * - taskList
+ *   - taskItem "Text content" (text extracted from paragraph)
+ *   - taskItem "Text" (text extracted, codeBlock and image filtered out)
+ *
+ * @param nodes - The nodes to transform
+ * @param context - The transformation context containing schema and target node type
+ * @returns The transformed nodes
+ */
+export declare const listToListStep: TransformStep;

package/dist/{types-ts4.5/editor-commands/transform-node-utils → types/editor-commands/transform-node-utils/steps}/unwrapListStep.d.ts

@@ -1,4 +1,4 @@
-import type { TransformStep } from './types';
+import type { TransformStep } from '../types';
 /**
  * Given an array of nodes, processes each list removing all parent list nodes and
  * just returning their child contents.

package/dist/{types/editor-commands/transform-node-utils → types-ts4.5/editor-commands/transform-node-utils/steps}/flattenListStep.d.ts

@@ -1,4 +1,4 @@
-import type { TransformStep } from './types';
+import type { TransformStep } from '../types';
 /**
  * Given an array of nodes, returns an array with the flattened children of any list node
  * to it's first ancestor list, maintaining document order.

package/dist/types-ts4.5/editor-commands/transform-node-utils/steps/listToListStep.d.ts

@@ -0,0 +1,65 @@
+import type { TransformStep } from '../types';
+/**
+ * Transform step that converts between bulletList, orderedList, and taskList types.
+ * This step maintains the order and indentation of the list by recursively
+ * converting all nested lists while preserving the structure. It also handles
+ * conversion between listItem and taskItem types.
+ *
+ * When converting to taskList/taskItem, unsupported content (images, codeBlocks) is filtered out.
+ *
+ * @example
+ * Input (bulletList with nested bulletList):
+ * - bulletList
+ *   - listItem "1"
+ *     - bulletList
+ *       - listItem "1.1"
+ *         - bulletList
+ *           - listItem "1.1.1"
+ *       - listItem "1.2"
+ *   - listItem "2"
+ *
+ * Output (orderedList with nested orderedList):
+ * 1. orderedList
+ *    1. listItem "1"
+ *       1. orderedList
+ *          1. listItem "1.1"
+ *             1. orderedList
+ *                1. listItem "1.1.1"
+ *          2. listItem "1.2"
+ *    2. listItem "2"
+ *
+ * @example
+ * Input (bulletList with nested taskList):
+ * - bulletList
+ *   - listItem "Regular item"
+ *     - taskList
+ *       - taskItem "Task 1" (checked)
+ *       - taskItem "Task 2" (unchecked)
+ *
+ * Output (orderedList with nested orderedList, taskItems converted to listItems):
+ * 1. orderedList
+ *    1. listItem "Regular item"
+ *       1. orderedList
+ *          1. listItem "Task 1"
+ *          2. listItem "Task 2"
+ *
+ * @example
+ * Input (bulletList to taskList, with paragraph extraction):
+ * - bulletList
+ *   - listItem
+ *     - paragraph "Text content"
+ *   - listItem
+ *     - paragraph "Text"
+ *     - codeBlock "code"
+ *     - mediaSingle (image)
+ *
+ * Output (taskList with text extracted from paragraphs, unsupported content filtered):
+ * - taskList
+ *   - taskItem "Text content" (text extracted from paragraph)
+ *   - taskItem "Text" (text extracted, codeBlock and image filtered out)
+ *
+ * @param nodes - The nodes to transform
+ * @param context - The transformation context containing schema and target node type
+ * @returns The transformed nodes
+ */
+export declare const listToListStep: TransformStep;

package/dist/{types/editor-commands/transform-node-utils → types-ts4.5/editor-commands/transform-node-utils/steps}/unwrapListStep.d.ts

@@ -1,4 +1,4 @@
-import type { TransformStep } from './types';
+import type { TransformStep } from '../types';
 /**
  * Given an array of nodes, processes each list removing all parent list nodes and
  * just returning their child contents.

package/package.json

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