@remit/web-client 0.0.325 → 0.0.326

package/dist/src/routes/settings.js

@@ -0,0 +1,64 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createFileRoute, Outlet } from "@tanstack/react-router";
+import { CalendarDays, Filter, FolderTree, Inbox, Palette, Tag, Users, } from "lucide-react";
+import { AdvancedNavIcon } from "../components/settings/AdvancedNavIcon";
+import { WarningsNavIcon } from "../components/settings/WarningsNavIcon";
+/* ------------------------------------------------------------------ */
+/* Nav items — single source of truth shared by all settings pages    */
+/* ------------------------------------------------------------------ */
+export const SETTINGS_NAV_ITEMS = [
+    { id: "accounts", label: "Accounts", icon: _jsx(Inbox, { className: "size-4" }) },
+    {
+        id: "senders",
+        label: "Senders & Rules",
+        icon: _jsx(Users, { className: "size-4" }),
+    },
+    {
+        id: "folders",
+        label: "Folder roles",
+        icon: _jsx(FolderTree, { className: "size-4" }),
+    },
+    {
+        id: "filters",
+        label: "Filters",
+        icon: _jsx(Filter, { className: "size-4" }),
+    },
+    {
+        id: "labels",
+        label: "Labels",
+        icon: _jsx(Tag, { className: "size-4" }),
+    },
+    {
+        id: "calendars",
+        label: "Calendars",
+        icon: _jsx(CalendarDays, { className: "size-4" }),
+    },
+    {
+        id: "appearance",
+        label: "Appearance",
+        icon: _jsx(Palette, { className: "size-4" }),
+    },
+    {
+        id: "warnings",
+        label: "Warnings",
+        icon: _jsx(WarningsNavIcon, {}),
+    },
+    { id: "advanced", label: "Advanced", icon: _jsx(AdvancedNavIcon, {}) },
+];
+export const SETTINGS_ID_TO_PATH = {
+    accounts: "/settings/accounts",
+    senders: "/settings/senders",
+    folders: "/settings/folders",
+    filters: "/settings/filters",
+    labels: "/settings/labels",
+    calendars: "/settings/calendars",
+    appearance: "/settings/appearance",
+    warnings: "/settings/warnings",
+    advanced: "/settings/advanced",
+};
+/* ------------------------------------------------------------------ */
+/* Route — pass-through                                               */
+/* ------------------------------------------------------------------ */
+export const Route = createFileRoute("/settings")({
+    component: () => _jsx(Outlet, {}),
+});

package/dist/src/routing/browsed-list.d.ts

@@ -0,0 +1,28 @@
+import { type BrowsedList } from "../lib/mail-route";
+export type { BrowsedList };
+/**
+ * The list the address is browsing, as the two values a navigation to it needs.
+ *
+ * Every surface a list can open — compose, a reply, a conversation — reads the
+ * same answer, so the four lists cannot disagree about which one is underneath.
+ *
+ * The same object until the address moves, so a caller can memoize on it.
+ */
+export declare function useBrowsedList(): BrowsedList;
+/**
+ * Whether the address names something the list has open below it — a
+ * conversation, a draft, the compose surface.
+ *
+ * Answers off the pathname, which is what says where the reader is going while
+ * the destination mounts; see `locationOpensDetail`.
+ */
+export declare function useOpensDetail(): boolean;
+/**
+ * Back up to the list, leaving whatever it had open.
+ *
+ * A push, like the open was: leaving is a move the reader makes, and Back is how
+ * they undo it. Every branch lands somewhere real — the brief is the fallback,
+ * because a list this cannot name still has to put them on one rather than
+ * strand them inside a surface they just dismissed.
+ */
+export declare function useNavigateToBrowsedList(): () => void;

package/dist/src/routing/browsed-list.js

