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

package/dist/mocked_classnames/components/Steps/StepsNumbersHeader.d.ts

@@ -2,8 +2,17 @@ import { FC } from "react";
 import VibeComponentProps from "../../types/VibeComponentProps";
 import { StepsColor } from "./Steps.types";
 export interface StepsNumbersHeaderProps extends VibeComponentProps {
+    /**
+     * The index of the currently active step.
+     */
     activeStepIndex: number;
+    /**
+     * The total number of steps.
+     */
     stepsCount: number;
+    /**
+     * The color theme of the steps numbers header.
+     */
     color?: StepsColor;
 }
 export declare const StepsNumbersHeader: FC<StepsNumbersHeaderProps>;

package/dist/mocked_classnames/components/Switch/Switch.d.ts

@@ -2,18 +2,57 @@ import { ChangeEvent, ReactElement } from "react";
 import { VibeComponent, VibeComponentProps } from "../../types";
 import { MockToggleProps } from "../Toggle/MockToggle";
 export interface SwitchProps extends VibeComponentProps {
+    /**
+     * The name of the switch input.
+     */
     name?: string;
+    /**
+     * The value associated with the switch.
+     */
     value?: string;
+    /**
+     * The ARIA role of the switch.
+     */
     role?: string;
+    /**
+     * If true, the switch is disabled.
+     */
     disabled?: boolean;
+    /**
+     * The ARIA label for accessibility.
+     */
     ariaLabel?: string;
+    /**
+     * The ID of the element labeling the switch.
+     */
     ariaLabelledBy?: string;
+    /**
+     * If true, the switch is checked.
+     */
     checked?: boolean;
+    /**
+     * Class name applied to the input element.
+     */
     inputClassName?: string;
+    /**
+     * Callback fired when the switch state changes.
+     */
     onChange?: (value: boolean, event: ChangeEvent<HTMLInputElement>) => void;
+    /**
+     * The ID of the element controlled by the switch.
+     */
     ariaControls?: string;
+    /**
+     * If true, the switch is checked by default.
+     */
     defaultChecked?: boolean;
+    /**
+     * The child component rendered inside the switch.
+     */
     children?: ReactElement<MockToggleProps>;
+    /**
+     * Class name applied to the wrapper element.
+     */
     wrapperClassName?: string;
 }
 export declare const Switch: VibeComponent<SwitchProps, HTMLInputElement>;

package/dist/mocked_classnames/components/Table/Table/Table.d.ts

