@open3cl/engine 1.11.1 → 1.11.2

package/11_ecs.spec.js

@@ -13,7 +13,8 @@ vi.mock('./enums.js', () => ({
     type_installation: {
       1: 'installation individuelle',
       2: 'installation collective',
-      3: 'installation collective multi-bâtiment'
+      3: 'installation collective multi-bâtiment',
+      4: 'installation de type inconnu'
     }
   }
 }));
@@ -566,6 +567,21 @@ describe('calc_ecs - rendement de distribution', () => {
     });
   });
 
+  test('type d’installation ni individuelle ni collective : aucun critère de configuration', () => {
+    const de = { enum_type_installation_id: '4' };
+    const ecs = makeEcs(de, [
+      {
+        donnee_entree: { position_volume_chauffe: 1 },
+        donnee_intermediaire: { conso_ecs: 0, conso_ecs_depensier: 0 }
+      }
+    ]);
+    calc_ecs({}, ecs, 100, 200, 1, 'ca1', 'h1a', 'maison', false, null, null, false);
+
+    // Le matcher reste vide : ni configuration_logement ni type_reseau_collectif
+    expect(tv).toHaveBeenCalledWith('rendement_distribution_ecs', {});
+    expect(requestInput).not.toHaveBeenCalled();
+  });
+
   test('aucune ligne forfaitaire trouvée : rendement de distribution non renseigné', () => {
     const errSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
     vi.mocked(tv).mockReturnValue(undefined);

package/13.2_generateur_combustion.spec.js

@@ -28,7 +28,8 @@ vi.mock('./enums.js', () => ({
     type_generateur_ch: {
       89: 'chaudière gaz standard 2001-2015',
       X: 'chaudière fioul',
-      Y: 'chaudière gaz'
+      Y: 'chaudière gaz',
+      Z: 'générateur sans équivalent ECS'
     },
     type_generateur_ecs: {
       50: 'chaudière gaz standard',
@@ -563,6 +564,28 @@ describe('tv_generateur_combustion - génération mixte (checkEcsVsChauffageForM
     errSpy.mockRestore();
   });
 
+  test('type CH sans équivalent ECS : type de générateur ECS conservé sans message d’alignement', () => {
+    state.bug = true;
+    const errSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    tv.mockReturnValue({ ...ROW_DEFAUT });
+    const di = { pn: 20000 };
+    // CH mixte 'Z' : aucun type ECS portant le même libellé -> pas d'alignement possible
+    const de = {
+      enum_type_generateur_ecs_id: 'A',
+      enum_usage_generateur_id: '3',
+      tv_generateur_combustion_id: '42',
+      ratio_virtualisation: 1,
+      presence_ventouse: 0
+    };
+    tv_generateur_combustion(dpeAvecChMixte('Z'), di, de, 'ecs', 200, -9, 1);
+    expect(tv).toHaveBeenCalledWith(
+      'generateur_combustion',
+      expect.objectContaining({ enum_type_generateur_ecs_id: 'A' })
+    );
+    expect(errSpy).not.toHaveBeenCalled();
+    errSpy.mockRestore();
+  });
+
   test('types ECS et CH identiques : type de générateur ECS conservé', () => {
     state.bug = true;
     tv.mockReturnValue({ ...ROW_DEFAUT });

package/13.2_generateur_combustion_bouilleur.spec.js

@@ -58,6 +58,14 @@ describe('updateGenerateurBouilleurs - substitution par une chaudière bois équ
     expect(de.enum_type_generateur_ch_id).toBe(attendu);
   });
 
+  test('année numérique antérieure à 1948 : aucune période correspondante, valeur par défaut conservée', () => {
+    getFicheTechnique.mockReturnValue({ valeur: '1900' });
+    const de = { enum_type_generateur_ch_id: '48' };
+    updateGenerateurBouilleurs({}, de, 'ch');
+    // Aucun seuil atteint : on garde la chaudière bois par défaut 2004-2012 (values[2004])
+    expect(de.enum_type_generateur_ch_id).toBe('58');
+  });
+
   test('type ECS (granulés 115) : utilise la table ECS des chaudières bois', () => {
     getFicheTechnique.mockReturnValue({ valeur: '2016' });
     const de = { enum_type_generateur_ecs_id: '115' };

package/13.2_generateur_combustion_ch.spec.js

@@ -173,6 +173,27 @@ describe('tv_temp_fonc_30_100 - températures de fonctionnement', () => {
     expect(di.temp_fonc_100).toBe(75);
   });
 
+  test('une température à 100 % plus basse issue d’un second émetteur ne remplace pas la valeur retenue', () => {
+    tv.mockImplementation((table, matcher) => {
+      if (table !== 'temp_fonc_100') return null;
+      // Le premier émetteur renvoie 75, le second 60 (plus basse)
+      return matcher.enum_temp_distribution_ch_id === '3'
+        ? { tv_temp_fonc_100_id: 'a', temp_fonc_100: '75' }
+        : { tv_temp_fonc_100_id: 'b', temp_fonc_100: '60' };
+    });
+    const di = {};
+    const de = { enum_type_generateur_ch_id: '89' };
+    tv_temp_fonc_30_100(
+      di,
+      de,
+      {},
+      [emetteur(), emetteur({ enum_temp_distribution_ch_id: '4' })],
+      1975
+    );
+    expect(di.temp_fonc_100).toBe(75);
+    expect(de.tv_temp_fonc_100_id).toBe('a');
+  });
+
   test('aucune ligne forfaitaire trouvée : erreurs signalées pour temp_fonc_30 et temp_fonc_100', () => {
     const errSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
     tv.mockReturnValue(null);
@@ -709,6 +730,26 @@ describe('calc_generateur_combustion_ch - rendement de génération', () => {
     warnSpy.mockRestore();
   });
 
+  test('bug_for_bug_compat : qp0 déjà exprimé en W (>= 1) conservé sans correction', () => {
+    state.bug = true;
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    const di = { pn: 20000, rpn: 0.9, rpint: 0.85, qp0: 200, temp_fonc_30: 40, temp_fonc_100: 70 };
+    const de = {
+      enum_type_generateur_ch_id: '89',
+      enum_type_energie_id: '2',
+      type_energie: 'gaz naturel',
+      presence_regulation_combustion: false,
+      description: 't'
+    };
+    calc_generateur_combustion_ch({}, di, de, { cdimref: 0.8, cdimrefDep: 0.6 });
+    // qp0 >= 1 -> pas de multiplication par 1000, pas d'avertissement
+    expect(di.qp0).toBe(200);
+    expect(warnSpy).not.toHaveBeenCalled();
+    // même résultat que la correction d'un qp0 de 0,2 kW (référence de régression ci-dessus)
+    expect(di.rg).toBeCloseTo(0.8557877790761849, 9);
+    warnSpy.mockRestore();
+  });
+
   test('la présence de régulation modifie le rendement (tf30 vs tf100)', () => {
     const base = () => ({
       pn: 25000,

package/14_generateur_ecs.spec.js

@@ -559,6 +559,23 @@ describe('calc_gen_ecs - consommation par générateur', () => {
     expect(g.donnee_intermediaire.Qgw).toBe(0);
   });
 
+  test('installation collective : volume de la fiche non numérique ignoré, volume saisi conservé', () => {
+    // « ba » (texte avant le premier « l ») n'est pas un nombre -> VsFiche = NaN, rejeté
+    vi.mocked(getFicheTechnique).mockReturnValue({ valeur: 'ballon' });
+    ecs_de.enum_type_installation_id = '2';
+    ecs_de.ratio_virtualisation = 1;
+    const g = gen({
+      type_energie: 'gaz',
+      enum_type_generateur_ecs_id: 'autre',
+      type_stockage_ecs: 'ballon',
+      volume_stockage: 150
+    });
+    calc_gen_ecs({}, g, ecs_di, ecs_de, 0, '1', '1', 'immeuble');
+
+    // Vs = volume saisi (150), identique au cas d'une fiche « 150 L »
+    expect(g.donnee_intermediaire.Qgw).toBeCloseTo(1064620.987190969, 9);
+  });
+
   test('bug_for_bug_compat : volume proratisé recalé sur la description', () => {
     state.bug = true;
     vi.mocked(getVolumeStockageFromDescription).mockReturnValue(100);
@@ -852,6 +869,61 @@ describe('calc_gen_ecs - consommation par générateur', () => {
     expect(g.donnee_entree.enum_type_generateur_ecs_id).toBe('84');
   });
 
+  test('type 84 combustion : ligne combustion sans type ECS, type 84 conservé', () => {
+    vi.mocked(getChaudiereFioulDefautId).mockReturnValue(undefined);
+    vi.mocked(tv).mockReturnValue({ tv_generateur_combustion_id: '42' });
+    const g = gen({
+      type_energie: 'gaz',
+      enum_type_generateur_ecs_id: '84',
+      tv_generateur_combustion_id: '42',
+      enum_methode_saisie_carac_sys_id: '1'
+    });
+    calc_gen_ecs({}, g, ecs_di, ecs_de, 0, '1', '1', 'maison');
+
+    // Aucune liste de types ECS exploitable dans la ligne : pas de redressement
+    expect(g.donnee_entree.enum_type_generateur_ecs_id).toBe('84');
+  });
+
+  test('type 84 sans combustion ni pompe à chaleur : ni calcul SCOP ni redressement du type', () => {
+    const g = gen({
+      type_energie: 'gaz',
+      enum_type_generateur_ecs_id: '84',
+      enum_methode_saisie_carac_sys_id: '1'
+    });
+    calc_gen_ecs({}, g, ecs_di, ecs_de, 0, '1', '1', 'maison');
+
+    expect(scopOrCop).not.toHaveBeenCalled();
+    expect(tv_generateur_combustion).not.toHaveBeenCalled();
+    expect(g.donnee_entree.enum_type_generateur_ecs_id).toBe('84');
+  });
+
+  test('bug_for_bug_compat : qp0 déjà en W (>= 1) conservé sans correction', () => {
+    state.bug = true;
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    vi.mocked(tvColumnIDs).mockImplementation((table) =>
+      table === 'generateur_combustion' ? ['chaud'] : []
+    );
+    vi.mocked(tv_generateur_combustion).mockImplementation((dpe, di) => {
+      di.rpn = 0.9;
+      di.qp0 = 100;
+      di.pn = 20000;
+      di.pveilleuse = 1;
+      di.pveil = 0;
+    });
+    const g = gen({
+      type_energie: 'gaz',
+      enum_type_generateur_ecs_id: 'chaud',
+      enum_methode_saisie_carac_sys_id: '1'
+    });
+    calc_gen_ecs({}, g, ecs_di, ecs_de, 0, '1', '1', 'maison');
+
+    expect(g.donnee_intermediaire.qp0).toBe(100);
+    expect(warnSpy).not.toHaveBeenCalled();
+    // même rendement que pour un qp0 de 0,1 kW corrigé en 100 W (cf. test de correction)
+    expect(g.donnee_intermediaire.rendement_generation).toBeCloseTo(0.3446955189582535, 9);
+    warnSpy.mockRestore();
+  });
+
   test('type 84 pompe à chaleur : déduit via tv_scop_id', () => {
     vi.mocked(scopOrCop).mockImplementation((di) => {
       di.scop = 3;

package/15_conso_aux.spec.js

@@ -355,6 +355,26 @@ describe('conso_aux_distribution_ch - auxiliaires de distribution', () => {
     expect(di.conso_auxiliaire_distribution_ch).toBeCloseTo(372.082418731648, 9);
   });
 
+  test('émetteur hors listes (type 1, « autre ») : perte de charge par défaut deltaPem=35, Fcot=0,802', () => {
+    const conso = (type) => {
+      const em = [
+        {
+          donnee_entree: {
+            enum_type_emission_distribution_id: type,
+            enum_temp_distribution_ch_id: '3'
+          }
+        }
+      ];
+      const di = {};
+      conso_aux_distribution_ch(em, {}, di, {}, 100, 1, 1, '0', 100000);
+      return di.conso_auxiliaire_distribution_ch;
+    };
+    // Type 24 (monotube) : deltaPem=30, même Fcot (0,802) -> seul deltaPem diffère
+    expect(conso('1')).toBeGreaterThan(conso('24'));
+    // Type 10 (radiateurs autres) : deltaPem=10
+    expect(conso('24')).toBeGreaterThan(conso('10'));
+  });
+
   /**
    * Seuls les émetteurs reliés au générateur (même enum_lien_generateur_emetteur_id) dimensionnent
    * son circulateur. Autotest CSTB IC5-0-3 : chaudière (lien 1) sur plancher chauffant + convecteurs

package/3.1_b.spec.js

@@ -365,4 +365,27 @@ describe('b - calcul du coefficient de réduction des déperditions', () => {
     });
     expect(di.b).toBe(0.7);
   });
+
+  test('adjacence hors liste aiu/aue (type 10 absent, type inconnu) : seul le type est apparié', () => {
+    tv.mockReturnValue({ b: '0.5', tv_coef_reduction_deperdition_id: '7' });
+    const di = {};
+    const de = { enum_type_adjacence_id: '1' };
+    b(di, de, {}, 1);
+    expect(tv).toHaveBeenCalledWith(TABLE, { enum_type_adjacence_id: '1' });
+    expect(di.b).toBe(0.5);
+  });
+
+  test('rapport inférieur à la plus petite borne : seule la borne max est renseignée', () => {
+    tv.mockReturnValue({ b: '0.9', tv_coef_reduction_deperdition_id: '3' });
+    const de = {
+      enum_type_adjacence_id: '8',
+      enum_cfg_isolation_lnc_id: '2',
+      surface_aiu: 1,
+      surface_aue: 10
+    };
+    b({}, de, {}, 1);
+    const matcher = tv.mock.calls[0][1];
+    expect(matcher.aiu_aue_max).toBe('≤ 0,25');
+    expect(matcher.aiu_aue_min).toBeUndefined();
+  });
 });

package/3.2.1_mur.spec.js

@@ -226,6 +226,63 @@ describe('calc_mur - calcul de Umur0 par table forfaitaire (tv_umur0)', () => {
     error.mockRestore();
   });
 
+  test('bug_for_bug : épaisseur absente et ligne tv_umur0_id sans épaisseur : matcher inchangé', () => {
+    bugForBugCompat = true;
+    const error = vi.spyOn(console, 'error').mockImplementation(() => {});
+    tv.mockImplementation((table, matcher) => {
+      if (table === 'umur0' && matcher.tv_umur0_id) return { tv_umur0_id: '1' };
+      if (table === 'umur0') return { ...ROW_UMUR0 };
+      return null;
+    });
+    const mur = {
+      donnee_entree: {
+        methode_saisie_u: 'non isolé',
+        methode_saisie_u0:
+          'déterminé selon le matériau et épaisseur à partir de la table de valeur forfaitaire',
+        enum_materiaux_structure_mur_id: '5',
+        description: 'mur sans épaisseur',
+        tv_umur0_id: 1,
+        enum_type_doublage_id: '2'
+      }
+    };
+
+    calc_mur(mur, 'h1a', '1', '0');
+
+    // Aucune épaisseur à reprendre : pas d'avertissement et épaisseur nulle conservée
+    expect(error).not.toHaveBeenCalled();
+    expect(tv).toHaveBeenLastCalledWith('umur0', {
+      enum_materiaux_structure_mur_id: '5',
+      epaisseur_structure: 0
+    });
+    error.mockRestore();
+  });
+
+  test('bug_for_bug : ligne tv_umur0_id introuvable : matcher inchangé', () => {
+    bugForBugCompat = true;
+    tv.mockImplementation((table, matcher) => {
+      if (table === 'umur0' && matcher.tv_umur0_id) return undefined;
+      if (table === 'umur0') return { ...ROW_UMUR0 };
+      return null;
+    });
+    const mur = {
+      donnee_entree: {
+        methode_saisie_u: 'non isolé',
+        methode_saisie_u0:
+          'déterminé selon le matériau et épaisseur à partir de la table de valeur forfaitaire',
+        enum_materiaux_structure_mur_id: '5',
+        tv_umur0_id: 1,
+        enum_type_doublage_id: '2'
+      }
+    };
+
+    calc_mur(mur, 'h1a', '1', '0');
+
+    expect(tv).toHaveBeenLastCalledWith('umur0', {
+      enum_materiaux_structure_mur_id: '5',
+      epaisseur_structure: 0
+    });
+  });
+
   test('bug_for_bug : épaisseur > 80 recalculée en la divisant par 10 (valeur en millimètres)', () => {
     bugForBugCompat = true;
     const error = vi.spyOn(console, 'error').mockImplementation(() => {});
@@ -423,6 +480,48 @@ describe('calc_mur - prise en compte du doublage', () => {
     }
   );
 
+  test('bug_for_bug : doublage de type 1 sans description : type de doublage inchangé', () => {
+    bugForBugCompat = true;
+    const mur = {
+      donnee_entree: {
+        methode_saisie_u: 'non isolé',
+        methode_saisie_u0:
+          'déterminé selon le matériau et épaisseur à partir de la table de valeur forfaitaire',
+        enum_materiaux_structure_mur_id: '5',
+        epaisseur_structure: 30,
+        enum_type_doublage_id: '1'
+      }
+    };
+
+    calc_mur(mur, 'h1a', '1', '0');
+
+    // Type 1 (pas de doublage) : Umur0 de la table non modifié
+    expect(mur.donnee_intermediaire.umur0).toBe(2);
+  });
+
+  test('bug_for_bug : type de doublage > 2 inconnu (6) : aucune résistance de doublage ajoutée', () => {
+    bugForBugCompat = true;
+    const error = vi.spyOn(console, 'error').mockImplementation(() => {});
+    const mur = {
+      donnee_entree: {
+        methode_saisie_u: 'non isolé',
+        methode_saisie_u0:
+          'déterminé selon le matériau et épaisseur à partir de la table de valeur forfaitaire',
+        enum_materiaux_structure_mur_id: '5',
+        epaisseur_structure: 30,
+        enum_type_doublage_id: '6'
+      }
+    };
+
+    calc_mur(mur, 'h1a', '1', '0');
+
+    // Le type 6 est hors énumération type_doublage (1 à 5) : aucune résistance de doublage n'est
+    // définie, ni dans le calcul ni dans la vérification de minoration. Comportement actuel figé :
+    // Umur0 devient NaN (donnée d'entrée invalide, non protégée par le moteur).
+    expect(mur.donnee_intermediaire.umur0).toBeNaN();
+    error.mockRestore();
+  });
+
   test('bug_for_bug : DPE minorant Umur0 à 2,5 avant doublage : avertissement (Umur0 avant)', () => {
     bugForBugCompat = true;
     const error = vi.spyOn(console, 'error').mockImplementation(() => {});

package/3.2.3_plancher_haut.spec.js

@@ -342,6 +342,35 @@ describe('calc_ph - compatibilité bug for bug (récupération depuis tv_uph_id)
     error.mockRestore();
   });
 
+  test('ligne tv_uph_id introuvable : type_toiture et effet_joule calculés conservés', () => {
+    const error = vi.spyOn(console, 'error').mockImplementation(() => {});
+    tv.mockImplementation((table, matcher) => {
+      if (table === 'uph0') return { ...ROW_UPH0 };
+      if (table === 'uph' && matcher.tv_uph_id) return undefined;
+      if (table === 'uph') return { ...ROW_UPH };
+      return null;
+    });
+
+    const ph = {
+      donnee_entree: {
+        methode_saisie_u: 'isolation inconnue  (table forfaitaire)',
+        methode_saisie_u0: 'type de paroi inconnu (valeur par défaut)',
+        type_adjacence: 'extérieur',
+        type_plancher_haut: 'terrasse',
+        tv_uph_id: 7,
+        description: 'PH test'
+      }
+    };
+
+    calc_ph(ph, 'h1a', '1', '0');
+
+    // Aucune correction issue du DPE : pas d'avertissement, matcher final en 'terrasse'
+    expect(error).not.toHaveBeenCalled();
+    expect(tv).toHaveBeenCalledWith('uph', expect.objectContaining({ type_toiture: 'terrasse' }));
+    expect(ph.donnee_intermediaire.uph).toBe(0.3);
+    error.mockRestore();
+  });
+
   test('effet_joule du DPE différent : la valeur du DPE est conservée dans le matcher', () => {
     const error = vi.spyOn(console, 'error').mockImplementation(() => {});
     tv.mockImplementation((table, matcher) => {

package/3.3_baie_vitree.spec.js

@@ -234,6 +234,16 @@ describe('tv_uw - coefficient de transmission de la fenêtre', () => {
     expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('Pas de valeur forfaitaire uw'));
   });
 
+  test('Ug exactement tabulé sans ligne uw : uw indéfini et erreur émise', () => {
+    // delta_ug = 0 (bornes identiques) mais aucune ligne uw pour ce Ug
+    rows.uw = null;
+    const bv = baseBv();
+    calc_bv(bv, 1);
+
+    expect(bv.donnee_intermediaire.uw).toBeUndefined();
+    expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('Pas de valeur forfaitaire uw'));
+  });
+
   test('interpolation entre deux Ug tabulés (delta_ug ≠ 0)', () => {
     rows.ug = { ug: '3', tv_ug_id: '5' };
     getRange.mockReturnValue([2.8, 4]);

package/3.4_pont_thermique.spec.js

@@ -810,6 +810,33 @@ describe('calc_pont_thermique - récupération du mur via la baie vitrée (compa
     expect(errorSpy).toHaveBeenCalled();
   });
 
+  test('hors compatibilité bug : la baie vitrée n’est pas consultée pour retrouver le mur', () => {
+    state.bug = false;
+    tv.mockReturnValue({ k: '0.5', tv_pont_thermique_id: '42' });
+    const mur = [
+      {
+        donnee_entree: { reference: 'M1', enum_type_adjacence_id: '1', type_isolation: 'iti' },
+        donnee_utilisateur: {}
+      }
+    ];
+    // Même configuration que le cas bug_for_bug : reference_paroi = index du mur (0)
+    const bv = [{ donnee_entree: { reference: 'BV1', reference_paroi: '0' } }];
+    const pt = pontThermique({
+      type_liaison: 'refend / mur',
+      reference_1: 'BV1',
+      description: 'refend'
+    });
+
+    calc_pont_thermique(pt, '1', logement({ mur, bv }));
+
+    // Mur non retrouvé via la baie : isolation ITI par défaut, aucun message de récupération
+    expect(tv).toHaveBeenCalledWith('pont_thermique', {
+      enum_type_liaison_id: '12',
+      isolation_mur: '^iti'
+    });
+    expect(errorSpy).not.toHaveBeenCalledWith(expect.stringContaining('Aucun mur trouvé'));
+  });
+
   test('reference_paroi ne correspondant pas à l’index du mur : aucun mur retrouvé (isolation ITI par défaut)', () => {
     state.bug = true;
     tv.mockReturnValue({ k: '0.5', tv_pont_thermique_id: '42' });

package/4_ventilation.spec.js

@@ -146,6 +146,18 @@ describe('calc_ventilation - orchestration', () => {
     );
   });
 
+  test('surface ventilée égale à Sh : conservée sans application de clé de répartition', () => {
+    const vt = ventilation({
+      surface_ventile: 100,
+      cle_repartition_ventilation: 2,
+      q4pa_conv_saisi: 1.3
+    });
+    calc_ventilation(vt, CG, 'th', 80, 100, [], [], [], []);
+
+    // surface_ventile = Sh = 100 (clé ignorée) => Hvent = 0,34 * 1,2 * 100
+    expect(vt.donnee_intermediaire.hvent).toBeCloseTo(40.8, 9);
+  });
+
   test('surface ventilée différente de Sh sans clé de répartition : divisée par 1', () => {
     // Branche `de.cle_repartition_ventilation || 1` : surface_ventile conservée telle quelle
     const vt = ventilation({ surface_ventile: 50, q4pa_conv_saisi: 1.3 });

package/7_inertie.spec.js

@@ -54,6 +54,16 @@ describe('Inertie unit tests', () => {
     }
   );
 
+  test('plancher haut non lourd (type 9) isolé par ITE ou non isolé : inertie 0', () => {
+    expect(
+      inertie.calculateInertiePhLourd({ enum_type_isolation_id: 2, enum_type_plancher_haut_id: 9 })
+    ).toBe(0);
+  });
+
+  test('type de plancher haut inconnu avec isolation ITE : considéré lourd, inertie 1', () => {
+    expect(inertie.calculateInertiePhLourd({ enum_type_isolation_id: 4 })).toBe(1);
+  });
+
   test.each([
     [1, 1, 0, 2, 0],
     [1, 1, 0, 3, 0],

package/9_besoin_ch.spec.js

@@ -93,6 +93,10 @@ describe('calc_Fj - fraction des besoins de chauffage couverte par les apports',
     expect(lourde).not.toBeCloseTo(legere, 9);
   });
 
+  test('une inertie inconnue ne définit pas alpha : le résultat n’est pas un nombre', () => {
+    expect(calc_Fj(100, 2000, 5000, 1000, 'inconnue')).toBeNaN();
+  });
+
   test('les inerties "très lourde" et "lourde" partagent le même alpha', () => {
     expect(calc_Fj(100, 2000, 5000, 1000, 'très lourde')).toBeCloseTo(
       calc_Fj(100, 2000, 5000, 1000, 'lourde'),

package/9_conso_ch.js

@@ -289,7 +289,7 @@ function calc_ch_base_appoint(
 
     di.conso_ch = 0;
     for (const mois of mois_liste) {
-      let bch_base_j = 0;
+      let bch_base_j;
 
       if (pe > 0) {
         // Nombre d’heures de chauffage sur le mois j

package/9_emetteur_ch.spec.js

@@ -23,7 +23,9 @@ vi.mock('./utils.js', () => ({
 }));
 
 vi.mock('./core/tv/infrastructure/tvs.store.js', () => ({
-  TvsStore: vi.fn(() => mockTvsStore)
+  TvsStore: vi.fn(function () {
+    return mockTvsStore;
+  })
 }));
 
 const { rendement_emission, calc_emetteur_ch, isIntermittenceCollectiveSaisie } =

package/9_generateur_ch.spec.js

@@ -342,6 +342,17 @@ describe('checkForGeneratorType - classification du générateur', () => {
     expect(de.enum_type_generateur_ch_id).toBe('119');
   });
 
+  test('cas 119 par défaut avec ligne de rendement sans type de générateur : aucune réécriture', () => {
+    vi.mocked(requestInputID).mockReturnValue('119');
+    vi.mocked(tv).mockReturnValue({ enum_type_generateur_ch_id: undefined });
+    const de = { tv_rendement_generation_id: 3, enum_type_generateur_ch_id: '119' };
+    const du = {};
+    checkForGeneratorType({}, de, {}, du);
+    expect(de.enum_type_generateur_ch_id).toBe('119');
+    expect(du.isPacGenerator).toBe(false);
+    expect(du.isCombustionGenerator).toBe(false);
+  });
+
   /**
    * Chaudière fioul par défaut : chaudière standard datant de la construction du bâtiment.
    * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §17.2.1.1

package/apport_et_besoin.spec.js

@@ -22,7 +22,11 @@ vi.mock('./6.2_surface_sud_equivalente.js', () => ({ calc_sse: vi.fn() }));
 vi.mock('./10_besoin_fr.js', () => ({ default: vi.fn() }));
 vi.mock('./11_besoin_ecs.js', () => ({ default: vi.fn() }));
 vi.mock('./6.1_apport_gratuit.js', () => ({ calc_ai: vi.fn(), calc_as: vi.fn() }));
-vi.mock('./11_nadeq.js', () => ({ Nadeq: vi.fn(() => ({ calculateNadeq })) }));
+vi.mock('./11_nadeq.js', () => ({
+  Nadeq: vi.fn(function () {
+    return { calculateNadeq };
+  })
+}));
 
 const { default: calc_apport_et_besoin } = await import('./apport_et_besoin.js');
 const { calc_sse } = await import('./6.2_surface_sud_equivalente.js');

package/core/assets/domain/add-additionnal-ue-values-tables.js

@@ -4,25 +4,6 @@ import { UPB_ADDITIONAL_VALUES } from '../../tv/infrastructure/assets/additional
  * Add additional values for ue
  */
 export class AddAdditionnalUeValuesTables {
-  /**
-   * @type {FileStore}
-   */
-  #fileStore;
-
-  /**
-   * @type {ApplicationConfig}
-   */
-  #appConfig;
-
-  /**
-   * @param fileStore {FileStore}
-   * @param appConfig {ApplicationConfig}
-   */
-  constructor(fileStore, appConfig) {
-    this.#fileStore = fileStore;
-    this.#appConfig = appConfig;
-  }
-
   /**
    * Ajout de valeurs supplémentaires pour le calcul du facteur Ue pour les déperditions plancher_bas
    * @param tableValues

package/core/assets/domain/add-additionnal-ue-values-tables.spec.js

@@ -3,12 +3,11 @@ import { AddAdditionnalUeValuesTables } from './add-additionnal-ue-values-tables
 import { UPB_ADDITIONAL_VALUES } from '../../tv/infrastructure/assets/additional-ue-values.js';
 
 /**
- * `execute` n'utilise ni le fileStore ni l'appConfig : on les passe en doubles
- * vides pour isoler la logique d'aplatissement des valeurs Ue additionnelles
- * dans la table `ue`.
+ * Le service n'a aucune dépendance : on vérifie la logique d'aplatissement des
+ * valeurs Ue additionnelles dans la table `ue`.
  */
 describe('AddAdditionnalUeValuesTables', () => {
-  const buildService = () => new AddAdditionnalUeValuesTables({}, {});
+  const buildService = () => new AddAdditionnalUeValuesTables();
 
   test('ajoute toutes les valeurs additionnelles dans la table ue', () => {
     const nbAttendu = UPB_ADDITIONAL_VALUES.reduce((acc, entree) => acc + entree.values.length, 0);

package/core/assets/domain/synchronize-dpe-ges-limit-values-tables.spec.js

@@ -69,4 +69,29 @@ describe('SynchronizeDpeGesLimitValuesTables unit tests', () => {
       });
     });
   });
+  test('regroupe plusieurs surfaces sous une même classe d’altitude', () => {
+    const fileStore = new FileStore();
+    const appConfig = new ApplicationConfig();
+    const synchronizeDpeGesLimitValuesTables = new SynchronizeDpeGesLimitValuesTables(
+      fileStore,
+      appConfig
+    );
+
+    vi.spyOn(fileStore, 'readLocalOdsFileAndConvertToJson').mockResolvedValue({
+      dpe_class_limit: [
+        { classe_altitude: '400-800m', surface: '10', A: '124' },
+        { classe_altitude: '400-800m', surface: '20', A: '100' }
+      ]
+    });
+    vi.spyOn(ApplicationConfig.prototype, 'solicitationsExtFilePath', 'get').mockReturnValue(
+      'src/file.ods'
+    );
+
+    return synchronizeDpeGesLimitValuesTables.execute().then((output) => {
+      // Le groupe d'altitude n'est créé qu'une fois : la 1ʳᵉ surface n'est pas écrasée
+      expect(output).toStrictEqual({
+        dpe_class_limit: { '400-800m': { 10: { A: 124 }, 20: { A: 100 } } }
+      });
+    });
+  });
 });

package/core/assets/domain/synchronize-valeur-tables.spec.js

@@ -99,4 +99,47 @@ describe('SynchronizeValeurTables unit tests', () => {
       expect(contenu).toContain('valeurs-ue-completees');
     });
   });
+  test('force isolation_surfaces à "0" uniquement lorsque la valeur est absente dans q4pa_conv', () => {
+    const fileStore = new FileStore();
+    const appConfig = new ApplicationConfig();
+    const synchronizeC1Tables = new SynchronizeC1Tables(fileStore, appConfig);
+    const synchronizeSolicitationTables = new SynchronizeSolicitationsTables(fileStore, appConfig);
+    const synchronizeDpeGesLimitValuesTables = new SynchronizeDpeGesLimitValuesTables(
+      fileStore,
+      appConfig
+    );
+    const addAdditionnalUeValuesTables = new AddAdditionnalUeValuesTables(fileStore, appConfig);
+    const synchronizeValeurTables = new SynchronizeValeurTables(
+      fileStore,
+      appConfig,
+      synchronizeSolicitationTables,
+      synchronizeDpeGesLimitValuesTables,
+      addAdditionnalUeValuesTables,
+      synchronizeC1Tables
+    );
+
+    vi.spyOn(ApplicationConfig.prototype, 'ademeValeurTablesFileUrl', 'get').mockReturnValue(
+      'http://localhost/file.xlsx'
+    );
+    vi.spyOn(ApplicationConfig.prototype, 'assetsOutputFolder', 'get').mockReturnValue(
+      'src/assets'
+    );
+
+    // Le parsing Excel ignore les valeurs à 0 : la 1ʳᵉ ligne n'a pas de isolation_surfaces,
+    // la 2ᵉ en possède déjà une qui doit être conservée.
+    vi.spyOn(fileStore, 'downloadXlsxFileAndConvertToJson').mockResolvedValue({
+      q4pa_conv: [{ q4pa_conv: 'a' }, { q4pa_conv: 'b', isolation_surfaces: 'oui' }]
+    });
+    vi.spyOn(fileStore, 'writeFileToLocalSystem').mockResolvedValue(null);
+    vi.spyOn(synchronizeC1Tables, 'execute').mockResolvedValue({});
+    vi.spyOn(synchronizeSolicitationTables, 'execute').mockResolvedValue({});
+    vi.spyOn(synchronizeDpeGesLimitValuesTables, 'execute').mockResolvedValue({});
+    vi.spyOn(addAdditionnalUeValuesTables, 'execute').mockResolvedValue({});
+
+    return synchronizeValeurTables.execute().then(() => {
+      const contenu = vi.mocked(fileStore.writeFileToLocalSystem).mock.calls[0][1];
+      const tvs = JSON.parse(contenu.match(/tvs = (\{[\s\S]*\});\n export/)[1]);
+      expect(tvs.q4pa_conv.map((l) => l.isolation_surfaces)).toEqual(['0', 'oui']);
+    });
+  });
 });

package/core/util/logger/log-service.spec.js

@@ -58,6 +58,17 @@ describe('Service de logs (log-service)', () => {
     expect(console.error).toBe(consoleOrigine.error);
   });
 
+  test('setLoggerOn sans option conserve console.error neutralisé', () => {
+    setLoggerOff(true);
+    const erreurNeutralisee = console.error;
+    setLoggerOn();
+
+    expect(logger.silent).toBe(false);
+    expect(console.log).toBe(consoleOrigine.log);
+    expect(console.error).toBe(erreurNeutralisee);
+    expect(console.error).not.toBe(consoleOrigine.error);
+  });
+
   test('les méthodes console neutralisées sont des fonctions no-op', () => {
     setLoggerOff();
 

package/dpe-sanitizer.service.spec.js

@@ -77,6 +77,15 @@ describe('DpeSanitizerService.execute - collections manquantes', () => {
   });
 });
 
+describe('DpeSanitizerService - transformation des clés', () => {
+  test('conserve les clés inchangées (transformation identité)', () => {
+    vi.mocked(has).mockReturnValue(true);
+    service.execute({});
+    const keyTransform = vi.mocked(ObjectUtil.deepObjectTransform).mock.calls[0][1];
+    expect(keyTransform('generateur_ecs')).toBe('generateur_ecs');
+  });
+});
+
 /**
  * Récupère la fonction de transformation des valeurs passée en 3e argument de
  * `deepObjectTransform` après un appel à `execute`.

package/engine.js

@@ -36,7 +36,7 @@ import DpeSanitizerService from './dpe-sanitizer.service.js';
 import { reconstituerRdimDpeGenereImmeuble } from './17.2_rdim_dpe_genere_immeuble.js';
 import { reconstituerRdimEcsIndividuelleUnique } from './11_rdim_ecs_individuelle_unique.js';
 
-const LIB_VERSION = '1.11.1';
+const LIB_VERSION = '1.11.2';
 
 const dpeSanitizerService = new DpeSanitizerService();
 

package/engine.spec.js

@@ -83,9 +83,15 @@ vi.mock('./11_rdim_ecs_individuelle_unique.js', () => ({
 const calculateInertie = vi.fn();
 const calculateEnr = vi.fn();
 const ratioProrataPvLogement = vi.fn();
-vi.mock('./7_inertie.js', () => ({ Inertie: vi.fn(() => ({ calculateInertie })) }));
+vi.mock('./7_inertie.js', () => ({
+  Inertie: vi.fn(function () {
+    return { calculateInertie };
+  })
+}));
 vi.mock('./16.2_production_enr.js', () => ({
-  ProductionENR: vi.fn(() => ({ calculateEnr })),
+  ProductionENR: vi.fn(function () {
+    return { calculateEnr };
+  }),
   ratioProrataPvLogement: (...args) => ratioProrataPvLogement(...args)
 }));
 
@@ -93,7 +99,9 @@ vi.mock('./16.2_production_enr.js', () => ({
 // renvoie l'entrée telle quelle.
 const sanitizeExecute = vi.fn((dpe) => dpe);
 vi.mock('./dpe-sanitizer.service.js', () => ({
-  default: vi.fn(() => ({ execute: sanitizeExecute }))
+  default: vi.fn(function () {
+    return { execute: sanitizeExecute };
+  })
 }));
 
 const { getVersion, get_conso_coeff_1_7_2027, get_classe_ges_dpe, calcul_3cl, calcul_3cl_xml } =
@@ -650,6 +658,20 @@ describe('calcul_3cl - collections vidables (poursuite du calcul)', () => {
 });
 
 describe('calcul_3cl - surfaces immeuble / appartement et prorata', () => {
+  test('méthode application inconnue : surface habitable indéterminée transmise à la déperdition', () => {
+    enums.methode_application_dpe_log = { 1: 'méthode farfelue' };
+    const errSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    const dpe = makeDpe();
+
+    calcul_3cl(dpe, { sanitize: false });
+
+    // th null => aucune surface retenue (ni logement ni immeuble)
+    expect(calc_deperdition.mock.calls[0][2]).toBeNull();
+    expect(calc_deperdition.mock.calls[0][5]).toBeUndefined();
+    expect(errSpy).toHaveBeenCalled();
+    errSpy.mockRestore();
+  });
+
   test('immeuble : Sh = surface immeuble ; ECS collective individualisée non divisée', () => {
     enums.methode_application_dpe_log = { 1: 'dpe immeuble collectif' };
     const dpe = makeDpe();
@@ -1340,4 +1362,22 @@ describe('get_conso_coeff_1_7_2027', () => {
     expect(res.ep_conso_5_usages_2027).toBeCloseTo(ep, 6);
     expect(classe_bilan_dpe).toHaveBeenCalledWith(Math.floor(ep / 200), 'zc1', 'ca1', 200);
   });
+
+  test('méthode application inconnue : surface indéterminée, aucune surface ne lui est substituée', () => {
+    enums.methode_application_dpe_log = { 1: 'méthode farfelue' };
+    const errSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    vi.mocked(classe_bilan_dpe).mockReturnValue('G');
+    const dpe = makeDpe();
+    dpe.logement.sortie = {
+      ep_conso: { ep_conso_5_usages: 10000 },
+      ef_conso: { conso_5_usages: 6000 }
+    };
+
+    get_conso_coeff_1_7_2027(dpe);
+
+    // th null => ni surface logement ni surface immeuble
+    expect(classe_bilan_dpe.mock.calls[0][3]).toBeUndefined();
+    expect(errSpy).toHaveBeenCalled();
+    errSpy.mockRestore();
+  });
 });

package/features/normalizer/domain/dpe-normalizer.service.spec.js

@@ -5,9 +5,11 @@ import { beforeEach, describe, expect, test, vi } from 'vitest';
 // du comportement réel de `DpePreProcessor` (testé dans son propre spec).
 const preprocessMock = vi.fn();
 vi.mock('../../../preprocessor/index.js', () => ({
-  DpePreProcessor: vi.fn().mockImplementation(() => ({
-    preprocess: preprocessMock
-  }))
+  DpePreProcessor: vi.fn(function () {
+    return {
+      preprocess: preprocessMock
+    };
+  })
 }));
 
 const { DpeNormalizerService } = await import('./dpe-normalizer.service.js');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open3cl/engine",
-  "version": "1.11.1",
+  "version": "1.11.2",
   "description": "Open Source 3CL-DPE engine",
   "main": "index.js",
   "directories": {
@@ -26,7 +26,7 @@
     "qa:format": "prettier --plugin-search-dir . --write .",
     "release": "semantic-release",
     "release:dry": "semantic-release --dry-run",
-    "prepare": "husky install",
+    "prepare": "husky",
     "assets:sync": "node scripts/synchronize_assets.js",
     "version:update": "node scripts/update_version.js",
     "reports:preview": "npm run http-server dist/reports/corpus -o",
@@ -45,43 +45,40 @@
   ],
   "dependencies": {
     "dioma": "^0.4.6",
-    "fast-xml-parser": "^5.11.1",
+    "fast-xml-parser": "^5.11.2",
     "lodash-es": "^4.18.1",
     "winston": "^3.19.0"
   },
   "devDependencies": {
-    "@aws-sdk/client-s3": "^3.1013.0",
-    "@commitlint/cli": "^19.2.1",
-    "@commitlint/config-conventional": "^19.1.0",
-    "@commitlint/cz-commitlint": "^19.2.0",
-    "@duckdb/node-api": "^1.3.2-alpha.25",
-    "@semantic-release/changelog": "^6.0.3",
+    "@aws-sdk/client-s3": "^3.1160.0",
+    "@commitlint/cli": "^21.2.4",
+    "@commitlint/config-conventional": "^21.2.4",
+    "@commitlint/cz-commitlint": "^21.2.4",
+    "@duckdb/node-api": "^2.0.0-r.1",
+    "@eslint/js": "^10.0.1",
+    "@semantic-release/changelog": "^7.0.0",
     "@semantic-release/commit-analyzer": "^13.0.1",
     "@semantic-release/exec": "^7.1.0",
-    "@semantic-release/git": "^10.0.1",
-    "@semantic-release/github": "^12.0.2",
-    "@types/node": "^20.12.4",
-    "@vitest/coverage-v8": "^3.2.7",
+    "@semantic-release/git": "^11.0.1",
+    "@semantic-release/github": "^12.0.10",
+    "@types/node": "^24.19.2",
+    "@vitest/coverage-v8": "^5.0.5",
     "ansi-colors": "^4.1.3",
     "cli-progress": "^3.12.0",
     "deep-object-diff": "^1.1.9",
-    "eslint": "^8.57.0",
-    "eslint-config-prettier": "^9.1.0",
-    "eslint-config-standard": "^17.1.0",
-    "eslint-plugin-check-file": "^2.7.1",
-    "eslint-plugin-import": "^2.29.1",
-    "eslint-plugin-n": "^16.6.2",
-    "eslint-plugin-promise": "^6.1.1",
-    "fast-csv": "^5.0.2",
+    "eslint": "^10.14.0",
+    "eslint-config-prettier": "^10.1.8",
+    "fast-csv": "^5.0.8",
+    "globals": "^17.13.0",
     "http-server": "^14.1.1",
-    "husky": "^9.0.11",
-    "js-yaml": "^4.3.2",
-    "jscpd": "^3.5.10",
-    "piscina": "^5.1.2",
-    "prettier": "^3.2.5",
+    "husky": "^9.1.7",
+    "js-yaml": "^5.5.0",
+    "jscpd": "^5.4.2",
+    "piscina": "^5.3.2",
+    "prettier": "^3.9.10",
     "pretty-quick": "^4.0.0",
-    "semantic-release": "^25.0.2",
-    "vitest": "3.2.7",
+    "semantic-release": "^25.0.9",
+    "vitest": "^5.0.5",
     "xlsx": "https://cdn.sheetjs.com/xlsx-0.20.3/xlsx-0.20.3.tgz"
   },
   "author": "Open3Cl",
@@ -92,21 +89,5 @@
   "bugs": {
     "url": "https://github.com/Open3CL/engine/issues"
   },
-  "homepage": "https://github.com/Open3CL/engine#readme",
-  "jscpd": {
-    "threshold": 0.1,
-    "reporters": [
-      "console",
-      "html"
-    ],
-    "ignore": [
-      "**/*.spec.js"
-    ],
-    "path": [
-      "src"
-    ],
-    "output": "./duplicate",
-    "absolute": true,
-    "gitignore": true
-  }
+  "homepage": "https://github.com/Open3CL/engine#readme"
 }

package/utils.js

@@ -459,12 +459,11 @@ export function tv(filePath, matcher) {
 function tvLookup(filePath, matcher) {
   const list = tvs[filePath];
   const matcher_size = Object.keys(matcher).length;
-  let match_count = 0;
   let max_match_count = 0;
   let match = null;
 
   for (const row of list) {
-    match_count = 0;
+    let match_count = 0;
     for (const key in matcher) {
       if (tvMatchImpl(row, key, matcher)) match_count += 1;
     }

package/utils.spec.js

@@ -215,6 +215,14 @@ describe('Utils unit tests', () => {
       expect(obj.other).toBe(3);
       expect(obj.nested.enum_c).toBe('7');
     });
+
+    test('ignore les propriétés héritées du prototype', () => {
+      const obj = Object.create({ enum_herite: 5 });
+      obj.enum_propre = 6;
+      useEnumAsString(obj);
+      expect(obj.enum_propre).toBe('6');
+      expect(obj.enum_herite).toBe(5);
+    });
   });
 
   // -------------------------------------------------------------------------------------------
@@ -589,6 +597,14 @@ describe('Utils unit tests', () => {
       expect(obj.nested.remove_me).toBeUndefined();
       expect(obj.nested.b).toBe(5);
     });
+
+    test('ignore les propriétés héritées du prototype', () => {
+      const obj = Object.create({ remove_me: 1, herite: { remove_me: 2 } });
+      obj.propre = 1;
+      removeKeyFromJSON(obj, 'remove_me', []);
+      expect(obj.remove_me).toBe(1);
+      expect(obj.herite.remove_me).toBe(2);
+    });
   });
 
   // -------------------------------------------------------------------------------------------