@@ -0,0 +1,61 @@
+import { useLocation, useNavigate, useParams, useRouterState, } from "@tanstack/react-router";
+import { useCallback, useMemo } from "react";
+import { locationOpensDetail, mailListRoute, } from "../lib/mail-route";
+import { useRetainOpenPanels } from "./fragment";
+/**
+ * The list the address is browsing, as the two values a navigation to it needs.
+ *
+ * Every surface a list can open — compose, a reply, a conversation — reads the
+ * same answer, so the four lists cannot disagree about which one is underneath.
+ *
+ * The same object until the address moves, so a caller can memoize on it.
+ */
+export function useBrowsedList() {
+    const list = useRouterState({
+        select: (state) => mailListRoute(state.matches)?.list,
+    });
+    const mailbox = useParams({ from: "/mail/$mailboxId", shouldThrow: false });
+    const mailboxId = mailbox?.mailboxId;
+    return useMemo(() => ({ list, mailboxId }), [list, mailboxId]);
+}
+/**
+ * Whether the address names something the list has open below it — a
+ * conversation, a draft, the compose surface.
+ *
+ * Answers off the pathname, which is what says where the reader is going while
+ * the destination mounts; see `locationOpensDetail`.
+ */
+export function useOpensDetail() {
+    const { pathname } = useLocation();
+    return locationOpensDetail(pathname);
+}
+/**
+ * Back up to the list, leaving whatever it had open.
+ *
+ * A push, like the open was: leaving is a move the reader makes, and Back is how
+ * they undo it. Every branch lands somewhere real — the brief is the fallback,
+ * because a list this cannot name still has to put them on one rather than
+ * strand them inside a surface they just dismissed.
+ */
+export function useNavigateToBrowsedList() {
+    const navigate = useNavigate();
+    const retainPanels = useRetainOpenPanels();
+    const { list, mailboxId } = useBrowsedList();
+    return useCallback(() => {
+        const search = (prev) => prev;
+        const hash = retainPanels;
+        if (list === "flagged") {
+            navigate({ to: "/mail/flagged", search, hash });
+            return;
+        }
+        if (list === "outbox") {
+            navigate({ to: "/mail/outbox", search, hash });
+            return;
+        }
+        if (list === "mailbox" && mailboxId) {
+            navigate({ to: "/mail/$mailboxId", params: { mailboxId }, search, hash });
+            return;
+        }
+        navigate({ to: "/mail/brief", search, hash });
+    }, [navigate, retainPanels, list, mailboxId]);
+}

package/dist/src/routing/calendar.d.ts

