@open3cl/engine 1.6.2 → 1.7.1

package/10_besoin_fr.spec.js

@@ -19,6 +19,7 @@ vi.mock('./tv.js', () => ({
 }));
 
 vi.mock('./utils.js', () => ({
+  set_bug_for_bug_compat: vi.fn(),
   mois_liste: ['Janvier']
 }));
 

package/10_clim.spec.js

@@ -8,6 +8,7 @@ import { beforeEach, describe, expect, test, vi } from 'vitest';
  *   d'installation.
  */
 vi.mock('./utils.js', () => ({
+  set_bug_for_bug_compat: vi.fn(),
   tv: vi.fn(),
   requestInputID: (de, du, field) => {
     const enumName = `enum_${field}_id`;

package/11_besoin_ecs.spec.js

@@ -14,6 +14,7 @@ vi.mock('./tv.js', () => ({
 }));
 
 vi.mock('./utils.js', () => ({
+  set_bug_for_bug_compat: vi.fn(),
   mois_liste: ['Janvier'],
   Njj: { Janvier: 30 }
 }));

package/11_ecs.spec.js

@@ -19,6 +19,7 @@ vi.mock('./enums.js', () => ({
 }));
 
 vi.mock('./utils.js', () => ({
+  set_bug_for_bug_compat: vi.fn(),
   tv: vi.fn(),
   requestInput: vi.fn()
 }));

package/12.4_pac.spec.js

@@ -7,6 +7,7 @@ import { beforeEach, describe, expect, test, vi } from 'vitest';
  * Le comportement de ces utilitaires n'est pas testé ici, seulement la logique du module.
  */
 vi.mock('./utils.js', () => ({
+  set_bug_for_bug_compat: vi.fn(),
   tv: vi.fn(),
   requestInputID: vi.fn((de, du, field) => {
     const enumName = `enum_${field}_id`;

package/13.2_generateur_combustion.spec.js

@@ -14,6 +14,7 @@ import { beforeEach, describe, expect, test, vi } from 'vitest';
 const state = vi.hoisted(() => ({ bug: false }));
 
 vi.mock('./utils.js', () => ({
+  set_bug_for_bug_compat: vi.fn(),
   get bug_for_bug_compat() {
     return state.bug;
   },
@@ -51,9 +52,8 @@ vi.mock('./ficheTechnique.js', () => ({
   default: vi.fn()
 }));
 
-const { tv_generateur_combustion, updateGenerateurCombustion } = await import(
-  './13.2_generateur_combustion.js'
-);
+const { tv_generateur_combustion, updateGenerateurCombustion } =
+  await import('./13.2_generateur_combustion.js');
 const { tv, tvColumnLines } = await import('./utils.js');
 const { updateGenerateurBouilleurs } = await import('./13.2_generateur_combustion_bouilleur.js');
 const { updateGenerateurChaudieres } = await import('./13.2_generateur_combustion_chaudiere.js');

package/13.2_generateur_combustion_ch.spec.js

@@ -29,6 +29,7 @@ vi.mock('./enums.js', () => ({
 }));
 
 vi.mock('./utils.js', () => ({
+  set_bug_for_bug_compat: vi.fn(),
   get bug_for_bug_compat() {
     return state.bug;
   },
@@ -37,9 +38,8 @@ vi.mock('./utils.js', () => ({
   requestInputID: vi.fn((de, du, field) => de[`enum_${field}_id`])
 }));
 
-const { tv_temp_fonc_30_100, calc_generateur_combustion_ch } = await import(
-  './13.2_generateur_combustion_ch.js'
-);
+const { tv_temp_fonc_30_100, calc_generateur_combustion_ch } =
+  await import('./13.2_generateur_combustion_ch.js');
 const { tv } = await import('./utils.js');
 
 beforeEach(() => {

package/14_generateur_ecs.spec.js

@@ -32,6 +32,7 @@ vi.mock('./enums.js', () => ({
 }));
 
 vi.mock('./utils.js', () => ({
+  set_bug_for_bug_compat: vi.fn(),
   get bug_for_bug_compat() {
     return state.bug;
   },

package/15_conso_aux.js

@@ -1,6 +1,6 @@
 import enums from './enums.js';
 import tvs from './tv.js';
-import { mois_liste, Tbase } from './utils.js';
+import { mois_liste, Njj, Tbase } from './utils.js';
 
 const G_CHAUDIERE = 20;
 const G_RADIATEURS_GAZ = 40;
@@ -259,3 +259,123 @@ function getPuissanceCirculateur(em_ch, de, di, du, surfaceHabitable, GV, Tbase)
       Math.max(1, surfaceHabitable / 400)
   );
 }
+
+/**
+ * 15.2.3 Consommation des auxiliaires de distribution d'ECS
+ * Calcul installation par installation pour le cas appartement
+ *
+ * SI installation individuelle : conso = 0
+ * SI installation collective :
+ *   CAS 1 - enum_bouclage_reseau_ecs_id = 1 (non bouclé) : conso = 0
+ *   CAS 2 - enum_bouclage_reseau_ecs_id = 2 (bouclé) : calcul selon étapes 1-9
+ *   CAS 3 - enum_bouclage_reseau_ecs_id = 3 (traçage) : conso = 0.14 * BECS_annuel * Sh_install / Sh_logement
+ *
+ * @param ecs {object} installation ECS
+ * @param de {Donnee_entree} donnée d'entrée de l'installation ECS
+ * @param di {Donnee_intermediaire} donnée intermédiaire de l'installation ECS
+ * @param Sh_logement {number} surface habitable du logement
+ * @param Sh_immeuble {number} surface habitable de l'immeuble
+ * @param caId {number} id de la classe d'altitude
+ * @param zcId {number} id de la zone climatique
+ * @param nadeq {number} nombre d'unités d'équivalence
+ * @param nombre_niveau_immeuble {number} nombre de niveaux de l'immeuble
+ */
+export function conso_aux_distribution_ecs(
+  ecs,
+  de,
+  di,
+  Sh_logement,
+  Sh_immeuble,
+  caId,
+  zcId,
+  nadeq,
+  nombre_niveau_immeuble
+) {
+  const typeInstallation = parseInt(de.enum_type_installation_id);
+
+  if (typeInstallation === 1) {
+    di.conso_auxiliaire_distribution_ecs = 0;
+    return;
+  }
+
+  const enumBouclage = parseInt(de.enum_bouclage_reseau_ecs_id);
+
+  // CAS 1 - enum_bouclage_reseau_ecs_id =1 (réseau d'ECS non bouclé)
+  if (enumBouclage === 1 || isNaN(enumBouclage)) {
+    di.conso_auxiliaire_distribution_ecs = 0;
+    return;
+  }
+
+  // CAS 3 - enum_bouclage_reseau_ecs_id = 3 (traçage)
+  if (enumBouclage === 3) {
+    const BECS_annuel = di.besoin_ecs;
+    const Sh_install = de.surface_habitable || Sh_logement;
+    di.conso_auxiliaire_distribution_ecs = (0.14 * BECS_annuel * Sh_install) / Sh_logement;
+    return;
+  }
+
+  // CAS 2 - enum_bouclage_reseau_ecs_id = 2 (réseau bouclé)
+  const ca = enums.classe_altitude[caId];
+  const zc = enums.zone_climatique[zcId];
+
+  const ratioVirtu = parseFloat(de.ratio_virtualisation);
+  let Sh_immeuble_ratio = Sh_immeuble;
+  let Sh_install = de.surface_habitable || Sh_logement;
+  let Niv_inst_ecs = de.nombre_niveau_installation_ecs || 1;
+
+  if (!(Sh_immeuble > Sh_logement) && ratioVirtu > 0 && ratioVirtu < 1) {
+    Sh_immeuble_ratio = Sh_logement / ratioVirtu;
+    Sh_install = Sh_logement;
+    Niv_inst_ecs = nombre_niveau_immeuble || Niv_inst_ecs;
+  }
+
+  // Etape 3: Lb - longueur par défaut du bouclage ECS (m)
+  // Sh est la surface habitable des logements desservis par l'installation d'ECS
+  // Pour l'appartement, on utilise la surface à l'échelle de l'immeuble
+  const Sh = (Sh_install / Sh_logement) * Sh_immeuble_ratio;
+  const Lb = 4 * Math.pow(Sh / Niv_inst_ecs, 0.5) + 6 * (Niv_inst_ecs - 0.5);
+
+  // Etape 4: DeltaPb (kPa) - perte de charge dans le bouclage
+  const DeltaPb = 0.2 * Lb + 10;
+
+  let conso = 0;
+
+  for (const mois of mois_liste) {
+    // Besoin ECS mensuel pour le logement (kWh)
+    // spec : https://rt-re-batiment.developpement-durable.gouv.fr/IMG/pdf/consolide_annexe_1_arrete_du_31_03_2021_relatif_aux_methodes_et_procedures_applicables.pdf
+    // page 71-72
+    const tefsj = tvs.tefs[ca][mois][zc];
+    const njj = Njj[mois];
+    const BECS_j = (1.163 * nadeq * 56 * (40 - tefsj) * njj) / 1000;
+
+    // Etape 1: Qdwj_i (Wh) - pertes de distribution à l'échelle de l'immeuble
+    // Qd,w,j = (0.5 * Lvc / Sh + 0.112 + 0.028) * BECS_j
+    // Pour Ratecs=1 (bouclé): Lvc = 0.2 * Sh * Ratecs = 0.2 * Sh
+    // So Qd,w,j = (0.1 + 0.112 + 0.028) * BECS_j = 0.24 * BECS_j (kWh)
+    // Pour l'appartement: Qd,w,j est multiplié par Sh_immeuble_ratio / Sh_logement
+    const Qdwj_i =
+      (0.24 * BECS_j * 1000 * Sh_install * Sh_immeuble_ratio) / (Sh_logement * Sh_logement);
+
+    // Etape 2: qdwj_i (m³/h) - débit de distribution ECS
+    const Nh_puisage_j = njj * 5;
+    const qdwj_i = Qdwj_i / (5.815 * Nh_puisage_j) / 1000;
+
+    // Etape 5: Phyd,j (W) - puissance hydraulique du bouclage
+    const Phyd_j = (qdwj_i * DeltaPb) / 3.6;
+
+    // Etape 6: Effcirb,j - efficacité du circulateur
+    const Effcirb_j = Math.pow(Phyd_j, 0.324) / 15.3;
+
+    // Etape 7: Pcirb,j (W) - puissance électrique du circulateur
+    const Pcirb_j = Math.max(20, Phyd_j / Effcirb_j);
+
+    // Etape 8: Qcirb,j (Wh) - consommation mensuelle du circulateur
+    const Nh_mois_j = njj * 24;
+    const Qcirb_j = Nh_puisage_j * Pcirb_j + (Nh_mois_j - Nh_puisage_j) * 20;
+
+    conso += Qcirb_j;
+  }
+
+  // Etape 9: conso annuelle ramenée à l'appartement (kWh)
+  di.conso_auxiliaire_distribution_ecs = (conso * Sh_logement) / Sh_immeuble_ratio / 1000;
+}

package/15_conso_aux.spec.js

@@ -1,10 +1,13 @@
 import { beforeEach, describe, expect, test, vi } from 'vitest';
 
 /**
- * Dépendances mockées uniquement pour `conso_aux_distribution_ch` :
+ * Dépendances mockées pour `conso_aux_distribution_ch` et `conso_aux_distribution_ecs` :
  * - `enums` : libellés de classe d'altitude / zone climatique ;
  * - `tvs.nref19` : nombre d'heures de fonctionnement mensuel ;
- * - `mois_liste` / `Tbase` : réduits à des valeurs contrôlées.
+ * - `tvs.tefs` : température d'eau froide sanitaire mensuelle ;
+ * - `mois_liste` / `Njj` / `Tbase` : réduits à des valeurs contrôlées.
+ * L'année est réduite à un seul mois (Janvier, 31 jours) pour rendre les
+ * consommations attendues calculables à la main.
  * `conso_aux_gen` n'utilise aucune de ces dépendances (calcul autonome).
  */
 vi.mock('./enums.js', () => ({
@@ -16,16 +19,20 @@ vi.mock('./enums.js', () => ({
 
 vi.mock('./tv.js', () => ({
   default: {
-    nref19: { 0: { ca1: { Janvier: { h1a: 100 } } } }
+    nref19: { 0: { ca1: { Janvier: { h1a: 100 } } } },
+    tefs: { ca1: { Janvier: { h1a: 10 } } }
   }
 }));
 
 vi.mock('./utils.js', () => ({
+  set_bug_for_bug_compat: vi.fn(),
   mois_liste: ['Janvier'],
+  Njj: { Janvier: 31 },
   Tbase: { ca1: { h1: -9 } }
 }));
 
-const { conso_aux_gen, conso_aux_distribution_ch } = await import('./15_conso_aux.js');
+const { conso_aux_gen, conso_aux_distribution_ch, conso_aux_distribution_ecs } =
+  await import('./15_conso_aux.js');
 
 /**
  * 15.1 Consommation des auxiliaires de génération
@@ -223,3 +230,321 @@ describe('conso_aux_distribution_ch - auxiliaires de distribution', () => {
     expect(di.conso_auxiliaire_distribution_ch).toBeCloseTo(136.51553416032854, 9);
   });
 });
+
+/**
+ * 15.2.3 Consommation des auxiliaires de distribution d'ECS
+ * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §15.2.3
+ *
+ * Les scénarios ci-dessous s'appuient sur l'année réduite à Janvier (31 jours,
+ * tefs = 10 °C) définie par les mocks en tête de fichier :
+ * - Nh_puisage = 31 × 5 = 155 h
+ * - Nh_mois    = 31 × 24 = 744 h
+ */
+describe("conso_aux_distribution_ecs - auxiliaires de distribution d'ECS", () => {
+  // Consommation du circulateur maintenu à 20 W sur toutes les heures du mois (kWh)
+  const CONSO_PLANCHER_20W = (31 * 24 * 20) / 1000; // 14,88 kWh
+
+  test('installation individuelle : consommation nulle', () => {
+    const di = {};
+    conso_aux_distribution_ecs(
+      {},
+      { enum_type_installation_id: '1', enum_bouclage_reseau_ecs_id: '2' },
+      di,
+      50,
+      2000,
+      1,
+      1,
+      30
+    );
+    expect(di.conso_auxiliaire_distribution_ecs).toBe(0);
+  });
+
+  test("réseau d'ECS non bouclé (id 1) : consommation nulle", () => {
+    const di = {};
+    conso_aux_distribution_ecs(
+      {},
+      { enum_type_installation_id: '2', enum_bouclage_reseau_ecs_id: '1' },
+      di,
+      50,
+      2000,
+      1,
+      1,
+      30
+    );
+    expect(di.conso_auxiliaire_distribution_ecs).toBe(0);
+  });
+
+  test('type de bouclage non renseigné : consommation nulle', () => {
+    const di = {};
+    conso_aux_distribution_ecs({}, { enum_type_installation_id: '2' }, di, 50, 2000, 1, 1, 30);
+    expect(di.conso_auxiliaire_distribution_ecs).toBe(0);
+  });
+
+  test('réseau avec traçage (id 3) : 0,14 × BECS × Sh_installation / Sh_logement', () => {
+    const di = { besoin_ecs: 1000 };
+    conso_aux_distribution_ecs(
+      {},
+      {
+        enum_type_installation_id: '2',
+        enum_bouclage_reseau_ecs_id: '3',
+        surface_habitable: 60
+      },
+      di,
+      50,
+      2000,
+      1,
+      1,
+      30
+    );
+    // 0,14 × 1000 × 60 / 50
+    expect(di.conso_auxiliaire_distribution_ecs).toBeCloseTo(168, 10);
+  });
+
+  test("traçage sans surface d'installation : repli sur la surface du logement", () => {
+    const di = { besoin_ecs: 1000 };
+    conso_aux_distribution_ecs(
+      {},
+      { enum_type_installation_id: '2', enum_bouclage_reseau_ecs_id: '3' },
+      di,
+      50,
+      2000,
+      1,
+      1,
+      30
+    );
+    // Sh_install = Sh_logement => 0,14 × 1000
+    expect(di.conso_auxiliaire_distribution_ecs).toBeCloseTo(140, 10);
+  });
+
+  test('réseau bouclé, faible puissance hydraulique : plancher de 20 W', () => {
+    const di = {};
+    // Immeuble réduit au logement (18 m²) et nadeq faible : Phyd ≈ 0,07 W, donc
+    // Pcirb calculée (≈ 2,6 W) passe sous le plancher de 20 W tous les mois.
+    conso_aux_distribution_ecs(
+      {},
+      {
+        enum_type_installation_id: '2',
+        enum_bouclage_reseau_ecs_id: '2',
+        surface_habitable: 18,
+        nombre_niveau_installation_ecs: 1
+      },
+      di,
+      18,
+      18,
+      1,
+      1,
+      1.15
+    );
+    expect(di.conso_auxiliaire_distribution_ecs).toBeCloseTo(CONSO_PLANCHER_20W, 10);
+  });
+
+  test('réseau bouclé : consommation ramenée au prorata Sh_logement / Sh_immeuble', () => {
+    const di = {};
+    // Même régime de plancher (Pcirb ≈ 11 W) : la consommation immeuble (14,88 kWh)
+    // est ramenée à l'appartement, soit un dixième ici.
+    conso_aux_distribution_ecs(
+      {},
+      {
+        enum_type_installation_id: '2',
+        enum_bouclage_reseau_ecs_id: '2',
+        surface_habitable: 50,
+        nombre_niveau_installation_ecs: 1
+      },
+      di,
+      50,
+      500,
+      1,
+      1,
+      0.5
+    );
+    expect(di.conso_auxiliaire_distribution_ecs).toBeCloseTo((CONSO_PLANCHER_20W * 50) / 500, 10);
+  });
+
+  test('réseau bouclé, circulateur au-dessus du plancher de 20 W', () => {
+    const di = {};
+    conso_aux_distribution_ecs(
+      {},
+      {
+        enum_type_installation_id: '2',
+        enum_bouclage_reseau_ecs_id: '2',
+        surface_habitable: 50,
+        nombre_niveau_installation_ecs: 2
+      },
+      di,
+      50,
+      2000,
+      1,
+      1,
+      30
+    );
+    // valeur de référence de régression (Pcirb ≈ 549 W pendant les heures de puisage)
+    expect(di.conso_auxiliaire_distribution_ecs).toBeCloseTo(2.4208575056559525, 9);
+  });
+
+  test('plus de niveaux desservis : bouclage plus court, donc consommation plus faible', () => {
+    const scenario = (Niv) => {
+      const di = {};
+      conso_aux_distribution_ecs(
+        {},
+        {
+          enum_type_installation_id: '2',
+          enum_bouclage_reseau_ecs_id: '2',
+          surface_habitable: 50,
+          nombre_niveau_installation_ecs: Niv
+        },
+        di,
+        50,
+        2000,
+        1,
+        1,
+        30
+      );
+      return di.conso_auxiliaire_distribution_ecs;
+    };
+    // Lb = 4 × (Sh / Niv)^0,5 + 6 × (Niv − 0,5) : sur cet immeuble, Lb décroît avec Niv
+    expect(scenario(1)).toBeCloseTo(2.767218880573735, 9);
+    expect(scenario(4)).toBeCloseTo(2.2222299894932647, 9);
+    expect(scenario(4)).toBeLessThan(scenario(1));
+  });
+
+  test("réseau bouclé sans surface ni nombre de niveaux d'installation : valeurs par défaut", () => {
+    const diDefaut = {};
+    conso_aux_distribution_ecs(
+      {},
+      { enum_type_installation_id: '2', enum_bouclage_reseau_ecs_id: '2' },
+      diDefaut,
+      50,
+      2000,
+      1,
+      1,
+      30
+    );
+    const diExplicite = {};
+    // Sh_install = Sh_logement et Niv = 1
+    conso_aux_distribution_ecs(
+      {},
+      {
+        enum_type_installation_id: '2',
+        enum_bouclage_reseau_ecs_id: '2',
+        surface_habitable: 50,
+        nombre_niveau_installation_ecs: 1
+      },
+      diExplicite,
+      50,
+      2000,
+      1,
+      1,
+      30
+    );
+    expect(diDefaut.conso_auxiliaire_distribution_ecs).toBeCloseTo(
+      diExplicite.conso_auxiliaire_distribution_ecs,
+      10
+    );
+  });
+
+  test("installation desservant tout l'immeuble : Sh_installation étendue à l'immeuble", () => {
+    const di = {};
+    conso_aux_distribution_ecs(
+      {},
+      {
+        enum_type_installation_id: '2',
+        enum_bouclage_reseau_ecs_id: '2',
+        surface_habitable: 2000,
+        nombre_niveau_installation_ecs: 2
+      },
+      di,
+      50,
+      2000,
+      1,
+      1,
+      30
+    );
+    // valeur de référence de régression
+    expect(di.conso_auxiliaire_distribution_ecs).toBeCloseTo(72.84189246242042, 9);
+  });
+});
+
+/**
+ * 15.2.3 - Cas des DPE d'appartement dont `surface_habitable_immeuble` est
+ * renseignée avec la surface du logement : l'échelle de l'immeuble est alors
+ * reconstruite à partir du ratio de virtualisation de l'installation.
+ */
+describe("conso_aux_distribution_ecs - surface d'immeuble incohérente", () => {
+  const RATIO_VIRTUALISATION = 0.0211;
+  const SH_LOGEMENT = 18;
+  // 18 / 0,0211 = 853,08 m²
+  const SH_IMMEUBLE_RECONSTRUITE = SH_LOGEMENT / RATIO_VIRTUALISATION;
+
+  /** @param de {object} @param Sh_immeuble {number} @param nbNiveauImmeuble {number} */
+  const consoEcs = (de, Sh_immeuble, nbNiveauImmeuble) => {
+    const di = {};
+    conso_aux_distribution_ecs(
+      {},
+      {
+        enum_type_installation_id: '2',
+        enum_bouclage_reseau_ecs_id: '2',
+        surface_habitable: SH_LOGEMENT,
+        nombre_niveau_installation_ecs: 1,
+        ...de
+      },
+      di,
+      SH_LOGEMENT,
+      Sh_immeuble,
+      1,
+      1,
+      1.15,
+      nbNiveauImmeuble
+    );
+    return di.conso_auxiliaire_distribution_ecs;
+  };
+
+  test("surface d'immeuble égale à celle du logement : reconstruite via le ratio de virtualisation", () => {
+    const reconstruite = consoEcs(
+      { ratio_virtualisation: String(RATIO_VIRTUALISATION) },
+      SH_LOGEMENT,
+      1
+    );
+
+    // Sans reconstruction, le prorata vaut 1 et le circulateur reste au plancher de 20 W
+    expect(reconstruite).not.toBeCloseTo((31 * 24 * 20) / 1000, 6);
+    expect(reconstruite).toBeCloseTo(0.45766695775765603, 9);
+
+    // Équivalent à une surface d'immeuble correctement renseignée
+    const renseignee = consoEcs({}, SH_IMMEUBLE_RECONSTRUITE, 1);
+    expect(reconstruite).toBeCloseTo(renseignee, 10);
+  });
+
+  test("reconstruction : le nombre de niveaux de l'immeuble prime sur celui de l'installation", () => {
+    // nombre_niveau_installation_ecs = 1 est la valeur du logement, incohérente
+    // avec la surface d'immeuble reconstruite
+    expect(
+      consoEcs({ ratio_virtualisation: String(RATIO_VIRTUALISATION) }, SH_LOGEMENT, 6)
+    ).toBeCloseTo(0.4237342712345093, 9);
+  });
+
+  test("reconstruction sans nombre de niveaux d'immeuble : repli sur celui de l'installation", () => {
+    expect(
+      consoEcs(
+        {
+          ratio_virtualisation: String(RATIO_VIRTUALISATION),
+          nombre_niveau_installation_ecs: 3
+        },
+        SH_LOGEMENT,
+        undefined
+      )
+    ).toBeCloseTo(0.4253220756819142, 9);
+  });
+
+  test('ratio de virtualisation égal à 1 : aucune reconstruction', () => {
+    expect(consoEcs({ ratio_virtualisation: '1' }, SH_LOGEMENT, 6)).toBeCloseTo(
+      (31 * 24 * 20) / 1000,
+      10
+    );
+  });
+
+  test("surface d'immeuble cohérente : le ratio de virtualisation est ignoré", () => {
+    expect(
+      consoEcs({ ratio_virtualisation: String(RATIO_VIRTUALISATION) }, SH_IMMEUBLE_RECONSTRUITE, 6)
+    ).toBeCloseTo(consoEcs({}, SH_IMMEUBLE_RECONSTRUITE, 6), 10);
+  });
+});

package/2021_04_13_confort_ete.spec.js

@@ -15,6 +15,7 @@ vi.mock('./enums.js', () => ({
 }));
 
 vi.mock('./utils.js', () => ({
+  set_bug_for_bug_compat: vi.fn(),
   getKeyByValue: (object, value) => value,
   requestInput: (de, du, field) => de[field]
 }));

package/3.1_b.spec.js

@@ -14,6 +14,7 @@ import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest';
 const state = vi.hoisted(() => ({ bug: false }));
 
 vi.mock('./utils.js', () => ({
+  set_bug_for_bug_compat: vi.fn(),
   tv: vi.fn(),
   requestInputID: (de, du, field) => {
     const enumName = `enum_${field}_id`;

package/3.2.1_mur.spec.js

@@ -24,6 +24,7 @@ vi.mock('./3.1_b.js', () => ({
 }));
 
 vi.mock('./utils.js', () => ({
+  set_bug_for_bug_compat: vi.fn(),
   tv: vi.fn(),
   requestInput: (de, du, field) => de[field],
   requestInputID: (de, du, field) => de[`enum_${field}_id`],

package/3.2.2_plancher_bas.spec.js

@@ -30,6 +30,7 @@ vi.mock('./3.1_b.js', () => ({
 }));
 
 vi.mock('./utils.js', () => ({
+  set_bug_for_bug_compat: vi.fn(),
   tv: vi.fn(),
   requestInput: (de, du, field) => de[field],
   getKeyByValue: (object, value) => Object.keys(object).find((key) => object[key] === value),

package/3.2.3_plancher_haut.spec.js

@@ -23,6 +23,7 @@ vi.mock('./3.1_b.js', () => ({
 }));
 
 vi.mock('./utils.js', () => ({
+  set_bug_for_bug_compat: vi.fn(),
   tv: vi.fn(),
   requestInput: (de, du, field) => de[field],
   getKeyByValue: (object, value) => Object.keys(object).find((key) => object[key] === value),

package/3.3.1.4_porte.spec.js

@@ -11,6 +11,7 @@ vi.mock('./3.1_b.js', () => ({
 }));
 
 vi.mock('./utils.js', () => ({
+  set_bug_for_bug_compat: vi.fn(),
   tv: vi.fn(),
   requestInput: (de, du, field) => de[field]
 }));

package/3.3_baie_vitree.spec.js

@@ -17,6 +17,7 @@ vi.mock('./3.1_b.js', () => ({
 }));
 
 vi.mock('./utils.js', () => ({
+  set_bug_for_bug_compat: vi.fn(),
   tv: vi.fn(),
   requestInput: (de, du, field) => de[field],
   requestInputID: (de, du, field) => de[`enum_${field}_id`],

package/3.4_pont_thermique.spec.js

@@ -27,6 +27,7 @@ vi.mock('lodash-es', () => ({
 const state = vi.hoisted(() => ({ bug: false }));
 
 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,

package/4_ventilation.spec.js

@@ -8,6 +8,7 @@ import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest';
  * - `calc_pvent` (5_conso_ventilation.js) : espion, la conso de ventilation est testée ailleurs.
  */
 vi.mock('./utils.js', () => ({
+  set_bug_for_bug_compat: vi.fn(),
   tv: vi.fn(),
   requestInput: (de, du, field) => de[field],
   requestInputID: (de, du, field) => de[`enum_${field}_id`],

package/5_conso_ventilation.spec.js

@@ -5,6 +5,7 @@ import { beforeEach, describe, expect, test, vi } from 'vitest';
  * d'entrée `de` pour le champ demandé. Cela isole `calc_pvent` de la logique de `utils`.
  */
 vi.mock('./utils.js', () => ({
+  set_bug_for_bug_compat: vi.fn(),
   requestInput: (de, du, field) => de[field]
 }));