willba-component-library 0.2.54 → 0.2.56

package/src/core/components/calendar/hooks/useCalendarTooltips.tsx

@@ -0,0 +1,139 @@
+import { useEffect } from 'react'
+import { DateRange } from 'react-day-picker'
+
+type Props = {
+  calendarRange?: DateRange
+  updateCalendarMonthNavigation?: boolean
+  overlappingDate?: DateRange[]
+  updateCalendarDefaultMoth?: number
+  showFeedback?: boolean
+}
+
+export const useCalendarTooltips = ({
+  calendarRange,
+  updateCalendarMonthNavigation,
+  overlappingDate,
+  updateCalendarDefaultMoth,
+  showFeedback,
+}: Props) =>
+  useEffect(() => {
+    if (typeof document === 'undefined' || !showFeedback) return
+
+    // Children
+    const calendarTooltip = document.querySelector('.will-calendar-tooltip')
+    const calendarTooltipCheckOut = document.querySelector(
+      '.will-calendar-tooltip-check-out'
+    )
+
+    const calendarTooltipOverlappingDate = document.querySelector(
+      '.will-calendar-tooltip-overlapping-date'
+    )
+
+    const loadingSpinner = document.querySelector(
+      '.will-filter-bar-calendar .will-calendar-spinner'
+    )
+
+    const calendarTooltipCheckInOnly = document.querySelector(
+      '.will-calendar-tooltip-check-in-only'
+    )
+    const calendarTooltipCheckOutOnly = document.querySelector(
+      '.will-calendar-tooltip-check-out-only'
+    )
+
+    // Parents
+    const calendarButtons = document.querySelectorAll(
+      '.will-filter-bar-calendar .rdp-cell:has(.booked):not(:has(.disabled-after-check-in))'
+    )
+    const calendarButtonsCheckOut = document.querySelectorAll(
+      '.will-filter-bar-calendar .rdp-cell:has(.booked.disabled-after-check-in)'
+    )
+    const calendarMonthContainer = document.querySelector(
+      '.will-filter-bar-calendar .rdp-months'
+    )
+    const calendarOverlappingDate = document.querySelectorAll(
+      '.will-filter-bar-calendar .rdp-cell:has(.overlapping-date)'
+    )
+
+    const calendarCheckInOnly = document.querySelectorAll(
+      '.will-filter-bar-calendar .rdp-cell:has(.check-in-only)'
+    )
+
+    const calendarCheckOutOnly = document.querySelectorAll(
+      '.will-filter-bar-calendar .rdp-cell:has(.check-out-only)'
+    )
+
+    // Append children to parents
+
+    const tooltipClonesCheckIn: Element[] = []
+    const tooltipClonesCheckOut: Element[] = []
+    const tooltipClonesCheckInOnly: Element[] = []
+    const tooltipClonesCheckOutOnly: Element[] = []
+    const tooltipClonesSpinner: Element[] = []
+    const tooltipClonesOverlappingDates: Element[] = []
+
+    if (calendarTooltip && calendarButtons.length > 0) {
+      calendarButtons.forEach((element) => {
+        const tooltipClone: Element = calendarTooltip.cloneNode(true) as Element
+        element.appendChild(tooltipClone)
+        tooltipClonesCheckIn.push(tooltipClone)
+      })
+    }
+
+    if (calendarTooltipCheckOut && calendarButtonsCheckOut.length > 0) {
+      calendarButtonsCheckOut.forEach((element) => {
+        const tooltipClone: Element = calendarTooltipCheckOut.cloneNode(
+          true
+        ) as Element
+        element.appendChild(tooltipClone)
+        tooltipClonesCheckOut.push(tooltipClone)
+      })
+    }
+
+    if (calendarTooltipCheckOutOnly && calendarCheckOutOnly.length > 0) {
+      calendarCheckOutOnly.forEach((element) => {
+        const tooltipClone: Element = calendarTooltipCheckOutOnly.cloneNode(
+          true
+        ) as Element
+        element.appendChild(tooltipClone)
+        tooltipClonesCheckOutOnly.push(tooltipClone)
+      })
+    }
+
+    if (calendarTooltipCheckInOnly && calendarCheckInOnly.length > 0) {
+      calendarCheckInOnly.forEach((element) => {
+        const tooltipClone: Element = calendarTooltipCheckInOnly.cloneNode(
+          true
+        ) as Element
+        element.appendChild(tooltipClone)
+        tooltipClonesCheckInOnly.push(tooltipClone)
+      })
+    }
+
+    if (loadingSpinner && calendarMonthContainer) {
+      const tooltipClone: Element = loadingSpinner.cloneNode(true) as Element
+      calendarMonthContainer.appendChild(tooltipClone)
+      tooltipClonesSpinner.push(tooltipClone)
+    }
+
+    if (calendarTooltipOverlappingDate && calendarOverlappingDate.length > 0) {
+      calendarOverlappingDate.forEach((element) => {
+        const tooltipClone: Element = calendarTooltipOverlappingDate.cloneNode(
+          true
+        ) as Element
+        element.appendChild(tooltipClone)
+        tooltipClonesOverlappingDates.push(tooltipClone)
+      })
+    }
+
+    return () => {
+      tooltipClonesCheckIn.forEach((clone) => clone.remove())
+      tooltipClonesCheckOut.forEach((clone) => clone.remove())
+      tooltipClonesSpinner.forEach((clone) => clone.remove())
+      tooltipClonesOverlappingDates.forEach((clone) => clone.remove())
+    }
+  }, [
+    calendarRange,
+    updateCalendarMonthNavigation,
+    overlappingDate,
+    updateCalendarDefaultMoth,
+  ])

