@gipisistemas/ng-core 1.1.11 → 1.1.13

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

@@ -0,0 +1,377 @@
+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 var GIPI_DATETIMEPICKER_VALUE_ACCESSOR = {
+    provide: NG_VALUE_ACCESSOR,
+    useExisting: forwardRef(function () { return GIPIDatetimepickerInputDirective; }),
+    multi: true,
+};
+export var GIPI_DATETIMEPICKER_VALIDATORS = {
+    provide: NG_VALIDATORS,
+    useExisting: forwardRef(function () { return 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.
+ */
+var GIPIDatetimepickerInputEvent = /** @class */ (function () {
+    function GIPIDatetimepickerInputEvent(target, targetElement) {
+        this.target = target;
+        this.targetElement = targetElement;
+        this.value = this.target.value;
+    }
+    return GIPIDatetimepickerInputEvent;
+}());
+export { GIPIDatetimepickerInputEvent };
+/** Directive used to connect an input to a MatDatepicker. */
+var GIPIDatetimepickerInputDirective = /** @class */ (function () {
+    function GIPIDatetimepickerInputDirective(_elementRef, _dateAdapter, _dateFormats, _formField) {
+        var _this = this;
+        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 = function () { };
+        this._cvaOnChange = function () { };
+        this._validatorOnChange = function () { };
+        /** The form control validator for whether the input parses. */
+        this._parseValidator = function () {
+            return _this._lastValueValid
+                ? null
+                : { matDatepickerParse: { text: _this._elementRef.nativeElement.value } };
+        };
+        /** The form control validator for the min date. */
+        this._minValidator = function (control) {
+            var 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 = function (control) {
+            var 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 = function (control) {
+            var 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(function () { return _this.value = _this.value; });
+    }
+    GIPIDatetimepickerInputDirective_1 = GIPIDatetimepickerInputDirective;
+    Object.defineProperty(GIPIDatetimepickerInputDirective.prototype, "gipiMatDatetimePicker", {
+        /** The datepicker that this input is associated with. */
+        set: function (value) {
+            this.registerDatepicker(value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GIPIDatetimepickerInputDirective.prototype, "matDatepickerFilter", {
+        set: function (filter) {
+            this._dateFilter = filter;
+            this._validatorOnChange();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GIPIDatetimepickerInputDirective.prototype, "value", {
+        get: function () {
+            return this._value;
+        },
+        set: function (value) {
+            var _this = this;
+            value = this._dateAdapter.deserialize(value);
+            this._lastValueValid = !value || this._dateAdapter.isValid(value);
+            value = this._dateAdapter.getValidDateOrNull(value);
+            var oldDate = this.value;
+            this._value = value;
+            this._formatValue(value);
+            // use timeout to ensure the datetimepicker is instantiated and we get the correct format
+            setTimeout(function () {
+                if (!_this._dateAdapter.sameDatetime(oldDate, value)) {
+                    _this._valueChange.emit(value);
+                }
+            });
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GIPIDatetimepickerInputDirective.prototype, "min", {
+        get: function () {
+            return this._min;
+        },
+        set: function (value) {
+            this._min = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));
+            this._validatorOnChange();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GIPIDatetimepickerInputDirective.prototype, "max", {
+        get: function () {
+            return this._max;
+        },
+        set: function (value) {
+            this._max = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));
+            this._validatorOnChange();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GIPIDatetimepickerInputDirective.prototype, "disabled", {
+        get: function () {
+            return !!this._disabled;
+        },
+        set: function (value) {
+            var newValue = coerceBooleanProperty(value);
+            if (this._disabled !== newValue) {
+                this._disabled = newValue;
+                this._disabledChange.emit(newValue);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    GIPIDatetimepickerInputDirective.prototype.ngAfterContentInit = function () {
+        var _this = this;
+        if (this._datepicker) {
+            this._datepickerSubscription = this._datepicker.selectedChanged.subscribe(function (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));
+            });
+        }
+    };
+    GIPIDatetimepickerInputDirective.prototype.ngOnDestroy = function () {
+        this._datepickerSubscription.unsubscribe();
+        this._localeSubscription.unsubscribe();
+        this._valueChange.complete();
+        this._disabledChange.complete();
+    };
+    GIPIDatetimepickerInputDirective.prototype.registerOnValidatorChange = function (fn) {
+        this._validatorOnChange = fn;
+    };
+    GIPIDatetimepickerInputDirective.prototype.validate = function (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.
+     */
+    GIPIDatetimepickerInputDirective.prototype.getConnectedOverlayOrigin = function () {
+        return this._formField
+            ? this._formField.getConnectedOverlayOrigin()
+            : this._elementRef;
+    };
+    // Implemented as part of ControlValueAccessor
+    GIPIDatetimepickerInputDirective.prototype.writeValue = function (value) {
+        this.value = value;
+    };
+    // Implemented as part of ControlValueAccessor
+    GIPIDatetimepickerInputDirective.prototype.registerOnChange = function (fn) {
+        this._cvaOnChange = fn;
+    };
+    // Implemented as part of ControlValueAccessor
+    GIPIDatetimepickerInputDirective.prototype.registerOnTouched = function (fn) {
+        this._onTouched = fn;
+    };
+    // Implemented as part of ControlValueAccessor
+    GIPIDatetimepickerInputDirective.prototype.setDisabledState = function (disabled) {
+        this.disabled = disabled;
+    };
+    GIPIDatetimepickerInputDirective.prototype._onKeydown = function (event) {
+        if (event.altKey && event.keyCode === DOWN_ARROW) {
+            this._datepicker.open();
+            event.preventDefault();
+        }
+    };
+    GIPIDatetimepickerInputDirective.prototype._onInput = function (value) {
+        var 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));
+    };
+    GIPIDatetimepickerInputDirective.prototype._onChange = function () {
+        this.dateChange.emit(new GIPIDatetimepickerInputEvent(this, this._elementRef.nativeElement));
+    };
+    /** Handles blur events on the input. */
+    GIPIDatetimepickerInputDirective.prototype._onBlur = function () {
+        // Reformat the input only if we have a valid value.
+        if (this.value) {
+            this._formatValue(this.value);
+        }
+        this._onTouched();
+    };
+    GIPIDatetimepickerInputDirective.prototype.registerDatepicker = function (value) {
+        if (value) {
+            this._datepicker = value;
+            this._datepicker._registerInput(this);
+        }
+    };
+    GIPIDatetimepickerInputDirective.prototype.getDisplayFormat = function () {
+        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;
+        }
+    };
+    GIPIDatetimepickerInputDirective.prototype.getParseFormat = function () {
+        var 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. */
+    GIPIDatetimepickerInputDirective.prototype._formatValue = function (value) {
+        this._elementRef.nativeElement.value = value
+            ? this._dateAdapter.format(value, this.getDisplayFormat())
+            : '';
+    };
+    var GIPIDatetimepickerInputDirective_1;
+    GIPIDatetimepickerInputDirective.ctorParameters = function () { return [
+        { 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);
+    return 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/esm5/shared/gipi-components/datetime-picker/mat-datetime-picker/datetimepicker-toggle.js

@@ -0,0 +1,89 @@
+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';
+var GIPIDatetimepickerToggleComponent = /** @class */ (function () {
+    function GIPIDatetimepickerToggleComponent(_intl, _changeDetectorRef) {
+        this._intl = _intl;
+        this._changeDetectorRef = _changeDetectorRef;
+        this._stateChanges = Subscription.EMPTY;
+    }
+    Object.defineProperty(GIPIDatetimepickerToggleComponent.prototype, "disabled", {
+        /** Whether the toggle button is disabled. */
+        get: function () {
+            return this._disabled === undefined
+                ? this.datetimepicker.disabled
+                : !!this._disabled;
+        },
+        set: function (value) {
+            this._disabled = coerceBooleanProperty(value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    GIPIDatetimepickerToggleComponent.prototype.ngOnChanges = function (changes) {
+        if (changes.datepicker) {
+            this._watchStateChanges();
+        }
+    };
+    GIPIDatetimepickerToggleComponent.prototype.ngOnDestroy = function () {
+        this._stateChanges.unsubscribe();
+    };
+    GIPIDatetimepickerToggleComponent.prototype.ngAfterContentInit = function () {
+        this._watchStateChanges();
+    };
+    GIPIDatetimepickerToggleComponent.prototype._open = function (event) {
+        if (this.datetimepicker && !this.disabled) {
+            this.datetimepicker.open();
+            event.stopPropagation();
+        }
+    };
+    GIPIDatetimepickerToggleComponent.prototype._watchStateChanges = function () {
+        var _this = this;
+        var datepickerDisabled = this.datetimepicker
+            ? this.datetimepicker._disabledChange
+            : of([], asyncScheduler);
+        var inputDisabled = this.datetimepicker && this.datetimepicker._datepickerInput
+            ? this.datetimepicker._datepickerInput._disabledChange
+            : of([], asyncScheduler);
+        this._stateChanges.unsubscribe();
+        this._stateChanges = merge(this._intl.changes, datepickerDisabled, inputDisabled).subscribe(function () { return _this._changeDetectorRef.markForCheck(); });
+    };
+    GIPIDatetimepickerToggleComponent.ctorParameters = function () { return [
+        { 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);
+    return GIPIDatetimepickerToggleComponent;
+}());
+export { GIPIDatetimepickerToggleComponent };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0ZXRpbWVwaWNrZXItdG9nZ2xlLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQGdpcGlzaXN0ZW1hcy9uZy1jb3JlLyIsInNvdXJjZXMiOlsic2hhcmVkL2dpcGktY29tcG9uZW50cy9kYXRldGltZS1waWNrZXIvbWF0LWRhdGV0aW1lLXBpY2tlci9kYXRldGltZXBpY2tlci10b2dnbGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBQzlELE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSx1QkFBdUIsRUFBRSxpQkFBaUIsRUFBRSxTQUFTLEVBQUUsS0FBSyxFQUFFLFNBQVMsRUFBRSxTQUFTLEVBQUUsYUFBYSxFQUFFLGlCQUFpQixHQUFHLE1BQU0sZUFBZSxDQUFDO0FBQ3hLLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLDhCQUE4QixDQUFDO0FBQ2pFLE9BQU8sRUFBRSxjQUFjLEVBQUUsS0FBSyxFQUFFLEVBQUUsRUFBRSxZQUFZLEVBQUUsTUFBTSxNQUFNLENBQUM7QUFFL0QsT0FBTyxFQUFFLDJCQUEyQixFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFpQi9EO0lBbUJJLDJDQUNXLEtBQXdCLEVBQ3ZCLGtCQUFxQztRQUR0QyxVQUFLLEdBQUwsS0FBSyxDQUFtQjtRQUN2Qix1QkFBa0IsR0FBbEIsa0JBQWtCLENBQW1CO1FBakJ6QyxrQkFBYSxHQUFHLFlBQVksQ0FBQyxLQUFLLENBQUM7SUFrQnZDLENBQUM7SUFaSSxzQkFBSSx1REFBUTtRQURyQiw2Q0FBNkM7YUFDcEM7WUFDTCxPQUFPLElBQUksQ0FBQyxTQUFTLEtBQUssU0FBUztnQkFDL0IsQ0FBQyxDQUFDLElBQUksQ0FBQyxjQUFjLENBQUMsUUFBUTtnQkFDOUIsQ0FBQyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDO1FBQzNCLENBQUM7YUFDRCxVQUFhLEtBQWM7WUFDdkIsSUFBSSxDQUFDLFNBQVMsR0FBRyxxQkFBcUIsQ0FBQyxLQUFLLENBQUMsQ0FBQztRQUNsRCxDQUFDOzs7T0FIQTtJQVVELHVEQUFXLEdBQVgsVUFBWSxPQUFzQjtRQUM5QixJQUFJLE9BQU8sQ0FBQyxVQUFVLEVBQUU7WUFDcEIsSUFBSSxDQUFDLGtCQUFrQixFQUFFLENBQUM7U0FDN0I7SUFDTCxDQUFDO0lBRUQsdURBQVcsR0FBWDtRQUNJLElBQUksQ0FBQyxhQUFhLENBQUMsV0FBVyxFQUFFLENBQUM7SUFDckMsQ0FBQztJQUVELDhEQUFrQixHQUFsQjtRQUNJLElBQUksQ0FBQyxrQkFBa0IsRUFBRSxDQUFDO0lBQzlCLENBQUM7SUFFRCxpREFBSyxHQUFMLFVBQU0sS0FBWTtRQUNkLElBQUksSUFBSSxDQUFDLGNBQWMsSUFBSSxDQUFDLElBQUksQ0FBQyxRQUFRLEVBQUU7WUFDdkMsSUFBSSxDQUFDLGNBQWMsQ0FBQyxJQUFJLEVBQUUsQ0FBQztZQUMzQixLQUFLLENBQUMsZUFBZSxFQUFFLENBQUM7U0FDM0I7SUFDTCxDQUFDO0lBRU8sOERBQWtCLEdBQTFCO1FBQUEsaUJBVUM7UUFURyxJQUFNLGtCQUFrQixHQUFHLElBQUksQ0FBQyxjQUFjO1lBQzFDLENBQUMsQ0FBQyxJQUFJLENBQUMsY0FBYyxDQUFDLGVBQWU7WUFDckMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxFQUFFLEVBQUUsY0FBYyxDQUFDLENBQUM7UUFDN0IsSUFBTSxhQUFhLEdBQUcsSUFBSSxDQUFDLGNBQWMsSUFBSSxJQUFJLENBQUMsY0FBYyxDQUFDLGdCQUFnQjtZQUM3RSxDQUFDLENBQUMsSUFBSSxDQUFDLGNBQWMsQ0FBQyxnQkFBZ0IsQ0FBQyxlQUFlO1lBQ3RELENBQUMsQ0FBQyxFQUFFLENBQUMsRUFBRSxFQUFFLGNBQWMsQ0FBQyxDQUFDO1FBRTdCLElBQUksQ0FBQyxhQUFhLENBQUMsV0FBVyxFQUFFLENBQUM7UUFDakMsSUFBSSxDQUFDLGFBQWEsR0FBRyxLQUFLLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsYUFBYSxDQUFDLENBQUMsU0FBUyxDQUFDLGNBQU0sT0FBQSxLQUFJLENBQUMsa0JBQWtCLENBQUMsWUFBWSxFQUFFLEVBQXRDLENBQXNDLENBQUMsQ0FBQztJQUM5SSxDQUFDOztnQkFuQ2lCLGlCQUFpQjtnQkFDSCxpQkFBaUI7O0lBZG5DO1FBQWIsS0FBSyxDQUFDLEtBQUssQ0FBQztrQ0FBaUIsMkJBQTJCOzZFQUFJO0lBR3BEO1FBQVIsS0FBSyxFQUFFOzs7cUVBSVA7SUFkUSxpQ0FBaUM7UUFmN0MsU0FBUyxDQUFDO1lBQ1AsUUFBUSxFQUFFLGlDQUFpQztZQUMzQyxRQUFRLEVBQUUsMEJBQTBCO1lBQ3BDLHUrREFBeUM7WUFDekMsYUFBYSxFQUFFLGlCQUFpQixDQUFDLElBQUk7WUFDckMsZUFBZSxFQUFFLHVCQUF1QixDQUFDLE1BQU07WUFDL0MsbUJBQW1CLEVBQUUsS0FBSztZQUMxQixJQUFJLEVBQUU7Z0JBQ0YsS0FBSyxFQUFFLGlDQUFpQztnQkFDeEMsc0dBQXNHO2dCQUN0RyxvR0FBb0c7Z0JBQ3BHLHNHQUFzRztnQkFDdEcsU0FBUyxFQUFFLGVBQWU7YUFDN0I7U0FDSixDQUFDO3lDQXFCb0IsaUJBQWlCO1lBQ0gsaUJBQWlCO09BckJ4QyxpQ0FBaUMsQ0F5RDdDO0lBQUQsd0NBQUM7Q0FBQSxBQXpERCxJQXlEQztTQXpEWSxpQ0FBaUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBjb2VyY2VCb29sZWFuUHJvcGVydHkgfSBmcm9tICdAYW5ndWxhci9jZGsvY29lcmNpb24nO1xuaW1wb3J0IHsgQWZ0ZXJDb250ZW50SW5pdCwgQ2hhbmdlRGV0ZWN0aW9uU3RyYXRlZ3ksIENoYW5nZURldGVjdG9yUmVmLCBDb21wb25lbnQsIElucHV0LCBPbkNoYW5nZXMsIE9uRGVzdHJveSwgU2ltcGxlQ2hhbmdlcywgVmlld0VuY2Fwc3VsYXRpb24sIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBNYXREYXRlcGlja2VySW50bCB9IGZyb20gJ0Bhbmd1bGFyL21hdGVyaWFsL2RhdGVwaWNrZXInO1xuaW1wb3J0IHsgYXN5bmNTY2hlZHVsZXIsIG1lcmdlLCBvZiwgU3Vic2NyaXB0aW9uIH0gZnJvbSAncnhqcyc7XG5cbmltcG9ydCB7IEdJUElEYXRldGltZXBpY2tlckNvbXBvbmVudCB9IGZyb20gJy4vZGF0ZXRpbWVwaWNrZXInO1xuXG5AQ29tcG9uZW50KHtcbiAgICBzZWxlY3RvcjogJ2dpcGktbWF0LWRhdGV0aW1lLXBpY2tlci10b2dnbGUnLFxuICAgIGV4cG9ydEFzOiAnZ2lwaURhdGV0aW1lUGlja2VyVG9nZ2xlJyxcbiAgICB0ZW1wbGF0ZVVybDogJ2RhdGV0aW1lcGlja2VyLXRvZ2dsZS5odG1sJyxcbiAgICBlbmNhcHN1bGF0aW9uOiBWaWV3RW5jYXBzdWxhdGlvbi5Ob25lLFxuICAgIGNoYW5nZURldGVjdGlvbjogQ2hhbmdlRGV0ZWN0aW9uU3RyYXRlZ3kuT25QdXNoLFxuICAgIHByZXNlcnZlV2hpdGVzcGFjZXM6IGZhbHNlLFxuICAgIGhvc3Q6IHtcbiAgICAgICAgY2xhc3M6ICdnaXBpLW1hdC1kYXRldGltZS1waWNrZXItdG9nZ2xlJyxcbiAgICAgICAgLy8gQmluZCB0aGUgYGNsaWNrYCBvbiB0aGUgaG9zdCwgcmF0aGVyIHRoYW4gdGhlIGlubmVyIGBidXR0b25gLCBzbyB0aGF0IHdlIGNhbiBjYWxsIGBzdG9wUHJvcGFnYXRpb25gXG4gICAgICAgIC8vIG9uIGl0IHdpdGhvdXQgYWZmZWN0aW5nIHRoZSB1c2VyJ3MgYGNsaWNrYCBoYW5kbGVycy4gV2UgbmVlZCB0byBzdG9wIGl0IHNvIHRoYXQgdGhlIGlucHV0IGRvZXNuJ3RcbiAgICAgICAgLy8gZ2V0IGZvY3VzZWQgYXV0b21hdGljYWxseSBieSB0aGUgZm9ybSBmaWVsZCAoU2VlIGh0dHBzOi8vZ2l0aHViLmNvbS9hbmd1bGFyL2NvbXBvbmVudHMvcHVsbC8yMTg1NikuXG4gICAgICAgICcoY2xpY2spJzogJ19vcGVuKCRldmVudCknLFxuICAgIH0sXG59KVxuZXhwb3J0IGNsYXNzIEdJUElEYXRldGltZXBpY2tlclRvZ2dsZUNvbXBvbmVudDxEPiBpbXBsZW1lbnRzIEFmdGVyQ29udGVudEluaXQsIE9uQ2hhbmdlcywgT25EZXN0cm95IHtcblxuICAgIHByaXZhdGUgX2Rpc2FibGVkOiBib29sZWFuO1xuXG4gICAgcHJpdmF0ZSBfc3RhdGVDaGFuZ2VzID0gU3Vic2NyaXB0aW9uLkVNUFRZO1xuXG4gICAgLyoqIERhdGVwaWNrZXIgaW5zdGFuY2UgdGhhdCB0aGUgYnV0dG9uIHdpbGwgdG9nZ2xlLiAqL1xuICAgIEBJbnB1dCgnZm9yJykgZGF0ZXRpbWVwaWNrZXI6IEdJUElEYXRldGltZXBpY2tlckNvbXBvbmVudDxEPjtcblxuICAgIC8qKiBXaGV0aGVyIHRoZSB0b2dnbGUgYnV0dG9uIGlzIGRpc2FibGVkLiAqL1xuICAgIEBJbnB1dCgpIGdldCBkaXNhYmxlZCgpOiBib29sZWFuIHtcbiAgICAgICAgcmV0dXJuIHRoaXMuX2Rpc2FibGVkID09PSB1bmRlZmluZWRcbiAgICAgICAgICAgID8gdGhpcy5kYXRldGltZXBpY2tlci5kaXNhYmxlZFxuICAgICAgICAgICAgOiAhIXRoaXMuX2Rpc2FibGVkO1xuICAgIH1cbiAgICBzZXQgZGlzYWJsZWQodmFsdWU6IGJvb2xlYW4pIHtcbiAgICAgICAgdGhpcy5fZGlzYWJsZWQgPSBjb2VyY2VCb29sZWFuUHJvcGVydHkodmFsdWUpO1xuICAgIH1cblxuICAgIGNvbnN0cnVjdG9yKFxuICAgICAgICBwdWJsaWMgX2ludGw6IE1hdERhdGVwaWNrZXJJbnRsLFxuICAgICAgICBwcml2YXRlIF9jaGFuZ2VEZXRlY3RvclJlZjogQ2hhbmdlRGV0ZWN0b3JSZWZcbiAgICApIHsgfVxuXG4gICAgbmdPbkNoYW5nZXMoY2hhbmdlczogU2ltcGxlQ2hhbmdlcykge1xuICAgICAgICBpZiAoY2hhbmdlcy5kYXRlcGlja2VyKSB7XG4gICAgICAgICAgICB0aGlzLl93YXRjaFN0YXRlQ2hhbmdlcygpO1xuICAgICAgICB9XG4gICAgfVxuXG4gICAgbmdPbkRlc3Ryb3koKSB7XG4gICAgICAgIHRoaXMuX3N0YXRlQ2hhbmdlcy51bnN1YnNjcmliZSgpO1xuICAgIH1cblxuICAgIG5nQWZ0ZXJDb250ZW50SW5pdCgpIHtcbiAgICAgICAgdGhpcy5fd2F0Y2hTdGF0ZUNoYW5nZXMoKTtcbiAgICB9XG5cbiAgICBfb3BlbihldmVudDogRXZlbnQpOiB2b2lkIHtcbiAgICAgICAgaWYgKHRoaXMuZGF0ZXRpbWVwaWNrZXIgJiYgIXRoaXMuZGlzYWJsZWQpIHtcbiAgICAgICAgICAgIHRoaXMuZGF0ZXRpbWVwaWNrZXIub3BlbigpO1xuICAgICAgICAgICAgZXZlbnQuc3RvcFByb3BhZ2F0aW9uKCk7XG4gICAgICAgIH1cbiAgICB9XG5cbiAgICBwcml2YXRlIF93YXRjaFN0YXRlQ2hhbmdlcygpIHtcbiAgICAgICAgY29uc3QgZGF0ZXBpY2tlckRpc2FibGVkID0gdGhpcy5kYXRldGltZXBpY2tlclxuICAgICAgICAgICAgPyB0aGlzLmRhdGV0aW1lcGlja2VyLl9kaXNhYmxlZENoYW5nZVxuICAgICAgICAgICAgOiBvZihbXSwgYXN5bmNTY2hlZHVsZXIpO1xuICAgICAgICBjb25zdCBpbnB1dERpc2FibGVkID0gdGhpcy5kYXRldGltZXBpY2tlciAmJiB0aGlzLmRhdGV0aW1lcGlja2VyLl9kYXRlcGlja2VySW5wdXRcbiAgICAgICAgICAgID8gdGhpcy5kYXRldGltZXBpY2tlci5fZGF0ZXBpY2tlcklucHV0Ll9kaXNhYmxlZENoYW5nZVxuICAgICAgICAgICAgOiBvZihbXSwgYXN5bmNTY2hlZHVsZXIpO1xuXG4gICAgICAgIHRoaXMuX3N0YXRlQ2hhbmdlcy51bnN1YnNjcmliZSgpO1xuICAgICAgICB0aGlzLl9zdGF0ZUNoYW5nZXMgPSBtZXJnZSh0aGlzLl9pbnRsLmNoYW5nZXMsIGRhdGVwaWNrZXJEaXNhYmxlZCwgaW5wdXREaXNhYmxlZCkuc3Vic2NyaWJlKCgpID0+IHRoaXMuX2NoYW5nZURldGVjdG9yUmVmLm1hcmtGb3JDaGVjaygpKTtcbiAgICB9XG5cbn1cbiJdfQ==

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

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