@agence-zef/astro 0.0.0-stage → 0.2.0

package/components/Popups.astro

@@ -0,0 +1,210 @@
+---
+/**
+ * Popups du site (C-11, C-12), sans style imposé : lues à l'exécution au CMS (activer ou
+ * modifier une popup ne demande pas de reconstruire le site). Ciblage (pages, langues,
+ * appareils), déclenchement, fréquence et priorité appliqués dans le navigateur ; une
+ * seule popup automatique à la fois. Les boutons `data-zef-popup` (destination « Popup »)
+ * ouvrent la leur. Rendu : `<dialog class="zef-popup" data-layout="…">` à habiller en CSS.
+ * À placer une fois dans le gabarit, avant `</body>`.
+ */
+const cms = (process.env.ZEF_URL ?? "").replace(/\/$/, "");
+const locale = Astro.currentLocale ?? "";
+---
+
+{cms && <div data-zef-popups={`${cms}/api/public/popups`} data-locale={locale} hidden />}
+
+<script>
+	type Button = {
+		label: string;
+		href: string | null;
+		target: string | null;
+		download: boolean;
+		popup: string | null;
+		variant: string | null;
+	};
+	type Popup = {
+		id: string;
+		layout: string;
+		trigger: { type: "load" | "delay" | "scroll" | "exit" | "click"; delay?: number; scroll?: number };
+		frequency: { type: "page" | "session" | "days" | "once"; days?: number };
+		devices: "all" | "desktop" | "mobile";
+		pages: { mode: "all" | "include" | "exclude"; urls: string[] };
+		locales: string[];
+		content: Record<
+			string,
+			{ titre: string; texte: string; image: { url: string; alt: string } | null; boutons: Button[] }
+		>;
+	};
+
+	const KEY = "zef-popups";
+	const store = {
+		read(storage: Storage): Record<string, number> {
+			try {
+				return JSON.parse(storage.getItem(KEY) ?? "{}");
+			} catch {
+				return {};
+			}
+		},
+		write(storage: Storage, id: string) {
+			try {
+				storage.setItem(KEY, JSON.stringify({ ...store.read(storage), [id]: Date.now() }));
+			} catch {
+				// Navigation privée : la fréquence ne tient que pour la page.
+			}
+		},
+	};
+
+	/** La fréquence autorise-t-elle encore la popup ? */
+	function allowed(p: Popup) {
+		const f = p.frequency;
+		if (f.type === "page") return true;
+		if (f.type === "session") return !store.read(sessionStorage)[p.id];
+		const last = store.read(localStorage)[p.id];
+		if (!last) return true;
+		if (f.type === "once") return false;
+		return Date.now() - last > (f.days ?? 1) * 86_400_000;
+	}
+
+	function targeted(p: Popup, locale: string, path: string) {
+		const mobile = matchMedia("(max-width: 767px)").matches;
+		if (p.devices === "mobile" && !mobile) return false;
+		if (p.devices === "desktop" && mobile) return false;
+		if (p.locales.length && !p.locales.includes(locale)) return false;
+		const clean = (u: string) => u.replace(/\/$/, "") || "/";
+		const here = p.pages.urls.map(clean).includes(clean(path));
+		if (p.pages.mode === "include") return here;
+		if (p.pages.mode === "exclude") return !here;
+		return true;
+	}
+
+	function render(p: Popup, locale: string, openPopup: (id: string) => void) {
+		const c = p.content[locale] ?? Object.values(p.content)[0];
+		const dialog = document.createElement("dialog");
+		dialog.className = "zef-popup";
+		dialog.dataset.layout = p.layout;
+		dialog.dataset.popup = p.id;
+		if (c?.titre) dialog.setAttribute("aria-label", c.titre);
+		const close = document.createElement("button");
+		close.type = "button";
+		close.className = "zef-popup__close";
+		close.setAttribute("aria-label", locale === "en" ? "Close" : "Fermer");
+		close.textContent = "×";
+		close.addEventListener("click", () => dialog.close());
+		dialog.append(close);
+		if (c?.image) {
+			const img = document.createElement("img");
+			img.className = "zef-popup__image";
+			img.src = c.image.url;
+			img.alt = c.image.alt;
+			dialog.append(img);
+		}
+		const body = document.createElement("div");
+		body.className = "zef-popup__body";
+		if (c?.titre) {
+			const h = document.createElement("h2");
+			h.className = "zef-popup__title";
+			h.textContent = c.titre;
+			body.append(h);
+		}
+		if (c?.texte) {
+			const t = document.createElement("div");
+			t.className = "zef-popup__text";
+			// Texte riche nettoyé par l'API du CMS (mêmes balises que les sections).
+			t.innerHTML = c.texte;
+			body.append(t);
+		}
+		if (c?.boutons.length) {
+			const actions = document.createElement("div");
+			actions.className = "zef-popup__actions";
+			for (const b of c.boutons) {
+				const el = b.href ? document.createElement("a") : document.createElement("button");
+				el.textContent = b.label;
+				el.className = "zef-popup__button";
+				if (b.variant) el.dataset.variant = b.variant;
+				if (el instanceof HTMLAnchorElement && b.href) {
+					el.href = b.href;
+					if (b.target) {
+						el.target = b.target;
+						el.rel = "noopener";
+					}
+					if (b.download) el.download = "";
+				} else {
+					(el as HTMLButtonElement).type = "button";
+					// Sans destination (« Plus tard ») : ferme ; vers une popup : l'ouvre.
+					el.addEventListener("click", () => {
+						dialog.close();
+						if (b.popup) openPopup(b.popup);
+					});
+				}
+				actions.append(el);
+			}
+			body.append(actions);
+		}
+		dialog.append(body);
+		dialog.addEventListener("click", (e) => {
+			if (e.target === dialog) dialog.close();
+		});
+		dialog.addEventListener("close", () => dialog.remove());
+		return dialog;
+	}
+
+	async function start(root: HTMLElement) {
+		if (new URLSearchParams(location.search).get("zef-popups") === "off") return;
+		const locale = root.dataset.locale || document.documentElement.lang || "fr";
+		let popups: Popup[] = [];
+		try {
+			const res = await fetch(root.dataset.zefPopups ?? "");
+			popups = (await res.json()).popups ?? [];
+		} catch {
+			return;
+		}
+		const byId = new Map(popups.map((p) => [p.id, p]));
+		const open = (id: string) => {
+			const p = byId.get(id);
+			if (!p || document.querySelector(`dialog.zef-popup[data-popup="${p.id}"]`)) return;
+			const dialog = render(p, locale, open);
+			document.body.append(dialog);
+			if (p.layout === "centree" || p.layout === "plein-ecran") dialog.showModal();
+			else dialog.show();
+			store.write(sessionStorage, p.id);
+			store.write(localStorage, p.id);
+		};
+
+		// Boutons « Popup » du site (et ceux ajoutés plus tard).
+		document.addEventListener("click", (e) => {
+			const trigger = (e.target as Element | null)?.closest<HTMLElement>("[data-zef-popup]");
+			if (!trigger?.dataset.zefPopup) return;
+			e.preventDefault();
+			open(trigger.dataset.zefPopup);
+		});
+
+		// Une seule popup automatique : la première (priorité) qui vise cette page.
+		const auto = popups.find(
+			(p) => p.trigger.type !== "click" && targeted(p, locale, location.pathname) && allowed(p),
+		);
+		if (!auto) return;
+		const t = auto.trigger;
+		if (t.type === "load") open(auto.id);
+		else if (t.type === "delay") setTimeout(() => open(auto.id), (t.delay ?? 0) * 1000);
+		else if (t.type === "scroll") {
+			const onScroll = () => {
+				const max = document.documentElement.scrollHeight - innerHeight;
+				if (max <= 0 || (scrollY / max) * 100 >= (t.scroll ?? 50)) {
+					removeEventListener("scroll", onScroll);
+					open(auto.id);
+				}
+			};
+			addEventListener("scroll", onScroll, { passive: true });
+		} else if (t.type === "exit" && matchMedia("(pointer: fine)").matches) {
+			const onLeave = (e: MouseEvent) => {
+				if (e.clientY > 0 || e.relatedTarget) return;
+				document.removeEventListener("mouseout", onLeave);
+				open(auto.id);
+			};
+			document.addEventListener("mouseout", onLeave);
+		}
+	}
+
+	const root = document.querySelector<HTMLElement>("[data-zef-popups]");
+	if (root) start(root);
+</script>

