@gipisistemas/ng-core 1.1.0 → 1.1.2

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

@@ -0,0 +1,324 @@
+/**
+ * @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, Input, OnDestroy, Optional, Output, ViewChild, ViewEncapsulation, } from '@angular/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';
+export var yearsPerPage = 24;
+export var yearsPerRow = 4;
+/**
+ * An internal component used to display a year selector in the datepicker.
+ * @docs-private
+ */
+var MatMultiYearView = /** @class */ (function () {
+    function MatMultiYearView(_changeDetectorRef, _dateAdapter, _dir) {
+        this._changeDetectorRef = _changeDetectorRef;
+        this._dateAdapter = _dateAdapter;
+        this._dir = _dir;
+        this._rerenderSubscription = Subscription.EMPTY;
+        /** Emits when a new year is selected. */
+        this.selectedChange = new EventEmitter();
+        /** Emits the selected year. This doesn't imply a change on the selected date */
+        this.yearSelected = new EventEmitter();
+        /** Emits when any date is activated. */
+        this.activeDateChange = new EventEmitter();
+        if (!this._dateAdapter) {
+            throw createMissingDateImplError('DateAdapter');
+        }
+        this._activeDate = this._dateAdapter.today();
+    }
+    Object.defineProperty(MatMultiYearView.prototype, "activeDate", {
+        /** The date to display in this multi-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 (!isSameMultiYearView(this._dateAdapter, oldActiveDate, this._activeDate, this.minDate, this.maxDate)) {
+                this._init();
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(MatMultiYearView.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._setSelectedYear(value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(MatMultiYearView.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(MatMultiYearView.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
+    });
+    MatMultiYearView.prototype.ngAfterContentInit = function () {
+        var _this = this;
+        this._rerenderSubscription = this._dateAdapter.localeChanges
+            .pipe(startWith(null))
+            .subscribe(function () { return _this._init(); });
+    };
+    MatMultiYearView.prototype.ngOnDestroy = function () {
+        this._rerenderSubscription.unsubscribe();
+    };
+    /** Initializes this multi-year view. */
+    MatMultiYearView.prototype._init = function () {
+        var _this = this;
+        this._todayYear = this._dateAdapter.getYear(this._dateAdapter.today());
+        // We want a range years such that we maximize the number of
+        // enabled dates visible at once. This prevents issues where the minimum year
+        // is the last item of a page OR the maximum year is the first item of a page.
+        // The offset from the active year to the "slot" for the starting year is the
+        // *actual* first rendered year in the multi-year view.
+        var activeYear = this._dateAdapter.getYear(this._activeDate);
+        var minYearOfPage = activeYear - getActiveOffset(this._dateAdapter, this.activeDate, this.minDate, this.maxDate);
+        this._years = [];
+        for (var i = 0, row = []; i < yearsPerPage; i++) {
+            row.push(minYearOfPage + i);
+            if (row.length == yearsPerRow) {
+                this._years.push(row.map(function (year) { return _this._createCellForYear(year); }));
+                row = [];
+            }
+        }
+        this._changeDetectorRef.markForCheck();
+    };
+    /** Handles when a new year is selected. */
+    MatMultiYearView.prototype._yearSelected = function (event) {
+        var year = event.value;
+        this.yearSelected.emit(this._dateAdapter.createDate(year, 0, 1));
+        var month = this._dateAdapter.getMonth(this.activeDate);
+        var daysInMonth = this._dateAdapter.getNumDaysInMonth(this._dateAdapter.createDate(year, month, 1));
+        this.selectedChange.emit(this._dateAdapter.createDate(year, month, Math.min(this._dateAdapter.getDate(this.activeDate), daysInMonth)));
+    };
+    /** Handles keydown events on the calendar body when calendar is in multi-year view. */
+    MatMultiYearView.prototype._handleCalendarBodyKeydown = function (event) {
+        var oldActiveDate = this._activeDate;
+        var isRtl = this._isRtl();
+        switch (event.keyCode) {
+            case LEFT_ARROW:
+                this.activeDate = this._dateAdapter.addCalendarYears(this._activeDate, isRtl ? 1 : -1);
+                break;
+            case RIGHT_ARROW:
+                this.activeDate = this._dateAdapter.addCalendarYears(this._activeDate, isRtl ? -1 : 1);
+                break;
+            case UP_ARROW:
+                this.activeDate = this._dateAdapter.addCalendarYears(this._activeDate, -yearsPerRow);
+                break;
+            case DOWN_ARROW:
+                this.activeDate = this._dateAdapter.addCalendarYears(this._activeDate, yearsPerRow);
+                break;
+            case HOME:
+                this.activeDate = this._dateAdapter.addCalendarYears(this._activeDate, -getActiveOffset(this._dateAdapter, this.activeDate, this.minDate, this.maxDate));
+                break;
+            case END:
+                this.activeDate = this._dateAdapter.addCalendarYears(this._activeDate, yearsPerPage - getActiveOffset(this._dateAdapter, this.activeDate, this.minDate, this.maxDate) - 1);
+                break;
+            case PAGE_UP:
+                this.activeDate =
+                    this._dateAdapter.addCalendarYears(this._activeDate, event.altKey ? -yearsPerPage * 10 : -yearsPerPage);
+                break;
+            case PAGE_DOWN:
+                this.activeDate =
+                    this._dateAdapter.addCalendarYears(this._activeDate, event.altKey ? yearsPerPage * 10 : yearsPerPage);
+                break;
+            case ENTER:
+            case SPACE:
+                this._yearSelected({ value: this._dateAdapter.getYear(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();
+    };
+    MatMultiYearView.prototype._getActiveCell = function () {
+        return getActiveOffset(this._dateAdapter, this.activeDate, this.minDate, this.maxDate);
+    };
+    /** Focuses the active cell after the microtask queue is empty. */
+    MatMultiYearView.prototype._focusActiveCell = function () {
+        this._matCalendarBody._focusActiveCell();
+    };
+    /** Creates an MatCalendarCell for the given year. */
+    MatMultiYearView.prototype._createCellForYear = function (year) {
+        var date = this._dateAdapter.createDate(year, 0, 1);
+        var yearName = this._dateAdapter.getYearName(date);
+        var cellClasses = this.dateClass ? this.dateClass(date, 'multi-year') : undefined;
+        return new MatCalendarCell(year, yearName, yearName, this._shouldEnableYear(year), cellClasses);
+    };
+    /** Whether the given year is enabled. */
+    MatMultiYearView.prototype._shouldEnableYear = function (year) {
+        // disable if the year is greater than maxDate lower than minDate
+        if (year === undefined || year === null ||
+            (this.maxDate && year > this._dateAdapter.getYear(this.maxDate)) ||
+            (this.minDate && year < this._dateAdapter.getYear(this.minDate))) {
+            return false;
+        }
+        // enable if it reaches here and there's no filter defined
+        if (!this.dateFilter) {
+            return true;
+        }
+        var firstOfYear = this._dateAdapter.createDate(year, 0, 1);
+        // If any date in the year is enabled count the year as enabled.
+        for (var date = firstOfYear; this._dateAdapter.getYear(date) == year; date = this._dateAdapter.addCalendarDays(date, 1)) {
+            if (this.dateFilter(date)) {
+                return true;
+            }
+        }
+        return false;
+    };
+    /** Determines whether the user has the RTL layout direction. */
+    MatMultiYearView.prototype._isRtl = function () {
+        return this._dir && this._dir.value === 'rtl';
+    };
+    /** Sets the currently-highlighted year based on a model value. */
+    MatMultiYearView.prototype._setSelectedYear = function (value) {
+        this._selectedYear = null;
+        if (value instanceof DateRange) {
+            var displayValue = value.start || value.end;
+            if (displayValue) {
+                this._selectedYear = this._dateAdapter.getYear(displayValue);
+            }
+        }
+        else if (value) {
+            this._selectedYear = this._dateAdapter.getYear(value);
+        }
+    };
+    MatMultiYearView.ctorParameters = function () { return [
+        { type: ChangeDetectorRef },
+        { type: DateAdapter, decorators: [{ type: Optional }] },
+        { type: Directionality, decorators: [{ type: Optional }] }
+    ]; };
+    __decorate([
+        Input(),
+        __metadata("design:type", Object),
+        __metadata("design:paramtypes", [Object])
+    ], MatMultiYearView.prototype, "activeDate", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", Object),
+        __metadata("design:paramtypes", [Object])
+    ], MatMultiYearView.prototype, "selected", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", Object),
+        __metadata("design:paramtypes", [Object])
+    ], MatMultiYearView.prototype, "minDate", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", Object),
+        __metadata("design:paramtypes", [Object])
+    ], MatMultiYearView.prototype, "maxDate", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", Function)
+    ], MatMultiYearView.prototype, "dateFilter", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Function)
+    ], MatMultiYearView.prototype, "dateClass", void 0);
+    __decorate([
+        Output(),
+        __metadata("design:type", EventEmitter)
+    ], MatMultiYearView.prototype, "selectedChange", void 0);
+    __decorate([
+        Output(),
+        __metadata("design:type", EventEmitter)
+    ], MatMultiYearView.prototype, "yearSelected", void 0);
+    __decorate([
+        Output(),
+        __metadata("design:type", EventEmitter)
+    ], MatMultiYearView.prototype, "activeDateChange", void 0);
+    __decorate([
+        ViewChild(MatCalendarBody, { static: true }),
+        __metadata("design:type", MatCalendarBody)
+    ], MatMultiYearView.prototype, "_matCalendarBody", void 0);
+    MatMultiYearView = __decorate([
+        Component({
+            selector: 'gipi-mat-multi-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           [rows]=\"_years\"\n           [todayValue]=\"_todayYear\"\n           [startValue]=\"_selectedYear!\"\n           [endValue]=\"_selectedYear!\"\n           [numCols]=\"4\"\n           [cellAspectRatio]=\"4 / 7\"\n           [activeCell]=\"_getActiveCell()\"\n           (selectedValueChange)=\"_yearSelected($event)\"\n           (keydown)=\"_handleCalendarBodyKeydown($event)\">\n    </tbody>\n</table>",
+            exportAs: 'gipiMatMultiYearView',
+            encapsulation: ViewEncapsulation.None,
+            changeDetection: ChangeDetectionStrategy.OnPush
+        }),
+        __param(1, Optional()),
+        __param(2, Optional()),
+        __metadata("design:paramtypes", [ChangeDetectorRef,
+            DateAdapter,
+            Directionality])
+    ], MatMultiYearView);
+    return MatMultiYearView;
+}());
+export { MatMultiYearView };
+export function isSameMultiYearView(dateAdapter, date1, date2, minDate, maxDate) {
+    var year1 = dateAdapter.getYear(date1);
+    var year2 = dateAdapter.getYear(date2);
+    var startingYear = getStartingYear(dateAdapter, minDate, maxDate);
+    return Math.floor((year1 - startingYear) / yearsPerPage) === Math.floor((year2 - startingYear) / yearsPerPage);
+}
+/**
+ * When the multi-year view is first opened, the active year will be in view.
+ * So we compute how many years are between the active year and the *slot* where our
+ * "startingYear" will render when paged into view.
+ */
+export function getActiveOffset(dateAdapter, activeDate, minDate, maxDate) {
+    var activeYear = dateAdapter.getYear(activeDate);
+    return euclideanModulo((activeYear - getStartingYear(dateAdapter, minDate, maxDate)), yearsPerPage);
+}
+/**
+ * We pick a "starting" year such that either the maximum year would be at the end
+ * or the minimum year would be at the beginning of a page.
+ */
+function getStartingYear(dateAdapter, minDate, maxDate) {
+    var startingYear = 0;
+    if (maxDate) {
+        var maxYear = dateAdapter.getYear(maxDate);
+        startingYear = maxYear - yearsPerPage + 1;
+    }
+    else if (minDate) {
+        startingYear = dateAdapter.getYear(minDate);
+    }
+    return startingYear;
+}
+/** Gets remainder that is non-negative, even if first number is negative */
+function euclideanModulo(a, b) {
+    return (a % b + b) % b;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"multi-year-view.js","sourceRoot":"ng://@gipisistemas/ng-core/","sources":["shared/gipi-components/datepicker/mat-datepicker/multi-year-view.ts"],"names":[],"mappings":"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","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, Input, OnDestroy, Optional, Output, ViewChild, ViewEncapsulation, } from '@angular/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\nexport const yearsPerPage = 24;\n\nexport const yearsPerRow = 4;\n\n/**\n * An internal component used to display a year selector in the datepicker.\n * @docs-private\n */\n@Component({\n    selector: 'gipi-mat-multi-year-view',\n    templateUrl: 'multi-year-view.html',\n    exportAs: 'gipiMatMultiYearView',\n    encapsulation: ViewEncapsulation.None,\n    changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class MatMultiYearView<D> implements AfterContentInit, OnDestroy {\n    private _rerenderSubscription = Subscription.EMPTY;\n\n    /** The date to display in this multi-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\n        if (!isSameMultiYearView(\n            this._dateAdapter, oldActiveDate, this._activeDate, this.minDate, this.maxDate)) {\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._setSelectedYear(value);\n    }\n    private _selected: DateRange<D> | D | null;\n\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 year is selected. */\n    @Output() readonly selectedChange: EventEmitter<D> = new EventEmitter<D>();\n\n    /** Emits the selected year. This doesn't imply a change on the selected date */\n    @Output() readonly yearSelected: 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 currently displayed years. */\n    _years: MatCalendarCell[][];\n\n    /** The year that today falls on. */\n    _todayYear: number;\n\n    /** The year of the selected date. Null if the selected date is null. */\n    _selectedYear: number | null;\n\n    constructor(\n        private _changeDetectorRef: ChangeDetectorRef,\n        @Optional() public _dateAdapter: DateAdapter<D>,\n        @Optional() private _dir?: Directionality\n    ) {\n        if (!this._dateAdapter) {\n            throw createMissingDateImplError('DateAdapter');\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    /** Initializes this multi-year view. */\n    _init() {\n        this._todayYear = this._dateAdapter.getYear(this._dateAdapter.today());\n\n        // We want a range years such that we maximize the number of\n        // enabled dates visible at once. This prevents issues where the minimum year\n        // is the last item of a page OR the maximum year is the first item of a page.\n\n        // The offset from the active year to the \"slot\" for the starting year is the\n        // *actual* first rendered year in the multi-year view.\n        const activeYear = this._dateAdapter.getYear(this._activeDate);\n        const minYearOfPage = activeYear - getActiveOffset(\n            this._dateAdapter, this.activeDate, this.minDate, this.maxDate);\n\n        this._years = [];\n        for (let i = 0, row: number[] = []; i < yearsPerPage; i++) {\n            row.push(minYearOfPage + i);\n            if (row.length == yearsPerRow) {\n                this._years.push(row.map(year => this._createCellForYear(year)));\n                row = [];\n            }\n        }\n        this._changeDetectorRef.markForCheck();\n    }\n\n    /** Handles when a new year is selected. */\n    _yearSelected(event: MatCalendarUserEvent<number>) {\n        const year = event.value;\n        this.yearSelected.emit(this._dateAdapter.createDate(year, 0, 1));\n        let month = this._dateAdapter.getMonth(this.activeDate);\n        let daysInMonth =\n            this._dateAdapter.getNumDaysInMonth(this._dateAdapter.createDate(year, month, 1));\n        this.selectedChange.emit(this._dateAdapter.createDate(year, month,\n            Math.min(this._dateAdapter.getDate(this.activeDate), daysInMonth)));\n    }\n\n    /** Handles keydown events on the calendar body when calendar is in multi-year view. */\n    _handleCalendarBodyKeydown(event: KeyboardEvent): void {\n        const oldActiveDate = this._activeDate;\n        const isRtl = this._isRtl();\n\n        switch (event.keyCode) {\n            case LEFT_ARROW:\n                this.activeDate = this._dateAdapter.addCalendarYears(this._activeDate, isRtl ? 1 : -1);\n                break;\n            case RIGHT_ARROW:\n                this.activeDate = this._dateAdapter.addCalendarYears(this._activeDate, isRtl ? -1 : 1);\n                break;\n            case UP_ARROW:\n                this.activeDate = this._dateAdapter.addCalendarYears(this._activeDate, -yearsPerRow);\n                break;\n            case DOWN_ARROW:\n                this.activeDate = this._dateAdapter.addCalendarYears(this._activeDate, yearsPerRow);\n                break;\n            case HOME:\n                this.activeDate = this._dateAdapter.addCalendarYears(this._activeDate,\n                    -getActiveOffset(this._dateAdapter, this.activeDate, this.minDate, this.maxDate));\n                break;\n            case END:\n                this.activeDate = this._dateAdapter.addCalendarYears(this._activeDate,\n                    yearsPerPage - getActiveOffset(\n                        this._dateAdapter, this.activeDate, this.minDate, this.maxDate) - 1);\n                break;\n            case PAGE_UP:\n                this.activeDate =\n                    this._dateAdapter.addCalendarYears(\n                        this._activeDate, event.altKey ? -yearsPerPage * 10 : -yearsPerPage);\n                break;\n            case PAGE_DOWN:\n                this.activeDate =\n                    this._dateAdapter.addCalendarYears(\n                        this._activeDate, event.altKey ? yearsPerPage * 10 : yearsPerPage);\n                break;\n            case ENTER:\n            case SPACE:\n                this._yearSelected({ value: this._dateAdapter.getYear(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        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    _getActiveCell(): number {\n        return getActiveOffset(this._dateAdapter, this.activeDate, this.minDate, this.maxDate);\n    }\n\n    /** Focuses the active cell after the microtask queue is empty. */\n    _focusActiveCell() {\n        this._matCalendarBody._focusActiveCell();\n    }\n\n    /** Creates an MatCalendarCell for the given year. */\n    private _createCellForYear(year: number) {\n        const date = this._dateAdapter.createDate(year, 0, 1);\n        const yearName = this._dateAdapter.getYearName(date);\n        const cellClasses = this.dateClass ? this.dateClass(date, 'multi-year') : undefined;\n\n        return new MatCalendarCell(year, yearName, yearName, this._shouldEnableYear(year), cellClasses);\n    }\n\n    /** Whether the given year is enabled. */\n    private _shouldEnableYear(year: number) {\n        // disable if the year is greater than maxDate lower than minDate\n        if (year === undefined || year === null ||\n            (this.maxDate && year > this._dateAdapter.getYear(this.maxDate)) ||\n            (this.minDate && year < this._dateAdapter.getYear(this.minDate))) {\n            return false;\n        }\n\n        // enable if it reaches here and there's no filter defined\n        if (!this.dateFilter) {\n            return true;\n        }\n\n        const firstOfYear = this._dateAdapter.createDate(year, 0, 1);\n\n        // If any date in the year is enabled count the year as enabled.\n        for (let date = firstOfYear; this._dateAdapter.getYear(date) == year;\n            date = this._dateAdapter.addCalendarDays(date, 1)) {\n            if (this.dateFilter(date)) {\n                return true;\n            }\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-highlighted year based on a model value. */\n    private _setSelectedYear(value: DateRange<D> | D | null) {\n        this._selectedYear = null;\n\n        if (value instanceof DateRange) {\n            const displayValue = value.start || value.end;\n\n            if (displayValue) {\n                this._selectedYear = this._dateAdapter.getYear(displayValue);\n            }\n        } else if (value) {\n            this._selectedYear = this._dateAdapter.getYear(value);\n        }\n    }\n}\n\nexport function isSameMultiYearView<D>(dateAdapter: DateAdapter<D>, date1: D, date2: D, minDate: D | null, maxDate: D | null): boolean {\n    const year1 = dateAdapter.getYear(date1);\n    const year2 = dateAdapter.getYear(date2);\n    const startingYear = getStartingYear(dateAdapter, minDate, maxDate);\n    return Math.floor((year1 - startingYear) / yearsPerPage) === Math.floor((year2 - startingYear) / yearsPerPage);\n}\n\n/**\n * When the multi-year view is first opened, the active year will be in view.\n * So we compute how many years are between the active year and the *slot* where our\n * \"startingYear\" will render when paged into view.\n */\nexport function getActiveOffset<D>(dateAdapter: DateAdapter<D>, activeDate: D, minDate: D | null, maxDate: D | null): number {\n    const activeYear = dateAdapter.getYear(activeDate);\n    return euclideanModulo((activeYear - getStartingYear(dateAdapter, minDate, maxDate)), yearsPerPage);\n}\n\n/**\n * We pick a \"starting\" year such that either the maximum year would be at the end\n * or the minimum year would be at the beginning of a page.\n */\nfunction getStartingYear<D>(dateAdapter: DateAdapter<D>, minDate: D | null, maxDate: D | null): number {\n    let startingYear = 0;\n    if (maxDate) {\n        const maxYear = dateAdapter.getYear(maxDate);\n        startingYear = maxYear - yearsPerPage + 1;\n    } else if (minDate) {\n        startingYear = dateAdapter.getYear(minDate);\n    }\n    return startingYear;\n}\n\n/** Gets remainder that is non-negative, even if first number is negative */\nfunction euclideanModulo(a: number, b: number): number {\n    return (a % b + b) % b;\n}\n"]}

