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
feat(calendar): mobile ui (#5482)
dev-rb2f032b27bff7
diff --git a/apps/web/src/components/app/mobile/MobileDock.tsx b/apps/web/src/components/app/mobile/MobileDock.tsxindex 7587609e65..3877453629 100644--- a/apps/web/src/components/app/mobile/MobileDock.tsx+++ b/apps/web/src/components/app/mobile/MobileDock.tsx@@ -1,4 +1,5 @@import type { ListView } from '@app/constants/list-views';+import { useCalendarUiFlag } from '@app/features/calendar/use-calendar-ui-flag';import {CREATABLE_BLOCKS,runCreateAction,@@ -18,6 +19,7 @@ import { hapticImpact } from '@core/mobile/haptics';import { openFilePicker } from '@core/util/upload';import { ICON_ANIMATION_DURATION_MS } from '@icon/animation';import IconGear from '@icon/macro-gear.svg';+import WideCalendarIcon from '@icon/wide-calendar.svg';import { AnimatedCallIcon } from '@icon/wide-call';import { AnimatedChannelIcon } from '@icon/wide-channel';import { AnimatedEmailIcon } from '@icon/wide-email';@@ -45,7 +47,7 @@ import { pressPulse } from './pressPulse';// Keeps the directive import from being tree-shaken / lint-flagged.false && pressPulse;-type DockId = ListView;+type DockId = ListView | 'calendar';type MobileDockButtonProps = {icon: MobileTouchIconComponent;@@ -105,26 +107,30 @@ function MobileDockButton(props: MobileDockButtonProps) {);}-const MORE_VIEWS: {- id: ListView;- label: string;- icon: MobileTouchIconComponent;-}[] = [- { id: 'inbox', label: 'Inbox', icon: AnimatedInboxIcon },- { id: 'agents', label: 'Agents', icon: AnimatedStarIcon },- { id: 'mail', label: 'Email', icon: AnimatedEmailIcon },- { id: 'documents', label: 'Documents', icon: AnimatedFileMdIcon },- { id: 'tasks', label: 'Tasks', icon: AnimatedTaskIcon },- { id: 'channels', label: 'Channels', icon: AnimatedChannelIcon },- { id: 'calls', label: 'Calls', icon: AnimatedCallIcon },- { id: 'folders', label: 'Folders', icon: AnimatedFolderIcon },-];-function MoreViewsMenu(props: {isActive: (id: DockId) => boolean;onNavigate: (id: DockId) => void;}) {const { settingsOpen, toggleSettings } = useSettingsState();+ const calendarUiEnabled = useCalendarUiFlag();++ const moreViews = (): Array<{+ id: DockId;+ label: string;+ icon: MobileTouchIconComponent;+ }> => [+ { id: 'inbox', label: 'Inbox', icon: AnimatedInboxIcon },+ { id: 'agents', label: 'Agents', icon: AnimatedStarIcon },+ { id: 'mail', label: 'Email', icon: AnimatedEmailIcon },+ { id: 'documents', label: 'Documents', icon: AnimatedFileMdIcon },+ { id: 'tasks', label: 'Tasks', icon: AnimatedTaskIcon },+ ...(calendarUiEnabled()+ ? [{ id: 'calendar' as const, label: 'Calendar', icon: WideCalendarIcon }]+ : []),+ { id: 'channels', label: 'Channels', icon: AnimatedChannelIcon },+ { id: 'calls', label: 'Calls', icon: AnimatedCallIcon },+ { id: 'folders', label: 'Folders', icon: AnimatedFolderIcon },+ ];return (<MobileTouchMenu@@ -140,7 +146,7 @@ function MoreViewsMenu(props: {animateIcon: false,onSelect: toggleSettings,},- ...MORE_VIEWS.map((item) => ({+ ...moreViews().map((item) => ({id: item.id,label: item.label,icon: item.icon,diff --git a/apps/web/src/components/ui/components/Calendar.tsx b/apps/web/src/components/ui/components/Calendar.tsxindex ef802cccde..83872b7e18 100644--- a/apps/web/src/components/ui/components/Calendar.tsx+++ b/apps/web/src/components/ui/components/Calendar.tsx@@ -18,6 +18,7 @@ import {} from 'solid-js';import { Virtualizer, type VirtualizerHandle } from 'virtua/solid';import { cn } from '../utils/classname';+import { Button } from './Button';import { Dropdown } from './Dropdown';const formatWeekdayLong = new Intl.DateTimeFormat(undefined, {@@ -41,6 +42,13 @@ const isRangeStart = (date: Date, range: HighlightedRange | undefined) =>const isRangeEnd = (date: Date, range: HighlightedRange | undefined) =>isDateInRange(date, range) && !isDateInRange(offsetDate(date, 1), range);+export interface CalendarMonthSelectorProps {+ /** Month currently displayed by the calendar. */+ month: Date;+ /** Displays another month. */+ onChange: (month: Date) => void;+}+export type CalendarProps = Omit<CorvuCalendarRootSingleProps,'children' | 'mode'@@ -70,23 +78,10 @@ export function Calendar(props: CalendarProps) {<div class={cn('w-full min-w-0 text-ink', local.class)}><div class="flex items-center gap-2"><CorvuCalendar.Label class="min-w-0 flex-1">- <Dropdown placement="bottom-start">- <Dropdown.Trigger- aria-label="Choose month"- class="h-7 max-w-full min-w-0 justify-start gap-1 border-none bg-transparent px-1 text-xs font-medium text-ink hover:bg-hover"- >- <span class="min-w-0 truncate">- {formatCalendarMonth(calendar.month)}- </span>- <CaretDownIcon class="size-3 shrink-0 text-ink-muted" />- </Dropdown.Trigger>- <Dropdown.Content class="min-w-40 p-1">- <CalendarMonthMenu- month={calendar.month}- onChange={calendar.setMonth}- />- </Dropdown.Content>- </Dropdown>+ <CalendarMonthDropdown+ month={calendar.month}+ onChange={calendar.setMonth}+ /></CorvuCalendar.Label><div class="ml-auto flex shrink-0 items-center gap-0.5"><CorvuCalendar.Nav@@ -172,8 +167,9 @@ export function Calendar(props: CalendarProps) {const MONTH_RANGE_YEARS = 100;const MONTH_OPTION_HEIGHT = 32;+const DRAWER_MONTH_OPTION_HEIGHT = 44;-const formatCalendarMonth = new Intl.DateTimeFormat(undefined, {+export const formatCalendarMonth = new Intl.DateTimeFormat(undefined, {month: 'long',year: 'numeric',}).format;@@ -189,11 +185,38 @@ type MonthOptionRange = {startYear: number;};-type CalendarMonthMenuProps = {- month: Date;- onChange: (month: Date) => void;+export type CalendarMonthMenuProps = CalendarMonthSelectorProps & {+ /** Semantic presentation used for month options. */+ presentation?: 'menu' | 'radio-group';+ /** Action invoked by the drawer's Go To Today button. */+ onToday?: () => void;};+/** Dropdown presentation for selecting a calendar month. */+function CalendarMonthDropdown(props: CalendarMonthSelectorProps) {+ const [open, setOpen] = createSignal(false);++ const selectMonth = (month: Date) => {+ props.onChange(month);+ setOpen(false);+ };++ return (+ <Dropdown open={open()} onOpenChange={setOpen} placement="bottom-start">+ <Dropdown.Trigger+ aria-label="Choose month"+ class="h-7 max-w-full min-w-0 justify-start gap-1 border-none bg-transparent px-1 text-xs font-medium text-ink hover:bg-hover"+ >+ <span class="min-w-0 truncate">{formatCalendarMonth(props.month)}</span>+ <CaretDownIcon class="size-3 shrink-0 text-ink-muted" />+ </Dropdown.Trigger>+ <Dropdown.Content class="min-w-40 p-1">+ <CalendarMonthMenu month={props.month} onChange={selectMonth} />+ </Dropdown.Content>+ </Dropdown>+ );+}+const monthValue = (date: Date) =>`${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}`;@@ -228,7 +251,8 @@ const createMonthOptionRange = (const monthIndex = (month: Date, startYear: number) =>(month.getFullYear() - startYear) * 12 + month.getMonth();-function CalendarMonthMenu(props: CalendarMonthMenuProps) {+/** Virtualized month menu reusable across dropdown and drawer presentations. */+export function CalendarMonthMenu(props: CalendarMonthMenuProps) {const now = new Date();const todayMonth = new Date(now.getFullYear(), now.getMonth(), 1);const todayValue = monthValue(todayMonth);@@ -239,18 +263,24 @@ function CalendarMonthMenu(props: CalendarMonthMenuProps) {props.month > todayMonth ? 'up' : 'down');let initialPositionComplete = false;+ let focusFrame: number | undefined;+ let menu!: HTMLDivElement;const range = createMemo(() =>createMonthOptionRange(props.month, todayMonth));const options = () => range().options;const selectedValue = () => monthValue(props.month);+ const optionHeight = () =>+ props.presentation === 'radio-group'+ ? DRAWER_MONTH_OPTION_HEIGHT+ : MONTH_OPTION_HEIGHT;const selectedIndex = () => monthIndex(props.month, range().startYear);const todayIndex = () => monthIndex(todayMonth, range().startYear);const centeredOffset = (index: number) => {const handle = virtualizer();- if (!handle) return index * MONTH_OPTION_HEIGHT;+ if (!handle) return index * optionHeight();return Math.max(0,@@ -264,6 +294,41 @@ function CalendarMonthMenu(props: CalendarMonthMenuProps) {virtualizer()?.scrollToIndex(index, { align: 'center' });};+ const focusIndex = (index: number) => {+ scrollToIndex(index);+ if (focusFrame !== undefined) cancelAnimationFrame(focusFrame);++ focusFrame = requestAnimationFrame(() => {+ focusFrame = undefined;+ menu.querySelector<HTMLElement>(`[data-month-index="${index}"]`)?.focus();+ });+ };++ const handleKeyDown = (event: KeyboardEvent) => {+ const option = (event.target as Element).closest<HTMLElement>(+ '[data-month-index]'+ );+ if (!option || !menu.contains(option)) return;++ const currentIndex = Number(option.dataset.monthIndex);+ let nextIndex: number | undefined;++ if (event.key === 'ArrowDown' || event.key === 'ArrowRight') {+ nextIndex = Math.min(options().length - 1, currentIndex + 1);+ } else if (event.key === 'ArrowUp' || event.key === 'ArrowLeft') {+ nextIndex = Math.max(0, currentIndex - 1);+ } else if (event.key === 'Home') {+ nextIndex = 0;+ } else if (event.key === 'End') {+ nextIndex = options().length - 1;+ }++ if (nextIndex === undefined) return;++ event.preventDefault();+ focusIndex(nextIndex);+ };+const handleScroll = (offset: number) => {if (!initialPositionComplete) return;@@ -296,42 +361,66 @@ function CalendarMonthMenu(props: CalendarMonthMenuProps) {scrollToIndex(selectedIndex());positionedFrame = requestAnimationFrame(() => {initialPositionComplete = true;+ menu+ .querySelector<HTMLElement>(`[data-month-index="${selectedIndex()}"]`)+ ?.focus({ preventScroll: true });});});onCleanup(() => {cancelAnimationFrame(frame);if (positionedFrame !== undefined) cancelAnimationFrame(positionedFrame);+ if (focusFrame !== undefined) cancelAnimationFrame(focusFrame);});});return (- <div class="relative">- <Dropdown.RadioGroup- value={selectedValue()}- onChange={(value) => {- const option = options().find(- (candidate) => candidate.value === value- );- if (option) props.onChange(option.date);- }}+ <div+ ref={menu}+ class="relative"+ role={props.presentation === 'radio-group' ? 'radiogroup' : undefined}+ aria-label={+ props.presentation === 'radio-group' ? 'Choose month' : undefined+ }+ onKeyDown={handleKeyDown}+ >+ <div+ class={cn(+ 'h-72 overflow-y-auto overscroll-contain',+ props.presentation === 'radio-group' && 'rounded-2xl'+ )}+ style={{ contain: 'strict' }}>- <div- class="h-72 overflow-y-auto overscroll-contain"- style={{ contain: 'strict' }}+ <Virtualizer+ data={options()}+ itemSize={optionHeight()}+ onScroll={handleScroll}+ ref={setVirtualizer}>- <Virtualizer- data={options()}- itemSize={MONTH_OPTION_HEIGHT}- onScroll={handleScroll}- ref={setVirtualizer}- >- {(option) => (- <Dropdown.RadioItem+ {(option) => {+ const index = () => monthIndex(option.date, range().startYear);+ const selected = () => option.value === selectedValue();++ return (+ <button+ type="button"+ role={+ props.presentation === 'radio-group'+ ? 'radio'+ : 'menuitemradio'+ }+ aria-checked={selected()}aria-current={option.value === todayValue ? 'date' : undefined}- class="h-8 text-xs"- closeOnSelect- value={option.value}+ data-month-index={index()}+ class={cn(+ 'flex w-full items-center gap-1.5 text-left outline-none hover:bg-hover focus-visible:bg-hover',+ selected() ? 'text-accent' : 'text-ink',+ props.presentation === 'radio-group'+ ? 'relative h-11 bg-surface px-4 text-sm'+ : 'h-8 rounded-lg px-2 text-xs'+ )}+ tabIndex={selected() ? 0 : -1}+ onClick={() => props.onChange(option.date)}><spanaria-hidden="true"@@ -342,22 +431,67 @@ function CalendarMonthMenu(props: CalendarMonthMenuProps) {</Show></span><span>{option.label}</span>- <Dropdown.ItemIndicator class="ml-auto">- <CheckIcon class="size-3.5 text-accent" />- </Dropdown.ItemIndicator>- </Dropdown.RadioItem>- )}- </Virtualizer>+ <CheckIcon+ class="ml-auto size-3.5 text-accent"+ classList={{ invisible: !selected() }}+ />+ <Show+ when={+ props.presentation === 'radio-group' &&+ index() < options().length - 1+ }+ >+ <span+ aria-hidden="true"+ class="absolute inset-x-2 bottom-0 h-px bg-edge-muted"+ />+ </Show>+ </button>+ );+ }}+ </Virtualizer>+ </div>++ <Show when={props.presentation === 'radio-group'}>+ <div class="flex pt-3">+ <Button+ fullWidth+ variant="base"+ size="sm"+ depth={3}+ class="rounded-full bg-surface px-3 text-ink shadow-menu"+ label="Go To Today"+ onClick={() => {+ if (props.onToday) {+ props.onToday();+ return;+ }+ focusIndex(todayIndex());+ }}+ >+ Go To Today+ </Button></div>- </Dropdown.RadioGroup>+ </Show>- <Show when={hasScrolled() && !isTodayVisible()}>+ <Show+ when={+ props.presentation !== 'radio-group' &&+ hasScrolled() &&+ !isTodayVisible()+ }+ ><div class="pointer-events-none absolute inset-x-0 bottom-2 z-10 flex justify-center">- <Dropdown.Item- class="pointer-events-auto w-auto min-w-16 justify-center rounded-full border border-edge-muted bg-surface px-3 text-xs shadow-menu hover:bg-active data-highlighted:bg-active"- closeOnSelect={false}+ <button+ type="button"+ class={cn(+ 'pointer-events-auto flex min-w-16 items-center justify-center gap-1.5 rounded-full border border-edge-muted bg-surface px-3 text-ink shadow-menu hover:bg-active',+ props.presentation === 'radio-group'+ ? 'h-11 text-sm'+ : 'h-8 text-xs'+ )}data-direction={todayDirection()}- onSelect={() => scrollToIndex(todayIndex())}+ onClick={() => focusIndex(todayIndex())}><Showwhen={todayDirection() === 'up'}@@ -366,7 +500,7 @@ function CalendarMonthMenu(props: CalendarMonthMenuProps) {<ArrowUpIcon aria-hidden="true" class="size-3" /></Show>Today- </Dropdown.Item>+ </button></div></Show></div>diff --git a/apps/web/src/components/ui/components/Pager/Pager.test.tsx b/apps/web/src/components/ui/components/Pager/Pager.test.tsxnew file mode 100644index 0000000000..8a787e29bc--- /dev/null+++ b/apps/web/src/components/ui/components/Pager/Pager.test.tsx@@ -0,0 +1,219 @@+/**+ * @vitest-environment jsdom+ */++import { render } from '@solidjs/testing-library';+import { createSignal, For } from 'solid-js';+import { beforeEach, describe, expect, it, vi } from 'vitest';+import { createPager, Pager, type PagerController, usePager } from '.';++type PageId = 'a' | 'b' | 'c' | 'd';++function finishTransition(container: HTMLElement) {+ const rail = container.querySelector<HTMLElement>('.pager-rail');+ if (!rail) throw new Error('Pager rail was not rendered');+ const event = new Event('transitionend', { bubbles: true });+ Object.defineProperty(event, 'propertyName', { value: 'transform' });+ rail.dispatchEvent(event);+}++function renderPager(options?: {+ canChangePage?: (page: PageId) => boolean;+ onChange?: (page: PageId) => void;+ pages?: PageId[];+}) {+ let controller!: PagerController<PageId>;+ let contextController!: PagerController<PageId>;+ const pages = options?.pages ?? ['a', 'b', 'c'];+ const [pageOrder, setPageOrder] = createSignal<readonly PageId[]>(pages);+ const [activePage, setActivePage] = createSignal<PageId>(pages[1] ?? 'a');++ function Controls() {+ contextController = usePager<PageId>();+ return null;+ }++ const rendered = render(() => {+ controller = createPager({+ pageOrder,+ activePage,+ canChangePage: ({ to }) => options?.canChangePage?.(to) ?? true,+ onPageChange: (page) => {+ setActivePage(page);+ options?.onChange?.(page);+ },+ });++ return (+ <Pager.Root controller={controller}>+ <Controls />+ <Pager.Viewport>+ <For each={pages}>+ {(page) => <Pager.Page id={page}>{page}</Pager.Page>}+ </For>+ </Pager.Viewport>+ </Pager.Root>+ );+ });++ const viewport = rendered.container.querySelector<HTMLElement>('.pager');+ if (!viewport) throw new Error('Pager viewport was not rendered');+ Object.defineProperty(viewport, 'clientWidth', {+ configurable: true,+ value: 320,+ });++ return {+ ...rendered,+ activePage,+ contextController,+ controller,+ pageOrder,+ setPageOrder,+ };+}++beforeEach(() => {+ vi.stubGlobal('matchMedia', () => ({ matches: false }));+ vi.stubGlobal(+ 'ResizeObserver',+ class {+ observe() {}+ unobserve() {}+ disconnect() {}+ }+ );+});++describe('Pager', () => {+ it('provides its controller outside the viewport', () => {+ const rendered = renderPager();+ expect(rendered.contextController).toBe(rendered.controller);+ });++ it('animates to the next page and commits after transition end', async () => {+ const onChange = vi.fn();+ const rendered = renderPager({ onChange });++ const navigation = rendered.contextController.next();+ expect(rendered.controller.phase()).toBe('settling');+ expect(rendered.controller.targetPage()).toBe('c');+ expect(rendered.activePage()).toBe('b');++ finishTransition(rendered.container);++ await expect(navigation).resolves.toBe(true);+ expect(rendered.activePage()).toBe('c');+ expect(rendered.controller.phase()).toBe('idle');+ expect(onChange).toHaveBeenCalledWith('c');+ });++ it('supports any number of ordered pages', async () => {+ const rendered = renderPager({ pages: ['a', 'b', 'c', 'd'] });++ const navigation = rendered.controller.goTo('d');+ finishTransition(rendered.container);++ await expect(navigation).resolves.toBe(true);+ expect(rendered.activePage()).toBe('d');+ expect(rendered.controller.relativePosition('a')).toBe(-3);+ });++ it('finishes rapid arrow navigation without replaying the full animation', async () => {+ const rendered = renderPager({ pages: ['a', 'b', 'c', 'd'] });++ const firstNavigation = rendered.controller.next();+ const secondNavigation = rendered.controller.next();++ await expect(firstNavigation).resolves.toBe(true);+ await expect(secondNavigation).resolves.toBe(true);+ expect(rendered.activePage()).toBe('d');+ expect(rendered.controller.phase()).toBe('idle');+ });++ it('keeps repeated clicks immediate for longer than one animation', async () => {+ const now = vi.spyOn(Date, 'now').mockReturnValue(1_000);+ const rendered = renderPager({ pages: ['a', 'b', 'c', 'd'] });++ const firstNavigation = rendered.controller.next();+ finishTransition(rendered.container);+ await firstNavigation;++ now.mockReturnValue(1_400);+ await expect(rendered.controller.next()).resolves.toBe(true);+ expect(rendered.activePage()).toBe('d');+ expect(rendered.controller.phase()).toBe('idle');++ now.mockRestore();+ });++ it('supports rapid navigation while the consumer rotates a three-page buffer', async () => {+ let rendered!: ReturnType<typeof renderPager>;+ rendered = renderPager({+ onChange: () => {+ const [first, ...remaining] = rendered.pageOrder();+ rendered.setPageOrder([...remaining, first]);+ },+ });++ const firstNavigation = rendered.controller.next();+ const secondNavigation = rendered.controller.next();++ await expect(firstNavigation).resolves.toBe(true);+ await expect(secondNavigation).resolves.toBe(true);+ expect(rendered.activePage()).toBe('a');+ expect(rendered.pageOrder()).toEqual(['c', 'a', 'b']);+ expect(rendered.controller.relativePosition('a')).toBe(0);+ });++ it('leaves page reordering to the controlled consumer', async () => {+ let rendered!: ReturnType<typeof renderPager>;+ rendered = renderPager({+ onChange: (page) => {+ if (page === 'c') rendered.setPageOrder(['b', 'c', 'a']);+ },+ });++ const navigation = rendered.controller.next();+ finishTransition(rendered.container);++ await navigation;+ expect(rendered.activePage()).toBe('c');+ expect(rendered.pageOrder()).toEqual(['b', 'c', 'a']);+ expect(rendered.controller.relativePosition('b')).toBe(-1);+ expect(rendered.controller.relativePosition('a')).toBe(1);+ });++ it('does not start a disabled transition', async () => {+ const rendered = renderPager({+ canChangePage: (page) => page !== 'c',+ });++ await expect(rendered.controller.next()).resolves.toBe(false);+ expect(rendered.controller.phase()).toBe('idle');+ expect(rendered.activePage()).toBe('b');+ });++ it('supports externally controlled drag progress', async () => {+ const rendered = renderPager();++ expect(rendered.controller.beginDrag()).toBe(true);+ rendered.controller.updateDrag(-100);+ const navigation = rendered.controller.commitDrag('next');+ finishTransition(rendered.container);++ await expect(navigation).resolves.toBe(true);+ expect(rendered.activePage()).toBe('c');+ });++ it('resets synchronously when the viewport detaches', async () => {+ const rendered = renderPager();+ const navigation = rendered.controller.next();+ expect(rendered.controller.phase()).toBe('settling');++ rendered.unmount();++ expect(rendered.controller.phase()).toBe('idle');+ await expect(navigation).resolves.toBe(false);+ });+});diff --git a/apps/web/src/components/ui/components/Pager/Pager.tsx b/apps/web/src/components/ui/components/Pager/Pager.tsxnew file mode 100644index 0000000000..af44e55fbd--- /dev/null+++ b/apps/web/src/components/ui/components/Pager/Pager.tsx@@ -0,0 +1,526 @@+import { createResizeObserver } from '@solid-primitives/resize-observer';+import {+ type Accessor,+ batch,+ createContext,+ createSignal,+ type JSX,+ onCleanup,+ onMount,+ type ParentProps,+ splitProps,+ useContext,+} from 'solid-js';+import './pager.css';++const DEFAULT_ANIMATION_DURATION = 140;+const RAPID_NAVIGATION_CLICK_THRESHOLD = DEFAULT_ANIMATION_DURATION + 10;+const TRANSITION_FALLBACK_BUFFER = 50;++type PagerPhase = 'idle' | 'dragging' | 'settling';+export type PagerDirection = 'previous' | 'next';+export type PagerNavigationSource = 'gesture' | 'programmatic';++/** Describes a page transition requested by the pager. */+export interface PagerChange<PageId> {+ /** Page active before the transition. */+ from: PageId;+ /** Page that will become active. */+ to: PageId;+ /** Logical direction through the configured page order. */+ direction: PagerDirection;+ /** Whether a gesture or imperative command started the transition. */+ source: PagerNavigationSource;+}++/** Configuration for a transform-driven pager. */+export interface PagerOptions<PageId> {+ /** Mounted pages in their current logical order. */+ pageOrder: Accessor<readonly PageId[]>;+ /** The controlled page aligned with the viewport while idle. */+ activePage: Accessor<PageId>;+ /** Commits the destination after its transition finishes. Must update synchronously. */+ onPageChange: (page: PageId, change: PagerChange<PageId>) => void;+ /** Allows a consumer to disable a particular transition. */+ canChangePage?: (change: PagerChange<PageId>) => boolean;+ /** Called when an external gesture starts moving the pager. */+ onDragStart?: (page: PageId) => void;+ /** Called immediately before a committed transition starts settling. */+ onTransitionStart?: (change: PagerChange<PageId>) => void;+ /** Called after the controlled page has been reconciled at rest. */+ onTransitionEnd?: (change: PagerChange<PageId>) => void;+ /** Duration of programmatic and release animations. */+ animationDuration?: number;+}++interface PendingTransition<PageId> {+ change: PagerChange<PageId>;+ resolve: (changed: boolean) => void;+}++/** Headless controller provided by `Pager.Root`. */+export interface PagerController<PageId> {+ /** Current interaction phase. */+ phase: Accessor<PagerPhase>;+ /** Destination while a committed transition is settling. */+ targetPage: Accessor<PageId | undefined>;+ /** Currently mounted pager viewport. */+ viewport: Accessor<HTMLDivElement | undefined>;+ /** Moves to the previous page in the configured order. */+ previous: () => Promise<boolean>;+ /** Moves to the next page in the configured order. */+ next: () => Promise<boolean>;+ /** Moves to any currently configured page. */+ goTo: (page: PageId, options?: { animate?: boolean }) => Promise<boolean>;+ /** Immediately cancels an active drag or transition. */+ cancel: () => void;+ /** Begins an externally controlled drag. */+ beginDrag: () => boolean;+ /** Moves the page rail during an externally controlled drag. */+ updateDrag: (offset: number) => void;+ /** Commits an externally controlled drag in one direction. */+ commitDrag: (direction: PagerDirection) => Promise<boolean>;+ /** Animates an externally controlled drag back to the active page. */+ cancelDrag: () => void;+ /** Returns whether this page is currently controlled as active. */+ isActive: (page: PageId) => boolean;+ /** Returns the page's position relative to the active page. */+ relativePosition: (page: PageId) => number;+ /** @internal Attaches motion to the rendered viewport and rail. */+ attachViewport: (+ viewport: HTMLDivElement,+ rail: HTMLDivElement+ ) => () => void;+}++/** Creates a generic transform-driven pager for any ordered set of pages. */+export function createPager<PageId>(+ options: PagerOptions<PageId>+): PagerController<PageId> {+ const [phase, setPhase] = createSignal<PagerPhase>('idle');+ const [targetPage, setTargetPage] = createSignal<PageId>();+ const [viewport, setViewport] = createSignal<HTMLDivElement>();++ let rail: HTMLDivElement | undefined;+ let dragFrame: number | undefined;+ let dragOffset = 0;+ let pendingTransition: PendingTransition<PageId> | undefined;+ let transitionTimer: number | undefined;+ let observedViewportWidth: number | undefined;+ let lastProgrammaticNavigationAt = Number.NEGATIVE_INFINITY;++ const animationDuration = () =>+ options.animationDuration ?? DEFAULT_ANIMATION_DURATION;++ const prefersReducedMotion = () =>+ window.matchMedia?.('(prefers-reduced-motion: reduce)').matches ?? false;++ const pageIndex = (page: PageId) => options.pageOrder().indexOf(page);++ const relativePosition = (page: PageId) => {+ const activeIndex = pageIndex(options.activePage());+ const index = pageIndex(page);++ if (activeIndex < 0 || index < 0) return 0;++ return index - activeIndex;+ };++ const clearTransitionTimer = () => {+ if (transitionTimer === undefined) return;++ clearTimeout(transitionTimer);+ transitionTimer = undefined;+ };++ const clearDragFrame = () => {+ if (dragFrame === undefined) return;++ cancelAnimationFrame(dragFrame);+ dragFrame = undefined;+ };++ const setRailOffset = (offset: number) => {+ dragOffset = offset;+ if (!rail) return;++ if (offset === 0) {+ rail.style.transform = '';+ return;+ }++ rail.style.transform = `translate3d(${offset}px, 0, 0)`;+ };++ const scheduleRailOffset = (offset: number) => {+ dragOffset = offset;+ if (dragFrame !== undefined) return;+ dragFrame = requestAnimationFrame(() => {+ dragFrame = undefined;+ setRailOffset(dragOffset);+ });+ };++ const setTransitionEnabled = (enabled: boolean) => {+ if (!rail) return;++ if (!enabled) {+ rail.style.transition = '';+ rail.style.willChange = phase() === 'dragging' ? 'transform' : '';+ return;+ }++ rail.style.transition = `transform ${animationDuration()}ms cubic-bezier(0.22, 1, 0.36, 1)`;+ rail.style.willChange = 'transform';+ };++ const transitionFor = (+ direction: PagerDirection,+ source: PagerNavigationSource,+ explicitPage?: PageId+ ): PagerChange<PageId> | undefined => {+ const order = options.pageOrder();+ const from = options.activePage();+ const fromIndex = order.indexOf(from);+ let toIndex: number;++ if (explicitPage === undefined) {+ const offset = direction === 'next' ? 1 : -1;+ toIndex = fromIndex + offset;+ } else {+ toIndex = order.indexOf(explicitPage);+ }++ const to = order[toIndex];+ if (fromIndex < 0 || to === undefined || Object.is(from, to)) {+ return undefined;+ }++ const change = { from, to, direction, source };+ if (options.canChangePage?.(change) === false) return undefined;++ return change;+ };++ const finishAtRest = () => {+ clearTransitionTimer();+ clearDragFrame();+ setTransitionEnabled(false);+ setRailOffset(0);+ batch(() => {+ setPhase('idle');+ setTargetPage(undefined);+ });+ if (rail) rail.style.willChange = '';+ };++ const transitionDistance = (change: PagerChange<PageId>) => {+ const viewportElement = viewport();+ if (!viewportElement) return 0;++ const pageDistance = pageIndex(change.to) - pageIndex(change.from);+ return pageDistance * viewportElement.clientWidth;+ };++ const finishTransition = () => {+ const pending = pendingTransition;+ pendingTransition = undefined;+ if (!pending) {+ finishAtRest();+ return;+ }++ clearTransitionTimer();+ clearDragFrame();+ setTransitionEnabled(false);+ setRailOffset(-transitionDistance(pending.change));+ options.onPageChange(pending.change.to, pending.change);+ setRailOffset(0);+ batch(() => {+ setPhase('idle');+ setTargetPage(undefined);+ });+ if (rail) rail.style.willChange = '';+ options.onTransitionEnd?.(pending.change);+ pending.resolve(true);+ };++ const scheduleTransitionFallback = (callback: () => void) => {+ clearTransitionTimer();+ transitionTimer = window.setTimeout(+ callback,+ animationDuration() + TRANSITION_FALLBACK_BUFFER+ );+ };++ const animateBack = () => {+ pendingTransition?.resolve(false);+ pendingTransition = undefined;+ batch(() => {+ setPhase('settling');+ setTargetPage(undefined);+ });++ if (prefersReducedMotion() || dragOffset === 0) {+ finishAtRest();+ return;+ }++ setTransitionEnabled(true);+ setRailOffset(0);+ scheduleTransitionFallback(finishAtRest);+ };++ const startTransition = (change: PagerChange<PageId>, animate = true) =>+ new Promise<boolean>((resolve) => {+ const viewportElement = viewport();+ if (!viewportElement || !rail || phase() === 'settling') {+ resolve(false);+ return;+ }++ clearDragFrame();+ pendingTransition = { change, resolve };+ batch(() => {+ setPhase('settling');+ setTargetPage(() => change.to);+ });+ options.onTransitionStart?.(change);++ const distance = transitionDistance(change);+ if (!animate || prefersReducedMotion() || distance === 0) {+ finishTransition();+ return;+ }++ setTransitionEnabled(true);+ setRailOffset(-distance);+ scheduleTransitionFallback(finishTransition);+ });++ const navigate = (+ direction: PagerDirection,+ source: PagerNavigationSource+ ) => {+ if (phase() === 'dragging') return Promise.resolve(false);++ const now = Date.now();+ const interruptedTransition = phase() === 'settling';+ const isRapidNavigation =+ source === 'programmatic' &&+ now - lastProgrammaticNavigationAt <= RAPID_NAVIGATION_CLICK_THRESHOLD;++ if (interruptedTransition) {+ if (pendingTransition) {+ finishTransition();+ } else {+ finishAtRest();+ }+ }++ if (phase() !== 'idle') return Promise.resolve(false);++ const change = transitionFor(direction, source);+ if (!change) return Promise.resolve(false);++ if (source === 'programmatic') lastProgrammaticNavigationAt = now;++ const animate = !interruptedTransition && !isRapidNavigation;+ return startTransition(change, animate);+ };++ const handleTransitionEnd = (event: TransitionEvent) => {+ if (event.target !== rail || event.propertyName !== 'transform') return;++ if (pendingTransition) {+ finishTransition();+ return;+ }++ finishAtRest();+ };++ createResizeObserver(viewport, ({ width }) => {+ if (observedViewportWidth === undefined) {+ observedViewportWidth = width;+ return;+ }++ if (width === observedViewportWidth) return;++ observedViewportWidth = width;+ if (phase() === 'idle') return;++ controller.cancel();+ });++ const controller: PagerController<PageId> = {+ phase,+ targetPage,+ viewport,+ previous: () => navigate('previous', 'programmatic'),+ next: () => navigate('next', 'programmatic'),+ goTo(page, navigationOptions) {+ if (phase() !== 'idle') return Promise.resolve(false);+ const fromIndex = pageIndex(options.activePage());+ const toIndex = pageIndex(page);+ if (fromIndex < 0 || toIndex < 0 || fromIndex === toIndex) {+ return Promise.resolve(false);+ }+ const direction = toIndex > fromIndex ? 'next' : 'previous';+ const change = transitionFor(direction, 'programmatic', page);+ if (!change) return Promise.resolve(false);++ return startTransition(change, navigationOptions?.animate !== false);+ },+ cancel() {+ if (phase() === 'idle') return;+ pendingTransition?.resolve(false);+ pendingTransition = undefined;+ finishAtRest();+ },+ beginDrag() {+ if (!viewport() || !rail || phase() !== 'idle') return false;++ setPhase('dragging');+ rail.style.willChange = 'transform';+ options.onDragStart?.(options.activePage());+ return true;+ },+ updateDrag(offset) {+ if (phase() !== 'dragging') return;++ const direction: PagerDirection = offset < 0 ? 'next' : 'previous';+ const constrainedOffset = transitionFor(direction, 'gesture')+ ? offset+ : offset * 0.12;+ scheduleRailOffset(constrainedOffset);+ },+ commitDrag(direction) {+ if (phase() !== 'dragging') return Promise.resolve(false);++ const change = transitionFor(direction, 'gesture');+ if (!change) {+ animateBack();+ return Promise.resolve(false);+ }+ return startTransition(change);+ },+ cancelDrag() {+ if (phase() !== 'dragging') return;+ animateBack();+ },+ isActive: (page) => Object.is(options.activePage(), page),+ relativePosition,+ attachViewport(nextViewport, nextRail) {+ observedViewportWidth = nextViewport.clientWidth;+ setViewport(nextViewport);++ rail = nextRail;+ rail.addEventListener('transitionend', handleTransitionEnd);++ return () => {+ controller.cancel();+ clearTransitionTimer();+ clearDragFrame();+ nextRail.removeEventListener('transitionend', handleTransitionEnd);+ setViewport(undefined);+ observedViewportWidth = undefined;+ rail = undefined;+ };+ },+ };++ onCleanup(() => {+ controller.cancel();+ clearTransitionTimer();+ clearDragFrame();+ });++ return controller;+}++const PagerContext = createContext<PagerController<unknown>>();++/** Returns the controller provided by the nearest `Pager.Root`. */+export function usePager<PageId>(): PagerController<PageId> {+ const controller = useContext(PagerContext) as+ | PagerController<PageId>+ | undefined;+ if (!controller) {+ throw new Error('Pager components must be used within Pager.Root');+ }++ return controller;+}++export type PagerRootProps<PageId> = ParentProps<{+ /** Pager controller created by `createPager`. */+ controller: PagerController<PageId>;+}>;++/** Provides one pager controller to controls, a viewport, and pages. */+export function PagerRoot<PageId>(props: PagerRootProps<PageId>) {+ return (+ <PagerContext.Provider+ value={props.controller as unknown as PagerController<unknown>}+ >+ {props.children}+ </PagerContext.Provider>+ );+}++export type PagerViewportProps = ParentProps<+ Omit<JSX.HTMLAttributes<HTMLDivElement>, 'children' | 'ref'>+>;++/** Renders the clipping viewport and transform rail for pager pages. */+export function PagerViewport(props: PagerViewportProps) {+ const controller = usePager<unknown>();+ const [local, elementProps] = splitProps(props, ['children', 'class']);+ let viewport!: HTMLDivElement;+ let rail!: HTMLDivElement;++ onMount(() => {+ const detach = controller.attachViewport(viewport, rail);+ onCleanup(detach);+ });++ return (+ <div+ {...elementProps}+ ref={viewport}+ class={`pager ${local.class ?? ''}`}+ data-phase={controller.phase()}+ >+ <div ref={rail} class="pager-rail">+ {local.children}+ </div>+ </div>+ );+}++export type PagerPageProps<PageId> = ParentProps<{+ /** Stable identity included in the controller's current page order. */+ id: PageId;+ /** Additional page-wrapper classes. */+ class?: string;+}>;++/** A stable physical page positioned by its nearest pager controller. */+export function PagerPage<PageId>(props: PagerPageProps<PageId>) {+ const controller = usePager<PageId>();++ return (+ <div+ class={`pager-page ${props.class ?? ''}`}+ style={{+ '--pager-page-position': controller.relativePosition(props.id),+ }}+ aria-hidden={!controller.isActive(props.id)}+ inert={!controller.isActive(props.id)}+ >+ {props.children}+ </div>+ );+}diff --git a/apps/web/src/components/ui/components/Pager/PagerSwipeGestures.test.tsx b/apps/web/src/components/ui/components/Pager/PagerSwipeGestures.test.tsxnew file mode 100644index 0000000000..65b9b4e55d--- /dev/null+++ b/apps/web/src/components/ui/components/Pager/PagerSwipeGestures.test.tsx@@ -0,0 +1,148 @@+/**+ * @vitest-environment jsdom+ */++import { fireEvent, render } from '@solidjs/testing-library';+import { createSignal, For } from 'solid-js';+import { beforeEach, describe, expect, it, vi } from 'vitest';+import {+ createPager,+ Pager,+ type PagerController,+ PagerSwipeGestures,+} from '.';++type PageId = 'previous' | 'current' | 'next';++function touchEvent(+ type: string,+ touches: Array<{ clientX: number; clientY: number }>,+ timeStamp: number,+ changedTouches = touches+) {+ const event = new Event(type, { bubbles: true, cancelable: true });+ Object.defineProperties(event, {+ changedTouches: { value: changedTouches },+ timeStamp: { value: timeStamp },+ touches: { value: touches },+ });+ return event;+}++function finishTransition(container: HTMLElement) {+ const rail = container.querySelector<HTMLElement>('.pager-rail');+ if (!rail) throw new Error('Pager rail was not rendered');+ const event = new Event('transitionend', { bubbles: true });+ Object.defineProperty(event, 'propertyName', { value: 'transform' });+ rail.dispatchEvent(event);+}++function renderSwipePager() {+ let controller!: PagerController<PageId>;+ const pages: PageId[] = ['previous', 'current', 'next'];+ const [activePage, setActivePage] = createSignal<PageId>('current');++ const rendered = render(() => {+ controller = createPager({+ pageOrder: () => pages,+ activePage,+ onPageChange: (page) => setActivePage(page),+ });++ return (+ <Pager.Root controller={controller}>+ <Pager.Viewport>+ <For each={pages}>+ {(page) => <Pager.Page id={page}>{page}</Pager.Page>}+ </For>+ </Pager.Viewport>+ <PagerSwipeGestures />+ </Pager.Root>+ );+ });++ const viewport = rendered.container.querySelector<HTMLElement>('.pager');+ if (!viewport) throw new Error('Pager viewport was not rendered');+ Object.defineProperty(viewport, 'clientWidth', {+ configurable: true,+ value: 320,+ });++ return { ...rendered, activePage, controller, viewport };+}++beforeEach(() => {+ vi.stubGlobal('matchMedia', () => ({ matches: false }));+ vi.stubGlobal(+ 'ResizeObserver',+ class {+ observe() {}+ unobserve() {}+ disconnect() {}+ }+ );+});++describe('PagerSwipeGestures', () => {+ it('commits a horizontal touch gesture after crossing the threshold', () => {+ const rendered = renderSwipePager();+ fireEvent(+ rendered.viewport,+ touchEvent('touchstart', [{ clientX: 200, clientY: 100 }], 0)+ );+ const move = touchEvent('touchmove', [{ clientX: 100, clientY: 102 }], 30);+ fireEvent(rendered.viewport, move);+ fireEvent(+ rendered.viewport,+ touchEvent('touchend', [], 60, [{ clientX: 100, clientY: 102 }])+ );++ expect(move.defaultPrevented).toBe(true);+ expect(rendered.controller.targetPage()).toBe('next');+ finishTransition(rendered.container);+ expect(rendered.activePage()).toBe('next');+ });++ it('snaps back when a second touch interrupts the gesture', () => {+ const rendered = renderSwipePager();+ fireEvent(+ rendered.viewport,+ touchEvent('touchstart', [{ clientX: 200, clientY: 100 }], 0)+ );+ fireEvent(+ rendered.viewport,+ touchEvent('touchmove', [{ clientX: 150, clientY: 100 }], 20)+ );+ expect(rendered.controller.phase()).toBe('dragging');++ fireEvent(+ rendered.viewport,+ touchEvent(+ 'touchstart',+ [+ { clientX: 150, clientY: 100 },+ { clientX: 170, clientY: 100 },+ ],+ 30+ )+ );+ expect(rendered.controller.phase()).toBe('settling');++ finishTransition(rendered.container);+ expect(rendered.controller.phase()).toBe('idle');+ expect(rendered.activePage()).toBe('current');+ });++ it('leaves vertical touch movement available to the browser', () => {+ const rendered = renderSwipePager();+ fireEvent(+ rendered.viewport,+ touchEvent('touchstart', [{ clientX: 100, clientY: 100 }], 0)+ );+ const move = touchEvent('touchmove', [{ clientX: 102, clientY: 140 }], 20);+ fireEvent(rendered.viewport, move);++ expect(move.defaultPrevented).toBe(false);+ expect(rendered.controller.phase()).toBe('idle');+ });+});diff --git a/apps/web/src/components/ui/components/Pager/PagerSwipeGestures.tsx b/apps/web/src/components/ui/components/Pager/PagerSwipeGestures.tsxnew file mode 100644index 0000000000..b3bbf8ef94--- /dev/null+++ b/apps/web/src/components/ui/components/Pager/PagerSwipeGestures.tsx@@ -0,0 +1,235 @@+import { createEffect, on, onCleanup } from 'solid-js';+import { type PagerDirection, usePager } from './Pager';++const DEFAULT_DIRECTION_LOCK_DISTANCE = 8;+const DEFAULT_VELOCITY_ACTIVATION_DISTANCE = 24;+const DEFAULT_VELOCITY_THRESHOLD = 0.5;+const RELEASE_VELOCITY_WINDOW = 100;++interface ActiveGesture {+ axis: 'x' | 'y' | undefined;+ claimed: boolean;+ currentX: number;+ currentY: number;+ samples: Array<{ time: number; x: number }>;+ startX: number;+ startY: number;+}++/** Options for adding mobile swipe input to a generic pager. */+export interface PagerSwipeGesturesProps {+ /** Allows a consumer to reject a touch based on its initial event. */+ canStart?: (event: TouchEvent) => boolean;+ /** Ignores touches beginning within this distance of either pager edge. */+ edgeInset?: number;+ /** Distance used to distinguish horizontal and vertical gestures. */+ directionLockDistance?: number;+ /** Distance required to commit, or a fraction of viewport width when below one. */+ activationDistance?: number;+ /** Release velocity in pixels per millisecond that can commit a page change. */+ velocityThreshold?: number;+}++/** Adds touch-only horizontal swipe input to the nearest `Pager.Root`. */+export function PagerSwipeGestures(props: PagerSwipeGesturesProps) {+ const pager = usePager<unknown>();++ createEffect(+ on(pager.viewport, (viewport) => {+ if (!viewport) return;++ let activeGesture: ActiveGesture | undefined;+ let suppressClick = false;+ let suppressClickTimer: number | undefined;+ const previousTouchAction = viewport.style.touchAction;+ viewport.style.touchAction = 'pan-y';++ const clearSuppressClickTimer = () => {+ if (suppressClickTimer === undefined) return;+ clearTimeout(suppressClickTimer);+ suppressClickTimer = undefined;+ };++ const animateBackAfterInterruption = () => {+ const shouldAnimateBack = activeGesture?.claimed;+ activeGesture = undefined;++ if (!shouldAnimateBack) return;++ pager.cancelDrag();+ };++ const handleTouchStart = (event: TouchEvent) => {+ if (event.touches.length !== 1) {+ animateBackAfterInterruption();+ return;+ }++ if (pager.phase() !== 'idle') return;++ const touch = event.touches[0];+ if (!touch || props.canStart?.(event) === false) return;++ const edgeInset = props.edgeInset ?? 0;+ const viewportBounds = viewport.getBoundingClientRect();+ if (+ edgeInset > 0 &&+ (touch.clientX <= viewportBounds.left + edgeInset ||+ touch.clientX >= viewportBounds.right - edgeInset)+ ) {+ return;+ }++ activeGesture = {+ axis: undefined,+ claimed: false,+ currentX: touch.clientX,+ currentY: touch.clientY,+ samples: [{ time: event.timeStamp, x: touch.clientX }],+ startX: touch.clientX,+ startY: touch.clientY,+ };+ };++ const handleTouchMove = (event: TouchEvent) => {+ const gesture = activeGesture;+ const touch = event.touches[0];+ if (!gesture || event.touches.length !== 1 || !touch) {+ animateBackAfterInterruption();+ return;+ }++ gesture.currentX = touch.clientX;+ gesture.currentY = touch.clientY;+ const deltaX = gesture.currentX - gesture.startX;+ const deltaY = gesture.currentY - gesture.startY;+ if (gesture.axis === undefined) {+ const directionLockDistance =+ props.directionLockDistance ?? DEFAULT_DIRECTION_LOCK_DISTANCE;+ if (Math.hypot(deltaX, deltaY) < directionLockDistance) return;++ gesture.axis = Math.abs(deltaX) > Math.abs(deltaY) ? 'x' : 'y';+ if (gesture.axis === 'x') {+ gesture.claimed = pager.beginDrag();+ }+ }++ if (gesture.axis !== 'x' || !gesture.claimed) return;++ gesture.samples.push({ time: event.timeStamp, x: gesture.currentX });+ while (+ gesture.samples.length > 2 &&+ event.timeStamp - gesture.samples[0].time > RELEASE_VELOCITY_WINDOW+ ) {+ gesture.samples.shift();+ }+ pager.updateDrag(deltaX);+ if (event.cancelable) event.preventDefault();+ };++ const releaseVelocity = (gesture: ActiveGesture, endTime: number) => {+ const samples = gesture.samples.filter(+ (sample) => endTime - sample.time <= RELEASE_VELOCITY_WINDOW+ );+ const first = samples[0];+ const last = samples.at(-1);+ if (!first || !last || last.time <= first.time) return 0;++ return (last.x - first.x) / (last.time - first.time);+ };++ const activationDistance = () => {+ const configured = props.activationDistance;+ if (configured === undefined) {+ return Math.min(96, Math.max(48, viewport.clientWidth * 0.2));+ }++ if (configured < 1) {+ return viewport.clientWidth * configured;+ }++ return configured;+ };++ const suppressSyntheticClick = () => {+ suppressClick = true;+ clearSuppressClickTimer();+ suppressClickTimer = window.setTimeout(() => {+ suppressClick = false;+ suppressClickTimer = undefined;+ }, 400);+ };++ const handleTouchEnd = (event: TouchEvent) => {+ const gesture = activeGesture;+ activeGesture = undefined;++ if (!gesture || gesture.axis !== 'x' || !gesture.claimed) return;+ if (event.touches.length > 0) {+ pager.cancelDrag();+ return;+ }++ suppressSyntheticClick();+ if (event.cancelable) event.preventDefault();++ const touch = event.changedTouches[0];+ if (touch) gesture.currentX = touch.clientX;++ const offset = gesture.currentX - gesture.startX;+ const velocity = releaseVelocity(gesture, event.timeStamp);+ const velocityThreshold =+ props.velocityThreshold ?? DEFAULT_VELOCITY_THRESHOLD;+ const commitsByDistance = Math.abs(offset) >= activationDistance();+ const commitsByVelocity =+ Math.abs(offset) >= DEFAULT_VELOCITY_ACTIVATION_DISTANCE &&+ Math.abs(velocity) >= velocityThreshold &&+ Math.sign(velocity) === Math.sign(offset);++ if (!commitsByDistance && !commitsByVelocity) {+ pager.cancelDrag();+ return;+ }++ const direction: PagerDirection = offset < 0 ? 'next' : 'previous';+ void pager.commitDrag(direction);+ };++ const handleTouchCancel = animateBackAfterInterruption;+ const handleClick = (event: MouseEvent) => {+ if (!suppressClick) return;+ suppressClick = false;+ clearSuppressClickTimer();+ event.preventDefault();+ event.stopPropagation();+ };++ viewport.addEventListener('touchstart', handleTouchStart, {+ passive: true,+ });+ viewport.addEventListener('touchmove', handleTouchMove, {+ passive: false,+ });+ viewport.addEventListener('touchend', handleTouchEnd, {+ passive: false,+ });+ viewport.addEventListener('touchcancel', handleTouchCancel, {+ passive: true,+ });+ viewport.addEventListener('click', handleClick, true);++ onCleanup(() => {+ animateBackAfterInterruption();+ clearSuppressClickTimer();+ viewport.style.touchAction = previousTouchAction;+ viewport.removeEventListener('touchstart', handleTouchStart);+ viewport.removeEventListener('touchmove', handleTouchMove);+ viewport.removeEventListener('touchend', handleTouchEnd);+ viewport.removeEventListener('touchcancel', handleTouchCancel);+ viewport.removeEventListener('click', handleClick, true);+ });+ })+ );++ return null;+}diff --git a/apps/web/src/components/ui/components/Pager/index.ts b/apps/web/src/components/ui/components/Pager/index.tsnew file mode 100644index 0000000000..cc9674cf0a--- /dev/null+++ b/apps/web/src/components/ui/components/Pager/index.ts@@ -0,0 +1,24 @@+import { PagerPage, PagerRoot, PagerViewport } from './Pager';+/** Compound components for rendering and interacting with a controlled pager. */+export const Pager = {+ Root: PagerRoot,+ Viewport: PagerViewport,+ Page: PagerPage,+};++export {+ createPager,+ type PagerChange,+ type PagerController,+ type PagerDirection,+ type PagerNavigationSource,+ type PagerOptions,+ type PagerPageProps,+ type PagerRootProps,+ type PagerViewportProps,+ usePager,+} from './Pager';+export {+ PagerSwipeGestures,+ type PagerSwipeGesturesProps,+} from './PagerSwipeGestures';diff --git a/apps/web/src/components/ui/components/Pager/pager.css b/apps/web/src/components/ui/components/Pager/pager.cssnew file mode 100644index 0000000000..9686810a91--- /dev/null+++ b/apps/web/src/components/ui/components/Pager/pager.css@@ -0,0 +1,25 @@+.pager {+ position: relative;+ overflow: hidden;+}++.pager-rail {+ position: absolute;+ inset: 0;+}++.pager-page {+ position: absolute;+ inset-block: 0;+ left: calc(var(--pager-page-position) * 100%);+ width: 100%;+ min-width: 0;+}++.pager-page[aria-hidden="true"] {+ pointer-events: none;+}++.pager[data-phase="dragging"] {+ user-select: none;+}diff --git a/apps/web/src/components/ui/index.ts b/apps/web/src/components/ui/index.tsindex 6d1ef3f879..d3276f1679 100644--- a/apps/web/src/components/ui/index.ts+++ b/apps/web/src/components/ui/index.ts@@ -11,8 +11,16 @@ export { Avatar, AvatarGroup } from './components/Avatar';export type { ButtonProps } from './components/Button';export { Button } from './components/Button';export { ButtonGroup } from './components/ButtonGroup';-export type { CalendarProps } from './components/Calendar';-export { Calendar } from './components/Calendar';+export type {+ CalendarMonthMenuProps,+ CalendarMonthSelectorProps,+ CalendarProps,+} from './components/Calendar';+export {+ Calendar,+ CalendarMonthMenu,+ formatCalendarMonth,+} from './components/Calendar';export type { ChatInputProps, ChatInputRows } from './components/ChatInput';export type { CheckboxProps } from './components/Checkbox';export {diff --git a/apps/web/src/features/calendar/CalendarDataStatus.tsx b/apps/web/src/features/calendar/CalendarDataStatus.tsxdeleted file mode 100644index 9d56200198..0000000000--- a/apps/web/src/features/calendar/CalendarDataStatus.tsx+++ /dev/null@@ -1,185 +0,0 @@-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 hasEvents = () => calendarView.events().length > 0;-- // Setup state is derived from the links alone. Existing events are not- // evidence that setup is complete: a link whose grant was revoked after a- // sync, or a delegated inbox, both leave events on screen with no working- // calendar connection of the requester's own.- const setupState = createMemo<- 'connect' | 'permission' | 'reauth' | undefined- >(() => {- if (- isRangeUnavailable() ||- !linksQuery.isSuccess ||- !calendarView.occurrencesQuery.isSuccess- ) {- 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() && !hasEvents()));- const showBlockingState = () =>- !isRangeUnavailable() &&- (calendarView.occurrencesQuery.isError ||- (setupState() !== undefined && !hasEvents()) ||- 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() &&- setupState() !== undefined- }- >- <div class="absolute right-2 bottom-2 z-10 flex items-center gap-2 rounded-full border border-edge-muted bg-surface py-1 pr-1 pl-2.5 text-xs text-ink-muted shadow-menu">- <span>{setupMessage().title}</span>- <Button- variant="active"- size="sm"- label={setupMessage().action}- onClick={() => {- startAddInbox();- }}- >- {setupMessage().action}- </Button>- </div>- </Show>-- <Show- when={- !isRangeUnavailable() &&- !showBlockingState() &&- setupState() === undefined &&- calendarView.isSyncing() &&- hasEvents()- }- >- <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/CalendarMonthDrawer.tsx b/apps/web/src/features/calendar/CalendarMonthDrawer.tsxnew file mode 100644index 0000000000..a1e469e78b--- /dev/null+++ b/apps/web/src/features/calendar/CalendarMonthDrawer.tsx@@ -0,0 +1,59 @@+import { MobileDrawer } from '@components/app/mobile/MobileDrawer';+import CaretDownIcon from '@phosphor/caret-down.svg';+import { Button, CalendarMonthMenu, formatCalendarMonth } from '@ui';+import { createSignal } from 'solid-js';+import { useCalendarPager } from './CalendarPagerContext';++type CalendarMonthDrawerProps = {+ month: Date;+};++/** Drawer presentation for navigating the calendar to a month. */+export function CalendarMonthDrawer(props: CalendarMonthDrawerProps) {+ const calendarPager = useCalendarPager();+ const [open, setOpen] = createSignal(false);++ const selectMonth = (month: Date) => {+ setOpen(false);+ calendarPager.navigateToDate(month);+ };++ const goToToday = () => {+ setOpen(false);+ calendarPager.navigateToToday();+ };++ return (+ <MobileDrawer+ side="bottom"+ open={open()}+ onOpenChange={setOpen}+ preventScroll={false}+ preventScrollbarShift={false}+ >+ <MobileDrawer.Trigger+ as={Button}+ aria-label="Choose month"+ class="max-w-full min-w-0 justify-start gap-1 rounded-full border-none bg-transparent px-1 text-base font-semibold text-ink hover:bg-hover"+ >+ <span class="min-w-0 truncate">{formatCalendarMonth(props.month)}</span>+ <CaretDownIcon class="size-3 shrink-0 text-ink-muted" />+ </MobileDrawer.Trigger>++ <MobileDrawer.Portal>+ <MobileDrawer.Overlay class="fixed inset-0 z-modal-overlay bg-modal-overlay pattern-diagonal-4 pattern-edge-muted" />+ <MobileDrawer.Content aria-label="Choose month">+ <MobileDrawer.Handle />+ <MobileDrawer.Section class="mb-3 overflow-visible">+ <CalendarMonthMenu+ month={props.month}+ presentation="radio-group"+ onChange={selectMonth}+ onToday={goToToday}+ />+ </MobileDrawer.Section>+ </MobileDrawer.Content>+ </MobileDrawer.Portal>+ </MobileDrawer>+ );+}diff --git a/apps/web/src/features/calendar/CalendarPage.tsx b/apps/web/src/features/calendar/CalendarPage.tsxnew file mode 100644index 0000000000..f616941980--- /dev/null+++ b/apps/web/src/features/calendar/CalendarPage.tsx@@ -0,0 +1,518 @@+import { ScrollIndicators } from '@core/component/VerticalScrollIndicators';+import { useUserId } from '@core/context/user';+import { isMobile } from '@core/mobile/isMobile';+import type { DatesSetArg } from '@fullcalendar/core';+import dayGridPlugin from '@fullcalendar/daygrid';+import interactionPlugin from '@fullcalendar/interaction';+import timeGridPlugin from '@fullcalendar/timegrid';+import SpinnerIcon from '@phosphor/spinner-gap.svg';+import {+ type CalendarOccurrenceQueryRange,+ createCalendarOccurrenceQueryRange,+ useCalendarOccurrencesQuery,+} from '@queries/calendar/occurrences';+import { CalendarSyncStatus } from '@service-storage/generated/schemas/calendarSyncStatus';+import { Button } from '@ui';+import {+ type Accessor,+ createEffect,+ createMemo,+ createSignal,+ on,+ onCleanup,+ onMount,+ Show,+} from 'solid-js';+import { Portal } from 'solid-js/web';+import {+ type CalendarPageData,+ type CalendarPageId,+ useCalendarPager,+} from './CalendarPagerContext';+import { useCalendarView } from './CalendarViewContext';+import { isCalendarRangeSupported } from './calendar-supported-range';+import { mapCalendarOccurrence } from './events/calendar-occurrence-mapper';+import { CalendarEventContent } from './events/EventContent';+import { mapCalendarEventToFullCalendar } from './events/event-mapper';+import type { CalendarTimeFormat } from './events/types';+import { FullCalendar, useFullCalendar } from './fullcalendar-solid';+import {+ CALENDAR_TIME_FORMAT_OPTIONS,+ formatCalendarTime,+ formatCompactCalendarTime,+} from './time-format';+import { useCalendarTimeGridHoverIndicator } from './useCalendarTimeGridHoverIndicator';++const formatWeekdayHeader = {+ narrow: new Intl.DateTimeFormat(undefined, {+ weekday: 'narrow',+ }).format,+ short: new Intl.DateTimeFormat(undefined, {+ weekday: 'short',+ }).format,+};++const formatDayNumber = new Intl.DateTimeFormat(undefined, {+ day: 'numeric',+}).format;++const isSameLocalDate = (first: Date, second: Date) =>+ first.getFullYear() === second.getFullYear() &&+ first.getMonth() === second.getMonth() &&+ first.getDate() === second.getDate();++function CurrentTimeAxisIndicator(props: {+ date: Date;+ timeFormat: CalendarTimeFormat;+}) {+ return (+ <span class="calendar-now-axis-indicator">+ <span class="calendar-now-time">+ {formatCalendarTime(props.date, props.timeFormat)}+ </span>+ </span>+ );+}++function getLocalScrollTime() {+ const now = new Date();+ const minutesSinceMidnight = now.getHours() * 60 + now.getMinutes();+ const scrollMinutes = Math.max(+ 0,+ Math.floor((minutesSinceMidnight - 60) / 30) * 30+ );+ const hours = Math.floor(scrollMinutes / 60);+ const minutes = scrollMinutes % 60;++ return `${String(hours).padStart(2, '0')}:${String(minutes).padStart(2, '0')}:00`;+}++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 = element.querySelector<HTMLElement>(+ '.fc-timegrid .fc-scroller-harness-liquid > .fc-scroller'+ );+ 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"+ class="h-6"+ />+ </Portal>+ )}+ </Show>+ );+}++function CalendarPageDataStatus(props: { data: CalendarPageData }) {+ const isRangeUnavailable = createMemo(() => {+ const range = props.data.range();+ return range !== undefined && !isCalendarRangeSupported(range);+ });++ const showLoading = () =>+ !isRangeUnavailable() &&+ !props.data.occurrencesQuery.isError &&+ props.data.isLoading();++ const showBlockingState = () => {+ if (isRangeUnavailable()) return false;+ if (props.data.occurrencesQuery.isError) return true;+ if (showLoading()) return false;++ return props.data.isSyncing() && props.data.events().length === 0;+ };++ 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={!props.data.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 props.data.occurrencesQuery.refetch()}+ >+ Retry+ </Button>+ </div>+ }+ >+ <div class="flex items-center gap-2 text-xs text-ink-muted">+ <SpinnerIcon class="size-4 animate-spin" />+ <span>Syncing calendar…</span>+ </div>+ </Show>+ </div>+ </Show>++ <Show when={showLoading()}>+ <div class="absolute top-2 left-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" />+ Loading+ </div>+ </Show>++ <Show+ when={+ !isRangeUnavailable() &&+ !showLoading() &&+ !showBlockingState() &&+ props.data.isSyncing() &&+ props.data.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>+ </>+ );+}++function createCalendarPageData(+ range: Accessor<CalendarOccurrenceQueryRange | undefined>,+ isActive: Accessor<boolean>+): CalendarPageData {+ const userId = useUserId();+ const calendarView = useCalendarView();+ const isRangeSupported = createMemo(() => {+ const currentRange = range();+ return currentRange !== undefined && isCalendarRangeSupported(currentRange);+ });+ const occurrencesQuery = useCalendarOccurrencesQuery(+ () => ({ userId: userId(), range: range() }),+ () => ({+ enabled: isRangeSupported(),+ pollWhileSyncing: isActive(),+ refetchOnWindowFocus: isActive(),+ })+ );+ const events = createMemo(() =>+ isRangeSupported()+ ? (occurrencesQuery.data?.items ?? []).map(mapCalendarOccurrence)+ : []+ );+ const visibleEvents = createMemo(() =>+ events().filter((event) =>+ calendarView.eventState.visibleSourceIds.includes(event.calendar.id)+ )+ );+ const eventsById = createMemo(+ () => new Map(events().map((event) => [event.id, event]))+ );+ const fullCalendarEvents = createMemo(() =>+ visibleEvents().map(mapCalendarEventToFullCalendar)+ );+ const isLoading = () =>+ range() === undefined ||+ (isRangeSupported() &&+ (occurrencesQuery.isPending || occurrencesQuery.isPlaceholderData));+ const isSyncing = () =>+ occurrencesQuery.data?.syncStatus === CalendarSyncStatus.syncing;++ return {+ range,+ occurrencesQuery,+ events,+ eventsById,+ fullCalendarEvents,+ isLoading,+ isSyncing,+ };+}++/** One independently rendered and queried FullCalendar page. */+export function CalendarPage(props: { id: CalendarPageId; initialDate: Date }) {+ const pager = useCalendarPager();+ const calendarView = useCalendarView();+ const [range, setRange] = createSignal<CalendarOccurrenceQueryRange>();+ const isActive = () => pager.isActive(props.id);+ const useNarrowWeekdayHeaders = () =>+ calendarView.useNarrowDayHeaders() && !isMobile();+ const data = createCalendarPageData(range, isActive);++ 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);+ };++ return (+ <FullCalendar.Root+ plugins={[dayGridPlugin, interactionPlugin, timeGridPlugin]}+ initialView={calendarView.displaySettings.periodView}+ initialDate={props.initialDate}+ height="100%"+ expandRows+ fixedWeekCount={false}+ handleWindowResize={false}+ allDayText="All day"+ nowIndicator+ headerToolbar={false}+ scrollTime={getLocalScrollTime()}+ scrollTimeReset={false}+ weekends={calendarView.displaySettings.showWeekends}+ firstDay={calendarView.displaySettings.weekStartsOn}+ slotLabelFormat={+ CALENDAR_TIME_FORMAT_OPTIONS[calendarView.displaySettings.timeFormat]+ }+ eventTimeFormat={+ CALENDAR_TIME_FORMAT_OPTIONS[calendarView.displaySettings.timeFormat]+ }+ events={data.fullCalendarEvents()}+ eventClick={({ el, event, jsEvent }) => {+ jsEvent.preventDefault();+ if (!isActive()) return;+ const selectedEvent = data.eventsById().get(event.id);+ if (selectedEvent) calendarView.selectEvent(selectedEvent, el);+ }}+ datesSet={handleDatesSet}+ dayHeaderFormat={{+ weekday: useNarrowWeekdayHeaders() ? 'narrow' : 'short',+ }}+ dayCellClassNames={({ date, view }) =>+ isSameLocalDate(date, view.calendar.getDate())+ ? ['calendar-day-selected']+ : []+ }+ >+ <FullCalendar.DayHeaderContent>+ {({ date, text, view }) => {+ if (view.type === 'timeGridWeek' || view.type === 'timeGridDay') {+ const weekday =+ view.type === 'timeGridDay'+ ? formatWeekdayHeader.short(date)+ : formatWeekdayHeader[+ useNarrowWeekdayHeaders() ? 'narrow' : 'short'+ ](date);++ return (+ <>+ <span class="calendar-day-header-weekday">{weekday}</span>{' '}+ <span+ class="calendar-day-header-date"+ classList={{+ 'calendar-day-header-date-selected': isSameLocalDate(+ date,+ view.calendar.getDate()+ ),+ }}+ >+ {formatDayNumber(date)}+ </span>+ </>+ );+ }+ return text;+ }}+ </FullCalendar.DayHeaderContent>++ <FullCalendar.SlotLabelContent>+ {({ date, text }) =>+ calendarView.useNarrowDayHeaders()+ ? formatCompactCalendarTime(+ date,+ calendarView.displaySettings.timeFormat+ )+ : text+ }+ </FullCalendar.SlotLabelContent>++ <FullCalendar.EventContent>+ {(renderProps) => {+ const event = data.eventsById().get(renderProps.event.id);+ if (!event) return null;++ return (+ <CalendarEventContent+ event={event}+ renderProps={renderProps}+ isSelected={+ isActive() &&+ calendarView.eventState.selectedEventId === event.id+ }+ timeFormat={calendarView.displaySettings.timeFormat}+ isNarrow={calendarView.useNarrowDayHeaders()}+ />+ );+ }}+ </FullCalendar.EventContent>++ <FullCalendar.NowIndicatorContent>+ {({ isAxis, view }) => {+ if (isAxis) {+ return view.type === 'timeGridWeek' ? (+ <span+ aria-hidden="true"+ class="calendar-now-axis-indicator calendar-now-axis-indicator-gutter"+ />+ ) : null;+ }++ return (+ <CurrentTimeAxisIndicator+ date={new Date()}+ timeFormat={calendarView.displaySettings.timeFormat}+ />+ );+ }}+ </FullCalendar.NowIndicatorContent>++ <CalendarPageHost id={props.id} data={data} />+ </FullCalendar.Root>+ );+}++function CalendarPageHost(props: {+ id: CalendarPageId;+ data: CalendarPageData;+}) {+ const calendar = useFullCalendar();+ const pager = useCalendarPager();+ const calendarView = useCalendarView();+ const [element, setElement] = createSignal<HTMLDivElement>();+ const isActive = () => pager.isActive(props.id);++ useCalendarTimeGridHoverIndicator(() => (isActive() ? element() : undefined));++ onMount(() => {+ const unregister = pager.registerPage({+ id: props.id,+ api: calendar.api,+ dateInfo: calendar.dateInfo,+ element,+ data: props.data,+ });+ onCleanup(unregister);+ });++ createEffect(+ on(isActive, (active, wasActive) => {+ if (+ active &&+ wasActive === false &&+ props.data.occurrencesQuery.isSuccess &&+ props.data.occurrencesQuery.isStale &&+ !props.data.occurrencesQuery.isFetching &&+ !props.data.occurrencesQuery.isPlaceholderData+ ) {+ void props.data.occurrencesQuery.refetch();+ }+ })+ );++ createEffect(+ on(+ () =>+ [+ isActive(),+ calendarView.eventState.selectedEventId,+ props.data.occurrencesQuery.dataUpdatedAt,+ ] as const,+ ([active, selectedEventId]) => {+ if (+ !active ||+ !selectedEventId ||+ !props.data.occurrencesQuery.isSuccess ||+ props.data.occurrencesQuery.isPlaceholderData+ ) {+ return;+ }++ const selectedEvent = props.data.eventsById().get(selectedEventId);+ if (selectedEvent) calendarView.refreshSelectedEvent(selectedEvent);+ else calendarView.closeEventDetails();+ }+ )+ );++ return (+ <>+ <FullCalendar.Host+ tabIndex={-1}+ ref={setElement}+ class="calendar-view-host size-full min-w-0 min-h-0 overflow-hidden"+ />+ <CalendarScrollIndicators calendarElement={element} />+ <CalendarPageDataStatus data={props.data} />+ </>+ );+}diff --git a/apps/web/src/features/calendar/CalendarPagerContext.tsx b/apps/web/src/features/calendar/CalendarPagerContext.tsxnew file mode 100644index 0000000000..60b45d156d--- /dev/null+++ b/apps/web/src/features/calendar/CalendarPagerContext.tsx@@ -0,0 +1,315 @@+import { createAssertedContextProvider } from '@core/context/createContext';+import type { Calendar, DatesSetArg, EventInput } from '@fullcalendar/core';+import type {+ CalendarOccurrenceQueryRange,+ useCalendarOccurrencesQuery,+} from '@queries/calendar/occurrences';+import { createPager, type PagerController } from '@ui/components/Pager';+import {+ type Accessor,+ batch,+ createEffect,+ createMemo,+ createSignal,+ on,+ onCleanup,+} from 'solid-js';+import { useCalendarView } from './CalendarViewContext';+import type { CalendarEvent, CalendarPeriodView } from './events/types';++export const CALENDAR_PAGE_IDS = ['previous', 'current', 'next'] as const;+export type CalendarPageId = (typeof CALENDAR_PAGE_IDS)[number];++const TIME_GRID_SCROLLER_SELECTOR =+ '.fc-timegrid .fc-scroller-harness-liquid > .fc-scroller';++export interface CalendarPageData {+ range: Accessor<CalendarOccurrenceQueryRange | undefined>;+ occurrencesQuery: ReturnType<typeof useCalendarOccurrencesQuery>;+ events: Accessor<CalendarEvent[]>;+ eventsById: Accessor<Map<string, CalendarEvent>>;+ fullCalendarEvents: Accessor<EventInput[]>;+ isLoading: Accessor<boolean>;+ isSyncing: Accessor<boolean>;+}++export interface CalendarPageHandle {+ id: CalendarPageId;+ api: Accessor<Calendar | undefined>;+ dateInfo: Accessor<DatesSetArg | undefined>;+ element: Accessor<HTMLDivElement | undefined>;+ data: CalendarPageData;+}++const shiftedDateForView = (+ date: Date,+ view: CalendarPeriodView,+ offset: -1 | 1+) => {+ const shifted = new Date(date);+ if (view === 'dayGridMonth') {+ shifted.setDate(1);+ shifted.setMonth(shifted.getMonth() + offset);+ } else {+ shifted.setDate(+ shifted.getDate() + (view === 'timeGridDay' ? offset : offset * 7)+ );+ }+ return shifted;+};++export const [CalendarPagerContextProvider, useCalendarPager] =+ createAssertedContextProvider('CalendarPagerContext', () => {+ const calendarView = useCalendarView();++ const initialDate = new Date();+ const initialView = calendarView.displaySettings.periodView;+ const initialDates: Record<CalendarPageId, Date> = {+ previous: shiftedDateForView(initialDate, initialView, -1),+ current: initialDate,+ next: shiftedDateForView(initialDate, initialView, 1),+ };++ const [pageOrder, setPageOrder] =+ createSignal<readonly CalendarPageId[]>(CALENDAR_PAGE_IDS);++ const [activePageId, setActivePageId] =+ createSignal<CalendarPageId>('current');++ const [listenForPageRegistryChange, notifyPageRegistryChange] =+ createSignal<void>(undefined, { equals: false });++ const pageHandles = new Map<CalendarPageId, CalendarPageHandle>();++ const pageHandle = (id: CalendarPageId) => {+ listenForPageRegistryChange();+ return pageHandles.get(id);+ };++ const activePage = createMemo(() => pageHandle(activePageId()));+ const activeData = createMemo(() => activePage()?.data);+ const activeDateInfo = createMemo(() => activePage()?.dateInfo());++ const scrollElementFor = (handle: CalendarPageHandle | undefined) => {+ const element = handle?.element();+ if (!element) return undefined;++ return element.querySelector<HTMLElement>(TIME_GRID_SCROLLER_SELECTOR);+ };++ const copyActiveScrollPosition = () => {+ const activeScrollElement = scrollElementFor(activePage());+ if (!activeScrollElement) return;++ for (const id of pageOrder()) {+ if (id === activePageId()) continue;+ const scrollElement = scrollElementFor(pageHandle(id));+ if (!scrollElement) continue;++ scrollElement.scrollTop = activeScrollElement.scrollTop;+ }+ };++ const synchronizePage = (+ handle: CalendarPageHandle | undefined,+ source: CalendarPageHandle | undefined,+ direction: 'previous' | 'next'+ ) => {+ const api = handle?.api();+ const sourceApi = source?.api();+ if (!api || !sourceApi) return;++ const date = sourceApi.getDate();+ const view = sourceApi.view.type;+ api.batchRendering(() => {+ if (api.view.type === view) {+ api.gotoDate(date);+ } else {+ api.changeView(view, date);+ }++ if (direction === 'previous') {+ api.prev();+ } else {+ api.next();+ }+ });+ };++ const synchronizeBuffers = () => {+ const order = pageOrder();+ const activeIndex = order.indexOf(activePageId());+ const current = activePage();+ const previousId = order[activeIndex - 1];+ const nextId = order[activeIndex + 1];+ if (previousId) {+ synchronizePage(pageHandle(previousId), current, 'previous');+ }++ if (nextId) {+ synchronizePage(pageHandle(nextId), current, 'next');+ }++ requestAnimationFrame(copyActiveScrollPosition);+ };++ const rotatePages = (+ destination: CalendarPageId,+ direction: 'previous' | 'next'+ ) => {+ const order = pageOrder();+ const recycledId =+ direction === 'next' ? order[0] : order[order.length - 1];+ const nextOrder =+ direction === 'next'+ ? [...order.slice(1), order[0]]+ : [order[order.length - 1], ...order.slice(0, -1)];++ calendarView.closeEventDetails();+ batch(() => {+ setPageOrder(nextOrder);+ setActivePageId(() => destination);+ });++ const current = pageHandle(destination);+ synchronizePage(pageHandle(recycledId), current, direction);+ requestAnimationFrame(copyActiveScrollPosition);+ };++ const pager: PagerController<CalendarPageId> = createPager({+ pageOrder,+ activePage: activePageId,+ canChangePage: ({ to }) => pageHandle(to)?.api() !== undefined,+ onDragStart: copyActiveScrollPosition,+ onTransitionStart: () => {+ calendarView.closeEventDetails();+ copyActiveScrollPosition();+ },+ onPageChange: (destination, { direction }) =>+ rotatePages(destination, direction),+ });++ const registerPage = (handle: CalendarPageHandle) => {+ pageHandles.set(handle.id, handle);+ notifyPageRegistryChange();++ return () => {+ if (pageHandles.get(handle.id) !== handle) return;+ pageHandles.delete(handle.id);+ notifyPageRegistryChange();+ };+ };++ let settingsSyncFrame: number | undefined;+ createEffect(+ on(+ () => [+ calendarView.displaySettings.showWeekends,+ calendarView.displaySettings.weekStartsOn,+ ],+ (_settings, previousSettings) => {+ if (previousSettings === undefined) return;+ if (settingsSyncFrame !== undefined) {+ cancelAnimationFrame(settingsSyncFrame);+ }+ settingsSyncFrame = requestAnimationFrame(() => {+ settingsSyncFrame = undefined;+ synchronizeBuffers();+ });+ }+ )+ );+ onCleanup(() => {+ if (settingsSyncFrame !== undefined) {+ cancelAnimationFrame(settingsSyncFrame);+ }+ });++ const updateSize = () => {+ listenForPageRegistryChange();++ for (const handle of pageHandles.values()) {+ handle.api()?.updateSize();+ }+ };++ const gotoDate = (date: Date) => {+ pager.cancel();+ calendarView.closeEventDetails();+ activePage()?.api()?.gotoDate(date);+ synchronizeBuffers();+ };++ const navigateToDate = (date: Date) => {+ pager.cancel();++ const sourceApi = activePage()?.api();+ if (!sourceApi) return;++ if (+ date >= sourceApi.view.currentStart &&+ date < sourceApi.view.currentEnd+ ) {+ gotoDate(date);+ return;+ }++ const direction =+ date < sourceApi.view.currentStart ? 'previous' : 'next';+ const order = pageOrder();+ const activeIndex = order.indexOf(activePageId());+ const destinationId =+ direction === 'previous'+ ? order[activeIndex - 1]+ : order[activeIndex + 1];+ const destinationApi = destinationId+ ? pageHandle(destinationId)?.api()+ : undefined;++ if (!destinationApi) {+ gotoDate(date);+ return;+ }++ destinationApi.batchRendering(() => {+ if (destinationApi.view.type === sourceApi.view.type) {+ destinationApi.gotoDate(date);+ } else {+ destinationApi.changeView(sourceApi.view.type, date);+ }+ });++ const transition =+ direction === 'previous' ? pager.previous() : pager.next();+ void transition.then(synchronizeBuffers);+ };++ const changeView = (view: CalendarPeriodView) => {+ calendarView.setPeriodView(view);++ const api = activePage()?.api();+ if (!api || api.view.type === view) return;+ pager.cancel();+ calendarView.closeEventDetails();+ api.changeView(view);+ synchronizeBuffers();+ };++ return {+ pager,+ pageOrder,+ activePageId,+ activePage,+ activeData,+ activeDateInfo,+ visibleRange: () => activeData()?.range(),+ initialDateFor: (id: CalendarPageId) => initialDates[id],+ isActive: (id: CalendarPageId) => activePageId() === id,+ registerPage,+ updateSize,+ gotoDate,+ navigateToDate,+ navigateToToday: () => navigateToDate(new Date()),+ changeView,+ };+ });diff --git a/apps/web/src/features/calendar/CalendarPeriodSelector.tsx b/apps/web/src/features/calendar/CalendarPeriodSelector.tsxindex 00a46ae170..dd88dc5d49 100644--- a/apps/web/src/features/calendar/CalendarPeriodSelector.tsx+++ b/apps/web/src/features/calendar/CalendarPeriodSelector.tsx@@ -1,3 +1,4 @@+import { MobileDrawer } from '@components/app/mobile/MobileDrawer';import { useSidePanel } from '@components/app/side-panel/SidePanel';import CalendarIcon from '@phosphor/calendar-blank.svg';import CaretDownIcon from '@phosphor/caret-down.svg';@@ -6,20 +7,22 @@ import CheckIcon from '@phosphor/check.svg';import { Dropdown, Calendar as MiniCalendar } from '@ui';import { createMemo, For, Show } from 'solid-js';import { createStore } from 'solid-js/store';+import { useCalendarPager } from './CalendarPagerContext';import { useCalendarView } from './CalendarViewContext';-import { useFullCalendar } from './fullcalendar-solid';+import type { CalendarPeriodView } from './events/types';const CALENDAR_VIEWS = [{ value: 'dayGridMonth', label: 'Month' },{ value: 'timeGridWeek', label: 'Week' },{ value: 'timeGridDay', label: 'Day' },-];+] satisfies Array<{ value: CalendarPeriodView; label: string }>;-/** Selects the FullCalendar period and provides narrow custom-date navigation. */-export function CalendarPeriodSelector() {+const DRAWER_ROW_CLASS =+ "relative flex w-full items-center gap-3 bg-surface px-4 py-3 text-left text-sm text-ink not-last:after:absolute not-last:after:inset-x-2 not-last:after:bottom-0 not-last:after:h-px not-last:after:bg-edge-muted not-last:after:content-['']";++function createCalendarPeriodControls(onSelect?: () => void) {const calendarView = useCalendarView();- const calendar = useFullCalendar();- const sidePanel = useSidePanel();+ const calendarPager = useCalendarPager();const initialDate = new Date();const [pickerState, setPickerState] = createStore({open: false,@@ -27,34 +30,42 @@ export function CalendarPeriodSelector() {focusedDay: initialDate,});- const isNarrow = () => sidePanel?.isNarrow() ?? false;const currentDate = createMemo(- () => calendar.dateInfo()?.view.calendar.getDate() ?? initialDate+ () => calendarPager.activeDateInfo()?.view.calendar.getDate() ?? initialDate);- const activeView = createMemo(- () => calendar.dateInfo()?.view.type ?? 'timeGridWeek'+ const activeView = createMemo<CalendarPeriodView>(+ () =>+ (calendarPager.activeDateInfo()?.view.type as+ | CalendarPeriodView+ | undefined) ?? calendarView.displaySettings.periodView);const highlightedRange = createMemo(() => {- const dateInfo = calendar.dateInfo();+ const dateInfo = calendarPager.activeDateInfo();return dateInfo?.view.type === 'timeGridWeek'? { end: dateInfo.end, start: dateInfo.start }: undefined;});- const changeView = (view: string) => {- setPickerState('open', false);- const calendarApi = calendar.api();- if (calendarApi?.view.type === view) return;- calendarApi?.changeView(view);- };-const syncCustomDatePicker = () => {const date = currentDate();setPickerState({ month: date, focusedDay: date });};+ const setOpen = (open: boolean) => {+ if (open) syncCustomDatePicker();+ setPickerState('open', open);+ };++ const changeView = (view: CalendarPeriodView) => {+ setPickerState('open', false);+ onSelect?.();+ if (calendarPager.activeDateInfo()?.view.type === view) return;++ calendarPager.changeView(view);+ };+const navigateCustomDateMonth = (month: Date) => {const focusedDay = pickerState.focusedDay;const targetDate =@@ -67,29 +78,76 @@ export function CalendarPeriodSelector() {const selectCustomDate = (date: Date | null) => {if (!date) return;+setPickerState({ month: date, focusedDay: date, open: false });- calendar.api()?.gotoDate(date);+ calendarPager.gotoDate(date);+ onSelect?.();+ };++ return {+ activeView,+ calendarView,+ changeView,+ currentDate,+ highlightedRange,+ navigateCustomDateMonth,+ pickerState,+ selectCustomDate,+ setFocusedDay: (date: Date) => setPickerState('focusedDay', date),+ setOpen,+ syncCustomDatePicker,};+}++type CalendarPeriodControls = ReturnType<typeof createCalendarPeriodControls>;++function CustomDatePicker(props: { controls: CalendarPeriodControls }) {+ const controls = props.controls;++ return (+ <MiniCalendar+ required+ fixedWeeks+ startOfWeek={controls.calendarView.displaySettings.weekStartsOn}+ value={controls.currentDate()}+ month={controls.pickerState.month}+ focusedDay={controls.pickerState.focusedDay}+ highlightedRange={controls.highlightedRange()}+ onMonthChange={controls.navigateCustomDateMonth}+ onFocusedDayChange={controls.setFocusedDay}+ onValueChange={controls.selectCustomDate}+ />+ );+}++/** Desktop calendar period selector and custom-date dropdown. */+export function CalendarPeriodSelector() {+ const sidePanel = useSidePanel();+ const controls = createCalendarPeriodControls();+ const isNarrow = () => sidePanel?.isNarrow() ?? false;return (<Dropdown- open={pickerState.open}- onOpenChange={(open) => setPickerState('open', open)}+ open={controls.pickerState.open}+ onOpenChange={controls.setOpen}placement="bottom-end"><Dropdown.Triggerdepth={2}aria-label="Choose calendar view"size="sm"- class="shrink-0 gap-1 rounded-lg border-edge-muted bg-panel text-xs font-medium text-ink"+ class="shrink-0 gap-1 rounded-lg border-edge-muted text-xs font-medium text-ink">- {CALENDAR_VIEWS.find((view) => view.value === activeView())?.label ??- 'Week'}+ {CALENDAR_VIEWS.find((view) => view.value === controls.activeView())+ ?.label ?? 'Week'}<CaretDownIcon class="size-3 text-ink-muted" /></Dropdown.Trigger><Dropdown.Content class="min-w-36"><Dropdown.Group>- <Dropdown.RadioGroup value={activeView()} onChange={changeView}>+ <Dropdown.RadioGroup+ value={controls.activeView()}+ onChange={(view) => controls.changeView(view as CalendarPeriodView)}+ ><For each={CALENDAR_VIEWS}>{(view) => (<Dropdown.RadioItem closeOnSelect value={view.value}>@@ -104,11 +162,7 @@ export function CalendarPeriodSelector() {</Dropdown.Group><Show when={isNarrow()}><Dropdown.Group>- <Dropdown.Sub- onOpenChange={(open) => {- if (open) syncCustomDatePicker();- }}- >+ <Dropdown.Sub><Dropdown.SubTrigger><CalendarIcon class="size-3.5 text-ink-muted" /><span class="flex-1">Custom date…</span>@@ -116,20 +170,7 @@ export function CalendarPeriodSelector() {</Dropdown.SubTrigger><Dropdown.SubContent class="w-72 max-w-[calc(100vw-1rem)]"><Dropdown.Group class="p-3">- <MiniCalendar- required- fixedWeeks- startOfWeek={calendarView.displaySettings.weekStartsOn}- value={currentDate()}- month={pickerState.month}- focusedDay={pickerState.focusedDay}- highlightedRange={highlightedRange()}- onMonthChange={navigateCustomDateMonth}- onFocusedDayChange={(date) =>- setPickerState('focusedDay', date)- }- onValueChange={selectCustomDate}- />+ <CustomDatePicker controls={controls} /></Dropdown.Group></Dropdown.SubContent></Dropdown.Sub>@@ -139,3 +180,35 @@ export function CalendarPeriodSelector() {</Dropdown>);}++/** Period controls embedded in the mobile settings drawer. */+export function MobileCalendarPeriodControls(props: { onSelect: () => void }) {+ const controls = createCalendarPeriodControls(props.onSelect);++ return (+ <>+ <MobileDrawer.Label>Period</MobileDrawer.Label>+ <MobileDrawer.Section class="flex shrink-0 flex-col">+ <For each={CALENDAR_VIEWS}>+ {(view) => (+ <button+ type="button"+ class={DRAWER_ROW_CLASS}+ aria-pressed={controls.activeView() === view.value}+ onClick={() => controls.changeView(view.value)}+ >+ <span class="flex-1">{view.label}</span>+ <CheckIcon+ class="size-4 shrink-0 text-accent"+ classList={{+ invisible: controls.activeView() !== view.value,+ }}+ />+ </button>+ )}+ </For>+ </MobileDrawer.Section>+ <div class="mt-4" />+ </>+ );+}diff --git a/apps/web/src/features/calendar/CalendarRangeUnavailableBanner.tsx b/apps/web/src/features/calendar/CalendarRangeUnavailableBanner.tsxindex 08a882db6a..9e8153efbc 100644--- a/apps/web/src/features/calendar/CalendarRangeUnavailableBanner.tsx+++ b/apps/web/src/features/calendar/CalendarRangeUnavailableBanner.tsx@@ -1,14 +1,18 @@import InfoIcon from '@phosphor/info.svg';+import { cn } from '@ui';import { createMemo, Show } from 'solid-js';import { Transition } from 'solid-transition-group';-import { useCalendarView } from './CalendarViewContext';+import { useCalendarPager } from './CalendarPagerContext';import { isCalendarRangeSupported } from './calendar-supported-range';/** Announces when the visible viewport is outside backend occurrence coverage. */-export function CalendarRangeUnavailableBanner() {- const calendarView = useCalendarView();+export function CalendarRangeUnavailableBanner(props: {+ class?: string;+ fullWidth?: boolean;+}) {+ const calendarPager = useCalendarPager();const isUnavailable = createMemo(() => {- const range = calendarView.visibleRange();+ const range = calendarPager.visibleRange();return range !== undefined && !isCalendarRangeSupported(range);});@@ -23,11 +27,14 @@ export function CalendarRangeUnavailableBanner() {exitToClass="grid-rows-[0fr] -translate-y-2 opacity-0"><Show when={isUnavailable()}>- <div class="grid shrink-0">+ <div class={cn('grid shrink-0', props.class)}><div class="min-h-0 overflow-hidden"><divrole="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"+ class={cn(+ 'mb-2 flex items-center gap-2 border border-accent/30 bg-accent-bg px-3 py-2 text-xs text-ink-muted',+ props.fullWidth ? 'rounded-none' : 'mx-2 rounded-lg'+ )}><InfoIcon class="size-3.5 shrink-0 text-accent" /><span>Calendar events aren’t available for this date range.</span>diff --git a/apps/web/src/features/calendar/CalendarSettingsDropdown.tsx b/apps/web/src/features/calendar/CalendarSettingsDropdown.tsxindex 7a8ae275c7..dc43da48ee 100644--- a/apps/web/src/features/calendar/CalendarSettingsDropdown.tsx+++ b/apps/web/src/features/calendar/CalendarSettingsDropdown.tsx@@ -1,9 +1,12 @@+import { MobileDrawer } from '@components/app/mobile/MobileDrawer';import { useSidePanel } from '@components/app/side-panel/SidePanel';+import { isMobile } from '@core/mobile/isMobile';import CaretRightIcon from '@phosphor/caret-right.svg';import CheckIcon from '@phosphor/check.svg';import GearIcon from '@phosphor/gear.svg';-import { Dropdown } from '@ui';-import { createMemo, For, Show } from 'solid-js';+import { Button, Checkbox, Dropdown } from '@ui';+import { createMemo, createSignal, For, Show } from 'solid-js';+import { MobileCalendarPeriodControls } from './CalendarPeriodSelector';import { useCalendarView } from './CalendarViewContext';import type { CalendarTimeFormat, CalendarWeekStart } from './events/types';@@ -23,8 +26,7 @@ const TIME_FORMAT_OPTIONS: Array<{{ value: '24-hour', label: '24-hour' },];-/** Calendar display settings. */-export function CalendarSettingsDropdown() {+function createCalendarSettingsControls() {const calendarView = useCalendarView();const sidePanel = useSidePanel();@@ -65,6 +67,28 @@ export function CalendarSettingsDropdown() {calendarView.setTimeFormat(timeFormat);};+ return {+ calendarView,+ showCalendarVisibility,+ weekStartLabel,+ timeFormatLabel,+ changeSourceVisibility,+ changeShowWeekends,+ changeWeekStartsOn,+ changeTimeFormat,+ };+}++type CalendarSettingsControls = ReturnType<+ typeof createCalendarSettingsControls+>;++function DesktopCalendarSettings(props: {+ controls: CalendarSettingsControls;+}) {+ const controls = props.controls;+ const calendarView = controls.calendarView;+return (<Dropdown placement="bottom-end"><Dropdown.Trigger@@ -76,7 +100,7 @@ export function CalendarSettingsDropdown() {<GearIcon class="size-3.5" /></Dropdown.Trigger><Dropdown.Content class="w-60 max-w-[calc(100vw-1rem)]">- <Show when={showCalendarVisibility()}>+ <Show when={controls.showCalendarVisibility()}><Dropdown.Group><Dropdown.GroupLabel>Calendars</Dropdown.GroupLabel><For each={calendarView.sources()}>@@ -85,7 +109,7 @@ export function CalendarSettingsDropdown() {checked={calendarView.isSourceVisible(source.id)}closeOnSelect={false}onChange={(checked) =>- changeSourceVisibility(source.id, checked)+ controls.changeSourceVisibility(source.id, checked)}><span@@ -105,7 +129,7 @@ export function CalendarSettingsDropdown() {<Dropdown.CheckboxItemchecked={calendarView.displaySettings.showWeekends}closeOnSelect={false}- onChange={changeShowWeekends}+ onChange={controls.changeShowWeekends}><span class="flex-1 truncate">Show weekends</span></Dropdown.CheckboxItem>@@ -116,7 +140,7 @@ export function CalendarSettingsDropdown() {Week starts on</span><span class="text-sm font-medium text-ink">- {weekStartLabel()}+ {controls.weekStartLabel()}</span><CaretRightIcon class="size-3 shrink-0 text-ink-muted" /></Dropdown.SubTrigger>@@ -125,7 +149,9 @@ export function CalendarSettingsDropdown() {<Dropdown.RadioGroupvalue={String(calendarView.displaySettings.weekStartsOn)}onChange={(value) =>- changeWeekStartsOn(Number(value) as CalendarWeekStart)+ controls.changeWeekStartsOn(+ Number(value) as CalendarWeekStart+ )}><For each={WEEK_START_OPTIONS}>@@ -152,7 +178,7 @@ export function CalendarSettingsDropdown() {Time format</span><span class="text-sm font-medium text-ink">- {timeFormatLabel()}+ {controls.timeFormatLabel()}</span><CaretRightIcon class="size-3 shrink-0 text-ink-muted" /></Dropdown.SubTrigger>@@ -161,7 +187,7 @@ export function CalendarSettingsDropdown() {<Dropdown.RadioGroupvalue={calendarView.displaySettings.timeFormat}onChange={(value) =>- changeTimeFormat(value as CalendarTimeFormat)+ controls.changeTimeFormat(value as CalendarTimeFormat)}><For each={TIME_FORMAT_OPTIONS}>@@ -183,3 +209,149 @@ export function CalendarSettingsDropdown() {</Dropdown>);}++const DRAWER_ROW_CLASS =+ "relative flex w-full items-center gap-3 bg-surface px-4 py-3 text-left text-sm text-ink not-last:after:absolute not-last:after:inset-x-2 not-last:after:bottom-0 not-last:after:h-px not-last:after:bg-edge-muted not-last:after:content-['']";++function MobileCalendarSettings(props: { controls: CalendarSettingsControls }) {+ const controls = props.controls;+ const calendarView = controls.calendarView;+ const [open, setOpen] = createSignal(false);++ return (+ <MobileDrawer+ side="bottom"+ open={open()}+ onOpenChange={setOpen}+ preventScroll={false}+ preventScrollbarShift={false}+ >+ <MobileDrawer.Trigger+ as={Button}+ variant="ghost"+ size="icon-sm"+ class="shrink-0 rounded-full"+ aria-label="Calendar settings"+ >+ <GearIcon class="size-3.5" />+ </MobileDrawer.Trigger>++ <MobileDrawer.Portal>+ <MobileDrawer.Overlay class="fixed inset-0 z-modal-overlay bg-modal-overlay pattern-diagonal-4 pattern-edge-muted" />+ <MobileDrawer.Content+ aria-label="Calendar settings"+ class="overflow-y-auto"+ >+ <MobileDrawer.Handle />+ <MobileCalendarPeriodControls onSelect={() => setOpen(false)} />++ <Show when={controls.showCalendarVisibility()}>+ <MobileDrawer.Label>Calendars</MobileDrawer.Label>+ <MobileDrawer.Section class="flex shrink-0 flex-col">+ <For each={calendarView.sources()}>+ {(source) => (+ <Checkbox+ as="label"+ checked={calendarView.isSourceVisible(source.id)}+ onChange={(checked) =>+ controls.changeSourceVisibility(source.id, checked)+ }+ class={DRAWER_ROW_CLASS}+ >+ <span+ aria-hidden="true"+ class="size-2.5 shrink-0 rounded-sm"+ style={{ 'background-color': source.color }}+ />+ <span class="min-w-0 flex-1 truncate">{source.name}</span>+ <Checkbox.Control />+ </Checkbox>+ )}+ </For>+ </MobileDrawer.Section>+ <div class="mt-4" />+ </Show>++ <MobileDrawer.Label>Display</MobileDrawer.Label>+ <MobileDrawer.Section class="flex shrink-0 flex-col">+ <Checkbox+ as="label"+ checked={calendarView.displaySettings.showWeekends}+ onChange={controls.changeShowWeekends}+ class={DRAWER_ROW_CLASS}+ >+ <span class="min-w-0 flex-1 truncate">Show weekends</span>+ <Checkbox.Control />+ </Checkbox>+ </MobileDrawer.Section>++ <MobileDrawer.Label class="pt-4">Week starts on</MobileDrawer.Label>+ <MobileDrawer.Section class="flex shrink-0 flex-col">+ <For each={WEEK_START_OPTIONS}>+ {(option) => (+ <button+ type="button"+ class={DRAWER_ROW_CLASS}+ aria-pressed={+ calendarView.displaySettings.weekStartsOn === option.value+ }+ onClick={() => controls.changeWeekStartsOn(option.value)}+ >+ <span class="flex-1">{option.label}</span>+ <CheckIcon+ class="size-4 shrink-0 text-accent"+ classList={{+ invisible:+ calendarView.displaySettings.weekStartsOn !==+ option.value,+ }}+ />+ </button>+ )}+ </For>+ </MobileDrawer.Section>++ <MobileDrawer.Label class="pt-4">Time format</MobileDrawer.Label>+ <MobileDrawer.Section class="mb-3 flex shrink-0 flex-col">+ <For each={TIME_FORMAT_OPTIONS}>+ {(option) => (+ <button+ type="button"+ class={DRAWER_ROW_CLASS}+ aria-pressed={+ calendarView.displaySettings.timeFormat === option.value+ }+ onClick={() => controls.changeTimeFormat(option.value)}+ >+ <span class="flex-1">{option.label}</span>+ <CheckIcon+ class="size-4 shrink-0 text-accent"+ classList={{+ invisible:+ calendarView.displaySettings.timeFormat !==+ option.value,+ }}+ />+ </button>+ )}+ </For>+ </MobileDrawer.Section>+ </MobileDrawer.Content>+ </MobileDrawer.Portal>+ </MobileDrawer>+ );+}++/** Responsive calendar display settings menu. */+export function CalendarSettingsDropdown() {+ const controls = createCalendarSettingsControls();++ return (+ <Show+ when={isMobile()}+ fallback={<DesktopCalendarSettings controls={controls} />}+ >+ <MobileCalendarSettings controls={controls} />+ </Show>+ );+}diff --git a/apps/web/src/features/calendar/CalendarSetupStatus.tsx b/apps/web/src/features/calendar/CalendarSetupStatus.tsxnew file mode 100644index 0000000000..3c0df78a71--- /dev/null+++ b/apps/web/src/features/calendar/CalendarSetupStatus.tsx@@ -0,0 +1,111 @@+import { useAddInboxFlow } from '@core/email-link';+import { useEmailLinksQuery } from '@queries/email/link';+import { Button } from '@ui';+import { createMemo, Show } from 'solid-js';+import { useCalendarPager } from './CalendarPagerContext';+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 account setup actions above the complete calendar pager. */+export function CalendarSetupStatus() {+ const calendarPager = useCalendarPager();+ const linksQuery = useEmailLinksQuery();+ const startAddInbox = useAddInboxFlow();++ const hasEvents = () =>+ (calendarPager.activeData()?.events().length ?? 0) > 0;++ // Existing events are not evidence that setup is complete: a revoked grant+ // or delegated inbox can leave events visible without a working calendar+ // connection belonging to the current user.+ const setupState = createMemo<+ 'connect' | 'permission' | 'reauth' | undefined+ >(() => {+ const activeData = calendarPager.activeData();+ const range = activeData?.range();+ if (range && !isCalendarRangeSupported(range)) return undefined;++ if (!linksQuery.isSuccess || !activeData?.occurrencesQuery.isSuccess) {+ 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']+ );++ return (+ <Show when={setupState() !== undefined}>+ <Show+ when={!hasEvents()}+ fallback={+ <div class="absolute right-2 bottom-2 z-20 flex items-center gap-2 rounded-full border border-edge-muted bg-surface py-1 pr-1 pl-2.5 text-xs text-ink-muted shadow-menu">+ <span>{setupMessage().title}</span>+ <Button+ variant="active"+ size="sm"+ label={setupMessage().action}+ onClick={() => void startAddInbox()}+ >+ {setupMessage().action}+ </Button>+ </div>+ }+ >+ <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">+ {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>+ </Show>+ </Show>+ );+}diff --git a/apps/web/src/features/calendar/CalendarSidePanelSections.tsx b/apps/web/src/features/calendar/CalendarSidePanelSections.tsxindex d5af69f858..45b82f8dc9 100644--- a/apps/web/src/features/calendar/CalendarSidePanelSections.tsx+++ b/apps/web/src/features/calendar/CalendarSidePanelSections.tsx@@ -1,22 +1,22 @@import { SidePanel, useSidePanel } from '@components/app/side-panel/SidePanel';import { Calendar as MiniCalendar } from '@ui';import { createEffect, createMemo, createSignal, on, Show } from 'solid-js';+import { useCalendarPager } from './CalendarPagerContext';import { useCalendarView } from './CalendarViewContext';import { CalendarControls } from './events/CalendarControls';-import { useFullCalendar } from './fullcalendar-solid';function CalendarMiniCalendarSidePanelSection() {const calendarView = useCalendarView();- const calendar = useFullCalendar();+ const calendarPager = useCalendarPager();const initialDate = new Date();const [focusedDay, setFocusedDay] = createSignal(initialDate);const currentDate = createMemo(- () => calendar.dateInfo()?.view.calendar.getDate() ?? initialDate+ () => calendarPager.activeDateInfo()?.view.calendar.getDate() ?? initialDate);const highlightedRange = createMemo(() => {- const dateInfo = calendar.dateInfo();+ const dateInfo = calendarPager.activeDateInfo();return dateInfo?.view.type === 'timeGridWeek'? { end: dateInfo.end, start: dateInfo.start }: undefined;@@ -25,7 +25,7 @@ function CalendarMiniCalendarSidePanelSection() {const selectDate = (date: Date | null) => {if (!date) return;setFocusedDay(date);- calendar.api()?.gotoDate(date);+ calendarPager.gotoDate(date);};const navigateMonth = (month: Date) => {@@ -36,7 +36,7 @@ function CalendarMiniCalendarSidePanelSection() {? focused: month;setFocusedDay(targetDate);- calendar.api()?.gotoDate(targetDate);+ calendarPager.gotoDate(targetDate);};createEffect(on(currentDate, setFocusedDay));diff --git a/apps/web/src/features/calendar/CalendarViewContext.tsx b/apps/web/src/features/calendar/CalendarViewContext.tsxindex cca2ae7a94..0b39c99ded 100644--- a/apps/web/src/features/calendar/CalendarViewContext.tsx+++ b/apps/web/src/features/calendar/CalendarViewContext.tsx@@ -1,177 +1,147 @@import { createAssertedContextProvider } from '@core/context/createContext';-import { useUserId } from '@core/context/user';-import {- type CalendarOccurrenceQueryRange,- createCalendarOccurrenceQueryRange,- useCalendarOccurrencesQuery,-} from '@queries/calendar/occurrences';-import { CalendarSyncStatus } from '@service-storage/generated/schemas/calendarSyncStatus';-import { batch, createEffect, createMemo, createSignal, on } from 'solid-js';+import { isMobile } from '@core/mobile/isMobile';+import { makePersisted } from '@solid-primitives/storage';+import { batch, createSignal } 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 { CalendarTimeFormat, CalendarWeekStart } from './events/types';+import { DEFAULT_CALENDAR_SOURCE } from './events/calendar-occurrence-mapper';+import type {+ CalendarEvent,+ CalendarPeriodView,+ CalendarTimeFormat,+ CalendarWeekStart,+} from './events/types';import { getDefaultCalendarTimeFormat } from './time-format';interface CalendarEventState {- visibleSourceIds: string[];- selectedEventId: string | undefined;+ readonly visibleSourceIds: string[];+ readonly selectedEventId: string | undefined;}interface CalendarDisplaySettings {+ readonly periodView: CalendarPeriodView;+ readonly showWeekends: boolean;+ readonly weekStartsOn: CalendarWeekStart;+ readonly timeFormat: CalendarTimeFormat;+}++interface CalendarPreferences {+ periodView: CalendarPeriodView;+ hiddenSourceIds: string[];showWeekends: boolean;weekStartsOn: CalendarWeekStart;timeFormat: CalendarTimeFormat;}+const CALENDAR_PREFERENCES_KEY = 'macro:pref:calendar:settings';const CALENDAR_SOURCES = [DEFAULT_CALENDAR_SOURCE];export const [CalendarViewContextProvider, useCalendarView] =createAssertedContextProvider('CalendarViewContext', () => {- const userId = useUserId();- const [visibleRange, setVisibleRange] =- createSignal<CalendarOccurrenceQueryRange>();- const [eventState, setEventState] = createStore<CalendarEventState>({- visibleSourceIds: CALENDAR_SOURCES.map((source) => source.id),- selectedEventId: undefined,- });-- const [displaySettings, setDisplaySettings] =- createStore<CalendarDisplaySettings>({- showWeekends: true,- weekStartsOn: 0,- timeFormat: getDefaultCalendarTimeFormat(),- });+ const defaultPreferences: CalendarPreferences = {+ periodView: isMobile() ? 'timeGridDay' : 'timeGridWeek',+ hiddenSourceIds: [],+ showWeekends: true,+ weekStartsOn: 0,+ timeFormat: getDefaultCalendarTimeFormat(),+ };+ const [preferences, setPreferences] = makePersisted(+ createStore<CalendarPreferences>(defaultPreferences),+ {+ name: CALENDAR_PREFERENCES_KEY,+ deserialize: (value) => ({+ ...defaultPreferences,+ ...(JSON.parse(value) as Partial<CalendarPreferences>),+ }),+ }+ );+ const [selectedEventId, setSelectedEventId] = createSignal<string>();+ const eventState: CalendarEventState = {+ get visibleSourceIds() {+ const hiddenSourceIds = preferences.hiddenSourceIds;+ return CALENDAR_SOURCES.filter(+ (source) => !hiddenSourceIds.includes(source.id)+ ).map((source) => source.id);+ },+ get selectedEventId() {+ return selectedEventId();+ },+ };+ const displaySettings: CalendarDisplaySettings = {+ get periodView() {+ return preferences.periodView;+ },+ get showWeekends() {+ return preferences.showWeekends;+ },+ get weekStartsOn() {+ return preferences.weekStartsOn;+ },+ get timeFormat() {+ return preferences.timeFormat;+ },+ };+ const [selectedEvent, setSelectedEvent] = createSignal<CalendarEvent>();const [selectedEventAnchor, setSelectedEventAnchor] =createSignal<HTMLElement>();const [useNarrowDayHeaders, setUseNarrowDayHeaders] = createSignal(false);- 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]))- );- const selectedEvent = createMemo(() => {- const eventId = eventState.selectedEventId;- return eventId ? eventsById().get(eventId) : undefined;- });- const fullCalendarEvents = createMemo(() =>- visibleEvents().map(mapCalendarEventToFullCalendar)- );- const isLoading = () =>- visibleRange() === undefined ||- (isVisibleRangeSupported() && occurrencesQuery.isPending);- const isSyncing = () =>- occurrencesQuery.data?.syncStatus === CalendarSyncStatus.syncing;-const closeEventDetails = () => {batch(() => {- setEventState('selectedEventId', undefined);+ setSelectedEventId(undefined);+ setSelectedEvent(undefined);setSelectedEventAnchor(undefined);});};- createEffect(- on(- () =>- [eventState.selectedEventId, occurrencesQuery.dataUpdatedAt] as const,- ([selectedEventId]) => {- if (- selectedEventId &&- occurrencesQuery.isSuccess &&- !eventsById().has(selectedEventId)- ) {- closeEventDetails();- }- }- )- );-- const updateVisibleRange = (start: Date, end: Date) => {- const nextRange = createCalendarOccurrenceQueryRange(start, end);- const currentRange = visibleRange();-- 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) => {- setEventState('visibleSourceIds', (current) => {- if (visible) {- return current.includes(sourceId) ? current : [...current, sourceId];- }-- return current.filter((id) => id !== sourceId);- });+ setPreferences('hiddenSourceIds', (current) =>+ visible+ ? current.filter((id) => id !== sourceId)+ : current.includes(sourceId)+ ? current+ : [...current, sourceId]+ );if (!visible && selectedEvent()?.calendar.id === sourceId) {closeEventDetails();}};- const selectEvent = (eventId: string, anchor: HTMLElement) => {+ const selectEvent = (event: CalendarEvent, anchor: HTMLElement) => {batch(() => {- setEventState('selectedEventId', eventId);+ setSelectedEventId(event.id);+ setSelectedEvent(() => event);setSelectedEventAnchor(anchor);});};+ const refreshSelectedEvent = (event: CalendarEvent) => {+ if (eventState.selectedEventId !== event.id) return;+ setSelectedEvent(event);+ };+return {eventState,displaySettings,- visibleRange,- updateVisibleRange,- occurrencesQuery,- events,sources: () => CALENDAR_SOURCES,isSourceVisible: (sourceId: string) =>eventState.visibleSourceIds.includes(sourceId),setSourceVisibility,- eventsById,selectedEvent,- fullCalendarEvents,- isLoading,- isSyncing,selectedEventAnchor,useNarrowDayHeaders,setUseNarrowDayHeaders,+ setPeriodView: (periodView: CalendarPeriodView) =>+ setPreferences('periodView', periodView),setShowWeekends: (showWeekends: boolean) =>- setDisplaySettings('showWeekends', showWeekends),+ setPreferences('showWeekends', showWeekends),setWeekStartsOn: (weekStartsOn: CalendarWeekStart) =>- setDisplaySettings('weekStartsOn', weekStartsOn),+ setPreferences('weekStartsOn', weekStartsOn),setTimeFormat: (timeFormat: CalendarTimeFormat) =>- setDisplaySettings('timeFormat', timeFormat),+ setPreferences('timeFormat', timeFormat),closeEventDetails,selectEvent,+ refreshSelectedEvent,};});diff --git a/apps/web/src/features/calendar/calendar-view.tsx b/apps/web/src/features/calendar/calendar-view.tsxindex e1adaf5878..ed24efe76a 100644--- a/apps/web/src/features/calendar/calendar-view.tsx+++ b/apps/web/src/features/calendar/calendar-view.tsx@@ -5,367 +5,139 @@ import {SplitHeaderRight,} from '@components/app/split-layout/components/SplitHeader';import { useSplitPanelOrThrow } from '@components/app/split-layout/layoutUtils';-import { ScrollIndicators } from '@core/component/VerticalScrollIndicators';-import type { DatesSetArg } from '@fullcalendar/core';-import dayGridPlugin from '@fullcalendar/daygrid';-import interactionPlugin from '@fullcalendar/interaction';-import timeGridPlugin from '@fullcalendar/timegrid';+import { isMobile } from '@core/mobile/isMobile';+import CalendarBlankIcon from '@phosphor/calendar-blank.svg';import CaretLeftIcon from '@phosphor/caret-left.svg';import CaretRightIcon from '@phosphor/caret-right.svg';+import { createResizeObserver } from '@solid-primitives/resize-observer';import { Button, Layer } from '@ui';+import { Pager, PagerSwipeGestures, usePager } from '@ui/components/Pager';import {- type Accessor,- createEffect,createMemo,createSignal,- on,+ For,onCleanup,onMount,Show,+ Suspense,} from 'solid-js';-import { Portal } from 'solid-js/web';-import { CalendarDataStatus } from './CalendarDataStatus';+import { CalendarMonthDrawer } from './CalendarMonthDrawer';+import { CalendarPage } from './CalendarPage';+import {+ CALENDAR_PAGE_IDS,+ type CalendarPageId,+ CalendarPagerContextProvider,+ useCalendarPager,+} from './CalendarPagerContext';import { CalendarPeriodSelector } from './CalendarPeriodSelector';import { CalendarRangeUnavailableBanner } from './CalendarRangeUnavailableBanner';import { CalendarSettingsDropdown } from './CalendarSettingsDropdown';+import { CalendarSetupStatus } from './CalendarSetupStatus';import { CalendarSidePanelSections } from './CalendarSidePanelSections';import {CalendarViewContextProvider,useCalendarView,} from './CalendarViewContext';-import { CalendarEventContent } from './events/EventContent';-import { SelectedEventDetailsPopover } from './events/EventDetailsPopover';-import type { CalendarTimeFormat } from './events/types';-import { FullCalendar, useFullCalendar } from './fullcalendar-solid';-import {- CALENDAR_TIME_FORMAT_OPTIONS,- formatCalendarTime,- formatCompactCalendarTime,-} from './time-format';-import { useCalendarTimeGridHoverIndicator } from './useCalendarTimeGridHoverIndicator';+import { SelectedEventDetails } from './events/EventDetailsPopover';import './calendar.css';+const CALENDAR_SWIPE_EDGE_INSET = 40;+const formatMonthTitle = new Intl.DateTimeFormat(undefined, {month: 'long',year: 'numeric',}).format;-const formatWeekdayHeader = {- narrow: new Intl.DateTimeFormat(undefined, {- weekday: 'narrow',- }).format,- short: new Intl.DateTimeFormat(undefined, {- weekday: 'short',- }).format,-};--const formatDayNumber = new Intl.DateTimeFormat(undefined, {- day: 'numeric',-}).format;--const isSameLocalDate = (first: Date, second: Date) =>- first.getFullYear() === second.getFullYear() &&- first.getMonth() === second.getMonth() &&- first.getDate() === second.getDate();--function CurrentTimeAxisIndicator(props: {- date: Date;- timeFormat: CalendarTimeFormat;-}) {+/** A calendar-focused workspace view backed by buffered FullCalendar pages. */+export function CalendarView() {return (- <span class="calendar-now-axis-indicator">- <span class="calendar-now-time">- {formatCalendarTime(props.date, props.timeFormat)}- </span>- </span>- );-}--function getLocalScrollTime() {- const now = new Date();- const minutesSinceMidnight = now.getHours() * 60 + now.getMinutes();- const scrollMinutes = Math.max(- 0,- Math.floor((minutesSinceMidnight - 60) / 30) * 30+ <CalendarViewContextProvider>+ <CalendarPagerContextProvider>+ <CalendarPagerRoot />+ </CalendarPagerContextProvider>+ </CalendarViewContextProvider>);- const hours = Math.floor(scrollMinutes / 60);- const minutes = scrollMinutes % 60;-- return `${String(hours).padStart(2, '0')}:${String(minutes).padStart(2, '0')}:00`;}-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 = element.querySelector<HTMLElement>(- '.fc-timegrid .fc-scroller-harness-liquid > .fc-scroller'- );- 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);- });- })- );+function CalendarPagerRoot() {+ const calendarPager = useCalendarPager();return (- <Show keyed when={target()}>- {(scrollTarget) => (- <Portal- mount={scrollTarget.fadeContainer}- ref={(container) => {- container.style.display = 'contents';- }}- >- <ScrollIndicators- scrollRef={() => scrollTarget.scrollElement}- appearance="gradient"- class="h-6"- />- </Portal>- )}- </Show>+ <Pager.Root controller={calendarPager.pager}>+ <SidePanel.Layout>+ <CalendarWorkspace />+ </SidePanel.Layout>+ </Pager.Root>);}-function ResponsiveCalendarHost() {- const calendar = useFullCalendar();+function CalendarPages() {+ const calendarPager = useCalendarPager();const calendarView = useCalendarView();- const [element, setElement] = createSignal<HTMLDivElement>();-- useCalendarTimeGridHoverIndicator(element);-- createEffect(- on(- () => [element(), calendar.api()] as const,- ([calendarElement, calendarApi]) => {- if (!calendarElement || !calendarApi) return;-- let observedWidth = calendarElement.clientWidth;- let resizeFrame: number | undefined;- const resizeObserver = new ResizeObserver(([entry]) => {- observedWidth =- entry?.contentRect.width ?? calendarElement.clientWidth;+ const [viewport, setViewport] = createSignal<HTMLDivElement>();+ let resizeFrame: number | undefined;- if (resizeFrame !== undefined) cancelAnimationFrame(resizeFrame);+ createResizeObserver(viewport, ({ width }) => {+ if (resizeFrame !== undefined) cancelAnimationFrame(resizeFrame);- resizeFrame = requestAnimationFrame(() => {- resizeFrame = undefined;- calendarView.setUseNarrowDayHeaders(observedWidth < 520);- calendarApi.updateSize();- });- });-- resizeObserver.observe(calendarElement);-- onCleanup(() => {- resizeObserver.disconnect();+ resizeFrame = requestAnimationFrame(() => {+ resizeFrame = undefined;+ calendarView.setUseNarrowDayHeaders(width < 520);+ calendarPager.updateSize();+ });+ });- if (resizeFrame !== undefined) cancelAnimationFrame(resizeFrame);- });- }- )- );+ onCleanup(() => {+ if (resizeFrame !== undefined) cancelAnimationFrame(resizeFrame);+ });return (<Layer depth={2}><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"- />- <CalendarScrollIndicators calendarElement={element} />- <CalendarDataStatus />+ <CalendarRangeUnavailableBanner+ class={isMobile() ? 'order-last' : undefined}+ fullWidth={isMobile()}+ />+ <div+ ref={setViewport}+ class="relative flex min-w-0 min-h-0 flex-1"+ role="region"+ aria-label="Calendar periods"+ >+ <Pager.Viewport class="size-full min-w-0 min-h-0">+ <For each={CALENDAR_PAGE_IDS}>+ {(pageId) => (+ <Pager.Page id={pageId}>+ <Suspense>+ <CalendarPage+ id={pageId}+ initialDate={calendarPager.initialDateFor(pageId)}+ />+ </Suspense>+ </Pager.Page>+ )}+ </For>+ </Pager.Viewport>+ <Show when={isMobile()}>+ <PagerSwipeGestures+ edgeInset={CALENDAR_SWIPE_EDGE_INSET}+ canStart={(event) =>+ !(+ event.target instanceof Element &&+ event.target.closest(+ 'button, input, select, textarea, [role="button"]'+ )+ )+ }+ />+ </Show>+ <CalendarSetupStatus /></div></div></Layer>);}-/** A calendar-focused workspace view backed by FullCalendar. */-export function CalendarView() {- return (- <CalendarViewContextProvider>- <CalendarViewContent />- </CalendarViewContextProvider>- );-}--function CalendarViewContent() {- const calendarView = useCalendarView();-- const handleDatesSet = ({ end, start }: DatesSetArg) => {- calendarView.updateVisibleRange(start, end);- };-- return (- <FullCalendar.Root- plugins={[dayGridPlugin, interactionPlugin, timeGridPlugin]}- initialView="timeGridWeek"- height="100%"- expandRows- fixedWeekCount={false}- handleWindowResize={false}- allDayText="All day"- nowIndicator- headerToolbar={false}- scrollTime={getLocalScrollTime()}- scrollTimeReset={false}- weekends={calendarView.displaySettings.showWeekends}- firstDay={calendarView.displaySettings.weekStartsOn}- slotLabelFormat={- CALENDAR_TIME_FORMAT_OPTIONS[calendarView.displaySettings.timeFormat]- }- eventTimeFormat={- CALENDAR_TIME_FORMAT_OPTIONS[calendarView.displaySettings.timeFormat]- }- events={calendarView.fullCalendarEvents()}- eventClick={({ el, event, jsEvent }) => {- jsEvent.preventDefault();- calendarView.selectEvent(event.id, el);- }}- datesSet={handleDatesSet}- dayHeaderFormat={{- weekday: calendarView.useNarrowDayHeaders() ? 'narrow' : 'short',- }}- dayCellClassNames={({ date, view }) =>- isSameLocalDate(date, view.calendar.getDate())- ? ['calendar-day-selected']- : []- }- >- <FullCalendar.DayHeaderContent>- {({ date, text, view }) => {- if (view.type === 'timeGridWeek' || view.type === 'timeGridDay') {- const weekday =- view.type === 'timeGridDay'- ? formatWeekdayHeader.short(date)- : formatWeekdayHeader[- calendarView.useNarrowDayHeaders() ? 'narrow' : 'short'- ](date);-- return (- <>- <span class="calendar-day-header-weekday">{weekday}</span>{' '}- <span- class="calendar-day-header-date"- classList={{- 'calendar-day-header-date-selected': isSameLocalDate(- date,- view.calendar.getDate()- ),- }}- >- {formatDayNumber(date)}- </span>- </>- );- }- return text;- }}- </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}- isSelected={calendarView.eventState.selectedEventId === event.id}- timeFormat={calendarView.displaySettings.timeFormat}- isNarrow={calendarView.useNarrowDayHeaders()}- />- );- }}- </FullCalendar.EventContent>-- <FullCalendar.NowIndicatorContent>- {({ isAxis, view }) => {- if (isAxis) {- return view.type === 'timeGridWeek' ? (- <span- aria-hidden="true"- class="calendar-now-axis-indicator calendar-now-axis-indicator-gutter"- />- ) : null;- }-- return (- <CurrentTimeAxisIndicator- date={new Date()}- timeFormat={calendarView.displaySettings.timeFormat}- />- );- }}- </FullCalendar.NowIndicatorContent>-- <SidePanel.Layout>- <CalendarWorkspace />- </SidePanel.Layout>- </FullCalendar.Root>- );-}-function createLocalToday() {const [today, setToday] = createSignal(new Date());let refreshTimer: number | undefined;@@ -396,17 +168,18 @@ function createLocalToday() {function CalendarWorkspace() {const panel = useSplitPanelOrThrow();- const calendar = useFullCalendar();+ const calendarPager = useCalendarPager();+ const pager = usePager<CalendarPageId>();const calendarView = useCalendarView();const initialDate = new Date();const today = createLocalToday();const currentDate = createMemo(- () => calendar.dateInfo()?.view.calendar.getDate() ?? initialDate+ () => calendarPager.activeDateInfo()?.view.calendar.getDate() ?? initialDate);const dateTitle = createMemo(() => formatMonthTitle(currentDate()));const visibleRange = createMemo(() => {- const dateInfo = calendar.dateInfo();+ const dateInfo = calendarPager.activeDateInfo();return dateInfo ? { end: dateInfo.end, start: dateInfo.start } : undefined;});const isTodayVisible = createMemo(() => {@@ -423,50 +196,78 @@ function CalendarWorkspace() {<><SplitHeaderLeft><HeaderIsland class="shrink">- <div class="flex min-w-0 items-center gap-2">- <span class="min-w-0 truncate text-base font-semibold text-ink">- {dateTitle()}- </span>- <Show when={!isTodayVisible()}>- <Button- variant="active"- size="sm"- class="rounded-lg px-3"- depth={2}- label="Go to today"- onClick={() => calendar.api()?.today()}- >- Today- </Button>- </Show>- </div>+ <Show+ when={isMobile()}+ fallback={+ <span class="min-w-0 truncate text-base font-semibold text-ink">+ {dateTitle()}+ </span>+ }+ >+ <CalendarMonthDrawer month={currentDate()} />+ </Show></HeaderIsland></SplitHeaderLeft><SplitHeaderRight><HeaderIsland class="px-1"><div class="flex items-center gap-1">- <CalendarPeriodSelector />- <div class="flex shrink-0 items-center gap-1">+ <Show+ when={isMobile()}+ fallback={+ <Show when={!isTodayVisible()}>+ <Button+ variant="active"+ size="sm"+ class="rounded-lg px-3"+ depth={2}+ label="Go to today"+ onClick={calendarPager.navigateToToday}+ >+ Today+ </Button>+ </Show>+ }+ ><Buttonvariant="ghost"size="icon-sm"- class="rounded-lg"- label="Previous period"- onClick={() => calendar.api()?.prev()}- >- <CaretLeftIcon class="size-4" />- </Button>- <Button- variant="ghost"- size="icon-sm"- class="rounded-lg"- label="Next period"- onClick={() => calendar.api()?.next()}+ class="rounded-full"+ label="Go to today"+ onClick={calendarPager.navigateToToday}>- <CaretRightIcon class="size-4" />+ <CalendarBlankIcon aria-hidden="true" />+ <span+ aria-hidden="true"+ class="pointer-events-none absolute inset-0 flex items-center justify-center pt-1 text-[8px] font-bold leading-none"+ >+ {today().getDate()}+ </span></Button>- </div>+ </Show>+ <Show when={!isMobile()}>+ <CalendarPeriodSelector />+ <div class="flex shrink-0 items-center gap-1">+ <Button+ variant="ghost"+ size="icon-sm"+ class="rounded-lg"+ label="Previous period"+ onClick={() => void pager.previous()}+ >+ <CaretLeftIcon class="size-4" />+ </Button>+ <Button+ variant="ghost"+ size="icon-sm"+ class="rounded-lg"+ label="Next period"+ onClick={() => void pager.next()}+ >+ <CaretRightIcon class="size-4" />+ </Button>+ </div>+ </Show><CalendarSettingsDropdown /></div></HeaderIsland>@@ -474,7 +275,7 @@ function CalendarWorkspace() {<CalendarSidePanelSections />- <SelectedEventDetailsPopover+ <SelectedEventDetailsanchor={calendarView.selectedEventAnchor}event={calendarView.selectedEvent}timeFormat={() => calendarView.displaySettings.timeFormat}@@ -483,7 +284,7 @@ function CalendarWorkspace() {<main class="calendar-view flex size-full min-h-0"><div class="calendar-view-content flex min-w-0 min-h-0 flex-1 flex-col">- <ResponsiveCalendarHost />+ <CalendarPages /></div></main></>diff --git a/apps/web/src/features/calendar/calendar.css b/apps/web/src/features/calendar/calendar.cssindex 9887d21ef6..4042093d3f 100644--- a/apps/web/src/features/calendar/calendar.css+++ b/apps/web/src/features/calendar/calendar.css@@ -29,7 +29,6 @@}.calendar-view .fc .fc-view-harness {- border-radius: 0.75rem;overflow: hidden;}diff --git a/apps/web/src/features/calendar/events/EventDetails.tsx b/apps/web/src/features/calendar/events/EventDetails.tsxindex 7be950a0f2..9c7db41353 100644--- a/apps/web/src/features/calendar/events/EventDetails.tsx+++ b/apps/web/src/features/calendar/events/EventDetails.tsx@@ -1,6 +1,10 @@import { UserIcon, type UserIconProps } from '@core/component/UserIcon';import { ScrollIndicators } from '@core/component/VerticalScrollIndicators';-import { emailToMacroId, useDisplayName } from '@core/user';+import {+ emailToMacroId,+ getInitialsFromName,+ useDisplayName,+} from '@core/user';import { plural } from '@core/util/string';import { openExternalUrl } from '@core/util/url';import { Collapsible } from '@kobalte/core/collapsible';@@ -17,8 +21,15 @@ import VideoCameraIcon from '@phosphor/video-camera.svg';import XIcon from '@phosphor/x.svg';import type { AttendeeResponseStatus } from '@service-storage/generated/schemas/attendeeResponseStatus';import type { CalendarAttendee } from '@service-storage/generated/schemas/calendarAttendee';-import { Button } from '@ui';-import { type Accessor, createMemo, createSignal, For, Show } from 'solid-js';+import { Avatar, Button } from '@ui';+import {+ type Accessor,+ createMemo,+ createSignal,+ For,+ type JSX,+ Show,+} from 'solid-js';import { Dynamic } from 'solid-js/web';import {CALENDAR_TIME_FORMAT_OPTIONS,@@ -92,65 +103,108 @@ function resolveCalendarAttendee(return { attendee, displayName, iconProps };}-function CalendarAttendeeItem(props: { item: ResolvedCalendarAttendee }) {- const response =- props.item.attendee.responseStatus === 'needs_action'- ? undefined- : ATTENDEE_RESPONSE[props.item.attendee.responseStatus];- const hasSecondaryLabel =- props.item.attendee.isOrganizer || props.item.attendee.isOptional;+function CalendarUserItem(props: {+ displayName: Accessor<string>;+ iconProps?: UserIconProps;+ isSelf: boolean;+ secondaryLabel?: JSX.Element;+ secondaryLabelPosition?: 'above' | 'below';+ details?: JSX.Element;+ trailing?: JSX.Element;+}) {+ const secondaryLabelPosition = () => props.secondaryLabelPosition ?? 'below';return (<div class="flex min-w-0 items-center gap-3">- <UserIcon- {...props.item.iconProps}- isDeleted={false}- size="md"- suppressClick- showTooltip={false}- />+ <Show+ keyed+ when={props.iconProps}+ fallback={+ <Avatar size="md">+ <Avatar.Fallback class="font-semibold">+ {getInitialsFromName(props.displayName(), '')}+ </Avatar.Fallback>+ </Avatar>+ }+ >+ {(iconProps) => (+ <UserIcon+ {...iconProps}+ isDeleted={false}+ size="md"+ suppressClick+ showTooltip={false}+ />+ )}+ </Show><div class="min-w-0 flex-1">- <div class="min-w-0">- <span class="block select-text truncate text-ink-muted">- {props.item.displayName()}- <Show when={props.item.attendee.isSelf}> (you)</Show>- </span>- </div>- <Show when={hasSecondaryLabel}>+ <Show+ when={secondaryLabelPosition() === 'above' && props.secondaryLabel}+ ><div class="flex gap-1 text-xxs text-ink-extra-muted">- <Show when={props.item.attendee.isOrganizer}>- <span>Organizer</span>- </Show>- <Show when={props.item.attendee.isOptional}>- <span>Optional</span>- </Show>+ {props.secondaryLabel}</div></Show>- <Show when={props.item.attendee.comment}>- {(comment) => (- <div class="line-clamp-2 select-text text-xxs italic text-ink-extra-muted">- {comment()}- </div>- )}+ <span class="block select-text truncate text-ink-muted">+ {props.displayName()}+ <Show when={props.isSelf}> (you)</Show>+ </span>+ <Show+ when={secondaryLabelPosition() === 'below' && props.secondaryLabel}+ >+ <div class="flex gap-1 text-xxs text-ink-extra-muted">+ {props.secondaryLabel}+ </div></Show>+ {props.details}</div>- <Show when={response}>- {(attendeeResponse) => (- <span- role="img"- aria-label={attendeeResponse().label}- title={attendeeResponse().label}- class={`shrink-0 ${attendeeResponse().class}`}- >- <Dynamic- component={attendeeResponse().icon}- aria-hidden="true"- class="size-3.5"- />- </span>- )}- </Show>+ {props.trailing}+ </div>+ );+}++function CalendarAttendeeItem(props: { item: ResolvedCalendarAttendee }) {+ const attendee = props.item.attendee;+ const response =+ attendee.responseStatus === 'needs_action'+ ? undefined+ : ATTENDEE_RESPONSE[attendee.responseStatus];+ const secondaryLabel =+ attendee.isOrganizer || attendee.isOptional ? (+ <>+ <Show when={attendee.isOrganizer}>+ <span>Organizer</span>+ </Show>+ <Show when={attendee.isOptional}>+ <span>Optional</span>+ </Show>+ </>+ ) : undefined;+ const details = attendee.comment ? (+ <div class="line-clamp-2 select-text text-xxs italic text-ink-extra-muted">+ {attendee.comment}</div>+ ) : undefined;+ const trailing = response ? (+ <span+ role="img"+ aria-label={response.label}+ title={response.label}+ class={`shrink-0 ${response.class}`}+ >+ <Dynamic component={response.icon} aria-hidden="true" class="size-3.5" />+ </span>+ ) : undefined;++ return (+ <CalendarUserItem+ displayName={props.item.displayName}+ iconProps={props.item.iconProps}+ isSelf={attendee.isSelf}+ secondaryLabel={secondaryLabel}+ details={details}+ trailing={trailing}+ />);}@@ -237,16 +291,63 @@ function safeConferenceUrl(value: string | undefined) {}}-function findOrganizer(event: CalendarEvent) {+interface CalendarOrganizer {+ displayName?: string;+ email?: string;+ isSelf: boolean;+}++function findOrganizer(event: CalendarEvent): CalendarOrganizer | undefined {const organizerAttendee = event.attendees.find((attendee) => attendee.isOrganizer);- const name =- event.organizerName ??- organizerAttendee?.displayName ??- event.organizerEmail ??- organizerAttendee?.email;- return name;+ const displayName =+ event.organizerName ?? organizerAttendee?.displayName ?? undefined;+ const email = event.organizerEmail ?? organizerAttendee?.email;++ return displayName || email+ ? { displayName, email, isSelf: organizerAttendee?.isSelf ?? false }+ : undefined;+}++function CalendarOrganizerItem(props: { organizer: CalendarOrganizer }) {+ const macroId = props.organizer.email+ ? emailToMacroId(props.organizer.email)+ : undefined;+ const [macroDisplayName] = useDisplayName(macroId);+ const displayName = () => {+ const email = props.organizer.email ?? '';+ const macroName = macroDisplayName().trim();+ if (isUsableDisplayName(macroName, email)) return macroName;++ const providerName = props.organizer.displayName?.trim() ?? '';+ if (providerName && (!email || isUsableDisplayName(providerName, email))) {+ return providerName;+ }++ return email || providerName;+ };++ const iconProps: UserIconProps | undefined = props.organizer.email+ ? macroId+ ? { id: macroId }+ : { email: props.organizer.email }+ : undefined;++ return (+ <div class="-ml-7 flex min-w-0 items-center gap-3">+ <PersonIcon class="size-4 shrink-0 text-ink-extra-muted" />+ <div class="min-w-0 flex-1">+ <CalendarUserItem+ displayName={displayName}+ iconProps={iconProps}+ isSelf={props.organizer.isSelf}+ secondaryLabel="Organizer"+ secondaryLabelPosition="above"+ />+ </div>+ </div>+ );}function formatOriginalTimeZone(@@ -370,15 +471,7 @@ export function EventDetails(props: {<Show when={organizer()}>{(eventOrganizer) => (- <div class="-ml-7 flex items-start gap-3">- <PersonIcon class="mt-0.5 size-4 shrink-0 text-ink-extra-muted" />- <div class="min-w-0">- <div class="text-xxs text-ink-extra-muted">Organizer</div>- <div class="select-text truncate text-ink-muted">- {eventOrganizer()}- </div>- </div>- </div>+ <CalendarOrganizerItem organizer={eventOrganizer()} />)}</Show></div>@@ -398,7 +491,7 @@ export function EventAttendeesSection(props: {defaultOpenclass="border-edge-muted border-t text-xs text-ink-muted">- <Collapsible.Trigger class="group flex w-full items-center gap-3 px-4 py-2 text-left hover:bg-hover hover:text-ink">+ <Collapsible.Trigger class="group flex w-full items-center gap-3 px-4 py-4 text-left hover:bg-hover hover:text-ink"><UsersIcon class="size-4 shrink-0 text-ink-extra-muted" /><span>{props.attendees.length}{' '}diff --git a/apps/web/src/features/calendar/events/EventDetailsPopover.tsx b/apps/web/src/features/calendar/events/EventDetailsPopover.tsxindex 27d92ba97a..d0274b4aa8 100644--- a/apps/web/src/features/calendar/events/EventDetailsPopover.tsx+++ b/apps/web/src/features/calendar/events/EventDetailsPopover.tsx@@ -1,3 +1,5 @@+import { MobileDrawer } from '@components/app/mobile/MobileDrawer';+import { isMobile } from '@core/mobile/isMobile';import { Popover } from '@kobalte/core/popover';import CloseIcon from '@phosphor/x.svg';import { Button, Layer } from '@ui';@@ -5,18 +7,16 @@ import { type Accessor, createMemo, Show } from 'solid-js';import { EventAttendeesSection, EventDetails } from './EventDetails';import type { CalendarEvent, CalendarTimeFormat } from './types';-interface SelectedEventDetailsPopoverProps {+interface SelectedEventDetailsProps {anchor: Accessor<HTMLElement | undefined>;event: Accessor<CalendarEvent | undefined>;timeFormat: Accessor<CalendarTimeFormat>;onClose: () => void;}-/** Renders selected event details without retaining stale narrowing accessors. */-export function SelectedEventDetailsPopover(- props: SelectedEventDetailsPopoverProps-) {- const selection = createMemo(() => {+/** Renders selected event details in a mobile drawer or anchored popover. */+export function SelectedEventDetails(props: SelectedEventDetailsProps) {+ const popoverSelection = createMemo(() => {const event = props.event();const anchor = props.anchor();@@ -24,28 +24,85 @@ export function SelectedEventDetailsPopover(});return (- <Show keyed when={selection()}>- {(selected) => (- <EventDetailsPopover- anchor={selected.anchor}- event={selected.event}- timeFormat={props.timeFormat()}- onOpenChange={(open) => {- if (!open) props.onClose();- }}- />- )}+ <Show+ when={isMobile()}+ fallback={+ <Show keyed when={popoverSelection()}>+ {(selected) => (+ <EventDetailsPopover+ anchor={selected.anchor}+ event={selected.event}+ timeFormat={props.timeFormat()}+ onOpenChange={(open) => {+ if (!open) props.onClose();+ }}+ />+ )}+ </Show>+ }+ >+ <Show keyed when={props.event()}>+ {(event) => (+ <EventDetailsDrawer+ event={event}+ timeFormat={props.timeFormat()}+ onOpenChange={(open) => {+ if (!open) props.onClose();+ }}+ />+ )}+ </Show></Show>);}-interface EventDetailsPopoverProps {- anchor: HTMLElement;+interface EventDetailsOverlayProps {event: CalendarEvent;timeFormat: CalendarTimeFormat;onOpenChange: (open: boolean) => void;}+function EventDetailsDrawer(props: EventDetailsOverlayProps) {+ return (+ <MobileDrawer+ side="bottom"+ open+ onOpenChange={props.onOpenChange}+ preventScroll={false}+ preventScrollbarShift={false}+ >+ <MobileDrawer.Portal>+ <MobileDrawer.Overlay class="fixed inset-0 z-modal-overlay bg-modal-overlay pattern-diagonal-4 pattern-edge-muted" />+ <MobileDrawer.Content+ aria-label={props.event.title}+ class="overflow-hidden"+ >+ <MobileDrawer.Handle />+ <div class="min-h-0 flex-1 overflow-y-auto">+ <div class="px-3 pb-3">+ <EventDetails event={props.event} timeFormat={props.timeFormat} />+ </div>+ <EventAttendeesSection attendees={props.event.attendees} />+ </div>+ <MobileDrawer.Close+ as={Button}+ aria-label="Close event details"+ variant="ghost"+ size="icon-sm"+ class="absolute right-2 top-2 rounded-full text-ink-muted"+ >+ <CloseIcon class="size-3" />+ </MobileDrawer.Close>+ </MobileDrawer.Content>+ </MobileDrawer.Portal>+ </MobileDrawer>+ );+}++interface EventDetailsPopoverProps extends EventDetailsOverlayProps {+ anchor: HTMLElement;+}+/** Anchors read-only event details to a rendered calendar event. */function EventDetailsPopover(props: EventDetailsPopoverProps) {return (diff --git a/apps/web/src/features/calendar/events/types.ts b/apps/web/src/features/calendar/events/types.tsindex 41fc2ed0bb..98b8beee56 100644--- a/apps/web/src/features/calendar/events/types.ts+++ b/apps/web/src/features/calendar/events/types.ts@@ -1,5 +1,11 @@import type { CalendarAttendee } from '@service-storage/generated/schemas/calendarAttendee';+/** Supported FullCalendar period views. */+export type CalendarPeriodView =+ | 'dayGridMonth'+ | 'timeGridWeek'+ | 'timeGridDay';+/** Supported first day of the calendar week. */export type CalendarWeekStart = 0 | 1;diff --git a/apps/web/src/features/calendar/fullcalendar-solid/FullCalendar.tsx b/apps/web/src/features/calendar/fullcalendar-solid/FullCalendar.tsxindex 58271293b3..1678b9d902 100644--- a/apps/web/src/features/calendar/fullcalendar-solid/FullCalendar.tsx+++ b/apps/web/src/features/calendar/fullcalendar-solid/FullCalendar.tsx@@ -1,7 +1,6 @@import {type AllDayContentArg,Calendar,- type CalendarApi,type CalendarOptions,type DatesSetArg,type DayCellContentArg,@@ -87,7 +86,7 @@ export type FullCalendarHostProps = Omit</** Public state and API available to descendants of `FullCalendar.Root`. */export interface FullCalendarContextValue {/** The mounted FullCalendar API, or `undefined` before a host mounts. */- api: Accessor<CalendarApi | undefined>;+ api: Accessor<Calendar | undefined>;/** The latest date information emitted by FullCalendar. */dateInfo: Accessor<DatesSetArg | undefined>;}diff --git a/apps/web/src/lib/queries/calendar/occurrences.ts b/apps/web/src/lib/queries/calendar/occurrences.tsindex b70b51b686..c3113f7ce3 100644--- a/apps/web/src/lib/queries/calendar/occurrences.ts+++ b/apps/web/src/lib/queries/calendar/occurrences.ts@@ -21,6 +21,8 @@ export interface CalendarOccurrencesQueryInput {export interface CalendarOccurrencesQueryOptions {enabled?: boolean;+ pollWhileSyncing?: boolean;+ refetchOnWindowFocus?: boolean;}export interface CalendarOccurrencesData {@@ -115,8 +117,9 @@ export function useCalendarOccurrencesQuery(Boolean(userId) && range !== undefined && options?.().enabled !== false,staleTime: CALENDAR_STALE_TIME,placeholderData: (p) => p,- refetchOnWindowFocus: true,+ refetchOnWindowFocus: options?.().refetchOnWindowFocus ?? true,refetchInterval: (query) =>+ options?.().pollWhileSyncing !== false &&query.state.data?.syncStatus === CalendarSyncStatus.syncing? CALENDAR_SYNC_POLL_INTERVAL: false,