@atlaskit/editor-plugin-block-menu 5.2.15 → 5.2.17

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

@@ -1,6 +1,5 @@
 import { Fragment } from '@atlaskit/editor-prosemirror/model';
-import { isListType } from '../utils';
-
+import { isListWithIndentation } from '../nodeChecks';
 /**
  * Recursively converts nested lists to the target list type.
  * This function handles the conversion of both the list container and its items,
@@ -14,13 +13,13 @@ const transformList = (node, targetListType, targetItemType, unsupportedContent)
   const schema = node.type.schema;
   const taskListType = schema.nodes.taskList;
   const isSourceTaskList = node.type === taskListType;
-  const isTargetTaskList = targetListType === 'taskList';
+  const isTargetTaskList = targetListType === taskListType.name;
   const convertFromTaskListStructure = (node, targetListType, targetItemType) => {
     const schema = node.type.schema;
     const targetListNodeType = schema.nodes[targetListType];
     const transformedContent = [];
     node.forEach(child => {
-      if (isListType(child, schema)) {
+      if (isListWithIndentation(child.type.name, schema)) {
         // This is a nested list - it should become a child of the previous item
         if (transformedContent.length > 0) {
           const previousItem = transformedContent[transformedContent.length - 1];
@@ -32,7 +31,7 @@ const transformList = (node, targetListType, targetItemType, unsupportedContent)
         }
         // If there's no previous item, skip this nested list (orphaned)
       } else {
-        const transformedItem = transformListItem(child, targetItemType, targetListType);
+        const transformedItem = transformListItem(child, targetListType, targetItemType);
         if (transformedItem) {
           transformedContent.push(transformedItem);
         }
@@ -45,19 +44,19 @@ const transformList = (node, targetListType, targetItemType, unsupportedContent)
     const targetListNodeType = schema.nodes[targetListType];
     const transformedContent = [];
     node.forEach(itemNode => {
-      const transformedItem = transformListItem(itemNode, targetItemType, targetListType, true);
+      const transformedItem = transformListItem(itemNode, targetListType, targetItemType, true);
       if (transformedItem) {
         transformedContent.push(transformedItem);
       }
       itemNode.forEach(child => {
-        if (isListType(child, schema)) {
+        if (isListWithIndentation(child.type.name, schema)) {
           transformedContent.push(transformList(child, targetListType, targetItemType, unsupportedContent));
         }
       });
     });
     return targetListNodeType.create(node.attrs, transformedContent);
   };
-  const transformListItem = (itemNode, targetItemType, targetListType, excludeNestedLists = false) => {
+  const transformListItem = (itemNode, targetListType, targetItemType, excludeNestedLists = false) => {
     const schema = itemNode.type.schema;
     const targetItemNodeType = schema.nodes[targetItemType];
     const isTargetTaskItem = targetItemType === 'taskItem';
@@ -71,7 +70,7 @@ const transformList = (node, targetListType, targetItemType, unsupportedContent)
         } else if (child.isText) {
           inlineContent.push(child);
           // Nested lists will be extracted and placed as siblings in the taskList
-        } else if (!isListType(child, schema)) {
+        } else if (!isListWithIndentation(child.type.name, schema)) {
           unsupportedContent.push(child);
         }
       });
@@ -82,7 +81,7 @@ const transformList = (node, targetListType, targetItemType, unsupportedContent)
       transformedContent.push(paragraphType.create(null, itemNode.content));
     } else {
       itemNode.forEach(child => {
-        if (isListType(child, schema)) {
+        if (isListWithIndentation(child.type.name, schema)) {
           if (excludeNestedLists) {
             // Skip nested lists - they will be handled separately as siblings
             return;
@@ -102,7 +101,7 @@ const transformList = (node, targetListType, targetItemType, unsupportedContent)
     const targetListNodeType = schema.nodes[targetListType];
     const transformedContent = [];
     node.forEach(childNode => {
-      const transformedItem = isListType(childNode, schema) ? transformList(childNode, targetListType, targetItemType, unsupportedContent) : transformListItem(childNode, targetItemType, targetListType);
+      const transformedItem = isListWithIndentation(childNode.type.name, schema) ? transformList(childNode, targetListType, targetItemType, unsupportedContent) : transformListItem(childNode, targetListType, targetItemType);
       if (transformedItem) {
         transformedContent.push(transformedItem);
       }
@@ -187,7 +186,7 @@ export const listToListStep = (nodes, context) => {
   } = context;
   const unsupportedContent = [];
   const transformedNodes = nodes.map(node => {
-    if (isListType(node, schema)) {
+    if (isListWithIndentation(node.type.name, schema)) {
       const targetItemType = targetNodeTypeName === 'taskList' ? 'taskItem' : 'listItem';
       return transformList(node, targetNodeTypeName, targetItemType, unsupportedContent);
     }

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

@@ -0,0 +1,18 @@
+import { createTextContent } from '../utils';
+
+/**
+ * Transforms a paragraph (or heading) into a codeBlock by extracting its text content.
+ * This step handles the conversion of inline content (including marks) to plain text,
+ * which is required because codeBlocks can only contain plain text nodes.
+ *
+ * Example: paragraph with bold/italic/status → codeBlock with plain text
+ */
+export const wrapTextToCodeblockStep = (nodes, context) => {
+  const {
+    schema
+  } = context;
+  return nodes.map(node => {
+    const codeBlockNode = schema.nodes.codeBlock.createAndFill({}, schema.text(createTextContent(node)));
+    return codeBlockNode !== null && codeBlockNode !== void 0 ? codeBlockNode : node;
+  });
+};

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

