@agence-zef/astro 0.0.0-stage → 0.2.0

package/dist/helpers.js

@@ -0,0 +1,100 @@
+import { createClient, } from "@agence-zef/sdk";
+let client;
+/** Client de l'API du site, configuré par ZEF_URL et ZEF_API_KEY (`zef link`). */
+export function getClient() {
+    if (!client) {
+        const url = process.env.ZEF_URL;
+        const apiKey = process.env.ZEF_API_KEY;
+        if (!url || !apiKey) {
+            throw new Error("[@agence-zef/astro] ZEF_URL et ZEF_API_KEY manquants : lancez `zef link <client>`.");
+        }
+        client = createClient({ url, apiKey });
+    }
+    return client;
+}
+/* Helpers typés pour les besoins particuliers (liste filtrée, page sur mesure). */
+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);
+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) {
+    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()) {
+        for (const [locale, url] of Object.entries(entry.urls)) {
+            const page = await api.page(url);
+            if (!page)
+                continue;
+            paths.push({
+                params: { path: toParam(url) },
+                props: {
+                    kind: "page",
+                    page,
+                    site,
+                    locale,
+                    title: page.seo.title ?? page.title,
+                    seo: page.seo,
+                    alternates: page.alternates,
+                    header: layouts.get(locale)?.header ?? null,
+                    footer: layouts.get(locale)?.footer ?? null,
+                },
+            });
+        }
+    }
+    const withPage = (config.collections ?? []).filter((c) => Boolean(c.page));
+    for (const def of withPage) {
+        const byLocale = await Promise.all(site.locales.map(async (locale) => ({
+            locale,
+            list: await api.collection(def.name, { locale }),
+        })));
+        for (const { locale, list } of byLocale) {
+            for (const item of list.items) {
+                if (!item.url)
+                    continue;
+                const alternates = {};
+                for (const other of byLocale) {
+                    const url = other.list.items.find((i) => i.id === item.id)?.url;
+                    if (url)
+                        alternates[other.locale] = url;
+                }
+                paths.push({
+                    params: { path: toParam(item.url) },
+                    props: {
+                        kind: "item",
+                        collection: def.name,
+                        item,
+                        site,
+                        locale,
+                        title: String(item[def.titleField] ?? ""),
+                        seo: { title: null, description: null, noindex: false, canonical: null, image: null },
+                        alternates,
+                        header: layouts.get(locale)?.header ?? null,
+                        footer: layouts.get(locale)?.footer ?? null,
+                    },
+                });
+            }
+        }
+    }
+    return paths;
+}
+/**
+ * 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 function cmsOrigins(zefUrl = process.env.ZEF_URL) {
+    if (!zefUrl)
+        return [];
+    const client = new URL(zefUrl);
+    const agency = new URL(client.origin);
+    agency.hostname = client.hostname.replace(/^[^.]+/, "admin");
+    return [...new Set([client.origin, agency.origin])];
+}
+/** Origine du CMS qui ouvre l'aperçu (`?cms=`), si elle est autorisée ; sinon celle du client. */
+export function cmsOrigin(requested, zefUrl = process.env.ZEF_URL) {
+    const allowed = cmsOrigins(zefUrl);
+    return requested && allowed.includes(requested) ? requested : (allowed[0] ?? "");
+}

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+import type { AstroIntegration } from "astro";
+export * from "./helpers.js";
+export type ZefOptions = {
+    /** Gabarit des pages du CMS (en-tête, pied, styles du site). */
+    layout?: string;
+    /**
+     * Adresses publiques des médias, optimisés au build par `<Image>`. Par défaut le CDN de
+     * l'agence (`https://medias.agence-zef.fr`), plus `ZEF_MEDIA_URL` si elle est posée
+     * (MinIO en local : `http://localhost:9000`).
+     */
+    mediaUrls?: string[];
+};
+/**
+ * Intégration Astro du CMS ZEF (cahier des charges § 10) : route attrape-tout des pages
+ * et des collections avec page (les sections choisies dans l'éditeur, sans gabarit), rendu des
+ * sections (`src/sections/<nom>/index.astro`). Lit ZEF_URL et ZEF_API_KEY.
+ */
+export default function zef(options?: ZefOptions): AstroIntegration;

package/dist/index.js

