@komekoo/astro-cms 0.0.0-stage → 0.2.0

package/dist/apercu/script.js

@@ -0,0 +1,321 @@
+// Script d'aperçu exécuté dans le site du client, affiché dans l'admin. Frontière de sécurité :
+// - seuls les messages de l'origine de l'admin, venant de la fenêtre parente et validés par `lireMessage`, sont lus ;
+// - avant le premier `bonjour` valide, rien n'est modifié et aucun événement n'est capté ;
+// - le contenu n'est construit qu'avec `createElement`, `createTextNode`, `setAttribute` et `textContent`.
+// N'importe que `./protocole.js` : ce fichier est copié tel quel dans le site construit (module du navigateur).
+import { BALISES_RICHES, MAX_CHEMINS, MOTIF_CHEMIN_CMS, MOTIF_LIEN, MOTIF_SRC_IMAGE, estUrlAbsolue, lireMessage, } from './protocole.js';
+const CLASSE_ZONE = 'komekoo-zone';
+const CLASSE_ACTIVE = 'komekoo-zone--active';
+const CLASSE_ETIQUETTE = 'komekoo-zone__etiquette';
+const CLASSE_INFO = 'komekoo-info';
+const TEXTE_LIEN_DESACTIVE = "Les liens sont désactivés dans l'aperçu";
+const TEXTE_INDISPONIBLE = 'Visible dans la prévisualisation';
+const DUREE_INFO = 2000;
+const PROFONDEUR_MAX = 20;
+// Valeurs de la maquette 04 (`.zone-editable`, `--active`, `__etiquette`) recopiées en dur, préfixe `komekoo-`.
+const STYLES = `
+.${CLASSE_ZONE}{outline:1px dashed transparent!important;outline-offset:2px!important;cursor:pointer!important;transition:outline-color 120ms ease}
+.${CLASSE_ZONE}:hover{outline-color:#52525B!important}
+.${CLASSE_ACTIVE}{box-shadow:0 0 0 2px #5DEFB7!important}
+.${CLASSE_ETIQUETTE},.${CLASSE_INFO}{position:fixed;z-index:2147483647;margin:0;pointer-events:none;font-family:system-ui,-apple-system,"Segoe UI",Roboto,"Helvetica Neue",Arial,sans-serif;font-size:0.8125rem;font-weight:500;line-height:1.5;letter-spacing:normal;text-transform:none;white-space:nowrap}
+.${CLASSE_ETIQUETTE}{padding:0 0.5rem;border-radius:0.375rem;background:#5DEFB7;color:#0E2A1E}
+.${CLASSE_INFO}{padding:0.25rem 0.75rem;border-radius:0.625rem;background:#18181B;color:#FFFFFF;box-shadow:0 12px 32px rgba(31,28,25,0.14),0 1px 2px rgba(31,28,25,0.06)}
+@media (prefers-reduced-motion:reduce){.${CLASSE_ZONE}{transition:none}}
+`;
+const estObjet = (x) => typeof x === 'object' && x !== null && !Array.isArray(x);
+const srcImageAutorisee = (x) => estUrlAbsolue(x) || (typeof x === 'string' && MOTIF_SRC_IMAGE.test(x));
+function construire(document, noeuds, profondeur, parent) {
+    if (!Array.isArray(noeuds) || profondeur > PROFONDEUR_MAX)
+        return;
+    for (const noeud of noeuds) {
+        if (!estObjet(noeud))
+            continue;
+        const t = noeud.t;
+        if (t === 'texte') {
+            if (typeof noeud.v === 'string')
+                parent.appendChild(document.createTextNode(noeud.v));
+        }
+        else if (t === 'a') {
+            if (typeof noeud.href === 'string' && MOTIF_LIEN.test(noeud.href)) {
+                const a = document.createElement('a');
+                a.setAttribute('href', noeud.href);
+                construire(document, noeud.c, profondeur + 1, a);
+                parent.appendChild(a);
+            }
+            else {
+                // Adresse refusée : le texte du lien est gardé, sans lien.
+                construire(document, noeud.c, profondeur + 1, parent);
+            }
+        }
+        else if (t === 'img') {
+            if (srcImageAutorisee(noeud.src)) {
+                const img = document.createElement('img');
+                img.setAttribute('src', noeud.src);
+                img.setAttribute('alt', typeof noeud.alt === 'string' ? noeud.alt : '');
+                parent.appendChild(img);
+            }
+        }
+        else if (typeof t === 'string' && BALISES_RICHES.has(t)) {
+            const element = document.createElement(t);
+            if (t !== 'br')
+                construire(document, noeud.c, profondeur + 1, element);
+            parent.appendChild(element);
+        }
+        // Tout autre type est ignoré, avec ses enfants.
+    }
+}
+/** Remplace les enfants de `element` par l'arbre, en ne créant que les nœuds et attributs autorisés. */
+export function appliquerArbre(element, arbre) {
+    const document = element.ownerDocument;
+    const fragment = document.createDocumentFragment();
+    construire(document, arbre, 1, fragment);
+    element.replaceChildren(fragment);
+}
+function appliquerValeur(element, valeur) {
+    switch (valeur.type) {
+        case 'texte':
+            element.textContent = valeur.texte;
+            return;
+        case 'image':
+            if (element.localName !== 'img' || !estUrlAbsolue(valeur.src))
+                return;
+            element.setAttribute('src', valeur.src);
+            if (valeur.srcset === '')
+                element.removeAttribute('srcset');
+            else
+                element.setAttribute('srcset', valeur.srcset);
+            element.setAttribute('alt', valeur.alt);
+            return;
+        case 'lien':
+            if (element.localName !== 'a' || !MOTIF_LIEN.test(valeur.href))
+                return;
+            element.setAttribute('href', valeur.href);
+            if (valeur.texte !== undefined && Array.from(element.childNodes).every((n) => n.nodeType === 3)) {
+                element.textContent = valeur.texte;
+            }
+            return;
+        case 'riche':
+            appliquerArbre(element, valeur.arbre);
+            return;
+        case 'indisponible':
+            return;
+    }
+}
+function elementDe(cible) {
+    const noeud = cible;
+    if (!noeud || typeof noeud.nodeType !== 'number')
+        return null;
+    return noeud.nodeType === 1 ? noeud : noeud.parentElement;
+}
+/**
+ * Démarre l'aperçu dans `fenetre` : écoute les messages de l'admin (`origineAdmin`, fenêtre parente).
+ * Renvoie une fonction d'arrêt.
+ */
+export function demarrerApercu(fenetre, origineAdmin) {
+    const document = fenetre.document;
+    if (fenetre.parent === fenetre)
+        return () => { };
+    let actif = false;
+    let feuille = null;
+    let etiquette = null;
+    let info = null;
+    let minuterieInfo;
+    let zoneActive = null;
+    const indisponibles = new Set();
+    const marques = () => Array.from(document.querySelectorAll('[data-cms]'));
+    const marquesDe = (chemin) => marques().filter((e) => e.getAttribute('data-cms') === chemin);
+    function envoyer(message) {
+        fenetre.parent.postMessage(message, origineAdmin);
+    }
+    function installerStyles() {
+        try {
+            const Feuille = fenetre.CSSStyleSheet;
+            if (typeof Feuille !== 'function' || !Array.isArray(document.adoptedStyleSheets))
+                return;
+            const nouvelle = new Feuille();
+            nouvelle.replaceSync(STYLES);
+            document.adoptedStyleSheets = [...document.adoptedStyleSheets, nouvelle];
+            feuille = nouvelle;
+        }
+        catch {
+            feuille = null;
+        }
+    }
+    function marquerZones() {
+        for (const element of marques())
+            element.classList.add(CLASSE_ZONE);
+    }
+    function placer(boite, gauche, haut) {
+        const largeur = fenetre.innerWidth || 0;
+        boite.style.setProperty('left', `${Math.max(0, Math.min(gauche, largeur - boite.offsetWidth - 4))}px`);
+        boite.style.setProperty('top', `${Math.max(0, haut)}px`);
+    }
+    function placerEtiquette() {
+        if (!etiquette || !zoneActive)
+            return;
+        const cible = marquesDe(zoneActive.chemin)[0];
+        if (!cible)
+            return;
+        const rect = cible.getBoundingClientRect();
+        const haut = rect.top - etiquette.offsetHeight - 4;
+        placer(etiquette, rect.left, haut < 0 ? rect.bottom + 4 : haut);
+    }
+    function retirerActif() {
+        for (const element of document.querySelectorAll(`.${CLASSE_ACTIVE}`))
+            element.classList.remove(CLASSE_ACTIVE);
+        etiquette?.remove();
+    }
+    function afficherActif(defiler) {
+        retirerActif();
+        if (!zoneActive)
+            return;
+        const elements = marquesDe(zoneActive.chemin);
+        if (elements.length === 0)
+            return;
+        for (const element of elements)
+            element.classList.add(CLASSE_ACTIVE);
+        const morceaux = [zoneActive.libelle, indisponibles.has(zoneActive.chemin) ? TEXTE_INDISPONIBLE : ''].filter(Boolean);
+        if (morceaux.length > 0) {
+            etiquette ??= document.createElement('span');
+            etiquette.className = CLASSE_ETIQUETTE;
+            etiquette.setAttribute('aria-hidden', 'true');
+            etiquette.textContent = morceaux.join(' — ');
+            (document.body ?? document.documentElement).appendChild(etiquette);
+            placerEtiquette();
+        }
+        if (defiler) {
+            const premier = elements[0];
+            const reduit = typeof fenetre.matchMedia === 'function' && fenetre.matchMedia('(prefers-reduced-motion: reduce)').matches;
+            if (typeof premier.scrollIntoView === 'function') {
+                premier.scrollIntoView({ behavior: reduit ? 'auto' : 'smooth', block: 'nearest', inline: 'nearest' });
+            }
+        }
+    }
+    function retirerInfo() {
+        if (minuterieInfo !== undefined)
+            fenetre.clearTimeout(minuterieInfo);
+        minuterieInfo = undefined;
+        info?.remove();
+        info = null;
+    }
+    function afficherInfo(gauche, haut) {
+        retirerInfo();
+        const bulle = document.createElement('div');
+        bulle.className = CLASSE_INFO;
+        bulle.setAttribute('role', 'status');
+        bulle.style.setProperty('position', 'fixed');
+        bulle.style.setProperty('z-index', '2147483647');
+        bulle.style.setProperty('pointer-events', 'none');
+        bulle.textContent = TEXTE_LIEN_DESACTIVE;
+        (document.body ?? document.documentElement).appendChild(bulle);
+        placer(bulle, gauche + 12, haut + 12);
+        info = bulle;
+        minuterieInfo = fenetre.setTimeout(retirerInfo, DUREE_INFO);
+    }
+    function surClic(evenement) {
+        const element = elementDe(evenement.target);
+        if (!element)
+            return;
+        const zone = element.closest('[data-cms]');
+        const chemin = zone?.getAttribute('data-cms');
+        if (chemin && MOTIF_CHEMIN_CMS.test(chemin)) {
+            evenement.preventDefault();
+            envoyer({ cms: 1, type: 'clic', chemin });
+            return;
+        }
+        const lien = element.closest('a[href], area[href]');
+        if (!lien)
+            return;
+        evenement.preventDefault();
+        let adresse = null;
+        try {
+            adresse = new URL(lien.getAttribute('href') ?? '', document.baseURI);
+        }
+        catch {
+            adresse = null;
+        }
+        if (adresse && adresse.origin === fenetre.location.origin) {
+            const message = lireMessage({ cms: 1, type: 'lien', adresse: adresse.pathname });
+            if (message) {
+                envoyer(message);
+                return;
+            }
+        }
+        afficherInfo(evenement.clientX, evenement.clientY);
+    }
+    function surAuxClic(evenement) {
+        // Clic du milieu sur un lien : ouvrirait la page hors de l'aperçu.
+        if (elementDe(evenement.target)?.closest('a[href], area[href]'))
+            evenement.preventDefault();
+    }
+    function surEnvoi(evenement) {
+        evenement.preventDefault();
+        const formulaire = elementDe(evenement.target);
+        const rect = formulaire?.getBoundingClientRect();
+        afficherInfo(rect ? rect.left : 0, rect ? rect.top : 0);
+    }
+    function surDefilement() {
+        placerEtiquette();
+    }
+    function activer() {
+        actif = true;
+        installerStyles();
+        fenetre.addEventListener('click', surClic, true);
+        fenetre.addEventListener('auxclick', surAuxClic, true);
+        fenetre.addEventListener('submit', surEnvoi, true);
+        fenetre.addEventListener('scroll', surDefilement, { capture: true, passive: true });
+        fenetre.addEventListener('resize', surDefilement, { passive: true });
+    }
+    function surMessage(evenement) {
+        if (evenement.origin !== origineAdmin || evenement.source !== fenetre.parent)
+            return;
+        const message = lireMessage(evenement.data);
+        if (!message)
+            return;
+        if (message.type === 'bonjour') {
+            if (!actif)
+                activer();
+            marquerZones();
+            const chemins = [...new Set(marques().map((e) => e.getAttribute('data-cms') ?? ''))]
+                .filter((chemin) => MOTIF_CHEMIN_CMS.test(chemin))
+                .slice(0, MAX_CHEMINS);
+            envoyer({ cms: 1, type: 'pret', chemins });
+            return;
+        }
+        if (!actif)
+            return;
+        if (message.type === 'valeurs') {
+            marquerZones();
+            for (const [chemin, valeur] of Object.entries(message.valeurs)) {
+                if (valeur.type === 'indisponible')
+                    indisponibles.add(chemin);
+                else
+                    indisponibles.delete(chemin);
+                for (const element of marquesDe(chemin))
+                    appliquerValeur(element, valeur);
+            }
+            afficherActif(false);
+        }
+        else if (message.type === 'actif') {
+            marquerZones();
+            zoneActive = message.chemin === null ? null : { chemin: message.chemin, libelle: message.libelle ?? '' };
+            afficherActif(true);
+        }
+    }
+    fenetre.addEventListener('message', surMessage);
+    return () => {
+        fenetre.removeEventListener('message', surMessage);
+        fenetre.removeEventListener('click', surClic, true);
+        fenetre.removeEventListener('auxclick', surAuxClic, true);
+        fenetre.removeEventListener('submit', surEnvoi, true);
+        fenetre.removeEventListener('scroll', surDefilement, true);
+        fenetre.removeEventListener('resize', surDefilement);
+        retirerInfo();
+        retirerActif();
+        if (feuille) {
+            const retiree = feuille;
+            document.adoptedStyleSheets = document.adoptedStyleSheets.filter((f) => f !== retiree);
+        }
+        actif = false;
+    };
+}

