@gipisistemas/ng-core 1.1.0 → 1.1.1

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

@@ -0,0 +1,555 @@
+/**
+ * @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 { ESCAPE, UP_ARROW } from '@angular/cdk/keycodes';
+import { Overlay, OverlayConfig, } from '@angular/cdk/overlay';
+import { ComponentPortal } from '@angular/cdk/portal';
+import { DOCUMENT } from '@angular/common';
+import { AfterViewInit, ChangeDetectionStrategy, ChangeDetectorRef, Component, ComponentRef, Directive, ElementRef, EventEmitter, Inject, InjectionToken, Input, NgZone, OnChanges, OnDestroy, Optional, Output, SimpleChanges, TemplateRef, ViewChild, ViewContainerRef, ViewEncapsulation } from '@angular/core';
+import { mixinColor, } from '@angular/material/core';
+import { MatDialog } from '@angular/material/dialog';
+import { merge, Subject, Subscription } from 'rxjs';
+import { filter, take } from 'rxjs/operators';
+import { MatCalendar } from './calendar';
+import { MAT_DATE_RANGE_SELECTION_STRATEGY, } from './date-range-selection-strategy';
+import { DateRange, ExtractDateTypeFromSelection, MatDateSelectionModel, } from './date-selection-model';
+import { matDatepickerAnimations } from './datepicker-animations';
+import { createMissingDateImplError } from './datepicker-errors';
+import { DateAdapter } from './shared/adapter/date-adapter';
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+/** Used to generate a unique ID for each datepicker instance. */
+let datepickerUid = 0;
+/** Injection token that determines the scroll handling while the calendar is open. */
+export const MAT_DATEPICKER_SCROLL_STRATEGY = new InjectionToken('mat-datepicker-scroll-strategy');
+/** @docs-private */
+export function MAT_DATEPICKER_SCROLL_STRATEGY_FACTORY(overlay) {
+    return () => overlay.scrollStrategies.reposition();
+}
+/** @docs-private */
+export const MAT_DATEPICKER_SCROLL_STRATEGY_FACTORY_PROVIDER = {
+    provide: MAT_DATEPICKER_SCROLL_STRATEGY,
+    deps: [Overlay],
+    useFactory: MAT_DATEPICKER_SCROLL_STRATEGY_FACTORY,
+};
+// Boilerplate for applying mixins to MatDatepickerContent.
+/** @docs-private */
+class MatDatepickerContentBase {
+    constructor(_elementRef) {
+        this._elementRef = _elementRef;
+    }
+}
+const _MatDatepickerContentMixinBase = mixinColor(MatDatepickerContentBase);
+/**
+ * Component used as the content for the datepicker dialog and popup. We use this instead of using
+ * MatCalendar directly as the content so we can control the initial focus. This also gives us a
+ * place to put additional features of the popup that are not part of the calendar itself in the
+ * future. (e.g. confirmation buttons).
+ * @docs-private
+ */
+let MatDatepickerContent = class MatDatepickerContent extends _MatDatepickerContentMixinBase {
+    constructor(elementRef, 
+    /**
+     * @deprecated `_changeDetectorRef`, `_model` and `_rangeSelectionStrategy`
+     * parameters to become required.
+     * @breaking-change 11.0.0
+     */
+    _changeDetectorRef, _model, _dateAdapter, _rangeSelectionStrategy) {
+        super(elementRef);
+        this._changeDetectorRef = _changeDetectorRef;
+        this._model = _model;
+        this._dateAdapter = _dateAdapter;
+        this._rangeSelectionStrategy = _rangeSelectionStrategy;
+        this._subscriptions = new Subscription();
+        /** Current state of the animation. */
+        this._animationState = 'enter';
+        /** Emits when an animation has finished. */
+        this._animationDone = new Subject();
+    }
+    ngAfterViewInit() {
+        // @breaking-change 11.0.0 Remove null check for `_changeDetectorRef.
+        if (this._changeDetectorRef) {
+            this._subscriptions.add(this.datepicker._stateChanges.subscribe(() => {
+                this._changeDetectorRef.markForCheck();
+            }));
+        }
+        this._calendar.focusActiveCell();
+    }
+    ngOnDestroy() {
+        this._subscriptions.unsubscribe();
+        this._animationDone.complete();
+    }
+    _handleUserSelection(event) {
+        // @breaking-change 11.0.0 Remove null checks for _model,
+        // _rangeSelectionStrategy and _dateAdapter.
+        if (this._model && this._dateAdapter) {
+            const selection = this._model.selection;
+            const value = event.value;
+            const isRange = selection instanceof DateRange;
+            // If we're selecting a range and we have a selection strategy, always pass the value through
+            // there. Otherwise don't assign null values to the model, unless we're selecting a range.
+            // A null value when picking a range means that the user cancelled the selection (e.g. by
+            // pressing escape), whereas when selecting a single value it means that the value didn't
+            // change. This isn't very intuitive, but it's here for backwards-compatibility.
+            if (isRange && this._rangeSelectionStrategy) {
+                const newSelection = this._rangeSelectionStrategy.selectionFinished(value, selection, event.event);
+                this._model.updateSelection(newSelection, this);
+            }
+            else if (value && (isRange ||
+                !this._dateAdapter.sameDate(value, selection))) {
+                this._model.add(value);
+            }
+        }
+        if (!this._model || this._model.isComplete()) {
+            this.datepicker.close();
+        }
+    }
+    _startExitAnimation() {
+        this._animationState = 'void';
+        // @breaking-change 11.0.0 Remove null check for `_changeDetectorRef`.
+        if (this._changeDetectorRef) {
+            this._changeDetectorRef.markForCheck();
+        }
+    }
+    _getSelected() {
+        // @breaking-change 11.0.0 Remove null check for `_model`.
+        return this._model ? this._model.selection : null;
+    }
+};
+MatDatepickerContent.ctorParameters = () => [
+    { type: ElementRef },
+    { type: ChangeDetectorRef },
+    { type: MatDateSelectionModel },
+    { type: DateAdapter },
+    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [MAT_DATE_RANGE_SELECTION_STRATEGY,] }] }
+];
+__decorate([
+    ViewChild(MatCalendar, { static: true }),
+    __metadata("design:type", MatCalendar)
+], MatDatepickerContent.prototype, "_calendar", void 0);
+MatDatepickerContent = __decorate([
+    Component({
+        selector: 'gipi-mat-datepicker-content',
+        template: "<gipi-mat-calendar cdkTrapFocus\n                   [id]=\"datepicker.id\"\n                   [ngClass]=\"datepicker.panelClass\"\n                   [startAt]=\"datepicker.startAt\"\n                   [startView]=\"datepicker.startView\"\n                   [minDate]=\"datepicker._getMinDate()\"\n                   [maxDate]=\"datepicker._getMaxDate()\"\n                   [dateFilter]=\"datepicker._getDateFilter()\"\n                   [templatePresetRange]=\"datepicker.templatePresetRange\"\n                   [selected]=\"_getSelected()\"\n                   [dateClass]=\"datepicker.dateClass\"\n                   [comparisonStart]=\"comparisonStart\"\n                   [comparisonEnd]=\"comparisonEnd\"\n                   [@fadeInCalendar]=\"'enter'\"\n                   (yearSelected)=\"datepicker._selectYear($event)\"\n                   (monthSelected)=\"datepicker._selectMonth($event)\"\n                   (_userSelection)=\"_handleUserSelection($event)\">\n</gipi-mat-calendar>",
+        host: {
+            'class': 'mat-datepicker-content',
+            '[@transformPanel]': '_animationState',
+            '(@transformPanel.done)': '_animationDone.next()',
+            '[class.mat-datepicker-content-touch]': 'datepicker.touchUi',
+        },
+        animations: [
+            matDatepickerAnimations.transformPanel,
+            matDatepickerAnimations.fadeInCalendar,
+        ],
+        exportAs: 'gipiMatDatepickerContent',
+        encapsulation: ViewEncapsulation.None,
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        inputs: ['color'],
+        styles: [".mat-datepicker-content{display:block;border-radius:4px}.mat-datepicker-content .mat-calendar{min-width:296px;height:365px}.mat-datepicker-content .gipi-mat-calendar-wrapper .gipi-mat-calendar-content{min-width:296px;min-height:365px;border-left:1px solid rgba(0,0,0,.12)}.mat-datepicker-content-touch{display:block;max-height:80vh;overflow:auto;margin:-24px}.mat-datepicker-content-touch .mat-calendar{min-width:250px;min-height:312px;max-width:750px;max-height:788px}@media all and (orientation:landscape){.mat-datepicker-content-touch .mat-calendar{width:64vh;height:80vh}}@media all and (orientation:portrait){.mat-datepicker-content-touch .mat-calendar{width:80vw;height:100vw}}"]
+    }),
+    __param(4, Optional()), __param(4, Inject(MAT_DATE_RANGE_SELECTION_STRATEGY)),
+    __metadata("design:paramtypes", [ElementRef,
+        ChangeDetectorRef,
+        MatDateSelectionModel,
+        DateAdapter, Object])
+], MatDatepickerContent);
+export { MatDatepickerContent };
+/** Base class for a datepicker. */
+let MatDatepickerBase = class MatDatepickerBase {
+    constructor(_dialog, _overlay, _ngZone, _viewContainerRef, scrollStrategy, _dateAdapter, _dir, _document, _model) {
+        this._dialog = _dialog;
+        this._overlay = _overlay;
+        this._ngZone = _ngZone;
+        this._viewContainerRef = _viewContainerRef;
+        this._dateAdapter = _dateAdapter;
+        this._dir = _dir;
+        this._document = _document;
+        this._model = _model;
+        this._inputStateChanges = Subscription.EMPTY;
+        /** The view that the calendar should start in. */
+        this.startView = 'month';
+        this._touchUi = false;
+        /** Preferred position of the datepicker in the X axis. */
+        this.xPosition = 'start';
+        /** Preferred position of the datepicker in the Y axis. */
+        this.yPosition = 'below';
+        /**
+         * Emits selected year in multiyear view.
+         * This doesn't imply a change on the selected date.
+         */
+        this.yearSelected = new EventEmitter();
+        /**
+         * Emits selected month in year view.
+         * This doesn't imply a change on the selected date.
+         */
+        this.monthSelected = new EventEmitter();
+        /** Emits when the datepicker has been opened. */
+        this.openedStream = new EventEmitter();
+        /** Emits when the datepicker has been closed. */
+        this.closedStream = new EventEmitter();
+        this._opened = false;
+        /** The id for the datepicker calendar. */
+        this.id = `mat-datepicker-${datepickerUid++}`;
+        /** The element that was focused before the datepicker was opened. */
+        this._focusedElementBeforeOpen = null;
+        /** Unique class that will be added to the backdrop so that the test harnesses can look it up. */
+        this._backdropHarnessClass = `${this.id}-backdrop`;
+        /** Emits when the datepicker's state changes. */
+        this._stateChanges = new Subject();
+        if (!this._dateAdapter) {
+            throw createMissingDateImplError('DateAdapter');
+        }
+        this._scrollStrategy = scrollStrategy;
+    }
+    /** The date to open the calendar to initially. */
+    get startAt() {
+        // If an explicit startAt is set we start there, otherwise we start at whatever the currently
+        // selected value is.
+        return this._startAt || (this._datepickerInput ? this._datepickerInput.getStartValue() : null);
+    }
+    set startAt(value) {
+        this._startAt = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));
+    }
+    /** Color palette to use on the datepicker's calendar. */
+    get color() {
+        return this._color || (this._datepickerInput ? this._datepickerInput.getThemePalette() : undefined);
+    }
+    set color(value) {
+        this._color = value;
+    }
+    /**
+     * Whether the calendar UI is in touch mode. In touch mode the calendar opens in a dialog rather
+     * than a popup and elements have more padding to allow for bigger touch targets.
+     */
+    get touchUi() { return this._touchUi; }
+    set touchUi(value) {
+        this._touchUi = coerceBooleanProperty(value);
+    }
+    /** Whether the datepicker pop-up should be disabled. */
+    get disabled() {
+        return this._disabled === undefined && this._datepickerInput ?
+            this._datepickerInput.disabled : !!this._disabled;
+    }
+    set disabled(value) {
+        const newValue = coerceBooleanProperty(value);
+        if (newValue !== this._disabled) {
+            this._disabled = newValue;
+            this._stateChanges.next(undefined);
+        }
+    }
+    /** Whether the calendar is open. */
+    get opened() { return this._opened; }
+    set opened(value) {
+        coerceBooleanProperty(value) ? this.open() : this.close();
+    }
+    /** The minimum selectable date. */
+    _getMinDate() {
+        return this._datepickerInput && this._datepickerInput.min;
+    }
+    /** The maximum selectable date. */
+    _getMaxDate() {
+        return this._datepickerInput && this._datepickerInput.max;
+    }
+    _getDateFilter() {
+        return this._datepickerInput && this._datepickerInput.dateFilter;
+    }
+    ngOnChanges(changes) {
+        const positionChange = changes['xPosition'] || changes['yPosition'];
+        if (positionChange && !positionChange.firstChange && this._popupRef) {
+            this._setConnectedPositions(this._popupRef.getConfig().positionStrategy);
+            if (this.opened) {
+                this._popupRef.updatePosition();
+            }
+        }
+        this._stateChanges.next(undefined);
+    }
+    ngOnDestroy() {
+        this._destroyPopup();
+        this.close();
+        this._inputStateChanges.unsubscribe();
+        this._stateChanges.complete();
+    }
+    /** Selects the given date */
+    select(date) {
+        this._model.add(date);
+    }
+    /** Emits the selected year in multiyear view */
+    _selectYear(normalizedYear) {
+        this.yearSelected.emit(normalizedYear);
+    }
+    /** Emits selected month in year view */
+    _selectMonth(normalizedMonth) {
+        this.monthSelected.emit(normalizedMonth);
+    }
+    /**
+     * Register an input with this datepicker.
+     * @param input The datepicker input to register with this datepicker.
+     * @returns Selection model that the input should hook itself up to.
+     */
+    _registerInput(input) {
+        if (this._datepickerInput) {
+            throw Error('A MatDatepicker can only be associated with a single input.');
+        }
+        this._inputStateChanges.unsubscribe();
+        this._datepickerInput = input;
+        this._inputStateChanges = input.stateChanges.subscribe(() => this._stateChanges.next(undefined));
+        return this._model;
+    }
+    /** Open the calendar. */
+    open() {
+        if (this._opened || this.disabled) {
+            return;
+        }
+        if (!this._datepickerInput) {
+            throw Error('Attempted to open an MatDatepicker with no associated input.');
+        }
+        if (this._document) {
+            this._focusedElementBeforeOpen = this._document.activeElement;
+        }
+        this.touchUi ? this._openAsDialog() : this._openAsPopup();
+        this._opened = true;
+        this.openedStream.emit();
+    }
+    /** Close the calendar. */
+    close() {
+        if (!this._opened) {
+            return;
+        }
+        if (this._popupComponentRef && this._popupRef) {
+            const instance = this._popupComponentRef.instance;
+            instance._startExitAnimation();
+            instance._animationDone.pipe(take(1)).subscribe(() => this._destroyPopup());
+        }
+        if (this._dialogRef) {
+            this._dialogRef.close();
+            this._dialogRef = null;
+        }
+        const completeClose = () => {
+            // The `_opened` could've been reset already if
+            // we got two events in quick succession.
+            if (this._opened) {
+                this._opened = false;
+                this.closedStream.emit();
+                this._focusedElementBeforeOpen = null;
+            }
+        };
+        if (this._focusedElementBeforeOpen &&
+            typeof this._focusedElementBeforeOpen.focus === 'function') {
+            // Because IE moves focus asynchronously, we can't count on it being restored before we've
+            // marked the datepicker as closed. If the event fires out of sequence and the element that
+            // we're refocusing opens the datepicker on focus, the user could be stuck with not being
+            // able to close the calendar at all. We work around it by making the logic, that marks
+            // the datepicker as closed, async as well.
+            this._focusedElementBeforeOpen.focus();
+            setTimeout(completeClose);
+        }
+        else {
+            completeClose();
+        }
+    }
+    /** Open the calendar as a dialog. */
+    _openAsDialog() {
+        // Usually this would be handled by `open` which ensures that we can only have one overlay
+        // open at a time, however since we reset the variables in async handlers some overlays
+        // may slip through if the user opens and closes multiple times in quick succession (e.g.
+        // by holding down the enter key).
+        if (this._dialogRef) {
+            this._dialogRef.close();
+        }
+        this._dialogRef = this._dialog.open(MatDatepickerContent, {
+            direction: this._dir ? this._dir.value : 'ltr',
+            viewContainerRef: this._viewContainerRef,
+            panelClass: 'mat-datepicker-dialog',
+            // These values are all the same as the defaults, but we set them explicitly so that the
+            // datepicker dialog behaves consistently even if the user changed the defaults.
+            hasBackdrop: true,
+            disableClose: false,
+            backdropClass: `cdk-overlay-dark-backdrop, ${this._backdropHarnessClass}`,
+            width: '',
+            height: '',
+            minWidth: '',
+            minHeight: '',
+            maxWidth: '80vw',
+            maxHeight: '',
+            position: {},
+            autoFocus: true,
+            // `MatDialog` has focus restoration built in, however we want to disable it since the
+            // datepicker also has focus restoration for dropdown mode. We want to do this, in order
+            // to ensure that the timing is consistent between dropdown and dialog modes since `MatDialog`
+            // restores focus when the animation is finished, but the datepicker does it immediately.
+            // Furthermore, this avoids any conflicts where the datepicker consumer might move focus
+            // inside the `closed` event which is dispatched immediately.
+            restoreFocus: false
+        });
+        this._dialogRef.afterClosed().subscribe(() => this.close());
+        this._forwardContentValues(this._dialogRef.componentInstance);
+    }
+    /** Open the calendar as a popup. */
+    _openAsPopup() {
+        const portal = new ComponentPortal(MatDatepickerContent, this._viewContainerRef);
+        this._destroyPopup();
+        this._createPopup();
+        this._popupComponentRef = this._popupRef.attach(portal);
+        this._forwardContentValues(this._popupComponentRef.instance);
+        // Update the position once the calendar has rendered.
+        this._ngZone.onStable.pipe(take(1)).subscribe(() => {
+            this._popupRef.updatePosition();
+        });
+    }
+    /** Forwards relevant values from the datepicker to the datepicker content inside the overlay. */
+    _forwardContentValues(instance) {
+        instance.datepicker = this;
+        instance.color = this.color;
+    }
+    /** Create the popup. */
+    _createPopup() {
+        const positionStrategy = this._overlay.position()
+            .flexibleConnectedTo(this._datepickerInput.getConnectedOverlayOrigin())
+            .withTransformOriginOn('.mat-datepicker-content')
+            .withFlexibleDimensions(false)
+            .withViewportMargin(8)
+            .withLockedPosition();
+        const overlayConfig = new OverlayConfig({
+            positionStrategy: this._setConnectedPositions(positionStrategy),
+            hasBackdrop: true,
+            backdropClass: ['mat-overlay-transparent-backdrop', this._backdropHarnessClass],
+            direction: this._dir,
+            scrollStrategy: this._scrollStrategy(),
+            panelClass: 'mat-datepicker-popup',
+        });
+        this._popupRef = this._overlay.create(overlayConfig);
+        this._popupRef.overlayElement.setAttribute('role', 'dialog');
+        merge(this._popupRef.backdropClick(), this._popupRef.detachments(), this._popupRef.keydownEvents().pipe(filter(event => {
+            // Closing on alt + up is only valid when there's an input associated with the datepicker.
+            return event.keyCode === ESCAPE || (this._datepickerInput && event.altKey && event.keyCode === UP_ARROW);
+        }))).subscribe(event => {
+            if (event) {
+                event.preventDefault();
+            }
+            this.close();
+        });
+    }
+    /** Destroys the current popup overlay. */
+    _destroyPopup() {
+        if (this._popupRef) {
+            this._popupRef.dispose();
+            this._popupRef = this._popupComponentRef = null;
+        }
+    }
+    /** Sets the positions of the datepicker in dropdown mode based on the current configuration. */
+    _setConnectedPositions(strategy) {
+        const primaryX = this.xPosition === 'end' ? 'end' : 'start';
+        const secondaryX = primaryX === 'start' ? 'end' : 'start';
+        const primaryY = this.yPosition === 'above' ? 'bottom' : 'top';
+        const secondaryY = primaryY === 'top' ? 'bottom' : 'top';
+        return strategy.withPositions([
+            {
+                originX: primaryX,
+                originY: secondaryY,
+                overlayX: primaryX,
+                overlayY: primaryY
+            },
+            {
+                originX: primaryX,
+                originY: primaryY,
+                overlayX: primaryX,
+                overlayY: secondaryY
+            },
+            {
+                originX: secondaryX,
+                originY: secondaryY,
+                overlayX: secondaryX,
+                overlayY: primaryY
+            },
+            {
+                originX: secondaryX,
+                originY: primaryY,
+                overlayX: secondaryX,
+                overlayY: secondaryY
+            }
+        ]);
+    }
+};
+__decorate([
+    Input(),
+    __metadata("design:type", TemplateRef)
+], MatDatepickerBase.prototype, "templatePresetRange", void 0);
+__decorate([
+    Input(),
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [Object])
+], MatDatepickerBase.prototype, "startAt", null);
+__decorate([
+    Input(),
+    __metadata("design:type", String)
+], MatDatepickerBase.prototype, "startView", void 0);
+__decorate([
+    Input(),
+    __metadata("design:type", String),
+    __metadata("design:paramtypes", [String])
+], MatDatepickerBase.prototype, "color", null);
+__decorate([
+    Input(),
+    __metadata("design:type", Boolean),
+    __metadata("design:paramtypes", [Boolean])
+], MatDatepickerBase.prototype, "touchUi", null);
+__decorate([
+    Input(),
+    __metadata("design:type", Boolean),
+    __metadata("design:paramtypes", [Boolean])
+], MatDatepickerBase.prototype, "disabled", null);
+__decorate([
+    Input(),
+    __metadata("design:type", String)
+], MatDatepickerBase.prototype, "xPosition", void 0);
+__decorate([
+    Input(),
+    __metadata("design:type", String)
+], MatDatepickerBase.prototype, "yPosition", void 0);
+__decorate([
+    Output(),
+    __metadata("design:type", EventEmitter)
+], MatDatepickerBase.prototype, "yearSelected", void 0);
+__decorate([
+    Output(),
+    __metadata("design:type", EventEmitter)
+], MatDatepickerBase.prototype, "monthSelected", void 0);
+__decorate([
+    Input(),
+    __metadata("design:type", Object)
+], MatDatepickerBase.prototype, "panelClass", void 0);
+__decorate([
+    Input(),
+    __metadata("design:type", Function)
+], MatDatepickerBase.prototype, "dateClass", void 0);
+__decorate([
+    Output('opened'),
+    __metadata("design:type", EventEmitter)
+], MatDatepickerBase.prototype, "openedStream", void 0);
+__decorate([
+    Output('closed'),
+    __metadata("design:type", EventEmitter)
+], MatDatepickerBase.prototype, "closedStream", void 0);
+__decorate([
+    Input(),
+    __metadata("design:type", Boolean),
+    __metadata("design:paramtypes", [Boolean])
+], MatDatepickerBase.prototype, "opened", null);
+MatDatepickerBase = __decorate([
+    __param(4, Inject(MAT_DATEPICKER_SCROLL_STRATEGY)),
+    __param(5, Optional()),
+    __param(6, Optional()),
+    __param(7, Optional()), __param(7, Inject(DOCUMENT)),
+    __metadata("design:paramtypes", [MatDialog,
+        Overlay,
+        NgZone,
+        ViewContainerRef, Object, DateAdapter,
+        Directionality, Object, MatDateSelectionModel])
+], MatDatepickerBase);
+export { MatDatepickerBase };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"datepicker-base.js","sourceRoot":"ng://@gipisistemas/ng-core/","sources":["shared/gipi-components/datepicker/mat-datepicker/datepicker-base.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 { ESCAPE, UP_ARROW } from '@angular/cdk/keycodes';\nimport { FlexibleConnectedPositionStrategy, Overlay, OverlayConfig, OverlayRef, ScrollStrategy, } from '@angular/cdk/overlay';\nimport { ComponentPortal, ComponentType } from '@angular/cdk/portal';\nimport { DOCUMENT } from '@angular/common';\nimport { AfterViewInit, ChangeDetectionStrategy, ChangeDetectorRef, Component, ComponentRef, Directive, ElementRef, EventEmitter, Inject, InjectionToken, Input, NgZone, OnChanges, OnDestroy, Optional, Output, SimpleChanges, TemplateRef, ViewChild, ViewContainerRef, ViewEncapsulation } from '@angular/core';\nimport { CanColor, CanColorCtor, mixinColor, ThemePalette, } from '@angular/material/core';\nimport { MatDialog, MatDialogRef } from '@angular/material/dialog';\nimport { merge, Observable, Subject, Subscription } from 'rxjs';\nimport { filter, take } from 'rxjs/operators';\nimport { MatCalendar } from './calendar';\nimport { MatCalendarCellClassFunction, MatCalendarUserEvent } from './calendar-body';\nimport { MAT_DATE_RANGE_SELECTION_STRATEGY, MatDateRangeSelectionStrategy, } from './date-range-selection-strategy';\nimport { DateRange, ExtractDateTypeFromSelection, MatDateSelectionModel, } from './date-selection-model';\nimport { matDatepickerAnimations } from './datepicker-animations';\nimport { createMissingDateImplError } from './datepicker-errors';\nimport { DateFilterFn } from './datepicker-input-base';\nimport { DateAdapter } from './shared/adapter/date-adapter';\nimport { coerceBooleanProperty } from '@angular/cdk/coercion';\n\n/** Used to generate a unique ID for each datepicker instance. */\nlet datepickerUid = 0;\n\n/** Injection token that determines the scroll handling while the calendar is open. */\nexport const MAT_DATEPICKER_SCROLL_STRATEGY = new InjectionToken<() => ScrollStrategy>('mat-datepicker-scroll-strategy');\n\n/** @docs-private */\nexport function MAT_DATEPICKER_SCROLL_STRATEGY_FACTORY(overlay: Overlay): () => ScrollStrategy {\n    return () => overlay.scrollStrategies.reposition();\n}\n\n/** Possible positions for the datepicker dropdown along the X axis. */\nexport type DatepickerDropdownPositionX = 'start' | 'end';\n\n/** Possible positions for the datepicker dropdown along the Y axis. */\nexport type DatepickerDropdownPositionY = 'above' | 'below';\n\n/** @docs-private */\nexport const MAT_DATEPICKER_SCROLL_STRATEGY_FACTORY_PROVIDER = {\n    provide: MAT_DATEPICKER_SCROLL_STRATEGY,\n    deps: [Overlay],\n    useFactory: MAT_DATEPICKER_SCROLL_STRATEGY_FACTORY,\n};\n\n// Boilerplate for applying mixins to MatDatepickerContent.\n/** @docs-private */\nclass MatDatepickerContentBase {\n    constructor(public _elementRef: ElementRef) { }\n}\n\nconst _MatDatepickerContentMixinBase: CanColorCtor & typeof MatDatepickerContentBase = mixinColor(MatDatepickerContentBase);\n\n/**\n * Component used as the content for the datepicker dialog and popup. We use this instead of using\n * MatCalendar directly as the content so we can control the initial focus. This also gives us a\n * place to put additional features of the popup that are not part of the calendar itself in the\n * future. (e.g. confirmation buttons).\n * @docs-private\n */\n@Component({\n    selector: 'gipi-mat-datepicker-content',\n    templateUrl: 'datepicker-content.html',\n    styleUrls: ['datepicker-content.scss'],\n    host: {\n        'class': 'mat-datepicker-content',\n        '[@transformPanel]': '_animationState',\n        '(@transformPanel.done)': '_animationDone.next()',\n        '[class.mat-datepicker-content-touch]': 'datepicker.touchUi',\n    },\n    animations: [\n        matDatepickerAnimations.transformPanel,\n        matDatepickerAnimations.fadeInCalendar,\n    ],\n    exportAs: 'gipiMatDatepickerContent',\n    encapsulation: ViewEncapsulation.None,\n    changeDetection: ChangeDetectionStrategy.OnPush,\n    inputs: ['color'],\n})\nexport class MatDatepickerContent<S, D = ExtractDateTypeFromSelection<S>> extends _MatDatepickerContentMixinBase implements AfterViewInit, OnDestroy, CanColor {\n\n    private _subscriptions = new Subscription();\n\n    /** Reference to the internal calendar component. */\n    @ViewChild(MatCalendar, { static: true }) _calendar: MatCalendar<D>;\n\n    /** Reference to the datepicker that created the overlay. */\n    datepicker: MatDatepickerBase<any, S, D>;\n\n    /** Start of the comparison range. */\n    comparisonStart: D | null;\n\n    /** End of the comparison range. */\n    comparisonEnd: D | null;\n\n    /** Whether the datepicker is above or below the input. */\n    _isAbove: boolean;\n\n    /** Current state of the animation. */\n    _animationState: 'enter' | 'void' = 'enter';\n\n    /** Emits when an animation has finished. */\n    _animationDone = new Subject<void>();\n\n    constructor(\n        elementRef: ElementRef,\n        /**\n         * @deprecated `_changeDetectorRef`, `_model` and `_rangeSelectionStrategy`\n         * parameters to become required.\n         * @breaking-change 11.0.0\n         */\n        private _changeDetectorRef?: ChangeDetectorRef,\n        private _model?: MatDateSelectionModel<S, D>,\n        private _dateAdapter?: DateAdapter<D>,\n        @Optional() @Inject(MAT_DATE_RANGE_SELECTION_STRATEGY)\n        private _rangeSelectionStrategy?: MatDateRangeSelectionStrategy<D>\n    ) {\n        super(elementRef);\n    }\n\n    ngAfterViewInit() {\n        // @breaking-change 11.0.0 Remove null check for `_changeDetectorRef.\n        if (this._changeDetectorRef) {\n            this._subscriptions.add(this.datepicker._stateChanges.subscribe(() => {\n                this._changeDetectorRef!.markForCheck();\n            }));\n        }\n\n        this._calendar.focusActiveCell();\n    }\n\n    ngOnDestroy() {\n        this._subscriptions.unsubscribe();\n        this._animationDone.complete();\n    }\n\n    _handleUserSelection(event: MatCalendarUserEvent<D | null>) {\n        // @breaking-change 11.0.0 Remove null checks for _model,\n        // _rangeSelectionStrategy and _dateAdapter.\n        if (this._model && this._dateAdapter) {\n            const selection = this._model.selection;\n            const value = event.value;\n            const isRange = selection instanceof DateRange;\n\n            // If we're selecting a range and we have a selection strategy, always pass the value through\n            // there. Otherwise don't assign null values to the model, unless we're selecting a range.\n            // A null value when picking a range means that the user cancelled the selection (e.g. by\n            // pressing escape), whereas when selecting a single value it means that the value didn't\n            // change. This isn't very intuitive, but it's here for backwards-compatibility.\n            if (isRange && this._rangeSelectionStrategy) {\n                const newSelection = this._rangeSelectionStrategy.selectionFinished(value,\n                    selection as unknown as DateRange<D>, event.event);\n                this._model.updateSelection(newSelection as unknown as S, this);\n            } else if (value && (isRange ||\n                !this._dateAdapter.sameDate(value, selection as unknown as D))) {\n                this._model.add(value);\n            }\n        }\n\n        if (!this._model || this._model.isComplete()) {\n            this.datepicker.close();\n        }\n    }\n\n    _startExitAnimation() {\n        this._animationState = 'void';\n\n        // @breaking-change 11.0.0 Remove null check for `_changeDetectorRef`.\n        if (this._changeDetectorRef) {\n            this._changeDetectorRef.markForCheck();\n        }\n    }\n\n    _getSelected() {\n        // @breaking-change 11.0.0 Remove null check for `_model`.\n        return this._model ? this._model.selection as unknown as D | DateRange<D> | null : null;\n    }\n}\n\n/** Form control that can be associated with a datepicker. */\nexport interface MatDatepickerControl<D> {\n    getStartValue(): D | null;\n    getThemePalette(): ThemePalette;\n    min: D | null;\n    max: D | null;\n    disabled: boolean;\n    dateFilter: DateFilterFn<D>;\n    getConnectedOverlayOrigin(): ElementRef;\n    stateChanges: Observable<void>;\n}\n\n/** Base class for a datepicker. */\nexport abstract class MatDatepickerBase<C extends MatDatepickerControl<D>, S, D = any> implements OnDestroy, OnChanges {\n\n    private _scrollStrategy: () => ScrollStrategy;\n    private _inputStateChanges = Subscription.EMPTY;\n\n    @Input() templatePresetRange: TemplateRef<any>;\n\n    /** The date to open the calendar to initially. */\n    @Input()\n    get startAt(): D | null {\n        // If an explicit startAt is set we start there, otherwise we start at whatever the currently\n        // selected value is.\n        return this._startAt || (this._datepickerInput ? this._datepickerInput.getStartValue() : null);\n    }\n    set startAt(value: D | null) {\n        this._startAt = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));\n    }\n    private _startAt: D | null;\n\n    /** The view that the calendar should start in. */\n    @Input() startView: 'month' | 'year' | 'multi-year' = 'month';\n\n    /** Color palette to use on the datepicker's calendar. */\n    @Input()\n    get color(): ThemePalette {\n        return this._color || (this._datepickerInput ? this._datepickerInput.getThemePalette() : undefined);\n    }\n    set color(value: ThemePalette) {\n        this._color = value;\n    }\n    _color: ThemePalette;\n\n    /**\n     * Whether the calendar UI is in touch mode. In touch mode the calendar opens in a dialog rather\n     * than a popup and elements have more padding to allow for bigger touch targets.\n     */\n    @Input()\n    get touchUi(): boolean { return this._touchUi; }\n    set touchUi(value: boolean) {\n        this._touchUi = coerceBooleanProperty(value);\n    }\n    private _touchUi = false;\n\n    /** Whether the datepicker pop-up should be disabled. */\n    @Input()\n    get disabled(): boolean {\n        return this._disabled === undefined && this._datepickerInput ?\n            this._datepickerInput.disabled : !!this._disabled;\n    }\n    set disabled(value: boolean) {\n        const newValue = coerceBooleanProperty(value);\n\n        if (newValue !== this._disabled) {\n            this._disabled = newValue;\n            this._stateChanges.next(undefined);\n        }\n    }\n    private _disabled: boolean;\n\n    /** Preferred position of the datepicker in the X axis. */\n    @Input()\n    xPosition: DatepickerDropdownPositionX = 'start';\n\n    /** Preferred position of the datepicker in the Y axis. */\n    @Input()\n    yPosition: DatepickerDropdownPositionY = 'below';\n\n    /**\n     * Emits selected year in multiyear view.\n     * This doesn't imply a change on the selected date.\n     */\n    @Output() readonly yearSelected: EventEmitter<D> = new EventEmitter<D>();\n\n    /**\n     * Emits selected month in year view.\n     * This doesn't imply a change on the selected date.\n     */\n    @Output() readonly monthSelected: EventEmitter<D> = new EventEmitter<D>();\n\n    /** Classes to be passed to the date picker panel. Supports the same syntax as `ngClass`. */\n    @Input() panelClass: string | string[];\n\n    /** Function that can be used to add custom CSS classes to dates. */\n    @Input() dateClass: MatCalendarCellClassFunction<D>;\n\n    /** Emits when the datepicker has been opened. */\n    @Output('opened') openedStream: EventEmitter<void> = new EventEmitter<void>();\n\n    /** Emits when the datepicker has been closed. */\n    @Output('closed') closedStream: EventEmitter<void> = new EventEmitter<void>();\n\n\n    /** Whether the calendar is open. */\n    @Input()\n    get opened(): boolean { return this._opened; }\n    set opened(value: boolean) {\n        coerceBooleanProperty(value) ? this.open() : this.close();\n    }\n    private _opened = false;\n\n    /** The id for the datepicker calendar. */\n    id: string = `mat-datepicker-${datepickerUid++}`;\n\n    /** The minimum selectable date. */\n    _getMinDate(): D | null {\n        return this._datepickerInput && this._datepickerInput.min;\n    }\n\n    /** The maximum selectable date. */\n    _getMaxDate(): D | null {\n        return this._datepickerInput && this._datepickerInput.max;\n    }\n\n    _getDateFilter(): DateFilterFn<D> {\n        return this._datepickerInput && this._datepickerInput.dateFilter;\n    }\n\n    /** A reference to the overlay when the calendar is opened as a popup. */\n    private _popupRef: OverlayRef | null;\n\n    /** A reference to the dialog when the calendar is opened as a dialog. */\n    private _dialogRef: MatDialogRef<MatDatepickerContent<S, D>> | null;\n\n    /** Reference to the component instantiated in popup mode. */\n    private _popupComponentRef: ComponentRef<MatDatepickerContent<S, D>> | null;\n\n    /** The element that was focused before the datepicker was opened. */\n    private _focusedElementBeforeOpen: HTMLElement | null = null;\n\n    /** Unique class that will be added to the backdrop so that the test harnesses can look it up. */\n    private _backdropHarnessClass = `${this.id}-backdrop`;\n\n    /** The input element this datepicker is associated with. */\n    _datepickerInput: C;\n\n    /** Emits when the datepicker's state changes. */\n    readonly _stateChanges = new Subject<void>();\n\n    constructor(\n        private _dialog: MatDialog,\n        private _overlay: Overlay,\n        private _ngZone: NgZone,\n        private _viewContainerRef: ViewContainerRef,\n        @Inject(MAT_DATEPICKER_SCROLL_STRATEGY) scrollStrategy: any,\n        @Optional() private _dateAdapter: DateAdapter<D>,\n        @Optional() private _dir: Directionality,\n        @Optional() @Inject(DOCUMENT) private _document: any,\n        private _model: MatDateSelectionModel<S, D>\n    ) {\n        if (!this._dateAdapter) {\n            throw createMissingDateImplError('DateAdapter');\n        }\n\n        this._scrollStrategy = scrollStrategy;\n    }\n\n    ngOnChanges(changes: SimpleChanges) {\n        const positionChange = changes['xPosition'] || changes['yPosition'];\n\n        if (positionChange && !positionChange.firstChange && this._popupRef) {\n            this._setConnectedPositions(this._popupRef.getConfig().positionStrategy as FlexibleConnectedPositionStrategy);\n\n            if (this.opened) {\n                this._popupRef.updatePosition();\n            }\n        }\n\n        this._stateChanges.next(undefined);\n    }\n\n    ngOnDestroy() {\n        this._destroyPopup();\n        this.close();\n        this._inputStateChanges.unsubscribe();\n        this._stateChanges.complete();\n    }\n\n    /** Selects the given date */\n    select(date: D): void {\n        this._model.add(date);\n    }\n\n    /** Emits the selected year in multiyear view */\n    _selectYear(normalizedYear: D): void {\n        this.yearSelected.emit(normalizedYear);\n    }\n\n    /** Emits selected month in year view */\n    _selectMonth(normalizedMonth: D): void {\n        this.monthSelected.emit(normalizedMonth);\n    }\n\n    /**\n     * Register an input with this datepicker.\n     * @param input The datepicker input to register with this datepicker.\n     * @returns Selection model that the input should hook itself up to.\n     */\n    _registerInput(input: C): MatDateSelectionModel<S, D> {\n        if (this._datepickerInput) {\n            throw Error('A MatDatepicker can only be associated with a single input.');\n        }\n        this._inputStateChanges.unsubscribe();\n        this._datepickerInput = input;\n        this._inputStateChanges = input.stateChanges.subscribe(() => this._stateChanges.next(undefined));\n        return this._model;\n    }\n\n    /** Open the calendar. */\n    open(): void {\n        if (this._opened || this.disabled) {\n            return;\n        }\n        if (!this._datepickerInput) {\n            throw Error('Attempted to open an MatDatepicker with no associated input.');\n        }\n        if (this._document) {\n            this._focusedElementBeforeOpen = this._document.activeElement;\n        }\n\n        this.touchUi ? this._openAsDialog() : this._openAsPopup();\n        this._opened = true;\n        this.openedStream.emit();\n    }\n\n    /** Close the calendar. */\n    close(): void {\n        if (!this._opened) {\n            return;\n        }\n        if (this._popupComponentRef && this._popupRef) {\n            const instance = this._popupComponentRef.instance;\n            instance._startExitAnimation();\n            instance._animationDone.pipe(take(1)).subscribe(() => this._destroyPopup());\n        }\n        if (this._dialogRef) {\n            this._dialogRef.close();\n            this._dialogRef = null;\n        }\n\n        const completeClose = () => {\n            // The `_opened` could've been reset already if\n            // we got two events in quick succession.\n            if (this._opened) {\n                this._opened = false;\n                this.closedStream.emit();\n                this._focusedElementBeforeOpen = null;\n            }\n        };\n\n        if (this._focusedElementBeforeOpen &&\n            typeof this._focusedElementBeforeOpen.focus === 'function') {\n            // Because IE moves focus asynchronously, we can't count on it being restored before we've\n            // marked the datepicker as closed. If the event fires out of sequence and the element that\n            // we're refocusing opens the datepicker on focus, the user could be stuck with not being\n            // able to close the calendar at all. We work around it by making the logic, that marks\n            // the datepicker as closed, async as well.\n            this._focusedElementBeforeOpen.focus();\n            setTimeout(completeClose);\n        } else {\n            completeClose();\n        }\n    }\n\n    /** Open the calendar as a dialog. */\n    private _openAsDialog(): void {\n        // Usually this would be handled by `open` which ensures that we can only have one overlay\n        // open at a time, however since we reset the variables in async handlers some overlays\n        // may slip through if the user opens and closes multiple times in quick succession (e.g.\n        // by holding down the enter key).\n        if (this._dialogRef) {\n            this._dialogRef.close();\n        }\n\n        this._dialogRef = this._dialog.open<MatDatepickerContent<S, D>>(MatDatepickerContent, {\n            direction: this._dir ? this._dir.value : 'ltr',\n            viewContainerRef: this._viewContainerRef,\n            panelClass: 'mat-datepicker-dialog',\n\n            // These values are all the same as the defaults, but we set them explicitly so that the\n            // datepicker dialog behaves consistently even if the user changed the defaults.\n            hasBackdrop: true,\n            disableClose: false,\n            backdropClass: `cdk-overlay-dark-backdrop, ${this._backdropHarnessClass}`,\n            width: '',\n            height: '',\n            minWidth: '',\n            minHeight: '',\n            maxWidth: '80vw',\n            maxHeight: '',\n            position: {},\n            autoFocus: true,\n\n            // `MatDialog` has focus restoration built in, however we want to disable it since the\n            // datepicker also has focus restoration for dropdown mode. We want to do this, in order\n            // to ensure that the timing is consistent between dropdown and dialog modes since `MatDialog`\n            // restores focus when the animation is finished, but the datepicker does it immediately.\n            // Furthermore, this avoids any conflicts where the datepicker consumer might move focus\n            // inside the `closed` event which is dispatched immediately.\n            restoreFocus: false\n        });\n\n        this._dialogRef.afterClosed().subscribe(() => this.close());\n        this._forwardContentValues(this._dialogRef.componentInstance);\n    }\n\n    /** Open the calendar as a popup. */\n    private _openAsPopup(): void {\n        const portal = new ComponentPortal<MatDatepickerContent<S, D>>(MatDatepickerContent, this._viewContainerRef);\n\n        this._destroyPopup();\n        this._createPopup();\n        this._popupComponentRef = this._popupRef!.attach(portal);\n        this._forwardContentValues(this._popupComponentRef.instance);\n\n        // Update the position once the calendar has rendered.\n        this._ngZone.onStable.pipe(take(1)).subscribe(() => {\n            this._popupRef!.updatePosition();\n        });\n    }\n\n    /** Forwards relevant values from the datepicker to the datepicker content inside the overlay. */\n    protected _forwardContentValues(instance: MatDatepickerContent<S, D>) {\n        instance.datepicker = this;\n        instance.color = this.color;\n    }\n\n    /** Create the popup. */\n    private _createPopup(): void {\n        const positionStrategy = this._overlay.position()\n            .flexibleConnectedTo(this._datepickerInput.getConnectedOverlayOrigin())\n            .withTransformOriginOn('.mat-datepicker-content')\n            .withFlexibleDimensions(false)\n            .withViewportMargin(8)\n            .withLockedPosition();\n\n        const overlayConfig = new OverlayConfig({\n            positionStrategy: this._setConnectedPositions(positionStrategy),\n            hasBackdrop: true,\n            backdropClass: ['mat-overlay-transparent-backdrop', this._backdropHarnessClass],\n            direction: this._dir,\n            scrollStrategy: this._scrollStrategy(),\n            panelClass: 'mat-datepicker-popup',\n        });\n\n        this._popupRef = this._overlay.create(overlayConfig);\n        this._popupRef.overlayElement.setAttribute('role', 'dialog');\n\n        merge(\n            this._popupRef.backdropClick(),\n            this._popupRef.detachments(),\n            this._popupRef.keydownEvents().pipe(filter(event => {\n                // Closing on alt + up is only valid when there's an input associated with the datepicker.\n                return event.keyCode === ESCAPE || (this._datepickerInput && event.altKey && event.keyCode === UP_ARROW);\n            }))\n        ).subscribe(event => {\n            if (event) {\n                event.preventDefault();\n            }\n\n            this.close();\n        });\n    }\n\n    /** Destroys the current popup overlay. */\n    private _destroyPopup() {\n        if (this._popupRef) {\n            this._popupRef.dispose();\n            this._popupRef = this._popupComponentRef = null;\n        }\n    }\n\n    /** Sets the positions of the datepicker in dropdown mode based on the current configuration. */\n    private _setConnectedPositions(strategy: FlexibleConnectedPositionStrategy) {\n        const primaryX = this.xPosition === 'end' ? 'end' : 'start';\n        const secondaryX = primaryX === 'start' ? 'end' : 'start';\n        const primaryY = this.yPosition === 'above' ? 'bottom' : 'top';\n        const secondaryY = primaryY === 'top' ? 'bottom' : 'top';\n\n        return strategy.withPositions([\n            {\n                originX: primaryX,\n                originY: secondaryY,\n                overlayX: primaryX,\n                overlayY: primaryY\n            },\n            {\n                originX: primaryX,\n                originY: primaryY,\n                overlayX: primaryX,\n                overlayY: secondaryY\n            },\n            {\n                originX: secondaryX,\n                originY: secondaryY,\n                overlayX: secondaryX,\n                overlayY: primaryY\n            },\n            {\n                originX: secondaryX,\n                originY: primaryY,\n                overlayX: secondaryX,\n                overlayY: secondaryY\n            }\n        ]);\n    }\n\n}\n"]}