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

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

@@ -1,29 +1,28 @@
 import { Fragment } from '@atlaskit/editor-prosemirror/model';
-import { NODE_CATEGORY_BY_TYPE } from './types';
-import { unwrapStep } from './unwrapStep';
+import { NODE_CATEGORY_BY_TYPE } from '../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.
  */
-const canFlatten = node => {
+const isTextNode = node => {
   const category = 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).
  */
-const flattenNode = (node, context) => {
-  return unwrapStep([node], context);
+const 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;
 };
 
 /**
@@ -118,12 +117,16 @@ export const wrapMixedContentStep = (nodes, context) => {
       if (expandNode) {
         result.push(expandNode);
       }
-    } else if (canFlatten(node)) {
-      // Node cannot be wrapped but CAN be flattened - flatten and add to container
-      const flattenedNodes = flattenNode(node, context);
-      currentContainerContent.push(...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
+      const 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/es2019/editor-commands/transform-node-utils/transform.js

@@ -1,17 +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 { wrapMixedContentStep } from './steps/wrapMixedContentStep';
 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';
 import { wrapStep } from './wrapStep';
 
 // Exampled step for overrides:
@@ -39,7 +37,7 @@ const TRANSFORM_STEPS = {
   list: {
     atomic: undefined,
     container: [wrapStep],
-    list: [stubStep],
+    list: [listToListStep],
     text: [flattenListStep, unwrapListStep]
   },
   text: {
@@ -58,7 +56,8 @@ const TRANSFORM_STEPS_OVERRIDE = {
   },
   panel: {
     layoutSection: [unwrapStep, wrapIntoLayoutStep],
-    codeBlock: [unwrapStep, flattenStep, wrapStep]
+    codeBlock: [unwrapStep, flattenStep, wrapStep],
+    blockquote: [unwrapStep, wrapMixedContentStep]
   },
   expand: {
     panel: [unwrapExpandStep, wrapMixedContentStep],
@@ -94,21 +93,19 @@ const TRANSFORM_STEPS_OVERRIDE = {
     panel: [wrapStep]
   },
   bulletList: {
-    // Warning: Actuall transformation logic not complete (Likelly prosemirror-markdown to be used)
-    codeBlock: [convertBulletListToTextStep, flattenStep, wrapStep],
+    // Text transformations currently not in scope > options will be disabled > stubbing in case
+    codeBlock: [stubStep],
     layoutSection: [wrapIntoLayoutStep]
   },
   orderedList: {
-    // Warning: Actuall transformation logic not complete (Likelly prosemirror-markdown to be used)
-    codeBlock: [convertOrderedListToTextStep, flattenStep, 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],
     layoutSection: [wrapIntoLayoutStep]
   },
   taskList: {
-    // Warning: Actuall transformation logic not complete (Skeptical that prosemirror-markdown can be used)
-    blockquote: [convertTaskListToTextStep, wrapStep],
-    // Warning: Actuall transformation logic not complete (Likelly prosemirror-markdown to be used)
-    codeBlock: [convertTaskListToTextStep, flattenStep, wrapStep],
+    // Text transformations currently not in scope > options will be disabled > stubbing in case
+    blockquote: [stubStep],
+    codeBlock: [stubStep],
     layoutSection: [wrapIntoLayoutStep]
   },
   table: {

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/{wrapMixedContentStep.js → steps/wrapMixedContentStep.js}

@@ -1,30 +1,28 @@
-import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
 import { Fragment } from '@atlaskit/editor-prosemirror/model';
-import { NODE_CATEGORY_BY_TYPE } from './types';
-import { unwrapStep } from './unwrapStep';
+import { NODE_CATEGORY_BY_TYPE } from '../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 = 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 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;
 };
 
 /**
@@ -117,13 +115,16 @@ export var wrapMixedContentStep = function wrapMixedContentStep(nodes, context)
       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, _toConsumableArray(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/esm/editor-commands/transform-node-utils/transform.js

@@ -1,17 +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 { wrapMixedContentStep } from './steps/wrapMixedContentStep';
 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';
 import { wrapStep } from './wrapStep';
 
 // Exampled step for overrides:
@@ -39,7 +37,7 @@ var TRANSFORM_STEPS = {
   list: {
     atomic: undefined,
     container: [wrapStep],
-    list: [stubStep],
+    list: [listToListStep],
     text: [flattenListStep, unwrapListStep]
   },
   text: {
@@ -58,7 +56,8 @@ var TRANSFORM_STEPS_OVERRIDE = {
   },
   panel: {
     layoutSection: [unwrapStep, wrapIntoLayoutStep],
-    codeBlock: [unwrapStep, flattenStep, wrapStep]
+    codeBlock: [unwrapStep, flattenStep, wrapStep],
+    blockquote: [unwrapStep, wrapMixedContentStep]
   },
   expand: {
     panel: [unwrapExpandStep, wrapMixedContentStep],
@@ -94,21 +93,19 @@ var TRANSFORM_STEPS_OVERRIDE = {
     panel: [wrapStep]
   },
   bulletList: {
-    // Warning: Actuall transformation logic not complete (Likelly prosemirror-markdown to be used)
-    codeBlock: [convertBulletListToTextStep, flattenStep, wrapStep],
+    // Text transformations currently not in scope > options will be disabled > stubbing in case
+    codeBlock: [stubStep],
     layoutSection: [wrapIntoLayoutStep]
   },
   orderedList: {
-    // Warning: Actuall transformation logic not complete (Likelly prosemirror-markdown to be used)
-    codeBlock: [convertOrderedListToTextStep, flattenStep, 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],
     layoutSection: [wrapIntoLayoutStep]
   },
   taskList: {
-    // Warning: Actuall transformation logic not complete (Skeptical that prosemirror-markdown can be used)
-    blockquote: [convertTaskListToTextStep, wrapStep],
-    // Warning: Actuall transformation logic not complete (Likelly prosemirror-markdown to be used)
-    codeBlock: [convertTaskListToTextStep, flattenStep, wrapStep],
+    // Text transformations currently not in scope > options will be disabled > stubbing in case
+    blockquote: [stubStep],
+    codeBlock: [stubStep],
     layoutSection: [wrapIntoLayoutStep]
   },
   table: {

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/editor-commands/transform-node-utils/{unwrapListStep.d.ts → 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/{wrapMixedContentStep.d.ts → steps/wrapMixedContentStep.d.ts}

@@ -1,4 +1,4 @@
-import type { TransformStep } from './types';
+import type { TransformStep } from '../types';
 /**
  * A wrap step that handles mixed content according to the Compatibility Matrix:
  * - Wraps consecutive compatible nodes into the target container

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.