@vibe/core 3.85.0 → 3.86.0

package/dist/components/Combobox/components/ComboboxOption/ComboboxOption.d.ts

@@ -1,5 +1,5 @@
 import React, { type RefObject } from "react";
-import { ComboboxOptionIconType as ComboboxOptionIconTypeEnum, type IComboboxOption, type IComboboxOptionEvents } from "../ComboboxConstants";
+import { type IComboboxOption, type IComboboxOptionEvents } from "../ComboboxConstants";
 export interface ComboboxOptionProps extends IComboboxOptionEvents {
     /**
      * The index of the option in the list.
@@ -42,7 +42,5 @@ export interface ComboboxOptionProps extends IComboboxOptionEvents {
      */
     optionRenderer?: (option: IComboboxOption) => JSX.Element;
 }
-declare const _default: React.FC<ComboboxOptionProps> & {
-    iconTypes: typeof ComboboxOptionIconTypeEnum;
-};
-export default _default;
+declare const ComboboxOption: ({ index, option, className, isActive, visualFocus, scrollRef, scrollOffset, onOptionClick, onOptionLeave, onOptionHover, optionLineHeight, shouldScrollWhenActive, optionRenderer }: ComboboxOptionProps) => React.JSX.Element;
+export default ComboboxOption;

package/dist/components/Counter/Counter.d.ts

@@ -1,5 +1,4 @@
 import React from "react";
