@infomaximum/ui-kit 0.19.0 → 0.20.0

package/dist/components/NewDropdown/components/Menu/Menu.js

@@ -0,0 +1,33 @@
+import { jsx } from "@emotion/react/jsx-runtime";
+import { isFlatMenuItem, isDividerItem, isSubMenuItem, isGroupItem } from "../../NewDropdown.utils.js";
+import { SubMenuItem } from "../SubMenuItem/SubMenuItem.js";
+import { GroupItem } from "../GroupItem/GroupItem.js";
+import { menuListStyle } from "./Menu.styles.js";
+import { MenuItem } from "../MenuItem/MenuItem.js";
+import { Divider } from "../Divider/Divider.js";
+const Menu = (props) => {
+  const {
+    items,
+    "test-id": menuTestId,
+    parentKeyPath = ""
+  } = props;
+  return /* @__PURE__ */ jsx("ul", { css: menuListStyle, "test-id": menuTestId, children: items.map((item, index) => {
+    const key = item.key ?? `__nokey-${index}`;
+    if (isFlatMenuItem(item)) {
+      return /* @__PURE__ */ jsx(MenuItem, { item, parentKeyPath }, key);
+    }
+    if (isDividerItem(item)) {
+      return /* @__PURE__ */ jsx(Divider, {}, key);
+    }
+    if (isSubMenuItem(item)) {
+      return /* @__PURE__ */ jsx(SubMenuItem, { item, parentKeyPath }, key);
+    }
+    if (isGroupItem(item)) {
+      return /* @__PURE__ */ jsx(GroupItem, { item, parentKeyPath }, key);
+    }
+    return null;
+  }) });
+};
+export {
+  Menu
+};

package/dist/components/NewDropdown/components/Menu/Menu.styles.d.ts

@@ -0,0 +1,2 @@
+import { Interpolation } from '@emotion/react';
+export declare const menuListStyle: Interpolation;

package/dist/components/NewDropdown/components/Menu/Menu.styles.js

@@ -0,0 +1,8 @@
+const menuListStyle = {
+  margin: 0,
+  padding: 0,
+  listStyle: "none"
+};
+export {
+  menuListStyle
+};

package/dist/components/NewDropdown/components/Menu/Menu.types.d.ts

@@ -0,0 +1,11 @@
+import { NewDropdownProps } from '../../NewDropdown.types';
+export interface MenuProps {
+    items: NewDropdownProps["menu"]["items"];
+    "test-id"?: string;
+    /**
+     * Путь ключей от корня меню до текущего уровня, разделённый точкой
+     * (формат lodash path). Пустая строка означает корень.
+     * @default ""
+     */
+    parentKeyPath?: string;
+}

package/dist/components/NewDropdown/components/Menu/index.d.ts

@@ -0,0 +1 @@
+export { Menu } from './Menu';

package/dist/components/NewDropdown/components/MenuItem/MenuItem.d.ts

@@ -0,0 +1,3 @@
+import { FC } from 'react';
+import { MenuItemProps } from './MenuItem.types';
+export declare const MenuItem: FC<MenuItemProps>;

package/dist/components/NewDropdown/components/MenuItem/MenuItem.js

