@hgdc/ui 0.37.0 → 0.39.0

package/dist/product-switch.js

@@ -1,6 +1,6 @@
 import { useEffect } from "react";
 /*
- * Passage d'un produit à l'autre (ADR 0016) : la barre des produits pointe vers
+ * Passage d'un produit à l'autre (ADR 0016, 0020) : la barre des produits pointe vers
  * `/auth/hgdc?refresh=background&next=/`. Avec une session du produit ouverte, l'entrée de
  * `@hgdc/auth` va droit à la page et pose un cookie « relire les organisations » ; la coque le lit
  * ici et relit les organisations dans un cadre caché, sans faire attendre la personne.
@@ -15,13 +15,33 @@ export const ORG_SYNC_COOKIE = "hgdc-org-sync";
 export const BACKGROUND_REFRESH_PATH = "/auth/hgdc?refresh=1&frame=1";
 /** Abandon du cadre s'il ne s'est pas chargé : Account injoignable, réseau coupé. */
 export const BACKGROUND_REFRESH_TIMEOUT_MS = 20_000;
+/** Marque d'un lien de la barre vers un autre produit servi sous la même origine : prérendu au survol. */
+export const PRODUCT_PRERENDER_ATTRIBUTE = "data-hgdc-prerender";
 /**
- * Liens préchargés au survol : l'entrée d'un autre produit en `refresh=background`. Elle ne fait
- * que lire la session et rediriger ; sans session, elle répond 503 à un préchargement (rien n'est
- * créé), et le clic repart normalement. Jamais de `prerender` : la page d'arrivée lit un cookie et
- * ouvre un cadre, ce qu'un prérendu ferait pour un simple survol.
+ * Règles de spéculation posées par la coque (Chrome et Edge ; ignorées ailleurs) :
+ *
+ * - **prérendu** au survol (`eagerness: "moderate"`, environ 200 ms) des liens marqués
+ *   `PRODUCT_PRERENDER_ATTRIBUTE` vers l'entrée `refresh=background` d'un produit de la même
+ *   origine (`app.hgdc.ch/<produit>`) : le motif est relatif, il ne vaut que pour l'origine de la
+ *   page. L'entrée ne rend que la redirection d'une session ouverte ; sans session, elle répond 503
+ *   à une requête `Sec-Purpose: prefetch;prerender`, le prérendu est jeté et le clic repart
+ *   normalement. La page prérendue attend d'être affichée pour relire les organisations.
+ * - **préchargement** seul de l'entrée d'un produit encore sur son sous-domaine (même site, les
+ *   cookies partent), comme avant (ADR 0016).
  */
