@remit/web-client 0.0.324 → 0.0.326

package/dist/src/hooks/calendar/useCalendarSubscriptions.js

@@ -0,0 +1,66 @@
+/**
+ * Subscribing a new calendar to a read-only iCalendar URL, and turning an
+ * existing subscription's refresh off and on (issue #1261).
+ *
+ * The server fetches the feed before it creates anything, so a refused
+ * subscribe leaves no calendar behind and its reason is what the form states.
+ * A 401 is not among the statuses owned here: a lapsed session escalates the
+ * way it does everywhere else.
+ */
+import { calendarDetailOperationsUpdateCalendarMutation, calendarOperationsCreateCalendarMutation, calendarOperationsListCalendarsQueryKey, } from "@remit/api-http-client/@tanstack/react-query.gen.ts";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { useCallback } from "react";
+import { softErrorStatuses } from "../../lib/error-classifier";
+import { useInvalidateCalendarReads } from "./useCalendarWrites";
+const SUBSCRIPTION_WRITE_META = softErrorStatuses(400, 404);
+const urlSegmentFor = () => `subscribed-${crypto.randomUUID().slice(0, 8)}`;
+export function useCalendarSubscriptions() {
+    const queryClient = useQueryClient();
+    const invalidateReads = useInvalidateCalendarReads();
+    const invalidate = () => {
+        void queryClient.invalidateQueries({
+            queryKey: calendarOperationsListCalendarsQueryKey(),
+        });
+        invalidateReads();
+    };
+    const create = useMutation({
+        ...calendarOperationsCreateCalendarMutation(),
+        meta: SUBSCRIPTION_WRITE_META,
+        onSuccess: invalidate,
+    });
+    const toggle = useMutation({
+        ...calendarDetailOperationsUpdateCalendarMutation(),
+        meta: SUBSCRIPTION_WRITE_META,
+        onSuccess: invalidate,
+    });
+    const { mutate: createCalendar } = create;
+    const subscribe = useCallback((request, onDone) => {
+        createCalendar({
+            body: {
+                urlSegment: urlSegmentFor(),
+                displayName: request.displayName.trim(),
+                subscriptionUrl: request.url.trim(),
+            },
+        }, { onSuccess: onDone });
+    }, [createCalendar]);
+    const { mutate: updateCalendar } = toggle;
+    const setEnabled = useCallback((calendarId, enabled) => {
+        updateCalendar({
+            path: { calendarId },
+            body: { subscriptionEnabled: enabled },
+        });
+    }, [updateCalendar]);
+    return {
+        subscribe,
+        isSubscribing: create.isPending,
+        subscribeError: create.error,
+        setEnabled,
+        togglingCalendarId: toggle.isPending
+            ? (toggle.variables?.path.calendarId ?? "")
+            : "",
+        toggleFailure: {
+            calendarId: toggle.variables?.path.calendarId ?? "",
+            error: toggle.error,
+        },
+    };
+}

package/dist/src/hooks/calendar/useCalendarSuggestions.d.ts

