@calcom/atoms 2.8.0 → 2.8.2

package/src/booker/config.ts

@@ -1,206 +0,0 @@
-// @ts-nocheck — framer-motion styles indexing by CSSProperty
-"use client";
-
-import { cubicBezier, useAnimate, useReducedMotion } from "framer-motion";
-import { useEffect } from "react";
-
-import { type BookerLayout, BookerLayouts, type BookerState } from "../contracts/booker";
-
-export const fadeInLeft = {
-  variants: {
-    visible: { opacity: 1, x: 0 },
-    hidden: { opacity: 0, x: 20 },
-  },
-  initial: "hidden",
-  exit: "hidden",
-  animate: "visible",
-  transition: { ease: "easeInOut", delay: 0.1 },
-};
-
-export const fadeInUp = {
-  variants: {
-    visible: { opacity: 1, y: 0 },
-    hidden: { opacity: 0, y: 20 },
-  },
-  initial: "hidden",
-  exit: "hidden",
-  animate: "visible",
-  transition: { ease: "easeInOut", delay: 0.1 },
-};
-
-export const fadeInRight = {
-  variants: {
-    visible: { opacity: 1, x: 0 },
-    hidden: { opacity: 0, x: -20 },
-  },
-  initial: "hidden",
-  exit: "hidden",
-  animate: "visible",
-  transition: { ease: "easeInOut", delay: 0.1 },
-};
-
-type ResizeAnimationConfig = {
-  [key in BookerLayout]: {
-    [key in BookerState | "default"]?: React.CSSProperties;
-  };
-};
-
-export const resizeAnimationConfig: ResizeAnimationConfig = {
-  mobile: {
-    default: {
-      width: "100%",
-      minHeight: "0px",
-      gridTemplateAreas: `
-          "meta"
-          "header"
-          "main"
-          "timeslots"
-        `,
-      gridTemplateColumns: "100%",
-      gridTemplateRows: "minmax(min-content,max-content) 1fr",
-    },
-  },
-  month_view: {
-    default: {
-      width: "calc(var(--booker-meta-width) + var(--booker-main-width))",
-      minHeight: "450px",
-      height: "auto",
-      gridTemplateAreas: `
-      "meta main main"
-      "meta main main"
-      `,
-      gridTemplateColumns: "var(--booker-meta-width) var(--booker-main-width)",
-      gridTemplateRows: "1fr 0fr",
-    },
-    selecting_time: {
-      width: "calc(var(--booker-meta-width) + var(--booker-main-width) + var(--booker-timeslots-width))",
-      minHeight: "450px",
-      height: "auto",
-      gridTemplateAreas: `
-      "meta main timeslots"
-      "meta main timeslots"
-      `,
-      gridTemplateColumns: "var(--booker-meta-width) 1fr var(--booker-timeslots-width)",
-      gridTemplateRows: "1fr 0fr",
-    },
-  },
-  week_view: {
-    default: {
-      width: "100vw",
-      minHeight: "100vh",
-      height: "auto",
-      gridTemplateAreas: `
-      "meta header header"
-      "meta main main"
-      `,
-      gridTemplateColumns: "var(--booker-meta-width) 1fr",
-      gridTemplateRows: "70px auto",
-    },
-  },
-  column_view: {
-    default: {
-      width: "100vw",
-      minHeight: "100vh",
-      height: "auto",
-      gridTemplateAreas: `
-      "meta header header"
-      "meta main main"
-      `,
-      gridTemplateColumns: "var(--booker-meta-width) 1fr",
-      gridTemplateRows: "70px auto",
-    },
-  },
-};
-
-export const getBookerSizeClassNames = (
-  layout: BookerLayout,
-  bookerState: BookerState,
-  hideEventTypeDetails = false
-) => {
-  const getBookerMetaClass = (className: string) => {
-    if (hideEventTypeDetails) return "";
-    return className;
-  };
-
-  return [
-    "[--booker-timeslots-width:240px] lg:[--booker-timeslots-width:280px]",
-    layout === BookerLayouts.MONTH_VIEW &&
-      (hideEventTypeDetails ? "[--booker-meta-width:0px]" : "[--booker-meta-width:240px]"),
-    layout === BookerLayouts.MONTH_VIEW &&
-      bookerState === "booking" &&
-      `[--booker-main-width:420px] ${getBookerMetaClass("lg:[--booker-meta-width:340px]")}`,
-    layout === BookerLayouts.MONTH_VIEW &&
-      bookerState !== "booking" &&
-      `[--booker-main-width:480px] ${getBookerMetaClass("lg:[--booker-meta-width:280px]")}`,
-    layout !== BookerLayouts.MONTH_VIEW &&
-      `[--booker-main-width:480px] [--booker-meta-width:340px] ${getBookerMetaClass(
-        "lg:[--booker-meta-width:424px]"
-      )}`,
-  ];
-};
-
-export const useBookerResizeAnimation = (layout: BookerLayout, state: BookerState) => {
-  const prefersReducedMotion = useReducedMotion();
-  const [animationScope, animate] = useAnimate();
-  const isEmbed = typeof window !== "undefined" && window?.isEmbed?.();
-
-  useEffect(() => {
-    const animationConfig = resizeAnimationConfig[layout][state] || resizeAnimationConfig[layout].default;
-
-    if (!animationScope.current) return;
-
-    const animatedProperties = {
-      height: animationConfig?.height || "auto",
-    };
-
-    const nonAnimatedProperties = {
-      gridTemplateAreas: animationConfig?.gridTemplateAreas,
-      width: animationConfig?.width || "auto",
-      gridTemplateColumns: animationConfig?.gridTemplateColumns,
-      gridTemplateRows: animationConfig?.gridTemplateRows,
-      minHeight: animationConfig?.minHeight,
-    };
-
-    if (prefersReducedMotion || layout === "mobile" || isEmbed) {
-      const styles = { ...nonAnimatedProperties, ...animatedProperties };
-      Object.keys(styles).forEach((property) => {
-        if (property === "height") {
-          animationScope.current.style.height =
-            animatedProperties.height === "100vh" && isEmbed ? "100%" : animatedProperties.height;
-        } else {
-          animationScope.current.style[property] = styles[property as keyof typeof styles];
-        }
-      });
-    } else {
-      Object.keys(nonAnimatedProperties).forEach((property) => {
-        animationScope.current.style[property] =
-          nonAnimatedProperties[property as keyof typeof nonAnimatedProperties];
-      });
-      animate(animationScope.current, animatedProperties, {
-        duration: 0.5,
-        ease: cubicBezier(0.4, 0, 0.2, 1),
-      });
-    }
-  }, [animate, isEmbed, animationScope, layout, prefersReducedMotion, state]);
-
-  return animationScope;
-};
-
-export const extraDaysConfig = {
-  mobile: {
-    desktop: 0,
-    tablet: 0,
-  },
-  [BookerLayouts.MONTH_VIEW]: {
-    desktop: 0,
-    tablet: 0,
-  },
-  [BookerLayouts.WEEK_VIEW]: {
-    desktop: 7,
-    tablet: 4,
-  },
-  [BookerLayouts.COLUMN_VIEW]: {
-    desktop: 6,
-    tablet: 2,
-  },
-};

