@starterlib/cli 0.10.2

package/src/etapes/versions.mjs

@@ -0,0 +1,184 @@
+/**
+ * Etape `versions` : le `package.json` de la SPA contre la matrice du socle et le train de reference.
+ *
+ * Elle verifie :
+ *   1. tout paquet de la matrice, s'il est declare, l'est a sa version EXACTE et a celle de la
+ *      matrice ; Angular, le greffon de federation et TypeScript sont exiges ;
+ *   2. tout paquet Angular installe figure a la matrice ;
+ *   3. le greffon de federation a la majeure.mineure d'Angular (235a : la matrice les liste, cette
+ *      regle les LIE) ;
+ *   4. zone.js n'est installe nulle part (le socle est zoneless) ;
+ *   5. pnpm et le plancher de Node sont ceux de la matrice ;
+ *   6. les paquets du socle, CLI compris, sont a la MEME version exacte, celle de ce CLI : ils
+ *      forment un train et se montent ensemble ;
+ *   7. le train de la SPA et le train de reference (le dernier publie) : meme train, vert ; un train
+ *      de retard, un avertissement (la coquille du nouveau train retire la SPA de son menu tant
+ *      qu'elle n'a pas monte) ; deux trains ou plus, un echec (docs/matrice-compatibilite.md,
+ *      « Regle de retard », ADR web 0006).
+ */
+import { spawnSync } from 'node:child_process';
+import { matriceDuSocle, versionDuSocle } from '../matrice.mjs';
+import { retardEnTrains, trainDe } from '../trains.mjs';
+
+const FEDERATION = '@angular-architects/native-federation';
+
+/** Exiges dans toute SPA : ce que la matrice epingle et sans quoi rien ne se construit. */
+const EXIGES = [
+  '@angular/core',
+  '@angular/common',
+  '@angular/compiler',
+  '@angular/compiler-cli',
+  '@angular/forms',
+  '@angular/platform-browser',
+  '@angular/router',
+  '@angular/build',
+  '@angular/cli',
+  FEDERATION,
+  'es-module-shims',
+  'typescript',
+  '@starterlib/core',
+  '@starterlib/tokens',
+  '@starterlib/ui',
+  '@starterlib/util',
+];
+
+/** `22.1.7` donne `22.1` ; `null` pour ce qui n'est pas un numero. */
+function majeureMineure(version) {
+  const trouve = /^(\d+)\.(\d+)\./.exec(version);
+  return trouve === null ? null : `${trouve[1]}.${trouve[2]}`;
+}
+
+/**
+ * Le train de reference : l'option `--train-de-reference`, la variable
+ * `STARTER_WEB_TRAIN_DE_REFERENCE`, sinon le dernier `@starterlib/core` publie au registre.
+ * `null` si rien ne le donne (registre injoignable) : le retard n'est alors pas mesure, et le dire.
+ */
+function trainDeReference(contexte) {
+  const donne = contexte.trainDeReference ?? process.env.STARTER_WEB_TRAIN_DE_REFERENCE;
+  if (donne !== undefined && donne !== '') return { train: trainDe(donne), origine: 'donne' };
+  const resultat = spawnSync('npm', ['view', '@starterlib/core', 'version', '--json'], {
+    encoding: 'utf8',
+    timeout: 20_000,
+    shell: process.platform === 'win32',
+  });
+  if (resultat.status !== 0) return { train: null, origine: 'registre injoignable' };
+  try {
+    return { train: trainDe(JSON.parse(resultat.stdout)), origine: 'registre' };
+  } catch {
+    return { train: null, origine: 'reponse du registre illisible' };
+  }
+}
+
+/** Les fautes et avertissements de `paquet` (le package.json) ; exporte pour les essais. */
+export function jugerLesVersions(paquet, { matrice, socle, reference }) {
+  const declarees = { ...paquet.dependencies, ...paquet.devDependencies };
+  const defauts = [];
+  const avertissements = [];
+
+  for (const nom of EXIGES) {
+    if (declarees[nom] === undefined) defauts.push(`${nom} : absent de package.json.`);
+  }
+
+  for (const [nom, attendue] of Object.entries(matrice.paquets)) {
+    const declaree = declarees[nom];
+    if (declaree === undefined) continue;
+    if (/^[\^~><=*]/.test(declaree)) {
+      defauts.push(
+        `${nom} : plage "${declaree}", version exacte obligatoire (${attendue}, matrice). Une plage ` +
+          'laisse la CI et le poste diverger.',
+      );
+    } else if (declaree !== attendue) {
+      defauts.push(`${nom} : ${declaree}, attendu ${attendue} (exact, matrice).`);
+    }
+  }
+
+  for (const [nom, version] of Object.entries(declarees)) {
+    if (nom.startsWith('@angular/') && !Object.hasOwn(matrice.paquets, nom)) {
+      defauts.push(`${nom} (${version}) est installe mais absent de la matrice de compatibilite.`);
+    }
+  }
+
+  const angular = declarees['@angular/core'];
+  const federation = declarees[FEDERATION];
+  if (
+    angular !== undefined &&
+    federation !== undefined &&
+    majeureMineure(angular) !== majeureMineure(federation)
+  ) {
+    defauts.push(
+      `${FEDERATION} ${federation} : la majeure.mineure du greffon doit etre celle d'@angular/core ` +
+        `(${angular}) ; les monter ensemble, dans le meme commit (235a).`,
+    );
+  }
+
+  if (Object.hasOwn(declarees, 'zone.js')) {
+    defauts.push('zone.js : interdit, le socle est zoneless.');
+  }
+  if (paquet.packageManager !== `pnpm@${matrice.pnpm}`) {
+    defauts.push(
+      `packageManager : ${String(paquet.packageManager)}, attendu pnpm@${matrice.pnpm}.`,
+    );
+  }
+  const node = paquet.engines?.node ?? '';
+  if (!node.startsWith(`>=${matrice.nodeMinimal}`)) {
+    defauts.push(
+      `engines.node "${node}" : le plancher de la matrice est >=${matrice.nodeMinimal}.`,
+    );
+  }
+
+  // Les paquets du socle forment un train : une version, la meme partout, celle de ce CLI.
+  const duSocle = Object.entries(declarees).filter(([nom]) => nom.startsWith('@starterlib/'));
+  for (const [nom, version] of duSocle) {
+    if (/^[\^~><=*]/.test(version)) {
+      defauts.push(`${nom} : plage "${version}", version exacte obligatoire (${socle}).`);
+    } else if (version !== socle) {
+      defauts.push(
+        `${nom} : ${version}, attendu ${socle} (la version de @starterlib/cli : les paquets du ` +
+          'socle se montent ensemble).',
+      );
+    }
+  }
+
+  const train = trainDe(socle);
+  if (reference.train === null) {
+    avertissements.push(
+      `train de reference inconnu (${reference.origine}) : le retard sur le dernier train n'est pas ` +
+        'mesure. --train-de-reference <train> le fixe.',
+    );
+  } else {
+    const retard = retardEnTrains(train, reference.train);
+    if (retard === 1) {
+      avertissements.push(
+        `un train de retard (${train}, dernier train ${reference.train}) : la coquille du nouveau ` +
+          'train retire cette SPA de son menu tant qu elle n a pas monte.',
+      );
+    } else if (retard >= 2) {
+      defauts.push(
+        `${String(retard)} trains de retard (${train}, dernier train ${reference.train}) : un remote ` +
+          'peut avoir un train de retard sur la coquille, pas davantage (ADR web 0006).',
+      );
+    }
+  }
+
+  return { defauts, avertissements, train };
+}
+
+export default {
+  nom: 'versions',
+  roles: ['remote', 'hote'],
+  executer(projet, contexte) {
+    const matrice = matriceDuSocle();
+    const socle = versionDuSocle();
+    const reference = trainDeReference(contexte);
+    const { defauts, avertissements, train } = jugerLesVersions(projet.paquet, {
+      matrice,
+      socle,
+      reference,
+    });
+    return {
+      defauts,
+      avertissements,
+      resume: `conformes a la matrice (socle ${socle}, train ${String(train)}, Angular ${matrice.paquets['@angular/core']}).`,
+    };
+  },
+};

