@calcom/atoms 2.7.2 → 2.8.1

package/src/troubleshooter/wrappers/troubleshooter-platform-wrapper.tsx

@@ -1,89 +0,0 @@
-import { BookerStoreProvider } from "../../booker/booker-store-provider";
-import { AtomsWrapper } from "../../components/atoms-wrapper";
-import { cn } from "../../lib/utils";
-import useMediaQuery from "../../vendor/hooks/use-media-query";
-import { LargeCalendar } from "../large-calendar/large-calendar";
-import { TroubleshooterSidebar } from "../sidebar/troubleshooter-sidebar";
-import { useInitalizeTroubleshooterStore } from "../store";
-
-interface TroubleshooterComponentProps {
-  month?: string | null;
-  onManageCalendarsClick?: () => void;
-  onInstallCalendarClick?: () => void;
-}
-
-export const TroubleshooterComponent = ({
-  month = null,
-  onManageCalendarsClick,
-  onInstallCalendarClick,
-}: TroubleshooterComponentProps): JSX.Element => {
-  const isMobile = useMediaQuery("(max-width: 768px)");
-  const isTablet = useMediaQuery("(max-width: 1024px)");
-
-  useInitalizeTroubleshooterStore({
-    month: month,
-    isPlatform: true,
-  });
-
-  return (
-    <AtomsWrapper>
-      <>
-        <div
-          className={cn(
-            "text-default flex min-h-full w-full flex-col items-center overflow-clip",
-            isMobile
-              ? "[--troubleshooter-meta-width:0px]"
-              : "[--troubleshooter-meta-width:250px] lg:[--troubleshooter-meta-width:430px]"
-          )}
-        >
-          <div
-            style={{
-              display: "grid",
-              width: "100%",
-              height: "auto",
-              gridTemplateAreas: `"meta main"`,
-              gridTemplateColumns: "var(--troubleshooter-meta-width) 1fr",
-              gridTemplateRows: "auto",
-            }}
-            className={cn(
-              "bg-default dark:bg-cal-muted text-default min-h-full w-full sm:transition-[width] sm:duration-300"
-            )}
-          >
-            <div className="sticky top-0 z-10 self-start ps-6 [grid-area:meta]">
-              <TroubleshooterSidebar
-                onManageCalendarsClick={onManageCalendarsClick}
-                onInstallCalendarClick={onInstallCalendarClick}
-              />
-            </div>
-
-            <div className="ml-[-1px] border-subtle [grid-area:main]">
-              <LargeCalendar />
-            </div>
-          </div>
-        </div>
-      </>
-    </AtomsWrapper>
-  );
-};
-
-interface TroubleshooterPlatformWrapperProps {
-  month?: string | null;
-  onManageCalendarsClick?: () => void;
-  onInstallCalendarClick?: () => void;
-}
-
-export const TroubleshooterPlatformWrapper = ({
-  month,
-  onManageCalendarsClick,
-  onInstallCalendarClick,
-}: TroubleshooterPlatformWrapperProps): JSX.Element => {
-  return (
-    <BookerStoreProvider>
-      <TroubleshooterComponent
-        month={month}
-        onManageCalendarsClick={onManageCalendarsClick}
-        onInstallCalendarClick={onInstallCalendarClick}
-      />
-    </BookerStoreProvider>
-  );
-};

package/src/types.ts

@@ -1,7 +0,0 @@
-export interface AtomsGlobalConfigProps {
-  /**
-   * API endpoint for the Booker component to fetch data from,
-   * defaults to https://cal.com
-   */
-  webAppUrl?: string;
-}

package/src/vendor/__tests__/availability.test.ts

