@gipisistemas/ng-core 1.0.67 → 1.0.68

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

@@ -0,0 +1,291 @@
+import { __decorate, __metadata, __read } from "tslib";
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, forwardRef, Input, OnDestroy, OnInit } from '@angular/core';
+import { Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import * as moment_ from 'moment';
+var moment = moment_;
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { MatCalendar } from '../../../mat-datepicker/calendar';
+import { MatDateRangeInput } from '../../../mat-datepicker/date-range-input';
+import { MatDateRangePicker } from '../../../mat-datepicker/date-range-picker';
+var PresetRangeComponent = /** @class */ (function () {
+    function PresetRangeComponent(_changeDetectorRef) {
+        this._changeDetectorRef = _changeDetectorRef;
+        this._destroy$ = new Subject();
+        this.rangesArray = [];
+        this.selectedRange = '';
+        this.matDateRangeInput = null;
+        this.matCalendar = null;
+        this.matDateRangePicker = null;
+        this._customRangeLabel = 'Personalizado';
+    }
+    PresetRangeComponent_1 = PresetRangeComponent;
+    Object.defineProperty(PresetRangeComponent.prototype, "customRangeLabel", {
+        get: function () {
+            return this._customRangeLabel;
+        },
+        set: function (value) {
+            this._customRangeLabel = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(PresetRangeComponent.prototype, "ranges", {
+        get: function () {
+            return this._ranges;
+        },
+        set: function (value) {
+            this._ranges = value;
+            this._renderRanges();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(PresetRangeComponent.prototype, "maxRange", {
+        get: function () {
+            return this._maxRange;
+        },
+        set: function (value) {
+            this._maxRange = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(PresetRangeComponent.prototype, "_startDate", {
+        get: function () {
+            var selectedRange = this.matCalendar.selected;
+            return selectedRange.start;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(PresetRangeComponent.prototype, "_endDate", {
+        get: function () {
+            var selectedRange = this.matCalendar.selected;
+            return selectedRange.end;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(PresetRangeComponent.prototype, "_minDate", {
+        get: function () {
+            return this.matCalendar.minDate;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(PresetRangeComponent.prototype, "_maxDate", {
+        get: function () {
+            return this.matCalendar.maxDate;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    PresetRangeComponent.prototype.ngOnInit = function () {
+        var _this = this;
+        this.matCalendar.stateChanges
+            .pipe(takeUntil(this._destroy$))
+            .subscribe(function () {
+            _this._loadSelectedRange();
+            _this._changeDetectorRef.markForCheck();
+        });
+        this._loadSelectedRange();
+    };
+    PresetRangeComponent.prototype.ngOnDestroy = function () {
+        this._destroy$.next();
+    };
+    PresetRangeComponent.prototype._renderRanges = function () {
+        var start;
+        var end;
+        if (typeof this.ranges === 'object') {
+            for (var range in this.ranges) {
+                if (this.ranges[range]) {
+                    // Start date
+                    if (typeof this.ranges[range][0] === 'string') {
+                        start = moment(this.ranges[range][0]);
+                    }
+                    else {
+                        start = moment(this.ranges[range][0]);
+                    }
+                    if (typeof this.ranges[range][1] === 'string') {
+                        end = moment(this.ranges[range][1]);
+                    }
+                    else {
+                        end = moment(this.ranges[range][1]);
+                    }
+                    var minDate = moment(this._minDate).clone();
+                    var maxDate = moment(this._maxDate).clone();
+                    if (minDate.isValid() && start.isBefore(minDate)) {
+                        start = minDate.clone();
+                    }
+                    if (maxDate.isValid() && start.clone().add((this.maxRange - 1), 'days').isAfter(maxDate)) {
+                        maxDate = start;
+                    }
+                    if (maxDate.isValid() && end.isAfter(maxDate)) {
+                        end = maxDate.clone();
+                    }
+                    if ((minDate && end.isBefore(minDate, 'day')) ||
+                        (maxDate && start.isAfter(maxDate, 'day'))) {
+                        continue;
+                    }
+                    this.ranges[range] = [start, end];
+                }
+            }
+            for (var range in this.ranges) {
+                if (this.ranges[range]) {
+                    this.rangesArray.push(range);
+                }
+            }
+        }
+        this._loadSelectedRange();
+    };
+    PresetRangeComponent.prototype._loadSelectedRange = function () {
+        var customRange = true;
+        var i = 0;
+        if (this.rangesArray.length > 0) {
+            var startDate = moment(this._startDate).startOf('day');
+            var endDate = moment(this._endDate).startOf('day');
+            for (var range in this.ranges) {
+                if (this.ranges[range]) {
+                    var startRange = (this.ranges[range][0]).startOf('day');
+                    var endRange = (this.ranges[range][1]).startOf('day');
+                    if (startDate.isSame(startRange) && endDate.isSame(endRange)) {
+                        customRange = false;
+                        this.selectedRange = this.rangesArray[i];
+                        break;
+                    }
+                    i++;
+                }
+            }
+            if (customRange) {
+                this.selectedRange = this.customRangeLabel;
+            }
+        }
+        else {
+            this.selectedRange = this.customRangeLabel;
+        }
+    };
+    PresetRangeComponent.prototype._calculateDateRange = function (range) {
+        var minDate = this._minDate ? moment(this._minDate) : null;
+        var maxDate = this._maxDate ? moment(this._maxDate) : null;
+        var _a = __read([this.ranges[range][0], this.ranges[range][1]], 2), start = _a[0], end = _a[1];
+        var startDateResp = null;
+        var endDateResp = null;
+        if (minDate && start.isBefore(minDate)) {
+            startDateResp = minDate.clone();
+        }
+        else {
+            startDateResp = start.clone();
+        }
+        if (maxDate && end.isAfter(maxDate)) {
+            endDateResp = maxDate.clone();
+        }
+        else {
+            endDateResp = end.clone();
+        }
+        if (range === this.customRangeLabel) {
+            var selectedRange = this.matCalendar.selected;
+            startDateResp = selectedRange.start;
+            endDateResp = selectedRange.end;
+        }
+        return [this._getValidDateOrNull(startDateResp.toDate()), this._getValidDateOrNull(endDateResp.toDate())];
+    };
+    PresetRangeComponent.prototype._getValidDateOrNull = function (obj) {
+        return this._isDateInstance(obj) && this._isValid(obj) ? obj : null;
+    };
+    PresetRangeComponent.prototype._isDateInstance = function (obj) {
+        return obj instanceof Date;
+    };
+    PresetRangeComponent.prototype._isValid = function (date) {
+        return !isNaN(date.getTime());
+    };
+    PresetRangeComponent.prototype.clickRange = function (event, range) {
+        if (range === this.customRangeLabel) {
+            return;
+        }
+        var _a = __read(this._calculateDateRange(range), 2), start = _a[0], end = _a[1];
+        // (this.matCalendar.selected as any).start = start;
+        // (this.matCalendar.selected as any).end = end;
+        // this.matCalendar.updateTodaysDate();
+        // this.matCalendar.activeDate = start;
+        // this.matCalendar.activeDate = end;
+        this.matDateRangePicker.select(start);
+        this.matDateRangePicker.select(end);
+        this.matDateRangePicker.close();
+    };
+    PresetRangeComponent.prototype.isDisableRange = function (range) {
+        var _this = this;
+        if (range === this._customRangeLabel) {
+            return false;
+        }
+        var rangeMarkers = this._ranges[range];
+        var areBothBefore = rangeMarkers.every(function (date) {
+            var minDate = moment(_this.matCalendar.minDate);
+            if (!minDate) {
+                return false;
+            }
+            return moment(date).isBefore(minDate);
+        });
+        var areBothAfter = rangeMarkers.every(function (date) {
+            var maxDate = moment(_this.matCalendar.maxDate);
+            if (!maxDate) {
+                return false;
+            }
+            return moment(date).isAfter(maxDate);
+        });
+        return areBothBefore || areBothAfter;
+    };
+    var PresetRangeComponent_1;
+    PresetRangeComponent.ctorParameters = function () { return [
+        { type: ChangeDetectorRef }
+    ]; };
+    __decorate([
+        Input(),
+        __metadata("design:type", MatDateRangeInput)
+    ], PresetRangeComponent.prototype, "matDateRangeInput", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", MatCalendar)
+    ], PresetRangeComponent.prototype, "matCalendar", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", MatDateRangePicker)
+    ], PresetRangeComponent.prototype, "matDateRangePicker", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String),
+        __metadata("design:paramtypes", [String])
+    ], PresetRangeComponent.prototype, "customRangeLabel", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", Object),
+        __metadata("design:paramtypes", [Object])
+    ], PresetRangeComponent.prototype, "ranges", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", Number),
+        __metadata("design:paramtypes", [Number])
+    ], PresetRangeComponent.prototype, "maxRange", null);
+    PresetRangeComponent = PresetRangeComponent_1 = __decorate([
+        Component({
+            selector: 'gipi-preset-range',
+            template: "<div class=\"preset-range-wrapper\">\n    <button *ngFor=\"let range of rangesArray\"\n            class=\"preset-range-btn\"\n            [class.selected]=\"range === selectedRange\"\n            [disabled]=\"isDisableRange(range)\"\n            (click)=\"clickRange($event, range)\">\n        {{ range }}\n    </button>\n    <button class=\"preset-range-btn\"\n            [disabled]=\"isDisableRange(customRangeLabel)\"\n            [class.selected]=\"selectedRange === customRangeLabel\">\n        {{ customRangeLabel }}\n    </button>\n</div>\n",
+            changeDetection: ChangeDetectionStrategy.OnPush,
+            providers: [
+                {
+                    provide: NG_VALUE_ACCESSOR,
+                    useExisting: forwardRef(function () { return PresetRangeComponent_1; }),
+                    multi: true
+                },
+            ],
+            host: {
+                'class': 'gipi-preset-range',
+            },
+            styles: [".preset-range-wrapper{display:flex;flex-direction:column;padding:.9rem;height:100%;background:#f0f0f0;border-top-left-radius:.6rem;border-bottom-left-radius:.6rem}.preset-range-btn{display:flex;align-items:center;justify-content:flex-start;padding:.8rem;height:3.6rem;border-radius:.6rem;background-color:transparent;outline:0;cursor:pointer;color:#595959;border:none;transition:.2s}.preset-range-btn.selected{background-color:#e0313e;color:#fff}.preset-range-btn.selected:hover{background-color:#9f232c}.preset-range-btn:hover{background-color:#e0313e;color:#fff}"]
+        }),
+        __metadata("design:paramtypes", [ChangeDetectorRef])
+    ], PresetRangeComponent);
+    return PresetRangeComponent;
+}());
+export { PresetRangeComponent };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"preset-range.component.js","sourceRoot":"ng://@gipisistemas/ng-core/","sources":["shared/gipi-components/datepicker/date-range-picker/shared/preset-range/preset-range.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectionStrategy, ChangeDetectorRef, Component, forwardRef, Input, OnDestroy, OnInit } from '@angular/core';\nimport { Subject } from 'rxjs';\nimport { takeUntil } from 'rxjs/operators';\n\nimport * as moment_ from 'moment';\nconst moment = moment_;\n\nimport { NG_VALUE_ACCESSOR } from '@angular/forms';\nimport { MatCalendar } from '../../../mat-datepicker/calendar';\nimport { MatDateRangeInput } from '../../../mat-datepicker/date-range-input';\nimport { MatDateRangePicker } from '../../../mat-datepicker/date-range-picker';\n\nexport interface PresetRanges<D> {\n    [index: string]: [D, D];\n}\n\n@Component({\n    selector: 'gipi-preset-range',\n    templateUrl: './preset-range.component.html',\n    styleUrls: ['./preset-range.component.scss'],\n    changeDetection: ChangeDetectionStrategy.OnPush,\n    providers: [\n        {\n            provide: NG_VALUE_ACCESSOR,\n            useExisting: forwardRef((): typeof PresetRangeComponent => PresetRangeComponent),\n            multi: true\n        },\n    ],\n    host: {\n        'class': 'gipi-preset-range',\n    }\n})\nexport class PresetRangeComponent implements OnInit, OnDestroy {\n\n    private readonly _destroy$: Subject<void> = new Subject();\n\n    public rangesArray: string[] = [];\n    public selectedRange: string = '';\n\n    @Input() matDateRangeInput: MatDateRangeInput<Date> = null;\n    @Input() matCalendar: MatCalendar<Date> = null;\n    @Input() matDateRangePicker: MatDateRangePicker<Date> = null;\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<moment.Moment>;\n    @Input() get ranges(): PresetRanges<moment.Moment> {\n        return this._ranges;\n    }\n    set ranges(value: PresetRanges<moment.Moment>) {\n        this._ranges = value;\n        this._renderRanges();\n    }\n\n    private _maxRange: number;\n    @Input() get maxRange(): number {\n        return this._maxRange;\n    }\n    set maxRange(value: number) {\n        this._maxRange = value;\n    }\n\n    private get _startDate(): Date {\n        const selectedRange: any = this.matCalendar.selected;\n        return selectedRange.start;\n    }\n\n    private get _endDate(): Date {\n        const selectedRange: any = this.matCalendar.selected;\n        return selectedRange.end;\n    }\n\n    private get _minDate(): Date {\n        return this.matCalendar.minDate;\n    }\n\n    private get _maxDate(): Date {\n        return this.matCalendar.maxDate;\n    }\n\n    constructor(private _changeDetectorRef: ChangeDetectorRef,) { }\n\n    ngOnInit(): void {\n        this.matCalendar.stateChanges\n            .pipe(takeUntil(this._destroy$))\n            .subscribe(() => {\n                this._loadSelectedRange();\n                this._changeDetectorRef.markForCheck();\n            });\n\n        this._loadSelectedRange();\n    }\n\n    ngOnDestroy(): void {\n        this._destroy$.next();\n    }\n\n    private _renderRanges(): void {\n        let start: moment.Moment;\n        let end: moment.Moment;\n\n        if (typeof this.ranges === 'object') {\n            for (const range in this.ranges) {\n                if (this.ranges[range]) {\n                    // Start date\n                    if (typeof this.ranges[range][0] === 'string') {\n                        start = moment(this.ranges[range][0]);\n                    } else {\n                        start = moment(this.ranges[range][0]);\n                    }\n\n                    if (typeof this.ranges[range][1] === 'string') {\n                        end = moment(this.ranges[range][1]);\n                    } else {\n                        end = moment(this.ranges[range][1]);\n                    }\n\n                    const minDate: moment.Moment = moment(this._minDate).clone();\n                    let maxDate: moment.Moment = moment(this._maxDate).clone();\n\n                    if (minDate.isValid() && start.isBefore(minDate)) {\n                        start = minDate.clone();\n                    }\n                    if (maxDate.isValid() && start.clone().add((this.maxRange - 1), 'days').isAfter(maxDate)) {\n                        maxDate = start;\n                    }\n                    if (maxDate.isValid() && end.isAfter(maxDate)) {\n                        end = maxDate.clone();\n                    }\n                    if (\n                        (minDate && end.isBefore(minDate, 'day')) ||\n                        (maxDate && start.isAfter(maxDate, 'day'))\n                    ) {\n                        continue;\n                    }\n\n                    this.ranges[range] = [start, end];\n                }\n            }\n\n            for (const range in this.ranges) {\n                if (this.ranges[range]) {\n                    this.rangesArray.push(range);\n                }\n            }\n        }\n\n        this._loadSelectedRange();\n    }\n\n    private _loadSelectedRange(): void {\n        let customRange: boolean = true;\n        let i: number = 0;\n        if (this.rangesArray.length > 0) {\n            const startDate: moment.Moment = moment(this._startDate).startOf('day');\n            const endDate: moment.Moment = moment(this._endDate).startOf('day');\n\n            for (const range in this.ranges) {\n                if (this.ranges[range]) {\n                    const startRange: moment.Moment = (this.ranges[range][0]).startOf('day');\n                    const endRange: moment.Moment = (this.ranges[range][1]).startOf('day');\n                    if (startDate.isSame(startRange) && endDate.isSame(endRange)) {\n                        customRange = false;\n                        this.selectedRange = this.rangesArray[i];\n                        break;\n                    }\n\n                    i++;\n                }\n            }\n            if (customRange) {\n                this.selectedRange = this.customRangeLabel;\n            }\n        } else {\n            this.selectedRange = this.customRangeLabel;\n        }\n    }\n\n    private _calculateDateRange(range: string): Date[] {\n        const minDate: moment.Moment = this._minDate ? moment(this._minDate) : null;\n        const maxDate: moment.Moment = this._maxDate ? moment(this._maxDate) : null;\n        const [start, end] = [this.ranges[range][0], this.ranges[range][1]];\n\n        let startDateResp: moment.Moment = null;\n        let endDateResp: moment.Moment = null;\n\n        if (minDate && start.isBefore(minDate)) {\n            startDateResp = minDate.clone();\n        } else {\n            startDateResp = start.clone();\n        }\n        if (maxDate && end.isAfter(maxDate)) {\n            endDateResp = maxDate.clone();\n        } else {\n            endDateResp = end.clone();\n        }\n\n        if (range === this.customRangeLabel) {\n            const selectedRange: any = this.matCalendar.selected;\n            startDateResp = selectedRange.start;\n            endDateResp = selectedRange.end;\n        }\n\n        return [this._getValidDateOrNull(startDateResp.toDate()), this._getValidDateOrNull(endDateResp.toDate())];\n    }\n\n    private _getValidDateOrNull(obj: unknown): Date | null {\n        return this._isDateInstance(obj) && this._isValid(obj as Date) ? obj as Date : null;\n    }\n\n    private _isDateInstance(obj: any): obj is Date {\n        return obj instanceof Date;\n    }\n\n    private _isValid(date: Date) {\n        return !isNaN(date.getTime());\n    }\n\n    public clickRange(event: MouseEvent, range: string): void {\n        if (range === this.customRangeLabel) {\n            return;\n        }\n\n        const [start, end] = this._calculateDateRange(range);\n        // (this.matCalendar.selected as any).start = start;\n        // (this.matCalendar.selected as any).end = end;\n        // this.matCalendar.updateTodaysDate();\n        // this.matCalendar.activeDate = start;\n        // this.matCalendar.activeDate = end;\n        this.matDateRangePicker.select(start);\n        this.matDateRangePicker.select(end);\n        this.matDateRangePicker.close();\n    }\n\n\n    public isDisableRange(range: string): boolean {\n        if (range === this._customRangeLabel) {\n            return false;\n        }\n\n        const rangeMarkers = this._ranges[range];\n        const areBothBefore = rangeMarkers.every((date) => {\n            const minDate: moment.Moment = moment(this.matCalendar.minDate);\n            if (!minDate) {\n                return false;\n            }\n            return moment(date).isBefore(minDate);\n\n        });\n\n        const areBothAfter = rangeMarkers.every((date) => {\n            const maxDate: moment.Moment = moment(this.matCalendar.maxDate);\n            if (!maxDate) {\n                return false;\n            }\n            return moment(date).isAfter(maxDate);\n        });\n\n        return areBothBefore || areBothAfter;\n    }\n\n}\n"]}

package/esm5/shared/gipi-components/datepicker/datepicker/datepicker.component.js

@@ -0,0 +1,252 @@
+import { __decorate, __metadata } from "tslib";
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { ChangeDetectorRef, Component, ElementRef, forwardRef, Input, OnDestroy, OnInit, ViewChild } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import * as moment_ from 'moment';
+var moment = moment_;
+import { BrowserUtil } from '../../../../core/utils/browser.util';
+import { DateUtil } from '../../../../core/utils/date.util';
+import { MatDatepickerToggle } from '../mat-datepicker/datepicker-toggle';
+var nextUniqueId = 0;
+var DatepickerComponent = /** @class */ (function () {
+    function DatepickerComponent(elementRef, _changeDetectorRef) {
+        this.elementRef = elementRef;
+        this._changeDetectorRef = _changeDetectorRef;
+        this._name = "gipi-date-range-" + nextUniqueId++;
+        this.id = this._name + "-date";
+        this.name = this._name + "-date";
+        this.label = '';
+        this.placeholder = '__/__/____';
+        this.help = '';
+        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 () { };
+    }
+    DatepickerComponent_1 = DatepickerComponent;
+    Object.defineProperty(DatepickerComponent.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(DatepickerComponent.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(DatepickerComponent.prototype, "required", {
+        get: function () {
+            return this._required;
+        },
+        set: function (value) {
+            this._required = coerceBooleanProperty(value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DatepickerComponent.prototype, "readonly", {
+        get: function () {
+            return this._readonly;
+        },
+        set: function (value) {
+            this._readonly = coerceBooleanProperty(value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DatepickerComponent.prototype, "disabled", {
+        get: function () {
+            return this._disabled;
+        },
+        set: function (value) {
+            this._disabled = coerceBooleanProperty(value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DatepickerComponent.prototype, "dateFilter", {
+        get: function () {
+            return this._dateFilter;
+        },
+        set: function (value) {
+            this._dateFilter = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DatepickerComponent.prototype, "value", {
+        get: function () {
+            return this._value;
+        },
+        set: function (value) {
+            this._value = value;
+            this.onChange(this._value);
+            this.onTouched(this._value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DatepickerComponent.prototype, "formattedValue", {
+        get: function () {
+            return '';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    DatepickerComponent.prototype.ngOnInit = function () { };
+    DatepickerComponent.prototype.ngOnDestroy = function () { };
+    DatepickerComponent.prototype.writeValue = function (value) {
+        this._value = value;
+        this._changeDetectorRef.detectChanges();
+    };
+    DatepickerComponent.prototype.registerOnChange = function (fn) {
+        this.onChange = fn;
+    };
+    DatepickerComponent.prototype.registerOnTouched = function (fn) {
+        this.onTouched = fn;
+    };
+    DatepickerComponent.prototype.setDisabledState = function (isDisabled) {
+        this.disabled = isDisabled;
+        this._changeDetectorRef.markForCheck();
+    };
+    DatepickerComponent.prototype.onInputContentClick = function (event) {
+        if (!this.readonly || !this.matDatepickerToggleRef) {
+            return;
+        }
+    };
+    DatepickerComponent.prototype.generatedDate = function (valueDate, keyUp) {
+        if (!keyUp && BrowserUtil.getBrowser() === 'Firefox') {
+            return;
+        }
+        var match = false;
+        if (valueDate.includes('/') && (!keyUp || valueDate.length === 10)) {
+            this.value = moment(valueDate, 'DD/MM/YYYY').toDate();
+            match = true;
+        }
+        else if (!valueDate.includes('/') && (!keyUp || valueDate.length === 8)) {
+            this.value = moment(valueDate, 'DDMMYYYY').toDate();
+            match = true;
+        }
+        if (BrowserUtil.getBrowser() !== 'Firefox') {
+            if (match && !DateUtil.isValid(this.value)) {
+                this.value = undefined;
+            }
+        }
+        else {
+            if (match && !this.value) {
+                this.value = undefined;
+            }
+        }
+    };
+    DatepickerComponent.prototype.validateMinAndMaxDate = function (valueDate) {
+        var dateInput = moment(valueDate, 'DD/MM/YYYY').toDate();
+        if (DateUtil.isLessThan(dateInput, this.minDate)) {
+            this.value = undefined;
+        }
+        else if (this.maxDate) {
+            this.value = (DateUtil.isGreaterThan(dateInput, this.maxDate) ? undefined : dateInput);
+        }
+    };
+    var DatepickerComponent_1;
+    DatepickerComponent.ctorParameters = function () { return [
+        { type: ElementRef },
+        { type: ChangeDetectorRef }
+    ]; };
+    __decorate([
+        ViewChild(MatDatepickerToggle, { static: true }),
+        __metadata("design:type", MatDatepickerToggle)
+    ], DatepickerComponent.prototype, "matDatepickerToggleRef", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], DatepickerComponent.prototype, "id", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], DatepickerComponent.prototype, "name", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], DatepickerComponent.prototype, "label", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], DatepickerComponent.prototype, "placeholder", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], DatepickerComponent.prototype, "help", void 0);
+    __decorate([
+        Input('min'),
+        __metadata("design:type", Date),
+        __metadata("design:paramtypes", [Date])
+    ], DatepickerComponent.prototype, "minDate", null);
+    __decorate([
+        Input('max'),
+        __metadata("design:type", Date),
+        __metadata("design:paramtypes", [Date])
+    ], DatepickerComponent.prototype, "maxDate", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean),
+        __metadata("design:paramtypes", [Boolean])
+    ], DatepickerComponent.prototype, "required", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean),
+        __metadata("design:paramtypes", [Boolean])
+    ], DatepickerComponent.prototype, "readonly", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean),
+        __metadata("design:paramtypes", [Boolean])
+    ], DatepickerComponent.prototype, "disabled", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Function])
+    ], DatepickerComponent.prototype, "dateFilter", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", Date),
+        __metadata("design:paramtypes", [Date])
+    ], DatepickerComponent.prototype, "value", null);
+    DatepickerComponent = DatepickerComponent_1 = __decorate([
+        Component({
+            selector: 'gipi-datepicker',
+            exportAs: 'gipiDatePicker',
+            template: "<div class=\"input-wrapper\">\n\n    <label *ngIf=\"label\"\n           class=\"input-label\"\n           [attr.for]=\"id\">\n        {{ label }}\n        <span *ngIf=\"required\"> * </span>\n    </label>\n\n    <div class=\"input-content\"\n         (click)=\"onInputContentClick($event)\">\n        <input matInput\n               class=\"input-element\"\n               type=\"text\"\n               [attr.id]=\"id\"\n               [attr.name]=\"name\"\n               [gipiMatDatepicker]=\"picker\"\n               [min]=\"minDate\"\n               [max]=\"maxDate\"\n               [maxlength]=\"10\"\n               [placeholder]=\"placeholder\"\n               [disabled]=\"disabled\"\n               [required]=\"required\"\n               [readOnly]=\"readonly\"\n               [autocomplete]=\"'off'\"\n               [autofocus]=\"false\"\n               [(ngModel)]=\"value\"\n               (keyup)=\"generatedDate($event.target.value, true)\"\n               (change)=\"generatedDate($event.target.value, false)\"\n               (blur)=\"validateMinAndMaxDate($event.target.value)\" />\n\n        <div class=\"suffix\">\n            <gipi-mat-datepicker-toggle [for]=\"picker\"> </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-datepicker #picker> </gipi-mat-datepicker>",
+            providers: [
+                {
+                    provide: NG_VALUE_ACCESSOR,
+                    useExisting: forwardRef(function () { return DatepickerComponent_1; }),
+                    multi: true
+                },
+            ],
+            host: {
+                'class': 'gipi-datepicker',
+            },
+            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}::-webkit-input-placeholder{color:#bbbdc1}:-moz-placeholder{color:#bbbdc1}::-moz-placeholder{color:#bbbdc1}:-ms-input-placeholder{color:#bbbdc1}"]
+        }),
+        __metadata("design:paramtypes", [ElementRef,
+            ChangeDetectorRef])
+    ], DatepickerComponent);
+    return DatepickerComponent;
+}());
+export { DatepickerComponent };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"datepicker.component.js","sourceRoot":"ng://@gipisistemas/ng-core/","sources":["shared/gipi-components/datepicker/datepicker/datepicker.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { coerceBooleanProperty } from '@angular/cdk/coercion';\nimport { ChangeDetectorRef, Component, ElementRef, forwardRef, Input, OnDestroy, OnInit, ViewChild } from '@angular/core';\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';\n\nimport * as moment_ from 'moment';\nconst moment = moment_;\n\nimport { BrowserUtil } from '../../../../core/utils/browser.util';\nimport { DateUtil } from '../../../../core/utils/date.util';\nimport { DateFilterFn } from '../mat-datepicker/datepicker-input-base';\nimport { MatDatepickerToggle } from '../mat-datepicker/datepicker-toggle';\n\nlet nextUniqueId = 0;\n\n@Component({\n    selector: 'gipi-datepicker',\n    exportAs: 'gipiDatePicker',\n    templateUrl: './datepicker.component.html',\n    styleUrls: ['./datepicker.component.scss'],\n    providers: [\n        {\n            provide: NG_VALUE_ACCESSOR,\n            useExisting: forwardRef((): typeof DatepickerComponent => DatepickerComponent),\n            multi: true\n        },\n    ],\n    host: {\n        'class': 'gipi-datepicker',\n    }\n})\nexport class DatepickerComponent implements OnInit, OnDestroy, ControlValueAccessor {\n\n    @ViewChild(MatDatepickerToggle, { static: true }) matDatepickerToggleRef: MatDatepickerToggle<Date>;\n\n    private _name: string = `gipi-date-range-${nextUniqueId++}`;\n\n    @Input() id: string = `${this._name}-date`;\n\n    @Input() name: string = `${this._name}-date`;\n\n    @Input() label: string = '';\n\n    @Input() placeholder: string = '__/__/____';\n\n    @Input() help: string = '';\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: Date;\n    @Input() get value(): Date {\n        return this._value;\n    }\n    set value(value: Date) {\n        this._value = value;\n        this.onChange(this._value);\n        this.onTouched(this._value);\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: Date): void {\n        this._value = value;\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\n    public generatedDate(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.value = moment(valueDate, 'DD/MM/YYYY').toDate();\n            match = true;\n        } else if (!valueDate.includes('/') && (!keyUp || valueDate.length === 8)) {\n            this.value = moment(valueDate, 'DDMMYYYY').toDate();\n            match = true;\n        }\n\n        if (BrowserUtil.getBrowser() !== 'Firefox') {\n            if (match && !DateUtil.isValid(this.value)) {\n                this.value = undefined;\n            }\n        } else {\n            if (match && !this.value) {\n                this.value = undefined;\n            }\n        }\n    }\n\n    public validateMinAndMaxDate(valueDate: string): void {\n        const dateInput = moment(valueDate, 'DD/MM/YYYY').toDate();\n        if (DateUtil.isLessThan(dateInput, this.minDate)) {\n            this.value = undefined;\n        } else if (this.maxDate) {\n            this.value = (DateUtil.isGreaterThan(dateInput, this.maxDate) ? undefined : dateInput);\n        }\n    }\n\n}\n"]}