@agent-native/core 0.159.5 → 0.160.1

package/corpus/templates/calendar/app/lib/calendar-timezone.ts

@@ -0,0 +1,351 @@
+import type { CalendarEvent } from "@shared/api";
+import {
+  addDays,
+  endOfMonth,
+  endOfWeek,
+  format,
+  startOfMonth,
+  startOfWeek,
+} from "date-fns";
+
+import { dateTimeInTimezoneToIso } from "./event-form-utils";
+
+export const DATE_ONLY_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
+
+export interface CalendarDateTimeParts {
+  date: string;
+  hour: number;
+  minute: number;
+  second: number;
+}
+
+export interface CalendarDayBounds {
+  date: string;
+  start: Date;
+  end: Date;
+}
+
+export interface CalendarEventSegment {
+  topMinutes: number;
+  durationMinutes: number;
+  startsOnDay: boolean;
+  endsOnDay: boolean;
+  startMinutes: number;
+  endMinutes: number;
+}
+
+export function getBrowserTimezone(): string {
+  try {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+  } catch {
+    return "UTC";
+  }
+}
+
+export function isValidTimezone(timezone: string): boolean {
+  try {
+    new Intl.DateTimeFormat("en-US", { timeZone: timezone }).format();
+    return true;
+  } catch (error) {
+    if (error instanceof RangeError) return false;
+    throw error;
+  }
+}
+
+export function normalizeTimezone(timezone?: string): string {
+  return timezone && isValidTimezone(timezone)
+    ? timezone
+    : getBrowserTimezone();
+}
+
+/** Date carriers are kept at local noon so browser DST never changes their date. */
+export function dateKeyToDate(date: string): Date {
+  const [year, month, day] = date.split("-").map(Number);
+  return new Date(year, month - 1, day, 12, 0, 0, 0);
+}
+
+export function dateToCalendarDateKey(date: Date): string {
+  return format(date, "yyyy-MM-dd");
+}
+
+export function addCalendarDays(date: string, amount: number): string {
+  const [year, month, day] = date.split("-").map(Number);
+  const next = new Date(Date.UTC(year, month - 1, day + amount));
+  return next.toISOString().slice(0, 10);
+}
+
+function dateTimeParts(value: Date | string, timezone: string) {
+  const parsed = value instanceof Date ? value : new Date(value);
+  if (Number.isNaN(parsed.getTime())) return null;
+
+  try {
+    const parts = new Intl.DateTimeFormat("en-US", {
+      timeZone: timezone,
+      hourCycle: "h23",
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit",
+    }).formatToParts(parsed);
+    const valueFor = (type: Intl.DateTimeFormatPartTypes) =>
+      parts.find((part) => part.type === type)?.value;
+    const year = valueFor("year");
+    const month = valueFor("month");
+    const day = valueFor("day");
+    const hour = valueFor("hour");
+    const minute = valueFor("minute");
+    const second = valueFor("second");
+    if (!year || !month || !day || !hour || !minute || !second) return null;
+
+    return {
+      date: `${year}-${month}-${day}`,
+      hour: Number(hour),
+      minute: Number(minute),
+      second: Number(second),
+    } satisfies CalendarDateTimeParts;
+  } catch (error) {
+    if (error instanceof RangeError) return null;
+    throw error;
+  }
+}
+
+export function getDateTimePartsInTimezone(
+  value: Date | string,
+  timezone: string,
+): CalendarDateTimeParts | null {
+  return dateTimeParts(value, normalizeTimezone(timezone));
+}
+
+export function getDateKeyInTimezone(
+  value: Date | string,
+  timezone: string,
+): string | null {
+  return dateTimeParts(value, normalizeTimezone(timezone))?.date ?? null;
+}
+
+export function dateKeyToTimezoneIso(
+  date: string,
+  time: string,
+  timezone: string,
+): string {
+  return dateTimeInTimezoneToIso(date, time, normalizeTimezone(timezone));
+}
+
+export function getCalendarDayBounds(
+  day: Date,
+  timezone: string,
+): CalendarDayBounds {
+  const normalizedTimezone = normalizeTimezone(timezone);
+  const date = dateToCalendarDateKey(day);
+  return {
+    date,
+    start: new Date(dateKeyToTimezoneIso(date, "00:00", normalizedTimezone)),
+    end: new Date(
+      dateKeyToTimezoneIso(
+        addCalendarDays(date, 1),
+        "00:00",
+        normalizedTimezone,
+      ),
+    ),
+  };
+}
+
+export function getViewDateRange(
+  viewMode: "month" | "week" | "day",
+  selectedDate: Date,
+  timezone: string,
+  weekStartsOn: 0 | 1 = 0,
+): { from: string; to: string } {
+  const normalizedTimezone = normalizeTimezone(timezone);
+  const weekOptions = { weekStartsOn };
+  let rangeStart: Date;
+  let rangeEndExclusive: Date;
+
+  if (viewMode === "month") {
+    rangeStart = startOfWeek(startOfMonth(selectedDate), weekOptions);
+    rangeEndExclusive = addDays(
+      endOfWeek(endOfMonth(selectedDate), weekOptions),
+      1,
+    );
+  } else if (viewMode === "week") {
+    rangeStart = startOfWeek(selectedDate, weekOptions);
+    rangeEndExclusive = addDays(endOfWeek(selectedDate, weekOptions), 1);
+  } else {
+    rangeStart = selectedDate;
+    rangeEndExclusive = addDays(selectedDate, 1);
+  }
+
+  return {
+    from: dateKeyToTimezoneIso(
+      dateToCalendarDateKey(rangeStart),
+      "00:00",
+      normalizedTimezone,
+    ),
+    to: dateKeyToTimezoneIso(
+      dateToCalendarDateKey(rangeEndExclusive),
+      "00:00",
+      normalizedTimezone,
+    ),
+  };
+}
+
+function dateOnlyPart(value: string | undefined): string | null {
+  if (!value) return null;
+  if (DATE_ONLY_PATTERN.test(value)) return value;
+  return value.slice(0, 10);
+}
+
+function eventDateRange(
+  event: Pick<CalendarEvent, "start" | "end" | "allDay">,
+  timezone: string,
+) {
+  if (event.allDay) {
+    const startDate = dateOnlyPart(event.start);
+    const endDate =
+      dateOnlyPart(event.end) ??
+      (startDate ? addCalendarDays(startDate, 1) : null);
+    return startDate && endDate ? { startDate, endDate } : null;
+  }
+
+  const start = getDateTimePartsInTimezone(event.start, timezone);
+  const end = getDateTimePartsInTimezone(event.end, timezone);
+  return start && end ? { startDate: start.date, endDate: end.date } : null;
+}
+
+export function getEventDateKey(
+  event: Pick<CalendarEvent, "start" | "end" | "allDay">,
+  timezone: string,
+): string | null {
+  return eventDateRange(event, timezone)?.startDate ?? null;
+}
+
+export function moveEventToCalendarDate(
+  event: Pick<CalendarEvent, "start" | "end" | "allDay">,
+  targetDate: Date,
+  timezone: string,
+): { start: string; end: string } | null {
+  const targetDateKey = dateToCalendarDateKey(targetDate);
+  const sourceStartDate = getEventDateKey(event, timezone);
+  if (!sourceStartDate) return null;
+
+  if (event.allDay) {
+    const sourceEndDate =
+      dateOnlyPart(event.end) ?? addCalendarDays(sourceStartDate, 1);
+    const spanDays = Math.max(
+      1,
+      Math.round(
+        (dateKeyToDate(sourceEndDate).getTime() -
+          dateKeyToDate(sourceStartDate).getTime()) /
+          (24 * 60 * 60 * 1000),
+      ),
+    );
+    return {
+      start: targetDateKey,
+      end: addCalendarDays(targetDateKey, spanDays),
+    };
+  }
+
+  const start = getDateTimePartsInTimezone(event.start, timezone);
+  const end = getDateTimePartsInTimezone(event.end, timezone);
+  if (!start || !end) return null;
+  const spanDays = Math.max(
+    0,
+    Math.round(
+      (dateKeyToDate(end.date).getTime() -
+        dateKeyToDate(start.date).getTime()) /
+        (24 * 60 * 60 * 1000),
+    ),
+  );
+  const startTime = `${String(start.hour).padStart(2, "0")}:${String(
+    start.minute,
+  ).padStart(2, "0")}`;
+  const endTime = `${String(end.hour).padStart(2, "0")}:${String(
+    end.minute,
+  ).padStart(2, "0")}`;
+  return {
+    start: dateKeyToTimezoneIso(targetDateKey, startTime, timezone),
+    end: dateKeyToTimezoneIso(
+      addCalendarDays(targetDateKey, spanDays),
+      endTime,
+      timezone,
+    ),
+  };
+}
+
+export function eventOverlapsCalendarDay(
+  event: Pick<CalendarEvent, "start" | "end" | "allDay">,
+  day: Date,
+  timezone: string,
+): boolean {
+  const normalizedTimezone = normalizeTimezone(timezone);
+  const dayBounds = getCalendarDayBounds(day, normalizedTimezone);
+  if (event.allDay) {
+    const range = eventDateRange(event, normalizedTimezone);
+    const dayDate = dayBounds.date;
+    return Boolean(
+      range && range.startDate <= dayDate && range.endDate > dayDate,
+    );
+  }
+
+  const start = new Date(event.start);
+  const end = new Date(event.end);
+  return (
+    !Number.isNaN(start.getTime()) &&
+    !Number.isNaN(end.getTime()) &&
+    start < dayBounds.end &&
+    end > dayBounds.start
+  );
+}
+
+function clockMinutes(parts: CalendarDateTimeParts): number {
+  return parts.hour * 60 + parts.minute + parts.second / 60;
+}
+
+export function getEventSegmentForCalendarDay(
+  event: Pick<CalendarEvent, "start" | "end">,
+  day: Date,
+  timezone: string,
+): CalendarEventSegment | null {
+  const normalizedTimezone = normalizeTimezone(timezone);
+  const dayBounds = getCalendarDayBounds(day, normalizedTimezone);
+  const rawStart = new Date(event.start);
+  const rawEnd = new Date(event.end);
+  if (
+    Number.isNaN(rawStart.getTime()) ||
+    Number.isNaN(rawEnd.getTime()) ||
+    rawStart >= dayBounds.end ||
+    rawEnd <= dayBounds.start
+  ) {
+    return null;
+  }
+
+  const start = getDateTimePartsInTimezone(rawStart, normalizedTimezone);
+  const end = getDateTimePartsInTimezone(rawEnd, normalizedTimezone);
+  if (!start || !end) return null;
+
+  const startMinutes =
+    start.date < dayBounds.date
+      ? 0
+      : start.date > dayBounds.date
+        ? 24 * 60
+        : clockMinutes(start);
+  const endMinutes =
+    end.date > dayBounds.date
+      ? 24 * 60
+      : end.date < dayBounds.date
+        ? 0
+        : clockMinutes(end);
+  const visibleStart = Math.max(0, Math.min(24 * 60, startMinutes));
+  const visibleEnd = Math.max(visibleStart, Math.min(24 * 60, endMinutes));
+
+  return {
+    topMinutes: visibleStart,
+    durationMinutes: Math.max(1, visibleEnd - visibleStart),
+    startsOnDay: start.date === dayBounds.date,
+    endsOnDay: end.date === dayBounds.date,
+    startMinutes: visibleStart,
+    endMinutes: visibleEnd,
+  };
+}

