intelicoreact 1.5.32 → 1.5.34

package/dist/src/Constants/index.constants.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    DEFAULT_COLORS: function() {
+        return DEFAULT_COLORS;
+    },
+    DEFAULT_DATE_MASK_NO_VALUE_SYMBOL: function() {
+        return DEFAULT_DATE_MASK_NO_VALUE_SYMBOL;
+    },
+    KEYBOARD_KEY_CODES: function() {
+        return KEYBOARD_KEY_CODES;
+    },
+    KEYBOARD_SERVICE_KEYS: function() {
+        return KEYBOARD_SERVICE_KEYS;
+    },
+    MAX_NAME_LENGTH: function() {
+        return MAX_NAME_LENGTH;
+    },
+    MAX_PHONE_LENGTH: function() {
+        return MAX_PHONE_LENGTH;
+    },
+    OS: function() {
+        return OS;
+    }
+});
+const KEYBOARD_SERVICE_KEYS = [
+    "Escape",
+    "F1",
+    "F2",
+    "F3",
+    "F4",
+    "F5",
+    "F6",
+    "F7",
+    "F8",
+    "F9",
+    "F10",
+    "F11",
+    "F12",
+    "Tab",
+    "CapsLock",
+    "Shift",
+    "Control",
+    "Meta",
+    "Option",
+    "Alt",
+    "ContextMenu",
+    "ArrowLeft",
+    "ArrowRight",
+    "ArrowUp",
+    "ArrowDown",
+    "NumLock",
+    "Backspace",
+    "Delete",
+    "Enter",
+    "Return",
+    "Insert",
+    "Home",
+    "End",
+    "PageUp",
+    "PageDown",
+    "PrintScreen",
+    "ScrollLock",
+    "Pause"
+];
+const MAX_PHONE_LENGTH = 10;
+const MAX_NAME_LENGTH = 128;
+const DEFAULT_DATE_MASK_NO_VALUE_SYMBOL = "_";
+const DEFAULT_COLORS = [
+    "#D9C1FF",
+    "#FFBAF0",
+    "#FFB8CE",
+    "#FFC3A2",
+    "#FFDB7C",
+    "#F9F871",
+    "#C3FCF1",
+    "#F6F2CB",
+    "#E0F8D1",
+    "#B1DFFB",
+    "#8DECFE",
+    "#76F7ED",
+    "#8AFEC8"
+];
+const KEYBOARD_KEY_CODES = {
+    Backspace: 8,
+    Delete: 46,
+    ARROW_LEFT: 37,
+    ARROW_RIGHT: 39
+};
+const OS = {
+    iOS: "iOS",
+    Android: "Android",
+    WP: "Windows Phone",
+    Linux: "Linux",
+    Windows: "Windows",
+    MacOS: "MacOS",
+    Unknown: "unknown"
+};