@@ -1,60 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { availabilityAsString, defaultDayRange } from "../availability";
-
-describe("availabilityAsString", () => {
-  it("formats a single day range", () => {
-    const result = availabilityAsString(
-      {
-        days: [1],
-        startTime: new Date("1970-01-01T09:00:00.000Z"),
-        endTime: new Date("1970-01-01T17:00:00.000Z"),
-      },
-      { locale: "en-US", hour12: true }
-    );
-    expect(result).toContain("Mon");
-  });
-
-  it("merges consecutive days into a range", () => {
-    const result = availabilityAsString(
-      {
-        days: [1, 2, 3, 4, 5],
-        startTime: new Date("1970-01-01T09:00:00.000Z"),
-        endTime: new Date("1970-01-01T17:00:00.000Z"),
-      },
-      { locale: "en-US", hour12: true }
-    );
-    expect(result).toContain("Mon");
-    expect(result).toContain("Fri");
-  });
-
-  it("handles non-consecutive day groups", () => {
-    const result = availabilityAsString(
-      {
-        days: [1, 3, 5],
-        startTime: new Date("1970-01-01T09:00:00.000Z"),
-        endTime: new Date("1970-01-01T17:00:00.000Z"),
-      },
-      { locale: "en-US", hour12: true }
-    );
-    expect(result.split(",").length).toBeGreaterThan(1);
-  });
-
-  it("accepts string ISO times", () => {
-    const result = availabilityAsString(
-      {
-        days: [0, 1, 2],
-        startTime: "1970-01-01T09:00:00.000Z",
-        endTime: "1970-01-01T17:00:00.000Z",
-      },
-      { locale: "en-US", hour12: false }
-    );
-    expect(result.length).toBeGreaterThan(0);
-  });
-});
-
-describe("defaultDayRange", () => {
-  it("is a 9am-5pm range", () => {
-    expect(defaultDayRange.start.getUTCHours()).toBe(9);
-    expect(defaultDayRange.end.getUTCHours()).toBe(17);
-  });
-});

package/src/vendor/__tests__/avatar-url.test.ts

@@ -1,75 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { CAL_URL } from "../../constants/app";
-import {
-  getAbsoluteAvatarUrl,
-  getOrgOrTeamAvatar,
-  getPlaceholderAvatar,
-  getUserAvatarUrl,
-} from "../avatar-url";
-
-describe("getAbsoluteAvatarUrl", () => {
-  it("returns absolute URLs unchanged", () => {
-    expect(getAbsoluteAvatarUrl("https://example.com/foo.png")).toBe("https://example.com/foo.png");
-  });
-
-  it("prefixes relative URLs with CAL_URL", () => {
-    expect(getAbsoluteAvatarUrl("/foo.png")).toBe(`${CAL_URL}/foo.png`);
-  });
-});
-
-describe("getUserAvatarUrl", () => {
-  it("returns CAL_URL + AVATAR_FALLBACK when user is undefined", () => {
-    const result = getUserAvatarUrl(undefined);
-    expect(result.startsWith(CAL_URL)).toBe(true);
-  });
-
-  it("returns fallback when user has no avatarUrl", () => {
-    const result = getUserAvatarUrl({});
-    expect(result.startsWith(CAL_URL)).toBe(true);
-  });
-
-  it("returns the absolute avatarUrl when present", () => {
-    expect(getUserAvatarUrl({ avatarUrl: "https://cdn.example/a.png" })).toBe("https://cdn.example/a.png");
-  });
-
-  it("prefixes relative avatarUrl with CAL_URL", () => {
-    expect(getUserAvatarUrl({ avatarUrl: "/uploads/a.png" })).toBe(`${CAL_URL}/uploads/a.png`);
-  });
-});
-
-describe("getPlaceholderAvatar", () => {
-  it("returns the provided avatar when truthy", () => {
-    expect(getPlaceholderAvatar("https://cdn/ex.png", "Alice")).toBe("https://cdn/ex.png");
-  });
-
-  it("generates a ui-avatars fallback when avatar is null", () => {
-    const result = getPlaceholderAvatar(null, "Alice Smith");
-    expect(result).toContain("ui-avatars.com");
-    expect(result).toContain("name=Alice%20Smith");
-  });
-
-  it("handles missing name gracefully", () => {
-    const result = getPlaceholderAvatar(null, null);
-    expect(result).toContain("name=");
-  });
-});
-
-describe("getOrgOrTeamAvatar", () => {
-  it("prefers team's own logoUrl", () => {
-    expect(getOrgOrTeamAvatar({ logoUrl: "https://cdn/team.png", name: "Team" })).toBe(
-      "https://cdn/team.png"
-    );
-  });
-
-  it("falls back to parent's logoUrl", () => {
-    expect(
-      getOrgOrTeamAvatar({ logoUrl: null, name: "Team", parent: { logoUrl: "https://cdn/parent.png" } })
-    ).toBe("https://cdn/parent.png");
-  });
-
-  it("falls back to ui-avatars when no logos", () => {
-    const result = getOrgOrTeamAvatar({ name: "Acme" });
-    expect(result).toContain("ui-avatars.com");
-    expect(result).toContain("name=Acme");
-  });
-});

