@antscorp/antsomi-ui 1.3.5-beta.2 → 1.3.5-beta.200

package/es/components/molecules/CalendarSelection/reducer.js

@@ -0,0 +1,121 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { produce } from 'immer';
+import { AUTO_UPDATE_TO_KEY, LOCAL_TIMEZONE, RANGE_LIMIT, SELECTION_KEY, TRIGGER_OUT_MODE, } from './constants';
+import { generateRangeInfo, getRangeValue, genTriggerOut } from './utils';
+import dayjs from 'dayjs';
+import { ACTION_TYPES } from './actions';
+const DEFAULT_VALUE = {
+    rangeInfo: { type: SELECTION_KEY.today },
+    rangeValue: [
+        {
+            start: dayjs().toISOString(),
+            end: dayjs().toISOString(),
+        },
+    ],
+};
+export const INITIAL_STATE = {
+    value: {
+        original: DEFAULT_VALUE,
+        current: DEFAULT_VALUE,
+    },
+    rangeLimit: RANGE_LIMIT,
+    timezone: LOCAL_TIMEZONE,
+    open: false,
+    triggerOut: {
+        // in reset => id reset to null => useTriggerOut not trigger
+        id: null,
+        mode: 'auto',
+    },
+};
+export const reducer = (state, action) => produce(state, draft => {
+    switch (action.type) {
+        case ACTION_TYPES.initState: {
+            const { initData, needTriggerOut } = action.payload;
+            const { rangeInfo } = initData;
+            const defaultValue = getRangeValue({
+                rangeInfo,
+                currentRangeValue: initData.rangeValue,
+            });
+            const initState = Object.assign(Object.assign({}, INITIAL_STATE), { value: {
+                    original: { rangeInfo, rangeValue: defaultValue },
+                    current: { rangeInfo, rangeValue: defaultValue },
+                } });
+            if (needTriggerOut) {
+                initState.triggerOut = genTriggerOut({ mode: TRIGGER_OUT_MODE.auto });
+            }
+            return initState;
+        }
+        case ACTION_TYPES.changeRangeType: {
+            const newRangeInfo = generateRangeInfo(action.payload.rangeType);
+            if (newRangeInfo) {
+                draft.value.current.rangeInfo = newRangeInfo;
+                draft.value.current.rangeValue = getRangeValue({
+                    rangeInfo: newRangeInfo,
+                    currentRangeValue: state.value.current.rangeValue,
+                });
+                if (action.payload.callback) {
+                    action.payload.callback(newRangeInfo);
+                }
+            }
+            break;
+        }
+        case ACTION_TYPES.updateRangeInfo: {
+            const _a = action.payload.updateValue, { type } = _a, rest = __rest(_a, ["type"]);
+            let updated;
+            if (type && type !== state.value.current.rangeInfo.type) {
+                const rangeInfoByType = generateRangeInfo(type);
+                if (!rangeInfoByType)
+                    break;
+                updated = Object.assign(Object.assign({}, rangeInfoByType), rest);
+            }
+            else {
+                updated = Object.assign(Object.assign({}, state.value.current.rangeInfo), action.payload.updateValue);
+            }
+            const rangeValue = getRangeValue({
+                rangeInfo: updated,
+                currentRangeValue: state.value.current.rangeValue,
+            });
+            draft.value.current.rangeInfo = updated;
+            draft.value.current.rangeValue = rangeValue;
+            break;
+        }
+        case ACTION_TYPES.updateRangeValue: {
+            const { rangeValue, options } = action.payload;
+            const rangeType = state.value.current.rangeInfo.type;
+            if ((options === null || options === void 0 ? void 0 : options.isManual) && rangeType !== SELECTION_KEY.custom) {
+                draft.value.current.rangeInfo = {
+                    type: SELECTION_KEY.custom,
+                    autoUpdateTo: AUTO_UPDATE_TO_KEY.fixed,
+                };
+            }
+            draft.value.current.rangeValue = rangeValue;
+            break;
+        }
+        case ACTION_TYPES.togglePopover: {
+            draft.open = !state.open;
+            break;
+        }
+        case ACTION_TYPES.apply: {
+            draft.value.original = state.value.current;
+            draft.open = false;
+            draft.triggerOut = genTriggerOut({ mode: TRIGGER_OUT_MODE.manual });
+            break;
+        }
+        case ACTION_TYPES.resetValue: {
+            draft.value.current = state.value.original;
+            break;
+        }
+        default:
+            break;
+    }
+});

