@calcom/atoms 2.7.2 → 2.8.1

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

@@ -1,219 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { trackEvent } from "../analytics";
-import { getAbsoluteAvatarUrl, getUserAvatarUrl } from "../get-avatar-url";
-import { getRoutedTeamMemberIdsFromSearchParams } from "../get-routed-team-member-ids";
-import { getUsernameList } from "../get-username-list";
-import invertLogoOnDark from "../invert-logo-on-dark";
-import { getScheduleListItemData } from "../schedule-list-item";
-import { scrollIntoViewSmooth } from "../scroll";
-import {
-  getIs24hClockFromLocalStorage,
-  getTimeFormatStringFromUserTimeFormat,
-  setIs24hClockInLocalStorage,
-  TimeFormat,
-} from "../time-format";
-
-describe("analytics.trackEvent", () => {
-  beforeEach(() => {
-    delete (window as unknown as { posthog?: unknown }).posthog;
-  });
-
-  it("is a no-op when posthog is not loaded", () => {
-    expect(() => trackEvent("test")).not.toThrow();
-  });
-
-  it("no-ops when posthog has not finished loading", () => {
-    const capture = vi.fn();
-    (window as unknown as { posthog?: unknown }).posthog = {
-      capture,
-      __loaded: false,
-    };
-    trackEvent("test");
-    expect(capture).not.toHaveBeenCalled();
-  });
-
-  it("captures when posthog is fully loaded", () => {
-    const capture = vi.fn();
-    (window as unknown as { posthog?: unknown }).posthog = {
-      capture,
-      __loaded: true,
-    };
-    trackEvent("test", { a: 1 });
-    expect(capture).toHaveBeenCalledWith("test", { a: 1 });
-  });
-});
-
-describe("getAvatarUrl", () => {
-  it("returns absolute URLs unchanged", () => {
-    expect(getAbsoluteAvatarUrl("https://example.test/x.png")).toBe("https://example.test/x.png");
-  });
-
-  it("prefixes CAL_URL for relative URLs", () => {
-    const result = getAbsoluteAvatarUrl("/avatar.png");
-    expect(result.endsWith("/avatar.png")).toBe(true);
-  });
-
-  it("falls back to the default when user has no avatarUrl", () => {
-    const url = getUserAvatarUrl({});
-    expect(url.length).toBeGreaterThan(0);
-  });
-
-  it("uses user.avatarUrl when present", () => {
-    expect(getUserAvatarUrl({ avatarUrl: "https://a.test/a.png" })).toBe("https://a.test/a.png");
-  });
-});
-
-describe("getRoutedTeamMemberIdsFromSearchParams", () => {
-  it("returns null when the param is missing", () => {
-    expect(getRoutedTeamMemberIdsFromSearchParams(new URLSearchParams())).toBeNull();
-  });
-
-  it("parses comma-separated numeric ids", () => {
-    const sp = new URLSearchParams("cal.routedTeamMemberIds=1,2,3");
-    expect(getRoutedTeamMemberIdsFromSearchParams(sp)).toEqual([1, 2, 3]);
-  });
-
-  it("filters out empty entries", () => {
-    const sp = new URLSearchParams("cal.routedTeamMemberIds=1,,3");
-    expect(getRoutedTeamMemberIdsFromSearchParams(sp)).toEqual([1, 3]);
-  });
-});
-
-describe("getUsernameList", () => {
-  it("returns an empty array for undefined", () => {
-    expect(getUsernameList(undefined)).toEqual([]);
-  });
-
-  it("splits a string on + symbols", () => {
-    expect(getUsernameList("alice+bob")).toEqual(["alice", "bob"]);
-  });
-
-  it("decodes URL-encoded separators", () => {
-    expect(getUsernameList("alice%20bob")).toEqual(["alice", "bob"]);
-  });
-
-  it("accepts an array of usernames", () => {
-    expect(getUsernameList(["alice", "bob"])).toEqual(["alice", "bob"]);
-  });
-
-  it("slugifies each username", () => {
-    expect(getUsernameList("Alice Bob")).toEqual(["alice", "bob"]);
-  });
-});
-
-describe("invertLogoOnDark", () => {
-  it("returns dark:invert when url has -dark segment", () => {
-    expect(invertLogoOnDark("/app-store/icons-dark.svg")).toBe("dark:invert");
-  });
-
-  it("returns empty string for /app-store/... without -dark", () => {
-    expect(invertLogoOnDark("/app-store/icon.svg")).toBe("");
-  });
-
-  it("inverts by default for external URLs", () => {
-    expect(invertLogoOnDark("https://example.test/a.svg")).toBe("dark:invert");
-  });
-
-  it("flips to invert dark:invert-0 with opposite=true", () => {
-    expect(invertLogoOnDark("https://example.test/a.svg", true)).toBe("invert dark:invert-0");
-  });
-
-  it("returns dark:invert when url is undefined", () => {
-    expect(invertLogoOnDark(undefined)).toBe("dark:invert");
-  });
-});
-
-describe("getScheduleListItemData", () => {
-  it("converts availability dates to Date objects", () => {
-    const result = getScheduleListItemData({
-      isDefault: true,
-      id: 1,
-      name: "Default",
-      timeZone: "UTC",
-      availability: [
-        {
-          id: 1,
-          userId: 1,
-          startTime: "1970-01-01T09:00:00.000Z",
-          endTime: "1970-01-01T17:00:00.000Z",
-          eventTypeId: null,
-          date: "2025-01-01",
-          days: [1, 2, 3, 4, 5],
-          scheduleId: 1,
-          createdAt: null,
-          updatedAt: null,
-        },
-      ],
-    });
-    expect(result.availability[0]?.startTime).toBeInstanceOf(Date);
-    expect(result.availability[0]?.endTime).toBeInstanceOf(Date);
-    expect(result.availability[0]?.date).toBeInstanceOf(Date);
-  });
-
-  it("handles null date entries", () => {
-    const result = getScheduleListItemData({
-      isDefault: false,
-      id: 2,
-      name: "Second",
-      timeZone: null,
-      availability: [
-        {
-          id: 1,
-          userId: null,
-          startTime: "1970-01-01T09:00:00.000Z",
-          endTime: "1970-01-01T17:00:00.000Z",
-          eventTypeId: null,
-          date: null,
-          days: [],
-          scheduleId: 2,
-          createdAt: null,
-          updatedAt: null,
-        },
-      ],
-    });
-    expect(result.availability[0]?.date).toBeNull();
-  });
-});
-
-describe("scrollIntoViewSmooth", () => {
-  it("invokes scrollIntoView with smooth behavior", () => {
-    const el = { scrollIntoView: vi.fn() } as unknown as HTMLElement;
-    scrollIntoViewSmooth(el);
-    expect(el.scrollIntoView).toHaveBeenCalledWith({ behavior: "smooth", block: "start" });
-  });
-
-  it("is a no-op when window is undefined", () => {
-    const originalWindow = globalThis.window;
-    // @ts-expect-error — test-only
-    delete globalThis.window;
-    const el = { scrollIntoView: vi.fn() } as unknown as HTMLElement;
-    scrollIntoViewSmooth(el);
-    globalThis.window = originalWindow;
-    expect(el.scrollIntoView).not.toHaveBeenCalled();
-  });
-});
-
-describe("time-format", () => {
-  beforeEach(() => {
-    window.localStorage.clear();
-  });
-
-  it("maps 24 to 24h format and other values to 12h", () => {
-    expect(getTimeFormatStringFromUserTimeFormat(24)).toBe(TimeFormat.TWENTY_FOUR_HOUR);
-    expect(getTimeFormatStringFromUserTimeFormat(12)).toBe(TimeFormat.TWELVE_HOUR);
-    expect(getTimeFormatStringFromUserTimeFormat(null)).toBe(TimeFormat.TWELVE_HOUR);
-    expect(getTimeFormatStringFromUserTimeFormat(undefined)).toBe(TimeFormat.TWELVE_HOUR);
-  });
-
-  it("round-trips is24h through localStorage", () => {
-    setIs24hClockInLocalStorage(true);
-    expect(getIs24hClockFromLocalStorage()).toBe(true);
-    setIs24hClockInLocalStorage(false);
-    expect(getIs24hClockFromLocalStorage()).toBe(false);
-  });
-
-  it("returns null when not set", () => {
-    window.localStorage.removeItem("timeOption.is24hClock");
-    expect(getIs24hClockFromLocalStorage()).toBeNull();
-  });
-});

