@ticketboothapp/booking 1.2.122 → 1.2.124

package/src/components/booking/useChangeBookingAvailabilities.ts

@@ -0,0 +1,692 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import type { Dispatch, SetStateAction } from 'react';
+import { addWeeks, isAfter, isBefore, parseISO } from 'date-fns';
+import { formatInTimeZone, fromZonedTime } from 'date-fns-tz';
+import {
+  getAvailabilities,
+  type Availability,
+  type GetAvailabilitiesOptions,
+  type PrecomputedPricesByCategory,
+  type PricingConfig,
+  type ProductOption,
+} from '../../lib/booking-api';
+import {
+  EARLIEST_AVAILABILITY_DATE,
+  INITIAL_FETCH_WEEKS,
+} from '../../lib/booking-constants';
+import { getSundayOfWeek } from '../../lib/booking/sunday-week';
+import { shouldReplacePricingConfig } from '../../lib/booking/pricing-config';
+import {
+  buildAvailabilitiesCacheKey,
+  useAvailabilitiesCache,
+} from '../../contexts/AvailabilitiesCacheContext';
+import {
+  deriveDefaultQuantitiesFromAvailabilities,
+  getAvailabilityCacheKey,
+  parseAvailabilityDateTime,
+} from './change-booking-flow-helpers';
+
+type DateRange = { start: Date; end: Date };
+
+type UseChangeBookingAvailabilitiesParams = {
+  productId: string;
+  productType?: 'STANDARD' | 'PRIVATE_SHUTTLE';
+  activeOptions: ProductOption[];
+  activeOptionIdsKey: string;
+  initialDateTime?: string | null;
+  companyTimezone: string;
+  isPartialLaunch: boolean;
+  appliedPromoCode: string | null;
+  pricingProfileIdForAvailabilities: string | null;
+  cancellationPolicyProfileIdForAvailabilities: string | null;
+  includeBookingDayResponseMode?: boolean;
+  filterCalendarAvailabilities?: (availabilities: Availability[]) => Availability[];
+  resetKey?: string | null;
+  setQuantities: Dispatch<SetStateAction<Record<string, number>>>;
+  setError: Dispatch<SetStateAction<string>>;
+};
+
+type UseChangeBookingAvailabilitiesResult = {
+  availabilities: Availability[];
+  calendarAvailabilities: Availability[];
+  loadingAvailabilities: boolean;
+  isFetchingMoreAvailabilities: boolean;
+  pricingConfig: PricingConfig | null;
+  precomputedPricesByOption: Record<string, PrecomputedPricesByCategory> | null;
+  selectedDate: string;
+  setSelectedDate: Dispatch<SetStateAction<string>>;
+  availabilitiesByDate: Record<string, Availability[]>;
+  dates: string[];
+  earliestAvailabilityDate: Date;
+  handleVisibleRangeChange: (start: Date, end: Date) => void;
+  reloadAvailabilitiesAfterReserveConflict: () => Promise<Availability[]>;
+  clearFetchedAvailabilityRanges: () => void;
+  resetAvailabilityState: () => void;
+};
+
+function needsFetch(fetchedRanges: DateRange[], start: Date, end: Date): boolean {
+  if (fetchedRanges.length === 0) return true;
+  return !fetchedRanges.some((range) => {
+    const rangeStart = range.start.getTime();
+    const rangeEnd = range.end.getTime();
+    const reqStart = start.getTime();
+    const reqEnd = end.getTime();
+    return rangeStart <= reqStart && rangeEnd >= reqEnd;
+  });
+}
+
+function mergeFetchedRanges(ranges: DateRange[]): DateRange[] {
+  const sorted = [...ranges].sort((a, b) => a.start.getTime() - b.start.getTime());
+  const merged: DateRange[] = [];
+  for (const range of sorted) {
+    const prev = merged[merged.length - 1];
+    if (!prev || prev.end < range.start) {
+      merged.push({ start: range.start, end: range.end });
+    } else {
+      prev.end = range.end > prev.end ? range.end : prev.end;
+    }
+  }
+  return merged;
+}
+
+function getSeasonBounds(companyTimezone: string): DateRange {
+  return {
+    start: fromZonedTime(new Date(2026, 5, 1, 0, 0, 0, 0), companyTimezone),
+    end: fromZonedTime(new Date(2026, 9, 12, 23, 59, 59, 999), companyTimezone),
+  };
+}
+
+function getStartOfCurrentDay(companyTimezone: string): Date {
+  const todayStr = formatInTimeZone(new Date(), companyTimezone, 'yyyy-MM-dd');
+  return fromZonedTime(parseISO(`${todayStr}T00:00:00.000`), companyTimezone);
+}
+
+function clampVisibleRange(
+  visibleRange: DateRange,
+  selectedDateKey: string,
+  companyTimezone: string,
+): DateRange {
+  const season = getSeasonBounds(companyTimezone);
+  const startOfCurrentDay = getStartOfCurrentDay(companyTimezone);
+  const minimumStart = isAfter(startOfCurrentDay, season.start) ? startOfCurrentDay : season.start;
+  const start = isBefore(visibleRange.start, minimumStart) ? minimumStart : visibleRange.start;
+  let end = isAfter(visibleRange.end, season.end) ? season.end : visibleRange.end;
+  if (isBefore(end, start)) {
+    end = start;
+  }
+
+  if (selectedDateKey) {
+    try {
+      const selectedDateObj = parseISO(selectedDateKey);
+      if (isAfter(selectedDateObj, end)) {
+        end = selectedDateObj;
+      }
+    } catch {
+      /* ignore */
+    }
+  }
+
+  return { start, end };
+}
+
+function formatAvailabilityRequestRange(
+  range: DateRange,
+  isPrivateShuttle: boolean,
+  companyTimezone: string,
+): { startDateStr: string; endDateStr: string } {
+  if (isPrivateShuttle) {
+    return {
+      startDateStr: formatInTimeZone(range.start, companyTimezone, 'yyyy-MM-dd'),
+      endDateStr: formatInTimeZone(range.end, companyTimezone, 'yyyy-MM-dd'),
+    };
+  }
+
+  const startDateInTz = formatInTimeZone(range.start, companyTimezone, 'yyyy-MM-dd');
+  const endDateInTz = formatInTimeZone(range.end, companyTimezone, 'yyyy-MM-dd');
+  const startMoment = fromZonedTime(parseISO(`${startDateInTz}T00:00:00.000`), companyTimezone);
+  const endMoment = fromZonedTime(parseISO(`${endDateInTz}T23:59:59.999`), companyTimezone);
+  return {
+    startDateStr: formatInTimeZone(startMoment, 'UTC', "yyyy-MM-dd'T'HH:mm:ss.SSS'Z'"),
+    endDateStr: formatInTimeZone(endMoment, 'UTC', "yyyy-MM-dd'T'HH:mm:ss.SSS'Z'"),
+  };
+}
+
+function mergePrecomputedPricesByOption(
+  prev: Record<string, PrecomputedPricesByCategory> | null,
+  results: Array<{ optionId: string; precomputedPrices?: PrecomputedPricesByCategory }>,
+): Record<string, PrecomputedPricesByCategory> | null {
+  const next = { ...(prev || {}) };
+  results.forEach((result) => {
+    if (result.precomputedPrices && Object.keys(result.precomputedPrices).length > 0) {
+      next[result.optionId] = result.precomputedPrices;
+    }
+  });
+  return Object.keys(next).length > 0 ? next : prev;
+}
+
+export function useChangeBookingAvailabilities({
+  productId,
+  productType,
+  activeOptions,
+  activeOptionIdsKey,
+  initialDateTime,
+  companyTimezone,
+  isPartialLaunch,
+  appliedPromoCode,
+  pricingProfileIdForAvailabilities,
+  cancellationPolicyProfileIdForAvailabilities,
+  includeBookingDayResponseMode = false,
+  filterCalendarAvailabilities,
+  resetKey,
+  setQuantities,
+  setError,
+}: UseChangeBookingAvailabilitiesParams): UseChangeBookingAvailabilitiesResult {
+  const availabilitiesCache = useAvailabilitiesCache();
+  const [availabilities, setAvailabilities] = useState<Availability[]>([]);
+  const [loadingAvailabilities, setLoadingAvailabilities] = useState(true);
+  const [isFetchingMoreAvailabilities, setIsFetchingMoreAvailabilities] = useState(false);
+  const [pricingConfig, setPricingConfig] = useState<PricingConfig | null>(null);
+  const [precomputedPricesByOption, setPrecomputedPricesByOption] =
+    useState<Record<string, PrecomputedPricesByCategory> | null>(null);
+  const [visibleRange, setVisibleRange] = useState<DateRange | null>(null);
+  const [selectedDate, setSelectedDate] = useState<string>(() => {
+    if (!initialDateTime?.trim()) return '';
+    try {
+      const target = parseAvailabilityDateTime(initialDateTime.trim());
+      return formatInTimeZone(target, companyTimezone, 'yyyy-MM-dd');
+    } catch {
+      return '';
+    }
+  });
+
+  const activeOptionsRef = useRef(activeOptions);
+  const fetchingRef = useRef(false);
+  const hasLoadedAvailabilitiesRef = useRef(false);
+  const inFlightRangeRef = useRef<DateRange | null>(null);
+  const fetchedRangesRef = useRef<DateRange[]>([]);
+  const pendingRangeRef = useRef<DateRange | null>(null);
+  const lastVisibleRangeRef = useRef<DateRange | null>(null);
+  const earliestAvailabilityDateRef = useRef<Date | null>(null);
+  const previousResetKeyRef = useRef(resetKey);
+
+  useEffect(() => {
+    activeOptionsRef.current = activeOptions;
+  }, [activeOptions]);
+
+  const applyPricingConfig = useCallback((next?: PricingConfig | null) => {
+    setPricingConfig((prev) => (shouldReplacePricingConfig(prev, next) ? next ?? null : prev));
+  }, []);
+
+  const clearFetchedAvailabilityRanges = useCallback(() => {
+    fetchedRangesRef.current = [];
+  }, []);
+
+  const resetAvailabilityState = useCallback(() => {
+    setAvailabilities([]);
+    setPrecomputedPricesByOption(null);
+    setPricingConfig(null);
+    setIsFetchingMoreAvailabilities(false);
+    fetchingRef.current = false;
+    hasLoadedAvailabilitiesRef.current = false;
+    inFlightRangeRef.current = null;
+    fetchedRangesRef.current = [];
+    pendingRangeRef.current = null;
+    earliestAvailabilityDateRef.current = null;
+  }, []);
+
+  useEffect(() => {
+    if (previousResetKeyRef.current === resetKey) return;
+    previousResetKeyRef.current = resetKey;
+    resetAvailabilityState();
+  }, [resetAvailabilityState, resetKey]);
+
+  const selectedDateRangeExtensionKey = useMemo(() => {
+    if (!visibleRange || !selectedDate) return '';
+    try {
+      return isAfter(parseISO(selectedDate), visibleRange.end) ? selectedDate : '';
+    } catch {
+      return '';
+    }
+  }, [selectedDate, visibleRange]);
+
+  const isPrivateShuttle = productType === 'PRIVATE_SHUTTLE';
+
+  const buildCacheKey = useCallback(() => {
+    return availabilitiesCache
+      ? buildAvailabilitiesCacheKey(
+          productId,
+          activeOptionIdsKey,
+          appliedPromoCode,
+          pricingProfileIdForAvailabilities,
+          cancellationPolicyProfileIdForAvailabilities,
+        )
+      : null;
+  }, [
+    activeOptionIdsKey,
+    appliedPromoCode,
+    availabilitiesCache,
+    cancellationPolicyProfileIdForAvailabilities,
+    pricingProfileIdForAvailabilities,
+    productId,
+  ]);
+
+  const fetchAvailabilityResults = useCallback(
+    async (range: DateRange) => {
+      const { startDateStr, endDateStr } = formatAvailabilityRequestRange(
+        range,
+        isPrivateShuttle,
+        companyTimezone,
+      );
+      const options = activeOptionsRef.current;
+      const availabilityPromises = options.map(async (option) => {
+        const requestOptions: GetAvailabilitiesOptions = {
+          ...(includeBookingDayResponseMode && !isPrivateShuttle
+            ? { responseMode: 'booking-day' as const }
+            : {}),
+          promoCode: appliedPromoCode || undefined,
+          ...(pricingProfileIdForAvailabilities
+            ? { pricingProfileId: pricingProfileIdForAvailabilities }
+            : {}),
+          ...(cancellationPolicyProfileIdForAvailabilities
+            ? { cancellationPolicyProfileId: cancellationPolicyProfileIdForAvailabilities }
+            : {}),
+        };
+        const result = await getAvailabilities(
+          option.optionId,
+          startDateStr,
+          endDateStr,
+          requestOptions,
+        );
+        applyPricingConfig(result.pricingConfig);
+        return {
+          optionId: option.optionId,
+          availabilities: result.availabilities.map((avail) => ({
+            ...avail,
+            productOptionId: option.optionId,
+          })),
+          precomputedPrices: result.precomputedPrices,
+          pricingConfig: result.pricingConfig,
+        };
+      });
+
+      return Promise.all(availabilityPromises);
+    },
+    [
+      appliedPromoCode,
+      applyPricingConfig,
+      cancellationPolicyProfileIdForAvailabilities,
+      companyTimezone,
+      includeBookingDayResponseMode,
+      isPrivateShuttle,
+      pricingProfileIdForAvailabilities,
+    ],
+  );
+
+  const mergeAvailabilitiesIntoState = useCallback((incoming: Availability[]): Availability[] => {
+    let mergedOut: Availability[] = [];
+    setAvailabilities((prev) => {
+      const existingMap = new Map(prev.map((avail) => [getAvailabilityCacheKey(avail), avail]));
+      incoming.forEach((avail) => {
+        existingMap.set(getAvailabilityCacheKey(avail), avail);
+      });
+      mergedOut = Array.from(existingMap.values());
+      return mergedOut;
+    });
+    return mergedOut;
+  }, []);
+
+  const mergeResultsIntoCache = useCallback(
+    (
+      cacheKey: string | null,
+      fetchedRanges: DateRange[],
+      fetchedAvailabilities: Availability[],
+      results: Array<{
+        optionId: string;
+        precomputedPrices?: PrecomputedPricesByCategory;
+        pricingConfig?: PricingConfig;
+      }>,
+    ) => {
+      if (!cacheKey || !availabilitiesCache) return;
+      const existingCache = availabilitiesCache.get(cacheKey);
+      const existingAvailabilities = existingCache?.availabilities ?? [];
+      const mergedAvailabilitiesMap = new Map(
+        existingAvailabilities.map((avail) => [getAvailabilityCacheKey(avail), avail]),
+      );
+      fetchedAvailabilities.forEach((avail) => {
+        mergedAvailabilitiesMap.set(getAvailabilityCacheKey(avail), avail);
+      });
+      const mergedPrecomputed = { ...(existingCache?.precomputedPricesByOption ?? {}) };
+      results.forEach((result) => {
+        if (result.precomputedPrices && Object.keys(result.precomputedPrices).length > 0) {
+          mergedPrecomputed[result.optionId] = result.precomputedPrices;
+        }
+      });
+      const firstPricingConfig =
+        (results[0] as { pricingConfig?: PricingConfig } | undefined)?.pricingConfig ??
+        existingCache?.pricingConfig ??
+        null;
+      availabilitiesCache.merge(cacheKey, {
+        fetchedRanges,
+        availabilities: Array.from(mergedAvailabilitiesMap.values()),
+        pricingConfig: firstPricingConfig,
+        precomputedPricesByOption:
+          Object.keys(mergedPrecomputed).length > 0 ? mergedPrecomputed : null,
+      });
+    },
+    [availabilitiesCache],
+  );
+
+  const reloadAvailabilitiesAfterReserveConflict = useCallback(async (): Promise<Availability[]> => {
+    if (isPartialLaunch || !visibleRange || activeOptionsRef.current.length === 0) {
+      return [];
+    }
+
+    const clampedRange = clampVisibleRange(visibleRange, selectedDate, companyTimezone);
+    const results = await fetchAvailabilityResults(clampedRange);
+    const allFetchedAvailabilities = results.flatMap((result) => result.availabilities);
+
+    setPrecomputedPricesByOption((prev) => mergePrecomputedPricesByOption(prev, results));
+    const mergedOut = mergeAvailabilitiesIntoState(allFetchedAvailabilities);
+
+    fetchedRangesRef.current = mergeFetchedRanges([
+      ...fetchedRangesRef.current,
+      { start: new Date(clampedRange.start), end: new Date(clampedRange.end) },
+    ]);
+
+    mergeResultsIntoCache(
+      buildCacheKey(),
+      fetchedRangesRef.current,
+      allFetchedAvailabilities,
+      results,
+    );
+
+    return mergedOut;
+  }, [
+    buildCacheKey,
+    companyTimezone,
+    fetchAvailabilityResults,
+    isPartialLaunch,
+    mergeAvailabilitiesIntoState,
+    mergeResultsIntoCache,
+    selectedDate,
+    visibleRange,
+  ]);
+
+  useEffect(() => {
+    if (visibleRange) return;
+
+    const season = getSeasonBounds(companyTimezone);
+    const startOfCurrentDay = getStartOfCurrentDay(companyTimezone);
+    const minimumStart = isAfter(startOfCurrentDay, season.start) ? startOfCurrentDay : season.start;
+    if (initialDateTime?.trim()) {
+      try {
+        const target = parseAvailabilityDateTime(initialDateTime.trim());
+        const dateStr = formatInTimeZone(target, companyTimezone, 'yyyy-MM-dd');
+        const weekStartStr = getSundayOfWeek(dateStr, companyTimezone);
+        let rangeStart = fromZonedTime(parseISO(`${weekStartStr}T12:00:00`), companyTimezone);
+        if (isBefore(rangeStart, minimumStart)) {
+          rangeStart = minimumStart;
+        }
+        let rangeEnd = addWeeks(rangeStart, INITIAL_FETCH_WEEKS);
+        if (isAfter(rangeEnd, season.end)) {
+          rangeEnd = season.end;
+        }
+        if (!isBefore(rangeEnd, rangeStart)) {
+          setVisibleRange({ start: rangeStart, end: rangeEnd });
+          return;
+        }
+      } catch {
+        /* fall through to default */
+      }
+    }
+
+    let initialEnd = addWeeks(minimumStart, INITIAL_FETCH_WEEKS);
+    if (isAfter(initialEnd, season.end)) {
+      initialEnd = season.end;
+    }
+    setVisibleRange({ start: minimumStart, end: initialEnd });
+  }, [companyTimezone, initialDateTime, visibleRange]);
+
+  useEffect(() => {
+    if (isPartialLaunch) {
+      setLoadingAvailabilities(false);
+      return;
+    }
+    if (activeOptionsRef.current.length === 0) {
+      setError('No active product options available');
+      setLoadingAvailabilities(false);
+      return;
+    }
+    if (!visibleRange) return;
+
+    async function fetchAvailabilitiesForVisibleRange() {
+      if (!visibleRange) return;
+      if (fetchingRef.current) {
+        const inFlight = inFlightRangeRef.current;
+        if (
+          inFlight &&
+          inFlight.start.getTime() === visibleRange.start.getTime() &&
+          inFlight.end.getTime() === visibleRange.end.getTime()
+        ) {
+          return;
+        }
+        pendingRangeRef.current = { start: visibleRange.start, end: visibleRange.end };
+        return;
+      }
+
+      const clampedRange = clampVisibleRange(
+        visibleRange,
+        selectedDateRangeExtensionKey,
+        companyTimezone,
+      );
+      const cacheKey = buildCacheKey();
+      const cached = cacheKey ? availabilitiesCache?.get(cacheKey) : undefined;
+
+      if (cached && cached.availabilities.length > 0) {
+        const cachedInitialQuantities = deriveDefaultQuantitiesFromAvailabilities(cached.availabilities);
+        if (cachedInitialQuantities) {
+          setQuantities((prev) => (Object.keys(prev).length > 0 ? prev : cachedInitialQuantities));
+        }
+        const cacheCoversRange = cached.fetchedRanges.some(
+          (range) =>
+            range.start.getTime() <= clampedRange.start.getTime() &&
+            range.end.getTime() >= clampedRange.end.getTime(),
+        );
+        const isStale = availabilitiesCache?.isStale(cached) ?? false;
+        setAvailabilities(cached.availabilities);
+        if (cached.availabilities.length > 0) {
+          hasLoadedAvailabilitiesRef.current = true;
+        }
+        if (cached.pricingConfig) {
+          setPricingConfig(cached.pricingConfig);
+        }
+        if (
+          cached.precomputedPricesByOption &&
+          Object.keys(cached.precomputedPricesByOption).length > 0
+        ) {
+          setPrecomputedPricesByOption(cached.precomputedPricesByOption);
+        }
+        setLoadingAvailabilities(false);
+        if (cacheCoversRange) {
+          setIsFetchingMoreAvailabilities(false);
+          if (!isStale) {
+            fetchedRangesRef.current = [...cached.fetchedRanges];
+            fetchingRef.current = false;
+            return;
+          }
+        }
+        fetchedRangesRef.current = [...cached.fetchedRanges];
+      }
+
+      if (!needsFetch(fetchedRangesRef.current, clampedRange.start, clampedRange.end)) {
+        setLoadingAvailabilities(false);
+        setIsFetchingMoreAvailabilities(false);
+        fetchingRef.current = false;
+        return;
+      }
+
+      const hasPartialCache = cached && cached.availabilities.length > 0;
+      const shouldUsePrimaryLoader = !hasPartialCache && !hasLoadedAvailabilitiesRef.current;
+      fetchingRef.current = true;
+      inFlightRangeRef.current = {
+        start: new Date(clampedRange.start),
+        end: new Date(clampedRange.end),
+      };
+      if (shouldUsePrimaryLoader) setLoadingAvailabilities(true);
+      else setIsFetchingMoreAvailabilities(true);
+
+      try {
+        const results = await fetchAvailabilityResults(clampedRange);
+        const allFetchedAvailabilities = results.flatMap((result) => result.availabilities);
+        if (allFetchedAvailabilities.length > 0) {
+          hasLoadedAvailabilitiesRef.current = true;
+        }
+
+        setPrecomputedPricesByOption((prev) => mergePrecomputedPricesByOption(prev, results));
+        mergeAvailabilitiesIntoState(allFetchedAvailabilities);
+
+        fetchedRangesRef.current = mergeFetchedRanges([
+          ...fetchedRangesRef.current,
+          { start: new Date(clampedRange.start), end: new Date(clampedRange.end) },
+        ]);
+
+        mergeResultsIntoCache(
+          cacheKey,
+          fetchedRangesRef.current,
+          allFetchedAvailabilities,
+          results,
+        );
+
+        const fetchedInitialQuantities =
+          deriveDefaultQuantitiesFromAvailabilities(allFetchedAvailabilities);
+        if (fetchedInitialQuantities) {
+          setQuantities((prev) => (Object.keys(prev).length > 0 ? prev : fetchedInitialQuantities));
+        }
+      } catch (err) {
+        setError(err instanceof Error ? err.message : 'Failed to load availabilities');
+        console.error('Error fetching availabilities:', err);
+      } finally {
+        setLoadingAvailabilities(false);
+        setIsFetchingMoreAvailabilities(false);
+        fetchingRef.current = false;
+        inFlightRangeRef.current = null;
+        const pending = pendingRangeRef.current;
+        if (pending) {
+          pendingRangeRef.current = null;
+          setVisibleRange({ start: pending.start, end: pending.end });
+        }
+      }
+    }
+
+    fetchAvailabilitiesForVisibleRange();
+  }, [
+    activeOptionIdsKey,
+    appliedPromoCode,
+    availabilitiesCache,
+    buildCacheKey,
+    cancellationPolicyProfileIdForAvailabilities,
+    companyTimezone,
+    fetchAvailabilityResults,
+    isPartialLaunch,
+    mergeAvailabilitiesIntoState,
+    mergeResultsIntoCache,
+    pricingProfileIdForAvailabilities,
+    selectedDateRangeExtensionKey,
+    setError,
+    setQuantities,
+    visibleRange,
+  ]);
+
+  useEffect(() => {
+    fetchedRangesRef.current = [];
+  }, [
+    appliedPromoCode,
+    pricingProfileIdForAvailabilities,
+    cancellationPolicyProfileIdForAvailabilities,
+  ]);
+
+  const handleVisibleRangeChange = useCallback((start: Date, end: Date) => {
+    const lastRange = lastVisibleRangeRef.current;
+    const rangeChanged =
+      !lastRange ||
+      Math.abs(lastRange.start.getTime() - start.getTime()) > 24 * 60 * 60 * 1000 ||
+      Math.abs(lastRange.end.getTime() - end.getTime()) > 24 * 60 * 60 * 1000;
+
+    if (rangeChanged) {
+      lastVisibleRangeRef.current = { start, end };
+      setVisibleRange({ start, end });
+    }
+  }, []);
+
+  const calendarAvailabilities = useMemo(
+    () => {
+      const todayStr = formatInTimeZone(new Date(), companyTimezone, 'yyyy-MM-dd');
+      const currentOrFutureAvailabilities = availabilities.filter((avail) => {
+        const dateTime = parseAvailabilityDateTime(avail.dateTime);
+        return formatInTimeZone(dateTime, companyTimezone, 'yyyy-MM-dd') >= todayStr;
+      });
+      return filterCalendarAvailabilities
+        ? filterCalendarAvailabilities(currentOrFutureAvailabilities)
+        : currentOrFutureAvailabilities;
+    },
+    [availabilities, companyTimezone, filterCalendarAvailabilities],
+  );
+
+  const availabilitiesByDate = useMemo(() => {
+    const grouped = calendarAvailabilities.reduce((acc, avail) => {
+      const dateTime = parseAvailabilityDateTime(avail.dateTime);
+      const dateInCompanyTz = formatInTimeZone(dateTime, companyTimezone, 'yyyy-MM-dd');
+      if (!acc[dateInCompanyTz]) acc[dateInCompanyTz] = [];
+      acc[dateInCompanyTz].push(avail);
+      return acc;
+    }, {} as Record<string, Availability[]>);
+
+    const sorted: Record<string, Availability[]> = {};
+    Object.keys(grouped).forEach((date) => {
+      sorted[date] = [...grouped[date]].sort((a, b) => {
+        const timeA = parseAvailabilityDateTime(a.dateTime).getTime();
+        const timeB = parseAvailabilityDateTime(b.dateTime).getTime();
+        return timeA - timeB;
+      });
+    });
+
+    return sorted;
+  }, [calendarAvailabilities, companyTimezone]);
+
+  const dates = useMemo(() => Object.keys(availabilitiesByDate).sort(), [availabilitiesByDate]);
+
+  const earliestAvailabilityDate = useMemo(() => {
+    if (dates.length === 0) {
+      return earliestAvailabilityDateRef.current || EARLIEST_AVAILABILITY_DATE;
+    }
+    const firstDate = dates[0];
+    const firstAvail = availabilitiesByDate[firstDate]?.[0];
+    const newEarliest = firstAvail
+      ? parseISO(firstAvail.dateTime)
+      : fromZonedTime(parseISO(`${firstDate}T12:00:00`), companyTimezone);
+
+    if (!earliestAvailabilityDateRef.current || newEarliest < earliestAvailabilityDateRef.current) {
+      earliestAvailabilityDateRef.current = newEarliest;
+    }
+
+    return earliestAvailabilityDateRef.current ?? newEarliest;
+  }, [availabilitiesByDate, companyTimezone, dates]);
+
+  return {
+    availabilities,
+    calendarAvailabilities,
+    loadingAvailabilities,
+    isFetchingMoreAvailabilities,
+    pricingConfig,
+    precomputedPricesByOption,
+    selectedDate,
+    setSelectedDate,
+    availabilitiesByDate,
+    dates,
+    earliestAvailabilityDate,
+    handleVisibleRangeChange,
+    reloadAvailabilitiesAfterReserveConflict,
+    clearFetchedAvailabilityRanges,
+    resetAvailabilityState,
+  };
+}