ono-react-element 0.0.0

package/dist/types/components/AvatarCrop/types.d.ts

@@ -0,0 +1,42 @@
+import { Dispatch, JSX, SetStateAction } from 'react';
+type imageStateType = {
+    w: number;
+    h: number;
+    t: number;
+    l: number;
+};
+export interface AvatarBaseProps {
+    imageFile: File | string;
+    cvsW?: number | string;
+    maskBG?: string;
+    border?: string;
+    wheelScale?: number;
+}
+export interface AvatarCanvasProps extends AvatarBaseProps {
+    maskInfo: {
+        w: number;
+        l: number;
+    };
+    setMaskInfo: Dispatch<SetStateAction<{
+        w: number;
+        l: number;
+    }>>;
+    setCtx: Dispatch<SetStateAction<CanvasRenderingContext2D | undefined>>;
+    imageStartState: imageStateType;
+    setImageStartState: Dispatch<SetStateAction<imageStateType>>;
+    imageState: imageStateType;
+    setImageState: Dispatch<SetStateAction<imageStateType>>;
+}
+export interface AvatarCropProps extends AvatarBaseProps {
+    children?: ({ handleConfirm, handleReduction }: {
+        handleConfirm: AvatarCropConfirmMethod;
+        handleReduction: (onReductionSuccess?: () => void) => void;
+    }) => JSX.Element;
+}
+export type UpdateStateMethod = <T>(state: Partial<T>, setState: React.Dispatch<React.SetStateAction<T>>) => void;
+export type AvatarCropConfirmMethod = (handleSave: (avatarData: string | Blob) => void, options?: {
+    imageSaveType: 'png' | 'jpeg' | 'webp';
+    dataSaveType: 'base64' | 'blob';
+    quality: number;
+}) => void;
+export {};

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

