@v-miniapp/ui-react 1.0.37 → 1.0.38

package/dist/components/checkbox/checkbox.d.ts

@@ -0,0 +1,24 @@
+import { ComponentProps, ReactNode } from 'react';
+import { IOverride } from '../../types/util';
+import { ITypographyProps } from '../typography';
+export type ICheckboxTheme = 'brand' | 'inverse';
+export type ICheckboxVariant = 'default' | 'number' | 'indeterminate';
+export type ICheckboxProps = IOverride<ComponentProps<'input'>, {
+    className?: string;
+    checked?: boolean;
+    defaultChecked?: boolean;
+    disabled?: boolean;
+    theme?: ICheckboxTheme;
+    variant?: ICheckboxVariant;
+    number?: number;
+    defaultNumber?: number;
+    onChange?: (checked: boolean) => void;
+    onNumberChange?: (number: number | undefined) => void;
+    children?: ReactNode;
+    typography?: Omit<ITypographyProps<'span'>, 'component' | 'children'>;
+}>;
+export type ICheckboxInstance = {
+    focus: () => void;
+    blur: () => void;
+};
+export declare const Checkbox: import('react').ForwardRefExoticComponent<Omit<ICheckboxProps, "ref"> & import('react').RefAttributes<ICheckboxInstance>>;

package/dist/components/checkbox/indeterminate-icon.d.ts

@@ -0,0 +1,6 @@
+import { default as React } from 'react';
+export interface IIndeterminateIconProps extends React.SVGProps<SVGSVGElement> {
+    fill?: string;
+}
+declare const IndeterminateIcon: React.FC<IIndeterminateIconProps>;
+export default IndeterminateIcon;

package/dist/components/checkbox/index.d.ts

@@ -0,0 +1 @@
+export * from './checkbox';

package/dist/components/chip/chip.d.ts

@@ -0,0 +1,16 @@
+import { IOverride } from '../../types/util';
+import { ComponentPropsWithRef, FC, ReactNode } from 'react';
+import { IIconProps } from '../icon';
+export type IChipTheme = 'default' | 'brand' | 'neutral';
+export type IChipType = 'selection' | 'dropdown' | 'action' | 'input';
+export type IChipProps = IOverride<ComponentPropsWithRef<'div'>, {
+    theme?: IChipTheme;
+    type?: IChipType;
+    disabled?: boolean;
+    leadingIcon?: IIconProps | ReactNode;
+    trailingIcon?: IIconProps | ReactNode;
+    selected?: boolean;
+    label?: ReactNode;
+    count?: number;
+}>;
+export declare const Chip: FC<IChipProps>;

package/dist/components/chip/index.d.ts

@@ -0,0 +1 @@
+export * from './chip';

package/dist/components/date-field/date-field-range.d.ts

