@vibe/core 3.36.0-alpha-94da6.0 → 3.36.0

package/dist/components/ListItem/ListItem.d.ts

@@ -4,56 +4,43 @@ import { ListItemComponentType as ListItemComponentTypeEnum } from "./ListItemCo
 import { ListItemElement, ListItemSize } from "./ListItem.types";
 export interface ListItemProps extends VibeComponentProps {
     /**
-     * the ListItem element [li, div, a]
+     * The HTML element used for the list item.
      */
     component?: ListItemElement;
     /**
-     * The textual content of the list item
+     * The textual content inside the list item.
      */
     children?: ElementContent;
     /**
-     * A class name to be passed to the list item wrapper
-     */
-    className?: string;
-    /**
-     * An id to be passed to the list item wrapper
-     */
-    id?: string;
-    /**
-     * A callback function which is being called when the item is being clicked
-     * It will be called with the following params
-     * event (DomEvent)
-     * id (the id which is being passed)
-     * onClick(event, id)
+     * Callback fired when the item is clicked.
      */
     onClick?: (event: React.MouseEvent | React.KeyboardEvent, id: string) => void;
     /**
-     * A callback function which is being called when the item is being hovered
-     * It will be called with the following params
-     * event (DomEvent)
-     * id (the id which is being passed)
-     * onHover(event, id)
+     * Callback fired when the item is hovered.
      */
     onHover?: (event: React.MouseEvent | React.FocusEvent, id: string) => void;
     /**
-     * disabled state - callback will not be called and navigation will be skipped
+     * If true, disables the item and prevents interactions.
      */
     disabled?: boolean;
     /**
-     * Selected indication
+     * If true, marks the item as selected.
      */
     selected?: boolean;
     /**
-     * The size of the list item
+     * The size of the list item.
      */
     size?: ListItemSize;
     /**
-     Tabindex is used for keyboard navigation - if you want to skip "Tab navigation" please pass -1.
+     * The tab index of the list item for keyboard navigation.
      */
     tabIndex?: number;
+    /**
+     * Indicates the current state of the item in a set of items.
+     */
     "aria-current"?: AriaAttributes["aria-current"];
     /**
-     * ARIA role for the list item.
+     * The ARIA role of the list item.
      */
     role?: AriaRole;
 }

package/dist/components/ListItemAvatar/ListItemAvatar.d.ts

