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

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @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

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/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/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.filterMarksForTargetNodeType = exports.convertNodeToInlineContent = exports.convertCodeBlockContentToParagraphs = 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

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