package/src/booker/export.ts

@@ -1,5 +0,0 @@
-/** Export file is only used for building the dist version of this Atom. */
-// import "../globals.css";
-
-export * from "../types";
-export { BookerWebWrapper as Booker } from "./BookerWebWrapper";

package/src/booker/framer-features.ts

@@ -1,3 +0,0 @@
-import { domAnimation } from "framer-motion";
-
-export default domAnimation;

package/src/booker/hooks/__tests__/use-booker-layout.test.tsx

@@ -1,98 +0,0 @@
-import { renderHook } from "@testing-library/react";
-import type { ReactNode } from "react";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { BookerStoreProvider } from "../../booker-store-provider";
-import { useBookerLayout } from "../use-booker-layout";
-
-function installMatchMedia(matches: (query: string) => boolean) {
-  window.matchMedia = vi.fn().mockImplementation((query: string) => ({
-    matches: matches(query),
-    media: query,
-    addEventListener: vi.fn(),
-    removeEventListener: vi.fn(),
-    addListener: vi.fn(),
-    removeListener: vi.fn(),
-    dispatchEvent: vi.fn(),
-    onchange: null,
-  })) as unknown as typeof window.matchMedia;
-}
-
-const Wrapper = ({ children }: { children: ReactNode }) => (
-  <BookerStoreProvider>{children}</BookerStoreProvider>
-);
-
-describe("useBookerLayout", () => {
-  beforeEach(() => {
-    window.history.replaceState({}, "", "/");
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  it("returns desktop values when neither mobile nor tablet viewports match", () => {
-    installMatchMedia(() => false);
-    const { result } = renderHook(() => useBookerLayout(null), { wrapper: Wrapper });
-    expect(result.current.isMobile).toBe(false);
-    expect(result.current.isTablet).toBe(false);
-    expect(result.current.isEmbed).toBe(false);
-    expect(result.current.hasDarkBackground).toBe(false);
-    expect(typeof result.current.extraDays).toBe("number");
-  });
-
-  it("reports mobile when the max-width:768px query matches", () => {
-    installMatchMedia((q) => q === "(max-width: 768px)" || q === "(max-width: 1024px)");
-    const { result } = renderHook(() => useBookerLayout(null), { wrapper: Wrapper });
-    expect(result.current.isMobile).toBe(true);
-    expect(result.current.isTablet).toBe(true);
-  });
-
-  it("uses profileBookerLayouts.defaultLayout when provided", () => {
-    installMatchMedia(() => false);
-    const profileLayouts = {
-      defaultLayout: "week_view" as const,
-      enabledLayouts: ["week_view", "month_view", "column_view"],
-    };
-    const { result } = renderHook(() => useBookerLayout(profileLayouts), { wrapper: Wrapper });
-    expect(result.current.defaultLayout).toBe("week_view");
-    expect(result.current.bookerLayouts).toEqual(profileLayouts);
-  });
-
-  it("falls back to default booker layout settings when the profile setting is null", () => {
-    installMatchMedia(() => false);
-    const { result } = renderHook(() => useBookerLayout(null), { wrapper: Wrapper });
-    expect(result.current.bookerLayouts).toBeDefined();
-    expect(result.current.bookerLayouts.defaultLayout).toBeDefined();
-  });
-
-  it("respects the hideEventTypeDetails query param when set to 'true'", () => {
-    installMatchMedia(() => false);
-    window.history.replaceState({}, "", "/?hideEventTypeDetails=true");
-    const { result } = renderHook(() => useBookerLayout(null), { wrapper: Wrapper });
-    expect(result.current.hideEventTypeDetails).toBe(true);
-  });
-
-  it("treats the hideEventTypeDetails query param as false when not exactly 'true'", () => {
-    installMatchMedia(() => false);
-    window.history.replaceState({}, "", "/?hideEventTypeDetails=yes");
-    const { result } = renderHook(() => useBookerLayout(null), { wrapper: Wrapper });
-    expect(result.current.hideEventTypeDetails).toBe(false);
-  });
-
-  it("returns false for hideEventTypeDetails when the query param is absent", () => {
-    installMatchMedia(() => false);
-    const { result } = renderHook(() => useBookerLayout(null), { wrapper: Wrapper });
-    expect(result.current.hideEventTypeDetails).toBe(false);
-  });
-
-  it("hides the form in a dialog in month view on desktop", () => {
-    installMatchMedia(() => false);
-    const { result } = renderHook(() => useBookerLayout(null), { wrapper: Wrapper });
-    expect(result.current.shouldShowFormInDialog).toBe(false);
-  });
-
-  it("throws when used outside BookerStoreProvider", () => {
-    installMatchMedia(() => false);
-    expect(() => renderHook(() => useBookerLayout(null))).toThrow(/BookerStoreProvider/);
-  });
-});

package/src/booker/hooks/__tests__/use-check-overlap-with-overlay.test.ts

@@ -1,95 +0,0 @@
-import { renderHook } from "@testing-library/react";
-import { beforeEach, describe, expect, it } from "vitest";
-import dayjs from "../../../vendor/dayjs";
-import { useOverlayCalendarStore } from "../../components/overlay-calendar/store";
-import { useCheckOverlapWithOverlay } from "../use-check-overlap-with-overlay";
-
-describe("useCheckOverlapWithOverlay", () => {
-  beforeEach(() => {
-    useOverlayCalendarStore.setState({ overlayBusyDates: undefined });
-  });
-
-  it("returns undefined isOverlapping when no overlay busy dates are set", () => {
-    const { result } = renderHook(() =>
-      useCheckOverlapWithOverlay({
-        start: dayjs("2030-06-17T10:00:00Z"),
-        selectedDuration: 30,
-        offset: 0,
-      })
-    );
-    expect(result.current.isOverlapping).toBeUndefined();
-    expect(result.current.overlappingTimeStart).toBeNull();
-    expect(result.current.overlappingTimeEnd).toBeNull();
-  });
-
-  it("returns false isOverlapping when busy dates array is empty", () => {
-    useOverlayCalendarStore.setState({ overlayBusyDates: [] });
-    const { result } = renderHook(() =>
-      useCheckOverlapWithOverlay({
-        start: dayjs("2030-06-17T10:00:00Z"),
-        selectedDuration: 30,
-        offset: 0,
-      })
-    );
-    expect(result.current.isOverlapping).toBe(false);
-  });
-
-  it("returns false isOverlapping when the selected slot ends before the busy start", () => {
-    useOverlayCalendarStore.setState({
-      overlayBusyDates: [{ start: "2030-06-17T12:00:00Z", end: "2030-06-17T13:00:00Z" }],
-    });
-    const { result } = renderHook(() =>
-      useCheckOverlapWithOverlay({
-        start: dayjs("2030-06-17T10:00:00Z"),
-        selectedDuration: 30,
-        offset: 0,
-      })
-    );
-    expect(result.current.isOverlapping).toBe(false);
-    expect(result.current.overlappingTimeStart).toBeNull();
-  });
-
-  it("returns true isOverlapping when the selected slot overlaps with a busy block", () => {
-    useOverlayCalendarStore.setState({
-      overlayBusyDates: [{ start: "2030-06-17T10:15:00Z", end: "2030-06-17T11:00:00Z" }],
-    });
-    const { result } = renderHook(() =>
-      useCheckOverlapWithOverlay({
-        start: dayjs("2030-06-17T10:00:00Z"),
-        selectedDuration: 60,
-        offset: 0,
-      })
-    );
-    expect(result.current.isOverlapping).toBe(true);
-    expect(result.current.overlappingTimeStart).toMatch(/^\d{2}:\d{2}$/);
-    expect(result.current.overlappingTimeEnd).toMatch(/^\d{2}:\d{2}$/);
-  });
-
-  it("handles a zero selected duration without throwing", () => {
-    useOverlayCalendarStore.setState({
-      overlayBusyDates: [{ start: "2030-06-17T10:00:00Z", end: "2030-06-17T11:00:00Z" }],
-    });
-    const { result } = renderHook(() =>
-      useCheckOverlapWithOverlay({
-        start: dayjs("2030-06-17T10:00:00Z"),
-        selectedDuration: null,
-        offset: 0,
-      })
-    );
-    expect(typeof result.current.isOverlapping).toBe("boolean");
-  });
-
-  it("respects the offset parameter when checking overlaps", () => {
-    useOverlayCalendarStore.setState({
-      overlayBusyDates: [{ start: "2030-06-17T12:00:00Z", end: "2030-06-17T13:00:00Z" }],
-    });
-    const { result } = renderHook(() =>
-      useCheckOverlapWithOverlay({
-        start: dayjs("2030-06-17T10:00:00Z"),
-        selectedDuration: 60,
-        offset: 2,
-      })
-    );
-    expect(result.current.isOverlapping).toBe(true);
-  });
-});

package/src/booker/hooks/__tests__/use-local-set.test.tsx

@@ -1,72 +0,0 @@
-import { act, renderHook } from "@testing-library/react";
-import { beforeEach, describe, expect, it } from "vitest";
-import { useLocalSet } from "../use-local-set";
-
-type Item = { externalId: string; label: string };
-
-describe("useLocalSet", () => {
-  beforeEach(() => {
-    window.localStorage.clear();
-  });
-
-  it("initializes from localStorage when a value is present", () => {
-    window.localStorage.setItem("cal.overlay", JSON.stringify([{ externalId: "a", label: "A" }]));
-    const { result } = renderHook(() => useLocalSet<Item>("cal.overlay", []));
-    expect(Array.from(result.current.set)).toEqual([{ externalId: "a", label: "A" }]);
-  });
-
-  it("falls back to initialValue when storage is empty", () => {
-    const initial = [{ externalId: "x", label: "X" }];
-    const { result } = renderHook(() => useLocalSet<Item>("cal.overlay", initial));
-    expect(Array.from(result.current.set)).toEqual(initial);
-  });
-
-  it("addValue appends and persists to localStorage", () => {
-    const { result } = renderHook(() => useLocalSet<Item>("cal.overlay", []));
-    act(() => result.current.addValue({ externalId: "1", label: "One" }));
-    expect(Array.from(result.current.set)).toEqual([{ externalId: "1", label: "One" }]);
-    expect(window.localStorage.getItem("cal.overlay")).toBe(
-      JSON.stringify([{ externalId: "1", label: "One" }])
-    );
-  });
-
-  it("removeById removes by externalId", () => {
-    const { result } = renderHook(() =>
-      useLocalSet<Item>("cal.overlay", [
-        { externalId: "1", label: "One" },
-        { externalId: "2", label: "Two" },
-      ])
-    );
-    act(() => result.current.removeById("1"));
-    expect(Array.from(result.current.set)).toEqual([{ externalId: "2", label: "Two" }]);
-  });
-
-  it("toggleValue adds a new item and removes an existing one by id", () => {
-    const { result } = renderHook(() => useLocalSet<Item>("cal.overlay", []));
-    act(() => {
-      result.current.toggleValue({ externalId: "1", label: "One" });
-    });
-    expect(Array.from(result.current.set)).toEqual([{ externalId: "1", label: "One" }]);
-    act(() => {
-      result.current.toggleValue({ externalId: "1", label: "One-alt" });
-    });
-    expect(Array.from(result.current.set)).toEqual([]);
-  });
-
-  it("hasItem matches by externalId", () => {
-    const { result } = renderHook(() =>
-      useLocalSet<Item>("cal.overlay", [{ externalId: "1", label: "One" }])
-    );
-    expect(result.current.hasItem({ externalId: "1", label: "any" })).toBe(true);
-    expect(result.current.hasItem({ externalId: "2", label: "any" })).toBe(false);
-  });
-
-  it("clearSet empties the set", () => {
-    window.localStorage.setItem("cal.overlay", JSON.stringify([{ externalId: "a", label: "A" }]));
-    const { result } = renderHook(() => useLocalSet<Item>("cal.overlay", []));
-    act(() => result.current.clearSet());
-    expect(Array.from(result.current.set)).toEqual([]);
-    // The effect re-persists the now-empty set, so the key ends up as "[]".
-    expect(window.localStorage.getItem("cal.overlay")).toBe("[]");
-  });
-});

package/src/booker/hooks/__tests__/use-non-empty-schedule-days.test.tsx

@@ -1,37 +0,0 @@
-import { renderHook } from "@testing-library/react";
-import { describe, expect, it } from "vitest";
-import { useNonEmptyScheduleDays } from "../use-non-empty-schedule-days";
-
-describe("useNonEmptyScheduleDays", () => {
-  it("returns empty array when slots is undefined", () => {
-    const { result } = renderHook(() => useNonEmptyScheduleDays(undefined));
-    expect(result.current).toEqual([]);
-  });
-
-  it("returns dates that have at least one normal slot", () => {
-    const slots = {
-      "2024-06-17": [{ time: "10:00" }],
-      "2024-06-18": [],
-    };
-    const { result } = renderHook(() => useNonEmptyScheduleDays(slots as never));
-    expect(result.current).toContain("2024-06-17");
-    expect(result.current).not.toContain("2024-06-18");
-  });
-
-  it("excludes days where every slot is away-only without toUser or public note", () => {
-    const slots = {
-      "2024-06-17": [{ time: "10:00", away: true, toUser: null, showNotePublicly: false }],
-    };
-    const { result } = renderHook(() => useNonEmptyScheduleDays(slots as never));
-    expect(result.current).toEqual([]);
-  });
-
-  it("includes days where away slots have a toUser (forwarded) or a public note", () => {
-    const slots = {
-      "2024-06-17": [{ time: "10:00", away: true, toUser: { id: 1 }, showNotePublicly: false }],
-      "2024-06-18": [{ time: "10:00", away: true, toUser: null, showNotePublicly: true }],
-    };
-    const { result } = renderHook(() => useNonEmptyScheduleDays(slots as never));
-    expect(result.current).toEqual(expect.arrayContaining(["2024-06-17", "2024-06-18"]));
-  });
-});

package/src/booker/hooks/__tests__/use-overlay-calendar.test.tsx

@@ -1,122 +0,0 @@
-import { act, renderHook } from "@testing-library/react";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { useOverlayCalendarStore } from "../../components/overlay-calendar/store";
-import { useOverlayCalendar } from "../use-overlay-calendar";
-
-describe("useOverlayCalendar", () => {
-  beforeEach(() => {
-    localStorage.clear();
-    useOverlayCalendarStore.setState({
-      overlayBusyDates: undefined,
-      continueWithProviderModal: false,
-      calendarSettingsOverlayModal: false,
-    });
-  });
-
-  it("exposes the modal flags from the overlay store", () => {
-    useOverlayCalendarStore.setState({
-      continueWithProviderModal: true,
-      calendarSettingsOverlayModal: false,
-    });
-    const onToggleCalendar = vi.fn();
-    const { result } = renderHook(() =>
-      useOverlayCalendar({
-        connectedCalendars: [],
-        onToggleCalendar,
-      })
-    );
-    expect(result.current.isOpenOverlayContinueModal).toBe(true);
-    expect(result.current.isOpenOverlaySettingsModal).toBe(false);
-  });
-
-  it("handleCloseContinueModal writes back to the store", () => {
-    const onToggleCalendar = vi.fn();
-    const { result } = renderHook(() => useOverlayCalendar({ connectedCalendars: [], onToggleCalendar }));
-    act(() => {
-      result.current.handleCloseContinueModal(true);
-    });
-    expect(useOverlayCalendarStore.getState().continueWithProviderModal).toBe(true);
-  });
-
-  it("handleCloseSettingsModal writes back to the store", () => {
-    const onToggleCalendar = vi.fn();
-    const { result } = renderHook(() => useOverlayCalendar({ connectedCalendars: [], onToggleCalendar }));
-    act(() => {
-      result.current.handleCloseSettingsModal(true);
-    });
-    expect(useOverlayCalendarStore.getState().calendarSettingsOverlayModal).toBe(true);
-  });
-
-  it("initialises with primary connected calendars toggled on", () => {
-    const onToggleCalendar = vi.fn();
-    const { result } = renderHook(() =>
-      useOverlayCalendar({
-        connectedCalendars: [
-          {
-            credentialId: 1,
-            calendars: [
-              { externalId: "primary@cal.com", primary: true },
-              { externalId: "secondary@cal.com", primary: false },
-            ],
-          },
-        ],
-        onToggleCalendar,
-      })
-    );
-    expect(result.current.checkIsCalendarToggled("primary@cal.com", 1)).toBe(true);
-    expect(result.current.checkIsCalendarToggled("secondary@cal.com", 1)).toBe(false);
-  });
-
-  it("handleToggleConnectedCalendar toggles membership and notifies the callback", () => {
-    const onToggleCalendar = vi.fn();
-    const { result } = renderHook(() =>
-      useOverlayCalendar({
-        connectedCalendars: [
-          {
-            credentialId: 7,
-            calendars: [{ externalId: "x@cal.com", primary: true }],
-          },
-        ],
-        onToggleCalendar,
-      })
-    );
-    expect(result.current.checkIsCalendarToggled("x@cal.com", 7)).toBe(true);
-    act(() => {
-      result.current.handleToggleConnectedCalendar("x@cal.com", 7);
-    });
-    expect(result.current.checkIsCalendarToggled("x@cal.com", 7)).toBe(false);
-    expect(onToggleCalendar).toHaveBeenCalledTimes(1);
-  });
-
-  it("applies the timezone offset when storing overlay busy dates", () => {
-    const onToggleCalendar = vi.fn();
-    const now = new Date("2030-06-17T10:00:00.000Z");
-    const busy = [{ start: now.toISOString(), end: new Date(now.getTime() + 3600_000).toISOString() }];
-    renderHook(() =>
-      useOverlayCalendar({
-        connectedCalendars: [],
-        overlayBusyDates: busy,
-        onToggleCalendar,
-      })
-    );
-    const stored = useOverlayCalendarStore.getState().overlayBusyDates;
-    expect(stored).toBeDefined();
-    expect(stored).toHaveLength(1);
-  });
-
-  it("skips initialisation when no connected calendars with primary are provided", () => {
-    const onToggleCalendar = vi.fn();
-    const { result } = renderHook(() =>
-      useOverlayCalendar({
-        connectedCalendars: [
-          {
-            credentialId: 1,
-            calendars: [],
-          },
-        ],
-        onToggleCalendar,
-      })
-    );
-    expect(result.current.checkIsCalendarToggled("anything", 1)).toBe(false);
-  });
-});

package/src/booker/hooks/__tests__/use-should-show-arrows.test.tsx

@@ -1,45 +0,0 @@
-import { act, renderHook } from "@testing-library/react";
-import type { UIEvent } from "react";
-import { describe, expect, it } from "vitest";
-import { useShouldShowArrows } from "../use-should-show-arrows";
-
-function makeEvent(props: { scrollLeft: number; scrollWidth: number; clientWidth: number }) {
-  return {
-    currentTarget: props,
-  } as unknown as UIEvent<HTMLUListElement>;
-}
-
-describe("useShouldShowArrows", () => {
-  it("starts with both arrows hidden", () => {
-    const { result } = renderHook(() => useShouldShowArrows());
-    expect(result.current.leftVisible).toBe(false);
-    expect(result.current.rightVisible).toBe(false);
-  });
-
-  it("calculateScroll shows the right arrow when not at the end", () => {
-    const { result } = renderHook(() => useShouldShowArrows());
-    act(() => {
-      result.current.calculateScroll(makeEvent({ scrollLeft: 0, scrollWidth: 1000, clientWidth: 500 }));
-    });
-    expect(result.current.leftVisible).toBe(false);
-    expect(result.current.rightVisible).toBe(true);
-  });
-
-  it("calculateScroll shows the left arrow when scrolled", () => {
-    const { result } = renderHook(() => useShouldShowArrows());
-    act(() => {
-      result.current.calculateScroll(makeEvent({ scrollLeft: 200, scrollWidth: 1000, clientWidth: 500 }));
-    });
-    expect(result.current.leftVisible).toBe(true);
-    expect(result.current.rightVisible).toBe(true);
-  });
-
-  it("calculateScroll hides the right arrow at the end", () => {
-    const { result } = renderHook(() => useShouldShowArrows());
-    act(() => {
-      result.current.calculateScroll(makeEvent({ scrollLeft: 500, scrollWidth: 1000, clientWidth: 500 }));
-    });
-    expect(result.current.leftVisible).toBe(true);
-    expect(result.current.rightVisible).toBe(false);
-  });
-});