@calcom/atoms 2.8.0 → 2.8.1

package/src/availability/index.ts

@@ -1,3 +0,0 @@
-export * from "../types";
-export { AvailabilitySettings } from "./availability-settings";
-export { AvailabilitySettingsPlatformWrapper } from "./wrappers/availability-settings-platform-wrapper";

package/src/availability/types.ts

@@ -1,40 +0,0 @@
-import type { Schedule as ScheduleType, TimeRange } from "../contracts";
-
-export type Availability = {
-  id: number;
-  userId: number | null;
-  eventTypeId: number | null;
-  days: number[];
-  startTime: string;
-  endTime: Date;
-  date: Date | null;
-  scheduleId: number | null;
-};
-
-export type WeekdayFormat = "short" | "long";
-
-export type AvailabilityFormValues = {
-  availability: number[][];
-  name: string;
-  schedule: ScheduleType;
-  dateOverrides: { ranges: TimeRange[] }[];
-  timeZone: string;
-  isDefault: boolean;
-};
-
-export type { scheduleClassNames } from "../contracts";
-
-export type AvailabilityFormValidationResult = {
-  isValid: boolean;
-  errors: Record<string, unknown>;
-};
-
-export interface AvailabilitySettingsFormCallbacks {
-  onSuccess?: () => void;
-  onError?: (error: Error) => void;
-}
-
-export interface AvailabilitySettingsFormRef {
-  validateForm: () => Promise<AvailabilityFormValidationResult>;
-  handleFormSubmit: (callbacks?: AvailabilitySettingsFormCallbacks) => void;
-}

package/src/availability/wrappers/availability-settings-platform-wrapper.tsx