package/src/core/components/calendar/hooks/useUpdateDisabledDates.tsx

@@ -0,0 +1,94 @@
+import { useMemo, useState } from 'react'
+import { addDays, format } from 'date-fns'
+import { DateRange } from 'react-day-picker'
+
+import { DisableCalendarDates } from '../CalendarTypes'
+
+type Props = {
+  disableCalendarDates?: DisableCalendarDates
+  calendarRange?: DateRange
+  updateCalendarMonthNavigation?: boolean
+  updateCalendarDefaultMoth?: number
+}
+
+export const useUpdateDisabledDates = ({
+  disableCalendarDates,
+  calendarRange,
+  updateCalendarMonthNavigation,
+  updateCalendarDefaultMoth,
+}: Props) => {
+  const [overlappingDate, setOverlappingDate] = useState<
+    DateRange[] | undefined
+  >(undefined)
+
+  const newDisableCalendarDates = useMemo(() => {
+    if (disableCalendarDates?.availableDates) {
+      const dateFormat = 'dd-MM-yyyy'
+
+      const { disabledDates } = disableCalendarDates
+
+      const { updatedDisabledDates, newOverlappingDates } = (
+        disabledDates || []
+      ).reduce(
+        (
+          acc: {
+            updatedDisabledDates: { to: Date; from: Date }[]
+            newOverlappingDates: { to: Date; from: Date }[]
+          },
+          dateRange
+        ) => {
+          const formattedFromDate = format(dateRange.from, dateFormat)
+          const formattedToDate = format(dateRange.to, dateFormat)
+
+          const hasTwoOverlappingDates =
+            disableCalendarDates.availableDates?.some(
+              (item) =>
+                format(item.lastCheckOut, dateFormat) === formattedFromDate &&
+                format(item.lastCheckOut, dateFormat) === formattedToDate
+            )
+
+          const hasOneOverlappingDate =
+            disableCalendarDates.availableDates?.some(
+              (item) =>
+                format(item.lastCheckOut, dateFormat) === formattedFromDate &&
+                format(item.lastCheckOut, dateFormat) !== formattedToDate
+            )
+
+          if (hasTwoOverlappingDates) {
+            acc.newOverlappingDates.push(dateRange)
+          } else if (hasOneOverlappingDate) {
+            acc.newOverlappingDates.push(dateRange)
+            acc.updatedDisabledDates.push({
+              ...dateRange,
+              from: addDays(dateRange.from, 1),
+            })
+          } else {
+            acc.updatedDisabledDates.push(dateRange)
+          }
+
+          return acc
+        },
+        { updatedDisabledDates: [], newOverlappingDates: [] }
+      )
+
+      if (newOverlappingDates.length) {
+        setOverlappingDate((prev = []) => [...prev, ...newOverlappingDates])
+      }
+
+      const newDisableCalendarDates = {
+        ...disableCalendarDates,
+        disabledDates: updatedDisabledDates,
+      }
+
+      return newDisableCalendarDates
+    }
+    return disableCalendarDates
+  }, [
+    disableCalendarDates,
+    calendarRange,
+    updateCalendarMonthNavigation,
+    updateCalendarDefaultMoth,
+  ])
+
+  return { newDisableCalendarDates, overlappingDate }
+}

