Skip to content

Email for professionals and teams

12.8 KB
Raw Blame
import { defaultTranslator, type Translator } from "@/lib/i18n/utils";
import type { CalendarEvent, CalendarEventTimes, EventGroup, EventResizeEdge } from "./types";
import type { FolderColor } from "@/lib/folders/types";
import type { CalendarRepeat } from "@/lib/calendar/types";
import { parseCalendarRepeatDays, parseExcludedOccurrences } from "@/lib/calendar/recurrence";
import { dateFromZonedFields, formatUserDate, getDisplayLocale, formatUserDateTimeLocal, getUserTimeZone, parseUserDateTimeLocal, zonedDateFields } from "@/lib/time/utils";

export const CALENDAR_START_HOUR = 0;
export const CALENDAR_END_HOUR = 24;
export const CALENDAR_HOUR_HEIGHT = 36;
export const UPCOMING_BATCH_SIZE = 14;
export const WEEKDAY_OPTIONS = [
  { value: 0, label: "Sun" }, { value: 1, label: "Mon" }, { value: 2, label: "Tue" },
  { value: 3, label: "Wed" }, { value: 4, label: "Thu" }, { value: 5, label: "Fri" },
  { value: 6, label: "Sat" },
] as const;

export const EVENT_COLOR_CLASSES: Record<FolderColor, string> = {
  "#2563eb": "bg-blue-600 text-white",
  "#7c3aed": "bg-violet-600 text-white",
  "#db2777": "bg-pink-600 text-white",
  "#dc2626": "bg-red-600 text-white",
  "#ea580c": "bg-orange-600 text-white",
  "#d97706": "bg-amber-600 text-white",
  "#16a34a": "bg-green-600 text-white",
  "#0d9488": "bg-teal-600 text-white",
};

export const PAST_EVENT_COLOR_CLASSES: Record<FolderColor, string> = {
  "#2563eb": "bg-blue-200 text-blue-900",
  "#7c3aed": "bg-violet-200 text-violet-900",
  "#db2777": "bg-pink-200 text-pink-900",
  "#dc2626": "bg-red-200 text-red-900",
  "#ea580c": "bg-orange-200 text-orange-900",
  "#d97706": "bg-amber-200 text-amber-900",
  "#16a34a": "bg-green-200 text-green-900",
  "#0d9488": "bg-teal-200 text-teal-900",
};

function recurringStart(first: Date, repeat: CalendarRepeat, index: number, timeZone: string, anchorDay?: number | null): Date {
  if (index === 0) return new Date(first);
  const fields = zonedDateFields(first, timeZone);
  if (repeat === "monthly") {
    const day = anchorDay ?? fields.getUTCDate();
    fields.setUTCDate(1);
    fields.setUTCMonth(fields.getUTCMonth() + index);
    const lastDay = new Date(Date.UTC(fields.getUTCFullYear(), fields.getUTCMonth() + 1, 0)).getUTCDate();
    fields.setUTCDate(Math.min(day, lastDay));
  } else {
    fields.setUTCDate(fields.getUTCDate() + index * (repeat === "weekly" ? 7 : 1));
  }
  return dateFromZonedFields(fields, timeZone);
}

export function calendarTimeZone(_event?: CalendarEvent | null): string {
  return getUserTimeZone();
}

export function calendarAnchorDay(event: CalendarEvent | null, value: Date): number {
  return zonedDateFields(value, calendarTimeZone(event)).getUTCDate();
}

function recurrenceStartIndex(first: Date, repeat: CalendarRepeat, after: Date, timeZone: string): number {
  const start = zonedDateFields(first, timeZone);
  const end = zonedDateFields(after, timeZone);
  if (repeat === "monthly") return Math.max(0, (end.getUTCFullYear() - start.getUTCFullYear()) * 12 + end.getUTCMonth() - start.getUTCMonth() - 1);
  return Math.max(0, Math.floor((end.getTime() - start.getTime()) / (86_400_000 * (repeat === "weekly" ? 7 : 1))) - 1);
}

export function expandCalendarEvents(events: CalendarEvent[], rangeStart: Date, rangeEnd: Date): CalendarEvent[] {
  const occurrences: CalendarEvent[] = [];
  for (const event of events) {
    const first = new Date(event.startsAt);
    const duration = new Date(event.endsAt).getTime() - first.getTime();
    if (event.repeat === "none") {
      if (first < rangeEnd && first.getTime() + duration > rangeStart.getTime()) occurrences.push(event);
      continue;
    }
    const until = event.repeatUntil ? new Date(event.repeatUntil).getTime() : Infinity;
    const repeatDays = parseCalendarRepeatDays(event.repeatDays);
    const excluded = new Set(parseExcludedOccurrences(event.excludedOccurrences));
    const timeZone = calendarTimeZone(event);
    const firstIndex = recurrenceStartIndex(first, event.repeat, new Date(rangeStart.getTime() - duration), timeZone);
    for (let index = firstIndex; index < firstIndex + 20_000; index++) {
      const startsAt = recurringStart(first, event.repeat, index, timeZone, event.repeatAnchorDay);
      if (startsAt >= rangeEnd || startsAt.getTime() >= until) break;
      if (excluded.has(startsAt.getTime()) || (event.repeat === "weekdays" && !repeatDays.includes(zonedDateFields(startsAt, timeZone).getUTCDay()))) continue;
      const endsAt = new Date(startsAt.getTime() + duration);
      if (endsAt > rangeStart) occurrences.push({ ...event, id: `${event.id}@${startsAt.getTime()}`, seriesStartsAt: event.startsAt, startsAt: startsAt.toISOString(), endsAt: endsAt.toISOString() });
    }
  }
  return occurrences.sort((a, b) => a.startsAt.localeCompare(b.startsAt));
}

