@gipisistemas/ng-core 1.0.67 → 1.0.68

package/esm2015/shared/gipi-components/datepicker/mat-datepicker/datepicker-toggle.js

@@ -0,0 +1,124 @@
+/**
+ * @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, Attribute, ChangeDetectionStrategy, ChangeDetectorRef, Component, ContentChild, Directive, Input, OnChanges, OnDestroy, SimpleChanges, ViewChild, ViewEncapsulation, } from '@angular/core';
+import { MatButton } from '@angular/material/button';
+import { merge, of as observableOf, Subscription } from 'rxjs';
+import { MatDatepickerBase } from './datepicker-base';
+import { MatDatepickerIntl } from './datepicker-intl';
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+/** Can be used to override the icon of a `matDatepickerToggle`. */
+let MatDatepickerToggleIcon = class MatDatepickerToggleIcon {
+};
+MatDatepickerToggleIcon = __decorate([
+    Directive({ selector: '[gipiDatepickerToggleIcon]' })
+], MatDatepickerToggleIcon);
+export { MatDatepickerToggleIcon };
+let MatDatepickerToggle = class MatDatepickerToggle {
+    constructor(_intl, _changeDetectorRef, defaultTabIndex) {
+        this._intl = _intl;
+        this._changeDetectorRef = _changeDetectorRef;
+        this._stateChanges = Subscription.EMPTY;
+        const parsedTabIndex = Number(defaultTabIndex);
+        this.tabIndex = (parsedTabIndex || parsedTabIndex === 0) ? parsedTabIndex : null;
+    }
+    /** Whether the toggle button is disabled. */
+    get disabled() {
+        if (this._disabled === undefined && this.datepicker) {
+            return this.datepicker.disabled;
+        }
+        return !!this._disabled;
+    }
+    set disabled(value) {
+        this._disabled = coerceBooleanProperty(value);
+    }
+    ngOnChanges(changes) {
+        if (changes['datepicker']) {
+            this._watchStateChanges();
+        }
+    }
+    ngOnDestroy() {
+        this._stateChanges.unsubscribe();
+    }
+    ngAfterContentInit() {
+        this._watchStateChanges();
+    }
+    _open(event) {
+        if (this.datepicker && !this.disabled) {
+            this.datepicker.open();
+            event.stopPropagation();
+        }
+    }
+    _watchStateChanges() {
+        const datepickerStateChanged = this.datepicker ? this.datepicker._stateChanges : observableOf();
+        const inputStateChanged = this.datepicker && this.datepicker._datepickerInput ?
+            this.datepicker._datepickerInput.stateChanges : observableOf();
+        const datepickerToggled = this.datepicker ?
+            merge(this.datepicker.openedStream, this.datepicker.closedStream) :
+            observableOf();
+        this._stateChanges.unsubscribe();
+        this._stateChanges = merge(this._intl.changes, datepickerStateChanged, inputStateChanged, datepickerToggled).subscribe(() => this._changeDetectorRef.markForCheck());
+    }
+};
+MatDatepickerToggle.ctorParameters = () => [
+    { type: MatDatepickerIntl },
+    { type: ChangeDetectorRef },
+    { type: String, decorators: [{ type: Attribute, args: ['tabindex',] }] }
+];
+__decorate([
+    Input('for'),
+    __metadata("design:type", MatDatepickerBase)
+], MatDatepickerToggle.prototype, "datepicker", void 0);
+__decorate([
+    Input(),
+    __metadata("design:type", Number)
+], MatDatepickerToggle.prototype, "tabIndex", void 0);
+__decorate([
+    Input(),
+    __metadata("design:type", Boolean),
+    __metadata("design:paramtypes", [Boolean])
+], MatDatepickerToggle.prototype, "disabled", null);
+__decorate([
+    Input(),
+    __metadata("design:type", Boolean)
+], MatDatepickerToggle.prototype, "disableRipple", void 0);
+__decorate([
+    ContentChild(MatDatepickerToggleIcon, { static: true }),
+    __metadata("design:type", MatDatepickerToggleIcon)
+], MatDatepickerToggle.prototype, "_customIcon", void 0);
+__decorate([
+    ViewChild('button', { static: true }),
+    __metadata("design:type", MatButton)
+], MatDatepickerToggle.prototype, "_button", void 0);
+MatDatepickerToggle = __decorate([
+    Component({
+        selector: 'gipi-mat-datepicker-toggle',
+        template: "<button #button\n        mat-icon-button\n        type=\"button\"\n        [attr.aria-haspopup]=\"datepicker ? 'dialog' : null\"\n        [attr.aria-label]=\"_intl.openCalendarLabel\"\n        [attr.tabindex]=\"disabled ? -1 : tabIndex\"\n        [disabled]=\"disabled\"\n        [disableRipple]=\"disableRipple\"\n        (click)=\"_open($event)\">\n\n    <svg *ngIf=\"!_customIcon\"\n         class=\"mat-datepicker-toggle-default-icon\"\n         viewBox=\"0 0 24 24\"\n         width=\"24px\"\n         height=\"24px\"\n         fill=\"currentColor\"\n         focusable=\"false\">\n        <path\n              d=\"M19 3h-1V1h-2v2H8V1H6v2H5c-1.11 0-1.99.9-1.99 2L3 19c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16H5V8h14v11zM7 10h5v5H7z\" />\n    </svg>\n\n    <ng-content select=\"[gipiMatDatepickerToggleIcon]\"> </ng-content>\n</button>",
+        host: {
+            'class': 'mat-datepicker-toggle',
+            // Always set the tabindex to -1 so that it doesn't overlap with any custom tabindex the
+            // consumer may have provided, while still being able to receive focus.
+            '[attr.tabindex]': 'disabled ? null : -1',
+            '[class.mat-datepicker-toggle-active]': 'datepicker && datepicker.opened',
+            '[class.mat-accent]': 'datepicker && datepicker.color === "accent"',
+            '[class.mat-warn]': 'datepicker && datepicker.color === "warn"',
+            // Used by the test harness to tie this toggle to its datepicker.
+            '[attr.data-mat-calendar]': 'datepicker ? datepicker.id : null',
+            '(focus)': '_button.focus()',
+        },
+        exportAs: 'gipiMatDatepickerToggle',
+        encapsulation: ViewEncapsulation.None,
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        styles: [".mat-form-field-appearance-legacy .mat-form-field-prefix .mat-datepicker-toggle-default-icon,.mat-form-field-appearance-legacy .mat-form-field-suffix .mat-datepicker-toggle-default-icon{width:1em}.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-prefix .mat-datepicker-toggle-default-icon,.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-suffix .mat-datepicker-toggle-default-icon{display:block;width:1.5em;height:1.5em}.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-prefix .mat-icon-button .mat-datepicker-toggle-default-icon,.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-suffix .mat-icon-button .mat-datepicker-toggle-default-icon{margin:auto}"]
+    }),
+    __param(2, Attribute('tabindex')),
+    __metadata("design:paramtypes", [MatDatepickerIntl,
+        ChangeDetectorRef, String])
+], MatDatepickerToggle);
+export { MatDatepickerToggle };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"datepicker-toggle.js","sourceRoot":"ng://@gipisistemas/ng-core/","sources":["shared/gipi-components/datepicker/mat-datepicker/datepicker-toggle.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, Attribute, ChangeDetectionStrategy, ChangeDetectorRef, Component, ContentChild, Directive, Input, OnChanges, OnDestroy, SimpleChanges, ViewChild, ViewEncapsulation, } from '@angular/core';\nimport { MatButton } from '@angular/material/button';\nimport { merge, of as observableOf, Subscription } from 'rxjs';\nimport { MatDatepickerBase, MatDatepickerControl } from './datepicker-base';\nimport { MatDatepickerIntl } from './datepicker-intl';\nimport { coerceBooleanProperty } from '@angular/cdk/coercion';\n\n/** Can be used to override the icon of a `matDatepickerToggle`. */\n@Directive({ selector: '[gipiDatepickerToggleIcon]' })\nexport class MatDatepickerToggleIcon { }\n\n@Component({\n    selector: 'gipi-mat-datepicker-toggle',\n    templateUrl: 'datepicker-toggle.html',\n    styleUrls: ['datepicker-toggle.scss'],\n    host: {\n        'class': 'mat-datepicker-toggle',\n        // Always set the tabindex to -1 so that it doesn't overlap with any custom tabindex the\n        // consumer may have provided, while still being able to receive focus.\n        '[attr.tabindex]': 'disabled ? null : -1',\n        '[class.mat-datepicker-toggle-active]': 'datepicker && datepicker.opened',\n        '[class.mat-accent]': 'datepicker && datepicker.color === \"accent\"',\n        '[class.mat-warn]': 'datepicker && datepicker.color === \"warn\"',\n        // Used by the test harness to tie this toggle to its datepicker.\n        '[attr.data-mat-calendar]': 'datepicker ? datepicker.id : null',\n        '(focus)': '_button.focus()',\n    },\n    exportAs: 'gipiMatDatepickerToggle',\n    encapsulation: ViewEncapsulation.None,\n    changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class MatDatepickerToggle<D> implements AfterContentInit, OnChanges, OnDestroy {\n\n    private _stateChanges = Subscription.EMPTY;\n\n    /** Datepicker instance that the button will toggle. */\n    @Input('for') datepicker: MatDatepickerBase<MatDatepickerControl<any>, D>;\n\n    /** Tabindex for the toggle. */\n    @Input() tabIndex: number | null;\n\n    /** Whether the toggle button is disabled. */\n    @Input()\n    get disabled(): boolean {\n        if (this._disabled === undefined && this.datepicker) {\n            return this.datepicker.disabled;\n        }\n\n        return !!this._disabled;\n    }\n    set disabled(value: boolean) {\n        this._disabled = coerceBooleanProperty(value);\n    }\n    private _disabled: boolean;\n\n    /** Whether ripples on the toggle should be disabled. */\n    @Input() disableRipple: boolean;\n\n    /** Custom icon set by the consumer. */\n    @ContentChild(MatDatepickerToggleIcon, { static: true }) _customIcon: MatDatepickerToggleIcon;\n\n    /** Underlying button element. */\n    @ViewChild('button', { static: true }) _button: MatButton;\n\n    constructor(\n        public _intl: MatDatepickerIntl,\n        private _changeDetectorRef: ChangeDetectorRef,\n        @Attribute('tabindex') defaultTabIndex: string\n    ) {\n\n        const parsedTabIndex = Number(defaultTabIndex);\n        this.tabIndex = (parsedTabIndex || parsedTabIndex === 0) ? parsedTabIndex : null;\n    }\n\n    ngOnChanges(changes: SimpleChanges) {\n        if (changes['datepicker']) {\n            this._watchStateChanges();\n        }\n    }\n\n    ngOnDestroy() {\n        this._stateChanges.unsubscribe();\n    }\n\n    ngAfterContentInit() {\n        this._watchStateChanges();\n    }\n\n    _open(event: Event): void {\n        if (this.datepicker && !this.disabled) {\n            this.datepicker.open();\n            event.stopPropagation();\n        }\n    }\n\n    private _watchStateChanges() {\n        const datepickerStateChanged = this.datepicker ? this.datepicker._stateChanges : observableOf();\n        const inputStateChanged = this.datepicker && this.datepicker._datepickerInput ?\n            this.datepicker._datepickerInput.stateChanges : observableOf();\n        const datepickerToggled = this.datepicker ?\n            merge(this.datepicker.openedStream, this.datepicker.closedStream) :\n            observableOf();\n\n        this._stateChanges.unsubscribe();\n        this._stateChanges = merge(\n            this._intl.changes,\n            datepickerStateChanged,\n            inputStateChanged,\n            datepickerToggled\n        ).subscribe(() => this._changeDetectorRef.markForCheck());\n    }\n\n\n}\n"]}