package/src/core/components/calendar/utils/calendarSelectionRules.tsx

@@ -0,0 +1,163 @@
+import {
+  addDays,
+  startOfDay,
+  format,
+  isAfter,
+  isBefore,
+  endOfDay,
+} from 'date-fns'
+import { DateRange, Matcher } from 'react-day-picker'
+
+import { DisableCalendarDates, RangeContext } from '../CalendarTypes'
+
+type Props = {
+  range: DateRange | undefined
+  newDisableCalendarDates?: DisableCalendarDates
+  setCalendarRange: (range: DateRange | undefined) => void
+  setDisabledDates?: (arg: Matcher[]) => void
+  setCalendarHasError?: (arg: boolean) => void
+  calendarRange?: DateRange
+  overlappingDate?: DateRange[]
+  calendarHasError?: boolean
+  rangeContext?: RangeContext
+}
+
+export const calendarSelectionRules = ({
+  range,
+  newDisableCalendarDates,
+  setCalendarRange,
+  setDisabledDates,
+  calendarRange,
+  overlappingDate,
+  setCalendarHasError,
+  rangeContext,
+}: Props) => {
+  // Get and parse needed data
+  const dateFormat = 'dd-MM-yyyy'
+  const rangeFrom = range?.from ? format(range.from, dateFormat) : null
+  const rangeTo = range?.to ? format(range.to, dateFormat) : null
+  const calendarFrom = calendarRange?.from
+    ? format(calendarRange?.from, dateFormat)
+    : null
+  const calendarTo = calendarRange?.to
+    ? format(calendarRange?.to, dateFormat)
+    : null
+  const rangeContextFrom = rangeContext?.from
+    ? format(rangeContext.from, dateFormat)
+    : null
+
+  const overlappingDateFrom = overlappingDate?.length
+    ? overlappingDate.find((date) =>
+        date.from ? format(date.from, dateFormat) === rangeFrom : false
+      )
+    : null
+
+  const checkOutRange = newDisableCalendarDates?.availableDates?.length
+    ? newDisableCalendarDates.availableDates.find(
+        (checkInDate) =>
+          format(checkInDate.checkIn || 1, dateFormat) ===
+          format(range?.from || 1, dateFormat)
+      )
+    : null
+
+  // On check-in, disable future dates that are unavailable for checkout
+  disableFutureDates({
+    rangeFrom,
+    checkOutRange,
+    setDisabledDates,
+    dateFormat,
+    newDisableCalendarDates,
+  })
+
+  // Calendar selection rules
+  switch (true) {
+    case !!overlappingDateFrom:
+      // Clear the selection when overlapping dates are detected
+      return setCalendarRange(undefined)
+
+    case !!((!rangeTo && !rangeFrom && calendarFrom) || rangeTo === rangeFrom):
+      // Handle double-click on the same date
+      return setCalendarRange({ from: calendarRange?.from, to: undefined })
+
+    case range?.to &&
+      calendarRange?.to &&
+      isAfter(endOfDay(range.to), endOfDay(calendarRange.to)) &&
+      !(
+        range?.to &&
+        rangeContext?.to &&
+        isAfter(startOfDay(range.to), startOfDay(rangeContext.to))
+      ):
+      // Handle checkout selection greater than current checkout
+      return setCalendarRange({ from: range?.to, to: undefined })
+
+    case calendarFrom && rangeFrom && rangeFrom !== calendarFrom:
+      // Handle check-in selection prior to current check-in
+      return setCalendarRange({ from: range?.from, to: undefined })
+
+    case checkOutRange && range?.to && checkOutRange.lastCheckOut < range.to:
+      return setCalendarRange({ from: range?.to, to: undefined })
+
+    // Handle checkout selection between the range context and first passible check-in
+    case range?.to &&
+      rangeContext?.from &&
+      isBefore(startOfDay(range.to), startOfDay(rangeContext.from)):
+      return setCalendarRange({ from: range?.to, to: undefined })
+
+    case range?.from &&
+      rangeContext?.to &&
+      isAfter(startOfDay(range.from), startOfDay(rangeContext.to)):
+      return (
+        setCalendarRange(undefined),
+        setCalendarHasError && setCalendarHasError(true)
+      )
+    //
+
+    default:
+      // Apply the given range
+      return setCalendarRange(range)
+  }
+}
+
+/////////
+
+const disableFutureDates = ({
+  rangeFrom,
+  checkOutRange,
+  setDisabledDates,
+  dateFormat,
+  newDisableCalendarDates,
+}: {
+  rangeFrom: string | null
+  checkOutRange?:
+    | NonNullable<DisableCalendarDates['availableDates']>['0']
+    | null
+  setDisabledDates?: (arg: Matcher[]) => void
+  dateFormat: string
+  newDisableCalendarDates?: DisableCalendarDates
+}) => {
+  if (rangeFrom && checkOutRange && setDisabledDates) {
+    // Get and parse data
+    const checkIn = addDays(checkOutRange.checkIn, 1)
+    const firstCheckOut = addDays(checkOutRange.firstCheckOut, -1)
+    const noDatesRange =
+      format(checkIn, dateFormat) ===
+      format(checkOutRange.firstCheckOut, dateFormat)
+
+    // -------------------
+
+    setDisabledDates([
+      // Will disable all dates before the check-in date
+      // { before: findCheckOutRange?.checkIn },
+
+      ...(newDisableCalendarDates?.disabledDates || []),
+
+      {
+        from: noDatesRange ? undefined : checkIn,
+        to: noDatesRange ? undefined : firstCheckOut,
+      },
+
+      // Will disable all dates after the last possible check-out after a check-in has been selected
+      //{ after: checkOutRange?.lastCheckOut },
+    ])
+  }
+}

