@agence-zef/astro 0.3.1 → 0.5.0

package/dist/helpers.js

@@ -43,13 +43,41 @@ export async function zefLayoutProps(opts) {
     };
 }
 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) {
+let staticPaths;
+/**
+ * Toutes les routes du site : pages publiées, puis éléments des collections avec page. Calculé
+ * une fois par build : la route des pages, le sitemap et `llms.txt` partagent le résultat.
+ */
+export function zefStaticPaths(config) {
+    staticPaths ??= buildStaticPaths(config).catch((error) => {
+        staticPaths = undefined;
+        throw error;
+    });
+    return staticPaths;
+}
+async function buildStaticPaths(config) {
     const api = getClient();
     const site = await api.site();
     const paths = [];
     const layouts = new Map(await Promise.all(site.locales.map(async (l) => [l, await api.layout({ locale: l })])));
-    for (const entry of await api.pages()) {
+    const entries = await api.pages();
+    const byId = new Map(entries.map((e) => [e.id, e]));
+    const homeOf = (locale) => entries.find((e) => e.urls[locale] === "/" || e.urls[locale] === `/${locale}`);
+    /** Accueil, puis les pages parentes, puis la page elle-même. */
+    const trail = (id, locale) => {
+        const out = [];
+        for (let e = byId.get(id); e; e = e.parentId ? byId.get(e.parentId) : undefined) {
+            const url = e.urls[locale];
+            if (url)
+                out.unshift({ title: e.titles[locale] || e.titles[site.defaultLocale] || "", url });
+        }
+        const home = homeOf(locale);
+        if (home && out[0]?.url !== home.urls[locale]) {
+            out.unshift({ title: home.titles[locale] || site.name, url: home.urls[locale] });
+        }
+        return out;
+    };
+    for (const entry of entries) {
         for (const [locale, url] of Object.entries(entry.urls)) {
             const page = await api.page(url);
             // Contenu réservé : rendu à la demande avec la session du compte (`/[...zefReserved]`).
@@ -65,6 +93,8 @@ export async function zefStaticPaths(config) {
                     title: page.seo.title ?? page.title,
                     seo: page.seo,
                     alternates: page.alternates,
+                    url,
+                    breadcrumbs: trail(entry.id, locale),
                     header: layouts.get(locale)?.header ?? null,
                     footer: layouts.get(locale)?.footer ?? null,
                 },
@@ -87,6 +117,9 @@ export async function zefStaticPaths(config) {
                     if (url)
                         alternates[other.locale] = url;
                 }
+                // Fil d'Ariane : accueil, page de la liste si elle existe (`/vins`), puis l'élément.
+                const listing = entries.find((e) => e.urls[locale] === def.page.path || e.urls[locale] === `/${locale}${def.page.path}`) ?? homeOf(locale);
+                const title = String(item[def.titleField] ?? "");
                 paths.push({
                     params: { path: toParam(item.url) },
                     props: {
@@ -95,9 +128,17 @@ export async function zefStaticPaths(config) {
                         item,
                         site,
                         locale,
-                        title: String(item[def.titleField] ?? ""),
-                        seo: { title: null, description: null, noindex: false, canonical: null, image: null },
+                        title: item.seo?.title ?? title,
+                        seo: item.seo ?? {
+                            title: null,
+                            description: null,
+                            noindex: false,
+                            canonical: null,
+                            image: null,
+                        },
                         alternates,
+                        url: item.url,
+                        breadcrumbs: [...(listing ? trail(listing.id, locale) : []), { title, url: item.url }],
                         header: layouts.get(locale)?.header ?? null,
                         footer: layouts.get(locale)?.footer ?? null,
                     },
@@ -107,6 +148,24 @@ export async function zefStaticPaths(config) {
     }
     return paths;
 }
+/**
+ * Index du site pour le sitemap et `llms.txt` : une entrée par page et par élément avec page,
+ * dans chaque langue (titre, description, indexation, date de publication, langues).
+ */
+export async function zefSiteIndex(config) {
+    const paths = await zefStaticPaths(config);
+    return paths.map(({ props }) => ({
+        url: props.url ?? "/",
+        locale: props.locale,
+        title: props.title,
+        description: props.seo.description,
+        noindex: props.seo.noindex,
+        canonical: props.seo.canonical,
+        updatedAt: props.kind === "page" ? props.page.updatedAt : props.item.updatedAt,
+        alternates: props.alternates,
+        collection: props.kind === "item" ? props.collection : null,
+    }));
+}
 /**
  * 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.

package/dist/index.d.ts

@@ -2,6 +2,7 @@ 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 "./seo.js";
 export * from "./shop.js";
 export type ZefOptions = {
     /** Gabarit des pages du CMS (en-tête, pied, styles du site). */

package/dist/index.js

@@ -5,6 +5,7 @@ import { loadZefEnv } from "./env.js";
 import { getClient } from "./helpers.js";
 export * from "./accounts.js";
 export * from "./helpers.js";
+export * from "./seo.js";
 export * from "./shop.js";
 const MEDIA_URL = "https://medias.agence-zef.fr";
 /** Domaines autorisés pour l'optimisation des images distantes (`image.remotePatterns`). */
@@ -83,6 +84,12 @@ export default function zef(options = {}) {
                         ]),
                     },
                 });
+                // Performance : le CSS (quelques Ko par page) est écrit dans la page plutôt que chargé à
+                // part, ce qui retire une requête bloquante du premier affichage. Un site peut choisir
+                // « never » dans son `astro.config`.
+                if (config.build.inlineStylesheets === "auto") {
+                    updateConfig({ build: { inlineStylesheets: "always" } });
+                }
                 addWatchFile(join(root, ".env"));
                 const layout = join(root, options.layout ?? "src/layouts/Page.astro");
                 const configFile = join(root, "zef.config.ts");
@@ -96,6 +103,17 @@ export default function zef(options = {}) {
                     entrypoint: "@agence-zef/astro/routes/robots.ts",
                     prerender: true,
                 });
+                // Référencement prêt à l'emploi (§ 5.13) : sitemap et présentation pour les IA.
+                injectRoute({
+                    pattern: "/sitemap.xml",
+                    entrypoint: "@agence-zef/astro/routes/sitemap.ts",
+                    prerender: true,
+                });
+                injectRoute({
+                    pattern: "/llms.txt",
+                    entrypoint: "@agence-zef/astro/routes/llms.ts",
+                    prerender: true,
+                });
                 // Aperçu de l'éditeur : rendu à la demande, donc avec un adaptateur (Vercel) ou en dev.
                 if (command === "dev" || config.adapter) {
                     injectRoute({

package/dist/seo.d.ts

@@ -0,0 +1,103 @@
+import type { Media } from "@agence-zef/schema";
+import type { ApiItem, ApiSeo, ApiSite } from "@agence-zef/sdk";
+import type { Breadcrumb } from "./helpers.js";
+/** Coordonnées de l'entreprise pour les données structurées (tirées du header et du footer). */
+export type SeoOrganization = {
+    /** Type schema.org : `Organization` par défaut, `LocalBusiness`, `Store`, `Restaurant`… */
+    type?: string;
+    name?: string;
+    /** Logo : média de la médiathèque ou adresse. */
+    logo?: Media | string | null;
+    description?: string | null;
+    telephone?: string | null;
+    email?: string | null;
+    /** Adresse en une chaîne (« 12 rue de Gand, 59000 Lille ») ou détaillée. */
+    address?: string | {
+        streetAddress?: string;
+        postalCode?: string;
+        addressLocality?: string;
+        addressRegion?: string;
+        addressCountry?: string;
+    } | null;
+    /** Profils publics (réseaux sociaux, fiche Google) : `sameAs`. */
+    sameAs?: (string | null | undefined)[];
+    /** Horaires au format schema.org (`Mo-Sa 10:00-19:30`). */
+    openingHours?: string | string[] | null;
+    priceRange?: string | null;
+    /** Données en plus, recopiées telles quelles dans l'objet. */
+    extra?: Record<string, unknown>;
+};
+export type SeoInput = {
+    site: ApiSite;
+    locale: string;
+    title: string;
+    seo: ApiSeo;
+    alternates: Record<string, string>;
+    /** Adresse de la page (`/la-cave`). */
+    url: string;
+    /** Origine du site (`https://cave-vivante.fr`) quand `site.url` est vide. */
+    origin?: string | null;
+    breadcrumbs?: Breadcrumb[];
+    item?: ApiItem;
+    organization?: SeoOrganization;
+    /** Modèle du titre : `%s` = titre de la page (défaut « Page · Site », le nom seul sur l'accueil). */
+    titleTemplate?: string;
+    /** `og:type` : `website` par défaut, `product` pour un produit. */
+    type?: string;
+    /** Données structurées en plus (article, évènement, FAQ…). */
+    jsonLd?: Record<string, unknown> | Record<string, unknown>[];
+    /** Icône de l'onglet (`/favicon.svg`) ; à défaut, le logo du client dans le CMS. */
+    icon?: string | null;
+};
+export type SeoTags = {
+    title: string;
+    meta: {
+        name?: string;
+        property?: string;
+        content: string;
+    }[];
+    links: {
+        rel: string;
+        href: string;
+        hreflang?: string;
+    }[];
+    jsonLd: Record<string, unknown>;
+};
+export declare const ogLocale: (locale: string) => string;
+/** Origine du site, sans `/` final. */
+export declare function siteOrigin(site: ApiSite, fallback?: string | null): string;
+/** Adresse absolue d'un chemin du site (une adresse déjà absolue est gardée). */
+export declare function absolute(origin: string, path: string): string;
+/** Balises du `<head>` et données structurées d'une page. */
+export declare function seoTags(input: SeoInput): SeoTags;
+/** JSON-LD sûr dans un `<script>` (pas de `</script>` ni de `<!--` dans les textes). */
+export declare const jsonLdScript: (data: unknown) => string;
+export type IndexEntry = {
+    url: string;
+    locale: string;
+    title: string;
+    description: string | null;
+    noindex: boolean;
+    canonical: string | null;
+    updatedAt: string | null;
+    alternates: Record<string, string>;
+    /** `null` pour une page, nom de la collection pour un élément. */
+    collection: string | null;
+};
+/** Pages et éléments indexables : ni `noindex`, ni canonique vers une autre adresse. */
+export declare const indexable: (e: IndexEntry, origin: string) => boolean;
+/** `sitemap.xml` avec les versions de chaque langue (`xhtml:link`) et la date de publication. */
+export declare function sitemapXml(entries: IndexEntry[], origin: string): string;
+/**
+ * `robots.txt` : tout bloqué tant que le site est en développement ; en ligne, moteurs et IA
+ * peuvent tout lire (sauf les routes techniques), avec le sitemap et `llms.txt`.
+ */
+export declare function robotsTxt(site: ApiSite, origin: string): string;
+/**
+ * `llms.txt` (format llmstxt.org) : présentation du site pour les assistants IA, puis ses pages
+ * et les éléments de chaque collection, avec leur description, dans la langue par défaut.
+ */
+export declare function llmsTxt(site: ApiSite, entries: IndexEntry[], origin: string, collections?: {
+    name: string;
+    label: string;
+}[]): string;

package/dist/seo.js

@@ -0,0 +1,258 @@
+/** Locale Open Graph (`fr` → `fr_FR`). */
+const OG_LOCALES = {
+    fr: "fr_FR",
+    en: "en_GB",
+    de: "de_DE",
+    es: "es_ES",
+    it: "it_IT",
+    nl: "nl_NL",
+    pt: "pt_PT",
+};
+export const ogLocale = (locale) => OG_LOCALES[locale] ??
+    (locale.includes("-") ? locale.replace("-", "_") : `${locale}_${locale.toUpperCase()}`);
+/** Origine du site, sans `/` final. */
+export function siteOrigin(site, fallback) {
+    return (site.url ?? fallback ?? "").replace(/\/+$/, "");
+}
+/** Adresse absolue d'un chemin du site (une adresse déjà absolue est gardée). */
+export function absolute(origin, path) {
+    if (/^https?:\/\//.test(path))
+        return path;
+    return `${origin}${path.startsWith("/") ? path : `/${path}`}`;
+}
+const mediaUrl = (m) => (typeof m === "string" ? m : m?.url);
+const compact = (o) => Object.fromEntries(Object.entries(o).filter(([, v]) => v !== undefined && v !== null && v !== "" && !(Array.isArray(v) && !v.length)));
+/** Balises du `<head>` et données structurées d'une page. */
+export function seoTags(input) {
+    const { site, locale, seo, alternates } = input;
+    const origin = siteOrigin(site, input.origin);
+    const path = input.url || "/";
+    const url = absolute(origin, path);
+    const isHome = path === "/" || path === `/${locale}` || path === `/${locale}/`;
+    const pageTitle = seo.title ?? input.title;
+    const template = input.titleTemplate ?? `%s · ${site.name}`;
+    const title = isHome || pageTitle === site.name || !pageTitle
+        ? pageTitle || site.name
+        : template.replace("%s", pageTitle);
+    const description = seo.description ?? null;
+    const image = seo.image ?? site.shareImage ?? null;
+    const noindex = seo.noindex || site.indexable === false;
+    const canonical = seo.canonical ? absolute(origin, seo.canonical) : url;
+    const product = input.item?.product;
+    const type = input.type ?? (product ? "product" : "website");
+    const meta = [];
+    const add = (key, k, content) => {
+        if (content)
+            meta.push({ [key]: k, content });
+    };
+    add("name", "description", description);
+    add("name", "robots", noindex ? "noindex, nofollow" : "index, follow, max-image-preview:large, max-snippet:-1");
+    add("property", "og:type", type);
+    add("property", "og:site_name", site.name);
+    add("property", "og:title", pageTitle || site.name);
+    add("property", "og:description", description);
+    add("property", "og:url", canonical);
+    add("property", "og:locale", ogLocale(locale));
+    for (const other of Object.keys(alternates)) {
+        if (other !== locale)
+            add("property", "og:locale:alternate", ogLocale(other));
+    }
+    if (image) {
+        add("property", "og:image", absolute(origin, image.url));
+        add("property", "og:image:alt", image.alt);
+        if (image.width)
+            add("property", "og:image:width", String(image.width));
+        if (image.height)
+            add("property", "og:image:height", String(image.height));
+        if (image.mime)
+            add("property", "og:image:type", image.mime);
+    }
+    add("name", "twitter:card", image ? "summary_large_image" : "summary");
+    add("name", "twitter:title", pageTitle || site.name);
+    add("name", "twitter:description", description);
+    if (image)
+        add("name", "twitter:image", absolute(origin, image.url));
+    const links = [{ rel: "canonical", href: canonical }];
+    const icon = input.icon ?? site.logo;
+    if (icon)
+        links.push({ rel: "icon", href: icon });
+    const langs = Object.entries(alternates);
+    if (langs.length > 1) {
+        for (const [lang, href] of langs)
+            links.push({ rel: "alternate", hreflang: lang, href: absolute(origin, href) });
+        const fallback = alternates[site.defaultLocale];
+        if (fallback)
+            links.push({ rel: "alternate", hreflang: "x-default", href: absolute(origin, fallback) });
+    }
+    if (!noindex)
+        links.push({ rel: "sitemap", href: absolute(origin, "/sitemap.xml") });
+    return {
+        title,
+        meta,
+        links,
+        jsonLd: structuredData(input, { origin, url: canonical, title: pageTitle, description, image }),
+    };
+}
+/** Graphe JSON-LD de la page (`@graph`), entités reliées par leurs `@id`. */
+function structuredData(input, page) {
+    const { site, locale, organization: org = {}, breadcrumbs = [], item } = input;
+    const { origin, url } = page;
+    const orgId = `${origin}/#organization`;
+    const websiteId = `${origin}/#website`;
+    const logo = mediaUrl(org.logo) ?? site.logo ?? undefined;
+    const address = typeof org.address === "string"
+        ? org.address.trim()
+            ? { "@type": "PostalAddress", streetAddress: org.address.trim() }
+            : undefined
+        : org.address && Object.keys(compact(org.address)).length
+            ? { "@type": "PostalAddress", ...compact(org.address) }
+            : undefined;
+    const graph = [
+        compact({
+            "@type": "WebSite",
+            "@id": websiteId,
+            url: `${origin}/`,
+            name: site.name,
+            inLanguage: site.locales,
+            publisher: { "@id": orgId },
+        }),
+        compact({
+            "@type": org.type ?? "Organization",
+            "@id": orgId,
+            name: org.name ?? site.name,
+            url: `${origin}/`,
+            logo: logo ? absolute(origin, logo) : undefined,
+            image: logo ? absolute(origin, logo) : undefined,
+            description: org.description,
+            telephone: org.telephone,
+            email: org.email,
+            address,
+            sameAs: (org.sameAs ?? []).filter((s) => Boolean(s)),
+            openingHours: org.openingHours,
+            priceRange: org.priceRange,
+            ...org.extra,
+        }),
+        compact({
+            "@type": "WebPage",
+            "@id": `${url}#webpage`,
+            url,
+            name: page.title || site.name,
+            description: page.description,
+            inLanguage: locale,
+            isPartOf: { "@id": websiteId },
+            about: { "@id": orgId },
+            primaryImageOfPage: page.image
+                ? { "@type": "ImageObject", url: absolute(origin, page.image.url) }
+                : undefined,
+            breadcrumb: breadcrumbs.length > 1 ? { "@id": `${url}#breadcrumb` } : undefined,
+            dateModified: item?.updatedAt ?? undefined,
+        }),
+    ];
+    if (breadcrumbs.length > 1) {
+        graph.push({
+            "@type": "BreadcrumbList",
+            "@id": `${url}#breadcrumb`,
+            itemListElement: breadcrumbs.map((b, i) => ({
+                "@type": "ListItem",
+                position: i + 1,
+                name: b.title,
+                item: absolute(origin, b.url),
+            })),
+        });
+    }
+    const product = item?.product;
+    if (product) {
+        const images = product.media
+            .filter((m) => m.mime.startsWith("image/"))
+            .map((m) => absolute(origin, m.url));
+        const currency = "EUR";
+        const offers = product.variants.length
+            ? product.variants.map((v) => compact({
+                "@type": "Offer",
+                url,
+                sku: v.sku ?? undefined,
+                price: (v.price / 100).toFixed(2),
+                priceCurrency: currency,
+                availability: `https://schema.org/${v.available ? "InStock" : "OutOfStock"}`,
+            }))
+            : undefined;
+        graph.push(compact({
+            "@type": "Product",
+            "@id": `${url}#product`,
+            name: page.title,
+            description: page.description,
+            image: images.length ? images : page.image ? [absolute(origin, page.image.url)] : undefined,
+            sku: product.variants.length === 1 ? (product.variants[0].sku ?? undefined) : undefined,
+            brand: { "@type": "Brand", name: org.name ?? site.name },
+            category: product.categories.map((c) => c.name).join(", ") || undefined,
+            offers: offers && offers.length === 1 ? offers[0] : offers,
+        }));
+    }
+    const extra = input.jsonLd ? (Array.isArray(input.jsonLd) ? input.jsonLd : [input.jsonLd]) : [];
+    graph.push(...extra);
+    return { "@context": "https://schema.org", "@graph": graph };
+}
+/** JSON-LD sûr dans un `<script>` (pas de `</script>` ni de `<!--` dans les textes). */
+export const jsonLdScript = (data) => JSON.stringify(data).replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/&/g, "\\u0026");
+const xml = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+/** Pages et éléments indexables : ni `noindex`, ni canonique vers une autre adresse. */
+export const indexable = (e, origin) => !e.noindex && (!e.canonical || absolute(origin, e.canonical) === absolute(origin, e.url));
+/** `sitemap.xml` avec les versions de chaque langue (`xhtml:link`) et la date de publication. */
+export function sitemapXml(entries, origin) {
+    const rows = entries
+        .filter((e) => indexable(e, origin))
+        .map((e) => {
+        const alternates = Object.entries(e.alternates);
+        const links = alternates.length > 1
+            ? alternates
+                .map(([lang, href]) => `\n    <xhtml:link rel="alternate" hreflang="${xml(lang)}" href="${xml(absolute(origin, href))}"/>`)
+                .join("")
+            : "";
+        const lastmod = e.updatedAt ? `\n    <lastmod>${e.updatedAt.slice(0, 10)}</lastmod>` : "";
+        return `  <url>\n    <loc>${xml(absolute(origin, e.url))}</loc>${lastmod}${links}\n  </url>`;
+    });
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" xmlns:xhtml="http://www.w3.org/1999/xhtml">
+${rows.join("\n")}
+</urlset>
+`;
+}
+/**
+ * `robots.txt` : tout bloqué tant que le site est en développement ; en ligne, moteurs et IA
+ * peuvent tout lire (sauf les routes techniques), avec le sitemap et `llms.txt`.
+ */
+export function robotsTxt(site, origin) {
+    if (!site.indexable)
+        return "User-agent: *\nDisallow: /\n";
+    const lines = ["User-agent: *", "Allow: /", "Disallow: /__zef/", ""];
+    if (origin)
+        lines.push(`Sitemap: ${origin}/sitemap.xml`, "");
+    return lines.join("\n");
+}
+/**
+ * `llms.txt` (format llmstxt.org) : présentation du site pour les assistants IA, puis ses pages
+ * et les éléments de chaque collection, avec leur description, dans la langue par défaut.
+ */
+export function llmsTxt(site, entries, origin, collections = []) {
+    const visible = entries.filter((e) => e.locale === site.defaultLocale && indexable(e, origin));
+    const home = visible.find((e) => e.collection === null && (e.url === "/" || e.url === ""));
+    const line = (e) => `- [${e.title || e.url}](${absolute(origin, e.url)})${e.description ? `: ${e.description}` : ""}`;
+    const out = [`# ${site.name}`, ""];
+    if (home?.description)
+        out.push(`> ${home.description}`, "");
+    if (origin)
+        out.push(`Site : ${origin}/`, "");
+    const pages = visible.filter((e) => e.collection === null);
+    if (pages.length)
+        out.push("## Pages", "", ...pages.map(line), "");
+    for (const c of collections) {
+        const items = visible.filter((e) => e.collection === c.name);
+        if (items.length)
+            out.push(`## ${c.label}`, "", ...items.map(line), "");
+    }
+    const others = site.locales.filter((l) => l !== site.defaultLocale);
+    if (others.length) {
+        out.push("## Autres langues", "", ...others.map((l) => `- ${l.toUpperCase()} : ${origin}/${l}`), "");
+    }
+    return out.join("\n");
+}

package/dist/ui.d.ts

@@ -0,0 +1,7 @@
+/** Ouvre une fenêtre `<Dialog>` par son identifiant. */
+export declare function openDialog(id: string): void;
+/**
+ * Ferme une fenêtre en laissant jouer son animation de sortie (`[data-closing]`), puis la
+ * ferme vraiment ; tout de suite si le visiteur réduit les animations ou sans animation CSS.
+ */
+export declare function closeDialog(target: HTMLDialogElement | string): void;

package/dist/ui.js

@@ -0,0 +1,33 @@
+/*
+ * Comportements des composants d'interface (`<Dialog>`, `<Accordion>`) partagés par leurs
+ * scripts : exportés pour qu'un site les déclenche lui-même.
+ */
+const reduced = () => window.matchMedia("(prefers-reduced-motion: reduce)").matches;
+/** Ouvre une fenêtre `<Dialog>` par son identifiant. */
+export function openDialog(id) {
+    const dialog = document.getElementById(id);
+    if (dialog instanceof HTMLDialogElement && !dialog.open)
+        dialog.showModal();
+}
+/**
+ * Ferme une fenêtre en laissant jouer son animation de sortie (`[data-closing]`), puis la
+ * ferme vraiment ; tout de suite si le visiteur réduit les animations ou sans animation CSS.
+ */
+export function closeDialog(target) {
+    const dialog = typeof target === "string" ? document.getElementById(target) : target;
+    if (!(dialog instanceof HTMLDialogElement) || !dialog.open || dialog.hasAttribute("data-closing"))
+        return;
+    const finish = () => {
+        dialog.removeAttribute("data-closing");
+        dialog.close();
+    };
+    if (reduced())
+        return finish();
+    dialog.setAttribute("data-closing", "");
+    const animated = getComputedStyle(dialog).animationName !== "none";
+    if (!animated)
+        return finish();
+    dialog.addEventListener("animationend", finish, { once: true });
+    // Filet : si l'animation ne se termine pas (onglet en arrière-plan), on ferme quand même.
+    setTimeout(() => dialog.hasAttribute("data-closing") && finish(), 400);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agence-zef/astro",
-  "version": "0.3.1",
+  "version": "0.5.0",
   "description": "Intégration Astro du CMS ZEF : routes, rendu des sections, aperçu, composants réutilisables sans style.",
   "license": "MIT",
   "type": "module",
@@ -13,6 +13,9 @@
     "./routes/page.astro": "./components/routes/page.astro",
     "./routes/reserved.astro": "./components/routes/reserved.astro",
     "./routes/robots.ts": "./components/routes/robots.ts",
+    "./routes/sitemap.ts": "./components/routes/sitemap.ts",
+    "./routes/llms.ts": "./components/routes/llms.ts",
+    "./Seo.astro": "./components/Seo.astro",
     "./Button.astro": "./components/Button.astro",
     "./Image.astro": "./components/Image.astro",
     "./Video.astro": "./components/Video.astro",
@@ -47,11 +50,25 @@
     "./VideoPlayer.astro": "./components/VideoPlayer.astro",
     "./Subscriptions.astro": "./components/Subscriptions.astro",
     "./ReservedNotice.astro": "./components/ReservedNotice.astro",
-    "./routes/shop.ts": "./components/routes/shop.ts"
+    "./routes/shop.ts": "./components/routes/shop.ts",
+    "./Dialog.astro": "./components/Dialog.astro",
+    "./Accordion.astro": "./components/Accordion.astro",
+    "./AccordionItem.astro": "./components/AccordionItem.astro",
+    "./Popover.astro": "./components/Popover.astro",
+    "./Field.astro": "./components/Field.astro",
+    "./Input.astro": "./components/Input.astro",
+    "./Select.astro": "./components/Select.astro",
+    "./Checkbox.astro": "./components/Checkbox.astro",
+    "./styles.css": "./styles.css",
+    "./ui": {
+      "types": "./dist/ui.d.ts",
+      "import": "./dist/ui.js"
+    }
   },
   "files": [
     "dist",
-    "components"
+    "components",
+    "styles.css"
   ],
   "publishConfig": {
     "access": "public"
@@ -64,8 +81,8 @@
     "@types/node": "^24.0.0"
   },
   "dependencies": {
-    "@agence-zef/schema": "0.3.0",
-    "@agence-zef/sdk": "0.3.0"
+    "@agence-zef/schema": "0.5.0",
+    "@agence-zef/sdk": "0.5.0"
   },
   "homepage": "https://agence-zef.fr",
   "scripts": {