@calcom/atoms 2.8.0 → 2.8.1

package/src/booker/types.ts

@@ -1,142 +0,0 @@
-import type React from "react";
-import type {
-  ApiErrorResponse,
-  ApiSuccessResponse,
-  ApiSuccessResponseWithoutData,
-  BookingResponse,
-  RoutingFormSearchParams,
-} from "../contracts";
-import type {
-  BookerPropsContract,
-  BookerStoreValues,
-  BookerTimezone,
-  BookerView,
-  BookingCreateInput,
-  CountryCode,
-  RecurringBookingCreateInput,
-} from "../contracts/booker";
-
-export type { BookerStoreValues };
-
-type SlotInfo = {
-  time: string;
-  attendees?: number;
-  bookingUid?: string;
-  away?: boolean;
-  fromUser?: {
-    id: number;
-    displayName: string | null;
-  };
-  toUser?: {
-    id: number;
-    username: string | null;
-    displayName: string | null;
-  };
-  reason?: string;
-  emoji?: string;
-  showNotePublicly?: boolean;
-};
-
-export type Slot = {
-  time: string;
-  userIds?: number[];
-  attendees?: number;
-  bookingUid?: string;
-  users?: string[];
-  /** Tentative-slot flag AvailableTimes toggles when a slot is
-   *  pre-selected but not yet confirmed. */
-  showConfirmButton?: boolean;
-  /** Out-of-office metadata carried by the schedule payload. */
-  away?: boolean;
-  // Drop the explicit `null` union — webapp consumers type fromUser/toUser
-  // as `Record<string, unknown> | undefined` (no null) and handlers expect
-  // values without null. Atoms's runtime never produces null here either.
-  fromUser?: { username?: string | null; name?: string | null; displayName?: string | null };
-  toUser?: {
-    id?: number;
-    username?: string | null;
-    name?: string | null;
-    displayName?: string | null;
-  };
-  reason?: string;
-  emoji?: string;
-  notes?: string | null;
-  showNotePublicly?: boolean;
-};
-
-/** Identity of a connected calendar toggled in the overlay. */
-export type ToggledConnectedCalendars = {
-  credentialId: number;
-  externalId: string;
-};
-
-export type BookerPlatformWrapperAtomProps = Omit<
-  BookerPropsContract,
-  "username" | "entity" | "isTeamEvent"
-> & {
-  rescheduleUid?: string;
-  rescheduledBy?: string;
-  bookingUid?: string;
-  entity?: BookerPropsContract["entity"];
-  // values for the booking form and booking fields
-  defaultFormValues?: {
-    firstName?: string;
-    lastName?: string;
-    guests?: string[];
-    name?: string;
-    email?: string;
-    notes?: string;
-    rescheduleReason?: string;
-  } & Record<string, string | string[]>;
-  handleCreateBooking?: (input: BookingCreateInput) => void;
-  handleCreateRecurringBooking?: (input: RecurringBookingCreateInput[]) => void;
-  onCreateBookingSuccess?: (data: ApiSuccessResponse<BookingResponse>) => void;
-  onCreateBookingError?: (data: ApiErrorResponse | Error) => void;
-  onCreateRecurringBookingSuccess?: (data: ApiSuccessResponse<BookingResponse[]>) => void;
-  onCreateRecurringBookingError?: (data: ApiErrorResponse | Error) => void;
-  onCreateInstantBookingSuccess?: (data: ApiSuccessResponse<BookingResponse>) => void;
-  onCreateInstantBookingError?: (data: ApiErrorResponse | Error) => void;
-  onReserveSlotSuccess?: (data: ApiSuccessResponse<string>) => void;
-  onReserveSlotError?: (data: ApiErrorResponse) => void;
-  onDeleteSlotSuccess?: (data: ApiSuccessResponseWithoutData) => void;
-  onDeleteSlotError?: (data: ApiErrorResponse) => void;
-  onBookerStateChange?: (state: BookerStoreValues) => void;
-  handleSlotReservation?: (timeslot: string) => void;
-  locationUrl?: string;
-  view?: BookerView;
-  metadata?: Record<string, string>;
-  bannerUrl?: string;
-  onDryRunSuccess?: () => void;
-  hostsLimit?: number;
-  preventEventTypeRedirect?: boolean;
-  allowUpdatingUrlParams?: boolean;
-  confirmButtonDisabled?: boolean;
-  timeZones?: BookerTimezone[];
-  isBookingDryRun?: boolean;
-  eventMetaChildren?: React.ReactNode;
-  onTimeslotsLoaded?: (slots: Record<string, Slot[]>) => void;
-  startTime?: string | Date;
-  roundRobinHideOrgAndTeam?: boolean;
-  silentlyHandleCalendarFailures?: boolean;
-  hideEventMetadata?: boolean;
-  defaultPhoneCountry?: CountryCode;
-  hideOrgTeamAvatar?: boolean;
-};
-
-export type BookerPlatformWrapperAtomPropsForIndividual = BookerPlatformWrapperAtomProps & {
-  username: string | string[];
-  isTeamEvent?: false;
-  routingFormSearchParams?: RoutingFormSearchParams;
-};
-
-export type BookerPlatformWrapperAtomPropsForTeam = BookerPlatformWrapperAtomProps & {
-  username?: string | string[];
-  isTeamEvent: true;
-  teamId: number;
-  routingFormSearchParams?: RoutingFormSearchParams;
-  rrHostSubsetIds?: number[];
-};
-
-export type GetAvailableSlotsResponse = {
-  slots: Record<string, SlotInfo[]>;
-};

