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

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 {};

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

@@ -0,0 +1,121 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
+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; }
+/**
+ * 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
+ */
+var hasParent = function 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
+ */
+var isTopLevelSection = function 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 var getSortedTopLevelSections = function getSortedTopLevelSections(components) {
+  return components.filter(isTopLevelSection).sort(function (a, b) {
+    return (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 var getChildrenMapKey = function getChildrenMapKey(key, type) {
+  return "".concat(type, ":").concat(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 var buildChildrenMap = function buildChildrenMap(components) {
+  var childrenMap = new Map();
+  var _iterator = _createForOfIteratorHelper(components),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var component = _step.value;
+      // Only components with parents can be children
+      if ('parent' in component && !!component.parent) {
+        var childrenMapKey = getChildrenMapKey(component.parent.key, component.parent.type);
+        var existing = childrenMap.get(childrenMapKey) || [];
+        existing.push(component);
+        childrenMap.set(childrenMapKey, existing);
+      }
+    }
+
+    // Sort children by their rank within their parent
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  var _iterator2 = _createForOfIteratorHelper(childrenMap.entries()),
+    _step2;
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var _step2$value = _slicedToArray(_step2.value, 2),
+        children = _step2$value[1];
+      children.sort(function (a, b) {
+        var rankA = hasParent(a) ? a.parent.rank || 0 : 0;
+        var rankB = hasParent(b) ? b.parent.rank || 0 : 0;
+        return rankA - rankB;
+      });
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+  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
+ */
+var _willComponentRender = function willComponentRender(registeredComponent, childrenMap) {
+  if (registeredComponent.type === 'block-menu-item') {
+    return registeredComponent.component ? registeredComponent.component() !== null : true;
+  }
+  var childrenMapKey = getChildrenMapKey(registeredComponent.key, registeredComponent.type);
+  var registeredComponents = childrenMap.get(childrenMapKey) || [];
+  if (registeredComponent.type === 'block-menu-nested') {
+    return registeredComponents.length > 0;
+  }
+  return registeredComponents.some(function (childComponent) {
+    return _willComponentRender(childComponent, childrenMap);
+  });
+};
+export { _willComponentRender as willComponentRender };

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

@@ -11,15 +11,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';
 var styles = {
   base: "_2rko12b0 _bfhk1bhr _16qs130s",
   emptyMenuSectionStyles: "_1cc0glyw _1k2yglyw"
@@ -111,24 +111,11 @@ var BlockMenuContent = function BlockMenuContent(_ref3) {
     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: function nestedMenu() {
-        return /*#__PURE__*/React.createElement(ToolbarNestedDropdownMenu, {
-          elemBefore: undefined,
-          elemAfter: undefined
-        }, /*#__PURE__*/React.createElement(ToolbarDropdownItemSection, null, /*#__PURE__*/React.createElement(ToolbarDropdownItem, null, "Block Menu Item")));
-      },
-      section: function section() {
-        return /*#__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: function item() {
-        return /*#__PURE__*/React.createElement(ToolbarDropdownItem, null, "Block Menu Item");
-      }
-    }
-  }));
+    allRegisteredComponents: blockMenuComponents || []
+  })));
 };
 var BlockMenu = function BlockMenu(_ref4) {
   var _editorView$dom, _ref5;

package/dist/types/blockMenuPluginType.d.ts

@@ -1,4 +1,4 @@
-import type { NextEditorPlugin, OptionalPlugin, EditorCommand } from '@atlaskit/editor-common/types';
+import type { EditorCommand, NextEditorPlugin, OptionalPlugin } from '@atlaskit/editor-common/types';
 import type { AnalyticsPlugin } from '@atlaskit/editor-plugin-analytics';
 import type { BlockControlsPlugin } from '@atlaskit/editor-plugin-block-controls';
 import type { DecorationsPlugin } from '@atlaskit/editor-plugin-decorations';
@@ -84,7 +84,7 @@ type BlockMenuNested = {
     key: string;
     type: 'block-menu-nested';
 };
-export type BlockMenuNestedComponent = (props?: {
+export type BlockMenuNestedComponent = (props: {
     children: React.ReactNode;
 }) => React.ReactNode;
 export type BlockMenuSectionComponent = (props: {
@@ -108,4 +108,5 @@ export type RegisterBlockMenuItem = BlockMenuItem & {
     parent: Parent<BlockMenuSection>;
 };
 export type RegisterBlockMenuComponent = RegisterBlockMenuNested | RegisterBlockMenuSection | RegisterBlockMenuItem;
+export type RegisterBlockMenuComponentType = RegisterBlockMenuComponent['type'];
 export {};

package/dist/types/ui/block-menu-renderer/BlockMenuComponent.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import type { RegisterBlockMenuComponent } from '../../blockMenuPluginType';
+import type { BlockMenuRenderingContext } from './types';
+type BlockMenuComponentProps = BlockMenuRenderingContext & {
+    registeredComponent: RegisterBlockMenuComponent;
+};
+/**
+ * Renders the given registered component based on its type
+ */
+export declare const BlockMenuComponent: ({ registeredComponent, childrenMap, fallbacks, }: BlockMenuComponentProps) => React.JSX.Element | null;
+export {};

package/dist/types/ui/block-menu-renderer/BlockMenuComponents.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import type { RegisterBlockMenuComponent } from '../../blockMenuPluginType';
+import type { BlockMenuRenderingContext } from './types';
+type BlockMenuComponentsProps = BlockMenuRenderingContext & {
+    registeredComponents?: RegisterBlockMenuComponent[];
+};
+/**
+ * Renders the given registered components
+ * Returns null if no components are rendered
+ */
+export declare const BlockMenuComponents: ({ registeredComponents, childrenMap, fallbacks, }: BlockMenuComponentsProps) => React.JSX.Element | null;
+export {};

package/dist/types/ui/block-menu-renderer/BlockMenuRenderer.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import type { RegisterBlockMenuComponent } from '../../blockMenuPluginType';
+import type { BlockMenuFallbacks } from './types';
+type BlockMenuProps = {
+    allRegisteredComponents: RegisterBlockMenuComponent[];
+    fallbacks?: BlockMenuFallbacks;
+};
+/**
+ * BlockMenuRenderer orchestrates the rendering of the entire block menu hierarchy
+ */
+export declare const BlockMenuRenderer: ({ allRegisteredComponents, fallbacks, }: BlockMenuProps) => React.JSX.Element;
+export {};

package/dist/types/ui/block-menu-renderer/fallbacks.d.ts

@@ -0,0 +1,2 @@
+import type { BlockMenuFallbacks } from './types';
+export declare const BLOCK_MENU_FALLBACKS: BlockMenuFallbacks;

package/dist/types/ui/block-menu-renderer/types.d.ts

@@ -0,0 +1,27 @@
+import type { BlockMenuItemComponent, BlockMenuNestedComponent, BlockMenuSectionComponent, RegisterBlockMenuComponent } from '../../blockMenuPluginType';
+/**
+ * Fallback components used as defaults when specific components aren't provided
+ */
+export type BlockMenuFallbacks = {
+    'block-menu-item': BlockMenuItemComponent;
+    'block-menu-nested': BlockMenuNestedComponent;
+    'block-menu-section': BlockMenuSectionComponent;
+};
+/**
+ * Map of parent keys to their sorted children components
+ * Used to efficiently organize and render hierarchical menu structures
+ */
+export type ChildrenMap = Map<string, RegisterBlockMenuComponent[]>;
+/**
+ * Props shared across multiple block menu rendering components
+ */
+export type BlockMenuRenderingContext = {
+    /**
+     * Lookup map for child components organized by parent key
+     */
+    childrenMap: ChildrenMap;
+    /**
+     * Fallback components when specific components aren't registered
+     */
+    fallbacks: BlockMenuFallbacks;
+};

package/dist/types/ui/block-menu-renderer/utils.d.ts

@@ -0,0 +1,37 @@
+import type { RegisterBlockMenuComponent, RegisterBlockMenuComponentType, RegisterBlockMenuSection } from '../../blockMenuPluginType';
+import type { ChildrenMap } from './types';
+/**
+ * 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 declare const getSortedTopLevelSections: (components: RegisterBlockMenuComponent[]) => RegisterBlockMenuSection[];
+/**
+ * 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 declare const getChildrenMapKey: (key: string, type: Omit<RegisterBlockMenuComponentType, "block-menu-item">) => string;
+/**
+ * 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 declare const buildChildrenMap: (components: RegisterBlockMenuComponent[]) => 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 declare const willComponentRender: (registeredComponent: RegisterBlockMenuComponent, childrenMap: ChildrenMap) => boolean;

package/dist/types-ts4.5/blockMenuPluginType.d.ts

@@ -1,4 +1,4 @@
-import type { NextEditorPlugin, OptionalPlugin, EditorCommand } from '@atlaskit/editor-common/types';
+import type { EditorCommand, NextEditorPlugin, OptionalPlugin } from '@atlaskit/editor-common/types';
 import type { AnalyticsPlugin } from '@atlaskit/editor-plugin-analytics';
 import type { BlockControlsPlugin } from '@atlaskit/editor-plugin-block-controls';
 import type { DecorationsPlugin } from '@atlaskit/editor-plugin-decorations';
@@ -84,7 +84,7 @@ type BlockMenuNested = {
     key: string;
     type: 'block-menu-nested';
 };
-export type BlockMenuNestedComponent = (props?: {
+export type BlockMenuNestedComponent = (props: {
     children: React.ReactNode;
 }) => React.ReactNode;
 export type BlockMenuSectionComponent = (props: {
@@ -108,4 +108,5 @@ export type RegisterBlockMenuItem = BlockMenuItem & {
     parent: Parent<BlockMenuSection>;
 };
 export type RegisterBlockMenuComponent = RegisterBlockMenuNested | RegisterBlockMenuSection | RegisterBlockMenuItem;
+export type RegisterBlockMenuComponentType = RegisterBlockMenuComponent['type'];
 export {};

package/dist/types-ts4.5/ui/block-menu-renderer/BlockMenuComponent.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import type { RegisterBlockMenuComponent } from '../../blockMenuPluginType';
+import type { BlockMenuRenderingContext } from './types';
+type BlockMenuComponentProps = BlockMenuRenderingContext & {
+    registeredComponent: RegisterBlockMenuComponent;
+};
+/**
+ * Renders the given registered component based on its type
+ */
+export declare const BlockMenuComponent: ({ registeredComponent, childrenMap, fallbacks, }: BlockMenuComponentProps) => React.JSX.Element | null;
+export {};

package/dist/types-ts4.5/ui/block-menu-renderer/BlockMenuComponents.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import type { RegisterBlockMenuComponent } from '../../blockMenuPluginType';
+import type { BlockMenuRenderingContext } from './types';
+type BlockMenuComponentsProps = BlockMenuRenderingContext & {
+    registeredComponents?: RegisterBlockMenuComponent[];
+};
+/**
+ * Renders the given registered components
+ * Returns null if no components are rendered
+ */
+export declare const BlockMenuComponents: ({ registeredComponents, childrenMap, fallbacks, }: BlockMenuComponentsProps) => React.JSX.Element | null;
+export {};

package/dist/types-ts4.5/ui/block-menu-renderer/BlockMenuRenderer.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import type { RegisterBlockMenuComponent } from '../../blockMenuPluginType';
+import type { BlockMenuFallbacks } from './types';
+type BlockMenuProps = {
+    allRegisteredComponents: RegisterBlockMenuComponent[];
+    fallbacks?: BlockMenuFallbacks;
+};
+/**
+ * BlockMenuRenderer orchestrates the rendering of the entire block menu hierarchy
+ */
+export declare const BlockMenuRenderer: ({ allRegisteredComponents, fallbacks, }: BlockMenuProps) => React.JSX.Element;
+export {};

package/dist/types-ts4.5/ui/block-menu-renderer/fallbacks.d.ts

@@ -0,0 +1,2 @@
+import type { BlockMenuFallbacks } from './types';
+export declare const BLOCK_MENU_FALLBACKS: BlockMenuFallbacks;

package/dist/types-ts4.5/ui/block-menu-renderer/types.d.ts

@@ -0,0 +1,27 @@
+import type { BlockMenuItemComponent, BlockMenuNestedComponent, BlockMenuSectionComponent, RegisterBlockMenuComponent } from '../../blockMenuPluginType';
+/**
+ * Fallback components used as defaults when specific components aren't provided
+ */
+export type BlockMenuFallbacks = {
+    'block-menu-item': BlockMenuItemComponent;
+    'block-menu-nested': BlockMenuNestedComponent;
+    'block-menu-section': BlockMenuSectionComponent;
+};
+/**
+ * Map of parent keys to their sorted children components
+ * Used to efficiently organize and render hierarchical menu structures
+ */
+export type ChildrenMap = Map<string, RegisterBlockMenuComponent[]>;
+/**
+ * Props shared across multiple block menu rendering components
+ */
+export type BlockMenuRenderingContext = {
+    /**
+     * Lookup map for child components organized by parent key
+     */
+    childrenMap: ChildrenMap;
+    /**
+     * Fallback components when specific components aren't registered
+     */
+    fallbacks: BlockMenuFallbacks;
+};

package/dist/types-ts4.5/ui/block-menu-renderer/utils.d.ts

@@ -0,0 +1,37 @@
+import type { RegisterBlockMenuComponent, RegisterBlockMenuComponentType, RegisterBlockMenuSection } from '../../blockMenuPluginType';
+import type { ChildrenMap } from './types';
+/**
+ * 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 declare const getSortedTopLevelSections: (components: RegisterBlockMenuComponent[]) => RegisterBlockMenuSection[];
+/**
+ * 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 declare const getChildrenMapKey: (key: string, type: Omit<RegisterBlockMenuComponentType, "block-menu-item">) => string;
+/**
+ * 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 declare const buildChildrenMap: (components: RegisterBlockMenuComponent[]) => 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 declare const willComponentRender: (registeredComponent: RegisterBlockMenuComponent, childrenMap: ChildrenMap) => boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@atlaskit/editor-plugin-block-menu",
-	"version": "5.2.11",
+	"version": "5.2.12",
 	"description": "BlockMenu plugin for @atlaskit/editor-core",
 	"author": "Atlassian Pty Ltd",
 	"license": "Apache-2.0",

package/dist/cjs/ui/block-menu-renderer.js

@@ -1,104 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-var _typeof = require("@babel/runtime/helpers/typeof");
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.BlockMenuRenderer = void 0;
-var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
-var _react = _interopRequireWildcard(require("react"));
-var _uiMenu = require("@atlaskit/editor-common/ui-menu");
-function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != _typeof(e) && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
-var NoOp = function NoOp() {
-  return null;
-};
-var isNonNestedMenuSection = function isNonNestedMenuSection(component) {
-  return component.type === 'block-menu-section' && !('parent' in component);
-};
-var isMenuItem = function isMenuItem(component) {
-  return component.type === 'block-menu-item';
-};
-var isNestedMenu = function isNestedMenu(component) {
-  return component.type === 'block-menu-nested';
-};
-var isNestedMenuSection = function isNestedMenuSection(component) {
-  return 'parent' in component && component.parent !== undefined && component.parent.type === 'block-menu-nested';
-};
-var getSortedChildren = function getSortedChildren(components, parentKey) {
-  return components.filter(function (component) {
-    return 'parent' in component && component.parent !== undefined && component.parent.key === parentKey;
-  }).sort(function (a, b) {
-    return (a.parent.rank || 0) - (b.parent.rank || 0);
-  });
-};
-var getSortedNestedSections = function getSortedNestedSections(components, parentKey) {
-  var nestedMenuSections = components.filter(isNestedMenuSection);
-  var nestedMenuSectionsWithParent = nestedMenuSections.filter(function (section) {
-    return section.parent !== undefined;
-  });
-  return getSortedChildren(nestedMenuSectionsWithParent, parentKey);
-};
-var getSortedNonNestedSections = function getSortedNonNestedSections(components) {
-  return components.filter(isNonNestedMenuSection).sort(function (a, b) {
-    return (a.rank || 0) - (b.rank || 0);
-  });
-};
-var BlockMenuRenderer = exports.BlockMenuRenderer = function BlockMenuRenderer(_ref) {
-  var components = _ref.components,
-    fallbacks = _ref.fallbacks;
-  var menuSections = getSortedNonNestedSections(components);
-  var menuItems = components.filter(isMenuItem);
-  var nestedMenus = components.filter(isNestedMenu);
-  var renderMenu = function renderMenu() {
-    return /*#__PURE__*/_react.default.createElement(_react.Fragment, null, menuSections.map(function (section) {
-      // Get all items for the current section, including nested menus, and sort them by rank
-      var currentSectionItemsSorted = getSortedChildren([].concat((0, _toConsumableArray2.default)(menuItems), (0, _toConsumableArray2.default)(nestedMenus)), section.key);
-      if (currentSectionItemsSorted.length === 0) {
-        return null;
-      }
-
-      // iterate over the current section items, if it is nested menu, get their children, sort them
-      // if they are menu items, just render as they are sorted above
-      var getChildrenWithNestedItems = function getChildrenWithNestedItems(items) {
-        return items.map(function (item) {
-          if (isNestedMenu(item)) {
-            var sortedNestedSections = getSortedNestedSections(components, item.key);
-            var sections = sortedNestedSections.map(function (section) {
-              var sortedNestedMenuItems = getSortedChildren(menuItems, section.key);
-              if (sortedNestedMenuItems.length === 0) {
-                return null;
-              }
-              var NestedSection = section.component || fallbacks.section || NoOp;
-              return /*#__PURE__*/_react.default.createElement(NestedSection, {
-                key: section.key
-              }, sortedNestedMenuItems.map(function (nestedItem) {
-                var NestedMenuItemComponent = nestedItem.component || fallbacks.item || NoOp;
-                return /*#__PURE__*/_react.default.createElement(NestedMenuItemComponent, {
-                  key: nestedItem.key
-                });
-              }));
-            });
-            var NestedMenuComponent = item.component || fallbacks.nestedMenu || NoOp;
-            return /*#__PURE__*/_react.default.createElement(NestedMenuComponent, {
-              key: item.key
-            }, sections);
-          } else {
-            var ItemComponent = item.component || fallbacks.item || NoOp;
-            return /*#__PURE__*/_react.default.createElement(ItemComponent, {
-              key: item.key
-            });
-          }
-        });
-      };
-      var children = getChildrenWithNestedItems(currentSectionItemsSorted);
-      var SectionComponent = section.component || fallbacks.section || NoOp;
-      return /*#__PURE__*/_react.default.createElement(SectionComponent, {
-        key: section.key
-      }, children);
-    }));
-  };
-  return /*#__PURE__*/_react.default.createElement(_uiMenu.ArrowKeyNavigationProvider, {
-    type: _uiMenu.ArrowKeyNavigationType.MENU
-  }, renderMenu());
-};