@atlaskit/editor-plugin-block-menu 5.2.19 → 5.2.21

package/dist/es2019/editor-actions/isTrasformToTargetDisabled.js

@@ -0,0 +1,110 @@
+import { expandSelectionToBlockRange } from '@atlaskit/editor-common/selection';
+import { Fragment } from '@atlaskit/editor-prosemirror/model';
+import { isTransformDisabledBasedOnStepsConfig } from '../editor-commands/transform-node-utils/transform';
+import { toNodeTypeValue } from '../editor-commands/transform-node-utils/types';
+import { getBlockNodesInRange, getTargetNodeTypeNameInContext } from '../editor-commands/transform-node-utils/utils';
+export const canParentContainNodeType = (schema, parentNode, nodeTypeName, nodeTypeAttrs) => {
+  const adjustedNodeTypeName = getTargetNodeTypeNameInContext(nodeTypeName, true);
+  if (!adjustedNodeTypeName) {
+    return false;
+  }
+  const nodeType = schema.nodes[adjustedNodeTypeName];
+  return parentNode.type.validContent(Fragment.from(nodeType.createAndFill(nodeTypeAttrs)));
+};
+const isHeadingToHeadingTransformEnabled = (selectedNode, targetNodeTypeAttrs) => {
+  var _selectedNode$attrs;
+  const selectedLevel = (_selectedNode$attrs = selectedNode.attrs) === null || _selectedNode$attrs === void 0 ? void 0 : _selectedNode$attrs.level;
+  const targetLevel = targetNodeTypeAttrs === null || targetNodeTypeAttrs === void 0 ? void 0 : targetNodeTypeAttrs.level;
+  if (selectedLevel === undefined || targetLevel === undefined) {
+    return false;
+  }
+  return selectedLevel !== targetLevel;
+};
+const isTransformEnabledForNode = (node, targetNodeTypeName, targetNodeTypeAttrs, isNested, parent, schema) => {
+  const selectedNodeTypeName = toNodeTypeValue(node.type.name);
+  if (!selectedNodeTypeName) {
+    return false;
+  }
+  const isDisabledByStepsConfig = isTransformDisabledBasedOnStepsConfig(selectedNodeTypeName, targetNodeTypeName);
+  if (isDisabledByStepsConfig) {
+    return false;
+  }
+  if (selectedNodeTypeName === 'heading' && targetNodeTypeName === 'heading') {
+    return isHeadingToHeadingTransformEnabled(node, targetNodeTypeAttrs);
+  }
+  if (isNested && !canParentContainNodeType(schema, parent, targetNodeTypeName, targetNodeTypeAttrs)) {
+    return false;
+  }
+  return true;
+};
+export const isTrasformToTargetDisabled = ({
+  selection,
+  targetNodeTypeName,
+  targetNodeTypeAttrs
+}) => {
+  const {
+    range
+  } = expandSelectionToBlockRange(selection);
+  if (!range) {
+    return false;
+  }
+  const selectedNodes = getBlockNodesInRange(range);
+  const parent = range.parent;
+  const isNested = range.depth >= 1;
+  const {
+    schema
+  } = selection.$from.doc.type;
+  const supportedTargetNodeTypeName = toNodeTypeValue(targetNodeTypeName);
+  if (!supportedTargetNodeTypeName) {
+    return true;
+  }
+  const isEnabledForAnyNode = selectedNodes.some(node => isTransformEnabledForNode(node, supportedTargetNodeTypeName, targetNodeTypeAttrs, isNested, parent, schema));
+  return !isEnabledForAnyNode;
+};
+
+// export const isTrasformToTargetDisabled = ({
+// 	selection,
+// 	targetNodeTypeName,
+// 	targetNodeTypeAttrs,
+// }: TransformDisabledArgs) => {
+// 	const { range } = expandSelectionToBlockRange(selection);
+// 	if (!range) {
+// 		return false;
+// 	}
+
+// 	const selectedNodes = getBlockNodesInRange(range);
+// 	const parent = range.parent;
+// 	const isNested = range.depth >= 1;
+
+// 	const { schema } = selection.$from.doc.type;
+
+// 	const isTransformEnabledForAnySelectedNode = selectedNodes.some((node) => {
+// 		const selectedNodeTypeName = toNodeTypeValue(node.type.name);
+// 		const supportedTargetNodeTypeName = toNodeTypeValue(targetNodeTypeName);
+// 		if (!selectedNodeTypeName || !supportedTargetNodeTypeName) {
+// 			return false;
+// 		}
+
+// 		if (isTransformDisabledBasedOnStepsConfig(selectedNodeTypeName, supportedTargetNodeTypeName)) {
+// 			if (selectedNodeTypeName === 'heading' && supportedTargetNodeTypeName === 'heading') {
+// 				return isHeadingToHeadingTransformDisabled(node, targetNodeTypeAttrs);
+// 			}
+// 			return false;
+// 		}
+
+// 		if (
+// 			isNested &&
+// 			!canParentContainNodeType(schema, parent, supportedTargetNodeTypeName, targetNodeTypeAttrs)
+// 		) {
+// 			return false;
+// 		}
+
+// 		return true;
+// 	});
+
+// 	if (isTransformEnabledForAnySelectedNode) {
+// 		return false;
+// 	}
+
+// 	return true;
+// };

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

