@seniorsistemas/data-seniorx-core 3.0.0 → 3.1.0

package/esm2022/features/input-mask/input-mask.directive.mjs

@@ -0,0 +1,510 @@
+import { Directive, ElementRef, EventEmitter, Input, Output, Renderer2, forwardRef, inject } from '@angular/core';
+import { NG_VALIDATORS, NG_VALUE_ACCESSOR } from '@angular/forms';
+import { INPUT_MASK_DEFAULT_AUTO_CLEAR, INPUT_MASK_DEFAULT_CHARACTER_PATTERN, INPUT_MASK_DEFAULT_SLOT_CHAR, INPUT_MASK_DEFAULT_UNMASK, INPUT_MASK_NAVIGATION_KEYS } from '../../core/constants/input-mask.const';
+import * as i0 from "@angular/core";
+/**
+ * @description Diretiva de máscara de entrada interativa para campos de texto.
+ *
+ * Aplique `sdcInputMask` em qualquer `<input>` para aplicar uma máscara de formatação,
+ * guiando a entrada do usuário com um padrão definido. Implementa `ControlValueAccessor`
+ * e `Validator` para integração nativa com Angular Forms (`ngModel`/`formControl`).
+ *
+ * **Tokens de máscara:**
+ * - `9` — dígito (0-9)
+ * - `a` — letra (conforme `characterPattern`, padrão `[A-Za-z]`)
+ * - `*` — alfanumérico (letra ou dígito)
+ * - Qualquer outro caractere é tratado como literal (ex: `.`, `-`, `/`, `(`, `)`)
+ * - `?` — tudo após esse ponto na máscara passa a ser opcional
+ *
+ * @example
+ * ```html
+ * <!-- CPF -->
+ * <input type="text" sdcInputMask="999.999.999-99" [(ngModel)]="cpf" />
+ *
+ * <!-- CNPJ -->
+ * <input type="text" sdcInputMask="99.999.999/9999-99" [(ngModel)]="cnpj" />
+ *
+ * <!-- Telefone, retornando só os dígitos digitados -->
+ * <input type="text" sdcInputMask="(99) 99999-9999" [unmask]="true" [(ngModel)]="telefone" />
+ * ```
+ * @category Input
+ */
+export class InputMaskDirective {
+    /**
+     * Padrão da máscara. Tokens: `9` (dígito), `a` (letra), `*` (alfanumérico).
+     * Demais caracteres são literais. `?` torna o restante da máscara opcional.
+     */
+    mask;
+    /**
+     * Caractere exibido nas posições ainda não preenchidas.
+     * @default '_'
+     */
+    slotChar = INPUT_MASK_DEFAULT_SLOT_CHAR;
+    /**
+     * Quando `true`, o modelo recebe apenas os caracteres digitados pelo usuário,
+     * sem os literais da máscara. Quando `false`, o modelo recebe o valor completo
+     * incluindo literais.
+     * @default false
+     */
+    unmask = INPUT_MASK_DEFAULT_UNMASK;
+    /**
+     * Expressão regular usada para validar o token `a` (letra).
+     * @default '[A-Za-z]'
+     */
+    characterPattern = INPUT_MASK_DEFAULT_CHARACTER_PATTERN;
+    /**
+     * Quando `true`, limpa o campo ao perder o foco se a máscara estiver incompleta.
+     * @default true
+     */
+    autoClear = INPUT_MASK_DEFAULT_AUTO_CLEAR;
+    /**
+     * Emitido quando todos os tokens obrigatórios da máscara estão preenchidos.
+     * Disparado apenas na transição de incompleto para completo (edge-triggered).
+     * Emite o valor atual (mascarado ou não, conforme `unmask`).
+     */
+    maskComplete = new EventEmitter();
+    el = inject((ElementRef));
+    renderer = inject(Renderer2);
+    tokens = [];
+    buffer = [];
+    wasComplete = false;
+    lastValue = null;
+    onChange = () => { };
+    onTouched = () => { };
+    onValidatorChange = null;
+    ngOnInit() {
+        this.buildMask();
+    }
+    ngOnChanges(changes) {
+        if (changes['mask'] || changes['slotChar'] || changes['characterPattern']) {
+            this.buildMask();
+            if (this.mask) {
+                this.writeValue(this.lastValue);
+            }
+            // Só re-notifica o Reactive Forms em mudanças de mask POSTERIORES à primeira (ex.: o
+            // consumidor troca a máscara em runtime). Na primeira ligação, chamar isso de forma
+            // síncrona dispara um `updateValueAndValidity()` no meio do mesmo ciclo de criação em que
+            // o template já leu `control.invalid` — é exatamente esse `.invalid` mudando dentro do
+            // mesmo pass que o Angular sinaliza como NG0100 em modo dev. `NG_VALIDATORS`/
+            // `FormControlName` já roda a validação inicial sozinho quando o controle é configurado;
+            // não precisamos forçar uma segunda rodada nesse momento.
+            if (!changes['mask']?.firstChange) {
+                this.onValidatorChange?.();
+            }
+        }
+    }
+    registerOnValidatorChange(fn) {
+        this.onValidatorChange = fn;
+    }
+    buildMask() {
+        if (!this.mask) {
+            this.tokens = [];
+            this.buffer = [];
+            return;
+        }
+        this.tokens = this.parseMask(this.mask);
+        this.resetBuffer();
+    }
+    parseMask(mask) {
+        const tokens = [];
+        let optional = false;
+        for (const ch of mask) {
+            if (ch === '?') {
+                optional = true;
+            }
+            else {
+                tokens.push(this.buildToken(ch, optional));
+            }
+        }
+        return tokens;
+    }
+    buildToken(ch, optional) {
+        switch (ch) {
+            case '9':
+                return { type: 'digit', optional };
+            case 'a':
+                return { type: 'alpha', optional };
+            case '*':
+                return { type: 'alphanumeric', optional };
+            default:
+                return { type: 'literal', char: ch, optional: false };
+        }
+    }
+    resetBuffer() {
+        this.buffer = this.tokens.map((t) => (t.type === 'literal' ? (t.char ?? '') : this.slotChar));
+    }
+    isValidChar(char, token) {
+        switch (token.type) {
+            case 'digit':
+                return /\d/.test(char);
+            case 'alpha':
+                return new RegExp(this.characterPattern).test(char);
+            case 'alphanumeric':
+                return /[A-Za-z0-9]/.test(char);
+            default:
+                return false;
+        }
+    }
+    isEditable(token) {
+        return token.type !== 'literal';
+    }
+    nextEditablePos(from) {
+        for (let i = from; i < this.tokens.length; i++) {
+            if (this.isEditable(this.tokens[i])) {
+                return i;
+            }
+        }
+        return this.tokens.length;
+    }
+    prevEditablePos(from) {
+        for (let i = from; i >= 0; i--) {
+            if (this.tokens[i] && this.isEditable(this.tokens[i])) {
+                return i;
+            }
+        }
+        return -1;
+    }
+    setCursor(pos) {
+        const safePos = Math.min(pos, this.tokens.length);
+        this.el.nativeElement.setSelectionRange(safePos, safePos);
+    }
+    setInputValue(value) {
+        this.renderer.setProperty(this.el.nativeElement, 'value', value);
+    }
+    getDisplayValue() {
+        return this.buffer.join('');
+    }
+    getBlurDisplayValue() {
+        let lastFilledIndex = -1;
+        for (let i = 0; i < this.buffer.length; i++) {
+            if (this.tokens[i] && this.tokens[i].type !== 'literal' && this.buffer[i] !== this.slotChar) {
+                lastFilledIndex = i;
+            }
+        }
+        if (lastFilledIndex === -1) {
+            return '';
+        }
+        return this.buffer.slice(0, lastFilledIndex + 1).join('');
+    }
+    /**
+     * Retorna o valor que deve ser propagado ao modelo.
+     * Retorna `null` quando o usuário não digitou nada.
+     */
+    getModelValue() {
+        const hasInput = this.buffer.some((ch, i) => this.tokens[i] && this.tokens[i].type !== 'literal' && ch !== this.slotChar);
+        if (!hasInput) {
+            return null;
+        }
+        if (this.unmask) {
+            return (this.buffer
+                .filter((ch, i) => this.tokens[i] && this.tokens[i].type !== 'literal' && ch !== this.slotChar)
+                .join('') || null);
+        }
+        return this.buffer.join('');
+    }
+    clearRange(startPos, endPos) {
+        for (let i = startPos; i < endPos; i++) {
+            if (this.tokens[i] && this.tokens[i].type !== 'literal') {
+                this.buffer[i] = this.slotChar;
+            }
+        }
+        this.setInputValue(this.getDisplayValue());
+    }
+    isMaskComplete() {
+        return this.tokens.every((token, i) => {
+            if (token.type === 'literal' || token.optional) {
+                return true;
+            }
+            return this.buffer[i] !== this.slotChar;
+        });
+    }
+    checkAndEmitComplete() {
+        const complete = this.isMaskComplete();
+        if (complete && !this.wasComplete) {
+            this.wasComplete = true;
+            this.maskComplete.emit(this.getModelValue() ?? '');
+            return;
+        }
+        if (!complete) {
+            this.wasComplete = false;
+        }
+    }
+    dispatchInputEvent() {
+        this.el.nativeElement.dispatchEvent(new Event('input', { bubbles: true }));
+    }
+    onKeyDown(event) {
+        if (!this.mask || this.shouldIgnoreKeydown(event)) {
+            return;
+        }
+        const key = event.key;
+        const input = this.el.nativeElement;
+        const startPos = input.selectionStart ?? 0;
+        const endPos = input.selectionEnd ?? 0;
+        if (key === 'Backspace') {
+            event.preventDefault();
+            this.handleBackspace(startPos, endPos);
+            return;
+        }
+        if (key === 'Delete') {
+            event.preventDefault();
+            this.handleDelete(startPos, endPos);
+            return;
+        }
+        // Caractere único imprimível
+        if (key.length === 1) {
+            event.preventDefault();
+            this.handleCharacterInput(key, startPos, endPos);
+        }
+    }
+    shouldIgnoreKeydown(event) {
+        if (this.el.nativeElement.readOnly || this.el.nativeElement.disabled) {
+            return true;
+        }
+        const key = event.key;
+        // Deixa o navegador tratar atalhos (Ctrl/Cmd), Tab e teclas de função
+        if (event.ctrlKey || event.metaKey || key === 'Tab' || key.startsWith('F')) {
+            return true;
+        }
+        // Deixa o navegador tratar navegação por setas e Home/End nativamente
+        return INPUT_MASK_NAVIGATION_KEYS.includes(key);
+    }
+    handleBackspace(startPos, endPos) {
+        if (startPos !== endPos) {
+            this.clearRange(startPos, endPos);
+            const nextPos = this.nextEditablePos(startPos);
+            this.setCursor(nextPos < this.tokens.length ? nextPos : startPos);
+            this.finishEdit();
+            return;
+        }
+        if (startPos > 0) {
+            const pos = this.prevEditablePos(startPos - 1);
+            if (pos >= 0) {
+                this.buffer[pos] = this.slotChar;
+                this.setInputValue(this.getDisplayValue());
+                this.setCursor(pos);
+            }
+        }
+        this.finishEdit();
+    }
+    handleDelete(startPos, endPos) {
+        if (startPos !== endPos) {
+            this.clearRange(startPos, endPos);
+            const nextPos = this.nextEditablePos(startPos);
+            this.setCursor(nextPos < this.tokens.length ? nextPos : startPos);
+            this.finishEdit();
+            return;
+        }
+        const pos = this.nextEditablePos(startPos);
+        if (pos < this.tokens.length) {
+            this.buffer[pos] = this.slotChar;
+            this.setInputValue(this.getDisplayValue());
+            this.setCursor(pos);
+        }
+        this.finishEdit();
+    }
+    handleCharacterInput(key, startPos, endPos) {
+        let insertPos = startPos;
+        // Limpa a seleção, se houver
+        if (startPos !== endPos) {
+            this.clearRange(startPos, endPos);
+            insertPos = startPos;
+        }
+        const pos = this.nextEditablePos(insertPos);
+        if (pos >= this.tokens.length) {
+            return;
+        }
+        const token = this.tokens[pos];
+        if (!this.isValidChar(key, token)) {
+            return;
+        }
+        this.buffer[pos] = key;
+        this.setInputValue(this.getDisplayValue());
+        const next = this.nextEditablePos(pos + 1);
+        this.setCursor(next <= this.tokens.length ? next : this.tokens.length);
+        this.finishEdit();
+    }
+    finishEdit() {
+        this.onChange(this.getModelValue());
+        this.checkAndEmitComplete();
+        this.dispatchInputEvent();
+    }
+    onFocus(_event) {
+        if (!this.mask) {
+            return;
+        }
+        // Sempre restaura a exibição completa da máscara no foco (slots ficam visíveis)
+        this.setInputValue(this.getDisplayValue());
+        // Move o cursor para o primeiro slot editável vazio
+        const firstEmpty = this.buffer.findIndex((ch, i) => this.tokens[i] && this.tokens[i].type !== 'literal' && ch === this.slotChar);
+        this.setCursor(firstEmpty >= 0 ? firstEmpty : this.nextEditablePos(0));
+    }
+    onBlur(_event) {
+        if (!this.mask) {
+            return;
+        }
+        this.onTouched();
+        if (!this.isMaskComplete()) {
+            if (this.autoClear) {
+                this.resetBuffer();
+                this.onChange(null);
+            }
+            this.setInputValue(this.getBlurDisplayValue());
+        }
+    }
+    onPaste(event) {
+        if (!this.mask || this.el.nativeElement.readOnly || this.el.nativeElement.disabled) {
+            return;
+        }
+        event.preventDefault();
+        const pastedText = event.clipboardData?.getData('text') ?? '';
+        const input = this.el.nativeElement;
+        const startPos = input.selectionStart ?? 0;
+        const endPos = input.selectionEnd ?? 0;
+        if (startPos !== endPos) {
+            this.clearRange(startPos, endPos);
+        }
+        const pos = this.consumePastedText(pastedText, startPos);
+        this.setInputValue(this.getDisplayValue());
+        this.setCursor(pos <= this.tokens.length ? pos : this.tokens.length);
+        this.finishEdit();
+    }
+    consumePastedText(pastedText, startPos) {
+        let pos = this.nextEditablePos(startPos);
+        for (const ch of pastedText) {
+            if (pos >= this.tokens.length) {
+                break;
+            }
+            pos = this.consumePastedChar(ch, pos);
+        }
+        return pos;
+    }
+    consumePastedChar(ch, pos) {
+        const token = this.tokens[pos];
+        if (token.type === 'literal') {
+            // Pula o literal correspondente no texto colado; avança o slot literal de qualquer forma
+            const advanced = ch === token.char ? pos + 1 : pos;
+            return this.nextEditablePos(advanced);
+        }
+        if (this.isValidChar(ch, token)) {
+            this.buffer[pos] = ch;
+            return this.nextEditablePos(pos + 1);
+        }
+        return pos;
+    }
+    onClick() {
+        if (!this.mask || this.el.nativeElement.readOnly || this.el.nativeElement.disabled) {
+            return;
+        }
+        const input = this.el.nativeElement;
+        const pos = input.selectionStart ?? 0;
+        // Se o cursor caiu em um literal, empurra para o slot editável mais próximo
+        if (this.tokens[pos] && this.tokens[pos].type === 'literal') {
+            this.setCursor(this.nextEditablePos(pos));
+        }
+    }
+    writeValue(value) {
+        this.lastValue = value;
+        if (!this.mask) {
+            return;
+        }
+        this.resetBuffer();
+        if (!value) {
+            this.setInputValue('');
+            return;
+        }
+        let bufferIdx = 0;
+        let valueIdx = 0;
+        while (valueIdx < value.length && bufferIdx < this.tokens.length) {
+            const token = this.tokens[bufferIdx];
+            const char = value[valueIdx];
+            if (token.type === 'literal') {
+                // Consome o literal do valor se corresponder; sempre avança o buffer
+                if (char === token.char) {
+                    valueIdx++;
+                }
+                bufferIdx++;
+            }
+            else if (this.isValidChar(char, token)) {
+                this.buffer[bufferIdx] = char;
+                bufferIdx++;
+                valueIdx++;
+            }
+            else {
+                // Pula caracteres do valor que não correspondem ao slot atual
+                valueIdx++;
+            }
+        }
+        this.setInputValue(this.getDisplayValue());
+    }
+    registerOnChange(onChange) {
+        this.onChange = onChange;
+    }
+    registerOnTouched(onTouched) {
+        this.onTouched = onTouched;
+    }
+    setDisabledState(isDisabled) {
+        this.renderer.setProperty(this.el.nativeElement, 'disabled', isDisabled);
+    }
+    validate(control) {
+        if (!this.mask || !control.value) {
+            return null;
+        }
+        if (!this.isMaskComplete()) {
+            return { incompleteMask: { mask: this.mask } };
+        }
+        return null;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: InputMaskDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: InputMaskDirective, isStandalone: true, selector: "input[sdcInputMask]", inputs: { mask: ["sdcInputMask", "mask"], slotChar: "slotChar", unmask: "unmask", characterPattern: "characterPattern", autoClear: "autoClear" }, outputs: { maskComplete: "maskComplete" }, host: { listeners: { "keydown": "onKeyDown($event)", "focus": "onFocus($event)", "blur": "onBlur($event)", "paste": "onPaste($event)", "click": "onClick()" } }, providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: forwardRef(() => InputMaskDirective),
+                multi: true
+            },
+            {
+                provide: NG_VALIDATORS,
+                useExisting: forwardRef(() => InputMaskDirective),
+                multi: true
+            }
+        ], usesOnChanges: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: InputMaskDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'input[sdcInputMask]',
+                    standalone: true,
+                    host: {
+                        '(keydown)': 'onKeyDown($event)',
+                        '(focus)': 'onFocus($event)',
+                        '(blur)': 'onBlur($event)',
+                        '(paste)': 'onPaste($event)',
+                        '(click)': 'onClick()'
+                    },
+                    providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => InputMaskDirective),
+                            multi: true
+                        },
+                        {
+                            provide: NG_VALIDATORS,
+                            useExisting: forwardRef(() => InputMaskDirective),
+                            multi: true
+                        }
+                    ]
+                }]
+        }], propDecorators: { mask: [{
+                type: Input,
+                args: ['sdcInputMask']
+            }], slotChar: [{
+                type: Input
+            }], unmask: [{
+                type: Input
+            }], characterPattern: [{
+                type: Input
+            }], autoClear: [{
+                type: Input
+            }], maskComplete: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"input-mask.directive.js","sourceRoot":"","sources":["../../../../../lib/src/features/input-mask/input-mask.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, ElementRef, EventEmitter, Input, OnChanges, OnInit, Output, Renderer2, SimpleChanges, forwardRef, inject } from '@angular/core';\nimport { AbstractControl, ControlValueAccessor, NG_VALIDATORS, NG_VALUE_ACCESSOR, ValidationErrors, Validator } from '@angular/forms';\n\nimport {\n  INPUT_MASK_DEFAULT_AUTO_CLEAR,\n  INPUT_MASK_DEFAULT_CHARACTER_PATTERN,\n  INPUT_MASK_DEFAULT_SLOT_CHAR,\n  INPUT_MASK_DEFAULT_UNMASK,\n  INPUT_MASK_NAVIGATION_KEYS\n} from '../../core/constants/input-mask.const';\nimport type { InputMaskToken } from '../../core/types/input-mask.type';\n\n/**\n * @description Diretiva de máscara de entrada interativa para campos de texto.\n *\n * Aplique `sdcInputMask` em qualquer `<input>` para aplicar uma máscara de formatação,\n * guiando a entrada do usuário com um padrão definido. Implementa `ControlValueAccessor`\n * e `Validator` para integração nativa com Angular Forms (`ngModel`/`formControl`).\n *\n * **Tokens de máscara:**\n * - `9` — dígito (0-9)\n * - `a` — letra (conforme `characterPattern`, padrão `[A-Za-z]`)\n * - `*` — alfanumérico (letra ou dígito)\n * - Qualquer outro caractere é tratado como literal (ex: `.`, `-`, `/`, `(`, `)`)\n * - `?` — tudo após esse ponto na máscara passa a ser opcional\n *\n * @example\n * ```html\n * <!-- CPF -->\n * <input type=\"text\" sdcInputMask=\"999.999.999-99\" [(ngModel)]=\"cpf\" />\n *\n * <!-- CNPJ -->\n * <input type=\"text\" sdcInputMask=\"99.999.999/9999-99\" [(ngModel)]=\"cnpj\" />\n *\n * <!-- Telefone, retornando só os dígitos digitados -->\n * <input type=\"text\" sdcInputMask=\"(99) 99999-9999\" [unmask]=\"true\" [(ngModel)]=\"telefone\" />\n * ```\n * @category Input\n */\n@Directive({\n  selector: 'input[sdcInputMask]',\n  standalone: true,\n  host: {\n    '(keydown)': 'onKeyDown($event)',\n    '(focus)': 'onFocus($event)',\n    '(blur)': 'onBlur($event)',\n    '(paste)': 'onPaste($event)',\n    '(click)': 'onClick()'\n  },\n  providers: [\n    {\n      provide: NG_VALUE_ACCESSOR,\n      useExisting: forwardRef(() => InputMaskDirective),\n      multi: true\n    },\n    {\n      provide: NG_VALIDATORS,\n      useExisting: forwardRef(() => InputMaskDirective),\n      multi: true\n    }\n  ]\n})\nexport class InputMaskDirective implements OnInit, OnChanges, ControlValueAccessor, Validator {\n  /**\n   * Padrão da máscara. Tokens: `9` (dígito), `a` (letra), `*` (alfanumérico).\n   * Demais caracteres são literais. `?` torna o restante da máscara opcional.\n   */\n  @Input('sdcInputMask') mask: string | undefined;\n\n  /**\n   * Caractere exibido nas posições ainda não preenchidas.\n   * @default '_'\n   */\n  @Input() slotChar: string = INPUT_MASK_DEFAULT_SLOT_CHAR;\n\n  /**\n   * Quando `true`, o modelo recebe apenas os caracteres digitados pelo usuário,\n   * sem os literais da máscara. Quando `false`, o modelo recebe o valor completo\n   * incluindo literais.\n   * @default false\n   */\n  @Input() unmask: boolean = INPUT_MASK_DEFAULT_UNMASK;\n\n  /**\n   * Expressão regular usada para validar o token `a` (letra).\n   * @default '[A-Za-z]'\n   */\n  @Input() characterPattern: string = INPUT_MASK_DEFAULT_CHARACTER_PATTERN;\n\n  /**\n   * Quando `true`, limpa o campo ao perder o foco se a máscara estiver incompleta.\n   * @default true\n   */\n  @Input() autoClear: boolean = INPUT_MASK_DEFAULT_AUTO_CLEAR;\n\n  /**\n   * Emitido quando todos os tokens obrigatórios da máscara estão preenchidos.\n   * Disparado apenas na transição de incompleto para completo (edge-triggered).\n   * Emite o valor atual (mascarado ou não, conforme `unmask`).\n   */\n  @Output() maskComplete = new EventEmitter<string>();\n\n  private readonly el = inject(ElementRef<HTMLInputElement>);\n  private readonly renderer = inject(Renderer2);\n\n  private tokens: InputMaskToken[] = [];\n  private buffer: string[] = [];\n  private wasComplete = false;\n  private lastValue: string | null = null;\n\n  private onChange: (value: string | null) => void = () => {};\n  private onTouched: () => void = () => {};\n  private onValidatorChange: (() => void) | null = null;\n\n  public ngOnInit(): void {\n    this.buildMask();\n  }\n\n  public ngOnChanges(changes: SimpleChanges): void {\n    if (changes['mask'] || changes['slotChar'] || changes['characterPattern']) {\n      this.buildMask();\n      if (this.mask) {\n        this.writeValue(this.lastValue);\n      }\n\n      // Só re-notifica o Reactive Forms em mudanças de mask POSTERIORES à primeira (ex.: o\n      // consumidor troca a máscara em runtime). Na primeira ligação, chamar isso de forma\n      // síncrona dispara um `updateValueAndValidity()` no meio do mesmo ciclo de criação em que\n      // o template já leu `control.invalid` — é exatamente esse `.invalid` mudando dentro do\n      // mesmo pass que o Angular sinaliza como NG0100 em modo dev. `NG_VALIDATORS`/\n      // `FormControlName` já roda a validação inicial sozinho quando o controle é configurado;\n      // não precisamos forçar uma segunda rodada nesse momento.\n      if (!changes['mask']?.firstChange) {\n        this.onValidatorChange?.();\n      }\n    }\n  }\n\n  public registerOnValidatorChange(fn: () => void): void {\n    this.onValidatorChange = fn;\n  }\n\n  private buildMask(): void {\n    if (!this.mask) {\n      this.tokens = [];\n      this.buffer = [];\n      return;\n    }\n    this.tokens = this.parseMask(this.mask);\n    this.resetBuffer();\n  }\n\n  private parseMask(mask: string): InputMaskToken[] {\n    const tokens: InputMaskToken[] = [];\n    let optional = false;\n\n    for (const ch of mask) {\n      if (ch === '?') {\n        optional = true;\n      } else {\n        tokens.push(this.buildToken(ch, optional));\n      }\n    }\n\n    return tokens;\n  }\n\n  private buildToken(ch: string, optional: boolean): InputMaskToken {\n    switch (ch) {\n      case '9':\n        return { type: 'digit', optional };\n      case 'a':\n        return { type: 'alpha', optional };\n      case '*':\n        return { type: 'alphanumeric', optional };\n      default:\n        return { type: 'literal', char: ch, optional: false };\n    }\n  }\n\n  private resetBuffer(): void {\n    this.buffer = this.tokens.map((t) => (t.type === 'literal' ? (t.char ?? '') : this.slotChar));\n  }\n\n  private isValidChar(char: string, token: InputMaskToken): boolean {\n    switch (token.type) {\n      case 'digit':\n        return /\\d/.test(char);\n      case 'alpha':\n        return new RegExp(this.characterPattern).test(char);\n      case 'alphanumeric':\n        return /[A-Za-z0-9]/.test(char);\n      default:\n        return false;\n    }\n  }\n\n  private isEditable(token: InputMaskToken): boolean {\n    return token.type !== 'literal';\n  }\n\n  private nextEditablePos(from: number): number {\n    for (let i = from; i < this.tokens.length; i++) {\n      if (this.isEditable(this.tokens[i])) {\n        return i;\n      }\n    }\n    return this.tokens.length;\n  }\n\n  private prevEditablePos(from: number): number {\n    for (let i = from; i >= 0; i--) {\n      if (this.tokens[i] && this.isEditable(this.tokens[i])) {\n        return i;\n      }\n    }\n    return -1;\n  }\n\n  private setCursor(pos: number): void {\n    const safePos = Math.min(pos, this.tokens.length);\n    this.el.nativeElement.setSelectionRange(safePos, safePos);\n  }\n\n  private setInputValue(value: string): void {\n    this.renderer.setProperty(this.el.nativeElement, 'value', value);\n  }\n\n  private getDisplayValue(): string {\n    return this.buffer.join('');\n  }\n\n  private getBlurDisplayValue(): string {\n    let lastFilledIndex = -1;\n    for (let i = 0; i < this.buffer.length; i++) {\n      if (this.tokens[i] && this.tokens[i].type !== 'literal' && this.buffer[i] !== this.slotChar) {\n        lastFilledIndex = i;\n      }\n    }\n    if (lastFilledIndex === -1) {\n      return '';\n    }\n    return this.buffer.slice(0, lastFilledIndex + 1).join('');\n  }\n\n  /**\n   * Retorna o valor que deve ser propagado ao modelo.\n   * Retorna `null` quando o usuário não digitou nada.\n   */\n  private getModelValue(): string | null {\n    const hasInput = this.buffer.some(\n      (ch, i) => this.tokens[i] && this.tokens[i].type !== 'literal' && ch !== this.slotChar\n    );\n\n    if (!hasInput) {\n      return null;\n    }\n\n    if (this.unmask) {\n      return (\n        this.buffer\n          .filter((ch, i) => this.tokens[i] && this.tokens[i].type !== 'literal' && ch !== this.slotChar)\n          .join('') || null\n      );\n    }\n\n    return this.buffer.join('');\n  }\n\n  private clearRange(startPos: number, endPos: number): void {\n    for (let i = startPos; i < endPos; i++) {\n      if (this.tokens[i] && this.tokens[i].type !== 'literal') {\n        this.buffer[i] = this.slotChar;\n      }\n    }\n    this.setInputValue(this.getDisplayValue());\n  }\n\n  private isMaskComplete(): boolean {\n    return this.tokens.every((token, i) => {\n      if (token.type === 'literal' || token.optional) {\n        return true;\n      }\n\n      return this.buffer[i] !== this.slotChar;\n    });\n  }\n\n  private checkAndEmitComplete(): void {\n    const complete = this.isMaskComplete();\n\n    if (complete && !this.wasComplete) {\n      this.wasComplete = true;\n      this.maskComplete.emit(this.getModelValue() ?? '');\n      return;\n    }\n\n    if (!complete) {\n      this.wasComplete = false;\n    }\n  }\n\n  private dispatchInputEvent(): void {\n    this.el.nativeElement.dispatchEvent(new Event('input', { bubbles: true }));\n  }\n\n  public onKeyDown(event: KeyboardEvent): void {\n    if (!this.mask || this.shouldIgnoreKeydown(event)) {\n      return;\n    }\n\n    const key = event.key;\n    const input = this.el.nativeElement;\n    const startPos = input.selectionStart ?? 0;\n    const endPos = input.selectionEnd ?? 0;\n\n    if (key === 'Backspace') {\n      event.preventDefault();\n      this.handleBackspace(startPos, endPos);\n      return;\n    }\n\n    if (key === 'Delete') {\n      event.preventDefault();\n      this.handleDelete(startPos, endPos);\n      return;\n    }\n\n    // Caractere único imprimível\n    if (key.length === 1) {\n      event.preventDefault();\n      this.handleCharacterInput(key, startPos, endPos);\n    }\n  }\n\n  private shouldIgnoreKeydown(event: KeyboardEvent): boolean {\n    if (this.el.nativeElement.readOnly || this.el.nativeElement.disabled) {\n      return true;\n    }\n\n    const key = event.key;\n\n    // Deixa o navegador tratar atalhos (Ctrl/Cmd), Tab e teclas de função\n    if (event.ctrlKey || event.metaKey || key === 'Tab' || key.startsWith('F')) {\n      return true;\n    }\n\n    // Deixa o navegador tratar navegação por setas e Home/End nativamente\n    return INPUT_MASK_NAVIGATION_KEYS.includes(key);\n  }\n\n  private handleBackspace(startPos: number, endPos: number): void {\n    if (startPos !== endPos) {\n      this.clearRange(startPos, endPos);\n      const nextPos = this.nextEditablePos(startPos);\n      this.setCursor(nextPos < this.tokens.length ? nextPos : startPos);\n      this.finishEdit();\n      return;\n    }\n\n    if (startPos > 0) {\n      const pos = this.prevEditablePos(startPos - 1);\n\n      if (pos >= 0) {\n        this.buffer[pos] = this.slotChar;\n        this.setInputValue(this.getDisplayValue());\n        this.setCursor(pos);\n      }\n    }\n\n    this.finishEdit();\n  }\n\n  private handleDelete(startPos: number, endPos: number): void {\n    if (startPos !== endPos) {\n      this.clearRange(startPos, endPos);\n      const nextPos = this.nextEditablePos(startPos);\n      this.setCursor(nextPos < this.tokens.length ? nextPos : startPos);\n      this.finishEdit();\n      return;\n    }\n\n    const pos = this.nextEditablePos(startPos);\n\n    if (pos < this.tokens.length) {\n      this.buffer[pos] = this.slotChar;\n      this.setInputValue(this.getDisplayValue());\n      this.setCursor(pos);\n    }\n\n    this.finishEdit();\n  }\n\n  private handleCharacterInput(key: string, startPos: number, endPos: number): void {\n    let insertPos = startPos;\n\n    // Limpa a seleção, se houver\n    if (startPos !== endPos) {\n      this.clearRange(startPos, endPos);\n      insertPos = startPos;\n    }\n\n    const pos = this.nextEditablePos(insertPos);\n\n    if (pos >= this.tokens.length) {\n      return;\n    }\n\n    const token = this.tokens[pos];\n\n    if (!this.isValidChar(key, token)) {\n      return;\n    }\n\n    this.buffer[pos] = key;\n    this.setInputValue(this.getDisplayValue());\n\n    const next = this.nextEditablePos(pos + 1);\n    this.setCursor(next <= this.tokens.length ? next : this.tokens.length);\n\n    this.finishEdit();\n  }\n\n  private finishEdit(): void {\n    this.onChange(this.getModelValue());\n    this.checkAndEmitComplete();\n    this.dispatchInputEvent();\n  }\n\n  public onFocus(_event: FocusEvent): void {\n    if (!this.mask) {\n      return;\n    }\n\n    // Sempre restaura a exibição completa da máscara no foco (slots ficam visíveis)\n    this.setInputValue(this.getDisplayValue());\n\n    // Move o cursor para o primeiro slot editável vazio\n    const firstEmpty = this.buffer.findIndex(\n      (ch, i) => this.tokens[i] && this.tokens[i].type !== 'literal' && ch === this.slotChar\n    );\n\n    this.setCursor(firstEmpty >= 0 ? firstEmpty : this.nextEditablePos(0));\n  }\n\n  public onBlur(_event: Event): void {\n    if (!this.mask) {\n      return;\n    }\n\n    this.onTouched();\n\n    if (!this.isMaskComplete()) {\n      if (this.autoClear) {\n        this.resetBuffer();\n        this.onChange(null);\n      }\n      this.setInputValue(this.getBlurDisplayValue());\n    }\n  }\n\n  public onPaste(event: ClipboardEvent): void {\n    if (!this.mask || this.el.nativeElement.readOnly || this.el.nativeElement.disabled) {\n      return;\n    }\n\n    event.preventDefault();\n\n    const pastedText = event.clipboardData?.getData('text') ?? '';\n    const input = this.el.nativeElement;\n    const startPos = input.selectionStart ?? 0;\n    const endPos = input.selectionEnd ?? 0;\n\n    if (startPos !== endPos) {\n      this.clearRange(startPos, endPos);\n    }\n\n    const pos = this.consumePastedText(pastedText, startPos);\n\n    this.setInputValue(this.getDisplayValue());\n    this.setCursor(pos <= this.tokens.length ? pos : this.tokens.length);\n    this.finishEdit();\n  }\n\n  private consumePastedText(pastedText: string, startPos: number): number {\n    let pos = this.nextEditablePos(startPos);\n\n    for (const ch of pastedText) {\n      if (pos >= this.tokens.length) {\n        break;\n      }\n\n      pos = this.consumePastedChar(ch, pos);\n    }\n\n    return pos;\n  }\n\n  private consumePastedChar(ch: string, pos: number): number {\n    const token = this.tokens[pos];\n\n    if (token.type === 'literal') {\n      // Pula o literal correspondente no texto colado; avança o slot literal de qualquer forma\n      const advanced = ch === token.char ? pos + 1 : pos;\n      return this.nextEditablePos(advanced);\n    }\n\n    if (this.isValidChar(ch, token)) {\n      this.buffer[pos] = ch;\n      return this.nextEditablePos(pos + 1);\n    }\n\n    return pos;\n  }\n\n  public onClick(): void {\n    if (!this.mask || this.el.nativeElement.readOnly || this.el.nativeElement.disabled) {\n      return;\n    }\n\n    const input = this.el.nativeElement;\n    const pos = input.selectionStart ?? 0;\n\n    // Se o cursor caiu em um literal, empurra para o slot editável mais próximo\n    if (this.tokens[pos] && this.tokens[pos].type === 'literal') {\n      this.setCursor(this.nextEditablePos(pos));\n    }\n  }\n\n  public writeValue(value: string | null): void {\n    this.lastValue = value;\n\n    if (!this.mask) {\n      return;\n    }\n\n    this.resetBuffer();\n\n    if (!value) {\n      this.setInputValue('');\n      return;\n    }\n\n    let bufferIdx = 0;\n    let valueIdx = 0;\n\n    while (valueIdx < value.length && bufferIdx < this.tokens.length) {\n      const token = this.tokens[bufferIdx];\n      const char = value[valueIdx];\n\n      if (token.type === 'literal') {\n        // Consome o literal do valor se corresponder; sempre avança o buffer\n        if (char === token.char) {\n          valueIdx++;\n        }\n        bufferIdx++;\n      } else if (this.isValidChar(char, token)) {\n        this.buffer[bufferIdx] = char;\n        bufferIdx++;\n        valueIdx++;\n      } else {\n        // Pula caracteres do valor que não correspondem ao slot atual\n        valueIdx++;\n      }\n    }\n\n    this.setInputValue(this.getDisplayValue());\n  }\n\n  public registerOnChange(onChange: (value: string | null) => void): void {\n    this.onChange = onChange;\n  }\n\n  public registerOnTouched(onTouched: () => void): void {\n    this.onTouched = onTouched;\n  }\n\n  public setDisabledState(isDisabled: boolean): void {\n    this.renderer.setProperty(this.el.nativeElement, 'disabled', isDisabled);\n  }\n\n  public validate(control: AbstractControl): ValidationErrors | null {\n    if (!this.mask || !control.value) {\n      return null;\n    }\n\n    if (!this.isMaskComplete()) {\n      return { incompleteMask: { mask: this.mask } };\n    }\n\n    return null;\n  }\n}\n"]}