alope-ui 1.1.6 → 1.2.2

package/dist/components/Accordion/Accordion.d.ts

@@ -0,0 +1,18 @@
+import { default as React } from 'react';
+type AccordionItem = {
+    label: string;
+    description: string;
+};
+export type AccordionProps = {
+    data: AccordionItem[];
+    openIndex?: number | number[] | null;
+    single?: boolean;
+    onToggleItem?: (index: number | number[] | null) => void;
+    icon?: React.ReactNode | ((isOpen: boolean) => React.ReactNode);
+    className?: string;
+    labelClassName?: string;
+    labelContainerClassName?: string;
+    descriptionClassName?: string;
+} & React.HTMLAttributes<HTMLDivElement>;
+export declare const Accordion: React.FC<AccordionProps>;
+export {};

package/dist/components/Alert/Alert.d.ts

@@ -0,0 +1,34 @@
+declare const AlertVariants: {
+    outline: string;
+    solid: string;
+};
+declare const IconColors: {
+    success: string;
+    info: string;
+    error: string;
+    warning: string;
+    primary: string;
+    default: string;
+};
+declare const AlertType: {
+    success: string;
+    info: string;
+    warning: string;
+    error: string;
+    primary: string;
+    default: string;
+};
+export type AlertProps = {
+    title: string;
+    description?: string;
+    type?: keyof typeof AlertType;
+    variant?: keyof typeof AlertVariants;
+    icon?: React.ReactNode;
+    withClose?: boolean;
+    titleClassName?: string;
+    descriptionClassName?: string;
+    action?: React.ReactNode | (() => React.ReactNode);
+    iconColor?: keyof typeof IconColors;
+};
+export declare const Alert: React.FC<AlertProps>;
+export {};

package/dist/components/Avatar/Avatar.d.ts

@@ -0,0 +1,38 @@
+import { default as React } from 'react';
+declare const AvatarSize: {
+    sm: string;
+    md: string;
+    lg: string;
+};
+declare const AvatarVariant: {
+    solid: string;
+    outline: string;
+};
+declare const AvatarShape: {
+    sharp: string;
+    cornered: string;
+    rounded: string;
+};
+declare const AvatarFallbackColor: {
+    primary: string;
+    error: string;
+    warning: string;
+    success: string;
+    info: string;
+    secondary: string;
+};
+export type AvatarProps = {
+    imageSrc?: string;
+    shape?: keyof typeof AvatarShape;
+    variant?: keyof typeof AvatarVariant;
+    size?: keyof typeof AvatarSize;
+    ring?: boolean;
+    ringClassName?: string;
+    fallbackName?: string;
+    fallbackColor?: keyof typeof AvatarFallbackColor;
+    alt?: string;
+    status?: 'online' | 'offline';
+    className?: string;
+};
+export declare const Avatar: React.FC<AvatarProps>;
+export {};

package/dist/components/Avatar/AvatarGroup.d.ts

@@ -0,0 +1,10 @@
+import { default as React } from 'react';
+import { AvatarProps } from './Avatar';
+export type AvatarGroupProps = {
+    avatars: AvatarProps[];
+    maxVisible?: number;
+    size?: AvatarProps['size'];
+    overlap?: string;
+    className?: string;
+};
+export declare const AvatarGroup: React.FC<AvatarGroupProps>;

package/dist/components/Badge/Badge.d.ts

@@ -0,0 +1,25 @@
+import { default as React } from 'react';
+declare const BadgeVariants: {
+    default: string;
+    secondary: string;
+    success: string;
+    error: string;
+    info: string;
+    warning: string;
+};
+declare const BadgePositions: {
+    'top-right': string;
+    'top-left': string;
+    'bottom-right': string;
+    'bottom-left': string;
+};
+export type BadgeProps = {
+    children?: React.ReactNode | string;
+    variant?: keyof typeof BadgeVariants;
+    position?: keyof typeof BadgePositions;
+    isAbsolute?: boolean;
+    className?: string;
+    icon?: React.ReactNode;
+} & React.ButtonHTMLAttributes<HTMLSpanElement>;
+export declare const Badge: React.FC<BadgeProps>;
+export {};

package/dist/components/Breadcrumb/Breadcrumb.d.ts

