@schenkerjon/ng-govbr-tw 0.2.1 → 0.3.0

package/esm2022/lib/components/input-cnpj/br-input-cnpj.component.mjs

@@ -0,0 +1,270 @@
+import { Component, Input, Optional, Self, ViewEncapsulation, } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+export class BrInputCnpjComponent {
+    static { this.nextId = 0; }
+    static { this.defaultErrorMessages = {
+        required: 'Campo obrigatório',
+        cnpjInvalid: 'CNPJ inválido',
+        cnpjIncomplete: 'CNPJ incompleto',
+    }; }
+    constructor(ngControl) {
+        this.ngControl = ngControl;
+        this.placeholder = '00.000.000/0000-00';
+        this.required = false;
+        this.density = 'medium';
+        /** Mensagens customizadas para erros */
+        this.errorMessages = {};
+        this.displayValue = '';
+        this.isDisabled = false;
+        this.rawValue = '';
+        this.inputId = `br-input-cnpj-${BrInputCnpjComponent.nextId++}`;
+        this.onChange = () => { };
+        this.onTouched = () => { };
+        this.onValidatorChange = () => { };
+        if (this.ngControl) {
+            this.ngControl.valueAccessor = this;
+        }
+    }
+    get displayError() {
+        if (this.error)
+            return this.error;
+        if (!this.ngControl?.control)
+            return undefined;
+        const control = this.ngControl.control;
+        if (!control.errors || (!control.touched && !control.dirty))
+            return undefined;
+        return this.getFirstErrorMessage(control.errors);
+    }
+    getFirstErrorMessage(errors) {
+        for (const key of Object.keys(errors)) {
+            if (this.errorMessages[key])
+                return this.errorMessages[key];
+            const defaultMsg = BrInputCnpjComponent.defaultErrorMessages[key];
+            if (defaultMsg)
+                return defaultMsg;
+        }
+        return 'Campo inválido';
+    }
+    get inputClasses() {
+        const densityHeights = {
+            small: 'h-[var(--govbr-input-small)] text-govbr-sm',
+            medium: 'h-[var(--govbr-input-medium)] text-govbr-base',
+            large: 'h-[var(--govbr-input-large)] text-govbr-lg',
+        };
+        const base = `w-full px-4 pr-10 font-rawline govbr-input ${densityHeights[this.density]}`;
+        const statusCls = this.displayError ? 'govbr-input--danger' : '';
+        const disabledCls = this.isDisabled
+            ? 'bg-govbr-gray-2 text-govbr-gray-40 cursor-not-allowed'
+            : 'bg-white text-govbr-gray-80';
+        return [base, statusCls, disabledCls].filter(Boolean).join(' ');
+    }
+    onInput(event) {
+        const input = event.target;
+        const digits = input.value.replace(/\D/g, '').slice(0, 14);
+        this.rawValue = digits;
+        this.displayValue = this.formatCnpj(digits);
+        this.onChange(digits);
+        setTimeout(() => {
+            input.value = this.displayValue;
+        });
+    }
+    onBlur() {
+        this.onTouched();
+    }
+    formatCnpj(digits) {
+        if (!digits)
+            return '';
+        let formatted = digits;
+        // 00.000.000/0000-00
+        if (digits.length > 2) {
+            formatted = digits.slice(0, 2) + '.' + digits.slice(2);
+        }
+        if (digits.length > 5) {
+            formatted = formatted.slice(0, 6) + '.' + formatted.slice(6);
+        }
+        if (digits.length > 8) {
+            formatted = formatted.slice(0, 10) + '/' + formatted.slice(10);
+        }
+        if (digits.length > 12) {
+            formatted = formatted.slice(0, 15) + '-' + formatted.slice(15);
+        }
+        return formatted;
+    }
+    // ControlValueAccessor
+    writeValue(value) {
+        const digits = (value || '').replace(/\D/g, '').slice(0, 14);
+        this.rawValue = digits;
+        this.displayValue = this.formatCnpj(digits);
+    }
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    setDisabledState(isDisabled) {
+        this.isDisabled = isDisabled;
+    }
+    // Validator
+    validate(control) {
+        const value = control.value;
+        if (!value) {
+            return this.required ? { required: true } : null;
+        }
+        const digits = value.replace(/\D/g, '');
+        if (digits.length < 14) {
+            return { cnpjIncomplete: true };
+        }
+        if (!this.isValidCnpj(digits)) {
+            return { cnpjInvalid: true };
+        }
+        return null;
+    }
+    registerOnValidatorChange(fn) {
+        this.onValidatorChange = fn;
+    }
+    isValidCnpj(cnpj) {
+        const digits = cnpj.replace(/\D/g, '');
+        if (digits.length !== 14)
+            return false;
+        // Verifica se todos os dígitos são iguais
+        if (/^(\d)\1+$/.test(digits))
+            return false;
+        // Calcula primeiro dígito verificador
+        const weights1 = [5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2];
+        let sum = 0;
+        for (let i = 0; i < 12; i++) {
+            sum += parseInt(digits[i], 10) * weights1[i];
+        }
+        let remainder = sum % 11;
+        const digit1 = remainder < 2 ? 0 : 11 - remainder;
+        if (digit1 !== parseInt(digits[12], 10))
+            return false;
+        // Calcula segundo dígito verificador
+        const weights2 = [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2];
+        sum = 0;
+        for (let i = 0; i < 13; i++) {
+            sum += parseInt(digits[i], 10) * weights2[i];
+        }
+        remainder = sum % 11;
+        const digit2 = remainder < 2 ? 0 : 11 - remainder;
+        if (digit2 !== parseInt(digits[13], 10))
+            return false;
+        return true;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BrInputCnpjComponent, deps: [{ token: i1.NgControl, optional: true, self: true }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "17.3.12", type: BrInputCnpjComponent, isStandalone: true, selector: "br-input-cnpj", inputs: { label: "label", placeholder: "placeholder", required: "required", helperText: "helperText", error: "error", density: "density", errorMessages: "errorMessages" }, ngImport: i0, template: `
+    <div class="mb-4 font-rawline">
+      @if (label) {
+        <label
+          [for]="inputId"
+          class="block text-govbr-sm font-semibold text-govbr-gray-80 mb-1"
+        >
+          {{ label }}
+          @if (required) {
+            <span class="text-govbr-danger ml-0.5">*</span>
+          }
+        </label>
+      }
+
+      @if (helperText && !displayError) {
+        <span class="block text-govbr-xs text-govbr-gray-60 mb-1">
+          {{ helperText }}
+        </span>
+      }
+
+      <div class="relative">
+        <input
+          [id]="inputId"
+          type="text"
+          inputmode="numeric"
+          [placeholder]="placeholder"
+          [disabled]="isDisabled"
+          [class]="inputClasses"
+          [value]="displayValue"
+          (input)="onInput($event)"
+          (blur)="onBlur()"
+          maxlength="18"
+        />
+        <i class="fa-solid fa-building absolute right-3 top-1/2 -translate-y-1/2 text-govbr-gray-40 pointer-events-none"></i>
+      </div>
+
+      @if (displayError) {
+        <span class="flex items-center mt-1 text-govbr-sm text-govbr-danger">
+          <i class="fa-solid fa-times-circle mr-1"></i>{{ displayError }}
+        </span>
+      }
+    </div>
+  `, isInline: true, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BrInputCnpjComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'br-input-cnpj',
+                    standalone: true,
+                    encapsulation: ViewEncapsulation.None,
+                    template: `
+    <div class="mb-4 font-rawline">
+      @if (label) {
+        <label
+          [for]="inputId"
+          class="block text-govbr-sm font-semibold text-govbr-gray-80 mb-1"
+        >
+          {{ label }}
+          @if (required) {
+            <span class="text-govbr-danger ml-0.5">*</span>
+          }
+        </label>
+      }
+
+      @if (helperText && !displayError) {
+        <span class="block text-govbr-xs text-govbr-gray-60 mb-1">
+          {{ helperText }}
+        </span>
+      }
+
+      <div class="relative">
+        <input
+          [id]="inputId"
+          type="text"
+          inputmode="numeric"
+          [placeholder]="placeholder"
+          [disabled]="isDisabled"
+          [class]="inputClasses"
+          [value]="displayValue"
+          (input)="onInput($event)"
+          (blur)="onBlur()"
+          maxlength="18"
+        />
+        <i class="fa-solid fa-building absolute right-3 top-1/2 -translate-y-1/2 text-govbr-gray-40 pointer-events-none"></i>
+      </div>
+
+      @if (displayError) {
+        <span class="flex items-center mt-1 text-govbr-sm text-govbr-danger">
+          <i class="fa-solid fa-times-circle mr-1"></i>{{ displayError }}
+        </span>
+      }
+    </div>
+  `,
+                }]
+        }], ctorParameters: () => [{ type: i1.NgControl, decorators: [{
+                    type: Self
+                }, {
+                    type: Optional
+                }] }], propDecorators: { label: [{
+                type: Input
+            }], placeholder: [{
+                type: Input
+            }], required: [{
+                type: Input
+            }], helperText: [{
+                type: Input
+            }], error: [{
+                type: Input
+            }], density: [{
+                type: Input
+            }], errorMessages: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"br-input-cnpj.component.js","sourceRoot":"","sources":["../../../../../../projects/ng-govbr-tw/src/lib/components/input-cnpj/br-input-cnpj.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  Component,\r\n  Input,\r\n  Optional,\r\n  Self,\r\n  ViewEncapsulation,\r\n} from '@angular/core';\r\n\r\nimport { ControlValueAccessor, NgControl, ValidationErrors, Validator, AbstractControl } from '@angular/forms';\r\n\r\n@Component({\r\n  selector: 'br-input-cnpj',\r\n  standalone: true,\r\n  encapsulation: ViewEncapsulation.None,\r\n  template: `\r\n    <div class=\"mb-4 font-rawline\">\r\n      @if (label) {\r\n        <label\r\n          [for]=\"inputId\"\r\n          class=\"block text-govbr-sm font-semibold text-govbr-gray-80 mb-1\"\r\n        >\r\n          {{ label }}\r\n          @if (required) {\r\n            <span class=\"text-govbr-danger ml-0.5\">*</span>\r\n          }\r\n        </label>\r\n      }\r\n\r\n      @if (helperText && !displayError) {\r\n        <span class=\"block text-govbr-xs text-govbr-gray-60 mb-1\">\r\n          {{ helperText }}\r\n        </span>\r\n      }\r\n\r\n      <div class=\"relative\">\r\n        <input\r\n          [id]=\"inputId\"\r\n          type=\"text\"\r\n          inputmode=\"numeric\"\r\n          [placeholder]=\"placeholder\"\r\n          [disabled]=\"isDisabled\"\r\n          [class]=\"inputClasses\"\r\n          [value]=\"displayValue\"\r\n          (input)=\"onInput($event)\"\r\n          (blur)=\"onBlur()\"\r\n          maxlength=\"18\"\r\n        />\r\n        <i class=\"fa-solid fa-building absolute right-3 top-1/2 -translate-y-1/2 text-govbr-gray-40 pointer-events-none\"></i>\r\n      </div>\r\n\r\n      @if (displayError) {\r\n        <span class=\"flex items-center mt-1 text-govbr-sm text-govbr-danger\">\r\n          <i class=\"fa-solid fa-times-circle mr-1\"></i>{{ displayError }}\r\n        </span>\r\n      }\r\n    </div>\r\n  `,\r\n})\r\nexport class BrInputCnpjComponent implements ControlValueAccessor, Validator {\r\n  @Input() label?: string;\r\n  @Input() placeholder = '00.000.000/0000-00';\r\n  @Input() required = false;\r\n  @Input() helperText?: string;\r\n  @Input() error?: string;\r\n  @Input() density: 'small' | 'medium' | 'large' = 'medium';\r\n\r\n  /** Mensagens customizadas para erros */\r\n  @Input() errorMessages: Record<string, string> = {};\r\n\r\n  displayValue = '';\r\n  isDisabled = false;\r\n  private rawValue = '';\r\n\r\n  private static nextId = 0;\r\n  inputId = `br-input-cnpj-${BrInputCnpjComponent.nextId++}`;\r\n\r\n  onChange: (value: string) => void = () => {};\r\n  onTouched: () => void = () => {};\r\n  onValidatorChange: () => void = () => {};\r\n\r\n  private static readonly defaultErrorMessages: Record<string, string> = {\r\n    required: 'Campo obrigatório',\r\n    cnpjInvalid: 'CNPJ inválido',\r\n    cnpjIncomplete: 'CNPJ incompleto',\r\n  };\r\n\r\n  constructor(@Self() @Optional() private ngControl: NgControl) {\r\n    if (this.ngControl) {\r\n      this.ngControl.valueAccessor = this;\r\n    }\r\n  }\r\n\r\n  get displayError(): string | undefined {\r\n    if (this.error) return this.error;\r\n\r\n    if (!this.ngControl?.control) return undefined;\r\n\r\n    const control = this.ngControl.control;\r\n    if (!control.errors || (!control.touched && !control.dirty)) return undefined;\r\n\r\n    return this.getFirstErrorMessage(control.errors);\r\n  }\r\n\r\n  private getFirstErrorMessage(errors: ValidationErrors): string {\r\n    for (const key of Object.keys(errors)) {\r\n      if (this.errorMessages[key]) return this.errorMessages[key];\r\n      const defaultMsg = BrInputCnpjComponent.defaultErrorMessages[key];\r\n      if (defaultMsg) return defaultMsg;\r\n    }\r\n    return 'Campo inválido';\r\n  }\r\n\r\n  get inputClasses(): string {\r\n    const densityHeights = {\r\n      small: 'h-[var(--govbr-input-small)] text-govbr-sm',\r\n      medium: 'h-[var(--govbr-input-medium)] text-govbr-base',\r\n      large: 'h-[var(--govbr-input-large)] text-govbr-lg',\r\n    } as const;\r\n\r\n    const base = `w-full px-4 pr-10 font-rawline govbr-input ${densityHeights[this.density]}`;\r\n    const statusCls = this.displayError ? 'govbr-input--danger' : '';\r\n    const disabledCls = this.isDisabled\r\n      ? 'bg-govbr-gray-2 text-govbr-gray-40 cursor-not-allowed'\r\n      : 'bg-white text-govbr-gray-80';\r\n\r\n    return [base, statusCls, disabledCls].filter(Boolean).join(' ');\r\n  }\r\n\r\n  onInput(event: Event): void {\r\n    const input = event.target as HTMLInputElement;\r\n    const digits = input.value.replace(/\\D/g, '').slice(0, 14);\r\n    this.rawValue = digits;\r\n    this.displayValue = this.formatCnpj(digits);\r\n    this.onChange(digits);\r\n\r\n    setTimeout(() => {\r\n      input.value = this.displayValue;\r\n    });\r\n  }\r\n\r\n  onBlur(): void {\r\n    this.onTouched();\r\n  }\r\n\r\n  private formatCnpj(digits: string): string {\r\n    if (!digits) return '';\r\n    let formatted = digits;\r\n    // 00.000.000/0000-00\r\n    if (digits.length > 2) {\r\n      formatted = digits.slice(0, 2) + '.' + digits.slice(2);\r\n    }\r\n    if (digits.length > 5) {\r\n      formatted = formatted.slice(0, 6) + '.' + formatted.slice(6);\r\n    }\r\n    if (digits.length > 8) {\r\n      formatted = formatted.slice(0, 10) + '/' + formatted.slice(10);\r\n    }\r\n    if (digits.length > 12) {\r\n      formatted = formatted.slice(0, 15) + '-' + formatted.slice(15);\r\n    }\r\n    return formatted;\r\n  }\r\n\r\n  // ControlValueAccessor\r\n  writeValue(value: string): void {\r\n    const digits = (value || '').replace(/\\D/g, '').slice(0, 14);\r\n    this.rawValue = digits;\r\n    this.displayValue = this.formatCnpj(digits);\r\n  }\r\n\r\n  registerOnChange(fn: (value: string) => void): void {\r\n    this.onChange = fn;\r\n  }\r\n\r\n  registerOnTouched(fn: () => void): void {\r\n    this.onTouched = fn;\r\n  }\r\n\r\n  setDisabledState(isDisabled: boolean): void {\r\n    this.isDisabled = isDisabled;\r\n  }\r\n\r\n  // Validator\r\n  validate(control: AbstractControl): ValidationErrors | null {\r\n    const value = control.value as string;\r\n    if (!value) {\r\n      return this.required ? { required: true } : null;\r\n    }\r\n\r\n    const digits = value.replace(/\\D/g, '');\r\n    if (digits.length < 14) {\r\n      return { cnpjIncomplete: true };\r\n    }\r\n\r\n    if (!this.isValidCnpj(digits)) {\r\n      return { cnpjInvalid: true };\r\n    }\r\n\r\n    return null;\r\n  }\r\n\r\n  registerOnValidatorChange(fn: () => void): void {\r\n    this.onValidatorChange = fn;\r\n  }\r\n\r\n  private isValidCnpj(cnpj: string): boolean {\r\n    const digits = cnpj.replace(/\\D/g, '');\r\n\r\n    if (digits.length !== 14) return false;\r\n\r\n    // Verifica se todos os dígitos são iguais\r\n    if (/^(\\d)\\1+$/.test(digits)) return false;\r\n\r\n    // Calcula primeiro dígito verificador\r\n    const weights1 = [5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2];\r\n    let sum = 0;\r\n    for (let i = 0; i < 12; i++) {\r\n      sum += parseInt(digits[i], 10) * weights1[i];\r\n    }\r\n    let remainder = sum % 11;\r\n    const digit1 = remainder < 2 ? 0 : 11 - remainder;\r\n    if (digit1 !== parseInt(digits[12], 10)) return false;\r\n\r\n    // Calcula segundo dígito verificador\r\n    const weights2 = [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2];\r\n    sum = 0;\r\n    for (let i = 0; i < 13; i++) {\r\n      sum += parseInt(digits[i], 10) * weights2[i];\r\n    }\r\n    remainder = sum % 11;\r\n    const digit2 = remainder < 2 ? 0 : 11 - remainder;\r\n    if (digit2 !== parseInt(digits[13], 10)) return false;\r\n\r\n    return true;\r\n  }\r\n}\r\n"]}