package/dist/champs.d.ts

@@ -0,0 +1,49 @@
+import { z } from 'astro/zod';
+import type { OptionsBase } from './types.js';
+import { MOTIF_LIEN, MOTIF_SRC_IMAGE } from './motifs.js';
+export { MOTIF_LIEN, MOTIF_SRC_IMAGE };
+type Bornes = {
+    min?: number;
+    max?: number;
+};
+/** `obligatoire: false` → `ZodOptional<T>` ; absent ou `true` → `T` ; `boolean` non littéral → l'un ou l'autre. */
+export type Finalise<T extends z.ZodType, O extends OptionsBase> = O extends {
+    obligatoire: false;
+} ? z.ZodOptional<T> : O extends {
+    obligatoire: true;
+} ? T : 'obligatoire' extends keyof O ? T | z.ZodOptional<T> : T;
+export declare const champ: {
+    texte: <O extends OptionsBase & Bornes>(o: O) => Finalise<z.ZodString, O>;
+    paragraphe: <O extends OptionsBase & Bornes>(o: O) => Finalise<z.ZodString, O>;
+    richtext: <O extends OptionsBase & {
+        max?: number;
+    }>(o: O) => Finalise<z.ZodString, O>;
+    image: <O extends OptionsBase>(o: O) => Finalise<z.ZodObject<{
+        src: z.ZodString;
+        alt: z.ZodString;
+        largeur: z.ZodInt;
+        hauteur: z.ZodInt;
+    }, z.core.$strict>, O>;
+    date: <O extends OptionsBase>(o: O) => Finalise<z.ZodISODate, O>;
+    lien: <O extends OptionsBase>(o: O) => Finalise<z.ZodString, O>;
+    nombre: <O extends OptionsBase & Bornes & {
+        entier?: boolean;
+        unite?: string;
+    }>(o: O) => Finalise<z.ZodNumber, O>;
+    booleen: <O extends OptionsBase>(o: O) => Finalise<z.ZodBoolean, O>;
+    choix: <const Options extends readonly [string, ...string[]], O extends OptionsBase>(o: O & {
+        options: Options;
+    }) => Finalise<z.ZodEnum<{ [k in Options[number]]: k; } extends infer T ? { [k in keyof T]: T[k]; } : never>, O & {
+        options: Options;
+    }>;
+    liste: <E extends z.ZodType, O extends OptionsBase & Bornes>(o: O & {
+        element: E;
+    }) => Finalise<z.ZodArray<E>, O & {
+        element: E;
+    }>;
+    groupe: <S extends Record<string, z.ZodType>, O extends OptionsBase>(o: O & {
+        champs: S;
+    }) => Finalise<z.ZodObject<{ -readonly [P in keyof S]: S[P]; }, z.core.$strict>, O & {
+        champs: S;
+    }>;
+};

