@seniorsistemas/angular-components 18.0.1 → 18.0.3

package/esm2022/numeric-mask/lib/numeric-mask/numeric-mask.directive.mjs

@@ -0,0 +1,579 @@
+import { Directive, effect, ElementRef, forwardRef, inject, input, Renderer2 } from '@angular/core';
+import { NG_VALIDATORS, NG_VALUE_ACCESSOR, } from '@angular/forms';
+import { LocaleService } from '@seniorsistemas/angular-components/locale';
+import BigNumber from 'bignumber.js';
+import * as i0 from "@angular/core";
+/**
+ * Numeric mask directive with internationalization support.
+ *
+ * Formats numeric values according to the specified locale, applying
+ * appropriate thousand and decimal separators, with support for negative values,
+ * min/max decimal places control, and scientific notation.
+ *
+ * @example
+ * ```html
+ * <input
+ *   type="text"
+ *   sNumericMask
+ *   [locale]="'pt-BR'"
+ *   [minDecimalPlaces]="2"
+ *   [maxDecimalPlaces]="2"
+ *   [allowNegative]="true"
+ *   [(ngModel)]="value"
+ * />
+ * ```
+ */
+export class NumericMaskDirective {
+    /**
+     * Locale for formatting (e.g. 'pt-BR', 'en-US', 'de-DE')
+     * If not provided, uses the locale from LocaleService
+     */
+    locale = input(undefined);
+    /**
+     * Minimum number of decimal places to display
+     * @default 0
+     */
+    minDecimalPlaces = input(0);
+    /**
+     * Maximum number of decimal places allowed
+     * @default 10
+     */
+    maxDecimalPlaces = input(10);
+    /**
+     * Allows negative values
+     * @default false
+     */
+    allowNegative = input(false);
+    /**
+     * Enables scientific notation support
+     * @default true
+     */
+    allowScientificNotation = input(true);
+    /**
+     * Text alignment in input
+     * @default 'right'
+     */
+    textAlign = input('right');
+    /**
+     * Minimum value allowed
+     */
+    min = input(undefined);
+    /**
+     * Maximum value allowed
+     */
+    max = input(undefined);
+    elementRef = inject((ElementRef));
+    renderer = inject(Renderer2);
+    localeService = inject(LocaleService, { optional: true });
+    onChange = () => { };
+    onTouched = () => { };
+    decimalSeparator = ',';
+    thousandSeparator = '.';
+    currentLocale = 'pt-BR';
+    lastModelValue = null;
+    constructor() {
+        effect(() => {
+            const inputLocale = this.locale();
+            if (inputLocale) {
+                this.currentLocale = inputLocale;
+                this.updateSeparators();
+            }
+        });
+    }
+    ngOnInit() {
+        if (this.minDecimalPlaces() > this.maxDecimalPlaces()) {
+            throw new Error(`NumericMaskDirective: minDecimalPlaces (${this.minDecimalPlaces()}) cannot be greater than maxDecimalPlaces (${this.maxDecimalPlaces()})`);
+        }
+        if (this.locale()) {
+            this.currentLocale = this.locale();
+            this.updateSeparators();
+            this.setInputMode();
+        }
+        else if (this.localeService) {
+            this.localeService.get().subscribe(() => {
+                this.currentLocale = this.localeService.getLocaleOptions()?.locale || 'pt-BR';
+                this.updateSeparators();
+                this.setInputMode();
+            });
+        }
+        else {
+            this.updateSeparators();
+            this.setInputMode();
+        }
+    }
+    /**
+     * Listener for input events (typing)
+     */
+    onInput(event) {
+        const input = event.target;
+        let value = input.value;
+        value = this.normalizeSeparators(value);
+        this.processInputValue(value);
+    }
+    /**
+     * Listener for focus events (gaining focus)
+     */
+    onFocus() {
+        const input = this.elementRef.nativeElement;
+        const currentValue = input.value;
+        if (!currentValue || currentValue.trim() === '') {
+            return;
+        }
+        if (this.lastModelValue) {
+            const displayValue = this.lastModelValue.replace('.', this.decimalSeparator);
+            this.renderer.setProperty(input, 'value', displayValue);
+            input.select();
+            return;
+        }
+        const modelValue = this.toModelValue(currentValue);
+        if (!modelValue) {
+            return;
+        }
+        const displayValue = modelValue.replace('.', this.decimalSeparator);
+        this.renderer.setProperty(input, 'value', displayValue);
+        input.select();
+    }
+    /**
+     * Listener for blur events (focus loss)
+     */
+    onBlur() {
+        this.onTouched();
+        const currentValue = this.elementRef.nativeElement.value;
+        if (!currentValue || currentValue.trim() === '') {
+            this.onChange(null);
+            this.lastModelValue = null;
+            return;
+        }
+        const modelValue = this.toModelValue(currentValue);
+        if (!modelValue) {
+            this.onChange(null);
+            this.lastModelValue = null;
+            return;
+        }
+        this.lastModelValue = modelValue;
+        const displayValue = this.fromModelValue(modelValue);
+        this.renderer.setProperty(this.elementRef.nativeElement, 'value', displayValue);
+        this.onChange(modelValue);
+    }
+    /**
+     * Listener for paste events (clipboard)
+     */
+    onPaste(event) {
+        event.preventDefault();
+        const pastedText = event.clipboardData?.getData('text') || '';
+        let value = this.parseClipboardValue(pastedText);
+        this.processInputValue(value);
+    }
+    /**
+     * Listener for special keys (+ and -)
+     */
+    onKeyDown(event) {
+        const key = event.key;
+        if (key === '-' || key === '+') {
+            const input = this.elementRef.nativeElement;
+            const value = input.value;
+            const cursorPosition = input.selectionStart || 0;
+            if (key === '-' && this.allowScientificNotation()) {
+                const charBeforeCursor = value[cursorPosition - 1];
+                if (charBeforeCursor === 'e' || charBeforeCursor === 'E') {
+                    return;
+                }
+            }
+            event.preventDefault();
+            if (!this.allowNegative()) {
+                return;
+            }
+            this.toggleSign(value, key === '-');
+        }
+    }
+    /**
+     * Listener for keypress to block invalid characters
+     */
+    onKeyPress(event) {
+        const key = event.key;
+        const input = this.elementRef.nativeElement;
+        const cursorPosition = input.selectionStart || 0;
+        const value = input.value;
+        if ((key === '-' || key === '+') && this.allowScientificNotation()) {
+            const charBeforeCursor = value[cursorPosition - 1];
+            if (charBeforeCursor === 'e' || charBeforeCursor === 'E') {
+                return;
+            }
+        }
+        if (key === '+' || key === '-') {
+            event.preventDefault();
+            return;
+        }
+        const isDigit = /^[0-9]$/.test(key);
+        const isLocaleDecimalSeparator = key === this.decimalSeparator;
+        const isOtherSeparator = (key === ',' || key === '.') && key !== this.decimalSeparator;
+        const isScientificNotation = (key === 'e' || key === 'E') && this.allowScientificNotation();
+        const isControlKey = event.ctrlKey || event.metaKey || event.altKey;
+        const isSpecialKey = [
+            'Backspace',
+            'Tab',
+            'Enter',
+            'Escape',
+            'ArrowLeft',
+            'ArrowRight',
+            'Delete',
+            'Home',
+            'End',
+        ].includes(key);
+        if (isOtherSeparator) {
+            event.preventDefault();
+            return;
+        }
+        if (isScientificNotation) {
+            if (value.includes('e') || value.includes('E')) {
+                event.preventDefault();
+                return;
+            }
+            const charBeforeCursor = value[cursorPosition - 1];
+            if (!charBeforeCursor || !/^[0-9]$/.test(charBeforeCursor)) {
+                event.preventDefault();
+                return;
+            }
+        }
+        if (!isDigit && !isLocaleDecimalSeparator && !isScientificNotation && !isControlKey && !isSpecialKey) {
+            event.preventDefault();
+        }
+    }
+    /**
+     * Updates separators according to the locale
+     * @private
+     */
+    updateSeparators() {
+        const formatted = new Intl.NumberFormat(this.currentLocale).format(1234.5);
+        this.thousandSeparator = formatted[1];
+        this.decimalSeparator = formatted[5];
+    }
+    /**
+     * Processes input value and updates the input and model
+     * @private
+     */
+    processInputValue(value) {
+        if (!this.decimalSeparator || !this.thousandSeparator) {
+            this.updateSeparators();
+        }
+        this.renderer.setProperty(this.elementRef.nativeElement, 'value', value);
+        const modelValue = this.toModelValue(value);
+        // During typing, clear the stored model value so onFocus will recalculate
+        this.lastModelValue = null;
+        this.onChange(modelValue);
+    }
+    /**
+     * Sets inputmode for numeric keyboard on mobile devices
+     * @private
+     */
+    setInputMode() {
+        this.renderer.setAttribute(this.elementRef.nativeElement, 'inputmode', 'decimal');
+        this.renderer.setAttribute(this.elementRef.nativeElement, 'autocomplete', 'off');
+    }
+    /**
+     * Removes separators from a formatted value
+     * @private
+     */
+    removeSeparators(value) {
+        const thousandRegex = new RegExp(`\\${this.escapeRegex(this.thousandSeparator)}`, 'g');
+        return value.replace(thousandRegex, '');
+    }
+    /**
+     * Strips unnecessary trailing zeros from decimal part
+     * @private
+     */
+    stripTrailingZeros(value) {
+        const parts = value.split(this.decimalSeparator);
+        if (parts.length === 2) {
+            const decimalPart = parts[1].replace(/0+$/, '');
+            return decimalPart.length > 0 ? parts[0] + this.decimalSeparator + decimalPart : parts[0];
+        }
+        return value;
+    }
+    /**
+     * Normalizes separators during typing
+     * @private
+     */
+    normalizeSeparators(value) {
+        value = this.removeSeparators(value);
+        if (this.decimalSeparator === ',') {
+            value = value.replace(/\./g, ',');
+        }
+        else if (this.decimalSeparator === '.') {
+            value = value.replace(/,/g, '.');
+        }
+        const parts = value.split(this.decimalSeparator);
+        if (parts.length > 2) {
+            value = parts[0] + this.decimalSeparator + parts.slice(1).join('');
+        }
+        return value;
+    }
+    /**
+     * Escapes special characters for use in regex
+     * @private
+     */
+    escapeRegex(str) {
+        return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
+    /**
+     * Truncates a number to the specified decimal places (never rounds)
+     * @private
+     */
+    truncateToDecimalPlaces(bigNumber, decimalPlaces) {
+        if (decimalPlaces < 0) {
+            return bigNumber;
+        }
+        const multiplier = new BigNumber(10).pow(decimalPlaces);
+        return bigNumber.multipliedBy(multiplier).integerValue(BigNumber.ROUND_DOWN).dividedBy(multiplier);
+    }
+    /**
+     * Checks if the value has excessive decimal places
+     * @private
+     */
+    hasExcessiveDecimalPlaces(value) {
+        const parts = value.split(this.decimalSeparator);
+        if (parts.length > 1) {
+            const decimalPart = parts[1].replace(/[^0-9]/g, '');
+            return decimalPart.length > this.maxDecimalPlaces();
+        }
+        return false;
+    }
+    /**
+     * Clears the input and notifies the model
+     * @private
+     */
+    clearInput() {
+        this.renderer.setProperty(this.elementRef.nativeElement, 'value', '');
+        this.lastModelValue = null;
+        this.onChange(null);
+    }
+    /**
+     * Parses a string value to its numeric representation, handling separators and sign
+     * Returns BigNumber to preserve full precision and optional number conversion
+     * @private
+     */
+    parseStringToValue(value) {
+        const isNegative = value.startsWith('-');
+        let numericStr = value
+            .replace(/^-/, '')
+            .replace(new RegExp(`\\${this.thousandSeparator}`, 'g'), '')
+            .replace(new RegExp(`\\${this.decimalSeparator}`, 'g'), '.');
+        if (numericStr === '.' || numericStr === '') {
+            numericStr = '0';
+        }
+        else if (numericStr.startsWith('.')) {
+            numericStr = '0' + numericStr;
+        }
+        let bigNumber = new BigNumber(numericStr);
+        if (bigNumber.isNaN()) {
+            bigNumber = new BigNumber(0);
+        }
+        if (isNegative && this.allowNegative()) {
+            bigNumber = bigNumber.negated();
+        }
+        return { bigNumber, numeric: bigNumber.toNumber(), isNegative };
+    }
+    /**
+     * Formats a numeric value according to the locale
+     * Truncates (never rounds) to maxDecimalPlaces for display purposes only
+     * @private
+     */
+    formatNumeric(numeric) {
+        let bigNumeric = numeric instanceof BigNumber ? numeric : new BigNumber(numeric);
+        const truncatedValue = this.truncateToDecimalPlaces(bigNumeric, this.maxDecimalPlaces());
+        const valueStr = truncatedValue.toFixed(this.maxDecimalPlaces());
+        let formattedValue = valueStr.replace('.', this.decimalSeparator);
+        const parts = formattedValue.split(this.decimalSeparator);
+        const integerPart = parts[0];
+        const decimalPart = parts[1] || '';
+        const formattedInteger = new Intl.NumberFormat(this.currentLocale).format(parseInt(integerPart, 10) || 0).split(this.decimalSeparator)[0];
+        const minDecimal = Math.max(this.minDecimalPlaces(), decimalPart.replace(/0+$/, '').length || 0);
+        const finalDecimal = decimalPart.padEnd(minDecimal, '0');
+        return formattedInteger + this.decimalSeparator + finalDecimal;
+    }
+    /**
+     * Formats the value according to the locale
+     * @private
+     */
+    formatValue(value) {
+        if (!value || value.trim() === '') {
+            return '';
+        }
+        const { numeric } = this.parseStringToValue(value);
+        return this.formatNumeric(numeric);
+    }
+    /**
+     * Converts the formatted value to the model format (international standard string)
+     * Always returns decimal notation, never scientific notation
+     * Stores the full precision value without truncation
+     * @private
+     */
+    toModelValue(formattedValue) {
+        if (!formattedValue || formattedValue.trim() === '') {
+            return null;
+        }
+        const { bigNumber } = this.parseStringToValue(formattedValue);
+        return bigNumber.toFixed();
+    }
+    /**
+     * Converts the model value to display format
+     * @private
+     */
+    fromModelValue(modelValue) {
+        if (modelValue === null || modelValue === undefined || modelValue === '') {
+            return '';
+        }
+        const bigNumber = new BigNumber(modelValue);
+        if (bigNumber.isNaN()) {
+            return '';
+        }
+        return this.formatNumeric(bigNumber);
+    }
+    /**
+     * Processes pasted value from clipboard
+     * Converts scientific notation to decimal using BigNumber
+     * @private
+     */
+    parseClipboardValue(text) {
+        if (this.allowScientificNotation() && /[eE]/.test(text)) {
+            try {
+                const bigNumeric = new BigNumber(text);
+                if (!bigNumeric.isNaN()) {
+                    text = bigNumeric.toFixed();
+                }
+            }
+            catch {
+                void 0;
+            }
+        }
+        return this.normalizeSeparators(text);
+    }
+    /**
+     * Toggles the sign (- or +) of a value
+     * @private
+     */
+    toggleSign(value, makeNegative) {
+        const input = this.elementRef.nativeElement;
+        let newValue = value;
+        if (makeNegative && !newValue.startsWith('-')) {
+            newValue = '-' + newValue;
+        }
+        else if (!makeNegative && newValue.startsWith('-')) {
+            newValue = newValue.substring(1);
+        }
+        else {
+            return;
+        }
+        this.renderer.setProperty(input, 'value', newValue);
+        const modelValue = this.toModelValue(newValue);
+        this.lastModelValue = null;
+        this.onChange(modelValue);
+    }
+    writeValue(value) {
+        if (!this.decimalSeparator || !this.thousandSeparator) {
+            this.updateSeparators();
+        }
+        const hasFocus = document.activeElement === this.elementRef.nativeElement;
+        if (hasFocus) {
+            const formattedValue = this.fromModelValue(value);
+            const rawValue = this.stripTrailingZeros(this.removeSeparators(formattedValue));
+            this.renderer.setProperty(this.elementRef.nativeElement, 'value', rawValue);
+        }
+        else {
+            const formattedValue = this.fromModelValue(value);
+            this.renderer.setProperty(this.elementRef.nativeElement, 'value', formattedValue);
+        }
+    }
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    setDisabledState(isDisabled) {
+        this.renderer.setProperty(this.elementRef.nativeElement, 'disabled', isDisabled);
+    }
+    validate(control) {
+        const value = control.value;
+        if (!value) {
+            return null;
+        }
+        const numericValue = parseFloat(value);
+        if (isNaN(numericValue)) {
+            return null;
+        }
+        if (!this.allowNegative() && numericValue < 0) {
+            return { negativeNotAllowed: true };
+        }
+        const minValue = this.min();
+        if (minValue !== undefined && numericValue < minValue) {
+            return {
+                min: {
+                    min: minValue,
+                    actual: numericValue,
+                },
+            };
+        }
+        const maxValue = this.max();
+        if (maxValue !== undefined && numericValue > maxValue) {
+            return {
+                max: {
+                    max: maxValue,
+                    actual: numericValue,
+                },
+            };
+        }
+        const decimalPart = value.split('.')[1];
+        if (decimalPart && decimalPart.length > this.maxDecimalPlaces()) {
+            return {
+                excessiveDecimalPlaces: {
+                    max: this.maxDecimalPlaces(),
+                    actual: decimalPart.length,
+                },
+            };
+        }
+        return null;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: NumericMaskDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.2.14", type: NumericMaskDirective, isStandalone: true, selector: "[sNumericMask]", inputs: { locale: { classPropertyName: "locale", publicName: "locale", isSignal: true, isRequired: false, transformFunction: null }, minDecimalPlaces: { classPropertyName: "minDecimalPlaces", publicName: "minDecimalPlaces", isSignal: true, isRequired: false, transformFunction: null }, maxDecimalPlaces: { classPropertyName: "maxDecimalPlaces", publicName: "maxDecimalPlaces", isSignal: true, isRequired: false, transformFunction: null }, allowNegative: { classPropertyName: "allowNegative", publicName: "allowNegative", isSignal: true, isRequired: false, transformFunction: null }, allowScientificNotation: { classPropertyName: "allowScientificNotation", publicName: "allowScientificNotation", isSignal: true, isRequired: false, transformFunction: null }, textAlign: { classPropertyName: "textAlign", publicName: "textAlign", isSignal: true, isRequired: false, transformFunction: null }, min: { classPropertyName: "min", publicName: "min", isSignal: true, isRequired: false, transformFunction: null }, max: { classPropertyName: "max", publicName: "max", isSignal: true, isRequired: false, transformFunction: null } }, host: { listeners: { "input": "onInput($event)", "focus": "onFocus()", "blur": "onBlur()", "paste": "onPaste($event)", "keydown": "onKeyDown($event)", "keypress": "onKeyPress($event)" }, properties: { "style.text-align": "textAlign()" } }, providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: forwardRef(() => NumericMaskDirective),
+                multi: true,
+            },
+            {
+                provide: NG_VALIDATORS,
+                useExisting: forwardRef(() => NumericMaskDirective),
+                multi: true,
+            },
+        ], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: NumericMaskDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[sNumericMask]',
+                    standalone: true,
+                    host: {
+                        '(input)': 'onInput($event)',
+                        '(focus)': 'onFocus()',
+                        '(blur)': 'onBlur()',
+                        '(paste)': 'onPaste($event)',
+                        '(keydown)': 'onKeyDown($event)',
+                        '(keypress)': 'onKeyPress($event)',
+                        '[style.text-align]': 'textAlign()',
+                    },
+                    providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => NumericMaskDirective),
+                            multi: true,
+                        },
+                        {
+                            provide: NG_VALIDATORS,
+                            useExisting: forwardRef(() => NumericMaskDirective),
+                            multi: true,
+                        },
+                    ],
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"numeric-mask.directive.js","sourceRoot":"","sources":["../../../../../projects/angular-components/numeric-mask/src/lib/numeric-mask/numeric-mask.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, effect, ElementRef, forwardRef, inject, input, OnInit, Renderer2 } from '@angular/core';\nimport {\n    AbstractControl,\n    ControlValueAccessor,\n    NG_VALIDATORS,\n    NG_VALUE_ACCESSOR,\n    ValidationErrors,\n    Validator,\n} from '@angular/forms';\n\nimport { LocaleService } from '@seniorsistemas/angular-components/locale';\nimport BigNumber from 'bignumber.js';\n\n/**\n * Numeric mask directive with internationalization support.\n *\n * Formats numeric values according to the specified locale, applying\n * appropriate thousand and decimal separators, with support for negative values,\n * min/max decimal places control, and scientific notation.\n *\n * @example\n * ```html\n * <input\n *   type=\"text\"\n *   sNumericMask\n *   [locale]=\"'pt-BR'\"\n *   [minDecimalPlaces]=\"2\"\n *   [maxDecimalPlaces]=\"2\"\n *   [allowNegative]=\"true\"\n *   [(ngModel)]=\"value\"\n * />\n * ```\n */\n@Directive({\n    selector: '[sNumericMask]',\n    standalone: true,\n    host: {\n        '(input)': 'onInput($event)',\n        '(focus)': 'onFocus()',\n        '(blur)': 'onBlur()',\n        '(paste)': 'onPaste($event)',\n        '(keydown)': 'onKeyDown($event)',\n        '(keypress)': 'onKeyPress($event)',\n        '[style.text-align]': 'textAlign()',\n    },\n    providers: [\n        {\n            provide: NG_VALUE_ACCESSOR,\n            useExisting: forwardRef(() => NumericMaskDirective),\n            multi: true,\n        },\n        {\n            provide: NG_VALIDATORS,\n            useExisting: forwardRef(() => NumericMaskDirective),\n            multi: true,\n        },\n    ],\n})\nexport class NumericMaskDirective implements OnInit, ControlValueAccessor, Validator {\n    /**\n     * Locale for formatting (e.g. 'pt-BR', 'en-US', 'de-DE')\n     * If not provided, uses the locale from LocaleService\n     */\n    public locale = input<string | undefined>(undefined);\n\n    /**\n     * Minimum number of decimal places to display\n     * @default 0\n     */\n    public minDecimalPlaces = input(0);\n\n    /**\n     * Maximum number of decimal places allowed\n     * @default 10\n     */\n    public maxDecimalPlaces = input(10);\n\n    /**\n     * Allows negative values\n     * @default false\n     */\n    public allowNegative = input(false);\n\n    /**\n     * Enables scientific notation support\n     * @default true\n     */\n    public allowScientificNotation = input(true);\n\n    /**\n     * Text alignment in input\n     * @default 'right'\n     */\n    public textAlign = input<'left' | 'right'>('right');\n\n    /**\n     * Minimum value allowed\n     */\n    public min = input<number | undefined>(undefined);\n\n    /**\n     * Maximum value allowed\n     */\n    public max = input<number | undefined>(undefined);\n\n    private readonly elementRef = inject(ElementRef<HTMLInputElement>);\n    private readonly renderer = inject(Renderer2);\n    private readonly localeService = inject(LocaleService, { optional: true });\n\n    private onChange: (value: string | null) => void = () => {};\n    private onTouched: () => void = () => {};\n    private decimalSeparator = ',';\n    private thousandSeparator = '.';\n    private currentLocale = 'pt-BR';\n    private lastModelValue: string | null = null;\n\n    constructor() {\n        effect(() => {\n            const inputLocale = this.locale();\n\n            if (inputLocale) {\n                this.currentLocale = inputLocale;\n                this.updateSeparators();\n            }\n        });\n    }\n\n    public ngOnInit(): void {\n        if (this.minDecimalPlaces() > this.maxDecimalPlaces()) {\n            throw new Error(\n                `NumericMaskDirective: minDecimalPlaces (${this.minDecimalPlaces()}) cannot be greater than maxDecimalPlaces (${this.maxDecimalPlaces()})`\n            );\n        }\n\n        if (this.locale()) {\n            this.currentLocale = this.locale()!;\n            this.updateSeparators();\n            this.setInputMode();\n        } else if (this.localeService) {\n            this.localeService.get().subscribe(() => {\n                this.currentLocale = this.localeService!.getLocaleOptions()?.locale || 'pt-BR';\n                this.updateSeparators();\n                this.setInputMode();\n            });\n        } else {\n            this.updateSeparators();\n            this.setInputMode();\n        }\n    }\n\n    /**\n     * Listener for input events (typing)\n     */\n    public onInput(event: Event): void {\n        const input = event.target as HTMLInputElement;\n        let value = input.value;\n        value = this.normalizeSeparators(value);\n        this.processInputValue(value);\n    }\n\n    /**\n     * Listener for focus events (gaining focus)\n     */\n    public onFocus(): void {\n        const input = this.elementRef.nativeElement;\n        const currentValue = input.value;\n\n        if (!currentValue || currentValue.trim() === '') {\n            return;\n        }\n\n        if (this.lastModelValue) {\n            const displayValue = this.lastModelValue.replace('.', this.decimalSeparator);\n            this.renderer.setProperty(input, 'value', displayValue);\n            input.select();\n            return;\n        }\n\n        const modelValue = this.toModelValue(currentValue);\n\n        if (!modelValue) {\n            return;\n        }\n\n        const displayValue = modelValue.replace('.', this.decimalSeparator);\n        this.renderer.setProperty(input, 'value', displayValue);\n        input.select();\n    }\n\n    /**\n     * Listener for blur events (focus loss)\n     */\n    public onBlur(): void {\n        this.onTouched();\n\n        const currentValue = this.elementRef.nativeElement.value;\n\n        if (!currentValue || currentValue.trim() === '') {\n            this.onChange(null);\n            this.lastModelValue = null;\n            return;\n        }\n\n        const modelValue = this.toModelValue(currentValue);\n\n        if (!modelValue) {\n            this.onChange(null);\n            this.lastModelValue = null;\n            return;\n        }\n\n        this.lastModelValue = modelValue;\n        const displayValue = this.fromModelValue(modelValue);\n        this.renderer.setProperty(this.elementRef.nativeElement, 'value', displayValue);\n        this.onChange(modelValue);\n    }\n\n    /**\n     * Listener for paste events (clipboard)\n     */\n    public onPaste(event: ClipboardEvent): void {\n        event.preventDefault();\n\n        const pastedText = event.clipboardData?.getData('text') || '';\n        let value = this.parseClipboardValue(pastedText);\n\n        this.processInputValue(value);\n    }\n\n    /**\n     * Listener for special keys (+ and -)\n     */\n    public onKeyDown(event: KeyboardEvent): void {\n        const key = event.key;\n\n        if (key === '-' || key === '+') {\n            const input = this.elementRef.nativeElement;\n            const value = input.value;\n            const cursorPosition = input.selectionStart || 0;\n\n            if (key === '-' && this.allowScientificNotation()) {\n                const charBeforeCursor = value[cursorPosition - 1];\n                if (charBeforeCursor === 'e' || charBeforeCursor === 'E') {\n                    return;\n                }\n            }\n\n            event.preventDefault();\n            if (!this.allowNegative()) {\n                return;\n            }\n\n            this.toggleSign(value, key === '-');\n        }\n    }\n\n    /**\n     * Listener for keypress to block invalid characters\n     */\n    public onKeyPress(event: KeyboardEvent): void {\n        const key = event.key;\n        const input = this.elementRef.nativeElement;\n        const cursorPosition = input.selectionStart || 0;\n        const value = input.value;\n\n        if ((key === '-' || key === '+') && this.allowScientificNotation()) {\n            const charBeforeCursor = value[cursorPosition - 1];\n            if (charBeforeCursor === 'e' || charBeforeCursor === 'E') {\n                return;\n            }\n        }\n\n        if (key === '+' || key === '-') {\n            event.preventDefault();\n            return;\n        }\n\n        const isDigit = /^[0-9]$/.test(key);\n        const isLocaleDecimalSeparator = key === this.decimalSeparator;\n        const isOtherSeparator = (key === ',' || key === '.') && key !== this.decimalSeparator;\n        const isScientificNotation = (key === 'e' || key === 'E') && this.allowScientificNotation();\n        const isControlKey = event.ctrlKey || event.metaKey || event.altKey;\n        const isSpecialKey = [\n            'Backspace',\n            'Tab',\n            'Enter',\n            'Escape',\n            'ArrowLeft',\n            'ArrowRight',\n            'Delete',\n            'Home',\n            'End',\n        ].includes(key);\n\n        if (isOtherSeparator) {\n            event.preventDefault();\n            return;\n        }\n\n        if (isScientificNotation) {\n            if (value.includes('e') || value.includes('E')) {\n                event.preventDefault();\n                return;\n            }\n\n            const charBeforeCursor = value[cursorPosition - 1];\n            if (!charBeforeCursor || !/^[0-9]$/.test(charBeforeCursor)) {\n                event.preventDefault();\n                return;\n            }\n        }\n\n        if (!isDigit && !isLocaleDecimalSeparator && !isScientificNotation && !isControlKey && !isSpecialKey) {\n            event.preventDefault();\n        }\n    }\n\n    /**\n     * Updates separators according to the locale\n     * @private\n     */\n    private updateSeparators(): void {\n        const formatted = new Intl.NumberFormat(this.currentLocale).format(1234.5);\n\n        this.thousandSeparator = formatted[1];\n        this.decimalSeparator = formatted[5];\n    }\n\n    /**\n     * Processes input value and updates the input and model\n     * @private\n     */\n    private processInputValue(value: string): void {\n        if (!this.decimalSeparator || !this.thousandSeparator) {\n            this.updateSeparators();\n        }\n\n        this.renderer.setProperty(this.elementRef.nativeElement, 'value', value);\n\n        const modelValue = this.toModelValue(value);\n\n        // During typing, clear the stored model value so onFocus will recalculate\n        this.lastModelValue = null;\n\n        this.onChange(modelValue);\n    }\n\n    /**\n     * Sets inputmode for numeric keyboard on mobile devices\n     * @private\n     */\n    private setInputMode(): void {\n        this.renderer.setAttribute(this.elementRef.nativeElement, 'inputmode', 'decimal');\n        this.renderer.setAttribute(this.elementRef.nativeElement, 'autocomplete', 'off');\n    }\n\n    /**\n     * Removes separators from a formatted value\n     * @private\n     */\n    private removeSeparators(value: string): string {\n        const thousandRegex = new RegExp(`\\\\${this.escapeRegex(this.thousandSeparator)}`, 'g');\n        return value.replace(thousandRegex, '');\n    }\n\n    /**\n     * Strips unnecessary trailing zeros from decimal part\n     * @private\n     */\n    private stripTrailingZeros(value: string): string {\n        const parts = value.split(this.decimalSeparator);\n        if (parts.length === 2) {\n            const decimalPart = parts[1].replace(/0+$/, '');\n            return decimalPart.length > 0 ? parts[0] + this.decimalSeparator + decimalPart : parts[0];\n        }\n        return value;\n    }\n\n    /**\n     * Normalizes separators during typing\n     * @private\n     */\n    private normalizeSeparators(value: string): string {\n        value = this.removeSeparators(value);\n\n        if (this.decimalSeparator === ',') {\n            value = value.replace(/\\./g, ',');\n        } else if (this.decimalSeparator === '.') {\n            value = value.replace(/,/g, '.');\n        }\n\n        const parts = value.split(this.decimalSeparator);\n        if (parts.length > 2) {\n            value = parts[0] + this.decimalSeparator + parts.slice(1).join('');\n        }\n\n        return value;\n    }\n\n    /**\n     * Escapes special characters for use in regex\n     * @private\n     */\n    private escapeRegex(str: string): string {\n        return str.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');\n    }\n\n    /**\n     * Truncates a number to the specified decimal places (never rounds)\n     * @private\n     */\n    private truncateToDecimalPlaces(bigNumber: BigNumber, decimalPlaces: number): BigNumber {\n        if (decimalPlaces < 0) {\n            return bigNumber;\n        }\n        const multiplier = new BigNumber(10).pow(decimalPlaces);\n        return bigNumber.multipliedBy(multiplier).integerValue(BigNumber.ROUND_DOWN).dividedBy(multiplier);\n    }\n\n    /**\n     * Checks if the value has excessive decimal places\n     * @private\n     */\n    private hasExcessiveDecimalPlaces(value: string): boolean {\n        const parts = value.split(this.decimalSeparator);\n\n        if (parts.length > 1) {\n            const decimalPart = parts[1].replace(/[^0-9]/g, '');\n            return decimalPart.length > this.maxDecimalPlaces();\n        }\n\n        return false;\n    }\n\n    /**\n     * Clears the input and notifies the model\n     * @private\n     */\n    private clearInput(): void {\n        this.renderer.setProperty(this.elementRef.nativeElement, 'value', '');\n        this.lastModelValue = null;\n        this.onChange(null);\n    }\n\n    /**\n     * Parses a string value to its numeric representation, handling separators and sign\n     * Returns BigNumber to preserve full precision and optional number conversion\n     * @private\n     */\n    private parseStringToValue(value: string): { bigNumber: BigNumber; numeric: number; isNegative: boolean } {\n        const isNegative = value.startsWith('-');\n        let numericStr = value\n            .replace(/^-/, '')\n            .replace(new RegExp(`\\\\${this.thousandSeparator}`, 'g'), '')\n            .replace(new RegExp(`\\\\${this.decimalSeparator}`, 'g'), '.');\n\n        if (numericStr === '.' || numericStr === '') {\n            numericStr = '0';\n        } else if (numericStr.startsWith('.')) {\n            numericStr = '0' + numericStr;\n        }\n\n        let bigNumber = new BigNumber(numericStr);\n        if (bigNumber.isNaN()) {\n            bigNumber = new BigNumber(0);\n        }\n\n        if (isNegative && this.allowNegative()) {\n            bigNumber = bigNumber.negated();\n        }\n\n        return { bigNumber, numeric: bigNumber.toNumber(), isNegative };\n    }\n\n    /**\n     * Formats a numeric value according to the locale\n     * Truncates (never rounds) to maxDecimalPlaces for display purposes only\n     * @private\n     */\n    private formatNumeric(numeric: number | BigNumber): string {\n        let bigNumeric = numeric instanceof BigNumber ? numeric : new BigNumber(numeric);\n        const truncatedValue = this.truncateToDecimalPlaces(bigNumeric, this.maxDecimalPlaces());\n        const valueStr = truncatedValue.toFixed(this.maxDecimalPlaces());\n        let formattedValue = valueStr.replace('.', this.decimalSeparator);\n        const parts = formattedValue.split(this.decimalSeparator);\n        const integerPart = parts[0];\n        const decimalPart = parts[1] || '';\n        const formattedInteger = new Intl.NumberFormat(this.currentLocale).format(\n            parseInt(integerPart, 10) || 0\n        ).split(this.decimalSeparator)[0];\n        const minDecimal = Math.max(this.minDecimalPlaces(), decimalPart.replace(/0+$/, '').length || 0);\n        const finalDecimal = decimalPart.padEnd(minDecimal, '0');\n        return formattedInteger + this.decimalSeparator + finalDecimal;\n    }\n\n    /**\n     * Formats the value according to the locale\n     * @private\n     */\n    private formatValue(value: string): string {\n        if (!value || value.trim() === '') {\n            return '';\n        }\n        const { numeric } = this.parseStringToValue(value);\n        return this.formatNumeric(numeric);\n    }\n\n    /**\n     * Converts the formatted value to the model format (international standard string)\n     * Always returns decimal notation, never scientific notation\n     * Stores the full precision value without truncation\n     * @private\n     */\n    private toModelValue(formattedValue: string): string | null {\n        if (!formattedValue || formattedValue.trim() === '') {\n            return null;\n        }\n        const { bigNumber } = this.parseStringToValue(formattedValue);\n        return bigNumber.toFixed();\n    }\n\n    /**\n     * Converts the model value to display format\n     * @private\n     */\n    private fromModelValue(modelValue: string | null): string {\n        if (modelValue === null || modelValue === undefined || modelValue === '') {\n            return '';\n        }\n        const bigNumber = new BigNumber(modelValue);\n        if (bigNumber.isNaN()) {\n            return '';\n        }\n        return this.formatNumeric(bigNumber);\n    }\n\n    /**\n     * Processes pasted value from clipboard\n     * Converts scientific notation to decimal using BigNumber\n     * @private\n     */\n    private parseClipboardValue(text: string): string {\n        if (this.allowScientificNotation() && /[eE]/.test(text)) {\n            try {\n                const bigNumeric = new BigNumber(text);\n                if (!bigNumeric.isNaN()) {\n                    text = bigNumeric.toFixed();\n                }\n            } catch {\n                void 0;\n            }\n        }\n        return this.normalizeSeparators(text);\n    }\n\n    /**\n     * Toggles the sign (- or +) of a value\n     * @private\n     */\n    private toggleSign(value: string, makeNegative: boolean): void {\n        const input = this.elementRef.nativeElement;\n        let newValue = value;\n\n        if (makeNegative && !newValue.startsWith('-')) {\n            newValue = '-' + newValue;\n        } else if (!makeNegative && newValue.startsWith('-')) {\n            newValue = newValue.substring(1);\n        } else {\n            return;\n        }\n\n        this.renderer.setProperty(input, 'value', newValue);\n        const modelValue = this.toModelValue(newValue);\n        this.lastModelValue = null;\n        this.onChange(modelValue);\n    }\n\n    public writeValue(value: string | null): void {\n        if (!this.decimalSeparator || !this.thousandSeparator) {\n            this.updateSeparators();\n        }\n        const hasFocus = document.activeElement === this.elementRef.nativeElement;\n        if (hasFocus) {\n            const formattedValue = this.fromModelValue(value);\n            const rawValue = this.stripTrailingZeros(this.removeSeparators(formattedValue));\n            this.renderer.setProperty(this.elementRef.nativeElement, 'value', rawValue);\n        } else {\n            const formattedValue = this.fromModelValue(value);\n            this.renderer.setProperty(this.elementRef.nativeElement, 'value', formattedValue);\n        }\n    }\n\n    public registerOnChange(fn: (value: string | null) => void): void {\n        this.onChange = fn;\n    }\n\n    public registerOnTouched(fn: () => void): void {\n        this.onTouched = fn;\n    }\n\n    public setDisabledState(isDisabled: boolean): void {\n        this.renderer.setProperty(this.elementRef.nativeElement, 'disabled', isDisabled);\n    }\n\n    public validate(control: AbstractControl): ValidationErrors | null {\n        const value = control.value;\n\n        if (!value) {\n            return null;\n        }\n\n        const numericValue = parseFloat(value);\n\n        if (isNaN(numericValue)) {\n            return null;\n        }\n\n        if (!this.allowNegative() && numericValue < 0) {\n            return { negativeNotAllowed: true };\n        }\n\n        const minValue = this.min();\n        if (minValue !== undefined && numericValue < minValue) {\n            return {\n                min: {\n                    min: minValue,\n                    actual: numericValue,\n                },\n            };\n        }\n\n        const maxValue = this.max();\n        if (maxValue !== undefined && numericValue > maxValue) {\n            return {\n                max: {\n                    max: maxValue,\n                    actual: numericValue,\n                },\n            };\n        }\n\n        const decimalPart = value.split('.')[1];\n\n        if (decimalPart && decimalPart.length > this.maxDecimalPlaces()) {\n            return {\n                excessiveDecimalPlaces: {\n                    max: this.maxDecimalPlaces(),\n                    actual: decimalPart.length,\n                },\n            };\n        }\n\n        return null;\n    }\n}\n\n"]}