@remit/web-client 0.0.324 → 0.0.326

package/dist/src/lib/organize/rule-model.js

@@ -0,0 +1,98 @@
+import { pickedDateToExpiresAt } from "./filter-status";
+/**
+ * The clause fields the Organize editor may offer (RFC 038 D2). Gated on what
+ * the backend matcher evaluates, not on what the generated enum carries: every
+ * one of these is honored by the literal matcher and the back-apply corpus
+ * projection (match.ts), so a chip never previews a set the apply can't
+ * reproduce. `ListId` and `FromDomain` joined once their matcher shipped (#262).
+ */
+export const SUPPORTED_CLAUSE_FIELDS = [
+    "From",
+    "Subject",
+    "HasWords",
+    "ListId",
+    "FromDomain",
+];
+/**
+ * Canonical form of a `ListId` clause value, matching the backend's
+ * `normalizeListId` (list-id.ts): the bracketed identifier when present,
+ * otherwise the whole value, trimmed and case-folded. Normalizing at input keeps
+ * the chip the user sees identical to the value the matcher compares, so
+ * `<weekly.news.example.com>` and `Weekly.News.Example.com` are one list.
+ */
+export const normalizeListId = (value) => {
+    const trimmed = value.trim();
+    const bracketed = trimmed.match(/<([^>]+)>/);
+    return (bracketed ? bracketed[1] : trimmed).trim().toLowerCase();
+};
+/** Canonicalize a clause value for its field before it becomes a chip. */
+export const normalizeClauseValue = (field, value) => (field === "ListId" ? normalizeListId(value) : value.trim());
+const toApiOperator = (operator) => operator === "all" ? "And" : "Or";
+/**
+ * The match-relevant projection of a rule — the operator and the literal
+ * clauses. Preview and apply
+ * both derive from this, so the set the editor counts is the set a commit acts
+ * on. Fields that do not change the match set (folder, scope, name, date) are
+ * deliberately absent.
+ */
+export const rulePredicate = (rule) => ({
+    matchOperator: toApiOperator(rule.matchOperator),
+    literalClauses: rule.clauses.map((clause) => ({
+        field: clause.field,
+        value: clause.value,
+    })),
+});
+/**
+ * Whether the matcher behind `/organize/preview` can evaluate this predicate at
+ * all. It reads no message body and rejects a `HasWords` clause rather than
+ * narrowing the match silently (`bodyContentRejection`, backend/service/organize.ts). Asking it
+ * anyway is refused with a 400, on preview and on a back-apply alike, so the
+ * caller must not ask.
+ */
+export const isEvaluablePredicate = (predicate) => !predicate.literalClauses.some((clause) => clause.field === "HasWords");
+/**
+ * A stable key for a predicate's match set. Two predicates with the same key
+ * match the same messages; a change to the key is what marks the live count
+ * stale and schedules the next preview.
+ */
+export const predicateSignature = (predicate) => JSON.stringify({
+    operator: predicate.matchOperator,
+    clauses: predicate.literalClauses.map((clause) => `${clause.field} ${clause.value}`),
+});
+/**
+ * The commit draft for a rule. The match fields are exactly
+ * {@link rulePredicate}'s — the previewed predicate — with the folder action
+ * and, for the `until` scope, the derived expiry added. The expiry never enters
+ * the match set, so preview and apply still count and act on the same messages.
+ */
+export const ruleToDraft = (rule) => {
+    const predicate = rulePredicate(rule);
+    return {
+        matchOperator: predicate.matchOperator,
+        literalClauses: predicate.literalClauses,
+        moveMailboxId: rule.moveMailboxId,
+        labelId: rule.labelId,
+        expiresAt: rule.scope === "until"
+            ? pickedDateToExpiresAt(rule.until ?? "")
+            : undefined,
+    };
+};
+/**
+ * The live count for the rule on screen. The count is `ready` only when it was
+ * counted for the current predicate; a predicate change since then reads
+ * `stale` (recounting, never blank) so the commit gate can hold apply until it
+ * settles.
+ */
+export const derivePreview = (state, currentSignature) => {
+    if (state.error !== undefined && state.errorSignature === currentSignature) {
+        return { status: "error", reason: state.error };
+    }
+    if (state.count === undefined)
+        return { status: "loading" };
+    if (state.previewedSignature === currentSignature) {
+        return { status: "ready", count: state.count };
+    }
+    return { status: "ready", count: state.count, stale: true };
+};
+/** How long a rule change settles before the next preview fires. */
+export const PREVIEW_DEBOUNCE_MS = 350;

