@remit/web-client 0.0.324 → 0.0.326

package/src/hooks/useComposeAttachments.ts

@@ -1,108 +0,0 @@
-import {
-	outboxAttachmentOperationsCompleteOutboxAttachmentMutation,
-	outboxDetailOperationsMintOutboxAttachmentMutation,
-	outboxDetailOperationsUpdateOutboxMessageMutation,
-} from "@remit/api-http-client/@tanstack/react-query.gen.ts";
-import { useMutation } from "@tanstack/react-query";
-import { useRef, useState, useSyncExternalStore } from "react";
-import {
-	type AttachmentTransport,
-	ComposeAttachmentController,
-	type DraftForAttachment,
-} from "../lib/compose-attachment-controller";
-import { softErrorMeta } from "../lib/error-classifier";
-
-export type { DraftForAttachment };
-
-const putFile = (
-	uploadUrl: string,
-	file: File,
-	signal: AbortSignal,
-): Promise<void> =>
-	fetch(uploadUrl, { method: "PUT", body: file, signal }).then((response) => {
-		if (!response.ok) {
-			throw new Error(`the server answered ${response.status}`);
-		}
-	});
-
-interface UseComposeAttachmentsOptions {
-	ensureDraft: () => Promise<DraftForAttachment>;
-}
-
-/** The composer's side of `ComposeAttachmentController`, over the app's API. */
-export const useComposeAttachments = ({
-	ensureDraft,
-}: UseComposeAttachmentsOptions) => {
-	const mintMutation = useMutation({
-		...outboxDetailOperationsMintOutboxAttachmentMutation(),
-		meta: softErrorMeta,
-	});
-	const completeMutation = useMutation({
-		...outboxAttachmentOperationsCompleteOutboxAttachmentMutation(),
-		meta: softErrorMeta,
-	});
-	const updateMutation = useMutation({
-		...outboxDetailOperationsUpdateOutboxMessageMutation(),
-		meta: softErrorMeta,
-	});
-
-	const transportRef = useRef<AttachmentTransport | null>(null);
-	transportRef.current = {
-		mint: (outboxMessageId, file) =>
-			mintMutation.mutateAsync({
-				path: { outboxMessageId },
-				body: {
-					filename: file.name,
-					contentType: file.type || "application/octet-stream",
-					sizeBytes: file.size,
-				},
-			}),
-		put: putFile,
-		complete: (outboxMessageId, outboxAttachmentId) =>
-			completeMutation
-				.mutateAsync({ path: { outboxMessageId, outboxAttachmentId } })
-				.then((attachment) => ({ contentUrl: attachment.contentUrl })),
-		keep: (outboxMessageId, attachmentIds) =>
-			updateMutation
-				.mutateAsync({
-					path: { outboxMessageId },
-					body: { attachmentIds },
-				})
-				.then(() => undefined),
-	};
-	const ensureDraftRef = useRef(ensureDraft);
-	ensureDraftRef.current = ensureDraft;
-
-	const [controller] = useState(
-		() =>
-			new ComposeAttachmentController({
-				transport: () => {
-					const transport = transportRef.current;
-					if (!transport) throw new Error("attachment transport not ready");
-					return transport;
-				},
-				ensureDraft: () => ensureDraftRef.current(),
-			}),
-	);
-
-	const items = useSyncExternalStore(
-		controller.subscribe,
-		controller.getSnapshot,
-		controller.getSnapshot,
-	);
-
-	return {
-		items,
-		attach: controller.attach,
-		retry: controller.retry,
-		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/useComposeLanguages.ts

@@ -1,69 +0,0 @@
-import {
-	accountDetailOperationsUpdateAccountMutation,
-	configOperationsGetConfigOptions,
-	configOperationsGetConfigQueryKey,
-} from "@remit/api-http-client/@tanstack/react-query.gen.ts";
-import { defaultComposeLanguages } from "@remit/ui";
-import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
-import { useCallback, useMemo } from "react";
-import { useErrorBanners } from "@/components/ui/ErrorBannerProvider";
-import { buildMutationErrorBanner } from "@/components/ui/error-banners";
-
-/**
- * The account's writing languages: the menu the composer's language chip
- * offers, and the set detection is allowed to choose inside. Absent on the
- * server means the user has never been here, and the browser's own ordered
- * answer stands in.
- */
-export const useComposeLanguages = (accountId?: string) => {
-	const queryClient = useQueryClient();
-	const { pushError } = useErrorBanners();
-
-	const { data: config } = useQuery({
-		...configOperationsGetConfigOptions(),
-		staleTime: Infinity,
-	});
-
-	const configured = config?.accounts.find(
-		(account) => account.accountId === accountId,
-	)?.composeLanguages;
-
-	const languages = useMemo<string[]>(
-		() =>
-			configured && configured.length > 0
-				? [...configured]
-				: defaultComposeLanguages(navigator.languages),
-		[configured],
-	);
-
-	const mutation = useMutation({
-		...accountDetailOperationsUpdateAccountMutation(),
-		onSuccess: () => {
-			queryClient.invalidateQueries({
-				queryKey: configOperationsGetConfigQueryKey(),
-			});
-		},
-		onError: (error) => {
-			pushError(
-				buildMutationErrorBanner(
-					"Couldn't save languages",
-					"The writing languages weren't saved.",
-					error,
-				),
-			);
-		},
-	});
-
-	const setLanguages = useCallback(
-		(next: string[]) => {
-			if (!accountId) return;
-			mutation.mutate({
-				path: { accountId },
-				body: { composeLanguages: next },
-			});
-		},
-		[accountId, mutation],
-	);
-
-	return { languages, setLanguages, isSaving: mutation.isPending };
-};

package/src/hooks/useCreateMailbox.render.test.ts

@@ -1,233 +0,0 @@
-/**
- * useCreateMailbox.createFolder — the shared create seam the kit surfaces call
- * for a dependent write. It validates the typed name against the account's
- * current folders with the same IMAP-aware rules the settings form uses, rejects
- * with the human-readable reason before any request, then waits for the mail
- * server to confirm the folder before resolving — so a filter or a move never
- * binds to a still-pending row. The mailbox list is seeded into the query cache
- * the hook reads, so validation runs against real paths.
- */
-
-import assert from "node:assert/strict";
-import { afterEach, describe, it } from "node:test";
-import { mailboxOperationsListMailboxesQueryKey } from "@remit/api-http-client/@tanstack/react-query.gen.ts";
-import type {
-	MailboxOperationsListMailboxesResponse,
-	RemitImapMailboxResponse,
-} from "@remit/api-http-client/types.gen.ts";
-import { MailboxSyncStatus } from "@remit/domain-enums";
-import type { FolderTreeNode } from "@remit/ui";
-import { act, createElement } from "react";
-import { MAILBOX_SYNC_FAILED_MESSAGE } from "../lib/mailbox-sync-wait";
-import { createDomHarness, type DomHarness } from "../test-support/dom";
-import { type HttpMock, mockFetch } from "../test-support/http";
-import { useCreateMailbox } from "./useCreateMailbox";
-
-const ACCOUNT = "acc-1";
-
-let harness: DomHarness | undefined;
-let http: HttpMock | undefined;
-let createFolder:
-	| ((name: string, signal?: AbortSignal) => Promise<FolderTreeNode>)
-	| undefined;
-
-afterEach(() => {
-	harness?.close();
-	harness = undefined;
-	http?.restore();
-	http = undefined;
-	createFolder = undefined;
-});
-
-const mailbox = (
-	fullPath: string,
-	delimiter: string,
-): RemitImapMailboxResponse =>
-	({
-		mailboxId: `mbx-${fullPath}`,
-		accountId: ACCOUNT,
-		fullPath,
-		hierarchyDelimiter: delimiter,
-	}) as RemitImapMailboxResponse;
-
-function Probe() {
-	createFolder = useCreateMailbox(ACCOUNT).createFolder;
-	return null;
-}
-
-const mount = (
-	items: RemitImapMailboxResponse[],
-	createdSyncStatus: RemitImapMailboxResponse["syncStatus"] = MailboxSyncStatus.synced,
-) => {
-	const created: RemitImapMailboxResponse[] = [];
-	http = mockFetch((call) => {
-		if (call.method === "POST") {
-			const body = call.body as { fullPath: string };
-			created.push({
-				mailboxId: `mbx-${body.fullPath}`,
-				accountId: ACCOUNT,
-				fullPath: body.fullPath,
-				hierarchyDelimiter: "/",
-				syncStatus: createdSyncStatus,
-			} as RemitImapMailboxResponse);
-			return { mailboxId: `mbx-${body.fullPath}`, fullPath: body.fullPath };
-		}
-		return { items: [...items, ...created] };
-	});
-	harness = createDomHarness();
-	harness.queryClient.setQueryData<MailboxOperationsListMailboxesResponse>(
-		mailboxOperationsListMailboxesQueryKey({ path: { accountId: ACCOUNT } }),
-		{ items },
-	);
-	harness.renderApp(createElement(Probe));
-};
-
-const reject = async (name: string): Promise<unknown> => {
-	const run = createFolder;
-	if (!run) throw new Error("createFolder is not mounted");
-	let caught: unknown;
-	await act(async () => {
-		caught = await run(name).then(
-			() => undefined,
-			(error: unknown) => error,
-		);
-	});
-	return caught;
-};
-
-const postCount = (): number =>
-	(http?.calls ?? []).filter((call) => call.method === "POST").length;
-
-describe("useCreateMailbox.createFolder validation", () => {
-	it("rejects a name containing the account delimiter before any request", async () => {
-		mount([mailbox("INBOX", "/")]);
-		const error = await reject("Work/Receipts");
-		assert.ok(error instanceof Error);
-		assert.match(error.message, /can't contain/);
-		assert.equal(postCount(), 0);
-	});
-
-	it("honours a non-slash account delimiter", async () => {
-		mount([mailbox("INBOX", ".")]);
-		const error = await reject("Work.Receipts");
-		assert.ok(error instanceof Error);
-		assert.match(error.message, /can't contain/);
-		assert.equal(postCount(), 0);
-	});
-
-	it("rejects a collision with an existing top-level fullPath before any request", async () => {
-		mount([mailbox("INBOX", "/"), mailbox("Work", "/")]);
-		const error = await reject("Work");
-		assert.ok(error instanceof Error);
-		assert.match(error.message, /already exists/);
-		assert.equal(postCount(), 0);
-	});
-
-	it("treats INBOX case-insensitively for collisions", async () => {
-		mount([mailbox("INBOX", "/")]);
-		const error = await reject("inbox");
-		assert.ok(error instanceof Error);
-		assert.match(error.message, /already exists/);
-		assert.equal(postCount(), 0);
-	});
-
-	it("passes a valid name through and resolves once the folder is confirmed synced", async () => {
-		mount([mailbox("INBOX", "/")]);
-		let result: FolderTreeNode | undefined;
-		await act(async () => {
-			result = await createFolder?.("Taxes");
-		});
-		const posts = (http?.calls ?? []).filter((call) => call.method === "POST");
-		assert.equal(posts.length, 1);
-		assert.deepEqual(posts[0].body, {
-			fullPath: "Taxes",
-			namespaceType: "personal",
-		});
-		// It polled the list after the create to confirm the folder before resolving.
-		const gets = (http?.calls ?? []).filter((call) => call.method === "GET");
-		assert.ok(gets.length >= 1, "polls the mailbox list for confirmation");
-		assert.equal(result?.label, "Taxes");
-	});
-
-	it("rejects — no folder to bind a dependent write to — when the create is reported failed", async () => {
-		mount([mailbox("INBOX", "/")], MailboxSyncStatus.failed);
-		let caught: unknown;
-		await act(async () => {
-			caught = await createFolder?.("Taxes").then(
-				() => undefined,
-				(error: unknown) => error,
-			);
-		});
-		assert.ok(caught instanceof Error);
-		assert.equal(caught.message, MAILBOX_SYNC_FAILED_MESSAGE);
-	});
-
-	it("retry resumes the wait on the folder it already made — no second create, no 'already exists'", async () => {
-		// The created folder is reported failed on the first attempt, then synced.
-		let status: RemitImapMailboxResponse["syncStatus"] =
-			MailboxSyncStatus.failed;
-		const created: RemitImapMailboxResponse[] = [];
-		http = mockFetch((call) => {
-			if (call.method === "POST") {
-				const body = call.body as { fullPath: string };
-				created.push({
-					mailboxId: `mbx-${body.fullPath}`,
-					accountId: ACCOUNT,
-					fullPath: body.fullPath,
-					hierarchyDelimiter: "/",
-				} as RemitImapMailboxResponse);
-				return { mailboxId: `mbx-${body.fullPath}`, fullPath: body.fullPath };
-			}
-			return {
-				items: [
-					mailbox("INBOX", "/"),
-					...created.map((entry) => ({ ...entry, syncStatus: status })),
-				],
-			};
-		});
-		harness = createDomHarness();
-		harness.queryClient.setQueryData<MailboxOperationsListMailboxesResponse>(
-			mailboxOperationsListMailboxesQueryKey({ path: { accountId: ACCOUNT } }),
-			{ items: [mailbox("INBOX", "/")] },
-		);
-		harness.renderApp(createElement(Probe));
-
-		let first: unknown;
-		await act(async () => {
-			first = await createFolder?.("Taxes").then(
-				() => undefined,
-				(error: unknown) => error,
-			);
-		});
-		assert.ok(first instanceof Error);
-		assert.equal(first.message, MAILBOX_SYNC_FAILED_MESSAGE);
-
-		// The server confirms; the user presses "Create folder" again, same name.
-		status = MailboxSyncStatus.synced;
-		let result: FolderTreeNode | undefined;
-		await act(async () => {
-			result = await createFolder?.("Taxes");
-		});
-		assert.equal(result?.label, "Taxes");
-
-		// Exactly one create across both attempts — the retry resumed, it did not
-		// re-validate (which would throw "already exists") or re-POST.
-		const posts = (http?.calls ?? []).filter((call) => call.method === "POST");
-		assert.equal(posts.length, 1);
-	});
-
-	it("abort stops the wait so a folder that confirms later never resolves", async () => {
-		mount([mailbox("INBOX", "/")], MailboxSyncStatus.pending);
-		const controller = new AbortController();
-		let caught: unknown;
-		await act(async () => {
-			const promise = createFolder?.("Taxes", controller.signal);
-			controller.abort();
-			caught = await promise?.then(
-				() => undefined,
-				(error: unknown) => error,
-			);
-		});
-		assert.equal((caught as { name?: string })?.name, "AbortError");
-	});
-});

package/src/hooks/useCreateMailbox.ts

@@ -1,153 +0,0 @@
-import {
-	mailboxOperationsCreateMailboxMutation,
-	mailboxOperationsListMailboxesOptions,
-	mailboxOperationsListMailboxesQueryKey,
-} from "@remit/api-http-client/@tanstack/react-query.gen.ts";
-import { mailboxLeafName } from "@remit/data-ports/mailbox-name";
-import type { FolderTreeNode } from "@remit/ui";
-import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
-import { useCallback, useRef } from "react";
-import { waitForMailboxSynced } from "@/lib/mailbox-sync-wait";
-import {
-	composeFolderPath,
-	type FolderTarget,
-	validateNewFolderName,
-} from "@/lib/new-folder";
-
-/**
- * Creates a mailbox for an account and refreshes the folder list on success.
- * The backend creates the row with a pending sync status and queues the IMAP
- * create.
- *
- * `createFolder` is the seam for dependent writes: a folder created so a filter
- * can move mail into it, or so a move can land mail there. It takes a leaf name,
- * validates it against the account's current folders with the same IMAP-aware
- * rules the settings form uses (non-empty, no hierarchy delimiter, no collision —
- * INBOX case-insensitive), and rejects with the human-readable reason before any
- * request. It then WAITS for the mail server to confirm the folder before
- * resolving — a folder is not a valid target until it exists on the server, and
- * binding a filter or a move to a still-pending row races the folder into
- * existence and cannot report a create that fails. It resolves with the confirmed
- * folder (carrying the path the server normalized to), rejects with a distinct
- * message when the create fails or never confirms, and the kit surfaces that
- * render either the "Creating folder…" wait or the failure inline.
- *
- * Retry is a resume, not a re-create: a create that timed out or failed leaves
- * the row already made, so pressing "Create folder" again calls `createFolder`
- * with the same name — which resumes the wait on the mailboxId it already made
- * rather than re-validating (the pending row would collide as "already exists")
- * and re-POSTing. The mailboxId is carried per-name until the folder confirms.
- *
- * `createFolder` takes an `AbortSignal` the surface aborts on unmount/cancel/
- * close, so a folder that confirms after the surface is gone resolves nothing.
- *
- * `createFolderIn` is the same seam for a folder made inside another one: the
- * parent is named by its provider path, and the name is joined to it with that
- * parent's own hierarchy delimiter. `createFolder` is it with no parent.
- *
- * `mutation` is exposed for callers that drive their own form state and want the
- * optimistic, non-waiting create.
- */
-export function useCreateMailbox(accountId: string | undefined) {
-	const queryClient = useQueryClient();
-
-	// Held by surfaces that are mounted before a selection has named an account —
-	// the selection wizard sits beside every list — so the folder list is only
-	// asked for once there is an account to ask about.
-	const { data } = useQuery({
-		...mailboxOperationsListMailboxesOptions({
-			path: { accountId: accountId ?? "" },
-		}),
-		enabled: !!accountId,
-	});
-
-	const mutation = useMutation({
-		...mailboxOperationsCreateMailboxMutation(),
-		onSuccess: () => {
-			if (!accountId) return;
-			queryClient.invalidateQueries({
-				queryKey: mailboxOperationsListMailboxesQueryKey({
-					path: { accountId },
-				}),
-			});
-		},
-	});
-
-	// fullPath -> mailboxId for a folder created but not yet confirmed, so a retry
-	// resumes the wait on it instead of re-creating. Cleared once it confirms.
-	const pendingByPath = useRef(new Map<string, string>());
-
-	const createFolderIn = useCallback(
-		async (
-			name: string,
-			parentPath: string,
-			signal?: AbortSignal,
-		): Promise<FolderTreeNode> => {
-			if (!accountId) {
-				throw new Error(
-					"No account to create the folder in. Pick messages from a single account first.",
-				);
-			}
-			const items = data?.items ?? [];
-			const parentMailbox = parentPath
-				? items.find((item) => item.fullPath === parentPath)
-				: undefined;
-			if (parentPath && !parentMailbox) {
-				throw new Error(
-					`Couldn't find the folder "${parentPath}" to create this one inside.`,
-				);
-			}
-			const parent: FolderTarget | undefined = parentMailbox
-				? {
-						fullPath: parentMailbox.fullPath,
-						hierarchyDelimiter: parentMailbox.hierarchyDelimiter,
-					}
-				: undefined;
-			const fullPath = composeFolderPath(name, parent);
-			let mailboxId = pendingByPath.current.get(fullPath);
-			if (!mailboxId) {
-				const delimiter =
-					parent?.hierarchyDelimiter ?? items[0]?.hierarchyDelimiter ?? "/";
-				const problem = validateNewFolderName({
-					name,
-					delimiter,
-					parent,
-					existingPaths: items.map((item) => item.fullPath),
-				});
-				if (problem) throw new Error(problem);
-				const mailbox = await mutation.mutateAsync({
-					path: { accountId },
-					body: { fullPath, namespaceType: "personal" },
-				});
-				mailboxId = mailbox.mailboxId;
-				pendingByPath.current.set(fullPath, mailboxId);
-			}
-			const confirmed = await waitForMailboxSynced({
-				mailboxId,
-				signal,
-				fetchMailboxes: async () => {
-					const response = await queryClient.fetchQuery({
-						...mailboxOperationsListMailboxesOptions({ path: { accountId } }),
-						staleTime: 0,
-					});
-					return response.items ?? [];
-				},
-			});
-			pendingByPath.current.delete(fullPath);
-			return {
-				id: confirmed.mailboxId,
-				label: mailboxLeafName(confirmed),
-				path: confirmed.fullPath,
-			};
-		},
-		[mutation, accountId, data, queryClient],
-	);
-
-	const createFolder = useCallback(
-		(name: string, signal?: AbortSignal): Promise<FolderTreeNode> =>
-			createFolderIn(name, "", signal),
-		[createFolderIn],
-	);
-
-	return { createFolder, createFolderIn, mutation };
-}

package/src/hooks/useCurrentMailboxName.ts

@@ -1,128 +0,0 @@
-import { mailboxOperationsListMailboxesOptions } from "@remit/api-http-client/@tanstack/react-query.gen.ts";
-import type { RemitImapAccountResponse } from "@remit/api-http-client/types.gen.ts";
-import { useQueries } from "@tanstack/react-query";
-import { useCallback } from "react";
-import { useTranslation } from "react-i18next";
-import { buildMailboxRoleMap, labelForMailbox } from "@/lib/folder-roles";
-import { useBrowsedList } from "@/routing";
-
-interface UseCurrentMailboxNameOptions {
-	accounts: RemitImapAccountResponse[];
-}
-
-/**
- * Resolves a display label for the mailbox or pseudo-mailbox the user is
- * currently looking at — used by the mobile top bar so it reads e.g.
- * "Inbox" or "Outbox" instead of the static "Remit" branding.
- *
- * Priority:
- *   - `/mail/outbox` → "Outbox"
- *   - `/mail/$mailboxId` → display name from the mailbox query
- *   - everything else (e.g. `/mail` mid-redirect) → `null`
- *
- * Reuses the same `mailboxOperationsListMailboxesOptions` queries the
- * `MailSidebarAdapter` runs, so on warm cache (the sidebar is always
- * mounted on `/mail/*`) this is a free lookup.
- */
-export const useCurrentMailboxName = ({
-	accounts,
-}: UseCurrentMailboxNameOptions): string | null => {
-	const { list, mailboxId } = useBrowsedList();
-	const { t } = useTranslation("mail", { useSuspense: false });
-	const translator = useCallback(
-		(key: string, fallback: string) => t(key, { defaultValue: fallback }),
-		[t],
-	);
-
-	const queries = useQueries({
-		queries: accounts.map((account) => ({
-			...mailboxOperationsListMailboxesOptions({
-				path: { accountId: account.accountId },
-			}),
-			staleTime: Infinity,
-		})),
-	});
-
-	if (list === "outbox") return "Outbox";
-	if (!mailboxId) return null;
-
-	for (let i = 0; i < accounts.length; i++) {
-		const items = queries[i]?.data?.items;
-		if (!items) continue;
-		const match = items.find((mailbox) => mailbox.mailboxId === mailboxId);
-		if (!match) continue;
-		const roleMap = buildMailboxRoleMap(accounts[i].folderAppointments);
-		return labelForMailbox(match, roleMap.get(mailboxId), translator);
-	}
-
-	return null;
-};
-
-/**
- * Resolves the authoritative unread (unseen) total for the current mailbox
- * from the mailbox query — the same warm-cache `mailboxOperationsListMailboxes`
- * data the sidebar and `useCurrentMailboxName` already read.
- *
- * Returns `mailbox.unseenCount` (the true server-side total), not a count
- * derived from the loaded infinite-query pages, which would undercount on any
- * mailbox larger than one page and creep upward as the user scrolls. Returns
- * `null` when the mailbox isn't resolvable yet (loading, or no `mailboxId`),
- * letting callers fall back to a loaded-derived count.
- */
-export const useCurrentMailboxUnseenCount = ({
-	accounts,
-}: UseCurrentMailboxNameOptions): number | null => {
-	const { mailboxId } = useBrowsedList();
-
-	const queries = useQueries({
-		queries: accounts.map((account) => ({
-			...mailboxOperationsListMailboxesOptions({
-				path: { accountId: account.accountId },
-			}),
-			staleTime: Infinity,
-		})),
-	});
-
-	if (!mailboxId) return null;
-
-	for (const query of queries) {
-		const items = query.data?.items;
-		if (!items) continue;
-		const match = items.find((mailbox) => mailbox.mailboxId === mailboxId);
-		if (match) return match.unseenCount;
-	}
-
-	return null;
-};
-
-/**
- * The current mailbox's total message count, from the same warm-cache mailbox
- * query. `0` while it is unresolvable, so a surface gated on "holds at least
- * one message" — Empty Trash (#847) — stays down rather than offering a verb
- * over a folder nothing is known about yet.
- */
-export const useCurrentMailboxMessageCount = ({
-	accounts,
-}: UseCurrentMailboxNameOptions): number => {
-	const { mailboxId } = useBrowsedList();
-
-	const queries = useQueries({
-		queries: accounts.map((account) => ({
-			...mailboxOperationsListMailboxesOptions({
-				path: { accountId: account.accountId },
-			}),
-			staleTime: Infinity,
-		})),
-	});
-
-	if (!mailboxId) return 0;
-
-	for (const query of queries) {
-		const items = query.data?.items;
-		if (!items) continue;
-		const match = items.find((mailbox) => mailbox.mailboxId === mailboxId);
-		if (match) return match.messageCount;
-	}
-
-	return 0;
-};