@tuturuuu/utils 0.34.0 → 0.35.0

package/src/calendar-recurrence-pattern.ts

@@ -0,0 +1,54 @@
+import type { Temporal } from '@js-temporal/polyfill';
+import type { CalendarRecurrenceRule } from '@tuturuuu/types/primitives/calendar-recurrence';
+export const CALENDAR_WEEKDAYS = [
+  'MO',
+  'TU',
+  'WE',
+  'TH',
+  'FR',
+  'SA',
+  'SU',
+] as const;
+export function matchesCalendarRecurrenceDate(
+  date: Temporal.PlainDate,
+  first: Temporal.PlainDate,
+  rule: CalendarRecurrenceRule
+) {
+  const days = first.until(date, { largestUnit: 'days' }).days;
+  if (rule.frequency === 'daily') return days % rule.interval === 0;
+  const day = CALENDAR_WEEKDAYS[date.dayOfWeek - 1]!;
+  if (rule.frequency === 'weekly') {
+    const weekStart = CALENDAR_WEEKDAYS.indexOf(rule.weekStartsOn ?? 'MO') + 1;
+    const leading = (first.dayOfWeek - weekStart + 7) % 7;
+    return (
+      Math.floor((days + leading) / 7) % rule.interval === 0 &&
+      rule.weekdays!.includes(day)
+    );
+  }
+  const months = (date.year - first.year) * 12 + date.month - first.month;
+  if (
+    rule.frequency === 'monthly'
+      ? months % rule.interval !== 0
+      : (date.year - first.year) % rule.interval !== 0 ||
+        date.month !== rule.month
+  )
+    return false;
+  if (rule.monthDay !== undefined)
+    return (
+      date.day ===
+      (rule.monthDayOverflow === 'last-day'
+        ? Math.min(rule.monthDay, date.daysInMonth)
+        : rule.monthDay)
+    );
+  // Graph relative patterns select the earliest matching ordinal weekday.
+  const candidates = rule.weekdays!.map((weekday) => {
+    const index = CALENDAR_WEEKDAYS.indexOf(weekday) + 1;
+    if (rule.weekIndex === -1) {
+      const last = date.with({ day: date.daysInMonth });
+      return last.day - ((last.dayOfWeek - index + 7) % 7);
+    }
+    const start = date.with({ day: 1 });
+    return 1 + ((index - start.dayOfWeek + 7) % 7) + (rule.weekIndex! - 1) * 7;
+  });
+  return date.day === Math.min(...candidates);
+}

package/src/calendar-recurrence-providers.ts