package/dist/champs.js

@@ -0,0 +1,58 @@
+import { z } from 'astro/zod';
+import { MOTIF_LIEN, MOTIF_SRC_IMAGE } from './motifs.js';
+export { MOTIF_LIEN, MOTIF_SRC_IMAGE };
+/** Appose la méta CMS puis, si le champ n'est pas obligatoire, `.optional()`. */
+function finaliser(schema, o, editeur, extra = {}) {
+    const cms = { editeur, libelle: o.libelle };
+    if (o.aide !== undefined)
+        cms.aide = o.aide;
+    if (o.onglet !== undefined) {
+        if (o.onglet === '')
+            throw new Error(`onglet du champ « ${o.libelle} » : texte non vide attendu`);
+        cms.onglet = o.onglet;
+    }
+    if (extra.unite !== undefined)
+        cms.unite = extra.unite;
+    const avecMeta = schema.meta({ cms });
+    return (o.obligatoire === false ? avecMeta.optional() : avecMeta);
+}
+function chaine({ min, max }) {
+    let s = z.string();
+    if (min !== undefined)
+        s = s.min(min);
+    if (max !== undefined)
+        s = s.max(max);
+    return s;
+}
+export const champ = {
+    texte: (o) => finaliser(chaine(o), o, 'texte'),
+    paragraphe: (o) => finaliser(chaine(o), o, 'paragraphe'),
+    richtext: (o) => finaliser(chaine({ max: o.max }), o, 'richtext'),
+    image: (o) => finaliser(z.strictObject({
+        src: z.string().regex(MOTIF_SRC_IMAGE),
+        alt: z.string().max(250),
+        largeur: z.int().positive(),
+        hauteur: z.int().positive(),
+    }), o, 'image'),
+    date: (o) => finaliser(z.iso.date(), o, 'date'),
+    lien: (o) => finaliser(z.string().regex(MOTIF_LIEN), o, 'lien'),
+    nombre: (o) => {
+        let s = o.entier ? z.int() : z.number();
+        if (o.min !== undefined)
+            s = s.min(o.min);
+        if (o.max !== undefined)
+            s = s.max(o.max);
+        return finaliser(s, o, 'nombre', { unite: o.unite });
+    },
+    booleen: (o) => finaliser(z.boolean(), o, 'booleen'),
+    choix: (o) => finaliser(z.enum(o.options), o, 'choix'),
+    liste: (o) => {
+        let s = z.array(o.element);
+        if (o.min !== undefined)
+            s = s.min(o.min);
+        if (o.max !== undefined)
+            s = s.max(o.max);
+        return finaliser(s, o, 'liste');
+    },
+    groupe: (o) => finaliser(z.strictObject(o.champs), o, 'groupe'),
+};

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+/** Cœur testable de la CLI : renvoie le code de sortie. */
+export declare function executerCli(argv: string[], racine: string): Promise<number>;

