@gipisistemas/ng-core 1.0.67 → 1.0.68

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

@@ -0,0 +1,329 @@
+/**
+ * @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
+ */
+var MatDateRangeInput_1;
+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';
+let nextUniqueId = 0;
+let MatDateRangeInput = MatDateRangeInput_1 = class MatDateRangeInput {
+    constructor(_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;
+    }
+    /** Current value of the range input. */
+    get value() {
+        return this._model ? this._model.selection : null;
+    }
+    /** Whether the control's label should float. */
+    get shouldLabelFloat() {
+        return this.focused || !this.empty;
+    }
+    /**
+     * Implemented as a part of `MatFormFieldControl`.
+     * Set the placeholder attribute on `matStartDate` and `matEndDate`.
+     * @docs-private
+     */
+    get placeholder() {
+        const start = this._startInput ? this._startInput._getPlaceholder() : '';
+        const end = this._endInput ? this._endInput._getPlaceholder() : '';
+        return (start || end) ? `${start} ${this.separator} ${end}` : '';
+    }
+    /** The range picker that this input is associated with. */
+    get rangePicker() { return this._rangePicker; }
+    set rangePicker(rangePicker) {
+        if (rangePicker) {
+            this._model = rangePicker._registerInput(this);
+            this._rangePicker = rangePicker;
+            this._registerModel(this._model);
+        }
+    }
+    /** Whether the input is required. */
+    get required() { return !!this._required; }
+    set required(value) {
+        this._required = coerceBooleanProperty(value);
+    }
+    /** Function that can be used to filter out dates within the date range picker. */
+    get dateFilter() { return this._dateFilter; }
+    set dateFilter(value) {
+        this._dateFilter = value;
+        this._revalidate();
+    }
+    /** The minimum valid date. */
+    get min() { return this._min; }
+    set min(value) {
+        const validValue = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));
+        if (!this._dateAdapter.sameDate(validValue, this._min)) {
+            this._min = validValue;
+            this._revalidate();
+        }
+    }
+    /** The maximum valid date. */
+    get max() { return this._max; }
+    set max(value) {
+        const validValue = this._dateAdapter.getValidDateOrNull(this._dateAdapter.deserialize(value));
+        if (!this._dateAdapter.sameDate(validValue, this._max)) {
+            this._max = validValue;
+            this._revalidate();
+        }
+    }
+    /** Whether the input is disabled. */
+    get disabled() {
+        return (this._startInput && this._endInput) ?
+            (this._startInput.disabled && this._endInput.disabled) :
+            this._groupDisabled;
+    }
+    set disabled(value) {
+        const newValue = coerceBooleanProperty(value);
+        if (newValue !== this._groupDisabled) {
+            this._groupDisabled = newValue;
+            this.stateChanges.next(undefined);
+        }
+    }
+    /** Whether the input is in an error state. */
+    get errorState() {
+        if (this._startInput && this._endInput) {
+            return this._startInput.errorState || this._endInput.errorState;
+        }
+        return false;
+    }
+    /** Whether the datepicker input is empty. */
+    get empty() {
+        const startEmpty = this._startInput ? this._startInput.isEmpty() : false;
+        const endEmpty = this._endInput ? this._endInput.isEmpty() : false;
+        return startEmpty && endEmpty;
+    }
+    /**
+     * Implemented as a part of `MatFormFieldControl`.
+     * @docs-private
+     */
+    setDescribedByIds(ids) {
+        this._ariaDescribedBy = ids.length ? ids.join(' ') : null;
+    }
+    /**
+     * Implemented as a part of `MatFormFieldControl`.
+     * @docs-private
+     */
+    onContainerClick() {
+        if (!this.focused && !this.disabled) {
+            if (!this._model || !this._model.selection.start) {
+                this._startInput.focus();
+            }
+            else {
+                this._endInput.focus();
+            }
+        }
+    }
+    ngAfterContentInit() {
+        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(() => {
+            this.stateChanges.next(undefined);
+        });
+    }
+    ngOnChanges(changes) {
+        if (dateInputsHaveChanged(changes, this._dateAdapter)) {
+            this.stateChanges.next(undefined);
+        }
+    }
+    ngOnDestroy() {
+        this.stateChanges.complete();
+    }
+    /** Gets the date at which the calendar should start. */
+    getStartValue() {
+        return this.value ? this.value.start : null;
+    }
+    /** Gets the input's theme palette. */
+    getThemePalette() {
+        return this._formField ? this._formField.color : undefined;
+    }
+    /** Gets the element to which the calendar overlay should be attached. */
+    getConnectedOverlayOrigin() {
+        return this._formField ? this._formField.getConnectedOverlayOrigin() : this._elementRef;
+    }
+    /** Gets the value that is used to mirror the state input. */
+    _getInputMirrorValue() {
+        return this._startInput ? this._startInput.getMirrorValue() : '';
+    }
+    /** Whether the input placeholders should be hidden. */
+    _shouldHidePlaceholders() {
+        return this._startInput ? !this._startInput.isEmpty() : false;
+    }
+    /** Handles the value in one of the child inputs changing. */
+    _handleChildValueChange() {
+        this.stateChanges.next(undefined);
+        this._changeDetectorRef.markForCheck();
+    }
+    /** Opens the date range picker associated with the input. */
+    _openDatepicker() {
+        if (this._rangePicker) {
+            this._rangePicker.open();
+        }
+    }
+    /** Whether the separate text should be hidden. */
+    _shouldHideSeparator() {
+        return (!this._formField || this._formField._hideControlPlaceholder()) && this.empty;
+    }
+    /** Gets the value for the `aria-labelledby` attribute of the inputs. */
+    _getAriaLabelledby() {
+        const formField = this._formField;
+        return formField && formField._hasFloatingLabel() ? formField._labelId : null;
+    }
+    /** Re-runs the validators on the start/end inputs. */
+    _revalidate() {
+        if (this._startInput) {
+            this._startInput._validatorOnChange();
+        }
+        if (this._endInput) {
+            this._endInput._validatorOnChange();
+        }
+    }
+    /** Registers the current date selection model with the start/end inputs. */
+    _registerModel(model) {
+        if (this._startInput) {
+            this._startInput._registerModel(model);
+        }
+        if (this._endInput) {
+            this._endInput._registerModel(model);
+        }
+    }
+};
+MatDateRangeInput.ctorParameters = () => [
+    { 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);
+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/esm2015/shared/gipi-components/datepicker/mat-datepicker/date-range-picker.js

@@ -0,0 +1,41 @@
+/**
+ * @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 } 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. */
+let MatDateRangePicker = class MatDateRangePicker extends MatDatepickerBase {
+    _forwardContentValues(instance) {
+        super._forwardContentValues(instance);
+        const 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);
+export { MatDateRangePicker };
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,61 @@
+/**
+ * @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 const MAT_DATE_RANGE_SELECTION_STRATEGY = new InjectionToken('MAT_DATE_RANGE_SELECTION_STRATEGY');
+/** Provides the default date range selection behavior. */
+let DefaultMatCalendarRangeStrategy = class DefaultMatCalendarRangeStrategy {
+    constructor(_dateAdapter) {
+        this._dateAdapter = _dateAdapter;
+    }
+    selectionFinished(date, currentRange) {
+        let { start, end } = currentRange;
+        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);
+    }
+    createPreview(activeDate, currentRange) {
+        let start = null;
+        let end = null;
+        if (currentRange.start && !currentRange.end && activeDate) {
+            start = currentRange.start;
+            end = activeDate;
+        }
+        return new DateRange(start, end);
+    }
+};
+DefaultMatCalendarRangeStrategy.ctorParameters = () => [
+    { type: DateAdapter }
+];
+DefaultMatCalendarRangeStrategy = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [DateAdapter])
+], DefaultMatCalendarRangeStrategy);
+export { DefaultMatCalendarRangeStrategy };
+/** @docs-private */
+export function MAT_CALENDAR_RANGE_STRATEGY_PROVIDER_FACTORY(parent, adapter) {
+    return parent || new DefaultMatCalendarRangeStrategy(adapter);
+}
+/** @docs-private */
+export const 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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