@seniorsistemas/angular-components 17.31.2 → 18.0.0-develop-ae6477c0

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

@@ -0,0 +1,611 @@
+import { Directive, HostListener, Input } from '@angular/core';
+import { isNullOrUndefined } from '@seniorsistemas/angular-components/utils';
+import * as i0 from "@angular/core";
+import * as i1 from "primeng/calendar";
+export class CalendarMaskDirective {
+    host;
+    renderer;
+    // TODO: Mudei um monte de coisa e tem que testar se isso ainda funciona
+    // TODO: Ainda está sendo usada esta diretiva?
+    SELECTORS = 'button, [href], input, select, textarea, [tabindex]:not([tabindex="-1"])';
+    slotChar = "_";
+    autoClear = false;
+    value;
+    input;
+    filled;
+    _mask;
+    defs;
+    tests;
+    partialPosition;
+    firstNonMaskPos;
+    lastRequiredNonMaskPos;
+    len;
+    oldVal;
+    buffer;
+    defaultBuffer;
+    focusText;
+    caretTimeoutId;
+    androidChrome;
+    firstTime = true;
+    focusListener;
+    blurListener;
+    keydownListener;
+    keypressListener;
+    inputListener;
+    pasteListener;
+    constructor(host, renderer) {
+        this.host = host;
+        this.renderer = renderer;
+    }
+    setListeners() {
+        this.input = this.host.inputfieldViewChild?.nativeElement;
+        this.value = this.input?.value;
+        this.focusListener = this.renderer.listen(this.input, "focus", () => {
+            this.onInputFocus();
+        });
+        this.blurListener = this.renderer.listen(this.input, "blur", (event) => {
+            this.onInputBlur(event);
+        });
+        this.keydownListener = this.renderer.listen(this.input, "keydown", (event) => {
+            this.onKeyDown(event);
+        });
+        this.keypressListener = this.renderer.listen(this.input, "keypress", (event) => {
+            this.onKeyPress(event);
+        });
+        this.inputListener = this.renderer.listen(this.input, "input", (event) => {
+            this.onInputChange(event);
+        });
+        this.pasteListener = this.renderer.listen(this.input, "paste", (event) => {
+            this.handleInputChange(event);
+        });
+    }
+    ngOnInit() {
+        const ua = navigator.userAgent;
+        this.androidChrome = /chrome/i.test(ua) && /android/i.test(ua);
+        this.createMaskFromDateFormat();
+        this.initMask();
+    }
+    get mask() {
+        return this._mask ?? '';
+    }
+    set mask(val) {
+        this._mask = val;
+        this.initMask();
+        this.writeValue("");
+    }
+    writeValue(value) {
+        this.value = value;
+        if (this.input) {
+            if (this.value == undefined) {
+                this.input.value = "";
+            }
+            else {
+                this.input.value = this.value;
+            }
+            this.checkVal();
+            this.focusText = this.input.value;
+            this.updateFilledState();
+        }
+    }
+    onInputBlur(e) {
+        this.checkVal();
+        this.updateFilledState();
+        if (this.value != this.focusText) {
+            if (!this.input?.disabled &&
+                (this.value === undefined || this.value === null || this.value.indexOf(this.slotChar) >= 0)) {
+                this.value = "";
+                e.target.value = "";
+                this.host.updateModel(null);
+            }
+            this.updateModel(e);
+            const event = document.createEvent("HTMLEvents");
+            event.initEvent("change", true, false);
+            this.input?.dispatchEvent(event);
+        }
+    }
+    onKeyDown(e) {
+        if (this.host.readonlyInput) {
+            return;
+        }
+        const k = e.which || e.keyCode;
+        const iPhone = /iphone/i.test(navigator.userAgent);
+        let pos;
+        let begin;
+        let end;
+        this.oldVal = this.input?.value;
+        // Backspace, delete, and escape get special treatment
+        if (k === 8 || k === 46 || (iPhone && k === 127)) {
+            pos = this.caret();
+            begin = pos?.begin;
+            end = pos?.end;
+            if (begin && end) {
+                if (end - begin === 0) {
+                    begin = k !== 46 ? this.seekPrev(begin) : (end = this.seekNext(begin - 1));
+                    end = k === 46 ? this.seekNext(end) : end;
+                }
+                this.clearBuffer(begin, end);
+                this.shiftL(begin, end - 1);
+            }
+            this.updateModel(e);
+            e.preventDefault();
+        }
+        else if (k === 13) {
+            // Enter
+            this.onInputBlur(e);
+            this.updateModel(e);
+        }
+        else if (k === 27) {
+            // Escape
+            if (this.input && this.focusText) {
+                this.input.value = this.focusText;
+                this.caret(0, this.checkVal());
+            }
+            this.updateModel(e);
+            e.preventDefault();
+        }
+    }
+    onKeyPress(e) {
+        if (this.host.readonlyInput)
+            return;
+        const k = e.which || e.keyCode;
+        const pos = this.caret();
+        let p;
+        let c;
+        let next;
+        if (e.ctrlKey || e.altKey || e.metaKey || k < 32 || (k > 34 && k < 41)) {
+            // Ignore
+            return;
+        }
+        else if (k && k !== 13) {
+            if (!isNullOrUndefined(pos?.end) && !isNullOrUndefined(pos?.begin)) {
+                if (pos.end - pos.begin !== 0) {
+                    this.clearBuffer(pos.begin, pos.end);
+                    this.shiftL(pos.begin, pos.end - 1);
+                }
+            }
+            if (!isNullOrUndefined(pos?.begin)) {
+                p = this.seekNext(pos.begin - 1);
+            }
+            if (p < (this.len ?? 0)) {
+                c = String.fromCharCode(k);
+                if (this.tests?.[p].test(c)) {
+                    this.shiftR(p);
+                    this.buffer[p] = c;
+                    this.writeBuffer();
+                    next = this.seekNext(p);
+                    if (/android/i.test(navigator.userAgent)) {
+                        // Path for CSP Violation on FireFox OS 1.1
+                        const proxy = () => {
+                            this.caret(next);
+                        };
+                        setTimeout(proxy, 0);
+                    }
+                    else {
+                        this.caret(next);
+                    }
+                }
+            }
+            e.preventDefault();
+        }
+        this.updateModel(e);
+        this.updateFilledState();
+    }
+    createCompleteMask() {
+        switch (this.host.selectionMode) {
+            case "range":
+                return this.mask + ` ${this.host.rangeSeparator} ` + this.mask;
+            case "single":
+            case "multiple":
+                return this.mask;
+            default: return '';
+        }
+    }
+    checkVal(allow) {
+        // Try to place characters where they belong
+        const test = this.input?.value;
+        let lastMatch = -1;
+        let i;
+        let c;
+        let pos = 0;
+        for (i = 0; i < (this.len ?? 0); i++) {
+            if (this.tests?.[i]) {
+                this.buffer[i] = this.getPlaceholder(i);
+                while (pos++ < (test?.length ?? 0)) {
+                    c = test?.charAt(pos - 1);
+                    if (this.tests[i].test(c)) {
+                        this.buffer[i] = c;
+                        lastMatch = i;
+                        break;
+                    }
+                }
+                if (pos > (test?.length ?? 0)) {
+                    this.clearBuffer(i + 1, this.len);
+                    break;
+                }
+            }
+            else {
+                if (this.buffer[i] === test?.charAt(pos)) {
+                    pos++;
+                }
+                if (i < this.partialPosition) {
+                    lastMatch = i;
+                }
+            }
+        }
+        if (allow) {
+            this.writeBuffer();
+        }
+        else if (lastMatch + 1 < this.partialPosition) {
+            if (this.autoClear || this.buffer.join("") === this.defaultBuffer) {
+                // Invalid value. Remove it and replace it with the
+                // mask, which is the default behavior.
+                if (this.input?.value) {
+                    this.input.value = "";
+                }
+                this.clearBuffer(0, this.len);
+            }
+            else {
+                // Invalid value, but we opt to show the value to the
+                // user and allow them to correct their mistake.
+                this.writeBuffer();
+            }
+        }
+        else {
+            this.writeBuffer();
+            if (!isNullOrUndefined(this.input)) {
+                this.input.value = this.input.value.substring(0, lastMatch + 1);
+            }
+        }
+        return this.partialPosition ? i : this.firstNonMaskPos;
+    }
+    onInputFocus() {
+        if (this.host.readonlyInput)
+            return;
+        clearTimeout(this.caretTimeoutId);
+        let pos;
+        this.focusText = this.input?.value;
+        pos = this.checkVal();
+        this.caretTimeoutId = setTimeout(() => {
+            if (this.input !== document.activeElement) {
+                return;
+            }
+            this.writeBuffer();
+            if (pos == this.mask.replace("?", "").length) {
+                this.caret(0, pos);
+            }
+            else {
+                this.caret(pos);
+            }
+        }, 10);
+    }
+    onInputChange(event) {
+        if (this.androidChrome)
+            this.handleAndroidInput(event);
+        else
+            this.handleInputChange(event);
+    }
+    handleInputChange(event) {
+        if (this.host.readonlyInput)
+            return;
+        setTimeout(() => {
+            const pos = this.checkVal(true);
+            this.caret(pos);
+            this.updateModel(event);
+        }, 0);
+    }
+    updateModel(e) {
+        const updatedValue = e.target.value;
+        if (updatedValue !== null || updatedValue !== undefined) {
+            this.value = updatedValue;
+            this.host.onUserInput(e);
+        }
+    }
+    updateFilledState() {
+        this.filled = this.input && this.input.value != "";
+    }
+    focus() {
+        this.input?.focus();
+    }
+    initMask() {
+        const completeMask = this.createCompleteMask();
+        this.tests = [];
+        this.partialPosition = completeMask.length;
+        this.len = completeMask.length;
+        this.firstNonMaskPos = null;
+        this.defs = {
+            "9": "[0-9]",
+        };
+        const maskTokens = completeMask.split("");
+        for (let i = 0; i < maskTokens.length; i++) {
+            const c = maskTokens[i];
+            if (c == "?") {
+                this.len--;
+                this.partialPosition = i;
+            }
+            else if (this.defs[c]) {
+                this.tests.push(new RegExp(this.defs[c]));
+                if (this.firstNonMaskPos === null) {
+                    this.firstNonMaskPos = this.tests.length - 1;
+                }
+                if (i < this.partialPosition) {
+                    this.lastRequiredNonMaskPos = this.tests.length - 1;
+                }
+            }
+            else {
+                this.tests.push(null);
+            }
+        }
+        this.buffer = [];
+        for (let i = 0; i < maskTokens.length; i++) {
+            const c = maskTokens[i];
+            if (c != "?") {
+                if (this.defs[c]) {
+                    this.buffer.push(this.getPlaceholder(i));
+                }
+                else {
+                    this.buffer.push(c);
+                }
+            }
+        }
+        this.defaultBuffer = this.buffer.join("");
+    }
+    caret(first, last) {
+        let range, begin, end;
+        if (!this.input?.offsetParent || this.input !== document.activeElement) {
+            return { begin: 0, end: 0 };
+        }
+        if (typeof first == "number") {
+            begin = first;
+            end = typeof last === "number" ? last : begin;
+            if (this.input.setSelectionRange) {
+                this.input.setSelectionRange(begin, end);
+            }
+            else if (this.input["createTextRange"]) {
+                range = this.input["createTextRange"]();
+                range.collapse(true);
+                range.moveEnd("character", end);
+                range.moveStart("character", begin);
+                range.select();
+            }
+        }
+        else {
+            begin = this.input.selectionStart;
+            end = this.input.selectionEnd;
+            return { begin: begin, end: end };
+        }
+        return { begin: first ?? 0, end: last ?? 0 };
+    }
+    getPlaceholder(i) {
+        if (i < this.slotChar.length)
+            return this.slotChar.charAt(i);
+        return this.slotChar.charAt(0);
+    }
+    seekNext(pos) {
+        while (++pos < (this.len ?? 0)) {
+            if (this.tests?.[pos])
+                break;
+        }
+        return pos;
+    }
+    seekPrev(pos) {
+        while (--pos >= 0 && !this.tests?.[pos]) {
+            if (this.tests?.[pos])
+                break;
+        }
+        return pos;
+    }
+    shiftL(begin, end) {
+        let i;
+        let j;
+        if (begin < 0) {
+            return;
+        }
+        j = this.seekNext(end);
+        for (i = begin; i < (this.len ?? 0); i++) {
+            if (this.tests?.[i]) {
+                if (j < (this.len ?? 0) && this.tests[i].test(this.buffer[j])) {
+                    this.buffer[i] = this.buffer[j];
+                    this.buffer[j] = this.getPlaceholder(j);
+                }
+                else
+                    break;
+                j = this.seekNext(j);
+            }
+        }
+        this.writeBuffer();
+        if (!isNullOrUndefined(this.firstNonMaskPos)) {
+            this.caret(Math.max(this.firstNonMaskPos, begin));
+        }
+    }
+    shiftR(pos) {
+        let i;
+        let c = this.getPlaceholder(pos);
+        let j;
+        let t;
+        for (i = pos; i < (this.len ?? 0); i++) {
+            if (this.tests?.[i]) {
+                j = this.seekNext(i);
+                t = this.buffer[i];
+                this.buffer[i] = c;
+                if (j < (this.len ?? 0) && this.tests[j].test(t)) {
+                    c = t;
+                }
+                else
+                    break;
+            }
+        }
+    }
+    handleAndroidInput(e) {
+        const curVal = this.input?.value;
+        const pos = this.caret();
+        if (isNullOrUndefined(pos?.begin))
+            return;
+        if (this.oldVal && this.oldVal.length && this.oldVal.length > (curVal?.length ?? 0)) {
+            // A deletion or backspace happened
+            this.checkVal(true);
+            while (pos?.begin > 0 && !this.tests?.[pos.begin - 1]) {
+                pos.begin--;
+            }
+            if (pos.begin === 0) {
+                while (pos.begin < (this.firstNonMaskPos ?? 0) && !this.tests?.[pos.begin]) {
+                    pos.begin++;
+                }
+            }
+            setTimeout(() => {
+                this.caret(pos.begin, pos.begin);
+                if (this.isCompleted()) {
+                    const sentVal = curVal?.replace(this.slotChar, ""); // Limpa os caracteres placeholders extras caso ele esteja completo
+                    sentVal && this.updateCalendarValue(sentVal);
+                }
+            }, 0);
+        }
+        else {
+            this.checkVal(true);
+            while (pos.begin < (this.len ?? 0) && !this.tests?.[pos.begin]) {
+                pos.begin++;
+            }
+            if (!isNullOrUndefined(pos.begin)) {
+                setTimeout(() => {
+                    this.caret(pos.begin, pos.begin);
+                    if (this.isCompleted()) {
+                        const sentVal = curVal?.replace(this.slotChar, ""); // Limpa os caracteres placeholders extras caso ele esteja completo
+                        sentVal && this.updateCalendarValue(sentVal);
+                    }
+                }, 0);
+            }
+        }
+    }
+    updateCalendarValue(sentVal) {
+        // TODO verificar
+        const dateVal = this.host.parseValueFromString(sentVal);
+        if (this.host.isSelectable(dateVal.getDate(), dateVal.getMonth(), dateVal.getFullYear(), false)) {
+            this.host.updateModel(sentVal);
+            this.host.updateUI();
+        }
+    }
+    clearBuffer(start, end) {
+        let i;
+        for (i = start; i < end && i < (this.len ?? 0); i++) {
+            if (this.tests?.[i]) {
+                this.buffer[i] = this.getPlaceholder(i);
+            }
+        }
+    }
+    writeBuffer() {
+        if (!isNullOrUndefined(this.input)) {
+            this.input.value = this.buffer.join("");
+        }
+    }
+    createMaskFromDateFormat() {
+        const calendar = this.host;
+        let mask = this.autoClear ? "?" : "";
+        if (!calendar.timeOnly) {
+            let dateFormat = calendar.dateFormat;
+            dateFormat = dateFormat?.replace(/y/g, "yy");
+            mask += dateFormat?.replace(/[^/*,.\-+\[\]\\]/g, "9");
+            if (calendar.showTime) {
+                mask += " ";
+            }
+        }
+        if (calendar.showTime || calendar.timeOnly) {
+            mask += "99:99";
+            if (calendar.showSeconds) {
+                mask += ":99";
+            }
+        }
+        this._mask = mask;
+        this.initMask();
+    }
+    isCompleted() {
+        for (let i = (this.firstNonMaskPos ?? 0); i <= this.lastRequiredNonMaskPos; i++) {
+            if (this.tests?.[i] && this.buffer[i] === this.getPlaceholder(i)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    ngAfterViewChecked() {
+        if (this.host.inputfieldViewChild && this.firstTime) {
+            this.firstTime = false;
+            this.setListeners();
+            if (!isNullOrUndefined(this.input)) {
+                this.input.type = "tel";
+            }
+        }
+    }
+    ngOnDestroy() {
+        if (this.focusListener)
+            this.focusListener();
+        if (this.blurListener)
+            this.blurListener();
+        if (this.keydownListener)
+            this.keydownListener();
+        if (this.keypressListener)
+            this.keypressListener();
+        if (this.inputListener)
+            this.inputListener();
+        if (this.pasteListener)
+            this.pasteListener();
+    }
+    onKeydownEventTest(e) {
+        const { key } = e;
+        if (key == "Tab") {
+            // Este código foi implementado para corrigir um problema no componente na v9
+            // Deve ser removido assim que atualizarmos o PrimeNG para a v10
+            const allFocusableElements = document.querySelectorAll(this.SELECTORS);
+            let nextIsFocusable = false;
+            let previousFocusable;
+            let forceCloseModal = true;
+            allFocusableElements.forEach((element) => {
+                if (!e.shiftKey) {
+                    if (nextIsFocusable && element.id) {
+                        this.focusableElement(element.id, forceCloseModal);
+                        nextIsFocusable = false;
+                        e.preventDefault();
+                        return;
+                    }
+                }
+                let activeTagName = window.document.activeElement?.tagName;
+                if (e.shiftKey && element.id && element.tagName === "INPUT" && activeTagName == "BUTTON") {
+                    previousFocusable = element.id;
+                    forceCloseModal = false;
+                }
+                if (element.id === this.host.inputId) {
+                    if (previousFocusable) {
+                        this.focusableElement(previousFocusable, forceCloseModal);
+                        e.preventDefault();
+                        forceCloseModal = true;
+                        return;
+                    }
+                    nextIsFocusable = true;
+                }
+                else if (e.shiftKey && element.id) {
+                    previousFocusable = element.id;
+                }
+            });
+        }
+    }
+    focusableElement(id, hide) {
+        const htmlElement = window.document.getElementById(id);
+        htmlElement?.focus();
+        if (hide) {
+            this.host.hideOverlay();
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CalendarMaskDirective, deps: [{ token: i1.Calendar }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: CalendarMaskDirective, selector: "p-calendar[sCalendarMask]", inputs: { slotChar: "slotChar", autoClear: "autoClear" }, host: { listeners: { "keydown": "onKeydownEventTest($event)" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CalendarMaskDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'p-calendar[sCalendarMask]',
+                }]
+        }], ctorParameters: () => [{ type: i1.Calendar }, { type: i0.Renderer2 }], propDecorators: { slotChar: [{
+                type: Input
+            }], autoClear: [{
+                type: Input
+            }], onKeydownEventTest: [{
+                type: HostListener,
+                args: ["keydown", ["$event"]]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"calendar-mask.directive.js","sourceRoot":"","sources":["../../../../../projects/angular-components/calendar-mask/src/lib/calendar-mask/calendar-mask.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { AfterViewChecked, Directive, HostListener, Input, OnDestroy, OnInit, Renderer2 } from '@angular/core';\nimport { isNullOrUndefined } from '@seniorsistemas/angular-components/utils';\n\nimport { Calendar } from 'primeng/calendar';\n\n@Directive({\n    selector: 'p-calendar[sCalendarMask]',\n})\nexport class CalendarMaskDirective implements OnInit, OnDestroy, AfterViewChecked {\n    // TODO: Mudei um monte de coisa e tem que testar se isso ainda funciona\n    // TODO: Ainda está sendo usada esta diretiva?\n    SELECTORS = 'button, [href], input, select, textarea, [tabindex]:not([tabindex=\"-1\"])';\n\n    @Input()\n    public slotChar = \"_\";\n\n    @Input()\n    public autoClear = false;\n\n    public value: any;\n    public input?: HTMLInputElement;\n    public filled?: boolean;\n\n    private _mask?: string;\n    private defs: any;\n    private tests?: any[];\n    private partialPosition: any;\n    private firstNonMaskPos: number | null | undefined;\n    private lastRequiredNonMaskPos: any;\n    private len?: number;\n    private oldVal?: string;\n    private buffer: any;\n    private defaultBuffer?: string;\n    private focusText?: string;\n    private caretTimeoutId: any;\n    private androidChrome?: boolean;\n    private firstTime = true;\n\n    private focusListener?: () => void;\n    private blurListener?: () => void;\n    private keydownListener?: () => void;\n    private keypressListener?: () => void;\n    private inputListener?: () => void;\n    private pasteListener?: () => void;\n\n    constructor(\n        public host: Calendar,\n        public renderer: Renderer2\n    ) { }\n\n    private setListeners() {\n        this.input = this.host.inputfieldViewChild?.nativeElement;\n        this.value = this.input?.value;\n\n        this.focusListener = this.renderer.listen(this.input, \"focus\", () => {\n            this.onInputFocus();\n        });\n\n        this.blurListener = this.renderer.listen(this.input, \"blur\", (event: any) => {\n            this.onInputBlur(event);\n        });\n\n        this.keydownListener = this.renderer.listen(this.input, \"keydown\", (event: any) => {\n            this.onKeyDown(event);\n        });\n\n        this.keypressListener = this.renderer.listen(this.input, \"keypress\", (event: any) => {\n            this.onKeyPress(event);\n        });\n\n        this.inputListener = this.renderer.listen(this.input, \"input\", (event: any) => {\n            this.onInputChange(event);\n        });\n\n        this.pasteListener = this.renderer.listen(this.input, \"paste\", (event: any) => {\n            this.handleInputChange(event);\n        });\n    }\n\n    public ngOnInit() {\n        const ua = navigator.userAgent;\n        this.androidChrome = /chrome/i.test(ua) && /android/i.test(ua);\n\n        this.createMaskFromDateFormat();\n        this.initMask();\n    }\n\n    get mask(): string {\n        return this._mask ?? '';\n    }\n\n    set mask(val: string) {\n        this._mask = val;\n\n        this.initMask();\n        this.writeValue(\"\");\n    }\n\n    public writeValue(value: any): void {\n        this.value = value;\n\n        if (this.input) {\n            if (this.value == undefined) {\n                this.input.value = \"\";\n            } else {\n                this.input.value = this.value;\n            }\n\n            this.checkVal();\n            this.focusText = this.input.value;\n            this.updateFilledState();\n        }\n    }\n\n    public onInputBlur(e: any) {\n        this.checkVal();\n        this.updateFilledState();\n\n        if (this.value != this.focusText) {\n            if (\n                !this.input?.disabled &&\n                (this.value === undefined || this.value === null || (this.value as string).indexOf(this.slotChar) >= 0)\n            ) {\n                this.value = \"\";\n                e.target.value = \"\";\n                this.host.updateModel(null);\n            }\n\n            this.updateModel(e);\n            const event = document.createEvent(\"HTMLEvents\");\n            event.initEvent(\"change\", true, false);\n            this.input?.dispatchEvent(event);\n        }\n    }\n\n    public onKeyDown(e: any) {\n        if (this.host.readonlyInput) {\n            return;\n        }\n\n        const k = e.which || e.keyCode;\n        const iPhone = /iphone/i.test(navigator.userAgent);\n        let pos;\n        let begin;\n        let end;\n        this.oldVal = this.input?.value;\n\n        // Backspace, delete, and escape get special treatment\n        if (k === 8 || k === 46 || (iPhone && k === 127)) {\n            pos = this.caret();\n            begin = pos?.begin;\n            end = pos?.end;\n\n            if (begin && end) {\n                if (end - begin === 0) {\n                    begin = k !== 46 ? this.seekPrev(begin) : (end = this.seekNext(begin - 1));\n                    end = k === 46 ? this.seekNext(end) : end;\n                }\n\n                this.clearBuffer(begin, end);\n                this.shiftL(begin, end - 1);\n            }\n\n            this.updateModel(e);\n            e.preventDefault();\n        } else if (k === 13) {\n            // Enter\n            this.onInputBlur(e);\n            this.updateModel(e);\n        } else if (k === 27) {\n            // Escape\n            if (this.input && this.focusText) {\n                this.input.value = this.focusText;\n                this.caret(0, this.checkVal());\n            }\n            this.updateModel(e);\n            e.preventDefault();\n        }\n    }\n\n    public onKeyPress(e: any) {\n        if (this.host.readonlyInput) return;\n\n        const k = e.which || e.keyCode;\n        const pos = this.caret();\n        let p;\n        let c;\n        let next: any;\n\n        if (e.ctrlKey || e.altKey || e.metaKey || k < 32 || (k > 34 && k < 41)) {\n            // Ignore\n            return;\n        } else if (k && k !== 13) {\n            if (!isNullOrUndefined(pos?.end) && !isNullOrUndefined(pos?.begin)) {\n                if (pos.end - pos.begin !== 0) {\n                    this.clearBuffer(pos.begin, pos.end);\n                    this.shiftL(pos.begin, pos.end - 1);\n                }\n            }\n\n            if (!isNullOrUndefined(pos?.begin)) {\n                p = this.seekNext(pos.begin - 1);\n            }\n\n            if (p < (this.len ?? 0)) {\n                c = String.fromCharCode(k);\n                if (this.tests?.[p].test(c)) {\n                    this.shiftR(p);\n\n                    this.buffer[p] = c;\n                    this.writeBuffer();\n                    next = this.seekNext(p);\n\n                    if (/android/i.test(navigator.userAgent)) {\n                        // Path for CSP Violation on FireFox OS 1.1\n                        const proxy = () => {\n                            this.caret(next);\n                        };\n\n                        setTimeout(proxy, 0);\n                    } else {\n                        this.caret(next);\n                    }\n                }\n            }\n            e.preventDefault();\n        }\n\n        this.updateModel(e);\n        this.updateFilledState();\n    }\n\n    private createCompleteMask(): string {\n        switch (this.host.selectionMode) {\n            case \"range\":\n                return this.mask + ` ${this.host.rangeSeparator} ` + this.mask;\n            case \"single\":\n            case \"multiple\":\n                return this.mask;\n            default: return '';\n        }\n    }\n\n    public checkVal(allow?: boolean) {\n        // Try to place characters where they belong\n        const test = this.input?.value;\n        let lastMatch = -1;\n        let i: any;\n        let c: any;\n        let pos = 0;\n\n        for (i = 0; i < (this.len ?? 0); i++) {\n            if (this.tests?.[i]) {\n                this.buffer[i] = this.getPlaceholder(i);\n                while (pos++ < (test?.length ?? 0)) {\n                    c = test?.charAt(pos - 1);\n                    if (this.tests[i].test(c)) {\n                        this.buffer[i] = c;\n                        lastMatch = i;\n                        break;\n                    }\n                }\n                if (pos > (test?.length ?? 0)) {\n                    this.clearBuffer(i + 1, this.len);\n                    break;\n                }\n            } else {\n                if (this.buffer[i] === test?.charAt(pos)) {\n                    pos++;\n                }\n                if (i < this.partialPosition) {\n                    lastMatch = i;\n                }\n            }\n        }\n        if (allow) {\n            this.writeBuffer();\n        } else if (lastMatch + 1 < this.partialPosition) {\n            if (this.autoClear || this.buffer.join(\"\") === this.defaultBuffer) {\n                // Invalid value. Remove it and replace it with the\n                // mask, which is the default behavior.\n                if (this.input?.value) {\n                    this.input.value = \"\";\n                }\n                this.clearBuffer(0, this.len);\n            } else {\n                // Invalid value, but we opt to show the value to the\n                // user and allow them to correct their mistake.\n                this.writeBuffer();\n            }\n        } else {\n            this.writeBuffer();\n            if (!isNullOrUndefined(this.input)) {\n                this.input.value = this.input.value.substring(0, lastMatch + 1);\n            }\n        }\n\n        return this.partialPosition ? i : this.firstNonMaskPos;\n    }\n\n    public onInputFocus() {\n        if (this.host.readonlyInput) return;\n\n        clearTimeout(this.caretTimeoutId);\n        let pos: any;\n\n        this.focusText = this.input?.value;\n\n        pos = this.checkVal();\n\n        this.caretTimeoutId = setTimeout(() => {\n            if (this.input !== document.activeElement) {\n                return;\n            }\n            this.writeBuffer();\n            if (pos == this.mask.replace(\"?\", \"\").length) {\n                this.caret(0, pos);\n            } else {\n                this.caret(pos);\n            }\n        }, 10);\n    }\n\n    public onInputChange(event: any) {\n        if (this.androidChrome) this.handleAndroidInput(event);\n        else this.handleInputChange(event);\n    }\n\n    public handleInputChange(event: any) {\n        if (this.host.readonlyInput) return;\n\n        setTimeout(() => {\n            const pos = this.checkVal(true);\n            this.caret(pos);\n            this.updateModel(event);\n        }, 0);\n    }\n\n    public updateModel(e: any) {\n        const updatedValue = e.target.value;\n        if (updatedValue !== null || updatedValue !== undefined) {\n            this.value = updatedValue;\n            this.host.onUserInput(e);\n        }\n    }\n\n    public updateFilledState() {\n        this.filled = this.input && this.input.value != \"\";\n    }\n\n    public focus() {\n        this.input?.focus();\n    }\n\n    private initMask() {\n        const completeMask = this.createCompleteMask();\n\n        this.tests = [];\n        this.partialPosition = completeMask.length;\n        this.len = completeMask.length;\n        this.firstNonMaskPos = null;\n        this.defs = {\n            \"9\": \"[0-9]\",\n        };\n\n        const maskTokens = completeMask.split(\"\");\n        for (let i = 0; i < maskTokens.length; i++) {\n            const c = maskTokens[i];\n\n            if (c == \"?\") {\n                this.len--;\n                this.partialPosition = i;\n            } else if (this.defs[c]) {\n                this.tests.push(new RegExp(this.defs[c]));\n\n                if (this.firstNonMaskPos === null) {\n                    this.firstNonMaskPos = this.tests.length - 1;\n                }\n\n                if (i < this.partialPosition) {\n                    this.lastRequiredNonMaskPos = this.tests.length - 1;\n                }\n            } else {\n                this.tests.push(null);\n            }\n        }\n\n        this.buffer = [];\n\n        for (let i = 0; i < maskTokens.length; i++) {\n            const c = maskTokens[i];\n\n            if (c != \"?\") {\n                if (this.defs[c]) {\n                    this.buffer.push(this.getPlaceholder(i));\n                } else {\n                    this.buffer.push(c);\n                }\n            }\n        }\n\n        this.defaultBuffer = this.buffer.join(\"\");\n    }\n\n    private caret(first?: number, last?: number) {\n        let range, begin, end;\n\n        if (!this.input?.offsetParent || this.input !== document.activeElement) {\n            return { begin: 0, end: 0 };\n        }\n\n        if (typeof first == \"number\") {\n            begin = first;\n            end = typeof last === \"number\" ? last : begin;\n\n            if (this.input.setSelectionRange) {\n                this.input.setSelectionRange(begin, end);\n            } else if ((this.input as any)[\"createTextRange\"]) {\n                range = (this.input as any)[\"createTextRange\"]();\n                range.collapse(true);\n                range.moveEnd(\"character\", end);\n                range.moveStart(\"character\", begin);\n                range.select();\n            }\n        } else {\n            begin = this.input.selectionStart;\n            end = this.input.selectionEnd;\n\n            return { begin: begin, end: end };\n        }\n\n        return { begin: first ?? 0, end: last ?? 0 };\n    }\n\n    private getPlaceholder(i: number) {\n        if (i < this.slotChar.length) return this.slotChar.charAt(i);\n        return this.slotChar.charAt(0);\n    }\n\n    private seekNext(pos: any) {\n        while (++pos < (this.len ?? 0)) {\n            if (this.tests?.[pos]) break;\n        }\n        return pos;\n    }\n\n    private seekPrev(pos: any) {\n        while (--pos >= 0 && !this.tests?.[pos]) {\n            if (this.tests?.[pos]) break;\n        }\n        return pos;\n    }\n\n    private shiftL(begin: number, end: number) {\n        let i: any;\n        let j: any;\n\n        if (begin < 0) {\n            return;\n        }\n\n        j = this.seekNext(end);\n\n        for (i = begin; i < (this.len ?? 0); i++) {\n            if (this.tests?.[i]) {\n                if (j < (this.len ?? 0) && this.tests[i].test(this.buffer[j])) {\n                    this.buffer[i] = this.buffer[j];\n                    this.buffer[j] = this.getPlaceholder(j);\n                } else break;\n\n                j = this.seekNext(j);\n            }\n        }\n        this.writeBuffer();\n        if (!isNullOrUndefined(this.firstNonMaskPos)) {\n            this.caret(Math.max(this.firstNonMaskPos, begin));\n        }\n    }\n\n    private shiftR(pos: any) {\n        let i: any;\n        let c = this.getPlaceholder(pos);\n        let j: any;\n        let t: any;\n\n        for (i = pos; i < (this.len ?? 0); i++) {\n            if (this.tests?.[i]) {\n                j = this.seekNext(i);\n                t = this.buffer[i];\n                this.buffer[i] = c;\n\n                if (j < (this.len ?? 0) && this.tests[j].test(t)) {\n                    c = t;\n                } else break;\n            }\n        }\n    }\n\n    private handleAndroidInput(e: any) {\n        const curVal = this.input?.value;\n        const pos = this.caret();\n\n        if (isNullOrUndefined(pos?.begin)) return;\n\n        if (this.oldVal && this.oldVal.length && this.oldVal.length > (curVal?.length ?? 0)) {\n            // A deletion or backspace happened\n            this.checkVal(true);\n            while (pos?.begin > 0 && !this.tests?.[pos.begin - 1]) {\n                pos.begin--;\n            }\n            if (pos.begin === 0) {\n                while (pos.begin < (this.firstNonMaskPos ?? 0) && !this.tests?.[pos.begin]) {\n                    pos.begin++;\n                }\n            }\n\n            setTimeout(() => {\n                this.caret(pos.begin!, pos.begin!);\n                if (this.isCompleted()) {\n                    const sentVal = curVal?.replace(this.slotChar, \"\"); // Limpa os caracteres placeholders extras caso ele esteja completo\n                    sentVal && this.updateCalendarValue(sentVal);\n                }\n            }, 0);\n        } else {\n            this.checkVal(true);\n\n            while (pos.begin < (this.len ?? 0) && !this.tests?.[pos.begin]) {\n                pos.begin++;\n            }\n\n            if (!isNullOrUndefined(pos.begin)) {\n                setTimeout(() => {\n                    this.caret(pos.begin!, pos.begin!);\n                    if (this.isCompleted()) {\n                        const sentVal = curVal?.replace(this.slotChar, \"\"); // Limpa os caracteres placeholders extras caso ele esteja completo\n                        sentVal && this.updateCalendarValue(sentVal);\n                    }\n                }, 0);\n            }\n        }\n    }\n\n    private updateCalendarValue(sentVal: string) {\n        // TODO verificar\n        const dateVal = <Date>this.host.parseValueFromString(sentVal);\n        if (this.host.isSelectable(dateVal.getDate(), dateVal.getMonth(), dateVal.getFullYear(), false)) {\n            this.host.updateModel(sentVal);\n            this.host.updateUI();\n        }\n    }\n\n    private clearBuffer(start: any, end: any) {\n        let i;\n\n        for (i = start; i < end && i < (this.len ?? 0); i++) {\n            if (this.tests?.[i]) {\n                this.buffer[i] = this.getPlaceholder(i);\n            }\n        }\n    }\n\n    private writeBuffer() {\n        if (!isNullOrUndefined(this.input)) {\n            this.input.value = this.buffer.join(\"\");\n        }\n    }\n\n    private createMaskFromDateFormat() {\n        const calendar = this.host;\n        let mask = this.autoClear ? \"?\" : \"\";\n\n        if (!calendar.timeOnly) {\n            let dateFormat = calendar.dateFormat;\n            dateFormat = dateFormat?.replace(/y/g, \"yy\");\n            mask += dateFormat?.replace(/[^/*,.\\-+\\[\\]\\\\]/g, \"9\");\n            if (calendar.showTime) {\n                mask += \" \";\n            }\n        }\n\n        if (calendar.showTime || calendar.timeOnly) {\n            mask += \"99:99\";\n            if (calendar.showSeconds) {\n                mask += \":99\";\n            }\n        }\n\n        this._mask = mask;\n\n        this.initMask();\n    }\n\n    isCompleted(): boolean {\n        for (let i = (this.firstNonMaskPos ?? 0); i <= this.lastRequiredNonMaskPos; i++) {\n            if (this.tests?.[i] && this.buffer[i] === this.getPlaceholder(i)) {\n                return false;\n            }\n        }\n\n        return true;\n    }\n\n    ngAfterViewChecked(): void {\n        if (this.host.inputfieldViewChild && this.firstTime) {\n            this.firstTime = false;\n            this.setListeners();\n            if (!isNullOrUndefined(this.input)) {\n                this.input.type = \"tel\";\n            }\n        }\n    }\n\n    ngOnDestroy(): void {\n        if (this.focusListener) this.focusListener();\n        if (this.blurListener) this.blurListener();\n        if (this.keydownListener) this.keydownListener();\n        if (this.keypressListener) this.keypressListener();\n        if (this.inputListener) this.inputListener();\n        if (this.pasteListener) this.pasteListener();\n    }\n\n    @HostListener(\"keydown\", [\"$event\"])\n    onKeydownEventTest(e: KeyboardEvent) {\n        const { key } = e;\n        if (key == \"Tab\") {\n            // Este código foi implementado para corrigir um problema no componente na v9\n            // Deve ser removido assim que atualizarmos o PrimeNG para a v10\n            const allFocusableElements = document.querySelectorAll(this.SELECTORS);\n            let nextIsFocusable = false;\n            let previousFocusable: string;\n            let forceCloseModal = true;\n            allFocusableElements.forEach((element) => {\n                if (!e.shiftKey) {\n                    if (nextIsFocusable && element.id) {\n                        this.focusableElement(element.id, forceCloseModal);\n                        nextIsFocusable = false;\n                        e.preventDefault();\n                        return;\n                    }\n                }\n\n                let activeTagName = window.document.activeElement?.tagName;\n                if (e.shiftKey && element.id && element.tagName === \"INPUT\" && activeTagName == \"BUTTON\") {\n                    previousFocusable = element.id;\n                    forceCloseModal = false;\n                }\n\n                if (element.id === this.host.inputId) {\n                    if (previousFocusable) {\n                        this.focusableElement(previousFocusable, forceCloseModal);\n                        e.preventDefault();\n                        forceCloseModal = true;\n                        return;\n                    }\n                    nextIsFocusable = true;\n                } else if (e.shiftKey && element.id) {\n                    previousFocusable = element.id;\n                }\n            });\n        }\n    }\n\n    public focusableElement(id: string, hide: boolean) {\n        const htmlElement = window.document.getElementById(id);\n        htmlElement?.focus();\n        if (hide) {\n            this.host.hideOverlay();\n        }\n    }\n}\n"]}