@remit/web-client 0.0.325 → 0.0.327

package/dist/src/auth/session-state.d.ts

@@ -0,0 +1,29 @@
+/**
+ * What the session query is actually telling the gate.
+ *
+ * "signedOut" is the only state that may put the sign-in screen up. A session
+ * lookup that failed for any other reason has not established that the user is
+ * signed out, and rendering the sign-in screen for it tells them they were
+ * logged out when they were not (#441).
+ */
+export type SessionState = {
+    kind: "pending";
+} | {
+    kind: "active";
+} | {
+    kind: "rateLimited";
+} | {
+    kind: "signedOut";
+};
+/** The shape better-auth's `useSession` hands back, read structurally. */
+export interface SessionQuery {
+    data: unknown;
+    isPending: boolean;
+    error: unknown;
+}
+/**
+ * A held session outranks everything: better-auth keeps `data` across a failed
+ * refetch unless the failure was a 401, so a throttled refresh must not evict a
+ * signed-in user.
+ */
+export declare const classifySessionQuery: ({ data, isPending, error, }: SessionQuery) => SessionState;

package/dist/src/auth/session-state.js

@@ -0,0 +1,16 @@
+import { getErrorStatus } from "../lib/error-classifier";
+const TOO_MANY_REQUESTS = 429;
+/**
+ * A held session outranks everything: better-auth keeps `data` across a failed
+ * refetch unless the failure was a 401, so a throttled refresh must not evict a
+ * signed-in user.
+ */
+export const classifySessionQuery = ({ data, isPending, error, }) => {
+    if (data)
+        return { kind: "active" };
+    if (isPending)
+        return { kind: "pending" };
+    if (getErrorStatus(error) === TOO_MANY_REQUESTS)
+        return { kind: "rateLimited" };
+    return { kind: "signedOut" };
+};

package/dist/src/auth/sign-out-visibility.d.ts

@@ -0,0 +1,5 @@
+export interface SignOutMenuVisibilityInput {
+    configured: boolean;
+    authStatus: string | undefined;
+}
+export declare const isSignOutVisible: ({ configured, authStatus, }: SignOutMenuVisibilityInput) => boolean;

package/dist/src/auth/sign-out-visibility.js

@@ -0,0 +1 @@
+export const isSignOutVisible = ({ configured, authStatus, }) => configured && authStatus === "authenticated";

package/dist/src/components/calendar/AgendaStrip.d.ts

@@ -0,0 +1,64 @@
+import { type AgendaScrollTarget, type CalendarDay, type CalendarDescriptor, type CalendarSlotPick, type Density } from "@remit/ui";
+import type { FreeLookup } from "../../hooks/calendar";
+/**
+ * The agenda, drawn.
+ *
+ * Presentational, like the rest of the calendar pane: it takes the days it was
+ * given, says which one is under the header, and asks for more at either end.
+ * What it never does is decide which days those are — the address owns that, and
+ * `AgendaView` turns each answer here into one.
+ *
+ * "What is next" leads today rather than sitting in a rail of its own. It is
+ * the question a strip is for, and putting it above today means the reader
+ * lands on it and scrolls past it, instead of reading it in a column that is
+ * still there when they are three weeks away.
+ */
+export interface AgendaStripProps {
+    /** Contiguous and ascending. */
+    days: CalendarDay[];
+    calendars: readonly CalendarDescriptor[];
+    /** The device preference the whole calendar reads. */
+    density: Density;
+    today: string;
+    /** The day the address names; never collapsed into a run. */
+    anchorDate: string;
+    /** The instant "what is next" is measured from. */
+    now: string;
+    selectedEventId: string;
+    /** What is still open on a day, measured off merged busy time. */
+    freeOn: FreeLookup;
+    /**
+     * Days whose week has not answered yet. They draw as skeletons: a day
+     * nobody has heard back about and a day with nothing on it are otherwise
+     * the same picture, and the strip would be claiming a free fortnight it has
+     * no grounds for.
+     */
+    loadingDates: ReadonlySet<string>;
+    /**
+     * A refusal stated in place of the strip. A diary drawn empty because the
+     * read failed is indistinguishable from a diary with nothing in it, which is
+     * the one thing this must never look like.
+     */
+    error?: unknown;
+    onRetry?: () => void;
+    scrollTarget?: AgendaScrollTarget;
+    onSelectEvent: (eventId: string) => void;
+    onPickSlot: (pick: CalendarSlotPick) => void;
+    /** Drops out of the list into the day grid. */
+    onZoomDay: (date: string) => void;
+    onGoToDate: (date: string) => void;
+    onReachStart: () => void;
+    onReachEnd: () => void;
+    /**
+     * The run has grown as far as scrolling takes it. The strip says so at that
+     * end and offers the next stretch, so a diary too sparse to fill the pane
+     * cannot fetch its way across years nobody asked for.
+     */
+    atStartCap?: boolean;
+    atEndCap?: boolean;
+    onLoadEarlier?: () => void;
+    onLoadLater?: () => void;
+    /** The day under the sticky header, which the address follows. */
+    onVisibleDayChange: (date: string) => void;
+}
+export declare function AgendaStrip({ days, calendars, density, today, anchorDate, now, selectedEventId, freeOn, loadingDates, error, onRetry, scrollTarget, onSelectEvent, onPickSlot, onZoomDay, onGoToDate, onReachStart, onReachEnd, atStartCap, atEndCap, onLoadEarlier, onLoadLater, onVisibleDayChange, }: AgendaStripProps): import("react").JSX.Element;

