@gipisistemas/ng-core 1.1.0 → 1.1.2

package/esm5/shared/gipi-components/datepicker/mat-datepicker/calendar.js

@@ -0,0 +1,441 @@
+/**
+ * @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 { AfterContentInit, AfterViewChecked, AfterViewInit, ChangeDetectionStrategy, ChangeDetectorRef, Component, EventEmitter, Inject, Input, OnChanges, OnDestroy, Optional, Output, SimpleChanges, TemplateRef, ViewChild, ViewEncapsulation } from '@angular/core';
+import { Subject } from 'rxjs';
+import { DateRange, MAT_SINGLE_DATE_SELECTION_MODEL_PROVIDER } from './date-selection-model';
+import { createMissingDateImplError } from './datepicker-errors';
+import { MatDatepickerIntl } from './datepicker-intl';
+import { MatMonthView } from './month-view';
+import { getActiveOffset, isSameMultiYearView, MatMultiYearView, yearsPerPage } from './multi-year-view';
+import { DateAdapter } from './shared/adapter/date-adapter';
+import { MAT_DATE_FORMATS } from './shared/adapter/date-formats';
+import { MatYearView } from './year-view';
+/**
+ * A calendar that is used as part of the datepicker.
+ * @docs-private
+ */
+var MatCalendar = /** @class */ (function () {
+    function MatCalendar(_intl, _dateAdapter, _dateFormats, _changeDetectorRef) {
+        var _this = this;
+        this._dateAdapter = _dateAdapter;
+        this._dateFormats = _dateFormats;
+        this._changeDetectorRef = _changeDetectorRef;
+        this.matCalendarRef = this;
+        /**
+         * Used for scheduling that focus should be moved to the active cell on the next tick.
+         * We need to schedule it, rather than do it immediately, because we have to wait
+         * for Angular to re-evaluate the view children.
+         */
+        this._moveFocusOnNextTick = false;
+        /** Whether the calendar should be started in month or year view. */
+        this.startView = 'month';
+        /**
+         * Emits when the currently selected date changes.
+         * @breaking-change 11.0.0 Emitted value to change to `D | null`.
+         */
+        this.selectedChange = new EventEmitter();
+        /**
+         * Emits the year chosen in multiyear view.
+         * This doesn't imply a change on the selected date.
+         */
+        this.yearSelected = new EventEmitter();
+        /**
+         * Emits the month chosen in year view.
+         * This doesn't imply a change on the selected date.
+         */
+        this.monthSelected = new EventEmitter();
+        /** Emits when any date is selected. */
+        this._userSelection = new EventEmitter();
+        /**
+         * Emits whenever there is a state change that the header may need to respond to.
+         */
+        this.stateChanges = new Subject();
+        if (!this._dateAdapter) {
+            throw createMissingDateImplError('DateAdapter');
+        }
+        if (!this._dateFormats) {
+            throw createMissingDateImplError('MAT_DATE_FORMATS');
+        }
+        this._intlChanges = _intl.changes.subscribe(function () {
+            _changeDetectorRef.markForCheck();
+            _this.stateChanges.next();
+        });
+    }
+    Object.defineProperty(MatCalendar.prototype, "startAt", {
+        /** A date representing the period (month or year) to start the calendar in. */
+        get: function () { return this._startAt; },
+        set: function (value) {
+            this._startAt = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(MatCalendar.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));
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(MatCalendar.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(MatCalendar.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
+    });
+    Object.defineProperty(MatCalendar.prototype, "activeDate", {
+        /**
+         * The current active date. This determines which time period is shown and which date is
+         * highlighted when using keyboard navigation.
+         */
+        get: function () { return this._clampedActiveDate; },
+        set: function (value) {
+            this._clampedActiveDate = this._dateAdapter.clampDate(value, this.minDate, this.maxDate);
+            this.stateChanges.next();
+            this._changeDetectorRef.markForCheck();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(MatCalendar.prototype, "currentView", {
+        /** Whether the calendar is in month view. */
+        get: function () { return this._currentView; },
+        set: function (value) {
+            this._currentView = value;
+            this._moveFocusOnNextTick = true;
+            this._changeDetectorRef.markForCheck();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    MatCalendar.prototype.ngAfterContentInit = function () {
+        this.activeDate = this.startAt || this._dateAdapter.today();
+        // Assign to the private property since we don't want to move focus on init.
+        this._currentView = this.startView;
+    };
+    MatCalendar.prototype.ngAfterViewChecked = function () {
+        if (this._moveFocusOnNextTick) {
+            this._moveFocusOnNextTick = false;
+            this.focusActiveCell();
+        }
+    };
+    MatCalendar.prototype.ngOnDestroy = function () {
+        this._intlChanges.unsubscribe();
+        this.stateChanges.complete();
+    };
+    MatCalendar.prototype.ngOnChanges = function (changes) {
+        var change = changes['minDate'] || changes['maxDate'] || changes['dateFilter'];
+        if (change && !change.firstChange) {
+            var view = this._getCurrentViewComponent();
+            if (view) {
+                // We need to `detectChanges` manually here, because the `minDate`, `maxDate` etc. are
+                // passed down to the view via data bindings which won't be up-to-date when we call `_init`.
+                this._changeDetectorRef.detectChanges();
+                view._init();
+            }
+        }
+        this.stateChanges.next();
+    };
+    MatCalendar.prototype.focusActiveCell = function () {
+        this._getCurrentViewComponent()._focusActiveCell(false);
+    };
+    /** Updates today's date after an update of the active date */
+    MatCalendar.prototype.updateTodaysDate = function () {
+        var currentView = this.currentView;
+        var view;
+        if (currentView === 'month') {
+            view = this.monthView;
+        }
+        else if (currentView === 'year') {
+            view = this.yearView;
+        }
+        else {
+            view = this.multiYearView;
+        }
+        view._init();
+    };
+    /** Handles date selection in the month view. */
+    MatCalendar.prototype._dateSelected = function (event) {
+        var date = event.value;
+        if (this.selected instanceof DateRange || (date && !this._dateAdapter.sameDate(date, this.selected))) {
+            // @breaking-change 11.0.0 remove non-null assertion
+            // once the `selectedChange` is allowed to be null.
+            this.selectedChange.emit(date);
+        }
+        this._userSelection.emit(event);
+    };
+    /** Handles year selection in the multiyear view. */
+    MatCalendar.prototype._yearSelectedInMultiYearView = function (normalizedYear) {
+        this.yearSelected.emit(normalizedYear);
+    };
+    /** Handles month selection in the year view. */
+    MatCalendar.prototype._monthSelectedInYearView = function (normalizedMonth) {
+        this.monthSelected.emit(normalizedMonth);
+    };
+    /** Handles year/month selection in the multi-year/year views. */
+    MatCalendar.prototype._goToDateInView = function (date, view) {
+        this.activeDate = date;
+        this.currentView = view;
+    };
+    /** Returns the component instance that corresponds to the current calendar view. */
+    MatCalendar.prototype._getCurrentViewComponent = function () {
+        return this.monthView || this.yearView || this.multiYearView;
+    };
+    MatCalendar.ctorParameters = function () { return [
+        { type: MatDatepickerIntl },
+        { type: DateAdapter, decorators: [{ type: Optional }] },
+        { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [MAT_DATE_FORMATS,] }] },
+        { type: ChangeDetectorRef }
+    ]; };
+    __decorate([
+        Input(),
+        __metadata("design:type", TemplateRef)
+    ], MatCalendar.prototype, "templatePresetRange", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Object),
+        __metadata("design:paramtypes", [Object])
+    ], MatCalendar.prototype, "startAt", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], MatCalendar.prototype, "startView", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Object),
+        __metadata("design:paramtypes", [Object])
+    ], MatCalendar.prototype, "selected", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", Object),
+        __metadata("design:paramtypes", [Object])
+    ], MatCalendar.prototype, "minDate", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", Object),
+        __metadata("design:paramtypes", [Object])
+    ], MatCalendar.prototype, "maxDate", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", Function)
+    ], MatCalendar.prototype, "dateFilter", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Function)
+    ], MatCalendar.prototype, "dateClass", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Object)
+    ], MatCalendar.prototype, "comparisonStart", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Object)
+    ], MatCalendar.prototype, "comparisonEnd", void 0);
+    __decorate([
+        Output(),
+        __metadata("design:type", EventEmitter)
+    ], MatCalendar.prototype, "selectedChange", void 0);
+    __decorate([
+        Output(),
+        __metadata("design:type", EventEmitter)
+    ], MatCalendar.prototype, "yearSelected", void 0);
+    __decorate([
+        Output(),
+        __metadata("design:type", EventEmitter)
+    ], MatCalendar.prototype, "monthSelected", void 0);
+    __decorate([
+        Output(),
+        __metadata("design:type", EventEmitter)
+    ], MatCalendar.prototype, "_userSelection", void 0);
+    __decorate([
+        ViewChild(MatMonthView, { static: false }),
+        __metadata("design:type", MatMonthView)
+    ], MatCalendar.prototype, "monthView", void 0);
+    __decorate([
+        ViewChild(MatYearView, { static: false }),
+        __metadata("design:type", MatYearView)
+    ], MatCalendar.prototype, "yearView", void 0);
+    __decorate([
+        ViewChild(MatMultiYearView, { static: false }),
+        __metadata("design:type", MatMultiYearView)
+    ], MatCalendar.prototype, "multiYearView", void 0);
+    MatCalendar = __decorate([
+        Component({
+            selector: 'gipi-mat-calendar',
+            template: "<div class=\"gipi-mat-calendar-wrapper\">\n    <ng-container *ngIf=\"templatePresetRange\"\n                  [ngTemplateOutlet]=\"templatePresetRange\"\n                  [ngTemplateOutletContext]=\"{$implicit: matCalendarRef}\">\n    </ng-container>\n\n    <div class=\"gipi-mat-calendar-content\">\n        <!-- <ng-template [cdkPortalOutlet]=\"_calendarHeaderPortal\"> </ng-template> -->\n        <gipi-mat-calendar-header [matCalendar]=\"matCalendarRef\"> </gipi-mat-calendar-header>\n\n        <div class=\"mat-calendar-content\"\n             [ngSwitch]=\"currentView\"\n             cdkMonitorSubtreeFocus\n             tabindex=\"-1\">\n            <gipi-mat-month-view *ngSwitchCase=\"'month'\"\n                                 [(activeDate)]=\"activeDate\"\n                                 [selected]=\"selected\"\n                                 [dateFilter]=\"dateFilter\"\n                                 [maxDate]=\"maxDate\"\n                                 [minDate]=\"minDate\"\n                                 [dateClass]=\"dateClass\"\n                                 [comparisonStart]=\"comparisonStart\"\n                                 [comparisonEnd]=\"comparisonEnd\"\n                                 (_userSelection)=\"_dateSelected($event)\">\n            </gipi-mat-month-view>\n\n            <gipi-mat-year-view *ngSwitchCase=\"'year'\"\n                                [(activeDate)]=\"activeDate\"\n                                [selected]=\"selected\"\n                                [dateFilter]=\"dateFilter\"\n                                [maxDate]=\"maxDate\"\n                                [minDate]=\"minDate\"\n                                [dateClass]=\"dateClass\"\n                                (monthSelected)=\"_monthSelectedInYearView($event)\"\n                                (selectedChange)=\"_goToDateInView($event, 'month')\">\n            </gipi-mat-year-view>\n\n            <gipi-mat-multi-year-view *ngSwitchCase=\"'multi-year'\"\n                                      [(activeDate)]=\"activeDate\"\n                                      [selected]=\"selected\"\n                                      [dateFilter]=\"dateFilter\"\n                                      [maxDate]=\"maxDate\"\n                                      [minDate]=\"minDate\"\n                                      [dateClass]=\"dateClass\"\n                                      (yearSelected)=\"_yearSelectedInMultiYearView($event)\"\n                                      (selectedChange)=\"_goToDateInView($event, 'year')\">\n            </gipi-mat-multi-year-view>\n        </div>\n    </div>\n</div>",
+            host: {
+                'class': 'mat-calendar',
+            },
+            exportAs: 'gipiMatCalendar',
+            encapsulation: ViewEncapsulation.None,
+            changeDetection: ChangeDetectionStrategy.OnPush,
+            providers: [
+                MAT_SINGLE_DATE_SELECTION_MODEL_PROVIDER
+            ],
+            styles: [".mat-calendar{display:block}.mat-calendar-header{padding:8px 8px 0}.mat-calendar-content{padding:0 8px 8px;outline:0}.mat-calendar-controls{display:flex;margin:5% calc(33% / 7 - 16px)}.mat-calendar-controls .mat-icon-button:hover .mat-button-focus-overlay{opacity:.04}.mat-calendar-spacer{flex:1 1 auto}.mat-calendar-period-button{min-width:0}.mat-calendar-arrow{display:inline-block;width:0;height:0;border-left:5px solid transparent;border-right:5px solid transparent;border-top-width:5px;border-top-style:solid;margin:0 0 0 5px;vertical-align:middle}.mat-calendar-arrow.mat-calendar-invert{transform:rotate(180deg)}[dir=rtl] .mat-calendar-arrow{margin:0 5px 0 0}.mat-calendar-next-button,.mat-calendar-previous-button{position:relative}.mat-calendar-next-button::after,.mat-calendar-previous-button::after{top:0;left:0;right:0;bottom:0;position:absolute;content:'';margin:15.5px;border:0 solid currentColor;border-top-width:2px}[dir=rtl] .mat-calendar-next-button,[dir=rtl] .mat-calendar-previous-button{transform:rotate(180deg)}.mat-calendar-previous-button::after{border-left-width:2px;transform:translateX(2px) rotate(-45deg)}.mat-calendar-next-button::after{border-right-width:2px;transform:translateX(-2px) rotate(45deg)}.mat-calendar-table{border-spacing:0;border-collapse:collapse;width:100%}.mat-calendar-table-header th{text-align:center;padding:0 0 8px}.mat-calendar-table-header-divider{position:relative;height:1px}.mat-calendar-table-header-divider::after{content:'';position:absolute;top:0;left:-8px;right:-8px;height:1px}.gipi-mat-calendar-wrapper{display:flex;flex-direction:row}"]
+        }),
+        __param(1, Optional()),
+        __param(2, Optional()), __param(2, Inject(MAT_DATE_FORMATS)),
+        __metadata("design:paramtypes", [MatDatepickerIntl,
+            DateAdapter, Object, ChangeDetectorRef])
+    ], MatCalendar);
+    return MatCalendar;
+}());
+export { MatCalendar };
+/** Default header for MatCalendar */
+var MatCalendarHeader = /** @class */ (function () {
+    function MatCalendarHeader(_intl, _dateAdapter, _dateFormats, _changeDetectorRef) {
+        this._intl = _intl;
+        this._dateAdapter = _dateAdapter;
+        this._dateFormats = _dateFormats;
+        this._changeDetectorRef = _changeDetectorRef;
+    }
+    MatCalendarHeader.prototype.ngAfterViewInit = function () {
+        var _this = this;
+        this.matCalendar.stateChanges.subscribe(function () { return _this._changeDetectorRef.markForCheck(); });
+    };
+    Object.defineProperty(MatCalendarHeader.prototype, "periodButtonText", {
+        /** The label for the current matCalendar view. */
+        get: function () {
+            if (this.matCalendar.currentView == 'month') {
+                return this._dateAdapter
+                    .format(this.matCalendar.activeDate, this._dateFormats.display.monthYearLabel)
+                    .toLocaleUpperCase();
+            }
+            if (this.matCalendar.currentView == 'year') {
+                return this._dateAdapter.getYearName(this.matCalendar.activeDate);
+            }
+            // The offset from the active year to the "slot" for the starting year is the
+            // *actual* first rendered year in the multi-year view, and the last year is
+            // just yearsPerPage - 1 away.
+            var activeYear = this._dateAdapter.getYear(this.matCalendar.activeDate);
+            var minYearOfPage = activeYear - getActiveOffset(this._dateAdapter, this.matCalendar.activeDate, this.matCalendar.minDate, this.matCalendar.maxDate);
+            var maxYearOfPage = minYearOfPage + yearsPerPage - 1;
+            var minYearName = this._dateAdapter.getYearName(this._dateAdapter.createDate(minYearOfPage, 0, 1));
+            var maxYearName = this._dateAdapter.getYearName(this._dateAdapter.createDate(maxYearOfPage, 0, 1));
+            return this._intl.formatYearRange(minYearName, maxYearName);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(MatCalendarHeader.prototype, "periodButtonLabel", {
+        get: function () {
+            return this.matCalendar.currentView == 'month' ? this._intl.switchToMultiYearViewLabel : this._intl.switchToMonthViewLabel;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(MatCalendarHeader.prototype, "prevButtonLabel", {
+        /** The label for the previous button. */
+        get: function () {
+            return {
+                'month': this._intl.prevMonthLabel,
+                'year': this._intl.prevYearLabel,
+                'multi-year': this._intl.prevMultiYearLabel
+            }[this.matCalendar.currentView];
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(MatCalendarHeader.prototype, "nextButtonLabel", {
+        /** The label for the next button. */
+        get: function () {
+            return {
+                'month': this._intl.nextMonthLabel,
+                'year': this._intl.nextYearLabel,
+                'multi-year': this._intl.nextMultiYearLabel
+            }[this.matCalendar.currentView];
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /** Handles user clicks on the period label. */
+    MatCalendarHeader.prototype.currentPeriodClicked = function () {
+        this.matCalendar.currentView = this.matCalendar.currentView == 'month' ? 'multi-year' : 'month';
+    };
+    /** Handles user clicks on the previous button. */
+    MatCalendarHeader.prototype.previousClicked = function () {
+        this.matCalendar.activeDate = this.matCalendar.currentView == 'month'
+            ? this._dateAdapter.addCalendarMonths(this.matCalendar.activeDate, -1)
+            : this._dateAdapter.addCalendarYears(this.matCalendar.activeDate, this.matCalendar.currentView == 'year' ? -1 : -yearsPerPage);
+    };
+    /** Handles user clicks on the next button. */
+    MatCalendarHeader.prototype.nextClicked = function () {
+        this.matCalendar.activeDate = this.matCalendar.currentView == 'month'
+            ? this._dateAdapter.addCalendarMonths(this.matCalendar.activeDate, 1)
+            : this._dateAdapter.addCalendarYears(this.matCalendar.activeDate, this.matCalendar.currentView == 'year' ? 1 : yearsPerPage);
+    };
+    /** Whether the previous period button is enabled. */
+    MatCalendarHeader.prototype.previousEnabled = function () {
+        if (!this.matCalendar.minDate) {
+            return true;
+        }
+        return !this.matCalendar.minDate || !this._isSameView(this.matCalendar.activeDate, this.matCalendar.minDate);
+    };
+    /** Whether the next period button is enabled. */
+    MatCalendarHeader.prototype.nextEnabled = function () {
+        return !this.matCalendar.maxDate || !this._isSameView(this.matCalendar.activeDate, this.matCalendar.maxDate);
+    };
+    /** Whether the two dates represent the same view in the current view mode (month or year). */
+    MatCalendarHeader.prototype._isSameView = function (date1, date2) {
+        if (this.matCalendar.currentView == 'month') {
+            return this._dateAdapter.getYear(date1) == this._dateAdapter.getYear(date2) && this._dateAdapter.getMonth(date1) == this._dateAdapter.getMonth(date2);
+        }
+        if (this.matCalendar.currentView == 'year') {
+            return this._dateAdapter.getYear(date1) == this._dateAdapter.getYear(date2);
+        }
+        // Otherwise we are in 'multi-year' view.
+        return isSameMultiYearView(this._dateAdapter, date1, date2, this.matCalendar.minDate, this.matCalendar.maxDate);
+    };
+    MatCalendarHeader.ctorParameters = function () { return [
+        { type: MatDatepickerIntl },
+        { type: DateAdapter, decorators: [{ type: Optional }] },
+        { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [MAT_DATE_FORMATS,] }] },
+        { type: ChangeDetectorRef }
+    ]; };
+    __decorate([
+        Input(),
+        __metadata("design:type", MatCalendar)
+    ], MatCalendarHeader.prototype, "matCalendar", void 0);
+    MatCalendarHeader = __decorate([
+        Component({
+            selector: 'gipi-mat-calendar-header',
+            template: "<div class=\"mat-calendar-header\">\n    <div class=\"mat-calendar-controls\">\n        <button mat-button\n                type=\"button\"\n                class=\"mat-calendar-period-button\"\n                (click)=\"currentPeriodClicked()\"\n                [attr.aria-label]=\"periodButtonLabel\"\n                cdkAriaLive=\"polite\">\n            {{ periodButtonText }}\n            <div class=\"mat-calendar-arrow\"\n                 [class.mat-calendar-invert]=\"matCalendar.currentView != 'month'\">\n            </div>\n        </button>\n\n        <div class=\"mat-calendar-spacer\"> </div>\n\n        <ng-content> </ng-content>\n\n        <button mat-icon-button\n                type=\"button\"\n                class=\"mat-calendar-previous-button\"\n                [disabled]=\"!previousEnabled()\"\n                (click)=\"previousClicked()\"\n                [attr.aria-label]=\"prevButtonLabel\">\n        </button>\n\n        <button mat-icon-button\n                type=\"button\"\n                class=\"mat-calendar-next-button\"\n                [disabled]=\"!nextEnabled()\"\n                (click)=\"nextClicked()\"\n                [attr.aria-label]=\"nextButtonLabel\">\n        </button>\n    </div>\n</div>",
+            exportAs: 'gipiMatCalendarHeader',
+            encapsulation: ViewEncapsulation.None,
+            changeDetection: ChangeDetectionStrategy.OnPush
+        }),
+        __param(1, Optional()),
+        __param(2, Optional()), __param(2, Inject(MAT_DATE_FORMATS)),
+        __metadata("design:paramtypes", [MatDatepickerIntl,
+            DateAdapter, Object, ChangeDetectorRef])
+    ], MatCalendarHeader);
+    return MatCalendarHeader;
+}());
+export { MatCalendarHeader };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"calendar.js","sourceRoot":"ng://@gipisistemas/ng-core/","sources":["shared/gipi-components/datepicker/mat-datepicker/calendar.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 { AfterContentInit, AfterViewChecked, AfterViewInit, ChangeDetectionStrategy, ChangeDetectorRef, Component, EventEmitter, Inject, Input, OnChanges, OnDestroy, Optional, Output, SimpleChanges, TemplateRef, ViewChild, ViewEncapsulation } from '@angular/core';\nimport { Subject, Subscription } from 'rxjs';\nimport { MatCalendarCellClassFunction, MatCalendarUserEvent } from './calendar-body';\nimport { DateRange, MAT_SINGLE_DATE_SELECTION_MODEL_PROVIDER } from './date-selection-model';\nimport { createMissingDateImplError } from './datepicker-errors';\nimport { MatDatepickerIntl } from './datepicker-intl';\nimport { MatMonthView } from './month-view';\nimport { getActiveOffset, isSameMultiYearView, MatMultiYearView, yearsPerPage } from './multi-year-view';\nimport { DateAdapter } from './shared/adapter/date-adapter';\nimport { MAT_DATE_FORMATS, MatDateFormats } from './shared/adapter/date-formats';\nimport { MatYearView } from './year-view';\n\n/**\n * Possible views for the calendar.\n * @docs-private\n */\nexport type MatCalendarView = 'month' | 'year' | 'multi-year';\n\n/**\n * A calendar that is used as part of the datepicker.\n * @docs-private\n */\n@Component({\n    selector: 'gipi-mat-calendar',\n    templateUrl: 'calendar.html',\n    styleUrls: ['calendar.scss'],\n    host: {\n        'class': 'mat-calendar',\n    },\n    exportAs: 'gipiMatCalendar',\n    encapsulation: ViewEncapsulation.None,\n    changeDetection: ChangeDetectionStrategy.OnPush,\n    providers: [\n        MAT_SINGLE_DATE_SELECTION_MODEL_PROVIDER\n    ]\n})\nexport class MatCalendar<D> implements AfterContentInit, AfterViewChecked, OnDestroy, OnChanges {\n\n    public matCalendarRef: MatCalendar<D> = this;\n\n    /** Created by GIPI Sistemas */\n    @Input() templatePresetRange: TemplateRef<any>;\n\n    private _intlChanges: Subscription;\n\n    /**\n     * Used for scheduling that focus should be moved to the active cell on the next tick.\n     * We need to schedule it, rather than do it immediately, because we have to wait\n     * for Angular to re-evaluate the view children.\n     */\n    private _moveFocusOnNextTick = false;\n\n    /** A date representing the period (month or year) to start the calendar in. */\n    @Input()\n    get startAt(): D | null { return this._startAt; }\n    set startAt(value: D | null) {\n        this._startAt = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));\n    }\n    private _startAt: D | null;\n\n    /** Whether the calendar should be started in month or year view. */\n    @Input() startView: MatCalendarView = 'month';\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    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    /** 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 dates. */\n    @Input() dateClass: MatCalendarCellClassFunction<D>;\n\n    /** Start of the comparison range. */\n    @Input() comparisonStart: D | null;\n\n    /** End of the comparison range. */\n    @Input() comparisonEnd: D | null;\n\n    /**\n     * Emits when the currently selected date changes.\n     * @breaking-change 11.0.0 Emitted value to change to `D | null`.\n     */\n    @Output() readonly selectedChange: EventEmitter<D> = new EventEmitter<D>();\n\n    /**\n     * Emits the year chosen in multiyear view.\n     * This doesn't imply a change on the selected date.\n     */\n    @Output() readonly yearSelected: EventEmitter<D> = new EventEmitter<D>();\n\n    /**\n     * Emits the month chosen in year view.\n     * This doesn't imply a change on the selected date.\n     */\n    @Output() readonly monthSelected: EventEmitter<D> = new EventEmitter<D>();\n\n    /** Emits when any date is selected. */\n    @Output() readonly _userSelection: EventEmitter<MatCalendarUserEvent<D | null>> = new EventEmitter<MatCalendarUserEvent<D | null>>();\n\n    /** Reference to the current month view component. */\n    @ViewChild(MatMonthView, { static: false }) monthView: MatMonthView<D>;\n\n    /** Reference to the current year view component. */\n    @ViewChild(MatYearView, { static: false }) yearView: MatYearView<D>;\n\n    /** Reference to the current multi-year view component. */\n    @ViewChild(MatMultiYearView, { static: false }) multiYearView: MatMultiYearView<D>;\n\n    /**\n     * The current active date. This determines which time period is shown and which date is\n     * highlighted when using keyboard navigation.\n     */\n    get activeDate(): D { return this._clampedActiveDate; }\n    set activeDate(value: D) {\n        this._clampedActiveDate = this._dateAdapter.clampDate(value, this.minDate, this.maxDate);\n        this.stateChanges.next();\n        this._changeDetectorRef.markForCheck();\n    }\n    private _clampedActiveDate: D;\n\n    /** Whether the calendar is in month view. */\n    get currentView(): MatCalendarView { return this._currentView; }\n    set currentView(value: MatCalendarView) {\n        this._currentView = value;\n        this._moveFocusOnNextTick = true;\n        this._changeDetectorRef.markForCheck();\n    }\n    private _currentView: MatCalendarView;\n\n    /**\n     * Emits whenever there is a state change that the header may need to respond to.\n     */\n    stateChanges = new Subject<void>();\n\n    constructor(\n        _intl: MatDatepickerIntl,\n        @Optional() private _dateAdapter: DateAdapter<D>,\n        @Optional() @Inject(MAT_DATE_FORMATS) private _dateFormats: MatDateFormats,\n        private _changeDetectorRef: ChangeDetectorRef\n    ) {\n        if (!this._dateAdapter) {\n            throw createMissingDateImplError('DateAdapter');\n        }\n\n        if (!this._dateFormats) {\n            throw createMissingDateImplError('MAT_DATE_FORMATS');\n        }\n\n        this._intlChanges = _intl.changes.subscribe(() => {\n            _changeDetectorRef.markForCheck();\n            this.stateChanges.next();\n        });\n    }\n\n    ngAfterContentInit() {\n        this.activeDate = this.startAt || this._dateAdapter.today();\n\n        // Assign to the private property since we don't want to move focus on init.\n        this._currentView = this.startView;\n    }\n\n    ngAfterViewChecked() {\n        if (this._moveFocusOnNextTick) {\n            this._moveFocusOnNextTick = false;\n            this.focusActiveCell();\n        }\n    }\n\n    ngOnDestroy() {\n        this._intlChanges.unsubscribe();\n        this.stateChanges.complete();\n    }\n\n    ngOnChanges(changes: SimpleChanges) {\n        const change = changes['minDate'] || changes['maxDate'] || changes['dateFilter'];\n\n        if (change && !change.firstChange) {\n            const view = this._getCurrentViewComponent();\n\n            if (view) {\n                // We need to `detectChanges` manually here, because the `minDate`, `maxDate` etc. are\n                // passed down to the view via data bindings which won't be up-to-date when we call `_init`.\n                this._changeDetectorRef.detectChanges();\n                view._init();\n            }\n        }\n\n        this.stateChanges.next();\n    }\n\n    focusActiveCell() {\n        this._getCurrentViewComponent()._focusActiveCell(false);\n    }\n\n    /** Updates today's date after an update of the active date */\n    updateTodaysDate() {\n        const currentView = this.currentView;\n        let view: MatMonthView<D> | MatYearView<D> | MatMultiYearView<D>;\n\n        if (currentView === 'month') {\n            view = this.monthView;\n        } else if (currentView === 'year') {\n            view = this.yearView;\n        } else {\n            view = this.multiYearView;\n        }\n\n        view._init();\n    }\n\n    /** Handles date selection in the month view. */\n    _dateSelected(event: MatCalendarUserEvent<D | null>): void {\n        const date = event.value;\n\n        if (this.selected instanceof DateRange || (date && !this._dateAdapter.sameDate(date, this.selected))) {\n            // @breaking-change 11.0.0 remove non-null assertion\n            // once the `selectedChange` is allowed to be null.\n            this.selectedChange.emit(date!);\n        }\n\n        this._userSelection.emit(event);\n    }\n\n    /** Handles year selection in the multiyear view. */\n    _yearSelectedInMultiYearView(normalizedYear: D) {\n        this.yearSelected.emit(normalizedYear);\n    }\n\n    /** Handles month selection in the year view. */\n    _monthSelectedInYearView(normalizedMonth: D) {\n        this.monthSelected.emit(normalizedMonth);\n    }\n\n    /** Handles year/month selection in the multi-year/year views. */\n    _goToDateInView(date: D, view: 'month' | 'year' | 'multi-year'): void {\n        this.activeDate = date;\n        this.currentView = view;\n    }\n\n    /** Returns the component instance that corresponds to the current calendar view. */\n    private _getCurrentViewComponent() {\n        return this.monthView || this.yearView || this.multiYearView;\n    }\n}\n\n/** Default header for MatCalendar */\n@Component({\n    selector: 'gipi-mat-calendar-header',\n    templateUrl: 'calendar-header.html',\n    exportAs: 'gipiMatCalendarHeader',\n    encapsulation: ViewEncapsulation.None,\n    changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class MatCalendarHeader<D> implements AfterViewInit {\n\n    @Input() matCalendar: MatCalendar<D>;\n\n    constructor(\n        private _intl: MatDatepickerIntl,\n        @Optional() private _dateAdapter: DateAdapter<D>,\n        @Optional() @Inject(MAT_DATE_FORMATS) private _dateFormats: MatDateFormats,\n        private _changeDetectorRef: ChangeDetectorRef,\n    ) { }\n\n    ngAfterViewInit(): void {\n        this.matCalendar.stateChanges.subscribe(() => this._changeDetectorRef.markForCheck());\n    }\n\n    /** The label for the current matCalendar view. */\n    get periodButtonText(): string {\n        if (this.matCalendar.currentView == 'month') {\n            return this._dateAdapter\n                .format(this.matCalendar.activeDate, this._dateFormats.display.monthYearLabel)\n                .toLocaleUpperCase();\n        }\n        if (this.matCalendar.currentView == 'year') {\n            return this._dateAdapter.getYearName(this.matCalendar.activeDate);\n        }\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, and the last year is\n        // just yearsPerPage - 1 away.\n        const activeYear = this._dateAdapter.getYear(this.matCalendar.activeDate);\n        const minYearOfPage = activeYear - getActiveOffset(this._dateAdapter, this.matCalendar.activeDate, this.matCalendar.minDate, this.matCalendar.maxDate);\n        const maxYearOfPage = minYearOfPage + yearsPerPage - 1;\n        const minYearName = this._dateAdapter.getYearName(this._dateAdapter.createDate(minYearOfPage, 0, 1));\n        const maxYearName = this._dateAdapter.getYearName(this._dateAdapter.createDate(maxYearOfPage, 0, 1));\n        return this._intl.formatYearRange(minYearName, maxYearName);\n    }\n\n    get periodButtonLabel(): string {\n        return this.matCalendar.currentView == 'month' ? this._intl.switchToMultiYearViewLabel : this._intl.switchToMonthViewLabel;\n    }\n\n    /** The label for the previous button. */\n    get prevButtonLabel(): string {\n        return {\n            'month': this._intl.prevMonthLabel,\n            'year': this._intl.prevYearLabel,\n            'multi-year': this._intl.prevMultiYearLabel\n        }[this.matCalendar.currentView];\n    }\n\n    /** The label for the next button. */\n    get nextButtonLabel(): string {\n        return {\n            'month': this._intl.nextMonthLabel,\n            'year': this._intl.nextYearLabel,\n            'multi-year': this._intl.nextMultiYearLabel\n        }[this.matCalendar.currentView];\n    }\n\n    /** Handles user clicks on the period label. */\n    currentPeriodClicked(): void {\n        this.matCalendar.currentView = this.matCalendar.currentView == 'month' ? 'multi-year' : 'month';\n    }\n\n    /** Handles user clicks on the previous button. */\n    previousClicked(): void {\n        this.matCalendar.activeDate = this.matCalendar.currentView == 'month'\n            ? this._dateAdapter.addCalendarMonths(this.matCalendar.activeDate, -1)\n            : this._dateAdapter.addCalendarYears(this.matCalendar.activeDate, this.matCalendar.currentView == 'year' ? -1 : -yearsPerPage);\n    }\n\n    /** Handles user clicks on the next button. */\n    nextClicked(): void {\n        this.matCalendar.activeDate = this.matCalendar.currentView == 'month'\n            ? this._dateAdapter.addCalendarMonths(this.matCalendar.activeDate, 1)\n            : this._dateAdapter.addCalendarYears(this.matCalendar.activeDate, this.matCalendar.currentView == 'year' ? 1 : yearsPerPage);\n    }\n\n    /** Whether the previous period button is enabled. */\n    previousEnabled(): boolean {\n        if (!this.matCalendar.minDate) {\n            return true;\n        }\n        return !this.matCalendar.minDate || !this._isSameView(this.matCalendar.activeDate, this.matCalendar.minDate);\n    }\n\n    /** Whether the next period button is enabled. */\n    nextEnabled(): boolean {\n        return !this.matCalendar.maxDate || !this._isSameView(this.matCalendar.activeDate, this.matCalendar.maxDate);\n    }\n\n    /** Whether the two dates represent the same view in the current view mode (month or year). */\n    private _isSameView(date1: D, date2: D): boolean {\n        if (this.matCalendar.currentView == 'month') {\n            return this._dateAdapter.getYear(date1) == this._dateAdapter.getYear(date2) && this._dateAdapter.getMonth(date1) == this._dateAdapter.getMonth(date2);\n        }\n        if (this.matCalendar.currentView == 'year') {\n            return this._dateAdapter.getYear(date1) == this._dateAdapter.getYear(date2);\n        }\n        // Otherwise we are in 'multi-year' view.\n        return isSameMultiYearView(this._dateAdapter, date1, date2, this.matCalendar.minDate, this.matCalendar.maxDate);\n    }\n}\n"]}