@remit/web-client 0.0.325 → 0.0.326

package/src/lib/thread-search-tokens.ts

@@ -1,177 +0,0 @@
-/**
- * The parsed search tokens as `threadOperationsSearchThreads` parameters, plus
- * the tokens that request cannot carry.
- *
- * A token the request drops does not narrow anything, so the mailbox answers a
- * weaker question than the one that was asked and returns mail the user
- * excluded — `is:starred` handing back unstarred mail. Every token is therefore
- * accounted for exactly once: either the request carries it, or it comes back
- * as residue for the caller to apply over the returned rows
- * (`matchesSearchTokens`).
- *
- * Membership is decided by reading the request back rather than by tracking
- * which branch set what: a token is carried when the request that will be sent
- * asks for exactly what the token asks for. That covers the cases where one
- * parameter has to answer for several tokens — the endpoint takes a single
- * `from`, a single `subject` and one boolean per state, so a second `from:` or
- * a contradicting `is:read` cannot be expressed and becomes residue.
- *
- * The inbox chips own the parameters they set: a chip is a control on screen,
- * a token is text in a field, and where they disagree the visible control wins
- * and the token drops to residue (where, contradicting the chip, it matches
- * nothing — which is the honest answer to a contradiction).
- */
-
-import type { RemitImapThreadMessageResponse } from "@remit/api-http-client/types.gen.ts";
-import { matchesSearchTokens, toThreadRowData } from "./brief.js";
-import type { InboxFilterParams, ThreadSearchQuery } from "./inbox-filters.js";
-import type { SearchToken } from "./search-tokens.js";
-
-/** The search parameters the tokens themselves set. */
-export type ThreadSearchTokenParams = Pick<
-	ThreadSearchQuery,
-	"from" | "subject" | "category" | "unread" | "starred" | "attachments"
->;
-
-/** A parameter name a listing endpoint accepts. */
-export type ThreadSearchTokenParamName = keyof ThreadSearchTokenParams;
-
-/**
- * Every parameter `searchThreads` takes, the default set.
- *
- * `listAllThreads` takes all six as well (#1128), so both callers carry the
- * same tokens. A caller still names its own set rather than inheriting this
- * one: the set is what decides which tokens come back as residue, and an
- * endpoint that grows or loses a parameter has to say so where it is called.
- */
-export const THREAD_SEARCH_TOKEN_PARAMS: readonly ThreadSearchTokenParamName[] =
-	["from", "subject", "category", "unread", "starred", "attachments"];
-
-export interface ThreadSearchTokens {
-	/** What the tokens add to the request. */
-	params: ThreadSearchTokenParams;
-	/** The tokens the request does not carry; apply these over the rows. */
-	residual: SearchToken[];
-}
-
-/** The first value wins: the endpoint takes one value per parameter. */
-const firstValue = <T>(values: T[]): T | undefined => values[0];
-
-const paramsFromTokens = (
-	tokens: readonly SearchToken[],
-): ThreadSearchTokenParams => {
-	const from = firstValue(
-		tokens.filter((t) => t.type === "from").map((t) => t.value),
-	);
-	const subject = firstValue(
-		tokens.filter((t) => t.type === "subject").map((t) => t.value),
-	);
-	const category = firstValue(
-		tokens.filter((t) => t.type === "category").map((t) => t.category),
-	);
-	const unread = firstValue(
-		tokens
-			.filter((t) => t.type === "isUnread" || t.type === "isRead")
-			.map((t) => t.type === "isUnread"),
-	);
-	const starred = tokens.some((t) => t.type === "isStarred") ? true : undefined;
-	const attachments = tokens.some((t) => t.type === "hasAttachment")
-		? true
-		: undefined;
-	return {
-		...(from !== undefined ? { from } : {}),
-		...(subject !== undefined ? { subject } : {}),
-		...(category !== undefined ? { category: [category] } : {}),
-		...(unread !== undefined ? { unread } : {}),
-		...(starred !== undefined ? { starred } : {}),
-		...(attachments !== undefined ? { attachments } : {}),
-	};
-};
-
-/** Whether the request being sent asks for exactly what this token asks for. */
-const isCarried = (
-	request: ThreadSearchTokenParams,
-	token: SearchToken,
-): boolean => {
-	switch (token.type) {
-		case "from":
-			return request.from?.toLowerCase() === token.value.toLowerCase();
-		case "subject":
-			return request.subject?.toLowerCase() === token.value.toLowerCase();
-		case "category":
-			return (
-				request.category?.length === 1 && request.category[0] === token.category
-			);
-		case "isUnread":
-			return request.unread === true;
-		case "isRead":
-			return request.unread === false;
-		case "isStarred":
-			return request.starred === true;
-		case "hasAttachment":
-			return request.attachments === true;
-		// No parameter on this endpoint at all: dates, the account and the
-		// mailbox are the caller's to apply.
-		case "before":
-		case "after":
-		case "in":
-		case "account":
-			return false;
-	}
-};
-
-const narrowTo = (
-	params: ThreadSearchTokenParams,
-	carries: readonly ThreadSearchTokenParamName[],
-): ThreadSearchTokenParams =>
-	Object.fromEntries(
-		Object.entries(params).filter(([name]) =>
-			carries.includes(name as ThreadSearchTokenParamName),
-		),
-	);
-
-/**
- * Split the tokens into the parameters the thread listing takes and the residue
- * the caller has to apply itself. `chipParams` are the parameters already set
- * by the filter chips, which win where they overlap; `carries` names the
- * parameters the endpoint being called actually accepts.
- */
-export function threadSearchTokens(
-	tokens: readonly SearchToken[],
-	chipParams: InboxFilterParams = {},
-	carries: readonly ThreadSearchTokenParamName[] = THREAD_SEARCH_TOKEN_PARAMS,
-): ThreadSearchTokens {
-	const params = narrowTo(paramsFromTokens(tokens), carries);
-	const request: ThreadSearchTokenParams = {
-		...params,
-		...narrowTo(chipParams, carries),
-	};
-	return {
-		params,
-		residual: tokens.filter((token) => !isCarried(request, token)),
-	};
-}
-
-/**
- * The rows that satisfy every residual token. Identity when there is none.
- *
- * `accountId` names the account the rows belong to. A per-mailbox listing does
- * not carry one on the row — the mailbox already answers it — and a row whose
- * account is unknown cannot satisfy `account:`, so it drops rather than showing
- * under a filter nothing verified.
- */
-export function applyResidualTokens(
-	threads: RemitImapThreadMessageResponse[],
-	residual: readonly SearchToken[],
-	accountId?: string,
-): RemitImapThreadMessageResponse[] {
-	if (residual.length === 0) return threads;
-	const tokens = [...residual];
-	return threads.filter((thread) => {
-		const row = toThreadRowData(thread);
-		return matchesSearchTokens(
-			{ ...row, accountId: row.accountId ?? accountId },
-			tokens,
-		);
-	});
-}

