@gipisistemas/ng-core 1.1.0 → 1.1.1

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

@@ -0,0 +1,378 @@
+import { __decorate, __metadata } from "tslib";
+import { coerceBooleanProperty, coerceNumberProperty } from '@angular/cdk/coercion';
+import { ChangeDetectorRef, Component, ElementRef, forwardRef, Input, OnDestroy, OnInit, ViewChild } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { BrowserUtil } from './../../../../core/utils/browser.util';
+import { DateUtil } from './../../../../core/utils/date.util';
+import * as moment_ from 'moment';
+var moment = moment_;
+import { DateRange } from '../mat-datepicker/date-selection-model';
+import { MatDatepickerToggle } from '../mat-datepicker/datepicker-toggle';
+export var nextUniqueId = 0;
+var DateRangePickerComponent = /** @class */ (function () {
+    function DateRangePickerComponent(elementRef, _changeDetectorRef) {
+        this.elementRef = elementRef;
+        this._changeDetectorRef = _changeDetectorRef;
+        this._name = "gipi-date-range-" + nextUniqueId++;
+        this.idStartDate = this._name + "-start";
+        this.idEndDate = this._name + "-end";
+        this.nameStartDate = this._name + "-start";
+        this.nameEndDate = this._name + "-end";
+        this.label = '';
+        this.placeholderStartDate = 'Inicial';
+        this.placeholderEndDate = 'Final';
+        this.help = '';
+        this.separator = '-';
+        this._customRangeLabel = 'Personalizado';
+        this._maxRange = 368;
+        this._minDate = new Date('01/01/2000');
+        this._required = false;
+        this._readonly = false;
+        this._disabled = false;
+        this._dateFilter = null;
+        this.onChange = function () { };
+        this.onTouched = function () { };
+    }
+    DateRangePickerComponent_1 = DateRangePickerComponent;
+    Object.defineProperty(DateRangePickerComponent.prototype, "startDate", {
+        get: function () {
+            return this._startDate;
+        },
+        set: function (value) {
+            this._startDate = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DateRangePickerComponent.prototype, "endDate", {
+        get: function () {
+            return this._endDate;
+        },
+        set: function (value) {
+            this._endDate = value;
+            this.value = new DateRange(this.startDate, value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DateRangePickerComponent.prototype, "customRangeLabel", {
+        get: function () {
+            return this._customRangeLabel;
+        },
+        set: function (value) {
+            this._customRangeLabel = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DateRangePickerComponent.prototype, "ranges", {
+        get: function () {
+            return this._ranges;
+        },
+        set: function (value) {
+            this._ranges = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DateRangePickerComponent.prototype, "maxRange", {
+        get: function () {
+            return this._maxRange;
+        },
+        set: function (value) {
+            this._maxRange = coerceNumberProperty(value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DateRangePickerComponent.prototype, "minDate", {
+        get: function () {
+            return this._minDate;
+        },
+        set: function (value) {
+            this._minDate = value;
+            this._minDate.setHours(0, 0, 0, 0);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DateRangePickerComponent.prototype, "maxDate", {
+        get: function () {
+            return this._maxDate;
+        },
+        set: function (value) {
+            this._maxDate = value;
+            this._maxDate.setHours(0, 0, 0, 0);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DateRangePickerComponent.prototype, "required", {
+        get: function () {
+            return this._required;
+        },
+        set: function (value) {
+            this._required = coerceBooleanProperty(value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DateRangePickerComponent.prototype, "readonly", {
+        get: function () {
+            return this._readonly;
+        },
+        set: function (value) {
+            this._readonly = coerceBooleanProperty(value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DateRangePickerComponent.prototype, "disabled", {
+        get: function () {
+            return this._disabled;
+        },
+        set: function (value) {
+            this._disabled = coerceBooleanProperty(value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DateRangePickerComponent.prototype, "dateFilter", {
+        get: function () {
+            return this._dateFilter;
+        },
+        set: function (value) {
+            this._dateFilter = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DateRangePickerComponent.prototype, "value", {
+        get: function () {
+            return this._value;
+        },
+        set: function (value) {
+            var start = null;
+            var end = null;
+            if (value && value.start) {
+                start = moment(value.start).startOf('day').toDate();
+            }
+            if (value && value.end) {
+                end = moment(value.end).endOf('day').toDate();
+            }
+            if (start && end) {
+                this._value = new DateRange(start, end);
+                this.onChange(this._value);
+                this.onTouched(this._value);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DateRangePickerComponent.prototype, "formattedValue", {
+        get: function () {
+            return '';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    DateRangePickerComponent.prototype.ngOnInit = function () { };
+    DateRangePickerComponent.prototype.ngOnDestroy = function () { };
+    DateRangePickerComponent.prototype.writeValue = function (value) {
+        if (value && value.start) {
+            this.startDate = moment(value.start).startOf('day').toDate();
+        }
+        else {
+            this.startDate = null;
+        }
+        if (value && value.end) {
+            this.endDate = moment(value.end).endOf('day').toDate();
+        }
+        else {
+            this.endDate = null;
+        }
+        this._changeDetectorRef.detectChanges();
+    };
+    DateRangePickerComponent.prototype.registerOnChange = function (fn) {
+        this.onChange = fn;
+    };
+    DateRangePickerComponent.prototype.registerOnTouched = function (fn) {
+        this.onTouched = fn;
+    };
+    DateRangePickerComponent.prototype.setDisabledState = function (isDisabled) {
+        this.disabled = isDisabled;
+        this._changeDetectorRef.markForCheck();
+    };
+    DateRangePickerComponent.prototype.onInputContentClick = function (event) {
+        if (!this.readonly || !this.matDatepickerToggleRef) {
+            return;
+        }
+        this.matDatepickerToggleRef._open(event);
+    };
+    DateRangePickerComponent.prototype.generatedStartDate = function (valueDate, keyUp) {
+        if (!keyUp && BrowserUtil.getBrowser() === 'Firefox') {
+            return;
+        }
+        var match = false;
+        if (valueDate.includes('/') && (!keyUp || valueDate.length === 10)) {
+            this.startDate = moment(valueDate, 'DD/MM/YYYY').toDate();
+            match = true;
+        }
+        else if (!valueDate.includes('/') && (!keyUp || valueDate.length === 8)) {
+            this.startDate = moment(valueDate, 'DDMMYYYY').toDate();
+            match = true;
+        }
+        if (BrowserUtil.getBrowser() !== 'Firefox') {
+            if (match && !DateUtil.isValid(this.startDate)) {
+                this.startDate = undefined;
+            }
+        }
+        else {
+            if (match && !this.startDate) {
+                this.startDate = undefined;
+            }
+        }
+    };
+    DateRangePickerComponent.prototype.generatedEndDate = function (valueDate, keyUp) {
+        if (!keyUp && BrowserUtil.getBrowser() === 'Firefox') {
+            return;
+        }
+        var match = false;
+        if (valueDate.includes('/') && (!keyUp || valueDate.length === 10)) {
+            this.endDate = moment(valueDate, 'DD/MM/YYYY').toDate();
+            match = true;
+        }
+        else if (!valueDate.includes('/') && (!keyUp || valueDate.length === 8)) {
+            this.endDate = moment(valueDate, 'DDMMYYYY').toDate();
+            match = true;
+        }
+        if (BrowserUtil.getBrowser() !== 'Firefox') {
+            if (match && !DateUtil.isValid(this.endDate)) {
+                this.endDate = undefined;
+            }
+        }
+        else {
+            if (match && !this.endDate) {
+                this.endDate = undefined;
+            }
+        }
+    };
+    var DateRangePickerComponent_1;
+    DateRangePickerComponent.ctorParameters = function () { return [
+        { type: ElementRef },
+        { type: ChangeDetectorRef }
+    ]; };
+    __decorate([
+        ViewChild(MatDatepickerToggle, { static: true }),
+        __metadata("design:type", MatDatepickerToggle)
+    ], DateRangePickerComponent.prototype, "matDatepickerToggleRef", void 0);
+    __decorate([
+        Input('idStart'),
+        __metadata("design:type", String)
+    ], DateRangePickerComponent.prototype, "idStartDate", void 0);
+    __decorate([
+        Input('idEnd'),
+        __metadata("design:type", String)
+    ], DateRangePickerComponent.prototype, "idEndDate", void 0);
+    __decorate([
+        Input('nameStart'),
+        __metadata("design:type", String)
+    ], DateRangePickerComponent.prototype, "nameStartDate", void 0);
+    __decorate([
+        Input('nameEnd'),
+        __metadata("design:type", String)
+    ], DateRangePickerComponent.prototype, "nameEndDate", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], DateRangePickerComponent.prototype, "label", void 0);
+    __decorate([
+        Input('placeholderStart'),
+        __metadata("design:type", String)
+    ], DateRangePickerComponent.prototype, "placeholderStartDate", void 0);
+    __decorate([
+        Input('placeholderEnd'),
+        __metadata("design:type", String)
+    ], DateRangePickerComponent.prototype, "placeholderEndDate", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], DateRangePickerComponent.prototype, "help", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], DateRangePickerComponent.prototype, "separator", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String),
+        __metadata("design:paramtypes", [String])
+    ], DateRangePickerComponent.prototype, "customRangeLabel", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", Object),
+        __metadata("design:paramtypes", [Object])
+    ], DateRangePickerComponent.prototype, "ranges", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", Number),
+        __metadata("design:paramtypes", [Number])
+    ], DateRangePickerComponent.prototype, "maxRange", null);
+    __decorate([
+        Input('min'),
+        __metadata("design:type", Date),
+        __metadata("design:paramtypes", [Date])
+    ], DateRangePickerComponent.prototype, "minDate", null);
+    __decorate([
+        Input('max'),
+        __metadata("design:type", Date),
+        __metadata("design:paramtypes", [Date])
+    ], DateRangePickerComponent.prototype, "maxDate", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean),
+        __metadata("design:paramtypes", [Boolean])
+    ], DateRangePickerComponent.prototype, "required", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean),
+        __metadata("design:paramtypes", [Boolean])
+    ], DateRangePickerComponent.prototype, "readonly", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean),
+        __metadata("design:paramtypes", [Boolean])
+    ], DateRangePickerComponent.prototype, "disabled", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Function])
+    ], DateRangePickerComponent.prototype, "dateFilter", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", DateRange),
+        __metadata("design:paramtypes", [DateRange])
+    ], DateRangePickerComponent.prototype, "value", null);
+    DateRangePickerComponent = DateRangePickerComponent_1 = __decorate([
+        Component({
+            selector: 'gipi-date-range-picker',
+            exportAs: 'gipiDateRangePicker',
+            template: "<div class=\"input-wrapper\">\n\n    <label *ngIf=\"label\"\n           class=\"input-label\"\n           [attr.for]=\"'dateRangeInput'\">\n        {{ label }}\n        <span *ngIf=\"required\"> * </span>\n    </label>\n\n    <div class=\"input-content\"\n         (click)=\"onInputContentClick($event)\">\n        <gipi-mat-date-range-input #matDateRangeInput\n                                   id=\"dateRangeInput\"\n                                   [min]=\"minDate\"\n                                   [max]=\"maxDate\"\n                                   [disabled]=\"disabled\"\n                                   [required]=\"required\"\n                                   [separator]=\"separator\"\n                                   [rangePicker]=\"rangepicker\">\n            <input gipiMatStartDate\n                   class=\"input-element\"\n                   [attr.id]=\"idStartDate\"\n                   [attr.name]=\"nameStartDate\"\n                   [placeholder]=\"placeholderStartDate\"\n                   [disabled]=\"disabled\"\n                   [required]=\"required\"\n                   [readOnly]=\"readonly\"\n                   [autocomplete]=\"'off'\"\n                   [autofocus]=\"false\"\n                   [maxlength]=\"10\"\n                   [(ngModel)]=\"startDate\"\n                   (keyup)=\"generatedStartDate($event.target.value, true)\"\n                   (change)=\"generatedStartDate($event.target.value, false)\" />\n\n            <input gipiMatEndDate\n                   class=\"input-element\"\n                   [attr.id]=\"idEndDate\"\n                   [attr.name]=\"nameEndDate\"\n                   [placeholder]=\"placeholderEndDate\"\n                   [disabled]=\"disabled\"\n                   [required]=\"required\"\n                   [readOnly]=\"readonly\"\n                   [autocomplete]=\"'off'\"\n                   [autofocus]=\"false\"\n                   [maxlength]=\"10\"\n                   [(ngModel)]=\"endDate\"\n                   (keyup)=\"generatedEndDate($event.target.value, true)\"\n                   (change)=\"generatedEndDate($event.target.value, false)\" />\n        </gipi-mat-date-range-input>\n\n        <div class=\"suffix\">\n            <gipi-mat-datepicker-toggle matSuffix\n                                        [for]=\"rangepicker\">\n            </gipi-mat-datepicker-toggle>\n        </div>\n    </div>\n\n    <small *ngIf=\"help\"\n           class=\"input-help\">\n        {{ help }}\n    </small>\n</div>\n\n<gipi-mat-date-range-picker #rangepicker\n                            [maxRange]=\"maxRange\"\n                            [templatePresetRange]=\"templatePresetRange\">\n</gipi-mat-date-range-picker>\n\n<ng-template #templatePresetRange\n             let-component>\n    <gipi-preset-range [matDateRangeInput]=\"matDateRangeInput\"\n                       [matCalendar]=\"component\"\n                       [matDateRangePicker]=\"rangepicker\"\n                       [customRangeLabel]=\"'Personalizado'\"\n                       [maxRange]=\"maxRange\"\n                       [ranges]=\"ranges\">\n    </gipi-preset-range>\n</ng-template>\n",
+            providers: [
+                {
+                    provide: NG_VALUE_ACCESSOR,
+                    useExisting: forwardRef(function () { return DateRangePickerComponent_1; }),
+                    multi: true
+                },
+            ],
+            host: {
+                'class': 'gipi-date-range-picker',
+            },
+            styles: [":host{display:block;width:100%}.input-wrapper{display:flex;flex-direction:column;gap:.8rem;font-size:1.4rem;color:#696969}.input-wrapper .input-label{display:flex;align-items:center;gap:.4rem;color:#131313;line-height:1.6rem}.input-wrapper .input-label>span{font-size:1.6rem;line-height:1.6rem;color:#d14014}.input-wrapper .input-content{display:flex;font-family:inherit;font-size:inherit;color:inherit;height:4rem;background:#fff;border:1px solid rgba(0,0,0,.12);transition:background-color .2s,color .2s,border-color .2s,box-shadow .2s;-webkit-appearance:none;-moz-appearance:none;appearance:none;border-radius:.6rem}.input-wrapper .input-content .input-element{padding:.75rem .8rem;border:none;outline:0;background-color:transparent;flex:1;color:inherit;caret-color:#696969;min-width:0}.input-wrapper .input-content:not(.input-element:disabled):has(.input-element:enabled:hover),.input-wrapper .input-content:not(.input-element:disabled):has(.prefix:hover),.input-wrapper .input-content:not(.input-element:disabled):has(.suffix:hover){border-color:#6d6f73}.input-wrapper .input-content:not(.input-element:disabled):has(.input-element:enabled:focus){outline:0;outline-offset:0;box-shadow:0 0 0 .2rem #e0e1e2;border-color:#6d6f73}.input-wrapper .input-content:has(.input-element:disabled){color:#bbbdc1!important;border-color:#e0e1e2!important;background-color:#f5f5f6!important;cursor:not-allowed}.input-wrapper .input-content:has(.input-element:disabled) .suffix>mat-icon{color:#bbbdc1!important}.input-wrapper .input-content .input-element:disabled{cursor:not-allowed}.input-wrapper .input-content .suffix{display:flex;align-items:center;justify-content:center;padding-block:.75rem;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;padding-right:.8rem}.input-wrapper .input-content .suffix>mat-icon{width:2rem;height:2rem;font-size:2rem;color:#696969}.input-wrapper .input-help{flex:1;font-size:1rem;font-weight:500;margin-top:-.4rem;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}::ng-deep .mat-date-range-input{height:4rem!important;padding-left:.8rem!important}::ng-deep .mat-date-range-input-container,::ng-deep .mat-date-range-input-end-wrapper,::ng-deep .mat-date-range-input-inner,::ng-deep .mat-date-range-input-start-wrapper{width:-webkit-fit-content;width:-moz-fit-content;width:fit-content;max-width:100%;min-height:100%;height:100%;padding-bottom:3px}::ng-deep .mat-date-range-input-inner{padding:0!important}::-webkit-input-placeholder{color:#bbbdc1}:-moz-placeholder{color:#bbbdc1}::-moz-placeholder{color:#bbbdc1}:-ms-input-placeholder{color:#bbbdc1}"]
+        }),
+        __metadata("design:paramtypes", [ElementRef,
+            ChangeDetectorRef])
+    ], DateRangePickerComponent);
+    return DateRangePickerComponent;
+}());
+export { DateRangePickerComponent };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"date-range-picker.component.js","sourceRoot":"ng://@gipisistemas/ng-core/","sources":["shared/gipi-components/datepicker/date-range-picker/date-range-picker.component.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,qBAAqB,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AACpF,OAAO,EAAE,iBAAiB,EAAE,SAAS,EAAE,UAAU,EAAE,UAAU,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC1H,OAAO,EAAwB,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACzE,OAAO,EAAE,WAAW,EAAE,MAAM,uCAAuC,CAAC;AACpE,OAAO,EAAE,QAAQ,EAAE,MAAM,oCAAoC,CAAC;AAE9D,OAAO,KAAK,OAAO,MAAM,QAAQ,CAAC;AAClC,IAAM,MAAM,GAAG,OAAO,CAAC;AAEvB,OAAO,EAAE,SAAS,EAAE,MAAM,wCAAwC,CAAC;AAEnE,OAAO,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAC;AAG1E,MAAM,CAAC,IAAI,YAAY,GAAG,CAAC,CAAC;AAkB5B;IA6II,kCACW,UAAsB,EACrB,kBAAqC;QADtC,eAAU,GAAV,UAAU,CAAY;QACrB,uBAAkB,GAAlB,kBAAkB,CAAmB;QA3IzC,UAAK,GAAW,qBAAmB,YAAY,EAAI,CAAC;QAmB1C,gBAAW,GAAc,IAAI,CAAC,KAAK,WAAQ,CAAC;QAC9C,cAAS,GAAc,IAAI,CAAC,KAAK,SAAM,CAAC;QAEpC,kBAAa,GAAc,IAAI,CAAC,KAAK,WAAQ,CAAC;QAChD,gBAAW,GAAc,IAAI,CAAC,KAAK,SAAM,CAAC;QAEnD,UAAK,GAAW,EAAE,CAAC;QAED,yBAAoB,GAAW,SAAS,CAAC;QAC3C,uBAAkB,GAAW,OAAO,CAAC;QAErD,SAAI,GAAW,EAAE,CAAC;QAElB,cAAS,GAAW,GAAG,CAAC;QAEzB,sBAAiB,GAAW,eAAe,CAAC;QAgB5C,cAAS,GAAW,GAAG,CAAC;QAQxB,aAAQ,GAAS,IAAI,IAAI,CAAC,YAAY,CAAC,CAAC;QAkBxC,cAAS,GAAY,KAAK,CAAC;QAQ3B,cAAS,GAAY,KAAK,CAAC;QAQ3B,cAAS,GAAY,KAAK,CAAC;QAQ3B,gBAAW,GAAuB,IAAI,CAAC;QA6B/C,aAAQ,GAAa,cAAQ,CAAC,CAAC;QAE/B,cAAS,GAAa,cAAQ,CAAC,CAAC;IAS5B,CAAC;iCAhJI,wBAAwB;IAOjC,sBAAI,+CAAS;aAAb;YACI,OAAO,IAAI,CAAC,UAAU,CAAC;QAC3B,CAAC;aACD,UAAc,KAAW;YACrB,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;QAC5B,CAAC;;;OAHA;IAMD,sBAAI,6CAAO;aAAX;YACI,OAAO,IAAI,CAAC,QAAQ,CAAC;QACzB,CAAC;aACD,UAAY,KAAW;YACnB,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;YACtB,IAAI,CAAC,KAAK,GAAG,IAAI,SAAS,CAAC,IAAI,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;QACtD,CAAC;;;OAJA;IAsBQ,sBAAI,sDAAgB;aAApB;YACL,OAAO,IAAI,CAAC,iBAAiB,CAAC;QAClC,CAAC;aACD,UAAqB,KAAa;YAC9B,IAAI,CAAC,iBAAiB,GAAG,KAAK,CAAC;QACnC,CAAC;;;OAHA;IAMQ,sBAAI,4CAAM;aAAV;YACL,OAAO,IAAI,CAAC,OAAO,CAAC;QACxB,CAAC;aACD,UAAW,KAAyB;YAChC,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;QACzB,CAAC;;;OAHA;IAMQ,sBAAI,8CAAQ;aAAZ;YACL,OAAO,IAAI,CAAC,SAAS,CAAC;QAC1B,CAAC;aACD,UAAa,KAAa;YACtB,IAAI,CAAC,SAAS,GAAG,oBAAoB,CAAC,KAAK,CAAC,CAAC;QACjD,CAAC;;;OAHA;IAMa,sBAAI,6CAAO;aAAX;YACV,OAAO,IAAI,CAAC,QAAQ,CAAC;QACzB,CAAC;aACD,UAAY,KAAW;YACnB,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;YACtB,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;QACvC,CAAC;;;OAJA;IAOa,sBAAI,6CAAO;aAAX;YACV,OAAO,IAAI,CAAC,QAAQ,CAAC;QACzB,CAAC;aACD,UAAY,KAAW;YACnB,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;YACtB,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;QACvC,CAAC;;;OAJA;IAOQ,sBAAI,8CAAQ;aAAZ;YACL,OAAO,IAAI,CAAC,SAAS,CAAC;QAC1B,CAAC;aACD,UAAa,KAAc;YACvB,IAAI,CAAC,SAAS,GAAG,qBAAqB,CAAC,KAAK,CAAC,CAAC;QAClD,CAAC;;;OAHA;IAMQ,sBAAI,8CAAQ;aAAZ;YACL,OAAO,IAAI,CAAC,SAAS,CAAC;QAC1B,CAAC;aACD,UAAa,KAAc;YACvB,IAAI,CAAC,SAAS,GAAG,qBAAqB,CAAC,KAAK,CAAC,CAAC;QAClD,CAAC;;;OAHA;IAMQ,sBAAI,8CAAQ;aAAZ;YACL,OAAO,IAAI,CAAC,SAAS,CAAC;QAC1B,CAAC;aACD,UAAa,KAAc;YACvB,IAAI,CAAC,SAAS,GAAG,qBAAqB,CAAC,KAAK,CAAC,CAAC;QAClD,CAAC;;;OAHA;IAMQ,sBAAI,gDAAU;aAAd;YACL,OAAO,IAAI,CAAC,WAAW,CAAC;QAC5B,CAAC;aACD,UAAe,KAAyB;YACpC,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC;QAC7B,CAAC;;;OAHA;IAMQ,sBAAI,2CAAK;aAAT;YACL,OAAO,IAAI,CAAC,MAAM,CAAC;QACvB,CAAC;aACD,UAAU,KAAsB;YAC5B,IAAI,KAAK,GAAS,IAAI,CAAC;YACvB,IAAI,GAAG,GAAS,IAAI,CAAC;YACrB,IAAI,KAAK,IAAI,KAAK,CAAC,KAAK,EAAE;gBACtB,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,MAAM,EAAE,CAAC;aACvD;YACD,IAAI,KAAK,IAAI,KAAK,CAAC,GAAG,EAAE;gBACpB,GAAG,GAAG,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,MAAM,EAAE,CAAC;aACjD;YAED,IAAI,KAAK,IAAI,GAAG,EAAE;gBACd,IAAI,CAAC,MAAM,GAAG,IAAI,SAAS,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;gBACxC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;gBAC3B,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;aAC/B;QACL,CAAC;;;OAhBA;IAsBD,sBAAW,oDAAc;aAAzB;YACI,OAAO,EAAE,CAAC;QACd,CAAC;;;OAAA;IAOD,2CAAQ,GAAR,cAAmB,CAAC;IAEpB,8CAAW,GAAX,cAAsB,CAAC;IAEvB,6CAAU,GAAV,UAAW,KAAsB;QAC7B,IAAI,KAAK,IAAI,KAAK,CAAC,KAAK,EAAE;YACtB,IAAI,CAAC,SAAS,GAAG,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,MAAM,EAAE,CAAC;SAChE;aAAM;YACH,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;SACzB;QACD,IAAI,KAAK,IAAI,KAAK,CAAC,GAAG,EAAE;YACpB,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,MAAM,EAAE,CAAC;SAC1D;aAAM;YACH,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;SACvB;QAED,IAAI,CAAC,kBAAkB,CAAC,aAAa,EAAE,CAAC;IAC5C,CAAC;IAED,mDAAgB,GAAhB,UAAiB,EAAY;QACzB,IAAI,CAAC,QAAQ,GAAG,EAAE,CAAC;IACvB,CAAC;IAED,oDAAiB,GAAjB,UAAkB,EAAY;QAC1B,IAAI,CAAC,SAAS,GAAG,EAAE,CAAC;IACxB,CAAC;IAED,mDAAgB,GAAhB,UAAkB,UAAmB;QACjC,IAAI,CAAC,QAAQ,GAAG,UAAU,CAAC;QAC3B,IAAI,CAAC,kBAAkB,CAAC,YAAY,EAAE,CAAC;IAC3C,CAAC;IAEM,sDAAmB,GAA1B,UAA2B,KAAiB;QACxC,IAAI,CAAC,IAAI,CAAC,QAAQ,IAAI,CAAC,IAAI,CAAC,sBAAsB,EAAE;YAChD,OAAO;SACV;QAED,IAAI,CAAC,sBAAsB,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAC7C,CAAC;IAEM,qDAAkB,GAAzB,UAA0B,SAAiB,EAAE,KAAc;QACvD,IAAI,CAAC,KAAK,IAAI,WAAW,CAAC,UAAU,EAAE,KAAK,SAAS,EAAE;YAClD,OAAO;SACV;QAED,IAAI,KAAK,GAAG,KAAK,CAAC;QAClB,IAAI,SAAS,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,KAAK,IAAI,SAAS,CAAC,MAAM,KAAK,EAAE,CAAC,EAAE;YAChE,IAAI,CAAC,SAAS,GAAG,MAAM,CAAC,SAAS,EAAE,YAAY,CAAC,CAAC,MAAM,EAAE,CAAC;YAC1D,KAAK,GAAG,IAAI,CAAC;SAChB;aAAM,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,KAAK,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,CAAC,EAAE;YACvE,IAAI,CAAC,SAAS,GAAG,MAAM,CAAC,SAAS,EAAE,UAAU,CAAC,CAAC,MAAM,EAAE,CAAC;YACxD,KAAK,GAAG,IAAI,CAAC;SAChB;QAED,IAAI,WAAW,CAAC,UAAU,EAAE,KAAK,SAAS,EAAE;YACxC,IAAI,KAAK,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE;gBAC5C,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;aAC9B;SACJ;aAAM;YACH,IAAI,KAAK,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE;gBAC1B,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;aAC9B;SACJ;IACL,CAAC;IAEM,mDAAgB,GAAvB,UAAwB,SAAiB,EAAE,KAAc;QACrD,IAAI,CAAC,KAAK,IAAI,WAAW,CAAC,UAAU,EAAE,KAAK,SAAS,EAAE;YAClD,OAAO;SACV;QAED,IAAI,KAAK,GAAG,KAAK,CAAC;QAClB,IAAI,SAAS,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,KAAK,IAAI,SAAS,CAAC,MAAM,KAAK,EAAE,CAAC,EAAE;YAChE,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC,SAAS,EAAE,YAAY,CAAC,CAAC,MAAM,EAAE,CAAC;YACxD,KAAK,GAAG,IAAI,CAAC;SAChB;aAAM,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,KAAK,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,CAAC,EAAE;YACvE,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC,SAAS,EAAE,UAAU,CAAC,CAAC,MAAM,EAAE,CAAC;YACtD,KAAK,GAAG,IAAI,CAAC;SAChB;QAED,IAAI,WAAW,CAAC,UAAU,EAAE,KAAK,SAAS,EAAE;YACxC,IAAI,KAAK,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE;gBAC1C,IAAI,CAAC,OAAO,GAAG,SAAS,CAAC;aAC5B;SACJ;aAAM;YACH,IAAI,KAAK,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE;gBACxB,IAAI,CAAC,OAAO,GAAG,SAAS,CAAC;aAC5B;SACJ;IACL,CAAC;;;gBA5FsB,UAAU;gBACD,iBAAiB;;IA7IC;QAAjD,SAAS,CAAC,mBAAmB,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;kCAAyB,mBAAmB;4EAAO;IAqBlF;QAAjB,KAAK,CAAC,SAAS,CAAC;;iEAA6C;IAC9C;QAAf,KAAK,CAAC,OAAO,CAAC;;+DAAyC;IAEpC;QAAnB,KAAK,CAAC,WAAW,CAAC;;mEAA+C;IAChD;QAAjB,KAAK,CAAC,SAAS,CAAC;;iEAA2C;IAEnD;QAAR,KAAK,EAAE;;2DAAoB;IAED;QAA1B,KAAK,CAAC,kBAAkB,CAAC;;0EAA0C;IAC3C;QAAxB,KAAK,CAAC,gBAAgB,CAAC;;wEAAsC;IAErD;QAAR,KAAK,EAAE;;0DAAmB;IAElB;QAAR,KAAK,EAAE;;+DAAyB;IAGxB;QAAR,KAAK,EAAE;;;oEAEP;IAMQ;QAAR,KAAK,EAAE;;;0DAEP;IAMQ;QAAR,KAAK,EAAE;;;4DAEP;IAMa;QAAb,KAAK,CAAC,KAAK,CAAC;kCAGM,IAAI;yCAAJ,IAAI;2DADtB;IAOa;QAAb,KAAK,CAAC,KAAK,CAAC;kCAGM,IAAI;yCAAJ,IAAI;2DADtB;IAOQ;QAAR,KAAK,EAAE;;;4DAEP;IAMQ;QAAR,KAAK,EAAE;;;4DAEP;IAMQ;QAAR,KAAK,EAAE;;;4DAEP;IAMQ;QAAR,KAAK,EAAE;;;8DAEP;IAMQ;QAAR,KAAK,EAAE;kCAGS,SAAS;yCAAT,SAAS;yDADzB;IAnHQ,wBAAwB;QAhBpC,SAAS,CAAC;YACP,QAAQ,EAAE,wBAAwB;YAClC,QAAQ,EAAE,qBAAqB;YAC/B,qnGAAiD;YAEjD,SAAS,EAAE;gBACP;oBACI,OAAO,EAAE,iBAAiB;oBAC1B,WAAW,EAAE,UAAU,CAAC,cAAuC,OAAA,0BAAwB,EAAxB,CAAwB,CAAC;oBACxF,KAAK,EAAE,IAAI;iBACd;aACJ;YACD,IAAI,EAAE;gBACF,OAAO,EAAE,wBAAwB;aACpC;;SACJ,CAAC;yCA+IyB,UAAU;YACD,iBAAiB;OA/IxC,wBAAwB,CA6OpC;IAAD,+BAAC;CAAA,AA7OD,IA6OC;SA7OY,wBAAwB","sourcesContent":["import { coerceBooleanProperty, coerceNumberProperty } from '@angular/cdk/coercion';\nimport { ChangeDetectorRef, Component, ElementRef, forwardRef, Input, OnDestroy, OnInit, ViewChild } from '@angular/core';\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';\nimport { BrowserUtil } from './../../../../core/utils/browser.util';\nimport { DateUtil } from './../../../../core/utils/date.util';\n\nimport * as moment_ from 'moment';\nconst moment = moment_;\n\nimport { DateRange } from '../mat-datepicker/date-selection-model';\nimport { DateFilterFn } from '../mat-datepicker/datepicker-input-base';\nimport { MatDatepickerToggle } from '../mat-datepicker/datepicker-toggle';\nimport { PresetRanges } from './shared/preset-range/preset-range.component';\n\nexport let nextUniqueId = 0;\n\n@Component({\n    selector: 'gipi-date-range-picker',\n    exportAs: 'gipiDateRangePicker',\n    templateUrl: './date-range-picker.component.html',\n    styleUrls: ['./date-range-picker.component.scss'],\n    providers: [\n        {\n            provide: NG_VALUE_ACCESSOR,\n            useExisting: forwardRef((): typeof DateRangePickerComponent => DateRangePickerComponent),\n            multi: true\n        },\n    ],\n    host: {\n        'class': 'gipi-date-range-picker',\n    }\n})\nexport class DateRangePickerComponent implements OnInit, OnDestroy, ControlValueAccessor {\n\n    @ViewChild(MatDatepickerToggle, { static: true }) matDatepickerToggleRef: MatDatepickerToggle<Date>;\n\n    private _name: string = `gipi-date-range-${nextUniqueId++}`;\n\n    private _startDate: Date;\n    get startDate(): Date {\n        return this._startDate;\n    }\n    set startDate(value: Date) {\n        this._startDate = value;\n    }\n\n    private _endDate: Date;\n    get endDate(): Date {\n        return this._endDate;\n    }\n    set endDate(value: Date) {\n        this._endDate = value;\n        this.value = new DateRange(this.startDate, value);\n    }\n\n    @Input('idStart') idStartDate: string = `${this._name}-start`;\n    @Input('idEnd') idEndDate: string = `${this._name}-end`;\n\n    @Input('nameStart') nameStartDate: string = `${this._name}-start`;\n    @Input('nameEnd') nameEndDate: string = `${this._name}-end`;\n\n    @Input() label: string = '';\n\n    @Input('placeholderStart') placeholderStartDate: string = 'Inicial';\n    @Input('placeholderEnd') placeholderEndDate: string = 'Final';\n\n    @Input() help: string = '';\n\n    @Input() separator: string = '-';\n\n    private _customRangeLabel: string = 'Personalizado';\n    @Input() get customRangeLabel(): string {\n        return this._customRangeLabel;\n    }\n    set customRangeLabel(value: string) {\n        this._customRangeLabel = value;\n    }\n\n    private _ranges: PresetRanges<Date>;\n    @Input() get ranges(): PresetRanges<Date> {\n        return this._ranges;\n    }\n    set ranges(value: PresetRanges<Date>) {\n        this._ranges = value;\n    }\n\n    private _maxRange: number = 368;\n    @Input() get maxRange(): number {\n        return this._maxRange;\n    }\n    set maxRange(value: number) {\n        this._maxRange = coerceNumberProperty(value);\n    }\n\n    private _minDate: Date = new Date('01/01/2000');\n    @Input('min') get minDate(): Date {\n        return this._minDate;\n    }\n    set minDate(value: Date) {\n        this._minDate = value;\n        this._minDate.setHours(0, 0, 0, 0);\n    }\n\n    private _maxDate: Date;\n    @Input('max') get maxDate(): Date {\n        return this._maxDate;\n    }\n    set maxDate(value: Date) {\n        this._maxDate = value;\n        this._maxDate.setHours(0, 0, 0, 0);\n    }\n\n    private _required: boolean = false;\n    @Input() get required(): boolean {\n        return this._required;\n    }\n    set required(value: boolean) {\n        this._required = coerceBooleanProperty(value);\n    }\n\n    private _readonly: boolean = false;\n    @Input() get readonly(): boolean {\n        return this._readonly;\n    }\n    set readonly(value: boolean) {\n        this._readonly = coerceBooleanProperty(value);\n    }\n\n    private _disabled: boolean = false;\n    @Input() get disabled(): boolean {\n        return this._disabled;\n    }\n    set disabled(value: boolean) {\n        this._disabled = coerceBooleanProperty(value);\n    }\n\n    private _dateFilter: DateFilterFn<Date> = null;\n    @Input() get dateFilter(): DateFilterFn<Date> {\n        return this._dateFilter;\n    }\n    set dateFilter(value: DateFilterFn<Date>) {\n        this._dateFilter = value;\n    }\n\n    private _value: DateRange<Date>;\n    @Input() get value(): DateRange<Date> {\n        return this._value;\n    }\n    set value(value: DateRange<Date>) {\n        let start: Date = null;\n        let end: Date = null;\n        if (value && value.start) {\n            start = moment(value.start).startOf('day').toDate();\n        }\n        if (value && value.end) {\n            end = moment(value.end).endOf('day').toDate();\n        }\n\n        if (start && end) {\n            this._value = new DateRange(start, end);\n            this.onChange(this._value);\n            this.onTouched(this._value);\n        }\n    }\n\n    onChange: Function = () => { };\n\n    onTouched: Function = () => { };\n\n    public get formattedValue(): string {\n        return '';\n    }\n\n    constructor(\n        public elementRef: ElementRef,\n        private _changeDetectorRef: ChangeDetectorRef,\n    ) { }\n\n    ngOnInit(): void { }\n\n    ngOnDestroy(): void { }\n\n    writeValue(value: DateRange<Date>): void {\n        if (value && value.start) {\n            this.startDate = moment(value.start).startOf('day').toDate();\n        } else {\n            this.startDate = null;\n        }\n        if (value && value.end) {\n            this.endDate = moment(value.end).endOf('day').toDate();\n        } else {\n            this.endDate = null;\n        }\n\n        this._changeDetectorRef.detectChanges();\n    }\n\n    registerOnChange(fn: Function): void {\n        this.onChange = fn;\n    }\n\n    registerOnTouched(fn: Function): void {\n        this.onTouched = fn;\n    }\n\n    setDisabledState?(isDisabled: boolean): void {\n        this.disabled = isDisabled;\n        this._changeDetectorRef.markForCheck();\n    }\n\n    public onInputContentClick(event: MouseEvent): void {\n        if (!this.readonly || !this.matDatepickerToggleRef) {\n            return;\n        }\n\n        this.matDatepickerToggleRef._open(event);\n    }\n\n    public generatedStartDate(valueDate: string, keyUp: boolean): void {\n        if (!keyUp && BrowserUtil.getBrowser() === 'Firefox') {\n            return;\n        }\n\n        let match = false;\n        if (valueDate.includes('/') && (!keyUp || valueDate.length === 10)) {\n            this.startDate = moment(valueDate, 'DD/MM/YYYY').toDate();\n            match = true;\n        } else if (!valueDate.includes('/') && (!keyUp || valueDate.length === 8)) {\n            this.startDate = moment(valueDate, 'DDMMYYYY').toDate();\n            match = true;\n        }\n\n        if (BrowserUtil.getBrowser() !== 'Firefox') {\n            if (match && !DateUtil.isValid(this.startDate)) {\n                this.startDate = undefined;\n            }\n        } else {\n            if (match && !this.startDate) {\n                this.startDate = undefined;\n            }\n        }\n    }\n\n    public generatedEndDate(valueDate: string, keyUp: boolean): void {\n        if (!keyUp && BrowserUtil.getBrowser() === 'Firefox') {\n            return;\n        }\n\n        let match = false;\n        if (valueDate.includes('/') && (!keyUp || valueDate.length === 10)) {\n            this.endDate = moment(valueDate, 'DD/MM/YYYY').toDate();\n            match = true;\n        } else if (!valueDate.includes('/') && (!keyUp || valueDate.length === 8)) {\n            this.endDate = moment(valueDate, 'DDMMYYYY').toDate();\n            match = true;\n        }\n\n        if (BrowserUtil.getBrowser() !== 'Firefox') {\n            if (match && !DateUtil.isValid(this.endDate)) {\n                this.endDate = undefined;\n            }\n        } else {\n            if (match && !this.endDate) {\n                this.endDate = undefined;\n            }\n        }\n    }\n\n\n}\n"]}

package/esm5/shared/gipi-components/datepicker/date-range-picker/shared/max-range/max-range-selection-startegy.js

@@ -0,0 +1,42 @@
+import { __decorate, __metadata } from "tslib";
+import { Injectable } from "@angular/core";
+import { DateRange } from "../../../mat-datepicker/date-selection-model";
+import { DateAdapter } from "../../../mat-datepicker/shared/adapter/date-adapter";
+var MaxRangeSelectionStrategy = /** @class */ (function () {
+    function MaxRangeSelectionStrategy(_dateAdapter) {
+        this._dateAdapter = _dateAdapter;
+    }
+    MaxRangeSelectionStrategy.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) {
+            var maxDate = this._dateAdapter.addCalendarDays(start, (this.delta - 1));
+            end = (date > maxDate) ? maxDate : date;
+        }
+        else {
+            start = date;
+            end = null;
+        }
+        return new DateRange(start, end);
+    };
+    MaxRangeSelectionStrategy.prototype.createPreview = function (activeDate, currentRange) {
+        if (currentRange.start && !currentRange.end) {
+            var maxDate = this._dateAdapter.addCalendarDays(currentRange.start, (this.delta - 1));
+            var rangeEnd = activeDate ? (activeDate > maxDate) ? maxDate : activeDate : null;
+            return new DateRange(currentRange.start, rangeEnd);
+        }
+        return new DateRange(null, null);
+    };
+    MaxRangeSelectionStrategy.ctorParameters = function () { return [
+        { type: DateAdapter }
+    ]; };
+    MaxRangeSelectionStrategy = __decorate([
+        Injectable(),
+        __metadata("design:paramtypes", [DateAdapter])
+    ], MaxRangeSelectionStrategy);
+    return MaxRangeSelectionStrategy;
+}());
+export { MaxRangeSelectionStrategy };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWF4LXJhbmdlLXNlbGVjdGlvbi1zdGFydGVneS5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BnaXBpc2lzdGVtYXMvbmctY29yZS8iLCJzb3VyY2VzIjpbInNoYXJlZC9naXBpLWNvbXBvbmVudHMvZGF0ZXBpY2tlci9kYXRlLXJhbmdlLXBpY2tlci9zaGFyZWQvbWF4LXJhbmdlL21heC1yYW5nZS1zZWxlY3Rpb24tc3RhcnRlZ3kudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFHM0MsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLDhDQUE4QyxDQUFDO0FBQ3pFLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSxxREFBcUQsQ0FBQztBQUdsRjtJQU1JLG1DQUFvQixZQUE0QjtRQUE1QixpQkFBWSxHQUFaLFlBQVksQ0FBZ0I7SUFBSSxDQUFDO0lBRXJELHFEQUFpQixHQUFqQixVQUFrQixJQUFPLEVBQUUsWUFBMEI7UUFDM0MsSUFBQSxLQUFLLEdBQVUsWUFBWSxNQUF0QixFQUFFLEdBQUcsR0FBSyxZQUFZLElBQWpCLENBQWtCO1FBRWxDLElBQUksS0FBSyxJQUFJLElBQUksRUFBRTtZQUNmLEtBQUssR0FBRyxJQUFJLENBQUM7U0FDaEI7YUFBTSxJQUFJLEdBQUcsSUFBSSxJQUFJLElBQUksSUFBSSxJQUFJLElBQUksQ0FBQyxZQUFZLENBQUMsV0FBVyxDQUFDLElBQUksRUFBRSxLQUFLLENBQUMsSUFBSSxDQUFDLEVBQUU7WUFDL0UsSUFBTSxPQUFPLEdBQUcsSUFBSSxDQUFDLFlBQVksQ0FBQyxlQUFlLENBQUMsS0FBSyxFQUFFLENBQUMsSUFBSSxDQUFDLEtBQUssR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUFDO1lBQzNFLEdBQUcsR0FBRyxDQUFDLElBQUksR0FBRyxPQUFPLENBQUMsQ0FBQyxDQUFDLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUM7U0FDM0M7YUFBTTtZQUNILEtBQUssR0FBRyxJQUFJLENBQUM7WUFDYixHQUFHLEdBQUcsSUFBSSxDQUFDO1NBQ2Q7UUFFRCxPQUFPLElBQUksU0FBUyxDQUFJLEtBQUssRUFBRSxHQUFHLENBQUMsQ0FBQztJQUN4QyxDQUFDO0lBRUQsaURBQWEsR0FBYixVQUFjLFVBQW9CLEVBQUUsWUFBMEI7UUFDMUQsSUFBSSxZQUFZLENBQUMsS0FBSyxJQUFJLENBQUMsWUFBWSxDQUFDLEdBQUcsRUFBRTtZQUN6QyxJQUFNLE9BQU8sR0FBRyxJQUFJLENBQUMsWUFBWSxDQUFDLGVBQWUsQ0FBQyxZQUFZLENBQUMsS0FBSyxFQUFFLENBQUMsSUFBSSxDQUFDLEtBQUssR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUFDO1lBQ3hGLElBQU0sUUFBUSxHQUFHLFVBQVUsQ0FBQyxDQUFDLENBQUMsQ0FBQyxVQUFVLEdBQUcsT0FBTyxDQUFDLENBQUMsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsVUFBVSxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUM7WUFDbkYsT0FBTyxJQUFJLFNBQVMsQ0FBQyxZQUFZLENBQUMsS0FBSyxFQUFFLFFBQVEsQ0FBQyxDQUFDO1NBQ3REO1FBRUQsT0FBTyxJQUFJLFNBQVMsQ0FBSSxJQUFJLEVBQUUsSUFBSSxDQUFDLENBQUM7SUFDeEMsQ0FBQzs7Z0JBMUJpQyxXQUFXOztJQU5wQyx5QkFBeUI7UUFEckMsVUFBVSxFQUFFO3lDQU95QixXQUFXO09BTnBDLHlCQUF5QixDQWtDckM7SUFBRCxnQ0FBQztDQUFBLEFBbENELElBa0NDO1NBbENZLHlCQUF5QiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tIFwiQGFuZ3VsYXIvY29yZVwiO1xuXG5pbXBvcnQgeyBNYXREYXRlUmFuZ2VTZWxlY3Rpb25TdHJhdGVneSB9IGZyb20gXCIuLi8uLi8uLi9tYXQtZGF0ZXBpY2tlci9kYXRlLXJhbmdlLXNlbGVjdGlvbi1zdHJhdGVneVwiO1xuaW1wb3J0IHsgRGF0ZVJhbmdlIH0gZnJvbSBcIi4uLy4uLy4uL21hdC1kYXRlcGlja2VyL2RhdGUtc2VsZWN0aW9uLW1vZGVsXCI7XG5pbXBvcnQgeyBEYXRlQWRhcHRlciB9IGZyb20gXCIuLi8uLi8uLi9tYXQtZGF0ZXBpY2tlci9zaGFyZWQvYWRhcHRlci9kYXRlLWFkYXB0ZXJcIjtcblxuQEluamVjdGFibGUoKVxuZXhwb3J0IGNsYXNzIE1heFJhbmdlU2VsZWN0aW9uU3RyYXRlZ3k8RD4gaW1wbGVtZW50cyBNYXREYXRlUmFuZ2VTZWxlY3Rpb25TdHJhdGVneTxEPiB7XG5cbiAgICBzdGFydDogYW55O1xuXG4gICAgcHVibGljIGRlbHRhOiBudW1iZXI7XG5cbiAgICBjb25zdHJ1Y3Rvcihwcml2YXRlIF9kYXRlQWRhcHRlcjogRGF0ZUFkYXB0ZXI8RD4pIHsgfVxuXG4gICAgc2VsZWN0aW9uRmluaXNoZWQoZGF0ZTogRCwgY3VycmVudFJhbmdlOiBEYXRlUmFuZ2U8RD4pIHtcbiAgICAgICAgbGV0IHsgc3RhcnQsIGVuZCB9ID0gY3VycmVudFJhbmdlO1xuXG4gICAgICAgIGlmIChzdGFydCA9PSBudWxsKSB7XG4gICAgICAgICAgICBzdGFydCA9IGRhdGU7XG4gICAgICAgIH0gZWxzZSBpZiAoZW5kID09IG51bGwgJiYgZGF0ZSAmJiB0aGlzLl9kYXRlQWRhcHRlci5jb21wYXJlRGF0ZShkYXRlLCBzdGFydCkgPj0gMCkge1xuICAgICAgICAgICAgY29uc3QgbWF4RGF0ZSA9IHRoaXMuX2RhdGVBZGFwdGVyLmFkZENhbGVuZGFyRGF5cyhzdGFydCwgKHRoaXMuZGVsdGEgLSAxKSk7XG4gICAgICAgICAgICBlbmQgPSAoZGF0ZSA+IG1heERhdGUpID8gbWF4RGF0ZSA6IGRhdGU7XG4gICAgICAgIH0gZWxzZSB7XG4gICAgICAgICAgICBzdGFydCA9IGRhdGU7XG4gICAgICAgICAgICBlbmQgPSBudWxsO1xuICAgICAgICB9XG5cbiAgICAgICAgcmV0dXJuIG5ldyBEYXRlUmFuZ2U8RD4oc3RhcnQsIGVuZCk7XG4gICAgfVxuXG4gICAgY3JlYXRlUHJldmlldyhhY3RpdmVEYXRlOiBEIHwgbnVsbCwgY3VycmVudFJhbmdlOiBEYXRlUmFuZ2U8RD4pOiBEYXRlUmFuZ2U8RD4ge1xuICAgICAgICBpZiAoY3VycmVudFJhbmdlLnN0YXJ0ICYmICFjdXJyZW50UmFuZ2UuZW5kKSB7XG4gICAgICAgICAgICBjb25zdCBtYXhEYXRlID0gdGhpcy5fZGF0ZUFkYXB0ZXIuYWRkQ2FsZW5kYXJEYXlzKGN1cnJlbnRSYW5nZS5zdGFydCwgKHRoaXMuZGVsdGEgLSAxKSk7XG4gICAgICAgICAgICBjb25zdCByYW5nZUVuZCA9IGFjdGl2ZURhdGUgPyAoYWN0aXZlRGF0ZSA+IG1heERhdGUpID8gbWF4RGF0ZSA6IGFjdGl2ZURhdGUgOiBudWxsO1xuICAgICAgICAgICAgcmV0dXJuIG5ldyBEYXRlUmFuZ2UoY3VycmVudFJhbmdlLnN0YXJ0LCByYW5nZUVuZCk7XG4gICAgICAgIH1cblxuICAgICAgICByZXR1cm4gbmV3IERhdGVSYW5nZTxEPihudWxsLCBudWxsKTtcbiAgICB9XG5cbn1cbiJdfQ==

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

@@ -0,0 +1,40 @@
+import { __decorate, __metadata, __param } from "tslib";
+import { Directive, Inject, Input } from '@angular/core';
+import { MAT_DATE_RANGE_SELECTION_STRATEGY } from '../../../mat-datepicker/date-range-selection-strategy';
+import { MaxRangeSelectionStrategy } from './max-range-selection-startegy';
+var MaxRangeDirective = /** @class */ (function () {
+    function MaxRangeDirective(maxRangeStrategy) {
+        this.maxRangeStrategy = maxRangeStrategy;
+    }
+    Object.defineProperty(MaxRangeDirective.prototype, "maxRange", {
+        set: function (value) {
+            this.maxRangeStrategy.delta = +value || 365;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    MaxRangeDirective.ctorParameters = function () { return [
+        { type: MaxRangeSelectionStrategy, decorators: [{ type: Inject, args: [MAT_DATE_RANGE_SELECTION_STRATEGY,] }] }
+    ]; };
+    __decorate([
+        Input(),
+        __metadata("design:type", Number),
+        __metadata("design:paramtypes", [Number])
+    ], MaxRangeDirective.prototype, "maxRange", null);
+    MaxRangeDirective = __decorate([
+        Directive({
+            selector: '[maxRange]',
+            providers: [
+                {
+                    provide: MAT_DATE_RANGE_SELECTION_STRATEGY,
+                    useClass: MaxRangeSelectionStrategy,
+                }
+            ]
+        }),
+        __param(0, Inject(MAT_DATE_RANGE_SELECTION_STRATEGY)),
+        __metadata("design:paramtypes", [MaxRangeSelectionStrategy])
+    ], MaxRangeDirective);
+    return MaxRangeDirective;
+}());
+export { MaxRangeDirective };
+//# sourceMappingURL=data:application/json;base64,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