@gipisistemas/ng-core 1.1.0 → 1.1.2

package/esm5/shared/gipi-components/input-monthpicker/input-monthpicker.component.js

@@ -0,0 +1,426 @@
+import { __decorate, __metadata } from "tslib";
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, EventEmitter, forwardRef, Input, OnInit, Output, ViewChild } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { ObjectUtil } from '../../../core/utils/object.util';
+import { GIPINgConfig } from '../../api/gipi-ng-config';
+var yearsPerPage = 24;
+var nextUniqueId = 0;
+var GIPIInputMonthPickerComponent = /** @class */ (function () {
+    function GIPIInputMonthPickerComponent(_changeDetectorRef, _config) {
+        this._changeDetectorRef = _changeDetectorRef;
+        this._config = _config;
+        this._name = "gipi-input-monthpicker-" + nextUniqueId++;
+        this._yearArrays = [];
+        this._now = new Date();
+        this._currentMonth = this._now.getMonth();
+        this._currentYear = this._now.getFullYear();
+        this._overlayVisible = false;
+        this.monthArrays = Array.from(Array(12).keys());
+        this.monthNames = ['Jan', 'Fev', 'Mar', 'Abr', 'Mai', 'Jun', 'Jul', 'Ago', 'Set', 'Out', 'Nov', 'Dez'];
+        this.internalCalendarView = 'month';
+        this.id = this._name;
+        this.name = this._name;
+        this.ariaLabel = '';
+        this.label = '';
+        this.placeholder = '';
+        this.disabled = false;
+        this.loading = false;
+        this.required = false;
+        this.showOnFocus = true;
+        this._calendarView = 'month';
+        this.onClose = new EventEmitter();
+        this.onMonthChange = new EventEmitter();
+        this.onYearChange = new EventEmitter();
+        this.onKeydown = new EventEmitter();
+        this.onKeydownEnter = new EventEmitter();
+        this.onFocus = new EventEmitter();
+        this.onBlur = new EventEmitter();
+        this.onClick = new EventEmitter();
+        this.onChange = function () { };
+        this.onTouch = function () { };
+    }
+    GIPIInputMonthPickerComponent_1 = GIPIInputMonthPickerComponent;
+    Object.defineProperty(GIPIInputMonthPickerComponent.prototype, "initialYear", {
+        get: function () {
+            return this._initialYear;
+        },
+        set: function (value) {
+            if (value > 1900) {
+                this._initialYear = value;
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GIPIInputMonthPickerComponent.prototype, "yearArrays", {
+        get: function () {
+            return this._yearArrays;
+        },
+        set: function (value) {
+            this._yearArrays = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GIPIInputMonthPickerComponent.prototype, "calendarView", {
+        get: function () {
+            return this._calendarView;
+        },
+        set: function (value) {
+            this._calendarView = value;
+            if (!ObjectUtil.isNull(this.value)) {
+                if (value === 'month') {
+                    this.monthChanged(this.value.getMonth());
+                }
+                else if (value === 'year') {
+                    this.yearChanged(this.value.getFullYear());
+                }
+                this.internalCalendarView = value;
+                this._changeDetectorRef.markForCheck();
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GIPIInputMonthPickerComponent.prototype, "value", {
+        get: function () {
+            return this._value;
+        },
+        set: function (value) {
+            this._value = value;
+            if (value) {
+                value.setDate(1);
+                this._value = value;
+                if (this.calendarView === 'month') {
+                    var month = this.value.getMonth() + 1;
+                    this.inputFieldValue = ((month <= 9) ? ('0' + month) : month) + "/" + this.value.getFullYear();
+                }
+                else if (this.calendarView === 'year') {
+                    this.inputFieldValue = "" + this.value.getFullYear();
+                }
+            }
+            this.onChange(value);
+            this._changeDetectorRef.markForCheck();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    GIPIInputMonthPickerComponent.prototype.ngOnInit = function () {
+        this._generateYears();
+    };
+    GIPIInputMonthPickerComponent.prototype.registerOnChange = function (fn) {
+        this.onChange = fn;
+    };
+    GIPIInputMonthPickerComponent.prototype.registerOnTouched = function (fn) {
+        this.onTouch = fn;
+    };
+    GIPIInputMonthPickerComponent.prototype.writeValue = function (value) {
+        this.value = value;
+    };
+    GIPIInputMonthPickerComponent.prototype.setDisabledState = function (val) {
+        this.disabled = val;
+        this._changeDetectorRef.markForCheck();
+    };
+    GIPIInputMonthPickerComponent.prototype._generateYears = function () {
+        var realCurrentYear = this._now.getFullYear();
+        if (!this.initialYear) {
+            this.initialYear = this.value ? this.value.getFullYear() : this._now.getFullYear();
+        }
+        this.yearArrays = [];
+        if (this.initialYear === realCurrentYear) {
+            var baseYear = this.initialYear - (this.initialYear % (yearsPerPage / 2));
+            for (var y = 0; y < yearsPerPage; y++) {
+                this.yearArrays.push((baseYear + y));
+            }
+        }
+        else {
+            for (var y = this.initialYear; y < (this.initialYear + yearsPerPage); y++) {
+                this.yearArrays.push(y);
+            }
+        }
+    };
+    GIPIInputMonthPickerComponent.prototype.clickToggleCalendar = function (currentView) {
+        if (currentView) {
+            this.internalCalendarView = currentView;
+        }
+        else {
+            if (this.internalCalendarView === 'month') {
+                this.internalCalendarView = 'year';
+            }
+        }
+        this._changeDetectorRef.detectChanges();
+    };
+    GIPIInputMonthPickerComponent.prototype.clickPrev = function () {
+        if (this.internalCalendarView === 'month') {
+            this.value = new Date(this.value.getFullYear() - 1, this.value.getMonth(), 1);
+            this.initialYear = (this.value.getFullYear() - 7);
+        }
+        else if (this.internalCalendarView === 'year') {
+            this.initialYear = this.yearArrays[0] - (yearsPerPage - 1);
+        }
+        this._generateYears();
+        this._changeDetectorRef.detectChanges();
+    };
+    GIPIInputMonthPickerComponent.prototype.clickNext = function () {
+        if (this.internalCalendarView === 'month') {
+            this.value = new Date(this.value.getFullYear() + 1, this.value.getMonth(), 1);
+            this.initialYear = ((this.value.getFullYear() - 7) + 1);
+        }
+        else if (this.internalCalendarView === 'year') {
+            this.initialYear = this.yearArrays[yearsPerPage - 1];
+        }
+        this._generateYears();
+        this._changeDetectorRef.detectChanges();
+    };
+    /**
+     * Chamado quando o mês é alterado
+     * @param month mês selecionado no calendário de meses
+     */
+    GIPIInputMonthPickerComponent.prototype.monthChanged = function (month) {
+        var year = this.value.getFullYear();
+        this._monthOrYearChanged(month, year);
+        this._hideOverlay();
+    };
+    /**
+     * Chamado quando o ano é alterado
+     * @param year ano selecionado no calendário de anos
+     */
+    GIPIInputMonthPickerComponent.prototype.yearChanged = function (year) {
+        var month = this.value.getMonth();
+        this._monthOrYearChanged(month, year);
+        if (this.calendarView === 'month') {
+            this.clickToggleCalendar('month');
+        }
+        else if (this.calendarView === 'year') {
+            this._hideOverlay();
+        }
+    };
+    /**
+     *  Chamar quando mês ou ano mudou
+     * @param month número do mês 0-11
+     * @param year ano exemplo: 1995
+     */
+    GIPIInputMonthPickerComponent.prototype._monthOrYearChanged = function (month, year) {
+        var newMonth = month;
+        var newYear = year;
+        if (this.minDate) {
+            if (newYear < this.minDate.getFullYear() || (newYear === this.minDate.getFullYear() && newMonth < this.minDate.getMonth())) {
+                newMonth = this.minDate.getMonth();
+                newYear = this.minDate.getFullYear();
+            }
+        }
+        if (this.maxDate) {
+            if (newYear > this.maxDate.getFullYear() || (newYear === this.maxDate.getFullYear() && newMonth > this.maxDate.getMonth())) {
+                newMonth = this.maxDate.getMonth();
+                newYear = this.maxDate.getFullYear();
+            }
+        }
+        this.value = new Date(newYear, newMonth, 1);
+        this._changeDetectorRef.detectChanges();
+    };
+    GIPIInputMonthPickerComponent.prototype.isMonthSelected = function (month) {
+        if (this.value) {
+            return this.value.getMonth() === month;
+        }
+        return false;
+    };
+    GIPIInputMonthPickerComponent.prototype.isMonthDisabled = function (month) {
+        if (this.value && this.minDate && this.maxDate) {
+            return (this.value.getFullYear() === this.minDate.getFullYear() && month < this.minDate.getMonth())
+                || (this.value.getFullYear() === this.maxDate.getFullYear() && month > this.maxDate.getMonth());
+        }
+        return false;
+    };
+    GIPIInputMonthPickerComponent.prototype.isYearSelected = function (year) {
+        if (this.value) {
+            return this.value.getFullYear() === year;
+        }
+        return false;
+    };
+    GIPIInputMonthPickerComponent.prototype.isYearDisabled = function (year) {
+        if (this.value && this.minDate && this.maxDate) {
+            return (this.value.getFullYear() === this.minDate.getFullYear() && year < this.minDate.getFullYear())
+                || (this.value.getFullYear() === this.maxDate.getFullYear() && year > this.maxDate.getFullYear());
+        }
+        return false;
+    };
+    GIPIInputMonthPickerComponent.prototype.onInputKeydown = function (event) {
+        if (!this.disabled) {
+            if (event.key.toUpperCase() === 'ENTER') {
+                this.onKeydownEnter.emit(event);
+            }
+            this.onKeydown.emit(event);
+        }
+    };
+    GIPIInputMonthPickerComponent.prototype.onInputKeyup = function (event) {
+        if (!this.disabled) {
+            if ((event.key.toUpperCase() === 'ESC') || (event.key.toUpperCase() === 'ESCAPE')) {
+                this._hideOverlay();
+            }
+            this.onKeydown.emit(event);
+        }
+    };
+    GIPIInputMonthPickerComponent.prototype.onInputFocus = function (event) {
+        if (!this.disabled && this.showOnFocus) {
+            this._showOverlay();
+            this.onFocus.emit(event);
+        }
+    };
+    GIPIInputMonthPickerComponent.prototype.onInputBlur = function (event) {
+        if (!this.disabled) {
+            this.onBlur.emit(event);
+            this.onTouch();
+        }
+    };
+    GIPIInputMonthPickerComponent.prototype.onInputClick = function (event) {
+        if (!this.disabled) {
+            this._showOverlay();
+            this.onClick.emit(event);
+        }
+    };
+    GIPIInputMonthPickerComponent.prototype.onButtonShowMonthpicker = function () {
+        this.toogleOverlay();
+        this._changeDetectorRef.markForCheck();
+    };
+    GIPIInputMonthPickerComponent.prototype._showOverlay = function () {
+        if (!this._overlayVisible) {
+            this._overlayVisible = true;
+        }
+    };
+    GIPIInputMonthPickerComponent.prototype._hideOverlay = function () {
+        this._overlayVisible = false;
+        this._changeDetectorRef.markForCheck();
+    };
+    GIPIInputMonthPickerComponent.prototype.toogleOverlay = function () {
+        if (this.disabled || this.loading) {
+            return;
+        }
+        else {
+            if (!this._overlayVisible) {
+                this._showOverlay();
+            }
+            else {
+                this._hideOverlay();
+            }
+        }
+    };
+    var GIPIInputMonthPickerComponent_1;
+    GIPIInputMonthPickerComponent.ctorParameters = function () { return [
+        { type: ChangeDetectorRef },
+        { type: GIPINgConfig }
+    ]; };
+    __decorate([
+        Input(),
+        __metadata("design:type", Object)
+    ], GIPIInputMonthPickerComponent.prototype, "id", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], GIPIInputMonthPickerComponent.prototype, "name", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], GIPIInputMonthPickerComponent.prototype, "ariaLabel", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], GIPIInputMonthPickerComponent.prototype, "label", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], GIPIInputMonthPickerComponent.prototype, "placeholder", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean)
+    ], GIPIInputMonthPickerComponent.prototype, "disabled", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean)
+    ], GIPIInputMonthPickerComponent.prototype, "loading", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean)
+    ], GIPIInputMonthPickerComponent.prototype, "required", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean)
+    ], GIPIInputMonthPickerComponent.prototype, "showOnFocus", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Date)
+    ], GIPIInputMonthPickerComponent.prototype, "minDate", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Date)
+    ], GIPIInputMonthPickerComponent.prototype, "maxDate", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String),
+        __metadata("design:paramtypes", [String])
+    ], GIPIInputMonthPickerComponent.prototype, "calendarView", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", Date),
+        __metadata("design:paramtypes", [Date])
+    ], GIPIInputMonthPickerComponent.prototype, "value", null);
+    __decorate([
+        Output(),
+        __metadata("design:type", EventEmitter)
+    ], GIPIInputMonthPickerComponent.prototype, "onClose", void 0);
+    __decorate([
+        Output(),
+        __metadata("design:type", EventEmitter)
+    ], GIPIInputMonthPickerComponent.prototype, "onMonthChange", void 0);
+    __decorate([
+        Output(),
+        __metadata("design:type", EventEmitter)
+    ], GIPIInputMonthPickerComponent.prototype, "onYearChange", void 0);
+    __decorate([
+        Output(),
+        __metadata("design:type", EventEmitter)
+    ], GIPIInputMonthPickerComponent.prototype, "onKeydown", void 0);
+    __decorate([
+        Output(),
+        __metadata("design:type", EventEmitter)
+    ], GIPIInputMonthPickerComponent.prototype, "onKeydownEnter", void 0);
+    __decorate([
+        Output(),
+        __metadata("design:type", EventEmitter)
+    ], GIPIInputMonthPickerComponent.prototype, "onFocus", void 0);
+    __decorate([
+        Output(),
+        __metadata("design:type", EventEmitter)
+    ], GIPIInputMonthPickerComponent.prototype, "onBlur", void 0);
+    __decorate([
+        Output(),
+        __metadata("design:type", EventEmitter)
+    ], GIPIInputMonthPickerComponent.prototype, "onClick", void 0);
+    __decorate([
+        ViewChild('inputMonthPicker', { static: true, read: HTMLInputElement }),
+        __metadata("design:type", HTMLInputElement)
+    ], GIPIInputMonthPickerComponent.prototype, "inputMonthPickerRef", void 0);
+    GIPIInputMonthPickerComponent = GIPIInputMonthPickerComponent_1 = __decorate([
+        Component({
+            selector: "gipi-input-monthpicker",
+            exportAs: 'gipiInputMonthPicker',
+            template: "<label class=\"input-monthpicker-container\"\n       [attr.for]=\"id\">\n    <span class=\"input-monthpicker-label\"\n          *ngIf=\"label\">\n        {{ label }}\n        <span *ngIf=\"required && label\"> * </span>\n    </span>\n\n    <div class=\"input-monthpicker-content\"\n         (click)=\"onInputClick($event)\"\n         #inputMonthPickerTarget>\n        <input class=\"input-monthpicker-input\"\n               #inputMonthPicker\n               autocomplete=\"off\"\n               [attr.id]=\"id\"\n               [attr.aria-label]=\"ariaLabel\"\n               [name]=\"name\"\n               type=\"text\"\n               [required]=\"required\"\n               [placeholder]=\"placeholder\"\n               [readonly]=\"true\"\n               [disabled]=\"disabled\"\n               [(ngModel)]=\"inputFieldValue\"\n               (keydown)=\"onInputKeydown($event)\"\n               (focus)=\"onInputFocus($event)\"\n               (blur)=\"onInputBlur($event);\"\n               (click)=\"onInputClick($event)\"\n               (keyup)=\"onInputKeyup($event)\" />\n\n        <div class=\"input-monthpicker-suffix\">\n            <button ariaLabel=\"Exibir calend\u00E1rio\"\n                    class=\"input-monthpicker-button\"\n                    [disabled]=\"disabled\"\n                    (click)=\"onButtonShowMonthpicker()\">\n                <svg class=\"input-monthpicker-icon\"\n                     viewBox=\"0 0 24 24\"\n                     width=\"24px\"\n                     height=\"24px\"\n                     fill=\"currentColor\"\n                     focusable=\"false\">\n                    <path\n                          d=\"M19 3h-1V1h-2v2H8V1H6v2H5c-1.11 0-1.99.9-1.99 2L3 19c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16H5V8h14v11zM7 10h5v5H7z\" />\n                </svg>\n            </button>\n        </div>\n    </div>\n</label>\n\n<gipi-overlay *ngIf=\"!disabled && !loading\"\n              [(visible)]=\"_overlayVisible\"\n              [appendTo]=\"'body'\">\n    <div class=\"calendar\">\n        <div class=\"calendar-header\">\n            <div class=\"calendar-title\"\n                 [class.month]=\"internalCalendarView === 'month'\"\n                 (click)=\"clickToggleCalendar()\">\n                <ng-container *ngIf=\"internalCalendarView === 'month'\">\n                    {{ value ? value.getFullYear() : _currentYear }}\n                </ng-container>\n\n                <ng-container *ngIf=\"internalCalendarView === 'year'\">\n                    {{ yearArrays[0] + ' - ' + yearArrays[yearArrays.length - 1] }}\n                </ng-container>\n\n                <mat-icon *ngIf=\"internalCalendarView === 'month'\">arrow_drop_down</mat-icon>\n            </div>\n            <div class=\"calendar-controls\">\n                <button aria-label=\"Voltar a data\"\n                        (click)=\"clickPrev()\">\n                    <mat-icon>navigate_before</mat-icon>\n                </button>\n                <button aria-label=\"Avan\u00E7ar a data\"\n                        (click)=\"clickNext()\">\n                    <mat-icon>navigate_next</mat-icon>\n                </button>\n            </div>\n        </div>\n\n        <div class=\"table-months\"\n             *ngIf=\"internalCalendarView === 'month'\">\n            <div *ngFor=\"let month of monthArrays\"\n                 class=\"month\"\n                 [class.selected]=\"isMonthSelected(month)\"\n                 [class.disabled]=\"isMonthDisabled(month)\"\n                 (click)=\"monthChanged(month)\">\n                {{ monthNames[month] }}\n            </div>\n        </div>\n\n        <div class=\"table-years\"\n             *ngIf=\"internalCalendarView === 'year'\">\n            <div *ngFor=\"let year of yearArrays\"\n                 class=\"year\"\n                 [class.selected]=\"isYearSelected(year)\"\n                 [class.disabled]=\"isYearDisabled(year)\"\n                 (click)=\"yearChanged(year)\">\n                {{ year }}\n            </div>\n        </div>\n    </div>\n</gipi-overlay>",
+            providers: [
+                {
+                    provide: NG_VALUE_ACCESSOR,
+                    useExisting: forwardRef(function () { return GIPIInputMonthPickerComponent_1; }),
+                    multi: true
+                }
+            ],
+            host: {
+                'class': 'gipi-input-monthpicker',
+            },
+            changeDetection: ChangeDetectionStrategy.OnPush,
+            styles: [".input-monthpicker-container{display:flex;flex-direction:column;gap:12px;width:100%}.input-monthpicker-container .input-monthpicker-label{color:#131313;font-size:1.4rem;line-height:100%}.input-monthpicker-container .input-monthpicker-label>span{color:#d14014;font-size:inherit;line-height:inherit}.input-monthpicker-container .input-monthpicker-content{display:flex;flex-direction:row;align-items:center;justify-content:space-between;padding:12px;width:100%;max-height:4rem;border-radius:5px;cursor:text;background-color:#fff;border:1px solid rgba(0,0,0,.12);color:#696969;caret-color:#9a9da2;transition:.2s;position:relative}.input-monthpicker-container .input-monthpicker-content:focus-within,.input-monthpicker-container .input-monthpicker-content:has(.input-monthpicker-input:active),.input-monthpicker-container .input-monthpicker-content:has(.input-monthpicker-input:focus){box-shadow:0 0 0 .2rem #f0f0f0}.input-monthpicker-container .input-monthpicker-content:focus-within,.input-monthpicker-container .input-monthpicker-content:hover{border-color:#bfbfbf!important}.input-monthpicker-container .input-monthpicker-content:has(.input-monthpicker-input:disabled){border-color:#e0e1e2!important;color:#d1d2d4!important;box-shadow:none!important;cursor:not-allowed!important;caret-color:#d1d2d4!important;pointer-events:none!important}.input-monthpicker-container .input-monthpicker-content:has(.input-monthpicker-input:disabled) .input-monthpicker-input,.input-monthpicker-container .input-monthpicker-content:has(.input-monthpicker-input:disabled) .input-monthpicker-suffix .input-monthpicker-button{cursor:not-allowed!important;pointer-events:none!important}.input-monthpicker-container .input-monthpicker-content:has(.input-monthpicker-input:disabled) .input-monthpicker-suffix .input-monthpicker-trigger{border-color:#e0e1e2!important;pointer-events:none!important}.input-monthpicker-container .input-monthpicker-content:has(.input-monthpicker-input:disabled) mat-icon{color:#d1d2d4!important;fill:#d1d2d4!important;cursor:not-allowed!important;pointer-events:none!important}.input-monthpicker-container .input-monthpicker-content .input-monthpicker-input{height:16px;max-width:84%;outline:0;border:none;background-color:transparent;color:inherit;flex:1}.input-monthpicker-container .input-monthpicker-content .input-monthpicker-suffix{display:flex;flex-direction:row;align-items:center;gap:16px}.input-monthpicker-container .input-monthpicker-content .input-monthpicker-suffix .input-monthpicker-button{display:flex;align-items:center;justify-content:center;outline:0;border:none;cursor:pointer;background-color:transparent}.input-monthpicker-container .input-monthpicker-content .input-monthpicker-suffix .input-monthpicker-button:hover:not(:disabled)>mat-icon{transform:scale(1.08)}.input-monthpicker-icon{width:1.6rem;height:1.6rem;font-size:1.6rem;color:#131313;fill:#131313}::ng-deep .calendar{width:100%;display:flex;flex-direction:column}::ng-deep .calendar .calendar-header{display:flex;flex-direction:row;align-items:center;justify-content:space-between;gap:10px;padding-bottom:10px;border-bottom:1px solid #aeb1b5;margin-bottom:8px}::ng-deep .calendar .calendar-header .calendar-title{display:flex;flex-direction:row;align-items:center;gap:8px;font-size:1.6rem;line-height:1.8rem;font-weight:600;cursor:default;border-radius:8px;padding:8px;white-space:nowrap}::ng-deep .calendar .calendar-header .calendar-title>mat-icon{font-size:2rem;width:20px;height:20px}::ng-deep .calendar .calendar-header .calendar-title.month:hover{cursor:pointer;background-color:#f0f0f0}::ng-deep .calendar .calendar-header .calendar-controls{display:flex;flex-direction:row;align-items:center;gap:8px}::ng-deep .calendar .calendar-header .calendar-controls>button{display:flex;align-items:center;justify-content:center;padding:8px;border-radius:8px;background-color:#e0313e;cursor:pointer;transition:.3s;border:0;outline:0;color:#fff}::ng-deep .calendar .calendar-header .calendar-controls>button:hover{background-color:#cc2d38}::ng-deep .calendar .calendar-header .calendar-controls>button>mat-icon{font-size:1.8rem;width:18px;height:18px}::ng-deep .calendar .table-months{display:-ms-grid;display:grid;-ms-grid-columns:(1fr)[3];grid-template-columns:repeat(3,1fr);gap:4px}::ng-deep .calendar .table-months .month{display:flex;align-items:center;justify-content:center;padding:8px;border-radius:8px;font-size:1.4rem;line-height:1.7rem;color:#555659;background-color:#f0f0f0;transition:background-color .1s;cursor:pointer}::ng-deep .calendar .table-months .month.disabled{color:#bbbdc1;background-color:#e0e1e2}::ng-deep .calendar .table-months .month:not(.disabled).selected,::ng-deep .calendar .table-months .month:not(.disabled):hover{color:#fff;background-color:#e0313e}::ng-deep .calendar .table-months .month:not(.disabled).selected:hover{background-color:#cc2d38}::ng-deep .calendar .table-years{display:-ms-grid;display:grid;-ms-grid-columns:(1fr)[4];grid-template-columns:repeat(4,1fr);gap:4px}::ng-deep .calendar .table-years .year{display:flex;align-items:center;justify-content:center;padding:8px;border-radius:8px;font-size:1.4rem;line-height:1.7rem;color:#555659;background-color:#f0f0f0;transition:background-color .1s;cursor:pointer}::ng-deep .calendar .table-years .year.disabled{color:#bbbdc1;background-color:#e0e1e2}::ng-deep .calendar .table-years .year:not(.disabled).selected,::ng-deep .calendar .table-years .year:not(.disabled):hover{color:#fff;background-color:#e0313e}::ng-deep .calendar .table-years .year:not(.disabled).selected:hover{background-color:#cc2d38}"]
+        }),
+        __metadata("design:paramtypes", [ChangeDetectorRef,
+            GIPINgConfig])
+    ], GIPIInputMonthPickerComponent);
+    return GIPIInputMonthPickerComponent;
+}());
+export { GIPIInputMonthPickerComponent };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"input-monthpicker.component.js","sourceRoot":"ng://@gipisistemas/ng-core/","sources":["shared/gipi-components/input-monthpicker/input-monthpicker.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectionStrategy, ChangeDetectorRef, Component, EventEmitter, forwardRef, Input, OnInit, Output, ViewChild } from '@angular/core';\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';\n\nimport { ObjectUtil } from '../../../core/utils/object.util';\nimport { GIPINgConfig } from '../../api/gipi-ng-config';\n\nconst yearsPerPage = 24;\n\nlet nextUniqueId = 0;\n\n@Component({\n    selector: `gipi-input-monthpicker`,\n    exportAs: 'gipiInputMonthPicker',\n    templateUrl: './input-monthpicker.component.html',\n    styleUrls: ['./input-monthpicker.component.scss'],\n    providers: [\n        {\n            provide: NG_VALUE_ACCESSOR,\n            useExisting: forwardRef((): typeof GIPIInputMonthPickerComponent => GIPIInputMonthPickerComponent),\n            multi: true\n        }\n    ],\n    host: {\n        'class': 'gipi-input-monthpicker',\n    },\n    changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class GIPIInputMonthPickerComponent implements OnInit, ControlValueAccessor {\n\n    private _name: string = `gipi-input-monthpicker-${nextUniqueId++}`;\n\n    private _initialYear: number;\n    set initialYear(value: number) {\n        if (value > 1900) {\n            this._initialYear = value;\n        }\n    }\n    get initialYear(): number {\n        return this._initialYear;\n    }\n\n    private _yearArrays: number[] = [];\n    set yearArrays(value: number[]) {\n        this._yearArrays = value;\n    }\n    get yearArrays(): number[] {\n        return this._yearArrays;\n    }\n\n    _now: Date = new Date();\n    _currentMonth: number = this._now.getMonth();\n    _currentYear: number = this._now.getFullYear();\n\n    _overlayVisible: boolean = false;\n\n    monthArrays: number[] = Array.from(Array(12).keys());\n\n    monthNames: string[] = ['Jan', 'Fev', 'Mar', 'Abr', 'Mai', 'Jun', 'Jul', 'Ago', 'Set', 'Out', 'Nov', 'Dez'];\n\n    internalCalendarView: 'month' | 'year' = 'month';\n\n    inputFieldValue: string;\n\n    @Input() id: string | number = this._name;\n\n    @Input() name: string = this._name;\n\n    @Input() ariaLabel: string = '';\n\n    @Input() label: string = '';\n\n    @Input() placeholder: string = '';\n\n    @Input() disabled: boolean = false;\n\n    @Input() loading: boolean = false;\n\n    @Input() required: boolean = false;\n\n    @Input() showOnFocus: boolean = true;\n\n    @Input() minDate: Date;\n\n    @Input() maxDate: Date;\n\n    private _calendarView: 'month' | 'year' = 'month';\n    @Input() set calendarView(value: 'month' | 'year') {\n        this._calendarView = value;\n\n        if (!ObjectUtil.isNull(this.value)) {\n            if (value === 'month') {\n                this.monthChanged(this.value.getMonth());\n            } else if (value === 'year') {\n                this.yearChanged(this.value.getFullYear());\n            }\n\n            this.internalCalendarView = value;\n            this._changeDetectorRef.markForCheck();\n        }\n    }\n    get calendarView(): 'month' | 'year' {\n        return this._calendarView;\n    }\n\n    private _value: Date;\n    @Input() set value(value: Date) {\n        this._value = value;\n\n        if (value) {\n            value.setDate(1);\n            this._value = value;\n\n            if (this.calendarView === 'month') {\n                const month: number = this.value.getMonth() + 1;\n                this.inputFieldValue = `${((month <= 9) ? ('0' + month) : month)}/${this.value.getFullYear()}`;\n            } else if (this.calendarView === 'year') {\n                this.inputFieldValue = `${this.value.getFullYear()}`;\n            }\n        }\n\n        this.onChange(value);\n        this._changeDetectorRef.markForCheck();\n    }\n    get value(): Date {\n        return this._value;\n    }\n\n    @Output() onClose: EventEmitter<Event> = new EventEmitter<Event>();\n    @Output() onMonthChange: EventEmitter<string> = new EventEmitter<string>();\n    @Output() onYearChange: EventEmitter<string> = new EventEmitter<string>();\n    @Output() onKeydown: EventEmitter<KeyboardEvent> = new EventEmitter<KeyboardEvent>();\n    @Output() onKeydownEnter: EventEmitter<KeyboardEvent> = new EventEmitter<KeyboardEvent>();\n    @Output() onFocus: EventEmitter<Event> = new EventEmitter<Event>();\n    @Output() onBlur: EventEmitter<Event> = new EventEmitter<Event>();\n    @Output() onClick: EventEmitter<Event> = new EventEmitter<Event>();\n\n    @ViewChild('inputMonthPicker', { static: true, read: HTMLInputElement }) inputMonthPickerRef: HTMLInputElement;\n\n    constructor(\n        private _changeDetectorRef: ChangeDetectorRef,\n        private _config: GIPINgConfig,\n    ) { }\n\n    ngOnInit(): void {\n        this._generateYears();\n    }\n\n    onChange: any = () => { };\n\n    onTouch: any = () => { };\n\n    registerOnChange(fn: any): void {\n        this.onChange = fn;\n    }\n\n    registerOnTouched(fn: any): void {\n        this.onTouch = fn;\n    }\n\n    writeValue(value: any): void {\n        this.value = value;\n    }\n\n    setDisabledState(val: boolean): void {\n        this.disabled = val;\n        this._changeDetectorRef.markForCheck();\n    }\n\n    private _generateYears(): void {\n        const realCurrentYear: number = this._now.getFullYear();\n\n        if (!this.initialYear) {\n            this.initialYear = this.value ? this.value.getFullYear() : this._now.getFullYear();\n        }\n\n        this.yearArrays = [];\n        if (this.initialYear === realCurrentYear) {\n            let baseYear = this.initialYear - (this.initialYear % (yearsPerPage / 2));\n            for (let y = 0; y < yearsPerPage; y++) {\n                this.yearArrays.push((baseYear + y));\n            }\n        } else {\n            for (let y = this.initialYear; y < (this.initialYear + yearsPerPage); y++) {\n                this.yearArrays.push(y);\n            }\n        }\n    }\n\n    public clickToggleCalendar(currentView?: 'month' | 'year') {\n        if (currentView) {\n            this.internalCalendarView = currentView;\n        } else {\n            if (this.internalCalendarView === 'month') {\n                this.internalCalendarView = 'year';\n            }\n        }\n        this._changeDetectorRef.detectChanges();\n    }\n\n    public clickPrev() {\n        if (this.internalCalendarView === 'month') {\n            this.value = new Date(this.value.getFullYear() - 1, this.value.getMonth(), 1);\n            this.initialYear = (this.value.getFullYear() - 7);\n        } else if (this.internalCalendarView === 'year') {\n            this.initialYear = this.yearArrays[0] - (yearsPerPage - 1);\n        }\n        this._generateYears();\n        this._changeDetectorRef.detectChanges();\n    }\n\n    public clickNext() {\n        if (this.internalCalendarView === 'month') {\n            this.value = new Date(this.value.getFullYear() + 1, this.value.getMonth(), 1);\n            this.initialYear = ((this.value.getFullYear() - 7) + 1);\n        } else if (this.internalCalendarView === 'year') {\n            this.initialYear = this.yearArrays[yearsPerPage - 1];\n        }\n        this._generateYears();\n        this._changeDetectorRef.detectChanges();\n    }\n\n    /**\n     * Chamado quando o mês é alterado\n     * @param month mês selecionado no calendário de meses\n     */\n    public monthChanged(month: number) {\n        const year: number = this.value.getFullYear();\n        this._monthOrYearChanged(month, year);\n        this._hideOverlay();\n    }\n\n    /**\n     * Chamado quando o ano é alterado\n     * @param year ano selecionado no calendário de anos\n     */\n    public yearChanged(year: number) {\n        const month: number = this.value.getMonth();\n        this._monthOrYearChanged(month, year);\n\n        if (this.calendarView === 'month') {\n            this.clickToggleCalendar('month');\n        } else if (this.calendarView === 'year') {\n            this._hideOverlay();\n        }\n    }\n\n    /**\n     *  Chamar quando mês ou ano mudou\n     * @param month número do mês 0-11\n     * @param year ano exemplo: 1995\n     */\n    private _monthOrYearChanged(month: number, year: number) {\n        let newMonth: number = month;\n        let newYear: number = year;\n\n        if (this.minDate) {\n            if (newYear < this.minDate.getFullYear() || (newYear === this.minDate.getFullYear() && newMonth < this.minDate.getMonth())) {\n                newMonth = this.minDate.getMonth();\n                newYear = this.minDate.getFullYear();\n            }\n        }\n\n        if (this.maxDate) {\n            if (newYear > this.maxDate.getFullYear() || (newYear === this.maxDate.getFullYear() && newMonth > this.maxDate.getMonth())) {\n                newMonth = this.maxDate.getMonth();\n                newYear = this.maxDate.getFullYear();\n            }\n        }\n\n        this.value = new Date(newYear, newMonth, 1);\n\n        this._changeDetectorRef.detectChanges();\n    }\n\n    public isMonthSelected(month: number): boolean {\n        if (this.value) {\n            return this.value.getMonth() === month;\n        }\n\n        return false;\n    }\n\n    public isMonthDisabled(month: number): boolean {\n        if (this.value && this.minDate && this.maxDate) {\n            return (this.value.getFullYear() === this.minDate.getFullYear() && month < this.minDate.getMonth())\n                || (this.value.getFullYear() === this.maxDate.getFullYear() && month > this.maxDate.getMonth());\n        }\n        return false;\n    }\n\n    public isYearSelected(year: number): boolean {\n        if (this.value) {\n            return this.value.getFullYear() === year;\n        }\n\n        return false;\n    }\n\n    public isYearDisabled(year: number): boolean {\n        if (this.value && this.minDate && this.maxDate) {\n            return (this.value.getFullYear() === this.minDate.getFullYear() && year < this.minDate.getFullYear())\n                || (this.value.getFullYear() === this.maxDate.getFullYear() && year > this.maxDate.getFullYear());\n        }\n        return false;\n    }\n\n    public onInputKeydown(event: KeyboardEvent): void {\n        if (!this.disabled) {\n            if (event.key.toUpperCase() === 'ENTER') {\n                this.onKeydownEnter.emit(event);\n            }\n            this.onKeydown.emit(event);\n        }\n    }\n\n    public onInputKeyup(event: KeyboardEvent): void {\n        if (!this.disabled) {\n            if ((event.key.toUpperCase() === 'ESC') || (event.key.toUpperCase() === 'ESCAPE')) {\n                this._hideOverlay();\n            }\n            this.onKeydown.emit(event);\n        }\n    }\n\n    public onInputFocus(event: Event): void {\n        if (!this.disabled && this.showOnFocus) {\n            this._showOverlay();\n            this.onFocus.emit(event);\n        }\n    }\n\n    public onInputBlur(event: Event): void {\n        if (!this.disabled) {\n            this.onBlur.emit(event);\n            this.onTouch();\n        }\n    }\n\n    public onInputClick(event: Event): void {\n        if (!this.disabled) {\n            this._showOverlay();\n            this.onClick.emit(event);\n        }\n    }\n\n    public onButtonShowMonthpicker(): void {\n        this.toogleOverlay();\n        this._changeDetectorRef.markForCheck();\n    }\n\n    private _showOverlay(): void {\n        if (!this._overlayVisible) {\n            this._overlayVisible = true;\n        }\n    }\n\n    private _hideOverlay(): void {\n        this._overlayVisible = false;\n        this._changeDetectorRef.markForCheck();\n    }\n\n    public toogleOverlay(): void {\n        if (this.disabled || this.loading) {\n            return;\n        } else {\n            if (!this._overlayVisible) {\n                this._showOverlay();\n            } else {\n                this._hideOverlay();\n            }\n        }\n    }\n\n}\n"]}