package/dist/src/lib/organize/search-to-rule.d.ts

@@ -0,0 +1,19 @@
+import type { RemitImapAccountResponse } from "@remit/api-http-client/types.gen.ts";
+import type { SearchConversion } from "@remit/ui";
+import { type ParsedSearchQuery } from "../search-tokens";
+/**
+ * Convert the current search into a rule's clauses and a record of what could not
+ * be carried. Terms become a `HasWords` clause; a `from:` facet a `From` clause
+ * and a `subject:` facet a `Subject` clause; an `in:` facet a kept-out folder
+ * scope; `account:` the target account; the attribute facets are dropped. The search's terms are ANDed with its facets, so
+ * the rule matches all of them (`all`).
+ */
+export declare const convertSearchToRule: (parsed: ParsedSearchQuery) => SearchConversion;
+/**
+ * Which account a rule converted from a search belongs to (#524). A query names
+ * one only through an explicit `account:` facet, which an ordinary search does
+ * not carry; without it the rule belongs to the account whose mail the search
+ * ran over, which is the account the surface handed over. Only a surface that
+ * has no single account of its own leaves the first configured one to answer.
+ */
+export declare const searchRuleAccountId: (conversion: SearchConversion, surfaceAccountId: string | undefined, accounts: readonly Pick<RemitImapAccountResponse, "accountId">[]) => string | undefined;

package/dist/src/lib/organize/search-to-rule.js

@@ -0,0 +1,65 @@
+import { searchTokenLabel, } from "../search-tokens";
+const FACET_HAS_NO_CLAUSE = new Set([
+    "hasAttachment",
+    "isUnread",
+    "isRead",
+    "isStarred",
+    "category",
+    "before",
+    "after",
+]);
+const hasNoClauseEquivalent = (type) => FACET_HAS_NO_CLAUSE.has(type);
+/**
+ * Convert the current search into a rule's clauses and a record of what could not
+ * be carried. Terms become a `HasWords` clause; a `from:` facet a `From` clause
+ * and a `subject:` facet a `Subject` clause; an `in:` facet a kept-out folder
+ * scope; `account:` the target account; the attribute facets are dropped. The search's terms are ANDed with its facets, so
+ * the rule matches all of them (`all`).
+ */
+export const convertSearchToRule = (parsed) => {
+    const clauses = [];
+    const droppedFacets = [];
+    let scopedOut;
+    let targetAccountId;
+    for (const token of parsed.tokens) {
+        if (token.type === "from") {
+            clauses.push({ field: "From", value: token.value });
+            continue;
+        }
+        if (token.type === "subject") {
+            clauses.push({ field: "Subject", value: token.value });
+            continue;
+        }
+        if (token.type === "in") {
+            scopedOut = { mailboxId: token.mailboxId, label: token.value };
+            continue;
+        }
+        if (token.type === "account") {
+            targetAccountId = token.accountId;
+            continue;
+        }
+        if (hasNoClauseEquivalent(token.type)) {
+            droppedFacets.push({ type: token.type, label: searchTokenLabel(token) });
+        }
+    }
+    const freeText = parsed.freeText.trim();
+    const keptTerms = freeText.length > 0;
+    if (keptTerms)
+        clauses.push({ field: "HasWords", value: freeText });
+    return {
+        clauses,
+        matchOperator: "all",
+        scopedOut,
+        droppedFacets,
+        targetAccountId,
+        keptTerms,
+    };
+};
+/**
+ * Which account a rule converted from a search belongs to (#524). A query names
+ * one only through an explicit `account:` facet, which an ordinary search does
+ * not carry; without it the rule belongs to the account whose mail the search
+ * ran over, which is the account the surface handed over. Only a surface that
+ * has no single account of its own leaves the first configured one to answer.
+ */
+export const searchRuleAccountId = (conversion, surfaceAccountId, accounts) => conversion.targetAccountId ?? surfaceAccountId ?? accounts[0]?.accountId;

