@calcom/atoms 2.8.0 → 2.8.2

package/src/vendor/__tests__/dayjs-utils.test.ts

@@ -1,37 +0,0 @@
-import { describe, expect, it } from "vitest";
-import dayjs from "../dayjs";
-import { daysInMonth, yyyymmdd } from "../dayjs-utils";
-
-describe("yyyymmdd", () => {
-  it("formats a Date instance to YYYY-MM-DD", () => {
-    const d = new Date(Date.UTC(2024, 5, 15, 12, 0, 0));
-    expect(yyyymmdd(d)).toMatch(/^\d{4}-\d{2}-\d{2}$/);
-  });
-
-  it("formats a Dayjs instance to YYYY-MM-DD", () => {
-    const d = dayjs("2024-06-15T12:00:00Z");
-    expect(yyyymmdd(d)).toBe("2024-06-15");
-  });
-});
-
-describe("daysInMonth", () => {
-  it("returns 31 for January from a Date", () => {
-    expect(daysInMonth(new Date(2024, 0, 10))).toBe(31);
-  });
-
-  it("returns 29 for February in a leap year", () => {
-    expect(daysInMonth(new Date(2024, 1, 10))).toBe(29);
-  });
-
-  it("returns 28 for February in a non-leap year", () => {
-    expect(daysInMonth(new Date(2023, 1, 10))).toBe(28);
-  });
-
-  it("returns 30 for April", () => {
-    expect(daysInMonth(new Date(2024, 3, 10))).toBe(30);
-  });
-
-  it("works with a Dayjs instance", () => {
-    expect(daysInMonth(dayjs("2024-07-10"))).toBe(31);
-  });
-});

package/src/vendor/__tests__/error-codes.test.ts

@@ -1,69 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { ErrorCode } from "../error-codes";
-
-describe("ErrorCode enum", () => {
-  it("exposes a stable set of error-code string values", () => {
-    expect(ErrorCode.Unauthorized).toBe("unauthorized_error");
-    expect(ErrorCode.Forbidden).toBe("forbidden_error");
-    expect(ErrorCode.NotFound).toBe("not_found_error");
-    expect(ErrorCode.BadRequest).toBe("bad_request_error");
-    expect(ErrorCode.InternalServerError).toBe("internal_server_error");
-    expect(ErrorCode.BookingNotFound).toBe("booking_not_found_error");
-    expect(ErrorCode.BookingSeatsFull).toBe("booking_seats_full_error");
-    expect(ErrorCode.AlreadySignedUpForBooking).toBe("already_signed_up_for_this_booking_error");
-    expect(ErrorCode.RestrictionScheduleNotFound).toBe("restriction_schedule_not_found_error");
-    expect(ErrorCode.BookingTimeOutOfBounds).toBe("booking_time_out_of_bounds_error");
-  });
-
-  it("has all values unique", () => {
-    const values = Object.values(ErrorCode) as string[];
-    expect(new Set(values).size).toBe(values.length);
-  });
-
-  it("exposes auth/booking/payment error codes", () => {
-    // Exhaustive pass — one expect per enum member so the whole file is marked executed.
-    const snapshot = [
-      ErrorCode.Unauthorized,
-      ErrorCode.Forbidden,
-      ErrorCode.NotFound,
-      ErrorCode.BadRequest,
-      ErrorCode.InternalServerError,
-      ErrorCode.PaymentCreationFailure,
-      ErrorCode.NoAvailableUsersFound,
-      ErrorCode.ChargeCardFailure,
-      ErrorCode.CollectCardFailure,
-      ErrorCode.RequestBodyWithouEnd,
-      ErrorCode.AlreadySignedUpForBooking,
-      ErrorCode.FixedHostsUnavailableForBooking,
-      ErrorCode.RoundRobinHostsUnavailableForBooking,
-      ErrorCode.EventTypeNotFound,
-      ErrorCode.BookingNotFound,
-      ErrorCode.BookingSeatsFull,
-      ErrorCode.MissingPaymentCredential,
-      ErrorCode.MissingPaymentAppId,
-      ErrorCode.NotEnoughAvailableSeats,
-      ErrorCode.AvailabilityNotFoundInSchedule,
-      ErrorCode.CancelledBookingsCannotBeRescheduled,
-      ErrorCode.UnableToSubscribeToThePlatform,
-      ErrorCode.UpdatingOauthClientError,
-      ErrorCode.CreatingOauthClientError,
-      ErrorCode.BookingTimeOutOfBounds,
-      ErrorCode.BookingConflict,
-      ErrorCode.BookerLimitExceeded,
-      ErrorCode.BookerLimitExceededReschedule,
-      ErrorCode.BookingNotAllowedByRestrictionSchedule,
-      ErrorCode.RestrictionScheduleNotFound,
-      ErrorCode.EventTypeNoHosts,
-      ErrorCode.RequestBodyInvalid,
-      ErrorCode.PrivateLinkExpired,
-      ErrorCode.BookerEmailBlocked,
-      ErrorCode.BookerEmailRequiresLogin,
-      ErrorCode.InvalidVerificationCode,
-      ErrorCode.UnableToValidateVerificationCode,
-    ];
-    for (const v of snapshot) {
-      expect(typeof v).toBe("string");
-      expect(v.length).toBeGreaterThan(0);
-    }
-  });
-});

