@remit/web-client 0.0.231 → 0.0.232

package/src/hooks/calendar/draft.test.ts

@@ -0,0 +1,241 @@
+/**
+ * What the form sends, and what it refuses to send.
+ *
+ * The two rules worth pinning: a refusal names the field and the fix rather
+ * than greying a button, and a patch carries only what changed. Absence means
+ * untouched on this API, so a patch built from every field would write back the
+ * empty location and notes a listing never carried and erase them without
+ * anybody asking for that.
+ */
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import type { EventDraft } from "@remit/ui";
+import {
+	type CreateInput,
+	createInputFromDraft,
+	emptyDraft,
+	patchFromDrafts,
+	type UpdatePatch,
+} from "./draft";
+
+const CALENDAR = "cal_work";
+const AMSTERDAM = "Europe/Amsterdam";
+const NEW_YORK = "America/New_York";
+
+const draft = (over: Partial<EventDraft> = {}): EventDraft => ({
+	...emptyDraft("2026-06-10", CALENDAR),
+	title: "Roadmap review",
+	...over,
+});
+
+const refusal = (result: CreateInput | UpdatePatch): string => {
+	assert.ok(
+		!result.ok,
+		"the draft was accepted where it should have been refused",
+	);
+	return result.problem;
+};
+
+describe("creating an event", () => {
+	it("sends the calendar, the summary and a start with an offset", () => {
+		const built = createInputFromDraft(draft(), AMSTERDAM);
+		assert.ok(built.ok);
+		assert.equal(built.input.calendarId, CALENDAR);
+		assert.equal(built.input.summary, "Roadmap review");
+		assert.equal(built.input.timeZone, AMSTERDAM);
+		assert.equal(built.input.start, "2026-06-10T09:00:00+02:00");
+		assert.equal(built.input.end, "2026-06-10T10:00:00+02:00");
+	});
+
+	it("makes an all-day event a civil date ending on the next one", () => {
+		const built = createInputFromDraft(
+			draft({ allDay: true, startTime: "", endTime: "" }),
+			AMSTERDAM,
+		);
+		assert.ok(built.ok);
+		assert.equal(built.input.start, "2026-06-10");
+		assert.equal(built.input.end, "2026-06-11");
+	});
+
+	it("turns a picked repeat sentence into the rule it means", () => {
+		const built = createInputFromDraft(
+			draft({ repeat: "Every weekday, 09:00" }),
+			AMSTERDAM,
+		);
+		assert.ok(built.ok);
+		assert.equal(
+			built.input.recurrenceRule,
+			"FREQ=WEEKLY;BYDAY=MO,TU,WE,TH,FR",
+		);
+	});
+});
+
+describe("a refusal", () => {
+	it("names the missing title", () => {
+		assert.match(
+			refusal(createInputFromDraft(draft({ title: "  " }), AMSTERDAM)),
+			/title/i,
+		);
+	});
+
+	it("names a span that runs backwards, and what to do about it", () => {
+		assert.match(
+			refusal(
+				createInputFromDraft(
+					draft({ startTime: "11:00", endTime: "10:00" }),
+					AMSTERDAM,
+				),
+			),
+			/end time is not after the start time/i,
+		);
+	});
+
+	it("names a missing time rather than saving a day-long event nobody asked for", () => {
+		assert.match(
+			refusal(createInputFromDraft(draft({ endTime: "" }), AMSTERDAM)),
+			/start and an end time/i,
+		);
+	});
+
+	it("refuses a repeat rule it cannot store, and says to pick another", () => {
+		assert.match(
+			refusal(
+				createInputFromDraft(
+					draft({ repeat: "Every other Tuesday" }),
+					AMSTERDAM,
+				),
+			),
+			/repeat rule/i,
+		);
+	});
+});
+
+describe("editing an event", () => {
+	it("sends only the field that changed", () => {
+		const before = draft({ location: "Room Zuid", notes: "Bring numbers." });
+		const patch = patchFromDrafts(
+			before,
+			{ ...before, title: "Roadmap" },
+			AMSTERDAM,
+		);
+		assert.ok(patch.ok);
+		assert.deepEqual(patch.patch, { summary: "Roadmap" });
+	});
+
+	it("sends both ends and the all-day flag when the event moves", () => {
+		const before = draft();
+		const patch = patchFromDrafts(
+			before,
+			{ ...before, startTime: "08:00" },
+			AMSTERDAM,
+		);
+		assert.ok(patch.ok);
+		assert.equal(patch.patch.allDay, false);
+		assert.equal(patch.patch.start, "2026-06-10T08:00:00+02:00");
+		assert.equal(patch.patch.end, "2026-06-10T10:00:00+02:00");
+	});
+
+	it("leaves an unreadable rule alone rather than refusing every other edit", () => {
+		const before = draft({ repeat: "Repeats" });
+		const patch = patchFromDrafts(
+			before,
+			{ ...before, title: "Standup" },
+			AMSTERDAM,
+		);
+		assert.ok(patch.ok);
+		assert.deepEqual(patch.patch, { summary: "Standup" });
+	});
+
+	it("drops the rule when the reader turns the repeat off", () => {
+		const before = draft({ repeat: "Every weekday, 09:00" });
+		const patch = patchFromDrafts(before, { ...before, repeat: "" }, AMSTERDAM);
+		assert.ok(patch.ok);
+		assert.equal(patch.patch.recurrenceRule, "");
+	});
+
+	it("changes nothing when nothing was touched", () => {
+		const before = draft();
+		const patch = patchFromDrafts(before, { ...before }, AMSTERDAM);
+		assert.ok(patch.ok);
+		assert.deepEqual(patch.patch, {});
+	});
+});
+
+/**
+ * The clock the form shows is the calendar's, not the device's.
+ *
+ * An occurrence is returned in the collection's zone and the form displays
+ * those digits, so rebuilding them with whatever offset the reader's laptop
+ * happens to be on moves the event by the difference — six hours for the same
+ * meeting looked at from New York, with nothing on screen saying it moved.
+ *
+ * Both assertions are absolute rather than "whatever this runner is on": the
+ * bug is precisely that the runner's zone leaked in, so a test that reads it is
+ * a test that cannot see the bug.
+ */
+describe("an event anchored somewhere other than the device", () => {
+	it("keeps a new event on the calendar's clock", () => {
+		const built = createInputFromDraft(draft(), NEW_YORK);
+		assert.ok(built.ok);
+		assert.equal(built.input.start, "2026-06-10T09:00:00-04:00");
+		assert.equal(built.input.timeZone, NEW_YORK);
+	});
+
+	it("moves an event to another day without moving it to another hour", () => {
+		const before = draft();
+		const patch = patchFromDrafts(
+			before,
+			{ ...before, date: "2026-06-17" },
+			AMSTERDAM,
+		);
+		assert.ok(patch.ok);
+		assert.equal(patch.patch.start, "2026-06-17T09:00:00+02:00");
+		assert.equal(patch.patch.end, "2026-06-17T10:00:00+02:00");
+		assert.equal(
+			patch.patch.timeZone,
+			AMSTERDAM,
+			"the offset pins the instant; the zone is what survives a DST change",
+		);
+	});
+
+	it("reads the zone's own winter offset rather than one it saw in June", () => {
+		const built = createInputFromDraft(
+			draft({ date: "2026-01-14" }),
+			AMSTERDAM,
+		);
+		assert.ok(built.ok);
+		assert.equal(built.input.start, "2026-01-14T09:00:00+01:00");
+	});
+
+	it("falls back to the device rather than refusing a zone nothing can resolve", () => {
+		const built = createInputFromDraft(draft(), "Mars/Olympus_Mons");
+		assert.ok(built.ok);
+		assert.match(built.input.start, /^2026-06-10T09:00:00[+-]\d{2}:\d{2}$/);
+	});
+
+	/**
+	 * The canonical IANA list holds no spelling of UTC, so there is nothing to
+	 * send for a collection that names no zone. Absent is what the API asks for
+	 * and the only thing it takes; the device's zone in its place was refused
+	 * outright on a UTC runner.
+	 */
+	it("sends no zone at all where the collection names none", () => {
+		const built = createInputFromDraft(draft(), "");
+		assert.ok(built.ok);
+		assert.equal(built.input.timeZone, undefined);
+		assert.equal(built.input.start, "2026-06-10T09:00:00+00:00");
+		assert.equal(built.input.end, "2026-06-10T10:00:00+00:00");
+	});
+
+	it("leaves the zone out of an edit on that collection too", () => {
+		const before = draft();
+		const patch = patchFromDrafts(
+			before,
+			{ ...before, date: "2026-06-17" },
+			"",
+		);
+		assert.ok(patch.ok);
+		assert.equal(patch.patch.timeZone, undefined);
+		assert.equal(patch.patch.start, "2026-06-17T09:00:00+00:00");
+	});
+});