@@ -0,0 +1,69 @@
+import type { CalendarViewId } from "@remit/ui";
+/** Which zoom the calendar is at, on which day, over which calendars. */
+export interface CalendarAddress {
+    view: CalendarViewId;
+    /** `YYYY-MM-DD`. */
+    date: string;
+    /** The calendars ticked in the query; empty means every one of them. */
+    calendarIds: readonly string[];
+}
+/**
+ * The calendar the address names.
+ *
+ * The route canonicalises its own segments before anything mounts, so what
+ * arrives here is always a view the ladder has and a day the calendar has —
+ * the fallbacks below only cover the frame before the router has resolved
+ * the params.
+ */
+export declare function useCalendarAddress(): CalendarAddress;
+/** The event the reading pane has open, and the instance of it, if any. */
+export interface OpenCalendarEvent {
+    calendarObjectId: string;
+    /** One instance of a series; absent on the series itself. */
+    recurrenceId: string | undefined;
+}
+export declare function useOpenCalendarEvent(): OpenCalendarEvent | undefined;
+/** Whether the composer is up, which is a route rather than a flag. */
+export declare function useChangingSuggestionId(): string | undefined;
+export declare function useIsWritingEvent(): boolean;
+export interface CalendarNavigation {
+    /** Change zoom, keeping the day on screen. */
+    goToView: (view: CalendarViewId) => void;
+    /** The previous or next screenful, measured in the view's own unit. */
+    step: (direction: -1 | 1) => void;
+    /** Home, from every view and every distance away. */
+    goToToday: () => void;
+    /**
+     * The day the strip has scrolled to, written by `replace`. Scrolling is not
+     * somewhere the reader went — Back belongs to the screen they arrived from,
+     * not to every row they passed on the way down.
+     */
+    setAnchorDate: (date: string) => void;
+    /** Out of the list and into the grid for one day. */
+    zoomToDay: (date: string) => void;
+    dayHref: (date: string) => string;
+    /**
+     * One occurrence names the series it belongs to and the instance under it;
+     * a resource that does not recur names only itself.
+     */
+    openEvent: (calendarObjectId: string, recurrenceId?: string) => void;
+    closeEvent: () => void;
+    openComposer: () => void;
+    changeSuggestionFirst: (suggestionId: string, date: string) => void;
+}
+/**
+ * Every move the calendar makes, as an address.
+ *
+ * Prev, next, today and the zoom switch are navigations rather than state
+ * changes, so the address always names what is on screen and a link to it
+ * reopens exactly that. Each one carries the open panes across the way the nav
+ * does, so the reader keeps their chrome moving through the week.
+ */
+export declare function useCalendarNavigation(): CalendarNavigation;
+/**
+ * Leave the mail for one event on the calendar, on the day it falls, so the
+ * reader lands where the grid already shows what is around it. The panes are
+ * not carried: the calendar is a different surface, as the nav treats it.
+ */
+export declare function useOpenEventOnCalendar(): (date: string, calendarObjectId: string, recurrenceId: string) => void;
+export declare function useChangeSuggestionOnCalendar(): (date: string, suggestionId: string) => void;

package/dist/src/routing/calendar.js

