Tags sur les projets, en version 3 du format

Un projet porte désormais une liste d'étiquettes libres, destinées à filtrer la
frise. Il n'y a pas de référentiel à tenir : les tags disponibles sont ceux que
portent les projets.

normaliserTags() nettoie la liste à l'enregistrement — espaces réduits, vides
écartés, doublons fusionnés à la casse près, tri alphabétique pour qu'une
ressaisie dans un autre ordre ne produise aucun diff. Les accents, eux, comptent :
« éditeur » et « editeur » restent deux tags distincts, contrairement aux
identifiants qui doivent tenir dans une URL.

Un tag trop long est tronqué plutôt que refusé : sa longueur est cosmétique, et
bloquer le chargement d'un planning entier pour un libellé bavard serait
disproportionné. La validation ne vérifie donc que le type — un tag mal typé
serait un tag qu'on croit poser et qui ne filtre rien.

teinteTag() dérive une teinte HSL du nom par hachage : la couleur d'un tag n'est
ni stockée ni saisie, et reste la même partout où il apparaît.

Le format passe en version 3. Un fichier en version 2 se charge sans rien
demander, ses projets recevant une liste vide, et il est réécrit en version 3 à
la première sauvegarde. Le bump empêche une version antérieure de l'outil
d'effacer silencieusement les tags en réécrivant le fichier.

Dix tests couvrent la normalisation, la comparaison, la teinte et le filtre.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

js/model.js

@@ -12,7 +12,7 @@
  * La date de fin est *incluse* : du 01/08 au 01/08 dure un jour.
  */
 
-export const VERSION_FORMAT = 2;
+export const VERSION_FORMAT = 3;
 
 export const STATUTS = ['todo', 'doing', 'done', 'blocked'];
 
@@ -151,6 +151,84 @@ export function fabriquerId(nom, dejaPris = []) {
   return `${base}-${compteur}`;
 }
 
+// ---------------------------------------------------------------------------
+// Tags
+// ---------------------------------------------------------------------------
+
+/**
+ * Longueur maximale d'un tag, au-delà de laquelle `normaliserTags` tronque.
+ *
+ * Un tag est une étiquette, pas une phrase. La limite est appliquée en
+ * normalisant plutôt qu'en refusant : elle est cosmétique, comme le statut d'une
+ * phase, et bloquer le chargement d'un planning entier pour un libellé trop
+ * bavard serait disproportionné.
+ */
+export const MAX_LONGUEUR_TAG = 24;
+
+/**
+ * Clé de comparaison d'un tag : c'est elle qui décide que « Client » et
+ * « client » sont le même tag. Minuscules et espaces normalisés, mais accents
+ * conservés — « éditeur » et « editeur » restent deux tags distincts, contrairement
+ * aux identifiants (`fabriquerId`) qui, eux, doivent tenir dans une URL.
+ */
+export function cleTag(tag) {
+  return tag.trim().replace(/\s+/g, ' ').toLocaleLowerCase('fr');
+}
+
+/**
+ * Nettoie une liste de tags : espaces retirés, vides écartés, doublons
+ * fusionnés à la clé près, ordre alphabétique.
+ *
+ * Le tri rend le fichier stable : ressaisir les mêmes tags dans un autre ordre
+ * ne produit aucun diff git.
+ */
+export function normaliserTags(tags) {
+  const vus = new Map();
+  for (const brut of tags) {
+    const tag = String(brut).trim().replace(/\s+/g, ' ').slice(0, MAX_LONGUEUR_TAG).trim();
+    if (!tag) continue;
+    const cle = cleTag(tag);
+    if (!vus.has(cle)) vus.set(cle, tag);
+  }
+  return [...vus.values()].sort((a, b) => a.localeCompare(b, 'fr'));
+}
+
+/** Tous les tags employés dans le planning, dédoublonnés et triés. */
+export function tousLesTags(planning) {
+  return normaliserTags(planning.projects.flatMap((projet) => projet.tags));
+}
+
+/**
+ * Vrai si le projet passe le filtre, c'est-à-dire s'il porte *tous* les tags
+ * sélectionnés. Un filtre vide laisse tout passer.
+ *
+ * La conjonction plutôt que la disjonction : cocher un tag de plus resserre
+ * toujours la sélection, ce qui rend le filtre prévisible — on part du tout et
+ * on élague, sans jamais voir la frise se repeupler en cochant.
+ */
+export function projetFiltre(projet, tagsActifs) {
+  if (!tagsActifs.length) return true;
+  const cles = new Set(projet.tags.map(cleTag));
+  return tagsActifs.every((tag) => cles.has(cleTag(tag)));
+}
+
+/**
+ * Teinte HSL attribuée à un tag, entre 0 et 359.
+ *
+ * Dérivée du nom par un hachage, donc stable d'une session à l'autre et
+ * identique partout où le tag apparaît, sans rien avoir à stocker. Deux tags
+ * peuvent tomber sur des teintes voisines : la couleur aide à repérer, elle ne
+ * porte pas d'information à elle seule — le nom est toujours écrit à côté.
+ */
+export function teinteTag(tag) {
+  const cle = cleTag(tag);
+  let hachage = 0;
+  for (let i = 0; i < cle.length; i += 1) {
+    hachage = (hachage * 31 + cle.charCodeAt(i)) % 360;
+  }
+  return hachage;
+}
+
 // ---------------------------------------------------------------------------
 // Validation
 // ---------------------------------------------------------------------------
@@ -214,6 +292,7 @@ export function validerPlanning(donnees) {
       id: projet.id,
       name: projet.name.trim(),
       color: MOTIF_COULEUR.test(projet.color || '') ? projet.color : COULEURS[0],
+      tags: validerTags(projet.tags, repere),
       collapsed: Boolean(projet.collapsed),
       hidden: Boolean(projet.hidden),
       ...(projet.baselineDate ? { baselineDate: projet.baselineDate } : {}),
@@ -224,6 +303,24 @@ export function validerPlanning(donnees) {
   return { version: VERSION_FORMAT, projects: projets };
 }
 
+/**
+ * Les tags sont facultatifs — un fichier en version 2 n'en a aucun — mais s'ils
+ * sont là, ils doivent être des chaînes : un tag avalé en silence parce qu'il
+ * était mal typé serait un tag qu'on croit poser et qui ne filtre rien.
+ */
+function validerTags(tags, repere) {
+  if (tags === undefined) return [];
+  if (!Array.isArray(tags)) {
+    throw new ErreurValidation(`Projet ${repere} : « tags » doit être un tableau.`);
+  }
+  for (const tag of tags) {
+    if (typeof tag !== 'string') {
+      throw new ErreurValidation(`Projet ${repere} : un tag n'est pas une chaîne.`);
+    }
+  }
+  return normaliserTags(tags);
+}
+
 function validerPhase(phase, rang, repereProjet, idsPhases) {
   const repere = phase && phase.name ? `« ${phase.name} »` : `n°${rang + 1}`;
   const ou = `Projet ${repereProjet}, phase ${repere}`;
@@ -406,12 +503,13 @@ export function formulerDerive(jours) {
 // Modifications
 // ---------------------------------------------------------------------------
 
-export function creerProjet(planning, nom) {
+export function creerProjet(planning, nom, tags = []) {
   const id = fabriquerId(nom, planning.projects.map((p) => p.id));
   return {
     id,
     name: nom.trim(),
     color: COULEURS[planning.projects.length % COULEURS.length],
+    tags: normaliserTags(tags),
     collapsed: false,
     hidden: false,
     phases: [],