package/src/vendor/__tests__/parse-dates.test.ts

@@ -1,67 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { parseDate, parseRecurringDates } from "../parse-dates";
-import { Frequency } from "../recurring";
-
-describe("parseDate", () => {
-  it("returns ['No date'] when date is falsy", () => {
-    expect(parseDate(null, "en", "UTC")).toEqual(["No date"]);
-    expect(parseDate("", "en", "UTC")).toEqual(["No date"]);
-  });
-
-  it("returns 'Invalid date' for unparseable strings", () => {
-    expect(parseDate("not-a-date", "en", "UTC")).toBe("Invalid date");
-  });
-
-  it("returns a formatted string for a valid ISO date", () => {
-    const result = parseDate("2024-06-15T14:30:00Z", "en", "UTC", { withDefaultTimeFormat: true });
-    expect(typeof result).toBe("string");
-    expect(result).toContain("2024");
-  });
-});
-
-describe("parseRecurringDates", () => {
-  it("returns recurringCount dates when given a weekly rule", () => {
-    const [dateStrings, dates] = parseRecurringDates(
-      {
-        startDate: "2024-06-01T10:00:00Z",
-        timeZone: "UTC",
-        recurringEvent: { freq: Frequency.WEEKLY, interval: 1, count: 4 },
-        recurringCount: 3,
-        withDefaultTimeFormat: true,
-      },
-      "en"
-    );
-    expect(dates).toHaveLength(3);
-    expect(dateStrings).toHaveLength(3);
-    expect(dateStrings.every((s) => typeof s === "string")).toBe(true);
-  });
-
-  it("respects recurringCount over the event's count", () => {
-    const [, dates] = parseRecurringDates(
-      {
-        startDate: "2024-06-01T10:00:00Z",
-        timeZone: "UTC",
-        recurringEvent: { freq: Frequency.DAILY, interval: 1, count: 10 },
-        recurringCount: 2,
-        withDefaultTimeFormat: true,
-      },
-      "en"
-    );
-    expect(dates).toHaveLength(2);
-  });
-
-  it("produces increasing timestamps", () => {
-    const [, dates] = parseRecurringDates(
-      {
-        startDate: "2024-06-01T10:00:00Z",
-        timeZone: "UTC",
-        recurringEvent: { freq: Frequency.DAILY, interval: 1, count: 3 },
-        recurringCount: 3,
-        withDefaultTimeFormat: true,
-      },
-      "en"
-    );
-    expect(dates[1].getTime()).toBeGreaterThan(dates[0].getTime());
-    expect(dates[2].getTime()).toBeGreaterThan(dates[1].getTime());
-  });
-});

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

