@remit/web-client 0.0.324 → 0.0.326

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

@@ -0,0 +1,110 @@
+/**
+ * The days the strip currently holds, and the arithmetic that grows them.
+ *
+ * The agenda never paginates. It holds one contiguous run of days around the
+ * day the address names and grows it at whichever end the reader reaches, so
+ * there are no page boundaries to lose a place at and no request that throws
+ * away what is already on screen. The range is the only thing a window is: what
+ * to ask `/calendar-events` and `/calendar-free-busy` for falls out of it.
+ *
+ * Nothing here reads a clock or a router. Every function takes the day it works
+ * from, which is what lets the rules be asserted without either.
+ */
+import { type BusySpan, type CalendarDay, type FreeStretch } from "@remit/ui";
+import { type CalendarWindow } from "./window";
+/**
+ * Days held behind and ahead of the day the address opened on. More ahead than
+ * behind: a reader lands on a calendar to look forward, and the days behind are
+ * there so scrolling back a little does not immediately fetch.
+ */
+export declare const LEAD_IN = 10;
+export declare const LEAD_OUT = 24;
+/** What reaching an end adds to it: the next week, and no more. */
+export declare const PAGE = 7;
+/**
+ * How far the run grows on the reader's scroll before it stops and asks.
+ *
+ * A year either way is further than anyone scrolls in one sitting, so the cap
+ * costs a reader nothing and bounds the damage of anything that asks for more
+ * days without one behind it. The strip is shorter than the reach it fetches at
+ * whenever the diary is sparse, and a run that grew on that alone walked out to
+ * a decade of empty weeks and took the address with it.
+ */
+export declare const CAP_WEEKS = 52;
+export interface AgendaRange {
+    /** `YYYY-MM-DD`, inclusive. */
+    from: string;
+    /** `YYYY-MM-DD`, inclusive. */
+    to: string;
+    /** The earliest day scrolling alone may reach. */
+    floor: string;
+    /** The latest. */
+    ceiling: string;
+}
+export declare const rangeAround: (date: string) => AgendaRange;
+/** The run has grown as far back as it may on its own. */
+export declare const rangeAtFloor: (range: AgendaRange) => boolean;
+export declare const rangeAtCeiling: (range: AgendaRange) => boolean;
+/** At the cap this is the range it was given, identically, so nothing refetches. */
+export declare const extendRangeStart: (range: AgendaRange) => AgendaRange;
+export declare const extendRangeEnd: (range: AgendaRange) => AgendaRange;
+/**
+ * The cap lifted, by a reader who said so. Another year opens behind the day
+ * the run has reached and the days already held stay where they are, so the
+ * strip keeps growing on the scroll from there.
+ */
+export declare const liftRangeFloor: (range: AgendaRange) => AgendaRange;
+export declare const liftRangeCeiling: (range: AgendaRange) => AgendaRange;
+/**
+ * The range that has a day in it. A day already held keeps the range it is in —
+ * identically, so a scroll that moved the address does not throw away the days
+ * either side of it and refetch them. A day outside it is a jump, and a jump
+ * opens a window around where it landed rather than stretching one across the
+ * months in between.
+ */
+export declare function rangeCovering(range: AgendaRange, date: string): AgendaRange;
+/**
+ * The week each day of the range is served by, deduplicated and in order.
+ *
+ * The strip holds more days than one read may ask for — the server refuses a
+ * window over a year — so the range says which weeks to fetch rather than being
+ * a window itself. Reaching an end then adds a week to this list instead of
+ * widening a single request, which is what keeps the days already on screen
+ * where they are.
+ *
+ * The weeks are `calendarWindow("week", …)` exactly, so they are the grid's own
+ * cache entries: a reader who drops into the week grid and comes back out draws
+ * from what the strip fetched, and a week the grid has already read costs the
+ * strip nothing.
+ */
+export declare function weekWindowsOver(dates: readonly string[]): CalendarWindow[];
+/** The week window a day belongs to, named by its `from`. */
+export declare const weekKeyOf: (date: string) => string;
+/**
+ * Busy spans as minutes of the days they cross, on the clock this device is
+ * reading. The API answers in UTC instants because a busy stretch is an
+ * interval rather than a civil date, so the split into days happens here, where
+ * the zone the strip is drawn in is known.
+ *
+ * A span crossing midnight becomes one entry per day it touches. Each day's
+ * entries come back sorted and merged, which is the shape the free-time rule
+ * takes.
+ */
+export declare function busySpansByDate(dates: readonly string[], spans: readonly {
+    start: string;
+    end: string;
+}[]): Map<string, BusySpan[]>;
+/**
+ * The free time on every day the strip holds, out of the busy spans the server
+ * merged across every calendar. It is `freeStretchesFromSpans` and nothing
+ * else: the rule lives in `@remit/ui` beside the strip that draws it, so this
+ * only decides which spans a day gets.
+ */
+export declare function freeStretchesByDate(dates: readonly string[], spans: readonly {
+    start: string;
+    end: string;
+}[]): Map<string, FreeStretch[]>;
+/** The days a range names, in order. */
+export declare const datesInRange: (range: AgendaRange) => string[];
+/** How the strip asks a day what is still open on it. */
+export type FreeLookup = (day: CalendarDay) => FreeStretch[];