package/dist/cli.js

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+import { realpathSync } from 'node:fs';
+import { pathToFileURL } from 'node:url';
+import { parseArgs } from 'node:util';
+import { chargerOptions } from './integration.js';
+import { formaterViolations } from './noyau/contenus.js';
+import { ErreurCms } from './noyau/erreurs.js';
+import { synchroniser, verifier } from './noyau/operations.js';
+const AIDE = `Usage : komekoo-cms <commande>
+
+Commandes :
+  sync    génère cms.schema.json et ai/manifest.json
+  check   vérifie les fichiers générés et valide les contenus (code 1 si problème)
+
+Options :
+  -h, --help   affiche cette aide`;
+/** Cœur testable de la CLI : renvoie le code de sortie. */
+export async function executerCli(argv, racine) {
+    const { positionals, values } = parseArgs({
+        args: argv,
+        allowPositionals: true,
+        options: { help: { type: 'boolean', short: 'h' } },
+    });
+    const commande = positionals[0];
+    if (values.help || (commande !== 'sync' && commande !== 'check')) {
+        console.error(AIDE);
+        return values.help && commande === undefined ? 0 : 2;
+    }
+    try {
+        const options = await chargerOptions(racine);
+        if (commande === 'sync') {
+            const ecrits = await synchroniser(racine, options);
+            console.log(ecrits.length === 0 ? 'Fichiers à jour.' : ecrits.map((f) => `réécrit : ${f}`).join('\n'));
+            return 0;
+        }
+        const violations = await verifier(racine, options);
+        if (violations.length === 0) {
+            console.log('Aucun problème.');
+            return 0;
+        }
+        console.log(formaterViolations(violations));
+        return 1;
+    }
+    catch (e) {
+        if (!(e instanceof ErreurCms))
+            throw e;
+        console.error(e.message);
+        return 1;
+    }
+}
+function estPrincipal() {
+    const script = process.argv[1];
+    if (script === undefined)
+        return false;
+    try {
+        return import.meta.url === pathToFileURL(realpathSync(script)).href;
+    }
+    catch {
+        return false;
+    }
+}
+if (estPrincipal()) {
+    try {
+        process.exitCode = await executerCli(process.argv.slice(2), process.cwd());
+    }
+    catch (e) {
+        console.error(e instanceof Error ? e.message : String(e));
+        process.exitCode = 1;
+    }
+}

