@ssa-ui-kit/core 3.21.2 → 3.21.3

package/dist/components/Dropdown/Dropdown.d.ts

@@ -94,5 +94,5 @@ import { DropdownProps } from './types';
  *
  * @see https://www.w3.org/WAI/ARIA/apg/example-index/combobox/combobox-select-only.html
  */
-declare const Dropdown: <T extends DropdownOptionProps>({ selectedItem, disabled, isDisabled, isOpen: isInitOpen, children, onChange: handleChange, className, placeholder, maxHeight, avatarBorder, label, helperText, errors, success, icon, dropdownProps: componentProps, }: DropdownProps<T>) => import("@emotion/react/jsx-runtime").JSX.Element;
+declare const Dropdown: <T extends DropdownOptionProps>({ selectedItem, disabled, isDisabled, isOpen: isInitOpen, children, onChange: handleChange, className, placeholder, maxHeight, avatarBorder, label, helperText, errors, success, icon, width, dropdownProps: componentProps, }: DropdownProps<T>) => import("@emotion/react/jsx-runtime").JSX.Element;
 export default Dropdown;

package/dist/components/Dropdown/types.d.ts

@@ -129,12 +129,42 @@ export interface DropdownProps<P extends DropdownOptionProps> extends CommonProp
      * Ignored once an item with an `avatar` is selected — the avatar always takes priority.
      */
     icon?: IconProps['name'];