package/dist/src/components/calendar/AgendaStrip.js

@@ -0,0 +1,19 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { AgendaFlow, ErrorState, NextUpCard, readNextUp, } from "@remit/ui";
+import { useMemo } from "react";
+import { agendaDensityOf } from "../../lib/calendar-density";
+export function AgendaStrip({ days, calendars, density, today, anchorDate, now, selectedEventId, freeOn, loadingDates, error, onRetry, scrollTarget, onSelectEvent, onPickSlot, onZoomDay, onGoToDate, onReachStart, onReachEnd, atStartCap, atEndCap, onLoadEarlier, onLoadLater, onVisibleDayChange, }) {
+    const nextUp = useMemo(() => readNextUp(days, now), [days, now]);
+    /*
+     * "What is next" is an answer about days that have arrived. Drawn over a
+     * today whose week is still out it reads "Nothing else booked", which is a
+     * claim rather than a delay.
+     */
+    const settledToday = !loadingDates.has(today);
+    if (error !== undefined && error !== null)
+        return (_jsx("div", { className: "flex h-full items-center justify-center bg-surface", children: _jsx(ErrorState, { title: "Couldn't load these days", error: error, onRetry: onRetry }) }));
+    /* No spinner over the whole strip. Days already fetched stay put while their
+       neighbours arrive, and a day still outstanding says so where it will be
+       drawn — which is also what stops the rows jumping when it lands. */
+    return (_jsx(AgendaFlow, { days: days, calendars: calendars, density: agendaDensityOf(density), today: today, focusDate: anchorDate, selectedEventId: selectedEventId, freeOn: freeOn, loadingDates: loadingDates, scrollTarget: scrollTarget, onSelectEvent: onSelectEvent, onPickSlot: onPickSlot, onZoomDay: onZoomDay, onReachStart: onReachStart, onReachEnd: onReachEnd, atStartCap: atStartCap, atEndCap: atEndCap, onLoadEarlier: onLoadEarlier, onLoadLater: onLoadLater, onVisibleDayChange: onVisibleDayChange, todayLead: settledToday ? (_jsx("div", { className: "border-b border-line bg-surface-sunken p-3", children: _jsx(NextUpCard, { nextUp: nextUp, calendars: calendars, today: today, onSelectEvent: onSelectEvent, onGoTo: onGoToDate }) })) : undefined }));
+}

package/dist/src/components/calendar/AgendaView.d.ts

@@ -0,0 +1,42 @@
+import { type CalendarSlotPick, type Density } from "@remit/ui";
+/**
+ * The agenda, bound to the address.
+ *
+ * The strip is the same continuous run of time the grid draws, at a zoom that
+ * does not spend pixels on empty hours. Two facts of the address drive it and
+ * nothing else does: the day it opened on, which the strip lands on, and the
+ * calendars ticked in the query, which narrow what it draws. Switching to the
+ * week grid and back changes neither, which is what "the grid is a zoom level
+ * you drop into and leave" means in practice.
+ *
+ * The days it holds are fetched a week at a time, on the grid's own cache keys.
+ * That is what lets the range grow at all — a single read may not cover more
+ * than a year, and one request that widened every time the reader reached an
+ * end would eventually be refused and replace the strip with the refusal — and
+ * it is what makes the two zooms share everything they have already read.
+ *
+ * It grows on the reader's scroll and on nothing else, a week at a time, and
+ * only as far as a year either way. Past that it says so and offers the next
+ * stretch: a sparse diary draws shorter than the distance the strip fetches at,
+ * so an end measured off the content alone is reached on the first layout pass
+ * and never stops being reached.
+ *
+ * Scrolling writes the day back to the address, debounced and by `replace`.
+ * Debounced because a flick past a fortnight is one move rather than fourteen,
+ * and `replace` because scrolling is not somewhere a reader went — Back belongs
+ * to the screen they came from, not to the row they scrolled past. Growing the
+ * range writes nothing: days arriving at an end is not the reader moving.
+ */
+/** Long enough that a flick lands before the address moves. */
+export declare const ANCHOR_DEBOUNCE_MS = 400;
+export interface AgendaViewProps {
+    /** The device preference the whole calendar reads. */
+    density: Density;
+    /**
+     * An empty slot the reader picked. The composer is seeded by the route, the
+     * same way the grid's picks are, so a slot picked off a free band and one
+     * dragged on the grid open the same form.
+     */
+    onPickSlot: (pick: CalendarSlotPick) => void;
+}
+export declare function AgendaView({ density, onPickSlot }: AgendaViewProps): import("react").JSX.Element;

