alope-ui 1.2.0 → 1.2.3

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;
+    secondary: string;
+};
+declare const AlertType: {
+    success: string;
+    info: string;
+    warning: string;
+    error: string;
+    primary: string;
+    secondary: 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/BottomNavbar/BottomNavbar.d.ts

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+interface BottomNavbarProps {
+    children: React.ReactNode;
+    className?: string;
+    value: string;
+    onChangeValue: (value: string) => void;
+}
+export declare const BottomNavbar: React.FC<BottomNavbarProps>;
+export {};

package/dist/components/BottomNavbar/BottomNavbarAction.d.ts

@@ -0,0 +1,11 @@
+import { default as React } from 'react';
+export interface BottomNavbarActionProps {
+    label?: React.ReactNode;
+    icon?: React.ReactNode;
+    value: string;
+    selectedValue?: string;
+    onChangeValue?: (value: string) => void;
+    labelClassName?: string;
+    className?: string;
+}
+export declare const BottomNavbarAction: React.FC<BottomNavbarActionProps>;

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,68 @@
+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;
+    };
+    secondary: {
+        solid: string;
+        outline: string;
+        ghost: string;
+        plain: string;
+    };
+    success: {
+        solid: string;
+        outline: string;
+        ghost: string;
+        plain: string;
+    };
+    warning: {
+        solid: string;
+        outline: string;
+        ghost: string;
+        plain: string;
+    };
+    error: {
+        solid: string;
+        outline: string;
+        ghost: string;
+        plain: string;
+    };
+    info: {
+        solid: string;
+        outline: string;
+        ghost: string;
+        plain: string;
+    };
+};
+export type VariantType = keyof typeof ButtonVariantsMap;
+export type Variant = keyof typeof ButtonVariantsMap[VariantType];
+export declare const getVariantClasses: (variant: Variant, variantType: VariantType) => string;
+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,20 @@
+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;
+    ribbonClassName?: 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/CodeInput/CodeInput.d.ts

@@ -0,0 +1,17 @@
+import { InputHTMLAttributes } from 'react';
+declare const CodeInputSize: {
+    sm: string;
+    md: string;
+    lg: string;
+    xl: string;
+};
+export type CodeInputProps = {
+    label?: string;
+    value: string;
+    length: number;
+    labelClassName?: string;
+    onCodeChange: (code: string) => void;
+    inputSize?: keyof typeof CodeInputSize;
+} & Omit<InputHTMLAttributes<HTMLInputElement>, 'onChange'>;
+export declare const CodeInput: React.FC<CodeInputProps>;
+export {};

package/dist/components/Collection/Collection.d.ts

@@ -0,0 +1,14 @@
+export type CollectionProps<T> = {
+    title?: string;
+    data: T[];
+    children?: (item: T, index: number, isActive: boolean) => React.ReactNode;
+    className?: string;
+    wrapperClassName?: string;
+    suffixIcon?: React.ReactNode | ((item?: T, index?: number, isActive?: boolean) => React.ReactNode);
+    activeItem?: any;
+    onChangeActive?: (item: T, index: number) => void;
+};
+export declare function Collection<T extends {
+    id: any;
+    name?: string;
+}>({ data, title, className, wrapperClassName, children, suffixIcon, activeItem, onChangeActive, }: CollectionProps<T>): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,47 @@
+import { default as React, InputHTMLAttributes } from 'react';
+declare const DatePickerColors: {
+    success: {
+        input: string;
+        outline: string;
+        header: string;
+        icon: string;
+        day: string;
+    };
+    info: {
+        input: string;
+        outline: string;
+        header: string;
+        icon: string;
+        day: string;
+    };
+    error: {
+        input: string;
+        outline: string;
+        header: string;
+        icon: string;
+        day: string;
+    };
+    warning: {
+        input: string;
+        outline: string;
+        header: string;
+        icon: string;
+        day: string;
+    };
+    default: {
+        input: string;
+        outline: string;
+        header: string;
+        icon: string;
+        day: string;
+    };
+};
+type DatePickerProps = {
+    label?: string;
+    selectedDate?: Date;
+    labelClassName?: string;
+    color?: keyof typeof DatePickerColors;
+    onDateChange?: (date: Date) => void;
+} & InputHTMLAttributes<HTMLInputElement>;
+export declare const DatePicker: React.FC<DatePickerProps>;
+export {};

package/dist/components/FAB/FAB.d.ts

