@atlaskit/editor-plugin-block-menu 6.0.4 → 6.0.6

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

@@ -1,80 +1,80 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.transformNode = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 var _analytics = require("@atlaskit/editor-common/analytics");
 var _performanceMeasures = require("@atlaskit/editor-common/performance-measures");
 var _selection = require("@atlaskit/editor-common/selection");
 var _state = require("@atlaskit/editor-prosemirror/state");
 var _isNestedNode = require("../ui/utils/isNestedNode");
-var _tranformContent = require("./transform-node-utils/tranformContent");
+var _transform = require("./transform-node-utils/transform");
 var _utils = require("./transforms/utils");
 var transformNode = exports.transformNode = function transformNode(api) {
-  return (
-    // eslint-disable-next-line no-unused-vars
-    function (targetType, metadata) {
-      return function (_ref) {
-        var _api$blockControls;
-        var tr = _ref.tr;
-        var preservedSelection = api === null || api === void 0 || (_api$blockControls = api.blockControls) === null || _api$blockControls === void 0 || (_api$blockControls = _api$blockControls.sharedState.currentState()) === null || _api$blockControls === void 0 ? void 0 : _api$blockControls.preservedSelection;
-        if (!preservedSelection) {
-          return tr;
-        }
-
-        // Start performance measurement
-        var measureId = "transformNode_".concat(targetType.name, "_").concat(Date.now());
-        (0, _performanceMeasures.startMeasure)(measureId);
-        var schema = tr.doc.type.schema;
-        var nodes = schema.nodes;
-        var _expandSelectionToBlo = (0, _selection.expandSelectionToBlockRange)(preservedSelection),
-          $from = _expandSelectionToBlo.$from,
-          $to = _expandSelectionToBlo.$to;
-        var selectedParent = $from.parent;
-        var isNested = (0, _isNestedNode.isNestedNode)(preservedSelection, '');
-        var isList = (0, _utils.isListNode)(selectedParent);
-        var slice = tr.doc.slice(isList ? $from.pos - 1 : $from.pos, isList ? $to.pos + 1 : $to.pos);
-
-        // Collect source node information for analytics before transformation
-        var nodeCount = 0;
-        var sourceNodeTypes = {};
-        slice.content.forEach(function (node) {
-          nodeCount++;
-          var nodeTypeName = node.type.name;
-          sourceNodeTypes[nodeTypeName] = (sourceNodeTypes[nodeTypeName] || 0) + 1;
-        });
-        var transformedNodes = (0, _tranformContent.tranformContent)(slice.content, targetType, schema, isNested, metadata === null || metadata === void 0 ? void 0 : metadata.targetAttrs, selectedParent);
-        var nodesToDeleteAndInsert = [nodes.mediaSingle];
-        if (preservedSelection instanceof _state.NodeSelection && nodesToDeleteAndInsert.includes(preservedSelection.node.type)) {
-          // when node is media single, use tr.replaceWith freeze editor, if modify position, tr.replaceWith creates duplicats
-          tr.deleteRange($from.pos, $to.pos);
-          tr.insert($from.pos, transformedNodes);
-        } else {
-          tr.replaceWith(isList ? $from.pos - 1 : $from.pos, $to.pos, transformedNodes);
-        }
-
-        // Stop performance measurement and fire analytics
-        (0, _performanceMeasures.stopMeasure)(measureId, function (duration, startTime) {
-          var _api$analytics;
-          api === null || api === void 0 || (_api$analytics = api.analytics) === null || _api$analytics === void 0 || (_api$analytics = _api$analytics.actions) === null || _api$analytics === void 0 || _api$analytics.fireAnalyticsEvent({
-            action: _analytics.ACTION.TRANSFORMED,
-            actionSubject: _analytics.ACTION_SUBJECT.ELEMENT,
-            actionSubjectId: _analytics.ACTION_SUBJECT_ID.TRANSFORM,
-            attributes: {
-              duration: duration,
-              isList: isList,
-              isNested: isNested,
-              nodeCount: nodeCount,
-              sourceNodeTypes: sourceNodeTypes,
-              startTime: startTime,
-              targetNodeType: targetType.name
-            },
-            eventType: _analytics.EVENT_TYPE.OPERATIONAL
-          });
-        });
+  return function (targetType, metadata) {
+    return function (_ref) {
+      var _api$blockControls;
+      var tr = _ref.tr;
+      var preservedSelection = api === null || api === void 0 || (_api$blockControls = api.blockControls) === null || _api$blockControls === void 0 || (_api$blockControls = _api$blockControls.sharedState.currentState()) === null || _api$blockControls === void 0 ? void 0 : _api$blockControls.preservedSelection;
+      if (!preservedSelection) {
         return tr;
-      };
-    }
-  );
+      }
+      var measureId = "transformNode_".concat(targetType.name, "_").concat(Date.now());
+      (0, _performanceMeasures.startMeasure)(measureId);
+      var nodes = tr.doc.type.schema.nodes;
+      var _expandSelectionToBlo = (0, _selection.expandSelectionToBlockRange)(preservedSelection),
+        $from = _expandSelectionToBlo.$from,
+        $to = _expandSelectionToBlo.$to;
+      var selectedParent = $from.parent;
+      var isParentLayout = selectedParent.type === nodes.layoutColumn;
+      var isNested = (0, _isNestedNode.isNestedNode)(preservedSelection, '') && !isParentLayout;
+      var isList = (0, _utils.isListNode)(selectedParent);
+      var sliceStart = isList ? $from.pos - 1 : $from.pos;
+      var sliceEnd = isList ? $to.pos + 1 : $to.pos;
+      var slice = tr.doc.slice(sliceStart, sliceEnd);
+      var sourceNodes = (0, _toConsumableArray2.default)(slice.content.content);
+      var sourceNodeTypes = {};
+      sourceNodes.forEach(function (node) {
+        var typeName = node.type.name;
+        sourceNodeTypes[typeName] = (sourceNodeTypes[typeName] || 0) + 1;
+      });
+      var resultNodes = (0, _transform.convertNodesToTargetType)({
+        sourceNodes: sourceNodes,
+        targetNodeType: targetType,
+        schema: tr.doc.type.schema,
+        isNested: isNested,
+        targetAttrs: metadata === null || metadata === void 0 ? void 0 : metadata.targetAttrs,
+        parentNode: selectedParent
+      });
+      var content = resultNodes.length > 0 ? resultNodes : slice.content;
+      if (preservedSelection instanceof _state.NodeSelection && preservedSelection.node.type === nodes.mediaSingle) {
+        tr.deleteRange($from.pos, $to.pos);
+        tr.insert($from.pos, content);
+      } else {
+        tr.replaceWith(sliceStart, $to.pos, content);
+      }
+      (0, _performanceMeasures.stopMeasure)(measureId, function (duration, startTime) {
+        var _api$analytics;
+        api === null || api === void 0 || (_api$analytics = api.analytics) === null || _api$analytics === void 0 || (_api$analytics = _api$analytics.actions) === null || _api$analytics === void 0 || _api$analytics.fireAnalyticsEvent({
+          action: _analytics.ACTION.TRANSFORMED,
+          actionSubject: _analytics.ACTION_SUBJECT.ELEMENT,
+          actionSubjectId: _analytics.ACTION_SUBJECT_ID.TRANSFORM,
+          attributes: {
+            duration: duration,
+            isList: isList,
+            isNested: isNested,
+            nodeCount: sourceNodes.length,
+            sourceNodeTypes: sourceNodeTypes,
+            startTime: startTime,
+            targetNodeType: targetType.name
+          },
+          eventType: _analytics.EVENT_TYPE.OPERATIONAL
+        });
+      });
+      return tr;
+    };
+  };
 };

