@po-ui/ng-components 5.22.1 → 6.1.0

package/esm2020/lib/components/po-field/po-datepicker-range/po-datepicker-range.component.mjs

@@ -0,0 +1,528 @@
+import { Component, ElementRef, forwardRef, ViewChild, ChangeDetectionStrategy } from '@angular/core';
+import { NG_VALIDATORS, NG_VALUE_ACCESSOR } from '@angular/forms';
+import { PoControlPositionService } from './../../../services/po-control-position/po-control-position.service';
+import { PoDatepickerRangeBaseComponent } from './po-datepicker-range-base.component';
+import { PoMask } from '../po-input/po-mask';
+import * as i0 from "@angular/core";
+import * as i1 from "./../../../services/po-control-position/po-control-position.service";
+import * as i2 from "./../../../services/po-date/po-date.service";
+import * as i3 from "../../../services/po-language/po-language.service";
+import * as i4 from "../po-field-container/po-field-container.component";
+import * as i5 from "@angular/common";
+import * as i6 from "../po-field-container/po-field-container-bottom/po-field-container-bottom.component";
+import * as i7 from "../po-clean/po-clean.component";
+import * as i8 from "../../po-calendar/po-calendar.component";
+import * as i9 from "@angular/forms";
+const _c0 = ["dateRangeField"];
+const _c1 = ["endDateInput"];
+const _c2 = ["startDateInput"];
+const _c3 = ["iconCalendar"];
+const _c4 = ["calendarPicker"];
+function PoDatepickerRangeComponent_po_clean_12_Template(rf, ctx) { if (rf & 1) {
+    const _r7 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "po-clean", 15);
+    i0.ɵɵlistener("p-change-event", function PoDatepickerRangeComponent_po_clean_12_Template_po_clean_p_change_event_0_listener() { i0.ɵɵrestoreView(_r7); const ctx_r6 = i0.ɵɵnextContext(); return ctx_r6.clear(); });
+    i0.ɵɵelementEnd();
+} }
+function PoDatepickerRangeComponent_ng_container_17_Template(rf, ctx) { if (rf & 1) {
+    const _r10 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementContainerStart(0);
+    i0.ɵɵelementStart(1, "div", 16, 17);
+    i0.ɵɵelementStart(3, "po-calendar", 18);
+    i0.ɵɵlistener("ngModelChange", function PoDatepickerRangeComponent_ng_container_17_Template_po_calendar_ngModelChange_3_listener($event) { i0.ɵɵrestoreView(_r10); const ctx_r9 = i0.ɵɵnextContext(); return ctx_r9.onCalendarChange($event); });
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementContainerEnd();
+} if (rf & 2) {
+    const ctx_r5 = i0.ɵɵnextContext();
+    i0.ɵɵadvance(3);
+    i0.ɵɵproperty("ngModel", ctx_r5.dateRange)("p-max-date", ctx_r5.maxDate)("p-min-date", ctx_r5.minDate);
+} }
+const arrowLeftKey = 37;
+const arrowRightKey = 39;
+const backspaceKey = 8;
+const poDatepickerRangeDateLengthDefault = 10;
+const poCalendarContentOffset = 8;
+const poCalendarPositionDefault = 'bottom-left';
+/* istanbul ignore next */
+const providers = [
+    {
+        provide: NG_VALUE_ACCESSOR,
+        // eslint-disable-next-line
+        useExisting: forwardRef(() => PoDatepickerRangeComponent),
+        multi: true
+    },
+    {
+        provide: NG_VALIDATORS,
+        // eslint-disable-next-line
+        useExisting: forwardRef(() => PoDatepickerRangeComponent),
+        multi: true
+    },
+    PoControlPositionService
+];
+/**
+ * @docsExtends PoDatepickerRangeBaseComponent
+ *
+ * @example
+ *
+ * <example name="po-datepicker-range-basic" title="PO Datepicker Range Basic">
+ *  <file name="sample-po-datepicker-range-basic/sample-po-datepicker-range-basic.component.html"> </file>
+ *  <file name="sample-po-datepicker-range-basic/sample-po-datepicker-range-basic.component.ts"> </file>
+ * </example>
+ *
+ * <example name="po-datepicker-range-labs" title="PO Datepicker Range Labs">
+ *  <file name="sample-po-datepicker-range-labs/sample-po-datepicker-range-labs.component.html"> </file>
+ *  <file name="sample-po-datepicker-range-labs/sample-po-datepicker-range-labs.component.ts"> </file>
+ * </example>
+ *
+ * <example name="po-datepicker-range-vacations" title="PO Datepicker Range - Vacations Suggestion">
+ *  <file name="sample-po-datepicker-range-vacations/sample-po-datepicker-range-vacations.component.html"> </file>
+ *  <file name="sample-po-datepicker-range-vacations/sample-po-datepicker-range-vacations.component.ts"> </file>
+ * </example>
+ *
+ * <example name="po-datepicker-range-vacations-reactive-form" title="PO Datepicker Range - Vacations Reactive Form">
+ *  <file name="sample-po-datepicker-range-vacations-reactive-form/sample-po-datepicker-range-vacations-reactive-form.component.html">
+ *  </file>
+ *  <file name="sample-po-datepicker-range-vacations-reactive-form/sample-po-datepicker-range-vacations-reactive-form.component.ts">
+ *  </file>
+ * </example>
+ */
+export class PoDatepickerRangeComponent extends PoDatepickerRangeBaseComponent {
+    constructor(changeDetector, controlPosition, renderer, cd, poDateService, poDatepickerRangeElement, poLanguageService) {
+        super(poDateService, poLanguageService);
+        this.changeDetector = changeDetector;
+        this.controlPosition = controlPosition;
+        this.renderer = renderer;
+        this.cd = cd;
+        this.isCalendarVisible = false;
+        this.onScroll = () => {
+            if (this.isCalendarVisible) {
+                this.controlPosition.adjustPosition(poCalendarPositionDefault);
+            }
+        };
+        this.poDatepickerRangeElement = poDatepickerRangeElement;
+    }
+    get autocomplete() {
+        return this.noAutocomplete ? 'off' : 'on';
+    }
+    get enableCleaner() {
+        return this.clean && (this.startDateInputValue || this.endDateInputValue) && !this.disabled && !this.readonly;
+    }
+    get endDateInputName() {
+        return 'end-date';
+    }
+    get endDateInputValue() {
+        return this.endDateInput.nativeElement.value;
+    }
+    get getErrorMessage() {
+        return this.errorMessage !== '' && this.hasInvalidClass() ? this.errorMessage : '';
+    }
+    get isDateRangeInputUncompleted() {
+        return (this.endDateInputValue.length < poDatepickerRangeDateLengthDefault &&
+            this.startDateInputValue.length < poDatepickerRangeDateLengthDefault);
+    }
+    get isDirtyDateRangeInput() {
+        return this.endDateInputValue.length > 0 || this.startDateInputValue.length > 0;
+    }
+    get startDateInputName() {
+        return 'start-date';
+    }
+    get startDateInputValue() {
+        return this.startDateInput.nativeElement.value;
+    }
+    static getKeyCode(event) {
+        return event.keyCode || event.which;
+    }
+    static getTargetElement(event) {
+        return event.target || event.srcElement;
+    }
+    static isValidKey(keyCode) {
+        const isNumericKey = keyCode >= 48 && keyCode <= 57;
+        const isNumericNumpadKey = keyCode >= 96 && keyCode <= 105;
+        return isNumericKey || isNumericNumpadKey;
+    }
+    ngAfterViewInit() {
+        if (this.autoFocus) {
+            this.focus();
+        }
+    }
+    ngOnInit() {
+        // Classe de máscara
+        this.poMaskObject = this.buildMask();
+    }
+    ngOnChanges(changes) {
+        if (changes.minDate || changes.maxDate) {
+            this.validateModel(this.dateRange);
+        }
+    }
+    ngOnDestroy() {
+        this.removeListeners();
+    }
+    clear() {
+        this.resetDateRangeInputValidation();
+        this.dateRange = { start: '', end: '' };
+        this.updateScreenByModel(this.dateRange);
+        this.updateModel(this.dateRange);
+    }
+    eventOnClick($event) {
+        this.poMaskObject.click($event);
+    }
+    /**
+     * Função que atribui foco ao componente.
+     *
+     * Para utilizá-la é necessário ter a instância do componente no DOM, podendo ser utilizado o ViewChild da seguinte forma:
+     *
+     * ```
+     * import { PoDatepickerRangeComponent } from '@po-ui/ng-components';
+     *
+     * ...
+     *
+     * @ViewChild(PoDatepickerRangeComponent, { static: true }) datepickerRange: PoDatepickerRangeComponent;
+     *
+     * focusDatepickerRange() {
+     *   this.datepickerRange.focus();
+     * }
+     * ```
+     */
+    focus() {
+        if (!this.disabled) {
+            this.startDateInput.nativeElement.focus();
+        }
+    }
+    onBlur(event) {
+        this.onTouchedModel?.();
+        const isStartDateTargetEvent = event.target.name === this.startDateInputName;
+        this.updateModelByScreen(isStartDateTargetEvent);
+        this.removeFocusFromDatePickerRangeField();
+    }
+    onCalendarChange({ start, end }) {
+        const isStartDateTargetEvent = start && !end;
+        this.updateScreenByModel({ start: start || '', end: end || '' });
+        this.updateModelByScreen(isStartDateTargetEvent, start || '', end || '');
+        if (start && end) {
+            setTimeout(() => {
+                this.isCalendarVisible = false;
+                this.cd.markForCheck();
+            }, 300);
+        }
+    }
+    onFocus(event) {
+        this.applyFocusOnDatePickerRangeField();
+        this.poMaskObject.resetPositions(event);
+    }
+    onKeydown(event) {
+        if (this.readonly) {
+            return;
+        }
+        if (this.isSetFocusOnBackspace(event)) {
+            event.preventDefault();
+            this.setFocusOnBackspace();
+        }
+        else {
+            this.poMaskObject.keydown(event);
+        }
+    }
+    onKeyup(event) {
+        if (this.readonly) {
+            return;
+        }
+        const isStartDateTargetEvent = event.target.name === this.startDateInputName;
+        this.setFocus(event);
+        this.poMaskObject.keyup(event);
+        this.updateModelWhenComplete(isStartDateTargetEvent, this.startDateInputValue, this.endDateInputValue);
+    }
+    resetDateRangeInputValidation() {
+        this.isStartDateRangeInputValid = true;
+        this.isDateRangeInputFormatValid = true;
+    }
+    toggleCalendar() {
+        if (this.disabled || this.readonly) {
+            return;
+        }
+        this.isCalendarVisible = !this.isCalendarVisible;
+        this.changeDetector.detectChanges();
+        if (this.isCalendarVisible) {
+            this.setCalendarPosition();
+            this.initializeListeners();
+        }
+        else {
+            this.removeListeners();
+        }
+    }
+    updateScreenByModel(model) {
+        const dateRange = { start: model.start, end: model.end };
+        const isStartDateValid = this.poDateService.isDateRangeValid(dateRange.end, dateRange.start);
+        const isDateValid = date => !this.dateFormatFailed(date) && isStartDateValid;
+        const endDateFormated = isDateValid(dateRange.end) ? this.formatModelToScreen(dateRange.end) : '';
+        const startDateFormated = isDateValid(dateRange.start) ? this.formatModelToScreen(dateRange.start) : '';
+        this.endDateInput.nativeElement.value = endDateFormated;
+        this.startDateInput.nativeElement.value = startDateFormated;
+        this.changeDetector.detectChanges();
+    }
+    applyFocusOnDatePickerRangeField() {
+        this.dateRangeField.nativeElement.classList.add('po-datepicker-range-field-focused');
+    }
+    // Retorna um objeto do tipo PoMask com a mascara configurada.
+    buildMask() {
+        let mask = this.format.toUpperCase();
+        mask = mask.replace(/DD/g, '99');
+        mask = mask.replace(/MM/g, '99');
+        mask = mask.replace(/YYYY/g, '9999');
+        return new PoMask(mask, true);
+    }
+    formatDate(format, day = '', month = '', year = '') {
+        let dateFormatted = format;
+        day = day && day.includes('T') ? day.slice(0, 2) : day;
+        dateFormatted = dateFormatted.replace('dd', ('0' + day).slice(-2));
+        dateFormatted = dateFormatted.replace('mm', ('0' + month).slice(-2));
+        dateFormatted = dateFormatted.replace('yyyy', String(year));
+        return dateFormatted;
+    }
+    formatScreenToModel(value = '') {
+        const [day, month, year] = value.split('/');
+        return value ? this.formatDate('yyyy-mm-dd', day, month, year) : '';
+    }
+    formatModelToScreen(value = '') {
+        const [year, month, day] = value.split('-');
+        return value ? this.formatDate(this.format, day, month, year) : '';
+    }
+    getDateRangeFormatValidation(startDate, endDate, isStartDateTargetEvent) {
+        this.setDateRangeInputValidation(startDate, endDate);
+        return {
+            isValid: this.isDateRangeInputFormatValid && this.isStartDateRangeInputValid && this.verifyValidDate(startDate, endDate),
+            dateRangeModel: this.getValidatedModel(startDate, endDate, isStartDateTargetEvent)
+        };
+    }
+    getValidatedModel(startDate, endDate, isStartDateTargetEvent) {
+        const dateRangeModel = { start: '', end: '' };
+        dateRangeModel.end =
+            (isStartDateTargetEvent || this.isStartDateRangeInputValid) && !this.dateFormatFailed(endDate) ? endDate : '';
+        dateRangeModel.start =
+            (!isStartDateTargetEvent || this.isStartDateRangeInputValid) && !this.dateFormatFailed(startDate)
+                ? startDate
+                : '';
+        return dateRangeModel;
+    }
+    hasAttrCalendar(element) {
+        const attrCalendar = 'attr-calendar';
+        return element?.hasAttribute(attrCalendar) || element?.parentElement?.hasAttribute(attrCalendar);
+    }
+    hasInvalidClass() {
+        return (this.poDatepickerRangeElement.nativeElement.classList.contains('ng-invalid') &&
+            this.poDatepickerRangeElement.nativeElement.classList.contains('ng-dirty'));
+    }
+    initializeListeners() {
+        this.clickListener = this.renderer.listen('document', 'click', (event) => {
+            this.wasClickedOnPicker(event);
+        });
+        this.eventResizeListener = this.renderer.listen('window', 'resize', () => {
+            this.isCalendarVisible = false;
+        });
+        window.addEventListener('scroll', this.onScroll, true);
+    }
+    isEqualBeforeValue(startDate, endDate) {
+        return this.isDateRangeInputFormatValid && endDate === this.dateRange.end && startDate === this.dateRange.start;
+    }
+    isSetFocusOnBackspace(event) {
+        return (event.target.name === this.endDateInputName &&
+            this.endDateInput.nativeElement.selectionStart === 0 &&
+            this.endDateInput.nativeElement.selectionEnd === 0 &&
+            event.keyCode === backspaceKey);
+    }
+    removeFocusFromDatePickerRangeField() {
+        this.dateRangeField.nativeElement.classList.remove('po-datepicker-range-field-focused');
+    }
+    setDateRangeInputValidation(startDate, endDate) {
+        this.isStartDateRangeInputValid = this.poDateService.isDateRangeValid(endDate, startDate);
+        this.isDateRangeInputFormatValid = !this.dateFormatFailed(startDate) && !this.dateFormatFailed(endDate);
+    }
+    setFocus(event) {
+        const inputElement = PoDatepickerRangeComponent.getTargetElement(event);
+        const keyCode = PoDatepickerRangeComponent.getKeyCode(event);
+        const inputName = inputElement['name'];
+        this.setFocusOnArrowLeft(keyCode, inputName);
+        this.setFocusOnArrowRight(keyCode, inputName, inputElement);
+        this.setFocusOnStartDateCompleted(keyCode, inputName);
+    }
+    setFocusAndPosition(position, inputElement, selectionRange) {
+        this.focusOnElement(inputElement);
+        setTimeout(() => {
+            inputElement.nativeElement.setSelectionRange(selectionRange, selectionRange);
+            this.poMaskObject.initialPosition = position;
+            this.poMaskObject.finalPosition = position;
+        });
+    }
+    focusOnElement(inputElement) {
+        inputElement.nativeElement.focus();
+    }
+    removeListeners() {
+        if (this.clickListener) {
+            this.clickListener();
+        }
+        if (this.eventResizeListener) {
+            this.eventResizeListener();
+        }
+        window.removeEventListener('scroll', this.onScroll, true);
+    }
+    setCalendarPosition() {
+        this.controlPosition.setElements(this.calendarPicker.nativeElement, poCalendarContentOffset, this.dateRangeField, ['bottom-left', 'bottom-right', 'top-left', 'top-right'], false, true);
+        this.controlPosition.adjustPosition(poCalendarPositionDefault);
+    }
+    setFocusOnArrowLeft(keyCode, inputName) {
+        const isCursorAtStartOfInput = this.endDateInput.nativeElement.selectionStart === 0;
+        if (inputName === this.endDateInputName && isCursorAtStartOfInput && keyCode === arrowLeftKey) {
+            const inputLength = this.startDateInput.nativeElement.value.length;
+            this.setFocusAndPosition(inputLength, this.startDateInput, inputLength);
+        }
+    }
+    setFocusOnArrowRight(keyCode, inputName, inputElement) {
+        const isCursorAtEndOfInput = this.startDateInput.nativeElement.selectionStart === inputElement.value.length;
+        if (inputName === this.startDateInputName && isCursorAtEndOfInput && keyCode === arrowRightKey) {
+            this.setFocusAndPosition(0, this.endDateInput, 0);
+        }
+    }
+    setFocusOnBackspace() {
+        const inputLength = this.startDateInput.nativeElement.value.length;
+        this.startDateInput.nativeElement.value = this.startDateInputValue.slice(0, -1);
+        this.setFocusAndPosition(inputLength, this.startDateInput, inputLength);
+    }
+    setFocusOnStartDateCompleted(keyCode, inputName) {
+        const isLastKeyPressed = this.startDateInput.nativeElement.selectionStart === poDatepickerRangeDateLengthDefault;
+        const isNewDateCompleted = this.startDateInputValue.length === poDatepickerRangeDateLengthDefault && isLastKeyPressed;
+        const isValidKey = PoDatepickerRangeComponent.isValidKey(keyCode);
+        if (inputName === this.startDateInputName && isNewDateCompleted && isValidKey) {
+            this.setFocusAndPosition(0, this.endDateInput, 0);
+        }
+    }
+    updateModelWhenComplete(isStartDateTargetEvent, startDate, endDate) {
+        const endDateFormatted = this.formatScreenToModel(endDate);
+        const startDateFormatted = this.formatScreenToModel(startDate);
+        const dateFormatValidation = this.getDateRangeFormatValidation(startDateFormatted, endDateFormatted, isStartDateTargetEvent);
+        if (this.isEqualBeforeValue(startDateFormatted, endDateFormatted)) {
+            this.resetDateRangeInputValidation();
+            this.validateModel(this.dateRange);
+            return;
+        }
+        if (dateFormatValidation.isValid) {
+            this.dateRange = { start: startDateFormatted, end: endDateFormatted };
+            this.updateModel(this.dateRange);
+            this.onChange.emit({ ...this.dateRange });
+        }
+    }
+    updateModelByScreen(isStartDateTargetEvent, startDate, endDate) {
+        const endDateFormatted = endDate || this.formatScreenToModel(this.endDateInputValue);
+        const startDateFormatted = startDate || this.formatScreenToModel(this.startDateInputValue);
+        if (this.isDateRangeInputUncompleted && this.isDirtyDateRangeInput) {
+            this.updateModel(this.dateRange);
+            return;
+        }
+        if (this.isEqualBeforeValue(startDateFormatted, endDateFormatted)) {
+            this.resetDateRangeInputValidation();
+            this.validateModel(this.dateRange);
+            return;
+        }
+        const dateFormatValidation = this.getDateRangeFormatValidation(startDateFormatted, endDateFormatted, isStartDateTargetEvent);
+        if (dateFormatValidation.isValid) {
+            this.dateRange = { start: startDateFormatted, end: endDateFormatted };
+            this.updateModel(this.dateRange);
+            this.onChange.emit({ ...this.dateRange });
+        }
+        if (!dateFormatValidation.isValid && this.verifyFormattedDates(startDateFormatted, endDateFormatted)) {
+            this.dateRange = { ...dateFormatValidation.dateRangeModel };
+            this.updateModel(dateFormatValidation.dateRangeModel);
+        }
+    }
+    verifyFormattedDates(start, end) {
+        return !!start || !!end;
+    }
+    wasClickedOnPicker(event) {
+        if (!this.isCalendarVisible) {
+            return;
+        }
+        if (!this.calendarPicker.nativeElement.contains(event.target) &&
+            !this.iconCalendar.nativeElement.contains(event.target) &&
+            !this.hasAttrCalendar(event.target)) {
+            this.isCalendarVisible = false;
+        }
+        this.cd.markForCheck();
+    }
+}
+PoDatepickerRangeComponent.ɵfac = function PoDatepickerRangeComponent_Factory(t) { return new (t || PoDatepickerRangeComponent)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i1.PoControlPositionService), i0.ɵɵdirectiveInject(i0.Renderer2), i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i2.PoDateService), i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i3.PoLanguageService)); };
+PoDatepickerRangeComponent.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: PoDatepickerRangeComponent, selectors: [["po-datepicker-range"]], viewQuery: function PoDatepickerRangeComponent_Query(rf, ctx) { if (rf & 1) {
+        i0.ɵɵviewQuery(_c0, 7, ElementRef);
+        i0.ɵɵviewQuery(_c1, 7, ElementRef);
+        i0.ɵɵviewQuery(_c2, 7, ElementRef);
+        i0.ɵɵviewQuery(_c3, 7, ElementRef);
+        i0.ɵɵviewQuery(_c4, 5, ElementRef);
+    } if (rf & 2) {
+        let _t;
+        i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.dateRangeField = _t.first);
+        i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.endDateInput = _t.first);
+        i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.startDateInput = _t.first);
+        i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.iconCalendar = _t.first);
+        i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.calendarPicker = _t.first);
+    } }, features: [i0.ɵɵProvidersFeature(providers), i0.ɵɵInheritDefinitionFeature, i0.ɵɵNgOnChangesFeature], decls: 18, vars: 20, consts: [[3, "p-help", "p-label", "p-optional"], [1, "po-datepicker-range-field", "po-input"], ["dateRangeField", ""], [1, "po-datepicker-range-start-date"], ["maxlength", "10", "type", "text", 1, "po-datepicker-range-input", 3, "autocomplete", "disabled", "name", "readonly", "blur", "focus", "keydown", "keyup", "click"], ["startDateInput", ""], [1, "po-datepicker-range-separator"], [1, "po-datepicker-range-end-date"], ["endDateInput", ""], [1, "po-datepicker-range-icon"], [3, "p-change-event", 4, "ngIf"], [1, "po-icon", "po-field-icon", "po-icon-calendar", 3, "click"], ["iconCalendar", ""], [3, "p-error-pattern"], [4, "ngIf"], [3, "p-change-event"], [1, "po-calendar-range-picker"], ["calendarPicker", ""], ["p-mode", "range", 3, "ngModel", "p-max-date", "p-min-date", "ngModelChange"]], template: function PoDatepickerRangeComponent_Template(rf, ctx) { if (rf & 1) {
+        i0.ɵɵelementStart(0, "po-field-container", 0);
+        i0.ɵɵelementStart(1, "div", 1, 2);
+        i0.ɵɵelementStart(3, "div", 3);
+        i0.ɵɵelementStart(4, "input", 4, 5);
+        i0.ɵɵlistener("blur", function PoDatepickerRangeComponent_Template_input_blur_4_listener($event) { return ctx.onBlur($event); })("focus", function PoDatepickerRangeComponent_Template_input_focus_4_listener($event) { return ctx.onFocus($event); })("keydown", function PoDatepickerRangeComponent_Template_input_keydown_4_listener($event) { return ctx.onKeydown($event); })("keyup", function PoDatepickerRangeComponent_Template_input_keyup_4_listener($event) { return ctx.onKeyup($event); })("click", function PoDatepickerRangeComponent_Template_input_click_4_listener($event) { return ctx.eventOnClick($event); });
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementStart(6, "div", 6);
+        i0.ɵɵtext(7, "-");
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementStart(8, "div", 7);
+        i0.ɵɵelementStart(9, "input", 4, 8);
+        i0.ɵɵlistener("blur", function PoDatepickerRangeComponent_Template_input_blur_9_listener($event) { return ctx.onBlur($event); })("focus", function PoDatepickerRangeComponent_Template_input_focus_9_listener($event) { return ctx.onFocus($event); })("keydown", function PoDatepickerRangeComponent_Template_input_keydown_9_listener($event) { return ctx.onKeydown($event); })("keyup", function PoDatepickerRangeComponent_Template_input_keyup_9_listener($event) { return ctx.onKeyup($event); })("click", function PoDatepickerRangeComponent_Template_input_click_9_listener($event) { return ctx.eventOnClick($event); });
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementStart(11, "div", 9);
+        i0.ɵɵtemplate(12, PoDatepickerRangeComponent_po_clean_12_Template, 1, 0, "po-clean", 10);
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementStart(13, "div", 9);
+        i0.ɵɵelementStart(14, "span", 11, 12);
+        i0.ɵɵlistener("click", function PoDatepickerRangeComponent_Template_span_click_14_listener() { return ctx.toggleCalendar(); });
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementEnd();
+        i0.ɵɵelement(16, "po-field-container-bottom", 13);
+        i0.ɵɵelementEnd();
+        i0.ɵɵtemplate(17, PoDatepickerRangeComponent_ng_container_17_Template, 4, 3, "ng-container", 14);
+    } if (rf & 2) {
+        i0.ɵɵproperty("p-help", ctx.help)("p-label", ctx.label)("p-optional", !ctx.required && ctx.optional);
+        i0.ɵɵadvance(1);
+        i0.ɵɵclassProp("po-datepicker-range-field-disabled", ctx.disabled);
+        i0.ɵɵadvance(3);
+        i0.ɵɵproperty("autocomplete", ctx.autocomplete)("disabled", ctx.disabled)("name", ctx.startDateInputName)("readonly", ctx.readonly);
+        i0.ɵɵadvance(5);
+        i0.ɵɵproperty("autocomplete", ctx.autocomplete)("disabled", ctx.disabled)("name", ctx.endDateInputName)("readonly", ctx.readonly);
+        i0.ɵɵadvance(3);
+        i0.ɵɵproperty("ngIf", ctx.enableCleaner);
+        i0.ɵɵadvance(2);
+        i0.ɵɵclassProp("po-clickable", !ctx.disabled && !ctx.readonly)("po-field-icon-disabled", ctx.disabled || ctx.readonly);
+        i0.ɵɵadvance(2);
+        i0.ɵɵproperty("p-error-pattern", ctx.getErrorMessage);
+        i0.ɵɵadvance(1);
+        i0.ɵɵproperty("ngIf", ctx.isCalendarVisible);
+    } }, directives: [i4.PoFieldContainerComponent, i5.NgIf, i6.PoFieldContainerBottomComponent, i7.PoCleanComponent, i8.PoCalendarComponent, i9.NgControlStatus, i9.NgModel], encapsulation: 2, changeDetection: 0 });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PoDatepickerRangeComponent, [{
+        type: Component,
+        args: [{ selector: 'po-datepicker-range', providers: providers, changeDetection: ChangeDetectionStrategy.OnPush, template: "<po-field-container [p-help]=\"help\" [p-label]=\"label\" [p-optional]=\"!required && optional\">\n  <div #dateRangeField class=\"po-datepicker-range-field po-input\" [class.po-datepicker-range-field-disabled]=\"disabled\">\n    <div class=\"po-datepicker-range-start-date\">\n      <input\n        #startDateInput\n        class=\"po-datepicker-range-input\"\n        maxlength=\"10\"\n        type=\"text\"\n        [autocomplete]=\"autocomplete\"\n        [disabled]=\"disabled\"\n        [name]=\"startDateInputName\"\n        [readonly]=\"readonly\"\n        (blur)=\"onBlur($event)\"\n        (focus)=\"onFocus($event)\"\n        (keydown)=\"onKeydown($event)\"\n        (keyup)=\"onKeyup($event)\"\n        (click)=\"eventOnClick($event)\"\n      />\n    </div>\n\n    <div class=\"po-datepicker-range-separator\">-</div>\n\n    <div class=\"po-datepicker-range-end-date\">\n      <input\n        #endDateInput\n        class=\"po-datepicker-range-input\"\n        maxlength=\"10\"\n        type=\"text\"\n        [autocomplete]=\"autocomplete\"\n        [disabled]=\"disabled\"\n        [name]=\"endDateInputName\"\n        [readonly]=\"readonly\"\n        (blur)=\"onBlur($event)\"\n        (focus)=\"onFocus($event)\"\n        (keydown)=\"onKeydown($event)\"\n        (keyup)=\"onKeyup($event)\"\n        (click)=\"eventOnClick($event)\"\n      />\n    </div>\n\n    <div class=\"po-datepicker-range-icon\">\n      <po-clean *ngIf=\"enableCleaner\" (p-change-event)=\"clear()\"></po-clean>\n    </div>\n\n    <div class=\"po-datepicker-range-icon\">\n      <span\n        #iconCalendar\n        class=\"po-icon po-field-icon po-icon-calendar\"\n        [class.po-clickable]=\"!disabled && !readonly\"\n        [class.po-field-icon-disabled]=\"disabled || readonly\"\n        (click)=\"toggleCalendar()\"\n      >\n      </span>\n    </div>\n  </div>\n\n  <po-field-container-bottom [p-error-pattern]=\"getErrorMessage\"></po-field-container-bottom>\n</po-field-container>\n\n<ng-container *ngIf=\"isCalendarVisible\">\n  <div #calendarPicker class=\"po-calendar-range-picker\">\n    <po-calendar\n      p-mode=\"range\"\n      [ngModel]=\"dateRange\"\n      [p-max-date]=\"maxDate\"\n      [p-min-date]=\"minDate\"\n      (ngModelChange)=\"onCalendarChange($event)\"\n    ></po-calendar>\n  </div>\n</ng-container>\n" }]
+    }], function () { return [{ type: i0.ChangeDetectorRef }, { type: i1.PoControlPositionService }, { type: i0.Renderer2 }, { type: i0.ChangeDetectorRef }, { type: i2.PoDateService }, { type: i0.ElementRef }, { type: i3.PoLanguageService }]; }, { dateRangeField: [{
+            type: ViewChild,
+            args: ['dateRangeField', { read: ElementRef, static: true }]
+        }], endDateInput: [{
+            type: ViewChild,
+            args: ['endDateInput', { read: ElementRef, static: true }]
+        }], startDateInput: [{
+            type: ViewChild,
+            args: ['startDateInput', { read: ElementRef, static: true }]
+        }], iconCalendar: [{
+            type: ViewChild,
+            args: ['iconCalendar', { read: ElementRef, static: true }]
+        }], calendarPicker: [{
+            type: ViewChild,
+            args: ['calendarPicker', { read: ElementRef }]
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"po-datepicker-range.component.js","sourceRoot":"","sources":["../../../../../../../projects/ui/src/lib/components/po-field/po-datepicker-range/po-datepicker-range.component.ts","../../../../../../../projects/ui/src/lib/components/po-field/po-datepicker-range/po-datepicker-range.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  ChangeDetectorRef,\n  Component,\n  ElementRef,\n  forwardRef,\n  OnInit,\n  ViewChild,\n  AfterViewInit,\n  Renderer2,\n  OnDestroy,\n  SimpleChanges,\n  OnChanges,\n  ChangeDetectionStrategy\n} from '@angular/core';\nimport { NG_VALIDATORS, NG_VALUE_ACCESSOR } from '@angular/forms';\n\nimport { PoControlPositionService } from './../../../services/po-control-position/po-control-position.service';\n\nimport { PoDatepickerRange } from './interfaces/po-datepicker-range.interface';\nimport { PoDatepickerRangeBaseComponent } from './po-datepicker-range-base.component';\nimport { PoDateService } from './../../../services/po-date/po-date.service';\nimport { PoMask } from '../po-input/po-mask';\nimport { PoLanguageService } from '../../../services/po-language/po-language.service';\n\nconst arrowLeftKey = 37;\nconst arrowRightKey = 39;\nconst backspaceKey = 8;\nconst poDatepickerRangeDateLengthDefault = 10;\n\nconst poCalendarContentOffset = 8;\nconst poCalendarPositionDefault = 'bottom-left';\n\n/* istanbul ignore next */\nconst providers = [\n  {\n    provide: NG_VALUE_ACCESSOR,\n    // eslint-disable-next-line\n    useExisting: forwardRef(() => PoDatepickerRangeComponent),\n    multi: true\n  },\n  {\n    provide: NG_VALIDATORS,\n    // eslint-disable-next-line\n    useExisting: forwardRef(() => PoDatepickerRangeComponent),\n    multi: true\n  },\n  PoControlPositionService\n];\n/**\n * @docsExtends PoDatepickerRangeBaseComponent\n *\n * @example\n *\n * <example name=\"po-datepicker-range-basic\" title=\"PO Datepicker Range Basic\">\n *  <file name=\"sample-po-datepicker-range-basic/sample-po-datepicker-range-basic.component.html\"> </file>\n *  <file name=\"sample-po-datepicker-range-basic/sample-po-datepicker-range-basic.component.ts\"> </file>\n * </example>\n *\n * <example name=\"po-datepicker-range-labs\" title=\"PO Datepicker Range Labs\">\n *  <file name=\"sample-po-datepicker-range-labs/sample-po-datepicker-range-labs.component.html\"> </file>\n *  <file name=\"sample-po-datepicker-range-labs/sample-po-datepicker-range-labs.component.ts\"> </file>\n * </example>\n *\n * <example name=\"po-datepicker-range-vacations\" title=\"PO Datepicker Range - Vacations Suggestion\">\n *  <file name=\"sample-po-datepicker-range-vacations/sample-po-datepicker-range-vacations.component.html\"> </file>\n *  <file name=\"sample-po-datepicker-range-vacations/sample-po-datepicker-range-vacations.component.ts\"> </file>\n * </example>\n *\n * <example name=\"po-datepicker-range-vacations-reactive-form\" title=\"PO Datepicker Range - Vacations Reactive Form\">\n *  <file name=\"sample-po-datepicker-range-vacations-reactive-form/sample-po-datepicker-range-vacations-reactive-form.component.html\">\n *  </file>\n *  <file name=\"sample-po-datepicker-range-vacations-reactive-form/sample-po-datepicker-range-vacations-reactive-form.component.ts\">\n *  </file>\n * </example>\n */\n@Component({\n  selector: 'po-datepicker-range',\n  templateUrl: './po-datepicker-range.component.html',\n  providers,\n  changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class PoDatepickerRangeComponent\n  extends PoDatepickerRangeBaseComponent\n  implements AfterViewInit, OnInit, OnDestroy, OnChanges {\n  @ViewChild('dateRangeField', { read: ElementRef, static: true }) dateRangeField: ElementRef;\n  @ViewChild('endDateInput', { read: ElementRef, static: true }) endDateInput: ElementRef;\n  @ViewChild('startDateInput', { read: ElementRef, static: true }) startDateInput: ElementRef;\n  @ViewChild('iconCalendar', { read: ElementRef, static: true }) iconCalendar: ElementRef;\n  @ViewChild('calendarPicker', { read: ElementRef }) calendarPicker: ElementRef;\n\n  isCalendarVisible = false;\n\n  private clickListener;\n  private eventResizeListener;\n  private poDatepickerRangeElement: ElementRef<any>;\n  private poMaskObject: PoMask;\n\n  get autocomplete() {\n    return this.noAutocomplete ? 'off' : 'on';\n  }\n\n  get enableCleaner(): boolean {\n    return this.clean && (this.startDateInputValue || this.endDateInputValue) && !this.disabled && !this.readonly;\n  }\n\n  get endDateInputName(): string {\n    return 'end-date';\n  }\n\n  get endDateInputValue(): string {\n    return this.endDateInput.nativeElement.value;\n  }\n\n  get getErrorMessage(): string {\n    return this.errorMessage !== '' && this.hasInvalidClass() ? this.errorMessage : '';\n  }\n\n  get isDateRangeInputUncompleted(): boolean {\n    return (\n      this.endDateInputValue.length < poDatepickerRangeDateLengthDefault &&\n      this.startDateInputValue.length < poDatepickerRangeDateLengthDefault\n    );\n  }\n\n  get isDirtyDateRangeInput(): boolean {\n    return this.endDateInputValue.length > 0 || this.startDateInputValue.length > 0;\n  }\n\n  get startDateInputName(): string {\n    return 'start-date';\n  }\n\n  get startDateInputValue(): string {\n    return this.startDateInput.nativeElement.value;\n  }\n\n  constructor(\n    private changeDetector: ChangeDetectorRef,\n    private controlPosition: PoControlPositionService,\n    private renderer: Renderer2,\n    private cd: ChangeDetectorRef,\n    poDateService: PoDateService,\n    poDatepickerRangeElement: ElementRef,\n    poLanguageService: PoLanguageService\n  ) {\n    super(poDateService, poLanguageService);\n    this.poDatepickerRangeElement = poDatepickerRangeElement;\n  }\n\n  static getKeyCode(event: KeyboardEvent) {\n    return event.keyCode || event.which;\n  }\n\n  static getTargetElement(event: any) {\n    return event.target || event.srcElement;\n  }\n\n  static isValidKey(keyCode: number): boolean {\n    const isNumericKey = keyCode >= 48 && keyCode <= 57;\n    const isNumericNumpadKey = keyCode >= 96 && keyCode <= 105;\n\n    return isNumericKey || isNumericNumpadKey;\n  }\n\n  ngAfterViewInit() {\n    if (this.autoFocus) {\n      this.focus();\n    }\n  }\n\n  ngOnInit() {\n    // Classe de máscara\n    this.poMaskObject = this.buildMask();\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    if (changes.minDate || changes.maxDate) {\n      this.validateModel(this.dateRange);\n    }\n  }\n\n  ngOnDestroy() {\n    this.removeListeners();\n  }\n\n  clear() {\n    this.resetDateRangeInputValidation();\n    this.dateRange = { start: '', end: '' };\n\n    this.updateScreenByModel(this.dateRange);\n    this.updateModel(this.dateRange);\n  }\n\n  eventOnClick($event: any) {\n    this.poMaskObject.click($event);\n  }\n\n  /**\n   * Função que atribui foco ao componente.\n   *\n   * Para utilizá-la é necessário ter a instância do componente no DOM, podendo ser utilizado o ViewChild da seguinte forma:\n   *\n   * ```\n   * import { PoDatepickerRangeComponent } from '@po-ui/ng-components';\n   *\n   * ...\n   *\n   * @ViewChild(PoDatepickerRangeComponent, { static: true }) datepickerRange: PoDatepickerRangeComponent;\n   *\n   * focusDatepickerRange() {\n   *   this.datepickerRange.focus();\n   * }\n   * ```\n   */\n  focus(): void {\n    if (!this.disabled) {\n      this.startDateInput.nativeElement.focus();\n    }\n  }\n\n  onBlur(event: any) {\n    this.onTouchedModel?.();\n    const isStartDateTargetEvent = event.target.name === this.startDateInputName;\n\n    this.updateModelByScreen(isStartDateTargetEvent);\n\n    this.removeFocusFromDatePickerRangeField();\n  }\n\n  onCalendarChange({ start, end }) {\n    const isStartDateTargetEvent = start && !end;\n\n    this.updateScreenByModel({ start: start || '', end: end || '' });\n    this.updateModelByScreen(isStartDateTargetEvent, start || '', end || '');\n\n    if (start && end) {\n      setTimeout(() => {\n        this.isCalendarVisible = false;\n        this.cd.markForCheck();\n      }, 300);\n    }\n  }\n\n  onFocus(event: any) {\n    this.applyFocusOnDatePickerRangeField();\n    this.poMaskObject.resetPositions(event);\n  }\n\n  onKeydown(event?: any) {\n    if (this.readonly) {\n      return;\n    }\n\n    if (this.isSetFocusOnBackspace(event)) {\n      event.preventDefault();\n      this.setFocusOnBackspace();\n    } else {\n      this.poMaskObject.keydown(event);\n    }\n  }\n\n  onKeyup(event: any) {\n    if (this.readonly) {\n      return;\n    }\n\n    const isStartDateTargetEvent = event.target.name === this.startDateInputName;\n\n    this.setFocus(event);\n    this.poMaskObject.keyup(event);\n    this.updateModelWhenComplete(isStartDateTargetEvent, this.startDateInputValue, this.endDateInputValue);\n  }\n\n  resetDateRangeInputValidation() {\n    this.isStartDateRangeInputValid = true;\n    this.isDateRangeInputFormatValid = true;\n  }\n\n  toggleCalendar() {\n    if (this.disabled || this.readonly) {\n      return;\n    }\n\n    this.isCalendarVisible = !this.isCalendarVisible;\n    this.changeDetector.detectChanges();\n\n    if (this.isCalendarVisible) {\n      this.setCalendarPosition();\n      this.initializeListeners();\n    } else {\n      this.removeListeners();\n    }\n  }\n\n  updateScreenByModel(model: PoDatepickerRange) {\n    const dateRange = { start: model.start as string, end: model.end as string };\n    const isStartDateValid = this.poDateService.isDateRangeValid(dateRange.end, dateRange.start);\n    const isDateValid = date => !this.dateFormatFailed(date) && isStartDateValid;\n\n    const endDateFormated = isDateValid(dateRange.end) ? this.formatModelToScreen(dateRange.end) : '';\n    const startDateFormated = isDateValid(dateRange.start) ? this.formatModelToScreen(dateRange.start) : '';\n\n    this.endDateInput.nativeElement.value = endDateFormated;\n    this.startDateInput.nativeElement.value = startDateFormated;\n    this.changeDetector.detectChanges();\n  }\n\n  private applyFocusOnDatePickerRangeField() {\n    this.dateRangeField.nativeElement.classList.add('po-datepicker-range-field-focused');\n  }\n\n  // Retorna um objeto do tipo PoMask com a mascara configurada.\n  private buildMask(): PoMask {\n    let mask = this.format.toUpperCase();\n\n    mask = mask.replace(/DD/g, '99');\n    mask = mask.replace(/MM/g, '99');\n    mask = mask.replace(/YYYY/g, '9999');\n\n    return new PoMask(mask, true);\n  }\n\n  private formatDate(format: string, day: string = '', month: string = '', year: string = ''): string {\n    let dateFormatted = format;\n\n    day = day && day.includes('T') ? day.slice(0, 2) : day;\n\n    dateFormatted = dateFormatted.replace('dd', ('0' + day).slice(-2));\n    dateFormatted = dateFormatted.replace('mm', ('0' + month).slice(-2));\n    dateFormatted = dateFormatted.replace('yyyy', String(year));\n\n    return dateFormatted;\n  }\n\n  private formatScreenToModel(value: string = ''): string {\n    const [day, month, year] = value.split('/');\n\n    return value ? this.formatDate('yyyy-mm-dd', day, month, year) : '';\n  }\n\n  private formatModelToScreen(value: string = ''): string {\n    const [year, month, day] = value.split('-');\n\n    return value ? this.formatDate(this.format, day, month, year) : '';\n  }\n\n  private getDateRangeFormatValidation(\n    startDate: string,\n    endDate: string,\n    isStartDateTargetEvent: boolean\n  ): { isValid: boolean; dateRangeModel: PoDatepickerRange } {\n    this.setDateRangeInputValidation(startDate, endDate);\n    return {\n      isValid:\n        this.isDateRangeInputFormatValid && this.isStartDateRangeInputValid && this.verifyValidDate(startDate, endDate),\n      dateRangeModel: this.getValidatedModel(startDate, endDate, isStartDateTargetEvent)\n    };\n  }\n\n  private getValidatedModel(startDate: string, endDate: string, isStartDateTargetEvent: boolean): PoDatepickerRange {\n    const dateRangeModel = { start: '', end: '' };\n\n    dateRangeModel.end =\n      (isStartDateTargetEvent || this.isStartDateRangeInputValid) && !this.dateFormatFailed(endDate) ? endDate : '';\n\n    dateRangeModel.start =\n      (!isStartDateTargetEvent || this.isStartDateRangeInputValid) && !this.dateFormatFailed(startDate)\n        ? startDate\n        : '';\n\n    return dateRangeModel;\n  }\n\n  private hasAttrCalendar(element) {\n    const attrCalendar = 'attr-calendar';\n\n    return element?.hasAttribute(attrCalendar) || element?.parentElement?.hasAttribute(attrCalendar);\n  }\n\n  private hasInvalidClass(): boolean {\n    return (\n      this.poDatepickerRangeElement.nativeElement.classList.contains('ng-invalid') &&\n      this.poDatepickerRangeElement.nativeElement.classList.contains('ng-dirty')\n    );\n  }\n\n  private initializeListeners() {\n    this.clickListener = this.renderer.listen('document', 'click', (event: MouseEvent) => {\n      this.wasClickedOnPicker(event);\n    });\n\n    this.eventResizeListener = this.renderer.listen('window', 'resize', () => {\n      this.isCalendarVisible = false;\n    });\n\n    window.addEventListener('scroll', this.onScroll, true);\n  }\n\n  private isEqualBeforeValue(startDate: string, endDate: string): boolean {\n    return this.isDateRangeInputFormatValid && endDate === this.dateRange.end && startDate === this.dateRange.start;\n  }\n\n  private isSetFocusOnBackspace(event: any) {\n    return (\n      event.target.name === this.endDateInputName &&\n      this.endDateInput.nativeElement.selectionStart === 0 &&\n      this.endDateInput.nativeElement.selectionEnd === 0 &&\n      event.keyCode === backspaceKey\n    );\n  }\n\n  private onScroll = (): void => {\n    if (this.isCalendarVisible) {\n      this.controlPosition.adjustPosition(poCalendarPositionDefault);\n    }\n  };\n\n  private removeFocusFromDatePickerRangeField() {\n    this.dateRangeField.nativeElement.classList.remove('po-datepicker-range-field-focused');\n  }\n\n  private setDateRangeInputValidation(startDate: string, endDate: string) {\n    this.isStartDateRangeInputValid = this.poDateService.isDateRangeValid(endDate, startDate);\n\n    this.isDateRangeInputFormatValid = !this.dateFormatFailed(startDate) && !this.dateFormatFailed(endDate);\n  }\n\n  private setFocus(event: any) {\n    const inputElement = PoDatepickerRangeComponent.getTargetElement(event);\n    const keyCode = PoDatepickerRangeComponent.getKeyCode(event);\n    const inputName = inputElement['name'];\n\n    this.setFocusOnArrowLeft(keyCode, inputName);\n    this.setFocusOnArrowRight(keyCode, inputName, inputElement);\n    this.setFocusOnStartDateCompleted(keyCode, inputName);\n  }\n\n  private setFocusAndPosition(position: number, inputElement: ElementRef, selectionRange: number) {\n    this.focusOnElement(inputElement);\n\n    setTimeout(() => {\n      inputElement.nativeElement.setSelectionRange(selectionRange, selectionRange);\n      this.poMaskObject.initialPosition = position;\n      this.poMaskObject.finalPosition = position;\n    });\n  }\n\n  private focusOnElement(inputElement: ElementRef) {\n    inputElement.nativeElement.focus();\n  }\n\n  private removeListeners() {\n    if (this.clickListener) {\n      this.clickListener();\n    }\n\n    if (this.eventResizeListener) {\n      this.eventResizeListener();\n    }\n\n    window.removeEventListener('scroll', this.onScroll, true);\n  }\n\n  private setCalendarPosition() {\n    this.controlPosition.setElements(\n      this.calendarPicker.nativeElement,\n      poCalendarContentOffset,\n      this.dateRangeField,\n      ['bottom-left', 'bottom-right', 'top-left', 'top-right'],\n      false,\n      true\n    );\n\n    this.controlPosition.adjustPosition(poCalendarPositionDefault);\n  }\n\n  private setFocusOnArrowLeft(keyCode: number, inputName: string) {\n    const isCursorAtStartOfInput = this.endDateInput.nativeElement.selectionStart === 0;\n\n    if (inputName === this.endDateInputName && isCursorAtStartOfInput && keyCode === arrowLeftKey) {\n      const inputLength = this.startDateInput.nativeElement.value.length;\n      this.setFocusAndPosition(inputLength, this.startDateInput, inputLength);\n    }\n  }\n\n  private setFocusOnArrowRight(keyCode: number, inputName: string, inputElement: any) {\n    const isCursorAtEndOfInput = this.startDateInput.nativeElement.selectionStart === inputElement.value.length;\n\n    if (inputName === this.startDateInputName && isCursorAtEndOfInput && keyCode === arrowRightKey) {\n      this.setFocusAndPosition(0, this.endDateInput, 0);\n    }\n  }\n\n  private setFocusOnBackspace() {\n    const inputLength = this.startDateInput.nativeElement.value.length;\n\n    this.startDateInput.nativeElement.value = this.startDateInputValue.slice(0, -1);\n    this.setFocusAndPosition(inputLength, this.startDateInput, inputLength);\n  }\n\n  private setFocusOnStartDateCompleted(keyCode: number, inputName: string) {\n    const isLastKeyPressed = this.startDateInput.nativeElement.selectionStart === poDatepickerRangeDateLengthDefault;\n    const isNewDateCompleted =\n      this.startDateInputValue.length === poDatepickerRangeDateLengthDefault && isLastKeyPressed;\n    const isValidKey = PoDatepickerRangeComponent.isValidKey(keyCode);\n\n    if (inputName === this.startDateInputName && isNewDateCompleted && isValidKey) {\n      this.setFocusAndPosition(0, this.endDateInput, 0);\n    }\n  }\n\n  private updateModelWhenComplete(isStartDateTargetEvent: boolean, startDate, endDate) {\n    const endDateFormatted = this.formatScreenToModel(endDate);\n    const startDateFormatted = this.formatScreenToModel(startDate);\n    const dateFormatValidation = this.getDateRangeFormatValidation(\n      startDateFormatted,\n      endDateFormatted,\n      isStartDateTargetEvent\n    );\n\n    if (this.isEqualBeforeValue(startDateFormatted, endDateFormatted)) {\n      this.resetDateRangeInputValidation();\n      this.validateModel(this.dateRange);\n      return;\n    }\n\n    if (dateFormatValidation.isValid) {\n      this.dateRange = { start: startDateFormatted, end: endDateFormatted };\n      this.updateModel(this.dateRange);\n      this.onChange.emit({ ...this.dateRange });\n    }\n  }\n\n  private updateModelByScreen(isStartDateTargetEvent: boolean, startDate?, endDate?) {\n    const endDateFormatted = endDate || this.formatScreenToModel(this.endDateInputValue);\n    const startDateFormatted = startDate || this.formatScreenToModel(this.startDateInputValue);\n    if (this.isDateRangeInputUncompleted && this.isDirtyDateRangeInput) {\n      this.updateModel(this.dateRange);\n      return;\n    }\n\n    if (this.isEqualBeforeValue(startDateFormatted, endDateFormatted)) {\n      this.resetDateRangeInputValidation();\n      this.validateModel(this.dateRange);\n      return;\n    }\n\n    const dateFormatValidation = this.getDateRangeFormatValidation(\n      startDateFormatted,\n      endDateFormatted,\n      isStartDateTargetEvent\n    );\n\n    if (dateFormatValidation.isValid) {\n      this.dateRange = { start: startDateFormatted, end: endDateFormatted };\n      this.updateModel(this.dateRange);\n      this.onChange.emit({ ...this.dateRange });\n    }\n\n    if (!dateFormatValidation.isValid && this.verifyFormattedDates(startDateFormatted, endDateFormatted)) {\n      this.dateRange = { ...dateFormatValidation.dateRangeModel };\n      this.updateModel(dateFormatValidation.dateRangeModel);\n    }\n  }\n\n  private verifyFormattedDates(start: string, end: string): boolean {\n    return !!start || !!end;\n  }\n\n  private wasClickedOnPicker(event): void {\n    if (!this.isCalendarVisible) {\n      return;\n    }\n\n    if (\n      !this.calendarPicker.nativeElement.contains(event.target) &&\n      !this.iconCalendar.nativeElement.contains(event.target) &&\n      !this.hasAttrCalendar(event.target)\n    ) {\n      this.isCalendarVisible = false;\n    }\n    this.cd.markForCheck();\n  }\n}\n","<po-field-container [p-help]=\"help\" [p-label]=\"label\" [p-optional]=\"!required && optional\">\n  <div #dateRangeField class=\"po-datepicker-range-field po-input\" [class.po-datepicker-range-field-disabled]=\"disabled\">\n    <div class=\"po-datepicker-range-start-date\">\n      <input\n        #startDateInput\n        class=\"po-datepicker-range-input\"\n        maxlength=\"10\"\n        type=\"text\"\n        [autocomplete]=\"autocomplete\"\n        [disabled]=\"disabled\"\n        [name]=\"startDateInputName\"\n        [readonly]=\"readonly\"\n        (blur)=\"onBlur($event)\"\n        (focus)=\"onFocus($event)\"\n        (keydown)=\"onKeydown($event)\"\n        (keyup)=\"onKeyup($event)\"\n        (click)=\"eventOnClick($event)\"\n      />\n    </div>\n\n    <div class=\"po-datepicker-range-separator\">-</div>\n\n    <div class=\"po-datepicker-range-end-date\">\n      <input\n        #endDateInput\n        class=\"po-datepicker-range-input\"\n        maxlength=\"10\"\n        type=\"text\"\n        [autocomplete]=\"autocomplete\"\n        [disabled]=\"disabled\"\n        [name]=\"endDateInputName\"\n        [readonly]=\"readonly\"\n        (blur)=\"onBlur($event)\"\n        (focus)=\"onFocus($event)\"\n        (keydown)=\"onKeydown($event)\"\n        (keyup)=\"onKeyup($event)\"\n        (click)=\"eventOnClick($event)\"\n      />\n    </div>\n\n    <div class=\"po-datepicker-range-icon\">\n      <po-clean *ngIf=\"enableCleaner\" (p-change-event)=\"clear()\"></po-clean>\n    </div>\n\n    <div class=\"po-datepicker-range-icon\">\n      <span\n        #iconCalendar\n        class=\"po-icon po-field-icon po-icon-calendar\"\n        [class.po-clickable]=\"!disabled && !readonly\"\n        [class.po-field-icon-disabled]=\"disabled || readonly\"\n        (click)=\"toggleCalendar()\"\n      >\n      </span>\n    </div>\n  </div>\n\n  <po-field-container-bottom [p-error-pattern]=\"getErrorMessage\"></po-field-container-bottom>\n</po-field-container>\n\n<ng-container *ngIf=\"isCalendarVisible\">\n  <div #calendarPicker class=\"po-calendar-range-picker\">\n    <po-calendar\n      p-mode=\"range\"\n      [ngModel]=\"dateRange\"\n      [p-max-date]=\"maxDate\"\n      [p-min-date]=\"minDate\"\n      (ngModelChange)=\"onCalendarChange($event)\"\n    ></po-calendar>\n  </div>\n</ng-container>\n"]}