package/src/core/components/calendar/utils/checkForContinuousSelection.tsx

@@ -0,0 +1,50 @@
+import { DateRange } from 'react-day-picker'
+import { isAfter, isEqual, isBefore, endOfDay } from 'date-fns'
+
+import { RangeContext } from '../CalendarTypes'
+
+type Props = {
+  setCalendarHasError?: (arg: boolean) => void
+  rangeContext?: RangeContext
+  calendarRange?: DateRange
+  calendarHasError?: boolean
+}
+
+// Case: If the selected dates do not overlap with the rangeContext during continuous selection,
+//       set setCalendarHasError to true. This will display an error message and
+//       prevent the submission of the selected dates.
+
+export const checkForContinuousSelection = ({
+  setCalendarHasError,
+  rangeContext,
+  calendarRange,
+  calendarHasError,
+}: Props) => {
+  const calendarRangeFrom = calendarRange?.from || null
+  const calendarRangeTo = calendarRange?.to || null
+  const rangeContextFrom = rangeContext?.from || null
+  const rangeContextTo = rangeContext?.to || null
+
+  // Checking if rangeFrom is equal to or before rangeContextTo
+  const startIsEqualOrBeforeRangeContextEnd =
+    calendarRangeFrom && rangeContextTo
+      ? isBefore(endOfDay(calendarRangeFrom), endOfDay(rangeContextTo)) ||
+        isEqual(endOfDay(calendarRangeFrom), endOfDay(rangeContextTo))
+      : null
+
+  // Checking if rangeTo is equal to or after rangeContextFrom
+  const endIsEqualOrAfterRangeContextStart =
+    calendarRangeTo && rangeContextFrom && rangeContextTo
+      ? isAfter(endOfDay(calendarRangeTo), endOfDay(rangeContextFrom)) ||
+        isEqual(endOfDay(calendarRangeTo), endOfDay(rangeContextFrom))
+      : null
+
+  if (
+    (rangeContext &&
+      calendarRangeFrom &&
+      !startIsEqualOrBeforeRangeContextEnd) ||
+    (rangeContext && calendarRangeTo && !endIsEqualOrAfterRangeContextStart)
+  ) {
+    setCalendarHasError && !calendarHasError && setCalendarHasError(true)
+  }
+}

package/src/core/components/calendar/utils/disabledDatesByPage.tsx