package/src/vendor/__tests__/event-naming.test.ts

@@ -1,32 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { nameObjectSchema, validateCustomEventName } from "../event-naming";
-
-describe("nameObjectSchema", () => {
-  it("parses a valid name object with first + last name", () => {
-    const result = nameObjectSchema.safeParse({ firstName: "Jane", lastName: "Doe" });
-    expect(result.success).toBe(true);
-  });
-
-  it("allows lastName to be optional", () => {
-    const result = nameObjectSchema.safeParse({ firstName: "Jane" });
-    expect(result.success).toBe(true);
-  });
-
-  it("rejects missing firstName", () => {
-    const result = nameObjectSchema.safeParse({ lastName: "Doe" });
-    expect(result.success).toBe(false);
-  });
-
-  it("rejects non-string firstName", () => {
-    const result = nameObjectSchema.safeParse({ firstName: 42 });
-    expect(result.success).toBe(false);
-  });
-});
-
-describe("validateCustomEventName", () => {
-  it("always returns true (authoritative validation is server-side)", () => {
-    expect(validateCustomEventName("any template")).toBe(true);
-    expect(validateCustomEventName("")).toBe(true);
-    expect(validateCustomEventName("{HOST}", { foo: "bar" })).toBe(true);
-  });
-});

package/src/vendor/__tests__/format-date-time.test.ts