package/esm2022/lib/components/input-cpf/br-input-cpf.component.mjs

@@ -0,0 +1,268 @@
+import { Component, Input, Optional, Self, ViewEncapsulation, } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+export class BrInputCpfComponent {
+    static { this.nextId = 0; }
+    static { this.defaultErrorMessages = {
+        required: 'Campo obrigatório',
+        cpfInvalid: 'CPF inválido',
+        cpfIncomplete: 'CPF incompleto',
+    }; }
+    constructor(ngControl) {
+        this.ngControl = ngControl;
+        this.placeholder = '000.000.000-00';
+        this.required = false;
+        this.density = 'medium';
+        /** Mensagens customizadas para erros */
+        this.errorMessages = {};
+        this.displayValue = '';
+        this.isDisabled = false;
+        this.rawValue = '';
+        this.inputId = `br-input-cpf-${BrInputCpfComponent.nextId++}`;
+        this.onChange = () => { };
+        this.onTouched = () => { };
+        this.onValidatorChange = () => { };
+        if (this.ngControl) {
+            this.ngControl.valueAccessor = this;
+        }
+    }
+    get displayError() {
+        if (this.error)
+            return this.error;
+        if (!this.ngControl?.control)
+            return undefined;
+        const control = this.ngControl.control;
+        if (!control.errors || (!control.touched && !control.dirty))
+            return undefined;
+        return this.getFirstErrorMessage(control.errors);
+    }
+    getFirstErrorMessage(errors) {
+        for (const key of Object.keys(errors)) {
+            if (this.errorMessages[key])
+                return this.errorMessages[key];
+            const defaultMsg = BrInputCpfComponent.defaultErrorMessages[key];
+            if (defaultMsg)
+                return defaultMsg;
+        }
+        return 'Campo inválido';
+    }
+    get inputClasses() {
+        const densityHeights = {
+            small: 'h-[var(--govbr-input-small)] text-govbr-sm',
+            medium: 'h-[var(--govbr-input-medium)] text-govbr-base',
+            large: 'h-[var(--govbr-input-large)] text-govbr-lg',
+        };
+        const base = `w-full px-4 pr-10 font-rawline govbr-input ${densityHeights[this.density]}`;
+        const statusCls = this.displayError ? 'govbr-input--danger' : '';
+        const disabledCls = this.isDisabled
+            ? 'bg-govbr-gray-2 text-govbr-gray-40 cursor-not-allowed'
+            : 'bg-white text-govbr-gray-80';
+        return [base, statusCls, disabledCls].filter(Boolean).join(' ');
+    }
+    onInput(event) {
+        const input = event.target;
+        const digits = input.value.replace(/\D/g, '').slice(0, 11);
+        this.rawValue = digits;
+        this.displayValue = this.formatCpf(digits);
+        this.onChange(digits);
+        // Reposition cursor
+        setTimeout(() => {
+            input.value = this.displayValue;
+        });
+    }
+    onBlur() {
+        this.onTouched();
+    }
+    formatCpf(digits) {
+        if (!digits)
+            return '';
+        let formatted = digits;
+        if (digits.length > 3) {
+            formatted = digits.slice(0, 3) + '.' + digits.slice(3);
+        }
+        if (digits.length > 6) {
+            formatted = formatted.slice(0, 7) + '.' + formatted.slice(7);
+        }
+        if (digits.length > 9) {
+            formatted = formatted.slice(0, 11) + '-' + formatted.slice(11);
+        }
+        return formatted;
+    }
+    // ControlValueAccessor
+    writeValue(value) {
+        const digits = (value || '').replace(/\D/g, '').slice(0, 11);
+        this.rawValue = digits;
+        this.displayValue = this.formatCpf(digits);
+    }
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    setDisabledState(isDisabled) {
+        this.isDisabled = isDisabled;
+    }
+    // Validator
+    validate(control) {
+        const value = control.value;
+        if (!value) {
+            return this.required ? { required: true } : null;
+        }
+        const digits = value.replace(/\D/g, '');
+        if (digits.length < 11) {
+            return { cpfIncomplete: true };
+        }
+        if (!this.isValidCpf(digits)) {
+            return { cpfInvalid: true };
+        }
+        return null;
+    }
+    registerOnValidatorChange(fn) {
+        this.onValidatorChange = fn;
+    }
+    isValidCpf(cpf) {
+        // Remove caracteres não numéricos
+        const digits = cpf.replace(/\D/g, '');
+        if (digits.length !== 11)
+            return false;
+        // Verifica se todos os dígitos são iguais
+        if (/^(\d)\1+$/.test(digits))
+            return false;
+        // Calcula primeiro dígito verificador
+        let sum = 0;
+        for (let i = 0; i < 9; i++) {
+            sum += parseInt(digits[i], 10) * (10 - i);
+        }
+        let remainder = (sum * 10) % 11;
+        if (remainder === 10 || remainder === 11)
+            remainder = 0;
+        if (remainder !== parseInt(digits[9], 10))
+            return false;
+        // Calcula segundo dígito verificador
+        sum = 0;
+        for (let i = 0; i < 10; i++) {
+            sum += parseInt(digits[i], 10) * (11 - i);
+        }
+        remainder = (sum * 10) % 11;
+        if (remainder === 10 || remainder === 11)
+            remainder = 0;
+        if (remainder !== parseInt(digits[10], 10))
+            return false;
+        return true;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BrInputCpfComponent, deps: [{ token: i1.NgControl, optional: true, self: true }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "17.3.12", type: BrInputCpfComponent, isStandalone: true, selector: "br-input-cpf", inputs: { label: "label", placeholder: "placeholder", required: "required", helperText: "helperText", error: "error", density: "density", errorMessages: "errorMessages" }, ngImport: i0, template: `
+    <div class="mb-4 font-rawline">
+      @if (label) {
+        <label
+          [for]="inputId"
+          class="block text-govbr-sm font-semibold text-govbr-gray-80 mb-1"
+        >
+          {{ label }}
+          @if (required) {
+            <span class="text-govbr-danger ml-0.5">*</span>
+          }
+        </label>
+      }
+
+      @if (helperText && !displayError) {
+        <span class="block text-govbr-xs text-govbr-gray-60 mb-1">
+          {{ helperText }}
+        </span>
+      }
+
+      <div class="relative">
+        <input
+          [id]="inputId"
+          type="text"
+          inputmode="numeric"
+          [placeholder]="placeholder"
+          [disabled]="isDisabled"
+          [class]="inputClasses"
+          [value]="displayValue"
+          (input)="onInput($event)"
+          (blur)="onBlur()"
+          maxlength="14"
+        />
+        <i class="fa-solid fa-id-card absolute right-3 top-1/2 -translate-y-1/2 text-govbr-gray-40 pointer-events-none"></i>
+      </div>
+
+      @if (displayError) {
+        <span class="flex items-center mt-1 text-govbr-sm text-govbr-danger">
+          <i class="fa-solid fa-times-circle mr-1"></i>{{ displayError }}
+        </span>
+      }
+    </div>
+  `, isInline: true, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BrInputCpfComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'br-input-cpf',
+                    standalone: true,
+                    encapsulation: ViewEncapsulation.None,
+                    template: `
+    <div class="mb-4 font-rawline">
+      @if (label) {
+        <label
+          [for]="inputId"
+          class="block text-govbr-sm font-semibold text-govbr-gray-80 mb-1"
+        >
+          {{ label }}
+          @if (required) {
+            <span class="text-govbr-danger ml-0.5">*</span>
+          }
+        </label>
+      }
+
+      @if (helperText && !displayError) {
+        <span class="block text-govbr-xs text-govbr-gray-60 mb-1">
+          {{ helperText }}
+        </span>
+      }
+
+      <div class="relative">
+        <input
+          [id]="inputId"
+          type="text"
+          inputmode="numeric"
+          [placeholder]="placeholder"
+          [disabled]="isDisabled"
+          [class]="inputClasses"
+          [value]="displayValue"
+          (input)="onInput($event)"
+          (blur)="onBlur()"
+          maxlength="14"
+        />
+        <i class="fa-solid fa-id-card absolute right-3 top-1/2 -translate-y-1/2 text-govbr-gray-40 pointer-events-none"></i>
+      </div>
+
+      @if (displayError) {
+        <span class="flex items-center mt-1 text-govbr-sm text-govbr-danger">
+          <i class="fa-solid fa-times-circle mr-1"></i>{{ displayError }}
+        </span>
+      }
+    </div>
+  `,
+                }]
+        }], ctorParameters: () => [{ type: i1.NgControl, decorators: [{
+                    type: Self
+                }, {
+                    type: Optional
+                }] }], propDecorators: { label: [{
+                type: Input
+            }], placeholder: [{
+                type: Input
+            }], required: [{
+                type: Input
+            }], helperText: [{
+                type: Input
+            }], error: [{
+                type: Input
+            }], density: [{
+                type: Input
+            }], errorMessages: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"br-input-cpf.component.js","sourceRoot":"","sources":["../../../../../../projects/ng-govbr-tw/src/lib/components/input-cpf/br-input-cpf.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  Component,\r\n  Input,\r\n  Optional,\r\n  Self,\r\n  ViewEncapsulation,\r\n} from '@angular/core';\r\n\r\nimport { ControlValueAccessor, NgControl, ValidationErrors, Validator, AbstractControl } from '@angular/forms';\r\n\r\n@Component({\r\n  selector: 'br-input-cpf',\r\n  standalone: true,\r\n  encapsulation: ViewEncapsulation.None,\r\n  template: `\r\n    <div class=\"mb-4 font-rawline\">\r\n      @if (label) {\r\n        <label\r\n          [for]=\"inputId\"\r\n          class=\"block text-govbr-sm font-semibold text-govbr-gray-80 mb-1\"\r\n        >\r\n          {{ label }}\r\n          @if (required) {\r\n            <span class=\"text-govbr-danger ml-0.5\">*</span>\r\n          }\r\n        </label>\r\n      }\r\n\r\n      @if (helperText && !displayError) {\r\n        <span class=\"block text-govbr-xs text-govbr-gray-60 mb-1\">\r\n          {{ helperText }}\r\n        </span>\r\n      }\r\n\r\n      <div class=\"relative\">\r\n        <input\r\n          [id]=\"inputId\"\r\n          type=\"text\"\r\n          inputmode=\"numeric\"\r\n          [placeholder]=\"placeholder\"\r\n          [disabled]=\"isDisabled\"\r\n          [class]=\"inputClasses\"\r\n          [value]=\"displayValue\"\r\n          (input)=\"onInput($event)\"\r\n          (blur)=\"onBlur()\"\r\n          maxlength=\"14\"\r\n        />\r\n        <i class=\"fa-solid fa-id-card absolute right-3 top-1/2 -translate-y-1/2 text-govbr-gray-40 pointer-events-none\"></i>\r\n      </div>\r\n\r\n      @if (displayError) {\r\n        <span class=\"flex items-center mt-1 text-govbr-sm text-govbr-danger\">\r\n          <i class=\"fa-solid fa-times-circle mr-1\"></i>{{ displayError }}\r\n        </span>\r\n      }\r\n    </div>\r\n  `,\r\n})\r\nexport class BrInputCpfComponent implements ControlValueAccessor, Validator {\r\n  @Input() label?: string;\r\n  @Input() placeholder = '000.000.000-00';\r\n  @Input() required = false;\r\n  @Input() helperText?: string;\r\n  @Input() error?: string;\r\n  @Input() density: 'small' | 'medium' | 'large' = 'medium';\r\n\r\n  /** Mensagens customizadas para erros */\r\n  @Input() errorMessages: Record<string, string> = {};\r\n\r\n  displayValue = '';\r\n  isDisabled = false;\r\n  private rawValue = '';\r\n\r\n  private static nextId = 0;\r\n  inputId = `br-input-cpf-${BrInputCpfComponent.nextId++}`;\r\n\r\n  onChange: (value: string) => void = () => {};\r\n  onTouched: () => void = () => {};\r\n  onValidatorChange: () => void = () => {};\r\n\r\n  private static readonly defaultErrorMessages: Record<string, string> = {\r\n    required: 'Campo obrigatório',\r\n    cpfInvalid: 'CPF inválido',\r\n    cpfIncomplete: 'CPF incompleto',\r\n  };\r\n\r\n  constructor(@Self() @Optional() private ngControl: NgControl) {\r\n    if (this.ngControl) {\r\n      this.ngControl.valueAccessor = this;\r\n    }\r\n  }\r\n\r\n  get displayError(): string | undefined {\r\n    if (this.error) return this.error;\r\n\r\n    if (!this.ngControl?.control) return undefined;\r\n\r\n    const control = this.ngControl.control;\r\n    if (!control.errors || (!control.touched && !control.dirty)) return undefined;\r\n\r\n    return this.getFirstErrorMessage(control.errors);\r\n  }\r\n\r\n  private getFirstErrorMessage(errors: ValidationErrors): string {\r\n    for (const key of Object.keys(errors)) {\r\n      if (this.errorMessages[key]) return this.errorMessages[key];\r\n      const defaultMsg = BrInputCpfComponent.defaultErrorMessages[key];\r\n      if (defaultMsg) return defaultMsg;\r\n    }\r\n    return 'Campo inválido';\r\n  }\r\n\r\n  get inputClasses(): string {\r\n    const densityHeights = {\r\n      small: 'h-[var(--govbr-input-small)] text-govbr-sm',\r\n      medium: 'h-[var(--govbr-input-medium)] text-govbr-base',\r\n      large: 'h-[var(--govbr-input-large)] text-govbr-lg',\r\n    } as const;\r\n\r\n    const base = `w-full px-4 pr-10 font-rawline govbr-input ${densityHeights[this.density]}`;\r\n    const statusCls = this.displayError ? 'govbr-input--danger' : '';\r\n    const disabledCls = this.isDisabled\r\n      ? 'bg-govbr-gray-2 text-govbr-gray-40 cursor-not-allowed'\r\n      : 'bg-white text-govbr-gray-80';\r\n\r\n    return [base, statusCls, disabledCls].filter(Boolean).join(' ');\r\n  }\r\n\r\n  onInput(event: Event): void {\r\n    const input = event.target as HTMLInputElement;\r\n    const digits = input.value.replace(/\\D/g, '').slice(0, 11);\r\n    this.rawValue = digits;\r\n    this.displayValue = this.formatCpf(digits);\r\n    this.onChange(digits);\r\n\r\n    // Reposition cursor\r\n    setTimeout(() => {\r\n      input.value = this.displayValue;\r\n    });\r\n  }\r\n\r\n  onBlur(): void {\r\n    this.onTouched();\r\n  }\r\n\r\n  private formatCpf(digits: string): string {\r\n    if (!digits) return '';\r\n    let formatted = digits;\r\n    if (digits.length > 3) {\r\n      formatted = digits.slice(0, 3) + '.' + digits.slice(3);\r\n    }\r\n    if (digits.length > 6) {\r\n      formatted = formatted.slice(0, 7) + '.' + formatted.slice(7);\r\n    }\r\n    if (digits.length > 9) {\r\n      formatted = formatted.slice(0, 11) + '-' + formatted.slice(11);\r\n    }\r\n    return formatted;\r\n  }\r\n\r\n  // ControlValueAccessor\r\n  writeValue(value: string): void {\r\n    const digits = (value || '').replace(/\\D/g, '').slice(0, 11);\r\n    this.rawValue = digits;\r\n    this.displayValue = this.formatCpf(digits);\r\n  }\r\n\r\n  registerOnChange(fn: (value: string) => void): void {\r\n    this.onChange = fn;\r\n  }\r\n\r\n  registerOnTouched(fn: () => void): void {\r\n    this.onTouched = fn;\r\n  }\r\n\r\n  setDisabledState(isDisabled: boolean): void {\r\n    this.isDisabled = isDisabled;\r\n  }\r\n\r\n  // Validator\r\n  validate(control: AbstractControl): ValidationErrors | null {\r\n    const value = control.value as string;\r\n    if (!value) {\r\n      return this.required ? { required: true } : null;\r\n    }\r\n\r\n    const digits = value.replace(/\\D/g, '');\r\n    if (digits.length < 11) {\r\n      return { cpfIncomplete: true };\r\n    }\r\n\r\n    if (!this.isValidCpf(digits)) {\r\n      return { cpfInvalid: true };\r\n    }\r\n\r\n    return null;\r\n  }\r\n\r\n  registerOnValidatorChange(fn: () => void): void {\r\n    this.onValidatorChange = fn;\r\n  }\r\n\r\n  private isValidCpf(cpf: string): boolean {\r\n    // Remove caracteres não numéricos\r\n    const digits = cpf.replace(/\\D/g, '');\r\n\r\n    if (digits.length !== 11) return false;\r\n\r\n    // Verifica se todos os dígitos são iguais\r\n    if (/^(\\d)\\1+$/.test(digits)) return false;\r\n\r\n    // Calcula primeiro dígito verificador\r\n    let sum = 0;\r\n    for (let i = 0; i < 9; i++) {\r\n      sum += parseInt(digits[i], 10) * (10 - i);\r\n    }\r\n    let remainder = (sum * 10) % 11;\r\n    if (remainder === 10 || remainder === 11) remainder = 0;\r\n    if (remainder !== parseInt(digits[9], 10)) return false;\r\n\r\n    // Calcula segundo dígito verificador\r\n    sum = 0;\r\n    for (let i = 0; i < 10; i++) {\r\n      sum += parseInt(digits[i], 10) * (11 - i);\r\n    }\r\n    remainder = (sum * 10) % 11;\r\n    if (remainder === 10 || remainder === 11) remainder = 0;\r\n    if (remainder !== parseInt(digits[10], 10)) return false;\r\n\r\n    return true;\r\n  }\r\n}\r\n"]}