@rapidmx/web-client 0.15.1 → 0.17.0

package/apps/shared/navigation/routerContext.tsx

@@ -1,83 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// Copyright (C) 2026 Jean-Philippe Steinmetz
-// SPDX-License-Identifier: MPL-2.0
-///////////////////////////////////////////////////////////////////////////////
-/**
- * What the client-side router (`AppRouter.tsx`) offers to the tree under it - the location and a way to navigate - and the hooks that read
- * it. Kept apart from the router itself so that the app frame (`AppShell`), which the router renders, can use `useNavigate()` without a
- * circular import. `AppRouter.tsx` re-exports everything here, so callers keep importing from there.
- */
-import { createContext, useContext, useEffect, useState } from "react";
-
-export interface RouterLocation {
-    pathname: string;
-    /** With the leading `?`, or `""`. */
-    search: string;
-    /** With the leading `#`, or `""`. */
-    hash: string;
-}
-
-export interface NavigateOptions {
-    /** Replaces the current history entry instead of adding one (a redirect, or a state change that isn't a "place"). */
-    replace?: boolean;
-}
-
-/** Goes to `href`: without a page load when it is a route of the app, else as an ordinary navigation. */
-export type NavigateFn = (href: string, options?: NavigateOptions) => void;
-
-export interface RouterContextValue {
-    location: RouterLocation;
-    navigate: NavigateFn;
-}
-
-export const RouterContext = createContext<RouterContextValue | null>(null);
-
-/** Before the browser's own location has been read (the server render and the first client render, which must match). */
-export const UNKNOWN_LOCATION: RouterLocation = { pathname: "", search: "", hash: "" };
-
-export function readWindowLocation(): RouterLocation {
-    const { pathname, search, hash } = window.location;
-    return { pathname, search, hash };
-}
-
-/** What `useNavigate()` does outside a router: an ordinary navigation, exactly as `window.location.href = href` always was. */
-function navigateWithBrowser(href: string, options: NavigateOptions = {}): void {
-    if (options.replace) {
-        window.location.replace(href);
-    } else {
-        window.location.href = href;
-    }
-}
-
-/**
- * The function to go somewhere with. `navigate("/calendar")` and `navigate("/?mailboxUid=a&folderUid=b")` change the page and
- * the URL without a page load when the router knows the route (Mail, Calendar, Contacts, Tasks, Settings and their subpages),
- * and load the page normally otherwise; outside the router it is always a normal navigation. Prefer a plain `<a href>` for
- * anything the user clicks - the router intercepts it, and it stays a real link - and this for what code decides (after a
- * save, a delete, a select). The returned function is stable across renders.
- */
-export function useNavigate(): NavigateFn {
-    const router = useContext(RouterContext);
-    return router ? router.navigate : navigateWithBrowser;
-}
-
-/**
- * Where the app is now, as `{ pathname, search, hash }`, updating as the router navigates (folder changes are `search`
- * changes, not page changes). Empty until the browser's location has been read in an effect after the first render, so that
- * the server render and the first client render agree - read query parameters from it in an effect, not during render.
- */
-export function useLocation(): RouterLocation {
-    const router = useContext(RouterContext);
-    const [own, setOwn] = useState<RouterLocation>(UNKNOWN_LOCATION);
-    useEffect(() => {
-        if (!router) {
-            setOwn(readWindowLocation());
-        }
-    }, [router]);
-    return router ? router.location : own;
-}
-
-/** `useLocation().search` - what the shells read `?mailboxUid=` and the like from. */
-export function useLocationSearch(): string {
-    return useLocation().search;
-}

package/apps/shared/navigation/routes.ts