package/src/vendor/__tests__/booker-url.test.ts

@@ -1,26 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { WEBAPP_URL } from "../../constants/app";
-import { getBookerBaseUrlSync, getTeamUrlSync } from "../booker-url";
-
-describe("getBookerBaseUrlSync", () => {
-  it("always returns WEBAPP_URL regardless of orgSlug", () => {
-    expect(getBookerBaseUrlSync(undefined)).toBe(WEBAPP_URL);
-    expect(getBookerBaseUrlSync(null)).toBe(WEBAPP_URL);
-    expect(getBookerBaseUrlSync("some-org")).toBe(WEBAPP_URL);
-  });
-});
-
-describe("getTeamUrlSync", () => {
-  it("returns WEBAPP_URL when teamSlug is missing", () => {
-    expect(getTeamUrlSync({})).toBe(WEBAPP_URL);
-    expect(getTeamUrlSync({ orgSlug: "acme" })).toBe(WEBAPP_URL);
-  });
-
-  it("prefixes /team for non-org teams", () => {
-    expect(getTeamUrlSync({ teamSlug: "engineering" })).toBe(`${WEBAPP_URL}/team/engineering`);
-  });
-
-  it("omits the /team segment when orgSlug is present", () => {
-    expect(getTeamUrlSync({ orgSlug: "acme", teamSlug: "engineering" })).toBe(`${WEBAPP_URL}/engineering`);
-  });
-});

package/src/vendor/__tests__/booking-to-mutation-input.test.ts