@@ -0,0 +1,76 @@
+import { IBasicInputProps } from '../input-wrapper';
+import { ComponentProps } from 'react';
+import { IOverride } from '../../types/util';
+import { IDatePickerSheetProps } from '../date-picker/date-picker-sheet';
+import { ICalendarRangeSheetProps } from '../calendar/calendar-range-sheet';
+type ICalendarPickerProps = Omit<ICalendarRangeSheetProps, 'open' | 'onCancel' | 'onSelect' | 'value' | 'title'>;
+type IDatePickerPickerProps = Omit<IDatePickerSheetProps, 'open' | 'onCancel' | 'onSelect' | 'value' | 'title'>;
+export type IDateFieldRangeValue = {
+    from?: Date | null;
+    to?: Date | null;
+};
+export type IDateFieldRangeProps = IOverride<ComponentProps<'input'>, IBasicInputProps & {
+    inputClassName?: string;
+    placeholder?: {
+        from?: string;
+        to?: string;
+    };
+    value?: IDateFieldRangeValue;
+    onChange?: (value: IDateFieldRangeValue) => void;
+    defaultValue?: IDateFieldRangeValue;
+    loading?: boolean;
+} & ({
+    picker?: 'date-picker';
+    pickerProps?: [IDatePickerPickerProps, IDatePickerPickerProps];
+} | {
+    picker: false;
+    pickerProps?: never;
+} | {
+    picker?: 'calendar';
+    pickerProps?: ICalendarPickerProps;
+})>;
+export type IDateFieldRangeInstance = {
+    focus: () => void;
+    blur: () => void;
+};
+export declare const DateFieldRange: import('react').ForwardRefExoticComponent<(Omit<IBasicInputProps & {
+    inputClassName?: string;
+    placeholder?: {
+        from?: string;
+        to?: string;
+    };
+    value?: IDateFieldRangeValue;
+    onChange?: (value: IDateFieldRangeValue) => void;
+    defaultValue?: IDateFieldRangeValue;
+    loading?: boolean;
+} & {
+    picker?: "date-picker";
+    pickerProps?: [IDatePickerPickerProps, IDatePickerPickerProps];
+} & Omit<import('react').DetailedHTMLProps<import('react').InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "placeholder" | "onChange" | "defaultValue" | "value" | "loading" | keyof IBasicInputProps | "inputClassName" | "picker" | "pickerProps">, "ref"> | Omit<IBasicInputProps & {
+    inputClassName?: string;
+    placeholder?: {
+        from?: string;
+        to?: string;
+    };
+    value?: IDateFieldRangeValue;
+    onChange?: (value: IDateFieldRangeValue) => void;
+    defaultValue?: IDateFieldRangeValue;
+    loading?: boolean;
+} & {
+    picker: false;
+    pickerProps?: never;
+} & Omit<import('react').DetailedHTMLProps<import('react').InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "placeholder" | "onChange" | "defaultValue" | "value" | "loading" | keyof IBasicInputProps | "inputClassName" | "picker" | "pickerProps">, "ref"> | Omit<IBasicInputProps & {
+    inputClassName?: string;
+    placeholder?: {
+        from?: string;
+        to?: string;
+    };
+    value?: IDateFieldRangeValue;
+    onChange?: (value: IDateFieldRangeValue) => void;
+    defaultValue?: IDateFieldRangeValue;
+    loading?: boolean;
+} & {
+    picker?: "calendar";
+    pickerProps?: ICalendarPickerProps;
+} & Omit<import('react').DetailedHTMLProps<import('react').InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "placeholder" | "onChange" | "defaultValue" | "value" | "loading" | keyof IBasicInputProps | "inputClassName" | "picker" | "pickerProps">, "ref">) & import('react').RefAttributes<IDateFieldRangeInstance>>;
+export {};

package/dist/components/date-field/date-field.d.ts

@@ -0,0 +1,56 @@
+import { ComponentProps } from 'react';
+import { IBasicInputProps } from '../input-wrapper';
+import { IOverride } from '../../types/util';
+import { IDatePickerSheetProps } from '../date-picker/date-picker-sheet';
+import { ICalendarSingleSheetProps } from '../calendar/calendar-single-sheet';
+type ICalendarPickerProps = Omit<ICalendarSingleSheetProps, 'open' | 'onCancel' | 'onSelect' | 'value' | 'title'>;
+type IDatePickerPickerProps = Omit<IDatePickerSheetProps, 'open' | 'onCancel' | 'onSelect' | 'value' | 'title'>;
+export type IDateFieldProps = IOverride<ComponentProps<'input'>, IBasicInputProps & {
+    inputClassName?: string;
+    value?: Date | null;
+    defaultValue?: Date | null;
+    onChange?: (value: Date | null) => void;
+    loading?: boolean;
+} & ({
+    picker?: 'date-picker';
+    pickerProps?: IDatePickerPickerProps;
+} | {
+    picker: false;
+    pickerProps?: never;
+} | {
+    picker: 'calendar';
+    pickerProps?: ICalendarPickerProps;
+})>;
+export type IDateFieldInstance = {
+    focus: () => void;
+    blur: () => void;
+};
+export declare const DateField: import('react').ForwardRefExoticComponent<(Omit<IBasicInputProps & {
+    inputClassName?: string;
+    value?: Date | null;
+    defaultValue?: Date | null;
+    onChange?: (value: Date | null) => void;
+    loading?: boolean;
+} & {
+    picker?: "date-picker";
+    pickerProps?: IDatePickerPickerProps;
+} & Omit<import('react').DetailedHTMLProps<import('react').InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "onChange" | "defaultValue" | "value" | "loading" | keyof IBasicInputProps | "inputClassName" | "picker" | "pickerProps">, "ref"> | Omit<IBasicInputProps & {
+    inputClassName?: string;
+    value?: Date | null;
+    defaultValue?: Date | null;
+    onChange?: (value: Date | null) => void;
+    loading?: boolean;
+} & {
+    picker: false;
+    pickerProps?: never;
+} & Omit<import('react').DetailedHTMLProps<import('react').InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "onChange" | "defaultValue" | "value" | "loading" | keyof IBasicInputProps | "inputClassName" | "picker" | "pickerProps">, "ref"> | Omit<IBasicInputProps & {
+    inputClassName?: string;
+    value?: Date | null;
+    defaultValue?: Date | null;
+    onChange?: (value: Date | null) => void;
+    loading?: boolean;
+} & {
+    picker: "calendar";
+    pickerProps?: ICalendarPickerProps;
+} & Omit<import('react').DetailedHTMLProps<import('react').InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "onChange" | "defaultValue" | "value" | "loading" | keyof IBasicInputProps | "inputClassName" | "picker" | "pickerProps">, "ref">) & import('react').RefAttributes<IDateFieldInstance>>;
+export {};