package/dist/src/components/calendar/AgendaView.js

@@ -0,0 +1,131 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { buildCalendarDay, freeStretchesOn, } from "@remit/ui";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { calendarInstanceId, datesInRange, extendRangeEnd, extendRangeStart, freeStretchesByDate, liftRangeCeiling, liftRangeFloor, rangeAround, rangeAtCeiling, rangeAtFloor, rangeCovering, readCalendarInstanceId, useCalendarEventWeeks, useCalendarFreeBusyWeeks, useCalendarSelection, useDrawnEvents, weekKeyOf, weekWindowsOver, } from "../../hooks/calendar";
+import { useDebouncedValue } from "../../hooks/useDebouncedValue";
+import { isoDate } from "../../lib/calendar-route";
+import { useCalendarAddress, useCalendarNavigation, useOpenCalendarEvent, } from "../../routing";
+import { AgendaStrip } from "./AgendaStrip";
+/**
+ * The agenda, bound to the address.
+ *
+ * The strip is the same continuous run of time the grid draws, at a zoom that
+ * does not spend pixels on empty hours. Two facts of the address drive it and
+ * nothing else does: the day it opened on, which the strip lands on, and the
+ * calendars ticked in the query, which narrow what it draws. Switching to the
+ * week grid and back changes neither, which is what "the grid is a zoom level
+ * you drop into and leave" means in practice.
+ *
+ * The days it holds are fetched a week at a time, on the grid's own cache keys.
+ * That is what lets the range grow at all — a single read may not cover more
+ * than a year, and one request that widened every time the reader reached an
+ * end would eventually be refused and replace the strip with the refusal — and
+ * it is what makes the two zooms share everything they have already read.
+ *
+ * It grows on the reader's scroll and on nothing else, a week at a time, and
+ * only as far as a year either way. Past that it says so and offers the next
+ * stretch: a sparse diary draws shorter than the distance the strip fetches at,
+ * so an end measured off the content alone is reached on the first layout pass
+ * and never stops being reached.
+ *
+ * Scrolling writes the day back to the address, debounced and by `replace`.
+ * Debounced because a flick past a fortnight is one move rather than fourteen,
+ * and `replace` because scrolling is not somewhere a reader went — Back belongs
+ * to the screen they came from, not to the row they scrolled past. Growing the
+ * range writes nothing: days arriving at an end is not the reader moving.
+ */
+/** Long enough that a flick lands before the address moves. */
+export const ANCHOR_DEBOUNCE_MS = 400;
+export function AgendaView({ density, onPickSlot }) {
+    const { date, calendarIds } = useCalendarAddress();
+    const { openEvent, setAnchorDate, zoomToDay } = useCalendarNavigation();
+    const opened = useOpenCalendarEvent();
+    // One reading of the clock per mount. A strip that re-decided what "today"
+    // meant on every render would move the day it is anchored to under a reader
+    // who had not touched it.
+    const [clock] = useState(() => new Date());
+    const today = useMemo(() => isoDate(clock), [clock]);
+    const now = useMemo(() => clock.toISOString(), [clock]);
+    const [range, setRange] = useState(() => rangeAround(date));
+    const [scrollTarget, setScrollTarget] = useState();
+    const [visibleDate, setVisibleDate] = useState(date);
+    const jumps = useRef(0);
+    /*
+     * The day this view last put in the address. A date arriving that matches it
+     * is our own write coming back, and landing the strip on that would fight the
+     * scroll that caused it.
+     */
+    const written = useRef(date);
+    const land = useCallback((day) => {
+        written.current = day;
+        setVisibleDate(day);
+        setRange((previous) => rangeCovering(previous, day));
+        jumps.current += 1;
+        setScrollTarget({ date: day, token: jumps.current });
+    }, []);
+    useEffect(() => {
+        if (date === written.current)
+            return;
+        land(date);
+    }, [date, land]);
+    const anchor = useDebouncedValue(visibleDate, ANCHOR_DEBOUNCE_MS);
+    useEffect(() => {
+        if (anchor === written.current)
+            return;
+        written.current = anchor;
+        setAnchorDate(anchor);
+    }, [anchor, setAnchorDate]);
+    const dates = useMemo(() => datesInRange(range), [range]);
+    const windows = useMemo(() => weekWindowsOver(dates), [dates]);
+    const { calendars, timeZoneByCalendarId, shown, narrowed, resolved, isLoading: loadingCalendars, } = useCalendarSelection(calendarIds);
+    const events = useCalendarEventWeeks(windows, narrowed, resolved);
+    const busy = useCalendarFreeBusyWeeks(windows);
+    const drawn = useDrawnEvents(events.instances, timeZoneByCalendarId, shown);
+    const days = useMemo(() => dates.map((day) => buildCalendarDay(day, drawn, today)), [dates, drawn, today]);
+    /*
+     * A day whose week has not answered yet, or whose calendars are not known.
+     * It draws as a skeleton rather than as a day with nothing on it, because
+     * those two pictures are otherwise the same one and only one of them is true.
+     */
+    const loadingDates = useMemo(() => {
+        const pending = new Set();
+        if (loadingCalendars || !resolved)
+            return new Set(dates);
+        for (const day of dates) {
+            if (events.pendingWindows.has(weekKeyOf(day)))
+                pending.add(day);
+        }
+        return pending;
+    }, [dates, events.pendingWindows, loadingCalendars, resolved]);
+    /*
+     * Free time comes from the merged busy spans, which cover every calendar the
+     * reader holds rather than the ones the strip is drawing. A week whose spans
+     * have not landed falls back to the gaps between its own rows: calling an
+     * afternoon clear on the strength of nothing at all is the one mistake this
+     * view exists to avoid.
+     */
+    const freeByDate = useMemo(() => freeStretchesByDate(dates, busy.spans), [dates, busy.spans]);
+    const freeOn = useCallback((day) => busy.pendingWindows.has(weekKeyOf(day.date))
+        ? freeStretchesOn(day)
+        : (freeByDate.get(day.date) ?? freeStretchesOn(day)), [freeByDate, busy.pendingWindows]);
+    const goToDate = useCallback((day) => {
+        land(day);
+        setAnchorDate(day);
+    }, [land, setAnchorDate]);
+    const selectEvent = useCallback((eventId) => {
+        const instance = readCalendarInstanceId(eventId);
+        openEvent(instance.calendarObjectId, instance.recurrenceId);
+    }, [openEvent]);
+    const growStart = useCallback(() => setRange(extendRangeStart), []);
+    const growEnd = useCallback(() => setRange(extendRangeEnd), []);
+    const loadEarlier = useCallback(() => setRange(liftRangeFloor), []);
+    const loadLater = useCallback(() => setRange(liftRangeCeiling), []);
+    /** Whichever read was refused is the one a retry re-sends. */
+    const retry = useCallback(() => {
+        events.refetch();
+        busy.refetch();
+    }, [events.refetch, busy.refetch]);
+    return (_jsx(AgendaStrip, { days: days, calendars: calendars, density: density, today: today, anchorDate: date, now: now, selectedEventId: opened
+            ? calendarInstanceId(opened.calendarObjectId, opened.recurrenceId ?? "")
+            : "", freeOn: freeOn, loadingDates: loadingDates, error: events.error ?? busy.error, onRetry: retry, scrollTarget: scrollTarget, onSelectEvent: selectEvent, onPickSlot: onPickSlot, onZoomDay: zoomToDay, onGoToDate: goToDate, onReachStart: growStart, onReachEnd: growEnd, atStartCap: rangeAtFloor(range), atEndCap: rangeAtCeiling(range), onLoadEarlier: loadEarlier, onLoadLater: loadLater, onVisibleDayChange: setVisibleDate }));
+}