package/esm5/shared/gipi-components/datepicker/mat-datepicker/shared/adapter/date-adapter.js

@@ -0,0 +1,118 @@
+/**
+ * @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 { inject, InjectionToken, LOCALE_ID } from '@angular/core';
+import { Subject } from 'rxjs';
+/** InjectionToken for datepicker that can be used to override default locale code. */
+export var MAT_DATE_LOCALE = new InjectionToken('MAT_DATE_LOCALE', {
+    providedIn: 'root',
+    factory: MAT_DATE_LOCALE_FACTORY,
+});
+/** @docs-private */
+export function MAT_DATE_LOCALE_FACTORY() {
+    return inject(LOCALE_ID);
+}
+/**
+ * No longer needed since MAT_DATE_LOCALE has been changed to a scoped injectable.
+ * If you are importing and providing this in your code you can simply remove it.
+ * @deprecated
+ * @breaking-change 8.0.0
+ */
+export var MAT_DATE_LOCALE_PROVIDER = { provide: MAT_DATE_LOCALE, useExisting: LOCALE_ID };
+/** Adapts type `D` to be usable as a date by cdk-based components that work with dates. */
+var DateAdapter = /** @class */ (function () {
+    function DateAdapter() {
+        this._localeChanges = new Subject();
+        /** A stream that emits when the locale changes. */
+        this.localeChanges = this._localeChanges;
+    }
+    /**
+     * Given a potential date object, returns that same date object if it is
+     * a valid date, or `null` if it's not a valid date.
+     * @param obj The object to check.
+     * @returns A date or `null`.
+     */
+    DateAdapter.prototype.getValidDateOrNull = function (obj) {
+        return this.isDateInstance(obj) && this.isValid(obj) ? obj : null;
+    };
+    /**
+     * Attempts to deserialize a value to a valid date object. This is different from parsing in that
+     * deserialize should only accept non-ambiguous, locale-independent formats (e.g. a ISO 8601
+     * string). The default implementation does not allow any deserialization, it simply checks that
+     * the given value is already a valid date object or null. The `<mat-datepicker>` will call this
+     * method on all of its `@Input()` properties that accept dates. It is therefore possible to
+     * support passing values from your backend directly to these properties by overriding this method
+     * to also deserialize the format used by your backend.
+     * @param value The value to be deserialized into a date object.
+     * @returns The deserialized date object, either a valid date, null if the value can be
+     *     deserialized into a null date (e.g. the empty string), or an invalid date.
+     */
+    DateAdapter.prototype.deserialize = function (value) {
+        if (value == null || this.isDateInstance(value) && this.isValid(value)) {
+            return value;
+        }
+        return this.invalid();
+    };
+    /**
+     * Sets the locale used for all dates.
+     * @param locale The new locale.
+     */
+    DateAdapter.prototype.setLocale = function (locale) {
+        this.locale = locale;
+        this._localeChanges.next();
+    };
+    /**
+     * Compares two dates.
+     * @param first The first date to compare.
+     * @param second The second date to compare.
+     * @returns 0 if the dates are equal, a number less than 0 if the first date is earlier,
+     *     a number greater than 0 if the first date is later.
+     */
+    DateAdapter.prototype.compareDate = function (first, second) {
+        return this.getYear(first) - this.getYear(second) ||
+            this.getMonth(first) - this.getMonth(second) ||
+            this.getDate(first) - this.getDate(second);
+    };
+    /**
+     * Checks if two dates are equal.
+     * @param first The first date to check.
+     * @param second The second date to check.
+     * @returns Whether the two dates are equal.
+     *     Null dates are considered equal to other null dates.
+     */
+    DateAdapter.prototype.sameDate = function (first, second) {
+        if (first && second) {
+            var firstValid = this.isValid(first);
+            var secondValid = this.isValid(second);
+            if (firstValid && secondValid) {
+                return !this.compareDate(first, second);
+            }
+            return firstValid == secondValid;
+        }
+        return first == second;
+    };
+    /**
+     * Clamp the given date between min and max dates.
+     * @param date The date to clamp.
+     * @param min The minimum value to allow. If null or omitted no min is enforced.
+     * @param max The maximum value to allow. If null or omitted no max is enforced.
+     * @returns `min` if `date` is less than `min`, `max` if date is greater than `max`,
+     *     otherwise `date`.
+     */
+    DateAdapter.prototype.clampDate = function (date, min, max) {
+        if (min && this.compareDate(date, min) < 0) {
+            return min;
+        }
+        if (max && this.compareDate(date, max) > 0) {
+            return max;
+        }
+        return date;
+    };
+    return DateAdapter;
+}());
+export { DateAdapter };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"date-adapter.js","sourceRoot":"ng://@gipisistemas/ng-core/","sources":["shared/gipi-components/datepicker/mat-datepicker/shared/adapter/date-adapter.ts"],"names":[],"mappings":"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","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 { inject, InjectionToken, LOCALE_ID } from '@angular/core';\nimport { Observable, Subject } from 'rxjs';\n\n/** InjectionToken for datepicker that can be used to override default locale code. */\nexport const MAT_DATE_LOCALE = new InjectionToken<string>('MAT_DATE_LOCALE', {\n    providedIn: 'root',\n    factory: MAT_DATE_LOCALE_FACTORY,\n});\n\n/** @docs-private */\nexport function MAT_DATE_LOCALE_FACTORY(): string {\n    return inject(LOCALE_ID);\n}\n\n/**\n * No longer needed since MAT_DATE_LOCALE has been changed to a scoped injectable.\n * If you are importing and providing this in your code you can simply remove it.\n * @deprecated\n * @breaking-change 8.0.0\n */\nexport const MAT_DATE_LOCALE_PROVIDER = { provide: MAT_DATE_LOCALE, useExisting: LOCALE_ID };\n\n/** Adapts type `D` to be usable as a date by cdk-based components that work with dates. */\nexport abstract class DateAdapter<D> {\n    /** The locale to use for all dates. */\n    protected locale: any;\n    protected _localeChanges = new Subject<void>();\n\n    /** A stream that emits when the locale changes. */\n    readonly localeChanges: Observable<void> = this._localeChanges;\n\n    /**\n     * Gets the year component of the given date.\n     * @param date The date to extract the year from.\n     * @returns The year component.\n     */\n    abstract getYear(date: D): number;\n\n    /**\n     * Gets the month component of the given date.\n     * @param date The date to extract the month from.\n     * @returns The month component (0-indexed, 0 = January).\n     */\n    abstract getMonth(date: D): number;\n\n    /**\n     * Gets the date of the month component of the given date.\n     * @param date The date to extract the date of the month from.\n     * @returns The month component (1-indexed, 1 = first of month).\n     */\n    abstract getDate(date: D): number;\n\n    /**\n     * Gets the day of the week component of the given date.\n     * @param date The date to extract the day of the week from.\n     * @returns The month component (0-indexed, 0 = Sunday).\n     */\n    abstract getDayOfWeek(date: D): number;\n\n    /**\n     * Gets a list of names for the months.\n     * @param style The naming style (e.g. long = 'January', short = 'Jan', narrow = 'J').\n     * @returns An ordered list of all month names, starting with January.\n     */\n    abstract getMonthNames(style: 'long' | 'short' | 'narrow'): string[];\n\n    /**\n     * Gets a list of names for the dates of the month.\n     * @returns An ordered list of all date of the month names, starting with '1'.\n     */\n    abstract getDateNames(): string[];\n\n    /**\n     * Gets a list of names for the days of the week.\n     * @param style The naming style (e.g. long = 'Sunday', short = 'Sun', narrow = 'S').\n     * @returns An ordered list of all weekday names, starting with Sunday.\n     */\n    abstract getDayOfWeekNames(style: 'long' | 'short' | 'narrow'): string[];\n\n    /**\n     * Gets the name for the year of the given date.\n     * @param date The date to get the year name for.\n     * @returns The name of the given year (e.g. '2017').\n     */\n    abstract getYearName(date: D): string;\n\n    /**\n     * Gets the first day of the week.\n     * @returns The first day of the week (0-indexed, 0 = Sunday).\n     */\n    abstract getFirstDayOfWeek(): number;\n\n    /**\n     * Gets the number of days in the month of the given date.\n     * @param date The date whose month should be checked.\n     * @returns The number of days in the month of the given date.\n     */\n    abstract getNumDaysInMonth(date: D): number;\n\n    /**\n     * Clones the given date.\n     * @param date The date to clone\n     * @returns A new date equal to the given date.\n     */\n    abstract clone(date: D): D;\n\n    /**\n     * Creates a date with the given year, month, and date. Does not allow over/under-flow of the\n     * month and date.\n     * @param year The full year of the date. (e.g. 89 means the year 89, not the year 1989).\n     * @param month The month of the date (0-indexed, 0 = January). Must be an integer 0 - 11.\n     * @param date The date of month of the date. Must be an integer 1 - length of the given month.\n     * @returns The new date, or null if invalid.\n     */\n    abstract createDate(year: number, month: number, date: number): D;\n\n    /**\n     * Gets today's date.\n     * @returns Today's date.\n     */\n    abstract today(): D;\n\n    /**\n     * Parses a date from a user-provided value.\n     * @param value The value to parse.\n     * @param parseFormat The expected format of the value being parsed\n     *     (type is implementation-dependent).\n     * @returns The parsed date.\n     */\n    abstract parse(value: any, parseFormat: any): D | null;\n\n    /**\n     * Formats a date as a string according to the given format.\n     * @param date The value to format.\n     * @param displayFormat The format to use to display the date as a string.\n     * @returns The formatted date string.\n     */\n    abstract format(date: D, displayFormat: any): string;\n\n    /**\n     * Adds the given number of years to the date. Years are counted as if flipping 12 pages on the\n     * calendar for each year and then finding the closest date in the new month. For example when\n     * adding 1 year to Feb 29, 2016, the resulting date will be Feb 28, 2017.\n     * @param date The date to add years to.\n     * @param years The number of years to add (may be negative).\n     * @returns A new date equal to the given one with the specified number of years added.\n     */\n    abstract addCalendarYears(date: D, years: number): D;\n\n    /**\n     * Adds the given number of months to the date. Months are counted as if flipping a page on the\n     * calendar for each month and then finding the closest date in the new month. For example when\n     * adding 1 month to Jan 31, 2017, the resulting date will be Feb 28, 2017.\n     * @param date The date to add months to.\n     * @param months The number of months to add (may be negative).\n     * @returns A new date equal to the given one with the specified number of months added.\n     */\n    abstract addCalendarMonths(date: D, months: number): D;\n\n    /**\n     * Adds the given number of days to the date. Days are counted as if moving one cell on the\n     * calendar for each day.\n     * @param date The date to add days to.\n     * @param days The number of days to add (may be negative).\n     * @returns A new date equal to the given one with the specified number of days added.\n     */\n    abstract addCalendarDays(date: D, days: number): D;\n\n    /**\n     * Gets the RFC 3339 compatible string (https://tools.ietf.org/html/rfc3339) for the given date.\n     * This method is used to generate date strings that are compatible with native HTML attributes\n     * such as the `min` or `max` attribute of an `<input>`.\n     * @param date The date to get the ISO date string for.\n     * @returns The ISO date string date string.\n     */\n    abstract toIso8601(date: D): string;\n\n    /**\n     * Checks whether the given object is considered a date instance by this DateAdapter.\n     * @param obj The object to check\n     * @returns Whether the object is a date instance.\n     */\n    abstract isDateInstance(obj: any): boolean;\n\n    /**\n     * Checks whether the given date is valid.\n     * @param date The date to check.\n     * @returns Whether the date is valid.\n     */\n    abstract isValid(date: D): boolean;\n\n    /**\n     * Gets date instance that is not valid.\n     * @returns An invalid date.\n     */\n    abstract invalid(): D;\n\n    /**\n     * Given a potential date object, returns that same date object if it is\n     * a valid date, or `null` if it's not a valid date.\n     * @param obj The object to check.\n     * @returns A date or `null`.\n     */\n    getValidDateOrNull(obj: unknown): D | null {\n        return this.isDateInstance(obj) && this.isValid(obj as D) ? obj as D : null;\n    }\n\n    /**\n     * Attempts to deserialize a value to a valid date object. This is different from parsing in that\n     * deserialize should only accept non-ambiguous, locale-independent formats (e.g. a ISO 8601\n     * string). The default implementation does not allow any deserialization, it simply checks that\n     * the given value is already a valid date object or null. The `<mat-datepicker>` will call this\n     * method on all of its `@Input()` properties that accept dates. It is therefore possible to\n     * support passing values from your backend directly to these properties by overriding this method\n     * to also deserialize the format used by your backend.\n     * @param value The value to be deserialized into a date object.\n     * @returns The deserialized date object, either a valid date, null if the value can be\n     *     deserialized into a null date (e.g. the empty string), or an invalid date.\n     */\n    deserialize(value: any): D | null {\n        if (value == null || this.isDateInstance(value) && this.isValid(value)) {\n            return value;\n        }\n        return this.invalid();\n    }\n\n    /**\n     * Sets the locale used for all dates.\n     * @param locale The new locale.\n     */\n    setLocale(locale: any) {\n        this.locale = locale;\n        this._localeChanges.next();\n    }\n\n    /**\n     * Compares two dates.\n     * @param first The first date to compare.\n     * @param second The second date to compare.\n     * @returns 0 if the dates are equal, a number less than 0 if the first date is earlier,\n     *     a number greater than 0 if the first date is later.\n     */\n    compareDate(first: D, second: D): number {\n        return this.getYear(first) - this.getYear(second) ||\n            this.getMonth(first) - this.getMonth(second) ||\n            this.getDate(first) - this.getDate(second);\n    }\n\n    /**\n     * Checks if two dates are equal.\n     * @param first The first date to check.\n     * @param second The second date to check.\n     * @returns Whether the two dates are equal.\n     *     Null dates are considered equal to other null dates.\n     */\n    sameDate(first: D | null, second: D | null): boolean {\n        if (first && second) {\n            let firstValid = this.isValid(first);\n            let secondValid = this.isValid(second);\n            if (firstValid && secondValid) {\n                return !this.compareDate(first, second);\n            }\n            return firstValid == secondValid;\n        }\n        return first == second;\n    }\n\n    /**\n     * Clamp the given date between min and max dates.\n     * @param date The date to clamp.\n     * @param min The minimum value to allow. If null or omitted no min is enforced.\n     * @param max The maximum value to allow. If null or omitted no max is enforced.\n     * @returns `min` if `date` is less than `min`, `max` if date is greater than `max`,\n     *     otherwise `date`.\n     */\n    clampDate(date: D, min?: D | null, max?: D | null): D {\n        if (min && this.compareDate(date, min) < 0) {\n            return min;\n        }\n        if (max && this.compareDate(date, max) > 0) {\n            return max;\n        }\n        return date;\n    }\n}\n"]}

