@remit/web-client 0.0.324 → 0.0.326

package/dist/src/lib/self-update-state.js

@@ -0,0 +1,384 @@
+import { getErrorStatus } from "./error-classifier";
+/**
+ * The longest an apply can plausibly take — pull, snapshot, stop, start, gate —
+ * before a silent server is treated as gone rather than still working. A five
+ * minute margin is added on top before the client gives up entirely.
+ */
+export const APPLY_BUDGET_SECONDS = 600;
+export const NEVER_CAME_BACK_MARGIN_SECONDS = 300;
+/** Shown on the dead-connection screens, where no server-authored command exists. */
+export const FALLBACK_LOGS_COMMAND = "remit logs";
+const RELEASE_TAG_BASE = "https://github.com/remit-mail/reader/releases/tag/";
+export function checkAnswered(press, data) {
+    const lastCheckedAt = data?.check.lastCheckedAt;
+    return lastCheckedAt !== undefined && lastCheckedAt !== press.since;
+}
+/**
+ * Why the request the press fired never reached the seam. The status is named
+ * because a 500 here is a real fault on the box — the control volume unwritable
+ * is the one seen in the wild — and a press that quietly re-served the old
+ * verdict is exactly how #599 stayed invisible for an hour.
+ */
+export function checkRequestFailureReason(error) {
+    const status = getErrorStatus(error);
+    const cause = status === undefined
+        ? "the server did not answer"
+        : `the server answered ${status}`;
+    return `The check could not be requested — ${cause}. Run \`remit logs backend\` to see why.`;
+}
+const API_PHASE_TO_UI = {
+    checking: "preparing",
+    pulling: "preparing",
+    snapshotting: "preparing",
+    stopping: "restarting",
+    starting: "restarting",
+    verifying: "reconnecting",
+    committing: "reconnecting",
+    rollingBack: "reconnecting",
+    recovering: "reconnecting",
+};
+export function mapUpdatePhase(phase) {
+    return API_PHASE_TO_UI[phase] ?? "reconnecting";
+}
+/**
+ * The surface has no entry point for this caller: `404` (no manifest URL
+ * configured) or `401` (not authenticated). Both render nothing and stop the
+ * poll. `403` is treated the same way as defensive cover for any authenticated
+ * edge state, though the backend no longer distinguishes callers once the
+ * surface is on.
+ */
+export function isSurfaceAbsent(error) {
+    const status = getErrorStatus(error);
+    return status === 404 || status === 403 || status === 401;
+}
+/**
+ * The run the server last reported as still going, or null when it reported
+ * none. The last answer outlives the failed requests that follow it, which is
+ * what lets any tab — not only the one that pressed install — know it is inside
+ * a restart rather than looking at an unreachable service (#468). A run the user
+ * has dismissed is not one either surface still speaks for.
+ */
+export function runInFlight(data, dismissedRunId) {
+    const run = data?.run ?? null;
+    if (run === null || run.outcome !== null)
+        return null;
+    return run.runId === dismissedRunId ? null : run;
+}
+/**
+ * The available release from the check block, or undefined when the check
+ * reports none. Independent of what the pane is currently showing, so a retry
+ * offered from a failed run can still open consent.
+ */
+export function releaseFromCheck(data, now) {
+    const check = data?.check;
+    if (check?.status !== "ok")
+        return undefined;
+    if (!check.updateAvailable || !check.latestVersion)
+        return undefined;
+    return {
+        version: check.latestVersion,
+        releasedAt: parseIso(check.publishedAt) ?? now,
+        releaseNotesUrl: check.releaseNotesUrl ?? releaseNotesUrl(check.latestVersion),
+        summary: check.summary ?? "",
+    };
+}
+/**
+ * Whether installing the latest release runs a schema migration during the
+ * offline window. Derived in the client from the two versions the surface
+ * carries — the API deliberately ships the versions, never a computed boolean.
+ * Silent unless both are present and the release is on a higher schema.
+ */
+export function appliesSchemaMigration(data) {
+    const target = data?.check.schemaVersion;
+    const current = data?.currentSchemaVersion;
+    if (target === undefined || current === undefined)
+        return false;
+    return target > current;
+}
+function budgetLimitSeconds() {
+    return APPLY_BUDGET_SECONDS + NEVER_CAME_BACK_MARGIN_SECONDS;
+}
+function elapsedSince(startMillis, now) {
+    return Math.max(0, Math.floor((now - startMillis) / 1000));
+}
+function parseIso(value) {
+    if (!value)
+        return undefined;
+    const parsed = Date.parse(value);
+    return Number.isNaN(parsed) ? undefined : parsed;
+}
+function releaseNotesUrl(version) {
+    return `${RELEASE_TAG_BASE}${version}`;
+}
+function applyingSection(runId, version, target, phase, elapsedSeconds) {
+    return { status: "applying", runId, version, target, phase, elapsedSeconds };
+}
+function terminalSection(data, run, outcome) {
+    switch (outcome) {
+        case "succeeded":
+            return {
+                status: "succeeded",
+                runId: run.runId,
+                version: run.targetVersion,
+                previousVersion: run.fromVersion,
+                releaseNotesUrl: data.check.releaseNotesUrl ?? releaseNotesUrl(run.targetVersion),
+            };
+        case "rolledBack":
+            return {
+                status: "rolledBack",
+                runId: run.runId,
+                version: run.fromVersion,
+                attemptedVersion: run.targetVersion,
+                reason: run.message,
+                logsCommand: run.logCommand,
+            };
+        case "rollbackFailed":
+            return {
+                status: "rollbackFailed",
+                runId: run.runId,
+                attemptedVersion: run.targetVersion,
+                previousVersion: run.fromVersion,
+                reason: run.message,
+                logsCommand: run.logCommand,
+            };
+        case "abandoned":
+            return {
+                status: "abandoned",
+                runId: run.runId,
+                version: run.fromVersion,
+                attemptedVersion: run.targetVersion,
+                reason: run.message,
+                logsCommand: run.logCommand,
+            };
+        default: {
+            const exhaustive = outcome;
+            return exhaustive;
+        }
+    }
+}
+function checkSection(data, press, failure, now) {
+    const check = data.check;
+    const lastCheckedAt = parseIso(check.lastCheckedAt);
+    if (failure !== null) {
+        return {
+            status: "checkFailed",
+            version: data.currentVersion,
+            reason: failure,
+            lastCheckedAt,
+        };
+    }
+    // The press is recorded and the updater has not answered it: the pane waits on
+    // a genuinely newer `lastCheckedAt` rather than re-serving the verdict it
+    // already had (#599). The caller drops the press when the wait runs out, which
+    // arrives here as a failure.
+    if (press !== null && !checkAnswered(press, data)) {
+        return { status: "checking", version: data.currentVersion };
+    }
+    if (check.status === "failed") {
+        return {
+            status: "checkFailed",
+            version: data.currentVersion,
+            reason: check.error ?? "Remit could not reach the update service.",
+            lastCheckedAt,
+        };
+    }
+    // A configured surface that has not run its first check yet is never-checked,
+    // not checking: the updater runs the check on a cadence and has not written a
+    // result. A spinner here would run forever, since nothing on this poll is in
+    // flight. Only a press this page is still waiting on shows the spinner.
+    if (check.status === "disabled") {
+        return {
+            status: "neverChecked",
+            version: data.currentVersion,
+            lastCheckedAt,
+        };
+    }
+    const release = releaseFromCheck(data, now);
+    if (release) {
+        return { status: "available", version: data.currentVersion, release };
+    }
+    return {
+        status: "upToDate",
+        version: data.currentVersion,
+        checkedAt: parseIso(check.lastCheckedAt) ?? now,
+    };
+}
+function ready(section, overlay, releaseHeld) {
+    return { surface: { status: "ready", section, overlay }, releaseHeld };
+}
+/**
+ * The wait every tab is in while the server it is polling is not answering: the
+ * run is known to be in flight, and the phase is the only one the client can
+ * claim from a dead connection.
+ */
+function reconnectingSurface(runId, previousVersion, attemptedVersion, elapsedSeconds) {
+    return {
+        status: "ready",
+        section: applyingSection(runId, previousVersion, attemptedVersion, "reconnecting", elapsedSeconds),
+        overlay: {
+            kind: "applying",
+            target: attemptedVersion,
+            phase: "reconnecting",
+            elapsedSeconds,
+        },
+    };
+}
+/** The client gave up waiting, and says so without claiming the rollback ran. */
+function neverCameBackSurface(runId, previousVersion, attemptedVersion, elapsedSeconds, logsCommand) {
+    return {
+        status: "ready",
+        section: applyingSection(runId, previousVersion, attemptedVersion, "reconnecting", elapsedSeconds),
+        overlay: {
+            kind: "neverCameBack",
+            attemptedVersion,
+            previousVersion,
+            elapsedSeconds,
+            logsCommand,
+        },
+    };
+}
+/**
+ * The client gave up waiting. The hold stays: the screen has to sit still, and
+ * its retry has to keep polling, until the server answers for itself.
+ */
+function neverCameBack(held, elapsedSeconds) {
+    return {
+        surface: neverCameBackSurface(held.runId, held.previousVersion, held.attemptedVersion, elapsedSeconds, FALLBACK_LOGS_COMMAND),
+        releaseHeld: false,
+    };
+}
+/**
+ * A held run resolves to one of: still applying, gave up ("never came back"),
+ * unaccounted for, still waiting on a first answer, or — returning `null` —
+ * resolved terminally on the server, in which case the caller renders the
+ * outcome from the response.
+ */
+function deriveHeld(held, data, run, isError, now) {
+    const elapsedSeconds = elapsedSince(held.startedAt, now);
+    const currentVersion = data?.currentVersion ?? held.previousVersion;
+    const matched = !isError && run !== null && run.runId === held.runId;
+    if (matched && run !== null && run.outcome !== null)
+        return null;
+    if (matched && run !== null) {
+        const phase = mapUpdatePhase(run.phase);
+        return ready(applyingSection(run.runId, currentVersion, run.targetVersion, phase, elapsedSeconds), { kind: "applying", target: run.targetVersion, phase, elapsedSeconds }, false);
+    }
+    if (isError) {
+        if (elapsedSeconds > budgetLimitSeconds()) {
+            return neverCameBack(held, elapsedSeconds);
+        }
+        return {
+            surface: reconnectingSurface(held.runId, held.previousVersion, held.attemptedVersion, elapsedSeconds),
+            releaseHeld: false,
+        };
+    }
+    // Nothing has come back yet. Silence is not a phase, so the surface waits
+    // rather than describing an install it has heard nothing about.
+    if (data === undefined) {
+        return { surface: { status: "loading" }, releaseHeld: false };
+    }
+    // The server answered, but not with our run. If we have been gone longer than
+    // the budget, we cannot reconcile the silence — say so and point at the log.
+    if (elapsedSeconds > budgetLimitSeconds()) {
+        return {
+            surface: {
+                status: "ready",
+                section: {
+                    status: "unreachable",
+                    runId: held.runId,
+                    previousVersion: held.previousVersion,
+                    attemptedVersion: held.attemptedVersion,
+                    elapsedSeconds,
+                    logsCommand: run?.logCommand ?? FALLBACK_LOGS_COMMAND,
+                },
+                overlay: { kind: "none" },
+            },
+            releaseHeld: true,
+        };
+    }
+    // The updater picks the request up off a control file, so the seam keeps
+    // reporting the previous run for a moment. The phase stays the one the server
+    // gave when it accepted this run, until the server reports a newer one.
+    return ready(applyingSection(held.runId, currentVersion, held.attemptedVersion, held.phase, elapsedSeconds), {
+        kind: "applying",
+        target: held.attemptedVersion,
+        phase: held.phase,
+        elapsedSeconds,
+    }, false);
+}
+function displayFromData(input) {
+    const { data, isError, dismissedRunId, checkPress, checkFailure, sighting, now, } = input;
+    if (isError) {
+        const stopped = runInFlight(data, dismissedRunId);
+        // A tab that never pressed install is in the same restart as the one that
+        // did: the run the server last reported is still going, and the server
+        // stopping is how it goes. The wait runs from when this tab saw the run,
+        // never from the `startedAt` the box wrote — same budget, on a clock the
+        // tab owns. A run in flight this tab has no sighting of has only just
+        // arrived, so the wait starts here.
+        if (stopped !== null) {
+            const observedAt = sighting !== null && sighting.runId === stopped.runId
+                ? sighting.observedAt
+                : now;
+            const elapsedSeconds = elapsedSince(observedAt, now);
+            if (elapsedSeconds > budgetLimitSeconds()) {
+                return neverCameBackSurface(stopped.runId, stopped.fromVersion, stopped.targetVersion, elapsedSeconds, stopped.logCommand);
+            }
+            return reconnectingSurface(stopped.runId, stopped.fromVersion, stopped.targetVersion, elapsedSeconds);
+        }
+        return {
+            status: "ready",
+            section: {
+                status: "checkFailed",
+                version: data?.currentVersion ?? "the current version",
+                reason: "Remit could not reach the update service.",
+            },
+            overlay: { kind: "none" },
+        };
+    }
+    if (!data)
+        return { status: "loading" };
+    const run = data.run;
+    const dismissed = run !== null && dismissedRunId !== null && run.runId === dismissedRunId;
+    if (run !== null && !dismissed && run.outcome !== null) {
+        return {
+            status: "ready",
+            section: terminalSection(data, run, run.outcome),
+            overlay: { kind: "none" },
+        };
+    }
+    if (run !== null && !dismissed && run.outcome === null) {
+        const elapsedSeconds = elapsedSince(parseIso(run.startedAt) ?? now, now);
+        const phase = mapUpdatePhase(run.phase);
+        return {
+            status: "ready",
+            section: applyingSection(run.runId, run.fromVersion, run.targetVersion, phase, elapsedSeconds),
+            overlay: {
+                kind: "applying",
+                target: run.targetVersion,
+                phase,
+                elapsedSeconds,
+            },
+        };
+    }
+    return {
+        status: "ready",
+        section: checkSection(data, checkPress, checkFailure, now),
+        overlay: { kind: "none" },
+    };
+}
+export function deriveUpdateSurface(input) {
+    const { data, isError, error, held, now } = input;
+    const run = data?.run ?? null;
+    if (isSurfaceAbsent(error) && !held) {
+        return { surface: { status: "absent" }, releaseHeld: true };
+    }
+    if (held) {
+        const heldResult = deriveHeld(held, data, run, isError, now);
+        if (heldResult)
+            return heldResult;
+        // Our run resolved terminally — render it from the response and let go.
+        return { surface: displayFromData(input), releaseHeld: true };
+    }
+    return { surface: displayFromData(input), releaseHeld: false };
+}