@@ -1,72 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// Copyright (C) 2026 Jean-Philippe Steinmetz
-// SPDX-License-Identifier: MPL-2.0
-///////////////////////////////////////////////////////////////////////////////
-import type { ComponentType } from "react";
-
-/**
- * One page the client-side router (`AppRouter`) can show without a page load. The table of them (`apps/www/_routes.ts`)
- * mirrors the files under `apps/www`: what isn't in it (the admin and escrow consoles, plugin pages, anything else) is
- * reached by a normal navigation.
- */
-export interface RouteDefinition {
-    /** The route template: literal segments and `:name` parameters, the same shape as the file path (`/messages/:uid`
-     * for `messages/[uid].tsx`). The first entry that matches a URL wins, so list literal routes before parameterized
-     * ones (`/settings/filters/new` before `/settings/filters/:uid`). */
-    path: string;
-    /** The app-rail entry (or `"settings"`) highlighted while this page shows - what the page's shell passes as `active`. */
-    active: string;
-    /**
-     * Loads the page's module, which must have a `routedPage()` component as its default export. Written as
-     * `() => import("./calendar/index.js")` so the bundler makes the page its own chunk; it is called the first time the
-     * page is shown or prefetched (pointer over or focus on a link to it, or when the browser is idle).
-     */
-    load: () => Promise<{ default: ComponentType<any> }>;
-    /** Downloaded when the browser is idle after the first page has loaded - the app rail's own pages, which are the
-     * likeliest next click. */
-    idlePrefetch?: boolean;
-}
-
-export interface RouteMatch {
-    route: RouteDefinition;
-    /** The values of the template's `:name` segments, decoded. */
-    params: Record<string, string>;
-}
-
-/** Splits a path into segments, ignoring a trailing slash: `/` and `""` have none. */
-function segmentsOf(path: string): string[] {
-    return path.split("/").filter((segment) => segment !== "");
-}
-
-/** Matches `pathname` against one route template - `undefined` when it doesn't, or a parameter isn't valid percent-encoding. */
-function matchTemplate(template: string, pathname: string): Record<string, string> | undefined {
-    const expected = segmentsOf(template);
-    const actual = segmentsOf(pathname);
-    if (expected.length !== actual.length) {
-        return undefined;
-    }
-    const params: Record<string, string> = {};
-    for (let i = 0; i < expected.length; i++) {
-        if (expected[i].startsWith(":")) {
-            try {
-                params[expected[i].slice(1)] = decodeURIComponent(actual[i]);
-            } catch {
-                return undefined;
-            }
-        } else if (expected[i] !== actual[i]) {
-            return undefined;
-        }
-    }
-    return params;
-}
-
-/** The first route in `routes` whose template matches `pathname`, with its parameters. */
-export function matchRoute(routes: readonly RouteDefinition[], pathname: string): RouteMatch | undefined {
-    for (const route of routes) {
-        const params = matchTemplate(route.path, pathname);
-        if (params) {
-            return { route, params };
-        }
-    }
-    return undefined;
-}

package/apps/www/_routedPage.tsx

@@ -1,24 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// Copyright (C) 2026 Jean-Philippe Steinmetz
-// SPDX-License-Identifier: MPL-2.0
-///////////////////////////////////////////////////////////////////////////////
-import React, { ComponentType } from "react";
-import AppRouter, { RoutedPageComponent } from "../shared/navigation/AppRouter.js";
-import { wwwRoutes } from "./_routes.js";
-
-/**
- * Makes a `www` page the entry of the client-side router: the page's default export is `routedPage("/its/route", Page)`.
- * `@rapidrest/react` server-renders and hydrates exactly that component, so what it renders - the router, with the persistent
- * app frame (`AppChrome`) and `Page` inside it - is the whole client tree, and later pages replace `Page` without a page load.
- * `path` is the page's route template, the same as its entry in `_routes.ts`.
- *
- * The result carries the plain `Page` as `.page`, which is what the router shows when it loads this module for a navigation
- * (rendering the wrapped default export there would nest a second router).
- */
-export function routedPage<P extends object>(path: string, Page: ComponentType<P>): RoutedPageComponent<P> {
-    function RoutedPage(props: P) {
-        return <AppRouter routes={wwwRoutes} initialPath={path} initialPage={Page} pageProps={props} />;
-    }
-    RoutedPage.page = Page;
-    return RoutedPage;
-}