package/esm2015/shared/gipi-components/datepicker/mat-datepicker/datepicker.js

@@ -0,0 +1,29 @@
+/**
+ * @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 } from "tslib";
+import { ChangeDetectionStrategy, Component, ViewEncapsulation } from '@angular/core';
+import { MAT_SINGLE_DATE_SELECTION_MODEL_PROVIDER } from './date-selection-model';
+import { MatDatepickerBase } from './datepicker-base';
+// TODO(mmalerba): We use a component instead of a directive here so the user can use implicit
+// template reference variables (e.g. #d vs #d="matDatepicker"). We can change this to a directive
+// if angular adds support for `exportAs: '$implicit'` on directives.
+/** Component responsible for managing the datepicker popup/dialog. */
+let MatDatepicker = class MatDatepicker extends MatDatepickerBase {
+};
+MatDatepicker = __decorate([
+    Component({
+        selector: 'gipi-mat-datepicker',
+        template: '',
+        exportAs: 'gipiMatDatepicker',
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        encapsulation: ViewEncapsulation.None,
+        providers: [MAT_SINGLE_DATE_SELECTION_MODEL_PROVIDER]
+    })
+], MatDatepicker);
+export { MatDatepicker };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/shared/gipi-components/datepicker/mat-datepicker/month-view.js

