@tanishraj/ui-kit 2.2.0 → 2.4.0

package/dist/index.d.ts

@@ -7,6 +7,8 @@ import { FC } from 'react';
 import { FieldsetHTMLAttributes } from 'react';
 import { ForwardRefExoticComponent } from 'react';
 import { HTMLAttributes } from 'react';
+import { KeyboardEvent as KeyboardEvent_2 } from 'react';
+import { MouseEvent as MouseEvent_2 } from 'react';
 import { Placement } from '@floating-ui/react';
 import { ReactElement } from 'react';
 import { ReactNode } from 'react';
@@ -15,6 +17,7 @@ import { RefAttributes } from 'react';
 import { RefObject } from 'react';
 import { RemoveNull as RemoveNull_2 } from '../../../utils';
 import { SVGProps } from 'react';
+import { ToasterProps } from 'sonner';
 import { VariantProps } from 'class-variance-authority';
 
 export declare const Accordion: FC<AccordionProps>;
@@ -215,12 +218,15 @@ export declare interface ButtonProps extends ComponentPropsWithRef<'button'>, Re
     trailingIcon?: FC<SVGProps<SVGSVGElement>>;
 }
 
+export declare type ButtonShapes = RemoveNull_2<VariantProps<typeof buttonStyles>>['shape'];
+
 export declare type ButtonSizes = RemoveNull_2<VariantProps<typeof buttonStyles>>['size'];
 
 declare const buttonStyles: (props?: ({
     size?: "sm" | "md" | "lg" | null | undefined;
     variant?: "default" | "primary" | "info" | "success" | "warning" | "danger" | null | undefined;
     appearance?: "filled" | "outline" | "dashed" | "ghost" | null | undefined;
+    shape?: "rounded" | "squared" | null | undefined;
     disabled?: boolean | null | undefined;
     loading?: boolean | null | undefined;
     fullWidth?: boolean | null | undefined;
@@ -360,33 +366,7 @@ export declare type DropdownAppearances = ButtonAppearances;
 
 export declare type DropdownIcon = NonNullable<ButtonProps['leadingIcon']>;
 
-export declare const DropdownItem: ForwardRefExoticComponent<DropdownItemComponentProps & RefAttributes<HTMLButtonElement>>;
-
-declare interface DropdownItem_2 {
-    disabled?: boolean;
-    id?: string;
-    label: ReactNode;
-    leadingIcon?: DropdownIcon;
-    value: string;
-}
-
-export declare interface DropdownItemComponentProps extends Omit<ComponentPropsWithoutRef<'button'>, 'children' | 'disabled' | 'onSelect' | 'value'> {
-    item: DropdownItem_2;
-    onSelect?: (item: DropdownItem_2) => void;
-    selected?: boolean;
-}
-
-export declare const DropdownList: ForwardRefExoticComponent<DropdownListProps & RefAttributes<HTMLDivElement>>;
-
-export declare interface DropdownListProps extends Omit<ComponentPropsWithoutRef<'div'>, 'children'> {
-    children?: ReactNode;
-    closeMenu?: () => void;
-    closeOnSelect?: boolean;
-    items?: DropdownItem_2[];
-    leadingSlot?: ReactNode;
-    onItemSelect?: (item: DropdownItem_2) => void;
-    selectedValue?: string;
-}
+export declare type DropdownItem = ListBoxItemData;
 
 export declare type DropdownPlacements = 'top' | 'right' | 'bottom' | 'left';
 
@@ -399,13 +379,13 @@ export declare interface DropdownProps extends Omit<ButtonProps, 'children' | 't
     icon?: DropdownIcon;
     iconOnly?: boolean;
     inline?: boolean;
-    items?: DropdownItem_2[];
+    items?: DropdownItem[];
     align?: DropdownAlignments;
     menuClassName?: string;
     menuContent?: ReactNode | ((closeMenu: () => void) => ReactNode);
     menuOffset?: [number, number];
     menuPlacement?: Placement;
-    onItemSelect?: (item: DropdownItem_2) => void;
+    onItemSelect?: (item: DropdownItem) => void;
     onOpenChange?: (open: boolean) => void;
     open?: boolean;
     placement?: DropdownPlacements;
@@ -434,6 +414,77 @@ declare enum EThemeOptions {
     DARK = "dark"
 }
 
+export declare const Feedback: FC<FeedbackProps>;
+
+export declare type FeedbackGetLabelText = (option: FeedbackOption, index: number, total: number) => string;
+
+export declare interface FeedbackOption {
+    emoji?: ReactNode;
+    label: string;
+    value: number;
+}
+
+declare const feedbackOptionStyles: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+    variant?: "emoji" | "face" | null | undefined;
+} & ClassProp) | undefined) => string;
+
+export declare interface FeedbackProps extends Omit<ComponentPropsWithRef<'div'>, 'defaultValue' | 'onChange'> {
+    defaultValue?: number;
+    disabled?: boolean;
+    getLabelText?: FeedbackGetLabelText;
+    name?: string;
+    onValueChange?: (value: number) => void;
+    options?: FeedbackOption[];
+    readOnly?: boolean;
+    size?: FeedbackSizes;
+    value?: number;
+    variant?: FeedbackVariant;
+}
+
+export declare type FeedbackSizes = RemoveNull_2<VariantProps<typeof feedbackOptionStyles>>['size'];
+
+export declare type FeedbackVariant = 'face' | 'emoji';
+
+export declare const Input: FC<InputProps>;
+
+export declare type InputIcon = FC<SVGProps<SVGSVGElement>>;
+
+export declare interface InputProps extends Omit<ComponentPropsWithRef<'input'>, 'children' | 'prefix' | 'size'> {
+    caption?: ReactNode;
+    clearLabel?: string;
+    clearable?: boolean;
+    containerClassName?: string;
+    error?: ReactNode;
+    fullWidth?: boolean;
+    inputClassName?: string;
+    label?: ReactNode;
+    labelClassName?: string;
+    leadingIcon?: InputIcon;
+    onClear?: () => void;
+    size?: InputSizes;
+    trailingIcon?: InputIcon;
+    variant?: InputVariants;
+}
+
+export declare type InputSizes = ButtonSizes;
+
+export declare type InputVariants = ButtonVariants;
+
+export declare interface InternalTabListProps extends TabsListProps {
+    children: ReactElement<TabProps> | ReactElement<TabProps>[];
+}
+
+export declare interface InternalTabPanelProps extends TabPanelProps {
+    index?: number;
+}
+
+export declare interface InternalTabProps extends TabProps {
+    index?: number;
+    panelId?: string;
+    selected?: boolean;
+}
+
 export declare const Link: FC<LinkProps>;
 
 export declare type LinkIcon = FC<SVGProps<SVGSVGElement>>;