@@ -0,0 +1,45 @@
+/**
+ * The events mail offers, and the answers the reader gives them.
+ *
+ * Every card is drawn from what the server holds. An answer is a request, and
+ * the card moves when the listing it came from is read again — never because
+ * this side decided the press worked — so a refused answer leaves the card
+ * where it was, with the refusal stated beside it.
+ *
+ * Answers come back as outcomes rather than throws, for the reason the event
+ * writes do: a surface switching on a caught `unknown` cannot tell a refusal it
+ * must state from a fault it must not swallow. A lapsed session is neither, and
+ * escalates the way it does everywhere else.
+ */
+import type { RemitImapAcceptCalendarSuggestionInput, RemitImapCalendarSuggestionResponse } from "@remit/api-http-client/types.gen.ts";
+export interface CalendarSuggestionsResult {
+    suggestions: RemitImapCalendarSuggestionResponse[];
+    isLoading: boolean;
+    error: unknown;
+}
+/** Every suggestion one message produced, whatever became of each. */
+export declare function useMessageCalendarSuggestions(messageId: string): CalendarSuggestionsResult;
+/** The suggestions still waiting on the reader, newest first. */
+export declare function usePendingCalendarSuggestions(): CalendarSuggestionsResult;
+export interface PendingCalendarSuggestionResult {
+    suggestion: RemitImapCalendarSuggestionResponse | null | undefined;
+    isLoading: boolean;
+    error: unknown;
+}
+export declare function usePendingCalendarSuggestion(suggestionId: string): PendingCalendarSuggestionResult;
+export type SuggestionAnswer = {
+    kind: "answered";
+} | {
+    kind: "refused";
+    message: string;
+};
+export interface CalendarSuggestionAnswers {
+    accept: (suggestionId: string, calendarId: string) => Promise<SuggestionAnswer>;
+    tentative: (suggestionId: string, calendarId: string) => Promise<SuggestionAnswer>;
+    acceptEdited: (suggestionId: string, input: RemitImapAcceptCalendarSuggestionInput) => Promise<SuggestionAnswer>;
+    decline: (suggestionId: string) => Promise<SuggestionAnswer>;
+    dismiss: (suggestionId: string, muteSender: boolean) => Promise<SuggestionAnswer>;
+    reopen: (suggestionId: string) => Promise<SuggestionAnswer>;
+    isAnswering: boolean;
+}
+export declare function useCalendarSuggestionAnswers(): CalendarSuggestionAnswers;

package/dist/src/hooks/calendar/useCalendarSuggestions.js

