@redneckz/wildless-cms-uni-blocks 0.14.989 → 0.14.991

package/mobile/bundle/bundle.umd.js

@@ -1211,6 +1211,27 @@
     const cyrillicPattern = /^[а-яё-]*$/i;
     const isCyrillic = (_ = '') => cyrillicPattern.test(_);
 
+    const isDateValid = (value, limits) => {
+        if (!value || isNaN(value.getTime())) {
+            return false;
+        }
+        const { minLimit, maxLimit } = limits;
+        const time = value.getTime();
+        return isValidMin(time, minLimit) && isValidMax(time, maxLimit);
+    };
+    const isValidMin = (time, minLimit) => {
+        if (!minLimit || isNaN(minLimit.getTime())) {
+            return true;
+        }
+        return time > minLimit.getTime();
+    };
+    const isValidMax = (time, maxLimit) => {
+        if (!maxLimit || isNaN(maxLimit.getTime())) {
+            return true;
+        }
+        return time < maxLimit.getTime();
+    };
+
     const required = validator((_) => _ !== null && _ !== undefined && _ !== '');
 
     const ERROR_MESSAGE$1 = 'Некорректно заполненное поле';
@@ -1227,6 +1248,7 @@
     const emailValidate = (email) => /^[^\s@]+@[^\s@]+\.[a-zA-Z]{2,4}$/.test(email);
     const emailValidator = (errorMsg) => validator((_) => emailValidate(_))(errorMsg);
     const isValidInnLength = (value) => typeof value === 'string' && (value.length === 10 || value.length === 12);
+    const birthdayValidator = (errorMsg) => validator((_) => isDateValid(_, { maxLimit: new Date() }))(errorMsg);
 
     const validatorObj$1 = {
         fullName: defaultValidator(),
@@ -1249,7 +1271,7 @@
         surname: nameValidator('Укажите свою фамилию на кириллице'),
         name: nameValidator('Укажите своё имя на кириллице (без сокращений)'),
         middleName: nameValidator('Укажите своё отчество на кириллице'),
-        birthday: defaultValidator('Укажите дату рождения'),
+        birthday: birthdayValidator('Укажите дату рождения'),
         phone: phoneValidator('Укажите номер телефона'),
         email: emailValidator('Укажите электронную почту'),
         inn: innValidator('Укажите ИНН'),
@@ -1263,6 +1285,20 @@
         callbackTime: defaultValidator(),
         questionProduct: defaultValidator(),
         russianPhone: russianPhoneValidator('Укажите номер телефона'),
+        cityOfResidence: defaultValidator(),
+        internshipStartDate: defaultValidator(),
+        internshipEndDate: defaultValidator(),
+        university: defaultValidator(),
+        fieldOfStudy: defaultValidator(),
+        courseYear: defaultValidator(),
+        graduationYear: defaultValidator(),
+        averageGrade: defaultValidator(),
+        skillsAndKnowledge: defaultValidator(),
+        educationLevel: defaultSelectValidator(),
+        motivationForInternship: defaultValidator(),
+        workExperience: defaultValidator(),
+        internshipDirection: defaultValidator(),
+        workingHours: defaultValidator(),
     };
     const getFormValidator = (fieldDefs, externalValidatorObj = {}) => {
         const requiredFields = fieldDefs.filter((_) => Boolean(_?.required && _?.name));
@@ -1423,6 +1459,32 @@
         { id: 'conversionTransactions', text: 'Конверсионные операции' },
         { id: 'otherIssues', text: 'Иные вопросы ВЭД' },
     ];
+    const INTERNSHIP_DIRECTION = [
+        { key: 'economics', text: 'Экономика и финансы' },
+        { key: 'audit', text: 'Аудит' },
+        { key: 'law', text: 'Юриспруденция' },
+        { key: 'it', text: 'ИТ' },
+        { key: 'marketing', text: 'Маркетинг' },
+        { key: 'hr', text: 'HR' },
+        { key: 'analytics', text: 'Аналитика' },
+        { key: 'management', text: 'Менеджмент' },
+        { key: 'administration', text: 'ГМУ' },
+        { key: 'design', text: 'Дизайн' },
+        { key: 'journalism', text: 'Журналистика' },
+        { key: 'contact', text: 'Контакт-центр' },
+        { key: 'other', text: 'Другое' },
+    ];
+    const WORKING_HOURS = [
+        { key: '20', text: '20' },
+        { key: '30', text: '30' },
+        { key: '40', text: '40' },
+    ];
+    const EDUCATION_LEVEL = [
+        { key: 'bachelor', text: 'Бакалавриат' },
+        { key: 'specialist', text: 'Специалитет' },
+        { key: 'master', text: 'Магистратура' },
+        { key: 'doctorate', text: 'Аспирантура' },
+    ];
 
     // TODO Базовая функицональность всех Control - надо вынести и привязать к required флагу
     const getRequiredLabel = ({ label, required = false }) => label && required ? `${label}*` : label;
@@ -1474,6 +1536,9 @@
 
     const getValidStyle = (valid) => (valid ? inputValidStyle : 'border-error');
 
+    const defaultStyle$1 = 'w-full border rounded-md text-primary-text outline-none p-m';
+    const borderStyle = 'border-dashed';
+
     const Input = JSX(
     // eslint-disable-next-line max-lines-per-function
     ({ key, className, id, name, type = 'text', label, placeholder, value = '', valid = true, pattern, autoFocus = false, isTextarea = false, disabled = false, children, onChange, onFocus, onBlur, }) => {
@@ -1492,7 +1557,6 @@
         const ariaLabel = label ?? name ?? id;
         return (jsxs("div", { className: style('relative', className), children: [jsxs("label", { className: "space-y-xs", children: [renderLabel$1(label), isTextarea ? (jsx("textarea", { className: style('block resize-y min-h-24', defaultStyle$1, validStyle), id: style('textarea', id), value: value, name: name || id, placeholder: placeholder, disabled: disabled, "aria-label": ariaLabel, onChange: handleChange, onFocus: onFocus, onBlur: onBlur }, key)) : (jsx("input", { ref: inputRef, className: style('h-14', defaultStyle$1, paddingStyle, validStyle), id: id, type: type, value: value, name: name || id, placeholder: placeholder, pattern: pattern, disabled: disabled, "aria-label": ariaLabel, onChange: handleChange, onFocus: onFocus, onBlur: onBlur }, key))] }), children] }));
     });
