@remit/web-client 0.0.325 → 0.0.327

package/src/lib/escalation-label.test.ts

@@ -1,49 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, test } from "node:test";
-import {
-	describeSearchScope,
-	escalatedStatusLabel,
-	escalationActionLabel,
-} from "./escalation-label.js";
-
-describe("describeSearchScope", () => {
-	test("free text query wins and is quoted", () => {
-		assert.equal(describeSearchScope({ query: "npm" }), 'matching "npm"');
-	});
-
-	test("falls back to a from: filter when there's no free text", () => {
-		assert.equal(
-			describeSearchScope({ from: "billing@example.com" }),
-			'from "billing@example.com"',
-		);
-	});
-
-	test("free text wins over a from: filter when both are set", () => {
-		assert.equal(
-			describeSearchScope({ query: "npm", from: "noreply@npmjs.com" }),
-			'matching "npm"',
-		);
-	});
-
-	test("neither present falls back to a generic scope rather than throwing", () => {
-		assert.equal(describeSearchScope({}), "matching your search");
-	});
-});
-
-describe("escalationActionLabel", () => {
-	test("names the scope, never a bare Select all", () => {
-		assert.equal(
-			escalationActionLabel({ query: "npm" }),
-			'Select all matching "npm"',
-		);
-	});
-});
-
-describe("escalatedStatusLabel", () => {
-	test("thousands-separates the total and names the scope", () => {
-		assert.equal(
-			escalatedStatusLabel({ query: "npm" }, 3412),
-			'All 3,412 matching "npm" selected',
-		);
-	});
-});

package/src/lib/escalation-label.ts

@@ -1,32 +0,0 @@
-import { formatNumber } from "./format";
-
-/** The subset of the search predicate that names the scope in escalation copy. */
-export interface EscalationScopeQuery {
-	query?: string;
-	from?: string;
-}
-
-/**
- * Names what an escalated selection covers, for the notice text and the
- * confirm dialog — never a bare "Select all" (issue #92 requirement 4). Free
- * text wins when present since it's what the user actually typed; `from:`
- * alone still names a scope. Neither present is unreachable in practice (the
- * escalation control only ever renders for an active search), but the
- * fallback keeps the label honest instead of throwing.
- */
-export const describeSearchScope = (query: EscalationScopeQuery): string => {
-	if (query.query) return `matching "${query.query}"`;
-	if (query.from) return `from "${query.from}"`;
-	return "matching your search";
-};
-
-/** "Select all matching "npm"" — the escalation notice's action label. */
-export const escalationActionLabel = (query: EscalationScopeQuery): string =>
-	`Select all ${describeSearchScope(query)}`;
-
-/** "All 3,412 matching "npm" selected" — the bar's status label once escalated. */
-export const escalatedStatusLabel = (
-	query: EscalationScopeQuery,
-	total: number,
-): string =>
-	`All ${formatNumber(total)} ${describeSearchScope(query)} selected`;

package/src/lib/fatal-error.test.ts

