@komekoo/astro-cms 0.0.0-stage → 0.1.0

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,11 @@
+export interface Violation {
+    fichier?: string;
+    ligne?: number;
+    motif: string;
+}
+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';
+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/operations.d.ts

@@ -0,0 +1,12 @@
+import type { OptionsCms } from './manifest.js';
+import type { Violation } from './markdown.js';
+type Fichiers = {
+    'cms.schema.json': string;
+    'ai/manifest.json': string;
+};
+export declare function genererFichiers(racine: string, options: OptionsCms): Promise<Fichiers>;
+/** Écrit les fichiers générés dont le contenu change ; renvoie les chemins (relatifs à `racine`) réécrits. */
+export declare function synchroniser(racine: string, options: OptionsCms): Promise<string[]>;
+/** Dérive des fichiers générés, puis validation des contenus. */
+export declare function verifier(racine: string, options: OptionsCms): Promise<Violation[]>;
+export {};

package/dist/noyau/operations.js

@@ -0,0 +1,54 @@
+import { promises as fsp } from 'node:fs';
+import path from 'node:path';
+import { chargerCollections } from './charger.js';
+import { collecter } from './collecter.js';
+import { validerContenus } from './contenus.js';
+import { versJsonSchema } from './json-schema.js';
+import { versManifest } from './manifest.js';
+import { serialiser } from './serialiser.js';
+const MOTIF_DERIVE = 'Schéma CMS périmé : lance `pnpm cms:sync` et committe.';
+function fichiersDuModele(modele, options) {
+    return {
+        'cms.schema.json': serialiser(versJsonSchema(modele, options)),
+        'ai/manifest.json': serialiser(versManifest(modele, options)),
+    };
+}
+export async function genererFichiers(racine, options) {
+    return fichiersDuModele(collecter(await chargerCollections(racine)), options);
+}
+async function lireOuNull(fichier) {
+    try {
+        return await fsp.readFile(fichier, 'utf8');
+    }
+    catch (e) {
+        if (e.code === 'ENOENT')
+            return null;
+        throw e;
+    }
+}
+/** Écrit les fichiers générés dont le contenu change ; renvoie les chemins (relatifs à `racine`) réécrits. */
+export async function synchroniser(racine, options) {
+    const ecrits = [];
+    for (const [rel, contenu] of Object.entries(await genererFichiers(racine, options))) {
+        const abs = path.join(racine, rel);
+        if ((await lireOuNull(abs)) === contenu)
+            continue;
+        await fsp.mkdir(path.dirname(abs), { recursive: true });
+        await fsp.writeFile(abs, contenu);
+        ecrits.push(rel);
+    }
+    return ecrits;
+}
+/** Dérive des fichiers générés, puis validation des contenus. */
+export async function verifier(racine, options) {
+    const modele = collecter(await chargerCollections(racine));
+    const violations = [];
+    for (const [rel, contenu] of Object.entries(fichiersDuModele(modele, options))) {
+        // Côté committé, CRLF → LF : un checkout Windows (core.autocrlf) ne compte pas comme une dérive.
+        if ((await lireOuNull(path.join(racine, rel)))?.replace(/\r\n/g, '\n') !== contenu) {
+            violations.push({ fichier: rel, motif: MOTIF_DERIVE });
+        }
+    }
+    violations.push(...(await validerContenus(racine, modele)));
+    return violations;
+}

package/dist/noyau/serialiser.d.ts

@@ -0,0 +1,2 @@
+/** JSON déterministe : clés triées (sauf `properties`), `required` trié, 2 espaces, saut de ligne final. */
+export declare function serialiser(valeur: unknown): string;

package/dist/noyau/serialiser.js

@@ -0,0 +1,25 @@
+function trier(valeur, dansProperties) {
+    if (Array.isArray(valeur))
+        return valeur.map((v) => trier(v, false));
+    if (typeof valeur !== 'object' || valeur === null)
+        return valeur;
+    const entrees = Object.entries(valeur);
+    // Dans `properties`, l'ordre de déclaration est conservé.
+    if (!dansProperties)
+        entrees.sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
+    const sortie = {};
+    for (const [cle, v] of entrees) {
+        if (cle === 'required' && Array.isArray(v) && v.every((x) => typeof x === 'string')) {
+            sortie[cle] = [...v].sort();
+        }
+        else {
+            // Les clés de `properties` sont des noms de champs : leurs valeurs sont des schémas ordinaires.
+            sortie[cle] = trier(v, !dansProperties && cle === 'properties');
+        }
+    }
+    return sortie;
+}
+/** JSON déterministe : clés triées (sauf `properties`), `required` trié, 2 espaces, saut de ligne final. */
+export function serialiser(valeur) {
+    return `${JSON.stringify(trier(valeur, false), null, 2)}\n`;
+}

package/dist/noyau/version.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Écrit `<dist>/_cms/version.json` et déclare ses en-têtes dans `<dist>/_headers`
+ * (créé si absent, contenu existant conservé, règle ajoutée une seule fois).
+ */
+export declare function ecrireVersion(dossierDist: string, commit: string, origineAdmin: string): Promise<void>;

package/dist/noyau/version.js