-    const defaultStyle$1 = 'w-full border rounded-md text-primary-text outline-none p-m';
 
     const InputWrapper = JSX(({ className, label, value = '', error, errors, type, isInteger, placeholder, maxLength, inputRef, isOpen, onOpen, onClose, required, onChange = noop, ...rest }) => {
         const popupRef = useOutsideClick(onClose);
@@ -1729,6 +1793,33 @@
 
     const API_BASE_URI = '/api/v1';
 
+    const ENDPOINT_MAPPING = {
+        lead: {
+            withTypeForm: true,
+            isNaturalEndpoint: true,
+        },
+        sendcorporatelead: {
+            withTypeForm: true,
+            isNaturalEndpoint: false,
+        },
+        practice: {
+            withTypeForm: false,
+            isNaturalEndpoint: true,
+        },
+        internship: {
+            withTypeForm: false,
+            isNaturalEndpoint: true,
+        },
+        initcorporatelead: {
+            withTypeForm: false,
+            isNaturalEndpoint: false,
+        },
+        callback: {
+            withTypeForm: false,
+            isNaturalEndpoint: true,
+        },
+    };
+
     const formatDate = (date, toTimeStamp = false) => {
         if (typeof date === 'string') {
             return date.split('-').reverse().join('.');
@@ -1743,16 +1834,22 @@
 
     const formatPhone = (phone) => phone?.replace(/[^+\d]/g, '');
 
-    const getSubmitBody = (body, isNaturalPerson, router) => {
-        const { typeForm, region, phone = '', email, birthday, desiredMeetingDate, inn, fullRegion, addressBranch, secondaryPhone = '', bankEmpolee, applicationDate, partnerName, russianPhone, partnerSymbolCode, ...staticBody } = body;
+    const getSubmitBody = ({ body, endpoint, router }) => {
+        const isNaturalPerson = endpoint && ENDPOINT_MAPPING[endpoint].isNaturalEndpoint;
+        const withTypeForm = endpoint && ENDPOINT_MAPPING[endpoint].withTypeForm;
+        const { typeForm, region, phone = '', email, birthday, desiredMeetingDate, fullRegion, addressBranch, secondaryPhone = '', bankEmpolee, applicationDate, partnerName, russianPhone, partnerSymbolCode, internshipEndDate, internshipStartDate, ...staticBody } = body;
         return {
-            typeForm,
+            ...(withTypeForm ? { typeForm } : {}),
             ...getRegion(region, isNaturalPerson),
             ...getEmail(email, isNaturalPerson),
             ...getPhone(phone),
             ...getPhone(russianPhone),
-            ...getFormatDate(desiredMeetingDate, 'desiredMeetingDate'),
-            ...(isNaturalPerson ? getFormatDate(birthday) : { inn }),
+            ...(isNaturalPerson ? getFormatDate([[birthday, 'birthday']]) : { birthday }),
+            ...getFormatDate([
+                [desiredMeetingDate, 'desiredMeetingDate'],
+                [internshipEndDate, 'internshipEndDate'],
+                [internshipStartDate, 'internshipStartDate'],
+            ]),
             ...(typeForm === 'FEEDBACK'
                 ? {}
                 : {
@@ -1776,7 +1873,7 @@
         };
     };
     const getPhone = (phone) => (phone ? { phone: formatPhone(phone) } : {});
-    const getFormatDate = (date, key = 'birthday') => date ? { [key]: formatDate(date) } : {};
+    const getFormatDate = (dates) => Object.fromEntries(dates.filter(([value]) => value).map(([value, key]) => [key, formatDate(value)]));
     const getRegion = (region, isNaturalPerson = true) => ({
         [isNaturalPerson ? 'regionBranch' : 'region']: region,
     });
@@ -1799,12 +1896,16 @@
         }
         : {};
 
+    // eslint-disable-next-line max-lines-per-function
     function LeadServiceAPI() {
-        async function send(body, router, isIndividualType = false) {
-            const { serviceDirection } = body;
-            const isNaturalPerson = isIndividualType && serviceDirection !== 'Юридическое лицо / ИП';
-            const url = `${API_BASE_URI}${isNaturalPerson ? '/lead' : '/sendcorporatelead'}`;
-            const submitBody = getSubmitBody(body, isNaturalPerson, router);
+        async function send({ body, router, endpoint }) {
+            const calculatedEndpoint = endpoint && getEndpoint(endpoint, body);
+            const url = `${API_BASE_URI}/${calculatedEndpoint}`;
+            const submitBody = getSubmitBody({
+                body,
+                endpoint,
+                router,
+            });
             try {
                 const response = await LeadServiceFetch(url, submitBody);
                 if (!response?.ok) {
@@ -1831,11 +1932,11 @@
                 return null;
             }
         }
-        async function checkCode({ reqId, code, body }) {
+        async function checkCode({ reqId, code, body, router, }) {
             const submitBody = {
                 requestId: reqId,
                 confimationCode: code,
-                leadRequest: getSubmitBody(body, false),
+                leadRequest: getSubmitBody({ body, router }),
             };
             try {
                 const response = await LeadServiceFetch(`${API_BASE_URI}/confirmCorporateLead`, submitBody);
@@ -1845,9 +1946,9 @@
                 return null;
             }
         }
-        async function sendPhoneCallRequest(body, isNaturalPerson = false) {
+        async function sendPhoneCallRequest(body, endpoint) {
             // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            const submitBody = getSubmitBody(body, isNaturalPerson);
+            const submitBody = getSubmitBody({ body, endpoint });
             const formatSubmitBody = getFormatCallbackSubmitBody(submitBody);
             try {
                 const response = await LeadServiceFetch(`${API_BASE_URI}/callback`, formatSubmitBody);
@@ -1882,6 +1983,13 @@
             clientTimezone: getUserTimezoneOffset(),
         };
     };
+    const getEndpoint = (endpoint, body) => {
+        const { serviceDirection } = body;
+        if (endpoint === 'lead' && serviceDirection !== 'Юридическое лицо / ИП') {
+            return 'lead';
+        }
+        return endpoint;
+    };
 
     const handleAspects = async ({ aspectsAttributes, aspects, ev }) => {
         for (const { aspectName, params } of aspectsAttributes ?? []) {
@@ -1911,8 +2019,8 @@
             },
         });
     };
-    const handleCallback = async ({ formatData, data, aspects = {}, ev, typeForm, responseTypeDialog, onSuccess = noop, }) => {
-        const response = await API$2.sendPhoneCallRequest(formatData);
+    const handleCallback = async ({ formatData, data, aspects = {}, ev, typeForm, responseTypeDialog, onSuccess = noop, endpoint, }) => {
+        const response = await API$2.sendPhoneCallRequest(formatData, endpoint);
         onSuccess();
         if (response?.status === 'success') {
             responseTypeDialog.open({ ok: true, typeForm });
@@ -1932,7 +2040,7 @@
         }
     };
     const handleDefault = async ({ formatData, data, aspects = {}, ev, router, responseTypeDialog, endpoint, withSnowplow, }) => {
-        const response = await API$2.send(formatData, router, endpoint === 'lead');
+        const response = await API$2.send({ body: formatData, router, endpoint });
         const ok = Boolean(response);
         responseTypeDialog.open({ ok });
         if (ok) {
@@ -2208,6 +2316,10 @@
 
     const ApplierTypeField = JSX(({ field, input }) => (jsx(SelectControl, { label: "\u0422\u0438\u043F \u043E\u0431\u0440\u0430\u0442\u0438\u0432\u0448\u0435\u0433\u043E\u0441\u044F", ...input, options: APPLIER_TYPES, ...field('applierType') })));
 
+    const AverageGradeField = JSX(({ field, input }) => {
+        return (jsx(InputControl, { label: "\u0421\u0440\u0435\u0434\u043D\u0438\u0439 \u0431\u0430\u043B\u043B \u043E\u0431\u0443\u0447\u0435\u043D\u0438\u044F", type: "number", ...field(input?.name ?? ''), ...input }));
+    });
+
     const BankEmpoleeField = JSX(({ field, input }) => (jsx(InputControl, { label: "\u0424\u0418\u041E \u0438\u043B\u0438 \u0434\u043E\u043B\u0436\u043D\u043E\u0441\u0442\u044C \u043E\u0431\u0441\u043B\u0443\u0436\u0438\u0432\u0430\u0432\u0448\u0435\u0433\u043E \u0412\u0430\u0441 \u0441\u043E\u0442\u0440\u0443\u0434\u043D\u0438\u043A\u0430 \u0411\u0430\u043D\u043A\u0430", ...field(input?.name ?? ''), ...input })));
 
     const useElementSpace = (ref, heightEl) => {
@@ -2322,7 +2434,7 @@
     const START_YEAR = 1940;
     const getYears = () => Array.from({ length: new Date().getFullYear() - START_YEAR + 1 }, (_, i) => START_YEAR + i);
 
-    const ICON_PROPS$1 = {
+    const ICON_PROPS$2 = {
         name: 'CalendarIcon',
         iconVersion: 'black',
         width: '24',
@@ -2357,7 +2469,7 @@
         useEffect(() => {
             updateSelectedDate({ inputValue, setSelectedMonth, setSelectedYear, onChange });
         }, [inputValue]);
-        return (jsxs("div", { onClick: onInputClick, className: style('relative', className), children: [jsx("input", { ref: ref, className: "h-full w-full px-m text-l text-black focus-visible:outline-none rounded-none", value: inputValue, type: "text", onChange: handleChange, onBlur: onBlur, disabled: disabled }), disabled ? null : jsx(Icon, { className: "mr-s", ...ICON_PROPS$1 })] }));
+        return (jsxs("div", { onClick: onInputClick, className: style('relative', className), children: [jsx("input", { ref: ref, className: "h-full w-full px-m text-l text-black focus-visible:outline-none rounded-none", value: inputValue, type: "text", onChange: handleChange, onBlur: onBlur, disabled: disabled }), disabled ? null : jsx(Icon, { className: "mr-s", ...ICON_PROPS$2 })] }));
     });
     const isValidYear = (year) => Number(year) >= START_YEAR && Number(year) <= new Date().getFullYear();
     const isValidMonth = (month) => Number(month) > 0 && Number(month) < 13;
@@ -2464,7 +2576,7 @@
             onChange?.(new Date(selectedYear, selectedMonth, Math.min(maxDateOfMonth, value.getDate())));
     };
 
-    const ICON_PROPS = {
+    const ICON_PROPS$1 = {
         name: 'ArrowUpIcon',
         iconVersion: 'black',
         width: '24',
@@ -2506,18 +2618,21 @@
                             setSelectedYear,
                         }), isCalendarVisible && !disabled ? (jsxs("div", { className: style('absolute bg-white z-20 select-none', {
                                 'bottom-full': spaceAbove,
-                            }), children: [jsxs("div", { className: "flex gap-s", children: [jsx("div", { className: "my-auto", onClick: handlePrevMonth, children: jsx(Icon, { ...ICON_PROPS, className: "-rotate-90 cursor-pointer" }) }), jsx(Select, { onChange: handleSelectMonth, value: { key: months[selectedMonth] }, options: monthsOptions, ...SELECT_PROPS }), jsx(Select, { onChange: handleSelectYear, value: { key: String(selectedYear) }, options: yearsOptions, ...SELECT_PROPS }), jsx("div", { className: "my-auto", onClick: handleNextMonth, children: jsx(Icon, { ...ICON_PROPS, className: "rotate-90 cursor-pointer" }) })] }), jsx(Calendar, { today: value, currentMonth: selectedMonth, currentYear: selectedYear, min: minDate, max: maxDate, weekends: weekends, onDateSelect: handleDateSelect })] })) : null] })] }));
+                            }), children: [jsxs("div", { className: "flex gap-s", children: [jsx("div", { className: "my-auto", onClick: handlePrevMonth, children: jsx(Icon, { ...ICON_PROPS$1, className: "-rotate-90 cursor-pointer" }) }), jsx(Select, { onChange: handleSelectMonth, value: { key: months[selectedMonth] }, options: monthsOptions, ...SELECT_PROPS }), jsx(Select, { onChange: handleSelectYear, value: { key: String(selectedYear) }, options: yearsOptions, ...SELECT_PROPS }), jsx("div", { className: "my-auto", onClick: handleNextMonth, children: jsx(Icon, { ...ICON_PROPS$1, className: "rotate-90 cursor-pointer" }) })] }), jsx(Calendar, { today: value, currentMonth: selectedMonth, currentYear: selectedYear, min: minDate, max: maxDate, weekends: weekends, onDateSelect: handleDateSelect })] })) : null] })] }));
     });
 
     const DatePickerControl = JSX(({ className, label, error, required, ...rest }) => (jsxs("div", { className: style('shrink-0 w-full', className), children: [jsx(DatePicker, { label: getRequiredLabel({ label, required }), valid: Boolean(!error), ...rest }), renderErrorText(error)] })));
 