package/dist/src/components/calendar/CalendarComposePane.d.ts

@@ -0,0 +1,49 @@
+import { type CalendarClash, type CalendarDescriptor, type EventDraft } from "@remit/ui";
+/**
+ * Writing an event, and editing one.
+ *
+ * Presentational, like the pane it sits beside: it holds no draft of its own
+ * and saves nothing. The route owns the draft and the write, so this renders
+ * the same form whichever of the two the address named.
+ *
+ * Guests are left out because the calendar store has nowhere to put them yet,
+ * which is the kit's default. A field that takes names and drops them is worse
+ * than no field: the reader only finds out afterwards, from an event with
+ * nobody on it.
+ */
+export interface CalendarComposePaneProps {
+    /** What the pane is doing: "New event", "Edit event". */
+    title: string;
+    /** The one line of context the title cannot carry — which day, which series. */
+    subtitle?: string;
+    notice?: string;
+    calendars: CalendarDescriptor[];
+    draft: EventDraft;
+    onChange: (draft: EventDraft) => void;
+    /**
+     * Why the last save did not happen, in the words the reader needs: what was
+     * refused and what to do about it. Empty when nothing has been refused.
+     */
+    problem: string;
+    saveLabel: string;
+    isSaving: boolean;
+    /**
+     * The rule belongs to the series rather than to one morning of it, so an
+     * edit scoped to a single occurrence reads it back instead of offering it.
+     */
+    repeatEditable?: boolean;
+    /**
+     * Whether the event can still be sent to a different calendar. Writing one
+     * chooses; editing one cannot, because the collection a resource lives in is
+     * part of its address and the patch has no field for it.
+     */
+    calendarEditable?: boolean;
+    /**
+     * What the span on the form runs into. Undefined while there is nothing to
+     * check or the answer has not landed, which draws no strip at all.
+     */
+    clashes?: CalendarClash[];
+    onSave: () => void;
+    onCancel: () => void;
+}
+export declare function CalendarComposePane({ title, subtitle, notice, calendars, draft, onChange, problem, saveLabel, isSaving, repeatEditable, calendarEditable, clashes, onSave, onCancel, }: CalendarComposePaneProps): import("react").JSX.Element;