package/dist/src/lib/outbox-search.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Query narrowing for the outbox list.
+ *
+ * The outbox is a small, fully-loaded client-side list of mail that has not
+ * left yet, so its search is a filter over the rows already in hand rather
+ * than a request. It matches what an outbox row shows — subject, recipients
+ * and sender — because that is what the user can see to search for.
+ *
+ * Filter tokens (`from:`, `is:unread`, dates) are not honored: an outbox row
+ * has no read state, no mailbox and no received date, so the operators have
+ * nothing to read. Only the free text narrows, so `Q3 from:billing` still
+ * matches on "Q3".
+ *
+ * A query made only of tokens asks for a filter this view cannot apply, and
+ * there is no free text left to fall back on. Rather than return every row as
+ * if the filter had been honored, that case returns nothing and the list says
+ * why — see `outboxQueryIsUnsupported`.
+ */
+import type { ParsedSearchQuery } from "./search-tokens";
+/** The outbox row fields a query is matched against. */
+export interface OutboxSearchRow {
+    subject?: string | null;
+    fromAddress?: string | null;
+    fromName?: string | null;
+    toAddresses?: readonly string[] | null;
+    ccAddresses?: readonly string[] | null;
+}
+export declare function matchesOutboxSearch(row: OutboxSearchRow, freeText: string): boolean;
+/**
+ * True when the query is nothing but filter tokens. The outbox can serve none
+ * of them, and matching on the empty free text left over would return every
+ * row — indistinguishable from a filter that matched everything.
+ */
+export declare function outboxQueryIsUnsupported(parsed: ParsedSearchQuery): boolean;

package/dist/src/lib/outbox-search.js

@@ -0,0 +1,26 @@
+export function matchesOutboxSearch(row, freeText) {
+    const needle = freeText.trim().toLowerCase();
+    if (needle.length === 0)
+        return true;
+    const haystack = [
+        row.subject,
+        row.fromAddress,
+        row.fromName,
+        ...(row.toAddresses ?? []),
+        ...(row.ccAddresses ?? []),
+    ]
+        .filter((value) => typeof value === "string")
+        .join(" ")
+        .toLowerCase();
+    return needle
+        .split(/\s+/)
+        .every((word) => word.length === 0 || haystack.includes(word));
+}
+/**
+ * True when the query is nothing but filter tokens. The outbox can serve none
+ * of them, and matching on the empty free text left over would return every
+ * row — indistinguishable from a filter that matched everything.
+ */
+export function outboxQueryIsUnsupported(parsed) {
+    return parsed.tokens.length > 0 && parsed.freeText.trim().length === 0;
+}

package/dist/src/lib/outbox-status.d.ts