export function nextCalendarOccurrence(event: CalendarEvent, after: Date): Date | null {
  const first = new Date(event.seriesStartsAt ?? event.startsAt);
  const until = event.repeatUntil ? new Date(event.repeatUntil).getTime() : Infinity;
  const repeatDays = parseCalendarRepeatDays(event.repeatDays);
  const excluded = new Set(parseExcludedOccurrences(event.excludedOccurrences));
  const timeZone = calendarTimeZone(event);
  const firstIndex = recurrenceStartIndex(first, event.repeat, after, timeZone);
  for (let index = firstIndex; index < firstIndex + 20_000; index++) {
    const startsAt = recurringStart(first, event.repeat, index, timeZone, event.repeatAnchorDay);
    if (startsAt.getTime() >= until) return null;
    if (startsAt < after || excluded.has(startsAt.getTime()) || (event.repeat === "weekdays" && !repeatDays.includes(zonedDateFields(startsAt, timeZone).getUTCDay()))) continue;
    return startsAt;
  }
  return null;
}

export function rescheduleCalendarOccurrence(event: CalendarEvent, startsAt: Date, endsAt: Date, effectiveFrom: Date): CalendarEventTimes | null {
  const timeZone = calendarTimeZone(event);
  const shift = zonedDateFields(startsAt, timeZone).getTime() - zonedDateFields(new Date(event.startsAt), timeZone).getTime();
  const threshold = dateFromZonedFields(new Date(zonedDateFields(effectiveFrom, timeZone).getTime() - shift), timeZone);
  let next = nextCalendarOccurrence(event, threshold);
  while (next) {
    const savedStart = shift === 0 ? next : dateFromZonedFields(new Date(zonedDateFields(next, timeZone).getTime() + shift), timeZone);
    if (savedStart >= effectiveFrom) return { startsAt: savedStart, endsAt: new Date(savedStart.getTime() + endsAt.getTime() - startsAt.getTime()) };
    next = nextCalendarOccurrence(event, new Date(next.getTime() + 1));
  }
  return null;
}

export function startOfDay(value: Date): Date {
  const fields = zonedDateFields(value, getUserTimeZone());
  fields.setUTCHours(0, 0, 0, 0);
  return dateFromZonedFields(fields, getUserTimeZone());
}

export function addDays(value: Date, days: number): Date {
  const fields = zonedDateFields(value, getUserTimeZone());
  fields.setUTCDate(fields.getUTCDate() + days);
  fields.setUTCHours(0, 0, 0, 0);
  return dateFromZonedFields(fields, getUserTimeZone());
}

export function addMonths(value: Date, months: number): Date {
  const fields = zonedDateFields(value, getUserTimeZone());
  fields.setUTCDate(1);
  fields.setUTCMonth(fields.getUTCMonth() + months);
  fields.setUTCHours(0, 0, 0, 0);
  return dateFromZonedFields(fields, getUserTimeZone());
}

export function startOfMonth(value: Date): Date {
  return addMonths(value, 0);
}

export function defaultCalendarStart(day: Date): Date {
  const hour = Math.min(Math.max(zonedDateFields(new Date(), getUserTimeZone()).getUTCHours() + 1, CALENDAR_START_HOUR), CALENDAR_END_HOUR - 1);
  const fields = zonedDateFields(day, getUserTimeZone());
  fields.setUTCHours(hour, 0, 0, 0);
  return dateFromZonedFields(fields, getUserTimeZone());
}

export function monthGridDates(month: Date): Date[] {
  const first = startOfMonth(month);
  const gridStart = addDays(first, -zonedDateFields(first, getUserTimeZone()).getUTCDay());
  return Array.from({ length: 42 }, (_, index) => addDays(gridStart, index));
}

export function startOfWeek(value: Date): Date {
  return addDays(startOfDay(value), -zonedDateFields(value, getUserTimeZone()).getUTCDay());
}

export function dateKey(value: Date): string {
  return zonedDateFields(value, getUserTimeZone()).toISOString().slice(0, 10);
}

export function formatLocalDateTime(value: Date): string {
  return formatUserDateTimeLocal(value);
}

export function eventEndAfterMinutes(start: string, minutes: number): string {
  const startDate = parseUserDateTimeLocal(start);
  if (!startDate) return "";
  return formatLocalDateTime(new Date(startDate.getTime() + minutes * 60_000));
}