package/dist/src/hooks/calendar/agenda-window.js

@@ -0,0 +1,159 @@
+/**
+ * The days the strip currently holds, and the arithmetic that grows them.
+ *
+ * The agenda never paginates. It holds one contiguous run of days around the
+ * day the address names and grows it at whichever end the reader reaches, so
+ * there are no page boundaries to lose a place at and no request that throws
+ * away what is already on screen. The range is the only thing a window is: what
+ * to ask `/calendar-events` and `/calendar-free-busy` for falls out of it.
+ *
+ * Nothing here reads a clock or a router. Every function takes the day it works
+ * from, which is what lets the rules be asserted without either.
+ */
+import { datesBetween, freeStretchesFromSpans, mergeBusySpans, } from "@remit/ui";
+import { isoDate } from "../../lib/calendar-route";
+import { addDays, calendarWindow } from "./window";
+/**
+ * Days held behind and ahead of the day the address opened on. More ahead than
+ * behind: a reader lands on a calendar to look forward, and the days behind are
+ * there so scrolling back a little does not immediately fetch.
+ */
+export const LEAD_IN = 10;
+export const LEAD_OUT = 24;
+/** What reaching an end adds to it: the next week, and no more. */
+export const PAGE = 7;
+/**
+ * How far the run grows on the reader's scroll before it stops and asks.
+ *
+ * A year either way is further than anyone scrolls in one sitting, so the cap
+ * costs a reader nothing and bounds the damage of anything that asks for more
+ * days without one behind it. The strip is shorter than the reach it fetches at
+ * whenever the diary is sparse, and a run that grew on that alone walked out to
+ * a decade of empty weeks and took the address with it.
+ */
+export const CAP_WEEKS = 52;
+const CAP_DAYS = CAP_WEEKS * 7;
+export const rangeAround = (date) => ({
+    from: addDays(date, -LEAD_IN),
+    to: addDays(date, LEAD_OUT),
+    floor: addDays(date, -CAP_DAYS),
+    ceiling: addDays(date, CAP_DAYS),
+});
+/** The run has grown as far back as it may on its own. */
+export const rangeAtFloor = (range) => range.from <= range.floor;
+export const rangeAtCeiling = (range) => range.to >= range.ceiling;
+const later = (a, b) => (a > b ? a : b);
+const earlier = (a, b) => (a < b ? a : b);
+/** At the cap this is the range it was given, identically, so nothing refetches. */
+export const extendRangeStart = (range) => rangeAtFloor(range)
+    ? range
+    : { ...range, from: later(addDays(range.from, -PAGE), range.floor) };
+export const extendRangeEnd = (range) => rangeAtCeiling(range)
+    ? range
+    : { ...range, to: earlier(addDays(range.to, PAGE), range.ceiling) };
+/**
+ * The cap lifted, by a reader who said so. Another year opens behind the day
+ * the run has reached and the days already held stay where they are, so the
+ * strip keeps growing on the scroll from there.
+ */
+export const liftRangeFloor = (range) => extendRangeStart({ ...range, floor: addDays(range.from, -CAP_DAYS) });
+export const liftRangeCeiling = (range) => extendRangeEnd({ ...range, ceiling: addDays(range.to, CAP_DAYS) });
+/**
+ * The range that has a day in it. A day already held keeps the range it is in —
+ * identically, so a scroll that moved the address does not throw away the days
+ * either side of it and refetch them. A day outside it is a jump, and a jump
+ * opens a window around where it landed rather than stretching one across the
+ * months in between.
+ */
+export function rangeCovering(range, date) {
+    if (date >= range.from && date <= range.to)
+        return range;
+    return rangeAround(date);
+}
+/**
+ * The week each day of the range is served by, deduplicated and in order.
+ *
+ * The strip holds more days than one read may ask for — the server refuses a
+ * window over a year — so the range says which weeks to fetch rather than being
+ * a window itself. Reaching an end then adds a week to this list instead of
+ * widening a single request, which is what keeps the days already on screen
+ * where they are.
+ *
+ * The weeks are `calendarWindow("week", …)` exactly, so they are the grid's own
+ * cache entries: a reader who drops into the week grid and comes back out draws
+ * from what the strip fetched, and a week the grid has already read costs the
+ * strip nothing.
+ */
+export function weekWindowsOver(dates) {
+    const byStart = new Map();
+    for (const date of dates) {
+        const week = calendarWindow("week", date);
+        if (!byStart.has(week.from))
+            byStart.set(week.from, week);
+    }
+    return [...byStart.values()];
+}
+/** The week window a day belongs to, named by its `from`. */
+export const weekKeyOf = (date) => calendarWindow("week", date).from;
+const MINUTES_IN_DAY = 24 * 60;
+const minuteOfInstant = (instant) => instant.getHours() * 60 + instant.getMinutes();
+/**
+ * Busy spans as minutes of the days they cross, on the clock this device is
+ * reading. The API answers in UTC instants because a busy stretch is an
+ * interval rather than a civil date, so the split into days happens here, where
+ * the zone the strip is drawn in is known.
+ *
+ * A span crossing midnight becomes one entry per day it touches. Each day's
+ * entries come back sorted and merged, which is the shape the free-time rule
+ * takes.
+ */
+export function busySpansByDate(dates, spans) {
+    const held = new Set(dates);
+    const byDate = new Map();
+    for (const span of spans) {
+        const start = new Date(span.start);
+        const end = new Date(span.end);
+        if (Number.isNaN(start.getTime()) || Number.isNaN(end.getTime()))
+            continue;
+        if (end.getTime() <= start.getTime())
+            continue;
+        const firstDate = isoDate(start);
+        // The instant before the end, so a span ending at midnight belongs to the
+        // day it ran through rather than opening an empty entry on the next one.
+        const lastDate = isoDate(new Date(end.getTime() - 1));
+        for (let date = firstDate; date <= lastDate; date = addDays(date, 1)) {
+            if (!held.has(date))
+                continue;
+            const from = date === firstDate ? minuteOfInstant(start) : 0;
+            // Read off the end's own day rather than off the loop: a span ending at
+            // midnight belongs to the day it ran through, where its end is the end
+            // of that day and not minute zero of the next one.
+            const to = isoDate(end) === date ? minuteOfInstant(end) : MINUTES_IN_DAY;
+            if (to <= from)
+                continue;
+            const day = byDate.get(date);
+            if (day)
+                day.push({ from, to });
+            else
+                byDate.set(date, [{ from, to }]);
+        }
+    }
+    for (const [date, day] of byDate)
+        byDate.set(date, mergeBusySpans(day));
+    return byDate;
+}
+/**
+ * The free time on every day the strip holds, out of the busy spans the server
+ * merged across every calendar. It is `freeStretchesFromSpans` and nothing
+ * else: the rule lives in `@remit/ui` beside the strip that draws it, so this
+ * only decides which spans a day gets.
+ */
+export function freeStretchesByDate(dates, spans) {
+    const busy = busySpansByDate(dates, spans);
+    return new Map(dates.map((date) => [
+        date,
+        freeStretchesFromSpans(date, busy.get(date) ?? []),
+    ]));
+}
+/** The days a range names, in order. */
+export const datesInRange = (range) => datesBetween(range.from, range.to);

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

