matcha-components 20.98.0 → 20.100.0

package/fesm2022/matcha-components.mjs

@@ -6215,6 +6215,35 @@ class MatchaMaskService extends MatchaMaskApplierService {
             : (v) => v;
         this.writingValue = false;
         this.maskChanged = false;
+        // Para máscaras de separador (currency), fazer conversão direta para número
+        if (this.maskExpression.startsWith("separator" /* MaskExpression.SEPARATOR */) && this.dropSpecialCharacters) {
+            // Remover prefixo e sufixo
+            let cleanValue = inputValue;
+            if (this.prefix) {
+                cleanValue = cleanValue.replace(this.prefix, '');
+            }
+            if (this.suffix) {
+                cleanValue = cleanValue.replace(this.suffix, '');
+            }
+            // Remover separador de milhares
+            if (this.thousandSeparator) {
+                cleanValue = cleanValue.split(this.thousandSeparator).join('');
+            }
+            // Converter decimal marker para ponto
+            const markers = Array.isArray(this.decimalMarker)
+                ? this.decimalMarker
+                : [this.decimalMarker];
+            for (const marker of markers) {
+                if (marker && marker !== '.') {
+                    cleanValue = cleanValue.replace(marker, '.');
+                }
+            }
+            // Converter para número
+            const numValue = parseFloat(cleanValue);
+            const finalValue = isNaN(numValue) ? 0 : numValue;
+            this.onChange(outputTransformFn(finalValue));
+            return;
+        }
         // Para máscaras de separador, garantir que isNumberValue é true
         // Isso assegura a conversão correta para número
         if (this.maskExpression.startsWith("separator" /* MaskExpression.SEPARATOR */)) {
@@ -6795,14 +6824,56 @@ class MatchaMaskCompatibleDirective {
         else {
             inputValue = String(value);
         }
-        // Se a máscara usa separator e o valor tem ponto decimal, converter para vírgula
-        // Isso é útil quando valores numéricos vêm do backend (ex: 10.5 -> 10,50)
-        if (this._mask && this._mask.trim().startsWith('separator.') && inputValue.includes('.')) {
-            // Converter ponto para vírgula se o decimalMarker é vírgula
+        // Para máscaras de separador (currency), formatar o valor do backend corretamente
+        // Exemplo: backend envia 10.5, devemos exibir "R$ 10,50"
+        if (this._mask && this._mask.trim().startsWith('separator.')) {
+            const precision = this._maskService.getPrecision(this._mask);
             const decimalMarker = this._maskService.decimalMarker;
-            if (decimalMarker === ',' || (Array.isArray(decimalMarker) && decimalMarker.includes(','))) {
-                inputValue = inputValue.replace('.', ',');
+            const actualDecimalMarker = decimalMarker === ',' ||
+                (Array.isArray(decimalMarker) && decimalMarker.includes(',')) ? ',' : '.';
+            // Se o valor tem ponto decimal (formato backend), converter para formato de exibição
+            if (inputValue.includes('.')) {
+                // Separar parte inteira e decimal
+                const parts = inputValue.split('.');
+                const integerPart = parts[0] || '0';
+                let decimalPart = parts[1] || '';
+                // Ajustar casas decimais conforme precisão
+                if (precision > 0) {
+                    decimalPart = decimalPart.padEnd(precision, '0').substring(0, precision);
+                }
+                // Aplicar separador de milhares na parte inteira
+                let formattedInteger = integerPart;
+                const rgx = /(\d+)(\d{3})/;
+                while (this._maskService.thousandSeparator && rgx.test(formattedInteger)) {
+                    formattedInteger = formattedInteger.replace(rgx, '$1' + this._maskService.thousandSeparator + '$2');
+                }
+                // Montar valor formatado
+                inputValue = precision > 0
+                    ? formattedInteger + actualDecimalMarker + decimalPart
+                    : formattedInteger;
+            }
+            else if (!inputValue.includes(actualDecimalMarker) && precision > 0) {
+                // Valor sem casas decimais (ex: "10"), adicionar zeros
+                let formattedInteger = inputValue;
+                const rgx = /(\d+)(\d{3})/;
+                while (this._maskService.thousandSeparator && rgx.test(formattedInteger)) {
+                    formattedInteger = formattedInteger.replace(rgx, '$1' + this._maskService.thousandSeparator + '$2');
+                }
+                inputValue = formattedInteger + actualDecimalMarker + '0'.repeat(precision);
+            }
+            // Adicionar prefixo se configurado
+            if (this._maskService.prefix && !inputValue.startsWith(this._maskService.prefix)) {
+                inputValue = this._maskService.prefix + inputValue;
             }
+            // Adicionar sufixo se configurado
+            if (this._maskService.suffix && !inputValue.endsWith(this._maskService.suffix)) {
+                inputValue = inputValue + this._maskService.suffix;
+            }
+            this._inputValue = inputValue;
+            this._maskService.currentValue = inputValue;
+            this._maskService.previousValue = inputValue;
+            this._maskService.writingValue = false;
+            return;
         }
         this._inputValue = inputValue;
         // Aplicar máscara se definida