package/dist/collections.d.ts

@@ -0,0 +1,39 @@
+import { z } from 'astro/zod';
+import { glob } from 'astro/loaders';
+import type { DeclCollection, DeclSingleton } from './types.js';
+/** Clé symbole portant les métadonnées CMS sur l'objet collection (invisible pour Astro). */
+export declare const CMS: unique symbol;
+type Loader = ReturnType<typeof glob>;
+type Forme = Record<string, z.ZodType>;
+type ChampOrdre = {
+    ordre: z.ZodInt;
+};
+/** Schéma strict d'une collection : sa forme, plus `ordre` si elle est ordonnable. */
+export type SchemaCollection<S extends Forme, Ord extends boolean> = z.ZodObject<Ord extends true ? S & ChampOrdre : S, z.core.$strict>;
+/** Type que pose `defineCollection` d'astro:content ; Astro refuse une collection à loader sans lui. */
+declare const TYPE_ASTRO = "content_layer";
+export declare function defineSingleton<S extends Forme>(id: string, o: {
+    libelle: string;
+    adresse?: string;
+    apercu?: string;
+    schema: S;
+}): {
+    type: typeof TYPE_ASTRO;
+    loader: Loader;
+    schema: z.ZodObject<S, z.core.$strict>;
+    [CMS]: DeclSingleton;
+};
+export declare function defineCollection<S extends Forme, Ord extends boolean = false>(id: string, o: {
+    libelle: string;
+    format: 'json' | 'markdown';
+    titre: string;
+    ordonnable?: Ord;
+    schema: S;
+}): {
+    type: typeof TYPE_ASTRO;
+    loader: Loader;
+    schema: SchemaCollection<S, Ord>;
+    [CMS]: DeclCollection;
+};
+export declare function lireDecl(c: unknown): DeclSingleton | DeclCollection | undefined;
+export {};

