@po-ui/ng-components 5.22.0 → 6.0.0

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

@@ -0,0 +1,506 @@
+import { __decorate } from "tslib";
+import { Directive, EventEmitter, Input, Output } from '@angular/core';
+import { InputBoolean } from '../../../decorators';
+import { poLocaleDefault } from '../../../services/po-language/po-language.constant';
+import { requiredFailed } from '../validators';
+import { convertIsoToDate, convertToBoolean, setYearFrom0To100, validateDateRange } from './../../../utils/util';
+import { poDatepickerRangeLiteralsDefault } from './po-datepicker-range.literals';
+import * as i0 from "@angular/core";
+import * as i1 from "./../../../services/po-date/po-date.service";
+import * as i2 from "../../../services/po-language/po-language.service";
+/**
+ * @description
+ *
+ * O `po-datepicker-range` é um componente para seleção de um período entre duas datas, onde é possível informar apenas
+ * a data inicial ou a data final.
+ *
+ * O componente `[(ngModel)]` do `po-datepicker-range` trabalha com um objeto que implementa a interface
+ * `PoDatepickerRange`, contendo as seguintes propriedades:
+ * ```
+ * { "start": '2017-11-28', "end": '2017-11-30' }
+ * ```
+ *
+ * <a id="accepted-formats"></a>
+ * Este componente pode receber os seguintes formatos de data:
+ *
+ * - **Data e hora combinados (E8601DZw): yyyy-mm-ddThh:mm:ss+|-hh:mm**
+ * ```
+ * '2017-11-28T00:00:00-02:00';
+ * ```
+ *
+ * - **Data (E8601DAw.): yyyy-mm-dd**
+ * ```
+ * '2017-11-28';
+ * ```
+ *
+ * - **JavaScript Date Object:**
+ * ```
+ * new Date(2017, 10, 28);
+ * ```
+ *
+ * > O componente respeitará o formato passado para o *model* via codificação. Porém, caso seja feita alteração em algum
+ * dos valores de data em tela, o componente atribuirá o formato **Data (E8601DAw.): yyyy-mm-dd** ao model.
+ *
+ * Importante:
+ *
+ * - Quando preenchidas a data inicial e final, a data inicial deve ser sempre menor ou igual a data final;
+ * - Ao passar uma data inválida via codificação, o valor será mantido no *model* e o `input` da tela aparecerá vazio;
+ * - Permite trabalhar com as duas datas separadamente através das propriedades `p-start-date` e `p-end-date` no lugar do
+ * `[(ngModel)]`, no entanto sem a validação do formulário;
+ * - Para a validação do formulário, utilize o `[(ngModel)]`.
+ */
+export class PoDatepickerRangeBaseComponent {
+    constructor(poDateService, languageService) {
+        this.poDateService = poDateService;
+        /**
+         * @optional
+         *
+         * @description
+         *
+         * Aplica foco no elemento ao ser iniciado.
+         *
+         * > Caso mais de um elemento seja configurado com essa propriedade, apenas o último elemento declarado com ela terá o foco.
+         *
+         * @default `false`
+         */
+        this.autoFocus = false;
+        /**
+         * @optional
+         *
+         * @description
+         *
+         * Evento disparado ao alterar valor do campo.
+         */
+        this.onChange = new EventEmitter();
+        this.errorMessage = '';
+        this.dateRange = { start: '', end: '' };
+        this.format = 'dd/mm/yyyy';
+        this.isDateRangeInputFormatValid = true;
+        this.isStartDateRangeInputValid = true;
+        this._clean = false;
+        this._noAutocomplete = false;
+        this._readonly = false;
+        this._required = false;
+        this.language = languageService.getShortLanguage();
+    }
+    get isDateRangeInputValid() {
+        return this.isDateRangeInputFormatValid && this.isStartDateRangeInputValid;
+    }
+    /**
+     * @optional
+     *
+     * @description
+     *
+     * Habilita ação para limpar o campo.
+     *
+     * @default `false`
+     */
+    set clean(clean) {
+        this._clean = convertToBoolean(clean);
+    }
+    get clean() {
+        return this._clean;
+    }
+    /**
+     * @optional
+     *
+     * @description
+     *
+     * Desabilita o campo.
+     *
+     * @default `false`
+     */
+    set disabled(value) {
+        this._disabled = convertToBoolean(value);
+        this.validateModel(this.dateRange);
+    }
+    get disabled() {
+        return this._disabled;
+    }
+    /**
+     * @optional
+     *
+     * @description
+     *
+     * Data final.
+     */
+    set endDate(date) {
+        this._endDate = this.convertPatternDateFormat(date);
+        this.dateRange.end = this.endDate;
+        this.updateScreenByModel(this.dateRange);
+        this.updateModel(this.dateRange);
+    }
+    get endDate() {
+        return this._endDate;
+    }
+    /**
+     * @optional
+     *
+     * @description
+     *
+     * Objeto com as literais usadas no `po-datepicker-range`.
+     *
+     * Existem duas maneiras de customizar o componente, passando um objeto com todas as literais disponíveis:
+     *
+     * ```
+     *  const customLiterals: PoDatepickerRangeLiterals = {
+     *    invalidFormat: 'Date in inconsistent format',
+     *    startDateGreaterThanEndDate: 'End date less than start date'
+     *  };
+     * ```
+     *
+     * Ou passando apenas as literais que deseja customizar:
+     *
+     * ```
+     *  const customLiterals: PoDatepickerRangeLiterals = {
+     *    invalidFormat: 'Date in inconsistent format'
+     *  };
+     * ```
+     *
+     * E para carregar as literais customizadas, basta apenas passar o objeto para o componente.
+     *
+     * ```
+     * <po-datepicker-range
+     *   [p-literals]="customLiterals">
+     * </po-datepicker-range>
+     * ```
+     *
+     * > O objeto padrão de literais será traduzido de acordo com o idioma do
+     * [`PoI18nService`](/documentation/po-i18n) ou do browser.
+     */
+    set literals(value) {
+        if (value instanceof Object && !(value instanceof Array)) {
+            this._literals = {
+                ...poDatepickerRangeLiteralsDefault[poLocaleDefault],
+                ...poDatepickerRangeLiteralsDefault[this.language],
+                ...value
+            };
+        }
+        else {
+            this._literals = poDatepickerRangeLiteralsDefault[this.language];
+        }
+    }
+    get literals() {
+        return this._literals || poDatepickerRangeLiteralsDefault[this.language];
+    }
+    /**
+     * @optional
+     *
+     * @description
+     *
+     * Define uma data mínima para o `po-datepicker-range`.
+     */
+    set minDate(value) {
+        if (value instanceof Date) {
+            const year = value.getFullYear();
+            const date = new Date(year, value.getMonth(), value.getDate(), 0, 0, 0);
+            setYearFrom0To100(date, year);
+            this._minDate = date;
+        }
+        else {
+            this._minDate = convertIsoToDate(value, true, false);
+        }
+    }
+    get minDate() {
+        return this._minDate;
+    }
+    /**
+     * @optional
+     *
+     * @description
+     *
+     * Define uma data máxima para o `po-datepicker-range`.
+     */
+    set maxDate(value) {
+        if (value instanceof Date) {
+            const year = value.getFullYear();
+            const date = new Date(year, value.getMonth(), value.getDate(), 23, 59, 59);
+            setYearFrom0To100(date, year);
+            this._maxDate = date;
+        }
+        else {
+            this._maxDate = convertIsoToDate(value, false, true);
+        }
+    }
+    get maxDate() {
+        return this._maxDate;
+    }
+    /**
+     * @optional
+     *
+     * @description
+     *
+     * Define a propriedade nativa `autocomplete` do campo como `off`.
+     *
+     * @default `false`
+     */
+    set noAutocomplete(value) {
+        this._noAutocomplete = convertToBoolean(value);
+    }
+    get noAutocomplete() {
+        return this._noAutocomplete;
+    }
+    /**
+     * @optional
+     *
+     * @description
+     *
+     * Indica que o campo será somente leitura.
+     *
+     * @default `false`
+     */
+    set readonly(value) {
+        this._readonly = convertToBoolean(value);
+        this.validateModel(this.dateRange);
+    }
+    get readonly() {
+        return this._readonly;
+    }
+    /**
+     * @optional
+     *
+     * @description
+     *
+     * Indica que o campo será obrigatório.
+     *
+     * @default `false`
+     */
+    set required(required) {
+        this._required = convertToBoolean(required);
+        this.validateModel(this.dateRange);
+    }
+    get required() {
+        return this._required;
+    }
+    /**
+     * @optional
+     *
+     * @description
+     *
+     * Data inicial.
+     */
+    set startDate(date) {
+        this._startDate = this.convertPatternDateFormat(date);
+        this.dateRange.start = this.startDate;
+        this.updateScreenByModel(this.dateRange);
+        this.updateModel(this.dateRange);
+    }
+    get startDate() {
+        return this._startDate;
+    }
+    // Função implementada do ControlValueAccessor
+    // Usada para interceptar os estados de habilitado via forms api
+    setDisabledState(isDisabled) {
+        this.disabled = isDisabled;
+    }
+    // Função implementada do ControlValueAccessor
+    // Usada para interceptar as mudanças e não atualizar automaticamente o Model
+    registerOnChange(func) {
+        this.onChangeModel = func;
+    }
+    // Função implementada do ControlValueAccessor
+    // Usada para interceptar as mudanças e não atualizar automaticamente o Model
+    registerOnTouched(func) {
+        this.onTouchedModel = func;
+    }
+    registerOnValidatorChange(fn) {
+        this.validatorChange = fn;
+    }
+    validate(control) {
+        const value = control.value || {};
+        const startDate = value.start ? this.convertPatternDateFormat(value.start) : '';
+        const endDate = value.end ? this.convertPatternDateFormat(value.end) : '';
+        if (this.requiredDateRangeFailed(startDate, endDate)) {
+            this.errorMessage = '';
+            return {
+                required: {
+                    valid: false
+                }
+            };
+        }
+        if (!this.verifyValidDate(startDate, endDate)) {
+            this.errorMessage = this.literals.invalidDate;
+            return {
+                date: {
+                    valid: false
+                }
+            };
+        }
+        if (this.dateRangeObjectFailed(control.value) || this.dateRangeFormatFailed(startDate, endDate)) {
+            this.errorMessage = this.literals.invalidFormat;
+            return {
+                date: {
+                    valid: false
+                }
+            };
+        }
+        if (this.dateRangeFailed(startDate, endDate)) {
+            this.errorMessage = this.literals.startDateGreaterThanEndDate;
+            return {
+                date: {
+                    valid: false
+                }
+            };
+        }
+        if ((startDate && !this.validateDateInRange(startDate)) || (endDate && !this.validateDateInRange(endDate))) {
+            this.errorMessage = this.literals.dateOutOfPeriod;
+            return {
+                date: {
+                    valid: false
+                }
+            };
+        }
+        return null;
+    }
+    validateDateInRange(startDate) {
+        return validateDateRange(convertIsoToDate(startDate, false, false), this._minDate, this._maxDate);
+    }
+    writeValue(dateRange) {
+        this.resetDateRangeInputValidation();
+        if (!dateRange || this.dateRangeObjectFailed(dateRange)) {
+            this.dateRange = { start: '', end: '' };
+        }
+        if (!dateRange) {
+            this.validateModel(this.dateRange);
+        }
+        if (this.dateRangeObjectFailed(dateRange)) {
+            this.updateModel(dateRange);
+        }
+        if (this.isDateRangeObject(dateRange)) {
+            this.dateRange = {
+                start: this.convertPatternDateFormat(dateRange.start),
+                end: this.convertPatternDateFormat(dateRange.end)
+            };
+            this.updateModel(this.dateRange);
+        }
+        this.updateScreenByModel(this.dateRange);
+    }
+    dateFormatFailed(value) {
+        return value && !this.poDateService.isValidIso(value);
+    }
+    // Executa a função onChange
+    updateModel(value) {
+        const model = typeof value === 'object' ? { ...value } : value;
+        // Quando o input não possui um formulário, então esta função não é registrada
+        if (this.onChangeModel) {
+            this.onChangeModel(model);
+        }
+    }
+    validateModel(value) {
+        const model = { ...value };
+        if (this.validatorChange) {
+            this.validatorChange(model);
+        }
+    }
+    verifyValidDate(startDate, endDate) {
+        if (startDate !== '' && endDate !== '') {
+            return this.dateIsValid(startDate) && this.dateIsValid(endDate);
+        }
+        else if (startDate !== '') {
+            return this.dateIsValid(startDate);
+        }
+        else {
+            return this.dateIsValid(endDate);
+        }
+    }
+    convertPatternDateFormat(value) {
+        if (value instanceof Date) {
+            return this.poDateService.convertDateToISO(value);
+        }
+        return value;
+    }
+    dateRangeFailed(startDate, endDate) {
+        return !this.poDateService.isDateRangeValid(endDate, startDate) || !this.isStartDateRangeInputValid;
+    }
+    dateRangeFormatFailed(startDate, endDate) {
+        return this.dateFormatFailed(endDate) || this.dateFormatFailed(startDate) || !this.isDateRangeInputFormatValid;
+    }
+    dateRangeObjectFailed(value) {
+        return value && !this.isDateRangeObject(value);
+    }
+    isDateRangeObject(value) {
+        return value && value.hasOwnProperty('start') && value.hasOwnProperty('end');
+    }
+    requiredDateRangeFailed(startDate, endDate) {
+        return (this.isDateRangeInputValid &&
+            requiredFailed(this.required, this.disabled, startDate) &&
+            requiredFailed(this.required, this.disabled, endDate));
+    }
+    dateIsValid(date) {
+        const [strYear, strMonth, strDay] = date.split('-');
+        const year = Number(strYear);
+        const month = Number(strMonth);
+        const day = Number(strDay);
+        //verificação dos meses com 31 dias
+        if (month === 1 || month === 3 || month === 5 || month === 7 || month === 8 || month === 10 || month === 12) {
+            return day < 1 || day > 31 ? false : true;
+        }
+        else if (month === 4 || month === 6 || month === 9 || month === 11) {
+            //verificação dos meses com 30 dias
+            return day < 1 || day > 30 ? false : true;
+        }
+        else {
+            //verificacao de ano bissexto para verificar até qual dia irá o mês de fevereiro
+            if ((year % 4 === 0 && year % 100 !== 0) || year % 400 === 0) {
+                return day < 1 || day > 29 ? false : true;
+            }
+            else {
+                return day < 1 || day > 28 ? false : true;
+            }
+        }
+    }
+}
+PoDatepickerRangeBaseComponent.ɵfac = function PoDatepickerRangeBaseComponent_Factory(t) { return new (t || PoDatepickerRangeBaseComponent)(i0.ɵɵdirectiveInject(i1.PoDateService), i0.ɵɵdirectiveInject(i2.PoLanguageService)); };
+PoDatepickerRangeBaseComponent.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: PoDatepickerRangeBaseComponent, inputs: { autoFocus: ["p-auto-focus", "autoFocus"], help: ["p-help", "help"], label: ["p-label", "label"], optional: ["p-optional", "optional"], clean: ["p-clean", "clean"], disabled: ["p-disabled", "disabled"], endDate: ["p-end-date", "endDate"], literals: ["p-literals", "literals"], minDate: ["p-min-date", "minDate"], maxDate: ["p-max-date", "maxDate"], noAutocomplete: ["p-no-autocomplete", "noAutocomplete"], readonly: ["p-readonly", "readonly"], required: ["p-required", "required"], startDate: ["p-start-date", "startDate"] }, outputs: { onChange: "p-change" } });
+__decorate([
+    InputBoolean()
+], PoDatepickerRangeBaseComponent.prototype, "autoFocus", void 0);
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PoDatepickerRangeBaseComponent, [{
+        type: Directive
+    }], function () { return [{ type: i1.PoDateService }, { type: i2.PoLanguageService }]; }, { autoFocus: [{
+            type: Input,
+            args: ['p-auto-focus']
+        }], help: [{
+            type: Input,
+            args: ['p-help']
+        }], label: [{
+            type: Input,
+            args: ['p-label']
+        }], optional: [{
+            type: Input,
+            args: ['p-optional']
+        }], onChange: [{
+            type: Output,
+            args: ['p-change']
+        }], clean: [{
+            type: Input,
+            args: ['p-clean']
+        }], disabled: [{
+            type: Input,
+            args: ['p-disabled']
+        }], endDate: [{
+            type: Input,
+            args: ['p-end-date']
+        }], literals: [{
+            type: Input,
+            args: ['p-literals']
+        }], minDate: [{
+            type: Input,
+            args: ['p-min-date']
+        }], maxDate: [{
+            type: Input,
+            args: ['p-max-date']
+        }], noAutocomplete: [{
+            type: Input,
+            args: ['p-no-autocomplete']
+        }], readonly: [{
+            type: Input,
+            args: ['p-readonly']
+        }], required: [{
+            type: Input,
+            args: ['p-required']
+        }], startDate: [{
+            type: Input,
+            args: ['p-start-date']
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"po-datepicker-range-base.component.js","sourceRoot":"","sources":["../../../../../../../projects/ui/src/lib/components/po-field/po-datepicker-range/po-datepicker-range-base.component.ts"],"names":[],"mappings":";AAAA,OAAO,EAAqB,SAAS,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAE1F,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,eAAe,EAAE,MAAM,oDAAoD,CAAC;AAErF,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAE/C,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAGjH,OAAO,EAAE,gCAAgC,EAAE,MAAM,gCAAgC,CAAC;;;;AAElF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAEH,MAAM,OAAgB,8BAA8B;IAuTlD,YAAsB,aAA4B,EAAE,eAAkC;QAAhE,kBAAa,GAAb,aAAa,CAAe;QAtTlD;;;;;;;;;;WAUG;QACoC,cAAS,GAAY,KAAK,CAAC;QAmClE;;;;;;WAMG;QACiB,aAAQ,GAAsB,IAAI,YAAY,EAAO,CAAC;QAE1E,iBAAY,GAAW,EAAE,CAAC;QAC1B,cAAS,GAAsB,EAAE,KAAK,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,CAAC;QAE5C,WAAM,GAAQ,YAAY,CAAC;QAC3B,gCAA2B,GAAY,IAAI,CAAC;QAC5C,+BAA0B,GAAY,IAAI,CAAC;QAG7C,WAAM,GAAa,KAAK,CAAC;QAMzB,oBAAe,GAAa,KAAK,CAAC;QAClC,cAAS,GAAY,KAAK,CAAC;QAC3B,cAAS,GAAa,KAAK,CAAC;QAgPlC,IAAI,CAAC,QAAQ,GAAG,eAAe,CAAC,gBAAgB,EAAE,CAAC;IACrD,CAAC;IA1OD,IAAI,qBAAqB;QACvB,OAAO,IAAI,CAAC,2BAA2B,IAAI,IAAI,CAAC,0BAA0B,CAAC;IAC7E,CAAC;IAED;;;;;;;;OAQG;IACH,IAAsB,KAAK,CAAC,KAAc;QACxC,IAAI,CAAC,MAAM,GAAG,gBAAgB,CAAC,KAAK,CAAC,CAAC;IACxC,CAAC;IAED,IAAI,KAAK;QACP,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IAED;;;;;;;;OAQG;IACH,IAAyB,QAAQ,CAAC,KAAc;QAC9C,IAAI,CAAC,SAAS,GAAG,gBAAgB,CAAC,KAAK,CAAC,CAAC;QAEzC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;IACrC,CAAC;IAED,IAAI,QAAQ;QACV,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;IAED;;;;;;OAMG;IACH,IAAyB,OAAO,CAAC,IAAmB;QAClD,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,wBAAwB,CAAC,IAAI,CAAC,CAAC;QACpD,IAAI,CAAC,SAAS,CAAC,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC;QAElC,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QACzC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;IACnC,CAAC;IAED,IAAI,OAAO;QACT,OAAO,IAAI,CAAC,QAAQ,CAAC;IACvB,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAkCG;IACH,IAAyB,QAAQ,CAAC,KAAgC;QAChE,IAAI,KAAK,YAAY,MAAM,IAAI,CAAC,CAAC,KAAK,YAAY,KAAK,CAAC,EAAE;YACxD,IAAI,CAAC,SAAS,GAAG;gBACf,GAAG,gCAAgC,CAAC,eAAe,CAAC;gBACpD,GAAG,gCAAgC,CAAC,IAAI,CAAC,QAAQ,CAAC;gBAClD,GAAG,KAAK;aACT,CAAC;SACH;aAAM;YACL,IAAI,CAAC,SAAS,GAAG,gCAAgC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;SAClE;IACH,CAAC;IAED,IAAI,QAAQ;QACV,OAAO,IAAI,CAAC,SAAS,IAAI,gCAAgC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IAC3E,CAAC;IAED;;;;;;OAMG;IACH,IAAyB,OAAO,CAAC,KAAoB;QACnD,IAAI,KAAK,YAAY,IAAI,EAAE;YACzB,MAAM,IAAI,GAAG,KAAK,CAAC,WAAW,EAAE,CAAC;YAEjC,MAAM,IAAI,GAAG,IAAI,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC,QAAQ,EAAE,EAAE,KAAK,CAAC,OAAO,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;YACxE,iBAAiB,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;YAE9B,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;SACtB;aAAM;YACL,IAAI,CAAC,QAAQ,GAAG,gBAAgB,CAAC,KAAK,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;SACtD;IACH,CAAC;IAED,IAAI,OAAO;QACT,OAAO,IAAI,CAAC,QAAQ,CAAC;IACvB,CAAC;IAED;;;;;;OAMG;IACH,IAAyB,OAAO,CAAC,KAAoB;QACnD,IAAI,KAAK,YAAY,IAAI,EAAE;YACzB,MAAM,IAAI,GAAG,KAAK,CAAC,WAAW,EAAE,CAAC;YAEjC,MAAM,IAAI,GAAG,IAAI,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC,QAAQ,EAAE,EAAE,KAAK,CAAC,OAAO,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;YAC3E,iBAAiB,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;YAE9B,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;SACtB;aAAM;YACL,IAAI,CAAC,QAAQ,GAAG,gBAAgB,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC;SACtD;IACH,CAAC;IAED,IAAI,OAAO;QACT,OAAO,IAAI,CAAC,QAAQ,CAAC;IACvB,CAAC;IAED;;;;;;;;OAQG;IACH,IAAgC,cAAc,CAAC,KAAc;QAC3D,IAAI,CAAC,eAAe,GAAG,gBAAgB,CAAC,KAAK,CAAC,CAAC;IACjD,CAAC;IAED,IAAI,cAAc;QAChB,OAAO,IAAI,CAAC,eAAe,CAAC;IAC9B,CAAC;IAED;;;;;;;;OAQG;IACH,IAAyB,QAAQ,CAAC,KAAc;QAC9C,IAAI,CAAC,SAAS,GAAG,gBAAgB,CAAC,KAAK,CAAC,CAAC;QAEzC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;IACrC,CAAC;IAED,IAAI,QAAQ;QACV,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;IAED;;;;;;;;OAQG;IACH,IAAyB,QAAQ,CAAC,QAAiB;QACjD,IAAI,CAAC,SAAS,GAAG,gBAAgB,CAAC,QAAQ,CAAC,CAAC;QAE5C,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;IACrC,CAAC;IAED,IAAI,QAAQ;QACV,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;IAED;;;;;;OAMG;IACH,IAA2B,SAAS,CAAC,IAAmB;QACtD,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,wBAAwB,CAAC,IAAI,CAAC,CAAC;QACtD,IAAI,CAAC,SAAS,CAAC,KAAK,GAAG,IAAI,CAAC,SAAS,CAAC;QAEtC,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QACzC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;IACnC,CAAC;IAED,IAAI,SAAS;QACX,OAAO,IAAI,CAAC,UAAU,CAAC;IACzB,CAAC;IAMD,8CAA8C;IAC9C,gEAAgE;IAChE,gBAAgB,CAAC,UAAmB;QAClC,IAAI,CAAC,QAAQ,GAAG,UAAU,CAAC;IAC7B,CAAC;IAED,8CAA8C;IAC9C,6EAA6E;IAC7E,gBAAgB,CAAC,IAAS;QACxB,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;IAC5B,CAAC;IAED,8CAA8C;IAC9C,6EAA6E;IAC7E,iBAAiB,CAAC,IAAS;QACzB,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;IAC7B,CAAC;IAED,yBAAyB,CAAE,EAAc;QACvC,IAAI,CAAC,eAAe,GAAG,EAAE,CAAC;IAC5B,CAAC;IAED,QAAQ,CAAC,OAAwB;QAC/B,MAAM,KAAK,GAAsB,OAAO,CAAC,KAAK,IAAI,EAAE,CAAC;QACrD,MAAM,SAAS,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,wBAAwB,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QAChF,MAAM,OAAO,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,wBAAwB,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QAE1E,IAAI,IAAI,CAAC,uBAAuB,CAAC,SAAS,EAAE,OAAO,CAAC,EAAE;YACpD,IAAI,CAAC,YAAY,GAAG,EAAE,CAAC;YAEvB,OAAO;gBACL,QAAQ,EAAE;oBACR,KAAK,EAAE,KAAK;iBACb;aACF,CAAC;SACH;QAED,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,SAAS,EAAE,OAAO,CAAC,EAAE;YAC7C,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC;YAC9C,OAAO;gBACL,IAAI,EAAE;oBACJ,KAAK,EAAE,KAAK;iBACb;aACF,CAAC;SACH;QAED,IAAI,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,IAAI,CAAC,qBAAqB,CAAC,SAAS,EAAE,OAAO,CAAC,EAAE;YAC/F,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC;YAEhD,OAAO;gBACL,IAAI,EAAE;oBACJ,KAAK,EAAE,KAAK;iBACb;aACF,CAAC;SACH;QAED,IAAI,IAAI,CAAC,eAAe,CAAC,SAAS,EAAE,OAAO,CAAC,EAAE;YAC5C,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,QAAQ,CAAC,2BAA2B,CAAC;YAE9D,OAAO;gBACL,IAAI,EAAE;oBACJ,KAAK,EAAE,KAAK;iBACb;aACF,CAAC;SACH;QAED,IAAI,CAAC,SAAS,IAAI,CAAC,IAAI,CAAC,mBAAmB,CAAC,SAAS,CAAC,CAAC,IAAI,CAAC,OAAO,IAAI,CAAC,IAAI,CAAC,mBAAmB,CAAC,OAAO,CAAC,CAAC,EAAE;YAC1G,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,QAAQ,CAAC,eAAe,CAAC;YAElD,OAAO;gBACL,IAAI,EAAE;oBACJ,KAAK,EAAE,KAAK;iBACb;aACF,CAAC;SACH;QAED,OAAO,IAAI,CAAC;IACd,CAAC;IAED,mBAAmB,CAAC,SAAc;QAChC,OAAO,iBAAiB,CAAC,gBAAgB,CAAC,SAAS,EAAE,KAAK,EAAE,KAAK,CAAC,EAAE,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;IACpG,CAAC;IAED,UAAU,CAAC,SAA4B;QACrC,IAAI,CAAC,6BAA6B,EAAE,CAAC;QAErC,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,qBAAqB,CAAC,SAAS,CAAC,EAAE;YACvD,IAAI,CAAC,SAAS,GAAG,EAAE,KAAK,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,CAAC;SACzC;QAED,IAAI,CAAC,SAAS,EAAE;YACd,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;SACpC;QAED,IAAI,IAAI,CAAC,qBAAqB,CAAC,SAAS,CAAC,EAAE;YACzC,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC;SAC7B;QAED,IAAI,IAAI,CAAC,iBAAiB,CAAC,SAAS,CAAC,EAAE;YACrC,IAAI,CAAC,SAAS,GAAG;gBACf,KAAK,EAAE,IAAI,CAAC,wBAAwB,CAAC,SAAS,CAAC,KAAK,CAAC;gBACrD,GAAG,EAAE,IAAI,CAAC,wBAAwB,CAAC,SAAS,CAAC,GAAG,CAAC;aAClD,CAAC;YAEF,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;SAClC;QAED,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;IAC3C,CAAC;IAES,gBAAgB,CAAC,KAAa;QACtC,OAAO,KAAK,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;IACxD,CAAC;IAED,4BAA4B;IAClB,WAAW,CAAC,KAAU;QAC9B,MAAM,KAAK,GAAG,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,EAAE,GAAG,KAAK,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC;QAC/D,8EAA8E;QAC9E,IAAI,IAAI,CAAC,aAAa,EAAE;YACtB,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;SAC3B;IACH,CAAC;IAES,aAAa,CAAC,KAAU;QAChC,MAAM,KAAK,GAAG,EAAE,GAAG,KAAK,EAAE,CAAC;QAC3B,IAAI,IAAI,CAAC,eAAe,EAAE;YACxB,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC;SAC7B;IACH,CAAC;IAES,eAAe,CAAC,SAAiB,EAAE,OAAe;QAC1D,IAAI,SAAS,KAAK,EAAE,IAAI,OAAO,KAAK,EAAE,EAAE;YACtC,OAAO,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC,IAAI,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;SACjE;aAAM,IAAI,SAAS,KAAK,EAAE,EAAE;YAC3B,OAAO,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC;SACpC;aAAM;YACL,OAAO,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;SAClC;IACH,CAAC;IAEO,wBAAwB,CAAC,KAAU;QACzC,IAAI,KAAK,YAAY,IAAI,EAAE;YACzB,OAAO,IAAI,CAAC,aAAa,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;SACnD;QAED,OAAO,KAAK,CAAC;IACf,CAAC;IAEO,eAAe,CAAC,SAAiB,EAAE,OAAe;QACxD,OAAO,CAAC,IAAI,CAAC,aAAa,CAAC,gBAAgB,CAAC,OAAO,EAAE,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,0BAA0B,CAAC;IACtG,CAAC;IAEO,qBAAqB,CAAC,SAAiB,EAAE,OAAe;QAC9D,OAAO,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,IAAI,IAAI,CAAC,gBAAgB,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,2BAA2B,CAAC;IACjH,CAAC;IAEO,qBAAqB,CAAC,KAAK;QACjC,OAAO,KAAK,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAC;IACjD,CAAC;IAEO,iBAAiB,CAAC,KAAK;QAC7B,OAAO,KAAK,IAAI,KAAK,CAAC,cAAc,CAAC,OAAO,CAAC,IAAI,KAAK,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;IAC/E,CAAC;IAEO,uBAAuB,CAAC,SAAiB,EAAE,OAAe;QAChE,OAAO,CACL,IAAI,CAAC,qBAAqB;YAC1B,cAAc,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE,SAAS,CAAC;YACvD,cAAc,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE,OAAO,CAAC,CACtD,CAAC;IACJ,CAAC;IAEO,WAAW,CAAC,IAAY;QAC9B,MAAM,CAAC,OAAO,EAAE,QAAQ,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QACpD,MAAM,IAAI,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC;QAC7B,MAAM,KAAK,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC;QAC/B,MAAM,GAAG,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC;QAE3B,mCAAmC;QACnC,IAAI,KAAK,KAAK,CAAC,IAAI,KAAK,KAAK,CAAC,IAAI,KAAK,KAAK,CAAC,IAAI,KAAK,KAAK,CAAC,IAAI,KAAK,KAAK,CAAC,IAAI,KAAK,KAAK,EAAE,IAAI,KAAK,KAAK,EAAE,EAAE;YAC3G,OAAO,GAAG,GAAG,CAAC,IAAI,GAAG,GAAG,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC;SAC3C;aAAM,IAAI,KAAK,KAAK,CAAC,IAAI,KAAK,KAAK,CAAC,IAAI,KAAK,KAAK,CAAC,IAAI,KAAK,KAAK,EAAE,EAAE;YACpE,mCAAmC;YACnC,OAAO,GAAG,GAAG,CAAC,IAAI,GAAG,GAAG,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC;SAC3C;aAAM;YACL,gFAAgF;YAChF,IAAI,CAAC,IAAI,GAAG,CAAC,KAAK,CAAC,IAAI,IAAI,GAAG,GAAG,KAAK,CAAC,CAAC,IAAI,IAAI,GAAG,GAAG,KAAK,CAAC,EAAE;gBAC5D,OAAO,GAAG,GAAG,CAAC,IAAI,GAAG,GAAG,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC;aAC3C;iBAAM;gBACL,OAAO,GAAG,GAAG,CAAC,IAAI,GAAG,GAAG,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC;aAC3C;SACF;IACH,CAAC;;4GA3fmB,8BAA8B;iFAA9B,8BAA8B;AAYX;IAAf,YAAY,EAAE;iEAA4B;uFAZ9C,8BAA8B;cADnD,SAAS;gGAa+B,SAAS;kBAA/C,KAAK;mBAAC,cAAc;YASJ,IAAI;kBAApB,KAAK;mBAAC,QAAQ;YASG,KAAK;kBAAtB,KAAK;mBAAC,SAAS;YAeK,QAAQ;kBAA5B,KAAK;mBAAC,YAAY;YASC,QAAQ;kBAA3B,MAAM;mBAAC,UAAU;YAsCI,KAAK;kBAA1B,KAAK;mBAAC,SAAS;YAiBS,QAAQ;kBAAhC,KAAK;mBAAC,YAAY;YAiBM,OAAO;kBAA/B,KAAK;mBAAC,YAAY;YA+CM,QAAQ;kBAAhC,KAAK;mBAAC,YAAY;YAuBM,OAAO;kBAA/B,KAAK;mBAAC,YAAY;YAwBM,OAAO;kBAA/B,KAAK;mBAAC,YAAY;YA0Ba,cAAc;kBAA7C,KAAK;mBAAC,mBAAmB;YAiBD,QAAQ;kBAAhC,KAAK;mBAAC,YAAY;YAmBM,QAAQ;kBAAhC,KAAK;mBAAC,YAAY;YAiBQ,SAAS;kBAAnC,KAAK;mBAAC,cAAc","sourcesContent":["import { ChangeDetectorRef, Directive, EventEmitter, Input, Output } from '@angular/core';\nimport { AbstractControl, ControlValueAccessor, ValidationErrors, Validator } from '@angular/forms';\nimport { InputBoolean } from '../../../decorators';\nimport { poLocaleDefault } from '../../../services/po-language/po-language.constant';\nimport { PoLanguageService } from '../../../services/po-language/po-language.service';\nimport { requiredFailed } from '../validators';\nimport { PoDateService } from './../../../services/po-date/po-date.service';\nimport { convertIsoToDate, convertToBoolean, setYearFrom0To100, validateDateRange } from './../../../utils/util';\nimport { PoDatepickerRangeLiterals } from './interfaces/po-datepicker-range-literals.interface';\nimport { PoDatepickerRange } from './interfaces/po-datepicker-range.interface';\nimport { poDatepickerRangeLiteralsDefault } from './po-datepicker-range.literals';\n\n/**\n * @description\n *\n * O `po-datepicker-range` é um componente para seleção de um período entre duas datas, onde é possível informar apenas\n * a data inicial ou a data final.\n *\n * O componente `[(ngModel)]` do `po-datepicker-range` trabalha com um objeto que implementa a interface\n * `PoDatepickerRange`, contendo as seguintes propriedades:\n * ```\n * { \"start\": '2017-11-28', \"end\": '2017-11-30' }\n * ```\n *\n * <a id=\"accepted-formats\"></a>\n * Este componente pode receber os seguintes formatos de data:\n *\n * - **Data e hora combinados (E8601DZw): yyyy-mm-ddThh:mm:ss+|-hh:mm**\n * ```\n * '2017-11-28T00:00:00-02:00';\n * ```\n *\n * - **Data (E8601DAw.): yyyy-mm-dd**\n * ```\n * '2017-11-28';\n * ```\n *\n * - **JavaScript Date Object:**\n * ```\n * new Date(2017, 10, 28);\n * ```\n *\n * > O componente respeitará o formato passado para o *model* via codificação. Porém, caso seja feita alteração em algum\n * dos valores de data em tela, o componente atribuirá o formato **Data (E8601DAw.): yyyy-mm-dd** ao model.\n *\n * Importante:\n *\n * - Quando preenchidas a data inicial e final, a data inicial deve ser sempre menor ou igual a data final;\n * - Ao passar uma data inválida via codificação, o valor será mantido no *model* e o `input` da tela aparecerá vazio;\n * - Permite trabalhar com as duas datas separadamente através das propriedades `p-start-date` e `p-end-date` no lugar do\n * `[(ngModel)]`, no entanto sem a validação do formulário;\n * - Para a validação do formulário, utilize o `[(ngModel)]`.\n */\n@Directive()\nexport abstract class PoDatepickerRangeBaseComponent implements ControlValueAccessor, Validator {\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Aplica foco no elemento ao ser iniciado.\n   *\n   * > Caso mais de um elemento seja configurado com essa propriedade, apenas o último elemento declarado com ela terá o foco.\n   *\n   * @default `false`\n   */\n  @Input('p-auto-focus') @InputBoolean() autoFocus: boolean = false;\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Texto de apoio do campo.\n   */\n  @Input('p-help') help?: string;\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Rótulo do campo.\n   */\n  @Input('p-label') label?: string;\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Define se a indicação de campo opcional será exibida.\n   *\n   * > Não será exibida a indicação se:\n   * - O campo conter `p-required`;\n   * - Não possuir `p-help` e/ou `p-label`.\n   *\n   * @default `false`\n   */\n  @Input('p-optional') optional: boolean;\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Evento disparado ao alterar valor do campo.\n   */\n  @Output('p-change') onChange: EventEmitter<any> = new EventEmitter<any>();\n\n  errorMessage: string = '';\n  dateRange: PoDatepickerRange = { start: '', end: '' };\n\n  protected format: any = 'dd/mm/yyyy';\n  protected isDateRangeInputFormatValid: boolean = true;\n  protected isStartDateRangeInputValid: boolean = true;\n  protected onTouchedModel: any;\n\n  private _clean?: boolean = false;\n  private _disabled?;\n  private _endDate?;\n  private _literals?: any;\n  private _maxDate: Date;\n  private _minDate: Date;\n  private _noAutocomplete?: boolean = false;\n  private _readonly: boolean = false;\n  private _required?: boolean = false;\n  private _startDate?;\n\n  private language;\n  private onChangeModel: any;\n  private validatorChange: any;\n\n  get isDateRangeInputValid() {\n    return this.isDateRangeInputFormatValid && this.isStartDateRangeInputValid;\n  }\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Habilita ação para limpar o campo.\n   *\n   * @default `false`\n   */\n  @Input('p-clean') set clean(clean: boolean) {\n    this._clean = convertToBoolean(clean);\n  }\n\n  get clean() {\n    return this._clean;\n  }\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Desabilita o campo.\n   *\n   * @default `false`\n   */\n  @Input('p-disabled') set disabled(value: boolean) {\n    this._disabled = convertToBoolean(value);\n\n    this.validateModel(this.dateRange);\n  }\n\n  get disabled() {\n    return this._disabled;\n  }\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Data final.\n   */\n  @Input('p-end-date') set endDate(date: string | Date) {\n    this._endDate = this.convertPatternDateFormat(date);\n    this.dateRange.end = this.endDate;\n\n    this.updateScreenByModel(this.dateRange);\n    this.updateModel(this.dateRange);\n  }\n\n  get endDate() {\n    return this._endDate;\n  }\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Objeto com as literais usadas no `po-datepicker-range`.\n   *\n   * Existem duas maneiras de customizar o componente, passando um objeto com todas as literais disponíveis:\n   *\n   * ```\n   *  const customLiterals: PoDatepickerRangeLiterals = {\n   *    invalidFormat: 'Date in inconsistent format',\n   *    startDateGreaterThanEndDate: 'End date less than start date'\n   *  };\n   * ```\n   *\n   * Ou passando apenas as literais que deseja customizar:\n   *\n   * ```\n   *  const customLiterals: PoDatepickerRangeLiterals = {\n   *    invalidFormat: 'Date in inconsistent format'\n   *  };\n   * ```\n   *\n   * E para carregar as literais customizadas, basta apenas passar o objeto para o componente.\n   *\n   * ```\n   * <po-datepicker-range\n   *   [p-literals]=\"customLiterals\">\n   * </po-datepicker-range>\n   * ```\n   *\n   * > O objeto padrão de literais será traduzido de acordo com o idioma do\n   * [`PoI18nService`](/documentation/po-i18n) ou do browser.\n   */\n  @Input('p-literals') set literals(value: PoDatepickerRangeLiterals) {\n    if (value instanceof Object && !(value instanceof Array)) {\n      this._literals = {\n        ...poDatepickerRangeLiteralsDefault[poLocaleDefault],\n        ...poDatepickerRangeLiteralsDefault[this.language],\n        ...value\n      };\n    } else {\n      this._literals = poDatepickerRangeLiteralsDefault[this.language];\n    }\n  }\n\n  get literals() {\n    return this._literals || poDatepickerRangeLiteralsDefault[this.language];\n  }\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Define uma data mínima para o `po-datepicker-range`.\n   */\n  @Input('p-min-date') set minDate(value: string | Date) {\n    if (value instanceof Date) {\n      const year = value.getFullYear();\n\n      const date = new Date(year, value.getMonth(), value.getDate(), 0, 0, 0);\n      setYearFrom0To100(date, year);\n\n      this._minDate = date;\n    } else {\n      this._minDate = convertIsoToDate(value, true, false);\n    }\n  }\n\n  get minDate() {\n    return this._minDate;\n  }\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Define uma data máxima para o `po-datepicker-range`.\n   */\n  @Input('p-max-date') set maxDate(value: string | Date) {\n    if (value instanceof Date) {\n      const year = value.getFullYear();\n\n      const date = new Date(year, value.getMonth(), value.getDate(), 23, 59, 59);\n      setYearFrom0To100(date, year);\n\n      this._maxDate = date;\n    } else {\n      this._maxDate = convertIsoToDate(value, false, true);\n    }\n  }\n\n  get maxDate() {\n    return this._maxDate;\n  }\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Define a propriedade nativa `autocomplete` do campo como `off`.\n   *\n   * @default `false`\n   */\n  @Input('p-no-autocomplete') set noAutocomplete(value: boolean) {\n    this._noAutocomplete = convertToBoolean(value);\n  }\n\n  get noAutocomplete() {\n    return this._noAutocomplete;\n  }\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Indica que o campo será somente leitura.\n   *\n   * @default `false`\n   */\n  @Input('p-readonly') set readonly(value: boolean) {\n    this._readonly = convertToBoolean(value);\n\n    this.validateModel(this.dateRange);\n  }\n\n  get readonly() {\n    return this._readonly;\n  }\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Indica que o campo será obrigatório.\n   *\n   * @default `false`\n   */\n  @Input('p-required') set required(required: boolean) {\n    this._required = convertToBoolean(required);\n\n    this.validateModel(this.dateRange);\n  }\n\n  get required() {\n    return this._required;\n  }\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Data inicial.\n   */\n  @Input('p-start-date') set startDate(date: string | Date) {\n    this._startDate = this.convertPatternDateFormat(date);\n    this.dateRange.start = this.startDate;\n\n    this.updateScreenByModel(this.dateRange);\n    this.updateModel(this.dateRange);\n  }\n\n  get startDate() {\n    return this._startDate;\n  }\n\n  constructor(protected poDateService: PoDateService, languageService: PoLanguageService) {\n    this.language = languageService.getShortLanguage();\n  }\n\n  // Função implementada do ControlValueAccessor\n  // Usada para interceptar os estados de habilitado via forms api\n  setDisabledState(isDisabled: boolean) {\n    this.disabled = isDisabled;\n  }\n\n  // Função implementada do ControlValueAccessor\n  // Usada para interceptar as mudanças e não atualizar automaticamente o Model\n  registerOnChange(func: any): void {\n    this.onChangeModel = func;\n  }\n\n  // Função implementada do ControlValueAccessor\n  // Usada para interceptar as mudanças e não atualizar automaticamente o Model\n  registerOnTouched(func: any): void {\n    this.onTouchedModel = func;\n  }\n\n  registerOnValidatorChange?(fn: () => void): void {\n    this.validatorChange = fn;\n  }\n\n  validate(control: AbstractControl): ValidationErrors {\n    const value: PoDatepickerRange = control.value || {};\n    const startDate = value.start ? this.convertPatternDateFormat(value.start) : '';\n    const endDate = value.end ? this.convertPatternDateFormat(value.end) : '';\n\n    if (this.requiredDateRangeFailed(startDate, endDate)) {\n      this.errorMessage = '';\n\n      return {\n        required: {\n          valid: false\n        }\n      };\n    }\n\n    if (!this.verifyValidDate(startDate, endDate)) {\n      this.errorMessage = this.literals.invalidDate;\n      return {\n        date: {\n          valid: false\n        }\n      };\n    }\n\n    if (this.dateRangeObjectFailed(control.value) || this.dateRangeFormatFailed(startDate, endDate)) {\n      this.errorMessage = this.literals.invalidFormat;\n\n      return {\n        date: {\n          valid: false\n        }\n      };\n    }\n\n    if (this.dateRangeFailed(startDate, endDate)) {\n      this.errorMessage = this.literals.startDateGreaterThanEndDate;\n\n      return {\n        date: {\n          valid: false\n        }\n      };\n    }\n\n    if ((startDate && !this.validateDateInRange(startDate)) || (endDate && !this.validateDateInRange(endDate))) {\n      this.errorMessage = this.literals.dateOutOfPeriod;\n\n      return {\n        date: {\n          valid: false\n        }\n      };\n    }\n\n    return null;\n  }\n\n  validateDateInRange(startDate: any): boolean {\n    return validateDateRange(convertIsoToDate(startDate, false, false), this._minDate, this._maxDate);\n  }\n\n  writeValue(dateRange: PoDatepickerRange): void {\n    this.resetDateRangeInputValidation();\n\n    if (!dateRange || this.dateRangeObjectFailed(dateRange)) {\n      this.dateRange = { start: '', end: '' };\n    }\n\n    if (!dateRange) {\n      this.validateModel(this.dateRange);\n    }\n\n    if (this.dateRangeObjectFailed(dateRange)) {\n      this.updateModel(dateRange);\n    }\n\n    if (this.isDateRangeObject(dateRange)) {\n      this.dateRange = {\n        start: this.convertPatternDateFormat(dateRange.start),\n        end: this.convertPatternDateFormat(dateRange.end)\n      };\n\n      this.updateModel(this.dateRange);\n    }\n\n    this.updateScreenByModel(this.dateRange);\n  }\n\n  protected dateFormatFailed(value: string): boolean {\n    return value && !this.poDateService.isValidIso(value);\n  }\n\n  // Executa a função onChange\n  protected updateModel(value: any) {\n    const model = typeof value === 'object' ? { ...value } : value;\n    // Quando o input não possui um formulário, então esta função não é registrada\n    if (this.onChangeModel) {\n      this.onChangeModel(model);\n    }\n  }\n\n  protected validateModel(value: any) {\n    const model = { ...value };\n    if (this.validatorChange) {\n      this.validatorChange(model);\n    }\n  }\n\n  protected verifyValidDate(startDate: string, endDate: string) {\n    if (startDate !== '' && endDate !== '') {\n      return this.dateIsValid(startDate) && this.dateIsValid(endDate);\n    } else if (startDate !== '') {\n      return this.dateIsValid(startDate);\n    } else {\n      return this.dateIsValid(endDate);\n    }\n  }\n\n  private convertPatternDateFormat(value: any) {\n    if (value instanceof Date) {\n      return this.poDateService.convertDateToISO(value);\n    }\n\n    return value;\n  }\n\n  private dateRangeFailed(startDate: string, endDate: string): boolean {\n    return !this.poDateService.isDateRangeValid(endDate, startDate) || !this.isStartDateRangeInputValid;\n  }\n\n  private dateRangeFormatFailed(startDate: string, endDate: string): boolean {\n    return this.dateFormatFailed(endDate) || this.dateFormatFailed(startDate) || !this.isDateRangeInputFormatValid;\n  }\n\n  private dateRangeObjectFailed(value): boolean {\n    return value && !this.isDateRangeObject(value);\n  }\n\n  private isDateRangeObject(value): boolean {\n    return value && value.hasOwnProperty('start') && value.hasOwnProperty('end');\n  }\n\n  private requiredDateRangeFailed(startDate: string, endDate: string): boolean {\n    return (\n      this.isDateRangeInputValid &&\n      requiredFailed(this.required, this.disabled, startDate) &&\n      requiredFailed(this.required, this.disabled, endDate)\n    );\n  }\n\n  private dateIsValid(date: string) {\n    const [strYear, strMonth, strDay] = date.split('-');\n    const year = Number(strYear);\n    const month = Number(strMonth);\n    const day = Number(strDay);\n\n    //verificação dos meses com 31 dias\n    if (month === 1 || month === 3 || month === 5 || month === 7 || month === 8 || month === 10 || month === 12) {\n      return day < 1 || day > 31 ? false : true;\n    } else if (month === 4 || month === 6 || month === 9 || month === 11) {\n      //verificação dos meses com 30 dias\n      return day < 1 || day > 30 ? false : true;\n    } else {\n      //verificacao de ano bissexto para verificar até qual dia irá o mês de fevereiro\n      if ((year % 4 === 0 && year % 100 !== 0) || year % 400 === 0) {\n        return day < 1 || day > 29 ? false : true;\n      } else {\n        return day < 1 || day > 28 ? false : true;\n      }\n    }\n  }\n\n  protected abstract resetDateRangeInputValidation(): void;\n\n  protected abstract updateScreenByModel(dateRange: PoDatepickerRange);\n}\n"]}