package/src/booker/use-slot-reservation-id.ts

@@ -1,14 +0,0 @@
-// Slot reservation id shared across the Booker. Persists only for the current
-// page lifetime; the cookie set by the reserveSlot call is the longer-lived
-// source of truth (and a third-party cookie inside embeds).
-let slotReservationId: null | string = null;
-
-export const useSlotReservationId = () => {
-  function set(uid: string) {
-    slotReservationId = uid;
-  }
-  function get() {
-    return slotReservationId;
-  }
-  return [get(), set] as const;
-};

package/src/booker/utils/__tests__/booker-utils.test.ts

@@ -1,159 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { BookerLayouts } from "../../../contracts";
-import { areDifferentValidMonths } from "../are-different-valid-months";
-import { getBookerTimezone } from "../get-booker-timezone";
-import { getBookingDuration } from "../get-booking-duration";
-import { getPrefetchMonthCount } from "../get-prefetch-month-count";
-import { isBookingDryRun } from "../is-booking-dry-run";
-import { isMonthChange } from "../is-month-change";
-import { isMonthViewPrefetchEnabled } from "../is-month-view-prefetch-enabled";
-import { isPrefetchNextMonthEnabled } from "../is-prefetch-next-month-enabled";
-import { validateLayout } from "../layout";
-
-describe("areDifferentValidMonths", () => {
-  it("returns false when both months equal", () => {
-    expect(areDifferentValidMonths(5, 5)).toBe(false);
-  });
-
-  it("returns false for NaN / Infinity", () => {
-    expect(areDifferentValidMonths(NaN, 5)).toBe(false);
-    expect(areDifferentValidMonths(5, Infinity)).toBe(false);
-  });
-
-  it("returns true for two different finite months", () => {
-    expect(areDifferentValidMonths(4, 5)).toBe(true);
-  });
-});
-
-describe("getBookerTimezone", () => {
-  it("prefers store timezone when set", () => {
-    expect(getBookerTimezone({ storeTimezone: "UTC", bookerUserPreferredTimezone: "Europe/Paris" })).toBe(
-      "UTC"
-    );
-  });
-
-  it("falls back to user preferred timezone when store timezone is null", () => {
-    expect(getBookerTimezone({ storeTimezone: null, bookerUserPreferredTimezone: "Europe/Paris" })).toBe(
-      "Europe/Paris"
-    );
-  });
-});
-
-describe("getBookingDuration", () => {
-  it("returns duration in minutes when it matches config", () => {
-    const start = "2024-06-17T10:00:00.000Z";
-    const end = "2024-06-17T10:30:00.000Z";
-    expect(getBookingDuration(start, end, [15, 30, 60])).toBe(30);
-  });
-
-  it("returns null when duration is not in config", () => {
-    const start = "2024-06-17T10:00:00.000Z";
-    const end = "2024-06-17T10:22:00.000Z";
-    expect(getBookingDuration(start, end, [15, 30, 60])).toBeNull();
-  });
-
-  it("accepts Date objects", () => {
-    expect(getBookingDuration(new Date("2024-06-17T10:00:00Z"), new Date("2024-06-17T11:00:00Z"), [60])).toBe(
-      60
-    );
-  });
-});
-
-describe("getPrefetchMonthCount", () => {
-  it("returns undefined when months are the same", () => {
-    expect(getPrefetchMonthCount(BookerLayouts.MONTH_VIEW, "selecting_time", 5, 5, false)).toBeUndefined();
-  });
-
-  it("returns 2 in column view when months differ", () => {
-    expect(getPrefetchMonthCount(BookerLayouts.COLUMN_VIEW, "selecting_date", 4, 5, false)).toBe(2);
-  });
-
-  it("returns 2 when selecting_time, not week view, prefetch disabled", () => {
-    expect(getPrefetchMonthCount(BookerLayouts.MONTH_VIEW, "selecting_time", 4, 5, false)).toBe(2);
-  });
-
-  it("returns undefined for week view selecting_time", () => {
-    expect(getPrefetchMonthCount(BookerLayouts.WEEK_VIEW, "selecting_time", 4, 5, false)).toBeUndefined();
-  });
-
-  it("returns undefined when prefetchNextMonth is true", () => {
-    expect(getPrefetchMonthCount(BookerLayouts.MONTH_VIEW, "selecting_time", 4, 5, true)).toBeUndefined();
-  });
-});
-
-describe("isBookingDryRun", () => {
-  it("returns true when query param is 'true'", () => {
-    const params = new URLSearchParams();
-    params.set("cal.isBookingDryRun", "true");
-    expect(isBookingDryRun(params)).toBe(true);
-  });
-
-  it("returns false when query param missing or false", () => {
-    expect(isBookingDryRun(new URLSearchParams())).toBe(false);
-    const params = new URLSearchParams();
-    params.set("cal.isBookingDryRun", "false");
-    expect(isBookingDryRun(params)).toBe(false);
-  });
-});
-
-describe("isMonthChange", () => {
-  it("returns true when months differ", () => {
-    expect(isMonthChange(4, 5)).toBe(true);
-  });
-
-  it("returns false when months equal", () => {
-    expect(isMonthChange(5, 5)).toBe(false);
-  });
-
-  it("returns false when either is NaN", () => {
-    expect(isMonthChange(NaN, 5)).toBe(false);
-    expect(isMonthChange(5, NaN)).toBe(false);
-  });
-});
-
-describe("isMonthViewPrefetchEnabled", () => {
-  it("returns false when date/month are invalid", () => {
-    expect(isMonthViewPrefetchEnabled("not-a-date", null)).toBe(false);
-  });
-});
-
-describe("isPrefetchNextMonthEnabled", () => {
-  it("WEEK_VIEW requires extraDays and month change", () => {
-    expect(isPrefetchNextMonthEnabled(BookerLayouts.WEEK_VIEW, "2024-06-17", 5, 6, 5, "2024-06", 3)).toBe(
-      true
-    );
-    expect(isPrefetchNextMonthEnabled(BookerLayouts.WEEK_VIEW, "2024-06-17", 5, 5, 5, "2024-06", 3)).toBe(
-      false
-    );
-    expect(
-      isPrefetchNextMonthEnabled(BookerLayouts.WEEK_VIEW, "2024-06-17", 5, 6, 5, "2024-06", undefined)
-    ).toBe(false);
-  });
-
-  it("COLUMN_VIEW triggers on column-view month change", () => {
-    expect(isPrefetchNextMonthEnabled(BookerLayouts.COLUMN_VIEW, "2024-06-17", 5, 5, 6, "2024-06")).toBe(
-      true
-    );
-    expect(isPrefetchNextMonthEnabled(BookerLayouts.COLUMN_VIEW, "2024-06-17", 5, 5, 5, "2024-06")).toBe(
-      false
-    );
-  });
-
-  it("returns false for unknown layouts", () => {
-    expect(isPrefetchNextMonthEnabled("unknown_view", "2024-06-17", 5, 6, 6, "2024-06")).toBe(false);
-  });
-});
-
-describe("validateLayout", () => {
-  it("returns the layout when it's valid", () => {
-    expect(validateLayout("month_view")).toBe("month_view");
-    expect(validateLayout("week_view")).toBe("week_view");
-    expect(validateLayout("column_view")).toBe("column_view");
-  });
-
-  it("returns undefined for invalid or null/undefined", () => {
-    expect(validateLayout("bad-layout" as never)).toBeUndefined();
-    expect(validateLayout(null)).toBeUndefined();
-    expect(validateLayout(undefined)).toBeUndefined();
-  });
-});

