@gipisistemas/ng-core 1.0.67 → 1.0.68

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

@@ -0,0 +1,130 @@
+import { __decorate } from "tslib";
+import { A11yModule } from '@angular/cdk/a11y';
+import { OverlayModule } from '@angular/cdk/overlay';
+import { PlatformModule } from '@angular/cdk/platform';
+import { PortalModule } from '@angular/cdk/portal';
+import { ScrollingModule } from '@angular/cdk/scrolling';
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { FormsModule, ReactiveFormsModule } from '@angular/forms';
+import { MatNativeDateModule } from '@angular/material';
+import { MatButtonModule } from '@angular/material/button';
+import { MatDialogModule } from '@angular/material/dialog';
+import { MatCalendar, MatCalendarHeader } from './mat-datepicker/calendar';
+import { MatCalendarBody } from './mat-datepicker/calendar-body';
+import { MatDateRangeInput } from './mat-datepicker/date-range-input';
+import { MatEndDate, MatStartDate } from './mat-datepicker/date-range-input-parts';
+import { MatDateRangePicker } from './mat-datepicker/date-range-picker';
+import { MatDatepicker } from './mat-datepicker/datepicker';
+import { MAT_DATEPICKER_SCROLL_STRATEGY_FACTORY_PROVIDER, MatDatepickerContent, } from './mat-datepicker/datepicker-base';
+import { MatDatepickerInput } from './mat-datepicker/datepicker-input';
+import { MatDatepickerIntl } from './mat-datepicker/datepicker-intl';
+import { MatDatepickerToggle, MatDatepickerToggleIcon } from './mat-datepicker/datepicker-toggle';
+import { MatMonthView } from './mat-datepicker/month-view';
+import { MatMultiYearView } from './mat-datepicker/multi-year-view';
+import { NativeDateAdapter } from './mat-datepicker/shared/adapter/native-date-adapter';
+import { MatYearView } from './mat-datepicker/year-view';
+import { DateRangePickerComponent } from './date-range-picker/date-range-picker.component';
+import { MaxRangeDirective } from './date-range-picker/shared/max-range/max-range.directive';
+import { PresetRangeComponent } from './date-range-picker/shared/preset-range/preset-range.component';
+import { DatepickerComponent } from './datepicker/datepicker.component';
+import { DateAdapter, MAT_DATE_LOCALE } from './mat-datepicker/shared/adapter/date-adapter';
+import { MAT_DATE_FORMATS } from './mat-datepicker/shared/adapter/date-formats';
+const ɵ0 = {
+    parse: {
+        dateInput: 'DD/MM/YYYY',
+    },
+    display: {
+        dateInput: 'DD/MM/YYYY',
+        monthYearLabel: 'MMM YYYY',
+        dateA11yLabel: 'LL',
+        monthYearA11yLabel: 'MMMM YYYY',
+    },
+};
+let DatepickerModule = class DatepickerModule {
+};
+DatepickerModule = __decorate([
+    NgModule({
+        imports: [
+            CommonModule,
+            MatButtonModule,
+            MatDialogModule,
+            OverlayModule,
+            A11yModule,
+            PortalModule,
+            FormsModule,
+            ReactiveFormsModule,
+            PlatformModule,
+            MatNativeDateModule,
+        ],
+        exports: [
+            ScrollingModule,
+            FormsModule,
+            ReactiveFormsModule,
+            PlatformModule,
+            MatCalendar,
+            MatCalendarBody,
+            MatDatepicker,
+            MatDatepickerContent,
+            MatDatepickerInput,
+            MatDatepickerToggle,
+            MatDatepickerToggleIcon,
+            MatMonthView,
+            MatYearView,
+            MatMultiYearView,
+            MatCalendarHeader,
+            MatDateRangeInput,
+            MatStartDate,
+            MatEndDate,
+            MatDateRangePicker,
+            MaxRangeDirective,
+            PresetRangeComponent,
+            DateRangePickerComponent,
+            DatepickerComponent,
+        ],
+        declarations: [
+            MatCalendar,
+            MatCalendarBody,
+            MatDatepicker,
+            MatDatepickerContent,
+            MatDatepickerInput,
+            MatDatepickerToggle,
+            MatDatepickerToggleIcon,
+            MatMonthView,
+            MatYearView,
+            MatMultiYearView,
+            MatCalendarHeader,
+            MatDateRangeInput,
+            MatStartDate,
+            MatEndDate,
+            MatDateRangePicker,
+            MaxRangeDirective,
+            PresetRangeComponent,
+            DateRangePickerComponent,
+            DatepickerComponent,
+        ],
+        providers: [
+            MatDatepickerIntl,
+            MAT_DATEPICKER_SCROLL_STRATEGY_FACTORY_PROVIDER,
+            {
+                provide: DateAdapter,
+                useClass: NativeDateAdapter,
+                deps: [MAT_DATE_LOCALE]
+            },
+            {
+                provide: MAT_DATE_LOCALE,
+                useValue: 'pt-BR',
+            },
+            {
+                provide: MAT_DATE_FORMATS,
+                useValue: ɵ0,
+            },
+        ],
+        entryComponents: [
+            MatDatepickerContent,
+        ]
+    })
+], DatepickerModule);
+export { DatepickerModule };
+export { ɵ0 };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"datepicker.module.js","sourceRoot":"ng://@gipisistemas/ng-core/","sources":["shared/gipi-components/datepicker/datepicker.module.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAC/C,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AACrD,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACzD,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAClE,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAE3D,OAAO,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAC3E,OAAO,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAC;AACjE,OAAO,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AACtE,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,yCAAyC,CAAC;AACnF,OAAO,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AACxE,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,EAAE,+CAA+C,EAAE,oBAAoB,GAAG,MAAM,kCAAkC,CAAC;AAC1H,OAAO,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAC;AACvE,OAAO,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AACrE,OAAO,EAAE,mBAAmB,EAAE,uBAAuB,EAAE,MAAM,oCAAoC,CAAC;AAClG,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACpE,OAAO,EAAE,iBAAiB,EAAE,MAAM,qDAAqD,CAAC;AACxF,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAEzD,OAAO,EAAE,wBAAwB,EAAE,MAAM,iDAAiD,CAAC;AAC3F,OAAO,EAAE,iBAAiB,EAAE,MAAM,0DAA0D,CAAC;AAC7F,OAAO,EAAE,oBAAoB,EAAE,MAAM,gEAAgE,CAAC;AACtG,OAAO,EAAE,mBAAmB,EAAE,MAAM,mCAAmC,CAAC;AACxE,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,8CAA8C,CAAC;AAC5F,OAAO,EAAE,gBAAgB,EAAE,MAAM,8CAA8C,CAAC;WA8E1D;IACN,KAAK,EAAE;QACH,SAAS,EAAE,YAAY;KAC1B;IACD,OAAO,EAAE;QACL,SAAS,EAAE,YAAY;QACvB,cAAc,EAAE,UAAU;QAC1B,aAAa,EAAE,IAAI;QACnB,kBAAkB,EAAE,WAAW;KAClC;CACJ;AAOb,IAAa,gBAAgB,GAA7B,MAAa,gBAAgB;CAAI,CAAA;AAApB,gBAAgB;IA7F5B,QAAQ,CAAC;QACN,OAAO,EAAE;YACL,YAAY;YACZ,eAAe;YACf,eAAe;YACf,aAAa;YACb,UAAU;YACV,YAAY;YACZ,WAAW;YACX,mBAAmB;YACnB,cAAc;YACd,mBAAmB;SACtB;QACD,OAAO,EAAE;YACL,eAAe;YACf,WAAW;YACX,mBAAmB;YACnB,cAAc;YAEd,WAAW;YACX,eAAe;YACf,aAAa;YACb,oBAAoB;YACpB,kBAAkB;YAClB,mBAAmB;YACnB,uBAAuB;YACvB,YAAY;YACZ,WAAW;YACX,gBAAgB;YAChB,iBAAiB;YACjB,iBAAiB;YACjB,YAAY;YACZ,UAAU;YACV,kBAAkB;YAElB,iBAAiB;YACjB,oBAAoB;YACpB,wBAAwB;YACxB,mBAAmB;SACtB;QACD,YAAY,EAAE;YACV,WAAW;YACX,eAAe;YACf,aAAa;YACb,oBAAoB;YACpB,kBAAkB;YAClB,mBAAmB;YACnB,uBAAuB;YACvB,YAAY;YACZ,WAAW;YACX,gBAAgB;YAChB,iBAAiB;YACjB,iBAAiB;YACjB,YAAY;YACZ,UAAU;YACV,kBAAkB;YAElB,iBAAiB;YACjB,oBAAoB;YACpB,wBAAwB;YACxB,mBAAmB;SACtB;QACD,SAAS,EAAE;YACP,iBAAiB;YACjB,+CAA+C;YAC/C;gBACI,OAAO,EAAE,WAAW;gBACpB,QAAQ,EAAE,iBAAiB;gBAC3B,IAAI,EAAE,CAAC,eAAe,CAAC;aAC1B;YACD;gBACI,OAAO,EAAE,eAAe;gBACxB,QAAQ,EAAE,OAAO;aACpB;YACD;gBACI,OAAO,EAAE,gBAAgB;gBACzB,QAAQ,IAUP;aACJ;SACJ;QACD,eAAe,EAAE;YACb,oBAAoB;SACvB;KACJ,CAAC;GACW,gBAAgB,CAAI;SAApB,gBAAgB","sourcesContent":["import { A11yModule } from '@angular/cdk/a11y';\nimport { OverlayModule } from '@angular/cdk/overlay';\nimport { PlatformModule } from '@angular/cdk/platform';\nimport { PortalModule } from '@angular/cdk/portal';\nimport { ScrollingModule } from '@angular/cdk/scrolling';\nimport { CommonModule } from '@angular/common';\nimport { NgModule } from '@angular/core';\nimport { FormsModule, ReactiveFormsModule } from '@angular/forms';\nimport { MatNativeDateModule } from '@angular/material';\nimport { MatButtonModule } from '@angular/material/button';\nimport { MatDialogModule } from '@angular/material/dialog';\n\nimport { MatCalendar, MatCalendarHeader } from './mat-datepicker/calendar';\nimport { MatCalendarBody } from './mat-datepicker/calendar-body';\nimport { MatDateRangeInput } from './mat-datepicker/date-range-input';\nimport { MatEndDate, MatStartDate } from './mat-datepicker/date-range-input-parts';\nimport { MatDateRangePicker } from './mat-datepicker/date-range-picker';\nimport { MatDatepicker } from './mat-datepicker/datepicker';\nimport { MAT_DATEPICKER_SCROLL_STRATEGY_FACTORY_PROVIDER, MatDatepickerContent, } from './mat-datepicker/datepicker-base';\nimport { MatDatepickerInput } from './mat-datepicker/datepicker-input';\nimport { MatDatepickerIntl } from './mat-datepicker/datepicker-intl';\nimport { MatDatepickerToggle, MatDatepickerToggleIcon } from './mat-datepicker/datepicker-toggle';\nimport { MatMonthView } from './mat-datepicker/month-view';\nimport { MatMultiYearView } from './mat-datepicker/multi-year-view';\nimport { NativeDateAdapter } from './mat-datepicker/shared/adapter/native-date-adapter';\nimport { MatYearView } from './mat-datepicker/year-view';\n\nimport { DateRangePickerComponent } from './date-range-picker/date-range-picker.component';\nimport { MaxRangeDirective } from './date-range-picker/shared/max-range/max-range.directive';\nimport { PresetRangeComponent } from './date-range-picker/shared/preset-range/preset-range.component';\nimport { DatepickerComponent } from './datepicker/datepicker.component';\nimport { DateAdapter, MAT_DATE_LOCALE } from './mat-datepicker/shared/adapter/date-adapter';\nimport { MAT_DATE_FORMATS } from './mat-datepicker/shared/adapter/date-formats';\n\n@NgModule({\n    imports: [\n        CommonModule,\n        MatButtonModule,\n        MatDialogModule,\n        OverlayModule,\n        A11yModule,\n        PortalModule,\n        FormsModule,\n        ReactiveFormsModule,\n        PlatformModule,\n        MatNativeDateModule,\n    ],\n    exports: [\n        ScrollingModule,\n        FormsModule,\n        ReactiveFormsModule,\n        PlatformModule,\n\n        MatCalendar,\n        MatCalendarBody,\n        MatDatepicker,\n        MatDatepickerContent,\n        MatDatepickerInput,\n        MatDatepickerToggle,\n        MatDatepickerToggleIcon,\n        MatMonthView,\n        MatYearView,\n        MatMultiYearView,\n        MatCalendarHeader,\n        MatDateRangeInput,\n        MatStartDate,\n        MatEndDate,\n        MatDateRangePicker,\n\n        MaxRangeDirective,\n        PresetRangeComponent,\n        DateRangePickerComponent,\n        DatepickerComponent,\n    ],\n    declarations: [\n        MatCalendar,\n        MatCalendarBody,\n        MatDatepicker,\n        MatDatepickerContent,\n        MatDatepickerInput,\n        MatDatepickerToggle,\n        MatDatepickerToggleIcon,\n        MatMonthView,\n        MatYearView,\n        MatMultiYearView,\n        MatCalendarHeader,\n        MatDateRangeInput,\n        MatStartDate,\n        MatEndDate,\n        MatDateRangePicker,\n\n        MaxRangeDirective,\n        PresetRangeComponent,\n        DateRangePickerComponent,\n        DatepickerComponent,\n    ],\n    providers: [\n        MatDatepickerIntl,\n        MAT_DATEPICKER_SCROLL_STRATEGY_FACTORY_PROVIDER,\n        {\n            provide: DateAdapter,\n            useClass: NativeDateAdapter,\n            deps: [MAT_DATE_LOCALE]\n        },\n        {\n            provide: MAT_DATE_LOCALE,\n            useValue: 'pt-BR',\n        },\n        {\n            provide: MAT_DATE_FORMATS,\n            useValue: {\n                parse: {\n                    dateInput: 'DD/MM/YYYY',\n                },\n                display: {\n                    dateInput: 'DD/MM/YYYY',\n                    monthYearLabel: 'MMM YYYY',\n                    dateA11yLabel: 'LL',\n                    monthYearA11yLabel: 'MMMM YYYY',\n                },\n            },\n        },\n    ],\n    entryComponents: [\n        MatDatepickerContent,\n    ]\n})\nexport class DatepickerModule { }\n"]}

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