package/dist/src/Functions/Portal.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _reactdom = /*#__PURE__*/ _interop_require_default(require("react-dom"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+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 Portal = ({ children, parentSelector })=>{
+    const [container] = (0, _react.useState)(()=>document.createElement("div"));
+    (0, _react.useEffect)(()=>{
+        let parent;
+        if (parentSelector) parent = document.querySelector(parentSelector);
+        else parent = document.body;
+        parent === null || parent === void 0 ? void 0 : parent.appendChild(container);
+        return ()=>{
+            parent === null || parent === void 0 ? void 0 : parent.removeChild(container);
+        };
+    }, []);
+    return /*#__PURE__*/ _reactdom.default.createPortal(children, container);
+};
+const _default = /*#__PURE__*/ _react.default.memo(Portal);

package/dist/src/Functions/animatingFunctions/getAnimatedHandler.js

@@ -0,0 +1 @@
+"use strict";

package/dist/src/Functions/customEventListener.js

@@ -0,0 +1,49 @@
+"use strict";
+(function() {
+    Element.prototype._addEventListener = Element.prototype.addEventListener;
+    Element.prototype.addEventListener = function(a, b, c) {
+        if (c == undefined) c = false;
+        this._addEventListener(a, b, c);
+        if (!this.eventListenerList) this.eventListenerList = {};
+        if (!this.eventListenerList[a]) this.eventListenerList[a] = [];
+        //this.removeEventListener(a,b,c); // TODO - handle duplicates..
+        this.eventListenerList[a].push({
+            listener: b,
+            useCapture: c
+        });
+    };
+    Element.prototype.getEventListeners = function(a) {
+        if (!this.eventListenerList) this.eventListenerList = {};
+        if (a == undefined) return this.eventListenerList;
+        return this.eventListenerList[a];
+    };
+    Element.prototype.clearEventListeners = function(a) {
+        if (!this.eventListenerList) this.eventListenerList = {};
+        if (a == undefined) {
+            for(const x in this.getEventListeners())this.clearEventListeners(x);
+            return;
+        }
+        const el = this.getEventListeners(a);
+        if (el == undefined) return;
+        for(let i = el.length - 1; i >= 0; --i){
+            const ev = el[i];
+            this.removeEventListener(a, ev.listener, ev.useCapture);
+        }
+    };
+    Element.prototype._removeEventListener = Element.prototype.removeEventListener;
+    Element.prototype.removeEventListener = function(a, b, c) {
+        if (c == undefined) c = false;
+        this._removeEventListener(a, b, c);
+        if (!this.eventListenerList) this.eventListenerList = {};
+        if (!this.eventListenerList[a]) this.eventListenerList[a] = [];
+        // Find the event in the list
+        for(let i = 0; i < this.eventListenerList[a].length; i++){
+            if (this.eventListenerList[a][i].listener == b, this.eventListenerList[a][i].useCapture == c) {
+                // Hmm..
+                this.eventListenerList[a].splice(i, 1);
+                break;
+            }
+        }
+        if (this.eventListenerList[a].length == 0) delete this.eventListenerList[a];
+    };
+})();

package/dist/src/Functions/dateTime.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    DATETIME_FORMATS: function() {
+        return DATETIME_FORMATS;
+    },
+    DATE_UNITS: function() {
+        return DATE_UNITS;
+    },
+    parseAndFormatDate: function() {
+        return parseAndFormatDate;
+    }
+});
+const _moment = /*#__PURE__*/ _interop_require_default(require("moment"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const DATETIME_FORMATS = Object.freeze({
+    // Основные форматы
+    DATE_FORMAT: "YYYY-MM-DD",
+    DATE_WITHOUT_SEPARATORS: "MMDDYYYY",
+    VALIDATION_DATE_FORMAT: "MM/DD/YYYY",
+    INPUT_DATE_FORMAT: "MM.DD.YYYY",
+    INPUT_TIME_FORMAT: "YYYY-MM-DD HH:mm:SS",
+    TIME_FORMAT_WSPACE: "YYYY-MM-DD HH:mm:SS",
+    TIME_FORMAT: "YYYY-MM-DDTHH:mm:SS",
+    DATE_FORMAT_WITH_SLASH: "MM/DD/YYYY",
+    // Дополнительные форматы
+    DATE_WITH_DASHES: "MM-DD-YYYY",
+    DATE_WITH_DOTS: "DD.MM.YYYY",
+    DATE_WITH_COMMA: "DD,MM,YYYY",
+    FULL_DATE_TIME: "YYYY-MM-DD HH:mm:ss",
+    ISO_DATE_TIME: "YYYY-MM-DDTHH:mm:ss.SSSZ",
+    LOCALIZED_DATE: "MMMM DD, YYYY",
+    SHORT_DATE: "MM/DD/YY",
+    SHORT_DATE_WITH_TIME: "MM/DD/YY HH:mm",
+    TIME_24H: "HH:mm",
+    TIME_12H: "hh:mm A",
+    TIME_12H_WITH_SECONDS: "hh:mm:ss A",
+    TIME_24H_WITH_SECONDS: "HH:mm:ss",
+    MONTH_DAY: "MM/DD",
+    YEAR_MONTH_DAY: "YYYY/MM/DD"
+});
+const formatMap = Object.freeze({
+    [DATETIME_FORMATS.DATE_FORMAT]: "YYYY-MM-DD",
+    [DATETIME_FORMATS.DATE_WITHOUT_SEPARATORS]: "MMDDYYYY",
+    [DATETIME_FORMATS.VALIDATION_DATE_FORMAT]: "MM/DD/YYYY",
+    [DATETIME_FORMATS.INPUT_DATE_FORMAT]: "MM.DD.YYYY",
+    [DATETIME_FORMATS.INPUT_TIME_FORMAT]: "YYYY-MM-DD HH:mm:SS",
+    [DATETIME_FORMATS.TIME_FORMAT_WSPACE]: "YYYY-MM-DD HH:mm:SS",
+    [DATETIME_FORMATS.TIME_FORMAT]: "YYYY-MM-DDTHH:mm:SS",
+    [DATETIME_FORMATS.DATE_FORMAT_WITH_SLASH]: "MM/DD/YYYY",
+    [DATETIME_FORMATS.DATE_WITH_DASHES]: "MM-DD-YYYY",
+    [DATETIME_FORMATS.DATE_WITH_DOTS]: "DD.MM.YYYY",
+    [DATETIME_FORMATS.DATE_WITH_COMMA]: "DD,MM,YYYY",
+    [DATETIME_FORMATS.FULL_DATE_TIME]: "YYYY-MM-DD HH:mm:ss",
+    [DATETIME_FORMATS.ISO_DATE_TIME]: "YYYY-MM-DDTHH:mm:ss.SSSZ",
+    [DATETIME_FORMATS.LOCALIZED_DATE]: "MMMM DD, YYYY",
+    [DATETIME_FORMATS.SHORT_DATE]: "MM/DD/YY",
+    [DATETIME_FORMATS.SHORT_DATE_WITH_TIME]: "MM/DD/YY HH:mm",
+    [DATETIME_FORMATS.TIME_24H]: "HH:mm",
+    [DATETIME_FORMATS.TIME_12H]: "hh:mm A",
+    [DATETIME_FORMATS.TIME_12H_WITH_SECONDS]: "hh:mm:ss A",
+    [DATETIME_FORMATS.TIME_24H_WITH_SECONDS]: "HH:mm:ss",
+    [DATETIME_FORMATS.MONTH_DAY]: "MM/DD",
+    [DATETIME_FORMATS.YEAR_MONTH_DAY]: "YYYY/MM/DD"
+});
+const DATE_UNITS = Object.freeze({
+    YEARS: Object.freeze({
+        YEARS: "years",
+        YEAR: "year",
+        Y: "y",
+        TEMPLATE: "YYYY"
+    }),
+    MONTHS: Object.freeze({
+        MONTHS: "months",
+        MONTH: "month",
+        MON: "M",
+        TEMPLATE: "MM"
+    }),
+    DAYS: Object.freeze({
+        DAYS: "days",
+        DAY: "day",
+        D: "d",
+        TEMPLATE: "DD"
+    }),
+    HOURS: Object.freeze({
+        HOURS: "hours",
+        HOUR: "hour",
+        H: "h",
+        TEMPLATE: "HH"
+    }),
+    WEEKS: Object.freeze({
+        WEEKS: "weeks",
+        WEEK: "week",
+        W: "w"
+    }),
+    QUARTERS: Object.freeze({
+        QUARTERS: "quarters",
+        QUARTER: "quarter",
+        Q: "Q"
+    }),
+    MINUTES: Object.freeze({
+        MINUTES: "minutes",
+        MINUTE: "minute",
+        MIN: "m"
+    }),
+    SECONDS: Object.freeze({
+        SECONDS: "seconds",
+        SECOND: "second",
+        S: "s"
+    }),
+    MILLISECONDS: Object.freeze({
+        MILLISECONDS: "milliseconds",
+        MILLISECOND: "millisecond",
+        MS: "ms"
+    })
+});
+function parseAndFormatDate(value, outputFormat = DATETIME_FORMATS.INPUT_DATE_FORMAT) {
+    if (!value || typeof value !== "string") return value;
+    for(let format in formatMap){
+        const parsedDate = (0, _moment.default)(value, formatMap[format], true);
+        if (parsedDate.isValid()) {
+            return parsedDate.format(outputFormat);
+        }
+    }
+    return value;
+}

package/dist/src/Functions/fieldValueFormatters.js

@@ -0,0 +1,299 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    filterFloat: function() {
+        return filterFloat;
+    },
+    filterNumeric: function() {
+        return filterNumeric;
+    },
+    formatAsPercentage: function() {
+        return formatAsPercentage;
+    },
+    formatNumberValueToMask: function() {
+        return formatNumberValueToMask;
+    },
+    formatOnlyNumbers: function() {
+        return formatOnlyNumbers;
+    },
+    formatToAddBitDepthPoints: function() {
+        return formatToAddBitDepthPoints;
+    },
+    formatToHex: function() {
+        return formatToHex;
+    },
+    formatToHideValuePartially: function() {
+        return formatToHideValuePartially;
+    },
+    formatToLimitLength: function() {
+        return formatToLimitLength;
+    },
+    formatToOnlyASCIICodeText: function() {
+        return formatToOnlyASCIICodeText;
+    },
+    formatToPriceWithCurrency: function() {
+        return formatToPriceWithCurrency;
+    },
+    formatToPriceWithUSD: function() {
+        return formatToPriceWithUSD;
+    },
+    formatToRemoveComa: function() {
+        return formatToRemoveComa;
+    },
+    formatToReplaceAllWhiteSpace: function() {
+        return formatToReplaceAllWhiteSpace;
+    },
+    getSafelyValue: function() {
+        return getSafelyValue;
+    },
+    intlNumbersFormatter: function() {
+        return intlNumbersFormatter;
+    }
+});
+const _utils = require("./utils");
+const 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)) || "" : "";
+};
+const intlNumbersFormatter = (inputValue, settings = {})=>{
+    const safelyInputValue = getSafelyValue(inputValue);
+    const previousValue = safelyInputValue.slice(0, -1);
+    const lastSym = safelyInputValue.slice(-1);
+    const 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;
+    switch(inputCurrencyDisplay){
+        case "name":
+            currencyDisplay = "name";
+            break;
+        case "code":
+            currencyDisplay = "code";
+            break;
+        case "narrowSymbol":
+            currencyDisplay = "narrowSymbol";
+            break;
+        default:
+            currencyDisplay = "symbol";
+    }
+    let numberStyle;
+    switch(withSymbol){
+        case "percent":
+            numberStyle = "percent";
+            break;
+        case "currency":
+            numberStyle = "currency";
+            break;
+        default:
+            numberStyle = "decimal";
+            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 = (()=>{
+        //? Безусловное минимальное количество. Всегда отрендерит дробную часть, в количестве символов сколько указано
+        if (typeof inputMinimumFractionDigits === "number") return inputMinimumFractionDigits;
+        //? Условное минимальное количество. Если есть дробная часть, то отрендерит дробных символов сколько указано
+        if (typeof conditionallyMinimumFractionDigits === "number") {
+            return afterDot && lastSym !== "." ? conditionallyMinimumFractionDigits : 0;
+        }
+        //? Дефолтное минимальное количество. Если есть дробная часть, то отрендерит дробных символов столько, сколько есть
+        //? Флаг isRenderAlways превращает дефолтный кейс в безусловное минимальное количество
+        return afterDot && lastSym !== "." ? safelyInputValue.slice(dotIndex).length - 1 : isRenderAlways ? quantity : 0;
+    })();
+    const priceSettings = {
+        useGrouping,
+        style: numberStyle,
+        currency: currencyType,
+        currencyDisplay,
+        //минимально не надо отображать центы, если их нет, иначе всегда будет .00
+        minimumFractionDigits,
+        //! Важно! Если придет велью с количеством дробных разрядов БОЛЬШИМ
+        //! чем указано в (inputMaximumFractionDigits ?? quantity) - округлит по правилам округления
+        //максимально отображать 2 цифры после запятой, если центы всё же есть
+        maximumFractionDigits: inputMaximumFractionDigits !== null && inputMaximumFractionDigits !== void 0 ? inputMaximumFractionDigits : quantity
+    };
+    let output;
+    try {
+        output = new Intl.NumberFormat(locale, priceSettings).format(value);
+    } catch (e) {
+        output = value;
+        // eslint-disable-next-line no-console
+        console.warn("Intl.NumberFormat error", e);
+    }
+    return lastSym === "." ? output + lastSym : output;
+};
+const formatOnlyNumbers = (value)=>getSafelyValue(value).replace(/\D/g, "");
+const formatToRemoveComa = (value)=>getSafelyValue(value).replace(/,/g, "");
+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
+        }
+    });
+const formatToPriceWithUSD = (value)=>{
+    if (isNaN(Number(value))) return value;
+    return intlNumbersFormatter(getSafelyValue(value), {
+        withSymbol: "currency",
+        currency: {
+            currencyType: "USD"
+        },
+        fractionDigits: {
+            quantity: 2,
+            conditionallyMinimumFractionDigits: 2
+        }
+    });
+};
+const formatToPriceWithCurrency = (value, currencyCode, symbolPosition = "before")=>{
+    if (isNaN(Number(value))) return value;
+    return intlNumbersFormatter(getSafelyValue(value), {
+        withSymbol: "currency",
+        currency: {
+            currencyType: currencyCode
+        },
+        fractionDigits: {
+            quantity: 2,
+            conditionallyMinimumFractionDigits: 2
+        }
+    });
+};
+const formatAsPercentage = (value, settings)=>{
+    const { isCommonPercentageSymbol = true, decimalPlaces = 2, beforeValueSymbol = "", afterValueSymbol = "", isGlueSameRangesTogether = false, // ? Тут удобный ф-л, поэтому иной раз удобно обработать обычный диапазан (НЕ проценты).
+    // ? Добавил возможность выпиливать значек процентов.
+    // todo(VL) - вообще правильно заренеймить (formatAsDiapason), а добавление процентов сделать как опцию,
+    // todo(VL) - но как обычно нет времени, нужно будет перечекать по всем проектам где тянется со старым неймингом
+    isUseAsSimpleDiapason = false } = (0, _utils.getIsOnlyAnObject)(settings) ? settings : {};
+    let safelyInputValue;
+    const checkValue = (value)=>getSafelyValue(value) || "0";
+    const transform = (valueAsSting)=>{
+        const processedValue = valueAsSting.replace(/,/g, ".");
+        if (Number.isNaN(Number(processedValue))) return processedValue;
+        return `${intlNumbersFormatter(getSafelyValue(Number(processedValue)), {
+            fractionDigits: {
+                quantity: decimalPlaces,
+                minimumFractionDigits: decimalPlaces
+            }
+        })}`;
+    };
+    if ((0, _utils.getIsOnlyAnObject)(value)) {
+        safelyInputValue = {
+            from: checkValue(value.from),
+            to: checkValue(value.to)
+        };
+    } else {
+        safelyInputValue = checkValue(value);
+        if (safelyInputValue.includes(" - ")) {
+            const valuesArr = safelyInputValue.split(" - ").map((partOfValue)=>partOfValue.trim());
+            safelyInputValue = {
+                from: checkValue(valuesArr[0]),
+                to: checkValue(valuesArr[1])
+            };
+        } else {
+            // Вариант когда велью передано строкой (НЕ объектом) и оно не содержит сепаратора " - "
+            //  - одиночные велью
+            //  - некорректный диапазон
+            return `${beforeValueSymbol}${transform(safelyInputValue)}${afterValueSymbol}${isUseAsSimpleDiapason ? '' : '%'}`;
+        }
+    }
+    if (safelyInputValue.from === safelyInputValue.to && !!isGlueSameRangesTogether) {
+        return `${beforeValueSymbol}${transform(safelyInputValue.from)}${afterValueSymbol}${isUseAsSimpleDiapason ? '' : '%'}`;
+    }
+    if (isCommonPercentageSymbol) return `${beforeValueSymbol}${transform(safelyInputValue.from)} - ${transform(safelyInputValue.to)}${afterValueSymbol}${isUseAsSimpleDiapason ? '' : '%'}`;
+    else return `${beforeValueSymbol}${transform(safelyInputValue.from)}${isUseAsSimpleDiapason ? '' : '%'} - ${transform(safelyInputValue.to)}${isUseAsSimpleDiapason ? '' : '%'}${afterValueSymbol}`;
+};
+const formatToOnlyASCIICodeText = (text)=>getSafelyValue(text).replace(/[^\x00-\x7F]+/g, "");
+const formatNumberValueToMask = (inputValue, settings)=>{
+    const safelyInputValue = getSafelyValue(inputValue);
+    // default valueSymbol === 'n', default mask === 'nnn-nnn-nnnn'
+    const { mask = "XXX-XXX-XXXX", valueSymbol = "X", isReturnAdvanced = false } = settings || {};
+    const processing = mask.split("").reduce((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)),
+        newValue: [],
+        cursorPosition: 0
+    });
+    return isReturnAdvanced ? {
+        value: processing.newValue.join(""),
+        cursorPosition: processing.cursorPosition
+    } : processing.newValue.join("");
+};
+const formatToLimitLength = (inputValue, limit)=>{
+    const 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;
+};
+const formatToHex = ({ inputValue, withSharp })=>{
+    const value = getSafelyValue(inputValue);
+    if (withSharp) return `#${value.replace(/[^a-f0-9]/gi, "")}`;
+    return `${value.replace(/[^#a-f0-9]/gi, "")}`;
+};
+function formatToReplaceAllWhiteSpace(str) {
+    const value = getSafelyValue(str);
+    return value.replace(/\s+/g, "");
+}
+const filterFloat = (inputValue, decimalPlaces)=>{
+    var _this;
+    const replaser = (input)=>('' + input).replace(/[^\.\d]/g, '');
+    const value = getSafelyValue(inputValue);
+    //? safelyDecimalPlaces ТОЧНО либо null, либо целое число
+    const safelyDecimalPlaces = (()=>{
+        if (decimalPlaces === null) return decimalPlaces;
+        const DEFAULT_VALUE = 2;
+        const isNumber = typeof decimalPlaces === 'number' || typeof decimalPlaces === 'string' && !Number.isNaN(+decimalPlaces);
+        //? защита от дробного значения decimalPlaces
+        return isNumber ? Number((+decimalPlaces).toFixed()) : DEFAULT_VALUE;
+    })();
+    // Обработка кейса если первым символом нажата точка
+    if (value.length === 1 && (value[0] === '.' || value[0] === ',')) return '0.';
+    // Приводим запятые к корректному разделителю, но не выпиливаем
+    let output = (_this = '' + value) === null || _this === void 0 ? void 0 : _this.replace(/,/g, '.');
+    // Выпилить первый ноль, если это не дробь
+    if (value.length > 1 && value[0] === '0' && value[1] !== '.' && value[0] !== ',') output = value.slice(1);
+    const previousValue = '' + output.slice(0, -1);
+    const lastSym = '' + output.slice(-1);
+    // Обработка кейса второй точки в дроби
+    if (lastSym === '.' && previousValue.includes('.')) output = previousValue;
+    // if (localStorage.getItem('useDeb')) debugger;
+    // Логика ограничения по decimalPlaces
+    if (typeof safelyDecimalPlaces === 'number') {
+        if (!safelyDecimalPlaces && lastSym === '.') return replaser(previousValue);
+        if (previousValue.includes('.') && previousValue.indexOf('.') + 1 + safelyDecimalPlaces === (previousValue === null || previousValue === void 0 ? void 0 : previousValue.length)) {
+            return replaser(previousValue);
+        }
+    }
+    return replaser(output);
+};
+const 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;
+    return executor(getSafelyValue(value), decimalPlaces);
+};
+const formatToHideValuePartially = (value, settings)=>{
+    const { showSymbolsCount = 4, isVisibleFromFront = false, isCutOutWhiteSpaces = true } = settings || {};
+    const safelyValue = getSafelyValue(value);
+    const newValue = isCutOutWhiteSpaces ? safelyValue.replace(/\s/g, "") : safelyValue;
+    if (newValue.length <= showSymbolsCount) return newValue;
+    const hide = (val)=>val.split("").map(()=>"*").join("");
+    const visiblePart = isVisibleFromFront ? newValue.slice(0, showSymbolsCount) : newValue.slice(-1 * showSymbolsCount);
+    const hiddenPart = isVisibleFromFront ? newValue.slice(showSymbolsCount) : newValue.slice(0, -1 * showSymbolsCount);
+    return isVisibleFromFront ? `${visiblePart}${hide(hiddenPart)}` : `${hide(hiddenPart)}${visiblePart}`;
+};