package/apps/www/_routes.ts

@@ -1,37 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// Copyright (C) 2026 Jean-Philippe Steinmetz
-// SPDX-License-Identifier: MPL-2.0
-///////////////////////////////////////////////////////////////////////////////
-import type { RouteDefinition } from "../shared/navigation/routes.js";
-
-/**
- * Every `apps/www` page the client-side router can show without a page load (see `apps/shared/navigation/AppRouter.tsx`), in
- * the order they are matched: literal routes before the parameterized ones that would also match them. Each page loads with a
- * dynamic `import()`, which is what makes it a chunk of its own - only the page a document was rendered for is in its first
- * JavaScript. Keep it in step with the files under `apps/www`; a page missing from here still works, it is just reached with a
- * page load. (The file starts with `_` so `@rapidrest/react` doesn't treat it as a page.)
- *
- * The four app-rail pages are `idlePrefetch`ed: downloaded when the browser is idle after the first page has loaded.
- */
-export const wwwRoutes: readonly RouteDefinition[] = [
-    { path: "/", active: "mail", load: () => import("./index.js"), idlePrefetch: true },
-    { path: "/messages/:uid", active: "mail", load: () => import("./messages/[uid].js") },
-    { path: "/calendar", active: "calendar", load: () => import("./calendar/index.js"), idlePrefetch: true },
-    { path: "/contacts", active: "contacts", load: () => import("./contacts/index.js"), idlePrefetch: true },
-    { path: "/contacts/:uid", active: "contacts", load: () => import("./contacts/[uid].js") },
-    { path: "/tasks", active: "tasks", load: () => import("./tasks/index.js"), idlePrefetch: true },
-    { path: "/settings/appearance", active: "settings", load: () => import("./settings/appearance/index.js") },
-    { path: "/settings/auto-reply", active: "settings", load: () => import("./settings/auto-reply/index.js") },
-    { path: "/settings/encryption", active: "settings", load: () => import("./settings/encryption/index.js") },
-    { path: "/settings/filters", active: "settings", load: () => import("./settings/filters/index.js") },
-    { path: "/settings/filters/new", active: "settings", load: () => import("./settings/filters/new/index.js") },
-    { path: "/settings/filters/:uid", active: "settings", load: () => import("./settings/filters/[uid].js") },
-    { path: "/settings/labels", active: "settings", load: () => import("./settings/labels/index.js") },
-    { path: "/settings/privacy", active: "settings", load: () => import("./settings/privacy/index.js") },
-    { path: "/settings/profile", active: "settings", load: () => import("./settings/profile/index.js") },
-    { path: "/settings/read-receipts", active: "settings", load: () => import("./settings/read-receipts/index.js") },
-    { path: "/settings/sharing", active: "settings", load: () => import("./settings/sharing/index.js") },
-    { path: "/settings/signatures", active: "settings", load: () => import("./settings/signatures/index.js") },
-    { path: "/settings/signatures/new", active: "settings", load: () => import("./settings/signatures/new/index.js") },
-    { path: "/settings/signatures/:uid", active: "settings", load: () => import("./settings/signatures/[uid].js") },
-];

package/dist/apps/shared/navigation/AppRouter.d.ts

