@komekoo/astro-cms 0.0.0-stage → 0.2.0

package/dist/noyau/marqueurs.js

@@ -0,0 +1,57 @@
+import { promises as fsp } from 'node:fs';
+import path from 'node:path';
+const MARQUEUR = /<(\w+)\b[^>]*\sdata-cms="([^"]*)"/g;
+const NUMERIQUE = /^\d+$/;
+function resoudre(chemin, schema) {
+    const [id = '', ...suite] = chemin.split('.');
+    if (!Object.hasOwn(schema, id))
+        return 'page inconnue';
+    let noeud = schema[id];
+    for (const segment of suite) {
+        const enfant = NUMERIQUE.test(segment) && noeud.items !== undefined
+            ? noeud.items
+            : noeud.properties !== undefined && Object.hasOwn(noeud.properties, segment)
+                ? noeud.properties[segment]
+                : undefined;
+        if (enfant === undefined)
+            return 'champ inconnu';
+        noeud = enfant;
+    }
+    return noeud;
+}
+/** Contrôle les marqueurs `data-cms` d'une page HTML produite. */
+export function verifierMarqueursHtml(html, page, schema) {
+    const erreurs = [];
+    for (const [, balise, chemin] of html.matchAll(MARQUEUR)) {
+        const noeud = resoudre(chemin, schema);
+        const motif = typeof noeud === 'string'
+            ? noeud
+            : noeud['x-cms']?.editeur === 'image' && balise.toLowerCase() !== 'img'
+                ? "image hors d'une balise <img>"
+                : noeud['x-cms']?.editeur === 'lien' && balise.toLowerCase() !== 'a'
+                    ? "lien hors d'une balise <a>"
+                    : undefined;
+        if (motif !== undefined)
+            erreurs.push({ page, chemin: chemin, motif });
+    }
+    return erreurs;
+}
+async function listerHtml(dossier, prefixe = '') {
+    const entrees = await fsp.readdir(path.join(dossier, prefixe), { withFileTypes: true });
+    const fichiers = await Promise.all(entrees.map(async (e) => {
+        const relatif = prefixe === '' ? e.name : `${prefixe}/${e.name}`;
+        if (e.isDirectory())
+            return listerHtml(dossier, relatif);
+        return e.name.endsWith('.html') ? [relatif] : [];
+    }));
+    return fichiers.flat().sort();
+}
+/** Contrôle toutes les pages HTML de `dossierDist` ; `page` est relative à ce dossier (séparateur `/`). */
+export async function verifierMarqueurs(dossierDist, schema) {
+    const erreurs = [];
+    for (const page of await listerHtml(dossierDist)) {
+        const html = await fsp.readFile(path.join(dossierDist, page), 'utf8');
+        erreurs.push(...verifierMarqueursHtml(html, page, schema));
+    }
+    return erreurs;
+}

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,34 @@
+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;
+    apercu?: 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,65 @@
 {
   "name": "@komekoo/astro-cms",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.2.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"
+    },
+    "./apercu": {
+      "types": "./dist/apercu/index.d.ts",
+      "default": "./dist/apercu/index.js"
+    },
+    "./apercu/arbre": {
+      "types": "./dist/apercu/arbre.d.ts",
+      "default": "./dist/apercu/arbre.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",
+    "happy-dom": "21.0.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,26 @@
+---
+import { srcsetDe } from '@komekoo/astro-cms';
+
+interface Props {
+  image: { src: string; alt: string; largeur: number; hauteur: number };
+  sizes?: string;
+  class?: string;
+  loading?: 'lazy' | 'eager';
+  cms?: string;
+}
+
+const { image, sizes = '100vw', class: classe, loading = 'lazy', cms } = 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}
+  data-cms={cms}
+/>