@@ -0,0 +1,361 @@
+import { Temporal } from '@js-temporal/polyfill';
+import type {
+  CalendarRecurrenceAnchor,
+  CalendarRecurrenceRule,
+  CalendarWeekday,
+} from '@tuturuuu/types/primitives/calendar-recurrence';
+import { CALENDAR_WEEKDAYS } from './calendar-recurrence-pattern';
+import {
+  CalendarRecurrenceRuleSchema,
+  validateCalendarRecurrence,
+} from './calendar-recurrence-validation';
+
+const graphDays = [
+  'monday',
+  'tuesday',
+  'wednesday',
+  'thursday',
+  'friday',
+  'saturday',
+  'sunday',
+] as const;
+const indexes = ['first', 'second', 'third', 'fourth', 'last'] as const;
+export class UnsupportedCalendarRecurrenceError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'UnsupportedCalendarRecurrenceError';
+  }
+}
+export interface GraphCalendarRecurrence {
+  pattern: {
+    type: string;
+    interval: number;
+    dayOfMonth?: number;
+    daysOfWeek?: string[];
+    firstDayOfWeek?: string;
+    index?: string;
+    month?: number;
+  };
+  range: {
+    type: string;
+    startDate: string;
+    recurrenceTimeZone?: string;
+    endDate?: string;
+    numberOfOccurrences?: number;
+  };
+}
+function graphDay(day: CalendarWeekday) {
+  return graphDays[CALENDAR_WEEKDAYS.indexOf(day)]!;
+}
+function canonicalDay(day: string): CalendarWeekday {
+  const index = graphDays.indexOf(day as (typeof graphDays)[number]);
+  if (index < 0)
+    throw new UnsupportedCalendarRecurrenceError('Unknown provider weekday');
+  return CALENDAR_WEEKDAYS[index]!;
+}
+
+export function toGraphCalendarRecurrence(
+  rule: CalendarRecurrenceRule,
+  anchor: CalendarRecurrenceAnchor
+): GraphCalendarRecurrence {
+  validateCalendarRecurrence(rule, anchor);
+  if (
+    rule.monthDay &&
+    rule.monthDay > 28 &&
+    rule.monthDayOverflow !== 'last-day'
+  )
+    throw new UnsupportedCalendarRecurrenceError(
+      'Outlook clamps missing month days; choose last-day overflow explicitly'
+    );
+  const relative = rule.weekIndex !== undefined;
+  const pattern: GraphCalendarRecurrence['pattern'] = {
+    type:
+      rule.frequency === 'monthly'
+        ? relative
+          ? 'relativeMonthly'
+          : 'absoluteMonthly'
+        : rule.frequency === 'yearly'
+          ? relative
+            ? 'relativeYearly'
+            : 'absoluteYearly'
+          : rule.frequency,
+    interval: rule.interval,
+    ...(rule.monthDay === undefined ? {} : { dayOfMonth: rule.monthDay }),
+    ...(rule.month === undefined ? {} : { month: rule.month }),
+    ...(rule.weekdays ? { daysOfWeek: rule.weekdays.map(graphDay) } : {}),
+    ...(rule.frequency === 'weekly'
+      ? { firstDayOfWeek: graphDay(rule.weekStartsOn ?? 'MO') }
+      : {}),
+    ...(relative
+      ? { index: indexes[rule.weekIndex === -1 ? 4 : rule.weekIndex! - 1] }
+      : {}),
+  };
+  return {
+    pattern,
+    range: {
+      type:
+        rule.end.type === 'count'
+          ? 'numbered'
+          : rule.end.type === 'until'
+            ? 'endDate'
+            : 'noEnd',
+      startDate: anchor.startLocal.slice(0, 10),
+      recurrenceTimeZone: rule.timeZone,
+      ...(rule.end.type === 'count'
+        ? { numberOfOccurrences: rule.end.count }
+        : {}),
+      ...(rule.end.type === 'until' ? { endDate: rule.end.date } : {}),
+    },
+  };
+}
+
+export function fromGraphCalendarRecurrence(
+  value: GraphCalendarRecurrence,
+  timeZone: string
+): CalendarRecurrenceRule {
+  const { pattern, range } = value;
+  const frequencies: Record<string, CalendarRecurrenceRule['frequency']> = {
+    daily: 'daily',
+    weekly: 'weekly',
+    absoluteMonthly: 'monthly',
+    relativeMonthly: 'monthly',
+    absoluteYearly: 'yearly',
+    relativeYearly: 'yearly',
+  };
+  const frequency = frequencies[pattern.type];
+  if (!frequency)
+    throw new UnsupportedCalendarRecurrenceError(
+      'Unknown provider recurrence pattern'
+    );
+  const relative = pattern.type.startsWith('relative');
+  const index = indexes.indexOf(
+    (pattern.index ?? 'first') as (typeof indexes)[number]
+  );
+  if (relative && index < 0)
+    throw new UnsupportedCalendarRecurrenceError(
+      'Unknown provider recurrence index'
+    );
+  if (!['numbered', 'endDate', 'noEnd'].includes(range.type))
+    throw new UnsupportedCalendarRecurrenceError(
+      'Unknown provider recurrence range'
+    );
+  return CalendarRecurrenceRuleSchema.parse({
+    version: 1,
+    frequency,
+    interval: pattern.interval,
+    timeZone: range.recurrenceTimeZone || timeZone,
+    ...(frequency === 'weekly' || relative
+      ? { weekdays: pattern.daysOfWeek?.map(canonicalDay) }
+      : {}),
+    ...(frequency === 'weekly'
+      ? { weekStartsOn: canonicalDay(pattern.firstDayOfWeek ?? 'sunday') }
+      : {}),
+    ...(relative ? { weekIndex: index === 4 ? -1 : index + 1 } : {}),
+    ...(!relative && (frequency === 'monthly' || frequency === 'yearly')
+      ? {
+          monthDay: pattern.dayOfMonth,
+          ...(pattern.dayOfMonth && pattern.dayOfMonth > 28
+            ? { monthDayOverflow: 'last-day' }
+            : {}),
+        }
+      : {}),
+    ...(frequency === 'yearly' ? { month: pattern.month } : {}),
+    end:
+      range.type === 'numbered'
+        ? { type: 'count', count: range.numberOfOccurrences }
+        : range.type === 'endDate'
+          ? { type: 'until', date: range.endDate }
+          : { type: 'never' },
+  });
+}
+
+export function toGoogleCalendarRecurrence(
+  rule: CalendarRecurrenceRule,
+  anchor: CalendarRecurrenceAnchor
+): string[] {
+  validateCalendarRecurrence(rule, anchor);
+  const parts = [
+    `FREQ=${rule.frequency.toUpperCase()}`,
+    `INTERVAL=${rule.interval}`,
+  ];
+  if (rule.frequency === 'weekly')
+    parts.push(`WKST=${rule.weekStartsOn ?? 'MO'}`);
+  if (rule.weekdays) {
+    parts.push(
+      `BYDAY=${rule.weekdays.map((day) => `${rule.weekIndex ?? ''}${day}`).join(',')}`
+    );
+    if (rule.weekIndex !== undefined && rule.weekdays.length > 1)
+      parts.push('BYSETPOS=1');
+  }
+  if (rule.monthDay !== undefined) {
+    if (rule.monthDayOverflow === 'last-day' && rule.monthDay > 28) {
+      parts.push(
+        `BYMONTHDAY=${Array.from({ length: rule.monthDay - 27 }, (_, index) => index + 28).join(',')}`,
+        'BYSETPOS=-1'
+      );
+    } else parts.push(`BYMONTHDAY=${rule.monthDay}`);
+  }
+  if (rule.month !== undefined) parts.push(`BYMONTH=${rule.month}`);
+  if (rule.end.type === 'count') parts.push(`COUNT=${rule.end.count}`);
+  if (rule.end.type === 'until') {
+    const until = anchor.allDay
+      ? rule.end.date.replaceAll('-', '')
+      : Temporal.PlainDate.from(rule.end.date)
+          .toPlainDateTime('23:59:59')
+          .toZonedDateTime(rule.timeZone)
+          .toInstant()
+          .toString()
+          .replaceAll('-', '')
+          .replaceAll(':', '');
+    parts.push(`UNTIL=${until}`);
+  }
+  return [`RRULE:${parts.join(';')}`];
+}
+
+/** Richer Google RRULE/RDATE/EXDATE data must be retained read-only, never dropped. */
+export function fromGoogleCalendarRecurrence(
+  value: string[],
+  anchor: CalendarRecurrenceAnchor,
+  timeZone: string
+): CalendarRecurrenceRule {
+  if (value.length !== 1 || !value[0]?.startsWith('RRULE:'))
+    throw new UnsupportedCalendarRecurrenceError(
+      'Only one common RRULE is editable; retain original provider recurrence'
+    );
+  const entries = value[0]
+    .slice(6)
+    .split(';')
+    .map((part) => part.split('='));
+  if (
+    entries.some((parts) => parts.length !== 2) ||
+    new Set(entries.map(([key]) => key)).size !== entries.length
+  )
+    throw new UnsupportedCalendarRecurrenceError(
+      'Malformed or duplicate RRULE fields'
+    );
+  const fields = Object.fromEntries(entries) as Record<string, string>;
+  if (
+    Object.keys(fields).some(
+      (key) =>
+        ![
+          'FREQ',
+          'INTERVAL',
+          'WKST',
+          'BYDAY',
+          'BYSETPOS',
+          'BYMONTHDAY',
+          'BYMONTH',
+          'COUNT',
+          'UNTIL',
+        ].includes(key)
+    )
+  )
+    throw new UnsupportedCalendarRecurrenceError('Unsupported RRULE selectors');
+  if (fields.COUNT && fields.UNTIL)
+    throw new UnsupportedCalendarRecurrenceError(
+      'COUNT and UNTIL are mutually exclusive'
+    );
+  const frequency = fields.FREQ?.toLowerCase();
+  const byday = fields.BYDAY?.split(',').map((value) => {
+    const match = /^(-1|[1-4])?(MO|TU|WE|TH|FR|SA|SU)$/.exec(value);
+    if (!match)
+      throw new UnsupportedCalendarRecurrenceError('Unsupported BYDAY');
+    return {
+      day: match[2] as CalendarWeekday,
+      index: match[1] ? Number(match[1]) : undefined,
+    };
+  });
+  const index = byday?.[0]?.index;
+  if (index !== undefined && frequency !== 'monthly' && frequency !== 'yearly')
+    throw new UnsupportedCalendarRecurrenceError(
+      'Ordinal weekdays require monthly or yearly recurrence'
+    );
+  const monthDays = fields.BYMONTHDAY?.split(',').map(Number);
+  const clampsMonthDay =
+    !byday &&
+    fields.BYSETPOS === '-1' &&
+    Boolean(
+      monthDays &&
+        monthDays.length > 1 &&
+        monthDays.every((day, i) => day === 28 + i) &&
+        monthDays.at(-1)! <= 31
+    );
+  if (
+    byday?.some((day) => day.index !== index) ||
+    (fields.BYSETPOS &&
+      !clampsMonthDay &&
+      (fields.BYSETPOS !== '1' || index === undefined)) ||
+    (index !== undefined && byday!.length > 1 && fields.BYSETPOS !== '1')
+  )
+    throw new UnsupportedCalendarRecurrenceError(
+      'Relative RRULE is not representable by Graph'
+    );
+  const number = (value: string | undefined, fallback?: number) => {
+    if (value === undefined) return fallback;
+    if (!/^\d+$/.test(value))
+      throw new UnsupportedCalendarRecurrenceError(
+        'Invalid numeric RRULE field'
+      );
+    return Number(value);
+  };
+  let end: CalendarRecurrenceRule['end'] = { type: 'never' };
+  if (fields.COUNT) end = { type: 'count', count: number(fields.COUNT)! };
+  if (fields.UNTIL) {
+    let date: Temporal.PlainDate;
+    if (anchor.allDay && /^\d{8}$/.test(fields.UNTIL))
+      date = Temporal.PlainDate.from(
+        `${fields.UNTIL.slice(0, 4)}-${fields.UNTIL.slice(4, 6)}-${fields.UNTIL.slice(6)}`
+      );
+    else if (!anchor.allDay && /^\d{8}T\d{6}Z$/.test(fields.UNTIL)) {
+      const raw = fields.UNTIL;
+      const cutoff = Temporal.Instant.from(
+        `${raw.slice(0, 4)}-${raw.slice(4, 6)}-${raw.slice(6, 8)}T${raw.slice(9, 11)}:${raw.slice(11, 13)}:${raw.slice(13, 15)}Z`
+      );
+      date = cutoff.toZonedDateTimeISO(timeZone).toPlainDate();
+      const slot = date
+        .toPlainDateTime(
+          Temporal.PlainDateTime.from(anchor.startLocal).toPlainTime()
+        )
+        .toZonedDateTime(timeZone)
+        .toInstant();
+      if (Temporal.Instant.compare(slot, cutoff) > 0)
+        date = date.subtract({ days: 1 });
+    } else
+      throw new UnsupportedCalendarRecurrenceError('Invalid UNTIL date type');
+    end = { type: 'until', date: date.toString() };
+  }
+  const anchorDate = Temporal.PlainDateTime.from(
+    anchor.startLocal
+  ).toPlainDate();
+  const rule = CalendarRecurrenceRuleSchema.parse({
+    version: 1,
+    frequency,
+    interval: number(fields.INTERVAL, 1),
+    timeZone,
+    ...(frequency === 'weekly'
+      ? {
+          weekdays: byday?.map((day) => day.day) ?? [
+            CALENDAR_WEEKDAYS[anchorDate.dayOfWeek - 1],
+          ],
+          weekStartsOn: fields.WKST ?? 'MO',
+        }
+      : byday
+        ? { weekdays: byday.map((day) => day.day), weekIndex: index }
+        : {}),
+    ...(fields.BYMONTHDAY
+      ? clampsMonthDay
+        ? { monthDay: monthDays!.at(-1), monthDayOverflow: 'last-day' }
+        : { monthDay: number(fields.BYMONTHDAY) }
+      : !byday && ['monthly', 'yearly'].includes(frequency ?? '')
+        ? { monthDay: anchorDate.day }
+        : {}),
+    ...(frequency === 'yearly'
+      ? { month: number(fields.BYMONTH, anchorDate.month) }
+      : fields.BYMONTH
+        ? { month: number(fields.BYMONTH) }
+        : {}),
+    end,
+  });
+  validateCalendarRecurrence(rule, anchor);
+  return rule;
+}