@@ -0,0 +1,59 @@
+/**
+ * The editor's draft, and what the API makes of it.
+ *
+ * A refusal is returned rather than thrown, and it says which field is wrong and
+ * what to do about it — a form that only greys its save button leaves the reader
+ * hunting for the reason.
+ *
+ * An edit sends the fields that changed and nothing else. Absence means
+ * untouched on this API, so patching every field would write back the empty
+ * `location` and `description` a listing never carried and quietly erase them.
+ */
+import type { RemitImapCreateCalendarEventInput, RemitImapUpdateCalendarEventInput } from "@remit/api-http-client/types.gen.ts";
+import { type CalendarEventData, type EventDraft } from "@remit/ui";
+export type DraftRefusal = {
+    ok: false;
+    problem: string;
+};
+/**
+ * The two zones a write needs. `clock` is the one the form's digits were read
+ * on — the device's, which every surface draws on — and it decides the offset,
+ * so the instant saved is the instant shown. `anchor` is the zone the event is
+ * stored in, written as the TZID a series keeps its wall time in across a DST
+ * change (`anchorZoneFor`); `""` anchors it in UTC.
+ */
+export interface DraftZones {
+    clock: string;
+    anchor: string;
+}
+export type CreateInput = {
+    ok: true;
+    input: RemitImapCreateCalendarEventInput;
+} | DraftRefusal;
+export type UpdatePatch = {
+    ok: true;
+    patch: RemitImapUpdateCalendarEventInput;
+} | DraftRefusal;
+/** A blank event, an hour long, at the start of a working day. */
+export declare function emptyDraft(date: string, calendarId: string): EventDraft;
+/**
+ * The draft an event opens into, so an edit starts from what is stored rather
+ * than from what a grid chip had room to draw. The occurrence listing carries
+ * neither the location nor the notes, so those come from the resource.
+ */
+export declare function draftFromEvent(event: CalendarEventData, stored: {
+    repeat: string;
+    location: string;
+    notes: string;
+}): EventDraft;
+/**
+ * The draft's wall clock, pinned to an instant on the clock it was read on.
+ * Stamping any other zone's offset onto those digits moves the event by the
+ * difference between the two — silently, and only for whoever is travelling.
+ */
+export declare function timesFor(draft: EventDraft, clock: string): {
+    start: string;
+    end: string;
+};
+export declare function createInputFromDraft(draft: EventDraft, zones: DraftZones): CreateInput;
+export declare function patchFromDrafts(before: EventDraft, after: EventDraft, zones: DraftZones): UpdatePatch;

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

