intelicoreact 1.5.41 → 1.6.0

package/dist/Functions/guards/typeGuards.js

@@ -0,0 +1,374 @@
+/**
+ * @name isArray
+ * @description Функция isArray принимает значение и возвращает true, если переданное значение является массивом.
+ * @param value - значение для проверки
+ * @example
+ * const result = isArray([]);
+ * console.log(result); // true
+ * @example
+ * const result = isArray({});
+ * console.log(result); // false
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const isArray = (value)=>Array.isArray(value);
+/**
+ * @name isObject
+ * @description Функция isObject принимает значение и возвращает true, если переданное значение является объектом.
+ * @param value - значение для проверки
+ * @example
+ * const result = isObject({});
+ * console.log(result); // true
+ * @example
+ * const result = isObject([]);
+ * console.log(result); // false
+ */ function isObject(value) {
+    return typeof value === 'object' && value !== null && !isArray(value);
+}
+/**
+ * @name isNumber
+ * @description Функция isNumber принимает значение и возвращает true, если переданное значение является числом.
+ * @param value - значение для проверки
+ * @example
+ * const result = isNumber(1);
+ * console.log(result); // true
+ */ const isNumber = (value)=>typeof value === 'number';
+/**
+ * @name isString
+ * @description Функция isString принимает значение и возвращает true, если переданное значение является строкой.
+ * @param value - значение для проверки
+ * @example
+ * const result = isString('string');
+ * console.log(result); // true
+ */ const isString = (value)=>typeof value === 'string';
+/**
+ * @name isBoolean
+ * @description Функция isBoolean принимает значение и возвращает true, если переданное значение является булевым.
+ * @param value - значение для проверки
+ * @example
+ * const result = isBoolean(true);
+ * console.log(result); // true
+ */ const isBoolean = (value)=>typeof value === 'boolean';
+/**
+ * @name isFunction
+ * @description Функция isFunction принимает значение и возвращает true, если переданное значение является функцией.
+ * @param value - значение для проверки
+ * @example
+ * const result = isFunction(() => {});
+ * console.log(result); // true
+ * @example
+ * const result = isFunction('string');
+ * console.log(result); // false
+ * @example
+ * const result = isFunction(1);
+ * console.log(result); // false
+ */ const isFunction = (value)=>typeof value === 'function';
+/**
+ * @name isInstanceOf
+ * @description Функция isInstanceOf принимает значение и возвращает true, если переданное значение является экземпляром класса.
+ * @param value - значение для проверки
+ * @param classType - класс для проверки
+ * @example
+ * class TestClass {}
+ * const result = isInstanceOf(new TestClass(), TestClass);
+ * console.log(result); // true
+ */ const isInstanceOf = (value, classType)=>value instanceof classType;
+/**
+ * @name isEnumValue
+ * @description Функция isEnumValue принимает значение и возвращает true, если переданное значение является значением enum.
+ * @param enumObject - enum для проверки
+ * @param value - значение для проверки
+ * @example
+ * enum Colors {
+ * Red = 'red',
+ * Green = 'green',
+ * Blue = 'blue',
+ * }
+ * const result = isEnumValue(Colors, 'red');
+ * console.log(result); // true
+ * @returns true - если значение является значением enum, false - если значение не является значением enum
+ */ function isEnumValue(enumObject, value) {
+    return Object.values(enumObject).includes(value);
+}
+/**
+ * @name isNullOrUndefined
+ * @description Функция isNullOrUndefined принимает значение и возвращает true, если переданное значение является null или undefined.
+ * @param value - значение для проверки
+ * @example
+ * isNullOrUndefined(null) // true
+ * isNullOrUndefined(undefined) // true
+ * isNullOrUndefined(1) // false
+ */ function isNullOrUndefined(value) {
+    return value === null || value === undefined;
+}
+/**
+ * @name isTruthy
+ * @description Функция isTruthy принимает значение и возвращает true, если переданное значение является true.
+ * @param value - значение для проверки
+ * @example
+ * isTruthy(true) // true
+ * isTruthy(1) // true
+ * isTruthy(Infinity) // true
+ * isTruthy(-Infinity) // true
+ * isTruthy(Symbol()) // true
+ * isTruthy('some string') // true
+ * isTruthy({}) // true
+ * isTruthy([]) // true
+ * isTruthy(Symbol('some description')) // true
+ * isTruthy(() => {}) // true
+ * isTruthy(function() {}) // true
+ * isTruthy(class {}) // true
+ * isTruthy(0) // false
+ * isTruthy('') // false
+ * isTruthy(null) // false
+ * isTruthy(undefined) // false
+ * isTruthy(NaN) // false
+ * isTruthy(false) // false
+ */ const isTruthy = (value)=>!!value;
+/**
+ * @name isEmptyObject
+ * @description Функция isEmptyObject принимает значение и возвращает true, если переданное значение является пустым объектом.
+ * @param value - значение для проверки
+ * @example
+ * isEmptyObject({}) // true
+ * isEmptyObject({ a: 1 }) // false
+ */ const isEmptyObject = (value)=>isObject(value) && Object.keys(value).length === 0;
+/**
+ * @name isTypedArray
+ * @description Функция isTypedArray принимает значение и возвращает true, если переданное значение является массивом определенного типа.
+ * @param value - значение для проверки
+ * @param type - тип для проверки
+ * @example
+ * isTypedArray([1, 2, 3], Number) // true
+ * isTypedArray([1, 2, 3], String) // false
+ */ function isTypedArray(value, type) {
+    return isArray(value) && value.every((item)=>item instanceof type);
+}
+/**
+ * @name isArrayWithLength
+ * @description Функция isArrayWithLength принимает значение и возвращает true, если переданное значение является массивом определенной длины.
+ * @param value - значение для проверки
+ * @param length - длина массива
+ * @example
+ * isArrayWithLength([1, 2, 3], 3) // true
+ * isArrayWithLength([1, 2, 3], 2) // false
+ */ function isArrayWithLength(value, length) {
+    return isArray(value) && value.length === length;
+}
+/**
+ * @name isEmptyArray
+ * @description Функция isEmptyArray принимает значение и возвращает true, если переданное значение является пустым массивом.
+ * @param value - значение для проверки
+ * @example
+ * isEmptyArray([]) // true
+ * isEmptyArray([1]) // false
+ */ const isEmptyArray = (value)=>Array.isArray(value) && value.length === 0;
+/**
+ * @name isTypeOrNull
+ * @description Функция isTypeOrNull принимает значение и возвращает true, если переданное значение является экземпляром класса или null.
+ * @param value - значение для проверки
+ * @param type - класс для проверки
+ * @example
+ * isTypeOrNull(null, SomeClass) // true
+ * isTypeOrNull(new SomeClass(), SomeClass) // true
+ */ function isTypeOrNull(value, type) {
+    return value === null || value instanceof type;
+}
+const nonNullable = (value)=>value !== null && value !== undefined;
+/**
+ * @name isDate
+ * @description Функция isDate принимает значение и возвращает true, если переданное значение является объектом Date.
+ * @param value - значение для проверки
+ * @example
+ * isDate(new Date()) // true
+ * isDate('2023-01-01') // false
+ */ const isDate = (value)=>value instanceof Date;
+/**
+ * @name isPromise
+ * @description Функция isPromise принимает значение и возвращает true, если переданное значение является Promise.
+ * @param value - значение для проверки
+ * @example
+ * isPromise(Promise.resolve()) // true
+ * isPromise({ then: () => {} }) // false
+ */ const isPromise = (value)=>value instanceof Promise;
+/**
+ * @name isRegExp
+ * @description Функция isRegExp принимает значение и возвращает true, если переданное значение является регулярным выражением.
+ * @param value - значение для проверки
+ * @example
+ * isRegExp(/test/) // true
+ * isRegExp('test') // false
+ */ const isRegExp = (value)=>value instanceof RegExp;
+/**
+ * @name isPrimitive
+ * @description Функция isPrimitive принимает значение и возвращает true, если переданное значение является примитивом.
+ * @param value - значение для проверки
+ * @example
+ * isPrimitive(42) // true
+ * isPrimitive('test') // true
+ * isPrimitive(true) // true
+ * isPrimitive(null) // true
+ * isPrimitive(undefined) // true
+ * isPrimitive({}) // false
+ */ function isPrimitive(value) {
+    return value === null || value === undefined || typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean';
+}
+/**
+ * @name isError
+ * @description Функция isError принимает значение и возвращает true, если переданное значение является объектом ошибки.
+ * @param value - значение для проверки
+ * @example
+ * isError(new Error()) // true
+ * isError({ message: 'error' }) // false
+ */ const isError = (value)=>value instanceof Error;
+/**
+ * @name isSymbol
+ * @description Функция isSymbol принимает значение и возвращает true, если переданное значение является символом.
+ * @param value - значение для проверки
+ * @example
+ * isSymbol(Symbol()) // true
+ * isSymbol('symbol') // false
+ */ const isSymbol = (value)=>typeof value === 'symbol';
+/**
+ * @name isMap
+ * @description Функция isMap принимает значение и возвращает true, если переданное значение является объектом Map.
+ * @param value - значение для проверки
+ * @example
+ * isMap(new Map()) // true
+ * isMap({}) // false
+ */ const isMap = (value)=>value instanceof Map;
+/**
+ * @name isSet
+ * @description Функция isSet принимает значение и возвращает true, если переданное значение является объектом Set.
+ * @param value - значение для проверки
+ * @example
+ * isSet(new Set()) // true
+ * isSet([]) // false
+ */ const isSet = (value)=>value instanceof Set;
+/**
+ * @name isReactElement
+ * @description Функция isReactElement принимает значение и возвращает true, если переданное значение является React элементом.
+ * @param value - значение для проверки
+ * @example
+ * isReactElement(<div>Test</div>) // true
+ * isReactElement('div') // false
+ */ function isReactElement(value) {
+    return isObject(value) && 'type' in value && 'props' in value && '$$typeof' in value;
+}
+/**
+ * @name isReactComponent
+ * @description Функция isReactComponent принимает значение и возвращает true, если переданное значение является React компонентом.
+ * @param value - значение для проверки
+ * @example
+ * const MyComponent = () => <div>Test</div>;
+ * isReactComponent(MyComponent) // true
+ * isReactComponent('div') // false
+ */ function isReactComponent(value) {
+    return isFunction(value) || isObject(value) && 'render' in value;
+}
+/**
+ * @name isComponentType
+ * @description Функция isComponentType принимает значение и тип компонента, возвращает true, если переданное значение является компонентом указанного типа.
+ * @param value - значение для проверки
+ * @param componentType - тип компонента для проверки
+ * @example
+ * const MyComponent = () => <div>Test</div>;
+ * isComponentType(<MyComponent />, MyComponent) // true
+ */ function isComponentType(value, componentType) {
+    return isReactElement(value) && value.type === componentType;
+}
+/**
+ * @name isReactEvent
+ * @description Функция isReactEvent принимает значение и возвращает true, если переданное значение является React событием.
+ * @param value - значение для проверки
+ * @example
+ * const handleClick = (e) => {
+ *   if (isReactEvent(e)) {
+ *     e.preventDefault();
+ *   }
+ * };
+ */ function isReactEvent(value) {
+    return isObject(value) && 'nativeEvent' in value && 'currentTarget' in value && 'target' in value;
+}
+/**
+ * @name isRef
+ * @description Функция isRef принимает значение и возвращает true, если переданное значение является React рефом.
+ * @param value - значение для проверки
+ * @example
+ * const ref = useRef(null);
+ * isRef(ref) // true
+ */ function isRef(value) {
+    return isObject(value) && 'current' in value;
+}
+/**
+ * @name isContext
+ * @description Функция isContext принимает значение и возвращает true, если переданное значение является React контекстом.
+ * @param value - значение для проверки
+ * @example
+ * const MyContext = React.createContext(null);
+ * isContext(MyContext) // true
+ */ function isContext(value) {
+    return isObject(value) && 'Provider' in value && 'Consumer' in value;
+}
+/**
+ * @name isType
+ * @description Функция isType принимает значение и тип, возвращает true, если переданное значение соответствует указанному типу.
+ * @param value - значение для проверки
+ * @param type - тип для проверки
+ * @example
+ * interface User {
+ *   name: string;
+ *   age: number;
+ * }
+ *
+ * const user = { name: "John", age: 30 };
+ * const isUser = isType<User>(user,);
+ * console.log(isUser); // true
+ *
+ * const notUser = "John";
+ * console.log(isType<User>(notUser)); // false
+ */ function isType(value) {
+    const type = typeof value;
+    return type === 'string' || type === 'number' || type === 'boolean' || type === 'object' || type === 'function' || type === 'undefined' || type === 'symbol' || type === 'bigint';
+}
+const typesGuards = {
+    isArray,
+    isObject,
+    isNumber,
+    isString,
+    isBoolean,
+    isFunction,
+    isInstanceOf,
+    isEnumValue,
+    isNullOrUndefined,
+    isTruthy,
+    isEmptyObject,
+    isEmptyArray,
+    isTypedArray,
+    isArrayWithLength,
+    isTypeOrNull,
+    nonNullable,
+    isDate,
+    isPromise,
+    isRegExp,
+    isPrimitive,
+    isError,
+    isSymbol,
+    isMap,
+    isSet,
+    isReactElement,
+    isReactComponent,
+    isComponentType,
+    isReactEvent,
+    isRef,
+    isContext,
+    isType
+};
+const _default = typesGuards;