-    const BirthdayField = JSX(({ field, input }) => (jsx(DatePickerControl, { label: input?.label || 'Дата рождения', ...field(input?.name ?? ''), ...input })));
+    const BirthdayField = JSX(({ field, input }) => {
+        const today = new Date();
+        return (jsx(DatePickerControl, { label: input?.label || 'Дата рождения', ...field(input?.name ?? ''), maxDate: today, ...input }));
+    });
 
     const CallbackTimeField = JSX(({ field, input }) => (jsx(SelectControl, { label: "\u041A\u043E\u0433\u0434\u0430 \u043F\u0435\u0440\u0435\u0437\u0432\u043E\u043D\u0438\u0442\u044C?", ...input, options: CALLBACK_TIME, ...field(input?.name ?? '') })));
 
     const CollectionCountField = JSX(({ field, input }) => (jsx(InputControl, { label: "\u041A\u043E\u043B\u0438\u0447\u0435\u0441\u0442\u0432\u043E \u043E\u0431\u044A\u0435\u043A\u0442\u043E\u0432 \u0438\u043D\u043A\u0430\u0441\u0441\u0430\u0446\u0438\u0438", isInteger: true, ...field(input?.name ?? ''), ...input })));
 
-    const CommentField = JSX(({ field, input }) => (jsx(InputControl, { className: "col-span-2", ...field(input?.name ?? ''), placeholder: "\u0412\u0430\u0448\u0435 \u0441\u043E\u043E\u0431\u0449\u0435\u043D\u0438\u0435", isTextarea: true, ...input })));
+    const CommentField = JSX(({ field, input }) => (jsx(InputControl, { className: "col-span-2", ...field(input?.name ?? ''), placeholder: input?.placeholder ?? 'Ваше сообщение', isTextarea: true, ...input })));
 
     function useAsyncEffect(effect, deps) {
         useEffect(() => {
@@ -2656,6 +2771,355 @@
 
     const FeedbackMethodField = JSX(({ field, input }) => (jsx(SelectControl, { label: "\u0421\u043F\u043E\u0441\u043E\u0431 \u043F\u043E\u043B\u0443\u0447\u0435\u043D\u0438\u044F \u043E\u0442\u0432\u0435\u0442\u0430", options: FEEDBACK_METHOD, ...field(input?.name ?? ''), ...input })));
 
+    const ACCEPTED_EXTENSIONS_TEXT = 'Поддерживаемые форматы файлов';
+    const MAX_SIZE_TEXT = 'Максимальный размер файла';
+    const EMPTY_FILE_ERROR_TEXT = 'Ошибка загрузки файла. Убедитесь, что файл не пустой';
+    const EXTENSIONS_ERROR_TEXT = 'Файл не соответствует допустимым расширениям';
+    const MAX_SIZE_ERROR_TEXT = 'Файл превышает допустимый размер';
+    const DEFAULT_ERROR_TEXT = 'Ошибка при загрузке файла. Попробуйте загрузить файл позднее';
+
+    const FILE_CHECK_URL = 'uploadFile';
+    const SUCCESS_STATUS = 'SUCCESS';
+    async function sendFile({ file, onProgress = noop }) {
+        return new Promise((resolve, reject) => {
+            const formData = new FormData();
+            formData.append('file', file);
+            let processingAnimation = undefined;
+            const xhr = new XMLHttpRequest();
+            let lastProgress;
+            xhr.upload.onprogress = (event) => {
+                if (event.lengthComputable) {
+                    const percentComplete = (event.loaded / event.total) * 50;
+                    onProgress(percentComplete);
+                }
+            };
+            xhr.upload.onload = () => {
+                let current = 50;
+                onProgress(current);
+                processingAnimation = window.setInterval(() => {
+                    current += 0.2;
+                    lastProgress = current;
+                    if (current < 90) {
+                        onProgress(current);
+                    }
+                    else {
+                        onProgress(90);
+                        window.clearInterval(processingAnimation);
+                    }
+                }, 100);
+            };
+            xhr.onload = async () => {
+                try {
+                    const response = JSON.parse(xhr.responseText);
+                    if (response.status === 'SUCCESS') {
+                        window.clearInterval(processingAnimation);
+                        await animateToFull(lastProgress, onProgress);
+                        resolve(response);
+                    }
+                    else {
+                        reject(new Error(response.errorDesc ?? DEFAULT_ERROR_TEXT));
+                    }
+                }
+                catch (e) {
+                    reject(new Error(DEFAULT_ERROR_TEXT));
+                }
+            };
+            xhr.onerror = () => {
+                reject(new Error(DEFAULT_ERROR_TEXT));
+            };
+            xhr.open('POST', `${API_BASE_URI}/${FILE_CHECK_URL}`);
+            xhr.send(formData);
+        });
+    }
+    const animateToFull = (current, onProgress) => new Promise((resolve) => {
+        let value = current;
+        const increment = (100 - current) / 30;
+        const interval = 16;
+        const step = () => {
+            value += increment;
+            if (value >= 100) {
+                onProgress(100);
+                resolve();
+            }
+            else {
+                onProgress(value);
+                setTimeout(step, interval);
+            }
+        };
+        step();
+    });
+
+    const useDragAndDrop = ({ onFileSelected, onReset, uploadResponse, onFileChanged, }) => {
+        const [isDragActive, setIsDragActive] = useState(false);
+        const handleDrag = (e) => {
+            e.preventDefault();
+            if (uploadResponse) {
+                return;
+            }
+            setIsDragActive(true);
+        };
+        const handleLeave = () => setIsDragActive(false);
+        const handleDrop = async (e) => {
+            e.preventDefault();
+            if (uploadResponse) {
+                return;
+            }
+            onReset();
+            setIsDragActive(false);
+            const file = e.dataTransfer?.files?.[0];
+            if (file) {
+                await onFileSelected({ file, onFileChanged });
+            }
+        };
+        return { handleDrag, handleLeave, handleDrop, isDragActive };
+    };
+
+    const ProgressBar = JSX(({ step = 10, description, showPercentage = true, isOnlyInteger = false }) => (jsxs("div", { children: [jsx("div", { className: "h-4 w-full bg-gray relative", children: jsx("div", { className: "h-4 bg-green", style: { width: `${step}%` } }) }), jsxs("div", { className: "relative", children: [showPercentage ? (jsxs("div", { className: "absolute left-2/4 text-green", children: [isOnlyInteger ? Math.round(step) : step, "%"] })) : null, description ? jsx("div", { className: "text-right pr-m text-gray", children: description }) : null] })] })));
+
+    const ICON_PROPS = {
+        name: 'DocIcon',
+        iconVersion: 'black',
+        width: '24',
+        height: '24',
+    };
+    const renderFileInput = ({ label, inputRef, id, key, type, name, pattern, disabled, onChange = noop, onFocus, onBlur, extensions, uploadResponse, file, }) => {
+        const ariaLabel = label ?? name ?? id;
+        return (jsx("div", { children: uploadResponse?.status === SUCCESS_STATUS ? (renderFileName(file)) : (jsxs("div", { className: "flex items-center space-x-2", children: [jsx(Icon, { className: "inline-block", ...ICON_PROPS }), renderLabel$1(label), jsx("input", { ref: inputRef, className: style('h-14 hidden'), id: id, type: type, name: name || id, pattern: pattern, disabled: disabled, "aria-label": ariaLabel, onChange: (e) => {
+                            e?.target?.files && onChange(e?.target?.files[0]);
+                        }, onFocus: onFocus, onBlur: onBlur, accept: extensionsToAccept(extensions) }, key)] })) }));
+    };
+    const extensionsToAccept = (extensions = []) => {
+        return extensions
+            .map((ext) => {
+            const str = String(ext).trim();
+            return str.startsWith('.') ? str : '.' + str;
+        })
+            .map((ext) => ext.toLowerCase())
+            .filter((ext, index, arr) => arr.indexOf(ext) === index)
+            .join(', ');
+    };
+    const renderFileName = (file) => jsx("span", { children: file?.name });
+
+    const renderInfoText = (extensions, maxSize) => {
+        const extensionsMessage = extensions
+            ? `${ACCEPTED_EXTENSIONS_TEXT} - ${extensions.join(', ')}. `
+            : '';
+        const maxSizeMessage = maxSize ? `${MAX_SIZE_TEXT} - ${maxSize}Мб.` : '';
+        return (jsx(Text, { size: "text-xs", font: "font-light", color: "text-secondary-text", children: extensionsMessage + maxSizeMessage }));
+    };
+
+    const animateStepWithMinDuration = ({ from, to, onUpdate = noop, minDuration = 300, }) => {
+        return new Promise((resolve) => {
+            const startTime = performance.now();
+            const animate = () => {
+                const currentTime = performance.now();
+                const elapsed = currentTime - startTime;
+                const animationProgress = Math.min(elapsed / minDuration, 1);
+                const easeProgress = 1 - Math.pow(1 - animationProgress, 3);
+                const value = from + (to - from) * easeProgress;
+                onUpdate(value);
+                if (animationProgress < 1) {
+                    requestAnimationFrame(animate);
+                }
+                else {
+                    onUpdate(to);
+                    resolve();
+                }
+            };
+            requestAnimationFrame(animate);
+        });
+    };
+
+    const checkFileExtension = async (file, extensions) => {
+        const fileExt = file.name.split('.')[1];
+        console.log(fileExt, extensions);
+        if (!extensions?.includes(fileExt)) {
+            throw new Error(EXTENSIONS_ERROR_TEXT);
+        }
+    };
+
+    const EXT_TO_MIME = {
+        pdf: 'application/pdf',
+        doc: 'application/msword',
+        docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+        pptx: 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+    };
+    const checkFileMimeType = async (file, extensions) => {
+        const fileMimeType = file?.type ?? '';
+        const expectedMimeTypes = (extensions || [])
+            .map((ext) => EXT_TO_MIME[ext])
+            .filter((mime) => mime !== undefined);
+        if (!expectedMimeTypes.includes(fileMimeType)) {
+            throw new Error(EXTENSIONS_ERROR_TEXT);
+        }
+    };
+
+    const getFileSignature = (file) => {
+        return new Promise((resolve, reject) => {
+            const reader = new FileReader();
+            reader.onload = () => {
+                const buffer = reader.result;
+                const bytes = new Uint8Array(buffer);
+                const hex = Array.from(bytes)
+                    .map((b) => b.toString(16).padStart(2, '0'))
+                    .join(' ');
+                resolve(hex);
+            };
+            reader.onerror = reject;
+            return file && reader.readAsArrayBuffer(file.slice(0, 8));
+        });
+    };
+
+    const SIGNATURES = {
+        pdf: '25 50 44 46 2d',
+        docx: '50 4b 03 04',
+        pptx: '50 4b 03 04',
+        xlsx: '50 4b 03 04',
+        doc: 'D0 CF 11 E0 A1 B1 1A E1',
+    };
+    const checkFileSignature = async (file, expectedTypes) => {
+        const hexSignature = await getFileSignature(file);
+        const isValid = (expectedTypes ?? []).some((type) => {
+            const expectedSignature = SIGNATURES[type]?.toLowerCase();
+            console.log(expectedSignature);
+            console.log(hexSignature);
+            return expectedSignature && hexSignature.startsWith(expectedSignature);
+        });
+        if (!isValid) {
+            throw new Error(EXTENSIONS_ERROR_TEXT);
+        }
+    };
+
+    const checkFileSize = async (file, maxSizeMB) => {
+        if (maxSizeMB && file.size > maxSizeMB * 1024 * 1024) {
+            throw new Error(MAX_SIZE_ERROR_TEXT);
+        }
+        if (file.size === 0) {
+            throw new Error(EMPTY_FILE_ERROR_TEXT);
+        }
+    };
+
+    const DEBOUNCE_DELAY = 500;
+    const useVerifyFile = ({ onUploadError = noop, onFileSelected = noop, extensions, maxSizeMB, onUploadResponse = noop, }) => {
+        const [progress, setProgress] = useState(0);
+        const [isFileUploading, setIsFileUploading] = useState(false);
+        const debouncedOnFileUploaded = useMemo(() => debounce((isUploading) => setIsFileUploading(isUploading), DEBOUNCE_DELAY), [setIsFileUploading]);
+        const debouncedOnUploadError = useMemo(() => debounce((message) => onUploadError(message), DEBOUNCE_DELAY), [onUploadError]);
+        const debouncedOnUploadResponse = useMemo(() => debounce((response) => onUploadResponse(response), DEBOUNCE_DELAY), [onUploadResponse]);
+        const verifyFile = async ({ file, onFileChanged = noop }) => {
+            onFileSelected(file);
+            setIsFileUploading(true);
+            const checks = [
+                () => checkFileExtension(file, extensions),
+                () => checkFileSize(file, maxSizeMB),
+                () => checkFileSignature(file, extensions),
+                () => checkFileMimeType(file, extensions),
+            ];
+            const checkProgressStep = 50 / checks.length;
+            let currentProgress = 0;
+            try {
+                for (let i = 0; i < checks.length; i++) {
+                    const checkPromise = checks[i];
+                    await checkPromise();
+                    const targetProgress = (i + 1) * checkProgressStep;
+                    await animateStepWithMinDuration({
+                        from: currentProgress,
+                        to: targetProgress,
+                        onUpdate: setProgress,
+                        minDuration: 300,
+                    });
+                    currentProgress = targetProgress;
+                }
+                const response = await sendFile({
+                    file,
+                    onProgress: setProgress,
+                });
+                debouncedOnUploadResponse(response);
+                onFileChanged(response?.fileId ?? '');
+                if (response?.status === SUCCESS_STATUS) {
+                    debouncedOnFileUploaded?.(false);
+                }
+            }
+            catch (e) {
+                const errorMessage = e instanceof Error ? e.message : DEFAULT_ERROR_TEXT;
+                debouncedOnUploadError(errorMessage);
+                onFileChanged('');
+            }
+            debouncedOnFileUploaded?.(false);
+        };
+        return { verifyFile, isFileUploading, progress };
+    };
+
+    const InputFile = JSX(
+    // eslint-disable-next-line max-lines-per-function
+    ({ key, className, id, name, type = 'file', label, valid = true, pattern, autoFocus = false, extensions, children, onFocus, onBlur, maxSizeMB, error, onFileChanged = noop, }) => {
+        const inputRef = useRef(null);
+        const [selectedFile, setSelectedFile] = useState(null);
+        const [uploadError, setUploadError] = useState('');
+        const [uploadResponse, setUploadResponse] = useState(null);
+        const { verifyFile, isFileUploading, progress } = useVerifyFile({
+            onUploadError: setUploadError,
+            onUploadResponse: setUploadResponse,
+            onFileSelected: setSelectedFile,
+            extensions,
+            maxSizeMB,
+        });
+        useEffect(() => {
+            if (autoFocus) {
+                inputRef.current?.focus();
+            }
+        }, [autoFocus, inputRef]);
+        const handleFileChange = async (file) => {
+            handleResetFile();
+            if (file) {
+                await verifyFile({ file, onFileChanged });
+            }
+        };
+        const handleResetFile = () => {
+            setSelectedFile(null);
+            setUploadError('');
+            setUploadResponse(null);
+            onFileChanged('');
+        };
+        const { handleDrag, handleLeave, handleDrop, isDragActive } = useDragAndDrop({
+            onReset: handleResetFile,
+            onFileSelected: verifyFile,
+            uploadResponse,
+            onFileChanged,
+        });
+        const paddingStyle = children ? 'pr-3xl' : '';
+        const validStyle = getValidStyle(valid);
+        const activeDragStyle = isDragActive ? 'border-primary-hover' : '';
+        return (jsxs("div", { className: style('relative', className), onDragEnter: handleDrag, onDragOver: handleDrag, onDragLeave: handleLeave, onDrop: handleDrop, children: [jsx("label", { className: style('h-14 cursor-pointer space-y-xs block', defaultStyle$1, paddingStyle, borderStyle, validStyle, activeDragStyle), children: isFileUploading ? (jsx("div", { children: jsx(ProgressBar, { step: progress, isOnlyInteger: true }) })) : (renderFileInput({
+                        label,
+                        inputRef,
+                        id,
+                        key,
+                        type,
+                        name,
+                        pattern,
+                        disabled: Boolean(uploadResponse || isFileUploading),
+                        onChange: handleFileChange,
+                        onFocus,
+                        onBlur,
+                        extensions,
+                        uploadResponse,
+                        file: selectedFile,
+                    })) }), uploadResponse?.status === SUCCESS_STATUS ? (jsx(CloseButton, { className: "absolute top-0 right-0 z-10", onClose: handleResetFile })) : null, renderInfoText(extensions, maxSizeMB), renderErrorText(error || uploadError), children] }));
+    });
+
+    const InputFileControl = JSX(({ label, value = '', error, type, inputRef, required, ...rest }) => {
+        return (jsx("div", { ref: inputRef, children: jsx(InputFile, { type: type || 'file', "aria-label": label, label: getRequiredLabel({ label, required }), valid: Boolean(!error), value: value, error: error, ...rest }) }));
+    });
+
+    const FileUploadField = JSX(({ field, input }) => {
+        const [fileId, setFileId] = useState('');
+        useEffect(() => {
+            field('fileId')?.onChange?.(fileId);
+        }, [fileId]);
+        return (jsx(InputFileControl, { type: "file", label: input?.name ?? '', ...field(input?.name ?? ''), ...input, onFileChanged: setFileId }));
+    });
+
     const FullNameField = JSX(({ field, input }) => (jsx(InputControl, { label: "\u0424\u0418\u041E", ...field(input?.name ?? ''), ...input })));
 
     const FullRegionField = JSX(({ field, input, params }) => {
@@ -2670,6 +3134,38 @@
 
     const InnField = JSX(({ field, input }) => (jsx(InputControl, { label: "\u0418\u041D\u041D", isInteger: true, maxLength: 12, ...input, ...field(input?.name ?? '') })));
 
+    const INTERNSHIP_END_DATE_ERROR = 'Некорректно заполненное поле';
+    const InternshipEndDateField = JSX(({ field, input }) => {
+        const [startDate, setStartDate] = useState();
+        const [internshipEndDateError, setInternshipEndDateError] = useState('');
+        const [internshipEndDateValue, setInternshipEndDateValue] = useState();
+        useEffect(() => {
+            setStartDate(field('internshipStartDate').value);
+        }, [field('internshipStartDate').value]);
+        const handleInputChange = (value) => {
+            setInternshipEndDateValue(value);
+            field(input?.name ?? '')?.onChange?.(value);
+            setInternshipEndDateError(isDateValid(value, { minLimit: startDate }) ? '' : INTERNSHIP_END_DATE_ERROR);
+        };
+        return (jsx(DatePickerControl, { label: input?.label || 'Дата окончания практики', ...field(input?.name ?? ''), ...input, value: internshipEndDateValue, error: field(input?.name ?? '')?.error || internshipEndDateError, errors: [field(input?.name ?? '')?.error || internshipEndDateError], onChange: handleInputChange, minDate: startDate }));
+    });
+
+    const INTERNSHIP_START_DATE_ERROR = 'Некорректно заполненное поле';
+    const InternshipStartDateField = JSX(({ field, input }) => {
+        const [endDate, setEndDate] = useState();
+        const [internshipStartDateError, setInternshipStartDateError] = useState('');
+        const [internshipStartDateValue, setInternshipStartDateValue] = useState();
+        useEffect(() => {
+            setEndDate(field('internshipEndDate').value);
+        }, [field('internshipEndDate').value]);
+        const handleInputChange = (value) => {
+            setInternshipStartDateValue(value);
+            field(input?.name ?? '')?.onChange?.(value);
+            setInternshipStartDateError(isDateValid(value, { maxLimit: endDate }) ? '' : INTERNSHIP_START_DATE_ERROR);
+        };
+        return (jsx(DatePickerControl, { label: input?.label || 'Дата начала практики', ...field(input?.name ?? ''), ...input, value: internshipStartDateValue, error: internshipStartDateError || field(input?.name ?? '')?.error, errors: [internshipStartDateError ?? field(input?.name ?? '')?.error], onChange: handleInputChange, maxDate: endDate }));
+    });
+
     const CheckboxWithError = JSX(({ className, text, value, key, disabled, error, onChange }) => (jsxs("div", { className: style('shrink-0', className), children: [jsx(Checkbox, { text: text, value: value, disabled: disabled, onChange: onChange }, key), renderErrorText(error)] })));
 
     const IsClientField = JSX(({ field, input }) => (jsx(CheckboxWithError, { ...field(input?.name ?? ''), ...input, text: '\u042F\u0432\u043B\u044F\u044E\u0441\u044C \u043A\u043B\u0438\u0435\u043D\u0442\u043E\u043C \u0431\u0430\u043D\u043A\u0430 \u0410\u041E "\u0420\u043E\u0441\u0441\u0435\u043B\u044C\u0445\u043E\u0437\u0431\u0430\u043D\u043A"' })));
@@ -2800,6 +3296,8 @@
                 : withValidator(fieldPhone, validatorObj$1.secondaryPhone)) }));
     });
 
