@atlaskit/editor-plugin-block-menu 0.0.20 → 1.0.1

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @atlaskit/editor-plugin-block-menu
 
+## 1.0.1
+
+### Patch Changes
+
+- [`ecae39119dc4b`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/ecae39119dc4b) -
+  [ux] ED-28558 Wrap block nodes inside container nodes
+- Updated dependencies
+
+## 1.0.0
+
+### Patch Changes
+
+- [`e882e86092666`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/e882e86092666) -
+  [ux] Register expand, layout and code block itmes in block menu. Update panel item.
+- Updated dependencies
+
 ## 0.0.20
 
 ### Patch Changes

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

@@ -27,19 +27,22 @@ var formatNode = exports.formatNode = function formatNode(targetType) {
       nodePos = selectedNode.pos;
     } else {
       // Try to find parent node (including list parents)
-      var parentNode = (0, _utils.findParentNodeOfType)([nodes.blockquote, nodes.panel, nodes.expand, nodes.codeBlock, nodes.listItem, nodes.layoutSection])(selection);
+      var parentNode = (0, _utils.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 = (0, _utils.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 = (0, _utils.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/cjs/editor-commands/transforms/block-transforms.js

@@ -5,33 +5,45 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.transformBlockNode = void 0;
 var _containerTransforms = require("./container-transforms");
+var _inlineNodeTransforms = require("./inline-node-transforms");
 var _listTransforms = require("./list-transforms");
 var _utils = require("./utils");
 /**
  * Transform block nodes (paragraph, heading, codeblock)
  */
 var transformBlockNode = exports.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 ((0, _utils.isListNodeType)(targetNodeType)) {
-    return (0, _listTransforms.transformToList)(context);
+    return (0, _listTransforms.transformBlockToList)(context);
   }
 
   // Handle transformation to container types (panel, expand, blockquote)
   if ((0, _utils.isContainerNodeType)(targetNodeType)) {
-    return (0, _containerTransforms.transformToContainer)();
+    return (0, _containerTransforms.transformToContainer)(context);
   }
 
   // Handle block type transformation (paragraph, heading, codeblock)
   if ((0, _utils.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 = (0, _inlineNodeTransforms.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/cjs/editor-commands/transforms/container-transforms.js

@@ -4,22 +4,55 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.unwrapAndConvertToList = exports.unwrapAndConvertToBlockType = exports.transformToContainer = exports.transformContainerNode = void 0;
+var _model = require("@atlaskit/editor-prosemirror/model");
 var _utils = require("./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 _model.Fragment.from(validTransformedContent);
+};
+
 /**
  * Transform selection to container type
  */
-var transformToContainer = exports.transformToContainer = function transformToContainer() {
-  return null;
+var transformToContainer = exports.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)
  */
-var transformContainerNode = exports.transformContainerNode = function transformContainerNode(_ref) {
-  var tr = _ref.tr,
-    sourcePos = _ref.sourcePos,
-    targetNodeType = _ref.targetNodeType,
-    targetAttrs = _ref.targetAttrs;
+var transformContainerNode = exports.transformContainerNode = function transformContainerNode(_ref2) {
+  var tr = _ref2.tr,
+    sourcePos = _ref2.sourcePos,
+    targetNodeType = _ref2.targetNodeType,
+    targetAttrs = _ref2.targetAttrs;
   if (sourcePos === null) {
     return null;
   }

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

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getInlineNodeTextContent = void 0;
+var getInlineNodeTextContent = exports.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);
+};

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

@@ -0,0 +1,102 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.transformListStructure = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+/**
+ * Extract all inline content from a node
+ */
+var extractInlineContent = function extractInlineContent(node) {
+  var inlineContent = [];
+  for (var i = 0; i < node.childCount; i++) {
+    inlineContent.push(node.child(i));
+  }
+  return inlineContent;
+};
+
+/**
+ * Transform list structure
+ */
+var transformListStructure = exports.transformListStructure = function transformListStructure(tr, listNode, targetNodeType, nodes) {
+  try {
+    var sourceList = listNode.node,
+      listPos = listNode.pos;
+    var bulletList = nodes.bulletList,
+      orderedList = nodes.orderedList,
+      taskList = nodes.taskList,
+      listItem = nodes.listItem,
+      taskItem = nodes.taskItem,
+      paragraph = nodes.paragraph;
+    var isSourceBulletOrOrdered = sourceList.type === bulletList || sourceList.type === orderedList;
+    var isTargetTask = targetNodeType === taskList;
+    var isSourceTask = sourceList.type === taskList;
+    var newListItems = [];
+    var listStart = listPos;
+    var listEnd = listPos + sourceList.nodeSize;
+
+    // Use nodesBetween to efficiently traverse the list structure
+    tr.doc.nodesBetween(listStart, listEnd, function (node, pos, parent) {
+      // Only process direct children of the list (depth 1)
+      if (parent !== sourceList) {
+        return true; // Continue traversal
+      }
+      if (isSourceBulletOrOrdered && isTargetTask) {
+        // Converting from bullet/ordered list to task list
+        // Extract inline content from all children within listItem
+        if (node.type === listItem) {
+          var inlineContent = [];
+
+          // Extract all inline content from all child nodes
+          for (var i = 0; i < node.childCount; i++) {
+            var child = node.child(i);
+            if (child.type === paragraph) {
+              // Extract inline content from paragraphs
+              inlineContent.push.apply(inlineContent, (0, _toConsumableArray2.default)(extractInlineContent(child)));
+            } else if (child.isBlock) {
+              // For other block content types eg. codeBlock, extract their text content and create text nodes
+              var textContent = child.textContent;
+              if (textContent) {
+                var textNode = tr.doc.type.schema.text(textContent);
+                inlineContent.push(textNode);
+              }
+            } else {
+              // Already inline content, add directly
+              inlineContent.push(child);
+            }
+          }
+          if (inlineContent.length > 0) {
+            var newItem = taskItem.create(null, inlineContent);
+            newListItems.push(newItem);
+          }
+        }
+      } else if (isSourceTask && !isTargetTask) {
+        // Converting from task list to bullet/ordered list
+        // Structure: taskItem > inline content -> listItem > paragraph > inline content
+        if (node.type === taskItem) {
+          var _inlineContent = extractInlineContent(node);
+          if (_inlineContent.length > 0) {
+            var paragraphNode = paragraph.create(null, _inlineContent);
+            var newListItem = listItem.create(null, paragraphNode);
+            newListItems.push(newListItem);
+          }
+        }
+      }
+      return false; // Don't traverse into children of list items
+    });
+    if (newListItems.length === 0) {
+      return tr;
+    }
+
+    // Create new list with transformed items
+    var newList = targetNodeType.create(null, newListItems);
+
+    // Replace the entire list
+    tr.replaceWith(listStart, listEnd, newList);
+    return tr;
+  } catch (_unused) {
+    return tr;
+  }
+};

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

@@ -3,18 +3,18 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.transformToList = exports.transformListNode = exports.transformBetweenListTypes = exports.liftListToBlockType = void 0;
+exports.transformListNode = exports.transformBlockToList = exports.transformBetweenListTypes = exports.liftListToBlockType = void 0;
 var _transform = require("@atlaskit/editor-prosemirror/transform");
 var _utils = require("@atlaskit/editor-prosemirror/utils");
+var _transformBetweenListTypes = require("./list/transformBetweenListTypes");
 var _utils2 = require("./utils");
 /**
  * Transform selection to list type
  */
-var transformToList = exports.transformToList = function transformToList(_ref) {
-  var tr = _ref.tr,
-    targetNodeType = _ref.targetNodeType,
-    targetAttrs = _ref.targetAttrs;
-  // Wrap selection in list of target type
+var transformBlockToList = exports.transformBlockToList = function transformBlockToList(context) {
+  var tr = context.tr,
+    targetNodeType = context.targetNodeType,
+    targetAttrs = context.targetAttrs;
   var _tr$selection = tr.selection,
     $from = _tr$selection.$from,
     $to = _tr$selection.$to;
@@ -22,13 +22,30 @@ var transformToList = exports.transformToList = function transformToList(_ref) {
   if (!range) {
     return null;
   }
+  var nodes = tr.doc.type.schema.nodes;
+  var 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
+  var sourceNode = tr.doc.nodeAt(range.start);
+  if (sourceNode && sourceNode.type.name.startsWith('heading')) {
+    tr.setBlockType(range.start, range.end, nodes.paragraph);
+  }
+
+  // Get the current range (updated if we converted from heading)
+  var currentRange = tr.selection.$from.blockRange(tr.selection.$to) || range;
 
-  // Find if we can wrap the selection in the target list type
-  var wrapping = (0, _transform.findWrapping)(range, targetNodeType, targetAttrs);
+  // Wrap in the target list type
+  var wrapping = (0, _transform.findWrapping)(currentRange, targetNodeType, targetAttrs);
   if (!wrapping) {
     return null;
   }
-  tr.wrap(range, wrapping);
+  tr.wrap(currentRange, wrapping);
   return tr;
 };
 
@@ -67,22 +84,37 @@ var liftListToBlockType = exports.liftListToBlockType = function liftListToBlock
 /**
  * Transform between different list types
  */
-var transformBetweenListTypes = exports.transformBetweenListTypes = function transformBetweenListTypes(_ref2) {
-  var tr = _ref2.tr,
-    targetNodeType = _ref2.targetNodeType;
-  var selection = tr.selection;
+var transformBetweenListTypes = exports.transformBetweenListTypes = function transformBetweenListTypes(_ref) {
+  var tr = _ref.tr,
+    targetNodeType = _ref.targetNodeType;
+  var _tr = tr,
+    selection = _tr.selection;
   var nodes = tr.doc.type.schema.nodes;
 
-  // Find the list node
-  var listNode = (0, _utils.findParentNodeOfType)([nodes.bulletList, nodes.orderedList, nodes.taskList])(selection);
+  // Find the list node - support bullet lists, ordered lists, and task lists
+  var supportedListTypes = [nodes.bulletList, nodes.orderedList, nodes.taskList].filter(Boolean); // Filter out undefined nodes in case some schemas don't have all types
+
+  var listNode = (0, _utils.findParentNodeOfType)(supportedListTypes)(selection);
   if (!listNode) {
     return null;
   }
+  var sourceListType = listNode.node.type;
+  var isSourceBulletOrOrdered = sourceListType === nodes.bulletList || sourceListType === nodes.orderedList;
+  var isTargetTask = targetNodeType === nodes.taskList;
+  var isSourceTask = sourceListType === nodes.taskList;
+  var isTargetBulletOrOrdered = targetNodeType === nodes.bulletList || targetNodeType === nodes.orderedList;
+
+  // Check if we need structure transformation
+  var 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 = (0, _transformBetweenListTypes.transformListStructure)(tr, listNode, targetNodeType, nodes);
+    }
+  } catch (_unused) {
     return null;
   }
+  return tr;
 };

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

@@ -67,7 +67,7 @@ var getTargetNodeInfo = exports.getTargetNodeInfo = function getTargetNodeInfo(t
           panelType: 'info'
         }
       };
-    case 'codeblock':
+    case 'codeBlock':
       return {
         nodeType: nodes.codeBlock
       };

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

@@ -11,7 +11,6 @@ var _blockMenu = require("@atlaskit/editor-common/block-menu");
 var _editorToolbar = require("@atlaskit/editor-toolbar");
 var _changes = _interopRequireDefault(require("@atlaskit/icon/core/changes"));
 var _chevronRight = _interopRequireDefault(require("@atlaskit/icon/core/chevron-right"));
-var _platformFeatureFlags = require("@atlaskit/platform-feature-flags");
 var _copyBlock = _interopRequireDefault(require("./copy-block"));
 var _copyLink = require("./copy-link");
 var _deleteButton = require("./delete-button");
@@ -98,7 +97,7 @@ var getFormatMenuComponents = function getFormatMenuComponents() {
 var getBlockMenuComponents = exports.getBlockMenuComponents = function getBlockMenuComponents(_ref4) {
   var api = _ref4.api,
     config = _ref4.config;
-  return [].concat((0, _toConsumableArray2.default)((0, _platformFeatureFlags.fg)('platform_editor_block_menu_format') ? getFormatMenuComponents() : []), [{
+  return [].concat((0, _toConsumableArray2.default)(getFormatMenuComponents()), [{
     type: 'block-menu-section',
     key: _blockMenu.COPY_MENU_SECTION.key,
     rank: _blockMenu.BLOCK_MENU_SECTION_RANK[_blockMenu.COPY_MENU_SECTION.key],

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

@@ -26,19 +26,22 @@ export const formatNode = targetType => {
       nodePos = selectedNode.pos;
     } else {
       // Try to find parent node (including list parents)
-      const parentNode = findParentNodeOfType([nodes.blockquote, nodes.panel, nodes.expand, nodes.codeBlock, nodes.listItem, nodes.layoutSection])(selection);
+      const 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;
-
+        const 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) {
           const 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/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);
+};