@@ -1,126 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { checkForMultiplePaymentApps, getPaymentAppData, getSuccessPageLocationMessage } from "../payments";
-
-describe("checkForMultiplePaymentApps", () => {
-  it("returns false when metadata is null", () => {
-    expect(checkForMultiplePaymentApps(null)).toBe(false);
-  });
-
-  it("returns false when no apps are enabled", () => {
-    expect(
-      checkForMultiplePaymentApps({
-        apps: { stripe: { enabled: false, appCategories: ["payment"] } },
-      })
-    ).toBe(false);
-  });
-
-  it("counts apps with appCategories=payment and enabled=true", () => {
-    const result = checkForMultiplePaymentApps({
-      apps: {
-        stripe: { enabled: true, appCategories: ["payment"] },
-        paypal: { enabled: true, appCategories: ["payment"] },
-      },
-    });
-    expect(result).toBe(true);
-  });
-
-  it("counts legacy {price,enabled} apps", () => {
-    const result = checkForMultiplePaymentApps({
-      apps: {
-        stripe: { enabled: true, price: 100 },
-        paypal: { enabled: true, price: 200 },
-      },
-    });
-    expect(result).toBe(true);
-  });
-
-  it("inclusive mode returns true for exactly one payment app", () => {
-    const result = checkForMultiplePaymentApps(
-      { apps: { stripe: { enabled: true, appCategories: ["payment"] } } },
-      true
-    );
-    expect(result).toBe(true);
-  });
-
-  it("non-inclusive mode requires strictly more than one", () => {
-    const result = checkForMultiplePaymentApps({
-      apps: { stripe: { enabled: true, appCategories: ["payment"] } },
-    });
-    expect(result).toBe(false);
-  });
-
-  it("tolerates an undefined apps entry", () => {
-    const result = checkForMultiplePaymentApps({
-      apps: { stripe: undefined },
-    });
-    expect(result).toBe(false);
-  });
-});
-
-describe("getPaymentAppData", () => {
-  it("returns disabled payment defaults when metadata.apps is missing", () => {
-    expect(getPaymentAppData({})).toEqual({
-      enabled: false,
-      price: 0,
-      currency: "usd",
-      appId: null,
-    });
-  });
-
-  it("returns the first enabled priced app", () => {
-    const data = getPaymentAppData({
-      metadata: {
-        apps: {
-          stripe: { enabled: true, price: 2500, currency: "eur", paymentOption: "HOLD" },
-        },
-      },
-    });
-    expect(data).toEqual(
-      expect.objectContaining({
-        enabled: true,
-        price: 2500,
-        currency: "eur",
-        appId: "stripe",
-        paymentOption: "HOLD",
-      })
-    );
-  });
-
-  it("prefers eventType price/currency when present", () => {
-    const data = getPaymentAppData({
-      price: 100,
-      currency: "brl",
-      metadata: {
-        apps: { stripe: { enabled: true, price: 2500, currency: "eur" } },
-      },
-    });
-    expect(data.price).toBe(100);
-    expect(data.currency).toBe("brl");
-  });
-
-  it("falls back to disabled defaults when no priced app is enabled", () => {
-    const data = getPaymentAppData({
-      metadata: { apps: { stripe: { enabled: false, price: 100 } } },
-    });
-    expect(data.enabled).toBe(false);
-    expect(data.appId).toBeNull();
-    expect(data.paymentOption).toBe("ON_BOOKING");
-  });
-});
-
-describe("getSuccessPageLocationMessage", () => {
-  it("returns empty string for missing location", () => {
-    expect(getSuccessPageLocationMessage(undefined, (k: string) => k)).toBe("");
-    expect(getSuccessPageLocationMessage("", (k: string) => k)).toBe("");
-  });
-
-  it("translates a URL location to the confirmation email pointer", () => {
-    expect(getSuccessPageLocationMessage("https://cal.com", (k: string) => k)).toBe(
-      "meeting_url_in_confirmation_email"
-    );
-  });
-
-  it("returns the location string verbatim for non-URL values", () => {
-    expect(getSuccessPageLocationMessage("My Office", (k: string) => k)).toBe("My Office");
-  });
-});