@@ -0,0 +1,171 @@
+/**
+ * The events mail offers, and the answers the reader gives them.
+ *
+ * Every card is drawn from what the server holds. An answer is a request, and
+ * the card moves when the listing it came from is read again — never because
+ * this side decided the press worked — so a refused answer leaves the card
+ * where it was, with the refusal stated beside it.
+ *
+ * Answers come back as outcomes rather than throws, for the reason the event
+ * writes do: a surface switching on a caught `unknown` cannot tell a refusal it
+ * must state from a fault it must not swallow. A lapsed session is neither, and
+ * escalates the way it does everywhere else.
+ */
+import { calendarSuggestionActionOperationsAcceptCalendarSuggestionMutation, calendarSuggestionActionOperationsDeclineCalendarSuggestionMutation, calendarSuggestionActionOperationsDismissCalendarSuggestionMutation, calendarSuggestionActionOperationsReopenCalendarSuggestionMutation, calendarSuggestionOperationsListCalendarSuggestionsOptions, messageCalendarSuggestionOperationsListMessageCalendarSuggestionsOptions, } from "@remit/api-http-client/@tanstack/react-query.gen.ts";
+import { calendarSuggestionOperationsListCalendarSuggestions } from "@remit/api-http-client/sdk.gen.ts";
+import { formatErrorMessage } from "@remit/ui";
+import { useMutation, useQuery, useQueryClient, } from "@tanstack/react-query";
+import { useCallback, useMemo } from "react";
+import { softErrorStatuses } from "../../lib/error-classifier";
+const SUGGESTION_META = softErrorStatuses(400, 404);
+/** Every read an answer can change: the cards, the calendar, the sender rules. */
+const ANSWERED_QUERY_IDS = new Set([
+    "calendarSuggestionOperationsListCalendarSuggestions",
+    "messageCalendarSuggestionOperationsListMessageCalendarSuggestions",
+    "calendarEventOperationsListCalendarEvents",
+    "calendarEventDetailOperationsGetCalendarEvent",
+    "calendarFreeBusyOperationsListCalendarFreeBusy",
+    "filterOperationsListFilters",
+]);
+const invalidateAnswered = (queryClient) => queryClient.invalidateQueries({
+    predicate: (query) => {
+        const head = query.queryKey[0];
+        if (typeof head !== "object" || head === null)
+            return false;
+        const id = head._id;
+        return typeof id === "string" && ANSWERED_QUERY_IDS.has(id);
+    },
+});
+/** Every suggestion one message produced, whatever became of each. */
+export function useMessageCalendarSuggestions(messageId) {
+    const { data, isLoading, error } = useQuery({
+        ...messageCalendarSuggestionOperationsListMessageCalendarSuggestionsOptions({ path: { messageId } }),
+        meta: SUGGESTION_META,
+    });
+    return {
+        suggestions: data?.items ?? [],
+        isLoading,
+        error: error ?? null,
+    };
+}
+/** The suggestions still waiting on the reader, newest first. */
+export function usePendingCalendarSuggestions() {
+    const { data, isLoading, error } = useQuery({
+        ...calendarSuggestionOperationsListCalendarSuggestionsOptions({
+            query: { state: "Pending" },
+        }),
+        meta: SUGGESTION_META,
+    });
+    return {
+        suggestions: data?.items ?? [],
+        isLoading,
+        error: error ?? null,
+    };
+}
+const findPending = async (suggestionId, signal) => {
+    let continuationToken;
+    do {
+        const { data } = await calendarSuggestionOperationsListCalendarSuggestions({
+            query: { state: "Pending", continuationToken },
+            signal,
+            throwOnError: true,
+        });
+        const found = data.items.find((item) => item.suggestionId === suggestionId);
+        if (found)
+            return found;
+        continuationToken = data.continuationToken;
+    } while (continuationToken);
+    return null;
+};
+export function usePendingCalendarSuggestion(suggestionId) {
+    const { data, isLoading, error } = useQuery({
+        queryKey: [
+            {
+                _id: "calendarSuggestionOperationsListCalendarSuggestions",
+                suggestionId,
+            },
+        ],
+        queryFn: ({ signal }) => findPending(suggestionId, signal),
+        meta: SUGGESTION_META,
+    });
+    return { suggestion: data, isLoading, error: error ?? null };
+}
+const ANSWERED = { kind: "answered" };
+const refused = (error) => ({
+    kind: "refused",
+    message: formatErrorMessage(error),
+});
+export function useCalendarSuggestionAnswers() {
+    const queryClient = useQueryClient();
+    const onSuccess = useCallback(() => invalidateAnswered(queryClient), [queryClient]);
+    const accept = useMutation({
+        ...calendarSuggestionActionOperationsAcceptCalendarSuggestionMutation(),
+        meta: SUGGESTION_META,
+        onSuccess,
+    });
+    const decline = useMutation({
+        ...calendarSuggestionActionOperationsDeclineCalendarSuggestionMutation(),
+        meta: SUGGESTION_META,
+        onSuccess,
+    });
+    const dismiss = useMutation({
+        ...calendarSuggestionActionOperationsDismissCalendarSuggestionMutation(),
+        meta: SUGGESTION_META,
+        onSuccess,
+    });
+    const reopen = useMutation({
+        ...calendarSuggestionActionOperationsReopenCalendarSuggestionMutation(),
+        meta: SUGGESTION_META,
+        onSuccess,
+    });
+    const acceptSuggestion = useCallback((suggestionId, calendarId) => accept
+        .mutateAsync({ path: { suggestionId }, body: { calendarId } })
+        .then(() => ANSWERED)
+        .catch(refused), [accept]);
+    const tentativeSuggestion = useCallback((suggestionId, calendarId) => accept
+        .mutateAsync({
+        path: { suggestionId },
+        body: { calendarId, answer: "Tentative" },
+    })
+        .then(() => ANSWERED)
+        .catch(refused), [accept]);
+    const acceptEditedSuggestion = useCallback((suggestionId, input) => accept
+        .mutateAsync({ path: { suggestionId }, body: input })
+        .then(() => ANSWERED)
+        .catch(refused), [accept]);
+    const declineSuggestion = useCallback((suggestionId) => decline
+        .mutateAsync({ path: { suggestionId } })
+        .then(() => ANSWERED)
+        .catch(refused), [decline]);
+    const dismissSuggestion = useCallback((suggestionId, muteSender) => dismiss
+        .mutateAsync({ path: { suggestionId }, body: { muteSender } })
+        .then(() => ANSWERED)
+        .catch(refused), [dismiss]);
+    const reopenSuggestion = useCallback((suggestionId) => reopen
+        .mutateAsync({ path: { suggestionId } })
+        .then(() => ANSWERED)
+        .catch(refused), [reopen]);
+    return useMemo(() => ({
+        accept: acceptSuggestion,
+        tentative: tentativeSuggestion,
+        acceptEdited: acceptEditedSuggestion,
+        decline: declineSuggestion,
+        dismiss: dismissSuggestion,
+        reopen: reopenSuggestion,
+        isAnswering: accept.isPending ||
+            decline.isPending ||
+            dismiss.isPending ||
+            reopen.isPending,
+    }), [
+        acceptSuggestion,
+        tentativeSuggestion,
+        acceptEditedSuggestion,
+        declineSuggestion,
+        dismissSuggestion,
+        reopenSuggestion,
+        accept.isPending,
+        decline.isPending,
+        dismiss.isPending,
+        reopen.isPending,
+    ]);
+}