package/dist/src/lib/sender-address.d.ts

@@ -0,0 +1,24 @@
+import type { RemitImapAddressResponse } from "@remit/api-http-client/types.gen.ts";
+/**
+ * `GET /addresses/search` matches the query as a substring of a display name, a
+ * local part, a domain or a whole address, and answers in relevance order. A
+ * query for one sender's address therefore returns several rows: everyone
+ * sharing that domain matches it too.
+ *
+ * Asking for a single row and taking `items[0]` is therefore wrong twice over:
+ * the row it returns may belong to a different sender, and the row we actually
+ * want may be past the cut. Fetch a small window instead and pick the exact
+ * address out of it.
+ */
+export declare const SENDER_ADDRESS_SEARCH_LIMIT = 10;
+/** Query params for the sender-address lookup. One shape, used by every caller. */
+export declare const senderAddressSearchQuery: (senderEmail: string | undefined) => {
+    q: string;
+    limit: number;
+};
+/**
+ * Select the address row for exactly this sender. Another sender under the same
+ * domain is not this sender, so it resolves to `undefined` rather than the wrong
+ * address — silently flagging the wrong sender is worse than not resolving.
+ */
+export declare const pickSenderAddress: (items: RemitImapAddressResponse[] | undefined, senderEmail: string | undefined) => RemitImapAddressResponse | undefined;