package/src/vendor/__tests__/query-param.test.ts

@@ -1,70 +0,0 @@
-import { beforeEach, describe, expect, it } from "vitest";
-import { getQueryParam, removeQueryParam, updateQueryParam } from "../query-param";
-
-describe("updateQueryParam / getQueryParam / removeQueryParam", () => {
-  beforeEach(() => {
-    window.history.replaceState({}, "", "/?initial=1");
-  });
-
-  it("getQueryParam reads a param from the current URL", () => {
-    expect(getQueryParam("initial")).toBe("1");
-    expect(getQueryParam("missing")).toBe(null);
-  });
-
-  it("updateQueryParam with shouldReplace=true uses replaceState and sets the param", () => {
-    updateQueryParam("foo", "bar");
-    expect(new URL(window.location.href).searchParams.get("foo")).toBe("bar");
-  });
-
-  it("updateQueryParam with shouldReplace=false uses pushState", () => {
-    const initialLength = window.history.length;
-    updateQueryParam("push", "value", false);
-    expect(new URL(window.location.href).searchParams.get("push")).toBe("value");
-    expect(window.history.length).toBeGreaterThanOrEqual(initialLength);
-  });
-
-  it("updateQueryParam with empty string removes the param", () => {
-    window.history.replaceState({}, "", "/?keep=y");
-    updateQueryParam("keep", "");
-    expect(new URL(window.location.href).searchParams.get("keep")).toBe(null);
-  });
-
-  it('updateQueryParam with value "null" removes the param', () => {
-    window.history.replaceState({}, "", "/?nullable=x");
-    updateQueryParam("nullable", "null");
-    expect(new URL(window.location.href).searchParams.get("nullable")).toBe(null);
-  });
-
-  it("updateQueryParam is a no-op when value already matches", () => {
-    window.history.replaceState({}, "", "/?same=1");
-    const before = window.location.href;
-    updateQueryParam("same", "1");
-    expect(window.location.href).toBe(before);
-  });
-
-  it("updateQueryParam accepts numeric values", () => {
-    updateQueryParam("count", 42);
-    expect(new URL(window.location.href).searchParams.get("count")).toBe("42");
-  });
-
-  it("removeQueryParam removes an existing param via replaceState", () => {
-    window.history.replaceState({}, "", "/?todelete=1&keep=2");
-    removeQueryParam("todelete");
-    const url = new URL(window.location.href);
-    expect(url.searchParams.get("todelete")).toBe(null);
-    expect(url.searchParams.get("keep")).toBe("2");
-  });
-
-  it("removeQueryParam with shouldReplace=false uses pushState", () => {
-    window.history.replaceState({}, "", "/?todelete=1");
-    removeQueryParam("todelete", false);
-    expect(new URL(window.location.href).searchParams.get("todelete")).toBe(null);
-  });
-
-  it("removeQueryParam is a no-op when the param doesn't exist", () => {
-    window.history.replaceState({}, "", "/?exists=1");
-    const before = window.location.href;
-    removeQueryParam("missing");
-    expect(window.location.href).toBe(before);
-  });
-});

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