package/dist/src/hooks/calendar/useCalendarWrites.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Creating, editing and deleting an event.
+ *
+ * Every write is conditional on the version the reader was looking at. A 412
+ * means somebody replaced the resource in between — over CalDAV, in another
+ * tab, from an accepted invitation — and applying the edit would discard their
+ * change with nobody seeing it happen. That comes back as an outcome the
+ * surface states, never as a write that quietly wins.
+ *
+ * Outcomes are returned rather than thrown: a caught value is `unknown`, and a
+ * surface that has to switch on one cannot tell a refusal it must render from a
+ * fault it must not swallow. Faults still escalate — these carry only the
+ * statuses this surface owns, so a lapsed session takes the screen the way it
+ * does everywhere else.
+ */
+import type { RemitImapCreateCalendarEventInput, RemitImapUpdateCalendarEventInput } from "@remit/api-http-client/types.gen.ts";
+import type { RecurrenceScope } from "@remit/ui";
+export type CalendarWriteOutcome = {
+    kind: "written";
+} | {
+    kind: "conflict";
+} | {
+    kind: "refused";
+    message: string;
+};
+export interface ScopedWrite {
+    calendarObjectId: string;
+    calendarId: string;
+    /** The occurrence the reader clicked. `""` on a resource that does not recur. */
+    recurrenceId: string;
+    /** Absent on a resource that does not recur — the server defaults to `All`. */
+    scope?: RecurrenceScope;
+    /** The version the edit was built on. */
+    etag: string;
+}
+export interface CalendarWrites {
+    createEvent: (input: RemitImapCreateCalendarEventInput) => Promise<CalendarWriteOutcome>;
+    updateEvent: (write: ScopedWrite, patch: RemitImapUpdateCalendarEventInput) => Promise<CalendarWriteOutcome>;
+    deleteEvent: (write: ScopedWrite) => Promise<CalendarWriteOutcome>;
+    isWriting: boolean;
+}
+/** Everything a write invalidates: the windows, the resource, the busy spans. */
+export declare function useInvalidateCalendarReads(): () => void;
+export declare function useCalendarWrites(): CalendarWrites;

package/dist/src/hooks/calendar/useCalendarWrites.js