package/es/components/molecules/CalendarSelection/styled.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+export declare const StyledPopover: import("styled-components").StyledComponent<import("react").ForwardRefExoticComponent<import("antd").PopoverProps & import("react").RefAttributes<unknown>> & {
+    _InternalPanelDoNotUseOrYouWillBeFired: import("react").FC<import("antd/es/popover/PurePanel").PurePanelProps>;
+}, any, {}, never>;
+export declare const StyledPopoverContainer: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const StyledPopoverBody: import("styled-components").StyledComponent<"div", any, {}, never>;

package/es/components/molecules/CalendarSelection/styled.js

@@ -0,0 +1,13 @@
+import { Popover } from '@antscorp/antsomi-ui/es/components/atoms';
+import styled from 'styled-components';
+export const StyledPopover = styled(Popover) `
+  font-size: 12px;
+`;
+export const StyledPopoverContainer = styled.div ``;
+export const StyledPopoverBody = styled.div `
+  font-size: 12px;
+  display: flex;
+  max-height: 75vh;
+
+  overflow: auto;
+`;

package/es/components/molecules/CalendarSelection/types.d.ts

@@ -0,0 +1,98 @@
+import { DatePickerProps, PopoverProps } from 'antd';
+import { Dispatch } from 'react';
+import { ValueOf } from 'type-fest';
+import { updateRangeInfo, changeRangeType, updateRangeValue, changeAutoUpdateTo, initState, togglePopover, apply, resetValue } from './actions';
+import { SELECTION_KEY, AUTO_UPDATE_TO_KEY } from './constants';
+import { TimeRangeDisplayProps } from './components/TimeRangeDisplay/TimeRangeDisplay';
+export type CalendarSelectionProps = Partial<{
+    popoverProps: PopoverProps;
+    rangeLimit: number;
+    timezone: string;
+    toDay: Date;
+    value: CalendarSelectionValue;
+    timeDisplayProps: TimeRangeDisplayProps;
+    rangePickerProps: DatePickerProps;
+    onChange: (value: CalendarSelectionValue, info: TriggerOutInfo) => void;
+}>;
+export type Range = (typeof SELECTION_KEY)[keyof typeof SELECTION_KEY];
+export type ActionType = {
+    dispatch: Dispatch<Action>;
+};
+export type TriggerOutInfo = {
+    id: number | null;
+    mode: 'auto' | 'manual';
+};
+export type ReducerState = {
+    value: {
+        original: CalendarSelectionValue;
+        current: ReducerState['value']['original'];
+    };
+    triggerOut: TriggerOutInfo;
+    rangeLimit: number;
+    timezone: string;
+    open: boolean;
+};
+export type Action = ReturnType<typeof changeRangeType> | ReturnType<typeof updateRangeInfo> | ReturnType<typeof updateRangeValue> | ReturnType<typeof changeAutoUpdateTo> | ReturnType<typeof initState> | ReturnType<typeof togglePopover> | ReturnType<typeof apply> | ReturnType<typeof resetValue>;
+type ToDay = {
+    type: typeof SELECTION_KEY.today;
+};
+type Yesterday = {
+    type: typeof SELECTION_KEY.yesterday;
+};
+type ThisWeek = {
+    type: typeof SELECTION_KEY.this_week;
+    weekStartsOn: number;
+};
+type LastWeek = {
+    type: typeof SELECTION_KEY.last_week;
+    weekStartsOn: number;
+};
+type Last7Days = {
+    type: typeof SELECTION_KEY.last_7_days;
+};
+type Last14Days = {
+    type: typeof SELECTION_KEY.last_14_days;
+};
+type Last30Days = {
+    type: typeof SELECTION_KEY.last_30_days;
+};
+type ThisMonth = {
+    type: typeof SELECTION_KEY.this_month;
+};
+type LastMonth = {
+    type: typeof SELECTION_KEY.last_month;
+};
+type ThisQuarter = {
+    type: typeof SELECTION_KEY.this_quarter;
+};
+type LastQuarter = {
+    type: typeof SELECTION_KEY.last_quarter;
+};
+type AllTime = {
+    type: typeof SELECTION_KEY.all_time;
+};
+export type AutoUpdateTo = ValueOf<typeof AUTO_UPDATE_TO_KEY>;
+export type Custom = {
+    type: typeof SELECTION_KEY.custom;
+    autoUpdateTo: AutoUpdateTo;
+};
+export type DaysUpToToday = {
+    type: typeof SELECTION_KEY.days_up_to_today;
+    numOfDays: number;
+};
+export type DaysUpToYesterday = {
+    type: typeof SELECTION_KEY.days_up_to_yesterday;
+    numOfDays: number;
+};
+export type RangeInfo = Custom | ToDay | Yesterday | ThisWeek | LastWeek | Last7Days | Last14Days | Last30Days | ThisMonth | LastMonth | ThisQuarter | LastQuarter | AllTime | DaysUpToToday | DaysUpToYesterday;
+export type RangeValue = {
+    start: string | null;
+    end: string | null;
+    label?: string;
+    color?: string;
+};
+export type CalendarSelectionValue = {
+    rangeInfo: RangeInfo;
+    rangeValue: RangeValue[];
+};
+export {};

