@gipisistemas/ng-core 1.1.0 → 1.1.2

package/esm5/shared/gipi-components/datepicker/mat-datepicker/date-range-input.js

@@ -0,0 +1,376 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { __decorate, __metadata, __param } from "tslib";
+import { AfterContentInit, ChangeDetectionStrategy, ChangeDetectorRef, Component, ContentChild, ElementRef, Inject, Input, OnChanges, OnDestroy, Optional, Self, SimpleChanges, ViewEncapsulation, } from '@angular/core';
+import { ControlContainer, NgControl } from '@angular/forms';
+import { MatFormField, MatFormFieldControl } from '@angular/material/form-field';
+import { Subject, merge } from 'rxjs';
+import { MAT_DATE_RANGE_INPUT_PARENT, MatEndDate, MatStartDate, } from './date-range-input-parts';
+import { MatDateRangePicker } from './date-range-picker';
+import { createMissingDateImplError } from './datepicker-errors';
+import { MAT_FORM_FIELD } from './datepicker-input';
+import { dateInputsHaveChanged } from './datepicker-input-base';
+import { DateAdapter } from './shared/adapter/date-adapter';
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+var nextUniqueId = 0;
+var MatDateRangeInput = /** @class */ (function () {
+    function MatDateRangeInput(_changeDetectorRef, _elementRef, control, _dateAdapter, _formField) {
+        this._changeDetectorRef = _changeDetectorRef;
+        this._elementRef = _elementRef;
+        this._dateAdapter = _dateAdapter;
+        this._formField = _formField;
+        /** Unique ID for the input. */
+        this.id = "mat-date-range-input-" + nextUniqueId++;
+        /** Whether the control is focused. */
+        this.focused = false;
+        /** Name of the form control. */
+        this.controlType = 'gipi-date-range-input';
+        this._groupDisabled = false;
+        /** Value for the `aria-describedby` attribute of the inputs. */
+        this._ariaDescribedBy = null;
+        /** Separator text to be shown between the inputs. */
+        this.separator = '–';
+        /** Start of the comparison range that should be shown in the calendar. */
+        this.comparisonStart = null;
+        /** End of the comparison range that should be shown in the calendar. */
+        this.comparisonEnd = null;
+        /** Emits when the input's state has changed. */
+        this.stateChanges = new Subject();
+        if (!_dateAdapter) {
+            throw createMissingDateImplError('DateAdapter');
+        }
+        // TODO(crisbeto): remove `as any` after #18206 lands.
+        this.ngControl = control;
+    }
+    MatDateRangeInput_1 = MatDateRangeInput;
+    Object.defineProperty(MatDateRangeInput.prototype, "value", {
+        /** Current value of the range input. */
+        get: function () {
+            return this._model ? this._model.selection : null;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(MatDateRangeInput.prototype, "shouldLabelFloat", {
+        /** Whether the control's label should float. */
+        get: function () {
+            return this.focused || !this.empty;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(MatDateRangeInput.prototype, "placeholder", {
+        /**
+         * Implemented as a part of `MatFormFieldControl`.
+         * Set the placeholder attribute on `matStartDate` and `matEndDate`.
+         * @docs-private
+         */
+        get: function () {
+            var start = this._startInput ? this._startInput._getPlaceholder() : '';
+            var end = this._endInput ? this._endInput._getPlaceholder() : '';
+            return (start || end) ? start + " " + this.separator + " " + end : '';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(MatDateRangeInput.prototype, "rangePicker", {
+        /** The range picker that this input is associated with. */
+        get: function () { return this._rangePicker; },
+        set: function (rangePicker) {
+            if (rangePicker) {
+                this._model = rangePicker._registerInput(this);
+                this._rangePicker = rangePicker;
+                this._registerModel(this._model);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(MatDateRangeInput.prototype, "required", {
+        /** Whether the input is required. */
+        get: function () { return !!this._required; },
+        set: function (value) {
+            this._required = coerceBooleanProperty(value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(MatDateRangeInput.prototype, "dateFilter", {
+        /** Function that can be used to filter out dates within the date range picker. */
+        get: function () { return this._dateFilter; },
+        set: function (value) {
+            this._dateFilter = value;
+            this._revalidate();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(MatDateRangeInput.prototype, "min", {
+        /** The minimum valid date. */
+        get: function () { return this._min; },
+        set: function (value) {
+            var validValue = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));
+            if (!this._dateAdapter.sameDate(validValue, this._min)) {
+                this._min = validValue;
+                this._revalidate();
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(MatDateRangeInput.prototype, "max", {
+        /** The maximum valid date. */
+        get: function () { return this._max; },
+        set: function (value) {
+            var validValue = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));
+            if (!this._dateAdapter.sameDate(validValue, this._max)) {
+                this._max = validValue;
+                this._revalidate();
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(MatDateRangeInput.prototype, "disabled", {
+        /** Whether the input is disabled. */
+        get: function () {
+            return (this._startInput && this._endInput) ?
+                (this._startInput.disabled && this._endInput.disabled) :
+                this._groupDisabled;
+        },
+        set: function (value) {
+            var newValue = coerceBooleanProperty(value);
+            if (newValue !== this._groupDisabled) {
+                this._groupDisabled = newValue;
+                this.stateChanges.next(undefined);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(MatDateRangeInput.prototype, "errorState", {
+        /** Whether the input is in an error state. */
+        get: function () {
+            if (this._startInput && this._endInput) {
+                return this._startInput.errorState || this._endInput.errorState;
+            }
+            return false;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(MatDateRangeInput.prototype, "empty", {
+        /** Whether the datepicker input is empty. */
+        get: function () {
+            var startEmpty = this._startInput ? this._startInput.isEmpty() : false;
+            var endEmpty = this._endInput ? this._endInput.isEmpty() : false;
+            return startEmpty && endEmpty;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Implemented as a part of `MatFormFieldControl`.
+     * @docs-private
+     */
+    MatDateRangeInput.prototype.setDescribedByIds = function (ids) {
+        this._ariaDescribedBy = ids.length ? ids.join(' ') : null;
+    };
+    /**
+     * Implemented as a part of `MatFormFieldControl`.
+     * @docs-private
+     */
+    MatDateRangeInput.prototype.onContainerClick = function () {
+        if (!this.focused && !this.disabled) {
+            if (!this._model || !this._model.selection.start) {
+                this._startInput.focus();
+            }
+            else {
+                this._endInput.focus();
+            }
+        }
+    };
+    MatDateRangeInput.prototype.ngAfterContentInit = function () {
+        var _this = this;
+        if (!this._startInput) {
+            throw Error('mat-date-range-input must contain a matStartDate input');
+        }
+        if (!this._endInput) {
+            throw Error('mat-date-range-input must contain a matEndDate input');
+        }
+        if (this._model) {
+            this._registerModel(this._model);
+        }
+        // We don't need to unsubscribe from this, because we
+        // know that the input streams will be completed on destroy.
+        merge(this._startInput.stateChanges, this._endInput.stateChanges).subscribe(function () {
+            _this.stateChanges.next(undefined);
+        });
+    };
+    MatDateRangeInput.prototype.ngOnChanges = function (changes) {
+        if (dateInputsHaveChanged(changes, this._dateAdapter)) {
+            this.stateChanges.next(undefined);
+        }
+    };
+    MatDateRangeInput.prototype.ngOnDestroy = function () {
+        this.stateChanges.complete();
+    };
+    /** Gets the date at which the calendar should start. */
+    MatDateRangeInput.prototype.getStartValue = function () {
+        return this.value ? this.value.start : null;
+    };
+    /** Gets the input's theme palette. */
+    MatDateRangeInput.prototype.getThemePalette = function () {
+        return this._formField ? this._formField.color : undefined;
+    };
+    /** Gets the element to which the calendar overlay should be attached. */
+    MatDateRangeInput.prototype.getConnectedOverlayOrigin = function () {
+        return this._formField ? this._formField.getConnectedOverlayOrigin() : this._elementRef;
+    };
+    /** Gets the value that is used to mirror the state input. */
+    MatDateRangeInput.prototype._getInputMirrorValue = function () {
+        return this._startInput ? this._startInput.getMirrorValue() : '';
+    };
+    /** Whether the input placeholders should be hidden. */
+    MatDateRangeInput.prototype._shouldHidePlaceholders = function () {
+        return this._startInput ? !this._startInput.isEmpty() : false;
+    };
+    /** Handles the value in one of the child inputs changing. */
+    MatDateRangeInput.prototype._handleChildValueChange = function () {
+        this.stateChanges.next(undefined);
+        this._changeDetectorRef.markForCheck();
+    };
+    /** Opens the date range picker associated with the input. */
+    MatDateRangeInput.prototype._openDatepicker = function () {
+        if (this._rangePicker) {
+            this._rangePicker.open();
+        }
+    };
+    /** Whether the separate text should be hidden. */
+    MatDateRangeInput.prototype._shouldHideSeparator = function () {
+        return (!this._formField || this._formField._hideControlPlaceholder()) && this.empty;
+    };
+    /** Gets the value for the `aria-labelledby` attribute of the inputs. */
+    MatDateRangeInput.prototype._getAriaLabelledby = function () {
+        var formField = this._formField;
+        return formField && formField._hasFloatingLabel() ? formField._labelId : null;
+    };
+    /** Re-runs the validators on the start/end inputs. */
+    MatDateRangeInput.prototype._revalidate = function () {
+        if (this._startInput) {
+            this._startInput._validatorOnChange();
+        }
+        if (this._endInput) {
+            this._endInput._validatorOnChange();
+        }
+    };
+    /** Registers the current date selection model with the start/end inputs. */
+    MatDateRangeInput.prototype._registerModel = function (model) {
+        if (this._startInput) {
+            this._startInput._registerModel(model);
+        }
+        if (this._endInput) {
+            this._endInput._registerModel(model);
+        }
+    };
+    var MatDateRangeInput_1;
+    MatDateRangeInput.ctorParameters = function () { return [
+        { type: ChangeDetectorRef },
+        { type: ElementRef },
+        { type: ControlContainer, decorators: [{ type: Optional }, { type: Self }] },
+        { type: DateAdapter, decorators: [{ type: Optional }] },
+        { type: MatFormField, decorators: [{ type: Optional }, { type: Inject, args: [MAT_FORM_FIELD,] }] }
+    ]; };
+    __decorate([
+        Input(),
+        __metadata("design:type", MatDateRangePicker),
+        __metadata("design:paramtypes", [MatDateRangePicker])
+    ], MatDateRangeInput.prototype, "rangePicker", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean),
+        __metadata("design:paramtypes", [Boolean])
+    ], MatDateRangeInput.prototype, "required", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Function])
+    ], MatDateRangeInput.prototype, "dateFilter", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", Object),
+        __metadata("design:paramtypes", [Object])
+    ], MatDateRangeInput.prototype, "min", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", Object),
+        __metadata("design:paramtypes", [Object])
+    ], MatDateRangeInput.prototype, "max", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean),
+        __metadata("design:paramtypes", [Boolean])
+    ], MatDateRangeInput.prototype, "disabled", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", Object)
+    ], MatDateRangeInput.prototype, "separator", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Object)
+    ], MatDateRangeInput.prototype, "comparisonStart", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Object)
+    ], MatDateRangeInput.prototype, "comparisonEnd", void 0);
+    __decorate([
+        ContentChild(MatStartDate, { static: true }),
+        __metadata("design:type", MatStartDate)
+    ], MatDateRangeInput.prototype, "_startInput", void 0);
+    __decorate([
+        ContentChild(MatEndDate, { static: true }),
+        __metadata("design:type", MatEndDate)
+    ], MatDateRangeInput.prototype, "_endInput", void 0);
+    MatDateRangeInput = MatDateRangeInput_1 = __decorate([
+        Component({
+            selector: 'gipi-mat-date-range-input',
+            template: "<div class=\"mat-date-range-input-container\"\n     cdkMonitorSubtreeFocus\n     (cdkFocusChange)=\"focused = $event !== null\">\n    <div class=\"mat-date-range-input-start-wrapper\">\n\n        <ng-content select=\"input[gipiMatStartDate]\"> </ng-content>\n\n        <span class=\"mat-date-range-input-mirror\"\n              aria-hidden=\"true\">\n            {{_getInputMirrorValue()}}\n        </span>\n    </div>\n\n    <span class=\"mat-date-range-input-separator\"\n          [class.mat-date-range-input-separator-hidden]=\"_shouldHideSeparator()\">\n        {{separator}}\n    </span>\n\n    <div class=\"mat-date-range-input-end-wrapper\">\n        <ng-content select=\"input[gipiMatEndDate]\"> </ng-content>\n    </div>\n</div>",
+            exportAs: 'gipiMatDateRangeInput',
+            host: {
+                'class': 'mat-date-range-input',
+                '[class.mat-date-range-input-hide-placeholders]': '_shouldHidePlaceholders()',
+                '[class.mat-date-range-input-required]': 'required',
+                '[attr.id]': 'null',
+                'role': 'group',
+                '[attr.aria-labelledby]': '_getAriaLabelledby()',
+                '[attr.aria-describedby]': '_ariaDescribedBy',
+                // Used by the test harness to tie this input to its calendar. We can't depend on
+                // `aria-owns` for this, because it's only defined while the calendar is open.
+                '[attr.data-mat-calendar]': 'rangePicker ? rangePicker.id : null',
+            },
+            changeDetection: ChangeDetectionStrategy.OnPush,
+            encapsulation: ViewEncapsulation.None,
+            providers: [
+                { provide: MatFormFieldControl, useExisting: MatDateRangeInput_1 },
+                { provide: MAT_DATE_RANGE_INPUT_PARENT, useExisting: MatDateRangeInput_1 },
+            ],
+            styles: [".mat-date-range-input{display:block;width:100%}.mat-date-range-input-container{display:flex;align-items:center;padding-bottom:3px}.mat-date-range-input-separator{transition:opacity .4s cubic-bezier(.25,.8,.25,1) .133s;margin:0 4px}.mat-date-range-input-separator-hidden{-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;opacity:0;transition:none}.mat-date-range-input-inner{font:inherit;background:0 0;color:currentColor;border:none;outline:0;padding:0;margin:0;vertical-align:bottom;text-align:inherit;-webkit-appearance:none;width:100%}.mat-date-range-input-inner::-ms-clear,.mat-date-range-input-inner::-ms-reveal{display:none}.mat-date-range-input-inner:-moz-ui-invalid{box-shadow:none}.mat-date-range-input-inner::-ms-input-placeholder{transition:color .4s cubic-bezier(.25,.8,.25,1) .133s}.mat-date-range-input-inner::placeholder{transition:color .4s cubic-bezier(.25,.8,.25,1) .133s}.mat-date-range-input-inner::-moz-placeholder{transition:color .4s cubic-bezier(.25,.8,.25,1) .133s}.mat-date-range-input-inner::-webkit-input-placeholder{transition:color .4s cubic-bezier(.25,.8,.25,1) .133s}.mat-date-range-input-inner:-ms-input-placeholder{transition:color .4s cubic-bezier(.25,.8,.25,1) .133s}.mat-date-range-input-hide-placeholders .mat-date-range-input-inner::-ms-input-placeholder,.mat-form-field-hide-placeholder .mat-date-range-input-inner::-ms-input-placeholder{-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;color:transparent!important;-webkit-text-fill-color:transparent;transition:none}.mat-date-range-input-hide-placeholders .mat-date-range-input-inner::placeholder,.mat-form-field-hide-placeholder .mat-date-range-input-inner::placeholder{-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;color:transparent!important;-webkit-text-fill-color:transparent;transition:none}.mat-date-range-input-hide-placeholders .mat-date-range-input-inner::-moz-placeholder,.mat-form-field-hide-placeholder .mat-date-range-input-inner::-moz-placeholder{-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;color:transparent!important;-webkit-text-fill-color:transparent;transition:none}.mat-date-range-input-hide-placeholders .mat-date-range-input-inner::-webkit-input-placeholder,.mat-form-field-hide-placeholder .mat-date-range-input-inner::-webkit-input-placeholder{-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;color:transparent!important;-webkit-text-fill-color:transparent;transition:none}.mat-date-range-input-hide-placeholders .mat-date-range-input-inner:-ms-input-placeholder,.mat-form-field-hide-placeholder .mat-date-range-input-inner:-ms-input-placeholder{-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;color:transparent!important;-webkit-text-fill-color:transparent;transition:none}.mat-date-range-input-mirror{-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;visibility:hidden;white-space:nowrap;display:inline-block;min-width:2px}.mat-date-range-input-start-wrapper{position:relative;overflow:hidden;max-width:calc(50% - 4px)}.mat-date-range-input-start-wrapper .mat-date-range-input-inner{position:absolute;top:0;left:0}.mat-date-range-input-end-wrapper{flex-grow:1;max-width:calc(50% - 4px)}.mat-form-field-type-mat-date-range-input .mat-form-field-infix{width:200px}"]
+        }),
+        __param(2, Optional()), __param(2, Self()),
+        __param(3, Optional()),
+        __param(4, Optional()), __param(4, Inject(MAT_FORM_FIELD)),
+        __metadata("design:paramtypes", [ChangeDetectorRef,
+            ElementRef,
+            ControlContainer,
+            DateAdapter,
+            MatFormField])
+    ], MatDateRangeInput);
+    return MatDateRangeInput;
+}());
+export { MatDateRangeInput };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"date-range-input.js","sourceRoot":"ng://@gipisistemas/ng-core/","sources":["shared/gipi-components/datepicker/mat-datepicker/date-range-input.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport { AfterContentInit, ChangeDetectionStrategy, ChangeDetectorRef, Component, ContentChild, ElementRef, Inject, Input, OnChanges, OnDestroy, Optional, Self, SimpleChanges, ViewEncapsulation, } from '@angular/core';\nimport { ControlContainer, NgControl } from '@angular/forms';\nimport { ThemePalette } from '@angular/material/core';\nimport { MatFormField, MatFormFieldControl } from '@angular/material/form-field';\nimport { Subject, merge } from 'rxjs';\nimport { MAT_DATE_RANGE_INPUT_PARENT, MatDateRangeInputParent, MatEndDate, MatStartDate, } from './date-range-input-parts';\nimport { MatDateRangePicker, MatDateRangePickerInput } from './date-range-picker';\nimport { DateRange, MatDateSelectionModel } from './date-selection-model';\nimport { MatDatepickerControl } from './datepicker-base';\nimport { createMissingDateImplError } from './datepicker-errors';\nimport { MAT_FORM_FIELD } from './datepicker-input';\nimport { DateFilterFn, dateInputsHaveChanged } from './datepicker-input-base';\nimport { DateAdapter } from './shared/adapter/date-adapter';\nimport { coerceBooleanProperty } from '@angular/cdk/coercion';\n\nlet nextUniqueId = 0;\n\n@Component({\n    selector: 'gipi-mat-date-range-input',\n    templateUrl: 'date-range-input.html',\n    styleUrls: ['date-range-input.scss'],\n    exportAs: 'gipiMatDateRangeInput',\n    host: {\n        'class': 'mat-date-range-input',\n        '[class.mat-date-range-input-hide-placeholders]': '_shouldHidePlaceholders()',\n        '[class.mat-date-range-input-required]': 'required',\n        '[attr.id]': 'null',\n        'role': 'group',\n        '[attr.aria-labelledby]': '_getAriaLabelledby()',\n        '[attr.aria-describedby]': '_ariaDescribedBy',\n        // Used by the test harness to tie this input to its calendar. We can't depend on\n        // `aria-owns` for this, because it's only defined while the calendar is open.\n        '[attr.data-mat-calendar]': 'rangePicker ? rangePicker.id : null',\n    },\n    changeDetection: ChangeDetectionStrategy.OnPush,\n    encapsulation: ViewEncapsulation.None,\n    providers: [\n        { provide: MatFormFieldControl, useExisting: MatDateRangeInput },\n        { provide: MAT_DATE_RANGE_INPUT_PARENT, useExisting: MatDateRangeInput },\n    ]\n})\nexport class MatDateRangeInput<D> implements MatFormFieldControl<DateRange<D>>, MatDatepickerControl<D>, MatDateRangeInputParent<D>, MatDateRangePickerInput<D>, AfterContentInit, OnChanges, OnDestroy {\n\n    /** Current value of the range input. */\n    get value() {\n        return this._model ? this._model.selection : null;\n    }\n\n    /** Unique ID for the input. */\n    id = `mat-date-range-input-${nextUniqueId++}`;\n\n    /** Whether the control is focused. */\n    focused = false;\n\n    /** Whether the control's label should float. */\n    get shouldLabelFloat(): boolean {\n        return this.focused || !this.empty;\n    }\n\n    /** Name of the form control. */\n    controlType = 'gipi-date-range-input';\n\n    /**\n     * Implemented as a part of `MatFormFieldControl`.\n     * Set the placeholder attribute on `matStartDate` and `matEndDate`.\n     * @docs-private\n     */\n    get placeholder() {\n        const start = this._startInput ? this._startInput._getPlaceholder() : '';\n        const end = this._endInput ? this._endInput._getPlaceholder() : '';\n        return (start || end) ? `${start} ${this.separator} ${end}` : '';\n    }\n\n    /** The range picker that this input is associated with. */\n    @Input()\n    get rangePicker() { return this._rangePicker; }\n    set rangePicker(rangePicker: MatDateRangePicker<D>) {\n        if (rangePicker) {\n            this._model = rangePicker._registerInput(this);\n            this._rangePicker = rangePicker;\n            this._registerModel(this._model!);\n        }\n    }\n    private _rangePicker: MatDateRangePicker<D>;\n\n    /** Whether the input is required. */\n    @Input()\n    get required(): boolean { return !!this._required; }\n    set required(value: boolean) {\n        this._required = coerceBooleanProperty(value);\n    }\n    private _required: boolean;\n\n    /** Function that can be used to filter out dates within the date range picker. */\n    @Input()\n    get dateFilter() { return this._dateFilter; }\n    set dateFilter(value: DateFilterFn<D>) {\n        this._dateFilter = value;\n        this._revalidate();\n    }\n    private _dateFilter: DateFilterFn<D>;\n\n    /** The minimum valid date. */\n    @Input()\n    get min(): D | null { return this._min; }\n    set min(value: D | null) {\n        const validValue = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));\n\n        if (!this._dateAdapter.sameDate(validValue, this._min)) {\n            this._min = validValue;\n            this._revalidate();\n        }\n    }\n    private _min: D | null;\n\n    /** The maximum valid date. */\n    @Input()\n    get max(): D | null { return this._max; }\n    set max(value: D | null) {\n        const validValue = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));\n\n        if (!this._dateAdapter.sameDate(validValue, this._max)) {\n            this._max = validValue;\n            this._revalidate();\n        }\n    }\n    private _max: D | null;\n\n    /** Whether the input is disabled. */\n    @Input()\n    get disabled(): boolean {\n        return (this._startInput && this._endInput) ?\n            (this._startInput.disabled && this._endInput.disabled) :\n            this._groupDisabled;\n    }\n    set disabled(value: boolean) {\n        const newValue = coerceBooleanProperty(value);\n\n        if (newValue !== this._groupDisabled) {\n            this._groupDisabled = newValue;\n            this.stateChanges.next(undefined);\n        }\n    }\n    _groupDisabled = false;\n\n    /** Whether the input is in an error state. */\n    get errorState(): boolean {\n        if (this._startInput && this._endInput) {\n            return this._startInput.errorState || this._endInput.errorState;\n        }\n\n        return false;\n    }\n\n    /** Whether the datepicker input is empty. */\n    get empty(): boolean {\n        const startEmpty = this._startInput ? this._startInput.isEmpty() : false;\n        const endEmpty = this._endInput ? this._endInput.isEmpty() : false;\n        return startEmpty && endEmpty;\n    }\n\n    /** Value for the `aria-describedby` attribute of the inputs. */\n    _ariaDescribedBy: string | null = null;\n\n    /** Date selection model currently registered with the input. */\n    private _model: MatDateSelectionModel<DateRange<D>> | undefined;\n\n    /** Separator text to be shown between the inputs. */\n    @Input() separator = '–';\n\n    /** Start of the comparison range that should be shown in the calendar. */\n    @Input() comparisonStart: D | null = null;\n\n    /** End of the comparison range that should be shown in the calendar. */\n    @Input() comparisonEnd: D | null = null;\n\n    @ContentChild(MatStartDate, { static: true }) _startInput: MatStartDate<D>;\n    @ContentChild(MatEndDate, { static: true }) _endInput: MatEndDate<D>;\n\n    /**\n     * Implemented as a part of `MatFormFieldControl`.\n     * TODO(crisbeto): change type to `AbstractControlDirective` after #18206 lands.\n     * @docs-private\n     */\n    ngControl: NgControl | null;\n\n    /** Emits when the input's state has changed. */\n    stateChanges = new Subject<void>();\n\n    constructor(\n        private _changeDetectorRef: ChangeDetectorRef,\n        private _elementRef: ElementRef<HTMLElement>,\n        @Optional() @Self() control: ControlContainer,\n        @Optional() private _dateAdapter: DateAdapter<D>,\n        @Optional() @Inject(MAT_FORM_FIELD) private _formField?: MatFormField\n    ) {\n\n        if (!_dateAdapter) {\n            throw createMissingDateImplError('DateAdapter');\n        }\n\n        // TODO(crisbeto): remove `as any` after #18206 lands.\n        this.ngControl = control as any;\n    }\n\n    /**\n     * Implemented as a part of `MatFormFieldControl`.\n     * @docs-private\n     */\n    setDescribedByIds(ids: string[]): void {\n        this._ariaDescribedBy = ids.length ? ids.join(' ') : null;\n    }\n\n    /**\n     * Implemented as a part of `MatFormFieldControl`.\n     * @docs-private\n     */\n    onContainerClick(): void {\n        if (!this.focused && !this.disabled) {\n            if (!this._model || !this._model.selection.start) {\n                this._startInput.focus();\n            } else {\n                this._endInput.focus();\n            }\n        }\n    }\n\n    ngAfterContentInit() {\n        if (!this._startInput) {\n            throw Error('mat-date-range-input must contain a matStartDate input');\n        }\n\n        if (!this._endInput) {\n            throw Error('mat-date-range-input must contain a matEndDate input');\n        }\n\n        if (this._model) {\n            this._registerModel(this._model);\n        }\n\n        // We don't need to unsubscribe from this, because we\n        // know that the input streams will be completed on destroy.\n        merge(this._startInput.stateChanges, this._endInput.stateChanges).subscribe(() => {\n            this.stateChanges.next(undefined);\n        });\n    }\n\n    ngOnChanges(changes: SimpleChanges) {\n        if (dateInputsHaveChanged(changes, this._dateAdapter)) {\n            this.stateChanges.next(undefined);\n        }\n    }\n\n    ngOnDestroy() {\n        this.stateChanges.complete();\n    }\n\n    /** Gets the date at which the calendar should start. */\n    getStartValue(): D | null {\n        return this.value ? this.value.start : null;\n    }\n\n    /** Gets the input's theme palette. */\n    getThemePalette(): ThemePalette {\n        return this._formField ? this._formField.color : undefined;\n    }\n\n    /** Gets the element to which the calendar overlay should be attached. */\n    getConnectedOverlayOrigin(): ElementRef {\n        return this._formField ? this._formField.getConnectedOverlayOrigin() : this._elementRef;\n    }\n\n    /** Gets the value that is used to mirror the state input. */\n    _getInputMirrorValue() {\n        return this._startInput ? this._startInput.getMirrorValue() : '';\n    }\n\n    /** Whether the input placeholders should be hidden. */\n    _shouldHidePlaceholders() {\n        return this._startInput ? !this._startInput.isEmpty() : false;\n    }\n\n    /** Handles the value in one of the child inputs changing. */\n    _handleChildValueChange() {\n        this.stateChanges.next(undefined);\n        this._changeDetectorRef.markForCheck();\n    }\n\n    /** Opens the date range picker associated with the input. */\n    _openDatepicker() {\n        if (this._rangePicker) {\n            this._rangePicker.open();\n        }\n    }\n\n    /** Whether the separate text should be hidden. */\n    _shouldHideSeparator() {\n        return (!this._formField || this._formField._hideControlPlaceholder()) && this.empty;\n    }\n\n    /** Gets the value for the `aria-labelledby` attribute of the inputs. */\n    _getAriaLabelledby() {\n        const formField = this._formField;\n        return formField && formField._hasFloatingLabel() ? formField._labelId : null;\n    }\n\n    /** Re-runs the validators on the start/end inputs. */\n    private _revalidate() {\n        if (this._startInput) {\n            this._startInput._validatorOnChange();\n        }\n\n        if (this._endInput) {\n            this._endInput._validatorOnChange();\n        }\n    }\n\n    /** Registers the current date selection model with the start/end inputs. */\n    private _registerModel(model: MatDateSelectionModel<DateRange<D>>) {\n        if (this._startInput) {\n            this._startInput._registerModel(model);\n        }\n\n        if (this._endInput) {\n            this._endInput._registerModel(model);\n        }\n    }\n\n}\n"]}

package/esm5/shared/gipi-components/datepicker/mat-datepicker/date-range-picker.js

@@ -0,0 +1,46 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { __decorate, __extends } from "tslib";
+import { ChangeDetectionStrategy, Component, ViewEncapsulation } from '@angular/core';
+import { MAT_CALENDAR_RANGE_STRATEGY_PROVIDER } from './date-range-selection-strategy';
+import { MAT_RANGE_DATE_SELECTION_MODEL_PROVIDER } from './date-selection-model';
+import { MatDatepickerBase } from './datepicker-base';
+// TODO(mmalerba): We use a component instead of a directive here so the user can use implicit
+// template reference variables (e.g. #d vs #d="matDateRangePicker"). We can change this to a
+// directive if angular adds support for `exportAs: '$implicit'` on directives.
+/** Component responsible for managing the date range picker popup/dialog. */
+var MatDateRangePicker = /** @class */ (function (_super) {
+    __extends(MatDateRangePicker, _super);
+    function MatDateRangePicker() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    MatDateRangePicker.prototype._forwardContentValues = function (instance) {
+        _super.prototype._forwardContentValues.call(this, instance);
+        var input = this._datepickerInput;
+        if (input) {
+            instance.comparisonStart = input.comparisonStart;
+            instance.comparisonEnd = input.comparisonEnd;
+        }
+    };
+    MatDateRangePicker = __decorate([
+        Component({
+            selector: 'gipi-mat-date-range-picker',
+            template: '',
+            exportAs: 'gipiMatDateRangePicker',
+            changeDetection: ChangeDetectionStrategy.OnPush,
+            encapsulation: ViewEncapsulation.None,
+            providers: [
+                MAT_RANGE_DATE_SELECTION_MODEL_PROVIDER,
+                MAT_CALENDAR_RANGE_STRATEGY_PROVIDER,
+            ]
+        })
+    ], MatDateRangePicker);
+    return MatDateRangePicker;
+}(MatDatepickerBase));
+export { MatDateRangePicker };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/shared/gipi-components/datepicker/mat-datepicker/date-range-selection-strategy.js

@@ -0,0 +1,62 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { __decorate, __metadata } from "tslib";
+import { Injectable, InjectionToken, Optional, SkipSelf } from '@angular/core';
+import { DateRange } from './date-selection-model';
+import { DateAdapter } from './shared/adapter/date-adapter';
+/** Injection token used to customize the date range selection behavior. */
+export var MAT_DATE_RANGE_SELECTION_STRATEGY = new InjectionToken('MAT_DATE_RANGE_SELECTION_STRATEGY');
+/** Provides the default date range selection behavior. */
+var DefaultMatCalendarRangeStrategy = /** @class */ (function () {
+    function DefaultMatCalendarRangeStrategy(_dateAdapter) {
+        this._dateAdapter = _dateAdapter;
+    }
+    DefaultMatCalendarRangeStrategy.prototype.selectionFinished = function (date, currentRange) {
+        var start = currentRange.start, end = currentRange.end;
+        if (start == null) {
+            start = date;
+        }
+        else if (end == null && date && this._dateAdapter.compareDate(date, start) >= 0) {
+            end = date;
+        }
+        else {
+            start = date;
+            end = null;
+        }
+        return new DateRange(start, end);
+    };
+    DefaultMatCalendarRangeStrategy.prototype.createPreview = function (activeDate, currentRange) {
+        var start = null;
+        var end = null;
+        if (currentRange.start && !currentRange.end && activeDate) {
+            start = currentRange.start;
+            end = activeDate;
+        }
+        return new DateRange(start, end);
+    };
+    DefaultMatCalendarRangeStrategy.ctorParameters = function () { return [
+        { type: DateAdapter }
+    ]; };
+    DefaultMatCalendarRangeStrategy = __decorate([
+        Injectable(),
+        __metadata("design:paramtypes", [DateAdapter])
+    ], DefaultMatCalendarRangeStrategy);
+    return DefaultMatCalendarRangeStrategy;
+}());
+export { DefaultMatCalendarRangeStrategy };
+/** @docs-private */
+export function MAT_CALENDAR_RANGE_STRATEGY_PROVIDER_FACTORY(parent, adapter) {
+    return parent || new DefaultMatCalendarRangeStrategy(adapter);
+}
+/** @docs-private */
+export var MAT_CALENDAR_RANGE_STRATEGY_PROVIDER = {
+    provide: MAT_DATE_RANGE_SELECTION_STRATEGY,
+    deps: [[new Optional(), new SkipSelf(), MAT_DATE_RANGE_SELECTION_STRATEGY], DateAdapter],
+    useFactory: MAT_CALENDAR_RANGE_STRATEGY_PROVIDER_FACTORY,
+};
+//# sourceMappingURL=data:application/json;base64,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