@@ -0,0 +1,109 @@
+/**
+ * Creating, editing and deleting an event.
+ *
+ * Every write is conditional on the version the reader was looking at. A 412
+ * means somebody replaced the resource in between — over CalDAV, in another
+ * tab, from an accepted invitation — and applying the edit would discard their
+ * change with nobody seeing it happen. That comes back as an outcome the
+ * surface states, never as a write that quietly wins.
+ *
+ * Outcomes are returned rather than thrown: a caught value is `unknown`, and a
+ * surface that has to switch on one cannot tell a refusal it must render from a
+ * fault it must not swallow. Faults still escalate — these carry only the
+ * statuses this surface owns, so a lapsed session takes the screen the way it
+ * does everywhere else.
+ */
+import { calendarEventDetailOperationsDeleteCalendarEventMutation, calendarEventDetailOperationsUpdateCalendarEventMutation, calendarEventOperationsCreateCalendarEventMutation, } from "@remit/api-http-client/@tanstack/react-query.gen.ts";
+import { formatErrorMessage } from "@remit/ui";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { useCallback, useMemo } from "react";
+import { getErrorStatus, softErrorStatuses } from "../../lib/error-classifier";
+/** The refusals a calendar surface renders itself. A 401 is not among them. */
+const CALENDAR_WRITE_META = softErrorStatuses(400, 404, 412);
+/** Every read whose answer a write can change. */
+const CALENDAR_QUERY_IDS = new Set([
+    "calendarEventOperationsListCalendarEvents",
+    "calendarEventDetailOperationsGetCalendarEvent",
+    "calendarFreeBusyOperationsListCalendarFreeBusy",
+]);
+const WRITTEN = { kind: "written" };
+const outcomeFor = (error) => getErrorStatus(error) === 412
+    ? { kind: "conflict" }
+    : { kind: "refused", message: formatErrorMessage(error) };
+const SCOPES = {
+    this: "This",
+    following: "Following",
+    all: "All",
+};
+/** Everything a write invalidates: the windows, the resource, the busy spans. */
+export function useInvalidateCalendarReads() {
+    const queryClient = useQueryClient();
+    return useCallback(() => {
+        void queryClient.invalidateQueries({
+            predicate: (query) => {
+                const head = query.queryKey[0];
+                if (typeof head !== "object" || head === null)
+                    return false;
+                const id = head._id;
+                return typeof id === "string" && CALENDAR_QUERY_IDS.has(id);
+            },
+        });
+    }, [queryClient]);
+}
+/**
+ * The occurrence rides along under `All` too: an edit's times are the times of
+ * the occurrence it was made from, and the server moves the series by as much.
+ */
+const scopeQuery = ({ scope, recurrenceId }) => scope === undefined ? {} : { scope: SCOPES[scope], recurrenceId };
+export function useCalendarWrites() {
+    const invalidate = useInvalidateCalendarReads();
+    const create = useMutation({
+        ...calendarEventOperationsCreateCalendarEventMutation(),
+        meta: CALENDAR_WRITE_META,
+        onSuccess: invalidate,
+    });
+    const update = useMutation({
+        ...calendarEventDetailOperationsUpdateCalendarEventMutation(),
+        meta: CALENDAR_WRITE_META,
+        onSuccess: invalidate,
+    });
+    const remove = useMutation({
+        ...calendarEventDetailOperationsDeleteCalendarEventMutation(),
+        meta: CALENDAR_WRITE_META,
+        onSuccess: invalidate,
+    });
+    const createEvent = useCallback((input) => create
+        .mutateAsync({ body: input })
+        .then(() => WRITTEN)
+        .catch(outcomeFor), [create]);
+    const updateEvent = useCallback((write, patch) => update
+        .mutateAsync({
+        path: { calendarObjectId: write.calendarObjectId },
+        query: { calendarId: write.calendarId, ...scopeQuery(write) },
+        headers: { "If-Match": write.etag },
+        body: patch,
+    })
+        .then(() => WRITTEN)
+        .catch(outcomeFor), [update]);
+    const deleteEvent = useCallback((write) => remove
+        .mutateAsync({
+        path: { calendarObjectId: write.calendarObjectId },
+        query: { calendarId: write.calendarId, ...scopeQuery(write) },
+        headers: { "If-Match": write.etag },
+    })
+        .then(() => WRITTEN)
+        .catch(outcomeFor), [remove]);
+    return useMemo(() => ({
+        createEvent,
+        updateEvent,
+        deleteEvent,
+        isWriting: create.isPending || update.isPending || remove.isPending,
+    }), [
+        createEvent,
+        updateEvent,
+        deleteEvent,
+        create.isPending,
+        update.isPending,
+        remove.isPending,
+    ]);
+}

package/dist/src/hooks/calendar/useCalendars.d.ts

@@ -0,0 +1,20 @@
+import type { RemitImapCalendarResponse } from "@remit/api-http-client/types.gen.ts";
+import type { CalendarColorId, CalendarDescriptor } from "@remit/ui";
+export interface CalendarsResult {
+    calendars: CalendarDescriptor[];
+    /** The collections as the API returned them, for a surface that manages them. */
+    collections: RemitImapCalendarResponse[];
+    colorByCalendarId: Record<string, CalendarColorId>;
+    /** The zone each collection's floating times are read in. */
+    timeZoneByCalendarId: Record<string, string>;
+    /**
+     * Where an accepted invitation lands: the collection the account was
+     * provisioned with, or the first one when that is gone. `""` until the
+     * listing has answered.
+     */
+    defaultCalendarId: string;
+    isLoading: boolean;
+    /** Why the listing could not be read; null when it was. */
+    error: unknown;
+}
+export declare function useCalendars(): CalendarsResult;