@@ -0,0 +1,341 @@
+/**
+ * @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 } from "tslib";
+import { ChangeDetectionStrategy, Component, ElementRef, EventEmitter, Input, NgZone, OnChanges, OnDestroy, Output, SimpleChanges, ViewEncapsulation, } from '@angular/core';
+import { take } from 'rxjs/operators';
+/**
+ * An internal class that represents the data corresponding to a single calendar cell.
+ * @docs-private
+ */
+export class MatCalendarCell {
+    constructor(value, displayValue, ariaLabel, enabled, cssClasses = {}, compareValue = value, rawValue) {
+        this.value = value;
+        this.displayValue = displayValue;
+        this.ariaLabel = ariaLabel;
+        this.enabled = enabled;
+        this.cssClasses = cssClasses;
+        this.compareValue = compareValue;
+        this.rawValue = rawValue;
+    }
+}
+/**
+ * An internal component used to display calendar data in a table.
+ * @docs-private
+ */
+let MatCalendarBody = class MatCalendarBody {
+    constructor(_elementRef, _ngZone) {
+        this._elementRef = _elementRef;
+        this._ngZone = _ngZone;
+        /** The number of columns in the table. */
+        this.numCols = 7;
+        /** The cell number of the active cell in the table. */
+        this.activeCell = 0;
+        /** Whether a range is being selected. */
+        this.isRange = false;
+        /**
+         * The aspect ratio (width / height) to use for the cells in the table. This aspect ratio will be
+         * maintained even as the table resizes.
+         */
+        this.cellAspectRatio = 1;
+        /** Start of the preview range. */
+        this.previewStart = null;
+        /** End of the preview range. */
+        this.previewEnd = null;
+        /** Emits when a new value is selected. */
+        this.selectedValueChange = new EventEmitter();
+        /** Emits when the preview has changed as a result of a user action. */
+        this.previewChange = new EventEmitter();
+        /**
+         * Event handler for when the user enters an element
+         * inside the calendar body (e.g. by hovering in or focus).
+         */
+        this._enterHandler = (event) => {
+            if (this._skipNextFocus && event.type === 'focus') {
+                this._skipNextFocus = false;
+                return;
+            }
+            // We only need to hit the zone when we're selecting a range.
+            if (event.target && this.isRange) {
+                const cell = this._getCellFromElement(event.target);
+                if (cell) {
+                    this._ngZone.run(() => this.previewChange.emit({ value: cell.enabled ? cell : null, event }));
+                }
+            }
+        };
+        /**
+         * Event handler for when the user's pointer leaves an element
+         * inside the calendar body (e.g. by hovering out or blurring).
+         */
+        this._leaveHandler = (event) => {
+            // We only need to hit the zone when we're selecting a range.
+            if (this.previewEnd !== null && this.isRange) {
+                // Only reset the preview end value when leaving cells. This looks better, because
+                // we have a gap between the cells and the rows and we don't want to remove the
+                // range just for it to show up again when the user moves a few pixels to the side.
+                if (event.target && isTableCell(event.target)) {
+                    this._ngZone.run(() => this.previewChange.emit({ value: null, event }));
+                }
+            }
+        };
+        _ngZone.runOutsideAngular(() => {
+            const element = _elementRef.nativeElement;
+            element.addEventListener('mouseenter', this._enterHandler, true);
+            element.addEventListener('focus', this._enterHandler, true);
+            element.addEventListener('mouseleave', this._leaveHandler, true);
+            element.addEventListener('blur', this._leaveHandler, true);
+        });
+    }
+    /** Called when a cell is clicked. */
+    _cellClicked(cell, event) {
+        if (cell.enabled) {
+            this.selectedValueChange.emit({ value: cell.value, event });
+        }
+    }
+    /** Returns whether a cell should be marked as selected. */
+    _isSelected(value) {
+        return this.startValue === value || this.endValue === value;
+    }
+    ngOnChanges(changes) {
+        const columnChanges = changes['numCols'];
+        const { rows, numCols } = this;
+        if (changes['rows'] || columnChanges) {
+            this._firstRowOffset = rows && rows.length && rows[0].length ? numCols - rows[0].length : 0;
+        }
+        if (changes['cellAspectRatio'] || columnChanges || !this._cellPadding) {
+            this._cellPadding = `${50 * this.cellAspectRatio / numCols}%`;
+        }
+        if (columnChanges || !this._cellWidth) {
+            this._cellWidth = `${100 / numCols}%`;
+        }
+    }
+    ngOnDestroy() {
+        const element = this._elementRef.nativeElement;
+        element.removeEventListener('mouseenter', this._enterHandler, true);
+        element.removeEventListener('focus', this._enterHandler, true);
+        element.removeEventListener('mouseleave', this._leaveHandler, true);
+        element.removeEventListener('blur', this._leaveHandler, true);
+    }
+    /** Returns whether a cell is active. */
+    _isActiveCell(rowIndex, colIndex) {
+        let cellNumber = rowIndex * this.numCols + colIndex;
+        // Account for the fact that the first row may not have as many cells.
+        if (rowIndex) {
+            cellNumber -= this._firstRowOffset;
+        }
+        return cellNumber == this.activeCell;
+    }
+    /** Focuses the active cell after the microtask queue is empty. */
+    _focusActiveCell(movePreview = true) {
+        this._ngZone.runOutsideAngular(() => {
+            this._ngZone.onStable.pipe(take(1)).subscribe(() => {
+                const activeCell = this._elementRef.nativeElement.querySelector('.mat-calendar-body-active');
+                if (activeCell) {
+                    if (!movePreview) {
+                        this._skipNextFocus = true;
+                    }
+                    activeCell.focus();
+                }
+            });
+        });
+    }
+    /** Gets whether a value is the start of the main range. */
+    _isRangeStart(value) {
+        return isStart(value, this.startValue, this.endValue);
+    }
+    /** Gets whether a value is the end of the main range. */
+    _isRangeEnd(value) {
+        return isEnd(value, this.startValue, this.endValue);
+    }
+    /** Gets whether a value is within the currently-selected range. */
+    _isInRange(value) {
+        return isInRange(value, this.startValue, this.endValue, this.isRange);
+    }
+    /** Gets whether a value is the start of the comparison range. */
+    _isComparisonStart(value) {
+        return isStart(value, this.comparisonStart, this.comparisonEnd);
+    }
+    /** Whether the cell is a start bridge cell between the main and comparison ranges. */
+    _isComparisonBridgeStart(value, rowIndex, colIndex) {
+        if (!this._isComparisonStart(value) || this._isRangeStart(value) || !this._isInRange(value)) {
+            return false;
+        }
+        let previousCell = this.rows[rowIndex][colIndex - 1];
+        if (!previousCell) {
+            const previousRow = this.rows[rowIndex - 1];
+            previousCell = previousRow && previousRow[previousRow.length - 1];
+        }
+        return previousCell && !this._isRangeEnd(previousCell.compareValue);
+    }
+    /** Whether the cell is an end bridge cell between the main and comparison ranges. */
+    _isComparisonBridgeEnd(value, rowIndex, colIndex) {
+        if (!this._isComparisonEnd(value) || this._isRangeEnd(value) || !this._isInRange(value)) {
+            return false;
+        }
+        let nextCell = this.rows[rowIndex][colIndex + 1];
+        if (!nextCell) {
+            const nextRow = this.rows[rowIndex + 1];
+            nextCell = nextRow && nextRow[0];
+        }
+        return nextCell && !this._isRangeStart(nextCell.compareValue);
+    }
+    /** Gets whether a value is the end of the comparison range. */
+    _isComparisonEnd(value) {
+        return isEnd(value, this.comparisonStart, this.comparisonEnd);
+    }
+    /** Gets whether a value is within the current comparison range. */
+    _isInComparisonRange(value) {
+        return isInRange(value, this.comparisonStart, this.comparisonEnd, this.isRange);
+    }
+    /**
+     * Gets whether a value is the same as the start and end of the comparison range.
+     * For context, the functions that we use to determine whether something is the start/end of
+     * a range don't allow for the start and end to be on the same day, because we'd have to use
+     * much more specific CSS selectors to style them correctly in all scenarios. This is fine for
+     * the regular range, because when it happens, the selected styles take over and still show where
+     * the range would've been, however we don't have these selected styles for a comparison range.
+     * This function is used to apply a class that serves the same purpose as the one for selected
+     * dates, but it only applies in the context of a comparison range.
+     */
+    _isComparisonIdentical(value) {
+        // Note that we don't need to null check the start/end
+        // here, because the `value` will always be defined.
+        return this.comparisonStart === this.comparisonEnd && value === this.comparisonStart;
+    }
+    /** Gets whether a value is the start of the preview range. */
+    _isPreviewStart(value) {
+        return isStart(value, this.previewStart, this.previewEnd);
+    }
+    /** Gets whether a value is the end of the preview range. */
+    _isPreviewEnd(value) {
+        return isEnd(value, this.previewStart, this.previewEnd);
+    }
+    /** Gets whether a value is inside the preview range. */
+    _isInPreview(value) {
+        return isInRange(value, this.previewStart, this.previewEnd, this.isRange);
+    }
+    /** Finds the MatCalendarCell that corresponds to a DOM node. */
+    _getCellFromElement(element) {
+        let cell;
+        if (isTableCell(element)) {
+            cell = element;
+        }
+        else if (isTableCell(element.parentNode)) {
+            cell = element.parentNode;
+        }
+        if (cell) {
+            const row = cell.getAttribute('data-mat-row');
+            const col = cell.getAttribute('data-mat-col');
+            if (row && col) {
+                return this.rows[parseInt(row)][parseInt(col)];
+            }
+        }
+        return null;
+    }
+};
+MatCalendarBody.ctorParameters = () => [
+    { type: ElementRef },
+    { type: NgZone }
+];
+__decorate([
+    Input(),
+    __metadata("design:type", String)
+], MatCalendarBody.prototype, "label", void 0);
+__decorate([
+    Input(),
+    __metadata("design:type", Array)
+], MatCalendarBody.prototype, "rows", void 0);
+__decorate([
+    Input(),
+    __metadata("design:type", Number)
+], MatCalendarBody.prototype, "todayValue", void 0);
+__decorate([
+    Input(),
+    __metadata("design:type", Number)
+], MatCalendarBody.prototype, "startValue", void 0);
+__decorate([
+    Input(),
+    __metadata("design:type", Number)
+], MatCalendarBody.prototype, "endValue", void 0);
+__decorate([
+    Input(),
+    __metadata("design:type", Number)
+], MatCalendarBody.prototype, "labelMinRequiredCells", void 0);
+__decorate([
+    Input(),
+    __metadata("design:type", Number)
+], MatCalendarBody.prototype, "numCols", void 0);
+__decorate([
+    Input(),
+    __metadata("design:type", Number)
+], MatCalendarBody.prototype, "activeCell", void 0);
+__decorate([
+    Input(),
+    __metadata("design:type", Boolean)
+], MatCalendarBody.prototype, "isRange", void 0);
+__decorate([
+    Input(),
+    __metadata("design:type", Number)
+], MatCalendarBody.prototype, "cellAspectRatio", void 0);
+__decorate([
+    Input(),
+    __metadata("design:type", Number)
+], MatCalendarBody.prototype, "comparisonStart", void 0);
+__decorate([
+    Input(),
+    __metadata("design:type", Number)
+], MatCalendarBody.prototype, "comparisonEnd", void 0);
+__decorate([
+    Input(),
+    __metadata("design:type", Number)
+], MatCalendarBody.prototype, "previewStart", void 0);
+__decorate([
+    Input(),
+    __metadata("design:type", Number)
+], MatCalendarBody.prototype, "previewEnd", void 0);
+__decorate([
+    Output(),
+    __metadata("design:type", EventEmitter)
+], MatCalendarBody.prototype, "selectedValueChange", void 0);
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], MatCalendarBody.prototype, "previewChange", void 0);
+MatCalendarBody = __decorate([
+    Component({
+        selector: '[gipi-mat-calendar-body]',
+        template: "<!--\n  If there's not enough space in the first row, create a separate label row. We mark this row as\n  aria-hidden because we don't want it to be read out as one of the weeks in the month.\n-->\n<tr *ngIf=\"_firstRowOffset < labelMinRequiredCells\"\n    aria-hidden=\"true\">\n    <td class=\"mat-calendar-body-label\"\n        [attr.colspan]=\"numCols\"\n        [style.paddingTop]=\"_cellPadding\"\n        [style.paddingBottom]=\"_cellPadding\">\n        {{label}}\n    </td>\n</tr>\n\n<!-- Create the first row separately so we can include a special spacer cell. -->\n<tr *ngFor=\"let row of rows; let rowIndex = index\"\n    role=\"row\">\n    <!--\n    We mark this cell as aria-hidden so it doesn't get read out as one of the days in the week.\n    The aspect ratio of the table cells is maintained by setting the top and bottom padding as a\n    percentage of the width (a variant of the trick described here:\n    https://www.w3schools.com/howto/howto_css_aspect_ratio.asp).\n  -->\n    <td *ngIf=\"rowIndex === 0 && _firstRowOffset\"\n        aria-hidden=\"true\"\n        class=\"mat-calendar-body-label\"\n        [attr.colspan]=\"_firstRowOffset\"\n        [style.paddingTop]=\"_cellPadding\"\n        [style.paddingBottom]=\"_cellPadding\">\n        {{_firstRowOffset >= labelMinRequiredCells ? label : ''}}\n    </td>\n    <td *ngFor=\"let item of row; let colIndex = index\"\n        role=\"gridcell\"\n        class=\"mat-calendar-body-cell\"\n        [ngClass]=\"item.cssClasses\"\n        [tabindex]=\"_isActiveCell(rowIndex, colIndex) ? 0 : -1\"\n        [attr.data-mat-row]=\"rowIndex\"\n        [attr.data-mat-col]=\"colIndex\"\n        [class.mat-calendar-body-disabled]=\"!item.enabled\"\n        [class.mat-calendar-body-active]=\"_isActiveCell(rowIndex, colIndex)\"\n        [class.mat-calendar-body-range-start]=\"_isRangeStart(item.compareValue)\"\n        [class.mat-calendar-body-range-end]=\"_isRangeEnd(item.compareValue)\"\n        [class.mat-calendar-body-in-range]=\"_isInRange(item.compareValue)\"\n        [class.mat-calendar-body-comparison-bridge-start]=\"_isComparisonBridgeStart(item.compareValue, rowIndex, colIndex)\"\n        [class.mat-calendar-body-comparison-bridge-end]=\"_isComparisonBridgeEnd(item.compareValue, rowIndex, colIndex)\"\n        [class.mat-calendar-body-comparison-start]=\"_isComparisonStart(item.compareValue)\"\n        [class.mat-calendar-body-comparison-end]=\"_isComparisonEnd(item.compareValue)\"\n        [class.mat-calendar-body-in-comparison-range]=\"_isInComparisonRange(item.compareValue)\"\n        [class.mat-calendar-body-preview-start]=\"_isPreviewStart(item.compareValue)\"\n        [class.mat-calendar-body-preview-end]=\"_isPreviewEnd(item.compareValue)\"\n        [class.mat-calendar-body-in-preview]=\"_isInPreview(item.compareValue)\"\n        [attr.aria-label]=\"item.ariaLabel\"\n        [attr.aria-disabled]=\"!item.enabled || null\"\n        [attr.aria-selected]=\"_isSelected(item.compareValue)\"\n        (click)=\"_cellClicked(item, $event)\"\n        [style.width]=\"_cellWidth\"\n        [style.paddingTop]=\"_cellPadding\"\n        [style.paddingBottom]=\"_cellPadding\">\n        <div class=\"mat-calendar-body-cell-content mat-focus-indicator\"\n             [class.mat-calendar-body-selected]=\"_isSelected(item.compareValue)\"\n             [class.mat-calendar-body-comparison-identical]=\"_isComparisonIdentical(item.compareValue)\"\n             [class.mat-calendar-body-today]=\"todayValue === item.compareValue\">\n            {{item.displayValue}}\n        </div>\n        <div class=\"mat-calendar-body-cell-preview\"></div>\n    </td>\n</tr>",
+        host: {
+            'class': 'mat-calendar-body',
+            'role': 'grid',
+            'aria-readonly': 'true'
+        },
+        exportAs: 'gipiMatCalendarBody',
+        encapsulation: ViewEncapsulation.None,
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        styles: [".mat-calendar-body{min-width:224px}.mat-calendar-body-label{height:0;line-height:0;text-align:left;padding-left:4.71429%;padding-right:4.71429%}.mat-calendar-body-cell{position:relative;height:0;line-height:0;text-align:center;outline:0;cursor:pointer}.mat-calendar-body-cell-preview,.mat-calendar-body-cell::after,.mat-calendar-body-cell::before{content:'';position:absolute;top:5%;left:0;z-index:0;box-sizing:border-box;height:90%;width:100%}.mat-calendar-body-comparison-start::after,.mat-calendar-body-comparison-start:not(.mat-calendar-body-comparison-bridge-start)::before,.mat-calendar-body-preview-start .mat-calendar-body-cell-preview,.mat-calendar-body-range-start::after,.mat-calendar-body-range-start:not(.mat-calendar-body-in-comparison-range)::before{left:5%;width:95%;border-top-left-radius:999px;border-bottom-left-radius:999px}[dir=rtl] .mat-calendar-body-comparison-start::after,[dir=rtl] .mat-calendar-body-comparison-start:not(.mat-calendar-body-comparison-bridge-start)::before,[dir=rtl] .mat-calendar-body-preview-start .mat-calendar-body-cell-preview,[dir=rtl] .mat-calendar-body-range-start::after,[dir=rtl] .mat-calendar-body-range-start:not(.mat-calendar-body-in-comparison-range)::before{left:0;border-radius:0 999px 999px 0}.mat-calendar-body-comparison-end::after,.mat-calendar-body-comparison-end:not(.mat-calendar-body-comparison-bridge-end)::before,.mat-calendar-body-preview-end .mat-calendar-body-cell-preview,.mat-calendar-body-range-end::after,.mat-calendar-body-range-end:not(.mat-calendar-body-in-comparison-range)::before{width:95%;border-top-right-radius:999px;border-bottom-right-radius:999px}[dir=rtl] .mat-calendar-body-comparison-end::after,[dir=rtl] .mat-calendar-body-comparison-end:not(.mat-calendar-body-comparison-bridge-end)::before,[dir=rtl] .mat-calendar-body-preview-end .mat-calendar-body-cell-preview,[dir=rtl] .mat-calendar-body-range-end::after,[dir=rtl] .mat-calendar-body-range-end:not(.mat-calendar-body-in-comparison-range)::before{left:5%;border-radius:999px 0 0 999px}[dir=rtl] .mat-calendar-body-comparison-bridge-end.mat-calendar-body-range-start::after,[dir=rtl] .mat-calendar-body-comparison-bridge-start.mat-calendar-body-range-end::after{width:95%;border-top-right-radius:999px;border-bottom-right-radius:999px}.mat-calendar-body-comparison-end.mat-calendar-body-range-start::after,.mat-calendar-body-comparison-start.mat-calendar-body-range-end::after,[dir=rtl] .mat-calendar-body-comparison-end.mat-calendar-body-range-start::after,[dir=rtl] .mat-calendar-body-comparison-start.mat-calendar-body-range-end::after{width:90%}.mat-calendar-body-in-preview .mat-calendar-body-cell-preview{border-top:1px dashed;border-bottom:1px dashed}.mat-calendar-body-preview-start .mat-calendar-body-cell-preview{border-left:1px dashed}[dir=rtl] .mat-calendar-body-preview-start .mat-calendar-body-cell-preview{border-left:0;border-right:1px dashed}.mat-calendar-body-preview-end .mat-calendar-body-cell-preview{border-right:1px dashed}[dir=rtl] .mat-calendar-body-preview-end .mat-calendar-body-cell-preview{border-right:0;border-left:1px dashed}.mat-calendar-body-disabled{cursor:default}.mat-calendar-body-cell-content{top:5%;left:5%;z-index:1;display:flex;align-items:center;justify-content:center;box-sizing:border-box;width:90%;height:90%;line-height:1;border-width:1px;border-style:solid;border-radius:999px}.mat-calendar-body-cell-content.mat-focus-indicator{position:absolute}.cdk-high-contrast-active .mat-calendar-body-cell-content{border:none}.cdk-high-contrast-active .mat-calendar-body-selected,.cdk-high-contrast-active .mat-datepicker-popup:not(:empty){outline:solid 1px}.cdk-high-contrast-active .mat-calendar-body-today{outline:dotted 1px}.cdk-high-contrast-active .cdk-keyboard-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected),.cdk-high-contrast-active .cdk-program-focused .mat-calendar-body-active>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected){outline:dotted 2px}[dir=rtl] .mat-calendar-body-label{text-align:right}@media (hover:none){.mat-calendar-body-cell:not(.mat-calendar-body-disabled):hover>.mat-calendar-body-cell-content:not(.mat-calendar-body-selected){background-color:transparent}}"]
+    }),
+    __metadata("design:paramtypes", [ElementRef, NgZone])
+], MatCalendarBody);
+export { MatCalendarBody };
+/** Checks whether a node is a table cell element. */
+function isTableCell(node) {
+    return node.nodeName === 'TD';
+}
+/** Checks whether a value is the start of a range. */
+function isStart(value, start, end) {
+    return end !== null && start !== end && value < end && value === start;
+}
+/** Checks whether a value is the end of a range. */
+function isEnd(value, start, end) {
+    return start !== null && start !== end && value >= start && value === end;
+}
+/** Checks whether a value is inside of a range. */
+function isInRange(value, start, end, rangeEnabled) {
+    return rangeEnabled && start !== null && end !== null && start !== end && value >= start && value <= end;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"calendar-body.js","sourceRoot":"ng://@gipisistemas/ng-core/","sources":["shared/gipi-components/datepicker/mat-datepicker/calendar-body.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 { ChangeDetectionStrategy, Component, ElementRef, EventEmitter, Input, NgZone, OnChanges, OnDestroy, Output, SimpleChanges, ViewEncapsulation, } from '@angular/core';\nimport { take } from 'rxjs/operators';\n\n/** Extra CSS classes that can be associated with a calendar cell. */\nexport type MatCalendarCellCssClasses = string | string[] | Set<string> | { [key: string]: any };\n\n/** Function that can generate the extra classes that should be added to a calendar cell. */\nexport type MatCalendarCellClassFunction<D> =\n    (date: D, view: 'month' | 'year' | 'multi-year') => MatCalendarCellCssClasses;\n\n/**\n * An internal class that represents the data corresponding to a single calendar cell.\n * @docs-private\n */\nexport class MatCalendarCell<D = any> {\n    constructor(\n        public value: number,\n        public displayValue: string,\n        public ariaLabel: string,\n        public enabled: boolean,\n        public cssClasses: MatCalendarCellCssClasses = {},\n        public compareValue = value,\n        public rawValue?: D\n    ) { }\n}\n\n/** Event emitted when a date inside the calendar is triggered as a result of a user action. */\nexport interface MatCalendarUserEvent<D> {\n    value: D;\n    event: Event;\n}\n\n/**\n * An internal component used to display calendar data in a table.\n * @docs-private\n */\n@Component({\n    selector: '[gipi-mat-calendar-body]',\n    templateUrl: 'calendar-body.html',\n    styleUrls: ['calendar-body.scss'],\n    host: {\n        'class': 'mat-calendar-body',\n        'role': 'grid',\n        'aria-readonly': 'true'\n    },\n    exportAs: 'gipiMatCalendarBody',\n    encapsulation: ViewEncapsulation.None,\n    changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class MatCalendarBody implements OnChanges, OnDestroy {\n    /**\n     * Used to skip the next focus event when rendering the preview range.\n     * We need a flag like this, because some browsers fire focus events asynchronously.\n     */\n    private _skipNextFocus: boolean;\n\n    /** The label for the table. (e.g. \"Jan 2017\"). */\n    @Input() label: string;\n\n    /** The cells to display in the table. */\n    @Input() rows: MatCalendarCell[][];\n\n    /** The value in the table that corresponds to today. */\n    @Input() todayValue: number;\n\n    /** Start value of the selected date range. */\n    @Input() startValue: number;\n\n    /** End value of the selected date range. */\n    @Input() endValue: number;\n\n    /** The minimum number of free cells needed to fit the label in the first row. */\n    @Input() labelMinRequiredCells: number;\n\n    /** The number of columns in the table. */\n    @Input() numCols: number = 7;\n\n    /** The cell number of the active cell in the table. */\n    @Input() activeCell: number = 0;\n\n    /** Whether a range is being selected. */\n    @Input() isRange: boolean = false;\n\n    /**\n     * The aspect ratio (width / height) to use for the cells in the table. This aspect ratio will be\n     * maintained even as the table resizes.\n     */\n    @Input() cellAspectRatio: number = 1;\n\n    /** Start of the comparison range. */\n    @Input() comparisonStart: number | null;\n\n    /** End of the comparison range. */\n    @Input() comparisonEnd: number | null;\n\n    /** Start of the preview range. */\n    @Input() previewStart: number | null = null;\n\n    /** End of the preview range. */\n    @Input() previewEnd: number | null = null;\n\n    /** Emits when a new value is selected. */\n    @Output() readonly selectedValueChange: EventEmitter<MatCalendarUserEvent<number>> =\n        new EventEmitter<MatCalendarUserEvent<number>>();\n\n    /** Emits when the preview has changed as a result of a user action. */\n    @Output() previewChange = new EventEmitter<MatCalendarUserEvent<MatCalendarCell | null>>();\n\n    /** The number of blank cells to put at the beginning for the first row. */\n    _firstRowOffset: number;\n\n    /** Padding for the individual date cells. */\n    _cellPadding: string;\n\n    /** Width of an individual cell. */\n    _cellWidth: string;\n\n    constructor(private _elementRef: ElementRef<HTMLElement>, private _ngZone: NgZone) {\n        _ngZone.runOutsideAngular(() => {\n            const element = _elementRef.nativeElement;\n            element.addEventListener('mouseenter', this._enterHandler, true);\n            element.addEventListener('focus', this._enterHandler, true);\n            element.addEventListener('mouseleave', this._leaveHandler, true);\n            element.addEventListener('blur', this._leaveHandler, true);\n        });\n    }\n\n    /** Called when a cell is clicked. */\n    _cellClicked(cell: MatCalendarCell, event: MouseEvent): void {\n        if (cell.enabled) {\n            this.selectedValueChange.emit({ value: cell.value, event });\n        }\n    }\n\n    /** Returns whether a cell should be marked as selected. */\n    _isSelected(value: number) {\n        return this.startValue === value || this.endValue === value;\n    }\n\n    ngOnChanges(changes: SimpleChanges) {\n        const columnChanges = changes['numCols'];\n        const { rows, numCols } = this;\n\n        if (changes['rows'] || columnChanges) {\n            this._firstRowOffset = rows && rows.length && rows[0].length ? numCols - rows[0].length : 0;\n        }\n\n        if (changes['cellAspectRatio'] || columnChanges || !this._cellPadding) {\n            this._cellPadding = `${50 * this.cellAspectRatio / numCols}%`;\n        }\n\n        if (columnChanges || !this._cellWidth) {\n            this._cellWidth = `${100 / numCols}%`;\n        }\n    }\n\n    ngOnDestroy() {\n        const element = this._elementRef.nativeElement;\n        element.removeEventListener('mouseenter', this._enterHandler, true);\n        element.removeEventListener('focus', this._enterHandler, true);\n        element.removeEventListener('mouseleave', this._leaveHandler, true);\n        element.removeEventListener('blur', this._leaveHandler, true);\n    }\n\n    /** Returns whether a cell is active. */\n    _isActiveCell(rowIndex: number, colIndex: number): boolean {\n        let cellNumber = rowIndex * this.numCols + colIndex;\n\n        // Account for the fact that the first row may not have as many cells.\n        if (rowIndex) {\n            cellNumber -= this._firstRowOffset;\n        }\n\n        return cellNumber == this.activeCell;\n    }\n\n    /** Focuses the active cell after the microtask queue is empty. */\n    _focusActiveCell(movePreview = true) {\n        this._ngZone.runOutsideAngular(() => {\n            this._ngZone.onStable.pipe(take(1)).subscribe(() => {\n                const activeCell: HTMLElement | null =\n                    this._elementRef.nativeElement.querySelector('.mat-calendar-body-active');\n\n                if (activeCell) {\n                    if (!movePreview) {\n                        this._skipNextFocus = true;\n                    }\n\n                    activeCell.focus();\n                }\n            });\n        });\n    }\n\n    /** Gets whether a value is the start of the main range. */\n    _isRangeStart(value: number) {\n        return isStart(value, this.startValue, this.endValue);\n    }\n\n    /** Gets whether a value is the end of the main range. */\n    _isRangeEnd(value: number) {\n        return isEnd(value, this.startValue, this.endValue);\n    }\n\n    /** Gets whether a value is within the currently-selected range. */\n    _isInRange(value: number): boolean {\n        return isInRange(value, this.startValue, this.endValue, this.isRange);\n    }\n\n    /** Gets whether a value is the start of the comparison range. */\n    _isComparisonStart(value: number) {\n        return isStart(value, this.comparisonStart, this.comparisonEnd);\n    }\n\n    /** Whether the cell is a start bridge cell between the main and comparison ranges. */\n    _isComparisonBridgeStart(value: number, rowIndex: number, colIndex: number) {\n        if (!this._isComparisonStart(value) || this._isRangeStart(value) || !this._isInRange(value)) {\n            return false;\n        }\n\n        let previousCell: MatCalendarCell | undefined = this.rows[rowIndex][colIndex - 1];\n\n        if (!previousCell) {\n            const previousRow = this.rows[rowIndex - 1];\n            previousCell = previousRow && previousRow[previousRow.length - 1];\n        }\n\n        return previousCell && !this._isRangeEnd(previousCell.compareValue);\n    }\n\n    /** Whether the cell is an end bridge cell between the main and comparison ranges. */\n    _isComparisonBridgeEnd(value: number, rowIndex: number, colIndex: number) {\n        if (!this._isComparisonEnd(value) || this._isRangeEnd(value) || !this._isInRange(value)) {\n            return false;\n        }\n\n        let nextCell: MatCalendarCell | undefined = this.rows[rowIndex][colIndex + 1];\n\n        if (!nextCell) {\n            const nextRow = this.rows[rowIndex + 1];\n            nextCell = nextRow && nextRow[0];\n        }\n\n        return nextCell && !this._isRangeStart(nextCell.compareValue);\n    }\n\n    /** Gets whether a value is the end of the comparison range. */\n    _isComparisonEnd(value: number) {\n        return isEnd(value, this.comparisonStart, this.comparisonEnd);\n    }\n\n    /** Gets whether a value is within the current comparison range. */\n    _isInComparisonRange(value: number) {\n        return isInRange(value, this.comparisonStart, this.comparisonEnd, this.isRange);\n    }\n\n    /**\n     * Gets whether a value is the same as the start and end of the comparison range.\n     * For context, the functions that we use to determine whether something is the start/end of\n     * a range don't allow for the start and end to be on the same day, because we'd have to use\n     * much more specific CSS selectors to style them correctly in all scenarios. This is fine for\n     * the regular range, because when it happens, the selected styles take over and still show where\n     * the range would've been, however we don't have these selected styles for a comparison range.\n     * This function is used to apply a class that serves the same purpose as the one for selected\n     * dates, but it only applies in the context of a comparison range.\n     */\n    _isComparisonIdentical(value: number) {\n        // Note that we don't need to null check the start/end\n        // here, because the `value` will always be defined.\n        return this.comparisonStart === this.comparisonEnd && value === this.comparisonStart;\n    }\n\n    /** Gets whether a value is the start of the preview range. */\n    _isPreviewStart(value: number) {\n        return isStart(value, this.previewStart, this.previewEnd);\n    }\n\n    /** Gets whether a value is the end of the preview range. */\n    _isPreviewEnd(value: number) {\n        return isEnd(value, this.previewStart, this.previewEnd);\n    }\n\n    /** Gets whether a value is inside the preview range. */\n    _isInPreview(value: number) {\n        return isInRange(value, this.previewStart, this.previewEnd, this.isRange);\n    }\n\n    /**\n     * Event handler for when the user enters an element\n     * inside the calendar body (e.g. by hovering in or focus).\n     */\n    private _enterHandler = (event: Event) => {\n        if (this._skipNextFocus && event.type === 'focus') {\n            this._skipNextFocus = false;\n            return;\n        }\n\n        // We only need to hit the zone when we're selecting a range.\n        if (event.target && this.isRange) {\n            const cell = this._getCellFromElement(event.target as HTMLElement);\n\n            if (cell) {\n                this._ngZone.run(() => this.previewChange.emit({ value: cell.enabled ? cell : null, event }));\n            }\n        }\n    }\n\n    /**\n     * Event handler for when the user's pointer leaves an element\n     * inside the calendar body (e.g. by hovering out or blurring).\n     */\n    private _leaveHandler = (event: Event) => {\n        // We only need to hit the zone when we're selecting a range.\n        if (this.previewEnd !== null && this.isRange) {\n            // Only reset the preview end value when leaving cells. This looks better, because\n            // we have a gap between the cells and the rows and we don't want to remove the\n            // range just for it to show up again when the user moves a few pixels to the side.\n            if (event.target && isTableCell(event.target as HTMLElement)) {\n                this._ngZone.run(() => this.previewChange.emit({ value: null, event }));\n            }\n        }\n    }\n\n    /** Finds the MatCalendarCell that corresponds to a DOM node. */\n    private _getCellFromElement(element: HTMLElement): MatCalendarCell | null {\n        let cell: HTMLElement | undefined;\n\n        if (isTableCell(element)) {\n            cell = element;\n        } else if (isTableCell(element.parentNode!)) {\n            cell = element.parentNode as HTMLElement;\n        }\n\n        if (cell) {\n            const row = cell.getAttribute('data-mat-row');\n            const col = cell.getAttribute('data-mat-col');\n\n            if (row && col) {\n                return this.rows[parseInt(row)][parseInt(col)];\n            }\n        }\n\n        return null;\n    }\n\n}\n\n/** Checks whether a node is a table cell element. */\nfunction isTableCell(node: Node): node is HTMLTableCellElement {\n    return node.nodeName === 'TD';\n}\n\n/** Checks whether a value is the start of a range. */\nfunction isStart(value: number, start: number | null, end: number | null): boolean {\n    return end !== null && start !== end && value < end && value === start;\n}\n\n/** Checks whether a value is the end of a range. */\nfunction isEnd(value: number, start: number | null, end: number | null): boolean {\n    return start !== null && start !== end && value >= start && value === end;\n}\n\n/** Checks whether a value is inside of a range. */\nfunction isInRange(value: number, start: number | null, end: number | null, rangeEnabled: boolean): boolean {\n    return rangeEnabled && start !== null && end !== null && start !== end && value >= start && value <= end;\n}\n"]}