-import { CounterColor as CounterColorEnum, CounterSize as CounterSizeEnum, CounterType as CounterTypeEnum } from "./CounterConstants";
 import { type CounterColor, type CounterSize, type CounterType } from "./Counter.types";
 import { type VibeComponentProps } from "../../types";
 export interface CounterProps extends VibeComponentProps {
@@ -48,9 +47,5 @@ export interface CounterProps extends VibeComponentProps {
      */
     noAnimation?: boolean;
 }
-declare const _default: React.FC<CounterProps> & {
-    sizes: typeof CounterSizeEnum;
-    colors: typeof CounterColorEnum;
-    kinds: typeof CounterTypeEnum;
-};
-export default _default;
+declare const Counter: ({ className, counterClassName, count, size, kind, color, maxDigits, ariaLabeledBy, ariaLabel, id, prefix, onMouseDown, noAnimation, "data-testid": dataTestId }: CounterProps) => React.JSX.Element;
+export default Counter;

package/dist/components/DatePicker/DatePicker.d.ts

@@ -1,66 +1,8 @@
-import React from "react";
-import "react-dates/initialize.js";
-import { type DayOfWeekShape, type DayPickerPhrases } from "react-dates";
-import { type Moment, type RangeDate } from "./types";
-import { type VibeComponentProps } from "../../types";
-import "./external_datepicker.scss";
-export interface DatePickerProps extends VibeComponentProps {
-    /**
-     * The first day of the week to display.
-     */
-    firstDayOfWeek?: DayOfWeekShape;
-    /**
-     * The currently selected date.
-     */
-    date?: Moment;
-    /**
-     * The end date for range selection mode.
-     */
-    endDate?: Moment;
-    /**
-     * Callback fired when a date is selected.
-     */
-    onPickDate?: (date: Moment | RangeDate) => void;
-    /**
-     * If true, hides the navigation buttons.
-     */
-    hideNavigationKeys?: boolean;
-    /**
-     * If true, allows selecting days outside the current month.
-     */
-    enableOutsideDays?: boolean;
-    /**
-     * If true, displays a column with week numbers.
-     */
-    showWeekNumber?: boolean;
-    /**
-     * The size of a single day cell.
-     */
-    daySize?: number;
-    /**
-     * Function to determine if a specific day should be disabled.
-     */
-    shouldBlockDay?: (date: Moment) => boolean;
-    /**
-     * If true, enables date range selection mode.
-     */
-    range?: boolean;
-    /**
-     * Custom phrases for accessibility and aria-labels.
-     */
-    phrases?: DayPickerPhrases;
-    /**
-     * The number of months displayed in the calendar.
-     */
-    numberOfMonths?: number;
-    /**
-     * Function to determine if a specific year should be disabled.
-     */
-    shouldBlockYear?: (year: number) => boolean;
-    /**
-     * Function to determine if a specific date range should be disabled.
-     */
-    shouldBlockRange?: (date: Moment) => boolean;
-}
-declare const DatePicker: React.ForwardRefExoticComponent<DatePickerProps & React.RefAttributes<HTMLDivElement>>;
+import { type FC } from "react";
+import { type DatePickerProps } from "./DatePicker.types";
+export declare const DEFAULT_TIME: {
+    hours: number;
+    minutes: number;
+};
+declare const DatePicker: FC<DatePickerProps>;
 export default DatePicker;

package/dist/components/DatePicker/index.d.ts

@@ -1 +1,2 @@
-export { default as DatePicker, type DatePickerProps } from "./DatePicker";
+export { default as DatePicker } from "./DatePicker";
+export * from "./DatePicker.types";

package/dist/components/Divider/Divider.d.ts

@@ -1,5 +1,4 @@
 import React from "react";
-import { DirectionType as DirectionTypeEnum } from "./DividerConstants";
 import { type DividerDirection } from "./Divider.types";
 import { type VibeComponentProps } from "../../types";
 export interface DividerProps extends VibeComponentProps {
@@ -12,7 +11,5 @@ export interface DividerProps extends VibeComponentProps {
      */
     withoutMargin?: boolean;
 }
-declare const _default: React.FC<DividerProps> & {
-    directions: typeof DirectionTypeEnum;
-};
-export default _default;
+declare const Divider: ({ className, withoutMargin, direction, id, "data-testid": dataTestId }: DividerProps) => React.JSX.Element;
+export default Divider;

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

@@ -1,13 +1,7 @@
-import { BaseSizes } from "../../constants";
 import React from "react";
-import { createFilter } from "react-select";
-import { DROPDOWN_CHIP_COLORS, DROPDOWN_MENU_PLACEMENT, DROPDOWN_MENU_POSITION } from "./DropdownConstants";
-import { type DropdownComponentProps } from "./Dropdown.types";
-declare const _default: React.ForwardRefExoticComponent<DropdownComponentProps & React.RefAttributes<HTMLElement>> & {
-    sizes: typeof BaseSizes;
-    chipColors: typeof DROPDOWN_CHIP_COLORS;
-    menuPlacements: typeof DROPDOWN_MENU_PLACEMENT;
-    menuPositions: typeof DROPDOWN_MENU_POSITION;
-    createFilter: typeof createFilter;
-};
+import { type BaseDropdownProps } from "./Dropdown.types";
+import { type BaseItemData } from "../BaseItem";
+declare const _default: <Item extends BaseItemData<Record<string, unknown>>>(props: BaseDropdownProps<Item> & {
+    ref?: React.ForwardedRef<HTMLDivElement>;
+}) => React.ReactElement;
 export default _default;

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

@@ -1,323 +1,268 @@
-import { type ActionMeta, type FocusEventHandler, type InputActionMeta, type KeyboardEventHandler, type MenuProps, type OptionProps, type OptionTypeBase, type SingleValueProps } from "react-select";
-import { type UIEventHandler, type WheelEventHandler } from "react";
 import type React from "react";
+import { type DropdownListGroup } from "./components/DropdownBaseList/DropdownBaseList.types";
 import { type VibeComponentProps } from "../../types";
-export type DropdownOption = any;
-export interface CustomSingleValueProps extends SingleValueProps<DropdownOption> {
+import { type BaseItemData } from "../BaseItem";
+import { type TooltipProps } from "@vibe/tooltip";
+export type DropdownOption<Item = Record<string, unknown>> = BaseItemData<Item>;
+export type DropdownGroupOption<Item = Record<string, unknown>> = DropdownListGroup<Item>[] | BaseItemData<Item>[];
+interface MultiSelectSpecifics<Item extends BaseItemData<Record<string, unknown>>> {
     /**
-     * The component used to render the selected value.
+     * If true, the dropdown allows multiple selections.
      */
-    Renderer: React.ComponentType;
+    multi: true;
+    multiline?: boolean;
     /**
-     * If true, the dropdown is read-only and cannot be edited.
+     * Callback fired when an option is removed in multi-select mode. Only available when multi is true.
      */
-    readOnly: boolean;
+    onOptionRemove?: (option: Item) => void;
     /**
-     * The currently selected option.
+     * The function to call to render the selected value on single select mode.
      */
-    selectedOption: DropdownOption;
-}
-export interface CustomMenuBaseProps {
+    valueRenderer?: never;
     /**
-     * Class name applied to the dropdown menu wrapper.
+     * The default selected values for multi-select.
      */
-    dropdownMenuWrapperClassName?: string;
+    defaultValue?: Item[];
     /**
-     * The ID of the menu container.
+     * The controlled selected values for multi-select.
      */
-    menuId?: string;
+    value?: Item[];
     /**
-     * The ARIA label for the menu container.
+     * Callback fired when the selected values change in multi-select mode.
      */
-    menuAriaLabel?: string;
+    onChange?: (options: Item[]) => void;
     /**
-     * The ARIA label for the dropdown input.
+     * Minimum number of selected chips to always show before overflowing to the counter.
      */
-    inputAriaLabel?: string;
+    minVisibleCount?: number;
 }
-export type CustomMenuProps = CustomMenuBaseProps & MenuProps<OptionTypeBase, boolean>;
-export interface CustomOptionBaseProps {
-    optionWrapperClassName?: string;
-}
-export type CustomOptionProps = CustomOptionBaseProps & OptionProps<OptionTypeBase, boolean>;
-export type DropdownState = {
-    isDisabled: boolean;
-    selectProps: {
-        readOnly: boolean;
-    };
-};
-export interface DropdownComponentProps extends CustomMenuBaseProps, CustomOptionBaseProps, VibeComponentProps {
-    /**
-     * Class name applied to the dropdown's single value wrapper.
-     */
-    singleValueWrapperClassName?: string;
-    /**
-     * Placeholder text displayed when no value is selected.
-     */
-    placeholder?: string;
-    /**
-     * If true, the placeholder will be truncated with an ellipsis when too long.
-     */
-    allowPlaceholderEllipsis?: boolean;
+interface SingleSelectSpecifics<Item extends BaseItemData<Record<string, unknown>>> {
     /**
-     * If true, the dropdown is disabled.
+     * If true, the dropdown allows multiple selections. Defaults to false.
      */
-    disabled?: boolean;
+    multi?: false;
     /**
-     * If true, the dropdown is read-only and cannot be edited.
+     * If true, the dropdown allows multiple lines of selected items. (Not available for single select)
      */
-    readOnly?: boolean;
+    multiline?: never;
     /**
-     * Callback fired when the dropdown menu opens.
+     * Callback fired when an option is removed in multi-select mode. (Not available for single select)
      */
-    onMenuOpen?: () => void;
+    onOptionRemove?: never;
     /**
-     * Callback fired when the dropdown menu closes.
+     * The function to call to render the selected value on single select mode.
      */
-    onMenuClose?: () => void;
+    valueRenderer?: (option: Item) => React.ReactNode;
     /**
-     * Callback fired when a key is pressed inside the dropdown.
+     * The default selected value for single-select.
      */
-    onKeyDown?: KeyboardEventHandler;
+    defaultValue?: Item;
     /**
-     * Callback fired when the dropdown gains focus.
+     * The controlled selected value for single-select.
      */
-    onFocus?: FocusEventHandler;
+    value?: Item;
     /**
-     * Callback fired when the dropdown loses focus.
+     * Callback fired when the selected value changes in single-select mode.
      */
-    onBlur?: FocusEventHandler;
+    onChange?: (option: Item) => void;
     /**
-     * Callback fired when scrolling inside the dropdown.
+     * Minimum number of selected chips to always show before overflowing to the counter. (Not available for single select)
      */
-    onScroll?: UIEventHandler<HTMLDivElement>;
+    minVisibleCount?: never;
+}
+type BoxModeConstraint = {
     /**
-     * Callback fired when the user scrolls to the bottom of the menu.
+     * If true, the dropdown is searchable.
      */
-    onMenuScrollToBottom?: WheelEventHandler<HTMLDivElement>;
+    searchable?: false;
     /**
-     * If true, prevents scrolling beyond the menu's boundaries.
+     * If true, the dropdown menu is displayed inline without a popup/dialog.
      */
-    captureMenuScroll?: boolean;
+    boxMode?: false;
+} | {
     /**
-     * Callback fired when the selected value changes.
+     * If true, the dropdown is searchable.
      */
-    onChange?: (option: DropdownOption | DropdownOption[], meta: ActionMeta<DropdownOption> | React.MouseEvent | React.KeyboardEvent) => void;
+    searchable: true;
     /**
-     * Callback fired when the dropdown input value changes.
+     * If true, the dropdown menu is displayed inline without a popup/dialog.
      */
-    onInputChange?: (newValue: string, actionMeta: InputActionMeta) => void;
+    boxMode?: boolean;
+};
+export type BaseDropdownProps<Item extends BaseItemData<Record<string, unknown>>> = VibeComponentProps & BoxModeConstraint & {
     /**
-     * If true, enables search functionality within the dropdown.
+     * The list of options available in the list.
      */
-    searchable?: boolean;
+    options: DropdownGroupOption<Item>;
     /**
-     * The list of options available in the dropdown.
+     * Props to be passed to the Tooltip component that wraps the dropdown.
      */
-    options?: DropdownOption[];
+    tooltipProps?: Partial<TooltipProps>;
     /**
-     * Function to customize the "no options found" message.
+     * If true, displays dividers between grouped options.
      */
-    noOptionsMessage?: (obj: {
-        inputValue: string;
-    }) => string | null;
+    withGroupDivider?: boolean;
     /**
-     * If true, the menu opens when the dropdown gains focus.
+     * If true, makes the group title sticky.
      */
-    openMenuOnFocus?: boolean;
+    stickyGroupTitle?: boolean;
     /**
-     * If true, the menu opens when the dropdown is clicked.
+     * The size of the dropdown.
      */
-    openMenuOnClick?: boolean;
+    size?: DropdownSizes;
     /**
-     * If true, displays a clear button inside the dropdown's input.
+     * The direction of the dropdown.
      */
-    clearable?: boolean;
+    dir?: DropdownDirection;
     /**
-     * Custom renderer for each option.
+     * If true, the dropdown has no visible border by default, but shows border on hover, focus, and active states.
      */
-    optionRenderer?: (option: DropdownOption) => JSX.Element;
+    borderless?: boolean;
     /**
-     * Custom renderer for the selected value.
+     * The function to call to render an option.
      */
-    valueRenderer?: React.ReactNode | ((props: Omit<CustomSingleValueProps, "Renderer"> & DropdownOption) => React.ReactNode);
+    optionRenderer?: (option: Item) => React.ReactNode;
     /**
-     *   Custom renderer for the selected value.
+     * The function to call to render the menu.
      */
-    ValueRenderer?: React.ReactNode;
+    menuRenderer?: (props: {
+        children: React.ReactNode;
+        filteredOptions: DropdownListGroup<Item>[];
+        selectedItems: Item[];
+        getItemProps: (options: any) => Record<string, unknown>;
+    }) => React.ReactNode;
     /**
-     * Custom renderer for the dropdown menu.
+     * The message to display when there are no options.
      */
-    menuRenderer?: React.ReactElement | ((props: CustomMenuProps) => React.ReactElement);
+    noOptionsMessage?: string | React.ReactNode;
     /**
-     * The placement of the dropdown menu relative to the input.
+     * The placeholder to display when the dropdown is empty.
      */
-    menuPlacement?: DropdownMenuPlacement;
+    placeholder?: string;
     /**
-     * The CSS position property of the dropdown menu.
+     * If true, the dropdown is disabled.
      */
-    menuPosition?: DropdownMenuPosition;
+    disabled?: boolean;
     /**
-     * If true, the dropdown is displayed in right-to-left mode.
+     * If true, the dropdown is read only.
      */
-    rtl?: boolean;
+    readOnly?: boolean;
     /**
-     * The default selected value.
+     * If true, the dropdown is in an error state.
      */
-    defaultValue?: DropdownOption[];
+    error?: boolean;
     /**
-     * The controlled value of the dropdown.
+     * The helper text to display below the dropdown.
      */
-    value?: DropdownOption | DropdownOption[];
+    helperText?: string;
     /**
-     * The size of the dropdown.
+     * If true, the dropdown is required.
      */
-    size?: DropdownSize;
+    required?: boolean;
     /**
-     * Enables async loading of options.
+     * The label to display above the dropdown.
      */
-    asyncOptions?: (inputValue: string) => Promise<DropdownOption[]>;
+    label?: string;
     /**
-     * If true, caches async-loaded options.
+     * The ARIA label for the dropdown.
      */
-    cacheOptions?: boolean;
+    ariaLabel?: string;
     /**
-     * If true, `asyncOptions` is invoked on mount.
+     * The ARIA label for the dropdown input.
      */
-    defaultOptions?: boolean | DropdownOption[];
+    inputAriaLabel?: string;
     /**
-     * If true, enables virtualization for improved performance.
+     * The ARIA label for the menu container.
      */
-    isVirtualized?: boolean;
+    menuAriaLabel?: string;
     /**
-     * The target element for the dropdown menu portal.
+     * The ARIA label for the clear button.
      */
-    menuPortalTarget?: HTMLElement;
+    clearAriaLabel?: string;
     /**
-     * Custom styles for the dropdown.
+     * The current value of the input field.
      */
-    extraStyles?: (...args: unknown[]) => unknown;
+    inputValue?: string;
     /**
-     * The maximum height of the menu before scrolling.
+     * The maximum height of the dropdown menu.
      */
     maxMenuHeight?: number;
     /**
-     * The tab index of the dropdown for keyboard navigation.
-     */
-    tabIndex?: number | string;
-    /**
-     * If true, the dropdown input is automatically focused on mount.
-     */
-    autoFocus?: boolean;
-    /**
-     * If true, enables multi-select mode.
-     * When in multi-select mode, the selected value will be an array,
-     * and it will be displayed as our [`<Chips>`](/?path=/docs/components-chips--sandbox) component.
-     */
-    multi?: boolean;
-    /**
-     * If true, expands the dropdown to multiple lines when multiple values are selected.
+     * If true, controls the menu open state.
      */
-    multiline?: boolean;
+    isMenuOpen?: boolean;
     /**
      * If true, closes the menu when an option is selected.
      */
     closeMenuOnSelect?: boolean;
     /**
-     * If true, closes the menu when scrolling.
-     */
-    closeMenuOnScroll?: boolean;
-    /**
-     * Callback fired when an option is removed in multi-select mode.
-     */
-    onOptionRemove?: (option?: DropdownOption) => void;
-    /**
-     * If true, prevents mandatory default options from being removed.
-     */
-    withMandatoryDefaultOptions?: boolean;
-    /**
-     * Custom function to determine if an option is selected.
-     */
-    isOptionSelected?: (option: DropdownOption, options: DropdownOption[]) => boolean;
-    /**
-     * If true, allows the dropdown menu to overflow its container.
-     */
-    insideOverflowContainer?: boolean;
-    /**
-     * If true, allows the dropdown menu to overflow its container even with CSS transforms.
-     */
-    insideOverflowWithTransformContainer?: boolean;
-    /**
-     * If true, renders the dropdown menu inside its parent container in case it's inside a layer provider.
-     * Use this prop when the dropdown menu is being cut off by its parent's (such as Modal, Dialog, Tooltip, etc.)overflow settings.
-     */
-    insideLayerContext?: boolean;
-    /**
-     * Tooltip content displayed when hovering over the selected value.
+     * If true, the dropdown menu will be auto focused.
      */
-    tooltipContent?: string;
+    autoFocus?: boolean;
     /**
-     * If true, displays a loading state inside the dropdown.
+     * If true, the dropdown will have a clear button.
      */
-    isLoading?: boolean;
+    clearable?: boolean;
     /**
-     * Function to override the default loading message.
+     * Callback fired when the dropdown loses focus.
      */
-    loadingMessage?: (obj: {
-        inputValue: string;
-    }) => string | null;
+    onBlur?: (event: React.FocusEvent<HTMLDivElement>) => void;
     /**
-     * The ARIA label for the dropdown.
+     * Callback fired when the clear button is clicked.
      */
-    ariaLabel?: string;
+    onClear?: () => void;
     /**
-     * If true, enables selecting values with the Tab key.
+     * Callback fired when the dropdown gains focus.
      */
-    tabSelectsValue?: boolean;
+    onFocus?: (event: React.FocusEvent<HTMLDivElement>) => void;
     /**
-     * Custom function to filter options based on input.
+     * Callback fired when the dropdown input value changes.
      */
-    filterOption?: (option: DropdownOption, inputValue: string) => boolean;
+    onInputChange?: (input: string | null) => void;
     /**
-     * The current value of the input field.
+     * Callback fired when a key is pressed inside the dropdown.
      */
-    inputValue?: string;
+    onKeyDown?: (event: React.KeyboardEvent<HTMLDivElement>) => void;
     /**
-     * If true, the input field loses focus when an option is selected.
+     * Callback fired when the dropdown menu opens.
      */
-    blurInputOnSelect?: boolean;
+    onMenuOpen?: () => void;
     /**
-     * Custom renderer for dropdown options.
+     * Callback fired when the dropdown menu closes.
      */
-    OptionRenderer?: React.ReactNode;
+    onMenuClose?: () => void;
     /**
-     * If true, controls the menu open state.
+     * Callback fired when an option is selected.
      */
-    menuIsOpen?: boolean;
+    onOptionSelect?: (option: Item) => void;
     /**
-     * Callback fired when an option is selected.
+     * Callback fired when scrolling inside the dropdown.
      */
-    onOptionSelect?: (option: DropdownOption) => void;
+    onScroll?: (event: React.UIEvent<HTMLUListElement>) => void;
     /**
-     * Callback fired when the clear button is clicked.
+     * A function to customize the filtering of options.
+     * It receives an option and the current input value, and should return true if the option should be included, false otherwise.
      */
-    onClear?: () => void;
+    filterOption?: (option: Item, inputValue: string) => boolean;
     /**
-     * CSS selector for the container where popups are rendered.
+     * If false, selected options will be hidden from the list. Defaults to true.
      */
-    popupsContainerSelector?: string;
+    showSelectedOptions?: boolean;
     /**
-     * Additional properties passed to the `react-select` component.
+     * The class name to be applied to the menu wrapper.
      */
-    selectProps?: Record<string, string>;
+    menuWrapperClassName?: string;
     /**
-     * If true, displays dividers between grouped options.
+     * If true, displays a loading indicator in the dropdown controls.
      */
-    withGroupDivider?: boolean;
-    multiValueDialogClassName?: string;
-}
-export type DropdownProps = DropdownComponentProps;
-export type DropdownChipColors = "primary" | "negative" | "positive";
-export type DropdownMenuPosition = "absolute" | "fixed";
-export type DropdownMenuPlacement = "top" | "bottom" | "auto";
-export type DropdownSize = "small" | "medium" | "large";
+    loading?: boolean;
+} & (MultiSelectSpecifics<Item> | SingleSelectSpecifics<Item>);
+export type DropdownSizes = "small" | "medium" | "large";
+export type DropdownDirection = "ltr" | "rtl" | "auto";
+export type DropdownMultiControllerProps<Item extends BaseItemData<Record<string, unknown>>> = Omit<BaseDropdownProps<Item>, keyof MultiSelectSpecifics<Item> | keyof BoxModeConstraint> & BoxModeConstraint & MultiSelectSpecifics<Item> & {
+    dropdownRef: React.Ref<HTMLDivElement>;
+};
+export type DropdownSingleControllerProps<Item extends BaseItemData<Record<string, unknown>>> = Omit<BaseDropdownProps<Item>, keyof SingleSelectSpecifics<Item> | keyof BoxModeConstraint> & BoxModeConstraint & SingleSelectSpecifics<Item> & {
+    dropdownRef: React.Ref<HTMLDivElement>;
+};
+export {};

package/dist/{mocked_classnames/components/next → components}/Dropdown/components/DropdownBaseList/DropdownBaseList.types.d.ts

@@ -1,7 +1,7 @@
 import { type ReactNode } from "react";
 import type React from "react";
-import { type VibeComponentProps } from "../../../../../types";
-import { type BaseItemData, type BaseItemSizes, type BaseItemDirection } from "../../../../BaseItem";
+import { type VibeComponentProps } from "../../../../types";
+import { type BaseItemData, type BaseItemSizes, type BaseItemDirection } from "../../../BaseItem";
 export interface DropdownBaseListProps<Item = Record<string, unknown>> extends React.HTMLAttributes<HTMLUListElement>, VibeComponentProps {
     /**
      * The list of options available in the list.

package/dist/{mocked_classnames/components/next → components}/Dropdown/components/DropdownWrapperUI.d.ts

@@ -1,6 +1,6 @@
 import React from "react";
 import { type DropdownContextProps } from "../context/DropdownContext.types";
-import { type BaseItemData } from "../../../BaseItem";
+import { type BaseItemData } from "../../BaseItem";
 interface DropdownWrapperUIProps<Item extends BaseItemData<Record<string, unknown>>> {
     contextValue: DropdownContextProps<Item>;
     dropdownRef: React.Ref<HTMLDivElement>;