@gipisistemas/ng-core 1.1.10 → 1.1.12

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

@@ -0,0 +1,346 @@
+var GIPIDatetimepickerInputDirective_1;
+import { __decorate, __metadata, __param } from "tslib";
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { DOWN_ARROW } from '@angular/cdk/keycodes';
+import { AfterContentInit, Directive, ElementRef, EventEmitter, forwardRef, Inject, Input, OnDestroy, Optional, Output, } from '@angular/core';
+import { NG_VALIDATORS, NG_VALUE_ACCESSOR, Validators, } from '@angular/forms';
+import { MatFormField } from '@angular/material/form-field';
+import { MAT_INPUT_VALUE_ACCESSOR } from '@angular/material/input';
+import { Subscription } from 'rxjs';
+import { GIPIDatetimepickerComponent } from './datetimepicker';
+import { createMissingDateImplError } from './datetimepicker-errors';
+import { GIPIDatetimepickerFilterType } from './datetimepicker-filtertype';
+import { GIPIDatetimeAdapter } from './shared/adapter/datetime-adapter';
+import { GIPI_DATETIME_FORMATS, } from './shared/adapter/datetime-formats';
+export const GIPI_DATETIMEPICKER_VALUE_ACCESSOR = {
+    provide: NG_VALUE_ACCESSOR,
+    useExisting: forwardRef(() => GIPIDatetimepickerInputDirective),
+    multi: true,
+};
+export const GIPI_DATETIMEPICKER_VALIDATORS = {
+    provide: NG_VALIDATORS,
+    useExisting: forwardRef(() => GIPIDatetimepickerInputDirective),
+    multi: true,
+};
+/**
+ * An event used for datepicker input and change events. We don't always have access to a native
+ * input or change event because the event may have been triggered by the user clicking on the
+ * calendar popup. For consistency, we always use MatDatepickerInputEvent instead.
+ */
+export class GIPIDatetimepickerInputEvent {
+    constructor(target, targetElement) {
+        this.target = target;
+        this.targetElement = targetElement;
+        this.value = this.target.value;
+    }
+}
+/** Directive used to connect an input to a MatDatepicker. */
+let GIPIDatetimepickerInputDirective = GIPIDatetimepickerInputDirective_1 = class GIPIDatetimepickerInputDirective {
+    constructor(_elementRef, _dateAdapter, _dateFormats, _formField) {
+        this._elementRef = _elementRef;
+        this._dateAdapter = _dateAdapter;
+        this._dateFormats = _dateFormats;
+        this._formField = _formField;
+        /** Emits when the value changes (either due to user input or programmatic change). */
+        this._valueChange = new EventEmitter();
+        /** Emits when the disabled state has changed */
+        this._disabledChange = new EventEmitter();
+        this._datepickerSubscription = Subscription.EMPTY;
+        this._localeSubscription = Subscription.EMPTY;
+        /** Whether the last value set on the input was valid. */
+        this._lastValueValid = false;
+        /** Emits when a `change` event is fired on this `<input>`. */
+        this.dateChange = new EventEmitter();
+        /** Emits when an `input` event is fired on this `<input>`. */
+        this.dateInput = new EventEmitter();
+        this._onTouched = () => { };
+        this._cvaOnChange = () => { };
+        this._validatorOnChange = () => { };
+        /** The form control validator for whether the input parses. */
+        this._parseValidator = () => {
+            return this._lastValueValid
+                ? null
+                : { matDatepickerParse: { text: this._elementRef.nativeElement.value } };
+        };
+        /** The form control validator for the min date. */
+        this._minValidator = (control) => {
+            const controlValue = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(control.value));
+            return !this.min ||
+                !controlValue ||
+                this._dateAdapter.compareDatetime(this.min, controlValue) <= 0 ? null : { matDatepickerMin: { min: this.min, actual: controlValue } };
+        };
+        /** The form control validator for the max date. */
+        this._maxValidator = (control) => {
+            const controlValue = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(control.value));
+            return !this.max ||
+                !controlValue ||
+                this._dateAdapter.compareDatetime(this.max, controlValue) >= 0 ? null : { matDatepickerMax: { max: this.max, actual: controlValue } };
+        };
+        /** The form control validator for the date filter. */
+        this._filterValidator = (control) => {
+            const controlValue = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(control.value));
+            return !this._dateFilter ||
+                !controlValue ||
+                this._dateFilter(controlValue, GIPIDatetimepickerFilterType.DATE)
+                ? null
+                : { matDatepickerFilter: true };
+        };
+        /** The combined form control validator for this input. */
+        this._validator = Validators.compose([
+            this._parseValidator,
+            this._minValidator,
+            this._maxValidator,
+            this._filterValidator,
+        ]);
+        if (!this._dateAdapter) {
+            throw createMissingDateImplError('GIPIDatetimeAdapter');
+        }
+        if (!this._dateFormats) {
+            throw createMissingDateImplError('GIPI_DATETIME_FORMATS');
+        }
+        // Update the displayed date when the locale changes.
+        this._localeSubscription = _dateAdapter.localeChanges.subscribe(() => this.value = this.value);
+    }
+    /** The datepicker that this input is associated with. */
+    set gipiMatDatetimePicker(value) {
+        this.registerDatepicker(value);
+    }
+    set matDatepickerFilter(filter) {
+        this._dateFilter = filter;
+        this._validatorOnChange();
+    }
+    get value() {
+        return this._value;
+    }
+    set value(value) {
+        value = this._dateAdapter.deserialize(value);
+        this._lastValueValid = !value || this._dateAdapter.isValid(value);
+        value = this._dateAdapter.getValidDateOrNull(value);
+        const oldDate = this.value;
+        this._value = value;
+        this._formatValue(value);
+        // use timeout to ensure the datetimepicker is instantiated and we get the correct format
+        setTimeout(() => {
+            if (!this._dateAdapter.sameDatetime(oldDate, value)) {
+                this._valueChange.emit(value);
+            }
+        });
+    }
+    get min() {
+        return this._min;
+    }
+    set min(value) {
+        this._min = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));
+        this._validatorOnChange();
+    }
+    get max() {
+        return this._max;
+    }
+    set max(value) {
+        this._max = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));
+        this._validatorOnChange();
+    }
+    get disabled() {
+        return !!this._disabled;
+    }
+    set disabled(value) {
+        const newValue = coerceBooleanProperty(value);
+        if (this._disabled !== newValue) {
+            this._disabled = newValue;
+            this._disabledChange.emit(newValue);
+        }
+    }
+    ngAfterContentInit() {
+        if (this._datepicker) {
+            this._datepickerSubscription = this._datepicker.selectedChanged.subscribe((selected) => {
+                this.value = selected;
+                this._cvaOnChange(selected);
+                this._onTouched();
+                this.dateInput.emit(new GIPIDatetimepickerInputEvent(this, this._elementRef.nativeElement));
+                this.dateChange.emit(new GIPIDatetimepickerInputEvent(this, this._elementRef.nativeElement));
+            });
+        }
+    }
+    ngOnDestroy() {
+        this._datepickerSubscription.unsubscribe();
+        this._localeSubscription.unsubscribe();
+        this._valueChange.complete();
+        this._disabledChange.complete();
+    }
+    registerOnValidatorChange(fn) {
+        this._validatorOnChange = fn;
+    }
+    validate(c) {
+        return this._validator ? this._validator(c) : null;
+    }
+    /**
+     * Gets the element that the datepicker popup should be connected to.
+     * @return The element to connect the popup to.
+     */
+    getConnectedOverlayOrigin() {
+        return this._formField
+            ? this._formField.getConnectedOverlayOrigin()
+            : this._elementRef;
+    }
+    // Implemented as part of ControlValueAccessor
+    writeValue(value) {
+        this.value = value;
+    }
+    // Implemented as part of ControlValueAccessor
+    registerOnChange(fn) {
+        this._cvaOnChange = fn;
+    }
+    // Implemented as part of ControlValueAccessor
+    registerOnTouched(fn) {
+        this._onTouched = fn;
+    }
+    // Implemented as part of ControlValueAccessor
+    setDisabledState(disabled) {
+        this.disabled = disabled;
+    }
+    _onKeydown(event) {
+        if (event.altKey && event.keyCode === DOWN_ARROW) {
+            this._datepicker.open();
+            event.preventDefault();
+        }
+    }
+    _onInput(value) {
+        let date = this._dateAdapter.parse(value, this.getParseFormat());
+        this._lastValueValid = !date || this._dateAdapter.isValid(date);
+        date = this._dateAdapter.getValidDateOrNull(date);
+        this._value = date;
+        this._cvaOnChange(date);
+        this._valueChange.emit(date);
+        this.dateInput.emit(new GIPIDatetimepickerInputEvent(this, this._elementRef.nativeElement));
+    }
+    _onChange() {
+        this.dateChange.emit(new GIPIDatetimepickerInputEvent(this, this._elementRef.nativeElement));
+    }
+    /** Handles blur events on the input. */
+    _onBlur() {
+        // Reformat the input only if we have a valid value.
+        if (this.value) {
+            this._formatValue(this.value);
+        }
+        this._onTouched();
+    }
+    registerDatepicker(value) {
+        if (value) {
+            this._datepicker = value;
+            this._datepicker._registerInput(this);
+        }
+    }
+    getDisplayFormat() {
+        switch (this._datepicker.type) {
+            case 'date': return this._dateFormats.display.dateInput;
+            case 'datetime': return this._dateFormats.display.datetimeInput;
+            case 'time': return this._dateFormats.display.timeInput;
+            case 'month': return this._dateFormats.display.monthInput;
+        }
+    }
+    getParseFormat() {
+        let parseFormat;
+        switch (this._datepicker.type) {
+            case 'date':
+                parseFormat = this._dateFormats.parse.dateInput;
+                break;
+            case 'datetime':
+                parseFormat = this._dateFormats.parse.datetimeInput;
+                break;
+            case 'time':
+                parseFormat = this._dateFormats.parse.timeInput;
+                break;
+            case 'month':
+                parseFormat = this._dateFormats.parse.monthInput;
+                break;
+        }
+        if (!parseFormat) {
+            parseFormat = this._dateFormats.parse.dateInput;
+        }
+        return parseFormat;
+    }
+    /** Formats a value and sets it on the input element. */
+    _formatValue(value) {
+        this._elementRef.nativeElement.value = value
+            ? this._dateAdapter.format(value, this.getDisplayFormat())
+            : '';
+    }
+};
+GIPIDatetimepickerInputDirective.ctorParameters = () => [
+    { type: ElementRef },
+    { type: GIPIDatetimeAdapter, decorators: [{ type: Optional }] },
+    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [GIPI_DATETIME_FORMATS,] }] },
+    { type: MatFormField, decorators: [{ type: Optional }] }
+];
+__decorate([
+    Input(),
+    __metadata("design:type", GIPIDatetimepickerComponent),
+    __metadata("design:paramtypes", [GIPIDatetimepickerComponent])
+], GIPIDatetimepickerInputDirective.prototype, "gipiMatDatetimePicker", null);
+__decorate([
+    Input(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Function])
+], GIPIDatetimepickerInputDirective.prototype, "matDatepickerFilter", null);
+__decorate([
+    Input(),
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [Object])
+], GIPIDatetimepickerInputDirective.prototype, "value", null);
+__decorate([
+    Input(),
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [Object])
+], GIPIDatetimepickerInputDirective.prototype, "min", null);
+__decorate([
+    Input(),
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [Object])
+], GIPIDatetimepickerInputDirective.prototype, "max", null);
+__decorate([
+    Input(),
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [Object])
+], GIPIDatetimepickerInputDirective.prototype, "disabled", null);
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], GIPIDatetimepickerInputDirective.prototype, "dateChange", void 0);
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], GIPIDatetimepickerInputDirective.prototype, "dateInput", void 0);
+GIPIDatetimepickerInputDirective = GIPIDatetimepickerInputDirective_1 = __decorate([
+    Directive({
+        selector: 'input[gipiMatDatetimePicker]',
+        exportAs: 'matDatepickerInput',
+        providers: [
+            GIPI_DATETIMEPICKER_VALUE_ACCESSOR,
+            GIPI_DATETIMEPICKER_VALIDATORS,
+            {
+                provide: MAT_INPUT_VALUE_ACCESSOR,
+                useExisting: GIPIDatetimepickerInputDirective_1,
+            },
+        ],
+        host: {
+            '[attr.aria-haspopup]': 'true',
+            '[attr.aria-owns]': '(_datepicker?.opened && _datepicker.id) || null',
+            '[attr.min]': 'min ? _dateAdapter.toIso8601(min) : null',
+            '[attr.max]': 'max ? _dateAdapter.toIso8601(max) : null',
+            '[disabled]': 'disabled',
+            '(focus)': '_datepicker._handleFocus()',
+            '(input)': '_onInput($event.target.value)',
+            '(change)': '_onChange()',
+            '(blur)': '_onBlur()',
+            '(keydown)': '_onKeydown($event)',
+        },
+    }),
+    __param(1, Optional()),
+    __param(2, Optional()),
+    __param(2, Inject(GIPI_DATETIME_FORMATS)),
+    __param(3, Optional()),
+    __metadata("design:paramtypes", [ElementRef,
+        GIPIDatetimeAdapter, Object, MatFormField])
+], GIPIDatetimepickerInputDirective);
+export { GIPIDatetimepickerInputDirective };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"datetimepicker-input.js","sourceRoot":"ng://@gipisistemas/ng-core/","sources":["shared/gipi-components/datetime-picker/mat-datetime-picker/datetimepicker-input.ts"],"names":[],"mappings":"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","sourcesContent":["import { coerceBooleanProperty } from '@angular/cdk/coercion';\nimport { DOWN_ARROW } from '@angular/cdk/keycodes';\nimport { AfterContentInit, Directive, ElementRef, EventEmitter, forwardRef, Inject, Input, OnDestroy, Optional, Output, } from '@angular/core';\nimport { AbstractControl, ControlValueAccessor, NG_VALIDATORS, NG_VALUE_ACCESSOR, ValidationErrors, Validator, ValidatorFn, Validators, } from '@angular/forms';\nimport { MatFormField } from '@angular/material/form-field';\nimport { MAT_INPUT_VALUE_ACCESSOR } from '@angular/material/input';\nimport { Subscription } from 'rxjs';\n\nimport { GIPIDatetimepickerComponent } from './datetimepicker';\nimport { createMissingDateImplError } from './datetimepicker-errors';\nimport { GIPIDatetimepickerFilterType } from './datetimepicker-filtertype';\nimport { GIPIDatetimeAdapter } from './shared/adapter/datetime-adapter';\nimport { GIPI_DATETIME_FORMATS, GIPIDatetimeFormats, } from './shared/adapter/datetime-formats';\n\nexport const GIPI_DATETIMEPICKER_VALUE_ACCESSOR: any = {\n    provide: NG_VALUE_ACCESSOR,\n    useExisting: forwardRef(() => GIPIDatetimepickerInputDirective),\n    multi: true,\n};\n\nexport const GIPI_DATETIMEPICKER_VALIDATORS: any = {\n    provide: NG_VALIDATORS,\n    useExisting: forwardRef(() => GIPIDatetimepickerInputDirective),\n    multi: true,\n};\n\n/**\n * An event used for datepicker input and change events. We don't always have access to a native\n * input or change event because the event may have been triggered by the user clicking on the\n * calendar popup. For consistency, we always use MatDatepickerInputEvent instead.\n */\nexport class GIPIDatetimepickerInputEvent<D> {\n    /** The new value for the target datepicker input. */\n    value: D | null;\n\n    constructor(\n        public target: GIPIDatetimepickerInputDirective<D>,\n        public targetElement: HTMLElement\n    ) {\n        this.value = this.target.value;\n    }\n}\n\n/** Directive used to connect an input to a MatDatepicker. */\n@Directive({\n    selector: 'input[gipiMatDatetimePicker]',\n    exportAs: 'matDatepickerInput',\n    providers: [\n        GIPI_DATETIMEPICKER_VALUE_ACCESSOR,\n        GIPI_DATETIMEPICKER_VALIDATORS,\n        {\n            provide: MAT_INPUT_VALUE_ACCESSOR,\n            useExisting: GIPIDatetimepickerInputDirective,\n        },\n    ],\n    host: {\n        '[attr.aria-haspopup]': 'true',\n        '[attr.aria-owns]': '(_datepicker?.opened && _datepicker.id) || null',\n        '[attr.min]': 'min ? _dateAdapter.toIso8601(min) : null',\n        '[attr.max]': 'max ? _dateAdapter.toIso8601(max) : null',\n        '[disabled]': 'disabled',\n        '(focus)': '_datepicker._handleFocus()',\n        '(input)': '_onInput($event.target.value)',\n        '(change)': '_onChange()',\n        '(blur)': '_onBlur()',\n        '(keydown)': '_onKeydown($event)',\n    },\n})\nexport class GIPIDatetimepickerInputDirective<D> implements AfterContentInit, ControlValueAccessor, OnDestroy, Validator {\n    _datepicker: GIPIDatetimepickerComponent<D>;\n\n    _dateFilter: (date: D | null, type: GIPIDatetimepickerFilterType) => boolean;\n\n    /** Emits when the value changes (either due to user input or programmatic change). */\n    _valueChange = new EventEmitter<D | null>();\n\n    /** Emits when the disabled state has changed */\n    _disabledChange = new EventEmitter<boolean>();\n    private _datepickerSubscription = Subscription.EMPTY;\n    private _localeSubscription = Subscription.EMPTY;\n\n    /** Whether the last value set on the input was valid. */\n    private _lastValueValid = false;\n\n    /** The datepicker that this input is associated with. */\n    @Input() set gipiMatDatetimePicker(value: GIPIDatetimepickerComponent<D>) {\n        this.registerDatepicker(value);\n    }\n\n    @Input() set matDatepickerFilter(filter: (date: D | null, type: GIPIDatetimepickerFilterType) => boolean) {\n        this._dateFilter = filter;\n        this._validatorOnChange();\n    }\n\n    /** The value of the input. */\n    private _value: D | null;\n    @Input() get value(): D | null {\n        return this._value;\n    }\n    set value(value: D | null) {\n        value = this._dateAdapter.deserialize(value);\n        this._lastValueValid = !value || this._dateAdapter.isValid(value);\n        value = this._dateAdapter.getValidDateOrNull(value);\n        const oldDate = this.value;\n        this._value = value;\n        this._formatValue(value);\n\n        // use timeout to ensure the datetimepicker is instantiated and we get the correct format\n        setTimeout(() => {\n            if (!this._dateAdapter.sameDatetime(oldDate, value)) {\n                this._valueChange.emit(value);\n            }\n        });\n    }\n\n    /** The minimum valid date. */\n    private _min: D | null;\n    @Input() get min(): D | null {\n        return this._min;\n    }\n    set min(value: D | null) {\n        this._min = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));\n        this._validatorOnChange();\n    }\n\n    /** The maximum valid date. */\n    private _max: D | null;\n    @Input() get max(): D | null {\n        return this._max;\n    }\n    set max(value: D | null) {\n        this._max = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));\n        this._validatorOnChange();\n    }\n\n    /** Whether the datepicker-input is disabled. */\n    private _disabled: boolean;\n    @Input() get disabled() {\n        return !!this._disabled;\n    }\n    set disabled(value: any) {\n        const newValue = coerceBooleanProperty(value);\n        if (this._disabled !== newValue) {\n            this._disabled = newValue;\n            this._disabledChange.emit(newValue);\n        }\n    }\n\n    /** Emits when a `change` event is fired on this `<input>`. */\n    @Output() dateChange = new EventEmitter<GIPIDatetimepickerInputEvent<D>>();\n\n    /** Emits when an `input` event is fired on this `<input>`. */\n    @Output() dateInput = new EventEmitter<GIPIDatetimepickerInputEvent<D>>();\n\n    constructor(\n        private _elementRef: ElementRef,\n        @Optional() public _dateAdapter: GIPIDatetimeAdapter<D>,\n        @Optional()\n        @Inject(GIPI_DATETIME_FORMATS)\n        private _dateFormats: GIPIDatetimeFormats,\n        @Optional() private _formField: MatFormField\n    ) {\n        if (!this._dateAdapter) {\n            throw createMissingDateImplError('GIPIDatetimeAdapter');\n        }\n        if (!this._dateFormats) {\n            throw createMissingDateImplError('GIPI_DATETIME_FORMATS');\n        }\n\n        // Update the displayed date when the locale changes.\n        this._localeSubscription = _dateAdapter.localeChanges.subscribe(() => this.value = this.value);\n    }\n\n    _onTouched = () => { };\n\n    ngAfterContentInit() {\n        if (this._datepicker) {\n            this._datepickerSubscription = this._datepicker.selectedChanged.subscribe((selected: D) => {\n                this.value = selected;\n                this._cvaOnChange(selected);\n                this._onTouched();\n                this.dateInput.emit(new GIPIDatetimepickerInputEvent(this, this._elementRef.nativeElement));\n                this.dateChange.emit(new GIPIDatetimepickerInputEvent(this, this._elementRef.nativeElement));\n            });\n        }\n    }\n\n    ngOnDestroy() {\n        this._datepickerSubscription.unsubscribe();\n        this._localeSubscription.unsubscribe();\n        this._valueChange.complete();\n        this._disabledChange.complete();\n    }\n\n    registerOnValidatorChange(fn: () => void): void {\n        this._validatorOnChange = fn;\n    }\n\n    validate(c: AbstractControl): ValidationErrors | null {\n        return this._validator ? this._validator(c) : null;\n    }\n\n    /**\n     * Gets the element that the datepicker popup should be connected to.\n     * @return The element to connect the popup to.\n     */\n    getConnectedOverlayOrigin(): ElementRef {\n        return this._formField\n            ? this._formField.getConnectedOverlayOrigin()\n            : this._elementRef;\n    }\n\n    // Implemented as part of ControlValueAccessor\n    writeValue(value: D): void {\n        this.value = value;\n    }\n\n    // Implemented as part of ControlValueAccessor\n    registerOnChange(fn: (value: any) => void): void {\n        this._cvaOnChange = fn;\n    }\n\n    // Implemented as part of ControlValueAccessor\n    registerOnTouched(fn: () => void): void {\n        this._onTouched = fn;\n    }\n\n    // Implemented as part of ControlValueAccessor\n    setDisabledState(disabled: boolean): void {\n        this.disabled = disabled;\n    }\n\n    _onKeydown(event: KeyboardEvent) {\n        if (event.altKey && event.keyCode === DOWN_ARROW) {\n            this._datepicker.open();\n            event.preventDefault();\n        }\n    }\n\n    _onInput(value: string) {\n        let date = this._dateAdapter.parse(value, this.getParseFormat());\n        this._lastValueValid = !date || this._dateAdapter.isValid(date);\n        date = this._dateAdapter.getValidDateOrNull(date);\n        this._value = date;\n        this._cvaOnChange(date);\n        this._valueChange.emit(date);\n        this.dateInput.emit(new GIPIDatetimepickerInputEvent(this, this._elementRef.nativeElement));\n    }\n\n    _onChange() {\n        this.dateChange.emit(new GIPIDatetimepickerInputEvent(this, this._elementRef.nativeElement));\n    }\n\n    /** Handles blur events on the input. */\n    _onBlur() {\n        // Reformat the input only if we have a valid value.\n        if (this.value) {\n            this._formatValue(this.value);\n        }\n\n        this._onTouched();\n    }\n\n    private registerDatepicker(value: GIPIDatetimepickerComponent<D>) {\n        if (value) {\n            this._datepicker = value;\n            this._datepicker._registerInput(this);\n        }\n    }\n\n    private getDisplayFormat() {\n        switch (this._datepicker.type) {\n            case 'date': return this._dateFormats.display.dateInput;\n            case 'datetime': return this._dateFormats.display.datetimeInput;\n            case 'time': return this._dateFormats.display.timeInput;\n            case 'month': return this._dateFormats.display.monthInput;\n        }\n    }\n\n    private getParseFormat() {\n        let parseFormat;\n        switch (this._datepicker.type) {\n            case 'date':\n                parseFormat = this._dateFormats.parse.dateInput;\n                break;\n            case 'datetime':\n                parseFormat = this._dateFormats.parse.datetimeInput;\n                break;\n            case 'time':\n                parseFormat = this._dateFormats.parse.timeInput;\n                break;\n            case 'month':\n                parseFormat = this._dateFormats.parse.monthInput;\n                break;\n        }\n        if (!parseFormat) {\n            parseFormat = this._dateFormats.parse.dateInput;\n        }\n\n        return parseFormat;\n    }\n\n    private _cvaOnChange: (value: any) => void = () => { };\n\n    private _validatorOnChange = () => { };\n\n    /** The form control validator for whether the input parses. */\n    private _parseValidator: ValidatorFn = (): ValidationErrors | null => {\n        return this._lastValueValid\n            ? null\n            : { matDatepickerParse: { text: this._elementRef.nativeElement.value } };\n    };\n\n    /** The form control validator for the min date. */\n    private _minValidator: ValidatorFn = (control: AbstractControl): ValidationErrors | null => {\n        const controlValue = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(control.value));\n        return !this.min ||\n            !controlValue ||\n            this._dateAdapter.compareDatetime(this.min, controlValue) <= 0 ? null : { matDatepickerMin: { min: this.min, actual: controlValue } };\n    };\n\n    /** The form control validator for the max date. */\n    private _maxValidator: ValidatorFn = (control: AbstractControl): ValidationErrors | null => {\n        const controlValue = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(control.value));\n        return !this.max ||\n            !controlValue ||\n            this._dateAdapter.compareDatetime(this.max, controlValue) >= 0 ? null : { matDatepickerMax: { max: this.max, actual: controlValue } };\n    };\n\n    /** The form control validator for the date filter. */\n    private _filterValidator: ValidatorFn = (control: AbstractControl): ValidationErrors | null => {\n        const controlValue = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(control.value));\n        return !this._dateFilter ||\n            !controlValue ||\n            this._dateFilter(controlValue, GIPIDatetimepickerFilterType.DATE)\n            ? null\n            : { matDatepickerFilter: true };\n    };\n\n    /** The combined form control validator for this input. */\n    private _validator: ValidatorFn | null = Validators.compose([\n        this._parseValidator,\n        this._minValidator,\n        this._maxValidator,\n        this._filterValidator,\n    ]);\n\n    /** Formats a value and sets it on the input element. */\n    private _formatValue(value: D | null) {\n        this._elementRef.nativeElement.value = value\n            ? this._dateAdapter.format(value, this.getDisplayFormat())\n            : '';\n    }\n}\n"]}

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