+    const SelectField$1 = JSX(({ field, input, label, options }) => (jsx(SelectControl, { label: label, options: options, ...field(input?.name ?? ''), ...input })));
+
     const ServiceDirectionField = JSX(({ field, input }) => (jsx(SelectControl, { label: "\u041D\u0430\u043F\u0440\u0430\u0432\u043B\u0435\u043D\u0438\u0435 \u043E\u0431\u0441\u043B\u0443\u0436\u0438\u0432\u0430\u043D\u0438\u044F", placeholder: "\u0412\u044B\u0431\u0435\u0440\u0438\u0442\u0435 \u043D\u0430\u043F\u0440\u0430\u0432\u043B\u0435\u043D\u0438\u0435", options: SERVICE_DIRECTIONS, ...field(input?.name ?? ''), ...input })));
 
     const SituationDescriptionField = JSX(({ field, input }) => (jsx(InputControl, { label: "\u041E\u043F\u0438\u0441\u0430\u043D\u0438\u0435 \u0441\u0438\u0442\u0443\u0430\u0446\u0438\u0438", ...input, ...field('situationDescription') })));
@@ -2813,6 +3311,8 @@
     const ITEMS_CREDIT_TERM = ['От 1 мес', 'До 15 лет'];
     const TermField = JSX(({ field }) => (jsx(InputRange, { title: "\u0421\u0440\u043E\u043A, \u043C\u0435\u0441\u044F\u0446\u0435\u0432", items: ITEMS_CREDIT_TERM, min: MIN_CREDIT_TERM, max: MAX_CREDIT_TERM, ...field('term') })));
 