@@ -0,0 +1,152 @@
+import { useNavigate, useParams, useRouter, useSearch, } from "@tanstack/react-router";
+import { useCallback, useMemo } from "react";
+import { canonicalCalendarParams, isoDate, stepCalendarDate, } from "../lib/calendar-route";
+import { useRetainOpenPanels } from "./fragment";
+const VIEW_ROUTE = "/calendar/$view/$date";
+const SUGGESTION_ROUTE = "/calendar/$view/$date/suggestion/$suggestionId";
+/**
+ * The calendar the address names.
+ *
+ * The route canonicalises its own segments before anything mounts, so what
+ * arrives here is always a view the ladder has and a day the calendar has —
+ * the fallbacks below only cover the frame before the router has resolved
+ * the params.
+ */
+export function useCalendarAddress() {
+    const params = useParams({ from: VIEW_ROUTE, shouldThrow: false });
+    const search = useSearch({ from: VIEW_ROUTE, shouldThrow: false });
+    const view = params?.view ?? "";
+    const date = params?.date ?? "";
+    const calendarIds = search?.calendarId;
+    return useMemo(() => {
+        const canonical = canonicalCalendarParams({ view, date }, isoDate(new Date()));
+        return { ...canonical, calendarIds: calendarIds ?? [] };
+    }, [view, date, calendarIds]);
+}
+export function useOpenCalendarEvent() {
+    const event = useParams({
+        from: "/calendar/$view/$date/$calendarObjectId",
+        shouldThrow: false,
+    });
+    const instance = useParams({
+        from: "/calendar/$view/$date/$calendarObjectId/$recurrenceId",
+        shouldThrow: false,
+    });
+    const calendarObjectId = event?.calendarObjectId;
+    const recurrenceId = instance?.recurrenceId;
+    return useMemo(() => (calendarObjectId ? { calendarObjectId, recurrenceId } : undefined), [calendarObjectId, recurrenceId]);
+}
+/** Whether the composer is up, which is a route rather than a flag. */
+export function useChangingSuggestionId() {
+    return useParams({ from: SUGGESTION_ROUTE, shouldThrow: false })
+        ?.suggestionId;
+}
+export function useIsWritingEvent() {
+    const composer = useParams({
+        from: "/calendar/$view/$date/new",
+        shouldThrow: false,
+    });
+    const changing = useParams({
+        from: SUGGESTION_ROUTE,
+        shouldThrow: false,
+    });
+    return composer !== undefined || changing !== undefined;
+}
+/**
+ * Every move the calendar makes, as an address.
+ *
+ * Prev, next, today and the zoom switch are navigations rather than state
+ * changes, so the address always names what is on screen and a link to it
+ * reopens exactly that. Each one carries the open panes across the way the nav
+ * does, so the reader keeps their chrome moving through the week.
+ */
+export function useCalendarNavigation() {
+    const navigate = useNavigate();
+    const router = useRouter();
+    const retainPanels = useRetainOpenPanels();
+    const { view, date } = useCalendarAddress();
+    const goTo = useCallback((params) => {
+        navigate({
+            to: VIEW_ROUTE,
+            params,
+            search: true,
+            hash: retainPanels,
+        });
+    }, [navigate, retainPanels]);
+    const dayHref = useCallback((next) => router.buildLocation({
+        to: VIEW_ROUTE,
+        params: { view: "day", date: next },
+        search: true,
+        hash: retainPanels,
+    }).href, [router, retainPanels]);
+    return useMemo(() => ({
+        goToView: (next) => goTo({ view: next, date }),
+        step: (direction) => goTo({ view, date: stepCalendarDate(date, view, direction) }),
+        goToToday: () => goTo({ view, date: isoDate(new Date()) }),
+        setAnchorDate: (next) => navigate({
+            to: VIEW_ROUTE,
+            params: { view, date: next },
+            search: true,
+            hash: retainPanels,
+            replace: true,
+        }),
+        zoomToDay: (next) => navigate({ href: dayHref(next) }),
+        dayHref,
+        openEvent: (calendarObjectId, recurrenceId) => recurrenceId === undefined || recurrenceId === ""
+            ? navigate({
+                to: "/calendar/$view/$date/$calendarObjectId",
+                params: { view, date, calendarObjectId },
+                search: true,
+                hash: retainPanels,
+            })
+            : navigate({
+                to: "/calendar/$view/$date/$calendarObjectId/$recurrenceId",
+                params: { view, date, calendarObjectId, recurrenceId },
+                search: true,
+                hash: retainPanels,
+            }),
+        closeEvent: () => goTo({ view, date }),
+        openComposer: () => navigate({
+            to: "/calendar/$view/$date/new",
+            params: { view, date },
+            search: true,
+            hash: retainPanels,
+        }),
+        changeSuggestionFirst: (suggestionId, on) => navigate({
+            to: SUGGESTION_ROUTE,
+            params: { view, date: on, suggestionId },
+            search: true,
+            hash: retainPanels,
+        }),
+    }), [goTo, navigate, dayHref, retainPanels, view, date]);
+}
+/**
+ * Leave the mail for one event on the calendar, on the day it falls, so the
+ * reader lands where the grid already shows what is around it. The panes are
+ * not carried: the calendar is a different surface, as the nav treats it.
+ */
+export function useOpenEventOnCalendar() {
+    const navigate = useNavigate();
+    return useCallback((date, calendarObjectId, recurrenceId) => {
+        if (recurrenceId === "") {
+            navigate({
+                to: "/calendar/$view/$date/$calendarObjectId",
+                params: { view: "day", date, calendarObjectId },
+            });
+            return;
+        }
+        navigate({
+            to: "/calendar/$view/$date/$calendarObjectId/$recurrenceId",
+            params: { view: "day", date, calendarObjectId, recurrenceId },
+        });
+    }, [navigate]);
+}
+export function useChangeSuggestionOnCalendar() {
+    const navigate = useNavigate();
+    return useCallback((date, suggestionId) => {
+        navigate({
+            to: SUGGESTION_ROUTE,
+            params: { view: "day", date, suggestionId },
+        });
+    }, [navigate]);
+}