@@ -1,224 +0,0 @@
-// @ts-nocheck — wrapper/hook reconciles loose atoms contracts with legacy
-// backend payload shapes (unknowns from Record<string, any> branches, Radix
-// prop-pick narrowing). Runtime matches pre-extract behavior; a targeted
-// typing pass follows once the contracts are tightened per-consumer.
-
-import type { ReactNode } from "react";
-import { forwardRef } from "react";
-import { AtomsWrapper } from "../../components/atoms-wrapper";
-import { Shell } from "../../components/ui/shell";
-import { useToast } from "../../components/ui/use-toast";
-import type {
-  ApiErrorResponse,
-  ApiResponse,
-  AtomUpdateScheduleResponse,
-  UpdateScheduleInput_2024_06_11,
-} from "../../contracts";
-import { useAtomSchedule } from "../../hooks/schedules/use-atom-schedule";
-import { useAtomUpdateSchedule } from "../../hooks/schedules/use-atom-update-schedule";
-import useDeleteSchedule from "../../hooks/schedules/use-delete-schedule";
-import { useMe } from "../../hooks/use-me";
-import { Timezone } from "../../timezone/index";
-import type { Availability, CustomClassNames } from "../availability-settings";
-import { AvailabilitySettings } from "../availability-settings";
-import type { ScheduleLabelsType } from "../components/schedule-component";
-import { ScheduleComponent } from "../components/schedule-component";
-import type { AvailabilityFormValues, AvailabilitySettingsFormRef } from "../types";
-
-export type AvailabilitySettingsPlatformWrapperProps = {
-  id?: string;
-  labels?: {
-    tooltips: Partial<ScheduleLabelsType>;
-  };
-  customClassNames?: Partial<CustomClassNames>;
-  onUpdateSuccess?: (res: ApiResponse<AtomUpdateScheduleResponse>) => void;
-  onUpdateError?: (err: ApiErrorResponse) => void;
-  onDeleteSuccess?: (res: ApiResponse) => void;
-  onDeleteError?: (err: ApiErrorResponse) => void;
-  disableEditableHeading?: boolean;
-  enableOverrides?: boolean;
-  onBeforeUpdate?: (updateBody: UpdateScheduleInput_2024_06_11) => boolean | Promise<boolean>;
-  onFormStateChange?: (formState: AvailabilityFormValues) => void;
-  allowDelete?: boolean;
-  allowSetToDefault?: boolean;
-  disableToasts?: boolean;
-  isDryRun?: boolean;
-  noScheduleChildren?: ReactNode;
-  loadingStateChildren?: ReactNode;
-};
-
-export const AvailabilitySettingsPlatformWrapper = forwardRef<
-  AvailabilitySettingsFormRef,
-  AvailabilitySettingsPlatformWrapperProps
->(function AvailabilitySettingsPlatformWrapper(props, ref) {
-  const {
-    id,
-    customClassNames,
-    onDeleteError,
-    onDeleteSuccess,
-    onUpdateError,
-    onUpdateSuccess,
-    disableEditableHeading = false,
-    enableOverrides = false,
-    onBeforeUpdate,
-    onFormStateChange,
-    allowDelete,
-    allowSetToDefault,
-    disableToasts,
-    isDryRun = false,
-    noScheduleChildren,
-    loadingStateChildren,
-  } = props;
-  const { isLoading, data: atomSchedule } = useAtomSchedule(id);
-  const { data: me } = useMe();
-  const { timeFormat } = me?.data || { timeFormat: null };
-  const { toast } = useToast();
-
-  const { mutate: deleteSchedule, isPending: isDeletionInProgress } = useDeleteSchedule({
-    onSuccess: (res) => {
-      onDeleteSuccess?.(res);
-      if (!disableToasts) {
-        toast({
-          description: "Schedule deleted successfully",
-        });
-      }
-    },
-    onError: (err) => {
-      onDeleteError?.(err);
-      if (!disableToasts) {
-        toast({
-          description: "Could not delete schedule",
-        });
-      }
-    },
-  });
-
-  const { mutateAsync: updateSchedule, isPending: isSavingInProgress } = useAtomUpdateSchedule({
-    onSuccess: (res) => {
-      onUpdateSuccess?.(res);
-      if (!disableToasts) {
-        toast({
-          description: "Schedule updated successfully",
-        });
-      }
-    },
-    onError: (err) => {
-      onUpdateError?.(err);
-      if (!disableToasts) {
-        toast({
-          description: "Could not update schedule",
-        });
-      }
-    },
-  });
-
-  const handleDelete = async (id: number) => {
-    await deleteSchedule({ id });
-  };
-
-  const handleUpdate = async (id: number, body: AvailabilityFormValues): Promise<"saved" | "skipped"> => {
-    let canUpdate = true;
-
-    if (onBeforeUpdate) {
-      canUpdate = await onBeforeUpdate(body);
-    }
-
-    if (!canUpdate) {
-      return "skipped";
-    }
-
-    await updateSchedule({
-      scheduleId: id,
-      body: {
-        ...body,
-        dateOverrides: body.dateOverrides.flatMap((override) => override.ranges),
-      },
-    });
-    return "saved";
-  };
-
-  if (isLoading) {
-    return (
-      <>
-        {loadingStateChildren ? loadingStateChildren : <div className="px-10 py-4 text-xl">Loading...</div>}
-      </>
-    );
-  }
-
-  if (!atomSchedule) {
-    return noScheduleChildren ? (
-      <>{noScheduleChildren}</>
-    ) : (
-      <div className="px-10 py-4 text-xl">No user schedule present</div>
-    );
-  }
-
-  return (
-    <AtomsWrapper>
-      <AvailabilitySettings
-        ref={ref}
-        disableEditableHeading={disableEditableHeading}
-        components={{
-          Shell,
-          Schedule: ScheduleComponent,
-          TimezoneSelect: Timezone,
-        }}
-        handleDelete={() => {
-          if (isDryRun) {
-            toast({
-              description: "Schedule deleted successfully",
-            });
-          }
-
-          if (!isDryRun && atomSchedule.id) {
-            handleDelete(atomSchedule.id);
-          }
-        }}
-        handleSubmit={async (data) => {
-          if (isDryRun) {
-            toast({
-              description: "Schedule updated successfully",
-            });
-            return "saved";
-          }
-
-          if (!isDryRun && atomSchedule.id) {
-            return await handleUpdate(atomSchedule.id, data);
-          }
-          return "skipped";
-        }}
-        weekStart={me?.data?.weekStart || "Sunday"}
-        timeFormat={timeFormat}
-        enableOverrides={enableOverrides}
-        isLoading={isLoading}
-        schedule={{
-          name: atomSchedule.name,
-          id: atomSchedule.id,
-          isLastSchedule: atomSchedule.isLastSchedule,
-          isDefault: atomSchedule.isDefault,
-          workingHours: atomSchedule.workingHours,
-          dateOverrides: atomSchedule.dateOverrides,
-          timeZone: atomSchedule.timeZone,
-          availability: atomSchedule.availability,
-          schedule:
-            atomSchedule.schedule.reduce(
-              (acc: Availability[], avail: Availability) => [
-                ...acc,
-                { days: avail.days, startTime: new Date(avail.startTime), endTime: new Date(avail.endTime) },
-              ],
-              []
-            ) || [],
-        }}
-        isDeleting={isDeletionInProgress}
-        isSaving={isSavingInProgress}
-        backPath=""
-        isPlatform={true}
-        customClassNames={customClassNames}
-        allowDelete={allowDelete}
-        allowSetToDefault={allowSetToDefault}
-        onFormStateChange={onFormStateChange}
-        isDryRun={isDryRun}
-      />
-    </AtomsWrapper>
-  );
-});