@@ -0,0 +1,142 @@
+import { lastDayOf } from "@remit/ui";
+import { moveRule, rruleFromText } from "./recurrence-rule";
+import { addDays, isoAtInZone, isoOnClock } from "./window";
+/** A blank event, an hour long, at the start of a working day. */
+export function emptyDraft(date, calendarId) {
+    return {
+        title: "",
+        date,
+        startTime: "09:00",
+        endDate: date,
+        endTime: "10:00",
+        allDay: false,
+        calendarId,
+        location: "",
+        guests: "",
+        notes: "",
+        repeat: "",
+    };
+}
+/**
+ * The draft an event opens into, so an edit starts from what is stored rather
+ * than from what a grid chip had room to draw. The occurrence listing carries
+ * neither the location nor the notes, so those come from the resource.
+ */
+export function draftFromEvent(event, stored) {
+    return {
+        title: event.title,
+        date: event.start.slice(0, 10),
+        startTime: event.allDay ? "" : event.start.slice(11, 16),
+        endDate: lastDayOf(event),
+        endTime: event.allDay ? "" : event.end.slice(11, 16),
+        allDay: event.allDay,
+        calendarId: event.calendarId,
+        location: stored.location,
+        guests: "",
+        notes: stored.notes,
+        repeat: stored.repeat,
+    };
+}
+/**
+ * The draft's wall clock, pinned to an instant on the clock it was read on.
+ * Stamping any other zone's offset onto those digits moves the event by the
+ * difference between the two — silently, and only for whoever is travelling.
+ */
+export function timesFor(draft, clock) {
+    if (draft.allDay)
+        return { start: draft.date, end: addDays(draft.endDate, 1) };
+    return {
+        start: isoAtInZone(draft.date, draft.startTime, clock),
+        end: isoAtInZone(draft.endDate, draft.endTime, clock),
+    };
+}
+/**
+ * The picked rule, stored on the day the event's own zone starts it on rather
+ * than on the day the device showed when it was picked.
+ */
+function storedRule(draft, start, zones) {
+    const rule = rruleFromText(draft.repeat) ?? "";
+    const anchorDate = draft.allDay
+        ? draft.date
+        : isoOnClock(start, zones.anchor === "" ? "UTC" : zones.anchor).slice(0, 10);
+    return moveRule(rule, draft.date, anchorDate);
+}
+/**
+ * An unreadable rule is only a refusal where the reader chose it. An event that
+ * arrived carrying a rule this client cannot put into words is still editable —
+ * the rule is left where it is and every other field saves.
+ */
+function refuse(draft, checkRepeat) {
+    if (draft.title.trim() === "")
+        return "Give the event a title before saving it.";
+    if (draft.date === "")
+        return "Pick the day the event is on.";
+    if (draft.endDate === "")
+        return "Pick the day the event ends on.";
+    if (draft.calendarId === "")
+        return "Pick the calendar to save the event in.";
+    if (!draft.allDay && (draft.startTime === "" || draft.endTime === ""))
+        return "Set a start and an end time, or mark the event all day.";
+    if (draft.allDay && draft.endDate < draft.date)
+        return "The last day is before the first. Move one of them.";
+    if (!draft.allDay &&
+        `${draft.endDate}T${draft.endTime}` <= `${draft.date}T${draft.startTime}`)
+        return "The end is not after the start. Move one of them.";
+    if (checkRepeat && rruleFromText(draft.repeat) === undefined)
+        return "This calendar can't store that repeat rule. Pick one of the offered rules, or turn the repeat off.";
+    return "";
+}
+export function createInputFromDraft(draft, zones) {
+    const problem = refuse(draft, true);
+    if (problem !== "")
+        return { ok: false, problem };
+    const { start, end } = timesFor(draft, zones.clock);
+    return {
+        ok: true,
+        input: {
+            calendarId: draft.calendarId,
+            summary: draft.title.trim(),
+            description: draft.notes,
+            location: draft.location,
+            start,
+            end,
+            allDay: draft.allDay,
+            ...(zones.anchor === "" ? {} : { timeZone: zones.anchor }),
+            recurrenceRule: storedRule(draft, start, zones),
+        },
+    };
+}
+export function patchFromDrafts(before, after, zones) {
+    const repeatChanged = after.repeat !== before.repeat;
+    const allDayChanged = after.allDay !== before.allDay;
+    const startMoved = allDayChanged ||
+        after.date !== before.date ||
+        after.startTime !== before.startTime;
+    const endMoved = startMoved ||
+        after.endDate !== before.endDate ||
+        after.endTime !== before.endTime;
+    const problem = refuse(after, repeatChanged);
+    if (problem !== "")
+        return { ok: false, problem };
+    const patch = {};
+    if (after.title.trim() !== before.title.trim())
+        patch.summary = after.title.trim();
+    if (after.location !== before.location)
+        patch.location = after.location;
+    if (after.notes !== before.notes)
+        patch.description = after.notes;
+    const { start, end } = timesFor(after, zones.clock);
+    if (startMoved)
+        patch.start = start;
+    if (endMoved) {
+        patch.end = end;
+        patch.allDay = after.allDay;
+        // The offset pins the instant; the zone is what a series needs to keep
+        // meeting at nine when the clocks go back.
+        if (zones.anchor !== "")
+            patch.timeZone = zones.anchor;
+    }
+    if (repeatChanged)
+        patch.recurrenceRule = storedRule(after, start, zones);
+    return { ok: true, patch };
+}

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