package/dist/src/routing/compose.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Whether the compose surface is showing.
+ *
+ * Compose is a child route of the list it was started from, so "is compose
+ * showing" is a question about the path rather than a flag somebody else has to
+ * keep in step with it.
+ */
+export declare function useIsComposing(): boolean;
+/**
+ * The draft the open composer is writing to, or `undefined` while it is still a
+ * message with nothing saved behind it.
+ *
+ * One owner: the address. A copy in React state disagrees with it the first
+ * time the reader presses Back, and the composer comes back empty over a draft
+ * row that is still listed.
+ */
+export declare function useComposeDraftId(): string | undefined;
+/**
+ * Start a new message.
+ *
+ * Takes nothing, because it is wired straight to buttons and key handlers: an
+ * optional draft argument here would quietly receive a click event instead.
+ * Resuming a draft is `useEditDraft`, which says so.
+ *
+ * A push, so Back leaves the surface and returns whatever it was opened over,
+ * and the query travels with it — a compose started mid-search is still inside
+ * that search.
+ */
+export declare function useOpenCompose(): () => void;
+/** Resume a draft: the same surface, addressed at what it is editing. */
+export declare function useEditDraft(): (outboxMessageId: string) => void;
+/**
+ * Record the draft the composer just created, in the address.
+ *
+ * A replace, and every panel left alone: the reader started one message, so the
+ * draft arriving under it is neither another step of history nor a move away
+ * from whatever they have open over the composer.
+ */
+export declare function useAdoptComposeDraft(): (outboxMessageId: string) => void;
+/**
+ * Close compose, landing back on the list it was opened from.
+ *
+ * A push, like opening it: closing a surface moves the reader on, and Back is
+ * how they undo that. Replacing the entry instead makes the press after a close
+ * do nothing at all, because the entry behind it is the list they are already
+ * looking at.
+ *
+ * Every branch leaves, the brief included. Leaving is what the reader asked
+ * for, so a case this cannot name has to put them somewhere real rather than
+ * return and strand them inside a surface they just dismissed.
+ */
+export declare function useCloseCompose(): () => void;

package/dist/src/routing/compose.js

