@komekoo/astro-cms 0.0.0-stage → 0.1.0

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,26 @@
+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;
+    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,132 @@
+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 }),
+                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;

package/dist/noyau/contenus.js

@@ -0,0 +1,218 @@
+import { promises as fsp } from 'node:fs';
+import path from 'node:path';
+import { MOTIF_SRC_IMAGE } from '../champs.js';
+import { lireMeta } from '../types.js';
+import { lireFrontmatter } from './frontmatter.js';
+import { extraireImages, validerMarkdown } from './markdown.js';
+const DOSSIER_PAGES = 'src/content/pages';
+const TAILLES = ['800', '1600', '2400'];
+const def = (s) => s._zod.def;
+const ENVELOPPES = new Set(['optional', 'nullable', 'default', 'prefault', 'nonoptional', 'readonly']);
+const estObjet = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+const posix = (p) => p.split(path.sep).join('/');
+function formaterChemin(chemin) {
+    let s = '';
+    for (const p of chemin) {
+        if (typeof p === 'number')
+            s += `[${p}]`;
+        else
+            s += s === '' ? String(p) : `.${String(p)}`;
+    }
+    return s;
+}
+/**
+ * Fichiers d'un dossier (récursif), chemins POSIX relatifs à `dossier`, triés ; dossier absent → `[]`.
+ * Fichiers et dossiers cachés (`.DS_Store`, `.gitkeep`…) ignorés, comme le glob loader d'Astro (`dot: false`).
+ */
+async function lister(dossier) {
+    let entrees;
+    try {
+        entrees = await fsp.readdir(dossier, { recursive: true, withFileTypes: true });
+    }
+    catch (e) {
+        if (e.code === 'ENOENT')
+            return [];
+        throw e;
+    }
+    return entrees
+        .filter((e) => e.isFile())
+        .map((e) => posix(path.relative(dossier, path.join(e.parentPath, e.name))))
+        .filter((rel) => !rel.split('/').some((segment) => segment.startsWith('.')))
+        .sort();
+}
+async function lireTexte(chemin) {
+    try {
+        return await fsp.readFile(chemin, 'utf8');
+    }
+    catch (e) {
+        if (e.code === 'ENOENT')
+            return undefined;
+        throw e;
+    }
+}
+async function existe(chemin) {
+    try {
+        await fsp.access(chemin);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+class Collecteur {
+    racine;
+    fichier;
+    violations = [];
+    constructor(racine, fichier) {
+        this.racine = racine;
+        this.fichier = fichier;
+    }
+    ajouter(motif, ligne) {
+        this.violations.push(ligne === undefined ? { fichier: this.fichier, motif } : { fichier: this.fichier, ligne, motif });
+    }
+    /** Vérifie les trois variantes d'une image. Un `src` hors motif n'est jamais résolu sur le disque. */
+    async image(src, ligne) {
+        if (typeof src !== 'string' || !MOTIF_SRC_IMAGE.test(src))
+            return;
+        const uploads = path.resolve(this.racine, 'public', 'uploads');
+        for (const taille of TAILLES) {
+            const variante = path.resolve(this.racine, 'public', `${src.slice(1, -'2400.webp'.length)}${taille}.webp`);
+            if (!variante.startsWith(uploads + path.sep))
+                continue;
+            if (!(await existe(variante))) {
+                this.ajouter(`variante d'image absente : ${posix(path.relative(this.racine, variante))}`, ligne);
+            }
+        }
+    }
+    /** Markdown d'un champ `richtext` : violations préfixées du chemin du champ (ligne inconnue). */
+    async richtext(valeur, chemin) {
+        if (typeof valeur !== 'string')
+            return;
+        for (const v of validerMarkdown(valeur))
+            this.ajouter(`${chemin} : ${v.motif}`);
+        for (const { url } of extraireImages(valeur))
+            await this.image(url);
+    }
+    /** Parcourt données et schéma ensemble : images et champs richtext. */
+    async parcourir(schema, valeur, chemin) {
+        let noeud = schema;
+        for (;;) {
+            const editeur = lireMeta(noeud)?.editeur;
+            if (editeur === 'image') {
+                if (estObjet(valeur))
+                    await this.image(valeur.src);
+                return;
+            }
+            if (editeur === 'richtext')
+                return this.richtext(valeur, chemin);
+            const d = def(noeud);
+            if (!ENVELOPPES.has(d.type) || !d.innerType)
+                break;
+            noeud = d.innerType;
+        }
+        const d = def(noeud);
+        if (d.type === 'object' && estObjet(valeur)) {
+            for (const [cle, sous] of Object.entries(d.shape ?? {})) {
+                if (cle in valeur)
+                    await this.parcourir(sous, valeur[cle], chemin === '' ? cle : `${chemin}.${cle}`);
+            }
+        }
+        else if (d.type === 'array' && d.element && Array.isArray(valeur)) {
+            for (const [i, v] of valeur.entries())
+                await this.parcourir(d.element, v, `${chemin}[${i}]`);
+        }
+        else if (d.type === 'union' && d.discriminator !== undefined && estObjet(valeur)) {
+            const option = d.options?.find((o) => {
+                const champDisc = def(o).shape?.[d.discriminator];
+                return champDisc !== undefined && def(champDisc).values?.includes(valeur[d.discriminator]);
+            });
+            if (option)
+                await this.parcourir(option, valeur, chemin);
+        }
+    }
+    /** Validation Zod puis parcours des images et du richtext. */
+    async donnees(schema, donnees) {
+        const r = schema.safeParse(donnees);
+        if (!r.success) {
+            for (const issue of r.error.issues) {
+                const chemin = formaterChemin(issue.path);
+                this.ajouter(chemin === '' ? issue.message : `${chemin} : ${issue.message}`);
+            }
+        }
+        await this.parcourir(schema, donnees, '');
+    }
+}
+function ligneJson(message) {
+    const m = /\(line (\d+) column \d+\)/.exec(message);
+    return m ? Number(m[1]) : undefined;
+}
+async function validerJson(racine, fichier, texte, schema) {
+    const c = new Collecteur(racine, fichier);
+    let donnees;
+    try {
+        donnees = JSON.parse(texte);
+    }
+    catch (e) {
+        c.ajouter(`JSON illisible : ${e.message}`, ligneJson(e.message));
+        return c.violations;
+    }
+    await c.donnees(schema, donnees);
+    return c.violations;
+}
+async function validerMd(racine, fichier, texte, schema) {
+    const c = new Collecteur(racine, fichier);
+    let lu;
+    try {
+        lu = lireFrontmatter(texte);
+    }
+    catch (e) {
+        const err = e;
+        c.ajouter(`frontmatter illisible : ${err.message}`, err.linePos?.[0]?.line);
+        return c.violations;
+    }
+    await c.donnees(schema, lu.donnees);
+    for (const v of validerMarkdown(lu.corps, lu.ligneCorps - 1)) {
+        c.ajouter(v.motif, v.ligne);
+    }
+    for (const { url, ligne } of extraireImages(lu.corps)) {
+        await c.image(url, ligne === undefined ? undefined : ligne + lu.ligneCorps - 1);
+    }
+    return c.violations;
+}
+/** Valide tous les fichiers de contenu d'un site. Ordre : singletons par id, collections par id, fichiers triés. */
+export async function validerContenus(racine, modele) {
+    const violations = [];
+    const declares = new Set(modele.singletons.map((s) => s.fichier));
+    for (const s of modele.singletons) {
+        const texte = await lireTexte(path.join(racine, s.fichier));
+        if (texte === undefined)
+            violations.push({ fichier: s.fichier, motif: 'fichier manquant' });
+        else
+            violations.push(...(await validerJson(racine, s.fichier, texte, s.schema)));
+    }
+    for (const f of await lister(path.join(racine, DOSSIER_PAGES))) {
+        const fichier = `${DOSSIER_PAGES}/${f}`;
+        if (!declares.has(fichier))
+            violations.push({ fichier, motif: 'fichier non déclaré comme singleton' });
+    }
+    for (const col of modele.collections) {
+        for (const f of await lister(path.join(racine, col.dossier))) {
+            const fichier = `${col.dossier}/${f}`;
+            const texte = await fsp.readFile(path.join(racine, fichier), 'utf8');
+            if (f.endsWith('.json'))
+                violations.push(...(await validerJson(racine, fichier, texte, col.schema)));
+            else if (f.endsWith('.md'))
+                violations.push(...(await validerMd(racine, fichier, texte, col.schema)));
+        }
+    }
+    return violations;
+}
+/** Une ligne par violation : `fichier:ligne — motif` (ordre d'entrée conservé). */
+export function formaterViolations(v) {
+    return v
+        .map((x) => {
+        const lieu = x.fichier === undefined ? '' : x.ligne === undefined ? `${x.fichier} — ` : `${x.fichier}:${x.ligne} — `;
+        return `${lieu}${x.motif}`;
+    })
+        .join('\n');
+}

package/dist/noyau/erreurs.d.ts

@@ -0,0 +1,7 @@
+/** Erreur destinée au développeur ; message au format `fichier:ligne — motif` (fichier/ligne omis si inconnus). */
+export declare class ErreurCms extends Error {
+    readonly motif: string;
+    readonly fichier: string | undefined;
+    readonly ligne: number | undefined;
+    constructor(motif: string, fichier?: string, ligne?: number);
+}

package/dist/noyau/erreurs.js

@@ -0,0 +1,14 @@
+/** Erreur destinée au développeur ; message au format `fichier:ligne — motif` (fichier/ligne omis si inconnus). */
+export class ErreurCms extends Error {
+    motif;
+    fichier;
+    ligne;
+    constructor(motif, fichier, ligne) {
+        const lieu = fichier === undefined ? '' : ligne === undefined ? `${fichier} — ` : `${fichier}:${ligne} — `;
+        super(`${lieu}${motif}`);
+        this.name = 'ErreurCms';
+        this.motif = motif;
+        this.fichier = fichier;
+        this.ligne = ligne;
+    }
+}

package/dist/noyau/frontmatter.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Sépare frontmatter et corps. `ligneCorps` est la ligne (1-based) du fichier où commence
+ * `corps` : la ligne `n` du corps est la ligne `ligneCorps + n - 1` du fichier.
+ * Lève l'erreur du parseur YAML (`YAMLParseError`, avec `linePos`) si le YAML est invalide.
+ */
+export declare function lireFrontmatter(source: string): {
+    donnees: unknown;
+    corps: string;
+    ligneCorps: number;
+};
+/**
+ * Inverse de `lireFrontmatter` : `---`, YAML (clés dans l'ordre reçu, lignes non repliées), `---`, corps.
+ * Les chaînes qui ressemblent à une date sont entre guillemets doubles, pour être relues comme chaînes.
+ */
+export declare function ecrireFrontmatter(donnees: Record<string, unknown>, corps: string): string;

package/dist/noyau/frontmatter.js

@@ -0,0 +1,70 @@
+import { Document, isScalar, parseDocument, visit } from 'yaml';
+import { ErreurCms } from './erreurs.js';
+// Extraction identique à `@astrojs/internal-helpers/frontmatter` (utilisée par Astro 7).
+const RE_FRONTMATTER = /(?:^?|^\s*\n)(?:---|\+\+\+)([\s\S]*?\n)(?:---|\+\+\+)/;
+const RE_TYPE = /(?:^?|^\s*\n)(---|\+\+\+)/;
+/**
+ * Même lecture YAML qu'Astro 7 (`@astrojs/internal-helpers/yaml`) : paquet `yaml`,
+ * schéma `core` + tag `timestamp` + `merge`. Une date non entre guillemets devient donc
+ * un objet `Date`, que `z.iso.date()` refuse — au build comme ici.
+ */
+function lireYaml(source) {
+    const document = parseDocument(source, { customTags: ['timestamp'], merge: true, schema: 'core' });
+    if (document.errors.length > 0)
+        throw document.errors[0];
+    if (document.contents === null)
+        return undefined;
+    return document.toJS();
+}
+const compterLignes = (s) => s.split('\n').length - 1;
+/**
+ * Sépare frontmatter et corps. `ligneCorps` est la ligne (1-based) du fichier où commence
+ * `corps` : la ligne `n` du corps est la ligne `ligneCorps + n - 1` du fichier.
+ * Lève l'erreur du parseur YAML (`YAMLParseError`, avec `linePos`) si le YAML est invalide.
+ */
+export function lireFrontmatter(source) {
+    const trouve = RE_FRONTMATTER.exec(source);
+    const brut = trouve?.[1];
+    if (trouve === null || brut === undefined)
+        return { donnees: {}, corps: source, ligneCorps: 1 };
+    if (RE_TYPE.exec(source)?.[1] === '+++') {
+        throw new ErreurCms('frontmatter TOML (+++) non pris en charge : utilise YAML (---)');
+    }
+    const analyse = lireYaml(brut);
+    const donnees = analyse !== null && typeof analyse === 'object' ? analyse : {};
+    const fin = trouve.index + trouve[0].length;
+    const reste = source.slice(fin);
+    // Le corps commence à la ligne qui suit la clôture `---`.
+    const saut = /^[^\S\n]*\r?\n/.exec(reste);
+    const corps = saut ? reste.slice(saut[0].length) : reste;
+    const ligneCloture = compterLignes(source.slice(0, fin)) + 1;
+    return { donnees, corps, ligneCorps: ligneCloture + (saut ? 1 : 0) };
+}
+/** Vrai si la chaîne, écrite sans guillemets, serait relue par `lireYaml` autrement que comme cette chaîne (ex. date). */
+function sRelitAutrement(valeur) {
+    if (!/^\d/.test(valeur) || valeur.includes('\n'))
+        return false;
+    try {
+        const relu = lireYaml(`k: ${valeur}`);
+        return relu?.k !== valeur;
+    }
+    catch {
+        return true;
+    }
+}
+/**
+ * Inverse de `lireFrontmatter` : `---`, YAML (clés dans l'ordre reçu, lignes non repliées), `---`, corps.
+ * Les chaînes qui ressemblent à une date sont entre guillemets doubles, pour être relues comme chaînes.
+ */
+export function ecrireFrontmatter(donnees, corps) {
+    if (Object.keys(donnees).length === 0)
+        return `---\n---\n${corps}`;
+    const document = new Document(donnees);
+    visit(document, {
+        Scalar(_cle, noeud) {
+            if (isScalar(noeud) && typeof noeud.value === 'string' && sRelitAutrement(noeud.value))
+                noeud.type = 'QUOTE_DOUBLE';
+        },
+    });
+    return `---\n${document.toString({ lineWidth: 0 })}---\n${corps}`;
+}

package/dist/noyau/json-schema.d.ts

@@ -0,0 +1,4 @@
+import type { ModeleCms } from './collecter.js';
+import type { OptionsCms } from './manifest.js';
+/** Document `cms.schema.json` (voir spec, section 5). */
+export declare function versJsonSchema(modele: ModeleCms, options: OptionsCms): object;

package/dist/noyau/json-schema.js

@@ -0,0 +1,58 @@
+import { z } from 'astro/zod';
+const ACCENT_DEFAUT = '#5DEFB7';
+/** Renomme la méta `cms` en `x-cms` et impose `additionalProperties: false` sur les objets. */
+function surcharger(ctx) {
+    const js = ctx.jsonSchema;
+    if ('cms' in js) {
+        js['x-cms'] = js.cms;
+        delete js.cms;
+    }
+    if (js.type === 'object')
+        js.additionalProperties = false;
+}
+function convertir(schema) {
+    const js = z.toJSONSchema(schema, {
+        target: 'draft-2020-12',
+        io: 'input',
+        override: surcharger,
+    });
+    delete js.$schema;
+    return js;
+}
+/** Document `cms.schema.json` (voir spec, section 5). */
+export function versJsonSchema(modele, options) {
+    const singletons = {};
+    for (const s of modele.singletons) {
+        singletons[s.id] = {
+            'x-cms-libelle': s.libelle,
+            'x-cms-fichier': s.fichier,
+            ...(s.adresse !== undefined && { 'x-cms-adresse': s.adresse }),
+            ...convertir(s.schema),
+        };
+    }
+    const collections = {};
+    for (const c of modele.collections) {
+        const entree = {
+            'x-cms-libelle': c.libelle,
+            'x-cms-dossier': c.dossier,
+            'x-cms-format': c.format,
+            'x-cms-titre': c.titre,
+            'x-cms-ordonnable': c.ordonnable,
+        };
+        if (c.format === 'markdown')
+            entree['x-cms-corps'] = { titres: [2, 3], tableaux: true };
+        entree.items = convertir(c.schema);
+        collections[c.id] = entree;
+    }
+    const site = { nom: options.site, url: options.url, accent: options.admin?.accent ?? ACCENT_DEFAUT };
+    if (options.admin?.logo !== undefined)
+        site.logo = options.admin.logo;
+    site.contact = options.contact;
+    return {
+        $schema: 'https://json-schema.org/draft/2020-12/schema',
+        'x-cms-version': 1,
+        'x-cms-site': site,
+        singletons,
+        collections,
+    };
+}

package/dist/noyau/manifest.d.ts

@@ -0,0 +1,15 @@
+import type { ModeleCms } from './collecter.js';
+export interface OptionsCms {
+    site: string;
+    contact: string;
+    horsPerimetre?: string[];
+    /** URL publique du site, en https, sans « / » final. */
+    url: string;
+    admin?: {
+        accent?: string;
+        logo?: string;
+        origine?: string;
+    };
+}
+/** Vue du modèle pour l'IA : langage naturel, aucun chemin de fichier. */
+export declare function versManifest(modele: ModeleCms, options: OptionsCms): object;