@@ -0,0 +1,83 @@
+import { __decorate, __metadata } from "tslib";
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { AfterContentInit, ChangeDetectionStrategy, ChangeDetectorRef, Component, Input, OnChanges, OnDestroy, SimpleChanges, ViewEncapsulation, } from '@angular/core';
+import { MatDatepickerIntl } from '@angular/material/datepicker';
+import { asyncScheduler, merge, of, Subscription } from 'rxjs';
+import { GIPIDatetimepickerComponent } from './datetimepicker';
+let GIPIDatetimepickerToggleComponent = class GIPIDatetimepickerToggleComponent {
+    constructor(_intl, _changeDetectorRef) {
+        this._intl = _intl;
+        this._changeDetectorRef = _changeDetectorRef;
+        this._stateChanges = Subscription.EMPTY;
+    }
+    /** Whether the toggle button is disabled. */
+    get disabled() {
+        return this._disabled === undefined
+            ? this.datetimepicker.disabled
+            : !!this._disabled;
+    }
+    set disabled(value) {
+        this._disabled = coerceBooleanProperty(value);
+    }
+    ngOnChanges(changes) {
+        if (changes.datepicker) {
+            this._watchStateChanges();
+        }
+    }
+    ngOnDestroy() {
+        this._stateChanges.unsubscribe();
+    }
+    ngAfterContentInit() {
+        this._watchStateChanges();
+    }
+    _open(event) {
+        if (this.datetimepicker && !this.disabled) {
+            this.datetimepicker.open();
+            event.stopPropagation();
+        }
+    }
+    _watchStateChanges() {
+        const datepickerDisabled = this.datetimepicker
+            ? this.datetimepicker._disabledChange
+            : of([], asyncScheduler);
+        const inputDisabled = this.datetimepicker && this.datetimepicker._datepickerInput
+            ? this.datetimepicker._datepickerInput._disabledChange
+            : of([], asyncScheduler);
+        this._stateChanges.unsubscribe();
+        this._stateChanges = merge(this._intl.changes, datepickerDisabled, inputDisabled).subscribe(() => this._changeDetectorRef.markForCheck());
+    }
+};
+GIPIDatetimepickerToggleComponent.ctorParameters = () => [
+    { type: MatDatepickerIntl },
+    { type: ChangeDetectorRef }
+];
+__decorate([
+    Input('for'),
+    __metadata("design:type", GIPIDatetimepickerComponent)
+], GIPIDatetimepickerToggleComponent.prototype, "datetimepicker", void 0);
+__decorate([
+    Input(),
+    __metadata("design:type", Boolean),
+    __metadata("design:paramtypes", [Boolean])
+], GIPIDatetimepickerToggleComponent.prototype, "disabled", null);
+GIPIDatetimepickerToggleComponent = __decorate([
+    Component({
+        selector: 'gipi-mat-datetime-picker-toggle',
+        exportAs: 'gipiDatetimePickerToggle',
+        template: "<button [attr.aria-label]=\"_intl.openCalendarLabel\"\n        [disabled]=\"disabled\"\n        mat-icon-button\n        type=\"button\">\n    <mat-icon [ngSwitch]=\"datetimepicker.type\">\n        <svg *ngSwitchCase=\"'time'\"\n             fill=\"currentColor\"\n             focusable=\"false\"\n             height=\"100%\"\n             style=\"vertical-align: top\"\n             viewBox=\"0 0 24 24\"\n             width=\"100%\">\n            <path\n                  d=\"M12,20A8,8 0 0,0 20,12A8,8 0 0,0 12,4A8,8 0 0,0 4,12A8,8 0 0,0 12,20M12,2A10,10 0 0,1 22,12A10,10 0 0,1 12,22C6.47,22 2,17.5 2,12A10,10 0 0,1 12,2M12.5,7V12.25L17,14.92L16.25,16.15L11,13V7H12.5Z\">\n            </path>\n        </svg>\n        <svg *ngSwitchCase=\"'datetime'\"\n             fill=\"currentColor\"\n             focusable=\"false\"\n             height=\"100%\"\n             style=\"vertical-align: top\"\n             viewBox=\"0 0 24 24\"\n             width=\"100%\">\n            <path\n                  d=\"M15,13H16.5V15.82L18.94,17.23L18.19,18.53L15,16.69V13M19,8H5V19H9.67C9.24,18.09 9,17.07 9,16A7,7 0 0,1 16,9C17.07,9 18.09,9.24 19,9.67V8M5,21C3.89,21 3,20.1 3,19V5C3,3.89 3.89,3 5,3H6V1H8V3H16V1H18V3H19A2,2 0 0,1 21,5V11.1C22.24,12.36 23,14.09 23,16A7,7 0 0,1 16,23C14.09,23 12.36,22.24 11.1,21H5M16,11.15A4.85,4.85 0 0,0 11.15,16C11.15,18.68 13.32,20.85 16,20.85A4.85,4.85 0 0,0 20.85,16C20.85,13.32 18.68,11.15 16,11.15Z\">\n            </path>\n        </svg>\n        <svg *ngSwitchDefault\n             fill=\"currentColor\"\n             focusable=\"false\"\n             height=\"100%\"\n             style=\"vertical-align: top\"\n             viewBox=\"0 0 24 24\"\n             width=\"100%\">\n            <path d=\"M0 0h24v24H0z\"\n                  fill=\"none\" />\n            <path\n                  d=\"M19 3h-1V1h-2v2H8V1H6v2H5c-1.11 0-1.99.9-1.99 2L3 19c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16H5V8h14v11zM7 10h5v5H7z\" />\n        </svg>\n    </mat-icon>\n</button>",
+        encapsulation: ViewEncapsulation.None,
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        preserveWhitespaces: false,
+        host: {
+            class: 'gipi-mat-datetime-picker-toggle',
+            // Bind the `click` on the host, rather than the inner `button`, so that we can call `stopPropagation`
+            // on it without affecting the user's `click` handlers. We need to stop it so that the input doesn't
+            // get focused automatically by the form field (See https://github.com/angular/components/pull/21856).
+            '(click)': '_open($event)',
+        }
+    }),
+    __metadata("design:paramtypes", [MatDatepickerIntl,
+        ChangeDetectorRef])
+], GIPIDatetimepickerToggleComponent);
+export { GIPIDatetimepickerToggleComponent };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0ZXRpbWVwaWNrZXItdG9nZ2xlLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQGdpcGlzaXN0ZW1hcy9uZy1jb3JlLyIsInNvdXJjZXMiOlsic2hhcmVkL2dpcGktY29tcG9uZW50cy9kYXRldGltZS1waWNrZXIvbWF0LWRhdGV0aW1lLXBpY2tlci9kYXRldGltZXBpY2tlci10b2dnbGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBQzlELE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSx1QkFBdUIsRUFBRSxpQkFBaUIsRUFBRSxTQUFTLEVBQUUsS0FBSyxFQUFFLFNBQVMsRUFBRSxTQUFTLEVBQUUsYUFBYSxFQUFFLGlCQUFpQixHQUFHLE1BQU0sZUFBZSxDQUFDO0FBQ3hLLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLDhCQUE4QixDQUFDO0FBQ2pFLE9BQU8sRUFBRSxjQUFjLEVBQUUsS0FBSyxFQUFFLEVBQUUsRUFBRSxZQUFZLEVBQUUsTUFBTSxNQUFNLENBQUM7QUFFL0QsT0FBTyxFQUFFLDJCQUEyQixFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFpQi9ELElBQWEsaUNBQWlDLEdBQTlDLE1BQWEsaUNBQWlDO0lBbUIxQyxZQUNXLEtBQXdCLEVBQ3ZCLGtCQUFxQztRQUR0QyxVQUFLLEdBQUwsS0FBSyxDQUFtQjtRQUN2Qix1QkFBa0IsR0FBbEIsa0JBQWtCLENBQW1CO1FBakJ6QyxrQkFBYSxHQUFHLFlBQVksQ0FBQyxLQUFLLENBQUM7SUFrQnZDLENBQUM7SUFiTCw2Q0FBNkM7SUFDcEMsSUFBSSxRQUFRO1FBQ2pCLE9BQU8sSUFBSSxDQUFDLFNBQVMsS0FBSyxTQUFTO1lBQy9CLENBQUMsQ0FBQyxJQUFJLENBQUMsY0FBYyxDQUFDLFFBQVE7WUFDOUIsQ0FBQyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDO0lBQzNCLENBQUM7SUFDRCxJQUFJLFFBQVEsQ0FBQyxLQUFjO1FBQ3ZCLElBQUksQ0FBQyxTQUFTLEdBQUcscUJBQXFCLENBQUMsS0FBSyxDQUFDLENBQUM7SUFDbEQsQ0FBQztJQU9ELFdBQVcsQ0FBQyxPQUFzQjtRQUM5QixJQUFJLE9BQU8sQ0FBQyxVQUFVLEVBQUU7WUFDcEIsSUFBSSxDQUFDLGtCQUFrQixFQUFFLENBQUM7U0FDN0I7SUFDTCxDQUFDO0lBRUQsV0FBVztRQUNQLElBQUksQ0FBQyxhQUFhLENBQUMsV0FBVyxFQUFFLENBQUM7SUFDckMsQ0FBQztJQUVELGtCQUFrQjtRQUNkLElBQUksQ0FBQyxrQkFBa0IsRUFBRSxDQUFDO0lBQzlCLENBQUM7SUFFRCxLQUFLLENBQUMsS0FBWTtRQUNkLElBQUksSUFBSSxDQUFDLGNBQWMsSUFBSSxDQUFDLElBQUksQ0FBQyxRQUFRLEVBQUU7WUFDdkMsSUFBSSxDQUFDLGNBQWMsQ0FBQyxJQUFJLEVBQUUsQ0FBQztZQUMzQixLQUFLLENBQUMsZUFBZSxFQUFFLENBQUM7U0FDM0I7SUFDTCxDQUFDO0lBRU8sa0JBQWtCO1FBQ3RCLE1BQU0sa0JBQWtCLEdBQUcsSUFBSSxDQUFDLGNBQWM7WUFDMUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxjQUFjLENBQUMsZUFBZTtZQUNyQyxDQUFDLENBQUMsRUFBRSxDQUFDLEVBQUUsRUFBRSxjQUFjLENBQUMsQ0FBQztRQUM3QixNQUFNLGFBQWEsR0FBRyxJQUFJLENBQUMsY0FBYyxJQUFJLElBQUksQ0FBQyxjQUFjLENBQUMsZ0JBQWdCO1lBQzdFLENBQUMsQ0FBQyxJQUFJLENBQUMsY0FBYyxDQUFDLGdCQUFnQixDQUFDLGVBQWU7WUFDdEQsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxFQUFFLEVBQUUsY0FBYyxDQUFDLENBQUM7UUFFN0IsSUFBSSxDQUFDLGFBQWEsQ0FBQyxXQUFXLEVBQUUsQ0FBQztRQUNqQyxJQUFJLENBQUMsYUFBYSxHQUFHLEtBQUssQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxhQUFhLENBQUMsQ0FBQyxTQUFTLENBQUMsR0FBRyxFQUFFLENBQUMsSUFBSSxDQUFDLGtCQUFrQixDQUFDLFlBQVksRUFBRSxDQUFDLENBQUM7SUFDOUksQ0FBQztDQUVKLENBQUE7O1lBckNxQixpQkFBaUI7WUFDSCxpQkFBaUI7O0FBZG5DO0lBQWIsS0FBSyxDQUFDLEtBQUssQ0FBQzs4QkFBaUIsMkJBQTJCO3lFQUFJO0FBR3BEO0lBQVIsS0FBSyxFQUFFOzs7aUVBSVA7QUFkUSxpQ0FBaUM7SUFmN0MsU0FBUyxDQUFDO1FBQ1AsUUFBUSxFQUFFLGlDQUFpQztRQUMzQyxRQUFRLEVBQUUsMEJBQTBCO1FBQ3BDLHUrREFBeUM7UUFDekMsYUFBYSxFQUFFLGlCQUFpQixDQUFDLElBQUk7UUFDckMsZUFBZSxFQUFFLHVCQUF1QixDQUFDLE1BQU07UUFDL0MsbUJBQW1CLEVBQUUsS0FBSztRQUMxQixJQUFJLEVBQUU7WUFDRixLQUFLLEVBQUUsaUNBQWlDO1lBQ3hDLHNHQUFzRztZQUN0RyxvR0FBb0c7WUFDcEcsc0dBQXNHO1lBQ3RHLFNBQVMsRUFBRSxlQUFlO1NBQzdCO0tBQ0osQ0FBQztxQ0FxQm9CLGlCQUFpQjtRQUNILGlCQUFpQjtHQXJCeEMsaUNBQWlDLENBeUQ3QztTQXpEWSxpQ0FBaUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBjb2VyY2VCb29sZWFuUHJvcGVydHkgfSBmcm9tICdAYW5ndWxhci9jZGsvY29lcmNpb24nO1xuaW1wb3J0IHsgQWZ0ZXJDb250ZW50SW5pdCwgQ2hhbmdlRGV0ZWN0aW9uU3RyYXRlZ3ksIENoYW5nZURldGVjdG9yUmVmLCBDb21wb25lbnQsIElucHV0LCBPbkNoYW5nZXMsIE9uRGVzdHJveSwgU2ltcGxlQ2hhbmdlcywgVmlld0VuY2Fwc3VsYXRpb24sIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBNYXREYXRlcGlja2VySW50bCB9IGZyb20gJ0Bhbmd1bGFyL21hdGVyaWFsL2RhdGVwaWNrZXInO1xuaW1wb3J0IHsgYXN5bmNTY2hlZHVsZXIsIG1lcmdlLCBvZiwgU3Vic2NyaXB0aW9uIH0gZnJvbSAncnhqcyc7XG5cbmltcG9ydCB7IEdJUElEYXRldGltZXBpY2tlckNvbXBvbmVudCB9IGZyb20gJy4vZGF0ZXRpbWVwaWNrZXInO1xuXG5AQ29tcG9uZW50KHtcbiAgICBzZWxlY3RvcjogJ2dpcGktbWF0LWRhdGV0aW1lLXBpY2tlci10b2dnbGUnLFxuICAgIGV4cG9ydEFzOiAnZ2lwaURhdGV0aW1lUGlja2VyVG9nZ2xlJyxcbiAgICB0ZW1wbGF0ZVVybDogJ2RhdGV0aW1lcGlja2VyLXRvZ2dsZS5odG1sJyxcbiAgICBlbmNhcHN1bGF0aW9uOiBWaWV3RW5jYXBzdWxhdGlvbi5Ob25lLFxuICAgIGNoYW5nZURldGVjdGlvbjogQ2hhbmdlRGV0ZWN0aW9uU3RyYXRlZ3kuT25QdXNoLFxuICAgIHByZXNlcnZlV2hpdGVzcGFjZXM6IGZhbHNlLFxuICAgIGhvc3Q6IHtcbiAgICAgICAgY2xhc3M6ICdnaXBpLW1hdC1kYXRldGltZS1waWNrZXItdG9nZ2xlJyxcbiAgICAgICAgLy8gQmluZCB0aGUgYGNsaWNrYCBvbiB0aGUgaG9zdCwgcmF0aGVyIHRoYW4gdGhlIGlubmVyIGBidXR0b25gLCBzbyB0aGF0IHdlIGNhbiBjYWxsIGBzdG9wUHJvcGFnYXRpb25gXG4gICAgICAgIC8vIG9uIGl0IHdpdGhvdXQgYWZmZWN0aW5nIHRoZSB1c2VyJ3MgYGNsaWNrYCBoYW5kbGVycy4gV2UgbmVlZCB0byBzdG9wIGl0IHNvIHRoYXQgdGhlIGlucHV0IGRvZXNuJ3RcbiAgICAgICAgLy8gZ2V0IGZvY3VzZWQgYXV0b21hdGljYWxseSBieSB0aGUgZm9ybSBmaWVsZCAoU2VlIGh0dHBzOi8vZ2l0aHViLmNvbS9hbmd1bGFyL2NvbXBvbmVudHMvcHVsbC8yMTg1NikuXG4gICAgICAgICcoY2xpY2spJzogJ19vcGVuKCRldmVudCknLFxuICAgIH0sXG59KVxuZXhwb3J0IGNsYXNzIEdJUElEYXRldGltZXBpY2tlclRvZ2dsZUNvbXBvbmVudDxEPiBpbXBsZW1lbnRzIEFmdGVyQ29udGVudEluaXQsIE9uQ2hhbmdlcywgT25EZXN0cm95IHtcblxuICAgIHByaXZhdGUgX2Rpc2FibGVkOiBib29sZWFuO1xuXG4gICAgcHJpdmF0ZSBfc3RhdGVDaGFuZ2VzID0gU3Vic2NyaXB0aW9uLkVNUFRZO1xuXG4gICAgLyoqIERhdGVwaWNrZXIgaW5zdGFuY2UgdGhhdCB0aGUgYnV0dG9uIHdpbGwgdG9nZ2xlLiAqL1xuICAgIEBJbnB1dCgnZm9yJykgZGF0ZXRpbWVwaWNrZXI6IEdJUElEYXRldGltZXBpY2tlckNvbXBvbmVudDxEPjtcblxuICAgIC8qKiBXaGV0aGVyIHRoZSB0b2dnbGUgYnV0dG9uIGlzIGRpc2FibGVkLiAqL1xuICAgIEBJbnB1dCgpIGdldCBkaXNhYmxlZCgpOiBib29sZWFuIHtcbiAgICAgICAgcmV0dXJuIHRoaXMuX2Rpc2FibGVkID09PSB1bmRlZmluZWRcbiAgICAgICAgICAgID8gdGhpcy5kYXRldGltZXBpY2tlci5kaXNhYmxlZFxuICAgICAgICAgICAgOiAhIXRoaXMuX2Rpc2FibGVkO1xuICAgIH1cbiAgICBzZXQgZGlzYWJsZWQodmFsdWU6IGJvb2xlYW4pIHtcbiAgICAgICAgdGhpcy5fZGlzYWJsZWQgPSBjb2VyY2VCb29sZWFuUHJvcGVydHkodmFsdWUpO1xuICAgIH1cblxuICAgIGNvbnN0cnVjdG9yKFxuICAgICAgICBwdWJsaWMgX2ludGw6IE1hdERhdGVwaWNrZXJJbnRsLFxuICAgICAgICBwcml2YXRlIF9jaGFuZ2VEZXRlY3RvclJlZjogQ2hhbmdlRGV0ZWN0b3JSZWZcbiAgICApIHsgfVxuXG4gICAgbmdPbkNoYW5nZXMoY2hhbmdlczogU2ltcGxlQ2hhbmdlcykge1xuICAgICAgICBpZiAoY2hhbmdlcy5kYXRlcGlja2VyKSB7XG4gICAgICAgICAgICB0aGlzLl93YXRjaFN0YXRlQ2hhbmdlcygpO1xuICAgICAgICB9XG4gICAgfVxuXG4gICAgbmdPbkRlc3Ryb3koKSB7XG4gICAgICAgIHRoaXMuX3N0YXRlQ2hhbmdlcy51bnN1YnNjcmliZSgpO1xuICAgIH1cblxuICAgIG5nQWZ0ZXJDb250ZW50SW5pdCgpIHtcbiAgICAgICAgdGhpcy5fd2F0Y2hTdGF0ZUNoYW5nZXMoKTtcbiAgICB9XG5cbiAgICBfb3BlbihldmVudDogRXZlbnQpOiB2b2lkIHtcbiAgICAgICAgaWYgKHRoaXMuZGF0ZXRpbWVwaWNrZXIgJiYgIXRoaXMuZGlzYWJsZWQpIHtcbiAgICAgICAgICAgIHRoaXMuZGF0ZXRpbWVwaWNrZXIub3BlbigpO1xuICAgICAgICAgICAgZXZlbnQuc3RvcFByb3BhZ2F0aW9uKCk7XG4gICAgICAgIH1cbiAgICB9XG5cbiAgICBwcml2YXRlIF93YXRjaFN0YXRlQ2hhbmdlcygpIHtcbiAgICAgICAgY29uc3QgZGF0ZXBpY2tlckRpc2FibGVkID0gdGhpcy5kYXRldGltZXBpY2tlclxuICAgICAgICAgICAgPyB0aGlzLmRhdGV0aW1lcGlja2VyLl9kaXNhYmxlZENoYW5nZVxuICAgICAgICAgICAgOiBvZihbXSwgYXN5bmNTY2hlZHVsZXIpO1xuICAgICAgICBjb25zdCBpbnB1dERpc2FibGVkID0gdGhpcy5kYXRldGltZXBpY2tlciAmJiB0aGlzLmRhdGV0aW1lcGlja2VyLl9kYXRlcGlja2VySW5wdXRcbiAgICAgICAgICAgID8gdGhpcy5kYXRldGltZXBpY2tlci5fZGF0ZXBpY2tlcklucHV0Ll9kaXNhYmxlZENoYW5nZVxuICAgICAgICAgICAgOiBvZihbXSwgYXN5bmNTY2hlZHVsZXIpO1xuXG4gICAgICAgIHRoaXMuX3N0YXRlQ2hhbmdlcy51bnN1YnNjcmliZSgpO1xuICAgICAgICB0aGlzLl9zdGF0ZUNoYW5nZXMgPSBtZXJnZSh0aGlzLl9pbnRsLmNoYW5nZXMsIGRhdGVwaWNrZXJEaXNhYmxlZCwgaW5wdXREaXNhYmxlZCkuc3Vic2NyaWJlKCgpID0+IHRoaXMuX2NoYW5nZURldGVjdG9yUmVmLm1hcmtGb3JDaGVjaygpKTtcbiAgICB9XG5cbn1cbiJdfQ==

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

@@ -0,0 +1 @@
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0ZXRpbWVwaWNrZXItdHlwZS5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BnaXBpc2lzdGVtYXMvbmctY29yZS8iLCJzb3VyY2VzIjpbInNoYXJlZC9naXBpLWNvbXBvbmVudHMvZGF0ZXRpbWUtcGlja2VyL21hdC1kYXRldGltZS1waWNrZXIvZGF0ZXRpbWVwaWNrZXItdHlwZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHR5cGUgR0lQSURhdGV0aW1lcGlja2VyVHlwZSA9IChcbiAgICB8ICdkYXRlJ1xuICAgIHwgJ3RpbWUnXG4gICAgfCAnbW9udGgnXG4gICAgfCAneWVhcidcbiAgICB8ICdkYXRldGltZSdcbik7XG4iXX0=