@agence-zef/astro 0.2.0 → 0.3.1

package/dist/accounts.d.ts

@@ -0,0 +1,65 @@
+import type { CustomFields } from "@agence-zef/schema";
+import { type ApiAccount, type ApiAccountSession, type ApiAccountsSettings, type Visitor } from "@agence-zef/sdk";
+import type { AstroCookies } from "astro";
+/** Cookie httpOnly qui garde le jeton de session. */
+export declare const ACCOUNT_COOKIE = "zef_account";
+/** Cookie d'une minute qui porte le message d'un refus (validation du sur-mesure). */
+export declare const MESSAGE_COOKIE = "zef_account_message";
+/** Ce dont les helpers ont besoin du contexte d'Astro (`Astro` ou le contexte d'un endpoint). */
+export type AccountContext = {
+    cookies: AstroCookies;
+    request: Request;
+    url: URL;
+    clientAddress?: string;
+};
+/** Actions des formulaires de compte (`<AccountForm action>`, `/__zef/account/<action>`). */
+export declare const ACCOUNT_ACTIONS: readonly ["sign-in", "sign-up", "sign-out", "forgot-password", "reset-password", "profile", "resend-verification", "delete"];
+export type AccountAction = (typeof ACCOUNT_ACTIONS)[number];
+export declare const isAccountAction: (value: string) => value is AccountAction;
+/** Messages affichés par `<AccountForm>` après une erreur (`?zef_error=<code>`). */
+export declare const ACCOUNT_ERRORS: Record<string, string>;
+/** Messages affichés après une action réussie qui reste sur la page (`?zef_ok=<action>`). */
+export declare const ACCOUNT_SUCCESS: Partial<Record<AccountAction, string>>;
+/** Réglages publics du module, gardés une minute ; `null` s'il n'est pas activé. */
+export declare function getAccountsSettings(): Promise<ApiAccountsSettings | null>;
+/** Session et adresse IP à relayer au CMS. */
+export declare function visitorOf(ctx: AccountContext): Visitor;
+export declare function setAccountSession(ctx: AccountContext, session: ApiAccountSession["session"]): void;
+export declare function clearAccountSession(ctx: AccountContext): void;
+/**
+ * Compte de la personne connectée, ou `null` : une seule lecture au CMS par requête. Une session
+ * expirée efface le cookie. À appeler dans une page rendue à la demande.
+ */
+export declare function getAccount(ctx: AccountContext): Promise<ApiAccount | null>;
+/**
+ * Page de vérification (lien reçu par email, `?token=…`) : confirme l'adresse.
+ * `{ ok: false, code: "invalid_token" }` si le lien a déjà servi ou a expiré.
+ */
+export declare function verifyEmailFromUrl(ctx: AccountContext): Promise<{
+    ok: true;
+    account: ApiAccount;
+} | {
+    ok: false;
+    code: string;
+    message: string;
+}>;
+/** Chemin interne seulement (pas de redirection vers un autre site). */
+export declare function safePath(value: unknown, fallback: string): string;
+/**
+ * Valeurs des champs personnalisés envoyées par `<AccountForm>` (`custom.<champ>`), converties
+ * selon leur type ; seuls les champs listés dans `zef_custom` (affichés) sont envoyés, une case
+ * décochée valant `false` et aucune case cochée une liste vide.
+ */
+export declare function customFromForm(form: FormData, fields?: CustomFields): Record<string, unknown> | undefined;
+/**
+ * Traite l'envoi d'un formulaire de compte et renvoie l'adresse où rediriger : `redirect` après
+ * un succès, sinon la page du formulaire avec `?zef_ok=<action>` ou `?zef_error=<code>&zef_form=<action>`.
+ */
+export declare function handleAccountForm(ctx: AccountContext, action: AccountAction, form: FormData, 
+/** Champs personnalisés du compte (`defineFields` de `zef.config.ts`). */
+customFields?: CustomFields): Promise<string>;
+/**
+ * Le chemin est-il protégé par l'option `accounts.protect` ? Chaque entrée est un chemin exact
+ * (`/compte`) ou, terminée par `/*`, tout ce qui est en dessous (`/compte/commandes/*`).
+ */
+export declare function isProtected(pathname: string, patterns: string[]): boolean;

