@atlaskit/editor-plugin-block-menu 6.0.5 → 6.0.7

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

@@ -15,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';
 
@@ -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,
@@ -220,9 +219,7 @@ const TRANSFORM_STEPS_OVERRIDE = {
     // 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,
-    // TODO: EDITOR-4138 - Implement multi content to layout transform
-    layoutSection: undefined
+    paragraph: null
   }
 };
 const getTransformStepsForNodeTypes = (selectedNodeTypeName, targetNodeTypeName) => {

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

@@ -1,6 +1,16 @@
 import { NodeSelection, TextSelection } from '@atlaskit/editor-prosemirror/state';
 import { findParentNodeOfType } from '@atlaskit/editor-prosemirror/utils';
 import { CellSelection } from '@atlaskit/editor-tables';
+import { NODE_CATEGORY_BY_TYPE } from './types';
+
+/**
+ * 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.
+ */
+export const isTextNode = node => {
+  const category = NODE_CATEGORY_BY_TYPE[node.type.name];
+  return category === 'text';
+};
 export const getSelectedNode = selection => {
   if (selection instanceof NodeSelection) {
     return {

package/dist/esm/editor-commands/transform-node-utils/steps/decisionListToListStep.js

@@ -67,11 +67,7 @@ export var decisionListToListStep = function decisionListToListStep(nodes, conte
     }
     var newItems = [];
     node.forEach(function (decisionItem) {
-      var itemContent = [];
-      decisionItem.forEach(function (child) {
-        itemContent.push(child);
-      });
-      var newItem = targetItemType === schema.nodes.listItem ? targetItemType.create({}, paragraphType.create({}, itemContent)) : targetItemType.create({}, itemContent);
+      var newItem = targetItemType.inlineContent ? targetItemType.create({}, decisionItem.children) : targetItemType.create({}, paragraphType.create({}, decisionItem.children));
       if (newItem) {
         newItems.push(newItem);
       }

package/dist/esm/editor-commands/transform-node-utils/steps/flattenListStep.js

@@ -18,7 +18,7 @@ var extractNestedLists = function extractNestedLists(node, schema) {
         child.forEach(function (grandChild) {
           if (isListWithIndentation(grandChild.type.name, schema)) {
             nestedLists.push(grandChild);
-          } else if (grandChild.isText) {
+          } else if (grandChild.isInline) {
             // For taskItem/decisionItem, keep text as-is (they support inline content)
             // For listItem, wrap text in paragraph (they require block content)
             if (isInlineItem) {
@@ -69,8 +69,6 @@ var extractNestedLists = function extractNestedLists(node, schema) {
  * @param nodes
  * @param context
  * @returns
- *
- * TODO: Lists with mixed types (e.g. bulletList with a taskItem) doesn't full flatten
  */
 export var flattenListStep = function flattenListStep(nodes, context) {
   return nodes.map(function (node) {

package/dist/esm/editor-commands/transform-node-utils/steps/listToDecisionListStep.js

@@ -38,7 +38,7 @@ export var listToDecisionListStep = function listToDecisionListStep(nodes, conte
         if (child.type === paragraphType) {
           // paragraph may contain hard breaks etc.
           itemContent.push.apply(itemContent, _toConsumableArray(child.children));
-        } else if (child.isText || child.isInline) {
+        } else if (child.isInline) {
           itemContent.push(child);
         } else if (!isListWithIndentation(child.type.name, schema)) {
           unsupportedContent.push(child);

package/dist/esm/editor-commands/transform-node-utils/steps/listToListStep.js

@@ -69,7 +69,7 @@ var _transformList = function transformList(node, targetListType, targetItemType
       itemNode.forEach(function (child) {
         if (child.type === paragraphType) {
           inlineContent.push.apply(inlineContent, _toConsumableArray(child.children));
-        } else if (child.isText) {
+        } else if (child.isInline) {
           inlineContent.push(child);
           // Nested lists will be extracted and placed as siblings in the taskList
         } else if (!isListWithIndentation(child.type.name, schema)) {

package/dist/esm/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.
- */
-var isTextNode = function isTextNode(node) {
-  var 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/esm/editor-commands/transform-node-utils/steps/wrapMixedContentStep.js

@@ -2,34 +2,7 @@ import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
 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.
- */
-var isTextNode = function isTextNode(node) {
-  var 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
- */
-var canWrapInTarget = function 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
@@ -69,18 +42,33 @@ var handleEmptyContainerEdgeCase = function handleEmptyContainerEdgeCase(result,
  * - 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 var wrapMixedContentStep = function wrapMixedContentStep(nodes, context) {
   var schema = context.schema,
@@ -90,49 +78,78 @@ export var wrapMixedContentStep = function wrapMixedContentStep(nodes, context)
   if (!targetNodeType) {
     return nodes;
   }
+  var isLayout = targetNodeTypeName === 'layoutSection';
+  var _schema$nodes = schema.nodes,
+    layoutSection = _schema$nodes.layoutSection,
+    layoutColumn = _schema$nodes.layoutColumn;
   var result = [];
   var currentContainerContent = [];
   var hasCreatedContainer = false;
   var flushCurrentContainer = function flushCurrentContainer() {
-    if (currentContainerContent.length > 0) {
-      var 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
+      var columnOne = layoutColumn.createAndFill({}, removeDisallowedMarks(currentContainerContent, layoutColumn));
+      var columnTwo = layoutColumn.createAndFill();
+      if (!columnOne || !columnTwo) {
+        currentContainerContent = [];
+        return;
+      }
+      var layout = layoutSection.createAndFill({}, [columnOne, columnTwo]);
+      if (layout) {
+        result.push(layout);
         hasCreatedContainer = true;
       }
       currentContainerContent = [];
+      return;
     }
+
+    // For regular containers, create directly
+    var containerNode = targetNodeType.createAndFill({}, currentContainerContent);
+    if (containerNode) {
+      result.push(containerNode);
+      hasCreatedContainer = true;
+    }
+    currentContainerContent = [];
   };
-  nodes.forEach(function (node) {
-    if (canWrapInTarget(node, targetNodeType, targetNodeTypeName)) {
+  var processNode = function processNode(node) {
+    var validationType = isLayout ? layoutColumn : targetNodeType;
+    var canWrapNode = validationType.validContent(Fragment.from(removeDisallowedMarks([node], validationType)));
+
+    // Node can be wrapped - add to current container content
+    if (canWrapNode) {
       var _currentContainerCont;
-      // Node can be wrapped - add to current container content
       // remove marks from node as nested nodes don't usually support block marks
-      (_currentContainerCont = currentContainerContent).push.apply(_currentContainerCont, _toConsumableArray(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
+      (_currentContainerCont = currentContainerContent).push.apply(_currentContainerCont, _toConsumableArray(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)) {
       var 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;
+  }
   var finalResult = handleEmptyContainerEdgeCase(result, hasCreatedContainer, fromNode, targetNodeType, targetNodeTypeName, schema);
   return finalResult.length > 0 ? finalResult : nodes;
 };