package/dist/src/lib/sender-address.js

@@ -0,0 +1,28 @@
+/**
+ * `GET /addresses/search` matches the query as a substring of a display name, a
+ * local part, a domain or a whole address, and answers in relevance order. A
+ * query for one sender's address therefore returns several rows: everyone
+ * sharing that domain matches it too.
+ *
+ * Asking for a single row and taking `items[0]` is therefore wrong twice over:
+ * the row it returns may belong to a different sender, and the row we actually
+ * want may be past the cut. Fetch a small window instead and pick the exact
+ * address out of it.
+ */
+export const SENDER_ADDRESS_SEARCH_LIMIT = 10;
+/** Query params for the sender-address lookup. One shape, used by every caller. */
+export const senderAddressSearchQuery = (senderEmail) => ({
+    q: senderEmail?.toLowerCase() ?? "",
+    limit: SENDER_ADDRESS_SEARCH_LIMIT,
+});
+/**
+ * Select the address row for exactly this sender. Another sender under the same
+ * domain is not this sender, so it resolves to `undefined` rather than the wrong
+ * address — silently flagging the wrong sender is worse than not resolving.
+ */
+export const pickSenderAddress = (items, senderEmail) => {
+    if (!senderEmail)
+        return undefined;
+    const normalized = senderEmail.toLowerCase();
+    return items?.find((item) => item.normalizedEmail === normalized);
+};