package/dist/accounts.js

@@ -0,0 +1,301 @@
+import { ZefApiError, } from "@agence-zef/sdk";
+import { getClient } from "./helpers.js";
+/*
+ * Module Comptes côté site (§ 7 U, lot 14c3) : la session d'une personne est un jeton gardé dans
+ * un cookie httpOnly du site et relayé au CMS par le serveur du site. Les pages de compte sont
+ * rendues à la demande (`export const prerender = false`) ; les formulaires (`<AccountForm>`)
+ * s'envoient sans JavaScript à `/__zef/account/<action>`.
+ */
+/** Cookie httpOnly qui garde le jeton de session. */
+export const ACCOUNT_COOKIE = "zef_account";
+/** Cookie d'une minute qui porte le message d'un refus (validation du sur-mesure). */
+export const MESSAGE_COOKIE = "zef_account_message";
+/** Actions des formulaires de compte (`<AccountForm action>`, `/__zef/account/<action>`). */
+export const ACCOUNT_ACTIONS = [
+    "sign-in",
+    "sign-up",
+    "sign-out",
+    "forgot-password",
+    "reset-password",
+    "profile",
+    "resend-verification",
+    "delete",
+];
+export const isAccountAction = (value) => ACCOUNT_ACTIONS.includes(value);
+/** Messages affichés par `<AccountForm>` après une erreur (`?zef_error=<code>`). */
+export const ACCOUNT_ERRORS = {
+    invalid: "Vérifiez les champs du formulaire.",
+    invalid_credentials: "Email ou mot de passe incorrect.",
+    invalid_token: "Ce lien n'est plus valable. Demandez-en un nouveau.",
+    email_taken: "Un compte existe déjà avec cette adresse. Connectez-vous.",
+    turnstile: "La vérification anti-robot a échoué. Réessayez.",
+    locked: "Trop d'essais : le compte est bloqué 15 minutes.",
+    too_many_requests: "Trop d'essais. Réessayez dans un instant.",
+    unauthenticated: "Votre session a expiré. Connectez-vous à nouveau.",
+    refused: "Inscription refusée.",
+    module_inactive: "Les comptes ne sont pas disponibles sur ce site.",
+    invalid_url: "Lien de retour refusé par le CMS.",
+    unknown: "Une erreur est survenue. Réessayez dans un instant.",
+};
+/** Messages affichés après une action réussie qui reste sur la page (`?zef_ok=<action>`). */
+export const ACCOUNT_SUCCESS = {
+    "forgot-password": "Si un compte existe avec cette adresse, un lien pour choisir un nouveau mot de passe vient de lui être envoyé.",
+    "reset-password": "Mot de passe enregistré. Vous pouvez vous connecter.",
+    profile: "Vos informations sont enregistrées.",
+    "resend-verification": "Un nouveau lien de vérification vient de vous être envoyé.",
+};
+/* ---------- Réglages du module (U-03), lus dans `GET /site` ---------- */
+let cached;
+/** Réglages publics du module, gardés une minute ; `null` s'il n'est pas activé. */
+export async function getAccountsSettings() {
+    if (cached && Date.now() - cached.at < 60_000)
+        return cached.value;
+    const value = (await getClient().site()).accounts ?? null;
+    cached = { at: Date.now(), value };
+    return value;
+}
+/* ---------- Session ---------- */
+/** Adresse IP du visiteur (absente pendant le build). */
+function ipOf(ctx) {
+    try {
+        return ctx.clientAddress ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Session et adresse IP à relayer au CMS. */
+export function visitorOf(ctx) {
+    return { session: ctx.cookies.get(ACCOUNT_COOKIE)?.value ?? null, ip: ipOf(ctx) };
+}
+export function setAccountSession(ctx, session) {
+    ctx.cookies.set(ACCOUNT_COOKIE, session.token, {
+        path: "/",
+        httpOnly: true,
+        sameSite: "lax",
+        secure: ctx.url.protocol === "https:",
+        expires: new Date(session.expiresAt),
+    });
+}
+export function clearAccountSession(ctx) {
+    ctx.cookies.delete(ACCOUNT_COOKIE, { path: "/" });
+}
+const current = new WeakMap();
+/**
+ * Compte de la personne connectée, ou `null` : une seule lecture au CMS par requête. Une session
+ * expirée efface le cookie. À appeler dans une page rendue à la demande.
+ */
+export function getAccount(ctx) {
+    const known = current.get(ctx.request);
+    if (known)
+        return known;
+    const visitor = visitorOf(ctx);
+    const promise = visitor.session
+        ? getClient()
+            .accounts.me(visitor)
+            .then((account) => {
+            if (!account)
+                clearAccountSession(ctx);
+            return account;
+        })
+        : Promise.resolve(null);
+    current.set(ctx.request, promise);
+    return promise;
+}
+/**
+ * Page de vérification (lien reçu par email, `?token=…`) : confirme l'adresse.
+ * `{ ok: false, code: "invalid_token" }` si le lien a déjà servi ou a expiré.
+ */
+export async function verifyEmailFromUrl(ctx) {
+    const token = ctx.url.searchParams.get("token");
+    if (!token)
+        return failure("invalid_token");
+    try {
+        const { account } = await getClient().accounts.verify(token);
+        return { ok: true, account };
+    }
+    catch (error) {
+        return failure(errorCode(error));
+    }
+}
+/**
+ * Code d'une erreur de l'API (`ZefApiError`), sans `instanceof` : Vite peut charger deux copies
+ * du SDK. Une autre erreur est journalisée et devient `unknown`.
+ */
+function errorCode(error) {
+    if (error instanceof ZefApiError)
+        return error.code;
+    if (error && typeof error === "object" && "code" in error && "status" in error) {
+        return String(error.code);
+    }
+    console.error("[@agence-zef/astro] accounts :", error);
+    return "unknown";
+}
+const failure = (code) => ({
+    ok: false,
+    code,
+    message: ACCOUNT_ERRORS[code] ?? ACCOUNT_ERRORS.unknown,
+});
+/* ---------- Formulaires (`/__zef/account/<action>`) ---------- */
+/** Chemin interne seulement (pas de redirection vers un autre site). */
+export function safePath(value, fallback) {
+    return typeof value === "string" && value.startsWith("/") && !value.startsWith("//")
+        ? value
+        : fallback;
+}
+/**
+ * Page du site qui reçoit un lien d'email, passée au CMS quand le site tourne en local ou sur un
+ * aperçu Vercel ; en ligne, le CMS prend celle de U-03 sur le domaine public.
+ */
+function linkUrl(ctx, path) {
+    if (!path)
+        return undefined;
+    const host = ctx.url.hostname;
+    const local = host === "localhost" || host === "127.0.0.1" || host.endsWith(".vercel.app");
+    return local ? new URL(path, ctx.url.origin).toString() : undefined;
+}
+/**
+ * Valeurs des champs personnalisés envoyées par `<AccountForm>` (`custom.<champ>`), converties
+ * selon leur type ; seuls les champs listés dans `zef_custom` (affichés) sont envoyés, une case
+ * décochée valant `false` et aucune case cochée une liste vide.
+ */
+export function customFromForm(form, fields = {}) {
+    const shown = String(form.get("zef_custom") ?? "")
+        .split(",")
+        .filter((k) => fields[k]);
+    if (!shown.length)
+        return undefined;
+    const values = {};
+    for (const key of shown) {
+        const field = fields[key];
+        const raw = form.getAll(`custom.${key}`).map((v) => (typeof v === "string" ? v.trim() : ""));
+        const one = raw[0] ?? "";
+        if (field.type === "boolean")
+            values[key] = one === "1";
+        else if (field.type === "select" && field.multiple)
+            values[key] = raw.filter(Boolean);
+        else if (field.type === "number")
+            values[key] = one === "" ? null : Number(one);
+        else
+            values[key] = one === "" ? null : one;
+    }
+    return values;
+}
+const text = (form, name) => {
+    const value = form.get(name);
+    return typeof value === "string" ? value.trim() : "";
+};
+/**
+ * Traite l'envoi d'un formulaire de compte et renvoie l'adresse où rediriger : `redirect` après
+ * un succès, sinon la page du formulaire avec `?zef_ok=<action>` ou `?zef_error=<code>&zef_form=<action>`.
+ */
+export async function handleAccountForm(ctx, action, form, 
+/** Champs personnalisés du compte (`defineFields` de `zef.config.ts`). */
+customFields) {
+    const referer = ctx.request.headers.get("referer");
+    const refererPath = referer ? new URL(referer).pathname : "/";
+    const page = safePath(form.get("zef_page"), refererPath);
+    const redirect = safePath(form.get("zef_redirect"), "");
+    const back = (key, value, message) => {
+        const url = new URL(page, ctx.url.origin);
+        // Refus d'une validation du sur-mesure : son message passe par un cookie de courte durée
+        // (jamais par l'adresse, qu'on pourrait forger pour afficher n'importe quoi sur le site).
+        if (message) {
+            ctx.cookies.set(MESSAGE_COOKIE, message.slice(0, 300), {
+                path: "/",
+                httpOnly: true,
+                sameSite: "lax",
+                secure: ctx.url.protocol === "https:",
+                maxAge: 60,
+            });
+        }
+        url.searchParams.set(key, value);
+        // Plusieurs formulaires sur une page : l'erreur ne s'affiche que sous celui envoyé.
+        if (key === "zef_error")
+            url.searchParams.set("zef_form", action);
+        if (redirect)
+            url.searchParams.set("redirect", redirect);
+        if (action === "reset-password" && key === "zef_error" && text(form, "token")) {
+            url.searchParams.set("token", text(form, "token"));
+        }
+        return `${url.pathname}${url.search}`;
+    };
+    const accounts = getClient().accounts;
+    const visitor = visitorOf(ctx);
+    const settings = await getAccountsSettings().catch(() => null);
+    try {
+        switch (action) {
+            case "sign-in": {
+                const { session } = await accounts.signIn(text(form, "email"), String(form.get("password") ?? ""), visitor);
+                setAccountSession(ctx, session);
+                return redirect || "/";
+            }
+            case "sign-up": {
+                const phone = text(form, "phone");
+                const { session } = await accounts.register({
+                    email: text(form, "email"),
+                    password: String(form.get("password") ?? ""),
+                    firstName: text(form, "firstName"),
+                    lastName: text(form, "lastName"),
+                    phone: phone || null,
+                    turnstileToken: text(form, "cf-turnstile-response"),
+                    verifyUrl: linkUrl(ctx, settings?.pages.verification),
+                    custom: customFromForm(form, customFields),
+                }, visitor);
+                setAccountSession(ctx, session);
+                return redirect || "/";
+            }
+            case "sign-out": {
+                if (visitor.session)
+                    await accounts.signOut(visitor).catch(() => undefined);
+                clearAccountSession(ctx);
+                return redirect || "/";
+            }
+            case "forgot-password": {
+                await accounts.requestPasswordReset(text(form, "email"), linkUrl(ctx, settings?.pages.password), visitor);
+                return back("zef_ok", action);
+            }
+            case "reset-password": {
+                await accounts.resetPassword(text(form, "token"), String(form.get("password") ?? ""), visitor);
+                clearAccountSession(ctx);
+                return redirect || back("zef_ok", action);
+            }
+            case "profile": {
+                const phone = form.has("phone") ? text(form, "phone") || null : undefined;
+                await accounts.updateMe({
+                    firstName: text(form, "firstName") || undefined,
+                    lastName: text(form, "lastName") || undefined,
+                    email: text(form, "email") || undefined,
+                    ...(phone !== undefined ? { phone } : {}),
+                    verifyUrl: linkUrl(ctx, settings?.pages.verification),
+                    custom: customFromForm(form, customFields),
+                }, visitor);
+                return redirect || back("zef_ok", action);
+            }
+            case "resend-verification": {
+                await accounts.resendVerification(visitor, linkUrl(ctx, settings?.pages.verification));
+                return back("zef_ok", action);
+            }
+            case "delete": {
+                await accounts.deleteMe(String(form.get("password") ?? ""), visitor);
+                clearAccountSession(ctx);
+                return redirect || "/";
+            }
+        }
+    }
+    catch (error) {
+        const code = errorCode(error);
+        if (code === "unauthenticated")
+            clearAccountSession(ctx);
+        const message = code === "refused" ? error.message : undefined;
+        return back("zef_error", code, message);
+    }
+}
+/**
+ * Le chemin est-il protégé par l'option `accounts.protect` ? Chaque entrée est un chemin exact
+ * (`/compte`) ou, terminée par `/*`, tout ce qui est en dessous (`/compte/commandes/*`).
+ */
+export function isProtected(pathname, patterns) {
+    const path = pathname.length > 1 ? pathname.replace(/\/$/, "") : pathname;
+    return patterns.some((p) => p.endsWith("/*") ? path.startsWith(p.slice(0, -1)) || path === p.slice(0, -2) : path === p);
+}

package/dist/helpers.d.ts

@@ -37,6 +37,15 @@ export type RouteProps = LayoutProps & ({
     collection: string;
     item: ApiItem;
 });
+/**
+ * Props du gabarit pour une page codée dans le site (`src/pages/…`, ex. les pages de compte) :
+ * site, header et footer du CMS, titre ; `noindex` par défaut (pages privées).
+ */
+export declare function zefLayoutProps(opts: {
+    title: string;
+    locale?: string;
+    noindex?: boolean;
+}): Promise<LayoutProps>;
 /** Toutes les routes du site : pages publiées, puis éléments des collections avec page. */
 export declare function zefStaticPaths(config: ZefConfig): Promise<{
     params: {

package/dist/helpers.js

@@ -17,6 +17,31 @@ export const getSite = () => getClient().site();
 export const getPage = (url) => getClient().page(url);
 export const getCollection = (name, opts) => getClient().collection(name, opts);
 export const getItem = (name, slug, opts) => getClient().item(name, slug, opts);
+/**
+ * Props du gabarit pour une page codée dans le site (`src/pages/…`, ex. les pages de compte) :
+ * site, header et footer du CMS, titre ; `noindex` par défaut (pages privées).
+ */
+export async function zefLayoutProps(opts) {
+    const api = getClient();
+    const site = await api.site();
+    const locale = opts.locale ?? site.defaultLocale;
+    const layout = await api.layout({ locale });
+    return {
+        site,
+        locale,
+        title: opts.title,
+        seo: {
+            title: null,
+            description: null,
+            noindex: opts.noindex ?? true,
+            canonical: null,
+            image: null,
+        },
+        alternates: {},
+        header: layout?.header ?? null,
+        footer: layout?.footer ?? null,
+    };
+}
 const toParam = (url) => url.replace(/^\/+|\/+$/g, "") || undefined;
 /** Toutes les routes du site : pages publiées, puis éléments des collections avec page. */
 export async function zefStaticPaths(config) {
@@ -27,7 +52,8 @@ export async function zefStaticPaths(config) {
     for (const entry of await api.pages()) {
         for (const [locale, url] of Object.entries(entry.urls)) {
             const page = await api.page(url);
-            if (!page)
+            // Contenu réservé : rendu à la demande avec la session du compte (`/[...zefReserved]`).
+            if (!page || page.access?.reserved)
                 continue;
             paths.push({
                 params: { path: toParam(url) },
@@ -53,7 +79,7 @@ export async function zefStaticPaths(config) {
         })));
         for (const { locale, list } of byLocale) {
             for (const item of list.items) {
-                if (!item.url)
+                if (!item.url || item.access?.reserved)
                     continue;
                 const alternates = {};
                 for (const other of byLocale) {

package/dist/index.d.ts

@@ -1,5 +1,8 @@
 import type { AstroIntegration } from "astro";
+export type { ApiAccount, ApiCart, ApiCheckout, ApiItem, ApiOrder, ApiProduct, ApiProductMedia, ApiProductVariant, } from "@agence-zef/sdk";
+export * from "./accounts.js";
 export * from "./helpers.js";
+export * from "./shop.js";
 export type ZefOptions = {
     /** Gabarit des pages du CMS (en-tête, pied, styles du site). */
     layout?: string;
@@ -9,6 +12,25 @@ export type ZefOptions = {
      * (MinIO en local : `http://localhost:9000`).
      */
     mediaUrls?: string[];
+    /**
+     * Module Comptes (§ 7 U) : route des formulaires `<AccountForm>` (`/__zef/account/<action>`)
+     * et middleware qui renvoie vers `signIn` (« /compte/connexion » par défaut) les pages de
+     * `protect` (chemins exacts, ou `/…/*` pour tout un dossier, ex. `["/compte"]`) tant que personne n'est connecté. Demande un
+     * adaptateur (pages de compte rendues à la demande).
+     */
+    accounts?: {
+        signIn?: string;
+        protect?: string[];
+    };
+    /**
+     * Boutique (§ 7 M) : route des formulaires du panier et du paiement (`/__zef/shop/<action>`)
+     * et adresses des pages du site (panier, paiement, confirmation). Demande l'option `accounts`.
+     */
+    shop?: {
+        cart?: string;
+        checkout?: string;
+        confirmation?: string;
+    };
 };
 /**
  * Intégration Astro du CMS ZEF (cahier des charges § 10) : route attrape-tout des pages

package/dist/index.js

@@ -3,7 +3,9 @@ import { join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { loadZefEnv } from "./env.js";
 import { getClient } from "./helpers.js";
+export * from "./accounts.js";
 export * from "./helpers.js";
+export * from "./shop.js";
 const MEDIA_URL = "https://medias.agence-zef.fr";
 /** Domaines autorisés pour l'optimisation des images distantes (`image.remotePatterns`). */
 function mediaPatterns(urls) {
@@ -27,6 +29,8 @@ const VIRTUAL = {
     config: "virtual:zef/config",
     sections: "virtual:zef/sections",
     layout: "virtual:zef/layout",
+    accounts: "virtual:zef/accounts",
+    shop: "virtual:zef/shop",
 };
 /** `{ hero: "/…/src/sections/hero/index.astro" }` pour chaque dossier de `src/sections`. */
 function sectionFiles(root) {
@@ -53,7 +57,7 @@ export default function zef(options = {}) {
     return {
         name: "@agence-zef/astro",
         hooks: {
-            "astro:config:setup": async ({ config, command, injectRoute, updateConfig, addWatchFile, logger, }) => {
+            "astro:config:setup": async ({ config, command, injectRoute, updateConfig, addWatchFile, addMiddleware, logger, }) => {
                 const root = fileURLToPath(config.root);
                 loadZefEnv(root);
                 // Redirections du CMS (C-17 : slugs modifiés, pages déplacées, redirections manuelles).
@@ -113,6 +117,38 @@ export default function zef(options = {}) {
                 else {
                     logger.info("pas d'adaptateur : la route d'aperçu de l'éditeur n'est pas construite");
                 }
+                // Contenu réservé (lot 14e5c) : les adresses que la route statique n'a pas générées
+                // (pages et éléments réservés) sont rendues à la demande, avec la session du compte.
+                if (options.shop && (command === "dev" || config.adapter)) {
+                    injectRoute({
+                        pattern: "/[...zefReserved]",
+                        entrypoint: "@agence-zef/astro/routes/reserved.astro",
+                        prerender: false,
+                    });
+                }
+                // Module Comptes : formulaires et pages protégées, rendus à la demande.
+                const signIn = options.accounts?.signIn ?? "/compte/connexion";
+                const protect = (options.accounts?.protect ?? []).filter((p) => p !== signIn);
+                if (options.accounts) {
+                    if (command === "dev" || config.adapter) {
+                        injectRoute({
+                            pattern: "/__zef/account/[action]",
+                            entrypoint: "@agence-zef/astro/routes/account.ts",
+                            prerender: false,
+                        });
+                        addMiddleware({ entrypoint: "@agence-zef/astro/middleware", order: "pre" });
+                        if (options.shop) {
+                            injectRoute({
+                                pattern: "/__zef/shop/[action]",
+                                entrypoint: "@agence-zef/astro/routes/shop.ts",
+                                prerender: false,
+                            });
+                        }
+                    }
+                    else {
+                        logger.warn("option accounts sans adaptateur : les formulaires de compte ne sont pas construits");
+                    }
+                }
                 updateConfig({
                     vite: {
                         plugins: [
@@ -133,6 +169,17 @@ export default function zef(options = {}) {
                                     }
                                     if (id === `\0${VIRTUAL.sections}`)
                                         return importMap(sectionFiles(root));
+                                    if (id === `\0${VIRTUAL.shop}`) {
+                                        return `export default ${JSON.stringify({
+                                            cart: options.shop?.cart ?? "/panier",
+                                            checkout: options.shop?.checkout ?? "/paiement",
+                                            confirmation: options.shop?.confirmation ?? "/commande",
+                                            signIn,
+                                        })};`;
+                                    }
+                                    if (id === `\0${VIRTUAL.accounts}`) {
+                                        return `export default ${JSON.stringify({ signIn, protect })};`;
+                                    }
                                     return undefined;
                                 },
                             },

package/dist/middleware.d.ts

@@ -0,0 +1,7 @@
+import type { MiddlewareHandler } from "astro";
+/**
+ * Middleware ajouté par l'option `accounts` de l'intégration : une page protégée
+ * (`accounts.protect`) rendue à la demande renvoie vers la page de connexion
+ * (`accounts.signIn`, avec `?redirect=`) tant que personne n'est connecté.
+ */
+export declare const onRequest: MiddlewareHandler;

package/dist/middleware.js

@@ -0,0 +1,20 @@
+import options from "virtual:zef/accounts";
+import { getAccount, isProtected } from "./accounts.js";
+/**
+ * Middleware ajouté par l'option `accounts` de l'intégration : une page protégée
+ * (`accounts.protect`) rendue à la demande renvoie vers la page de connexion
+ * (`accounts.signIn`, avec `?redirect=`) tant que personne n'est connecté.
+ */
+export const onRequest = async (context, next) => {
+    const { pathname, search } = context.url;
+    if (context.isPrerendered ||
+        pathname === options.signIn ||
+        !isProtected(pathname, options.protect)) {
+        return next();
+    }
+    if (await getAccount(context))
+        return next();
+    const to = new URL(options.signIn, context.url.origin);
+    to.searchParams.set("redirect", `${pathname}${search}`);
+    return context.redirect(`${to.pathname}${to.search}`, 303);
+};

package/dist/overlay.js

@@ -127,6 +127,8 @@ export function startOverlay() {
 		#zef-overlay .zef-frame { position: fixed; border: 1.5px solid #8c40f7; border-radius: 2px; }
 		#zef-overlay .zef-frame.zef-section { border-style: dashed; border-color: #8c40f7aa; }
 		#zef-overlay .zef-frame.zef-selected { border-width: 2px; }
+		#zef-overlay .zef-frame.zef-field { border: 1.5px solid #8c40f7; border-radius: 3px; background: #8c40f70d; }
+		#zef-overlay .zef-frame.zef-field .zef-tag { padding: 1px 5px; font-size: 10px; }
 		#zef-overlay .zef-tag { position: absolute; left: -1.5px; bottom: 100%; margin-bottom: 2px; padding: 2px 6px; border-radius: 4px; background: #8c40f7; color: #fff; white-space: nowrap; }
 		#zef-overlay .zef-compare { border: 2px solid #ea580c; }
 		#zef-overlay .zef-compare .zef-tag { left: 8px; top: 8px; bottom: auto; margin: 0; background: #fff7ed; color: #c2410c; }
@@ -283,6 +285,11 @@ export function startOverlay() {
             if (wrapper)
                 insertLine(section, rect(wrapper));
         }
+        // Champ survolé (titre, texte, bouton, image) : cadre et libellé ; un clic l'ouvre dans le
+        // panneau de droite.
+        const field = target && !editing ? target.closest(`[${ATTR}]`) : null;
+        if (field && field !== editing)
+            frame(rect(field), "zef-field", info(field)?.label);
     }
     let frameRequest = 0;
     const redraw = () => {
@@ -335,9 +342,10 @@ export function startOverlay() {
             });
             return;
         }
-        // Un clic choisit toute la section (ou l'élément de collection pour ses propres champs).
+        // Un clic choisit toute la section (ou l'élément de collection pour ses propres champs) et
+        // désigne le champ cliqué, que l'éditeur ouvre et met au premier plan dans son panneau.
         selected = { section: location?.scope === "@" ? "@" : section, path: null };
-        post({ zef: "select", ...selected });
+        post({ zef: "select", ...selected, path: location?.path ?? null });
         redraw();
     }, true);
     document.addEventListener("submit", (e) => e.preventDefault(), true);