react-day-picker 8.4.0 → 8.5.0

package/src/contexts/Focus/FocusContext.test.ts

@@ -1,4 +1,4 @@
-import { act, RenderResult } from '@testing-library/react-hooks';
+import { act } from '@testing-library/react';
 import {
   addDays,
   addMonths,
@@ -8,19 +8,16 @@ import {
   startOfWeek
 } from 'date-fns';
 
-import { customRenderHook } from 'test/render';
+import { renderDayPickerHook, RenderHookResult } from 'test/render';
 import { freezeBeforeAll } from 'test/utils';
 
 import { FocusContextValue, useFocusContext } from 'contexts/Focus';
 
-let renderResult: RenderResult<FocusContextValue>;
-
 const today = new Date(2021, 11, 8); // make sure is in the middle of the week for the complete test
 freezeBeforeAll(today);
 
-function setup() {
-  const { result } = customRenderHook(() => useFocusContext());
-  renderResult = result;
+function renderHook() {
+  return renderDayPickerHook<FocusContextValue>(useFocusContext);
 }
 
 type HookFunction =
@@ -35,12 +32,9 @@ type HookFunction =
   | 'focusStartOfWeek'
   | 'focusEndOfWeek';
 
-beforeEach(() => {
-  setup();
-});
-
 test('`focusedDay` should be undefined', () => {
-  expect(renderResult.current.focusedDay).toBeUndefined();
+  const result = renderHook();
+  expect(result.current.focusedDay).toBeUndefined();
 });
 
 const tests: Array<HookFunction> = [
@@ -56,128 +50,107 @@ const tests: Array<HookFunction> = [
   'focusEndOfWeek'
 ];
 describe.each(tests)('when calling %s', (fn: HookFunction) => {
-  beforeEach(() => {
-    renderResult.current[fn];
-  });
   test('`focusedDay` should be undefined', () => {
-    expect(renderResult.current.focusedDay).toBeUndefined();
+    const result = renderHook();
+    result.current[fn];
+    expect(result.current.focusedDay).toBeUndefined();
   });
 });
 
 describe('when a day is focused', () => {
   const day = today;
+  let result: RenderHookResult<FocusContextValue>;
   beforeEach(() => {
-    act(() => renderResult.current.focus(day));
+    result = renderHook();
+    act(() => result.current.focus(day));
   });
   test('should set the focused day', () => {
-    expect(renderResult.current.focusedDay).toEqual(day);
+    expect(result.current.focusedDay).toEqual(day);
   });
   describe('when "focusDayBefore" is called', () => {
     const dayBefore = addDays(day, -1);
-    beforeEach(() => {
-      act(() => renderResult.current.focusDayBefore());
-    });
+    beforeEach(() => act(() => result.current.focusDayBefore()));
     test('should focus the day before', () => {
-      expect(renderResult.current.focusedDay).toEqual(dayBefore);
+      expect(result.current.focusedDay).toEqual(dayBefore);
     });
     test.todo('should call the navigation goToDate');
   });
   describe('when "focusDayAfter" is called', () => {
-    beforeEach(() => {
-      act(() => renderResult.current.focusDayAfter());
-    });
+    beforeEach(() => act(() => result.current.focusDayAfter()));
     test('should focus the day after', () => {
       const dayAfter = addDays(day, 1);
-      expect(renderResult.current.focusedDay).toEqual(dayAfter);
+      expect(result.current.focusedDay).toEqual(dayAfter);
     });
     test.todo('should call the navigation goToDate');
   });
   describe('when "focusWeekBefore" is called', () => {
-    beforeEach(() => {
-      act(() => renderResult.current.focusWeekBefore());
-    });
+    beforeEach(() => act(() => result.current.focusWeekBefore()));
     test('should focus the day in the previous week', () => {
       const prevWeek = addWeeks(day, -1);
-      expect(renderResult.current.focusedDay).toEqual(prevWeek);
+      expect(result.current.focusedDay).toEqual(prevWeek);
     });
     test.todo('should call the navigation goToDate');
   });
   describe('when "focusWeekAfter" is called', () => {
-    beforeEach(() => {
-      act(() => renderResult.current.focusWeekAfter());
-    });
+    beforeEach(() => act(() => result.current.focusWeekAfter()));
     test('should focus the day in the next week', () => {
       const nextWeek = addWeeks(day, 1);
-      expect(renderResult.current.focusedDay).toEqual(nextWeek);
+      expect(result.current.focusedDay).toEqual(nextWeek);
     });
     test.todo('should call the navigation goToDate');
   });
   describe('when "focusStartOfWeek" is called', () => {
-    beforeEach(() => {
-      act(() => renderResult.current.focusStartOfWeek());
-    });
+    beforeEach(() => act(() => result.current.focusStartOfWeek()));
     test('should focus the first day of the week', () => {
       const firstDayOfWeek = startOfWeek(day);
-      expect(renderResult.current.focusedDay).toEqual(firstDayOfWeek);
+      expect(result.current.focusedDay).toEqual(firstDayOfWeek);
     });
     test.todo('should call the navigation goToDate');
   });
   describe('when "focusEndOfWeek" is called', () => {
-    beforeEach(() => {
-      act(() => renderResult.current.focusEndOfWeek());
-    });
+    beforeEach(() => act(() => result.current.focusEndOfWeek()));
     test('should focus the last day of the week', () => {
       const lastDayOfWeek = endOfWeek(day);
-      expect(renderResult.current.focusedDay).toEqual(lastDayOfWeek);
+      expect(result.current.focusedDay).toEqual(lastDayOfWeek);
     });
     test.todo('should call the navigation goToDate');
   });
   describe('when "focusMonthBefore" is called', () => {
-    beforeEach(() => {
-      act(() => renderResult.current.focusMonthBefore());
-    });
+    beforeEach(() => act(() => result.current.focusMonthBefore()));
     test('should focus the day in the month before', () => {
       const monthBefore = addMonths(day, -1);
-      expect(renderResult.current.focusedDay).toEqual(monthBefore);
+      expect(result.current.focusedDay).toEqual(monthBefore);
     });
     test.todo('should call the navigation goToDate');
   });
   describe('when "focusMonthAfter" is called', () => {
-    beforeEach(() => {
-      act(() => renderResult.current.focusMonthAfter());
-    });
+    beforeEach(() => act(() => result.current.focusMonthAfter()));
     test('should focus the day in the month after', () => {
       const monthAfter = addMonths(day, 1);
-      expect(renderResult.current.focusedDay).toEqual(monthAfter);
+      expect(result.current.focusedDay).toEqual(monthAfter);
     });
     test.todo('should call the navigation goToDate');
   });
   describe('when "focusYearBefore" is called', () => {
-    beforeEach(() => {
-      act(() => renderResult.current.focusYearBefore());
-    });
+    beforeEach(() => act(() => result.current.focusYearBefore()));
     test('should focus the day in the year before', () => {
       const prevYear = addYears(day, -1);
-      expect(renderResult.current.focusedDay).toEqual(prevYear);
+      expect(result.current.focusedDay).toEqual(prevYear);
     });
     test.todo('should call the navigation goToDate');
   });
   describe('when "focusYearAfter" is called', () => {
-    beforeEach(() => {
-      act(() => renderResult.current.focusYearAfter());
-    });
+    beforeEach(() => act(() => result.current.focusYearAfter()));
     test('should focus the day in the year after', () => {
       const nextYear = addYears(day, 1);
-      expect(renderResult.current.focusedDay).toEqual(nextYear);
+      expect(result.current.focusedDay).toEqual(nextYear);
     });
     test.todo('should call the navigation goToDate');
   });
   describe('when blur is called', () => {
-    beforeEach(() => {
-      act(() => renderResult.current.blur());
-    });
+    beforeEach(() => act(() => result.current.blur()));
     test('`focusedDay` should be undefined', () => {
-      expect(renderResult.current.focusedDay).toBeUndefined();
+      expect(result.current.focusedDay).toBeUndefined();
     });
   });
 });

package/src/contexts/Focus/FocusContext.tsx

@@ -1,6 +1,6 @@
 import React, { createContext, ReactNode, useContext, useState } from 'react';
 
-import isSameDay from 'date-fns/isSameDay';
+import { isSameDay } from 'date-fns';
 
 import { useDayPicker } from 'contexts/DayPicker';
 

package/src/contexts/Focus/utils/getInitialFocusTarget.ts

@@ -1,6 +1,4 @@
-import addDays from 'date-fns/addDays';
-import endOfMonth from 'date-fns/endOfMonth';
-import startOfMonth from 'date-fns/startOfMonth';
+import { addDays, endOfMonth, startOfMonth } from 'date-fns';
 
 import { getActiveModifiers } from 'contexts/Modifiers';
 import { Modifiers } from 'types/Modifiers';

package/src/contexts/Focus/utils/getNextFocus.ts

@@ -1,13 +1,15 @@
-import addDays from 'date-fns/addDays';
-import addMonths from 'date-fns/addMonths';
-import addWeeks from 'date-fns/addWeeks';
-import addYears from 'date-fns/addYears';
-import endOfISOWeek from 'date-fns/endOfISOWeek';
-import endOfWeek from 'date-fns/endOfWeek';
-import max from 'date-fns/max';
-import min from 'date-fns/min';
-import startOfISOWeek from 'date-fns/startOfISOWeek';
-import startOfWeek from 'date-fns/startOfWeek';
+import {
+  addDays,
+  addMonths,
+  addWeeks,
+  addYears,
+  endOfISOWeek,
+  endOfWeek,
+  max,
+  min,
+  startOfISOWeek,
+  startOfWeek
+} from 'date-fns';
 
 import { DayPickerContextValue } from 'contexts/DayPicker';
 import { getActiveModifiers } from 'contexts/Modifiers';

package/src/contexts/Modifiers/ModifiersContext.test.ts

@@ -1,20 +1,16 @@
-import { RenderResult } from '@testing-library/react-hooks';
 import { DayPickerProps } from 'DayPicker';
 
-import { customRenderHook } from 'test/render';
+import { renderDayPickerHook } from 'test/render';
 
 import { useModifiers } from 'contexts/Modifiers';
 import { DayModifiers, InternalModifier, Modifiers } from 'types/Modifiers';
 
-let renderResult: RenderResult<Modifiers>;
+const internalModifiers = Object.values(InternalModifier);
 
-function setup(dayPickerProps: DayPickerProps) {
-  const { result } = customRenderHook(() => useModifiers(), dayPickerProps);
-  renderResult = result;
+function renderHook(dayPickerProps: Partial<DayPickerProps> = {}) {
+  return renderDayPickerHook<Modifiers>(useModifiers, dayPickerProps);
 }
 
-const internalModifiers = Object.values(InternalModifier);
-
 describe('when rendered with custom modifiers', () => {
   const modifier = new Date(2018, 11, 12);
   const dayModifiers: DayModifiers = {
@@ -28,17 +24,15 @@ describe('when rendered with custom modifiers', () => {
     range_end: modifier,
     range_middle: modifier
   };
-  beforeEach(() => {
-    setup({ modifiers: dayModifiers });
-  });
-
   test('should return the custom modifiers', () => {
-    expect(renderResult.current.foo).toEqual([dayModifiers.foo]);
+    const result = renderHook({ modifiers: dayModifiers });
+    expect(result.current.foo).toEqual([dayModifiers.foo]);
   });
   test.each(internalModifiers)(
     'should override the %s internal modifier',
     (internalModifier) => {
-      expect(renderResult.current[internalModifier]).toEqual([
+      const result = renderHook({ modifiers: dayModifiers });
+      expect(result.current[internalModifier]).toEqual([
         dayModifiers[internalModifier]
       ]);
     }

package/src/contexts/Modifiers/utils/getActiveModifiers.ts

@@ -1,4 +1,4 @@
-import isSameMonth from 'date-fns/isSameMonth';
+import { isSameMonth } from 'date-fns';
 
 import { ActiveModifiers, Modifiers } from 'types/Modifiers';
 

package/src/contexts/Modifiers/utils/isDateInRange.ts

@@ -1,5 +1,4 @@
-import differenceInCalendarDays from 'date-fns/differenceInCalendarDays';
-import isSameDay from 'date-fns/isSameDay';
+import { differenceInCalendarDays, isSameDay } from 'date-fns';
 
 import { DateRange } from 'types/Matchers';
 

package/src/contexts/Modifiers/utils/isMatch.ts

@@ -1,7 +1,4 @@
-import { isAfter } from 'date-fns';
-import differenceInCalendarDays from 'date-fns/differenceInCalendarDays';
-import isDate from 'date-fns/isDate';
-import isSameDay from 'date-fns/isSameDay';
+import { differenceInCalendarDays, isAfter, isDate, isSameDay } from 'date-fns';
 
 import {
   isDateAfterType,

package/src/contexts/Navigation/NavigationContext.test.ts

@@ -1,28 +1,24 @@
-import { act, RenderResult } from '@testing-library/react-hooks';
+import { act } from '@testing-library/react';
 import { addMonths, startOfMonth, subMonths } from 'date-fns';
+import { DayPickerProps } from 'DayPicker';
 
-import { customRenderHook } from 'test/render/customRenderHook';
+import { renderDayPickerHook, RenderHookResult } from 'test/render';
 import { freezeBeforeAll } from 'test/utils';
 
-import { DayPickerBase } from 'types/DayPickerBase';
-
 import { NavigationContextValue, useNavigation } from './NavigationContext';
 
 const today = new Date(2021, 11, 8);
 const todaysMonth = startOfMonth(today);
 freezeBeforeAll(today);
 
-let result: RenderResult<NavigationContextValue>;
-
-function setup(dayPickerProps?: DayPickerBase) {
-  const view = customRenderHook(() => useNavigation(), dayPickerProps);
-  result = view.result;
-  return result;
+function renderHook(props: Partial<DayPickerProps> = {}) {
+  return renderDayPickerHook<NavigationContextValue>(useNavigation, props);
 }
 
+let result: RenderHookResult<NavigationContextValue>;
 describe('when rendered', () => {
   beforeEach(() => {
-    setup();
+    result = renderHook();
   });
   test('the current month should be the today`s month', () => {
     expect(result.current.currentMonth).toEqual(todaysMonth);
@@ -39,9 +35,8 @@ describe('when rendered', () => {
   describe('when goToMonth is called', () => {
     const newMonth = addMonths(todaysMonth, 10);
     beforeEach(() => {
-      act(() => {
-        result.current.goToMonth(newMonth);
-      });
+      result = renderHook();
+      act(() => result.current.goToMonth(newMonth));
     });
     test('should go to the specified month', () => {
       expect(result.current.currentMonth).toEqual(newMonth);
@@ -60,7 +55,7 @@ describe('when rendered', () => {
     const newDate = addMonths(today, 10);
     const onMonthChange = jest.fn();
     beforeEach(() => {
-      setup({ onMonthChange });
+      result = renderHook({ onMonthChange });
       act(() => result.current.goToDate(newDate));
     });
     test('should go to the specified month', () => {
@@ -86,7 +81,7 @@ describe('when rendered', () => {
 const numberOfMonths = 2;
 describe('when the number of months is ${numberOfMonths}', () => {
   beforeEach(() => {
-    setup({ numberOfMonths: 2 });
+    result = renderHook({ numberOfMonths: 2 });
   });
   test('the current month should be the today`s month', () => {
     expect(result.current.currentMonth).toEqual(todaysMonth);
@@ -107,7 +102,7 @@ describe('when the number of months is ${numberOfMonths}', () => {
 
 describe(`when the number of months is ${numberOfMonths} and the navigation is paged`, () => {
   beforeEach(() => {
-    setup({ numberOfMonths, pagedNavigation: true });
+    result = renderHook({ numberOfMonths, pagedNavigation: true });
   });
   test('the current month should be the today`s month', () => {
     expect(result.current.currentMonth).toEqual(todaysMonth);

package/src/contexts/Navigation/NavigationContext.tsx

@@ -1,8 +1,6 @@
 import React, { createContext, ReactNode, useContext } from 'react';
 
-import addMonths from 'date-fns/addMonths';
-import isBefore from 'date-fns/isBefore';
-import isSameMonth from 'date-fns/isSameMonth';
+import { addMonths, isBefore, isSameMonth } from 'date-fns';
 
 import { useDayPicker } from '../DayPicker';
 import { useNavigationState } from './useNavigationState';

package/src/contexts/Navigation/useNavigationState.test.ts

@@ -1,39 +1,32 @@
-import { act } from '@testing-library/react-hooks';
+import { act } from '@testing-library/react';
 import { addMonths, startOfMonth } from 'date-fns';
+import { DayPickerProps } from 'DayPicker';
 
-import { customRenderHook } from 'test/render/customRenderHook';
+import { renderDayPickerHook } from 'test/render';
 import { freezeBeforeAll } from 'test/utils';
 
-import { DayPickerBase } from 'types/DayPickerBase';
-
-import { useNavigationState } from './useNavigationState';
+import { NavigationState, useNavigationState } from './useNavigationState';
 
 const today = new Date(2021, 11, 8);
 freezeBeforeAll(today);
 
-function setup(dayPickerProps?: DayPickerBase) {
-  const { result } = customRenderHook(
-    () => useNavigationState(),
-    dayPickerProps
-  );
-  return result;
+function renderHook(props: Partial<DayPickerProps> = {}) {
+  return renderDayPickerHook<NavigationState>(useNavigationState, props);
 }
 
 describe('when goToMonth is called', () => {
   test('should set the month in state', () => {
     const onMonthChange = jest.fn();
-    const result = setup({ onMonthChange });
+    const result = renderHook({ onMonthChange });
     const month = addMonths(today, 2);
-    act(() => {
-      result.current[1](month);
-    });
+    act(() => result.current[1](month));
     expect(result.current[0]).toEqual(startOfMonth(month));
     expect(onMonthChange).toHaveBeenCalledWith(startOfMonth(month));
   });
   describe('when navigation is disabled', () => {
     test('should not set the month in state', () => {
       const onMonthChange = jest.fn();
-      const result = setup({ disableNavigation: true, onMonthChange });
+      const result = renderHook({ disableNavigation: true, onMonthChange });
       const month = addMonths(today, 2);
       result.current[1](month);
       expect(result.current[0]).toEqual(startOfMonth(today));

package/src/contexts/Navigation/useNavigationState.ts

@@ -1,17 +1,19 @@
-import startOfMonth from 'date-fns/startOfMonth';
+import { startOfMonth } from 'date-fns';
 
 import { useDayPicker } from 'contexts/DayPicker';
 import { useControlledValue } from 'hooks/useControlledValue';
 
 import { getInitialMonth } from './utils/getInitialMonth';
 
-/** Controls the navigation state. */
-export function useNavigationState(): [
+export type NavigationState = [
   /** The month DayPicker is navigating at */
   month: Date,
   /** Go to the specified month. */
   goToMonth: (month: Date) => void
-] {
+];
+
+/** Controls the navigation state. */
+export function useNavigationState(): NavigationState {
   const context = useDayPicker();
   const initialMonth = getInitialMonth(context);
   const [month, setMonth] = useControlledValue(initialMonth, context.month);

package/src/contexts/Navigation/utils/getDisplayMonths.ts

@@ -1,6 +1,4 @@
-import addMonths from 'date-fns/addMonths';
-import differenceInCalendarMonths from 'date-fns/differenceInCalendarMonths';
-import startOfMonth from 'date-fns/startOfMonth';
+import { addMonths, differenceInCalendarMonths, startOfMonth } from 'date-fns';
 
 /**
  * Return the months to display in the component according to the number of

package/src/contexts/Navigation/utils/getInitialMonth.ts

@@ -1,6 +1,4 @@
-import addMonths from 'date-fns/addMonths';
-import differenceInCalendarMonths from 'date-fns/differenceInCalendarMonths';
-import startOfMonth from 'date-fns/startOfMonth';
+import { addMonths, differenceInCalendarMonths, startOfMonth } from 'date-fns';
 
 import { DayPickerContextValue } from 'contexts/DayPicker';
 

package/src/contexts/Navigation/utils/getNextMonth.ts

@@ -1,6 +1,4 @@
-import addMonths from 'date-fns/addMonths';
-import differenceInCalendarMonths from 'date-fns/differenceInCalendarMonths';
-import startOfMonth from 'date-fns/startOfMonth';
+import { addMonths, differenceInCalendarMonths, startOfMonth } from 'date-fns';
 
 /**
  * Returns the next month the user can navigate to according to the given

package/src/contexts/Navigation/utils/getPreviousMonth.ts

@@ -1,6 +1,4 @@
-import addMonths from 'date-fns/addMonths';
-import differenceInCalendarMonths from 'date-fns/differenceInCalendarMonths';
-import startOfMonth from 'date-fns/startOfMonth';
+import { addMonths, differenceInCalendarMonths, startOfMonth } from 'date-fns';
 
 /**
  * Returns the next previous the user can navigate to, according to the given

package/src/contexts/SelectMultiple/SelectMultipleContext.test.ts

@@ -1,7 +1,7 @@
-import { RenderResult } from '@testing-library/react-hooks';
 import { addDays, addMonths } from 'date-fns';
+import { DayPickerProps } from 'DayPicker';
 
-import { customRenderHook } from 'test/render/customRenderHook';
+import { renderDayPickerHook } from 'test/render';
 import { freezeBeforeAll } from 'test/utils';
 
 import { isMatch } from 'contexts/Modifiers/utils/isMatch';
@@ -16,17 +16,15 @@ import {
 const today = new Date(2021, 11, 8);
 freezeBeforeAll(today);
 
-let result: RenderResult<SelectMultipleContextValue>;
-
-function setup(dayPickerProps?: DayPickerMultipleProps) {
-  const view = customRenderHook(useSelectMultiple, dayPickerProps);
-  result = view.result;
+function renderHook(props?: Partial<DayPickerProps>) {
+  return renderDayPickerHook<SelectMultipleContextValue>(
+    useSelectMultiple,
+    props
+  );
 }
 
 describe('when is not a multiple select DayPicker', () => {
-  beforeAll(() => {
-    setup();
-  });
+  const result = renderHook();
   test('the selected day should be undefined', () => {
     expect(result.current.selected).toBeUndefined();
   });
@@ -52,10 +50,8 @@ describe('when days are selected', () => {
     selected
   };
 
-  beforeAll(() => {
-    setup(dayPickerProps);
-  });
   test('it should return the days as selected', () => {
+    const result = renderHook(dayPickerProps);
     expect(result.current.selected).toStrictEqual(selected);
   });
   describe('when `onDayClick` is called with a not selected day', () => {
@@ -63,6 +59,7 @@ describe('when days are selected', () => {
     const activeModifiers = {};
     const event = {} as React.MouseEvent;
     beforeAll(() => {
+      const result = renderHook(dayPickerProps);
       result.current.onDayClick?.(clickedDay, activeModifiers, event);
     });
     afterAll(() => {
@@ -89,6 +86,7 @@ describe('when days are selected', () => {
     const clickedDay = selectedDay1;
     const activeModifiers: ActiveModifiers = { selected: true };
     beforeAll(() => {
+      const result = renderHook(dayPickerProps);
       result.current.onDayClick?.(clickedDay, activeModifiers, event);
     });
     afterAll(() => {
@@ -121,17 +119,15 @@ describe('when the maximum number of days are selected', () => {
     selected,
     max: selected.length
   };
-  beforeAll(() => {
-    setup(dayPickerProps);
-  });
-
   test('the selected days should not be disabled', () => {
+    const result = renderHook(dayPickerProps);
     const { disabled } = result.current.modifiers;
     expect(isMatch(selectedDay1, disabled)).toBe(false);
     expect(isMatch(selectedDay2, disabled)).toBe(false);
     expect(isMatch(selectedDay3, disabled)).toBe(false);
   });
   test('the other days should be disabled', () => {
+    const result = renderHook(dayPickerProps);
     const { disabled } = result.current.modifiers;
     expect(isMatch(addMonths(selectedDay1, 1), disabled)).toBe(true);
     expect(isMatch(addMonths(selectedDay2, 1), disabled)).toBe(true);
@@ -140,6 +136,7 @@ describe('when the maximum number of days are selected', () => {
     const clickedDay = addMonths(selectedDay1, 1);
     const activeModifiers: ActiveModifiers = {};
     beforeAll(() => {
+      const result = renderHook(dayPickerProps);
       result.current.onDayClick?.(clickedDay, activeModifiers, event);
     });
     afterAll(() => {
@@ -166,13 +163,11 @@ describe('when the minimum number of days are selected', () => {
     selected,
     min: selected.length
   };
-  beforeAll(() => {
-    setup(dayPickerProps);
-  });
   describe('when `onDayClick` is called with one of the selected days', () => {
     const clickedDay = selected[0];
     const activeModifiers: ActiveModifiers = { selected: true };
     beforeAll(() => {
+      const result = renderHook(dayPickerProps);
       result.current.onDayClick?.(clickedDay, activeModifiers, event);
     });
     afterAll(() => {

package/src/contexts/SelectMultiple/SelectMultipleContext.tsx

@@ -1,6 +1,6 @@
 import React, { createContext, ReactNode, useContext } from 'react';
 
-import isSameDay from 'date-fns/isSameDay';
+import { isSameDay } from 'date-fns';
 
 import { DayPickerBase } from 'types/DayPickerBase';
 import {