@@ -0,0 +1,2 @@
+import { ButtonProps } from './types';
+export declare const Button: ({ onClick, children, disabled, loading, plain, shape, htmlType, type, className, style, icon }: ButtonProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,2 @@
+export { Button } from './Button';
+export * from './types';

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

@@ -0,0 +1,20 @@
+import { CSSProperties, ReactNode } from 'react';
+export type ButtonType = 'primary' | 'info' | 'success' | 'warning' | 'danger' | 'default';
+export type ButtonHtmlType = 'button' | 'submit' | 'reset';
+export type ButtonShapeType = 'circle' | 'round' | 'default';
+export interface ButtonProps {
+    htmlType?: ButtonHtmlType;
+    type?: ButtonType;
+    icon?: ReactNode;
+    shape?: ButtonShapeType;
+    plain?: boolean;
+    disabled?: boolean | (() => boolean);
+    loading?: boolean | {
+        delay?: number;
+        icon?: ReactNode;
+    };
+    children: ReactNode;
+    className?: string;
+    style?: CSSProperties;
+    onClick?: (e: React.MouseEvent<HTMLButtonElement>) => void;
+}

package/dist/types/components/Card3D/Card3D.d.ts

@@ -0,0 +1,12 @@
+interface Card3DProps {
+    src?: string;
+    scale?: number;
+    shadow?: string;
+    enlarge?: boolean;
+    xRange?: [number, number];
+    yRange?: [number, number];
+    children?: React.ReactNode;
+    borderRadius?: number | string;
+}
+export declare const Card3D: ({ src, children, enlarge, scale, shadow, xRange, yRange, borderRadius }: Card3DProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/Card3D/index.d.ts

@@ -0,0 +1 @@
+export { Card3D } from './Card3D';

package/dist/types/components/Checkbox/Checkbox.d.ts

@@ -0,0 +1,2 @@
+import { CheckboxProps } from './types';
+export declare const Checkbox: ({ id, style, checked, onChange, className, indeterminate, checkedColor, indeterminateStyle, indeterminateColor }: CheckboxProps) => import("react/jsx-runtime").JSX.Element;

package/dist/types/components/Checkbox/index.d.ts

@@ -0,0 +1,2 @@
+export { Checkbox } from './Checkbox';
+export * from './types';

package/dist/types/components/Checkbox/types.d.ts

@@ -0,0 +1,12 @@
+import { ChangeEvent, CSSProperties } from 'react';
+export type CheckboxProps = {
+    id?: string;
+    checked: boolean;
+    className?: string;
+    style?: CSSProperties;
+    checkedColor?: string;
+    indeterminate?: boolean;
+    indeterminateColor?: string;
+    indeterminateStyle?: 'line' | 'border';
+    onChange: (e: ChangeEvent<HTMLInputElement>) => void;
+};

package/dist/types/components/InjunctiveBox/InjunctiveBox.d.ts

@@ -0,0 +1,18 @@
+import { CSSProperties, ReactNode } from 'react';
+interface BoxProps {
+    className?: string;
+    style?: CSSProperties;
+    content: ReactNode | ((onClose: (onDestroy?: () => void) => void) => ReactNode);
+    onClick?: (e: React.MouseEvent) => void;
+    onDoubleClick?: (e: React.MouseEvent) => void;
+    onContextMenu?: (e: React.MouseEvent) => void;
+    onMouseDown?: (e: React.MouseEvent) => void;
+    onMouseUp?: (e: React.MouseEvent) => void;
+    onMouseEnter?: (e: React.MouseEvent) => void;
+    onMouseLeave?: (e: React.MouseEvent) => void;
+    onMouseMove?: (e: React.MouseEvent) => void;
+    isSingle?: boolean;
+    isClickBoxToClose?: boolean;
+}
+export declare const injunctiveBox: (options: BoxProps) => HTMLDivElement;
+export {};

package/dist/types/components/InjunctiveBox/index.d.ts

@@ -0,0 +1 @@
+export { injunctiveBox } from './InjunctiveBox';

package/dist/types/components/Input/Input.d.ts

@@ -0,0 +1,2 @@
+import { InputProps } from './types';
+export declare const OnoInput: ({ id, name, max, min, maxLength, minLength, type, className, defaultValue, placeholder, readonly, autocomplete, autofocus, form, disabled, clearable, showPassword, prepend, append, prefix, suffix, showCount, border, boxShadow, value, onChange, onFocus, onBlur, onClear }: InputProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,2 @@
+import { TextareaProps } from './types';
+export declare const OnoTextarea: ({ id, name, rows, maxLength, minLength, className, placeholder, readonly, resize, autocomplete, autofocus, form, disabled, autoSize, showCount, border, boxShadow, value, onChange }: TextareaProps) => import("react/jsx-runtime").JSX.Element;

package/dist/types/components/Input/index.d.ts

@@ -0,0 +1,2 @@
+export { OnoInput } from './Input';
+export { OnoTextarea } from './Textarea';

package/dist/types/components/Input/types.d.ts

@@ -0,0 +1,46 @@
+import { ChangeEvent, ReactNode } from 'react';
+interface InputBaseProps {
+    id?: string;
+    className?: string;
+    name?: string;
+    defaultValue?: string;
+    placeholder?: string;
+    readonly?: boolean;
+    autofocus?: boolean;
+    autocomplete?: string;
+    form?: string;
+    maxLength?: number;
+    minLength?: number;
+    disabled?: boolean;
+    showCount?: boolean;
+    border?: string;
+    boxShadow?: string;
+    value?: string;
+}
+export interface InputProps extends InputBaseProps {
+    max?: number;
+    min?: number;
+    type?: HTMLInputElement['type'];
+    showPassword?: boolean;
+    clearable?: boolean;
+    prepend?: ReactNode;
+    append?: ReactNode;
+    prefix?: ReactNode;
+    suffix?: ReactNode;
+    onClear?: () => void;
+    onChange?: (event: ChangeEvent<HTMLInputElement>) => void;
+    onFocus?: (event: ChangeEvent<HTMLInputElement>) => void;
+    onBlur?: (event: ChangeEvent<HTMLInputElement>) => void;
+}
+export interface TextareaProps extends InputBaseProps {
+    rows?: number;
+    resize?: boolean;
+    autoSize?: boolean | {
+        minRows?: number;
+        maxRows?: number;
+    };
+    onChange?: (event: ChangeEvent<HTMLTextAreaElement>) => void;
+    onFocus?: (event: ChangeEvent<HTMLTextAreaElement>) => void;
+    onBlur?: (event: ChangeEvent<HTMLTextAreaElement>) => void;
+}
+export {};

package/dist/types/components/List/AwaitList.d.ts

@@ -0,0 +1,3 @@
+import { ReactNode } from 'react';
+import { AwaitListProps } from './types';
+export declare const AwaitList: <T>({ list, children, fallback, deps, insertBetweenDom }: AwaitListProps<T>) => ReactNode | ReactNode[];

package/dist/types/components/List/List.d.ts

@@ -0,0 +1,3 @@
+import { ReactNode } from 'react';
+import { ListProps } from './types';
+export declare const List: <T>({ list, children, fallback, insertBetweenDom }: ListProps<T>) => ReactNode;

package/dist/types/components/List/index.d.ts

@@ -0,0 +1,2 @@
+export { AwaitList } from './AwaitList';
+export { List } from './List';

package/dist/types/components/List/types.d.ts

@@ -0,0 +1,11 @@
+import { DependencyList, ReactNode } from 'react';
+export interface ListProps<T> {
+    list: T[] | (() => T[]);
+    children: (item: T, index: number) => ReactNode;
+    fallback?: ReactNode | ReactNode[];
+    insertBetweenDom?: (i: number) => ReactNode;
+}
+export interface AwaitListProps<T> extends Omit<ListProps<T>, 'list'> {
+    list: T[] | (() => T[]) | (() => Promise<T[]>);
+    deps?: DependencyList;
+}

package/dist/types/components/MenuButton/MenuButton.d.ts

@@ -0,0 +1,2 @@
+import { MenuButtonProps } from './types';
+export declare const MenuButton: ({ active, onchange, w, duration, clr, bgc }: MenuButtonProps) => import("react/jsx-runtime").JSX.Element;

package/dist/types/components/MenuButton/index.d.ts

@@ -0,0 +1 @@
+export { MenuButton } from './MenuButton';

package/dist/types/components/MenuButton/types.d.ts

@@ -0,0 +1,8 @@
+export interface MenuButtonProps {
+    w?: string;
+    clr?: string;
+    bgc?: string;
+    active?: boolean;
+    duration?: number;
+    onchange?: (bl: boolean) => void;
+}

package/dist/types/components/Message/Message.d.ts

@@ -0,0 +1,8 @@
+import { MessageProps } from './types';
+export declare const message: {
+    info: (props: string | MessageProps) => void;
+    success: (props: string | MessageProps) => void;
+    warning: (props: string | MessageProps) => void;
+    error: (props: string | MessageProps) => void;
+    loading: (props: string | MessageProps) => void;
+};

package/dist/types/components/Message/index.d.ts

@@ -0,0 +1 @@
+export { message } from './Message';

package/dist/types/components/Message/types.d.ts

@@ -0,0 +1,20 @@
+import { ReactNode } from 'react';
+export type MessageType = 'success' | 'error' | 'info' | 'warning' | 'loading';
+export interface OnoMessageProps {
+    id: string;
+    plain?: boolean;
+    instancesKey?: string;
+    type: MessageType;
+    duration?: number;
+    message: ReactNode | ((icon: ReactNode, closeButton?: ReactNode) => ReactNode);
+    speed?: number;
+    offset?: number;
+    showClose?: boolean;
+    zIndex?: number;
+    onClose?: () => void;
+    destroy: (onDestroy?: () => void) => void;
+}
+export type MessageSignificantProps = Omit<OnoMessageProps, 'id' | 'instancesKey' | 'plain' | 'offset' | 'zIndex' | 'destroy'>;
+export type MessageProps = Omit<OnoMessageProps, 'id' | 'type' | 'destroy' | 'instancesKey'> & {
+    key?: string;
+};

package/dist/types/components/Message/utils.d.ts

@@ -0,0 +1,23 @@
+import { JSX, ReactNode } from 'react';
+interface OffsetOptionsType {
+    topOffset: number;
+    height: number;
+    bottomOffset: number;
+}
+interface InstanceType {
+    id: string;
+    key: string;
+    reactNode: ReactNode;
+    props: unknown;
+    offsetOptions: OffsetOptionsType;
+    destroy: (onDestroy?: () => void) => void;
+}
+export declare const createInstancesList: <T extends {
+    instancesKey?: string;
+}>(Component: (props: T) => JSX.Element, props: Omit<T, "id" | "destroy">, idPrefix?: string) => InstanceType[];
+export declare const deleteCurrentInstance: (id: string) => void;
+export declare const changeCurrentInstanceOffsetOptions: (id: string, offsetOptions: OffsetOptionsType) => void;
+export declare const getPreviousTopOffset: (id: string) => number;
+export declare const getPreviousBottomOffset: (id: string) => number;
+export declare const getSameKeyInstanceProps: (key: string) => unknown;
+export {};

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

@@ -0,0 +1,2 @@
+import { ModalBoxProps } from './types';
+export declare const Modal: (options: ModalBoxProps) => (onDestroy?: (() => void) | undefined) => void;

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

@@ -0,0 +1 @@
+export { Modal } from './Modal';

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

@@ -0,0 +1,27 @@
+import { FC, ReactNode } from 'react';
+export type ModalBoxProps = {
+    title?: ReactNode;
+    icon?: ReactNode;
+    content?: ReactNode;
+    okText?: string;
+    cancelText?: string;
+    isLoading?: boolean;
+    position?: {
+        x: number;
+        y: number;
+    };
+    confirmDisabled?: boolean;
+    cancelDisabled?: boolean;
+    onConfirm?: () => void | Promise<void>;
+    onCancel?: () => void | Promise<void>;
+    mask?: boolean;
+    maskClosable?: boolean;
+    width?: string | number;
+    btnClr?: string;
+    footer?: (({ OkBtn, CancelBtn, handleClose }: {
+        OkBtn: FC;
+        CancelBtn: FC;
+        handleClose: () => void;
+    }) => ReactNode) | null;
+    modalBody?: (handleClose: () => void) => ReactNode;
+};

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

@@ -0,0 +1,2 @@
+import { PaginationProps } from './types';
+export declare const Pagination: ({ firstBtn, lastBtn, currentPage, total, prevBtn, nextBtn, styles, className, children, onChange, pageBtnClassName, pageBtnActiveClassName, hiddenNextBtnOnLastPage, hiddenPrevBtnOnFirstPage }: PaginationProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1 @@
+export { Pagination } from './Pagination';

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

@@ -0,0 +1,20 @@
+import { CSSProperties, ReactNode } from 'react';
+export interface PaginationProps {
+    firstBtn?: ReactNode;
+    lastBtn?: ReactNode;
+    currentPage: number;
+    total: number;
+    prevBtn?: ReactNode | ((isActive: boolean) => ReactNode);
+    nextBtn?: ReactNode | ((isActive: boolean) => ReactNode);
+    className?: string;
+    styles?: CSSProperties;
+    pageBtnClassName?: string;
+    children?: ({ page, isActive }: {
+        page: number;
+        isActive: boolean;
+    }) => ReactNode;
+    pageBtnActiveClassName?: string;
+    hiddenPrevBtnOnFirstPage?: boolean;
+    hiddenNextBtnOnLastPage?: boolean;
+    onChange: (page: number) => void;
+}

package/dist/types/components/PortalRenderer/PortalRenderer.d.ts

@@ -0,0 +1,2 @@
+import { JSX } from 'react';
+export declare const portalRenderer: <T>(Component: (props: T) => JSX.Element, props: Omit<T, "destroy">, id?: string, rootId?: string) => (onDestroy?: () => void) => void;

package/dist/types/components/PortalRenderer/index.d.ts

@@ -0,0 +1 @@
+export { portalRenderer } from './PortalRenderer';

package/dist/types/components/Radio/Radio.d.ts

@@ -0,0 +1,2 @@
+import { RadioProps } from './types';
+export declare const Radio: <T>({ name, value, style, checked, onChange, children, className, radioW, radioGap, checkedColor, unCheckedColor, disabled }: RadioProps<T>) => import("react/jsx-runtime").JSX.Element;

package/dist/types/components/Radio/RadioGroup.d.ts

@@ -0,0 +1,2 @@
+import { RadioGroupProps } from './types';
+export declare const RadioGroup: <T>({ name, style, options, onChange, className, radioW, radioGap, labelPosition, checkedColor, unCheckedColor, value: selectedValue }: RadioGroupProps<T>) => import("react/jsx-runtime").JSX.Element;

package/dist/types/components/Radio/index.d.ts

@@ -0,0 +1,2 @@
+export { Radio } from './Radio';
+export { RadioGroup } from './RadioGroup';

package/dist/types/components/Radio/types.d.ts

@@ -0,0 +1,26 @@
+import { CSSProperties, ReactNode } from 'react';
+type RadioItemType<T> = {
+    value: T;
+    label: string;
+    disabled?: boolean | ((value: T) => boolean);
+};
+export interface RadioProps<T> {
+    value: T;
+    name?: string;
+    checked: boolean;
+    className?: string;
+    disabled?: boolean;
+    children?: ReactNode;
+    style?: CSSProperties;
+    checkedColor?: string;
+    unCheckedColor?: string;
+    radioW?: number | string;
+    radioGap?: number | string;
+    onChange: (e: React.ChangeEvent<HTMLInputElement>) => void;
+}
+export interface RadioGroupProps<T> extends Omit<RadioProps<T>, 'children' | 'checked' | 'onChange' | 'disabled'> {
+    options: RadioItemType<T>[];
+    labelPosition?: 'left' | 'right';
+    onChange: (value: T) => void;
+}
+export {};

package/dist/types/components/Select/Option.d.ts

@@ -0,0 +1,2 @@
+import { OptionProps } from './types';
+export declare const OnoOption: ({ label, value, disabled, onChange, optionRender, currentValue }: OptionProps) => import("react/jsx-runtime").JSX.Element;

package/dist/types/components/Select/Select.d.ts

@@ -0,0 +1,2 @@
+import { SelectProps } from './types';
+export declare const OnoSelect: ({ options, defaultValue, placeholder, inputBorder, isShowArrow, disabled, clearable, selectClassName, optionsClassName, filterable, notFoundContent, optionRender, onClear, onChange, filterMethod }: SelectProps) => import("react/jsx-runtime").JSX.Element;

package/dist/types/components/Select/index.d.ts

@@ -0,0 +1 @@
+export { OnoSelect } from './Select';

package/dist/types/components/Select/types.d.ts

@@ -0,0 +1,30 @@
+import { ReactNode } from 'react';
+export interface SelectOption {
+    label: string;
+    value: string | number;
+    disabled?: boolean;
+}
+export interface SelectProps {
+    options: SelectOption[];
+    defaultValue?: string | number;
+    placeholder?: string;
+    isShowArrow?: boolean;
+    inputBorder?: string;
+    disabled?: boolean;
+    clearable?: boolean;
+    selectClassName?: string;
+    optionsClassName?: string;
+    filterable?: boolean;
+    notFoundContent?: ReactNode;
+    labelRender?: (option: SelectOption) => ReactNode;
+    optionRender?: (option: SelectOption, isSelected: boolean) => ReactNode;
+    onClear?: () => void;
+    onChange?: (value: string | number) => void;
+    filterMethod?: (keyword: string, options: SelectOption[]) => SelectOption[];
+}
+export interface OptionProps extends SelectOption {
+    currentValue: string;
+    showOptionEntries?: number;
+    onChange?: (value: string | number) => void;
+    optionRender?: (option: SelectOption, isSelected: boolean) => ReactNode;
+}

package/dist/types/components/SvgImg/SvgImg.d.ts

@@ -0,0 +1,10 @@
+interface SvgImgProps {
+    w?: number | string;
+    h?: number | string;
+    className?: string;
+    src: string;
+    clr?: string;
+    onClick?: (e: React.MouseEvent<HTMLDivElement>) => void;
+}
+export declare const SvgImg: ({ w, h, src, clr, className, onClick }: SvgImgProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/SvgImg/index.d.ts

@@ -0,0 +1 @@
+export { SvgImg } from './SvgImg';

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

@@ -0,0 +1,2 @@
+import { SwitchProps } from './types';
+export declare const Switch: ({ id, text, style, color, checked, onChange, name, className, disabled }: SwitchProps) => import("react/jsx-runtime").JSX.Element;

package/dist/types/components/Switch/index.d.ts

@@ -0,0 +1 @@
+export { Switch } from './Switch';

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

@@ -0,0 +1,18 @@
+import { ChangeEvent, CSSProperties, ReactNode } from 'react';
+export interface SwitchProps {
+    id?: string;
+    name?: string;
+    checked: boolean;
+    disabled?: boolean;
+    className?: string;
+    style?: CSSProperties;
+    text?: {
+        active: ReactNode;
+        inactive: ReactNode;
+    };
+    color?: string | {
+        active: string;
+        inactive: string;
+    };
+    onChange?: (bl: boolean, e: ChangeEvent<HTMLInputElement>) => void;
+}

package/dist/types/components/TemplateDialog/TemplateDialog.d.ts

@@ -0,0 +1,2 @@
+import { TemplateDialogProps } from './types';
+export declare const TemplateDialog: ({ children, animation, className, duration, style, maskColor, disableContextMenu, clickMaskClose, dialogClose }: TemplateDialogProps) => import("react/jsx-runtime").JSX.Element;

package/dist/types/components/TemplateDialog/index.d.ts

@@ -0,0 +1 @@
+export { TemplateDialog } from './TemplateDialog';

package/dist/types/components/TemplateDialog/types.d.ts

@@ -0,0 +1,19 @@
+import { CSSProperties, ReactNode } from 'react';
+export interface TemplateDialogProps {
+    children: ReactNode | ((enhancedDialogClose: () => void) => ReactNode);
+    animation?: {
+        type: 'zoom';
+        element: HTMLElement;
+    } | {
+        type: 'fade';
+        direction?: 'top-center' | 'left-center';
+        startPosition: string;
+    };
+    duration?: number;
+    className?: string;
+    style?: CSSProperties;
+    maskColor?: string;
+    disableContextMenu?: boolean;
+    clickMaskClose?: boolean;
+    dialogClose: () => void;
+}

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

@@ -0,0 +1,7 @@
+import { PromiseOptionsType, ToastProps } from './types';
+export declare const toast: {
+    success: (message: string | Omit<ToastProps, "type">) => void;
+    error: (message: string | Omit<ToastProps, "type">) => void;
+    warning: (message: string | Omit<ToastProps, "type">) => void;
+    promise: (promise: Promise<string> | (() => Promise<string>), options: PromiseOptionsType) => void;
+};

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

@@ -0,0 +1 @@
+export { toast } from './Toast';

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

@@ -0,0 +1,19 @@
+import { CSSProperties } from 'react';
+export type MessageType = 'success' | 'error' | 'warning' | 'promise';
+export type PromiseOptionsType = {
+    success: string | ((message: string) => string);
+    error?: string | ((message: string) => string);
+    loading: string;
+};
+export interface ToastProps {
+    type: MessageType;
+    message: string | Promise<string> | (() => Promise<string>);
+    duration?: number;
+    zIndex?: number;
+    className?: string;
+    speed?: number;
+    style?: CSSProperties;
+    isUseEnterAnimation?: boolean;
+    promiseOptions?: PromiseOptionsType;
+    toastList: any[];
+}

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

@@ -0,0 +1,2 @@
+import { TooltipProps } from './types';
+export declare const Tooltip: ({ children, content, onOpenChange, trigger, placement, popperOptions, className, style, isShowArrow, sameWidth, autoAdjustOverflow }: TooltipProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1 @@
+export { Tooltip } from './Tooltip';

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

@@ -0,0 +1,15 @@
+import { Options, Placement } from '@popperjs/core';
+import { CSSProperties, ReactNode } from 'react';
+export interface TooltipProps {
+    content?: ReactNode | (() => ReactNode);
+    children: ReactNode | (() => ReactNode);
+    trigger?: 'hover' | 'click' | 'focus' | 'contextmenu';
+    placement?: Placement;
+    isShowArrow?: boolean;
+    className?: string;
+    style?: CSSProperties;
+    sameWidth?: boolean;
+    autoAdjustOverflow?: boolean;
+    popperOptions?: Partial<Options>;
+    onOpenChange?: (isVisible: boolean) => void;
+}

package/dist/types/components/VirtualList/EstimatedVirtualList.d.ts

@@ -0,0 +1,2 @@
+import { VirtualListProps } from './types';
+export declare const EstimatedVirtualList: import('react').MemoExoticComponent<({ containerClassName, dataSource, containerStyle, onEndCallback, refreshSpeed, wrapperClassName, wrapperStyle, estimatedSize, updateDataSourceScroll2Top, direction }: VirtualListProps) => import("react/jsx-runtime").JSX.Element>;

package/dist/types/components/VirtualList/index.d.ts

@@ -0,0 +1,2 @@
+export { EstimatedVirtualList } from './EstimatedVirtualList';
+export { createDataSource } from './types';

package/dist/types/components/VirtualList/types.d.ts

@@ -0,0 +1,35 @@
+import { CSSProperties, ReactNode } from 'react';
+export type VirtualListDataSource = {
+    id: number;
+    data: ReactNode;
+};
+export type VirtualListProps = {
+    containerClassName?: string;
+    containerStyle?: CSSProperties;
+    refreshSpeed?: number;
+    estimatedSize?: number | (() => number);
+    wrapperClassName?: string;
+    wrapperStyle?: CSSProperties;
+    direction?: 'vertical' | 'horizontal';
+    dataSource: VirtualListDataSource[];
+    updateDataSourceScroll2Top?: boolean;
+    onEndCallback?: () => void;
+};
+export type virtualListState = {
+    viewSize: number;
+    startIndex: number;
+    listSize: number;
+    renderCount: number;
+    prevLen: number;
+};
+export type virtualListItemInfo = {
+    start: number;
+    index: number;
+    end: number;
+    size: number;
+    dSize: number;
+};
+export declare const createDataSource: <T>(dataList: T[], dom: (data: T, index: number) => ReactNode) => {
+    id: number;
+    data: ReactNode;
+}[];

package/dist/types/components/Waterfall/Waterfall.d.ts

@@ -0,0 +1,2 @@
+import { WaterfallProps } from './types';
+export declare const Waterfall: ({ options, pageSize, children, request, reloadData, className, style, updateData, loading, bottomThreshold }: WaterfallProps) => import("react/jsx-runtime").JSX.Element;

package/dist/types/components/Waterfall/index.d.ts

@@ -0,0 +1,2 @@
+export type { ImageItem } from './types';
+export { Waterfall } from './Waterfall';