@remit/web-client 0.0.312 → 0.0.314

package/src/hooks/calendar/useCalendarSuggestions.ts

@@ -18,7 +18,11 @@ import {
 	calendarSuggestionOperationsListCalendarSuggestionsOptions,
 	messageCalendarSuggestionOperationsListMessageCalendarSuggestionsOptions,
 } from "@remit/api-http-client/@tanstack/react-query.gen.ts";
-import type { RemitImapCalendarSuggestionResponse } from "@remit/api-http-client/types.gen.ts";
+import { calendarSuggestionOperationsListCalendarSuggestions } from "@remit/api-http-client/sdk.gen.ts";
+import type {
+	RemitImapAcceptCalendarSuggestionInput,
+	RemitImapCalendarSuggestionResponse,
+} from "@remit/api-http-client/types.gen.ts";
 import {
 	type QueryClient,
 	useMutation,
@@ -89,6 +93,46 @@ export function usePendingCalendarSuggestions(): CalendarSuggestionsResult {
 	};
 }
 
+const findPending = async (
+	suggestionId: string,
+	signal: AbortSignal,
+): Promise<RemitImapCalendarSuggestionResponse | null> => {
+	let continuationToken: string | undefined;
+	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 interface PendingCalendarSuggestionResult {
+	suggestion: RemitImapCalendarSuggestionResponse | null | undefined;
+	isLoading: boolean;
+	error: unknown;
+}
+
+export function usePendingCalendarSuggestion(
+	suggestionId: string,
+): PendingCalendarSuggestionResult {
+	const { data, isLoading, error } = useQuery({
+		queryKey: [
+			{
+				_id: "calendarSuggestionOperationsListCalendarSuggestions",
+				suggestionId,
+			},
+		],
+		queryFn: ({ signal }) => findPending(suggestionId, signal),
+		meta: SUGGESTION_META,
+	});
+	return { suggestion: data, isLoading, error: error ?? null };
+}
+
 export type SuggestionAnswer =
 	| { kind: "answered" }
 	| { kind: "refused"; message: string };
@@ -109,6 +153,10 @@ export interface CalendarSuggestionAnswers {
 		suggestionId: string,
 		calendarId: string,
 	) => Promise<SuggestionAnswer>;
+	acceptEdited: (
+		suggestionId: string,
+		input: RemitImapAcceptCalendarSuggestionInput,
+	) => Promise<SuggestionAnswer>;
 	decline: (suggestionId: string) => Promise<SuggestionAnswer>;
 	dismiss: (
 		suggestionId: string,
@@ -159,6 +207,14 @@ export function useCalendarSuggestionAnswers(): CalendarSuggestionAnswers {
 				.catch(refused),
 		[accept],
 	);
+	const acceptEditedSuggestion = useCallback(
+		(suggestionId: string, input: RemitImapAcceptCalendarSuggestionInput) =>
+			accept
+				.mutateAsync({ path: { suggestionId }, body: input })
+				.then(() => ANSWERED)
+				.catch(refused),
+		[accept],
+	);
 	const declineSuggestion = useCallback(
 		(suggestionId: string) =>
 			decline
@@ -180,6 +236,7 @@ export function useCalendarSuggestionAnswers(): CalendarSuggestionAnswers {
 		() => ({
 			accept: acceptSuggestion,
 			tentative: tentativeSuggestion,
+			acceptEdited: acceptEditedSuggestion,
 			decline: declineSuggestion,
 			dismiss: dismissSuggestion,
 			isAnswering: accept.isPending || decline.isPending || dismiss.isPending,
@@ -187,6 +244,7 @@ export function useCalendarSuggestionAnswers(): CalendarSuggestionAnswers {
 		[
 			acceptSuggestion,
 			tentativeSuggestion,
+			acceptEditedSuggestion,
 			declineSuggestion,
 			dismissSuggestion,
 			accept.isPending,

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

@@ -14,6 +14,14 @@ import type {
 	RemitImapCalendarSuggestionResponse,
 } from "@remit/api-http-client/types.gen.ts";
 import { type IntelligenceData, IntelligencePanel } from "@remit/ui";
+import {
+	type AnyRouter,
+	createMemoryHistory,
+	createRootRoute,
+	createRoute,
+	createRouter,
+	RouterProvider,
+} from "@tanstack/react-router";
 import { createElement } from "react";
 import { createDomHarness, type DomHarness } from "@/test-support/dom";
 import { makeThreadMessage } from "@/test-support/fixtures";
@@ -261,3 +269,130 @@ describe("the invitation beside the open message", () => {
 		assert.deepEqual(dismissed[0].body, { muteSender: true });
 	});
 });
+
+(globalThis as { self?: typeof globalThis }).self ??= globalThis;
+
+const READING = "33333333-3333-4333-8333-333333333333";
+
+const routedMount = async (
+	items: RemitImapCalendarSuggestionResponse[],
+): Promise<AnyRouter> => {
+	http = mockFetch((call: HttpCall): unknown => {
+		if (call.path.endsWith("/calendars")) return { items: calendars };
+		if (call.path.endsWith("/messages/msg-1/calendar-suggestions"))
+			return { items };
+		return { items: [] };
+	});
+	const rootRoute = createRootRoute({ component: Harness });
+	const routeTree = rootRoute.addChildren([
+		createRoute({
+			getParentRoute: () => rootRoute,
+			path: "/mail",
+			component: () => null,
+		}),
+		createRoute({
+			getParentRoute: () => rootRoute,
+			path: "/calendar/$view/$date/suggestion/$suggestionId",
+			component: () => null,
+		}),
+	]);
+	const router = createRouter({
+		routeTree,
+		history: createMemoryHistory({ initialEntries: ["/mail"] }),
+	}) as unknown as AnyRouter;
+	await router.load();
+	harness = createDomHarness();
+	harness.renderApp(createElement(RouterProvider, { router }));
+	await harness.waitFor(
+		() => harness?.text().includes("Quarterly review") === true,
+		"the invitation to be drawn",
+	);
+	return router;
+};
+
+const answered = (): HttpCall[] =>
+	(http?.calls ?? []).filter((call) => call.method === "POST");
+
+describe("changing a suggestion beside the message before adding it", () => {
+	it("opens the editor for a reading from the thread on the day it falls", async () => {
+		const router = await routedMount([
+			invitation("Pending"),
+			{
+				...invitation("Pending"),
+				suggestionId: READING,
+				source: "TextHeuristic",
+				summary: "Lunch with Sam",
+			},
+		]);
+		await harness?.waitFor(
+			() => harness?.text().includes("Lunch with Sam") === true,
+			"the reading to be drawn",
+		);
+
+		press("Change first");
+		await harness?.waitFor(
+			() => router.state.location.pathname.includes(READING),
+			"the editor to be opened",
+		);
+
+		assert.equal(
+			router.state.location.pathname,
+			`/calendar/day/2026-09-01/suggestion/${READING}`,
+		);
+		assert.deepEqual(answered(), []);
+	});
+
+	it("sends an invitation nobody could put on a clock to the editor instead of adding it", async () => {
+		const router = await routedMount([
+			{ ...invitation("Pending"), zoneCertainty: "Ambiguous" },
+		]);
+
+		press("Add to calendar");
+		await harness?.waitFor(
+			() => router.state.location.pathname.includes(SUGGESTION),
+			"the editor to be opened",
+		);
+
+		assert.equal(
+			router.state.location.pathname,
+			`/calendar/day/2026-09-01/suggestion/${SUGGESTION}`,
+		);
+		assert.deepEqual(answered(), []);
+	});
+
+	it("applies a cancellation read out of the thread, and offers no editor for it", async () => {
+		const router = await routedMount([
+			invitation("Accepted"),
+			{
+				...invitation("Pending"),
+				suggestionId: READING,
+				source: "TextHeuristic",
+				method: "Cancel",
+				zoneCertainty: "Ambiguous",
+				summary: "Lunch with Sam",
+			},
+		]);
+		await harness?.waitFor(
+			() => harness?.text().includes("Lunch with Sam") === true,
+			"the reading to be drawn",
+		);
+		const card = harness?.query('article[aria-label="Lunch with Sam"]');
+		if (!card) throw new Error("the reading's card is not drawn");
+		const buttons = [...card.querySelectorAll("button")];
+		assert.equal(
+			buttons.some((button) => button.textContent?.includes("Change first")),
+			false,
+		);
+		const add = buttons.find((button) =>
+			button.textContent?.includes("Add to calendar"),
+		);
+		if (!add) throw new Error("the reading offers no Add");
+		harness?.click(add);
+
+		await harness?.waitFor(
+			() => answered().some((call) => call.path.endsWith(`/${READING}/accept`)),
+			"the cancellation to be applied",
+		);
+		assert.equal(router.state.location.pathname, "/mail");
+	});
+});

package/src/hooks/useComposeAttachments.ts

@@ -61,7 +61,7 @@ export const useComposeAttachments = ({
 		complete: (outboxMessageId, outboxAttachmentId) =>
 			completeMutation
 				.mutateAsync({ path: { outboxMessageId, outboxAttachmentId } })
-				.then(() => undefined),
+				.then((attachment) => ({ contentUrl: attachment.contentUrl })),
 		keep: (outboxMessageId, attachmentIds) =>
 			updateMutation
 				.mutateAsync({
@@ -98,6 +98,11 @@ export const useComposeAttachments = ({
 		remove: controller.remove,
 		load: controller.load,
 		reset: controller.reset,
+		owns: controller.owns,
+		isLoaded: controller.isLoaded,
+		refreshLinks: controller.refreshLinks,
+		storedContent: controller.storedContent,
+		onRemoved: controller.onRemoved,
 		blockingReason: controller.blockingReason(),
 	};
 };

package/src/hooks/useInlineImages.ts

@@ -0,0 +1,93 @@
+import type { RemitImapOutboxAttachmentResponse } from "@remit/api-http-client/types.gen.ts";
+import type { InlineImagePlacement, InlineImages } from "@remit/ui/rich-text";
+import { useMemo, useRef } from "react";
+import { useAuthProvider } from "@/auth/provider";
+import {
+	attachmentFailureContent,
+	extractAttachmentFailureDetail,
+	extractAttachmentFailureReason,
+	fetchAttachment,
+} from "@/lib/attachment-download";
+import type { PushErrorInput } from "../components/ui/error-banners";
+import type { StoredContent } from "../lib/compose-attachment-controller";
+
+interface UseInlineImagesOptions {
+	attach: (files: File[], placement?: InlineImagePlacement) => Promise<void>;
+	owns: (contentId: string) => boolean;
+	isLoaded: () => boolean;
+	storedContent: (contentId: string) => StoredContent | null;
+	refreshLinks: () => Promise<void>;
+	onRemoved: (listener: (contentId: string) => void) => () => void;
+	draftAttachments: readonly RemitImapOutboxAttachmentResponse[];
+	pushError: (input: PushErrorInput) => string;
+}
+
+export const useInlineImages = (
+	options: UseInlineImagesOptions,
+): InlineImages => {
+	const { getToken } = useAuthProvider();
+	const latest = useRef({ ...options, getToken });
+	latest.current = { ...options, getToken };
+
+	return useMemo<InlineImages>(() => {
+		const beforeLoad = (contentId: string): StoredContent | null => {
+			const current = latest.current;
+			if (current.isLoaded()) return null;
+			return (
+				current.draftAttachments.find(
+					(attachment) => attachment.contentId === contentId,
+				) ?? null
+			);
+		};
+
+		const stored = (contentId: string): StoredContent | null =>
+			latest.current.storedContent(contentId) ?? beforeLoad(contentId);
+
+		const fetchStored = (content: StoredContent): Promise<string> =>
+			fetchAttachment(content.contentUrl, latest.current.getToken).then(
+				(blob) =>
+					URL.createObjectURL(new Blob([blob], { type: content.contentType })),
+			);
+
+		const fetchRenewed = (contentId: string): Promise<string> =>
+			latest.current.refreshLinks().then(() => {
+				const renewed = stored(contentId);
+				if (!renewed) {
+					throw new Error("the file is no longer on this draft");
+				}
+				return fetchStored(renewed);
+			});
+
+		return {
+			attach: (files, placement) => {
+				void latest.current.attach(files, placement);
+			},
+			owns: (contentId) =>
+				latest.current.owns(contentId) || beforeLoad(contentId) !== null,
+			onRemoved: (listener) => latest.current.onRemoved(listener),
+			resolve: (contentId) => {
+				const content = stored(contentId);
+				if (!content) return Promise.resolve(null);
+				return fetchStored(content)
+					.catch((error: unknown) => {
+						if (extractAttachmentFailureReason(error) !== "link-expired") {
+							throw error;
+						}
+						return fetchRenewed(contentId);
+					})
+					.catch((error: unknown) => {
+						const reason = extractAttachmentFailureReason(error);
+						latest.current.pushError({
+							...attachmentFailureContent(
+								reason,
+								content.filename,
+								extractAttachmentFailureDetail(error),
+							),
+							error: reason === "generic" ? error : undefined,
+						});
+						return null;
+					});
+			},
+		};
+	}, []);
+};

package/src/hooks/useIntelligenceCalendar.ts

@@ -50,7 +50,10 @@ import {
 	toCalendarInvite,
 	toEventSuggestion,
 } from "@/lib/calendar-suggestion";
-import { useOpenEventOnCalendar } from "@/routing";
+import {
+	useChangeSuggestionOnCalendar,
+	useOpenEventOnCalendar,
+} from "@/routing";
 
 /** What the reader is in the middle of, for one message and no other. */
 interface Working {
@@ -107,6 +110,7 @@ export function useIntelligenceCalendar(
 	const answers = useCalendarSuggestionAnswers();
 
 	const openEvent = useOpenEventOnCalendar();
+	const changeOnCalendar = useChangeSuggestionOnCalendar();
 
 	const [held, setHeld] = useState<Working>(() => fresh(messageId));
 	const working = held.messageId === messageId ? held : fresh(messageId);
@@ -238,14 +242,34 @@ export function useIntelligenceCalendar(
 			: "Couldn't read the invitations in this message. Reopen it to try again.";
 
 	const cancellation = invitation?.method === "Cancel";
+	const changeFirst = (suggestionId: string) => {
+		const suggestion = suggestions.find(
+			(candidate) => candidate.suggestionId === suggestionId,
+		);
+		if (suggestion) changeOnCalendar(suggestionDate(suggestion), suggestionId);
+	};
+	const unplaced = (suggestionId: string): boolean => {
+		const suggestion = suggestions.find(
+			(candidate) => candidate.suggestionId === suggestionId,
+		);
+		return (
+			suggestion?.zoneCertainty === "Ambiguous" &&
+			suggestion.method !== "Cancel"
+		);
+	};
 	const pickedText =
 		date === "" ? "" : slotsAsText(date, slots, working.picked);
 
 	const actions: IntelligenceCalendarActions = {
-		onAddInvite: () =>
+		onAddInvite: () => {
+			if (unplaced(invitationId)) {
+				changeFirst(invitationId);
+				return;
+			}
 			answer(invitationId, "add this to your calendar", () =>
 				answers.accept(invitationId, defaultCalendarId),
-			),
+			);
+		},
 		onTentativeInvite: cancellation
 			? undefined
 			: () =>
@@ -281,10 +305,17 @@ export function useIntelligenceCalendar(
 			? () =>
 					replyWithText({ threadId: thread.threadId, messageId }, pickedText)
 			: undefined,
-		onAddSuggestion: (suggestionId) =>
+		onAddSuggestion: (suggestionId) => {
+			if (unplaced(suggestionId)) {
+				changeFirst(suggestionId);
+				return;
+			}
 			answer(suggestionId, "add this to your calendar", () =>
 				answers.accept(suggestionId, defaultCalendarId),
-			),
+			);
+		},
+		onReviewSuggestion:
+			readings[0]?.method === "Cancel" ? undefined : changeFirst,
 		onDismissSuggestion: (suggestionId) =>
 			answer(suggestionId, "dismiss this", () =>
 				answers.dismiss(suggestionId, false),

package/src/lib/calendar-suggestion.test.ts

@@ -113,10 +113,19 @@ describe("toEventSuggestion", () => {
 			suggestion({ zoneCertainty: "Ambiguous", source: "TextHeuristic" }),
 			{ ...context, sender: "Organizer" },
 		);
-		assert.match(reading.ambiguity, /hours out/);
+		assert.match(reading.ambiguity, /Add opens the editor/);
 		assert.equal(reading.zoneCertainty, "ambiguous");
 		assert.ok(reading.confidence < 1);
 	});
+
+	it("promises no editor for a cancellation, which Add applies as it is", () => {
+		const reading = toEventSuggestion(
+			suggestion({ zoneCertainty: "Ambiguous", method: "Cancel" }),
+			{ ...context, sender: "Organizer" },
+		);
+		assert.match(reading.ambiguity, /could not be resolved/);
+		assert.doesNotMatch(reading.ambiguity, /editor/);
+	});
 });
 
 describe("clashesOver", () => {

package/src/lib/calendar-suggestion.ts

@@ -47,7 +47,10 @@ const ZONES: Record<CalendarSuggestion["zoneCertainty"], ZoneCertainty> = {
 };
 
 const AMBIGUOUS_ZONE =
-	"The invitation named a time zone nothing could resolve, so this time may be hours out.";
+	"The invitation's time zone could not be resolved. Add opens the editor so you can set the time.";
+
+const AMBIGUOUS_CANCELLATION =
+	"The invitation's time zone could not be resolved.";
 
 /** Where the card stands, or nothing when there is no card left to draw. */
 export interface InviteStanding {
@@ -163,6 +166,13 @@ export function toCalendarInvite(
 	};
 }
 
+function ambiguityOf(suggestion: CalendarSuggestion): string {
+	if (suggestion.zoneCertainty !== "Ambiguous") return "";
+	return suggestion.method === "Cancel"
+		? AMBIGUOUS_CANCELLATION
+		: AMBIGUOUS_ZONE;
+}
+
 export function toEventSuggestion(
 	suggestion: CalendarSuggestion,
 	context: Omit<InviteContext, "senderName"> & { sender: string },
@@ -179,7 +189,7 @@ export function toEventSuggestion(
 		sender: context.sender,
 		senderAddress: suggestion.organizer,
 		confidence: isFromInvitation(suggestion) ? 1 : 0.6,
-		ambiguity: suggestion.zoneCertainty === "Ambiguous" ? AMBIGUOUS_ZONE : "",
+		ambiguity: ambiguityOf(suggestion),
 		suggestedCalendarId: context.calendarId,
 		timeZone: "",
 		zoneCertainty: ZONES[suggestion.zoneCertainty],

package/src/lib/compose-attachment-controller.test.ts

@@ -55,6 +55,7 @@ const createServer = () => {
 		},
 		complete: async (_draft, outboxAttachmentId) => {
 			completed.push(outboxAttachmentId);
+			return { contentUrl: `https://content.test/${outboxAttachmentId}` };
 		},
 		keep: async (_draft, attachmentIds) => {
 			keeps.push(attachmentIds);
@@ -66,12 +67,20 @@ const createServer = () => {
 		},
 	};
 
+	const refuseMint = (filename: string, error: unknown) => {
+		const answer = mints.get(filename);
+		if (!answer) throw new Error(`no reservation asked for ${filename}`);
+		answer.reject(error);
+	};
+
 	const answerMint = (filename: string, outboxAttachmentId: string) => {
 		const answer = mints.get(filename);
 		if (!answer) throw new Error(`no reservation asked for ${filename}`);
 		answer.resolve({
 			outboxAttachmentId,
 			filename,
+			contentType: "application/octet-stream",
+			contentId: `${outboxAttachmentId}@test`,
 			uploadUrl: `https://upload.test/${outboxAttachmentId}`,
 		});
 	};
@@ -79,6 +88,7 @@ const createServer = () => {
 	return {
 		transport,
 		answerMint,
+		refuseMint,
 		onDraft,
 		put,
 		completed,
@@ -128,6 +138,106 @@ describe("ComposeAttachmentController", () => {
 		assert.equal(controller.blockingReason(), undefined);
 	});
 
+	it("hands the content-id to whoever attached the file once it is stored", async () => {
+		const { server, controller } = setup();
+		const stored: [string, string][] = [];
+		const shot = file("shot.png");
+
+		const attaching = controller.attach([shot], {
+			stored: (attached, contentId) => {
+				stored.push([attached.name, contentId]);
+			},
+			failed: () => {
+				throw new Error("a stored file was reported failed");
+			},
+		});
+		await settle();
+		assert.deepEqual(stored, [], "named before the bytes were stored");
+		server.answerMint("shot.png", "att-shot");
+		await attaching;
+
+		assert.deepEqual(stored, [["shot.png", "att-shot@test"]]);
+		assert.deepEqual(controller.storedContent("att-shot@test"), {
+			filename: "shot.png",
+			contentType: "application/octet-stream",
+			contentUrl: "https://content.test/att-shot",
+		});
+	});
+
+	it("tells whoever attached a refused file that it did not land, and keeps the refusal on its row", async () => {
+		const { server, controller } = setup();
+		const failed: string[] = [];
+
+		const attaching = controller.attach([file("huge.png")], {
+			stored: () => {
+				throw new Error("a refused file was reported stored");
+			},
+			failed: (attached) => {
+				failed.push(attached.name);
+			},
+		});
+		await settle();
+		server.refuseMint("huge.png", {
+			code: "attachment_rejected",
+			reason: "FileTooLarge",
+			message: '"huge.png" is 30.0 MB, over the 25.0 MB a message can carry.',
+		});
+		await attaching;
+
+		assert.deepEqual(failed, ["huge.png"]);
+		assert.deepEqual(rowFor(controller, "huge.png")?.state, {
+			status: "failed",
+			reason: '"huge.png" is 30.0 MB, over the 25.0 MB a message can carry.',
+			retryable: false,
+		});
+	});
+
+	it("names the content-id of a file once the server has dropped it", async () => {
+		const { server, controller } = setup();
+		const removed: string[] = [];
+		controller.onRemoved((contentId) => removed.push(contentId));
+
+		const attaching = controller.attach([file("shot.png")]);
+		await settle();
+		server.answerMint("shot.png", "att-shot");
+		await attaching;
+		await controller.remove(controller.getSnapshot()[0].key);
+
+		assert.deepEqual(removed, ["att-shot@test"]);
+		assert.equal(controller.owns("att-shot@test"), false);
+	});
+
+	it("keeps a file attached while the draft it joins was still loading", async () => {
+		const { server, controller } = setup();
+
+		const attaching = controller.attach([file("minutes.pdf")]);
+		await settle();
+		controller.load(DRAFT, [
+			{
+				outboxAttachmentId: "att-earlier",
+				outboxMessageId: DRAFT,
+				filename: "agenda.pdf",
+				contentType: "application/pdf",
+				sizeBytes: 5,
+				state: "Stored",
+				contentId: "att-earlier@remit",
+				contentUrl: "https://content.test/att-earlier",
+			},
+		]);
+		server.answerMint("minutes.pdf", "att-minutes");
+		await attaching;
+
+		assert.deepEqual(
+			controller
+				.getSnapshot()
+				.map((item) => [item.filename, item.state.status]),
+			[
+				["agenda.pdf", "attached"],
+				["minutes.pdf", "attached"],
+			],
+		);
+	});
+
 	it("takes a file removed while its reservation is out off the draft, and never uploads it", async () => {
 		const { server, controller } = setup();