@ticketboothapp/booking 1.2.123 → 1.2.125

package/src/components/booking/use-private-shuttle-availability.ts

@@ -0,0 +1,602 @@
+import {
+  useCallback,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+  type Dispatch,
+  type SetStateAction,
+} from 'react';
+import { addWeeks, isAfter, isBefore, parseISO } from 'date-fns';
+import { formatInTimeZone, fromZonedTime } from 'date-fns-tz';
+
+import {
+  getAvailabilities,
+  type Availability,
+  type PrecomputedPricesByCategory,
+  type PricingConfig,
+  type Product,
+} from '../../lib/booking-api';
+import { isDateAfterPublicBookingCutoff } from '../../lib/booking/booking-cutoffs';
+import { shouldReplacePricingConfig } from '../../lib/booking/pricing-config';
+import { useAvailabilitiesCache, buildAvailabilitiesCacheKey } from '../../contexts/AvailabilitiesCacheContext';
+import {
+  EARLIEST_AVAILABILITY_DATE,
+  INITIAL_FETCH_WEEKS,
+  VISIBLE_RANGE_BUFFER_WEEKS,
+} from '../../lib/booking-constants';
+import {
+  getPrivateShuttleAvailabilityCacheKey,
+  getPrivateShuttleAvailabilityOptionId,
+  parseAvailabilityDateTime,
+  privateShuttleAvailabilityDateInZone,
+  privateShuttleStartTimeAllowed,
+} from './private-shuttle-availability';
+import { getStartOfCurrentDay } from './standard-booking-availability';
+
+interface UsePrivateShuttleAvailabilityParams {
+  product: Product;
+  activeOptions: Product['options'];
+  activeOptionIdsKey: string;
+  selectedDate: string;
+  activePromoCode: string | null;
+  pricingProfileIdForAvailabilities: string | null;
+  cancellationPolicyProfileIdForAvailabilities: string | null;
+  companyTimezone: string;
+  isAdmin: boolean;
+  bookingCutoffNow: Date;
+  bookingCutoffMinutes?: number | null;
+  passengerCount: number;
+  setPassengerCount: Dispatch<SetStateAction<number>>;
+  setError: Dispatch<SetStateAction<string>>;
+}
+
+type DateRange = { start: Date; end: Date };
+
+function clampAvailabilityRange(
+  range: DateRange,
+  selectedDate: string,
+  companyTimezone: string,
+): DateRange {
+  const startOfEarliestDay = fromZonedTime(new Date(2026, 5, 1, 0, 0, 0, 0), companyTimezone);
+  const endOfLatestDay = fromZonedTime(new Date(2026, 9, 12, 23, 59, 59, 999), companyTimezone);
+  const startOfCurrentDay = getStartOfCurrentDay(companyTimezone);
+  const minimumStart = isAfter(startOfCurrentDay, startOfEarliestDay) ? startOfCurrentDay : startOfEarliestDay;
+  const clampedStart = isBefore(range.start, minimumStart) ? minimumStart : range.start;
+  let clampedEnd = isAfter(range.end, endOfLatestDay) ? endOfLatestDay : range.end;
+  if (isBefore(clampedEnd, clampedStart)) {
+    clampedEnd = clampedStart;
+  }
+
+  if (selectedDate) {
+    try {
+      const selectedDateObj = parseISO(selectedDate);
+      if (isAfter(selectedDateObj, clampedEnd)) clampedEnd = selectedDateObj;
+    } catch {
+      // Ignore parse errors.
+    }
+  }
+
+  return { start: clampedStart, end: clampedEnd };
+}
+
+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) {
+    if (merged.length === 0 || merged[merged.length - 1].end < range.start) {
+      merged.push({ start: range.start, end: range.end });
+    } else {
+      merged[merged.length - 1].end =
+        range.end > merged[merged.length - 1].end ? range.end : merged[merged.length - 1].end;
+    }
+  }
+  return merged;
+}
+
+function mergePrivateShuttleAvailabilities(
+  existing: Availability[],
+  incoming: Availability[],
+): Availability[] {
+  if (existing.length === 0) return incoming;
+  const existingMap = new Map(
+    existing.map((availability) => [
+      getPrivateShuttleAvailabilityCacheKey(availability),
+      availability,
+    ]),
+  );
+  incoming.forEach((availability) => {
+    existingMap.set(getPrivateShuttleAvailabilityCacheKey(availability), availability);
+  });
+  return Array.from(existingMap.values());
+}
+
+export function usePrivateShuttleAvailability({
+  product,
+  activeOptions,
+  activeOptionIdsKey,
+  selectedDate,
+  activePromoCode,
+  pricingProfileIdForAvailabilities,
+  cancellationPolicyProfileIdForAvailabilities,
+  companyTimezone,
+  isAdmin,
+  bookingCutoffNow,
+  bookingCutoffMinutes,
+  passengerCount,
+  setPassengerCount,
+  setError,
+}: UsePrivateShuttleAvailabilityParams) {
+  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 [precomputedPrices, setPrecomputedPrices] = useState<PrecomputedPricesByCategory | null>(null);
+  const [resourcePriceByCurrency, setResourcePriceByCurrency] = useState<Record<string, number> | null>(null);
+  const [resourcePriceByOption, setResourcePriceByOption] =
+    useState<Record<string, Record<string, number>> | null>(null);
+  const [visibleRange, setVisibleRange] = useState<DateRange | null>(null);
+  const fetchingRef = useRef(false);
+  const fetchedRangesRef = useRef<DateRange[]>([]);
+  const pricingConfigSetRef = useRef(false);
+  const lastVisibleRangeRef = useRef<DateRange | null>(null);
+
+  const applyPricingConfig = useCallback((next?: PricingConfig | null) => {
+    setPricingConfig((prev) => {
+      if (!shouldReplacePricingConfig(prev, next)) return prev;
+      pricingConfigSetRef.current = true;
+      return next ?? null;
+    });
+  }, []);
+
+  const applyCachedPricingConfig = useCallback((next: PricingConfig) => {
+    setPricingConfig(next);
+    pricingConfigSetRef.current = true;
+  }, []);
+
+  const getCacheKey = useCallback(
+    () =>
+      availabilitiesCache
+        ? buildAvailabilitiesCacheKey(
+            product.productId,
+            activeOptionIdsKey,
+            activePromoCode,
+            pricingProfileIdForAvailabilities,
+          )
+        : null,
+    [
+      activeOptionIdsKey,
+      activePromoCode,
+      availabilitiesCache,
+      pricingProfileIdForAvailabilities,
+      product.productId,
+    ],
+  );
+
+  const applyAvailabilityPriceFields = useCallback(
+    (result: {
+      pricingConfig?: PricingConfig | null;
+      precomputedPrices?: PrecomputedPricesByCategory | null;
+      resourcePriceByCurrency?: Record<string, number> | null;
+      resourcePriceByOption?: Record<string, Record<string, number>> | null;
+    }) => {
+      applyPricingConfig(result.pricingConfig);
+      if (result.precomputedPrices) setPrecomputedPrices(result.precomputedPrices);
+      if (result.resourcePriceByCurrency) setResourcePriceByCurrency(result.resourcePriceByCurrency);
+      if (result.resourcePriceByOption) setResourcePriceByOption(result.resourcePriceByOption);
+    },
+    [applyPricingConfig],
+  );
+
+  const mergeIntoState = useCallback((incoming: Availability[]) => {
+    let mergedAvailabilities: Availability[] = [];
+    setAvailabilities((prev) => {
+      mergedAvailabilities = mergePrivateShuttleAvailabilities(prev, incoming);
+      return mergedAvailabilities;
+    });
+    return mergedAvailabilities;
+  }, []);
+
+  const updateCache = useCallback(
+    (
+      incoming: Availability[],
+      result: {
+        pricingConfig?: PricingConfig | null;
+        precomputedPrices?: PrecomputedPricesByCategory | null;
+        resourcePriceByCurrency?: Record<string, number> | null;
+        resourcePriceByOption?: Record<string, Record<string, number>> | null;
+      },
+      fetchedRanges?: DateRange[],
+    ) => {
+      const cacheKey = getCacheKey();
+      if (!cacheKey || !availabilitiesCache) return;
+
+      const existingCache = availabilitiesCache.get(cacheKey);
+      const mergedAvailabilities = mergePrivateShuttleAvailabilities(
+        existingCache?.availabilities ?? [],
+        incoming,
+      );
+      availabilitiesCache.merge(cacheKey, {
+        fetchedRanges: fetchedRanges ?? existingCache?.fetchedRanges ?? fetchedRangesRef.current,
+        availabilities: mergedAvailabilities,
+        pricingConfig: result.pricingConfig ?? existingCache?.pricingConfig ?? null,
+        precomputedPrices: result.precomputedPrices ?? existingCache?.precomputedPrices ?? null,
+        resourcePriceByCurrency:
+          result.resourcePriceByCurrency ?? existingCache?.resourcePriceByCurrency ?? null,
+        resourcePriceByOption: result.resourcePriceByOption ?? existingCache?.resourcePriceByOption ?? null,
+      });
+    },
+    [availabilitiesCache, getCacheKey],
+  );
+
+  const needsFetch = useCallback((start: Date, end: Date) => {
+    if (fetchedRangesRef.current.length === 0) return true;
+    return !fetchedRangesRef.current.some(
+      (range) => range.start.getTime() <= start.getTime() && range.end.getTime() >= end.getTime(),
+    );
+  }, []);
+
+  const reloadAvailabilitiesAfterReserveConflict = useCallback(async (): Promise<Availability[]> => {
+    if (!visibleRange || !product.productId) return [];
+
+    const { start, end } = clampAvailabilityRange(visibleRange, selectedDate, companyTimezone);
+    const startDate = formatInTimeZone(start, companyTimezone, 'yyyy-MM-dd');
+    const endDate = formatInTimeZone(end, companyTimezone, 'yyyy-MM-dd');
+    const result = await getAvailabilities(product.productId, startDate, endDate, {
+      allOptions: true,
+      promoCode: activePromoCode || undefined,
+      ...(pricingProfileIdForAvailabilities ? { pricingProfileId: pricingProfileIdForAvailabilities } : {}),
+      ...(cancellationPolicyProfileIdForAvailabilities
+        ? { cancellationPolicyProfileId: cancellationPolicyProfileIdForAvailabilities }
+        : {}),
+    });
+
+    applyAvailabilityPriceFields(result);
+    const mergedAvailabilities = mergeIntoState(result.availabilities);
+    const mergedRanges = mergeFetchedRanges([
+      ...fetchedRangesRef.current,
+      { start: new Date(start), end: new Date(end) },
+    ]);
+    fetchedRangesRef.current = mergedRanges;
+    updateCache(result.availabilities, result, mergedRanges);
+
+    return mergedAvailabilities;
+  }, [
+    activePromoCode,
+    applyAvailabilityPriceFields,
+    cancellationPolicyProfileIdForAvailabilities,
+    companyTimezone,
+    mergeIntoState,
+    pricingProfileIdForAvailabilities,
+    product.productId,
+    selectedDate,
+    updateCache,
+    visibleRange,
+  ]);
+
+  const refreshSelectedDateDetailsForCheckout = useCallback(async (): Promise<{
+    availabilities: Availability[];
+    pricingConfig?: PricingConfig | null;
+  }> => {
+    if (!selectedDate || !product.productId) return { availabilities: [] };
+
+    const result = await getAvailabilities(product.productId, selectedDate, selectedDate, {
+      allOptions: true,
+      promoCode: activePromoCode || undefined,
+      ...(pricingProfileIdForAvailabilities ? { pricingProfileId: pricingProfileIdForAvailabilities } : {}),
+      ...(cancellationPolicyProfileIdForAvailabilities
+        ? { cancellationPolicyProfileId: cancellationPolicyProfileIdForAvailabilities }
+        : {}),
+    });
+
+    applyAvailabilityPriceFields(result);
+    mergeIntoState(result.availabilities);
+    updateCache(result.availabilities, result);
+
+    return { availabilities: result.availabilities, pricingConfig: result.pricingConfig };
+  }, [
+    activePromoCode,
+    applyAvailabilityPriceFields,
+    cancellationPolicyProfileIdForAvailabilities,
+    mergeIntoState,
+    pricingProfileIdForAvailabilities,
+    product.productId,
+    selectedDate,
+    updateCache,
+  ]);
+
+  useEffect(() => {
+    if (!visibleRange) {
+      setVisibleRange({
+        start: EARLIEST_AVAILABILITY_DATE,
+        end: addWeeks(EARLIEST_AVAILABILITY_DATE, INITIAL_FETCH_WEEKS + VISIBLE_RANGE_BUFFER_WEEKS),
+      });
+    }
+  }, [visibleRange]);
+
+  useEffect(() => {
+    fetchedRangesRef.current = [];
+  }, [
+    activePromoCode,
+    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 });
+    }
+  }, []);
+
+  useEffect(() => {
+    if (activeOptions.length === 0) {
+      setError('No active product options available');
+      setLoadingAvailabilities(false);
+      return;
+    }
+    if (!visibleRange) return;
+
+    async function fetchAvailabilities() {
+      if (!visibleRange) return;
+      if (fetchingRef.current) return;
+
+      const { start: clampedStart, end: clampedEnd } = clampAvailabilityRange(
+        visibleRange,
+        selectedDate,
+        companyTimezone,
+      );
+      const cacheKey = getCacheKey();
+      const cached = cacheKey ? availabilitiesCache?.get(cacheKey) : undefined;
+      let shouldRevalidateCachedRange = false;
+
+      if (cached && cached.availabilities.length > 0) {
+        const cacheCoversRange = cached.fetchedRanges.some(
+          (range) =>
+            range.start.getTime() <= clampedStart.getTime() &&
+            range.end.getTime() >= clampedEnd.getTime(),
+        );
+        const isStale = availabilitiesCache?.isStale(cached) ?? false;
+        if (cacheCoversRange) {
+          shouldRevalidateCachedRange = true;
+          setAvailabilities(cached.availabilities);
+          if (cached.pricingConfig) applyCachedPricingConfig(cached.pricingConfig);
+          if (cached.precomputedPrices) setPrecomputedPrices(cached.precomputedPrices);
+          if (cached.resourcePriceByCurrency) setResourcePriceByCurrency(cached.resourcePriceByCurrency);
+          if (cached.resourcePriceByOption) setResourcePriceByOption(cached.resourcePriceByOption);
+          setLoadingAvailabilities(false);
+          setIsFetchingMoreAvailabilities(false);
+          if (!isStale) {
+            fetchedRangesRef.current = [...cached.fetchedRanges];
+          }
+        }
+
+        setAvailabilities(cached.availabilities);
+        if (cached.pricingConfig) applyCachedPricingConfig(cached.pricingConfig);
+        if (cached.precomputedPrices) setPrecomputedPrices(cached.precomputedPrices);
+        if (cached.resourcePriceByCurrency) setResourcePriceByCurrency(cached.resourcePriceByCurrency);
+        if (cached.resourcePriceByOption) setResourcePriceByOption(cached.resourcePriceByOption);
+        fetchedRangesRef.current = [...cached.fetchedRanges];
+        setLoadingAvailabilities(false);
+      }
+
+      if (!shouldRevalidateCachedRange && !needsFetch(clampedStart, clampedEnd)) {
+        setLoadingAvailabilities(false);
+        setIsFetchingMoreAvailabilities(false);
+        fetchingRef.current = false;
+        return;
+      }
+
+      const hasPartialCache = cached && cached.availabilities.length > 0;
+      fetchingRef.current = true;
+      if (!hasPartialCache) setLoadingAvailabilities(true);
+      else if (!shouldRevalidateCachedRange) setIsFetchingMoreAvailabilities(true);
+
+      try {
+        const startDate = formatInTimeZone(clampedStart, companyTimezone, 'yyyy-MM-dd');
+        const endDate = formatInTimeZone(clampedEnd, companyTimezone, 'yyyy-MM-dd');
+        const result = await getAvailabilities(product.productId, startDate, endDate, {
+          allOptions: true,
+          summary: true,
+          promoCode: activePromoCode || undefined,
+          ...(pricingProfileIdForAvailabilities ? { pricingProfileId: pricingProfileIdForAvailabilities } : {}),
+          ...(cancellationPolicyProfileIdForAvailabilities
+            ? { cancellationPolicyProfileId: cancellationPolicyProfileIdForAvailabilities }
+            : {}),
+        });
+        applyAvailabilityPriceFields(result);
+
+        const mergedAvailabilities = mergePrivateShuttleAvailabilities(
+          hasPartialCache && cached ? cached.availabilities : [],
+          result.availabilities,
+        );
+        setAvailabilities(mergedAvailabilities);
+
+        const mergedRanges = mergeFetchedRanges([
+          ...fetchedRangesRef.current,
+          { start: new Date(clampedStart), end: new Date(clampedEnd) },
+        ]);
+        fetchedRangesRef.current = mergedRanges;
+        if (passengerCount === 0) setPassengerCount(1);
+        updateCache(mergedAvailabilities, result, mergedRanges);
+      } catch (err) {
+        if (shouldRevalidateCachedRange && cached?.availabilities.length) {
+          console.warn('Background private shuttle availability refresh failed; keeping cached availability visible.', err);
+        } else {
+          setError(err instanceof Error ? err.message : 'Failed to load availabilities');
+        }
+      } finally {
+        setLoadingAvailabilities(false);
+        setIsFetchingMoreAvailabilities(false);
+        fetchingRef.current = false;
+      }
+    }
+
+    fetchAvailabilities();
+  }, [
+    activeOptions,
+    activePromoCode,
+    applyAvailabilityPriceFields,
+    applyCachedPricingConfig,
+    availabilitiesCache,
+    cancellationPolicyProfileIdForAvailabilities,
+    companyTimezone,
+    getCacheKey,
+    needsFetch,
+    passengerCount,
+    pricingProfileIdForAvailabilities,
+    product.productId,
+    selectedDate,
+    setError,
+    setPassengerCount,
+    updateCache,
+    visibleRange,
+  ]);
+
+  const isPrivateShuttleAvailabilityBookable = useCallback(
+    (availability: Availability): boolean => {
+      if (isAdmin) return true;
+      const dateInCompanyTz = privateShuttleAvailabilityDateInZone(availability, companyTimezone);
+      const optionId = getPrivateShuttleAvailabilityOptionId(availability);
+      const option = activeOptions.find((opt) => opt.optionId === optionId);
+      const startTimes = availability.suggestedStartTimes || option?.privateShuttleConfig?.suggestedStartTimes || [];
+      if (startTimes.length === 0) {
+        return isDateAfterPublicBookingCutoff(
+          fromZonedTime(parseISO(`${dateInCompanyTz}T23:59:59`), companyTimezone),
+          bookingCutoffNow,
+          bookingCutoffMinutes,
+        );
+      }
+      return startTimes.some((time) =>
+        privateShuttleStartTimeAllowed(
+          dateInCompanyTz,
+          time,
+          companyTimezone,
+          bookingCutoffNow,
+          bookingCutoffMinutes,
+        ),
+      );
+    },
+    [activeOptions, bookingCutoffMinutes, bookingCutoffNow, companyTimezone, isAdmin],
+  );
+
+  const publicVisibleAvailabilities = useMemo(
+    () => {
+      const todayStr = formatInTimeZone(new Date(), companyTimezone, 'yyyy-MM-dd');
+      const currentOrFutureAvailabilities = availabilities.filter(
+        (availability) => privateShuttleAvailabilityDateInZone(availability, companyTimezone) >= todayStr,
+      );
+      return isAdmin
+        ? currentOrFutureAvailabilities
+        : currentOrFutureAvailabilities.filter(isPrivateShuttleAvailabilityBookable);
+    },
+    [availabilities, companyTimezone, isAdmin, isPrivateShuttleAvailabilityBookable],
+  );
+
+  const availabilitiesByDate = useMemo(() => {
+    const grouped = publicVisibleAvailabilities.reduce(
+      (acc, availability) => {
+        const dateInCompanyTz = privateShuttleAvailabilityDateInZone(availability, companyTimezone);
+        if (!acc[dateInCompanyTz]) acc[dateInCompanyTz] = [];
+        acc[dateInCompanyTz].push(availability);
+        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;
+  }, [companyTimezone, publicVisibleAvailabilities]);
+
+  const optionsAvailableForSelectedDate = useMemo(() => {
+    if (!selectedDate) return [];
+    const dateAvailabilities = availabilitiesByDate[selectedDate] || [];
+    const optionIds = new Set(dateAvailabilities.map(getPrivateShuttleAvailabilityOptionId).filter(Boolean));
+    return activeOptions.filter((option) => optionIds.has(option.optionId));
+  }, [activeOptions, availabilitiesByDate, selectedDate]);
+
+  const dates = useMemo(() => Object.keys(availabilitiesByDate).sort(), [availabilitiesByDate]);
+
+  useEffect(() => {
+    if (!selectedDate || !product.productId) return;
+    const selectedDateAvailabilities = availabilitiesByDate[selectedDate] ?? [];
+    if (!selectedDateAvailabilities.some((availability) => availability.isSummary)) return;
+
+    let cancelled = false;
+    async function hydrateSelectedDateDetails() {
+      setIsFetchingMoreAvailabilities(true);
+      try {
+        const result = await getAvailabilities(product.productId, selectedDate, selectedDate, {
+          allOptions: true,
+          promoCode: activePromoCode || undefined,
+          ...(pricingProfileIdForAvailabilities ? { pricingProfileId: pricingProfileIdForAvailabilities } : {}),
+          ...(cancellationPolicyProfileIdForAvailabilities
+            ? { cancellationPolicyProfileId: cancellationPolicyProfileIdForAvailabilities }
+            : {}),
+        });
+        if (cancelled) return;
+
+        applyAvailabilityPriceFields(result);
+        mergeIntoState(result.availabilities);
+        updateCache(result.availabilities, result);
+      } catch (err) {
+        if (!cancelled) {
+          console.error('Error hydrating private shuttle availability details:', err);
+        }
+      } finally {
+        if (!cancelled) setIsFetchingMoreAvailabilities(false);
+      }
+    }
+
+    hydrateSelectedDateDetails();
+    return () => {
+      cancelled = true;
+    };
+  }, [
+    activePromoCode,
+    applyAvailabilityPriceFields,
+    availabilitiesByDate,
+    cancellationPolicyProfileIdForAvailabilities,
+    mergeIntoState,
+    pricingProfileIdForAvailabilities,
+    product.productId,
+    selectedDate,
+    updateCache,
+  ]);
+
+  const earliestAvailabilityDate = useMemo(() => {
+    if (dates.length === 0) return EARLIEST_AVAILABILITY_DATE;
+    return fromZonedTime(parseISO(`${dates[0]}T12:00:00`), companyTimezone);
+  }, [companyTimezone, dates]);
+
+  return {
+    availabilities,
+    loadingAvailabilities,
+    isFetchingMoreAvailabilities,
+    pricingConfig,
+    precomputedPrices,
+    resourcePriceByCurrency,
+    resourcePriceByOption,
+    availabilitiesByDate,
+    optionsAvailableForSelectedDate,
+    dates,
+    earliestAvailabilityDate,
+    handleVisibleRangeChange,
+    reloadAvailabilitiesAfterReserveConflict,
+    refreshSelectedDateDetailsForCheckout,
+    fetchedRangesRef,
+  };
+}