-export const PRODUCT_PREFETCH_RULES = JSON.stringify({
+export const PRODUCT_SPECULATION_RULES = JSON.stringify({
+    prerender: [
+        {
+            source: "document",
+            where: {
+                and: [
+                    { selector_matches: `a[${PRODUCT_PRERENDER_ATTRIBUTE}]` },
+                    { href_matches: "/*/auth/hgdc?refresh=background*" },
+                ],
+            },
+            eagerness: "moderate",
+        },
+    ],
     prefetch: [
         {
             source: "document",
@@ -30,24 +50,53 @@ export const PRODUCT_PREFETCH_RULES = JSON.stringify({
         },
     ],
 });
-/** Lit et efface le cookie de relecture. Vrai s'il était posé. */
-export function takeOrgSyncCookie(doc = document) {
-    const present = doc.cookie.split(";").some((part) => part.trim() === `${ORG_SYNC_COOKIE}=1`);
-    if (present) {
+/** @deprecated Remplacé par `PRODUCT_SPECULATION_RULES` (prérendu sous la même origine, 0.38). */
+export const PRODUCT_PREFETCH_RULES = PRODUCT_SPECULATION_RULES;
+/** Base de chemin d'un produit (`/analytics`), telle que l'entrée la pose dans le cookie. */
+const BASE_PATH = /^(?:\/[A-Za-z0-9_~-][A-Za-z0-9._~-]*)+$/;
+/**
+ * Lit et efface le cookie de relecture. Rend la base de chemin du produit (`""` à la racine de son
+ * origine, `"/analytics"` sous `app.hgdc.ch/analytics`), `null` s'il n'était pas posé. Sous une
+ * base, l'entrée le limite à ce chemin : un autre produit de la même origine ne le voit pas.
+ */
+export function takeOrgSync(doc = document) {
+    let base = null;
+    for (const part of doc.cookie.split(";")) {
+        const [name, value] = part.trim().split("=", 2);
+        if (name !== ORG_SYNC_COOKIE || value === undefined)
+            continue;
+        if (value === "1")
+            base = "";
+        else if (BASE_PATH.test(value))
+            base = value;
+        if (base !== null)
+            break;
+    }
+    if (base !== null) {
         const secure = doc.location.protocol === "https:" ? "; Secure" : "";
-        doc.cookie = `${ORG_SYNC_COOKIE}=; Path=/; Max-Age=0; SameSite=Lax${secure}`;
+        doc.cookie = `${ORG_SYNC_COOKIE}=; Path=${base || "/"}; Max-Age=0; SameSite=Lax${secure}`;
     }
-    return present;
+    return base;
+}
+/** Lit et efface le cookie de relecture. Vrai s'il était posé. */
+export function takeOrgSyncCookie(doc = document) {
+    return takeOrgSync(doc) !== null;
 }
 /**
  * Relit les organisations dans un cadre caché, une fois, si l'entrée l'a demandé. Le cadre n'a
  * ni script ni formulaire (`sandbox`), il suit seulement les redirections d'Account ; la nouvelle
  * session du produit recopie les organisations, et les requêtes Convex abonnées se mettent à jour.
  * Si la session d'Account a expiré, Account refuse d'être affiché dans un cadre : rien ne se passe,
- * la session du produit reste celle d'avant.
+ * la session du produit reste celle d'avant. Une page prérendue au survol attend d'être affichée :
+ * un survol sans clic ne relit rien.
  */
 export function startBackgroundRefresh(doc = document) {
-    if (!takeOrgSyncCookie(doc))
+    if (doc.prerendering) {
+        doc.addEventListener("prerenderingchange", () => startBackgroundRefresh(doc), { once: true });
+        return null;
+    }
+    const base = takeOrgSync(doc);
+    if (base === null)
         return null;
     const frame = doc.createElement("iframe");
     frame.hidden = true;
@@ -63,7 +112,7 @@ export function startBackgroundRefresh(doc = document) {
     };
     const timer = window.setTimeout(done, BACKGROUND_REFRESH_TIMEOUT_MS);
     frame.addEventListener("load", done, { once: true });
-    frame.src = BACKGROUND_REFRESH_PATH;
+    frame.src = `${base}${BACKGROUND_REFRESH_PATH}`;
     doc.body.append(frame);
     return frame;
 }
@@ -80,7 +129,9 @@ export function useBackgroundOrganizationRefresh() {
 }
 /**
  * Dans la coque (`AppShell` le fait) : la relecture ci-dessus si la racine ne l'a pas déjà faite
- * (le cookie ne sert qu'une fois), et le préchargement au survol des autres produits.
+ * (le cookie ne sert qu'une fois), et le prérendu ou le préchargement au survol des autres
+ * produits. Les règles sont un `<script type="speculationrules">` en ligne : une CSP qui pose
+ * `script-src` doit y autoriser `'inline-speculation-rules'` (README).
  */
 export function useProductSwitch(enabled = true) {
     useEffect(() => {
@@ -95,7 +146,7 @@ export function useProductSwitch(enabled = true) {
         // Créé par le DOM, pas par React : un script inséré par `innerHTML` n'est jamais lu.
         const script = document.createElement("script");
         script.type = "speculationrules";
-        script.textContent = PRODUCT_PREFETCH_RULES;
+        script.textContent = PRODUCT_SPECULATION_RULES;
         document.head.append(script);
         return () => script.remove();
     }, [enabled]);

package/dist/products.d.ts

@@ -96,6 +96,11 @@ export declare function productMenuEntries(options?: {
     accountHref?: string | undefined;
     catalog?: ReadonlyArray<HgdcCatalogProduct> | undefined;
 }): Array<ProductMenuEntry>;
+/**
+ * Chemin de `href` s'il est servi sous `pageOrigin` (`/mail/auth/hgdc?…` depuis
+ * `https://app.hgdc.ch`), sinon `null`. Sans origine connue (rendu serveur), `null`.
+ */
+export declare function sameOriginPath(href: string, pageOrigin: string | undefined): string | null;
 /** Une entrée de la barre des produits d'`AppShell`. */
 export type ProductRailEntry = {
     name: string;
@@ -105,17 +110,27 @@ export type ProductRailEntry = {
     current?: boolean;
     /** Texte discret sous le nom : « Préversion ». */
     hint?: string;
+    /**
+     * Produit servi sous la même origine que la page : lien relatif, prérendu au survol
+     * (`PRODUCT_PRERENDER_ATTRIBUTE` de `@hgdc/ui/product-switch`) et transition de vue.
+     */
+    sameOrigin?: boolean;
 };
 /**
  * Les entrées de la barre des produits : les produits ouverts du catalogue et Account, affiché en
  * tête (le compte commun, pas un produit). Chaque produit pointe vers son entrée
  * `/auth/hgdc?refresh=background&next=/` (ADR 0010, 0013, 0016), Account vers sa racine (`accountHref` en
- * développement). Le produit courant pointe vers `/`, sans détour par l'entrée.
+ * développement). Le produit courant pointe vers sa racine, sans détour par l'entrée.
+ *
+ * `pageOrigin` (`location.origin`, absent au rendu serveur) : un produit servi sous cette origine
+ * (`PRODUCT_ORIGINS`, `app.hgdc.ch/<produit>`) reçoit un lien relatif et `sameOrigin` (ADR 0020),
+ * et le produit courant sa base (`/mail/`) plutôt que `/`.
  */
 export declare function productRailEntries(options?: {
     current?: string | undefined;
     accountHref?: string | undefined;
     catalog?: ReadonlyArray<HgdcCatalogProduct> | undefined;
+    pageOrigin?: string | undefined;
 }): {
     products: Array<ProductRailEntry>;
     account: ProductRailEntry;

package/dist/products.js

@@ -34,6 +34,7 @@ export const PRODUCT_ORIGINS = {
     analytics: { origin: "https://app.hgdc.ch", basePath: "/analytics" },
     mail: { origin: "https://app.hgdc.ch", basePath: "/mail" },
     host: { origin: "https://app.hgdc.ch", basePath: "/host" },
+    docs: { origin: "https://app.hgdc.ch", basePath: "/docs" },
 };
 /** Adresse de l'app d'un produit : celle de `PRODUCT_ORIGINS`, sinon `https://<mot>.hgdc.ch`. */
 export function productOrigin(word, origins = PRODUCT_ORIGINS) {
@@ -104,22 +105,49 @@ export function productMenuEntries(options = {}) {
         ...(item.stage === "preview" ? { hint: PRODUCT_STAGE_LABEL.preview } : {}),
     }));
 }
+/**
+ * Chemin de `href` s'il est servi sous `pageOrigin` (`/mail/auth/hgdc?…` depuis
+ * `https://app.hgdc.ch`), sinon `null`. Sans origine connue (rendu serveur), `null`.
+ */
+export function sameOriginPath(href, pageOrigin) {
+    if (!pageOrigin)
+        return null;
+    try {
+        const url = new URL(href);
+        return url.origin === pageOrigin ? `${url.pathname}${url.search}${url.hash}` : null;
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * Les entrées de la barre des produits : les produits ouverts du catalogue et Account, affiché en
  * tête (le compte commun, pas un produit). Chaque produit pointe vers son entrée
  * `/auth/hgdc?refresh=background&next=/` (ADR 0010, 0013, 0016), Account vers sa racine (`accountHref` en
- * développement). Le produit courant pointe vers `/`, sans détour par l'entrée.
+ * développement). Le produit courant pointe vers sa racine, sans détour par l'entrée.
+ *
+ * `pageOrigin` (`location.origin`, absent au rendu serveur) : un produit servi sous cette origine
+ * (`PRODUCT_ORIGINS`, `app.hgdc.ch/<produit>`) reçoit un lien relatif et `sameOrigin` (ADR 0020),
+ * et le produit courant sa base (`/mail/`) plutôt que `/`.
  */
 export function productRailEntries(options = {}) {
     const current = options.current?.toLowerCase();
-    const entry = (item, href) => ({
-        name: item.name,
-        badge: item.badge,
-        ...(item.badge === current ? { href: "/", current: true } : { href }),
-        ...(item.stage === "preview" ? { hint: PRODUCT_STAGE_LABEL.preview } : {}),
-    });
+    const { pageOrigin } = options;
+    const entry = (item, href, product) => {
+        const base = {
+            name: item.name,
+            badge: item.badge,
+            ...(item.stage === "preview" ? { hint: PRODUCT_STAGE_LABEL.preview } : {}),
+        };
+        if (item.badge === current) {
+            const app = productOrigin(item.badge);
+            return { ...base, href: pageOrigin === app.origin ? `${app.basePath}/` : "/", current: true };
+        }
+        const path = product ? sameOriginPath(href, pageOrigin) : null;
+        return path === null ? { ...base, href } : { ...base, href: path, sameOrigin: true };
+    };
     return {
-        products: (options.catalog ?? HGDC_PRODUCTS).filter(isProductOpen).map((item) => entry(item, item.entryHref)),
-        account: entry(HGDC_ACCOUNT, options.accountHref ?? HGDC_ACCOUNT.entryHref),
+        products: (options.catalog ?? HGDC_PRODUCTS).filter(isProductOpen).map((item) => entry(item, item.entryHref, true)),
+        account: entry(HGDC_ACCOUNT, options.accountHref ?? HGDC_ACCOUNT.entryHref, false),
     };
 }

package/dist/shell-frame.d.ts

@@ -0,0 +1,21 @@
+import { type FamilyProduct } from "./family-svg.ts";
+/** Nom affiché d'un produit de la famille (« Mail »), Account compris. */
+export declare function familyProductName(product: FamilyProduct): string;
+/** Haut de la barre latérale (marque du produit) : le même dans la coque et dans le cadre. */
+export declare const SIDEBAR_HEAD = "mt-2 flex h-14 shrink-0 items-center gap-1 px-3";
+export declare const SIDEBAR_BRAND = "flex min-w-0 flex-1 items-center gap-2.5 pl-2.25";
+export declare const SIDEBAR_BRAND_NAME = "truncate font-heading text-[0.9375rem] font-semibold";
+/** Même boîte qu'une entrée de la barre en rail : 40 × 36 px. */
+export declare const SIDEBAR_RAIL_BOX = "grid h-9 w-10 shrink-0 place-items-center rounded-xl";
+/**
+ * Le cadre de la coque, dessiné par le chargeur du document (`FamilyLoaderRoot`) quand une page
+ * attend hors de la coque : barre des produits complète (organisation retenue, pastilles, produit
+ * courant), barre latérale du produit (sa marque, la navigation en squelette à sa hauteur
+ * retenue), carte du contenu et sa barre du haut. Mêmes boîtes que la coque, au pixel : la
+ * transition de vue d'un produit à l'autre n'a rien à faire bouger, et la coque qui monte ensuite
+ * prend la place sans saut.
+ *
+ * Le produit vient de l'adresse (`<html data-hgdc-product>`, `sidebarInitScript`) : le rendu
+ * serveur dessine toutes les marques, le CSS montre la bonne.
+ */
+export declare function ShellFrame(): React.JSX.Element;

package/dist/shell-frame.js

@@ -0,0 +1,33 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { FAMILY_PRODUCTS } from "./family-svg.js";
+import { ProductBadge } from "./product-badge.js";
+import { ProductRailFrame } from "./product-rail.js";
+import { HGDC_ACCOUNT, HGDC_PRODUCTS } from "./products.js";
+/** Nom affiché d'un produit de la famille (« Mail »), Account compris. */
+export function familyProductName(product) {
+    if (product === HGDC_ACCOUNT.badge)
+        return HGDC_ACCOUNT.name;
+    return HGDC_PRODUCTS.find((item) => item.badge === product)?.name ?? `HGDC ${product}`;
+}
+/** Haut de la barre latérale (marque du produit) : le même dans la coque et dans le cadre. */
+export const SIDEBAR_HEAD = "mt-2 flex h-14 shrink-0 items-center gap-1 px-3";
+export const SIDEBAR_BRAND = "flex min-w-0 flex-1 items-center gap-2.5 pl-2.25";
+export const SIDEBAR_BRAND_NAME = "truncate font-heading text-[0.9375rem] font-semibold";
+/** Même boîte qu'une entrée de la barre en rail : 40 × 36 px. */
+export const SIDEBAR_RAIL_BOX = "grid h-9 w-10 shrink-0 place-items-center rounded-xl";
+/** Lignes de squelette de la navigation, coupées à la hauteur retenue (`--hgdc-nav-height`). */
+const SKELETON_ROWS = 12;
+/**
+ * Le cadre de la coque, dessiné par le chargeur du document (`FamilyLoaderRoot`) quand une page
+ * attend hors de la coque : barre des produits complète (organisation retenue, pastilles, produit
+ * courant), barre latérale du produit (sa marque, la navigation en squelette à sa hauteur
+ * retenue), carte du contenu et sa barre du haut. Mêmes boîtes que la coque, au pixel : la
+ * transition de vue d'un produit à l'autre n'a rien à faire bouger, et la coque qui monte ensuite
+ * prend la place sans saut.
+ *
+ * Le produit vient de l'adresse (`<html data-hgdc-product>`, `sidebarInitScript`) : le rendu
+ * serveur dessine toutes les marques, le CSS montre la bonne.
+ */
+export function ShellFrame() {
+    return (_jsxs("div", { "data-slot": "shell-frame", "aria-hidden": true, className: "hidden h-full lg:flex", children: [_jsx(ProductRailFrame, {}), _jsxs("div", { "data-slot": "shell-frame-sidebar", className: "flex w-64 shrink-0 flex-col overflow-hidden rail:w-16", children: [_jsx("div", { className: SIDEBAR_HEAD, children: FAMILY_PRODUCTS.map((product) => (_jsxs("div", { "data-product": product, className: "contents", children: [_jsxs("div", { className: `${SIDEBAR_BRAND} rail:hidden`, children: [_jsx(ProductBadge, { product: product, className: "size-6" }), _jsx("span", { className: SIDEBAR_BRAND_NAME, children: familyProductName(product) })] }), _jsx("div", { className: `${SIDEBAR_RAIL_BOX} hidden rail:grid`, children: _jsx(ProductBadge, { product: product, className: "size-6" }) })] }, product))) }), _jsx("div", { className: "px-3 py-2", children: _jsx("div", { "data-slot": "shell-frame-nav", className: "grid gap-0.5 overflow-hidden", children: Array.from({ length: SKELETON_ROWS }, (_, index) => (_jsxs("div", { className: "flex h-9 shrink-0 items-center gap-2.5 px-3 rail:justify-center rail:px-0", children: [_jsx("span", { className: "size-[1.125rem] shrink-0 rounded-md bg-shell-hover" }), _jsx("span", { className: "h-2.5 w-24 rounded-full bg-shell-hover rail:hidden" })] }, index))) }) })] }), _jsx("div", { className: "min-w-0 flex-1 py-2 pr-2", children: _jsx("div", { className: "h-full overflow-hidden rounded-xl bg-background", children: _jsx("div", { "data-slot": "shell-frame-header", className: "min-h-14 border-b border-foreground/5 bg-background" }) }) })] }));
+}

package/dist/shell-memory.d.ts

@@ -0,0 +1,65 @@
+/** Organisation affichée en dernier : `{ initials, logo? }`, en `localStorage`. */
+export declare const SHELL_ORG_KEY = "hgdc-shell:org";
+/** Hauteur en pixels de la navigation d'un produit : `hgdc-shell:nav:<produit>`. */
+export declare const SHELL_NAV_KEY_PREFIX = "hgdc-shell:nav:";
+/** Passage d'un produit à l'autre (horodatage), en `sessionStorage`. */
+export declare const SHELL_SWITCH_KEY = "hgdc-shell:switch";
+/** Au-delà, un passage noté n'est plus celui qu'on vit (onglet laissé, retour bien plus tard). */
+export declare const SHELL_SWITCH_MAX_AGE_MS = 10000;
+export type ShellOrganization = {
+    initials: string;
+    logo?: string;
+};
+export type ShellBootConfig = {
+    /** Clé du rail de la barre latérale (`sidebar`), valeur `rail`. */
+    railKey: string;
+    orgKey: string;
+    navKeyPrefix: string;
+    /** Les produits de la famille, par mot en minuscules. */
+    products: ReadonlyArray<string>;
+    /** `[produit, origine, base]` des produits servis sous une base de chemin (`PRODUCT_ORIGINS`). */
+    origins: ReadonlyArray<readonly [string, string, string]>;
+    /** Domaine des produits sur leur sous-domaine (`hgdc.ch` : `mail.hgdc.ch` est Mail). */
+    domain: string;
+};
+type BootWindow = {
+    document: {
+        documentElement: HTMLElement;
+    };
+    location: {
+        origin: string;
+        hostname: string;
+        pathname: string;
+    };
+    localStorage: Pick<Storage, "getItem">;
+};
+/**
+ * Applique la mémoire de la coque sur `<html>` : `data-sidebar="rail"`, `data-hgdc-product`
+ * (le produit de l'adresse), `data-hgdc-org` et les variables `--hgdc-org-initials`,
+ * `--hgdc-org-logo`, `--hgdc-nav-height` que lit `styles.css`. Autonome : sa source est recopiée
+ * telle quelle dans le script en ligne du `<head>`.
+ */
+export declare function shellBoot(config: ShellBootConfig, win: BootWindow): void;
+/** Configuration de la famille : les produits du kit et `PRODUCT_ORIGINS`. */
+export declare const SHELL_BOOT_CONFIG: ShellBootConfig;
+/** Le script en ligne du `<head>` : `shellBoot` et sa configuration, sans dépendance. */
+export declare function shellBootScript(config?: ShellBootConfig): string;
+/** Ce que la coque retient d'une organisation : ses initiales et son logo (`https:` seulement). */
+export declare function shellOrganization(org: {
+    name: string;
+    logo?: string | undefined;
+}): ShellOrganization;
+/** Retient l'organisation affichée (`OrgSwitcher` le fait) et l'applique à la page. */
+export declare function rememberShellOrganization(org: {
+    name: string;
+    logo?: string | undefined;
+}): void;
+/** Oublie l'organisation (déconnexion) : la page suivante montre un squelette. */
+export declare function forgetShellOrganization(): void;
+/** Retient la hauteur de la navigation d'un produit (`AppShell` le fait après l'affichage). */
+export declare function rememberShellNavHeight(product: string, height: number): void;
+/** Note le départ vers un autre produit (clic dans la barre des produits). */
+export declare function markProductSwitch(now?: number): void;
+/** Lit et efface la note : vrai si la page vient d'un passage depuis la barre, il y a peu. */
+export declare function takeProductSwitch(now?: number): boolean;
+export {};

package/dist/shell-memory.js

@@ -0,0 +1,169 @@
+import { initials } from "./initials.js";
+import { FAMILY_PRODUCTS } from "./family-svg.js";
+import { PRODUCT_ORIGINS } from "./products.js";
+/*
+ * Mémoire de la coque, partagée par les produits servis sous la même origine (`app.hgdc.ch/<produit>`,
+ * ADR 0020) : ce qu'il faut pour que la première image d'un produit ait déjà la barre des produits
+ * complète et la barre latérale à sa taille, avant que ses données n'arrivent.
+ *
+ * - l'organisation affichée en dernier : ses initiales et son logo (rien d'autre, pas le nom) ;
+ * - la hauteur de la navigation de chaque produit, pour un squelette à la bonne taille ;
+ * - le passage en cours d'un produit à l'autre (session de l'onglet), pour que la barre d'arrivée
+ *   ne s'élargisse pas sous une souris restée immobile.
+ *
+ * `shellBoot` applique la mémoire sur `<html>` avant la première peinture : il tourne en ligne
+ * dans le `<head>` (`sidebarInitScript`), donc il ne dépend de rien d'autre que de ses arguments.
+ */
+/** Organisation affichée en dernier : `{ initials, logo? }`, en `localStorage`. */
+export const SHELL_ORG_KEY = "hgdc-shell:org";
+/** Hauteur en pixels de la navigation d'un produit : `hgdc-shell:nav:<produit>`. */
+export const SHELL_NAV_KEY_PREFIX = "hgdc-shell:nav:";
+/** Passage d'un produit à l'autre (horodatage), en `sessionStorage`. */
+export const SHELL_SWITCH_KEY = "hgdc-shell:switch";
+/** Au-delà, un passage noté n'est plus celui qu'on vit (onglet laissé, retour bien plus tard). */
+export const SHELL_SWITCH_MAX_AGE_MS = 10_000;
+/**
+ * Applique la mémoire de la coque sur `<html>` : `data-sidebar="rail"`, `data-hgdc-product`
+ * (le produit de l'adresse), `data-hgdc-org` et les variables `--hgdc-org-initials`,
+ * `--hgdc-org-logo`, `--hgdc-nav-height` que lit `styles.css`. Autonome : sa source est recopiée
+ * telle quelle dans le script en ligne du `<head>`.
+ */
+export function shellBoot(config, win) {
+    // Ni fonction imbriquée ni import : un outil de construction n'a rien à y injecter.
+    const root = win.document.documentElement;
+    let rail = null;
+    let rawOrg = null;
+    try {
+        rail = win.localStorage.getItem(config.railKey);
+        rawOrg = win.localStorage.getItem(config.orgKey);
+    }
+    catch {
+        // Stockage bloqué : rien à reprendre.
+    }
+    if (rail === "rail")
+        root.dataset.sidebar = "rail";
+    let product = "";
+    for (const [word, origin, base] of config.origins) {
+        const path = win.location.pathname;
+        if (win.location.origin === origin && (path === base || path.startsWith(`${base}/`)))
+            product = word;
+    }
+    const host = win.location.hostname;
+    const suffix = `.${config.domain}`;
+    if (!product && host.endsWith(suffix)) {
+        const word = host.slice(0, -suffix.length);
+        if (config.products.includes(word))
+            product = word;
+    }
+    // La coque, une fois montée, sait mieux que l'adresse : on ne réécrit pas son produit.
+    if (product && !root.dataset.hgdcProduct)
+        root.dataset.hgdcProduct = product;
+    product = root.dataset.hgdcProduct ?? "";
+    let org = null;
+    try {
+        org = JSON.parse(rawOrg ?? "null");
+    }
+    catch {
+        org = null;
+    }
+    const letters = org && typeof org.initials === "string" ? org.initials.replace(/[^\p{L}\p{N}]/gu, "").slice(0, 4) : "";
+    const logo = org && typeof org.logo === "string" && org.logo.length < 2048 && /^https:\/\/[^\s"'()\\]+$/.test(org.logo)
+        ? org.logo
+        : "";
+    if (letters || logo) {
+        root.dataset.hgdcOrg = "";
+        root.style.setProperty("--hgdc-org-initials", logo ? '""' : `"${letters}"`);
+        if (logo)
+            root.style.setProperty("--hgdc-org-logo", `url("${logo}")`);
+        else
+            root.style.removeProperty("--hgdc-org-logo");
+    }
+    else {
+        delete root.dataset.hgdcOrg;
+        root.style.removeProperty("--hgdc-org-initials");
+        root.style.removeProperty("--hgdc-org-logo");
+    }
+    let height = 0;
+    try {
+        height = product ? Number(win.localStorage.getItem(config.navKeyPrefix + product)) : 0;
+    }
+    catch {
+        height = 0;
+    }
+    if (height > 0 && height < 2000)
+        root.style.setProperty("--hgdc-nav-height", `${Math.round(height)}px`);
+}
+/** Configuration de la famille : les produits du kit et `PRODUCT_ORIGINS`. */
+export const SHELL_BOOT_CONFIG = {
+    railKey: "sidebar",
+    orgKey: SHELL_ORG_KEY,
+    navKeyPrefix: SHELL_NAV_KEY_PREFIX,
+    products: FAMILY_PRODUCTS,
+    origins: Object.entries(PRODUCT_ORIGINS).map(([word, { origin, basePath }]) => [word, origin, basePath]),
+    domain: "hgdc.ch",
+};
+/** Le script en ligne du `<head>` : `shellBoot` et sa configuration, sans dépendance. */
+export function shellBootScript(config = SHELL_BOOT_CONFIG) {
+    return `try{(${shellBoot.toString()})(${JSON.stringify(config)},window)}catch(e){}`;
+}
+function browser() {
+    return typeof window === "undefined" ? null : window;
+}
+function storageSet(storage, key, value) {
+    try {
+        if (value === null)
+            window[storage].removeItem(key);
+        else
+            window[storage].setItem(key, value);
+    }
+    catch {
+        // Stockage bloqué : la première image d'un autre produit montrera un squelette, rien de plus.
+    }
+}
+/** Ce que la coque retient d'une organisation : ses initiales et son logo (`https:` seulement). */
+export function shellOrganization(org) {
+    return { initials: initials(org.name), ...(org.logo ? { logo: org.logo } : {}) };
+}
+/** Retient l'organisation affichée (`OrgSwitcher` le fait) et l'applique à la page. */
+export function rememberShellOrganization(org) {
+    const win = browser();
+    if (!win)
+        return;
+    storageSet("localStorage", SHELL_ORG_KEY, JSON.stringify(shellOrganization(org)));
+    shellBoot(SHELL_BOOT_CONFIG, win);
+}
+/** Oublie l'organisation (déconnexion) : la page suivante montre un squelette. */
+export function forgetShellOrganization() {
+    const win = browser();
+    if (!win)
+        return;
+    storageSet("localStorage", SHELL_ORG_KEY, null);
+    shellBoot(SHELL_BOOT_CONFIG, win);
+}
+/** Retient la hauteur de la navigation d'un produit (`AppShell` le fait après l'affichage). */
+export function rememberShellNavHeight(product, height) {
+    if (!browser() || !(height > 0))
+        return;
+    storageSet("localStorage", SHELL_NAV_KEY_PREFIX + product, String(Math.round(height)));
+}
+/** Note le départ vers un autre produit (clic dans la barre des produits). */
+export function markProductSwitch(now = Date.now()) {
+    if (!browser())
+        return;
+    storageSet("sessionStorage", SHELL_SWITCH_KEY, String(now));
+}
+/** Lit et efface la note : vrai si la page vient d'un passage depuis la barre, il y a peu. */
+export function takeProductSwitch(now = Date.now()) {
+    if (!browser())
+        return false;
+    let value = null;
+    try {
+        value = window.sessionStorage.getItem(SHELL_SWITCH_KEY);
+        window.sessionStorage.removeItem(SHELL_SWITCH_KEY);
+    }
+    catch {
+        return false;
+    }
+    const at = Number(value);
+    return value !== null && at > 0 && now - at >= 0 && now - at < SHELL_SWITCH_MAX_AGE_MS;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hgdc/ui",
-  "version": "0.37.0",
+  "version": "0.39.0",
   "description": "Interface de la H Collection : jetons de la DA, thèmes, polices et composants.",
   "license": "UNLICENSED",
   "homepage": "https://github.com/hugogebel-boop/hgdc-kit/tree/main/packages/ui#readme",