@@ -7,27 +7,69 @@ import { RowSizes } from "./Table.types";
 export type TableLoadingStateType = "long-text" | "medium-text" | "circle" | "rectangle";
 type Width = number | `${number}%` | `${number}px` | `${number}fr`;
 export interface TableColumn {
+    /**
+     * Unique identifier for the column.
+     */
     id: string;
+    /**
+     * Column title displayed in the header.
+     */
     title: string;
+    /**
+     * Additional information displayed as a tooltip.
+     */
     infoContent?: string;
+    /**
+     * Column width configuration.
+     */
     width?: Width | {
         min: Width;
         max: Width;
     };
+    /**
+     * Icon displayed next to the column title.
+     */
     icon?: SubIcon;
+    /**
+     * Loading state type for the column when data is being fetched.
+     */
     loadingStateType?: TableLoadingStateType;
 }
 export interface TableProps extends VibeComponentProps {
+    /**
+     * Defines the columns of the table.
+     */
     columns: TableColumn[];
+    /**
+     * State of the data being displayed (loading or error).
+     */
     dataState?: {
         isLoading?: boolean;
         isError?: boolean;
     };
+    /**
+     * React element displayed when there is an error state.
+     */
     errorState: ReactElement;
+    /**
+     * React element displayed when there is no data.
+     */
     emptyState: ReactElement;
+    /**
+     * Custom styles for the table.
+     */
     style?: React.CSSProperties;
+    /**
+     * The child components inside the table, such as `<TableHeader />` and `<TableBody />`.
+     */
     children?: ReactElement<TableHeaderProps> | ReactElement<TableBodyProps> | Array<ReactElement<TableHeaderProps> | ReactElement<TableBodyProps>>;
+    /**
+     * The row size of the table.
+     */
     size?: RowSizes;
+    /**
+     * If true, removes the table's outer border.
+     */
     withoutBorder?: boolean;
 }
 declare const _default: ((VibeComponent<TableProps & React.RefAttributes<HTMLDivElement>, HTMLDivElement> & Partial<{

package/dist/mocked_classnames/components/Table/TableBody/TableBody.d.ts

@@ -3,6 +3,9 @@ import { VibeComponent, VibeComponentProps } from "../../../types";
 import { TableRowProps } from "../TableRow/TableRow";
 import VirtualizedList from "../../VirtualizedList/VirtualizedList";
 export interface TableBodyProps extends VibeComponentProps {
+    /**
+     * The child components inside the table body, such as `<TableRow />` elements.
+     */
     children?: ReactElement<TableRowProps> | ReactElement<TableRowProps>[] | ReactElement<ComponentProps<typeof VirtualizedList>>;
 }
 declare const TableBody: VibeComponent<TableBodyProps, HTMLDivElement>;

package/dist/mocked_classnames/components/Table/TableCell/TableCell.d.ts

@@ -1,7 +1,13 @@
 import React from "react";
 import { VibeComponent, VibeComponentProps } from "../../../types";
 export interface TableCellProps extends VibeComponentProps {
+    /**
+     * The content inside the table cell.
+     */
     children?: React.ReactNode;
+    /**
+     * If true, makes the cell sticky (typically used for frozen columns).
+     */
     sticky?: boolean;
 }
 declare const TableCell: VibeComponent<TableCellProps, HTMLDivElement>;

package/dist/mocked_classnames/components/Table/TableCellSkeleton/TableCellSkeleton.d.ts

@@ -2,7 +2,13 @@ import React from "react";
 import { VibeComponentProps } from "../../../types";
 import { TableLoadingStateType } from "../Table/Table";
 export interface TableCellSkeletonProps extends VibeComponentProps {
+    /**
+     * The type of loading state for the skeleton.
+     */
     type?: TableLoadingStateType;
+    /**
+     * If true, renders a shorter skeleton for text-based loading states.
+     */
     short?: boolean;
 }
 declare const TableCellSkeleton: React.FC<TableCellSkeletonProps>;

package/dist/mocked_classnames/components/Table/TableContainer/TableContainer.types.d.ts

@@ -1,6 +1,12 @@
 import React from "react";
 import { VibeComponentProps } from "../../../types";
 export interface TableContainerProps extends VibeComponentProps {
+    /**
+     * Custom styles for the table container.
+     */
     style?: React.CSSProperties;
+    /**
+     * The child elements inside the table container.
+     */
     children: React.ReactNode;
 }

package/dist/mocked_classnames/components/Table/TableHeader/TableHeader.d.ts

@@ -2,6 +2,9 @@ import React from "react";
 import { VibeComponent, VibeComponentProps } from "../../../types";
 import { TableHeaderCellProps } from "../TableHeaderCell/TableHeaderCell";
 export interface TableHeaderProps extends VibeComponentProps {
+    /**
+     * The child elements inside the table header, typically `<TableHeaderCell />` components.
+     */
     children?: React.ReactElement<TableHeaderCellProps> | React.ReactElement<TableHeaderCellProps>[];
 }
 declare const TableHeader: VibeComponent<TableHeaderProps, HTMLDivElement>;

package/dist/mocked_classnames/components/Table/TableHeaderCell/TableHeaderCell.d.ts

@@ -1,12 +1,33 @@
 import React from "react";
 import { SubIcon, VibeComponent, VibeComponentProps } from "../../../types";
 export interface TableHeaderCellProps extends VibeComponentProps {
+    /**
+     * The title of the column, displayed inside the header cell.
+     */
     title: string | React.ReactNode;
+    /**
+     * Icon displayed next to the column title.
+     */
     icon?: SubIcon;
+    /**
+     * Tooltip content for additional information about the column.
+     */
     infoContent?: string;
+    /**
+     * Current sorting state of the column.
+     */
     sortState?: "asc" | "desc" | "none";
+    /**
+     * Callback fired when the column header is clicked to change sorting.
+     */
     onSortClicked?: (direction: "asc" | "desc" | "none") => void;
+    /**
+     * ARIA label for the sort button.
+     */
     sortButtonAriaLabel?: string;
+    /**
+     * If true, the header cell remains visible while scrolling horizontally.
+     */
     sticky?: boolean;
 }
 declare const TableHeaderCell: VibeComponent<TableHeaderCellProps, HTMLDivElement>;

package/dist/mocked_classnames/components/Table/TableRow/TableRow.d.ts

@@ -3,10 +3,16 @@ import { VibeComponent, VibeComponentProps } from "../../../types";
 import { TableCellProps } from "../TableCell/TableCell";
 export interface TableRowProps extends VibeComponentProps {
     /**
-     * Does the row have a highlighted style
+     * If true, applies a highlighted style to the row.
      */
     highlighted?: boolean;
+    /**
+     * The child components inside the table row, typically `<TableCell />` elements.
+     */
     children?: React.ReactElement<TableCellProps> | React.ReactElement<TableCellProps>[];
+    /**
+     * Custom styles applied to the table row.
+     */
     style?: React.CSSProperties;
 }
 declare const TableRow: VibeComponent<TableRowProps, HTMLDivElement>;

package/dist/mocked_classnames/components/Table/TableRowMenu/TableRowMenu.types.d.ts

@@ -1,6 +1,12 @@
 import { VibeComponentProps } from "../../../types";
 import React from "react";
 export interface TableMenuProps extends VibeComponentProps {
+    /**
+     * The ID of the row that the menu is associated with.
+     */
     rowId: string;
+    /**
+     * The child elements inside the table menu.
+     */
     children?: React.ReactNode;
 }

package/dist/mocked_classnames/components/Table/TableVirtualizedBody/TableVirtualizedBody.d.ts

@@ -6,10 +6,25 @@ export type TableVirtualizedRow = Record<string, unknown> & {
     id: string;
 };
 export interface TableVirtualizedBodyProps<T extends TableVirtualizedRow = TableVirtualizedRow> extends VibeComponentProps {
+    /**
+     * The list of items to render in the virtualized table.
+     */
     items: T[];
+    /**
+     * Function to render a row in the table.
+     */
     rowRenderer: (item: T) => JSX.Element;
+    /**
+     * Callback function triggered on scroll.
+     */
     onScroll?: (horizontalScrollDirection: ScrollDirection, scrollTop: number, scrollUpdateWasRequested: boolean) => void;
+    /**
+     * The columns configuration for the table.
+     */
     columns?: TableColumn[];
+    /**
+     * Function to render the table header.
+     */
     headerRenderer?: (columns: TableColumn[]) => JSX.Element;
 }
 declare const TableVirtualizedBody: React.ForwardRefExoticComponent<TableVirtualizedBodyProps<TableVirtualizedRow> & React.RefAttributes<HTMLDivElement>>;

package/dist/mocked_classnames/components/Tabs/Tab/Tab.d.ts

@@ -5,23 +5,47 @@ import { SubIcon } from "../../../types/SubIcon";
 import { TooltipProps } from "../../Tooltip/Tooltip";
 export interface TabProps extends VibeComponentProps {
     /**
-     * Class name for tab link-name
+     * Class name applied to the inner tab content.
      */
     tabInnerClassName?: string;
     /**
-     * Tab index
+     * The index value of the tab.
      */
     value?: number;
+    /**
+     * If true, disables the tab.
+     */
     disabled?: boolean;
+    /**
+     * If true, marks the tab as active.
+     */
     active?: boolean;
+    /**
+     * If true, applies focus styles to the tab.
+     */
     focus?: boolean;
+    /**
+     * The icon displayed in the tab.
+     */
     icon?: SubIcon;
+    /**
+     * The type of icon.
+     */
     iconType?: IconType;
+    /**
+     * The position of the icon relative to the text.
+     */
     iconSide?: string;
+    /**
+     * Callback fired when the tab is clicked.
+     */
     onClick?: (value: number) => void;
+    /**
+     * Props passed to the tab's tooltip.
+     */
     tooltipProps?: Partial<TooltipProps>;
     /**
-     * Tab link-name
+     * The content displayed inside the tab.
      */
     children?: string | ReactElement | ReactElement[];
 }

package/dist/mocked_classnames/components/Tabs/TabList/TabList.d.ts

@@ -2,10 +2,25 @@ import { FC, ReactElement } from "react";
 import VibeComponentProps from "../../../types/VibeComponentProps";
 import { TabProps } from "../Tab/Tab";
 export interface TabListProps extends VibeComponentProps {
+    /**
+     * Callback fired when the active tab changes.
+     */
     onTabChange?: (tabId: number) => void;
+    /**
+     * The index of the currently active tab.
+     */
     activeTabId?: number;
+    /**
+     * The type of tab style.
+     */
     tabType?: string;
+    /**
+     * The size of the tab list.
+     */
     size?: string;
+    /**
+     * The child elements representing tabs.
+     */
     children?: ReactElement<TabProps>[];
 }
 declare const TabList: FC<TabListProps>;

package/dist/mocked_classnames/components/Tabs/TabPanel/TabPanel.d.ts

@@ -1,7 +1,13 @@
 import { FC, ReactElement } from "react";
 import VibeComponentProps from "../../../types/VibeComponentProps";
 export interface TabPanelProps extends VibeComponentProps {
+    /**
+     * The content inside the tab panel.
+     */
     children?: ReactElement | ReactElement[] | string;
+    /**
+     * The index of the tab panel.
+     */
     index?: number;
 }
 declare const TabPanel: FC<TabPanelProps>;

package/dist/mocked_classnames/components/Tabs/TabPanels/TabPanels.d.ts

@@ -4,8 +4,17 @@ import { TabPanelsAnimationDirection as TabPanelsAnimationDirectionEnum } from "
 import { TabPanelsAnimationDirection } from "./TabPanels.types";
 import { TabPanelProps } from "../TabPanel/TabPanel";
 export interface TabPanelsProps extends VibeComponentProps {
+    /**
+     * The index of the currently active tab panel.
+     */
     activeTabId?: number;
+    /**
+     * The animation direction when switching between tab panels.
+     */
     animationDirection?: TabPanelsAnimationDirection;
+    /**
+     * The child elements representing tab panels.
+     */
     children?: ReactElement<TabPanelProps> | ReactElement<TabPanelProps>[];
 }
 declare const _default: ((import("../../../types/VibeComponent").default<TabPanelsProps, unknown> & Partial<{

package/dist/mocked_classnames/components/Tabs/TabsContext/TabsContext.d.ts

@@ -1,7 +1,13 @@
 import { FC, ReactElement } from "react";
 import VibeComponentProps from "../../../types/VibeComponentProps";
 export interface TabsContextProps extends VibeComponentProps {
+    /**
+     * The index of the currently active tab.
+     */
     activeTabId?: number;
+    /**
+     * The child elements representing the tab list and tab panels.
+     */
     children?: ReactElement | ReactElement[];
 }
 declare const TabsContext: FC<TabsContextProps>;

package/dist/mocked_classnames/components/Text/Text.d.ts

@@ -5,8 +5,17 @@ import { TypographyProps } from "../Typography/Typography";
 import { TypographyAlign as TypographyAlignEnum, TypographyColor as TypographyColorEnum } from "../Typography/TypographyConstants";
 import { TextType, TextWeight } from "./Text.types";
 export interface TextProps extends TypographyProps {
+    /**
+     * The text style variant.
+     */
     type?: TextType;
+    /**
+     * The font weight of the text.
+     */
     weight?: TextWeight;
+    /**
+     * The content inside the text component.
+     */
     children: ReactNode;
 }
 declare const _default: ((VibeComponent<TextProps & React.RefAttributes<HTMLElement>, HTMLElement> & Partial<{

package/dist/mocked_classnames/components/TextArea/TextArea.types.d.ts

@@ -12,58 +12,55 @@ export interface TextAreaProps extends TextAreaNativeInputProps, VibeComponentPr
      */
     size?: TextAreaSize;
     /**
-     * Indicates that the textarea has passed validation successfully, controlling
-     * the visual styling to convey success.
+     * If true, applies success styling to the textarea.
      */
     success?: boolean;
     /**
-     * Indicates an error with the current value of the textarea, controlling
-     * the visual styling to convey error.
+     * If true, applies error styling to the textarea.
      */
     error?: boolean;
     /**
-     * Label text associated with the textarea element.
+     * The label associated with the textarea.
      */
     label?: string;
     /**
-     * Function to call on textarea value change.
+     * Callback fired when the textarea value changes.
      */
     onChange?: (event: React.ChangeEvent<HTMLTextAreaElement>) => void;
     /**
-     * Help text associated with the textarea element, typically used for guidance.
+     * Help text displayed below the textarea.
      */
     helpText?: string;
     /**
-     * Accessibility label for the textarea element.
+     * The accessibility label for the textarea.
      */
     "aria-label"?: React.AriaAttributes["aria-label"];
     /**
-     * If true, the textarea can be resized vertically by the user.
+     * If true, the textarea can be resized vertically.
      */
     resize?: boolean;
     /**
-     * Placeholder text to display when the textarea is empty.
+     * The placeholder text displayed when the textarea is empty.
      */
     placeholder?: string;
     /**
-     * The allowed number of characters.
+     * The maximum number of characters allowed.
      */
     maxLength?: number;
     /**
-     * If true, the TextArea will allow the user to exceed the character limit set by maxLength.
-     * Note: Using this prop will only make sense alongside the maxLength prop.
+     * If true, allows the user to exceed the character limit set by `maxLength`.
      */
     allowExceedingMaxLength?: boolean;
     /**
-     * If true, the character count and limit will be displayed below the textarea.
+     * If true, displays the character count below the textarea.
      */
     showCharCount?: boolean;
     /**
-     * If true, the textarea will be disabled.
+     * If true, disables the textarea.
      */
     disabled?: boolean;
     /**
-     * If true, the textarea will be read-only.
+     * If true, makes the textarea read-only.
      */
     readOnly?: boolean;
 }