@@ -1,104 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { Frequency, getEveryFreqFor, getRecurringFreq } from "../recurring";
-
-const translate = (key: string, options?: Record<string, unknown>) => {
-  if (options && "freq" in options) return `every ${(options as { freq: string }).freq}`;
-  if (options && "count" in options && key === "occurrence") {
-    return (options as { count: number }).count === 1 ? "occurrence" : "occurrences";
-  }
-  return key;
-};
-
-describe("getRecurringFreq", () => {
-  it("returns formatted frequency string when interval > 1", () => {
-    const result = getRecurringFreq({
-      t: translate,
-      recurringEvent: { freq: Frequency.WEEKLY, interval: 2, count: 4 },
-    });
-    expect(result).toBe("every 2 weekly");
-  });
-
-  it("omits the numeric prefix when interval is 1", () => {
-    const result = getRecurringFreq({
-      t: translate,
-      recurringEvent: { freq: Frequency.WEEKLY, interval: 1, count: 4 },
-    });
-    expect(result).toBe("every  weekly");
-  });
-
-  it("returns empty string when interval is 0", () => {
-    expect(
-      getRecurringFreq({
-        t: translate,
-        recurringEvent: { freq: Frequency.WEEKLY, interval: 0, count: 4 },
-      })
-    ).toBe("");
-  });
-
-  it("returns empty string when freq is negative", () => {
-    expect(
-      getRecurringFreq({
-        t: translate,
-        recurringEvent: { freq: -1 as Frequency, interval: 1, count: 4 },
-      })
-    ).toBe("");
-  });
-
-  it("calls translator with the expected count", () => {
-    const spy = vi.fn(translate);
-    getRecurringFreq({
-      t: spy,
-      recurringEvent: { freq: Frequency.DAILY, interval: 3, count: 4 },
-    });
-    expect(spy).toHaveBeenCalledWith("daily", { count: 3 });
-  });
-});
-
-describe("getEveryFreqFor", () => {
-  it("composes freq + count + occurrence", () => {
-    const result = getEveryFreqFor({
-      t: translate,
-      recurringEvent: { freq: Frequency.WEEKLY, interval: 2, count: 4 },
-      recurringCount: 3,
-    });
-    expect(result).toBe("every 2 weekly 3 occurrences");
-  });
-
-  it("falls back to recurringEvent.count when recurringCount is not provided", () => {
-    const result = getEveryFreqFor({
-      t: translate,
-      recurringEvent: { freq: Frequency.WEEKLY, interval: 1, count: 2 },
-    });
-    expect(result).toBe("every  weekly 2 occurrences");
-  });
-
-  it("uses provided recurringFreq override instead of computing it", () => {
-    const result = getEveryFreqFor({
-      t: translate,
-      recurringEvent: { freq: Frequency.WEEKLY, interval: 1, count: 1 },
-      recurringFreq: "custom-freq",
-      recurringCount: 1,
-    });
-    expect(result).toBe("custom-freq 1 occurrence");
-  });
-
-  it("returns empty string when freq is null/undefined", () => {
-    const result = getEveryFreqFor({
-      t: translate,
-      recurringEvent: { freq: null as unknown as Frequency, interval: 1, count: 1 },
-    });
-    expect(result).toBe("");
-  });
-});
-
-describe("Frequency", () => {
-  it("maps canonical rrule numeric values", () => {
-    expect(Frequency.YEARLY).toBe(0);
-    expect(Frequency.MONTHLY).toBe(1);
-    expect(Frequency.WEEKLY).toBe(2);
-    expect(Frequency.DAILY).toBe(3);
-    expect(Frequency.HOURLY).toBe(4);
-    expect(Frequency.MINUTELY).toBe(5);
-    expect(Frequency.SECONDLY).toBe(6);
-  });
-});

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

