infinity-forge 3.2.7 → 3.3.0

package/dist/ui/components/carousel/carousel-lib/core/update/updateSlides.js

@@ -0,0 +1,306 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var utils_1 = require("../../shared/utils.js");
+function updateSlides() {
+    var swiper = this;
+    function getDirectionPropertyValue(node, label) {
+        return parseFloat(node.getPropertyValue(swiper.getDirectionLabel(label)) || 0);
+    }
+    var params = swiper.params;
+    var wrapperEl = swiper.wrapperEl, slidesEl = swiper.slidesEl, swiperSize = swiper.size, rtl = swiper.rtlTranslate, wrongRTL = swiper.wrongRTL;
+    var isVirtual = swiper.virtual && params.virtual.enabled;
+    var previousSlidesLength = isVirtual ? swiper.virtual.slides.length : swiper.slides.length;
+    var slides = (0, utils_1.elementChildren)(slidesEl, ".".concat(swiper.params.slideClass, ", swiper-slide"));
+    var slidesLength = isVirtual ? swiper.virtual.slides.length : slides.length;
+    var snapGrid = [];
+    var slidesGrid = [];
+    var slidesSizesGrid = [];
+    var offsetBefore = params.slidesOffsetBefore;
+    if (typeof offsetBefore === 'function') {
+        offsetBefore = params.slidesOffsetBefore.call(swiper);
+    }
+    var offsetAfter = params.slidesOffsetAfter;
+    if (typeof offsetAfter === 'function') {
+        offsetAfter = params.slidesOffsetAfter.call(swiper);
+    }
+    var previousSnapGridLength = swiper.snapGrid.length;
+    var previousSlidesGridLength = swiper.slidesGrid.length;
+    var spaceBetween = params.spaceBetween;
+    var slidePosition = -offsetBefore;
+    var prevSlideSize = 0;
+    var index = 0;
+    if (typeof swiperSize === 'undefined') {
+        return;
+    }
+    if (typeof spaceBetween === 'string' && spaceBetween.indexOf('%') >= 0) {
+        spaceBetween = (parseFloat(spaceBetween.replace('%', '')) / 100) * swiperSize;
+    }
+    else if (typeof spaceBetween === 'string') {
+        spaceBetween = parseFloat(spaceBetween);
+    }
+    swiper.virtualSize = -spaceBetween;
+    // reset margins
+    slides.forEach(function (slideEl) {
+        if (rtl) {
+            slideEl.style.marginLeft = '';
+        }
+        else {
+            slideEl.style.marginRight = '';
+        }
+        slideEl.style.marginBottom = '';
+        slideEl.style.marginTop = '';
+    });
+    // reset cssMode offsets
+    if (params.centeredSlides && params.cssMode) {
+        (0, utils_1.setCSSProperty)(wrapperEl, '--swiper-centered-offset-before', '');
+        (0, utils_1.setCSSProperty)(wrapperEl, '--swiper-centered-offset-after', '');
+    }
+    var gridEnabled = params.grid && params.grid.rows > 1 && swiper.grid;
+    if (gridEnabled) {
+        swiper.grid.initSlides(slides);
+    }
+    else if (swiper.grid) {
+        swiper.grid.unsetSlides();
+    }
+    // Calc slides
+    var slideSize;
+    var shouldResetSlideSize = params.slidesPerView === 'auto' &&
+        params.breakpoints &&
+        Object.keys(params.breakpoints).filter(function (key) {
+            return typeof params.breakpoints[key].slidesPerView !== 'undefined';
+        }).length > 0;
+    for (var i = 0; i < slidesLength; i += 1) {
+        slideSize = 0;
+        var slide = void 0;
+        if (slides[i])
+            slide = slides[i];
+        if (gridEnabled) {
+            swiper.grid.updateSlide(i, slide, slides);
+        }
+        if (slides[i] && (0, utils_1.elementStyle)(slide, 'display') === 'none')
+            continue; // eslint-disable-line
+        if (params.slidesPerView === 'auto') {
+            if (shouldResetSlideSize) {
+                slides[i].style[swiper.getDirectionLabel('width')] = "";
+            }
+            var slideStyles = getComputedStyle(slide);
+            var currentTransform = slide.style.transform;
+            var currentWebKitTransform = slide.style.webkitTransform;
+            if (currentTransform) {
+                slide.style.transform = 'none';
+            }
+            if (currentWebKitTransform) {
+                slide.style.webkitTransform = 'none';
+            }
+            if (params.roundLengths) {
+                slideSize = swiper.isHorizontal()
+                    ? (0, utils_1.elementOuterSize)(slide, 'width', true)
+                    : (0, utils_1.elementOuterSize)(slide, 'height', true);
+            }
+            else {
+                // eslint-disable-next-line
+                var width = getDirectionPropertyValue(slideStyles, 'width');
+                var paddingLeft = getDirectionPropertyValue(slideStyles, 'padding-left');
+                var paddingRight = getDirectionPropertyValue(slideStyles, 'padding-right');
+                var marginLeft = getDirectionPropertyValue(slideStyles, 'margin-left');
+                var marginRight = getDirectionPropertyValue(slideStyles, 'margin-right');
+                var boxSizing = slideStyles.getPropertyValue('box-sizing');
+                if (boxSizing && boxSizing === 'border-box') {
+                    slideSize = width + marginLeft + marginRight;
+                }
+                else {
+                    var clientWidth = slide.clientWidth, offsetWidth = slide.offsetWidth;
+                    slideSize =
+                        width +
+                            paddingLeft +
+                            paddingRight +
+                            marginLeft +
+                            marginRight +
+                            (offsetWidth - clientWidth);
+                }
+            }
+            if (currentTransform) {
+                slide.style.transform = currentTransform;
+            }
+            if (currentWebKitTransform) {
+                slide.style.webkitTransform = currentWebKitTransform;
+            }
+            if (params.roundLengths)
+                slideSize = Math.floor(slideSize);
+        }
+        else {
+            slideSize = (swiperSize - (params.slidesPerView - 1) * spaceBetween) / params.slidesPerView;
+            if (params.roundLengths)
+                slideSize = Math.floor(slideSize);
+            if (slides[i]) {
+                slides[i].style[swiper.getDirectionLabel('width')] = "".concat(slideSize, "px");
+            }
+        }
+        if (slides[i]) {
+            slides[i].swiperSlideSize = slideSize;
+        }
+        slidesSizesGrid.push(slideSize);
+        if (params.centeredSlides) {
+            slidePosition = slidePosition + slideSize / 2 + prevSlideSize / 2 + spaceBetween;
+            if (prevSlideSize === 0 && i !== 0)
+                slidePosition = slidePosition - swiperSize / 2 - spaceBetween;
+            if (i === 0)
+                slidePosition = slidePosition - swiperSize / 2 - spaceBetween;
+            if (Math.abs(slidePosition) < 1 / 1000)
+                slidePosition = 0;
+            if (params.roundLengths)
+                slidePosition = Math.floor(slidePosition);
+            if (index % params.slidesPerGroup === 0)
+                snapGrid.push(slidePosition);
+            slidesGrid.push(slidePosition);
+        }
+        else {
+            if (params.roundLengths)
+                slidePosition = Math.floor(slidePosition);
+            if ((index - Math.min(swiper.params.slidesPerGroupSkip, index)) %
+                swiper.params.slidesPerGroup ===
+                0)
+                snapGrid.push(slidePosition);
+            slidesGrid.push(slidePosition);
+            slidePosition = slidePosition + slideSize + spaceBetween;
+        }
+        swiper.virtualSize += slideSize + spaceBetween;
+        prevSlideSize = slideSize;
+        index += 1;
+    }
+    swiper.virtualSize = Math.max(swiper.virtualSize, swiperSize) + offsetAfter;
+    if (rtl && wrongRTL && (params.effect === 'slide' || params.effect === 'coverflow')) {
+        wrapperEl.style.width = "".concat(swiper.virtualSize + spaceBetween, "px");
+    }
+    if (params.setWrapperSize) {
+        wrapperEl.style[swiper.getDirectionLabel('width')] = "".concat(swiper.virtualSize + spaceBetween, "px");
+    }
+    if (gridEnabled) {
+        swiper.grid.updateWrapperSize(slideSize, snapGrid);
+    }
+    // Remove last grid elements depending on width
+    if (!params.centeredSlides) {
+        var newSlidesGrid = [];
+        for (var i = 0; i < snapGrid.length; i += 1) {
+            var slidesGridItem = snapGrid[i];
+            if (params.roundLengths)
+                slidesGridItem = Math.floor(slidesGridItem);
+            if (snapGrid[i] <= swiper.virtualSize - swiperSize) {
+                newSlidesGrid.push(slidesGridItem);
+            }
+        }
+        snapGrid = newSlidesGrid;
+        if (Math.floor(swiper.virtualSize - swiperSize) - Math.floor(snapGrid[snapGrid.length - 1]) >
+            1) {
+            snapGrid.push(swiper.virtualSize - swiperSize);
+        }
+    }
+    if (isVirtual && params.loop) {
+        var size = slidesSizesGrid[0] + spaceBetween;
+        if (params.slidesPerGroup > 1) {
+            var groups = Math.ceil((swiper.virtual.slidesBefore + swiper.virtual.slidesAfter) / params.slidesPerGroup);
+            var groupSize = size * params.slidesPerGroup;
+            for (var i = 0; i < groups; i += 1) {
+                snapGrid.push(snapGrid[snapGrid.length - 1] + groupSize);
+            }
+        }
+        for (var i = 0; i < swiper.virtual.slidesBefore + swiper.virtual.slidesAfter; i += 1) {
+            if (params.slidesPerGroup === 1) {
+                snapGrid.push(snapGrid[snapGrid.length - 1] + size);
+            }
+            slidesGrid.push(slidesGrid[slidesGrid.length - 1] + size);
+            swiper.virtualSize += size;
+        }
+    }
+    if (snapGrid.length === 0)
+        snapGrid = [0];
+    if (spaceBetween !== 0) {
+        var key_1 = swiper.isHorizontal() && rtl ? 'marginLeft' : swiper.getDirectionLabel('marginRight');
+        slides
+            .filter(function (_, slideIndex) {
+            if (!params.cssMode || params.loop)
+                return true;
+            if (slideIndex === slides.length - 1) {
+                return false;
+            }
+            return true;
+        })
+            .forEach(function (slideEl) {
+            slideEl.style[key_1] = "".concat(spaceBetween, "px");
+        });
+    }
+    if (params.centeredSlides && params.centeredSlidesBounds) {
+        var allSlidesSize_1 = 0;
+        slidesSizesGrid.forEach(function (slideSizeValue) {
+            allSlidesSize_1 += slideSizeValue + (spaceBetween || 0);
+        });
+        allSlidesSize_1 -= spaceBetween;
+        var maxSnap_1 = allSlidesSize_1 - swiperSize;
+        snapGrid = snapGrid.map(function (snap) {
+            if (snap <= 0)
+                return -offsetBefore;
+            if (snap > maxSnap_1)
+                return maxSnap_1 + offsetAfter;
+            return snap;
+        });
+    }
+    if (params.centerInsufficientSlides) {
+        var allSlidesSize_2 = 0;
+        slidesSizesGrid.forEach(function (slideSizeValue) {
+            allSlidesSize_2 += slideSizeValue + (spaceBetween || 0);
+        });
+        allSlidesSize_2 -= spaceBetween;
+        var offsetSize = (params.slidesOffsetBefore || 0) + (params.slidesOffsetAfter || 0);
+        if (allSlidesSize_2 + offsetSize < swiperSize) {
+            var allSlidesOffset_1 = (swiperSize - allSlidesSize_2 - offsetSize) / 2;
+            snapGrid.forEach(function (snap, snapIndex) {
+                snapGrid[snapIndex] = snap - allSlidesOffset_1;
+            });
+            slidesGrid.forEach(function (snap, snapIndex) {
+                slidesGrid[snapIndex] = snap + allSlidesOffset_1;
+            });
+        }
+    }
+    Object.assign(swiper, {
+        slides: slides,
+        snapGrid: snapGrid,
+        slidesGrid: slidesGrid,
+        slidesSizesGrid: slidesSizesGrid,
+    });
+    if (params.centeredSlides && params.cssMode && !params.centeredSlidesBounds) {
+        (0, utils_1.setCSSProperty)(wrapperEl, '--swiper-centered-offset-before', "".concat(-snapGrid[0], "px"));
+        (0, utils_1.setCSSProperty)(wrapperEl, '--swiper-centered-offset-after', "".concat(swiper.size / 2 - slidesSizesGrid[slidesSizesGrid.length - 1] / 2, "px"));
+        var addToSnapGrid_1 = -swiper.snapGrid[0];
+        var addToSlidesGrid_1 = -swiper.slidesGrid[0];
+        swiper.snapGrid = swiper.snapGrid.map(function (v) { return v + addToSnapGrid_1; });
+        swiper.slidesGrid = swiper.slidesGrid.map(function (v) { return v + addToSlidesGrid_1; });
+    }
+    if (slidesLength !== previousSlidesLength) {
+        swiper.emit('slidesLengthChange');
+    }
+    if (snapGrid.length !== previousSnapGridLength) {
+        if (swiper.params.watchOverflow)
+            swiper.checkOverflow();
+        swiper.emit('snapGridLengthChange');
+    }
+    if (slidesGrid.length !== previousSlidesGridLength) {
+        swiper.emit('slidesGridLengthChange');
+    }
+    if (params.watchSlidesProgress) {
+        swiper.updateSlidesOffset();
+    }
+    swiper.emit('slidesUpdated');
+    if (!isVirtual && !params.cssMode && (params.effect === 'slide' || params.effect === 'fade')) {
+        var backFaceHiddenClass = "".concat(params.containerModifierClass, "backface-hidden");
+        var hasClassBackfaceClassAdded = swiper.el.classList.contains(backFaceHiddenClass);
+        if (slidesLength <= params.maxBackfaceHiddenSlides) {
+            if (!hasClassBackfaceClassAdded)
+                swiper.el.classList.add(backFaceHiddenClass);
+        }
+        else if (hasClassBackfaceClassAdded) {
+            swiper.el.classList.remove(backFaceHiddenClass);
+        }
+    }
+}
+exports.default = updateSlides;
+//# sourceMappingURL=updateSlides.js.map