@@ -0,0 +1,24 @@
+/**
+ * What every calendar surface reads and writes, in one module.
+ *
+ * The grid, the reading pane and the day strip all ask the same questions, so
+ * they ask them through the same hooks: one window is fetched once however many
+ * of them are on screen, and a write invalidates what all of them are showing.
+ */
+export { type AgendaRange, busySpansByDate, CAP_WEEKS, datesInRange, extendRangeEnd, extendRangeStart, type FreeLookup, freeStretchesByDate, LEAD_IN, LEAD_OUT, liftRangeCeiling, liftRangeFloor, PAGE, rangeAround, rangeAtCeiling, rangeAtFloor, rangeCovering, weekKeyOf, weekWindowsOver, } from "./agenda-window";
+export { type CreateInput, createInputFromDraft, type DraftRefusal, type DraftZones, draftFromEvent, emptyDraft, patchFromDrafts, type UpdatePatch, } from "./draft";
+export { anchorZoneFor, type CalendarInstanceRef, type CalendarJump, calendarInstanceId, calendarJumpOf, deviceTimeZone, isDrawnInstance, readCalendarInstanceId, seriesOccurrenceOf, toCalendarDescriptor, toCalendarEventData, UNZONED_CALENDAR, } from "./instance";
+export { moveRule, rruleFromText, textFromRrule } from "./recurrence-rule";
+export { type CalendarResourceText, rruleFromIcalData, storedAnchorZone, textFromIcalData, } from "./resource";
+export { type CalendarSelection, selectCalendarIds, useCalendarSelection, useDrawnEvents, } from "./selection";
+export { type AcceptEditedInput, acceptEditedInputFromDrafts, draftFromSuggestion, } from "./suggestion-draft";
+export { type CalendarCollectionOutcome, type CalendarCollectionWrites, useCalendarCollectionWrites, } from "./useCalendarCollectionWrites";
+export { type CalendarEventResource, useCalendarEvent, } from "./useCalendarEvent";
+export { CALENDAR_WINDOW_STALE_TIME, type CalendarEventWeeksResult, type CalendarEventWindowRequest, type CalendarEventWindowResult, useCalendarEventWeeks, useCalendarEventWindow, usePrefetchAdjacentWindows, } from "./useCalendarEvents";
+export { type CalendarFreeBusyResult, useCalendarFreeBusyWeeks, } from "./useCalendarFreeBusy";
+export { type CalendarJumpSearch, useCalendarJump } from "./useCalendarJump";
+export { type CalendarSuggestionAnswers, type CalendarSuggestionsResult, type PendingCalendarSuggestionResult, type SuggestionAnswer, useCalendarSuggestionAnswers, useMessageCalendarSuggestions, usePendingCalendarSuggestion, usePendingCalendarSuggestions, } from "./useCalendarSuggestions";
+export { type CalendarsResult, useCalendars } from "./useCalendars";
+export { type CalendarWriteOutcome, type CalendarWrites, type ScopedWrite, useCalendarWrites, useInvalidateCalendarReads, } from "./useCalendarWrites";
+export { useDraftClashes } from "./useDraftClashes";
+export { addDays, type CalendarWindow, calendarWindow, calendarWindowOfDays, isoAt, isoAtInZone, isoOnClock, startOfDay, } from "./window";

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