@@ -0,0 +1,365 @@
+/**
+ * @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, ESCAPE, HOME, LEFT_ARROW, PAGE_DOWN, PAGE_UP, RIGHT_ARROW, SPACE, UP_ARROW, } from '@angular/cdk/keycodes';
+import { AfterContentInit, ChangeDetectionStrategy, ChangeDetectorRef, Component, EventEmitter, Inject, Input, OnChanges, OnDestroy, Optional, Output, SimpleChanges, 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 { MAT_DATE_RANGE_SELECTION_STRATEGY, } from './date-range-selection-strategy';
+import { DateRange } from './date-selection-model';
+import { createMissingDateImplError } from './datepicker-errors';
+import { DateAdapter } from './shared/adapter/date-adapter';
+const DAYS_PER_WEEK = 7;
+/**
+ * An internal component used to display a single month in the datepicker.
+ * @docs-private
+ */
+let MatMonthView = class MatMonthView {
+    constructor(_changeDetectorRef, _dateFormats, _dateAdapter, _dir, _rangeStrategy) {
+        this._changeDetectorRef = _changeDetectorRef;
+        this._dateFormats = _dateFormats;
+        this._dateAdapter = _dateAdapter;
+        this._dir = _dir;
+        this._rangeStrategy = _rangeStrategy;
+        this._rerenderSubscription = Subscription.EMPTY;
+        /** Emits when a new date is selected. */
+        this.selectedChange = new EventEmitter();
+        /** Emits when any date is selected. */
+        this._userSelection = 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();
+    }
+    /**
+     * The date to display in this month view (everything other than the month and year is ignored).
+     */
+    get activeDate() { return this._activeDate; }
+    set activeDate(value) {
+        const oldActiveDate = this._activeDate;
+        const validDate = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value)) || this._dateAdapter.today();
+        this._activeDate = this._dateAdapter.clampDate(validDate, this.minDate, this.maxDate);
+        if (!this._hasSameMonthAndYear(oldActiveDate, this._activeDate)) {
+            this._init();
+        }
+    }
+    /** The currently selected date. */
+    get selected() { return this._selected; }
+    set selected(value) {
+        if (value instanceof DateRange) {
+            this._selected = value;
+        }
+        else {
+            this._selected = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));
+        }
+        this._setRanges(this._selected);
+    }
+    /** The minimum selectable date. */
+    get minDate() { return this._minDate; }
+    set minDate(value) {
+        this._minDate = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));
+    }
+    /** The maximum selectable date. */
+    get maxDate() { return this._maxDate; }
+    set maxDate(value) {
+        this._maxDate = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));
+    }
+    ngAfterContentInit() {
+        this._rerenderSubscription = this._dateAdapter.localeChanges
+            .pipe(startWith(null))
+            .subscribe(() => this._init());
+    }
+    ngOnChanges(changes) {
+        const comparisonChange = changes['comparisonStart'] || changes['comparisonEnd'];
+        if (comparisonChange && !comparisonChange.firstChange) {
+            this._setRanges(this.selected);
+        }
+    }
+    ngOnDestroy() {
+        this._rerenderSubscription.unsubscribe();
+    }
+    /** Handles when a new date is selected. */
+    _dateSelected(event) {
+        const date = event.value;
+        const selectedYear = this._dateAdapter.getYear(this.activeDate);
+        const selectedMonth = this._dateAdapter.getMonth(this.activeDate);
+        const selectedDate = this._dateAdapter.createDate(selectedYear, selectedMonth, date);
+        let rangeStartDate;
+        let rangeEndDate;
+        if (this._selected instanceof DateRange) {
+            rangeStartDate = this._getDateInCurrentMonth(this._selected.start);
+            rangeEndDate = this._getDateInCurrentMonth(this._selected.end);
+        }
+        else {
+            rangeStartDate = rangeEndDate = this._getDateInCurrentMonth(this._selected);
+        }
+        if (rangeStartDate !== date || rangeEndDate !== date) {
+            this.selectedChange.emit(selectedDate);
+        }
+        this._userSelection.emit({ value: selectedDate, event: event.event });
+    }
+    /** Handles keydown events on the calendar body when calendar is in month view. */
+    _handleCalendarBodyKeydown(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.
+        const oldActiveDate = this._activeDate;
+        const isRtl = this._isRtl();
+        switch (event.keyCode) {
+            case LEFT_ARROW:
+                this.activeDate = this._dateAdapter.addCalendarDays(this._activeDate, isRtl ? 1 : -1);
+                break;
+            case RIGHT_ARROW:
+                this.activeDate = this._dateAdapter.addCalendarDays(this._activeDate, isRtl ? -1 : 1);
+                break;
+            case UP_ARROW:
+                this.activeDate = this._dateAdapter.addCalendarDays(this._activeDate, -7);
+                break;
+            case DOWN_ARROW:
+                this.activeDate = this._dateAdapter.addCalendarDays(this._activeDate, 7);
+                break;
+            case HOME:
+                this.activeDate = this._dateAdapter.addCalendarDays(this._activeDate, 1 - this._dateAdapter.getDate(this._activeDate));
+                break;
+            case END:
+                this.activeDate = this._dateAdapter.addCalendarDays(this._activeDate, (this._dateAdapter.getNumDaysInMonth(this._activeDate) -
+                    this._dateAdapter.getDate(this._activeDate)));
+                break;
+            case PAGE_UP:
+                this.activeDate = event.altKey ?
+                    this._dateAdapter.addCalendarYears(this._activeDate, -1) :
+                    this._dateAdapter.addCalendarMonths(this._activeDate, -1);
+                break;
+            case PAGE_DOWN:
+                this.activeDate = event.altKey ?
+                    this._dateAdapter.addCalendarYears(this._activeDate, 1) :
+                    this._dateAdapter.addCalendarMonths(this._activeDate, 1);
+                break;
+            case ENTER:
+            case SPACE:
+                if (!this.dateFilter || this.dateFilter(this._activeDate)) {
+                    this._dateSelected({ value: this._dateAdapter.getDate(this._activeDate), event });
+                    // Prevent unexpected default actions such as form submission.
+                    event.preventDefault();
+                }
+                return;
+            case ESCAPE:
+                // Abort the current range selection if the user presses escape mid-selection.
+                if (this._previewEnd != null) {
+                    this._previewStart = this._previewEnd = null;
+                    this.selectedChange.emit(null);
+                    this._userSelection.emit({ value: null, event });
+                    event.preventDefault();
+                    event.stopPropagation(); // Prevents the overlay from closing.
+                }
+                return;
+            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 month view. */
+    _init() {
+        this._setRanges(this.selected);
+        this._todayDate = this._getCellCompareValue(this._dateAdapter.today());
+        this._monthLabel = this._dateAdapter.getMonthNames('short')[this._dateAdapter.getMonth(this.activeDate)].toLocaleUpperCase();
+        let firstOfMonth = this._dateAdapter.createDate(this._dateAdapter.getYear(this.activeDate), this._dateAdapter.getMonth(this.activeDate), 1);
+        this._firstWeekOffset = (DAYS_PER_WEEK + this._dateAdapter.getDayOfWeek(firstOfMonth) - this._dateAdapter.getFirstDayOfWeek()) % DAYS_PER_WEEK;
+        this._initWeekdays();
+        this._createWeekCells();
+        this._changeDetectorRef.markForCheck();
+    }
+    /** Focuses the active cell after the microtask queue is empty. */
+    _focusActiveCell(movePreview) {
+        this._matCalendarBody._focusActiveCell(movePreview);
+    }
+    /** Called when the user has activated a new cell and the preview needs to be updated. */
+    _previewChanged({ event, value: cell }) {
+        if (this._rangeStrategy) {
+            // We can assume that this will be a range, because preview
+            // events aren't fired for single date selections.
+            const value = cell ? cell.rawValue : null;
+            const previewRange = this._rangeStrategy.createPreview(value, this.selected, event);
+            this._previewStart = this._getCellCompareValue(previewRange.start);
+            this._previewEnd = this._getCellCompareValue(previewRange.end);
+            // Note that here we need to use `detectChanges`, rather than `markForCheck`, because
+            // the way `_focusActiveCell` is set up at the moment makes it fire at the wrong time
+            // when navigating one month back using the keyboard which will cause this handler
+            // to throw a "changed after checked" error when updating the preview state.
+            this._changeDetectorRef.detectChanges();
+        }
+    }
+    /** Initializes the weekdays. */
+    _initWeekdays() {
+        const firstDayOfWeek = this._dateAdapter.getFirstDayOfWeek();
+        const narrowWeekdays = this._dateAdapter.getDayOfWeekNames('narrow');
+        const longWeekdays = this._dateAdapter.getDayOfWeekNames('long');
+        // Rotate the labels for days of the week based on the configured first day of the week.
+        let weekdays = longWeekdays.map((long, i) => {
+            return { long, narrow: narrowWeekdays[i] };
+        });
+        this._weekdays = weekdays.slice(firstDayOfWeek).concat(weekdays.slice(0, firstDayOfWeek));
+    }
+    /** Creates MatCalendarCells for the dates in this month. */
+    _createWeekCells() {
+        const daysInMonth = this._dateAdapter.getNumDaysInMonth(this.activeDate);
+        const dateNames = this._dateAdapter.getDateNames();
+        this._weeks = [[]];
+        for (let i = 0, cell = this._firstWeekOffset; i < daysInMonth; i++, cell++) {
+            if (cell == DAYS_PER_WEEK) {
+                this._weeks.push([]);
+                cell = 0;
+            }
+            const date = this._dateAdapter.createDate(this._dateAdapter.getYear(this.activeDate), this._dateAdapter.getMonth(this.activeDate), i + 1);
+            const enabled = this._shouldEnableDate(date);
+            const ariaLabel = this._dateAdapter.format(date, this._dateFormats.display.dateA11yLabel);
+            const cellClasses = this.dateClass ? this.dateClass(date, 'month') : undefined;
+            this._weeks[this._weeks.length - 1].push(new MatCalendarCell(i + 1, dateNames[i], ariaLabel, enabled, cellClasses, this._getCellCompareValue(date), date));
+        }
+    }
+    /** Date filter for the month */
+    _shouldEnableDate(date) {
+        return !!date &&
+            (!this.minDate || this._dateAdapter.compareDate(date, this.minDate) >= 0) &&
+            (!this.maxDate || this._dateAdapter.compareDate(date, this.maxDate) <= 0) &&
+            (!this.dateFilter || this.dateFilter(date));
+    }
+    /**
+     * Gets the date in this month that the given Date falls on.
+     * Returns null if the given Date is in another month.
+     */
+    _getDateInCurrentMonth(date) {
+        return date && this._hasSameMonthAndYear(date, this.activeDate) ?
+            this._dateAdapter.getDate(date) : null;
+    }
+    /** Checks whether the 2 dates are non-null and fall within the same month of the same year. */
+    _hasSameMonthAndYear(d1, d2) {
+        return !!(d1 && d2 && this._dateAdapter.getMonth(d1) == this._dateAdapter.getMonth(d2) &&
+            this._dateAdapter.getYear(d1) == this._dateAdapter.getYear(d2));
+    }
+    /** Gets the value that will be used to one cell to another. */
+    _getCellCompareValue(date) {
+        if (date) {
+            // We use the time since the Unix epoch to compare dates in this view, rather than the
+            // cell values, because we need to support ranges that span across multiple months/years.
+            const year = this._dateAdapter.getYear(date);
+            const month = this._dateAdapter.getMonth(date);
+            const day = this._dateAdapter.getDate(date);
+            return new Date(year, month, day).getTime();
+        }
+        return null;
+    }
+    /** Determines whether the user has the RTL layout direction. */
+    _isRtl() {
+        return this._dir && this._dir.value === 'rtl';
+    }
+    /** Sets the current range based on a model value. */
+    _setRanges(selectedValue) {
+        if (selectedValue instanceof DateRange) {
+            this._rangeStart = this._getCellCompareValue(selectedValue.start);
+            this._rangeEnd = this._getCellCompareValue(selectedValue.end);
+            this._isRange = true;
+        }
+        else {
+            this._rangeStart = this._rangeEnd = this._getCellCompareValue(selectedValue);
+            this._isRange = false;
+        }
+        this._comparisonRangeStart = this._getCellCompareValue(this.comparisonStart);
+        this._comparisonRangeEnd = this._getCellCompareValue(this.comparisonEnd);
+    }
+};
+MatMonthView.ctorParameters = () => [
+    { type: ChangeDetectorRef },
+    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [MAT_DATE_FORMATS,] }] },
+    { type: DateAdapter, decorators: [{ type: Optional }] },
+    { type: Directionality, decorators: [{ type: Optional }] },
+    { type: undefined, decorators: [{ type: Inject, args: [MAT_DATE_RANGE_SELECTION_STRATEGY,] }, { type: Optional }] }
+];
+__decorate([
+    Input(),
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [Object])
+], MatMonthView.prototype, "activeDate", null);
+__decorate([
+    Input(),
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [Object])
+], MatMonthView.prototype, "selected", null);
+__decorate([
+    Input(),
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [Object])
+], MatMonthView.prototype, "minDate", null);
+__decorate([
+    Input(),
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [Object])
+], MatMonthView.prototype, "maxDate", null);
+__decorate([
+    Input(),
+    __metadata("design:type", Function)
+], MatMonthView.prototype, "dateFilter", void 0);
+__decorate([
+    Input(),
+    __metadata("design:type", Function)
+], MatMonthView.prototype, "dateClass", void 0);
+__decorate([
+    Input(),
+    __metadata("design:type", Object)
+], MatMonthView.prototype, "comparisonStart", void 0);
+__decorate([
+    Input(),
+    __metadata("design:type", Object)
+], MatMonthView.prototype, "comparisonEnd", void 0);
+__decorate([
+    Output(),
+    __metadata("design:type", EventEmitter)
+], MatMonthView.prototype, "selectedChange", void 0);
+__decorate([
+    Output(),
+    __metadata("design:type", EventEmitter)
+], MatMonthView.prototype, "_userSelection", void 0);
+__decorate([
+    Output(),
+    __metadata("design:type", EventEmitter)
+], MatMonthView.prototype, "activeDateChange", void 0);
+__decorate([
+    ViewChild(MatCalendarBody, { static: true }),
+    __metadata("design:type", MatCalendarBody)
+], MatMonthView.prototype, "_matCalendarBody", void 0);
+MatMonthView = __decorate([
+    Component({
+        selector: 'gipi-mat-month-view',
+        template: "<table class=\"mat-calendar-table\"\n       role=\"presentation\">\n    <thead class=\"mat-calendar-table-header\">\n        <tr>\n            <th scope=\"col\"\n                *ngFor=\"let day of _weekdays\"\n                [attr.aria-label]=\"day.long\">\n                {{ day.narrow }}\n            </th>\n        </tr>\n        <tr>\n            <th class=\"mat-calendar-table-header-divider\"\n                colspan=\"7\"\n                aria-hidden=\"true\">\n            </th>\n        </tr>\n    </thead>\n    <tbody gipi-mat-calendar-body\n           [label]=\"_monthLabel\"\n           [rows]=\"_weeks\"\n           [todayValue]=\"_todayDate!\"\n           [startValue]=\"_rangeStart!\"\n           [endValue]=\"_rangeEnd!\"\n           [comparisonStart]=\"_comparisonRangeStart\"\n           [comparisonEnd]=\"_comparisonRangeEnd\"\n           [previewStart]=\"_previewStart\"\n           [previewEnd]=\"_previewEnd\"\n           [isRange]=\"_isRange\"\n           [labelMinRequiredCells]=\"3\"\n           [activeCell]=\"_dateAdapter.getDate(activeDate) - 1\"\n           (selectedValueChange)=\"_dateSelected($event)\"\n           (previewChange)=\"_previewChanged($event)\"\n           (keydown)=\"_handleCalendarBodyKeydown($event)\">\n    </tbody>\n</table>",
+        exportAs: 'gipiMatMonthView',
+        encapsulation: ViewEncapsulation.None,
+        changeDetection: ChangeDetectionStrategy.OnPush
+    }),
+    __param(1, Optional()), __param(1, Inject(MAT_DATE_FORMATS)),
+    __param(2, Optional()),
+    __param(3, Optional()),
+    __param(4, Inject(MAT_DATE_RANGE_SELECTION_STRATEGY)), __param(4, Optional()),
+    __metadata("design:paramtypes", [ChangeDetectorRef, Object, DateAdapter,
+        Directionality, Object])
+], MatMonthView);
+export { MatMonthView };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"month-view.js","sourceRoot":"ng://@gipisistemas/ng-core/","sources":["shared/gipi-components/datepicker/mat-datepicker/month-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, ESCAPE, HOME, LEFT_ARROW, PAGE_DOWN, PAGE_UP, RIGHT_ARROW, SPACE, UP_ARROW, } from '@angular/cdk/keycodes';\nimport { AfterContentInit, ChangeDetectionStrategy, ChangeDetectorRef, Component, EventEmitter, Inject, Input, OnChanges, OnDestroy, Optional, Output, SimpleChanges, 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 { MAT_DATE_RANGE_SELECTION_STRATEGY, MatDateRangeSelectionStrategy, } from './date-range-selection-strategy';\nimport { DateRange } from './date-selection-model';\nimport { createMissingDateImplError } from './datepicker-errors';\nimport { DateAdapter } from './shared/adapter/date-adapter';\n\nconst DAYS_PER_WEEK = 7;\n\n/**\n * An internal component used to display a single month in the datepicker.\n * @docs-private\n */\n@Component({\n    selector: 'gipi-mat-month-view',\n    templateUrl: 'month-view.html',\n    exportAs: 'gipiMatMonthView',\n    encapsulation: ViewEncapsulation.None,\n    changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class MatMonthView<D> implements AfterContentInit, OnChanges, OnDestroy {\n    private _rerenderSubscription = Subscription.EMPTY;\n\n    /**\n     * The date to display in this month view (everything other than the month and year is ignored).\n     */\n    @Input()\n    get activeDate(): D { return this._activeDate; }\n    set activeDate(value: D) {\n        const oldActiveDate = this._activeDate;\n        const validDate = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value)) || this._dateAdapter.today();\n        this._activeDate = this._dateAdapter.clampDate(validDate, this.minDate, this.maxDate);\n        if (!this._hasSameMonthAndYear(oldActiveDate, 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._setRanges(this._selected);\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    /** Emits when a new date is selected. */\n    @Output() readonly selectedChange: EventEmitter<D | null> = new EventEmitter<D | null>();\n\n    /** Emits when any date is selected. */\n    @Output() readonly _userSelection: EventEmitter<MatCalendarUserEvent<D | null>> =\n        new EventEmitter<MatCalendarUserEvent<D | null>>();\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    /** The label for this month (e.g. \"January 2017\"). */\n    _monthLabel: string;\n\n    /** Grid of calendar cells representing the dates of the month. */\n    _weeks: MatCalendarCell[][];\n\n    /** The number of blank cells in the first row before the 1st of the month. */\n    _firstWeekOffset: number;\n\n    /** Start value of the currently-shown date range. */\n    _rangeStart: number | null;\n\n    /** End value of the currently-shown date range. */\n    _rangeEnd: number | null;\n\n    /** Start value of the currently-shown comparison date range. */\n    _comparisonRangeStart: number | null;\n\n    /** End value of the currently-shown comparison date range. */\n    _comparisonRangeEnd: number | null;\n\n    /** Start of the preview range. */\n    _previewStart: number | null;\n\n    /** End of the preview range. */\n    _previewEnd: number | null;\n\n    /** Whether the user is currently selecting a range of dates. */\n    _isRange: boolean;\n\n    /** The date of the month that today falls on. Null if today is in another month. */\n    _todayDate: number | null;\n\n    /** The names of the weekdays. */\n    _weekdays: { long: string, narrow: string }[];\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        @Inject(MAT_DATE_RANGE_SELECTION_STRATEGY) @Optional()\n        private _rangeStrategy?: MatDateRangeSelectionStrategy<D>\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    ngOnChanges(changes: SimpleChanges) {\n        const comparisonChange = changes['comparisonStart'] || changes['comparisonEnd'];\n\n        if (comparisonChange && !comparisonChange.firstChange) {\n            this._setRanges(this.selected);\n        }\n    }\n\n    ngOnDestroy() {\n        this._rerenderSubscription.unsubscribe();\n    }\n\n    /** Handles when a new date is selected. */\n    _dateSelected(event: MatCalendarUserEvent<number>) {\n        const date = event.value;\n        const selectedYear = this._dateAdapter.getYear(this.activeDate);\n        const selectedMonth = this._dateAdapter.getMonth(this.activeDate);\n        const selectedDate = this._dateAdapter.createDate(selectedYear, selectedMonth, date);\n        let rangeStartDate: number | null;\n        let rangeEndDate: number | null;\n\n        if (this._selected instanceof DateRange) {\n            rangeStartDate = this._getDateInCurrentMonth(this._selected.start);\n            rangeEndDate = this._getDateInCurrentMonth(this._selected.end);\n        } else {\n            rangeStartDate = rangeEndDate = this._getDateInCurrentMonth(this._selected);\n        }\n\n        if (rangeStartDate !== date || rangeEndDate !== date) {\n            this.selectedChange.emit(selectedDate);\n        }\n\n        this._userSelection.emit({ value: selectedDate, event: event.event });\n    }\n\n    /** Handles keydown events on the calendar body when calendar is in month 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.addCalendarDays(this._activeDate, isRtl ? 1 : -1);\n                break;\n            case RIGHT_ARROW:\n                this.activeDate = this._dateAdapter.addCalendarDays(this._activeDate, isRtl ? -1 : 1);\n                break;\n            case UP_ARROW:\n                this.activeDate = this._dateAdapter.addCalendarDays(this._activeDate, -7);\n                break;\n            case DOWN_ARROW:\n                this.activeDate = this._dateAdapter.addCalendarDays(this._activeDate, 7);\n                break;\n            case HOME:\n                this.activeDate = this._dateAdapter.addCalendarDays(this._activeDate,\n                    1 - this._dateAdapter.getDate(this._activeDate));\n                break;\n            case END:\n                this.activeDate = this._dateAdapter.addCalendarDays(this._activeDate,\n                    (this._dateAdapter.getNumDaysInMonth(this._activeDate) -\n                        this._dateAdapter.getDate(this._activeDate)));\n                break;\n            case PAGE_UP:\n                this.activeDate = event.altKey ?\n                    this._dateAdapter.addCalendarYears(this._activeDate, -1) :\n                    this._dateAdapter.addCalendarMonths(this._activeDate, -1);\n                break;\n            case PAGE_DOWN:\n                this.activeDate = event.altKey ?\n                    this._dateAdapter.addCalendarYears(this._activeDate, 1) :\n                    this._dateAdapter.addCalendarMonths(this._activeDate, 1);\n                break;\n            case ENTER:\n            case SPACE:\n                if (!this.dateFilter || this.dateFilter(this._activeDate)) {\n                    this._dateSelected({ value: this._dateAdapter.getDate(this._activeDate), event });\n                    // Prevent unexpected default actions such as form submission.\n                    event.preventDefault();\n                }\n                return;\n            case ESCAPE:\n                // Abort the current range selection if the user presses escape mid-selection.\n                if (this._previewEnd != null) {\n                    this._previewStart = this._previewEnd = null;\n                    this.selectedChange.emit(null);\n                    this._userSelection.emit({ value: null, event });\n                    event.preventDefault();\n                    event.stopPropagation(); // Prevents the overlay from closing.\n                }\n                return;\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 month view. */\n    _init() {\n        this._setRanges(this.selected);\n        this._todayDate = this._getCellCompareValue(this._dateAdapter.today());\n        this._monthLabel = this._dateAdapter.getMonthNames('short')[this._dateAdapter.getMonth(this.activeDate)].toLocaleUpperCase();\n\n        let firstOfMonth = this._dateAdapter.createDate(this._dateAdapter.getYear(this.activeDate), this._dateAdapter.getMonth(this.activeDate), 1);\n        this._firstWeekOffset = (DAYS_PER_WEEK + this._dateAdapter.getDayOfWeek(firstOfMonth) - this._dateAdapter.getFirstDayOfWeek()) % DAYS_PER_WEEK;\n\n        this._initWeekdays();\n        this._createWeekCells();\n        this._changeDetectorRef.markForCheck();\n    }\n\n    /** Focuses the active cell after the microtask queue is empty. */\n    _focusActiveCell(movePreview?: boolean) {\n        this._matCalendarBody._focusActiveCell(movePreview);\n    }\n\n    /** Called when the user has activated a new cell and the preview needs to be updated. */\n    _previewChanged({ event, value: cell }: MatCalendarUserEvent<MatCalendarCell<D> | null>) {\n        if (this._rangeStrategy) {\n            // We can assume that this will be a range, because preview\n            // events aren't fired for single date selections.\n            const value = cell ? cell.rawValue! : null;\n            const previewRange = this._rangeStrategy.createPreview(value, this.selected as DateRange<D>, event);\n            this._previewStart = this._getCellCompareValue(previewRange.start);\n            this._previewEnd = this._getCellCompareValue(previewRange.end);\n\n            // Note that here we need to use `detectChanges`, rather than `markForCheck`, because\n            // the way `_focusActiveCell` is set up at the moment makes it fire at the wrong time\n            // when navigating one month back using the keyboard which will cause this handler\n            // to throw a \"changed after checked\" error when updating the preview state.\n            this._changeDetectorRef.detectChanges();\n        }\n    }\n\n    /** Initializes the weekdays. */\n    private _initWeekdays() {\n        const firstDayOfWeek = this._dateAdapter.getFirstDayOfWeek();\n        const narrowWeekdays = this._dateAdapter.getDayOfWeekNames('narrow');\n        const longWeekdays = this._dateAdapter.getDayOfWeekNames('long');\n\n        // Rotate the labels for days of the week based on the configured first day of the week.\n        let weekdays = longWeekdays.map((long, i) => {\n            return { long, narrow: narrowWeekdays[i] };\n        });\n        this._weekdays = weekdays.slice(firstDayOfWeek).concat(weekdays.slice(0, firstDayOfWeek));\n    }\n\n    /** Creates MatCalendarCells for the dates in this month. */\n    private _createWeekCells() {\n        const daysInMonth = this._dateAdapter.getNumDaysInMonth(this.activeDate);\n        const dateNames = this._dateAdapter.getDateNames();\n        this._weeks = [[]];\n        for (let i = 0, cell = this._firstWeekOffset; i < daysInMonth; i++, cell++) {\n            if (cell == DAYS_PER_WEEK) {\n                this._weeks.push([]);\n                cell = 0;\n            }\n            const date = this._dateAdapter.createDate(this._dateAdapter.getYear(this.activeDate), this._dateAdapter.getMonth(this.activeDate), i + 1);\n            const enabled = this._shouldEnableDate(date);\n            const ariaLabel = this._dateAdapter.format(date, this._dateFormats.display.dateA11yLabel);\n            const cellClasses = this.dateClass ? this.dateClass(date, 'month') : undefined;\n\n            this._weeks[this._weeks.length - 1].push(new MatCalendarCell<D>(i + 1, dateNames[i], ariaLabel, enabled, cellClasses, this._getCellCompareValue(date)!, date));\n        }\n    }\n\n    /** Date filter for the month */\n    private _shouldEnableDate(date: D): boolean {\n        return !!date &&\n            (!this.minDate || this._dateAdapter.compareDate(date, this.minDate) >= 0) &&\n            (!this.maxDate || this._dateAdapter.compareDate(date, this.maxDate) <= 0) &&\n            (!this.dateFilter || this.dateFilter(date));\n    }\n\n    /**\n     * Gets the date in this month that the given Date falls on.\n     * Returns null if the given Date is in another month.\n     */\n    private _getDateInCurrentMonth(date: D | null): number | null {\n        return date && this._hasSameMonthAndYear(date, this.activeDate) ?\n            this._dateAdapter.getDate(date) : null;\n    }\n\n    /** Checks whether the 2 dates are non-null and fall within the same month of the same year. */\n    private _hasSameMonthAndYear(d1: D | null, d2: D | null): boolean {\n        return !!(d1 && d2 && this._dateAdapter.getMonth(d1) == this._dateAdapter.getMonth(d2) &&\n            this._dateAdapter.getYear(d1) == this._dateAdapter.getYear(d2));\n    }\n\n    /** Gets the value that will be used to one cell to another. */\n    private _getCellCompareValue(date: D | null): number | null {\n        if (date) {\n            // We use the time since the Unix epoch to compare dates in this view, rather than the\n            // cell values, because we need to support ranges that span across multiple months/years.\n            const year = this._dateAdapter.getYear(date);\n            const month = this._dateAdapter.getMonth(date);\n            const day = this._dateAdapter.getDate(date);\n            return new Date(year, month, day).getTime();\n        }\n\n        return null;\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 current range based on a model value. */\n    private _setRanges(selectedValue: DateRange<D> | D | null) {\n        if (selectedValue instanceof DateRange) {\n            this._rangeStart = this._getCellCompareValue(selectedValue.start);\n            this._rangeEnd = this._getCellCompareValue(selectedValue.end);\n            this._isRange = true;\n        } else {\n            this._rangeStart = this._rangeEnd = this._getCellCompareValue(selectedValue);\n            this._isRange = false;\n        }\n\n        this._comparisonRangeStart = this._getCellCompareValue(this.comparisonStart);\n        this._comparisonRangeEnd = this._getCellCompareValue(this.comparisonEnd);\n    }\n}\n"]}