@@ -0,0 +1,139 @@
+import { useNavigate, useParams } from "@tanstack/react-router";
+import { useCallback } from "react";
+import { withoutComposeSeed } from "../lib/mail-search";
+import { useBrowsedList, useNavigateToBrowsedList } from "./browsed-list";
+import { useRetainOpenPanels } from "./fragment";
+/**
+ * The compose route under each list. The draft is an optional segment of the
+ * same route rather than a child of it, so adopting the id the first autosave
+ * creates rewrites the address without unmounting the composer.
+ */
+const BRIEF_COMPOSE = "/mail/brief/compose/{-$outboxMessageId}";
+const FLAGGED_COMPOSE = "/mail/flagged/compose/{-$outboxMessageId}";
+const OUTBOX_COMPOSE = "/mail/outbox/compose/{-$outboxMessageId}";
+const MAILBOX_COMPOSE = "/mail/$mailboxId/compose/{-$outboxMessageId}";
+/**
+ * The compose match, if the address has one. Each `from` names a real route, so
+ * a segment that does not exist fails to compile.
+ *
+ * A path matches one list at a time, so at most one of these answers.
+ */
+function useComposeParams() {
+    const brief = useParams({ from: BRIEF_COMPOSE, shouldThrow: false });
+    const flagged = useParams({ from: FLAGGED_COMPOSE, shouldThrow: false });
+    const outbox = useParams({ from: OUTBOX_COMPOSE, shouldThrow: false });
+    const mailbox = useParams({ from: MAILBOX_COMPOSE, shouldThrow: false });
+    return brief ?? flagged ?? outbox ?? mailbox;
+}
+/**
+ * Whether the compose surface is showing.
+ *
+ * Compose is a child route of the list it was started from, so "is compose
+ * showing" is a question about the path rather than a flag somebody else has to
+ * keep in step with it.
+ */
+export function useIsComposing() {
+    return useComposeParams() !== undefined;
+}
+/**
+ * The draft the open composer is writing to, or `undefined` while it is still a
+ * message with nothing saved behind it.
+ *
+ * One owner: the address. A copy in React state disagrees with it the first
+ * time the reader presses Back, and the composer comes back empty over a draft
+ * row that is still listed.
+ */
+export function useComposeDraftId() {
+    return useComposeParams()?.outboxMessageId;
+}
+/**
+ * Where compose opens: the list being browsed, or the brief.
+ *
+ * Every case lands on a composer. The brief is the fallback rather than a
+ * refusal because it always exists and always mounts the surface, so the two
+ * addresses that name no folder — `/mail` on its way to the brief, and a folder
+ * route in the frame before its id resolves — open a composer instead of
+ * explaining why they cannot. A press that reports rather than writes is the
+ * dead button this change deletes, and neither case has anything to report:
+ * a message needs no folder to be written in.
+ */
+function composeTarget(list, mailboxId, outboxMessageId) {
+    if (list === "flagged")
+        return { to: FLAGGED_COMPOSE, params: { outboxMessageId } };
+    if (list === "outbox")
+        return { to: OUTBOX_COMPOSE, params: { outboxMessageId } };
+    if (list === "mailbox" && mailboxId)
+        return { to: MAILBOX_COMPOSE, params: { mailboxId, outboxMessageId } };
+    return { to: BRIEF_COMPOSE, params: { outboxMessageId } };
+}
+/**
+ * Navigate to compose on the list being browsed, on the draft named or on none.
+ *
+ * The draft travels as an argument rather than being set somewhere first: an
+ * opener that had to do both could do only one, and the composer would come up
+ * on whatever the last one left behind.
+ */
+function useComposeNavigate() {
+    const navigate = useNavigate();
+    const retainPanels = useRetainOpenPanels();
+    const { list, mailboxId } = useBrowsedList();
+    return useCallback((outboxMessageId, options) => {
+        navigate({
+            ...composeTarget(list, mailboxId, outboxMessageId),
+            search: withoutComposeSeed,
+            // Opening or closing the surface is going somewhere, so the panes the
+            // reader keeps up travel and the overlays they were reading over do
+            // not. Recording the draft is not going anywhere — the address is
+            // rewritten under a composer they are still typing in — so whatever is
+            // up stays up, sheet included.
+            hash: options?.keepPanels ? true : retainPanels,
+            replace: options?.replace ?? false,
+        });
+    }, [navigate, retainPanels, list, mailboxId]);
+}
+/**
+ * Start a new message.
+ *
+ * Takes nothing, because it is wired straight to buttons and key handlers: an
+ * optional draft argument here would quietly receive a click event instead.
+ * Resuming a draft is `useEditDraft`, which says so.
+ *
+ * A push, so Back leaves the surface and returns whatever it was opened over,
+ * and the query travels with it — a compose started mid-search is still inside
+ * that search.
+ */
+export function useOpenCompose() {
+    const openCompose = useComposeNavigate();
+    return useCallback(() => openCompose(undefined), [openCompose]);
+}
+/** Resume a draft: the same surface, addressed at what it is editing. */
+export function useEditDraft() {
+    const openCompose = useComposeNavigate();
+    return useCallback((outboxMessageId) => openCompose(outboxMessageId), [openCompose]);
+}
+/**
+ * Record the draft the composer just created, in the address.
+ *
+ * A replace, and every panel left alone: the reader started one message, so the
+ * draft arriving under it is neither another step of history nor a move away
+ * from whatever they have open over the composer.
+ */
+export function useAdoptComposeDraft() {
+    const openCompose = useComposeNavigate();
+    return useCallback((outboxMessageId) => openCompose(outboxMessageId, { replace: true, keepPanels: true }), [openCompose]);
+}
+/**
+ * Close compose, landing back on the list it was opened from.
+ *
+ * A push, like opening it: closing a surface moves the reader on, and Back is
+ * how they undo that. Replacing the entry instead makes the press after a close
+ * do nothing at all, because the entry behind it is the list they are already
+ * looking at.
+ *
+ * Every branch leaves, the brief included. Leaving is what the reader asked
+ * for, so a case this cannot name has to put them somewhere real rather than
+ * return and strand them inside a surface they just dismissed.
+ */
+export function useCloseCompose() {
+    return useNavigateToBrowsedList();
+}