@@ -1,52 +0,0 @@
-/**
- * The web client's client-side router: what lets Mail, Calendar, Contacts, Tasks and Settings replace one another - and a
- * folder replace a folder - without a page load.
- *
- * `@rapidrest/react` has no router of its own: every page is a server-rendered document with its own hydration entry, and
- * hydrates only the page component (never `_layout.tsx`). So the router is a component the pages render themselves - each
- * page's default export is `routedPage(path, Page)` (see `apps/www/_routedPage.tsx`), which renders `AppRouter` with the page
- * as its first content. The first load is unchanged: the server renders the same tree, the browser hydrates it.
- *
- * `AppRouter` keeps ONE `AppChrome` (the icon rail, header, user menu, impersonation banner, compose windows, unlock prompt,
- * idle-key timer, sign-out listener) mounted and swaps only what is inside it. A page's own shell (`MailShell`,
- * `CalendarShell`, ...) still renders `AppShell` as it always did; inside the frame that renders nothing but its children.
- *
- * Navigation:
- *
- * Every `<a href>` to a same-origin path in the route table is intercepted (plain left clicks only - not with a modifier key, not
- * `target`/`download`, not a hash-only link, not one marked `data-full-reload`), so pages just write ordinary links and
- * middle-click, "open in new tab" and copy-link keep working. Anything not in the table - the admin and escrow consoles, plugin
- * pages, other sites - is left to the browser. `useNavigate()` does the same for code (`navigate("/contacts")`).
- *
- * Back and forward work (`popstate`), and the URL is always the real, shareable one (`?mailboxUid=&folderUid=` and all).
- *
- * A route's code is loaded (`route.load()`) before the URL and the page change, so the old page stays up meanwhile (the frame is
- * `aria-busy`); a route that fails to load falls back to a real navigation, which also picks up a new deploy.
- *
- * The next page's code is fetched on hover, focus and pointer-down of a link to it, and for the app rail's pages when the browser
- * is idle.
- *
- * After a page change the frame moves keyboard focus to the content region, scrolls to the top, sets `document.title` and
- * announces the new page to screen readers.
- *
- * The props of every `apps/www` page are the same for all of them (`WwwRoute.fetchProps()`: the user, auth-server URL,
- * branding, plugin navigation, impersonation) except `params`, which the router recomputes from the URL - so the props of the
- * page that was loaded are what every later page gets.
- */
-import React, { ComponentType } from "react";
-import { RouteDefinition } from "./routes.js";
-export { useLocation, useLocationSearch, useNavigate } from "./routerContext.js";
-export type { NavigateFn, NavigateOptions, RouterLocation } from "./routerContext.js";
-/** What `routedPage()` gives the router: the page component itself, without the router around it. */
-export type RoutedPageComponent<P = any> = ComponentType<P> & {
-    page: ComponentType<P>;
-};
-export interface AppRouterProps {
-    routes: readonly RouteDefinition[];
-    /** The template of the route this document was rendered for. */
-    initialPath: string;
-    initialPage: ComponentType<any>;
-    /** The props the server rendered the page with. */
-    pageProps: Record<string, any>;
-}
-export default function AppRouter({ routes, initialPath, initialPage, pageProps }: AppRouterProps): React.JSX.Element;

package/dist/apps/shared/navigation/AppRouter.js

