@open3cl/engine 1.7.1 → 1.7.2

package/13.2_generateur_combustion.js

@@ -4,7 +4,7 @@ import { updateGenerateurBouilleurs } from './13.2_generateur_combustion_bouille
 import { updateGenerateurChaudieres } from './13.2_generateur_combustion_chaudiere.js';
 import { updateGenerateurPacs } from './13.2_generateur_pac.js';
 import getFicheTechnique from './ficheTechnique.js';
-import { evaluate } from 'mathjs';
+import { evaluateFormula as evaluateTvFormula } from './formula.js';
 
 function criterePn(Pn, matcher) {
   let critere_list = tvColumnLines('generateur_combustion', 'critere_pn', matcher);
@@ -38,15 +38,7 @@ const F_tab = {
 };
 
 function evaluateFormula(formulaOrValue, pn, E, F) {
-  const pnVariable = pn / 1000;
-  if (!isNaN(formulaOrValue)) {
-    return Number(formulaOrValue);
-  }
-  const variables = new Map();
-  variables.set('Pn', pnVariable);
-  variables.set('E', E);
-  variables.set('F', F);
-  return evaluate(formulaOrValue, variables);
+  return evaluateTvFormula(formulaOrValue, pn, E, F);
 }
 
 /**

package/3.1_b.js

@@ -1,8 +1,47 @@
 import enums from './enums.js';
 import { tv, requestInput, requestInputID, bug_for_bug_compat } from './utils.js';
 
+const RANGES = [0.25, 0.5, 0.75, 1, 1.25, 2, 2.5, 3, 3.5, 4, 6, 8, 10, 25, 50];
+
+/**
+ * Identifiants de type d'adjacence pour lesquels le ratio aiu/aue est pris en compte.
+ */
+const ADJACENCE_AIU_AUE_IDS = new Set([
+  '8',
+  '9',
+  '11',
+  '12',
+  '13',
+  '14',
+  '15',
+  '16',
+  '17',
+  '18',
+  '19',
+  '21'
+]);
+
+const TYPE_ADJACENCE_IDS = Object.keys(enums.type_adjacence);
+
+/**
+ * Formate une borne du ratio aiu/aue au format des tables de valeurs (`0,25`, `1,00`…).
+ *
+ * `toLocaleString(undefined, { minimumFractionDigits: 2, … })` construisait un
+ * `Intl.NumberFormat` à chaque appel (~29 µs), ce qui représentait l'essentiel du
+ * temps CPU de `b()`. `toFixed(2)` produit exactement les mêmes chaînes pour toutes
+ * les valeurs de `RANGES`, en ~0,2 µs, et sans dépendre de la locale de la machine —
+ * le `.replace('.', ',')` qui suivait était d'ailleurs un no-op sur une machine en
+ * locale française et une vraie conversion ailleurs.
+ *
+ * @param borne {number}
+ * @returns {string}
+ */
+function formatBorneAiuAue(borne) {
+  return borne.toFixed(2).replace('.', ',');
+}
+
 export function findRanges(inputNumber) {
-  const ranges = [0.25, 0.5, 0.75, 1, 1.25, 2, 2.5, 3, 3.5, 4, 6, 8, 10, 25, 50];
+  const ranges = RANGES;
   const result = [];
 
   if (inputNumber < ranges[0]) {
@@ -28,7 +67,7 @@ export function findRanges(inputNumber) {
 export default function b(di, de, du, zc_id) {
   const zc = enums.zone_climatique[zc_id].slice(0, 2);
 
-  du.enum_type_adjacence_id = Object.keys(enums.type_adjacence);
+  du.enum_type_adjacence_id = TYPE_ADJACENCE_IDS;
   const matcher = {
     enum_type_adjacence_id: requestInputID(de, du, 'type_adjacence')
   };
@@ -37,11 +76,7 @@ export default function b(di, de, du, zc_id) {
     matcher.zone_climatique = zc;
     matcher.enum_cfg_isolation_lnc_id = requestInputID(de, du, 'cfg_isolation_lnc');
     /* du.enum_cfg_isolation_lnc_id = ['6', '7', '8', '9', '10', '11'] */
-  } else if (
-    ['8', '9', '11', '12', '13', '14', '15', '16', '17', '18', '19', '21'].includes(
-      de.enum_type_adjacence_id.toString()
-    )
-  ) {
+  } else if (ADJACENCE_AIU_AUE_IDS.has(de.enum_type_adjacence_id.toString())) {
     if (de.surface_aue === 0) {
       // cf page 10
       // NOTE: bizarre de regarder aue pour un local chauffé non accessible
@@ -96,36 +131,13 @@ export default function b(di, de, du, zc_id) {
           // Si le rapport des surfaces est égale à la borne inférieure, utilisation de la borne supérieure
           // et prise en compte de l'égalité
           if (ranges[0] === de.surface_aiu / de.surface_aue) {
-            matcher.aiu_aue_max =
-              '≤ ' +
-              ranges[0]
-                .toLocaleString(undefined, {
-                  minimumFractionDigits: 2,
-                  maximumFractionDigits: 2,
-                  useGrouping: false
-                })
-                .replace('.', ',');
+            matcher.aiu_aue_max = '≤ ' + formatBorneAiuAue(ranges[0]);
           } else {
-            matcher.aiu_aue_min =
-              ranges[0]
-                .toLocaleString(undefined, {
-                  minimumFractionDigits: 2,
-                  maximumFractionDigits: 2,
-                  useGrouping: false
-                })
-                .replace('.', ',') + ' <';
+            matcher.aiu_aue_min = formatBorneAiuAue(ranges[0]) + ' <';
           }
         }
         if (ranges[1]) {
-          matcher.aiu_aue_max =
-            '≤ ' +
-            ranges[1]
-              .toLocaleString(undefined, {
-                minimumFractionDigits: 2,
-                maximumFractionDigits: 2,
-                useGrouping: false
-              })
-              .replace('.', ',');
+          matcher.aiu_aue_max = '≤ ' + formatBorneAiuAue(ranges[1]);
         }
       }
     }

package/3.3_baie_vitree.js

@@ -23,6 +23,37 @@ function tv_ug(di, de, du) {
   }
 }
 
+/**
+ * Valeurs de Ug tabulées dans `uw`, indexées par (type de baie, matériau de menuiserie).
+ *
+ * Le scan des 723 lignes de `tvs.uw` — avec un `split('|')` par ligne — était refait
+ * pour chaque baie vitrée de chaque DPE, alors que la table est statique.
+ *
+ * Le tableau est partagé et `getRange()` le trie sur place : le tri par défaut de
+ * `Array#sort` étant déterministe, la première mise en cache le laisse trié et les
+ * appels suivants produisent exactement le même résultat qu'avec un tableau reconstruit.
+ */
+const uwUgValuesCache = new Map();
+
+function uwUgValues(enum_type_baie_id, enum_type_materiaux_menuiserie_id) {
+  const cacheKey = `${enum_type_baie_id}
${enum_type_materiaux_menuiserie_id}`;
+  let values = uwUgValuesCache.get(cacheKey);
+  if (values === undefined) {
+    values = tvs.uw
+      .filter((row) => {
+        return (
+          row.enum_type_baie_id.split('|').includes(enum_type_baie_id) &&
+          row.enum_type_materiaux_menuiserie_id
+            .split('|')
+            .includes(enum_type_materiaux_menuiserie_id)
+        );
+      })
+      .map((row) => parseFloat(row.ug));
+    uwUgValuesCache.set(cacheKey, values);
+  }
+  return values;
+}
+
 function tv_uw(di, de) {
   const enum_type_baie_id = de.enum_type_baie_id;
   const matcher = { enum_type_baie_id };
@@ -46,16 +77,7 @@ function tv_uw(di, de) {
     matcher.enum_type_materiaux_menuiserie_id = enum_type_materiaux_menuiserie_id;
 
     // Récupération de toutes les valeurs de Ug présentes dans les tables Uw pour le type de baie et matériaux de la baie vitrée
-    const ugValues = tvs.uw
-      .filter((row) => {
-        return (
-          row.enum_type_baie_id.split('|').includes(enum_type_baie_id) &&
-          row.enum_type_materiaux_menuiserie_id
-            .split('|')
-            .includes(enum_type_materiaux_menuiserie_id)
-        );
-      })
-      .map((row) => parseFloat(row.ug));
+    const ugValues = uwUgValues(enum_type_baie_id, enum_type_materiaux_menuiserie_id);
 
     /**
      * 3.3.2 Coefficients Uw des fenêtres / portes-fenêtres

package/3.4_pont_thermique.js

@@ -1,6 +1,6 @@
 import enums from './enums.js';
 import { isNil } from 'lodash-es';
-import { tv, requestInput, compareReferences, bug_for_bug_compat } from './utils.js';
+import { tv, requestInput, cleanReference, bug_for_bug_compat } from './utils.js';
 
 function defaultValue(type_liaison, pt_di, de) {
   if (pt_di.k === 0) {
@@ -115,10 +115,20 @@ function tv_k(pt_di, di, de, du, pc_id, logement) {
     }
   }
 
+  /**
+   * Références du pont thermique nettoyées une seule fois : elles sont confrontées à toutes les
+   * parois de plusieurs listes ci-dessous, et `compareReferences` les renettoyait à chaque
+   * comparaison. Les affectations de `de.reference_1` / `de.reference_2` ont toutes eu lieu
+   * au-dessus, dans le bloc de récupération par description.
+   */
+  const cleaned_reference_1 = cleanReference(de.reference_1);
+  const cleaned_reference_2 = cleanReference(de.reference_2);
+
   let mur = mur_list.find((mur, murIndex) => {
+    const cleaned_mur_reference = cleanReference(mur.donnee_entree.reference);
     if (
-      compareReferences(mur.donnee_entree.reference, de.reference_1) ||
-      compareReferences(mur.donnee_entree.reference, de.reference_2)
+      cleaned_mur_reference === cleaned_reference_1 ||
+      cleaned_mur_reference === cleaned_reference_2
     ) {
       return true;
     }
@@ -190,11 +200,10 @@ function tv_k(pt_di, di, de, du, pc_id, logement) {
     case 'plancher bas / mur':
     case 'plancher haut lourd / mur': {
       const plancher_list = ph_list.concat(pb_list);
-      const plancher = plancher_list.find(
-        (plancher) =>
-          compareReferences(plancher.donnee_entree.reference, de.reference_1) ||
-          compareReferences(plancher.donnee_entree.reference, de.reference_2)
-      );
+      const plancher = plancher_list.find((plancher) => {
+        const cleaned = cleanReference(plancher.donnee_entree.reference);
+        return cleaned === cleaned_reference_1 || cleaned === cleaned_reference_2;
+      });
       if (!plancher) {
         di.k = defaultValue(type_liaison, pt_di, de);
         console.error(
@@ -331,11 +340,10 @@ function tv_k(pt_di, di, de, du, pc_id, logement) {
       }
 
       const menuiserie_list = bv_list.concat(porte_list);
-      const menuiserie = menuiserie_list.find(
-        (men) =>
-          compareReferences(men.donnee_entree.reference, de.reference_1) ||
-          compareReferences(men.donnee_entree.reference, de.reference_2)
-      );
+      const menuiserie = menuiserie_list.find((men) => {
+        const cleaned = cleanReference(men.donnee_entree.reference);
+        return cleaned === cleaned_reference_1 || cleaned === cleaned_reference_2;
+      });
       if (!menuiserie) {
         di.k = defaultValue(type_liaison, pt_di, de);
         console.error(

package/3.4_pont_thermique.spec.js

@@ -30,7 +30,7 @@ vi.mock('./utils.js', () => ({
   set_bug_for_bug_compat: vi.fn(),
   tv: vi.fn(),
   requestInput: (de, du, field) => de[field],
-  compareReferences: (a, b) => a === b,
+  cleanReference: (reference) => reference,
   get bug_for_bug_compat() {
     return state.bug;
   }

package/README.md

@@ -385,7 +385,7 @@ Ces résultats sont **générés automatiquement** à la fin de `npm run test:co
 
 <!-- CORPUS:START -->
 
-> **Version `1.6.2`** · branche `main` · généré le 2026-09-11
+> **Version `1.6.2`** · branche `main` · généré le 2026-09-18
 > Seuil de tolérance **5%**
 
 <table>
@@ -411,6 +411,36 @@ Ces résultats sont **générés automatiquement** à la fin de `npm run test:co
 
 <sub>🟢 ≥ 85 % · 🟡 ≥ 60 % · 🔴 < 60 %</sub>
 
+#### Temps d’exécution
+
+> Durée de l’appel à `calcul_3cl` par DPE, sur 89 956 calculs.
+> La copie défensive de l’entrée et la lecture du fichier sont exclues de la mesure.
+
+<table>
+<tr>
+<td align="center"><strong>5,61 ms</strong><br/><sub>moyenne</sub></td>
+<td align="center"><strong>5,03 ms</strong><br/><sub>médiane</sub></td>
+<td align="center"><strong>0,11 ms</strong><br/><sub>min</sub></td>
+<td align="center"><strong>705,8 ms</strong><br/><sub>max</sub></td>
+</tr>
+</table>
+
+| Corpus                                         | Moyenne | Médiane |     Min |      Max |     p95 |     p99 |
+| :--------------------------------------------- | ------: | ------: | ------: | -------: | ------: | ------: |
+| **Généraliste**                                | 4,50 ms | 4,09 ms | 0,20 ms |  34,8 ms | 8,12 ms | 11,3 ms |
+| **Appartement · chauffage individuel (2025)**  | 3,71 ms | 3,46 ms | 1,32 ms |  26,1 ms | 6,22 ms | 7,99 ms |
+| **Logement individuel (2025)**                 | 5,30 ms | 4,84 ms | 1,52 ms |  42,5 ms | 9,73 ms | 13,2 ms |
+| **Maison individuelle (2025)**                 | 6,54 ms | 6,02 ms | 1,71 ms |  54,5 ms | 11,6 ms | 16,4 ms |
+| **Immeuble · chauffage individuel**            | 7,17 ms | 6,22 ms | 0,11 ms | 137,7 ms | 14,3 ms | 22,3 ms |
+| **Appartement · chauffage collectif (2025)**   | 3,98 ms | 3,76 ms | 1,22 ms |  37,6 ms | 6,35 ms | 8,00 ms |
+| **Immeuble · chauffage collectif**             | 6,40 ms | 5,58 ms | 0,15 ms | 101,0 ms | 12,1 ms | 21,2 ms |
+| **Immeuble · chauffage mixte**                 | 6,01 ms | 5,01 ms | 0,22 ms | 705,8 ms | 12,4 ms | 19,8 ms |
+| **Individuel généré depuis l'immeuble (2026)** | 6,89 ms | 6,27 ms | 1,52 ms |  65,1 ms | 13,0 ms | 19,7 ms |
+
+<sub>La moyenne est tirée vers le haut par les DPE collectifs, dont le coût atteint plusieurs
+dizaines de fois la médiane : c’est la médiane qui décrit le cas courant, et p95/p99 le cas
+défavorable réel.</sub>
+
 <!-- CORPUS:END -->
 
 📈 Historique complet des versions : [docs/CORPUS-HISTORY.md](docs/CORPUS-HISTORY.md)

package/engine.js

@@ -33,7 +33,7 @@ import getFicheTechnique from './ficheTechnique.js';
 import { ProductionENR } from './16.2_production_enr.js';
 import DpeSanitizerService from './dpe-sanitizer.service.js';
 
-const LIB_VERSION = '1.7.1';
+const LIB_VERSION = '1.7.2';
 
 const dpeSanitizerService = new DpeSanitizerService();
 

package/ficheTechnique.js

@@ -1,3 +1,85 @@
+/**
+ * Recherche dans les fiches techniques d'un DPE.
+ *
+ * L'implémentation précédente rebalayait la totalité des fiches à chaque appel, concaténait les
+ * sous-fiches dans un `reduce` (`acc.concat(...)` recopie l'accumulateur à chaque itération) et
+ * remettait en minuscules des valeurs qui ne changent jamais. Le coût par appel croissait en
+ * `fiches^1,3`.
+ *
+ * Sur un DPE de logement individuel, une poignée de fiches : invisible. Sur un DPE collectif,
+ * les fiches suivent les installations — un DPE mesuré comptait 235 fiches et 1597 sous-fiches
+ * pour 73 générateurs — et la fonction représentait alors **54 % du temps de `calcul_3cl`**,
+ * le ramasse-miettes des concaténations comptant pour 10 % de plus.
+ *
+ * Les fiches techniques ne sont jamais modifiées pendant un calcul : elles sont donc indexées
+ * une fois par DPE, par catégorie, avec les minuscules pré-calculées. L'index est mémorisé dans
+ * une `WeakMap` sur le DPE lui-même, donc libéré avec lui — rien à vider, aucune fuite possible
+ * sur un process qui enchaîne les calculs.
+ */
+
+/** @type {WeakMap<object, Map<string, {sousFiches: any[], valeursMinuscules: (string|null)[], champsMinuscules: Map<string, (string|null)[]>}[]>>} */
+const indexParDpe = new WeakMap();
+
+/**
+ * Regroupe les sous-fiches par catégorie, en conservant l'ordre du document — l'ordre détermine
+ * quelle correspondance est retournée en premier.
+ *
+ * @param dpe {FullDpe}
+ */
+function indexerFichesTechniques(dpe) {
+  const parCategorie = new Map();
+
+  /** @type {FicheTechniqueItem[]} */
+  let fichesTechniques = dpe.fiche_technique_collection?.fiche_technique || [];
+  if (!Array.isArray(fichesTechniques)) {
+    fichesTechniques = [fichesTechniques];
+  }
+
+  for (const ficheTechnique of fichesTechniques) {
+    if (!ficheTechnique) continue;
+
+    const categorie = ficheTechnique.enum_categorie_fiche_technique_id;
+    let groupes = parCategorie.get(categorie);
+    if (!groupes) {
+      groupes = [];
+      parCategorie.set(categorie, groupes);
+    }
+
+    const brut = ficheTechnique.sous_fiche_technique_collection?.sous_fiche_technique;
+    const sousFiches = brut === undefined ? [] : Array.isArray(brut) ? brut : [brut];
+
+    groupes.push({
+      sousFiches,
+      // `valeur` en minuscules, calculée une fois ; null quand ce n'est pas une chaîne, auquel
+      // cas la comparaison se fait par identité stricte comme avant.
+      valeursMinuscules: sousFiches.map((sousFiche) =>
+        typeof sousFiche?.valeur === 'string' ? sousFiche.valeur.toLowerCase() : null
+      ),
+      // Les autres champs sont mis en minuscules à la demande : seuls `description` et `valeur`
+      // sont interrogés en pratique, inutile de préparer le reste.
+      champsMinuscules: new Map()
+    });
+  }
+
+  return parCategorie;
+}
+
+/**
+ * @param groupe {{sousFiches: any[], champsMinuscules: Map<string, (string|null)[]>}}
+ * @param field {string}
+ * @returns {(string|null)[]}
+ */
+function champEnMinuscules(groupe, field) {
+  let valeurs = groupe.champsMinuscules.get(field);
+  if (valeurs === undefined) {
+    valeurs = groupe.sousFiches.map((sousFiche) =>
+      sousFiche && sousFiche[field] ? sousFiche[field].toString().toLowerCase() : null
+    );
+    groupe.champsMinuscules.set(field, valeurs);
+  }
+  return valeurs;
+}
+
 /**
  * Retourne si elle existe la fiche technique contenant le texte description et
  * présente dans la catégorie de fiches techniques ayant pour catégorie categoryFicheTechiqueId
@@ -15,72 +97,70 @@ export default function getFicheTechnique(
   classifications = [],
   field = 'description'
 ) {
-  /** @type {FicheTechniqueItem[]} */
-  let fichesTechniques = dpe.fiche_technique_collection?.fiche_technique || [];
+  let index = indexParDpe.get(dpe);
+  if (index === undefined) {
+    index = indexerFichesTechniques(dpe);
+    indexParDpe.set(dpe, index);
+  }
 
-  if (!Array.isArray(fichesTechniques)) {
-    fichesTechniques = [fichesTechniques];
+  const groupes = index.get(categoryFicheTechiqueId);
+  if (!groupes) {
+    return null;
   }
 
   classifications = classifications.filter((classification) => classification);
+  const aiguilles = classifications.map((classification) =>
+    classification.toString().toLowerCase()
+  );
+  const descriptionMinuscule = description.toLowerCase();
 
-  fichesTechniques = fichesTechniques
-    .filter((ficheTechnique) => ficheTechnique)
-    .reduce((acc, ficheTechnique) => {
-      if (ficheTechnique.enum_categorie_fiche_technique_id === categoryFicheTechiqueId) {
-        /**
-         * Plusieurs collections de fiches techniques peuvent exister pour la même catégorie (pour 2 systèmes ECS par exemple)
-         * Le champs classification permet de trouver la collection qui convient en filtrant sur une seconde donnée
-         */
-        if (classifications.length) {
-          /** @type {SousFicheTechniqueItem[]} */
-          let sousFichesTechniques =
-            ficheTechnique.sous_fiche_technique_collection.sous_fiche_technique;
-
-          if (!Array.isArray(sousFichesTechniques)) {
-            sousFichesTechniques = [sousFichesTechniques];
-          }
-
-          const allContained = classifications.every((classification) =>
-            sousFichesTechniques.some((ficheTechnique) => {
-              const valeur = ficheTechnique?.valeur;
-
-              if (typeof valeur === 'string') {
-                return (
-                  ficheTechnique.valeur
-                    .toLowerCase()
-                    .indexOf(classification.toString().toLowerCase()) !== -1
-                );
-              }
+  for (const groupe of groupes) {
+    /**
+     * Plusieurs collections de fiches techniques peuvent exister pour la même catégorie (pour 2
+     * systèmes ECS par exemple). Le champ classification permet de trouver la collection qui
+     * convient en filtrant sur une seconde donnée.
+     */
+    if (classifications.length) {
+      let toutesPresentes = true;
 
-              return ficheTechnique.valeur === classification;
-            })
-          );
+      for (let i = 0; i < classifications.length; i++) {
+        const aiguille = aiguilles[i];
+        let presente = false;
 
-          if (!allContained) {
-            return acc;
+        for (let j = 0; j < groupe.sousFiches.length; j++) {
+          const valeurMinuscule = groupe.valeursMinuscules[j];
+          if (valeurMinuscule !== null) {
+            if (valeurMinuscule.indexOf(aiguille) !== -1) {
+              presente = true;
+              break;
+            }
+          } else if (groupe.sousFiches[j].valeur === classifications[i]) {
+            presente = true;
+            break;
           }
         }
 
-        return acc.concat(ficheTechnique.sous_fiche_technique_collection.sous_fiche_technique);
+        if (!presente) {
+          toutesPresentes = false;
+          break;
+        }
       }
-      return acc;
-    }, []);
-
-  if (!fichesTechniques.length) {
-    return null;
-  }
 
-  const firstFiche = fichesTechniques.filter(
-    (ficheTechnique) =>
-      ficheTechnique &&
-      ficheTechnique[field] &&
-      ficheTechnique[field].toString().toLowerCase().indexOf(description.toLowerCase()) !== -1
-  );
+      if (!toutesPresentes) continue;
+    }
 
-  if (!firstFiche.length) {
-    return null;
+    // L'ancienne implémentation aplatissait toutes les catégories correspondantes avant de
+    // filtrer : la première correspondance du tableau aplati est la première correspondance du
+    // premier groupe qui en contient une. Parcourir les groupes dans l'ordre donne le même
+    // résultat, sans construire le tableau intermédiaire.
+    const champs = champEnMinuscules(groupe, field);
+    for (let j = 0; j < groupe.sousFiches.length; j++) {
+      const champ = champs[j];
+      if (champ !== null && champ.indexOf(descriptionMinuscule) !== -1) {
+        return groupe.sousFiches[j];
+      }
+    }
   }
 
-  return firstFiche[0];
+  return null;
 }

package/ficheTechnique.spec.js

@@ -188,21 +188,53 @@ describe('FicheTechnique service tests', () => {
 
     fiche = getFicheTechnique(dpe, '10', 'non existing');
     expect(fiche).toBeNull();
+  });
 
-    dpe.fiche_technique_collection.fiche_technique[0].sous_fiche_technique_collection.sous_fiche_technique =
-      null;
-
-    fiche = getFicheTechnique(dpe, '11', 'non existing');
-    expect(fiche).toBeNull();
-
-    dpe.fiche_technique_collection.fiche_technique[0].sous_fiche_technique_collection = null;
-
-    fiche = getFicheTechnique(dpe, '11', 'non existing');
-    expect(fiche).toBeNull();
-
-    dpe.fiche_technique_collection.fiche_technique = null;
+  /**
+   * Les fiches techniques sont indexées une fois par objet DPE : chaque cas utilise donc un DPE
+   * neuf, muter un DPE déjà interrogé n'aurait aucun effet.
+   */
+  describe('fiches techniques absentes ou incomplètes', () => {
+    const buildDpe = (ficheTechnique) => ({
+      fiche_technique_collection: { fiche_technique: ficheTechnique }
+    });
+
+    test.each([
+      ['sans fiche_technique_collection', {}],
+      ['avec fiche_technique null', buildDpe(null)],
+      ['avec une fiche technique null', buildDpe([null])],
+      [
+        'sans sous_fiche_technique_collection',
+        buildDpe([
+          { enum_categorie_fiche_technique_id: '10', sous_fiche_technique_collection: null }
+        ])
+      ],
+      [
+        'avec des sous-fiches null ou sans description',
+        buildDpe([
+          {
+            enum_categorie_fiche_technique_id: '10',
+            sous_fiche_technique_collection: {
+              sous_fiche_technique: [null, { valeur: 'plusieurs' }]
+            }
+          }
+        ])
+      ]
+    ])('retourne null %s', (_, dpeIncomplet) => {
+      expect(getFicheTechnique(dpeIncomplet, '10', 'exposées')).toBeNull();
+    });
+
+    test('ignore les fiches techniques null au milieu des autres', () => {
+      const fiche = { description: 'Façades exposées: plusieurs', valeur: 'plusieurs' };
+      const dpeAvecTrou = buildDpe([
+        null,
+        {
+          enum_categorie_fiche_technique_id: '10',
+          sous_fiche_technique_collection: { sous_fiche_technique: [fiche] }
+        }
+      ]);
 
-    fiche = getFicheTechnique(dpe, '10', 'non existing');
-    expect(fiche).toBeNull();
+      expect(getFicheTechnique(dpeAvecTrou, '10', 'exposées')).toBe(fiche);
+    });
   });
 });