@seniorsistemas/angular-components 19.1.0 → 19.2.0

package/bignumber-input/lib/bignumber-input/bignumber-input.directive.d.ts

@@ -1,9 +1,9 @@
-import { ElementRef, EventEmitter, KeyValueDiffers, OnChanges, OnInit, SimpleChanges } from '@angular/core';
-import { CurrencyMaskDirective } from 'ng2-currency-mask';
-import { LocaleService } from '@seniorsistemas/angular-components/locale';
+import { OnInit, OnChanges, SimpleChanges } from '@angular/core';
+import { AbstractControl, ValidationErrors } from '@angular/forms';
+import { NumericMaskDirective } from '@seniorsistemas/angular-components/numeric-mask';
 import * as i0 from "@angular/core";
 /**
- * @deprecated Should use 'AlignmentOptions' from @seniorsistemas/ng2-currency-mask instead
+ * @deprecated Este enum não tem mais efeito. O alinhamento do campo é sempre `'right'`.
  */
 export declare enum BignumberAlignmentOption {
     RIGHT = "right",
@@ -22,66 +22,99 @@ export declare enum BignumberAlignmentOption {
  *
  * @category Inputs
  */
-export declare class BignumberInputDirective extends CurrencyMaskDirective implements OnInit, OnChanges {
-    private readonly localeService;
+export declare class BignumberInputDirective extends NumericMaskDirective implements OnInit, OnChanges {
     /**
-     * @description Número total de dígitos significativos aceitos pelo campo.
+     * @description Número total de dígitos significativos aceitos pelo campo (parte inteira + parte decimal).
+     *
+     * Durante a digitação, o campo limita fisicamente o número de caracteres via `maxLength`.
+     * Ao colar um valor que ultrapasse o limite, o evento `pasteRejected` é emitido e a colagem é cancelada.
+     * Após sair do campo (blur) ou ao submeter o formulário, se o valor ultrapassar `precision`,
+     * o campo ficará inválido com o erro `exceedsPrecision: { precision, actual }`.
      *
      * @default 15
      */
-    precision: number;
+    precision: import("@angular/core").InputSignal<number>;
     /**
+     * @deprecated Use `minDecimalPlaces` e `maxDecimalPlaces` ao invés deste.
      * @description Número de casas decimais exibidas e aceitas pelo campo.
+     * Quando informado, repassa o valor para `minDecimalPlaces` e `maxDecimalPlaces`.
+     *
+     * @default 0
+     */
+    scale: import("@angular/core").InputSignal<number>;
+    /**
+     * @description Número mínimo de casas decimais exibidas.
+     *
+     * @default 0
+     */
+    minDecimalPlaces: import("@angular/core").ModelSignal<number>;
+    /**
+     * @description Número máximo de casas decimais aceitas.
      *
      * @default 0
      */
-    scale: number;
+    maxDecimalPlaces: import("@angular/core").ModelSignal<number>;
     /**
      * @description Separador decimal personalizado. Quando não informado,
      * utiliza o separador definido pelo locale ativo da aplicação.
      */
-    decimalSeparator?: string;
+    decimalSeparator: import("@angular/core").ModelSignal<string>;
+    /**
+     * @deprecated Use `thousandSeparator` ao invés deste.
+     * @description Separador de milhar personalizado. Recomenda-se migrar para `thousandSeparator`.
+     */
+    thousandsSeparator: import("@angular/core").InputSignal<string | undefined>;
     /**
      * @description Separador de milhar personalizado. Quando não informado,
      * utiliza o separador definido pelo locale ativo da aplicação.
      */
-    thousandsSeparator?: string;
+    thousandSeparator: import("@angular/core").ModelSignal<string>;
     /**
-     * @description Alinhamento do conteúdo do campo. Aceita `'left'` ou `'right'`.
-     *
-     * @default 'left'
+     * @deprecated Este input não tem mais efeito e pode ser removido.
+     * O alinhamento do campo é sempre `'right'`, conforme o comportamento padrão da máscara numérica.
      */
-    alignTo: 'left' | 'right';
+    alignTo: import("@angular/core").InputSignal<"right" | "left">;
     /**
      * @description Permite a entrada de valores negativos.
      *
      * @default true
      */
-    allowNegative: boolean;
+    allowNegative: import("@angular/core").InputSignal<boolean>;
     /**
      * @description Texto de placeholder exibido quando o campo está vazio.
      */
-    placeholder?: string;
+    placeholder: import("@angular/core").ModelSignal<string | undefined>;
     maxLength?: number;
     /**
-     * @description Emitido quando uma colé (paste) é rejeitada pela validação do campo.
+     * @description Emitido quando uma colagem (paste) é rejeitada pela validação do campo.
      * Emite a string colada que foi recusada.
      */
-    pasteRejected: EventEmitter<string>;
-    private readonly regex;
-    constructor(_elementRef: ElementRef, _keyValueDiffers: KeyValueDiffers, localeService: LocaleService);
+    pasteRejected: import("@angular/core").OutputEmitterRef<string>;
+    private _decimalSeparatorExplicit;
+    private _thousandSeparatorExplicit;
+    constructor();
     ngOnInit(): void;
     ngOnChanges(changes: SimpleChanges): void;
+    /**
+     * Overrides base paste handler to add precision validation.
+     * If the pasted value exceeds `precision` digits, the paste is rejected.
+     */
     onPaste(event: ClipboardEvent): void;
     /**
-     * Update the options values according to the directive input values.
+     * Overrides locale-derived separators with explicitly set inputs, if provided.
+     * If no explicit separator is set, the locale-derived value is used.
+     */
+    protected updateSeparators(): void;
+    /**
+     * Overrides base validator to add precision validation.
+     * If the total number of significant digits exceeds `precision`, returns an `exceedsPrecision` error.
      */
-    private updateVariables;
+    validate(control: AbstractControl): ValidationErrors | null;
     /**
      * Responsible to calculate the field maximum length considering the separators.
      */
     private calculateMaxLength;
-    private onLocaleService;
+    private updatePlaceholder;
     static ɵfac: i0.ɵɵFactoryDeclaration<BignumberInputDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<BignumberInputDirective, "input[sBignumberInput]", never, { "precision": { "alias": "precision"; "required": false; }; "scale": { "alias": "scale"; "required": false; }; "decimalSeparator": { "alias": "decimalSeparator"; "required": false; }; "thousandsSeparator": { "alias": "thousandsSeparator"; "required": false; }; "alignTo": { "alias": "alignTo"; "required": false; }; "allowNegative": { "alias": "allowNegative"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; }, { "pasteRejected": "pasteRejected"; }, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BignumberInputDirective, "input[sBignumberInput]", never, { "precision": { "alias": "precision"; "required": false; "isSignal": true; }; "scale": { "alias": "scale"; "required": false; "isSignal": true; }; "minDecimalPlaces": { "alias": "minDecimalPlaces"; "required": false; "isSignal": true; }; "maxDecimalPlaces": { "alias": "maxDecimalPlaces"; "required": false; "isSignal": true; }; "decimalSeparator": { "alias": "decimalSeparator"; "required": false; "isSignal": true; }; "thousandsSeparator": { "alias": "thousandsSeparator"; "required": false; "isSignal": true; }; "thousandSeparator": { "alias": "thousandSeparator"; "required": false; "isSignal": true; }; "alignTo": { "alias": "alignTo"; "required": false; "isSignal": true; }; "allowNegative": { "alias": "allowNegative"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; }, { "minDecimalPlaces": "minDecimalPlacesChange"; "maxDecimalPlaces": "maxDecimalPlacesChange"; "decimalSeparator": "decimalSeparatorChange"; "thousandSeparator": "thousandSeparatorChange"; "placeholder": "placeholderChange"; "pasteRejected": "pasteRejected"; }, never, never, false, never>;
 }

package/dynamic-form/dynamic-form/components/lookup/lookup.component.d.ts

@@ -1,14 +1,12 @@
 import { ChangeDetectorRef, EventEmitter, OnChanges, OnDestroy, OnInit, SimpleChanges } from '@angular/core';
 import { ControlValueAccessor, FormGroup } from '@angular/forms';
 import { TranslateService } from '@ngx-translate/core';
-import { MaskConfig } from '@seniorsistemas/ng2-currency-mask';
+import { LoadingStateIndicators } from '@seniorsistemas/angular-components/loading-state';
+import { LocalizedBignumberOptions } from '@seniorsistemas/angular-components/locale';
 import { HotkeysService } from 'angular2-hotkeys';
 import { SortMeta } from 'primeng/api';
 import { AutoComplete, AutoCompleteCompleteEvent } from 'primeng/autocomplete';
 import { Table, TableLazyLoadEvent } from 'primeng/table';
-import { DefaultFilter } from './types/default-filter';
-import { LabelOptions } from './types/label-options';
-import { LoadingStateIndicators } from '@seniorsistemas/angular-components/loading-state';
 import { DynamicStructure } from '../../configurations/structure/structure';
 import { BignumberFieldConfig } from '../../form-field/configurations/fields/bignumber-field';
 import { CurrencyFieldConfig } from '../../form-field/configurations/fields/currency-field';
@@ -17,6 +15,8 @@ import { NumberFieldConfig } from '../../form-field/configurations/fields/number
 import { SelectFieldConfig } from '../../form-field/configurations/fields/select-field';
 import { TextFieldConfig } from '../../form-field/configurations/fields/text-field';
 import { LookupSearchRequest } from './models/lookup-api.model';
+import { DefaultFilter } from './types/default-filter';
+import { LabelOptions } from './types/label-options';
 import * as i0 from "@angular/core";
 export declare class LookupComponent implements ControlValueAccessor, OnChanges, OnInit, OnDestroy {
     private readonly hotkeysService;
@@ -128,10 +128,10 @@ export declare class LookupComponent implements ControlValueAccessor, OnChanges,
     getColWidth(label: string): string;
     getScale(scale: any): number;
     private isFunction;
-    getDoubleMaskConfig(col: NumberFieldConfig | BignumberFieldConfig): MaskConfig;
-    getMoneyMaskConfig(col: CurrencyFieldConfig): MaskConfig;
-    getIntegerMaskConfig(col: BignumberFieldConfig | NumberFieldConfig): MaskConfig;
-    getNumberMaskConfig(col: NumberFieldConfig | BignumberFieldConfig): MaskConfig;
+    getDoubleMaskConfig(col: NumberFieldConfig | BignumberFieldConfig): LocalizedBignumberOptions;
+    getMoneyMaskConfig(col: CurrencyFieldConfig): LocalizedBignumberOptions;
+    getIntegerMaskConfig(col: BignumberFieldConfig | NumberFieldConfig): LocalizedBignumberOptions;
+    getNumberMaskConfig(col: NumberFieldConfig | BignumberFieldConfig): LocalizedBignumberOptions;
     parseValueMaskValue(col: DynamicType, rowData: any): any;
     fieldHasMask(field: DynamicType): field is NumberFieldConfig | BignumberFieldConfig | TextFieldConfig;
     onTableRowDoubleClick(rowData: any): void;

package/esm2022/bignumber-input/lib/bignumber-input/bignumber-input.directive.mjs

@@ -1,11 +1,9 @@
-import { Directive, EventEmitter, forwardRef, HostBinding, HostListener, Input, Output, } from '@angular/core';
+import { Directive, forwardRef, input, model, output } from '@angular/core';
 import { NG_VALUE_ACCESSOR } from '@angular/forms';
-import { CurrencyMaskDirective } from 'ng2-currency-mask';
-import { first } from 'rxjs/operators';
+import { NumericMaskDirective } from '@seniorsistemas/angular-components/numeric-mask';
 import * as i0 from "@angular/core";
-import * as i1 from "@seniorsistemas/angular-components/locale";
 /**
- * @deprecated Should use 'AlignmentOptions' from @seniorsistemas/ng2-currency-mask instead
+ * @deprecated Este enum não tem mais efeito. O alinhamento do campo é sempre `'right'`.
  */
 export var BignumberAlignmentOption;
 (function (BignumberAlignmentOption) {
@@ -25,134 +23,198 @@ export var BignumberAlignmentOption;
  *
  * @category Inputs
  */
-export class BignumberInputDirective extends CurrencyMaskDirective {
-    localeService;
+export class BignumberInputDirective extends NumericMaskDirective {
     /**
-     * @description Número total de dígitos significativos aceitos pelo campo.
+     * @description Número total de dígitos significativos aceitos pelo campo (parte inteira + parte decimal).
+     *
+     * Durante a digitação, o campo limita fisicamente o número de caracteres via `maxLength`.
+     * Ao colar um valor que ultrapasse o limite, o evento `pasteRejected` é emitido e a colagem é cancelada.
+     * Após sair do campo (blur) ou ao submeter o formulário, se o valor ultrapassar `precision`,
+     * o campo ficará inválido com o erro `exceedsPrecision: { precision, actual }`.
      *
      * @default 15
      */
-    precision = 15;
+    precision = input(15);
     /**
+     * @deprecated Use `minDecimalPlaces` e `maxDecimalPlaces` ao invés deste.
      * @description Número de casas decimais exibidas e aceitas pelo campo.
+     * Quando informado, repassa o valor para `minDecimalPlaces` e `maxDecimalPlaces`.
      *
      * @default 0
      */
-    scale = 0;
+    scale = input(0);
+    /**
+     * @description Número mínimo de casas decimais exibidas.
+     *
+     * @default 0
+     */
+    minDecimalPlaces = model(0);
+    /**
+     * @description Número máximo de casas decimais aceitas.
+     *
+     * @default 0
+     */
+    maxDecimalPlaces = model(0);
     /**
      * @description Separador decimal personalizado. Quando não informado,
      * utiliza o separador definido pelo locale ativo da aplicação.
      */
-    decimalSeparator;
+    decimalSeparator = model(',');
+    /**
+     * @deprecated Use `thousandSeparator` ao invés deste.
+     * @description Separador de milhar personalizado. Recomenda-se migrar para `thousandSeparator`.
+     */
+    thousandsSeparator = input(undefined);
     /**
      * @description Separador de milhar personalizado. Quando não informado,
      * utiliza o separador definido pelo locale ativo da aplicação.
      */
-    thousandsSeparator;
+    thousandSeparator = model('.');
     /**
-     * @description Alinhamento do conteúdo do campo. Aceita `'left'` ou `'right'`.
-     *
-     * @default 'left'
+     * @deprecated Este input não tem mais efeito e pode ser removido.
+     * O alinhamento do campo é sempre `'right'`, conforme o comportamento padrão da máscara numérica.
      */
-    alignTo = 'left';
+    alignTo = input('right');
     /**
      * @description Permite a entrada de valores negativos.
      *
      * @default true
      */
-    allowNegative = true;
+    allowNegative = input(true);
     /**
      * @description Texto de placeholder exibido quando o campo está vazio.
      */
-    placeholder;
+    placeholder = model(undefined);
     maxLength;
     /**
-     * @description Emitido quando uma colé (paste) é rejeitada pela validação do campo.
+     * @description Emitido quando uma colagem (paste) é rejeitada pela validação do campo.
      * Emite a string colada que foi recusada.
      */
-    pasteRejected = new EventEmitter();
-    regex = /\d/;
-    //TODO: Ajuste no ng2-currency-mask para utilizar esse Código (aplicado na tarefa: SDS-305)
-    // private readonly _angularComponentsLocaleService: LocaleService;
-    // constructor(injector: Injector) {
-    // super(injector);
-    // this._angularComponentsLocaleService = injector.get(LocaleService);
-    // this.onLocaleService();
-    // }
-    //TODO:  Remover esse constructor
-    constructor(_elementRef, _keyValueDiffers, localeService) {
-        super({ align: '', allowNegative: true, decimal: '', precision: 0, prefix: '', suffix: '', thousands: '' }, _elementRef, _keyValueDiffers);
-        this.localeService = localeService;
-        this.onLocaleService();
+    pasteRejected = output();
+    _decimalSeparatorExplicit = false;
+    _thousandSeparatorExplicit = false;
+    constructor() {
+        super();
     }
     ngOnInit() {
-        this.updateVariables();
         super.ngOnInit();
+        this.updatePlaceholder();
     }
+    // ngOnChanges handles all signal writes reactively, avoiding the need for
+    // effect() with allowSignalWrites. The decimalSeparator/thousandSeparator inputs
+    // have truthy defaults, so ngOnChanges is necessary to distinguish "parent bound this"
+    // from "it's just the default value".
     ngOnChanges(changes) {
-        const placeholderChange = changes['placeholder']?.currentValue;
-        if (!placeholderChange && this.scale) {
-            this.placeholder = `0${this.decimalSeparator}${''.padEnd(this.scale, '0')}`;
+        if (changes['decimalSeparator'] && this.decimalSeparator()) {
+            this._decimalSeparatorExplicit = true;
+        }
+        if (changes['thousandSeparator'] && this.thousandSeparator()) {
+            this._thousandSeparatorExplicit = true;
         }
-        const configChanged = changes['scale'] ||
+        if (changes['thousandsSeparator']) {
+            const val = this.thousandsSeparator();
+            if (val !== undefined) {
+                this._thousandSeparatorExplicit = true;
+                this.thousandSeparator.set(val);
+            }
+        }
+        if (changes['scale']) {
+            this.minDecimalPlaces.set(this.scale());
+            this.maxDecimalPlaces.set(this.scale());
+        }
+        if (changes['scale'] ||
             changes['decimalSeparator'] ||
+            changes['thousandSeparator'] ||
             changes['thousandsSeparator'] ||
-            changes['alignTo'] ||
-            changes['precision'] ||
-            changes['allowNegative'];
-        if (configChanged) {
-            this.updateVariables();
+            changes['precision']) {
+            this.calculateMaxLength();
+        }
+        if (changes['scale'] || changes['decimalSeparator']) {
+            this.updatePlaceholder();
         }
     }
+    /**
+     * Overrides base paste handler to add precision validation.
+     * If the pasted value exceeds `precision` digits, the paste is rejected.
+     */
     onPaste(event) {
         const pastedText = event.clipboardData?.getData('text') ?? '';
+        const effectiveThousandSep = this.thousandsSeparator() ?? this.thousandSeparator();
         const numericText = pastedText
-            .replace(new RegExp(`\\${this.thousandsSeparator}`, 'g'), '')
-            .replace(this.decimalSeparator, '.');
+            .replace(new RegExp(`\\${effectiveThousandSep}`, 'g'), '')
+            .replace(this.decimalSeparator(), '.');
         const [intPart, decimalPart = ''] = numericText.split('.');
-        const totalDigits = intPart.replace(/\D/g, '').length + decimalPart.slice(0, this.scale).length;
-        if (totalDigits > this.precision) {
+        const totalDigits = intPart.replace(/\D/g, '').length + decimalPart.slice(0, this.scale()).length;
+        if (totalDigits > this.precision()) {
             event.preventDefault();
             this.pasteRejected.emit(pastedText);
+            return;
         }
+        super.onPaste(event);
     }
     /**
-     * Update the options values according to the directive input values.
+     * Overrides locale-derived separators with explicitly set inputs, if provided.
+     * If no explicit separator is set, the locale-derived value is used.
      */
-    updateVariables() {
-        this.options = {
-            align: this.alignTo,
-            decimal: this.decimalSeparator,
-            thousands: this.thousandsSeparator,
-            precision: this.scale || 0,
-            prefix: '',
-            suffix: '',
-            allowNegative: this.allowNegative,
-        };
+    updateSeparators() {
+        const explicitDecimal = this._decimalSeparatorExplicit ? this.decimalSeparator() : undefined;
+        const explicitThousand = this._thousandSeparatorExplicit
+            ? (this.thousandsSeparator() ?? this.thousandSeparator())
+            : undefined;
+        super.updateSeparators();
+        if (explicitDecimal !== undefined) {
+            this.decimalSeparator.set(explicitDecimal);
+        }
+        if (explicitThousand !== undefined) {
+            this.thousandSeparator.set(explicitThousand);
+        }
         this.calculateMaxLength();
+        this.updatePlaceholder();
+    }
+    /**
+     * Overrides base validator to add precision validation.
+     * If the total number of significant digits exceeds `precision`, returns an `exceedsPrecision` error.
+     */
+    validate(control) {
+        const baseErrors = super.validate(control);
+        if (!control.value || !this.precision()) {
+            return baseErrors ?? null;
+        }
+        const numericStr = String(control.value).replace('-', '');
+        const [intPart, decimalPart = ''] = numericStr.split('.');
+        const totalDigits = intPart.length + decimalPart.length;
+        if (totalDigits > this.precision()) {
+            return {
+                ...baseErrors,
+                exceedsPrecision: {
+                    precision: this.precision(),
+                    actual: totalDigits,
+                },
+            };
+        }
+        return baseErrors ?? null;
     }
     /**
      * Responsible to calculate the field maximum length considering the separators.
      */
     calculateMaxLength() {
-        const decSepLength = this.decimalSeparator?.length ?? 0;
-        const thoSepLength = this.thousandsSeparator?.length ?? 0;
+        const decSepLength = this.decimalSeparator()?.length ?? 0;
+        const effectiveThousandSep = this.thousandsSeparator() ?? this.thousandSeparator();
+        const thoSepLength = effectiveThousandSep?.length ?? 0;
         const DIGITS_GROUP_SIZE = 3;
-        let maxLength = this.precision + (this.scale ? decSepLength : 0);
-        maxLength += Math.ceil((this.precision - (this.scale ? this.scale : 0)) / DIGITS_GROUP_SIZE - 1) * thoSepLength;
+        let maxLength = this.precision() + (this.scale() ? decSepLength : 0);
+        maxLength +=
+            Math.ceil((this.precision() - (this.scale() ? this.scale() : 0)) / DIGITS_GROUP_SIZE - 1) * thoSepLength;
         this.maxLength = maxLength;
     }
-    onLocaleService() {
-        this.localeService
-            .getLocale()
-            .pipe(first())
-            .subscribe(() => {
-            this.decimalSeparator = this.decimalSeparator ?? this.localeService.getDecimalSeparator();
-            this.thousandsSeparator = this.thousandsSeparator ?? this.localeService.getGroupingSeparator();
-        });
+    updatePlaceholder() {
+        const scale = this.scale();
+        if (!this.placeholder() && scale) {
+            this.placeholder.set(`0${this.decimalSeparator()}${''.padEnd(scale, '0')}`);
+        }
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: BignumberInputDirective, deps: [{ token: i0.ElementRef }, { token: i0.KeyValueDiffers }, { token: i1.LocaleService }], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: BignumberInputDirective, selector: "input[sBignumberInput]", inputs: { precision: "precision", scale: "scale", decimalSeparator: "decimalSeparator", thousandsSeparator: "thousandsSeparator", alignTo: "alignTo", allowNegative: "allowNegative", placeholder: "placeholder" }, outputs: { pasteRejected: "pasteRejected" }, host: { listeners: { "paste": "onPaste($event)" }, properties: { "attr.placeholder": "this.placeholder", "attr.maxLength": "this.maxLength" } }, providers: [
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: BignumberInputDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.2.14", type: BignumberInputDirective, selector: "input[sBignumberInput]", inputs: { precision: { classPropertyName: "precision", publicName: "precision", isSignal: true, isRequired: false, transformFunction: null }, scale: { classPropertyName: "scale", publicName: "scale", 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 }, decimalSeparator: { classPropertyName: "decimalSeparator", publicName: "decimalSeparator", isSignal: true, isRequired: false, transformFunction: null }, thousandsSeparator: { classPropertyName: "thousandsSeparator", publicName: "thousandsSeparator", isSignal: true, isRequired: false, transformFunction: null }, thousandSeparator: { classPropertyName: "thousandSeparator", publicName: "thousandSeparator", isSignal: true, isRequired: false, transformFunction: null }, alignTo: { classPropertyName: "alignTo", publicName: "alignTo", isSignal: true, isRequired: false, transformFunction: null }, allowNegative: { classPropertyName: "allowNegative", publicName: "allowNegative", isSignal: true, isRequired: false, transformFunction: null }, placeholder: { classPropertyName: "placeholder", publicName: "placeholder", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { minDecimalPlaces: "minDecimalPlacesChange", maxDecimalPlaces: "maxDecimalPlacesChange", decimalSeparator: "decimalSeparatorChange", thousandSeparator: "thousandSeparatorChange", placeholder: "placeholderChange", pasteRejected: "pasteRejected" }, host: { properties: { "attr.placeholder": "placeholder()", "attr.maxLength": "maxLength" } }, providers: [
             {
                 provide: NG_VALUE_ACCESSOR,
                 // NOSONAR - 'BignumberInputDirective' is deprecated.
@@ -165,6 +227,10 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
             type: Directive,
             args: [{
                     selector: 'input[sBignumberInput]',
+                    host: {
+                        '[attr.placeholder]': 'placeholder()',
+                        '[attr.maxLength]': 'maxLength',
+                    },
                     providers: [
                         {
                             provide: NG_VALUE_ACCESSOR,
@@ -174,30 +240,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
                         },
                     ],
                 }]
-        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.KeyValueDiffers }, { type: i1.LocaleService }], propDecorators: { precision: [{
-                type: Input
-            }], scale: [{
-                type: Input
-            }], decimalSeparator: [{
-                type: Input
-            }], thousandsSeparator: [{
-                type: Input
-            }], alignTo: [{
-                type: Input
-            }], allowNegative: [{
-                type: Input
-            }], placeholder: [{
-                type: Input
-            }, {
-                type: HostBinding,
-                args: ['attr.placeholder']
-            }], maxLength: [{
-                type: HostBinding,
-                args: ['attr.maxLength']
-            }], pasteRejected: [{
-                type: Output
-            }], onPaste: [{
-                type: HostListener,
-                args: ['paste', ['$event']]
-            }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bignumber-input.directive.js","sourceRoot":"","sources":["../../../../../projects/angular-components/bignumber-input/src/lib/bignumber-input/bignumber-input.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    Directive,\n    ElementRef,\n    EventEmitter,\n    forwardRef,\n    HostBinding,\n    HostListener,\n    Input,\n    KeyValueDiffers,\n    OnChanges,\n    OnInit,\n    Output,\n    SimpleChanges,\n} from '@angular/core';\nimport { NG_VALUE_ACCESSOR } from '@angular/forms';\n\nimport { CurrencyMaskDirective } from 'ng2-currency-mask';\nimport { first } from 'rxjs/operators';\nimport { AlignmentOptions } from '@seniorsistemas/ng2-currency-mask';\nimport { LocaleService } from '@seniorsistemas/angular-components/locale';\n\n/**\n * @deprecated Should use 'AlignmentOptions' from @seniorsistemas/ng2-currency-mask instead\n */\nexport enum BignumberAlignmentOption {\n    RIGHT = 'right',\n    LEFT = 'left',\n}\n\n/**\n * @deprecated Utilize a diretiva `BigNumberInput` ao invés desta.\n * @description Diretiva de máscara para campos de entrada de números de grande precisão,\n * adaptada do `CurrencyMaskDirective`. Permite configurar precisão, escala,\n * separadores decimais e de milhar de acordo com o locale da aplicação.\n *\n * @example\n * ```html\n * <input sBignumberInput [precision]=\"15\" [scale]=\"2\" [allowNegative]=\"false\" />\n * ```\n *\n * @category Inputs\n */\n@Directive({\n    selector: 'input[sBignumberInput]',\n    providers: [\n        {\n            provide: NG_VALUE_ACCESSOR,\n            // NOSONAR - 'BignumberInputDirective' is deprecated.\n            useExisting: forwardRef(() => BignumberInputDirective),\n            multi: true,\n        },\n    ],\n})\nexport class BignumberInputDirective extends CurrencyMaskDirective implements OnInit, OnChanges {\n    /**\n     * @description Número total de dígitos significativos aceitos pelo campo.\n     *\n     * @default 15\n     */\n    @Input()\n    public precision = 15;\n\n    /**\n     * @description Número de casas decimais exibidas e aceitas pelo campo.\n     *\n     * @default 0\n     */\n    @Input()\n    public scale = 0;\n\n    /**\n     * @description Separador decimal personalizado. Quando não informado,\n     * utiliza o separador definido pelo locale ativo da aplicação.\n     */\n    @Input()\n    public decimalSeparator?: string;\n\n    /**\n     * @description Separador de milhar personalizado. Quando não informado,\n     * utiliza o separador definido pelo locale ativo da aplicação.\n     */\n    @Input()\n    public thousandsSeparator?: string;\n\n    /**\n     * @description Alinhamento do conteúdo do campo. Aceita `'left'` ou `'right'`.\n     *\n     * @default 'left'\n     */\n    @Input()\n    public alignTo: 'left' | 'right' = 'left';\n\n    /**\n     * @description Permite a entrada de valores negativos.\n     *\n     * @default true\n     */\n    @Input()\n    public allowNegative = true;\n\n    /**\n     * @description Texto de placeholder exibido quando o campo está vazio.\n     */\n    @Input()\n    @HostBinding('attr.placeholder')\n    public placeholder?: string;\n\n    @HostBinding('attr.maxLength')\n    public maxLength?: number;\n\n    /**\n     * @description Emitido quando uma colé (paste) é rejeitada pela validação do campo.\n     * Emite a string colada que foi recusada.\n     */\n    @Output()\n    public pasteRejected = new EventEmitter<string>();\n\n    private readonly regex = /\\d/;\n\n    //TODO: Ajuste no ng2-currency-mask para utilizar esse Código (aplicado na tarefa: SDS-305)\n    // private readonly _angularComponentsLocaleService: LocaleService;\n\n    // constructor(injector: Injector) {\n    // super(injector);\n\n    // this._angularComponentsLocaleService = injector.get(LocaleService);\n    // this.onLocaleService();\n    // }\n\n    //TODO:  Remover esse constructor\n    constructor(\n        _elementRef: ElementRef,\n        _keyValueDiffers: KeyValueDiffers,\n        private readonly localeService: LocaleService,\n    ) {\n        super(\n            { align: '', allowNegative: true, decimal: '', precision: 0, prefix: '', suffix: '', thousands: '' },\n            _elementRef,\n            _keyValueDiffers,\n        );\n\n        this.onLocaleService();\n    }\n\n    public override ngOnInit(): void {\n        this.updateVariables();\n\n        super.ngOnInit();\n    }\n\n    public ngOnChanges(changes: SimpleChanges) {\n        const placeholderChange = changes['placeholder']?.currentValue;\n        if (!placeholderChange && this.scale) {\n            this.placeholder = `0${this.decimalSeparator}${''.padEnd(this.scale, '0')}`;\n        }\n\n        const configChanged =\n            changes['scale'] ||\n            changes['decimalSeparator'] ||\n            changes['thousandsSeparator'] ||\n            changes['alignTo'] ||\n            changes['precision'] ||\n            changes['allowNegative'];\n\n        if (configChanged) {\n            this.updateVariables();\n        }\n    }\n\n    @HostListener('paste', ['$event'])\n    public onPaste(event: ClipboardEvent): void {\n        const pastedText = event.clipboardData?.getData('text') ?? '';\n        const numericText = pastedText\n            .replace(new RegExp(`\\\\${this.thousandsSeparator}`, 'g'), '')\n            .replace(this.decimalSeparator as string, '.');\n        const [intPart, decimalPart = ''] = numericText.split('.');\n        const totalDigits = intPart.replace(/\\D/g, '').length + decimalPart.slice(0, this.scale).length;\n\n        if (totalDigits > this.precision) {\n            event.preventDefault();\n            this.pasteRejected.emit(pastedText);\n        }\n    }\n\n    /**\n     * Update the options values according to the directive input values.\n     */\n    private updateVariables(): void {\n        this.options = {\n            align: this.alignTo,\n            decimal: this.decimalSeparator,\n            thousands: this.thousandsSeparator,\n            precision: this.scale || 0,\n            prefix: '',\n            suffix: '',\n            allowNegative: this.allowNegative,\n        };\n        this.calculateMaxLength();\n    }\n\n    /**\n     * Responsible to calculate the field maximum length considering the separators.\n     */\n    private calculateMaxLength(): void {\n        const decSepLength = this.decimalSeparator?.length ?? 0;\n        const thoSepLength = this.thousandsSeparator?.length ?? 0;\n\n        const DIGITS_GROUP_SIZE = 3;\n\n        let maxLength = this.precision + (this.scale ? decSepLength : 0);\n        maxLength += Math.ceil((this.precision - (this.scale ? this.scale : 0)) / DIGITS_GROUP_SIZE - 1) * thoSepLength;\n\n        this.maxLength = maxLength;\n    }\n\n    private onLocaleService(): void {\n        this.localeService\n            .getLocale()\n            .pipe(first())\n            .subscribe(() => {\n                this.decimalSeparator = this.decimalSeparator ?? this.localeService.getDecimalSeparator();\n                this.thousandsSeparator = this.thousandsSeparator ?? this.localeService.getGroupingSeparator();\n            });\n    }\n}\n\n"]}
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bignumber-input.directive.js","sourceRoot":"","sources":["../../../../../projects/angular-components/bignumber-input/src/lib/bignumber-input/bignumber-input.directive.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,KAAK,EAAE,KAAK,EAAqB,MAAM,EAAiB,MAAM,eAAe,CAAC;AAC9G,OAAO,EAAE,iBAAiB,EAAqC,MAAM,gBAAgB,CAAC;AAEtF,OAAO,EAAE,oBAAoB,EAAE,MAAM,iDAAiD,CAAC;;AAEvF;;GAEG;AACH,MAAM,CAAN,IAAY,wBAGX;AAHD,WAAY,wBAAwB;IAChC,2CAAe,CAAA;IACf,yCAAa,CAAA;AACjB,CAAC,EAHW,wBAAwB,KAAxB,wBAAwB,QAGnC;AAED;;;;;;;;;;;;GAYG;AAgBH,MAAM,OAAO,uBAAwB,SAAQ,oBAAoB;IAC7D;;;;;;;;;OASG;IACI,SAAS,GAAG,KAAK,CAAC,EAAE,CAAC,CAAC;IAE7B;;;;;;OAMG;IACI,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;IAExB;;;;OAIG;IACa,gBAAgB,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;IAE5C;;;;OAIG;IACa,gBAAgB,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;IAE5C;;;OAGG;IACa,gBAAgB,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC;IAE9C;;;OAGG;IACI,kBAAkB,GAAG,KAAK,CAAqB,SAAS,CAAC,CAAC;IAEjE;;;OAGG;IACa,iBAAiB,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC;IAE/C;;;OAGG;IACI,OAAO,GAAG,KAAK,CAAmB,OAAO,CAAC,CAAC;IAElD;;;;OAIG;IACa,aAAa,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC;IAE5C;;OAEG;IACI,WAAW,GAAG,KAAK,CAAqB,SAAS,CAAC,CAAC;IAEnD,SAAS,CAAU;IAE1B;;;OAGG;IACI,aAAa,GAAG,MAAM,EAAU,CAAC;IAEhC,yBAAyB,GAAG,KAAK,CAAC;IAClC,0BAA0B,GAAG,KAAK,CAAC;IAE3C;QACI,KAAK,EAAE,CAAC;IACZ,CAAC;IAEe,QAAQ;QACpB,KAAK,CAAC,QAAQ,EAAE,CAAC;QACjB,IAAI,CAAC,iBAAiB,EAAE,CAAC;IAC7B,CAAC;IAED,0EAA0E;IAC1E,iFAAiF;IACjF,uFAAuF;IACvF,sCAAsC;IACtB,WAAW,CAAC,OAAsB;QAC9C,IAAI,OAAO,CAAC,kBAAkB,CAAC,IAAI,IAAI,CAAC,gBAAgB,EAAE,EAAE,CAAC;YACzD,IAAI,CAAC,yBAAyB,GAAG,IAAI,CAAC;QAC1C,CAAC;QACD,IAAI,OAAO,CAAC,mBAAmB,CAAC,IAAI,IAAI,CAAC,iBAAiB,EAAE,EAAE,CAAC;YAC3D,IAAI,CAAC,0BAA0B,GAAG,IAAI,CAAC;QAC3C,CAAC;QACD,IAAI,OAAO,CAAC,oBAAoB,CAAC,EAAE,CAAC;YAChC,MAAM,GAAG,GAAG,IAAI,CAAC,kBAAkB,EAAE,CAAC;YACtC,IAAI,GAAG,KAAK,SAAS,EAAE,CAAC;gBACpB,IAAI,CAAC,0BAA0B,GAAG,IAAI,CAAC;gBACvC,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YACpC,CAAC;QACL,CAAC;QACD,IAAI,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;YACnB,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC;YACxC,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC;QAC5C,CAAC;QACD,IACI,OAAO,CAAC,OAAO,CAAC;YAChB,OAAO,CAAC,kBAAkB,CAAC;YAC3B,OAAO,CAAC,mBAAmB,CAAC;YAC5B,OAAO,CAAC,oBAAoB,CAAC;YAC7B,OAAO,CAAC,WAAW,CAAC,EACtB,CAAC;YACC,IAAI,CAAC,kBAAkB,EAAE,CAAC;QAC9B,CAAC;QACD,IAAI,OAAO,CAAC,OAAO,CAAC,IAAI,OAAO,CAAC,kBAAkB,CAAC,EAAE,CAAC;YAClD,IAAI,CAAC,iBAAiB,EAAE,CAAC;QAC7B,CAAC;IACL,CAAC;IAED;;;OAGG;IACa,OAAO,CAAC,KAAqB;QACzC,MAAM,UAAU,GAAG,KAAK,CAAC,aAAa,EAAE,OAAO,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;QAC9D,MAAM,oBAAoB,GAAG,IAAI,CAAC,kBAAkB,EAAE,IAAI,IAAI,CAAC,iBAAiB,EAAE,CAAC;QACnF,MAAM,WAAW,GAAG,UAAU;aACzB,OAAO,CAAC,IAAI,MAAM,CAAC,KAAK,oBAAoB,EAAE,EAAE,GAAG,CAAC,EAAE,EAAE,CAAC;aACzD,OAAO,CAAC,IAAI,CAAC,gBAAgB,EAAE,EAAE,GAAG,CAAC,CAAC;QAC3C,MAAM,CAAC,OAAO,EAAE,WAAW,GAAG,EAAE,CAAC,GAAG,WAAW,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAC3D,MAAM,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,MAAM,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC,MAAM,CAAC;QAElG,IAAI,WAAW,GAAG,IAAI,CAAC,SAAS,EAAE,EAAE,CAAC;YACjC,KAAK,CAAC,cAAc,EAAE,CAAC;YACvB,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;YACpC,OAAO;QACX,CAAC;QAED,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;IACzB,CAAC;IAED;;;OAGG;IACgB,gBAAgB;QAC/B,MAAM,eAAe,GAAG,IAAI,CAAC,yBAAyB,CAAC,CAAC,CAAC,IAAI,CAAC,gBAAgB,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC;QAC7F,MAAM,gBAAgB,GAAG,IAAI,CAAC,0BAA0B;YACpD,CAAC,CAAC,CAAC,IAAI,CAAC,kBAAkB,EAAE,IAAI,IAAI,CAAC,iBAAiB,EAAE,CAAC;YACzD,CAAC,CAAC,SAAS,CAAC;QAEhB,KAAK,CAAC,gBAAgB,EAAE,CAAC;QAEzB,IAAI,eAAe,KAAK,SAAS,EAAE,CAAC;YAChC,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;QAC/C,CAAC;QACD,IAAI,gBAAgB,KAAK,SAAS,EAAE,CAAC;YACjC,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,gBAAgB,CAAC,CAAC;QACjD,CAAC;QAED,IAAI,CAAC,kBAAkB,EAAE,CAAC;QAC1B,IAAI,CAAC,iBAAiB,EAAE,CAAC;IAC7B,CAAC;IAED;;;OAGG;IACa,QAAQ,CAAC,OAAwB;QAC7C,MAAM,UAAU,GAAG,KAAK,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;QAE3C,IAAI,CAAC,OAAO,CAAC,KAAK,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,EAAE,CAAC;YACtC,OAAO,UAAU,IAAI,IAAI,CAAC;QAC9B,CAAC;QAED,MAAM,UAAU,GAAG,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;QAC1D,MAAM,CAAC,OAAO,EAAE,WAAW,GAAG,EAAE,CAAC,GAAG,UAAU,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAC1D,MAAM,WAAW,GAAG,OAAO,CAAC,MAAM,GAAG,WAAW,CAAC,MAAM,CAAC;QAExD,IAAI,WAAW,GAAG,IAAI,CAAC,SAAS,EAAE,EAAE,CAAC;YACjC,OAAO;gBACH,GAAG,UAAU;gBACb,gBAAgB,EAAE;oBACd,SAAS,EAAE,IAAI,CAAC,SAAS,EAAE;oBAC3B,MAAM,EAAE,WAAW;iBACtB;aACJ,CAAC;QACN,CAAC;QAED,OAAO,UAAU,IAAI,IAAI,CAAC;IAC9B,CAAC;IAED;;OAEG;IACK,kBAAkB;QACtB,MAAM,YAAY,GAAG,IAAI,CAAC,gBAAgB,EAAE,EAAE,MAAM,IAAI,CAAC,CAAC;QAC1D,MAAM,oBAAoB,GAAG,IAAI,CAAC,kBAAkB,EAAE,IAAI,IAAI,CAAC,iBAAiB,EAAE,CAAC;QACnF,MAAM,YAAY,GAAG,oBAAoB,EAAE,MAAM,IAAI,CAAC,CAAC;QAEvD,MAAM,iBAAiB,GAAG,CAAC,CAAC;QAE5B,IAAI,SAAS,GAAG,IAAI,CAAC,SAAS,EAAE,GAAG,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACrE,SAAS;YACL,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,SAAS,EAAE,GAAG,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,iBAAiB,GAAG,CAAC,CAAC,GAAG,YAAY,CAAC;QAE7G,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;IAC/B,CAAC;IAEO,iBAAiB;QACrB,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,EAAE,CAAC;QAC3B,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,IAAI,KAAK,EAAE,CAAC;YAC/B,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,IAAI,CAAC,gBAAgB,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,KAAK,EAAE,GAAG,CAAC,EAAE,CAAC,CAAC;QAChF,CAAC;IACL,CAAC;wGA/NQ,uBAAuB;4FAAvB,uBAAuB,szDATrB;YACP;gBACI,OAAO,EAAE,iBAAiB;gBAC1B,qDAAqD;gBACrD,WAAW,EAAE,UAAU,CAAC,GAAG,EAAE,CAAC,uBAAuB,CAAC;gBACtD,KAAK,EAAE,IAAI;aACd;SACJ;;4FAEQ,uBAAuB;kBAfnC,SAAS;mBAAC;oBACP,QAAQ,EAAE,wBAAwB;oBAClC,IAAI,EAAE;wBACF,oBAAoB,EAAE,eAAe;wBACrC,kBAAkB,EAAE,WAAW;qBAClC;oBACD,SAAS,EAAE;wBACP;4BACI,OAAO,EAAE,iBAAiB;4BAC1B,qDAAqD;4BACrD,WAAW,EAAE,UAAU,CAAC,GAAG,EAAE,wBAAwB,CAAC;4BACtD,KAAK,EAAE,IAAI;yBACd;qBACJ;iBACJ","sourcesContent":["import { Directive, forwardRef, input, model, OnInit, OnChanges, output, SimpleChanges } from '@angular/core';\nimport { NG_VALUE_ACCESSOR, AbstractControl, ValidationErrors } from '@angular/forms';\n\nimport { NumericMaskDirective } from '@seniorsistemas/angular-components/numeric-mask';\n\n/**\n * @deprecated Este enum não tem mais efeito. O alinhamento do campo é sempre `'right'`.\n */\nexport enum BignumberAlignmentOption {\n    RIGHT = 'right',\n    LEFT = 'left',\n}\n\n/**\n * @deprecated Utilize a diretiva `BigNumberInput` ao invés desta.\n * @description Diretiva de máscara para campos de entrada de números de grande precisão,\n * adaptada do `CurrencyMaskDirective`. Permite configurar precisão, escala,\n * separadores decimais e de milhar de acordo com o locale da aplicação.\n *\n * @example\n * ```html\n * <input sBignumberInput [precision]=\"15\" [scale]=\"2\" [allowNegative]=\"false\" />\n * ```\n *\n * @category Inputs\n */\n@Directive({\n    selector: 'input[sBignumberInput]',\n    host: {\n        '[attr.placeholder]': 'placeholder()',\n        '[attr.maxLength]': 'maxLength',\n    },\n    providers: [\n        {\n            provide: NG_VALUE_ACCESSOR,\n            // NOSONAR - 'BignumberInputDirective' is deprecated.\n            useExisting: forwardRef(() => BignumberInputDirective),\n            multi: true,\n        },\n    ],\n})\nexport class BignumberInputDirective extends NumericMaskDirective implements OnInit, OnChanges {\n    /**\n     * @description Número total de dígitos significativos aceitos pelo campo (parte inteira + parte decimal).\n     *\n     * Durante a digitação, o campo limita fisicamente o número de caracteres via `maxLength`.\n     * Ao colar um valor que ultrapasse o limite, o evento `pasteRejected` é emitido e a colagem é cancelada.\n     * Após sair do campo (blur) ou ao submeter o formulário, se o valor ultrapassar `precision`,\n     * o campo ficará inválido com o erro `exceedsPrecision: { precision, actual }`.\n     *\n     * @default 15\n     */\n    public precision = input(15);\n\n    /**\n     * @deprecated Use `minDecimalPlaces` e `maxDecimalPlaces` ao invés deste.\n     * @description Número de casas decimais exibidas e aceitas pelo campo.\n     * Quando informado, repassa o valor para `minDecimalPlaces` e `maxDecimalPlaces`.\n     *\n     * @default 0\n     */\n    public scale = input(0);\n\n    /**\n     * @description Número mínimo de casas decimais exibidas.\n     *\n     * @default 0\n     */\n    public override minDecimalPlaces = model(0);\n\n    /**\n     * @description Número máximo de casas decimais aceitas.\n     *\n     * @default 0\n     */\n    public override maxDecimalPlaces = model(0);\n\n    /**\n     * @description Separador decimal personalizado. Quando não informado,\n     * utiliza o separador definido pelo locale ativo da aplicação.\n     */\n    public override decimalSeparator = model(',');\n\n    /**\n     * @deprecated Use `thousandSeparator` ao invés deste.\n     * @description Separador de milhar personalizado. Recomenda-se migrar para `thousandSeparator`.\n     */\n    public thousandsSeparator = input<string | undefined>(undefined);\n\n    /**\n     * @description Separador de milhar personalizado. Quando não informado,\n     * utiliza o separador definido pelo locale ativo da aplicação.\n     */\n    public override thousandSeparator = model('.');\n\n    /**\n     * @deprecated Este input não tem mais efeito e pode ser removido.\n     * O alinhamento do campo é sempre `'right'`, conforme o comportamento padrão da máscara numérica.\n     */\n    public alignTo = input<'left' | 'right'>('right');\n\n    /**\n     * @description Permite a entrada de valores negativos.\n     *\n     * @default true\n     */\n    public override allowNegative = input(true);\n\n    /**\n     * @description Texto de placeholder exibido quando o campo está vazio.\n     */\n    public placeholder = model<string | undefined>(undefined);\n\n    public maxLength?: number;\n\n    /**\n     * @description Emitido quando uma colagem (paste) é rejeitada pela validação do campo.\n     * Emite a string colada que foi recusada.\n     */\n    public pasteRejected = output<string>();\n\n    private _decimalSeparatorExplicit = false;\n    private _thousandSeparatorExplicit = false;\n\n    constructor() {\n        super();\n    }\n\n    public override ngOnInit(): void {\n        super.ngOnInit();\n        this.updatePlaceholder();\n    }\n\n    // ngOnChanges handles all signal writes reactively, avoiding the need for\n    // effect() with allowSignalWrites. The decimalSeparator/thousandSeparator inputs\n    // have truthy defaults, so ngOnChanges is necessary to distinguish \"parent bound this\"\n    // from \"it's just the default value\".\n    public override ngOnChanges(changes: SimpleChanges): void {\n        if (changes['decimalSeparator'] && this.decimalSeparator()) {\n            this._decimalSeparatorExplicit = true;\n        }\n        if (changes['thousandSeparator'] && this.thousandSeparator()) {\n            this._thousandSeparatorExplicit = true;\n        }\n        if (changes['thousandsSeparator']) {\n            const val = this.thousandsSeparator();\n            if (val !== undefined) {\n                this._thousandSeparatorExplicit = true;\n                this.thousandSeparator.set(val);\n            }\n        }\n        if (changes['scale']) {\n            this.minDecimalPlaces.set(this.scale());\n            this.maxDecimalPlaces.set(this.scale());\n        }\n        if (\n            changes['scale'] ||\n            changes['decimalSeparator'] ||\n            changes['thousandSeparator'] ||\n            changes['thousandsSeparator'] ||\n            changes['precision']\n        ) {\n            this.calculateMaxLength();\n        }\n        if (changes['scale'] || changes['decimalSeparator']) {\n            this.updatePlaceholder();\n        }\n    }\n\n    /**\n     * Overrides base paste handler to add precision validation.\n     * If the pasted value exceeds `precision` digits, the paste is rejected.\n     */\n    public override onPaste(event: ClipboardEvent): void {\n        const pastedText = event.clipboardData?.getData('text') ?? '';\n        const effectiveThousandSep = this.thousandsSeparator() ?? this.thousandSeparator();\n        const numericText = pastedText\n            .replace(new RegExp(`\\\\${effectiveThousandSep}`, 'g'), '')\n            .replace(this.decimalSeparator(), '.');\n        const [intPart, decimalPart = ''] = numericText.split('.');\n        const totalDigits = intPart.replace(/\\D/g, '').length + decimalPart.slice(0, this.scale()).length;\n\n        if (totalDigits > this.precision()) {\n            event.preventDefault();\n            this.pasteRejected.emit(pastedText);\n            return;\n        }\n\n        super.onPaste(event);\n    }\n\n    /**\n     * Overrides locale-derived separators with explicitly set inputs, if provided.\n     * If no explicit separator is set, the locale-derived value is used.\n     */\n    protected override updateSeparators(): void {\n        const explicitDecimal = this._decimalSeparatorExplicit ? this.decimalSeparator() : undefined;\n        const explicitThousand = this._thousandSeparatorExplicit\n            ? (this.thousandsSeparator() ?? this.thousandSeparator())\n            : undefined;\n\n        super.updateSeparators();\n\n        if (explicitDecimal !== undefined) {\n            this.decimalSeparator.set(explicitDecimal);\n        }\n        if (explicitThousand !== undefined) {\n            this.thousandSeparator.set(explicitThousand);\n        }\n\n        this.calculateMaxLength();\n        this.updatePlaceholder();\n    }\n\n    /**\n     * Overrides base validator to add precision validation.\n     * If the total number of significant digits exceeds `precision`, returns an `exceedsPrecision` error.\n     */\n    public override validate(control: AbstractControl): ValidationErrors | null {\n        const baseErrors = super.validate(control);\n\n        if (!control.value || !this.precision()) {\n            return baseErrors ?? null;\n        }\n\n        const numericStr = String(control.value).replace('-', '');\n        const [intPart, decimalPart = ''] = numericStr.split('.');\n        const totalDigits = intPart.length + decimalPart.length;\n\n        if (totalDigits > this.precision()) {\n            return {\n                ...baseErrors,\n                exceedsPrecision: {\n                    precision: this.precision(),\n                    actual: totalDigits,\n                },\n            };\n        }\n\n        return baseErrors ?? null;\n    }\n\n    /**\n     * Responsible to calculate the field maximum length considering the separators.\n     */\n    private calculateMaxLength(): void {\n        const decSepLength = this.decimalSeparator()?.length ?? 0;\n        const effectiveThousandSep = this.thousandsSeparator() ?? this.thousandSeparator();\n        const thoSepLength = effectiveThousandSep?.length ?? 0;\n\n        const DIGITS_GROUP_SIZE = 3;\n\n        let maxLength = this.precision() + (this.scale() ? decSepLength : 0);\n        maxLength +=\n            Math.ceil((this.precision() - (this.scale() ? this.scale() : 0)) / DIGITS_GROUP_SIZE - 1) * thoSepLength;\n\n        this.maxLength = maxLength;\n    }\n\n    private updatePlaceholder(): void {\n        const scale = this.scale();\n        if (!this.placeholder() && scale) {\n            this.placeholder.set(`0${this.decimalSeparator()}${''.padEnd(scale, '0')}`);\n        }\n    }\n}\n\n"]}