export function currentTimePosition(value: Date): number {
  const fields = zonedDateFields(value, getUserTimeZone());
  return ((fields.getUTCHours() - CALENDAR_START_HOUR) * 60 + fields.getUTCMinutes() + fields.getUTCSeconds() / 60) * CALENDAR_HOUR_HEIGHT / 60;
}

export function formatHour(hour: number): string {
  return new Date(2026, 0, 1, hour).toLocaleTimeString(getDisplayLocale(), { hour: "numeric" });
}

export function formatEventTime(value: Date): string {
  const minutes = zonedDateFields(value, getUserTimeZone()).getUTCMinutes();
  return formatUserDate(value, { hour: "numeric", minute: minutes ? "2-digit" : undefined });
}

export function formatEventRange(event: CalendarEvent): string {
  const start = new Date(event.startsAt);
  const end = new Date(event.endsAt);
  return `${formatEventTime(start)} – ${formatEventTime(end)}`;
}

export function groupUpcomingEvents(events: CalendarEvent[], today: Date, t: Translator = defaultTranslator): EventGroup[] {
  const todayStart = startOfDay(today);
  const tomorrowStart = addDays(todayStart, 1);
  const groups: EventGroup[] = [];

  for (const event of events) {
    const eventDate = startOfDay(new Date(event.startsAt));
    if (eventDate < todayStart) continue;
    const key = dateKey(eventDate);
    const label = key === dateKey(todayStart)
      ? t("calendar.today")
      : key === dateKey(tomorrowStart)
        ? t("calendar.tomorrow")
        : formatUserDate(eventDate, { month: "short", day: "numeric", year: "numeric" });
    const lastGroup = groups[groups.length - 1];
    if (lastGroup?.key === key) lastGroup.events.push(event);
    else groups.push({ key, label, events: [event] });
  }

  return groups;
}

export function takeUpcomingGroups(groups: EventGroup[], count: number): EventGroup[] {
  const visible: EventGroup[] = [];
  let remaining = count;
  for (const group of groups) {
    if (remaining <= 0) break;
    const events = group.events.slice(0, remaining);
    if (events.length) visible.push({ ...group, events });
    remaining -= events.length;
  }
  return visible;
}

export function eventPosition(event: CalendarEvent, day: Date): { top: number; height: number } | null {
  const start = new Date(event.startsAt);
  const end = new Date(event.endsAt);
  const dayStart = startOfDay(day);
  const dayEnd = addDays(dayStart, 1);
  if (start >= dayEnd || end <= dayStart) return null;
  const startFields = zonedDateFields(start, getUserTimeZone());
  const endFields = zonedDateFields(end, getUserTimeZone());
  const startMinutes = start <= dayStart ? 0 : startFields.getUTCHours() * 60 + startFields.getUTCMinutes() + startFields.getUTCSeconds() / 60;
  const endMinutes = end >= dayEnd ? 24 * 60 : endFields.getUTCHours() * 60 + endFields.getUTCMinutes() + endFields.getUTCSeconds() / 60;
  // A repeated hour can put the end above the start on this wall-clock grid.
  const heightMinutes = endMinutes > startMinutes ? endMinutes - startMinutes : 15;
  return {
    top: (startMinutes - CALENDAR_START_HOUR * 60) * CALENDAR_HOUR_HEIGHT / 60,
    height: heightMinutes * CALENDAR_HOUR_HEIGHT / 60,
  };
}

export function dropStartForPosition(day: Date, pixelsFromTop: number): Date {
  const minutes = Math.max(0, Math.min(24 * 60 - 15, Math.round(pixelsFromTop * 60 / CALENDAR_HOUR_HEIGHT / 15) * 15));
  const fields = zonedDateFields(startOfDay(day), getUserTimeZone());
  fields.setUTCMinutes(minutes);
  return dateFromZonedFields(fields, getUserTimeZone());
}

export function resizeEventTimes(event: CalendarEvent, day: Date, edge: EventResizeEdge, pixelsFromTop: number): { startsAt: Date; endsAt: Date } {
  const minimum = edge === "start" ? 0 : 15;
  const maximum = edge === "start" ? 24 * 60 - 15 : 24 * 60;
  const minutes = Math.max(minimum, Math.min(maximum, Math.round(pixelsFromTop * 60 / CALENDAR_HOUR_HEIGHT / 15) * 15));
  const fields = zonedDateFields(startOfDay(day), getUserTimeZone());
  fields.setUTCMinutes(minutes);
  const boundary = dateFromZonedFields(fields, getUserTimeZone());
  const startsAt = new Date(event.startsAt);
  const endsAt = new Date(event.endsAt);
  if (edge === "start") {
    return { startsAt: new Date(Math.min(boundary.getTime(), endsAt.getTime() - 15 * 60_000)), endsAt };
  }
  return { startsAt, endsAt: new Date(Math.max(boundary.getTime(), startsAt.getTime() + 15 * 60_000)) };
}