package/src/lib/wizard-selection.test.ts

@@ -1,50 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import type { ThreadRowData } from "@remit/ui";
-import { wizardSelectionFrom } from "./wizard-selection.js";
-
-const row = (over: Partial<ThreadRowData> & { id: string }): ThreadRowData => ({
-	fromName: "Alice",
-	fromEmail: "alice@example.com",
-	subject: "Quarterly report",
-	snippet: "",
-	timeLabel: "Jan 1",
-	...over,
-});
-
-describe("the ticked rows the wizard is handed", () => {
-	// Regression for #872: a bulk run batches per account, and a row that
-	// arrives without its own account is one the run cannot place.
-	it("carries each row's own account, not the first one it saw", () => {
-		const got = wizardSelectionFrom(
-			[
-				row({ id: "m1", accountId: "acc-work" }),
-				row({ id: "m2", accountId: "acc-personal" }),
-			],
-			new Set(["m1", "m2"]),
-		);
-		assert.deepEqual(
-			got.map((message) => message.accountId),
-			["acc-work", "acc-personal"],
-		);
-	});
-
-	it("keeps a row whose list carries no account rather than dropping it", () => {
-		const got = wizardSelectionFrom([row({ id: "m1" })], new Set(["m1"]));
-		assert.deepEqual(
-			got.map((message) => ({ id: message.id, accountId: message.accountId })),
-			[{ id: "m1", accountId: undefined }],
-		);
-	});
-
-	it("takes only the ticked rows", () => {
-		const got = wizardSelectionFrom(
-			[row({ id: "m1" }), row({ id: "m2" })],
-			new Set(["m2"]),
-		);
-		assert.deepEqual(
-			got.map((message) => message.id),
-			["m2"],
-		);
-	});
-});