+    const TextField = JSX(({ field, input, label }) => (jsx(InputControl, { label: label, maxLength: 60, ...field(input?.name ?? ''), ...input })));
+
     const UltraPremiumField = JSX(({ field, input }) => (jsx(SelectControl, { label: "\u0422\u0438\u043F \u043E\u0431\u0441\u043B\u0443\u0436\u0438\u0432\u0430\u043D\u0438\u044F", options: SERVICE_TYPES, ...field(input?.name ?? ''), ...input })));
 
     const orientationStyleMap = {
@@ -2833,22 +3333,6 @@
 
     const ConsentToReceiveMaterialsField = JSX(({ field, input }) => (jsx(Checkbox, { text: "\u0421\u043E\u0433\u043B\u0430\u0441\u0435\u043D \u043D\u0430 \u043F\u043E\u043B\u0443\u0447\u0435\u043D\u0438\u0435 \u0438\u043D\u0444\u043E\u0440\u043C\u0430\u0446\u0438\u043E\u043D\u043D\u044B\u0445 \u0438 \u0430\u043D\u0430\u043B\u0438\u0442\u0438\u0447\u0435\u0441\u043A\u0438\u0445 \u043C\u0430\u0442\u0435\u0440\u0438\u0430\u043B\u043E\u0432 \u043F\u043E \u044D\u043B\u0435\u043A\u0442\u0440\u043E\u043D\u043D\u043E\u0439 \u043F\u043E\u0447\u0442\u0435", ...field(input?.name ?? ''), ...input })));
 
-    const RefWrapper = JSX(({ onFieldRef = noop, children }) => {
-        const ref = useRef(null);
-        useEffect(() => {
-            if (ref.current) {
-                onFieldRef(ref.current);
-            }
-        }, []);
-        return jsx("div", { ref: ref, children: children });
-    });
-
-    function shouldRenderField({ input, field, }) {
-        const { condition } = input;
-        const { value } = field(condition?.name || '');
-        return !condition || condition?.values?.includes(value?.key ?? value);
-    }
-
     const PRODUCT_REF = {
         $ref: '/wcms-resources/outservice-productlist.json',
     };
@@ -2899,7 +3383,39 @@
         questionProduct: QuestionProductField,
         callbackTime: CallbackTimeField,
         russianPhone: PhoneField,
+        cityOfResidence: (props) => jsx(TextField, { ...props, label: "\u0413\u043E\u0440\u043E\u0434 \u043F\u0440\u043E\u0436\u0438\u0432\u0430\u043D\u0438\u044F" }),
+        internshipStartDate: InternshipStartDateField,
+        internshipEndDate: InternshipEndDateField,
+        university: (props) => jsx(TextField, { ...props, label: "\u0412\u0423\u0417" }),
+        courseYear: (props) => jsx(TextField, { ...props, label: "\u041A\u0443\u0440\u0441" }),
+        graduationYear: (props) => jsx(TextField, { ...props, label: "\u0413\u043E\u0434 \u043E\u043A\u043E\u043D\u0447\u0430\u043D\u0438\u044F" }),
+        fieldOfStudy: (props) => jsx(TextField, { ...props, label: "\u041D\u0430\u043F\u0440\u0430\u0432\u043B\u0435\u043D\u0438\u0435 \u043E\u0431\u0443\u0447\u0435\u043D\u0438\u044F" }),
+        educationLevel: (props) => (jsx(SelectField$1, { ...props, label: "\u0421\u0442\u0443\u043F\u0435\u043D\u044C \u043E\u0431\u0443\u0447\u0435\u043D\u0438\u044F", options: EDUCATION_LEVEL })),
+        averageGrade: AverageGradeField,
+        skillsAndKnowledge: CommentField,
+        workExperience: CommentField,
+        motivationForInternship: CommentField,
+        internshipDirection: (props) => (jsx(SelectField$1, { ...props, label: "\u041D\u0430\u043F\u0440\u0430\u0432\u043B\u0435\u043D\u0438\u0435 \u0441\u0442\u0430\u0436\u0438\u0440\u043E\u0432\u043A\u0438", options: INTERNSHIP_DIRECTION })),
+        workingHours: (props) => (jsx(SelectField$1, { ...props, label: "\u041A\u043E\u043B\u0438\u0447\u0435\u0441\u0442\u0432\u043E \u0440\u0430\u0431\u043E\u0447\u0438\u0445 \u0447\u0430\u0441\u043E\u0432", options: WORKING_HOURS })),
+        fileUpload: FileUploadField,
     };
