@atlaskit/editor-plugin-block-menu 5.2.11 → 5.2.13

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

@@ -1,8 +1,6 @@
-import { expandToBlockRange } from '@atlaskit/editor-common/selection';
 import { NodeSelection, TextSelection } from '@atlaskit/editor-prosemirror/state';
 import { findParentNodeOfType } from '@atlaskit/editor-prosemirror/utils';
 import { CellSelection } from '@atlaskit/editor-tables';
-import { findTable, isTableSelected } from '@atlaskit/editor-tables/utils';
 export const getSelectedNode = selection => {
   if (selection instanceof NodeSelection) {
     return {
@@ -52,58 +50,6 @@ export const getTargetNodeTypeNameInContext = (nodeTypeName, isNested) => {
   }
   return nodeTypeName;
 };
-
-/**
- * Use common expandToBlockRange function to get the correct range for the selection
- * For example, if selection starts in a listItem, go find the bullet list or ordered list, their $from
- * @param selection
- * @param schema
- * @returns
- */
-export const expandSelectionToBlockRange = (selection, schema) => {
-  const {
-    nodes
-  } = schema;
-  const nodesNeedToExpandRange = [nodes.bulletList, nodes.orderedList, nodes.taskList, nodes.listItem, nodes.taskItem];
-
-  // when adding nodes.tableRow, tableHeader, tableCell in nodesNeedToExpandRang,
-  // expandToBlockRange does not return expected table start position, sometimes even freeze editor
-  // so handle table in the below logic
-  if (isTableSelected(selection)) {
-    const table = findTable(selection);
-    if (table) {
-      const $from = selection.$from.doc.resolve(table.pos);
-      const $to = selection.$from.doc.resolve(table.pos + table.node.nodeSize - 1);
-      return {
-        $from,
-        $to,
-        range: $from.blockRange($to)
-      };
-    }
-  }
-
-  // when selecting a file, selection is on media
-  // need to find media group and return its pos
-  if (selection instanceof NodeSelection) {
-    if (selection.node.type === nodes.media) {
-      const mediaGroup = findParentNodeOfType(nodes.mediaGroup)(selection);
-      if (mediaGroup) {
-        const $from = selection.$from.doc.resolve(mediaGroup.pos);
-        const $to = selection.$from.doc.resolve(mediaGroup.pos + mediaGroup.node.nodeSize);
-        return {
-          $from,
-          $to
-        };
-      }
-    }
-  }
-  return expandToBlockRange(selection.$from, selection.$to, node => {
-    if (nodesNeedToExpandRange.includes(node.type)) {
-      return false;
-    }
-    return true;
-  });
-};
 export const isListType = (node, schema) => {
   const lists = [schema.nodes.taskList, schema.nodes.bulletList, schema.nodes.orderedList];
   return lists.some(list => list === node.type);

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

@@ -1,8 +1,8 @@
+import { expandSelectionToBlockRange } from '@atlaskit/editor-common/selection';
 import { Fragment } from '@atlaskit/editor-prosemirror/model';
 import { NodeSelection } from '@atlaskit/editor-prosemirror/state';
 import { isNestedNode } from '../ui/utils/isNestedNode';
 import { getOutputNodes } from './transform-node-utils/transform';
-import { expandSelectionToBlockRange } from './transform-node-utils/utils';
 import { isListNode } from './transforms/utils';
 export const transformNode = api =>
 // eslint-disable-next-line no-unused-vars
@@ -22,7 +22,7 @@ export const transformNode = api =>
     const {
       $from,
       $to
-    } = expandSelectionToBlockRange(preservedSelection, schema);
+    } = expandSelectionToBlockRange(preservedSelection);
     const isNested = isNestedNode(preservedSelection, '');
     const selectedParent = $from.parent;
     let fragment = Fragment.empty;

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

@@ -0,0 +1,31 @@
+import React from 'react';
+import { BlockMenuComponents } from './BlockMenuComponents';
+import { getChildrenMapKey, willComponentRender } from './utils';
+/**
+ * Renders the given registered component based on its type
+ */
+export const BlockMenuComponent = ({
+  registeredComponent,
+  childrenMap,
+  fallbacks
+}) => {
+  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);
+  return /*#__PURE__*/React.createElement(ParentComponent, {
+    key: registeredComponent.key
+  }, /*#__PURE__*/React.createElement(BlockMenuComponents, {
+    registeredComponents: registeredComponents,
+    childrenMap: childrenMap,
+    fallbacks: fallbacks
+  }));
+};

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

@@ -0,0 +1,21 @@
+import React from 'react';
+import { BlockMenuComponent } from './BlockMenuComponent';
+/**
+ * Renders the given registered components
+ * Returns null if no components are rendered
+ */
+export const BlockMenuComponents = ({
+  registeredComponents,
+  childrenMap,
+  fallbacks
+}) => {
+  if (!(registeredComponents !== null && registeredComponents !== void 0 && registeredComponents.length)) {
+    return null;
+  }
+  return /*#__PURE__*/React.createElement(React.Fragment, null, registeredComponents.map(registeredComponent => /*#__PURE__*/React.createElement(BlockMenuComponent, {
+    key: registeredComponent.key,
+    registeredComponent: registeredComponent,
+    childrenMap: childrenMap,
+    fallbacks: fallbacks
+  })));
+};

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

@@ -0,0 +1,24 @@
+import React, { useMemo } from 'react';
+import { BlockMenuComponents } from './BlockMenuComponents';
+import { BLOCK_MENU_FALLBACKS } from './fallbacks';
+import { buildChildrenMap, getSortedTopLevelSections } from './utils';
+/**
+ * BlockMenuRenderer orchestrates the rendering of the entire block menu hierarchy
+ */
+export const BlockMenuRenderer = ({
+  allRegisteredComponents,
+  fallbacks = BLOCK_MENU_FALLBACKS
+}) => {
+  const {
+    childrenMap,
+    topLevelSections
+  } = useMemo(() => ({
+    childrenMap: buildChildrenMap(allRegisteredComponents),
+    topLevelSections: getSortedTopLevelSections(allRegisteredComponents)
+  }), [allRegisteredComponents]);
+  return /*#__PURE__*/React.createElement(BlockMenuComponents, {
+    registeredComponents: topLevelSections,
+    childrenMap: childrenMap,
+    fallbacks: fallbacks
+  });
+};

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

@@ -0,0 +1,21 @@
+import React from 'react';
+import { ToolbarDropdownItem, ToolbarDropdownItemSection, ToolbarNestedDropdownMenu } from '@atlaskit/editor-toolbar';
+import ChevronRightIcon from '@atlaskit/icon/core/chevron-right';
+export const BLOCK_MENU_FALLBACKS = {
+  'block-menu-nested': ({
+    children
+  }) => /*#__PURE__*/React.createElement(ToolbarNestedDropdownMenu, {
+    elemBefore: undefined,
+    elemAfter: /*#__PURE__*/React.createElement(ChevronRightIcon, {
+      label: ""
+    }),
+    text: "Nested Menu",
+    enableMaxHeight: true,
+    shouldFitContainer: true
+  }, children),
+  'block-menu-section': ({
+    children
+  }) => /*#__PURE__*/React.createElement(ToolbarDropdownItemSection, null, children),
+  // eslint-disable-next-line @atlassian/i18n/no-literal-string-in-jsx
+  'block-menu-item': () => /*#__PURE__*/React.createElement(ToolbarDropdownItem, null, "Block Menu Item")
+};

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,93 @@
+/**
+ * Type guard to check if a component has a parent
+ *
+ * @param component The block menu component to check
+ * @returns True if the component has a parent, false otherwise
+ */
+const hasParent = component => {
+  return 'parent' in component && !!component.parent;
+};
+
+/**
+ * Type guard to identify top-level sections (sections without a parent)
+ *
+ * @param component The block menu component to check
+ * @returns True if the component is a top-level section, false otherwise
+ */
+const isTopLevelSection = component => {
+  return component.type === 'block-menu-section' && !hasParent(component);
+};
+
+/**
+ * Gets all top-level sections (those without a parent) sorted by rank
+ *
+ * @param components All registered block menu components
+ * @returns Sorted array of top-level sections
+ */
+export const getSortedTopLevelSections = components => {
+  return components.filter(isTopLevelSection).sort((a, b) => (a.rank || 0) - (b.rank || 0));
+};
+
+/**
+ * Generates a unique key from a key and type
+ * Used to lookup children in the childrenMap
+ *
+ * @param key The component's key
+ * @param type The component's type
+ * @returns A unique string key combining type and key
+ */
+export const getChildrenMapKey = (key, type) => {
+  return `${type}:${key}`;
+};
+
+/**
+ * Builds a map of parent keys to their sorted children
+ * This enables efficient hierarchical rendering of the menu structure
+ *
+ * @param components All registered block menu components
+ * @returns Map where keys are parent identifiers and values are sorted child components
+ */
+export const buildChildrenMap = components => {
+  const childrenMap = new Map();
+  for (const component of components) {
+    // Only components with parents can be children
+    if ('parent' in component && !!component.parent) {
+      const childrenMapKey = getChildrenMapKey(component.parent.key, component.parent.type);
+      const existing = childrenMap.get(childrenMapKey) || [];
+      existing.push(component);
+      childrenMap.set(childrenMapKey, existing);
+    }
+  }
+
+  // Sort children by their rank within their parent
+  for (const [, children] of childrenMap.entries()) {
+    children.sort((a, b) => {
+      const rankA = hasParent(a) ? a.parent.rank || 0 : 0;
+      const rankB = hasParent(b) ? b.parent.rank || 0 : 0;
+      return rankA - rankB;
+    });
+  }
+  return childrenMap;
+};
+
+/**
+ * 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
+ * - 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;
+  }
+  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/block-menu.js

@@ -10,15 +10,15 @@ import { useSharedPluginStateWithSelector } from '@atlaskit/editor-common/hooks'
 import { deleteSelectedRange } from '@atlaskit/editor-common/selection';
 import { DRAG_HANDLE_SELECTOR, DRAG_HANDLE_WIDTH } from '@atlaskit/editor-common/styles';
 import { Popup } from '@atlaskit/editor-common/ui';
+import { ArrowKeyNavigationProvider, ArrowKeyNavigationType } from '@atlaskit/editor-common/ui-menu';
 import { OutsideClickTargetRefContext, withReactEditorViewOuterListeners } from '@atlaskit/editor-common/ui-react';
 import { akEditorFloatingOverlapPanelZIndex } from '@atlaskit/editor-shared-styles';
-import { ToolbarDropdownItem, ToolbarDropdownItemSection, ToolbarNestedDropdownMenu } from '@atlaskit/editor-toolbar';
 import { fg } from '@atlaskit/platform-feature-flags';
 import { conditionalHooksFactory } from '@atlaskit/platform-feature-flags-react';
 import { Box } from '@atlaskit/primitives/compiled';
 import { editorExperiment } from '@atlaskit/tmp-editor-statsig/experiments';
 import { useBlockMenu } from './block-menu-provider';
-import { BlockMenuRenderer } from './block-menu-renderer';
+import { BlockMenuRenderer } from './block-menu-renderer/BlockMenuRenderer';
 const styles = {
   base: "_2rko12b0 _bfhk1bhr _16qs130s",
   emptyMenuSectionStyles: "_1cc0glyw _1k2yglyw"
@@ -111,18 +111,11 @@ const BlockMenuContent = ({
     testId: "editor-block-menu",
     ref: ref,
     xcss: cx(styles.base, editorExperiment('platform_synced_block', true) && styles.emptyMenuSectionStyles)
+  }, /*#__PURE__*/React.createElement(ArrowKeyNavigationProvider, {
+    type: ArrowKeyNavigationType.MENU
   }, /*#__PURE__*/React.createElement(BlockMenuRenderer, {
-    components: blockMenuComponents || [],
-    fallbacks: {
-      nestedMenu: () => /*#__PURE__*/React.createElement(ToolbarNestedDropdownMenu, {
-        elemBefore: undefined,
-        elemAfter: undefined
-      }, /*#__PURE__*/React.createElement(ToolbarDropdownItemSection, null, /*#__PURE__*/React.createElement(ToolbarDropdownItem, null, "Block Menu Item"))),
-      section: () => /*#__PURE__*/React.createElement(ToolbarDropdownItemSection, null, /*#__PURE__*/React.createElement(ToolbarDropdownItem, null, "Block Menu Item")),
-      // eslint-disable-next-line @atlassian/i18n/no-literal-string-in-jsx
-      item: () => /*#__PURE__*/React.createElement(ToolbarDropdownItem, null, "Block Menu Item")
-    }
-  }));
+    allRegisteredComponents: blockMenuComponents || []
+  })));
 };
 const BlockMenu = ({
   editorView,

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

@@ -29,23 +29,20 @@ const CopyLinkDropdownItemContent = ({
   const {
     preservedSelection,
     defaultSelection,
-    menuTriggerBy,
-    schema
-  } = useSharedPluginStateWithSelector(api, ['blockControls', 'selection', 'core'], ({
+    menuTriggerBy
+  } = useSharedPluginStateWithSelector(api, ['blockControls', 'selection'], ({
     blockControlsState,
-    selectionState,
-    coreState
+    selectionState
   }) => {
     return {
       menuTriggerBy: blockControlsState === null || blockControlsState === void 0 ? void 0 : blockControlsState.menuTriggerBy,
       preservedSelection: blockControlsState === null || blockControlsState === void 0 ? void 0 : blockControlsState.preservedSelection,
-      defaultSelection: selectionState === null || selectionState === void 0 ? void 0 : selectionState.selection,
-      schema: coreState === null || coreState === void 0 ? void 0 : coreState.schema
+      defaultSelection: selectionState === null || selectionState === void 0 ? void 0 : selectionState.selection
     };
   });
   const selection = preservedSelection || defaultSelection;
   const handleClick = useCallback(() => {
-    if (!selection || !schema) {
+    if (!selection) {
       return;
     }
     api === null || api === void 0 ? void 0 : api.core.actions.execute(({
@@ -72,8 +69,7 @@ const CopyLinkDropdownItemContent = ({
     copyLink({
       getLinkPath,
       blockLinkHashPrefix,
-      selection,
-      schema
+      selection
     }).then(success => {
       if (success) {
         api === null || api === void 0 ? void 0 : api.core.actions.execute(({
@@ -86,7 +82,7 @@ const CopyLinkDropdownItemContent = ({
         });
       }
     });
-  }, [api, blockLinkHashPrefix, getLinkPath, onDropdownOpenChanged, schema, selection]);
+  }, [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) {

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

@@ -1,6 +1,7 @@
 import { useMemo } from 'react';
 import { useSharedPluginStateWithSelector } from '@atlaskit/editor-common/hooks';
-import { getBlockNodesInRange, expandSelectionToBlockRange } from '../../editor-commands/transform-node-utils/utils';
+import { expandSelectionToBlockRange } from '@atlaskit/editor-common/selection';
+import { getBlockNodesInRange } from '../../editor-commands/transform-node-utils/utils';
 import { getSortedSuggestedItems } from '../utils/suggested-items-rank';
 export const useSuggestedItems = api => {
   var _api$blockMenu;
@@ -28,16 +29,20 @@ export const useSuggestedItems = api => {
     }
     const {
       range
-    } = expandSelectionToBlockRange(currentSelection, currentSelection.$from.doc.type.schema);
+    } = expandSelectionToBlockRange(currentSelection);
     if (!range) {
       return [];
     }
     const blockNodes = getBlockNodesInRange(range);
-    const singleNode = blockNodes.length === 1 ? blockNodes[0] : undefined;
-    if (!singleNode) {
+    if (blockNodes.length === 0) {
       return [];
     }
-    const nodeTypeName = singleNode.type.name;
+    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);
   }, [menuItemsMap, preservedSelection, selection]);

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

@@ -1,14 +1,13 @@
 import { createBlockLinkHashValue, DEFAULT_BLOCK_LINK_HASH_PREFIX } from '@atlaskit/editor-common/block-menu';
 import { copyToClipboard } from '@atlaskit/editor-common/clipboard';
 import { logException } from '@atlaskit/editor-common/monitoring';
-import { expandSelectionToBlockRange } from '../../editor-commands/transform-node-utils/utils';
+import { expandSelectionToBlockRange } from '@atlaskit/editor-common/selection';
 export const copyLink = async ({
   getLinkPath,
   blockLinkHashPrefix = DEFAULT_BLOCK_LINK_HASH_PREFIX,
-  selection,
-  schema
+  selection
 }) => {
-  const blockRange = expandSelectionToBlockRange(selection, schema);
+  const blockRange = expandSelectionToBlockRange(selection);
   if (!blockRange) {
     return false;
   }

package/dist/es2019/ui/utils/suggested-items-rank.js

@@ -99,11 +99,6 @@ export const TRANSFORM_SUGGESTED_ITEMS_RANK = {
     [TRANSFORM_STRUCTURE_EXPAND_MENU_ITEM.key]: 100,
     [TRANSFORM_STRUCTURE_PANEL_MENU_ITEM.key]: 200,
     [TRANSFORM_STRUCTURE_LAYOUT_MENU_ITEM.key]: 300
-  },
-  [BLOCK_MENU_NODE_TYPES.BODIED_EXTENSION]: {
-    [TRANSFORM_STRUCTURE_EXPAND_MENU_ITEM.key]: 100,
-    [TRANSFORM_STRUCTURE_PANEL_MENU_ITEM.key]: 200,
-    [TRANSFORM_STRUCTURE_LAYOUT_MENU_ITEM.key]: 300
   }
 };
 export const getSuggestedItemsForNodeType = nodeType => {

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

@@ -128,7 +128,8 @@ var TRANSFORM_STEPS_OVERRIDE = {
   decisionList: {
     bulletList: [decisionListToListStep],
     orderedList: [decisionListToListStep],
-    taskList: [decisionListToListStep]
+    taskList: [decisionListToListStep],
+    layoutSection: [wrapIntoLayoutStep]
   }
 };
 var getTransformStepsForNodeTypes = function getTransformStepsForNodeTypes(selectedNodeTypeName, targetNodeTypeName) {

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

@@ -1,8 +1,6 @@
-import { expandToBlockRange } from '@atlaskit/editor-common/selection';
 import { NodeSelection, TextSelection } from '@atlaskit/editor-prosemirror/state';
 import { findParentNodeOfType } from '@atlaskit/editor-prosemirror/utils';
 import { CellSelection } from '@atlaskit/editor-tables';
-import { findTable, isTableSelected } from '@atlaskit/editor-tables/utils';
 export var getSelectedNode = function getSelectedNode(selection) {
   if (selection instanceof NodeSelection) {
     return {
@@ -51,56 +49,6 @@ export var getTargetNodeTypeNameInContext = function getTargetNodeTypeNameInCont
   }
   return nodeTypeName;
 };
-
-/**
- * Use common expandToBlockRange function to get the correct range for the selection
- * For example, if selection starts in a listItem, go find the bullet list or ordered list, their $from
- * @param selection
- * @param schema
- * @returns
- */
-export var expandSelectionToBlockRange = function expandSelectionToBlockRange(selection, schema) {
-  var nodes = schema.nodes;
-  var nodesNeedToExpandRange = [nodes.bulletList, nodes.orderedList, nodes.taskList, nodes.listItem, nodes.taskItem];
-
-  // when adding nodes.tableRow, tableHeader, tableCell in nodesNeedToExpandRang,
-  // expandToBlockRange does not return expected table start position, sometimes even freeze editor
-  // so handle table in the below logic
-  if (isTableSelected(selection)) {
-    var table = findTable(selection);
-    if (table) {
-      var $from = selection.$from.doc.resolve(table.pos);
-      var $to = selection.$from.doc.resolve(table.pos + table.node.nodeSize - 1);
-      return {
-        $from: $from,
-        $to: $to,
-        range: $from.blockRange($to)
-      };
-    }
-  }
-
-  // when selecting a file, selection is on media
-  // need to find media group and return its pos
-  if (selection instanceof NodeSelection) {
-    if (selection.node.type === nodes.media) {
-      var mediaGroup = findParentNodeOfType(nodes.mediaGroup)(selection);
-      if (mediaGroup) {
-        var _$from = selection.$from.doc.resolve(mediaGroup.pos);
-        var _$to = selection.$from.doc.resolve(mediaGroup.pos + mediaGroup.node.nodeSize);
-        return {
-          $from: _$from,
-          $to: _$to
-        };
-      }
-    }
-  }
-  return expandToBlockRange(selection.$from, selection.$to, function (node) {
-    if (nodesNeedToExpandRange.includes(node.type)) {
-      return false;
-    }
-    return true;
-  });
-};
 export var isListType = function isListType(node, schema) {
   var lists = [schema.nodes.taskList, schema.nodes.bulletList, schema.nodes.orderedList];
   return lists.some(function (list) {

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

@@ -1,8 +1,8 @@
+import { expandSelectionToBlockRange } from '@atlaskit/editor-common/selection';
 import { Fragment } from '@atlaskit/editor-prosemirror/model';
 import { NodeSelection } from '@atlaskit/editor-prosemirror/state';
 import { isNestedNode } from '../ui/utils/isNestedNode';
 import { getOutputNodes } from './transform-node-utils/transform';
-import { expandSelectionToBlockRange } from './transform-node-utils/utils';
 import { isListNode } from './transforms/utils';
 export var transformNode = function transformNode(api) {
   return (
@@ -17,7 +17,7 @@ export var transformNode = function transformNode(api) {
         }
         var schema = tr.doc.type.schema;
         var nodes = schema.nodes;
-        var _expandSelectionToBlo = expandSelectionToBlockRange(preservedSelection, schema),
+        var _expandSelectionToBlo = expandSelectionToBlockRange(preservedSelection),
           $from = _expandSelectionToBlo.$from,
           $to = _expandSelectionToBlo.$to;
         var isNested = isNestedNode(preservedSelection, '');

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

@@ -0,0 +1,30 @@
+import React from 'react';
+import { BlockMenuComponents } from './BlockMenuComponents';
+import { getChildrenMapKey, willComponentRender } from './utils';
+/**
+ * Renders the given registered component based on its type
+ */
+export var BlockMenuComponent = function BlockMenuComponent(_ref) {
+  var registeredComponent = _ref.registeredComponent,
+    childrenMap = _ref.childrenMap,
+    fallbacks = _ref.fallbacks;
+  if (registeredComponent.type === 'block-menu-item') {
+    var ItemComponent = registeredComponent.component || fallbacks['block-menu-item'];
+    return /*#__PURE__*/React.createElement(ItemComponent, {
+      key: registeredComponent.key
+    });
+  }
+  if (!willComponentRender(registeredComponent, childrenMap)) {
+    return null;
+  }
+  var ParentComponent = registeredComponent.component || fallbacks[registeredComponent.type];
+  var childrenMapKey = getChildrenMapKey(registeredComponent.key, registeredComponent.type);
+  var registeredComponents = childrenMap.get(childrenMapKey);
+  return /*#__PURE__*/React.createElement(ParentComponent, {
+    key: registeredComponent.key
+  }, /*#__PURE__*/React.createElement(BlockMenuComponents, {
+    registeredComponents: registeredComponents,
+    childrenMap: childrenMap,
+    fallbacks: fallbacks
+  }));
+};

package/dist/esm/ui/block-menu-renderer/BlockMenuComponents.js

@@ -0,0 +1,22 @@
+import React from 'react';
+import { BlockMenuComponent } from './BlockMenuComponent';
+/**
+ * Renders the given registered components
+ * Returns null if no components are rendered
+ */
+export var BlockMenuComponents = function BlockMenuComponents(_ref) {
+  var registeredComponents = _ref.registeredComponents,
+    childrenMap = _ref.childrenMap,
+    fallbacks = _ref.fallbacks;
+  if (!(registeredComponents !== null && registeredComponents !== void 0 && registeredComponents.length)) {
+    return null;
+  }
+  return /*#__PURE__*/React.createElement(React.Fragment, null, registeredComponents.map(function (registeredComponent) {
+    return /*#__PURE__*/React.createElement(BlockMenuComponent, {
+      key: registeredComponent.key,
+      registeredComponent: registeredComponent,
+      childrenMap: childrenMap,
+      fallbacks: fallbacks
+    });
+  }));
+};

package/dist/esm/ui/block-menu-renderer/BlockMenuRenderer.js

@@ -0,0 +1,25 @@
+import React, { useMemo } from 'react';
+import { BlockMenuComponents } from './BlockMenuComponents';
+import { BLOCK_MENU_FALLBACKS } from './fallbacks';
+import { buildChildrenMap, getSortedTopLevelSections } from './utils';
+/**
+ * BlockMenuRenderer orchestrates the rendering of the entire block menu hierarchy
+ */
+export var BlockMenuRenderer = function BlockMenuRenderer(_ref) {
+  var allRegisteredComponents = _ref.allRegisteredComponents,
+    _ref$fallbacks = _ref.fallbacks,
+    fallbacks = _ref$fallbacks === void 0 ? BLOCK_MENU_FALLBACKS : _ref$fallbacks;
+  var _useMemo = useMemo(function () {
+      return {
+        childrenMap: buildChildrenMap(allRegisteredComponents),
+        topLevelSections: getSortedTopLevelSections(allRegisteredComponents)
+      };
+    }, [allRegisteredComponents]),
+    childrenMap = _useMemo.childrenMap,
+    topLevelSections = _useMemo.topLevelSections;
+  return /*#__PURE__*/React.createElement(BlockMenuComponents, {
+    registeredComponents: topLevelSections,
+    childrenMap: childrenMap,
+    fallbacks: fallbacks
+  });
+};

package/dist/esm/ui/block-menu-renderer/fallbacks.js

@@ -0,0 +1,25 @@
+import React from 'react';
+import { ToolbarDropdownItem, ToolbarDropdownItemSection, ToolbarNestedDropdownMenu } from '@atlaskit/editor-toolbar';
+import ChevronRightIcon from '@atlaskit/icon/core/chevron-right';
+export var BLOCK_MENU_FALLBACKS = {
+  'block-menu-nested': function blockMenuNested(_ref) {
+    var children = _ref.children;
+    return /*#__PURE__*/React.createElement(ToolbarNestedDropdownMenu, {
+      elemBefore: undefined,
+      elemAfter: /*#__PURE__*/React.createElement(ChevronRightIcon, {
+        label: ""
+      }),
+      text: "Nested Menu",
+      enableMaxHeight: true,
+      shouldFitContainer: true
+    }, children);
+  },
+  'block-menu-section': function blockMenuSection(_ref2) {
+    var children = _ref2.children;
+    return /*#__PURE__*/React.createElement(ToolbarDropdownItemSection, null, children);
+  },
+  // eslint-disable-next-line @atlassian/i18n/no-literal-string-in-jsx
+  'block-menu-item': function blockMenuItem() {
+    return /*#__PURE__*/React.createElement(ToolbarDropdownItem, null, "Block Menu Item");
+  }
+};

package/dist/esm/ui/block-menu-renderer/types.js

@@ -0,0 +1 @@
+export {};