@@ -1,78 +0,0 @@
-import assert from "node:assert/strict";
-import { afterEach, describe, it } from "node:test";
-import { ApiError } from "./api";
-import { getRecentErrors } from "./console-errors";
-import {
-	__resetFatalError,
-	getCurrentFatalError,
-	reportFatalError,
-	subscribeFatalError,
-} from "./fatal-error";
-
-afterEach(() => {
-	__resetFatalError();
-});
-
-describe("reportFatalError", () => {
-	it("notifies subscribers with the classified fatal", () => {
-		const seen: string[] = [];
-		subscribeFatalError((fatal) => seen.push(fatal.message));
-
-		reportFatalError(new Error("server exploded"));
-
-		assert.deepEqual(seen, ["server exploded"]);
-	});
-
-	it("records the fatal into the recent-errors ring (bug-report flow reads it)", () => {
-		reportFatalError(new Error("ring me"));
-		const recent = getRecentErrors();
-		assert.ok(
-			recent.some((line) => line.includes("Fatal: ring me")),
-			"expected the fatal to land in the console-errors ring",
-		);
-	});
-
-	it("assigns a correlation id and exposes the current fatal", () => {
-		const fatal = reportFatalError(new Error("with id"));
-		assert.ok(fatal.correlationId.length > 0);
-		assert.equal(getCurrentFatalError(), fatal);
-	});
-
-	it("unsubscribe stops further notifications", () => {
-		let count = 0;
-		const unsubscribe = subscribeFatalError(() => {
-			count += 1;
-		});
-		reportFatalError(new Error("one"));
-		unsubscribe();
-		reportFatalError(new Error("two"));
-		assert.equal(count, 1);
-	});
-});
-
-describe("reportFatalError — recoverable classification", () => {
-	it("classifies a 5xx as recoverable (Retry may succeed)", () => {
-		const fatal = reportFatalError(new ApiError("boom", 503));
-		assert.equal(fatal.recoverable, true);
-	});
-
-	it("classifies a hard 4xx as not recoverable (deterministic)", () => {
-		const fatal = reportFatalError(new ApiError("bad request", 400));
-		assert.equal(fatal.recoverable, false);
-	});
-
-	it("honours an explicit recoverable=false for a caught render exception", () => {
-		const fatal = reportFatalError(new Error("date value is not finite"), {
-			recoverable: false,
-			componentStack: "\n    at Accounts\n    at Route",
-		});
-		assert.equal(fatal.recoverable, false);
-		assert.equal(fatal.componentStack, "\n    at Accounts\n    at Route");
-	});
-
-	it("carries the error stack so the bug report can seed from it", () => {
-		const error = new Error("with stack");
-		const fatal = reportFatalError(error);
-		assert.equal(fatal.stack, error.stack);
-	});
-});

package/src/lib/fatal-error.ts