+
+    const RefWrapper = JSX(({ onFieldRef = noop, children }) => {
+        const ref = useRef(null);
+        useEffect(() => {
+            if (ref.current) {
+                onFieldRef(ref.current);
+            }
+        }, []);
+        return jsx("div", { ref: ref, children: children });
+    });
+
+    function shouldRenderField({ input, field, }) {
+        const { condition } = input;
+        const { value } = field(condition?.name || '');
+        return !condition || condition?.values?.includes(value?.key ?? value);
+    }
+
     const getField = (field, params, externalInputs = {}) => (input, i) => {
         const fieldsRegister = {
             ...InputsMap$1,
@@ -3012,6 +3528,7 @@
     const API$1 = LeadServiceAPI();
     const useVerifyPhoneDialogSubmit$1 = ({ values, onSuccess, formatData, reqId, }) => {
         const timer = Math.max(getTimer(Date.now()), 0);
+        const router = useRouter();
         const [errorText, setErrorText] = useState('');
         const [isLoading, { setTrue: startLoading, setFalse: endLoading }] = useBool(false);
         const [timeNextReq, setTimeNextReq] = useState(timer);
@@ -3024,6 +3541,7 @@
                     code: values.join(''),
                     body: formatData,
                     reqId,
+                    router,
                 });
                 if (response?.errorDesc) {
                     setErrorText(response?.errorDesc);
@@ -3095,7 +3613,7 @@
         const verifyPhoneDialog = useDialog(VerifyPhoneDialog$1);
         const handleSubmit = useCallback(async (formData, ev) => {
             const formatData = getFormatData({ ...formData, ...additionalParams });
-            await executeHandler(endpoint ?? 'default', {
+            await executeHandler({
                 formatData,
                 ev,
                 typeForm,
@@ -3105,9 +3623,8 @@
                 responseTypeDialog,
                 verifyPhoneDialog,
                 onSuccess,
-                endpoint,
                 withSnowplow,
-            });
+            }, endpoint);
         }, [typeForm]);
         const [, { field, onSubmit }] = useForm(initialFormState, {
             resetOnSubmit: true,
@@ -3123,9 +3640,9 @@
                             typeForm,
                         })] }), isContacts ? renderContacts() : null] }));
     });