package/dist/collections.js

@@ -0,0 +1,57 @@
+import { z } from 'astro/zod';
+import { glob } from 'astro/loaders';
+import { lireMeta } from './types.js';
+/** Clé symbole portant les métadonnées CMS sur l'objet collection (invisible pour Astro). */
+export const CMS = Symbol.for('komekoo-cms.decl');
+/** Type que pose `defineCollection` d'astro:content ; Astro refuse une collection à loader sans lui. */
+const TYPE_ASTRO = 'content_layer';
+const RE_ADRESSE = /^\/[a-z0-9\-\/]*$/;
+const RE_ID = /^[a-z][a-z0-9-]*$/;
+function verifierId(id) {
+    if (!RE_ID.test(id)) {
+        throw new Error(`id « ${id} » invalide : attendu ${RE_ID.source}`);
+    }
+}
+export function defineSingleton(id, o) {
+    verifierId(id);
+    if (o.adresse !== undefined && !RE_ADRESSE.test(o.adresse)) {
+        throw new Error(`adresse « ${o.adresse} » invalide : attendu ${RE_ADRESSE.source}`);
+    }
+    if (o.apercu !== undefined && !RE_ADRESSE.test(o.apercu)) {
+        throw new Error(`apercu « ${o.apercu} » invalide : attendu ${RE_ADRESSE.source}`);
+    }
+    const decl = { type: 'singleton', id, libelle: o.libelle };
+    if (o.adresse !== undefined)
+        decl.adresse = o.adresse;
+    if (o.apercu !== undefined)
+        decl.apercu = o.apercu;
+    return {
+        type: TYPE_ASTRO,
+        loader: glob({ pattern: `${id}.json`, base: './src/content/pages' }),
+        schema: z.strictObject(o.schema),
+        [CMS]: decl,
+    };
+}
+export function defineCollection(id, o) {
+    verifierId(id);
+    if (id === 'pages') {
+        throw new Error("l'id « pages » est réservé aux singletons");
+    }
+    const champTitre = o.schema[o.titre];
+    if (!champTitre || lireMeta(champTitre)?.editeur !== 'texte') {
+        throw new Error(`titre « ${o.titre} » doit désigner un champ existant de type texte`);
+    }
+    const ordonnable = o.ordonnable ?? false;
+    const forme = ordonnable ? { ...o.schema, ordre: z.int().min(0) } : o.schema;
+    return {
+        type: TYPE_ASTRO,
+        loader: glob({ pattern: o.format === 'json' ? '**/*.json' : '**/*.md', base: `./src/content/${id}` }),
+        schema: z.strictObject(forme),
+        [CMS]: { type: 'collection', id, libelle: o.libelle, format: o.format, titre: o.titre, ordonnable },
+    };
+}
+export function lireDecl(c) {
+    if (typeof c !== 'object' || c === null)
+        return undefined;
+    return c[CMS];
+}