package/src/booker/Booker.docs.mdx

@@ -1,12 +0,0 @@
-import { Meta, Canvas, ArgsTable } from "@storybook/blocks";
-import { Title } from "@calcom/storybook/components";
-import { BookerWebWrapper as Booker } from "./BookerWebWrapper";
-import * as BookerStories from "./Booker.stories";
-
-<Meta of={BookerStories} />
-
-<Title title="Booker" />
-
-<ArgsTable of={Booker} />
-
-<Canvas of={BookerStories.Default}/>

package/src/booker/__tests__/config.test.ts

@@ -1,58 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { BookerLayouts } from "../../contracts/booker";
-import { fadeInLeft, fadeInRight, fadeInUp, getBookerSizeClassNames, resizeAnimationConfig } from "../config";
-
-describe("booker/config fade presets", () => {
-  it.each([
-    ["fadeInLeft", fadeInLeft],
-    ["fadeInUp", fadeInUp],
-    ["fadeInRight", fadeInRight],
-  ])("%s has visible and hidden variants plus initial/exit/animate keys", (_name, preset) => {
-    expect(preset.variants.visible).toMatchObject({ opacity: 1 });
-    expect(preset.variants.hidden).toMatchObject({ opacity: 0 });
-    expect(preset.initial).toBe("hidden");
-    expect(preset.exit).toBe("hidden");
-    expect(preset.animate).toBe("visible");
-  });
-});
-
-describe("resizeAnimationConfig", () => {
-  it("defines default styles for every layout", () => {
-    expect(resizeAnimationConfig.mobile.default).toBeDefined();
-    expect(resizeAnimationConfig.month_view.default).toBeDefined();
-    expect(resizeAnimationConfig.week_view.default).toBeDefined();
-    expect(resizeAnimationConfig.column_view.default).toBeDefined();
-  });
-
-  it("defines a selecting_time variant for month_view", () => {
-    expect(resizeAnimationConfig.month_view.selecting_time).toBeDefined();
-    expect(resizeAnimationConfig.month_view.selecting_time?.width).toContain("booker-timeslots-width");
-  });
-});
-
-describe("getBookerSizeClassNames", () => {
-  it("returns month_view booking-state class list", () => {
-    const classes = getBookerSizeClassNames(BookerLayouts.MONTH_VIEW, "booking");
-    expect(Array.isArray(classes)).toBe(true);
-    expect(classes.some((c) => c === "[--booker-meta-width:240px]")).toBe(true);
-    expect(classes.some((c) => c && c.includes("[--booker-main-width:420px]"))).toBe(true);
-  });
-
-  it("uses the non-booking width on month_view in other states", () => {
-    const classes = getBookerSizeClassNames(BookerLayouts.MONTH_VIEW, "selecting_date");
-    expect(classes.some((c) => c && c.includes("[--booker-main-width:480px]"))).toBe(true);
-  });
-
-  it("sets meta width to 0px when hideEventTypeDetails is true on month_view booking state", () => {
-    const classes = getBookerSizeClassNames(BookerLayouts.MONTH_VIEW, "booking", true);
-    // PR #1920: explicitly zero meta width so layout collapses correctly
-    expect(classes[1]).toBe("[--booker-meta-width:0px]");
-  });
-
-  it("uses week/column layout widths when layout is not month_view", () => {
-    const week = getBookerSizeClassNames(BookerLayouts.WEEK_VIEW, "selecting_date");
-    const col = getBookerSizeClassNames(BookerLayouts.COLUMN_VIEW, "selecting_date");
-    expect(week.some((c) => c && c.includes("[--booker-main-width:480px]"))).toBe(true);
-    expect(col.some((c) => c && c.includes("[--booker-main-width:480px]"))).toBe(true);
-  });
-});

package/src/booker/__tests__/store-extended.test.ts

