monkey-style-guide 2.0.106 → 2.0.110

package/esm2020/lib/components/date-range-picker/date-range-picker.component.mjs

@@ -0,0 +1,569 @@
+/**************************
+ * Copyright Monkey Exchange. All Rights Reserved
+ * This style guide was developed by Monkey Exchange Team
+ * MIT Licence
+ **************************/
+import { CurrencyPipe } from '@angular/common';
+import { Component, ViewEncapsulation, forwardRef, Output, EventEmitter, Input, } from '@angular/core';
+import { NG_VALUE_ACCESSOR, Validators, } from '@angular/forms';
+import { MonkeyUtils } from '../../core/utils';
+import * as moment_ from 'moment';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+import * as i2 from "../button/button.component";
+import * as i3 from "@angular/common";
+const moment = moment_;
+export class MonkeyDateRangePickerComponent {
+    constructor(fb, cdr) {
+        this.fb = fb;
+        this.cdr = cdr;
+        this.helperMessage = '';
+        this.minDate = null;
+        this.onChange = new EventEmitter();
+        this.today = moment.default().format('YYYY-MM-DD');
+        this.onModelChange = (value) => { };
+        this.onModelTouched = (value) => { };
+        this._dateFirst = moment.default();
+        this._dateSecond = moment.default().add(1, 'M');
+        this._id = `mecx-date-range-picker-${MonkeyUtils.getRandomString(10)}`;
+        this._daysArrFirst = [];
+        this._daysArrSecond = [];
+        this._disabled = false;
+        this.initDateRange();
+    }
+    initDateRange() {
+        return (this._dateForm = this.fb.group({
+            startDate: [null, Validators.required],
+            endDate: [null, Validators.required],
+        }));
+    }
+    createCalendar(month) {
+        let firstDay = moment.default(month).startOf('M');
+        let lastDay = moment.default(month).endOf('M');
+        let days = Array.apply(null, { length: month.daysInMonth() })
+            .map(Number.call, Number)
+            .map((n) => {
+            return moment.default(firstDay).add(n, 'd');
+        });
+        let n = 0;
+        while (n < firstDay.weekday()) {
+            days.unshift(null);
+            n++;
+        }
+        n = 0;
+        while (n < 7 - lastDay.weekday()) {
+            days.push(null);
+            n++;
+        }
+        let index = 1;
+        let group = [];
+        let grouped = [];
+        Object.entries(days).map(([key, value]) => {
+            if (index > 7) {
+                index = 1;
+                grouped.push(group);
+                group = [];
+            }
+            group.push(value);
+            index++;
+        });
+        grouped.push(group);
+        return grouped;
+    }
+    build() {
+        this._daysArrFirst = this.createCalendar(this._dateFirst);
+        this._daysArrSecond = this.createCalendar(this._dateSecond);
+    }
+    clearDates() {
+        if (this._disabled)
+            return;
+        this._dateForm.setValue({ startDate: null, endDate: null });
+        this.writeValue(this._dateForm.value);
+    }
+    navigateToToday() {
+        this._dateFirst = moment.default();
+        this._dateSecond = moment.default().add(1, 'M');
+        this.build();
+    }
+    ngOnInit() {
+        this.build();
+    }
+    registerOnChange(fn) {
+        this.onModelChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onModelTouched = fn;
+    }
+    setDisabledState(isDisabled) {
+        this._disabled = isDisabled;
+    }
+    set value(value) {
+        if (value &&
+            Object.prototype.hasOwnProperty.call(value, 'startDate') &&
+            Object.prototype.hasOwnProperty.call(value, 'endDate')) {
+            this._dateForm.setValue(value);
+            this.cdr.detectChanges();
+            this.onModelChange(this._dateForm.value);
+            this.onModelTouched(this._dateForm.value);
+        }
+        else {
+            this.clearDates();
+        }
+    }
+    get value() {
+        return this._dateForm.value;
+    }
+    writeValue(value) {
+        this.value = value;
+        this.onChange.next(value);
+    }
+    nextMonth() {
+        if (this._disabled)
+            return;
+        this._dateFirst.add(1, 'M');
+        this._dateSecond.add(1, 'M');
+        this._daysArrFirst = this.createCalendar(this._dateFirst);
+        this._daysArrSecond = this.createCalendar(this._dateSecond);
+    }
+    previousMonth() {
+        if (this._disabled)
+            return;
+        this._dateFirst.subtract(1, 'M');
+        this._dateSecond.subtract(1, 'M');
+        this._daysArrFirst = this.createCalendar(this._dateFirst);
+        this._daysArrSecond = this.createCalendar(this._dateSecond);
+    }
+    todayCheck(day) {
+        if (!day) {
+            return false;
+        }
+        return moment.default().format('L') === day.format('L');
+    }
+    isSelected(day) {
+        if (!day) {
+            return false;
+        }
+        let startDateMoment = moment.default(this._dateForm.value.startDate, 'YYYY-MM-DD');
+        let endDateMoment = moment.default(this._dateForm.value.endDate, 'YYYY-MM-DD');
+        if (this._dateForm.valid) {
+            return startDateMoment.isSameOrBefore(day) && endDateMoment.isSameOrAfter(day);
+        }
+        if (this._dateForm.get('startDate').valid) {
+            return startDateMoment.isSame(day);
+        }
+    }
+    isDisabled(day) {
+        const { minDate } = this;
+        if (minDate) {
+            const firstDay = moment.default(minDate);
+            return day.isBefore(firstDay.subtract(1, 'day'));
+        }
+        return false;
+    }
+    isFirstSelected(day) {
+        const { _dateForm } = this;
+        const { startDate } = _dateForm.value;
+        return day?.isSame(startDate);
+    }
+    isLastSelected(day) {
+        const { _dateForm } = this;
+        const { endDate } = _dateForm.value;
+        return day?.isSame(endDate);
+    }
+    selectedDate(day) {
+        if (this._disabled)
+            return;
+        const { _dateForm, minDate } = this;
+        let dayFormatted = day.format('YYYY-MM-DD');
+        if (minDate) {
+            const firstDay = moment.default(minDate);
+            if (day.isBefore(firstDay.subtract(1, 'day')))
+                return;
+        }
+        if (_dateForm.valid) {
+            this.clearDates();
+        }
+        let { startDate, endDate } = _dateForm.value;
+        if (startDate) {
+            if (moment.default(startDate).isAfter(moment.default(dayFormatted))) {
+                endDate = startDate;
+                startDate = dayFormatted;
+            }
+            else {
+                endDate = dayFormatted;
+            }
+        }
+        else
+            startDate = dayFormatted;
+        if (startDate) {
+            _dateForm.get('startDate').patchValue(startDate);
+        }
+        if (endDate) {
+            _dateForm.get('endDate').patchValue(endDate);
+        }
+        this.writeValue(_dateForm.value);
+    }
+    selectRangeOfDays(days) {
+        if (this._disabled)
+            return;
+        const { _dateForm, minDate, today } = this;
+        const { startDate } = _dateForm.value;
+        const firstDay = moment.default(startDate || minDate || today).format('YYYY-MM-DD');
+        const lastDay = moment.default(firstDay).add(days, 'day').format('YYYY-MM-DD');
+        _dateForm.get('startDate').patchValue(firstDay);
+        _dateForm.get('endDate').patchValue(lastDay);
+        this.writeValue(_dateForm.value);
+    }
+}
+MonkeyDateRangePickerComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: MonkeyDateRangePickerComponent, deps: [{ token: i1.FormBuilder }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+MonkeyDateRangePickerComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.1.3", type: MonkeyDateRangePickerComponent, selector: "monkey-date-range-picker", inputs: { label: "label", helperMessage: "helperMessage", i18n: "i18n", infoMessage: "infoMessage", errorMessage: "errorMessage", minDate: "minDate", value: "value" }, outputs: { onChange: "onChange" }, providers: [
+        {
+            provide: NG_VALUE_ACCESSOR,
+            useExisting: forwardRef(() => MonkeyDateRangePickerComponent),
+            multi: true,
+        },
+        CurrencyPipe,
+    ], ngImport: i0, template: `
+    <mecx-date-range-picker-group [ngClass]="{ disabled: _disabled }" [id]="_id">
+      <mecx-date-range-picker-group-header>
+        <label>
+          {{ label }}
+        </label>
+        <helper>
+          {{ helperMessage }}
+        </helper>
+      </mecx-date-range-picker-group-header>
+      <mecx-date-range-picker-group-body>
+        <mecx-date-range-picker class="first-date-range">
+          <mecx-date-range-picker-header>
+            <div class="calendar-title">
+              <monkey-button
+                class="calendar-previous"
+                color="theme"
+                icon="arrow-left-16"
+                type="tertiary"
+                (click)="previousMonth()"
+                size="sm"
+                [disabled]="_disabled"
+              >
+              </monkey-button>
+              <div class="month-year-title">
+                {{ i18n?.months?.[_dateFirst.format('M')] }}
+                {{ _dateFirst.format('YYYY') }}
+              </div>
+              <monkey-button
+                class="calendar-next"
+                color="theme"
+                icon="arrow-right-16"
+                type="tertiary"
+                (click)="nextMonth()"
+                size="sm"
+                [disabled]="_disabled"
+              >
+              </monkey-button>
+            </div>
+            <div class="week">
+              <span class="week-day" *ngFor="let day of [1, 2, 3, 4, 5, 6, 7]">
+                {{ i18n?.days?.[day]}}
+              </span>
+            </div>
+          </mecx-date-range-picker-header>
+          <mecx-date-range-picker-body>
+            <div class="month-week" *ngFor="let week of _daysArrFirst">
+              <div
+                class="month-day"
+                (click)="selectedDate(day)"
+                [ngClass]="{
+                  inactive: !day || isDisabled(day),
+                  selected: isSelected(day),
+                  today: todayCheck(day),
+                  'first-selected': isFirstSelected(day),
+                  'last-selected': isLastSelected(day)
+                }"
+                *ngFor="let day of week"
+                #divOne
+              >
+                {{ day?.date() }}
+              </div>
+            </div>
+          </mecx-date-range-picker-body>
+        </mecx-date-range-picker>
+
+        <mecx-date-range-picker class="second-date-range">
+          <mecx-date-range-picker-header>
+            <div class="calendar-title">
+              <div class="month-year-title">
+                {{ i18n?.months?.[_dateSecond.format('M')] }}
+                {{ _dateSecond.format('YYYY') }}
+              </div>
+              <monkey-button
+                class="calendar-previous"
+                color="theme"
+                icon="arrow-right-16"
+                type="tertiary"
+                (click)="nextMonth()"
+                size="sm"
+                [disabled]="_disabled"
+              >
+              </monkey-button>
+            </div>
+            <div class="week">
+              <span class="week-day" *ngFor="let day of [1, 2, 3, 4, 5, 6, 7]">
+                {{ i18n?.days?.[day]}}
+              </span>
+            </div>
+          </mecx-date-range-picker-header>
+          <mecx-date-range-picker-body>
+            <div class="month-week" *ngFor="let week of _daysArrSecond">
+              <div
+                class="month-day"
+                (click)="selectedDate(day)"
+                [ngClass]="{
+                  inactive: !day || isDisabled(day),
+                  selected: isSelected(day),
+                  today: todayCheck(day),
+                  'first-selected': isFirstSelected(day),
+                  'last-selected': isLastSelected(day)
+                }"
+                *ngFor="let day of week"
+              >
+                {{ day?.date() }}
+              </div>
+            </div>
+          </mecx-date-range-picker-body>
+        </mecx-date-range-picker>
+      </mecx-date-range-picker-group-body>
+      <mecx-date-range-picker-group-info>
+        <info>
+          {{ infoMessage }}
+        </info>
+        <error>
+          {{ errorMessage }}
+        </error>
+      </mecx-date-range-picker-group-info>
+      <mecx-date-range-picker-group-action [class.error]="errorMessage?.trim()">
+        <div class="action-days">
+          <monkey-button
+            color="theme"
+            type="secondary"
+            (click)="selectRangeOfDays(30)"
+            [disabled]="_disabled"
+          >
+            {{ i18n?.actions?.['30'] }}
+          </monkey-button>
+          <monkey-button
+            color="theme"
+            type="secondary"
+            (click)="selectRangeOfDays(60)"
+            [disabled]="_disabled"
+          >
+            {{ i18n?.actions?.['60'] }}
+          </monkey-button>
+          <monkey-button
+            color="theme"
+            type="secondary"
+            (click)="selectRangeOfDays(90)"
+            [disabled]="_disabled"
+          >
+            {{ i18n?.actions?.['90'] }}
+          </monkey-button>
+        </div>
+        <monkey-button
+          color="theme"
+          type="primary"
+          (click)="navigateToToday()"
+          [disabled]="_disabled"
+        >
+          {{ i18n?.today }}
+        </monkey-button>
+      </mecx-date-range-picker-group-action>
+    </mecx-date-range-picker-group>
+  `, isInline: true, components: [{ type: i2.MonkeyButtonComponent, selector: "monkey-button", inputs: ["label", "icon", "iconPosition", "type", "color", "disabled", "size"] }], directives: [{ type: i3.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { type: i3.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }], encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: MonkeyDateRangePickerComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'monkey-date-range-picker',
+                    template: `
+    <mecx-date-range-picker-group [ngClass]="{ disabled: _disabled }" [id]="_id">
+      <mecx-date-range-picker-group-header>
+        <label>
+          {{ label }}
+        </label>
+        <helper>
+          {{ helperMessage }}
+        </helper>
+      </mecx-date-range-picker-group-header>
+      <mecx-date-range-picker-group-body>
+        <mecx-date-range-picker class="first-date-range">
+          <mecx-date-range-picker-header>
+            <div class="calendar-title">
+              <monkey-button
+                class="calendar-previous"
+                color="theme"
+                icon="arrow-left-16"
+                type="tertiary"
+                (click)="previousMonth()"
+                size="sm"
+                [disabled]="_disabled"
+              >
+              </monkey-button>
+              <div class="month-year-title">
+                {{ i18n?.months?.[_dateFirst.format('M')] }}
+                {{ _dateFirst.format('YYYY') }}
+              </div>
+              <monkey-button
+                class="calendar-next"
+                color="theme"
+                icon="arrow-right-16"
+                type="tertiary"
+                (click)="nextMonth()"
+                size="sm"
+                [disabled]="_disabled"
+              >
+              </monkey-button>
+            </div>
+            <div class="week">
+              <span class="week-day" *ngFor="let day of [1, 2, 3, 4, 5, 6, 7]">
+                {{ i18n?.days?.[day]}}
+              </span>
+            </div>
+          </mecx-date-range-picker-header>
+          <mecx-date-range-picker-body>
+            <div class="month-week" *ngFor="let week of _daysArrFirst">
+              <div
+                class="month-day"
+                (click)="selectedDate(day)"
+                [ngClass]="{
+                  inactive: !day || isDisabled(day),
+                  selected: isSelected(day),
+                  today: todayCheck(day),
+                  'first-selected': isFirstSelected(day),
+                  'last-selected': isLastSelected(day)
+                }"
+                *ngFor="let day of week"
+                #divOne
+              >
+                {{ day?.date() }}
+              </div>
+            </div>
+          </mecx-date-range-picker-body>
+        </mecx-date-range-picker>
+
+        <mecx-date-range-picker class="second-date-range">
+          <mecx-date-range-picker-header>
+            <div class="calendar-title">
+              <div class="month-year-title">
+                {{ i18n?.months?.[_dateSecond.format('M')] }}
+                {{ _dateSecond.format('YYYY') }}
+              </div>
+              <monkey-button
+                class="calendar-previous"
+                color="theme"
+                icon="arrow-right-16"
+                type="tertiary"
+                (click)="nextMonth()"
+                size="sm"
+                [disabled]="_disabled"
+              >
+              </monkey-button>
+            </div>
+            <div class="week">
+              <span class="week-day" *ngFor="let day of [1, 2, 3, 4, 5, 6, 7]">
+                {{ i18n?.days?.[day]}}
+              </span>
+            </div>
+          </mecx-date-range-picker-header>
+          <mecx-date-range-picker-body>
+            <div class="month-week" *ngFor="let week of _daysArrSecond">
+              <div
+                class="month-day"
+                (click)="selectedDate(day)"
+                [ngClass]="{
+                  inactive: !day || isDisabled(day),
+                  selected: isSelected(day),
+                  today: todayCheck(day),
+                  'first-selected': isFirstSelected(day),
+                  'last-selected': isLastSelected(day)
+                }"
+                *ngFor="let day of week"
+              >
+                {{ day?.date() }}
+              </div>
+            </div>
+          </mecx-date-range-picker-body>
+        </mecx-date-range-picker>
+      </mecx-date-range-picker-group-body>
+      <mecx-date-range-picker-group-info>
+        <info>
+          {{ infoMessage }}
+        </info>
+        <error>
+          {{ errorMessage }}
+        </error>
+      </mecx-date-range-picker-group-info>
+      <mecx-date-range-picker-group-action [class.error]="errorMessage?.trim()">
+        <div class="action-days">
+          <monkey-button
+            color="theme"
+            type="secondary"
+            (click)="selectRangeOfDays(30)"
+            [disabled]="_disabled"
+          >
+            {{ i18n?.actions?.['30'] }}
+          </monkey-button>
+          <monkey-button
+            color="theme"
+            type="secondary"
+            (click)="selectRangeOfDays(60)"
+            [disabled]="_disabled"
+          >
+            {{ i18n?.actions?.['60'] }}
+          </monkey-button>
+          <monkey-button
+            color="theme"
+            type="secondary"
+            (click)="selectRangeOfDays(90)"
+            [disabled]="_disabled"
+          >
+            {{ i18n?.actions?.['90'] }}
+          </monkey-button>
+        </div>
+        <monkey-button
+          color="theme"
+          type="primary"
+          (click)="navigateToToday()"
+          [disabled]="_disabled"
+        >
+          {{ i18n?.today }}
+        </monkey-button>
+      </mecx-date-range-picker-group-action>
+    </mecx-date-range-picker-group>
+  `,
+                    encapsulation: ViewEncapsulation.None,
+                    providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => MonkeyDateRangePickerComponent),
+                            multi: true,
+                        },
+                        CurrencyPipe,
+                    ],
+                }]
+        }], ctorParameters: function () { return [{ type: i1.FormBuilder }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { label: [{
+                type: Input
+            }], helperMessage: [{
+                type: Input
+            }], i18n: [{
+                type: Input
+            }], infoMessage: [{
+                type: Input
+            }], errorMessage: [{
+                type: Input
+            }], minDate: [{
+                type: Input
+            }], onChange: [{
+                type: Output
+            }], value: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"date-range-picker.component.js","sourceRoot":"","sources":["../../../../../../projects/monkey-style-guide/src/lib/components/date-range-picker/date-range-picker.component.ts"],"names":[],"mappings":"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","sourcesContent":["/**************************\r\n * Copyright Monkey Exchange. All Rights Reserved\r\n * This style guide was developed by Monkey Exchange Team\r\n * MIT Licence\r\n **************************/\r\nimport { CurrencyPipe } from '@angular/common';\r\nimport {\r\n  Component,\r\n  ViewEncapsulation,\r\n  forwardRef,\r\n  OnInit,\r\n  Output,\r\n  EventEmitter,\r\n  Input,\r\n  ChangeDetectorRef,\r\n} from '@angular/core';\r\nimport {\r\n  ControlValueAccessor,\r\n  FormBuilder,\r\n  FormGroup,\r\n  NG_VALUE_ACCESSOR,\r\n  Validators,\r\n} from '@angular/forms';\r\nimport { MonkeyUtils } from '../../core/utils';\r\nimport * as moment_ from 'moment';\r\n\r\nconst moment: any = moment_;\r\n\r\n@Component({\r\n  selector: 'monkey-date-range-picker',\r\n  template: `\r\n    <mecx-date-range-picker-group [ngClass]=\"{ disabled: _disabled }\" [id]=\"_id\">\r\n      <mecx-date-range-picker-group-header>\r\n        <label>\r\n          {{ label }}\r\n        </label>\r\n        <helper>\r\n          {{ helperMessage }}\r\n        </helper>\r\n      </mecx-date-range-picker-group-header>\r\n      <mecx-date-range-picker-group-body>\r\n        <mecx-date-range-picker class=\"first-date-range\">\r\n          <mecx-date-range-picker-header>\r\n            <div class=\"calendar-title\">\r\n              <monkey-button\r\n                class=\"calendar-previous\"\r\n                color=\"theme\"\r\n                icon=\"arrow-left-16\"\r\n                type=\"tertiary\"\r\n                (click)=\"previousMonth()\"\r\n                size=\"sm\"\r\n                [disabled]=\"_disabled\"\r\n              >\r\n              </monkey-button>\r\n              <div class=\"month-year-title\">\r\n                {{ i18n?.months?.[_dateFirst.format('M')] }}\r\n                {{ _dateFirst.format('YYYY') }}\r\n              </div>\r\n              <monkey-button\r\n                class=\"calendar-next\"\r\n                color=\"theme\"\r\n                icon=\"arrow-right-16\"\r\n                type=\"tertiary\"\r\n                (click)=\"nextMonth()\"\r\n                size=\"sm\"\r\n                [disabled]=\"_disabled\"\r\n              >\r\n              </monkey-button>\r\n            </div>\r\n            <div class=\"week\">\r\n              <span class=\"week-day\" *ngFor=\"let day of [1, 2, 3, 4, 5, 6, 7]\">\r\n                {{ i18n?.days?.[day]}}\r\n              </span>\r\n            </div>\r\n          </mecx-date-range-picker-header>\r\n          <mecx-date-range-picker-body>\r\n            <div class=\"month-week\" *ngFor=\"let week of _daysArrFirst\">\r\n              <div\r\n                class=\"month-day\"\r\n                (click)=\"selectedDate(day)\"\r\n                [ngClass]=\"{\r\n                  inactive: !day || isDisabled(day),\r\n                  selected: isSelected(day),\r\n                  today: todayCheck(day),\r\n                  'first-selected': isFirstSelected(day),\r\n                  'last-selected': isLastSelected(day)\r\n                }\"\r\n                *ngFor=\"let day of week\"\r\n                #divOne\r\n              >\r\n                {{ day?.date() }}\r\n              </div>\r\n            </div>\r\n          </mecx-date-range-picker-body>\r\n        </mecx-date-range-picker>\r\n\r\n        <mecx-date-range-picker class=\"second-date-range\">\r\n          <mecx-date-range-picker-header>\r\n            <div class=\"calendar-title\">\r\n              <div class=\"month-year-title\">\r\n                {{ i18n?.months?.[_dateSecond.format('M')] }}\r\n                {{ _dateSecond.format('YYYY') }}\r\n              </div>\r\n              <monkey-button\r\n                class=\"calendar-previous\"\r\n                color=\"theme\"\r\n                icon=\"arrow-right-16\"\r\n                type=\"tertiary\"\r\n                (click)=\"nextMonth()\"\r\n                size=\"sm\"\r\n                [disabled]=\"_disabled\"\r\n              >\r\n              </monkey-button>\r\n            </div>\r\n            <div class=\"week\">\r\n              <span class=\"week-day\" *ngFor=\"let day of [1, 2, 3, 4, 5, 6, 7]\">\r\n                {{ i18n?.days?.[day]}}\r\n              </span>\r\n            </div>\r\n          </mecx-date-range-picker-header>\r\n          <mecx-date-range-picker-body>\r\n            <div class=\"month-week\" *ngFor=\"let week of _daysArrSecond\">\r\n              <div\r\n                class=\"month-day\"\r\n                (click)=\"selectedDate(day)\"\r\n                [ngClass]=\"{\r\n                  inactive: !day || isDisabled(day),\r\n                  selected: isSelected(day),\r\n                  today: todayCheck(day),\r\n                  'first-selected': isFirstSelected(day),\r\n                  'last-selected': isLastSelected(day)\r\n                }\"\r\n                *ngFor=\"let day of week\"\r\n              >\r\n                {{ day?.date() }}\r\n              </div>\r\n            </div>\r\n          </mecx-date-range-picker-body>\r\n        </mecx-date-range-picker>\r\n      </mecx-date-range-picker-group-body>\r\n      <mecx-date-range-picker-group-info>\r\n        <info>\r\n          {{ infoMessage }}\r\n        </info>\r\n        <error>\r\n          {{ errorMessage }}\r\n        </error>\r\n      </mecx-date-range-picker-group-info>\r\n      <mecx-date-range-picker-group-action [class.error]=\"errorMessage?.trim()\">\r\n        <div class=\"action-days\">\r\n          <monkey-button\r\n            color=\"theme\"\r\n            type=\"secondary\"\r\n            (click)=\"selectRangeOfDays(30)\"\r\n            [disabled]=\"_disabled\"\r\n          >\r\n            {{ i18n?.actions?.['30'] }}\r\n          </monkey-button>\r\n          <monkey-button\r\n            color=\"theme\"\r\n            type=\"secondary\"\r\n            (click)=\"selectRangeOfDays(60)\"\r\n            [disabled]=\"_disabled\"\r\n          >\r\n            {{ i18n?.actions?.['60'] }}\r\n          </monkey-button>\r\n          <monkey-button\r\n            color=\"theme\"\r\n            type=\"secondary\"\r\n            (click)=\"selectRangeOfDays(90)\"\r\n            [disabled]=\"_disabled\"\r\n          >\r\n            {{ i18n?.actions?.['90'] }}\r\n          </monkey-button>\r\n        </div>\r\n        <monkey-button\r\n          color=\"theme\"\r\n          type=\"primary\"\r\n          (click)=\"navigateToToday()\"\r\n          [disabled]=\"_disabled\"\r\n        >\r\n          {{ i18n?.today }}\r\n        </monkey-button>\r\n      </mecx-date-range-picker-group-action>\r\n    </mecx-date-range-picker-group>\r\n  `,\r\n  encapsulation: ViewEncapsulation.None,\r\n  providers: [\r\n    {\r\n      provide: NG_VALUE_ACCESSOR,\r\n      useExisting: forwardRef(() => MonkeyDateRangePickerComponent),\r\n      multi: true,\r\n    },\r\n    CurrencyPipe,\r\n  ],\r\n})\r\nexport class MonkeyDateRangePickerComponent implements ControlValueAccessor, OnInit {\r\n  @Input() label: string;\r\n  @Input() helperMessage: string = '';\r\n  @Input() i18n: {\r\n    months: {\r\n      [s: string]: string;\r\n    };\r\n    days: {\r\n      [s: string]: string;\r\n    };\r\n    actions: {\r\n      [s: string]: string;\r\n    };\r\n    today: string;\r\n  };\r\n  @Input() infoMessage: string;\r\n  @Input() errorMessage: string;\r\n  @Input() minDate: any = null;\r\n  @Output() onChange = new EventEmitter<any>();\r\n\r\n  private today = moment.default().format('YYYY-MM-DD');\r\n  private onModelChange = (value: any) => {};\r\n  private onModelTouched = (value: any) => {};\r\n\r\n  public _dateFirst = moment.default();\r\n  public _dateSecond = moment.default().add(1, 'M');\r\n  public _id: string = `mecx-date-range-picker-${MonkeyUtils.getRandomString(10)}`;\r\n  public _daysArrFirst = [];\r\n  public _daysArrSecond = [];\r\n  public _dateForm: FormGroup;\r\n  public _disabled: boolean = false;\r\n\r\n  constructor(private fb: FormBuilder, private cdr: ChangeDetectorRef) {\r\n    this.initDateRange();\r\n  }\r\n\r\n  private initDateRange() {\r\n    return (this._dateForm = this.fb.group({\r\n      startDate: [null, Validators.required],\r\n      endDate: [null, Validators.required],\r\n    }));\r\n  }\r\n\r\n  private createCalendar(month: moment.Moment) {\r\n    let firstDay = moment.default(month).startOf('M');\r\n    let lastDay = moment.default(month).endOf('M');\r\n    let days = Array.apply(null, { length: month.daysInMonth() })\r\n      .map(Number.call, Number)\r\n      .map((n: number) => {\r\n        return moment.default(firstDay).add(n, 'd');\r\n      });\r\n\r\n    let n = 0;\r\n    while (n < firstDay.weekday()) {\r\n      days.unshift(null);\r\n      n++;\r\n    }\r\n    n = 0;\r\n    while (n < 7 - lastDay.weekday()) {\r\n      days.push(null);\r\n      n++;\r\n    }\r\n\r\n    let index = 1;\r\n    let group = [];\r\n    let grouped = [];\r\n\r\n    Object.entries(days).map(([key, value]: [string, any]) => {\r\n      if (index > 7) {\r\n        index = 1;\r\n        grouped.push(group);\r\n        group = [];\r\n      }\r\n\r\n      group.push(value);\r\n      index++;\r\n    });\r\n    grouped.push(group);\r\n\r\n    return grouped;\r\n  }\r\n\r\n  private build() {\r\n    this._daysArrFirst = this.createCalendar(this._dateFirst);\r\n    this._daysArrSecond = this.createCalendar(this._dateSecond);\r\n  }\r\n\r\n  private clearDates() {\r\n    if (this._disabled) return;\r\n    this._dateForm.setValue({ startDate: null, endDate: null });\r\n    this.writeValue(this._dateForm.value);\r\n  }\r\n\r\n  navigateToToday() {\r\n    this._dateFirst = moment.default();\r\n    this._dateSecond = moment.default().add(1, 'M');\r\n    this.build();\r\n  }\r\n\r\n  ngOnInit() {\r\n    this.build();\r\n  }\r\n\r\n  registerOnChange(fn: any): void {\r\n    this.onModelChange = fn;\r\n  }\r\n\r\n  registerOnTouched(fn: any): void {\r\n    this.onModelTouched = fn;\r\n  }\r\n\r\n  setDisabledState?(isDisabled: boolean): void {\r\n    this._disabled = isDisabled;\r\n  }\r\n\r\n  @Input()\r\n  set value(value: any) {\r\n    if (\r\n      value &&\r\n      Object.prototype.hasOwnProperty.call(value, 'startDate') &&\r\n      Object.prototype.hasOwnProperty.call(value, 'endDate')\r\n    ) {\r\n      this._dateForm.setValue(value);\r\n      this.cdr.detectChanges();\r\n      this.onModelChange(this._dateForm.value);\r\n      this.onModelTouched(this._dateForm.value);\r\n    } else {\r\n      this.clearDates();\r\n    }\r\n  }\r\n\r\n  get value(): any {\r\n    return this._dateForm.value;\r\n  }\r\n\r\n  writeValue(value: any): void {\r\n    this.value = value;\r\n    this.onChange.next(value);\r\n  }\r\n\r\n  nextMonth() {\r\n    if (this._disabled) return;\r\n    this._dateFirst.add(1, 'M');\r\n    this._dateSecond.add(1, 'M');\r\n\r\n    this._daysArrFirst = this.createCalendar(this._dateFirst);\r\n    this._daysArrSecond = this.createCalendar(this._dateSecond);\r\n  }\r\n\r\n  previousMonth() {\r\n    if (this._disabled) return;\r\n    this._dateFirst.subtract(1, 'M');\r\n    this._dateSecond.subtract(1, 'M');\r\n\r\n    this._daysArrFirst = this.createCalendar(this._dateFirst);\r\n    this._daysArrSecond = this.createCalendar(this._dateSecond);\r\n  }\r\n\r\n  todayCheck(day: moment.Moment) {\r\n    if (!day) {\r\n      return false;\r\n    }\r\n\r\n    return moment.default().format('L') === day.format('L');\r\n  }\r\n\r\n  isSelected(day: moment.Moment) {\r\n    if (!day) {\r\n      return false;\r\n    }\r\n\r\n    let startDateMoment = moment.default(this._dateForm.value.startDate, 'YYYY-MM-DD');\r\n    let endDateMoment = moment.default(this._dateForm.value.endDate, 'YYYY-MM-DD');\r\n\r\n    if (this._dateForm.valid) {\r\n      return startDateMoment.isSameOrBefore(day) && endDateMoment.isSameOrAfter(day);\r\n    }\r\n\r\n    if (this._dateForm.get('startDate').valid) {\r\n      return startDateMoment.isSame(day);\r\n    }\r\n  }\r\n\r\n  isDisabled(day) {\r\n    const { minDate } = this;\r\n    if (minDate) {\r\n      const firstDay = moment.default(minDate);\r\n      return day.isBefore(firstDay.subtract(1, 'day'));\r\n    }\r\n    return false;\r\n  }\r\n\r\n  isFirstSelected(day) {\r\n    const { _dateForm } = this;\r\n    const { startDate } = _dateForm.value;\r\n    return day?.isSame(startDate);\r\n  }\r\n\r\n  isLastSelected(day: moment.Moment) {\r\n    const { _dateForm } = this;\r\n    const { endDate } = _dateForm.value;\r\n    return day?.isSame(endDate);\r\n  }\r\n\r\n  selectedDate(day: moment.Moment) {\r\n    if (this._disabled) return;\r\n    const { _dateForm, minDate } = this;\r\n    let dayFormatted = day.format('YYYY-MM-DD');\r\n\r\n    if (minDate) {\r\n      const firstDay = moment.default(minDate);\r\n      if (day.isBefore(firstDay.subtract(1, 'day'))) return;\r\n    }\r\n\r\n    if (_dateForm.valid) {\r\n      this.clearDates();\r\n    }\r\n\r\n    let { startDate, endDate } = _dateForm.value;\r\n    if (startDate) {\r\n      if (moment.default(startDate).isAfter(moment.default(dayFormatted))) {\r\n        endDate = startDate;\r\n        startDate = dayFormatted;\r\n      } else {\r\n        endDate = dayFormatted;\r\n      }\r\n    } else startDate = dayFormatted;\r\n\r\n    if (startDate) {\r\n      _dateForm.get('startDate').patchValue(startDate);\r\n    }\r\n\r\n    if (endDate) {\r\n      _dateForm.get('endDate').patchValue(endDate);\r\n    }\r\n\r\n    this.writeValue(_dateForm.value);\r\n  }\r\n\r\n  selectRangeOfDays(days: number) {\r\n    if (this._disabled) return;\r\n    const { _dateForm, minDate, today } = this;\r\n    const { startDate } = _dateForm.value;\r\n\r\n    const firstDay = moment.default(startDate || minDate || today).format('YYYY-MM-DD');\r\n    const lastDay = moment.default(firstDay).add(days, 'day').format('YYYY-MM-DD');\r\n    _dateForm.get('startDate').patchValue(firstDay);\r\n    _dateForm.get('endDate').patchValue(lastDay);\r\n    this.writeValue(_dateForm.value);\r\n  }\r\n}\r\n"]}

package/{esm2015/lib/components/date-range-picker/date-range-picker.module.js → esm2020/lib/components/date-range-picker/date-range-picker.module.mjs}

@@ -7,10 +7,10 @@ import { MonkeyButtonModule } from '../button/button.module';
 import * as i0 from "@angular/core";
 export class MonkeyDateRangePickerModule {
 }
-MonkeyDateRangePickerModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.14", ngImport: i0, type: MonkeyDateRangePickerModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-MonkeyDateRangePickerModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.14", ngImport: i0, type: MonkeyDateRangePickerModule, declarations: [MonkeyDateRangePickerComponent], imports: [CommonModule, FormsModule, ReactiveFormsModule, MonkeyButtonModule, MonkeyIconModule], exports: [MonkeyDateRangePickerComponent] });
-MonkeyDateRangePickerModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.14", ngImport: i0, type: MonkeyDateRangePickerModule, imports: [[CommonModule, FormsModule, ReactiveFormsModule, MonkeyButtonModule, MonkeyIconModule]] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.14", ngImport: i0, type: MonkeyDateRangePickerModule, decorators: [{
+MonkeyDateRangePickerModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: MonkeyDateRangePickerModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+MonkeyDateRangePickerModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: MonkeyDateRangePickerModule, declarations: [MonkeyDateRangePickerComponent], imports: [CommonModule, FormsModule, ReactiveFormsModule, MonkeyButtonModule, MonkeyIconModule], exports: [MonkeyDateRangePickerComponent] });
+MonkeyDateRangePickerModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: MonkeyDateRangePickerModule, imports: [[CommonModule, FormsModule, ReactiveFormsModule, MonkeyButtonModule, MonkeyIconModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: MonkeyDateRangePickerModule, decorators: [{
             type: NgModule,
             args: [{
                     declarations: [MonkeyDateRangePickerComponent],
@@ -19,4 +19,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.14", ngImpo
                     schemas: [NO_ERRORS_SCHEMA],
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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