@@ -39,7 +39,7 @@ export const listToDecisionListStep = (nodes, context) => {
         if (child.type === paragraphType) {
           // paragraph may contain hard breaks etc.
           itemContent.push(...child.children);
-        } else if (child.isText) {
+        } else if (child.isText || child.isInline) {
           itemContent.push(child);
         } else if (!isListWithIndentation(child.type.name, schema)) {
           unsupportedContent.push(child);

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

@@ -1,5 +1,6 @@
 import { Fragment } from '@atlaskit/editor-prosemirror/model';
 import { NODE_CATEGORY_BY_TYPE } from '../types';
+import { convertTextNodeToParagraph } from '../utils';
 
 /**
  * Determines if a node is a text node (heading or paragraph).
@@ -10,21 +11,6 @@ const isTextNode = node => {
   return category === 'text';
 };
 
-/**
- * Converts a text node (heading, paragraph) to a paragraph preserving its inline content.
- * This is used when a text node can't be wrapped directly in the target container
- * (e.g., heading can't go in blockquote, so it becomes a paragraph).
- */
-const convertTextNodeToParagraph = (node, schema) => {
-  var _schema$nodes$paragra;
-  // If it's already a paragraph, return as-is
-  if (node.type.name === 'paragraph') {
-    return node;
-  }
-  // Convert heading (or other text node) to paragraph with same inline content
-  return (_schema$nodes$paragra = schema.nodes.paragraph.createAndFill({}, node.content)) !== null && _schema$nodes$paragra !== void 0 ? _schema$nodes$paragra : null;
-};
-
 /**
  * Determines if a node can be wrapped in the target container type.
  * Uses the schema's validContent to check if the target container can hold this node.

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

@@ -10,7 +10,6 @@ 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';
 import { unwrapStep } from './unwrapStep';
@@ -40,7 +39,7 @@ const TRANSFORM_STEPS = {
   },
   text: {
     atomic: undefined,
-    container: [wrapStep],
+    container: [wrapMixedContentStep],
     list: [wrapIntoListStep],
     text: [flattenStep, applyTargetTextTypeStep]
   }
@@ -48,102 +47,166 @@ const TRANSFORM_STEPS = {
 
 // Transform steps for specific pairs of node types that cannot be processed
 // using generic rules/steps from TRANSFORM_STEPS.
+// Use 'null' to indicate unavailable transfrorm for a case where TRANSFORM_STEPS are not undefined.
 const TRANSFORM_STEPS_OVERRIDE = {
   paragraph: {
+    paragraph: null,
+    codeBlock: [wrapTextToCodeblockStep],
+    layoutSection: [wrapIntoLayoutStep]
+  },
+  heading: {
     codeBlock: [wrapTextToCodeblockStep],
     layoutSection: [wrapIntoLayoutStep]
   },
   panel: {
+    panel: null,
     layoutSection: [unwrapStep, wrapIntoLayoutStep],
     codeBlock: [unwrapStep, flattenStep, wrapStep],
-    blockquote: [unwrapStep, wrapMixedContentStep]
+    blockquote: [unwrapStep, wrapMixedContentStep],
+    taskList: null,
+    bulletList: null,
+    orderedList: null,
+    heading: null
   },
   expand: {
+    expand: null,
     panel: [unwrapExpandStep, wrapMixedContentStep],
     blockquote: [unwrapExpandStep, wrapMixedContentStep],
     layoutSection: [unwrapExpandStep, wrapIntoLayoutStep],
     paragraph: [unwrapExpandStep],
-    codeBlock: [unwrapExpandStep, flattenStep, wrapStep]
+    codeBlock: null,
+    heading: null
   },
   nestedExpand: {
+    expand: null,
+    nestedExpand: null,
     panel: [unwrapExpandStep, wrapMixedContentStep],
     blockquote: [unwrapExpandStep, wrapMixedContentStep],
     paragraph: [unwrapExpandStep],
-    codeBlock: [unwrapExpandStep, flattenStep, wrapStep]
+    codeBlock: null,
+    heading: null
   },
   blockquote: {
+    blockquote: null,
     expand: [wrapStep],
     nestedExpand: [wrapStep],
     layoutSection: [wrapIntoLayoutStep],
-    codeBlock: [unwrapStep, flattenStep, wrapStep],
+    codeBlock: null,
     decisionList: [unwrapStep, wrapBlockquoteToDecisionListStep]
   },
   layoutSection: {
+    layoutSection: null,
     blockquote: [unwrapLayoutStep, wrapMixedContentStep],
     expand: [unwrapLayoutStep, wrapStep],
     panel: [unwrapLayoutStep, wrapMixedContentStep],
-    codeBlock: [unwrapLayoutStep, flattenStep, wrapStep],
-    paragraph: [unwrapLayoutStep]
+    codeBlock: null,
+    paragraph: [unwrapLayoutStep],
+    heading: null
   },
   codeBlock: {
+    codeBlock: null,
     blockquote: [wrapStep],
     expand: [wrapStep],
     nestedExpand: [wrapStep],
     layoutSection: [wrapIntoLayoutStep],
-    panel: [wrapStep]
+    panel: [wrapStep],
+    heading: null
   },
   bulletList: {
-    // Text transformations currently not in scope > options will be disabled > stubbing in case
-    codeBlock: [stubStep],
+    bulletList: null,
+    codeBlock: null,
     layoutSection: [wrapIntoLayoutStep],
-    decisionList: [flattenListStep, listToDecisionListStep]
+    decisionList: [flattenListStep, listToDecisionListStep],
+    heading: null
   },
   orderedList: {
-    // Text transformations currently not in scope > options will be disabled > stubbing in case
-    codeBlock: [stubStep],
+    orderedList: null,
+    codeBlock: null,
     layoutSection: [wrapIntoLayoutStep],
-    decisionList: [flattenListStep, listToDecisionListStep]
+    decisionList: [flattenListStep, listToDecisionListStep],
+    heading: null
   },
   taskList: {
-    // Text transformations currently not in scope > options will be disabled > stubbing in case
-    blockquote: [stubStep],
-    codeBlock: [stubStep],
+    blockquote: null,
+    codeBlock: null,
     layoutSection: [wrapIntoLayoutStep],
-    decisionList: [flattenListStep, listToDecisionListStep]
+    decisionList: [flattenListStep, listToDecisionListStep],
+    heading: null,
+    taskList: null
   },
   table: {
-    layoutSection: [wrapIntoLayoutStep]
+    layoutSection: [wrapIntoLayoutStep],
+    blockquote: null,
+    panel: null,
+    codeBlock: null,
+    orderedList: null,
+    bulletList: null,
+    taskList: null,
+    decisionList: null
   },
   mediaSingle: {
-    layoutSection: [wrapIntoLayoutStep]
+    layoutSection: [wrapIntoLayoutStep],
+    codeBlock: null,
+    decisionList: null,
+    taskList: null
   },
   mediaGroup: {
-    layoutSection: [wrapIntoLayoutStep]
+    layoutSection: [wrapIntoLayoutStep],
+    codeBlock: null
   },
   decisionList: {
+    decisionList: null,
     bulletList: [decisionListToListStep],
     orderedList: [decisionListToListStep],
     taskList: [decisionListToListStep],
     layoutSection: [wrapIntoLayoutStep]
   },
   blockCard: {
-    layoutSection: [wrapIntoLayoutStep]
+    layoutSection: [wrapIntoLayoutStep],
+    blockquote: null,
+    codeBlock: null,
+    orderedList: null,
+    bulletList: null,
+    taskList: null,
+    decisionList: null
   },
   embedCard: {
-    layoutSection: [wrapIntoLayoutStep]
+    layoutSection: [wrapIntoLayoutStep],
+    blockquote: null,
+    panel: null,
+    codeBlock: null,
+    orderedList: null,
+    bulletList: null,
+    taskList: null,
+    decisionList: null
   },
   extension: {
-    layoutSection: [wrapIntoLayoutStep]
+    layoutSection: [wrapIntoLayoutStep],
+    codeBlock: null,
+    decisionList: null,
+    taskList: null
   },
   bodiedExtension: {
-    layoutSection: [wrapIntoLayoutStep]
+    layoutSection: [wrapIntoLayoutStep],
+    blockquote: null,
+    expand: null,
+    panel: null,
+    codeBlock: null,
+    orderedList: null,
+    bulletList: null,
+    taskList: null,
+    decisionList: null
   }
 };
 const getTransformStepsForNodeTypes = (selectedNodeTypeName, targetNodeTypeName) => {
-  var _TRANSFORM_STEPS_OVER, _TRANSFORM_STEPS_OVER2;
+  var _TRANSFORM_STEPS_OVER;
   const fromCategory = NODE_CATEGORY_BY_TYPE[selectedNodeTypeName];
   const toCategory = NODE_CATEGORY_BY_TYPE[targetNodeTypeName];
-  const steps = (_TRANSFORM_STEPS_OVER = (_TRANSFORM_STEPS_OVER2 = TRANSFORM_STEPS_OVERRIDE[selectedNodeTypeName]) === null || _TRANSFORM_STEPS_OVER2 === void 0 ? void 0 : _TRANSFORM_STEPS_OVER2[targetNodeTypeName]) !== null && _TRANSFORM_STEPS_OVER !== void 0 ? _TRANSFORM_STEPS_OVER : TRANSFORM_STEPS[fromCategory][toCategory];
+  const overrideSteps = (_TRANSFORM_STEPS_OVER = TRANSFORM_STEPS_OVERRIDE[selectedNodeTypeName]) === null || _TRANSFORM_STEPS_OVER === void 0 ? void 0 : _TRANSFORM_STEPS_OVER[targetNodeTypeName];
+  if (overrideSteps === null) {
+    return null;
+  }
+  const steps = overrideSteps !== null && overrideSteps !== void 0 ? overrideSteps : TRANSFORM_STEPS[fromCategory][toCategory];
   return steps;
 };
 // Note: Currently works only for single node in the selection
@@ -175,4 +238,11 @@ export const getOutputNodes = ({
   return steps.reduce((nodes, step) => {
     return step(nodes, context);
   }, nodesToReplace);
+};
+export const isTransformDisabledBasedOnStepsConfig = (selectedNodeType, targetNodeType) => {
+  const steps = getTransformStepsForNodeTypes(selectedNodeType, targetNodeType);
+  if (!steps || steps.length === 0) {
+    return true;
+  }
+  return false;
 };

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

@@ -82,6 +82,21 @@ export const convertExpandToNestedExpand = (node, schema) => {
     title: ((_node$attrs2 = node.attrs) === null || _node$attrs2 === void 0 ? void 0 : _node$attrs2.title) || ''
   }, node.content);
 };
+
+/**
+ * Converts a text node (heading, paragraph) to a paragraph preserving its inline content.
+ * This is used when a text node can't be wrapped directly in the target container
+ * (e.g., heading can't go in blockquote, so it becomes a paragraph).
+ */
+export const convertTextNodeToParagraph = (node, schema) => {
+  var _schema$nodes$paragra;
+  // If it's already a paragraph, return as-is
+  if (node.type.name === 'paragraph') {
+    return node;
+  }
+  // Convert heading (or other text node) to paragraph with same inline content
+  return (_schema$nodes$paragra = schema.nodes.paragraph.createAndFill({}, node.content)) !== null && _schema$nodes$paragra !== void 0 ? _schema$nodes$paragra : null;
+};
 export const getBlockNodesInRange = range => {
   if (range.startIndex === range.endIndex) {
     return [];

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

@@ -1,4 +1,5 @@
 import { isListWithTextContentOnly } from './nodeChecks';
+import { convertTextNodeToParagraph } from './utils';
 const wrapIntoTaskOrDecisionList = (nodes, targetNodeTypeName, schema) => {
   const itemNodeType = targetNodeTypeName === 'taskList' ? schema.nodes.taskItem : schema.nodes.decisionItem;
   const inlineContent = nodes.flatMap(node => {
@@ -14,8 +15,11 @@ const wrapIntoTaskOrDecisionList = (nodes, targetNodeTypeName, schema) => {
   return outputNode ? [outputNode] : nodes;
 };
 const wrapIntoBulletOrOrderedList = (nodes, targetNodeTypeName, schema) => {
-  const listItemNode = schema.nodes.listItem.createAndFill({}, nodes);
-  const outputNode = schema.nodes[targetNodeTypeName].createAndFill({}, listItemNode);
+  const listItemNodes = nodes.map(node => schema.nodes.listItem.createAndFill({}, node.isTextblock ? convertTextNodeToParagraph(node, schema) : node)).filter(node => node !== null);
+  if (listItemNodes.length === 0) {
+    return nodes;
+  }
+  const outputNode = schema.nodes[targetNodeTypeName].createAndFill({}, listItemNodes);
   return outputNode ? [outputNode] : nodes;
 };
 

package/dist/esm/blockMenuPlugin.js

@@ -1,5 +1,6 @@
 import React from 'react';
 import { createBlockMenuRegistry } from './editor-actions';
+import { isTrasformToTargetDisabled } from './editor-actions/isTrasformToTargetDisabled';
 import { formatNode as _formatNode } from './editor-commands/formatNode';
 import { transformNode as _transformNode } from './editor-commands/transformNode';
 import { blockMenuPluginKey, createPlugin } from './pm-plugins/main';
@@ -29,6 +30,20 @@ export var blockMenuPlugin = function blockMenuPlugin(_ref) {
       },
       getBlockMenuComponents: function getBlockMenuComponents() {
         return registry.components;
+      },
+      isTransformOptionDisabled: function isTransformOptionDisabled(optionNodeTypeName, optionNodeTypeAttrs) {
+        var _api$blockControls, _api$selection;
+        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;
+        var selection = api === null || api === void 0 || (_api$selection = api.selection) === null || _api$selection === void 0 || (_api$selection = _api$selection.sharedState) === null || _api$selection === void 0 || (_api$selection = _api$selection.currentState()) === null || _api$selection === void 0 ? void 0 : _api$selection.selection;
+        var currentSelection = preservedSelection || selection;
+        if (!currentSelection) {
+          return true;
+        }
+        return isTrasformToTargetDisabled({
+          selection: currentSelection,
+          targetNodeTypeName: optionNodeTypeName,
+          targetNodeTypeAttrs: optionNodeTypeAttrs
+        });
       }
     },
     commands: {
@@ -40,7 +55,7 @@ export var blockMenuPlugin = function blockMenuPlugin(_ref) {
       }
     },
     getSharedState: function getSharedState(editorState) {
-      var _api$blockControls, _pluginState$showFlag;
+      var _api$blockControls2, _pluginState$showFlag;
       if (!editorState) {
         return {
           currentSelectedNodeName: undefined,
@@ -49,7 +64,7 @@ export var blockMenuPlugin = function blockMenuPlugin(_ref) {
       }
 
       // Get the menuTriggerBy from blockControls plugin if available
-      var currentSelectedNodeName = 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.menuTriggerBy;
+      var currentSelectedNodeName = api === null || api === void 0 || (_api$blockControls2 = api.blockControls) === null || _api$blockControls2 === void 0 || (_api$blockControls2 = _api$blockControls2.sharedState.currentState()) === null || _api$blockControls2 === void 0 ? void 0 : _api$blockControls2.menuTriggerBy;
 
       // Get the showFlag from plugin state
       var pluginState = blockMenuPluginKey.getState(editorState);

package/dist/esm/editor-actions/isTrasformToTargetDisabled.js

@@ -0,0 +1,108 @@
+import { expandSelectionToBlockRange } from '@atlaskit/editor-common/selection';
+import { Fragment } from '@atlaskit/editor-prosemirror/model';
+import { isTransformDisabledBasedOnStepsConfig } from '../editor-commands/transform-node-utils/transform';
+import { toNodeTypeValue } from '../editor-commands/transform-node-utils/types';
+import { getBlockNodesInRange, getTargetNodeTypeNameInContext } from '../editor-commands/transform-node-utils/utils';
+export var canParentContainNodeType = function canParentContainNodeType(schema, parentNode, nodeTypeName, nodeTypeAttrs) {
+  var adjustedNodeTypeName = getTargetNodeTypeNameInContext(nodeTypeName, true);
+  if (!adjustedNodeTypeName) {
+    return false;
+  }
+  var nodeType = schema.nodes[adjustedNodeTypeName];
+  return parentNode.type.validContent(Fragment.from(nodeType.createAndFill(nodeTypeAttrs)));
+};
+var isHeadingToHeadingTransformEnabled = function isHeadingToHeadingTransformEnabled(selectedNode, targetNodeTypeAttrs) {
+  var _selectedNode$attrs;
+  var selectedLevel = (_selectedNode$attrs = selectedNode.attrs) === null || _selectedNode$attrs === void 0 ? void 0 : _selectedNode$attrs.level;
+  var targetLevel = targetNodeTypeAttrs === null || targetNodeTypeAttrs === void 0 ? void 0 : targetNodeTypeAttrs.level;
+  if (selectedLevel === undefined || targetLevel === undefined) {
+    return false;
+  }
+  return selectedLevel !== targetLevel;
+};
+var isTransformEnabledForNode = function isTransformEnabledForNode(node, targetNodeTypeName, targetNodeTypeAttrs, isNested, parent, schema) {
+  var selectedNodeTypeName = toNodeTypeValue(node.type.name);
+  if (!selectedNodeTypeName) {
+    return false;
+  }
+  var isDisabledByStepsConfig = isTransformDisabledBasedOnStepsConfig(selectedNodeTypeName, targetNodeTypeName);
+  if (isDisabledByStepsConfig) {
+    return false;
+  }
+  if (selectedNodeTypeName === 'heading' && targetNodeTypeName === 'heading') {
+    return isHeadingToHeadingTransformEnabled(node, targetNodeTypeAttrs);
+  }
+  if (isNested && !canParentContainNodeType(schema, parent, targetNodeTypeName, targetNodeTypeAttrs)) {
+    return false;
+  }
+  return true;
+};
+export var isTrasformToTargetDisabled = function isTrasformToTargetDisabled(_ref) {
+  var selection = _ref.selection,
+    targetNodeTypeName = _ref.targetNodeTypeName,
+    targetNodeTypeAttrs = _ref.targetNodeTypeAttrs;
+  var _expandSelectionToBlo = expandSelectionToBlockRange(selection),
+    range = _expandSelectionToBlo.range;
+  if (!range) {
+    return false;
+  }
+  var selectedNodes = getBlockNodesInRange(range);
+  var parent = range.parent;
+  var isNested = range.depth >= 1;
+  var schema = selection.$from.doc.type.schema;
+  var supportedTargetNodeTypeName = toNodeTypeValue(targetNodeTypeName);
+  if (!supportedTargetNodeTypeName) {
+    return true;
+  }
+  var isEnabledForAnyNode = selectedNodes.some(function (node) {
+    return isTransformEnabledForNode(node, supportedTargetNodeTypeName, targetNodeTypeAttrs, isNested, parent, schema);
+  });
+  return !isEnabledForAnyNode;
+};
+
+// export const isTrasformToTargetDisabled = ({
+// 	selection,
+// 	targetNodeTypeName,
+// 	targetNodeTypeAttrs,
+// }: TransformDisabledArgs) => {
+// 	const { range } = expandSelectionToBlockRange(selection);
+// 	if (!range) {
+// 		return false;
+// 	}
+
+// 	const selectedNodes = getBlockNodesInRange(range);
+// 	const parent = range.parent;
+// 	const isNested = range.depth >= 1;
+
+// 	const { schema } = selection.$from.doc.type;
+
+// 	const isTransformEnabledForAnySelectedNode = selectedNodes.some((node) => {
+// 		const selectedNodeTypeName = toNodeTypeValue(node.type.name);
+// 		const supportedTargetNodeTypeName = toNodeTypeValue(targetNodeTypeName);
+// 		if (!selectedNodeTypeName || !supportedTargetNodeTypeName) {
+// 			return false;
+// 		}
+
+// 		if (isTransformDisabledBasedOnStepsConfig(selectedNodeTypeName, supportedTargetNodeTypeName)) {
+// 			if (selectedNodeTypeName === 'heading' && supportedTargetNodeTypeName === 'heading') {
+// 				return isHeadingToHeadingTransformDisabled(node, targetNodeTypeAttrs);
+// 			}
+// 			return false;
+// 		}
+
+// 		if (
+// 			isNested &&
+// 			!canParentContainNodeType(schema, parent, supportedTargetNodeTypeName, targetNodeTypeAttrs)
+// 		) {
+// 			return false;
+// 		}
+
+// 		return true;
+// 	});
+
+// 	if (isTransformEnabledForAnySelectedNode) {
+// 		return false;
+// 	}
+
+// 	return true;
+// };

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) {
+        } else if (child.isText || child.isInline) {
           itemContent.push(child);
         } else if (!isListWithIndentation(child.type.name, schema)) {
           unsupportedContent.push(child);

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

@@ -1,6 +1,7 @@
 import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
 import { Fragment } from '@atlaskit/editor-prosemirror/model';
 import { NODE_CATEGORY_BY_TYPE } from '../types';
+import { convertTextNodeToParagraph } from '../utils';
 
 /**
  * Determines if a node is a text node (heading or paragraph).
@@ -11,21 +12,6 @@ var isTextNode = function isTextNode(node) {
   return category === 'text';
 };
 
-/**
- * Converts a text node (heading, paragraph) to a paragraph preserving its inline content.
- * This is used when a text node can't be wrapped directly in the target container
- * (e.g., heading can't go in blockquote, so it becomes a paragraph).
- */
-var convertTextNodeToParagraph = function convertTextNodeToParagraph(node, schema) {
-  var _schema$nodes$paragra;
-  // If it's already a paragraph, return as-is
-  if (node.type.name === 'paragraph') {
-    return node;
-  }
-  // Convert heading (or other text node) to paragraph with same inline content
-  return (_schema$nodes$paragra = schema.nodes.paragraph.createAndFill({}, node.content)) !== null && _schema$nodes$paragra !== void 0 ? _schema$nodes$paragra : null;
-};
-
 /**
  * Determines if a node can be wrapped in the target container type.
  * Uses the schema's validContent to check if the target container can hold this node.