@open3cl/engine 1.6.0 → 1.6.2

package/index.spec.js

@@ -0,0 +1,54 @@
+import { describe, expect, test, vi } from 'vitest';
+
+/**
+ * `index.js` est un simple point d'entrée qui ré-exporte des fonctions/valeurs
+ * provenant de `engine.js` et `3_deperdition.js`. On mocke ces deux modules avec
+ * des identités reconnaissables afin de vérifier que chaque symbole est bien
+ * ré-exporté tel quel (même référence).
+ */
+vi.mock('./engine.js', () => ({
+  calcul_3cl: vi.fn(),
+  calcul_3cl_xml: vi.fn(),
+  get_classe_ges_dpe: vi.fn(),
+  get_conso_coeff_1_9_2026: vi.fn(),
+  getVersion: vi.fn()
+}));
+
+vi.mock('./3_deperdition.js', () => ({
+  default: vi.fn(),
+  Umur: vi.fn(),
+  Uph: vi.fn(),
+  Upb: vi.fn(),
+  Uporte: vi.fn(),
+  Ubv: vi.fn(),
+  Upt: vi.fn()
+}));
+
+const index = await import('./index.js');
+const engine = await import('./engine.js');
+const deperdition = await import('./3_deperdition.js');
+
+describe('index - ré-exports depuis engine.js', () => {
+  test.each(['calcul_3cl', 'calcul_3cl_xml', 'get_classe_ges_dpe', 'getVersion'])(
+    "ré-exporte %s à l'identique depuis engine.js",
+    (nom) => {
+      expect(index[nom]).toBe(engine[nom]);
+      expect(typeof index[nom]).toBe('function');
+    }
+  );
+});
+
+describe('index - ré-exports depuis 3_deperdition.js', () => {
+  test.each(['Umur', 'Uph', 'Upb', 'Uporte', 'Ubv', 'Upt'])(
+    "ré-exporte %s à l'identique depuis 3_deperdition.js",
+    (nom) => {
+      expect(index[nom]).toBe(deperdition[nom]);
+      expect(typeof index[nom]).toBe('function');
+    }
+  );
+
+  test("ne ré-exporte pas l'export par défaut de 3_deperdition.js", () => {
+    // index.js n'expose que les exports nommés Umur, Uph, ...
+    expect(index.default).toBeUndefined();
+  });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open3cl/engine",
-  "version": "1.6.0",
+  "version": "1.6.2",
   "description": "Open Source 3CL-DPE engine",
   "main": "index.js",
   "directories": {
@@ -14,7 +14,10 @@
   "scripts": {
     "http-server": "http-server",
     "test": "vitest run",
-    "test:ci": "vitest run --coverage",
+    "test:unit": "vitest run src",
+    "test:unit:ci": "vitest run src --coverage",
+    "test:int": "vitest run test",
+    "test:int:ci": "vitest run test --coverage",
     "test:corpus": "node test/corpus/run_all_corpus_checks.js",
     "test:corpus:all": "node test/corpus/run_all_corpus_checks.js",
     "test:corpus:all+database": "npm run test:corpus:all && node test/corpus/corpus_database.js",

package/preprocessor/index.js

@@ -0,0 +1,20 @@
+/**
+ * Pré-traitement du DPE d'entrée.
+ *
+ * Placeholder minimal : la migration vers la nouvelle architecture `features/` prévoit un
+ * pré-processeur chargé de redresser / compléter les données d'entrée avant calcul. Tant que
+ * cette étape n'est pas implémentée, `preprocess` est un no-op qui laisse le DPE inchangé.
+ *
+ * Ce module existe pour que {@link DpeNormalizerService} soit chargeable (son import était cassé,
+ * pointant vers un fichier inexistant). Il n'est pas câblé dans le moteur legacy (`engine.js`).
+ */
+export class DpePreProcessor {
+  /**
+   * @param dpe {Dpe} DPE à pré-traiter (modifié sur place)
+   * @return {void}
+   */
+  preprocess(dpe) {
+    // no-op : voir la description du module
+    return dpe;
+  }
+}

package/preprocessor/index.spec.js

@@ -0,0 +1,15 @@
+import { describe, expect, test } from 'vitest';
+import { DpePreProcessor } from './index.js';
+
+describe('Pré-processeur du DPE (DpePreProcessor)', () => {
+  test('preprocess est un no-op : renvoie le DPE inchangé (même référence)', () => {
+    const preProcessor = new DpePreProcessor();
+    const dpe = { logement: { enveloppe: {} } };
+
+    const resultat = preProcessor.preprocess(dpe);
+
+    // Placeholder : le DPE est renvoyé tel quel, sans copie ni mutation.
+    expect(resultat).toBe(dpe);
+    expect(resultat).toEqual({ logement: { enveloppe: {} } });
+  });
+});

package/tv.spec.js

@@ -0,0 +1,38 @@
+import { describe, expect, test } from 'vitest';
+
+/**
+ * `tv.js` ne contient que des données : le catalogue des tables de valeurs
+ * du DPE 3CL. On vérifie ici uniquement la structure des exports (export nommé
+ * `tvs` + export par défaut identique) et quelques invariants de forme, sans
+ * dépendre de la valeur métier des tables.
+ */
+const { tvs, default: tvsDefault } = await import('./tv.js');
+
+describe('tv - structure des exports', () => {
+  test('exporte un objet non vide `tvs`', () => {
+    expect(tvs).toBeTypeOf('object');
+    expect(tvs).not.toBeNull();
+    expect(Object.keys(tvs).length).toBeGreaterThan(0);
+  });
+
+  test("l'export par défaut est la même référence que l'export nommé", () => {
+    expect(tvsDefault).toBe(tvs);
+  });
+});
+
+describe('tv - forme des tables', () => {
+  test('la table coef_reduction_deperdition est un tableau de lignes indexées', () => {
+    const table = tvs.coef_reduction_deperdition;
+    expect(Array.isArray(table)).toBe(true);
+    expect(table.length).toBeGreaterThan(0);
+    // chaque ligne possède son identifiant de table de valeur
+    expect(table[0]).toHaveProperty('tv_coef_reduction_deperdition_id');
+  });
+
+  test('toutes les valeurs de premier niveau sont des objets (tableaux ou dictionnaires)', () => {
+    for (const [nom, table] of Object.entries(tvs)) {
+      expect(table, `table ${nom}`).toBeTypeOf('object');
+      expect(table, `table ${nom}`).not.toBeNull();
+    }
+  });
+});

package/utils.js

@@ -2,6 +2,7 @@ import enums from './enums.js';
 import tvs from './tv.js';
 import { set } from 'lodash-es';
 import { XMLParser } from 'fast-xml-parser';
+import { evaluate } from 'mathjs';
 
 export const xmlParser = new XMLParser({
   // We want to make sure collections of length 1 are still parsed as arrays
@@ -473,6 +474,44 @@ export function containsAnySubstring(mainString, substrings) {
   );
 }
 
+/**
+ * Évalue une formule de type tableur issue des tables de valeurs des générateurs à combustion
+ * (ex. `Pn * (E + F * logPn) / 100`, `84 + 2 logPn`).
+ *
+ * Une valeur numérique est retournée telle quelle. Sinon la formule est évaluée avec les
+ * variables suivantes :
+ *   - `Pn`    : puissance nominale exprimée en kW (l'argument `pn` est fourni en W, donc divisé
+ *               par 1000),
+ *   - `logPn` : logarithme décimal de `Pn`,
+ *   - `E`, `F`: coefficients forfaitaires (présence ou non d'une ventouse).
+ *
+ * @param formulaOrValue {string|number} Formule tableur ou valeur numérique.
+ * @param pn {number} Puissance nominale en W.
+ * @param E {number} [Coefficient forfaitaire E]
+ * @param F {number} [Coefficient forfaitaire F]
+ * @returns {number} Résultat de l'évaluation.
+ */
+export function excel_to_js_exec(formulaOrValue, pn, E, F) {
+  // Les formules des tables utilisent la virgule comme séparateur décimal (ex. `0,085`),
+  // à convertir en point pour être évaluées.
+  const formula =
+    typeof formulaOrValue === 'string'
+      ? formulaOrValue.replace(/(\d),(\d)/g, '$1.$2')
+      : formulaOrValue;
+
+  if (!isNaN(formula)) {
+    return Number(formula);
+  }
+
+  const Pn = pn / 1000;
+  return evaluate(formula, {
+    Pn,
+    logPn: Math.log10(Pn),
+    E,
+    F
+  });
+}
+
 /**
  * Conversion des expressions du type `70 < Pn <= 400` en (70 < Pn) && (Pn <= 400)
  * @param expression {string}
@@ -504,7 +543,7 @@ export function getRange(inputNumber, ranges) {
 
   ranges.sort();
 
-  if (inputNumber <= ranges[0]) {
+  if (inputNumber < ranges[0]) {
     result.push(ranges[0]);
     result.push(ranges[1]);
     return result;
@@ -519,11 +558,14 @@ export function getRange(inputNumber, ranges) {
   } else {
     ranges.find((range, index) => {
       if (inputNumber < range) {
+        /* c8 ignore start -- branche défensive inatteignable : inputNumber < ranges[0] provoque
+           déjà le retour anticipé en amont, donc index vaut toujours > 0 ici. */
         if (index > 0) {
           result.push(ranges[index - 1]);
         } else {
           result.push(ranges[index]);
         }
+        /* c8 ignore stop */
         result.push(ranges[index]);
         return true;
       }