package/dist/src/components/calendar/CalendarComposePane.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { CalendarClashStrip, EventEditor, EventEditorPane, } from "@remit/ui";
+import { AlertCircle, AlertTriangle } from "lucide-react";
+export function CalendarComposePane({ title, subtitle, notice = "", calendars, draft, onChange, problem, saveLabel, isSaving, repeatEditable = true, calendarEditable = true, clashes, onSave, onCancel, }) {
+    return (_jsx(EventEditorPane, { title: title, subtitle: subtitle, onClose: onCancel, children: _jsx(EventEditor, { draft: draft, onChange: onChange, calendars: calendars, layout: "pane", repeatEditable: repeatEditable, calendarEditable: calendarEditable, saveLabel: isSaving ? "Saving…" : saveLabel, onSave: onSave, onCancel: onCancel, header: problem === "" &&
+                notice === "" &&
+                clashes === undefined ? undefined : (_jsxs("div", { className: "space-y-2", children: [notice !== "" && (_jsxs("p", { className: "flex items-start gap-2 rounded-md border border-warning/40 bg-warning-soft px-3 py-2 text-sm text-fg", children: [_jsx(AlertTriangle, { className: "mt-0.5 size-4 shrink-0 text-warning", "aria-hidden": "true" }), _jsx("span", { className: "min-w-0 flex-1 break-words", children: notice })] })), problem !== "" && (_jsxs("div", { role: "alert", className: "flex items-start gap-2 rounded-md border border-danger/40 bg-danger-soft px-3 py-2 text-sm", children: [_jsx(AlertCircle, { className: "mt-0.5 size-4 shrink-0 text-danger", "aria-hidden": "true" }), _jsx("p", { className: "min-w-0 flex-1 break-words text-fg", children: problem })] })), clashes !== undefined && (_jsx(CalendarClashStrip, { clashes: clashes, clearText: "Nothing else is booked at this time." }))] })) }) }));
+}

package/dist/src/components/calendar/CalendarComposeSeed.d.ts

@@ -0,0 +1,7 @@
+import type { CalendarSlotPick } from "@remit/ui";
+import { type ReactNode } from "react";
+export declare const CalendarComposeSeedProvider: ({ pick, children, }: {
+    pick: CalendarSlotPick | undefined;
+    children?: ReactNode;
+}) => import("react").JSX.Element;
+export declare const useCalendarComposeSeed: () => CalendarSlotPick | undefined;

package/dist/src/components/calendar/CalendarComposeSeed.js

