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

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # @atlaskit/editor-plugin-block-menu
 
+## 1.0.13
+
+### Patch Changes
+
+- [`c24edcf83432c`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/c24edcf83432c) -
+  [ux] ED-29147 Add functionality to convert layout to nodes
+- Updated dependencies
+
+## 1.0.12
+
+### Patch Changes
+
+- [`6e27819feadc7`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/6e27819feadc7) -
+  ED-29183: Fixed aligned p and heading not able to convert to list
+- [`6a9265f5389db`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/6a9265f5389db) -
+  Fix container transform with blockquote containing list
+- [`24e0d952943aa`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/24e0d952943aa) -
+  ED-29206: Fixed conversion from code block to panel, expand text formatting issue
+- Updated dependencies
+
 ## 1.0.11
 
 ### Patch Changes

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

@@ -41,7 +41,7 @@ var transformToBlockNode = function transformToBlockNode(context) {
     $to = selection.$to;
   var schema = doc.type.schema;
   if (targetNodeType === schema.nodes.codeBlock) {
-    var textContent = (0, _inlineNodeTransforms.getInlineNodeTextContent)(selection.content().content, tr);
+    var textContent = (0, _inlineNodeTransforms.getInlineNodeTextNode)(selection.content().content, schema);
     var node = schema.nodes.codeBlock.createChecked(undefined, textContent);
     return tr.replaceRangeWith(selection.from, selection.to, node);
   }

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

@@ -20,19 +20,6 @@ var convertInvalidNodeToValidNodeType = function convertInvalidNodeToValidNodeTy
   });
   return _model.Fragment.from(validTransformedContent);
 };
