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

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @atlaskit/editor-plugin-block-menu
 
+## 5.2.4
+
+### Patch Changes
+
+- [`dbbf4fabef4fe`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/dbbf4fabef4fe) -
+  [ux] Scope change | Remove text transformations for incompatible nodes
+- [`bb7cbcb12ae4f`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/bb7cbcb12ae4f) -
+  [ux] Implement transformation steps for panel to other nodes
+
+## 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/{wrapMixedContentStep.js → steps/wrapMixedContentStep.js}

@@ -1,36 +1,33 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.wrapMixedContentStep = void 0;
-var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 var _model = require("@atlaskit/editor-prosemirror/model");
-var _types = require("./types");
-var _unwrapStep = require("./unwrapStep");
+var _types = require("../types");
 /**
- * Determines if a node can be flattened (unwrapped and its contents merged).
- *
- * According to the text transformations list, flattenable nodes are:
- * - Bulleted list, Numbered list, Task list
- * - Text nodes (heading, paragraph)
- *
- * Containers (panels, expands, layouts, blockquotes) and atomic nodes (tables, media, macros) break out.
+ * Determines if a node is a text node (heading or paragraph).
+ * Text nodes can have their content converted to paragraphs when they can't be wrapped directly.
  */
-var canFlatten = function canFlatten(node) {
+var isTextNode = function isTextNode(node) {
   var category = _types.NODE_CATEGORY_BY_TYPE[node.type.name];
-  // Text and list nodes can be flattened (converted to simpler forms)
-  return category === 'text' || category === 'list';
+  return category === 'text';
 };
 
 /**
- * Flattens a node by extracting its contents using the appropriate unwrap step.
- * This is only called for text and list nodes that can be converted to simpler forms.
- * Uses unwrapStep to extract children from list containers.
+ * Converts a text node (heading, paragraph) to a paragraph preserving its inline content.
+ * This is used when a text node can't be wrapped directly in the target container
+ * (e.g., heading can't go in blockquote, so it becomes a paragraph).
  */
-var flattenNode = function flattenNode(node, context) {
-  return (0, _unwrapStep.unwrapStep)([node], context);
+var convertTextNodeToParagraph = function convertTextNodeToParagraph(node, schema) {
+  var _schema$nodes$paragra;
+  // If it's already a paragraph, return as-is
+  if (node.type.name === 'paragraph') {
+    return node;
+  }
+  // Convert heading (or other text node) to paragraph with same inline content
+  return (_schema$nodes$paragra = schema.nodes.paragraph.createAndFill({}, node.content)) !== null && _schema$nodes$paragra !== void 0 ? _schema$nodes$paragra : null;
 };
 
 /**
@@ -123,13 +120,16 @@ var wrapMixedContentStep = exports.wrapMixedContentStep = function wrapMixedCont
       if (expandNode) {
         result.push(expandNode);
       }
-    } else if (canFlatten(node)) {
-      var _currentContainerCont;
-      // Node cannot be wrapped but CAN be flattened - flatten and add to container
-      var flattenedNodes = flattenNode(node, context);
-      (_currentContainerCont = currentContainerContent).push.apply(_currentContainerCont, (0, _toConsumableArray2.default)(flattenedNodes));
+    } else if (isTextNode(node)) {
+      // Text node (heading, paragraph) that can't be wrapped - convert to paragraph
+      // Example: heading can't go in blockquote, so convert to paragraph with same content
+      var paragraph = convertTextNodeToParagraph(node, schema);
+      if (paragraph) {
+        currentContainerContent.push(paragraph);
+      }
     } else {
-      // Node cannot be wrapped AND cannot be flattened (containers, tables, media, macros) - break out
+      // All other nodes that cannot be wrapped (lists, containers, tables, media, macros) - break out
+      // This includes list nodes like taskList that can't be placed in certain containers
       flushCurrentContainer();
       result.push(node);
     }

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

@@ -5,19 +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 _wrapMixedContentStep = require("./steps/wrapMixedContentStep");
 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");
 var _wrapStep = require("./wrapStep");
 // Exampled step for overrides:
 // - open Block menu on a paragraph, click 'Panel' in the Turn into'
@@ -44,7 +42,7 @@ var TRANSFORM_STEPS = {
   list: {
     atomic: undefined,
     container: [_wrapStep.wrapStep],
-    list: [_stubStep.stubStep],
+    list: [_listToListStep.listToListStep],
     text: [_flattenListStep.flattenListStep, _unwrapListStep.unwrapListStep]
   },
   text: {
@@ -63,7 +61,8 @@ var TRANSFORM_STEPS_OVERRIDE = {
   },
   panel: {
     layoutSection: [_unwrapStep.unwrapStep, _wrapIntoLayoutStep.wrapIntoLayoutStep],
-    codeBlock: [_unwrapStep.unwrapStep, _flattenStep.flattenStep, _wrapStep.wrapStep]
+    codeBlock: [_unwrapStep.unwrapStep, _flattenStep.flattenStep, _wrapStep.wrapStep],
+    blockquote: [_unwrapStep.unwrapStep, _wrapMixedContentStep.wrapMixedContentStep]
   },
   expand: {
     panel: [_unwrapExpandStep.unwrapExpandStep, _wrapMixedContentStep.wrapMixedContentStep],
@@ -99,21 +98,19 @@ var TRANSFORM_STEPS_OVERRIDE = {
     panel: [_wrapStep.wrapStep]
   },
   bulletList: {
-    // Warning: Actuall transformation logic not complete (Likelly prosemirror-markdown to be used)
-    codeBlock: [_convertBulletListToTextStep.convertBulletListToTextStep, _flattenStep.flattenStep, _wrapStep.wrapStep],
+    // Text transformations currently not in scope > options will be disabled > stubbing in case
+    codeBlock: [_stubStep.stubStep],
     layoutSection: [_wrapIntoLayoutStep.wrapIntoLayoutStep]
   },
   orderedList: {
-    // Warning: Actuall transformation logic not complete (Likelly prosemirror-markdown to be used)
-    codeBlock: [_convertOrderedListToTextStep.convertOrderedListToTextStep, _flattenStep.flattenStep, _wrapStep.wrapStep],
-    // Warning: Actuall transformation logic not complete (Likelly prosemirror-markdown to be used)
+    // Text transformations currently not in scope > options will be disabled > stubbing in case
+    codeBlock: [_stubStep.stubStep],
     layoutSection: [_wrapIntoLayoutStep.wrapIntoLayoutStep]
   },
   taskList: {
-    // Warning: Actuall transformation logic not complete (Skeptical that prosemirror-markdown can be used)
-    blockquote: [_convertTaskListToTextStep.convertTaskListToTextStep, _wrapStep.wrapStep],
-    // Warning: Actuall transformation logic not complete (Likelly prosemirror-markdown to be used)
-    codeBlock: [_convertTaskListToTextStep.convertTaskListToTextStep, _flattenStep.flattenStep, _wrapStep.wrapStep],
+    // Text transformations currently not in scope > options will be disabled > stubbing in case
+    blockquote: [_stubStep.stubStep],
+    codeBlock: [_stubStep.stubStep],
     layoutSection: [_wrapIntoLayoutStep.wrapIntoLayoutStep]
   },
   table: {

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;
+  });
+};