package/dist/es2019/editor-commands/transform-node-utils/steps/convertEachNodeStep.js

@@ -0,0 +1,28 @@
+import { convertNodesToTargetType } from '../transform';
+export const convertEachNodeStep = (nodes, context) => {
+  const {
+    schema,
+    targetNodeTypeName,
+    targetAttrs
+  } = context;
+  const targetNodeType = schema.nodes[targetNodeTypeName];
+  if (!targetNodeType) {
+    return nodes;
+  }
+  const resultNodes = [];
+  for (const node of nodes) {
+    const transformedNodes = convertNodesToTargetType({
+      sourceNodes: [node],
+      targetNodeType,
+      schema,
+      isNested: false,
+      targetAttrs
+    });
+    if (transformedNodes.length > 0) {
+      resultNodes.push(...transformedNodes);
+    } else {
+      resultNodes.push(node);
+    }
+  }
+  return resultNodes;
+};

package/dist/es2019/editor-commands/transform-node-utils/steps/mergeNeighbourListsStep.js

@@ -0,0 +1,75 @@
+import { isListWithIndentation } from '../nodeChecks';
+/**
+ * Merges consecutive lists of the same type into a single list.
+ * This step is useful after multiToListStep which may create multiple separate lists
+ * that should be combined.
+ *
+ * Handles both nestable lists (bulletList, orderedList, taskList) and
+ * non-nestable lists (decisionList).
+ *
+ * @example
+ * Input:
+ * - bulletList
+ *   - listItem "1"
+ * - bulletList
+ *   - listItem "2"
+ * - panel (non-list node)
+ * - bulletList
+ *   - listItem "3"
+ *
+ * Output:
+ * - bulletList
+ *   - listItem "1"
+ *   - listItem "2"
+ * - panel (non-list node)
+ * - bulletList
+ *   - listItem "3"
+ *
+ * @param nodes - The nodes to process
+ * @param context - The transformation context
+ * @returns The merged nodes
+ */
+export const mergeNeighbourListsStep = (nodes, context) => {
+  if (nodes.length === 0) {
+    return nodes;
+  }
+  const {
+    schema
+  } = context;
+  const resultNodes = [];
+  let currentList = null;
+
+  // Check if a node is any type of list (including decisionList)
+  const isList = node => {
+    return isListWithIndentation(node.type.name, schema) || node.type.name === 'decisionList';
+  };
+  for (const node of nodes) {
+    // Check if this node is any type of list
+    if (isList(node)) {
+      if (currentList && currentList.type === node.type) {
+        // Merge with the current list by combining their children
+        const mergedContent = currentList.content.append(node.content);
+        currentList = currentList.type.create(currentList.attrs, mergedContent);
+      } else {
+        // Start a new list or switch to a different list type
+        if (currentList) {
+          resultNodes.push(currentList);
+        }
+        currentList = node;
+      }
+    } else {
+      // Non-list node - push any accumulated list and then this node
+      if (currentList) {
+        resultNodes.push(currentList);
+        currentList = null;
+      }
+      resultNodes.push(node);
+    }
+  }
+
+  // Don't forget the last list if we ended with one
+  if (currentList) {
+    resultNodes.push(currentList);
+  }
+  return resultNodes;
+};

