@remit/web-client 0.0.231 → 0.0.233

package/src/hooks/calendar/calendar-writes.render.test.ts

@@ -0,0 +1,305 @@
+/**
+ * Writing an event, and what the calendar does with the answer.
+ *
+ * Three outcomes have to be distinguishable at the call site, which is why they
+ * are returned rather than thrown: the write landed, somebody else had already
+ * written it, or the server refused it. The one that must never be silent is
+ * the middle one — a 412 says the version on screen is stale, and applying the
+ * edit anyway would discard a change nobody would ever see go.
+ *
+ * A lapsed session is not one of the three. It escalates to the page that signs
+ * the reader back in, so the caches here are the real ones from
+ * `lib/query-error-handler.ts` rather than the harness's quiet default.
+ */
+
+import assert from "node:assert/strict";
+import { afterEach, describe, it } from "node:test";
+import type { RemitImapCalendarResponse } from "@remit/api-http-client/types.gen.ts";
+import { MutationCache, QueryCache, QueryClient } from "@tanstack/react-query";
+import { act, createElement, Fragment } from "react";
+import { FatalErrorOverlay } from "@/components/ui/FatalErrorOverlay";
+import { useCalendarData } from "@/hooks/useCalendarData";
+import { __resetFatalError } from "@/lib/fatal-error";
+import {
+	handleMutationCacheError,
+	handleQueryCacheError,
+} from "@/lib/query-error-handler";
+import { createDomHarness, type DomHarness } from "../../test-support/dom";
+import {
+	type HttpCall,
+	type HttpMock,
+	httpError,
+	mockFetch,
+} from "../../test-support/http";
+import {
+	type CalendarWriteOutcome,
+	type CalendarWrites,
+	useCalendarWrites,
+} from "./useCalendarWrites";
+
+const WORK = "11111111-1111-4111-8111-111111111111";
+const OBJECT = "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa";
+
+let harness: DomHarness | undefined;
+let http: HttpMock | undefined;
+let writes: CalendarWrites | undefined;
+
+afterEach(() => {
+	harness?.close();
+	harness = undefined;
+	http?.restore();
+	http = undefined;
+	writes = undefined;
+	__resetFatalError();
+});
+
+const calendars: RemitImapCalendarResponse[] = [
+	{
+		calendarId: WORK,
+		accountConfigId: "cfg-1",
+		urlSegment: "work",
+		displayName: "Work",
+		color: "Cal1",
+		componentSet: "VeventOnly",
+		source: "UserCreated",
+		timezone: "Europe/Amsterdam",
+		syncSequence: 1,
+		createdAt: 0,
+		updatedAt: 0,
+	} as RemitImapCalendarResponse,
+];
+
+const escalatingClient = (): QueryClient =>
+	new QueryClient({
+		queryCache: new QueryCache({ onError: handleQueryCacheError }),
+		mutationCache: new MutationCache({ onError: handleMutationCacheError }),
+		defaultOptions: { queries: { retry: false }, mutations: { retry: false } },
+	});
+
+/** Reads the visible week and holds the writes, the way the routes do. */
+function Probe() {
+	useCalendarData({ view: "week", date: "2026-06-10", calendarIds: [] });
+	writes = useCalendarWrites();
+	return null;
+}
+
+const mount = async (
+	respond: (call: HttpCall) => unknown,
+	options: { escalating?: boolean; calendarsRespond?: boolean } = {},
+) => {
+	const serveCalendars = options.calendarsRespond ?? true;
+	http = mockFetch((call) =>
+		serveCalendars && call.path.endsWith("/calendars") && call.method === "GET"
+			? { items: calendars }
+			: respond(call),
+	);
+	harness = createDomHarness(
+		options.escalating ? { queryClient: escalatingClient() } : {},
+	);
+	harness.renderApp(
+		createElement(
+			Fragment,
+			null,
+			createElement(FatalErrorOverlay),
+			createElement(Probe),
+		),
+	);
+	await settle();
+};
+
+const settle = async () => {
+	await harness?.flush();
+	await harness?.wait(20);
+	await harness?.flush();
+};
+
+/** The writes the probe is holding, driven inside `act` the way a click is. */
+const write = async (
+	run: (writes: CalendarWrites) => Promise<CalendarWriteOutcome>,
+): Promise<CalendarWriteOutcome> => {
+	const held = writes;
+	if (!held) throw new Error("the writes are not mounted");
+	let outcome: CalendarWriteOutcome | undefined;
+	await act(async () => {
+		outcome = await run(held);
+	});
+	await settle();
+	if (!outcome) throw new Error("the write returned nothing");
+	return outcome;
+};
+
+const listings = (): number =>
+	(http?.to("/calendar-events") ?? []).filter(
+		(call) =>
+			call.method === "GET" &&
+			call.url.includes(`from=${encodeURIComponent("2026-06-08")}`),
+	).length;
+
+const scopedWrite = {
+	calendarObjectId: OBJECT,
+	calendarId: WORK,
+	recurrenceId: "2026-06-11T07:15:00Z",
+	scope: "this" as const,
+	etag: "etag-1",
+};
+
+describe("creating an event", () => {
+	it("posts it and reads the week back, so the grid shows it", async () => {
+		await mount(() => ({ items: [] }));
+		const before = listings();
+
+		const outcome = await write((writes) =>
+			writes.createEvent({
+				calendarId: WORK,
+				summary: "Roadmap review",
+				start: "2026-06-10T10:00:00+02:00",
+				end: "2026-06-10T11:30:00+02:00",
+			}),
+		);
+
+		assert.deepEqual(outcome, { kind: "written" });
+		const posted = (http?.to("/calendar-events") ?? []).filter(
+			(call) => call.method === "POST",
+		);
+		assert.equal(posted.length, 1);
+		assert.equal(posted[0].body?.summary, "Roadmap review");
+		assert.ok(
+			listings() > before,
+			"the window a write changed has to be read again",
+		);
+	});
+});
+
+describe("editing one occurrence of a series", () => {
+	it("names the occurrence, the scope, and the version it was built on", async () => {
+		await mount(() => ({ items: [] }));
+		await write((writes) =>
+			writes.updateEvent(scopedWrite, { summary: "Standup" }),
+		);
+
+		const patched = (http?.calls ?? []).find((call) => call.method === "PATCH");
+		assert.ok(patched, "the edit was sent");
+		assert.equal(
+			patched.headers["if-match"],
+			"etag-1",
+			"an unconditional write is one that can discard somebody else's edit",
+		);
+		assert.ok(patched.url.includes("scope=This"), patched.url);
+		assert.ok(
+			patched.url.includes(encodeURIComponent("2026-06-11T07:15:00Z")),
+			patched.url,
+		);
+	});
+
+	it("makes the delete conditional on the same version", async () => {
+		await mount(() => ({ items: [] }));
+		await write((writes) => writes.deleteEvent(scopedWrite));
+		const deleted = (http?.calls ?? []).find(
+			(call) => call.method === "DELETE",
+		);
+		assert.equal(
+			deleted?.headers["if-match"],
+			"etag-1",
+			"an unconditional delete removes whatever is there now, not what was read",
+		);
+	});
+});
+
+describe("a version somebody else has already replaced", () => {
+	it("comes back as a conflict rather than as a write that won", async () => {
+		await mount((call) =>
+			call.method === "PATCH" ? httpError(412, "etag mismatch") : { items: [] },
+		);
+		const outcome = await write((writes) =>
+			writes.updateEvent(scopedWrite, { summary: "Standup" }),
+		);
+		assert.deepEqual(outcome, { kind: "conflict" });
+	});
+
+	it("refuses the delete the same way", async () => {
+		await mount((call) =>
+			call.method === "DELETE"
+				? httpError(412, "etag mismatch")
+				: { items: [] },
+		);
+		const outcome = await write((writes) => writes.deleteEvent(scopedWrite));
+		assert.deepEqual(outcome, { kind: "conflict" });
+	});
+});
+
+describe("a refusal the server states", () => {
+	it("comes back with what it said, for the form to show", async () => {
+		await mount((call) =>
+			call.method === "POST"
+				? httpError(400, "start must be before end")
+				: { items: [] },
+		);
+		const outcome = await write((writes) =>
+			writes.createEvent({
+				calendarId: WORK,
+				summary: "Backwards",
+				start: "2026-06-10T11:00:00+02:00",
+				end: "2026-06-10T10:00:00+02:00",
+			}),
+		);
+		assert.deepEqual(outcome, {
+			kind: "refused",
+			message: "start must be before end",
+		});
+	});
+});
+
+describe("a session that has lapsed", () => {
+	/**
+	 * The read is the dangerous one. A calendar that answers a 401 with no
+	 * events draws a clear week, and a clear week is what a reader plans around
+	 * — they never learn their session ended, and neither does the app.
+	 */
+	it("never lets the event listing come back as an empty week", async () => {
+		await mount(
+			(call) =>
+				call.method === "GET"
+					? httpError(401, "session expired")
+					: { items: [] },
+			{ escalating: true, calendarsRespond: false },
+		);
+		assert.ok(
+			harness?.query('[data-testid="fatal-error-overlay"]'),
+			"a refused read must not be drawn as a week with nothing in it",
+		);
+	});
+
+	it("escalates a refused calendar list rather than showing no calendars", async () => {
+		await mount(
+			(call) =>
+				call.path.endsWith("/calendars")
+					? httpError(401, "session expired")
+					: { items: [] },
+			{ escalating: true, calendarsRespond: false },
+		);
+		assert.ok(harness?.query('[data-testid="fatal-error-overlay"]'));
+	});
+
+	it("takes the reader to the page that signs them back in", async () => {
+		await mount(
+			(call) =>
+				call.method === "POST"
+					? httpError(401, "session expired")
+					: { items: [] },
+			{ escalating: true },
+		);
+		await write((writes) =>
+			writes.createEvent({
+				calendarId: WORK,
+				summary: "Roadmap review",
+				start: "2026-06-10T10:00:00+02:00",
+				end: "2026-06-10T11:30:00+02:00",
+			}),
+		);
+
+		assert.ok(
+			harness?.query('[data-testid="fatal-error-overlay"]'),
+			"no banner on a calendar signs anybody back in",
+		);
+	});
+});

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 };
+}