package/src/calendar-recurrence-validation.ts

@@ -0,0 +1,180 @@
+import { Temporal } from '@js-temporal/polyfill';
+import type {
+  CalendarRecurrenceAnchor,
+  CalendarRecurrenceRule,
+} from '@tuturuuu/types/primitives/calendar-recurrence';
+import { z } from 'zod';
+
+import {
+  CALENDAR_WEEKDAYS,
+  matchesCalendarRecurrenceDate,
+} from './calendar-recurrence-pattern';
+
+const weekday = z.enum(CALENDAR_WEEKDAYS);
+export const CalendarLocalDateSchema = z
+  .string()
+  .regex(/^\d{4}-\d{2}-\d{2}$/)
+  .refine((value) => {
+    try {
+      Temporal.PlainDate.from(value, { overflow: 'reject' });
+      return true;
+    } catch {
+      return false;
+    }
+  }, 'Invalid calendar date');
+export const CalendarLocalDateTimeSchema = z
+  .string()
+  .regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}$/)
+  .refine((value) => {
+    try {
+      Temporal.PlainDateTime.from(value, { overflow: 'reject' });
+      return true;
+    } catch {
+      return false;
+    }
+  }, 'Invalid local date-time');
+
+export const CalendarRecurrenceRuleSchema = z
+  .object({
+    version: z.literal(1),
+    frequency: z.enum(['daily', 'weekly', 'monthly', 'yearly']),
+    interval: z.number().int().min(1).max(1000),
+    timeZone: z
+      .string()
+      .max(100)
+      .refine((value) => {
+        if (/^[+-]/.test(value)) return false;
+        try {
+          Temporal.Now.zonedDateTimeISO(value);
+          return true;
+        } catch {
+          return false;
+        }
+      }, 'Expected a named time zone'),
+    weekStartsOn: weekday.optional(),
+    weekdays: z
+      .array(weekday)
+      .min(1)
+      .max(7)
+      .refine((days) => new Set(days).size === days.length)
+      .optional(),
+    monthDay: z.number().int().min(1).max(31).optional(),
+    monthDayOverflow: z.enum(['skip', 'last-day']).optional(),
+    weekIndex: z
+      .union([
+        z.literal(1),
+        z.literal(2),
+        z.literal(3),
+        z.literal(4),
+        z.literal(-1),
+      ])
+      .optional(),
+    month: z.number().int().min(1).max(12).optional(),
+    end: z.discriminatedUnion('type', [
+      z.object({ type: z.literal('never') }).strict(),
+      z
+        .object({
+          type: z.literal('count'),
+          count: z.number().int().min(1).max(10000),
+        })
+        .strict(),
+      z
+        .object({ type: z.literal('until'), date: CalendarLocalDateSchema })
+        .strict(),
+    ]),
+  })
+  .strict()
+  .superRefine((rule, ctx) => {
+    const invalid = (message: string) =>
+      ctx.addIssue({ code: 'custom', message });
+    if (rule.monthDayOverflow && rule.monthDay === undefined)
+      invalid('Month-day overflow requires an absolute month day');
+    if (
+      rule.frequency === 'daily' &&
+      (rule.weekdays || rule.monthDay || rule.weekIndex || rule.month)
+    )
+      invalid('Daily recurrence does not accept selectors');
+    if (
+      rule.frequency === 'weekly' &&
+      (!rule.weekdays || rule.monthDay || rule.weekIndex || rule.month)
+    )
+      invalid('Weekly recurrence requires only weekday selectors');
+    if (rule.frequency === 'monthly' || rule.frequency === 'yearly') {
+      if (
+        rule.monthDay !== undefined
+          ? Boolean(rule.weekdays || rule.weekIndex)
+          : !(rule.weekdays && rule.weekIndex)
+      )
+        invalid('Choose a month day or relative weekdays and index');
+      if (rule.frequency === 'yearly' ? !rule.month : rule.month !== undefined)
+        invalid('Month is required only for yearly recurrence');
+    }
+  });
+export const CalendarRecurrenceAnchorSchema = z
+  .object({
+    startLocal: CalendarLocalDateTimeSchema,
+    endLocal: CalendarLocalDateTimeSchema,
+    allDay: z.boolean(),
+  })
+  .strict()
+  .superRefine((anchor, ctx) => {
+    if (Temporal.PlainDateTime.compare(anchor.startLocal, anchor.endLocal) >= 0)
+      ctx.addIssue({ code: 'custom', message: 'End must follow start' });
+    if (
+      anchor.allDay &&
+      ![anchor.startLocal, anchor.endLocal].every((value) =>
+        value.endsWith('T00:00:00')
+      )
+    )
+      ctx.addIssue({
+        code: 'custom',
+        message: 'All-day anchors require exclusive midnight date boundaries',
+      });
+  });
+
+export function validateCalendarRecurrence(
+  rule: CalendarRecurrenceRule,
+  anchor: CalendarRecurrenceAnchor
+) {
+  const validRule = CalendarRecurrenceRuleSchema.parse(rule);
+  const validAnchor = CalendarRecurrenceAnchorSchema.parse(anchor);
+  if (
+    validRule.end.type === 'until' &&
+    validRule.end.date < validAnchor.startLocal.slice(0, 10)
+  )
+    throw new RangeError('Recurrence ends before its anchor');
+  const first = Temporal.PlainDateTime.from(
+    validAnchor.startLocal
+  ).toPlainDate();
+  if (!matchesCalendarRecurrenceDate(first, first, validRule))
+    throw new RangeError('Series anchor must match its recurrence pattern');
+  return { rule: validRule, anchor: validAnchor };
+}
+
+export const CalendarRecurrenceExceptionSchema = z
+  .object({
+    originalStartLocal: CalendarLocalDateTimeSchema,
+    cancelled: z.boolean().optional(),
+    startLocal: CalendarLocalDateTimeSchema.optional(),
+    endLocal: CalendarLocalDateTimeSchema.optional(),
+  })
+  .strict()
+  .superRefine((exception, ctx) => {
+    if (Boolean(exception.startLocal) !== Boolean(exception.endLocal))
+      ctx.addIssue({
+        code: 'custom',
+        message: 'Moved occurrences require start and end',
+      });
+    if (
+      exception.startLocal &&
+      exception.endLocal &&
+      Temporal.PlainDateTime.compare(
+        exception.startLocal,
+        exception.endLocal
+      ) >= 0
+    )
+      ctx.addIssue({
+        code: 'custom',
+        message: 'Moved occurrence end must follow start',
+      });
+  });