@@ -0,0 +1,145 @@
+import { existsSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { loadZefEnv } from "./env.js";
+import { getClient } from "./helpers.js";
+export * from "./helpers.js";
+const MEDIA_URL = "https://medias.agence-zef.fr";
+/** Domaines autorisés pour l'optimisation des images distantes (`image.remotePatterns`). */
+function mediaPatterns(urls) {
+    return urls.flatMap((raw) => {
+        try {
+            const url = new URL(raw);
+            return [
+                {
+                    protocol: url.protocol.replace(":", ""),
+                    hostname: url.hostname,
+                    ...(url.port ? { port: url.port } : {}),
+                },
+            ];
+        }
+        catch {
+            return [];
+        }
+    });
+}
+const VIRTUAL = {
+    config: "virtual:zef/config",
+    sections: "virtual:zef/sections",
+    layout: "virtual:zef/layout",
+};
+/** `{ hero: "/…/src/sections/hero/index.astro" }` pour chaque dossier de `src/sections`. */
+function sectionFiles(root) {
+    const dir = join(root, "src", "sections");
+    if (!existsSync(dir))
+        return {};
+    return Object.fromEntries(readdirSync(dir, { withFileTypes: true })
+        .filter((d) => d.isDirectory() && existsSync(join(dir, d.name, "index.astro")))
+        .map((d) => [d.name, join(dir, d.name, "index.astro")]));
+}
+const importMap = (files) => {
+    const entries = Object.entries(files);
+    return [
+        ...entries.map(([, file], i) => `import C${i} from ${JSON.stringify(file)};`),
+        `export default { ${entries.map(([name], i) => `${JSON.stringify(name)}: C${i}`).join(", ")} };`,
+    ].join("\n");
+};
+/**
+ * Intégration Astro du CMS ZEF (cahier des charges § 10) : route attrape-tout des pages
+ * et des collections avec page (les sections choisies dans l'éditeur, sans gabarit), rendu des
+ * sections (`src/sections/<nom>/index.astro`). Lit ZEF_URL et ZEF_API_KEY.
+ */
+export default function zef(options = {}) {
+    return {
+        name: "@agence-zef/astro",
+        hooks: {
+            "astro:config:setup": async ({ config, command, injectRoute, updateConfig, addWatchFile, logger, }) => {
+                const root = fileURLToPath(config.root);
+                loadZefEnv(root);
+                // Redirections du CMS (C-17 : slugs modifiés, pages déplacées, redirections manuelles).
+                if ((command === "build" || command === "dev") &&
+                    process.env.ZEF_URL &&
+                    process.env.ZEF_API_KEY) {
+                    try {
+                        const list = await getClient().redirects();
+                        updateConfig({
+                            redirects: Object.fromEntries(list.map((r) => [r.from, { status: r.status, destination: r.to }])),
+                        });
+                    }
+                    catch (error) {
+                        logger.warn(`redirections non chargées : ${error instanceof Error ? error.message : error}`);
+                    }
+                }
+                // Médias de la médiathèque : optimisés au build par `<Image>` (format, poids, srcset).
+                updateConfig({
+                    image: {
+                        remotePatterns: mediaPatterns([
+                            ...(options.mediaUrls ?? [MEDIA_URL]),
+                            ...(process.env.ZEF_MEDIA_URL ? [process.env.ZEF_MEDIA_URL] : []),
+                        ]),
+                    },
+                });
+                addWatchFile(join(root, ".env"));
+                const layout = join(root, options.layout ?? "src/layouts/Page.astro");
+                const configFile = join(root, "zef.config.ts");
+                injectRoute({
+                    pattern: "/[...path]",
+                    entrypoint: "@agence-zef/astro/routes/page.astro",
+                    prerender: true,
+                });
+                injectRoute({
+                    pattern: "/robots.txt",
+                    entrypoint: "@agence-zef/astro/routes/robots.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({
+                        pattern: "/__zef/preview",
+                        entrypoint: "@agence-zef/astro/routes/preview.astro",
+                        prerender: false,
+                    });
+                    injectRoute({
+                        pattern: "/__zef/preview/section",
+                        entrypoint: "@agence-zef/astro/routes/preview-section.astro",
+                        prerender: false,
+                    });
+                    injectRoute({
+                        pattern: "/__zef/preview/thumbnail",
+                        entrypoint: "@agence-zef/astro/routes/preview-thumbnail.astro",
+                        prerender: false,
+                    });
+                }
+                else {
+                    logger.info("pas d'adaptateur : la route d'aperçu de l'éditeur n'est pas construite");
+                }
+                updateConfig({
+                    vite: {
+                        plugins: [
+                            {
+                                name: "zef:virtual",
+                                resolveId(id) {
+                                    return Object.values(VIRTUAL).includes(id) ? `\0${id}` : undefined;
+                                },
+                                load(id) {
+                                    if (id === `\0${VIRTUAL.config}`) {
+                                        return `export { default } from ${JSON.stringify(configFile)};`;
+                                    }
+                                    if (id === `\0${VIRTUAL.layout}`) {
+                                        if (!existsSync(layout)) {
+                                            throw new Error(`[@agence-zef/astro] gabarit introuvable : ${layout}`);
+                                        }
+                                        return `export { default } from ${JSON.stringify(layout)};`;
+                                    }
+                                    if (id === `\0${VIRTUAL.sections}`)
+                                        return importMap(sectionFiles(root));
+                                    return undefined;
+                                },
+                            },
+                        ],
+                    },
+                });
+            },
+        },
+    };
+}