package/corpus/templates/calendar/app/lib/event-layout.ts

@@ -1,5 +1,9 @@
 import type { CalendarEvent } from "@shared/api";
-import { addDays, parseISO, startOfDay } from "date-fns";
+
+import {
+  getBrowserTimezone,
+  getEventSegmentForCalendarDay,
+} from "@/lib/calendar-timezone";
 
 export interface TimedEventLayout {
   left: number;
@@ -35,21 +39,23 @@ function overlaps(a: EventBounds, b: EventBounds): boolean {
 export function computeTimedEventLayout(
   dayEvents: readonly CalendarEvent[],
   day: Date,
+  timezone: string = getBrowserTimezone(),
 ): Map<string, TimedEventLayout> {
   const result = new Map<string, TimedEventLayout>();
   if (dayEvents.length === 0) return result;
 
-  const dayStartMs = startOfDay(day).getTime();
-  const dayEndMs = addDays(startOfDay(day), 1).getTime();
   const entries = dayEvents.map<EventEntry>((event, inputOrder) => {
-    const rawStart = parseISO(event.start).getTime();
-    const rawEnd = parseISO(event.end).getTime();
-    const start = Math.min(dayEndMs, Math.max(dayStartMs, rawStart));
+    const segment = getEventSegmentForCalendarDay(event, day, timezone);
+    const start = segment?.startMinutes ?? 0;
     // Match the card renderer's minimum height so tiny adjacent events get
     // collision-aware placement even when their raw times barely overlap.
     const end = Math.min(
-      dayEndMs,
-      Math.max(start, rawEnd, start + MIN_VISIBLE_EVENT_MINUTES * 60 * 1000),
+      24 * 60,
+      Math.max(
+        start,
+        segment?.endMinutes ?? start,
+        start + MIN_VISIBLE_EVENT_MINUTES,
+      ),
     );
 
     return { event, bounds: { start, end }, inputOrder };

package/corpus/templates/calendar/app/lib/out-of-office.ts

@@ -1,13 +1,12 @@
 import type { CalendarEvent } from "@shared/api";
-import {
-  addDays,
-  differenceInMinutes,
-  format,
-  parseISO,
-  startOfDay,
-} from "date-fns";
 
-import { dateTimeInTimezoneToIso } from "@/lib/event-form-utils";
+import {
+  dateKeyToTimezoneIso,
+  dateToCalendarDateKey,
+  getBrowserTimezone,
+  getDateTimePartsInTimezone,
+  getEventSegmentForCalendarDay,
+} from "@/lib/calendar-timezone";
 
 export interface OutOfOfficeSegment {
   topMinutes: number;
@@ -22,34 +21,6 @@ export function isOutOfOfficeEvent(
   return event.eventType === "outOfOffice";
 }
 
-function localDateTimeParts(value: string, timeZone: string) {
-  const date = parseISO(value);
-  if (Number.isNaN(date.getTime())) return null;
-
-  try {
-    const parts = new Intl.DateTimeFormat("en-US", {
-      timeZone,
-      year: "numeric",
-      month: "2-digit",
-      day: "2-digit",
-      hour: "2-digit",
-      minute: "2-digit",
-      hourCycle: "h23",
-    }).formatToParts(date);
-    const valueFor = (type: Intl.DateTimeFormatPartTypes) =>
-      parts.find((part) => part.type === type)?.value;
-    const year = valueFor("year");
-    const month = valueFor("month");
-    const day = valueFor("day");
-    const hour = valueFor("hour");
-    const minute = valueFor("minute");
-    if (!year || !month || !day || !hour || !minute) return null;
-    return { date: `${year}-${month}-${day}`, hour, minute };
-  } catch {
-    return null;
-  }
-}
-
 export function isFullDayOutOfOfficeEvent(
   event: Pick<
     CalendarEvent,
@@ -68,19 +39,15 @@ export function getFullDayOutOfOfficeDateRange(
   if (!isOutOfOfficeEvent(event) || event.allDay) return null;
   const timeZone = event.startTimeZone ?? event.endTimeZone;
   if (!timeZone) return null;
-  const start = localDateTimeParts(event.start, timeZone);
-  const end = localDateTimeParts(event.end, timeZone);
+  const start = getDateTimePartsInTimezone(event.start, timeZone);
+  const end = getDateTimePartsInTimezone(event.end, timeZone);
   const isFullDay =
     start !== null &&
     end !== null &&
     new Date(event.start).getTime() ===
-      new Date(
-        dateTimeInTimezoneToIso(start.date, "00:00", timeZone),
-      ).getTime() &&
+      new Date(dateKeyToTimezoneIso(start.date, "00:00", timeZone)).getTime() &&
     new Date(event.end).getTime() ===
-      new Date(
-        dateTimeInTimezoneToIso(end.date, "00:00", timeZone),
-      ).getTime() &&
+      new Date(dateKeyToTimezoneIso(end.date, "00:00", timeZone)).getTime() &&
     end.date > start.date;
   return isFullDay
     ? { startDate: start.date, endDateExclusive: end.date }
@@ -96,36 +63,37 @@ export function fullDayOutOfOfficeCoversDate(
 ): boolean {
   const range = getFullDayOutOfOfficeDateRange(event);
   if (!range) return false;
-  const dateString = format(date, "yyyy-MM-dd");
+  const dateString = dateToCalendarDateKey(date);
   return dateString >= range.startDate && dateString < range.endDateExclusive;
 }
 
 /** Return the portion of a timed out-of-office event visible on one day. */
 export function getOutOfOfficeSegment(
-  event: Pick<CalendarEvent, "start" | "end">,
+  event: Pick<CalendarEvent, "start" | "end" | "startTimeZone" | "endTimeZone">,
   day: Date,
+  timezone: string = event.startTimeZone ??
+    event.endTimeZone ??
+    getBrowserTimezone(),
 ): OutOfOfficeSegment | null {
-  const eventStart = parseISO(event.start);
-  const eventEnd = parseISO(event.end);
-  const dayStart = startOfDay(day);
-  const dayEnd = addDays(dayStart, 1);
-
-  if (eventStart >= dayEnd || eventEnd <= dayStart) return null;
-
-  const segmentStart = eventStart > dayStart ? eventStart : dayStart;
-  const segmentEnd = eventEnd < dayEnd ? eventEnd : dayEnd;
+  const segment = getEventSegmentForCalendarDay(event, day, timezone);
+  if (!segment) return null;
 
   return {
-    topMinutes: Math.max(0, differenceInMinutes(segmentStart, dayStart)),
-    durationMinutes: Math.max(1, differenceInMinutes(segmentEnd, segmentStart)),
-    startsOnDay: eventStart >= dayStart && eventStart < dayEnd,
-    endsOnDay: eventEnd > dayStart && eventEnd <= dayEnd,
+    topMinutes: segment.topMinutes,
+    durationMinutes: segment.durationMinutes,
+    startsOnDay: segment.startsOnDay,
+    endsOnDay: segment.endsOnDay,
   };
 }
 
 export function getFirstVisibleOutOfOfficeDayIndex(
-  event: Pick<CalendarEvent, "start" | "end">,
+  event: Pick<CalendarEvent, "start" | "end" | "startTimeZone" | "endTimeZone">,
   days: Date[],
+  timezone: string = event.startTimeZone ??
+    event.endTimeZone ??
+    getBrowserTimezone(),
 ): number {
-  return days.findIndex((day) => getOutOfOfficeSegment(event, day) !== null);
+  return days.findIndex(
+    (day) => getOutOfOfficeSegment(event, day, timezone) !== null,
+  );
 }

package/corpus/templates/calendar/app/lib/working-location.ts

@@ -1,5 +1,7 @@
 import type { CalendarEvent, UpdateEventScope } from "@shared/api";
 
+import { eventOverlapsCalendarDay } from "@/lib/calendar-timezone";
+
 export type WorkingLocationKind =
   | "homeOffice"
   | "officeLocation"
@@ -64,14 +66,12 @@ export function getWorkingLocationLabel(
       properties.officeLocation?.label ||
       properties.officeLocation?.buildingId ||
       event.location ||
-      event.title ||
       labels.office
     );
   }
   return (
     properties?.customLocation?.label ||
     event.location ||
-    event.title ||
     labels.workingLocation
   );
 }
@@ -147,6 +147,38 @@ export function getWorkingLocationTitle(
     : event.title;
 }
 
+export function isWorkingLocationDraftReadyToCreate(
+  event: Pick<
+    CalendarEvent,
+    "eventType" | "location" | "workingLocationProperties"
+  >,
+): boolean {
+  if (!isWorkingLocationEvent(event)) return true;
+  if (getWorkingLocationType(event) !== "customLocation") return true;
+  return getWorkingLocationEditableLabel(event).trim().length > 0;
+}
+
+export function findOwnedWorkingLocationForDay(
+  events: readonly CalendarEvent[],
+  day: Date,
+  timezone: string,
+  accountEmail?: string,
+): CalendarEvent | undefined {
+  const matches = events.filter((event) => {
+    if (!isWorkingLocationEvent(event)) return false;
+    if (event.overlayEmail) return false;
+    if (
+      accountEmail &&
+      event.accountEmail &&
+      event.accountEmail !== accountEmail
+    ) {
+      return false;
+    }
+    return eventOverlapsCalendarDay(event, day, timezone);
+  });
+  return matches.find((event) => event.source === "google") ?? matches[0];
+}
+
 export function getWorkingLocationDetail(
   event: Pick<CalendarEvent, "workingLocationProperties">,
   labels: WorkingLocationDisplayLabels,