@gipisistemas/ng-core 1.1.0 → 1.1.1

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

@@ -0,0 +1,35 @@
+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';
+let MaxRangeDirective = class MaxRangeDirective {
+    constructor(maxRangeStrategy) {
+        this.maxRangeStrategy = maxRangeStrategy;
+    }
+    set maxRange(value) {
+        this.maxRangeStrategy.delta = +value || 365;
+    }
+};
+MaxRangeDirective.ctorParameters = () => [
+    { 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);
+export { MaxRangeDirective };
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,259 @@
+var PresetRangeComponent_1;
+import { __decorate, __metadata } 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';
+const 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';
+let PresetRangeComponent = PresetRangeComponent_1 = class PresetRangeComponent {
+    constructor(_changeDetectorRef) {
+        this._changeDetectorRef = _changeDetectorRef;
+        this._destroy$ = new Subject();
+        this.rangesArray = [];
+        this.selectedRange = '';
+        this.matDateRangeInput = null;
+        this.matCalendar = null;
+        this.matDateRangePicker = null;
+        this._customRangeLabel = 'Personalizado';
+    }
+    get customRangeLabel() {
+        return this._customRangeLabel;
+    }
+    set customRangeLabel(value) {
+        this._customRangeLabel = value;
+    }
+    get ranges() {
+        return this._ranges;
+    }
+    set ranges(value) {
+        this._ranges = value;
+        this._renderRanges();
+    }
+    get maxRange() {
+        return this._maxRange;
+    }
+    set maxRange(value) {
+        this._maxRange = value;
+    }
+    get _startDate() {
+        const selectedRange = this.matCalendar.selected;
+        return selectedRange.start;
+    }
+    get _endDate() {
+        const selectedRange = this.matCalendar.selected;
+        return selectedRange.end;
+    }
+    get _minDate() {
+        return this.matCalendar.minDate;
+    }
+    get _maxDate() {
+        return this.matCalendar.maxDate;
+    }
+    ngOnInit() {
+        this.matCalendar.stateChanges
+            .pipe(takeUntil(this._destroy$))
+            .subscribe(() => {
+            this._loadSelectedRange();
+            this._changeDetectorRef.markForCheck();
+        });
+        this._loadSelectedRange();
+    }
+    ngOnDestroy() {
+        this._destroy$.next();
+    }
+    _renderRanges() {
+        let start;
+        let end;
+        if (typeof this.ranges === 'object') {
+            for (const 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]);
+                    }
+                    const minDate = moment(this._minDate).clone();
+                    let 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 (const range in this.ranges) {
+                if (this.ranges[range]) {
+                    this.rangesArray.push(range);
+                }
+            }
+        }
+        this._loadSelectedRange();
+    }
+    _loadSelectedRange() {
+        let customRange = true;
+        let i = 0;
+        if (this.rangesArray.length > 0) {
+            const startDate = moment(this._startDate).startOf('day');
+            const endDate = moment(this._endDate).startOf('day');
+            for (const range in this.ranges) {
+                if (this.ranges[range]) {
+                    const startRange = (this.ranges[range][0]).startOf('day');
+                    const 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;
+        }
+    }
+    _calculateDateRange(range) {
+        const minDate = this._minDate ? moment(this._minDate) : null;
+        const maxDate = this._maxDate ? moment(this._maxDate) : null;
+        const [start, end] = [this.ranges[range][0], this.ranges[range][1]];
+        let startDateResp = null;
+        let 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) {
+            const selectedRange = this.matCalendar.selected;
+            startDateResp = selectedRange.start;
+            endDateResp = selectedRange.end;
+        }
+        return [this._getValidDateOrNull(startDateResp.toDate()), this._getValidDateOrNull(endDateResp.toDate())];
+    }
+    _getValidDateOrNull(obj) {
+        return this._isDateInstance(obj) && this._isValid(obj) ? obj : null;
+    }
+    _isDateInstance(obj) {
+        return obj instanceof Date;
+    }
+    _isValid(date) {
+        return !isNaN(date.getTime());
+    }
+    clickRange(event, range) {
+        if (range === this.customRangeLabel) {
+            return;
+        }
+        const [start, end] = this._calculateDateRange(range);
+        // (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();
+    }
+    isDisableRange(range) {
+        if (range === this._customRangeLabel) {
+            return false;
+        }
+        const rangeMarkers = this._ranges[range];
+        const areBothBefore = rangeMarkers.every((date) => {
+            const minDate = moment(this.matCalendar.minDate);
+            if (!minDate) {
+                return false;
+            }
+            return moment(date).isBefore(minDate);
+        });
+        const areBothAfter = rangeMarkers.every((date) => {
+            const maxDate = moment(this.matCalendar.maxDate);
+            if (!maxDate) {
+                return false;
+            }
+            return moment(date).isAfter(maxDate);
+        });
+        return areBothBefore || areBothAfter;
+    }
+};
+PresetRangeComponent.ctorParameters = () => [
+    { 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(() => 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);
+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/esm2015/shared/gipi-components/datepicker/datepicker/datepicker.component.js

@@ -0,0 +1,218 @@
+var DatepickerComponent_1;
+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';
+const moment = moment_;
+import { BrowserUtil } from '../../../../core/utils/browser.util';
+import { DateUtil } from '../../../../core/utils/date.util';
+import { MatDatepickerToggle } from '../mat-datepicker/datepicker-toggle';
+let nextUniqueId = 0;
+let DatepickerComponent = DatepickerComponent_1 = class DatepickerComponent {
+    constructor(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 = () => { };
+        this.onTouched = () => { };
+    }
+    get minDate() {
+        return this._minDate;
+    }
+    set minDate(value) {
+        this._minDate = value;
+        this._minDate.setHours(0, 0, 0, 0);
+    }
+    get maxDate() {
+        return this._maxDate;
+    }
+    set maxDate(value) {
+        this._maxDate = value;
+        this._maxDate.setHours(0, 0, 0, 0);
+    }
+    get required() {
+        return this._required;
+    }
+    set required(value) {
+        this._required = coerceBooleanProperty(value);
+    }
+    get readonly() {
+        return this._readonly;
+    }
+    set readonly(value) {
+        this._readonly = coerceBooleanProperty(value);
+    }
+    get disabled() {
+        return this._disabled;
+    }
+    set disabled(value) {
+        this._disabled = coerceBooleanProperty(value);
+    }
+    get dateFilter() {
+        return this._dateFilter;
+    }
+    set dateFilter(value) {
+        this._dateFilter = value;
+    }
+    get value() {
+        return this._value;
+    }
+    set value(value) {
+        this._value = value;
+        this.onChange(this._value);
+        this.onTouched(this._value);
+    }
+    get formattedValue() {
+        return '';
+    }
+    ngOnInit() { }
+    ngOnDestroy() { }
+    writeValue(value) {
+        this._value = value;
+        this._changeDetectorRef.detectChanges();
+    }
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    setDisabledState(isDisabled) {
+        this.disabled = isDisabled;
+        this._changeDetectorRef.markForCheck();
+    }
+    onInputContentClick(event) {
+        if (!this.readonly || !this.matDatepickerToggleRef) {
+            return;
+        }
+    }
+    generatedDate(valueDate, keyUp) {
+        if (!keyUp && BrowserUtil.getBrowser() === 'Firefox') {
+            return;
+        }
+        let 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;
+            }
+        }
+    }
+    validateMinAndMaxDate(valueDate) {
+        const 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);
+        }
+    }
+};
+DatepickerComponent.ctorParameters = () => [
+    { 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(() => 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);
+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"]}