@@ -462,8 +513,70 @@ export declare type LinkUnderline = RemoveNull_2<VariantProps<typeof linkStyles>
 
 export declare type LinkVariants = RemoveNull_2<VariantProps<typeof linkStyles>>['variant'];
 
+export declare const ListBox: ForwardRefExoticComponent<ListBoxProps & RefAttributes<HTMLDivElement>>;
+
+export declare type ListBoxIcon = FC<SVGProps<SVGSVGElement>>;
+
+export declare interface ListBoxItemData {
+    disabled?: boolean;
+    id?: string;
+    label: ReactNode;
+    leadingIcon?: ListBoxIcon;
+    value: string;
+}
+
+export declare interface ListBoxProps extends Omit<ComponentPropsWithoutRef<'div'>, 'children'> {
+    children?: ReactNode;
+    itemRole?: 'option' | 'menuitem';
+    items?: ListBoxItemData[];
+    leadingSlot?: ReactNode;
+    onItemSelect?: (item: ListBoxItemData) => void;
+    selectedValue?: string;
+    size?: ListBoxSizes;
+}
+
+export declare type ListBoxSizes = 'sm' | 'md' | 'lg';
+
+export declare const ListItem: ForwardRefExoticComponent<ListItemProps & RefAttributes<HTMLButtonElement>>;
+
+export declare interface ListItemProps extends Omit<ComponentPropsWithoutRef<'button'>, 'children' | 'disabled' | 'onSelect' | 'value'> {
+    item: ListBoxItemData;
+    onSelect?: (item: ListBoxItemData) => void;
+    selected?: boolean;
+    size?: ListBoxSizes;
+}
+
 export declare const mergeRefs: <T>(...refs: Array<PossibleRef<T>>) => (node: T | null) => (() => void) | undefined;
 
