Lot 6 : l'interface est bilingue, et la mesure l'est devenue aussi

    const texte = await readFile(f, "utf8");

    // Une longue phrase est coupée en littéraux concaténés pour tenir dans la

    // largeur du fichier : la clé est leur recollement, pas le premier morceau.

    for (const m of texte.matchAll(/\bt\(\s*((?:"(?:[^"\\]|\\.)*"\s*\+?\s*)+)/g)) {

    // « traduisible(…) » marque une chaîne au niveau d'un module, où « t » ne

    // peut pas s'appeler : elle compte comme employée, et le dictionnaire doit

    // donc la porter — sans quoi le marqueur serait une promesse sans suite.

    for (const m of texte.matchAll(

      /\b(?:t|traduisible)\(\s*((?:"(?:[^"\\]|\\.)*"\s*\+?\s*)+)/g)) {

      const morceaux = [...m[1]!.matchAll(/"((?:[^"\\]|\\.)*)"/g)].map((x) => x[1]!);

      employees.add(morceaux.join("").replace(/\\"/g, '"'));

    }

  for (const f of fichiers) {

    if (f.includes("/langues/")) continue;

    const texte = await readFile(f, "utf8");

    for (const m of texte.matchAll(/>([^<>{}]*[A-Za-zÀ-ÿ][^<>{}]*)</g)) {

    // Un nœud de texte ne se termine pas toujours sur une balise : « Kastell —

    // logiciel libre sous{" "} » finit sur une accolade. Cette seconde borne

    // demande plus de prudence — une déclaration de type finit aussi sur une

    // accolade — d'où l'exigence d'une phrase : une espace, un mot-outil

    // français, et rien qui ressemble à une signature.

    const versAccolade = [...texte.matchAll(/>([^<>{}]*[A-Za-zÀ-ÿ][^<>{}]*)\{/g)]

      .filter((m) => {

        const v = m[1]!.replace(/\s+/g, " ").trim();

        return v.includes(" ") && /\b(le|la|les|de|du|des|sous|sur|dans|pour|et|ou|un|une)\b/i

          .test(v) && !/[:()[\]=;]/.test(v);

      });

    for (const m of [...texte.matchAll(/>([^<>{}]*[A-Za-zÀ-ÿ][^<>{}]*)</g), ...versAccolade]) {

      const brut = m[1]!.replace(/\s+/g, " ").trim();

      // Un commentaire cite parfois des chevrons — « l:<nom> » — que le motif

      // prend pour des balises. Et « m.seq » ou « (e: React.ChangeEvent » sont

  // Les noms de classes de la feuille de style ne sont pas du texte.

  const CLASSE =

    /\b(discret|petit|pousse|accent|pastille|ligne|carte|etiq|crit|alerte|neutre|sans-point|ok|mono|aide|scene|contenu|champ|pile|grille|vide|item|actif|fait|valeur|nombres|noreferrer|noopener)\b/;

  const APPEL_T = /\bt\(\s*(?:"(?:[^"\\\n]|\\.)*"\s*\+?\s*)+\)?/g;

  const APPEL_T = /\b(?:t|traduisible)\(\s*(?:"(?:[^"\\\n]|\\.)*"\s*\+?\s*)+\)?/g;

  for (const f of fichiers) {

    if (f.includes("/langues/")) continue;

    const texte = await readFile(f, "utf8");

      // Un commentaire n'est pas de l'interface ; « throw new Error » non plus,

      // qui s'adresse à celui qui lit la console, pas à la cellule.

      if (avant.trimStart().startsWith("*") || avant.includes("//")) continue;

      if (avant.includes("throw new Error(") || avant.includes("console.")) continue;

      // Un « throw new Error » peut tenir sur plusieurs lignes : c'est la

      // phrase entière qu'il faut écarter, pas la première ligne seulement.

      const amont = texte.slice(Math.max(0, i - 400), i);

      if (/throw new Error\((?:[^)]|\n)*$/.test(amont) || avant.includes("console.")) continue;

      // « fontFamily: 'JetBrains Mono' » est une valeur de style, et

      // « chemin: "reponse" | "sans-reponse" » un littéral de type.

      if (/fontFamily|font-family|fontWeight/.test(avant)) continue;

      if (/:\s*"[\w-]+"\s*\|\s*$|\|\s*$/.test(avant)) continue;

      const valeur = m[1]!.trim();

      if (valeur.length < 3) continue;

      const accentue = /[àâäéèêëîïôöùûü眒]/.test(valeur);

      // Sans accent, on exige aussi une espace ou une capitale : « sans-reponse »

      // est une valeur de données, pas une phrase.

      if (!accentue && !valeur.includes(" ") && !/^[A-ZÀ-Ý]/.test(valeur)) continue;

      if (!accentue && (CLASSE.test(valeur)

        || (!MOT_FRANCAIS.test(valeur) && !valeur.includes(" "))

        || /className\s*[=:]\s*$|queryKey|`/.test(avant))) continue;

  // cinquante-six, puis soixante-dix-neuf. Il ne se baisse jamais. Le jour où

  // il atteindra cent, il deviendra une exigence simple — d'ici là, il dit

  // exactement ce qui reste, et empêche que cela reparte à l'envers.

  const PLANCHER = 88;

  // Le cliquet a fait son office. Parti de dix-sept pour cent, il a servi de

  // liste de tâches lot après lot — vingt-et-un, trente-neuf, cinquante-six,

  // soixante-dix-neuf, quatre-vingt-huit — en se relevant sans jamais se

  // baisser, et en encaissant trois fois la correction d'une mesure qui se

  // trompait : les génériques comptés pour du texte, le texte hors du rendu

  // oublié, puis les chaînes sans accent.

  //

  // Il est arrivé à cent. EX-21 demande une interface bilingue, pas une

  // interface presque bilingue : l'exigence est donc simple désormais, et ce

  // qui manquerait est nommé, pour qu'aucune chaîne neuve ne se glisse en

  // français sans qu'on la voie.

  r.verifie("EX-21",

    `${employees.size} chaînes visibles sur ${visibles} passent par la traduction`

    + ` (${couverture} %, plancher ${PLANCHER} %)`,

    couverture >= PLANCHER,

    couverture < PLANCHER

      ? `recul de ${PLANCHER - couverture} points ; il reste ${nues.size} chaînes`

      : "");

    + ` (${couverture} %)`,

    nues.size === 0,

    [...nues].slice(0, 4).map((n) => `« ${n.slice(0, 40)} »`).join(", "));

  // Un texte non traduit s'affiche en français : c'est le repli voulu, jamais

  // un identifiant technique illisible sous pression.

          ) : null

        ))}

        {(data?.hors_cellule ?? []).length > 0 && (

          <optgroup label="Hors cellule">

          <optgroup label={t("Hors cellule")}>

            {data!.hors_cellule.map((p) => (

              <option

                key={p.compte_id ?? `nom:${p.nom}`}

import { useEffect, useRef, useState } from "react";

import { useQueryClient } from "@tanstack/react-query";

import { api, ErreurApi } from "../api.js";

import { useT } from "../langues/index.js";

import { useT, traduisible } from "../langues/index.js";

/**

 * Ce que l'on consigne à la main.

 */

const GENRES = [

  { cle: "fait", libelle: "Fait" },

  { cle: "decision", libelle: "Décision" },

  { cle: "hypothese", libelle: "Hypothèse" },

  { cle: "decision", libelle: traduisible("Décision") },

  { cle: "hypothese", libelle: traduisible("Hypothèse") },

  { cle: "alerte", libelle: "Alerte" },

  { cle: "communication", libelle: "Communication" },

];

      await client.invalidateQueries({ queryKey: ["cockpit", criseId] });

      fermer();

    } catch (e) {

      definirErreur(e instanceof ErreurApi ? e.message : "Consignation impossible.");

      definirErreur(e instanceof ErreurApi ? e.message : t("Consignation impossible."));

      definirOccupe(false);

    }

  }

          <button key={g.cle} type="button"

            className={genre === g.cle ? "actif" : ""}

            onClick={() => definirGenre(g.cle)}>

            {g.libelle}

            {t(g.libelle)}

          </button>

        ))}

      </div>

      // Mise à jour fonctionnelle, et non depuis une valeur capturée : c'est la

      // règle qui manquait, et son absence remettait la fenêtre qu'on venait de

      // fermer.

      const titre = String(d.charge?.["auteur_nom"] ?? "Message direct");

      const titre = String(d.charge?.["auteur_nom"] ?? t("Message direct"));

      definirFenetres((liste) => (

        liste.some((f) => f.conversationId === conversation)

          ? liste.map((f) => (f.conversationId === conversation

            portée, fermer l'écarte. Confondre les deux fait perdre le fil

            qu'on voulait seulement mettre de côté. */}

        <button className="reduire"

          aria-label={fenetre.repliee ? "Agrandir la conversation" : t("Réduire la conversation")}

          aria-label={fenetre.repliee ? t("Agrandir la conversation") : t("Réduire la conversation")}

          title={fenetre.repliee ? "Agrandir" : t("Réduire")}

          onClick={() => (fenetre.repliee ? basculer(id) : reduire(id))}>

          {fenetre.repliee ? "▴" : "▾"}