package/dist/images.d.ts

@@ -0,0 +1,8 @@
+export declare const LARGEURS: readonly [800, 1600, 2400];
+export type Variante = {
+    largeur: (typeof LARGEURS)[number];
+    url: string;
+};
+export declare function variantes(src: string): Variante[];
+/** Variantes strictement plus petites que l'original, puis le fichier -2400 (original non agrandi). */
+export declare function srcsetDe(src: string, largeurOriginale: number): string;

package/dist/images.js

@@ -0,0 +1,19 @@
+import { MOTIF_SRC_IMAGE } from './motifs.js';
+export const LARGEURS = [800, 1600, 2400];
+export function variantes(src) {
+    if (!MOTIF_SRC_IMAGE.test(src)) {
+        throw new Error(`Chemin d'image invalide : ${src}`);
+    }
+    const base = src.slice(0, -'-2400.webp'.length);
+    return LARGEURS.map((largeur) => ({ largeur, url: `${base}-${largeur}.webp` }));
+}
+/** Variantes strictement plus petites que l'original, puis le fichier -2400 (original non agrandi). */
+export function srcsetDe(src, largeurOriginale) {
+    const toutes = variantes(src);
+    const plusGrande = toutes[toutes.length - 1];
+    const entrees = toutes
+        .filter((v) => v !== plusGrande && v.largeur < largeurOriginale)
+        .map((v) => `${v.url} ${v.largeur}w`);
+    entrees.push(`${plusGrande.url} ${Math.min(largeurOriginale, 2400)}w`);
+    return entrees.join(', ');
+}

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export declare const VERSION_SCHEMA = 1;
+export { champ } from './champs.js';
+export { lireMeta } from './types.js';
+export type { Editeur, MetaCms, OptionsBase, DeclSingleton, DeclCollection } from './types.js';
+export { ErreurCms } from './noyau/erreurs.js';
+export { defineSingleton, defineCollection, lireDecl, CMS } from './collections.js';
+export { cms } from './marqueur.js';
+export { creerAjv, MOTS_CLES_CMS } from './ajv.js';
+export { versManifest } from './noyau/manifest.js';
+export type { OptionsCms } from './noyau/manifest.js';
+export { HORS_PERIMETRE_SOCLE } from './socle/hors-perimetre.js';
+export { LARGEURS, variantes, srcsetDe } from './images.js';
+export type { Variante } from './images.js';

