Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.
TypeScript agentaiai-agentsall-in-onecrmcrm-systememaillinearmcpmessagingnotesnotionofficerustslackslack-alternativestartupstartup-toolstypescriptworkspace
import {
CalendarGrid,
type CalendarGridHandle,
} from '@app/features/calendar/components/CalendarGrid';
import {
type CalendarPageId,
useCalendarPager,
} from '@app/features/calendar/components/CalendarPagerContext';
import { useCalendarView } from '@app/features/calendar/components/CalendarViewContext';
import { calendarSelectionToEditorInitialValues } from '@app/features/calendar/components/composer/event-form-model';
import {
type CalendarOccurrenceData,
useCalendarOccurrenceData,
} from '@app/features/calendar/hooks/use-calendar-occurrence-data';
import { useCalendarTimeGridHoverIndicator } from '@app/features/calendar/hooks/use-calendar-time-grid-hover-indicator';
import { useTeamOooEvents } from '@app/features/calendar/hooks/use-team-ooo';
import {
type CalendarEvent,
DEFAULT_CALENDAR_SOURCE,
} from '@app/features/calendar/types';
import { isCalendarRangeSupported } from '@app/features/calendar/utils/calendar-supported-range';
import { GUEST_EDITS_RESTRICTED } from '@app/features/calendar/utils/event-guest-editing';
import {
type CalendarEventTimeChange,
calendarEventTimeFromFullCalendar,
canEditCalendarEventTime,
} from '@app/features/calendar/utils/event-interaction';
import { consumeSuppressedCalendarDateSelection } from '@app/features/calendar/utils/open-event-outside-press';
import {
scrollEventChipIntoView,
timeGridScroller,
} from '@app/features/calendar/utils/time-grid-scroller';
import { mergeCalendarOverlays } from '@app/features/calendar-team/core/merge';
import { useOpenEventComposer } from '@app/features/calendar-view/components/use-open-event-composer';
import { useQuickCallsFlag } from '@app/features/meetings/use-quick-calls-flag';
import { toast } from '@core/component/Toast/Toast';
import { ScrollIndicators } from '@core/component/VerticalScrollIndicators';
import { isMobile } from '@core/mobile/isMobile';
import { fireAndForget } from '@core/util/fireAndForget';
import type { DateSelectArg, DatesSetArg } from '@fullcalendar/core';
import { useVisibleCalendarsQuery } from '@queries/calendar/calendars';
import {
isGuestEditRefused,
useUpdateCalendarEventMutation,
} from '@queries/calendar/mutations';
import {
type CalendarOccurrenceQueryRange,
createCalendarOccurrenceQueryRange,
} from '@queries/calendar/occurrences';
import { Button } from '@ui';
import {
type Accessor,
createDeferred,
createEffect,
createMemo,
createSignal,
on,
onCleanup,
onMount,
Show,
untrack,
} from 'solid-js';
import { Portal } from 'solid-js/web';
import {
calendarFocusTargetId,
useCalendarFocus,
} from '../calendar-focus-target';
import { CalendarLoadingSkeleton } from './CalendarLoadingSkeleton';
interface CalendarScrollTarget {
scrollElement: HTMLElement;
fadeContainer: HTMLElement;
}
function CalendarScrollIndicators(props: {
calendarElement: Accessor<HTMLElement | undefined>;
}) {
const [target, setTarget] = createSignal<CalendarScrollTarget>();
createEffect(
on(props.calendarElement, (element) => {
if (!element) {
setTarget(undefined);
return;
}
let updateFrame: number | undefined;
const updateScrollElements = () => {
const scrollElement = timeGridScroller(element);
const fadeContainer = scrollElement?.parentElement;
setTarget((current) => {
if (!scrollElement || !fadeContainer) return undefined;
return current?.scrollElement === scrollElement &&
current.fadeContainer === fadeContainer
? current
: { scrollElement, fadeContainer };
});
};
const scheduleScrollElementUpdate = () => {
if (updateFrame !== undefined) cancelAnimationFrame(updateFrame);
updateFrame = requestAnimationFrame(() => {
updateFrame = undefined;
updateScrollElements();
});
};
const mutationObserver = new MutationObserver(
scheduleScrollElementUpdate
);
mutationObserver.observe(element, { childList: true, subtree: true });
scheduleScrollElementUpdate();
onCleanup(() => {
mutationObserver.disconnect();
if (updateFrame !== undefined) cancelAnimationFrame(updateFrame);
});
})
);
return (
<Show keyed when={target()}>
{(scrollTarget) => (
<Portal
mount={scrollTarget.fadeContainer}
ref={(container) => {
container.style.display = 'contents';
}}
>
<ScrollIndicators
scrollRef={() => scrollTarget.scrollElement}
appearance="gradient"
gradientColor="panel"
class="h-6"
/>
</Portal>
)}
</Show>
);
}
function CalendarPageDataStatus(props: {
data: CalendarOccurrenceData;
changingView: boolean;
grid: CalendarGridHandle;
onLoadingBlockingChange: (blocking: boolean) => void;
}) {
const isRangeUnavailable = createMemo(() => {
const range = props.data.range();
return range !== undefined && !isCalendarRangeSupported(range);
});
const showLoading = () =>
!isRangeUnavailable() &&
!props.data.occurrencesQuery.isError &&
(props.changingView || props.data.isLoading());
return (
<>
<CalendarLoadingSkeleton
element={props.grid.element()}
dateInfo={props.grid.dateInfo()}
loading={showLoading()}
disabled={isRangeUnavailable() || props.data.occurrencesQuery.isError}
onBlockingChange={props.onLoadingBlockingChange}
/>
<Show when={!isRangeUnavailable() && props.data.occurrencesQuery.isError}>
<div
class="absolute inset-0 z-20 flex items-center justify-center rounded-xl bg-surface/90 p-6 text-center"
aria-live="polite"
>
<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
aria-label="Retry loading calendar"
tooltip="Retry loading calendar"
variant="primary"
size="sm"
onClick={() =>
fireAndForget(
props.data.occurrencesQuery.refetch(),
'calendar-view'
)
}
>
Retry
</Button>
</div>
</div>
</Show>
</>
);
}
/** One independently rendered and queried FullCalendar page. */
export function Page(props: {
id: CalendarPageId;
initialDate: Date;
useNarrowDayHeaders: boolean;
}) {
const pager = useCalendarPager();
const calendarView = useCalendarView();
const [loadingDecorationBlocking, setLoadingDecorationBlocking] =
createSignal(false);
// Keep the settings object independent of route-period changes. Otherwise
// reading any grid setting also subscribes FullCalendar to the whole object.
const initialView = untrack(() => calendarView.displaySettings.periodView);
const openEventComposer = useOpenEventComposer();
const quickCalls = useQuickCallsFlag();
const calendarsQuery = useVisibleCalendarsQuery();
const firstWritableCalendar = createMemo(() =>
calendarsQuery.isSuccess
? calendarsQuery.data?.find((calendar) => calendar.isWritable)
: undefined
);
const [range, setRange] = createSignal<CalendarOccurrenceQueryRange>();
const [selectionColor, setSelectionColor] = createSignal<string>();
const effectiveSelectionColor = () =>
selectionColor() ??
firstWritableCalendar()?.color ??
DEFAULT_CALENDAR_SOURCE.color;
const isActive = () => pager.isActive(props.id);
const useNarrowWeekdayHeaders = () =>
props.useNarrowDayHeaders && !isMobile();
// Let the checkbox update before remapping occurrences and redrawing the grid.
// Each page has its own deferred update, so the scheduler can yield between
// the three FullCalendar instances.
const renderedHiddenSourceIds = createDeferred(calendarView.hiddenSourceIds);
const isRenderedSourceVisible = (sourceId: string) =>
!renderedHiddenSourceIds().has(sourceId);
const data = useCalendarOccurrenceData({
range,
sourceById: calendarView.sourceById,
sourcesReady: calendarView.sourcesReady,
isSourceVisible: isRenderedSourceVisible,
queryOptions: () => ({
pollWhileSyncing: isActive(),
refetchOnWindowFocus: isActive(),
}),
});
const teamOoo = useTeamOooEvents({
range,
isSourceVisible: isRenderedSourceVisible,
refetchOnWindowFocus: isActive,
});
const visibleEvents = createMemo(() =>
mergeCalendarOverlays(data.visibleEvents(), teamOoo.events())
);
const eventsById = createMemo(
() => new Map(visibleEvents().map((event) => [event.id, event]))
);
const updateEventTime = useUpdateCalendarEventMutation();
const handleSelect = (selection: DateSelectArg) => {
if (!isActive()) return;
// The press that closes open event details also hits the grid. FullCalendar
// selects on mouseup, after the details have already closed, so that
// gesture must not open a new event.
if (consumeSuppressedCalendarDateSelection()) {
selection.view.calendar.unselect();
return;
}
const calendar = firstWritableCalendar();
setSelectionColor(calendar?.color ?? DEFAULT_CALENDAR_SOURCE.color);
openEventComposer({
initialValues: {
...calendarSelectionToEditorInitialValues(
selection,
quickCalls().enabled && !quickCalls().loading
),
...(calendar ? { calendarId: calendar.id } : {}),
},
onCalendarChange: (_calendarId: string, color: string) =>
setSelectionColor(color),
onClose: () => {
selection.view.calendar.unselect();
setSelectionColor(undefined);
},
});
};
const handleDatesSet = ({ end, start }: DatesSetArg) => {
const nextRange = createCalendarOccurrenceQueryRange(start, end);
const currentRange = range();
if (
currentRange?.start === nextRange.start &&
currentRange.end === nextRange.end &&
currentRange.startDate === nextRange.startDate &&
currentRange.endDate === nextRange.endDate
) {
return;
}
setRange(nextRange);
};
const handleEventTimeChange = (
change: CalendarEventTimeChange,
event: CalendarEvent | undefined
) => {
if (
!isActive() ||
updateEventTime.isPending ||
!event ||
!canEditCalendarEventTime(event)
) {
change.revert();
return;
}
const time = calendarEventTimeFromFullCalendar(change.event, event);
if (!time) {
change.revert();
return;
}
updateEventTime.mutate(
{ eventId: event.eventId, calendarId: event.calendarId, patch: { time } },
{
onError: (error) => {
change.revert();
if (isGuestEditRefused(error)) {
toast.failure(GUEST_EDITS_RESTRICTED);
return;
}
toast.failure('Failed to update event', {
subtext: error.message,
});
},
}
);
};
return (
<div
class="relative size-full min-w-0 min-h-0"
aria-busy={
data.isLoading() ||
(isActive() && pager.isChangingView()) ||
loadingDecorationBlocking()
}
>
<CalendarGrid
initialDate={props.initialDate}
events={visibleEvents()}
eventsById={eventsById()}
settings={{
initialView,
showWeekends: calendarView.displaySettings.showWeekends,
weekStartsOn: calendarView.displaySettings.weekStartsOn,
timeFormat: calendarView.displaySettings.timeFormat,
useNarrowDayHeaders: useNarrowWeekdayHeaders(),
useNarrowEventContent: props.useNarrowDayHeaders,
}}
selection={{
color: effectiveSelectionColor(),
eventId: isActive() ? calendarView.selectedEvent()?.id : undefined,
onDateSelect: isMobile() ? undefined : handleSelect,
onEventSelect: (event, element) => {
if (isActive()) calendarView.selectEvent(event, element);
},
onSelectedEventMount: (event, element) => {
if (isActive()) calendarView.reanchorSelectedEvent(event, element);
},
}}
eventTimeChangePending={updateEventTime.isPending}
onDatesSet={handleDatesSet}
onEventTimeChange={handleEventTimeChange}
>
{(grid) => (
<CalendarPageHost
id={props.id}
data={data}
teamEvents={teamOoo.events}
eventsById={eventsById}
grid={grid}
onLoadingBlockingChange={setLoadingDecorationBlocking}
/>
)}
</CalendarGrid>
</div>
);
}
function CalendarPageHost(props: {
id: CalendarPageId;
data: CalendarOccurrenceData;
/** Teammate out-of-office events rendered on this page. */
teamEvents: Accessor<CalendarEvent[]>;
/** Occurrence events merged with the team out-of-office overlay. */
eventsById: Accessor<Map<string, CalendarEvent>>;
grid: CalendarGridHandle;
onLoadingBlockingChange: (blocking: boolean) => void;
}) {
const pager = useCalendarPager();
const calendarView = useCalendarView();
const calendarFocus = useCalendarFocus();
const isActive = () => pager.isActive(props.id);
// A block navigation request pages this calendar instance to one occurrence
// and opens its details once FullCalendar has mounted the target chip.
let navigatedFor: number | undefined;
createEffect(() => {
props.grid.chipMounts();
const target = calendarFocus.pendingTarget();
if (!target || !isActive()) return;
// Cached occurrences can resolve before onMount registers this page.
// Wait reactively so a no-op navigation cannot consume the request.
if (!pager.activePage()?.api()) return;
const dateInfo = props.grid.dateInfo();
if (!dateInfo) return;
if (target.date < dateInfo.start || target.date >= dateInfo.end) {
// Navigate once per request; the effect re-runs as the destination
// page's chips mount, and by then the date is inside the view.
if (navigatedFor !== target.requestId) {
navigatedFor = target.requestId;
pager.navigateToDate(target.date);
}
return;
}
const targetId = calendarFocusTargetId(target);
const event = props.eventsById().get(targetId);
const chip = props.grid.eventElements.get(targetId);
if (!event || !chip?.isConnected) return;
calendarFocus.consume(target.requestId);
scrollEventChipIntoView(props.grid.element(), chip);
calendarView.selectEvent(event, chip);
});
useCalendarTimeGridHoverIndicator(() =>
isActive() ? props.grid.element() : undefined
);
onMount(() => {
const unregister = pager.registerPage({
id: props.id,
api: props.grid.api,
dateInfo: props.grid.dateInfo,
element: props.grid.element,
data: props.data,
teamEvents: props.teamEvents,
});
onCleanup(unregister);
});
createEffect(
on(isActive, (active, wasActive) => {
if (
active &&
wasActive === false &&
props.data.occurrencesQuery.isSuccess &&
props.data.occurrencesQuery.isStale &&
!props.data.occurrencesQuery.isFetching
) {
fireAndForget(props.data.occurrencesQuery.refetch(), 'calendar-view');
}
})
);
createEffect(
on(
() =>
[
isActive(),
calendarView.selectedEvent()?.id,
props.eventsById(),
] as const,
([active, selectedEventId, eventsById]) => {
if (!active || !selectedEventId) return;
// An absent event proves nothing until its occurrences and source
// metadata are ready to render.
calendarView.refreshSelectedEventFromPage(
eventsById,
props.data.occurrencesQuery.isSuccess && !props.data.isLoading()
);
}
)
);
return (
<>
<CalendarScrollIndicators calendarElement={props.grid.element} />
<CalendarPageDataStatus
data={props.data}
changingView={isActive() && pager.isChangingView()}
grid={props.grid}
onLoadingBlockingChange={props.onLoadingBlockingChange}
/>
</>
);
}