@@ -1,242 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-///////////////////////////////////////////////////////////////////////////////
-// Copyright (C) 2026 Jean-Philippe Steinmetz
-// SPDX-License-Identifier: MPL-2.0
-///////////////////////////////////////////////////////////////////////////////
-/**
- * The web client's client-side router: what lets Mail, Calendar, Contacts, Tasks and Settings replace one another - and a
- * folder replace a folder - without a page load.
- *
- * `@rapidrest/react` has no router of its own: every page is a server-rendered document with its own hydration entry, and
- * hydrates only the page component (never `_layout.tsx`). So the router is a component the pages render themselves - each
- * page's default export is `routedPage(path, Page)` (see `apps/www/_routedPage.tsx`), which renders `AppRouter` with the page
- * as its first content. The first load is unchanged: the server renders the same tree, the browser hydrates it.
- *
- * `AppRouter` keeps ONE `AppChrome` (the icon rail, header, user menu, impersonation banner, compose windows, unlock prompt,
- * idle-key timer, sign-out listener) mounted and swaps only what is inside it. A page's own shell (`MailShell`,
- * `CalendarShell`, ...) still renders `AppShell` as it always did; inside the frame that renders nothing but its children.
- *
- * Navigation:
- *
- * Every `<a href>` to a same-origin path in the route table is intercepted (plain left clicks only - not with a modifier key, not
- * `target`/`download`, not a hash-only link, not one marked `data-full-reload`), so pages just write ordinary links and
- * middle-click, "open in new tab" and copy-link keep working. Anything not in the table - the admin and escrow consoles, plugin
- * pages, other sites - is left to the browser. `useNavigate()` does the same for code (`navigate("/contacts")`).
- *
- * Back and forward work (`popstate`), and the URL is always the real, shareable one (`?mailboxUid=&folderUid=` and all).
- *
- * A route's code is loaded (`route.load()`) before the URL and the page change, so the old page stays up meanwhile (the frame is
- * `aria-busy`); a route that fails to load falls back to a real navigation, which also picks up a new deploy.
- *
- * The next page's code is fetched on hover, focus and pointer-down of a link to it, and for the app rail's pages when the browser
- * is idle.
- *
- * After a page change the frame moves keyboard focus to the content region, scrolls to the top, sets `document.title` and
- * announces the new page to screen readers.
- *
- * The props of every `apps/www` page are the same for all of them (`WwwRoute.fetchProps()`: the user, auth-server URL,
- * branding, plugin navigation, impersonation) except `params`, which the router recomputes from the URL - so the props of the
- * page that was loaded are what every later page gets.
- */
-import { useCallback, useEffect, useMemo, useRef, useState } from "react";
-import { AppChrome } from "../components/layout/AppShell.js";
-import { AppFrameContext } from "./frameContext.js";
-import { whenIdle, shouldSaveData } from "./idle.js";
-import { matchRoute } from "./routes.js";
-import { RouterContext, UNKNOWN_LOCATION, readWindowLocation } from "./routerContext.js";
-export { useLocation, useLocationSearch, useNavigate } from "./routerContext.js";
-function pickChromeProps(props) {
-    const { userUid, authServerUrl, impersonating, impersonationBaseUrl, trusted, trustedRoles, pluginNav, branding, appearance } = props;
-    return { userUid, authServerUrl, impersonating, impersonationBaseUrl, trusted, trustedRoles, pluginNav, branding, appearance };
-}
-/** The anchor a click/pointer event is on or in, if it is a link. */
-function linkOf(event) {
-    const target = event.target;
-    return target instanceof Element ? target.closest("a[href]") : null;
-}
-/** The URL of a link the router may take over, `null` for one the browser must handle itself. */
-function routerUrlOf(link) {
-    if ((link.target && link.target !== "_self") || link.hasAttribute("download") || link.hasAttribute("data-full-reload")) {
-        return null;
-    }
-    const url = new URL(link.href, window.location.href);
-    if (url.origin !== window.location.origin) {
-        return null;
-    }
-    // A link that only moves within the page (`#section`) is the browser's own.
-    if (url.hash !== "" && url.pathname === window.location.pathname && url.search === window.location.search) {
-        return null;
-    }
-    return url;
-}
-export default function AppRouter({ routes, initialPath, initialPage, pageProps }) {
-    const [current, setCurrent] = useState(() => ({
-        Page: initialPage,
-        routePath: initialPath,
-        active: routes.find((route) => route.path === initialPath)?.active ?? "mail",
-        params: pageProps.params ?? {},
-        key: "initial",
-    }));
-    const [location, setLocation] = useState(UNKNOWN_LOCATION);
-    const [pending, setPending] = useState(false);
-    const [takeovers, setTakeovers] = useState(0);
-    const currentRef = useRef(current);
-    currentRef.current = current;
-    /** Identifies the latest navigation; one that finds it changed while loading has been overtaken and does nothing. */
-    const navigationRef = useRef(0);
-    /** The page components loaded or loading, by route template - one request per page however many links are touched. */
-    const pagesRef = useRef(new Map([[initialPath, Promise.resolve(initialPage)]]));
-    const routesRef = useRef(routes);
-    routesRef.current = routes;
-    /** Loads a route's page component (once). Rejects if its code can't be loaded - and then a later attempt tries again. */
-    const pageFor = useCallback((route) => {
-        let loading = pagesRef.current.get(route.path);
-        if (!loading) {
-            loading = route.load().then((module) => {
-                const page = module.default.page;
-                if (!page) {
-                    throw new Error(`The page for ${route.path} is not a routedPage().`);
-                }
-                return page;
-            });
-            pagesRef.current.set(route.path, loading);
-            loading.catch(() => pagesRef.current.delete(route.path));
-        }
-        return loading;
-    }, []);
-    /** The pathname of the page on screen (the address bar's, once a navigation has been committed). */
-    const shownPathRef = useRef(null);
-    /**
-     * Shows `match` (loading its page first if it is a different page from the one on screen), calling `commit` - which puts
-     * the URL in the address bar - at the moment the new page replaces the old one. Resolves `false` when the page's code
-     * couldn't be loaded, and `true` otherwise, including when a newer navigation overtook this one while it loaded.
-     */
-    const show = useCallback(async (match, target, sequence, commit) => {
-        const pathChanged = target.pathname !== shownPathRef.current;
-        let Page = currentRef.current.Page;
-        if (pathChanged && match.route.path !== currentRef.current.routePath) {
-            try {
-                Page = await pageFor(match.route);
-            }
-            catch {
-                return false;
-            }
-        }
-        if (sequence !== navigationRef.current) {
-            return true;
-        }
-        commit();
-        shownPathRef.current = target.pathname;
-        if (pathChanged) {
-            setCurrent({ Page, routePath: match.route.path, active: match.route.active, params: match.params, key: target.pathname });
-        }
-        setLocation(target);
-        return true;
-    }, [pageFor]);
-    const navigate = useCallback((href, options = {}) => {
-        const url = new URL(href, window.location.href);
-        const leave = () => (options.replace ? window.location.replace(url.href) : (window.location.href = url.href));
-        const match = url.origin === window.location.origin ? matchRoute(routesRef.current, url.pathname) : undefined;
-        if (!match) {
-            leave();
-            return;
-        }
-        const target = { pathname: url.pathname, search: url.search, hash: url.hash };
-        const now = readWindowLocation();
-        if (target.pathname === now.pathname && target.search === now.search && target.hash === now.hash) {
-            return;
-        }
-        const sequence = ++navigationRef.current;
-        setPending(true);
-        void show(match, target, sequence, () => {
-            window.history[options.replace ? "replaceState" : "pushState"](null, "", target.pathname + target.search + target.hash);
-        }).then((ok) => {
-            if (!ok) {
-                leave();
-            }
-            if (sequence === navigationRef.current) {
-                setPending(false);
-            }
-        });
-    }, [show]);
-    // The browser's own location is read after the first render, never during it: the server can't know the query string.
-    useEffect(() => {
-        const here = readWindowLocation();
-        shownPathRef.current = here.pathname;
-        setLocation(here);
-    }, []);
-    // Back and forward.
-    useEffect(() => {
-        function handlePopState() {
-            const here = readWindowLocation();
-            const match = matchRoute(routesRef.current, here.pathname);
-            if (!match) {
-                window.location.reload();
-                return;
-            }
-            const sequence = ++navigationRef.current;
-            setPending(true);
-            void show(match, here, sequence, () => undefined).then((ok) => {
-                if (!ok) {
-                    window.location.reload();
-                }
-                if (sequence === navigationRef.current) {
-                    setPending(false);
-                }
-            });
-        }
-        window.addEventListener("popstate", handlePopState);
-        return () => window.removeEventListener("popstate", handlePopState);
-    }, [show]);
-    // Plain links, and fetching what they lead to before they are clicked.
-    useEffect(() => {
-        function handleClick(event) {
-            if (event.defaultPrevented || event.button !== 0 || event.metaKey || event.ctrlKey || event.shiftKey || event.altKey) {
-                return;
-            }
-            const link = linkOf(event);
-            const url = link && routerUrlOf(link);
-            if (!url || !matchRoute(routesRef.current, url.pathname)) {
-                return;
-            }
-            event.preventDefault();
-            navigate(url.pathname + url.search + url.hash);
-        }
-        function handleIntent(event) {
-            const link = linkOf(event);
-            const url = link && routerUrlOf(link);
-            const match = url && matchRoute(routesRef.current, url.pathname);
-            if (match) {
-                pageFor(match.route).catch(() => undefined);
-            }
-        }
-        document.addEventListener("click", handleClick);
-        document.addEventListener("pointerover", handleIntent);
-        document.addEventListener("pointerdown", handleIntent);
-        document.addEventListener("focusin", handleIntent);
-        return () => {
-            document.removeEventListener("click", handleClick);
-            document.removeEventListener("pointerover", handleIntent);
-            document.removeEventListener("pointerdown", handleIntent);
-            document.removeEventListener("focusin", handleIntent);
-        };
-    }, [navigate, pageFor]);
-    // The app rail's other pages, once the browser has nothing else to do - so that the likeliest next click is instant.
-    useEffect(() => {
-        if (shouldSaveData()) {
-            return;
-        }
-        const cancels = routesRef.current
-            .filter((route) => route.idlePrefetch)
-            .map((route) => whenIdle(() => void pageFor(route).catch(() => undefined)));
-        return () => cancels.forEach((cancel) => cancel());
-    }, [pageFor]);
-    const enterTakeover = useCallback(() => {
-        setTakeovers((n) => n + 1);
-        return () => setTakeovers((n) => n - 1);
-    }, []);
-    const frame = useMemo(() => ({ enterTakeover }), [enterTakeover]);
-    const router = useMemo(() => ({ location, navigate }), [location, navigate]);
-    const Page = current.Page;
-    return (_jsx(RouterContext.Provider, { value: router, children: _jsx(AppFrameContext.Provider, { value: frame, children: _jsx(AppChrome, { active: current.active, routeKey: current.key, busy: pending, hideChrome: takeovers > 0, ...pickChromeProps(pageProps), children: _jsx(Page, { ...pageProps, params: current.params }, current.key) }) }) }));
-}