@@ -0,0 +1,47 @@
+import type { RemitImapOutboxMessageStatus } from "@remit/api-http-client/types.gen.ts";
+/**
+ * Visual states for outbox messages.
+ *
+ * `sent` is included for completeness (the detail view of a sent message
+ * uses it before the row gets purged) but the outbox list never renders
+ * `sent` rows — they are filtered out (issue #193).
+ */
+export type OutboxDisplayStatus = Exclude<RemitImapOutboxMessageStatus, "draft">;
+export type OutboxStatusTone = "success" | "info" | "warning" | "error" | "neutral";
+export interface OutboxStatusDescriptor {
+    label: string;
+    tone: OutboxStatusTone;
+}
+/**
+ * Describe an outbox status for UI rendering.
+ *
+ * `failed` and `blocked` are both terminal non-success states but carry
+ * different remediation: `failed` may auto-retry on a transient error, and
+ * is the appropriate label for SMTP auth/connection errors. `blocked` means
+ * the account is misconfigured (e.g. no SMTP host) — the user must fix the
+ * account before any retry can succeed.
+ *
+ * Returns null for `draft` (drafts live in a separate view).
+ */
+export declare const describeOutboxStatus: (status: RemitImapOutboxMessageStatus) => OutboxStatusDescriptor | null;
+/**
+ * Whether a status carries a `lastError` worth surfacing in the UI.
+ *
+ * Critically: `sent` is NOT included. A successful send must never display
+ * a stale lastError — that is the contradictory "green check + 'SMTP not
+ * configured'" UI bug from issue #192. `unfiled` is: the message was
+ * delivered but could not be filed, and the reason is the whole point of
+ * the row still being there.
+ */
+export declare const showsLastError: (status: RemitImapOutboxMessageStatus) => boolean;
+/**
+ * Whether the outbox list view should render this row.
+ *
+ * `draft` belongs in the Drafts view. `sent` rows are deleted by the IMAP
+ * APPEND handler (issue #178) — but until that happens we hide them from
+ * the Outbox list so a successfully-sent message never appears in two
+ * places at once (issue #193). `unfiled` is the settled failure of that
+ * APPEND: the message is on no server folder, so the Outbox row is the only
+ * copy the user has and it stays listed.
+ */
+export declare const isOutboxListRow: (status: RemitImapOutboxMessageStatus) => boolean;

package/dist/src/lib/outbox-status.js

@@ -0,0 +1,45 @@
+const STATUS_DESCRIPTORS = {
+    queued: { label: "Queued", tone: "neutral" },
+    sending: { label: "Sending…", tone: "info" },
+    sent: { label: "Sent", tone: "success" },
+    unfiled: { label: "Sent, not filed", tone: "warning" },
+    failed: { label: "Failed", tone: "error" },
+    blocked: { label: "Blocked", tone: "warning" },
+};
+/**
+ * Describe an outbox status for UI rendering.
+ *
+ * `failed` and `blocked` are both terminal non-success states but carry
+ * different remediation: `failed` may auto-retry on a transient error, and
+ * is the appropriate label for SMTP auth/connection errors. `blocked` means
+ * the account is misconfigured (e.g. no SMTP host) — the user must fix the
+ * account before any retry can succeed.
+ *
+ * Returns null for `draft` (drafts live in a separate view).
+ */
+export const describeOutboxStatus = (status) => {
+    if (status === "draft")
+        return null;
+    return STATUS_DESCRIPTORS[status];
+};
+/**
+ * Whether a status carries a `lastError` worth surfacing in the UI.
+ *
+ * Critically: `sent` is NOT included. A successful send must never display
+ * a stale lastError — that is the contradictory "green check + 'SMTP not
+ * configured'" UI bug from issue #192. `unfiled` is: the message was
+ * delivered but could not be filed, and the reason is the whole point of
+ * the row still being there.
+ */
+export const showsLastError = (status) => status === "failed" || status === "blocked" || status === "unfiled";
+/**
+ * Whether the outbox list view should render this row.
+ *
+ * `draft` belongs in the Drafts view. `sent` rows are deleted by the IMAP
+ * APPEND handler (issue #178) — but until that happens we hide them from
+ * the Outbox list so a successfully-sent message never appears in two
+ * places at once (issue #193). `unfiled` is the settled failure of that
+ * APPEND: the message is on no server folder, so the Outbox row is the only
+ * copy the user has and it stays listed.
+ */
+export const isOutboxListRow = (status) => status !== "draft" && status !== "sent";

package/dist/src/lib/provider-presets.d.ts

@@ -0,0 +1,16 @@
+import { type ServerSettings } from "./autodiscovery.js";
+export interface ProviderPreset {
+    id: string;
+    label: string;
+    username: "full-email";
+    imap: ServerSettings;
+    smtp: ServerSettings;
+    passwordHelp: {
+        text: string;
+        url: string;
+    };
+}
+export declare const PROVIDER_PRESETS: ProviderPreset[];
+export declare function getPresetById(id: string): ProviderPreset | undefined;
+/** Pre-select a provider preset from a known email domain; "" for Custom. */
+export declare function presetIdForEmail(email: string): string;