@@ -0,0 +1,36 @@
+import { addDays } from 'date-fns'
+
+import { DisableCalendarDates } from '../CalendarTypes'
+
+export const disabledDatesByPage = ({
+  newDisableCalendarDates,
+  selectedPath,
+  today,
+}: {
+  newDisableCalendarDates?: DisableCalendarDates
+  selectedPath?: string
+  today: Date
+}) => {
+  const daysToOffsetCalendar =
+    newDisableCalendarDates?.disabledDatesByPage && selectedPath
+      ? [
+          newDisableCalendarDates?.disabledDatesByPage?.find(
+            (item) => selectedPath === item.page
+          ),
+        ]
+      : []
+
+  return daysToOffsetCalendar.length
+    ? [
+        {
+          from: addDays(
+            today,
+            daysToOffsetCalendar.length && daysToOffsetCalendar[0]?.offset
+              ? daysToOffsetCalendar[0]?.offset
+              : -2
+          ),
+          to: addDays(today, -100),
+        },
+      ]
+    : []
+}

package/src/core/components/calendar/utils/handleCalendarModifiers.tsx

@@ -0,0 +1,151 @@
+import { format, addDays, endOfDay, differenceInDays, isEqual } from 'date-fns'
+import { DateRange, Matcher } from 'react-day-picker'
+
+import { DisableCalendarDates, RangeContext } from '../CalendarTypes'
+
+type Props = {
+  newDisableCalendarDates?: DisableCalendarDates
+  calendarRange?: DateRange
+  disabledDatesByPage: {
+    from: Date
+    to: Date
+  }[]
+  disabledDates?: Matcher[]
+  overlappingDate?: DateRange[]
+  rangeContext?: RangeContext
+  findFirstPossibleRangeContextCheckIn?: NonNullable<
+    DisableCalendarDates['availableDates']
+  >['0']
+  findLastPossibleRangeContextCheckOut?: NonNullable<
+    DisableCalendarDates['availableDates']
+  >['0']
+  firstPossibleRangeContextCheckIn: Matcher[]
+  lastPossibleRangeContextCheckOut: Matcher[]
+  currentSelectionLastCheckoutDate?: NonNullable<
+    DisableCalendarDates['availableDates']
+  >['0']
+}
+
+export const handleCalendarModifiers = ({
+  newDisableCalendarDates,
+  calendarRange,
+  disabledDatesByPage,
+  disabledDates,
+  overlappingDate,
+  rangeContext,
+  firstPossibleRangeContextCheckIn,
+  lastPossibleRangeContextCheckOut,
+  findFirstPossibleRangeContextCheckIn,
+  findLastPossibleRangeContextCheckOut,
+  currentSelectionLastCheckoutDate,
+}: Props) => {
+  // Create range for range context middle selection and current overlapping selection
+  const rangeContextMiddleSelection =
+    rangeContext?.from && rangeContext?.to
+      ? Array.from(
+          { length: differenceInDays(rangeContext.to, rangeContext.from) - 1 },
+          (_, i) => ({
+            from: addDays(rangeContext.from, i + 1),
+            to: addDays(rangeContext.from, i + 1),
+          })
+        ).filter(
+          (date) =>
+            !(
+              (calendarRange?.from &&
+                isEqual(endOfDay(calendarRange.from), endOfDay(date.from))) ||
+              (calendarRange?.to &&
+                isEqual(endOfDay(calendarRange.to), endOfDay(date.from)))
+            )
+        )
+      : []
+
+  return {
+    booked: disabledDatesByPage.length
+      ? disabledDatesByPage
+      : disabledDates?.length
+      ? [
+          ...disabledDates,
+          ...firstPossibleRangeContextCheckIn,
+          ...lastPossibleRangeContextCheckOut,
+        ]
+      : newDisableCalendarDates?.disabledDates?.length
+      ? [
+          ...newDisableCalendarDates?.disabledDates,
+          ...firstPossibleRangeContextCheckIn,
+          ...lastPossibleRangeContextCheckOut,
+        ]
+      : [],
+
+    disabledAfterCheckIn: calendarRange?.from
+      ? [{ after: calendarRange.from }]
+      : [],
+
+    overlappingDate: [
+      ...(!calendarRange?.from && !!overlappingDate?.length && !rangeContext
+        ? overlappingDate.map((date) => ({ from: date.from }))
+        : []),
+    ],
+
+    noActiveSelectionStart:
+      rangeContext?.from &&
+      !(
+        calendarRange?.from &&
+        rangeContext?.from &&
+        isEqual(endOfDay(rangeContext.from), endOfDay(calendarRange.from))
+      )
+        ? rangeContext.from
+        : [],
+
+    noActiveSelectionMid: [
+      ...(rangeContextMiddleSelection.length
+        ? rangeContextMiddleSelection
+        : []),
+    ],
+
+    noActiveSelectionEnd:
+      rangeContext?.to &&
+      !(
+        calendarRange?.from &&
+        rangeContext?.to &&
+        isEqual(endOfDay(rangeContext.to), endOfDay(calendarRange.from))
+      )
+        ? rangeContext.to
+        : [],
+
+    checkoutOptionsMid: [
+      ...(calendarRange?.from &&
+      !calendarRange?.to &&
+      currentSelectionLastCheckoutDate?.lastCheckOut
+        ? [
+            {
+              after: calendarRange.from,
+              before: addDays(currentSelectionLastCheckoutDate.lastCheckOut, 1),
+            },
+          ]
+        : []),
+    ],
+
+    checkInOnly: [
+      ...(findFirstPossibleRangeContextCheckIn?.checkIn && rangeContext
+        ? [
+            {
+              from: findFirstPossibleRangeContextCheckIn.checkIn,
+              to: addDays(rangeContext.from, -1),
+            },
+          ]
+        : []),
+    ],
+
+    checkOutOnly: [
+      ...(findLastPossibleRangeContextCheckOut?.checkIn &&
+      findLastPossibleRangeContextCheckOut.lastCheckOut
+        ? [
+            {
+              from: addDays(findLastPossibleRangeContextCheckOut.checkIn, 1),
+              to: findLastPossibleRangeContextCheckOut.lastCheckOut,
+            },
+          ]
+        : []),
+    ],
+  }
+}

