@gipisistemas/ng-core 1.1.0 → 1.1.1

package/esm5/shared/gipi-components/datepicker/mat-datepicker/year-view.js

@@ -0,0 +1,313 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { __decorate, __metadata, __param } from "tslib";
+import { Directionality } from '@angular/cdk/bidi';
+import { DOWN_ARROW, END, ENTER, HOME, LEFT_ARROW, PAGE_DOWN, PAGE_UP, RIGHT_ARROW, SPACE, UP_ARROW, } from '@angular/cdk/keycodes';
+import { AfterContentInit, ChangeDetectionStrategy, ChangeDetectorRef, Component, EventEmitter, Inject, Input, OnDestroy, Optional, Output, ViewChild, ViewEncapsulation, } from '@angular/core';
+import { MAT_DATE_FORMATS } from '@angular/material/core';
+import { Subscription } from 'rxjs';
+import { startWith } from 'rxjs/operators';
+import { MatCalendarBody, MatCalendarCell, } from './calendar-body';
+import { DateRange } from './date-selection-model';
+import { createMissingDateImplError } from './datepicker-errors';
+import { DateAdapter } from './shared/adapter/date-adapter';
+/**
+ * An internal component used to display a single year in the datepicker.
+ * @docs-private
+ */
+var MatYearView = /** @class */ (function () {
+    function MatYearView(_changeDetectorRef, _dateFormats, _dateAdapter, _dir) {
+        this._changeDetectorRef = _changeDetectorRef;
+        this._dateFormats = _dateFormats;
+        this._dateAdapter = _dateAdapter;
+        this._dir = _dir;
+        this._rerenderSubscription = Subscription.EMPTY;
+        /** Emits when a new month is selected. */
+        this.selectedChange = new EventEmitter();
+        /** Emits the selected month. This doesn't imply a change on the selected date */
+        this.monthSelected = new EventEmitter();
+        /** Emits when any date is activated. */
+        this.activeDateChange = new EventEmitter();
+        if (!this._dateAdapter) {
+            throw createMissingDateImplError('DateAdapter');
+        }
+        if (!this._dateFormats) {
+            throw createMissingDateImplError('MAT_DATE_FORMATS');
+        }
+        this._activeDate = this._dateAdapter.today();
+    }
+    Object.defineProperty(MatYearView.prototype, "activeDate", {
+        /** The date to display in this year view (everything other than the year is ignored). */
+        get: function () { return this._activeDate; },
+        set: function (value) {
+            var oldActiveDate = this._activeDate;
+            var validDate = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value)) || this._dateAdapter.today();
+            this._activeDate = this._dateAdapter.clampDate(validDate, this.minDate, this.maxDate);
+            if (this._dateAdapter.getYear(oldActiveDate) !== this._dateAdapter.getYear(this._activeDate)) {
+                this._init();
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(MatYearView.prototype, "selected", {
+        /** The currently selected date. */
+        get: function () { return this._selected; },
+        set: function (value) {
+            if (value instanceof DateRange) {
+                this._selected = value;
+            }
+            else {
+                this._selected = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));
+            }
+            this._setSelectedMonth(value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(MatYearView.prototype, "minDate", {
+        /** The minimum selectable date. */
+        get: function () { return this._minDate; },
+        set: function (value) {
+            this._minDate = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(MatYearView.prototype, "maxDate", {
+        /** The maximum selectable date. */
+        get: function () { return this._maxDate; },
+        set: function (value) {
+            this._maxDate = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));
+        },
+        enumerable: false,
+        configurable: true
+    });
+    MatYearView.prototype.ngAfterContentInit = function () {
+        var _this = this;
+        this._rerenderSubscription = this._dateAdapter.localeChanges
+            .pipe(startWith(null))
+            .subscribe(function () { return _this._init(); });
+    };
+    MatYearView.prototype.ngOnDestroy = function () {
+        this._rerenderSubscription.unsubscribe();
+    };
+    /** Handles when a new month is selected. */
+    MatYearView.prototype._monthSelected = function (event) {
+        var month = event.value;
+        var normalizedDate = this._dateAdapter.createDate(this._dateAdapter.getYear(this.activeDate), month, 1);
+        this.monthSelected.emit(normalizedDate);
+        var daysInMonth = this._dateAdapter.getNumDaysInMonth(normalizedDate);
+        this.selectedChange.emit(this._dateAdapter.createDate(this._dateAdapter.getYear(this.activeDate), month, Math.min(this._dateAdapter.getDate(this.activeDate), daysInMonth)));
+    };
+    /** Handles keydown events on the calendar body when calendar is in year view. */
+    MatYearView.prototype._handleCalendarBodyKeydown = function (event) {
+        // TODO(mmalerba): We currently allow keyboard navigation to disabled dates, but just prevent
+        // disabled ones from being selected. This may not be ideal, we should look into whether
+        // navigation should skip over disabled dates, and if so, how to implement that efficiently.
+        var oldActiveDate = this._activeDate;
+        var isRtl = this._isRtl();
+        switch (event.keyCode) {
+            case LEFT_ARROW:
+                this.activeDate = this._dateAdapter.addCalendarMonths(this._activeDate, isRtl ? 1 : -1);
+                break;
+            case RIGHT_ARROW:
+                this.activeDate = this._dateAdapter.addCalendarMonths(this._activeDate, isRtl ? -1 : 1);
+                break;
+            case UP_ARROW:
+                this.activeDate = this._dateAdapter.addCalendarMonths(this._activeDate, -4);
+                break;
+            case DOWN_ARROW:
+                this.activeDate = this._dateAdapter.addCalendarMonths(this._activeDate, 4);
+                break;
+            case HOME:
+                this.activeDate = this._dateAdapter.addCalendarMonths(this._activeDate, -this._dateAdapter.getMonth(this._activeDate));
+                break;
+            case END:
+                this.activeDate = this._dateAdapter.addCalendarMonths(this._activeDate, 11 - this._dateAdapter.getMonth(this._activeDate));
+                break;
+            case PAGE_UP:
+                this.activeDate =
+                    this._dateAdapter.addCalendarYears(this._activeDate, event.altKey ? -10 : -1);
+                break;
+            case PAGE_DOWN:
+                this.activeDate =
+                    this._dateAdapter.addCalendarYears(this._activeDate, event.altKey ? 10 : 1);
+                break;
+            case ENTER:
+            case SPACE:
+                this._monthSelected({ value: this._dateAdapter.getMonth(this._activeDate), event: event });
+                break;
+            default:
+                // Don't prevent default or focus active cell on keys that we don't explicitly handle.
+                return;
+        }
+        if (this._dateAdapter.compareDate(oldActiveDate, this.activeDate)) {
+            this.activeDateChange.emit(this.activeDate);
+        }
+        this._focusActiveCell();
+        // Prevent unexpected default actions such as form submission.
+        event.preventDefault();
+    };
+    /** Initializes this year view. */
+    MatYearView.prototype._init = function () {
+        var _this = this;
+        this._setSelectedMonth(this.selected);
+        this._todayMonth = this._getMonthInCurrentYear(this._dateAdapter.today());
+        this._yearLabel = this._dateAdapter.getYearName(this.activeDate);
+        var monthNames = this._dateAdapter.getMonthNames('short');
+        // First row of months only contains 5 elements so we can fit the year label on the same row.
+        this._months = [[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11]].map(function (row) { return row.map(function (month) { return _this._createCellForMonth(month, monthNames[month]); }); });
+        this._changeDetectorRef.markForCheck();
+    };
+    /** Focuses the active cell after the microtask queue is empty. */
+    MatYearView.prototype._focusActiveCell = function () {
+        this._matCalendarBody._focusActiveCell();
+    };
+    /**
+     * Gets the month in this year that the given Date falls on.
+     * Returns null if the given Date is in another year.
+     */
+    MatYearView.prototype._getMonthInCurrentYear = function (date) {
+        return date && this._dateAdapter.getYear(date) == this._dateAdapter.getYear(this.activeDate) ?
+            this._dateAdapter.getMonth(date) : null;
+    };
+    /** Creates an MatCalendarCell for the given month. */
+    MatYearView.prototype._createCellForMonth = function (month, monthName) {
+        var date = this._dateAdapter.createDate(this._dateAdapter.getYear(this.activeDate), month, 1);
+        var ariaLabel = this._dateAdapter.format(date, this._dateFormats.display.monthYearA11yLabel);
+        var cellClasses = this.dateClass ? this.dateClass(date, 'year') : undefined;
+        return new MatCalendarCell(month, monthName.toLocaleUpperCase(), ariaLabel, this._shouldEnableMonth(month), cellClasses);
+    };
+    /** Whether the given month is enabled. */
+    MatYearView.prototype._shouldEnableMonth = function (month) {
+        var activeYear = this._dateAdapter.getYear(this.activeDate);
+        if (month === undefined ||
+            month === null ||
+            this._isYearAndMonthAfterMaxDate(activeYear, month) ||
+            this._isYearAndMonthBeforeMinDate(activeYear, month)) {
+            return false;
+        }
+        if (!this.dateFilter) {
+            return true;
+        }
+        var firstOfMonth = this._dateAdapter.createDate(activeYear, month, 1);
+        // If any date in the month is enabled count the month as enabled.
+        for (var date = firstOfMonth; this._dateAdapter.getMonth(date) == month; date = this._dateAdapter.addCalendarDays(date, 1)) {
+            if (this.dateFilter(date)) {
+                return true;
+            }
+        }
+        return false;
+    };
+    /**
+     * Tests whether the combination month/year is after this.maxDate, considering
+     * just the month and year of this.maxDate
+     */
+    MatYearView.prototype._isYearAndMonthAfterMaxDate = function (year, month) {
+        if (this.maxDate) {
+            var maxYear = this._dateAdapter.getYear(this.maxDate);
+            var maxMonth = this._dateAdapter.getMonth(this.maxDate);
+            return year > maxYear || (year === maxYear && month > maxMonth);
+        }
+        return false;
+    };
+    /**
+     * Tests whether the combination month/year is before this.minDate, considering
+     * just the month and year of this.minDate
+     */
+    MatYearView.prototype._isYearAndMonthBeforeMinDate = function (year, month) {
+        if (this.minDate) {
+            var minYear = this._dateAdapter.getYear(this.minDate);
+            var minMonth = this._dateAdapter.getMonth(this.minDate);
+            return year < minYear || (year === minYear && month < minMonth);
+        }
+        return false;
+    };
+    /** Determines whether the user has the RTL layout direction. */
+    MatYearView.prototype._isRtl = function () {
+        return this._dir && this._dir.value === 'rtl';
+    };
+    /** Sets the currently-selected month based on a model value. */
+    MatYearView.prototype._setSelectedMonth = function (value) {
+        if (value instanceof DateRange) {
+            this._selectedMonth = this._getMonthInCurrentYear(value.start) ||
+                this._getMonthInCurrentYear(value.end);
+        }
+        else {
+            this._selectedMonth = this._getMonthInCurrentYear(value);
+        }
+    };
+    MatYearView.ctorParameters = function () { return [
+        { type: ChangeDetectorRef },
+        { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [MAT_DATE_FORMATS,] }] },
+        { type: DateAdapter, decorators: [{ type: Optional }] },
+        { type: Directionality, decorators: [{ type: Optional }] }
+    ]; };
+    __decorate([
+        Input(),
+        __metadata("design:type", Object),
+        __metadata("design:paramtypes", [Object])
+    ], MatYearView.prototype, "activeDate", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", Object),
+        __metadata("design:paramtypes", [Object])
+    ], MatYearView.prototype, "selected", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", Object),
+        __metadata("design:paramtypes", [Object])
+    ], MatYearView.prototype, "minDate", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", Object),
+        __metadata("design:paramtypes", [Object])
+    ], MatYearView.prototype, "maxDate", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", Function)
+    ], MatYearView.prototype, "dateFilter", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Function)
+    ], MatYearView.prototype, "dateClass", void 0);
+    __decorate([
+        Output(),
+        __metadata("design:type", EventEmitter)
+    ], MatYearView.prototype, "selectedChange", void 0);
+    __decorate([
+        Output(),
+        __metadata("design:type", EventEmitter)
+    ], MatYearView.prototype, "monthSelected", void 0);
+    __decorate([
+        Output(),
+        __metadata("design:type", EventEmitter)
+    ], MatYearView.prototype, "activeDateChange", void 0);
+    __decorate([
+        ViewChild(MatCalendarBody, { static: true }),
+        __metadata("design:type", MatCalendarBody)
+    ], MatYearView.prototype, "_matCalendarBody", void 0);
+    MatYearView = __decorate([
+        Component({
+            selector: 'gipi-mat-year-view',
+            template: "<table class=\"mat-calendar-table\"\n       role=\"presentation\">\n    <thead class=\"mat-calendar-table-header\">\n        <tr>\n            <th class=\"mat-calendar-table-header-divider\"\n                colspan=\"4\">\n            </th>\n        </tr>\n    </thead>\n    <tbody gipi-mat-calendar-body\n           [label]=\"_yearLabel\"\n           [rows]=\"_months\"\n           [todayValue]=\"_todayMonth!\"\n           [startValue]=\"_selectedMonth!\"\n           [endValue]=\"_selectedMonth!\"\n           [labelMinRequiredCells]=\"2\"\n           [numCols]=\"4\"\n           [cellAspectRatio]=\"4 / 7\"\n           [activeCell]=\"_dateAdapter.getMonth(activeDate)\"\n           (selectedValueChange)=\"_monthSelected($event)\"\n           (keydown)=\"_handleCalendarBodyKeydown($event)\">\n    </tbody>\n</table>",
+            exportAs: 'gipiMatYearView',
+            encapsulation: ViewEncapsulation.None,
+            changeDetection: ChangeDetectionStrategy.OnPush
+        }),
+        __param(1, Optional()), __param(1, Inject(MAT_DATE_FORMATS)),
+        __param(2, Optional()),
+        __param(3, Optional()),
+        __metadata("design:paramtypes", [ChangeDetectorRef, Object, DateAdapter,
+            Directionality])
+    ], MatYearView);
+    return MatYearView;
+}());
+export { MatYearView };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"year-view.js","sourceRoot":"ng://@gipisistemas/ng-core/","sources":["shared/gipi-components/datepicker/mat-datepicker/year-view.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,UAAU,EAAE,GAAG,EAAE,KAAK,EAAE,IAAI,EAAE,UAAU,EAAE,SAAS,EAAE,OAAO,EAAE,WAAW,EAAE,KAAK,EAAE,QAAQ,GAAG,MAAM,uBAAuB,CAAC;AACpI,OAAO,EAAE,gBAAgB,EAAE,uBAAuB,EAAE,iBAAiB,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,iBAAiB,GAAG,MAAM,eAAe,CAAC;AACjM,OAAO,EAAE,gBAAgB,EAAkB,MAAM,wBAAwB,CAAC;AAC1E,OAAO,EAAE,YAAY,EAAE,MAAM,MAAM,CAAC;AACpC,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,eAAe,EAAE,eAAe,GAAuD,MAAM,iBAAiB,CAAC;AACxH,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AACnD,OAAO,EAAE,0BAA0B,EAAE,MAAM,qBAAqB,CAAC;AACjE,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAE5D;;;GAGG;AAQH;IAkFI,qBACY,kBAAqC,EACC,YAA4B,EACvD,YAA4B,EAC3B,IAAqB;QAHjC,uBAAkB,GAAlB,kBAAkB,CAAmB;QACC,iBAAY,GAAZ,YAAY,CAAgB;QACvD,iBAAY,GAAZ,YAAY,CAAgB;QAC3B,SAAI,GAAJ,IAAI,CAAiB;QArFrC,0BAAqB,GAAG,YAAY,CAAC,KAAK,CAAC;QAsDnD,0CAA0C;QACvB,mBAAc,GAAoB,IAAI,YAAY,EAAK,CAAC;QAE3E,iFAAiF;QAC9D,kBAAa,GAAoB,IAAI,YAAY,EAAK,CAAC;QAE1E,wCAAwC;QACrB,qBAAgB,GAAoB,IAAI,YAAY,EAAK,CAAC;QA0BzE,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE;YACpB,MAAM,0BAA0B,CAAC,aAAa,CAAC,CAAC;SACnD;QACD,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE;YACpB,MAAM,0BAA0B,CAAC,kBAAkB,CAAC,CAAC;SACxD;QAED,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE,CAAC;IACjD,CAAC;IA3FD,sBAAI,mCAAU;QAFd,yFAAyF;aAEzF,cAAsB,OAAO,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC;aAChD,UAAe,KAAQ;YACnB,IAAI,aAAa,GAAG,IAAI,CAAC,WAAW,CAAC;YACrC,IAAM,SAAS,GACX,IAAI,CAAC,YAAY,CAAC,kBAAkB,CAChC,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC,KAAK,CAAC,CACvC,IAAI,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE,CAAC;YACnC,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC,SAAS,EAAE,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;YACtF,IAAI,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,aAAa,CAAC,KAAK,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE;gBAC1F,IAAI,CAAC,KAAK,EAAE,CAAC;aAChB;QACL,CAAC;;;OAX+C;IAgBhD,sBAAI,iCAAQ;QAFZ,mCAAmC;aAEnC,cAA0C,OAAO,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC;aAClE,UAAa,KAA8B;YACvC,IAAI,KAAK,YAAY,SAAS,EAAE;gBAC5B,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;aAC1B;iBAAM;gBACH,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,YAAY,CAAC,kBAAkB,CAAC,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC;aAC/F;YAED,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAC;QAClC,CAAC;;;OATiE;IAclE,sBAAI,gCAAO;QAFX,mCAAmC;aAEnC,cAA0B,OAAO,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC;aACjD,UAAY,KAAe;YACvB,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,YAAY,CAAC,kBAAkB,CAAC,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC;QAC/F,CAAC;;;OAHgD;IAQjD,sBAAI,gCAAO;QAFX,mCAAmC;aAEnC,cAA0B,OAAO,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC;aACjD,UAAY,KAAe;YACvB,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,YAAY,CAAC,kBAAkB,CAAC,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC;QAC/F,CAAC;;;OAHgD;IAuDjD,wCAAkB,GAAlB;QAAA,iBAIC;QAHG,IAAI,CAAC,qBAAqB,GAAG,IAAI,CAAC,YAAY,CAAC,aAAa;aACvD,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;aACrB,SAAS,CAAC,cAAM,OAAA,KAAI,CAAC,KAAK,EAAE,EAAZ,CAAY,CAAC,CAAC;IACvC,CAAC;IAED,iCAAW,GAAX;QACI,IAAI,CAAC,qBAAqB,CAAC,WAAW,EAAE,CAAC;IAC7C,CAAC;IAED,4CAA4C;IAC5C,oCAAc,GAAd,UAAe,KAAmC;QAC9C,IAAM,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC;QAC1B,IAAM,cAAc,GAChB,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC;QAEvF,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;QAExC,IAAM,WAAW,GAAG,IAAI,CAAC,YAAY,CAAC,iBAAiB,CAAC,cAAc,CAAC,CAAC;QAExE,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,UAAU,CACjD,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,KAAK,EACjD,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC;IAC5E,CAAC;IAED,iFAAiF;IACjF,gDAA0B,GAA1B,UAA2B,KAAoB;QAC3C,6FAA6F;QAC7F,wFAAwF;QACxF,4FAA4F;QAE5F,IAAM,aAAa,GAAG,IAAI,CAAC,WAAW,CAAC;QACvC,IAAM,KAAK,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC;QAE5B,QAAQ,KAAK,CAAC,OAAO,EAAE;YACnB,KAAK,UAAU;gBACX,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,YAAY,CAAC,iBAAiB,CAAC,IAAI,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;gBACxF,MAAM;YACV,KAAK,WAAW;gBACZ,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,YAAY,CAAC,iBAAiB,CAAC,IAAI,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;gBACxF,MAAM;YACV,KAAK,QAAQ;gBACT,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,YAAY,CAAC,iBAAiB,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,CAAC;gBAC5E,MAAM;YACV,KAAK,UAAU;gBACX,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,YAAY,CAAC,iBAAiB,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC;gBAC3E,MAAM;YACV,KAAK,IAAI;gBACL,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,YAAY,CAAC,iBAAiB,CAAC,IAAI,CAAC,WAAW,EAClE,CAAC,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC;gBACnD,MAAM;YACV,KAAK,GAAG;gBACJ,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,YAAY,CAAC,iBAAiB,CAAC,IAAI,CAAC,WAAW,EAClE,EAAE,GAAG,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC;gBACvD,MAAM;YACV,KAAK,OAAO;gBACR,IAAI,CAAC,UAAU;oBACX,IAAI,CAAC,YAAY,CAAC,gBAAgB,CAAC,IAAI,CAAC,WAAW,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;gBAClF,MAAM;YACV,KAAK,SAAS;gBACV,IAAI,CAAC,UAAU;oBACX,IAAI,CAAC,YAAY,CAAC,gBAAgB,CAAC,IAAI,CAAC,WAAW,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;gBAChF,MAAM;YACV,KAAK,KAAK,CAAC;YACX,KAAK,KAAK;gBACN,IAAI,CAAC,cAAc,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,KAAK,OAAA,EAAE,CAAC,CAAC;gBACpF,MAAM;YACV;gBACI,sFAAsF;gBACtF,OAAO;SACd;QAED,IAAI,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC,aAAa,EAAE,IAAI,CAAC,UAAU,CAAC,EAAE;YAC/D,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;SAC/C;QAED,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACxB,8DAA8D;QAC9D,KAAK,CAAC,cAAc,EAAE,CAAC;IAC3B,CAAC;IAED,kCAAkC;IAClC,2BAAK,GAAL;QAAA,iBASC;QARG,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QACtC,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE,CAAC,CAAC;QAC1E,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QAEjE,IAAI,UAAU,GAAG,IAAI,CAAC,YAAY,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;QAC1D,6FAA6F;QAC7F,IAAI,CAAC,OAAO,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,UAAA,GAAG,IAAI,OAAA,GAAG,CAAC,GAAG,CAAC,UAAA,KAAK,IAAI,OAAA,KAAI,CAAC,mBAAmB,CAAC,KAAK,EAAE,UAAU,CAAC,KAAK,CAAC,CAAC,EAAlD,CAAkD,CAAC,EAApE,CAAoE,CAAC,CAAC;QAC7I,IAAI,CAAC,kBAAkB,CAAC,YAAY,EAAE,CAAC;IAC3C,CAAC;IAED,kEAAkE;IAClE,sCAAgB,GAAhB;QACI,IAAI,CAAC,gBAAgB,CAAC,gBAAgB,EAAE,CAAC;IAC7C,CAAC;IAED;;;OAGG;IACK,4CAAsB,GAA9B,UAA+B,IAAc;QACzC,OAAO,IAAI,IAAI,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC;YAC1F,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IAChD,CAAC;IAED,sDAAsD;IAC9C,yCAAmB,GAA3B,UAA4B,KAAa,EAAE,SAAiB;QACxD,IAAM,IAAI,GAAG,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC;QAChG,IAAM,SAAS,GAAG,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,kBAAkB,CAAC,CAAC;QAC/F,IAAM,WAAW,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;QAE9E,OAAO,IAAI,eAAe,CAAC,KAAK,EAAE,SAAS,CAAC,iBAAiB,EAAE,EAAE,SAAS,EAAE,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC,EAAE,WAAW,CAAC,CAAC;IAC7H,CAAC;IAED,0CAA0C;IAClC,wCAAkB,GAA1B,UAA2B,KAAa;QACpC,IAAM,UAAU,GAAG,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QAE9D,IACI,KAAK,KAAK,SAAS;YACnB,KAAK,KAAK,IAAI;YACd,IAAI,CAAC,2BAA2B,CAAC,UAAU,EAAE,KAAK,CAAC;YACnD,IAAI,CAAC,4BAA4B,CAAC,UAAU,EAAE,KAAK,CAAC,EACtD;YACE,OAAO,KAAK,CAAC;SAChB;QAED,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE;YAClB,OAAO,IAAI,CAAC;SACf;QAED,IAAM,YAAY,GAAG,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,UAAU,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC;QAExE,kEAAkE;QAClE,KAAK,IAAI,IAAI,GAAG,YAAY,EAAE,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,KAAK,EACnE,IAAI,GAAG,IAAI,CAAC,YAAY,CAAC,eAAe,CAAC,IAAI,EAAE,CAAC,CAAC,EAAE;YACnD,IAAI,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE;gBACvB,OAAO,IAAI,CAAC;aACf;SACJ;QAED,OAAO,KAAK,CAAC;IACjB,CAAC;IAED;;;OAGG;IACK,iDAA2B,GAAnC,UAAoC,IAAY,EAAE,KAAa;QAC3D,IAAI,IAAI,CAAC,OAAO,EAAE;YACd,IAAM,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YACxD,IAAM,QAAQ,GAAG,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YAE1D,OAAO,IAAI,GAAG,OAAO,IAAI,CAAC,IAAI,KAAK,OAAO,IAAI,KAAK,GAAG,QAAQ,CAAC,CAAC;SACnE;QAED,OAAO,KAAK,CAAC;IACjB,CAAC;IAED;;;OAGG;IACK,kDAA4B,GAApC,UAAqC,IAAY,EAAE,KAAa;QAC5D,IAAI,IAAI,CAAC,OAAO,EAAE;YACd,IAAM,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YACxD,IAAM,QAAQ,GAAG,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YAE1D,OAAO,IAAI,GAAG,OAAO,IAAI,CAAC,IAAI,KAAK,OAAO,IAAI,KAAK,GAAG,QAAQ,CAAC,CAAC;SACnE;QAED,OAAO,KAAK,CAAC;IACjB,CAAC;IAED,gEAAgE;IACxD,4BAAM,GAAd;QACI,OAAO,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,IAAI,CAAC,KAAK,KAAK,KAAK,CAAC;IAClD,CAAC;IAED,gEAAgE;IACxD,uCAAiB,GAAzB,UAA0B,KAA8B;QACpD,IAAI,KAAK,YAAY,SAAS,EAAE;YAC5B,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,sBAAsB,CAAC,KAAK,CAAC,KAAK,CAAC;gBAC1D,IAAI,CAAC,sBAAsB,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;SAC9C;aAAM;YACH,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,sBAAsB,CAAC,KAAK,CAAC,CAAC;SAC5D;IACL,CAAC;;gBA5M+B,iBAAiB;gDAC5C,QAAQ,YAAI,MAAM,SAAC,gBAAgB;gBACH,WAAW,uBAA3C,QAAQ;gBACkB,cAAc,uBAAxC,QAAQ;;IAjFb;QADC,KAAK,EAAE;;;iDACwC;IAgBhD;QADC,KAAK,EAAE;;;+CAC0D;IAclE;QADC,KAAK,EAAE;;;8CACyC;IAQjD;QADC,KAAK,EAAE;;;8CACyC;IAOxC;QAAR,KAAK,EAAE;;mDAAkC;IAGjC;QAAR,KAAK,EAAE;;kDAA4C;IAG1C;QAAT,MAAM,EAAE;kCAA0B,YAAY;uDAA4B;IAGjE;QAAT,MAAM,EAAE;kCAAyB,YAAY;sDAA4B;IAGhE;QAAT,MAAM,EAAE;kCAA4B,YAAY;yDAA4B;IAG/B;QAA7C,SAAS,CAAC,eAAe,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;kCAAmB,eAAe;yDAAC;IAjEvE,WAAW;QAPvB,SAAS,CAAC;YACP,QAAQ,EAAE,oBAAoB;YAC9B,i0BAA6B;YAC7B,QAAQ,EAAE,iBAAiB;YAC3B,aAAa,EAAE,iBAAiB,CAAC,IAAI;YACrC,eAAe,EAAE,uBAAuB,CAAC,MAAM;SAClD,CAAC;QAqFO,WAAA,QAAQ,EAAE,CAAA,EAAE,WAAA,MAAM,CAAC,gBAAgB,CAAC,CAAA;QACpC,WAAA,QAAQ,EAAE,CAAA;QACV,WAAA,QAAQ,EAAE,CAAA;yCAHiB,iBAAiB,UAEZ,WAAW;YACjB,cAAc;OAtFpC,WAAW,CAgSvB;IAAD,kBAAC;CAAA,AAhSD,IAgSC;SAhSY,WAAW","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport { Directionality } from '@angular/cdk/bidi';\nimport { DOWN_ARROW, END, ENTER, HOME, LEFT_ARROW, PAGE_DOWN, PAGE_UP, RIGHT_ARROW, SPACE, UP_ARROW, } from '@angular/cdk/keycodes';\nimport { AfterContentInit, ChangeDetectionStrategy, ChangeDetectorRef, Component, EventEmitter, Inject, Input, OnDestroy, Optional, Output, ViewChild, ViewEncapsulation, } from '@angular/core';\nimport { MAT_DATE_FORMATS, MatDateFormats } from '@angular/material/core';\nimport { Subscription } from 'rxjs';\nimport { startWith } from 'rxjs/operators';\nimport { MatCalendarBody, MatCalendarCell, MatCalendarCellClassFunction, MatCalendarUserEvent, } from './calendar-body';\nimport { DateRange } from './date-selection-model';\nimport { createMissingDateImplError } from './datepicker-errors';\nimport { DateAdapter } from './shared/adapter/date-adapter';\n\n/**\n * An internal component used to display a single year in the datepicker.\n * @docs-private\n */\n@Component({\n    selector: 'gipi-mat-year-view',\n    templateUrl: 'year-view.html',\n    exportAs: 'gipiMatYearView',\n    encapsulation: ViewEncapsulation.None,\n    changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class MatYearView<D> implements AfterContentInit, OnDestroy {\n    private _rerenderSubscription = Subscription.EMPTY;\n\n    /** The date to display in this year view (everything other than the year is ignored). */\n    @Input()\n    get activeDate(): D { return this._activeDate; }\n    set activeDate(value: D) {\n        let oldActiveDate = this._activeDate;\n        const validDate =\n            this._dateAdapter.getValidDateOrNull(\n                this._dateAdapter.deserialize(value)\n            ) || this._dateAdapter.today();\n        this._activeDate = this._dateAdapter.clampDate(validDate, this.minDate, this.maxDate);\n        if (this._dateAdapter.getYear(oldActiveDate) !== this._dateAdapter.getYear(this._activeDate)) {\n            this._init();\n        }\n    }\n    private _activeDate: D;\n\n    /** The currently selected date. */\n    @Input()\n    get selected(): DateRange<D> | D | null { return this._selected; }\n    set selected(value: DateRange<D> | D | null) {\n        if (value instanceof DateRange) {\n            this._selected = value;\n        } else {\n            this._selected = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));\n        }\n\n        this._setSelectedMonth(value);\n    }\n    private _selected: DateRange<D> | D | null;\n\n    /** The minimum selectable date. */\n    @Input()\n    get minDate(): D | null { return this._minDate; }\n    set minDate(value: D | null) {\n        this._minDate = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));\n    }\n    private _minDate: D | null;\n\n    /** The maximum selectable date. */\n    @Input()\n    get maxDate(): D | null { return this._maxDate; }\n    set maxDate(value: D | null) {\n        this._maxDate = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));\n    }\n    private _maxDate: D | null;\n\n    /** A function used to filter which dates are selectable. */\n    @Input() dateFilter: (date: D) => boolean;\n\n    /** Function that can be used to add custom CSS classes to date cells. */\n    @Input() dateClass: MatCalendarCellClassFunction<D>;\n\n    /** Emits when a new month is selected. */\n    @Output() readonly selectedChange: EventEmitter<D> = new EventEmitter<D>();\n\n    /** Emits the selected month. This doesn't imply a change on the selected date */\n    @Output() readonly monthSelected: EventEmitter<D> = new EventEmitter<D>();\n\n    /** Emits when any date is activated. */\n    @Output() readonly activeDateChange: EventEmitter<D> = new EventEmitter<D>();\n\n    /** The body of calendar table */\n    @ViewChild(MatCalendarBody, { static: true }) _matCalendarBody: MatCalendarBody;\n\n    /** Grid of calendar cells representing the months of the year. */\n    _months: MatCalendarCell[][];\n\n    /** The label for this year (e.g. \"2017\"). */\n    _yearLabel: string;\n\n    /** The month in this year that today falls on. Null if today is in a different year. */\n    _todayMonth: number | null;\n\n    /**\n     * The month in this year that the selected Date falls on.\n     * Null if the selected Date is in a different year.\n     */\n    _selectedMonth: number | null;\n\n    constructor(\n        private _changeDetectorRef: ChangeDetectorRef,\n        @Optional() @Inject(MAT_DATE_FORMATS) private _dateFormats: MatDateFormats,\n        @Optional() public _dateAdapter: DateAdapter<D>,\n        @Optional() private _dir?: Directionality\n    ) {\n        if (!this._dateAdapter) {\n            throw createMissingDateImplError('DateAdapter');\n        }\n        if (!this._dateFormats) {\n            throw createMissingDateImplError('MAT_DATE_FORMATS');\n        }\n\n        this._activeDate = this._dateAdapter.today();\n    }\n\n    ngAfterContentInit() {\n        this._rerenderSubscription = this._dateAdapter.localeChanges\n            .pipe(startWith(null))\n            .subscribe(() => this._init());\n    }\n\n    ngOnDestroy() {\n        this._rerenderSubscription.unsubscribe();\n    }\n\n    /** Handles when a new month is selected. */\n    _monthSelected(event: MatCalendarUserEvent<number>) {\n        const month = event.value;\n        const normalizedDate =\n            this._dateAdapter.createDate(this._dateAdapter.getYear(this.activeDate), month, 1);\n\n        this.monthSelected.emit(normalizedDate);\n\n        const daysInMonth = this._dateAdapter.getNumDaysInMonth(normalizedDate);\n\n        this.selectedChange.emit(this._dateAdapter.createDate(\n            this._dateAdapter.getYear(this.activeDate), month,\n            Math.min(this._dateAdapter.getDate(this.activeDate), daysInMonth)));\n    }\n\n    /** Handles keydown events on the calendar body when calendar is in year view. */\n    _handleCalendarBodyKeydown(event: KeyboardEvent): void {\n        // TODO(mmalerba): We currently allow keyboard navigation to disabled dates, but just prevent\n        // disabled ones from being selected. This may not be ideal, we should look into whether\n        // navigation should skip over disabled dates, and if so, how to implement that efficiently.\n\n        const oldActiveDate = this._activeDate;\n        const isRtl = this._isRtl();\n\n        switch (event.keyCode) {\n            case LEFT_ARROW:\n                this.activeDate = this._dateAdapter.addCalendarMonths(this._activeDate, isRtl ? 1 : -1);\n                break;\n            case RIGHT_ARROW:\n                this.activeDate = this._dateAdapter.addCalendarMonths(this._activeDate, isRtl ? -1 : 1);\n                break;\n            case UP_ARROW:\n                this.activeDate = this._dateAdapter.addCalendarMonths(this._activeDate, -4);\n                break;\n            case DOWN_ARROW:\n                this.activeDate = this._dateAdapter.addCalendarMonths(this._activeDate, 4);\n                break;\n            case HOME:\n                this.activeDate = this._dateAdapter.addCalendarMonths(this._activeDate,\n                    -this._dateAdapter.getMonth(this._activeDate));\n                break;\n            case END:\n                this.activeDate = this._dateAdapter.addCalendarMonths(this._activeDate,\n                    11 - this._dateAdapter.getMonth(this._activeDate));\n                break;\n            case PAGE_UP:\n                this.activeDate =\n                    this._dateAdapter.addCalendarYears(this._activeDate, event.altKey ? -10 : -1);\n                break;\n            case PAGE_DOWN:\n                this.activeDate =\n                    this._dateAdapter.addCalendarYears(this._activeDate, event.altKey ? 10 : 1);\n                break;\n            case ENTER:\n            case SPACE:\n                this._monthSelected({ value: this._dateAdapter.getMonth(this._activeDate), event });\n                break;\n            default:\n                // Don't prevent default or focus active cell on keys that we don't explicitly handle.\n                return;\n        }\n\n        if (this._dateAdapter.compareDate(oldActiveDate, this.activeDate)) {\n            this.activeDateChange.emit(this.activeDate);\n        }\n\n        this._focusActiveCell();\n        // Prevent unexpected default actions such as form submission.\n        event.preventDefault();\n    }\n\n    /** Initializes this year view. */\n    _init() {\n        this._setSelectedMonth(this.selected);\n        this._todayMonth = this._getMonthInCurrentYear(this._dateAdapter.today());\n        this._yearLabel = this._dateAdapter.getYearName(this.activeDate);\n\n        let monthNames = this._dateAdapter.getMonthNames('short');\n        // First row of months only contains 5 elements so we can fit the year label on the same row.\n        this._months = [[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11]].map(row => row.map(month => this._createCellForMonth(month, monthNames[month])));\n        this._changeDetectorRef.markForCheck();\n    }\n\n    /** Focuses the active cell after the microtask queue is empty. */\n    _focusActiveCell() {\n        this._matCalendarBody._focusActiveCell();\n    }\n\n    /**\n     * Gets the month in this year that the given Date falls on.\n     * Returns null if the given Date is in another year.\n     */\n    private _getMonthInCurrentYear(date: D | null) {\n        return date && this._dateAdapter.getYear(date) == this._dateAdapter.getYear(this.activeDate) ?\n            this._dateAdapter.getMonth(date) : null;\n    }\n\n    /** Creates an MatCalendarCell for the given month. */\n    private _createCellForMonth(month: number, monthName: string) {\n        const date = this._dateAdapter.createDate(this._dateAdapter.getYear(this.activeDate), month, 1);\n        const ariaLabel = this._dateAdapter.format(date, this._dateFormats.display.monthYearA11yLabel);\n        const cellClasses = this.dateClass ? this.dateClass(date, 'year') : undefined;\n\n        return new MatCalendarCell(month, monthName.toLocaleUpperCase(), ariaLabel, this._shouldEnableMonth(month), cellClasses);\n    }\n\n    /** Whether the given month is enabled. */\n    private _shouldEnableMonth(month: number) {\n        const activeYear = this._dateAdapter.getYear(this.activeDate);\n\n        if (\n            month === undefined ||\n            month === null ||\n            this._isYearAndMonthAfterMaxDate(activeYear, month) ||\n            this._isYearAndMonthBeforeMinDate(activeYear, month)\n        ) {\n            return false;\n        }\n\n        if (!this.dateFilter) {\n            return true;\n        }\n\n        const firstOfMonth = this._dateAdapter.createDate(activeYear, month, 1);\n\n        // If any date in the month is enabled count the month as enabled.\n        for (let date = firstOfMonth; this._dateAdapter.getMonth(date) == month;\n            date = this._dateAdapter.addCalendarDays(date, 1)) {\n            if (this.dateFilter(date)) {\n                return true;\n            }\n        }\n\n        return false;\n    }\n\n    /**\n     * Tests whether the combination month/year is after this.maxDate, considering\n     * just the month and year of this.maxDate\n     */\n    private _isYearAndMonthAfterMaxDate(year: number, month: number) {\n        if (this.maxDate) {\n            const maxYear = this._dateAdapter.getYear(this.maxDate);\n            const maxMonth = this._dateAdapter.getMonth(this.maxDate);\n\n            return year > maxYear || (year === maxYear && month > maxMonth);\n        }\n\n        return false;\n    }\n\n    /**\n     * Tests whether the combination month/year is before this.minDate, considering\n     * just the month and year of this.minDate\n     */\n    private _isYearAndMonthBeforeMinDate(year: number, month: number) {\n        if (this.minDate) {\n            const minYear = this._dateAdapter.getYear(this.minDate);\n            const minMonth = this._dateAdapter.getMonth(this.minDate);\n\n            return year < minYear || (year === minYear && month < minMonth);\n        }\n\n        return false;\n    }\n\n    /** Determines whether the user has the RTL layout direction. */\n    private _isRtl() {\n        return this._dir && this._dir.value === 'rtl';\n    }\n\n    /** Sets the currently-selected month based on a model value. */\n    private _setSelectedMonth(value: DateRange<D> | D | null) {\n        if (value instanceof DateRange) {\n            this._selectedMonth = this._getMonthInCurrentYear(value.start) ||\n                this._getMonthInCurrentYear(value.end);\n        } else {\n            this._selectedMonth = this._getMonthInCurrentYear(value);\n        }\n    }\n}\n"]}