package/dist/src/lib/provider-presets.js

@@ -0,0 +1,82 @@
+import { APP_PASSWORD_URLS } from "./autodiscovery.js";
+export const PROVIDER_PRESETS = [
+    {
+        id: "icloud",
+        label: "iCloud",
+        username: "full-email",
+        imap: { host: "imap.mail.me.com", port: 993, security: "tls" },
+        smtp: { host: "smtp.mail.me.com", port: 587, security: "starttls" },
+        passwordHelp: {
+            text: "iCloud requires an app-specific password, not your Apple ID password. Generate one under Sign-In & Security → App-Specific Passwords.",
+            url: "https://support.apple.com/en-us/102654",
+        },
+    },
+    {
+        id: "yahoo",
+        label: "Yahoo",
+        username: "full-email",
+        imap: { host: "imap.mail.yahoo.com", port: 993, security: "tls" },
+        smtp: { host: "smtp.mail.yahoo.com", port: 465, security: "tls" },
+        passwordHelp: {
+            text: "Yahoo requires an app password, not your login password. Generate one under Account Security.",
+            url: "https://help.yahoo.com/kb/generate-manage-third-party-passwords-sln15241.html",
+        },
+    },
+    {
+        id: "aol",
+        label: "AOL",
+        username: "full-email",
+        imap: { host: "imap.aol.com", port: 993, security: "tls" },
+        smtp: { host: "smtp.aol.com", port: 465, security: "tls" },
+        passwordHelp: {
+            text: "AOL requires an app password, not your login password. Generate one under Account Security.",
+            url: "https://login.aol.com/account/security",
+        },
+    },
+    {
+        id: "fastmail",
+        label: "Fastmail",
+        username: "full-email",
+        imap: { host: "imap.fastmail.com", port: 993, security: "tls" },
+        smtp: { host: "smtp.fastmail.com", port: 465, security: "tls" },
+        passwordHelp: {
+            text: "Fastmail requires an app password, not your login password. Create one under Settings → Privacy & Security → App passwords.",
+            url: "https://www.fastmail.help/hc/en-us/articles/360058752854",
+        },
+    },
+    {
+        id: "gmail",
+        label: "Gmail",
+        username: "full-email",
+        imap: { host: "imap.gmail.com", port: 993, security: "tls" },
+        smtp: { host: "smtp.gmail.com", port: 587, security: "starttls" },
+        passwordHelp: {
+            text: "Gmail requires an app password, not your Google password. First turn on 2-Step Verification for your Google Account, then create an app password under Security → 2-Step Verification → App passwords.",
+            url: APP_PASSWORD_URLS["gmail.com"],
+        },
+    },
+];
+export function getPresetById(id) {
+    return PROVIDER_PRESETS.find((preset) => preset.id === id);
+}
+const DOMAIN_TO_PRESET = {
+    "icloud.com": "icloud",
+    "me.com": "icloud",
+    "mac.com": "icloud",
+    "yahoo.com": "yahoo",
+    "yahoo.co.uk": "yahoo",
+    "ymail.com": "yahoo",
+    "aol.com": "aol",
+    "fastmail.com": "fastmail",
+    "fastmail.fm": "fastmail",
+    "gmail.com": "gmail",
+    "googlemail.com": "gmail",
+};
+/** Pre-select a provider preset from a known email domain; "" for Custom. */
+export function presetIdForEmail(email) {
+    const atIdx = email.indexOf("@");
+    if (atIdx === -1)
+        return "";
+    const domain = email.slice(atIdx + 1).toLowerCase();
+    return DOMAIN_TO_PRESET[domain] ?? "";
+}

package/dist/src/lib/quarantine-entries.d.ts