package/components/RichText.astro

@@ -0,0 +1,11 @@
+---
+/** Texte riche saisi dans le CMS (paragraphes, titres autorisés, listes, liens). */
+interface Props {
+	html: string;
+	class?: string;
+}
+
+const { html, class: className } = Astro.props;
+---
+
+{html && <div class={className} set:html={html} />}

package/components/Video.astro

@@ -0,0 +1,38 @@
+---
+/**
+ * Vidéo de la médiathèque (champ `f.media({ accept: "video" })`), sans style imposé. Par défaut
+ * avec les contrôles ; `ambient` : lecture automatique, en boucle et sans le son (fond de section).
+ * `poster` : image affichée avant la lecture (une `Media` de la médiathèque).
+ */
+import type { Media } from "@agence-zef/schema";
+
+interface Props {
+	media: Media | null;
+	poster?: Media | null;
+	class?: string;
+	/** Fond animé : lecture automatique, en boucle, sans le son ni contrôles. */
+	ambient?: boolean;
+}
+
+const { media, poster, class: className, ambient = false } = Astro.props;
+const isVideo = Boolean(media?.mime?.startsWith("video/"));
+---
+
+{
+	media && isVideo && (
+		<video
+			src={media.url}
+			poster={poster?.url}
+			width={media.width}
+			height={media.height}
+			class={className}
+			aria-label={media.alt || undefined}
+			preload="metadata"
+			playsinline
+			controls={!ambient}
+			autoplay={ambient}
+			loop={ambient}
+			muted={ambient}
+		/>
+	)
+}