@@ -0,0 +1,24 @@
+/**
+ * What every calendar surface reads and writes, in one module.
+ *
+ * The grid, the reading pane and the day strip all ask the same questions, so
+ * they ask them through the same hooks: one window is fetched once however many
+ * of them are on screen, and a write invalidates what all of them are showing.
+ */
+export { busySpansByDate, CAP_WEEKS, datesInRange, extendRangeEnd, extendRangeStart, freeStretchesByDate, LEAD_IN, LEAD_OUT, liftRangeCeiling, liftRangeFloor, PAGE, rangeAround, rangeAtCeiling, rangeAtFloor, rangeCovering, weekKeyOf, weekWindowsOver, } from "./agenda-window";
+export { createInputFromDraft, draftFromEvent, emptyDraft, patchFromDrafts, } from "./draft";
+export { anchorZoneFor, calendarInstanceId, calendarJumpOf, deviceTimeZone, isDrawnInstance, readCalendarInstanceId, seriesOccurrenceOf, toCalendarDescriptor, toCalendarEventData, UNZONED_CALENDAR, } from "./instance";
+export { moveRule, rruleFromText, textFromRrule } from "./recurrence-rule";
+export { rruleFromIcalData, storedAnchorZone, textFromIcalData, } from "./resource";
+export { selectCalendarIds, useCalendarSelection, useDrawnEvents, } from "./selection";
+export { acceptEditedInputFromDrafts, draftFromSuggestion, } from "./suggestion-draft";
+export { useCalendarCollectionWrites, } from "./useCalendarCollectionWrites";
+export { useCalendarEvent, } from "./useCalendarEvent";
+export { CALENDAR_WINDOW_STALE_TIME, useCalendarEventWeeks, useCalendarEventWindow, usePrefetchAdjacentWindows, } from "./useCalendarEvents";
+export { useCalendarFreeBusyWeeks, } from "./useCalendarFreeBusy";
+export { useCalendarJump } from "./useCalendarJump";
+export { useCalendarSuggestionAnswers, useMessageCalendarSuggestions, usePendingCalendarSuggestion, usePendingCalendarSuggestions, } from "./useCalendarSuggestions";
+export { useCalendars } from "./useCalendars";
+export { useCalendarWrites, useInvalidateCalendarReads, } from "./useCalendarWrites";
+export { useDraftClashes } from "./useDraftClashes";
+export { addDays, calendarWindow, calendarWindowOfDays, isoAt, isoAtInZone, isoOnClock, startOfDay, } from "./window";

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

