@komekoo/astro-cms 0.0.0-stage → 0.2.0

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,61 @@
+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 }),
+            ...(s.apercu !== undefined && { 'x-cms-apercu': s.apercu }),
+            ...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;
+    if (options.admin?.apercu !== undefined)
+        site.apercu = options.admin.apercu;
+    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,16 @@
+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;
+        apercu?: string;
+    };
+}
+/** Vue du modèle pour l'IA : langage naturel, aucun chemin de fichier. */
+export declare function versManifest(modele: ModeleCms, options: OptionsCms): object;

package/dist/noyau/manifest.js

@@ -0,0 +1,136 @@
+import { HORS_PERIMETRE_SOCLE } from '../socle/hors-perimetre.js';
+import { lireMeta } from '../types.js';
+import { deduireEditeur } from './collecter.js';
+const interne = (s) => s._zod;
+const ENVELOPPES = new Set(['optional', 'nullable', 'default', 'prefault', 'nonoptional', 'readonly']);
+function deballer(schema) {
+    let courant = schema;
+    while (ENVELOPPES.has(interne(courant).def.type) && interne(courant).def.innerType) {
+        courant = interne(courant).def.innerType;
+    }
+    return courant;
+}
+const estFacultatif = (s) => interne(s).def.type === 'optional';
+const TYPES = {
+    texte: 'texte court',
+    paragraphe: 'texte long',
+    richtext: 'texte mis en forme',
+    image: 'image',
+    date: 'date',
+    lien: 'lien',
+    nombre: 'nombre',
+    booleen: 'oui/non',
+    choix: 'choix',
+    liste: 'liste',
+    groupe: 'groupe',
+};
+const CORPS_MARKDOWN = 'Markdown : intertitres niveaux 2 et 3, gras, italique, liens, listes, citations, images, tableaux simples. Pas de HTML.';
+/** Lit une borne dans les vérifications déclarées (`.min()`/`.max()`), le `bag` étant vide après `.meta()`. */
+function borne(schema, cle) {
+    const verifs = interne(schema).def.checks ?? [];
+    const noms = cle === 'minimum' ? ['min_length', 'greater_than'] : ['max_length', 'less_than'];
+    for (const v of verifs) {
+        const d = v._zod.def;
+        if (!noms.includes(d.check))
+            continue;
+        const valeur = d.check === 'min_length' || d.check === 'max_length' ? d.minimum ?? d.maximum : d.value;
+        if (typeof valeur === 'number')
+            return valeur;
+    }
+    return undefined;
+}
+function contraintes(schema, editeur) {
+    const bag = deballer(schema);
+    const parties = [estFacultatif(schema) ? 'facultatif' : 'obligatoire'];
+    if (editeur === 'texte' || editeur === 'paragraphe' || editeur === 'richtext') {
+        const max = borne(bag, 'maximum');
+        if (max !== undefined)
+            parties.push(`${max} caractères max`);
+    }
+    else if (editeur === 'nombre') {
+        const min = borne(bag, 'minimum');
+        const max = borne(bag, 'maximum');
+        if (min !== undefined && max !== undefined)
+            parties.push(`entre ${min} et ${max}`);
+        else if (min !== undefined)
+            parties.push(`${min} minimum`);
+        else if (max !== undefined)
+            parties.push(`${max} maximum`);
+        const unite = lireMeta(schema)?.unite;
+        if (unite !== undefined)
+            parties.push(`unité : ${unite}`);
+    }
+    else if (editeur === 'liste') {
+        const min = borne(bag, 'minimum');
+        const max = borne(bag, 'maximum');
+        if (min !== undefined)
+            parties.push(`${min} éléments min`);
+        if (max !== undefined)
+            parties.push(`${max} éléments max`);
+    }
+    return parties.join(', ');
+}
+function typeLisible(schema, editeur) {
+    if (editeur === 'choix') {
+        const options = deballer(schema).options ?? [];
+        return `choix parmi : ${options.join(', ')}`;
+    }
+    return TYPES[editeur];
+}
+function aplatir(cle, schema, chemin, sortie) {
+    const editeur = deduireEditeur(schema);
+    const entree = {
+        chemin,
+        libelle: lireMeta(schema)?.libelle ?? cle,
+        type: typeLisible(schema, editeur),
+    };
+    const c = contraintes(schema, editeur);
+    if (c !== '')
+        entree.contraintes = c;
+    sortie.push(entree);
+    // L'image est un champ atomique : sa structure interne (src, alt…) n'est pas exposée.
+    if (editeur !== 'groupe' && editeur !== 'liste')
+        return;
+    const d = interne(deballer(schema)).def;
+    if (d.type === 'object' && d.shape) {
+        for (const [sousCle, sous] of Object.entries(d.shape))
+            aplatir(sousCle, sous, `${chemin}.${sousCle}`, sortie);
+    }
+    else if (d.type === 'array' && d.element) {
+        const de = interne(deballer(d.element)).def;
+        if (de.type === 'object' && de.shape) {
+            for (const [sousCle, sous] of Object.entries(de.shape)) {
+                aplatir(sousCle, sous, `${chemin}[].${sousCle}`, sortie);
+            }
+        }
+    }
+}
+function champs(schema, ignorer = []) {
+    const sortie = [];
+    for (const [cle, sous] of Object.entries(interne(schema).def.shape ?? {})) {
+        if (ignorer.includes(cle))
+            continue;
+        aplatir(cle, sous, cle, sortie);
+    }
+    return sortie;
+}
+/** Vue du modèle pour l'IA : langage naturel, aucun chemin de fichier. */
+export function versManifest(modele, options) {
+    return {
+        version: 1,
+        site: options.site,
+        pages: modele.singletons.map((s) => ({ id: s.id, libelle: s.libelle, champs: champs(s.schema) })),
+        collections: modele.collections.map((c) => ({
+            id: c.id,
+            libelle: c.libelle,
+            actions: c.ordonnable
+                ? ['ajouter', 'modifier', 'supprimer', 'reordonner']
+                : ['ajouter', 'modifier', 'supprimer'],
+            // `ordre` est ajouté automatiquement aux collections ordonnables : couvert par `reordonner`.
+            champs: champs(c.schema, c.ordonnable ? ['ordre'] : []),
+            ...(c.format === 'markdown' ? { corps: CORPS_MARKDOWN } : {}),
+        })),
+        horsPerimetre: [...new Set([...HORS_PERIMETRE_SOCLE, ...(options.horsPerimetre ?? [])])],
+        contact: options.contact,
+    };
+}