package/src/core/components/calendar/utils/handleRangeContextDisabledDates.tsx

@@ -0,0 +1,70 @@
+import { DateRange, Matcher } from 'react-day-picker'
+import { isEqual, format } from 'date-fns'
+
+import { DisableCalendarDates, RangeContext } from '../CalendarTypes'
+
+type Props = {
+  rangeContext?: RangeContext
+  availableDates?: DisableCalendarDates['availableDates']
+  calendarRange?: DateRange
+}
+
+export const handleRangeContextDisabledDates = ({
+  rangeContext,
+  availableDates,
+  calendarRange,
+}: Props) => {
+  let findFirstPossibleRangeContextCheckIn:
+    | NonNullable<DisableCalendarDates['availableDates']>['0']
+    | undefined
+  let findLastPossibleRangeContextCheckOut:
+    | NonNullable<DisableCalendarDates['availableDates']>['0']
+    | undefined
+
+  let firstPossibleRangeContextCheckIn: Matcher[] = []
+  let lastPossibleRangeContextCheckOut: Matcher[] = []
+
+  if (rangeContext && availableDates?.length) {
+    // Find the first possible check-in after the last date gap till the range context
+    findFirstPossibleRangeContextCheckIn = availableDates?.find(
+      (date) =>
+        date.checkIn < rangeContext.from &&
+        date.lastCheckOut >= rangeContext.from
+    )
+
+    if (findFirstPossibleRangeContextCheckIn?.checkIn) {
+      firstPossibleRangeContextCheckIn.push({
+        before: findFirstPossibleRangeContextCheckIn.checkIn,
+      })
+    }
+
+    // Find the last possible checkout before the first date gap till the range context
+    findLastPossibleRangeContextCheckOut = availableDates?.find((date) =>
+      isEqual(rangeContext.to, date.checkIn)
+    )
+
+    if (findLastPossibleRangeContextCheckOut?.checkIn) {
+      lastPossibleRangeContextCheckOut.push({
+        after: findLastPossibleRangeContextCheckOut.lastCheckOut,
+      })
+    }
+  }
+
+  // Get last possible check-out dates for current check-in
+  const currentSelectionLastCheckoutDate = availableDates?.find((date) => {
+    const calendarCheckIn = calendarRange?.from
+      ? format(calendarRange.from, 'dd.MM.yyyy')
+      : null
+    const itemCheckIn = format(date.checkIn, 'dd.MM.yyyy')
+
+    return calendarCheckIn ? itemCheckIn === calendarCheckIn : false
+  })
+
+  return {
+    findFirstPossibleRangeContextCheckIn,
+    findLastPossibleRangeContextCheckOut,
+    firstPossibleRangeContextCheckIn,
+    lastPossibleRangeContextCheckOut,
+    currentSelectionLastCheckoutDate,
+  }
+}