package/dist/ui/components/carousel/carousel-lib/core/update/updateSlidesClasses.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//@ts-nocheck
+var utils_1 = require("../../shared/utils.js");
+var toggleSlideClasses = function (slideEl, condition, className) {
+    if (condition && !slideEl.classList.contains(className)) {
+        slideEl.classList.add(className);
+    }
+    else if (!condition && slideEl.classList.contains(className)) {
+        slideEl.classList.remove(className);
+    }
+};
+function updateSlidesClasses() {
+    var swiper = this;
+    var slides = swiper.slides, params = swiper.params, slidesEl = swiper.slidesEl, activeIndex = swiper.activeIndex;
+    var isVirtual = swiper.virtual && params.virtual.enabled;
+    var gridEnabled = swiper.grid && params.grid && params.grid.rows > 1;
+    var getFilteredSlide = function (selector) {
+        return (0, utils_1.elementChildren)(slidesEl, ".".concat(params.slideClass).concat(selector, ", swiper-slide").concat(selector))[0];
+    };
+    var activeSlide;
+    var prevSlide;
+    var nextSlide;
+    if (isVirtual) {
+        if (params.loop) {
+            var slideIndex = activeIndex - swiper.virtual.slidesBefore;
+            if (slideIndex < 0)
+                slideIndex = swiper.virtual.slides.length + slideIndex;
+            if (slideIndex >= swiper.virtual.slides.length)
+                slideIndex -= swiper.virtual.slides.length;
+            activeSlide = getFilteredSlide("[data-swiper-slide-index=\"".concat(slideIndex, "\"]"));
+        }
+        else {
+            activeSlide = getFilteredSlide("[data-swiper-slide-index=\"".concat(activeIndex, "\"]"));
+        }
+    }
+    else {
+        if (gridEnabled) {
+            activeSlide = slides.filter(function (slideEl) { return slideEl.column === activeIndex; })[0];
+            nextSlide = slides.filter(function (slideEl) { return slideEl.column === activeIndex + 1; })[0];
+            prevSlide = slides.filter(function (slideEl) { return slideEl.column === activeIndex - 1; })[0];
+        }
+        else {
+            activeSlide = slides[activeIndex];
+        }
+    }
+    if (activeSlide) {
+        if (!gridEnabled) {
+            // Next Slide
+            nextSlide = (0, utils_1.elementNextAll)(activeSlide, ".".concat(params.slideClass, ", swiper-slide"))[0];
+            if (params.loop && !nextSlide) {
+                nextSlide = slides[0];
+            }
+            // Prev Slide
+            prevSlide = (0, utils_1.elementPrevAll)(activeSlide, ".".concat(params.slideClass, ", swiper-slide"))[0];
+            if (params.loop && !prevSlide === 0) {
+                prevSlide = slides[slides.length - 1];
+            }
+        }
+    }
+    slides.forEach(function (slideEl) {
+        toggleSlideClasses(slideEl, slideEl === activeSlide, params.slideActiveClass);
+        toggleSlideClasses(slideEl, slideEl === nextSlide, params.slideNextClass);
+        toggleSlideClasses(slideEl, slideEl === prevSlide, params.slidePrevClass);
+    });
+    swiper.emitSlidesClasses();
+}
+exports.default = updateSlidesClasses;
+//# sourceMappingURL=updateSlidesClasses.js.map

