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

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

@@ -11,6 +11,8 @@ import { MoveDownDropdownItem } from './move-down';
 import { MoveUpDropdownItem } from './move-up';
 import { SuggestedItemsMenuSection } from './suggested-items-menu-section';
 import { SuggestedMenuItems } from './suggested-menu-items';
+import { createMenuItemsMap } from './utils/createMenuItemsMap';
+import { getSuggestedItemsFromSelection } from './utils/getSuggestedItemsFromSelection';
 const getMoveUpMoveDownMenuComponents = api => {
   return [{
     type: 'block-menu-item',
@@ -79,7 +81,17 @@ const getTurnIntoMenuComponents = api => {
     },
     component: () => /*#__PURE__*/React.createElement(SuggestedMenuItems, {
       api: api
-    })
+    }),
+    isHidden: () => {
+      var _api$blockMenu, _api$selection, _api$selection$shared, _api$blockControls, _api$blockControls$sh;
+      const blockMenuComponents = api === null || api === void 0 ? void 0 : (_api$blockMenu = api.blockMenu) === null || _api$blockMenu === void 0 ? void 0 : _api$blockMenu.actions.getBlockMenuComponents();
+      const menuItemsMap = createMenuItemsMap(blockMenuComponents);
+      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.currentState()) === null || _api$selection$shared === void 0 ? void 0 : _api$selection$shared.selection;
+      const preservedSelection = api === null || api === void 0 ? void 0 : (_api$blockControls = api.blockControls) === null || _api$blockControls === void 0 ? void 0 : (_api$blockControls$sh = _api$blockControls.sharedState.currentState()) === null || _api$blockControls$sh === void 0 ? void 0 : _api$blockControls$sh.preservedSelection;
+      const currentSelection = preservedSelection || selection;
+      const suggestedItems = getSuggestedItemsFromSelection(menuItemsMap, currentSelection);
+      return suggestedItems.length === 0;
+    }
   }, {
     type: 'block-menu-section',
     key: TRANSFORM_CREATE_MENU_SECTION.key,

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

@@ -9,15 +9,15 @@ export const BlockMenuComponent = ({
   childrenMap,
   fallbacks
 }) => {
+  if (!willComponentRender(registeredComponent, childrenMap)) {
+    return null;
+  }
   if (registeredComponent.type === 'block-menu-item') {
     const ItemComponent = registeredComponent.component || fallbacks['block-menu-item'];
     return /*#__PURE__*/React.createElement(ItemComponent, {
       key: registeredComponent.key
     });
   }
-  if (!willComponentRender(registeredComponent, childrenMap)) {
-    return null;
-  }
   const ParentComponent = registeredComponent.component || fallbacks[registeredComponent.type];
   const childrenMapKey = getChildrenMapKey(registeredComponent.key, registeredComponent.type);
   const registeredComponents = childrenMap.get(childrenMapKey);

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

@@ -74,20 +74,17 @@ export const buildChildrenMap = components => {
  * Determines whether a component will render based on its type and children
  *
  * Rules:
- * - An item will not render if has a component that returns null
- * - A nested menu will render if it has at least one registered child component
+ * - An item will not render if it has isHidden that returns true OR if its component returns null (fallback)
+ * - A nested menu will render if at least one section, that has at least one registered child
  * - A section will render if it has at least one registered child component that will render
  *
- * NOTE: This requires invoking each item's component function to check for null return
  */
 export const willComponentRender = (registeredComponent, childrenMap) => {
   if (registeredComponent.type === 'block-menu-item') {
-    return registeredComponent.component ? registeredComponent.component() !== null : true;
+    var _registeredComponent$;
+    return !(registeredComponent !== null && registeredComponent !== void 0 && (_registeredComponent$ = registeredComponent.isHidden) !== null && _registeredComponent$ !== void 0 && _registeredComponent$.call(registeredComponent));
   }
   const childrenMapKey = getChildrenMapKey(registeredComponent.key, registeredComponent.type);
   const registeredComponents = childrenMap.get(childrenMapKey) || [];
-  if (registeredComponent.type === 'block-menu-nested') {
-    return registeredComponents.length > 0;
-  }
   return registeredComponents.some(childComponent => willComponentRender(childComponent, childrenMap));
 };

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

@@ -1,8 +1,7 @@
 import { useMemo } from 'react';
 import { useSharedPluginStateWithSelector } from '@atlaskit/editor-common/hooks';
-import { expandSelectionToBlockRange } from '@atlaskit/editor-common/selection';
-import { getBlockNodesInRange } from '../../editor-commands/transform-node-utils/utils';
-import { getSortedSuggestedItems } from '../utils/suggested-items-rank';
+import { createMenuItemsMap } from '../utils/createMenuItemsMap';
+import { getSuggestedItemsFromSelection } from '../utils/getSuggestedItemsFromSelection';
 export const useSuggestedItems = api => {
   var _api$blockMenu;
   const {
@@ -17,34 +16,11 @@ export const useSuggestedItems = api => {
   });
   const blockMenuComponents = api === null || api === void 0 ? void 0 : (_api$blockMenu = api.blockMenu) === null || _api$blockMenu === void 0 ? void 0 : _api$blockMenu.actions.getBlockMenuComponents();
   const menuItemsMap = useMemo(() => {
-    if (!blockMenuComponents) {
-      return new Map();
-    }
-    return new Map(blockMenuComponents.filter(c => c.type === 'block-menu-item').map(item => [item.key, item]));
+    return createMenuItemsMap(blockMenuComponents);
   }, [blockMenuComponents]);
   const suggestedItems = useMemo(() => {
     const currentSelection = preservedSelection || selection;
-    if (menuItemsMap.size === 0 || !currentSelection) {
-      return [];
-    }
-    const {
-      range
-    } = expandSelectionToBlockRange(currentSelection);
-    if (!range) {
-      return [];
-    }
-    const blockNodes = getBlockNodesInRange(range);
-    if (blockNodes.length === 0) {
-      return [];
-    }
-    const firstNodeType = blockNodes[0].type.name;
-    const allSameType = blockNodes.every(node => node.type.name === firstNodeType);
-    if (!allSameType) {
-      return [];
-    }
-    const nodeTypeName = firstNodeType;
-    const sortedKeys = getSortedSuggestedItems(nodeTypeName);
-    return sortedKeys.map(key => menuItemsMap.get(key)).filter(item => item !== undefined);
+    return getSuggestedItemsFromSelection(menuItemsMap, currentSelection);
   }, [menuItemsMap, preservedSelection, selection]);
   return suggestedItems;
 };

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

@@ -0,0 +1,9 @@
+/**
+ * Helper function to create menu items map from block menu components.
+ */
+export const createMenuItemsMap = blockMenuComponents => {
+  if (!blockMenuComponents) {
+    return new Map();
+  }
+  return new Map(blockMenuComponents.filter(c => c.type === 'block-menu-item').map(item => [item.key, item]));
+};

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

@@ -0,0 +1,30 @@
+import { expandSelectionToBlockRange } from '@atlaskit/editor-common/selection';
+import { getBlockNodesInRange } from '../../editor-commands/transform-node-utils/utils';
+import { getSortedSuggestedItems } from '../utils/suggested-items-rank';
+
+/**
+ * Pure function to calculate suggested items based on selection and menu components.
+ */
+export const getSuggestedItemsFromSelection = (menuItemsMap, currentSelection) => {
+  if (menuItemsMap.size === 0 || !currentSelection) {
+    return [];
+  }
+  const {
+    range
+  } = expandSelectionToBlockRange(currentSelection);
+  if (!range) {
+    return [];
+  }
+  const blockNodes = getBlockNodesInRange(range);
+  if (blockNodes.length === 0) {
+    return [];
+  }
+  const firstNodeType = blockNodes[0].type.name;
+  const allSameType = blockNodes.every(node => node.type.name === firstNodeType);
+  if (!allSameType) {
+    return [];
+  }
+  const nodeTypeName = firstNodeType;
+  const sortedKeys = getSortedSuggestedItems(nodeTypeName);
+  return sortedKeys.map(key => menuItemsMap.get(key)).filter(item => item !== undefined);
+};

package/dist/esm/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 var 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/esm/editor-commands/transform-node-utils/steps/convertEachNodeStep.js

@@ -3,6 +3,46 @@ function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol
 function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
 function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
 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
+ */
+var handleEmptyDecisionListEdgeCase = function 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
+  var allContentBrokeOut = !hasCreatedDecisionList && result.length > 0;
+  if (!allContentBrokeOut) {
+    return result;
+  }
+
+  // Create an empty decisionList
+  var decisionListType = schema.nodes.decisionList;
+  var decisionItemType = schema.nodes.decisionItem;
+  if (decisionListType && decisionItemType) {
+    var emptyDecisionItem = decisionItemType.createAndFill();
+    if (emptyDecisionItem) {
+      var emptyDecisionList = decisionListType.createAndFill({}, [emptyDecisionItem]);
+      if (emptyDecisionList) {
+        return [emptyDecisionList].concat(_toConsumableArray(result));
+      }
+    }
+  }
+  return result;
+};
 export var convertEachNodeStep = function convertEachNodeStep(nodes, context) {
   var schema = context.schema,
     targetNodeTypeName = context.targetNodeTypeName,
@@ -11,12 +51,19 @@ export var convertEachNodeStep = function convertEachNodeStep(nodes, context) {
   if (!targetNodeType) {
     return nodes;
   }
+  var blockquoteType = schema.nodes.blockquote;
   var resultNodes = [];
+  var hasCreatedDecisionList = false;
   var _iterator = _createForOfIteratorHelper(nodes),
     _step;
   try {
     for (_iterator.s(); !(_step = _iterator.n()).done;) {
       var node = _step.value;
+      // Edge case: blockquotes should break out when transforming to decisionList
+      if (targetNodeTypeName === 'decisionList' && blockquoteType && node.type === blockquoteType) {
+        resultNodes.push(node);
+        continue;
+      }
       var transformedNodes = convertNodesToTargetType({
         sourceNodes: [node],
         targetNodeType: targetNodeType,
@@ -26,14 +73,24 @@ export var convertEachNodeStep = function convertEachNodeStep(nodes, context) {
       });
       if (transformedNodes.length > 0) {
         resultNodes.push.apply(resultNodes, _toConsumableArray(transformedNodes));
+        // Track if we created a decisionList
+
+        if (targetNodeTypeName === 'decisionList' && transformedNodes.some(function (n) {
+          return n.type === targetNodeType;
+        })) {
+          hasCreatedDecisionList = true;
+        }
       } else {
         resultNodes.push(node);
       }
     }
+
+    // Handle edge case: if no decisionList was created, create an empty one
   } catch (err) {
     _iterator.e(err);
   } finally {
     _iterator.f();
   }
-  return resultNodes;
+  var finalResult = handleEmptyDecisionListEdgeCase(resultNodes, hasCreatedDecisionList, targetNodeTypeName, schema);
+  return finalResult;
 };