package/src/index.mjs

@@ -0,0 +1,12 @@
+/**
+ * L'API programmatique de `@starterlib/cli`, pour un outil qui l'appelle sans passer par la ligne
+ * de commande (un script de fixtures, un essai). La ligne de commande est `starter-web`.
+ */
+export { lancer, lireLesArguments } from './lancer.mjs';
+export { lireLeProjet, ProjetIllisible } from './projet.mjs';
+export { ETAPES, verifier } from './verifier.mjs';
+export { lireLaMatrice, matriceDuSocle, versionDuSocle } from './matrice.mjs';
+export { comparerLesTrains, retardEnTrains, trainDe } from './trains.mjs';
+export { precompresser } from './construction/precompresser.mjs';
+export { ecrireLeManifeste } from './construction/manifeste.mjs';
+export { poserLeSprite } from './construction/sprite.mjs';

package/src/lancer.mjs

@@ -0,0 +1,211 @@
+/**
+ * La ligne de commande `starter-web` (lot 174).
+ *
+ * Codes de sortie : 0 conforme ; 1 une etape a echoue, et son nom est ecrit ; 2 la commande ne peut
+ * pas s'executer (argument inconnu, projet illisible).
+ */
+import { construire } from './construction/construire.mjs';
+import { ecrireLeManifeste } from './construction/manifeste.mjs';
+import { juger, precompresser } from './construction/precompresser.mjs';
+import { poserLeSprite } from './construction/sprite.mjs';
+import { ecrireLesTypesDeCles } from './construction/types-i18n.mjs';
+import { lireJson, relatif } from './commun.mjs';
+import { versionDuSocle } from './matrice.mjs';
+import { ProjetIllisible, lireLeProjet } from './projet.mjs';
+import { ETAPES, etapesInconnues, verifier } from './verifier.mjs';
+import { join, resolve } from 'node:path';
+
+const AIDE = `starter-web : la chaine d'une SPA du socle frontal (@starterlib/cli).
+
+Commandes :
+  verify          les etapes, dans l'ordre, arretees a la premiere qui echoue
+  construire      sprite, ng build, manifeste, precompression (--configuration development)
+  sprite          pose le sprite hache et sa constante
+  manifeste       engendre manifest.json dans le dossier livre
+  precompresser   ecrit les variantes .br et .gz (dossier livre, ou le dossier donne)
+  i18n:types      engendre le type des cles de chaque perimetre (src/app/i18n/cles.ts)
+  etapes          liste les etapes de verify
+
+Options de verify :
+  --etapes a,b             seulement ces etapes
+  --sauter a,b             toutes sauf celles-ci
+  --train-de-reference T   le dernier train publie (sinon lu au registre)
+
+Options du projet (valeurs attendues, lues sinon dans ses fichiers) :
+  --nom <nom>  --prefixe <prefixe>  --pleine-page | --pas-pleine-page
+`;
+
+/** Les arguments en `{ commande, positionnels, options }` ; leve sur une option inconnue. */
+export function lireLesArguments(argv) {
+  const options = {};
+  const positionnels = [];
+  const valeur = (indice, nom) => {
+    const suivant = argv[indice + 1];
+    if (suivant === undefined || suivant.startsWith('--'))
+      throw new Error(`${nom} attend une valeur.`);
+    return suivant;
+  };
+  const liste = (texte) =>
+    texte
+      .split(',')
+      .map((nom) => nom.trim())
+      .filter((nom) => nom !== '');
+  for (let indice = 0; indice < argv.length; indice += 1) {
+    const argument = argv[indice];
+    switch (argument) {
+      case '--etapes':
+        options.etapes = liste(valeur(indice, argument));
+        indice += 1;
+        break;
+      case '--sauter':
+        options.sauter = liste(valeur(indice, argument));
+        indice += 1;
+        break;
+      case '--train-de-reference':
+        options.trainDeReference = valeur(indice, argument);
+        indice += 1;
+        break;
+      case '--nom':
+        options.nom = valeur(indice, argument);
+        indice += 1;
+        break;
+      case '--prefixe':
+        options.prefixe = valeur(indice, argument);
+        indice += 1;
+        break;
+      case '--configuration':
+        options.configuration = valeur(indice, argument);
+        indice += 1;
+        break;
+      case '--pleine-page':
+        options.pleinePage = true;
+        break;
+      case '--pas-pleine-page':
+        options.pleinePage = false;
+        break;
+      case '--aide':
+      case '-h':
+        options.aide = true;
+        break;
+      case '--version':
+      case '-v':
+        options.version = true;
+        break;
+      default:
+        if (argument.startsWith('-')) throw new Error(`option inconnue : ${argument}`);
+        positionnels.push(argument);
+    }
+  }
+  const [commande, ...reste] = positionnels;
+  return { commande, positionnels: reste, options };
+}
+
+function precompresserEtDire(dossier, sortie) {
+  const { resume, defauts } = juger(precompresser(dossier));
+  sortie.info(`precompression : ${resume}`);
+  for (const defaut of defauts) sortie.erreur(`  - ${defaut}`);
+  return defauts.length === 0 ? 0 : 1;
+}
+
+/**
+ * Lance `argv` (sans `node` ni le script) depuis `racine`. `journal` : `{ info, erreur }`. Rend le
+ * code de sortie.
+ */
+export async function lancer(argv, { racine = process.cwd(), journal } = {}) {
+  const sortie = journal ?? {
+    info: (texte) => console.log(texte),
+    erreur: (texte) => console.error(texte),
+  };
+  let lu;
+  try {
+    lu = lireLesArguments(argv);
+  } catch (erreur) {
+    sortie.erreur(`starter-web : ${erreur.message}\n\n${AIDE}`);
+    return 2;
+  }
+  const { commande, positionnels, options } = lu;
+  if (options.version) {
+    sortie.info(versionDuSocle());
+    return 0;
+  }
+  if (options.aide || commande === undefined || commande === 'aide') {
+    sortie.info(AIDE);
+    return commande === undefined && !options.aide ? 2 : 0;
+  }
+  if (commande === 'etapes') {
+    for (const etape of ETAPES) sortie.info(`${etape.nom.padEnd(12)} ${etape.roles.join(', ')}`);
+    return 0;
+  }
+
+  const inconnues = etapesInconnues([...(options.etapes ?? []), ...(options.sauter ?? [])]);
+  if (inconnues.length > 0) {
+    sortie.erreur(
+      `starter-web : etape(s) inconnue(s) : ${inconnues.join(', ')} (starter-web etapes).`,
+    );
+    return 2;
+  }
+
+  // Un dossier donne se precompresse sans projet autour : une fixture reecrite, un dossier d'essai.
+  if (commande === 'precompresser' && positionnels[0] !== undefined) {
+    return precompresserEtDire(resolve(racine, positionnels[0]), sortie);
+  }
+
+  let projet;
+  try {
+    projet = lireLeProjet(racine, options);
+  } catch (erreur) {
+    if (erreur instanceof ProjetIllisible) {
+      sortie.erreur(`starter-web : ${erreur.message}`);
+      return 2;
+    }
+    throw erreur;
+  }
+
+  try {
+    switch (commande) {
+      case 'verify': {
+        sortie.info(
+          `starter-web verify ${versionDuSocle()} : ${projet.nom} (${projet.role}, prefixe ` +
+            `${String(projet.prefixe)}, pleine page ${projet.pleinePage ? 'oui' : 'non'}, ` +
+            `${projet.sortieRelative})`,
+        );
+        return await verifier(projet, { ...options, journal: sortie });
+      }
+      case 'construire':
+        return construire(projet, { configuration: options.configuration, journal: sortie });
+      case 'sprite':
+        sortie.info(`sprite : ${poserLeSprite(projet)}`);
+        return 0;
+      case 'manifeste': {
+        const manifeste = ecrireLeManifeste(projet);
+        sortie.info(
+          `manifest.json : ${manifeste.nom} ${manifeste.version}, socle ${manifeste.socle.construit}, Angular ${manifeste.angular}`,
+        );
+        return 0;
+      }
+      case 'precompresser':
+        return precompresserEtDire(projet.sortie, sortie);
+      case 'i18n:types': {
+        const perimetres =
+          projet.role === 'remote' ? (projet.source?.i18n?.perimetres ?? []) : ['socle'];
+        const catalogues = Object.fromEntries(
+          perimetres.map((perimetre) => [
+            perimetre,
+            { fr: lireJson(join(projet.racine, 'public', 'i18n', `${perimetre}.fr.json`)) },
+          ]),
+        );
+        const chemin = ecrireLesTypesDeCles(projet.racine, perimetres, catalogues);
+        sortie.info(`i18n:types : ${relatif(projet.racine, chemin)} (${perimetres.join(', ')})`);
+        return 0;
+      }
+      default:
+        sortie.erreur(`starter-web : commande inconnue : ${commande}\n\n${AIDE}`);
+        return 2;
+    }
+  } catch (erreur) {
+    sortie.erreur(
+      `starter-web ${commande} : ${erreur instanceof Error ? erreur.message : String(erreur)}`,
+    );
+    return 1;
+  }
+}