package/dist/overlay.d.ts

@@ -0,0 +1,110 @@
+/** Messages échangés avec l'éditeur. */
+export type FieldKind = "text" | "textarea" | "richtext" | "label" | "media" | "other";
+export type FieldInfo = {
+    label: string;
+    kind: FieldKind;
+};
+export type ToPreview = {
+    zef: "labels";
+    sections: Record<string, string>;
+    fields: Record<string, Record<string, FieldInfo>>;
+    /** Sections fixes (header, footer) : ni barre d'outils ni « + Ajouter une section ». */
+    fixed?: string[];
+    /** Lecture seule (rôle, ou quelqu'un d'autre a la main) : sélection seulement. */
+    readOnly?: boolean;
+} | {
+    zef: "select";
+    section: string | null;
+    path: string | null;
+} | {
+    zef: "text";
+    section: string;
+    path: string;
+    value: string;
+} | {
+    zef: "render";
+    section: {
+        id: string;
+        type: string;
+    };
+    after?: string | null;
+} | {
+    zef: "order";
+    ids: string[];
+} | {
+    zef: "remove";
+    id: string;
+}
+/** Historique (E-05) : sections modifiées ou ajoutées depuis une version, `null` pour effacer. */
+ | {
+    zef: "compare";
+    sections: Record<string, {
+        state: "modified" | "added";
+        label: string;
+    }> | null;
+}
+/** Commentaires (E-06) : épingles numérotées, mode « cliquez sur un élément », épingle à montrer. */
+ | {
+    zef: "pins";
+    pins: Pin[];
+} | {
+    zef: "commentMode";
+    on: boolean;
+} | {
+    zef: "showPin";
+    id: string;
+}
+/** Textes à ne pas éditer sur place (`<section>:<chemin>`) : ils contiennent des variables. */
+ | {
+    zef: "locked";
+    fields: string[];
+};
+export type Pin = {
+    id: string;
+    number: number;
+    section: string;
+    path: string | null;
+};
+export type Box = {
+    top: number;
+    left: number;
+    width: number;
+    height: number;
+};
+export type SectionAction = "up" | "down" | "duplicate" | "variants" | "delete";
+export type FromPreview = {
+    zef: "ready";
+} | {
+    zef: "select";
+    section: string | null;
+    path: string | null;
+} | {
+    zef: "edit";
+    section: string;
+    path: string;
+    value: string;
+} | {
+    zef: "action";
+    section: string;
+    action: SectionAction;
+} | {
+    zef: "insert";
+    after: string;
+} | {
+    zef: "pin";
+    id: string;
+    box: Box;
+} | {
+    zef: "commentTarget";
+    section: string;
+    path: string | null;
+    box: Box;
+}
+/** Fichier glissé sur l'image d'un champ média : l'éditeur l'envoie et remplace l'image. */
+ | {
+    zef: "drop";
+    section: string;
+    path: string;
+    file: File;
+};
+export declare function startOverlay(): void;