@@ -0,0 +1,19 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext } from "react";
+/**
+ * The slot a reader dragged out of the grid, handed to the composer the click
+ * opened.
+ *
+ * It is not in the address on purpose. What a half-written event says is not a
+ * fact about where the reader is, and a link to a composer pre-filled with
+ * somebody else's Tuesday afternoon is not an address worth being able to send.
+ * The composer opened without one starts on the day the calendar is showing.
+ *
+ * It lives outside the route files for the same reason
+ * `CalendarShell`'s context does: the generated route tree imports route files
+ * relatively, so a context declared inside one resolves to a second module
+ * instance and hands the consumer an empty default.
+ */
+const CalendarComposeSeedCtx = createContext(undefined);
+export const CalendarComposeSeedProvider = ({ pick, children, }) => (_jsx(CalendarComposeSeedCtx.Provider, { value: pick, children: children }));
+export const useCalendarComposeSeed = () => useContext(CalendarComposeSeedCtx);

package/dist/src/components/calendar/CalendarEventPane.d.ts

@@ -0,0 +1,48 @@
+import type { CalendarDescriptor, CalendarEventData } from "@remit/ui";
+import type { ReactNode } from "react";
+export type CalendarEventAbsence = {
+    kind: "NotInView";
+} | {
+    kind: "Finding";
+} | {
+    kind: "Deleted";
+} | {
+    kind: "NoOccurrenceFound";
+} | {
+    kind: "SignedOut";
+    signIn: ReactNode;
+} | {
+    kind: "Failed";
+    reason: string;
+    reportHref: string;
+};
+/**
+ * The event the address has open.
+ *
+ * Presentational, like the workspace beside it: the route resolves the event
+ * and turns closing, editing and deleting into things it does, so this renders
+ * what it is handed and nothing else. Each control appears only when the route
+ * gave it somewhere to go — a control that leads nowhere is worse than none.
+ */
+export interface CalendarEventPaneProps {
+    /** Absent when the address names an event the calendar does not have. */
+    event: CalendarEventData | undefined;
+    calendar: CalendarDescriptor | undefined;
+    /** Whether the address names one occurrence rather than the series. */
+    isOccurrence: boolean;
+    absence?: CalendarEventAbsence;
+    /**
+     * A write that did not happen, stated where the reader is looking. Empty
+     * when the last one did.
+     */
+    problem?: string;
+    /**
+     * Why this event cannot be changed here, stated where Edit and Delete would
+     * be. Empty for an event the reader can change.
+     */
+    readOnlyNote?: string;
+    onEdit?: () => void;
+    onDelete?: () => void;
+    onClose: () => void;
+}
+export declare function CalendarEventPane({ event, calendar, isOccurrence, absence, problem, readOnlyNote, onEdit, onDelete, onClose, }: CalendarEventPaneProps): import("react").JSX.Element;

package/dist/src/components/calendar/CalendarEventPane.js