@@ -0,0 +1,15 @@
+import type { RemitImapQuarantineResponse } from "@remit/api-http-client/types.gen.ts";
+import type { QuarantineEntry } from "@remit/ui";
+/**
+ * The wire record carries `accountConfigId`, `createdAt` and `updatedAt`, which
+ * the settings surface has no use for, and spells the folder role in the
+ * canonical PascalCase the API uses everywhere. Both differences are resolved
+ * here rather than by widening the kit's entry type.
+ *
+ * The record carries no hierarchy delimiter either, so the caller joins the
+ * mailbox id against the account's own mailbox list and hands the delimiter in
+ * — the row shows a folder name, and a path cannot be cut into one without it.
+ * An empty delimiter means no account lists that mailbox, and the row keeps its
+ * whole path rather than being cut on a guess.
+ */
+export declare function toQuarantineEntry(wire: RemitImapQuarantineResponse, mailboxDelimiter: string): QuarantineEntry;

package/dist/src/lib/quarantine-entries.js

@@ -0,0 +1,40 @@
+import { CANONICAL_TO_NAV_ROLE } from "./folder-roles";
+/**
+ * The wire record carries `accountConfigId`, `createdAt` and `updatedAt`, which
+ * the settings surface has no use for, and spells the folder role in the
+ * canonical PascalCase the API uses everywhere. Both differences are resolved
+ * here rather than by widening the kit's entry type.
+ *
+ * The record carries no hierarchy delimiter either, so the caller joins the
+ * mailbox id against the account's own mailbox list and hands the delimiter in
+ * — the row shows a folder name, and a path cannot be cut into one without it.
+ * An empty delimiter means no account lists that mailbox, and the row keeps its
+ * whole path rather than being cut on a guess.
+ */
+export function toQuarantineEntry(wire, mailboxDelimiter) {
+    return {
+        quarantineId: wire.quarantineId,
+        accountId: wire.accountId,
+        mailboxId: wire.mailboxId,
+        uidValidity: wire.uidValidity,
+        uid: wire.uid,
+        mailboxRole: wire.mailboxRole
+            ? CANONICAL_TO_NAV_ROLE[wire.mailboxRole]
+            : undefined,
+        mailboxPath: wire.mailboxPath,
+        mailboxDelimiter,
+        failureStage: wire.failureStage,
+        failureCode: wire.failureCode,
+        failureMessage: wire.failureMessage,
+        failurePartPath: wire.failurePartPath,
+        quarantinedAt: wire.quarantinedAt,
+        attempts: wire.attempts,
+        sizeBytes: wire.sizeBytes,
+        contentType: wire.contentType,
+        transferEncoding: wire.transferEncoding,
+        charset: wire.charset,
+        structure: wire.structure,
+        messageIdHash: wire.messageIdHash,
+        workerVersion: wire.workerVersion,
+    };
+}

package/dist/src/lib/query-error-handler.d.ts

@@ -0,0 +1,21 @@
+import type { Mutation, Query } from "@tanstack/react-query";
+/**
+ * Global React Query error sink. Every query and mutation error flows through
+ * here (wired on the `QueryCache`/`MutationCache` in main.tsx). The fail-fast
+ * contract (#1059) lives in `shouldEscalate`: a non-2xx escalates to the
+ * full-screen red overlay by default; a 5xx ALWAYS escalates; only aborts,
+ * statusless network blips, and non-5xx errors a call site opted out of via
+ * `meta.softError` stay soft.
+ *
+ * The two caches differ on one thing, the `Awaiting` argument. A mutation is
+ * something the user did and is owed the outcome of, so a 401 there escalates
+ * over `meta.softError` — no banner signs anyone back in. A query is "nobody" as
+ * a class: the reads the screen is actually waiting on carry no `meta.softError`
+ * and escalate on the default anyway, so the only ones this spares are those
+ * that already declared they own their failures.
+ *
+ * This is the v5 equivalent of `defaultOptions.queries.onError` /
+ * `.mutations.onError` — v5 moved the global error hook onto the caches.
+ */
+export declare const handleQueryCacheError: (error: Error, query: Query<unknown, unknown, unknown>) => void;
+export declare const handleMutationCacheError: (error: unknown, _variables: unknown, _onMutateResult: unknown, mutation: Mutation<unknown, unknown, unknown>) => void;

