Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

feat(calendar): add queries and display events (#5413)

dev-rb9a3ef7ff2c8f
diff --git a/apps/web/src/features/calendar/CalendarDataStatus.tsx b/apps/web/src/features/calendar/CalendarDataStatus.tsx
new file mode 100644
index 0000000000..0c5a1d196d
--- /dev/null
+++ b/apps/web/src/features/calendar/CalendarDataStatus.tsx
@@ -0,0 +1,158 @@
+import { useAddInboxFlow } from '@core/email-link';
+import SpinnerIcon from '@phosphor/spinner-gap.svg';
+import { useEmailLinksQuery } from '@queries/email/link';
+import { Button } from '@ui';
+import { createMemo, Show } from 'solid-js';
+import { useCalendarView } from './CalendarViewContext';
+import { isCalendarRangeSupported } from './calendar-supported-range';
+
+const SETUP_MESSAGES = {
+ connect: {
+ title: 'Connect your calendar',
+ description: 'Connect a Google account to show your calendar events.',
+ action: 'Connect calendar',
+ },
+ permission: {
+ title: 'Enable calendar',
+ description: 'Grant calendar access to show your events in Macro.',
+ action: 'Grant access',
+ },
+ reauth: {
+ title: 'Reconnect calendar',
+ description: 'Reconnect your Google account to resume calendar sync.',
+ action: 'Reconnect',
+ },
+} as const;
+
+/** Displays setup, loading, sync, and retry states over the calendar host. */
+export function CalendarDataStatus() {
+ const calendarView = useCalendarView();
+ const linksQuery = useEmailLinksQuery();
+ const startAddInbox = useAddInboxFlow();
+ const isRangeUnavailable = createMemo(() => {
+ const range = calendarView.visibleRange();
+ return range !== undefined && !isCalendarRangeSupported(range);
+ });
+
+ const setupState = createMemo<
+ 'connect' | 'permission' | 'reauth' | undefined
+ >(() => {
+ if (
+ isRangeUnavailable() ||
+ !linksQuery.isSuccess ||
+ !calendarView.occurrencesQuery.isSuccess ||
+ calendarView.events().length > 0
+ ) {
+ return undefined;
+ }
+
+ const links = linksQuery.data?.links ?? [];
+ if (links.length === 0) return 'connect';
+
+ const hasAvailableCalendar = links.some(
+ (link) =>
+ link.is_sync_active &&
+ !link.needs_calendar_permission &&
+ !link.needs_reauth
+ );
+ if (hasAvailableCalendar) return undefined;
+ if (links.some((link) => link.needs_reauth)) return 'reauth';
+ if (links.some((link) => link.needs_calendar_permission)) {
+ return 'permission';
+ }
+
+ return 'connect';
+ });
+
+ const setupMessage = createMemo(
+ () => SETUP_MESSAGES[setupState() ?? 'connect']
+ );
+
+ const showLoading = () =>
+ !isRangeUnavailable() &&
+ (calendarView.isLoading() ||
+ (calendarView.isSyncing() && calendarView.events().length === 0));
+ const showBlockingState = () =>
+ !isRangeUnavailable() &&
+ (calendarView.occurrencesQuery.isError ||
+ setupState() !== undefined ||
+ showLoading());
+
+ return (
+ <>
+ <Show when={showBlockingState()}>
+ <div
+ class="absolute inset-0 z-20 flex items-center justify-center rounded-xl bg-surface/90 p-6 text-center"
+ aria-live="polite"
+ >
+ <Show
+ when={!calendarView.occurrencesQuery.isError}
+ fallback={
+ <div class="flex max-w-sm flex-col items-center gap-3">
+ <div class="text-sm font-semibold text-ink">
+ Calendar unavailable
+ </div>
+ <p class="text-xs text-ink-muted">
+ We couldn’t load your calendar events. Try again.
+ </p>
+ <Button
+ variant="active"
+ size="sm"
+ label="Retry loading calendar"
+ onClick={() => void calendarView.occurrencesQuery.refetch()}
+ >
+ Retry
+ </Button>
+ </div>
+ }
+ >
+ <Show
+ when={setupState() === undefined}
+ fallback={
+ <div class="flex max-w-sm flex-col items-center gap-3">
+ <div class="text-sm font-semibold text-ink">
+ {setupMessage().title}
+ </div>
+ <p class="text-xs text-ink-muted">
+ {setupMessage().description}
+ </p>
+ <Button
+ variant="active"
+ size="sm"
+ label={setupMessage().action}
+ onClick={() => void startAddInbox()}
+ >
+ {setupMessage().action}
+ </Button>
+ </div>
+ }
+ >
+ <div class="flex items-center gap-2 text-xs text-ink-muted">
+ <SpinnerIcon class="size-4 animate-spin" />
+ <span>
+ {calendarView.isSyncing()
+ ? 'Syncing calendar…'
+ : 'Loading calendar…'}
+ </span>
+ </div>
+ </Show>
+ </Show>
+ </div>
+ </Show>
+
+ <Show
+ when={
+ !isRangeUnavailable() &&
+ !showBlockingState() &&
+ calendarView.isSyncing() &&
+ calendarView.events().length > 0
+ }
+ >
+ <div class="absolute right-2 bottom-2 z-10 flex items-center gap-1.5 rounded-full border border-edge-muted bg-surface px-2.5 py-1 text-xs text-ink-muted shadow-menu">
+ <SpinnerIcon class="size-3 animate-spin" />
+ Syncing
+ </div>
+ </Show>
+ </>
+ );
+}
diff --git a/apps/web/src/features/calendar/CalendarPeriodSelector.tsx b/apps/web/src/features/calendar/CalendarPeriodSelector.tsx
index d422fb3b95..1e684b999d 100644
--- a/apps/web/src/features/calendar/CalendarPeriodSelector.tsx
+++ b/apps/web/src/features/calendar/CalendarPeriodSelector.tsx
@@ -33,7 +33,7 @@ export function CalendarPeriodSelector() {
);
const activeView = createMemo(
- () => calendar.dateInfo()?.view.type ?? 'dayGridMonth'
+ () => calendar.dateInfo()?.view.type ?? 'timeGridWeek'
);
const highlightedRange = createMemo(() => {
@@ -83,7 +83,7 @@ export function CalendarPeriodSelector() {
class="h-7 shrink-0 gap-1 rounded-lg border-edge-muted bg-panel px-2 text-xs font-medium text-ink"
>
{CALENDAR_VIEWS.find((view) => view.value === activeView())?.label ??
- 'Month'}
+ 'Week'}
<CaretDownIcon class="size-3 text-ink-muted" />
</Dropdown.Trigger>
<Dropdown.Content class="min-w-36">
diff --git a/apps/web/src/features/calendar/CalendarRangeUnavailableBanner.tsx b/apps/web/src/features/calendar/CalendarRangeUnavailableBanner.tsx
new file mode 100644
index 0000000000..08a882db6a
--- /dev/null
+++ b/apps/web/src/features/calendar/CalendarRangeUnavailableBanner.tsx
@@ -0,0 +1,40 @@
+import InfoIcon from '@phosphor/info.svg';
+import { createMemo, Show } from 'solid-js';
+import { Transition } from 'solid-transition-group';
+import { useCalendarView } from './CalendarViewContext';
+import { isCalendarRangeSupported } from './calendar-supported-range';
+
+/** Announces when the visible viewport is outside backend occurrence coverage. */
+export function CalendarRangeUnavailableBanner() {
+ const calendarView = useCalendarView();
+ const isUnavailable = createMemo(() => {
+ const range = calendarView.visibleRange();
+ return range !== undefined && !isCalendarRangeSupported(range);
+ });
+
+ return (
+ <Transition
+ appear
+ enterActiveClass="transition-[grid-template-rows,opacity,transform] duration-200 ease-in-out motion-reduce:transition-none"
+ enterClass="grid-rows-[0fr] -translate-y-2 opacity-0"
+ enterToClass="grid-rows-[1fr] translate-y-0 opacity-100"
+ exitActiveClass="transition-[grid-template-rows,opacity,transform] duration-200 ease-in-out motion-reduce:transition-none"
+ exitClass="grid-rows-[1fr] translate-y-0 opacity-100"
+ exitToClass="grid-rows-[0fr] -translate-y-2 opacity-0"
+ >
+ <Show when={isUnavailable()}>
+ <div class="grid shrink-0">
+ <div class="min-h-0 overflow-hidden">
+ <div
+ role="status"
+ class="mx-2 mb-2 flex items-center gap-2 rounded-lg border border-accent/30 bg-accent-bg px-3 py-2 text-xs text-ink-muted"
+ >
+ <InfoIcon class="size-3.5 shrink-0 text-accent" />
+ <span>Calendar events aren’t available for this date range.</span>
+ </div>
+ </div>
+ </div>
+ </Show>
+ </Transition>
+ );
+}
diff --git a/apps/web/src/features/calendar/CalendarSettingsDropdown.tsx b/apps/web/src/features/calendar/CalendarSettingsDropdown.tsx
index efb836d835..41dac8e108 100644
--- a/apps/web/src/features/calendar/CalendarSettingsDropdown.tsx
+++ b/apps/web/src/features/calendar/CalendarSettingsDropdown.tsx
@@ -23,12 +23,14 @@ const TIME_FORMAT_OPTIONS: Array<{
{ value: '24-hour', label: '24-hour' },
];
-/** Calendar display settings with source visibility on narrow layouts. */
+/** Calendar display settings. */
export function CalendarSettingsDropdown() {
const calendarView = useCalendarView();
const sidePanel = useSidePanel();
- const showCalendarVisibility = () => sidePanel?.isNarrow() ?? false;
+ const showCalendarVisibility = () =>
+ (sidePanel?.isNarrow() ?? false) && calendarView.sources().length > 1;
+
const weekStartLabel = createMemo(
() =>
WEEK_START_OPTIONS.find(
diff --git a/apps/web/src/features/calendar/CalendarSidePanelSections.tsx b/apps/web/src/features/calendar/CalendarSidePanelSections.tsx
index 0b46d12793..7c9b9eba34 100644
--- a/apps/web/src/features/calendar/CalendarSidePanelSections.tsx
+++ b/apps/web/src/features/calendar/CalendarSidePanelSections.tsx
@@ -120,18 +120,20 @@ function CalendarSourcesSidePanelSection() {
const calendarView = useCalendarView();
return (
- <SidePanel.Section
- id="calendar-controls"
- title="Calendars"
- order={20}
- defaultOpen
- >
- <CalendarControls
- sources={calendarView.sources()}
- isVisible={calendarView.isSourceVisible}
- onVisibilityChange={calendarView.setSourceVisibility}
- />
- </SidePanel.Section>
+ <Show when={calendarView.sources().length > 1}>
+ <SidePanel.Section
+ id="calendar-controls"
+ title="Calendars"
+ order={20}
+ defaultOpen
+ >
+ <CalendarControls
+ sources={calendarView.sources()}
+ isVisible={calendarView.isSourceVisible}
+ onVisibilityChange={calendarView.setSourceVisibility}
+ />
+ </SidePanel.Section>
+ </Show>
);
}
diff --git a/apps/web/src/features/calendar/CalendarViewContext.tsx b/apps/web/src/features/calendar/CalendarViewContext.tsx
index c1c7bd7a8e..7fcd1f704f 100644
--- a/apps/web/src/features/calendar/CalendarViewContext.tsx
+++ b/apps/web/src/features/calendar/CalendarViewContext.tsx
@@ -1,15 +1,20 @@
import { createAssertedContextProvider } from '@core/context/createContext';
-import type { EventDropArg } from '@fullcalendar/core';
-import type { EventResizeDoneArg } from '@fullcalendar/interaction';
-import { createMemo, createSignal } from 'solid-js';
+import { useUserId } from '@core/context/user';
+import {
+ type CalendarOccurrenceQueryRange,
+ createCalendarOccurrenceQueryRange,
+ useCalendarOccurrencesQuery,
+} from '@queries/calendar/occurrences';
+import { CalendarSyncStatus } from '@service-storage/generated/schemas/calendarSyncStatus';
+import { createEffect, createMemo, createSignal, on } from 'solid-js';
import { createStore } from 'solid-js/store';
+import { isCalendarRangeSupported } from './calendar-supported-range';
+import {
+ DEFAULT_CALENDAR_SOURCE,
+ mapCalendarOccurrence,
+} from './events/calendar-occurrence-mapper';
import { mapCalendarEventToFullCalendar } from './events/event-mapper';
-import type {
- CalendarEvent,
- CalendarSource,
- CalendarTimeFormat,
- CalendarWeekStart,
-} from './events/types';
+import type { CalendarTimeFormat, CalendarWeekStart } from './events/types';
import { getDefaultCalendarTimeFormat } from './time-format';
interface CalendarEventState {
@@ -23,14 +28,15 @@ interface CalendarDisplaySettings {
timeFormat: CalendarTimeFormat;
}
+const CALENDAR_SOURCES = [DEFAULT_CALENDAR_SOURCE];
+
export const [CalendarViewContextProvider, useCalendarView] =
createAssertedContextProvider('CalendarViewContext', () => {
- const [eventData, setEventData] = createSignal<
- CalendarEvent[] | undefined
- >();
-
+ const userId = useUserId();
+ const [visibleRange, setVisibleRange] =
+ createSignal<CalendarOccurrenceQueryRange>();
const [eventState, setEventState] = createStore<CalendarEventState>({
- visibleSourceIds: [],
+ visibleSourceIds: CALENDAR_SOURCES.map((source) => source.id),
selectedEventId: undefined,
});
@@ -41,12 +47,28 @@ export const [CalendarViewContextProvider, useCalendarView] =
timeFormat: getDefaultCalendarTimeFormat(),
});
- const [sources, setSources] = createSignal<CalendarSource[]>([]);
const [selectedEventAnchor, setSelectedEventAnchor] =
createSignal<HTMLElement>();
const [useNarrowDayHeaders, setUseNarrowDayHeaders] = createSignal(false);
- const events = createMemo(() => eventData() ?? []);
+ const isVisibleRangeSupported = createMemo(() => {
+ const range = visibleRange();
+ return range !== undefined && isCalendarRangeSupported(range);
+ });
+ const occurrencesQuery = useCalendarOccurrencesQuery(
+ () => ({ userId: userId(), range: visibleRange() }),
+ () => ({ enabled: isVisibleRangeSupported() })
+ );
+ const events = createMemo(() =>
+ isVisibleRangeSupported()
+ ? (occurrencesQuery.data?.items ?? []).map(mapCalendarOccurrence)
+ : []
+ );
+ const visibleEvents = createMemo(() =>
+ events().filter((event) =>
+ eventState.visibleSourceIds.includes(event.calendar.id)
+ )
+ );
const eventsById = createMemo(
() => new Map(events().map((event) => [event.id, event]))
);
@@ -54,63 +76,51 @@ export const [CalendarViewContextProvider, useCalendarView] =
const eventId = eventState.selectedEventId;
return eventId ? eventsById().get(eventId) : undefined;
});
- const visibleEvents = createMemo(() =>
- events().filter((event) =>
- eventState.visibleSourceIds.includes(event.calendar.id)
- )
- );
const fullCalendarEvents = createMemo(() =>
visibleEvents().map(mapCalendarEventToFullCalendar)
);
+ const isLoading = () =>
+ visibleRange() === undefined ||
+ (isVisibleRangeSupported() && occurrencesQuery.isPending);
+ const isSyncing = () =>
+ occurrencesQuery.data?.syncStatus === CalendarSyncStatus.syncing;
- const isSourceVisible = (sourceId: string) =>
- eventState.visibleSourceIds.includes(sourceId);
-
- const replaceEvents = (nextEvents: CalendarEvent[]) => {
- setEventData(nextEvents);
-
- const nextSources = new Map(
- sources().map((source) => [source.id, source])
- );
-
- for (const event of nextEvents) {
- nextSources.set(event.calendar.id, event.calendar);
- }
-
- replaceSources([...nextSources.values()]);
-
- if (
- eventState.selectedEventId &&
- !nextEvents.some((event) => event.id === eventState.selectedEventId)
- ) {
- setEventState('selectedEventId', undefined);
- setSelectedEventAnchor(undefined);
- }
+ const closeEventDetails = () => {
+ setEventState('selectedEventId', undefined);
+ setSelectedEventAnchor(undefined);
};
- const replaceSources = (nextSources: CalendarSource[]) => {
- const knownSourceIds = sources().map((source) => source.id);
-
- setSources(nextSources);
- setEventState('visibleSourceIds', (current) => {
- const next = [...current];
-
- for (const source of nextSources) {
+ createEffect(
+ on(
+ () =>
+ [eventState.selectedEventId, occurrencesQuery.dataUpdatedAt] as const,
+ ([selectedEventId]) => {
if (
- !knownSourceIds.includes(source.id) &&
- !next.includes(source.id)
+ selectedEventId &&
+ occurrencesQuery.isSuccess &&
+ !eventsById().has(selectedEventId)
) {
- next.push(source.id);
+ closeEventDetails();
}
}
+ )
+ );
- return next;
- });
- };
+ const updateVisibleRange = (start: Date, end: Date) => {
+ const nextRange = createCalendarOccurrenceQueryRange(start, end);
+ const currentRange = visibleRange();
- const closeEventDetails = () => {
- setEventState('selectedEventId', undefined);
- setSelectedEventAnchor(undefined);
+ if (
+ currentRange?.start === nextRange.start &&
+ currentRange.end === nextRange.end &&
+ currentRange.startDate === nextRange.startDate &&
+ currentRange.endDate === nextRange.endDate
+ ) {
+ return;
+ }
+
+ closeEventDetails();
+ setVisibleRange(nextRange);
};
const setSourceVisibility = (sourceId: string, visible: boolean) => {
@@ -127,50 +137,30 @@ export const [CalendarViewContextProvider, useCalendarView] =
}
};
- const updateEventDates = ({
- event,
- revert,
- }: EventDropArg | EventResizeDoneArg) => {
- if (!eventsById().has(event.id) || !event.startStr || !event.endStr) {
- revert();
- return;
- }
-
- closeEventDetails();
- setEventData((current) =>
- (current ?? []).map((calendarEvent) =>
- calendarEvent.id === event.id
- ? {
- ...calendarEvent,
- start: event.startStr,
- end: event.endStr,
- allDay: event.allDay,
- }
- : calendarEvent
- )
- );
- };
-
const selectEvent = (eventId: string, anchor: HTMLElement) => {
setEventState('selectedEventId', eventId);
setSelectedEventAnchor(anchor);
};
return {
- eventData,
eventState,
displaySettings,
+ visibleRange,
+ updateVisibleRange,
+ occurrencesQuery,
events,
- sources,
+ sources: () => CALENDAR_SOURCES,
+ isSourceVisible: (sourceId: string) =>
+ eventState.visibleSourceIds.includes(sourceId),
+ setSourceVisibility,
eventsById,
selectedEvent,
fullCalendarEvents,
- isSourceVisible,
+ isLoading,
+ isSyncing,
selectedEventAnchor,
useNarrowDayHeaders,
setUseNarrowDayHeaders,
- replaceEvents,
- replaceSources,
setShowWeekends: (showWeekends: boolean) =>
setDisplaySettings('showWeekends', showWeekends),
setWeekStartsOn: (weekStartsOn: CalendarWeekStart) =>
@@ -178,8 +168,6 @@ export const [CalendarViewContextProvider, useCalendarView] =
setTimeFormat: (timeFormat: CalendarTimeFormat) =>
setDisplaySettings('timeFormat', timeFormat),
closeEventDetails,
- setSourceVisibility,
- updateEventDates,
selectEvent,
};
});
diff --git a/apps/web/src/features/calendar/calendar-supported-range.ts b/apps/web/src/features/calendar/calendar-supported-range.ts
new file mode 100644
index 0000000000..b3a537d464
--- /dev/null
+++ b/apps/web/src/features/calendar/calendar-supported-range.ts
@@ -0,0 +1,39 @@
+import type { CalendarOccurrenceQueryRange } from '@queries/calendar/occurrences';
+
+const CALENDAR_HISTORY_DAYS = 364;
+const CALENDAR_FUTURE_DAYS = 729;
+
+interface CalendarSupportedRange {
+ start: Date;
+ end: Date;
+}
+
+/** Returns a safely inset version of the backend's rolling materialized range. */
+function getCalendarSupportedRange(now = new Date()): CalendarSupportedRange {
+ const start = new Date(now);
+ start.setDate(start.getDate() - CALENDAR_HISTORY_DAYS);
+ start.setHours(0, 0, 0, 0);
+
+ const end = new Date(now);
+ end.setDate(end.getDate() + CALENDAR_FUTURE_DAYS);
+ end.setHours(0, 0, 0, 0);
+
+ return { start, end };
+}
+
+/** Returns whether the complete viewport can be served by the backend. */
+export function isCalendarRangeSupported(
+ range: CalendarOccurrenceQueryRange,
+ now = new Date()
+) {
+ const supportedRange = getCalendarSupportedRange(now);
+ const start = new Date(range.start);
+ const end = new Date(range.end);
+
+ return (
+ !Number.isNaN(start.getTime()) &&
+ !Number.isNaN(end.getTime()) &&
+ start >= supportedRange.start &&
+ end <= supportedRange.end
+ );
+}
diff --git a/apps/web/src/features/calendar/calendar-view.tsx b/apps/web/src/features/calendar/calendar-view.tsx
index c478e7a5e1..0db4251973 100644
--- a/apps/web/src/features/calendar/calendar-view.tsx
+++ b/apps/web/src/features/calendar/calendar-view.tsx
@@ -22,7 +22,9 @@ import {
onMount,
Show,
} from 'solid-js';
+import { CalendarDataStatus } from './CalendarDataStatus';
import { CalendarPeriodSelector } from './CalendarPeriodSelector';
+import { CalendarRangeUnavailableBanner } from './CalendarRangeUnavailableBanner';
import { CalendarSettingsDropdown } from './CalendarSettingsDropdown';
import { CalendarSidePanelSections } from './CalendarSidePanelSections';
import {
@@ -36,6 +38,7 @@ import { FullCalendar, useFullCalendar } from './fullcalendar-solid';
import {
CALENDAR_TIME_FORMAT_OPTIONS,
formatCalendarTime,
+ formatCompactCalendarTime,
} from './time-format';
import { useCalendarTimeGridHoverIndicator } from './useCalendarTimeGridHoverIndicator';
import './calendar.css';
@@ -162,16 +165,22 @@ function ResponsiveCalendarHost() {
return (
<Layer depth={2}>
- <FullCalendar.Host
- tabIndex={-1}
- ref={(calendarElement) => {
- setElement(calendarElement);
- calendarView.setUseNarrowDayHeaders(
- calendarElement.clientWidth < 520
- );
- }}
- class="calendar-view-host min-w-0 min-h-0 flex-1 overflow-hidden rounded-xl"
- />
+ <div class="flex min-w-0 min-h-0 flex-1 flex-col">
+ <CalendarRangeUnavailableBanner />
+ <div class="relative flex min-w-0 min-h-0 flex-1">
+ <FullCalendar.Host
+ tabIndex={-1}
+ ref={(calendarElement) => {
+ setElement(calendarElement);
+ calendarView.setUseNarrowDayHeaders(
+ calendarElement.clientWidth < 520
+ );
+ }}
+ class="calendar-view-host min-w-0 min-h-0 flex-1 overflow-hidden rounded-xl"
+ />
+ <CalendarDataStatus />
+ </div>
+ </div>
</Layer>
);
}
@@ -187,20 +196,15 @@ export function CalendarView() {
function CalendarViewContent() {
const calendarView = useCalendarView();
- let visibleRangeKey: string | undefined;
-
- const handleDatesSet = ({ end, start, view }: DatesSetArg) => {
- const nextRangeKey = `${view.type}:${start.toISOString()}:${end.toISOString()}`;
- if (visibleRangeKey !== undefined && visibleRangeKey !== nextRangeKey) {
- calendarView.closeEventDetails();
- }
- visibleRangeKey = nextRangeKey;
+
+ const handleDatesSet = ({ end, start }: DatesSetArg) => {
+ calendarView.updateVisibleRange(start, end);
};
return (
<FullCalendar.Root
plugins={[dayGridPlugin, interactionPlugin, timeGridPlugin]}
- initialView="dayGridMonth"
+ initialView="timeGridWeek"
height="100%"
expandRows
fixedWeekCount={false}
@@ -218,14 +222,7 @@ function CalendarViewContent() {
eventTimeFormat={
CALENDAR_TIME_FORMAT_OPTIONS[calendarView.displaySettings.timeFormat]
}
- eventStartEditable
- eventDurationEditable
- eventResizableFromStart
events={calendarView.fullCalendarEvents()}
- eventDragStart={calendarView.closeEventDetails}
- eventDrop={calendarView.updateEventDates}
- eventResizeStart={calendarView.closeEventDetails}
- eventResize={calendarView.updateEventDates}
eventClick={({ el, event, jsEvent }) => {
jsEvent.preventDefault();
calendarView.selectEvent(event.id, el);
@@ -271,13 +268,30 @@ function CalendarViewContent() {
}}
</FullCalendar.DayHeaderContent>
+ <FullCalendar.SlotLabelContent>
+ {({ date, text }) =>
+ calendarView.useNarrowDayHeaders()
+ ? formatCompactCalendarTime(
+ date,
+ calendarView.displaySettings.timeFormat
+ )
+ : text
+ }
+ </FullCalendar.SlotLabelContent>
+
<FullCalendar.EventContent>
{(renderProps) => {
const event = calendarView.eventsById().get(renderProps.event.id);
if (!event) return null;
return (
- <CalendarEventContent event={event} renderProps={renderProps} />
+ <CalendarEventContent
+ event={event}
+ renderProps={renderProps}
+ isSelected={calendarView.eventState.selectedEventId === event.id}
+ timeFormat={calendarView.displaySettings.timeFormat}
+ isNarrow={calendarView.useNarrowDayHeaders()}
+ />
);
}}
</FullCalendar.EventContent>
diff --git a/apps/web/src/features/calendar/calendar.css b/apps/web/src/features/calendar/calendar.css
index 67ac43cc69..8ab6745d71 100644
--- a/apps/web/src/features/calendar/calendar.css
+++ b/apps/web/src/features/calendar/calendar.css
@@ -104,36 +104,56 @@
padding: 0.5rem 0.625rem;
}
-.calendar-view .fc .fc-dayGridMonth-view .fc-day-today .fc-daygrid-day-number {
+.calendar-view .fc .fc-dayGridMonth-view .fc-day-today .fc-daygrid-day-number,
+.calendar-view
+ .fc
+ .fc-dayGridMonth-view
+ .calendar-day-selected
+ .fc-daygrid-day-number {
+ position: relative;
+ z-index: 0;
display: inline-flex;
- width: 1.25rem;
- height: 1.25rem;
align-items: center;
justify-content: center;
- margin: 0.25rem;
- padding: 0;
- border: 1px solid var(--color-accent);
- border-radius: 0.375rem;
font-weight: 600;
}
+.calendar-view
+ .fc
+ .fc-dayGridMonth-view
+ .fc-day-today
+ .fc-daygrid-day-number::before,
.calendar-view
.fc
.fc-dayGridMonth-view
.calendar-day-selected
- .fc-daygrid-day-number {
- display: inline-flex;
+ .fc-daygrid-day-number::before {
+ position: absolute;
+ top: 50%;
+ left: 50%;
+ z-index: -1;
width: 1.25rem;
height: 1.25rem;
- align-items: center;
- justify-content: center;
- margin: 0.25rem;
- padding: 0;
border: 1px solid var(--color-accent);
border-radius: 0.375rem;
- background: var(--color-accent);
+ content: "";
+ transform: translate(-50%, -50%);
+}
+
+.calendar-view
+ .fc
+ .fc-dayGridMonth-view
+ .calendar-day-selected
+ .fc-daygrid-day-number {
color: var(--color-surface);
- font-weight: 600;
+}
+
+.calendar-view
+ .fc
+ .fc-dayGridMonth-view
+ .calendar-day-selected
+ .fc-daygrid-day-number::before {
+ background: var(--color-accent);
}
.calendar-view
@@ -174,12 +194,9 @@
color: var(--color-ink-disabled);
}
-.calendar-view .fc-direction-ltr .fc-daygrid-event {
- margin-right: 0.25rem;
-}
-
-.calendar-view .fc-direction-rtl .fc-daygrid-event {
- margin-left: 0.25rem;
+.calendar-view .fc .fc-daygrid-event {
+ margin-right: 0.375rem;
+ margin-left: 0.375rem;
}
.calendar-view .fc-direction-ltr .fc-h-event:not(.fc-event-end) {
@@ -194,12 +211,105 @@
border-bottom-left-radius: 0.375rem;
}
-.calendar-view .fc-direction-ltr .fc-timegrid-col-events {
- margin-right: 0.25rem;
+.calendar-view .fc .fc-timegrid-col-events {
+ margin-right: 0.375rem;
+ margin-left: 0.375rem;
+}
+
+.calendar-view .fc .fc-event {
+ transition: box-shadow 120ms ease-out;
+}
+
+.calendar-view .fc .fc-event .calendar-event-content {
+ container-type: inline-size;
+ border-radius: 0.25rem;
+ transition: background-color 120ms ease-out;
+}
+
+.calendar-view .fc .fc-timegrid-event .calendar-event-content {
+ container-type: size;
+}
+
+.calendar-view .fc .calendar-event-content-compact {
+ font-size: clamp(0.625rem, 7cqi, 0.6875rem);
+}
+
+.calendar-view .fc .calendar-event-title {
+ font-size: clamp(0.625rem, min(6cqi, 20cqh), 0.75rem);
+}
+
+.calendar-view
+ .fc
+ .calendar-event-content-compact
+ .calendar-event-title {
+ font-size: inherit;
+}
+
+.calendar-view .fc .calendar-event-metadata {
+ font-size: clamp(0.5625rem, min(5cqi, 18cqh), 0.6875rem);
}
-.calendar-view .fc-direction-rtl .fc-timegrid-col-events {
- margin-left: 0.25rem;
+.calendar-view .fc .calendar-event-time {
+ font-size: 0.6875rem;
+}
+
+.calendar-view .fc .calendar-event-content-layout {
+ padding: 1px 3px;
+}
+
+.calendar-view .fc .calendar-event-content-layout-single-line {
+ flex-direction: row;
+ align-items: center;
+ gap: 0.25rem;
+ padding: 1px 3px;
+}
+
+.calendar-view
+ .fc
+ .calendar-event-content-layout-single-line
+ .calendar-event-time {
+ margin-top: 0;
+}
+
+.calendar-view
+ .fc
+ .calendar-event-content-layout-single-line
+ .calendar-event-location {
+ display: none;
+}
+
+.calendar-view .fc .fc-event:hover {
+ z-index: 4;
+}
+
+.calendar-view .fc .fc-event:focus-visible {
+ z-index: 4;
+ box-shadow: 0 0 0 1px currentColor;
+}
+
+.calendar-view .fc .fc-event:hover .calendar-event-content,
+.calendar-view .fc .fc-event:focus-visible .calendar-event-content {
+ background-color: color-mix(
+ in oklch,
+ var(--color-accent) 10%,
+ transparent
+ );
+}
+
+.calendar-view .fc .fc-event:has(.calendar-event-content-selected) {
+ z-index: 3;
+ border-color: var(--color-accent) !important;
+ background-color: var(--color-accent) !important;
+ color: var(--color-surface) !important;
+ box-shadow: 0 0 0 1px var(--color-accent);
+}
+
+.calendar-view
+ .fc
+ .fc-event:has(.calendar-event-content-selected)
+ .calendar-event-content-selected {
+ background-color: var(--color-accent);
+ color: var(--color-surface);
}
.calendar-view .fc .fc-dayGridMonth-view .fc-daygrid-day-frame {
diff --git a/apps/web/src/features/calendar/events/EventContent.test.tsx b/apps/web/src/features/calendar/events/EventContent.test.tsx
new file mode 100644
index 0000000000..dda9bacec6
--- /dev/null
+++ b/apps/web/src/features/calendar/events/EventContent.test.tsx
@@ -0,0 +1,82 @@
+/**
+ * @vitest-environment jsdom
+ */
+
+import type { EventContentArg } from '@fullcalendar/core';
+import { render, screen } from '@solidjs/testing-library';
+import { describe, expect, it } from 'vitest';
+import {
+ formatCompactCalendarTime,
+ formatCompactCalendarTimeRange,
+} from '../time-format';
+import { CalendarEventContent } from './EventContent';
+import type { CalendarEvent } from './types';
+
+const start = new Date(2025, 0, 15, 9);
+
+function calendarEvent(durationMinutes: number): CalendarEvent {
+ return {
+ id: 'occurrence-1',
+ eventId: 'event-1',
+ occurrenceKey: 'occurrence-1',
+ isReadOnly: false,
+ attendees: [],
+ recurrenceLines: [],
+ title: 'Planning',
+ start: start.toISOString(),
+ end: new Date(start.getTime() + durationMinutes * 60 * 1000).toISOString(),
+ allDay: false,
+ calendar: {
+ id: 'calendar-1',
+ name: 'Work',
+ color: 'red',
+ },
+ };
+}
+
+function renderProps(timeText: string): EventContentArg {
+ return {
+ event: { start },
+ timeText,
+ view: { type: 'timeGridWeek' },
+ } as EventContentArg;
+}
+
+describe('CalendarEventContent', () => {
+ it('shows only the start time for a 15-minute event', () => {
+ render(() => (
+ <CalendarEventContent
+ event={calendarEvent(15)}
+ renderProps={renderProps('9:00 AM - 9:15 AM')}
+ isSelected={false}
+ timeFormat="12-hour"
+ />
+ ));
+
+ expect(
+ screen.getByText(formatCompactCalendarTime(start, '12-hour'))
+ ).toBeTruthy();
+ expect(screen.queryByText('9:00 AM - 9:15 AM')).toBeNull();
+ });
+
+ it('preserves the time range for longer events', () => {
+ render(() => (
+ <CalendarEventContent
+ event={calendarEvent(30)}
+ renderProps={renderProps('9:00 AM - 9:30 AM')}
+ isSelected={false}
+ timeFormat="12-hour"
+ />
+ ));
+
+ expect(
+ screen.getByText(
+ formatCompactCalendarTimeRange(
+ start,
+ new Date(start.getTime() + 30 * 60 * 1000),
+ '12-hour'
+ )
+ )
+ ).toBeTruthy();
+ });
+});
diff --git a/apps/web/src/features/calendar/events/EventContent.tsx b/apps/web/src/features/calendar/events/EventContent.tsx
index b730e877a0..0e8a45fae4 100644
--- a/apps/web/src/features/calendar/events/EventContent.tsx
+++ b/apps/web/src/features/calendar/events/EventContent.tsx
@@ -1,52 +1,93 @@
import type { EventContentArg } from '@fullcalendar/core';
import { Show } from 'solid-js';
-import type { CalendarEvent } from './types';
+import {
+ formatCompactCalendarTime,
+ formatCompactCalendarTimeRange,
+} from '../time-format';
+import type { CalendarEvent, CalendarTimeFormat } from './types';
interface CalendarEventContentProps {
event: CalendarEvent;
renderProps: EventContentArg;
+ isSelected: boolean;
+ timeFormat: CalendarTimeFormat;
+ isNarrow?: boolean;
}
+const SINGLE_LINE_EVENT_DURATION_MS = 15 * 60 * 1000;
+
/** Renders responsive event content for FullCalendar. */
export function CalendarEventContent(props: CalendarEventContentProps) {
const isCompact = () =>
props.event.allDay || props.renderProps.view.type === 'dayGridMonth';
const showLocation = () =>
!props.event.allDay && props.renderProps.view.type === 'timeGridDay';
+ const usesSingleLineLayout = () => {
+ const duration =
+ new Date(props.event.end).getTime() -
+ new Date(props.event.start).getTime();
+
+ return (
+ !props.event.allDay &&
+ duration > 0 &&
+ duration <= SINGLE_LINE_EVENT_DURATION_MS
+ );
+ };
+ const timeText = () => {
+ if (props.isNarrow || props.event.allDay) return undefined;
+
+ const start = new Date(props.event.start);
+ const end = new Date(props.event.end);
+ if (Number.isNaN(start.getTime()) || Number.isNaN(end.getTime())) {
+ return props.renderProps.timeText;
+ }
+
+ const formattedStart = formatCompactCalendarTime(start, props.timeFormat);
+ if (isCompact() || usesSingleLineLayout()) return formattedStart;
+
+ return formatCompactCalendarTimeRange(start, end, props.timeFormat);
+ };
return (
- <Show
- when={!isCompact()}
- fallback={
- <div class="flex min-w-0 items-center gap-1 overflow-hidden px-1 py-0.5 text-[0.6875rem] leading-tight">
- <Show when={props.renderProps.timeText}>
- {(timeText) => (
- <span class="shrink-0 font-semibold tabular-nums">
- {timeText()}
- </span>
- )}
- </Show>
- <span class="truncate font-medium">{props.event.title}</span>
- </div>
- }
+ <div
+ class="calendar-event-content w-full min-w-0 overflow-hidden"
+ classList={{
+ 'h-full': !isCompact(),
+ 'min-h-0': !isCompact(),
+ 'calendar-event-content-selected': props.isSelected,
+ }}
>
- <div class="flex size-full min-h-0 flex-col overflow-hidden p-1">
- <span class="truncate text-xs font-semibold leading-tight">
+ <div
+ class="calendar-event-content-layout flex w-full min-h-0 flex-col overflow-hidden"
+ classList={{
+ 'h-full': !isCompact(),
+ 'calendar-event-content-compact': isCompact(),
+ 'calendar-event-content-layout-single-line':
+ isCompact() || usesSingleLineLayout(),
+ }}
+ >
+ <span
+ class="calendar-event-title max-w-full shrink-0 font-semibold leading-tight"
+ classList={{
+ truncate: !props.isNarrow,
+ 'whitespace-nowrap': props.isNarrow,
+ }}
+ >
{props.event.title}
</span>
- <Show when={props.renderProps.timeText}>
- {(timeText) => (
- <span class="mt-0.5 truncate text-[0.6875rem] leading-tight opacity-85 tabular-nums">
- {timeText()}
+ <Show when={timeText()}>
+ {(text) => (
+ <span class="calendar-event-time mt-0.5 shrink-0 truncate leading-tight opacity-85 tabular-nums">
+ {text()}
</span>
)}
</Show>
<Show when={showLocation() && props.event.location}>
- <span class="mt-1 truncate text-[0.6875rem] leading-tight opacity-80">
+ <span class="calendar-event-metadata calendar-event-location mt-1 shrink-0 truncate leading-tight opacity-80">
{props.event.location}
</span>
</Show>
</div>
- </Show>
+ </div>
);
}
diff --git a/apps/web/src/features/calendar/events/EventDetails.tsx b/apps/web/src/features/calendar/events/EventDetails.tsx
index c2b28df605..33428eec35 100644
--- a/apps/web/src/features/calendar/events/EventDetails.tsx
+++ b/apps/web/src/features/calendar/events/EventDetails.tsx
@@ -1,8 +1,19 @@
+import { openExternalUrl } from '@core/util/url';
import CalendarIcon from '@phosphor/calendar-blank.svg';
import ClockIcon from '@phosphor/clock.svg';
+import GlobeIcon from '@phosphor/globe.svg';
import MapPinIcon from '@phosphor/map-pin.svg';
-import { Show } from 'solid-js';
-import { formatCalendarTime } from '../time-format';
+import RepeatIcon from '@phosphor/repeat.svg';
+import UserIcon from '@phosphor/user.svg';
+import UsersIcon from '@phosphor/users.svg';
+import VideoCameraIcon from '@phosphor/video-camera.svg';
+import type { AttendeeResponseStatus } from '@service-storage/generated/schemas/attendeeResponseStatus';
+import { Button } from '@ui';
+import { createMemo, For, Show } from 'solid-js';
+import {
+ CALENDAR_TIME_FORMAT_OPTIONS,
+ formatCalendarTime,
+} from '../time-format';
import type { CalendarEvent, CalendarTimeFormat } from './types';
const formatDate = new Intl.DateTimeFormat(undefined, {
@@ -16,6 +27,13 @@ const formatShortDate = new Intl.DateTimeFormat(undefined, {
});
const isDateOnly = (value: string) => /^\d{4}-\d{2}-\d{2}$/.test(value);
+const ATTENDEE_RESPONSE = {
+ accepted: { label: 'Accepted', class: 'text-success' },
+ declined: { label: 'Declined', class: 'text-failure' },
+ tentative: { label: 'Tentative', class: 'text-warning' },
+ needs_action: { label: 'No response', class: 'text-ink-extra-muted' },
+} satisfies Record<AttendeeResponseStatus, { label: string; class: string }>;
+
function parseCalendarDate(value: string) {
if (!isDateOnly(value)) return new Date(value);
@@ -48,11 +66,67 @@ function formatEventSchedule(
: `${formatDate.format(start)}, ${formatCalendarTime(start, timeFormat)}–${formatDate.format(end)}, ${formatCalendarTime(end, timeFormat)}`;
}
+function safeConferenceUrl(value: string | undefined) {
+ if (!value) return undefined;
+
+ try {
+ const url = new URL(value);
+ return url.protocol === 'https:' || url.protocol === 'http:'
+ ? url.toString()
+ : undefined;
+ } catch {
+ return undefined;
+ }
+}
+
+function findOrganizer(event: CalendarEvent) {
+ const organizerAttendee = event.attendees.find(
+ (attendee) => attendee.isOrganizer
+ );
+ const name =
+ event.organizerName ??
+ organizerAttendee?.displayName ??
+ event.organizerEmail ??
+ organizerAttendee?.email;
+ const email = event.organizerEmail ?? organizerAttendee?.email;
+
+ return name ? { name, email } : undefined;
+}
+
+function formatOriginalTimeZone(
+ event: CalendarEvent,
+ timeFormat: CalendarTimeFormat
+) {
+ if (event.allDay || !event.timeZone) return undefined;
+
+ try {
+ const time = new Intl.DateTimeFormat(undefined, {
+ ...CALENDAR_TIME_FORMAT_OPTIONS[timeFormat],
+ timeZone: event.timeZone,
+ timeZoneName: 'short',
+ }).format(parseCalendarDate(event.start));
+ return `Original time: ${time} · ${event.timeZone}`;
+ } catch {
+ return `Original timezone: ${event.timeZone}`;
+ }
+}
+
/** Displays read-only details for a selected calendar event. */
export function EventDetails(props: {
event: CalendarEvent;
timeFormat: CalendarTimeFormat;
}) {
+ const conferenceUrl = createMemo(() =>
+ safeConferenceUrl(props.event.conferenceUrl)
+ );
+ const organizer = createMemo(() => findOrganizer(props.event));
+ const originalTimeZone = createMemo(() =>
+ formatOriginalTimeZone(props.event, props.timeFormat)
+ );
+ const isRecurring = () =>
+ props.event.recurrenceLines.length > 0 ||
+ props.event.recurrenceId !== undefined;
+
return (
<div class="min-w-0 p-1 text-ink">
<div class="flex items-start gap-2">
@@ -65,7 +139,24 @@ export function EventDetails(props: {
<div class="text-sm font-semibold leading-snug text-ink">
{props.event.title}
</div>
- <div class="mt-2 flex flex-col gap-2 text-xs text-ink-muted">
+
+ <Show when={conferenceUrl()}>
+ {(url) => (
+ <Button
+ fullWidth
+ variant="cta"
+ size="sm"
+ class="mt-3 h-7 rounded-lg"
+ label="Join meeting"
+ onClick={() => openExternalUrl(url())}
+ >
+ <VideoCameraIcon class="size-3.5" />
+ Join meeting
+ </Button>
+ )}
+ </Show>
+
+ <div class="mt-3 flex flex-col gap-2 text-xs text-ink-muted">
<div class="flex items-start gap-2">
<Show
when={props.event.allDay}
@@ -77,6 +168,23 @@ export function EventDetails(props: {
</Show>
<span>{formatEventSchedule(props.event, props.timeFormat)}</span>
</div>
+
+ <Show when={originalTimeZone()}>
+ {(timeZone) => (
+ <div class="flex items-start gap-2">
+ <GlobeIcon class="mt-0.5 size-3.5 shrink-0 text-ink-extra-muted" />
+ <span>{timeZone()}</span>
+ </div>
+ )}
+ </Show>
+
+ <Show when={isRecurring()}>
+ <div class="flex items-start gap-2">
+ <RepeatIcon class="mt-0.5 size-3.5 shrink-0 text-ink-extra-muted" />
+ <span>Recurring event</span>
+ </div>
+ </Show>
+
<Show when={props.event.location}>
{(location) => (
<div class="flex items-start gap-2">
@@ -85,6 +193,101 @@ export function EventDetails(props: {
</div>
)}
</Show>
+
+ <Show when={organizer()}>
+ {(eventOrganizer) => (
+ <div class="flex items-start gap-2">
+ <UserIcon class="mt-0.5 size-3.5 shrink-0 text-ink-extra-muted" />
+ <div class="min-w-0">
+ <div class="text-[0.6875rem] text-ink-extra-muted">
+ Organizer
+ </div>
+ <div class="truncate text-ink-muted">
+ {eventOrganizer().name}
+ </div>
+ <Show
+ when={
+ eventOrganizer().email &&
+ eventOrganizer().email !== eventOrganizer().name
+ }
+ >
+ <div class="truncate text-[0.6875rem] text-ink-extra-muted">
+ {eventOrganizer().email}
+ </div>
+ </Show>
+ </div>
+ </div>
+ )}
+ </Show>
+
+ <Show when={props.event.attendees.length > 0}>
+ <div class="flex items-start gap-2">
+ <UsersIcon class="mt-0.5 size-3.5 shrink-0 text-ink-extra-muted" />
+ <div class="min-w-0 flex-1">
+ <div>
+ {props.event.attendees.length}{' '}
+ {props.event.attendees.length === 1
+ ? 'attendee'
+ : 'attendees'}
+ </div>
+ <div class="mt-1.5 flex max-h-40 flex-col gap-1.5 overflow-y-auto pr-1">
+ <For each={props.event.attendees}>
+ {(attendee) => {
+ const response =
+ ATTENDEE_RESPONSE[attendee.responseStatus];
+ const name = attendee.displayName ?? attendee.email;
+
+ return (
+ <div class="flex min-w-0 items-start gap-2">
+ <div class="min-w-0 flex-1">
+ <div class="flex min-w-0 items-center gap-1">
+ <span class="truncate text-ink-muted">
+ {name}
+ <Show when={attendee.isSelf}> (you)</Show>
+ </span>
+ <Show when={attendee.isOrganizer}>
+ <span class="shrink-0 text-[0.625rem] text-ink-extra-muted">
+ Organizer
+ </span>
+ </Show>
+ <Show when={attendee.isOptional}>
+ <span class="shrink-0 text-[0.625rem] text-ink-extra-muted">
+ Optional
+ </span>
+ </Show>
+ </div>
+ <Show
+ when={
+ attendee.displayName &&
+ attendee.displayName !== attendee.email
+ }
+ >
+ <div class="truncate text-[0.6875rem] text-ink-extra-muted">
+ {attendee.email}
+ </div>
+ </Show>
+ <Show when={attendee.comment}>
+ {(comment) => (
+ <div class="line-clamp-2 text-[0.6875rem] italic text-ink-extra-muted">
+ {comment()}
+ </div>
+ )}
+ </Show>
+ </div>
+ <span
+ class={`shrink-0 text-[0.6875rem] ${response.class}`}
+ >
+ {response.label}
+ </span>
+ </div>
+ );
+ }}
+ </For>
+ </div>
+ </div>
+ </div>
+ </Show>
+
<div class="flex items-center gap-2">
<span
aria-hidden="true"
@@ -94,6 +297,7 @@ export function EventDetails(props: {
<span>{props.event.calendar.name}</span>
</div>
</div>
+
<Show when={props.event.description}>
{(description) => (
<p class="mt-3 border-t border-edge-muted pt-3 text-xs leading-relaxed text-ink-muted">
diff --git a/apps/web/src/features/calendar/events/calendar-occurrence-mapper.test.ts b/apps/web/src/features/calendar/events/calendar-occurrence-mapper.test.ts
new file mode 100644
index 0000000000..ed3e16cb86
--- /dev/null
+++ b/apps/web/src/features/calendar/events/calendar-occurrence-mapper.test.ts
@@ -0,0 +1,103 @@
+import type { CalendarOccurrenceItem } from '@service-storage/generated/schemas/calendarOccurrenceItem';
+import { describe, expect, it } from 'vitest';
+import {
+ DEFAULT_CALENDAR_SOURCE,
+ mapCalendarOccurrence,
+} from './calendar-occurrence-mapper';
+
+const item = (time: CalendarOccurrenceItem['occurrence']['time']) =>
+ ({
+ event: {
+ id: 'event-1',
+ title: 'Planning',
+ location: null,
+ description: 'Weekly planning',
+ conferenceUrl: 'https://meet.example.com/planning',
+ organizerName: 'Alex Rivera',
+ organizerEmail: '[email protected]',
+ attendees: [
+ {
+ email: '[email protected]',
+ displayName: 'Alex Rivera',
+ responseStatus: 'accepted',
+ isOrganizer: true,
+ isOptional: false,
+ isSelf: false,
+ },
+ ],
+ recurrenceLines: ['RRULE:FREQ=WEEKLY'],
+ isReadOnly: true,
+ },
+ occurrence: {
+ occurrenceKey: '2026-08-04T14:00:00+00:00',
+ recurrenceId: 'recurrence-1',
+ time,
+ },
+ }) as CalendarOccurrenceItem;
+
+describe('mapCalendarOccurrence', () => {
+ it('maps a timed occurrence using its occurrence span', () => {
+ const event = mapCalendarOccurrence(
+ item({
+ kind: 'timed',
+ startsAt: '2026-08-04T15:00:00Z',
+ endsAt: '2026-08-04T16:00:00Z',
+ timeZone: 'America/New_York',
+ })
+ );
+
+ expect(event).toMatchObject({
+ eventId: 'event-1',
+ occurrenceKey: '2026-08-04T14:00:00+00:00',
+ recurrenceId: 'recurrence-1',
+ start: '2026-08-04T15:00:00Z',
+ end: '2026-08-04T16:00:00Z',
+ allDay: false,
+ isReadOnly: true,
+ conferenceUrl: 'https://meet.example.com/planning',
+ organizerName: 'Alex Rivera',
+ organizerEmail: '[email protected]',
+ recurrenceLines: ['RRULE:FREQ=WEEKLY'],
+ timeZone: 'America/New_York',
+ title: 'Planning',
+ description: 'Weekly planning',
+ location: undefined,
+ calendar: DEFAULT_CALENDAR_SOURCE,
+ });
+ });
+
+ it('preserves exclusive local dates for an all-day occurrence', () => {
+ const event = mapCalendarOccurrence(
+ item({
+ kind: 'allDay',
+ startDate: '2026-08-04',
+ endDate: '2026-08-06',
+ })
+ );
+
+ expect(event).toMatchObject({
+ start: '2026-08-04',
+ end: '2026-08-06',
+ allDay: true,
+ });
+ });
+
+ it('creates distinct render IDs for occurrences of the same event', () => {
+ const first = item({
+ kind: 'allDay',
+ startDate: '2026-08-04',
+ endDate: '2026-08-05',
+ });
+ const second = {
+ ...first,
+ occurrence: {
+ ...first.occurrence,
+ occurrenceKey: '2026-08-11',
+ },
+ };
+
+ expect(mapCalendarOccurrence(first).id).not.toBe(
+ mapCalendarOccurrence(second).id
+ );
+ });
+});
diff --git a/apps/web/src/features/calendar/events/calendar-occurrence-mapper.ts b/apps/web/src/features/calendar/events/calendar-occurrence-mapper.ts
new file mode 100644
index 0000000000..5dd9a95a6f
--- /dev/null
+++ b/apps/web/src/features/calendar/events/calendar-occurrence-mapper.ts
@@ -0,0 +1,40 @@
+import type { CalendarOccurrenceItem } from '@service-storage/generated/schemas/calendarOccurrenceItem';
+import type { CalendarEvent, CalendarSource } from './types';
+
+/** Shared presentation source until calendar/account metadata is exposed. */
+export const DEFAULT_CALENDAR_SOURCE: CalendarSource = {
+ id: 'calendar',
+ name: 'Calendar',
+ color: 'var(--color-accent)',
+};
+
+/** Maps one backend occurrence projection into the calendar view model. */
+export function mapCalendarOccurrence(
+ item: CalendarOccurrenceItem
+): CalendarEvent {
+ const { event, occurrence } = item;
+ const time = occurrence.time;
+ const range =
+ time.kind === 'timed'
+ ? { allDay: false, start: time.startsAt, end: time.endsAt }
+ : { allDay: true, start: time.startDate, end: time.endDate };
+
+ return {
+ ...range,
+ id: JSON.stringify([event.id, occurrence.occurrenceKey]),
+ eventId: event.id,
+ occurrenceKey: occurrence.occurrenceKey,
+ recurrenceId: occurrence.recurrenceId ?? undefined,
+ recurrenceLines: event.recurrenceLines ?? [],
+ isReadOnly: event.isReadOnly,
+ conferenceUrl: event.conferenceUrl ?? undefined,
+ organizerName: event.organizerName ?? undefined,
+ organizerEmail: event.organizerEmail ?? undefined,
+ attendees: event.attendees ?? [],
+ timeZone: time.kind === 'timed' ? (time.timeZone ?? undefined) : undefined,
+ title: event.title,
+ calendar: DEFAULT_CALENDAR_SOURCE,
+ location: event.location ?? undefined,
+ description: event.description ?? undefined,
+ };
+}
diff --git a/apps/web/src/features/calendar/events/types.ts b/apps/web/src/features/calendar/events/types.ts
index 76e46de676..fc5e8f2ba2 100644
--- a/apps/web/src/features/calendar/events/types.ts
+++ b/apps/web/src/features/calendar/events/types.ts
@@ -1,3 +1,5 @@
+import type { CalendarAttendee } from '@service-storage/generated/schemas/calendarAttendee';
+
/** Supported first day of the calendar week. */
export type CalendarWeekStart = 0 | 1;
@@ -14,10 +16,30 @@ export interface CalendarSource {
color: string;
}
-/** Calendar-owned event data, independent from FullCalendar. */
+/** Calendar occurrence data, independent from FullCalendar. */
export interface CalendarEvent {
- /** Stable event identifier. */
+ /** Stable identifier for this rendered occurrence. */
id: string;
+ /** Stable canonical calendar event identifier. */
+ eventId: string;
+ /** Stable key for this occurrence within its event. */
+ occurrenceKey: string;
+ /** Provider recurrence identifier, when applicable. */
+ recurrenceId?: string;
+ /** Whether the canonical event source is read-only. */
+ isReadOnly: boolean;
+ /** Direct conference join URL, when available. */
+ conferenceUrl?: string;
+ /** Event organizer display name. */
+ organizerName?: string;
+ /** Event organizer email address. */
+ organizerEmail?: string;
+ /** Attendees and their RSVP metadata. */
+ attendees: CalendarAttendee[];
+ /** Raw recurrence rules attached to the canonical event. */
+ recurrenceLines: string[];
+ /** Original IANA timezone for a timed occurrence. */
+ timeZone?: string;
/** Event title. */
title: string;
/** ISO timestamp or local date string for all-day events. */
diff --git a/apps/web/src/features/calendar/time-format.ts b/apps/web/src/features/calendar/time-format.ts
index 11eca746ba..f22d78a375 100644
--- a/apps/web/src/features/calendar/time-format.ts
+++ b/apps/web/src/features/calendar/time-format.ts
@@ -25,6 +25,36 @@ const calendarTimeFormatters = {
),
} satisfies Record<CalendarTimeFormat, Intl.DateTimeFormat>;
+const compactWholeHourFormatter = new Intl.DateTimeFormat(undefined, {
+ hour: 'numeric',
+ hour12: true,
+});
+
+function compactDayPeriod(
+ parts: Intl.DateTimeFormatPart[],
+ showDayPeriod = true
+) {
+ return parts
+ .map((part, index) => {
+ if (part.type === 'dayPeriod') {
+ return showDayPeriod ? part.value.toLocaleLowerCase() : '';
+ }
+
+ const previousPart = parts[index - 1];
+ const nextPart = parts[index + 1];
+ if (
+ part.type === 'literal' &&
+ part.value.trim() === '' &&
+ (previousPart?.type === 'dayPeriod' || nextPart?.type === 'dayPeriod')
+ ) {
+ return '';
+ }
+
+ return part.value;
+ })
+ .join('');
+}
+
/** Returns the time format that matches the user's current locale. */
export function getDefaultCalendarTimeFormat(): CalendarTimeFormat {
return new Intl.DateTimeFormat(undefined, {
@@ -38,3 +68,37 @@ export function getDefaultCalendarTimeFormat(): CalendarTimeFormat {
export function formatCalendarTime(date: Date, timeFormat: CalendarTimeFormat) {
return calendarTimeFormatters[timeFormat].format(date);
}
+
+/** Formats event-card times compactly while preserving the selected clock. */
+export function formatCompactCalendarTime(
+ date: Date,
+ timeFormat: CalendarTimeFormat,
+ showDayPeriod = true
+) {
+ if (timeFormat === '24-hour') {
+ return calendarTimeFormatters[timeFormat].format(date);
+ }
+
+ const formatter =
+ date.getMinutes() === 0
+ ? compactWholeHourFormatter
+ : calendarTimeFormatters[timeFormat];
+ return compactDayPeriod(formatter.formatToParts(date), showDayPeriod);
+}
+
+/** Formats an event-card range without repeating a shared AM/PM marker. */
+export function formatCompactCalendarTimeRange(
+ start: Date,
+ end: Date,
+ timeFormat: CalendarTimeFormat
+) {
+ const startIsAm = start.getHours() < 12;
+ const endIsAm = end.getHours() < 12;
+ const sharesDayPeriod = timeFormat === '12-hour' && startIsAm === endIsAm;
+
+ return `${formatCompactCalendarTime(
+ start,
+ timeFormat,
+ !sharesDayPeriod
+ )}–${formatCompactCalendarTime(end, timeFormat)}`;
+}
diff --git a/apps/web/src/lib/queries/calendar/keys.ts b/apps/web/src/lib/queries/calendar/keys.ts
new file mode 100644
index 0000000000..5d495df290
--- /dev/null
+++ b/apps/web/src/lib/queries/calendar/keys.ts
@@ -0,0 +1,17 @@
+import { createQueryKeys } from '@lukemorales/query-key-factory';
+
+export interface CalendarOccurrenceQueryRange {
+ start: string;
+ end: string;
+ startDate: string;
+ endDate: string;
+}
+
+export const calendarKeys = createQueryKeys('calendar', {
+ occurrences: (
+ userId: string,
+ range: CalendarOccurrenceQueryRange | undefined
+ ) => ({
+ queryKey: [userId, range],
+ }),
+});
diff --git a/apps/web/src/lib/queries/calendar/occurrences.ts b/apps/web/src/lib/queries/calendar/occurrences.ts
new file mode 100644
index 0000000000..b70b51b686
--- /dev/null
+++ b/apps/web/src/lib/queries/calendar/occurrences.ts
@@ -0,0 +1,131 @@
+import { throwOnErr } from '@core/util/result';
+import { queryClient } from '@queries/client';
+import { storageServiceClient } from '@service-storage/client';
+import type { CalendarOccurrenceItem } from '@service-storage/generated/schemas/calendarOccurrenceItem';
+import type { CalendarOccurrenceResponse } from '@service-storage/generated/schemas/calendarOccurrenceResponse';
+import { CalendarSyncStatus } from '@service-storage/generated/schemas/calendarSyncStatus';
+import { useQuery } from '@tanstack/solid-query';
+import type { Accessor } from 'solid-js';
+import { type CalendarOccurrenceQueryRange, calendarKeys } from './keys';
+
+export type { CalendarOccurrenceQueryRange } from './keys';
+
+const CALENDAR_OCCURRENCE_PAGE_SIZE = 2000;
+const CALENDAR_SYNC_POLL_INTERVAL = 5000;
+const CALENDAR_STALE_TIME = 60_000;
+
+export interface CalendarOccurrencesQueryInput {
+ userId: string | undefined;
+ range: CalendarOccurrenceQueryRange | undefined;
+}
+
+export interface CalendarOccurrencesQueryOptions {
+ enabled?: boolean;
+}
+
+export interface CalendarOccurrencesData {
+ items: CalendarOccurrenceItem[];
+ syncStatus: CalendarOccurrenceResponse['syncStatus'];
+}
+
+const formatLocalDate = (date: Date) =>
+ `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}-${String(date.getDate()).padStart(2, '0')}`;
+
+/** Creates the UTC and local boundaries required by the occurrence endpoint. */
+export function createCalendarOccurrenceQueryRange(
+ start: Date,
+ end: Date
+): CalendarOccurrenceQueryRange {
+ return {
+ start: start.toISOString(),
+ end: end.toISOString(),
+ startDate: formatLocalDate(start),
+ endDate: formatLocalDate(end),
+ };
+}
+
+const occurrenceIdentity = (item: CalendarOccurrenceItem) =>
+ JSON.stringify([item.event.id, item.occurrence.occurrenceKey]);
+
+/** Fetches and deduplicates every occurrence page for one viewport. */
+export async function fetchCalendarOccurrences(
+ range: CalendarOccurrenceQueryRange,
+ signal?: AbortSignal
+): Promise<CalendarOccurrencesData> {
+ const itemsById = new Map<string, CalendarOccurrenceItem>();
+ const seenCursors = new Set<string>();
+ let cursor: string | undefined;
+ let syncStatus: CalendarOccurrenceResponse['syncStatus'] =
+ CalendarSyncStatus.ready;
+
+ do {
+ const page = await throwOnErr(() =>
+ storageServiceClient.listCalendarOccurrences({
+ ...range,
+ cursor,
+ limit: CALENDAR_OCCURRENCE_PAGE_SIZE,
+ signal,
+ })
+ );
+
+ if (page.syncStatus === CalendarSyncStatus.syncing) {
+ syncStatus = CalendarSyncStatus.syncing;
+ }
+
+ for (const item of page.items) {
+ itemsById.set(occurrenceIdentity(item), item);
+ }
+
+ if (!page.hasMore) break;
+
+ const nextCursor = page.nextCursor ?? undefined;
+ if (!nextCursor || seenCursors.has(nextCursor)) {
+ throw new Error(
+ 'Calendar occurrence pagination returned an invalid cursor'
+ );
+ }
+
+ seenCursors.add(nextCursor);
+ cursor = nextCursor;
+ } while (cursor);
+
+ return {
+ items: [...itemsById.values()],
+ syncStatus,
+ };
+}
+
+export function useCalendarOccurrencesQuery(
+ input: Accessor<CalendarOccurrencesQueryInput>,
+ options?: Accessor<CalendarOccurrencesQueryOptions>
+) {
+ return useQuery(() => {
+ const { userId, range } = input();
+
+ return {
+ queryKey: calendarKeys.occurrences(userId ?? '', range).queryKey,
+ queryFn: ({ signal }) => {
+ if (!range) {
+ throw new Error('Calendar occurrence range is unavailable');
+ }
+
+ return fetchCalendarOccurrences(range, signal);
+ },
+ enabled:
+ Boolean(userId) && range !== undefined && options?.().enabled !== false,
+ staleTime: CALENDAR_STALE_TIME,
+ placeholderData: (p) => p,
+ refetchOnWindowFocus: true,
+ refetchInterval: (query) =>
+ query.state.data?.syncStatus === CalendarSyncStatus.syncing
+ ? CALENDAR_SYNC_POLL_INTERVAL
+ : false,
+ };
+ });
+}
+
+export function invalidateCalendarOccurrences() {
+ return queryClient.invalidateQueries({
+ queryKey: calendarKeys.occurrences._def,
+ });
+}
diff --git a/apps/web/src/lib/queries/calendar/tests/occurrences.test.ts b/apps/web/src/lib/queries/calendar/tests/occurrences.test.ts
new file mode 100644
index 0000000000..538e50bb87
--- /dev/null
+++ b/apps/web/src/lib/queries/calendar/tests/occurrences.test.ts
@@ -0,0 +1,136 @@
+import { storageServiceClient } from '@service-storage/client';
+import type { CalendarOccurrenceItem } from '@service-storage/generated/schemas/calendarOccurrenceItem';
+import { CalendarSyncStatus } from '@service-storage/generated/schemas/calendarSyncStatus';
+import { ok } from 'neverthrow';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import {
+ createCalendarOccurrenceQueryRange,
+ fetchCalendarOccurrences,
+} from '../occurrences';
+
+vi.mock('@service-storage/client', () => ({
+ storageServiceClient: {
+ listCalendarOccurrences: vi.fn(),
+ },
+}));
+
+const range = {
+ start: '2026-08-01T04:00:00.000Z',
+ end: '2026-09-01T04:00:00.000Z',
+ startDate: '2026-08-01',
+ endDate: '2026-09-01',
+};
+
+const occurrence = (
+ eventId: string,
+ occurrenceKey: string
+): CalendarOccurrenceItem =>
+ ({
+ event: { id: eventId },
+ occurrence: { occurrenceKey },
+ }) as CalendarOccurrenceItem;
+
+describe('fetchCalendarOccurrences', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ });
+
+ it('fetches every page, forwards cancellation, and deduplicates occurrences', async () => {
+ const first = occurrence('event-1', '2026-08-01T14:00:00Z');
+ const second = occurrence('event-1', '2026-08-08T14:00:00Z');
+ vi.mocked(storageServiceClient.listCalendarOccurrences)
+ .mockResolvedValueOnce(
+ ok({
+ items: [first],
+ hasMore: true,
+ nextCursor: 'next-page',
+ syncStatus: CalendarSyncStatus.ready,
+ })
+ )
+ .mockResolvedValueOnce(
+ ok({
+ items: [first, second],
+ hasMore: false,
+ nextCursor: null,
+ syncStatus: CalendarSyncStatus.syncing,
+ })
+ );
+ const controller = new AbortController();
+
+ await expect(
+ fetchCalendarOccurrences(range, controller.signal)
+ ).resolves.toEqual({
+ items: [first, second],
+ syncStatus: CalendarSyncStatus.syncing,
+ });
+ expect(
+ storageServiceClient.listCalendarOccurrences
+ ).toHaveBeenNthCalledWith(1, {
+ ...range,
+ cursor: undefined,
+ limit: 2000,
+ signal: controller.signal,
+ });
+ expect(
+ storageServiceClient.listCalendarOccurrences
+ ).toHaveBeenNthCalledWith(2, {
+ ...range,
+ cursor: 'next-page',
+ limit: 2000,
+ signal: controller.signal,
+ });
+ });
+
+ it('rejects a missing cursor when another page is expected', async () => {
+ vi.mocked(storageServiceClient.listCalendarOccurrences).mockResolvedValue(
+ ok({
+ items: [],
+ hasMore: true,
+ nextCursor: null,
+ syncStatus: CalendarSyncStatus.ready,
+ })
+ );
+
+ await expect(fetchCalendarOccurrences(range)).rejects.toThrow(
+ 'Calendar occurrence pagination returned an invalid cursor'
+ );
+ });
+
+ it('rejects a repeated cursor', async () => {
+ vi.mocked(storageServiceClient.listCalendarOccurrences)
+ .mockResolvedValueOnce(
+ ok({
+ items: [],
+ hasMore: true,
+ nextCursor: 'repeated',
+ syncStatus: CalendarSyncStatus.ready,
+ })
+ )
+ .mockResolvedValueOnce(
+ ok({
+ items: [],
+ hasMore: true,
+ nextCursor: 'repeated',
+ syncStatus: CalendarSyncStatus.ready,
+ })
+ );
+
+ await expect(fetchCalendarOccurrences(range)).rejects.toThrow(
+ 'Calendar occurrence pagination returned an invalid cursor'
+ );
+ });
+});
+
+describe('calendar range helpers', () => {
+ it('uses UTC instants with local all-day boundaries', () => {
+ const start = new Date(2026, 7, 3, 0, 0, 0);
+ const end = new Date(2026, 7, 10, 0, 0, 0);
+
+ expect(createCalendarOccurrenceQueryRange(start, end)).toEqual({
+ start: start.toISOString(),
+ end: end.toISOString(),
+ startDate: '2026-08-03',
+ endDate: '2026-08-10',
+ });
+ });
+});
diff --git a/apps/web/src/lib/service-clients/service-storage/client.ts b/apps/web/src/lib/service-clients/service-storage/client.ts
index 186318164c..bf04f2f3ab 100644
--- a/apps/web/src/lib/service-clients/service-storage/client.ts
+++ b/apps/web/src/lib/service-clients/service-storage/client.ts
@@ -43,6 +43,7 @@ import type { ApiThreadReply } from './generated/schemas/apiThreadReply';
import type { Bot } from './generated/schemas/bot';
import type { BotChannel } from './generated/schemas/botChannel';
import type { BotToken } from './generated/schemas/botToken';
+import type { CalendarOccurrenceResponse } from './generated/schemas/calendarOccurrenceResponse';
import type { CallRecordPreview } from './generated/schemas/callRecordPreview';
import type { ChannelJoinCodeResponse } from './generated/schemas/channelJoinCodeResponse';
import type { ChannelMessageFilters } from './generated/schemas/channelMessageFilters';
@@ -115,6 +116,7 @@ import type { GroupedSoupGroupPage } from './generated/schemas/groupedSoupGroupP
import type { GroupedSoupInitialPage } from './generated/schemas/groupedSoupInitialPage';
import type { GroupedSoupSort } from './generated/schemas/groupedSoupSort';
import type { Item } from './generated/schemas/item';
+import type { ListOccurrencesParams } from './generated/schemas/listOccurrencesParams';
import type { LocationResponseV3 } from './generated/schemas/locationResponseV3';
import type { PatchChannelRequest } from './generated/schemas/patchChannelRequest';
import type { PatchMessageRequest } from './generated/schemas/patchMessageRequest';
@@ -413,6 +415,25 @@ export const storageServiceClient = {
).map((result) => result);
},
+ async listCalendarOccurrences(
+ args: ListOccurrencesParams & { signal?: AbortSignal }
+ ) {
+ const { cursor, end, endDate, limit, signal, start, startDate } = args;
+ const params = new URLSearchParams({ end, start });
+
+ if (startDate) params.set('startDate', startDate);
+ if (endDate) params.set('endDate', endDate);
+ if (limit !== undefined) params.set('limit', String(limit));
+ if (cursor) params.set('cursor', cursor);
+
+ return (
+ await dssFetch<CalendarOccurrenceResponse>(
+ `/calendar-events?${params.toString()}`,
+ { method: 'GET', signal }
+ )
+ ).map((result) => result);
+ },
+
async getSoupItems(args: {
params: { cursor?: string | null };
body: PostSoupRequest;