@@ -1,232 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import {
-  type BookingOptions,
-  mapBookingToMutationInput,
-  mapRecurringBookingToMutationInput,
-} from "../booking-to-mutation-input";
-import { Frequency } from "../recurring";
-
-const baseOptions = (): BookingOptions => ({
-  values: { name: "Jane", email: "jane@example.com" },
-  event: { id: 123, slug: "intro-call", length: 30 },
-  date: "2024-06-15T10:00:00Z",
-  timeZone: "UTC",
-  language: "en",
-  username: "alice",
-});
-
-describe("mapBookingToMutationInput", () => {
-  it("produces a payload with start/end computed from duration", () => {
-    const input = mapBookingToMutationInput(baseOptions());
-    expect(input.user).toBe("alice");
-    expect(input.eventTypeId).toBe(123);
-    expect(input.eventTypeSlug).toBe("intro-call");
-    expect(input.timeZone).toBe("UTC");
-    expect(input.language).toBe("en");
-    expect(input.start).toBeTruthy();
-    expect(input.end).toBeTruthy();
-    // end must be 30 minutes after start when duration defaults from event.length
-    expect(new Date(input.end as string).getTime() - new Date(input.start as string).getTime()).toBe(
-      30 * 60 * 1000
-    );
-  });
-
-  it("prefers explicit duration over event.length", () => {
-    const input = mapBookingToMutationInput({ ...baseOptions(), duration: 60 });
-    expect(new Date(input.end as string).getTime() - new Date(input.start as string).getTime()).toBe(
-      60 * 60 * 1000
-    );
-  });
-
-  it("defaults language to 'en' when empty", () => {
-    const input = mapBookingToMutationInput({ ...baseOptions(), language: "" });
-    expect(input.language).toBe("en");
-  });
-
-  it("sets hasHashedBookingLink when hashedLink provided", () => {
-    const withLink = mapBookingToMutationInput({ ...baseOptions(), hashedLink: "abc" });
-    expect(withLink.hasHashedBookingLink).toBe(true);
-    const withoutLink = mapBookingToMutationInput(baseOptions());
-    expect(withoutLink.hasHashedBookingLink).toBe(false);
-  });
-
-  it("passes through booking identifiers", () => {
-    const input = mapBookingToMutationInput({
-      ...baseOptions(),
-      rescheduleUid: "resc-1",
-      rescheduledBy: "alice",
-      bookingUid: "bk-1",
-      seatReferenceUid: "seat-1",
-    });
-    expect(input.rescheduleUid).toBe("resc-1");
-    expect(input.rescheduledBy).toBe("alice");
-    expect(input.bookingUid).toBe("bk-1");
-    expect(input.seatReferenceUid).toBe("seat-1");
-  });
-
-  it("pulls routedTeamMemberIds from routingFormSearchParams", () => {
-    const input = mapBookingToMutationInput({
-      ...baseOptions(),
-      routingFormSearchParams: { "cal.routedTeamMemberIds": "1,2,3" },
-    });
-    expect(input.routedTeamMemberIds).toEqual([1, 2, 3]);
-  });
-
-  it("returns null routedTeamMemberIds when search param absent", () => {
-    const input = mapBookingToMutationInput({
-      ...baseOptions(),
-      routingFormSearchParams: {},
-    });
-    expect(input.routedTeamMemberIds).toBeNull();
-  });
-
-  it("parses routingFormResponseId as Number", () => {
-    const input = mapBookingToMutationInput({
-      ...baseOptions(),
-      routingFormSearchParams: { "cal.routingFormResponseId": "42" },
-    });
-    expect(input.routingFormResponseId).toBe(42);
-  });
-
-  it("marks skipContactOwner when true", () => {
-    const input = mapBookingToMutationInput({
-      ...baseOptions(),
-      routingFormSearchParams: { "cal.skipContactOwner": "true" },
-    });
-    expect(input.skipContactOwner).toBe(true);
-  });
-
-  it("parses JSON reroutingFormResponses", () => {
-    const input = mapBookingToMutationInput({
-      ...baseOptions(),
-      routingFormSearchParams: { "cal.reroutingFormResponses": '{"foo":"bar"}' },
-    });
-    expect(input.reroutingFormResponses).toEqual({ foo: "bar" });
-  });
-
-  it("honors explicit isDryRunProp over search param", () => {
-    const input = mapBookingToMutationInput({
-      ...baseOptions(),
-      isDryRunProp: true,
-      routingFormSearchParams: { "cal.isBookingDryRun": "false" },
-    });
-    expect(input._isDryRun).toBe(true);
-  });
-
-  it("reads isBookingDryRun from search params when isDryRunProp undefined", () => {
-    const input = mapBookingToMutationInput({
-      ...baseOptions(),
-      routingFormSearchParams: { "cal.isBookingDryRun": "true" },
-    });
-    expect(input._isDryRun).toBe(true);
-  });
-
-  it("handles array search param values", () => {
-    const input = mapBookingToMutationInput({
-      ...baseOptions(),
-      routingFormSearchParams: { "cal.routedTeamMemberIds": ["1,2"] as unknown as string[] },
-    });
-    // Array search param should be appended; first value should parse
-    expect(input.routedTeamMemberIds).toEqual([1, 2]);
-  });
-
-  it("defaults metadata to empty object when omitted", () => {
-    const input = mapBookingToMutationInput(baseOptions());
-    expect(input.metadata).toEqual({});
-  });
-
-  it("passes metadata through unchanged", () => {
-    const input = mapBookingToMutationInput({
-      ...baseOptions(),
-      metadata: { x: "y" },
-    });
-    expect(input.metadata).toEqual({ x: "y" });
-  });
-});
-
-describe("mapRecurringBookingToMutationInput", () => {
-  const recurringOptions: BookingOptions = {
-    ...baseOptions(),
-    event: {
-      id: 123,
-      slug: "weekly-sync",
-      length: 30,
-      schedulingType: "ROUND_ROBIN",
-      recurringEvent: { freq: Frequency.WEEKLY, interval: 1, count: 4 },
-    },
-  };
-
-  it("returns an array with recurringCount entries", () => {
-    const result = mapRecurringBookingToMutationInput(recurringOptions, 3);
-    expect(Array.isArray(result)).toBe(true);
-    expect(result).toHaveLength(3);
-  });
-
-  it("each entry has a unique-to-the-batch recurringEventId shared across occurrences", () => {
-    const result = mapRecurringBookingToMutationInput(recurringOptions, 3);
-    const ids = new Set(result.map((r) => r.recurringEventId));
-    expect(ids.size).toBe(1); // all occurrences share one recurringEventId
-  });
-
-  it("each entry has distinct start timestamps", () => {
-    const result = mapRecurringBookingToMutationInput(recurringOptions, 3);
-    const starts = new Set(result.map((r) => r.start));
-    expect(starts.size).toBe(3);
-  });
-
-  it("each entry has schedulingType from the event", () => {
-    const result = mapRecurringBookingToMutationInput(recurringOptions, 2);
-    expect(result[0].schedulingType).toBe("ROUND_ROBIN");
-    expect(result[1].schedulingType).toBe("ROUND_ROBIN");
-  });
-
-  it("each entry reports the actual recurringCount (length of occurrences)", () => {
-    const result = mapRecurringBookingToMutationInput(recurringOptions, 3);
-    expect(result[0].recurringCount).toBe(3);
-  });
-
-  it("end = start + duration for each entry", () => {
-    const result = mapRecurringBookingToMutationInput(recurringOptions, 2);
-    for (const entry of result) {
-      const startMs = new Date(entry.start as string).getTime();
-      const endMs = new Date(entry.end as string).getTime();
-      expect(endMs - startMs).toBe(30 * 60 * 1000);
-    }
-  });
-
-  it("passes tracking metadata through to every entry", () => {
-    const tracking = { utm_source: "test" };
-    const result = mapRecurringBookingToMutationInput(recurringOptions, 2, tracking);
-    expect(result[0].tracking).toEqual(tracking);
-    expect(result[1].tracking).toEqual(tracking);
-  });
-
-  it("strips bookingUid from recurring entries (treated as new bookings)", () => {
-    const result = mapRecurringBookingToMutationInput({ ...recurringOptions, bookingUid: "existing-uid" }, 2);
-    for (const entry of result) {
-      expect(entry.bookingUid).toBeUndefined();
-    }
-  });
-});
-
-describe("buildSearchParams window fallback", () => {
-  const originalWindow = globalThis.window;
-  beforeEach(() => {
-    // @ts-expect-error — mock a minimal window for this scope
-    globalThis.window = {
-      location: { search: "?cal.routedTeamMemberIds=7,8" },
-    };
-  });
-  afterEach(() => {
-    if (originalWindow === undefined) {
-      delete (globalThis as any).window;
-    } else {
-      globalThis.window = originalWindow;
-    }
-  });
-
-  it("reads window.location.search when routingFormSearchParams not provided", () => {
-    const input = mapBookingToMutationInput(baseOptions());
-    expect(input.routedTeamMemberIds).toEqual([7, 8]);
-  });
-});