@@ -4,10 +4,16 @@ import { ListItemComponentType as ListItemComponentTypeEnum } from "../ListItem/
 import { ListItemElement } from "../ListItem/ListItem.types";
 export interface ListItemAvatarProps extends VibeComponentProps {
     /**
-     * the ListItem component [li, div, a]
+     * The HTML element used for the list item avatar.
      */
     component?: ListItemElement;
+    /**
+     * The source URL of the avatar image.
+     */
     src?: string;
+    /**
+     * Class name applied to the avatar.
+     */
     avatarClassName?: string;
 }
 declare const _default: ((VibeComponent<ListItemAvatarProps & React.RefAttributes<HTMLElement>, HTMLElement> & Partial<{

package/dist/components/ListItemIcon/ListItemIcon.d.ts

@@ -7,12 +7,15 @@ import { ListItemIconMargin } from "./ListItemIcon.types";
 export declare const LIST_ITEM_ICON_SIZE = 18;
 export interface ListItemIconProps extends VibeComponentProps {
     /**
-     * the ListItem component [li, div, a]
+     * The HTML element used for the list item icon.
      */
     component?: ListItemElement;
+    /**
+     * The icon displayed inside the list item.
+     */
     icon?: SubIcon;
     /**
-     * the position of the icon inside the list item (this sets the margins of the icon)
+     * The position of the icon inside the list item, determining its margins.
      */
     margin?: ListItemIconMargin;
 }

package/dist/components/ListTitle/ListTitle.d.ts

@@ -1,7 +1,13 @@
 import React from "react";
 import VibeComponentProps from "../../types/VibeComponentProps";
 export interface ListTitleProps extends VibeComponentProps {
+    /**
+     * The tab index for keyboard navigation.
+     */
     tabIndex?: number;
+    /**
+     * The title text.
+     */
     children?: string;
 }
 declare const ListTitle: React.FC<ListTitleProps>;

package/dist/components/Loader/Loader.d.ts

@@ -3,11 +3,21 @@ import { LoaderColors as LoaderColorsEnum, LoaderSizes as LoaderSizesEnum } from
 import { LoaderColors, LoaderSize } from "./Loader.types";
 import { VibeComponent, VibeComponentProps } from "../../types";
 export interface LoaderProps extends VibeComponentProps {
-    className?: string;
-    /** The loader's size: `number` or `LoaderSizes` */
+    /**
+     * The size of the loader, either a predefined size or a custom number.
+     */
     size?: LoaderSize;
+    /**
+     * The color of the loader.
+     */
     color?: LoaderColors;
+    /**
+     * If true, a background circle is displayed behind the loader.
+     */
     hasBackground?: boolean;
+    /**
+     * Class name applied to the wrapper element.
+     */
     wrapperClassName?: string;
 }
 declare const _default: ((VibeComponent<LoaderProps & React.RefAttributes<HTMLElement>, HTMLElement> & Partial<{

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

@@ -3,19 +3,61 @@ import React from "react";
 import { ElementContent, VibeComponent, VibeComponentProps } from "../../../types";
 import { CloseMenuOption } from "./MenuConstants";
 export interface MenuProps extends VibeComponentProps {
+    /**
+     * Size of the menu.
+     */
     size?: (typeof SIZES)[keyof typeof SIZES];
+    /**
+     * The tab index of the menu.
+     */
     tabIndex?: number;
+    /**
+     * ARIA label for accessibility.
+     */
     ariaLabel?: string;
+    /**
+     * ARIA description ID.
+     */
     ariaDescribedBy?: string;
+    /**
+     * If true, the menu will automatically focus on mount.
+     */
     focusOnMount?: boolean;
+    /**
+     * Callback when a menu item gains focus.
+     */
     onItemFocus?: (index: number) => void;
+    /**
+     * Controls the visibility of the menu.
+     */
     isVisible?: boolean;
+    /**
+     * Callback triggered when the menu closes.
+     */
     onClose?: (option: CloseMenuOption) => void;
+    /**
+     * Index of the focused menu item.
+     */
     focusItemIndex?: number;
+    /**
+     * If true, this menu is a submenu.
+     */
     isSubMenu?: boolean;
+    /**
+     * If true, event listeners will be attached to the document.
+     */
     useDocumentEventListeners?: boolean;
+    /**
+     * Index of the item that should be focused when the menu mounts.
+     */
     focusItemIndexOnMount?: number;
+    /**
+     * If true, enables scrolling within the menu.
+     */
     shouldScrollMenu?: boolean;
+    /**
+     * The menu items.
+     */
     children?: ElementContent;
 }
 declare const _default: ((VibeComponent<MenuProps & React.RefAttributes<HTMLElement>, HTMLElement> & Partial<{

package/dist/components/Menu/MenuGridItem/MenuGridItem.d.ts

@@ -2,21 +2,49 @@ import { ReactElement } from "react";
 import { VibeComponent, VibeComponentProps } from "../../../types";
 import { CloseMenuOption } from "../Menu/MenuConstants";
 export interface MenuGridItemProps extends VibeComponentProps {
+    /**
+     * The content of the menu grid item.
+     */
     children?: ReactElement | ReactElement[];
-    /** if true, keyboard navigation will skip on this item. Also, this prop will be passed on to the child **/
+    /**
+     * If true, keyboard navigation will skip this item. This prop is also passed to the child.
+     */
     disabled?: boolean;
-    /** a callback to close the wrapping menu **/
+    /**
+     * A callback function to close the wrapping menu.
+     */
     closeMenu?: (option: CloseMenuOption) => void;
-    /** the currently active index of the wrapping menu **/
+    /**
+     * The currently active index of the wrapping menu.
+     */
     activeItemIndex?: number;
+    /**
+     * Callback function to set the active item index.
+     */
     setActiveItemIndex?: (index: number) => void;
+    /**
+     * Function to get the next selectable index.
+     */
     getNextSelectableIndex?: (activeItemIndex: number) => number;
+    /**
+     * Function to get the previous selectable index.
+     */
     getPreviousSelectableIndex?: (activeItemIndex: number) => number;
-    /** the index of this item **/
+    /**
+     * The index of this menu grid item.
+     */
     index?: number;
-    /** true if this item is under a submenu, and not a top-level menu **/
+    /**
+     * If true, this item is under a submenu instead of a top-level menu.
+     */
     isUnderSubMenu?: boolean;
+    /**
+     * Callback function to open or close a submenu by its index.
+     */
     setSubMenuIsOpenByIndex?: (index: number, isOpen: boolean) => void;
+    /**
+     * If true, event listeners will be attached to the document.
+     */
     useDocumentEventListeners?: boolean;
 }
 declare const MenuGridItem: VibeComponent<MenuGridItemProps> & {

package/dist/components/Menu/MenuItem/AvatarMenuItem.d.ts

@@ -3,7 +3,13 @@ import { MenuItemProps } from "./MenuItem";
 import { AvatarProps } from "../../Avatar/Avatar";
 import VibeComponentProps from "../../../types/VibeComponentProps";
 export interface AvatarMenuItemProps extends VibeComponentProps {
+    /**
+     * Props passed to the avatar component.
+     */
     avatarProps?: AvatarProps;
+    /**
+     * Props passed to the menu item component.
+     */
     menuItemProps?: MenuItemProps;
 }
 /**

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

@@ -8,51 +8,141 @@ import { TooltipPositions } from "../../Tooltip/Tooltip.types";
 import { TooltipPositions as TooltipPositionsEnum } from "../../Tooltip/TooltipConstants";
 import { SubmenuPosition } from "./MenuItem.types";
 export interface MenuItemProps extends VibeComponentProps {
+    /**
+     * The title of the menu item.
+     */
     title?: string;
+    /**
+     * The label displayed alongside the title.
+     */
     label?: string | React.ReactElement<typeof Label>;
+    /**
+     * The icon displayed in the menu item.
+     */
     icon?: SubIcon;
+    /**
+     * The type of icon.
+     */
     iconType?: IconType;
+    /**
+     * The background color of the icon.
+     */
     iconBackgroundColor?: string;
+    /**
+     * If true, the menu item is disabled.
+     */
     disabled?: boolean;
+    /**
+     * The reason for disabling the item, shown in a tooltip.
+     */
     disableReason?: string;
+    /**
+     * If true, the menu item is selected.
+     */
     selected?: boolean;
+    /**
+     * Callback fired when the menu item is clicked.
+     */
     onClick?: (event: React.MouseEvent | React.KeyboardEvent) => void;
+    /**
+     * The active item index in the menu.
+     */
     activeItemIndex?: number;
+    /**
+     * Callback to set the active item index.
+     */
     setActiveItemIndex?: (index: number) => void;
+    /**
+     * The index of the menu item.
+     */
     index?: number;
+    /**
+     * The key of the menu item.
+     */
     key?: string;
+    /**
+     * If true, the parent menu is visible.
+     */
     isParentMenuVisible?: boolean;
+    /**
+     * Callback to reset the open submenu index.
+     */
     resetOpenSubMenuIndex?: () => void;
+    /**
+     * If true, a submenu is open.
+     */
     hasOpenSubMenu?: boolean;
+    /**
+     * Callback to open or close a submenu by index.
+     */
     setSubMenuIsOpenByIndex?: (index: number, isOpen: boolean) => void;
+    /**
+     * If true, document event listeners are used for handling interactions.
+     */
     useDocumentEventListeners?: boolean;
+    /**
+     * The tooltip content for the menu item.
+     */
     tooltipContent?: string;
+    /**
+     * The position of the tooltip.
+     */
     tooltipPosition?: TooltipPositions;
+    /**
+     * The delay in milliseconds before the tooltip shows.
+     */
     tooltipShowDelay?: number;
+    /**
+     * Additional props for customizing the tooltip.
+     */
     tooltipProps?: Partial<TooltipProps>;
+    /**
+     * Callback fired when the mouse leaves the item.
+     */
     onMouseLeave?: (event: React.MouseEvent) => void;
+    /**
+     * Callback fired when the mouse enters the item.
+     */
     onMouseEnter?: (event: React.MouseEvent) => void;
     /**
-     * Class name which is added to div which wraps an Icon
+     * Class name applied to the icon wrapper.
      */
     iconWrapperClassName?: string;
+    /**
+     * If true, the menu item starts as selected.
+     */
     isInitialSelectedState?: boolean;
+    /**
+     * If true, the menu scrolls to ensure visibility.
+     */
     shouldScrollMenu?: boolean;
+    /**
+     * Function to close the menu with a given option.
+     */
     closeMenu?: (option: CloseMenuOption) => void;
+    /**
+     * Reference to the menu container.
+     */
     menuRef?: React.RefObject<HTMLElement>;
+    /**
+     * The submenu items, if applicable.
+     */
     children?: MenuChild | MenuChild[];
     /**
-     * Type of menu item with sub menu, which has two click/hover options-
-     *    1. click on the main menu item will trigger onClick
-     *    2. click/hover on icon button will open the sub menu
+     * If true, enables a split menu item interaction where the main area triggers an action,
+     * while the icon button opens the submenu.
      */
     splitMenuItem?: boolean;
+    /**
+     * The label of the menu item for accessibility.
+     */
     "aria-label"?: AriaAttributes["aria-label"];
+    /**
+     * The position of a submenu relative to the menu item.
+     */
     submenuPosition?: SubmenuPosition;
     /**
-     * When set to `true`, submenu's content and size changes would automatically trigger repositioning.
-     *
-     * This is useful for when submenu's content may grow or shrink without a re-render being triggered.
+     * If true, automatically repositions the submenu when its content changes.
      */
     autoAdjustOnSubMenuContentResize?: boolean;
 }

package/dist/components/Menu/MenuItem/components/BaseMenuItem/BaseMenuItem.types.d.ts

@@ -4,6 +4,13 @@ import React from "react";
 import { VibeComponentProps } from "../../../../../types";
 export type LossMenuItemProps = Omit<MenuItemProps, "className" | "classname" | "iconWrapperClassName" | "title" | "label" | "icon" | "iconType" | "iconBackgroundColor" | "disabledReason" | "key" | "tooltipContent" | "tooltipPosition" | "tooltipShowDelay" | "tooltipProps" | "aria-label" | "children">;
 export interface BaseMenuItemProps extends LossMenuItemProps, VibeComponentProps {
+    /**
+     * The submenu items associated with this menu item.
+     * **Note:** Only `Menu` elements are allowed as first-level children, even though `MenuChild[]` is currently accepted.
+     */
     subMenu?: MenuChild | MenuChild[];
+    /**
+     * The content of the menu item.
+     */
     children: React.ReactNode;
 }

package/dist/components/Menu/MenuItem/components/MenuItemIcon/MenuItemIcon.types.d.ts

@@ -2,31 +2,32 @@ import { SubIcon } from "../../../../../types";
 import { IconType } from "../../../../Icon";
 export interface MenuItemIconProps {
     /**
-     * Icon to be displayed. Can be a string or an icon component.
+     * The icon to be displayed. Can be a string or an icon component.
      */
     icon?: SubIcon;
     /**
-     * Icon type to be used.
+     * The type of icon to be used.
      */
     type?: IconType;
     /**
      * Label for the icon, used for accessibility.
+     * @deprecated This property will be removed in the next major version.
      */
     label?: string;
     /**
-     * Indicates whether the icon is disabled. Disabled icons appear faded and do not respond to user interactions.
+     * If true, the icon appears disabled.
      */
     disabled?: boolean;
     /**
-     * Indicates whether the icon is selected. Selected icons have a different visual style.
+     * If true, the icon appears selected.
      */
     selected?: boolean;
     /**
-     * Background color for the icon wrapper.
+     * The background color of the icon wrapper.
      */
     backgroundColor?: string;
     /**
-     * Additional class name for the icon wrapper.
+     * Additional class name for styling the icon wrapper.
      */
     wrapperClassName?: string;
 }

package/dist/components/Menu/MenuItem/components/MenuItemSubMenu/MenuItemSubMenu.types.d.ts

@@ -4,11 +4,12 @@ import { SubmenuPosition } from "../../MenuItem.types";
 import { MenuItemProps } from "../../MenuItem";
 export interface MenuItemSubMenuProps extends Pick<MenuItemProps, "autoAdjustOnSubMenuContentResize"> {
     /**
-     * Reference to the anchor element that the submenu is related to. This is used to position the submenu correctly relative to the parent menu item.
+     * Reference to the anchor element that the submenu is related to.
+     * This is used to position the submenu correctly relative to the parent menu item.
      */
     anchorRef: React.MutableRefObject<HTMLElement>;
     /**
-     * Controls the visibility of the submenu. When true, the submenu is shown; otherwise, it is hidden.
+     * Controls the visibility of the submenu. If true, the submenu is shown; otherwise, it is hidden.
      */
     open?: boolean;
     /**
@@ -22,8 +23,11 @@ export interface MenuItemSubMenuProps extends Pick<MenuItemProps, "autoAdjustOnS
      */
     onClose?: (option?: CloseMenuOption) => void;
     /**
-     * The children elements of the submenu, should be a Menu component.
+     * The submenu content, which should be a `Menu` component.
      */
     children: MenuChild | MenuChild[];
+    /**
+     * The position of the submenu relative to its parent menu item.
+     */
     submenuPosition?: SubmenuPosition;
 }

package/dist/components/Menu/MenuItem/components/MenuItemSubMenuIcon/MenuItemSubMenuIcon.types.d.ts

@@ -14,13 +14,17 @@ export interface SplitMenuItemSubMenuIconProps {
     disabled?: boolean;
 }
 export interface SimpleMenuItemSubMenuIconProps {
+    /**
+     * Determines whether the submenu icon is part of the main menu item.
+     * When false, the submenu is accessed by interacting with the main menu item itself.
+     */
     isSplit?: false;
     /**
      * Label for the submenu icon, used for accessibility.
      */
     label?: string;
     /**
-     * Whether the split submenu icon is disabled.
+     * Whether the submenu icon is disabled.
      */
     disabled?: boolean;
 }

package/dist/components/Menu/MenuItemButton/MenuItemButton.d.ts

@@ -4,22 +4,73 @@ import { SubIcon, VibeComponentProps, ElementContent } from "../../../types";
 import { TooltipPositions } from "../../Tooltip/Tooltip.types";
 import { TooltipPositions as TooltipPositionsEnum } from "../../Tooltip/TooltipConstants";
 export interface MenuItemButtonProps extends VibeComponentProps {
+    /**
+     * The style variant of the button.
+     */
     kind?: ButtonType;
+    /**
+     * Icon displayed on the left side of the button.
+     */
     leftIcon?: SubIcon;
+    /**
+     * Icon displayed on the right side of the button.
+     */
     rightIcon?: SubIcon;
+    /**
+     * The index of the menu item in the menu.
+     */
     index?: number;
+    /**
+     * The index of the currently active menu item.
+     */
     activeItemIndex?: number;
+    /**
+     * If true, the button is disabled.
+     */
     disabled?: boolean;
+    /**
+     * The reason why the button is disabled, displayed as a tooltip.
+     */
     disableReason?: string;
+    /**
+     * Callback fired when the button is clicked.
+     */
     onClick?: (event: React.MouseEvent | React.KeyboardEvent) => void;
+    /**
+     * The position of the tooltip.
+     */
     tooltipPosition?: TooltipPositions;
+    /**
+     * The delay in milliseconds before the tooltip appears.
+     */
     tooltipShowDelay?: number;
+    /**
+     * Callback to reset the open submenu index.
+     */
     resetOpenSubMenuIndex?: () => void;
+    /**
+     * Callback to open or close a submenu by index.
+     */
     setSubMenuIsOpenByIndex?: (index: number, isOpen: boolean) => void;
+    /**
+     * Callback to set the active item index.
+     */
     setActiveItemIndex?: (index: number) => void;
+    /**
+     * Reference to the menu container.
+     */
     menuRef?: React.RefObject<HTMLElement>;
+    /**
+     * Function to close the menu.
+     */
     closeMenu?: () => void;
+    /**
+     * If true, event listeners are added at the document level.
+     */
     useDocumentEventListeners?: boolean;
+    /**
+     * The content of the button.
+     */
     children?: ElementContent | ElementContent[];
 }
 declare const _default: ((import("../../../types/VibeComponent").default<MenuItemButtonProps, unknown> & Partial<{

package/dist/components/Menu/MenuTitle/MenuTitle.d.ts

@@ -3,7 +3,13 @@ import { MenuTitleCaptionPosition as MenuTitleCaptionPositionEnum } from "./Menu
 import { MenuTitleCaptionPosition } from "./MenuTitle.type";
 import { VibeComponentProps } from "../../../types";
 export interface MenuTitleProps extends VibeComponentProps {
+    /**
+     * The caption text displayed alongside the title.
+     */
     caption?: string;
+    /**
+     * The position of the caption relative to the title.
+     */
     captionPosition?: MenuTitleCaptionPosition;
 }
 declare const _default: ((import("../../../types/VibeComponent").default<MenuTitleProps, unknown> & Partial<{