+export declare const Modal: FC<ModalProps>;
+
+export declare type ModalIcon = FC<SVGProps<SVGSVGElement>>;
+
+declare const modalPanelStyles: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & ClassProp) | undefined) => string;
+
+export declare interface ModalProps extends Omit<HTMLAttributes<HTMLDivElement>, 'title'>, RemoveNull_2<VariantProps<typeof modalPanelStyles>> {
+    open: boolean;
+    children?: ReactNode;
+    title?: ReactNode;
+    description?: ReactNode;
+    footer?: ReactNode;
+    onClose?: () => void;
+    closeLabel?: string;
+    closeOnEscape?: boolean;
+    closeOnOverlayClick?: boolean;
+    container?: HTMLElement | null | undefined;
+    containerId?: string | undefined;
+    containerRef?: RefObject<HTMLElement | null> | undefined;
+    disablePortal?: boolean;
+    leadingIcon?: ModalIcon;
+    showCloseButton?: boolean;
+    showOverlay?: boolean;
+}
+
+export declare type ModalSizes = RemoveNull_2<VariantProps<typeof modalPanelStyles>>['size'];
+
 export declare const OrganizationChart: ForwardRefExoticComponent<OrgChartComponentProps & RefAttributes<OrgChartRef>>;
 
 export declare interface OrgChartApiNodeData {
@@ -485,6 +598,7 @@ export declare interface OrgChartApiNodeData {
 export declare interface OrgChartComponentProps extends Omit<ComponentPropsWithoutRef<'div'>, 'onClick'> {
     data: Array<OrgChartNodeData | OrgChartApiNodeData>;
     orientation?: OrgChartOrientation;
+    onOrientationChange?: (orientation: OrgChartOrientation) => void;
     initialDepth?: number;
     imageName?: string;
     onNodeClick?: (nodeId: string) => void;
@@ -528,6 +642,7 @@ export declare interface OrgChartRef {
     zoomOut: () => void;
     resetZoom: () => void;
     resetLevel: () => void;
+    resetOrientation: () => void;
     exportImg: () => void;
     exportSvg: () => void;
     expandAll: () => void;
@@ -581,16 +696,291 @@ declare interface PresenceChildProps {
     children: ReactElement;
 }
 
+export declare const ProgressBar: FC<ProgressBarProps>;
+
+export declare type ProgressBarAppearances = NonNullable<RemoveNull_2<VariantProps<typeof progressBarRootStyles>>['appearance']>;
+
+export declare interface ProgressBarProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    appearance?: ProgressBarAppearances;
+    caption?: ReactNode;
+    captionClassName?: string;
+    fullWidth?: boolean;
+    indicatorClassName?: string;
+    inverted?: boolean;
+    label?: ReactNode;
+    labelClassName?: string;
+    max?: number;
+    min?: number;
+    showDot?: boolean;
+    showValue?: boolean;
+    size?: ProgressBarSizes;
+    trackClassName?: string;
+    value?: number;
+    valueClassName?: string;
+    valueFormatter?: (args: ProgressBarValueFormatterArgs) => ReactNode;
+    variant?: ProgressBarVariants;
+}
+
+declare const progressBarRootStyles: (props?: ({
+    appearance?: "linear" | "circular" | null | undefined;
+    fullWidth?: boolean | null | undefined;
+} & ClassProp) | undefined) => string;
+
+export declare type ProgressBarSizes = NonNullable<RemoveNull_2<VariantProps<typeof progressBarTrackStyles>>['size']>;
+
+declare const progressBarTrackStyles: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+    inverted?: boolean | null | undefined;
+} & ClassProp) | undefined) => string;
+
+export declare interface ProgressBarValueFormatterArgs {
+    max: number;
+    min: number;
+    percentage: number;
+    value: number;
+}
+
+export declare type ProgressBarVariants = ButtonVariants;
+
+export declare const Radio: FC<RadioProps>;
+
+declare const radioControlStyles: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+    invalid?: boolean | null | undefined;
+} & ClassProp) | undefined) => string;
+
+export declare const RadioGroup: FC<RadioGroupProps>;
+
+export declare interface RadioGroupOption extends Omit<RadioProps, 'checked' | 'defaultChecked' | 'children' | 'error' | 'name' | 'ref' | 'required' | 'size' | 'type' | 'value'> {
+    value: string;
+}
+
+export declare type RadioGroupOrientation = 'horizontal' | 'vertical';
+
+export declare interface RadioGroupProps extends Omit<FieldsetHTMLAttributes<HTMLFieldSetElement>, 'children' | 'defaultValue' | 'onChange' | 'value'> {
+    defaultValue?: string;
+    description?: ReactNode;
+    error?: ReactNode;
+    label?: ReactNode;
+    name?: string;
+    onValueChange?: (value: string) => void;
+    options: RadioGroupOption[];
+    orientation?: RadioGroupOrientation;
+    required?: boolean;
+    size?: RadioGroupSizes;
+    value?: string;
+}
+
+export declare type RadioGroupSizes = RadioSizes;
+
+export declare interface RadioProps extends Omit<ComponentPropsWithRef<'input'>, 'children' | 'size' | 'type'> {
+    description?: ReactNode;
+    error?: ReactNode;
+    label?: ReactNode;
+    size?: RadioSizes;
+}
+
+export declare type RadioSizes = RemoveNull_2<VariantProps<typeof radioControlStyles>>['size'];
+
+export declare const Rating: FC<RatingProps>;
+
+export declare type RatingPrecision = 0.5 | 1;
+
+export declare interface RatingProps extends Omit<ComponentPropsWithRef<'div'>, 'defaultValue' | 'onChange'> {
+    defaultValue?: number;
+    disabled?: boolean;
+    getLabelText?: (value: number, max: number) => string;
+    max?: number;
+    name?: string;
+    onValueChange?: (value: number) => void;
+    precision?: RatingPrecision;
+    readOnly?: boolean;
+    size?: RatingSizes;
+    value?: number;
+}
+
+export declare type RatingSizes = RemoveNull_2<VariantProps<typeof ratingStarStyles>>['size'];
+
+declare const ratingStarStyles: (props?: ({
+    size?: "sm" | "md" | "lg" | "xs" | null | undefined;
+} & ClassProp) | undefined) => string;
+
 export declare type RemoveNull<T> = {
     [K in keyof T]: Exclude<T[K], null>;
 };
 