package/src/booker/utils/__tests__/is-timeslot-available.test.ts

@@ -1,224 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { isTimeSlotAvailable } from "../is-timeslot-available";
-
-type QuickAvailabilityCheck = { utcStartIso: string; status: string };
-
-describe("isTimeSlotAvailable", () => {
-  // Test when a slot is unavailable according to quick availability checks
-  it("should return false when slot is unavailable according to quick availability checks", () => {
-    const slotToCheckInIso = "2024-02-08T10:30:00.000Z";
-    const quickAvailabilityChecks: QuickAvailabilityCheck[] = [
-      {
-        utcStartIso: slotToCheckInIso,
-        status: "unavailable",
-      },
-    ];
-
-    const result = isTimeSlotAvailable({
-      scheduleData: {
-        slots: {
-          "2024-02-08": [{ time: slotToCheckInIso }],
-        },
-      },
-      slotToCheckInIso,
-      quickAvailabilityChecks,
-    });
-
-    expect(result).toBe(false);
-  });
-
-  it("should return true when scheduleData is null", () => {
-    const slotToCheckInIso = "2024-02-08T10:30:00.000Z";
-    const quickAvailabilityChecks: QuickAvailabilityCheck[] = [];
-
-    const result = isTimeSlotAvailable({
-      scheduleData: null,
-      slotToCheckInIso,
-      quickAvailabilityChecks,
-    });
-
-    expect(result).toBe(true);
-  });
-
-  it("should return true when the date doesn't exist in the schedule data", () => {
-    const slotToCheckInIso = "2024-02-08T10:30:00.000Z";
-    const quickAvailabilityChecks: QuickAvailabilityCheck[] = [];
-
-    const result = isTimeSlotAvailable({
-      scheduleData: {
-        slots: {
-          "2024-02-09": [{ time: "2024-02-09T10:30:00.000Z" }],
-        },
-      },
-      slotToCheckInIso,
-      quickAvailabilityChecks,
-    });
-
-    expect(result).toBe(false);
-  });
-
-  describe("Different day due to timezone", () => {
-    it("should correctly lookup on appropriate date when the day in which to show the slot is before the date in the ISO string", () => {
-      const slotToCheckInIso1 = "2024-02-08T10:30:00.000Z";
-      const dateToShowSlot1 = "2024-02-07";
-      const quickAvailabilityChecks1: QuickAvailabilityCheck[] = [];
-
-      const result1 = isTimeSlotAvailable({
-        scheduleData: {
-          slots: {
-            [dateToShowSlot1]: [{ time: slotToCheckInIso1 }],
-          },
-        },
-        slotToCheckInIso: slotToCheckInIso1,
-        quickAvailabilityChecks: quickAvailabilityChecks1,
-      });
-
-      expect(result1).toBe(true);
-
-      const slotToCheckInIso2 = "2024-02-01T10:30:00.000Z";
-      const dateToShowSlot2 = "2024-01-31";
-      const quickAvailabilityChecks2: QuickAvailabilityCheck[] = [];
-      const result2 = isTimeSlotAvailable({
-        scheduleData: {
-          slots: {
-            [dateToShowSlot2]: [{ time: slotToCheckInIso2 }],
-          },
-        },
-        slotToCheckInIso: slotToCheckInIso2,
-        quickAvailabilityChecks: quickAvailabilityChecks2,
-      });
-
-      expect(result2).toBe(true);
-    });
-
-    it("should correctly lookup on appropriate date when the day in which to show the slot is after the date in the ISO string", () => {
-      const slotToCheckInIso1 = "2024-02-08T10:30:00.000Z";
-      const dateToShowSlot1 = "2024-02-09";
-      const quickAvailabilityChecks1: QuickAvailabilityCheck[] = [];
-
-      const result1 = isTimeSlotAvailable({
-        scheduleData: {
-          slots: {
-            [dateToShowSlot1]: [{ time: slotToCheckInIso1 }],
-          },
-        },
-        slotToCheckInIso: slotToCheckInIso1,
-        quickAvailabilityChecks: quickAvailabilityChecks1,
-      });
-
-      expect(result1).toBe(true);
-
-      const slotToCheckInIso2 = "2024-02-01T10:30:00.000Z";
-      const dateToShowSlot2 = "2024-01-31";
-      const quickAvailabilityChecks2: QuickAvailabilityCheck[] = [];
-      const result2 = isTimeSlotAvailable({
-        scheduleData: {
-          slots: {
-            [dateToShowSlot2]: [{ time: slotToCheckInIso2 }],
-          },
-        },
-        slotToCheckInIso: slotToCheckInIso2,
-        quickAvailabilityChecks: quickAvailabilityChecks2,
-      });
-
-      expect(result2).toBe(true);
-    });
-  });
-
-  it("should return true when the slot exists in the schedule data", () => {
-    const slotToCheckInIso = "2024-02-08T10:30:00.000Z";
-    const quickAvailabilityChecks: QuickAvailabilityCheck[] = [];
-
-    const result = isTimeSlotAvailable({
-      scheduleData: {
-        slots: {
-          "2024-02-08": [{ time: slotToCheckInIso }],
-        },
-      },
-      slotToCheckInIso,
-      quickAvailabilityChecks,
-    });
-
-    expect(result).toBe(true);
-  });
-
-  // Test when the slot doesn't exist in the schedule data
-  it("should return false when the slot doesn't exist in the schedule data", () => {
-    const slotToCheckInIso = "2024-02-08T10:30:00.000Z";
-    const differentSlotTime = "2024-02-08T11:30:00.000Z";
-    const quickAvailabilityChecks: QuickAvailabilityCheck[] = [];
-
-    const result = isTimeSlotAvailable({
-      scheduleData: {
-        slots: {
-          "2024-02-08": [{ time: differentSlotTime }],
-        },
-      },
-      slotToCheckInIso,
-      quickAvailabilityChecks,
-    });
-
-    expect(result).toBe(false);
-  });
-
-  // Test when the slot is available according to quick availability checks
-  it("should check schedule data when slot is available according to quick availability checks", () => {
-    const slotToCheckInIso = "2024-02-08T10:30:00.000Z";
-    const quickAvailabilityChecks: QuickAvailabilityCheck[] = [
-      {
-        utcStartIso: slotToCheckInIso,
-        status: "available",
-      },
-    ];
-
-    const result = isTimeSlotAvailable({
-      scheduleData: {
-        slots: {
-          "2024-02-08": [{ time: slotToCheckInIso }],
-        },
-      },
-      slotToCheckInIso,
-      quickAvailabilityChecks,
-    });
-
-    expect(result).toBe(true);
-  });
-
-  // Test with seconds difference in time slots
-  it("should return true when slots differ only by seconds", () => {
-    const slotToCheckInIso = "2024-02-08T10:30:00.000Z";
-    const slotWithSeconds = "2024-02-08T10:30:45.000Z";
-    const quickAvailabilityChecks: QuickAvailabilityCheck[] = [];
-
-    const result = isTimeSlotAvailable({
-      scheduleData: {
-        slots: {
-          "2024-02-08": [{ time: slotWithSeconds }],
-        },
-      },
-      slotToCheckInIso,
-      quickAvailabilityChecks,
-    });
-
-    expect(result).toBe(true);
-  });
-
-  it("should return true(give a false positive) when the date string is not in the expected format", () => {
-    // Invalid ISO format -> Correct is "2024-02-08T10:30:00.000Z"
-    const slotToCheckInIso = "2024-02-8T10:30:00.000Z";
-    const quickAvailabilityChecks: QuickAvailabilityCheck[] = [];
-
-    const result = isTimeSlotAvailable({
-      scheduleData: {
-        slots: {
-          "2024-02-08": [{ time: "2024-02-08T12:00:00.000Z" }],
-        },
-      },
-      slotToCheckInIso,
-      quickAvailabilityChecks,
-    });
-
-    expect(result).toBe(true);
-  });
-});

