@scbt-ecom/ui 0.13.3 → 0.14.0

package/dist/shared/types/index.d.ts

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

package/dist/shared/types/utils.d.ts

@@ -0,0 +1,3 @@
+export type DeepPartial<T> = {
+    [K in keyof T]?: T[K] extends object ? DeepPartial<T[K]> : T[K];
+};

package/dist/shared/ui/calendar/Calendar.d.ts

@@ -0,0 +1,11 @@
+import { DetailedHTMLProps, HTMLAttributes, JSX } from 'react';
+import { DayPickerProps } from 'react-day-picker';
+import { SelectOptions } from './ui';
+type CalendarProps = DayPickerProps & {
+    navigation?: boolean;
+    renderFooter?: (props: DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>) => JSX.Element | string;
+    selectOptions?: SelectOptions;
+    disabledAfterToday?: boolean;
+};
+export declare const Calendar: ({ classNames, showOutsideDays, navigation, renderFooter, selectOptions, className, disabledAfterToday, ...props }: CalendarProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/shared/ui/calendar/index.d.ts

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

package/dist/shared/ui/calendar/model/index.d.ts

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

package/dist/shared/ui/calendar/model/utils.d.ts

@@ -0,0 +1,34 @@
+export declare const DATE_VISIBLE_PATTERN = "dd.MM.yyyy";
+/**
+ * Форматирование объекта даты в читаемую строку
+ * @example
+ * new Date() -> '10.10.2024'
+ * @param {Date} date
+ * @param {string} locale
+ * @returns Форматированная строка
+ */
+export declare const formatDateToLocaleString: (date: Date, locale?: string) => string;
+/**
+ * Форматирование объекта даты в читаемую строку года
+ * @example
+ * new Date() -> '2024'
+ * @param {Date} date
+ * @param {string} locale
+ * @returns Форматированная строка
+ */
+export declare const formatDateToYearString: (date: Date, locale?: string) => string;
+/**
+ * Форматирование объекта даты в читаемую строку месяца
+ * @example
+ * new Date() -> 'декабрь'
+ * @param date
+ * @param locale
+ */
+export declare const formatDateToMonthString: (date: Date, locale?: string) => string;
+export declare const defaultClassNames: {
+    today: string;
+    outside: string;
+    selected: string;
+    range_outer: string;
+    range_middle: string;
+};

package/dist/shared/ui/calendar/ui/Day.d.ts

@@ -0,0 +1,9 @@
+import { ClassAttributes, TdHTMLAttributes } from 'react';
+import { CalendarDay, Modifiers } from 'react-day-picker';
+type DayProps = ClassAttributes<HTMLTableCellElement> & TdHTMLAttributes<HTMLTableCellElement> & {
+    day: CalendarDay;
+    modifiers: Modifiers;
+    disabledAfterToday?: boolean;
+};
+export declare const Day: ({ className, day, children, disabledAfterToday, ...props }: DayProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/shared/ui/calendar/ui/DayButton.d.ts

@@ -0,0 +1,8 @@
+import { ButtonHTMLAttributes, ClassAttributes } from 'react';
+import { CalendarDay, Modifiers } from 'react-day-picker';
+type DayButtonProps = ClassAttributes<HTMLButtonElement> & ButtonHTMLAttributes<HTMLButtonElement> & {
+    day: CalendarDay;
+    modifiers: Modifiers;
+};
+export declare const DayButton: ({ className, ...props }: DayButtonProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/shared/ui/calendar/ui/Footer.d.ts

@@ -0,0 +1,6 @@
+import { DetailedHTMLProps, HTMLAttributes, JSX } from 'react';
+type FooterProps = React.HTMLAttributes<HTMLDivElement> & {
+    render: (props: DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>) => JSX.Element | string;
+};
+export declare const Footer: ({ render, ...props }: FooterProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/shared/ui/calendar/ui/MonthCaption.d.ts

@@ -0,0 +1,10 @@
+import { ClassAttributes, HTMLAttributes } from 'react';
+import { CalendarMonth } from 'react-day-picker';
+import { SelectOptions } from './model';
+type MonthCaptionProps = ClassAttributes<HTMLDivElement> & HTMLAttributes<HTMLDivElement> & {
+    calendarMonth: CalendarMonth;
+    displayIndex: number;
+    selectOptions?: SelectOptions | false;
+};
+export declare const MonthCaption: ({ calendarMonth, displayIndex, className, selectOptions, ...props }: MonthCaptionProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/shared/ui/calendar/ui/Navigation.d.ts

@@ -0,0 +1,4 @@
+import { HTMLAttributes } from 'react';
+type NavigationProps = HTMLAttributes<HTMLElement>;
+export declare const Navigation: ({ className, ...props }: NavigationProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/shared/ui/calendar/ui/Weekday.d.ts

@@ -0,0 +1,4 @@
+import { DetailedHTMLProps, ThHTMLAttributes } from 'react';
+type WeekdayProps = DetailedHTMLProps<ThHTMLAttributes<HTMLTableCellElement>, HTMLTableCellElement>;
+export declare const Weekday: ({ className, children, ...props }: WeekdayProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/shared/ui/calendar/ui/index.d.ts

@@ -0,0 +1,7 @@
+export { DayButton } from './DayButton';
+export { Weekday } from './Weekday';
+export { Day } from './Day';
+export { Footer } from './Footer';
+export { Navigation } from './Navigation';
+export { MonthCaption } from './MonthCaption';
+export type { SelectOptions } from './model';

package/dist/shared/ui/calendar/ui/model/index.d.ts

@@ -0,0 +1,2 @@
+export { weekdays, getYearsFrom, getMonthsFrom, defaultSelectOptions } from './utils';
+export type * from './types';

package/dist/shared/ui/calendar/ui/model/types.d.ts

@@ -0,0 +1,9 @@
+export type CalendarSelectOption = {
+    disabled?: boolean;
+    startFrom?: number;
+    order?: 'asc' | 'desc';
+};
+export type SelectOptions = {
+    year?: CalendarSelectOption | false;
+    month?: CalendarSelectOption | false;
+};

package/dist/shared/ui/calendar/ui/model/utils.d.ts

@@ -0,0 +1,13 @@
+import { SelectOptions } from '..';
+export declare const weekdays: {
+    пн: boolean;
+    вт: boolean;
+    ср: boolean;
+    чт: boolean;
+    пт: boolean;
+    сб: boolean;
+    вс: boolean;
+};
+export declare const getYearsFrom: (startFrom?: number, order?: string) => number[];
+export declare const getMonthsFrom: (startFrom?: number, order?: string) => number[];
+export declare const defaultSelectOptions: SelectOptions;

package/dist/shared/ui/calendar/ui/selectDate/SelectDate.d.ts

@@ -0,0 +1,13 @@
+import { HTMLAttributes } from 'react';
+import { CalendarMonth } from 'react-day-picker';
+type SelectDateProps = HTMLAttributes<HTMLDivElement> & {
+    dates: number[];
+    currentMonth: CalendarMonth;
+    onMonthChange: (month: Date) => void;
+    mode: 'month' | 'year';
+    disabled?: boolean;
+    open: boolean;
+    onOpenChange: () => void;
+};
+export declare const SelectDate: ({ dates, currentMonth, onMonthChange, className, open, onOpenChange, mode, disabled, ...props }: SelectDateProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/shared/ui/calendar/ui/selectDate/index.d.ts

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

package/dist/shared/ui/calendar/ui/selectDate/ui/SelectList.d.ts

@@ -0,0 +1,10 @@
+import { ComponentPropsWithoutRef } from 'react';
+import { motion } from 'framer-motion';
+type SelectListProps = Omit<ComponentPropsWithoutRef<typeof motion.ul>, 'onSelect'> & {
+    dates: number[];
+    selected: Date;
+    onSelect: (date: Date) => void;
+    mode: 'month' | 'year';
+};
+export declare const SelectList: ({ dates, selected, onSelect, className, mode, ...props }: SelectListProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/shared/ui/calendar/ui/selectDate/ui/Trigger.d.ts

@@ -0,0 +1,9 @@
+import { ButtonHTMLAttributes } from 'react';
+type TriggerProps = Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'children'> & {
+    currentDate: Date;
+    mode: 'year' | 'month';
+    open: boolean;
+    onOpenChange: () => void;
+};
+export declare const Trigger: ({ currentDate, mode, className, open, onOpenChange, ...props }: TriggerProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/shared/ui/calendar/ui/selectDate/ui/index.d.ts

@@ -0,0 +1,2 @@
+export { Trigger } from './Trigger';
+export { SelectList } from './SelectList';

package/dist/shared/ui/checkbox/Checkbox.d.ts

@@ -0,0 +1,14 @@
+import { CheckboxProps as CheckboxPrimitiveProps } from '@radix-ui/react-checkbox';
+type CheckboxBaseClasses = {
+    root?: string;
+    indicator?: string;
+};
+export type CheckboxBaseProps = CheckboxPrimitiveProps & {
+    classes?: CheckboxBaseClasses;
+    invalid?: boolean;
+};
+export declare const CheckboxBase: import('react').ForwardRefExoticComponent<CheckboxPrimitiveProps & {
+    classes?: CheckboxBaseClasses;
+    invalid?: boolean;
+} & import('react').RefAttributes<HTMLButtonElement>>;
+export {};

package/dist/shared/ui/checkbox/index.d.ts

@@ -0,0 +1 @@
+export { CheckboxBase, type CheckboxBaseProps } from './Checkbox';

package/dist/shared/ui/formElements/controlled/checkbox/CheckboxControl.d.ts

@@ -0,0 +1,15 @@
+import { Control, FieldPath, FieldValues, UseControllerProps } from 'react-hook-form';
+import { CheckboxBaseProps } from '../../..';
+type CheckboxControlClasses = CheckboxBaseProps['classes'] & {
+    container?: string;
+    message?: string;
+    label?: string;
+};
+type CheckboxControlProps<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>> = UseControllerProps<TFieldValues, TName> & Omit<CheckboxBaseProps, 'classes'> & {
+    control: Control<TFieldValues>;
+    children: React.ReactElement | string;
+    classes?: CheckboxControlClasses;
+};
+declare const InnerComponent: <TFieldValues extends FieldValues = FieldValues>({ control, classes, className, name, rules, shouldUnregister, defaultValue, disabled, children, ...props }: CheckboxControlProps<TFieldValues>) => import("react/jsx-runtime").JSX.Element;
+export declare const CheckboxControl: typeof InnerComponent;
+export {};

package/dist/shared/ui/formElements/controlled/checkbox/index.d.ts

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

package/dist/shared/ui/formElements/controlled/dayPickerControl/dayPickerControl.d.ts

@@ -0,0 +1,15 @@
+import { Control, FieldPath, FieldValues, UseControllerProps } from 'react-hook-form';
+import { Calendar, MaskInputProps } from '../../..';
+type CalendarProps = React.ComponentPropsWithoutRef<typeof Calendar>;
+type DayPickerControlClasses = MaskInputProps['classes'] & {
+    message?: string;
+};
+export type DayPickerControlProps<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>> = UseControllerProps<TFieldValues, TName> & Omit<CalendarProps, 'selected' | 'onSelect' | 'mode'> & {
+    control: Control<TFieldValues>;
+    inputProps: Omit<MaskInputProps, 'mask'>;
+    textHint?: string;
+    classes?: DayPickerControlClasses;
+};
+declare const InnerComponent: <T extends FieldValues = FieldValues>({ control, name, disabled, rules, shouldUnregister, defaultValue, inputProps, textHint, classes, ...props }: DayPickerControlProps<T>) => import("react/jsx-runtime").JSX.Element;
+export declare const DayPickerControl: typeof InnerComponent;
+export {};

package/dist/shared/ui/formElements/controlled/dayPickerControl/index.d.ts

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

package/dist/shared/ui/formElements/controlled/dayPickerControl/model/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const SINGLE_MASK = "##.##.####";
+export declare const RANGE_MASK = "##.##.#### - ##.##.####";
+export declare const SINGLE_VALIDATION_REGEX: RegExp;
+export declare const RANGE_VALIDATION_REGEX: RegExp;

package/dist/shared/ui/formElements/controlled/dayPickerControl/model/index.d.ts

@@ -0,0 +1,2 @@
+export * from './constants';
+export * from './utils';

package/dist/shared/ui/formElements/controlled/dayPickerControl/model/utils.d.ts

@@ -0,0 +1,25 @@
+import { DateRange } from 'react-day-picker';
+type IsoDateRange = {
+    from?: string;
+    to?: string;
+};
+/**
+ * Функция для получения инит состояния поля ввода
+ * @param mode режим календаря (single | range)
+ * @param value текущее состояние поля
+ */
+export declare function getInitialValue(mode: 'single', value?: string): string;
+export declare function getInitialValue(mode: 'range', value?: IsoDateRange): string;
+export declare function getInitialValue(mode: 'multiple', value?: IsoDateRange): string;
+/**
+ * Функция для получения объекта даты по текущему состоянию
+ * @param mode режим календаря (single | range)
+ * @param value текущее состояние поля
+ *
+ * @returns Date если mode 'single'
+ * @returns DateRange если mode 'range'
+ */
+export declare function getCurrentDate(mode: 'single', value?: string): Date;
+export declare function getCurrentDate(mode: 'range', value?: IsoDateRange): DateRange;
+export declare function getCurrentDate(mode: 'multiple', value?: IsoDateRange): Date;
+export {};

package/dist/shared/ui/formElements/controlled/dayPickerControl/range.d.ts

@@ -0,0 +1,17 @@
+import { Calendar, MaskInputProps } from '../../..';
+type CalendarProps = React.ComponentPropsWithoutRef<typeof Calendar>;
+type RangeDayPickerClasses = MaskInputProps['classes'] & {
+    calendar?: string;
+};
+type IsoDateRange = {
+    from?: string;
+    to?: string;
+};
+type RangeDayPickerProps = Omit<CalendarProps, 'mode'> & {
+    inputProps: Omit<MaskInputProps, 'mask'>;
+    classes?: RangeDayPickerClasses;
+    value: IsoDateRange;
+    onChange: (value: IsoDateRange) => void;
+};
+export declare const RangeDayPicker: ({ inputProps, classes, value, onChange, ...props }: RangeDayPickerProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/shared/ui/formElements/controlled/dayPickerControl/single.d.ts

@@ -0,0 +1,13 @@
+import { Calendar, MaskInputProps } from '../../..';
+type CalendarProps = React.ComponentPropsWithoutRef<typeof Calendar>;
+type SingleDayPickerClasses = MaskInputProps['classes'] & {
+    calendar?: string;
+};
+type SingleDayPickerProps = Omit<CalendarProps, 'mode'> & {
+    inputProps: Omit<MaskInputProps, 'mask'>;
+    classes?: SingleDayPickerClasses;
+    value: string;
+    onChange: (value: string) => void;
+};
+export declare const SingleDayPicker: ({ inputProps, classes, value, onChange, ...props }: SingleDayPickerProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/shared/ui/formElements/controlled/index.d.ts

@@ -0,0 +1,63 @@
+export declare const Controlled: {
+    InputControl: <TFieldValues extends import('react-hook-form').FieldValues = import('react-hook-form').FieldValues>({ className, control, name, defaultValue, disabled, rules, shouldUnregister, textHint, classes, ...props }: import('react-hook-form').UseControllerProps<TFieldValues, import('react-hook-form').Path<TFieldValues>> & Omit<import('../..').InputBaseProps, "classes"> & {
+        control: import('react-hook-form').Control<TFieldValues>;
+        textHint?: string;
+        classes?: {
+            container?: string;
+            input?: string;
+            label?: string;
+        } & {
+            message?: string;
+        };
+    }) => import("react/jsx-runtime").JSX.Element;
+    MaskInputControl: <TFieldValues extends import('react-hook-form').FieldValues = import('react-hook-form').FieldValues>({ className, control, name, defaultValue, disabled, rules, shouldUnregister, classes, textHint, ...props }: import('react-hook-form').UseControllerProps<TFieldValues, import('react-hook-form').Path<TFieldValues>> & Omit<import('../..').MaskInputProps, "classes"> & {
+        control: import('react-hook-form').Control<TFieldValues>;
+        classes?: {
+            container?: string;
+            input?: string;
+            label?: string;
+        } & {
+            message?: string;
+        };
+        textHint?: string;
+    }) => import("react/jsx-runtime").JSX.Element;
+    DayPickerControl: <T extends import('react-hook-form').FieldValues = import('react-hook-form').FieldValues>({ control, name, disabled, rules, shouldUnregister, defaultValue, inputProps, textHint, classes, ...props }: import('./dayPickerControl/dayPickerControl').DayPickerControlProps<T>) => import("react/jsx-runtime").JSX.Element;
+    CheckboxControl: <TFieldValues extends import('react-hook-form').FieldValues = import('react-hook-form').FieldValues>({ control, classes, className, name, rules, shouldUnregister, defaultValue, disabled, children, ...props }: import('react-hook-form').UseControllerProps<TFieldValues, import('react-hook-form').Path<TFieldValues>> & Omit<import('../..').CheckboxBaseProps, "classes"> & {
+        control: import('react-hook-form').Control<TFieldValues>;
+        children: React.ReactElement | string;
+        classes?: {
+            root?: string;
+            indicator?: string;
+        } & {
+            container?: string;
+            message?: string;
+            label?: string;
+        };
+    }) => import("react/jsx-runtime").JSX.Element;
+    SelectControl: <TFieldValues extends import('react-hook-form').FieldValues = import('react-hook-form').FieldValues>({ control, classes, className, name, rules, shouldUnregister, disabled, defaultValue, returnValue, options, ...props }: import('react-hook-form').UseControllerProps<TFieldValues, import('react-hook-form').Path<TFieldValues>> & Omit<import('react-select').Props<import('../..').SelectItemOption, boolean>, "defaultValue" | "options" | "placeholder"> & Pick<import('../..').InputBaseProps, "attachmentProps"> & {
+        label: string;
+        invalid?: boolean;
+        isSearchable?: boolean;
+        returnValue?: (option: import('../..').SelectItemOption) => string;
+        displayValue?: (option: import('../..').SelectItemOption) => string;
+        classes?: {
+            container?: string;
+            control?: import('../../select/ui').ControlClasses;
+            option?: import('../../select/ui').SelectItemClasses;
+            list?: import('../../select/ui').SelectListClasses;
+        };
+        options: import('../..').SelectItemOption[];
+        filterOptionDisabled?: boolean;
+    } & {
+        control: import('react-hook-form').Control<TFieldValues>;
+        classes?: {
+            container?: string;
+            control?: import('../../select/ui').ControlClasses;
+            option?: import('../../select/ui').SelectItemClasses;
+            list?: import('../../select/ui').SelectListClasses;
+        } & {
+            container?: string;
+            message?: string;
+        };
+    }) => import("react/jsx-runtime").JSX.Element;
+};

package/dist/shared/ui/formElements/controlled/input/InputControl.d.ts

@@ -0,0 +1,13 @@
+import { Control, FieldValues, Path, UseControllerProps } from 'react-hook-form';
+import { InputBaseProps } from '../../../input';
+type InputControlClasses = InputBaseProps['classes'] & {
+    message?: string;
+};
+type InputControlProps<TFieldValues extends FieldValues = FieldValues, TName extends Path<TFieldValues> = Path<TFieldValues>> = UseControllerProps<TFieldValues, TName> & Omit<InputBaseProps, 'classes'> & {
+    control: Control<TFieldValues>;
+    textHint?: string;
+    classes?: InputControlClasses;
+};
+declare const InnerComponent: <TFieldValues extends FieldValues = FieldValues>({ className, control, name, defaultValue, disabled, rules, shouldUnregister, textHint, classes, ...props }: InputControlProps<TFieldValues>) => import("react/jsx-runtime").JSX.Element;
+export declare const InputControl: typeof InnerComponent;
+export {};

package/dist/shared/ui/formElements/controlled/input/MaskInputControl.d.ts

@@ -0,0 +1,13 @@
+import { Control, FieldPath, FieldValues, UseControllerProps } from 'react-hook-form';
+import { MaskInputProps } from '../../../input';
+type MaskInputClasses = MaskInputProps['classes'] & {
+    message?: string;
+};
+type MaskInputControlProps<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>> = UseControllerProps<TFieldValues, TName> & Omit<MaskInputProps, 'classes'> & {
+    control: Control<TFieldValues>;
+    classes?: MaskInputClasses;
+    textHint?: string;
+};
+declare const InnerComponent: <TFieldValues extends FieldValues = FieldValues>({ className, control, name, defaultValue, disabled, rules, shouldUnregister, classes, textHint, ...props }: MaskInputControlProps<TFieldValues>) => import("react/jsx-runtime").JSX.Element;
+export declare const MaskInputControl: typeof InnerComponent;
+export {};

package/dist/shared/ui/formElements/controlled/input/index.d.ts

@@ -0,0 +1,2 @@
+export { InputControl } from './InputControl';
+export { MaskInputControl } from './MaskInputControl';

package/dist/shared/ui/formElements/controlled/select/SelectControl.d.ts

@@ -0,0 +1,13 @@
+import { Control, FieldPath, FieldValues, UseControllerProps } from 'react-hook-form';
+import { SelectBaseProps } from '../../..';
+type SelectControlClasses = SelectBaseProps['classes'] & {
+    container?: string;
+    message?: string;
+};
+type SelectControlProps<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>> = UseControllerProps<TFieldValues, TName> & SelectBaseProps & {
+    control: Control<TFieldValues>;
+    classes?: SelectControlClasses;
+};
+declare const InnerComponent: <TFieldValues extends FieldValues = FieldValues>({ control, classes, className, name, rules, shouldUnregister, disabled, defaultValue, returnValue, options, ...props }: SelectControlProps<TFieldValues>) => import("react/jsx-runtime").JSX.Element;
+export declare const SelectControl: typeof InnerComponent;
+export {};

package/dist/shared/ui/formElements/controlled/select/index.d.ts

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

package/dist/shared/ui/formElements/index.d.ts

@@ -12,3 +12,4 @@ export * from './radioControl';
 export * from './inputCurrencyControl';
 export * from './InputOtpControl';
 export * from './FormControl';
+export { Controlled } from './controlled';

package/dist/shared/ui/formElements/uploaderControl/model/hooks/useUploader.d.ts

@@ -5,7 +5,7 @@ export type TUseUploader = {
     onValueChange: (f: File[]) => void;
 };
 export declare const useUploader: ({ dropzoneOptions, controlledFiles, onValueChange }: TUseUploader) => {
-    filesStatus: Record<string, "error" | "success" | "loading">;
+    filesStatus: Record<string, "error" | "loading" | "success">;
     removeFile: (index: number) => void;
     dropzoneState: import('react-dropzone').DropzoneState;
 };

package/dist/shared/ui/index.d.ts

@@ -6,6 +6,10 @@ export * from './PhoneView';
 export { Badge, type IBadgeProps } from './Badge';
 export { Loader, type ILoaderProps } from './Loader';
 export { Skeleton, type ISkeletonProps } from './Skeleton';
+export * from './calendar';
+export * from './input';
+export * from './select';
+export * from './checkbox';
 export * from './FloatButton';
 export { Accordion, type IAccordionProps } from './accordion';
 export { Hint, type IHintProps } from './Hint';

package/dist/shared/ui/input/Input.d.ts

@@ -0,0 +1,23 @@
+import { FieldAttachment } from '../formElements/ui';
+import { DeepPartial } from '../../types';
+type InputBaseClasses = {
+    container?: string;
+    input?: string;
+    label?: string;
+};
+type FieldAttachmentProps = React.ComponentPropsWithoutRef<typeof FieldAttachment>;
+export type InputBaseProps = Omit<React.InputHTMLAttributes<HTMLInputElement>, 'placeholder'> & {
+    classes?: InputBaseClasses;
+    label: string;
+    invalid?: boolean;
+    attachmentProps?: DeepPartial<FieldAttachmentProps>;
+    renderValues?: () => React.JSX.Element | null;
+};
+export declare const InputBase: import('react').ForwardRefExoticComponent<Omit<import('react').InputHTMLAttributes<HTMLInputElement>, "placeholder"> & {
+    classes?: InputBaseClasses;
+    label: string;
+    invalid?: boolean;
+    attachmentProps?: DeepPartial<FieldAttachmentProps>;
+    renderValues?: () => React.JSX.Element | null;
+} & import('react').RefAttributes<HTMLInputElement>>;
+export {};

package/dist/shared/ui/input/MaskInput.d.ts

@@ -0,0 +1,49 @@
+import { useInputMask } from 'use-mask-input';
+import { InputBaseProps } from './Input';
+type Validator = (char: string) => boolean;
+type Casing = 'upper' | 'lower' | 'title';
+export type Definition = {
+    validator: string | Validator;
+    casing?: Casing;
+    cardinality?: number;
+    placeholder?: string;
+    definitionSymbol?: string;
+};
+export type MaskInputProps = InputBaseProps & {
+    /**
+     * маска, по которой будет определяться валидация символов
+     */
+    mask: Parameters<typeof useInputMask>[0]['mask'];
+    /**
+     * дополнительные валидаторы спец символов в маске
+     */
+    externalMaskDefinitions?: Record<string, Definition>;
+};
+/**
+ * Компонент маски очень умный, умеет обрабатывать специальные символы
+ * в том порядке, который определён маской
+ * @typeParam '\#' позволяет вводить только числа (regexp: /\d/g)
+ * @typeParam 'A' позволяет вводить любые буквы русского и английского алфавита (regexp: /[A-Za-zА-Яа-я]/g)
+ * @typeParam 'C' позволяет вводить любые буквы, которые определены для использования в гос номерах автомобилей (regexp: /([АВЕКМНОРСТУХавекмнорстух])/)
+ */
+export declare const MaskInput: import('react').ForwardRefExoticComponent<Omit<import('react').InputHTMLAttributes<HTMLInputElement>, "placeholder"> & {
+    classes?: {
+        container?: string;
+        input?: string;
+        label?: string;
+    };
+    label: string;
+    invalid?: boolean;
+    attachmentProps?: import('../../types').DeepPartial<import('../formElements/ui').IFieldAttachmentProps>;
+    renderValues?: () => React.JSX.Element | null;
+} & {
+    /**
+     * маска, по которой будет определяться валидация символов
+     */
+    mask: Parameters<typeof useInputMask>[0]["mask"];
+    /**
+     * дополнительные валидаторы спец символов в маске
+     */
+    externalMaskDefinitions?: Record<string, Definition>;
+} & import('react').RefAttributes<HTMLInputElement>>;
+export {};

package/dist/shared/ui/input/index.d.ts

@@ -0,0 +1,2 @@
+export { InputBase, type InputBaseProps } from './Input';
+export { MaskInput, type MaskInputProps } from './MaskInput';

package/dist/shared/ui/input/model/mask/index.d.ts

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

package/dist/shared/ui/input/model/mask/utils.d.ts

@@ -0,0 +1,2 @@
+import { Definition } from '../../MaskInput';
+export declare const defaultDefinitions: Record<string, Definition>;

package/dist/shared/ui/select/Select.d.ts

@@ -0,0 +1,30 @@
+import { Props } from 'react-select';
+import { ControlClasses, SelectItemClasses, SelectItemOption, SelectListClasses } from './ui';
+import { InputBaseProps } from '..';
+type SelectClasses = {
+    container?: string;
+    control?: ControlClasses;
+    option?: SelectItemClasses;
+    list?: SelectListClasses;
+};
+export type SelectBaseProps<IsMulti extends boolean = boolean> = Omit<Props<SelectItemOption, IsMulti>, 'placeholder' | 'options' | 'defaultValue'> & Pick<InputBaseProps, 'attachmentProps'> & {
+    label: string;
+    invalid?: boolean;
+    isSearchable?: boolean;
+    returnValue?: (option: SelectItemOption) => string;
+    displayValue?: (option: SelectItemOption) => string;
+    classes?: SelectClasses;
+    options: SelectItemOption[];
+    filterOptionDisabled?: boolean;
+};
+export declare const SelectBase: import('react').ForwardRefExoticComponent<Omit<Props<SelectItemOption, boolean>, "defaultValue" | "options" | "placeholder"> & Pick<InputBaseProps, "attachmentProps"> & {
+    label: string;
+    invalid?: boolean;
+    isSearchable?: boolean;
+    returnValue?: (option: SelectItemOption) => string;
+    displayValue?: (option: SelectItemOption) => string;
+    classes?: SelectClasses;
+    options: SelectItemOption[];
+    filterOptionDisabled?: boolean;
+} & import('react').RefAttributes<import('node_modules/react-select/dist/declarations/src/Select').default<SelectItemOption, boolean, import('react-select').GroupBase<SelectItemOption>>>>;
+export {};

package/dist/shared/ui/select/index.d.ts

@@ -0,0 +1,2 @@
+export { SelectBase, type SelectBaseProps } from './Select';
+export type { SelectItemOption } from './ui';

package/dist/shared/ui/select/ui/SelectItem.d.ts

@@ -0,0 +1,24 @@
+import { OptionProps } from 'react-select';
+import { DeepPartial } from '../../../types';
+import { FieldAttachment } from '../../formElements/ui';
+type FieldAttachmentProps = React.ComponentPropsWithoutRef<typeof FieldAttachment>;
+export type SelectItemOption = {
+    id: string | number;
+    value: string;
+    label: string;
+    additionalText?: string;
+    disabled?: boolean;
+    attachment?: {
+        left?: DeepPartial<FieldAttachmentProps>;
+        right?: DeepPartial<FieldAttachmentProps>;
+    };
+};
+export type SelectItemClasses = {
+    container?: string;
+    additionalText?: string;
+};
+type SelectItemProps = OptionProps<SelectItemOption> & {
+    classes?: SelectItemClasses;
+};
+export declare const SelectItem: ({ isSelected, label, data, innerProps, innerRef, selectProps, isFocused, classes, isMulti, ...props }: SelectItemProps) => import("react/jsx-runtime").JSX.Element;
+export {};