package/components/ZefSections.astro

@@ -0,0 +1,68 @@
+---
+import components from "virtual:zef/sections";
+/**
+ * Rend les sections d'une page du CMS, dans l'ordre, avec le composant
+ * `src/sections/<type>/index.astro` du site. Props : champs de la section, `id`, `variant`, `anchor`,
+ * et `item` sur la page d'un élément de collection.
+ * Le bloc HTML de l'agence (`zef-html`) est rendu ici, sans composant ; le CSS personnalisé
+ * d'une section est ajouté juste avant elle, `&` désignant l'élément racine de la section.
+ */
+import { HTML_BLOCK } from "@agence-zef/schema";
+import type { ApiItem, ApiSection } from "@agence-zef/sdk";
+
+interface Props {
+	sections: ApiSection[];
+	/** Page d'un élément de collection : l'élément, passé à chaque section (`item`). */
+	item?: ApiItem;
+	/** Aperçu de l'éditeur : chaque section est repérée pour l'overlay (`data-zef-section`). */
+	preview?: boolean;
+}
+
+const { sections, item, preview = false } = Astro.props;
+const missing = sections
+	.filter((s) => s.type !== HTML_BLOCK && !components[s.type])
+	.map((s) => s.type);
+if (missing.length) {
+	console.warn(
+		`[@agence-zef/astro] section(s) sans composant : ${[...new Set(missing)].join(", ")}`,
+	);
+}
+
+/** Le CSS ne peut pas refermer sa balise `<style>`. */
+const safeCss = (css: string) => css.replace(/<\/?style/gi, "");
+const scoped = (css: string, id: string) =>
+	safeCss(css).replaceAll("&", `:where([data-zef-css="${id}"]) > *`);
+const text = (value: unknown) => (typeof value === "string" ? value : "");
+---
+
+{
+	sections.map((s) => {
+		const Section = components[s.type];
+		if (s.type !== HTML_BLOCK && !Section) return null;
+		const rendered =
+			s.type === HTML_BLOCK ? (
+				<Fragment>
+					<section id={s.anchor ?? undefined} data-zef-html={s.id}>
+						<Fragment set:html={text(s.data.html)} />
+					</section>
+					{text(s.data.css) && <style set:html={safeCss(text(s.data.css))} />}
+					{text(s.data.js) && <script is:inline set:html={text(s.data.js).replace(/<\/script/gi, "<\\/script")} />}
+				</Fragment>
+			) : (
+				<Section {...s.data} id={s.id} variant={s.variant} anchor={s.anchor} item={item} />
+			);
+		return preview || s.css ? (
+			<div
+				data-zef-section={preview ? s.id : undefined}
+				data-zef-type={preview ? s.type : undefined}
+				data-zef-css={s.css ? s.id : undefined}
+				style="display: contents"
+			>
+				{s.css && <style set:html={scoped(s.css, s.id)} />}
+				{rendered}
+			</div>
+		) : (
+			rendered
+		);
+	})
+}

package/components/routes/page.astro