package/src/vendor/__tests__/check-for-empty-assignment.test.ts

@@ -1,59 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { checkForEmptyAssignment } from "../check-for-empty-assignment";
-
-describe("checkForEmptyAssignment", () => {
-  it("returns false when assignAllTeamMembers is true regardless of assignments", () => {
-    expect(
-      checkForEmptyAssignment({
-        assignedUsers: { length: 0 },
-        hosts: { length: 0 },
-        isManagedEventType: false,
-        assignAllTeamMembers: true,
-      })
-    ).toBe(false);
-  });
-
-  it("returns true for managed event type with no assigned users", () => {
-    expect(
-      checkForEmptyAssignment({
-        assignedUsers: { length: 0 },
-        hosts: { length: 3 },
-        isManagedEventType: true,
-        assignAllTeamMembers: false,
-      })
-    ).toBe(true);
-  });
-
-  it("returns false for managed event type with at least one assigned user", () => {
-    expect(
-      checkForEmptyAssignment({
-        assignedUsers: { length: 1 },
-        hosts: { length: 0 },
-        isManagedEventType: true,
-        assignAllTeamMembers: false,
-      })
-    ).toBe(false);
-  });
-
-  it("returns true for non-managed event type with no hosts", () => {
-    expect(
-      checkForEmptyAssignment({
-        assignedUsers: { length: 3 },
-        hosts: { length: 0 },
-        isManagedEventType: false,
-        assignAllTeamMembers: false,
-      })
-    ).toBe(true);
-  });
-
-  it("returns false for non-managed event type with at least one host", () => {
-    expect(
-      checkForEmptyAssignment({
-        assignedUsers: { length: 0 },
-        hosts: { length: 1 },
-        isManagedEventType: false,
-        assignAllTeamMembers: false,
-      })
-    ).toBe(false);
-  });
-});