package/dist/apps/shared/navigation/idle.d.ts

@@ -1,14 +0,0 @@
-/** How long an idle callback may be held back on a busy page before it runs anyway. */
-export declare const IDLE_TIMEOUT_MS = 3000;
-/** The delay used where the browser has no `requestIdleCallback` (Safari). */
-export declare const IDLE_FALLBACK_DELAY_MS = 200;
-/**
- * Runs `callback` once the page has finished loading (the window `load` event, which waits for every script and image the page
- * asked for) and the browser has nothing better to do (`requestIdleCallback`), or shortly after where there is no such thing.
- * For work that only makes later things faster - fetching a code chunk, warming a cache - and must never compete with what
- * the user is waiting for. Returns a function that cancels it if it hasn't run yet.
- */
-export declare function whenIdle(callback: () => void): () => void;
-/** `true` when the user has asked the browser to save data (or is on a very slow connection): work that only speculates
- * about what will be needed - prefetching - should not run then. */
-export declare function shouldSaveData(): boolean;

package/dist/apps/shared/navigation/idle.js

@@ -1,43 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// Copyright (C) 2026 Jean-Philippe Steinmetz
-// SPDX-License-Identifier: MPL-2.0
-///////////////////////////////////////////////////////////////////////////////
-/** How long an idle callback may be held back on a busy page before it runs anyway. */
-export const IDLE_TIMEOUT_MS = 3000;
-/** The delay used where the browser has no `requestIdleCallback` (Safari). */
-export const IDLE_FALLBACK_DELAY_MS = 200;
-/**
- * Runs `callback` once the page has finished loading (the window `load` event, which waits for every script and image the page
- * asked for) and the browser has nothing better to do (`requestIdleCallback`), or shortly after where there is no such thing.
- * For work that only makes later things faster - fetching a code chunk, warming a cache - and must never compete with what
- * the user is waiting for. Returns a function that cancels it if it hasn't run yet.
- */
-export function whenIdle(callback) {
-    let cancelIdle = () => undefined;
-    function schedule() {
-        if (typeof window.requestIdleCallback === "function") {
-            const handle = window.requestIdleCallback(callback, { timeout: IDLE_TIMEOUT_MS });
-            cancelIdle = () => window.cancelIdleCallback(handle);
-        }
-        else {
-            const timer = setTimeout(callback, IDLE_FALLBACK_DELAY_MS);
-            cancelIdle = () => clearTimeout(timer);
-        }
-    }
-    if (document.readyState === "complete") {
-        schedule();
-    }
-    else {
-        window.addEventListener("load", schedule, { once: true });
-    }
-    return () => {
-        window.removeEventListener("load", schedule);
-        cancelIdle();
-    };
-}
-/** `true` when the user has asked the browser to save data (or is on a very slow connection): work that only speculates
- * about what will be needed - prefetching - should not run then. */
-export function shouldSaveData() {
-    const connection = navigator.connection;
-    return connection?.saveData === true || connection?.effectiveType === "slow-2g" || connection?.effectiveType === "2g";
-}