@@ -0,0 +1,25 @@
+import { promises as fsp } from 'node:fs';
+import path from 'node:path';
+const CHEMIN = '/_cms/version.json';
+/**
+ * Écrit `<dist>/_cms/version.json` et déclare ses en-têtes dans `<dist>/_headers`
+ * (créé si absent, contenu existant conservé, règle ajoutée une seule fois).
+ */
+export async function ecrireVersion(dossierDist, commit, origineAdmin) {
+    await fsp.mkdir(path.join(dossierDist, '_cms'), { recursive: true });
+    await fsp.writeFile(path.join(dossierDist, '_cms/version.json'), `${JSON.stringify({ commit })}\n`);
+    const fichier = path.join(dossierDist, '_headers');
+    let existant = '';
+    try {
+        existant = await fsp.readFile(fichier, 'utf8');
+    }
+    catch (e) {
+        if (e.code !== 'ENOENT')
+            throw e;
+    }
+    if (existant.split('\n').some((ligne) => ligne.trim() === CHEMIN))
+        return;
+    const regle = `${CHEMIN}\n  Access-Control-Allow-Origin: ${origineAdmin}\n  Cache-Control: no-store\n`;
+    const separateur = existant === '' || existant.endsWith('\n') ? '' : '\n';
+    await fsp.writeFile(fichier, existant + separateur + regle);
+}

package/dist/socle/hors-perimetre.d.ts

@@ -0,0 +1,2 @@
+/** Ce que le CMS ne permet jamais de faire, quel que soit le site. */
+export declare const HORS_PERIMETRE_SOCLE: readonly string[];

package/dist/socle/hors-perimetre.js

@@ -0,0 +1,9 @@
+/** Ce que le CMS ne permet jamais de faire, quel que soit le site. */
+export const HORS_PERIMETRE_SOCLE = [
+    'Modifier le design, les couleurs ou les polices',
+    'Modifier la mise en page',
+    'Ajouter une page ou une section',
+    'Ajouter une fonctionnalité (formulaire, réservation, paiement…)',
+    'Modifier le référencement technique',
+    'Gérer le nom de domaine ou les adresses e-mail',
+];

package/dist/types.d.ts

@@ -0,0 +1,33 @@
+import { z } from 'astro/zod';
+export type Editeur = 'texte' | 'paragraphe' | 'richtext' | 'image' | 'date' | 'lien' | 'nombre' | 'booleen' | 'choix' | 'liste' | 'groupe';
+export interface MetaCms {
+    editeur: Editeur;
+    libelle: string;
+    aide?: string;
+    unite?: string;
+    onglet?: string;
+}
+export interface OptionsBase {
+    libelle: string;
+    aide?: string;
+    /** `true` par défaut. */
+    obligatoire?: boolean;
+    /** Onglet de l'admin où ranger le champ (non vide). */
+    onglet?: string;
+}
+export interface DeclSingleton {
+    type: 'singleton';
+    id: string;
+    libelle: string;
+    adresse?: string;
+}
+export interface DeclCollection {
+    type: 'collection';
+    id: string;
+    libelle: string;
+    format: 'json' | 'markdown';
+    titre: string;
+    ordonnable: boolean;
+}
+/** Lit la méta CMS d'un schéma, en traversant `ZodOptional`. */
+export declare function lireMeta(schema: z.ZodType): MetaCms | undefined;

package/dist/types.js

@@ -0,0 +1,10 @@
+import { z } from 'astro/zod';
+/** Lit la méta CMS d'un schéma, en traversant `ZodOptional`. */
+export function lireMeta(schema) {
+    let courant = schema;
+    while (courant instanceof z.ZodOptional) {
+        courant = courant.unwrap();
+    }
+    const meta = courant.meta();
+    return meta?.cms;
+}

package/package.json

@@ -1,6 +1,56 @@
 {
   "name": "@komekoo/astro-cms",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "type": "module",
+  "license": "MIT",
+  "engines": {
+    "node": ">=22.23.4"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./integration": {
+      "types": "./dist/integration.d.ts",
+      "default": "./dist/integration.js"
+    },
+    "./navigateur": {
+      "types": "./dist/navigateur.d.ts",
+      "default": "./dist/navigateur.js"
+    },
+    "./CmsImage.astro": "./src/composants/CmsImage.astro"
+  },
+  "bin": {
+    "komekoo-cms": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "src/composants"
+  ],
+  "peerDependencies": {
+    "astro": "^7.4.2",
+    "vite": "^8.3.5"
+  },
+  "devDependencies": {
+    "@types/mdast": "4.0.4",
+    "@types/node": "26.6.5",
+    "astro": "7.4.2",
+    "typescript": "7.0.2",
+    "vite": "8.3.5",
+    "vitest": "5.0.5"
+  },
+  "dependencies": {
+    "ajv": "8.20.0",
+    "ajv-formats": "3.0.1",
+    "remark-gfm": "4.0.1",
+    "remark-parse": "11.0.0",
+    "unified": "11.0.5",
+    "yaml": "2.9.1"
+  },
+  "scripts": {
+    "test": "vitest run",
+    "typecheck": "tsc -p tsconfig.typecheck.json",
+    "build": "tsc -p tsconfig.json"
+  }
 }

package/src/composants/CmsImage.astro

@@ -0,0 +1,24 @@
+---
+import { srcsetDe } from '@komekoo/astro-cms';
+
+interface Props {
+  image: { src: string; alt: string; largeur: number; hauteur: number };
+  sizes?: string;
+  class?: string;
+  loading?: 'lazy' | 'eager';
+}
+
+const { image, sizes = '100vw', class: classe, loading = 'lazy' } = Astro.props;
+---
+
+<img
+  src={image.src}
+  srcset={srcsetDe(image.src, image.largeur)}
+  sizes={sizes}
+  alt={image.alt}
+  width={image.largeur}
+  height={image.hauteur}
+  loading={loading}
+  decoding="async"
+  class={classe}
+/>