package/src/hooks/calendar/draft.ts

@@ -0,0 +1,168 @@
+/**
+ * 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, EventDraft } from "@remit/ui";
+import { rruleFromText } from "./recurrence-rule";
+import { addDays, isoAtInZone } from "./window";
+
+export type DraftRefusal = { ok: false; problem: 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 function emptyDraft(date: string, calendarId: string): EventDraft {
+	return {
+		title: "",
+		date,
+		startTime: "09:00",
+		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: CalendarEventData,
+	stored: { repeat: string; location: string; notes: string },
+): EventDraft {
+	return {
+		title: event.title,
+		date: event.start.slice(0, 10),
+		startTime: event.allDay ? "" : event.start.slice(11, 16),
+		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 in the calendar's own zone.
+ *
+ * The zone is the calendar's rather than the device's because that is the clock
+ * the times were read on: the listing returns an occurrence in the collection's
+ * zone, and the form shows those digits. Stamping the device's offset back onto
+ * them moves the event by the difference between the two — silently, and only
+ * for whoever is travelling.
+ */
+function timesFor(
+	draft: EventDraft,
+	timeZone: string,
+): { start: string; end: string } {
+	if (draft.allDay) return { start: draft.date, end: addDays(draft.date, 1) };
+	return {
+		start: isoAtInZone(draft.date, draft.startTime, timeZone),
+		end: isoAtInZone(draft.date, draft.endTime, timeZone),
+	};
+}
+
+/**
+ * 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: EventDraft, checkRepeat: boolean): string {
+	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.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.endTime <= draft.startTime)
+		return "The end time is not after the start time. 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: EventDraft,
+	timeZone: string,
+): CreateInput {
+	const problem = refuse(draft, true);
+	if (problem !== "") return { ok: false, problem };
+	const { start, end } = timesFor(draft, timeZone);
+	return {
+		ok: true,
+		input: {
+			calendarId: draft.calendarId,
+			summary: draft.title.trim(),
+			description: draft.notes,
+			location: draft.location,
+			start,
+			end,
+			allDay: draft.allDay,
+			// Absent anchors the event in UTC, which is exactly what a collection
+			// naming no zone means. There is no spelling of UTC the server takes
+			// as a TZID, so sending one instead is not an option.
+			...(timeZone === "" ? {} : { timeZone }),
+			recurrenceRule: rruleFromText(draft.repeat) ?? "",
+		},
+	};
+}
+
+export function patchFromDrafts(
+	before: EventDraft,
+	after: EventDraft,
+	timeZone: string,
+): UpdatePatch {
+	const repeatChanged = after.repeat !== before.repeat;
+	const problem = refuse(after, repeatChanged);
+	if (problem !== "") return { ok: false, problem };
+
+	const patch: RemitImapUpdateCalendarEventInput = {};
+	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 moved =
+		after.date !== before.date ||
+		after.startTime !== before.startTime ||
+		after.endTime !== before.endTime ||
+		after.allDay !== before.allDay;
+	if (moved) {
+		const { start, end } = timesFor(after, timeZone);
+		patch.start = start;
+		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. A collection with none of its
+		// own says so by sending nothing.
+		if (timeZone !== "") patch.timeZone = timeZone;
+	}
+
+	if (repeatChanged) patch.recurrenceRule = rruleFromText(after.repeat) ?? "";
+
+	return { ok: true, patch };
+}

package/src/hooks/calendar/index.ts

@@ -0,0 +1,59 @@
+/**
+ * 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 CreateInput,
+	createInputFromDraft,
+	type DraftRefusal,
+	draftFromEvent,
+	emptyDraft,
+	patchFromDrafts,
+	type UpdatePatch,
+} from "./draft";
+export {
+	type CalendarInstanceRef,
+	calendarInstanceId,
+	deviceTimeZone,
+	isDrawnInstance,
+	readCalendarInstanceId,
+	toCalendarDescriptor,
+	toCalendarEventData,
+	UNZONED_CALENDAR,
+} from "./instance";
+export { rruleFromText, textFromRrule } from "./recurrence-rule";
+export {
+	type CalendarResourceText,
+	rruleFromIcalData,
+	textFromIcalData,
+} from "./resource";
+export {
+	type CalendarEventResource,
+	useCalendarEvent,
+} from "./useCalendarEvent";
+export {
+	type CalendarEventWindowRequest,
+	type CalendarEventWindowResult,
+	useCalendarEventWindow,
+	usePrefetchAdjacentWindows,
+} from "./useCalendarEvents";
+export { type CalendarsResult, useCalendars } from "./useCalendars";
+export {
+	type CalendarWriteOutcome,
+	type CalendarWrites,
+	type ScopedWrite,
+	useCalendarWrites,
+	useInvalidateCalendarReads,
+} from "./useCalendarWrites";
+export {
+	addDays,
+	type CalendarWindow,
+	calendarWindow,
+	calendarWindowOfDays,
+	isoAt,
+	isoAtInZone,
+	startOfDay,
+} from "./window";

package/src/hooks/calendar/instance.ts

@@ -0,0 +1,136 @@
+/**
+ * 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 {
+	CalendarColorId,
+	CalendarDescriptor,
+	CalendarEventData,
+	ZoneCertainty,
+} from "@remit/ui";
+
+/** The device's own clock, the only zone a browser can honestly draw in. */
+export const deviceTimeZone = (): string =>
+	Intl.DateTimeFormat().resolvedOptions().timeZone;
+
+/**
+ * A collection that names no zone of its own, spelled the way the API spells
+ * it: an empty string, which both ends read as UTC.
+ *
+ * There is deliberately no substitute value. The server checks a TZID against
+ * `Intl.supportedValuesOf("timeZone")`, which is the canonical zone list and so
+ * holds no spelling of UTC at all — not `UTC`, not `Etc/UTC` — and refuses
+ * anything else. Sending nothing is what the API asks for, and it is the only
+ * thing it accepts.
+ *
+ * The device's zone is not the fallback either. The listing returns this
+ * collection's occurrences on its own clock, so answering with the reader's
+ * would rewrite every time they saved by the difference between the two.
+ */
+export const UNZONED_CALENDAR = "";
+
+const COLORS: Record<string, CalendarColorId> = {
+	Cal1: "cal-1",
+	Cal2: "cal-2",
+	Cal3: "cal-3",
+	Cal4: "cal-4",
+	Cal5: "cal-5",
+	Cal6: "cal-6",
+};
+
+const ZONES: Record<string, ZoneCertainty> = {
+	Local: "local",
+	Explicit: "explicit",
+	Ambiguous: "ambiguous",
+};
+
+/**
+ * The address of one occurrence, as a single string, because the grid selects
+ * an event by one id. A series draws many occurrences from one resource, so the
+ * resource id alone would key every Monday standup the same and select all of
+ * them at once.
+ */
+const OCCURRENCE_SEPARATOR = "#";
+
+export function calendarInstanceId(
+	calendarObjectId: string,
+	recurrenceId: string,
+): string {
+	return recurrenceId === ""
+		? calendarObjectId
+		: `${calendarObjectId}${OCCURRENCE_SEPARATOR}${recurrenceId}`;
+}
+
+export interface CalendarInstanceRef {
+	calendarObjectId: string;
+	/** `""` on a resource that does not recur. */
+	recurrenceId: string;
+}
+
+export function readCalendarInstanceId(id: string): CalendarInstanceRef {
+	const cut = id.indexOf(OCCURRENCE_SEPARATOR);
+	if (cut === -1) return { calendarObjectId: id, recurrenceId: "" };
+	return {
+		calendarObjectId: id.slice(0, cut),
+		recurrenceId: id.slice(cut + 1),
+	};
+}
+
+export function toCalendarDescriptor(
+	calendar: RemitImapCalendarResponse,
+): CalendarDescriptor {
+	return {
+		id: calendar.calendarId,
+		accountId: calendar.accountConfigId,
+		accountLabel: "",
+		name: calendar.displayName,
+		color: COLORS[calendar.color] ?? "cal-1",
+	};
+}
+
+/**
+ * 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.
+ */
+export function toCalendarEventData(
+	instance: RemitImapCalendarEventInstance,
+	timeZone: string,
+): CalendarEventData {
+	return {
+		id: calendarInstanceId(instance.calendarObjectId, instance.recurrenceId),
+		calendarId: instance.calendarId,
+		title: instance.summary,
+		start: instance.start,
+		end: instance.end,
+		allDay: instance.allDay,
+		location: "",
+		notes: "",
+		attendees: [],
+		myRsvp: "accepted",
+		threadId: "",
+		threadSubject: "",
+		timeZone,
+		zoneCertainty: ZONES[instance.zoneCertainty] ?? "explicit",
+		recurrenceRule: instance.hasRecurrence ? "Repeats" : "",
+		seriesId: instance.hasRecurrence ? instance.icalUid : "",
+		seriesException: false,
+		status: instance.status === "Tentative" ? "tentative" : "confirmed",
+	};
+}
+
+/**
+ * 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 const isDrawnInstance = (
+	instance: RemitImapCalendarEventInstance,
+): boolean => instance.status !== "Cancelled";

package/src/hooks/calendar/recurrence-rule.test.ts

@@ -0,0 +1,92 @@
+/**
+ * Repeat rules, both ways.
+ *
+ * The picker only ever offers the sentences `repeatChoices` derives, so the
+ * table has to cover exactly those and refuse everything else — a sentence
+ * turned into a rule it does not mean is an event that repeats on days nobody
+ * chose, and nothing on screen would say so.
+ *
+ * A rule written by something else — a native client, an invitation — must come
+ * back unread rather than snapped to the nearest sentence.
+ */
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { repeatChoices } from "@remit/ui";
+import { rruleFromText, textFromRrule } from "./recurrence-rule";
+
+const DATE = "2026-06-10";
+const TIME = "09:15";
+
+describe("every rule the picker offers", () => {
+	it("becomes an RRULE, and reads back as the sentence it was picked from", () => {
+		for (const choice of repeatChoices(DATE, TIME)) {
+			const rule = rruleFromText(choice);
+			assert.ok(
+				rule !== undefined && rule !== "",
+				`no rule for the offered choice "${choice}"`,
+			);
+			assert.equal(textFromRrule(rule, TIME), choice);
+		}
+	});
+
+	it("says what each one means", () => {
+		assert.equal(rruleFromText("Every day, 09:15"), "FREQ=DAILY");
+		assert.equal(
+			rruleFromText("Every weekday, 09:15"),
+			"FREQ=WEEKLY;BYDAY=MO,TU,WE,TH,FR",
+		);
+		assert.equal(
+			rruleFromText("Every week on Wednesday, 09:15"),
+			"FREQ=WEEKLY;BYDAY=WE",
+		);
+		assert.equal(
+			rruleFromText("Every month on the second Wednesday, 09:15"),
+			"FREQ=MONTHLY;BYDAY=2WE",
+		);
+		assert.equal(
+			rruleFromText("Every year on 10 June, 09:15"),
+			"FREQ=YEARLY;BYMONTH=6;BYMONTHDAY=10",
+		);
+	});
+
+	it("reads the last week of a month as the rule that means it", () => {
+		assert.equal(
+			rruleFromText("Every month on the last Friday"),
+			"FREQ=MONTHLY;BYDAY=-1FR",
+		);
+		assert.equal(
+			textFromRrule("FREQ=MONTHLY;BYDAY=-1FR", ""),
+			"Every month on the last Friday",
+		);
+	});
+});
+
+describe("no repeat", () => {
+	it("is the empty rule rather than a refusal", () => {
+		assert.equal(rruleFromText(""), "");
+	});
+});
+
+describe("a sentence this table does not cover", () => {
+	it("is refused rather than guessed at", () => {
+		assert.equal(rruleFromText("Every other Tuesday"), undefined);
+		assert.equal(rruleFromText("Every week on Caturday"), undefined);
+		assert.equal(rruleFromText("Repeats"), undefined);
+	});
+});
+
+describe("a rule written by something else", () => {
+	it("comes back unread rather than snapped to the nearest sentence", () => {
+		assert.equal(
+			textFromRrule("FREQ=WEEKLY;INTERVAL=2;BYDAY=TU", ""),
+			undefined,
+		);
+		assert.equal(textFromRrule("FREQ=DAILY;COUNT=10", ""), undefined);
+		assert.equal(
+			textFromRrule("FREQ=DAILY;UNTIL=20261231T000000Z", ""),
+			undefined,
+		);
+		assert.equal(textFromRrule("FREQ=HOURLY", ""), undefined);
+		assert.equal(textFromRrule("FREQ=WEEKLY", ""), undefined);
+	});
+});