@@ -1,90 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { formatDateTime, formatDateTimeRange, formatWeekday, getWeekdayNames } from "../format-date-time";
-
-const date = new Date("2024-06-12T10:30:00.000Z");
-const endDate = new Date("2024-06-12T11:30:00.000Z");
-
-describe("formatDateTime", () => {
-  it("formats a date with Intl-supported locale", () => {
-    const out = formatDateTime(date, { locale: "en-US", dateStyle: "medium", timeZone: "UTC" });
-    expect(out).toContain("Jun");
-    expect(out).toContain("2024");
-  });
-
-  it("returns month only when month option is set", () => {
-    const out = formatDateTime(date, { locale: "en-US", month: "short", timeZone: "UTC" });
-    expect(out).toContain("Jun");
-  });
-
-  it("produces an output including time when timeStyle is passed", () => {
-    const out = formatDateTime(date, { locale: "en-US", timeStyle: "short", timeZone: "UTC" });
-    expect(out).toMatch(/\d/);
-  });
-
-  it("uses default format when no style options provided for unsupported locale", () => {
-    const out = formatDateTime(date, { locale: "", timeZone: "UTC" });
-    expect(out).toMatch(/\d{4}-\d{2}-\d{2}/);
-  });
-
-  it("handles hour12 option in supported locale", () => {
-    const out = formatDateTime(date, { locale: "en-US", timeStyle: "short", hour12: true, timeZone: "UTC" });
-    expect(typeof out).toBe("string");
-    expect(out.length).toBeGreaterThan(0);
-  });
-});
-
-describe("formatDateTimeRange", () => {
-  it("formats a range with Intl-supported locale", () => {
-    const out = formatDateTimeRange(date, endDate, { locale: "en-US", timeStyle: "short", timeZone: "UTC" });
-    expect(out.length).toBeGreaterThan(0);
-  });
-
-  it("falls back to dayjs for empty locale", () => {
-    const out = formatDateTimeRange(date, endDate, {
-      locale: "",
-      dateStyle: "short",
-      timeZone: "UTC",
-    });
-    expect(out).toContain(" — ");
-  });
-});
-
-describe("formatWeekday", () => {
-  it("returns long weekday in English", () => {
-    const out = formatWeekday("en-US", 3, "long");
-    expect(out).toMatch(/^[A-Z]/);
-  });
-
-  it("returns short weekday in English", () => {
-    const out = formatWeekday("en-US", 3, "short");
-    expect(out.length).toBeGreaterThan(0);
-    expect(out.length).toBeLessThan(10);
-  });
-});
-
-describe("getWeekdayNames", () => {
-  it("returns 7 weekday names", () => {
-    const names = getWeekdayNames("en-US", 0, "long");
-    expect(names).toHaveLength(7);
-    expect(names.every((n) => typeof n === "string" && n.length > 0)).toBe(true);
-  });
-
-  it("rotates weekday order based on weekStart", () => {
-    const sunday = getWeekdayNames("en-US", 0, "long");
-    const monday = getWeekdayNames("en-US", 1, "long");
-    expect(sunday[0]).not.toBe(monday[0]);
-    expect(monday[0]).toBe(sunday[1]);
-  });
-
-  it("caches repeated calls (same result)", () => {
-    const first = getWeekdayNames("en-US", 0, "long");
-    const second = getWeekdayNames("en-US", 0, "long");
-    expect(second).toEqual(first);
-  });
-
-  it("supports short format", () => {
-    const names = getWeekdayNames("en-US", 0, "short");
-    expect(names).toHaveLength(7);
-    expect(names[0].length).toBeLessThan(10);
-  });
-});

package/src/vendor/__tests__/get-available-dates-in-month.test.ts

@@ -1,51 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { getAvailableDatesInMonth } from "../get-available-dates-in-month";
-
-describe("getAvailableDatesInMonth", () => {
-  it("returns all days in the month starting from browsingDate", () => {
-    const browsingDate = new Date(2024, 5, 1); // June 1 2024
-    const minDate = new Date(2024, 5, 1);
-    const result = getAvailableDatesInMonth({ browsingDate, minDate });
-    expect(result).toHaveLength(30);
-    expect(result[0]).toBe("2024-06-01");
-    expect(result[29]).toBe("2024-06-30");
-  });
-
-  it("skips days before minDate when minDate is later than browsingDate", () => {
-    const browsingDate = new Date(2024, 5, 1);
-    const minDate = new Date(2024, 5, 15);
-    const result = getAvailableDatesInMonth({ browsingDate, minDate });
-    expect(result[0]).toBe("2024-06-15");
-    expect(result).toHaveLength(16);
-  });
-
-  it("includes only dates found in includedDates", () => {
-    const browsingDate = new Date(2024, 5, 1);
-    const minDate = new Date(2024, 5, 1);
-    const result = getAvailableDatesInMonth({
-      browsingDate,
-      minDate,
-      includedDates: ["2024-06-05", "2024-06-10"],
-    });
-    expect(result).toEqual(["2024-06-05", "2024-06-10"]);
-  });
-
-  it("returns empty array when includedDates has no month entries", () => {
-    const browsingDate = new Date(2024, 5, 1);
-    const minDate = new Date(2024, 5, 1);
-    const result = getAvailableDatesInMonth({
-      browsingDate,
-      minDate,
-      includedDates: ["2023-01-01"],
-    });
-    expect(result).toEqual([]);
-  });
-
-  it("handles February in leap year (29 days)", () => {
-    const browsingDate = new Date(2024, 1, 1); // Feb 1 2024
-    const minDate = new Date(2024, 1, 1);
-    const result = getAvailableDatesInMonth({ browsingDate, minDate });
-    expect(result).toHaveLength(29);
-    expect(result[28]).toBe("2024-02-29");
-  });
-});