package/esm5/shared/gipi-components/datepicker/mat-datepicker/shared/adapter/date-formats.js

@@ -0,0 +1,10 @@
+/**
+ * @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 { InjectionToken } from '@angular/core';
+export var MAT_DATE_FORMATS = new InjectionToken('mat-date-formats');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0ZS1mb3JtYXRzLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQGdpcGlzaXN0ZW1hcy9uZy1jb3JlLyIsInNvdXJjZXMiOlsic2hhcmVkL2dpcGktY29tcG9uZW50cy9kYXRlcGlja2VyL21hdC1kYXRlcGlja2VyL3NoYXJlZC9hZGFwdGVyL2RhdGUtZm9ybWF0cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7QUFFSCxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBZ0IvQyxNQUFNLENBQUMsSUFBTSxnQkFBZ0IsR0FBRyxJQUFJLGNBQWMsQ0FBaUIsa0JBQWtCLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5pbXBvcnQgeyBJbmplY3Rpb25Ub2tlbiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5cbmV4cG9ydCB0eXBlIE1hdERhdGVGb3JtYXRzID0ge1xuICAgIHBhcnNlOiB7XG4gICAgICAgIGRhdGVJbnB1dDogYW55XG4gICAgfSxcbiAgICBkaXNwbGF5OiB7XG4gICAgICAgIGRhdGVJbnB1dDogYW55LFxuICAgICAgICBtb250aFllYXJMYWJlbDogYW55LFxuICAgICAgICBkYXRlQTExeUxhYmVsOiBhbnksXG4gICAgICAgIG1vbnRoWWVhckExMXlMYWJlbDogYW55LFxuICAgIH1cbn07XG5cblxuZXhwb3J0IGNvbnN0IE1BVF9EQVRFX0ZPUk1BVFMgPSBuZXcgSW5qZWN0aW9uVG9rZW48TWF0RGF0ZUZvcm1hdHM+KCdtYXQtZGF0ZS1mb3JtYXRzJyk7XG4iXX0=