package/dist/src/lib/session-storage.d.ts

@@ -0,0 +1 @@
+export declare const sessionStore: () => Storage | null;

package/dist/src/lib/session-storage.js

@@ -0,0 +1,8 @@
+export const sessionStore = () => {
+    try {
+        return globalThis.sessionStorage ?? null;
+    }
+    catch {
+        return null;
+    }
+};

package/dist/src/lib/spam-offer.d.ts

@@ -0,0 +1,69 @@
+/**
+ * The Spam offer: how much of a search sits in Spam, and where taking the offer
+ * lands.
+ *
+ * Both answers come from one server count per junk folder the search reached
+ * (`useSpamMatchCounts`). The number is their sum, because a search spans every
+ * account and every account has its own Spam folder — "N in Spam" that named
+ * one folder's share would be smaller than the mail the phrase describes.
+ *
+ * The destination is a single folder even so: scoping is a route and a route
+ * names one mailbox. It is the folder holding the most matches, which is the
+ * best a single click can do, and `SpamResultsOffer` says where the button goes
+ * rather than promising to show every match. Where no count ranks the folders —
+ * a short query, a residual token, a failed request — the page's own junk rows
+ * do, because they are the only evidence left of where the mail is.
+ *
+ * This used to group the search results the header held and count each group.
+ * That array is a page, so the figure was a count of the loaded window offered
+ * as a count of a mailbox: a Spam match below the page was missing from it, and
+ * the number climbed as further pages loaded (#313).
+ *
+ * A folder whose count did not arrive makes the total `unknown`. Summing the
+ * ones that did would state a figure that is exact in form and short in fact,
+ * and nothing distinguishes it from a true one on screen.
+ */
+import type { ResultCount } from "@remit/ui";
+export interface SpamMailboxCount {
+    mailboxId: string;
+    count: ResultCount;
+    /**
+     * The count request failed. Distinct from `unknown`, which also covers a
+     * request still in flight or one nobody made: a failure is a folder that
+     * could not answer, and it must never read as a folder holding nothing.
+     */
+    failed: boolean;
+}
+export interface SpamOffer {
+    /** The junk folder "Go to Spam" scopes the search to. */
+    mailboxId: string;
+    /** Matches across every junk folder, or `unknown` if any went uncounted. */
+    count: ResultCount;
+}
+export interface SpamOfferEvidence {
+    /**
+     * Junk rows the loaded page held, per junk folder.
+     *
+     * Never the number the offer states — a page is a page. It is what says
+     * spam was reached at all while the counts are absent, and, crucially, WHICH
+     * folder the reader is being sent to: with no count to rank the folders by,
+     * the rows on screen are the only evidence of where the mail is, and a
+     * "Go to Spam" that lands on the wrong account's folder shows "No matches"
+     * over mail this very page is holding out.
+     */
+    pageRowsByMailbox: ReadonlyMap<string, number>;
+}
+/**
+ * The offer these per-folder counts support, or none.
+ *
+ * None when every junk folder answered and they sum to zero with no junk row on
+ * the page either — the search reaches no spam. Anything else is an offer: rows
+ * held out of the list are always offered a way back, because hiding mail
+ * without one is worse than hiding a number.
+ *
+ * The figure is the sum, and only when every folder answered. One folder
+ * missing takes it off, because summing the folders that replied states a
+ * number exact in form and short in fact. A sum of zero over a page that is
+ * holding junk rows takes it off too: the two disagree, so neither is stated.
+ */
+export declare function spamOfferFromCounts(counts: readonly SpamMailboxCount[], { pageRowsByMailbox }: SpamOfferEvidence): SpamOffer | undefined;