package/src/lib/wizard-selection.ts

@@ -1,43 +0,0 @@
-import type { ThreadRowData, WizardMessage } from "@remit/ui";
-
-/** A ticked row, as the wizard's samples and its clause prefill read it. */
-export interface WizardSelectionMessage extends WizardMessage {
-	/** Sender address — the properties prefill matches on it. */
-	email: string;
-	/**
-	 * Owning account, which a bulk run splits its batches by (#872) — the bulk
-	 * endpoints refuse a batch spanning accounts before applying any of it.
-	 * Stated by every surface rather than inferred: a per-mailbox list has one
-	 * account for all its rows and carries none on the row, while the brief and
-	 * Flagged span accounts and carry each row's own. Never `accountConfigId`,
-	 * which every account of one user shares (#456).
-	 */
-	accountId: string | undefined;
-	/**
-	 * The folder the row sits in, when the listing says. A saved rule's first
-	 * pass runs over the inbox, so a row elsewhere takes the action directly.
-	 */
-	mailboxId: string | undefined;
-}
-
-/**
- * The ticked rows of a thread list, as the wizard reads them. The brief and
- * Flagged both list rows from every account and hand their selection over the
- * same way, so they read it from here rather than each keeping a copy that has
- * to learn about a new field twice.
- */
-export const wizardSelectionFrom = (
-	rows: readonly ThreadRowData[],
-	selectedIds: ReadonlySet<string>,
-): WizardSelectionMessage[] =>
-	rows
-		.filter((row) => selectedIds.has(row.id))
-		.map((row) => ({
-			id: row.id,
-			sender: row.fromName,
-			email: row.fromEmail,
-			subject: row.subject,
-			date: row.timeLabel,
-			accountId: row.accountId,
-			mailboxId: row.mailboxId,
-		}));

package/src/main.tsx

@@ -1,10 +0,0 @@
-// Default distributor entry: composes the app shell with the combined auth
-// provider (Cognito + better-auth, selected at runtime by `config.js`). This is
-// what `@remit/web-client-dist` ships — one artifact for every deployment. A
-// single-provider deployment writes its own entry against the primitives and
-// omits the shell it does not use; see `harness/` for the reference build.
-import "./auth/cognito/cognito.css";
-import { combinedAuthProvider } from "./auth/combined-provider";
-import { mountApp } from "./shell";
-
-mountApp({ authProvider: combinedAuthProvider });

package/src/mocks/story-frame/AppStory.tsx

@@ -1,62 +0,0 @@
-import {
-	MutationCache,
-	QueryCache,
-	QueryClient,
-	QueryClientProvider,
-} from "@tanstack/react-query";
-import { createMemoryHistory, RouterProvider } from "@tanstack/react-router";
-import { useState } from "react";
-import {
-	type AuthProvider,
-	AuthProviderProvider,
-	noneAuthProvider,
-} from "@/auth/provider";
-import {
-	handleMutationCacheError,
-	handleQueryCacheError,
-} from "@/lib/query-error-handler";
-import { noopTelemetry } from "@/lib/telemetry";
-import { createAppRouter } from "@/router";
-import "@/lib/i18n";
-import "@/lib/client";
-
-export interface AppStoryProps {
-	url: string;
-	authProvider?: AuthProvider;
-}
-
-const createStoryQueryClient = (): QueryClient =>
-	new QueryClient({
-		queryCache: new QueryCache({ onError: handleQueryCacheError }),
-		mutationCache: new MutationCache({ onError: handleMutationCacheError }),
-		defaultOptions: {
-			queries: { staleTime: Number.POSITIVE_INFINITY, retry: false },
-			mutations: { retry: false },
-		},
-	});
-
-export function AppStory({
-	url,
-	authProvider = noneAuthProvider,
-}: AppStoryProps) {
-	const [queryClient] = useState(createStoryQueryClient);
-	const [router] = useState(() => {
-		authProvider.configure();
-		return createAppRouter(
-			queryClient,
-			noopTelemetry,
-			createMemoryHistory({ initialEntries: [url] }),
-		);
-	});
-	const { Shell } = authProvider;
-
-	return (
-		<QueryClientProvider client={queryClient}>
-			<AuthProviderProvider value={authProvider}>
-				<Shell>
-					<RouterProvider router={router} />
-				</Shell>
-			</AuthProviderProvider>
-		</QueryClientProvider>
-	);
-}

