@komekoo/astro-cms 0.0.0-stage → 0.2.0

package/dist/integration.js

@@ -0,0 +1,113 @@
+import { promises as fsp } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { chargerConfigAstro } from './noyau/charger.js';
+import { formaterViolations } from './noyau/contenus.js';
+import { MOTIF_SRC_IMAGE, MOTIF_URL_SITE } from './motifs.js';
+import { ErreurCms } from './noyau/erreurs.js';
+import { synchroniser, verifier } from './noyau/operations.js';
+import { ecrireApercu } from './noyau/apercu-build.js';
+import { verifierMarqueurs } from './noyau/marqueurs.js';
+import { ecrireVersion } from './noyau/version.js';
+const NOM = '@komekoo/astro-cms';
+/** `Symbol.for` : la même clé que l'intégration soit chargée par Node ou par Vite (`chargerOptions`). */
+export const OPTIONS = Symbol.for('@komekoo/astro-cms/options');
+const estTexte = (v) => typeof v === 'string' && v.trim() !== '';
+/** Options passées depuis `astro.config.mjs` (JavaScript, non typé) : vérifiées à l'appel de `cms()`. */
+function verifierOptions(options) {
+    const o = (typeof options === 'object' && options !== null ? options : {});
+    for (const cle of ['site', 'contact']) {
+        if (!estTexte(o[cle]))
+            throw new ErreurCms(`${NOM} : option « ${cle} » obligatoire (texte non vide)`, 'astro.config.mjs');
+    }
+    const hp = o.horsPerimetre;
+    if (hp !== undefined && !(Array.isArray(hp) && hp.every((x) => typeof x === 'string'))) {
+        throw new ErreurCms(`${NOM} : option « horsPerimetre » doit être une liste de textes`, 'astro.config.mjs');
+    }
+    const refuser = (cle, attendu) => {
+        throw new ErreurCms(`${NOM} : option « ${cle} » ${attendu}`, 'astro.config.mjs');
+    };
+    if (!estTexte(o.url) || !MOTIF_URL_SITE.test(o.url) || o.url.endsWith('/')) {
+        refuser('url', 'obligatoire : adresse https sans « / » final (ex. https://exemple.fr)');
+    }
+    const admin = o.admin;
+    if (admin === undefined)
+        return;
+    if (typeof admin !== 'object' || admin === null || Array.isArray(admin)) {
+        return refuser('admin', 'doit être un objet { accent?, logo?, origine?, apercu? }');
+    }
+    const { accent, logo, origine, apercu } = admin;
+    if (accent !== undefined && !(typeof accent === 'string' && /^#[0-9A-Fa-f]{6}$/.test(accent))) {
+        refuser('admin.accent', 'doit être une couleur au format #RRGGBB');
+    }
+    if (logo !== undefined && !(typeof logo === 'string' && MOTIF_SRC_IMAGE.test(logo))) {
+        refuser('admin.logo', 'doit être une image téléversée (/uploads/…-2400.webp)');
+    }
+    if (origine !== undefined && !(typeof origine === 'string' && /^https:\/\/[^\s/]+$/.test(origine))) {
+        refuser('admin.origine', 'doit être une origine https sans chemin (ex. https://admin.exemple.fr)');
+    }
+    if (apercu !== undefined && !(typeof apercu === 'string' && MOTIF_URL_SITE.test(apercu) && !apercu.endsWith('/'))) {
+        refuser('admin.apercu', 'doit être une adresse https sans « / » final (ex. https://apercu.exemple.pages.dev)');
+    }
+}
+export default function cms(options) {
+    verifierOptions(options);
+    let racineProjet = '';
+    return {
+        name: NOM,
+        [OPTIONS]: options,
+        hooks: {
+            'astro:config:setup': async ({ config, command, addWatchFile, logger }) => {
+                const racine = fileURLToPath(config.root);
+                racineProjet = racine;
+                if (command === 'dev' || command === 'sync')
+                    await synchroniser(racine, options);
+                if (command === 'dev')
+                    addWatchFile(path.join(racine, 'src/content.config.ts'));
+                // Avant la synchronisation de contenu d'Astro (glob loader), qui s'arrête à la première erreur Zod.
+                if (command === 'build') {
+                    const violations = await verifier(racine, options);
+                    if (violations.length === 0)
+                        return;
+                    logger.error(formaterViolations(violations));
+                    throw new ErreurCms(`${violations.length} problème(s) de contenu`);
+                }
+            },
+            'astro:build:done': async ({ dir, logger }) => {
+                const dist = fileURLToPath(dir);
+                const schema = JSON.parse(await fsp.readFile(path.join(racineProjet, 'cms.schema.json'), 'utf8'));
+                const erreurs = await verifierMarqueurs(dist, schema.singletons ?? {});
+                if (erreurs.length > 0) {
+                    for (const e of erreurs)
+                        logger.error(`${e.page} — ${e.chemin} — ${e.motif}`);
+                    throw new ErreurCms(`${erreurs.length} marqueur(s) d'aperçu invalide(s)`);
+                }
+                const origineAdmin = options.admin?.origine ?? 'https://cms.komekoo.link';
+                await ecrireVersion(dist, process.env.CF_PAGES_COMMIT_SHA ?? 'inconnu', origineAdmin);
+                await ecrireApercu(dist, {
+                    origineAdmin,
+                    branche: process.env.CF_PAGES_BRANCH,
+                    avertir: (m) => logger.warn(m),
+                });
+            },
+        },
+    };
+}
+function aplatir(valeur) {
+    return Array.isArray(valeur) ? valeur.flatMap(aplatir) : [valeur];
+}
+/** Retrouve les options passées à `cms()` dans `astro.config.mjs` (utilisé par la CLI). */
+export async function chargerOptions(racine) {
+    const config = await chargerConfigAstro(racine);
+    const integrations = config?.integrations;
+    for (const integration of aplatir(integrations)) {
+        if (typeof integration !== 'object' || integration === null)
+            continue;
+        if (integration.name !== NOM)
+            continue;
+        const options = integration[OPTIONS];
+        if (options !== undefined)
+            return options;
+    }
+    throw new ErreurCms(`intégration ${NOM} absente de astro.config.mjs`);
+}

package/dist/marqueur.d.ts

@@ -0,0 +1,4 @@
+/** Marqueur d'aperçu : `<h1 {...cms('accueil.titre')}>` pose `data-cms` pour que l'admin retrouve le champ. */
+export declare function cms(chemin: string): {
+    'data-cms': string;
+};

package/dist/marqueur.js

@@ -0,0 +1,8 @@
+import { MOTIF_CHEMIN_CMS } from './motifs.js';
+/** Marqueur d'aperçu : `<h1 {...cms('accueil.titre')}>` pose `data-cms` pour que l'admin retrouve le champ. */
+export function cms(chemin) {
+    if (!MOTIF_CHEMIN_CMS.test(chemin)) {
+        throw new Error(`chemin d'aperçu « ${chemin} » invalide : attendu ${MOTIF_CHEMIN_CMS.source}`);
+    }
+    return { 'data-cms': chemin };
+}

package/dist/motifs.d.ts

@@ -0,0 +1,10 @@
+export declare const MOTIF_SRC_IMAGE: RegExp;
+/**
+ * Schéma autorisé, puis aucun espace ni caractère de contrôle : les navigateurs suppriment tabulations et sauts
+ * de ligne (`/\t/evil.com` → `//evil.com`), d'où leur exclusion aussi juste après la barre oblique initiale.
+ */
+export declare const MOTIF_LIEN: RegExp;
+/** Adresse publique du site : https, sans espace, sans « ? » ni « # » (le « / » final est refusé à part). */
+export declare const MOTIF_URL_SITE: RegExp;
+/** Chemin d'un champ dans une page : id du singleton, puis noms de champ ou indices (`reglages.horaires.2.ouverture`). */
+export declare const MOTIF_CHEMIN_CMS: RegExp;

package/dist/motifs.js

@@ -0,0 +1,11 @@
+// Motifs partagés entre le schéma (`champs.ts`, qui dépend d'Astro) et le navigateur : aucun import ici.
+export const MOTIF_SRC_IMAGE = /^\/uploads\/(?:[a-z0-9-]+\/)*[a-z0-9-]+-2400\.webp$/;
+/**
+ * Schéma autorisé, puis aucun espace ni caractère de contrôle : les navigateurs suppriment tabulations et sauts
+ * de ligne (`/\t/evil.com` → `//evil.com`), d'où leur exclusion aussi juste après la barre oblique initiale.
+ */
+export const MOTIF_LIEN = /^(https:\/\/[^\s\x00-\x1f]|\/(?![\/\\\s])|mailto:|tel:)[^\s\x00-\x1f]*$/;
+/** Adresse publique du site : https, sans espace, sans « ? » ni « # » (le « / » final est refusé à part). */
+export const MOTIF_URL_SITE = /^https:\/\/[^\s/?#]+(\/[^\s?#]*)?$/;
+/** Chemin d'un champ dans une page : id du singleton, puis noms de champ ou indices (`reglages.horaires.2.ouverture`). */
+export const MOTIF_CHEMIN_CMS = /^[a-z][a-z0-9-]*(\.([A-Za-z][A-Za-z0-9]*|\d+))+$/;

package/dist/navigateur.d.ts

@@ -0,0 +1,6 @@
+export { creerAjv, MOTS_CLES_CMS } from './ajv.js';
+export { validerMarkdown } from './noyau/markdown.js';
+export type { Violation } from './noyau/markdown.js';
+export { lireFrontmatter, ecrireFrontmatter } from './noyau/frontmatter.js';
+export { MOTIF_CHEMIN_CMS, MOTIF_LIEN, MOTIF_SRC_IMAGE, MOTIF_URL_SITE } from './motifs.js';
+export { srcsetDe, variantes } from './images.js';

package/dist/navigateur.js

@@ -0,0 +1,6 @@
+// Point d'entrée sûr pour le navigateur : n'importe rien de `node:*`, `astro` ni `vite`.
+export { creerAjv, MOTS_CLES_CMS } from './ajv.js';
+export { validerMarkdown } from './noyau/markdown.js';
+export { lireFrontmatter, ecrireFrontmatter } from './noyau/frontmatter.js';
+export { MOTIF_CHEMIN_CMS, MOTIF_LIEN, MOTIF_SRC_IMAGE, MOTIF_URL_SITE } from './motifs.js';
+export { srcsetDe, variantes } from './images.js';

package/dist/noyau/apercu-build.d.ts

@@ -0,0 +1,12 @@
+/** Contenu de `_cms/chargeur.js` : fichier externe (compatible avec une CSP sans `unsafe-inline`). */
+export declare const CHARGEUR = "(function () {\n  if (window.parent === window) return;\n  if (!new URLSearchParams(location.search).has('cms-apercu')) return;\n  var script = document.createElement('script');\n  script.type = 'module';\n  script.src = '/_cms/apercu/demarrage.js';\n  document.head.appendChild(script);\n})();\n";
+/**
+ * Ajoute au site construit le chargeur et le script d'aperçu (modules ES), la balise du chargeur dans
+ * chaque page HTML, et les en-têtes `_headers` qui autorisent l'affichage dans l'admin.
+ */
+export declare function ecrireApercu(dossierDist: string, o: {
+    origineAdmin: string;
+    branche?: string;
+    sources?: string;
+    avertir?: (message: string) => void;
+}): Promise<void>;

package/dist/noyau/apercu-build.js

@@ -0,0 +1,74 @@
+import { promises as fsp } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+const PLACEHOLDER = "'__KOMEKOO_ORIGINE_ADMIN__'";
+const BALISE = '<script src="/_cms/chargeur.js" async></script>';
+const MARQUE_CSP = '  Content-Security-Policy: frame-ancestors';
+const AVERTISSEMENT = "L'aperçu de l'admin ne pourra pas afficher ce site tant que X-Frame-Options est présent.";
+/** Fichiers du script d'aperçu : chemin source (relatif à `dist/` du paquet) → chemin dans `<dist>/_cms/`. */
+const MODULES = ['apercu/demarrage.js', 'apercu/script.js', 'apercu/protocole.js', 'motifs.js'];
+/** Contenu de `_cms/chargeur.js` : fichier externe (compatible avec une CSP sans `unsafe-inline`). */
+export const CHARGEUR = `(function () {
+  if (window.parent === window) return;
+  if (!new URLSearchParams(location.search).has('cms-apercu')) return;
+  var script = document.createElement('script');
+  script.type = 'module';
+  script.src = '/_cms/apercu/demarrage.js';
+  document.head.appendChild(script);
+})();
+`;
+async function listerHtml(dossier) {
+    const entrees = await fsp.readdir(dossier, { withFileTypes: true });
+    const fichiers = await Promise.all(entrees.map(async (e) => {
+        const chemin = path.join(dossier, e.name);
+        if (e.isDirectory())
+            return listerHtml(chemin);
+        return e.name.endsWith('.html') ? [chemin] : [];
+    }));
+    return fichiers.flat();
+}
+async function injecterBalise(fichier) {
+    const html = await fsp.readFile(fichier, 'utf8');
+    if (html.includes(BALISE))
+        return;
+    const i = html.indexOf('</head>');
+    if (i === -1)
+        return;
+    await fsp.writeFile(fichier, html.slice(0, i) + BALISE + html.slice(i));
+}
+/**
+ * Ajoute au site construit le chargeur et le script d'aperçu (modules ES), la balise du chargeur dans
+ * chaque page HTML, et les en-têtes `_headers` qui autorisent l'affichage dans l'admin.
+ */
+export async function ecrireApercu(dossierDist, o) {
+    const sources = o.sources ?? fileURLToPath(new URL('../../dist/', import.meta.url));
+    await fsp.mkdir(path.join(dossierDist, '_cms/apercu'), { recursive: true });
+    await fsp.writeFile(path.join(dossierDist, '_cms/chargeur.js'), CHARGEUR);
+    for (const module of MODULES) {
+        let contenu = await fsp.readFile(path.join(sources, module), 'utf8');
+        if (module === 'apercu/demarrage.js')
+            contenu = contenu.replaceAll(PLACEHOLDER, JSON.stringify(o.origineAdmin));
+        await fsp.writeFile(path.join(dossierDist, '_cms', module), contenu);
+    }
+    for (const fichier of await listerHtml(dossierDist))
+        await injecterBalise(fichier);
+    const fichier = path.join(dossierDist, '_headers');
+    let existant = '';
+    try {
+        existant = await fsp.readFile(fichier, 'utf8');
+    }
+    catch (e) {
+        if (e.code !== 'ENOENT')
+            throw e;
+    }
+    if (o.avertir && existant.split('\n').some((l) => /x-frame-options:.*\b(deny|sameorigin)\b/i.test(l))) {
+        o.avertir(AVERTISSEMENT);
+    }
+    if (existant.split('\n').some((l) => l.startsWith(MARQUE_CSP)))
+        return;
+    let regle = `/*\n${MARQUE_CSP} 'self' ${o.origineAdmin}\n`;
+    if (o.branche !== undefined && o.branche !== 'main')
+        regle += '  X-Robots-Tag: noindex\n';
+    const separateur = existant === '' || existant.endsWith('\n') ? '' : '\n';
+    await fsp.writeFile(fichier, existant + separateur + regle);
+}

package/dist/noyau/charger.d.ts

@@ -0,0 +1,4 @@
+/** Charge `src/content.config.ts` du site et renvoie ses `collections`. */
+export declare function chargerCollections(racine: string): Promise<Record<string, unknown>>;
+/** Charge `astro.config.mjs` et renvoie son export par défaut. */
+export declare function chargerConfigAstro(racine: string): Promise<unknown>;

package/dist/noyau/charger.js

@@ -0,0 +1,48 @@
+import path from 'node:path';
+import { createServer } from 'vite';
+import { ErreurCms } from './erreurs.js';
+const FICHIER_CONFIG = 'src/content.config.ts';
+const FICHIER_ASTRO = 'astro.config.mjs';
+/**
+ * Charge un module du site via Vite (même chaîne de résolution qu'Astro) et le passe à `lire`.
+ * Un serveur neuf par appel : `ssrLoadModule` met les modules en cache, une config modifiée doit être relue.
+ */
+async function chargerModule(racine, fichier, lire) {
+    const serveur = await createServer({
+        root: path.resolve(racine),
+        appType: 'custom',
+        server: { middlewareMode: true, watch: null, ws: false },
+        optimizeDeps: { noDiscovery: true },
+        logLevel: 'silent',
+        configFile: false,
+    });
+    try {
+        return lire(await serveur.ssrLoadModule(`/${fichier}`));
+    }
+    catch (e) {
+        if (e instanceof ErreurCms)
+            throw e;
+        const cause = e instanceof Error ? e.message : String(e);
+        if (cause.includes('astro:content')) {
+            throw new ErreurCms("import de « astro:content » non pris en charge par komekoo-cms : utilise astro/zod, astro/loaders et l'API de @komekoo/astro-cms", fichier);
+        }
+        throw new ErreurCms(`chargement impossible : ${cause}`, fichier);
+    }
+    finally {
+        await serveur.close();
+    }
+}
+/** Charge `src/content.config.ts` du site et renvoie ses `collections`. */
+export function chargerCollections(racine) {
+    return chargerModule(racine, FICHIER_CONFIG, (module) => {
+        const collections = module['collections'];
+        if (typeof collections !== 'object' || collections === null) {
+            throw new ErreurCms('`collections` n’est pas exporté', FICHIER_CONFIG);
+        }
+        return collections;
+    });
+}
+/** Charge `astro.config.mjs` et renvoie son export par défaut. */
+export function chargerConfigAstro(racine) {
+    return chargerModule(racine, FICHIER_ASTRO, (module) => module['default']);
+}

package/dist/noyau/collecter.d.ts

@@ -0,0 +1,27 @@
+import type { z } from 'astro/zod';
+import type { Editeur } from '../types.js';
+export interface ModeleSingleton {
+    id: string;
+    libelle: string;
+    /** `src/content/pages/<id>.json` */
+    fichier: string;
+    adresse?: string;
+    apercu?: string;
+    schema: z.ZodObject;
+}
+export interface ModeleCollection {
+    id: string;
+    libelle: string;
+    dossier: string;
+    format: 'json' | 'markdown';
+    titre: string;
+    ordonnable: boolean;
+    schema: z.ZodObject;
+}
+export interface ModeleCms {
+    singletons: ModeleSingleton[];
+    collections: ModeleCollection[];
+}
+export declare function collecter(collections: Record<string, unknown>): ModeleCms;
+/** Déduit l'éditeur d'un schéma Zod brut ; la méta CMS prime quand elle existe. */
+export declare function deduireEditeur(schema: z.ZodType): Editeur;

package/dist/noyau/collecter.js

@@ -0,0 +1,133 @@
+import { lireDecl } from '../collections.js';
+import { lireMeta } from '../types.js';
+import { ErreurCms } from './erreurs.js';
+const def = (s) => s._zod.def;
+const REFUSES = {
+    function: 'type « function » non sérialisable',
+    transform: 'transformation non sérialisable',
+    any: 'type « any » refusé : déclare un type précis',
+    unknown: 'type « unknown » refusé : déclare un type précis',
+    date: 'type « date » refusé : utilise champ.date()',
+};
+const FEUILLES = new Set(['string', 'number', 'boolean', 'enum', 'literal', 'null']);
+const ENVELOPPES = new Set(['optional', 'nullable', 'default', 'prefault', 'nonoptional', 'readonly']);
+function verifier(schema, chemin, vus) {
+    if (vus.has(schema))
+        return;
+    vus.add(schema);
+    const d = def(schema);
+    const refus = REFUSES[d.type];
+    if (refus !== undefined)
+        throw new ErreurCms(`${chemin} : ${refus}`);
+    if (FEUILLES.has(d.type))
+        return;
+    if (ENVELOPPES.has(d.type)) {
+        if (d.innerType)
+            verifier(d.innerType, chemin, vus);
+        return;
+    }
+    switch (d.type) {
+        case 'object':
+            for (const [cle, sous] of Object.entries(d.shape ?? {}))
+                verifier(sous, `${chemin}.${cle}`, vus);
+            return;
+        case 'array':
+            if (d.element)
+                verifier(d.element, `${chemin}[]`, vus);
+            return;
+        case 'union':
+            if (d.discriminator === undefined) {
+                throw new ErreurCms(`${chemin} : union sans discriminant refusée : utilise z.discriminatedUnion()`);
+            }
+            for (const option of d.options ?? [])
+                verifier(option, chemin, vus);
+            return;
+        case 'pipe':
+            if (def(d.in).type === 'transform' || def(d.out).type === 'transform') {
+                throw new ErreurCms(`${chemin} : ${REFUSES.transform}`);
+            }
+            verifier(d.in, chemin, vus);
+            verifier(d.out, chemin, vus);
+            return;
+        default:
+            throw new ErreurCms(`${chemin} : type « ${d.type} » non pris en charge`);
+    }
+}
+export function collecter(collections) {
+    const modele = { singletons: [], collections: [] };
+    for (const [cle, valeur] of Object.entries(collections)) {
+        const decl = lireDecl(valeur);
+        if (!decl)
+            continue;
+        if (cle !== decl.id) {
+            throw new ErreurCms(`la clé « ${cle} » de l'export collections diffère de l'id déclaré « ${decl.id} »`);
+        }
+        const schema = valeur.schema;
+        verifier(schema, decl.id, new WeakSet());
+        if (decl.type === 'singleton') {
+            modele.singletons.push({
+                id: decl.id,
+                libelle: decl.libelle,
+                fichier: `src/content/pages/${decl.id}.json`,
+                ...(decl.adresse !== undefined && { adresse: decl.adresse }),
+                ...(decl.apercu !== undefined && { apercu: decl.apercu }),
+                schema,
+            });
+        }
+        else {
+            modele.collections.push({
+                id: decl.id,
+                libelle: decl.libelle,
+                dossier: `src/content/${decl.id}`,
+                format: decl.format,
+                titre: decl.titre,
+                ordonnable: decl.ordonnable,
+                schema,
+            });
+        }
+    }
+    const parId = (a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+    modele.singletons.sort(parId);
+    modele.collections.sort(parId);
+    return modele;
+}
+/** Déduit l'éditeur d'un schéma Zod brut ; la méta CMS prime quand elle existe. */
+export function deduireEditeur(schema) {
+    const meta = lireMeta(schema);
+    if (meta)
+        return meta.editeur;
+    const d = def(schema);
+    switch (d.type) {
+        case 'string':
+            return 'texte';
+        case 'literal': {
+            const t = typeof d.values?.[0];
+            if (t === 'string')
+                return 'texte';
+            if (t === 'number')
+                return 'nombre';
+            if (t === 'boolean')
+                return 'booleen';
+            throw new ErreurCms('impossible de déduire un éditeur pour ce littéral');
+        }
+        case 'number':
+            return 'nombre';
+        case 'boolean':
+            return 'booleen';
+        case 'enum':
+            return 'choix';
+        case 'array':
+            return 'liste';
+        case 'object':
+            return 'groupe';
+        case 'optional':
+        case 'nullable':
+        case 'default':
+        case 'prefault':
+        case 'nonoptional':
+        case 'readonly':
+            return deduireEditeur(d.innerType);
+        default:
+            throw new ErreurCms(`impossible de déduire un éditeur pour le type « ${d.type} »`);
+    }
+}

package/dist/noyau/contenus.d.ts

@@ -0,0 +1,6 @@
+import type { Violation } from './markdown.js';
+import type { ModeleCms } from './collecter.js';
+/** Valide tous les fichiers de contenu d'un site. Ordre : singletons par id, collections par id, fichiers triés. */
+export declare function validerContenus(racine: string, modele: ModeleCms): Promise<Violation[]>;
+/** Une ligne par violation : `fichier:ligne — motif` (ordre d'entrée conservé). */
+export declare function formaterViolations(v: Violation[]): string;