@atlaskit/editor-plugin-block-menu 6.0.9 → 6.0.12

package/dist/cjs/ui/hooks/useSuggestedItems.js

@@ -6,9 +6,8 @@ Object.defineProperty(exports, "__esModule", {
 exports.useSuggestedItems = void 0;
 var _react = require("react");
 var _hooks = require("@atlaskit/editor-common/hooks");
-var _selection = require("@atlaskit/editor-common/selection");
-var _utils = require("../../editor-commands/transform-node-utils/utils");
-var _suggestedItemsRank = require("../utils/suggested-items-rank");
+var _createMenuItemsMap = require("../utils/createMenuItemsMap");
+var _getSuggestedItemsFromSelection = require("../utils/getSuggestedItemsFromSelection");
 var useSuggestedItems = exports.useSuggestedItems = function useSuggestedItems(api) {
   var _api$blockMenu;
   var _useSharedPluginState = (0, _hooks.useSharedPluginStateWithSelector)(api, ['blockControls', 'selection'], function (states) {
@@ -22,43 +21,11 @@ var useSuggestedItems = exports.useSuggestedItems = function useSuggestedItems(a
     selection = _useSharedPluginState.selection;
   var blockMenuComponents = api === null || api === void 0 || (_api$blockMenu = api.blockMenu) === null || _api$blockMenu === void 0 ? void 0 : _api$blockMenu.actions.getBlockMenuComponents();
   var menuItemsMap = (0, _react.useMemo)(function () {
-    if (!blockMenuComponents) {
-      return new Map();
-    }
-    return new Map(blockMenuComponents.filter(function (c) {
-      return c.type === 'block-menu-item';
-    }).map(function (item) {
-      return [item.key, item];
-    }));
+    return (0, _createMenuItemsMap.createMenuItemsMap)(blockMenuComponents);
   }, [blockMenuComponents]);
   var suggestedItems = (0, _react.useMemo)(function () {
     var currentSelection = preservedSelection || selection;
-    if (menuItemsMap.size === 0 || !currentSelection) {
-      return [];
-    }
-    var _expandSelectionToBlo = (0, _selection.expandSelectionToBlockRange)(currentSelection),
-      range = _expandSelectionToBlo.range;
-    if (!range) {
-      return [];
-    }
-    var blockNodes = (0, _utils.getBlockNodesInRange)(range);
-    if (blockNodes.length === 0) {
-      return [];
-    }
-    var firstNodeType = blockNodes[0].type.name;
-    var allSameType = blockNodes.every(function (node) {
-      return node.type.name === firstNodeType;
-    });
-    if (!allSameType) {
-      return [];
-    }
-    var nodeTypeName = firstNodeType;
-    var sortedKeys = (0, _suggestedItemsRank.getSortedSuggestedItems)(nodeTypeName);
-    return sortedKeys.map(function (key) {
-      return menuItemsMap.get(key);
-    }).filter(function (item) {
-      return item !== undefined;
-    });
+    return (0, _getSuggestedItemsFromSelection.getSuggestedItemsFromSelection)(menuItemsMap, currentSelection);
   }, [menuItemsMap, preservedSelection, selection]);
   return suggestedItems;
 };

package/dist/cjs/ui/utils/createMenuItemsMap.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createMenuItemsMap = void 0;
+/**
+ * Helper function to create menu items map from block menu components.
+ */
+var createMenuItemsMap = exports.createMenuItemsMap = function createMenuItemsMap(blockMenuComponents) {
+  if (!blockMenuComponents) {
+    return new Map();
+  }
+  return new Map(blockMenuComponents.filter(function (c) {
+    return c.type === 'block-menu-item';
+  }).map(function (item) {
+    return [item.key, item];
+  }));
+};

package/dist/cjs/ui/utils/getSuggestedItemsFromSelection.js

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getSuggestedItemsFromSelection = void 0;
+var _selection = require("@atlaskit/editor-common/selection");
+var _utils = require("../../editor-commands/transform-node-utils/utils");
+var _suggestedItemsRank = require("../utils/suggested-items-rank");
+/**
+ * Pure function to calculate suggested items based on selection and menu components.
+ */
+var getSuggestedItemsFromSelection = exports.getSuggestedItemsFromSelection = function getSuggestedItemsFromSelection(menuItemsMap, currentSelection) {
+  if (menuItemsMap.size === 0 || !currentSelection) {
+    return [];
+  }
+  var _expandSelectionToBlo = (0, _selection.expandSelectionToBlockRange)(currentSelection),
+    range = _expandSelectionToBlo.range;
+  if (!range) {
+    return [];
+  }
+  var blockNodes = (0, _utils.getBlockNodesInRange)(range);
+  if (blockNodes.length === 0) {
+    return [];
+  }
+  var firstNodeType = blockNodes[0].type.name;
+  var allSameType = blockNodes.every(function (node) {
+    return node.type.name === firstNodeType;
+  });
+  if (!allSameType) {
+    return [];
+  }
+  var nodeTypeName = firstNodeType;
+  var sortedKeys = (0, _suggestedItemsRank.getSortedSuggestedItems)(nodeTypeName);
+  return sortedKeys.map(function (key) {
+    return menuItemsMap.get(key);
+  }).filter(function (item) {
+    return item !== undefined;
+  });
+};

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

@@ -0,0 +1,219 @@
+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';
+import { wrapMixedContentStep } from './steps/wrapMixedContentStep';
+import { unwrapExpandStep } from './unwrapExpandStep';
+import { unwrapStep } from './unwrapStep';
+import { wrapIntoListStep } from './wrapIntoListStep';
+import { wrapStep } from './wrapStep';
+
+// Transform steps for all node type pairs.
+// If a transformation is not defined (undefined), it is not available.
+export const TRANSFORMATION_MATRIX = {
+  paragraph: {
+    heading: [flattenStep, applyTargetTextTypeStep],
+    blockquote: [wrapMixedContentStep],
+    codeBlock: [wrapMixedContentStep],
+    expand: [wrapMixedContentStep],
+    nestedExpand: [wrapMixedContentStep],
+    layoutSection: [wrapMixedContentStep],
+    panel: [wrapMixedContentStep],
+    bulletList: [wrapIntoListStep],
+    orderedList: [wrapIntoListStep],
+    taskList: [wrapIntoListStep],
+    decisionList: [wrapIntoListStep]
+  },
+  heading: {
+    heading: [flattenStep, applyTargetTextTypeStep],
+    paragraph: [flattenStep, applyTargetTextTypeStep],
+    blockquote: [wrapMixedContentStep],
+    codeBlock: [wrapMixedContentStep],
+    expand: [wrapMixedContentStep],
+    nestedExpand: [wrapMixedContentStep],
+    layoutSection: [wrapMixedContentStep],
+    panel: [wrapMixedContentStep],
+    bulletList: [wrapIntoListStep],
+    orderedList: [wrapIntoListStep],
+    taskList: [wrapIntoListStep],
+    decisionList: [wrapIntoListStep]
+  },
+  panel: {
+    blockquote: [unwrapStep, wrapMixedContentStep],
+    codeBlock: [unwrapStep, wrapMixedContentStep],
+    expand: [unwrapStep, wrapStep],
+    nestedExpand: [unwrapStep, wrapStep],
+    layoutSection: [unwrapStep, wrapMixedContentStep],
+    paragraph: [unwrapStep]
+  },
+  expand: {
+    panel: [unwrapExpandStep, wrapMixedContentStep],
+    blockquote: [unwrapExpandStep, wrapMixedContentStep],
+    layoutSection: [unwrapExpandStep, wrapMixedContentStep],
+    nestedExpand: [unwrapExpandStep, wrapStep],
+    paragraph: [unwrapExpandStep]
+  },
+  nestedExpand: {
+    panel: [unwrapExpandStep, wrapMixedContentStep],
+    blockquote: [unwrapExpandStep, wrapMixedContentStep],
+    layoutSection: [unwrapExpandStep, wrapMixedContentStep],
+    paragraph: [unwrapExpandStep]
+  },
+  blockquote: {
+    expand: [wrapStep],
+    nestedExpand: [wrapStep],
+    layoutSection: [wrapMixedContentStep],
+    panel: [unwrapStep, wrapStep],
+    paragraph: [unwrapStep],
+    heading: [unwrapStep, applyTargetTextTypeStep],
+    decisionList: [unwrapStep, wrapBlockquoteToDecisionListStep]
+  },
+  layoutSection: {
+    blockquote: [unwrapLayoutStep, wrapMixedContentStep],
+    expand: [unwrapLayoutStep, wrapStep],
+    nestedExpand: [unwrapLayoutStep, wrapStep],
+    panel: [unwrapLayoutStep, wrapMixedContentStep],
+    paragraph: [unwrapLayoutStep]
+  },
+  codeBlock: {
+    blockquote: [wrapStep],
+    expand: [wrapStep],
+    nestedExpand: [wrapStep],
+    layoutSection: [wrapMixedContentStep],
+    panel: [wrapStep],
+    paragraph: [applyTargetTextTypeStep]
+  },
+  bulletList: {
+    orderedList: [listToListStep],
+    taskList: [listToListStep],
+    decisionList: [flattenListStep, listToDecisionListStep],
+    blockquote: [wrapStep],
+    expand: [wrapStep],
+    nestedExpand: [wrapStep],
+    layoutSection: [wrapMixedContentStep],
+    panel: [wrapStep],
+    paragraph: [flattenListStep, unwrapListStep, applyTargetTextTypeStep]
+  },
+  orderedList: {
+    bulletList: [listToListStep],
+    taskList: [listToListStep],
+    decisionList: [flattenListStep, listToDecisionListStep],
+    blockquote: [wrapStep],
+    expand: [wrapStep],
+    nestedExpand: [wrapStep],
+    layoutSection: [wrapMixedContentStep],
+    panel: [wrapStep],
+    paragraph: [flattenListStep, unwrapListStep, applyTargetTextTypeStep]
+  },
+  taskList: {
+    bulletList: [listToListStep],
+    orderedList: [listToListStep],
+    decisionList: [flattenListStep, listToDecisionListStep],
+    expand: [wrapStep],
+    nestedExpand: [wrapStep],
+    layoutSection: [wrapMixedContentStep],
+    panel: [wrapStep],
+    paragraph: [flattenListStep, unwrapListStep, applyTargetTextTypeStep]
+  },
+  table: {
+    expand: [wrapStep],
+    nestedExpand: [wrapStep],
+    layoutSection: [wrapMixedContentStep]
+  },
+  mediaSingle: {
+    blockquote: [wrapStep],
+    expand: [wrapStep],
+    nestedExpand: [wrapStep],
+    layoutSection: [wrapMixedContentStep],
+    panel: [wrapStep],
+    bulletList: [wrapIntoListStep],
+    orderedList: [wrapIntoListStep]
+  },
+  mediaGroup: {
+    blockquote: [wrapStep],
+    expand: [wrapStep],
+    nestedExpand: [wrapStep],
+    layoutSection: [wrapMixedContentStep],
+    panel: [wrapStep]
+  },
+  media: {
+    blockquote: [wrapStep],
+    codeBlock: [wrapStep],
+    expand: [wrapStep],
+    nestedExpand: [wrapStep],
+    layoutSection: [wrapStep],
+    panel: [wrapStep],
+    bulletList: [wrapIntoListStep],
+    orderedList: [wrapIntoListStep],
+    taskList: [wrapIntoListStep],
+    decisionList: [wrapIntoListStep]
+  },
+  decisionList: {
+    bulletList: [decisionListToListStep],
+    orderedList: [decisionListToListStep],
+    taskList: [decisionListToListStep],
+    blockquote: [unwrapListStep, wrapStep],
+    codeBlock: [unwrapListStep, wrapMixedContentStep],
+    expand: [wrapStep],
+    nestedExpand: [wrapStep],
+    layoutSection: [wrapMixedContentStep],
+    panel: [wrapStep],
+    paragraph: [flattenListStep, unwrapListStep, applyTargetTextTypeStep],
+    heading: [flattenListStep, unwrapListStep, applyTargetTextTypeStep]
+  },
+  blockCard: {
+    expand: [wrapStep],
+    nestedExpand: [wrapStep],
+    layoutSection: [wrapMixedContentStep],
+    panel: [wrapStep]
+  },
+  embedCard: {
+    expand: [wrapStep],
+    nestedExpand: [wrapStep],
+    layoutSection: [wrapMixedContentStep]
+  },
+  extension: {
+    blockquote: [wrapStep],
+    expand: [wrapStep],
+    nestedExpand: [wrapStep],
+    layoutSection: [wrapMixedContentStep],
+    panel: [wrapStep]
+  },
+  bodiedExtension: {
+    nestedExpand: [wrapStep],
+    layoutSection: [wrapMixedContentStep]
+  },
+  multiBodiedExtension: {
+    blockquote: [wrapStep],
+    codeBlock: [wrapStep],
+    expand: [wrapStep],
+    nestedExpand: [wrapStep],
+    layoutSection: [wrapStep],
+    panel: [wrapStep],
+    bulletList: [wrapIntoListStep],
+    orderedList: [wrapIntoListStep],
+    taskList: [wrapIntoListStep],
+    decisionList: [wrapIntoListStep]
+  },
+  multi: {
+    blockquote: [wrapMixedContentStep],
+    codeBlock: [wrapMixedContentStep],
+    expand: [wrapMixedContentStep],
+    nestedExpand: [wrapMixedContentStep],
+    layoutSection: [wrapMixedContentStep],
+    panel: [wrapMixedContentStep],
+    bulletList: [convertEachNodeStep, mergeNeighbourListsStep],
+    orderedList: [convertEachNodeStep, mergeNeighbourListsStep],
+    taskList: [convertEachNodeStep, mergeNeighbourListsStep],
+    decisionList: [convertEachNodeStep, mergeNeighbourListsStep],
+    paragraph: [convertEachNodeStep],
+    heading: [applyTargetTextTypeStep]
+  }
+};

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

@@ -1,4 +1,44 @@
 import { convertNodesToTargetType } from '../transform';
+/**
+ * Handles the edge case where transforming multi-selection to decisionList results in
+ * all content breaking out (no valid children for the target). In this case, creates an empty
+ * decisionList to ensure the target type exists.
+ *
+ * Similar to handleEmptyContainerEdgeCase in wrapMixedContentStep, but specifically for
+ * multi-to-decisionList transformations where blockquotes break out.
+ *
+ * @param result - The current result nodes after processing
+ * @param hasCreatedDecisionList - Whether a decisionList was already created during processing
+ * @param targetNodeTypeName - The target node type name
+ * @param schema - The schema
+ * @returns The result nodes with an empty decisionList prepended if needed, or the original result
+ */
+const handleEmptyDecisionListEdgeCase = (result, hasCreatedDecisionList, targetNodeTypeName, schema) => {
+  // Only apply this edge case for decisionList target
+  if (targetNodeTypeName !== 'decisionList') {
+    return result;
+  }
+
+  // If no decisionList was created but we have nodes in result, all content broke out
+  const allContentBrokeOut = !hasCreatedDecisionList && result.length > 0;
+  if (!allContentBrokeOut) {
+    return result;
+  }
+
+  // Create an empty decisionList
+  const decisionListType = schema.nodes.decisionList;
+  const decisionItemType = schema.nodes.decisionItem;
+  if (decisionListType && decisionItemType) {
+    const emptyDecisionItem = decisionItemType.createAndFill();
+    if (emptyDecisionItem) {
+      const emptyDecisionList = decisionListType.createAndFill({}, [emptyDecisionItem]);
+      if (emptyDecisionList) {
+        return [emptyDecisionList, ...result];
+      }
+    }
+  }
+  return result;
+};
 export const convertEachNodeStep = (nodes, context) => {
   const {
     schema,
@@ -9,8 +49,15 @@ export const convertEachNodeStep = (nodes, context) => {
   if (!targetNodeType) {
     return nodes;
   }
+  const blockquoteType = schema.nodes.blockquote;
   const resultNodes = [];
+  let hasCreatedDecisionList = false;
   for (const node of nodes) {
+    // Edge case: blockquotes should break out when transforming to decisionList
+    if (targetNodeTypeName === 'decisionList' && blockquoteType && node.type === blockquoteType) {
+      resultNodes.push(node);
+      continue;
+    }
     const transformedNodes = convertNodesToTargetType({
       sourceNodes: [node],
       targetNodeType,
@@ -20,9 +67,17 @@ export const convertEachNodeStep = (nodes, context) => {
     });
     if (transformedNodes.length > 0) {
       resultNodes.push(...transformedNodes);
+      // Track if we created a decisionList
+
+      if (targetNodeTypeName === 'decisionList' && transformedNodes.some(n => n.type === targetNodeType)) {
+        hasCreatedDecisionList = true;
+      }
     } else {
       resultNodes.push(node);
     }
   }
-  return resultNodes;
+
+  // Handle edge case: if no decisionList was created, create an empty one
+  const finalResult = handleEmptyDecisionListEdgeCase(resultNodes, hasCreatedDecisionList, targetNodeTypeName, schema);
+  return finalResult;
 };

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

@@ -1,238 +1,6 @@
 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';
-import { wrapMixedContentStep } from './steps/wrapMixedContentStep';
-import { getNodeName, NODE_CATEGORY_BY_TYPE, toNodeTypeValue } from './types';
-import { unwrapExpandStep } from './unwrapExpandStep';
-import { unwrapStep } from './unwrapStep';
-import { wrapIntoListStep } from './wrapIntoListStep';
-import { wrapStep } from './wrapStep';
-
-// Transform steps for combinations of node categories (block/container/list/text)
-const TRANSFORM_STEPS = {
-  atomic: {
-    atomic: undefined,
-    container: [wrapStep],
-    list: [wrapIntoListStep],
-    text: undefined,
-    multi: undefined
-  },
-  container: {
-    atomic: undefined,
-    container: [unwrapStep, wrapStep],
-    list: undefined,
-    text: [unwrapStep],
-    multi: undefined
-  },
-  list: {
-    atomic: undefined,
-    container: [wrapStep],
-    list: [listToListStep],
-    text: [flattenListStep, unwrapListStep, applyTargetTextTypeStep],
-    multi: undefined
-  },
-  text: {
-    atomic: undefined,
-    container: [wrapMixedContentStep],
-    list: [wrapIntoListStep],
-    text: [flattenStep, applyTargetTextTypeStep],
-    multi: undefined
-  },
-  multi: {
-    atomic: undefined,
-    container: [wrapMixedContentStep],
-    list: [convertEachNodeStep, mergeNeighbourListsStep],
-    text: [convertEachNodeStep],
-    multi: undefined
-  }
-};
-
-// 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
-  },
-  heading: {},
-  panel: {
-    panel: null,
-    layoutSection: [unwrapStep, wrapMixedContentStep],
-    codeBlock: [unwrapStep, wrapMixedContentStep],
-    blockquote: [unwrapStep, wrapMixedContentStep],
-    taskList: null,
-    bulletList: null,
-    orderedList: null,
-    heading: null
-  },
-  expand: {
-    expand: null,
-    panel: [unwrapExpandStep, wrapMixedContentStep],
-    blockquote: [unwrapExpandStep, wrapMixedContentStep],
-    layoutSection: [unwrapExpandStep, wrapMixedContentStep],
-    paragraph: [unwrapExpandStep],
-    codeBlock: null,
-    heading: null
-  },
-  nestedExpand: {
-    expand: null,
-    nestedExpand: null,
-    panel: [unwrapExpandStep, wrapMixedContentStep],
-    blockquote: [unwrapExpandStep, wrapMixedContentStep],
-    paragraph: [unwrapExpandStep],
-    codeBlock: null,
-    heading: null
-  },
-  blockquote: {
-    blockquote: null,
-    expand: [wrapStep],
-    nestedExpand: [wrapStep],
-    layoutSection: [wrapMixedContentStep],
-    codeBlock: null,
-    decisionList: [unwrapStep, wrapBlockquoteToDecisionListStep],
-    paragraph: [unwrapStep],
-    heading: [unwrapStep, applyTargetTextTypeStep]
-  },
-  layoutSection: {
-    layoutSection: null,
-    blockquote: [unwrapLayoutStep, wrapMixedContentStep],
-    expand: [unwrapLayoutStep, wrapStep],
-    panel: [unwrapLayoutStep, wrapMixedContentStep],
-    codeBlock: null,
-    paragraph: [unwrapLayoutStep],
-    heading: null
-  },
-  codeBlock: {
-    codeBlock: null,
-    blockquote: [wrapStep],
-    expand: [wrapStep],
-    nestedExpand: [wrapStep],
-    layoutSection: [wrapMixedContentStep],
-    panel: [wrapStep],
-    paragraph: [applyTargetTextTypeStep],
-    heading: null
-  },
-  bulletList: {
-    bulletList: null,
-    codeBlock: null,
-    layoutSection: [wrapMixedContentStep],
-    decisionList: [flattenListStep, listToDecisionListStep],
-    heading: null
-  },
-  orderedList: {
-    orderedList: null,
-    codeBlock: null,
-    layoutSection: [wrapMixedContentStep],
-    decisionList: [flattenListStep, listToDecisionListStep],
-    heading: null
-  },
-  taskList: {
-    blockquote: null,
-    codeBlock: null,
-    layoutSection: [wrapMixedContentStep],
-    decisionList: [flattenListStep, listToDecisionListStep],
-    heading: null,
-    taskList: null
-  },
-  table: {
-    layoutSection: [wrapMixedContentStep],
-    blockquote: null,
-    panel: null,
-    codeBlock: null,
-    orderedList: null,
-    bulletList: null,
-    taskList: null,
-    decisionList: null
-  },
-  mediaSingle: {
-    layoutSection: [wrapMixedContentStep],
-    codeBlock: null,
-    decisionList: null,
-    taskList: null
-  },
-  mediaGroup: {
-    layoutSection: [wrapMixedContentStep],
-    codeBlock: null,
-    decisionList: null,
-    bulletList: null,
-    orderedList: null,
-    taskList: null
-  },
-  decisionList: {
-    decisionList: null,
-    bulletList: [decisionListToListStep],
-    orderedList: [decisionListToListStep],
-    taskList: [decisionListToListStep],
-    layoutSection: [wrapMixedContentStep],
-    blockquote: [unwrapListStep, wrapStep],
-    codeBlock: [unwrapListStep, wrapMixedContentStep]
-  },
-  blockCard: {
-    layoutSection: [wrapMixedContentStep],
-    blockquote: null,
-    codeBlock: null,
-    orderedList: null,
-    bulletList: null,
-    taskList: null,
-    decisionList: null
-  },
-  embedCard: {
-    layoutSection: [wrapMixedContentStep],
-    blockquote: null,
-    panel: null,
-    codeBlock: null,
-    orderedList: null,
-    bulletList: null,
-    taskList: null,
-    decisionList: null
-  },
-  extension: {
-    layoutSection: [wrapMixedContentStep],
-    codeBlock: null,
-    decisionList: null,
-    taskList: null,
-    orderedList: null,
-    bulletList: null
-  },
-  bodiedExtension: {
-    layoutSection: [wrapMixedContentStep],
-    blockquote: null,
-    expand: null,
-    panel: null,
-    codeBlock: null,
-    orderedList: null,
-    bulletList: null,
-    taskList: null,
-    decisionList: null
-  },
-  multi: {
-    heading: [applyTargetTextTypeStep]
-    // Similar to heading, all structures are kept as is
-    // EG: transformed: other lists, paragarph, headings
-    // eg: not-transformed: quotes, codeblocks ... all typeof 'containers'
-    // decisionList: [],
-  }
-};
-const getTransformStepsForNodeTypes = (selectedNodeTypeName, targetNodeTypeName) => {
-  var _TRANSFORM_STEPS_OVER;
-  const fromCategory = NODE_CATEGORY_BY_TYPE[selectedNodeTypeName];
-  const toCategory = NODE_CATEGORY_BY_TYPE[targetNodeTypeName];
-  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;
-};
+import { TRANSFORMATION_MATRIX } from './TRANSFORMATION_MATRIX';
+import { getNodeName, toNodeTypeValue } from './types';
 /**
  * Convert a list of nodes to a target node type.
  * If no steps are found, the source nodes are returned unchanged.
@@ -266,7 +34,7 @@ export const convertNodesToTargetType = ({
   if (!selectedNodeTypeName || !targetNodeTypeName) {
     return sourceNodes;
   }
-  const steps = getTransformStepsForNodeTypes(selectedNodeTypeName, targetNodeTypeName);
+  const steps = TRANSFORMATION_MATRIX[selectedNodeTypeName][targetNodeTypeName];
   const context = {
     // sourceNode is incorrect now - what to do here?
     fromNode: sourceNode,
@@ -282,9 +50,6 @@ export const convertNodesToTargetType = ({
   }, sourceNodes);
 };
 export const isTransformDisabledBasedOnStepsConfig = (selectedNodeType, targetNodeType) => {
-  const steps = getTransformStepsForNodeTypes(selectedNodeType, targetNodeType);
-  if (!steps || steps.length === 0) {
-    return true;
-  }
-  return false;
+  const steps = TRANSFORMATION_MATRIX[selectedNodeType][targetNodeType];
+  return !steps || steps.length === 0;
 };