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

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

@@ -1,5 +1,6 @@
 import { transformToContainer } from './container-transforms';
-import { transformToList } from './list-transforms';
+import { getInlineNodeTextContent } from './inline-node-transforms';
+import { transformBlockToList } from './list-transforms';
 import { isListNodeType, isContainerNodeType, isBlockNodeType } from './utils';
 
 /**
@@ -7,32 +8,45 @@ import { isListNodeType, isContainerNodeType, isBlockNodeType } from './utils';
  */
 export const transformBlockNode = context => {
   const {
-    tr,
-    targetNodeType,
-    targetAttrs
+    targetNodeType
   } = context;
-  const {
-    selection
-  } = tr;
-  const {
-    $from,
-    $to
-  } = selection;
 
   // Handle transformation to list types
   if (isListNodeType(targetNodeType)) {
-    return transformToList(context);
+    return transformBlockToList(context);
   }
 
   // Handle transformation to container types (panel, expand, blockquote)
   if (isContainerNodeType(targetNodeType)) {
-    return transformToContainer();
+    return transformToContainer(context);
   }
 
   // Handle block type transformation (paragraph, heading, codeblock)
   if (isBlockNodeType(targetNodeType)) {
-    tr.setBlockType($from.pos, $to.pos, targetNodeType, targetAttrs);
-    return tr;
+    return transformToBlockNode(context);
   }
   return null;
+};
+const transformToBlockNode = context => {
+  const {
+    tr,
+    targetNodeType,
+    targetAttrs
+  } = context;
+  const {
+    selection,
+    doc
+  } = tr;
+  const {
+    $from,
+    $to
+  } = selection;
+  const schema = doc.type.schema;
+  if (targetNodeType === schema.nodes.codeBlock) {
+    const textContent = getInlineNodeTextContent(selection.content().content, tr);
+    const node = schema.nodes.codeBlock.createChecked(undefined, textContent);
+    return tr.replaceRangeWith(selection.from, selection.to, node);
+  }
+  tr.setBlockType($from.pos, $to.pos, targetNodeType, targetAttrs);
+  return tr;
 };

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

@@ -1,10 +1,43 @@
+import { Fragment } from '@atlaskit/editor-prosemirror/model';
 import { isBlockNodeType, isListNodeType, isContainerNodeType } from './utils';
+const convertInvalidNodeToValidNodeType = (sourceContent, sourceNodeType, validNodeType, withMarks) => {
+  const validTransformedContent = [];
+  // Headings are not valid inside headings so convert heading nodes to paragraphs
+  sourceContent.forEach(node => {
+    if (sourceNodeType === node.type) {
+      validTransformedContent.push(validNodeType.createChecked(node.attrs, node.content, withMarks ? node.marks : undefined));
+    } else {
+      validTransformedContent.push(node);
+    }
+  });
+  return Fragment.from(validTransformedContent);
+};
 
 /**
  * Transform selection to container type
  */
-export const transformToContainer = () => {
-  return null;
+export const transformToContainer = ({
+  tr,
+  sourceNode,
+  targetNodeType,
+  targetAttrs
+}) => {
+  const selection = tr.selection;
+  const schema = tr.doc.type.schema;
+  const content = selection.content().content;
+  let transformedContent = content;
+  if (sourceNode.type === schema.nodes.codeBlock) {
+    transformedContent = convertInvalidNodeToValidNodeType(transformedContent, schema.nodes.codeBlock, schema.nodes.paragraph);
+  }
+  if (targetNodeType === schema.nodes.blockquote) {
+    transformedContent = convertInvalidNodeToValidNodeType(transformedContent, schema.nodes.heading, schema.nodes.paragraph, true);
+  }
+  const newNode = targetNodeType.createAndFill(targetAttrs, transformedContent);
+  if (!newNode) {
+    return null;
+  }
+  tr.replaceRangeWith(selection.from, selection.to, newNode);
+  return tr;
 };
 
 /**

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

@@ -0,0 +1,21 @@
+export const getInlineNodeTextContent = (sourceContent, tr) => {
+  let validTransformedContent = '';
+  const schema = tr.doc.type.schema;
+  if (sourceContent.content.length > 1) {
+    return;
+  }
+  // Headings are not valid inside headings so convert heading nodes to paragraphs
+  sourceContent.forEach(node => {
+    if (['paragraph', 'heading'].includes(node.type.name)) {
+      node.content.forEach(inlineNode => {
+        if (inlineNode.type.name === 'status') {
+          validTransformedContent += inlineNode.attrs.text;
+        } else {
+          validTransformedContent += `${inlineNode.textContent}`;
+        }
+      });
+      validTransformedContent;
+    }
+  });
+  return schema.text(validTransformedContent);
+};

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

@@ -0,0 +1,98 @@
+/**
+ * Extract all inline content from a node
+ */
+const extractInlineContent = node => {
+  const inlineContent = [];
+  for (let i = 0; i < node.childCount; i++) {
+    inlineContent.push(node.child(i));
+  }
+  return inlineContent;
+};
+
+/**
+ * Transform list structure
+ */
+export const transformListStructure = (tr, listNode, targetNodeType, nodes) => {
+  try {
+    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);
+              }
+            } else {
+              // Already inline content, add directly
+              inlineContent.push(child);
+            }
+          }
+          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);
+          }
+        }
+      }
+      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 tr;
+  } catch {
+    return tr;
+  }
+};

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