@@ -1,349 +0,0 @@
-import { beforeEach, describe, expect, it } from "vitest";
-import { BookerLayouts } from "../../contracts";
-import { createBookerStore } from "../store";
-
-describe("createBookerStore — extended coverage", () => {
-  beforeEach(() => {
-    window.history.replaceState({}, "", "/");
-  });
-
-  describe("setLayout URL behaviour", () => {
-    it("writes the layout query param when not on the platform", () => {
-      const store = createBookerStore();
-      store.getState().setLayout(BookerLayouts.COLUMN_VIEW);
-      expect(new URL(window.location.href).searchParams.get("layout")).toBe(BookerLayouts.COLUMN_VIEW);
-    });
-
-    it("skips writing the query param on the platform without allowUpdatingUrlParams", () => {
-      const store = createBookerStore();
-      store.getState().initialize({
-        username: "a",
-        eventSlug: "s",
-        eventId: 1,
-        layout: BookerLayouts.MONTH_VIEW,
-        isPlatform: true,
-        allowUpdatingUrlParams: false,
-      });
-      store.getState().setLayout(BookerLayouts.COLUMN_VIEW);
-      expect(new URL(window.location.href).searchParams.get("layout")).toBeNull();
-    });
-  });
-
-  describe("setSelectedDate URL behaviour", () => {
-    it("respects omitUpdatingParams and does not write the date param", () => {
-      const store = createBookerStore();
-      store.getState().setSelectedDate({ date: "2030-06-17", omitUpdatingParams: true });
-      expect(store.getState().selectedDate).toBe("2030-06-17");
-      expect(new URL(window.location.href).searchParams.get("date")).toBeNull();
-    });
-
-    it("writes the date param by default", () => {
-      const store = createBookerStore();
-      store.getState().setSelectedDate({ date: "2030-06-17" });
-      expect(new URL(window.location.href).searchParams.get("date")).toBe("2030-06-17");
-    });
-
-    it("writes the month param when the month changes", () => {
-      const store = createBookerStore();
-      store.getState().setSelectedDate({ date: "2030-06-30" });
-      store.getState().setSelectedDate({ date: "2030-07-01" });
-      expect(new URL(window.location.href).searchParams.get("month")).toBe("2030-07");
-    });
-  });
-
-  describe("addToSelectedDate", () => {
-    it("updates the month query param on boundary crossing when not platform-restricted", () => {
-      const store = createBookerStore();
-      const futureYear = new Date().getFullYear() + 2;
-      store.getState().setSelectedDate({ date: `${futureYear}-06-30` });
-      store.getState().addToSelectedDate(1);
-      expect(new URL(window.location.href).searchParams.get("month")).toBe(`${futureYear}-07`);
-    });
-
-    it("does not cross a month boundary when staying in the same month", () => {
-      const store = createBookerStore();
-      const futureYear = new Date().getFullYear() + 2;
-      store.getState().setSelectedDate({ date: `${futureYear}-06-15` });
-      store.getState().addToSelectedDate(1);
-      expect(store.getState().selectedDate).toBe(`${futureYear}-06-16`);
-    });
-  });
-
-  describe("setMonth URL behaviour", () => {
-    it("writes the month query param", () => {
-      const store = createBookerStore();
-      store.getState().setMonth("2030-06");
-      expect(new URL(window.location.href).searchParams.get("month")).toBe("2030-06");
-    });
-  });
-
-  describe("setSeatedEventData", () => {
-    it("writes bookingUid to the query param", () => {
-      const store = createBookerStore();
-      store.getState().setSeatedEventData({
-        seatsPerTimeSlot: 5,
-        attendees: 2,
-        bookingUid: "seated-abc",
-        showAvailableSeatsCount: true,
-      });
-      expect(new URL(window.location.href).searchParams.get("bookingUid")).toBe("seated-abc");
-    });
-
-    it("clears the bookingUid param when no uid is provided", () => {
-      window.history.replaceState({}, "", "/?bookingUid=prev");
-      const store = createBookerStore();
-      store.getState().setSeatedEventData({
-        seatsPerTimeSlot: 5,
-        attendees: 2,
-        bookingUid: undefined,
-        showAvailableSeatsCount: true,
-      });
-      expect(new URL(window.location.href).searchParams.get("bookingUid")).toBeNull();
-    });
-  });
-
-  describe("setSelectedTimeslot", () => {
-    it("writes the slot query param", () => {
-      const store = createBookerStore();
-      store.getState().setSelectedTimeslot("2030-06-17T10:00:00Z");
-      expect(store.getState().selectedTimeslot).toBe("2030-06-17T10:00:00Z");
-      expect(new URL(window.location.href).searchParams.get("slot")).toBe("2030-06-17T10:00:00Z");
-    });
-
-    it("accepts null and clears the slot", () => {
-      const store = createBookerStore();
-      store.getState().setSelectedTimeslot("x");
-      store.getState().setSelectedTimeslot(null);
-      expect(store.getState().selectedTimeslot).toBeNull();
-    });
-  });
-
-  describe("setSelectedDuration writes the duration query param", () => {
-    it("persists a numeric duration", () => {
-      const store = createBookerStore();
-      store.getState().setSelectedDuration(45);
-      expect(new URL(window.location.href).searchParams.get("duration")).toBe("45");
-    });
-  });
-
-  describe("setTentativeSelectedTimeslots", () => {
-    it("replaces the tentative-slots array", () => {
-      const store = createBookerStore();
-      store.getState().setTentativeSelectedTimeslots(["a", "b"]);
-      expect(store.getState().tentativeSelectedTimeslots).toEqual(["a", "b"]);
-    });
-  });
-
-  describe("setFormValues", () => {
-    it("replaces the form values map", () => {
-      const store = createBookerStore();
-      store.getState().setFormValues({ name: "Alice", email: "alice@example.com" });
-      expect(store.getState().formValues).toEqual({
-        name: "Alice",
-        email: "alice@example.com",
-      });
-    });
-  });
-
-  describe("setOrg", () => {
-    it("accepts strings, null, and undefined", () => {
-      const store = createBookerStore();
-      store.getState().setOrg("cal");
-      expect(store.getState().org).toBe("cal");
-      store.getState().setOrg(null);
-      expect(store.getState().org).toBeNull();
-      store.getState().setOrg(undefined);
-      expect(store.getState().org).toBeUndefined();
-    });
-  });
-
-  describe("setRescheduleUid", () => {
-    it("stores the reschedule uid", () => {
-      const store = createBookerStore();
-      store.getState().setRescheduleUid("reschedule-123");
-      expect(store.getState().rescheduleUid).toBe("reschedule-123");
-      store.getState().setRescheduleUid(null);
-      expect(store.getState().rescheduleUid).toBeNull();
-    });
-  });
-
-  describe("setRecurringEventCount", () => {
-    it("stores an integer count", () => {
-      const store = createBookerStore();
-      store.getState().setRecurringEventCount(3);
-      expect(store.getState().recurringEventCount).toBe(3);
-      store.getState().setRecurringEventCount(null);
-      expect(store.getState().recurringEventCount).toBeNull();
-    });
-  });
-
-  describe("setRecurringEventCountQueryParam", () => {
-    it("ignores null values", () => {
-      const store = createBookerStore();
-      store.getState().setRecurringEventCountQueryParam(null);
-      expect(store.getState().recurringEventCountQueryParam).toBeNull();
-      expect(new URL(window.location.href).searchParams.get("recurringEventCount")).toBeNull();
-    });
-
-    it("ignores NaN values", () => {
-      const store = createBookerStore();
-      store.getState().setRecurringEventCountQueryParam(Number.NaN);
-      expect(new URL(window.location.href).searchParams.get("recurringEventCount")).toBeNull();
-    });
-
-    it("writes a valid integer to the query param", () => {
-      const store = createBookerStore();
-      store.getState().setRecurringEventCountQueryParam(4);
-      expect(store.getState().recurringEventCountQueryParam).toBe(4);
-      expect(new URL(window.location.href).searchParams.get("recurringEventCount")).toBe("4");
-    });
-  });
-
-  describe("setIsSlotSelectionModalVisible", () => {
-    it("toggles the slot-selection modal flag", () => {
-      const store = createBookerStore();
-      store.getState().setIsSlotSelectionModalVisible(true);
-      expect(store.getState().isSlotSelectionModalVisible).toBe(true);
-      store.getState().setIsSlotSelectionModalVisible(false);
-      expect(store.getState().isSlotSelectionModalVisible).toBe(false);
-    });
-  });
-
-  describe("initialize edge cases", () => {
-    it("clears selectedTimeslot when rescheduleUid + bookingData are provided", () => {
-      const store = createBookerStore();
-      store.getState().setSelectedTimeslot("2030-06-17T10:00:00Z");
-      store.getState().initialize({
-        username: "alice",
-        eventSlug: "30min",
-        eventId: 1,
-        layout: BookerLayouts.MONTH_VIEW,
-        rescheduleUid: "abc",
-        bookingData: { responses: { email: "x@y.com" } },
-      });
-      expect(store.getState().selectedTimeslot).toBeNull();
-    });
-
-    it("falls back to MONTH_VIEW when layout is empty", () => {
-      const store = createBookerStore();
-      store.getState().initialize({
-        username: "alice",
-        eventSlug: "30min",
-        eventId: 1,
-        layout: undefined,
-      });
-      expect(store.getState().layout).toBe(BookerLayouts.MONTH_VIEW);
-    });
-
-    it("picks the first durationConfig entry when reschedule + booking duration cannot be derived", () => {
-      const store = createBookerStore();
-      store.getState().initialize({
-        username: "alice",
-        eventSlug: "30min",
-        eventId: 1,
-        layout: BookerLayouts.MONTH_VIEW,
-        rescheduleUid: "abc",
-        bookingData: {
-          startTime: "",
-          endTime: "",
-          responses: { email: "x@y.com" },
-        },
-        durationConfig: [15, 30, 60],
-      });
-      expect(store.getState().selectedDuration).toBe(15);
-    });
-
-    it("picks the duration from the query param when it is in durationConfig", () => {
-      window.history.replaceState({}, "", "/?duration=60");
-      const store = createBookerStore();
-      store.getState().initialize({
-        username: "alice",
-        eventSlug: "30min",
-        eventId: 1,
-        layout: BookerLayouts.MONTH_VIEW,
-        durationConfig: [15, 30, 60],
-      });
-      expect(store.getState().selectedDuration).toBe(60);
-    });
-
-    it("removes the duration query param when no matching duration is found", () => {
-      window.history.replaceState({}, "", "/?duration=99");
-      const store = createBookerStore();
-      store.getState().initialize({
-        username: "alice",
-        eventSlug: "30min",
-        eventId: 1,
-        layout: BookerLayouts.MONTH_VIEW,
-      });
-      expect(new URL(window.location.href).searchParams.get("duration")).toBeNull();
-    });
-
-    it("preserves selectedDate when already set", () => {
-      const store = createBookerStore();
-      store.getState().setSelectedDate({ date: "2030-06-17" });
-      store.getState().initialize({
-        username: "alice",
-        eventSlug: "30min",
-        eventId: 1,
-        layout: BookerLayouts.WEEK_VIEW,
-      });
-      expect(store.getState().selectedDate).toBe("2030-06-17");
-    });
-
-    it("persists platform + allowUpdatingUrlParams flags", () => {
-      const store = createBookerStore();
-      store.getState().initialize({
-        username: "alice",
-        eventSlug: "30min",
-        eventId: 1,
-        layout: BookerLayouts.MONTH_VIEW,
-        isPlatform: true,
-        allowUpdatingUrlParams: false,
-        defaultPhoneCountry: "us",
-      });
-      const state = store.getState();
-      expect(state.isPlatform).toBe(true);
-      expect(state.allowUpdatingUrlParams).toBe(false);
-      expect(state.defaultPhoneCountry).toBe("us");
-    });
-
-    it("persists team/crm context fields", () => {
-      const store = createBookerStore();
-      store.getState().initialize({
-        username: "alice",
-        eventSlug: "30min",
-        eventId: 1,
-        layout: BookerLayouts.MONTH_VIEW,
-        isTeamEvent: true,
-        teamMemberEmail: "bob@example.com",
-        crmOwnerRecordType: "Contact",
-        crmAppSlug: "salesforce",
-        crmRecordId: "0034",
-        pendingCrmTraceId: "trace-x",
-        org: "cal",
-      });
-      const state = store.getState();
-      expect(state.isTeamEvent).toBe(true);
-      expect(state.teamMemberEmail).toBe("bob@example.com");
-      expect(state.crmOwnerRecordType).toBe("Contact");
-      expect(state.crmAppSlug).toBe("salesforce");
-      expect(state.crmRecordId).toBe("0034");
-      expect(state.pendingCrmTraceId).toBe("trace-x");
-      expect(state.org).toBe("cal");
-    });
-
-    it("does not update the duration query param on the platform when updates are disabled", () => {
-      const store = createBookerStore();
-      store.getState().initialize({
-        username: "alice",
-        eventSlug: "30min",
-        eventId: 1,
-        layout: BookerLayouts.MONTH_VIEW,
-        isPlatform: true,
-        allowUpdatingUrlParams: false,
-      });
-      store.getState().setSelectedDuration(30);
-      expect(new URL(window.location.href).searchParams.get("duration")).toBeNull();
-    });
-  });
-});