package/dist/noyau/markdown.d.ts

@@ -0,0 +1,12 @@
+export interface Violation {
+    fichier?: string;
+    ligne?: number;
+    motif: string;
+}
+export declare const analyseur: import("unified").Processor<import("mdast").Root, undefined, undefined, undefined, undefined>;
+export declare function validerMarkdown(source: string, decalageLigne?: number): Violation[];
+/** Images (`![](url)`) du source, avec leur ligne (1-based) et leur URL brute. */
+export declare function extraireImages(source: string): {
+    url: string;
+    ligne?: number;
+}[];

package/dist/noyau/markdown.js

@@ -0,0 +1,95 @@
+import remarkGfm from 'remark-gfm';
+import remarkParse from 'remark-parse';
+import { unified } from 'unified';
+import { MOTIF_LIEN, MOTIF_SRC_IMAGE } from '../motifs.js';
+export const analyseur = unified().use(remarkParse).use(remarkGfm);
+const AUTORISES = new Set([
+    'root', 'paragraph', 'text', 'heading', 'strong', 'emphasis', 'link', 'list',
+    'listItem', 'blockquote', 'image', 'table', 'tableRow', 'tableCell', 'break',
+]);
+const DANS_CELLULE = new Set(['text', 'strong', 'emphasis', 'link']);
+const MOTIFS_FIXES = {
+    html: 'HTML interdit',
+    code: 'bloc de code interdit',
+    inlineCode: 'code en ligne interdit',
+    delete: 'texte barré interdit',
+    footnoteReference: 'note de bas de page interdite',
+    footnoteDefinition: 'note de bas de page interdite',
+    thematicBreak: 'ligne horizontale interdite',
+};
+/**
+ * Autolien littéral GFM (`www.exemple.fr`, `http://exemple.fr` écrits nus) : un seul enfant texte égal à l'URL,
+ * ou à l'URL sans le préfixe `http://` que GFM ajoute aux `www.`. Un lien explicite `[x](http://…)` reste refusé.
+ */
+function estAutolienLitteral(lien) {
+    if (!/^https?:\/\//.test(lien.url))
+        return false;
+    const [enfant, ...reste] = lien.children;
+    if (enfant?.type !== 'text' || reste.length > 0)
+        return false;
+    return enfant.value === lien.url || `http://${enfant.value}` === lien.url;
+}
+// Motif de refus propre au nœud, ou undefined s'il est autorisé hors tableau.
+function motifRefus(noeud) {
+    const fixe = MOTIFS_FIXES[noeud.type];
+    if (fixe)
+        return fixe;
+    switch (noeud.type) {
+        case 'heading':
+            return noeud.depth === 2 || noeud.depth === 3
+                ? undefined
+                : `titre de niveau ${noeud.depth} interdit`;
+        case 'listItem':
+            return typeof noeud.checked === 'boolean' ? 'case à cocher interdite' : undefined;
+        case 'link':
+            return MOTIF_LIEN.test(noeud.url) || estAutolienLitteral(noeud) ? undefined : `lien non autorisé : ${noeud.url}`;
+        case 'image':
+            return MOTIF_SRC_IMAGE.test(noeud.url)
+                ? undefined
+                : `image hors de /uploads/ : ${noeud.url}`;
+        default:
+            return AUTORISES.has(noeud.type) ? undefined : `élément « ${noeud.type} » interdit`;
+    }
+}
+export function validerMarkdown(source, decalageLigne = 0) {
+    // Les fins de ligne CRLF sont normalisées : le nombre de lignes est inchangé.
+    const arbre = analyseur.parse(source.replace(/\r\n/g, '\n'));
+    const violations = [];
+    const visiter = (noeud, dansCellule) => {
+        let motif = motifRefus(noeud);
+        if (!motif && dansCellule && !DANS_CELLULE.has(noeud.type)) {
+            motif =
+                noeud.type === 'image'
+                    ? 'image interdite dans un tableau'
+                    : `élément « ${noeud.type} » interdit dans un tableau`;
+        }
+        if (motif) {
+            const ligne = noeud.position?.start.line;
+            violations.push(ligne === undefined ? { motif } : { ligne: ligne + decalageLigne, motif });
+            return;
+        }
+        if ('children' in noeud) {
+            const enfantsDansCellule = dansCellule || noeud.type === 'tableCell';
+            for (const enfant of noeud.children)
+                visiter(enfant, enfantsDansCellule);
+        }
+    };
+    visiter(arbre, false);
+    return violations;
+}
+/** Images (`![](url)`) du source, avec leur ligne (1-based) et leur URL brute. */
+export function extraireImages(source) {
+    const arbre = analyseur.parse(source.replace(/\r\n/g, '\n'));
+    const images = [];
+    const visiter = (noeud) => {
+        if (noeud.type === 'image') {
+            const ligne = noeud.position?.start.line;
+            images.push(ligne === undefined ? { url: noeud.url } : { url: noeud.url, ligne });
+        }
+        if ('children' in noeud)
+            for (const enfant of noeud.children)
+                visiter(enfant);
+    };
+    visiter(arbre);
+    return images;
+}

package/dist/noyau/marqueurs.d.ts

@@ -0,0 +1,11 @@
+/** `singletons` de `cms.schema.json`. */
+export type SchemaSingletons = Record<string, object>;
+export interface ErreurMarqueur {
+    page: string;
+    chemin: string;
+    motif: string;
+}
+/** Contrôle les marqueurs `data-cms` d'une page HTML produite. */
+export declare function verifierMarqueursHtml(html: string, page: string, schema: SchemaSingletons): ErreurMarqueur[];
+/** Contrôle toutes les pages HTML de `dossierDist` ; `page` est relative à ce dossier (séparateur `/`). */
+export declare function verifierMarqueurs(dossierDist: string, schema: SchemaSingletons): Promise<ErreurMarqueur[]>;