package/dist/ui/components/form/handler/i18n/capture-i18n-errors/index.d.ts

@@ -0,0 +1,6 @@
+import { TabContentProps } from "../../../../../../system/index.js";
+export declare function CaptureI18nErrors({ languages, changeTab }: {
+    languages: {
+        symbol: string;
+    }[];
+} & TabContentProps): import("react/jsx-runtime").JSX.Element;

package/dist/ui/components/form/input-cep/use-cep/providers/ibge/hook.d.ts

@@ -1,4 +1,4 @@
-import { FieldsProviderCep, InputCepProps } from '../../../../../../../ui';
+import { FieldsProviderCep, InputCepProps } from '../../../../../../../ui/index.js';
 export declare function useCepIBGE<T = any>({ fields }: InputCepProps<T>): {
     getCep: (zipCode: any) => Promise<T>;
     fields: FieldsProviderCep<T>;

package/dist/ui/components/form/input-cep/use-cep/providers/ibge/hook.js

@@ -37,7 +37,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useCepIBGE = void 0;
-var ui_1 = require("../../../../../../../ui");
+var ui_1 = require("../../../../../../../ui/index.js");
 function useCepIBGE(_a) {
     var fields = _a.fields;
     function getCep(zipCode) {

package/dist/ui/components/form/input-cep/use-cep/providers/ibge/index.d.ts

@@ -1,3 +1,3 @@
-export * from "./hook";
-export * from "./service";
-export * from "./interfaces";
+export * from "./hook.js";
+export * from "./service.js";
+export * from "./interfaces.js";

package/dist/ui/components/form/input-cep/use-cep/providers/ibge/index.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./hook"), exports);
-__exportStar(require("./service"), exports);
-__exportStar(require("./interfaces"), exports);
+__exportStar(require("./hook.js"), exports);
+__exportStar(require("./service.js"), exports);
+__exportStar(require("./interfaces.js"), exports);
 //# sourceMappingURL=index.js.map

package/dist/ui/components/form/input-cep/use-cep/providers/index.d.ts

@@ -0,0 +1 @@
+export * from "./ibge/index.js";

package/dist/ui/components/form/input-cep/use-cep/providers/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./ibge/index.js"), exports);
+//# sourceMappingURL=index.js.map

package/dist/ui/components/form/input-currency/components/utils/cleanValue.d.ts

@@ -0,0 +1,8 @@
+import { CurrencyInputProps } from '../CurrencyInputProps.js';
+export type CleanValueOptions = Pick<CurrencyInputProps, 'decimalSeparator' | 'groupSeparator' | 'allowDecimals' | 'decimalsLimit' | 'allowNegativeValue' | 'disableAbbreviations' | 'prefix' | 'transformRawValue'> & {
+    value: string;
+};
+/**
+ * Remove prefix, separators and extra decimals from value
+ */
+export declare const cleanValue: ({ value, groupSeparator, decimalSeparator, allowDecimals, decimalsLimit, allowNegativeValue, disableAbbreviations, prefix, transformRawValue, }: CleanValueOptions) => string;

package/dist/ui/components/form/input-currency/components/utils/cleanValue.js

@@ -0,0 +1,62 @@
+"use strict";
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanValue = void 0;
+var parseAbbrValue_1 = require("./parseAbbrValue.js");
+var removeSeparators_1 = require("./removeSeparators.js");
+var removeInvalidChars_1 = require("./removeInvalidChars.js");
+var escapeRegExp_1 = require("./escapeRegExp.js");
+/**
+ * Remove prefix, separators and extra decimals from value
+ */
+var cleanValue = function (_a) {
+    var value = _a.value, _b = _a.groupSeparator, groupSeparator = _b === void 0 ? ',' : _b, _c = _a.decimalSeparator, decimalSeparator = _c === void 0 ? '.' : _c, _d = _a.allowDecimals, allowDecimals = _d === void 0 ? true : _d, _e = _a.decimalsLimit, decimalsLimit = _e === void 0 ? 2 : _e, _f = _a.allowNegativeValue, allowNegativeValue = _f === void 0 ? true : _f, _g = _a.disableAbbreviations, disableAbbreviations = _g === void 0 ? false : _g, _h = _a.prefix, prefix = _h === void 0 ? '' : _h, _j = _a.transformRawValue, transformRawValue = _j === void 0 ? function (rawValue) { return rawValue; } : _j;
+    var transformedValue = transformRawValue(value);
+    if (transformedValue === '-') {
+        return transformedValue;
+    }
+    var abbreviations = disableAbbreviations ? [] : ['k', 'm', 'b'];
+    var reg = new RegExp("((^|\\D)-\\d)|(-".concat((0, escapeRegExp_1.escapeRegExp)(prefix), ")"));
+    var isNegative = reg.test(transformedValue);
+    // Is there a digit before the prefix? eg. 1$
+    var _k = RegExp("(\\d+)-?".concat((0, escapeRegExp_1.escapeRegExp)(prefix))).exec(value) || [], prefixWithValue = _k[0], preValue = _k[1];
+    var withoutPrefix = prefix
+        ? prefixWithValue
+            ? transformedValue.replace(prefixWithValue, '').concat(preValue)
+            : transformedValue.replace(prefix, '')
+        : transformedValue;
+    var withoutSeparators = (0, removeSeparators_1.removeSeparators)(withoutPrefix, groupSeparator);
+    var withoutInvalidChars = (0, removeInvalidChars_1.removeInvalidChars)(withoutSeparators, __spreadArray([
+        groupSeparator,
+        decimalSeparator
+    ], abbreviations, true));
+    var valueOnly = withoutInvalidChars;
+    if (!disableAbbreviations) {
+        // disallow letter without number
+        if (abbreviations.some(function (letter) { return letter === withoutInvalidChars.toLowerCase().replace(decimalSeparator, ''); })) {
+            return '';
+        }
+        var parsed = (0, parseAbbrValue_1.parseAbbrValue)(withoutInvalidChars, decimalSeparator);
+        if (parsed) {
+            valueOnly = String(parsed);
+        }
+    }
+    var includeNegative = isNegative && allowNegativeValue ? '-' : '';
+    if (decimalSeparator && valueOnly.includes(decimalSeparator)) {
+        var _l = withoutInvalidChars.split(decimalSeparator), int = _l[0], decimals = _l[1];
+        var trimmedDecimals = decimalsLimit && decimals ? decimals.slice(0, decimalsLimit) : decimals;
+        var includeDecimals = allowDecimals ? "".concat(decimalSeparator).concat(trimmedDecimals) : '';
+        return "".concat(includeNegative).concat(int).concat(includeDecimals);
+    }
+    return "".concat(includeNegative).concat(valueOnly);
+};
+exports.cleanValue = cleanValue;
+//# sourceMappingURL=cleanValue.js.map

package/dist/ui/components/form/input-currency/components/utils/formatValue.d.ts

@@ -0,0 +1,49 @@
+import { IntlConfig } from '../CurrencyInputProps.js';
+export type FormatValueOptions = {
+    /**
+     * Value to format
+     */
+    value: string | undefined;
+    /**
+     * Decimal separator
+     *
+     * Default = '.'
+     */
+    decimalSeparator?: string;
+    /**
+     * Group separator
+     *
+     * Default = ','
+     */
+    groupSeparator?: string;
+    /**
+     * Turn off separators
+     *
+     * This will override Group separators
+     *
+     * Default = false
+     */
+    disableGroupSeparators?: boolean;
+    /**
+     * Intl locale currency config
+     */
+    intlConfig?: IntlConfig;
+    /**
+     * Specify decimal scale for padding/trimming
+     *
+     * Eg. 1.5 -> 1.50 or 1.234 -> 1.23
+     */
+    decimalScale?: number;
+    /**
+     * Prefix
+     */
+    prefix?: string;
+    /**
+     * Suffix
+     */
+    suffix?: string;
+};
+/**
+ * Format value with decimal separator, group separator and prefix
+ */
+export declare const formatValue: (options: FormatValueOptions) => string;