@gipisistemas/ng-core 1.0.67 → 1.0.68

package/esm5/shared/gipi-components/month-year-picker/month-year-picker.component.js

@@ -0,0 +1,505 @@
+import { __decorate, __metadata, __param } from "tslib";
+import { Directionality } from '@angular/cdk/bidi';
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { ESCAPE, UP_ARROW } from '@angular/cdk/keycodes';
+import { FlexibleConnectedPositionStrategy, Overlay, OverlayConfig, OverlayRef, ScrollStrategy } from '@angular/cdk/overlay';
+import { ComponentPortal } from '@angular/cdk/portal';
+import { DOCUMENT } from '@angular/common';
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, ComponentRef, ElementRef, EventEmitter, forwardRef, Inject, InjectionToken, Input, NgZone, OnChanges, OnDestroy, OnInit, Optional, Output, SimpleChanges, ViewChild, ViewContainerRef } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { merge, Subject } from 'rxjs';
+import { filter, take } from 'rxjs/operators';
+import { ObjectUtil } from './../../../core/utils/object.util';
+import * as moment_ from 'moment';
+var moment = moment_;
+import { CalendarMonthYearComponent } from './calendar-month-year/calendar-month-year.component';
+export var GIPI_MONTH_YEAR_SCROLL_STRATEGY = new InjectionToken('gipi-month-year-scroll-strategy');
+/** @docs-private */
+export function GIPI_MONTH_YEAR_SCROLL_STRATEGY_FACTORY(overlay) {
+    return function () { return overlay.scrollStrategies.reposition(); };
+}
+/** @docs-private */
+export var GIPI_MONTH_YEAR_SCROLL_STRATEGY_FACTORY_PROVIDER = {
+    provide: GIPI_MONTH_YEAR_SCROLL_STRATEGY,
+    deps: [Overlay],
+    useFactory: GIPI_MONTH_YEAR_SCROLL_STRATEGY_FACTORY,
+};
+var MonthYear = /** @class */ (function () {
+    function MonthYear(month, year) {
+        this._month = month;
+        this._year = year;
+    }
+    Object.defineProperty(MonthYear.prototype, "date", {
+        get: function () {
+            var date = moment().day(1).month(this.month).year(this.year).startOf('day').toDate();
+            return date;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(MonthYear.prototype, "month", {
+        get: function () {
+            return this._month;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(MonthYear.prototype, "year", {
+        get: function () {
+            return this._year;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return MonthYear;
+}());
+export { MonthYear };
+var MonthPickerModel = /** @class */ (function () {
+    function MonthPickerModel() {
+        this.months = [];
+        this.selectedYearMoment = moment();
+        this.updateYearText();
+        this.selectedMonthMoment = moment();
+        this.months = moment.monthsShort().map(function (month) { return month + "."; });
+        this.selectedMonthIndex = this.selectedMonthMoment.month();
+        this.selectedMonthYear = this.selectedYearMoment.year();
+    }
+    MonthPickerModel.prototype.updateYearText = function () {
+        this.selectedYearText = !ObjectUtil.isNull(moment) ? moment(this.selectedYearMoment).format('YYYY') : '';
+    };
+    MonthPickerModel.prototype.selectMonth = function (index) {
+        this.selectedMonthMoment = moment().month(index);
+        this.selectedMonthIndex = this.selectedMonthMoment.month();
+        this.selectedMonthYear = this.selectedYearMoment.year();
+    };
+    MonthPickerModel.prototype.incrementYear = function () {
+        this.selectedYearMoment = this.selectedYearMoment.add(1, "year");
+        this.updateYearText();
+    };
+    MonthPickerModel.prototype.decrementYear = function () {
+        this.selectedYearMoment = this.selectedYearMoment.subtract(1, "year");
+        this.updateYearText();
+    };
+    return MonthPickerModel;
+}());
+export { MonthPickerModel };
+var nextUniqueId = 0;
+var MonthYearPickerComponent = /** @class */ (function () {
+    function MonthYearPickerComponent(elementRef, _changeDetectorRef, _overlay, _ngZone, _viewContainerRef, scrollStrategy, _dir, _document) {
+        this.elementRef = elementRef;
+        this._changeDetectorRef = _changeDetectorRef;
+        this._overlay = _overlay;
+        this._ngZone = _ngZone;
+        this._viewContainerRef = _viewContainerRef;
+        this._dir = _dir;
+        this._document = _document;
+        this._name = "gipi-date-range-" + nextUniqueId++;
+        this._focusedElementBeforeOpen = null;
+        this._backdropHarnessClass = this._name + "-backdrop";
+        this._stateChanges = new Subject();
+        this.valueLabel = '';
+        this.id = this._name + "-date";
+        this.name = this._name + "-date";
+        this.label = '';
+        this.placeholder = '';
+        this.help = '';
+        this.xPosition = 'start';
+        this.yPosition = 'below';
+        this.calendarView = 'both';
+        this._opened = false;
+        this._required = false;
+        this._disabled = false;
+        this._min = null;
+        this._max = null;
+        this.openedStream = new EventEmitter();
+        this.closedStream = new EventEmitter();
+        this.onChange = function () { };
+        this.onTouched = function () { };
+        this._scrollStrategy = scrollStrategy;
+    }
+    MonthYearPickerComponent_1 = MonthYearPickerComponent;
+    Object.defineProperty(MonthYearPickerComponent.prototype, "opened", {
+        get: function () {
+            return this._opened;
+        },
+        set: function (value) {
+            coerceBooleanProperty(value) ? this.open() : this.close();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(MonthYearPickerComponent.prototype, "required", {
+        get: function () {
+            return this._required;
+        },
+        set: function (value) {
+            this._required = coerceBooleanProperty(value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(MonthYearPickerComponent.prototype, "disabled", {
+        get: function () {
+            return this._disabled;
+        },
+        set: function (value) {
+            this._disabled = coerceBooleanProperty(value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(MonthYearPickerComponent.prototype, "min", {
+        get: function () {
+            return this._min;
+        },
+        set: function (value) {
+            this._min = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(MonthYearPickerComponent.prototype, "max", {
+        get: function () {
+            return this._max;
+        },
+        set: function (value) {
+            this._max = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(MonthYearPickerComponent.prototype, "value", {
+        get: function () {
+            return this._value;
+        },
+        set: function (value) {
+            var valueAux = value;
+            if (!value) {
+                valueAux = null;
+            }
+            if (valueAux) {
+                switch (this.calendarView) {
+                    case 'both': {
+                        this.valueLabel = moment(valueAux.date).format('MM/YYYY');
+                        break;
+                    }
+                    case 'year': {
+                        this.valueLabel = moment(valueAux.date).format('YYYY');
+                        break;
+                    }
+                    default: {
+                        this.valueLabel = moment(valueAux.date).format('MM/YYYY');
+                        break;
+                    }
+                }
+            }
+            this._value = valueAux;
+            this.onChange(this._value);
+            this.onTouched(this._value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    MonthYearPickerComponent.prototype.ngOnInit = function () {
+        this.model = new MonthPickerModel();
+        if (this.year) {
+            this.model.selectedYearMoment = moment().year(this.year);
+        }
+        if (this.month) {
+            this.model.selectedMonthIndex = this.month;
+            this.model.selectedMonthMoment = moment().month(this.month);
+            if (this.year) {
+                this.model.selectedMonthYear = this.year;
+            }
+        }
+        this.model.updateYearText();
+        if (ObjectUtil.isNull(this.month) && ObjectUtil.isNull(this.year)) {
+            this.value = null;
+            this._changeDetectorRef.detectChanges();
+        }
+        else {
+            this.onValueChange(this.model.selectedMonthIndex, this.model.selectedMonthYear);
+        }
+    };
+    MonthYearPickerComponent.prototype.ngOnChanges = function (changes) {
+        var positionChange = changes['xPosition'] || changes['yPosition'];
+        if (positionChange && !positionChange.firstChange && this._popupRef) {
+            this._setConnectedPositions(this._popupRef.getConfig().positionStrategy);
+            if (this.opened) {
+                this._popupRef.updatePosition();
+            }
+        }
+        this._stateChanges.next(undefined);
+    };
+    MonthYearPickerComponent.prototype.ngOnDestroy = function () {
+        this._destroyPopup();
+        this.close();
+        this._stateChanges.complete();
+    };
+    MonthYearPickerComponent.prototype.writeValue = function (value) {
+        this.value = value;
+        this._changeDetectorRef.detectChanges();
+    };
+    MonthYearPickerComponent.prototype.registerOnChange = function (fn) {
+        this.onChange = fn;
+    };
+    MonthYearPickerComponent.prototype.registerOnTouched = function (fn) {
+        this.onTouched = fn;
+    };
+    MonthYearPickerComponent.prototype.setDisabledState = function (isDisabled) {
+        this.disabled = isDisabled;
+        this._changeDetectorRef.markForCheck();
+    };
+    MonthYearPickerComponent.prototype.onValueChange = function (month, year) {
+        var monthYear = new MonthYear(month, year);
+        this.value = monthYear;
+        this._changeDetectorRef.detectChanges();
+    };
+    MonthYearPickerComponent.prototype.open = function () {
+        if (this._opened || this.disabled) {
+            return;
+        }
+        if (!this.inputMonthYearContentRef) {
+            throw Error('Attempted to open an MonthYearPicker with no associated input.');
+        }
+        if (this._document) {
+            this._focusedElementBeforeOpen = this._document.activeElement;
+        }
+        this._openAsPopup();
+        this._opened = true;
+        this.openedStream.emit();
+    };
+    MonthYearPickerComponent.prototype.close = function () {
+        var _this = this;
+        if (!this._opened) {
+            return;
+        }
+        if (this._popupComponentRef && this._popupRef) {
+            var instance = this._popupComponentRef.instance;
+            instance._startExitAnimation();
+            instance._animationDone.pipe(take(1)).subscribe(function () { return _this._destroyPopup(); });
+        }
+        var completeClose = function () {
+            if (_this._opened) {
+                _this._opened = false;
+                _this.closedStream.emit();
+                _this._focusedElementBeforeOpen = null;
+            }
+        };
+        if (this._focusedElementBeforeOpen &&
+            typeof this._focusedElementBeforeOpen.focus === 'function') {
+            this._focusedElementBeforeOpen.focus();
+            setTimeout(completeClose);
+        }
+        else {
+            completeClose();
+        }
+    };
+    MonthYearPickerComponent.prototype._openAsPopup = function () {
+        var _this = this;
+        var portal = new ComponentPortal(CalendarMonthYearComponent, this._viewContainerRef);
+        this._destroyPopup();
+        this._createPopup();
+        this._popupComponentRef = this._popupRef.attach(portal);
+        this._popupComponentRef.instance.monthYearPicker = this;
+        this._ngZone.onStable.pipe(take(1)).subscribe(function () {
+            _this._popupRef.updatePosition();
+        });
+    };
+    MonthYearPickerComponent.prototype._getConnectedOverlayOrigin = function () {
+        return this.inputMonthYearContentRef ? this.inputMonthYearContentRef : this.elementRef;
+    };
+    MonthYearPickerComponent.prototype._createPopup = function () {
+        var _this = this;
+        var positionStrategy = this._overlay.position()
+            .flexibleConnectedTo(this._getConnectedOverlayOrigin())
+            .withTransformOriginOn('.mat-datepicker-content')
+            .withFlexibleDimensions(false)
+            .withViewportMargin(8)
+            .withLockedPosition();
+        var overlayConfig = new OverlayConfig({
+            positionStrategy: this._setConnectedPositions(positionStrategy),
+            hasBackdrop: true,
+            backdropClass: ['mat-overlay-transparent-backdrop', this._backdropHarnessClass],
+            direction: this._dir || 'ltr',
+            scrollStrategy: this._scrollStrategy(),
+            panelClass: 'mat-month-year-picker-popup',
+        });
+        this._popupRef = this._overlay.create(overlayConfig);
+        this._popupRef.overlayElement.setAttribute('role', 'dialog');
+        merge(this._popupRef.backdropClick(), this._popupRef.detachments(), this._popupRef.keydownEvents().pipe(filter(function (event) { return event.keyCode === ESCAPE || (_this.inputMonthYearContentRef && event.altKey && event.keyCode === UP_ARROW); }))).subscribe(function (event) {
+            if (event) {
+                event.preventDefault();
+            }
+            _this.close();
+        });
+    };
+    MonthYearPickerComponent.prototype._destroyPopup = function () {
+        if (this._popupRef) {
+            this._popupRef.dispose();
+            this._popupRef = this._popupComponentRef = null;
+        }
+    };
+    MonthYearPickerComponent.prototype._setConnectedPositions = function (strategy) {
+        var primaryX = this.xPosition === 'end' ? 'end' : 'start';
+        var secondaryX = primaryX === 'start' ? 'end' : 'start';
+        var primaryY = this.yPosition === 'above' ? 'bottom' : 'top';
+        var secondaryY = primaryY === 'top' ? 'bottom' : 'top';
+        return strategy.withPositions([
+            {
+                originX: primaryX,
+                originY: secondaryY,
+                overlayX: primaryX,
+                overlayY: primaryY
+            },
+            {
+                originX: primaryX,
+                originY: primaryY,
+                overlayX: primaryX,
+                overlayY: secondaryY
+            },
+            {
+                originX: secondaryX,
+                originY: secondaryY,
+                overlayX: secondaryX,
+                overlayY: primaryY
+            },
+            {
+                originX: secondaryX,
+                originY: primaryY,
+                overlayX: secondaryX,
+                overlayY: secondaryY
+            }
+        ]);
+    };
+    var MonthYearPickerComponent_1;
+    MonthYearPickerComponent.ctorParameters = function () { return [
+        { type: ElementRef },
+        { type: ChangeDetectorRef },
+        { type: Overlay },
+        { type: NgZone },
+        { type: ViewContainerRef },
+        { type: undefined, decorators: [{ type: Inject, args: [GIPI_MONTH_YEAR_SCROLL_STRATEGY,] }] },
+        { type: Directionality, decorators: [{ type: Optional }] },
+        { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [DOCUMENT,] }] }
+    ]; };
+    __decorate([
+        ViewChild('inputMonthYearContent', { static: false, }),
+        __metadata("design:type", ElementRef)
+    ], MonthYearPickerComponent.prototype, "inputMonthYearContentRef", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], MonthYearPickerComponent.prototype, "id", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], MonthYearPickerComponent.prototype, "name", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], MonthYearPickerComponent.prototype, "label", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], MonthYearPickerComponent.prototype, "placeholder", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], MonthYearPickerComponent.prototype, "help", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], MonthYearPickerComponent.prototype, "locale", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Number)
+    ], MonthYearPickerComponent.prototype, "year", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Number)
+    ], MonthYearPickerComponent.prototype, "month", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean)
+    ], MonthYearPickerComponent.prototype, "multiple", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], MonthYearPickerComponent.prototype, "xPosition", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], MonthYearPickerComponent.prototype, "yPosition", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], MonthYearPickerComponent.prototype, "calendarView", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean),
+        __metadata("design:paramtypes", [Boolean])
+    ], MonthYearPickerComponent.prototype, "opened", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean),
+        __metadata("design:paramtypes", [Boolean])
+    ], MonthYearPickerComponent.prototype, "required", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", Boolean),
+        __metadata("design:paramtypes", [Boolean])
+    ], MonthYearPickerComponent.prototype, "disabled", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", MonthYear),
+        __metadata("design:paramtypes", [MonthYear])
+    ], MonthYearPickerComponent.prototype, "min", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", MonthYear),
+        __metadata("design:paramtypes", [MonthYear])
+    ], MonthYearPickerComponent.prototype, "max", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", MonthYear),
+        __metadata("design:paramtypes", [MonthYear])
+    ], MonthYearPickerComponent.prototype, "value", null);
+    __decorate([
+        Output('opened'),
+        __metadata("design:type", EventEmitter)
+    ], MonthYearPickerComponent.prototype, "openedStream", void 0);
+    __decorate([
+        Output('closed'),
+        __metadata("design:type", EventEmitter)
+    ], MonthYearPickerComponent.prototype, "closedStream", void 0);
+    MonthYearPickerComponent = MonthYearPickerComponent_1 = __decorate([
+        Component({
+            selector: 'gipi-month-year-picker',
+            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         #inputMonthYearContent\n         (click)=\"open()\">\n        <input matInput\n               class=\"input-element\"\n               type=\"text\"\n               [attr.id]=\"id\"\n               [attr.name]=\"name\"\n               [placeholder]=\"placeholder\"\n               [disabled]=\"disabled\"\n               [required]=\"required\"\n               [readOnly]=\"true\"\n               [autocomplete]=\"'off'\"\n               [autofocus]=\"false\"\n               [ngModel]=\"valueLabel\"\n               (click)=\"open()\" />\n\n        <div class=\"suffix\">\n            <button #button\n                    mat-icon-button\n                    type=\"button\"\n                    class=\"btn-month-year-toggle\"\n                    [attr.aria-label]=\"'Abrir calend\u00E1rio mensal'\"\n                    [disabled]=\"disabled\"\n                    (click)=\"open()\">\n                <svg class=\"month-year-toggle-default-icon\"\n                     viewBox=\"0 0 24 24\"\n                     width=\"24px\"\n                     height=\"24px\"\n                     fill=\"currentColor\"\n                     focusable=\"false\">\n                    <path\n                          d=\"M19 3h-1V1h-2v2H8V1H6v2H5c-1.11 0-1.99.9-1.99 2L3 19c0 1.1.89 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16H5V8h14v11zM7 10h5v5H7z\" />\n                </svg>\n            </button>\n        </div>\n    </div>\n\n    <small *ngIf=\"help\"\n           class=\"input-help\">\n        {{ help }}\n    </small>\n</div>\n",
+            providers: [
+                {
+                    provide: NG_VALUE_ACCESSOR,
+                    useExisting: forwardRef(function () { return MonthYearPickerComponent_1; }),
+                    multi: true
+                },
+            ],
+            host: {
+                'class': 'gipi-month-year-picker',
+            },
+            changeDetection: ChangeDetectionStrategy.OnPush,
+            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.ng-invalid:enabled:hover),.input-wrapper .input-content:not(.input-element:disabled):has(.input-element:invalid:enabled:hover){border-color:#e07f62}.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:not(.input-element:disabled):has(.input-element.ng-invalid:enabled),.input-wrapper .input-content:not(.input-element:disabled):has(.input-element:invalid:enabled){border-color:#d14014}.input-wrapper .input-content:not(.input-element:disabled):has(.input-element.ng-invalid:enabled:focus),.input-wrapper .input-content:not(.input-element:disabled):has(.input-element:invalid:enabled:focus){outline:0;outline-offset:0;box-shadow:0 0 0 .2rem #f1c4b6;border-color:#d14014}.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}.month-year-toggle-default-icon{display:block;width:1.5em;height:1.5em}.mat-icon-button .month-year-toggle-default-icon{margin:auto}.btn-month-year-toggle{width:2rem!important;height:2rem!important;line-height:2rem!important}"]
+        }),
+        __param(5, Inject(GIPI_MONTH_YEAR_SCROLL_STRATEGY)),
+        __param(6, Optional()),
+        __param(7, Optional()), __param(7, Inject(DOCUMENT)),
+        __metadata("design:paramtypes", [ElementRef,
+            ChangeDetectorRef,
+            Overlay,
+            NgZone,
+            ViewContainerRef, Object, Directionality, Object])
+    ], MonthYearPickerComponent);
+    return MonthYearPickerComponent;
+}());
+export { MonthYearPickerComponent };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"month-year-picker.component.js","sourceRoot":"ng://@gipisistemas/ng-core/","sources":["shared/gipi-components/month-year-picker/month-year-picker.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directionality } from '@angular/cdk/bidi';\nimport { coerceBooleanProperty } from '@angular/cdk/coercion';\nimport { ESCAPE, UP_ARROW } from '@angular/cdk/keycodes';\nimport { FlexibleConnectedPositionStrategy, Overlay, OverlayConfig, OverlayRef, ScrollStrategy } from '@angular/cdk/overlay';\nimport { ComponentPortal } from '@angular/cdk/portal';\nimport { DOCUMENT } from '@angular/common';\nimport { ChangeDetectionStrategy, ChangeDetectorRef, Component, ComponentRef, ElementRef, EventEmitter, forwardRef, Inject, InjectionToken, Input, NgZone, OnChanges, OnDestroy, OnInit, Optional, Output, SimpleChanges, ViewChild, ViewContainerRef } from '@angular/core';\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';\nimport { merge, Subject } from 'rxjs';\nimport { filter, take } from 'rxjs/operators';\nimport { ObjectUtil } from './../../../core/utils/object.util';\n\nimport * as moment_ from 'moment';\nconst moment = moment_;\n\nimport { CalendarMonthYearComponent } from './calendar-month-year/calendar-month-year.component';\n\n\nexport const GIPI_MONTH_YEAR_SCROLL_STRATEGY = new InjectionToken<() => ScrollStrategy>('gipi-month-year-scroll-strategy');\n\n/** @docs-private */\nexport function GIPI_MONTH_YEAR_SCROLL_STRATEGY_FACTORY(overlay: Overlay): () => ScrollStrategy {\n    return () => overlay.scrollStrategies.reposition();\n}\n\n/** @docs-private */\nexport const GIPI_MONTH_YEAR_SCROLL_STRATEGY_FACTORY_PROVIDER = {\n    provide: GIPI_MONTH_YEAR_SCROLL_STRATEGY,\n    deps: [Overlay],\n    useFactory: GIPI_MONTH_YEAR_SCROLL_STRATEGY_FACTORY,\n};\n\n\nexport class MonthYear {\n    private _month: number;\n    private _year: number;\n\n    public get date(): Date {\n        const date = moment().day(1).month(this.month).year(this.year).startOf('day').toDate();\n        return date;\n    }\n\n    public get month(): number {\n        return this._month;\n    }\n\n    public get year(): number {\n        return this._year;\n    }\n\n    constructor(month?: number, year?: number) {\n        this._month = month;\n        this._year = year;\n    }\n}\n\nexport class MonthPickerModel {\n    selectedYearMoment: moment.Moment;\n    selectedYearText: string;\n\n    selectedMonthMoment: moment.Moment;\n    selectedMonthIndex: number;\n    selectedMonthYear: number;\n\n    months: Array<string> = [];\n\n    constructor() {\n        this.selectedYearMoment = moment();\n        this.updateYearText();\n\n        this.selectedMonthMoment = moment();\n\n        this.months = moment.monthsShort().map(month => `${month}.`);\n\n        this.selectedMonthIndex = this.selectedMonthMoment.month();\n        this.selectedMonthYear = this.selectedYearMoment.year();\n    }\n\n    updateYearText() {\n        this.selectedYearText = !ObjectUtil.isNull(moment) ? moment(this.selectedYearMoment).format('YYYY') : '';\n    }\n\n    selectMonth(index: number) {\n        this.selectedMonthMoment = moment().month(index);\n        this.selectedMonthIndex = this.selectedMonthMoment.month();\n        this.selectedMonthYear = this.selectedYearMoment.year();\n    }\n\n    incrementYear() {\n        this.selectedYearMoment = this.selectedYearMoment.add(1, \"year\")\n        this.updateYearText();\n    }\n\n    decrementYear() {\n        this.selectedYearMoment = this.selectedYearMoment.subtract(1, \"year\")\n        this.updateYearText();\n    }\n}\n\nlet nextUniqueId = 0;\n\n@Component({\n    selector: 'gipi-month-year-picker',\n    templateUrl: './month-year-picker.component.html',\n    styleUrls: ['./month-year-picker.component.scss'],\n    providers: [\n        {\n            provide: NG_VALUE_ACCESSOR,\n            useExisting: forwardRef((): typeof MonthYearPickerComponent => MonthYearPickerComponent),\n            multi: true\n        },\n    ],\n    host: {\n        'class': 'gipi-month-year-picker',\n    },\n    changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class MonthYearPickerComponent implements OnInit, OnChanges, OnDestroy, ControlValueAccessor {\n\n    @ViewChild('inputMonthYearContent', { static: false, }) inputMonthYearContentRef: ElementRef;\n\n    private _name: string = `gipi-date-range-${nextUniqueId++}`;\n\n    private _scrollStrategy: () => ScrollStrategy;\n\n    private _popupRef: OverlayRef | null;\n    private _popupComponentRef: ComponentRef<CalendarMonthYearComponent> | null;\n    private _focusedElementBeforeOpen: HTMLElement | null = null;\n    private _backdropHarnessClass = `${this._name}-backdrop`;\n\n    readonly _stateChanges: Subject<void> = new Subject();\n\n    public valueLabel: string = '';\n\n    public model: MonthPickerModel;\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    @Input() locale: string;\n    @Input() year: number;\n    @Input() month: number;\n\n    // @Input() enabledMonths: Array<number> = [];\n    // @Input() disabledMonths: Array<number> = [];\n\n    // @Input() enabledYears: Array<number> = [];\n    // @Input() disabledYears: Array<number> = [];\n\n    @Input() multiple: boolean;\n\n    @Input() xPosition: 'start' | 'end' = 'start';\n\n    @Input() yPosition: 'above' | 'below' = 'below';\n\n    @Input() calendarView: 'both' | 'year' = 'both';\n\n    private _opened = false;\n    @Input() get opened(): boolean {\n        return this._opened;\n    }\n    set opened(value: boolean) {\n        coerceBooleanProperty(value) ? this.open() : this.close();\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 _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 _min: MonthYear = null;\n    @Input() get min(): MonthYear {\n        return this._min;\n    }\n    set min(value: MonthYear) {\n        this._min = value;\n    }\n\n    private _max: MonthYear = null;\n    @Input() get max(): MonthYear {\n        return this._max;\n    }\n    set max(value: MonthYear) {\n        this._max = value;\n    }\n\n    private _value: MonthYear;\n    @Input() get value(): MonthYear {\n        return this._value;\n    }\n    set value(value: MonthYear) {\n        let valueAux: MonthYear = value;\n        if (!value) {\n            valueAux = null;\n        }\n        if (valueAux) {\n            switch (this.calendarView) {\n                case 'both': {\n                    this.valueLabel = moment(valueAux.date).format('MM/YYYY');\n                    break;\n                }\n                case 'year': {\n                    this.valueLabel = moment(valueAux.date).format('YYYY');\n                    break;\n                }\n                default: {\n                    this.valueLabel = moment(valueAux.date).format('MM/YYYY');\n                    break;\n                }\n            }\n        }\n\n        this._value = valueAux;\n\n        this.onChange(this._value);\n        this.onTouched(this._value);\n    }\n\n    @Output('opened') openedStream: EventEmitter<void> = new EventEmitter<void>();\n    @Output('closed') closedStream: EventEmitter<void> = new EventEmitter<void>();\n\n    onChange: Function = () => { };\n\n    onTouched: Function = () => { };\n\n    constructor(\n        public elementRef: ElementRef,\n        private _changeDetectorRef: ChangeDetectorRef,\n        private _overlay: Overlay,\n        private _ngZone: NgZone,\n        private _viewContainerRef: ViewContainerRef,\n        @Inject(GIPI_MONTH_YEAR_SCROLL_STRATEGY) scrollStrategy: any,\n        @Optional() private _dir: Directionality,\n        @Optional() @Inject(DOCUMENT) private _document: any,\n    ) {\n        this._scrollStrategy = scrollStrategy;\n    }\n\n    ngOnInit(): void {\n        this.model = new MonthPickerModel();\n\n        if (this.year) {\n            this.model.selectedYearMoment = moment().year(this.year);\n        }\n\n        if (this.month) {\n            this.model.selectedMonthIndex = this.month;\n            this.model.selectedMonthMoment = moment().month(this.month);\n\n            if (this.year) {\n                this.model.selectedMonthYear = this.year;\n            }\n        }\n\n        this.model.updateYearText();\n        if (ObjectUtil.isNull(this.month) && ObjectUtil.isNull(this.year)) {\n            this.value = null;\n            this._changeDetectorRef.detectChanges();\n        } else {\n            this.onValueChange(this.model.selectedMonthIndex, this.model.selectedMonthYear);\n        }\n    }\n\n    ngOnChanges(changes: SimpleChanges): void {\n        const positionChange = changes['xPosition'] || changes['yPosition'];\n\n        if (positionChange && !positionChange.firstChange && this._popupRef) {\n            this._setConnectedPositions(this._popupRef.getConfig().positionStrategy as FlexibleConnectedPositionStrategy);\n\n            if (this.opened) {\n                this._popupRef.updatePosition();\n            }\n        }\n\n        this._stateChanges.next(undefined);\n    }\n\n    ngOnDestroy(): void {\n        this._destroyPopup();\n        this.close();\n        this._stateChanges.complete();\n    }\n\n    writeValue(value: MonthYear): 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 onValueChange(month: number, year: number) {\n        const monthYear: MonthYear = new MonthYear(month, year);\n        this.value = monthYear;\n        this._changeDetectorRef.detectChanges();\n    }\n\n    public open(): void {\n        if (this._opened || this.disabled) {\n            return;\n        }\n        if (!this.inputMonthYearContentRef) {\n            throw Error('Attempted to open an MonthYearPicker with no associated input.');\n        }\n        if (this._document) {\n            this._focusedElementBeforeOpen = this._document.activeElement;\n        }\n\n        this._openAsPopup();\n        this._opened = true;\n        this.openedStream.emit();\n    }\n\n    public close(): void {\n        if (!this._opened) {\n            return;\n        }\n        if (this._popupComponentRef && this._popupRef) {\n            const instance = this._popupComponentRef.instance;\n            instance._startExitAnimation();\n            instance._animationDone.pipe(take(1)).subscribe(() => this._destroyPopup());\n        }\n\n        const completeClose = () => {\n            if (this._opened) {\n                this._opened = false;\n                this.closedStream.emit();\n                this._focusedElementBeforeOpen = null;\n            }\n        };\n\n        if (this._focusedElementBeforeOpen &&\n            typeof this._focusedElementBeforeOpen.focus === 'function') {\n            this._focusedElementBeforeOpen.focus();\n            setTimeout(completeClose);\n        } else {\n            completeClose();\n        }\n    }\n\n    private _openAsPopup(): void {\n        const portal: ComponentPortal<CalendarMonthYearComponent> = new ComponentPortal<CalendarMonthYearComponent>(CalendarMonthYearComponent, this._viewContainerRef);\n\n        this._destroyPopup();\n        this._createPopup();\n        this._popupComponentRef = this._popupRef!.attach(portal);\n        this._popupComponentRef.instance.monthYearPicker = this;\n\n        this._ngZone.onStable.pipe(take(1)).subscribe(() => {\n            this._popupRef!.updatePosition();\n        });\n    }\n\n    private _getConnectedOverlayOrigin(): ElementRef {\n        return this.inputMonthYearContentRef ? this.inputMonthYearContentRef : this.elementRef;\n    }\n\n    private _createPopup(): void {\n        const positionStrategy = this._overlay.position()\n            .flexibleConnectedTo(this._getConnectedOverlayOrigin())\n            .withTransformOriginOn('.mat-datepicker-content')\n            .withFlexibleDimensions(false)\n            .withViewportMargin(8)\n            .withLockedPosition();\n\n        const overlayConfig = new OverlayConfig({\n            positionStrategy: this._setConnectedPositions(positionStrategy),\n            hasBackdrop: true,\n            backdropClass: ['mat-overlay-transparent-backdrop', this._backdropHarnessClass],\n            direction: this._dir || 'ltr',\n            scrollStrategy: this._scrollStrategy(),\n            panelClass: 'mat-month-year-picker-popup',\n        });\n\n        this._popupRef = this._overlay.create(overlayConfig);\n        this._popupRef.overlayElement.setAttribute('role', 'dialog');\n\n        merge(\n            this._popupRef.backdropClick(),\n            this._popupRef.detachments(),\n            this._popupRef.keydownEvents().pipe(filter(event => event.keyCode === ESCAPE || (this.inputMonthYearContentRef && event.altKey && event.keyCode === UP_ARROW)))\n        ).subscribe(event => {\n            if (event) {\n                event.preventDefault();\n            }\n\n            this.close();\n        });\n    }\n\n    private _destroyPopup() {\n        if (this._popupRef) {\n            this._popupRef.dispose();\n            this._popupRef = this._popupComponentRef = null;\n        }\n    }\n\n    private _setConnectedPositions(strategy: FlexibleConnectedPositionStrategy) {\n        const primaryX = this.xPosition === 'end' ? 'end' : 'start';\n        const secondaryX = primaryX === 'start' ? 'end' : 'start';\n        const primaryY = this.yPosition === 'above' ? 'bottom' : 'top';\n        const secondaryY = primaryY === 'top' ? 'bottom' : 'top';\n\n        return strategy.withPositions([\n            {\n                originX: primaryX,\n                originY: secondaryY,\n                overlayX: primaryX,\n                overlayY: primaryY\n            },\n            {\n                originX: primaryX,\n                originY: primaryY,\n                overlayX: primaryX,\n                overlayY: secondaryY\n            },\n            {\n                originX: secondaryX,\n                originY: secondaryY,\n                overlayX: secondaryX,\n                overlayY: primaryY\n            },\n            {\n                originX: secondaryX,\n                originY: primaryY,\n                overlayX: secondaryX,\n                overlayY: secondaryY\n            }\n        ]);\n    }\n\n}\n"]}