@@ -0,0 +1,48 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { EventDetail } from "@remit/ui";
+import { AlertCircle, CalendarDays, Lock } from "lucide-react";
+import { formatEventWhen } from "../../lib/calendar-format";
+const NOT_IN_VIEW = { kind: "NotInView" };
+const LINK = "rounded-md border border-line px-2.5 py-1 text-sm font-medium text-fg outline-none hover:bg-surface-sunken focus-visible:ring-2 focus-visible:ring-ring";
+function absenceText(absence) {
+    switch (absence.kind) {
+        case "Finding":
+            return {
+                title: "Finding the event",
+                detail: "Looking for the day it falls on.",
+            };
+        case "Deleted":
+            return {
+                title: "This event was deleted",
+                detail: "None of your calendars holds it any more.",
+            };
+        case "NoOccurrenceFound":
+            return {
+                title: "No occurrence in its first year or the coming year",
+                detail: "Its repeat rule, or the days taken out of it, leave it no day in either.",
+            };
+        case "SignedOut":
+            return {
+                title: "Your session has ended",
+                detail: "Sign in again to open this event.",
+            };
+        case "Failed":
+            return {
+                title: "The event couldn't be looked up",
+                detail: absence.reason,
+            };
+        case "NotInView":
+            return {
+                title: "That event isn't on this week",
+                detail: "The address names an event the calendar doesn't have here.",
+            };
+    }
+}
+export function CalendarEventPane({ event, calendar, isOccurrence, absence = NOT_IN_VIEW, problem = "", readOnlyNote = "", onEdit, onDelete, onClose, }) {
+    if (!event || !calendar) {
+        const { title, detail } = absenceText(absence);
+        const loud = absence.kind === "Failed" || absence.kind === "SignedOut";
+        return (_jsxs("div", { role: loud ? "alert" : undefined, className: "flex h-full flex-col items-center justify-center gap-2 bg-surface p-8 text-center", children: [_jsx(CalendarDays, { className: "size-8 text-fg-subtle", "aria-hidden": "true" }), _jsx("p", { className: "text-sm font-medium text-fg", children: title }), _jsx("p", { className: "max-w-xs break-words text-sm text-fg-muted", children: detail }), _jsxs("div", { className: "flex flex-wrap items-center justify-center gap-2", children: [absence.kind === "SignedOut" && absence.signIn, absence.kind === "Failed" && (_jsx("a", { href: absence.reportHref, target: "_blank", rel: "noreferrer", className: LINK, children: "Report an issue" })), _jsx("button", { type: "button", onClick: onClose, className: LINK, children: "Back to the calendar" })] })] }));
+    }
+    return (_jsxs("div", { className: "flex h-full min-h-0 flex-col bg-surface", children: [isOccurrence && (_jsx("p", { className: "shrink-0 border-b border-line bg-surface-sunken px-row-inset py-1.5 text-2xs uppercase tracking-wider text-fg-subtle", children: "One occurrence of a repeating event" })), readOnlyNote !== "" && (_jsxs("p", { className: "flex shrink-0 items-start gap-2 border-b border-line bg-surface-sunken px-row-inset py-2 text-sm text-fg-muted", children: [_jsx(Lock, { className: "mt-0.5 size-4 shrink-0", "aria-hidden": "true" }), _jsx("span", { className: "min-w-0 flex-1 break-words", children: readOnlyNote })] })), problem !== "" && (_jsxs("div", { role: "alert", className: "flex shrink-0 items-start gap-2 border-b border-danger/40 bg-danger-soft px-row-inset py-2 text-sm", children: [_jsx(AlertCircle, { className: "mt-0.5 size-4 shrink-0 text-danger", "aria-hidden": "true" }), _jsx("p", { className: "min-w-0 flex-1 break-words text-fg", children: problem })] })), _jsx(EventDetail, { event: event, calendar: calendar, whenText: formatEventWhen(event), onEdit: onEdit, onDelete: onDelete, onClose: onClose, className: "min-h-0 flex-1" })] }));
+}

package/dist/src/components/calendar/CalendarShell.d.ts

@@ -0,0 +1,43 @@
+import { type ReactNode } from "react";
+/**
+ * The chrome the calendar shares with mail, published by the `/calendar` layout
+ * and consumed by the view route that mounts the shell.
+ *
+ * It lives outside the route files for the same reason
+ * `lib/mail-context.ts` does: the generated route tree imports route files
+ * relatively, so a context declared inside one would resolve to a second module
+ * instance and hand the consumer an empty default.
+ */
+export interface CalendarShellChrome {
+    /** Below the reading boundary the shell shows one pane, as mail's does. */
+    isSinglePane: boolean;
+    isLoading: boolean;
+    nav: ReactNode;
+    navOpen: boolean;
+    onOpenNav: () => void;
+    onCloseNav: () => void;
+}
+export declare const CalendarShellProvider: ({ chrome, children, }: {
+    chrome: CalendarShellChrome;
+    children: ReactNode;
+}) => import("react").JSX.Element;
+export interface CalendarShellProps {
+    /** The grid, or whatever the current zoom draws. */
+    workspace: ReactNode;
+    /** The open event, from the route below this one. */
+    reading: ReactNode;
+    /** Whether the address has an event or the composer open. */
+    hasOpenEvent: boolean;
+}
+/**
+ * The shell the calendar mounts around its own panes.
+ *
+ * `listBias="list"` because the grid is the work rather than an index into it:
+ * a week of columns costs width it cannot give back when a detail opens, which
+ * is the opposite of the split a message list wants.
+ *
+ * Below the reading boundary there is one pane, so the open event replaces the
+ * grid in it — the same swap mail makes, read off the address rather than
+ * decided here.
+ */
+export declare function CalendarShell({ workspace, reading, hasOpenEvent, }: CalendarShellProps): import("react").JSX.Element;

package/dist/src/components/calendar/CalendarShell.js