@@ -0,0 +1,18 @@
+import { Variant, VariantType } from '../Button/Button';
+declare const FABSizes: {
+    sm: string;
+    md: string;
+    lg: string;
+};
+type FABProps = {
+    children: React.ReactNode;
+    direction?: 'horizontal' | 'vertical';
+    size?: keyof typeof FABSizes;
+    variant?: Variant;
+    variantType?: VariantType;
+    isOpen: boolean;
+    onOpen: () => void;
+    icon?: React.ReactNode;
+};
+export declare const FAB: ({ children, direction, size, variant, variantType, isOpen, onOpen, icon }: FABProps) => import("react/jsx-runtime").JSX.Element;
+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;
+    maxKiloByte?: number;
+    mediaCapture?: 'user' | 'environment';
+    mode?: 'dropzone' | 'textinput';
+    clearable?: boolean;
+    onFilesChange: (files: File[]) => void;
+}
+export declare const FileUpload: React.FC<FileUploadProps>;
+export {};

package/dist/components/Grid/Grid.d.ts

@@ -0,0 +1,12 @@
+import { default as React, HTMLAttributes } from 'react';
+type Breakpoint = 'base' | 'md' | 'lg' | 'xl' | 'lg' | 'xl' | '2xl';
+export type ResponsiveValue<T extends number | string> = T | Partial<Record<Breakpoint, T>>;
+type ResponsiveCols = ResponsiveValue<1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12>;
+type ResponsiveGap = ResponsiveValue<1 | 2 | 3 | 4 | 5 | 6>;
+export interface GridProps extends HTMLAttributes<HTMLDivElement> {
+    children: React.ReactNode;
+    cols?: ResponsiveCols;
+    gap?: ResponsiveGap;
+}
+export declare const Grid: ({ className, cols, gap, children, style, ...props }: GridProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/Grid/GridItem.d.ts

@@ -0,0 +1,10 @@
+import { default as React, HTMLAttributes } from 'react';
+type Breakpoint = 'base' | 'md' | 'lg' | 'xl' | 'lg' | 'xl' | '2xl';
+export type ResponsiveValue<T extends number | string> = T | Partial<Record<Breakpoint, T>>;
+type ResponsiveColSpan = ResponsiveValue<1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12>;
+export interface GridItemProps extends HTMLAttributes<HTMLDivElement> {
+    children: React.ReactNode;
+    colSpan?: ResponsiveColSpan;
+}
+export declare const GridItem: ({ className, colSpan, children, ...props }: GridItemProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/Masonry/Masonry.d.ts

@@ -0,0 +1,13 @@
+import { default as React } from 'react';
+type Breakpoint = "base" | "sm" | "md" | "lg" | "xl" | "lg" | "xl" | "2xl";
+export type ResponsiveValue<T extends number | string> = T | Partial<Record<Breakpoint, T>>;
+type ResponsiveCols = ResponsiveValue<1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12>;
+type ResponsiveGap = ResponsiveValue<1 | 2 | 3 | 4 | 5 | 6>;
+export interface MasonryProps extends React.HTMLAttributes<HTMLDivElement> {
+    children: React.ReactNode;
+    className?: string;
+    cols?: ResponsiveCols;
+    gap?: ResponsiveGap;
+}
+export declare const Masonry: React.ForwardRefExoticComponent<MasonryProps & React.RefAttributes<HTMLDivElement>>;
+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,20 @@
+import { default as React } from 'react';
+declare const OffcanvasWidthVariants: {
+    default: string;
+    sm: string;
+    md: string;
+    lg: string;
+};
+interface OffcanvasProps {
+    isOpen: boolean;
+    onClose: () => void;
+    title: string;
+    children: React.ReactNode;
+    position?: 'left' | 'right';
+    width?: keyof typeof OffcanvasWidthVariants;
+    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/Slider/Slider.d.ts

@@ -0,0 +1,26 @@
+import { InputHTMLAttributes } from 'react';
+declare const SliderColor: {
+    primary: string;
+    error: string;
+    warning: string;
+    success: string;
+    info: string;
+    secondary: string;
+};
+declare const SliderSize: {
+    sm: string;
+    md: string;
+    lg: string;
+    xl: string;
+};
+export type SliderProps = {
+    label?: string;
+    prefixIcon?: React.ReactNode;
+    suffixIcon?: React.ReactNode;
+    color?: keyof typeof SliderColor;
+    sliderSize?: keyof typeof SliderSize;
+    showTooltip?: boolean;
+    showMarks?: boolean;
+} & InputHTMLAttributes<HTMLInputElement>;
+export declare const Slider: React.FC<SliderProps>;
+export {};

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 {};