package/dist/components/date-field/index.d.ts

@@ -0,0 +1,2 @@
+export * from './date-field';
+export * from './date-field-range';

package/dist/components/date-field/input.d.ts

@@ -0,0 +1,6 @@
+export declare const Input: import('react').ForwardRefExoticComponent<{
+    value?: Date | null;
+    defaultValue?: Date | null;
+    onChange?: (value: Date | null) => void;
+    onCompleted?: (value: Date, selectionIndex: number) => void;
+} & Omit<Omit<import('react').DetailedHTMLProps<import('react').InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "ref">, "onChange" | "defaultValue" | "value" | "onCompleted"> & import('react').RefAttributes<HTMLInputElement>>;

package/dist/components/date-picker/date-picker-base.d.ts

@@ -0,0 +1,32 @@
+import { ComponentProps, FC } from 'react';
+import { IOverride } from '../../types/util';
+export type IDatePickerBaseValue = {
+    minutes: number;
+    hours: number;
+    days: number;
+    months: number;
+    years: number;
+    dayOfWeeks: number;
+};
+type IItemProps = {
+    step?: number;
+    min?: number;
+    max?: number;
+    renderLabel?: (item: number) => string;
+};
+export type IDatePickerBaseProps = IOverride<ComponentProps<'div'>, {
+    hour?: boolean;
+    day?: boolean;
+    month?: boolean;
+    year?: boolean;
+    minutesProps: IItemProps;
+    hoursProps: IItemProps;
+    daysProps: IItemProps;
+    monthsProps: IItemProps;
+    yearsProps: IItemProps;
+    dayOfWeeksProps: IItemProps;
+    value?: IDatePickerBaseValue;
+    onChange?: (value: IDatePickerBaseValue) => void;
+}>;
+export declare const DatePickerBase: FC<IDatePickerBaseProps>;
+export {};

package/dist/components/date-picker/date-picker-item.d.ts

@@ -0,0 +1,14 @@
+import { default as React, ComponentProps } from 'react';
+import { EmblaCarouselType } from 'embla-carousel';
+import { IOverride } from '../../types/util';
+export declare const setContainerStyles: (emblaApi: EmblaCarouselType, wheelRotation: number) => void;
+type IPropType = IOverride<ComponentProps<'div'>, {
+    items: number[];
+    min?: number;
+    max?: number;
+    activeIndex?: number;
+    renderLabel?: (item: number) => string;
+    onChange?: (item: number) => void;
+}>;
+declare const DatePickerItem: React.FC<IPropType>;
+export { DatePickerItem };

package/dist/components/date-picker/date-picker-sheet.d.ts