+export declare const Slider: FC<SliderProps>;
+
+export declare type SliderLabelSizes = RemoveNull_2<VariantProps<typeof sliderLabelStyles>>['size'];
+
+declare const sliderLabelStyles: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+    disabled?: boolean | null | undefined;
+} & ClassProp) | undefined) => string;
+
+export declare interface SliderProps extends Omit<ComponentPropsWithRef<'div'>, 'children' | 'defaultValue' | 'onChange'> {
+    caption?: ReactNode;
+    captionClassName?: string;
+    defaultValue?: SliderValue;
+    disabled?: boolean;
+    error?: ReactNode;
+    formatValue?: (value: number) => ReactNode;
+    label?: ReactNode;
+    labelClassName?: string;
+    max?: number;
+    min?: number;
+    onValueChange?: (value: SliderValue) => void;
+    range?: boolean;
+    showMaxLabel?: boolean;
+    showMinLabel?: boolean;
+    showValueLabel?: boolean;
+    size?: SliderSizes;
+    step?: number;
+    thumbClassName?: string;
+    trackClassName?: string;
+    value?: SliderValue;
+    valueClassName?: string;
+}
+
+export declare type SliderSizes = RemoveNull_2<VariantProps<typeof sliderTrackStyles>>['size'];
+
+export declare interface SliderState {
+    max: number;
+    min: number;
+    values: [number, number?];
+}
+
+export declare type SliderThumbSizes = RemoveNull_2<VariantProps<typeof sliderThumbStyles>>['size'];
+
+declare const sliderThumbStyles: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+    disabled?: boolean | null | undefined;
+} & ClassProp) | undefined) => string;
+
+declare const sliderTrackStyles: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+    disabled?: boolean | null | undefined;
+} & ClassProp) | undefined) => string;
+
+export declare type SliderValue = number | [number, number];
+
+export declare const Tab: FC<InternalTabProps>;
+
+export declare type TabKeyboardEvent = KeyboardEvent_2<HTMLDivElement>;
+
+declare const tabListStyles: (props?: ({
+    orientation?: "horizontal" | "vertical" | null | undefined;
+    variant?: "underline" | "pill" | null | undefined;
+} & ClassProp) | undefined) => string;
+
+export declare const TabPanel: FC<TabPanelProps>;
+
+export declare type TabPanelOrientation = RemoveNull_2<VariantProps<typeof tabPanelStyles>>['orientation'];
+
+export declare interface TabPanelProps extends Omit<ComponentPropsWithoutRef<'div'>, 'children'> {
+    children: ReactNode;
+}
+
+declare const tabPanelStyles: (props?: ({
+    orientation?: "horizontal" | "vertical" | null | undefined;
+} & ClassProp) | undefined) => string;
+
+export declare interface TabProps extends Omit<ComponentPropsWithoutRef<'div'>, 'children' | 'id' | 'onClick' | 'onKeyDown' | 'role' | 'tabIndex'> {
+    children: ReactNode;
+    closeLabel?: string;
+    disabled?: boolean;
+    endAdornment?: ReactNode;
+    onClose?: (event: MouseEvent_2<HTMLButtonElement>) => void;
+    startAdornment?: ReactNode;
+    statusDot?: boolean;
+}
+
+declare const tabRootStyles: (props?: ({
+    variant?: "underline" | "pill" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+    orientation?: "horizontal" | "vertical" | null | undefined;
+    selected?: boolean | null | undefined;
+    disabled?: boolean | null | undefined;
+} & ClassProp) | undefined) => string;
+
+export declare const Tabs: FC<TabsProps>;
+
+export declare interface TabsContextValue {
+    baseId: string;
+    disabled: boolean;
+    orientation: NonNullable<TabsProps['orientation']>;
+    selectedIndex: number;
+    setSelectedIndex: (index: number) => void;
+    size: NonNullable<TabsProps['size']>;
+    variant: NonNullable<TabsProps['variant']>;
+}
+
+export declare const TabsList: FC<TabsListProps>;
+
+export declare interface TabsListContextValue extends TabsContextValue {
+    registerTab: (index: number, node: HTMLDivElement | null) => void;
+    focusTab: (index: number) => void;
+    getNextEnabledIndex: (currentIndex: number, direction: 1 | -1) => number;
+    getFirstEnabledIndex: () => number;
+    getLastEnabledIndex: () => number;
+    isTabDisabled: (index: number) => boolean;
+    tabCount: number;
+}
+
+export declare interface TabsListProps extends Omit<ComponentPropsWithoutRef<'div'>, 'children'> {
+    children: ReactNode;
+}
+
+export declare type TabsOrientation = RemoveNull_2<VariantProps<typeof tabsRootStyles>>['orientation'];
+
+export declare interface TabsProps extends Omit<ComponentPropsWithoutRef<'div'>, 'children' | 'defaultValue' | 'onChange'> {
+    children: ReactNode;
+    defaultValue?: number;
+    disabled?: boolean;
+    id?: string;
+    onValueChange?: (value: number) => void;
+    orientation?: TabsOrientation;
+    size?: TabsSizes;
+    value?: number;
+    variant?: TabsVariant;
+}
+
+export declare type TabsRootOrientation = RemoveNull_2<VariantProps<typeof tabListStyles>>['orientation'];
+
+declare const tabsRootStyles: (props?: ({
+    orientation?: "horizontal" | "vertical" | null | undefined;
+} & ClassProp) | undefined) => string;
+
+export declare type TabsSizes = RemoveNull_2<VariantProps<typeof tabRootStyles>>['size'];
+
+export declare type TabsVariant = RemoveNull_2<VariantProps<typeof tabRootStyles>>['variant'];
+
+export declare const Toaster: FC<ToasterProps>;
+
+export declare interface ToastProps extends AlertProps {
+    duration?: number;
+    position?: ToasterProps['position'];
+    dismissable?: boolean;
+}
+
 export declare const useTheme: () => {
     theme: EThemeOptions;
     isDark: boolean;
     setTheme: (theme: EThemeOptions) => void;
 };
 
+export declare const useToast: () => {
+    toast: (props: ToastProps) => string | number;
+    default: (props: Omit<ToastProps, "variant">) => string | number;
+    primary: (props: Omit<ToastProps, "variant">) => string | number;
+    info: (props: Omit<ToastProps, "variant">) => string | number;
+    success: (props: Omit<ToastProps, "variant">) => string | number;
+    warning: (props: Omit<ToastProps, "variant">) => string | number;
+    danger: (props: Omit<ToastProps, "variant">) => string | number;
+    error: (props: Omit<ToastProps, "variant">) => string | number;
+    dismiss: (id?: number | string) => string | number;
+};
+
 export declare const useToggle: () => readonly [boolean, () => void];
 
 export { }