package/src/booker/utils/are-different-valid-months.ts

@@ -1,5 +0,0 @@
-export const areDifferentValidMonths = (firstMonth: number, secondMonth: number) => {
-  if (!Number.isFinite(firstMonth) || !Number.isFinite(secondMonth)) return false;
-  if (firstMonth === secondMonth) return false;
-  return true;
-};

package/src/booker/utils/dates.tsx

@@ -1,90 +0,0 @@
-import { formatDateTime, formatDateTimeRange } from "../../vendor/format-date-time";
-import { TimeFormat } from "../../vendor/time-format";
-
-interface EventFromToTime {
-  date: string;
-  duration: number | null;
-  timeFormat: TimeFormat;
-  timeZone: string;
-  language: string;
-}
-
-interface EventFromTime {
-  date: string;
-  timeFormat: TimeFormat;
-  timeZone: string;
-  language: string;
-}
-
-export const formatEventFromTime = ({ date, timeFormat, timeZone, language }: EventFromTime) => {
-  const startDate = new Date(date);
-
-  const formattedDate = formatDateTime(startDate, {
-    locale: language,
-    timeZone,
-    dateStyle: "full",
-  });
-
-  const formattedTime = formatDateTime(startDate, {
-    locale: language,
-    timeZone,
-    timeStyle: "short",
-    hour12: timeFormat === TimeFormat.TWELVE_HOUR,
-  });
-
-  return {
-    date: formattedDate,
-    time: timeFormat === TimeFormat.TWELVE_HOUR ? formattedTime.toLowerCase() : formattedTime,
-  };
-};
-
-export const formatEventFromToTime = ({
-  date,
-  duration,
-  timeFormat,
-  timeZone,
-  language,
-}: EventFromToTime) => {
-  const startDate = new Date(date);
-  const endDate = duration
-    ? new Date(new Date(date).setMinutes(startDate.getMinutes() + duration))
-    : startDate;
-
-  const formattedDate = formatDateTimeRange(startDate, endDate, {
-    locale: language,
-    timeZone,
-    dateStyle: "full",
-  });
-
-  const formattedTime = formatDateTimeRange(startDate, endDate, {
-    locale: language,
-    timeZone,
-    timeStyle: "short",
-    hour12: timeFormat === TimeFormat.TWELVE_HOUR,
-  });
-
-  return {
-    date: formattedDate,
-    time: timeFormat === TimeFormat.TWELVE_HOUR ? formattedTime.toLowerCase() : formattedTime,
-  };
-};
-
-export const FromToTime = (props: EventFromToTime) => {
-  const formatted = formatEventFromToTime(props);
-  return (
-    <>
-      {formatted.date}
-      <br />
-      {formatted.time}
-    </>
-  );
-};
-
-export const FromTime = (props: EventFromTime) => {
-  const formatted = formatEventFromTime(props);
-  return (
-    <>
-      {formatted.date}, {formatted.time}
-    </>
-  );
-};

