@wordpress/block-library 9.36.2-next.8fd3f8831.0 → 9.37.2-next.79a2f3cdd.0

package/build-module/navigation/edit/inner-blocks.mjs

@@ -0,0 +1,84 @@
+// packages/block-library/src/navigation/edit/inner-blocks.js
+import { useEntityBlockEditor } from "@wordpress/core-data";
+import {
+  useInnerBlocksProps,
+  InnerBlocks,
+  store as blockEditorStore
+} from "@wordpress/block-editor";
+import { useSelect } from "@wordpress/data";
+import { useMemo } from "@wordpress/element";
+import PlaceholderPreview from "./placeholder/placeholder-preview.mjs";
+import { DEFAULT_BLOCK, PRIORITIZED_INSERTER_BLOCKS } from "../constants.mjs";
+import { jsx } from "react/jsx-runtime";
+function NavigationInnerBlocks({
+  clientId,
+  hasCustomPlaceholder,
+  orientation,
+  templateLock
+}) {
+  const {
+    isImmediateParentOfSelectedBlock,
+    selectedBlockHasChildren,
+    isSelected,
+    hasSelectedDescendant
+  } = useSelect(
+    (select) => {
+      const {
+        getBlockCount,
+        hasSelectedInnerBlock,
+        getSelectedBlockClientId
+      } = select(blockEditorStore);
+      const selectedBlockId = getSelectedBlockClientId();
+      return {
+        isImmediateParentOfSelectedBlock: hasSelectedInnerBlock(
+          clientId,
+          false
+        ),
+        selectedBlockHasChildren: !!getBlockCount(selectedBlockId),
+        hasSelectedDescendant: hasSelectedInnerBlock(clientId, true),
+        // This prop is already available but computing it here ensures it's
+        // fresh compared to isImmediateParentOfSelectedBlock.
+        isSelected: selectedBlockId === clientId
+      };
+    },
+    [clientId]
+  );
+  const [blocks, onInput, onChange] = useEntityBlockEditor(
+    "postType",
+    "wp_navigation"
+  );
+  const parentOrChildHasSelection = isSelected || isImmediateParentOfSelectedBlock && !selectedBlockHasChildren;
+  const placeholder = useMemo(() => /* @__PURE__ */ jsx(PlaceholderPreview, {}), []);
+  const hasMenuItems = !!blocks?.length;
+  const showPlaceholder = !hasCustomPlaceholder && !hasMenuItems && !isSelected;
+  const innerBlocksProps = useInnerBlocksProps(
+    {
+      className: "wp-block-navigation__container"
+    },
+    {
+      value: blocks,
+      onInput,
+      onChange,
+      prioritizedInserterBlocks: PRIORITIZED_INSERTER_BLOCKS,
+      defaultBlock: DEFAULT_BLOCK,
+      directInsert: true,
+      orientation,
+      templateLock,
+      // As an exception to other blocks which feature nesting, show
+      // the block appender even when a child block is selected.
+      // This should be a temporary fix, to be replaced by improvements to
+      // the sibling inserter.
+      // See https://github.com/WordPress/gutenberg/issues/37572.
+      renderAppender: isSelected || isImmediateParentOfSelectedBlock && !selectedBlockHasChildren || hasSelectedDescendant || // Show the appender while dragging to allow inserting element between item and the appender.
+      parentOrChildHasSelection ? InnerBlocks.ButtonBlockAppender : false,
+      placeholder: showPlaceholder ? placeholder : void 0,
+      __experimentalCaptureToolbars: true,
+      __unstableDisableLayoutClassNames: true
+    }
+  );
+  return /* @__PURE__ */ jsx("div", { ...innerBlocksProps });
+}
+export {
+  NavigationInnerBlocks as default
+};
+//# sourceMappingURL=inner-blocks.mjs.map

package/build-module/navigation/edit/leaf-more-menu.mjs