package/src/calendar-recurrence.ts

@@ -0,0 +1,5 @@
+export * from './calendar-recurrence-edit';
+export * from './calendar-recurrence-expansion';
+export { CALENDAR_WEEKDAYS } from './calendar-recurrence-pattern';
+export * from './calendar-recurrence-providers';
+export * from './calendar-recurrence-validation';

package/src/calendar-utils.ts

@@ -7,10 +7,17 @@ dayjs.extend(timezone);
 dayjs.extend(utc);
 
 export function isAllDayEvent(
-  event: Pick<CalendarEvent, 'start_at' | 'end_at'>
+  event: Pick<CalendarEvent, 'start_at' | 'end_at'>,
+  displayTimezone?: string
 ): boolean {
-  const start = dayjs(event.start_at);
-  const end = dayjs(event.end_at);
+  const start =
+    displayTimezone && displayTimezone !== 'auto'
+      ? dayjs(event.start_at).tz(displayTimezone)
+      : dayjs(event.start_at);
+  const end =
+    displayTimezone && displayTimezone !== 'auto'
+      ? dayjs(event.end_at).tz(displayTimezone)
+      : dayjs(event.end_at);
 
   const durationMs = end.diff(start, 'millisecond');
   const isMultipleOf24Hours = durationMs % (24 * 60 * 60 * 1000) === 0;
@@ -27,6 +34,37 @@ export function isAllDayEvent(
   );
 }
 