@@ -0,0 +1,75 @@
+import { jsxs, jsx } from "@emotion/react/jsx-runtime";
+import { useContext } from "react";
+import { useFloatingTree, useListItem } from "@floating-ui/react";
+import { isString, toPath } from "lodash-es";
+import { NewDropdownContext } from "../../contexts/NewDropdownContext.js";
+import { NewDropdownNavigationContext } from "../../contexts/NewDropdownNavigationContext.js";
+import { getItemStyle, itemContentStyle, itemIconStyle, itemTitleStyle, getItemExtraStyle, itemExtraTextStyle } from "./MenuItem.styles.js";
+import { useNewDropdownTokens } from "../../hooks/useNewDropdownTokens/useNewDropdownTokens.js";
+const MenuItem = (props) => {
+  var _a, _b, _c, _d;
+  const {
+    item,
+    parentKeyPath
+  } = props;
+  const {
+    key,
+    label,
+    icon,
+    extra,
+    disabled = false,
+    onClick,
+    "test-id": testId
+  } = item;
+  const {
+    styles,
+    onMenuClick
+  } = useContext(NewDropdownContext);
+  const {
+    activeIndex,
+    getItemProps
+  } = useContext(NewDropdownNavigationContext);
+  const {
+    theme,
+    tokens
+  } = useNewDropdownTokens();
+  const tree = useFloatingTree();
+  const listItem = useListItem();
+  const isActive = listItem.index === activeIndex;
+  const handleClick = (event) => {
+    if (disabled) {
+      return;
+    }
+    const keyPath = parentKeyPath ? [...toPath(parentKeyPath), key] : [key];
+    onClick == null ? void 0 : onClick({
+      key,
+      keyPath,
+      domEvent: event
+    });
+    onMenuClick == null ? void 0 : onMenuClick({
+      item,
+      key,
+      keyPath,
+      domEvent: event
+    });
+    tree == null ? void 0 : tree.events.emit("click", event.nativeEvent);
+  };
+  return /* @__PURE__ */ jsxs("li", { ref: listItem.ref, css: [getItemStyle({
+    tokens,
+    disabled
+  })(theme), (_a = styles == null ? void 0 : styles.item) == null ? void 0 : _a.call(styles, tokens, theme), process.env.NODE_ENV === "production" ? "" : ";label:MenuItem;", process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"], ...getItemProps({
+    onClick: handleClick
+  }), tabIndex: isActive ? 0 : -1, "aria-disabled": disabled || void 0, "test-id": testId, children: [
+    /* @__PURE__ */ jsxs("div", { css: itemContentStyle(theme), children: [
+      icon && /* @__PURE__ */ jsx("span", { css: [itemIconStyle(theme), (_b = styles == null ? void 0 : styles.itemIcon) == null ? void 0 : _b.call(styles, tokens, theme), process.env.NODE_ENV === "production" ? "" : ";label:MenuItem;", process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"], children: icon }),
+      /* @__PURE__ */ jsx("span", { css: [itemTitleStyle(theme), (_c = styles == null ? void 0 : styles.itemTitle) == null ? void 0 : _c.call(styles, tokens, theme), process.env.NODE_ENV === "production" ? "" : ";label:MenuItem;", process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"], children: label })
+    ] }),
+    extra && /* @__PURE__ */ jsx("span", { css: [getItemExtraStyle({
+      tokens,
+      disabled
+    })(theme), (_d = styles == null ? void 0 : styles.itemExtra) == null ? void 0 : _d.call(styles, tokens, theme), process.env.NODE_ENV === "production" ? "" : ";label:MenuItem;", process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"], children: isString(extra) ? /* @__PURE__ */ jsx("span", { css: itemExtraTextStyle(theme), children: extra }) : extra })
+  ] });
+};
+export {
+  MenuItem
+};

package/dist/components/NewDropdown/components/MenuItem/MenuItem.styles.d.ts

@@ -0,0 +1,42 @@
+import { Interpolation } from '@emotion/react';
+import { Theme } from 'themes';
+import { NewDropdownTokens } from '../../NewDropdown.tokens';
+/**
+ * Стили строки `<li>` для одного пункта меню.
+ * Применяет токены padding, цвет текста, hover-фон и disabled-состояние.
+ */
+export declare const getItemStyle: ({ tokens, disabled }: {
+    tokens: NewDropdownTokens;
+    disabled: boolean;
+}) => (theme: Theme) => Interpolation;
+/**
+ * Стили внутреннего flex-контейнера для зоны [icon + title].
+ * Только внутренний layout без применения `styles?.itemContent`.
+ * gap берётся из theme.marginXS (4px) — разрыв между иконкой и label.
+ */
+export declare const itemContentStyle: (theme: Theme) => Interpolation;
+/**
+ * Стили левого слота иконки.
+ * Цвет наследуется от родительского `<li>`; размер берётся из theme.
+ */
+export declare const itemIconStyle: (theme: Theme) => Interpolation;
+/**
+ * Стили центральной зоны label/title.
+ * Типографика берётся из theme.
+ */
+export declare const itemTitleStyle: (theme: Theme) => Interpolation;
+/**
+ * Стили правого слота extra.
+ * fontSize: theme.iconM — чтобы SVG-иконки (width/height: 1em) рендерились 16×16,
+ * как и в левом icon-слоте. Текстовые шорткаты получают body3 (12px) через
+ * inner-обёртку (см. itemExtraTextStyle), без перетирания размера иконок.
+ */
+export declare const getItemExtraStyle: ({ tokens, disabled }: {
+    tokens: NewDropdownTokens;
+    disabled: boolean;
+}) => (theme: Theme) => Interpolation;
+/**
+ * Стили текстовой обёртки внутри extra-слота (для строковых шорткатов).
+ * Не применяется к JSX-extra — там типографикой управляет сам пользовательский узел.
+ */
+export declare const itemExtraTextStyle: (theme: Theme) => Interpolation;

package/dist/components/NewDropdown/components/MenuItem/MenuItem.styles.js

@@ -0,0 +1,67 @@
+const getItemStyle = ({
+  tokens,
+  disabled
+}) => (theme) => ({
+  display: "flex",
+  alignItems: "center",
+  paddingBlock: tokens.dropdownItemPaddingVertical,
+  paddingInline: tokens.dropdownItemPaddingHorizontal,
+  borderRadius: theme.borderRadiusM,
+  color: disabled ? tokens.dropdownItemTextDisabled : tokens.dropdownItemText,
+  cursor: disabled ? "not-allowed" : "pointer",
+  listStyle: "none",
+  userSelect: "none",
+  outline: "none",
+  ...!disabled && {
+    "&:hover, &:focus, &:focus-visible": {
+      background: tokens.dropdownItemBgHover
+    }
+  }
+});
+const itemContentStyle = (theme) => ({
+  display: "flex",
+  alignItems: "center",
+  gap: theme.marginXS,
+  flex: 1,
+  // flex-reset: позволяет дочернему flex-элементу сжиматься ниже content-size при overflow: hidden
+  minWidth: 0,
+  overflow: "hidden"
+});
+const itemIconStyle = (theme) => ({
+  display: "flex",
+  alignItems: "center",
+  justifyContent: "center",
+  flexShrink: 0,
+  fontSize: theme.iconM
+});
+const itemTitleStyle = (theme) => ({
+  ...theme.typography.body2,
+  flex: 1,
+  overflow: "hidden",
+  textOverflow: "ellipsis",
+  whiteSpace: "nowrap",
+  // flex-reset: позволяет дочернему flex-элементу сжиматься ниже content-size при overflow: hidden
+  minWidth: 0
+});
+const getItemExtraStyle = ({
+  tokens,
+  disabled
+}) => (theme) => ({
+  display: "flex",
+  alignItems: "center",
+  flexShrink: 0,
+  marginLeft: theme.marginM,
+  color: disabled ? tokens.dropdownItemTextDisabled : tokens.dropdownItemTextExtra,
+  fontSize: theme.iconM
+});
+const itemExtraTextStyle = (theme) => ({
+  ...theme.typography.body3
+});
+export {
+  getItemExtraStyle,
+  getItemStyle,
+  itemContentStyle,
+  itemExtraTextStyle,
+  itemIconStyle,
+  itemTitleStyle
+};

package/dist/components/NewDropdown/components/MenuItem/MenuItem.types.d.ts

@@ -0,0 +1,5 @@
+import { NewDropdownMenuItem } from '../../NewDropdown.types';
+export interface MenuItemProps {
+    item: NewDropdownMenuItem;
+    parentKeyPath: string;
+}

package/dist/components/NewDropdown/components/MenuItem/index.d.ts

@@ -0,0 +1 @@
+export { MenuItem } from './MenuItem';

package/dist/components/NewDropdown/components/SubMenuItem/SubMenuItem.d.ts

@@ -0,0 +1,3 @@
+import { FC } from 'react';
+import { SubMenuItemProps } from './SubMenuItem.types';
+export declare const SubMenuItem: FC<SubMenuItemProps>;

package/dist/components/NewDropdown/components/SubMenuItem/SubMenuItem.js

@@ -0,0 +1,170 @@
+import { jsxs, jsx } from "@emotion/react/jsx-runtime";
+import { useContext, useRef, useState, useEffect, useMemo } from "react";
+import { RightOutlined } from "@infomaximum/icons";
+import { useFloatingTree, useFloatingNodeId, useFloatingParentNodeId, useListItem, useFloating, offset, flip, shift, autoUpdate, useHover, safePolygon, useClick, useDismiss, useListNavigation, useInteractions, useMergeRefs, FloatingNode, FloatingList, FloatingPortal, FloatingFocusManager } from "@floating-ui/react";
+import { useEvent } from "../../../../hooks/useEvent/useEvent.js";
+import { useInputModeDetector } from "../../../../hooks/useInputModeDetector/useInputModeDetector.js";
+import { NewDropdownContext } from "../../contexts/NewDropdownContext.js";
+import { NewDropdownNavigationContext } from "../../contexts/NewDropdownNavigationContext.js";
+import { getItemStyle, itemContentStyle, itemIconStyle, itemTitleStyle } from "../MenuItem/MenuItem.styles.js";
+import { rootStyle } from "../../NewDropdown.styles.js";
+import { getSubMenuArrowStyle } from "./SubMenuItem.styles.js";
+import { Menu } from "../Menu/Menu.js";
+import { useNewDropdownTokens } from "../../hooks/useNewDropdownTokens/useNewDropdownTokens.js";
+const SubMenuItem = (props) => {
+  var _a, _b, _c, _d;
+  const {
+    item,
+    parentKeyPath
+  } = props;
+  const {
+    key,
+    label,
+    icon,
+    disabled = false,
+    children,
+    onClick,
+    "test-id": testId
+  } = item;
+  const {
+    styles,
+    triggerSubMenuAction,
+    subMenuOpenDelay,
+    subMenuCloseDelay,
+    onMenuClick
+  } = useContext(NewDropdownContext);
+  const {
+    activeIndex: parentActiveIndex,
+    getItemProps: parentGetItemProps
+  } = useContext(NewDropdownNavigationContext);
+  const {
+    theme,
+    tokens
+  } = useNewDropdownTokens();
+  const tree = useFloatingTree();
+  const nodeId = useFloatingNodeId();
+  const parentId = useFloatingParentNodeId();
+  const listItem = useListItem();
+  const submenuElementsRef = useRef([]);
+  const isActive = listItem.index === parentActiveIndex;
+  const [isOpen, setIsOpen] = useState(false);
+  const [submenuActiveIndex, setSubmenuActiveIndex] = useState(null);
+  const inputMode = useInputModeDetector();
+  const allowHover = inputMode === "pointer";
+  const {
+    refs,
+    floatingStyles,
+    context
+  } = useFloating({
+    nodeId,
+    open: isOpen,
+    onOpenChange: (open) => {
+      setIsOpen(open);
+    },
+    placement: "right-start",
+    middleware: [offset(0), flip(), shift()],
+    whileElementsMounted: autoUpdate
+  });
+  const hover = useHover(context, {
+    enabled: !disabled && triggerSubMenuAction === "hover" && allowHover,
+    handleClose: safePolygon({
+      blockPointerEvents: true
+    }),
+    delay: {
+      open: subMenuOpenDelay * 1e3,
+      close: subMenuCloseDelay * 1e3
+    }
+  });
+  const click = useClick(context, {
+    enabled: !disabled && triggerSubMenuAction === "click"
+  });
+  const dismiss = useDismiss(context, {
+    bubbles: true
+  });
+  const submenuListNavigation = useListNavigation(context, {
+    listRef: submenuElementsRef,
+    activeIndex: submenuActiveIndex,
+    onNavigate: setSubmenuActiveIndex,
+    nested: true
+  });
+  const {
+    getReferenceProps,
+    getFloatingProps,
+    getItemProps
+  } = useInteractions([hover, click, dismiss, submenuListNavigation]);
+  const stableGetItemProps = useEvent(getItemProps);
+  const triggerRef = useMergeRefs([refs.setReference, listItem.ref]);
+  useEffect(() => {
+    if (!tree) {
+      return;
+    }
+    const handleTreeClick = () => {
+      setIsOpen(false);
+    };
+    const handleMenuOpen = (event) => {
+      if (event.nodeId !== nodeId && event.parentId === parentId) {
+        setIsOpen(false);
+      }
+    };
+    tree.events.on("click", handleTreeClick);
+    tree.events.on("menuopen", handleMenuOpen);
+    return () => {
+      tree.events.off("click", handleTreeClick);
+      tree.events.off("menuopen", handleMenuOpen);
+    };
+  }, [tree, nodeId, parentId]);
+  useEffect(() => {
+    if (isOpen && tree) {
+      tree.events.emit("menuopen", {
+        parentId,
+        nodeId
+      });
+    }
+  }, [tree, isOpen, nodeId, parentId]);
+  useEffect(() => {
+    if (!isOpen) {
+      setSubmenuActiveIndex(null);
+    }
+  }, [isOpen]);
+  const handleTriggerClick = (event) => {
+    if (disabled) {
+      return;
+    }
+    onClick == null ? void 0 : onClick({
+      key,
+      domEvent: event
+    });
+  };
+  const submenuContextValue = useMemo(() => ({
+    styles,
+    triggerSubMenuAction,
+    subMenuOpenDelay,
+    subMenuCloseDelay,
+    onMenuClick
+  }), [styles, triggerSubMenuAction, subMenuOpenDelay, subMenuCloseDelay, onMenuClick]);
+  const submenuNavigationContextValue = useMemo(() => ({
+    activeIndex: submenuActiveIndex,
+    getItemProps: stableGetItemProps
+  }), [submenuActiveIndex, stableGetItemProps]);
+  return /* @__PURE__ */ jsxs(FloatingNode, { id: nodeId, children: [
+    /* @__PURE__ */ jsxs("li", { ref: triggerRef, css: [getItemStyle({
+      tokens,
+      disabled
+    })(theme), (_a = styles == null ? void 0 : styles.item) == null ? void 0 : _a.call(styles, tokens, theme), process.env.NODE_ENV === "production" ? "" : ";label:SubMenuItem;", process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/builds/frontend/libs/ui-kit/src/components/NewDropdown/components/SubMenuItem/SubMenuItem.tsx"],"names":[],"mappings":"AA+KQ","file":"/builds/frontend/libs/ui-kit/src/components/NewDropdown/components/SubMenuItem/SubMenuItem.tsx","sourcesContent":["import { useContext, useEffect, useMemo, useRef, useState, type FC, type MouseEvent } from \"react\";\nimport { RightOutlined } from \"@infomaximum/icons\";\nimport {\n  autoUpdate,\n  flip,\n  FloatingFocusManager,\n  FloatingList,\n  FloatingNode,\n  FloatingPortal,\n  offset,\n  safePolygon,\n  shift,\n  useClick,\n  useDismiss,\n  useFloating,\n  useFloatingNodeId,\n  useFloatingParentNodeId,\n  useFloatingTree,\n  useHover,\n  useInteractions,\n  useListItem,\n  useListNavigation,\n  useMergeRefs,\n} from \"@floating-ui/react\";\nimport { useEvent } from \"hooks/useEvent\";\nimport { useInputModeDetector } from \"hooks/useInputModeDetector\";\nimport { useNewDropdownTokens } from \"../../hooks/useNewDropdownTokens\";\nimport {\n  NewDropdownContext,\n  type NewDropdownContextValue,\n} from \"../../contexts/NewDropdownContext\";\nimport {\n  NewDropdownNavigationContext,\n  type NewDropdownNavigationContextValue,\n} from \"../../contexts/NewDropdownNavigationContext\";\nimport {\n  getItemStyle,\n  itemContentStyle,\n  itemIconStyle,\n  itemTitleStyle,\n} from \"../MenuItem/MenuItem.styles\";\nimport { rootStyle } from \"../../NewDropdown.styles\";\nimport { getSubMenuArrowStyle } from \"./SubMenuItem.styles\";\nimport { Menu } from \"../Menu/Menu\";\nimport type { SubMenuItemProps } from \"./SubMenuItem.types\";\n\nexport const SubMenuItem: FC<SubMenuItemProps> = (props) => {\n  const { item, parentKeyPath } = props;\n  const { key, label, icon, disabled = false, children, onClick, \"test-id\": testId } = item;\n  const { styles, triggerSubMenuAction, subMenuOpenDelay, subMenuCloseDelay, onMenuClick } =\n    useContext(NewDropdownContext);\n  const { activeIndex: parentActiveIndex, getItemProps: parentGetItemProps } = useContext(\n    NewDropdownNavigationContext\n  );\n  const { theme, tokens } = useNewDropdownTokens();\n  const tree = useFloatingTree();\n  const nodeId = useFloatingNodeId();\n  const parentId = useFloatingParentNodeId();\n  const listItem = useListItem();\n  const submenuElementsRef = useRef<Array<HTMLElement | null>>([]);\n  const isActive = listItem.index === parentActiveIndex;\n\n  const [isOpen, setIsOpen] = useState(false);\n  const [submenuActiveIndex, setSubmenuActiveIndex] = useState<number | null>(null);\n  const inputMode = useInputModeDetector();\n  const allowHover = inputMode === \"pointer\";\n\n  const { refs, floatingStyles, context } = useFloating({\n    nodeId,\n    open: isOpen,\n    onOpenChange: (open) => {\n      setIsOpen(open);\n    },\n    placement: \"right-start\",\n    middleware: [offset(0), flip(), shift()],\n    whileElementsMounted: autoUpdate,\n  });\n\n  const hover = useHover(context, {\n    enabled: !disabled && triggerSubMenuAction === \"hover\" && allowHover,\n    handleClose: safePolygon({ blockPointerEvents: true }),\n    delay: {\n      open: subMenuOpenDelay * 1000,\n      close: subMenuCloseDelay * 1000,\n    },\n  });\n\n  const click = useClick(context, {\n    enabled: !disabled && triggerSubMenuAction === \"click\",\n  });\n\n  const dismiss = useDismiss(context, { bubbles: true });\n\n  const submenuListNavigation = useListNavigation(context, {\n    listRef: submenuElementsRef,\n    activeIndex: submenuActiveIndex,\n    onNavigate: setSubmenuActiveIndex,\n    nested: true,\n  });\n\n  const { getReferenceProps, getFloatingProps, getItemProps } = useInteractions([\n    hover,\n    click,\n    dismiss,\n    submenuListNavigation,\n  ]);\n  // см. NewDropdown.tsx: getItemProps нестабилен между рендерами, стабилизируем.\n  const stableGetItemProps = useEvent(getItemProps);\n\n  const triggerRef = useMergeRefs([refs.setReference, listItem.ref]);\n\n  useEffect(() => {\n    if (!tree) {\n      return;\n    }\n\n    const handleTreeClick = () => {\n      setIsOpen(false);\n    };\n\n    const handleMenuOpen = (event: { nodeId: string; parentId: string }) => {\n      if (event.nodeId !== nodeId && event.parentId === parentId) {\n        setIsOpen(false);\n      }\n    };\n\n    tree.events.on(\"click\", handleTreeClick);\n    tree.events.on(\"menuopen\", handleMenuOpen);\n\n    return () => {\n      tree.events.off(\"click\", handleTreeClick);\n      tree.events.off(\"menuopen\", handleMenuOpen);\n    };\n  }, [tree, nodeId, parentId]);\n\n  useEffect(() => {\n    if (isOpen && tree) {\n      tree.events.emit(\"menuopen\", { parentId, nodeId });\n    }\n  }, [tree, isOpen, nodeId, parentId]);\n\n  useEffect(() => {\n    if (!isOpen) {\n      setSubmenuActiveIndex(null);\n    }\n  }, [isOpen]);\n\n  const handleTriggerClick = (event: MouseEvent<HTMLLIElement>) => {\n    if (disabled) {\n      return;\n    }\n\n    onClick?.({ key, domEvent: event });\n  };\n\n  const submenuContextValue = useMemo<NewDropdownContextValue>(\n    () => ({\n      styles,\n      triggerSubMenuAction,\n      subMenuOpenDelay,\n      subMenuCloseDelay,\n      onMenuClick,\n    }),\n    [styles, triggerSubMenuAction, subMenuOpenDelay, subMenuCloseDelay, onMenuClick]\n  );\n\n  const submenuNavigationContextValue = useMemo<NewDropdownNavigationContextValue>(\n    () => ({ activeIndex: submenuActiveIndex, getItemProps: stableGetItemProps }),\n    [submenuActiveIndex, stableGetItemProps]\n  );\n\n  return (\n    <FloatingNode id={nodeId}>\n      <li\n        ref={triggerRef}\n        css={[getItemStyle({ tokens, disabled })(theme), styles?.item?.(tokens, theme)]}\n        {...getReferenceProps(parentGetItemProps({ onClick: handleTriggerClick }))}\n        tabIndex={isActive ? 0 : -1}\n        aria-disabled={disabled || undefined}\n        test-id={testId}\n      >\n        <div css={itemContentStyle(theme)}>\n          {icon && (\n            <span css={[itemIconStyle(theme), styles?.itemIcon?.(tokens, theme)]}>{icon}</span>\n          )}\n          <span css={[itemTitleStyle(theme), styles?.itemTitle?.(tokens, theme)]}>{label}</span>\n        </div>\n        <span css={getSubMenuArrowStyle({ tokens, disabled })(theme)}>\n          <RightOutlined />\n        </span>\n      </li>\n      <FloatingList elementsRef={submenuElementsRef}>\n        {isOpen && (\n          <FloatingPortal>\n            <FloatingFocusManager\n              context={context}\n              modal={false}\n              initialFocus={-1}\n              returnFocus={false}\n            >\n              <div\n                ref={refs.setFloating}\n                style={floatingStyles}\n                css={[rootStyle(theme), styles?.root?.(tokens, theme)]}\n                {...getFloatingProps()}\n              >\n                <NewDropdownContext.Provider value={submenuContextValue}>\n                  <NewDropdownNavigationContext.Provider value={submenuNavigationContextValue}>\n                    <Menu\n                      items={children}\n                      parentKeyPath={parentKeyPath ? `${parentKeyPath}.${key}` : key}\n                    />\n                  </NewDropdownNavigationContext.Provider>\n                </NewDropdownContext.Provider>\n              </div>\n            </FloatingFocusManager>\n          </FloatingPortal>\n        )}\n      </FloatingList>\n    </FloatingNode>\n  );\n};\n"]} */"], ...getReferenceProps(parentGetItemProps({
+      onClick: handleTriggerClick
+    })), tabIndex: isActive ? 0 : -1, "aria-disabled": disabled || void 0, "test-id": testId, children: [
+      /* @__PURE__ */ jsxs("div", { css: itemContentStyle(theme), children: [
+        icon && /* @__PURE__ */ jsx("span", { css: [itemIconStyle(theme), (_b = styles == null ? void 0 : styles.itemIcon) == null ? void 0 : _b.call(styles, tokens, theme), process.env.NODE_ENV === "production" ? "" : ";label:SubMenuItem;", process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/builds/frontend/libs/ui-kit/src/components/NewDropdown/components/SubMenuItem/SubMenuItem.tsx"],"names":[],"mappings":"AAuLkB","file":"/builds/frontend/libs/ui-kit/src/components/NewDropdown/components/SubMenuItem/SubMenuItem.tsx","sourcesContent":["import { useContext, useEffect, useMemo, useRef, useState, type FC, type MouseEvent } from \"react\";\nimport { RightOutlined } from \"@infomaximum/icons\";\nimport {\n  autoUpdate,\n  flip,\n  FloatingFocusManager,\n  FloatingList,\n  FloatingNode,\n  FloatingPortal,\n  offset,\n  safePolygon,\n  shift,\n  useClick,\n  useDismiss,\n  useFloating,\n  useFloatingNodeId,\n  useFloatingParentNodeId,\n  useFloatingTree,\n  useHover,\n  useInteractions,\n  useListItem,\n  useListNavigation,\n  useMergeRefs,\n} from \"@floating-ui/react\";\nimport { useEvent } from \"hooks/useEvent\";\nimport { useInputModeDetector } from \"hooks/useInputModeDetector\";\nimport { useNewDropdownTokens } from \"../../hooks/useNewDropdownTokens\";\nimport {\n  NewDropdownContext,\n  type NewDropdownContextValue,\n} from \"../../contexts/NewDropdownContext\";\nimport {\n  NewDropdownNavigationContext,\n  type NewDropdownNavigationContextValue,\n} from \"../../contexts/NewDropdownNavigationContext\";\nimport {\n  getItemStyle,\n  itemContentStyle,\n  itemIconStyle,\n  itemTitleStyle,\n} from \"../MenuItem/MenuItem.styles\";\nimport { rootStyle } from \"../../NewDropdown.styles\";\nimport { getSubMenuArrowStyle } from \"./SubMenuItem.styles\";\nimport { Menu } from \"../Menu/Menu\";\nimport type { SubMenuItemProps } from \"./SubMenuItem.types\";\n\nexport const SubMenuItem: FC<SubMenuItemProps> = (props) => {\n  const { item, parentKeyPath } = props;\n  const { key, label, icon, disabled = false, children, onClick, \"test-id\": testId } = item;\n  const { styles, triggerSubMenuAction, subMenuOpenDelay, subMenuCloseDelay, onMenuClick } =\n    useContext(NewDropdownContext);\n  const { activeIndex: parentActiveIndex, getItemProps: parentGetItemProps } = useContext(\n    NewDropdownNavigationContext\n  );\n  const { theme, tokens } = useNewDropdownTokens();\n  const tree = useFloatingTree();\n  const nodeId = useFloatingNodeId();\n  const parentId = useFloatingParentNodeId();\n  const listItem = useListItem();\n  const submenuElementsRef = useRef<Array<HTMLElement | null>>([]);\n  const isActive = listItem.index === parentActiveIndex;\n\n  const [isOpen, setIsOpen] = useState(false);\n  const [submenuActiveIndex, setSubmenuActiveIndex] = useState<number | null>(null);\n  const inputMode = useInputModeDetector();\n  const allowHover = inputMode === \"pointer\";\n\n  const { refs, floatingStyles, context } = useFloating({\n    nodeId,\n    open: isOpen,\n    onOpenChange: (open) => {\n      setIsOpen(open);\n    },\n    placement: \"right-start\",\n    middleware: [offset(0), flip(), shift()],\n    whileElementsMounted: autoUpdate,\n  });\n\n  const hover = useHover(context, {\n    enabled: !disabled && triggerSubMenuAction === \"hover\" && allowHover,\n    handleClose: safePolygon({ blockPointerEvents: true }),\n    delay: {\n      open: subMenuOpenDelay * 1000,\n      close: subMenuCloseDelay * 1000,\n    },\n  });\n\n  const click = useClick(context, {\n    enabled: !disabled && triggerSubMenuAction === \"click\",\n  });\n\n  const dismiss = useDismiss(context, { bubbles: true });\n\n  const submenuListNavigation = useListNavigation(context, {\n    listRef: submenuElementsRef,\n    activeIndex: submenuActiveIndex,\n    onNavigate: setSubmenuActiveIndex,\n    nested: true,\n  });\n\n  const { getReferenceProps, getFloatingProps, getItemProps } = useInteractions([\n    hover,\n    click,\n    dismiss,\n    submenuListNavigation,\n  ]);\n  // см. NewDropdown.tsx: getItemProps нестабилен между рендерами, стабилизируем.\n  const stableGetItemProps = useEvent(getItemProps);\n\n  const triggerRef = useMergeRefs([refs.setReference, listItem.ref]);\n\n  useEffect(() => {\n    if (!tree) {\n      return;\n    }\n\n    const handleTreeClick = () => {\n      setIsOpen(false);\n    };\n\n    const handleMenuOpen = (event: { nodeId: string; parentId: string }) => {\n      if (event.nodeId !== nodeId && event.parentId === parentId) {\n        setIsOpen(false);\n      }\n    };\n\n    tree.events.on(\"click\", handleTreeClick);\n    tree.events.on(\"menuopen\", handleMenuOpen);\n\n    return () => {\n      tree.events.off(\"click\", handleTreeClick);\n      tree.events.off(\"menuopen\", handleMenuOpen);\n    };\n  }, [tree, nodeId, parentId]);\n\n  useEffect(() => {\n    if (isOpen && tree) {\n      tree.events.emit(\"menuopen\", { parentId, nodeId });\n    }\n  }, [tree, isOpen, nodeId, parentId]);\n\n  useEffect(() => {\n    if (!isOpen) {\n      setSubmenuActiveIndex(null);\n    }\n  }, [isOpen]);\n\n  const handleTriggerClick = (event: MouseEvent<HTMLLIElement>) => {\n    if (disabled) {\n      return;\n    }\n\n    onClick?.({ key, domEvent: event });\n  };\n\n  const submenuContextValue = useMemo<NewDropdownContextValue>(\n    () => ({\n      styles,\n      triggerSubMenuAction,\n      subMenuOpenDelay,\n      subMenuCloseDelay,\n      onMenuClick,\n    }),\n    [styles, triggerSubMenuAction, subMenuOpenDelay, subMenuCloseDelay, onMenuClick]\n  );\n\n  const submenuNavigationContextValue = useMemo<NewDropdownNavigationContextValue>(\n    () => ({ activeIndex: submenuActiveIndex, getItemProps: stableGetItemProps }),\n    [submenuActiveIndex, stableGetItemProps]\n  );\n\n  return (\n    <FloatingNode id={nodeId}>\n      <li\n        ref={triggerRef}\n        css={[getItemStyle({ tokens, disabled })(theme), styles?.item?.(tokens, theme)]}\n        {...getReferenceProps(parentGetItemProps({ onClick: handleTriggerClick }))}\n        tabIndex={isActive ? 0 : -1}\n        aria-disabled={disabled || undefined}\n        test-id={testId}\n      >\n        <div css={itemContentStyle(theme)}>\n          {icon && (\n            <span css={[itemIconStyle(theme), styles?.itemIcon?.(tokens, theme)]}>{icon}</span>\n          )}\n          <span css={[itemTitleStyle(theme), styles?.itemTitle?.(tokens, theme)]}>{label}</span>\n        </div>\n        <span css={getSubMenuArrowStyle({ tokens, disabled })(theme)}>\n          <RightOutlined />\n        </span>\n      </li>\n      <FloatingList elementsRef={submenuElementsRef}>\n        {isOpen && (\n          <FloatingPortal>\n            <FloatingFocusManager\n              context={context}\n              modal={false}\n              initialFocus={-1}\n              returnFocus={false}\n            >\n              <div\n                ref={refs.setFloating}\n                style={floatingStyles}\n                css={[rootStyle(theme), styles?.root?.(tokens, theme)]}\n                {...getFloatingProps()}\n              >\n                <NewDropdownContext.Provider value={submenuContextValue}>\n                  <NewDropdownNavigationContext.Provider value={submenuNavigationContextValue}>\n                    <Menu\n                      items={children}\n                      parentKeyPath={parentKeyPath ? `${parentKeyPath}.${key}` : key}\n                    />\n                  </NewDropdownNavigationContext.Provider>\n                </NewDropdownContext.Provider>\n              </div>\n            </FloatingFocusManager>\n          </FloatingPortal>\n        )}\n      </FloatingList>\n    </FloatingNode>\n  );\n};\n"]} */"], children: icon }),
+        /* @__PURE__ */ jsx("span", { css: [itemTitleStyle(theme), (_c = styles == null ? void 0 : styles.itemTitle) == null ? void 0 : _c.call(styles, tokens, theme), process.env.NODE_ENV === "production" ? "" : ";label:SubMenuItem;", process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/builds/frontend/libs/ui-kit/src/components/NewDropdown/components/SubMenuItem/SubMenuItem.tsx"],"names":[],"mappings":"AAyLgB","file":"/builds/frontend/libs/ui-kit/src/components/NewDropdown/components/SubMenuItem/SubMenuItem.tsx","sourcesContent":["import { useContext, useEffect, useMemo, useRef, useState, type FC, type MouseEvent } from \"react\";\nimport { RightOutlined } from \"@infomaximum/icons\";\nimport {\n  autoUpdate,\n  flip,\n  FloatingFocusManager,\n  FloatingList,\n  FloatingNode,\n  FloatingPortal,\n  offset,\n  safePolygon,\n  shift,\n  useClick,\n  useDismiss,\n  useFloating,\n  useFloatingNodeId,\n  useFloatingParentNodeId,\n  useFloatingTree,\n  useHover,\n  useInteractions,\n  useListItem,\n  useListNavigation,\n  useMergeRefs,\n} from \"@floating-ui/react\";\nimport { useEvent } from \"hooks/useEvent\";\nimport { useInputModeDetector } from \"hooks/useInputModeDetector\";\nimport { useNewDropdownTokens } from \"../../hooks/useNewDropdownTokens\";\nimport {\n  NewDropdownContext,\n  type NewDropdownContextValue,\n} from \"../../contexts/NewDropdownContext\";\nimport {\n  NewDropdownNavigationContext,\n  type NewDropdownNavigationContextValue,\n} from \"../../contexts/NewDropdownNavigationContext\";\nimport {\n  getItemStyle,\n  itemContentStyle,\n  itemIconStyle,\n  itemTitleStyle,\n} from \"../MenuItem/MenuItem.styles\";\nimport { rootStyle } from \"../../NewDropdown.styles\";\nimport { getSubMenuArrowStyle } from \"./SubMenuItem.styles\";\nimport { Menu } from \"../Menu/Menu\";\nimport type { SubMenuItemProps } from \"./SubMenuItem.types\";\n\nexport const SubMenuItem: FC<SubMenuItemProps> = (props) => {\n  const { item, parentKeyPath } = props;\n  const { key, label, icon, disabled = false, children, onClick, \"test-id\": testId } = item;\n  const { styles, triggerSubMenuAction, subMenuOpenDelay, subMenuCloseDelay, onMenuClick } =\n    useContext(NewDropdownContext);\n  const { activeIndex: parentActiveIndex, getItemProps: parentGetItemProps } = useContext(\n    NewDropdownNavigationContext\n  );\n  const { theme, tokens } = useNewDropdownTokens();\n  const tree = useFloatingTree();\n  const nodeId = useFloatingNodeId();\n  const parentId = useFloatingParentNodeId();\n  const listItem = useListItem();\n  const submenuElementsRef = useRef<Array<HTMLElement | null>>([]);\n  const isActive = listItem.index === parentActiveIndex;\n\n  const [isOpen, setIsOpen] = useState(false);\n  const [submenuActiveIndex, setSubmenuActiveIndex] = useState<number | null>(null);\n  const inputMode = useInputModeDetector();\n  const allowHover = inputMode === \"pointer\";\n\n  const { refs, floatingStyles, context } = useFloating({\n    nodeId,\n    open: isOpen,\n    onOpenChange: (open) => {\n      setIsOpen(open);\n    },\n    placement: \"right-start\",\n    middleware: [offset(0), flip(), shift()],\n    whileElementsMounted: autoUpdate,\n  });\n\n  const hover = useHover(context, {\n    enabled: !disabled && triggerSubMenuAction === \"hover\" && allowHover,\n    handleClose: safePolygon({ blockPointerEvents: true }),\n    delay: {\n      open: subMenuOpenDelay * 1000,\n      close: subMenuCloseDelay * 1000,\n    },\n  });\n\n  const click = useClick(context, {\n    enabled: !disabled && triggerSubMenuAction === \"click\",\n  });\n\n  const dismiss = useDismiss(context, { bubbles: true });\n\n  const submenuListNavigation = useListNavigation(context, {\n    listRef: submenuElementsRef,\n    activeIndex: submenuActiveIndex,\n    onNavigate: setSubmenuActiveIndex,\n    nested: true,\n  });\n\n  const { getReferenceProps, getFloatingProps, getItemProps } = useInteractions([\n    hover,\n    click,\n    dismiss,\n    submenuListNavigation,\n  ]);\n  // см. NewDropdown.tsx: getItemProps нестабилен между рендерами, стабилизируем.\n  const stableGetItemProps = useEvent(getItemProps);\n\n  const triggerRef = useMergeRefs([refs.setReference, listItem.ref]);\n\n  useEffect(() => {\n    if (!tree) {\n      return;\n    }\n\n    const handleTreeClick = () => {\n      setIsOpen(false);\n    };\n\n    const handleMenuOpen = (event: { nodeId: string; parentId: string }) => {\n      if (event.nodeId !== nodeId && event.parentId === parentId) {\n        setIsOpen(false);\n      }\n    };\n\n    tree.events.on(\"click\", handleTreeClick);\n    tree.events.on(\"menuopen\", handleMenuOpen);\n\n    return () => {\n      tree.events.off(\"click\", handleTreeClick);\n      tree.events.off(\"menuopen\", handleMenuOpen);\n    };\n  }, [tree, nodeId, parentId]);\n\n  useEffect(() => {\n    if (isOpen && tree) {\n      tree.events.emit(\"menuopen\", { parentId, nodeId });\n    }\n  }, [tree, isOpen, nodeId, parentId]);\n\n  useEffect(() => {\n    if (!isOpen) {\n      setSubmenuActiveIndex(null);\n    }\n  }, [isOpen]);\n\n  const handleTriggerClick = (event: MouseEvent<HTMLLIElement>) => {\n    if (disabled) {\n      return;\n    }\n\n    onClick?.({ key, domEvent: event });\n  };\n\n  const submenuContextValue = useMemo<NewDropdownContextValue>(\n    () => ({\n      styles,\n      triggerSubMenuAction,\n      subMenuOpenDelay,\n      subMenuCloseDelay,\n      onMenuClick,\n    }),\n    [styles, triggerSubMenuAction, subMenuOpenDelay, subMenuCloseDelay, onMenuClick]\n  );\n\n  const submenuNavigationContextValue = useMemo<NewDropdownNavigationContextValue>(\n    () => ({ activeIndex: submenuActiveIndex, getItemProps: stableGetItemProps }),\n    [submenuActiveIndex, stableGetItemProps]\n  );\n\n  return (\n    <FloatingNode id={nodeId}>\n      <li\n        ref={triggerRef}\n        css={[getItemStyle({ tokens, disabled })(theme), styles?.item?.(tokens, theme)]}\n        {...getReferenceProps(parentGetItemProps({ onClick: handleTriggerClick }))}\n        tabIndex={isActive ? 0 : -1}\n        aria-disabled={disabled || undefined}\n        test-id={testId}\n      >\n        <div css={itemContentStyle(theme)}>\n          {icon && (\n            <span css={[itemIconStyle(theme), styles?.itemIcon?.(tokens, theme)]}>{icon}</span>\n          )}\n          <span css={[itemTitleStyle(theme), styles?.itemTitle?.(tokens, theme)]}>{label}</span>\n        </div>\n        <span css={getSubMenuArrowStyle({ tokens, disabled })(theme)}>\n          <RightOutlined />\n        </span>\n      </li>\n      <FloatingList elementsRef={submenuElementsRef}>\n        {isOpen && (\n          <FloatingPortal>\n            <FloatingFocusManager\n              context={context}\n              modal={false}\n              initialFocus={-1}\n              returnFocus={false}\n            >\n              <div\n                ref={refs.setFloating}\n                style={floatingStyles}\n                css={[rootStyle(theme), styles?.root?.(tokens, theme)]}\n                {...getFloatingProps()}\n              >\n                <NewDropdownContext.Provider value={submenuContextValue}>\n                  <NewDropdownNavigationContext.Provider value={submenuNavigationContextValue}>\n                    <Menu\n                      items={children}\n                      parentKeyPath={parentKeyPath ? `${parentKeyPath}.${key}` : key}\n                    />\n                  </NewDropdownNavigationContext.Provider>\n                </NewDropdownContext.Provider>\n              </div>\n            </FloatingFocusManager>\n          </FloatingPortal>\n        )}\n      </FloatingList>\n    </FloatingNode>\n  );\n};\n"]} */"], children: label })
+      ] }),
+      /* @__PURE__ */ jsx("span", { css: getSubMenuArrowStyle({
+        tokens,
+        disabled
+      })(theme), children: /* @__PURE__ */ jsx(RightOutlined, {}) })
+    ] }),
+    /* @__PURE__ */ jsx(FloatingList, { elementsRef: submenuElementsRef, children: isOpen && /* @__PURE__ */ jsx(FloatingPortal, { children: /* @__PURE__ */ jsx(FloatingFocusManager, { context, modal: false, initialFocus: -1, returnFocus: false, children: /* @__PURE__ */ jsx("div", { ref: refs.setFloating, style: floatingStyles, css: [rootStyle(theme), (_d = styles == null ? void 0 : styles.root) == null ? void 0 : _d.call(styles, tokens, theme), process.env.NODE_ENV === "production" ? "" : ";label:SubMenuItem;", process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/builds/frontend/libs/ui-kit/src/components/NewDropdown/components/SubMenuItem/SubMenuItem.tsx"],"names":[],"mappings":"AA2MgB","file":"/builds/frontend/libs/ui-kit/src/components/NewDropdown/components/SubMenuItem/SubMenuItem.tsx","sourcesContent":["import { useContext, useEffect, useMemo, useRef, useState, type FC, type MouseEvent } from \"react\";\nimport { RightOutlined } from \"@infomaximum/icons\";\nimport {\n  autoUpdate,\n  flip,\n  FloatingFocusManager,\n  FloatingList,\n  FloatingNode,\n  FloatingPortal,\n  offset,\n  safePolygon,\n  shift,\n  useClick,\n  useDismiss,\n  useFloating,\n  useFloatingNodeId,\n  useFloatingParentNodeId,\n  useFloatingTree,\n  useHover,\n  useInteractions,\n  useListItem,\n  useListNavigation,\n  useMergeRefs,\n} from \"@floating-ui/react\";\nimport { useEvent } from \"hooks/useEvent\";\nimport { useInputModeDetector } from \"hooks/useInputModeDetector\";\nimport { useNewDropdownTokens } from \"../../hooks/useNewDropdownTokens\";\nimport {\n  NewDropdownContext,\n  type NewDropdownContextValue,\n} from \"../../contexts/NewDropdownContext\";\nimport {\n  NewDropdownNavigationContext,\n  type NewDropdownNavigationContextValue,\n} from \"../../contexts/NewDropdownNavigationContext\";\nimport {\n  getItemStyle,\n  itemContentStyle,\n  itemIconStyle,\n  itemTitleStyle,\n} from \"../MenuItem/MenuItem.styles\";\nimport { rootStyle } from \"../../NewDropdown.styles\";\nimport { getSubMenuArrowStyle } from \"./SubMenuItem.styles\";\nimport { Menu } from \"../Menu/Menu\";\nimport type { SubMenuItemProps } from \"./SubMenuItem.types\";\n\nexport const SubMenuItem: FC<SubMenuItemProps> = (props) => {\n  const { item, parentKeyPath } = props;\n  const { key, label, icon, disabled = false, children, onClick, \"test-id\": testId } = item;\n  const { styles, triggerSubMenuAction, subMenuOpenDelay, subMenuCloseDelay, onMenuClick } =\n    useContext(NewDropdownContext);\n  const { activeIndex: parentActiveIndex, getItemProps: parentGetItemProps } = useContext(\n    NewDropdownNavigationContext\n  );\n  const { theme, tokens } = useNewDropdownTokens();\n  const tree = useFloatingTree();\n  const nodeId = useFloatingNodeId();\n  const parentId = useFloatingParentNodeId();\n  const listItem = useListItem();\n  const submenuElementsRef = useRef<Array<HTMLElement | null>>([]);\n  const isActive = listItem.index === parentActiveIndex;\n\n  const [isOpen, setIsOpen] = useState(false);\n  const [submenuActiveIndex, setSubmenuActiveIndex] = useState<number | null>(null);\n  const inputMode = useInputModeDetector();\n  const allowHover = inputMode === \"pointer\";\n\n  const { refs, floatingStyles, context } = useFloating({\n    nodeId,\n    open: isOpen,\n    onOpenChange: (open) => {\n      setIsOpen(open);\n    },\n    placement: \"right-start\",\n    middleware: [offset(0), flip(), shift()],\n    whileElementsMounted: autoUpdate,\n  });\n\n  const hover = useHover(context, {\n    enabled: !disabled && triggerSubMenuAction === \"hover\" && allowHover,\n    handleClose: safePolygon({ blockPointerEvents: true }),\n    delay: {\n      open: subMenuOpenDelay * 1000,\n      close: subMenuCloseDelay * 1000,\n    },\n  });\n\n  const click = useClick(context, {\n    enabled: !disabled && triggerSubMenuAction === \"click\",\n  });\n\n  const dismiss = useDismiss(context, { bubbles: true });\n\n  const submenuListNavigation = useListNavigation(context, {\n    listRef: submenuElementsRef,\n    activeIndex: submenuActiveIndex,\n    onNavigate: setSubmenuActiveIndex,\n    nested: true,\n  });\n\n  const { getReferenceProps, getFloatingProps, getItemProps } = useInteractions([\n    hover,\n    click,\n    dismiss,\n    submenuListNavigation,\n  ]);\n  // см. NewDropdown.tsx: getItemProps нестабилен между рендерами, стабилизируем.\n  const stableGetItemProps = useEvent(getItemProps);\n\n  const triggerRef = useMergeRefs([refs.setReference, listItem.ref]);\n\n  useEffect(() => {\n    if (!tree) {\n      return;\n    }\n\n    const handleTreeClick = () => {\n      setIsOpen(false);\n    };\n\n    const handleMenuOpen = (event: { nodeId: string; parentId: string }) => {\n      if (event.nodeId !== nodeId && event.parentId === parentId) {\n        setIsOpen(false);\n      }\n    };\n\n    tree.events.on(\"click\", handleTreeClick);\n    tree.events.on(\"menuopen\", handleMenuOpen);\n\n    return () => {\n      tree.events.off(\"click\", handleTreeClick);\n      tree.events.off(\"menuopen\", handleMenuOpen);\n    };\n  }, [tree, nodeId, parentId]);\n\n  useEffect(() => {\n    if (isOpen && tree) {\n      tree.events.emit(\"menuopen\", { parentId, nodeId });\n    }\n  }, [tree, isOpen, nodeId, parentId]);\n\n  useEffect(() => {\n    if (!isOpen) {\n      setSubmenuActiveIndex(null);\n    }\n  }, [isOpen]);\n\n  const handleTriggerClick = (event: MouseEvent<HTMLLIElement>) => {\n    if (disabled) {\n      return;\n    }\n\n    onClick?.({ key, domEvent: event });\n  };\n\n  const submenuContextValue = useMemo<NewDropdownContextValue>(\n    () => ({\n      styles,\n      triggerSubMenuAction,\n      subMenuOpenDelay,\n      subMenuCloseDelay,\n      onMenuClick,\n    }),\n    [styles, triggerSubMenuAction, subMenuOpenDelay, subMenuCloseDelay, onMenuClick]\n  );\n\n  const submenuNavigationContextValue = useMemo<NewDropdownNavigationContextValue>(\n    () => ({ activeIndex: submenuActiveIndex, getItemProps: stableGetItemProps }),\n    [submenuActiveIndex, stableGetItemProps]\n  );\n\n  return (\n    <FloatingNode id={nodeId}>\n      <li\n        ref={triggerRef}\n        css={[getItemStyle({ tokens, disabled })(theme), styles?.item?.(tokens, theme)]}\n        {...getReferenceProps(parentGetItemProps({ onClick: handleTriggerClick }))}\n        tabIndex={isActive ? 0 : -1}\n        aria-disabled={disabled || undefined}\n        test-id={testId}\n      >\n        <div css={itemContentStyle(theme)}>\n          {icon && (\n            <span css={[itemIconStyle(theme), styles?.itemIcon?.(tokens, theme)]}>{icon}</span>\n          )}\n          <span css={[itemTitleStyle(theme), styles?.itemTitle?.(tokens, theme)]}>{label}</span>\n        </div>\n        <span css={getSubMenuArrowStyle({ tokens, disabled })(theme)}>\n          <RightOutlined />\n        </span>\n      </li>\n      <FloatingList elementsRef={submenuElementsRef}>\n        {isOpen && (\n          <FloatingPortal>\n            <FloatingFocusManager\n              context={context}\n              modal={false}\n              initialFocus={-1}\n              returnFocus={false}\n            >\n              <div\n                ref={refs.setFloating}\n                style={floatingStyles}\n                css={[rootStyle(theme), styles?.root?.(tokens, theme)]}\n                {...getFloatingProps()}\n              >\n                <NewDropdownContext.Provider value={submenuContextValue}>\n                  <NewDropdownNavigationContext.Provider value={submenuNavigationContextValue}>\n                    <Menu\n                      items={children}\n                      parentKeyPath={parentKeyPath ? `${parentKeyPath}.${key}` : key}\n                    />\n                  </NewDropdownNavigationContext.Provider>\n                </NewDropdownContext.Provider>\n              </div>\n            </FloatingFocusManager>\n          </FloatingPortal>\n        )}\n      </FloatingList>\n    </FloatingNode>\n  );\n};\n"]} */"], ...getFloatingProps(), children: /* @__PURE__ */ jsx(NewDropdownContext.Provider, { value: submenuContextValue, children: /* @__PURE__ */ jsx(NewDropdownNavigationContext.Provider, { value: submenuNavigationContextValue, children: /* @__PURE__ */ jsx(Menu, { items: children, parentKeyPath: parentKeyPath ? `${parentKeyPath}.${key}` : key }) }) }) }) }) }) })
+  ] });
+};
+export {
+  SubMenuItem
+};

package/dist/components/NewDropdown/components/SubMenuItem/SubMenuItem.styles.d.ts

@@ -0,0 +1,13 @@
+import { Interpolation } from '@emotion/react';
+import { Theme } from 'themes';
+import { NewDropdownTokens } from '../../NewDropdown.tokens';
+/**
+ * Стиль стрелки-индикатора подменю (справа от label).
+ * Размер: 12×12 (icons/right) — явный overlay-маркер в Figma, меньше стандартного iconM.
+ * Цвет: dropdownItemTextExtra (textSecondary) для активного состояния,
+ *        dropdownItemTextDisabled для disabled.
+ */
+export declare const getSubMenuArrowStyle: ({ tokens, disabled }: {
+    tokens: NewDropdownTokens;
+    disabled: boolean;
+}) => (theme: Theme) => Interpolation;

package/dist/components/NewDropdown/components/SubMenuItem/SubMenuItem.styles.js

@@ -0,0 +1,15 @@
+const getSubMenuArrowStyle = ({
+  tokens,
+  disabled
+}) => (theme) => ({
+  display: "flex",
+  alignItems: "center",
+  flexShrink: 0,
+  marginLeft: theme.marginM,
+  // icons/right: 12×12 — явный overlay-маркер в Figma (не стандартный iconM = 16px)
+  fontSize: theme.iconS,
+  color: disabled ? tokens.dropdownItemTextDisabled : tokens.dropdownItemTextExtra
+});
+export {
+  getSubMenuArrowStyle
+};

package/dist/components/NewDropdown/components/SubMenuItem/SubMenuItem.types.d.ts

@@ -0,0 +1,5 @@
+import { NewDropdownSubMenuItem } from '../../NewDropdown.types';
+export interface SubMenuItemProps {
+    item: NewDropdownSubMenuItem;
+    parentKeyPath: string;
+}

package/dist/components/NewDropdown/components/SubMenuItem/index.d.ts

@@ -0,0 +1 @@
+export { SubMenuItem } from './SubMenuItem';

package/dist/components/NewDropdown/contexts/NewDropdownContext.d.ts

@@ -0,0 +1,9 @@
+import { NewDropdownMenuProps, NewDropdownProps } from '../NewDropdown.types';
+/**
+ * Конфиг-контекст: редко меняющиеся значения (стили, тайминги подменю, callback).
+ * Изменение этих значений не должно перерисовывать всё дерево пунктов на каждый ArrowDown.
+ */
+export interface NewDropdownContextValue extends Pick<NewDropdownProps, "styles">, Required<Pick<NewDropdownMenuProps, "triggerSubMenuAction" | "subMenuOpenDelay" | "subMenuCloseDelay">> {
+    onMenuClick?: NewDropdownMenuProps["onClick"];
+}
+export declare const NewDropdownContext: import('react').Context<NewDropdownContextValue>;

package/dist/components/NewDropdown/contexts/NewDropdownContext.js

@@ -0,0 +1,8 @@
+import { createContext } from "react";
+import { defaultMenuConfig } from "../NewDropdown.utils.js";
+const NewDropdownContext = createContext({
+  ...defaultMenuConfig
+});
+export {
+  NewDropdownContext
+};

package/dist/components/NewDropdown/contexts/NewDropdownNavigationContext.d.ts

@@ -0,0 +1,11 @@
+import { UseInteractionsReturn } from '@floating-ui/react';
+/**
+ * Navigation-контекст: ephemeral state, меняется на каждое перемещение фокуса/клавиатуру.
+ * Вынесен отдельно, чтобы consumers конфига (Divider и потенциальные новые «статические»
+ * подкомпоненты) не перерендеривались на каждом ArrowDown.
+ */
+export interface NewDropdownNavigationContextValue {
+    activeIndex: number | null;
+    getItemProps: UseInteractionsReturn["getItemProps"];
+}
+export declare const NewDropdownNavigationContext: import('react').Context<NewDropdownNavigationContextValue>;