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): ai event preview (#5875)

dev-rb5f28343b6d86
diff --git a/apps/web/src/features/calendar/components/CalendarEmbed.tsx b/apps/web/src/features/calendar/components/CalendarEmbed.tsx
index 0e47b71d8a..f14602de70 100644
--- a/apps/web/src/features/calendar/components/CalendarEmbed.tsx
+++ b/apps/web/src/features/calendar/components/CalendarEmbed.tsx
@@ -17,6 +17,8 @@ export type CalendarEmbedSettings = Omit<
'showAllDaySlot' | 'useNarrowDayHeaders' | 'useNarrowEventContent'
> & {
collapseEmptyAllDaySlot?: boolean;
+ /** Overrides responsive abbreviated weekday headers when provided. */
+ useNarrowDayHeaders?: boolean;
};
export type CalendarEmbedProps = Omit<CalendarGridProps, 'settings'> & {
@@ -78,10 +80,11 @@ export function CalendarEmbed(props: CalendarEmbedProps) {
showWeekends: props.settings.showWeekends,
weekStartsOn: props.settings.weekStartsOn,
timeFormat: props.settings.timeFormat,
- useNarrowDayHeaders: isNarrow(),
+ useNarrowDayHeaders: props.settings.useNarrowDayHeaders ?? isNarrow(),
useNarrowEventContent: isNarrow(),
}}
selection={props.selection}
+ emphasizedEventIds={props.emphasizedEventIds}
eventTimeChangePending={props.eventTimeChangePending}
onDatesSet={props.onDatesSet}
onEventTimeChange={props.onEventTimeChange}
diff --git a/apps/web/src/features/calendar/components/CalendarGrid.tsx b/apps/web/src/features/calendar/components/CalendarGrid.tsx
index fd1c5e0d9b..b1576f2215 100644
--- a/apps/web/src/features/calendar/components/CalendarGrid.tsx
+++ b/apps/web/src/features/calendar/components/CalendarGrid.tsx
@@ -113,6 +113,8 @@ export interface CalendarGridProps {
eventsById: Map<string, CalendarEvent>;
settings: CalendarGridSettings;
selection: CalendarGridSelection;
+ /** Rendered occurrence ids that should visually stand out from nearby events. */
+ emphasizedEventIds?: ReadonlySet<string>;
eventTimeChangePending?: boolean;
onDatesSet?: (info: DatesSetArg) => void;
onEventTimeChange?: (
@@ -159,9 +161,15 @@ export function CalendarGrid(props: CalendarGridProps) {
const mappedEvents = createMemo<EventInput[]>(() =>
props.events.map((event) => {
const mapped = mapCalendarEventToFullCalendar(event);
- return props.onEventTimeChange
- ? mapped
- : { ...mapped, startEditable: false, durationEditable: false };
+ const emphasized = props.emphasizedEventIds?.has(event.id);
+ return {
+ ...mapped,
+ classNames: emphasized ? ['calendar-event-emphasized'] : undefined,
+ startEditable: props.onEventTimeChange ? mapped.startEditable : false,
+ durationEditable: props.onEventTimeChange
+ ? mapped.durationEditable
+ : false,
+ };
})
);
const [eventInteractionActive, setEventInteractionActive] =
@@ -206,6 +214,7 @@ export function CalendarGrid(props: CalendarGridProps) {
? undefined
: { days: props.settings.dayCount }
}
+ dateAlignment={props.settings.dayCount === undefined ? undefined : 'day'}
dayHeaders={props.settings.showDayHeaders ?? true}
allDaySlot={props.settings.showAllDaySlot ?? true}
height="100%"
diff --git a/apps/web/src/features/calendar/components/composer/create-calendar-event-form-controller.ts b/apps/web/src/features/calendar/components/composer/create-calendar-event-form-controller.ts
index fbb63eed00..7f556a70ee 100644
--- a/apps/web/src/features/calendar/components/composer/create-calendar-event-form-controller.ts
+++ b/apps/web/src/features/calendar/components/composer/create-calendar-event-form-controller.ts
@@ -90,6 +90,7 @@ export interface CreateCalendarEventFormControllerOptions {
initialValue: EventEditorInitialValues;
calendarOptions: Accessor<EventEditorCalendarOption[]>;
guestOptions: Accessor<EventEditorGuestOption[]>;
+ recurrenceTimeZone?: string;
onChange?: (value: EventEditorInitialValues) => void;
}
@@ -136,6 +137,7 @@ export function createCalendarEventFormController(
const recurrence = createEventEditorState({
initialValues: options.initialValue,
state,
+ recurrenceTimeZone: options.recurrenceTimeZone,
});
const effectiveCalendarId = () =>
diff --git a/apps/web/src/features/calendar/components/composer/event-form-model.ts b/apps/web/src/features/calendar/components/composer/event-form-model.ts
index 73bf0b8022..60f1dd9f92 100644
--- a/apps/web/src/features/calendar/components/composer/event-form-model.ts
+++ b/apps/web/src/features/calendar/components/composer/event-form-model.ts
@@ -3,6 +3,7 @@ import {
recipientEntityMapper,
type WithCustomUserInput,
} from '@core/user/combinedRecipient';
+import { TZDateMini } from '@date-fns/tz';
import type { ConferenceChange } from '@service-email/generated/schemas/conferenceChange';
import type { EventTime } from '@service-email/generated/schemas/eventTime';
import type { EventReminderOverride } from '@service-storage/generated/schemas/eventReminderOverride';
@@ -320,17 +321,24 @@ export function moveAllDayRange(
export interface CreateEventEditorStateOptions {
initialValues: EventEditorInitialValues;
state: Accessor<EventEditorInitialValues>;
+ recurrenceTimeZone?: string;
}
-function recurrenceConfigFor(values: EventEditorInitialValues) {
+function recurrenceConfigFor(
+ values: EventEditorInitialValues,
+ timeZone?: string
+) {
return values.recurrenceLines.length > 0
- ? parseRecurrenceConfig(values.recurrenceLines)
+ ? parseRecurrenceConfig(values.recurrenceLines, timeZone)
: undefined;
}
-function recurrenceChoiceFor(values: EventEditorInitialValues) {
+function recurrenceChoiceFor(
+ values: EventEditorInitialValues,
+ timeZone?: string
+) {
if (values.recurrenceLines.length === 0) return 'none';
- const config = recurrenceConfigFor(values);
+ const config = recurrenceConfigFor(values, timeZone);
if (!config) return 'existing';
const start = values.allDay ? parseISO(values.start) : new Date(values.start);
const preset = recurrencePresetsFor(start).find((candidate) =>
@@ -342,18 +350,23 @@ function recurrenceChoiceFor(values: EventEditorInitialValues) {
/** Shared recurrence and validation state used by event editor layouts. */
export function createEventEditorState(options: CreateEventEditorStateOptions) {
const [initialValues, setInitialValues] = createSignal(options.initialValues);
- const initialConfig = createMemo(() => recurrenceConfigFor(initialValues()));
+ const initialConfig = createMemo(() =>
+ recurrenceConfigFor(initialValues(), options.recurrenceTimeZone)
+ );
const hasUnrepresentableRule = () =>
initialValues().recurrenceLines.length > 0 && !initialConfig();
const startForRecurrence = createMemo(() => {
- const start = options.state().start;
- const parsed = options.state().allDay ? parseISO(start) : new Date(start);
- return Number.isNaN(parsed.getTime()) ? new Date() : parsed;
+ const state = options.state();
+ const parsed = state.allDay ? parseISO(state.start) : new Date(state.start);
+ if (Number.isNaN(parsed.getTime())) return new Date();
+ return !state.allDay && options.recurrenceTimeZone
+ ? TZDateMini.tz(options.recurrenceTimeZone, parsed)
+ : parsed;
});
const presets = createMemo(() => recurrencePresetsFor(startForRecurrence()));
const [recurrenceChoice, setRecurrenceChoice] = createSignal(
- recurrenceChoiceFor(options.initialValues)
+ recurrenceChoiceFor(options.initialValues, options.recurrenceTimeZone)
);
const recurrenceOptions = createMemo<EventEditorRecurrenceOption[]>(() => {
const values = [
@@ -409,11 +422,19 @@ export function createEventEditorState(options: CreateEventEditorStateOptions) {
if (choice === 'existing') return undefined;
if (choice === 'none') return [];
if (choice === 'custom') {
- return buildRecurrenceLines(customConfig(), options.state().allDay);
+ return buildRecurrenceLines(
+ customConfig(),
+ options.state().allDay,
+ options.recurrenceTimeZone
+ );
}
const preset = presets().find((candidate) => candidate.id === choice);
return preset
- ? buildRecurrenceLines(preset.config, options.state().allDay)
+ ? buildRecurrenceLines(
+ preset.config,
+ options.state().allDay,
+ options.recurrenceTimeZone
+ )
: undefined;
};
const dateRangeError = createMemo(() => {
@@ -439,9 +460,12 @@ export function createEventEditorState(options: CreateEventEditorStateOptions) {
const replaceInitialValues = (next: EventEditorInitialValues) => {
batch(() => {
setInitialValues(() => next);
- setRecurrenceChoice(recurrenceChoiceFor(next));
+ setRecurrenceChoice(
+ recurrenceChoiceFor(next, options.recurrenceTimeZone)
+ );
setCustomConfig(
- recurrenceConfigFor(next) ?? defaultCustomConfig(startForRecurrence())
+ recurrenceConfigFor(next, options.recurrenceTimeZone) ??
+ defaultCustomConfig(startForRecurrence())
);
});
};
diff --git a/apps/web/src/features/calendar/utils/recurrence.test.ts b/apps/web/src/features/calendar/utils/recurrence.test.ts
index 038cf26026..697d1b48b6 100644
--- a/apps/web/src/features/calendar/utils/recurrence.test.ts
+++ b/apps/web/src/features/calendar/utils/recurrence.test.ts
@@ -232,6 +232,21 @@ describe('buildRecurrenceLines', () => {
]);
});
+ it('serializes timed UNTIL in the recurrence timezone', () => {
+ expect(
+ buildRecurrenceLines(
+ {
+ frequency: 'DAILY',
+ interval: 1,
+ byDay: [],
+ ends: { kind: 'on', date: '2026-08-22' },
+ },
+ false,
+ 'America/Los_Angeles'
+ )
+ ).toEqual(['RRULE:FREQ=DAILY;UNTIL=20260823T065959Z']);
+ });
+
it('uses a date-valued UNTIL for all-day events', () => {
expect(
buildRecurrenceLines(
@@ -288,6 +303,15 @@ describe('parseRecurrenceConfig', () => {
expect(parsed?.ends).toEqual({ kind: 'on', date: localDate });
});
+ it('round-trips timed UNTIL in the recurrence timezone', () => {
+ const lines = ['RRULE:FREQ=DAILY;UNTIL=20260823T065959Z'];
+ const parsed = parseRecurrenceConfig(lines, 'America/Los_Angeles');
+ expect(parsed?.ends).toEqual({ kind: 'on', date: '2026-08-22' });
+ expect(
+ parsed && buildRecurrenceLines(parsed, false, 'America/Los_Angeles')
+ ).toEqual(lines);
+ });
+
it('declines rules it cannot round-trip', () => {
expect(parseRecurrenceConfig([])).toBeUndefined();
expect(
diff --git a/apps/web/src/features/calendar/utils/recurrence.ts b/apps/web/src/features/calendar/utils/recurrence.ts
index ab79a50fd5..810c99ceef 100644
--- a/apps/web/src/features/calendar/utils/recurrence.ts
+++ b/apps/web/src/features/calendar/utils/recurrence.ts
@@ -1,4 +1,5 @@
import { formatOrdinal, plural } from '@core/util/string';
+import { TZDateMini } from '@date-fns/tz';
import { format } from 'date-fns';
const POSITIVE_INTEGER_REGEX = /^\d+$/;
@@ -460,14 +461,18 @@ const NEVER: RecurrenceEnds = { kind: 'never' };
* all-day rules carry the plain date, timed rules the local end-of-day
* instant rendered in UTC.
*/
-function untilValue(date: string, allDay: boolean) {
+function untilValue(date: string, allDay: boolean, timeZone?: string) {
if (allDay) return date.replaceAll('-', '');
- const endOfDay = new Date(`${date}T23:59:59`);
+ const [year, month, day] = date.split('-').map(Number);
+ const endOfDay =
+ timeZone && year !== undefined && month !== undefined && day !== undefined
+ ? new TZDateMini(year, month - 1, day, 23, 59, 59, timeZone)
+ : new Date(`${date}T23:59:59`);
return `${endOfDay.toISOString().slice(0, 19).replaceAll(/[-:]/g, '')}Z`;
}
/** The local calendar date a stored `UNTIL` value ends on (inclusive). */
-function untilDate(value: string): string | undefined {
+function untilDate(value: string, timeZone?: string): string | undefined {
const match = value.match(
/^(\d{4})-?(\d{2})-?(\d{2})(?:T(\d{2}):?(\d{2}):?(\d{2})Z)?$/
);
@@ -483,13 +488,17 @@ function untilDate(value: string): string | undefined {
Number(match[6])
)
);
- return format(instant, 'yyyy-MM-dd');
+ return format(
+ timeZone ? TZDateMini.tz(timeZone, instant) : instant,
+ 'yyyy-MM-dd'
+ );
}
/** Serialize a config into a single-`RRULE` recurrence property list. */
export function buildRecurrenceLines(
config: RecurrenceConfig,
- allDay: boolean
+ allDay: boolean,
+ timeZone?: string
): string[] {
const parts = [`FREQ=${config.frequency}`];
if (config.interval > 1) {
@@ -505,7 +514,7 @@ export function buildRecurrenceLines(
);
}
if (config.ends.kind === 'on') {
- parts.push(`UNTIL=${untilValue(config.ends.date, allDay)}`);
+ parts.push(`UNTIL=${untilValue(config.ends.date, allDay, timeZone)}`);
} else if (config.ends.kind === 'after') {
parts.push(`COUNT=${config.ends.count}`);
}
@@ -518,7 +527,8 @@ export function buildRecurrenceLines(
* selectors beyond its vocabulary), which the UI keeps untouched instead.
*/
export function parseRecurrenceConfig(
- lines: string[]
+ lines: string[],
+ timeZone?: string
): RecurrenceConfig | undefined {
if (lines.length === 0) return undefined;
const parsed = parseRecurrenceLines(lines);
@@ -567,7 +577,7 @@ export function parseRecurrenceConfig(
if (rule.count !== undefined) {
ends = { kind: 'after', count: rule.count };
} else if (rule.until !== undefined) {
- const date = untilDate(rule.until);
+ const date = untilDate(rule.until, timeZone);
if (date === undefined) return undefined;
ends = { kind: 'on', date };
}
diff --git a/apps/web/src/lib/core/component/AI/component/tool/calendar/ChatCompose.tsx b/apps/web/src/lib/core/component/AI/component/tool/calendar/ChatCompose.tsx
index 8ed247d82f..818580e541 100644
--- a/apps/web/src/lib/core/component/AI/component/tool/calendar/ChatCompose.tsx
+++ b/apps/web/src/lib/core/component/AI/component/tool/calendar/ChatCompose.tsx
@@ -18,7 +18,15 @@ import type { NamedTool } from '@service-cognition/generated/tools/tool';
import type { CreateCalendarEvent } from '@service-cognition/generated/tools/types';
import { debounce } from '@solid-primitives/scheduled';
import { Layer } from '@ui';
-import { createMemo, createSignal, onCleanup, Show, Suspense } from 'solid-js';
+import {
+ createMemo,
+ createSignal,
+ ErrorBoundary,
+ onCleanup,
+ Show,
+ Suspense,
+} from 'solid-js';
+import { CalendarToolEventPreview } from './EventPreview';
import {
createCalendarEventToEditorInitialValues,
editorSubmitValuesToCreateCalendarEvent,
@@ -169,6 +177,10 @@ function CalendarChatComposeContent(props: CalendarChatComposeProps) {
initialValue: createCalendarEventToEditorInitialValues(props.initialData),
calendarOptions,
guestOptions,
+ recurrenceTimeZone:
+ props.initialData.time.kind === 'timed'
+ ? (props.initialData.time.timeZone ?? undefined)
+ : undefined,
onChange: scheduleUpdate,
});
@@ -311,29 +323,56 @@ function CalendarChatComposeContent(props: CalendarChatComposeProps) {
return (
<Layer depth={2}>
- <div class="flex max-h-[32rem] min-h-0 flex-col gap-3 rounded-xl border border-edge-muted bg-surface p-4 text-ink shadow-sm">
- <Show when={showOwnerDisabledMessage()}>
- <p class="text-xs text-ink-extra-muted/60">
- Only the chat owner can create or edit this calendar event.
- </p>
- </Show>
- <Show when={props.streamLocked && !showOwnerDisabledMessage()}>
- <p class="text-xs text-ink-extra-muted/60">
- Waiting for the response to finish before this event can be edited.
- </p>
- </Show>
- <EventForm
- controller={controller}
- disabled={
- toolFinalized ||
- ownerGateDisabled() ||
- props.streamLocked === true ||
- operation() === 'reject'
+ <div class="flex min-h-0 w-full flex-col gap-4">
+ <div
+ data-calendar-tool-composer
+ class="flex min-h-80 max-h-128 min-w-0 flex-col gap-3 rounded-xl border border-edge-muted bg-surface p-4 text-ink shadow-sm"
+ >
+ <Show when={showOwnerDisabledMessage()}>
+ <p class="text-xs text-ink-extra-muted/60">
+ Only the chat owner can create or edit this calendar event.
+ </p>
+ </Show>
+ <Show when={props.streamLocked && !showOwnerDisabledMessage()}>
+ <p class="text-xs text-ink-extra-muted/60">
+ Waiting for the response to finish before this event can be
+ edited.
+ </p>
+ </Show>
+ <EventForm
+ controller={controller}
+ class="min-w-0"
+ disabled={
+ toolFinalized ||
+ ownerGateDisabled() ||
+ props.streamLocked === true ||
+ operation() === 'reject'
+ }
+ pending={operation() === 'create'}
+ onCancel={() => void handleCancel()}
+ onSubmit={(values) => void handleCreate(values)}
+ />
+ </div>
+ <ErrorBoundary
+ fallback={
+ <div class="flex h-96 items-center justify-center rounded-xl border border-edge-muted bg-surface p-4 text-center text-xs text-ink-muted shadow-sm">
+ Calendar preview unavailable.
+ </div>
}
- pending={operation() === 'create'}
- onCancel={() => void handleCancel()}
- onSubmit={(values) => void handleCreate(values)}
- />
+ >
+ <CalendarToolEventPreview
+ controller={controller}
+ eventId={`calendar-tool-preview:${props.toolCallId}`}
+ showPeriodLabel
+ showNavigationControls
+ timeZone={
+ props.initialData.time.kind === 'timed'
+ ? (props.initialData.time.timeZone ?? undefined)
+ : undefined
+ }
+ class="h-96 shrink-0"
+ />
+ </ErrorBoundary>
</div>
</Layer>
);
diff --git a/apps/web/src/lib/core/component/AI/component/tool/calendar/EventPreview.css b/apps/web/src/lib/core/component/AI/component/tool/calendar/EventPreview.css
new file mode 100644
index 0000000000..d407107255
--- /dev/null
+++ b/apps/web/src/lib/core/component/AI/component/tool/calendar/EventPreview.css
@@ -0,0 +1,77 @@
+.calendar-tool-preview .calendar-view {
+ --fc-border-color: var(--color-edge);
+}
+
+.calendar-tool-preview
+ .calendar-view
+ .fc
+ .fc-timeGridWeek-view
+ .fc-col-header-cell-cushion {
+ flex-direction: row;
+ gap: 0.25rem;
+}
+
+.calendar-tool-preview
+ .calendar-view
+ .fc
+ .fc-timeGridWeek-view
+ .calendar-day-header-date {
+ width: auto;
+ height: 1.5rem;
+ min-width: 1.5rem;
+ padding: 0 0.125rem;
+ font-size: 0.875rem;
+}
+
+/* Keep surrounding events legible while making the live tool proposal unmistakable. */
+.calendar-tool-preview
+ .calendar-view
+ .fc
+ .fc-event:not(.calendar-event-emphasized) {
+ opacity: 0.62;
+}
+
+.calendar-tool-preview .calendar-view .fc .calendar-event-emphasized {
+ --fc-event-bg-color: color-mix(
+ in oklch,
+ var(--event-calendar-color, var(--color-calendar)) 22%,
+ var(--color-surface)
+ );
+ --fc-event-text-color: color-mix(
+ in oklch,
+ var(--event-calendar-color, var(--color-calendar)) 72%,
+ var(--color-ink)
+ );
+ z-index: 4;
+ border-width: 2px;
+ box-shadow:
+ 0 0 0 1px
+ color-mix(
+ in oklch,
+ var(--event-calendar-color, var(--color-calendar)) 35%,
+ transparent
+ ),
+ 0 3px 8px
+ color-mix(
+ in oklch,
+ var(--event-calendar-color, var(--color-calendar)) 20%,
+ transparent
+ );
+ opacity: 1;
+}
+
+.calendar-tool-preview
+ .calendar-view
+ .fc.fc-direction-ltr
+ .fc-timeGridWeek-view
+ :is(.fc-timegrid-axis, .fc-timegrid-slot-label) {
+ border-right: 1px solid var(--fc-border-color);
+}
+
+.calendar-tool-preview
+ .calendar-view
+ .fc.fc-direction-rtl
+ .fc-timeGridWeek-view
+ :is(.fc-timegrid-axis, .fc-timegrid-slot-label) {
+ border-left: 1px solid var(--fc-border-color);
+}
diff --git a/apps/web/src/lib/core/component/AI/component/tool/calendar/EventPreview.tsx b/apps/web/src/lib/core/component/AI/component/tool/calendar/EventPreview.tsx
new file mode 100644
index 0000000000..396fa56987
--- /dev/null
+++ b/apps/web/src/lib/core/component/AI/component/tool/calendar/EventPreview.tsx
@@ -0,0 +1,430 @@
+import type { CalendarGridHandle } from '@app/features/calendar/components/CalendarGrid';
+import { CalendarGridSkeleton } from '@app/features/calendar/components/CalendarGridSkeleton';
+import type { CalendarEventFormController } from '@app/features/calendar/components/composer/create-calendar-event-form-controller';
+import { useCalendarOccurrenceData } from '@app/features/calendar/hooks/use-calendar-occurrence-data';
+import { useCalendarSources } from '@app/features/calendar/hooks/use-calendar-sources';
+import type { CalendarPeriodView } from '@app/features/calendar/types';
+import { formatLocalDate } from '@app/features/calendar/utils/calendar-date';
+import { getDefaultCalendarTimeFormat } from '@app/features/calendar/utils/time-format';
+import CalendarIcon from '@phosphor/calendar-blank.svg';
+import CaretLeftIcon from '@phosphor/caret-left.svg';
+import CaretRightIcon from '@phosphor/caret-right.svg';
+import { createCalendarOccurrenceQueryRange } from '@queries/calendar/occurrences';
+import { Button, cn } from '@ui';
+import {
+ createEffect,
+ createMemo,
+ createSignal,
+ type JSX,
+ lazy,
+ onCleanup,
+ Show,
+ Suspense,
+ untrack,
+} from 'solid-js';
+import './EventPreview.css';
+import {
+ buildCalendarToolPreviewEvent,
+ type CalendarToolPreviewWindow,
+ calendarToolPreviewStartDate,
+ calendarToolPreviewWindow,
+ expandCalendarToolPreviewEvents,
+} from './event-preview-model';
+
+const CalendarEmbed = lazy(() =>
+ import('@app/features/calendar/components/CalendarEmbed').then((module) => ({
+ default: module.CalendarEmbed,
+ }))
+);
+
+const MAX_EXISTING_PREVIEW_EVENTS = 50;
+const PREVIEW_MONTH_YEAR_FORMAT = new Intl.DateTimeFormat(undefined, {
+ month: 'long',
+ year: 'numeric',
+});
+
+function previewScrollTime(date: Date) {
+ const startMinutes = date.getHours() * 60 + date.getMinutes();
+ const scrollMinutes = Math.max(0, startMinutes - 60);
+ const hours = Math.floor(scrollMinutes / 60);
+ const minutes = scrollMinutes % 60;
+ return `${String(hours).padStart(2, '0')}:${String(minutes).padStart(2, '0')}:00`;
+}
+
+function dayPreviewWindow(date: Date): CalendarToolPreviewWindow {
+ const start = new Date(date.getFullYear(), date.getMonth(), date.getDate());
+ const end = new Date(start);
+ end.setDate(end.getDate() + 1);
+ return { view: 'timeGridDay', start, end };
+}
+
+function previewWindowsEqual(
+ first: CalendarToolPreviewWindow | undefined,
+ second: CalendarToolPreviewWindow | undefined
+) {
+ return (
+ first?.view === second?.view &&
+ first?.start.getTime() === second?.start.getTime() &&
+ first?.end.getTime() === second?.end.getTime() &&
+ first?.dayCount === second?.dayCount
+ );
+}
+
+function CalendarPreviewViewport(props: {
+ grid: CalendarGridHandle;
+ start: string;
+ allDay: boolean;
+ view: CalendarPeriodView;
+ initialView: CalendarPeriodView;
+ dayCount?: number;
+ eventIds: ReadonlySet<string>;
+}) {
+ let visibleDay: string | undefined;
+ let visibleView = props.initialView;
+ let visibleDayCount = props.dayCount;
+ let scrollFrame: number | undefined;
+
+ createEffect(() => {
+ const allDay = props.allDay;
+ const date = calendarToolPreviewStartDate(props.start, allDay);
+ const api = props.grid.api();
+ if (!date || !api) return;
+
+ const day = formatLocalDate(date);
+ const view = props.view;
+ const dayCount = props.dayCount;
+ if (view !== visibleView || dayCount !== visibleDayCount) {
+ visibleView = view;
+ visibleDayCount = dayCount;
+ visibleDay = day;
+ api.changeView(view, date);
+ } else if (day !== visibleDay) {
+ visibleDay = day;
+ api.gotoDate(date);
+ }
+ });
+
+ createEffect(() => {
+ const allDay = props.allDay;
+ const date = calendarToolPreviewStartDate(props.start, allDay);
+ const view = props.view;
+ const eventIds = untrack(() => props.eventIds);
+ const dateInfo = props.grid.dateInfo();
+ const api = props.grid.api();
+ // Re-run after FullCalendar mounts event chips for a new view.
+ props.grid.chipMounts();
+
+ if (scrollFrame !== undefined) cancelAnimationFrame(scrollFrame);
+ scrollFrame = undefined;
+ if (
+ !date ||
+ !dateInfo ||
+ !api ||
+ dateInfo.view.type !== view ||
+ date < dateInfo.start ||
+ date >= dateInfo.end
+ ) {
+ return;
+ }
+
+ if (view === 'dayGridMonth') {
+ scrollFrame = requestAnimationFrame(() => {
+ scrollFrame = undefined;
+ for (const eventId of eventIds) {
+ const element = props.grid.eventElements.get(eventId);
+ if (!element) continue;
+ element.scrollIntoView({ block: 'nearest', inline: 'nearest' });
+ break;
+ }
+ });
+ return;
+ }
+ if (allDay) return;
+
+ scrollFrame = requestAnimationFrame(() => {
+ scrollFrame = undefined;
+ api.scrollToTime(previewScrollTime(date));
+ });
+ });
+
+ onCleanup(() => {
+ if (scrollFrame !== undefined) cancelAnimationFrame(scrollFrame);
+ });
+
+ return null;
+}
+
+interface CalendarToolEventPreviewProps {
+ controller: CalendarEventFormController;
+ eventId: string;
+ timeZone?: string;
+ /** Whether to display the preview date's month and year above the grid. */
+ showPeriodLabel?: boolean;
+ /** Whether to show previous/next controls in week and month views. */
+ showNavigationControls?: boolean;
+ /** Optional controls aligned to the right in place of built-in navigation. */
+ navigationControls?: JSX.Element;
+ class?: string;
+}
+
+/** Live day-grid preview for a deferred calendar event tool call. */
+export function CalendarToolEventPreview(props: CalendarToolEventPreviewProps) {
+ const previewEvent = createMemo(() =>
+ buildCalendarToolPreviewEvent({
+ id: props.eventId,
+ values: props.controller.state(),
+ time: props.controller.eventTime(),
+ recurrenceLines: props.controller.recurrenceLines(),
+ calendar: props.controller.selectedCalendarOption(),
+ timeZone: props.timeZone,
+ })
+ );
+ const editorStart = createMemo(() => props.controller.state().start);
+ const editorAllDay = createMemo(() => props.controller.state().allDay);
+ const previewDay = createMemo(() => {
+ const date = calendarToolPreviewStartDate(editorStart(), editorAllDay());
+ return date ? formatLocalDate(date) : undefined;
+ });
+ const previewDate = createMemo(() => {
+ const day = previewDay();
+ return day ? calendarToolPreviewStartDate(day, true) : undefined;
+ });
+ const previewColor = createMemo(() => previewEvent()?.calendar.color);
+ const previewWindow = createMemo<CalendarToolPreviewWindow | undefined>(
+ () => {
+ const event = previewEvent();
+ if (event) return calendarToolPreviewWindow(event);
+ const date = previewDate();
+ return date ? dayPreviewWindow(date) : undefined;
+ },
+ undefined,
+ { equals: previewWindowsEqual }
+ );
+ const previewView = () => previewWindow()?.view ?? 'timeGridDay';
+ const previewDayCount = () => previewWindow()?.dayCount;
+ const previewLayoutKey = () => previewDayCount() ?? 'standard';
+ const [displayedWindow, setDisplayedWindow] =
+ createSignal<CalendarToolPreviewWindow>();
+ const [displayedDate, setDisplayedDate] = createSignal<Date>();
+ let activeGrid: CalendarGridHandle | undefined;
+ const visibleWindow = createMemo(() => {
+ const displayed = displayedWindow();
+ return displayed?.view === previewView() &&
+ displayed.dayCount === previewDayCount()
+ ? displayed
+ : previewWindow();
+ });
+ const range = createMemo(() => {
+ const window = visibleWindow();
+ return window
+ ? createCalendarOccurrenceQueryRange(window.start, window.end)
+ : undefined;
+ });
+ const { sourceById } = useCalendarSources();
+ const occurrenceData = useCalendarOccurrenceData({ range, sourceById });
+ const availableExistingEvents = createMemo(() =>
+ occurrenceData.occurrencesQuery.isPlaceholderData
+ ? []
+ : occurrenceData.visibleEvents()
+ );
+ const existingEvents = createMemo(() =>
+ availableExistingEvents().slice(0, MAX_EXISTING_PREVIEW_EVENTS)
+ );
+ const previewEvents = createMemo(() => {
+ const event = previewEvent();
+ const window = visibleWindow();
+ return event && window
+ ? expandCalendarToolPreviewEvents(event, window)
+ : [];
+ });
+ const events = createMemo(() => [...existingEvents(), ...previewEvents()]);
+ const emphasizedEventIds = createMemo(
+ () => new Set(previewEvents().map((event) => event.id))
+ );
+ const eventsById = createMemo(
+ () => new Map(events().map((event) => [event.id, event]))
+ );
+ const showBuiltInNavigation = () =>
+ props.showNavigationControls === true && previewView() !== 'timeGridDay';
+ const showPreviewHeader = () =>
+ props.showPeriodLabel === true ||
+ showBuiltInNavigation() ||
+ props.navigationControls !== undefined;
+ const periodDate = () => {
+ const displayed = displayedWindow();
+ return displayed?.view === previewView() &&
+ displayed.dayCount === previewDayCount()
+ ? (displayedDate() ?? previewDate())
+ : previewDate();
+ };
+ const isEventStartVisible = () => {
+ const date = calendarToolPreviewStartDate(editorStart(), editorAllDay());
+ const displayed = displayedWindow();
+ return (
+ !date || !displayed || (date >= displayed.start && date < displayed.end)
+ );
+ };
+ const navigate = (direction: 'previous' | 'next') => {
+ const api = activeGrid?.api();
+ if (!api) return;
+ if (direction === 'previous') api.prev();
+ else api.next();
+ };
+ const goToEvent = () => {
+ const date = calendarToolPreviewStartDate(editorStart(), editorAllDay());
+ if (date) activeGrid?.api()?.gotoDate(date);
+ };
+
+ return (
+ <div
+ role="region"
+ aria-label="Calendar event preview"
+ class={cn(
+ 'calendar-tool-preview relative flex min-h-0 min-w-0 flex-col overflow-hidden rounded-xl border border-edge-muted bg-surface shadow-sm',
+ props.class
+ )}
+ >
+ <Show when={showPreviewHeader()}>
+ <div class="flex shrink-0 items-center border-b border-edge-muted px-3 py-2">
+ <Show when={props.showPeriodLabel ? periodDate() : undefined}>
+ {(date) => (
+ <div class="text-sm font-semibold text-ink">
+ {PREVIEW_MONTH_YEAR_FORMAT.format(date())}
+ </div>
+ )}
+ </Show>
+ <Show
+ when={
+ props.navigationControls !== undefined || showBuiltInNavigation()
+ }
+ >
+ <div class="ml-auto flex shrink-0 items-center gap-1">
+ <Show
+ when={props.navigationControls !== undefined}
+ fallback={
+ <>
+ <Show when={!isEventStartVisible()}>
+ <Button
+ variant="ghost"
+ size="sm"
+ class="rounded-lg px-2"
+ onClick={goToEvent}
+ >
+ <CalendarIcon class="size-3.5" />
+ Go to event
+ </Button>
+ </Show>
+ <Button
+ variant="ghost"
+ size="icon-sm"
+ class="rounded-lg"
+ label={`Previous ${previewView() === 'dayGridMonth' ? 'month' : 'week'}`}
+ onClick={() => navigate('previous')}
+ >
+ <CaretLeftIcon class="size-4" />
+ </Button>
+ <Button
+ variant="ghost"
+ size="icon-sm"
+ class="rounded-lg"
+ label={`Next ${previewView() === 'dayGridMonth' ? 'month' : 'week'}`}
+ onClick={() => navigate('next')}
+ >
+ <CaretRightIcon class="size-4" />
+ </Button>
+ </>
+ }
+ >
+ {props.navigationControls}
+ </Show>
+ </div>
+ </Show>
+ </div>
+ </Show>
+ <div class="relative min-h-0 flex-1">
+ <Suspense
+ fallback={
+ <CalendarGridSkeleton
+ showDayHeader={false}
+ showAllDaySlot={false}
+ />
+ }
+ >
+ <Show when={previewLayoutKey()} keyed>
+ {(layoutKey) => {
+ // FullCalendar cannot safely remove dayCount in place. Remount only
+ // when entering, leaving, or resizing an exact multi-day layout.
+ const dayCount =
+ typeof layoutKey === 'number' ? layoutKey : undefined;
+ const initialView = previewView();
+ return (
+ <CalendarEmbed
+ initialDate={previewDate() ?? new Date()}
+ events={events()}
+ eventsById={eventsById()}
+ emphasizedEventIds={emphasizedEventIds()}
+ settings={{
+ initialView,
+ dayCount,
+ showDayHeaders: previewView() !== 'timeGridDay',
+ useNarrowDayHeaders: false,
+ collapseEmptyAllDaySlot: true,
+ showWeekends: true,
+ weekStartsOn: 0,
+ timeFormat: getDefaultCalendarTimeFormat(),
+ }}
+ selection={{
+ color: previewColor() ?? 'var(--color-accent)',
+ }}
+ onDatesSet={(info) => {
+ setDisplayedWindow({
+ view: info.view.type as CalendarPeriodView,
+ start: info.start,
+ end: info.end,
+ dayCount,
+ });
+ setDisplayedDate(info.view.calendar.getDate());
+ }}
+ >
+ {(grid) => {
+ activeGrid = grid;
+ return (
+ <CalendarPreviewViewport
+ grid={grid}
+ start={editorStart()}
+ allDay={editorAllDay()}
+ view={previewView()}
+ initialView={initialView}
+ dayCount={dayCount}
+ eventIds={emphasizedEventIds()}
+ />
+ );
+ }}
+ </CalendarEmbed>
+ );
+ }}
+ </Show>
+ <Show when={previewEvent() === undefined}>
+ <div class="pointer-events-none absolute inset-x-2 top-2 rounded-md border border-edge-muted bg-surface px-2 py-1 text-center text-xs text-ink-muted shadow-sm">
+ Enter an end time after the start time to preview this event.
+ </div>
+ </Show>
+ <Show when={occurrenceData.isLoading()}>
+ <div
+ role="status"
+ aria-label="Loading calendar events"
+ class="pointer-events-none absolute right-2 bottom-2 rounded-md border border-edge-muted bg-surface px-2 py-1 text-xs text-ink-muted shadow-sm"
+ >
+ Loading events…
+ </div>
+ </Show>
+ <Show when={occurrenceData.occurrencesQuery.isError}>
+ <div class="absolute inset-x-2 bottom-2 rounded-md border border-edge-muted bg-surface px-2 py-1 text-center text-xs text-ink-muted shadow-sm">
+ Other calendar events couldn’t be loaded.
+ </div>
+ </Show>
+ </Suspense>
+ </div>
+ </div>
+ );
+}
diff --git a/apps/web/src/lib/core/component/AI/component/tool/calendar/event-preview-model.ts b/apps/web/src/lib/core/component/AI/component/tool/calendar/event-preview-model.ts
new file mode 100644
index 0000000000..a4f14f3e56
--- /dev/null
+++ b/apps/web/src/lib/core/component/AI/component/tool/calendar/event-preview-model.ts
@@ -0,0 +1,473 @@
+import type {
+ EventEditorCalendarOption,
+ EventEditorInitialValues,
+} from '@app/features/calendar/components/composer/event-form-model';
+import {
+ type CalendarEvent,
+ type CalendarPeriodView,
+ DEFAULT_CALENDAR_SOURCE,
+} from '@app/features/calendar/types';
+import {
+ formatLocalDate,
+ parseLocalDate,
+} from '@app/features/calendar/utils/calendar-date';
+import {
+ parseRecurrenceConfig,
+ parseRecurrenceLines,
+ type RecurrenceConfig,
+ WEEKDAY_CODES,
+} from '@app/features/calendar/utils/recurrence';
+import { TZDateMini } from '@date-fns/tz';
+import type { EventTime } from '@service-email/generated/schemas/eventTime';
+
+interface CalendarToolPreviewEventInput {
+ id: string;
+ values: EventEditorInitialValues;
+ time: EventTime | undefined;
+ recurrenceLines: string[] | undefined;
+ calendar: EventEditorCalendarOption | undefined;
+ timeZone?: string;
+}
+
+/** Projects editable calendar-tool values into one query-free preview event. */
+export function buildCalendarToolPreviewEvent(
+ input: CalendarToolPreviewEventInput
+): CalendarEvent | undefined {
+ if (!input.time) return undefined;
+
+ const calendar = input.calendar
+ ? {
+ id: input.calendar.id,
+ name: input.calendar.label,
+ color: input.calendar.color,
+ }
+ : DEFAULT_CALENDAR_SOURCE;
+ const range =
+ input.time.kind === 'timed'
+ ? {
+ allDay: false,
+ start: input.time.startsAt,
+ end: input.time.endsAt,
+ timeZone: input.timeZone ?? input.time.timeZone ?? undefined,
+ }
+ : {
+ allDay: true,
+ start: input.time.startDate,
+ end: input.time.endDate,
+ timeZone: undefined,
+ };
+
+ return {
+ ...range,
+ // FullCalendar only reapplies the event color when an event remounts.
+ id: JSON.stringify([input.id, calendar.id, calendar.color]),
+ eventId: input.id,
+ occurrenceKey: input.id,
+ isCancelled: false,
+ isReadOnly: true,
+ attendees: [],
+ recurrenceLines: input.recurrenceLines ?? input.values.recurrenceLines,
+ calendarId: input.calendar?.id ?? input.values.calendarId,
+ title: input.values.title.trim() || 'New event',
+ calendar,
+ location: input.values.location || undefined,
+ description: input.values.description || undefined,
+ };
+}
+
+/** Parses a preview start without shifting local all-day values. */
+export function calendarToolPreviewStartDate(start: string, allDay: boolean) {
+ const date = allDay ? parseLocalDate(start) : new Date(start);
+ return date && !Number.isNaN(date.getTime()) ? date : undefined;
+}
+
+/** Returns the preview's local display date without shifting all-day values. */
+export function calendarToolPreviewDate(event: CalendarEvent) {
+ return calendarToolPreviewStartDate(event.start, event.allDay);
+}
+
+/** Visible period selected for a calendar-tool preview. */
+export interface CalendarToolPreviewWindow {
+ view: CalendarPeriodView;
+ start: Date;
+ end: Date;
+ /** Consecutive days shown when previewing one non-recurring multi-day event. */
+ dayCount?: number;
+}
+
+function calendarDate(
+ year: number,
+ month: number,
+ day: number,
+ hours = 0,
+ minutes = 0,
+ seconds = 0,
+ milliseconds = 0,
+ timeZone?: string
+) {
+ return timeZone
+ ? new TZDateMini(
+ year,
+ month,
+ day,
+ hours,
+ minutes,
+ seconds,
+ milliseconds,
+ timeZone
+ )
+ : new Date(year, month, day, hours, minutes, seconds, milliseconds);
+}
+
+function startOfLocalDay(date: Date, timeZone?: string) {
+ return calendarDate(
+ date.getFullYear(),
+ date.getMonth(),
+ date.getDate(),
+ 0,
+ 0,
+ 0,
+ 0,
+ timeZone
+ );
+}
+
+function addLocalDays(date: Date, days: number, timeZone?: string) {
+ return calendarDate(
+ date.getFullYear(),
+ date.getMonth(),
+ date.getDate() + days,
+ 0,
+ 0,
+ 0,
+ 0,
+ timeZone
+ );
+}
+
+function localDayNumber(date: Date) {
+ return Date.UTC(date.getFullYear(), date.getMonth(), date.getDate());
+}
+
+function occupiedEndDate(event: CalendarEvent) {
+ const end = calendarToolPreviewStartDate(event.end, event.allDay);
+ return end ? new Date(end.getTime() - 1) : undefined;
+}
+
+/** Chooses a bounded day, week, or month window for a proposed event. */
+export function calendarToolPreviewWindow(
+ event: CalendarEvent
+): CalendarToolPreviewWindow | undefined {
+ const start = calendarToolPreviewDate(event);
+ const occupiedEnd = occupiedEndDate(event);
+ if (!start || !occupiedEnd) return undefined;
+
+ const recurrenceFrequency = parseRecurrenceLines(event.recurrenceLines).rule
+ ?.frequency;
+ const daySpan = Math.floor(
+ (localDayNumber(occupiedEnd) - localDayNumber(start)) /
+ (24 * 60 * 60 * 1000)
+ );
+ const view: CalendarPeriodView = recurrenceFrequency
+ ? recurrenceFrequency === 'DAILY' || recurrenceFrequency === 'WEEKLY'
+ ? 'timeGridWeek'
+ : 'dayGridMonth'
+ : event.recurrenceLines.length > 0 || daySpan >= 7
+ ? 'dayGridMonth'
+ : daySpan > 0
+ ? 'timeGridWeek'
+ : 'timeGridDay';
+
+ if (view === 'dayGridMonth') {
+ const monthStart = new Date(start.getFullYear(), start.getMonth(), 1);
+ const monthEnd = new Date(start.getFullYear(), start.getMonth() + 1, 0);
+ return {
+ view,
+ start: addLocalDays(monthStart, -monthStart.getDay()),
+ end: addLocalDays(monthEnd, 7 - monthEnd.getDay()),
+ };
+ }
+ if (view === 'timeGridWeek') {
+ if (!recurrenceFrequency && daySpan > 0) {
+ const rangeStart = startOfLocalDay(start);
+ const dayCount = daySpan + 1;
+ return {
+ view,
+ start: rangeStart,
+ end: addLocalDays(rangeStart, dayCount),
+ dayCount,
+ };
+ }
+ const weekStart = addLocalDays(startOfLocalDay(start), -start.getDay());
+ return { view, start: weekStart, end: addLocalDays(weekStart, 7) };
+ }
+
+ const dayStart = startOfLocalDay(start);
+ return { view, start: dayStart, end: addLocalDays(dayStart, 1) };
+}
+
+function sameLocalDay(first: Date, second: Date) {
+ return formatLocalDate(first) === formatLocalDate(second);
+}
+
+function monthDifference(first: Date, second: Date) {
+ return (
+ (second.getFullYear() - first.getFullYear()) * 12 +
+ second.getMonth() -
+ first.getMonth()
+ );
+}
+
+function isMonthlyWeekday(
+ date: Date,
+ monthlyByDay: NonNullable<RecurrenceConfig['monthlyByDay']>,
+ timeZone?: string
+) {
+ const weekday = WEEKDAY_CODES[date.getDay()];
+ if (weekday !== monthlyByDay.weekday) return false;
+ if (monthlyByDay.ordinal < 0) {
+ const daysFromEnd =
+ calendarDate(
+ date.getFullYear(),
+ date.getMonth() + 1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ timeZone
+ ).getDate() - date.getDate();
+ return -(Math.floor(daysFromEnd / 7) + 1) === monthlyByDay.ordinal;
+ }
+ return Math.ceil(date.getDate() / 7) === monthlyByDay.ordinal;
+}
+
+function recurrenceMatches(
+ date: Date,
+ start: Date,
+ config: RecurrenceConfig,
+ weekStartsOn: number,
+ timeZone?: string
+) {
+ if (sameLocalDay(date, start)) return true;
+ const dayDifference = Math.floor(
+ (localDayNumber(date) - localDayNumber(start)) / (24 * 60 * 60 * 1000)
+ );
+
+ if (config.frequency === 'DAILY') {
+ return dayDifference % config.interval === 0;
+ }
+ if (config.frequency === 'WEEKLY') {
+ const startOffset = (start.getDay() - weekStartsOn + 7) % 7;
+ const dateOffset = (date.getDay() - weekStartsOn + 7) % 7;
+ const startWeek = addLocalDays(
+ startOfLocalDay(start, timeZone),
+ -startOffset,
+ timeZone
+ );
+ const dateWeek = addLocalDays(
+ startOfLocalDay(date, timeZone),
+ -dateOffset,
+ timeZone
+ );
+ const weekDifference = Math.floor(
+ (localDayNumber(dateWeek) - localDayNumber(startWeek)) /
+ (7 * 24 * 60 * 60 * 1000)
+ );
+ const weekdays =
+ config.byDay.length > 0 ? config.byDay : [WEEKDAY_CODES[start.getDay()]];
+ return (
+ weekDifference % config.interval === 0 &&
+ weekdays.includes(WEEKDAY_CODES[date.getDay()])
+ );
+ }
+ if (config.frequency === 'MONTHLY') {
+ const months = monthDifference(start, date);
+ if (months % config.interval !== 0) return false;
+ return config.monthlyByDay
+ ? isMonthlyWeekday(date, config.monthlyByDay, timeZone)
+ : date.getDate() === start.getDate();
+ }
+
+ return (
+ (date.getFullYear() - start.getFullYear()) % config.interval === 0 &&
+ date.getMonth() === start.getMonth() &&
+ date.getDate() === start.getDate()
+ );
+}
+
+function recurrenceRuleField(rule: string, name: string) {
+ const fields = rule.slice(rule.indexOf(':') + 1).split(';');
+ const prefix = `${name.toUpperCase()}=`;
+ return fields
+ .map((field) => field.trim())
+ .find((field) => field.toUpperCase().startsWith(prefix))
+ ?.slice(prefix.length);
+}
+
+function recurrenceWeekStartsOn(rule: string) {
+ const code = recurrenceRuleField(rule, 'WKST')?.toUpperCase();
+ const index = code
+ ? WEEKDAY_CODES.indexOf(code as (typeof WEEKDAY_CODES)[number])
+ : -1;
+ return index >= 0 ? index : 1;
+}
+
+function recurrenceUntil(
+ rule: string,
+ allDay: boolean,
+ timeZone?: string
+): { date?: string; instant?: Date } | undefined {
+ const value = recurrenceRuleField(rule, 'UNTIL');
+ if (!value) return undefined;
+ const match = /^(\d{4})(\d{2})(\d{2})(?:T(\d{2})(\d{2})(\d{2})(Z)?)?$/.exec(
+ value
+ );
+ if (!match) return undefined;
+ if (allDay || match[4] === undefined) {
+ return { date: `${match[1]}-${match[2]}-${match[3]}` };
+ }
+
+ const parts = match.slice(1, 7).map(Number);
+ const [year, month, day, hours, minutes, seconds] = parts;
+ if (
+ year === undefined ||
+ month === undefined ||
+ day === undefined ||
+ hours === undefined ||
+ minutes === undefined ||
+ seconds === undefined
+ ) {
+ return undefined;
+ }
+ return {
+ instant: match[7]
+ ? new Date(Date.UTC(year, month - 1, day, hours, minutes, seconds))
+ : calendarDate(
+ year,
+ month - 1,
+ day,
+ hours,
+ minutes,
+ seconds,
+ 0,
+ timeZone
+ ),
+ };
+}
+
+function occurrenceEvent(
+ event: CalendarEvent,
+ occurrenceStart: Date,
+ duration: number,
+ index: number
+): CalendarEvent {
+ const start = event.allDay
+ ? formatLocalDate(occurrenceStart)
+ : occurrenceStart.toISOString();
+ const occurrenceEnd = event.allDay
+ ? addLocalDays(occurrenceStart, duration)
+ : new Date(occurrenceStart.getTime() + duration);
+ const end = event.allDay
+ ? formatLocalDate(occurrenceEnd)
+ : occurrenceEnd.toISOString();
+
+ return {
+ ...event,
+ id: JSON.stringify([event.id, start]),
+ occurrenceKey: start,
+ start,
+ end,
+ recurrenceId: `${event.eventId}:${index}`,
+ };
+}
+
+/** Materializes proposed recurrence instances inside the selected preview. */
+export function expandCalendarToolPreviewEvents(
+ event: CalendarEvent,
+ window: CalendarToolPreviewWindow,
+ limit = 50
+): CalendarEvent[] {
+ const recurrenceRule = event.recurrenceLines.find((line) =>
+ line.trimStart().toUpperCase().startsWith('RRULE:')
+ );
+ const config = parseRecurrenceConfig(event.recurrenceLines, event.timeZone);
+ const displayStart = calendarToolPreviewDate(event);
+ const end = calendarToolPreviewStartDate(event.end, event.allDay);
+ const timeZone = event.allDay ? undefined : event.timeZone;
+ const start =
+ displayStart && timeZone
+ ? TZDateMini.tz(timeZone, displayStart)
+ : displayStart;
+ if (!recurrenceRule || !config || !start || !end || limit <= 0) {
+ return [event];
+ }
+ const weekStartsOn = recurrenceWeekStartsOn(recurrenceRule);
+ const until = recurrenceUntil(recurrenceRule, event.allDay, timeZone);
+
+ const duration = event.allDay
+ ? Math.max(
+ 1,
+ Math.round(
+ (localDayNumber(end) - localDayNumber(start)) / (24 * 60 * 60 * 1000)
+ )
+ )
+ : end.getTime() - start.getTime();
+ if (duration <= 0) return [event];
+
+ const occurrences: CalendarEvent[] = [];
+ let cursor = startOfLocalDay(start, timeZone);
+ let ruleOccurrenceIndex = 0;
+ let renderedIndex = 0;
+ let ruleEnded = false;
+ const cursorEnd = new Date(window.end.getTime() + 24 * 60 * 60 * 1000);
+ while (cursor < cursorEnd && occurrences.length < limit) {
+ const date = formatLocalDate(cursor);
+ const occurrenceStart = event.allDay
+ ? cursor
+ : calendarDate(
+ cursor.getFullYear(),
+ cursor.getMonth(),
+ cursor.getDate(),
+ start.getHours(),
+ start.getMinutes(),
+ start.getSeconds(),
+ start.getMilliseconds(),
+ timeZone
+ );
+ let matchesRule =
+ !ruleEnded &&
+ recurrenceMatches(cursor, start, config, weekStartsOn, timeZone);
+ if (matchesRule) {
+ ruleOccurrenceIndex += 1;
+ const exceedsCount =
+ config.ends.kind === 'after' && ruleOccurrenceIndex > config.ends.count;
+ const exceedsDateUntil =
+ (until?.date !== undefined && date > until.date) ||
+ (until === undefined &&
+ config.ends.kind === 'on' &&
+ date > config.ends.date);
+ const exceedsInstantUntil =
+ until?.instant !== undefined && occurrenceStart > until.instant;
+ if (exceedsCount || exceedsDateUntil || exceedsInstantUntil) {
+ matchesRule = false;
+ ruleEnded = true;
+ }
+ }
+
+ if (matchesRule) {
+ const occurrenceEnd = event.allDay
+ ? addLocalDays(occurrenceStart, duration)
+ : new Date(occurrenceStart.getTime() + duration);
+ if (occurrenceStart < window.end && occurrenceEnd > window.start) {
+ renderedIndex += 1;
+ occurrences.push(
+ occurrenceEvent(event, occurrenceStart, duration, renderedIndex)
+ );
+ }
+ }
+ cursor = addLocalDays(cursor, 1, timeZone);
+ }
+
+ return occurrences.length > 0 ? occurrences : [event];
+}
diff --git a/apps/web/src/lib/fullcalendar-solid/FullCalendar.tsx b/apps/web/src/lib/fullcalendar-solid/FullCalendar.tsx
index 1678b9d902..325ed86e69 100644
--- a/apps/web/src/lib/fullcalendar-solid/FullCalendar.tsx
+++ b/apps/web/src/lib/fullcalendar-solid/FullCalendar.tsx
@@ -19,6 +19,7 @@ import {
type Component,
createContext,
createEffect,
+ createMemo,
createSignal,
getOwner,
type JSX,
@@ -269,6 +270,8 @@ function createFullCalendarController(
SolidContentOptionName,
ContentRegistration
>();
+ const [listenForContentRegistrationChange, notifyContentRegistrationChange] =
+ createSignal<void>(undefined, { equals: false });
const requestResize = () => {
if (isUnmounting() || !calendar()) return;
@@ -290,13 +293,15 @@ function createFullCalendarController(
customRenderingManager.handle(rendering);
};
- const buildOptions = () =>
- buildCalendarOptions(
+ const buildOptions = createMemo(() => {
+ listenForContentRegistrationChange();
+ return buildCalendarOptions(
getOptions(),
contentRegistrations,
handleCustomRendering,
setDateInfo
);
+ });
const resetOptions = () => {
const calendarInstance = calendar();
@@ -361,6 +366,7 @@ function createFullCalendarController(
token: Symbol(optionName),
};
contentRegistrations.set(optionName, registration);
+ notifyContentRegistrationChange();
resetOptions();
return {
@@ -372,6 +378,7 @@ function createFullCalendarController(
}
contentRegistrations.delete(optionName);
+ notifyContentRegistrationChange();
resetOptions();
},
};