@@ -0,0 +1,42 @@
+import { Fragment, Slice } from '@atlaskit/editor-prosemirror/model';
+import { findChildrenByType } from '@atlaskit/editor-prosemirror/utils';
+export const transformOrderedUnorderedListToBlockNodes = context => {
+  const {
+    tr,
+    targetNodeType,
+    targetAttrs,
+    sourceNode,
+    sourcePos
+  } = context;
+  const {
+    selection
+  } = tr;
+  const schema = selection.$from.doc.type.schema;
+  // find all paragraph nodes inside the list node
+  const paragraphs = findChildrenByType(sourceNode, schema.nodes.paragraph);
+  const paragraphNodes = paragraphs.map(paragraph => paragraph.node);
+  let targetNodes = paragraphNodes;
+
+  // Convert paragraphs to headings if target is heading
+  if (targetNodeType === schema.nodes.heading && targetAttrs) {
+    const targetHeadingLevel = targetAttrs.level;
+    targetNodes = paragraphNodes.map(paragraphNode => schema.nodes.heading.createChecked({
+      level: targetHeadingLevel
+    }, paragraphNode.content));
+  }
+
+  // Convert paragraphs to code block if target is code block
+  if (targetNodeType === schema.nodes.codeBlock) {
+    // convert the paragraphNodes to one code block
+    const listItemsResult = findChildrenByType(sourceNode, schema.nodes.listItem);
+    const listItems = listItemsResult.map(item => item.node);
+    const listItemFragments = listItems.map(listItem => listItem.content);
+    const codeBlockContent = listItemFragments.map(fragment => fragment.textBetween(0, fragment.size, '\n')).join('\n');
+    targetNodes = [schema.nodes.codeBlock.createChecked({}, schema.text(codeBlockContent))];
+  }
+  const fragment = Fragment.fromArray(targetNodes);
+  const slice = new Slice(fragment, 0, 0);
+  const rangeStart = sourcePos !== null ? sourcePos : selection.from;
+  tr.replaceRange(rangeStart, rangeStart + sourceNode.nodeSize, slice);
+  return tr;
+};

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

@@ -0,0 +1,47 @@
+import { Fragment, Slice } from '@atlaskit/editor-prosemirror/model';
+import { findChildrenByType } from '@atlaskit/editor-prosemirror/utils';
+export const transformTaskListToBlockNodes = context => {
+  const {
+    tr,
+    targetNodeType,
+    targetAttrs,
+    sourceNode,
+    sourcePos
+  } = context;
+  const {
+    selection
+  } = tr;
+  const schema = selection.$from.doc.type.schema;
+  const taskItemsResult = findChildrenByType(sourceNode, schema.nodes.taskItem);
+  const taskItems = taskItemsResult.map(item => item.node);
+  const taskItemFragments = taskItems.map(taskItem => taskItem.content);
+  let targetNodes = [];
+
+  // Convert fragments to headings if target is heading
+  if (targetNodeType === schema.nodes.heading && targetAttrs) {
+    // convert the fragments to headings
+    const targetHeadingLevel = targetAttrs.level;
+    targetNodes = taskItemFragments.map(fragment => schema.nodes.heading.createChecked({
+      level: targetHeadingLevel
+    }, fragment.content));
+  }
+
+  // Convert fragments to paragraphs if target is paragraphs
+  if (targetNodeType === schema.nodes.paragraph) {
+    // convert the fragments to paragraphs
+    targetNodes = taskItemFragments.map(fragment => schema.nodes.paragraph.createChecked({}, fragment.content));
+  }
+
+  // Convert fragments to code block if target is code block
+  if (targetNodeType === schema.nodes.codeBlock) {
+    // convert the fragments to one code block
+    const codeBlockContent = taskItemFragments.map(fragment => fragment.textBetween(0, fragment.size, '\n')).join('\n');
+    targetNodes = [schema.nodes.codeBlock.createChecked({}, schema.text(codeBlockContent))];
+  }
+
+  // Replace the task list node with the new content in the transaction
+  const slice = new Slice(Fragment.fromArray(targetNodes), 0, 0);
+  const rangeStart = sourcePos !== null ? sourcePos : selection.from;
+  tr.replaceRange(rangeStart, rangeStart + sourceNode.nodeSize, slice);
+  return tr;
+};

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