package/dist/Functions/hooks/useFormFieldsChangesManager.js

@@ -1,105 +1,134 @@
 "use strict";
-
 Object.defineProperty(exports, "__esModule", {
-  value: true
+    value: true
 });
-exports.default = void 0;
-var _react = _interopRequireWildcard(require("react"));
-function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
-function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_wildcard(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 _interop_require_wildcard(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 = {
+        __proto__: null
+    };
+    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 = {
-  timeoutId: null
+    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,
-  //? но по какой-то причине после изменении рефки не заходило в useEffect.
-  //? Однако если срабатывал useEffect по какой-нибудь другой переменной,
-  //? то и в useEffect по formChangesRef.current тоже заходило.
-  //? Поэтому тут нужен этот стейт,
-  //? хотя по итогу в конечной реализации с ним даже неплохо получилось (но вообще очень странная ерунда...)
-  const [isFormMustBeChanget, setIsFormMustBeChanget] = (0, _react.useState)(false);
-
-  //? Ф-я является ф-ей - постановщиком изменений формы в очередь.
-  //? Ф-я получается самовызывающимся геттером.
-  //? Cуть ф-ии:
-  //?   Для того чтоб не спамить изменениями, если их назначается много в рамках одной итерации,
-  //?   ипользую прием с переназначением setTimeout
-
-  //?   Чтобы преждевременно не спровацировать сработку useEffect
-  //?   по стейту фиксирующему "отмашку" к началу изменений (isFormMustBeChanget)
-  //?   откладываю переназначение этого стейта до приостановки непрерывных вызовов assignChangesToField,
-  //?   но при этом при каждом ее вызове продолжаю добавлять изменения в массив
-  const assignChangesToField = (() => {
-    return (data, key) => {
-      clearTimeout(timeouts.timeoutId);
-      formChanges.push({
-        key,
-        data
-      });
-      setIsFormMustBeChanget(false);
-      timeouts.timeoutId = setTimeout(() => setIsFormMustBeChanget(true), 1);
-      return formChanges;
+const useFormFieldsChangesManager = ({ form, setForm, callback, validateField, settings })=>{
+    const { isNotSetForm, isUseValidation = false } = settings || {};
+    //? Пробовал ставить просто useEffect по formChangesRef.current,
+    //? но по какой-то причине после изменении рефки не заходило в useEffect.
+    //? Однако если срабатывал useEffect по какой-нибудь другой переменной,
+    //? то и в useEffect по formChangesRef.current тоже заходило.
+    //? Поэтому тут нужен этот стейт,
+    //? хотя по итогу в конечной реализации с ним даже неплохо получилось (но вообще очень странная ерунда...)
+    const [isFormMustBeChanget, setIsFormMustBeChanget] = (0, _react.useState)(false);
+    //? Ф-я является ф-ей - постановщиком изменений формы в очередь.
+    //? Ф-я получается самовызывающимся геттером.
+    //? Cуть ф-ии:
+    //?   Для того чтоб не спамить изменениями, если их назначается много в рамках одной итерации,
+    //?   ипользую прием с переназначением setTimeout
+    //?   Чтобы преждевременно не спровацировать сработку useEffect
+    //?   по стейту фиксирующему "отмашку" к началу изменений (isFormMustBeChanget)
+    //?   откладываю переназначение этого стейта до приостановки непрерывных вызовов assignChangesToField,
+    //?   но при этом при каждом ее вызове продолжаю добавлять изменения в массив
+    const assignChangesToField = (()=>{
+        return (data, key)=>{
+            clearTimeout(timeouts.timeoutId);
+            formChanges.push({
+                key,
+                data
+            });
+            setIsFormMustBeChanget(false);
+            timeouts.timeoutId = setTimeout(()=>setIsFormMustBeChanget(true), 1);
+            return formChanges;
+        };
+    })();
+    //? Ф-я применяет "накопленные" изменения
+    const changeForm = async ()=>{
+        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_field, _validateField;
+            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(modifiedFormFromOutside !== null && modifiedFormFromOutside !== void 0 ? modifiedFormFromOutside : validatedForm);
+        formChanges.length = 0;
+        setIsFormMustBeChanget(false);
+    };
+    (0, _react.useEffect)(()=>{
+        if (isFormMustBeChanget) changeForm();
+    }, [
+        isFormMustBeChanget
+    ]);
+    return {
+        assignChangesToField,
+        isFormMustBeChanget,
+        setIsFormMustBeChanget,
+        changesArray: [
+            ...formChanges
+        ]
     };
-  })();
-
-  //? Ф-я применяет "накопленные" изменения
-  const changeForm = async () => {
-    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 => ({
-      ...field,
-      error: validateField({
-        ...field
-      }, newForm)?.field?.error || errorsFromChanges[field.key] || ""
-    })) : newForm;
-    if (callback && typeof callback === "function") modifiedFormFromOutside = await callback(validatedForm);
-    if (!isNotSetForm) await setForm(modifiedFormFromOutside ?? validatedForm);
-    formChanges.length = 0;
-    setIsFormMustBeChanget(false);
-  };
-  (0, _react.useEffect)(() => {
-    if (isFormMustBeChanget) changeForm();
-  }, [isFormMustBeChanget]);
-  return {
-    assignChangesToField,
-    isFormMustBeChanget,
-    setIsFormMustBeChanget,
-    changesArray: [...formChanges]
-  };
 };
-var _default = exports.default = useFormFieldsChangesManager;
+const _default = useFormFieldsChangesManager;

package/dist/Functions/locale/createTranslator.js

@@ -1,31 +1,33 @@
 "use strict";
-
 Object.defineProperty(exports, "__esModule", {
-  value: true
+    value: true
 });
-exports.default = createTranslator;
-var _fieldValueFormatters = require("./../fieldValueFormatters");
-const DEFAULT_CODE = "en";
-function createTranslator(_ref) {
-  let {
-    ...langCatalogs
-  } = _ref;
-  const loc = {
-    ...langCatalogs
-  };
-  let code = window.localStorage.getItem("lng");
-  if (!code) code = window.navigator ? window.navigator.language.split("-")[0] : DEFAULT_CODE;
-  if (!loc[code]) code = DEFAULT_CODE;
-  return function (text, values) {
-    const safelyValues = values ?? {};
-    const safelyText = (0, _fieldValueFormatters.getSafelyValue)(text);
-    let translatedText = loc[code] && loc[code][safelyText] ? loc[code][safelyText] : safelyText;
-    if (Object?.keys(safelyValues)?.length) {
-      for (const key in values) {
-        const regex = new RegExp(`%${key}%`, "g");
-        translatedText = translatedText?.replace(regex, values[key]);
-      }
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return createTranslator;
     }
-    return translatedText;
-  };
-}
+});
+const _fieldValueFormatters = require("./../fieldValueFormatters");
+const DEFAULT_CODE = "en";
+function createTranslator({ ...langCatalogs }) {
+    const loc = {
+        ...langCatalogs
+    };
+    let code = window.localStorage.getItem("lng");
+    if (!code) code = window.navigator ? window.navigator.language.split("-")[0] : DEFAULT_CODE;
+    if (!loc[code]) code = DEFAULT_CODE;
+    return function(text, values) {
+        var _Object_keys, _Object;
+        const safelyValues = values !== null && values !== void 0 ? values : {};
+        const safelyText = (0, _fieldValueFormatters.getSafelyValue)(text);
+        let translatedText = loc[code] && loc[code][safelyText] ? loc[code][safelyText] : safelyText;
+        if ((_Object = Object) === null || _Object === void 0 ? void 0 : (_Object_keys = _Object.keys(safelyValues)) === null || _Object_keys === void 0 ? void 0 : _Object_keys.length) {
+            for(const key in values){
+                const regex = new RegExp(`%${key}%`, "g");
+                translatedText = translatedText === null || translatedText === void 0 ? void 0 : translatedText.replace(regex, values[key]);
+            }
+        }
+        return translatedText;
+    };
+}