Apparie amortissements et dépréciations par racine de compte (revue #66)

L'appariement « 28 + suffixe » échouait sur les numéros complétés
(2810000 cherché pour 210000) : l'amortissement partait sur une ligne
orpheline — total exact mais présentation trompeuse — et les 29x
n'étaient jamais appariés. Un 28x/29x sans immobilisation brute
détectée disparaissait en outre entièrement du bilan, tout le bloc
étant sous « if (immoAccounts.length > 0) ».

Appariement par racine : zéros finaux retirés puis 8/9 en 2e position
(281000→210000, 281830→218300, 28183→2183, 291000→210000). Les comptes
réellement orphelins gardent leur ligne propre et restent affichés
même sans immobilisation brute.

Tests de non-régression ajoutés à test:calc — 210000/281000,
218300/281830, dépréciation 29x, 28x orphelin — chacun vu échouer
avant le correctif. Bilan du journal d'exemple byte-identique
avant/après ; npm run test:calc OK.

Author: jcnoir

scripts/generate-statements.js

@@ -270,20 +270,30 @@ function generateBilan(accounts, company, pcgNames, plData) {
   let totalImmoBrut = 0;
   let totalAmort = 0;
 
-  if (immoAccounts.length > 0) {
-    md += '| **ACTIF IMMOBILISE** | | | |\n';
+  // 281/291 suivent la meme ventilation que le compte d'immobilisation (PCG),
+  // mais les exports completent les numeros a 6 chiffres : 281000 amortit
+  // 210000, 281830 amortit 218300, 28183 amortit 2183. On apparie donc par
+  // racine (zeros finaux retires, 8/9 en 2e position retire).
+  const rootOf = (acct) => acct.replace(/0+$/, '') || acct;
+  const immoByRoot = new Map(immoAccounts.map(([acct]) => [rootOf(acct), acct]));
+  const amortByImmo = new Map();
+  const orphanAmort = [];
+  for (const [acct, bal] of amortAccounts) {
+    const amount = round2(bal.credit - bal.debit);
+    const target = immoByRoot.get('2' + rootOf(acct).substring(2));
+    if (target !== undefined) {
+      amortByImmo.set(target, round2((amortByImmo.get(target) || 0) + amount));
+    } else if (Math.abs(amount) > 0.01) {
+      orphanAmort.push([acct, amount]);
+    }
+  }
 
-    const matchedAmort = new Set();
+  if (immoAccounts.length > 0 || orphanAmort.length > 0) {
+    md += '| **ACTIF IMMOBILISE** | | | |\n';
 
     for (const [acct, bal] of immoAccounts) {
       const brut = round2(bal.debit - bal.credit);
-      // Find corresponding amortization account (28 + suffix)
-      const amortAcct = '28' + acct.substring(1);
-      let amort = 0;
-      if (accounts[amortAcct]) {
-        matchedAmort.add(amortAcct);
-        amort = round2(accounts[amortAcct].credit - accounts[amortAcct].debit);
-      }
+      const amort = amortByImmo.get(acct) || 0;
       const net = round2(brut - amort);
       const name = pcgNames[acct] || acct;
 
@@ -292,16 +302,12 @@ function generateBilan(accounts, company, pcgNames, plData) {
       totalAmort += amort;
     }
 
-    // 28x/29x accounts not matched above (subdivided charts use e.g. 281000 for
-    // 210000, and 29x were counted nowhere): own line so the total stays exact
-    for (const [acct, bal] of amortAccounts) {
-      if (matchedAmort.has(acct)) continue;
-      const amort = round2(bal.credit - bal.debit);
-      if (Math.abs(amort) > 0.01) {
-        const name = pcgNames[acct] || acct;
-        md += '|   ' + acct + ' — ' + name + ' | | ' + fmt(amort) + ' | ' + fmt(round2(-amort)) + ' |\n';
-        totalAmort += amort;
-      }
+    // 28x/29x sans immobilisation brute appariee : ligne propre pour que la
+    // depreciation reste visible et que le total actif reste exact
+    for (const [acct, amort] of orphanAmort) {
+      const name = pcgNames[acct] || acct;
+      md += '|   ' + acct + ' — ' + name + ' | | ' + fmt(amort) + ' | ' + fmt(round2(-amort)) + ' |\n';
+      totalAmort += amort;
     }
 
     md += '| **Total actif immobilise** | **' + fmt(totalImmoBrut) + '** | **' + fmt(totalAmort) + '** | **' + fmt(round2(totalImmoBrut - totalAmort)) + '** |\n';
@@ -582,4 +588,8 @@ function main() {
   }
 }
 
-main();
+if (require.main === module) {
+  main();
+}
+
+module.exports = { computeBalances, generatePL, generateBilan, generateBalance };

scripts/test-deterministic-calculations.js

@@ -74,6 +74,73 @@ function testProrata() {
   assert.match(output, /Resultat: 136,99 EUR/);
 }
 
+// ---------------------------------------------------------------------------
+// Bilan : appariement immobilisations / amortissements-depreciations (issue #65)
+// ---------------------------------------------------------------------------
+
+const { generateBilan } = require(path.join(ROOT, "scripts", "generate-statements.js"));
+
+const FIXTURE_COMPANY = {
+  fiscal_year: { start: "2025-01-01", end: "2025-12-31", is_first_year: false },
+};
+
+function runBilan(accounts) {
+  return generateBilan(accounts, FIXTURE_COMPANY, {}, { resultatNet: 0 });
+}
+
+function bilanRow(md, acct) {
+  const line = md.split("\n").find((l) => l.includes(acct + " —"));
+  assert.ok(line, "ligne " + acct + " absente du bilan:\n" + md);
+  return line;
+}
+
+function testBilanAmortComptesCompletes() {
+  // Plan de comptes a 6 chiffres : 281000 amortit 210000 (et non 2810000)
+  const { md } = runBilan({
+    "210000": { debit: 10000, credit: 0 },
+    "281000": { debit: 0, credit: 1200 },
+  });
+  const row = bilanRow(md, "210000");
+  assert.match(row, /1\s?200,00/, "amortissement 281000 non apparie a 210000: " + row);
+  assert.match(row, /8\s?800,00/, "net attendu 8 800,00: " + row);
+  assert.ok(!md.includes("281000 —"), "281000 ne doit pas avoir de ligne separee:\n" + md);
+}
+
+function testBilanAmortSubdivision() {
+  // Subdivision : 281830 amortit 218300
+  const { md } = runBilan({
+    "218300": { debit: 3000, credit: 0 },
+    "281830": { debit: 0, credit: 500 },
+  });
+  const row = bilanRow(md, "218300");
+  assert.match(row, /500,00/, "amortissement 281830 non apparie a 218300: " + row);
+  assert.match(row, /2\s?500,00/, "net attendu 2 500,00: " + row);
+  assert.ok(!md.includes("281830 —"), "281830 ne doit pas avoir de ligne separee:\n" + md);
+}
+
+function testBilanDepreciation29x() {
+  // Depreciation 29x apparie a l'immobilisation correspondante
+  const { md } = runBilan({
+    "210000": { debit: 10000, credit: 0 },
+    "291000": { debit: 0, credit: 700 },
+  });
+  const row = bilanRow(md, "210000");
+  assert.match(row, /700,00/, "depreciation 291000 non appariee a 210000: " + row);
+  assert.match(row, /9\s?300,00/, "net attendu 9 300,00: " + row);
+  assert.ok(!md.includes("291000 —"), "291000 ne doit pas avoir de ligne separee:\n" + md);
+}
+
+function testBilanAmortOrphelin() {
+  // 28x sans immobilisation brute : doit rester visible au bilan, pas disparaitre
+  const { md, totalActif } = runBilan({
+    "281000": { debit: 0, credit: 1200 },
+    "512000": { debit: 1200, credit: 0 },
+  });
+  const row = bilanRow(md, "281000");
+  assert.match(row, /1\s?200,00/, "amortissement orphelin absent: " + row);
+  assert.strictEqual(totalActif, 0, "total actif attendu 0 (1200 - 1200): " + totalActif);
+}
+
 function main() {
   testCCA();
   testAmortissementLineaire();
@@ -83,6 +150,10 @@ function main() {
   testISProratedReducedRate();
   testTVAAcomptesRS();
   testProrata();
+  testBilanAmortComptesCompletes();
+  testBilanAmortSubdivision();
+  testBilanDepreciation29x();
+  testBilanAmortOrphelin();
   console.log("Deterministic calculation tests passed.");
 }