@progressio_resources/gravity-design-system 2.6.21 → 2.6.23

package/esm2022/lib/components/gravity-calendar-v2/datepicker/reducer/bs-datepicker.effects.mjs

@@ -0,0 +1,128 @@
+import { Injectable } from '@angular/core';
+import { combineLatest } from 'rxjs';
+import { filter, map } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "./bs-datepicker.actions";
+export class BsDatepickerEffects {
+    constructor(_actions) {
+        this._actions = _actions;
+        this._subs = [];
+    }
+    init(_bsDatepickerStore) {
+        this._store = _bsDatepickerStore;
+        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;
+    }
+    setDisabled(value) {
+        this._store?.dispatch(this._actions.isDisabled(value));
+        return this;
+    }
+    /* Set rendering options */
+    setOptions(_config) {
+        const _options = Object.assign({ locale: 'en' }, _config);
+        this._store?.dispatch(this._actions.setOptions(_options));
+        return this;
+    }
+    /** view to mode bindings */
+    setBindings(container) {
+        if (!this._store)
+            return this;
+        container.daysCalendar$ = this._store.select(state => state.flaggedMonths).pipe(filter(months => !!months));
+        container.monthsCalendar = this._store.select(state => state.flaggedMonthsCalendar).pipe(filter(months => !!months));
+        container.yearsCalendar = this._store.select(state => state.yearsCalendarFlagged).pipe(filter(years => !!years));
+        container.viewMode = this._store.select(state => state.view?.mode);
+        container.options$ = combineLatest([this._store.select(state => state.displayMonths)]).pipe(map((latest) => ({ displayMonths: latest[0] })));
+        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() {
+        if (!this._store)
+            return this;
+        this._subs.push(this._store.select(state => state.view).subscribe(() => {
+            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(() => this._store?.dispatch(this._actions.format())));
+        // flag day values
+        this._subs.push(this._store
+            .select(state => state.formattedMonths)
+            .pipe(filter(month => !!month))
+            .subscribe(() => this._store?.dispatch(this._actions.flag())));
+        // flag day values
+        this._subs.push(this._store
+            .select(state => state.selectedDate)
+            .pipe(filter(selectedDate => !!selectedDate))
+            .subscribe(() => 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(() => 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(() => this._store?.dispatch(this._actions.flag())));
+        return this;
+    }
+    destroy() {
+        for (const sub of this._subs) {
+            sub.unsubscribe();
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: BsDatepickerEffects, deps: [{ token: i1.BsDatepickerActions }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: BsDatepickerEffects, providedIn: 'platform' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: BsDatepickerEffects, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'platform' }]
+        }], ctorParameters: function () { return [{ type: i1.BsDatepickerActions }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bs-datepicker.effects.js","sourceRoot":"","sources":["../../../../../../../../projects/gravity-design-system/src/lib/components/gravity-calendar-v2/datepicker/reducer/bs-datepicker.effects.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable} from '@angular/core';\n\nimport {combineLatest, Observable, Subscription} from 'rxjs';\nimport {filter, map} from 'rxjs/operators';\n\nimport {BsDatepickerAbstractComponent} from '../base/bs-datepicker-container';\nimport {BsDatepickerConfig} from '../bs-datepicker.config';\n\nimport {\n  BsDatepickerViewMode,\n  BsNavigationEvent,\n  CellHoverEvent,\n  DatepickerRenderOptions,\n  DaysCalendarViewModel,\n  DayViewModel,\n  MonthsCalendarViewModel,\n  YearsCalendarViewModel\n} from '../models';\nimport {BsDatepickerActions} from './bs-datepicker.actions';\nimport {BsDatepickerStore} from './bs-datepicker.store';\n\n\n@Injectable({providedIn: 'platform'})\nexport class BsDatepickerEffects {\n  viewMode?: Observable<BsDatepickerViewMode>;\n  daysCalendar?: Observable<DaysCalendarViewModel[]>;\n  monthsCalendar?: Observable<MonthsCalendarViewModel[]>;\n  yearsCalendar?: Observable<YearsCalendarViewModel[]>;\n  options?: Observable<DatepickerRenderOptions>;\n\n  private _store?: BsDatepickerStore;\n  private _subs: Subscription[] = [];\n\n  constructor(private _actions: BsDatepickerActions) {\n  }\n\n  init(_bsDatepickerStore: BsDatepickerStore): BsDatepickerEffects {\n    this._store = _bsDatepickerStore;\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 | undefined)[] | undefined): void {\n    this._store?.dispatch(this._actions.selectRange(value));\n  }\n\n  setMinDate(value?: Date): BsDatepickerEffects {\n    this._store?.dispatch(this._actions.minDate(value));\n    return this;\n  }\n\n  setMaxDate(value?: Date): BsDatepickerEffects {\n    this._store?.dispatch(this._actions.maxDate(value));\n    return this;\n  }\n\n  setDisabled(value?: boolean): BsDatepickerEffects {\n    this._store?.dispatch(this._actions.isDisabled(value));\n    return this;\n  }\n\n  /* Set rendering options */\n  setOptions(_config: BsDatepickerConfig): BsDatepickerEffects {\n    const _options = Object.assign({locale: 'en'}, _config);\n    this._store?.dispatch(this._actions.setOptions(_options));\n    return this;\n  }\n\n  /** view to mode bindings */\n  setBindings(container: BsDatepickerAbstractComponent): BsDatepickerEffects {\n    if (!this._store) return this;\n\n    container.daysCalendar$ = this._store.select(state => state.flaggedMonths).pipe(filter(months => !!months));\n    container.monthsCalendar = this._store.select(state => state.flaggedMonthsCalendar).pipe(filter(months => !!months));\n    container.yearsCalendar = this._store.select(state => state.yearsCalendarFlagged).pipe(filter(years => !!years));\n    container.viewMode = this._store.select(state => state.view?.mode);\n    container.options$ = combineLatest([this._store.select(state => state.displayMonths)]).pipe(map((latest) => ({displayMonths: latest[0]})));\n\n    return this;\n  }\n\n  /** event handlers */\n  setEventHandlers(container: BsDatepickerAbstractComponent): BsDatepickerEffects {\n    container.setViewMode = (event: BsDatepickerViewMode): 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\n      if (_cell.isOtherMonth || _cell.isDisabled) return;\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(): BsDatepickerEffects {\n    if (!this._store) return this;\n\n    this._subs.push(\n      this._store.select(state => state.view).subscribe(() => {\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(filter(monthModel => !!monthModel))\n        .subscribe(() => 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(filter(month => !!month))\n        .subscribe(() => 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(filter(selectedDate => !!selectedDate))\n        .subscribe(() => 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(filter(selectedRange => !!selectedRange))\n        .subscribe(() => 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(filter(state => !!state))\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(filter(hoveredDate => !!hoveredDate))\n        .subscribe(() => this._store?.dispatch(this._actions.flag()))\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/esm2022/lib/components/gravity-calendar-v2/datepicker/reducer/bs-datepicker.reducer.mjs

@@ -0,0 +1,301 @@
+import { initialDatepickerState } from './bs-datepicker.state';
+import { BsDatepickerActions } 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 { getLocale, isAfter, isArray, isBefore, isDateValid, isSame, setFullDate, shiftDate, startOf } from 'ngx-bootstrap/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';
+export function bsDatepickerReducer(state = initialDatepickerState, action) {
+    switch (action.type) {
+        case BsDatepickerActions.CALCULATE: {
+            return calculateReducer(state);
+        }
+        case BsDatepickerActions.FORMAT: {
+            return formatReducer(state);
+        }
+        case BsDatepickerActions.FLAG: {
+            return flagReducer(state);
+        }
+        case BsDatepickerActions.NAVIGATE_OFFSET: {
+            return navigateOffsetReducer(state, action);
+        }
+        case BsDatepickerActions.NAVIGATE_TO: {
+            const payload = action.payload;
+            if (!state.view || !payload.unit)
+                return state;
+            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 BsDatepickerActions.CHANGE_VIEWMODE: {
+            if (!canSwitchMode(action.payload, state.minMode) || !state.view)
+                return state;
+            const date = state.view.date;
+            const mode = action.payload;
+            const newState = { view: { date, mode } };
+            return Object.assign({}, state, newState);
+        }
+        case BsDatepickerActions.HOVER: {
+            return Object.assign({}, state, { hoveredDate: action.payload });
+        }
+        case BsDatepickerActions.SELECT: {
+            if (!state.view)
+                return state;
+            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 BsDatepickerActions.SET_OPTIONS: {
+            if (!state.view)
+                return state;
+            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;
+                }
+            }
+            return Object.assign({}, state, newState);
+        }
+        // date range picker
+        case BsDatepickerActions.SELECT_RANGE: {
+            if (!state.view)
+                return state;
+            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 BsDatepickerActions.SET_MIN_DATE: {
+            return Object.assign({}, state, {
+                minDate: action.payload
+            });
+        }
+        case BsDatepickerActions.SET_MAX_DATE: {
+            return Object.assign({}, state, {
+                maxDate: action.payload
+            });
+        }
+        case BsDatepickerActions.SET_IS_DISABLED: {
+            return Object.assign({}, state, {
+                isDisabled: action.payload
+            });
+        }
+        default:
+            return state;
+    }
+}
+function calculateReducer(state) {
+    if (!state.view)
+        return state;
+    // how many calendars
+    let displayMonths = state.displayMonths;
+    // use selected date on initial rendering if set
+    let viewDate = state.view.date;
+    if (state.view.mode === 'day' && state.monthViewOptions) {
+        state.monthViewOptions.firstDayOfWeek = getLocale(state.locale).firstDayOfWeek();
+        let monthsModel = new Array(displayMonths);
+        for (let monthIndex = 0; monthIndex < displayMonths; monthIndex++) {
+            monthsModel[monthIndex] = calcDaysCalendar(viewDate, state.monthViewOptions);
+            viewDate = shiftDate(viewDate, { month: 1 });
+        }
+        // Check if parameter enabled and check if it's not months navigation event
+        if (state.preventChangeToNextMonth && state.flaggedMonths && state.hoveredDate) {
+            const viewMonth = calcDaysCalendar(state.view.date, state.monthViewOptions);
+            // Check if viewed right month same as in flaggedMonths state, then override months model with flaggedMonths
+            if (state.flaggedMonths.length >= 2) {
+                if (state.flaggedMonths[1].month.getMonth() === viewMonth.month.getMonth()) {
+                    monthsModel = state.flaggedMonths.map((item) => {
+                        return state.monthViewOptions ? calcDaysCalendar(item.month, state.monthViewOptions) : null;
+                    }).filter(item => item !== null);
+                }
+            }
+            else {
+                monthsModel = state.flaggedMonths.map((item) => {
+                    return state.monthViewOptions ? calcDaysCalendar(item.month, state.monthViewOptions) : null;
+                }).filter(item => item !== null);
+            }
+        }
+        return Object.assign({}, state, { monthsModel });
+    }
+    if (state.view.mode === 'month') {
+        const monthsCalendar = new Array(displayMonths);
+        for (let calendarIndex = 0; calendarIndex < displayMonths; calendarIndex++) {
+            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++) {
+            yearsCalendarModel[calendarIndex] = formatYearsCalendar(viewDate, getFormatOptions(state), state.minMode === 'year' ? getYearsCalendarInitialDate(state, calendarIndex) : undefined, state.selectedDate ? state.selectedDate : new Date());
+            viewDate = shiftDate(viewDate, { year: yearsPerCalendar });
+        }
+        return Object.assign({}, state, { yearsCalendarModel });
+    }
+    return state;
+}
+function formatReducer(state) {
+    if (!state.view)
+        return state;
+    if (state.view.mode === 'day' && state.monthsModel) {
+        const formattedMonths = state.monthsModel.map((month, monthIndex) => formatDaysCalendar(month, getFormatOptions(state), monthIndex));
+        return Object.assign({}, state, { formattedMonths });
+    }
+    // how many calendars
+    const displayMonths = state.displayMonths || 1;
+    // 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++) {
+            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++) {
+            yearsCalendarModel[calendarIndex] = formatYearsCalendar(viewDate, getFormatOptions(state), undefined, state.selectedDate ? state.selectedDate : new Date());
+            viewDate = shiftDate(viewDate, { year: 16 });
+        }
+        return Object.assign({}, state, { yearsCalendarModel });
+    }
+    return state;
+}
+function flagReducer(state) {
+    if (!state.view)
+        return state;
+    const displayMonths = isDisplayOneMonth(state.view.date, state.minDate, state.maxDate) ? 1 : state.displayMonths;
+    if (state.formattedMonths && state.view.mode === 'day') {
+        const flaggedMonths = state.formattedMonths.map((formattedMonth, monthIndex) => flagDaysCalendar(formattedMonth, {
+            isDisabled: state.isDisabled,
+            minDate: state.minDate,
+            maxDate: state.maxDate,
+            hoveredDate: state.hoveredDate,
+            selectedDate: state.selectedDate,
+            selectedRange: state.selectedRange,
+            displayMonths,
+            monthIndex
+        }));
+        return Object.assign({}, state, { flaggedMonths });
+    }
+    if (state.view.mode === 'month' && state.monthsCalendar) {
+        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' && state.yearsCalendarModel) {
+        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) {
+    if (!state.view)
+        return state;
+    const date = shiftViewDate(state, action);
+    if (!date)
+        return state;
+    const newState = {
+        view: { mode: state.view.mode, date }
+    };
+    return Object.assign({}, state, newState);
+}
+function shiftViewDate(state, action) {
+    if (!state.view)
+        return undefined;
+    if (state.view.mode === 'year' && state.minMode === 'year') {
+        const initialDate = getYearsCalendarInitialDate(state, 0);
+        if (initialDate) {
+            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
+    };
+}
+/**
+ * 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;
+    return minDate && maxDate && minDate.getMonth() === maxDate.getMonth();
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bs-datepicker.reducer.js","sourceRoot":"","sources":["../../../../../../../../projects/gravity-design-system/src/lib/components/gravity-calendar-v2/datepicker/reducer/bs-datepicker.reducer.ts"],"names":[],"mappings":"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","sourcesContent":["import {BsDatepickerState, BsDatepickerViewState, initialDatepickerState} from './bs-datepicker.state';\nimport {Action} from 'ngx-bootstrap/mini-ngrx';\nimport {BsDatepickerActions} 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  getLocale,\n  isAfter,\n  isArray,\n  isBefore,\n  isDateValid,\n  isSame,\n  setFullDate,\n  shiftDate,\n  startOf\n} from 'ngx-bootstrap/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 {\n  BsDatepickerViewMode,\n  BsViewNavigationEvent,\n  DatepickerFormatOptions,\n  DaysCalendarModel,\n  DaysCalendarViewModel,\n  MonthsCalendarViewModel,\n  YearsCalendarViewModel\n} from '../models';\nimport {getYearsCalendarInitialDate} from '../utils/bs-calendar-utils';\n\n\nexport function bsDatepickerReducer(state: BsDatepickerState = initialDatepickerState, action: Action): BsDatepickerState {\n  switch (action.type) {\n    case BsDatepickerActions.CALCULATE: {\n      return calculateReducer(state);\n    }\n\n    case BsDatepickerActions.FORMAT: {\n      return formatReducer(state);\n    }\n\n    case BsDatepickerActions.FLAG: {\n      return flagReducer(state);\n    }\n\n    case BsDatepickerActions.NAVIGATE_OFFSET: {\n      return navigateOffsetReducer(state, action);\n    }\n\n    case BsDatepickerActions.NAVIGATE_TO: {\n      const payload: BsViewNavigationEvent = action.payload;\n\n      if (!state.view || !payload.unit) return state;\n\n      const date: Date = setFullDate(state.view.date, payload.unit);\n\n      let newState;\n      let mode: BsDatepickerViewMode;\n\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 BsDatepickerActions.CHANGE_VIEWMODE: {\n      if (!canSwitchMode(action.payload, state.minMode) || !state.view) return state;\n\n      const date: 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 BsDatepickerActions.HOVER: {\n      return Object.assign({}, state, {hoveredDate: action.payload});\n    }\n\n    case BsDatepickerActions.SELECT: {\n      if (!state.view) return state;\n\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: Date = getViewDate(_date, state.minDate, state.maxDate);\n      newState.view = {mode, date};\n\n      return Object.assign({}, state, newState);\n    }\n\n    case BsDatepickerActions.SET_OPTIONS: {\n      if (!state.view) return state;\n\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 || isArray(newState.value) && isDateValid(newState.value[0]) && newState.value[0] || state.view.date;\n      const date: Date = getViewDate(_viewDate, newState.minDate, newState.maxDate);\n      newState.view = {mode, date};\n\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\n      return Object.assign({}, state, newState);\n    }\n\n    // date range picker\n    case BsDatepickerActions.SELECT_RANGE: {\n      if (!state.view) return state;\n\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: Date = getViewDate(_date, state.minDate, state.maxDate);\n      newState.view = {mode, date};\n\n      return Object.assign({}, state, newState);\n    }\n\n    case BsDatepickerActions.SET_MIN_DATE: {\n      return Object.assign({}, state, {\n        minDate: action.payload\n      });\n    }\n\n    case BsDatepickerActions.SET_MAX_DATE: {\n      return Object.assign({}, state, {\n        maxDate: action.payload\n      });\n    }\n\n    case BsDatepickerActions.SET_IS_DISABLED: {\n      return Object.assign({}, state, {\n        isDisabled: action.payload\n      });\n    }\n\n    default:\n      return state;\n  }\n}\n\nfunction calculateReducer(state: BsDatepickerState): BsDatepickerState {\n  if (!state.view) return state;\n\n  // how many calendars\n  let displayMonths: number = state.displayMonths;\n\n  // use selected date on initial rendering if set\n  let viewDate: Date = state.view.date;\n\n  if (state.view.mode === 'day' && state.monthViewOptions) {\n    state.monthViewOptions.firstDayOfWeek = getLocale(state.locale).firstDayOfWeek();\n\n    let monthsModel = new Array(displayMonths);\n    for (let monthIndex: number = 0; monthIndex < displayMonths; monthIndex++) {\n      monthsModel[monthIndex] = calcDaysCalendar(viewDate, state.monthViewOptions);\n      viewDate = shiftDate(viewDate, {month: 1});\n    }\n\n    // Check if parameter enabled and check if it's not months navigation event\n    if (state.preventChangeToNextMonth && state.flaggedMonths && state.hoveredDate) {\n      const viewMonth: DaysCalendarModel = calcDaysCalendar(state.view.date, state.monthViewOptions);\n\n      // Check if viewed right month same as in flaggedMonths state, then override months model with flaggedMonths\n      if (state.flaggedMonths.length >= 2) {\n        if (state.flaggedMonths[1].month.getMonth() === viewMonth.month.getMonth()) {\n          monthsModel = state.flaggedMonths.map((item: DaysCalendarViewModel) => {\n            return state.monthViewOptions ? calcDaysCalendar(item.month, state.monthViewOptions) : null;\n          }).filter(item => item !== null);\n        }\n      } else {\n        monthsModel = state.flaggedMonths.map((item: DaysCalendarViewModel) => {\n          return state.monthViewOptions ? calcDaysCalendar(item.month, state.monthViewOptions) : null;\n        }).filter(item => item !== null);\n      }\n    }\n\n    return Object.assign({}, state, {monthsModel});\n  }\n\n  if (state.view.mode === 'month') {\n    const monthsCalendar = new Array(displayMonths);\n\n    for (let calendarIndex: number = 0; calendarIndex < displayMonths; calendarIndex++) {\n      monthsCalendar[calendarIndex] = formatMonthsCalendar(viewDate, getFormatOptions(state));\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 (let calendarIndex: number = 0; calendarIndex < displayMonths; calendarIndex++) {\n      yearsCalendarModel[calendarIndex] = formatYearsCalendar(viewDate, getFormatOptions(state), state.minMode === 'year' ? getYearsCalendarInitialDate(state, calendarIndex) : undefined, state.selectedDate ? state.selectedDate : new Date());\n      viewDate = shiftDate(viewDate, {year: yearsPerCalendar});\n    }\n\n    return Object.assign({}, state, {yearsCalendarModel});\n  }\n\n  return state;\n}\n\nfunction formatReducer(state: BsDatepickerState): BsDatepickerState {\n  if (!state.view) return state;\n\n  if (state.view.mode === 'day' && state.monthsModel) {\n    const formattedMonths: DaysCalendarViewModel[] = state.monthsModel.map((month: DaysCalendarModel, monthIndex: number) => formatDaysCalendar(month, getFormatOptions(state), monthIndex));\n\n    return Object.assign({}, state, {formattedMonths});\n  }\n\n  // how many calendars\n  const displayMonths: number = state.displayMonths || 1;\n\n  // check initial rendering\n  // use selected date on initial rendering if set\n  let viewDate: Date = state.view.date;\n\n  if (state.view.mode === 'month') {\n    const monthsCalendar = new Array(displayMonths);\n    for (let calendarIndex: number = 0; calendarIndex < displayMonths; calendarIndex++) {\n      monthsCalendar[calendarIndex] = formatMonthsCalendar(viewDate, getFormatOptions(state));\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 (let calendarIndex: number = 0; calendarIndex < displayMonths; calendarIndex++) {\n      yearsCalendarModel[calendarIndex] = formatYearsCalendar(viewDate, getFormatOptions(state), undefined, state.selectedDate ? state.selectedDate : new Date());\n      viewDate = shiftDate(viewDate, {year: 16});\n    }\n\n    return Object.assign({}, state, {yearsCalendarModel});\n  }\n\n  return state;\n}\n\nfunction flagReducer(state: BsDatepickerState): BsDatepickerState {\n  if (!state.view) return state;\n\n  const displayMonths: number = isDisplayOneMonth(state.view.date, state.minDate, state.maxDate) ? 1 : state.displayMonths;\n  if (state.formattedMonths && state.view.mode === 'day') {\n    const flaggedMonths: DaysCalendarViewModel[] = state.formattedMonths.map((formattedMonth: DaysCalendarViewModel, monthIndex: number) =>\n      flagDaysCalendar(formattedMonth, {\n        isDisabled: state.isDisabled,\n        minDate: state.minDate,\n        maxDate: state.maxDate,\n        hoveredDate: state.hoveredDate,\n        selectedDate: state.selectedDate,\n        selectedRange: state.selectedRange,\n        displayMonths,\n        monthIndex\n      }));\n\n    return Object.assign({}, state, {flaggedMonths});\n  }\n\n  if (state.view.mode === 'month' && state.monthsCalendar) {\n    const flaggedMonthsCalendar: MonthsCalendarViewModel[] = state.monthsCalendar.map((formattedMonth: MonthsCalendarViewModel, monthIndex: number) =>\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    return Object.assign({}, state, {flaggedMonthsCalendar});\n  }\n\n  if (state.view.mode === 'year' && state.yearsCalendarModel) {\n    const yearsCalendarFlagged: YearsCalendarViewModel[] = state.yearsCalendarModel.map((formattedMonth: YearsCalendarViewModel, yearIndex: number) =>\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: BsDatepickerState, action: Action): BsDatepickerState {\n  if (!state.view) return state;\n\n  const date: Date | undefined = shiftViewDate(state, action);\n  if (!date) return state;\n\n  const newState: { view: BsDatepickerViewState } = {\n    view: {mode: state.view.mode, date}\n  };\n\n  return Object.assign({}, state, newState);\n}\n\nfunction shiftViewDate(state: BsDatepickerState, action: Action): Date | undefined {\n  if (!state.view) return undefined;\n\n  if (state.view.mode === 'year' && state.minMode === 'year') {\n    const initialDate: Date | undefined = getYearsCalendarInitialDate(state, 0);\n\n    if (initialDate) {\n      const middleDate = shiftDate(initialDate, {year: -initialYearShift});\n      return shiftDate(middleDate, action.payload);\n    }\n  }\n\n  return shiftDate(startOf(state.view.date, 'month'), action.payload);\n}\n\nfunction getFormatOptions(state: BsDatepickerState): 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}\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): Date {\n  const _date: Date = Array.isArray(viewDate) ? viewDate[0] : viewDate;\n\n  if (minDate && isAfter(minDate, _date, 'day')) return minDate;\n  if (maxDate && isBefore(maxDate, _date, 'day')) return maxDate;\n\n  return _date;\n}\n\nfunction isDisplayOneMonth(viewDate: Date, minDate?: Date, maxDate?: Date): boolean | undefined {\n  if (maxDate && isSame(maxDate, viewDate, 'day')) return true;\n\n  return minDate && maxDate && minDate.getMonth() === maxDate.getMonth();\n}\n"]}

package/esm2022/lib/components/gravity-calendar-v2/datepicker/reducer/bs-datepicker.state.mjs

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

package/esm2022/lib/components/gravity-calendar-v2/datepicker/reducer/bs-datepicker.store.mjs

@@ -0,0 +1,20 @@
+import { Injectable } from '@angular/core';
+import { MiniState, MiniStore } from 'ngx-bootstrap/mini-ngrx';
+import { initialDatepickerState } from './bs-datepicker.state';
+import { BehaviorSubject } from 'rxjs';
+import { bsDatepickerReducer } from './bs-datepicker.reducer';
+import * as i0 from "@angular/core";
+export class BsDatepickerStore extends MiniStore {
+    constructor() {
+        const _dispatcher = new BehaviorSubject({ type: '[datepicker] dispatcher init' });
+        const state = new MiniState(initialDatepickerState, _dispatcher, bsDatepickerReducer);
+        super(_dispatcher, bsDatepickerReducer, state);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: BsDatepickerStore, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: BsDatepickerStore, providedIn: 'platform' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: BsDatepickerStore, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'platform' }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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