package/dist/src/routing/fragment.d.ts

@@ -0,0 +1,64 @@
+/**
+ * The fragment tier carries panel visibility and nothing else — no identity, no
+ * payload, no selection. A panel qualifies only when its own copy is
+ * independent of in-memory data, so a cold load of the URL reproduces it
+ * exactly.
+ */
+export declare const panelFragments: readonly ["intelligence", "nav", "shortcuts"];
+export type PanelFragment = (typeof panelFragments)[number];
+/**
+ * The panels that cover the view rather than sit in it. The rail is a pane in
+ * the shell's row and the other two are modal over it, so a sheet opening can
+ * never take the rail down with it — the address holds the pane and the overlay
+ * at once. Two overlays cannot be up together, because the second one hides the
+ * first.
+ */
+export declare const overlayPanels: readonly ["nav", "shortcuts"];
+export type OverlayPanel = (typeof overlayPanels)[number];
+export declare const isOverlayPanel: (panel: PanelFragment) => panel is OverlayPanel;
+/**
+ * The set an overlay opening or closing leaves behind it.
+ *
+ * A write states the whole set, so raising the nav slide-over has to say what
+ * else is up or it takes it down. The panes stay and the previous overlay goes,
+ * because two overlays cannot both be up — which is how a reader crossing from
+ * their mail into the calendar and reaching for the folders keeps the rail they
+ * arrived with.
+ */
+export declare function panelsWithOverlay(open: readonly PanelFragment[], overlay: OverlayPanel | undefined): PanelFragment[];
+/**
+ * The panels the address asks for, in the union's own order so one set of open
+ * panels has one spelling. A hand-edited or stale URL is a normal thing to
+ * receive, so an unrecognised name is dropped instead of throwing.
+ */
+export declare function parseOpenPanels(hash: string): readonly PanelFragment[];
+/** The address a set of open panels is written as. */
+export declare function formatOpenPanels(panels: readonly PanelFragment[]): string;
+/** The panels the address currently asks for. */
+export declare function useOpenPanels(): readonly PanelFragment[];
+/**
+ * A destination's `hash`, for a navigation that keeps the reader where they
+ * are. The router drops the fragment on every navigation unless the destination
+ * asks for it, so this is what a link or a `navigate` call passes to state the
+ * rule rather than restate it.
+ *
+ * The tier is bound here rather than passed at the call site, so the updater
+ * still has the shape the router hands a previous fragment to. That parameter
+ * is optional because the router types it `string | undefined`.
+ */
+export declare function retainOpenPanelsAtTier(isDesktop: boolean): (hash?: string) => string;
+/**
+ * The `hash` updater for a navigation from the surface the reader is on. The
+ * layout tier is read here, once, so no call site decides for itself what a
+ * navigation keeps.
+ */
+export declare function useRetainOpenPanels(): (hash?: string) => string;
+/**
+ * Puts a set of panels up, replacing whatever was up before.
+ *
+ * `replace`, because a panel is chrome over the current view rather than a place
+ * to go: Back belongs to the message the reader came from, not to the rail they
+ * just collapsed. The fragment names panels and never an element, so it is not
+ * an anchor to scroll to either.
+ */
+export declare function useSetOpenPanels(): (panels: readonly PanelFragment[]) => void;