@gipisistemas/ng-core 1.0.67 → 1.0.68

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

@@ -0,0 +1,460 @@
+var MonthYearPickerComponent_1;
+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';
+const moment = moment_;
+import { CalendarMonthYearComponent } from './calendar-month-year/calendar-month-year.component';
+export const GIPI_MONTH_YEAR_SCROLL_STRATEGY = new InjectionToken('gipi-month-year-scroll-strategy');
+/** @docs-private */
+export function GIPI_MONTH_YEAR_SCROLL_STRATEGY_FACTORY(overlay) {
+    return () => overlay.scrollStrategies.reposition();
+}
+/** @docs-private */
+export const GIPI_MONTH_YEAR_SCROLL_STRATEGY_FACTORY_PROVIDER = {
+    provide: GIPI_MONTH_YEAR_SCROLL_STRATEGY,
+    deps: [Overlay],
+    useFactory: GIPI_MONTH_YEAR_SCROLL_STRATEGY_FACTORY,
+};
+export class MonthYear {
+    constructor(month, year) {
+        this._month = month;
+        this._year = year;
+    }
+    get date() {
+        const date = moment().day(1).month(this.month).year(this.year).startOf('day').toDate();
+        return date;
+    }
+    get month() {
+        return this._month;
+    }
+    get year() {
+        return this._year;
+    }
+}
+export class MonthPickerModel {
+    constructor() {
+        this.months = [];
+        this.selectedYearMoment = moment();
+        this.updateYearText();
+        this.selectedMonthMoment = moment();
+        this.months = moment.monthsShort().map(month => `${month}.`);
+        this.selectedMonthIndex = this.selectedMonthMoment.month();
+        this.selectedMonthYear = this.selectedYearMoment.year();
+    }
+    updateYearText() {
+        this.selectedYearText = !ObjectUtil.isNull(moment) ? moment(this.selectedYearMoment).format('YYYY') : '';
+    }
+    selectMonth(index) {
+        this.selectedMonthMoment = moment().month(index);
+        this.selectedMonthIndex = this.selectedMonthMoment.month();
+        this.selectedMonthYear = this.selectedYearMoment.year();
+    }
+    incrementYear() {
+        this.selectedYearMoment = this.selectedYearMoment.add(1, "year");
+        this.updateYearText();
+    }
+    decrementYear() {
+        this.selectedYearMoment = this.selectedYearMoment.subtract(1, "year");
+        this.updateYearText();
+    }
+}
+let nextUniqueId = 0;
+let MonthYearPickerComponent = MonthYearPickerComponent_1 = class MonthYearPickerComponent {
+    constructor(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 = () => { };
+        this.onTouched = () => { };
+        this._scrollStrategy = scrollStrategy;
+    }
+    get opened() {
+        return this._opened;
+    }
+    set opened(value) {
+        coerceBooleanProperty(value) ? this.open() : this.close();
+    }
+    get required() {
+        return this._required;
+    }
+    set required(value) {
+        this._required = coerceBooleanProperty(value);
+    }
+    get disabled() {
+        return this._disabled;
+    }
+    set disabled(value) {
+        this._disabled = coerceBooleanProperty(value);
+    }
+    get min() {
+        return this._min;
+    }
+    set min(value) {
+        this._min = value;
+    }
+    get max() {
+        return this._max;
+    }
+    set max(value) {
+        this._max = value;
+    }
+    get value() {
+        return this._value;
+    }
+    set value(value) {
+        let 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);
+    }
+    ngOnInit() {
+        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);
+        }
+    }
+    ngOnChanges(changes) {
+        const 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);
+    }
+    ngOnDestroy() {
+        this._destroyPopup();
+        this.close();
+        this._stateChanges.complete();
+    }
+    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();
+    }
+    onValueChange(month, year) {
+        const monthYear = new MonthYear(month, year);
+        this.value = monthYear;
+        this._changeDetectorRef.detectChanges();
+    }
+    open() {
+        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();
+    }
+    close() {
+        if (!this._opened) {
+            return;
+        }
+        if (this._popupComponentRef && this._popupRef) {
+            const instance = this._popupComponentRef.instance;
+            instance._startExitAnimation();
+            instance._animationDone.pipe(take(1)).subscribe(() => this._destroyPopup());
+        }
+        const completeClose = () => {
+            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();
+        }
+    }
+    _openAsPopup() {
+        const 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(() => {
+            this._popupRef.updatePosition();
+        });
+    }
+    _getConnectedOverlayOrigin() {
+        return this.inputMonthYearContentRef ? this.inputMonthYearContentRef : this.elementRef;
+    }
+    _createPopup() {
+        const positionStrategy = this._overlay.position()
+            .flexibleConnectedTo(this._getConnectedOverlayOrigin())
+            .withTransformOriginOn('.mat-datepicker-content')
+            .withFlexibleDimensions(false)
+            .withViewportMargin(8)
+            .withLockedPosition();
+        const 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(event => event.keyCode === ESCAPE || (this.inputMonthYearContentRef && event.altKey && event.keyCode === UP_ARROW)))).subscribe(event => {
+            if (event) {
+                event.preventDefault();
+            }
+            this.close();
+        });
+    }
+    _destroyPopup() {
+        if (this._popupRef) {
+            this._popupRef.dispose();
+            this._popupRef = this._popupComponentRef = null;
+        }
+    }
+    _setConnectedPositions(strategy) {
+        const primaryX = this.xPosition === 'end' ? 'end' : 'start';
+        const secondaryX = primaryX === 'start' ? 'end' : 'start';
+        const primaryY = this.yPosition === 'above' ? 'bottom' : 'top';
+        const 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
+            }
+        ]);
+    }
+};
+MonthYearPickerComponent.ctorParameters = () => [
+    { 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(() => 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);
+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":";;AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,iCAAiC,EAAE,OAAO,EAAE,aAAa,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAC7H,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAC3C,OAAO,EAAE,uBAAuB,EAAE,iBAAiB,EAAE,SAAS,EAAE,YAAY,EAAE,UAAU,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,EAAE,cAAc,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,aAAa,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAC7Q,OAAO,EAAwB,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACzE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AACtC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,UAAU,EAAE,MAAM,mCAAmC,CAAC;AAE/D,OAAO,KAAK,OAAO,MAAM,QAAQ,CAAC;AAClC,MAAM,MAAM,GAAG,OAAO,CAAC;AAEvB,OAAO,EAAE,0BAA0B,EAAE,MAAM,qDAAqD,CAAC;AAGjG,MAAM,CAAC,MAAM,+BAA+B,GAAG,IAAI,cAAc,CAAuB,iCAAiC,CAAC,CAAC;AAE3H,oBAAoB;AACpB,MAAM,UAAU,uCAAuC,CAAC,OAAgB;IACpE,OAAO,GAAG,EAAE,CAAC,OAAO,CAAC,gBAAgB,CAAC,UAAU,EAAE,CAAC;AACvD,CAAC;AAED,oBAAoB;AACpB,MAAM,CAAC,MAAM,gDAAgD,GAAG;IAC5D,OAAO,EAAE,+BAA+B;IACxC,IAAI,EAAE,CAAC,OAAO,CAAC;IACf,UAAU,EAAE,uCAAuC;CACtD,CAAC;AAGF,MAAM,OAAO,SAAS;IAiBlB,YAAY,KAAc,EAAE,IAAa;QACrC,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;QACpB,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;IACtB,CAAC;IAhBD,IAAW,IAAI;QACX,MAAM,IAAI,GAAG,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,MAAM,EAAE,CAAC;QACvF,OAAO,IAAI,CAAC;IAChB,CAAC;IAED,IAAW,KAAK;QACZ,OAAO,IAAI,CAAC,MAAM,CAAC;IACvB,CAAC;IAED,IAAW,IAAI;QACX,OAAO,IAAI,CAAC,KAAK,CAAC;IACtB,CAAC;CAMJ;AAED,MAAM,OAAO,gBAAgB;IAUzB;QAFA,WAAM,GAAkB,EAAE,CAAC;QAGvB,IAAI,CAAC,kBAAkB,GAAG,MAAM,EAAE,CAAC;QACnC,IAAI,CAAC,cAAc,EAAE,CAAC;QAEtB,IAAI,CAAC,mBAAmB,GAAG,MAAM,EAAE,CAAC;QAEpC,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC,WAAW,EAAE,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,GAAG,KAAK,GAAG,CAAC,CAAC;QAE7D,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC,mBAAmB,CAAC,KAAK,EAAE,CAAC;QAC3D,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC,kBAAkB,CAAC,IAAI,EAAE,CAAC;IAC5D,CAAC;IAED,cAAc;QACV,IAAI,CAAC,gBAAgB,GAAG,CAAC,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;IAC7G,CAAC;IAED,WAAW,CAAC,KAAa;QACrB,IAAI,CAAC,mBAAmB,GAAG,MAAM,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QACjD,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC,mBAAmB,CAAC,KAAK,EAAE,CAAC;QAC3D,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC,kBAAkB,CAAC,IAAI,EAAE,CAAC;IAC5D,CAAC;IAED,aAAa;QACT,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,CAAA;QAChE,IAAI,CAAC,cAAc,EAAE,CAAC;IAC1B,CAAC;IAED,aAAa;QACT,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC,kBAAkB,CAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC,CAAA;QACrE,IAAI,CAAC,cAAc,EAAE,CAAC;IAC1B,CAAC;CACJ;AAED,IAAI,YAAY,GAAG,CAAC,CAAC;AAkBrB,IAAa,wBAAwB,gCAArC,MAAa,wBAAwB;IA8HjC,YACW,UAAsB,EACrB,kBAAqC,EACrC,QAAiB,EACjB,OAAe,EACf,iBAAmC,EACF,cAAmB,EACxC,IAAoB,EACF,SAAc;QAP7C,eAAU,GAAV,UAAU,CAAY;QACrB,uBAAkB,GAAlB,kBAAkB,CAAmB;QACrC,aAAQ,GAAR,QAAQ,CAAS;QACjB,YAAO,GAAP,OAAO,CAAQ;QACf,sBAAiB,GAAjB,iBAAiB,CAAkB;QAEvB,SAAI,GAAJ,IAAI,CAAgB;QACF,cAAS,GAAT,SAAS,CAAK;QAlIhD,UAAK,GAAW,mBAAmB,YAAY,EAAE,EAAE,CAAC;QAMpD,8BAAyB,GAAuB,IAAI,CAAC;QACrD,0BAAqB,GAAG,GAAG,IAAI,CAAC,KAAK,WAAW,CAAC;QAEhD,kBAAa,GAAkB,IAAI,OAAO,EAAE,CAAC;QAE/C,eAAU,GAAW,EAAE,CAAC;QAItB,OAAE,GAAW,GAAG,IAAI,CAAC,KAAK,OAAO,CAAC;QAElC,SAAI,GAAW,GAAG,IAAI,CAAC,KAAK,OAAO,CAAC;QAEpC,UAAK,GAAW,EAAE,CAAC;QAEnB,gBAAW,GAAW,EAAE,CAAC;QAEzB,SAAI,GAAW,EAAE,CAAC;QAclB,cAAS,GAAoB,OAAO,CAAC;QAErC,cAAS,GAAsB,OAAO,CAAC;QAEvC,iBAAY,GAAoB,MAAM,CAAC;QAExC,YAAO,GAAG,KAAK,CAAC;QAQhB,cAAS,GAAY,KAAK,CAAC;QAQ3B,cAAS,GAAY,KAAK,CAAC;QAQ3B,SAAI,GAAc,IAAI,CAAC;QAQvB,SAAI,GAAc,IAAI,CAAC;QAwCb,iBAAY,GAAuB,IAAI,YAAY,EAAQ,CAAC;QAC5D,iBAAY,GAAuB,IAAI,YAAY,EAAQ,CAAC;QAE9E,aAAQ,GAAa,GAAG,EAAE,GAAG,CAAC,CAAC;QAE/B,cAAS,GAAa,GAAG,EAAE,GAAG,CAAC,CAAC;QAY5B,IAAI,CAAC,eAAe,GAAG,cAAc,CAAC;IAC1C,CAAC;IAzFQ,IAAI,MAAM;QACf,OAAO,IAAI,CAAC,OAAO,CAAC;IACxB,CAAC;IACD,IAAI,MAAM,CAAC,KAAc;QACrB,qBAAqB,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC;IAC9D,CAAC;IAGQ,IAAI,QAAQ;QACjB,OAAO,IAAI,CAAC,SAAS,CAAC;IAC1B,CAAC;IACD,IAAI,QAAQ,CAAC,KAAc;QACvB,IAAI,CAAC,SAAS,GAAG,qBAAqB,CAAC,KAAK,CAAC,CAAC;IAClD,CAAC;IAGQ,IAAI,QAAQ;QACjB,OAAO,IAAI,CAAC,SAAS,CAAC;IAC1B,CAAC;IACD,IAAI,QAAQ,CAAC,KAAc;QACvB,IAAI,CAAC,SAAS,GAAG,qBAAqB,CAAC,KAAK,CAAC,CAAC;IAClD,CAAC;IAGQ,IAAI,GAAG;QACZ,OAAO,IAAI,CAAC,IAAI,CAAC;IACrB,CAAC;IACD,IAAI,GAAG,CAAC,KAAgB;QACpB,IAAI,CAAC,IAAI,GAAG,KAAK,CAAC;IACtB,CAAC;IAGQ,IAAI,GAAG;QACZ,OAAO,IAAI,CAAC,IAAI,CAAC;IACrB,CAAC;IACD,IAAI,GAAG,CAAC,KAAgB;QACpB,IAAI,CAAC,IAAI,GAAG,KAAK,CAAC;IACtB,CAAC;IAGQ,IAAI,KAAK;QACd,OAAO,IAAI,CAAC,MAAM,CAAC;IACvB,CAAC;IACD,IAAI,KAAK,CAAC,KAAgB;QACtB,IAAI,QAAQ,GAAc,KAAK,CAAC;QAChC,IAAI,CAAC,KAAK,EAAE;YACR,QAAQ,GAAG,IAAI,CAAC;SACnB;QACD,IAAI,QAAQ,EAAE;YACV,QAAQ,IAAI,CAAC,YAAY,EAAE;gBACvB,KAAK,MAAM,CAAC,CAAC;oBACT,IAAI,CAAC,UAAU,GAAG,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;oBAC1D,MAAM;iBACT;gBACD,KAAK,MAAM,CAAC,CAAC;oBACT,IAAI,CAAC,UAAU,GAAG,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;oBACvD,MAAM;iBACT;gBACD,OAAO,CAAC,CAAC;oBACL,IAAI,CAAC,UAAU,GAAG,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;oBAC1D,MAAM;iBACT;aACJ;SACJ;QAED,IAAI,CAAC,MAAM,GAAG,QAAQ,CAAC;QAEvB,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAC3B,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAChC,CAAC;IAsBD,QAAQ;QACJ,IAAI,CAAC,KAAK,GAAG,IAAI,gBAAgB,EAAE,CAAC;QAEpC,IAAI,IAAI,CAAC,IAAI,EAAE;YACX,IAAI,CAAC,KAAK,CAAC,kBAAkB,GAAG,MAAM,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;SAC5D;QAED,IAAI,IAAI,CAAC,KAAK,EAAE;YACZ,IAAI,CAAC,KAAK,CAAC,kBAAkB,GAAG,IAAI,CAAC,KAAK,CAAC;YAC3C,IAAI,CAAC,KAAK,CAAC,mBAAmB,GAAG,MAAM,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YAE5D,IAAI,IAAI,CAAC,IAAI,EAAE;gBACX,IAAI,CAAC,KAAK,CAAC,iBAAiB,GAAG,IAAI,CAAC,IAAI,CAAC;aAC5C;SACJ;QAED,IAAI,CAAC,KAAK,CAAC,cAAc,EAAE,CAAC;QAC5B,IAAI,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE;YAC/D,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;YAClB,IAAI,CAAC,kBAAkB,CAAC,aAAa,EAAE,CAAC;SAC3C;aAAM;YACH,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,kBAAkB,EAAE,IAAI,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAC;SACnF;IACL,CAAC;IAED,WAAW,CAAC,OAAsB;QAC9B,MAAM,cAAc,GAAG,OAAO,CAAC,WAAW,CAAC,IAAI,OAAO,CAAC,WAAW,CAAC,CAAC;QAEpE,IAAI,cAAc,IAAI,CAAC,cAAc,CAAC,WAAW,IAAI,IAAI,CAAC,SAAS,EAAE;YACjE,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,EAAE,CAAC,gBAAqD,CAAC,CAAC;YAE9G,IAAI,IAAI,CAAC,MAAM,EAAE;gBACb,IAAI,CAAC,SAAS,CAAC,cAAc,EAAE,CAAC;aACnC;SACJ;QAED,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;IACvC,CAAC;IAED,WAAW;QACP,IAAI,CAAC,aAAa,EAAE,CAAC;QACrB,IAAI,CAAC,KAAK,EAAE,CAAC;QACb,IAAI,CAAC,aAAa,CAAC,QAAQ,EAAE,CAAC;IAClC,CAAC;IAED,UAAU,CAAC,KAAgB;QACvB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,kBAAkB,CAAC,aAAa,EAAE,CAAC;IAC5C,CAAC;IAED,gBAAgB,CAAC,EAAY;QACzB,IAAI,CAAC,QAAQ,GAAG,EAAE,CAAC;IACvB,CAAC;IAED,iBAAiB,CAAC,EAAY;QAC1B,IAAI,CAAC,SAAS,GAAG,EAAE,CAAC;IACxB,CAAC;IAED,gBAAgB,CAAE,UAAmB;QACjC,IAAI,CAAC,QAAQ,GAAG,UAAU,CAAC;QAC3B,IAAI,CAAC,kBAAkB,CAAC,YAAY,EAAE,CAAC;IAC3C,CAAC;IAEM,aAAa,CAAC,KAAa,EAAE,IAAY;QAC5C,MAAM,SAAS,GAAc,IAAI,SAAS,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;QACxD,IAAI,CAAC,KAAK,GAAG,SAAS,CAAC;QACvB,IAAI,CAAC,kBAAkB,CAAC,aAAa,EAAE,CAAC;IAC5C,CAAC;IAEM,IAAI;QACP,IAAI,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,QAAQ,EAAE;YAC/B,OAAO;SACV;QACD,IAAI,CAAC,IAAI,CAAC,wBAAwB,EAAE;YAChC,MAAM,KAAK,CAAC,gEAAgE,CAAC,CAAC;SACjF;QACD,IAAI,IAAI,CAAC,SAAS,EAAE;YAChB,IAAI,CAAC,yBAAyB,GAAG,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC;SACjE;QAED,IAAI,CAAC,YAAY,EAAE,CAAC;QACpB,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;QACpB,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC;IAC7B,CAAC;IAEM,KAAK;QACR,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE;YACf,OAAO;SACV;QACD,IAAI,IAAI,CAAC,kBAAkB,IAAI,IAAI,CAAC,SAAS,EAAE;YAC3C,MAAM,QAAQ,GAAG,IAAI,CAAC,kBAAkB,CAAC,QAAQ,CAAC;YAClD,QAAQ,CAAC,mBAAmB,EAAE,CAAC;YAC/B,QAAQ,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC,CAAC;SAC/E;QAED,MAAM,aAAa,GAAG,GAAG,EAAE;YACvB,IAAI,IAAI,CAAC,OAAO,EAAE;gBACd,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;gBACrB,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC;gBACzB,IAAI,CAAC,yBAAyB,GAAG,IAAI,CAAC;aACzC;QACL,CAAC,CAAC;QAEF,IAAI,IAAI,CAAC,yBAAyB;YAC9B,OAAO,IAAI,CAAC,yBAAyB,CAAC,KAAK,KAAK,UAAU,EAAE;YAC5D,IAAI,CAAC,yBAAyB,CAAC,KAAK,EAAE,CAAC;YACvC,UAAU,CAAC,aAAa,CAAC,CAAC;SAC7B;aAAM;YACH,aAAa,EAAE,CAAC;SACnB;IACL,CAAC;IAEO,YAAY;QAChB,MAAM,MAAM,GAAgD,IAAI,eAAe,CAA6B,0BAA0B,EAAE,IAAI,CAAC,iBAAiB,CAAC,CAAC;QAEhK,IAAI,CAAC,aAAa,EAAE,CAAC;QACrB,IAAI,CAAC,YAAY,EAAE,CAAC;QACpB,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC,SAAU,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QACzD,IAAI,CAAC,kBAAkB,CAAC,QAAQ,CAAC,eAAe,GAAG,IAAI,CAAC;QAExD,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,EAAE;YAC/C,IAAI,CAAC,SAAU,CAAC,cAAc,EAAE,CAAC;QACrC,CAAC,CAAC,CAAC;IACP,CAAC;IAEO,0BAA0B;QAC9B,OAAO,IAAI,CAAC,wBAAwB,CAAC,CAAC,CAAC,IAAI,CAAC,wBAAwB,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC;IAC3F,CAAC;IAEO,YAAY;QAChB,MAAM,gBAAgB,GAAG,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE;aAC5C,mBAAmB,CAAC,IAAI,CAAC,0BAA0B,EAAE,CAAC;aACtD,qBAAqB,CAAC,yBAAyB,CAAC;aAChD,sBAAsB,CAAC,KAAK,CAAC;aAC7B,kBAAkB,CAAC,CAAC,CAAC;aACrB,kBAAkB,EAAE,CAAC;QAE1B,MAAM,aAAa,GAAG,IAAI,aAAa,CAAC;YACpC,gBAAgB,EAAE,IAAI,CAAC,sBAAsB,CAAC,gBAAgB,CAAC;YAC/D,WAAW,EAAE,IAAI;YACjB,aAAa,EAAE,CAAC,kCAAkC,EAAE,IAAI,CAAC,qBAAqB,CAAC;YAC/E,SAAS,EAAE,IAAI,CAAC,IAAI,IAAI,KAAK;YAC7B,cAAc,EAAE,IAAI,CAAC,eAAe,EAAE;YACtC,UAAU,EAAE,6BAA6B;SAC5C,CAAC,CAAC;QAEH,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC;QACrD,IAAI,CAAC,SAAS,CAAC,cAAc,CAAC,YAAY,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;QAE7D,KAAK,CACD,IAAI,CAAC,SAAS,CAAC,aAAa,EAAE,EAC9B,IAAI,CAAC,SAAS,CAAC,WAAW,EAAE,EAC5B,IAAI,CAAC,SAAS,CAAC,aAAa,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,OAAO,KAAK,MAAM,IAAI,CAAC,IAAI,CAAC,wBAAwB,IAAI,KAAK,CAAC,MAAM,IAAI,KAAK,CAAC,OAAO,KAAK,QAAQ,CAAC,CAAC,CAAC,CAClK,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE;YAChB,IAAI,KAAK,EAAE;gBACP,KAAK,CAAC,cAAc,EAAE,CAAC;aAC1B;YAED,IAAI,CAAC,KAAK,EAAE,CAAC;QACjB,CAAC,CAAC,CAAC;IACP,CAAC;IAEO,aAAa;QACjB,IAAI,IAAI,CAAC,SAAS,EAAE;YAChB,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,CAAC;YACzB,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC;SACnD;IACL,CAAC;IAEO,sBAAsB,CAAC,QAA2C;QACtE,MAAM,QAAQ,GAAG,IAAI,CAAC,SAAS,KAAK,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC;QAC5D,MAAM,UAAU,GAAG,QAAQ,KAAK,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC;QAC1D,MAAM,QAAQ,GAAG,IAAI,CAAC,SAAS,KAAK,OAAO,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC;QAC/D,MAAM,UAAU,GAAG,QAAQ,KAAK,KAAK,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC;QAEzD,OAAO,QAAQ,CAAC,aAAa,CAAC;YAC1B;gBACI,OAAO,EAAE,QAAQ;gBACjB,OAAO,EAAE,UAAU;gBACnB,QAAQ,EAAE,QAAQ;gBAClB,QAAQ,EAAE,QAAQ;aACrB;YACD;gBACI,OAAO,EAAE,QAAQ;gBACjB,OAAO,EAAE,QAAQ;gBACjB,QAAQ,EAAE,QAAQ;gBAClB,QAAQ,EAAE,UAAU;aACvB;YACD;gBACI,OAAO,EAAE,UAAU;gBACnB,OAAO,EAAE,UAAU;gBACnB,QAAQ,EAAE,UAAU;gBACpB,QAAQ,EAAE,QAAQ;aACrB;YACD;gBACI,OAAO,EAAE,UAAU;gBACnB,OAAO,EAAE,QAAQ;gBACjB,QAAQ,EAAE,UAAU;gBACpB,QAAQ,EAAE,UAAU;aACvB;SACJ,CAAC,CAAC;IACP,CAAC;CAEJ,CAAA;;YAvN0B,UAAU;YACD,iBAAiB;YAC3B,OAAO;YACR,MAAM;YACI,gBAAgB;4CAC1C,MAAM,SAAC,+BAA+B;YACb,cAAc,uBAAvC,QAAQ;4CACR,QAAQ,YAAI,MAAM,SAAC,QAAQ;;AApIwB;IAAvD,SAAS,CAAC,uBAAuB,EAAE,EAAE,MAAM,EAAE,KAAK,GAAG,CAAC;8BAA2B,UAAU;0EAAC;AAiBpF;IAAR,KAAK,EAAE;;oDAAmC;AAElC;IAAR,KAAK,EAAE;;sDAAqC;AAEpC;IAAR,KAAK,EAAE;;uDAAoB;AAEnB;IAAR,KAAK,EAAE;;6DAA0B;AAEzB;IAAR,KAAK,EAAE;;sDAAmB;AAElB;IAAR,KAAK,EAAE;;wDAAgB;AACf;IAAR,KAAK,EAAE;;sDAAc;AACb;IAAR,KAAK,EAAE;;uDAAe;AAQd;IAAR,KAAK,EAAE;;0DAAmB;AAElB;IAAR,KAAK,EAAE;;2DAAsC;AAErC;IAAR,KAAK,EAAE;;2DAAwC;AAEvC;IAAR,KAAK,EAAE;;8DAAwC;AAGvC;IAAR,KAAK,EAAE;;;sDAEP;AAMQ;IAAR,KAAK,EAAE;;;wDAEP;AAMQ;IAAR,KAAK,EAAE;;;wDAEP;AAMQ;IAAR,KAAK,EAAE;8BAGO,SAAS;qCAAT,SAAS;mDADvB;AAMQ;IAAR,KAAK,EAAE;8BAGO,SAAS;qCAAT,SAAS;mDADvB;AAMQ;IAAR,KAAK,EAAE;8BAGS,SAAS;qCAAT,SAAS;qDADzB;AA6BiB;IAAjB,MAAM,CAAC,QAAQ,CAAC;8BAAe,YAAY;8DAAkC;AAC5D;IAAjB,MAAM,CAAC,QAAQ,CAAC;8BAAe,YAAY;8DAAkC;AAxHrE,wBAAwB;IAhBpC,SAAS,CAAC;QACP,QAAQ,EAAE,wBAAwB;QAClC,owDAAiD;QAEjD,SAAS,EAAE;YACP;gBACI,OAAO,EAAE,iBAAiB;gBAC1B,WAAW,EAAE,UAAU,CAAC,GAAoC,EAAE,CAAC,0BAAwB,CAAC;gBACxF,KAAK,EAAE,IAAI;aACd;SACJ;QACD,IAAI,EAAE;YACF,OAAO,EAAE,wBAAwB;SACpC;QACD,eAAe,EAAE,uBAAuB,CAAC,MAAM;;KAClD,CAAC;IAqIO,WAAA,MAAM,CAAC,+BAA+B,CAAC,CAAA;IACvC,WAAA,QAAQ,EAAE,CAAA;IACV,WAAA,QAAQ,EAAE,CAAA,EAAE,WAAA,MAAM,CAAC,QAAQ,CAAC,CAAA;qCAPV,UAAU;QACD,iBAAiB;QAC3B,OAAO;QACR,MAAM;QACI,gBAAgB,UAEjB,cAAc;GArInC,wBAAwB,CAsVpC;SAtVY,wBAAwB","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"]}

package/esm2015/shared/gipi-components/notification/notification.component.js

@@ -0,0 +1,104 @@
+var GIPINotificationComponent_1;
+import { __decorate, __metadata } from "tslib";
+import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output, forwardRef } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+let GIPINotificationComponent = GIPINotificationComponent_1 = class GIPINotificationComponent {
+    constructor() {
+        this.buttonPadding = 4;
+        this.iconWidth = 24;
+        this.iconHeight = 24;
+        this.icon = null;
+        this.svgIcon = null;
+        this.onShowOverlay = new EventEmitter();
+        this.onClick = new EventEmitter();
+        this.onFocus = new EventEmitter();
+        this.onBlur = new EventEmitter();
+    }
+    ngOnInit() { }
+};
+__decorate([
+    Input(),
+    __metadata("design:type", String)
+], GIPINotificationComponent.prototype, "id", void 0);
+__decorate([
+    Input(),
+    __metadata("design:type", String)
+], GIPINotificationComponent.prototype, "name", void 0);
+__decorate([
+    Input(),
+    __metadata("design:type", String)
+], GIPINotificationComponent.prototype, "ariaLabel", void 0);
+__decorate([
+    Input(),
+    __metadata("design:type", String)
+], GIPINotificationComponent.prototype, "label", void 0);
+__decorate([
+    Input(),
+    __metadata("design:type", Object)
+], GIPINotificationComponent.prototype, "buttonPadding", void 0);
+__decorate([
+    Input(),
+    __metadata("design:type", Object)
+], GIPINotificationComponent.prototype, "iconWidth", void 0);
+__decorate([
+    Input(),
+    __metadata("design:type", Object)
+], GIPINotificationComponent.prototype, "iconHeight", void 0);
+__decorate([
+    Input(),
+    __metadata("design:type", String)
+], GIPINotificationComponent.prototype, "icon", void 0);
+__decorate([
+    Input(),
+    __metadata("design:type", String)
+], GIPINotificationComponent.prototype, "svgIcon", void 0);
+__decorate([
+    Input(),
+    __metadata("design:type", String)
+], GIPINotificationComponent.prototype, "disabled", void 0);
+__decorate([
+    Input(),
+    __metadata("design:type", String)
+], GIPINotificationComponent.prototype, "loading", void 0);
+__decorate([
+    Input(),
+    __metadata("design:type", String)
+], GIPINotificationComponent.prototype, "tooltip", void 0);
+__decorate([
+    Output(),
+    __metadata("design:type", EventEmitter)
+], GIPINotificationComponent.prototype, "onShowOverlay", void 0);
+__decorate([
+    Output('click'),
+    __metadata("design:type", EventEmitter)
+], GIPINotificationComponent.prototype, "onClick", void 0);
+__decorate([
+    Output('focus'),
+    __metadata("design:type", EventEmitter)
+], GIPINotificationComponent.prototype, "onFocus", void 0);
+__decorate([
+    Output('blur'),
+    __metadata("design:type", EventEmitter)
+], GIPINotificationComponent.prototype, "onBlur", void 0);
+GIPINotificationComponent = GIPINotificationComponent_1 = __decorate([
+    Component({
+        selector: `gipi-notification`,
+        exportAs: 'gipiNotification',
+        template: "<gipi-button gipi-icon\n             [id]=\"id\"\n             [name]=\"name\"\n             [ariaLabel]=\"ariaLabel\"\n             [buttonPadding]=\"buttonPadding\"\n             [iconWidth]=\"iconWidth\"\n             [iconHeight]=\"iconHeight\"\n             [icon]=\"icon\"\n             [svgIcon]=\"svgIcon\"\n             [disabled]=\"disabled\"\n             [loading]=\"loading\"\n             [tooltip]=\"tooltip\"\n             [popover]=\"true\"\n             [overlay]=\"false\"\n             (onShowOverlay)=\"onShowOverlay.emit()\"\n             (click)=\"onClick.emit($event)\"\n             (focus)=\"onFocus.emit($event)\"\n             (blur)=\"onBlur.emit($event)\">\n    <div role=\"menu\"\n         class=\"notification\">\n        <header>\n            <span role=\"text\">Notifica\u00E7\u00F5es</span>\n            <span role=\"button\">Apagar notifica\u00E7\u00F5es lidas</span>\n        </header>\n        <main>\n            Em breve\n        </main>\n        <footer>\n        </footer>\n    </div>\n</gipi-button>\n",
+        providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: forwardRef(() => GIPINotificationComponent_1),
+                multi: true
+            }
+        ],
+        host: {
+            'class': 'gipi-notification',
+        },
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        styles: [".button-only-icon{padding:4px!important}.button-only-icon .button-content>mat-icon{width:24px!important;height:24px!important}.notification{max-width:30rem}.notification>footer,.notification>header{display:none}.notification>main{width:20rem;text-align:center;font-size:1.6rem;font-weight:600;color:#262626}"]
+    }),
+    __metadata("design:paramtypes", [])
+], GIPINotificationComponent);
+export { GIPINotificationComponent };
+//# sourceMappingURL=data:application/json;base64,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