package/src/vendor/__tests__/host-group-utils.test.ts

@@ -1,117 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { getHostsFromOtherGroups, groupHostsByGroupId, sortHosts } from "../host-group-utils";
-
-type Host = { id: number; groupId?: string | null };
-
-describe("groupHostsByGroupId", () => {
-  it("groups hosts under default_group_id when no hostGroups provided", () => {
-    const hosts: Host[] = [{ id: 1 }, { id: 2 }];
-    const result = groupHostsByGroupId({ hosts });
-    expect(result).toEqual({ default_group_id: [{ id: 1 }, { id: 2 }] });
-  });
-
-  it("groups hosts under explicit group IDs", () => {
-    const hosts: Host[] = [
-      { id: 1, groupId: "a" },
-      { id: 2, groupId: "b" },
-      { id: 3, groupId: "a" },
-    ];
-    const result = groupHostsByGroupId({
-      hosts,
-      hostGroups: [{ id: "a" }, { id: "b" }],
-    });
-    expect(result).toEqual({
-      a: [
-        { id: 1, groupId: "a" },
-        { id: 3, groupId: "a" },
-      ],
-      b: [{ id: 2, groupId: "b" }],
-    });
-  });
-
-  it("uses default group for hosts missing a groupId even when hostGroups provided", () => {
-    const hosts: Host[] = [{ id: 1 }, { id: 2, groupId: "a" }];
-    const result = groupHostsByGroupId({
-      hosts,
-      hostGroups: [{ id: "a" }],
-    });
-    expect(result.a).toEqual([{ id: 2, groupId: "a" }]);
-    expect(result.default_group_id).toBeUndefined();
-  });
-
-  it("creates empty arrays for groups with no matching hosts", () => {
-    const result = groupHostsByGroupId({
-      hosts: [],
-      hostGroups: [{ id: "a" }, { id: "b" }],
-    });
-    expect(result).toEqual({ a: [], b: [] });
-  });
-
-  it("drops hosts whose groupId doesn't match any known group", () => {
-    const hosts: Host[] = [{ id: 1, groupId: "missing" }];
-    const result = groupHostsByGroupId({
-      hosts,
-      hostGroups: [{ id: "a" }],
-    });
-    expect(result).toEqual({ a: [] });
-  });
-});
-
-describe("getHostsFromOtherGroups", () => {
-  const hosts: Host[] = [
-    { id: 1, groupId: "a" },
-    { id: 2, groupId: "b" },
-    { id: 3 },
-    { id: 4, groupId: null },
-  ];
-
-  it("returns hosts whose groupId differs from the target groupId", () => {
-    const result = getHostsFromOtherGroups(hosts, "a");
-    expect(result).toEqual([{ id: 2, groupId: "b" }, { id: 3 }, { id: 4, groupId: null }]);
-  });
-
-  it("returns only hosts with a groupId when target is null", () => {
-    const result = getHostsFromOtherGroups(hosts, null);
-    expect(result).toEqual([
-      { id: 1, groupId: "a" },
-      { id: 2, groupId: "b" },
-    ]);
-  });
-});
-
-describe("sortHosts", () => {
-  const host = (priority: number | null, weight: number | null) => ({ priority, weight });
-
-  it("sorts by priority desc when weights are disabled", () => {
-    const comparator = (
-      a: { priority: number | null; weight: number | null },
-      b: { priority: number | null; weight: number | null }
-    ) => sortHosts(a, b, false);
-    const result = [host(1, 100), host(3, 50), host(2, 80)].sort(comparator);
-    expect(result.map((h) => h.priority)).toEqual([3, 2, 1]);
-  });
-
-  it("sorts by weight desc when weights are enabled", () => {
-    const comparator = (
-      a: { priority: number | null; weight: number | null },
-      b: { priority: number | null; weight: number | null }
-    ) => sortHosts(a, b, true);
-    const result = [host(1, 100), host(3, 50), host(2, 80)].sort(comparator);
-    expect(result.map((h) => h.weight)).toEqual([100, 80, 50]);
-  });
-
-  it("breaks weight ties by priority desc when weights are enabled", () => {
-    const comparator = (
-      a: { priority: number | null; weight: number | null },
-      b: { priority: number | null; weight: number | null }
-    ) => sortHosts(a, b, true);
-    const result = [host(1, 100), host(3, 100), host(2, 100)].sort(comparator);
-    expect(result.map((h) => h.priority)).toEqual([3, 2, 1]);
-  });
-
-  it("uses defaults when priority/weight are null", () => {
-    // defaults: priority=2, weight=100
-    expect(sortHosts({ priority: null, weight: null }, { priority: null, weight: null }, true)).toBe(0);
-    expect(sortHosts({ priority: null, weight: null }, { priority: null, weight: null }, false)).toBe(0);
-  });
-});