@@ -1,48 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { slugify } from "../slugify";
-
-describe("slugify", () => {
-  it("returns empty string for empty input", () => {
-    expect(slugify("")).toBe("");
-  });
-
-  it("lowercases and trims input", () => {
-    expect(slugify("  Hello World  ")).toBe("hello-world");
-  });
-
-  it("replaces spaces and underscores with dashes", () => {
-    expect(slugify("hello_world test")).toBe("hello-world-test");
-  });
-
-  it("strips diacritics", () => {
-    expect(slugify("café résumé naïve")).toBe("cafe-resume-naive");
-  });
-
-  it("preserves periods but collapses consecutive periods", () => {
-    expect(slugify("foo..bar...baz")).toBe("foo.bar.baz");
-  });
-
-  it("removes leading periods", () => {
-    expect(slugify("...foo")).toBe("foo");
-  });
-
-  it("collapses multiple dashes into one", () => {
-    expect(slugify("foo---bar")).toBe("foo-bar");
-  });
-
-  it("trims trailing dashes when not forDisplayingInput", () => {
-    expect(slugify("hello-")).toBe("hello");
-  });
-
-  it("keeps trailing dashes when forDisplayingInput=true", () => {
-    expect(slugify("hello-", true)).toBe("hello-");
-  });
-
-  it("removes emoji/symbols", () => {
-    expect(slugify("foo ☀ bar")).toBe("foo-bar");
-  });
-
-  it("strips trailing periods when not forDisplayingInput", () => {
-    expect(slugify("hello.")).toBe("hello");
-  });
-});

package/src/vendor/__tests__/time-shift.test.ts

@@ -1,48 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { getFirstShiftFlags, getTimeShiftFlags } from "../time-shift";
-
-describe("getTimeShiftFlags", () => {
-  it("returns empty array for empty input", () => {
-    expect(getTimeShiftFlags({ dates: [], timezone: "UTC" })).toEqual([]);
-  });
-
-  it("first entry is always false; subsequent entries flag hour/minute shifts against the first", () => {
-    const base = "2024-06-01T10:00:00Z";
-    const sameTime = "2024-06-02T10:00:00Z";
-    const shifted = "2024-06-03T11:00:00Z";
-    const flags = getTimeShiftFlags({ dates: [base, sameTime, shifted], timezone: "UTC" });
-    expect(flags).toEqual([false, false, true]);
-  });
-
-  it("flags minute shifts relative to the base entry", () => {
-    const base = "2024-06-01T10:00:00Z";
-    const shifted = "2024-06-02T10:30:00Z";
-    const flags = getTimeShiftFlags({ dates: [base, shifted], timezone: "UTC" });
-    expect(flags).toEqual([false, true]);
-  });
-});
-
-describe("getFirstShiftFlags", () => {
-  it("returns only the first true as true and zeroes the rest", () => {
-    expect(getFirstShiftFlags([false, false, true, true, false, true])).toEqual([
-      false,
-      false,
-      true,
-      false,
-      false,
-      false,
-    ]);
-  });
-
-  it("returns all false for an all-false input", () => {
-    expect(getFirstShiftFlags([false, false, false])).toEqual([false, false, false]);
-  });
-
-  it("returns first true preserved when only one shift present", () => {
-    expect(getFirstShiftFlags([false, true, false])).toEqual([false, true, false]);
-  });
-
-  it("returns empty array for empty input", () => {
-    expect(getFirstShiftFlags([])).toEqual([]);
-  });
-});