+    /**
+     * Width of the dropdown.
+     * Can be a number (pixels) or a string (any CSS value, e.g. `'100%'`).
+     *
+     * The value is applied to the outer field wrapper; the positioning base and
+     * the toggle button are stretched to fill it. All three have to be sized,
+     * because each one shrink-wraps on its own — but only the outermost carries
+     * the value, so a relative width like `'60%'` resolves against the
+     * surrounding container rather than compounding at every level.
+     *
+     * Setting the width from the outside via `className` / `css` only reaches the
+     * toggle button, which cannot grow past a shrink-wrapped parent.
+     *
+     * Has no default: when omitted, the dropdown sizes itself to its content,
+     * matching the behaviour of previous versions.
+     *
+     * @example
+     * ```tsx
+     * // Fill the surrounding form column
+     * <Dropdown width="100%" selectedItem={selected} onChange={handleChange}>
+     *   ...
+     * </Dropdown>
+     * ```
+     */
+    width?: string | number;
     /**
      * Props object for sub-components
      * Allows fine-grained control over component parts
      */
     dropdownProps?: {
-        /** Props for the wrapper div element */
+        /**
+         * Props for the wrapper div element.
+         *
+         * For sizing prefer the top-level `width` prop — it also reaches the outer
+         * field wrapper, which this slot cannot.
+         */
         base?: React.HTMLAttributes<HTMLDivElement>;
         /** Props for the toggle button element (excluding controlled props) */
         toggleButton?: Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, ControlledButtonProps> & {

package/dist/components/MultipleDropdown/types.d.ts

@@ -84,6 +84,20 @@ export type DropdownProps<P extends DropdownOptionProps> = {
      * @default 200
      */
     maxHeight?: number;
+    /**
+     * Width of the dropdown.
+     * Can be a number (pixels) or a string (any CSS value, e.g. `'100%'`).
+     *
+     * The value is applied to the positioning base; the toggle button is
+     * stretched to fill it, so a relative width like `'60%'` resolves against the
+     * surrounding container instead of compounding. It also clears the base's
+     * default `min-width` and the toggle's `max-width`, which would otherwise cap
+     * the value.
+     *
+     * Has no default: when omitted, the dropdown sizes itself to its content,
+     * matching the behaviour of previous versions.
+     */
+    width?: string | number;
 };
 /**
  * Context value shared with child DropdownOption components via MultipleDropdownContext

package/dist/index.js

@@ -25848,7 +25848,7 @@ const DropdownFieldWrapper = /*#__PURE__*/base_default()("div", process.env.NODE
   styles: "display:inline-flex;flex-direction:column;align-items:flex-start"
 } : {
   name: "1bj7yge",
-  styles: "display:inline-flex;flex-direction:column;align-items:flex-start/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/ui-kit/ui-kit/packages/core/src/components/Dropdown/Dropdown.tsx"],"names":[],"mappings":"AA0BuC","file":"/home/runner/work/ui-kit/ui-kit/packages/core/src/components/Dropdown/Dropdown.tsx","sourcesContent":["import React, {\n  useState,\n  useEffect,\n  useLayoutEffect,\n  useRef,\n  useId,\n  ReactNode,\n} from 'react';\nimport styled from '@emotion/styled';\nimport { useTheme } from '@emotion/react';\nimport { useClickOutside } from '@ssa-ui-kit/hooks';\nimport { isNill } from '@ssa-ui-kit/utils';\n\nimport DropdownToggle from '@components/DropdownToggle';\nimport DropdownArrow from '@components/DropdownArrow';\nimport DropdownOptions from '@components/DropdownOptions';\nimport Avatar, { AvatarSizes } from '@components/Avatar';\nimport Icon from '@components/Icon';\nimport Label from '@components/Label';\nimport FormHelperText from '@components/FormHelperText';\nimport DropdownContext from '@components/Dropdown/Dropdown.context';\nimport { resolveDisabled } from '@utils/deprecation';\nimport { DropdownOptionProps } from '@components/DropdownOptions/types';\n\nimport { DropdownContextType, DropdownPositions, DropdownProps } from './types';\n\nconst DropdownFieldWrapper = styled.div`\n  display: inline-flex;\n  flex-direction: column;\n  align-items: flex-start;\n`;\n\nconst DropdownBase = styled.div`\n  display: inline-block;\n  position: relative;\n`;\n\nconst SelectedContent = styled.span`\n  display: inline-flex;\n  align-items: center;\n  gap: 8px;\n  flex-shrink: 0;\n  min-width: 0;\n`;\n\n/**\n * Dropdown - Select-like dropdown component for single selection\n *\n * A flexible dropdown component that allows users to select one option from\n * a list of choices. Uses a compound component pattern with DropdownOption\n * children. Provides keyboard navigation, accessibility features, click-outside\n * to close functionality, and automatic viewport-aware placement of the options list.\n *\n * On every open the component measures available space below the toggle button\n * and flips the list upward when there is not enough room, preventing the list\n * from being clipped by the viewport edge. This behavior can be overridden via\n * dropdownProps.dropdownPosition.\n *\n * Component structure:\n * - Dropdown (root container with context)\n *   - DropdownToggle (button that opens/closes dropdown)\n *   - DropdownOptions (menu container that appears when open)\n *     - DropdownOption (individual selectable items)\n *\n * @category Form Controls\n * @subcategory Selection\n *\n * @example\n * ```tsx\n * const items = [\n *   { id: 1, value: 'Apple' },\n *   { id: 2, value: 'Banana' },\n *   { id: 3, value: 'Cherry' },\n * ];\n *\n * <Dropdown\n *   selectedItem={items[0]}\n *   onChange={(item) => handleSelection(item)}\n *   placeholder=\"Select a fruit\"\n * >\n *   {items.map(item => (\n *     <DropdownOption key={item.id} value={item.id}>\n *       {item.value}\n *     </DropdownOption>\n *   ))}\n * </Dropdown>\n * ```\n *\n * @example\n * ```tsx\n * // Controlled open state\n * const [isOpen, setIsOpen] = useState(false);\n * <Dropdown\n *   isOpen={isOpen}\n *   onChange={handleChange}\n *   selectedItem={selected}\n * >\n *   {options.map(opt => (\n *     <DropdownOption key={opt.id} value={opt.id}>\n *       {opt.label}\n *     </DropdownOption>\n *   ))}\n * </Dropdown>\n * ```\n *\n * @example\n * ```tsx\n * // With custom props for sub-components and forced upward placement\n * <Dropdown\n *   selectedItem={selected}\n *   onChange={handleChange}\n *   dropdownProps={{\n *     base: { id: 'my-dropdown' },\n *     toggleButton: { 'data-testid': 'dropdown-toggle' },\n *     toggleButtonArrow: { className: 'custom-arrow' },\n *     dropdownPosition: DropdownPositions.top,\n *   }}\n * >\n *   {options.map(opt => (\n *     <DropdownOption key={opt.id} value={opt.id}>\n *       {opt.label}\n *     </DropdownOption>\n *   ))}\n * </Dropdown>\n * ```\n *\n * @see {@link DropdownOption} - Child component for individual options\n * @see {@link DropdownToggle} - Toggle button component\n * @see {@link DropdownOptions} - Options menu container\n *\n * @accessibility\n * - ARIA attributes set according to WAI-ARIA combobox pattern\n * - Keyboard navigation (Arrow keys, Enter, Escape)\n * - Click outside to close\n * - Screen reader friendly\n * - Focus management\n *\n * @see https://www.w3.org/WAI/ARIA/apg/example-index/combobox/combobox-select-only.html\n */\nconst Dropdown = <T extends DropdownOptionProps>({\n  selectedItem,\n  disabled,\n  isDisabled,\n  isOpen: isInitOpen,\n  children,\n  onChange: handleChange,\n  className,\n  placeholder = 'Select something',\n  maxHeight = 200,\n  avatarBorder = false,\n  label,\n  helperText,\n  errors,\n  success,\n  icon,\n  dropdownProps: componentProps,\n}: DropdownProps<T>) => {\n  const isDropdownDisabled = resolveDisabled('Dropdown', disabled, isDisabled);\n  const status = success ? 'success' : errors ? 'error' : 'basic';\n  const { dropdownPosition = DropdownPositions.auto } = componentProps ?? {};\n\n  const theme = useTheme();\n  const dropdownRef = useRef<HTMLDivElement>(null);\n  const listRef = useRef<HTMLUListElement>(null);\n\n  const dropdownId = useId();\n  const options: T[] = [];\n\n  const [isFocused, setIsFocused] = useState(false);\n  const [isOpen, setIsOpen] = useState(isInitOpen || false);\n  const [colors, setColors] = useState<Array<string | undefined>>([]);\n  const [activeItem, setActiveItem] = useState<T | undefined>(selectedItem);\n  const [placement, setPlacement] = useState<'top' | 'bottom'>('bottom');\n\n  const onChange: DropdownContextType['onChange'] = (item) => {\n    const innerItem = options.filter((option) => option.value === item)[0];\n\n    setIsOpen(false);\n\n    if (isDropdownDisabled || !innerItem) {\n      return;\n    }\n\n    if (innerItem.value === activeItem?.value) {\n      return;\n    }\n\n    setActiveItem(innerItem);\n    if (handleChange) {\n      handleChange(innerItem);\n    }\n  };\n\n  useClickOutside(dropdownRef, () => isOpen && setIsOpen(false));\n\n  useEffect(() => {\n    if (isDropdownDisabled) {\n      setColors([theme.colors.greyDarker60, theme.colors.grey20]);\n    } else if (isOpen) {\n      setColors([theme.colors.white, theme.colors.white60]);\n    } else if (isFocused) {\n      setColors([theme.colors.greyDarker, theme.colors.greyDarker60]);\n    }\n  }, [isOpen, isDropdownDisabled, isFocused]);\n\n  useEffect(() => {\n    setActiveItem(selectedItem);\n  }, [selectedItem]);\n\n  useEffect(() => {\n    if (isDropdownDisabled && isOpen) {\n      setIsOpen(false);\n    }\n  }, [isDropdownDisabled]);\n\n  useLayoutEffect(() => {\n    if (!isOpen || !dropdownRef.current) return;\n\n    if (dropdownPosition !== DropdownPositions.auto) {\n      setPlacement(dropdownPosition);\n      return;\n    }\n\n    const rect = dropdownRef.current.getBoundingClientRect();\n    const listHeight = listRef.current?.offsetHeight || maxHeight;\n    const spaceBelow = window.innerHeight - rect.bottom;\n    setPlacement(spaceBelow < listHeight ? 'top' : 'bottom');\n  }, [isOpen]);\n\n  const childrenArray = React.Children.toArray(children).filter(Boolean);\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const items = (childrenArray as React.ReactElement<any>[]).map(\n    (child, index) => {\n      options.push(child.props);\n\n      return React.cloneElement(child, {\n        index,\n        onClick: onChange.bind(this),\n        ...child.props,\n      });\n    },\n  );\n\n  const contextValue: DropdownContextType = React.useMemo(\n    () => ({ onChange, activeItem, maxHeight, listRef, placement }),\n    [onChange, activeItem, maxHeight, placement],\n  );\n\n  const value = (\n    activeItem\n      ? activeItem.label ||\n        activeItem.children ||\n        activeItem.value ||\n        activeItem ||\n        placeholder\n      : placeholder\n  ) as ReactNode;\n\n  const rawAvatar =\n    activeItem && (activeItem as Record<string, unknown>).avatar;\n\n  const selectedAvatar = !isNill(rawAvatar) ? (\n    typeof rawAvatar === 'string' ? (\n      <Avatar\n        size={AvatarSizes.small}\n        image={rawAvatar}\n        border={avatarBorder}\n      />\n    ) : React.isValidElement(rawAvatar) ? (\n      (rawAvatar as ReactNode)\n    ) : null\n  ) : null;\n\n  const leadingElement = !isNill(selectedAvatar) ? (\n    (selectedAvatar as ReactNode)\n  ) : icon ? (\n    <Icon\n      name={icon}\n      size={16}\n      color={isDropdownDisabled ? theme.colors.grey : theme.colors.greyDarker80}\n    />\n  ) : null;\n\n  const toggleContent = !isNill(leadingElement) ? (\n    <SelectedContent>\n      {leadingElement}\n      <span style={{ minWidth: 0 }}>{value}</span>\n    </SelectedContent>\n  ) : (\n    value\n  );\n\n  return (\n    <DropdownFieldWrapper>\n      {label ? <Label disabled={isDropdownDisabled}>{label}</Label> : null}\n      <DropdownContext.Provider value={contextValue}>\n        <DropdownBase\n          {...componentProps?.base}\n          ref={dropdownRef}\n          data-testid=\"dropdown\">\n          <DropdownToggle\n            {...componentProps?.toggleButton}\n            className={className}\n            isOpen={isOpen}\n            disabled={isDropdownDisabled}\n            status={status}\n            onClick={setIsOpen.bind(null, !isOpen)}\n            onFocus={setIsFocused.bind(null, true)}\n            colors={colors}\n            aria-labelledby={`dropdown-label-${dropdownId}`}\n            aria-controls={`dropdown-popup-${dropdownId}`}>\n            {toggleContent}\n            <DropdownArrow\n              {...componentProps?.toggleButtonArrow}\n              isUp={isOpen}\n            />\n          </DropdownToggle>\n\n          {isOpen ? <DropdownOptions>{items}</DropdownOptions> : null}\n        </DropdownBase>\n      </DropdownContext.Provider>\n      {helperText || errors ? (\n        <FormHelperText\n          role=\"status\"\n          status={status}\n          disabled={isDropdownDisabled}>\n          {errors?.message || helperText}\n        </FormHelperText>\n      ) : null}\n    </DropdownFieldWrapper>\n  );\n};\n\nexport default Dropdown;\n"]} */",
+  styles: "display:inline-flex;flex-direction:column;align-items:flex-start/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/ui-kit/ui-kit/packages/core/src/components/Dropdown/Dropdown.tsx"],"names":[],"mappings":"AA0BuC","file":"/home/runner/work/ui-kit/ui-kit/packages/core/src/components/Dropdown/Dropdown.tsx","sourcesContent":["import React, {\n  useState,\n  useEffect,\n  useLayoutEffect,\n  useRef,\n  useId,\n  ReactNode,\n} from 'react';\nimport styled from '@emotion/styled';\nimport { useTheme } from '@emotion/react';\nimport { useClickOutside } from '@ssa-ui-kit/hooks';\nimport { isNill } from '@ssa-ui-kit/utils';\n\nimport DropdownToggle from '@components/DropdownToggle';\nimport DropdownArrow from '@components/DropdownArrow';\nimport DropdownOptions from '@components/DropdownOptions';\nimport Avatar, { AvatarSizes } from '@components/Avatar';\nimport Icon from '@components/Icon';\nimport Label from '@components/Label';\nimport FormHelperText from '@components/FormHelperText';\nimport DropdownContext from '@components/Dropdown/Dropdown.context';\nimport { resolveDisabled } from '@utils/deprecation';\nimport { DropdownOptionProps } from '@components/DropdownOptions/types';\n\nimport { DropdownContextType, DropdownPositions, DropdownProps } from './types';\n\nconst DropdownFieldWrapper = styled.div`\n  display: inline-flex;\n  flex-direction: column;\n  align-items: flex-start;\n`;\n\nconst DropdownBase = styled.div`\n  display: inline-block;\n  position: relative;\n`;\n\nconst SelectedContent = styled.span`\n  display: inline-flex;\n  align-items: center;\n  gap: 8px;\n  flex-shrink: 0;\n  min-width: 0;\n`;\n\n/**\n * Dropdown - Select-like dropdown component for single selection\n *\n * A flexible dropdown component that allows users to select one option from\n * a list of choices. Uses a compound component pattern with DropdownOption\n * children. Provides keyboard navigation, accessibility features, click-outside\n * to close functionality, and automatic viewport-aware placement of the options list.\n *\n * On every open the component measures available space below the toggle button\n * and flips the list upward when there is not enough room, preventing the list\n * from being clipped by the viewport edge. This behavior can be overridden via\n * dropdownProps.dropdownPosition.\n *\n * Component structure:\n * - Dropdown (root container with context)\n *   - DropdownToggle (button that opens/closes dropdown)\n *   - DropdownOptions (menu container that appears when open)\n *     - DropdownOption (individual selectable items)\n *\n * @category Form Controls\n * @subcategory Selection\n *\n * @example\n * ```tsx\n * const items = [\n *   { id: 1, value: 'Apple' },\n *   { id: 2, value: 'Banana' },\n *   { id: 3, value: 'Cherry' },\n * ];\n *\n * <Dropdown\n *   selectedItem={items[0]}\n *   onChange={(item) => handleSelection(item)}\n *   placeholder=\"Select a fruit\"\n * >\n *   {items.map(item => (\n *     <DropdownOption key={item.id} value={item.id}>\n *       {item.value}\n *     </DropdownOption>\n *   ))}\n * </Dropdown>\n * ```\n *\n * @example\n * ```tsx\n * // Controlled open state\n * const [isOpen, setIsOpen] = useState(false);\n * <Dropdown\n *   isOpen={isOpen}\n *   onChange={handleChange}\n *   selectedItem={selected}\n * >\n *   {options.map(opt => (\n *     <DropdownOption key={opt.id} value={opt.id}>\n *       {opt.label}\n *     </DropdownOption>\n *   ))}\n * </Dropdown>\n * ```\n *\n * @example\n * ```tsx\n * // With custom props for sub-components and forced upward placement\n * <Dropdown\n *   selectedItem={selected}\n *   onChange={handleChange}\n *   dropdownProps={{\n *     base: { id: 'my-dropdown' },\n *     toggleButton: { 'data-testid': 'dropdown-toggle' },\n *     toggleButtonArrow: { className: 'custom-arrow' },\n *     dropdownPosition: DropdownPositions.top,\n *   }}\n * >\n *   {options.map(opt => (\n *     <DropdownOption key={opt.id} value={opt.id}>\n *       {opt.label}\n *     </DropdownOption>\n *   ))}\n * </Dropdown>\n * ```\n *\n * @see {@link DropdownOption} - Child component for individual options\n * @see {@link DropdownToggle} - Toggle button component\n * @see {@link DropdownOptions} - Options menu container\n *\n * @accessibility\n * - ARIA attributes set according to WAI-ARIA combobox pattern\n * - Keyboard navigation (Arrow keys, Enter, Escape)\n * - Click outside to close\n * - Screen reader friendly\n * - Focus management\n *\n * @see https://www.w3.org/WAI/ARIA/apg/example-index/combobox/combobox-select-only.html\n */\nconst Dropdown = <T extends DropdownOptionProps>({\n  selectedItem,\n  disabled,\n  isDisabled,\n  isOpen: isInitOpen,\n  children,\n  onChange: handleChange,\n  className,\n  placeholder = 'Select something',\n  maxHeight = 200,\n  avatarBorder = false,\n  label,\n  helperText,\n  errors,\n  success,\n  icon,\n  width,\n  dropdownProps: componentProps,\n}: DropdownProps<T>) => {\n  const isDropdownDisabled = resolveDisabled('Dropdown', disabled, isDisabled);\n  const status = success ? 'success' : errors ? 'error' : 'basic';\n  const { dropdownPosition = DropdownPositions.auto } = componentProps ?? {};\n  // `width` has no default: without it every level keeps shrink-wrapping, which\n  // is the historical behaviour. When set, all three nested levels\n  // (wrapper -> base -> toggle) have to be stretched — sizing only one is a\n  // no-op, because the level above it is still sized to its content.\n  //\n  // Only the outermost level gets the requested value; the inner two get 100%.\n  // Repeating the value would compound relative units: `width=\"60%\"` would\n  // otherwise render the base at 60% of the wrapper and the toggle at 60% of\n  // that, i.e. 21.6% of the container.\n  //\n  // Spread rather than passed as `css={...}`: Emotion wraps an element whenever\n  // `css` is present in its props, even when its value is undefined, and that\n  // re-serializes any incoming `className` (e.g. from `styled(Dropdown)`).\n  // Omitting the key keeps the no-width path identical to writing no `css` prop.\n  const wrapperCssProps = width === undefined ? undefined : { css: { width } };\n  const baseCssProps =\n    width === undefined ? undefined : { css: { width: '100%' } };\n  const toggleCssProps =\n    width === undefined\n      ? undefined\n      : { css: [{ width: '100%' }, componentProps?.toggleButton?.css] };\n\n  const theme = useTheme();\n  const dropdownRef = useRef<HTMLDivElement>(null);\n  const listRef = useRef<HTMLUListElement>(null);\n\n  const dropdownId = useId();\n  const options: T[] = [];\n\n  const [isFocused, setIsFocused] = useState(false);\n  const [isOpen, setIsOpen] = useState(isInitOpen || false);\n  const [colors, setColors] = useState<Array<string | undefined>>([]);\n  const [activeItem, setActiveItem] = useState<T | undefined>(selectedItem);\n  const [placement, setPlacement] = useState<'top' | 'bottom'>('bottom');\n\n  const onChange: DropdownContextType['onChange'] = (item) => {\n    const innerItem = options.filter((option) => option.value === item)[0];\n\n    setIsOpen(false);\n\n    if (isDropdownDisabled || !innerItem) {\n      return;\n    }\n\n    if (innerItem.value === activeItem?.value) {\n      return;\n    }\n\n    setActiveItem(innerItem);\n    if (handleChange) {\n      handleChange(innerItem);\n    }\n  };\n\n  useClickOutside(dropdownRef, () => isOpen && setIsOpen(false));\n\n  useEffect(() => {\n    if (isDropdownDisabled) {\n      setColors([theme.colors.greyDarker60, theme.colors.grey20]);\n    } else if (isOpen) {\n      setColors([theme.colors.white, theme.colors.white60]);\n    } else if (isFocused) {\n      setColors([theme.colors.greyDarker, theme.colors.greyDarker60]);\n    }\n  }, [isOpen, isDropdownDisabled, isFocused]);\n\n  useEffect(() => {\n    setActiveItem(selectedItem);\n  }, [selectedItem]);\n\n  useEffect(() => {\n    if (isDropdownDisabled && isOpen) {\n      setIsOpen(false);\n    }\n  }, [isDropdownDisabled]);\n\n  useLayoutEffect(() => {\n    if (!isOpen || !dropdownRef.current) return;\n\n    if (dropdownPosition !== DropdownPositions.auto) {\n      setPlacement(dropdownPosition);\n      return;\n    }\n\n    const rect = dropdownRef.current.getBoundingClientRect();\n    const listHeight = listRef.current?.offsetHeight || maxHeight;\n    const spaceBelow = window.innerHeight - rect.bottom;\n    setPlacement(spaceBelow < listHeight ? 'top' : 'bottom');\n  }, [isOpen]);\n\n  const childrenArray = React.Children.toArray(children).filter(Boolean);\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const items = (childrenArray as React.ReactElement<any>[]).map(\n    (child, index) => {\n      options.push(child.props);\n\n      return React.cloneElement(child, {\n        index,\n        onClick: onChange.bind(this),\n        ...child.props,\n      });\n    },\n  );\n\n  const contextValue: DropdownContextType = React.useMemo(\n    () => ({ onChange, activeItem, maxHeight, listRef, placement }),\n    [onChange, activeItem, maxHeight, placement],\n  );\n\n  const value = (\n    activeItem\n      ? activeItem.label ||\n        activeItem.children ||\n        activeItem.value ||\n        activeItem ||\n        placeholder\n      : placeholder\n  ) as ReactNode;\n\n  const rawAvatar =\n    activeItem && (activeItem as Record<string, unknown>).avatar;\n\n  const selectedAvatar = !isNill(rawAvatar) ? (\n    typeof rawAvatar === 'string' ? (\n      <Avatar\n        size={AvatarSizes.small}\n        image={rawAvatar}\n        border={avatarBorder}\n      />\n    ) : React.isValidElement(rawAvatar) ? (\n      (rawAvatar as ReactNode)\n    ) : null\n  ) : null;\n\n  const leadingElement = !isNill(selectedAvatar) ? (\n    (selectedAvatar as ReactNode)\n  ) : icon ? (\n    <Icon\n      name={icon}\n      size={16}\n      color={isDropdownDisabled ? theme.colors.grey : theme.colors.greyDarker80}\n    />\n  ) : null;\n\n  const toggleContent = !isNill(leadingElement) ? (\n    <SelectedContent>\n      {leadingElement}\n      <span style={{ minWidth: 0 }}>{value}</span>\n    </SelectedContent>\n  ) : (\n    value\n  );\n\n  return (\n    <DropdownFieldWrapper {...wrapperCssProps}>\n      {label ? <Label disabled={isDropdownDisabled}>{label}</Label> : null}\n      <DropdownContext.Provider value={contextValue}>\n        <DropdownBase\n          {...componentProps?.base}\n          {...baseCssProps}\n          ref={dropdownRef}\n          data-testid=\"dropdown\">\n          <DropdownToggle\n            {...componentProps?.toggleButton}\n            {...toggleCssProps}\n            className={className}\n            isOpen={isOpen}\n            disabled={isDropdownDisabled}\n            status={status}\n            onClick={setIsOpen.bind(null, !isOpen)}\n            onFocus={setIsFocused.bind(null, true)}\n            colors={colors}\n            aria-labelledby={`dropdown-label-${dropdownId}`}\n            aria-controls={`dropdown-popup-${dropdownId}`}>\n            {toggleContent}\n            <DropdownArrow\n              {...componentProps?.toggleButtonArrow}\n              isUp={isOpen}\n            />\n          </DropdownToggle>\n\n          {isOpen ? <DropdownOptions>{items}</DropdownOptions> : null}\n        </DropdownBase>\n      </DropdownContext.Provider>\n      {helperText || errors ? (\n        <FormHelperText\n          role=\"status\"\n          status={status}\n          disabled={isDropdownDisabled}>\n          {errors?.message || helperText}\n        </FormHelperText>\n      ) : null}\n    </DropdownFieldWrapper>\n  );\n};\n\nexport default Dropdown;\n"]} */",
   toString: Dropdown_EMOTION_STRINGIFIED_CSS_ERROR_
 });
 const DropdownBase = /*#__PURE__*/base_default()("div", process.env.NODE_ENV === "production" ? {
@@ -25861,7 +25861,7 @@ const DropdownBase = /*#__PURE__*/base_default()("div", process.env.NODE_ENV ===
   styles: "display:inline-block;position:relative"
 } : {
   name: "11ffxfj",
-  styles: "display:inline-block;position:relative/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/ui-kit/ui-kit/packages/core/src/components/Dropdown/Dropdown.tsx"],"names":[],"mappings":"AAgC+B","file":"/home/runner/work/ui-kit/ui-kit/packages/core/src/components/Dropdown/Dropdown.tsx","sourcesContent":["import React, {\n  useState,\n  useEffect,\n  useLayoutEffect,\n  useRef,\n  useId,\n  ReactNode,\n} from 'react';\nimport styled from '@emotion/styled';\nimport { useTheme } from '@emotion/react';\nimport { useClickOutside } from '@ssa-ui-kit/hooks';\nimport { isNill } from '@ssa-ui-kit/utils';\n\nimport DropdownToggle from '@components/DropdownToggle';\nimport DropdownArrow from '@components/DropdownArrow';\nimport DropdownOptions from '@components/DropdownOptions';\nimport Avatar, { AvatarSizes } from '@components/Avatar';\nimport Icon from '@components/Icon';\nimport Label from '@components/Label';\nimport FormHelperText from '@components/FormHelperText';\nimport DropdownContext from '@components/Dropdown/Dropdown.context';\nimport { resolveDisabled } from '@utils/deprecation';\nimport { DropdownOptionProps } from '@components/DropdownOptions/types';\n\nimport { DropdownContextType, DropdownPositions, DropdownProps } from './types';\n\nconst DropdownFieldWrapper = styled.div`\n  display: inline-flex;\n  flex-direction: column;\n  align-items: flex-start;\n`;\n\nconst DropdownBase = styled.div`\n  display: inline-block;\n  position: relative;\n`;\n\nconst SelectedContent = styled.span`\n  display: inline-flex;\n  align-items: center;\n  gap: 8px;\n  flex-shrink: 0;\n  min-width: 0;\n`;\n\n/**\n * Dropdown - Select-like dropdown component for single selection\n *\n * A flexible dropdown component that allows users to select one option from\n * a list of choices. Uses a compound component pattern with DropdownOption\n * children. Provides keyboard navigation, accessibility features, click-outside\n * to close functionality, and automatic viewport-aware placement of the options list.\n *\n * On every open the component measures available space below the toggle button\n * and flips the list upward when there is not enough room, preventing the list\n * from being clipped by the viewport edge. This behavior can be overridden via\n * dropdownProps.dropdownPosition.\n *\n * Component structure:\n * - Dropdown (root container with context)\n *   - DropdownToggle (button that opens/closes dropdown)\n *   - DropdownOptions (menu container that appears when open)\n *     - DropdownOption (individual selectable items)\n *\n * @category Form Controls\n * @subcategory Selection\n *\n * @example\n * ```tsx\n * const items = [\n *   { id: 1, value: 'Apple' },\n *   { id: 2, value: 'Banana' },\n *   { id: 3, value: 'Cherry' },\n * ];\n *\n * <Dropdown\n *   selectedItem={items[0]}\n *   onChange={(item) => handleSelection(item)}\n *   placeholder=\"Select a fruit\"\n * >\n *   {items.map(item => (\n *     <DropdownOption key={item.id} value={item.id}>\n *       {item.value}\n *     </DropdownOption>\n *   ))}\n * </Dropdown>\n * ```\n *\n * @example\n * ```tsx\n * // Controlled open state\n * const [isOpen, setIsOpen] = useState(false);\n * <Dropdown\n *   isOpen={isOpen}\n *   onChange={handleChange}\n *   selectedItem={selected}\n * >\n *   {options.map(opt => (\n *     <DropdownOption key={opt.id} value={opt.id}>\n *       {opt.label}\n *     </DropdownOption>\n *   ))}\n * </Dropdown>\n * ```\n *\n * @example\n * ```tsx\n * // With custom props for sub-components and forced upward placement\n * <Dropdown\n *   selectedItem={selected}\n *   onChange={handleChange}\n *   dropdownProps={{\n *     base: { id: 'my-dropdown' },\n *     toggleButton: { 'data-testid': 'dropdown-toggle' },\n *     toggleButtonArrow: { className: 'custom-arrow' },\n *     dropdownPosition: DropdownPositions.top,\n *   }}\n * >\n *   {options.map(opt => (\n *     <DropdownOption key={opt.id} value={opt.id}>\n *       {opt.label}\n *     </DropdownOption>\n *   ))}\n * </Dropdown>\n * ```\n *\n * @see {@link DropdownOption} - Child component for individual options\n * @see {@link DropdownToggle} - Toggle button component\n * @see {@link DropdownOptions} - Options menu container\n *\n * @accessibility\n * - ARIA attributes set according to WAI-ARIA combobox pattern\n * - Keyboard navigation (Arrow keys, Enter, Escape)\n * - Click outside to close\n * - Screen reader friendly\n * - Focus management\n *\n * @see https://www.w3.org/WAI/ARIA/apg/example-index/combobox/combobox-select-only.html\n */\nconst Dropdown = <T extends DropdownOptionProps>({\n  selectedItem,\n  disabled,\n  isDisabled,\n  isOpen: isInitOpen,\n  children,\n  onChange: handleChange,\n  className,\n  placeholder = 'Select something',\n  maxHeight = 200,\n  avatarBorder = false,\n  label,\n  helperText,\n  errors,\n  success,\n  icon,\n  dropdownProps: componentProps,\n}: DropdownProps<T>) => {\n  const isDropdownDisabled = resolveDisabled('Dropdown', disabled, isDisabled);\n  const status = success ? 'success' : errors ? 'error' : 'basic';\n  const { dropdownPosition = DropdownPositions.auto } = componentProps ?? {};\n\n  const theme = useTheme();\n  const dropdownRef = useRef<HTMLDivElement>(null);\n  const listRef = useRef<HTMLUListElement>(null);\n\n  const dropdownId = useId();\n  const options: T[] = [];\n\n  const [isFocused, setIsFocused] = useState(false);\n  const [isOpen, setIsOpen] = useState(isInitOpen || false);\n  const [colors, setColors] = useState<Array<string | undefined>>([]);\n  const [activeItem, setActiveItem] = useState<T | undefined>(selectedItem);\n  const [placement, setPlacement] = useState<'top' | 'bottom'>('bottom');\n\n  const onChange: DropdownContextType['onChange'] = (item) => {\n    const innerItem = options.filter((option) => option.value === item)[0];\n\n    setIsOpen(false);\n\n    if (isDropdownDisabled || !innerItem) {\n      return;\n    }\n\n    if (innerItem.value === activeItem?.value) {\n      return;\n    }\n\n    setActiveItem(innerItem);\n    if (handleChange) {\n      handleChange(innerItem);\n    }\n  };\n\n  useClickOutside(dropdownRef, () => isOpen && setIsOpen(false));\n\n  useEffect(() => {\n    if (isDropdownDisabled) {\n      setColors([theme.colors.greyDarker60, theme.colors.grey20]);\n    } else if (isOpen) {\n      setColors([theme.colors.white, theme.colors.white60]);\n    } else if (isFocused) {\n      setColors([theme.colors.greyDarker, theme.colors.greyDarker60]);\n    }\n  }, [isOpen, isDropdownDisabled, isFocused]);\n\n  useEffect(() => {\n    setActiveItem(selectedItem);\n  }, [selectedItem]);\n\n  useEffect(() => {\n    if (isDropdownDisabled && isOpen) {\n      setIsOpen(false);\n    }\n  }, [isDropdownDisabled]);\n\n  useLayoutEffect(() => {\n    if (!isOpen || !dropdownRef.current) return;\n\n    if (dropdownPosition !== DropdownPositions.auto) {\n      setPlacement(dropdownPosition);\n      return;\n    }\n\n    const rect = dropdownRef.current.getBoundingClientRect();\n    const listHeight = listRef.current?.offsetHeight || maxHeight;\n    const spaceBelow = window.innerHeight - rect.bottom;\n    setPlacement(spaceBelow < listHeight ? 'top' : 'bottom');\n  }, [isOpen]);\n\n  const childrenArray = React.Children.toArray(children).filter(Boolean);\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const items = (childrenArray as React.ReactElement<any>[]).map(\n    (child, index) => {\n      options.push(child.props);\n\n      return React.cloneElement(child, {\n        index,\n        onClick: onChange.bind(this),\n        ...child.props,\n      });\n    },\n  );\n\n  const contextValue: DropdownContextType = React.useMemo(\n    () => ({ onChange, activeItem, maxHeight, listRef, placement }),\n    [onChange, activeItem, maxHeight, placement],\n  );\n\n  const value = (\n    activeItem\n      ? activeItem.label ||\n        activeItem.children ||\n        activeItem.value ||\n        activeItem ||\n        placeholder\n      : placeholder\n  ) as ReactNode;\n\n  const rawAvatar =\n    activeItem && (activeItem as Record<string, unknown>).avatar;\n\n  const selectedAvatar = !isNill(rawAvatar) ? (\n    typeof rawAvatar === 'string' ? (\n      <Avatar\n        size={AvatarSizes.small}\n        image={rawAvatar}\n        border={avatarBorder}\n      />\n    ) : React.isValidElement(rawAvatar) ? (\n      (rawAvatar as ReactNode)\n    ) : null\n  ) : null;\n\n  const leadingElement = !isNill(selectedAvatar) ? (\n    (selectedAvatar as ReactNode)\n  ) : icon ? (\n    <Icon\n      name={icon}\n      size={16}\n      color={isDropdownDisabled ? theme.colors.grey : theme.colors.greyDarker80}\n    />\n  ) : null;\n\n  const toggleContent = !isNill(leadingElement) ? (\n    <SelectedContent>\n      {leadingElement}\n      <span style={{ minWidth: 0 }}>{value}</span>\n    </SelectedContent>\n  ) : (\n    value\n  );\n\n  return (\n    <DropdownFieldWrapper>\n      {label ? <Label disabled={isDropdownDisabled}>{label}</Label> : null}\n      <DropdownContext.Provider value={contextValue}>\n        <DropdownBase\n          {...componentProps?.base}\n          ref={dropdownRef}\n          data-testid=\"dropdown\">\n          <DropdownToggle\n            {...componentProps?.toggleButton}\n            className={className}\n            isOpen={isOpen}\n            disabled={isDropdownDisabled}\n            status={status}\n            onClick={setIsOpen.bind(null, !isOpen)}\n            onFocus={setIsFocused.bind(null, true)}\n            colors={colors}\n            aria-labelledby={`dropdown-label-${dropdownId}`}\n            aria-controls={`dropdown-popup-${dropdownId}`}>\n            {toggleContent}\n            <DropdownArrow\n              {...componentProps?.toggleButtonArrow}\n              isUp={isOpen}\n            />\n          </DropdownToggle>\n\n          {isOpen ? <DropdownOptions>{items}</DropdownOptions> : null}\n        </DropdownBase>\n      </DropdownContext.Provider>\n      {helperText || errors ? (\n        <FormHelperText\n          role=\"status\"\n          status={status}\n          disabled={isDropdownDisabled}>\n          {errors?.message || helperText}\n        </FormHelperText>\n      ) : null}\n    </DropdownFieldWrapper>\n  );\n};\n\nexport default Dropdown;\n"]} */",
+  styles: "display:inline-block;position:relative/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/ui-kit/ui-kit/packages/core/src/components/Dropdown/Dropdown.tsx"],"names":[],"mappings":"AAgC+B","file":"/home/runner/work/ui-kit/ui-kit/packages/core/src/components/Dropdown/Dropdown.tsx","sourcesContent":["import React, {\n  useState,\n  useEffect,\n  useLayoutEffect,\n  useRef,\n  useId,\n  ReactNode,\n} from 'react';\nimport styled from '@emotion/styled';\nimport { useTheme } from '@emotion/react';\nimport { useClickOutside } from '@ssa-ui-kit/hooks';\nimport { isNill } from '@ssa-ui-kit/utils';\n\nimport DropdownToggle from '@components/DropdownToggle';\nimport DropdownArrow from '@components/DropdownArrow';\nimport DropdownOptions from '@components/DropdownOptions';\nimport Avatar, { AvatarSizes } from '@components/Avatar';\nimport Icon from '@components/Icon';\nimport Label from '@components/Label';\nimport FormHelperText from '@components/FormHelperText';\nimport DropdownContext from '@components/Dropdown/Dropdown.context';\nimport { resolveDisabled } from '@utils/deprecation';\nimport { DropdownOptionProps } from '@components/DropdownOptions/types';\n\nimport { DropdownContextType, DropdownPositions, DropdownProps } from './types';\n\nconst DropdownFieldWrapper = styled.div`\n  display: inline-flex;\n  flex-direction: column;\n  align-items: flex-start;\n`;\n\nconst DropdownBase = styled.div`\n  display: inline-block;\n  position: relative;\n`;\n\nconst SelectedContent = styled.span`\n  display: inline-flex;\n  align-items: center;\n  gap: 8px;\n  flex-shrink: 0;\n  min-width: 0;\n`;\n\n/**\n * Dropdown - Select-like dropdown component for single selection\n *\n * A flexible dropdown component that allows users to select one option from\n * a list of choices. Uses a compound component pattern with DropdownOption\n * children. Provides keyboard navigation, accessibility features, click-outside\n * to close functionality, and automatic viewport-aware placement of the options list.\n *\n * On every open the component measures available space below the toggle button\n * and flips the list upward when there is not enough room, preventing the list\n * from being clipped by the viewport edge. This behavior can be overridden via\n * dropdownProps.dropdownPosition.\n *\n * Component structure:\n * - Dropdown (root container with context)\n *   - DropdownToggle (button that opens/closes dropdown)\n *   - DropdownOptions (menu container that appears when open)\n *     - DropdownOption (individual selectable items)\n *\n * @category Form Controls\n * @subcategory Selection\n *\n * @example\n * ```tsx\n * const items = [\n *   { id: 1, value: 'Apple' },\n *   { id: 2, value: 'Banana' },\n *   { id: 3, value: 'Cherry' },\n * ];\n *\n * <Dropdown\n *   selectedItem={items[0]}\n *   onChange={(item) => handleSelection(item)}\n *   placeholder=\"Select a fruit\"\n * >\n *   {items.map(item => (\n *     <DropdownOption key={item.id} value={item.id}>\n *       {item.value}\n *     </DropdownOption>\n *   ))}\n * </Dropdown>\n * ```\n *\n * @example\n * ```tsx\n * // Controlled open state\n * const [isOpen, setIsOpen] = useState(false);\n * <Dropdown\n *   isOpen={isOpen}\n *   onChange={handleChange}\n *   selectedItem={selected}\n * >\n *   {options.map(opt => (\n *     <DropdownOption key={opt.id} value={opt.id}>\n *       {opt.label}\n *     </DropdownOption>\n *   ))}\n * </Dropdown>\n * ```\n *\n * @example\n * ```tsx\n * // With custom props for sub-components and forced upward placement\n * <Dropdown\n *   selectedItem={selected}\n *   onChange={handleChange}\n *   dropdownProps={{\n *     base: { id: 'my-dropdown' },\n *     toggleButton: { 'data-testid': 'dropdown-toggle' },\n *     toggleButtonArrow: { className: 'custom-arrow' },\n *     dropdownPosition: DropdownPositions.top,\n *   }}\n * >\n *   {options.map(opt => (\n *     <DropdownOption key={opt.id} value={opt.id}>\n *       {opt.label}\n *     </DropdownOption>\n *   ))}\n * </Dropdown>\n * ```\n *\n * @see {@link DropdownOption} - Child component for individual options\n * @see {@link DropdownToggle} - Toggle button component\n * @see {@link DropdownOptions} - Options menu container\n *\n * @accessibility\n * - ARIA attributes set according to WAI-ARIA combobox pattern\n * - Keyboard navigation (Arrow keys, Enter, Escape)\n * - Click outside to close\n * - Screen reader friendly\n * - Focus management\n *\n * @see https://www.w3.org/WAI/ARIA/apg/example-index/combobox/combobox-select-only.html\n */\nconst Dropdown = <T extends DropdownOptionProps>({\n  selectedItem,\n  disabled,\n  isDisabled,\n  isOpen: isInitOpen,\n  children,\n  onChange: handleChange,\n  className,\n  placeholder = 'Select something',\n  maxHeight = 200,\n  avatarBorder = false,\n  label,\n  helperText,\n  errors,\n  success,\n  icon,\n  width,\n  dropdownProps: componentProps,\n}: DropdownProps<T>) => {\n  const isDropdownDisabled = resolveDisabled('Dropdown', disabled, isDisabled);\n  const status = success ? 'success' : errors ? 'error' : 'basic';\n  const { dropdownPosition = DropdownPositions.auto } = componentProps ?? {};\n  // `width` has no default: without it every level keeps shrink-wrapping, which\n  // is the historical behaviour. When set, all three nested levels\n  // (wrapper -> base -> toggle) have to be stretched — sizing only one is a\n  // no-op, because the level above it is still sized to its content.\n  //\n  // Only the outermost level gets the requested value; the inner two get 100%.\n  // Repeating the value would compound relative units: `width=\"60%\"` would\n  // otherwise render the base at 60% of the wrapper and the toggle at 60% of\n  // that, i.e. 21.6% of the container.\n  //\n  // Spread rather than passed as `css={...}`: Emotion wraps an element whenever\n  // `css` is present in its props, even when its value is undefined, and that\n  // re-serializes any incoming `className` (e.g. from `styled(Dropdown)`).\n  // Omitting the key keeps the no-width path identical to writing no `css` prop.\n  const wrapperCssProps = width === undefined ? undefined : { css: { width } };\n  const baseCssProps =\n    width === undefined ? undefined : { css: { width: '100%' } };\n  const toggleCssProps =\n    width === undefined\n      ? undefined\n      : { css: [{ width: '100%' }, componentProps?.toggleButton?.css] };\n\n  const theme = useTheme();\n  const dropdownRef = useRef<HTMLDivElement>(null);\n  const listRef = useRef<HTMLUListElement>(null);\n\n  const dropdownId = useId();\n  const options: T[] = [];\n\n  const [isFocused, setIsFocused] = useState(false);\n  const [isOpen, setIsOpen] = useState(isInitOpen || false);\n  const [colors, setColors] = useState<Array<string | undefined>>([]);\n  const [activeItem, setActiveItem] = useState<T | undefined>(selectedItem);\n  const [placement, setPlacement] = useState<'top' | 'bottom'>('bottom');\n\n  const onChange: DropdownContextType['onChange'] = (item) => {\n    const innerItem = options.filter((option) => option.value === item)[0];\n\n    setIsOpen(false);\n\n    if (isDropdownDisabled || !innerItem) {\n      return;\n    }\n\n    if (innerItem.value === activeItem?.value) {\n      return;\n    }\n\n    setActiveItem(innerItem);\n    if (handleChange) {\n      handleChange(innerItem);\n    }\n  };\n\n  useClickOutside(dropdownRef, () => isOpen && setIsOpen(false));\n\n  useEffect(() => {\n    if (isDropdownDisabled) {\n      setColors([theme.colors.greyDarker60, theme.colors.grey20]);\n    } else if (isOpen) {\n      setColors([theme.colors.white, theme.colors.white60]);\n    } else if (isFocused) {\n      setColors([theme.colors.greyDarker, theme.colors.greyDarker60]);\n    }\n  }, [isOpen, isDropdownDisabled, isFocused]);\n\n  useEffect(() => {\n    setActiveItem(selectedItem);\n  }, [selectedItem]);\n\n  useEffect(() => {\n    if (isDropdownDisabled && isOpen) {\n      setIsOpen(false);\n    }\n  }, [isDropdownDisabled]);\n\n  useLayoutEffect(() => {\n    if (!isOpen || !dropdownRef.current) return;\n\n    if (dropdownPosition !== DropdownPositions.auto) {\n      setPlacement(dropdownPosition);\n      return;\n    }\n\n    const rect = dropdownRef.current.getBoundingClientRect();\n    const listHeight = listRef.current?.offsetHeight || maxHeight;\n    const spaceBelow = window.innerHeight - rect.bottom;\n    setPlacement(spaceBelow < listHeight ? 'top' : 'bottom');\n  }, [isOpen]);\n\n  const childrenArray = React.Children.toArray(children).filter(Boolean);\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const items = (childrenArray as React.ReactElement<any>[]).map(\n    (child, index) => {\n      options.push(child.props);\n\n      return React.cloneElement(child, {\n        index,\n        onClick: onChange.bind(this),\n        ...child.props,\n      });\n    },\n  );\n\n  const contextValue: DropdownContextType = React.useMemo(\n    () => ({ onChange, activeItem, maxHeight, listRef, placement }),\n    [onChange, activeItem, maxHeight, placement],\n  );\n\n  const value = (\n    activeItem\n      ? activeItem.label ||\n        activeItem.children ||\n        activeItem.value ||\n        activeItem ||\n        placeholder\n      : placeholder\n  ) as ReactNode;\n\n  const rawAvatar =\n    activeItem && (activeItem as Record<string, unknown>).avatar;\n\n  const selectedAvatar = !isNill(rawAvatar) ? (\n    typeof rawAvatar === 'string' ? (\n      <Avatar\n        size={AvatarSizes.small}\n        image={rawAvatar}\n        border={avatarBorder}\n      />\n    ) : React.isValidElement(rawAvatar) ? (\n      (rawAvatar as ReactNode)\n    ) : null\n  ) : null;\n\n  const leadingElement = !isNill(selectedAvatar) ? (\n    (selectedAvatar as ReactNode)\n  ) : icon ? (\n    <Icon\n      name={icon}\n      size={16}\n      color={isDropdownDisabled ? theme.colors.grey : theme.colors.greyDarker80}\n    />\n  ) : null;\n\n  const toggleContent = !isNill(leadingElement) ? (\n    <SelectedContent>\n      {leadingElement}\n      <span style={{ minWidth: 0 }}>{value}</span>\n    </SelectedContent>\n  ) : (\n    value\n  );\n\n  return (\n    <DropdownFieldWrapper {...wrapperCssProps}>\n      {label ? <Label disabled={isDropdownDisabled}>{label}</Label> : null}\n      <DropdownContext.Provider value={contextValue}>\n        <DropdownBase\n          {...componentProps?.base}\n          {...baseCssProps}\n          ref={dropdownRef}\n          data-testid=\"dropdown\">\n          <DropdownToggle\n            {...componentProps?.toggleButton}\n            {...toggleCssProps}\n            className={className}\n            isOpen={isOpen}\n            disabled={isDropdownDisabled}\n            status={status}\n            onClick={setIsOpen.bind(null, !isOpen)}\n            onFocus={setIsFocused.bind(null, true)}\n            colors={colors}\n            aria-labelledby={`dropdown-label-${dropdownId}`}\n            aria-controls={`dropdown-popup-${dropdownId}`}>\n            {toggleContent}\n            <DropdownArrow\n              {...componentProps?.toggleButtonArrow}\n              isUp={isOpen}\n            />\n          </DropdownToggle>\n\n          {isOpen ? <DropdownOptions>{items}</DropdownOptions> : null}\n        </DropdownBase>\n      </DropdownContext.Provider>\n      {helperText || errors ? (\n        <FormHelperText\n          role=\"status\"\n          status={status}\n          disabled={isDropdownDisabled}>\n          {errors?.message || helperText}\n        </FormHelperText>\n      ) : null}\n    </DropdownFieldWrapper>\n  );\n};\n\nexport default Dropdown;\n"]} */",
   toString: Dropdown_EMOTION_STRINGIFIED_CSS_ERROR_
 });
 const SelectedContent = /*#__PURE__*/base_default()("span", process.env.NODE_ENV === "production" ? {
@@ -25874,7 +25874,7 @@ const SelectedContent = /*#__PURE__*/base_default()("span", process.env.NODE_ENV
   styles: "display:inline-flex;align-items:center;gap:8px;flex-shrink:0;min-width:0"
 } : {
   name: "p07vyh",
-  styles: "display:inline-flex;align-items:center;gap:8px;flex-shrink:0;min-width:0/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/ui-kit/ui-kit/packages/core/src/components/Dropdown/Dropdown.tsx"],"names":[],"mappings":"AAqCmC","file":"/home/runner/work/ui-kit/ui-kit/packages/core/src/components/Dropdown/Dropdown.tsx","sourcesContent":["import React, {\n  useState,\n  useEffect,\n  useLayoutEffect,\n  useRef,\n  useId,\n  ReactNode,\n} from 'react';\nimport styled from '@emotion/styled';\nimport { useTheme } from '@emotion/react';\nimport { useClickOutside } from '@ssa-ui-kit/hooks';\nimport { isNill } from '@ssa-ui-kit/utils';\n\nimport DropdownToggle from '@components/DropdownToggle';\nimport DropdownArrow from '@components/DropdownArrow';\nimport DropdownOptions from '@components/DropdownOptions';\nimport Avatar, { AvatarSizes } from '@components/Avatar';\nimport Icon from '@components/Icon';\nimport Label from '@components/Label';\nimport FormHelperText from '@components/FormHelperText';\nimport DropdownContext from '@components/Dropdown/Dropdown.context';\nimport { resolveDisabled } from '@utils/deprecation';\nimport { DropdownOptionProps } from '@components/DropdownOptions/types';\n\nimport { DropdownContextType, DropdownPositions, DropdownProps } from './types';\n\nconst DropdownFieldWrapper = styled.div`\n  display: inline-flex;\n  flex-direction: column;\n  align-items: flex-start;\n`;\n\nconst DropdownBase = styled.div`\n  display: inline-block;\n  position: relative;\n`;\n\nconst SelectedContent = styled.span`\n  display: inline-flex;\n  align-items: center;\n  gap: 8px;\n  flex-shrink: 0;\n  min-width: 0;\n`;\n\n/**\n * Dropdown - Select-like dropdown component for single selection\n *\n * A flexible dropdown component that allows users to select one option from\n * a list of choices. Uses a compound component pattern with DropdownOption\n * children. Provides keyboard navigation, accessibility features, click-outside\n * to close functionality, and automatic viewport-aware placement of the options list.\n *\n * On every open the component measures available space below the toggle button\n * and flips the list upward when there is not enough room, preventing the list\n * from being clipped by the viewport edge. This behavior can be overridden via\n * dropdownProps.dropdownPosition.\n *\n * Component structure:\n * - Dropdown (root container with context)\n *   - DropdownToggle (button that opens/closes dropdown)\n *   - DropdownOptions (menu container that appears when open)\n *     - DropdownOption (individual selectable items)\n *\n * @category Form Controls\n * @subcategory Selection\n *\n * @example\n * ```tsx\n * const items = [\n *   { id: 1, value: 'Apple' },\n *   { id: 2, value: 'Banana' },\n *   { id: 3, value: 'Cherry' },\n * ];\n *\n * <Dropdown\n *   selectedItem={items[0]}\n *   onChange={(item) => handleSelection(item)}\n *   placeholder=\"Select a fruit\"\n * >\n *   {items.map(item => (\n *     <DropdownOption key={item.id} value={item.id}>\n *       {item.value}\n *     </DropdownOption>\n *   ))}\n * </Dropdown>\n * ```\n *\n * @example\n * ```tsx\n * // Controlled open state\n * const [isOpen, setIsOpen] = useState(false);\n * <Dropdown\n *   isOpen={isOpen}\n *   onChange={handleChange}\n *   selectedItem={selected}\n * >\n *   {options.map(opt => (\n *     <DropdownOption key={opt.id} value={opt.id}>\n *       {opt.label}\n *     </DropdownOption>\n *   ))}\n * </Dropdown>\n * ```\n *\n * @example\n * ```tsx\n * // With custom props for sub-components and forced upward placement\n * <Dropdown\n *   selectedItem={selected}\n *   onChange={handleChange}\n *   dropdownProps={{\n *     base: { id: 'my-dropdown' },\n *     toggleButton: { 'data-testid': 'dropdown-toggle' },\n *     toggleButtonArrow: { className: 'custom-arrow' },\n *     dropdownPosition: DropdownPositions.top,\n *   }}\n * >\n *   {options.map(opt => (\n *     <DropdownOption key={opt.id} value={opt.id}>\n *       {opt.label}\n *     </DropdownOption>\n *   ))}\n * </Dropdown>\n * ```\n *\n * @see {@link DropdownOption} - Child component for individual options\n * @see {@link DropdownToggle} - Toggle button component\n * @see {@link DropdownOptions} - Options menu container\n *\n * @accessibility\n * - ARIA attributes set according to WAI-ARIA combobox pattern\n * - Keyboard navigation (Arrow keys, Enter, Escape)\n * - Click outside to close\n * - Screen reader friendly\n * - Focus management\n *\n * @see https://www.w3.org/WAI/ARIA/apg/example-index/combobox/combobox-select-only.html\n */\nconst Dropdown = <T extends DropdownOptionProps>({\n  selectedItem,\n  disabled,\n  isDisabled,\n  isOpen: isInitOpen,\n  children,\n  onChange: handleChange,\n  className,\n  placeholder = 'Select something',\n  maxHeight = 200,\n  avatarBorder = false,\n  label,\n  helperText,\n  errors,\n  success,\n  icon,\n  dropdownProps: componentProps,\n}: DropdownProps<T>) => {\n  const isDropdownDisabled = resolveDisabled('Dropdown', disabled, isDisabled);\n  const status = success ? 'success' : errors ? 'error' : 'basic';\n  const { dropdownPosition = DropdownPositions.auto } = componentProps ?? {};\n\n  const theme = useTheme();\n  const dropdownRef = useRef<HTMLDivElement>(null);\n  const listRef = useRef<HTMLUListElement>(null);\n\n  const dropdownId = useId();\n  const options: T[] = [];\n\n  const [isFocused, setIsFocused] = useState(false);\n  const [isOpen, setIsOpen] = useState(isInitOpen || false);\n  const [colors, setColors] = useState<Array<string | undefined>>([]);\n  const [activeItem, setActiveItem] = useState<T | undefined>(selectedItem);\n  const [placement, setPlacement] = useState<'top' | 'bottom'>('bottom');\n\n  const onChange: DropdownContextType['onChange'] = (item) => {\n    const innerItem = options.filter((option) => option.value === item)[0];\n\n    setIsOpen(false);\n\n    if (isDropdownDisabled || !innerItem) {\n      return;\n    }\n\n    if (innerItem.value === activeItem?.value) {\n      return;\n    }\n\n    setActiveItem(innerItem);\n    if (handleChange) {\n      handleChange(innerItem);\n    }\n  };\n\n  useClickOutside(dropdownRef, () => isOpen && setIsOpen(false));\n\n  useEffect(() => {\n    if (isDropdownDisabled) {\n      setColors([theme.colors.greyDarker60, theme.colors.grey20]);\n    } else if (isOpen) {\n      setColors([theme.colors.white, theme.colors.white60]);\n    } else if (isFocused) {\n      setColors([theme.colors.greyDarker, theme.colors.greyDarker60]);\n    }\n  }, [isOpen, isDropdownDisabled, isFocused]);\n\n  useEffect(() => {\n    setActiveItem(selectedItem);\n  }, [selectedItem]);\n\n  useEffect(() => {\n    if (isDropdownDisabled && isOpen) {\n      setIsOpen(false);\n    }\n  }, [isDropdownDisabled]);\n\n  useLayoutEffect(() => {\n    if (!isOpen || !dropdownRef.current) return;\n\n    if (dropdownPosition !== DropdownPositions.auto) {\n      setPlacement(dropdownPosition);\n      return;\n    }\n\n    const rect = dropdownRef.current.getBoundingClientRect();\n    const listHeight = listRef.current?.offsetHeight || maxHeight;\n    const spaceBelow = window.innerHeight - rect.bottom;\n    setPlacement(spaceBelow < listHeight ? 'top' : 'bottom');\n  }, [isOpen]);\n\n  const childrenArray = React.Children.toArray(children).filter(Boolean);\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const items = (childrenArray as React.ReactElement<any>[]).map(\n    (child, index) => {\n      options.push(child.props);\n\n      return React.cloneElement(child, {\n        index,\n        onClick: onChange.bind(this),\n        ...child.props,\n      });\n    },\n  );\n\n  const contextValue: DropdownContextType = React.useMemo(\n    () => ({ onChange, activeItem, maxHeight, listRef, placement }),\n    [onChange, activeItem, maxHeight, placement],\n  );\n\n  const value = (\n    activeItem\n      ? activeItem.label ||\n        activeItem.children ||\n        activeItem.value ||\n        activeItem ||\n        placeholder\n      : placeholder\n  ) as ReactNode;\n\n  const rawAvatar =\n    activeItem && (activeItem as Record<string, unknown>).avatar;\n\n  const selectedAvatar = !isNill(rawAvatar) ? (\n    typeof rawAvatar === 'string' ? (\n      <Avatar\n        size={AvatarSizes.small}\n        image={rawAvatar}\n        border={avatarBorder}\n      />\n    ) : React.isValidElement(rawAvatar) ? (\n      (rawAvatar as ReactNode)\n    ) : null\n  ) : null;\n\n  const leadingElement = !isNill(selectedAvatar) ? (\n    (selectedAvatar as ReactNode)\n  ) : icon ? (\n    <Icon\n      name={icon}\n      size={16}\n      color={isDropdownDisabled ? theme.colors.grey : theme.colors.greyDarker80}\n    />\n  ) : null;\n\n  const toggleContent = !isNill(leadingElement) ? (\n    <SelectedContent>\n      {leadingElement}\n      <span style={{ minWidth: 0 }}>{value}</span>\n    </SelectedContent>\n  ) : (\n    value\n  );\n\n  return (\n    <DropdownFieldWrapper>\n      {label ? <Label disabled={isDropdownDisabled}>{label}</Label> : null}\n      <DropdownContext.Provider value={contextValue}>\n        <DropdownBase\n          {...componentProps?.base}\n          ref={dropdownRef}\n          data-testid=\"dropdown\">\n          <DropdownToggle\n            {...componentProps?.toggleButton}\n            className={className}\n            isOpen={isOpen}\n            disabled={isDropdownDisabled}\n            status={status}\n            onClick={setIsOpen.bind(null, !isOpen)}\n            onFocus={setIsFocused.bind(null, true)}\n            colors={colors}\n            aria-labelledby={`dropdown-label-${dropdownId}`}\n            aria-controls={`dropdown-popup-${dropdownId}`}>\n            {toggleContent}\n            <DropdownArrow\n              {...componentProps?.toggleButtonArrow}\n              isUp={isOpen}\n            />\n          </DropdownToggle>\n\n          {isOpen ? <DropdownOptions>{items}</DropdownOptions> : null}\n        </DropdownBase>\n      </DropdownContext.Provider>\n      {helperText || errors ? (\n        <FormHelperText\n          role=\"status\"\n          status={status}\n          disabled={isDropdownDisabled}>\n          {errors?.message || helperText}\n        </FormHelperText>\n      ) : null}\n    </DropdownFieldWrapper>\n  );\n};\n\nexport default Dropdown;\n"]} */",
+  styles: "display:inline-flex;align-items:center;gap:8px;flex-shrink:0;min-width:0/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/ui-kit/ui-kit/packages/core/src/components/Dropdown/Dropdown.tsx"],"names":[],"mappings":"AAqCmC","file":"/home/runner/work/ui-kit/ui-kit/packages/core/src/components/Dropdown/Dropdown.tsx","sourcesContent":["import React, {\n  useState,\n  useEffect,\n  useLayoutEffect,\n  useRef,\n  useId,\n  ReactNode,\n} from 'react';\nimport styled from '@emotion/styled';\nimport { useTheme } from '@emotion/react';\nimport { useClickOutside } from '@ssa-ui-kit/hooks';\nimport { isNill } from '@ssa-ui-kit/utils';\n\nimport DropdownToggle from '@components/DropdownToggle';\nimport DropdownArrow from '@components/DropdownArrow';\nimport DropdownOptions from '@components/DropdownOptions';\nimport Avatar, { AvatarSizes } from '@components/Avatar';\nimport Icon from '@components/Icon';\nimport Label from '@components/Label';\nimport FormHelperText from '@components/FormHelperText';\nimport DropdownContext from '@components/Dropdown/Dropdown.context';\nimport { resolveDisabled } from '@utils/deprecation';\nimport { DropdownOptionProps } from '@components/DropdownOptions/types';\n\nimport { DropdownContextType, DropdownPositions, DropdownProps } from './types';\n\nconst DropdownFieldWrapper = styled.div`\n  display: inline-flex;\n  flex-direction: column;\n  align-items: flex-start;\n`;\n\nconst DropdownBase = styled.div`\n  display: inline-block;\n  position: relative;\n`;\n\nconst SelectedContent = styled.span`\n  display: inline-flex;\n  align-items: center;\n  gap: 8px;\n  flex-shrink: 0;\n  min-width: 0;\n`;\n\n/**\n * Dropdown - Select-like dropdown component for single selection\n *\n * A flexible dropdown component that allows users to select one option from\n * a list of choices. Uses a compound component pattern with DropdownOption\n * children. Provides keyboard navigation, accessibility features, click-outside\n * to close functionality, and automatic viewport-aware placement of the options list.\n *\n * On every open the component measures available space below the toggle button\n * and flips the list upward when there is not enough room, preventing the list\n * from being clipped by the viewport edge. This behavior can be overridden via\n * dropdownProps.dropdownPosition.\n *\n * Component structure:\n * - Dropdown (root container with context)\n *   - DropdownToggle (button that opens/closes dropdown)\n *   - DropdownOptions (menu container that appears when open)\n *     - DropdownOption (individual selectable items)\n *\n * @category Form Controls\n * @subcategory Selection\n *\n * @example\n * ```tsx\n * const items = [\n *   { id: 1, value: 'Apple' },\n *   { id: 2, value: 'Banana' },\n *   { id: 3, value: 'Cherry' },\n * ];\n *\n * <Dropdown\n *   selectedItem={items[0]}\n *   onChange={(item) => handleSelection(item)}\n *   placeholder=\"Select a fruit\"\n * >\n *   {items.map(item => (\n *     <DropdownOption key={item.id} value={item.id}>\n *       {item.value}\n *     </DropdownOption>\n *   ))}\n * </Dropdown>\n * ```\n *\n * @example\n * ```tsx\n * // Controlled open state\n * const [isOpen, setIsOpen] = useState(false);\n * <Dropdown\n *   isOpen={isOpen}\n *   onChange={handleChange}\n *   selectedItem={selected}\n * >\n *   {options.map(opt => (\n *     <DropdownOption key={opt.id} value={opt.id}>\n *       {opt.label}\n *     </DropdownOption>\n *   ))}\n * </Dropdown>\n * ```\n *\n * @example\n * ```tsx\n * // With custom props for sub-components and forced upward placement\n * <Dropdown\n *   selectedItem={selected}\n *   onChange={handleChange}\n *   dropdownProps={{\n *     base: { id: 'my-dropdown' },\n *     toggleButton: { 'data-testid': 'dropdown-toggle' },\n *     toggleButtonArrow: { className: 'custom-arrow' },\n *     dropdownPosition: DropdownPositions.top,\n *   }}\n * >\n *   {options.map(opt => (\n *     <DropdownOption key={opt.id} value={opt.id}>\n *       {opt.label}\n *     </DropdownOption>\n *   ))}\n * </Dropdown>\n * ```\n *\n * @see {@link DropdownOption} - Child component for individual options\n * @see {@link DropdownToggle} - Toggle button component\n * @see {@link DropdownOptions} - Options menu container\n *\n * @accessibility\n * - ARIA attributes set according to WAI-ARIA combobox pattern\n * - Keyboard navigation (Arrow keys, Enter, Escape)\n * - Click outside to close\n * - Screen reader friendly\n * - Focus management\n *\n * @see https://www.w3.org/WAI/ARIA/apg/example-index/combobox/combobox-select-only.html\n */\nconst Dropdown = <T extends DropdownOptionProps>({\n  selectedItem,\n  disabled,\n  isDisabled,\n  isOpen: isInitOpen,\n  children,\n  onChange: handleChange,\n  className,\n  placeholder = 'Select something',\n  maxHeight = 200,\n  avatarBorder = false,\n  label,\n  helperText,\n  errors,\n  success,\n  icon,\n  width,\n  dropdownProps: componentProps,\n}: DropdownProps<T>) => {\n  const isDropdownDisabled = resolveDisabled('Dropdown', disabled, isDisabled);\n  const status = success ? 'success' : errors ? 'error' : 'basic';\n  const { dropdownPosition = DropdownPositions.auto } = componentProps ?? {};\n  // `width` has no default: without it every level keeps shrink-wrapping, which\n  // is the historical behaviour. When set, all three nested levels\n  // (wrapper -> base -> toggle) have to be stretched — sizing only one is a\n  // no-op, because the level above it is still sized to its content.\n  //\n  // Only the outermost level gets the requested value; the inner two get 100%.\n  // Repeating the value would compound relative units: `width=\"60%\"` would\n  // otherwise render the base at 60% of the wrapper and the toggle at 60% of\n  // that, i.e. 21.6% of the container.\n  //\n  // Spread rather than passed as `css={...}`: Emotion wraps an element whenever\n  // `css` is present in its props, even when its value is undefined, and that\n  // re-serializes any incoming `className` (e.g. from `styled(Dropdown)`).\n  // Omitting the key keeps the no-width path identical to writing no `css` prop.\n  const wrapperCssProps = width === undefined ? undefined : { css: { width } };\n  const baseCssProps =\n    width === undefined ? undefined : { css: { width: '100%' } };\n  const toggleCssProps =\n    width === undefined\n      ? undefined\n      : { css: [{ width: '100%' }, componentProps?.toggleButton?.css] };\n\n  const theme = useTheme();\n  const dropdownRef = useRef<HTMLDivElement>(null);\n  const listRef = useRef<HTMLUListElement>(null);\n\n  const dropdownId = useId();\n  const options: T[] = [];\n\n  const [isFocused, setIsFocused] = useState(false);\n  const [isOpen, setIsOpen] = useState(isInitOpen || false);\n  const [colors, setColors] = useState<Array<string | undefined>>([]);\n  const [activeItem, setActiveItem] = useState<T | undefined>(selectedItem);\n  const [placement, setPlacement] = useState<'top' | 'bottom'>('bottom');\n\n  const onChange: DropdownContextType['onChange'] = (item) => {\n    const innerItem = options.filter((option) => option.value === item)[0];\n\n    setIsOpen(false);\n\n    if (isDropdownDisabled || !innerItem) {\n      return;\n    }\n\n    if (innerItem.value === activeItem?.value) {\n      return;\n    }\n\n    setActiveItem(innerItem);\n    if (handleChange) {\n      handleChange(innerItem);\n    }\n  };\n\n  useClickOutside(dropdownRef, () => isOpen && setIsOpen(false));\n\n  useEffect(() => {\n    if (isDropdownDisabled) {\n      setColors([theme.colors.greyDarker60, theme.colors.grey20]);\n    } else if (isOpen) {\n      setColors([theme.colors.white, theme.colors.white60]);\n    } else if (isFocused) {\n      setColors([theme.colors.greyDarker, theme.colors.greyDarker60]);\n    }\n  }, [isOpen, isDropdownDisabled, isFocused]);\n\n  useEffect(() => {\n    setActiveItem(selectedItem);\n  }, [selectedItem]);\n\n  useEffect(() => {\n    if (isDropdownDisabled && isOpen) {\n      setIsOpen(false);\n    }\n  }, [isDropdownDisabled]);\n\n  useLayoutEffect(() => {\n    if (!isOpen || !dropdownRef.current) return;\n\n    if (dropdownPosition !== DropdownPositions.auto) {\n      setPlacement(dropdownPosition);\n      return;\n    }\n\n    const rect = dropdownRef.current.getBoundingClientRect();\n    const listHeight = listRef.current?.offsetHeight || maxHeight;\n    const spaceBelow = window.innerHeight - rect.bottom;\n    setPlacement(spaceBelow < listHeight ? 'top' : 'bottom');\n  }, [isOpen]);\n\n  const childrenArray = React.Children.toArray(children).filter(Boolean);\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const items = (childrenArray as React.ReactElement<any>[]).map(\n    (child, index) => {\n      options.push(child.props);\n\n      return React.cloneElement(child, {\n        index,\n        onClick: onChange.bind(this),\n        ...child.props,\n      });\n    },\n  );\n\n  const contextValue: DropdownContextType = React.useMemo(\n    () => ({ onChange, activeItem, maxHeight, listRef, placement }),\n    [onChange, activeItem, maxHeight, placement],\n  );\n\n  const value = (\n    activeItem\n      ? activeItem.label ||\n        activeItem.children ||\n        activeItem.value ||\n        activeItem ||\n        placeholder\n      : placeholder\n  ) as ReactNode;\n\n  const rawAvatar =\n    activeItem && (activeItem as Record<string, unknown>).avatar;\n\n  const selectedAvatar = !isNill(rawAvatar) ? (\n    typeof rawAvatar === 'string' ? (\n      <Avatar\n        size={AvatarSizes.small}\n        image={rawAvatar}\n        border={avatarBorder}\n      />\n    ) : React.isValidElement(rawAvatar) ? (\n      (rawAvatar as ReactNode)\n    ) : null\n  ) : null;\n\n  const leadingElement = !isNill(selectedAvatar) ? (\n    (selectedAvatar as ReactNode)\n  ) : icon ? (\n    <Icon\n      name={icon}\n      size={16}\n      color={isDropdownDisabled ? theme.colors.grey : theme.colors.greyDarker80}\n    />\n  ) : null;\n\n  const toggleContent = !isNill(leadingElement) ? (\n    <SelectedContent>\n      {leadingElement}\n      <span style={{ minWidth: 0 }}>{value}</span>\n    </SelectedContent>\n  ) : (\n    value\n  );\n\n  return (\n    <DropdownFieldWrapper {...wrapperCssProps}>\n      {label ? <Label disabled={isDropdownDisabled}>{label}</Label> : null}\n      <DropdownContext.Provider value={contextValue}>\n        <DropdownBase\n          {...componentProps?.base}\n          {...baseCssProps}\n          ref={dropdownRef}\n          data-testid=\"dropdown\">\n          <DropdownToggle\n            {...componentProps?.toggleButton}\n            {...toggleCssProps}\n            className={className}\n            isOpen={isOpen}\n            disabled={isDropdownDisabled}\n            status={status}\n            onClick={setIsOpen.bind(null, !isOpen)}\n            onFocus={setIsFocused.bind(null, true)}\n            colors={colors}\n            aria-labelledby={`dropdown-label-${dropdownId}`}\n            aria-controls={`dropdown-popup-${dropdownId}`}>\n            {toggleContent}\n            <DropdownArrow\n              {...componentProps?.toggleButtonArrow}\n              isUp={isOpen}\n            />\n          </DropdownToggle>\n\n          {isOpen ? <DropdownOptions>{items}</DropdownOptions> : null}\n        </DropdownBase>\n      </DropdownContext.Provider>\n      {helperText || errors ? (\n        <FormHelperText\n          role=\"status\"\n          status={status}\n          disabled={isDropdownDisabled}>\n          {errors?.message || helperText}\n        </FormHelperText>\n      ) : null}\n    </DropdownFieldWrapper>\n  );\n};\n\nexport default Dropdown;\n"]} */",
   toString: Dropdown_EMOTION_STRINGIFIED_CSS_ERROR_
 });
 
