@spaced-out/ui-design-system 0.1.109 → 0.1.111

package/lib/utils/date-range-picker/date-range-picker.js

@@ -0,0 +1,306 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.wrangleMoment = exports.isStartOfRange = exports.isStartDateEndDateSame = exports.isEndOfRange = exports.inDateRange = exports.getValidDates = exports.getTimezones = exports.getSubtractedDate = exports.getMonthEndDate = exports.getDaysInMonth = exports.getAvailableMonths = exports.getAddedDate = exports.generateAvailableYears = exports.formatIsoDate = exports.checkRangeValidity = exports.addTimezone = exports.WEEKDAYS = exports.NAVIGATION_ACTION = exports.MONTHS = exports.MARKERS = exports.DATE_RANGE_PICKER_ERRORS = void 0;
+var _formatISO = _interopRequireDefault(require("date-fns/formatISO"));
+var _parseISO = _interopRequireDefault(require("date-fns/parseISO"));
+var _invariant = _interopRequireDefault(require("invariant"));
+var _lodash = require("lodash");
+var _momentTimezone = _interopRequireDefault(require("moment-timezone"));
+var _timezones = require("./timezones");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// $FlowFixMe - strict types for date-fns
+
+// $FlowFixMe - strict types for date-fns
+
+// $FlowFixMe[untyped-import]
+
+const NAVIGATION_ACTION = Object.freeze({
+  NEXT: 'next',
+  PREV: 'prev'
+});
+exports.NAVIGATION_ACTION = NAVIGATION_ACTION;
+const MARKERS = Object.freeze({
+  DATE_RANGE_START: 'FIRST',
+  DATE_RANGE_END: 'SECOND'
+});
+exports.MARKERS = MARKERS;
+const WEEKDAYS = ['Su', 'Mo', 'Tu', 'We', 'Th', 'Fr', 'Sa'];
+exports.WEEKDAYS = WEEKDAYS;
+const MONTHS = [{
+  key: '0',
+  label: 'Jan'
+}, {
+  key: '1',
+  label: 'Feb'
+}, {
+  key: '2',
+  label: 'Mar'
+}, {
+  key: '3',
+  label: 'Apr'
+}, {
+  key: '4',
+  label: 'May'
+}, {
+  key: '5',
+  label: 'Jun'
+}, {
+  key: '6',
+  label: 'Jul'
+}, {
+  key: '7',
+  label: 'Aug'
+}, {
+  key: '8',
+  label: 'Sep'
+}, {
+  key: '9',
+  label: 'Oct'
+}, {
+  key: '10',
+  label: 'Nov'
+}, {
+  key: '11',
+  label: 'Dec'
+}];
+exports.MONTHS = MONTHS;
+const DATE_RANGE_PICKER_ERRORS = Object.freeze({
+  MIN_MAX_INVALID: {
+    type: 'MIN_MAX_INVALID',
+    description: 'Given minDate and maxDate are invalid.'
+  },
+  START_DATE_EARLY: {
+    type: 'START_DATE_EARLY',
+    description: 'Given startDate can not come before minDate.'
+  },
+  START_DATE_LATE: {
+    type: 'START_DATE_LATE',
+    description: 'Given startDate can not come after endDate.'
+  },
+  END_DATE_LATE: {
+    type: 'END_DATE_LATE',
+    description: 'Given endDate can not come after maxDate.'
+  }
+});
+exports.DATE_RANGE_PICKER_ERRORS = DATE_RANGE_PICKER_ERRORS;
+const checkRangeValidity = (rangeStart, rangeEnd, errorBody, onError) => {
+  const isRangeStartValid = (0, _momentTimezone.default)(rangeStart).isValid();
+  const isRangeEndValid = isRangeStartValid && (0, _momentTimezone.default)(rangeEnd).isValid();
+  const isRangeValid = isRangeEndValid && (0, _momentTimezone.default)(rangeStart).isSameOrBefore(rangeEnd);
+  (0, _invariant.default)(isRangeValid, JSON.stringify(errorBody));
+  if (!isRangeValid) {
+    onError?.(errorBody);
+  }
+  return isRangeValid;
+};
+exports.checkRangeValidity = checkRangeValidity;
+const wrangleMoment = date => {
+  if (date instanceof Date) {
+    return date;
+  } else if (!date) {
+    return new Date();
+  }
+  return date instanceof _momentTimezone.default ? date.toDate() : (0, _parseISO.default)(date);
+};
+exports.wrangleMoment = wrangleMoment;
+const formatIsoDate = date => (0, _formatISO.default)(wrangleMoment(date), {
+  representation: 'date'
+});
+exports.formatIsoDate = formatIsoDate;
+const isStartOfRange = (_ref, date) => {
+  let {
+    startDate
+  } = _ref;
+  return Boolean(startDate) && (0, _momentTimezone.default)(date).isSame((0, _momentTimezone.default)(startDate), 'd');
+};
+exports.isStartOfRange = isStartOfRange;
+const isEndOfRange = (_ref2, date) => {
+  let {
+    endDate
+  } = _ref2;
+  return Boolean(endDate) && (0, _momentTimezone.default)(date).isSame((0, _momentTimezone.default)(endDate), 'd');
+};
+exports.isEndOfRange = isEndOfRange;
+const inDateRange = (_ref3, date) => {
+  let {
+    startDate,
+    endDate
+  } = _ref3;
+  if (startDate && endDate) {
+    const momentDay = (0, _momentTimezone.default)(date);
+    const momentStartDate = (0, _momentTimezone.default)(startDate);
+    const momentEndDate = (0, _momentTimezone.default)(endDate);
+    return momentDay.isBetween(momentStartDate, momentEndDate, null, '[]');
+  }
+  return false;
+};
+exports.inDateRange = inDateRange;
+const isStartDateEndDateSame = _ref4 => {
+  let {
+    startDate,
+    endDate
+  } = _ref4;
+  if (startDate && endDate) {
+    return (0, _momentTimezone.default)(startDate).isSame((0, _momentTimezone.default)(endDate), 'd');
+  }
+  return false;
+};
+exports.isStartDateEndDateSame = isStartDateEndDateSame;
+const getMonthAndYear = date => {
+  const momentDate = date ? (0, _momentTimezone.default)(date) : (0, _momentTimezone.default)();
+  return [momentDate.month(), momentDate.year()];
+};
+const getDaysInMonth = date => {
+  const startWeek = (0, _momentTimezone.default)(date).startOf('month').startOf('week');
+  const endWeek = (0, _momentTimezone.default)(date).endOf('month').endOf('week');
+  const days = [],
+    current = startWeek;
+  while (current.isBefore(endWeek)) {
+    days.push(current.clone().format('YYYY-MM-DD'));
+    current.add(1, 'd');
+  }
+  const daysInChunks = (0, _lodash.chunk)(days, 7);
+
+  // if total rows in calendar are 5 add one more week to the calendar
+  if (daysInChunks.length === 5) {
+    const nextWeek = getAddedDate(endWeek, WEEKDAYS.length, 'd');
+    const extraDays = [];
+    while (current.isSameOrBefore(nextWeek)) {
+      extraDays.push(current.clone().format('YYYY-MM-DD'));
+      current.add(1, 'd');
+    }
+    daysInChunks.push(extraDays);
+  }
+  return daysInChunks;
+};
+exports.getDaysInMonth = getDaysInMonth;
+const getAddedDate = (date, addCount, timeUnit) => formatIsoDate((0, _momentTimezone.default)(date).add(addCount, timeUnit));
+exports.getAddedDate = getAddedDate;
+const getSubtractedDate = (date, subtractCount, timeUnit) => formatIsoDate((0, _momentTimezone.default)(date).subtract(subtractCount, timeUnit));
+exports.getSubtractedDate = getSubtractedDate;
+const getMonthEndDate = date => formatIsoDate((0, _momentTimezone.default)(date).endOf('M'));
+exports.getMonthEndDate = getMonthEndDate;
+const addTimezone = (date, timezone) => _momentTimezone.default.tz(date, timezone).startOf('d').utc().toISOString();
+exports.addTimezone = addTimezone;
+const getTimezones = () => Object.keys(_timezones.TIMEZONES).reduce((menuOptions, key) => {
+  menuOptions.push({
+    key,
+    label: _timezones.TIMEZONES[key]
+  });
+  return menuOptions;
+}, []);
+exports.getTimezones = getTimezones;
+const generateAvailableYears = _ref5 => {
+  let {
+    marker,
+    minDate,
+    maxDate,
+    rangeStartMonth,
+    rangeEndMonth
+  } = _ref5;
+  const rangeStartYear = (0, _momentTimezone.default)(rangeStartMonth).year();
+  const rangeEndYear = (0, _momentTimezone.default)(rangeEndMonth).year();
+  const isWithinRange = year => marker === MARKERS.DATE_RANGE_START ? year <= rangeEndYear : year >= rangeStartYear;
+  return (0, _lodash.range)((0, _momentTimezone.default)(minDate).year(), (0, _momentTimezone.default)(maxDate).year() + 1).filter(year => isWithinRange(year)).map(year => ({
+    key: year.toString(),
+    label: year.toString()
+  }));
+};
+exports.generateAvailableYears = generateAvailableYears;
+const getAvailableMonths = _ref6 => {
+  let {
+    marker,
+    minDate,
+    maxDate,
+    rangeStartMonth,
+    rangeEndMonth
+  } = _ref6;
+  const [rangeStartMonthKey, rangeStartYear] = getMonthAndYear(rangeStartMonth);
+  const [rangeEndMonthKey, rangeEndYear] = getMonthAndYear(rangeEndMonth);
+  const [minDateMonth, minDateYear] = getMonthAndYear(minDate);
+  const [maxDateMonth, maxDateYear] = getMonthAndYear(maxDate);
+  return MONTHS.filter(month => {
+    const isSameYear = rangeStartYear === rangeEndYear;
+    const isFirstAndMinDateYearSame = rangeStartYear === minDateYear;
+    const isSecondAndMaxDateYearSame = rangeEndYear === maxDateYear;
+    if (marker === MARKERS.DATE_RANGE_START) {
+      if (isSameYear && month.key >= rangeEndMonthKey) {
+        return false;
+      } else if (isFirstAndMinDateYearSame && month.key < minDateMonth) {
+        return false;
+      } else {
+        return true;
+      }
+    } else {
+      if (isSameYear && month.key <= rangeStartMonthKey) {
+        return false;
+      } else if (isSecondAndMaxDateYearSame && month.key > maxDateMonth) {
+        return false;
+      } else {
+        return true;
+      }
+    }
+  });
+};
+exports.getAvailableMonths = getAvailableMonths;
+const getValidDates = (selectedDateRange, minDate, maxDate, onError) => {
+  const today = formatIsoDate();
+  const localTimezone = _momentTimezone.default.tz.guess();
+  const {
+    startDate,
+    endDate,
+    timezone = ''
+  } = selectedDateRange;
+  const validTimezone = (0, _lodash.isEmpty)(timezone) ? localTimezone : timezone;
+  const validMaxDate = maxDate && !(0, _lodash.isEmpty)(maxDate) ? maxDate : today;
+  const validMinDate = minDate && !(0, _lodash.isEmpty)(minDate) ? minDate : getSubtractedDate(today, 8, 'y');
+  const isRangeValid = (min, max, errorMessage) => checkRangeValidity(min, max, errorMessage, onError);
+
+  // minDate should be after maxDate
+  const isMinMaxRangeInvalid = !isRangeValid(validMinDate, validMaxDate, DATE_RANGE_PICKER_ERRORS.MIN_MAX_INVALID);
+
+  // if startDate is defined and then it should be after minDate
+  const isStartDateInvalid = isMinMaxRangeInvalid || (0, _lodash.isEmpty)(startDate) || !isRangeValid(minDate, startDate, DATE_RANGE_PICKER_ERRORS.START_DATE_EARLY);
+  if (isMinMaxRangeInvalid || isStartDateInvalid) {
+    return {
+      validTimezone,
+      validDateRange: {
+        startDate: null,
+        endDate: null
+      },
+      validMinDate,
+      validMaxDate
+    };
+  }
+
+  // if endDate is defined then it should be before maxDate
+  const isEndDateInvalid = (0, _lodash.isEmpty)(endDate) || !isRangeValid(endDate, maxDate, DATE_RANGE_PICKER_ERRORS.END_DATE_LATE);
+
+  // startDate should be before endDate
+  const isStartEndRangeInvalid = isEndDateInvalid || !isRangeValid(startDate, endDate, DATE_RANGE_PICKER_ERRORS.START_DATE_LATE);
+  if (isEndDateInvalid || isStartEndRangeInvalid) {
+    return {
+      validTimezone,
+      validDateRange: {
+        startDate,
+        endDate: null
+      },
+      validMinDate,
+      validMaxDate
+    };
+  }
+  return {
+    validTimezone,
+    validDateRange: {
+      startDate: (0, _lodash.isEmpty)(startDate) ? null : startDate,
+      endDate: (0, _lodash.isEmpty)(endDate) ? null : endDate
+    },
+    validMinDate,
+    validMaxDate
+  };
+};
+exports.getValidDates = getValidDates;