+/** Civil date carriers for all-day rendering, with an exclusive end date.
+ * Untagged UTC-midnight legacy imports preserve their stored YMD, matching mobile.
+ * Other rows project actual instants into the configured display timezone.
+ */
+export function allDayEventCivilDates(
+  event: Pick<CalendarEvent, 'start_at' | 'end_at'>,
+  displayTimezone?: string
+) {
+  const rawStart = dayjs(event.start_at);
+  const rawEnd = dayjs(event.end_at);
+  if (!rawStart.isValid() || !rawEnd.isValid() || !rawEnd.isAfter(rawStart))
+    return null;
+  const utcStart = rawStart.utc();
+  const utcEnd = rawEnd.utc();
+  const midnight = (date: dayjs.Dayjs) =>
+    date.hour() === 0 &&
+    date.minute() === 0 &&
+    date.second() === 0 &&
+    date.millisecond() === 0;
+  const legacyDateOnly = midnight(utcStart) && midnight(utcEnd);
+  const project = (date: dayjs.Dayjs) =>
+    legacyDateOnly
+      ? date.utc()
+      : displayTimezone && displayTimezone !== 'auto'
+        ? date.tz(displayTimezone)
+        : date;
+  const civil = (date: dayjs.Dayjs) =>
+    new Date(date.year(), date.month(), date.date());
+  return { start: civil(project(rawStart)), end: civil(project(rawEnd)) };
+}
+
 // Helper function to convert Google Calendar all-day events to proper timezone
 export function convertGoogleAllDayEvent(
   startDate: string | undefined,

package/src/common/metadata.test.ts

@@ -270,10 +270,6 @@ describe('application metadata coverage', () => {
   });
 
   it('covers the non-Next public application shells', () => {
-    const tanStackHead = readFileSync(
-      resolve(repoRoot, 'apps/tanstack-web/src/lib/platform/app-shell.ts'),
-      'utf8'
-    );
     const mobileHead = readFileSync(
       resolve(repoRoot, 'apps/mobile/web/index.html'),
       'utf8'
@@ -282,8 +278,6 @@ describe('application metadata coverage', () => {
       readFileSync(resolve(repoRoot, 'apps/docs/docs.json'), 'utf8')
     ) as { description?: string };
 
-    expect(tanStackHead).toContain('max-image-preview:large');
-    expect(tanStackHead).toContain("name: 'twitter:site'");
     expect(mobileHead).toContain('name="robots" content="noindex, nofollow"');
     expect(mobileHead).toContain('property="og:image"');
     expect(docsConfig.description).toMatch(/Tuturuuu platform/);