intelicoreact 1.4.81 → 1.4.83

package/dist/Functions/fieldValueFormatters.js

@@ -18,7 +18,7 @@ var _utils = require("./utils");
 // ****************************
 // Base utils
 // ****************************
-const getSafelyValue = value => {
+var getSafelyValue = function getSafelyValue(value) {
   var _value$toString;
 
   return value !== undefined && value !== null ? (value === null || value === void 0 ? void 0 : (_value$toString = value.toString) === null || _value$toString === void 0 ? void 0 : _value$toString.call(value)) || "" : "";
@@ -27,31 +27,26 @@ const getSafelyValue = value => {
 
 exports.getSafelyValue = getSafelyValue;
 
-const intlNumbersFormatter = function (inputValue) {
-  let settings = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  const safelyInputValue = getSafelyValue(inputValue);
-  const previousValue = safelyInputValue.slice(0, -1);
-  const lastSym = safelyInputValue.slice(-1);
-  const value = lastSym === "." ? previousValue : safelyInputValue;
+var intlNumbersFormatter = function intlNumbersFormatter(inputValue) {
+  var settings = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var safelyInputValue = getSafelyValue(inputValue);
+  var previousValue = safelyInputValue.slice(0, -1);
+  var lastSym = safelyInputValue.slice(-1);
+  var value = lastSym === "." ? previousValue : safelyInputValue;
   if (Number.isNaN(Number(value)) || !getSafelyValue(value)) return "";
-  const {
-    // локаль, даже региональная, влияет на отображение знаков и формата.
-    locale = "en-US",
-    // percent || currency(default case) || decimal(просто число) влияет на ТИП обработки.
-    withSymbol,
-    //группировка запятыми поразрядно.
-    useGrouping = true,
-    //!!работает только при withSymbol: 'currency' !! влияет на то, как именно будет выглядет формат валюты.
-    currency = {},
-    //сколько знаков после точки, и всегда ли они будут.
-    // !!если поставить  isAlwaysRender: true, но не дать центов, то будет 100.00
-    fractionDigits = {}
-  } = settings;
-  const {
-    currencyType = "USD",
-    currencyDisplay: inputCurrencyDisplay
-  } = currency;
-  let currencyDisplay;
+  var _settings$locale = settings.locale,
+      locale = _settings$locale === void 0 ? "en-US" : _settings$locale,
+      withSymbol = settings.withSymbol,
+      _settings$useGrouping = settings.useGrouping,
+      useGrouping = _settings$useGrouping === void 0 ? true : _settings$useGrouping,
+      _settings$currency = settings.currency,
+      currency = _settings$currency === void 0 ? {} : _settings$currency,
+      _settings$fractionDig = settings.fractionDigits,
+      fractionDigits = _settings$fractionDig === void 0 ? {} : _settings$fractionDig;
+  var _currency$currencyTyp = currency.currencyType,
+      currencyType = _currency$currencyTyp === void 0 ? "USD" : _currency$currencyTyp,
+      inputCurrencyDisplay = currency.currencyDisplay;
+  var currencyDisplay;
 
   switch (inputCurrencyDisplay) {
     case "name":
@@ -70,7 +65,7 @@ const intlNumbersFormatter = function (inputValue) {
       currencyDisplay = "symbol";
   }
 
-  let numberStyle;
+  var numberStyle;
 
   switch (withSymbol) {
     case "percent":
@@ -86,17 +81,16 @@ const intlNumbersFormatter = function (inputValue) {
       break;
   }
 
-  const {
-    quantity,
-    isRenderAlways = false,
-    minimumFractionDigits: inputMinimumFractionDigits,
-    maximumFractionDigits: inputMaximumFractionDigits,
-    conditionallyMinimumFractionDigits
-  } = fractionDigits;
-  const dotIndex = safelyInputValue === null || safelyInputValue === void 0 ? void 0 : safelyInputValue.indexOf(".");
-  const afterDot = dotIndex !== -1 ? safelyInputValue.slice(dotIndex + 1) : "";
-
-  const minimumFractionDigits = (() => {
+  var quantity = fractionDigits.quantity,
+      _fractionDigits$isRen = fractionDigits.isRenderAlways,
+      isRenderAlways = _fractionDigits$isRen === void 0 ? false : _fractionDigits$isRen,
+      inputMinimumFractionDigits = fractionDigits.minimumFractionDigits,
+      inputMaximumFractionDigits = fractionDigits.maximumFractionDigits,
+      conditionallyMinimumFractionDigits = fractionDigits.conditionallyMinimumFractionDigits;
+  var dotIndex = safelyInputValue === null || safelyInputValue === void 0 ? void 0 : safelyInputValue.indexOf(".");
+  var afterDot = dotIndex !== -1 ? safelyInputValue.slice(dotIndex + 1) : "";
+
+  var minimumFractionDigits = function () {
     //? Безусловное минимальное количество. Всегда отрендерит дробную часть, в количестве символов сколько указано
     if (typeof inputMinimumFractionDigits === "number") return inputMinimumFractionDigits; //? Условное минимальное количество. Если есть дробная часть, то отрендерит дробных символов сколько указано
 
@@ -107,25 +101,25 @@ const intlNumbersFormatter = function (inputValue) {
 
 
     return afterDot && lastSym !== "." ? safelyInputValue.slice(dotIndex).length - 1 : isRenderAlways ? quantity : 0;
-  })();
+  }();
 
-  const priceSettings = {
-    useGrouping,
+  var priceSettings = {
+    useGrouping: useGrouping,
     //группировка разрядов
     style: numberStyle,
     //тип форматирования (валюта или число). decimal - без знака валюты
     currency: currencyType,
     //валюта
-    currencyDisplay,
+    currencyDisplay: currencyDisplay,
     //валюта в виде символа
     //минимально не надо отображать центы, если их нет, иначе всегда будет .00
-    minimumFractionDigits,
+    minimumFractionDigits: minimumFractionDigits,
     //! Важно! Если придет велью с количеством дробных разрядов БОЛЬШИМ
     //! чем указано в (inputMaximumFractionDigits ?? quantity) - округлит по правилам округления
     //максимально отображать 2 цифры после запятой, если центы всё же есть
     maximumFractionDigits: inputMaximumFractionDigits !== null && inputMaximumFractionDigits !== void 0 ? inputMaximumFractionDigits : quantity
   };
-  let output;
+  var output;
 
   try {
     output = new Intl.NumberFormat(locale, priceSettings).format(value);
@@ -143,25 +137,31 @@ const intlNumbersFormatter = function (inputValue) {
 
 exports.intlNumbersFormatter = intlNumbersFormatter;
 
-const formatOnlyNumbers = value => getSafelyValue(value).replace(/\D/g, "");
+var formatOnlyNumbers = function formatOnlyNumbers(value) {
+  return getSafelyValue(value).replace(/\D/g, "");
+};
 
 exports.formatOnlyNumbers = formatOnlyNumbers;
 
-const formatToRemoveComa = value => getSafelyValue(value).replace(/,/g, "");
+var formatToRemoveComa = function formatToRemoveComa(value) {
+  return getSafelyValue(value).replace(/,/g, "");
+};
 
 exports.formatToRemoveComa = formatToRemoveComa;
 
-const formatToAddBitDepthPoints = (value, settings) => intlNumbersFormatter(getSafelyValue(value), {
-  fractionDigits: {
-    quantity: (settings === null || settings === void 0 ? void 0 : settings.type) === "int" ? 0 : settings === null || settings === void 0 ? void 0 : settings.decimalPlaces
-  }
-}); //! Важно! Если придет велью с количеством дробных разрядов БОЛЬШИМ
+var formatToAddBitDepthPoints = function formatToAddBitDepthPoints(value, settings) {
+  return intlNumbersFormatter(getSafelyValue(value), {
+    fractionDigits: {
+      quantity: (settings === null || settings === void 0 ? void 0 : settings.type) === "int" ? 0 : settings === null || settings === void 0 ? void 0 : settings.decimalPlaces
+    }
+  });
+}; //! Важно! Если придет велью с количеством дробных разрядов БОЛЬШИМ
 //! чем указано в quantity - округлит по правилам округления
 
 
 exports.formatToAddBitDepthPoints = formatToAddBitDepthPoints;
 
-const formatToPriceWithUSD = value => {
+var formatToPriceWithUSD = function formatToPriceWithUSD(value) {
   if (isNaN(Number(value))) return value;
   return intlNumbersFormatter(getSafelyValue(value), {
     withSymbol: "currency",
@@ -180,8 +180,8 @@ const formatToPriceWithUSD = value => {
 
 exports.formatToPriceWithUSD = formatToPriceWithUSD;
 
-const formatToPriceWithCurrency = function (value, currencyCode) {
-  let symbolPosition = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : "before";
+var formatToPriceWithCurrency = function formatToPriceWithCurrency(value, currencyCode) {
+  var symbolPosition = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : "before";
   if (isNaN(Number(value))) return value;
   return intlNumbersFormatter(getSafelyValue(value), {
     withSymbol: "currency",
@@ -210,19 +210,25 @@ const formatToPriceWithCurrency = function (value, currencyCode) {
 
 exports.formatToPriceWithCurrency = formatToPriceWithCurrency;
 
-const formatAsPercentage = (value, settings) => {
-  const {
-    isCommonPercentageSymbol = true,
-    decimalPlaces = 2,
-    beforeValueSymbol = "",
-    afterValueSymbol = ""
-  } = (0, _utils.getIsOnlyAnObject)(settings) ? settings : {};
-  let safelyInputValue;
-
-  const checkValue = value => getSafelyValue(value) || "0";
+var formatAsPercentage = function formatAsPercentage(value, settings) {
+  var _ref = (0, _utils.getIsOnlyAnObject)(settings) ? settings : {},
+      _ref$isCommonPercenta = _ref.isCommonPercentageSymbol,
+      isCommonPercentageSymbol = _ref$isCommonPercenta === void 0 ? true : _ref$isCommonPercenta,
+      _ref$decimalPlaces = _ref.decimalPlaces,
+      decimalPlaces = _ref$decimalPlaces === void 0 ? 2 : _ref$decimalPlaces,
+      _ref$beforeValueSymbo = _ref.beforeValueSymbol,
+      beforeValueSymbol = _ref$beforeValueSymbo === void 0 ? "" : _ref$beforeValueSymbo,
+      _ref$afterValueSymbol = _ref.afterValueSymbol,
+      afterValueSymbol = _ref$afterValueSymbol === void 0 ? "" : _ref$afterValueSymbol;
+
+  var safelyInputValue;
+
+  var checkValue = function checkValue(value) {
+    return getSafelyValue(value) || "0";
+  };
 
-  const transform = valueAsSting => {
-    const processedValue = valueAsSting.replace(/,/g, ".");
+  var transform = function transform(valueAsSting) {
+    var processedValue = valueAsSting.replace(/,/g, ".");
     if (Number.isNaN(Number(processedValue))) return processedValue;
     return "".concat(intlNumbersFormatter(getSafelyValue(Number(processedValue)), {
       fractionDigits: {
@@ -241,7 +247,9 @@ const formatAsPercentage = (value, settings) => {
     safelyInputValue = checkValue(value);
 
     if (safelyInputValue.includes(" - ")) {
-      const valuesArr = safelyInputValue.split(" - ").map(partOfValue => partOfValue.trim());
+      var valuesArr = safelyInputValue.split(" - ").map(function (partOfValue) {
+        return partOfValue.trim();
+      });
       safelyInputValue = {
         from: checkValue(valuesArr[0]),
         to: checkValue(valuesArr[1])
@@ -257,25 +265,32 @@ const formatAsPercentage = (value, settings) => {
 
 exports.formatAsPercentage = formatAsPercentage;
 
-const formatToOnlyASCIICodeText = text => getSafelyValue(text).replace(/[^\x00-\x7F]+/g, ""); // eslint-disable-next-line default-param-last
+var formatToOnlyASCIICodeText = function formatToOnlyASCIICodeText(text) {
+  return getSafelyValue(text).replace(/[^\x00-\x7F]+/g, "");
+}; // eslint-disable-next-line default-param-last
 
 
 exports.formatToOnlyASCIICodeText = formatToOnlyASCIICodeText;
 
-const formatNumberValueToMask = (inputValue, settings) => {
-  const safelyInputValue = getSafelyValue(inputValue); // default valueSymbol === 'n', default mask === 'nnn-nnn-nnnn'
+var formatNumberValueToMask = function formatNumberValueToMask(inputValue, settings) {
+  var safelyInputValue = getSafelyValue(inputValue); // default valueSymbol === 'n', default mask === 'nnn-nnn-nnnn'
+
+  var _ref2 = settings || {},
+      _ref2$mask = _ref2.mask,
+      mask = _ref2$mask === void 0 ? "XXX-XXX-XXXX" : _ref2$mask,
+      _ref2$valueSymbol = _ref2.valueSymbol,
+      valueSymbol = _ref2$valueSymbol === void 0 ? "X" : _ref2$valueSymbol,
+      _ref2$isReturnAdvance = _ref2.isReturnAdvanced,
+      isReturnAdvanced = _ref2$isReturnAdvance === void 0 ? false : _ref2$isReturnAdvance;
 
-  const {
-    mask = "XXX-XXX-XXXX",
-    valueSymbol = "X",
-    isReturnAdvanced = false
-  } = settings || {};
-  const processing = mask.split("").reduce((acc, item) => {
+  var processing = mask.split("").reduce(function (acc, item) {
     if (acc.value.length) ++acc.cursorPosition;
     acc.newValue.push(item === valueSymbol && acc.value.length ? acc.value.shift() : item);
     return acc;
   }, {
-    value: safelyInputValue.split("").filter(sym => /[0-9]/g.test(sym)),
+    value: safelyInputValue.split("").filter(function (sym) {
+      return /[0-9]/g.test(sym);
+    }),
     newValue: [],
     cursorPosition: 0
   });
@@ -287,19 +302,17 @@ const formatNumberValueToMask = (inputValue, settings) => {
 
 exports.formatNumberValueToMask = formatNumberValueToMask;
 
-const formatToLimitLength = (inputValue, limit) => {
-  const value = getSafelyValue(inputValue);
+var formatToLimitLength = function formatToLimitLength(inputValue, limit) {
+  var value = getSafelyValue(inputValue);
   return limit && typeof limit === "number" && !Number.isNaN(limit) && (value === null || value === void 0 ? void 0 : value.length) > limit ? value.substr(0, limit) : value;
 };
 
 exports.formatToLimitLength = formatToLimitLength;
 
-const formatToHex = _ref => {
-  let {
-    inputValue,
-    withSharp
-  } = _ref;
-  const value = getSafelyValue(inputValue);
+var formatToHex = function formatToHex(_ref3) {
+  var inputValue = _ref3.inputValue,
+      withSharp = _ref3.withSharp;
+  var value = getSafelyValue(inputValue);
   if (withSharp) return "#".concat(value.replace(/[^a-f0-9]/gi, ""));
   return "".concat(value.replace(/[^#a-f0-9]/gi, ""));
 };
@@ -307,7 +320,7 @@ const formatToHex = _ref => {
 exports.formatToHex = formatToHex;
 
 function formatToReplaceAllWhiteSpace(str) {
-  const value = getSafelyValue(str);
+  var value = getSafelyValue(str);
   return value.replace(/\s+/g, "");
 } // ****************************
 // transform
@@ -338,22 +351,22 @@ function formatToReplaceAllWhiteSpace(str) {
 // };
 
 
-const filterFloat = function (inputValue) {
+var filterFloat = function filterFloat(inputValue) {
   var _output, _output2, _output3, _output4;
 
-  let decimalPlaces = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
-  const value = getSafelyValue(inputValue);
+  var decimalPlaces = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+  var value = getSafelyValue(inputValue);
 
-  const replacer = input => {
+  var replacer = function replacer(input) {
     var _String;
 
     return (_String = String(input)) === null || _String === void 0 ? void 0 : _String.replace(/[^\.\d,]/g, "");
   };
 
   if (value.length === 1 && (value[0] === "." || value[0] === ",")) return "0.";
-  let output = value;
-  const previousValue = String((_output = output) === null || _output === void 0 ? void 0 : _output.slice(0, -1));
-  const lastSym = String((_output2 = output) === null || _output2 === void 0 ? void 0 : _output2.slice(-1));
+  var output = value;
+  var previousValue = String((_output = output) === null || _output === void 0 ? void 0 : _output.slice(0, -1));
+  var lastSym = String((_output2 = output) === null || _output2 === void 0 ? void 0 : _output2.slice(-1));
 
   if (decimalPlaces && typeof decimalPlaces === "number" && previousValue !== null && previousValue !== void 0 && previousValue.includes(".") && (previousValue === null || previousValue === void 0 ? void 0 : previousValue.indexOf(".")) + 1 + decimalPlaces === (previousValue === null || previousValue === void 0 ? void 0 : previousValue.length)) {
     return replacer(previousValue);
@@ -370,34 +383,43 @@ const filterFloat = function (inputValue) {
 
 exports.filterFloat = filterFloat;
 
-const filterNumeric = (value, settings) => {
+var filterNumeric = function filterNumeric(value, settings) {
   var _getSafelyValue;
 
   value = (_getSafelyValue = getSafelyValue(value)) === null || _getSafelyValue === void 0 ? void 0 : _getSafelyValue.replace(/,/g, "");
-  const {
-    type = "float",
-    decimalPlaces
-  } = settings || {};
-  const executor = type === "float" ? filterFloat : formatOnlyNumbers;
+
+  var _ref4 = settings || {},
+      _ref4$type = _ref4.type,
+      type = _ref4$type === void 0 ? "float" : _ref4$type,
+      decimalPlaces = _ref4.decimalPlaces;
+
+  var executor = type === "float" ? filterFloat : formatOnlyNumbers;
   return executor(getSafelyValue(value), decimalPlaces);
 };
 
 exports.filterNumeric = filterNumeric;
 
-const formatToHideValuePartially = (value, settings) => {
-  const {
-    showSymbolsCount = 4,
-    isVisibleFromFront = false,
-    isCutOutWhiteSpaces = true
-  } = settings || {};
-  const safelyValue = getSafelyValue(value);
-  const newValue = isCutOutWhiteSpaces ? safelyValue.replace(/\s/g, "") : safelyValue;
+var formatToHideValuePartially = function formatToHideValuePartially(value, settings) {
+  var _ref5 = settings || {},
+      _ref5$showSymbolsCoun = _ref5.showSymbolsCount,
+      showSymbolsCount = _ref5$showSymbolsCoun === void 0 ? 4 : _ref5$showSymbolsCoun,
+      _ref5$isVisibleFromFr = _ref5.isVisibleFromFront,
+      isVisibleFromFront = _ref5$isVisibleFromFr === void 0 ? false : _ref5$isVisibleFromFr,
+      _ref5$isCutOutWhiteSp = _ref5.isCutOutWhiteSpaces,
+      isCutOutWhiteSpaces = _ref5$isCutOutWhiteSp === void 0 ? true : _ref5$isCutOutWhiteSp;
+
+  var safelyValue = getSafelyValue(value);
+  var newValue = isCutOutWhiteSpaces ? safelyValue.replace(/\s/g, "") : safelyValue;
   if (newValue.length <= showSymbolsCount) return newValue;
 
-  const hide = val => val.split("").map(() => "*").join("");
+  var hide = function hide(val) {
+    return val.split("").map(function () {
+      return "*";
+    }).join("");
+  };
 
-  const visiblePart = isVisibleFromFront ? newValue.slice(0, showSymbolsCount) : newValue.slice(-1 * showSymbolsCount);
-  const hiddenPart = isVisibleFromFront ? newValue.slice(showSymbolsCount) : newValue.slice(0, -1 * showSymbolsCount);
+  var visiblePart = isVisibleFromFront ? newValue.slice(0, showSymbolsCount) : newValue.slice(-1 * showSymbolsCount);
+  var hiddenPart = isVisibleFromFront ? newValue.slice(showSymbolsCount) : newValue.slice(0, -1 * showSymbolsCount);
   return isVisibleFromFront ? "".concat(visiblePart).concat(hide(hiddenPart)) : "".concat(hide(hiddenPart)).concat(visiblePart);
 };
 

package/dist/Functions/hooks/useFormFieldsChangesManager.js

@@ -1,40 +1,59 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
 
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
 var _react = _interopRequireWildcard(require("react"));
 
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 
-const timeouts = {
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+var timeouts = {
   timeoutId: null
 };
-const formChanges = []; // ? validateField - должен возвращать структуру { field, isValid }
-
-const useFormFieldsChangesManager = _ref => {
-  let {
-    form,
-    setForm,
-    callback,
-    validateField,
-    settings
-  } = _ref;
-  const {
-    isNotSetForm,
-    isUseValidation = false
-  } = settings || {}; //? Пробовал ставить просто useEffect по formChangesRef.current,
+var formChanges = []; // ? validateField - должен возвращать структуру { field, isValid }
+
+var useFormFieldsChangesManager = function useFormFieldsChangesManager(_ref) {
+  var form = _ref.form,
+      setForm = _ref.setForm,
+      callback = _ref.callback,
+      validateField = _ref.validateField,
+      settings = _ref.settings;
+
+  var _ref2 = settings || {},
+      isNotSetForm = _ref2.isNotSetForm,
+      _ref2$isUseValidation = _ref2.isUseValidation,
+      isUseValidation = _ref2$isUseValidation === void 0 ? false : _ref2$isUseValidation; //? Пробовал ставить просто useEffect по formChangesRef.current,
   //? но по какой-то причине после изменении рефки не заходило в useEffect.
   //? Однако если срабатывал useEffect по какой-нибудь другой переменной,
   //? то и в useEffect по formChangesRef.current тоже заходило.
   //? Поэтому тут нужен этот стейт,
   //? хотя по итогу в конечной реализации с ним даже неплохо получилось (но вообще очень странная ерунда...)
 
-  const [isFormMustBeChanget, setIsFormMustBeChanget] = (0, _react.useState)(false); //? Ф-я является ф-ей - постановщиком изменений формы в очередь.
+
+  var _useState = (0, _react.useState)(false),
+      _useState2 = (0, _slicedToArray2.default)(_useState, 2),
+      isFormMustBeChanget = _useState2[0],
+      setIsFormMustBeChanget = _useState2[1]; //? Ф-я является ф-ей - постановщиком изменений формы в очередь.
   //? Ф-я получается самовызывающимся геттером.
   //? Cуть ф-ии:
   //?   Для того чтоб не спамить изменениями, если их назначается много в рамках одной итерации,
@@ -44,67 +63,107 @@ const useFormFieldsChangesManager = _ref => {
   //?   откладываю переназначение этого стейта до приостановки непрерывных вызовов assignChangesToField,
   //?   но при этом при каждом ее вызове продолжаю добавлять изменения в массив
 
-  const assignChangesToField = (() => {
-    return (data, key) => {
+
+  var assignChangesToField = function () {
+    return function (data, key) {
       clearTimeout(timeouts.timeoutId);
       formChanges.push({
-        key,
-        data
+        key: key,
+        data: data
       });
       setIsFormMustBeChanget(false);
-      timeouts.timeoutId = setTimeout(() => setIsFormMustBeChanget(true), 1);
+      timeouts.timeoutId = setTimeout(function () {
+        return setIsFormMustBeChanget(true);
+      }, 1);
       return formChanges;
     };
-  })(); //? Ф-я применяет "накопленные" изменения
-
-
-  const changeForm = async () => {
-    var _modifiedFormFromOuts;
-
-    let modifiedFormFromOutside;
-    const errorsFromChanges = {};
-    const newForm = formChanges.reduce((acc, change) => {
-      const {
-        data,
-        key
-      } = change;
-      const {
-        error
-      } = data || {};
-      const field = acc.find(field => field.key === key);
-
-      if (field) {
-        acc = acc.map(field => field.key === key ? { ...field,
-          ...data
-        } : field);
-        if (error || error !== undefined) errorsFromChanges[key] = error;
-      }
-
-      return acc;
-    }, form); // ToDo - порефакторить, не прогонять валидацию всех полей, а только измененных
-
-    const validatedForm = isUseValidation && typeof validateField === "function" ? newForm.map(field => {
-      var _validateField, _validateField$field;
-
-      return { ...field,
-        error: ((_validateField = validateField({ ...field
-        }, newForm)) === null || _validateField === void 0 ? void 0 : (_validateField$field = _validateField.field) === null || _validateField$field === void 0 ? void 0 : _validateField$field.error) || errorsFromChanges[field.key] || ""
-      };
-    }) : newForm;
-    if (callback && typeof callback === "function") modifiedFormFromOutside = await callback(validatedForm);
-    if (!isNotSetForm) await setForm((_modifiedFormFromOuts = modifiedFormFromOutside) !== null && _modifiedFormFromOuts !== void 0 ? _modifiedFormFromOuts : validatedForm);
-    formChanges.length = 0;
-    setIsFormMustBeChanget(false);
-  };
+  }(); //? Ф-я применяет "накопленные" изменения
+
+
+  var changeForm = /*#__PURE__*/function () {
+    var _ref3 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee() {
+      var _modifiedFormFromOuts;
+
+      var modifiedFormFromOutside, errorsFromChanges, newForm, validatedForm;
+      return _regenerator.default.wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              errorsFromChanges = {};
+              newForm = formChanges.reduce(function (acc, change) {
+                var data = change.data,
+                    key = change.key;
+
+                var _ref4 = data || {},
+                    error = _ref4.error;
+
+                var field = acc.find(function (field) {
+                  return field.key === key;
+                });
+
+                if (field) {
+                  acc = acc.map(function (field) {
+                    return field.key === key ? _objectSpread(_objectSpread({}, field), data) : field;
+                  });
+                  if (error || error !== undefined) errorsFromChanges[key] = error;
+                }
+
+                return acc;
+              }, form); // ToDo - порефакторить, не прогонять валидацию всех полей, а только измененных
+
+              validatedForm = isUseValidation && typeof validateField === "function" ? newForm.map(function (field) {
+                var _validateField, _validateField$field;
+
+                return _objectSpread(_objectSpread({}, field), {}, {
+                  error: ((_validateField = validateField(_objectSpread({}, field), newForm)) === null || _validateField === void 0 ? void 0 : (_validateField$field = _validateField.field) === null || _validateField$field === void 0 ? void 0 : _validateField$field.error) || errorsFromChanges[field.key] || ""
+                });
+              }) : newForm;
+
+              if (!(callback && typeof callback === "function")) {
+                _context.next = 7;
+                break;
+              }
+
+              _context.next = 6;
+              return callback(validatedForm);
+
+            case 6:
+              modifiedFormFromOutside = _context.sent;
+
+            case 7:
+              if (isNotSetForm) {
+                _context.next = 10;
+                break;
+              }
+
+              _context.next = 10;
+              return setForm((_modifiedFormFromOuts = modifiedFormFromOutside) !== null && _modifiedFormFromOuts !== void 0 ? _modifiedFormFromOuts : validatedForm);
+
+            case 10:
+              formChanges.length = 0;
+              setIsFormMustBeChanget(false);
+
+            case 12:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee);
+    }));
+
+    return function changeForm() {
+      return _ref3.apply(this, arguments);
+    };
+  }();
 
-  (0, _react.useEffect)(() => {
+  (0, _react.useEffect)(function () {
     if (isFormMustBeChanget) changeForm();
   }, [isFormMustBeChanget]);
   return {
-    assignChangesToField,
-    isFormMustBeChanget,
-    setIsFormMustBeChanget,
-    changesArray: [...formChanges]
+    assignChangesToField: assignChangesToField,
+    isFormMustBeChanget: isFormMustBeChanget,
+    setIsFormMustBeChanget: setIsFormMustBeChanget,
+    changesArray: [].concat(formChanges)
   };
 };