diff --git a/src/preferences.test.ts b/src/preferences.test.ts new file mode 100644 index 0000000..2bb8389 --- /dev/null +++ b/src/preferences.test.ts @@ -0,0 +1,59 @@ +import { describe, it, expect } from "vitest"; +import { resolvePreferences } from "./preferences"; + +function makeRequest(url: string, cookieHeader?: string): { request: Request; url: URL } { + const parsed = new URL(url); + const headers = new Headers(); + if (cookieHeader) { + headers.set("Cookie", cookieHeader); + } + return { request: new Request(url, { headers }), url: parsed }; +} + +describe("resolvePreferences", () => { + it("defaults to eastern, system, vcr", () => { + const { request, url } = makeRequest("https://vcr.test/week"); + const prefs = resolvePreferences(request, url); + expect(prefs.tz).toBe("eastern"); + expect(prefs.theme).toBe("system"); + expect(prefs.mode).toBe("vcr"); + }); + + it("reads tz from query param", () => { + const { request, url } = makeRequest("https://vcr.test/week?tz=amsterdam"); + const prefs = resolvePreferences(request, url); + expect(prefs.tz).toBe("amsterdam"); + }); + + it("reads tz from cookie when no query param", () => { + const { request, url } = makeRequest("https://vcr.test/week", "tz=pacific"); + const prefs = resolvePreferences(request, url); + expect(prefs.tz).toBe("pacific"); + }); + + it("query param overrides cookie", () => { + const { request, url } = makeRequest("https://vcr.test/week?tz=central", "tz=pacific"); + const prefs = resolvePreferences(request, url); + expect(prefs.tz).toBe("central"); + }); + + it("ignores invalid tz values", () => { + const { request, url } = makeRequest("https://vcr.test/week?tz=mars"); + const prefs = resolvePreferences(request, url); + expect(prefs.tz).toBe("eastern"); + }); + + it("sets cookies when preferences change via query param", () => { + const { request, url } = makeRequest("https://vcr.test/week?tz=amsterdam&theme=dark"); + const prefs = resolvePreferences(request, url); + expect(prefs.setCookies.length).toBeGreaterThan(0); + expect(prefs.setCookies.some((c) => c.includes("tz=amsterdam"))).toBe(true); + expect(prefs.setCookies.some((c) => c.includes("theme=dark"))).toBe(true); + }); + + it("reads mode from query param", () => { + const { request, url } = makeRequest("https://vcr.test/week?mode=all"); + const prefs = resolvePreferences(request, url); + expect(prefs.mode).toBe("all"); + }); +}); diff --git a/src/preferences.ts b/src/preferences.ts index c6c9820..a06dbe2 100644 --- a/src/preferences.ts +++ b/src/preferences.ts @@ -1,5 +1,76 @@ -import type { Preferences } from "./types"; +import { isValidTimezoneKey } from "./time/zones"; +import type { Preferences, TimezoneKey, ThemeKey, ModeKey } from "./types"; +import { getCurrentWeek } from "./time/week"; -export function resolvePreferences(_request: Request, _url: URL): Preferences { - return { tz: "eastern", theme: "system", mode: "vcr", week: "", setCookies: [] }; +const VALID_THEMES = new Set(["system", "light", "dark"]); +const VALID_MODES = new Set(["vcr", "all"]); +const COOKIE_MAX_AGE = 31_536_000; + +function parseCookies(header: string): Record { + const cookies: Record = {}; + for (const part of header.split(";")) { + const [key, ...rest] = part.trim().split("="); + if (key) cookies[key.trim()] = rest.join("=").trim(); + } + return cookies; +} + +function makeCookie(name: string, value: string): string { + return `${name}=${value}; Path=/; SameSite=Lax; Max-Age=${COOKIE_MAX_AGE}`; +} + +function clearCookie(name: string): string { + return `${name}=; Path=/; SameSite=Lax; Max-Age=0`; +} + +export function resolvePreferences(request: Request, url: URL): Preferences { + const params = url.searchParams; + const cookieHeader = request.headers.get("Cookie") ?? ""; + const cookies = parseCookies(cookieHeader); + const setCookies: string[] = []; + + if (params.has("reset")) { + setCookies.push(clearCookie("tz"), clearCookie("theme"), clearCookie("mode")); + return { + tz: "eastern", + theme: "system", + mode: "vcr", + week: params.get("week") ?? getCurrentWeek("eastern"), + setCookies, + }; + } + + const tzParam = params.get("tz"); + const tzCookie = cookies["tz"]; + let tz: TimezoneKey = "eastern"; + if (tzParam && isValidTimezoneKey(tzParam)) { + tz = tzParam; + setCookies.push(makeCookie("tz", tz)); + } else if (tzCookie && isValidTimezoneKey(tzCookie)) { + tz = tzCookie; + } + + const themeParam = params.get("theme"); + const themeCookie = cookies["theme"]; + let theme: ThemeKey = "system"; + if (themeParam && VALID_THEMES.has(themeParam)) { + theme = themeParam as ThemeKey; + setCookies.push(makeCookie("theme", theme)); + } else if (themeCookie && VALID_THEMES.has(themeCookie)) { + theme = themeCookie as ThemeKey; + } + + const modeParam = params.get("mode"); + const modeCookie = cookies["mode"]; + let mode: ModeKey = "vcr"; + if (modeParam && VALID_MODES.has(modeParam)) { + mode = modeParam as ModeKey; + setCookies.push(makeCookie("mode", mode)); + } else if (modeCookie && VALID_MODES.has(modeCookie)) { + mode = modeCookie as ModeKey; + } + + const week = params.get("week") ?? getCurrentWeek(tz); + + return { tz, theme, mode, week, setCookies }; } diff --git a/src/time/week.test.ts b/src/time/week.test.ts new file mode 100644 index 0000000..7a1d173 --- /dev/null +++ b/src/time/week.test.ts @@ -0,0 +1,36 @@ +import { describe, it, expect } from "vitest"; +import { getCurrentWeek, getWeekBounds, getAdjacentWeeks } from "./week"; + +describe("getWeekBounds", () => { + it("returns Sunday-Saturday bounds for 2026-W45", () => { + const bounds = getWeekBounds("2026-W45", "eastern"); + expect(bounds.start.getUTCDay()).toBe(0); // Sunday + expect(bounds.label).toContain("Nov"); + }); + + it("returns correct label format", () => { + const bounds = getWeekBounds("2026-W45", "eastern"); + expect(bounds.label).toMatch(/\w+ \d+.+\d{4}/); + }); +}); + +describe("getAdjacentWeeks", () => { + it("returns prev and next weeks", () => { + const adj = getAdjacentWeeks("2026-W45"); + expect(adj.prev).toBe("2026-W44"); + expect(adj.next).toBe("2026-W46"); + }); + + it("handles year boundary (W01 -> previous year last week)", () => { + const adj = getAdjacentWeeks("2026-W01"); + expect(adj.prev).toMatch(/2025-W\d+/); + expect(adj.next).toBe("2026-W02"); + }); +}); + +describe("getCurrentWeek", () => { + it("returns a valid ISO week string", () => { + const week = getCurrentWeek("eastern"); + expect(week).toMatch(/^\d{4}-W\d{2}$/); + }); +}); diff --git a/src/time/week.ts b/src/time/week.ts new file mode 100644 index 0000000..8f44335 --- /dev/null +++ b/src/time/week.ts @@ -0,0 +1,86 @@ +import { TIMEZONE_CONFIG } from "./zones"; +import type { TimezoneKey } from "../types"; + +export function getCurrentWeek(tzKey: TimezoneKey): string { + const iana = TIMEZONE_CONFIG[tzKey].iana; + const now = new Date(); + const formatter = new Intl.DateTimeFormat("en-US", { + timeZone: iana, + year: "numeric", + month: "2-digit", + day: "2-digit", + weekday: "short", + }); + const parts = formatter.formatToParts(now); + const year = parseInt(parts.find((p) => p.type === "year")!.value); + const month = parseInt(parts.find((p) => p.type === "month")!.value) - 1; + const day = parseInt(parts.find((p) => p.type === "day")!.value); + + const localDate = new Date(Date.UTC(year, month, day)); + return dateToIsoWeek(localDate); +} + +export function getWeekBounds( + isoWeek: string, + _tzKey: TimezoneKey +): { start: Date; end: Date; label: string } { + const sunday = isoWeekToSunday(isoWeek); + const saturday = new Date(sunday); + saturday.setUTCDate(saturday.getUTCDate() + 6); + + const startMonth = sunday.toLocaleDateString("en-US", { month: "short", timeZone: "UTC" }); + const endMonth = saturday.toLocaleDateString("en-US", { month: "short", timeZone: "UTC" }); + const year = saturday.getUTCFullYear(); + + const label = + startMonth === endMonth + ? `${startMonth} ${sunday.getUTCDate()}–${saturday.getUTCDate()}, ${year}` + : `${startMonth} ${sunday.getUTCDate()} – ${endMonth} ${saturday.getUTCDate()}, ${year}`; + + return { start: sunday, end: saturday, label }; +} + +export function getAdjacentWeeks(isoWeek: string): { prev: string; next: string } { + const sunday = isoWeekToSunday(isoWeek); + + const prevSunday = new Date(sunday); + prevSunday.setUTCDate(prevSunday.getUTCDate() - 7); + + const nextSunday = new Date(sunday); + nextSunday.setUTCDate(nextSunday.getUTCDate() + 7); + + return { prev: dateToIsoWeek(prevSunday), next: dateToIsoWeek(nextSunday) }; +} + +function isoWeekToSunday(isoWeek: string): Date { + const [yearStr, weekStr] = isoWeek.split("-W"); + const year = parseInt(yearStr); + const week = parseInt(weekStr); + + const jan4 = new Date(Date.UTC(year, 0, 4)); + const jan4Day = jan4.getUTCDay(); + const mondayOfWeek1 = new Date(jan4); + mondayOfWeek1.setUTCDate(jan4.getUTCDate() - ((jan4Day + 6) % 7)); + + const mondayOfWeek = new Date(mondayOfWeek1); + mondayOfWeek.setUTCDate(mondayOfWeek1.getUTCDate() + (week - 1) * 7); + + const sunday = new Date(mondayOfWeek); + sunday.setUTCDate(mondayOfWeek.getUTCDate() - 1); + + return sunday; +} + +function dateToIsoWeek(date: Date): string { + const d = new Date(date); + const dayOfWeek = d.getUTCDay(); + const thursdayOffset = dayOfWeek === 0 ? 4 : 4 - dayOfWeek; + d.setUTCDate(d.getUTCDate() + thursdayOffset); + + const year = d.getUTCFullYear(); + const jan1 = new Date(Date.UTC(year, 0, 1)); + const daysDiff = Math.floor((d.getTime() - jan1.getTime()) / 86_400_000); + const weekNum = Math.floor(daysDiff / 7) + 1; + + return `${year}-W${String(weekNum).padStart(2, "0")}`; +} diff --git a/src/time/zones.test.ts b/src/time/zones.test.ts new file mode 100644 index 0000000..00eb893 --- /dev/null +++ b/src/time/zones.test.ts @@ -0,0 +1,48 @@ +import { describe, it, expect } from "vitest"; +import { TIMEZONE_CONFIG, convertTime } from "./zones"; +import type { TimezoneKey } from "../types"; + +describe("TIMEZONE_CONFIG", () => { + it("has all 5 supported timezones", () => { + const keys: TimezoneKey[] = ["eastern", "central", "pacific", "utc", "amsterdam"]; + for (const key of keys) { + expect(TIMEZONE_CONFIG[key]).toBeDefined(); + expect(TIMEZONE_CONFIG[key].iana).toBeTruthy(); + expect(TIMEZONE_CONFIG[key].label).toBeTruthy(); + } + }); +}); + +describe("convertTime", () => { + it("converts Eastern 22:00 to Central 21:00 (same day)", () => { + const ref = new Date("2026-11-03T00:00:00Z"); + const result = convertTime(22, 0, "America/New_York", "America/Chicago", ref); + expect(result.hour).toBe(21); + expect(result.minute).toBe(0); + expect(result.dayOffset).toBe(0); + }); + + it("converts Eastern 22:00 to UTC 03:00 (+1 day)", () => { + const ref = new Date("2026-11-03T00:00:00Z"); + const result = convertTime(22, 0, "America/New_York", "UTC", ref); + expect(result.hour).toBe(3); + expect(result.minute).toBe(0); + expect(result.dayOffset).toBe(1); + }); + + it("converts Eastern 22:00 to Amsterdam 04:00 (+1 day)", () => { + const ref = new Date("2026-11-03T00:00:00Z"); + const result = convertTime(22, 0, "America/New_York", "Europe/Amsterdam", ref); + expect(result.hour).toBe(4); + expect(result.minute).toBe(0); + expect(result.dayOffset).toBe(1); + }); + + it("handles half-hour times (20:30 Eastern to 19:30 Central)", () => { + const ref = new Date("2026-11-04T00:00:00Z"); + const result = convertTime(20, 30, "America/New_York", "America/Chicago", ref); + expect(result.hour).toBe(19); + expect(result.minute).toBe(30); + expect(result.dayOffset).toBe(0); + }); +}); diff --git a/src/time/zones.ts b/src/time/zones.ts new file mode 100644 index 0000000..a144542 --- /dev/null +++ b/src/time/zones.ts @@ -0,0 +1,70 @@ +import type { TimezoneKey } from "../types"; + +export const TIMEZONE_CONFIG: Record = { + eastern: { iana: "America/New_York", label: "Eastern" }, + central: { iana: "America/Chicago", label: "Central" }, + pacific: { iana: "America/Los_Angeles", label: "Pacific" }, + utc: { iana: "UTC", label: "UTC" }, + amsterdam: { iana: "Europe/Amsterdam", label: "Amsterdam" }, +}; + +const VALID_TZ_KEYS = new Set(Object.keys(TIMEZONE_CONFIG)); + +export function isValidTimezoneKey(value: string): value is TimezoneKey { + return VALID_TZ_KEYS.has(value); +} + +export function convertTime( + hour: number, + minute: number, + fromZone: string, + toZone: string, + referenceDate: Date +): { hour: number; minute: number; dayOffset: number } { + const refYear = referenceDate.getUTCFullYear(); + const refMonth = referenceDate.getUTCMonth(); + const refDay = referenceDate.getUTCDate(); + + const fromFormatter = new Intl.DateTimeFormat("en-US", { + timeZone: fromZone, + year: "numeric", + month: "2-digit", + day: "2-digit", + hour: "2-digit", + minute: "2-digit", + hour12: false, + }); + const toFormatter = new Intl.DateTimeFormat("en-US", { + timeZone: toZone, + year: "numeric", + month: "2-digit", + day: "2-digit", + hour: "2-digit", + minute: "2-digit", + hour12: false, + }); + + const roughUtc = new Date(Date.UTC(refYear, refMonth, refDay, hour, minute)); + + const fromParts = fromFormatter.formatToParts(roughUtc); + const fromHour = parseInt(fromParts.find((p) => p.type === "hour")!.value); + const fromMinute = parseInt(fromParts.find((p) => p.type === "minute")!.value); + + const wantedMinutes = hour * 60 + minute; + const gotMinutes = (fromHour === 24 ? 0 : fromHour) * 60 + fromMinute; + const offsetDiff = wantedMinutes - gotMinutes; + + const correctedUtc = new Date(roughUtc.getTime() + offsetDiff * 60_000); + + const toParts = toFormatter.formatToParts(correctedUtc); + const toHour = parseInt(toParts.find((p) => p.type === "hour")!.value); + const toMin = parseInt(toParts.find((p) => p.type === "minute")!.value); + const toDay = parseInt(toParts.find((p) => p.type === "day")!.value); + + const fromCorrectedParts = fromFormatter.formatToParts(correctedUtc); + const fromDay = parseInt(fromCorrectedParts.find((p) => p.type === "day")!.value); + + const dayOffset = toDay - fromDay; + + return { hour: toHour === 24 ? 0 : toHour, minute: toMin, dayOffset }; +}