@@ -0,0 +1,16 @@
+import { default as React } from 'react';
+type BreadcrumbItem = {
+    label: string;
+    path?: string;
+    icon?: React.ReactNode;
+};
+type BreadcrumbProps = {
+    data: BreadcrumbItem[];
+    labelClassName?: string;
+    linkClassName?: string;
+    currentLinkClassName?: string;
+    separatorClassName?: string;
+    separator?: React.ReactNode;
+};
+export declare const Breadcrumb: React.FC<BreadcrumbProps>;
+export {};

package/dist/components/Button/Button.d.ts

@@ -0,0 +1,67 @@
+import { default as React } from 'react';
+declare const ButtonSizes: {
+    sm: string;
+    md: string;
+    lg: string;
+};
+declare const ButtonRadius: {
+    regular: string;
+    stadium: string;
+};
+export declare const ButtonVariantsMap: {
+    primary: {
+        solid: string;
+        outline: string;
+        ghost: string;
+        plain: string;
+    };
+    error: {
+        solid: string;
+        outline: string;
+        ghost: string;
+        plain: string;
+    };
+    warning: {
+        solid: string;
+        outline: string;
+        ghost: string;
+        plain: string;
+    };
+    success: {
+        solid: string;
+        outline: string;
+        ghost: string;
+        plain: string;
+    };
+    info: {
+        solid: string;
+        outline: string;
+        ghost: string;
+        plain: string;
+    };
+    secondary: {
+        solid: string;
+        outline: string;
+        ghost: string;
+        plain: string;
+    };
+};
+export type VariantType = keyof typeof ButtonVariantsMap;
+export type Variant = keyof typeof ButtonVariantsMap[VariantType];
+export type ButtonProps = {
+    children?: React.ReactNode | string;
+    onClick?: () => void;
+    size?: keyof typeof ButtonSizes;
+    to?: string;
+    variant?: Variant;
+    variantType?: VariantType;
+    borderType?: keyof typeof ButtonRadius;
+    type?: 'button' | 'submit' | 'reset';
+    disabled?: boolean;
+    fullWidth?: boolean;
+    prefixIcon?: React.ReactNode;
+    suffixIcon?: React.ReactNode;
+    className?: string;
+} & React.ButtonHTMLAttributes<HTMLButtonElement>;
+export declare const Button: React.FC<ButtonProps>;
+export {};

package/dist/components/Card/Card.d.ts

@@ -0,0 +1,19 @@
+import { default as React } from 'react';
+type CardSize = 'sm' | 'md' | 'lg' | 'full';
+type CardProps = {
+    title?: string;
+    description?: string;
+    image?: string | React.ReactNode;
+    onClick?: () => void;
+    horizontal?: boolean;
+    footer?: React.ReactNode;
+    size?: CardSize;
+    containerClassName?: string;
+    imageClassName?: string;
+    titleClassName?: string;
+    descriptionClassName?: string;
+    ribbon?: string;
+    children?: React.ReactNode;
+};
+export declare const Card: React.FC<CardProps>;
+export {};

package/dist/components/CheckboxInput/CheckboxInput.d.ts

@@ -0,0 +1,10 @@
+import { default as React } from 'react';
+export interface CheckboxProps extends React.InputHTMLAttributes<HTMLInputElement> {
+    label?: React.ReactNode;
+    indeterminate?: boolean;
+    checkboxClassName?: string;
+    labelClassName?: string;
+    description?: string;
+    descriptionClassName?: string;
+}
+export declare const CheckboxInput: React.ForwardRefExoticComponent<CheckboxProps & React.RefAttributes<HTMLInputElement>>;

package/dist/components/CheckboxInput/ListCheckboxInput.d.ts