package/lib/utils/date-range-picker/date-range-picker.js.flow

@@ -0,0 +1,335 @@
+// @flow strict
+
+// $FlowFixMe - strict types for date-fns
+import formatISO from 'date-fns/formatISO';
+// $FlowFixMe - strict types for date-fns
+import parseISO from 'date-fns/parseISO';
+import invariant from 'invariant';
+import {chunk, isEmpty, range} from 'lodash';
+// $FlowFixMe[untyped-import]
+import moment from 'moment-timezone';
+import type {
+  DateRange,
+  DateRangePickerError,
+  DateRangeWithTimezone,
+  TimeUnit,
+} from 'src/types/date-range-picker';
+
+import type {MenuOption} from '../../components/Menu';
+
+import {TIMEZONES} from './timezones';
+
+
+export const NAVIGATION_ACTION = Object.freeze({
+  NEXT: 'next',
+  PREV: 'prev',
+});
+export const MARKERS = Object.freeze({
+  DATE_RANGE_START: 'FIRST',
+  DATE_RANGE_END: 'SECOND',
+});
+export const WEEKDAYS = ['Su', 'Mo', 'Tu', 'We', 'Th', 'Fr', 'Sa'];
+export const MONTHS = [
+  {key: '0', label: 'Jan'},
+  {key: '1', label: 'Feb'},
+  {key: '2', label: 'Mar'},
+  {key: '3', label: 'Apr'},
+  {key: '4', label: 'May'},
+  {key: '5', label: 'Jun'},
+  {key: '6', label: 'Jul'},
+  {key: '7', label: 'Aug'},
+  {key: '8', label: 'Sep'},
+  {key: '9', label: 'Oct'},
+  {key: '10', label: 'Nov'},
+  {key: '11', label: 'Dec'},
+];
+
+export const DATE_RANGE_PICKER_ERRORS = Object.freeze({
+  MIN_MAX_INVALID: {
+    type: 'MIN_MAX_INVALID',
+    description: 'Given minDate and maxDate are invalid.',
+  },
+  START_DATE_EARLY: {
+    type: 'START_DATE_EARLY',
+    description: 'Given startDate can not come before minDate.',
+  },
+  START_DATE_LATE: {
+    type: 'START_DATE_LATE',
+    description: 'Given startDate can not come after endDate.',
+  },
+  END_DATE_LATE: {
+    type: 'END_DATE_LATE',
+    description: 'Given endDate can not come after maxDate.',
+  },
+});
+
+export const checkRangeValidity = (
+  rangeStart?: ?string,
+  rangeEnd?: ?string,
+  errorBody: DateRangePickerError,
+  onError?: (DateRangePickerError) => void,
+): boolean => {
+  const isRangeStartValid = moment(rangeStart).isValid();
+  const isRangeEndValid = isRangeStartValid && moment(rangeEnd).isValid();
+  const isRangeValid =
+    isRangeEndValid && moment(rangeStart).isSameOrBefore(rangeEnd);
+
+  invariant(isRangeValid, JSON.stringify(errorBody));
+  if (!isRangeValid) {
+    onError?.(errorBody);
+  }
+
+  return isRangeValid;
+};
+
+export const wrangleMoment = (date?: string | Date): Date => {
+  if (date instanceof Date) {
+    return date;
+  } else if (!date) {
+    return new Date();
+  }
+  return date instanceof moment ? date.toDate() : parseISO(date);
+};
+
+export const formatIsoDate = (date?: string | Date): string =>
+  formatISO(wrangleMoment(date), {
+    representation: 'date',
+  });
+
+export const isStartOfRange = ({startDate}: DateRange, date: string): boolean =>
+  Boolean(startDate) && moment(date).isSame(moment(startDate), 'd');
+
+export const isEndOfRange = ({endDate}: DateRange, date: string): boolean =>
+  Boolean(endDate) && moment(date).isSame(moment(endDate), 'd');
+
+export const inDateRange = (
+  {startDate, endDate}: DateRange,
+  date: string,
+): boolean => {
+  if (startDate && endDate) {
+    const momentDay = moment(date);
+    const momentStartDate = moment(startDate);
+    const momentEndDate = moment(endDate);
+    return momentDay.isBetween(momentStartDate, momentEndDate, null, '[]');
+  }
+  return false;
+};
+
+export const isStartDateEndDateSame = ({
+  startDate,
+  endDate,
+}: DateRange): boolean => {
+  if (startDate && endDate) {
+    return moment(startDate).isSame(moment(endDate), 'd');
+  }
+  return false;
+};
+
+const getMonthAndYear = (date) => {
+  const momentDate = date ? moment(date) : moment();
+  return [momentDate.month(), momentDate.year()];
+};
+
+export const getDaysInMonth = (date: string): Array<Array<string>> => {
+  const startWeek = moment(date).startOf('month').startOf('week');
+  const endWeek = moment(date).endOf('month').endOf('week');
+  const days = [],
+    current = startWeek;
+
+  while (current.isBefore(endWeek)) {
+    days.push(current.clone().format('YYYY-MM-DD'));
+    current.add(1, 'd');
+  }
+  const daysInChunks = chunk(days, 7);
+
+  // if total rows in calendar are 5 add one more week to the calendar
+  if (daysInChunks.length === 5) {
+    const nextWeek = getAddedDate(endWeek, WEEKDAYS.length, 'd');
+    const extraDays = [];
+    while (current.isSameOrBefore(nextWeek)) {
+      extraDays.push(current.clone().format('YYYY-MM-DD'));
+      current.add(1, 'd');
+    }
+    daysInChunks.push(extraDays);
+  }
+
+  return daysInChunks;
+};
+
+export const getAddedDate = (
+  date: string,
+  addCount: number,
+  timeUnit: TimeUnit,
+): string => formatIsoDate(moment(date).add(addCount, timeUnit));
+
+export const getSubtractedDate = (
+  date: string,
+  subtractCount: number,
+  timeUnit: TimeUnit,
+): string => formatIsoDate(moment(date).subtract(subtractCount, timeUnit));
+
+export const getMonthEndDate = (date: string): string =>
+  formatIsoDate(moment(date).endOf('M'));
+
+export const addTimezone = (date: string, timezone: string): string =>
+  moment.tz(date, timezone).startOf('d').utc().toISOString();
+
+export const getTimezones = (): Array<MenuOption> =>
+  Object.keys(TIMEZONES).reduce((menuOptions, key) => {
+    menuOptions.push({
+      key,
+      label: TIMEZONES[key],
+    });
+    return menuOptions;
+  }, []);
+
+export const generateAvailableYears = ({
+  marker,
+  minDate,
+  maxDate,
+  rangeStartMonth,
+  rangeEndMonth,
+}: {
+  marker: $Values<typeof MARKERS>,
+  minDate: string,
+  maxDate: string,
+  rangeStartMonth: string,
+  rangeEndMonth: string,
+}): Array<MenuOption> => {
+  const rangeStartYear = moment(rangeStartMonth).year();
+  const rangeEndYear = moment(rangeEndMonth).year();
+
+  const isWithinRange = (year: number) =>
+    marker === MARKERS.DATE_RANGE_START
+      ? year <= rangeEndYear
+      : year >= rangeStartYear;
+
+  return range(moment(minDate).year(), moment(maxDate).year() + 1)
+    .filter((year) => isWithinRange(year))
+    .map((year) => ({
+      key: year.toString(),
+      label: year.toString(),
+    }));
+};
+
+export const getAvailableMonths = ({
+  marker,
+  minDate,
+  maxDate,
+  rangeStartMonth,
+  rangeEndMonth,
+}: {
+  marker: $Values<typeof MARKERS>,
+  minDate: string,
+  maxDate: string,
+  rangeStartMonth: string,
+  rangeEndMonth: string,
+}): Array<MenuOption> => {
+  const [rangeStartMonthKey, rangeStartYear] = getMonthAndYear(rangeStartMonth);
+  const [rangeEndMonthKey, rangeEndYear] = getMonthAndYear(rangeEndMonth);
+  const [minDateMonth, minDateYear] = getMonthAndYear(minDate);
+  const [maxDateMonth, maxDateYear] = getMonthAndYear(maxDate);
+
+  return MONTHS.filter((month: MenuOption) => {
+    const isSameYear = rangeStartYear === rangeEndYear;
+    const isFirstAndMinDateYearSame = rangeStartYear === minDateYear;
+    const isSecondAndMaxDateYearSame = rangeEndYear === maxDateYear;
+
+    if (marker === MARKERS.DATE_RANGE_START) {
+      if (isSameYear && month.key >= rangeEndMonthKey) {
+        return false;
+      } else if (isFirstAndMinDateYearSame && month.key < minDateMonth) {
+        return false;
+      } else {
+        return true;
+      }
+    } else {
+      if (isSameYear && month.key <= rangeStartMonthKey) {
+        return false;
+      } else if (isSecondAndMaxDateYearSame && month.key > maxDateMonth) {
+        return false;
+      } else {
+        return true;
+      }
+    }
+  });
+};
+
+export const getValidDates = (
+  selectedDateRange: DateRangeWithTimezone,
+  minDate?: ?string,
+  maxDate?: ?string,
+  onError?: (DateRangePickerError) => void,
+): {
+  validTimezone: string,
+  validMinDate: string,
+  validMaxDate: string,
+  validDateRange: DateRange,
+} => {
+  const today = formatIsoDate();
+  const localTimezone = moment.tz.guess();
+  const {startDate, endDate, timezone = ''} = selectedDateRange;
+
+  const validTimezone = isEmpty(timezone) ? localTimezone : timezone;
+  const validMaxDate = maxDate && !isEmpty(maxDate) ? maxDate : today;
+  const validMinDate =
+    minDate && !isEmpty(minDate) ? minDate : getSubtractedDate(today, 8, 'y');
+
+  const isRangeValid = (min, max, errorMessage) =>
+    checkRangeValidity(min, max, errorMessage, onError);
+
+  // minDate should be after maxDate
+  const isMinMaxRangeInvalid = !isRangeValid(
+    validMinDate,
+    validMaxDate,
+    DATE_RANGE_PICKER_ERRORS.MIN_MAX_INVALID,
+  );
+
+  // if startDate is defined and then it should be after minDate
+  const isStartDateInvalid =
+    isMinMaxRangeInvalid ||
+    isEmpty(startDate) ||
+    !isRangeValid(
+      minDate,
+      startDate,
+      DATE_RANGE_PICKER_ERRORS.START_DATE_EARLY,
+    );
+
+  if (isMinMaxRangeInvalid || isStartDateInvalid) {
+    return {
+      validTimezone,
+      validDateRange: {startDate: null, endDate: null},
+      validMinDate,
+      validMaxDate,
+    };
+  }
+
+  // if endDate is defined then it should be before maxDate
+  const isEndDateInvalid =
+    isEmpty(endDate) ||
+    !isRangeValid(endDate, maxDate, DATE_RANGE_PICKER_ERRORS.END_DATE_LATE);
+
+  // startDate should be before endDate
+  const isStartEndRangeInvalid =
+    isEndDateInvalid ||
+    !isRangeValid(startDate, endDate, DATE_RANGE_PICKER_ERRORS.START_DATE_LATE);
+
+  if (isEndDateInvalid || isStartEndRangeInvalid) {
+    return {
+      validTimezone,
+      validDateRange: {startDate, endDate: null},
+      validMinDate,
+      validMaxDate,
+    };
+  }
+
+  return {
+    validTimezone,
+    validDateRange: {
+      startDate: isEmpty(startDate) ? null : startDate,
+      endDate: isEmpty(endDate) ? null : endDate,
+    },
+    validMinDate,
+    validMaxDate,
+  };
+};

package/lib/utils/date-range-picker/index.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _dateRangePicker = require("./date-range-picker");
+Object.keys(_dateRangePicker).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _dateRangePicker[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _dateRangePicker[key];
+    }
+  });
+});
+var _timezones = require("./timezones");
+Object.keys(_timezones).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _timezones[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _timezones[key];
+    }
+  });
+});

package/lib/utils/date-range-picker/index.js.flow

@@ -0,0 +1,4 @@
+// @flow strict
+
+export * from './date-range-picker';
+export * from './timezones';

package/lib/utils/index.js

@@ -47,6 +47,17 @@ Object.keys(_clickAway).forEach(function (key) {
     }
   });
 });
+var _dateRangePicker = require("./date-range-picker");
+Object.keys(_dateRangePicker).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _dateRangePicker[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _dateRangePicker[key];
+    }
+  });
+});
 var _dom = require("./dom");
 Object.keys(_dom).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;

package/lib/utils/index.js.flow

@@ -4,6 +4,7 @@ export * from './array';
 export * from './charts';
 export * from './classify';
 export * from './click-away';
+export * from './date-range-picker';
 export * from './dom';
 export * from './helpers';
 export * from './makeClassNameComponent';