package/src/vendor/__tests__/interval-limit.test.ts

@@ -1,42 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { ascendingLimitKeys, validateIntervalLimitOrder } from "../interval-limit";
-
-describe("ascendingLimitKeys", () => {
-  it("exposes the canonical ascending order", () => {
-    expect(ascendingLimitKeys).toEqual(["PER_DAY", "PER_WEEK", "PER_MONTH", "PER_YEAR"]);
-  });
-});
-
-describe("validateIntervalLimitOrder", () => {
-  it("returns true when limits increase from day to year", () => {
-    expect(
-      validateIntervalLimitOrder({
-        PER_DAY: 1,
-        PER_WEEK: 5,
-        PER_MONTH: 20,
-        PER_YEAR: 100,
-      })
-    ).toBe(true);
-  });
-
-  it("returns true when only a subset is provided (still ascending)", () => {
-    expect(validateIntervalLimitOrder({ PER_DAY: 1, PER_MONTH: 10 })).toBe(true);
-  });
-
-  it("returns true for a single limit", () => {
-    expect(validateIntervalLimitOrder({ PER_WEEK: 5 })).toBe(true);
-  });
-
-  it("returns false when a wider interval has a lower limit than a narrower one", () => {
-    expect(
-      validateIntervalLimitOrder({
-        PER_DAY: 10,
-        PER_WEEK: 5,
-      })
-    ).toBe(false);
-  });
-
-  it("returns true for an empty input", () => {
-    expect(validateIntervalLimitOrder({})).toBe(true);
-  });
-});

package/src/vendor/__tests__/locations-resolver.test.ts

@@ -1,48 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { locationsResolver } from "../locations-resolver";
-
-describe("locationsResolver", () => {
-  it("allows an empty array", () => {
-    const schema = locationsResolver(() => "");
-    expect(schema.parse([])).toEqual([]);
-  });
-
-  it("accepts a minimal location with just a type", () => {
-    const schema = locationsResolver(() => "");
-    const parsed = schema.parse([{ type: "integrations:daily" }]);
-    expect(parsed?.[0]?.type).toBe("integrations:daily");
-  });
-
-  it("accepts optional fields like phone/link/address", () => {
-    const schema = locationsResolver(() => "");
-    const parsed = schema.parse([
-      {
-        type: "userPhone",
-        phone: "+351911111111",
-        link: "https://cal.com",
-        address: "Lisbon",
-        hostPhoneNumber: "+351922222222",
-        displayLocationPublicly: true,
-        credentialId: 1,
-        teamName: "team",
-      },
-    ]);
-    expect(parsed?.[0]?.phone).toBe("+351911111111");
-  });
-
-  it("passes through unknown keys", () => {
-    const schema = locationsResolver(() => "");
-    const parsed = schema.parse([{ type: "custom", foo: "bar" }]);
-    expect(parsed?.[0]).toEqual(expect.objectContaining({ foo: "bar" }));
-  });
-
-  it("allows the whole array to be undefined", () => {
-    const schema = locationsResolver(() => "");
-    expect(schema.parse(undefined)).toBeUndefined();
-  });
-
-  it("throws when type is missing", () => {
-    const schema = locationsResolver(() => "");
-    expect(() => schema.parse([{ address: "Lisbon" }])).toThrow();
-  });
-});

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