package/src/booker/utils/get-booker-timezone.ts

@@ -1,9 +0,0 @@
-export const getBookerTimezone = ({
-  storeTimezone,
-  bookerUserPreferredTimezone,
-}: {
-  storeTimezone: string | null;
-  bookerUserPreferredTimezone: string;
-}) => {
-  return storeTimezone ?? bookerUserPreferredTimezone;
-};

package/src/booker/utils/get-booking-duration.ts

@@ -1,19 +0,0 @@
-/**
- * Computes the duration in minutes of a booking from its start and end times.
- * Returns the duration if it's a valid option in the durationConfig, otherwise null.
- */
-export const getBookingDuration = (
-  startTime: Date | string,
-  endTime: Date | string,
-  durationConfig: number[]
-): number | null => {
-  const start = new Date(startTime);
-  const end = new Date(endTime);
-  const durationInMinutes = Math.round((end.getTime() - start.getTime()) / 60000);
-
-  if (durationConfig.includes(durationInMinutes)) {
-    return durationInMinutes;
-  }
-
-  return null;
-};

package/src/booker/utils/get-prefetch-month-count.ts

@@ -1,24 +0,0 @@
-import { BookerLayouts, type BookerState } from "../../contracts";
-import { areDifferentValidMonths } from "./are-different-valid-months";
-
-export const getPrefetchMonthCount = (
-  bookerLayout: string,
-  bookerState: BookerState,
-  firstMonth: number,
-  secondMonth: number,
-  prefetchNextMonth: boolean
-) => {
-  const isDifferentMonth = areDifferentValidMonths(firstMonth, secondMonth);
-
-  const isWeekView = bookerLayout === BookerLayouts.WEEK_VIEW;
-  const isColumnView = bookerLayout === BookerLayouts.COLUMN_VIEW;
-  const isSelectingTime = bookerState === "selecting_time";
-
-  if (!isDifferentMonth) return undefined;
-
-  if (isColumnView) return 2;
-
-  if (!isWeekView && isSelectingTime && !prefetchNextMonth) return 2;
-
-  return undefined;
-};

package/src/booker/utils/is-booking-dry-run.ts

@@ -1,5 +0,0 @@
-import type { ReadonlyURLSearchParams } from "next/navigation";
-
-export const isBookingDryRun = (searchParams: URLSearchParams | ReadonlyURLSearchParams) => {
-  return searchParams.get("cal.isBookingDryRun") === "true";
-};