@@ -0,0 +1,24 @@
+---
+import config from "virtual:zef/config";
+import Layout from "virtual:zef/layout";
+/**
+ * Route attrape-tout injectée par `@agence-zef/astro` : pages du CMS et éléments des collections
+ * avec page, chacun avec les sections choisies dans l'éditeur, dans le gabarit du site.
+ * Sur un élément, chaque section reçoit aussi l'élément (`item`) pour afficher ses champs.
+ */
+import { type RouteProps, zefStaticPaths } from "@agence-zef/astro";
+import ZefSections from "../ZefSections.astro";
+
+export async function getStaticPaths() {
+	return zefStaticPaths(config);
+}
+
+const props = Astro.props as RouteProps;
+const { site, locale, title, alternates, header, footer } = props;
+// Site en développement (§ 5.11) : aucune page n'est indexable.
+const seo = site.indexable === false ? { ...props.seo, noindex: true } : props.seo;
+---
+
+<Layout site={site} locale={locale} title={title} seo={seo} alternates={alternates} header={header} footer={footer}>
+	{props.kind === "page" ? <ZefSections sections={props.page.sections} /> : <ZefSections sections={props.item.sections ?? []} item={props.item} />}
+</Layout>

package/components/routes/preview-section.astro

@@ -0,0 +1,37 @@
+---
+/**
+ * Re-rendu d'une seule section pour l'aperçu (changement de variante, élément ajouté…) :
+ * l'overlay envoie la section du brouillon, l'API la résout, le composant du site la rend.
+ * Sur la page d'un élément de collection, la section reçoit aussi l'élément (`item`).
+ */
+import { type ApiItem, createClient } from "@agence-zef/sdk";
+import ZefSections from "../ZefSections.astro";
+
+export const prerender = false;
+
+Astro.response.headers.set("Cache-Control", "no-store");
+
+let section = null;
+let item: ApiItem | undefined;
+if (Astro.request.method === "POST") {
+	const body = (await Astro.request.json().catch(() => null)) as {
+		token?: string;
+		locale?: string;
+		doc?: string;
+		section?: { id: string; type: string };
+	} | null;
+	if (body?.token && body.section) {
+		const api = createClient({ url: process.env.ZEF_URL ?? "", apiKey: body.token });
+		const [resolved, document] = await Promise.all([
+			// Le document est passé à l'API : sur la page d'un élément, ses variables sont remplacées.
+			api.previewSection(body.section, { locale: body.locale, item: body.doc }).catch(() => null),
+			body.doc ? api.previewDocument(body.doc, { locale: body.locale }).catch(() => null) : null,
+		]);
+		section = resolved;
+		if (document?.kind === "item") item = document.item;
+	}
+}
+if (!section) Astro.response.status = 400;
+---
+
+{section && <ZefSections sections={[section]} item={item} preview />}

package/components/routes/preview-thumbnail.astro

@@ -0,0 +1,72 @@
+---
+import Layout from "virtual:zef/layout";
+/**
+ * Vignette de la bibliothèque de sections (E-02) : une section avec son contenu d'exemple,
+ * dans le gabarit du site, mise en haut de la fenêtre. L'éditeur l'affiche réduite dans une
+ * iframe ; affichable seulement dans le CMS (`frame-ancestors`).
+ */
+import { cmsOrigins } from "@agence-zef/astro";
+import { createClient } from "@agence-zef/sdk";
+import ZefSections from "../ZefSections.astro";
+
+export const prerender = false;
+
+const params = Astro.url.searchParams;
+const token = params.get("token") ?? "";
+const locale = params.get("locale") ?? undefined;
+
+const ancestors = cmsOrigins().join(" ");
+Astro.response.headers.set("Content-Security-Policy", `frame-ancestors ${ancestors || "'none'"}`);
+Astro.response.headers.set("Cache-Control", "no-store");
+Astro.response.headers.set("X-Robots-Tag", "noindex");
+
+let raw: { id: string; type: string } | null = null;
+try {
+	raw = JSON.parse(Buffer.from(params.get("section") ?? "", "base64url").toString("utf8"));
+} catch {
+	raw = null;
+}
+const api = createClient({ url: process.env.ZEF_URL ?? "", apiKey: token });
+const [site, section] = await Promise.all([
+	api.site().catch(() => null),
+	raw ? api.previewSection(raw, { locale }).catch(() => null) : null,
+]);
+if (!site || !section) Astro.response.status = 404;
+---
+
+{
+	site && section ? (
+		<Layout
+			site={site}
+			locale={locale ?? site.defaultLocale}
+			title={site.name}
+			seo={{ title: null, description: null, noindex: true, canonical: null, image: null }}
+			alternates={{}}
+			header={null}
+			footer={null}
+		>
+			<div id="zef-thumbnail">
+				<ZefSections sections={[section]} />
+			</div>
+			<style is:global>
+				html { overflow: hidden; scrollbar-width: none; }
+				body { pointer-events: none; }
+				astro-dev-toolbar { display: none !important; }
+			</style>
+			<script>
+				// La section seule : tout ce qui l'entoure dans le gabarit (header, footer…) est masqué.
+				let node = document.getElementById("zef-thumbnail");
+				while (node && node !== document.body) {
+					for (const sibling of node.parentElement?.children ?? []) {
+						if (sibling !== node && !["SCRIPT", "STYLE", "LINK"].includes(sibling.tagName)) {
+							(sibling as HTMLElement).style.display = "none";
+						}
+					}
+					node = node.parentElement;
+				}
+			</script>
+		</Layout>
+	) : (
+		<p style="font-family: system-ui; padding: 1rem; color: #71717a">Vignette indisponible</p>
+	)
+}