-    const executeHandler = async (endpoint, context) => {
-        const handler = handlerMap[endpoint] || handlerMap.default;
-        await handler(context);
+    const executeHandler = async (context, endpoint) => {
+        const handler = (endpoint && handlerMap[endpoint]) || handlerMap.default;
+        await handler({ ...context, endpoint });
     };
 
     const mapProductTypeToName = {
@@ -8991,8 +9508,6 @@
     const showIncreasedPercents = (currentCashback, cashback) => INCREASED_PERCENTS.includes(currentCashback.percent.key) ||
         !cashback.some((_) => INCREASED_PERCENTS.includes(_.percent.key));
 
-    const ProgressBar = JSX(({ step = 10, description, showPercentage = true }) => (jsxs("div", { children: [jsx("div", { className: "h-4 w-full bg-gray relative", children: jsx("div", { className: "h-4 bg-green", style: { width: `${step}%` } }) }), jsxs("div", { className: "relative", children: [showPercentage ? jsxs("div", { className: "absolute left-2/4 text-green", children: [step, "%"] }) : null, description ? jsx("div", { className: "text-right pr-m text-gray", children: description }) : null] })] })));
-
     const CreditCardFormProgress = JSX(({ step = 1, totalSteps = 6, stepsTitles = [] }) => {
         const progress = useMemo(() => ((step + 1) / totalSteps) * 100, [step, totalSteps]);
         return (jsx("div", { className: "py-lg px-5xl bg-white col-span-12", children: jsxs("div", { children: [jsxs("span", { className: "font-bold mr-s", children: ["\u0428\u0430\u0433 ", step + 1, " \u0438\u0437 ", totalSteps, "."] }), stepsTitles[step] || null, jsx(ProgressBar, { step: progress, showPercentage: false })] }) }));
@@ -12949,7 +13464,7 @@
         slots: () => [HEADER_SLOT, FOOTER_SLOT, STICKY_FOOTER_SLOT],
     });
 
-    const packageVersion = "0.14.988";
+    const packageVersion = "0.14.990";
 
     exports.Blocks = Blocks;
     exports.ContentPage = ContentPage;