package/dist/apps/shared/navigation/routerContext.d.ts

@@ -1,37 +0,0 @@
-export interface RouterLocation {
-    pathname: string;
-    /** With the leading `?`, or `""`. */
-    search: string;
-    /** With the leading `#`, or `""`. */
-    hash: string;
-}
-export interface NavigateOptions {
-    /** Replaces the current history entry instead of adding one (a redirect, or a state change that isn't a "place"). */
-    replace?: boolean;
-}
-/** Goes to `href`: without a page load when it is a route of the app, else as an ordinary navigation. */
-export type NavigateFn = (href: string, options?: NavigateOptions) => void;
-export interface RouterContextValue {
-    location: RouterLocation;
-    navigate: NavigateFn;
-}
-export declare const RouterContext: import("react").Context<RouterContextValue | null>;
-/** Before the browser's own location has been read (the server render and the first client render, which must match). */
-export declare const UNKNOWN_LOCATION: RouterLocation;
-export declare function readWindowLocation(): RouterLocation;
-/**
- * The function to go somewhere with. `navigate("/calendar")` and `navigate("/?mailboxUid=a&folderUid=b")` change the page and
- * the URL without a page load when the router knows the route (Mail, Calendar, Contacts, Tasks, Settings and their subpages),
- * and load the page normally otherwise; outside the router it is always a normal navigation. Prefer a plain `<a href>` for
- * anything the user clicks - the router intercepts it, and it stays a real link - and this for what code decides (after a
- * save, a delete, a select). The returned function is stable across renders.
- */
-export declare function useNavigate(): NavigateFn;
-/**
- * Where the app is now, as `{ pathname, search, hash }`, updating as the router navigates (folder changes are `search`
- * changes, not page changes). Empty until the browser's location has been read in an effect after the first render, so that
- * the server render and the first client render agree - read query parameters from it in an effect, not during render.
- */
-export declare function useLocation(): RouterLocation;
-/** `useLocation().search` - what the shells read `?mailboxUid=` and the like from. */
-export declare function useLocationSearch(): string;