@@ -0,0 +1,35 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { AppShellSlotted } from "@remit/ui";
+import { createContext, useContext } from "react";
+import { AppShellSkeleton } from "../layout/AppShellSkeleton";
+const CalendarShellCtx = createContext(null);
+export const CalendarShellProvider = ({ chrome, children, }) => (_jsx(CalendarShellCtx.Provider, { value: chrome, children: children }));
+/**
+ * The shell the calendar mounts around its own panes.
+ *
+ * `listBias="list"` because the grid is the work rather than an index into it:
+ * a week of columns costs width it cannot give back when a detail opens, which
+ * is the opposite of the split a message list wants.
+ *
+ * Below the reading boundary there is one pane, so the open event replaces the
+ * grid in it — the same swap mail makes, read off the address rather than
+ * decided here.
+ */
+export function CalendarShell({ workspace, reading, hasOpenEvent, }) {
+    const chrome = useContext(CalendarShellCtx);
+    if (!chrome)
+        return _jsx(AppShellSkeleton, {});
+    const shared = {
+        nav: chrome.nav,
+        skeleton: _jsx(AppShellSkeleton, {}),
+        isLoading: chrome.isLoading,
+        navOpen: chrome.navOpen,
+        onOpenNav: chrome.onOpenNav,
+        onCloseNav: chrome.onCloseNav,
+        listBias: "list",
+    };
+    if (chrome.isSinglePane) {
+        return (_jsx(AppShellSlotted, { ...shared, list: hasOpenEvent ? reading : workspace }));
+    }
+    return _jsx(AppShellSlotted, { ...shared, list: workspace, reading: reading });
+}

package/dist/src/components/calendar/CalendarUnavailable.d.ts

@@ -0,0 +1,13 @@
+import type { ReactNode } from "react";
+import type { CalendarsResult } from "../../hooks/calendar";
+/**
+ * Whether there is a calendar an answer can write to. Declining and muting
+ * write none, so only adding waits on this.
+ */
+export type CalendarWriteGate = "ready" | "loading" | "failed" | "none";
+export declare function calendarWriteGate(calendars: Pick<CalendarsResult, "defaultCalendarId" | "isLoading" | "error">): CalendarWriteGate;
+/**
+ * Why adding waits, with the way past it. Undefined when nothing stops it, so a
+ * host can hand the answer straight to a card's `addBlocked`.
+ */
+export declare function calendarUnavailable(gate: CalendarWriteGate, reportHref: string): ReactNode | undefined;

package/dist/src/components/calendar/CalendarUnavailable.js

@@ -0,0 +1,24 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { NavLink } from "../../routing";
+export function calendarWriteGate(calendars) {
+    if (calendars.defaultCalendarId !== "")
+        return "ready";
+    if (calendars.error !== null)
+        return "failed";
+    if (calendars.isLoading)
+        return "loading";
+    return "none";
+}
+/**
+ * Why adding waits, with the way past it. Undefined when nothing stops it, so a
+ * host can hand the answer straight to a card's `addBlocked`.
+ */
+export function calendarUnavailable(gate, reportHref) {
+    if (gate === "ready")
+        return undefined;
+    if (gate === "loading")
+        return "Reading your calendars…";
+    if (gate === "failed")
+        return (_jsxs(_Fragment, { children: ["Couldn't read your calendars, so there is nowhere to add this yet. Reload to try again.", " ", _jsx("a", { href: reportHref, target: "_blank", rel: "noreferrer", className: "font-medium text-accent hover:underline", children: "Report an issue" })] }));
+    return (_jsxs(_Fragment, { children: ["You have no calendar yet, so there is nowhere to add this.", " ", _jsx(NavLink, { to: "/settings/calendars", className: "font-medium text-accent hover:underline", children: "Create a calendar" })] }));
+}

package/dist/src/components/calendar/CalendarViewPlaceholder.d.ts

@@ -0,0 +1 @@
+export declare function CalendarViewPlaceholder(): import("react").JSX.Element;

package/dist/src/components/calendar/CalendarViewPlaceholder.js

@@ -0,0 +1,5 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { CalendarRange } from "lucide-react";
+export function CalendarViewPlaceholder() {
+    return (_jsxs("div", { className: "flex h-full flex-col items-center justify-center gap-2 bg-surface p-8 text-center", "data-testid": "calendar-placeholder-year", children: [_jsx(CalendarRange, { className: "size-8 text-fg-subtle", "aria-hidden": "true" }), _jsx("p", { className: "text-sm font-medium text-fg", children: "Not built yet" }), _jsx("p", { className: "max-w-xs text-sm text-fg-muted", children: "The year grid arrives with the rest of the zoom ladder. Month, Week, Day and Agenda work now." })] }));
+}