package/dist/index.js

@@ -0,0 +1,10 @@
+export const VERSION_SCHEMA = 1;
+export { champ } from './champs.js';
+export { lireMeta } from './types.js';
+export { ErreurCms } from './noyau/erreurs.js';
+export { defineSingleton, defineCollection, lireDecl, CMS } from './collections.js';
+export { cms } from './marqueur.js';
+export { creerAjv, MOTS_CLES_CMS } from './ajv.js';
+export { versManifest } from './noyau/manifest.js';
+export { HORS_PERIMETRE_SOCLE } from './socle/hors-perimetre.js';
+export { LARGEURS, variantes, srcsetDe } from './images.js';

package/dist/integration.d.ts

@@ -0,0 +1,9 @@
+import type { AstroIntegration } from 'astro';
+import type { OptionsCms } from './noyau/manifest.js';
+/** `Symbol.for` : la même clé que l'intégration soit chargée par Node ou par Vite (`chargerOptions`). */
+export declare const OPTIONS: unique symbol;
+export default function cms(options: OptionsCms): AstroIntegration & {
+    [OPTIONS]: OptionsCms;
+};
+/** Retrouve les options passées à `cms()` dans `astro.config.mjs` (utilisé par la CLI). */
+export declare function chargerOptions(racine: string): Promise<OptionsCms>;