Skip to content

armgit / macro

Public Imported from GitHub
0

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

feat(calendar): mobile ui (#5482)

dev-rb2f032b27bff7
diff --git a/apps/web/src/components/app/mobile/MobileDock.tsx b/apps/web/src/components/app/mobile/MobileDock.tsx
index 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.tsx
index 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)}
>
<span
aria-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())}
>
<Show
when={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.tsx
new file mode 100644
index 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.tsx
new file mode 100644
index 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.tsx
new file mode 100644
index 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.tsx
new file mode 100644
index 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.ts
new file mode 100644
index 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.css
new file mode 100644
index 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.ts
index 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.tsx
deleted file mode 100644
index 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.tsx
new file mode 100644
index 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.tsx
new file mode 100644
index 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.tsx
new file mode 100644
index 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.tsx
index 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.Trigger
depth={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.tsx
index 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">
<div
role="status"
- class="mx-2 mb-2 flex items-center gap-2 rounded-lg border border-accent/30 bg-accent-bg px-3 py-2 text-xs text-ink-muted"
+ 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.tsx
index 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.CheckboxItem
checked={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.RadioGroup
value={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.RadioGroup
value={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.tsx
new file mode 100644
index 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.tsx
index 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.tsx
index 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.tsx
index 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>
+ }
+ >
<Button
variant="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
+ <SelectedEventDetails
anchor={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.css
index 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.tsx
index 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: {
defaultOpen
class="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.tsx
index 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.ts
index 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.tsx
index 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.ts
index 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,