package/components/routes/preview.astro

@@ -0,0 +1,77 @@
+---
+import Layout from "virtual:zef/layout";
+/**
+ * Aperçu de l'éditeur (plan technique § 3.4) : la page ou l'élément de collection, brouillon
+ * compris, dans le gabarit du site, avec l'overlay de sélection. Lu avec le jeton signé que
+ * l'éditeur passe dans l'adresse ; affichable seulement dans le CMS (`frame-ancestors` :
+ * sous-domaine du client et espace agence `admin.`).
+ */
+import { cmsOrigin, cmsOrigins } from "@agence-zef/astro";
+import { createClient } from "@agence-zef/sdk";
+import ZefSections from "../ZefSections.astro";
+
+export const prerender = false;
+
+const params = Astro.url.searchParams;
+const token = params.get("token") ?? "";
+const doc = params.get("doc") ?? "";
+const locale = params.get("locale") ?? undefined;
+const version = params.get("version") ?? undefined;
+const cms = cmsOrigin(params.get("cms"));
+
+const ancestors = cmsOrigins().join(" ");
+Astro.response.headers.set("Content-Security-Policy", `frame-ancestors ${ancestors || "'none'"}`);
+Astro.response.headers.set("Cache-Control", "no-store");
+Astro.response.headers.set("X-Robots-Tag", "noindex");
+
+const api = createClient({ url: process.env.ZEF_URL ?? "", apiKey: token });
+const [site, document, layout] = await Promise.all([
+	api.site().catch(() => null),
+	doc ? api.previewDocument(doc, { locale, version }).catch(() => null) : null,
+	api.previewLayout({ locale }).catch(() => ({ header: null, footer: null })),
+]);
+if (!site || !document) {
+	Astro.response.status = 404;
+}
+const page = document?.kind === "page" ? document.page : null;
+const props = document &&
+	site && {
+		site,
+		locale: page?.locale ?? locale ?? site.defaultLocale,
+		title: page
+			? page.title
+			: String(document.kind === "item" ? document.item[document.titleField] : ""),
+		seo: page?.seo ?? {
+			title: null,
+			description: null,
+			noindex: true,
+			canonical: null,
+			image: null,
+		},
+		alternates: page?.alternates ?? {},
+		header: layout.header,
+		footer: layout.footer,
+		preview: true,
+	};
+---
+
+{
+	props ? (
+		<Layout {...props}>
+			<div data-zef-sections style="display: contents">
+				<ZefSections
+					sections={page ? page.sections : document?.kind === "item" ? (document.item.sections ?? []) : []}
+					item={document?.kind === "item" ? document.item : undefined}
+					preview
+				/>
+			</div>
+			<div id="zef-preview" hidden data-cms={cms} data-token={token} data-locale={props.locale} data-doc={doc} />
+			<script>
+				import { startOverlay } from "@agence-zef/astro/overlay";
+				startOverlay();
+			</script>
+		</Layout>
+	) : (
+		<p style="font-family: system-ui; padding: 2rem">Aperçu indisponible : le lien a expiré ou le contenu n'existe plus.</p>
+	)
+}

package/components/routes/robots.ts

@@ -0,0 +1,16 @@
+import { getClient } from "@agence-zef/astro";
+import type { APIRoute } from "astro";
+
+/*
+ * `robots.txt` injecté par `@agence-zef/astro` (§ 5.11) : tout est bloqué tant que le site est en
+ * développement ; une fois en ligne, les moteurs peuvent tout indexer. Construit avec le site :
+ * la mise en ligne relance un build.
+ */
+
+export const prerender = true;
+
+export const GET: APIRoute = async () => {
+	const site = await getClient().site();
+	const body = site.indexable ? "User-agent: *\nAllow: /\n" : "User-agent: *\nDisallow: /\n";
+	return new Response(body, { headers: { "Content-Type": "text/plain; charset=utf-8" } });
+};