-var 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);
-};
 
 /**
  * Transform selection to container type
@@ -47,7 +34,8 @@ var transformToContainer = exports.transformToContainer = function transformToCo
   var content = selection.content().content;
   var transformedContent = content;
   if (sourceNode.type === schema.nodes.codeBlock) {
-    transformedContent = convertInvalidNodeToValidNodeType(transformedContent, schema.nodes.codeBlock, schema.nodes.paragraph);
+    var paragraphNodes = (0, _utils.convertCodeBlockContentToParagraphs)(sourceNode, schema);
+    transformedContent = _model.Fragment.fromArray(paragraphNodes);
   }
   if (targetNodeType === schema.nodes.blockquote) {
     transformedContent = convertInvalidNodeToValidNodeType(transformedContent, schema.nodes.heading, schema.nodes.paragraph, true);
@@ -57,7 +45,7 @@ var transformToContainer = exports.transformToContainer = function transformToCo
   // e.g. blocks (heading/ paragraph) with alignment need to remove alignment
   // as panel/ blockQuote/ expands does not support alignment
   if (sourceNode.type === schema.nodes.paragraph || sourceNode.type === schema.nodes.heading) {
-    transformedContent = filterMarksForTargetNodeType(transformedContent, targetNodeType);
+    transformedContent = (0, _utils.filterMarksForTargetNodeType)(transformedContent, targetNodeType);
   }
   var newNode = targetNodeType.createAndFill(targetAttrs, transformedContent);
   if (!newNode) {
@@ -158,12 +146,7 @@ var unwrapAndConvertToBlockType = exports.unwrapAndConvertToBlockType = function
 
   // if the container is a code block, convert text content to multiple paragraphs
   if (sourceNode.type === codeBlock) {
-    var codeText = sourceNode.textContent;
-    var lines = codeText.split('\n');
-    var paragraphNodes = lines.map(function (line) {
-      return paragraph.create(null, line ? schema.text(line) : null);
-    });
-    sourceChildren = paragraphNodes;
+    sourceChildren = (0, _utils.convertCodeBlockContentToParagraphs)(sourceNode, schema);
   }
 
   // if target node is a paragraph, just do unwrap
@@ -400,15 +383,15 @@ var splitContentAroundUnsupportedBlocks = function splitContentAroundUnsupported
     if (isContentSupported(childNode)) {
       // Supported content - add to current container
       currentContainerContent.push(childNode);
-    } else if ((0, _utils.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(function (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
       var inlineContent = (0, _utils.convertNodeToInlineContent)(childNode, schema);

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

@@ -3,12 +3,11 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.getInlineNodeTextContent = void 0;
-var getInlineNodeTextContent = exports.getInlineNodeTextContent = function getInlineNodeTextContent(sourceContent, tr) {
+exports.getInlineNodeTextNode = exports.getInlineNodeTextContent = void 0;
+var getInlineNodeTextContent = exports.getInlineNodeTextContent = function getInlineNodeTextContent(sourceContent) {
   var validTransformedContent = '';
-  var 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(function (node) {
@@ -20,8 +19,11 @@ var getInlineNodeTextContent = exports.getInlineNodeTextContent = function getIn
           validTransformedContent += "".concat(inlineNode.textContent);
         }
       });
-      validTransformedContent;
     }
   });
-  return schema.text(validTransformedContent);
+  return validTransformedContent;
+};
+var getInlineNodeTextNode = exports.getInlineNodeTextNode = function getInlineNodeTextNode(sourceContent, schema) {
+  var text = getInlineNodeTextContent(sourceContent);
+  return schema.text(text);
 };

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

@@ -0,0 +1,289 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.unwrapLayoutNodesToTextNodes = exports.transformToListNode = exports.convertUnwrappedLayoutContent = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _model = require("@atlaskit/editor-prosemirror/model");
+var _utils = require("@atlaskit/editor-prosemirror/utils");
+var _inlineNodeTransforms = require("../inline-node-transforms");
+var _transformBetweenListTypes = require("../list/transformBetweenListTypes");
+var _utils2 = require("../utils");
+var unwrapLayoutNodesToTextNodes = exports.unwrapLayoutNodesToTextNodes = function unwrapLayoutNodesToTextNodes(context, finalTargetNodeType) {
+  var tr = context.tr,
+    sourceNode = context.sourceNode,
+    targetNodeType = context.targetNodeType,
+    targetAttrs = context.targetAttrs;
+  var schema = tr.doc.type.schema || {};
+  var isValid = (0, _utils2.getContentSupportChecker)(finalTargetNodeType);
+  var createTextNode = function createTextNode(node) {
+    var isTextNode = node.type.name === 'text';
+    if (isValid(node) && !isTextNode) {
+      return node;
+    }
+    return targetNodeType.createChecked(targetAttrs, isTextNode ? node : node.content, node.marks);
+  };
+  if ((0, _utils2.isBlockNode)(sourceNode)) {
+    // code block acts like a container, we need to unwrap it
+    if (sourceNode.type === schema.nodes.codeBlock) {
+      var textNodes = sourceNode.textContent.split('\n').map(function (line) {
+        return targetNodeType.createChecked(undefined, line ? schema.text(line) : null);
+      });
+      return textNodes;
+    }
+    return [createTextNode(sourceNode)];
+  }
+  if ((0, _utils2.isContainerNode)(sourceNode)) {
+    var _sourceNode$attrs;
+    var 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(function (childNode) {
+      if ((0, _utils2.isHeadingOrParagraphNode)(childNode)) {
+        containerNodes.push(createTextNode(childNode));
+        return;
+      }
+      containerNodes.push(childNode);
+    });
+    return containerNodes;
+  }
+  if ((0, _utils2.isListNode)(sourceNode)) {
+    if ((0, _utils2.isBlockNodeType)(finalTargetNodeType)) {
+      if (sourceNode.type.name === 'taskList') {
+        var taskItemsResult = (0, _utils.findChildrenByType)(sourceNode, schema.nodes.taskItem);
+        var taskItems = taskItemsResult.map(function (item) {
+          return item.node;
+        });
+        var taskItemFragments = taskItems.map(function (taskItem) {
+          return taskItem.content;
+        });
+        return taskItemFragments.map(function (fragment) {
+          return targetNodeType.createChecked(targetAttrs, fragment.content);
+        });
+      } else {
+        var paragraphs = (0, _utils.findChildrenByType)(sourceNode, schema.nodes.paragraph);
+        var paragraphNodes = paragraphs.map(function (paragraph) {
+          return paragraph.node;
+        });
+        if (targetNodeType === schema.nodes.heading) {
+          return paragraphNodes.map(function (paragraphNode) {
+            return targetNodeType.createChecked(targetAttrs, paragraphNode.content);
+          });
+        }
+        return paragraphNodes;
+      }
+    }
+    return [sourceNode];
+  }
+  return [sourceNode];
+};
+var transformToBlockNode = function transformToBlockNode(nodes, targetNodeType, schema) {
+  if (targetNodeType === schema.nodes.codeBlock) {
+    var newNodes = [];
+    nodes.forEach(function (node) {
+      if (node.isTextblock) {
+        var inlineTextContent = node.type === schema.nodes.codeBlock ? node.textContent : (0, _inlineNodeTransforms.getInlineNodeTextContent)(_model.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
+          var lastItem = newNodes[newNodes.length - 1];
+          if (lastItem.canBeTransformed) {
+            newNodes[newNodes.length - 1] = {
+              content: [].concat((0, _toConsumableArray2.default)(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(function (_ref) {
+      var canBeTransformed = _ref.canBeTransformed,
+        content = _ref.content;
+      if (canBeTransformed) {
+        var text = content.join('\n');
+        if (text === '') {
+          return undefined;
+        }
+        return targetNodeType.createChecked(null, schema.text(text));
+      } else {
+        return content;
+      }
+    }).filter(Boolean);
+  }
+  return nodes;
+};
+var transformToContainerNode = function transformToContainerNode(nodes, targetNodeType) {
+  var newNodes = [];
+  var isNodeValid = (0, _utils2.getContentSupportChecker)(targetNodeType);
+  nodes.forEach(function (node) {
+    // If the node is not supported then we append as is
+    if ((0, _utils2.isBlockNodeForExtraction)(node)) {
+      newNodes.push({
+        node: node,
+        canBeTransformed: false
+      });
+    } else {
+      // Remove alignment marks as container nodes don't support them
+      var nodeWithValidAttrs = node.mark(node.marks.filter(function (mark) {
+        return mark.type.name !== 'alignment';
+      }));
+      var 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;
+      }
+      var _nodes = isSameNodeType ? node.content.content : [nodeWithValidAttrs];
+      if (newNodes.length === 0) {
+        newNodes.push({
+          node: _nodes,
+          canBeTransformed: true
+        });
+      } else {
+        var lastItem = newNodes[newNodes.length - 1];
+        if (lastItem.canBeTransformed) {
+          newNodes[newNodes.length - 1] = {
+            node: [].concat((0, _toConsumableArray2.default)(lastItem.node), (0, _toConsumableArray2.default)(_nodes)),
+            canBeTransformed: true
+          };
+        } else {
+          newNodes.push({
+            node: _nodes,
+            canBeTransformed: true
+          });
+        }
+      }
+    }
+  });
+  return newNodes.map(function (_ref2) {
+    var node = _ref2.node,
+      canBeTransformed = _ref2.canBeTransformed;
+    if (canBeTransformed) {
+      return targetNodeType.createChecked(null, _model.Fragment.fromArray(node));
+    } else {
+      return node;
+    }
+  });
+};
+var transformToListNode = exports.transformToListNode = function transformToListNode(nodes, targetNodeType, schema) {
+  var isTargetTask = (0, _utils2.isTaskList)(targetNodeType);
+  var listItems = [];
+  var listItemType = isTargetTask ? schema.nodes.taskItem : schema.nodes.listItem;
+  var isValid = (0, _utils2.getContentSupportChecker)(listItemType);
+  nodes.forEach(function (node) {
+    // Append unsupported nodes as is
+    if ((0, _utils2.isBlockNodeForExtraction)(node)) {
+      listItems.push({
+        canBeTransformed: false,
+        node: node
+      });
+    } else {
+      var newListItems;
+
+      // If the node is a list, we may need to transform it
+      if ((0, _utils2.isListNode)(node)) {
+        var isSourceBulletOrOrdered = (0, _utils2.isBulletOrOrderedList)(node.type);
+        var _isTargetTask = (0, _utils2.isTaskList)(targetNodeType);
+        var isSourceTask = (0, _utils2.isTaskList)(node.type);
+        var isTargetBulletOrOrdered = (0, _utils2.isBulletOrOrderedList)(targetNodeType);
+        var supportedListTypes = (0, _utils2.getSupportedListTypesSet)(schema.nodes);
+        if (node.type === targetNodeType) {
+          // For the same list type, we can keep the structure
+          newListItems = node.content.content;
+        } else {
+          var newList = (0, _transformBetweenListTypes.transformListRecursively)({
+            isSourceBulletOrOrdered: isSourceBulletOrOrdered,
+            isSourceTask: isSourceTask,
+            isTargetBulletOrOrdered: isTargetBulletOrOrdered,
+            isTargetTask: _isTargetTask,
+            listNode: node,
+            schema: schema,
+            supportedListTypes: supportedListTypes,
+            targetNodeType: targetNodeType
+          });
+          newListItems = (0, _toConsumableArray2.default)(newList.content.content);
+        }
+      } else if ((0, _utils2.isHeadingOrParagraphNode)(node) || isValid(node)) {
+        if (isTargetTask) {
+          var inlineContent = (0, _toConsumableArray2.default)(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: node
+        });
+      }
+      if (newListItems) {
+        if (listItems.length === 0) {
+          listItems.push({
+            canBeTransformed: true,
+            node: newListItems
+          });
+        } else {
+          var lastItem = listItems[listItems.length - 1];
+          if (lastItem.canBeTransformed) {
+            listItems[listItems.length - 1] = {
+              node: [].concat((0, _toConsumableArray2.default)(lastItem.node), (0, _toConsumableArray2.default)(newListItems)),
+              canBeTransformed: true
+            };
+          } else {
+            listItems.push({
+              node: newListItems,
+              canBeTransformed: true
+            });
+          }
+        }
+      }
+    }
+  });
+  return listItems.map(function (_ref3) {
+    var node = _ref3.node,
+      canBeTransformed = _ref3.canBeTransformed;
+    if (canBeTransformed) {
+      return targetNodeType.createChecked(null, _model.Fragment.fromArray(node));
+    } else {
+      return node;
+    }
+  });
+};
+var convertUnwrappedLayoutContent = exports.convertUnwrappedLayoutContent = function convertUnwrappedLayoutContent(nodes, targetNodeType, schema) {
+  if ((0, _utils2.isBlockNodeType)(targetNodeType)) {
+    return transformToBlockNode(nodes, targetNodeType, schema);
+  }
+  if ((0, _utils2.isContainerNodeType)(targetNodeType)) {
+    return transformToContainerNode(nodes, targetNodeType);
+  }
+  if ((0, _utils2.isListNodeType)(targetNodeType)) {
+    return transformToListNode(nodes, targetNodeType, schema);
+  }
+  return [];
+};

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

@@ -1,11 +1,14 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.convertToLayout = void 0;
+exports.transformLayoutNode = exports.convertToLayout = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 var _styles = require("@atlaskit/editor-common/styles");
 var _model = require("@atlaskit/editor-prosemirror/model");
+var _utils = require("./layout/utils");
 var convertToLayout = exports.convertToLayout = function convertToLayout(context) {
   var tr = context.tr,
     sourceNode = context.sourceNode,
@@ -25,6 +28,41 @@ var convertToLayout = exports.convertToLayout = function convertToLayout(context
   var 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;
+};
+var transformLayoutNode = exports.transformLayoutNode = function transformLayoutNode(context) {
+  var tr = context.tr,
+    sourceNode = context.sourceNode,
+    targetNodeType = context.targetNodeType,
+    sourcePos = context.sourcePos,
+    targetAttrs = context.targetAttrs;
+  var schema = tr.doc.type.schema || {};
+  var _ref2 = schema.nodes || {},
+    layoutSection = _ref2.layoutSection,
+    layoutColumn = _ref2.layoutColumn,
+    paragraph = _ref2.paragraph,
+    heading = _ref2.heading;
+  var layoutColumnNodes = [];
+  var targetTextNodeType = targetNodeType === heading ? heading : paragraph;
+  sourceNode.children.forEach(function (child) {
+    if (child.type === layoutColumn) {
+      var unwrappedContent = [];
+      child.content.forEach(function (node) {
+        // Unwrap all nodes and convert to text nodes
+        var context = {
+          tr: tr,
+          sourceNode: node,
+          targetNodeType: targetTextNodeType,
+          sourcePos: 0,
+          targetAttrs: targetAttrs
+        };
+        var newContent = (0, _utils.unwrapLayoutNodesToTextNodes)(context, targetNodeType);
+        unwrappedContent.push.apply(unwrappedContent, (0, _toConsumableArray2.default)(newContent));
+      });
+      var newColumnContent = (0, _utils.convertUnwrappedLayoutContent)(unwrappedContent, targetNodeType, schema);
+      layoutColumnNodes.push(layoutColumn.createChecked(child.attrs, _model.Fragment.fromArray(newColumnContent), child.marks));
+    }
+  });
+  return tr.replaceRangeWith(sourcePos, sourcePos + sourceNode.nodeSize, layoutSection.createChecked(sourceNode.attrs, _model.Fragment.fromArray(layoutColumnNodes), sourceNode.marks));
 };

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

@@ -4,9 +4,12 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.transformListStructure = void 0;
+exports.transformListStructure = exports.transformListRecursively = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 var _utils = require("../utils");
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2.default)(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 /**
  * Convert a block node to inline content suitable for task items
  */
