@gipisistemas/ng-core 1.1.10 → 1.1.12

package/esm5/shared/gipi-components/datetime-picker/mat-datetime-picker/datetimepicker.js

@@ -0,0 +1,495 @@
+import { __decorate, __metadata, __param } from "tslib";
+import { Directionality } from '@angular/cdk/bidi';
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { ESCAPE } from '@angular/cdk/keycodes';
+import { Overlay, OverlayConfig, OverlayRef, PositionStrategy, } from '@angular/cdk/overlay';
+import { ComponentPortal } from '@angular/cdk/portal';
+import { DOCUMENT } from '@angular/common';
+import { AfterContentInit, ChangeDetectionStrategy, Component, ComponentRef, EventEmitter, Inject, Input, NgZone, OnDestroy, Optional, Output, ViewChild, ViewContainerRef, ViewEncapsulation, } from '@angular/core';
+import { MAT_DATEPICKER_SCROLL_STRATEGY } from '@angular/material/datepicker';
+import { MatDialog, MatDialogRef } from '@angular/material/dialog';
+import { Subject, Subscription } from 'rxjs';
+import { first } from 'rxjs/operators';
+import { GIPIDatetimepickerCalendarComponent, } from './calendar';
+import { createMissingDateImplError } from './datetimepicker-errors';
+import { GIPIDatetimeAdapter } from './shared/adapter/datetime-adapter';
+/** Used to generate a unique ID for each datepicker instance. */
+var datetimepickerUid = 0;
+/**
+ * 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
+ */
+var GIPIDatetimepickerContentComponent = /** @class */ (function () {
+    function GIPIDatetimepickerContentComponent() {
+    }
+    GIPIDatetimepickerContentComponent.prototype.ngAfterContentInit = function () {
+        this._calendar._focusActiveCell();
+    };
+    GIPIDatetimepickerContentComponent.prototype.onSelectionChange = function (date) {
+        this.datetimepicker._select(date);
+        this.datetimepicker.close();
+    };
+    /**
+     * Handles keydown event on datepicker content.
+     * @param event The event.
+     */
+    GIPIDatetimepickerContentComponent.prototype._handleKeydown = function (event) {
+        if (event.keyCode === ESCAPE) {
+            this.datetimepicker.close();
+            event.preventDefault();
+            event.stopPropagation();
+        }
+    };
+    __decorate([
+        ViewChild(GIPIDatetimepickerCalendarComponent, { static: true }),
+        __metadata("design:type", GIPIDatetimepickerCalendarComponent)
+    ], GIPIDatetimepickerContentComponent.prototype, "_calendar", void 0);
+    GIPIDatetimepickerContentComponent = __decorate([
+        Component({
+            selector: 'gipi-mat-datetime-picker-content',
+            template: "<gipi-mat-datetime-picker-calendar cdkTrapFocus\n                                   class=\"mat-typography\"\n                                   [id]=\"datetimepicker.id\"\n                                   [attr.mode]=\"datetimepicker.mode\"\n                                   [ariaNextMonthLabel]=\"datetimepicker.ariaNextMonthLabel\"\n                                   [ariaNextYearLabel]=\"datetimepicker.ariaNextYearLabel\"\n                                   [ariaPrevMonthLabel]=\"datetimepicker.ariaPrevMonthLabel\"\n                                   [ariaPrevYearLabel]=\"datetimepicker.ariaPrevYearLabel\"\n                                   [preventSameDateTimeSelection]=\"datetimepicker.preventSameDateTimeSelection\"\n                                   [dateFilter]=\"datetimepicker._dateFilter\"\n                                   [maxDate]=\"datetimepicker._maxDate\"\n                                   [minDate]=\"datetimepicker._minDate\"\n                                   [multiYearSelector]=\"datetimepicker.multiYearSelector\"\n                                   [selected]=\"datetimepicker._selected\"\n                                   [startAt]=\"datetimepicker.startAt\"\n                                   [startView]=\"datetimepicker.startView\"\n                                   [timeInterval]=\"datetimepicker.timeInterval\"\n                                   [twelvehour]=\"datetimepicker.twelvehour\"\n                                   [type]=\"datetimepicker.type\"\n                                   (_userSelection)=\"datetimepicker.close()\"\n                                   (selectedChange)=\"onSelectionChange($event)\"\n                                   (viewChanged)=\"datetimepicker._viewChanged($event)\">\n</gipi-mat-datetime-picker-calendar>",
+            encapsulation: ViewEncapsulation.None,
+            changeDetection: ChangeDetectionStrategy.OnPush,
+            host: {
+                class: 'gipi-mat-datetime-picker-content',
+                '[class.gipi-mat-datetime-picker-content-touch]': 'datetimepicker?.touchUi',
+                '(keydown)': '_handleKeydown($event)',
+            },
+            styles: ["@use '@angular/material' as mat;.gipi-mat-datetime-picker-content{display:block;background-color:#fff;border-radius:4px!important;overflow:hidden;box-shadow:0 2px 4px -1px rgba(0,0,0,.2),0 4px 5px 0 rgba(0,0,0,.14),0 1px 10px 0 rgba(0,0,0,.12)}.gipi-mat-datetime-picker-calendar{width:296px;height:405px}.gipi-mat-datetime-picker-calendar[mode=landscape]{width:446px;height:328px}@media (min-width:480px){.gipi-mat-datetime-picker-calendar[mode=auto]{width:446px;height:328px}}.gipi-mat-datetime-picker-content-touch{display:block;box-shadow:0 11px 15px -7px rgba(0,0,0,.2),0 24px 38px 3px rgba(0,0,0,.14),0 9px 46px 8px rgba(0,0,0,.12)}.cdk-global-overlay-wrapper,.cdk-overlay-container{pointer-events:none;top:0;left:0;height:100%;width:100%}.cdk-overlay-container{position:fixed;z-index:1000}.cdk-global-overlay-wrapper{display:flex;position:absolute;z-index:1000}.cdk-overlay-pane{position:absolute;pointer-events:auto;box-sizing:border-box;z-index:1000}.cdk-overlay-backdrop{position:absolute;top:0;bottom:0;left:0;right:0;z-index:1000;pointer-events:auto;transition:opacity .4s cubic-bezier(.25,.8,.25,1);opacity:0}.cdk-overlay-backdrop.cdk-overlay-backdrop-showing{opacity:.48}.cdk-overlay-dark-backdrop{background:rgba(0,0,0,.6)}.gipi-mat-datetime-picker-dialog .mat-dialog-container{padding:0}"]
+        })
+    ], GIPIDatetimepickerContentComponent);
+    return GIPIDatetimepickerContentComponent;
+}());
+export { GIPIDatetimepickerContentComponent };
+var GIPIDatetimepickerComponent = /** @class */ (function () {
+    function GIPIDatetimepickerComponent(_dialog, _overlay, _ngZone, _viewContainerRef, _scrollStrategy, _dateAdapter, _dir, _document) {
+        this._dialog = _dialog;
+        this._overlay = _overlay;
+        this._ngZone = _ngZone;
+        this._viewContainerRef = _viewContainerRef;
+        this._scrollStrategy = _scrollStrategy;
+        this._dateAdapter = _dateAdapter;
+        this._dir = _dir;
+        this._document = _document;
+        /** Whether the calendar is open. */
+        this.opened = false;
+        /** The id for the datepicker calendar. */
+        this.id = "gipi-mat-datetime-picker-" + datetimepickerUid++;
+        /** Emits when the datepicker is disabled. */
+        this._disabledChange = new Subject();
+        this._validSelected = null;
+        /** The element that was focused before the datepicker was opened. */
+        this._focusedElementBeforeOpen = null;
+        this._inputSubscription = Subscription.EMPTY;
+        /** Active multi year view when click on year. */
+        this.multiYearSelector = false;
+        /** if true change the clock to 12 hour format. */
+        this.twelvehour = false;
+        /** The view that the calendar should start in. */
+        this.startView = 'month';
+        this.mode = 'auto';
+        this.timeInterval = 1;
+        this.ariaNextMonthLabel = 'Next month';
+        this.ariaPrevMonthLabel = 'Previous month';
+        this.ariaNextYearLabel = 'Next year';
+        this.ariaPrevYearLabel = 'Previous year';
+        /** Prevent user to select same date time */
+        this.preventSameDateTimeSelection = false;
+        this._type = 'date';
+        /** 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. */
+        this._touchUi = false;
+        /** Emits when the datepicker has been opened. */
+        this.openedStream = new EventEmitter();
+        /** Emits when the datepicker has been closed. */
+        this.closedStream = new EventEmitter();
+        /** Emits when the view has been changed. **/
+        this.viewChanged = new EventEmitter();
+        /**
+         * Emits new selected date when selected date changes.
+         * @deprecated Switch to the `dateChange` and `dateInput` binding on the input element.
+         */
+        this.selectedChanged = new EventEmitter();
+        if (!this._dateAdapter) {
+            throw createMissingDateImplError('DateAdapter');
+        }
+    }
+    Object.defineProperty(GIPIDatetimepickerComponent.prototype, "startAt", {
+        get: function () {
+            // 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.value : null));
+        },
+        set: function (date) {
+            this._startAt = this._dateAdapter.getValidDateOrNull(date);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GIPIDatetimepickerComponent.prototype, "openOnFocus", {
+        get: function () {
+            return this._openOnFocus;
+        },
+        set: function (value) {
+            this._openOnFocus = coerceBooleanProperty(value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GIPIDatetimepickerComponent.prototype, "type", {
+        get: function () {
+            return this._type;
+        },
+        set: function (value) {
+            this._type = value || 'date';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GIPIDatetimepickerComponent.prototype, "touchUi", {
+        get: function () {
+            return this._touchUi;
+        },
+        set: function (value) {
+            this._touchUi = coerceBooleanProperty(value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GIPIDatetimepickerComponent.prototype, "disabled", {
+        get: function () {
+            return this._disabled === undefined && this._datepickerInput
+                ? this._datepickerInput.disabled
+                : !!this._disabled;
+        },
+        set: function (value) {
+            var newValue = coerceBooleanProperty(value);
+            if (newValue !== this._disabled) {
+                this._disabled = newValue;
+                this._disabledChange.next(newValue);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GIPIDatetimepickerComponent.prototype, "_selected", {
+        /** The currently selected date. */
+        get: function () {
+            return this._validSelected;
+        },
+        set: function (value) {
+            this._validSelected = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GIPIDatetimepickerComponent.prototype, "_minDate", {
+        /** The minimum selectable date. */
+        get: function () {
+            return this._datepickerInput && this._datepickerInput.min;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GIPIDatetimepickerComponent.prototype, "_maxDate", {
+        /** The maximum selectable date. */
+        get: function () {
+            return this._datepickerInput && this._datepickerInput.max;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GIPIDatetimepickerComponent.prototype, "_dateFilter", {
+        get: function () {
+            return this._datepickerInput && this._datepickerInput._dateFilter;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    GIPIDatetimepickerComponent.prototype._handleFocus = function () {
+        if (!this.opened && this.openOnFocus) {
+            this.open();
+        }
+    };
+    GIPIDatetimepickerComponent.prototype._viewChanged = function (type) {
+        this.viewChanged.emit(type);
+    };
+    GIPIDatetimepickerComponent.prototype.ngOnDestroy = function () {
+        this.close();
+        this._inputSubscription.unsubscribe();
+        this._disabledChange.complete();
+        if (this._popupRef) {
+            this._popupRef.dispose();
+        }
+    };
+    /** Selects the given date */
+    GIPIDatetimepickerComponent.prototype._select = function (date) {
+        var oldValue = this._selected;
+        this._selected = date;
+        if (!this._dateAdapter.sameDatetime(oldValue, this._selected)) {
+            this.selectedChanged.emit(date);
+        }
+    };
+    /**
+     * Register an input with this datepicker.
+     * @param input The datepicker input to register with this datepicker.
+     */
+    GIPIDatetimepickerComponent.prototype._registerInput = function (input) {
+        var _this = this;
+        if (this._datepickerInput) {
+            throw Error('A MatDatepicker can only be associated with a single input.');
+        }
+        this._datepickerInput = input;
+        this._inputSubscription = this._datepickerInput._valueChange.subscribe(function (value) { return (_this._selected = value); });
+    };
+    /** Open the calendar. */
+    GIPIDatetimepickerComponent.prototype.open = function () {
+        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. */
+    GIPIDatetimepickerComponent.prototype.close = function () {
+        var _this = this;
+        if (!this.opened) {
+            return;
+        }
+        if (this._popupRef && this._popupRef.hasAttached()) {
+            this._popupRef.detach();
+        }
+        if (this._dialogRef) {
+            this._dialogRef.close();
+            this._dialogRef = null;
+        }
+        if (this._calendarPortal && this._calendarPortal.isAttached) {
+            this._calendarPortal.detach();
+        }
+        var completeClose = function () {
+            // 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. */
+    GIPIDatetimepickerComponent.prototype._openAsDialog = function () {
+        var _this = this;
+        this._dialogRef = this._dialog.open(GIPIDatetimepickerContentComponent, {
+            direction: this._dir ? this._dir.value : 'ltr',
+            viewContainerRef: this._viewContainerRef,
+            panelClass: 'gipi-mat-datetime-picker-dialog',
+        });
+        this._dialogRef.afterClosed().subscribe(function () { return _this.close(); });
+        this._dialogRef.componentInstance.datetimepicker = this;
+    };
+    /** Open the calendar as a popup. */
+    GIPIDatetimepickerComponent.prototype._openAsPopup = function () {
+        var _this = this;
+        if (!this._calendarPortal) {
+            this._calendarPortal = new ComponentPortal(GIPIDatetimepickerContentComponent, this._viewContainerRef);
+        }
+        if (!this._popupRef) {
+            this._createPopup();
+        }
+        if (!this._popupRef.hasAttached()) {
+            var componentRef = this._popupRef.attach(this._calendarPortal);
+            componentRef.instance.datetimepicker = this;
+            // Update the position once the calendar has rendered.
+            this._ngZone.onStable
+                .asObservable()
+                .pipe(first())
+                .subscribe(function () { return _this._popupRef.updatePosition(); });
+        }
+        this._popupRef.backdropClick().subscribe(function () { return _this.close(); });
+    };
+    /** Create the popup. */
+    GIPIDatetimepickerComponent.prototype._createPopup = function () {
+        var overlayConfig = new OverlayConfig({
+            positionStrategy: this._createPopupPositionStrategy(),
+            hasBackdrop: true,
+            backdropClass: 'mat-overlay-transparent-backdrop',
+            direction: this._dir ? this._dir.value : 'ltr',
+            scrollStrategy: this._scrollStrategy(),
+            panelClass: 'gipi-mat-datetime-picker-popup',
+        });
+        this._popupRef = this._overlay.create(overlayConfig);
+    };
+    /** Create the popup PositionStrategy. */
+    GIPIDatetimepickerComponent.prototype._createPopupPositionStrategy = function () {
+        return this._overlay
+            .position()
+            .flexibleConnectedTo(this._datepickerInput.getConnectedOverlayOrigin())
+            .withTransformOriginOn('.gipi-mat-datetime-picker-content')
+            .withFlexibleDimensions(false)
+            .withViewportMargin(8)
+            .withLockedPosition()
+            .withPositions([
+            {
+                originX: 'start',
+                originY: 'bottom',
+                overlayX: 'start',
+                overlayY: 'top',
+            },
+            {
+                originX: 'start',
+                originY: 'top',
+                overlayX: 'start',
+                overlayY: 'bottom',
+            },
+            {
+                originX: 'end',
+                originY: 'bottom',
+                overlayX: 'end',
+                overlayY: 'top',
+            },
+            {
+                originX: 'end',
+                originY: 'top',
+                overlayX: 'end',
+                overlayY: 'bottom',
+            },
+        ]);
+    };
+    GIPIDatetimepickerComponent.ctorParameters = function () { return [
+        { type: MatDialog },
+        { type: Overlay },
+        { type: NgZone },
+        { type: ViewContainerRef },
+        { type: undefined, decorators: [{ type: Inject, args: [MAT_DATEPICKER_SCROLL_STRATEGY,] }] },
+        { type: GIPIDatetimeAdapter, decorators: [{ type: Optional }] },
+        { type: Directionality, decorators: [{ type: Optional }] },
+        { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [DOCUMENT,] }] }
+    ]; };
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean)
+    ], GIPIDatetimepickerComponent.prototype, "multiYearSelector", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean)
+    ], GIPIDatetimepickerComponent.prototype, "twelvehour", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], GIPIDatetimepickerComponent.prototype, "startView", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], GIPIDatetimepickerComponent.prototype, "mode", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Number)
+    ], GIPIDatetimepickerComponent.prototype, "timeInterval", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Object)
+    ], GIPIDatetimepickerComponent.prototype, "ariaNextMonthLabel", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Object)
+    ], GIPIDatetimepickerComponent.prototype, "ariaPrevMonthLabel", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Object)
+    ], GIPIDatetimepickerComponent.prototype, "ariaNextYearLabel", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Object)
+    ], GIPIDatetimepickerComponent.prototype, "ariaPrevYearLabel", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Object)
+    ], GIPIDatetimepickerComponent.prototype, "preventSameDateTimeSelection", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Object)
+    ], GIPIDatetimepickerComponent.prototype, "panelClass", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Object),
+        __metadata("design:paramtypes", [Object])
+    ], GIPIDatetimepickerComponent.prototype, "startAt", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean),
+        __metadata("design:paramtypes", [Boolean])
+    ], GIPIDatetimepickerComponent.prototype, "openOnFocus", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", String),
+        __metadata("design:paramtypes", [String])
+    ], GIPIDatetimepickerComponent.prototype, "type", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean),
+        __metadata("design:paramtypes", [Boolean])
+    ], GIPIDatetimepickerComponent.prototype, "touchUi", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean),
+        __metadata("design:paramtypes", [Boolean])
+    ], GIPIDatetimepickerComponent.prototype, "disabled", null);
+    __decorate([
+        Output('opened'),
+        __metadata("design:type", EventEmitter)
+    ], GIPIDatetimepickerComponent.prototype, "openedStream", void 0);
+    __decorate([
+        Output('closed'),
+        __metadata("design:type", EventEmitter)
+    ], GIPIDatetimepickerComponent.prototype, "closedStream", void 0);
+    __decorate([
+        Output(),
+        __metadata("design:type", EventEmitter)
+    ], GIPIDatetimepickerComponent.prototype, "viewChanged", void 0);
+    __decorate([
+        Output(),
+        __metadata("design:type", Object)
+    ], GIPIDatetimepickerComponent.prototype, "selectedChanged", void 0);
+    GIPIDatetimepickerComponent = __decorate([
+        Component({
+            selector: 'gipi-mat-datetime-picker',
+            exportAs: 'gipiDatetimePicker',
+            template: '',
+            changeDetection: ChangeDetectionStrategy.OnPush,
+            encapsulation: ViewEncapsulation.None,
+            preserveWhitespaces: false
+        }),
+        __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, GIPIDatetimeAdapter,
+            Directionality, Object])
+    ], GIPIDatetimepickerComponent);
+    return GIPIDatetimepickerComponent;
+}());
+export { GIPIDatetimepickerComponent };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"datetimepicker.js","sourceRoot":"ng://@gipisistemas/ng-core/","sources":["shared/gipi-components/datetime-picker/mat-datetime-picker/datetimepicker.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directionality } from '@angular/cdk/bidi';\nimport { coerceBooleanProperty } from '@angular/cdk/coercion';\nimport { ESCAPE } from '@angular/cdk/keycodes';\nimport { Overlay, OverlayConfig, OverlayRef, PositionStrategy, } from '@angular/cdk/overlay';\nimport { ComponentPortal } from '@angular/cdk/portal';\nimport { DOCUMENT } from '@angular/common';\nimport { AfterContentInit, ChangeDetectionStrategy, Component, ComponentRef, EventEmitter, Inject, Input, NgZone, OnDestroy, Optional, Output, ViewChild, ViewContainerRef, ViewEncapsulation, } from '@angular/core';\nimport { MAT_DATEPICKER_SCROLL_STRATEGY } from '@angular/material/datepicker';\nimport { MatDialog, MatDialogRef } from '@angular/material/dialog';\nimport { Subject, Subscription } from 'rxjs';\nimport { first } from 'rxjs/operators';\n\nimport { GIPICalendarView, GIPIDatetimepickerCalendarComponent, } from './calendar';\nimport { createMissingDateImplError } from './datetimepicker-errors';\nimport { GIPIDatetimepickerFilterType } from './datetimepicker-filtertype';\nimport { GIPIDatetimepickerInputDirective } from './datetimepicker-input';\nimport { GIPIDatetimepickerType } from './datetimepicker-type';\nimport { GIPIDatetimeAdapter } from './shared/adapter/datetime-adapter';\n\nexport type GIPIDatetimepickerMode = 'auto' | 'portrait' | 'landscape';\n\n/** Used to generate a unique ID for each datepicker instance. */\nlet datetimepickerUid = 0;\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-datetime-picker-content',\n    templateUrl: 'datetimepicker-content.html',\n    styleUrls: ['datetimepicker-content.scss'],\n    encapsulation: ViewEncapsulation.None,\n    changeDetection: ChangeDetectionStrategy.OnPush,\n    host: {\n        class: 'gipi-mat-datetime-picker-content',\n        '[class.gipi-mat-datetime-picker-content-touch]': 'datetimepicker?.touchUi',\n        '(keydown)': '_handleKeydown($event)',\n    },\n})\nexport class GIPIDatetimepickerContentComponent<D> implements AfterContentInit {\n\n    @ViewChild(GIPIDatetimepickerCalendarComponent, { static: true }) _calendar: GIPIDatetimepickerCalendarComponent<D>;\n\n    datetimepicker: GIPIDatetimepickerComponent<D>;\n\n    ngAfterContentInit() {\n        this._calendar._focusActiveCell();\n    }\n\n    onSelectionChange(date: D) {\n        this.datetimepicker._select(date);\n        this.datetimepicker.close();\n    }\n\n    /**\n     * Handles keydown event on datepicker content.\n     * @param event The event.\n     */\n    _handleKeydown(event: KeyboardEvent): void {\n        if (event.keyCode === ESCAPE) {\n            this.datetimepicker.close();\n            event.preventDefault();\n            event.stopPropagation();\n        }\n    }\n}\n\n@Component({\n    selector: 'gipi-mat-datetime-picker',\n    exportAs: 'gipiDatetimePicker',\n    template: '',\n    changeDetection: ChangeDetectionStrategy.OnPush,\n    encapsulation: ViewEncapsulation.None,\n    preserveWhitespaces: false,\n})\nexport class GIPIDatetimepickerComponent<D> implements OnDestroy {\n\n    /** Whether the calendar is open. */\n    opened = false;\n\n    /** The id for the datepicker calendar. */\n    id = `gipi-mat-datetime-picker-${datetimepickerUid++}`;\n\n    /** The input element this datepicker is associated with. */\n    _datepickerInput: GIPIDatetimepickerInputDirective<D>;\n\n    /** Emits when the datepicker is disabled. */\n    _disabledChange = new Subject<boolean>();\n\n    private _validSelected: D | null = null;\n\n    /** A reference to the overlay when the calendar is opened as a popup. */\n    private _popupRef: OverlayRef;\n\n    /** A reference to the dialog when the calendar is opened as a dialog. */\n    private _dialogRef: MatDialogRef<any> | null;\n\n    /** A portal containing the calendar for this datepicker. */\n    private _calendarPortal: ComponentPortal<GIPIDatetimepickerContentComponent<D>>;\n\n    /** The element that was focused before the datepicker was opened. */\n    private _focusedElementBeforeOpen: HTMLElement | null = null;\n    private _inputSubscription = Subscription.EMPTY;\n\n    /** Active multi year view when click on year. */\n    @Input() multiYearSelector: boolean = false;\n\n    /** if true change the clock to 12 hour format. */\n    @Input() twelvehour: boolean = false;\n\n    /** The view that the calendar should start in. */\n    @Input() startView: GIPICalendarView = 'month';\n    @Input() mode: GIPIDatetimepickerMode = 'auto';\n    @Input() timeInterval: number = 1;\n    @Input() ariaNextMonthLabel = 'Next month';\n    @Input() ariaPrevMonthLabel = 'Previous month';\n    @Input() ariaNextYearLabel = 'Next year';\n    @Input() ariaPrevYearLabel = 'Previous year';\n\n    /** Prevent user to select same date time */\n    @Input() preventSameDateTimeSelection = false;\n\n    /** Classes to be passed to the date picker panel. Supports the same syntax as `ngClass`. */\n    @Input() panelClass: string | string[];\n\n\n    /** The date to open the calendar to initially. */\n    private _startAt: D | null;\n    @Input() get startAt(): D | null {\n        // If an explicit startAt is set we start there, otherwise we start at whatever the currently selected value is.\n        return (this._startAt || (this._datepickerInput ? this._datepickerInput.value : null));\n    }\n    set startAt(date: D | null) {\n        this._startAt = this._dateAdapter.getValidDateOrNull(date);\n    }\n\n    private _openOnFocus: boolean;\n    @Input() get openOnFocus(): boolean {\n        return this._openOnFocus;\n    }\n    set openOnFocus(value: boolean) {\n        this._openOnFocus = coerceBooleanProperty(value);\n    }\n\n    private _type: GIPIDatetimepickerType = 'date';\n    @Input() get type() {\n        return this._type;\n    }\n    set type(value: GIPIDatetimepickerType) {\n        this._type = value || 'date';\n    }\n\n    /** 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. */\n    private _touchUi = false;\n    @Input() get touchUi(): boolean {\n        return this._touchUi;\n    }\n    set touchUi(value: boolean) {\n        this._touchUi = coerceBooleanProperty(value);\n    }\n\n    /** Whether the datepicker pop-up should be disabled. */\n    private _disabled: boolean;\n    @Input() get disabled(): boolean {\n        return this._disabled === undefined && this._datepickerInput\n            ? this._datepickerInput.disabled\n            : !!this._disabled;\n    }\n    set disabled(value: boolean) {\n        const newValue = coerceBooleanProperty(value);\n        if (newValue !== this._disabled) {\n            this._disabled = newValue;\n            this._disabledChange.next(newValue);\n        }\n    }\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    /** Emits when the view has been changed. **/\n    @Output() viewChanged: EventEmitter<GIPICalendarView> = new EventEmitter<GIPICalendarView>();\n\n    /**\n     * Emits new selected date when selected date changes.\n     * @deprecated Switch to the `dateChange` and `dateInput` binding on the input element.\n     */\n    @Output() selectedChanged = new EventEmitter<D>();\n\n    /** The currently selected date. */\n    get _selected(): D | null {\n        return this._validSelected;\n    }\n\n    set _selected(value: D | null) {\n        this._validSelected = value;\n    }\n\n    /** The minimum selectable date. */\n    get _minDate(): D | null {\n        return this._datepickerInput && this._datepickerInput.min;\n    }\n\n    /** The maximum selectable date. */\n    get _maxDate(): D | null {\n        return this._datepickerInput && this._datepickerInput.max;\n    }\n\n    get _dateFilter(): (date: D | null, type: GIPIDatetimepickerFilterType) => boolean {\n        return this._datepickerInput && this._datepickerInput._dateFilter;\n    }\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) private _scrollStrategy,\n        @Optional() private _dateAdapter: GIPIDatetimeAdapter<D>,\n        @Optional() private _dir: Directionality,\n        @Optional() @Inject(DOCUMENT) private _document: any\n    ) {\n        if (!this._dateAdapter) {\n            throw createMissingDateImplError('DateAdapter');\n        }\n    }\n\n    _handleFocus() {\n        if (!this.opened && this.openOnFocus) {\n            this.open();\n        }\n    }\n\n    _viewChanged(type: GIPICalendarView): void {\n        this.viewChanged.emit(type);\n    }\n\n    ngOnDestroy() {\n        this.close();\n        this._inputSubscription.unsubscribe();\n        this._disabledChange.complete();\n\n        if (this._popupRef) {\n            this._popupRef.dispose();\n        }\n    }\n\n    /** Selects the given date */\n    _select(date: D): void {\n        const oldValue = this._selected;\n        this._selected = date;\n        if (!this._dateAdapter.sameDatetime(oldValue, this._selected)) {\n            this.selectedChanged.emit(date);\n        }\n    }\n\n    /**\n     * Register an input with this datepicker.\n     * @param input The datepicker input to register with this datepicker.\n     */\n    _registerInput(input: GIPIDatetimepickerInputDirective<D>): void {\n        if (this._datepickerInput) {\n            throw Error('A MatDatepicker can only be associated with a single input.');\n        }\n        this._datepickerInput = input;\n        this._inputSubscription = this._datepickerInput._valueChange.subscribe((value: D | null) => (this._selected = value));\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._popupRef && this._popupRef.hasAttached()) {\n            this._popupRef.detach();\n        }\n        if (this._dialogRef) {\n            this._dialogRef.close();\n            this._dialogRef = null;\n        }\n        if (this._calendarPortal && this._calendarPortal.isAttached) {\n            this._calendarPortal.detach();\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 && 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        this._dialogRef = this._dialog.open(GIPIDatetimepickerContentComponent, {\n            direction: this._dir ? this._dir.value : 'ltr',\n            viewContainerRef: this._viewContainerRef,\n            panelClass: 'gipi-mat-datetime-picker-dialog',\n        });\n        this._dialogRef.afterClosed().subscribe(() => this.close());\n        this._dialogRef.componentInstance.datetimepicker = this;\n    }\n\n    /** Open the calendar as a popup. */\n    private _openAsPopup(): void {\n        if (!this._calendarPortal) {\n            this._calendarPortal = new ComponentPortal<GIPIDatetimepickerContentComponent<D>>(GIPIDatetimepickerContentComponent, this._viewContainerRef);\n        }\n\n        if (!this._popupRef) {\n            this._createPopup();\n        }\n\n        if (!this._popupRef.hasAttached()) {\n            const componentRef: ComponentRef<GIPIDatetimepickerContentComponent<D>> = this._popupRef.attach(this._calendarPortal);\n            componentRef.instance.datetimepicker = this;\n\n            // Update the position once the calendar has rendered.\n            this._ngZone.onStable\n                .asObservable()\n                .pipe(first())\n                .subscribe(() => this._popupRef.updatePosition());\n        }\n\n        this._popupRef.backdropClick().subscribe(() => this.close());\n    }\n\n    /** Create the popup. */\n    private _createPopup(): void {\n        const overlayConfig = new OverlayConfig({\n            positionStrategy: this._createPopupPositionStrategy(),\n            hasBackdrop: true,\n            backdropClass: 'mat-overlay-transparent-backdrop',\n            direction: this._dir ? this._dir.value : 'ltr',\n            scrollStrategy: this._scrollStrategy(),\n            panelClass: 'gipi-mat-datetime-picker-popup',\n        });\n\n        this._popupRef = this._overlay.create(overlayConfig);\n    }\n\n    /** Create the popup PositionStrategy. */\n    private _createPopupPositionStrategy(): PositionStrategy {\n        return this._overlay\n            .position()\n            .flexibleConnectedTo(this._datepickerInput.getConnectedOverlayOrigin())\n            .withTransformOriginOn('.gipi-mat-datetime-picker-content')\n            .withFlexibleDimensions(false)\n            .withViewportMargin(8)\n            .withLockedPosition()\n            .withPositions([\n                {\n                    originX: 'start',\n                    originY: 'bottom',\n                    overlayX: 'start',\n                    overlayY: 'top',\n                },\n                {\n                    originX: 'start',\n                    originY: 'top',\n                    overlayX: 'start',\n                    overlayY: 'bottom',\n                },\n                {\n                    originX: 'end',\n                    originY: 'bottom',\n                    overlayX: 'end',\n                    overlayY: 'top',\n                },\n                {\n                    originX: 'end',\n                    originY: 'top',\n                    overlayX: 'end',\n                    overlayY: 'bottom',\n                },\n            ]);\n    }\n\n}\n"]}