package/components/virtual.d.ts

@@ -0,0 +1,12 @@
+declare module "virtual:zef/config" {
+	const config: import("@agence-zef/schema").ZefConfig;
+	export default config;
+}
+declare module "virtual:zef/sections" {
+	const sections: Record<string, (props: Record<string, unknown>) => unknown>;
+	export default sections;
+}
+declare module "virtual:zef/layout" {
+	const layout: (props: Record<string, unknown>) => unknown;
+	export default layout;
+}

package/dist/env.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Charge ZEF_URL et ZEF_API_KEY depuis `.env` (écrit par `zef link`) dans `process.env`,
+ * sans écraser les variables déjà posées (Vercel). Astro ne le fait que pour `import.meta.env`.
+ */
+export declare function loadZefEnv(root: string): void;

package/dist/env.js

@@ -0,0 +1,17 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { parseEnv } from "node:util";
+/**
+ * Charge ZEF_URL et ZEF_API_KEY depuis `.env` (écrit par `zef link`) dans `process.env`,
+ * sans écraser les variables déjà posées (Vercel). Astro ne le fait que pour `import.meta.env`.
+ */
+export function loadZefEnv(root) {
+    const file = join(root, ".env");
+    if (!existsSync(file))
+        return;
+    const values = parseEnv(readFileSync(file, "utf8"));
+    for (const key of ["ZEF_URL", "ZEF_API_KEY"]) {
+        if (!process.env[key] && values[key])
+            process.env[key] = values[key];
+    }
+}

package/dist/helpers.d.ts

@@ -0,0 +1,53 @@
+import type { ZefConfig } from "@agence-zef/schema";
+import { type ApiItem, type ApiPage, type ApiSection, type ApiSeo, type ApiSite, type ZefClient } from "@agence-zef/sdk";
+/**
+ * Registre du site, déclaré une fois dans `src/env.d.ts` pour typer les helpers :
+ * `declare module "@agence-zef/astro" { interface Register { config: typeof import("../zef.config").default } }`
+ */
+export interface Register {
+}
+export type SiteConfig = Register extends {
+    config: infer C extends ZefConfig;
+} ? C : ZefConfig;
+/** Client de l'API du site, configuré par ZEF_URL et ZEF_API_KEY (`zef link`). */
+export declare function getClient(): ZefClient<SiteConfig>;
+export declare const getSite: () => Promise<ApiSite>;
+export declare const getPage: (url: string) => Promise<ApiPage | null>;
+export declare const getCollection: ZefClient<SiteConfig>["collection"];
+export declare const getItem: ZefClient<SiteConfig>["item"];
+/** Props reçues par `src/layouts/Page.astro` : une page du CMS ou un élément de collection. */
+export type LayoutProps = {
+    site: ApiSite;
+    locale: string;
+    title: string;
+    seo: ApiSeo;
+    /** Adresse dans chaque langue (sélecteur de langue, balises hreflang). */
+    alternates: Record<string, string>;
+    /** Header et footer (sections partagées), à rendre avec `<ZefSections>` ; `null` sans `layout`. */
+    header: ApiSection | null;
+    footer: ApiSection | null;
+    /** Aperçu de l'éditeur : à passer à `<ZefSections preview>` pour le header et le footer. */
+    preview?: boolean;
+};
+export type RouteProps = LayoutProps & ({
+    kind: "page";
+    page: ApiPage;
+} | {
+    kind: "item";
+    collection: string;
+    item: ApiItem;
+});
+/** Toutes les routes du site : pages publiées, puis éléments des collections avec page. */
+export declare function zefStaticPaths(config: ZefConfig): Promise<{
+    params: {
+        path: string | undefined;
+    };
+    props: RouteProps;
+}[]>;
+/**
+ * Origines du CMS autorisées à afficher l'aperçu : le sous-domaine du client (`ZEF_URL`) et
+ * l'espace agence (`admin.` du même domaine), d'où l'agence gère ses clients.
+ */
+export declare function cmsOrigins(zefUrl?: string | undefined): string[];
+/** Origine du CMS qui ouvre l'aperçu (`?cms=`), si elle est autorisée ; sinon celle du client. */
+export declare function cmsOrigin(requested: string | null, zefUrl?: string | undefined): string;