package/src/livraison.mjs

@@ -0,0 +1,45 @@
+/**
+ * La nature des fichiers d'un livrable federe, lue dans `remoteEntry.json` (lot 177).
+ *
+ * - PARTAGES : les paquets que la federation partage (`shared[].outFileName`) et leurs morceaux
+ *   internes (`chunks['browser-shared']`, adresses `@nf-internal/...` de la carte d'importation) :
+ *   le code d'Angular et du socle, charge une fois par la coquille pour toutes les SPA.
+ * - EXPOSES : ce que la coquille charge du remote (`exposes[].outFileName` et
+ *   `chunks['mapping-or-exposed']`) : ses routes, ses pages et leurs morceaux.
+ * - le RESTE : l'application autonome (`main`, ses morceaux, `index.html`), que la coquille ne
+ *   charge jamais d'un remote.
+ *
+ * Les gardes de l'ADR 0029 jugent le code de la SPA, pas celui du cadre : Angular ecrit
+ * `innerHTML` et appelle `fetch`, le socle aussi (televersement direct), et la garde de securite du
+ * socle juge deja ses propres paquets construits.
+ */
+
+/** `{ partages, exposes }` : deux ensembles de chemins relatifs au dossier livre. */
+export function natureDesFichiers(entree) {
+  return {
+    partages: new Set([
+      ...(entree?.shared ?? []).map((partage) => partage.outFileName),
+      ...(entree?.chunks?.['browser-shared'] ?? []),
+    ]),
+    exposes: new Set([
+      ...(entree?.exposes ?? []).map((expose) => expose.outFileName),
+      ...(entree?.chunks?.['mapping-or-exposed'] ?? []),
+    ]),
+  };
+}
+
+/** Un specificateur nu, tel qu'un module ES construit l'ecrit (`@angular/core`, `rxjs/operators`). */
+export const SPECIFICATEUR_NU = /^@?[a-z0-9][\w.-]*(?:\/[\w.@-]+)*$/i;
+
+/** Les specificateurs importes par un module construit, statiquement et dynamiquement. */
+export function specificateurs(code) {
+  const trouves = [];
+  for (const motif of [
+    /\bfrom\s*["']([^"']+)["']/g,
+    /\bimport\s*["']([^"']+)["']/g,
+    /\bimport\s*\(\s*["']([^"']+)["']\s*\)/g,
+  ]) {
+    for (const [, specificateur] of code.matchAll(motif)) trouves.push(specificateur);
+  }
+  return trouves;
+}