package/dist/es2019/editor-commands/transform-node-utils/steps/wrapBlockquoteToDecisionListStep.js

@@ -1,14 +1,4 @@
-import { NODE_CATEGORY_BY_TYPE } from '../types';
-
-/**
- * Determines if a node is a text node (heading or paragraph).
- * Only text nodes should have their inline content extracted for decisionItem.
- * All other nodes should break out.
- */
-const isTextNode = node => {
-  const category = NODE_CATEGORY_BY_TYPE[node.type.name];
-  return category === 'text';
-};
+import { isTextNode } from '../utils';
 
 /**
  * Creates a decisionItem with the given inline content.

package/dist/es2019/editor-commands/transform-node-utils/steps/wrapMixedContentStep.js

@@ -1,34 +1,7 @@
 import { Fragment } from '@atlaskit/editor-prosemirror/model';
 import { removeDisallowedMarks } from '../marks';
 import { NODE_CATEGORY_BY_TYPE } from '../types';
-import { convertTextNodeToParagraph } from '../utils';
-
-/**
- * Determines if a node is a text node (heading or paragraph).
- * Text nodes can have their content converted to paragraphs when they can't be wrapped directly.
- */
-const isTextNode = node => {
-  const category = NODE_CATEGORY_BY_TYPE[node.type.name];
-  return category === 'text';
-};
-
-/**
- * Determines if a node can be wrapped in the target container type, removes block marks from the node during check.
- * Uses the schema's validContent to check if the target container can hold this node.
- *
- * Note: What can be wrapped depends on the target container type - for example:
- * - Tables and media CAN go inside expand nodes
- * - Tables CANNOT go inside panels or blockquotes
- */
-const canWrapInTarget = (node, targetNodeType, targetNodeTypeName) => {
-  // Same-type containers should break out as separate containers
-  if (node.type.name === targetNodeTypeName) {
-    return false;
-  }
-
-  // Use the schema to determine if this node can be contained in the target
-  return targetNodeType.validContent(Fragment.from(removeDisallowedMarks([node], targetNodeType)));
-};
+import { convertTextNodeToParagraph, isTextNode } from '../utils';
 
 /**
  * Handles the edge case where transforming from a container to another container results in
@@ -68,18 +41,33 @@ const handleEmptyContainerEdgeCase = (result, hasCreatedContainer, fromNode, tar
  * - Same-type containers break out as separate containers (preserved as-is)
  * - NestedExpands break out as regular expands (converted since nestedExpand can't exist outside expand)
  * - Container structures that can't be nested in target break out (not flattened)
- * - Text/list nodes that can't be wrapped are flattened and merged into the container
+ * - Text/list nodes that can't be wrapped are converted to paragraphs and merged into the container
  * - Atomic nodes (tables, media, macros) break out
  *
+ * Special handling for layouts:
+ * - Layout sections break out as separate layouts (preserved as-is, not wrapped)
+ * - Other nodes (including headings, paragraphs, lists) are wrapped into layout columns within a layout section
+ * - Layouts always require layoutColumns as children (never paragraphs directly)
+ * - Layout columns can contain most block content including headings, paragraphs, lists, etc.
+ *
+ * Edge case handling:
+ * - For regular containers: If all content breaks out (container → container transform with no
+ *   valid children), an empty container with a paragraph is created to ensure the target type exists
+ * - For layouts: Edge case handling is skipped because layouts require columns, not direct paragraphs.
+ *   If all content breaks out, only the broken-out nodes are returned (no empty layout created)
+ *
  * What can be wrapped depends on the target container's schema:
  * - expand → panel: tables break out, nestedExpands convert to expands and break out
- * - expand → blockquote: tables/media break out, nestedExpands convert to expands and break out
+ * - expand → blockquote: tables/media break out, nestedExpands convert to expands and break out, headings converted to paragraphs
  * - expand → expand: tables/media stay inside (expands can contain them)
+ * - multi → layoutSection: layout sections break out, headings/paragraphs/lists wrapped into layout columns
  *
  * Example: expand(p('a'), table(), p('b')) → panel: [panel(p('a')), table(), panel(p('b'))]
  * Example: expand(p('a'), panel(p('x')), p('b')) → panel: [panel(p('a')), panel(p('x')), panel(p('b'))]
  * Example: expand(p('a'), nestedExpand({title: 'inner'})(p('x')), p('b')) → panel: [panel(p('a')), expand({title: 'inner'})(p('x')), panel(p('b'))]
  * Example: expand(nestedExpand()(p())) → panel: [panel(), expand()(p())] (empty panel when all content breaks out)
+ * Example: [p('a'), layoutSection(...), p('b')] → layoutSection: [layoutSection(layoutColumn(p('a'))), layoutSection(...), layoutSection(layoutColumn(p('b')))]
+ * Example: [h1('heading'), p('para')] → layoutSection: [layoutSection(layoutColumn(h1('heading'), p('para')))] (headings stay as headings in layouts)
  */
 export const wrapMixedContentStep = (nodes, context) => {
   const {
@@ -91,48 +79,78 @@ export const wrapMixedContentStep = (nodes, context) => {
   if (!targetNodeType) {
     return nodes;
   }
+  const isLayout = targetNodeTypeName === 'layoutSection';
+  const {
+    layoutSection,
+    layoutColumn
+  } = schema.nodes;
   const result = [];
   let currentContainerContent = [];
   let hasCreatedContainer = false;
   const flushCurrentContainer = () => {
-    if (currentContainerContent.length > 0) {
-      const containerNode = targetNodeType.createAndFill({}, Fragment.fromArray(currentContainerContent));
-      if (containerNode) {
-        result.push(containerNode);
+    if (currentContainerContent.length === 0) {
+      return;
+    }
+    if (isLayout) {
+      // For layouts, create layoutSection with two layoutColumns
+      const columnOne = layoutColumn.createAndFill({}, removeDisallowedMarks(currentContainerContent, layoutColumn));
+      const columnTwo = layoutColumn.createAndFill();
+      if (!columnOne || !columnTwo) {
+        currentContainerContent = [];
+        return;
+      }
+      const layout = layoutSection.createAndFill({}, [columnOne, columnTwo]);
+      if (layout) {
+        result.push(layout);
         hasCreatedContainer = true;
       }
       currentContainerContent = [];
+      return;
+    }
+
+    // For regular containers, create directly
+    const containerNode = targetNodeType.createAndFill({}, currentContainerContent);
+    if (containerNode) {
+      result.push(containerNode);
+      hasCreatedContainer = true;
     }
+    currentContainerContent = [];
   };
-  nodes.forEach(node => {
-    if (canWrapInTarget(node, targetNodeType, targetNodeTypeName)) {
-      // Node can be wrapped - add to current container content
+  const processNode = node => {
+    const validationType = isLayout ? layoutColumn : targetNodeType;
+    const canWrapNode = validationType.validContent(Fragment.from(removeDisallowedMarks([node], validationType)));
+
+    // Node can be wrapped - add to current container content
+    if (canWrapNode) {
       // remove marks from node as nested nodes don't usually support block marks
-      currentContainerContent.push(...removeDisallowedMarks([node], targetNodeType));
-    } else if (node.type.name === targetNodeTypeName) {
-      // Same-type container - breaks out as a separate container (preserved as-is)
-      // This handles: "If there's a panel in the expand, it breaks out into a separate panel"
-      flushCurrentContainer();
-      result.push(node);
-    } else if (isTextNode(node)) {
-      // Text node (heading, paragraph) that can't be wrapped - convert to paragraph
-      // Example: heading can't go in blockquote, so convert to paragraph with same content
+      currentContainerContent.push(...removeDisallowedMarks([node], validationType));
+      return;
+    }
+
+    // Text node (heading, paragraph) that can't be wrapped - convert to paragraph
+    // Example: heading can't go in blockquote, so convert to paragraph with same content
+    if (isTextNode(node)) {
       const paragraph = convertTextNodeToParagraph(node, schema);
       if (paragraph) {
         currentContainerContent.push(paragraph);
       }
-    } else {
-      // All other nodes that cannot be wrapped (lists, containers, tables, media, macros) - break out
-      // This includes list nodes like taskList that can't be placed in certain containers
-      flushCurrentContainer();
-      result.push(node);
+      return;
     }
-  });
+
+    // All other nodes that cannot be wrapped in the target node - break out
+    // Examples: same-type containers, tables in panels, layoutSections in layouts
+    flushCurrentContainer();
+    result.push(node);
+  };
+  nodes.forEach(processNode);
 
   // Flush any remaining content into a container
   flushCurrentContainer();
 
-  // Handle edge case: create empty container if all content broke out
+  // Skip edge case handling for layouts since layouts always have columns
+  if (isLayout) {
+    return result.length > 0 ? result : nodes;
+  }
   const finalResult = handleEmptyContainerEdgeCase(result, hasCreatedContainer, fromNode, targetNodeType, targetNodeTypeName, schema);
   return finalResult.length > 0 ? finalResult : nodes;
 };

package/dist/es2019/editor-commands/transform-node-utils/transform.js

@@ -1,10 +1,12 @@
 import { getTargetNodeTypeNameInContext } from '../transform-node-utils/utils';
 import { flattenStep } from './flattenStep';
 import { applyTargetTextTypeStep } from './steps/applyTargetTextTypeStep';
+import { convertEachNodeStep } from './steps/convertEachNodeStep';
 import { decisionListToListStep } from './steps/decisionListToListStep';
 import { flattenListStep } from './steps/flattenListStep';
 import { listToDecisionListStep } from './steps/listToDecisionListStep';
 import { listToListStep } from './steps/listToListStep';
+import { mergeNeighbourListsStep } from './steps/mergeNeighbourListsStep';
 import { unwrapLayoutStep } from './steps/unwrapLayoutStep';
 import { unwrapListStep } from './steps/unwrapListStep';
 import { wrapBlockquoteToDecisionListStep } from './steps/wrapBlockquoteToDecisionListStep';
@@ -13,7 +15,6 @@ import { wrapTextToCodeblockStep } from './steps/wrapTextToCodeblock';
 import { getNodeName, NODE_CATEGORY_BY_TYPE, toNodeTypeValue } from './types';
 import { unwrapExpandStep } from './unwrapExpandStep';
 import { unwrapStep } from './unwrapStep';
-import { wrapIntoLayoutStep } from './wrapIntoLayoutStep';
 import { wrapIntoListStep } from './wrapIntoListStep';
 import { wrapStep } from './wrapStep';
 
@@ -50,10 +51,8 @@ const TRANSFORM_STEPS = {
   multi: {
     atomic: undefined,
     container: [wrapMixedContentStep],
-    // TODO: EDITOR-4137 - Implement multi list transform
-    list: undefined,
-    // TODO: EDITOR-4140 - Implement multi text transform
-    text: undefined,
+    list: [convertEachNodeStep, mergeNeighbourListsStep],
+    text: [convertEachNodeStep],
     multi: undefined
   }
 };
@@ -65,15 +64,15 @@ const TRANSFORM_STEPS_OVERRIDE = {
   paragraph: {
     paragraph: null,
     codeBlock: [wrapTextToCodeblockStep],
-    layoutSection: [wrapIntoLayoutStep]
+    layoutSection: [wrapMixedContentStep]
   },
   heading: {
     codeBlock: [wrapTextToCodeblockStep],
-    layoutSection: [wrapIntoLayoutStep]
+    layoutSection: [wrapMixedContentStep]
   },
   panel: {
     panel: null,
-    layoutSection: [unwrapStep, wrapIntoLayoutStep],
+    layoutSection: [unwrapStep, wrapMixedContentStep],
     codeBlock: [unwrapStep, flattenStep, wrapStep],
     blockquote: [unwrapStep, wrapMixedContentStep],
     taskList: null,
@@ -85,7 +84,7 @@ const TRANSFORM_STEPS_OVERRIDE = {
     expand: null,
     panel: [unwrapExpandStep, wrapMixedContentStep],
     blockquote: [unwrapExpandStep, wrapMixedContentStep],
-    layoutSection: [unwrapExpandStep, wrapIntoLayoutStep],
+    layoutSection: [unwrapExpandStep, wrapMixedContentStep],
     paragraph: [unwrapExpandStep],
     codeBlock: null,
     heading: null
@@ -103,7 +102,7 @@ const TRANSFORM_STEPS_OVERRIDE = {
     blockquote: null,
     expand: [wrapStep],
     nestedExpand: [wrapStep],
-    layoutSection: [wrapIntoLayoutStep],
+    layoutSection: [wrapMixedContentStep],
     codeBlock: null,
     decisionList: [unwrapStep, wrapBlockquoteToDecisionListStep]
   },
@@ -121,34 +120,34 @@ const TRANSFORM_STEPS_OVERRIDE = {
     blockquote: [wrapStep],
     expand: [wrapStep],
     nestedExpand: [wrapStep],
-    layoutSection: [wrapIntoLayoutStep],
+    layoutSection: [wrapMixedContentStep],
     panel: [wrapStep],
     heading: null
   },
   bulletList: {
     bulletList: null,
     codeBlock: null,
-    layoutSection: [wrapIntoLayoutStep],
+    layoutSection: [wrapMixedContentStep],
     decisionList: [flattenListStep, listToDecisionListStep],
     heading: null
   },
   orderedList: {
     orderedList: null,
     codeBlock: null,
-    layoutSection: [wrapIntoLayoutStep],
+    layoutSection: [wrapMixedContentStep],
     decisionList: [flattenListStep, listToDecisionListStep],
     heading: null
   },
   taskList: {
     blockquote: null,
     codeBlock: null,
-    layoutSection: [wrapIntoLayoutStep],
+    layoutSection: [wrapMixedContentStep],
     decisionList: [flattenListStep, listToDecisionListStep],
     heading: null,
     taskList: null
   },
   table: {
-    layoutSection: [wrapIntoLayoutStep],
+    layoutSection: [wrapMixedContentStep],
     blockquote: null,
     panel: null,
     codeBlock: null,
@@ -158,13 +157,13 @@ const TRANSFORM_STEPS_OVERRIDE = {
     decisionList: null
   },
   mediaSingle: {
-    layoutSection: [wrapIntoLayoutStep],
+    layoutSection: [wrapMixedContentStep],
     codeBlock: null,
     decisionList: null,
     taskList: null
   },
   mediaGroup: {
-    layoutSection: [wrapIntoLayoutStep],
+    layoutSection: [wrapMixedContentStep],
     codeBlock: null,
     decisionList: null,
     bulletList: null,
@@ -176,10 +175,10 @@ const TRANSFORM_STEPS_OVERRIDE = {
     bulletList: [decisionListToListStep],
     orderedList: [decisionListToListStep],
     taskList: [decisionListToListStep],
-    layoutSection: [wrapIntoLayoutStep]
+    layoutSection: [wrapMixedContentStep]
   },
   blockCard: {
-    layoutSection: [wrapIntoLayoutStep],
+    layoutSection: [wrapMixedContentStep],
     blockquote: null,
     codeBlock: null,
     orderedList: null,
@@ -188,7 +187,7 @@ const TRANSFORM_STEPS_OVERRIDE = {
     decisionList: null
   },
   embedCard: {
-    layoutSection: [wrapIntoLayoutStep],
+    layoutSection: [wrapMixedContentStep],
     blockquote: null,
     panel: null,
     codeBlock: null,
@@ -198,7 +197,7 @@ const TRANSFORM_STEPS_OVERRIDE = {
     decisionList: null
   },
   extension: {
-    layoutSection: [wrapIntoLayoutStep],
+    layoutSection: [wrapMixedContentStep],
     codeBlock: null,
     decisionList: null,
     taskList: null,
@@ -206,7 +205,7 @@ const TRANSFORM_STEPS_OVERRIDE = {
     bulletList: null
   },
   bodiedExtension: {
-    layoutSection: [wrapIntoLayoutStep],
+    layoutSection: [wrapMixedContentStep],
     blockquote: null,
     expand: null,
     panel: null,
@@ -217,8 +216,10 @@ const TRANSFORM_STEPS_OVERRIDE = {
     decisionList: null
   },
   multi: {
-    // TODO: EDITOR-4138 - Implement multi content to layout transform
-    layoutSection: undefined
+    // TODO: EDITOR-4140 - Implement multiple paragraphs/headings/codeblocks to heading transform
+    heading: null,
+    // TODO: EDITOR-4141 - Implement multiple codeblocks/headings to paragraph transform
+    paragraph: null
   }
 };
 const getTransformStepsForNodeTypes = (selectedNodeTypeName, targetNodeTypeName) => {
@@ -232,7 +233,22 @@ const getTransformStepsForNodeTypes = (selectedNodeTypeName, targetNodeTypeName)
   const steps = overrideSteps !== null && overrideSteps !== void 0 ? overrideSteps : TRANSFORM_STEPS[fromCategory][toCategory];
   return steps;
 };
-export const getOutputNodes = ({
+/**
+ * Convert a list of nodes to a target node type.
+ * If no steps are found, the source nodes are returned unchanged.
+ * If steps are found, they are applied to the source nodes in order.
+ * If a step returns an empty array, the source nodes are returned.
+ * If a step returns a non-empty array, that array is returned.
+ * @param args - The conversion arguments
+ * @param args.sourceNodes - The list of nodes to convert
+ * @param args.targetNodeType - The type of node to convert into
+ * @param args.schema - The schema to use for the conversion
+ * @param args.isNested - Whether the conversion is nested
+ * @param args.targetAttrs - The attributes to use for the conversion
+ * @param args.parentNode - The parent node of the selected node
+ * @returns The converted list of nodes
+ */
+export const convertNodesToTargetType = ({
   sourceNodes,
   targetNodeType,
   schema,
@@ -242,14 +258,13 @@ export const getOutputNodes = ({
 }) => {
   const sourceNode = sourceNodes.at(0);
   if (!sourceNode) {
-    return;
+    return sourceNodes;
   }
   const selectedNodeTypeName = toNodeTypeValue(getNodeName(sourceNodes));
   const initialTargetNodeTypeName = toNodeTypeValue(targetNodeType.name);
   const targetNodeTypeName = getTargetNodeTypeNameInContext(initialTargetNodeTypeName, isNested, parentNode);
   if (!selectedNodeTypeName || !targetNodeTypeName) {
-    // We may decide to return an empty array or undefined here
-    return;
+    return sourceNodes;
   }
   const steps = getTransformStepsForNodeTypes(selectedNodeTypeName, targetNodeTypeName);
   const context = {
@@ -260,7 +275,7 @@ export const getOutputNodes = ({
     targetAttrs
   };
   if (!steps || steps.length === 0) {
-    return;
+    return sourceNodes;
   }
   return steps.reduce((nodes, step) => {
     return step(nodes, context);