@@ -0,0 +1,61 @@
+/**
+ * The API's shapes, as the calendar kit draws them.
+ *
+ * One place does the translating, so the grid, the strip and the reading pane
+ * cannot disagree about what an occurrence is. Nothing here expands a
+ * recurrence: the server returns instances, and this reads them.
+ */
+import type { RemitImapCalendarEventInstance, RemitImapCalendarResponse } from "@remit/api-http-client/types.gen.ts";
+import type { CalendarDescriptor, CalendarEventData } from "@remit/ui";
+/** The device's own clock, the only zone a browser can honestly draw in. */
+export declare const deviceTimeZone: () => string;
+/** A collection that names no zone of its own, spelled the way the API spells it. */
+export declare const UNZONED_CALENDAR = "";
+/**
+ * The zone a write anchors an event in: the collection's, or where it names
+ * none, the device's — a weekly 09:00 written from New York into an unzoned
+ * calendar would otherwise be stored in UTC and meet at 10:00 once the clocks
+ * change. UTC itself has no name the server takes as a TZID, so a device on it
+ * sends nothing, which the server reads as UTC.
+ */
+export declare function anchorZoneFor(collectionZone: string): string;
+export declare function calendarInstanceId(calendarObjectId: string, recurrenceId: string): string;
+export interface CalendarInstanceRef {
+    calendarObjectId: string;
+    /** `""` on a resource that does not recur. */
+    recurrenceId: string;
+}
+export declare function readCalendarInstanceId(id: string): CalendarInstanceRef;
+/**
+ * The occurrence a series opens at when the address names only the series: the
+ * next one still to finish, or the first in the window where none is left.
+ */
+export declare function seriesOccurrenceOf(events: readonly CalendarEventData[], calendarObjectId: string, now: string): CalendarInstanceRef | undefined;
+export interface CalendarJump extends CalendarInstanceRef {
+    calendarId: string;
+    /** On the clock the calendar is drawn in. */
+    date: string;
+}
+/**
+ * Where a view has to move to show an event it does not hold: the day of its
+ * next occurrence still to finish, or of its first where none is left.
+ */
+export declare function calendarJumpOf(instances: readonly RemitImapCalendarEventInstance[], calendarObjectId: string, now: string, clockZone: string): CalendarJump | undefined;
+export declare function toCalendarDescriptor(calendar: RemitImapCalendarResponse): CalendarDescriptor;
+/**
+ * One occurrence, drawn. `location`, `notes` and the guest list are projections
+ * the listing does not carry — the reading pane fetches the resource itself for
+ * those, and a grid chip has no room for them anyway.
+ *
+ * A timed occurrence is re-read on `clockZone`, the clock every surface draws
+ * on. An all-day one is a civil date and keeps only its date: midnight with an
+ * offset is an instant, and a device west of it reads that instant as the day
+ * before.
+ */
+export declare function toCalendarEventData(instance: RemitImapCalendarEventInstance, timeZone: string, clockZone: string): CalendarEventData;
+/**
+ * A cancelled occurrence is not a lighter shade of confirmed, and the kit has
+ * no third state to draw it in, so it is left off the calendar entirely rather
+ * than shown as an event that is still happening.
+ */
+export declare const isDrawnInstance: (instance: RemitImapCalendarEventInstance) => boolean;