@@ -0,0 +1,14 @@
+import { FC, ReactNode } from 'react';
+import { IButtonProps } from '../button';
+import { IDatePickerProps } from './date-picker';
+import { IOverride } from '../../types/util';
+export type IDatePickerSheetProps = IOverride<Omit<IDatePickerProps, 'value' | 'onChange'>, {
+    title?: ReactNode;
+    confirmButton?: IButtonProps;
+    open?: boolean;
+    onCancel?: () => void;
+    value?: Date | null;
+    defaultValue?: Date | null;
+    onSelect?: (value: Date) => void;
+}>;
+export declare const DatePickerSheet: FC<IDatePickerSheetProps>;

package/dist/components/date-picker/date-picker.constant.d.ts

@@ -0,0 +1,8 @@
+declare const prefixClassName: string;
+declare const itemConfig: {
+    readonly CIRCLE_DEGREES: 360;
+    readonly WHEEL_ITEM_SIZE: 24;
+    readonly WHEEL_ITEM_COUNT: 80;
+    readonly WHEEL_ITEMS_IN_VIEW: 4;
+};
+export { prefixClassName, itemConfig };

package/dist/components/date-picker/date-picker.d.ts

@@ -0,0 +1,17 @@
+import { ComponentProps, FC } from 'react';
+import { IOverride } from '../../types/util';
+import { ITypePickerProps } from './date-picker.utils';
+type IDatePickerProps = IOverride<ComponentProps<'div'>, {
+    hour?: boolean;
+    day?: boolean;
+    month?: boolean;
+    year?: boolean;
+    min?: Date | null;
+    max?: Date | null;
+    renderLabels?: ITypePickerProps['renderLabels'];
+    value?: Date;
+    onChange?: (value: Date) => void;
+}>;
+declare const DatePicker: FC<IDatePickerProps>;
+export { DatePicker };
+export type { IDatePickerProps };

package/dist/components/date-picker/date-picker.utils.d.ts

@@ -0,0 +1,31 @@
+type ITypePickerProps = {
+    type: 'year' | 'month' | 'day' | 'hour' | 'minute' | 'dayOfWeek';
+    value: Date;
+    max?: Date | null;
+    min?: Date | null;
+    renderLabels?: {
+        minutes?: (value: number) => string;
+        hours?: (value: number) => string;
+        days?: (value: number) => string;
+        months?: (value: number) => string;
+        years?: (value: number) => string;
+        dayOfWeeks?: (value: number) => string;
+    };
+    hasHour?: boolean;
+};
+declare const getTypePickerProps: (params: ITypePickerProps) => {
+    renderLabel: ((value: number) => string) | undefined;
+    max: number | undefined;
+    min: number | undefined;
+};
+declare const getRanges: (from: number, to: number, step: number) => number[];
+declare const getActiveIndex: (items: number[], value: number) => number;
+declare const renderHoursLabel: (value: number) => string;
+declare const renderMinutesLabel: (value: number) => string;
+declare const renderDaysLabel: (value: number) => string;
+declare const renderMonthsLabel: (value: number) => string;
+declare const renderMonthsThumbLabel: (value: number) => string;
+declare const renderYearsLabel: (value: number) => string;
+declare const renderDayOfWeeksLabel: (value: number) => string;
+export { getRanges, getActiveIndex, renderHoursLabel, renderMinutesLabel, renderDaysLabel, renderMonthsLabel, renderMonthsThumbLabel, renderYearsLabel, renderDayOfWeeksLabel, getTypePickerProps, };
+export type { ITypePickerProps };

package/dist/components/date-picker/index.d.ts

@@ -0,0 +1,2 @@
+export * from './date-picker';
+export * from './date-picker-base';

package/dist/components/dialog/dialog.d.ts

@@ -0,0 +1,20 @@
+import { IOverride } from '../../types/util';
+import { ComponentPropsWithRef, FC, ReactNode } from 'react';
+type IRawDialogProps = IOverride<ComponentPropsWithRef<'div'>, {
+    topImageUrl?: string;
+    top?: ReactNode;
+    title?: ReactNode;
+    description?: ReactNode;
+    children?: ReactNode;
+    closeAction?: boolean;
+    footer?: ReactNode;
+    overlay?: 'default' | 'blur';
+    open?: boolean;
+    onBackdropClick?: (e: React.MouseEvent<HTMLDivElement, MouseEvent>) => void;
+    onCloseClick?: (e: React.MouseEvent<HTMLButtonElement, MouseEvent>) => void;
+}>;
+export type IDialogProps = IRawDialogProps & {
+    portal?: boolean;
+};
+export declare const Dialog: FC<IDialogProps>;
+export {};

