Added some helper function to deal with dates

src/utils/dates/types/index.ts

@@ -1,13 +1,13 @@
 import { subDays, startOfDay, endOfDay } from 'date-fns';
-import { filter, isEmpty } from 'ramda';
-import { formatInternational } from '../../helpers/date';
+import { cond, filter, isEmpty, T } from 'ramda';
+import { DateOrString, formatInternational, isBeforeOrEqual, parseISO } from '../../helpers/date';
 
 export interface DateRange {
   startDate?: Date | null;
   endDate?: Date | null;
 }
 
-export type DateInterval = 'all' | 'today' | 'yesterday' | 'last7Days' | 'last30Days' | 'last90Days' | 'last180days' | 'last365Days';
+export type DateInterval = 'all' | 'today' | 'yesterday' | 'last7Days' | 'last30Days' | 'last90Days' | 'last180Days' | 'last365Days';
 
 export const dateRangeIsEmpty = (dateRange?: DateRange): boolean => dateRange === undefined
   || isEmpty(filter(Boolean, dateRange as any));
@@ -21,7 +21,7 @@ const INTERVAL_TO_STRING_MAP: Record<DateInterval, string | undefined> = {
   last7Days: 'Last 7 days',
   last30Days: 'Last 30 days',
   last90Days: 'Last 90 days',
-  last180days: 'Last 180 days',
+  last180Days: 'Last 180 days',
   last365Days: 'Last 365 days',
   all: undefined,
 };
@@ -75,7 +75,7 @@ export const intervalToDateRange = (dateInterval?: DateInterval): DateRange => {
       return endingToday(startOfDaysAgo(30));
     case 'last90Days':
       return endingToday(startOfDaysAgo(90));
-    case 'last180days':
+    case 'last180Days':
       return endingToday(startOfDaysAgo(180));
     case 'last365Days':
       return endingToday(startOfDaysAgo(365));
@@ -83,3 +83,18 @@ export const intervalToDateRange = (dateInterval?: DateInterval): DateRange => {
 
   return {};
 };
+
+export const dateToMatchingInterval = (date: DateOrString): DateInterval => {
+  const theDate: Date = parseISO(date);
+
+  return cond<never, DateInterval>([
+    [ () => isBeforeOrEqual(startOfDay(new Date()), theDate), () => 'today' ],
+    [ () => isBeforeOrEqual(startOfDaysAgo(1), theDate), () => 'yesterday' ],
+    [ () => isBeforeOrEqual(startOfDaysAgo(7), theDate), () => 'last7Days' ],
+    [ () => isBeforeOrEqual(startOfDaysAgo(30), theDate), () => 'last30Days' ],
+    [ () => isBeforeOrEqual(startOfDaysAgo(90), theDate), () => 'last90Days' ],
+    [ () => isBeforeOrEqual(startOfDaysAgo(180), theDate), () => 'last180Days' ],
+    [ () => isBeforeOrEqual(startOfDaysAgo(365), theDate), () => 'last365Days' ],
+    [ T, () => 'all' ],
+  ])();
+};

src/utils/helpers/date.ts

@@ -1,7 +1,8 @@
-import { format, formatISO, isAfter, isBefore, isWithinInterval, parse, parseISO as stdParseISO } from 'date-fns';
+import { format, formatISO, isBefore, isEqual, isWithinInterval, parse, parseISO as stdParseISO } from 'date-fns';
 import { OptionalString } from '../utils';
 
-type DateOrString = Date | string;
+export type DateOrString = Date | string;
+
 type NullableDate = DateOrString | null;
 
 export const isDateObject = (date: DateOrString): date is Date => typeof date !== 'string';
@@ -22,20 +23,15 @@ export const formatInternational = formatDate();
 
 export const parseDate = (date: string, format: string) => parse(date, format, new Date());
 
-const parseISO = (date: DateOrString): Date => isDateObject(date) ? date : stdParseISO(date);
+export const parseISO = (date: DateOrString): Date => isDateObject(date) ? date : stdParseISO(date);
 
 export const isBetween = (date: DateOrString, start?: DateOrString, end?: DateOrString): boolean => {
-  if (!start && end) {
-    return isBefore(parseISO(date), parseISO(end));
+  try {
+    return isWithinInterval(parseISO(date), { start: parseISO(start ?? date), end: parseISO(end ?? date) });
+  } catch (e) {
+    return false;
   }
-
-  if (start && !end) {
-    return isAfter(parseISO(date), parseISO(start));
-  }
-
-  if (start && end) {
-    return isWithinInterval(parseISO(date), { start: parseISO(start), end: parseISO(end) });
-  }
-
-  return true;
 };
+
+export const isBeforeOrEqual = (date: Date | number, dateToCompare: Date | number) =>
+  isEqual(date, dateToCompare) || isBefore(date, dateToCompare);

src/utils/helpers/hooks.ts

@@ -1,4 +1,4 @@
-import { useState, useRef } from 'react';
+import { useState, useRef, EffectCallback, DependencyList, useEffect } from 'react';
 import { useSwipeable as useReactSwipeable } from 'react-swipeable';
 import { parseQuery, stringifyQuery } from './query';
 
@@ -66,3 +66,12 @@ export const useQueryState = <T>(paramName: string, initialState: T): [ T, (newV
 
   return [ value, setValueWithLocation ];
 };
+
+export const useEffectExceptFirstTime = (callback: EffectCallback, deps: DependencyList): void => {
+  const isFirstLoad = useRef(true);
+
+  useEffect(() => {
+    !isFirstLoad.current && callback();
+    isFirstLoad.current = false;
+  }, deps);
+};

src/visits/types/index.ts

@@ -1,7 +1,7 @@
 import { Action } from 'redux';
 import { ShortUrl } from '../../short-urls/data';
 import { ProblemDetailsError, ShlinkVisitsParams } from '../../api/types';
-import { DateRange } from '../../utils/dates/types';
+import { DateInterval, DateRange } from '../../utils/dates/types';
 
 export interface VisitsInfo {
   visits: Visit[];
@@ -12,12 +12,17 @@ export interface VisitsInfo {
   progress: number;
   cancelLoad: boolean;
   query?: ShlinkVisitsParams;
+  fallbackInterval?: DateInterval;
 }
 
 export interface VisitsLoadProgressChangedAction extends Action<string> {
   progress: number;
 }
 
+export interface VisitsFallbackIntervalAction extends Action<string> {
+  fallbackInterval: DateInterval;
+}
+
 export type OrphanVisitType = 'base_url' | 'invalid_short_url' | 'regular_404';
 
 interface VisitLocation {