package/es/components/molecules/CalendarSelection/types.js

@@ -0,0 +1 @@
+export {};

package/es/components/molecules/CalendarSelection/utils.d.ts

@@ -0,0 +1,52 @@
+import { AutoUpdateTo, RangeInfo, RangeValue, ReducerState } from './types';
+export declare const rangeInfoToStringType: (rangeInfo: RangeInfo) => string;
+export declare const serializeWeekStartsOn: (rangeType: string) => number | undefined;
+export declare const generateRangeInfo: (rangeType: string) => RangeInfo | null;
+export declare const getDefaultDate: () => {
+    toDay: string;
+    yesterday: string;
+    startWeekSS: string;
+    startWeekMS: string;
+    last7Days: string;
+    startLastWeekSS: string;
+    startLastWeekMS: string;
+    endLastWeekSS: string;
+    endLastWeekMS: string;
+    last14Days: string;
+    startOfThisMonth: string;
+    endOfThisMonth: string;
+    last30Days: string;
+    lastMonthFirstDate: string;
+    lastMonthLastDate: string;
+    thisQuaterFirstDate: string;
+    thisQuaterLastDate: string;
+    lastQuaterFirstDate: string;
+    lastQuaterLastDate: string;
+    maxSub: number;
+    todayUptoCount: (val: number) => string;
+    yesterdayUptoCount: (val: number) => string;
+};
+export declare const getRangeValue: ({ rangeInfo, currentRangeValue, limitNumOfDays, }: {
+    rangeInfo: RangeInfo;
+    currentRangeValue: RangeValue[];
+    limitNumOfDays?: number | undefined;
+}) => RangeValue[];
+export declare const getRangeValueSelctedTitle: (rangeValue: RangeValue[], options?: {
+    formatStart?: string;
+    formatEnd?: string;
+    minimize?: boolean;
+    operator?: string;
+}) => string[];
+export declare const getRangeTypeSelectedTitle: (rangeInfo: RangeInfo) => string;
+export declare const combineCurrentValue: (state: ReducerState) => {
+    rangeInfo: RangeInfo;
+    rangeValue: RangeValue[];
+};
+export declare const genTriggerOut: ({ mode, id, }: {
+    mode: ReducerState['triggerOut']['mode'];
+    id?: number | undefined;
+}) => {
+    mode: "auto" | "manual";
+    id: number;
+};
+export declare const isAutoUpdateToOption: (value: unknown) => value is AutoUpdateTo;

package/es/components/molecules/CalendarSelection/utils.js