@@ -8,6 +8,7 @@ import { unwrapLayoutStep } from './steps/unwrapLayoutStep';
 import { unwrapListStep } from './steps/unwrapListStep';
 import { wrapBlockquoteToDecisionListStep } from './steps/wrapBlockquoteToDecisionListStep';
 import { wrapMixedContentStep } from './steps/wrapMixedContentStep';
+import { wrapTextToCodeblockStep } from './steps/wrapTextToCodeblock';
 import { stubStep } from './stubStep';
 import { NODE_CATEGORY_BY_TYPE, toNodeTypeValue } from './types';
 import { unwrapExpandStep } from './unwrapExpandStep';
@@ -16,14 +17,6 @@ import { wrapIntoLayoutStep } from './wrapIntoLayoutStep';
 import { wrapIntoListStep } from './wrapIntoListStep';
 import { wrapStep } from './wrapStep';
 
-// Exampled step for overrides:
-// - open Block menu on a paragraph, click 'Panel' in the Turn into'
-// - expected to put paragraph into a panel
-const wrapIntoPanelStep = (nodes, context) => {
-  const newNode = context.schema.nodes.panel.createAndFill({}, nodes);
-  return newNode ? [newNode] : [];
-};
-
 // Transform steps for combinations of node categories (block/container/list/text)
 const TRANSFORM_STEPS = {
   atomic: {
@@ -46,8 +39,8 @@ const TRANSFORM_STEPS = {
   },
   text: {
     atomic: undefined,
-    container: [stubStep],
-    list: [stubStep],
+    container: [wrapStep],
+    list: [wrapIntoListStep],
     text: [stubStep]
   }
 };
@@ -56,7 +49,8 @@ const TRANSFORM_STEPS = {
 // using generic rules/steps from TRANSFORM_STEPS.
 const TRANSFORM_STEPS_OVERRIDE = {
   paragraph: {
-    panel: [wrapIntoPanelStep]
+    codeBlock: [wrapTextToCodeblockStep],
+    layoutSection: [wrapIntoLayoutStep]
   },
   panel: {
     layoutSection: [unwrapStep, wrapIntoLayoutStep],
@@ -130,6 +124,12 @@ const TRANSFORM_STEPS_OVERRIDE = {
     orderedList: [decisionListToListStep],
     taskList: [decisionListToListStep],
     layoutSection: [wrapIntoLayoutStep]
+  },
+  blockCard: {
+    layoutSection: [wrapIntoLayoutStep]
+  },
+  embedCard: {
+    layoutSection: [wrapIntoLayoutStep]
   }
 };
 const getTransformStepsForNodeTypes = (selectedNodeTypeName, targetNodeTypeName) => {

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

@@ -50,10 +50,6 @@ export const getTargetNodeTypeNameInContext = (nodeTypeName, isNested) => {
   }
   return nodeTypeName;
 };
-export const isListType = (node, schema) => {
-  const lists = [schema.nodes.taskList, schema.nodes.bulletList, schema.nodes.orderedList];
-  return lists.some(list => list === node.type);
-};
 
 /**
  * Converts a nestedExpand to a regular expand node.
@@ -100,4 +96,23 @@ export const getBlockNodesInRange = range => {
     }
   }
   return blockNodes;
+};
+
+/**
+ * Iterates over a nodes children and extracting text content, removing all other inline content and converting
+ * hardbreaks to newlines.
+ *
+ * @param node - The node to create text content from (should be paragraph)
+ * @returns The text content string.
+ */
+export const createTextContent = node => {
+  const textContent = node.children.map(child => {
+    if (child.isText) {
+      return child.text;
+    } else if (child.type.name === 'hardBreak') {
+      return '\n';
+    }
+    return '';
+  });
+  return textContent.join('');
 };

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

@@ -1,13 +1,35 @@
-/** wrap nodes into bullet list or numbered list, does not work for task list */
+import { isListWithTextContentOnly } from './nodeChecks';
+const wrapIntoTaskOrDecisionList = (nodes, targetNodeTypeName, schema) => {
+  const itemNodeType = targetNodeTypeName === 'taskList' ? schema.nodes.taskItem : schema.nodes.decisionItem;
+  const inlineContent = nodes.flatMap(node => {
+    if (node.isTextblock) {
+      return node.children;
+    } else if (node.isText) {
+      return [node];
+    }
+    return [];
+  });
+  const itemNode = itemNodeType.create({}, inlineContent);
+  const outputNode = schema.nodes[targetNodeTypeName].createAndFill({}, itemNode);
+  return outputNode ? [outputNode] : nodes;
+};
+const wrapIntoBulletOrOrderedList = (nodes, targetNodeTypeName, schema) => {
+  const listItemNode = schema.nodes.listItem.createAndFill({}, nodes);
+  const outputNode = schema.nodes[targetNodeTypeName].createAndFill({}, listItemNode);
+  return outputNode ? [outputNode] : nodes;
+};
+
+/**
+ * Wraps nodes into bullet list, numbered list, task list, or decision list.
+ *
+ * @param nodes - The nodes to wrap.
+ * @param context - The transformation context containing schema and target node type.
+ * @returns The wrapped nodes.
+ */
 export const wrapIntoListStep = (nodes, context) => {
   const {
     schema,
     targetNodeTypeName
   } = context;
-  const listItemNode = schema.nodes.listItem.createAndFill({}, nodes);
-  const outputNode = schema.nodes[targetNodeTypeName].createAndFill({}, listItemNode);
-  if (outputNode) {
-    return [outputNode];
-  }
-  return nodes;
+  return isListWithTextContentOnly(targetNodeTypeName, schema) ? wrapIntoTaskOrDecisionList(nodes, targetNodeTypeName, schema) : wrapIntoBulletOrOrderedList(nodes, targetNodeTypeName, schema);
 };

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

@@ -23,8 +23,9 @@ export const transformNode = api =>
       $from,
       $to
     } = expandSelectionToBlockRange(preservedSelection);
-    const isNested = isNestedNode(preservedSelection, '');
     const selectedParent = $from.parent;
+    const isParentLayout = selectedParent.type === nodes.layoutColumn;
+    const isNestedExceptLayout = isNestedNode(preservedSelection, '') && !isParentLayout;
     let fragment = Fragment.empty;
     const isList = isListNode(selectedParent);
     const slice = tr.doc.slice(isList ? $from.pos - 1 : $from.pos, isList ? $to.pos + 1 : $to.pos);
@@ -33,7 +34,7 @@ export const transformNode = api =>
         sourceNode: node,
         targetNodeType: targetType,
         schema: tr.doc.type.schema,
-        isNested
+        isNested: isNestedExceptLayout
       });
       if (outputNode) {
         fragment = fragment.append(Fragment.fromArray(outputNode));

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

@@ -188,9 +188,7 @@ export const getBlockMenuComponents = ({
     component: ({
       children
     }) => {
-      return /*#__PURE__*/React.createElement(DeleteSection, {
-        api: api
-      }, children);
+      return /*#__PURE__*/React.createElement(DeleteSection, null, children);
     }
   }, {
     type: 'block-menu-item',

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

@@ -124,7 +124,7 @@ const BlockMenu = ({
   boundariesElement,
   scrollableElement
 }) => {
-  var _editorView$dom, _ref;
+  var _editorView$dom, _ref, _api$analytics3;
   const {
     menuTriggerBy,
     isSelectedViaDragHandle,
@@ -194,6 +194,13 @@ const BlockMenu = ({
       return tr;
     });
   };
+  const handleClickOutside = e => {
+    // check if the clicked element was another drag handle, if so don't close the menu
+    if (e.target instanceof HTMLElement && e.target.closest(DRAG_HANDLE_SELECTOR)) {
+      return;
+    }
+    closeMenu();
+  };
   const closeMenu = () => {
     api === null || api === void 0 ? void 0 : api.core.actions.execute(({
       tr
@@ -220,39 +227,37 @@ const BlockMenu = ({
       popupRef.current = el;
     }
   };
-  if (targetHandleRef instanceof HTMLElement) {
-    var _api$analytics3;
-    return /*#__PURE__*/React.createElement(ErrorBoundary, {
-      component: ACTION_SUBJECT.BLOCK_MENU,
-      dispatchAnalyticsEvent: api === null || api === void 0 ? void 0 : (_api$analytics3 = api.analytics) === null || _api$analytics3 === void 0 ? void 0 : _api$analytics3.actions.fireAnalyticsEvent,
-      fallbackComponent: null
-    }, /*#__PURE__*/React.createElement(PopupWithListeners, {
-      alignX: 'right',
-      alignY: 'start',
-      handleClickOutside: closeMenu,
-      handleEscapeKeydown: closeMenu,
-      handleBackspaceDeleteKeydown: handleBackspaceDeleteKeydown,
-      mountTo: mountTo,
-      boundariesElement: boundariesElement,
-      scrollableElement: scrollableElement,
-      target: targetHandleRef,
-      zIndex: akEditorFloatingOverlapPanelZIndex,
-      fitWidth: DEFAULT_MENU_WIDTH,
-      fitHeight: menuHeight,
-      preventOverflow: true,
-      stick: true,
-      offset: [DRAG_HANDLE_WIDTH + DRAG_HANDLE_OFFSET_PADDING, targetHandleHeightOffset],
-      focusTrap: openedViaKeyboard ?
-      // Only enable focus trap when opened via keyboard to make sure the focus is on the first focusable menu item
-      {
-        initialFocus: undefined
-      } : undefined
-    }, /*#__PURE__*/React.createElement(BlockMenuContent, {
-      api: api,
-      setRef: setRef
-    })));
-  } else {
+  if (!(targetHandleRef instanceof HTMLElement)) {
     return null;
   }
+  return /*#__PURE__*/React.createElement(ErrorBoundary, {
+    component: ACTION_SUBJECT.BLOCK_MENU,
+    dispatchAnalyticsEvent: api === null || api === void 0 ? void 0 : (_api$analytics3 = api.analytics) === null || _api$analytics3 === void 0 ? void 0 : _api$analytics3.actions.fireAnalyticsEvent,
+    fallbackComponent: null
+  }, /*#__PURE__*/React.createElement(PopupWithListeners, {
+    alignX: 'right',
+    alignY: 'start',
+    handleClickOutside: handleClickOutside,
+    handleEscapeKeydown: closeMenu,
+    handleBackspaceDeleteKeydown: handleBackspaceDeleteKeydown,
+    mountTo: mountTo,
+    boundariesElement: boundariesElement,
+    scrollableElement: scrollableElement,
+    target: targetHandleRef,
+    zIndex: akEditorFloatingOverlapPanelZIndex,
+    fitWidth: DEFAULT_MENU_WIDTH,
+    fitHeight: menuHeight,
+    preventOverflow: true,
+    stick: true,
+    offset: [DRAG_HANDLE_WIDTH + DRAG_HANDLE_OFFSET_PADDING, targetHandleHeightOffset],
+    focusTrap: openedViaKeyboard ?
+    // Only enable focus trap when opened via keyboard to make sure the focus is on the first focusable menu item
+    {
+      initialFocus: undefined
+    } : undefined
+  }, /*#__PURE__*/React.createElement(BlockMenuContent, {
+    api: api,
+    setRef: setRef
+  })));
 };
 export default injectIntl(BlockMenu);

package/dist/es2019/ui/copy-link.js

@@ -84,8 +84,8 @@ const CopyLinkDropdownItemContent = ({
     });
   }, [api, blockLinkHashPrefix, getLinkPath, onDropdownOpenChanged, selection]);
 
-  // Hide copy link when `platform_editor_adf_with_localid` feature flag is off or when the node is nested or on empty line
-  if (!fg('platform_editor_adf_with_localid') || !!menuTriggerBy && isNestedNode(selection, menuTriggerBy) || selection !== null && selection !== void 0 && selection.empty) {
+  // Hide copy link when `platform_editor_adf_with_localid` feature flag is off or when the node is nested
+  if (!fg('platform_editor_adf_with_localid') || !!menuTriggerBy && isNestedNode(selection, menuTriggerBy)) {
     return null;
   }
   return /*#__PURE__*/React.createElement(ToolbarDropdownItem, {

package/dist/es2019/ui/delete-section.js

@@ -1,15 +1,8 @@
 import React from 'react';
 import { ToolbarDropdownItemSection } from '@atlaskit/editor-toolbar';
 export const DeleteSection = ({
-  api,
   children
 }) => {
-  var _api$selection, _api$selection$shared, _api$selection$shared2;
-  const selection = api === null || api === void 0 ? void 0 : (_api$selection = api.selection) === null || _api$selection === void 0 ? void 0 : (_api$selection$shared = _api$selection.sharedState) === null || _api$selection$shared === void 0 ? void 0 : (_api$selection$shared2 = _api$selection$shared.currentState()) === null || _api$selection$shared2 === void 0 ? void 0 : _api$selection$shared2.selection;
-  const isEmptyLineSelected = !!(selection !== null && selection !== void 0 && selection.empty);
-  if (isEmptyLineSelected) {
-    return null;
-  }
   return /*#__PURE__*/React.createElement(ToolbarDropdownItemSection, {
     hasSeparator: true
   }, children);

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

@@ -0,0 +1,27 @@
+/**
+ * Checks if a node is a list type that supports indentation (bulletList, orderedList, taskList).
+ *
+ * @param node - The node to check.
+ * @param schema - ProseMirror schema for check
+ * @returns True if the node is a list type, false otherwise.
+ */
+export var isListWithIndentation = function isListWithIndentation(nodeTypeName, schema) {
+  var lists = [schema.nodes.taskList, schema.nodes.bulletList, schema.nodes.orderedList];
+  return lists.some(function (list) {
+    return list.name === nodeTypeName;
+  });
+};
+
+/**
+ * Checks if a node is a list where its list items only support text content (taskList or decisionList).
+ *
+ * @param nodeTypeName - The node type name to check.
+ * @param schema - ProseMirror schema for check
+ * @returns True if the node is a list text type, false otherwise.
+ */
+export var isListWithTextContentOnly = function isListWithTextContentOnly(nodeTypeName, schema) {
+  var lists = [schema.nodes.taskList, schema.nodes.decisionList];
+  return lists.some(function (list) {
+    return list.name === nodeTypeName;
+  });
+};

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

@@ -1,7 +1,9 @@
 import { Fragment } from '@atlaskit/editor-prosemirror/model';
-var extractNestedLists = function extractNestedLists(node, listTypes, itemTypes, schema) {
+import { isListWithIndentation } from '../nodeChecks';
+var extractNestedLists = function extractNestedLists(node, schema) {
   var items = [];
   var paragraph = schema.nodes.paragraph;
+  var itemTypes = [schema.nodes.listItem, schema.nodes.taskItem];
   var _extract = function extract(currentNode) {
     currentNode.forEach(function (child) {
       if (itemTypes.some(function (type) {
@@ -10,9 +12,7 @@ var extractNestedLists = function extractNestedLists(node, listTypes, itemTypes,
         var contentWithoutNestedLists = [];
         var nestedLists = [];
         child.forEach(function (grandChild) {
-          if (listTypes.some(function (type) {
-            return grandChild.type === type;
-          })) {
+          if (isListWithIndentation(grandChild.type.name, schema)) {
             nestedLists.push(grandChild);
           } else if (grandChild.isText) {
             contentWithoutNestedLists.push(paragraph.createAndFill({}, grandChild));
@@ -24,9 +24,7 @@ var extractNestedLists = function extractNestedLists(node, listTypes, itemTypes,
         nestedLists.forEach(function (nestedList) {
           _extract(nestedList);
         });
-      } else if (listTypes.some(function (type) {
-        return child.type === type;
-      })) {
+      } else if (isListWithIndentation(child.type.name, schema)) {
         _extract(child);
       }
     });
@@ -65,12 +63,9 @@ var extractNestedLists = function extractNestedLists(node, listTypes, itemTypes,
  * TODO: Lists with mixed types (e.g. bulletList with a taskItem) doesn't full flatten
  */
 export var flattenListStep = function flattenListStep(nodes, context) {
-  var listTypes = [context.schema.nodes.bulletList, context.schema.nodes.orderedList, context.schema.nodes.taskList];
   return nodes.map(function (node) {
-    if (listTypes.some(function (type) {
-      return node.type === type;
-    })) {
-      return node.copy(Fragment.from(extractNestedLists(node, listTypes, [context.schema.nodes.listItem, context.schema.nodes.taskItem], context.schema)));
+    if (isListWithIndentation(node.type.name, context.schema)) {
+      return node.copy(Fragment.from(extractNestedLists(node, context.schema)));
     }
     return node;
   });

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

@@ -1,6 +1,5 @@
 import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
-import { isListType } from '../utils';
-
+import { isListWithIndentation } from '../nodeChecks';
 /**
  * Transforms a bulletList, orderedList, or taskList into a decisionList.
  *
@@ -29,7 +28,7 @@ export var listToDecisionListStep = function listToDecisionListStep(nodes, conte
   var paragraphType = schema.nodes.paragraph;
   var unsupportedContent = [];
   var transformedNodes = nodes.map(function (node) {
-    if (!isListType(node, schema)) {
+    if (!isListWithIndentation(node.type.name, schema)) {
       return node;
     }
     var decisionItems = [];
@@ -41,7 +40,7 @@ export var listToDecisionListStep = function listToDecisionListStep(nodes, conte
           itemContent.push.apply(itemContent, _toConsumableArray(child.children));
         } else if (child.isText) {
           itemContent.push(child);
-        } else if (!isListType(child, schema)) {
+        } else if (!isListWithIndentation(child.type.name, schema)) {
           unsupportedContent.push(child);
         }
       });

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

@@ -1,7 +1,6 @@
 import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
 import { Fragment } from '@atlaskit/editor-prosemirror/model';
-import { isListType } from '../utils';
-
+import { isListWithIndentation } from '../nodeChecks';
 /**
  * Recursively converts nested lists to the target list type.
  * This function handles the conversion of both the list container and its items,
@@ -15,13 +14,13 @@ var _transformList = function transformList(node, targetListType, targetItemType
   var schema = node.type.schema;
   var taskListType = schema.nodes.taskList;
   var isSourceTaskList = node.type === taskListType;
-  var isTargetTaskList = targetListType === 'taskList';
+  var isTargetTaskList = targetListType === taskListType.name;
   var convertFromTaskListStructure = function convertFromTaskListStructure(node, targetListType, targetItemType) {
     var schema = node.type.schema;
     var targetListNodeType = schema.nodes[targetListType];
     var transformedContent = [];
     node.forEach(function (child) {
-      if (isListType(child, schema)) {
+      if (isListWithIndentation(child.type.name, schema)) {
         // This is a nested list - it should become a child of the previous item
         if (transformedContent.length > 0) {
           var previousItem = transformedContent[transformedContent.length - 1];
@@ -33,7 +32,7 @@ var _transformList = function transformList(node, targetListType, targetItemType
         }
         // If there's no previous item, skip this nested list (orphaned)
       } else {
-        var transformedItem = transformListItem(child, targetItemType, targetListType);
+        var transformedItem = transformListItem(child, targetListType, targetItemType);
         if (transformedItem) {
           transformedContent.push(transformedItem);
         }
@@ -46,19 +45,19 @@ var _transformList = function transformList(node, targetListType, targetItemType
     var targetListNodeType = schema.nodes[targetListType];
     var transformedContent = [];
     node.forEach(function (itemNode) {
-      var transformedItem = transformListItem(itemNode, targetItemType, targetListType, true);
+      var transformedItem = transformListItem(itemNode, targetListType, targetItemType, true);
       if (transformedItem) {
         transformedContent.push(transformedItem);
       }
       itemNode.forEach(function (child) {
-        if (isListType(child, schema)) {
+        if (isListWithIndentation(child.type.name, schema)) {
           transformedContent.push(_transformList(child, targetListType, targetItemType, unsupportedContent));
         }
       });
     });
     return targetListNodeType.create(node.attrs, transformedContent);
   };
-  var transformListItem = function transformListItem(itemNode, targetItemType, targetListType) {
+  var transformListItem = function transformListItem(itemNode, targetListType, targetItemType) {
     var excludeNestedLists = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
     var schema = itemNode.type.schema;
     var targetItemNodeType = schema.nodes[targetItemType];
@@ -73,7 +72,7 @@ var _transformList = function transformList(node, targetListType, targetItemType
         } else if (child.isText) {
           inlineContent.push(child);
           // Nested lists will be extracted and placed as siblings in the taskList
-        } else if (!isListType(child, schema)) {
+        } else if (!isListWithIndentation(child.type.name, schema)) {
           unsupportedContent.push(child);
         }
       });
@@ -84,7 +83,7 @@ var _transformList = function transformList(node, targetListType, targetItemType
       transformedContent.push(paragraphType.create(null, itemNode.content));
     } else {
       itemNode.forEach(function (child) {
-        if (isListType(child, schema)) {
+        if (isListWithIndentation(child.type.name, schema)) {
           if (excludeNestedLists) {
             // Skip nested lists - they will be handled separately as siblings
             return;
@@ -104,7 +103,7 @@ var _transformList = function transformList(node, targetListType, targetItemType
     var targetListNodeType = schema.nodes[targetListType];
     var transformedContent = [];
     node.forEach(function (childNode) {
-      var transformedItem = isListType(childNode, schema) ? _transformList(childNode, targetListType, targetItemType, unsupportedContent) : transformListItem(childNode, targetItemType, targetListType);
+      var transformedItem = isListWithIndentation(childNode.type.name, schema) ? _transformList(childNode, targetListType, targetItemType, unsupportedContent) : transformListItem(childNode, targetListType, targetItemType);
       if (transformedItem) {
         transformedContent.push(transformedItem);
       }
@@ -187,7 +186,7 @@ export var listToListStep = function listToListStep(nodes, context) {
     targetNodeTypeName = context.targetNodeTypeName;
   var unsupportedContent = [];
   var transformedNodes = nodes.map(function (node) {
-    if (isListType(node, schema)) {
+    if (isListWithIndentation(node.type.name, schema)) {
       var targetItemType = targetNodeTypeName === 'taskList' ? 'taskItem' : 'listItem';
       return _transformList(node, targetNodeTypeName, targetItemType, unsupportedContent);
     }

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

@@ -0,0 +1,16 @@
+import { createTextContent } from '../utils';
+
+/**
+ * Transforms a paragraph (or heading) into a codeBlock by extracting its text content.
+ * This step handles the conversion of inline content (including marks) to plain text,
+ * which is required because codeBlocks can only contain plain text nodes.
+ *
+ * Example: paragraph with bold/italic/status → codeBlock with plain text
+ */
+export var wrapTextToCodeblockStep = function wrapTextToCodeblockStep(nodes, context) {
+  var schema = context.schema;
+  return nodes.map(function (node) {
+    var codeBlockNode = schema.nodes.codeBlock.createAndFill({}, schema.text(createTextContent(node)));
+    return codeBlockNode !== null && codeBlockNode !== void 0 ? codeBlockNode : node;
+  });
+};