package/dist/src/hooks/calendar/useCalendars.js

@@ -0,0 +1,30 @@
+/**
+ * The calendars the account holds.
+ *
+ * The listing provisions a default collection on first read, so this never
+ * comes back empty for a working account and no surface has to know how a
+ * calendar gets made. It carries no `softError` meta: a session that has lapsed
+ * escalates to the signed-out state rather than drawing an empty week, which is
+ * indistinguishable from a week with nothing in it.
+ */
+import { calendarOperationsListCalendarsOptions } from "@remit/api-http-client/@tanstack/react-query.gen.ts";
+import { useQuery } from "@tanstack/react-query";
+import { useMemo } from "react";
+import { toCalendarDescriptor } from "./instance";
+export function useCalendars() {
+    const { data, isLoading, error } = useQuery(calendarOperationsListCalendarsOptions());
+    return useMemo(() => {
+        const items = data?.items ?? [];
+        const calendars = items.map(toCalendarDescriptor);
+        return {
+            calendars,
+            collections: items,
+            colorByCalendarId: Object.fromEntries(calendars.map((calendar) => [calendar.id, calendar.color])),
+            timeZoneByCalendarId: Object.fromEntries(items.map((item) => [item.calendarId, item.timezone])),
+            defaultCalendarId: (items.find((item) => item.source === "Default") ?? items[0])
+                ?.calendarId ?? "",
+            isLoading,
+            error: error ?? null,
+        };
+    }, [data, isLoading, error]);
+}

package/dist/src/hooks/calendar/useDraftClashes.d.ts

@@ -0,0 +1,15 @@
+/**
+ * What the span a draft names runs into, across every calendar the reader
+ * holds — so the editor says so before Save rather than the grid after it.
+ *
+ * Read on the weeks from the draft's first day through its last, which for a
+ * single-day draft is the grid's own cache entry, and measured by the same rule the invitation card uses. Undefined
+ * while there is no span to check (all day, a time missing, an end not after
+ * the start) or no answer to
+ * check it against: drawing "nothing else is booked" over a read that has not
+ * landed is a claim, not a delay.
+ */
+import { type CalendarClash, type EventDraft } from "@remit/ui";
+export declare function useDraftClashes(draft: EventDraft, 
+/** The resource being edited, which never clashes with itself. */
+calendarObjectId?: string): CalendarClash[] | undefined;

package/dist/src/hooks/calendar/useDraftClashes.js

@@ -0,0 +1,68 @@
+/**
+ * What the span a draft names runs into, across every calendar the reader
+ * holds — so the editor says so before Save rather than the grid after it.
+ *
+ * Read on the weeks from the draft's first day through its last, which for a
+ * single-day draft is the grid's own cache entry, and measured by the same rule the invitation card uses. Undefined
+ * while there is no span to check (all day, a time missing, an end not after
+ * the start) or no answer to
+ * check it against: drawing "nothing else is booked" over a read that has not
+ * landed is a claim, not a delay.
+ */
+import { clashesWith, } from "@remit/ui";
+import { useMemo } from "react";
+import { formatEventWhen } from "../../lib/calendar-format";
+import { deviceTimeZone, isDrawnInstance, toCalendarEventData, UNZONED_CALENDAR, } from "./instance";
+import { useCalendarEventWindow } from "./useCalendarEvents";
+import { useCalendars } from "./useCalendars";
+import { calendarWindow, isoAtInZone } from "./window";
+const EVERY_CALENDAR = [];
+const NO_WINDOW = { from: "", to: "" };
+export function useDraftClashes(draft, 
+/** The resource being edited, which never clashes with itself. */
+calendarObjectId = "") {
+    const { timeZoneByCalendarId } = useCalendars();
+    const checkable = draft.date !== "" &&
+        !draft.allDay &&
+        draft.endDate !== "" &&
+        draft.startTime !== "" &&
+        draft.endTime !== "" &&
+        `${draft.endDate}T${draft.endTime}` > `${draft.date}T${draft.startTime}`;
+    const { instances, isLoading, error } = useCalendarEventWindow({
+        ...(checkable
+            ? {
+                from: calendarWindow("week", draft.date).from,
+                to: calendarWindow("week", draft.endDate).to,
+            }
+            : NO_WINDOW),
+        calendarIds: EVERY_CALENDAR,
+        enabled: checkable,
+    });
+    const zone = deviceTimeZone();
+    return useMemo(() => {
+        if (!checkable || isLoading || error)
+            return undefined;
+        const start = isoAtInZone(draft.date, draft.startTime, zone);
+        const end = isoAtInZone(draft.endDate, draft.endTime, zone);
+        const others = instances
+            .filter((instance) => isDrawnInstance(instance) &&
+            instance.calendarObjectId !== calendarObjectId)
+            .map((instance) => toCalendarEventData(instance, timeZoneByCalendarId[instance.calendarId] ?? UNZONED_CALENDAR, zone));
+        return clashesWith({ start, end }, others).map((event) => ({
+            id: event.id,
+            label: `${event.title}, ${formatEventWhen(event)}`,
+        }));
+    }, [
+        checkable,
+        isLoading,
+        error,
+        draft.date,
+        draft.endDate,
+        draft.startTime,
+        draft.endTime,
+        zone,
+        instances,
+        calendarObjectId,
+        timeZoneByCalendarId,
+    ]);
+}