@@ -0,0 +1,55 @@
+import { default as React } from 'react';
+export type CheckboxOptionType = {
+    label: string;
+    value: string;
+};
+declare const CheckboxSizes: {
+    sm: {
+        container: string;
+        checkbox: string;
+        label: string;
+    };
+    md: {
+        container: string;
+        checkbox: string;
+        label: string;
+    };
+    lg: {
+        container: string;
+        checkbox: string;
+        label: string;
+    };
+};
+declare const CheckboxVariants: {
+    solid: {
+        label: string;
+        checked: string;
+        checkbox: string;
+        checkedCheckbox: string;
+    };
+    subtle: {
+        label: string;
+        checked: string;
+        checkbox: string;
+        checkedCheckbox: string;
+    };
+    outline: {
+        label: string;
+        checked: string;
+        checkbox: string;
+        checkedCheckbox: string;
+    };
+};
+export type ListCheckBoxInputProps = {
+    options: CheckboxOptionType[];
+    selectedValues: CheckboxOptionType[] | undefined;
+    onValueChange: (value: CheckboxOptionType[]) => void;
+    containerClassName?: string;
+    inputLabelClassName?: (option: CheckboxOptionType, isChecked: boolean) => string;
+    inputGroupClassName?: (option: CheckboxOptionType, isChecked: boolean) => string;
+    inputCheckboxClassName?: (option: CheckboxOptionType, isChecked: boolean) => string;
+    variant?: keyof typeof CheckboxVariants;
+    checkboxSize?: keyof typeof CheckboxSizes;
+} & Omit<React.InputHTMLAttributes<HTMLInputElement>, 'size'>;
+export declare const ListCheckboxInput: React.FC<ListCheckBoxInputProps>;
+export {};

package/dist/components/FileUpload/FIleUpload.d.ts

@@ -0,0 +1,14 @@
+import { default as React } from 'react';
+interface FileUploadProps {
+    acceptedFiles?: string;
+    maxFiles?: number;
+    helperText?: string;
+    inputLabel?: string;
+    maxByte?: number;
+    mediaCapture?: 'user' | 'environment';
+    mode?: 'dropzone' | 'textinput';
+    clearable?: boolean;
+    onFilesChange: (files: File[]) => void;
+}
+export declare const FileUpload: React.FC<FileUploadProps>;
+export {};

package/dist/components/Modal/Modal.d.ts

@@ -0,0 +1,13 @@
+import { default as React } from 'react';
+type ModalProps = {
+    isOpen: boolean;
+    overlayClose?: boolean;
+    onClose: () => void;
+    title?: string;
+    children: React.ReactNode;
+    showCloseButton?: boolean;
+    size?: 'sm' | 'md' | 'lg' | 'xl';
+    className?: string;
+};
+export declare const Modal: React.FC<ModalProps>;
+export {};

package/dist/components/Offcanvas/Offcanvas.d.ts

@@ -0,0 +1,14 @@
+import { default as React } from 'react';
+interface OffcanvasProps {
+    isOpen: boolean;
+    onClose: () => void;
+    title: string;
+    children: React.ReactNode;
+    position?: 'left' | 'right';
+    width?: 'sm' | 'md' | 'lg';
+    titleClassName?: string;
+    closeButtonClassName?: string;
+    className?: string;
+}
+export declare const Offcanvas: React.FC<OffcanvasProps>;
+export {};

package/dist/components/Pagination/Pagination.d.ts

@@ -0,0 +1,22 @@
+type PaginationProps = {
+    currentPage: number;
+    format?: 'none' | 'long';
+    count?: number;
+    pageSize?: number;
+    simplified?: boolean;
+    asLink?: boolean;
+    getPageHref?: (page: number) => string;
+    totalPages?: number;
+    onPageChange: (page: number) => void;
+    siblingCount?: number;
+    prevIcon?: React.ReactNode;
+    nextIcon?: React.ReactNode;
+    size?: keyof typeof PaginationSizes;
+};
+declare const PaginationSizes: {
+    sm: string;
+    md: string;
+    lg: string;
+};
+export declare const Pagination: React.FC<PaginationProps>;
+export {};

package/dist/components/RadioInput/RadioInput.d.ts

@@ -0,0 +1,55 @@
+import { default as React } from 'react';
+export type RadioOptionType = {
+    label: string;
+    value: string;
+};
+declare const RadioSizes: {
+    sm: {
+        container: string;
+        radio: string;
+        label: string;
+    };
+    md: {
+        container: string;
+        radio: string;
+        label: string;
+    };
+    lg: {
+        container: string;
+        radio: string;
+        label: string;
+    };
+};
+declare const RadioVariants: {
+    solid: {
+        label: string;
+        checked: string;
+        radio: string;
+        checkedRadio: string;
+    };
+    subtle: {
+        label: string;
+        checked: string;
+        radio: string;
+        checkedRadio: string;
+    };
+    outline: {
+        label: string;
+        checked: string;
+        radio: string;
+        checkedRadio: string;
+    };
+};
+export type RadioInputProps = {
+    options: RadioOptionType[];
+    selectedValue?: RadioOptionType;
+    onValueChange: (value: RadioOptionType) => void;
+    containerClassName?: string;
+    inputLabelClassName?: (isChecked: boolean, option: RadioOptionType) => string;
+    inputGroupClassName?: (isChecked: boolean, option: RadioOptionType) => string;
+    inputRadioClassName?: (isChecked: boolean, option: RadioOptionType) => string;
+    variant?: keyof typeof RadioVariants;
+    radioSize?: keyof typeof RadioSizes;
+} & Omit<React.InputHTMLAttributes<HTMLInputElement>, 'size'>;
+export declare const RadioInput: React.FC<RadioInputProps>;
+export {};