@@ -0,0 +1,153 @@
+// packages/block-library/src/navigation/edit/leaf-more-menu.js
+import { createBlock } from "@wordpress/blocks";
+import {
+  addSubmenu,
+  chevronUp,
+  chevronDown,
+  moreVertical
+} from "@wordpress/icons";
+import { DropdownMenu, MenuItem, MenuGroup } from "@wordpress/components";
+import { useDispatch, useSelect } from "@wordpress/data";
+import { __, sprintf } from "@wordpress/i18n";
+import { BlockTitle, store as blockEditorStore } from "@wordpress/block-editor";
+import { DEFAULT_BLOCK } from "../constants.mjs";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+var POPOVER_PROPS = {
+  className: "block-editor-block-settings-menu__popover",
+  placement: "bottom-start"
+};
+var BLOCKS_THAT_CAN_BE_CONVERTED_TO_SUBMENU = [
+  "core/navigation-link",
+  "core/navigation-submenu"
+];
+function AddSubmenuItem({
+  block,
+  onClose,
+  expandedState,
+  expand,
+  setInsertedBlock
+}) {
+  const { insertBlock, replaceBlock, replaceInnerBlocks } = useDispatch(blockEditorStore);
+  const clientId = block.clientId;
+  const isDisabled = !BLOCKS_THAT_CAN_BE_CONVERTED_TO_SUBMENU.includes(
+    block.name
+  );
+  return /* @__PURE__ */ jsx(
+    MenuItem,
+    {
+      icon: addSubmenu,
+      disabled: isDisabled,
+      onClick: () => {
+        const updateSelectionOnInsert = false;
+        const newLink = createBlock(
+          DEFAULT_BLOCK.name,
+          DEFAULT_BLOCK.attributes
+        );
+        if (block.name === "core/navigation-submenu") {
+          insertBlock(
+            newLink,
+            block.innerBlocks.length,
+            clientId,
+            updateSelectionOnInsert
+          );
+        } else {
+          const newSubmenu = createBlock(
+            "core/navigation-submenu",
+            block.attributes,
+            block.innerBlocks
+          );
+          replaceBlock(clientId, newSubmenu);
+          replaceInnerBlocks(
+            newSubmenu.clientId,
+            [newLink],
+            updateSelectionOnInsert
+          );
+        }
+        setInsertedBlock(newLink);
+        if (!expandedState[block.clientId]) {
+          expand(block.clientId);
+        }
+        onClose();
+      },
+      children: __("Add submenu link")
+    }
+  );
+}
+function LeafMoreMenu(props) {
+  const { block } = props;
+  const { clientId } = block;
+  const { moveBlocksDown, moveBlocksUp, removeBlocks } = useDispatch(blockEditorStore);
+  const removeLabel = sprintf(
+    /* translators: %s: block name */
+    __("Remove %s"),
+    BlockTitle({ clientId, maximumLength: 25 })
+  );
+  const rootClientId = useSelect(
+    (select) => {
+      const { getBlockRootClientId } = select(blockEditorStore);
+      return getBlockRootClientId(clientId);
+    },
+    [clientId]
+  );
+  return /* @__PURE__ */ jsx(
+    DropdownMenu,
+    {
+      icon: moreVertical,
+      label: __("Options"),
+      className: "block-editor-block-settings-menu",
+      popoverProps: POPOVER_PROPS,
+      noIcons: true,
+      ...props,
+      children: ({ onClose }) => /* @__PURE__ */ jsxs(Fragment, { children: [
+        /* @__PURE__ */ jsxs(MenuGroup, { children: [
+          /* @__PURE__ */ jsx(
+            MenuItem,
+            {
+              icon: chevronUp,
+              onClick: () => {
+                moveBlocksUp([clientId], rootClientId);
+                onClose();
+              },
+              children: __("Move up")
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            MenuItem,
+            {
+              icon: chevronDown,
+              onClick: () => {
+                moveBlocksDown([clientId], rootClientId);
+                onClose();
+              },
+              children: __("Move down")
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            AddSubmenuItem,
+            {
+              block,
+              onClose,
+              expandedState: props.expandedState,
+              expand: props.expand,
+              setInsertedBlock: props.setInsertedBlock
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsx(MenuGroup, { children: /* @__PURE__ */ jsx(
+          MenuItem,
+          {
+            onClick: () => {
+              removeBlocks([clientId], false);
+              onClose();
+            },
+            children: removeLabel
+          }
+        ) })
+      ] })
+    }
+  );
+}
+export {
+  LeafMoreMenu as default
+};
+//# sourceMappingURL=leaf-more-menu.mjs.map

package/build-module/navigation/edit/manage-menus-button.mjs

@@ -0,0 +1,32 @@
+// packages/block-library/src/navigation/edit/manage-menus-button.js
+import { addQueryArgs } from "@wordpress/url";
+import { Button, MenuItem } from "@wordpress/components";
+import { __ } from "@wordpress/i18n";
+import { jsx } from "react/jsx-runtime";
+var ManageMenusButton = ({
+  className = "",
+  disabled,
+  isMenuItem = false
+}) => {
+  let ComponentName = Button;
+  if (isMenuItem) {
+    ComponentName = MenuItem;
+  }
+  return /* @__PURE__ */ jsx(
+    ComponentName,
+    {
+      variant: "link",
+      disabled,
+      className,
+      href: addQueryArgs("edit.php", {
+        post_type: "wp_navigation"
+      }),
+      children: __("Manage menus")
+    }
+  );
+};
+var manage_menus_button_default = ManageMenusButton;
+export {
+  manage_menus_button_default as default
+};
+//# sourceMappingURL=manage-menus-button.mjs.map

package/build-module/navigation/edit/menu-inspector-controls.mjs

@@ -0,0 +1,178 @@
+// packages/block-library/src/navigation/edit/menu-inspector-controls.js
+import {
+  privateApis as blockEditorPrivateApis,
+  InspectorControls,
+  store as blockEditorStore
+} from "@wordpress/block-editor";
+import {
+  PanelBody,
+  __experimentalHStack as HStack,
+  __experimentalHeading as Heading,
+  Spinner
+} from "@wordpress/components";
+import { useSelect, useDispatch } from "@wordpress/data";
+import { __, sprintf } from "@wordpress/i18n";
+import NavigationMenuSelector from "./navigation-menu-selector.mjs";
+import { unlock } from "../../lock-unlock.mjs";
+import DeletedNavigationWarning from "./deleted-navigation-warning.mjs";
+import useNavigationMenu from "../use-navigation-menu.mjs";
+import LeafMoreMenu from "./leaf-more-menu.mjs";
+import {
+  LinkUI,
+  updateAttributes,
+  useEntityBinding
+} from "../../navigation-link/shared/index.mjs";
+import { jsx, jsxs } from "react/jsx-runtime";
+var actionLabel = (
+  /* translators: %s: The name of a menu. */
+  __("Switch to '%s'")
+);
+var BLOCKS_WITH_LINK_UI_SUPPORT = [
+  "core/navigation-link",
+  "core/navigation-submenu"
+];
+var { PrivateListView } = unlock(blockEditorPrivateApis);
+function AdditionalBlockContent({ block, insertedBlock, setInsertedBlock }) {
+  const { updateBlockAttributes, removeBlock } = useDispatch(blockEditorStore);
+  const supportsLinkControls = BLOCKS_WITH_LINK_UI_SUPPORT?.includes(
+    insertedBlock?.name
+  );
+  const blockWasJustInserted = insertedBlock?.clientId === block.clientId;
+  const showLinkControls = supportsLinkControls && blockWasJustInserted;
+  const { createBinding, clearBinding } = useEntityBinding({
+    clientId: insertedBlock?.clientId,
+    attributes: insertedBlock?.attributes || {}
+  });
+  if (!showLinkControls) {
+    return null;
+  }
+  const cleanupInsertedBlock = () => {
+    const shouldAutoSelectBlock = false;
+    if (!insertedBlock?.attributes?.url && insertedBlock?.clientId) {
+      removeBlock(insertedBlock.clientId, shouldAutoSelectBlock);
+    }
+    setInsertedBlock(null);
+  };
+  const setInsertedBlockAttributes = (_insertedBlockClientId) => (_updatedAttributes) => {
+    if (!_insertedBlockClientId) {
+      return;
+    }
+    updateBlockAttributes(_insertedBlockClientId, _updatedAttributes);
+  };
+  const handleSetInsertedBlock = (newBlock) => {
+    const shouldAutoSelectBlock = false;
+    if (insertedBlock?.clientId && newBlock) {
+      removeBlock(insertedBlock.clientId, shouldAutoSelectBlock);
+    }
+    setInsertedBlock(newBlock);
+  };
+  return /* @__PURE__ */ jsx(
+    LinkUI,
+    {
+      clientId: insertedBlock?.clientId,
+      link: insertedBlock?.attributes,
+      onBlockInsert: handleSetInsertedBlock,
+      onClose: () => {
+        cleanupInsertedBlock();
+      },
+      onChange: (updatedValue) => {
+        const { isEntityLink, attributes: updatedAttributes } = updateAttributes(
+          updatedValue,
+          setInsertedBlockAttributes(insertedBlock?.clientId),
+          insertedBlock?.attributes
+        );
+        if (isEntityLink) {
+          createBinding(updatedAttributes);
+        } else {
+          clearBinding();
+        }
+        setInsertedBlock(null);
+      }
+    }
+  );
+}
+var MainContent = ({
+  clientId,
+  currentMenuId,
+  isLoading,
+  isNavigationMenuMissing,
+  onCreateNew
+}) => {
+  const hasChildren = useSelect(
+    (select) => {
+      return !!select(blockEditorStore).getBlockCount(clientId);
+    },
+    [clientId]
+  );
+  const { navigationMenu } = useNavigationMenu(currentMenuId);
+  if (currentMenuId && isNavigationMenuMissing) {
+    return /* @__PURE__ */ jsx(DeletedNavigationWarning, { onCreateNew, isNotice: true });
+  }
+  if (isLoading) {
+    return /* @__PURE__ */ jsx(Spinner, {});
+  }
+  const description = navigationMenu ? sprintf(
+    /* translators: %s: The name of a menu. */
+    __("Structure for Navigation Menu: %s"),
+    navigationMenu?.title || __("Untitled menu")
+  ) : __(
+    "You have not yet created any menus. Displaying a list of your Pages"
+  );
+  return /* @__PURE__ */ jsxs("div", { className: "wp-block-navigation__menu-inspector-controls", children: [
+    !hasChildren && /* @__PURE__ */ jsx("p", { className: "wp-block-navigation__menu-inspector-controls__empty-message", children: __("This Navigation Menu is empty.") }),
+    /* @__PURE__ */ jsx(
+      PrivateListView,
+      {
+        rootClientId: clientId,
+        isExpanded: true,
+        description,
+        showAppender: true,
+        blockSettingsMenu: LeafMoreMenu,
+        additionalBlockContent: AdditionalBlockContent
+      }
+    )
+  ] });
+};
+var MenuInspectorControls = (props) => {
+  const {
+    createNavigationMenuIsSuccess,
+    createNavigationMenuIsError,
+    currentMenuId = null,
+    onCreateNew,
+    onSelectClassicMenu,
+    onSelectNavigationMenu,
+    isManageMenusButtonDisabled,
+    blockEditingMode
+  } = props;
+  return /* @__PURE__ */ jsx(InspectorControls, { group: "list", children: /* @__PURE__ */ jsxs(PanelBody, { title: null, children: [
+    /* @__PURE__ */ jsxs(HStack, { className: "wp-block-navigation-off-canvas-editor__header", children: [
+      /* @__PURE__ */ jsx(
+        Heading,
+        {
+          className: "wp-block-navigation-off-canvas-editor__title",
+          level: 2,
+          children: __("Menu")
+        }
+      ),
+      blockEditingMode === "default" && /* @__PURE__ */ jsx(
+        NavigationMenuSelector,
+        {
+          currentMenuId,
+          onSelectClassicMenu,
+          onSelectNavigationMenu,
+          onCreateNew,
+          createNavigationMenuIsSuccess,
+          createNavigationMenuIsError,
+          actionLabel,
+          isManageMenusButtonDisabled
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx(MainContent, { ...props })
+  ] }) });
+};
+var menu_inspector_controls_default = MenuInspectorControls;
+export {
+  menu_inspector_controls_default as default
+};
+//# sourceMappingURL=menu-inspector-controls.mjs.map

package/build-module/navigation/edit/navigation-menu-delete-control.mjs

@@ -0,0 +1,54 @@
+// packages/block-library/src/navigation/edit/navigation-menu-delete-control.js
+import {
+  Button,
+  __experimentalConfirmDialog as ConfirmDialog
+} from "@wordpress/components";
+import { store as coreStore, useEntityId } from "@wordpress/core-data";
+import { useDispatch } from "@wordpress/data";
+import { useState } from "@wordpress/element";
+import { __ } from "@wordpress/i18n";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+function NavigationMenuDeleteControl({ onDelete }) {
+  const [isConfirmDialogVisible, setIsConfirmDialogVisible] = useState(false);
+  const id = useEntityId("postType", "wp_navigation");
+  const { deleteEntityRecord } = useDispatch(coreStore);
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(
+      Button,
+      {
+        __next40pxDefaultSize: true,
+        className: "wp-block-navigation-delete-menu-button",
+        variant: "secondary",
+        isDestructive: true,
+        onClick: () => {
+          setIsConfirmDialogVisible(true);
+        },
+        children: __("Delete menu")
+      }
+    ),
+    isConfirmDialogVisible && /* @__PURE__ */ jsx(
+      ConfirmDialog,
+      {
+        isOpen: true,
+        onConfirm: () => {
+          deleteEntityRecord("postType", "wp_navigation", id, {
+            force: true
+          });
+          onDelete();
+        },
+        onCancel: () => {
+          setIsConfirmDialogVisible(false);
+        },
+        confirmButtonText: __("Delete"),
+        size: "medium",
+        children: __(
+          "Are you sure you want to delete this Navigation Menu?"
+        )
+      }
+    )
+  ] });
+}
+export {
+  NavigationMenuDeleteControl as default
+};
+//# sourceMappingURL=navigation-menu-delete-control.mjs.map

package/build-module/navigation/edit/navigation-menu-name-control.mjs

@@ -0,0 +1,25 @@
+// packages/block-library/src/navigation/edit/navigation-menu-name-control.js
+import { TextControl } from "@wordpress/components";
+import { useEntityProp } from "@wordpress/core-data";
+import { __ } from "@wordpress/i18n";
+import { jsx } from "react/jsx-runtime";
+function NavigationMenuNameControl() {
+  const [title, updateTitle] = useEntityProp(
+    "postType",
+    "wp_navigation",
+    "title"
+  );
+  return /* @__PURE__ */ jsx(
+    TextControl,
+    {
+      __next40pxDefaultSize: true,
+      label: __("Menu name"),
+      value: title,
+      onChange: updateTitle
+    }
+  );
+}
+export {
+  NavigationMenuNameControl as default
+};
+//# sourceMappingURL=navigation-menu-name-control.mjs.map

package/build-module/navigation/edit/navigation-menu-selector.mjs

@@ -0,0 +1,168 @@
+// packages/block-library/src/navigation/edit/navigation-menu-selector.js
+import {
+  MenuGroup,
+  MenuItem,
+  MenuItemsChoice,
+  DropdownMenu
+} from "@wordpress/components";
+import { moreVertical } from "@wordpress/icons";
+import { __, sprintf } from "@wordpress/i18n";
+import { decodeEntities } from "@wordpress/html-entities";
+import { useEffect, useMemo, useState } from "@wordpress/element";
+import { useEntityProp } from "@wordpress/core-data";
+import useNavigationMenu from "../use-navigation-menu.mjs";
+import useNavigationEntities from "../use-navigation-entities.mjs";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+function buildMenuLabel(title, id, status) {
+  if (!title) {
+    return sprintf(__("(no title %s)"), id);
+  }
+  if (status === "publish") {
+    return decodeEntities(title);
+  }
+  return sprintf(
+    // translators: 1: title of the menu. 2: status of the menu (draft, pending, etc.).
+    __("%1$s (%2$s)"),
+    decodeEntities(title),
+    status
+  );
+}
+function NavigationMenuSelector({
+  currentMenuId,
+  onSelectNavigationMenu,
+  onSelectClassicMenu,
+  onCreateNew,
+  actionLabel,
+  createNavigationMenuIsSuccess,
+  createNavigationMenuIsError
+}) {
+  const createActionLabel = __("Create from '%s'");
+  const [isUpdatingMenuRef, setIsUpdatingMenuRef] = useState(false);
+  actionLabel = actionLabel || createActionLabel;
+  const { menus: classicMenus } = useNavigationEntities();
+  const {
+    navigationMenus,
+    isResolvingNavigationMenus,
+    hasResolvedNavigationMenus,
+    canUserCreateNavigationMenus,
+    canSwitchNavigationMenu,
+    isNavigationMenuMissing
+  } = useNavigationMenu(currentMenuId);
+  const [currentTitle] = useEntityProp(
+    "postType",
+    "wp_navigation",
+    "title"
+  );
+  const menuChoices = useMemo(() => {
+    return navigationMenus?.map(({ id, title, status }, index) => {
+      const label = buildMenuLabel(
+        title?.rendered,
+        index + 1,
+        status
+      );
+      return {
+        value: id,
+        label,
+        ariaLabel: sprintf(actionLabel, label),
+        disabled: isUpdatingMenuRef || isResolvingNavigationMenus || !hasResolvedNavigationMenus
+      };
+    }) || [];
+  }, [
+    navigationMenus,
+    actionLabel,
+    isResolvingNavigationMenus,
+    hasResolvedNavigationMenus,
+    isUpdatingMenuRef
+  ]);
+  const hasNavigationMenus = !!navigationMenus?.length;
+  const hasClassicMenus = !!classicMenus?.length;
+  const showNavigationMenus = !!canSwitchNavigationMenu;
+  const showClassicMenus = !!canUserCreateNavigationMenus;
+  const noMenuSelected = hasNavigationMenus && !currentMenuId;
+  const noBlockMenus = !hasNavigationMenus && hasResolvedNavigationMenus;
+  const menuUnavailable = hasResolvedNavigationMenus && currentMenuId === null;
+  const navMenuHasBeenDeleted = currentMenuId && isNavigationMenuMissing;
+  let selectorLabel = "";
+  if (isResolvingNavigationMenus) {
+    selectorLabel = __("Loading\u2026");
+  } else if (noMenuSelected || noBlockMenus || menuUnavailable || navMenuHasBeenDeleted) {
+    selectorLabel = __("Choose or create a Navigation Menu");
+  } else {
+    selectorLabel = currentTitle;
+  }
+  useEffect(() => {
+    if (isUpdatingMenuRef && (createNavigationMenuIsSuccess || createNavigationMenuIsError)) {
+      setIsUpdatingMenuRef(false);
+    }
+  }, [
+    hasResolvedNavigationMenus,
+    createNavigationMenuIsSuccess,
+    canUserCreateNavigationMenus,
+    createNavigationMenuIsError,
+    isUpdatingMenuRef,
+    menuUnavailable,
+    noBlockMenus,
+    noMenuSelected
+  ]);
+  const NavigationMenuSelectorDropdown = /* @__PURE__ */ jsx(
+    DropdownMenu,
+    {
+      label: selectorLabel,
+      icon: moreVertical,
+      toggleProps: { size: "small" },
+      children: ({ onClose }) => /* @__PURE__ */ jsxs(Fragment, { children: [
+        showNavigationMenus && hasNavigationMenus && /* @__PURE__ */ jsx(MenuGroup, { label: __("Menus"), children: /* @__PURE__ */ jsx(
+          MenuItemsChoice,
+          {
+            value: currentMenuId,
+            onSelect: (menuId) => {
+              onSelectNavigationMenu(menuId);
+              onClose();
+            },
+            choices: menuChoices
+          }
+        ) }),
+        showClassicMenus && hasClassicMenus && /* @__PURE__ */ jsx(MenuGroup, { label: __("Import Classic Menus"), children: classicMenus?.map((menu) => {
+          const label = decodeEntities(menu.name);
+          return /* @__PURE__ */ jsx(
+            MenuItem,
+            {
+              onClick: async () => {
+                setIsUpdatingMenuRef(true);
+                await onSelectClassicMenu(menu);
+                setIsUpdatingMenuRef(false);
+                onClose();
+              },
+              "aria-label": sprintf(
+                createActionLabel,
+                label
+              ),
+              disabled: isUpdatingMenuRef || isResolvingNavigationMenus || !hasResolvedNavigationMenus,
+              children: label
+            },
+            menu.id
+          );
+        }) }),
+        canUserCreateNavigationMenus && /* @__PURE__ */ jsx(MenuGroup, { label: __("Tools"), children: /* @__PURE__ */ jsx(
+          MenuItem,
+          {
+            onClick: async () => {
+              setIsUpdatingMenuRef(true);
+              await onCreateNew();
+              setIsUpdatingMenuRef(false);
+              onClose();
+            },
+            disabled: isUpdatingMenuRef || isResolvingNavigationMenus || !hasResolvedNavigationMenus,
+            children: __("Create new Menu")
+          }
+        ) })
+      ] })
+    }
+  );
+  return NavigationMenuSelectorDropdown;
+}
+var navigation_menu_selector_default = NavigationMenuSelector;
+export {
+  navigation_menu_selector_default as default
+};
+//# sourceMappingURL=navigation-menu-selector.mjs.map