@@ -1,16 +1,19 @@
 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';
 
 /**
  * Transform selection to list type
  */
-export const transformToList = ({
-  tr,
-  targetNodeType,
-  targetAttrs
-}) => {
-  // Wrap selection in list of target type
+export const transformBlockToList = context => {
+  const {
+    tr,
+    targetNodeType,
+    targetAttrs
+  } = context;
   const {
     $from,
     $to
@@ -19,16 +22,49 @@ export const transformToList = ({
   if (!range) {
     return null;
   }
+  const {
+    nodes
+  } = tr.doc.type.schema;
+  const isTargetTask = targetNodeType === nodes.taskList;
+
+  // Handle task lists differently due to their structure
+  // TODO: ED-29152 - Implement task list transformation
+  if (isTargetTask) {
+    return null;
+  }
+
+  // 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);
+  }
 
-  // Find if we can wrap the selection in the target list type
-  const wrapping = findWrapping(range, targetNodeType, targetAttrs);
+  // Get the current range (updated if we converted from heading)
+  const currentRange = tr.selection.$from.blockRange(tr.selection.$to) || range;
+
+  // Wrap in the target list type
+  const wrapping = findWrapping(currentRange, targetNodeType, targetAttrs);
   if (!wrapping) {
     return null;
   }
-  tr.wrap(range, wrapping);
+  tr.wrap(currentRange, wrapping);
   return tr;
 };
 
+/**
+ * Transform list to block nodes
+ */
+export const transformListToBlockNodes = context => {
+  const {
+    sourceNode
+  } = context;
+  if (sourceNode.type.name === 'taskList') {
+    return transformTaskListToBlockNodes(context);
+  } else {
+    return transformOrderedUnorderedListToBlockNodes(context);
+  }
+};
+
 /**
  * Transform list nodes
  */
@@ -39,7 +75,7 @@ export const transformListNode = context => {
   // Transform list to block type
   if (isBlockNodeType(targetNodeType)) {
     // Lift list items out of the list and convert to target block type
-    return null;
+    return transformListToBlockNodes(context);
   }
 
   // Transform list to container type
@@ -77,16 +113,30 @@ export const transformBetweenListTypes = ({
     nodes
   } = tr.doc.type.schema;
 
-  // Find the list node
-  const listNode = findParentNodeOfType([nodes.bulletList, nodes.orderedList, nodes.taskList])(selection);
+  // 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;
+
+  // Check if we need structure transformation
+  const needsStructureTransform = isSourceBulletOrOrdered && isTargetTask || isSourceTask && isTargetBulletOrOrdered;
   try {
-    // Change the list type while preserving content
-    tr.setNodeMarkup(listNode.pos, targetNodeType);
-    return tr;
-  } catch (e) {
+    if (!needsStructureTransform) {
+      // Simple type change for same structure lists (bullet <-> ordered)
+      tr.setNodeMarkup(listNode.pos, targetNodeType);
+    } else {
+      tr = transformListStructure(tr, listNode, targetNodeType, nodes);
+    }
+  } catch {
     return null;
   }
+  return tr;
 };

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

@@ -3,7 +3,6 @@ import { MOVE_UP_MENU_ITEM, MOVE_UP_DOWN_MENU_SECTION, MOVE_DOWN_MENU_ITEM, MOVE
 import { ToolbarDropdownItemSection, ToolbarNestedDropdownMenu } from '@atlaskit/editor-toolbar';
 import ChangesIcon from '@atlaskit/icon/core/changes';
 import ChevronRightIcon from '@atlaskit/icon/core/chevron-right';
-import { fg } from '@atlaskit/platform-feature-flags';
 import CopyBlockMenuItem from './copy-block';
 import { CopyLinkDropdownItem } from './copy-link';
 import { DeleteDropdownItem } from './delete-button';
@@ -88,7 +87,7 @@ export const getBlockMenuComponents = ({
   api,
   config
 }) => {
-  return [...(fg('platform_editor_block_menu_format') ? getFormatMenuComponents() : []), {
+  return [...getFormatMenuComponents(), {
     type: 'block-menu-section',
     key: COPY_MENU_SECTION.key,
     rank: BLOCK_MENU_SECTION_RANK[COPY_MENU_SECTION.key],

package/dist/es2019/ui/block-menu.compiled.css

@@ -1,3 +1,3 @@
 
-._2rkoglpi{border-radius:var(--ds-border-radius,4px)}._16qs1cd0{box-shadow:var(--ds-shadow-overlay,0 8px 9pt #091e4226,0 0 1px #091e424f)}
+._2rko12b0{border-radius:var(--ds-radius-small,4px)}._16qs1cd0{box-shadow:var(--ds-shadow-overlay,0 8px 9pt #091e4226,0 0 1px #091e424f)}
 ._bfhk1bhr{background-color:var(--ds-surface-overlay,#fff)}

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

@@ -13,7 +13,7 @@ import { ToolbarDropdownItem, ToolbarDropdownItemSection, ToolbarNestedDropdownM
 import { Box } from '@atlaskit/primitives/compiled';
 import { BlockMenuRenderer } from './block-menu-renderer';
 const styles = {
-  base: "_2rkoglpi _bfhk1bhr _16qs1cd0"
+  base: "_2rko12b0 _bfhk1bhr _16qs1cd0"
 };
 const DEFAULT_MENU_WIDTH = 230;
 const DRAG_HANDLE_OFFSET_PADDING = 5;

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

@@ -21,19 +21,22 @@ export var formatNode = function formatNode(targetType) {
       nodePos = selectedNode.pos;
     } else {
       // Try to find parent node (including list parents)
-      var parentNode = findParentNodeOfType([nodes.blockquote, nodes.panel, nodes.expand, nodes.codeBlock, nodes.listItem, nodes.layoutSection])(selection);
+      var parentNode = findParentNodeOfType([nodes.blockquote, nodes.panel, nodes.expand, nodes.codeBlock, nodes.listItem, nodes.taskItem, nodes.layoutSection])(selection);
       if (parentNode) {
         nodeToFormat = parentNode.node;
         nodePos = parentNode.pos;
-
+        var paragraphOrHeadingNode = findParentNodeOfType([nodes.paragraph, nodes.heading])(selection);
         // Special case: if we found a listItem, check if we need the parent list instead
-        if (parentNode.node.type === nodes.listItem) {
+        if (parentNode.node.type === nodes.listItem || parentNode.node.type === nodes.taskItem) {
           var listParent = findParentNodeOfType([nodes.bulletList, nodes.orderedList, nodes.taskList])(selection);
           if (listParent) {
             // For list transformations, we want the list parent, not the listItem
             nodeToFormat = listParent.node;
             nodePos = listParent.pos;
           }
+        } else if (paragraphOrHeadingNode) {
+          nodeToFormat = paragraphOrHeadingNode.node;
+          nodePos = paragraphOrHeadingNode.pos;
         }
       }
     }

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

@@ -1,32 +1,44 @@
 import { transformToContainer } from './container-transforms';
-import { transformToList } from './list-transforms';
+import { getInlineNodeTextContent } from './inline-node-transforms';
+import { transformBlockToList } from './list-transforms';
 import { isListNodeType, isContainerNodeType, isBlockNodeType } from './utils';
 
 /**
  * Transform block nodes (paragraph, heading, codeblock)
  */
 export var transformBlockNode = function transformBlockNode(context) {
-  var tr = context.tr,
-    targetNodeType = context.targetNodeType,
-    targetAttrs = context.targetAttrs;
-  var selection = tr.selection;
-  var $from = selection.$from,
-    $to = selection.$to;
+  var targetNodeType = context.targetNodeType;
 
   // Handle transformation to list types
   if (isListNodeType(targetNodeType)) {
-    return transformToList(context);
+    return transformBlockToList(context);
   }
 
   // Handle transformation to container types (panel, expand, blockquote)
   if (isContainerNodeType(targetNodeType)) {
-    return transformToContainer();
+    return transformToContainer(context);
   }
 
   // Handle block type transformation (paragraph, heading, codeblock)
   if (isBlockNodeType(targetNodeType)) {
-    tr.setBlockType($from.pos, $to.pos, targetNodeType, targetAttrs);
-    return tr;
+    return transformToBlockNode(context);
   }
   return null;
+};
+var transformToBlockNode = function transformToBlockNode(context) {
+  var tr = context.tr,
+    targetNodeType = context.targetNodeType,
+    targetAttrs = context.targetAttrs;
+  var selection = tr.selection,
+    doc = tr.doc;
+  var $from = selection.$from,
+    $to = selection.$to;
+  var schema = doc.type.schema;
+  if (targetNodeType === schema.nodes.codeBlock) {
+    var textContent = getInlineNodeTextContent(selection.content().content, tr);
+    var node = schema.nodes.codeBlock.createChecked(undefined, textContent);
+    return tr.replaceRangeWith(selection.from, selection.to, node);
+  }
+  tr.setBlockType($from.pos, $to.pos, targetNodeType, targetAttrs);
+  return tr;
 };

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

@@ -1,20 +1,52 @@
+import { Fragment } from '@atlaskit/editor-prosemirror/model';
 import { isBlockNodeType, isListNodeType, isContainerNodeType } from './utils';
+var convertInvalidNodeToValidNodeType = function convertInvalidNodeToValidNodeType(sourceContent, sourceNodeType, validNodeType, withMarks) {
+  var validTransformedContent = [];
+  // Headings are not valid inside headings so convert heading nodes to paragraphs
+  sourceContent.forEach(function (node) {
+    if (sourceNodeType === node.type) {
+      validTransformedContent.push(validNodeType.createChecked(node.attrs, node.content, withMarks ? node.marks : undefined));
+    } else {
+      validTransformedContent.push(node);
+    }
+  });
+  return Fragment.from(validTransformedContent);
+};
 
 /**
  * Transform selection to container type
  */
-export var transformToContainer = function transformToContainer() {
-  return null;
+export var transformToContainer = function transformToContainer(_ref) {
+  var tr = _ref.tr,
+    sourceNode = _ref.sourceNode,
+    targetNodeType = _ref.targetNodeType,
+    targetAttrs = _ref.targetAttrs;
+  var selection = tr.selection;
+  var schema = tr.doc.type.schema;
+  var content = selection.content().content;
+  var transformedContent = content;
+  if (sourceNode.type === schema.nodes.codeBlock) {
+    transformedContent = convertInvalidNodeToValidNodeType(transformedContent, schema.nodes.codeBlock, schema.nodes.paragraph);
+  }
+  if (targetNodeType === schema.nodes.blockquote) {
+    transformedContent = convertInvalidNodeToValidNodeType(transformedContent, schema.nodes.heading, schema.nodes.paragraph, true);
+  }
+  var newNode = targetNodeType.createAndFill(targetAttrs, transformedContent);
+  if (!newNode) {
+    return null;
+  }
+  tr.replaceRangeWith(selection.from, selection.to, newNode);
+  return tr;
 };
 
 /**
  * Transform container nodes (panel, expand, blockquote)
  */
-export var transformContainerNode = function transformContainerNode(_ref) {
-  var tr = _ref.tr,
-    sourcePos = _ref.sourcePos,
-    targetNodeType = _ref.targetNodeType,
-    targetAttrs = _ref.targetAttrs;
+export var transformContainerNode = function transformContainerNode(_ref2) {
+  var tr = _ref2.tr,
+    sourcePos = _ref2.sourcePos,
+    targetNodeType = _ref2.targetNodeType,
+    targetAttrs = _ref2.targetAttrs;
   if (sourcePos === null) {
     return null;
   }

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

@@ -0,0 +1,21 @@
+export var getInlineNodeTextContent = function getInlineNodeTextContent(sourceContent, tr) {
+  var validTransformedContent = '';
+  var schema = tr.doc.type.schema;
+  if (sourceContent.content.length > 1) {
+    return;
+  }
+  // Headings are not valid inside headings so convert heading nodes to paragraphs
+  sourceContent.forEach(function (node) {
+    if (['paragraph', 'heading'].includes(node.type.name)) {
+      node.content.forEach(function (inlineNode) {
+        if (inlineNode.type.name === 'status') {
+          validTransformedContent += inlineNode.attrs.text;
+        } else {
+          validTransformedContent += "".concat(inlineNode.textContent);
+        }
+      });
+      validTransformedContent;
+    }
+  });
+  return schema.text(validTransformedContent);
+};