package/esm5/shared/gipi-components/dom/connected-overlay-scroll-handler.js

@@ -0,0 +1,30 @@
+import { GIPIDomHandler } from './dom-handler';
+var GIPIConnectedOverlayScrollHandler = /** @class */ (function () {
+    function GIPIConnectedOverlayScrollHandler(element, listener) {
+        if (listener === void 0) { listener = function () { }; }
+        this.element = element;
+        this.listener = listener;
+    }
+    GIPIConnectedOverlayScrollHandler.prototype.bindScrollListener = function () {
+        this.scrollableParents = GIPIDomHandler.getScrollableParents(this.element);
+        for (var i = 0; i < this.scrollableParents.length; i++) {
+            this.scrollableParents[i].addEventListener('scroll', this.listener);
+        }
+    };
+    GIPIConnectedOverlayScrollHandler.prototype.unbindScrollListener = function () {
+        if (this.scrollableParents) {
+            for (var i = 0; i < this.scrollableParents.length; i++) {
+                this.scrollableParents[i].removeEventListener('scroll', this.listener);
+            }
+        }
+    };
+    GIPIConnectedOverlayScrollHandler.prototype.destroy = function () {
+        this.unbindScrollListener();
+        this.element = null;
+        this.listener = null;
+        this.scrollableParents = null;
+    };
+    return GIPIConnectedOverlayScrollHandler;
+}());
+export { GIPIConnectedOverlayScrollHandler };
+//# sourceMappingURL=data:application/json;base64,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