@netwin/angular-datetime-picker 1.0.0-rc.3

package/esm2022/lib/date-time/date-time-picker.component.mjs

@@ -0,0 +1,564 @@
+/**
+ * date-time-picker.component
+ */
+import { coerceArray, coerceBooleanProperty } from '@angular/cdk/coercion';
+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 { ChangeDetectionStrategy, Component, EventEmitter, Inject, InjectionToken, Input, Optional, Output } from '@angular/core';
+import { Subscription, merge } from 'rxjs';
+import { filter, take } from 'rxjs/operators';
+import { OWL_DATE_TIME_FORMATS } from './adapter/date-time-format.class';
+import { OwlDateTimeContainerComponent } from './date-time-picker-container.component';
+import { OwlDateTime } from './date-time.class';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/overlay";
+import * as i2 from "../dialog/dialog.service";
+import * as i3 from "./adapter/date-time-adapter.class";
+/** Injection token that determines the scroll handling while the dtPicker is open. */
+export const OWL_DTPICKER_SCROLL_STRATEGY = new InjectionToken('owl-dtpicker-scroll-strategy');
+/** @docs-private */
+export function OWL_DTPICKER_SCROLL_STRATEGY_PROVIDER_FACTORY(overlay) {
+    const fn = () => overlay.scrollStrategies.block();
+    return fn;
+}
+/** @docs-private */
+export const OWL_DTPICKER_SCROLL_STRATEGY_PROVIDER = {
+    provide: OWL_DTPICKER_SCROLL_STRATEGY,
+    deps: [Overlay],
+    useFactory: OWL_DTPICKER_SCROLL_STRATEGY_PROVIDER_FACTORY
+};
+export class OwlDateTimeComponent extends OwlDateTime {
+    get startAt() {
+        // If an explicit startAt is set we start there, otherwise we start at whatever the currently
+        // selected value is.
+        if (this._startAt) {
+            return this._startAt;
+        }
+        if (this._dtInput) {
+            if (this._dtInput.selectMode === 'single') {
+                return this._dtInput.value || null;
+            }
+            else if (this._dtInput.selectMode === 'range' || this._dtInput.selectMode === 'rangeFrom') {
+                return this._dtInput.values[0] || null;
+            }
+            else if (this._dtInput.selectMode === 'rangeTo') {
+                return this._dtInput.values[1] || null;
+            }
+        }
+        return null;
+    }
+    set startAt(date) {
+        this._startAt = this.getValidDate(this.dateTimeAdapter.deserialize(date));
+    }
+    get endAt() {
+        if (this._endAt) {
+            return this._endAt;
+        }
+        if (this._dtInput) {
+            if (this._dtInput.selectMode === 'single') {
+                return this._dtInput.value || null;
+            }
+            else if (this._dtInput.selectMode === 'range' || this._dtInput.selectMode === 'rangeFrom') {
+                return this._dtInput.values[1] || null;
+            }
+        }
+        return null;
+    }
+    set endAt(date) {
+        this._endAt = this.getValidDate(this.dateTimeAdapter.deserialize(date));
+    }
+    get pickerType() {
+        return this._pickerType;
+    }
+    set pickerType(val) {
+        if (val !== this._pickerType) {
+            this._pickerType = val;
+            if (this._dtInput) {
+                this._dtInput.formatNativeInputValue();
+            }
+        }
+    }
+    get pickerMode() {
+        return this._pickerMode;
+    }
+    set pickerMode(mode) {
+        if (mode === 'popup') {
+            this._pickerMode = mode;
+        }
+        else {
+            this._pickerMode = 'dialog';
+        }
+    }
+    get disabled() {
+        return this._disabled === undefined && this._dtInput ? this._dtInput.disabled : !!this._disabled;
+    }
+    set disabled(value) {
+        value = coerceBooleanProperty(value);
+        if (value !== this._disabled) {
+            this._disabled = value;
+            this.disabledChange.next(value);
+        }
+    }
+    get opened() {
+        return this._opened;
+    }
+    set opened(val) {
+        if (val) {
+            this.open();
+        }
+        else {
+            this.close();
+        }
+    }
+    get dtInput() {
+        return this._dtInput;
+    }
+    get selected() {
+        return this._selected;
+    }
+    set selected(value) {
+        this._selected = value;
+        this.changeDetector.markForCheck();
+    }
+    get selecteds() {
+        return this._selecteds;
+    }
+    set selecteds(values) {
+        this._selecteds = values;
+        this.changeDetector.markForCheck();
+    }
+    /** The minimum selectable date. */
+    get minDateTime() {
+        return this._dtInput && this._dtInput.min;
+    }
+    /** The maximum selectable date. */
+    get maxDateTime() {
+        return this._dtInput && this._dtInput.max;
+    }
+    get dateTimeFilter() {
+        return this._dtInput && this._dtInput.dateTimeFilter;
+    }
+    get selectMode() {
+        return this._dtInput.selectMode;
+    }
+    get isInSingleMode() {
+        return this._dtInput.isInSingleMode;
+    }
+    get isInRangeMode() {
+        return this._dtInput.isInRangeMode;
+    }
+    constructor(overlay, viewContainerRef, dialogService, ngZone, changeDetector, dateTimeAdapter, defaultScrollStrategy, dateTimeFormats, document) {
+        super(dateTimeAdapter, dateTimeFormats);
+        this.overlay = overlay;
+        this.viewContainerRef = viewContainerRef;
+        this.dialogService = dialogService;
+        this.ngZone = ngZone;
+        this.changeDetector = changeDetector;
+        this.dateTimeAdapter = dateTimeAdapter;
+        this.dateTimeFormats = dateTimeFormats;
+        this.document = document;
+        /** Custom class for the picker backdrop. */
+        this.backdropClass = [];
+        /** Custom class for the picker overlay pane. */
+        this.panelClass = [];
+        /**
+         * Set the type of the dateTime picker
+         *      'both' -- show both calendar and timer
+         *      'calendar' -- show only calendar
+         *      'timer' -- show only timer
+         */
+        this._pickerType = 'both';
+        /**
+         * Whether the picker open as a dialog
+         */
+        this._pickerMode = 'popup';
+        /** Whether the calendar is open. */
+        this._opened = false;
+        /**
+         * Callback when the picker is closed
+         * */
+        this.afterPickerClosed = new EventEmitter();
+        /**
+         * Callback before the picker is open
+         * */
+        this.beforePickerOpen = new EventEmitter();
+        /**
+         * Callback when the picker is open
+         * */
+        this.afterPickerOpen = new EventEmitter();
+        /**
+         * Emits selected year in multi-year 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 selected date
+         * */
+        this.dateSelected = new EventEmitter();
+        /**
+         * Emit when the selected value has been confirmed
+         * */
+        this.confirmSelectedChange = new EventEmitter();
+        /**
+         * Emits when the date time picker is disabled.
+         * */
+        this.disabledChange = new EventEmitter();
+        this.dtInputSub = Subscription.EMPTY;
+        this.hidePickerStreamSub = Subscription.EMPTY;
+        this.confirmSelectedStreamSub = Subscription.EMPTY;
+        this.pickerOpenedStreamSub = Subscription.EMPTY;
+        this.pickerBeforeOpenedStreamSub = Subscription.EMPTY;
+        /** The element that was focused before the date time picker was opened. */
+        this.focusedElementBeforeOpen = null;
+        this._selecteds = [];
+        this.defaultScrollStrategy = defaultScrollStrategy;
+    }
+    ngOnDestroy() {
+        this.close();
+        this.dtInputSub.unsubscribe();
+        this.disabledChange.complete();
+        if (this.popupRef) {
+            this.popupRef.dispose();
+        }
+    }
+    registerInput(input) {
+        if (this._dtInput) {
+            throw Error('A Owl DateTimePicker can only be associated with a single input.');
+        }
+        this._dtInput = input;
+        this.dtInputSub = this._dtInput.valueChange.subscribe((value) => {
+            if (Array.isArray(value)) {
+                this.selecteds = value;
+            }
+            else {
+                this.selected = value;
+            }
+        });
+    }
+    open() {
+        if (this._opened || this.disabled) {
+            return;
+        }
+        if (!this._dtInput) {
+            throw Error('Attempted to open an DateTimePicker with no associated input.');
+        }
+        if (this.document) {
+            this.focusedElementBeforeOpen = this.document.activeElement;
+        }
+        // reset the picker selected value
+        if (this.isInSingleMode) {
+            this.selected = this._dtInput.value;
+        }
+        else if (this.isInRangeMode) {
+            this.selecteds = this._dtInput.values;
+        }
+        // when the picker is open , we make sure the picker's current selected time value
+        // is the same as the _startAt time value.
+        if (this.selected && this.pickerType !== 'calendar' && this._startAt) {
+            this.selected = this.dateTimeAdapter.createDate(this.dateTimeAdapter.getYear(this.selected), this.dateTimeAdapter.getMonth(this.selected), this.dateTimeAdapter.getDate(this.selected), this.dateTimeAdapter.getHours(this._startAt), this.dateTimeAdapter.getMinutes(this._startAt), this.dateTimeAdapter.getSeconds(this._startAt));
+        }
+        if (this.pickerMode === 'dialog') {
+            this.openAsDialog();
+        }
+        else {
+            this.openAsPopup();
+        }
+        this.pickerContainer.picker = this;
+        // Listen to picker container's hidePickerStream
+        this.hidePickerStreamSub = this.pickerContainer.hidePickerStream.subscribe(() => {
+            this.close();
+        });
+        // Listen to picker container's confirmSelectedStream
+        this.confirmSelectedStreamSub = this.pickerContainer.confirmSelectedStream.subscribe((event) => {
+            this.confirmSelect(event);
+        });
+    }
+    /**
+     * Selects the given date
+     */
+    select(date) {
+        if (Array.isArray(date)) {
+            this.selecteds = [...date];
+        }
+        else {
+            this.selected = date;
+        }
+        /**
+         * Cases in which automatically confirm the select when date or dates are selected:
+         * 1) picker mode is NOT 'dialog'
+         * 2) picker type is 'calendar' and selectMode is 'single'.
+         * 3) picker type is 'calendar' and selectMode is 'range' and
+         *    the 'selecteds' has 'from'(selecteds[0]) and 'to'(selecteds[1]) values.
+         * 4) selectMode is 'rangeFrom' and selecteds[0] has value.
+         * 5) selectMode is 'rangeTo' and selecteds[1] has value.
+         * */
+        if (this.pickerMode !== 'dialog' &&
+            this.pickerType === 'calendar' &&
+            ((this.selectMode === 'single' && this.selected) ||
+                (this.selectMode === 'rangeFrom' && this.selecteds[0]) ||
+                (this.selectMode === 'rangeTo' && this.selecteds[1]) ||
+                (this.selectMode === 'range' && this.selecteds[0] && this.selecteds[1]))) {
+            this.confirmSelect();
+        }
+    }
+    /**
+     * Emits the selected year in multi-year view
+     * */
+    selectYear(normalizedYear) {
+        this.yearSelected.emit(normalizedYear);
+    }
+    /**
+     * Emits selected month in year view
+     * */
+    selectMonth(normalizedMonth) {
+        this.monthSelected.emit(normalizedMonth);
+    }
+    /**
+     * Emits the selected date
+     * */
+    selectDate(normalizedDate) {
+        this.dateSelected.emit(normalizedDate);
+    }
+    /**
+     * Hide the picker
+     */
+    close() {
+        if (!this._opened) {
+            return;
+        }
+        if (this.popupRef && this.popupRef.hasAttached()) {
+            this.popupRef.detach();
+        }
+        if (this.pickerContainerPortal && this.pickerContainerPortal.isAttached) {
+            this.pickerContainerPortal.detach();
+        }
+        if (this.hidePickerStreamSub) {
+            this.hidePickerStreamSub.unsubscribe();
+            this.hidePickerStreamSub = null;
+        }
+        if (this.confirmSelectedStreamSub) {
+            this.confirmSelectedStreamSub.unsubscribe();
+            this.confirmSelectedStreamSub = null;
+        }
+        if (this.pickerBeforeOpenedStreamSub) {
+            this.pickerBeforeOpenedStreamSub.unsubscribe();
+            this.pickerBeforeOpenedStreamSub = null;
+        }
+        if (this.pickerOpenedStreamSub) {
+            this.pickerOpenedStreamSub.unsubscribe();
+            this.pickerOpenedStreamSub = null;
+        }
+        if (this.dialogRef) {
+            this.dialogRef.close();
+            this.dialogRef = null;
+        }
+        const completeClose = () => {
+            if (this._opened) {
+                this._opened = false;
+                const selected = this.selected || this.selecteds;
+                this.afterPickerClosed.emit(selected);
+                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();
+        }
+    }
+    /**
+     * Confirm the selected value
+     */
+    confirmSelect(event) {
+        if (this.isInSingleMode) {
+            const selected = this.selected || this.startAt || this.dateTimeAdapter.now();
+            this.confirmSelectedChange.emit(selected);
+        }
+        else if (this.isInRangeMode) {
+            this.confirmSelectedChange.emit(this.selecteds);
+        }
+        this.close();
+        return;
+    }
+    /**
+     * Open the picker as a dialog
+     */
+    openAsDialog() {
+        this.dialogRef = this.dialogService.open(OwlDateTimeContainerComponent, {
+            autoFocus: false,
+            backdropClass: ['cdk-overlay-dark-backdrop', ...coerceArray(this.backdropClass)],
+            paneClass: ['owl-dt-dialog', ...coerceArray(this.panelClass)],
+            viewContainerRef: this.viewContainerRef,
+            scrollStrategy: this.scrollStrategy || this.defaultScrollStrategy()
+        });
+        this.pickerContainer = this.dialogRef.componentInstance;
+        this.dialogRef.beforeOpen().subscribe(() => {
+            this.beforePickerOpen.emit(null);
+        });
+        this.dialogRef.afterOpen().subscribe(() => {
+            this.afterPickerOpen.emit(null);
+            this._opened = true;
+        });
+        this.dialogRef.afterClosed().subscribe(() => this.close());
+    }
+    /**
+     * Open the picker as popup
+     */
+    openAsPopup() {
+        if (!this.pickerContainerPortal) {
+            this.pickerContainerPortal = new ComponentPortal(OwlDateTimeContainerComponent, this.viewContainerRef);
+        }
+        if (!this.popupRef) {
+            this.createPopup();
+        }
+        if (!this.popupRef.hasAttached()) {
+            const componentRef = this.popupRef.attach(this.pickerContainerPortal);
+            this.pickerContainer = componentRef.instance;
+            // Update the position once the calendar has rendered.
+            this.ngZone.onStable
+                .asObservable()
+                .pipe(take(1))
+                .subscribe(() => {
+                this.popupRef.updatePosition();
+            });
+            this.pickerBeforeOpenedStreamSub = this.pickerContainer.beforePickerOpenedStream.pipe(take(1)).subscribe(() => {
+                this.beforePickerOpen.emit(null);
+            });
+            // emit open stream
+            this.pickerOpenedStreamSub = this.pickerContainer.pickerOpenedStream.pipe(take(1)).subscribe(() => {
+                this.afterPickerOpen.emit(null);
+                this._opened = true;
+            });
+        }
+    }
+    createPopup() {
+        const overlayConfig = new OverlayConfig({
+            positionStrategy: this.createPopupPositionStrategy(),
+            hasBackdrop: true,
+            backdropClass: ['cdk-overlay-transparent-backdrop', ...coerceArray(this.backdropClass)],
+            scrollStrategy: this.scrollStrategy || this.defaultScrollStrategy(),
+            panelClass: ['owl-dt-popup', ...coerceArray(this.panelClass)]
+        });
+        this.popupRef = this.overlay.create(overlayConfig);
+        merge(this.popupRef.backdropClick(), this.popupRef.detachments(), this.popupRef
+            .keydownEvents()
+            .pipe(filter((event) => event.keyCode === ESCAPE || (this._dtInput && event.altKey && event.keyCode === UP_ARROW)))).subscribe(() => this.close());
+    }
+    /**
+     * Create the popup PositionStrategy.
+     * */
+    createPopupPositionStrategy() {
+        return this.overlay
+            .position()
+            .flexibleConnectedTo(this._dtInput.elementRef)
+            .withTransformOriginOn('.owl-dt-container')
+            .withFlexibleDimensions(false)
+            .withPush(false)
+            .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'
+            },
+            {
+                originX: 'start',
+                originY: 'top',
+                overlayX: 'start',
+                overlayY: 'top',
+                offsetY: -176
+            },
+            {
+                originX: 'start',
+                originY: 'top',
+                overlayX: 'start',
+                overlayY: 'top',
+                offsetY: -352
+            }
+        ]);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: OwlDateTimeComponent, deps: [{ token: i1.Overlay }, { token: i0.ViewContainerRef }, { token: i2.OwlDialogService }, { token: i0.NgZone }, { token: i0.ChangeDetectorRef }, { token: i3.DateTimeAdapter, optional: true }, { token: OWL_DTPICKER_SCROLL_STRATEGY }, { token: OWL_DATE_TIME_FORMATS, optional: true }, { token: DOCUMENT, optional: true }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.7", type: OwlDateTimeComponent, selector: "owl-date-time", inputs: { backdropClass: "backdropClass", panelClass: "panelClass", startAt: "startAt", endAt: "endAt", pickerType: "pickerType", pickerMode: "pickerMode", disabled: "disabled", opened: "opened", scrollStrategy: "scrollStrategy" }, outputs: { afterPickerClosed: "afterPickerClosed", beforePickerOpen: "beforePickerOpen", afterPickerOpen: "afterPickerOpen", yearSelected: "yearSelected", monthSelected: "monthSelected", dateSelected: "dateSelected" }, exportAs: ["owlDateTime"], usesInheritance: true, ngImport: i0, template: "", styles: [""], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: OwlDateTimeComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'owl-date-time', exportAs: 'owlDateTime', changeDetection: ChangeDetectionStrategy.OnPush, preserveWhitespaces: false, template: "" }]
+        }], ctorParameters: () => [{ type: i1.Overlay }, { type: i0.ViewContainerRef }, { type: i2.OwlDialogService }, { type: i0.NgZone }, { type: i0.ChangeDetectorRef }, { type: i3.DateTimeAdapter, decorators: [{
+                    type: Optional
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [OWL_DTPICKER_SCROLL_STRATEGY]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [OWL_DATE_TIME_FORMATS]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }], propDecorators: { backdropClass: [{
+                type: Input
+            }], panelClass: [{
+                type: Input
+            }], startAt: [{
+                type: Input
+            }], endAt: [{
+                type: Input
+            }], pickerType: [{
+                type: Input
+            }], pickerMode: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], opened: [{
+                type: Input
+            }], scrollStrategy: [{
+                type: Input
+            }], afterPickerClosed: [{
+                type: Output
+            }], beforePickerOpen: [{
+                type: Output
+            }], afterPickerOpen: [{
+                type: Output
+            }], yearSelected: [{
+                type: Output
+            }], monthSelected: [{
+                type: Output
+            }], dateSelected: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"date-time-picker.component.js","sourceRoot":"","sources":["../../../../../projects/picker/src/lib/date-time/date-time-picker.component.ts","../../../../../projects/picker/src/lib/date-time/date-time-picker.component.html"],"names":[],"mappings":"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","sourcesContent":["/**\n * date-time-picker.component\n */\n\nimport { coerceArray, coerceBooleanProperty } from '@angular/cdk/coercion';\nimport { ESCAPE, UP_ARROW } from '@angular/cdk/keycodes';\nimport {\n  BlockScrollStrategy,\n  Overlay,\n  OverlayConfig,\n  OverlayRef,\n  PositionStrategy,\n  ScrollStrategy\n} from '@angular/cdk/overlay';\nimport { ComponentPortal } from '@angular/cdk/portal';\nimport { DOCUMENT } from '@angular/common';\nimport {\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  ComponentRef,\n  EventEmitter,\n  Inject,\n  InjectionToken,\n  Input,\n  NgZone,\n  OnDestroy,\n  Optional,\n  Output,\n  ViewContainerRef\n} from '@angular/core';\nimport { Subscription, merge } from 'rxjs';\nimport { filter, take } from 'rxjs/operators';\nimport { OwlDialogRef } from '../dialog/dialog-ref.class';\nimport { OwlDialogService } from '../dialog/dialog.service';\nimport { DateTimeAdapter } from './adapter/date-time-adapter.class';\nimport { OWL_DATE_TIME_FORMATS, OwlDateTimeFormats } from './adapter/date-time-format.class';\nimport { OwlDateTimeContainerComponent } from './date-time-picker-container.component';\nimport { OwlDateTimeInputDirective } from './date-time-picker-input.directive';\nimport { OwlDateTime, PickerMode, PickerType, SelectMode } from './date-time.class';\n\n/** Injection token that determines the scroll handling while the dtPicker is open. */\nexport const OWL_DTPICKER_SCROLL_STRATEGY = new InjectionToken<() => ScrollStrategy>('owl-dtpicker-scroll-strategy');\n\n/** @docs-private */\nexport function OWL_DTPICKER_SCROLL_STRATEGY_PROVIDER_FACTORY(overlay: Overlay): () => BlockScrollStrategy {\n  const fn = () => overlay.scrollStrategies.block();\n  return fn;\n}\n\n/** @docs-private */\nexport const OWL_DTPICKER_SCROLL_STRATEGY_PROVIDER = {\n  provide: OWL_DTPICKER_SCROLL_STRATEGY,\n  deps: [Overlay],\n  useFactory: OWL_DTPICKER_SCROLL_STRATEGY_PROVIDER_FACTORY\n};\n\n@Component({\n  selector: 'owl-date-time',\n  exportAs: 'owlDateTime',\n  templateUrl: './date-time-picker.component.html',\n  styleUrls: ['./date-time-picker.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  preserveWhitespaces: false\n})\nexport class OwlDateTimeComponent<T> extends OwlDateTime<T> implements OnDestroy {\n  /** Custom class for the picker backdrop. */\n  @Input()\n  public backdropClass: string | Array<string> = [];\n\n  /** Custom class for the picker overlay pane. */\n  @Input()\n  public panelClass: string | Array<string> = [];\n\n  /** The date to open the calendar to initially. */\n  private _startAt: T | null;\n  @Input()\n  get startAt(): T | null {\n    // If an explicit startAt is set we start there, otherwise we start at whatever the currently\n    // selected value is.\n    if (this._startAt) {\n      return this._startAt;\n    }\n\n    if (this._dtInput) {\n      if (this._dtInput.selectMode === 'single') {\n        return this._dtInput.value || null;\n      } else if (this._dtInput.selectMode === 'range' || this._dtInput.selectMode === 'rangeFrom') {\n        return this._dtInput.values[0] || null;\n      } else if (this._dtInput.selectMode === 'rangeTo') {\n        return this._dtInput.values[1] || null;\n      }\n    }\n\n    return null;\n  }\n\n  set startAt(date: T | null) {\n    this._startAt = this.getValidDate(this.dateTimeAdapter.deserialize(date));\n  }\n\n  /** The end date to set for range calendar. */\n  private _endAt: T | null;\n  @Input()\n  get endAt(): T | null {\n    if (this._endAt) {\n      return this._endAt;\n    }\n\n    if (this._dtInput) {\n      if (this._dtInput.selectMode === 'single') {\n        return this._dtInput.value || null;\n      } else if (this._dtInput.selectMode === 'range' || this._dtInput.selectMode === 'rangeFrom') {\n        return this._dtInput.values[1] || null;\n      }\n    }\n    return null;\n  }\n\n  set endAt(date: T | null) {\n    this._endAt = this.getValidDate(this.dateTimeAdapter.deserialize(date));\n  }\n\n  /**\n   * Set the type of the dateTime picker\n   *      'both' -- show both calendar and timer\n   *      'calendar' -- show only calendar\n   *      'timer' -- show only timer\n   */\n  private _pickerType: PickerType = 'both';\n  @Input()\n  get pickerType(): PickerType {\n    return this._pickerType;\n  }\n\n  set pickerType(val: PickerType) {\n    if (val !== this._pickerType) {\n      this._pickerType = val;\n      if (this._dtInput) {\n        this._dtInput.formatNativeInputValue();\n      }\n    }\n  }\n\n  /**\n   * Whether the picker open as a dialog\n   */\n  _pickerMode: PickerMode = 'popup';\n  @Input()\n  get pickerMode() {\n    return this._pickerMode;\n  }\n\n  set pickerMode(mode: PickerMode) {\n    if (mode === 'popup') {\n      this._pickerMode = mode;\n    } else {\n      this._pickerMode = 'dialog';\n    }\n  }\n\n  /** Whether the date time picker should be disabled. */\n  private _disabled: boolean;\n  @Input()\n  override get disabled(): boolean {\n    return this._disabled === undefined && this._dtInput ? this._dtInput.disabled : !!this._disabled;\n  }\n\n  override set disabled(value: boolean) {\n    value = coerceBooleanProperty(value);\n    if (value !== this._disabled) {\n      this._disabled = value;\n      this.disabledChange.next(value);\n    }\n  }\n\n  /** Whether the calendar is open. */\n  private _opened = false;\n  @Input()\n  get opened(): boolean {\n    return this._opened;\n  }\n\n  set opened(val: boolean) {\n    if (val) {\n      this.open();\n    } else {\n      this.close();\n    }\n  }\n\n  /**\n   * The scroll strategy when the picker is open\n   * Learn more this from https://material.angular.io/cdk/overlay/overview#scroll-strategies\n   * */\n  @Input()\n  public scrollStrategy: ScrollStrategy;\n\n  /**\n   * Callback when the picker is closed\n   * */\n  @Output()\n  afterPickerClosed = new EventEmitter<any>();\n\n  /**\n   * Callback before the picker is open\n   * */\n  @Output()\n  beforePickerOpen = new EventEmitter<any>();\n\n  /**\n   * Callback when the picker is open\n   * */\n  @Output()\n  afterPickerOpen = new EventEmitter<any>();\n\n  /**\n   * Emits selected year in multi-year view\n   * This doesn't imply a change on the selected date.\n   * */\n  @Output()\n  yearSelected = new EventEmitter<T>();\n\n  /**\n   * Emits selected month in year view\n   * This doesn't imply a change on the selected date.\n   * */\n  @Output()\n  monthSelected = new EventEmitter<T>();\n\n  /**\n   * Emits selected date\n   * */\n  @Output()\n  dateSelected = new EventEmitter<T>();\n\n  /**\n   * Emit when the selected value has been confirmed\n   * */\n  public confirmSelectedChange = new EventEmitter<Array<T> | T>();\n\n  /**\n   * Emits when the date time picker is disabled.\n   * */\n  public disabledChange = new EventEmitter<boolean>();\n\n  private pickerContainerPortal: ComponentPortal<OwlDateTimeContainerComponent<T>>;\n  private pickerContainer: OwlDateTimeContainerComponent<T>;\n  private popupRef: OverlayRef;\n  private dialogRef: OwlDialogRef<OwlDateTimeContainerComponent<T>>;\n  private dtInputSub = Subscription.EMPTY;\n  private hidePickerStreamSub = Subscription.EMPTY;\n  private confirmSelectedStreamSub = Subscription.EMPTY;\n  private pickerOpenedStreamSub = Subscription.EMPTY;\n  private pickerBeforeOpenedStreamSub = Subscription.EMPTY;\n\n  /** The element that was focused before the date time picker was opened. */\n  private focusedElementBeforeOpen: HTMLElement | null = null;\n\n  private _dtInput: OwlDateTimeInputDirective<T>;\n  get dtInput() {\n    return this._dtInput;\n  }\n\n  private _selected: T | null;\n  get selected() {\n    return this._selected;\n  }\n\n  set selected(value: T | null) {\n    this._selected = value;\n    this.changeDetector.markForCheck();\n  }\n\n  private _selecteds: Array<T> = [];\n  get selecteds() {\n    return this._selecteds;\n  }\n\n  set selecteds(values: Array<T>) {\n    this._selecteds = values;\n    this.changeDetector.markForCheck();\n  }\n\n  /** The minimum selectable date. */\n  get minDateTime(): T | null {\n    return this._dtInput && this._dtInput.min;\n  }\n\n  /** The maximum selectable date. */\n  get maxDateTime(): T | null {\n    return this._dtInput && this._dtInput.max;\n  }\n\n  get dateTimeFilter(): (date: T | null) => boolean {\n    return this._dtInput && this._dtInput.dateTimeFilter;\n  }\n\n  get selectMode(): SelectMode {\n    return this._dtInput.selectMode;\n  }\n\n  get isInSingleMode(): boolean {\n    return this._dtInput.isInSingleMode;\n  }\n\n  get isInRangeMode(): boolean {\n    return this._dtInput.isInRangeMode;\n  }\n\n  private readonly defaultScrollStrategy: () => ScrollStrategy;\n\n  constructor(\n    public overlay: Overlay,\n    private viewContainerRef: ViewContainerRef,\n    private dialogService: OwlDialogService,\n    private ngZone: NgZone,\n    protected changeDetector: ChangeDetectorRef,\n    @Optional() protected override dateTimeAdapter: DateTimeAdapter<T>,\n    @Inject(OWL_DTPICKER_SCROLL_STRATEGY) defaultScrollStrategy: any,\n    @Optional()\n    @Inject(OWL_DATE_TIME_FORMATS)\n    protected override dateTimeFormats: OwlDateTimeFormats,\n    @Optional()\n    @Inject(DOCUMENT)\n    private document: any\n  ) {\n    super(dateTimeAdapter, dateTimeFormats);\n    this.defaultScrollStrategy = defaultScrollStrategy;\n  }\n\n  public ngOnDestroy(): void {\n    this.close();\n    this.dtInputSub.unsubscribe();\n    this.disabledChange.complete();\n\n    if (this.popupRef) {\n      this.popupRef.dispose();\n    }\n  }\n\n  public registerInput(input: OwlDateTimeInputDirective<T>): void {\n    if (this._dtInput) {\n      throw Error('A Owl DateTimePicker can only be associated with a single input.');\n    }\n\n    this._dtInput = input;\n    this.dtInputSub = this._dtInput.valueChange.subscribe((value: Array<T> | T | null) => {\n      if (Array.isArray(value)) {\n        this.selecteds = value;\n      } else {\n        this.selected = value;\n      }\n    });\n  }\n\n  public open(): void {\n    if (this._opened || this.disabled) {\n      return;\n    }\n\n    if (!this._dtInput) {\n      throw Error('Attempted to open an DateTimePicker with no associated input.');\n    }\n\n    if (this.document) {\n      this.focusedElementBeforeOpen = this.document.activeElement;\n    }\n\n    // reset the picker selected value\n    if (this.isInSingleMode) {\n      this.selected = this._dtInput.value;\n    } else if (this.isInRangeMode) {\n      this.selecteds = this._dtInput.values;\n    }\n\n    // when the picker is open , we make sure the picker's current selected time value\n    // is the same as the _startAt time value.\n    if (this.selected && this.pickerType !== 'calendar' && this._startAt) {\n      this.selected = this.dateTimeAdapter.createDate(\n        this.dateTimeAdapter.getYear(this.selected),\n        this.dateTimeAdapter.getMonth(this.selected),\n        this.dateTimeAdapter.getDate(this.selected),\n        this.dateTimeAdapter.getHours(this._startAt),\n        this.dateTimeAdapter.getMinutes(this._startAt),\n        this.dateTimeAdapter.getSeconds(this._startAt)\n      );\n    }\n\n    if (this.pickerMode === 'dialog') {\n      this.openAsDialog();\n    } else {\n      this.openAsPopup();\n    }\n\n    this.pickerContainer.picker = this;\n\n    // Listen to picker container's hidePickerStream\n    this.hidePickerStreamSub = this.pickerContainer.hidePickerStream.subscribe(() => {\n      this.close();\n    });\n\n    // Listen to picker container's confirmSelectedStream\n    this.confirmSelectedStreamSub = this.pickerContainer.confirmSelectedStream.subscribe((event: any) => {\n      this.confirmSelect(event);\n    });\n  }\n\n  /**\n   * Selects the given date\n   */\n  public select(date: Array<T> | T): void {\n    if (Array.isArray(date)) {\n      this.selecteds = [...date];\n    } else {\n      this.selected = date;\n    }\n\n    /**\n     * Cases in which automatically confirm the select when date or dates are selected:\n     * 1) picker mode is NOT 'dialog'\n     * 2) picker type is 'calendar' and selectMode is 'single'.\n     * 3) picker type is 'calendar' and selectMode is 'range' and\n     *    the 'selecteds' has 'from'(selecteds[0]) and 'to'(selecteds[1]) values.\n     * 4) selectMode is 'rangeFrom' and selecteds[0] has value.\n     * 5) selectMode is 'rangeTo' and selecteds[1] has value.\n     * */\n    if (\n      this.pickerMode !== 'dialog' &&\n      this.pickerType === 'calendar' &&\n      ((this.selectMode === 'single' && this.selected) ||\n        (this.selectMode === 'rangeFrom' && this.selecteds[0]) ||\n        (this.selectMode === 'rangeTo' && this.selecteds[1]) ||\n        (this.selectMode === 'range' && this.selecteds[0] && this.selecteds[1]))\n    ) {\n      this.confirmSelect();\n    }\n  }\n\n  /**\n   * Emits the selected year in multi-year view\n   * */\n  public selectYear(normalizedYear: T): void {\n    this.yearSelected.emit(normalizedYear);\n  }\n\n  /**\n   * Emits selected month in year view\n   * */\n  public selectMonth(normalizedMonth: T): void {\n    this.monthSelected.emit(normalizedMonth);\n  }\n\n  /**\n   * Emits the selected date\n   * */\n  public selectDate(normalizedDate: T): void {\n    this.dateSelected.emit(normalizedDate);\n  }\n\n  /**\n   * Hide the picker\n   */\n  public close(): void {\n    if (!this._opened) {\n      return;\n    }\n\n    if (this.popupRef && this.popupRef.hasAttached()) {\n      this.popupRef.detach();\n    }\n\n    if (this.pickerContainerPortal && this.pickerContainerPortal.isAttached) {\n      this.pickerContainerPortal.detach();\n    }\n\n    if (this.hidePickerStreamSub) {\n      this.hidePickerStreamSub.unsubscribe();\n      this.hidePickerStreamSub = null;\n    }\n\n    if (this.confirmSelectedStreamSub) {\n      this.confirmSelectedStreamSub.unsubscribe();\n      this.confirmSelectedStreamSub = null;\n    }\n\n    if (this.pickerBeforeOpenedStreamSub) {\n      this.pickerBeforeOpenedStreamSub.unsubscribe();\n      this.pickerBeforeOpenedStreamSub = null;\n    }\n\n    if (this.pickerOpenedStreamSub) {\n      this.pickerOpenedStreamSub.unsubscribe();\n      this.pickerOpenedStreamSub = null;\n    }\n\n    if (this.dialogRef) {\n      this.dialogRef.close();\n      this.dialogRef = null;\n    }\n\n    const completeClose = () => {\n      if (this._opened) {\n        this._opened = false;\n        const selected = this.selected || this.selecteds;\n        this.afterPickerClosed.emit(selected);\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  /**\n   * Confirm the selected value\n   */\n  public confirmSelect(event?: any): void {\n    if (this.isInSingleMode) {\n      const selected = this.selected || this.startAt || this.dateTimeAdapter.now();\n      this.confirmSelectedChange.emit(selected);\n    } else if (this.isInRangeMode) {\n      this.confirmSelectedChange.emit(this.selecteds);\n    }\n\n    this.close();\n    return;\n  }\n\n  /**\n   * Open the picker as a dialog\n   */\n  private openAsDialog(): void {\n    this.dialogRef = this.dialogService.open(OwlDateTimeContainerComponent, {\n      autoFocus: false,\n      backdropClass: ['cdk-overlay-dark-backdrop', ...coerceArray(this.backdropClass)],\n      paneClass: ['owl-dt-dialog', ...coerceArray(this.panelClass)],\n      viewContainerRef: this.viewContainerRef,\n      scrollStrategy: this.scrollStrategy || this.defaultScrollStrategy()\n    });\n    this.pickerContainer = this.dialogRef.componentInstance;\n\n    this.dialogRef.beforeOpen().subscribe(() => {\n      this.beforePickerOpen.emit(null);\n    });\n    this.dialogRef.afterOpen().subscribe(() => {\n      this.afterPickerOpen.emit(null);\n      this._opened = true;\n    });\n    this.dialogRef.afterClosed().subscribe(() => this.close());\n  }\n\n  /**\n   * Open the picker as popup\n   */\n  private openAsPopup(): void {\n    if (!this.pickerContainerPortal) {\n      this.pickerContainerPortal = new ComponentPortal<OwlDateTimeContainerComponent<T>>(\n        OwlDateTimeContainerComponent,\n        this.viewContainerRef\n      );\n    }\n\n    if (!this.popupRef) {\n      this.createPopup();\n    }\n\n    if (!this.popupRef.hasAttached()) {\n      const componentRef: ComponentRef<OwlDateTimeContainerComponent<T>> = this.popupRef.attach(\n        this.pickerContainerPortal\n      );\n      this.pickerContainer = componentRef.instance;\n\n      // Update the position once the calendar has rendered.\n      this.ngZone.onStable\n        .asObservable()\n        .pipe(take(1))\n        .subscribe(() => {\n          this.popupRef.updatePosition();\n        });\n\n      this.pickerBeforeOpenedStreamSub = this.pickerContainer.beforePickerOpenedStream.pipe(take(1)).subscribe(() => {\n        this.beforePickerOpen.emit(null);\n      });\n\n      // emit open stream\n      this.pickerOpenedStreamSub = this.pickerContainer.pickerOpenedStream.pipe(take(1)).subscribe(() => {\n        this.afterPickerOpen.emit(null);\n        this._opened = true;\n      });\n    }\n  }\n\n  private createPopup(): void {\n    const overlayConfig = new OverlayConfig({\n      positionStrategy: this.createPopupPositionStrategy(),\n      hasBackdrop: true,\n      backdropClass: ['cdk-overlay-transparent-backdrop', ...coerceArray(this.backdropClass)],\n      scrollStrategy: this.scrollStrategy || this.defaultScrollStrategy(),\n      panelClass: ['owl-dt-popup', ...coerceArray(this.panelClass)]\n    });\n\n    this.popupRef = this.overlay.create(overlayConfig);\n\n    merge(\n      this.popupRef.backdropClick(),\n      this.popupRef.detachments(),\n      this.popupRef\n        .keydownEvents()\n        .pipe(\n          filter((event) => event.keyCode === ESCAPE || (this._dtInput && event.altKey && event.keyCode === UP_ARROW))\n        )\n    ).subscribe(() => this.close());\n  }\n\n  /**\n   * Create the popup PositionStrategy.\n   * */\n  private createPopupPositionStrategy(): PositionStrategy {\n    return this.overlay\n      .position()\n      .flexibleConnectedTo(this._dtInput.elementRef)\n      .withTransformOriginOn('.owl-dt-container')\n      .withFlexibleDimensions(false)\n      .withPush(false)\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          originX: 'start',\n          originY: 'top',\n          overlayX: 'start',\n          overlayY: 'top',\n          offsetY: -176\n        },\n        {\n          originX: 'start',\n          originY: 'top',\n          overlayX: 'start',\n          overlayY: 'top',\n          offsetY: -352\n        }\n      ]);\n  }\n}\n",""]}