@@ -0,0 +1,304 @@
+import dayjs from 'dayjs';
+import utc from 'dayjs/plugin/utc';
+import timezone from 'dayjs/plugin/timezone';
+import isoWeek from 'dayjs/plugin/isoWeek';
+import weekday from 'dayjs/plugin/weekday';
+import quarterOfYear from 'dayjs/plugin/quarterOfYear';
+import isSameOrBefore from 'dayjs/plugin/isSameOrBefore';
+import { AUTO_UPDATE_TO_KEY, DEFAULT_NUM_UP_TO, MAP_TITLE, RANGE_LIMIT, SELECTION_KEY, } from './constants';
+import { last } from 'lodash';
+import { asssertCannotReach } from '@antscorp/antsomi-ui/es/utils/common';
+dayjs.extend(utc);
+dayjs.extend(timezone);
+dayjs.extend(isoWeek);
+dayjs.extend(quarterOfYear);
+dayjs.extend(weekday);
+dayjs.extend(isSameOrBefore);
+const dayZero = new Date(0);
+export const rangeInfoToStringType = (rangeInfo) => {
+    switch (rangeInfo.type) {
+        case SELECTION_KEY.last_week:
+        case SELECTION_KEY.this_week: {
+            return `${rangeInfo.type}_${rangeInfo.weekStartsOn}`;
+        }
+        default:
+            return rangeInfo.type;
+    }
+};
+export const serializeWeekStartsOn = (rangeType) => {
+    let startOn = last(rangeType.split('_'));
+    if (startOn) {
+        startOn = +startOn;
+    }
+    if (typeof startOn === 'number' && startOn >= 1 && startOn <= 7) {
+        return startOn;
+    }
+};
+export const generateRangeInfo = (rangeType) => {
+    const startOn = serializeWeekStartsOn(rangeType);
+    let rangeInfo = null;
+    switch (true) {
+        case rangeType.startsWith(SELECTION_KEY.this_week): {
+            if (startOn) {
+                rangeInfo = {
+                    type: SELECTION_KEY.this_week,
+                    weekStartsOn: startOn,
+                };
+            }
+            break;
+        }
+        case rangeType.startsWith(SELECTION_KEY.last_week): {
+            if (startOn) {
+                rangeInfo = {
+                    type: SELECTION_KEY.last_week,
+                    weekStartsOn: startOn,
+                };
+            }
+            break;
+        }
+        default:
+            break;
+    }
+    switch (rangeType) {
+        case SELECTION_KEY.custom: {
+            rangeInfo = {
+                type: rangeType,
+                autoUpdateTo: AUTO_UPDATE_TO_KEY.fixed,
+            };
+            break;
+        }
+        case SELECTION_KEY.yesterday:
+        case SELECTION_KEY.today:
+        case SELECTION_KEY.last_7_days:
+        case SELECTION_KEY.last_14_days:
+        case SELECTION_KEY.last_30_days:
+        case SELECTION_KEY.this_month:
+        case SELECTION_KEY.last_month:
+        case SELECTION_KEY.this_quarter:
+        case SELECTION_KEY.last_quarter:
+        case SELECTION_KEY.all_time: {
+            rangeInfo = { type: rangeType };
+            break;
+        }
+        case SELECTION_KEY.days_up_to_today:
+        case SELECTION_KEY.days_up_to_yesterday: {
+            rangeInfo = {
+                type: rangeType,
+                numOfDays: DEFAULT_NUM_UP_TO,
+            };
+            break;
+        }
+        default:
+            break;
+    }
+    return rangeInfo;
+};
+export const getDefaultDate = () => {
+    const toDayTz = dayjs(new Date());
+    return {
+        toDay: toDayTz.toISOString(),
+        yesterday: toDayTz.subtract(1, 'd').toISOString(),
+        startWeekSS: toDayTz.weekday(0).toISOString(),
+        startWeekMS: toDayTz.isoWeekday(1).toISOString(),
+        last7Days: toDayTz.subtract(1, 'w').toISOString(),
+        startLastWeekSS: toDayTz.subtract(1, 'w').weekday(0).toISOString(),
+        startLastWeekMS: toDayTz.subtract(1, 'w').isoWeekday(1).toISOString(),
+        endLastWeekSS: toDayTz.subtract(1, 'w').weekday(6).toISOString(),
+        endLastWeekMS: toDayTz.subtract(1, 'w').isoWeekday(7).toISOString(),
+        last14Days: toDayTz.subtract(14, 'd').toISOString(),
+        startOfThisMonth: toDayTz.startOf('M').toISOString(),
+        endOfThisMonth: toDayTz.endOf('M').toISOString(),
+        last30Days: toDayTz.subtract(30, 'd').toISOString(),
+        lastMonthFirstDate: toDayTz.subtract(1, 'M').startOf('M').toISOString(),
+        lastMonthLastDate: toDayTz.subtract(1, 'M').endOf('M').toISOString(),
+        thisQuaterFirstDate: toDayTz.startOf('Q').toISOString(),
+        thisQuaterLastDate: toDayTz.endOf('Q').toISOString(),
+        lastQuaterFirstDate: toDayTz.subtract(1, 'Q').startOf('Q').toISOString(),
+        lastQuaterLastDate: toDayTz.subtract(1, 'Q').endOf('Q').toISOString(),
+        maxSub: toDayTz.diff(dayZero, 'd'),
+        todayUptoCount: (val) => toDayTz.subtract(Math.round(val - 1), 'd').toISOString(),
+        yesterdayUptoCount: (val) => toDayTz.subtract(Math.round(val - 1) + 1, 'd').toISOString(),
+    };
+};
+export const getRangeValue = ({ rangeInfo, currentRangeValue, limitNumOfDays = RANGE_LIMIT, }) => {
+    const defaultDates = getDefaultDate();
+    const result = currentRangeValue.map(rangeValue => {
+        const temp = {
+            start: defaultDates.toDay,
+            end: defaultDates.toDay,
+        };
+        switch (rangeInfo.type) {
+            case SELECTION_KEY.custom: {
+                temp.start = rangeValue.start;
+                temp.end = rangeValue.end;
+                switch (rangeInfo.autoUpdateTo) {
+                    case AUTO_UPDATE_TO_KEY.today: {
+                        temp.end = defaultDates.toDay;
+                        break;
+                    }
+                    case AUTO_UPDATE_TO_KEY.yesterday: {
+                        temp.end = defaultDates.yesterday;
+                        break;
+                    }
+                    default:
+                        break;
+                }
+                break;
+            }
+            case SELECTION_KEY.today: {
+                temp.start = defaultDates.toDay;
+                temp.end = defaultDates.toDay;
+                break;
+            }
+            case SELECTION_KEY.yesterday: {
+                temp.start = defaultDates.yesterday;
+                temp.end = defaultDates.yesterday;
+                break;
+            }
+            case SELECTION_KEY.this_week: {
+                temp.start =
+                    rangeInfo.weekStartsOn === 1 ? defaultDates.startWeekMS : defaultDates.startWeekSS;
+                temp.end = defaultDates.toDay;
+                break;
+            }
+            case SELECTION_KEY.last_week: {
+                temp.start =
+                    rangeInfo.weekStartsOn === 1
+                        ? defaultDates.startLastWeekMS
+                        : defaultDates.startLastWeekSS;
+                temp.end =
+                    rangeInfo.weekStartsOn === 1 ? defaultDates.endLastWeekMS : defaultDates.endLastWeekSS;
+                break;
+            }
+            case SELECTION_KEY.last_7_days: {
+                temp.start = defaultDates.last7Days;
+                temp.end = defaultDates.yesterday;
+                break;
+            }
+            case SELECTION_KEY.last_14_days: {
+                temp.start = defaultDates.last14Days;
+                temp.end = defaultDates.yesterday;
+                break;
+            }
+            case SELECTION_KEY.last_30_days: {
+                temp.start = defaultDates.last30Days;
+                temp.end = defaultDates.yesterday;
+                break;
+            }
+            case SELECTION_KEY.this_month: {
+                temp.start = defaultDates.startOfThisMonth;
+                temp.end = defaultDates.toDay;
+                break;
+            }
+            case SELECTION_KEY.last_month: {
+                temp.start = defaultDates.lastMonthFirstDate;
+                temp.end = defaultDates.lastMonthLastDate;
+                break;
+            }
+            case SELECTION_KEY.this_quarter: {
+                temp.start = defaultDates.thisQuaterFirstDate;
+                temp.end = defaultDates.toDay;
+                break;
+            }
+            case SELECTION_KEY.last_quarter: {
+                temp.start = defaultDates.lastQuaterFirstDate;
+                temp.end = defaultDates.lastQuaterLastDate;
+                break;
+            }
+            case SELECTION_KEY.all_time: {
+                temp.start = dayjs(defaultDates.toDay).subtract(limitNumOfDays, 'd').toISOString();
+                temp.end = defaultDates.toDay;
+                break;
+            }
+            case SELECTION_KEY.days_up_to_today: {
+                temp.start = dayjs(defaultDates.toDay).subtract(rangeInfo.numOfDays, 'd').toISOString();
+                temp.end = defaultDates.toDay;
+                break;
+            }
+            case SELECTION_KEY.days_up_to_yesterday: {
+                temp.start = dayjs(defaultDates.toDay).subtract(rangeInfo.numOfDays, 'd').toISOString();
+                temp.end = defaultDates.yesterday;
+                break;
+            }
+            default:
+                asssertCannotReach(rangeInfo);
+        }
+        return Object.assign(Object.assign({}, rangeValue), temp);
+    });
+    return result;
+};
+export const getRangeValueSelctedTitle = (rangeValue, options) => {
+    const { formatStart, formatEnd, operator = '-' } = options || {};
+    const result = [];
+    rangeValue.forEach(range => {
+        var _a, _b, _c, _d, _e;
+        const { start, end } = range;
+        let startFormat = formatStart || 'MMM D';
+        const endFormat = formatEnd || 'MMM D YYYY';
+        if ((_a = dayjs(start)) === null || _a === void 0 ? void 0 : _a.isSame(dayjs(end), 'D')) {
+            return result.push((_b = dayjs(start)) === null || _b === void 0 ? void 0 : _b.format('MMM D YYYY'));
+        }
+        if (!((_c = dayjs(start)) === null || _c === void 0 ? void 0 : _c.isSame(dayjs(end), 'y')) && !formatStart) {
+            startFormat = `${startFormat} YYYY`;
+        }
+        result.push(`${(_d = dayjs(start)) === null || _d === void 0 ? void 0 : _d.format(startFormat)} ${operator} ${(_e = dayjs(end)) === null || _e === void 0 ? void 0 : _e.format(endFormat)}`);
+    });
+    return result;
+};
+export const getRangeTypeSelectedTitle = (rangeInfo) => {
+    let label = MAP_TITLE[rangeInfo.type];
+    switch (rangeInfo.type) {
+        case SELECTION_KEY.days_up_to_yesterday:
+        case SELECTION_KEY.days_up_to_today: {
+            label = `${rangeInfo.numOfDays} ${label}`;
+            break;
+        }
+        default:
+            break;
+    }
+    return label;
+};
+export const combineCurrentValue = (state) => {
+    const { rangeValue, rangeInfo } = state.value.current;
+    return { rangeInfo, rangeValue };
+};
+export const genTriggerOut = (() => {
+    let catchedId = 0;
+    return function increaseTriggerOut({ mode, id, }) {
+        if (!id)
+            catchedId++;
+        return { mode, id: id || catchedId };
+    };
+})();
+// export const serializeRangeColors = (rangeValue: RangeValue[]) => {
+//   const listDate = rangeValue
+//     .flatMap(range => [range.start, range.end])
+//     .sort((a, b) => ascending(a.toDate(), b.toDate()));
+//   let rangeDates = listDate.reduce<RangeValue[]>((acc, current, idx) => {
+//     if (listDate[idx + 1]) {
+//       acc.push({ start: current, end: listDate[idx + 1] });
+//     }
+//     return acc;
+//   }, []);
+//   rangeDates = uniqWith(rangeDates, (a, b) => a.start.isSame(b.start) && a.end.isSame(b.end));
+//   rangeDates = rangeDates.map(rangeDate => {
+//     const colors: string[] = [];
+//     rangeValue.forEach(range => {
+//       if (
+//         range.color &&
+//         rangeDate.start.isBetween(range.start, range.end, 'd', '[]') &&
+//         rangeDate.end.isBetween(range.start, range.end, 'd', '[]')
+//       ) {
+//         colors.push(range.color);
+//       }
+//     });
+//     return { ...rangeDate, colors: uniq(colors) };
+//   });
+//   return rangeDates;
+// };
+export const isAutoUpdateToOption = (value) => {
+    if (typeof value === 'string' && Object.values(AUTO_UPDATE_TO_KEY).some(v => v === value)) {
+        return true;
+    }
+    return false;
+};