package/dist/src/hooks/calendar/window.d.ts

@@ -0,0 +1,57 @@
+/**
+ * The stretch of time a calendar surface is asking the server about.
+ *
+ * A window is derived from the address rather than from the day the reader
+ * happens to be on, so every day inside one week asks for the same window and
+ * stepping back to a week already read is a cache hit rather than a request.
+ *
+ * Nothing here reads a clock: the caller passes the day it is drawing, and the
+ * offsets come from that day rather than from today, so a window spanning a DST
+ * change carries the right offset at each end.
+ */
+import type { CalendarViewId } from "@remit/ui";
+export interface CalendarWindow {
+    /** ISO 8601 date-time with offset. Inclusive. */
+    from: string;
+    /** ISO 8601 date-time with offset. Exclusive. */
+    to: string;
+}
+/** A clock time on a civil date, carrying the offset the device is on then. */
+export declare function isoAt(date: string, time: string): string;
+/**
+ * A clock time on a civil date, carrying the offset **that zone** is on then.
+ *
+ * The device's own offset is the wrong one for a calendar anchored elsewhere: a
+ * 10:00 Amsterdam meeting rewritten with a New York offset is a 16:00 Amsterdam
+ * meeting, and nothing on screen says it moved.
+ *
+ * The offset is read twice because reading it needs an instant and the instant
+ * needs the offset. The first pass is off only inside a DST transition, and the
+ * second pass — taken at the instant the first one implies — settles it.
+ */
+export declare function isoAtInZone(date: string, time: string, timeZone: string): string;
+/**
+ * An instant written again as the wall time it reads as on a zone's clock.
+ *
+ * The listing serves each occurrence on its collection's clock, and the grid,
+ * the strip and the form all read the digits. Drawing those digits as they came
+ * puts a Tokyo calendar's 08:00 at 08:00 in New York; re-reading the instant on
+ * the device's clock is what puts it at 18:00 the evening before.
+ */
+export declare function isoOnClock(iso: string, timeZone: string): string;
+/** Midnight on a civil date, carrying the offset the device is on that day. */
+export declare const startOfDay: (date: string) => string;
+export declare function addDays(date: string, days: number): string;
+/**
+ * The window a view over a day covers.
+ *
+ * The week is the unit every surface reads in. A grid asks for the one week it
+ * draws; the strip holds many days and asks for each of their weeks
+ * (`weekWindowsOver`), because a single read may not cover more than a year and
+ * a range that grows as the reader scrolls would eventually become one. Both
+ * therefore key on the same entries, so dropping into the grid and coming back
+ * out to the strip fetches nothing either of them already holds.
+ */
+export declare function calendarWindow(view: CalendarViewId, date: string): CalendarWindow;
+/** A window of whole days from one civil date, for a surface rolling its own. */
+export declare function calendarWindowOfDays(date: string, days: number): CalendarWindow;