@salutejs/plasma-new-hope 0.194.0-canary.1562.11857238836.0 → 0.194.0-canary.1565.11870784206.0

package/emotion/cjs/components/TextField/TextField.template-doc.mdx

@@ -5,6 +5,9 @@ title: TextField
 
 import { PropsTable, Description } from '@site/src/components';
 
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
 # TextField
 <Description name="TextField" />
 <PropsTable name="TextField" exclude={['$isFocused']} />
@@ -198,3 +201,330 @@ export function App() {
     );
 }
 ```
+
+### Валидация
+Поддерживается валидация почты и пароля:
+
+<Tabs>
+    <TabItem value="email" label="Email" default>
+        Свойства доступные при валидации почты:
+        ```tsx
+        type ValidationProps = {
+            /*
+            * Тип валидации
+            */
+            validationType: 'email';
+            /*
+            * Опции валидации
+            */
+            options?: EmailValidationOptions;
+            /*
+            * Функция, вызываемая при валидации значения.
+            * Вызывается при событии onBlur и по нажатию Enter, когда фокус на поле ввода
+            */
+            onValidate?: (args: OnValidateArgs) => void;
+        }
+        ```
+        Свойство `options` имеет следующий вид:
+        ```tsx
+        type EmailValidationOptions = {
+            /*
+            * Пользовательское регулярное выражение, для проверки почты на валидность
+            */
+            customEmailRegex?: {
+                value?: RegExp;
+                errorMessage?: string;
+            };
+            /*
+            * Минимальная длина почты
+            */
+            minLength?: {
+                value?: number;
+                errorMessage?: string;
+            };
+            /*
+            * Максимальная длина почты
+            */
+            maxLength?: {
+                value?: number;
+                errorMessage?: string;
+            };
+            /*
+            * Минимальная длина хоста (часть почты до `@`)
+            */
+            minHostLength?: {
+                value?: number;
+                errorMessage?: string;
+            };
+            /*
+            * Максимальная длина хоста (часть почты до `@`)
+            */
+            maxHostLength?: {
+                value?: number;
+                errorMessage?: string;
+            };
+            /*
+            * Минимальная длина домена (часть почты от `@` до `.` перед доменной зоной)
+            */
+            minDomainLength?: {
+                value?: number;
+                errorMessage?: string;
+            };
+            /*
+            * Максимальная длина домена (часть почты от `@` до `.` перед доменной зоной)
+            */
+            maxDomainLength?: {
+                value?: number;
+                errorMessage?: string;
+            };
+            /*
+            * Минимальная длина доменной зоны (часть почты от `.`; например `ru`, `com`...)
+            */
+            minZoneLength?: {
+                value?: number;
+                errorMessage?: string;
+            };
+            /*
+            * Максимальная длина доменной зоны (часть почты от `.`; например `ru`, `com`...)
+            */
+            maxZoneLength?: {
+                value?: number;
+                errorMessage?: string;
+            };
+            /*
+            * Список разрешенных доменов (например `['mail.ru', 'yahoo.ru', 'gmail.com']`)
+            */
+            whitelistDomains?: {
+                value?: string[];
+                errorMessage?: string;
+            };
+            /*
+            * Список запрещенных доменов (например `['org.biz', 'expressmail.com']`)
+            */
+            blacklistDomains?: {
+                value?: string[];
+                errorMessage?: string;
+            };
+        };
+        ```
+
+        ```tsx live
+        import React, { useState } from 'react';
+        import { TextField } from '@salutejs/{{ package }}';
+
+        export function App() {
+            const options = {
+                minLength: {
+                    value: 7,
+                    errorMessage: 'Почта слишком короткая',
+                },
+                maxLength: {
+                    value: 30,
+                    errorMessage: 'Почта слишком длинная',
+                },
+                minHostLength: {
+                    value: 2,
+                    errorMessage: 'Хост слишком короткий',
+                },
+                maxHostLength: {
+                    value: 12,
+                    errorMessage: 'Хост слишком длинный',
+                },
+                minDomainLength: {
+                    value: 3,
+                    errorMessage: 'Домен слишком короткий',
+                },
+                maxDomainLength: {
+                    value: 6,
+                    errorMessage: 'Домен слишком длинный',
+                },
+                minZoneLength: {
+                    value: 2,
+                    errorMessage: 'Доменная зона слишком короткая',
+                },
+                maxZoneLength: {
+                    value: 5,
+                    errorMessage: 'Доменная зона слишком длинная',
+                },
+                whitelistDomains: {
+                    value: ['plasma.ru', 'gmail.com', 'mail.ru'],
+                    errorMessage: 'Домен не разрешен',
+                },
+                blacklistDomains: {
+                    value: ['hah.ah', 'heh.eh'],
+                    errorMessage: 'Домен запрещен',
+                },
+            };
+
+            const [error, setError] = useState('');
+
+            const handleOnChange = () => {
+                setError('');
+            };
+
+            const handleOnValidate = ({ errorMessage }: { errorMessage?: string }) => {
+                setError(errorMessage || '');
+            };
+
+            return (
+                <div>
+                    <TextField
+                        label="Валидация почты"
+                        placeholder="Заполните поле"
+                        validationType="email"
+                        options={options}
+                        view={error ? 'negative' : 'default}
+                        helperText={error || 'Валидация почты'}
+                        onChange={handleOnChange}
+                        onValidate={handleOnValidate}
+                    />
+                </div>
+            );
+        }
+        ```
+    </TabItem>
+
+    <TabItem value="password" label="Password" default>
+        Свойства доступные при валидации пароля:
+        ```tsx
+        type ValidationProps = {
+            /*
+            * Тип валидации
+            */
+            validationType: 'password';
+            /*
+            * Опции валидации
+            */
+            options?: PasswordValidationOptions;
+            /*
+            * Состояние сокрытия оригинального пароля
+            */
+            passwordHidden?: boolean;
+            /*
+            * Функция, вызываемая при валидации значения.
+            * Вызывается при событии onBlur и по нажатию Enter, когда фокус на поле ввода
+            */
+            onValidate?: (args: OnValidateArgs) => void;
+        }
+        ```
+        Свойство `options` имеет следующий вид:
+        ```tsx
+        type PasswordValidationOptions = {
+            /*
+            * Минимальная длина пароля
+            */
+            minLength?: {
+                value?: number;
+                errorMessage?: string;
+            };
+            /*
+            * Максимальная длина пароля
+            */
+            maxLength?: {
+                value?: number;
+                errorMessage?: string;
+            };
+            /*
+            * Должны ли быть буквы верхнего регистра в пароле
+            */
+            includeUppercase?: {
+                value?: boolean;
+                errorMessage?: string;
+            };
+            /*
+            * Должны ли быть буквы нижнего регистра в пароле
+            */
+            includeLowercase?: {
+                value?: boolean;
+                errorMessage?: string;
+            };
+            /*
+            * Должны ли быть цифры в пароле
+            */
+            includeDigits?: {
+                value?: boolean;
+                errorMessage?: string;
+            };
+            /*
+            * Должны ли быть специальные символы в пароле
+            */
+            includeSpecialSymbols?: {
+                value?: boolean;
+                errorMessage?: string;
+            };
+        };
+        ```
+
+        ```tsx live
+        import React, { useState } from 'react';
+        import { TextField, IconButton } from '@salutejs/{{ package }}';
+        import { IconEyeFill, IconEyeClosedFill } from '@salutejs/plasma-icons';
+
+        export function App() {
+            const options = {
+                minLength: {
+                    value: 5,
+                    errorMessage: 'Пароль слишком короткий',
+                },
+                maxLength: {
+                    value: 20,
+                    errorMessage: 'Пароль слишком длинный',
+                },
+                includeUppercase: {
+                    value: true,
+                    errorMessage: 'Пароль должен содержать хотя бы одну заглавную букву',
+                },
+                includeLowercase: {
+                    value: true,
+                    errorMessage: 'Пароль должен содержать хотя бы одну строчную букву',
+                },
+                includeDigits: {
+                    value: true,
+                    errorMessage: 'Пароль должен содержать хотя бы одну цифру',
+                },
+                includeSpecialSymbols: {
+                    value: true,
+                    errorMessage: 'Пароль должен содержать хотя бы один специальный символ',
+                },
+            };
+
+            const [error, setError] = useState('');
+            const [hidden, setHidden] = useState(false);
+
+            const handleOnChange = () => {
+                setError('');
+            };
+
+            const handleOnValidate = ({ errorMessage }: { errorMessage?: string }) => {
+                setError(errorMessage || '');
+            };
+
+            const toggleShowPassword = () => setHidden(!hidden);
+
+            const HideButton = () => (
+                <IconButton size="s" view="clear" onClick={toggleShowPassword}>
+                    {hidden ? <IconEyeClosedFill size="xs" color="inherit" /> : <IconEyeFill size="xs" color="inherit" />}
+                </IconButton>
+            )
+
+            return (
+                <div>
+                    <TextField
+                        label="Валидация пароля"
+                        placeholder="Заполните поле"
+                        validationType="password"
+                        options={options}
+                        view={error ? 'negative' : 'default'}
+                        leftHelper={error || 'Валидация пароля'}
+                        onChange={handleOnChange}
+                        onValidate={handleOnValidate}
+                        passwordHidden={hidden}
+                        contentLeft={<HideButton />}
+                    />
+                </div>
+            );
+        }
+        ```
+    </TabItem>
+</Tabs>
+

package/emotion/cjs/components/TextField/hooks/index.js

@@ -9,4 +9,11 @@ Object.defineProperty(exports, "useKeyNavigation", {
     return _useKeyNavigation.useKeyNavigation;
   }
 });
-var _useKeyNavigation = /*#__PURE__*/require("./useKeyNavigation");
+Object.defineProperty(exports, "useValidation", {
+  enumerable: true,
+  get: function get() {
+    return _useValidation.useValidation;
+  }
+});
+var _useKeyNavigation = /*#__PURE__*/require("./useKeyNavigation");
+var _useValidation = /*#__PURE__*/require("./useValidation");

package/emotion/cjs/components/TextField/hooks/useValidation.js

@@ -0,0 +1,276 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useValidation = void 0;
+var _react = /*#__PURE__*/require("react");
+var _utils = /*#__PURE__*/require("../../../utils");
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+var getUniqueKeys = function getUniqueKeys(lengthOptions) {
+  return lengthOptions.map(function (option) {
+    return option.replace(/min|max|Length/g, '');
+  });
+};
+var validateLenghtOptions = function validateLenghtOptions(options) {
+  var _options$minLength, _options$maxLength;
+  if (!options) {
+    return;
+  }
+  var minHash = Object.keys(options).filter(function (key) {
+    return key.startsWith('min');
+  });
+  var maxHash = Object.keys(options).filter(function (key) {
+    return key.startsWith('max');
+  });
+  var minMaxUniqueKeys = (minHash === null || minHash === void 0 ? void 0 : minHash.length) >= (maxHash === null || maxHash === void 0 ? void 0 : maxHash.length) ? getUniqueKeys(minHash) : getUniqueKeys(maxHash);
+  var globalMinValue = Number(options === null || options === void 0 || (_options$minLength = options.minLength) === null || _options$minLength === void 0 ? void 0 : _options$minLength.value);
+  var globalMaxValue = Number(options === null || options === void 0 || (_options$maxLength = options.maxLength) === null || _options$maxLength === void 0 ? void 0 : _options$maxLength.value);
+  if (globalMinValue <= 0) {
+    console.error('minLength must be more than 0');
+  }
+  if (globalMaxValue <= 0) {
+    console.error('maxLength must be more than 0');
+  }
+  if (globalMaxValue <= globalMinValue) {
+    console.error('maxLength must be more than minLength');
+  }
+  minMaxUniqueKeys.forEach(function (key) {
+    var _options$optionMinKey, _options$optionMaxKey;
+    var optionMinKey = "min".concat(key, "Length");
+    var optionMaxKey = "max".concat(key, "Length");
+    var minValue = Number(options === null || options === void 0 || (_options$optionMinKey = options[optionMinKey]) === null || _options$optionMinKey === void 0 ? void 0 : _options$optionMinKey.value);
+    var maxValue = Number(options === null || options === void 0 || (_options$optionMaxKey = options[optionMaxKey]) === null || _options$optionMaxKey === void 0 ? void 0 : _options$optionMaxKey.value);
+    if (!minValue || minValue <= 0) {
+      console.error("".concat(optionMinKey, " must be more than 0"));
+    }
+    if (!maxValue || maxValue <= 0) {
+      console.error("".concat(optionMaxKey, " must be more than 0"));
+    }
+    if (maxValue <= minValue) {
+      console.error("".concat(optionMaxKey, " must be more than ").concat(optionMinKey));
+    }
+  });
+};
+var validateWithLengthOptions = function validateWithLengthOptions(value, options, optionKey) {
+  var _options$optionMinKey2, _options$optionMaxKey2;
+  var optionMinKey = "min".concat(optionKey, "Length");
+  var optionMaxKey = "max".concat(optionKey, "Length");
+  var minValue = Number((_options$optionMinKey2 = options[optionMinKey]) === null || _options$optionMinKey2 === void 0 ? void 0 : _options$optionMinKey2.value);
+  var maxValue = Number((_options$optionMaxKey2 = options[optionMaxKey]) === null || _options$optionMaxKey2 === void 0 ? void 0 : _options$optionMaxKey2.value);
+  if (minValue && value.length < minValue) {
+    var _options$optionMinKey3;
+    return {
+      isValid: false,
+      errorMessage: ((_options$optionMinKey3 = options[optionMinKey]) === null || _options$optionMinKey3 === void 0 ? void 0 : _options$optionMinKey3.errorMessage) || "".concat(optionMinKey, " is too short")
+    };
+  }
+  if (maxValue && value.length > maxValue) {
+    var _options$optionMaxKey3;
+    return {
+      isValid: false,
+      errorMessage: ((_options$optionMaxKey3 = options[optionMaxKey]) === null || _options$optionMaxKey3 === void 0 ? void 0 : _options$optionMaxKey3.errorMessage) || "".concat(optionMaxKey, " is too long")
+    };
+  }
+  return {
+    isValid: true
+  };
+};
+var validateEmailDomainsLists = function validateEmailDomainsLists(blacklistDomains, whitelistDomains) {
+  if (!(blacklistDomains !== null && blacklistDomains !== void 0 && blacklistDomains.length) || !(whitelistDomains !== null && whitelistDomains !== void 0 && whitelistDomains.length)) {
+    return;
+  }
+  var uniqueDomains = new Set([].concat(_toConsumableArray(blacklistDomains), _toConsumableArray(whitelistDomains)));
+  if (uniqueDomains.size !== blacklistDomains.length + whitelistDomains.length) {
+    console.error('Blacklisted domains must not overlap whitelisted domains');
+  }
+};
+var validateWithDomainsLists = function validateWithDomainsLists(domainWithZone, options) {
+  var _options$whitelistDom, _options$blacklistDom, _options$blacklistDom2, _options$whitelistDom2;
+  if (!((_options$whitelistDom = options.whitelistDomains) !== null && _options$whitelistDom !== void 0 && (_options$whitelistDom = _options$whitelistDom.value) !== null && _options$whitelistDom !== void 0 && _options$whitelistDom.length) && !((_options$blacklistDom = options.blacklistDomains) !== null && _options$blacklistDom !== void 0 && (_options$blacklistDom = _options$blacklistDom.value) !== null && _options$blacklistDom !== void 0 && _options$blacklistDom.length)) {
+    return {
+      isValid: true
+    };
+  }
+  if (options !== null && options !== void 0 && (_options$blacklistDom2 = options.blacklistDomains) !== null && _options$blacklistDom2 !== void 0 && (_options$blacklistDom2 = _options$blacklistDom2.value) !== null && _options$blacklistDom2 !== void 0 && _options$blacklistDom2.includes(domainWithZone)) {
+    var _options$blacklistDom3;
+    return {
+      isValid: false,
+      errorMessage: ((_options$blacklistDom3 = options.blacklistDomains) === null || _options$blacklistDom3 === void 0 ? void 0 : _options$blacklistDom3.errorMessage) || 'Domain is blacklisted'
+    };
+  }
+  if (!(options !== null && options !== void 0 && (_options$whitelistDom2 = options.whitelistDomains) !== null && _options$whitelistDom2 !== void 0 && (_options$whitelistDom2 = _options$whitelistDom2.value) !== null && _options$whitelistDom2 !== void 0 && _options$whitelistDom2.includes(domainWithZone))) {
+    var _options$whitelistDom3;
+    return {
+      isValid: false,
+      errorMessage: ((_options$whitelistDom3 = options.whitelistDomains) === null || _options$whitelistDom3 === void 0 ? void 0 : _options$whitelistDom3.errorMessage) || 'Domain is not whitelisted'
+    };
+  }
+  return {
+    isValid: true
+  };
+};
+var validateEmail = function validateEmail(email, options) {
+  var _options$customEmailR, _options$minLength2, _options$maxLength2;
+  if (!email) {
+    return {
+      isValid: true
+    };
+  }
+  var emailRegex = (options === null || options === void 0 || (_options$customEmailR = options.customEmailRegex) === null || _options$customEmailR === void 0 ? void 0 : _options$customEmailR.value) || _utils.constants.emailPattern;
+  if (!emailRegex.test(email)) {
+    var _options$customEmailR2;
+    return {
+      isValid: false,
+      errorMessage: (options === null || options === void 0 || (_options$customEmailR2 = options.customEmailRegex) === null || _options$customEmailR2 === void 0 ? void 0 : _options$customEmailR2.errorMessage) || 'Invalid email'
+    };
+  }
+  if (!options) {
+    return {
+      isValid: true
+    };
+  }
+  if ((_options$minLength2 = options.minLength) !== null && _options$minLength2 !== void 0 && _options$minLength2.value && email.length < options.minLength.value) {
+    var _options$minLength3;
+    return {
+      isValid: false,
+      errorMessage: ((_options$minLength3 = options.minLength) === null || _options$minLength3 === void 0 ? void 0 : _options$minLength3.errorMessage) || 'Email is too short'
+    };
+  }
+  if ((_options$maxLength2 = options.maxLength) !== null && _options$maxLength2 !== void 0 && _options$maxLength2.value && email.length > options.maxLength.value) {
+    var _options$maxLength3;
+    return {
+      isValid: false,
+      errorMessage: ((_options$maxLength3 = options.maxLength) === null || _options$maxLength3 === void 0 ? void 0 : _options$maxLength3.errorMessage) || 'Email is too long'
+    };
+  }
+  var emailHost = email.split('@')[0];
+  var emailDomainWithZone = email.split('@')[1];
+  var emailZone = emailDomainWithZone.split('.').pop();
+  if (!(emailZone !== null && emailZone !== void 0 && emailZone.length)) {
+    var _options$customEmailR3;
+    return {
+      isValid: false,
+      errorMessage: ((_options$customEmailR3 = options.customEmailRegex) === null || _options$customEmailR3 === void 0 ? void 0 : _options$customEmailR3.errorMessage) || 'Invalid email'
+    };
+  }
+  var emailDomain = emailDomainWithZone.substring(0, emailDomainWithZone.length - (emailZone.length + 1));
+  var hostValidation = validateWithLengthOptions(emailHost, options, 'Host');
+  if (!hostValidation.isValid) {
+    return hostValidation;
+  }
+  var domainValidation = validateWithLengthOptions(emailDomain, options, 'Domain');
+  if (!domainValidation.isValid) {
+    return domainValidation;
+  }
+  var zoneValidation = validateWithLengthOptions(emailZone, options, 'Zone');
+  if (!zoneValidation.isValid) {
+    return zoneValidation;
+  }
+  var domainWithZoneValidation = validateWithDomainsLists(emailDomainWithZone, options);
+  if (!domainWithZoneValidation.isValid) {
+    return domainWithZoneValidation;
+  }
+  return {
+    isValid: true
+  };
+};
+var validatePassword = function validatePassword(password, options) {
+  var _options$minLength4, _options$maxLength4, _options$includeUpper, _options$includeLower, _options$includeDigit, _options$includeSpeci;
+  if (!password || !options) {
+    return {
+      isValid: true
+    };
+  }
+  if ((_options$minLength4 = options.minLength) !== null && _options$minLength4 !== void 0 && _options$minLength4.value && password.length < options.minLength.value) {
+    var _options$minLength5;
+    return {
+      isValid: false,
+      errorMessage: ((_options$minLength5 = options.minLength) === null || _options$minLength5 === void 0 ? void 0 : _options$minLength5.errorMessage) || 'Password is too short'
+    };
+  }
+  if ((_options$maxLength4 = options.maxLength) !== null && _options$maxLength4 !== void 0 && _options$maxLength4.value && password.length > options.maxLength.value) {
+    var _options$maxLength5;
+    return {
+      isValid: false,
+      errorMessage: ((_options$maxLength5 = options.maxLength) === null || _options$maxLength5 === void 0 ? void 0 : _options$maxLength5.errorMessage) || 'Password is too long'
+    };
+  }
+  var lowercasedPassword = password.toLowerCase();
+  var uppercasedPassword = password.toUpperCase();
+  if ((_options$includeUpper = options.includeUppercase) !== null && _options$includeUpper !== void 0 && _options$includeUpper.value && password === lowercasedPassword) {
+    var _options$includeUpper2;
+    return {
+      isValid: false,
+      errorMessage: ((_options$includeUpper2 = options.includeUppercase) === null || _options$includeUpper2 === void 0 ? void 0 : _options$includeUpper2.errorMessage) || 'Password must contain at least one uppercase letter'
+    };
+  }
+  if ((_options$includeLower = options.includeLowercase) !== null && _options$includeLower !== void 0 && _options$includeLower.value && password === uppercasedPassword) {
+    var _options$includeLower2;
+    return {
+      isValid: false,
+      errorMessage: ((_options$includeLower2 = options.includeLowercase) === null || _options$includeLower2 === void 0 ? void 0 : _options$includeLower2.errorMessage) || 'Password must contain at least one lowercase letter'
+    };
+  }
+  if ((_options$includeDigit = options.includeDigits) !== null && _options$includeDigit !== void 0 && _options$includeDigit.value && !/\d/.test(password)) {
+    var _options$includeDigit2;
+    return {
+      isValid: false,
+      errorMessage: ((_options$includeDigit2 = options.includeDigits) === null || _options$includeDigit2 === void 0 ? void 0 : _options$includeDigit2.errorMessage) || 'Password must contain digits'
+    };
+  }
+  if ((_options$includeSpeci = options.includeSpecialSymbols) !== null && _options$includeSpeci !== void 0 && _options$includeSpeci.value && !_utils.constants.specialCharacters.test(password)) {
+    var _options$includeSpeci2;
+    return {
+      isValid: false,
+      errorMessage: ((_options$includeSpeci2 = options.includeSpecialSymbols) === null || _options$includeSpeci2 === void 0 ? void 0 : _options$includeSpeci2.errorMessage) || 'Password must contain special characters'
+    };
+  }
+  return {
+    isValid: true
+  };
+};
+var validationVariants = {
+  email: validateEmail,
+  password: validatePassword
+};
+var useValidation = exports.useValidation = function useValidation(_ref) {
+  var validationType = _ref.validationType,
+    options = _ref.options,
+    onValidate = _ref.onValidate;
+  var handleValidationBlur = function handleValidationBlur(event) {
+    if (!validationType) {
+      return;
+    }
+    var validationResult = validationVariants[validationType](event.target.value, options);
+    onValidate === null || onValidate === void 0 || onValidate(validationResult);
+  };
+  var handleValidationKeyDown = function handleValidationKeyDown(event) {
+    if (!validationType) {
+      return;
+    }
+    if (event.keyCode === _utils.constants.keyCodes.Enter) {
+      event.preventDefault();
+      var _ref2 = event.target,
+        value = _ref2.value;
+      var validationResult = validationVariants[validationType](value, options);
+      onValidate === null || onValidate === void 0 || onValidate(validationResult);
+    }
+  };
+  (0, _react.useEffect)(function () {
+    validateLenghtOptions(options);
+    if (validationType === 'email') {
+      var _whitelistDomains, _blacklistDomains;
+      validateEmailDomainsLists(options === null || options === void 0 || (_whitelistDomains = options.whitelistDomains) === null || _whitelistDomains === void 0 ? void 0 : _whitelistDomains.value, (_blacklistDomains = options.blacklistDomains) === null || _blacklistDomains === void 0 ? void 0 : _blacklistDomains.value);
+    }
+  }, []);
+  return {
+    handleValidationBlur: handleValidationBlur,
+    handleValidationKeyDown: handleValidationKeyDown
+  };
+};