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

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

@@ -1,96 +1,99 @@
+import { getSupportedListTypesSet, isBulletOrOrderedList, isTaskList } from '../utils';
+
 /**
- * Extract all inline content from a node
+ * Convert a block node to inline content suitable for task items
  */
-const extractInlineContent = node => {
-  const inlineContent = [];
-  for (let i = 0; i < node.childCount; i++) {
-    inlineContent.push(node.child(i));
+const convertBlockToInlineContent = (node, schema) => {
+  const {
+    paragraph
+  } = schema.nodes;
+  if (node.type === paragraph) {
+    return [...node.content.content];
+  }
+  if (node.isBlock) {
+    const textContent = node.textContent;
+    return textContent ? [schema.text(textContent)] : [];
   }
-  return inlineContent;
+  return [node];
 };
 
 /**
- * Transform list structure
+ * Transform list structure between different list types
  */
-export const transformListStructure = (tr, listNode, targetNodeType, nodes) => {
+export const transformListStructure = context => {
+  const {
+    tr,
+    sourceNode,
+    sourcePos,
+    targetNodeType
+  } = context;
+  const nodes = tr.doc.type.schema.nodes;
   try {
+    const listNode = {
+      node: sourceNode,
+      pos: sourcePos
+    };
     const {
       node: sourceList,
       pos: listPos
     } = listNode;
     const {
-      bulletList,
-      orderedList,
       taskList,
       listItem,
       taskItem,
       paragraph
     } = nodes;
-    const isSourceBulletOrOrdered = sourceList.type === bulletList || sourceList.type === orderedList;
-    const isTargetTask = targetNodeType === taskList;
-    const isSourceTask = sourceList.type === taskList;
-    const newListItems = [];
-    const listStart = listPos;
-    const listEnd = listPos + sourceList.nodeSize;
-
-    // Use nodesBetween to efficiently traverse the list structure
-    tr.doc.nodesBetween(listStart, listEnd, (node, pos, parent) => {
-      // Only process direct children of the list (depth 1)
-      if (parent !== sourceList) {
-        return true; // Continue traversal
-      }
-      if (isSourceBulletOrOrdered && isTargetTask) {
-        // Converting from bullet/ordered list to task list
-        // Extract inline content from all children within listItem
-        if (node.type === listItem) {
-          const inlineContent = [];
-
-          // Extract all inline content from all child nodes
-          for (let i = 0; i < node.childCount; i++) {
-            const child = node.child(i);
-            if (child.type === paragraph) {
-              // Extract inline content from paragraphs
-              inlineContent.push(...extractInlineContent(child));
-            } else if (child.isBlock) {
-              // For other block content types eg. codeBlock, extract their text content and create text nodes
-              const textContent = child.textContent;
-              if (textContent) {
-                const textNode = tr.doc.type.schema.text(textContent);
-                inlineContent.push(textNode);
+    const isSourceBulletOrOrdered = isBulletOrOrderedList(sourceList.type);
+    const isTargetTask = isTaskList(targetNodeType);
+    const isSourceTask = isTaskList(sourceList.type);
+    const isTargetBulletOrOrdered = isBulletOrOrderedList(targetNodeType);
+    const supportedListTypes = getSupportedListTypesSet(nodes);
+    const transformListRecursively = listNode => {
+      const transformedItems = [];
+      listNode.forEach(child => {
+        if (isSourceBulletOrOrdered && isTargetTask) {
+          // Convert bullet/ordered => task
+          if (child.type === listItem) {
+            const inlineContent = [];
+            const nestedTaskLists = [];
+            child.forEach(grandChild => {
+              if (supportedListTypes.has(grandChild.type) && grandChild.type !== taskList) {
+                nestedTaskLists.push(transformListRecursively(grandChild));
+              } else {
+                inlineContent.push(...convertBlockToInlineContent(grandChild, tr.doc.type.schema));
               }
-            } else {
-              // Already inline content, add directly
-              inlineContent.push(child);
+            });
+            if (inlineContent.length > 0) {
+              transformedItems.push(taskItem.create(null, inlineContent));
             }
+            transformedItems.push(...nestedTaskLists);
           }
-          if (inlineContent.length > 0) {
-            const newItem = taskItem.create(null, inlineContent);
-            newListItems.push(newItem);
-          }
-        }
-      } else if (isSourceTask && !isTargetTask) {
-        // Converting from task list to bullet/ordered list
-        // Structure: taskItem > inline content -> listItem > paragraph > inline content
-        if (node.type === taskItem) {
-          const inlineContent = extractInlineContent(node);
-          if (inlineContent.length > 0) {
-            const paragraphNode = paragraph.create(null, inlineContent);
-            const newListItem = listItem.create(null, paragraphNode);
-            newListItems.push(newListItem);
+        } else if (isSourceTask && isTargetBulletOrOrdered) {
+          // Convert task => bullet/ordered
+          if (child.type === taskItem) {
+            const inlineContent = [...child.content.content];
+            if (inlineContent.length > 0) {
+              const paragraphNode = paragraph.create(null, inlineContent);
+              transformedItems.push(listItem.create(null, [paragraphNode]));
+            }
+          } else if (child.type === taskList) {
+            const transformedNestedList = transformListRecursively(child);
+            const lastItem = transformedItems[transformedItems.length - 1];
+            if ((lastItem === null || lastItem === void 0 ? void 0 : lastItem.type) === listItem) {
+              // Attach nested list to previous item
+              const updatedContent = [...lastItem.content.content, transformedNestedList];
+              transformedItems[transformedItems.length - 1] = listItem.create(lastItem.attrs, updatedContent);
+            } else {
+              // No previous item, flatten nested items
+              transformedItems.push(...transformedNestedList.content.content);
+            }
           }
         }
-      }
-      return false; // Don't traverse into children of list items
-    });
-    if (newListItems.length === 0) {
-      return tr;
-    }
-
-    // Create new list with transformed items
-    const newList = targetNodeType.create(null, newListItems);
-
-    // Replace the entire list
-    tr.replaceWith(listStart, listEnd, newList);
+      });
+      return targetNodeType.create(null, transformedItems);
+    };
+    const newList = transformListRecursively(sourceList);
+    tr.replaceWith(listPos, listPos + sourceList.nodeSize, newList);
     return tr;
   } catch {
     return tr;

package/dist/es2019/editor-commands/transforms/list/transformToTaskList.js

@@ -0,0 +1,38 @@
+/**
+ * Transform selection to task list
+ * Handles the special structure where taskItem contains text directly (no paragraph wrapper)
+ */
+export const transformToTaskList = (tr, range, targetNodeType, targetAttrs, nodes) => {
+  try {
+    const {
+      taskItem
+    } = nodes;
+    const listItems = [];
+
+    // Process each block in the range
+    tr.doc.nodesBetween(range.start, range.end, node => {
+      if (node.isBlock) {
+        // For block nodes like paragraphs, directly use their inline content
+        const inlineContent = [...node.content.content];
+        if (inlineContent.length > 0) {
+          // Create task item with inline content directly
+          const listItem = taskItem.create(targetAttrs, inlineContent);
+          listItems.push(listItem);
+        }
+      }
+      return false; // Don't traverse into children
+    });
+    if (listItems.length === 0) {
+      return null;
+    }
+
+    // Create the new task list
+    const newList = targetNodeType.create(targetAttrs, listItems);
+
+    // Replace the range with the new list
+    tr.replaceWith(range.start, range.end, newList);
+    return tr;
+  } catch {
+    return null;
+  }
+};

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

@@ -1,9 +1,9 @@
 import { findWrapping } from '@atlaskit/editor-prosemirror/transform';
-import { findParentNodeOfType } from '@atlaskit/editor-prosemirror/utils';
 import { transformListStructure } from './list/transformBetweenListTypes';
 import { transformOrderedUnorderedListToBlockNodes } from './list/transformOrderedUnorderedListToBlockNodes';
 import { transformTaskListToBlockNodes } from './list/transformTaskListToBlockNodes';
-import { isBlockNodeType, isContainerNodeType, isListNodeType } from './utils';
+import { transformToTaskList } from './list/transformToTaskList';
+import { getSupportedListTypesSet, isBulletOrOrderedList, isBlockNodeType, isContainerNodeType, isListNodeType, isTaskList } from './utils';
 
 /**
  * Transform selection to list type
@@ -11,6 +11,7 @@ import { isBlockNodeType, isContainerNodeType, isListNodeType } from './utils';
 export const transformBlockToList = context => {
   const {
     tr,
+    sourceNode,
     targetNodeType,
     targetAttrs
   } = context;
@@ -25,16 +26,14 @@ export const transformBlockToList = context => {
   const {
     nodes
   } = tr.doc.type.schema;
-  const isTargetTask = targetNodeType === nodes.taskList;
+  const isTargetTask = isTaskList(targetNodeType);
 
   // Handle task lists differently due to their structure
-  // TODO: ED-29152 - Implement task list transformation
   if (isTargetTask) {
-    return null;
+    return transformToTaskList(tr, range, targetNodeType, targetAttrs, nodes);
   }
 
   // For headings, convert to paragraph first since headings cannot be direct children of list items
-  const sourceNode = tr.doc.nodeAt(range.start);
   if (sourceNode && sourceNode.type.name.startsWith('heading')) {
     tr.setBlockType(range.start, range.end, nodes.paragraph);
   }
@@ -102,41 +101,52 @@ export const liftListToBlockType = () => {
 /**
  * Transform between different list types
  */
-export const transformBetweenListTypes = ({
-  tr,
-  targetNodeType
-}) => {
+export const transformBetweenListTypes = context => {
   const {
-    selection
-  } = tr;
+    tr,
+    sourceNode,
+    sourcePos,
+    targetNodeType
+  } = context;
   const {
     nodes
   } = tr.doc.type.schema;
-
-  // Find the list node - support bullet lists, ordered lists, and task lists
-  const supportedListTypes = [nodes.bulletList, nodes.orderedList, nodes.taskList].filter(Boolean); // Filter out undefined nodes in case some schemas don't have all types
-
-  const listNode = findParentNodeOfType(supportedListTypes)(selection);
-  if (!listNode) {
-    return null;
-  }
-  const sourceListType = listNode.node.type;
-  const isSourceBulletOrOrdered = sourceListType === nodes.bulletList || sourceListType === nodes.orderedList;
-  const isTargetTask = targetNodeType === nodes.taskList;
-  const isSourceTask = sourceListType === nodes.taskList;
-  const isTargetBulletOrOrdered = targetNodeType === nodes.bulletList || targetNodeType === nodes.orderedList;
+  const sourceListType = sourceNode.type;
+  const isSourceBulletOrOrdered = isBulletOrOrderedList(sourceListType);
+  const isTargetTask = isTaskList(targetNodeType);
+  const isSourceTask = isTaskList(sourceListType);
+  const isTargetBulletOrOrdered = isBulletOrOrderedList(targetNodeType);
 
   // Check if we need structure transformation
   const needsStructureTransform = isSourceBulletOrOrdered && isTargetTask || isSourceTask && isTargetBulletOrOrdered;
   try {
     if (!needsStructureTransform) {
       // Simple type change for same structure lists (bullet <-> ordered)
-      tr.setNodeMarkup(listNode.pos, targetNodeType);
+      // Apply to the main list
+      tr.setNodeMarkup(sourcePos, targetNodeType);
+
+      // Apply to nested lists
+      const listStart = sourcePos;
+      const listEnd = sourcePos + sourceNode.nodeSize;
+      const supportedListTypesSet = getSupportedListTypesSet(nodes);
+      tr.doc.nodesBetween(listStart, listEnd, (node, pos, parent) => {
+        // Only process nested lists (not the root list we already handled)
+        if (supportedListTypesSet.has(node.type) && pos !== sourcePos) {
+          const isNestedList = parent && (supportedListTypesSet.has(parent.type) || parent.type === nodes.listItem);
+          if (isNestedList) {
+            const shouldTransformNode = node.type === sourceListType || isBulletOrOrderedList(node.type) && isTargetBulletOrOrdered;
+            if (shouldTransformNode) {
+              tr.setNodeMarkup(pos, targetNodeType);
+            }
+          }
+        }
+        return true; // Continue traversing
+      });
+      return tr;
     } else {
-      tr = transformListStructure(tr, listNode, targetNodeType, nodes);
+      return transformListStructure(context);
     }
   } catch {
     return null;
   }
-  return tr;
 };

package/dist/es2019/editor-commands/transforms/utils.js

@@ -87,7 +87,7 @@ export const isBlockNode = node => {
   return ['paragraph', 'heading', 'codeBlock'].includes(node.type.name);
 };
 export const isListNode = node => {
-  return ['bulletList', 'orderedList', 'taskList', 'listItem'].includes(node.type.name);
+  return ['bulletList', 'orderedList', 'taskList'].includes(node.type.name);
 };
 export const isContainerNode = node => {
   return ['panel', 'expand', 'blockquote'].includes(node.type.name);
@@ -100,4 +100,18 @@ export const isListNodeType = nodeType => {
 };
 export const isContainerNodeType = nodeType => {
   return ['panel', 'expand', 'blockquote'].includes(nodeType.name);
+};
+
+// List type utilities
+export const isBulletOrOrderedList = nodeType => {
+  return nodeType.name === 'bulletList' || nodeType.name === 'orderedList';
+};
+export const isTaskList = nodeType => {
+  return nodeType.name === 'taskList';
+};
+export const getSupportedListTypes = nodes => {
+  return [nodes.bulletList, nodes.orderedList, nodes.taskList].filter(Boolean);
+};
+export const getSupportedListTypesSet = nodes => {
+  return new Set(getSupportedListTypes(nodes));
 };

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

@@ -54,7 +54,8 @@ const getFormatMenuComponents = () => {
         }),
         elemAfter: /*#__PURE__*/React.createElement(ChevronRightIcon, {
           label: 'example nested menu'
-        })
+        }),
+        enableMaxHeight: true
       }, children);
     }
   }, {

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

@@ -12,7 +12,7 @@ export var formatNode = function formatNode(targetType) {
 
     // Find the node to format from the current selection
     var nodeToFormat;
-    var nodePos = null;
+    var nodePos = selection.from;
 
     // Try to find the current node from selection
     var selectedNode = findSelectedNodeOfType([nodes.paragraph, nodes.heading, nodes.blockquote, nodes.panel, nodes.expand, nodes.codeBlock, nodes.bulletList, nodes.orderedList, nodes.taskList, nodes.layoutSection])(selection);
@@ -34,7 +34,7 @@ export var formatNode = function formatNode(targetType) {
             nodeToFormat = listParent.node;
             nodePos = listParent.pos;
           }
-        } else if (paragraphOrHeadingNode) {
+        } else if (parentNode.node.type !== nodes.blockquote && paragraphOrHeadingNode) {
           nodeToFormat = paragraphOrHeadingNode.node;
           nodePos = paragraphOrHeadingNode.pos;
         }

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

@@ -44,6 +44,7 @@ export var transformToContainer = function transformToContainer(_ref) {
  */
 export var transformContainerNode = function transformContainerNode(_ref2) {
   var tr = _ref2.tr,
+    sourceNode = _ref2.sourceNode,
     sourcePos = _ref2.sourcePos,
     targetNodeType = _ref2.targetNodeType,
     targetAttrs = _ref2.targetAttrs;
@@ -58,7 +59,13 @@ export var transformContainerNode = function transformContainerNode(_ref2) {
 
   // Transform container to list type
   if (isListNodeType(targetNodeType)) {
-    return unwrapAndConvertToList();
+    return unwrapAndConvertToList({
+      tr: tr,
+      sourceNode: sourceNode,
+      sourcePos: sourcePos,
+      targetNodeType: targetNodeType,
+      targetAttrs: targetAttrs
+    });
   }
 
   // Transform between container types
@@ -80,7 +87,56 @@ export var unwrapAndConvertToBlockType = function unwrapAndConvertToBlockType()
 /**
  * Unwrap container node and convert content to list
  */
-export var unwrapAndConvertToList = function unwrapAndConvertToList() {
-  // Convert to list directly
-  return null;
+export var unwrapAndConvertToList = function unwrapAndConvertToList(_ref3) {
+  var tr = _ref3.tr,
+    sourceNode = _ref3.sourceNode,
+    sourcePos = _ref3.sourcePos,
+    targetNodeType = _ref3.targetNodeType,
+    targetAttrs = _ref3.targetAttrs;
+  if (sourcePos === null) {
+    return tr;
+  }
+  var schema = tr.doc.type.schema;
+  var _schema$nodes = schema.nodes,
+    listItem = _schema$nodes.listItem,
+    paragraph = _schema$nodes.paragraph,
+    taskList = _schema$nodes.taskList,
+    taskItem = _schema$nodes.taskItem;
+  var isTargetTaskList = targetNodeType === taskList;
+  var createListItemFromInline = function createListItemFromInline(inlineFrag) {
+    return isTargetTaskList ? taskItem.create(null, inlineFrag) : listItem.create(null, paragraph.create(null, inlineFrag));
+  };
+  var getInlineContent = function getInlineContent(textblock) {
+    var inlineContent = [];
+    textblock.forEach(function (inline) {
+      inlineContent.push(inline);
+    });
+    return inlineContent;
+  };
+  var items = [];
+
+  // Expand's title should become the first item of the list
+  if (sourceNode.type.name === 'expand') {
+    var _sourceNode$attrs;
+    var title = (_sourceNode$attrs = sourceNode.attrs) === null || _sourceNode$attrs === void 0 ? void 0 : _sourceNode$attrs.title;
+    if (title) {
+      var titleContent = schema.text(title);
+      items.push(isTargetTaskList ? taskItem.create(null, titleContent) : listItem.create(null, paragraph.create(null, titleContent)));
+    }
+  }
+  for (var i = 0; i < sourceNode.childCount; i++) {
+    var node = sourceNode.child(i);
+
+    // Abort early if unsupported content (e.g. table) encounted inside of the container
+    if (!node.isTextblock) {
+      return tr;
+    }
+    var inline = Fragment.from(getInlineContent(node));
+    items.push(createListItemFromInline(inline));
+  }
+  if (!items.length) {
+    return tr;
+  }
+  var list = targetNodeType.create(targetAttrs || null, Fragment.from(items));
+  return tr.replaceWith(sourcePos, sourcePos + sourceNode.nodeSize, list);
 };

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

@@ -1,93 +1,92 @@
 import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import { getSupportedListTypesSet, isBulletOrOrderedList, isTaskList } from '../utils';
+
 /**
- * Extract all inline content from a node
+ * Convert a block node to inline content suitable for task items
  */
-var extractInlineContent = function extractInlineContent(node) {
-  var inlineContent = [];
-  for (var i = 0; i < node.childCount; i++) {
-    inlineContent.push(node.child(i));
+var convertBlockToInlineContent = function convertBlockToInlineContent(node, schema) {
+  var paragraph = schema.nodes.paragraph;
+  if (node.type === paragraph) {
+    return _toConsumableArray(node.content.content);
+  }
+  if (node.isBlock) {
+    var textContent = node.textContent;
+    return textContent ? [schema.text(textContent)] : [];
   }
-  return inlineContent;
+  return [node];
 };
 
 /**
- * Transform list structure
+ * Transform list structure between different list types
  */
-export var transformListStructure = function transformListStructure(tr, listNode, targetNodeType, nodes) {
+export var transformListStructure = function transformListStructure(context) {
+  var tr = context.tr,
+    sourceNode = context.sourceNode,
+    sourcePos = context.sourcePos,
+    targetNodeType = context.targetNodeType;
+  var nodes = tr.doc.type.schema.nodes;
   try {
+    var listNode = {
+      node: sourceNode,
+      pos: sourcePos
+    };
     var sourceList = listNode.node,
       listPos = listNode.pos;
-    var bulletList = nodes.bulletList,
-      orderedList = nodes.orderedList,
-      taskList = nodes.taskList,
+    var taskList = nodes.taskList,
       listItem = nodes.listItem,
       taskItem = nodes.taskItem,
       paragraph = nodes.paragraph;
-    var isSourceBulletOrOrdered = sourceList.type === bulletList || sourceList.type === orderedList;
-    var isTargetTask = targetNodeType === taskList;
-    var isSourceTask = sourceList.type === taskList;
-    var newListItems = [];
-    var listStart = listPos;
-    var listEnd = listPos + sourceList.nodeSize;
-
-    // Use nodesBetween to efficiently traverse the list structure
-    tr.doc.nodesBetween(listStart, listEnd, function (node, pos, parent) {
-      // Only process direct children of the list (depth 1)
-      if (parent !== sourceList) {
-        return true; // Continue traversal
-      }
-      if (isSourceBulletOrOrdered && isTargetTask) {
-        // Converting from bullet/ordered list to task list
-        // Extract inline content from all children within listItem
-        if (node.type === listItem) {
-          var inlineContent = [];
-
-          // Extract all inline content from all child nodes
-          for (var i = 0; i < node.childCount; i++) {
-            var child = node.child(i);
-            if (child.type === paragraph) {
-              // Extract inline content from paragraphs
-              inlineContent.push.apply(inlineContent, _toConsumableArray(extractInlineContent(child)));
-            } else if (child.isBlock) {
-              // For other block content types eg. codeBlock, extract their text content and create text nodes
-              var textContent = child.textContent;
-              if (textContent) {
-                var textNode = tr.doc.type.schema.text(textContent);
-                inlineContent.push(textNode);
+    var isSourceBulletOrOrdered = isBulletOrOrderedList(sourceList.type);
+    var isTargetTask = isTaskList(targetNodeType);
+    var isSourceTask = isTaskList(sourceList.type);
+    var isTargetBulletOrOrdered = isBulletOrOrderedList(targetNodeType);
+    var supportedListTypes = getSupportedListTypesSet(nodes);
+    var _transformListRecursively = function transformListRecursively(listNode) {
+      var transformedItems = [];
+      listNode.forEach(function (child) {
+        if (isSourceBulletOrOrdered && isTargetTask) {
+          // Convert bullet/ordered => task
+          if (child.type === listItem) {
+            var inlineContent = [];
+            var nestedTaskLists = [];
+            child.forEach(function (grandChild) {
+              if (supportedListTypes.has(grandChild.type) && grandChild.type !== taskList) {
+                nestedTaskLists.push(_transformListRecursively(grandChild));
+              } else {
+                inlineContent.push.apply(inlineContent, _toConsumableArray(convertBlockToInlineContent(grandChild, tr.doc.type.schema)));
               }
-            } else {
-              // Already inline content, add directly
-              inlineContent.push(child);
+            });
+            if (inlineContent.length > 0) {
+              transformedItems.push(taskItem.create(null, inlineContent));
             }
+            transformedItems.push.apply(transformedItems, nestedTaskLists);
           }
-          if (inlineContent.length > 0) {
-            var newItem = taskItem.create(null, inlineContent);
-            newListItems.push(newItem);
-          }
-        }
-      } else if (isSourceTask && !isTargetTask) {
-        // Converting from task list to bullet/ordered list
-        // Structure: taskItem > inline content -> listItem > paragraph > inline content
-        if (node.type === taskItem) {
-          var _inlineContent = extractInlineContent(node);
-          if (_inlineContent.length > 0) {
-            var paragraphNode = paragraph.create(null, _inlineContent);
-            var newListItem = listItem.create(null, paragraphNode);
-            newListItems.push(newListItem);
+        } else if (isSourceTask && isTargetBulletOrOrdered) {
+          // Convert task => bullet/ordered
+          if (child.type === taskItem) {
+            var _inlineContent = _toConsumableArray(child.content.content);
+            if (_inlineContent.length > 0) {
+              var paragraphNode = paragraph.create(null, _inlineContent);
+              transformedItems.push(listItem.create(null, [paragraphNode]));
+            }
+          } else if (child.type === taskList) {
+            var transformedNestedList = _transformListRecursively(child);
+            var lastItem = transformedItems[transformedItems.length - 1];
+            if ((lastItem === null || lastItem === void 0 ? void 0 : lastItem.type) === listItem) {
+              // Attach nested list to previous item
+              var updatedContent = [].concat(_toConsumableArray(lastItem.content.content), [transformedNestedList]);
+              transformedItems[transformedItems.length - 1] = listItem.create(lastItem.attrs, updatedContent);
+            } else {
+              // No previous item, flatten nested items
+              transformedItems.push.apply(transformedItems, _toConsumableArray(transformedNestedList.content.content));
+            }
           }
         }
-      }
-      return false; // Don't traverse into children of list items
-    });
-    if (newListItems.length === 0) {
-      return tr;
-    }
-
-    // Create new list with transformed items
-    var newList = targetNodeType.create(null, newListItems);
-
-    // Replace the entire list
-    tr.replaceWith(listStart, listEnd, newList);
+      });
+      return targetNodeType.create(null, transformedItems);
+    };
+    var newList = _transformListRecursively(sourceList);
+    tr.replaceWith(listPos, listPos + sourceList.nodeSize, newList);
     return tr;
   } catch (_unused) {
     return tr;