@@ -1,165 +0,0 @@
-import { recordError } from "./console-errors";
-import { isServerError } from "./error-classifier";
-import type { Telemetry } from "./telemetry";
-
-/**
- * The single escalation seam for first-party fatal errors.
- *
- * Calling `reportFatalError(error)` does three things, unconditionally:
- *  1. records the error into the recent-errors ring (so the bug-report flow
- *     picks it up),
- *  2. emits a telemetry fatal-error event (when a telemetry sink is registered
- *     via `setFatalErrorTelemetry` — `main.tsx` plugs the live RUM adapter in
- *     here), and
- *  3. notifies every subscriber — the `FatalErrorOverlay` subscribes here and
- *     takes over the whole screen with the red escalation page.
- *
- * This is the one place telemetry plugs in: RUM wires in once, not per call
- * site.
- */
-
-export interface FatalError {
-	error: unknown;
-	/** Human-readable message extracted from the error. */
-	message: string;
-	/** Correlation id for support — distinguishes one fatal from the next. */
-	correlationId: string;
-	/** When the fatal was reported. */
-	at: number;
-	/**
-	 * Whether retrying the same action might succeed. A transient class — a 5xx,
-	 * an offline/network blip, an aborted request — is recoverable; the overlay
-	 * offers Retry. A deterministic render/exception (caught by the route error
-	 * boundary) is NOT recoverable — retry re-crashes, so the overlay offers a
-	 * way out (a safe route) instead.
-	 */
-	recoverable: boolean;
-	/** The error's stack, when it is an `Error`. Seeds the bug report. */
-	stack?: string;
-	/** React component stack from the error boundary, when available. */
-	componentStack?: string;
-}
-
-/** Options for `reportFatalError`. */
-export interface ReportFatalOptions {
-	/**
-	 * Force the recoverable classification. Omit to derive it from the error
-	 * (transient network/5xx/abort ⇒ recoverable). The route error boundary
-	 * passes `false` for a caught render exception — it is deterministic.
-	 */
-	recoverable?: boolean;
-	/** React component stack captured by the error boundary. */
-	componentStack?: string;
-}
-
-/**
- * Default recoverable classification for an error with no explicit override.
- * Only a 5xx is treated as recoverable — the one clearly transient class, where
- * retrying the same action may succeed. Everything that reaches the fatal seam
- * is otherwise deterministic: aborts and offline/network blips never escalate
- * here (they are filtered upstream by `shouldEscalate`), so a statusless error
- * arriving here is an uncaught/unhandled crash, not a benign network blip.
- * A caught render exception is deterministic too — the error boundary reports
- * it with an explicit `recoverable: false` for good measure.
- */
-const defaultRecoverable = (error: unknown): boolean => isServerError(error);
-
-type FatalErrorListener = (fatal: FatalError) => void;
-
-const listeners = new Set<FatalErrorListener>();
-
-let current: FatalError | null = null;
-
-let telemetry: Telemetry | null = null;
-
-/**
- * Register the telemetry sink the fatal seam emits to. Called once from
- * `main.tsx` with the live RUM adapter (no-op telemetry when RUM is disabled).
- */
-export const setFatalErrorTelemetry = (sink: Telemetry): void => {
-	telemetry = sink;
-};
-
-const toError = (error: unknown): Error =>
-	error instanceof Error ? error : new Error(messageOf(error));
-
-const messageOf = (error: unknown): string => {
-	if (error instanceof Error) return error.message || error.name;
-	if (typeof error === "string") return error;
-	if (
-		error &&
-		typeof error === "object" &&
-		"message" in error &&
-		typeof (error as { message: unknown }).message === "string"
-	) {
-		return (error as { message: string }).message;
-	}
-	return "An unexpected server error occurred.";
-};
-
-const newCorrelationId = (): string => {
-	if (
-		typeof globalThis.crypto !== "undefined" &&
-		typeof globalThis.crypto.randomUUID === "function"
-	) {
-		return globalThis.crypto.randomUUID();
-	}
-	return `fatal-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
-};
-
-/**
- * Report a fatal, first-party error. Idempotent in spirit: the overlay shows
- * the first fatal and stays until the user reloads, so repeated calls only
- * refresh the recorded entry and re-notify (a no-op for an already-mounted
- * overlay).
- */
-export const reportFatalError = (
-	error: unknown,
-	options?: ReportFatalOptions,
-): FatalError => {
-	const fatal: FatalError = {
-		error,
-		message: messageOf(error),
-		correlationId: newCorrelationId(),
-		at: Date.now(),
-		recoverable: options?.recoverable ?? defaultRecoverable(error),
-		stack: error instanceof Error ? error.stack : undefined,
-		componentStack: options?.componentStack,
-	};
-
-	current = fatal;
-	recordError(`Fatal: ${fatal.message} [${fatal.correlationId}]`);
-
-	// Single telemetry seam: emit the fatal through RUM (epic #658). Scrubbing
-	// of ids/tokens happens inside the RUM adapter.
-	telemetry?.recordError(toError(error), {
-		fatal: "true",
-		correlationId: fatal.correlationId,
-	});
-
-	for (const listener of listeners) {
-		listener(fatal);
-	}
-
-	return fatal;
-};
-
-/** Subscribe to fatal errors. Returns an unsubscribe function. */
-export const subscribeFatalError = (
-	listener: FatalErrorListener,
-): (() => void) => {
-	listeners.add(listener);
-	return () => {
-		listeners.delete(listener);
-	};
-};
-
-/** The most recent fatal error, if any — lets a late subscriber catch up. */
-export const getCurrentFatalError = (): FatalError | null => current;
-
-/** Test-only: clear the in-memory fatal state, listeners, and telemetry sink. */
-export const __resetFatalError = (): void => {
-	current = null;
-	listeners.clear();
-	telemetry = null;
-};

package/src/lib/filter-report.ts

@@ -1,19 +0,0 @@
-import { buildBugReportContext, buildGitHubIssueUrl } from "./bug-report";
-
-export function filterToggleReportHref(message: string): string {
-	return buildGitHubIssueUrl(
-		buildBugReportContext({
-			title: `Filter toggle: ${message}`,
-			errorMessage: message,
-		}),
-	);
-}
-
-export function filterRunReportHref(message: string): string {
-	return buildGitHubIssueUrl(
-		buildBugReportContext({
-			title: `Filter run now: ${message}`,
-			errorMessage: message,
-		}),
-	);
-}

package/src/lib/flagged-criteria.test.ts

@@ -1,114 +0,0 @@
-/**
- * What the Flagged view asks the server for.
- *
- * #308: the chips became query parameters, and the tokens that ask for the same
- * thing have to travel the same way. A token evaluated over the pages loaded so
- * far reintroduces the defect one control down — the field would show an empty
- * list for a category whose starred mail sits below the newest page, while the
- * chip beside it showed the mail.
- */
-import assert from "node:assert/strict";
-import { describe, test } from "node:test";
-import { flaggedCriteria } from "./flagged-criteria.js";
-import type { InboxFilterCriteria } from "./inbox-filters.js";
-import { parseSearchTokens, type SearchToken } from "./search-tokens.js";
-
-const NO_CHIPS: InboxFilterCriteria = {
-	category: "all",
-	attributes: new Set<string>(),
-};
-
-const chips = (
-	category: string,
-	attributes: string[] = [],
-): InboxFilterCriteria => ({ category, attributes: new Set(attributes) });
-
-const tokensOf = (query: string): SearchToken[] =>
-	parseSearchTokens(query, {
-		accountsByName: new Map([["alice", "acc_1"]]),
-		mailboxesByName: new Map([["sent", "mb2"]]),
-	}).tokens;
-
-const criteriaOf = (query: string, filters = NO_CHIPS) =>
-	flaggedCriteria(filters, tokensOf(query)).criteria;
-
-const residualTypes = (query: string, filters = NO_CHIPS) =>
-	flaggedCriteria(filters, tokensOf(query)).residual.map((t) => t.type);
-
-describe("flaggedCriteria", () => {
-	test("a typed token asks for exactly what its chip asks for", () => {
-		assert.deepEqual(
-			criteriaOf("is:unread"),
-			criteriaOf("", chips("all", ["unread"])),
-		);
-		assert.deepEqual(
-			criteriaOf("has:attachment"),
-			criteriaOf("", chips("all", ["attachment"])),
-		);
-		assert.deepEqual(
-			criteriaOf("category:personal"),
-			criteriaOf("", chips("personal")),
-		);
-	});
-
-	test("carries the row criteria as parameters", () => {
-		assert.deepEqual(criteriaOf("is:unread"), { unread: true });
-		assert.deepEqual(criteriaOf("is:read"), { unread: false });
-		assert.deepEqual(criteriaOf("has:attachment"), { attachments: true });
-		assert.deepEqual(criteriaOf("category:social"), { category: ["social"] });
-	});
-
-	test("leaves nothing carried in the residue", () => {
-		assert.deepEqual(
-			residualTypes("is:unread has:attachment category:personal"),
-			[],
-		);
-	});
-
-	// The view is starred mail, so the request always carries `starred`. A token
-	// asking for what the request already asks for is answered, not re-applied.
-	test("answers is:starred from the view itself", () => {
-		assert.deepEqual(residualTypes("is:starred"), []);
-	});
-
-	// #1128: the free-text parameter matches subject and From at once, so
-	// neither token could be asked for on its own. Both applied over the pages
-	// already fetched, and a starred collection is paged — a match below them
-	// never appeared. Each has its own parameter now.
-	test("from: and subject: travel as parameters", () => {
-		assert.deepEqual(criteriaOf("from:alice"), { from: "alice" });
-		assert.deepEqual(residualTypes("from:alice"), []);
-		assert.deepEqual(criteriaOf("subject:invoice"), { subject: "invoice" });
-		assert.deepEqual(residualTypes("subject:invoice"), []);
-	});
-
-	test("keeps the tokens no parameter carries", () => {
-		assert.deepEqual(residualTypes("before:2026-01-01"), ["before"]);
-		assert.deepEqual(residualTypes("in:sent"), ["in"]);
-		assert.deepEqual(residualTypes("account:alice"), ["account"]);
-	});
-
-	// One parameter per field, so only the first value can be expressed.
-	test("a second subject: stays residue", () => {
-		assert.deepEqual(criteriaOf("subject:one subject:two"), {
-			subject: "one",
-		});
-		assert.deepEqual(residualTypes("subject:one subject:two"), ["subject"]);
-	});
-
-	test("the chip wins over a token that contradicts it", () => {
-		const { criteria, residual } = flaggedCriteria(
-			chips("all", ["unread"]),
-			tokensOf("is:read"),
-		);
-		assert.equal(criteria.unread, true);
-		assert.deepEqual(
-			residual.map((t) => t.type),
-			["isRead"],
-		);
-	});
-
-	test("a cleared category sets no category parameter", () => {
-		assert.deepEqual(criteriaOf("", NO_CHIPS), {});
-	});
-});

package/src/lib/flagged-criteria.ts

@@ -1,62 +0,0 @@
-/**
- * What the Flagged view asks `listAllThreads` for, and what is left over.
- *
- * Every criterion the view offers — the category chip, the Unread and Has
- * attachment chips, and the `from:` / `subject:` / `category:` / `is:unread` /
- * `is:read` / `has:attachment` / `is:starred` tokens typed in the field — is a
- * field on the ThreadMessage row, so all of them travel as query parameters. A
- * criterion applied over the pages loaded so far is the defect this replaces: a
- * starred collection is paged, so anything below the newest page was invisible
- * to it (#308, #1128).
- *
- * `starred` is the view rather than a criterion: the request always carries it,
- * which is what makes `is:starred` a carried token instead of residue.
- *
- * A chip beats a token where both set the same parameter — a control on screen
- * beats text in a field — and the overruled token drops to the residue, where
- * it matches nothing, which is the honest answer to a contradiction.
- */
-import type { InboxFilterCriteria } from "./inbox-filters.js";
-import { inboxFilterParams } from "./inbox-filters.js";
-import type { SearchToken } from "./search-tokens.js";
-import {
-	type ThreadSearchTokenParamName,
-	type ThreadSearchTokenParams,
-	threadSearchTokens,
-} from "./thread-search-tokens.js";
-
-/**
- * The token parameters `listAllThreads` carries, which is every parameter it
- * takes. `from` and `subject` joined them once the operation grew a parameter
- * for each field: its one free-text parameter matches both at once, so neither
- * token could be asked for on its own and both were applied over the pages
- * already fetched — a match below them never appeared (#1128).
- */
-export const FLAGGED_TOKEN_PARAMS: readonly ThreadSearchTokenParamName[] = [
-	"from",
-	"subject",
-	"category",
-	"unread",
-	"starred",
-	"attachments",
-];
-
-export interface FlaggedCriteria {
-	/** What the request narrows by, chips and carried tokens together. */
-	criteria: ThreadSearchTokenParams;
-	/** The tokens no parameter carries; apply these over the returned rows. */
-	residual: SearchToken[];
-}
-
-export const flaggedCriteria = (
-	chips: InboxFilterCriteria,
-	tokens: readonly SearchToken[],
-): FlaggedCriteria => {
-	const chipParams = inboxFilterParams(chips);
-	const { params, residual } = threadSearchTokens(
-		tokens,
-		{ ...chipParams, starred: true },
-		FLAGGED_TOKEN_PARAMS,
-	);
-	return { criteria: { ...params, ...chipParams }, residual };
-};

package/src/lib/folder-failure.test.ts

@@ -1,29 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import { folderFailure } from "./folder-failure.js";
-
-describe("folderFailure", () => {
-	it("says nothing about a folder that did not fail", () => {
-		assert.equal(
-			folderFailure({ syncStatus: "synced", syncFailureReason: "" }),
-			undefined,
-		);
-	});
-
-	it("carries the mail server's own words", () => {
-		assert.equal(
-			folderFailure({
-				syncStatus: "failed",
-				syncFailureReason: "Permission denied",
-			}),
-			"The mail server refused the last change: Permission denied",
-		);
-	});
-
-	it("still says it failed when the server gave no reason", () => {
-		assert.equal(
-			folderFailure({ syncStatus: "failed", syncFailureReason: " " }),
-			"The last change to this folder failed.",
-		);
-	});
-});

package/src/lib/folder-failure.ts

@@ -1,10 +0,0 @@
-import type { RemitImapMailboxResponse } from "@remit/api-http-client/types.gen.ts";
-
-export const folderFailure = (
-	mailbox: Pick<RemitImapMailboxResponse, "syncStatus" | "syncFailureReason">,
-): string | undefined => {
-	if (mailbox.syncStatus !== "failed") return undefined;
-	const reason = mailbox.syncFailureReason.trim();
-	if (reason.length === 0) return "The last change to this folder failed.";
-	return `The mail server refused the last change: ${reason}`;
-};