@mis-wis/common 0.1.6 → 0.1.7

package/esm2020/src/lib/components/datepicker/reducer/bs-datepicker.effects.mjs

@@ -0,0 +1,171 @@
+/* tslint:disable:max-file-line-count */
+import { Injectable } from '@angular/core';
+import { filter, map } from 'rxjs/operators';
+import { MisDatePickerActions } from './bs-datepicker.actions';
+import { BsLocaleService } from '../bs-locale.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./bs-datepicker.actions";
+import * as i2 from "../bs-locale.service";
+export class MisDatePickerEffects {
+    constructor(_actions, _localeService) {
+        this._actions = _actions;
+        this._localeService = _localeService;
+        this._subs = [];
+    }
+    init(_misDatePickerStore) {
+        this._store = _misDatePickerStore;
+        return this;
+    }
+    /** setters */
+    setValue(value) {
+        this._store.dispatch(this._actions.select(value));
+    }
+    setRangeValue(value) {
+        this._store.dispatch(this._actions.selectRange(value));
+    }
+    setMinDate(value) {
+        this._store.dispatch(this._actions.minDate(value));
+        return this;
+    }
+    setMaxDate(value) {
+        this._store.dispatch(this._actions.maxDate(value));
+        return this;
+    }
+    setDaysDisabled(value) {
+        this._store.dispatch(this._actions.daysDisabled(value));
+        return this;
+    }
+    setDatesDisabled(value) {
+        this._store.dispatch(this._actions.datesDisabled(value));
+        return this;
+    }
+    setDatesEnabled(value) {
+        this._store.dispatch(this._actions.datesEnabled(value));
+        return this;
+    }
+    setDisabled(value) {
+        this._store.dispatch(this._actions.isDisabled(value));
+        return this;
+    }
+    setDateCustomClasses(value) {
+        this._store.dispatch(this._actions.setDateCustomClasses(value));
+        return this;
+    }
+    setDateTooltipTexts(value) {
+        this._store.dispatch(this._actions.setDateTooltipTexts(value));
+        return this;
+    }
+    /* Set rendering options */
+    setOptions(_config) {
+        const _options = Object.assign({ locale: this._localeService.currentLocale }, _config);
+        this._store.dispatch(this._actions.setOptions(_options));
+        return this;
+    }
+    /** view to mode bindings */
+    setBindings(container) {
+        container.daysCalendar = this._store
+            .select(state => state.flaggedMonths)
+            .pipe(filter(months => !!months));
+        // month calendar
+        container.monthsCalendar = this._store
+            .select(state => state.flaggedMonthsCalendar)
+            .pipe(filter(months => !!months));
+        // year calendar
+        container.yearsCalendar = this._store
+            .select(state => state.yearsCalendarFlagged)
+            .pipe(filter(years => !!years));
+        container.viewMode = this._store.select(state => state.view.mode);
+        container.options = this._store
+            .select(state => state.showWeekNumbers)
+            .pipe(map(showWeekNumbers => ({ showWeekNumbers })));
+        return this;
+    }
+    /** event handlers */
+    setEventHandlers(container) {
+        container.setViewMode = (event) => {
+            this._store.dispatch(this._actions.changeViewMode(event));
+        };
+        container.navigateTo = (event) => {
+            this._store.dispatch(this._actions.navigateStep(event.step));
+        };
+        container.dayHoverHandler = (event) => {
+            const _cell = event.cell;
+            if (_cell.isOtherMonth || _cell.isDisabled) {
+                return;
+            }
+            this._store.dispatch(this._actions.hoverDay(event));
+            _cell.isHovered = event.isHovered;
+        };
+        container.monthHoverHandler = (event) => {
+            event.cell.isHovered = event.isHovered;
+        };
+        container.yearHoverHandler = (event) => {
+            event.cell.isHovered = event.isHovered;
+        };
+        return this;
+    }
+    registerDatePickerSideEffects() {
+        this._subs.push(this._store.select(state => state.view).subscribe(view => {
+            this._store.dispatch(this._actions.calculate());
+        }));
+        // format calendar values on month model change
+        this._subs.push(this._store
+            .select(state => state.monthsModel)
+            .pipe(filter(monthModel => !!monthModel))
+            .subscribe(month => this._store.dispatch(this._actions.format())));
+        // flag day values
+        this._subs.push(this._store
+            .select(state => state.formattedMonths)
+            .pipe(filter(month => !!month))
+            .subscribe(month => this._store.dispatch(this._actions.flag())));
+        // flag day values
+        this._subs.push(this._store
+            .select(state => state.selectedDate)
+            .pipe(filter(selectedDate => !!selectedDate))
+            .subscribe(selectedDate => this._store.dispatch(this._actions.flag())));
+        // flag for date range picker
+        this._subs.push(this._store
+            .select(state => state.selectedRange)
+            .pipe(filter(selectedRange => !!selectedRange))
+            .subscribe(selectedRange => this._store.dispatch(this._actions.flag())));
+        // monthsCalendar
+        this._subs.push(this._store
+            .select(state => state.monthsCalendar)
+            .subscribe(() => this._store.dispatch(this._actions.flag())));
+        // years calendar
+        this._subs.push(this._store
+            .select(state => state.yearsCalendarModel)
+            .pipe(filter(state => !!state))
+            .subscribe(() => this._store.dispatch(this._actions.flag())));
+        // on hover
+        this._subs.push(this._store
+            .select(state => state.hoveredDate)
+            .pipe(filter(hoveredDate => !!hoveredDate))
+            .subscribe(hoveredDate => this._store.dispatch(this._actions.flag())));
+        // date custom classes
+        this._subs.push(this._store
+            .select(state => state.dateCustomClasses)
+            .pipe(filter(dateCustomClasses => !!dateCustomClasses))
+            .subscribe(dateCustomClasses => this._store.dispatch(this._actions.flag())));
+        // date tooltip texts
+        this._subs.push(this._store
+            .select(state => state.dateTooltipTexts)
+            .pipe(filter(dateTooltipTexts => !!dateTooltipTexts))
+            .subscribe(dateTooltipTexts => this._store.dispatch(this._actions.flag())));
+        // on locale change
+        this._subs.push(this._localeService.localeChange
+            .subscribe(locale => this._store.dispatch(this._actions.setLocale(locale))));
+        return this;
+    }
+    destroy() {
+        for (const sub of this._subs) {
+            sub.unsubscribe();
+        }
+    }
+}
+MisDatePickerEffects.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: MisDatePickerEffects, deps: [{ token: i1.MisDatePickerActions }, { token: i2.BsLocaleService }], target: i0.ɵɵFactoryTarget.Injectable });
+MisDatePickerEffects.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: MisDatePickerEffects });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: MisDatePickerEffects, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.MisDatePickerActions }, { type: i2.BsLocaleService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bs-datepicker.effects.js","sourceRoot":"","sources":["../../../../../../../../libraries/wis-common/src/lib/components/datepicker/reducer/bs-datepicker.effects.ts"],"names":[],"mappings":"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","sourcesContent":["/* tslint:disable:max-file-line-count */\nimport { Injectable } from '@angular/core';\n\nimport { Observable, Subscription } from 'rxjs';\nimport { filter, map } from 'rxjs/operators';\n\nimport { MisDatePickerAbstractComponent } from '../base/bs-datepicker-container';\nimport { MisDatePickerActions } from './bs-datepicker.actions';\nimport { MisDatePickerConfig } from '../bs-datepicker.config';\nimport { MisDatePickerStore } from './bs-datepicker.store';\nimport { BsLocaleService } from '../bs-locale.service';\n\nimport {\n  MisDatePickerViewMode,\n  BsNavigationEvent,\n  CellHoverEvent,\n  DatePickerRenderOptions,\n  DatePickerDateCustomClasses,\n  DatePickerDateTooltipText,\n  DaysCalendarViewModel,\n  DayViewModel,\n  MonthsCalendarViewModel,\n  YearsCalendarViewModel\n} from '../models';\n\n\n@Injectable()\nexport class MisDatePickerEffects {\n  viewMode: Observable<MisDatePickerViewMode>;\n  daysCalendar: Observable<DaysCalendarViewModel[]>;\n  monthsCalendar: Observable<MonthsCalendarViewModel[]>;\n  yearsCalendar: Observable<YearsCalendarViewModel[]>;\n  options: Observable<DatePickerRenderOptions>;\n\n  private _store: MisDatePickerStore;\n  private _subs: Subscription[] = [];\n\n  constructor(private _actions: MisDatePickerActions,\n              private _localeService: BsLocaleService) {}\n\n  init(_misDatePickerStore: MisDatePickerStore): MisDatePickerEffects {\n    this._store = _misDatePickerStore;\n\n    return this;\n  }\n\n  /** setters */\n\n  setValue(value: Date): void {\n    this._store.dispatch(this._actions.select(value));\n  }\n\n  setRangeValue(value: Date[]): void {\n    this._store.dispatch(this._actions.selectRange(value));\n  }\n\n  setMinDate(value: Date): MisDatePickerEffects {\n    this._store.dispatch(this._actions.minDate(value));\n\n    return this;\n  }\n\n  setMaxDate(value: Date): MisDatePickerEffects {\n    this._store.dispatch(this._actions.maxDate(value));\n\n    return this;\n  }\n\n  setDaysDisabled(value: number[]): MisDatePickerEffects  {\n    this._store.dispatch(this._actions.daysDisabled(value));\n\n    return this;\n  }\n\n  setDatesDisabled(value: Date[]): MisDatePickerEffects  {\n    this._store.dispatch(this._actions.datesDisabled(value));\n\n    return this;\n  }\n\n  setDatesEnabled(value: Date[]): MisDatePickerEffects {\n    this._store.dispatch(this._actions.datesEnabled(value));\n\n    return this;\n  }\n\n  setDisabled(value: boolean): MisDatePickerEffects {\n    this._store.dispatch(this._actions.isDisabled(value));\n\n    return this;\n  }\n\n  setDateCustomClasses(value: DatePickerDateCustomClasses[]): MisDatePickerEffects {\n    this._store.dispatch(this._actions.setDateCustomClasses(value));\n\n    return this;\n  }\n\n  setDateTooltipTexts(value: DatePickerDateTooltipText[]): MisDatePickerEffects {\n    this._store.dispatch(this._actions.setDateTooltipTexts(value));\n\n    return this;\n  }\n\n  /* Set rendering options */\n  setOptions(_config: MisDatePickerConfig): MisDatePickerEffects {\n    const _options = Object.assign({locale: this._localeService.currentLocale}, _config);\n    this._store.dispatch(this._actions.setOptions(_options));\n\n    return this;\n  }\n\n  /** view to mode bindings */\n  setBindings(container: MisDatePickerAbstractComponent): MisDatePickerEffects {\n    container.daysCalendar = this._store\n      .select(state => state.flaggedMonths)\n      .pipe(\n        filter(months => !!months)\n      );\n\n    // month calendar\n    container.monthsCalendar = this._store\n      .select(state => state.flaggedMonthsCalendar)\n      .pipe(\n        filter(months => !!months)\n      );\n\n    // year calendar\n    container.yearsCalendar = this._store\n      .select(state => state.yearsCalendarFlagged)\n      .pipe(\n        filter(years => !!years)\n      );\n\n    container.viewMode = this._store.select(state => state.view.mode);\n\n    container.options = this._store\n      .select(state => state.showWeekNumbers)\n      .pipe(\n        map(showWeekNumbers => ({showWeekNumbers}))\n      );\n\n    return this;\n  }\n\n  /** event handlers */\n  setEventHandlers(container: MisDatePickerAbstractComponent): MisDatePickerEffects {\n    container.setViewMode = (event: MisDatePickerViewMode): void => {\n      this._store.dispatch(this._actions.changeViewMode(event));\n    };\n\n    container.navigateTo = (event: BsNavigationEvent): void => {\n      this._store.dispatch(this._actions.navigateStep(event.step));\n    };\n\n    container.dayHoverHandler = (event: CellHoverEvent): void => {\n      const _cell = event.cell as DayViewModel;\n      if (_cell.isOtherMonth || _cell.isDisabled) {\n        return;\n      }\n\n      this._store.dispatch(this._actions.hoverDay(event));\n      _cell.isHovered = event.isHovered;\n    };\n\n    container.monthHoverHandler = (event: CellHoverEvent): void => {\n      event.cell.isHovered = event.isHovered;\n    };\n\n    container.yearHoverHandler = (event: CellHoverEvent): void => {\n      event.cell.isHovered = event.isHovered;\n    };\n\n    return this;\n  }\n\n  registerDatePickerSideEffects(): MisDatePickerEffects {\n    this._subs.push(\n      this._store.select(state => state.view).subscribe(view => {\n        this._store.dispatch(this._actions.calculate());\n      })\n    );\n\n    // format calendar values on month model change\n    this._subs.push(\n      this._store\n        .select(state => state.monthsModel)\n        .pipe(\n          filter(monthModel => !!monthModel)\n        )\n        .subscribe(month => this._store.dispatch(this._actions.format()))\n    );\n\n    // flag day values\n    this._subs.push(\n      this._store\n        .select(state => state.formattedMonths)\n        .pipe(\n          filter(month => !!month)\n        )\n        .subscribe(month => this._store.dispatch(this._actions.flag()))\n    );\n\n    // flag day values\n    this._subs.push(\n      this._store\n        .select(state => state.selectedDate)\n        .pipe(\n          filter(selectedDate => !!selectedDate)\n        )\n        .subscribe(selectedDate => this._store.dispatch(this._actions.flag()))\n    );\n\n    // flag for date range picker\n    this._subs.push(\n      this._store\n        .select(state => state.selectedRange)\n        .pipe(\n          filter(selectedRange => !!selectedRange)\n        )\n        .subscribe(selectedRange => this._store.dispatch(this._actions.flag()))\n    );\n\n    // monthsCalendar\n    this._subs.push(\n      this._store\n        .select(state => state.monthsCalendar)\n        .subscribe(() => this._store.dispatch(this._actions.flag()))\n    );\n\n    // years calendar\n    this._subs.push(\n      this._store\n        .select(state => state.yearsCalendarModel)\n        .pipe(\n          filter(state => !!state)\n        )\n        .subscribe(() => this._store.dispatch(this._actions.flag()))\n    );\n\n    // on hover\n    this._subs.push(\n      this._store\n        .select(state => state.hoveredDate)\n        .pipe(\n          filter(hoveredDate => !!hoveredDate)\n        )\n        .subscribe(hoveredDate => this._store.dispatch(this._actions.flag()))\n    );\n\n    // date custom classes\n    this._subs.push(\n      this._store\n        .select(state => state.dateCustomClasses)\n        .pipe(\n          filter(dateCustomClasses => !!dateCustomClasses)\n        )\n        .subscribe(dateCustomClasses => this._store.dispatch(this._actions.flag()))\n    );\n\n    // date tooltip texts\n    this._subs.push(\n      this._store\n        .select(state => state.dateTooltipTexts)\n        .pipe(\n          filter(dateTooltipTexts => !!dateTooltipTexts)\n        )\n        .subscribe(dateTooltipTexts => this._store.dispatch(this._actions.flag()))\n    );\n\n    // on locale change\n    this._subs.push(\n      this._localeService.localeChange\n        .subscribe(locale => this._store.dispatch(this._actions.setLocale(locale)))\n    );\n\n    return this;\n  }\n\n  destroy(): void {\n    for (const sub of this._subs) {\n      sub.unsubscribe();\n    }\n  }\n}\n"]}

package/esm2020/src/lib/components/datepicker/reducer/bs-datepicker.reducer.mjs

@@ -0,0 +1,302 @@
+// tslint:disable:max-file-line-count
+import { initialDatePickerState } from './bs-datepicker.state';
+import { MisDatePickerActions } from './bs-datepicker.actions';
+import { calcDaysCalendar } from '../engine/calc-days-calendar';
+import { formatDaysCalendar } from '../engine/format-days-calendar';
+import { flagDaysCalendar } from '../engine/flag-days-calendar';
+import { setFullDate, shiftDate, isArray, isDateValid, startOf, getLocale, isAfter, isBefore, isSame } from '../chronos';
+import { canSwitchMode } from '../engine/view-mode';
+import { formatMonthsCalendar } from '../engine/format-months-calendar';
+import { flagMonthsCalendar } from '../engine/flag-months-calendar';
+import { formatYearsCalendar, initialYearShift, yearsPerCalendar } from '../engine/format-years-calendar';
+import { flagYearsCalendar } from '../engine/flag-years-calendar';
+import { getYearsCalendarInitialDate } from '../utils/bs-calendar-utils';
+/* tslint:disable-next-line: cyclomatic-complexity */
+export function misDatePickerReducer(state = initialDatePickerState, action) {
+    switch (action.type) {
+        case MisDatePickerActions.CALCULATE: {
+            return calculateReducer(state);
+        }
+        case MisDatePickerActions.FORMAT: {
+            return formatReducer(state, action);
+        }
+        case MisDatePickerActions.FLAG: {
+            return flagReducer(state, action);
+        }
+        case MisDatePickerActions.NAVIGATE_OFFSET: {
+            return navigateOffsetReducer(state, action);
+        }
+        case MisDatePickerActions.NAVIGATE_TO: {
+            const payload = action.payload;
+            const date = setFullDate(state.view.date, payload.unit);
+            let newState;
+            let mode;
+            if (canSwitchMode(payload.viewMode, state.minMode)) {
+                mode = payload.viewMode;
+                newState = { view: { date, mode } };
+            }
+            else {
+                mode = state.view.mode;
+                newState = { selectedDate: date, view: { date, mode } };
+            }
+            return Object.assign({}, state, newState);
+        }
+        case MisDatePickerActions.CHANGE_VIEWMODE: {
+            if (!canSwitchMode(action.payload, state.minMode)) {
+                return state;
+            }
+            const date = state.view.date;
+            const mode = action.payload;
+            const newState = { view: { date, mode } };
+            return Object.assign({}, state, newState);
+        }
+        case MisDatePickerActions.HOVER: {
+            return Object.assign({}, state, { hoveredDate: action.payload });
+        }
+        case MisDatePickerActions.SELECT: {
+            const newState = {
+                selectedDate: action.payload,
+                view: state.view
+            };
+            const mode = state.view.mode;
+            const _date = action.payload || state.view.date;
+            const date = getViewDate(_date, state.minDate, state.maxDate);
+            newState.view = { mode, date };
+            return Object.assign({}, state, newState);
+        }
+        case MisDatePickerActions.SET_OPTIONS: {
+            const newState = action.payload;
+            // preserve view mode
+            const mode = newState.minMode ? newState.minMode : state.view.mode;
+            const _viewDate = isDateValid(newState.value) && newState.value
+                || isArray(newState.value) && isDateValid(newState.value[0]) && newState.value[0]
+                || state.view.date;
+            const date = getViewDate(_viewDate, newState.minDate, newState.maxDate);
+            newState.view = { mode, date };
+            // update selected value
+            if (newState.value) {
+                // if new value is array we work with date range
+                if (isArray(newState.value)) {
+                    newState.selectedRange = newState.value;
+                }
+                // if new value is a date -> datepicker
+                if (newState.value instanceof Date) {
+                    newState.selectedDate = newState.value;
+                }
+                // provided value is not supported :)
+                // need to report it somehow
+            }
+            return Object.assign({}, state, newState);
+        }
+        // date range picker
+        case MisDatePickerActions.SELECT_RANGE: {
+            const newState = {
+                selectedRange: action.payload,
+                view: state.view
+            };
+            const mode = state.view.mode;
+            const _date = action.payload && action.payload[0] || state.view.date;
+            const date = getViewDate(_date, state.minDate, state.maxDate);
+            newState.view = { mode, date };
+            return Object.assign({}, state, newState);
+        }
+        case MisDatePickerActions.SET_MIN_DATE: {
+            return Object.assign({}, state, {
+                minDate: action.payload
+            });
+        }
+        case MisDatePickerActions.SET_MAX_DATE: {
+            return Object.assign({}, state, {
+                maxDate: action.payload
+            });
+        }
+        case MisDatePickerActions.SET_IS_DISABLED: {
+            return Object.assign({}, state, {
+                isDisabled: action.payload
+            });
+        }
+        case MisDatePickerActions.SET_DATE_CUSTOM_CLASSES: {
+            return Object.assign({}, state, {
+                dateCustomClasses: action.payload
+            });
+        }
+        case MisDatePickerActions.SET_DATE_TOOLTIP_TEXTS: {
+            return Object.assign({}, state, {
+                dateTooltipTexts: action.payload
+            });
+        }
+        default:
+            return state;
+    }
+}
+function calculateReducer(state) {
+    // how many calendars
+    const displayMonths = (state.displayOneMonthRange &&
+        isDisplayOneMonth(state.view.date, state.minDate, state.maxDate)) ? 1 : state.displayMonths;
+    // use selected date on initial rendering if set
+    let viewDate = state.view.date;
+    if (state.view.mode === 'day') {
+        if (state.showPreviousMonth && state.selectedRange && state.selectedRange.length === 0) {
+            viewDate = shiftDate(viewDate, { month: -1 });
+        }
+        state.monthViewOptions.firstDayOfWeek = getLocale(state.locale).firstDayOfWeek();
+        const monthsModel = new Array(displayMonths);
+        for (let monthIndex = 0; monthIndex < displayMonths; monthIndex++) {
+            // todo: for unlinked calendars it will be harder
+            monthsModel[monthIndex] = calcDaysCalendar(viewDate, state.monthViewOptions);
+            viewDate = shiftDate(viewDate, { month: 1 });
+        }
+        return Object.assign({}, state, { monthsModel });
+    }
+    if (state.view.mode === 'month') {
+        const monthsCalendar = new Array(displayMonths);
+        for (let calendarIndex = 0; calendarIndex < displayMonths; calendarIndex++) {
+            // todo: for unlinked calendars it will be harder
+            monthsCalendar[calendarIndex] = formatMonthsCalendar(viewDate, getFormatOptions(state));
+            viewDate = shiftDate(viewDate, { year: 1 });
+        }
+        return Object.assign({}, state, { monthsCalendar });
+    }
+    if (state.view.mode === 'year') {
+        const yearsCalendarModel = new Array(displayMonths);
+        for (let calendarIndex = 0; calendarIndex < displayMonths; calendarIndex++) {
+            // todo: for unlinked calendars it will be harder
+            yearsCalendarModel[calendarIndex] = formatYearsCalendar(viewDate, getFormatOptions(state), state.minMode === 'year' ? getYearsCalendarInitialDate(state, calendarIndex) : undefined);
+            viewDate = shiftDate(viewDate, { year: yearsPerCalendar });
+        }
+        return Object.assign({}, state, { yearsCalendarModel });
+    }
+    return state;
+}
+function formatReducer(state, action) {
+    if (state.view.mode === 'day') {
+        const formattedMonths = state.monthsModel.map((month, monthIndex) => formatDaysCalendar(month, getFormatOptions(state), monthIndex));
+        return Object.assign({}, state, { formattedMonths });
+    }
+    // how many calendars
+    const displayMonths = state.displayMonths;
+    // check initial rendering
+    // use selected date on initial rendering if set
+    let viewDate = state.view.date;
+    if (state.view.mode === 'month') {
+        const monthsCalendar = new Array(displayMonths);
+        for (let calendarIndex = 0; calendarIndex < displayMonths; calendarIndex++) {
+            // todo: for unlinked calendars it will be harder
+            monthsCalendar[calendarIndex] = formatMonthsCalendar(viewDate, getFormatOptions(state));
+            viewDate = shiftDate(viewDate, { year: 1 });
+        }
+        return Object.assign({}, state, { monthsCalendar });
+    }
+    if (state.view.mode === 'year') {
+        const yearsCalendarModel = new Array(displayMonths);
+        for (let calendarIndex = 0; calendarIndex < displayMonths; calendarIndex++) {
+            // todo: for unlinked calendars it will be harder
+            yearsCalendarModel[calendarIndex] = formatYearsCalendar(viewDate, getFormatOptions(state));
+            viewDate = shiftDate(viewDate, { year: 16 });
+        }
+        return Object.assign({}, state, { yearsCalendarModel });
+    }
+    return state;
+}
+function flagReducer(state, action) {
+    const displayMonths = isDisplayOneMonth(state.view.date, state.minDate, state.maxDate) ? 1 : state.displayMonths;
+    if (state.view.mode === 'day') {
+        const flaggedMonths = state.formattedMonths.map((formattedMonth, monthIndex) => flagDaysCalendar(formattedMonth, {
+            isDisabled: state.isDisabled,
+            minDate: state.minDate,
+            maxDate: state.maxDate,
+            daysDisabled: state.daysDisabled,
+            datesDisabled: state.datesDisabled,
+            datesEnabled: state.datesEnabled,
+            hoveredDate: state.hoveredDate,
+            selectedDate: state.selectedDate,
+            selectedRange: state.selectedRange,
+            displayMonths,
+            dateCustomClasses: state.dateCustomClasses,
+            dateTooltipTexts: state.dateTooltipTexts,
+            monthIndex
+        }));
+        return Object.assign({}, state, { flaggedMonths });
+    }
+    if (state.view.mode === 'month') {
+        const flaggedMonthsCalendar = state.monthsCalendar.map((formattedMonth, monthIndex) => flagMonthsCalendar(formattedMonth, {
+            isDisabled: state.isDisabled,
+            minDate: state.minDate,
+            maxDate: state.maxDate,
+            hoveredMonth: state.hoveredMonth,
+            selectedDate: state.selectedDate,
+            selectedRange: state.selectedRange,
+            displayMonths,
+            monthIndex
+        }));
+        return Object.assign({}, state, { flaggedMonthsCalendar });
+    }
+    if (state.view.mode === 'year') {
+        const yearsCalendarFlagged = state.yearsCalendarModel.map((formattedMonth, yearIndex) => flagYearsCalendar(formattedMonth, {
+            isDisabled: state.isDisabled,
+            minDate: state.minDate,
+            maxDate: state.maxDate,
+            hoveredYear: state.hoveredYear,
+            selectedDate: state.selectedDate,
+            selectedRange: state.selectedRange,
+            displayMonths,
+            yearIndex
+        }));
+        return Object.assign({}, state, { yearsCalendarFlagged });
+    }
+    return state;
+}
+function navigateOffsetReducer(state, action) {
+    const newState = {
+        view: {
+            mode: state.view.mode,
+            date: shiftViewDate(state, action)
+        }
+    };
+    return Object.assign({}, state, newState);
+}
+function shiftViewDate(state, action) {
+    if (state.view.mode === 'year' && state.minMode === 'year') {
+        const initialDate = getYearsCalendarInitialDate(state, 0);
+        const middleDate = shiftDate(initialDate, { year: -initialYearShift });
+        return shiftDate(middleDate, action.payload);
+    }
+    return shiftDate(startOf(state.view.date, 'month'), action.payload);
+}
+function getFormatOptions(state) {
+    return {
+        locale: state.locale,
+        monthTitle: state.monthTitle,
+        yearTitle: state.yearTitle,
+        dayLabel: state.dayLabel,
+        monthLabel: state.monthLabel,
+        yearLabel: state.yearLabel,
+        weekNumbers: state.weekNumbers
+    };
+}
+/**
+ * if view date is provided (bsValue|ngModel) it should be shown
+ * if view date is not provider:
+ * if minDate>currentDate (default view value), show minDate
+ * if maxDate<currentDate(default view value) show maxDate
+ */
+function getViewDate(viewDate, minDate, maxDate) {
+    const _date = Array.isArray(viewDate) ? viewDate[0] : viewDate;
+    if (minDate && isAfter(minDate, _date, 'day')) {
+        return minDate;
+    }
+    if (maxDate && isBefore(maxDate, _date, 'day')) {
+        return maxDate;
+    }
+    return _date;
+}
+function isDisplayOneMonth(viewDate, minDate, maxDate) {
+    if (maxDate && isSame(maxDate, viewDate, 'day')) {
+        return true;
+    }
+    if (minDate && maxDate && minDate.getMonth() === maxDate.getMonth()) {
+        return true;
+    }
+    return false;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bs-datepicker.reducer.js","sourceRoot":"","sources":["../../../../../../../../libraries/wis-common/src/lib/components/datepicker/reducer/bs-datepicker.reducer.ts"],"names":[],"mappings":"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","sourcesContent":["// tslint:disable:max-file-line-count\nimport { MisDatePickerState, initialDatePickerState } from './bs-datepicker.state';\nimport { Action } from '../mini-ngrx';\nimport { MisDatePickerActions } from './bs-datepicker.actions';\nimport { calcDaysCalendar } from '../engine/calc-days-calendar';\nimport { formatDaysCalendar } from '../engine/format-days-calendar';\nimport { flagDaysCalendar } from '../engine/flag-days-calendar';\nimport {\n  setFullDate,\n  shiftDate,\n  isArray,\n  isDateValid,\n  startOf,\n  getLocale,\n  isAfter,\n  isBefore,\n  isSame\n} from '../chronos';\nimport { canSwitchMode } from '../engine/view-mode';\nimport { formatMonthsCalendar } from '../engine/format-months-calendar';\nimport { flagMonthsCalendar } from '../engine/flag-months-calendar';\nimport { formatYearsCalendar, initialYearShift, yearsPerCalendar } from '../engine/format-years-calendar';\nimport { flagYearsCalendar } from '../engine/flag-years-calendar';\nimport { BsViewNavigationEvent, DatePickerFormatOptions, MisDatePickerViewMode } from '../models';\nimport { getYearsCalendarInitialDate } from '../utils/bs-calendar-utils';\n\n\n/* tslint:disable-next-line: cyclomatic-complexity */\nexport function misDatePickerReducer(state = initialDatePickerState,\n                                    action: Action): MisDatePickerState {\n  switch (action.type) {\n    case MisDatePickerActions.CALCULATE: {\n      return calculateReducer(state);\n    }\n\n    case MisDatePickerActions.FORMAT: {\n      return formatReducer(state, action);\n    }\n\n    case MisDatePickerActions.FLAG: {\n      return flagReducer(state, action);\n    }\n\n    case MisDatePickerActions.NAVIGATE_OFFSET: {\n      return navigateOffsetReducer(state, action);\n    }\n\n    case MisDatePickerActions.NAVIGATE_TO: {\n      const payload: BsViewNavigationEvent = action.payload;\n\n      const date = setFullDate(state.view.date, payload.unit);\n      let newState;\n      let mode: MisDatePickerViewMode;\n      if (canSwitchMode(payload.viewMode, state.minMode)) {\n        mode = payload.viewMode;\n        newState = { view: { date, mode } };\n      } else {\n        mode = state.view.mode;\n        newState = { selectedDate: date, view: { date, mode } };\n      }\n\n      return Object.assign({}, state, newState);\n    }\n\n    case MisDatePickerActions.CHANGE_VIEWMODE: {\n      if (!canSwitchMode(action.payload, state.minMode)) {\n        return state;\n      }\n      const date = state.view.date;\n      const mode = action.payload;\n      const newState = { view: { date, mode } };\n\n      return Object.assign({}, state, newState);\n    }\n\n    case MisDatePickerActions.HOVER: {\n      return Object.assign({}, state, { hoveredDate: action.payload });\n    }\n\n    case MisDatePickerActions.SELECT: {\n      const newState = {\n        selectedDate: action.payload,\n        view: state.view\n      };\n\n      const mode = state.view.mode;\n      const _date = action.payload || state.view.date;\n      const date = getViewDate(_date, state.minDate, state.maxDate);\n      newState.view = { mode, date };\n\n      return Object.assign({}, state, newState);\n    }\n\n    case MisDatePickerActions.SET_OPTIONS: {\n      const newState = action.payload;\n      // preserve view mode\n      const mode = newState.minMode ? newState.minMode : state.view.mode;\n      const _viewDate = isDateValid(newState.value) && newState.value\n        || isArray(newState.value) && isDateValid(newState.value[0]) && newState.value[0]\n        || state.view.date;\n      const date = getViewDate(_viewDate, newState.minDate, newState.maxDate);\n      newState.view = { mode, date };\n      // update selected value\n      if (newState.value) {\n        // if new value is array we work with date range\n        if (isArray(newState.value)) {\n          newState.selectedRange = newState.value;\n        }\n\n        // if new value is a date -> datepicker\n        if (newState.value instanceof Date) {\n          newState.selectedDate = newState.value;\n        }\n\n        // provided value is not supported :)\n        // need to report it somehow\n      }\n\n      return Object.assign({}, state, newState);\n    }\n\n    // date range picker\n    case MisDatePickerActions.SELECT_RANGE: {\n      const newState = {\n        selectedRange: action.payload,\n        view: state.view\n      };\n\n      const mode = state.view.mode;\n      const _date = action.payload && action.payload[0] || state.view.date;\n      const date = getViewDate(_date, state.minDate, state.maxDate);\n      newState.view = { mode, date };\n\n      return Object.assign({}, state, newState);\n    }\n\n    case MisDatePickerActions.SET_MIN_DATE: {\n      return Object.assign({}, state, {\n        minDate: action.payload\n      });\n    }\n    case MisDatePickerActions.SET_MAX_DATE: {\n      return Object.assign({}, state, {\n        maxDate: action.payload\n      });\n    }\n    case MisDatePickerActions.SET_IS_DISABLED: {\n      return Object.assign({}, state, {\n        isDisabled: action.payload\n      });\n    }\n    case MisDatePickerActions.SET_DATE_CUSTOM_CLASSES: {\n      return Object.assign({}, state, {\n        dateCustomClasses: action.payload\n      });\n    }\n    case MisDatePickerActions.SET_DATE_TOOLTIP_TEXTS: {\n      return Object.assign({}, state, {\n        dateTooltipTexts: action.payload\n      });\n    }\n\n    default:\n      return state;\n  }\n}\n\nfunction calculateReducer(state: MisDatePickerState): MisDatePickerState {\n  // how many calendars\n  const displayMonths = (state.displayOneMonthRange &&\n    isDisplayOneMonth(state.view.date, state.minDate, state.maxDate)) ? 1 : state.displayMonths;\n\n  // use selected date on initial rendering if set\n  let viewDate = state.view.date;\n\n  if (state.view.mode === 'day') {\n    if (state.showPreviousMonth && state.selectedRange && state.selectedRange.length === 0) {\n      viewDate = shiftDate(viewDate, { month: -1 });\n    }\n\n    state.monthViewOptions.firstDayOfWeek = getLocale(state.locale).firstDayOfWeek();\n    const monthsModel = new Array(displayMonths);\n    for (let monthIndex = 0; monthIndex < displayMonths; monthIndex++) {\n      // todo: for unlinked calendars it will be harder\n      monthsModel[monthIndex] = calcDaysCalendar(\n        viewDate,\n        state.monthViewOptions\n      );\n      viewDate = shiftDate(viewDate, { month: 1 });\n    }\n\n    return Object.assign({}, state, { monthsModel });\n  }\n\n  if (state.view.mode === 'month') {\n    const monthsCalendar = new Array(displayMonths);\n    for (\n      let calendarIndex = 0;\n      calendarIndex < displayMonths;\n      calendarIndex++\n    ) {\n      // todo: for unlinked calendars it will be harder\n      monthsCalendar[calendarIndex] = formatMonthsCalendar(\n        viewDate,\n        getFormatOptions(state)\n      );\n      viewDate = shiftDate(viewDate, { year: 1 });\n    }\n\n    return Object.assign({}, state, { monthsCalendar });\n  }\n\n  if (state.view.mode === 'year') {\n    const yearsCalendarModel = new Array(displayMonths);\n\n    for (\n      let calendarIndex = 0;\n      calendarIndex < displayMonths;\n      calendarIndex++\n    ) {\n      // todo: for unlinked calendars it will be harder\n      yearsCalendarModel[calendarIndex] = formatYearsCalendar(\n        viewDate,\n        getFormatOptions(state),\n        state.minMode === 'year' ? getYearsCalendarInitialDate(state, calendarIndex) : undefined\n      );\n      viewDate = shiftDate(viewDate, { year: yearsPerCalendar });\n    }\n\n    return Object.assign({}, state, { yearsCalendarModel });\n  }\n\n  return state;\n}\n\nfunction formatReducer(state: MisDatePickerState,\n                       action: Action): MisDatePickerState {\n  if (state.view.mode === 'day') {\n    const formattedMonths = state.monthsModel.map((month, monthIndex) =>\n      formatDaysCalendar(month, getFormatOptions(state), monthIndex)\n    );\n\n    return Object.assign({}, state, { formattedMonths });\n  }\n\n  // how many calendars\n  const displayMonths = state.displayMonths;\n  // check initial rendering\n  // use selected date on initial rendering if set\n  let viewDate = state.view.date;\n\n  if (state.view.mode === 'month') {\n    const monthsCalendar = new Array(displayMonths);\n    for (\n      let calendarIndex = 0;\n      calendarIndex < displayMonths;\n      calendarIndex++\n    ) {\n      // todo: for unlinked calendars it will be harder\n      monthsCalendar[calendarIndex] = formatMonthsCalendar(\n        viewDate,\n        getFormatOptions(state)\n      );\n      viewDate = shiftDate(viewDate, { year: 1 });\n    }\n\n    return Object.assign({}, state, { monthsCalendar });\n  }\n\n  if (state.view.mode === 'year') {\n    const yearsCalendarModel = new Array(displayMonths);\n    for (\n      let calendarIndex = 0;\n      calendarIndex < displayMonths;\n      calendarIndex++\n    ) {\n      // todo: for unlinked calendars it will be harder\n      yearsCalendarModel[calendarIndex] = formatYearsCalendar(\n        viewDate,\n        getFormatOptions(state)\n      );\n      viewDate = shiftDate(viewDate, { year: 16 });\n    }\n\n    return Object.assign({}, state, { yearsCalendarModel });\n  }\n\n  return state;\n}\n\nfunction flagReducer(state: MisDatePickerState,\n                     action: Action): MisDatePickerState {\n  const displayMonths = isDisplayOneMonth(state.view.date, state.minDate, state.maxDate) ? 1 : state.displayMonths;\n  if (state.view.mode === 'day') {\n    const flaggedMonths = state.formattedMonths.map(\n      (formattedMonth, monthIndex) =>\n        flagDaysCalendar(formattedMonth, {\n          isDisabled: state.isDisabled,\n          minDate: state.minDate,\n          maxDate: state.maxDate,\n          daysDisabled: state.daysDisabled,\n          datesDisabled: state.datesDisabled,\n          datesEnabled: state.datesEnabled,\n          hoveredDate: state.hoveredDate,\n          selectedDate: state.selectedDate,\n          selectedRange: state.selectedRange,\n          displayMonths,\n          dateCustomClasses: state.dateCustomClasses,\n          dateTooltipTexts: state.dateTooltipTexts,\n          monthIndex\n        })\n    );\n\n    return Object.assign({}, state, { flaggedMonths });\n  }\n\n  if (state.view.mode === 'month') {\n    const flaggedMonthsCalendar = state.monthsCalendar.map(\n      (formattedMonth, monthIndex) =>\n        flagMonthsCalendar(formattedMonth, {\n          isDisabled: state.isDisabled,\n          minDate: state.minDate,\n          maxDate: state.maxDate,\n          hoveredMonth: state.hoveredMonth,\n          selectedDate: state.selectedDate,\n          selectedRange: state.selectedRange,\n          displayMonths,\n          monthIndex\n        })\n    );\n\n    return Object.assign({}, state, { flaggedMonthsCalendar });\n  }\n\n  if (state.view.mode === 'year') {\n    const yearsCalendarFlagged = state.yearsCalendarModel.map(\n      (formattedMonth, yearIndex) =>\n        flagYearsCalendar(formattedMonth, {\n          isDisabled: state.isDisabled,\n          minDate: state.minDate,\n          maxDate: state.maxDate,\n          hoveredYear: state.hoveredYear,\n          selectedDate: state.selectedDate,\n          selectedRange: state.selectedRange,\n          displayMonths,\n          yearIndex\n        })\n    );\n\n    return Object.assign({}, state, { yearsCalendarFlagged });\n  }\n\n  return state;\n}\n\nfunction navigateOffsetReducer(state: MisDatePickerState, action: Action): MisDatePickerState {\n  const newState = {\n    view: {\n      mode: state.view.mode,\n      date: shiftViewDate(state, action)\n    }\n  };\n\n  return Object.assign({}, state, newState);\n}\n\nfunction shiftViewDate(state: MisDatePickerState, action: Action): Date {\n  if (state.view.mode === 'year' && state.minMode === 'year') {\n    const initialDate = getYearsCalendarInitialDate(state, 0);\n    const middleDate = shiftDate(initialDate, { year: -initialYearShift });\n\n    return shiftDate(middleDate, action.payload);\n  }\n\n  return shiftDate(startOf(state.view.date, 'month'), action.payload);\n}\n\nfunction getFormatOptions(state: MisDatePickerState): DatePickerFormatOptions {\n  return {\n    locale: state.locale,\n\n    monthTitle: state.monthTitle,\n    yearTitle: state.yearTitle,\n\n    dayLabel: state.dayLabel,\n    monthLabel: state.monthLabel,\n    yearLabel: state.yearLabel,\n\n    weekNumbers: state.weekNumbers\n  };\n}\n\n/**\n * if view date is provided (bsValue|ngModel) it should be shown\n * if view date is not provider:\n * if minDate>currentDate (default view value), show minDate\n * if maxDate<currentDate(default view value) show maxDate\n */\nfunction getViewDate(viewDate: Date | Date[], minDate: Date, maxDate: Date) {\n  const _date = Array.isArray(viewDate) ? viewDate[0] : viewDate;\n\n  if (minDate && isAfter(minDate, _date, 'day')) {\n    return minDate;\n  }\n\n  if (maxDate && isBefore(maxDate, _date, 'day')) {\n    return maxDate;\n  }\n\n  return _date;\n}\n\nfunction isDisplayOneMonth(viewDate: Date, minDate: Date, maxDate: Date) {\n  if (maxDate && isSame(maxDate, viewDate, 'day')) {\n    return true;\n  }\n\n  if (minDate && maxDate &&  minDate.getMonth() === maxDate.getMonth()) {\n    return true;\n  }\n\n  return false;\n}\n"]}

package/esm2020/src/lib/components/datepicker/reducer/bs-datepicker.state.mjs

@@ -0,0 +1,12 @@
+import { defaultMonthOptions } from './_defaults';
+import { MisDatePickerConfig } from '../bs-datepicker.config';
+export class MisDatePickerState {
+}
+const _initialView = { date: new Date(), mode: 'day' };
+export const initialDatePickerState = Object.assign(new MisDatePickerConfig(), {
+    locale: 'en',
+    view: _initialView,
+    selectedRange: [],
+    monthViewOptions: defaultMonthOptions
+});
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/lib/components/datepicker/reducer/bs-datepicker.store.mjs

@@ -0,0 +1,21 @@
+import { Injectable } from '@angular/core';
+import { MiniStore, MiniState } from '../mini-ngrx';
+import { initialDatePickerState } from './bs-datepicker.state';
+import { BehaviorSubject } from 'rxjs';
+import { misDatePickerReducer } from './bs-datepicker.reducer';
+import * as i0 from "@angular/core";
+export class MisDatePickerStore extends MiniStore {
+    constructor() {
+        const _dispatcher = new BehaviorSubject({
+            type: '[datepicker] dispatcher init'
+        });
+        const state = new MiniState(initialDatePickerState, _dispatcher, misDatePickerReducer);
+        super(_dispatcher, misDatePickerReducer, state);
+    }
+}
+MisDatePickerStore.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: MisDatePickerStore, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+MisDatePickerStore.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: MisDatePickerStore });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: MisDatePickerStore, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnMtZGF0ZXBpY2tlci5zdG9yZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnJhcmllcy93aXMtY29tbW9uL3NyYy9saWIvY29tcG9uZW50cy9kYXRlcGlja2VyL3JlZHVjZXIvYnMtZGF0ZXBpY2tlci5zdG9yZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQzNDLE9BQU8sRUFBRSxTQUFTLEVBQVUsU0FBUyxFQUFFLE1BQU0sY0FBYyxDQUFDO0FBQzVELE9BQU8sRUFBc0Isc0JBQXNCLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUNuRixPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sTUFBTSxDQUFDO0FBQ3ZDLE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLHlCQUF5QixDQUFDOztBQUcvRCxNQUFNLE9BQU8sa0JBQW1CLFNBQVEsU0FBNkI7SUFDbkU7UUFDRSxNQUFNLFdBQVcsR0FBRyxJQUFJLGVBQWUsQ0FBUztZQUM5QyxJQUFJLEVBQUUsOEJBQThCO1NBQ3JDLENBQUMsQ0FBQztRQUNILE1BQU0sS0FBSyxHQUFHLElBQUksU0FBUyxDQUN6QixzQkFBc0IsRUFDdEIsV0FBVyxFQUNYLG9CQUFvQixDQUNyQixDQUFDO1FBQ0YsS0FBSyxDQUFDLFdBQVcsRUFBRSxvQkFBb0IsRUFBRSxLQUFLLENBQUMsQ0FBQztJQUNsRCxDQUFDOzsrR0FYVSxrQkFBa0I7bUhBQWxCLGtCQUFrQjsyRkFBbEIsa0JBQWtCO2tCQUQ5QixVQUFVIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgTWluaVN0b3JlLCBBY3Rpb24sIE1pbmlTdGF0ZSB9IGZyb20gJy4uL21pbmktbmdyeCc7XG5pbXBvcnQgeyBNaXNEYXRlUGlja2VyU3RhdGUsIGluaXRpYWxEYXRlUGlja2VyU3RhdGUgfSBmcm9tICcuL2JzLWRhdGVwaWNrZXIuc3RhdGUnO1xuaW1wb3J0IHsgQmVoYXZpb3JTdWJqZWN0IH0gZnJvbSAncnhqcyc7XG5pbXBvcnQgeyBtaXNEYXRlUGlja2VyUmVkdWNlciB9IGZyb20gJy4vYnMtZGF0ZXBpY2tlci5yZWR1Y2VyJztcblxuQEluamVjdGFibGUoKVxuZXhwb3J0IGNsYXNzIE1pc0RhdGVQaWNrZXJTdG9yZSBleHRlbmRzIE1pbmlTdG9yZTxNaXNEYXRlUGlja2VyU3RhdGU+IHtcbiAgY29uc3RydWN0b3IoKSB7XG4gICAgY29uc3QgX2Rpc3BhdGNoZXIgPSBuZXcgQmVoYXZpb3JTdWJqZWN0PEFjdGlvbj4oe1xuICAgICAgdHlwZTogJ1tkYXRlcGlja2VyXSBkaXNwYXRjaGVyIGluaXQnXG4gICAgfSk7XG4gICAgY29uc3Qgc3RhdGUgPSBuZXcgTWluaVN0YXRlPE1pc0RhdGVQaWNrZXJTdGF0ZT4oXG4gICAgICBpbml0aWFsRGF0ZVBpY2tlclN0YXRlLFxuICAgICAgX2Rpc3BhdGNoZXIsXG4gICAgICBtaXNEYXRlUGlja2VyUmVkdWNlclxuICAgICk7XG4gICAgc3VwZXIoX2Rpc3BhdGNoZXIsIG1pc0RhdGVQaWNrZXJSZWR1Y2VyLCBzdGF0ZSk7XG4gIH1cbn1cbiJdfQ==