@mostajs/flotte-ui 0.1.0 → 0.2.0

package/src/textes.js

@@ -11,13 +11,13 @@ export const TEXTES = Object.freeze({
   rechercheGlobale: 'Rechercher un véhicule, un chauffeur, une plaque, une tournée…',
   nouveau: 'Nouveau véhicule',
   kpi: {
-    vehicules: 'Véhicules', chauffeurs: 'Chauffeurs', enService: 'En service', enMaintenance: 'En maintenance',
+    vehicules: 'Véhicules', chauffeurs: 'Chauffeurs', enService: 'En service', enMaintenance: 'En maintenance', horsService: 'Hors service',
     documentsExpires: 'Documents expirés', vsPeriode: 'vs période précédente', nouveau: 'nouveau',
   },
   liste: {
     titre: 'Liste des véhicules', recherche: 'Rechercher un véhicule, une plaque, un chauffeur…', tousTypes: 'Tous les types',
     tousStatuts: 'Tous les statuts', toutesRegions: 'Toutes les régions', filtrer: 'Filtrer', vide: 'Aucun véhicule ne répond à ces filtres.',
-    exporter: 'Exporter (CSV)', resultat: '{n} véhicule(s)',
+    exporter: 'Exporter (CSV)', resultat: '{n} véhicule(s)', tous: 'Tous', puces: 'Filtrer par statut',
   },
   col: {
     numero: '#', plaque: 'Plaque', type: 'Type', capacite: 'Capacité', region: 'Région', station: 'Station', chauffeur: 'Chauffeur',
@@ -25,27 +25,46 @@ export const TEXTES = Object.freeze({
   },
   action: {
     voir: 'Voir', modifier: 'Modifier', affecter: 'Affecter un chauffeur', planifier: 'Planifier un entretien', documents: 'Voir les documents',
-    tournee: 'Planifier une tournée', historique: 'Consulter l’historique', menu: 'Actions sur {plaque}',
+    tournee: 'Planifier une tournée', historique: 'Consulter l’historique', menu: 'Actions sur {plaque}', ouvrir: 'Ouvrir la fiche',
+    changerStatut: 'Changer le statut', intervention: 'Ouvrir une intervention', clore: 'Clore', renouveler: 'Renouveler', liberer: 'Libérer le véhicule',
+    plein: 'Saisir un plein', releve: 'Ajouter un relevé', relever: 'Relever le compteur', enregistrer: 'Enregistrer', annuler: 'Annuler',
+    valider: 'Valider l’affectation', telecharger: 'Télécharger {nom}',
   },
-  depart: { oui: 'Peut partir aujourd’hui', non: 'Ne peut pas partir', ouiCourt: 'peut partir', nonCourt: 'ne peut pas partir' },
+  depart: { oui: 'Peut partir aujourd’hui', non: 'Ne peut pas partir', ouiCourt: 'peut partir', nonCourt: 'ne peut pas partir', aucunMotif: 'Aucun motif bloquant' },
   documentExpire: 'document expiré',
   detail: { titre: 'Détail du véhicule', aucun: 'Choisissez un véhicule dans la liste.' },
-  onglet: { informations: 'Informations', documents: 'Documents', entretiens: 'Entretiens', affectations: 'Affectations', historique: 'Historique' },
+  onglet: {
+    informations: 'Informations', documents: 'Documents', entretiens: 'Entretiens', affectations: 'Affectations', pleins: 'Pleins et relevés',
+    couts: 'Coûts', historique: 'Historique',
+  },
   info: {
     plaque: 'Plaque d’immatriculation', type: 'Type', capacite: 'Capacité', region: 'Région', station: 'Station principale', km: 'Kilométrage',
     miseEnService: 'Date de mise en service', chauffeur: 'Chauffeur actuel', consommation: 'Consommation moyenne', prochainEntretien: 'Prochain entretien',
     valideJusquau: 'Valide jusqu’au {date}', expireeLe: 'Expirée le {date}', expireBientot: 'Expire le {date}', absent: 'Aucun document',
     dansJours: 'dans {n} jours', depuisJours: 'depuis {n} jours', aujourdhui: 'aujourd’hui', estimee: 'estimée', aucunPlan: 'Aucun plan d’entretien',
-    auKm: 'à {km} km', aucunChauffeur: 'Aucun chauffeur', aucuneDonnee: '—',
+    auKm: 'à {km} km', aucunChauffeur: 'Aucun chauffeur', aucuneDonnee: '—', chassis: 'Numéro de châssis', mode: 'Mode de détention',
+  },
+  documents: {
+    titre: 'Documents et échéances', type: 'Document', du: 'Du', au: 'Au', cout: 'Coût', piece: 'Pièce', etat: 'État', courante: 'en vigueur',
+    ancienne: 'ancienne', vide: 'Aucun document enregistré.', reference: 'Référence', organisme: 'Organisme', empreinte: 'sha256 : {court}',
+    deposee: 'déposée par {par} le {date}', precedentes: 'Périodes précédentes ({n})', bloque: 'Le véhicule ne peut pas partir',
+    etats: { valide: 'Valide', proche: 'Expire bientôt', expiree: 'Expirée', absente: 'Absente' }, obligatoire: 'obligatoire',
   },
-  documents: { type: 'Document', du: 'Du', au: 'Au', cout: 'Coût', piece: 'Pièce', etat: 'État', courante: 'en vigueur', ancienne: 'ancienne', vide: 'Aucun document enregistré.' },
   entretiens: {
     plans: 'Plans d’entretien', plan: 'Plan', pas: 'Tous les', prochain: 'Prochain', interventions: 'Interventions', numero: 'N°', nature: 'Nature',
     ouverte: 'Ouverte le', close: 'Close le', atelier: 'Atelier', cout: 'Coût', enCours: 'En cours', vide: 'Aucune intervention.',
-    ou: 'ou', km: '{n} km', jours: '{n} jours',
+    ou: 'ou', km: '{n} km', jours: '{n} jours', tousLes: 'Tous les {pas}', avanceKm: 'Avancement kilométrique', avanceJours: 'Avancement temporel',
+    fait: '{fait} / {pas}', prochaine: 'Prochaine : {date}', aKm: 'à {km} km', rythme: 'au rythme de {n} km/j', auPlusTard: 'au plus tard le {date}',
+    kmIntervention: 'Kilométrage', statut: 'Statut', fermee: 'Close', etats: { proche: 'Proche', du: 'Dû', depasse: 'Dépassé' },
   },
-  affectations: { chauffeur: 'Chauffeur', du: 'Du', au: 'Au', par: 'Affecté par', enCours: 'en cours', vide: 'Aucune affectation.' },
-  historique: { le: 'Le', de: 'De', vers: 'Vers', motif: 'Motif', par: 'Par', inscrit: 'Inscription au parc', vide: 'Aucun changement de statut.' },
+  affectations: {
+    chauffeur: 'Chauffeur', du: 'Du', au: 'Au', par: 'Affecté par', enCours: 'en cours', vide: 'Aucune affectation.', actuel: 'Chauffeur actuel',
+    depuis: 'Depuis le {date}', parLe: 'Affecté par {par}', frise: 'Historique des affectations', choisir: 'Sélectionner un chauffeur du bureau',
+    categorie: 'Catégorie requise pour ce véhicule', nom: 'Nom', telephone: 'Téléphone', permis: 'Permis', permisDe: 'Permis {p}',
+    disponibilite: 'Disponibilité', libre: 'Libre', ceVehicule: 'Ce véhicule', conduit: 'Conduit {plaque}', nonHabilite: 'non habilité',
+    aucunCandidat: 'Aucun chauffeur à proposer.',
+  },
+  historique: { le: 'Le', de: 'De', vers: 'Vers', motif: 'Motif', par: 'Par', inscrit: 'Inscription au parc', modification: 'Modification : {champs}', vide: 'Aucun changement de statut.' },
   alertes: { titre: 'Alertes et échéances', voirTout: 'Voir tout', vide: 'Aucune échéance dans les {n} jours.', entretien: 'Entretien périodique' },
   graphe: {
     types: 'Répartition des véhicules par type', vehicules: 'véhicules', statuts: 'Statut des véhicules', km: 'Évolution du kilométrage',
@@ -53,6 +72,46 @@ export const TEXTES = Object.freeze({
     top: 'Top 5 des véhicules par activité', kmMois: 'Km (30 j)', tournees: 'Tournées', colis: 'Colis', total: 'Total',
   },
   rapides: { titre: 'Actions rapides' },
+  pleins: {
+    courbe: 'Évolution du kilométrage', kmReleve: 'Kilométrage relevé', au: 'au {date}', rythme: 'Rythme : {n} km/j sur 90 jours',
+    releves: 'Relevés du compteur', date: 'Date', km: 'Kilométrage', source: 'Source', saisiPar: 'Saisi par', commentaire: 'Commentaire',
+    correction: 'Correction : {motif}', pleins: 'Pleins de carburant', litres: 'Litres', montant: 'Montant', complet: 'Plein complet',
+    conso: 'Conso. mesurée', consoMoyenne: 'Consommation moyenne', oui: 'Oui', non: 'Non', aucunReleve: 'Aucun relevé.', aucunPlein: 'Aucun plein.',
+  },
+  couts: {
+    periode: 'Période d’analyse', mois: 'Ce mois-ci', trimestre: '3 derniers mois', annee: 'Cette année', perso: 'Personnalisée', du: 'Du', au: 'Au',
+    appliquer: 'Appliquer', carburant: 'Carburant', entretien: 'Entretien', echeances: 'Assurance et documents (prorata)', total: 'Total',
+    nonComptes: 'Non comptés : {postes}', km: 'Kilomètres parcourus', parKm: 'Coût au kilomètre', parMois: 'Coûts par mois et par poste',
+    parc: 'Coût au km par véhicule', parcSous: '(période sélectionnée)', vehicule: 'Véhicule',
+  },
+  formulaire: {
+    requis: 'Ce champ est requis', nombre: 'Nombre attendu', date: 'Date attendue (JJ/MM/AAAA)', choix: 'Choix invalide',
+    identification: 'Identification', rattachement: 'Rattachement', compteur: 'Compteur', documents: 'Documents',
+    nouveau: 'Nouveau véhicule', nouveauSous: 'Enregistrer un nouveau véhicule dans la flotte.', modifier: 'Modifier le véhicule {plaque}',
+    modifierSous: 'Le code, le type et le statut ne se modifient pas ici.', inscrire: 'Inscrire le véhicule',
+    immatriculation: 'Plaque d’immatriculation', type: 'Type de véhicule', choisir: '— Choisir —', categorie: 'Catégorie de permis exigée',
+    categorieAide: 'Tirée du type de véhicule : {liste}', region: 'Région', station: 'Station principale', mode: 'Mode de détention',
+    kmDepart: 'Kilométrage de départ', kmDepartAide: 'Relevé initial lors de la mise en service du véhicule.', document: 'Type de document',
+    attribut: { chargeUtileKg: 'Capacité de charge (kg)', volumeM3: 'Volume utile (m³)' }, dernierReleve: 'Dernier relevé : {km} km',
+    statutTitre: '{transition} : {plaque}', motif: 'Motif', motifAide: 'Le motif est écrit tel quel dans l’historique du véhicule.',
+    definitif: 'Cette action est définitive', definitifAide: 'Le véhicule sort du parc ; son carnet reste consultable.',
+    statutActuel: 'Statut actuel', reformerQuestion: 'Réformer ce véhicule ?',
+    plan: 'Planifier un entretien', intervention: 'Ouvrir une intervention', cloture: 'Clore l’intervention', plein: 'Saisir un plein',
+    releve: 'Relever le compteur', echeance: 'Renouveler un document',
+    champ: {
+      libelle: 'Libellé', tousLesKm: 'Tous les (km)', tousLesJours: 'Tous les (jours)', toleranceKm: 'Tolérance (km)', toleranceJours: 'Tolérance (jours)',
+      nature: 'Nature', plan: 'Plan d’entretien', prestataire: 'Atelier', description: 'Description', km: 'Kilométrage', cout: 'Coût', le: 'Date',
+      litres: 'Litres', montant: 'Montant', complet: 'Plein complet', piece: 'Pièce jointe', ouverteLe: 'Ouverte le', ticket: 'Photo du ticket', type: 'Document',
+      debut: 'Du', fin: 'Au', reference: 'Référence', organisme: 'Organisme', aucunPlan: '— Aucun —',
+    },
+  },
+  monVehicule: { titre: 'Mon véhicule', aucun: 'Aucun véhicule ne vous est affecté.', prochains: 'Prochains entretiens', documents: 'Documents' },
+  tournee: {
+    refus: 'Véhicule refusé par le serveur', refusSous: 'Ce véhicule ne peut pas partir aujourd’hui, avec ce chauffeur.', carnet: 'Ouvrir le carnet du véhicule',
+    motifs: '{n} motifs bloquants', motif: '1 motif bloquant', disponibles: 'Autres véhicules disponibles', disponiblesSous: 'Seuls les véhicules pouvant partir sont proposés.',
+    aucunDisponible: 'Aucun autre véhicule ne peut partir.', vehicule: 'Véhicule',
+  },
+  message: { erreur: 'L’opération est refusée' },
 });
 
 const lire = (o, cle) => cle.split('.').reduce((x, k) => (x && typeof x === 'object' ? x[k] : undefined), o);

package/src/vue.js

@@ -4,7 +4,7 @@
 // Lecture seule. Toute RÈGLE (expiré, prochain entretien, peut partir) vient du moteur ; ici, seulement des agrégats
 // d'affichage : comptes, parts, variations sur la période, km par mois, top 5. Les vue-modèles portent des CODES :
 // la langue n'intervient qu'au rendu.
-import { regles as R } from '@mostajs/flotte';
+import { regles as R, transitionsDepuis } from '@mostajs/flotte';
 
 const STATUTS_PARC = ['en_service', 'a_l_atelier', 'immobilise'];
 const jourDe = (d) => (typeof d === 'string' ? d : d.toISOString().slice(0, 10));
@@ -19,7 +19,8 @@ const nomDe = (conducteurs, id) => {
 function statutAu(v, jour) {
   if (v.inscritLe && v.inscritLe > jour) return null;
   let s = 'en_service';
-  for (const pas of v.historique || []) if (pas.le <= jour) s = pas.vers;
+  // Une entrée sans `vers` (modification descriptive, flotte ≥ 0.4.0) ne change pas le statut.
+  for (const pas of v.historique || []) if (pas.vers && pas.le <= jour) s = pas.vers;
   return s;
 }
 /** Une échéance déclarée a-t-elle expiré à `jour` ? On lit celle qui faisait foi à cette date. */
@@ -83,6 +84,7 @@ export async function construireTableau(flotte, opts = {}) {
     chauffeurs: { n: chauffeurs, variation: variation(chauffeurs, chauffeurs0, true) },
     enService: { n: parStatut('en_service'), part: pct(parStatut('en_service'), n), variation: variation(parStatut('en_service'), parStatut0('en_service'), true) },
     enMaintenance: { n: parStatut('a_l_atelier'), part: pct(parStatut('a_l_atelier'), n), variation: variation(parStatut('a_l_atelier'), parStatut0('a_l_atelier'), false) },
+    horsService: { n: parStatut('immobilise'), part: pct(parStatut('immobilise'), n), variation: variation(parStatut('immobilise'), parStatut0('immobilise'), false) },
     documentsExpires: { n: expires, part: pct(expires, n), variation: variation(expires, compte(passe, ({ x }) => expireeAu(x.echeances, avant)), false) },
   };
 
@@ -140,48 +142,161 @@ export async function construireTableau(flotte, opts = {}) {
   const choisi = filtres.v && lus.some((x) => x.v.id === filtres.v) ? filtres.v : liste.lignes[0]?.id;
   const fiche = choisi ? await construireFiche(flotte, choisi, { ...opts, date: jour, onglet: filtres.onglet }) : null;
 
+  // Les puces de statut (16.29) : l'effectif de chaque statut dans le périmètre, réformés compris.
+  const puces = { tous: n, ...Object.fromEntries(STATUTS_PARC.map((st) => [st, parStatut(st)])), reforme: compte(lus, (x) => x.v.statut === 'reforme') };
+
   return {
-    date: jour, periodeJours, filtres, indicateurs, liste,
+    date: jour, periodeJours, filtres, indicateurs, puces, liste,
     options: { types: Object.keys(declarations.types || {}), statuts: [...STATUTS_PARC, 'reforme'], regions: [...new Set(Object.values(sites).map((s) => s.region).filter(Boolean))].sort() },
     alertes: { lignes: alertes.slice(0, alertesMax), total: alertes.length, jours: alerteJours },
     repartition, statuts, km, parSite, top: top.slice(0, 5), avecActivite: typeof activite === 'function', fiche,
   };
 }
 
-export const ONGLETS = Object.freeze(['informations', 'documents', 'entretiens', 'affectations', 'historique']);
+export const ONGLETS = Object.freeze(['informations', 'documents', 'entretiens', 'affectations', 'pleins', 'couts', 'historique']);
+
+const premierDuMois = (jour, k = 0) => { const d = new Date(`${jour.slice(0, 7)}-01T00:00:00Z`); d.setUTCMonth(d.getUTCMonth() - k); return d.toISOString().slice(0, 10); };
+const finDuMois = (m, jour) => { const d = new Date(`${m}-01T00:00:00Z`); d.setUTCMonth(d.getUTCMonth() + 1); d.setUTCDate(0); const f = d.toISOString().slice(0, 10); return f < jour ? f : jour; };
+/** Les `n` derniers mois (AAAA-MM), le mois de `jour` en dernier. */
+const derniersMois = (jour, n) => Array.from({ length: n }, (_, i) => premierDuMois(jour, n - 1 - i).slice(0, 7));
+const parDateDesc = (cle) => (a, b) => (a[cle] < b[cle] ? 1 : a[cle] > b[cle] ? -1 : 0);
+
+/**
+ * La période d'analyse des coûts (16.38) : 'mois' (par défaut), 'trimestre' (les 3 derniers mois), 'annee', ou un
+ * objet { du, au } (la requête GET elle-même convient : { periode, du, au }). Une période à l'envers vaut le mois.
+ */
+export function periodeDe(p, jour) {
+  if (p && typeof p === 'object') {
+    if (R.estJour(p.du) && R.estJour(p.au) && p.du <= p.au) return { periode: 'perso', du: p.du, au: p.au };
+    p = p.periode;
+  }
+  if (p === 'trimestre') return { periode: 'trimestre', du: premierDuMois(jour, 2), au: jour };
+  if (p === 'annee') return { periode: 'annee', du: `${jour.slice(0, 4)}-01-01`, au: jour };
+  return { periode: 'mois', du: premierDuMois(jour), au: jour };
+}
 
 /**
  * La fiche d'un véhicule : l'en-tête et l'onglet Informations toujours ; le contenu de l'onglet demandé.
- * opts : { declarations, date?, sites?, conducteurs?, onglet? }
+ * opts : { declarations, date?, sites?, conducteurs?, agents? (id → { nom }), onglet?, chauffeurs? ([{ id, nom,
+ *          telephone, permis, habilite? }] du bureau, pour « Affecter »), periode? (onglet Coûts), perimetre? }
  */
 export async function construireFiche(flotte, id, opts = {}) {
-  const { declarations = {}, sites = {}, conducteurs = {} } = opts;
+  const { declarations = {}, sites = {}, conducteurs = {}, agents = {}, perimetre = null } = opts;
   const jour = jourDe(opts.date ?? new Date());
   const onglet = ONGLETS.includes(opts.onglet) ? opts.onglet : 'informations';
   const v = await flotte.lire(id);
   const x = await lireVehicule(flotte, v, jour);
+  const agent = (a) => (a ? nomDe(agents, a).nom : null);
   const alerteJours = declarations.alerteJours ?? 30;
   const echeances = Object.entries(declarations.echeances || {}).map(([type, d]) => {
     const courante = R.echeanceCourante(x.echeances.filter((e) => e.debut <= jour), type) || R.echeanceCourante(x.echeances, type);
     const n = courante ? R.jours(jour, courante.fin) : null;
-    return { type, obligatoire: Boolean(d.obligatoire), courante, n, etat: !courante ? 'absente' : n < 0 ? 'expiree' : n < alerteJours ? 'proche' : 'valide' };
+    return { type, obligatoire: Boolean(d.obligatoire), bloquante: Boolean(d.bloquante), courante, n, etat: !courante ? 'absente' : n < 0 ? 'expiree' : n < alerteJours ? 'proche' : 'valide' };
   });
   const fiche = {
     date: jour, onglet, vehicule: v, plaque: v.immatriculation, site: v.site, siteLibelle: sites[v.site]?.libelle ?? v.site ?? null, region: sites[v.site]?.region ?? null,
     capacite: { kg: v.attributs?.chargeUtileKg ?? null, m3: v.attributs?.volumeM3 ?? null },
     conducteur: nomDe(conducteurs, conducteurAu(x.affectations, jour)), km: x.km, depart: x.depart,
     consommation: (await flotte.consommation(id)).lPour100Km, prochain: await flotte.prochainEntretien(id, { date: jour }), echeances,
-    miseEnService: v.acquisition?.le ?? v.inscritLe ?? null,
+    miseEnService: v.miseEnService ?? v.acquisition?.le ?? v.inscritLe ?? null,
+    // 0.2.0 : les changements de statut permis (lus dans le moteur), la catégorie de permis du type, les plans.
+    transitions: transitionsDepuis(v.statut), categoriePermis: declarations.types?.[v.type]?.categoriePermis ?? null,
+    plans: (await flotte.plans(id)).map((p) => ({ id: p.id, libelle: p.libelle })),
   };
   if (onglet === 'documents') {
-    fiche.documents = [...x.echeances].sort((a, b) => (a.type === b.type ? (a.debut < b.debut ? 1 : -1) : a.type < b.type ? -1 : 1))
-      .map((e) => ({ ...e, courante: echeances.find((c) => c.type === e.type)?.courante?.id === e.id }));
+    // Une carte par échéance déclarée (16.33) : la période qui fait foi, et les autres, de la plus récente à la plus ancienne.
+    const avecPar = (e) => (e ? { ...e, par: agent(e.piece?.deposePar ?? e.poseePar), deposeLe: e.piece?.deposeLe ?? e.poseeLe ?? null } : null);
+    fiche.documents = echeances.map((e) => ({
+      ...e, courante: avecPar(e.courante),
+      anciennes: x.echeances.filter((y) => y.type === e.type && y.id !== e.courante?.id).sort(parDateDesc('debut')).map(avecPar),
+    }));
   }
   if (onglet === 'entretiens') {
     const [prochains, plans, interventions] = await Promise.all([flotte.prochainsEntretiens(id, { date: jour }), flotte.plans(id), flotte.interventions(id)]);
-    fiche.entretiens = { prochains: prochains.map((p) => ({ ...p, pas: plans.find((q) => q.id === p.plan) })), interventions: [...interventions].sort((a, b) => (a.ouverteLe < b.ouverteLe ? 1 : -1)) };
+    const jauge = (fait, pas) => ({ fait, pas, pct: Math.max(0, Math.min(100, Math.round((100 * fait) / pas))) });
+    fiche.entretiens = {
+      rythme: R.kmParJour(x.releves, jour),
+      plans: prochains.map((p) => {
+        const q = plans.find((y) => y.id === p.plan) || {};
+        return {
+          plan: p.plan, libelle: p.libelle, etat: p.etat, n: p.n ?? null, unite: p.unite ?? null, tousLesKm: q.tousLesKm ?? null, tousLesJours: q.tousLesJours ?? null,
+          km: q.tousLesKm > 0 && x.km !== null ? { ...jauge(x.km - (q.dernierKm || 0), q.tousLesKm), echeance: p.km?.echeance ?? null } : null,
+          jours: q.tousLesJours > 0 && q.dernierLe ? { ...jauge(R.jours(q.dernierLe, jour), q.tousLesJours), echeance: p.jours?.echeance ?? null } : null,
+          le: p.le, dans: p.dans, estime: p.estime, auPlusTard: p.estime ? (p.jours?.echeance ?? null) : null,
+        };
+      }),
+      interventions: [...interventions].sort(parDateDesc('ouverteLe')).map((i) => ({ ...i, close: Boolean(i.closeLe) })),
+    };
+  }
+  if (onglet === 'affectations') {
+    const permisDe = (c) => (Array.isArray(opts.chauffeurs) ? opts.chauffeurs.find((y) => y.id === c)?.permis ?? null : null);
+    const frise = [...x.affectations].reverse().map((a) => ({ ...a, conducteur: nomDe(conducteurs, a.conducteur), permis: permisDe(a.conducteur), par: agent(a.parAgent) }));
+    // La disponibilité de chaque chauffeur proposé est LUE dans le moteur (vehiculeDe) ; le permis et
+    // l'habilitation viennent de l'application, qui seule les connaît.
+    const candidats = await Promise.all((Array.isArray(opts.chauffeurs) ? opts.chauffeurs : []).map(async (c) => {
+      const a = await flotte.vehiculeDe(c.id);
+      if (!a) return { ...c, disponibilite: 'libre' };
+      if (a.vehicule === id) return { ...c, disponibilite: 'ce_vehicule' };
+      return { ...c, disponibilite: 'occupe', plaque: (await flotte.lire(a.vehicule)).immatriculation };
+    }));
+    fiche.affectations = { courante: frise.find((a) => !a.au) ?? null, frise, candidats, categorie: fiche.categoriePermis };
+  }
+  if (onglet === 'pleins') {
+    const pleins = await flotte.pleins(id);
+    const conso = R.consommation(pleins);
+    const mois = derniersMois(jour, 7);
+    fiche.pleins = {
+      km: x.km, rythme: R.kmParJour(x.releves, jour), consommation: conso.lPour100Km,
+      courbe: { mois, valeurs: mois.map((m) => R.dernierReleve(x.releves, finDuMois(m, jour))?.km ?? null) },
+      releves: [...x.releves].reverse().map((r) => ({ ...r, par: agent(r.saisiPar) })),
+      pleins: [...pleins].reverse().map((p) => ({ ...p, par: agent(p.saisiPar), conso: (p.complet && conso.mesures.find((m) => m.au === p.km)?.lPour100Km) || null })),
+    };
+  }
+  if (onglet === 'couts') {
+    const P = periodeDe(opts.periode, jour);
+    const parMois = await Promise.all(derniersMois(jour, 6).map(async (m) => {
+      const c = await flotte.cout(id, { du: `${m}-01`, au: finDuMois(m, jour) });
+      return { mois: m, carburant: c.carburant, entretien: c.entretien, echeances: c.echeances, total: c.total };
+    }));
+    const vs = (await flotte.vehicules()).filter((w) => !perimetre || perimetre.includes(w.site));
+    const parc = await Promise.all(vs.map(async (w) => {
+      const c = await flotte.cout(w.id, { du: P.du, au: P.au });
+      return { vehicule: w.id, code: w.code, plaque: w.immatriculation, type: w.type, km: c.km, carburant: c.carburant, entretien: c.entretien, echeances: c.echeances, total: c.total, parKm: c.parKm, courant: w.id === id };
+    }));
+    parc.sort((a, b) => (a.parKm === b.parKm ? (a.code < b.code ? -1 : 1) : a.parKm === null ? 1 : b.parKm === null ? -1 : b.parKm - a.parKm));
+    const cout = await flotte.cout(id, { du: P.du, au: P.au });
+    fiche.couts = { ...P, cout, mois: parMois, parc, nonComptes: cout.nonComptes };
   }
-  if (onglet === 'affectations') fiche.affectations = [...x.affectations].reverse().map((a) => ({ ...a, conducteur: nomDe(conducteurs, a.conducteur) }));
   if (onglet === 'historique') fiche.historique = [...(v.historique || [])].reverse();
   return fiche;
 }
+
+/**
+ * « Mon véhicule » du livreur (16.40) : le véhicule que le conducteur tient (vehiculeDe), sa fiche, ses prochains
+ * entretiens et le rythme. { vehicule: null } s'il n'en tient aucun.
+ */
+export async function construireMonVehicule(flotte, conducteur, opts = {}) {
+  const a = await flotte.vehiculeDe(conducteur);
+  if (!a) return { conducteur, vehicule: null, prochains: [], rythme: null };
+  const fiche = await construireFiche(flotte, a.vehicule, { ...opts, onglet: 'informations' });
+  const [prochains, releves] = await Promise.all([flotte.prochainsEntretiens(a.vehicule, { date: fiche.date }), flotte.releves(a.vehicule)]);
+  return { conducteur, vehicule: fiche, prochains, rythme: R.kmParJour(releves, fiche.date) };
+}
+
+/**
+ * L'aptitude de chaque véhicule du périmètre pour une tournée (16.41) : peutPartir du moteur, avec le conducteur
+ * s'il est choisi. Les aptes d'abord, puis par code. Les réformés n'y sont pas.
+ * opts : { date?, conducteur?, perimetre?, sites? }
+ */
+export async function construireAptitudes(flotte, opts = {}) {
+  const { sites = {}, perimetre = null, conducteur } = opts;
+  const jour = jourDe(opts.date ?? new Date());
+  const vs = (await flotte.vehicules()).filter((w) => !perimetre || perimetre.includes(w.site));
+  const lignes = await Promise.all(vs.map(async (w) => ({
+    id: w.id, code: w.code, plaque: w.immatriculation, type: w.type, site: w.site, region: sites[w.site]?.region ?? null,
+    capacite: { kg: w.attributs?.chargeUtileKg ?? null, m3: w.attributs?.volumeM3 ?? null },
+    km: R.dernierReleve(await flotte.releves(w.id), jour)?.km ?? null,
+    depart: await flotte.peutPartir(w.id, { date: jour, ...(conducteur ? { conducteur } : {}) }),
+  })));
+  return lignes.sort((a, b) => (a.depart.ok === b.depart.ok ? (a.code < b.code ? -1 : 1) : a.depart.ok ? -1 : 1));
+}