package/dist/src/lib/spam-offer.js

@@ -0,0 +1,90 @@
+/**
+ * How good a destination a folder is, before ties are broken.
+ *
+ * A counted match is the best evidence; junk rows on the page are the next
+ * best, and they outrank the folder's own count because the rows are on screen
+ * while the count may be half a minute old. A folder that answered zero and
+ * shows no row ranks LAST — it is the only one known to hold nothing, so
+ * sending the reader there is the one choice guaranteed to show an empty list.
+ */
+const tier = (candidate) => {
+    if (candidate.count.kind === "exact" && candidate.count.value > 0)
+        return 3;
+    if (candidate.pageRows > 0)
+        return 2;
+    return candidate.count.kind === "unknown" ? 1 : 0;
+};
+const exactValue = (candidate) => candidate.count.kind === "exact" ? candidate.count.value : 0;
+/** Strict, so equal candidates leave the earlier one standing. */
+const isBetterDestination = (candidate, standing) => {
+    if (tier(candidate) !== tier(standing)) {
+        return tier(candidate) > tier(standing);
+    }
+    if (exactValue(candidate) !== exactValue(standing)) {
+        return exactValue(candidate) > exactValue(standing);
+    }
+    return candidate.pageRows > standing.pageRows;
+};
+/**
+ * The offer these per-folder counts support, or none.
+ *
+ * None when every junk folder answered and they sum to zero with no junk row on
+ * the page either — the search reaches no spam. Anything else is an offer: rows
+ * held out of the list are always offered a way back, because hiding mail
+ * without one is worse than hiding a number.
+ *
+ * The figure is the sum, and only when every folder answered. One folder
+ * missing takes it off, because summing the folders that replied states a
+ * number exact in form and short in fact. A sum of zero over a page that is
+ * holding junk rows takes it off too: the two disagree, so neither is stated.
+ */
+export function spamOfferFromCounts(counts, { pageRowsByMailbox }) {
+    const candidates = counts.map((entry) => ({
+        ...entry,
+        pageRows: pageRowsByMailbox.get(entry.mailboxId) ?? 0,
+    }));
+    // A folder the page names but the counts do not — the mailbox lists are still
+    // loading, or the folder arrived after the requests went out. Its rows are
+    // already being held out of the list, so it has to be reachable.
+    for (const [mailboxId, pageRows] of pageRowsByMailbox) {
+        if (pageRows <= 0)
+            continue;
+        if (candidates.some((entry) => entry.mailboxId === mailboxId))
+            continue;
+        candidates.push({
+            mailboxId,
+            count: { kind: "unknown" },
+            failed: false,
+            pageRows,
+        });
+    }
+    const first = candidates[0];
+    if (!first)
+        return undefined;
+    let total = 0;
+    let everyFolderAnswered = true;
+    let best = first;
+    for (const candidate of candidates) {
+        if (candidate.count.kind === "unknown")
+            everyFolderAnswered = false;
+        else
+            total += candidate.count.value;
+        if (isBetterDestination(candidate, best))
+            best = candidate;
+    }
+    const pageHeldSpam = candidates.some((candidate) => candidate.pageRows > 0);
+    const anyFailed = candidates.some((candidate) => candidate.failed);
+    if (total === 0 && !pageHeldSpam && (everyFolderAnswered || !anyFailed)) {
+        return undefined;
+    }
+    // The count and the page disagree: an exact zero under rows the list is
+    // holding out. The rows are on screen and the count is up to half a minute
+    // old, so the offer stands and states nothing.
+    const contradicted = everyFolderAnswered && total === 0 && pageHeldSpam;
+    return {
+        mailboxId: best.mailboxId,
+        count: everyFolderAnswered && !contradicted
+            ? { kind: "exact", value: total }
+            : { kind: "unknown" },
+    };
+}