@@ -1,109 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  DailyLocationType,
-  DefaultEventLocationTypeEnum,
-  getEventLocationType,
-  getLocationOptionsForSelect,
-  getOrganizerInputLocationTypes,
-  getTranslatedLocation,
-  MeetLocationType,
-  MSTeamsLocationType,
-} from "../locations";
-
-const t = (key: string) => key;
-
-describe("location type constants", () => {
-  it("exposes canonical integration type strings", () => {
-    expect(DailyLocationType).toBe("integrations:daily");
-    expect(MeetLocationType).toBe("integrations:google:meet");
-    expect(MSTeamsLocationType).toBe("integrations:office365_video");
-  });
-});
-
-describe("getEventLocationType", () => {
-  it("finds a default location by type", () => {
-    const result = getEventLocationType(DefaultEventLocationTypeEnum.InPerson);
-    expect(result?.type).toBe(DefaultEventLocationTypeEnum.InPerson);
-  });
-
-  it("finds a common integration location", () => {
-    const result = getEventLocationType(DailyLocationType);
-    expect(result?.type).toBe(DailyLocationType);
-  });
-
-  it("returns undefined for unknown type", () => {
-    expect(getEventLocationType("unknown-type")).toBeUndefined();
-  });
-
-  it("returns undefined for null/undefined", () => {
-    expect(getEventLocationType(null)).toBeUndefined();
-    expect(getEventLocationType(undefined)).toBeUndefined();
-  });
-});
-
-describe("getTranslatedLocation", () => {
-  it("returns null when eventLocationType is missing", () => {
-    expect(getTranslatedLocation({ type: "foo" }, undefined, t)).toBeNull();
-  });
-
-  it("returns the integration label for integration locations", () => {
-    const eventLocationType = getEventLocationType(DailyLocationType);
-    const result = getTranslatedLocation({ type: DailyLocationType }, eventLocationType, t);
-    expect(result).toBe(eventLocationType?.label);
-  });
-
-  it("translates known-translatable key for non-integration locations", () => {
-    const eventLocationType = getEventLocationType(DefaultEventLocationTypeEnum.InPerson);
-    const result = getTranslatedLocation(
-      { type: DefaultEventLocationTypeEnum.InPerson, address: "123 Main St" },
-      eventLocationType,
-      (key) => `[translated]${key}`
-    );
-    // locationKey resolves to the address value (defaultValueVariable=address) which isn't in translateAbleKeys list.
-    expect(result).toBe("123 Main St");
-  });
-});
-
-describe("getOrganizerInputLocationTypes", () => {
-  it("returns the canonical organizer input types", () => {
-    expect(getOrganizerInputLocationTypes()).toEqual([
-      DefaultEventLocationTypeEnum.InPerson,
-      DefaultEventLocationTypeEnum.UserPhone,
-      DefaultEventLocationTypeEnum.Link,
-    ]);
-  });
-});
-
-describe("getLocationOptionsForSelect", () => {
-  it("maps locations into select options", () => {
-    const options = getLocationOptionsForSelect(
-      [{ type: DailyLocationType }, { type: DefaultEventLocationTypeEnum.InPerson, address: "123 Main" }],
-      t
-    );
-    expect(options).toHaveLength(2);
-    expect(options[0]?.value).toBe(DailyLocationType);
-    expect(options[1]?.value).toBe(DefaultEventLocationTypeEnum.InPerson);
-  });
-
-  it("filters out unknown location types", () => {
-    const options = getLocationOptionsForSelect([{ type: "unknown-type" }, { type: DailyLocationType }], t);
-    expect(options).toHaveLength(1);
-    expect(options[0]?.value).toBe(DailyLocationType);
-  });
-
-  it("uses customLabel when provided", () => {
-    const options = getLocationOptionsForSelect(
-      [{ type: DailyLocationType, customLabel: "My Daily Room" }],
-      t
-    );
-    expect(options[0]?.label).toBe("My Daily Room");
-  });
-
-  it("uses 'somewhere_else' translation for SomewhereElse type", () => {
-    const options = getLocationOptionsForSelect(
-      [{ type: DefaultEventLocationTypeEnum.SomewhereElse, somewhereElse: "conf room" }],
-      (key) => (key === "somewhere_else" ? "SOMEWHERE_ELSE" : key)
-    );
-    expect(options[0]?.label).toBe("SOMEWHERE_ELSE");
-  });
-});