@calcom/atoms 2.5.0 → 2.7.0

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

@@ -0,0 +1,219 @@
+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

@@ -0,0 +1,67 @@
+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

@@ -0,0 +1,126 @@
+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

@@ -0,0 +1,70 @@
+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

@@ -0,0 +1,104 @@
+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

@@ -0,0 +1,48 @@
+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

@@ -0,0 +1,48 @@
+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([]);
+  });
+});