package/src/vendor/__tests__/children-event-type.test.ts

@@ -1,64 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { stripChildrenForPayload } from "../children-event-type";
-
-describe("stripChildrenForPayload", () => {
-  it("returns an empty array for empty input", () => {
-    expect(stripChildrenForPayload([])).toEqual([]);
-  });
-
-  it("strips non-required fields like avatar and slug", () => {
-    const result = stripChildrenForPayload([
-      {
-        value: "1",
-        label: "Alice",
-        created: true,
-        slug: "30-min",
-        hidden: false,
-        owner: {
-          avatar: "https://example.test/a.png",
-          id: 1,
-          email: "alice@test.com",
-          name: "Alice",
-          username: "alice",
-          membership: "MEMBER" as never,
-          eventTypeSlugs: ["30-min"],
-          profile: { username: "alice" },
-        },
-      },
-    ]);
-    expect(result).toEqual([
-      {
-        hidden: false,
-        owner: {
-          id: 1,
-          name: "Alice",
-          email: "alice@test.com",
-          eventTypeSlugs: ["30-min"],
-        },
-      },
-    ]);
-  });
-
-  it("preserves hidden=true", () => {
-    const result = stripChildrenForPayload([
-      {
-        value: "2",
-        label: "Bob",
-        created: false,
-        slug: "60-min",
-        hidden: true,
-        owner: {
-          avatar: "",
-          id: 2,
-          email: "bob@test.com",
-          name: "Bob",
-          username: "bob",
-          membership: "MEMBER" as never,
-          eventTypeSlugs: [],
-          profile: {},
-        },
-      },
-    ]);
-    expect(result[0]?.hidden).toBe(true);
-  });
-});

package/src/vendor/__tests__/currency.test.ts

@@ -1,48 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { convertFromSmallestToPresentableCurrencyUnit, formatPrice } from "../currency";
-
-describe("convertFromSmallestToPresentableCurrencyUnit", () => {
-  it("returns amount as-is for zero-decimal currencies (JPY)", () => {
-    expect(convertFromSmallestToPresentableCurrencyUnit(1000, "JPY")).toBe(1000);
-  });
-
-  it("is case-insensitive for zero-decimal currencies", () => {
-    expect(convertFromSmallestToPresentableCurrencyUnit(1000, "jpy")).toBe(1000);
-  });
-
-  it("divides by 100 for standard currencies (USD)", () => {
-    expect(convertFromSmallestToPresentableCurrencyUnit(1000, "USD")).toBe(10);
-  });
-
-  it("divides by 100 for EUR", () => {
-    expect(convertFromSmallestToPresentableCurrencyUnit(2550, "EUR")).toBe(25.5);
-  });
-});
-
-describe("formatPrice", () => {
-  it("formats BTC as sats without Intl", () => {
-    expect(formatPrice(50000, "BTC")).toBe("50000 sats");
-  });
-
-  it("formats USD with $ prefix and cents", () => {
-    const result = formatPrice(1000, "USD");
-    // Intl output includes non-breaking space and may vary by runtime; assert key substrings.
-    expect(result).toContain("10.00");
-    expect(result).toContain("$");
-  });
-
-  it("falls back to USD when currency is undefined", () => {
-    const result = formatPrice(1000, undefined);
-    expect(result).toContain("10.00");
-  });
-
-  it("formats zero-decimal currency without dividing", () => {
-    const result = formatPrice(1000, "JPY");
-    expect(result).toContain("1,000");
-  });
-
-  it("honors locale parameter", () => {
-    const result = formatPrice(1000, "EUR", "de-DE");
-    expect(result).toContain("10,00");
-  });
-});