package/dist/components/SelectInput/SelectInput.d.ts

@@ -0,0 +1,14 @@
+import { default as React } from 'react';
+import { Props as SelectProps, GroupBase, ClassNamesConfig } from 'react-select';
+export interface SelectOptionType {
+    value: string;
+    label: string;
+}
+export type SelectInputProps = {
+    label?: string;
+    error?: string;
+    labelClassName?: string;
+    errorClassName?: string;
+    customClassNames?: ClassNamesConfig<SelectOptionType, boolean, GroupBase<SelectOptionType>>;
+} & SelectProps<SelectOptionType, boolean, GroupBase<SelectOptionType>>;
+export declare const SelectInput: React.FC<SelectInputProps>;

package/dist/components/Skeleton/Skeleton.d.ts

@@ -0,0 +1,10 @@
+import { default as React } from 'react';
+export type SkeletonProps = {
+    width?: string;
+    height?: string;
+    rounded?: boolean;
+    isLoading?: boolean;
+    children?: React.ReactNode;
+    animode?: "shimmer" | "flash";
+};
+export declare const Skeleton: React.FC<SkeletonProps>;

package/dist/components/Spinner/Spinner.d.ts

@@ -0,0 +1,23 @@
+import { default as React } from 'react';
+declare const SpinnerSize: {
+    sm: string;
+    md: string;
+    lg: string;
+};
+declare const SpinnerColor: {
+    primary: string;
+    error: string;
+    warning: string;
+    success: string;
+    info: string;
+    secondary: string;
+};
+export type SpinnerProps = {
+    size?: keyof typeof SpinnerSize;
+    color?: keyof typeof SpinnerColor;
+    className?: string;
+    duration?: number;
+    thickness?: number | undefined;
+};
+export declare const Spinner: React.FC<SpinnerProps>;
+export {};

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

@@ -0,0 +1,34 @@
+export type Column<T> = {
+    header: string;
+    accessor: keyof T;
+    render?: (value: T[keyof T], row: T) => React.ReactNode;
+};
+declare const TableSize: {
+    sm: string;
+    md: string;
+    lg: string;
+};
+export type TableType<T> = {
+    columns: Column<T>[];
+    data: T[];
+    striped?: boolean;
+    stripeColor?: string;
+    headerClassName?: string;
+    dataColumnClassName?: string;
+    dataRowClassName?: string;
+    tableClassName?: string;
+    captionClassName?: string;
+    containerClassName?: string;
+    customEmptyData?: React.ReactNode;
+    size?: keyof typeof TableSize;
+    caption?: string;
+    captionPosition?: 'top' | 'bottom';
+    stickyHeader?: boolean;
+    selectable?: boolean;
+    onSelectionChange?: (selected: T[]) => void;
+    selectedRows?: T[];
+};
+export declare function Table<T extends {
+    id: any;
+}>({ columns, data, striped, stripeColor, headerClassName, dataColumnClassName, dataRowClassName, customEmptyData, tableClassName, captionClassName, containerClassName, size, caption, captionPosition, stickyHeader, selectable, onSelectionChange, selectedRows, }: TableType<T>): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,57 @@
+declare const TabsVariants: {
+    line: {
+        wrapper: string;
+        button: string;
+        active: string;
+        inactive: string;
+    };
+    solid: {
+        wrapper: string;
+        button: string;
+        active: string;
+        inactive: string;
+    };
+    subtle: {
+        wrapper: string;
+        button: string;
+        active: string;
+        inactive: string;
+    };
+    inline: {
+        wrapper: string;
+        button: string;
+        active: string;
+        inactive: string;
+    };
+    outline: {
+        wrapper: string;
+        button: string;
+        active: string;
+        inactive: string;
+    };
+    plain: {
+        wrapper: string;
+        button: string;
+        active: string;
+        inactive: string;
+    };
+};
+export type Tabs = {
+    label: string;
+    content: React.ReactNode;
+    disabled?: boolean;
+    link?: string;
+};
+export type TabsProps = {
+    tabs: Tabs[];
+    variant?: keyof typeof TabsVariants;
+    fitted?: boolean;
+    wrapperClassName?: string;
+    buttonClassName?: string;
+    activeClassName?: string;
+    inactiveClassName?: string;
+    activeTab?: number;
+    onTabChange?: (index: number) => void;
+};
+export declare const Tabs: React.FC<TabsProps>;
+export {};