@@ -25988,6 +25988,7 @@ const Dropdown = ({
   errors,
   success,
   icon,
+  width,
   dropdownProps: componentProps
 }) => {
   const isDropdownDisabled = resolveDisabled('Dropdown', disabled, isDisabled);
@@ -25995,6 +25996,35 @@ const Dropdown = ({
   const {
     dropdownPosition = DropdownPositions.auto
   } = componentProps ?? {};
+  // `width` has no default: without it every level keeps shrink-wrapping, which
+  // is the historical behaviour. When set, all three nested levels
+  // (wrapper -> base -> toggle) have to be stretched — sizing only one is a
+  // no-op, because the level above it is still sized to its content.
+  //
+  // Only the outermost level gets the requested value; the inner two get 100%.
+  // Repeating the value would compound relative units: `width="60%"` would
+  // otherwise render the base at 60% of the wrapper and the toggle at 60% of
+  // that, i.e. 21.6% of the container.
+  //
+  // Spread rather than passed as `css={...}`: Emotion wraps an element whenever
+  // `css` is present in its props, even when its value is undefined, and that
+  // re-serializes any incoming `className` (e.g. from `styled(Dropdown)`).
+  // Omitting the key keeps the no-width path identical to writing no `css` prop.
+  const wrapperCssProps = width === undefined ? undefined : {
+    css: {
+      width
+    }
+  };
+  const baseCssProps = width === undefined ? undefined : {
+    css: {
+      width: '100%'
+    }
+  };
+  const toggleCssProps = width === undefined ? undefined : {
+    css: [{
+      width: '100%'
+    }, componentProps?.toggleButton?.css]
+  };
   const theme = (0,react_namespaceObject.useTheme)();
   const dropdownRef = (0,external_react_.useRef)(null);
   const listRef = (0,external_react_.useRef)(null);
@@ -26087,6 +26117,7 @@ const Dropdown = ({
     })]
   }) : value;
   return (0,jsx_runtime_namespaceObject.jsxs)(DropdownFieldWrapper, {
+    ...wrapperCssProps,
     children: [label ? (0,jsx_runtime_namespaceObject.jsx)(Label_Label, {
       disabled: isDropdownDisabled,
       children: label
@@ -26094,10 +26125,12 @@ const Dropdown = ({
       value: contextValue,
       children: (0,jsx_runtime_namespaceObject.jsxs)(DropdownBase, {
         ...componentProps?.base,
+        ...baseCssProps,
         ref: dropdownRef,
         "data-testid": "dropdown",
         children: [(0,jsx_runtime_namespaceObject.jsxs)(DropdownToggle_DropdownToggle, {
           ...componentProps?.toggleButton,
+          ...toggleCssProps,
           className: className,
           isOpen: isOpen,
           disabled: isDropdownDisabled,
@@ -26365,7 +26398,7 @@ const DropdownPlaceholderLabel = /*#__PURE__*/base_default()("div", process.env.
   styles: "white-space:nowrap;overflow:hidden;text-overflow:ellipsis"
 } : {
   name: "l8l8b8",
-  styles: "white-space:nowrap;overflow:hidden;text-overflow:ellipsis/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/ui-kit/ui-kit/packages/core/src/components/MultipleDropdown/MultipleDropdown.tsx"],"names":[],"mappings":"AAkB2C","file":"/home/runner/work/ui-kit/ui-kit/packages/core/src/components/MultipleDropdown/MultipleDropdown.tsx","sourcesContent":["import React, { useState, useEffect, useId, useRef } from 'react';\nimport styled from '@emotion/styled';\nimport { useClickOutside } from '@ssa-ui-kit/hooks';\nimport { mapObjIndexed } from '@ssa-ui-kit/utils';\nimport { useMergeRefs } from '@floating-ui/react';\n\nimport DropdownBase from '@components/DropdownBase';\nimport DropdownToggle from '@components/DropdownToggle';\nimport DropdownArrow from '@components/DropdownArrow';\nimport MultipleDropdownOptions from '@components/MultipleDropdownOptions';\nimport MultipleDropdownContext from '@components/MultipleDropdown/MultipleDropdown.context';\nimport { DropdownOptionProps } from '@components/DropdownOptions/types';\nimport { resolveDisabled } from '@utils/deprecation';\n\nimport { DropdownContextType, DropdownProps } from './types';\nimport { getActiveItems } from '@components/MultipleDropdown/utils';\nimport MultipleDropdownNotification from '@components/MultipleDropdownNotification';\n\nconst DropdownPlaceholderLabel = styled.div`\n  white-space: nowrap;\n  overflow: hidden;\n  text-overflow: ellipsis;\n`;\n\n/**\n * MultipleDropdown - Dropdown component for multi-select and single-select\n *\n * A flexible dropdown that lets users select one or more options from a list.\n * In multi-select mode (`isMultiple=true`, default) each option toggles independently;\n * the toggle button shows the first selected value and a `+N` badge for overflow.\n * In single-select mode (`isMultiple=false`) selecting an option closes the menu.\n * Forwards its ref to the root container div.\n *\n * Component structure:\n * - MultipleDropdown (root container with context)\n *   - DropdownToggle (button that opens/closes the menu)\n *   - MultipleDropdownOptions (menu container rendered when open)\n *     - DropdownOption (individual selectable items)\n *\n * @category Form Controls\n * @subcategory Selection\n *\n * @example\n * ```tsx\n * // Basic multi-select\n * <MultipleDropdown\n *   label=\"Fruits\"\n *   selectedItems={[{ value: 'apple' }]}\n *   onChange={(value, isSelected) => handleChange(value, isSelected)}\n * >\n *   <DropdownOption value=\"apple\">Apple</DropdownOption>\n *   <DropdownOption value=\"banana\">Banana</DropdownOption>\n *   <DropdownOption value=\"cherry\">Cherry</DropdownOption>\n * </MultipleDropdown>\n * ```\n *\n * @example\n * ```tsx\n * // Single-select mode (closes on pick)\n * <MultipleDropdown\n *   label=\"Country\"\n *   isMultiple={false}\n *   selectedItems={selected}\n *   onChange={handleChange}\n * >\n *   <DropdownOption value=\"us\">United States</DropdownOption>\n *   <DropdownOption value=\"uk\">United Kingdom</DropdownOption>\n * </MultipleDropdown>\n * ```\n *\n * @example\n * ```tsx\n * // Hide placeholder text, only show badge count\n * <MultipleDropdown\n *   label=\"Tags\"\n *   showPlaceholder={false}\n *   selectedItems={tags}\n *   onChange={handleChange}\n * >\n *   {tags.map(tag => (\n *     <DropdownOption key={tag.value} value={tag.value}>{tag.label}</DropdownOption>\n *   ))}\n * </MultipleDropdown>\n * ```\n *\n * @see {@link DropdownOption} - Child component for individual options\n * @see {@link DropdownToggle} - Toggle button component\n * @see {@link MultipleDropdownOptions} - Options menu container\n *\n * @accessibility\n * - ARIA attributes set according to WAI-ARIA combobox pattern\n * - Keyboard navigation (Arrow keys, Enter, Escape)\n * - Click outside to close\n * - Screen reader friendly with aria-expanded and aria-controls\n *\n * @see https://www.w3.org/WAI/ARIA/apg/example-index/combobox/combobox-select-only.html\n */\nfunction MultipleDropdownInner<T extends DropdownOptionProps>(\n  {\n    selectedItems = [],\n    disabled,\n    isDisabled,\n    isOpen: isInitOpen,\n    isMultiple = true,\n    placeholder = 'Select something',\n    showPlaceholder = true,\n    label,\n    children,\n    onChange: handleChange,\n    className,\n    maxHeight = 200,\n  }: DropdownProps<T>,\n  ref?: React.ForwardedRef<HTMLDivElement | null>,\n) {\n  const isDropdownDisabled = resolveDisabled(\n    'MultipleDropdown',\n    disabled,\n    isDisabled,\n  );\n  const dropdownBaseRef: React.RefObject<HTMLDivElement | null> =\n    useRef<HTMLDivElement>(null);\n  const dropdownId = useId();\n  const [isOpen, setIsOpen] = useState(isInitOpen || false);\n  const [optionsWithKey, setOptionsWithKey] = useState<\n    Record<number | string, T>\n  >({});\n  const [items, setItems] = useState<Array<React.ReactElement>>([]);\n  const [values, setValues] = useState<Array<unknown>>([]);\n  const [valuesWithoutPlaceholder, setValuesWithoutPlaceholder] = useState<\n    Array<unknown>\n  >([]);\n\n  const memoSelectedItems = React.useMemo(\n    () => selectedItems,\n    [JSON.stringify(selectedItems)],\n  );\n\n  const onChange = (item: DropdownOptionProps) => {\n    if (isDropdownDisabled || !item) {\n      return;\n    }\n    if (!isMultiple && optionsWithKey[item.value].isSelected) {\n      return;\n    }\n    let newOptionsWithKey = {};\n    let isSelected = true;\n    if (isMultiple) {\n      isSelected = !optionsWithKey[item.value].isSelected;\n      newOptionsWithKey = {\n        ...optionsWithKey,\n        [item.value]: {\n          ...optionsWithKey[item.value],\n          isSelected,\n        },\n      };\n      setOptionsWithKey(newOptionsWithKey);\n    } else {\n      newOptionsWithKey = mapObjIndexed(\n        (option) => ({\n          ...option,\n          isSelected: option.value === item.value,\n        }),\n        optionsWithKey,\n      );\n      setOptionsWithKey(newOptionsWithKey);\n      setIsOpen(false);\n    }\n\n    if (handleChange) {\n      handleChange(item.value, isSelected);\n    }\n  };\n\n  useClickOutside(dropdownBaseRef, () => isOpen && setIsOpen(false));\n\n  useEffect(() => {\n    if (isDropdownDisabled && isOpen) {\n      setIsOpen(false);\n    }\n  }, [isDropdownDisabled]);\n\n  useEffect(() => {\n    const childrenArray = React.Children.toArray(children).filter(Boolean);\n    const newOptions: T[] = [];\n    const keyedOptions: Record<number | string, T> = {};\n    const childItems = (childrenArray as React.ReactElement<T>[]).map(\n      (child, index) => {\n        const newOption = {\n          ...child.props,\n          isSelected: !!memoSelectedItems.find(\n            (selectedItem) => selectedItem.value === child.props.value,\n          ),\n        };\n        newOptions.push(newOption);\n        keyedOptions[newOption.value] = newOption;\n\n        return React.cloneElement(child, {\n          index,\n          onClick: onChange.bind(null),\n          ...child.props,\n        });\n      },\n    );\n\n    setOptionsWithKey(keyedOptions);\n    setItems(childItems);\n  }, [memoSelectedItems, children]);\n\n  const contextValue: DropdownContextType<DropdownOptionProps> = React.useMemo(\n    () => ({\n      onChange,\n      allItems: optionsWithKey,\n      isMultiple,\n      maxHeight,\n    }),\n    [onChange, optionsWithKey, isMultiple, maxHeight],\n  );\n\n  useEffect(() => {\n    const newValues = getActiveItems({ allItems: optionsWithKey, placeholder });\n    const newValuesWithoutPlaceholder = newValues.filter(\n      (item) => item !== placeholder,\n    );\n    setValues(newValues);\n    setValuesWithoutPlaceholder(newValuesWithoutPlaceholder);\n  }, [optionsWithKey]);\n\n  return (\n    <MultipleDropdownContext.Provider value={contextValue}>\n      <DropdownBase\n        ref={useMergeRefs([dropdownBaseRef, ref])}\n        data-testid=\"dropdown\">\n        <DropdownToggle\n          className={className}\n          isOpen={isOpen}\n          disabled={isDropdownDisabled}\n          onClick={setIsOpen.bind(null, !isOpen)}\n          aria-labelledby={`dropdown-label-${dropdownId}`}\n          aria-controls={`dropdown-popup-${dropdownId}`}\n          isMultiple={isMultiple}\n          selectedCount={valuesWithoutPlaceholder.length}>\n          {isMultiple ? (\n            <>\n              <DropdownPlaceholderLabel>\n                {label}\n                {showPlaceholder\n                  ? values.length > 0 && `: ${values[0]}`\n                  : valuesWithoutPlaceholder.length > 0 &&\n                    `: ${valuesWithoutPlaceholder[0]}`}\n              </DropdownPlaceholderLabel>\n              {values.length > 1 ? (\n                <MultipleDropdownNotification as={'div'}>\n                  +{values.length - 1}\n                </MultipleDropdownNotification>\n              ) : (\n                ''\n              )}\n            </>\n          ) : (\n            values.join('')\n          )}\n          <DropdownArrow isUp={isOpen} />\n        </DropdownToggle>\n\n        {isOpen ? (\n          <MultipleDropdownOptions>{items}</MultipleDropdownOptions>\n        ) : null}\n      </DropdownBase>\n    </MultipleDropdownContext.Provider>\n  );\n}\n\nconst MultipleDropdown = React.forwardRef<\n  HTMLDivElement,\n  DropdownProps<DropdownOptionProps>\n>(MultipleDropdownInner);\n\nexport default MultipleDropdown;\n"]} */",
+  styles: "white-space:nowrap;overflow:hidden;text-overflow:ellipsis/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/ui-kit/ui-kit/packages/core/src/components/MultipleDropdown/MultipleDropdown.tsx"],"names":[],"mappings":"AAkB2C","file":"/home/runner/work/ui-kit/ui-kit/packages/core/src/components/MultipleDropdown/MultipleDropdown.tsx","sourcesContent":["import React, { useState, useEffect, useId, useRef } from 'react';\nimport styled from '@emotion/styled';\nimport { useClickOutside } from '@ssa-ui-kit/hooks';\nimport { mapObjIndexed } from '@ssa-ui-kit/utils';\nimport { useMergeRefs } from '@floating-ui/react';\n\nimport DropdownBase from '@components/DropdownBase';\nimport DropdownToggle from '@components/DropdownToggle';\nimport DropdownArrow from '@components/DropdownArrow';\nimport MultipleDropdownOptions from '@components/MultipleDropdownOptions';\nimport MultipleDropdownContext from '@components/MultipleDropdown/MultipleDropdown.context';\nimport { DropdownOptionProps } from '@components/DropdownOptions/types';\nimport { resolveDisabled } from '@utils/deprecation';\n\nimport { DropdownContextType, DropdownProps } from './types';\nimport { getActiveItems } from '@components/MultipleDropdown/utils';\nimport MultipleDropdownNotification from '@components/MultipleDropdownNotification';\n\nconst DropdownPlaceholderLabel = styled.div`\n  white-space: nowrap;\n  overflow: hidden;\n  text-overflow: ellipsis;\n`;\n\n/**\n * MultipleDropdown - Dropdown component for multi-select and single-select\n *\n * A flexible dropdown that lets users select one or more options from a list.\n * In multi-select mode (`isMultiple=true`, default) each option toggles independently;\n * the toggle button shows the first selected value and a `+N` badge for overflow.\n * In single-select mode (`isMultiple=false`) selecting an option closes the menu.\n * Forwards its ref to the root container div.\n *\n * Component structure:\n * - MultipleDropdown (root container with context)\n *   - DropdownToggle (button that opens/closes the menu)\n *   - MultipleDropdownOptions (menu container rendered when open)\n *     - DropdownOption (individual selectable items)\n *\n * @category Form Controls\n * @subcategory Selection\n *\n * @example\n * ```tsx\n * // Basic multi-select\n * <MultipleDropdown\n *   label=\"Fruits\"\n *   selectedItems={[{ value: 'apple' }]}\n *   onChange={(value, isSelected) => handleChange(value, isSelected)}\n * >\n *   <DropdownOption value=\"apple\">Apple</DropdownOption>\n *   <DropdownOption value=\"banana\">Banana</DropdownOption>\n *   <DropdownOption value=\"cherry\">Cherry</DropdownOption>\n * </MultipleDropdown>\n * ```\n *\n * @example\n * ```tsx\n * // Single-select mode (closes on pick)\n * <MultipleDropdown\n *   label=\"Country\"\n *   isMultiple={false}\n *   selectedItems={selected}\n *   onChange={handleChange}\n * >\n *   <DropdownOption value=\"us\">United States</DropdownOption>\n *   <DropdownOption value=\"uk\">United Kingdom</DropdownOption>\n * </MultipleDropdown>\n * ```\n *\n * @example\n * ```tsx\n * // Hide placeholder text, only show badge count\n * <MultipleDropdown\n *   label=\"Tags\"\n *   showPlaceholder={false}\n *   selectedItems={tags}\n *   onChange={handleChange}\n * >\n *   {tags.map(tag => (\n *     <DropdownOption key={tag.value} value={tag.value}>{tag.label}</DropdownOption>\n *   ))}\n * </MultipleDropdown>\n * ```\n *\n * @see {@link DropdownOption} - Child component for individual options\n * @see {@link DropdownToggle} - Toggle button component\n * @see {@link MultipleDropdownOptions} - Options menu container\n *\n * @accessibility\n * - ARIA attributes set according to WAI-ARIA combobox pattern\n * - Keyboard navigation (Arrow keys, Enter, Escape)\n * - Click outside to close\n * - Screen reader friendly with aria-expanded and aria-controls\n *\n * @see https://www.w3.org/WAI/ARIA/apg/example-index/combobox/combobox-select-only.html\n */\nfunction MultipleDropdownInner<T extends DropdownOptionProps>(\n  {\n    selectedItems = [],\n    disabled,\n    isDisabled,\n    isOpen: isInitOpen,\n    isMultiple = true,\n    placeholder = 'Select something',\n    showPlaceholder = true,\n    label,\n    children,\n    onChange: handleChange,\n    className,\n    maxHeight = 200,\n    width,\n  }: DropdownProps<T>,\n  ref?: React.ForwardedRef<HTMLDivElement | null>,\n) {\n  const isDropdownDisabled = resolveDisabled(\n    'MultipleDropdown',\n    disabled,\n    isDisabled,\n  );\n  const dropdownBaseRef: React.RefObject<HTMLDivElement | null> =\n    useRef<HTMLDivElement>(null);\n  const dropdownId = useId();\n  // `width` has no default — without it the base and the toggle both\n  // shrink-wrap, which is the historical behaviour. When set it has to clear\n  // the base's `min-width` and the multiple toggle's `max-width`, otherwise\n  // those caps silently win over the explicit value.\n  //\n  // Only the outer base gets the requested value; the toggle gets 100%.\n  // Repeating the value would compound relative units: `width=\"60%\"` would\n  // otherwise render the toggle at 60% of an already-60% base.\n  //\n  // Spread rather than passed as `css={...}`: Emotion wraps an element whenever\n  // `css` is present in its props, even when its value is undefined, and that\n  // re-serializes any incoming `className` (e.g. from\n  // `styled(MultipleDropdown)`). Omitting the key keeps the no-width path\n  // identical to writing no `css` prop.\n  const baseCssProps =\n    width === undefined ? undefined : { css: { width, minWidth: 0 } };\n  const toggleCssProps =\n    width === undefined\n      ? undefined\n      : { css: { width: '100%', maxWidth: 'none' } };\n  const [isOpen, setIsOpen] = useState(isInitOpen || false);\n  const [optionsWithKey, setOptionsWithKey] = useState<\n    Record<number | string, T>\n  >({});\n  const [items, setItems] = useState<Array<React.ReactElement>>([]);\n  const [values, setValues] = useState<Array<unknown>>([]);\n  const [valuesWithoutPlaceholder, setValuesWithoutPlaceholder] = useState<\n    Array<unknown>\n  >([]);\n\n  const memoSelectedItems = React.useMemo(\n    () => selectedItems,\n    [JSON.stringify(selectedItems)],\n  );\n\n  const onChange = (item: DropdownOptionProps) => {\n    if (isDropdownDisabled || !item) {\n      return;\n    }\n    if (!isMultiple && optionsWithKey[item.value].isSelected) {\n      return;\n    }\n    let newOptionsWithKey = {};\n    let isSelected = true;\n    if (isMultiple) {\n      isSelected = !optionsWithKey[item.value].isSelected;\n      newOptionsWithKey = {\n        ...optionsWithKey,\n        [item.value]: {\n          ...optionsWithKey[item.value],\n          isSelected,\n        },\n      };\n      setOptionsWithKey(newOptionsWithKey);\n    } else {\n      newOptionsWithKey = mapObjIndexed(\n        (option) => ({\n          ...option,\n          isSelected: option.value === item.value,\n        }),\n        optionsWithKey,\n      );\n      setOptionsWithKey(newOptionsWithKey);\n      setIsOpen(false);\n    }\n\n    if (handleChange) {\n      handleChange(item.value, isSelected);\n    }\n  };\n\n  useClickOutside(dropdownBaseRef, () => isOpen && setIsOpen(false));\n\n  useEffect(() => {\n    if (isDropdownDisabled && isOpen) {\n      setIsOpen(false);\n    }\n  }, [isDropdownDisabled]);\n\n  useEffect(() => {\n    const childrenArray = React.Children.toArray(children).filter(Boolean);\n    const newOptions: T[] = [];\n    const keyedOptions: Record<number | string, T> = {};\n    const childItems = (childrenArray as React.ReactElement<T>[]).map(\n      (child, index) => {\n        const newOption = {\n          ...child.props,\n          isSelected: !!memoSelectedItems.find(\n            (selectedItem) => selectedItem.value === child.props.value,\n          ),\n        };\n        newOptions.push(newOption);\n        keyedOptions[newOption.value] = newOption;\n\n        return React.cloneElement(child, {\n          index,\n          onClick: onChange.bind(null),\n          ...child.props,\n        });\n      },\n    );\n\n    setOptionsWithKey(keyedOptions);\n    setItems(childItems);\n  }, [memoSelectedItems, children]);\n\n  const contextValue: DropdownContextType<DropdownOptionProps> = React.useMemo(\n    () => ({\n      onChange,\n      allItems: optionsWithKey,\n      isMultiple,\n      maxHeight,\n    }),\n    [onChange, optionsWithKey, isMultiple, maxHeight],\n  );\n\n  useEffect(() => {\n    const newValues = getActiveItems({ allItems: optionsWithKey, placeholder });\n    const newValuesWithoutPlaceholder = newValues.filter(\n      (item) => item !== placeholder,\n    );\n    setValues(newValues);\n    setValuesWithoutPlaceholder(newValuesWithoutPlaceholder);\n  }, [optionsWithKey]);\n\n  return (\n    <MultipleDropdownContext.Provider value={contextValue}>\n      <DropdownBase\n        {...baseCssProps}\n        ref={useMergeRefs([dropdownBaseRef, ref])}\n        data-testid=\"dropdown\">\n        <DropdownToggle\n          {...toggleCssProps}\n          className={className}\n          isOpen={isOpen}\n          disabled={isDropdownDisabled}\n          onClick={setIsOpen.bind(null, !isOpen)}\n          aria-labelledby={`dropdown-label-${dropdownId}`}\n          aria-controls={`dropdown-popup-${dropdownId}`}\n          isMultiple={isMultiple}\n          selectedCount={valuesWithoutPlaceholder.length}>\n          {isMultiple ? (\n            <>\n              <DropdownPlaceholderLabel>\n                {label}\n                {showPlaceholder\n                  ? values.length > 0 && `: ${values[0]}`\n                  : valuesWithoutPlaceholder.length > 0 &&\n                    `: ${valuesWithoutPlaceholder[0]}`}\n              </DropdownPlaceholderLabel>\n              {values.length > 1 ? (\n                <MultipleDropdownNotification as={'div'}>\n                  +{values.length - 1}\n                </MultipleDropdownNotification>\n              ) : (\n                ''\n              )}\n            </>\n          ) : (\n            values.join('')\n          )}\n          <DropdownArrow isUp={isOpen} />\n        </DropdownToggle>\n\n        {isOpen ? (\n          <MultipleDropdownOptions>{items}</MultipleDropdownOptions>\n        ) : null}\n      </DropdownBase>\n    </MultipleDropdownContext.Provider>\n  );\n}\n\nconst MultipleDropdown = React.forwardRef<\n  HTMLDivElement,\n  DropdownProps<DropdownOptionProps>\n>(MultipleDropdownInner);\n\nexport default MultipleDropdown;\n"]} */",
   toString: MultipleDropdown_EMOTION_STRINGIFIED_CSS_ERROR_
 });
 
@@ -26454,11 +26487,38 @@ function MultipleDropdownInner({
   children,
   onChange: handleChange,
   className,
-  maxHeight = 200
+  maxHeight = 200,
+  width
 }, ref) {
   const isDropdownDisabled = resolveDisabled('MultipleDropdown', disabled, isDisabled);
   const dropdownBaseRef = (0,external_react_.useRef)(null);
   const dropdownId = (0,external_react_.useId)();
+  // `width` has no default — without it the base and the toggle both
+  // shrink-wrap, which is the historical behaviour. When set it has to clear
+  // the base's `min-width` and the multiple toggle's `max-width`, otherwise
+  // those caps silently win over the explicit value.
+  //
+  // Only the outer base gets the requested value; the toggle gets 100%.
+  // Repeating the value would compound relative units: `width="60%"` would
+  // otherwise render the toggle at 60% of an already-60% base.
+  //
+  // Spread rather than passed as `css={...}`: Emotion wraps an element whenever
+  // `css` is present in its props, even when its value is undefined, and that
+  // re-serializes any incoming `className` (e.g. from
+  // `styled(MultipleDropdown)`). Omitting the key keeps the no-width path
+  // identical to writing no `css` prop.
+  const baseCssProps = width === undefined ? undefined : {
+    css: {
+      width,
+      minWidth: 0
+    }
+  };
+  const toggleCssProps = width === undefined ? undefined : {
+    css: {
+      width: '100%',
+      maxWidth: 'none'
+    }
+  };
   const [isOpen, setIsOpen] = (0,external_react_.useState)(isInitOpen || false);
   const [optionsWithKey, setOptionsWithKey] = (0,external_react_.useState)({});
   const [items, setItems] = (0,external_react_.useState)([]);
@@ -26540,9 +26600,11 @@ function MultipleDropdownInner({
   return (0,jsx_runtime_namespaceObject.jsx)(MultipleDropdown_context.Provider, {
     value: contextValue,
     children: (0,jsx_runtime_namespaceObject.jsxs)(components_DropdownBase_DropdownBase, {
+      ...baseCssProps,
       ref: (0,external_floating_ui_react_namespaceObject.useMergeRefs)([dropdownBaseRef, ref]),
       "data-testid": "dropdown",
       children: [(0,jsx_runtime_namespaceObject.jsxs)(DropdownToggle_DropdownToggle, {
+        ...toggleCssProps,
         className: className,
         isOpen: isOpen,
         disabled: isDropdownDisabled,