package/src/matrice.mjs

@@ -0,0 +1,119 @@
+/**
+ * La matrice de compatibilite, lue dans le DOCUMENT ou le proprietaire l'ecrit (lot 174).
+ *
+ * `docs/matrice-compatibilite.md` est la source : chaque montee s'y ecrit ligne par ligne, avec sa
+ * raison. Les copies recopiees dans chaque SPA (`tools/verifier-versions.mjs`) divergeaient des le
+ * premier ajustement ; le CLI lit le document publie avec lui, et une garde du socle compare cette
+ * lecture a la matrice de sa propre garde (`test/matrice.test.mjs`).
+ *
+ * Ce qui est lu : les tableaux des sections « Train » et « A destination des depots de SPA ». Dans la
+ * colonne des elements, un nom sans portee qui suit un nom porte (`@angular/core`, `common`) herite
+ * de sa portee ; une cellule de versions a une seule valeur s'applique a toute la ligne, sinon les
+ * versions s'appairent aux noms dans l'ordre. `node` donne le plancher, `pnpm` le gestionnaire.
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const ICI = dirname(fileURLToPath(import.meta.url));
+
+/** Les sections dont les tableaux font la matrice. */
+const SECTIONS = [/^## Train\b/, /^## A destination des depots de SPA\b/];
+
+/** Le document : publie a la racine du paquet, ou lu dans le depot du socle. */
+export function cheminDeLaMatrice() {
+  const candidats = [
+    join(ICI, '..', 'matrice-compatibilite.md'),
+    join(ICI, '..', '..', '..', 'docs', 'matrice-compatibilite.md'),
+  ];
+  const trouve = candidats.find((candidat) => existsSync(candidat));
+  if (trouve === undefined) {
+    throw new Error(
+      `matrice-compatibilite.md introuvable (${candidats.join(', ')}) : paquet incomplet.`,
+    );
+  }
+  return trouve;
+}
+
+/** Les cellules des lignes de donnees d'un tableau markdown (en-tete et separateur exclus). */
+function lignesDeTableau(lignes) {
+  const tableau = lignes.filter((ligne) => ligne.trimStart().startsWith('|'));
+  return tableau
+    .slice(2)
+    .map((ligne) => ligne.trim().replace(/^\|/, '').replace(/\|$/, '').split('|'))
+    .map((cellules) => cellules.map((cellule) => cellule.trim()));
+}
+
+/** Les noms entre accents graves d'une cellule, portee heritee (`@angular/core`, `common`). */
+function nomsDeLaCellule(cellule) {
+  const noms = [];
+  let portee = null;
+  for (const [, brut] of cellule.matchAll(/`([^`]+)`/g)) {
+    if (brut.startsWith('@')) {
+      portee = brut.split('/')[0];
+      noms.push(brut);
+    } else if (portee !== null && !brut.includes('/')) {
+      noms.push(`${portee}/${brut}`);
+    } else {
+      noms.push(brut);
+    }
+  }
+  return noms;
+}
+
+/**
+ * La matrice ecrite dans `texte` : `{ train, paquets, pnpm, nodeMinimal }`. Leve si le document ne
+ * porte plus ce que le CLI sait lire : une matrice lue a moitie laisserait passer en silence ce
+ * qu'elle ne voit plus.
+ */
+export function lireLaMatrice(texte) {
+  const lignes = texte.split(/\r?\n/);
+  const paquets = {};
+  let pnpm = null;
+  let nodeMinimal = null;
+  let train = null;
+
+  for (const section of SECTIONS) {
+    const debut = lignes.findIndex((ligne) => section.test(ligne));
+    if (debut === -1) {
+      throw new Error(`matrice : section ${String(section)} absente du document.`);
+    }
+    const fin = lignes.findIndex((ligne, indice) => indice > debut && ligne.startsWith('## '));
+    const corps = lignes.slice(debut + 1, fin === -1 ? undefined : fin);
+    train ??= /`([^`]+)`/.exec(lignes[debut])?.[1] ?? null;
+
+    for (const [element = '', colonneDesVersions = ''] of lignesDeTableau(corps)) {
+      const noms = nomsDeLaCellule(element);
+      const versions = [...colonneDesVersions.matchAll(/`([^`]+)`/g)].map(([, version]) => version);
+      if (noms.length === 0 || versions.length === 0) {
+        throw new Error(`matrice : ligne illisible (${element} | ${colonneDesVersions}).`);
+      }
+      if (versions.length !== 1 && versions.length !== noms.length) {
+        throw new Error(
+          `matrice : ${String(noms.length)} noms pour ${String(versions.length)} versions (${element}).`,
+        );
+      }
+      noms.forEach((nom, indice) => {
+        const version = versions.length === 1 ? versions[0] : versions[indice];
+        if (nom === 'node') nodeMinimal = version.replace(/^>=\s*/, '');
+        else if (nom === 'pnpm') pnpm = version;
+        else paquets[nom] = version;
+      });
+    }
+  }
+
+  if (paquets['@angular/core'] === undefined || pnpm === null || nodeMinimal === null) {
+    throw new Error('matrice : @angular/core, pnpm ou node manque au document.');
+  }
+  return { train, paquets, pnpm, nodeMinimal };
+}
+
+/** La matrice publiee avec le CLI. */
+export function matriceDuSocle() {
+  return lireLaMatrice(readFileSync(cheminDeLaMatrice(), 'utf8'));
+}
+
+/** La version du socle que ce CLI porte : la sienne, publiee avec les autres paquets du train. */
+export function versionDuSocle() {
+  return JSON.parse(readFileSync(join(ICI, '..', 'package.json'), 'utf8')).version;
+}

package/src/projet.mjs

@@ -0,0 +1,96 @@
+/**
+ * Ce que le CLI sait d'une SPA, lu dans ses fichiers et jamais recopie (lot 174).
+ *
+ * Les huit outils recopies dans chaque SPA ne differaient que par trois ecritures : le nom du remote
+ * (`dist/<nom>/browser`, `/ui/<nom>/`), le prefixe de ses selecteurs et `pleinePage`. Le CLI les lit
+ * la ou elles vivent deja :
+ *
+ * - le role : `package.json#starterWeb.role` (`hote` pour la coquille), sinon `remote` des qu'un
+ *   `manifest.source.json` existe ;
+ * - le nom et `pleinePage` : `manifest.source.json` (un remote), `socle` pour l'hote ;
+ * - le prefixe : `prefix` du projet d'`angular.json`, ou `starterWeb.prefixe` ;
+ * - le dossier livre : `outputPath` de la cible `@angular/build:application`, plus `browser`.
+ *
+ * Les options de la ligne de commande (`--nom`, `--prefixe`, `--pleine-page`) les remplacent : ce
+ * sont les valeurs ATTENDUES, et les etapes signalent tout fichier qui s'en ecarte.
+ */
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { lireJson } from './commun.mjs';
+
+/** Le projet ne peut pas etre lu : la commande ne peut pas s'executer (code 2). */
+export class ProjetIllisible extends Error {}
+
+const CIBLE_DE_CONSTRUCTION = '@angular/build:application';
+
+/** Le projet d'application d'`angular.json` : le seul, ou celui qui porte le nom attendu. */
+function projetAngular(angular, nom) {
+  const applications = Object.entries(angular?.projects ?? {}).filter(
+    ([, projet]) => projet.projectType === undefined || projet.projectType === 'application',
+  );
+  const retenu =
+    applications.find(([cle]) => cle === nom) ??
+    (applications.length === 1 ? applications[0] : null);
+  if (retenu === null) {
+    throw new ProjetIllisible(
+      `angular.json : ${String(applications.length)} projets d'application, aucun nomme ${nom}.`,
+    );
+  }
+  return { nomDuProjet: retenu[0], projet: retenu[1] };
+}
+
+/** `outputPath` de la cible de construction, plus `browser` : ce qui part vers le serveur. */
+function dossierDeSortie(projet) {
+  for (const cible of Object.values(projet.architect ?? {})) {
+    if (cible.builder !== CIBLE_DE_CONSTRUCTION) continue;
+    const chemin = cible.options?.outputPath;
+    if (typeof chemin === 'string') return join(chemin, 'browser');
+    if (typeof chemin?.base === 'string') return join(chemin.base, chemin.browser ?? 'browser');
+  }
+  return null;
+}
+
+/**
+ * Le projet sous `racine`. `options` : `nom`, `prefixe`, `pleinePage`, `role` venus de la ligne de
+ * commande. Leve `ProjetIllisible` quand un fichier manque ou ne se lit pas.
+ */
+export function lireLeProjet(racine, options = {}) {
+  const paquet = lireJson(join(racine, 'package.json'));
+  if (paquet === null)
+    throw new ProjetIllisible(`package.json absent ou illisible dans ${racine}.`);
+  const reglages = paquet.starterWeb ?? {};
+
+  const cheminSource = join(racine, 'manifest.source.json');
+  const role = options.role ?? reglages.role ?? (existsSync(cheminSource) ? 'remote' : 'hote');
+  if (role !== 'remote' && role !== 'hote') {
+    throw new ProjetIllisible(`starterWeb.role : "remote" ou "hote", recu "${String(role)}".`);
+  }
+  const source = role === 'remote' ? lireJson(cheminSource) : null;
+  if (role === 'remote' && source === null) {
+    throw new ProjetIllisible('manifest.source.json absent ou illisible : un remote en a un.');
+  }
+
+  const nom = options.nom ?? source?.nom ?? reglages.nom ?? 'socle';
+  const angular = lireJson(join(racine, 'angular.json'));
+  if (angular === null) throw new ProjetIllisible('angular.json absent ou illisible.');
+  const { nomDuProjet, projet } = projetAngular(angular, nom);
+  const sortie = dossierDeSortie(projet);
+  if (sortie === null) {
+    throw new ProjetIllisible(
+      `angular.json : aucune cible ${CIBLE_DE_CONSTRUCTION} avec outputPath dans ${nomDuProjet}.`,
+    );
+  }
+
+  return {
+    racine,
+    paquet,
+    role,
+    nom,
+    prefixe: options.prefixe ?? reglages.prefixe ?? projet.prefix ?? null,
+    pleinePage: options.pleinePage ?? source?.pleinePage === true,
+    source,
+    nomDuProjetAngular: nomDuProjet,
+    sortieRelative: sortie.split('\\').join('/'),
+    sortie: join(racine, sortie),
+  };
+}