@atlaskit/editor-plugin-block-menu 1.0.11 → 1.0.13

package/dist/cjs/editor-commands/transforms/transformNodeToTargetType.js

@@ -52,6 +52,9 @@ function transformNodeToTargetType(tr, sourceNode, sourcePos, targetType) {
     if (sourceNode.type.name === 'codeBlock' && (0, _utils.isListNodeType)(targetNodeType)) {
       return (0, _containerTransforms.unwrapAndConvertToList)(transformationContext);
     }
+    if ((0, _utils.isLayoutNode)(sourceNode)) {
+      return (0, _layoutTransforms.transformLayoutNode)(transformationContext);
+    }
     if ((0, _utils.isBlockNode)(sourceNode)) {
       return (0, _blockTransforms.transformBlockNode)(transformationContext);
     }

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

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.isTaskList = exports.isListNodeType = exports.isListNode = exports.isLayoutNodeType = exports.isContainerNodeType = exports.isContainerNode = exports.isBulletOrOrderedList = exports.isBlockNodeType = exports.isBlockNodeForExtraction = exports.isBlockNode = exports.getTargetNodeInfo = exports.getSupportedListTypesSet = exports.getSupportedListTypes = exports.getContentSupportChecker = exports.convertNodeToInlineContent = void 0;
+exports.isTaskList = exports.isListNodeType = exports.isListNode = exports.isLayoutNodeType = exports.isLayoutNode = exports.isHeadingOrParagraphNode = exports.isContainerNodeType = exports.isContainerNode = exports.isBulletOrOrderedList = exports.isBlockNodeType = exports.isBlockNodeForExtraction = exports.isBlockNode = exports.getTargetNodeInfo = exports.getSupportedListTypesSet = exports.getSupportedListTypes = exports.getContentSupportChecker = exports.filterMarksForTargetNodeType = exports.convertNodeToInlineContent = exports.convertCodeBlockContentToParagraphs = void 0;
 var _model = require("@atlaskit/editor-prosemirror/model");
 var getTargetNodeInfo = exports.getTargetNodeInfo = function getTargetNodeInfo(targetType, nodes) {
   switch (targetType) {
@@ -97,6 +97,9 @@ var getTargetNodeInfo = exports.getTargetNodeInfo = function getTargetNodeInfo(t
 var isBlockNode = exports.isBlockNode = function isBlockNode(node) {
   return ['paragraph', 'heading', 'codeBlock'].includes(node.type.name);
 };
+var isHeadingOrParagraphNode = exports.isHeadingOrParagraphNode = function isHeadingOrParagraphNode(node) {
+  return ['paragraph', 'heading'].includes(node.type.name);
+};
 var isListNode = exports.isListNode = function isListNode(node) {
   return ['bulletList', 'orderedList', 'taskList'].includes(node.type.name);
 };
@@ -129,6 +132,9 @@ var getSupportedListTypesSet = exports.getSupportedListTypesSet = function getSu
 var isLayoutNodeType = exports.isLayoutNodeType = function isLayoutNodeType(nodeType) {
   return nodeType.name === 'layoutSection';
 };
+var isLayoutNode = exports.isLayoutNode = function isLayoutNode(node) {
+  return node.type.name === 'layoutSection';
+};
 
 /**
  * Check if a node should be extracted as a standalone block node
@@ -174,4 +180,37 @@ var convertNodeToInlineContent = exports.convertNodeToInlineContent = function c
     return [schema.text(node.textContent)];
   }
   return inlineNodes;
+};
+
+/**
+ * Filter marks from content based on the target node type
+ * @param content The content fragment to filter
+ * @param targetNodeType The target node type to check against
+ * @returns A new fragment with marks filtered for the target node type
+ */
+var filterMarksForTargetNodeType = exports.filterMarksForTargetNodeType = function filterMarksForTargetNodeType(content, targetNodeType) {
+  var withValidMarks = [];
+  content.forEach(function (node) {
+    if (node.marks.length > 0) {
+      var allowedMarks = targetNodeType.allowedMarks(node.marks);
+      var updatedNode = node.mark(allowedMarks);
+      withValidMarks.push(updatedNode);
+    } else {
+      withValidMarks.push(node);
+    }
+  });
+  return _model.Fragment.from(withValidMarks);
+};
+
+/** * Convert content from a code block node into multiple paragraph nodes
+ */
+var convertCodeBlockContentToParagraphs = exports.convertCodeBlockContentToParagraphs = function convertCodeBlockContentToParagraphs(codeBlockNode, schema) {
+  var paragraphNodes = [];
+  var codeText = codeBlockNode.textContent;
+  var lines = codeText.split('\n');
+  lines.forEach(function (line) {
+    var paragraphNode = schema.nodes.paragraph.create(null, line ? schema.text(line) : null);
+    paragraphNodes.push(paragraphNode);
+  });
+  return paragraphNodes;
 };

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

@@ -1,5 +1,5 @@
 import { transformToContainer, unwrapAndConvertToBlockType } from './container-transforms';
-import { getInlineNodeTextContent } from './inline-node-transforms';
+import { getInlineNodeTextNode } from './inline-node-transforms';
 import { transformBlockToList } from './list-transforms';
 import { isListNodeType, isContainerNodeType, isBlockNodeType } from './utils';
 
@@ -44,7 +44,7 @@ const transformToBlockNode = context => {
   } = selection;
   const schema = doc.type.schema;
   if (targetNodeType === schema.nodes.codeBlock) {
-    const textContent = getInlineNodeTextContent(selection.content().content, tr);
+    const textContent = getInlineNodeTextNode(selection.content().content, schema);
     const node = schema.nodes.codeBlock.createChecked(undefined, textContent);
     return tr.replaceRangeWith(selection.from, selection.to, node);
   }

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

@@ -1,5 +1,5 @@
 import { Fragment, Slice } from '@atlaskit/editor-prosemirror/model';
-import { isBlockNodeType, isListNodeType, isContainerNodeType, isBlockNodeForExtraction, convertNodeToInlineContent, getContentSupportChecker } from './utils';
+import { isBlockNodeType, isListNodeType, isContainerNodeType, isBlockNodeForExtraction, convertNodeToInlineContent, getContentSupportChecker, convertCodeBlockContentToParagraphs, filterMarksForTargetNodeType } from './utils';
 const convertInvalidNodeToValidNodeType = (sourceContent, sourceNodeType, validNodeType, withMarks) => {
   const validTransformedContent = [];
   // Headings are not valid inside headings so convert heading nodes to paragraphs
@@ -12,19 +12,6 @@ const convertInvalidNodeToValidNodeType = (sourceContent, sourceNodeType, validN
   });
   return Fragment.from(validTransformedContent);
 };
-const filterMarksForTargetNodeType = (content, targetNodeType) => {
-  const withValidMarks = [];
-  content.forEach(node => {
-    if (node.marks.length > 0) {
-      const allowedMarks = targetNodeType.allowedMarks(node.marks);
-      const updatedNode = node.mark(allowedMarks);
-      withValidMarks.push(updatedNode);
-    } else {
-      withValidMarks.push(node);
-    }
-  });
-  return Fragment.from(withValidMarks);
-};
 
 /**
  * Transform selection to container type
@@ -40,7 +27,8 @@ export const transformToContainer = ({
   const content = selection.content().content;
   let transformedContent = content;
   if (sourceNode.type === schema.nodes.codeBlock) {
-    transformedContent = convertInvalidNodeToValidNodeType(transformedContent, schema.nodes.codeBlock, schema.nodes.paragraph);
+    const paragraphNodes = convertCodeBlockContentToParagraphs(sourceNode, schema);
+    transformedContent = Fragment.fromArray(paragraphNodes);
   }
   if (targetNodeType === schema.nodes.blockquote) {
     transformedContent = convertInvalidNodeToValidNodeType(transformedContent, schema.nodes.heading, schema.nodes.paragraph, true);
@@ -157,10 +145,7 @@ export const unwrapAndConvertToBlockType = context => {
 
   // if the container is a code block, convert text content to multiple paragraphs
   if (sourceNode.type === codeBlock) {
-    const codeText = sourceNode.textContent;
-    const lines = codeText.split('\n');
-    const paragraphNodes = lines.map(line => paragraph.create(null, line ? schema.text(line) : null));
-    sourceChildren = paragraphNodes;
+    sourceChildren = convertCodeBlockContentToParagraphs(sourceNode, schema);
   }
 
   // if target node is a paragraph, just do unwrap
@@ -399,15 +384,15 @@ const splitContentAroundUnsupportedBlocks = (sourceNode, isContentSupported, tar
     if (isContentSupported(childNode)) {
       // Supported content - add to current container
       currentContainerContent.push(childNode);
-    } else if (isBlockNodeForExtraction(childNode)) {
-      // Unsupported block node - flush current container, add block, continue
-      flushCurrentContainer();
-      splits.push(childNode);
     } else if (childNode.type.name === targetNodeType.name) {
       // Same type of container merge contents
       childNode.content.forEach(child => {
         currentContainerContent.push(child);
       });
+    } else if (childNode.isBlock) {
+      // Unsupported block node - flush current container, add block, continue
+      flushCurrentContainer();
+      splits.push(childNode);
     } else {
       // Unsupported inline content - convert to paragraph and add to container
       const inlineContent = convertNodeToInlineContent(childNode, schema);

package/dist/es2019/editor-commands/transforms/inline-node-transforms.js

@@ -1,8 +1,7 @@
-export const getInlineNodeTextContent = (sourceContent, tr) => {
+export const getInlineNodeTextContent = sourceContent => {
   let validTransformedContent = '';
-  const schema = tr.doc.type.schema;
-  if (sourceContent.content.length > 1) {
-    return;
+  if (sourceContent.content.length < 1) {
+    return '';
   }
   // Headings are not valid inside headings so convert heading nodes to paragraphs
   sourceContent.forEach(node => {
@@ -14,8 +13,11 @@ export const getInlineNodeTextContent = (sourceContent, tr) => {
           validTransformedContent += `${inlineNode.textContent}`;
         }
       });
-      validTransformedContent;
     }
   });
-  return schema.text(validTransformedContent);
+  return validTransformedContent;
+};
+export const getInlineNodeTextNode = (sourceContent, schema) => {
+  const text = getInlineNodeTextContent(sourceContent);
+  return schema.text(text);
 };

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

@@ -0,0 +1,272 @@
+import { Fragment } from '@atlaskit/editor-prosemirror/model';
+import { findChildrenByType } from '@atlaskit/editor-prosemirror/utils';
+import { getInlineNodeTextContent } from '../inline-node-transforms';
+import { transformListRecursively } from '../list/transformBetweenListTypes';
+import { getContentSupportChecker, getSupportedListTypesSet, isBlockNode, isBlockNodeForExtraction, isBlockNodeType, isBulletOrOrderedList, isContainerNode, isContainerNodeType, isHeadingOrParagraphNode, isListNode, isListNodeType, isTaskList } from '../utils';
+export const unwrapLayoutNodesToTextNodes = (context, finalTargetNodeType) => {
+  const {
+    tr,
+    sourceNode,
+    targetNodeType,
+    targetAttrs
+  } = context;
+  const schema = tr.doc.type.schema || {};
+  const isValid = getContentSupportChecker(finalTargetNodeType);
+  const createTextNode = node => {
+    const isTextNode = node.type.name === 'text';
+    if (isValid(node) && !isTextNode) {
+      return node;
+    }
+    return targetNodeType.createChecked(targetAttrs, isTextNode ? node : node.content, node.marks);
+  };
+  if (isBlockNode(sourceNode)) {
+    // code block acts like a container, we need to unwrap it
+    if (sourceNode.type === schema.nodes.codeBlock) {
+      const textNodes = sourceNode.textContent.split('\n').map(line => targetNodeType.createChecked(undefined, line ? schema.text(line) : null));
+      return textNodes;
+    }
+    return [createTextNode(sourceNode)];
+  }
+  if (isContainerNode(sourceNode)) {
+    var _sourceNode$attrs;
+    const containerNodes = [];
+    if (sourceNode.type.name === 'expand' && (_sourceNode$attrs = sourceNode.attrs) !== null && _sourceNode$attrs !== void 0 && _sourceNode$attrs.title) {
+      containerNodes.push(createTextNode(schema.text(sourceNode.attrs.title)));
+    }
+    sourceNode.content.forEach(childNode => {
+      if (isHeadingOrParagraphNode(childNode)) {
+        containerNodes.push(createTextNode(childNode));
+        return;
+      }
+      containerNodes.push(childNode);
+    });
+    return containerNodes;
+  }
+  if (isListNode(sourceNode)) {
+    if (isBlockNodeType(finalTargetNodeType)) {
+      if (sourceNode.type.name === 'taskList') {
+        const taskItemsResult = findChildrenByType(sourceNode, schema.nodes.taskItem);
+        const taskItems = taskItemsResult.map(item => item.node);
+        const taskItemFragments = taskItems.map(taskItem => taskItem.content);
+        return taskItemFragments.map(fragment => targetNodeType.createChecked(targetAttrs, fragment.content));
+      } else {
+        const paragraphs = findChildrenByType(sourceNode, schema.nodes.paragraph);
+        const paragraphNodes = paragraphs.map(paragraph => paragraph.node);
+        if (targetNodeType === schema.nodes.heading) {
+          return paragraphNodes.map(paragraphNode => targetNodeType.createChecked(targetAttrs, paragraphNode.content));
+        }
+        return paragraphNodes;
+      }
+    }
+    return [sourceNode];
+  }
+  return [sourceNode];
+};
+const transformToBlockNode = (nodes, targetNodeType, schema) => {
+  if (targetNodeType === schema.nodes.codeBlock) {
+    const newNodes = [];
+    nodes.forEach(node => {
+      if (node.isTextblock) {
+        const inlineTextContent = node.type === schema.nodes.codeBlock ? node.textContent : getInlineNodeTextContent(Fragment.from(node));
+
+        // For first node, add directly
+        if (newNodes.length === 0) {
+          newNodes.push({
+            canBeTransformed: true,
+            content: [inlineTextContent]
+          });
+        } else {
+          // Check if last node can also be transformed, if yes then append content
+          const lastItem = newNodes[newNodes.length - 1];
+          if (lastItem.canBeTransformed) {
+            newNodes[newNodes.length - 1] = {
+              content: [...lastItem.content, inlineTextContent],
+              canBeTransformed: true
+            };
+          } else {
+            newNodes.push({
+              content: [inlineTextContent],
+              canBeTransformed: true
+            });
+          }
+        }
+      } else {
+        // If not text block, then cannot be transformed
+        newNodes.push({
+          canBeTransformed: false,
+          content: node
+        });
+      }
+    });
+    return newNodes.map(({
+      canBeTransformed,
+      content
+    }) => {
+      if (canBeTransformed) {
+        const text = content.join('\n');
+        if (text === '') {
+          return undefined;
+        }
+        return targetNodeType.createChecked(null, schema.text(text));
+      } else {
+        return content;
+      }
+    }).filter(Boolean);
+  }
+  return nodes;
+};
+const transformToContainerNode = (nodes, targetNodeType) => {
+  const newNodes = [];
+  const isNodeValid = getContentSupportChecker(targetNodeType);
+  nodes.forEach(node => {
+    // If the node is not supported then we append as is
+    if (isBlockNodeForExtraction(node)) {
+      newNodes.push({
+        node: node,
+        canBeTransformed: false
+      });
+    } else {
+      // Remove alignment marks as container nodes don't support them
+      const nodeWithValidAttrs = node.mark(node.marks.filter(mark => mark.type.name !== 'alignment'));
+      const isSameNodeType = node.type === targetNodeType;
+
+      // If the node is not valid and not the same type, we cannot transform it
+      if (!isNodeValid(nodeWithValidAttrs) && !isSameNodeType) {
+        newNodes.push({
+          node: node,
+          canBeTransformed: false
+        });
+        return;
+      }
+      const nodes = isSameNodeType ? node.content.content : [nodeWithValidAttrs];
+      if (newNodes.length === 0) {
+        newNodes.push({
+          node: nodes,
+          canBeTransformed: true
+        });
+      } else {
+        const lastItem = newNodes[newNodes.length - 1];
+        if (lastItem.canBeTransformed) {
+          newNodes[newNodes.length - 1] = {
+            node: [...lastItem.node, ...nodes],
+            canBeTransformed: true
+          };
+        } else {
+          newNodes.push({
+            node: nodes,
+            canBeTransformed: true
+          });
+        }
+      }
+    }
+  });
+  return newNodes.map(({
+    node,
+    canBeTransformed
+  }) => {
+    if (canBeTransformed) {
+      return targetNodeType.createChecked(null, Fragment.fromArray(node));
+    } else {
+      return node;
+    }
+  });
+};
+export const transformToListNode = (nodes, targetNodeType, schema) => {
+  const isTargetTask = isTaskList(targetNodeType);
+  const listItems = [];
+  const listItemType = isTargetTask ? schema.nodes.taskItem : schema.nodes.listItem;
+  const isValid = getContentSupportChecker(listItemType);
+  nodes.forEach(node => {
+    // Append unsupported nodes as is
+    if (isBlockNodeForExtraction(node)) {
+      listItems.push({
+        canBeTransformed: false,
+        node
+      });
+    } else {
+      let newListItems;
+
+      // If the node is a list, we may need to transform it
+      if (isListNode(node)) {
+        const isSourceBulletOrOrdered = isBulletOrOrderedList(node.type);
+        const isTargetTask = isTaskList(targetNodeType);
+        const isSourceTask = isTaskList(node.type);
+        const isTargetBulletOrOrdered = isBulletOrOrderedList(targetNodeType);
+        const supportedListTypes = getSupportedListTypesSet(schema.nodes);
+        if (node.type === targetNodeType) {
+          // For the same list type, we can keep the structure
+          newListItems = node.content.content;
+        } else {
+          const newList = transformListRecursively({
+            isSourceBulletOrOrdered,
+            isSourceTask,
+            isTargetBulletOrOrdered,
+            isTargetTask,
+            listNode: node,
+            schema,
+            supportedListTypes,
+            targetNodeType
+          });
+          newListItems = [...newList.content.content];
+        }
+      } else if (isHeadingOrParagraphNode(node) || isValid(node)) {
+        if (isTargetTask) {
+          const inlineContent = [...node.content.content];
+          if (inlineContent.length > 0) {
+            newListItems = [listItemType.create(null, inlineContent)];
+          }
+        } else {
+          newListItems = [listItemType.create(null, node)];
+        }
+      } else if (!isValid(node)) {
+        listItems.push({
+          canBeTransformed: false,
+          node
+        });
+      }
+      if (newListItems) {
+        if (listItems.length === 0) {
+          listItems.push({
+            canBeTransformed: true,
+            node: newListItems
+          });
+        } else {
+          const lastItem = listItems[listItems.length - 1];
+          if (lastItem.canBeTransformed) {
+            listItems[listItems.length - 1] = {
+              node: [...lastItem.node, ...newListItems],
+              canBeTransformed: true
+            };
+          } else {
+            listItems.push({
+              node: newListItems,
+              canBeTransformed: true
+            });
+          }
+        }
+      }
+    }
+  });
+  return listItems.map(({
+    node,
+    canBeTransformed
+  }) => {
+    if (canBeTransformed) {
+      return targetNodeType.createChecked(null, Fragment.fromArray(node));
+    } else {
+      return node;
+    }
+  });
+};
+export const convertUnwrappedLayoutContent = (nodes, targetNodeType, schema) => {
+  if (isBlockNodeType(targetNodeType)) {
+    return transformToBlockNode(nodes, targetNodeType, schema);
+  }
+  if (isContainerNodeType(targetNodeType)) {
+    return transformToContainerNode(nodes, targetNodeType);
+  }
+  if (isListNodeType(targetNodeType)) {
+    return transformToListNode(nodes, targetNodeType, schema);
+  }
+  return [];
+};

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

@@ -1,5 +1,6 @@
 import { DEFAULT_TWO_COLUMN_LAYOUT_COLUMN_WIDTH } from '@atlaskit/editor-common/styles';
 import { Fragment } from '@atlaskit/editor-prosemirror/model';
+import { convertUnwrappedLayoutContent, unwrapLayoutNodesToTextNodes } from './layout/utils';
 export const convertToLayout = context => {
   const {
     tr,
@@ -20,6 +21,44 @@ export const convertToLayout = context => {
   const layoutSectionNode = layoutSection.createChecked(undefined, layoutContent);
 
   // Replace the original node with the new layout node
-  tr.replaceRangeWith(sourcePos || 0, (sourcePos || 0) + sourceNode.nodeSize, layoutSectionNode);
+  tr.replaceRangeWith(sourcePos, sourcePos + sourceNode.nodeSize, layoutSectionNode);
   return tr;
+};
+export const transformLayoutNode = context => {
+  const {
+    tr,
+    sourceNode,
+    targetNodeType,
+    sourcePos,
+    targetAttrs
+  } = context;
+  const schema = tr.doc.type.schema || {};
+  const {
+    layoutSection,
+    layoutColumn,
+    paragraph,
+    heading
+  } = schema.nodes || {};
+  const layoutColumnNodes = [];
+  const targetTextNodeType = targetNodeType === heading ? heading : paragraph;
+  sourceNode.children.forEach(child => {
+    if (child.type === layoutColumn) {
+      const unwrappedContent = [];
+      child.content.forEach(node => {
+        // Unwrap all nodes and convert to text nodes
+        const context = {
+          tr,
+          sourceNode: node,
+          targetNodeType: targetTextNodeType,
+          sourcePos: 0,
+          targetAttrs
+        };
+        const newContent = unwrapLayoutNodesToTextNodes(context, targetNodeType);
+        unwrappedContent.push(...newContent);
+      });
+      const newColumnContent = convertUnwrappedLayoutContent(unwrappedContent, targetNodeType, schema);
+      layoutColumnNodes.push(layoutColumn.createChecked(child.attrs, Fragment.fromArray(newColumnContent), child.marks));
+    }
+  });
+  return tr.replaceRangeWith(sourcePos, sourcePos + sourceNode.nodeSize, layoutSection.createChecked(sourceNode.attrs, Fragment.fromArray(layoutColumnNodes), sourceNode.marks));
 };

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

@@ -16,6 +16,88 @@ const convertBlockToInlineContent = (node, schema) => {
   }
   return [node];
 };
+export const transformListRecursively = props => {
+  const transformedItems = [];
+  const {
+    listNode,
+    isSourceBulletOrOrdered,
+    isTargetBulletOrOrdered,
+    isSourceTask,
+    isTargetTask,
+    supportedListTypes,
+    schema,
+    targetNodeType
+  } = props;
+  const {
+    taskList,
+    listItem,
+    taskItem,
+    paragraph
+  } = schema.nodes;
+  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({
+              ...props,
+              listNode: grandChild
+            }));
+          } else {
+            inlineContent.push(...convertBlockToInlineContent(grandChild, schema));
+          }
+        });
+        if (inlineContent.length > 0) {
+          transformedItems.push(taskItem.create(null, inlineContent));
+        }
+        transformedItems.push(...nestedTaskLists);
+      }
+    } 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({
+          ...props,
+          listNode: 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);
+        }
+      }
+    } else if (isSourceBulletOrOrdered && isTargetBulletOrOrdered) {
+      if (child.type === listItem) {
+        const convertedNestedLists = [];
+        child.forEach(grandChild => {
+          if (supportedListTypes.has(grandChild.type) && grandChild.type !== targetNodeType) {
+            const convertedNode = transformListRecursively({
+              ...props,
+              listNode: grandChild
+            });
+            convertedNestedLists.push(convertedNode);
+          } else {
+            convertedNestedLists.push(grandChild);
+          }
+        });
+        transformedItems.push(listItem.create(null, convertedNestedLists));
+      }
+    }
+  });
+  return targetNodeType.create(null, transformedItems);
+};
 
 /**
  * Transform list structure between different list types
@@ -37,62 +119,23 @@ export const transformListStructure = context => {
       node: sourceList,
       pos: listPos
     } = listNode;
-    const {
-      taskList,
-      listItem,
-      taskItem,
-      paragraph
-    } = nodes;
+    // const { taskList, listItem, taskItem, paragraph } = nodes;
+
     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));
-              }
-            });
-            if (inlineContent.length > 0) {
-              transformedItems.push(taskItem.create(null, inlineContent));
-            }
-            transformedItems.push(...nestedTaskLists);
-          }
-        } 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 targetNodeType.create(null, transformedItems);
-    };
-    const newList = transformListRecursively(sourceList);
+    const newList = transformListRecursively({
+      isSourceBulletOrOrdered,
+      isSourceTask,
+      isTargetBulletOrOrdered,
+      isTargetTask,
+      listNode: sourceList,
+      schema: tr.doc.type.schema,
+      supportedListTypes,
+      targetNodeType
+    });
     tr.replaceWith(listPos, listPos + sourceList.nodeSize, newList);
     return tr;
   } catch {