package/dist/src/lib/query-error-handler.js

@@ -0,0 +1,30 @@
+import { shouldEscalate } from "./error-classifier";
+import { reportFatalError } from "./fatal-error";
+/**
+ * Global React Query error sink. Every query and mutation error flows through
+ * here (wired on the `QueryCache`/`MutationCache` in main.tsx). The fail-fast
+ * contract (#1059) lives in `shouldEscalate`: a non-2xx escalates to the
+ * full-screen red overlay by default; a 5xx ALWAYS escalates; only aborts,
+ * statusless network blips, and non-5xx errors a call site opted out of via
+ * `meta.softError` stay soft.
+ *
+ * The two caches differ on one thing, the `Awaiting` argument. A mutation is
+ * something the user did and is owed the outcome of, so a 401 there escalates
+ * over `meta.softError` — no banner signs anyone back in. A query is "nobody" as
+ * a class: the reads the screen is actually waiting on carry no `meta.softError`
+ * and escalate on the default anyway, so the only ones this spares are those
+ * that already declared they own their failures.
+ *
+ * This is the v5 equivalent of `defaultOptions.queries.onError` /
+ * `.mutations.onError` — v5 moved the global error hook onto the caches.
+ */
+export const handleQueryCacheError = (error, query) => {
+    if (shouldEscalate(error, query.meta, "nobody")) {
+        reportFatalError(error);
+    }
+};
+export const handleMutationCacheError = (error, _variables, _onMutateResult, mutation) => {
+    if (shouldEscalate(error, mutation.meta, "user")) {
+        reportFatalError(error);
+    }
+};

package/dist/src/lib/recent-searches.d.ts

@@ -0,0 +1,2 @@
+export declare function loadRecentSearches(): string[];
+export declare function saveRecentSearch(query: string): string[];

package/dist/src/lib/recent-searches.js

@@ -0,0 +1,37 @@
+/**
+ * Recent search queries for the mobile search takeover, persisted in
+ * localStorage. Best-effort: storage failures (private mode, quota) degrade to
+ * an empty list rather than crashing the search surface.
+ */
+const RECENT_SEARCHES_KEY = "remit.recentSearches";
+const MAX_RECENT = 5;
+export function loadRecentSearches() {
+    try {
+        const raw = localStorage.getItem(RECENT_SEARCHES_KEY);
+        if (!raw)
+            return [];
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed))
+            return [];
+        return parsed.filter((q) => typeof q === "string");
+    }
+    catch {
+        return [];
+    }
+}
+export function saveRecentSearch(query) {
+    const trimmed = query.trim();
+    if (!trimmed)
+        return loadRecentSearches();
+    const next = [
+        trimmed,
+        ...loadRecentSearches().filter((q) => q !== trimmed),
+    ].slice(0, MAX_RECENT);
+    try {
+        localStorage.setItem(RECENT_SEARCHES_KEY, JSON.stringify(next));
+    }
+    catch {
+        return next;
+    }
+    return next;
+}

package/dist/src/lib/recipient-suggestions.d.ts

@@ -0,0 +1,2 @@
+import type { RemitImapAddressResponse } from "@remit/api-http-client";
+export declare const offerableAsRecipient: (address: RemitImapAddressResponse) => boolean;

package/dist/src/lib/recipient-suggestions.js

@@ -0,0 +1,11 @@
+const accountHasCorresponded = (address) => address.outboundCount > 0 ||
+    address.replyCount > 0 ||
+    address.flags?.vip?.value === true ||
+    address.flags?.trusted?.value === true;
+export const offerableAsRecipient = (address) => {
+    if (address.flags?.blocked?.value === true)
+        return false;
+    if (address.flags?.junkOnly?.value !== true)
+        return true;
+    return accountHasCorresponded(address);
+};