package/src/mocks/story-frame/calendar-window.ts

@@ -1,21 +0,0 @@
-import type { RemitImapCalendarEventInstance } from "@remit/api-http-client/types.gen.ts";
-
-/**
- * The occurrences inside the window a request asked for.
- *
- * The panes read a week at a time and hold several weeks at once, so a server
- * that answered every window with the same list would draw each day's events
- * once per window it appears in.
- */
-export const instancesWithin = (
-	url: URL,
-	instances: readonly RemitImapCalendarEventInstance[],
-): RemitImapCalendarEventInstance[] => {
-	const from = Date.parse(url.searchParams.get("from") ?? "");
-	const to = Date.parse(url.searchParams.get("to") ?? "");
-	if (Number.isNaN(from) || Number.isNaN(to)) return [...instances];
-	return instances.filter((instance) => {
-		const start = Date.parse(instance.start);
-		return start >= from && start < to;
-	});
-};

package/src/mocks/story-frame/compose-world.ts

@@ -1,191 +0,0 @@
-import type {
-	RemitImapOutboxMessageResponse,
-	RemitImapThreadMessageResponse,
-} from "@remit/api-http-client/types.gen.ts";
-import {
-	DAY,
-	HOUR,
-	type MailWorld,
-	MINUTE,
-	mailboxIdFor,
-	mailWorld,
-	outboxMessage,
-	threadRow,
-	WORK,
-} from "./mail-world";
-
-export const INBOX = mailboxIdFor(WORK, "Inbox");
-
-export const LUNCH_SUBJECT = "Lunch Thursday?";
-export const LUNCH_BODY = "Are we still on for Thursday? I can do 12:30.";
-export const LONG_SUBJECT = "Billing migration owners";
-export const TURNS_SUBJECT = "Offsite venue";
-export const SCANS_SUBJECT = "Scans";
-export const MISSPELT_DRAFT =
-	"<p>Ths report is redy today, and the notes are attachd.</p>";
-export const PLAIN_DRAFT = [
-	"Thanks, that works for me.",
-	"",
-	"| Region | Total |",
-	"| --- | --- |",
-	"| EMEA | 412 |",
-].join("\n");
-
-const longBody = [
-	"Longer context, so the pane has more message than it has room for.",
-	...Array.from(
-		{ length: 14 },
-		(_, index) =>
-			`Point ${index + 1}. The billing migration touches the export path, the dunning schedule and the invoice numbering, and each of those has a different owner today.`,
-	),
-].join("\n\n");
-
-const longDraft = [
-	"<p>That works. Before Thursday, three things I want written down:</p>",
-	...Array.from(
-		{ length: 24 },
-		(_, index) =>
-			`<p>Point ${index + 1}. Whoever owns the dunning mail after self-serve ships also owns the invoice numbering, and today those are two different people on two different rotas.</p>`,
-	),
-].join("");
-
-const conversations: RemitImapThreadMessageResponse[] = [
-	threadRow({
-		id: "lunch",
-		accountId: WORK,
-		fromName: "Ada Lovelace",
-		fromEmail: "ada@acme.example",
-		subject: LUNCH_SUBJECT,
-		snippet: LUNCH_BODY,
-		category: "personal",
-		ago: 30 * MINUTE,
-	}),
-	threadRow({
-		id: "billing",
-		accountId: WORK,
-		fromName: "Priya Raman",
-		fromEmail: "priya@acme.example",
-		subject: LONG_SUBJECT,
-		snippet:
-			"Longer context, so the pane has more message than it has room for.",
-		category: "personal",
-		ago: 3 * HOUR,
-	}),
-	threadRow({
-		id: "venue-1",
-		inThread: "venue",
-		accountId: WORK,
-		role: "Archive",
-		fromName: "Linus Berg",
-		fromEmail: "linus@acme.example",
-		subject: TURNS_SUBJECT,
-		snippet: "Two options for the offsite: the boathouse or the old mill.",
-		category: "personal",
-		ago: 3 * DAY,
-		isRead: true,
-	}),
-	threadRow({
-		id: "venue-2",
-		inThread: "venue",
-		accountId: WORK,
-		role: "Sent",
-		fromName: "Alice Tan",
-		fromEmail: "alice.tan@acme.example",
-		subject: `Re: ${TURNS_SUBJECT}`,
-		snippet: "The boathouse, if it still has the long table.",
-		category: "personal",
-		ago: 2 * DAY,
-		isRead: true,
-	}),
-	threadRow({
-		id: "venue-3",
-		inThread: "venue",
-		accountId: WORK,
-		fromName: "Linus Berg",
-		fromEmail: "linus@acme.example",
-		subject: `Re: ${TURNS_SUBJECT}`,
-		snippet: "It does. Shall I book it for the 14th?",
-		category: "personal",
-		ago: 4 * HOUR,
-	}),
-	threadRow({
-		id: "scans",
-		accountId: WORK,
-		fromName: "Office Scanner",
-		fromEmail: "scanner@acme.example",
-		subject: SCANS_SUBJECT,
-		snippet: "",
-		category: "automated",
-		ago: 5 * HOUR,
-		hasAttachment: true,
-	}),
-];
-
-const drafts: RemitImapOutboxMessageResponse[] = [
-	{
-		...outboxMessage({
-			id: "misspelt",
-			accountId: WORK,
-			to: "ada@acme.example",
-			subject: "Report",
-			body: "Ths report is redy today, and the notes are attachd.",
-			status: "draft",
-			ago: 5 * MINUTE,
-		}),
-		htmlBody: MISSPELT_DRAFT,
-	},
-	outboxMessage({
-		id: "plain",
-		accountId: WORK,
-		to: "ada@acme.example",
-		subject: "Re: Q3 planning",
-		body: PLAIN_DRAFT,
-		status: "draft",
-		ago: 6 * MINUTE,
-	}),
-	{
-		...outboxMessage({
-			id: "long-reply",
-			accountId: WORK,
-			to: "ada@acme.example",
-			subject: `Re: ${LUNCH_SUBJECT}`,
-			body: "That works.",
-			status: "draft",
-			ago: 7 * MINUTE,
-		}),
-		htmlBody: longDraft,
-	},
-];
-
-export const composeWorld = (overrides: Partial<MailWorld> = {}): MailWorld => {
-	const base = mailWorld();
-	return {
-		...base,
-		accounts: base.accounts.map((account) =>
-			account.accountId === WORK
-				? { ...account, composeLanguages: ["en", "nl", "de"] }
-				: account,
-		),
-		threads: [...base.threads, ...conversations],
-		outbox: [...base.outbox, ...drafts],
-		bodies: { "msg-billing": longBody },
-		...overrides,
-	};
-};
-
-export const withoutSmtp = (world: MailWorld): MailWorld => ({
-	...world,
-	accounts: world.accounts.map((account) => ({
-		...account,
-		smtpEnabled: false,
-	})),
-});
-
-export const messageUrl = (id: string, mailboxId: string = INBOX): string =>
-	`/mail/${mailboxId}/thread-${id}/msg-${id}`;
-
-export const threadUrl = (
-	threadId: string,
-	messageId: string,
-	mailboxId: string = INBOX,
-): string => `/mail/${mailboxId}/thread-${threadId}/msg-${messageId}`;