package/dist/components/dialog/index.d.ts

@@ -0,0 +1 @@
+export * from './dialog';

package/dist/components/dropdown/dropdown-base.d.ts

@@ -0,0 +1,6 @@
+import { FC } from 'react';
+import { IInputWrapperProps } from '../input-wrapper';
+export type IDropdownBaseProps = IInputWrapperProps & {
+    loading?: boolean;
+};
+export declare const DropdownBase: FC<IDropdownBaseProps>;

package/dist/components/dropdown/dropdown.d.ts

@@ -0,0 +1,33 @@
+import { ReactNode } from 'react';
+import { IBasicInputProps } from '../input-wrapper';
+import { ISearchFieldProps } from '../search-field';
+export type IDropdownOption<Value = any, Data = any> = {
+    value: Value;
+    label: ReactNode;
+    data?: Data;
+};
+export type IDropdownProps<Value = any, Data = any> = IBasicInputProps & {
+    placeholder?: string;
+    options: IDropdownOption<Value, Data>[];
+    value?: Value;
+    onChange?: (value: Value) => void;
+    renderLabel?: (option: IDropdownOption<Value, Data>, value: Value) => ReactNode;
+    renderItem?: (option: IDropdownOption<Value, Data>, context: {
+        options: IDropdownOption<Value, Data>[];
+        value: Value;
+        index: number;
+    }) => ReactNode;
+    renderValue?: (option: IDropdownOption<Value, Data>) => ReactNode;
+    sheetTitle?: ReactNode;
+    allowSearch?: boolean;
+    searchFilter?: (option: IDropdownOption<Value, Data>, search: string) => boolean;
+    searchProps?: ISearchFieldProps;
+    emptyText?: ReactNode;
+    children?: ReactNode;
+    loading?: boolean;
+};
+export type IDropdownInstance = {
+    open: () => void;
+    close: () => void;
+};
+export declare const Dropdown: <Value, Data>(props: IDropdownProps<Value, Data> & React.RefAttributes<IDropdownInstance>) => ReactNode;

package/dist/components/dropdown/index.d.ts

@@ -0,0 +1,2 @@
+export * from './dropdown';
+export * from './dropdown-base';

package/dist/components/error/error-boundary.d.ts

@@ -0,0 +1,15 @@
+import { default as React } from 'react';
+type IErrorBoundaryProps = {
+    children: React.ReactNode;
+    isGlobal?: boolean;
+};
+type IErrorBoundaryState = {
+    hasError: boolean;
+    error: Error | null;
+};
+export declare class ErrorBoundary extends React.Component<IErrorBoundaryProps, IErrorBoundaryState> {
+    constructor(props: IErrorBoundaryProps);
+    static getDerivedStateFromError(error: Error): Partial<IErrorBoundaryState>;
+    render(): string | number | bigint | boolean | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | import("react/jsx-runtime").JSX.Element | null | undefined;
+}
+export {};

package/dist/components/error/error.d.ts

@@ -0,0 +1,10 @@
+import { IOverride } from '../../types/util';
+import { ComponentProps, FC, ReactNode } from 'react';
+import { IButtonProps } from '../button';
+export type IErrorComponentProps = IOverride<ComponentProps<'div'>, {
+    image?: ReactNode;
+    title?: ReactNode;
+    description?: ReactNode;
+    button?: IButtonProps;
+}>;
+export declare const ErrorComponent: FC<IErrorComponentProps>;

package/dist/components/error/index.d.ts

@@ -0,0 +1 @@
+export * from './error';

package/dist/components/freeze/index.d.ts

@@ -0,0 +1,11 @@
+import { default as React } from 'react';
+type ISuspenderProps = {
+    freeze: boolean;
+    children: React.ReactNode;
+};
+type IFreezeProps = ISuspenderProps & {
+    placeholder?: React.ReactNode;
+    delay?: number;
+};
+export declare function Freeze({ freeze, delay, children, placeholder, }: IFreezeProps): import("react/jsx-runtime").JSX.Element;
+export {};