package/dist/components/TextInput/TextInput.d.ts

@@ -0,0 +1,6 @@
+import { default as React, InputHTMLAttributes } from 'react';
+export type TextInputProps = {
+    label?: string;
+    error?: string;
+} & InputHTMLAttributes<HTMLInputElement>;
+export declare const TextInput: React.FC<TextInputProps>;

package/dist/components/Textarea/Textarea.d.ts

@@ -0,0 +1,8 @@
+import { default as React, InputHTMLAttributes } from 'react';
+export type TextareaType = {
+    label?: string;
+    error?: string;
+    autoResize?: boolean;
+    customClassName?: string;
+} & InputHTMLAttributes<HTMLTextAreaElement>;
+export declare const Textarea: React.FC<TextareaType>;

package/dist/components/Toast/Toast.d.ts

@@ -0,0 +1,28 @@
+import { default as React } from 'react';
+export interface ToastProps {
+    title?: string;
+    message: string;
+    type: keyof typeof ToastTypes;
+    position?: keyof typeof ToastPositions;
+    variant?: keyof typeof ToastVariants;
+    icon?: React.ReactNode;
+    onClose?: () => void;
+}
+export declare const ToastVariants: {
+    outline: string;
+    solid: string;
+};
+export declare const ToastPositions: {
+    topLeft: string;
+    bottomLeft: string;
+    topRight: string;
+    bottomRight: string;
+};
+export declare const ToastTypes: {
+    success: string;
+    info: string;
+    warning: string;
+    error: string;
+};
+declare const Toast: React.FC<ToastProps>;
+export default Toast;

package/dist/components/Toast/ToastProvider.d.ts

@@ -0,0 +1,11 @@
+import { default as React } from 'react';
+import { ToastProps } from './Toast';
+interface ToastContextType {
+    addToast: ({ title, message, type, variant, icon, onClose }: ToastProps) => void;
+}
+export declare const useToast: () => ToastContextType;
+interface ToastProviderProps {
+    children: React.ReactNode;
+}
+export declare const ToastProvider: React.FC<ToastProviderProps>;
+export {};

package/dist/components/Toggle/Toggle.d.ts

@@ -0,0 +1,27 @@
+import { InputHTMLAttributes } from 'react';
+export declare const ToggleVariant: {
+    primary: string;
+    error: string;
+    warning: string;
+    success: string;
+    info: string;
+    secondary: string;
+};
+export declare const ToggleThumbShape: {
+    stadium: string;
+    rounded: string;
+};
+export declare const ToggleSize: {
+    sm: string;
+    md: string;
+    lg: string;
+};
+export type ToggleProps = {
+    customSize?: keyof typeof ToggleSize;
+    variant?: keyof typeof ToggleVariant;
+    thumbShape?: keyof typeof ToggleThumbShape;
+    label?: string;
+    wrapperClassName?: string;
+    labelClassName?: string;
+} & InputHTMLAttributes<HTMLInputElement>;
+export declare const Toggle: React.FC<ToggleProps>;

package/dist/components/Tooltip/Tooltip.d.ts

@@ -0,0 +1,14 @@
+export type TooltipProps = {
+    children: React.ReactNode;
+    text: string;
+    showArrow?: boolean;
+    placement?: 'top' | 'bottom' | 'left' | 'right';
+    offset?: number;
+    bgColor?: string;
+    isOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    disabled?: boolean;
+    animationDuration?: number;
+    delay?: number;
+};
+export declare const Tooltip: React.FC<TooltipProps>;