@@ -21,6 +24,82 @@ var convertBlockToInlineContent = function convertBlockToInlineContent(node, sch
   }
   return [node];
 };
+var _transformListRecursively = exports.transformListRecursively = function transformListRecursively(props) {
+  var transformedItems = [];
+  var listNode = props.listNode,
+    isSourceBulletOrOrdered = props.isSourceBulletOrOrdered,
+    isTargetBulletOrOrdered = props.isTargetBulletOrOrdered,
+    isSourceTask = props.isSourceTask,
+    isTargetTask = props.isTargetTask,
+    supportedListTypes = props.supportedListTypes,
+    schema = props.schema,
+    targetNodeType = props.targetNodeType;
+  var _schema$nodes = schema.nodes,
+    taskList = _schema$nodes.taskList,
+    listItem = _schema$nodes.listItem,
+    taskItem = _schema$nodes.taskItem,
+    paragraph = _schema$nodes.paragraph;
+  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(_objectSpread(_objectSpread({}, props), {}, {
+              listNode: grandChild
+            })));
+          } else {
+            inlineContent.push.apply(inlineContent, (0, _toConsumableArray2.default)(convertBlockToInlineContent(grandChild, schema)));
+          }
+        });
+        if (inlineContent.length > 0) {
+          transformedItems.push(taskItem.create(null, inlineContent));
+        }
+        transformedItems.push.apply(transformedItems, nestedTaskLists);
+      }
+    } else if (isSourceTask && isTargetBulletOrOrdered) {
+      // Convert task => bullet/ordered
+      if (child.type === taskItem) {
+        var _inlineContent = (0, _toConsumableArray2.default)(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(_objectSpread(_objectSpread({}, props), {}, {
+          listNode: 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((0, _toConsumableArray2.default)(lastItem.content.content), [transformedNestedList]);
+          transformedItems[transformedItems.length - 1] = listItem.create(lastItem.attrs, updatedContent);
+        } else {
+          // No previous item, flatten nested items
+          transformedItems.push.apply(transformedItems, (0, _toConsumableArray2.default)(transformedNestedList.content.content));
+        }
+      }
+    } else if (isSourceBulletOrOrdered && isTargetBulletOrOrdered) {
+      if (child.type === listItem) {
+        var convertedNestedLists = [];
+        child.forEach(function (grandChild) {
+          if (supportedListTypes.has(grandChild.type) && grandChild.type !== targetNodeType) {
+            var convertedNode = _transformListRecursively(_objectSpread(_objectSpread({}, 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
@@ -38,60 +117,23 @@ var transformListStructure = exports.transformListStructure = function transform
     };
     var sourceList = listNode.node,
       listPos = listNode.pos;
-    var taskList = nodes.taskList,
-      listItem = nodes.listItem,
-      taskItem = nodes.taskItem,
-      paragraph = nodes.paragraph;
+    // const { taskList, listItem, taskItem, paragraph } = nodes;
+
     var isSourceBulletOrOrdered = (0, _utils.isBulletOrOrderedList)(sourceList.type);
     var isTargetTask = (0, _utils.isTaskList)(targetNodeType);
     var isSourceTask = (0, _utils.isTaskList)(sourceList.type);
     var isTargetBulletOrOrdered = (0, _utils.isBulletOrOrderedList)(targetNodeType);
     var supportedListTypes = (0, _utils.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, (0, _toConsumableArray2.default)(convertBlockToInlineContent(grandChild, tr.doc.type.schema)));
-              }
-            });
-            if (inlineContent.length > 0) {
-              transformedItems.push(taskItem.create(null, inlineContent));
-            }
-            transformedItems.push.apply(transformedItems, nestedTaskLists);
-          }
-        } else if (isSourceTask && isTargetBulletOrOrdered) {
-          // Convert task => bullet/ordered
-          if (child.type === taskItem) {
-            var _inlineContent = (0, _toConsumableArray2.default)(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((0, _toConsumableArray2.default)(lastItem.content.content), [transformedNestedList]);
-              transformedItems[transformedItems.length - 1] = listItem.create(lastItem.attrs, updatedContent);
-            } else {
-              // No previous item, flatten nested items
-              transformedItems.push.apply(transformedItems, (0, _toConsumableArray2.default)(transformedNestedList.content.content));
-            }
-          }
-        }
-      });
-      return targetNodeType.create(null, transformedItems);
-    };
-    var newList = _transformListRecursively(sourceList);
+    var newList = _transformListRecursively({
+      isSourceBulletOrOrdered: isSourceBulletOrOrdered,
+      isSourceTask: isSourceTask,
+      isTargetBulletOrOrdered: isTargetBulletOrOrdered,
+      isTargetTask: isTargetTask,
+      listNode: sourceList,
+      schema: tr.doc.type.schema,
+      supportedListTypes: supportedListTypes,
+      targetNodeType: targetNodeType
+    });
     tr.replaceWith(listPos, listPos + sourceList.nodeSize, newList);
     return tr;
   } catch (_unused) {

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

@@ -24,6 +24,7 @@ var transformBlockToList = exports.transformBlockToList = function transformBloc
   var _tr$selection = tr.selection,
     $from = _tr$selection.$from,
     $to = _tr$selection.$to;
+  var schema = tr.doc.type.schema;
   var range = $from.blockRange($to);
   if (!range) {
     return null;
@@ -36,6 +37,12 @@ var transformBlockToList = exports.transformBlockToList = function transformBloc
     return (0, _transformToTaskList.transformToTaskList)(tr, range, targetNodeType, targetAttrs, nodes);
   }
 
+  // filter marks that are not allowed in the target node type
+  if (sourceNode.type === schema.nodes.paragraph || sourceNode.type === schema.nodes.heading) {
+    var allowedMarks = targetNodeType.allowedMarks(sourceNode.marks);
+    tr.setNodeMarkup(range.start, null, null, allowedMarks);
+  }
+
   // For headings, convert to paragraph first since headings cannot be direct children of list items
   if (sourceNode && sourceNode.type.name.startsWith('heading')) {
     tr.setBlockType(range.start, range.end, nodes.paragraph);