matcha-components 20.97.0 → 20.99.0

package/fesm2022/matcha-components.mjs

@@ -5940,12 +5940,6 @@ class MatchaMaskService extends MatchaMaskApplierService {
                     (newInputValue !== this.currentValue && this.writingValue) ||
                     (this.previousValue === this.currentValue && justPasted);
         }
-        // DEBUG: Verificar se formControlResult está sendo chamado
-        console.log('=== applyMask DEBUG ===');
-        console.log('result:', result);
-        console.log('_emitValue:', this._emitValue);
-        console.log('previousValue:', this.previousValue);
-        console.log('currentValue:', this.currentValue);
         // Propagate the input value back to the Angular model
         // eslint-disable-next-line no-unused-expressions,@typescript-eslint/no-unused-expressions
         this._emitValue ? this.formControlResult(result) : '';
@@ -6226,35 +6220,15 @@ class MatchaMaskService extends MatchaMaskApplierService {
         if (this.maskExpression.startsWith("separator" /* MaskExpression.SEPARATOR */)) {
             this.isNumberValue = true;
         }
-        console.log('=== formControlResult DEBUG ===');
-        console.log('inputValue:', inputValue);
-        console.log('isNumberValue:', this.isNumberValue);
-        console.log('dropSpecialCharacters:', this.dropSpecialCharacters);
         if (Array.isArray(this.dropSpecialCharacters)) {
-            const afterPrefix = this._removePrefix(inputValue);
-            const afterSuffix = this._removeSuffix(afterPrefix);
-            const afterMask = this._removeMask(afterSuffix, this.dropSpecialCharacters);
-            const afterSymbols = this._checkSymbols(afterMask);
-            const afterNumber = this._toNumber(afterSymbols);
-            const finalValue = outputTransformFn(afterNumber);
-            console.log('Array: afterPrefix:', afterPrefix, 'afterSuffix:', afterSuffix, 'afterMask:', afterMask, 'afterSymbols:', afterSymbols, 'afterNumber:', afterNumber, 'final:', finalValue, 'type:', typeof finalValue);
-            this.onChange(finalValue);
+            this.onChange(outputTransformFn(this._toNumber(this._checkSymbols(this._removeMask(this._removeSuffix(this._removePrefix(inputValue)), this.dropSpecialCharacters)))));
         }
         else if (this.dropSpecialCharacters ||
             (!this.dropSpecialCharacters && this.prefix === inputValue)) {
-            const afterPrefix = this._removePrefix(inputValue);
-            const afterSuffix = this._removeSuffix(afterPrefix);
-            const afterSymbols = this._checkSymbols(afterSuffix);
-            const afterNumber = this._toNumber(afterSymbols);
-            const finalValue = outputTransformFn(afterNumber);
-            console.log('Boolean: afterPrefix:', afterPrefix, 'afterSuffix:', afterSuffix, 'afterSymbols:', afterSymbols, 'afterNumber:', afterNumber, 'final:', finalValue, 'type:', typeof finalValue);
-            this.onChange(finalValue);
+            this.onChange(outputTransformFn(this._toNumber(this._checkSymbols(this._removeSuffix(this._removePrefix(inputValue))))));
         }
         else {
-            const afterNumber = this._toNumber(inputValue);
-            const finalValue = outputTransformFn(afterNumber);
-            console.log('Else: afterNumber:', afterNumber, 'final:', finalValue);
-            this.onChange(finalValue);
+            this.onChange(outputTransformFn(this._toNumber(inputValue)));
         }
     }
     _toNumber(value) {
@@ -6332,6 +6306,25 @@ class MatchaMaskService extends MatchaMaskApplierService {
             this.decimalMarker === "," /* MaskExpression.COMMA */) {
             processedResult = processedResult.replace("," /* MaskExpression.COMMA */, "." /* MaskExpression.DOT */);
         }
+        // Para máscaras de separador (currency), processar de forma especial
+        // Remover separador de milhares e converter decimal marker para ponto
+        if (this.maskExpression.startsWith("separator" /* MaskExpression.SEPARATOR */)) {
+            let cleanValue = processedResult;
+            // 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, '.');
+                }
+            }
+            return cleanValue;
+        }
         const separatorPrecision = this._retrieveSeparatorPrecision(this.maskExpression);
         const separatorValue = this.specialCharacters.length === 0
             ? this._retrieveSeparatorValue(processedResult)
@@ -6802,14 +6795,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