package/dist/src/lib/stale-build.d.ts

@@ -0,0 +1,10 @@
+export declare const STALE_BUILD_RELOAD_KEY_PREFIX = "remit.stale-build-reload:";
+type ReloadGuard = Pick<Storage, "getItem" | "setItem">;
+export interface StaleBuildPorts {
+    reload: () => void;
+    guard: ReloadGuard | null;
+    commit: string;
+}
+export declare const reloadOnceForChunkFailure: ({ reload, guard, commit, }: StaleBuildPorts) => boolean;
+export declare const installStaleBuildReload: () => void;
+export {};

package/dist/src/lib/stale-build.js

@@ -0,0 +1,24 @@
+import { APP_SHA } from "./app-info";
+import { sessionStore } from "./session-storage";
+export const STALE_BUILD_RELOAD_KEY_PREFIX = "remit.stale-build-reload:";
+export const reloadOnceForChunkFailure = ({ reload, guard, commit, }) => {
+    if (guard === null)
+        return false;
+    const key = `${STALE_BUILD_RELOAD_KEY_PREFIX}${commit}`;
+    if (guard.getItem(key) !== null)
+        return false;
+    guard.setItem(key, String(Date.now()));
+    reload();
+    return true;
+};
+export const installStaleBuildReload = () => {
+    window.addEventListener("vite:preloadError", (event) => {
+        const reloaded = reloadOnceForChunkFailure({
+            reload: () => window.location.reload(),
+            guard: sessionStore(),
+            commit: APP_SHA,
+        });
+        if (reloaded)
+            event.preventDefault();
+    });
+};

package/dist/src/lib/starred-rows.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Collapse rows that are the same conversation.
+ *
+ * A message's identity includes its mailbox, so the same mail filed in two
+ * folders is two rows carrying the same server-side star. The starred scope
+ * already excludes the folder that causes this wholesale (Gmail's All Mail),
+ * but an ordinary copy in a user folder still produces a pair.
+ *
+ * Deduping over the accumulated pages rather than inside one keeps a
+ * conversation single even when its copies straddle a page boundary — a single
+ * page cannot know what earlier pages already showed. The first row wins: the
+ * newest under a plain listing, and under a search the one the server ranked
+ * highest, so a sender's own older message beats a newer reply that mentions
+ * them.
+ *
+ * Generic over anything naming its thread, so the same collapse runs over the
+ * API rows and over the merged display rows a text search produces — two
+ * definitions of "same conversation" is one too many. A row that names no
+ * thread is never merged: there is nothing to say it is the same conversation
+ * as any other.
+ */
+export declare const dedupeByThread: <T extends {
+    threadId?: string;
+}>(items: T[]) => T[];