@tricoteuses/senat 3.1.23 → 3.2.0

package/lib/src/scripts/retrieve_collaborateurs.js

@@ -1,51 +1,51 @@
 import fs from "fs-extra";
 import path from "path";
 import { getDocumentProxy } from "unpdf";
-import { construireLignesCollaborateurs, extraireDateEdition, normaliserPourComparaison, } from "../parsers/collaborateurs.js";
+import { buildCollaboratorRows, extractEditionDate, normalizeForComparison, } from "../parsers/collaborateurs.js";
 import { assertExistingDirectory } from "./shared/cli_helpers.js";
 import { iterFilePaths } from "../server/loaders.js";
-const URL_PDF_DEFAUT = "https://www.senat.fr/pubagas/liste_senateurs_collaborateurs.pdf";
+const DEFAULT_PDF_URL = "https://www.senat.fr/pubagas/liste_senateurs_collaborateurs.pdf";
 const USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120 Safari/537.36";
-async function telechargerPdf(url) {
+async function downloadPdf(url) {
     const cookies = new Map();
-    let courant = url;
+    let current = url;
     for (let i = 0; i < 8; i += 1) {
         const headers = { "User-Agent": USER_AGENT };
         if (cookies.size > 0) {
             headers["Cookie"] = [...cookies].map(([k, v]) => `${k}=${v}`).join("; ");
         }
-        const reponse = await fetch(courant, { redirect: "manual", headers });
-        for (const brut of reponse.headers.getSetCookie?.() ?? []) {
-            const [paire] = brut.split(";");
-            const idx = paire.indexOf("=");
+        const response = await fetch(current, { redirect: "manual", headers });
+        for (const raw of response.headers.getSetCookie?.() ?? []) {
+            const [pair] = raw.split(";");
+            const idx = pair.indexOf("=");
             if (idx > 0)
-                cookies.set(paire.slice(0, idx).trim(), paire.slice(idx + 1).trim());
+                cookies.set(pair.slice(0, idx).trim(), pair.slice(idx + 1).trim());
         }
-        if (reponse.status >= 300 && reponse.status < 400) {
-            const location = reponse.headers.get("location");
+        if (response.status >= 300 && response.status < 400) {
+            const location = response.headers.get("location");
             if (!location)
-                throw new Error(`Redirection sans en-tête Location (HTTP ${reponse.status})`);
-            courant = new URL(location, courant).toString();
+                throw new Error(`Redirect without Location header (HTTP ${response.status})`);
+            current = new URL(location, current).toString();
             continue;
         }
-        if (!reponse.ok)
-            throw new Error(`Téléchargement du PDF échoué : HTTP ${reponse.status}`);
-        const buffer = Buffer.from(await reponse.arrayBuffer());
+        if (!response.ok)
+            throw new Error(`PDF download failed: HTTP ${response.status}`);
+        const buffer = Buffer.from(await response.arrayBuffer());
         if (buffer.subarray(0, 5).toString("latin1") !== "%PDF-") {
-            throw new Error("Le contenu téléchargé n'est pas un PDF");
+            throw new Error("Downloaded content is not a PDF");
         }
         return buffer;
     }
-    throw new Error("Trop de redirections lors du téléchargement du PDF DRH");
+    throw new Error("Too many redirects during HR PDF download");
 }
-async function extraireItemsPdf(buffer) {
+async function extractPdfItems(buffer) {
     const pdf = await getDocumentProxy(new Uint8Array(buffer));
     const items = [];
     const strings = [];
     for (let p = 1; p <= pdf.numPages; p += 1) {
         const page = await pdf.getPage(p);
-        const contenu = await page.getTextContent();
-        for (const item of contenu.items) {
+        const content = await page.getTextContent();
+        for (const item of content.items) {
             if (typeof item.str !== "string" || !item.str.trim() || !item.transform)
                 continue;
             items.push({ str: item.str, x: item.transform[4], y: item.transform[5], page: p });
@@ -54,110 +54,110 @@ async function extraireItemsPdf(buffer) {
     }
     return { items, strings };
 }
-function chargerSenateurs(dataDir) {
-    const senateursDir = path.join(dataDir, "sens", "senateurs");
+function loadSenators(dataDir) {
+    const senatorsDir = path.join(dataDir, "sens", "senateurs");
     const files = new Map();
-    const indexParNom = new Map();
-    if (!fs.existsSync(senateursDir))
-        return { files, indexParNom };
-    for (const filePath of iterFilePaths(senateursDir)) {
+    const indexByName = new Map();
+    if (!fs.existsSync(senatorsDir))
+        return { files, indexByName };
+    for (const filePath of iterFilePaths(senatorsDir)) {
         const senator = JSON.parse(fs.readFileSync(filePath, "utf-8"));
         files.set(senator.matricule, senator);
-        const cle = normaliserPourComparaison(senator.nom_usuel);
-        const liste = indexParNom.get(cle);
-        if (liste)
-            liste.push(senator);
+        const key = normalizeForComparison(senator.nom_usuel);
+        const list = indexByName.get(key);
+        if (list)
+            list.push(senator);
         else
-            indexParNom.set(cle, [senator]);
+            indexByName.set(key, [senator]);
     }
-    return { files, indexParNom };
+    return { files, indexByName };
 }
 async function main() {
     const dataDir = process.argv[2];
     assertExistingDirectory(dataDir, "dataDir");
-    // 1. Téléchargement + parsing du PDF
-    console.log(`Téléchargement du PDF DRH : ${URL_PDF_DEFAUT}`);
-    const buffer = await telechargerPdf(URL_PDF_DEFAUT);
-    const { items, strings } = await extraireItemsPdf(buffer);
-    const lignes = construireLignesCollaborateurs(items);
-    const dateEdition = extraireDateEdition(strings);
-    console.log(`PDF lu : ${lignes.length} lignes collaborateur, édition ${dateEdition?.toISOString().slice(0, 10) ?? "inconnue"}`);
-    if (lignes.length === 0) {
-        throw new Error("Aucune ligne collaborateur extraite du PDF : format inattendu, abandon sans modification.");
+    // 1. Download + parse PDF
+    console.log(`Downloading HR PDF: ${DEFAULT_PDF_URL}`);
+    const buffer = await downloadPdf(DEFAULT_PDF_URL);
+    const { items, strings } = await extractPdfItems(buffer);
+    const rows = buildCollaboratorRows(items);
+    const editionDate = extractEditionDate(strings);
+    console.log(`PDF parsed: ${rows.length} collaborator rows, edition ${editionDate?.toISOString().slice(0, 10) ?? "unknown"}`);
+    if (rows.length === 0) {
+        throw new Error("No collaborator rows extracted from PDF: unexpected format, aborting without changes.");
     }
-    // 2. Charger les fichiers sénateurs existants
-    const { indexParNom } = chargerSenateurs(dataDir);
-    if (indexParNom.size === 0) {
-        throw new Error("Aucun fichier sénateur trouvé. Lancez d'abord data:download pour générer les fichiers.");
+    // 2. Load existing senator files
+    const { indexByName } = loadSenators(dataDir);
+    if (indexByName.size === 0) {
+        throw new Error("No senator files found. Run data:download first to generate the files.");
     }
-    // 3. Résoudre les sénateurs du PDF → fichiers
-    let nbEnrichis = 0;
-    let nbNonResolus = 0;
-    // Grouper les collaborateurs par matricule de sénateur
-    const collabsParMatricule = new Map();
-    const nomsNonResolus = new Set();
-    for (const ligne of lignes) {
-        const cleNom = normaliserPourComparaison(ligne.senateur.nom);
-        const candidats = indexParNom.get(cleNom);
-        if (!candidats || candidats.length === 0) {
-            nomsNonResolus.add(`${ligne.senateur.civilite} ${ligne.senateur.nom} ${ligne.senateur.prenom}`.trim());
-            nbNonResolus += 1;
+    // 3. Resolve PDF senators → files
+    let nbEnriched = 0;
+    let nbUnresolved = 0;
+    // Group collaborators by senator matricule
+    const collabsByMatricule = new Map();
+    const unresolvedNames = new Set();
+    for (const row of rows) {
+        const nameKey = normalizeForComparison(row.senateur.nom);
+        const candidates = indexByName.get(nameKey);
+        if (!candidates || candidates.length === 0) {
+            unresolvedNames.add(`${row.senateur.civilite} ${row.senateur.nom} ${row.senateur.prenom}`.trim());
+            nbUnresolved += 1;
             continue;
         }
-        // Désambiguïsation par préfixe de prénom
-        const prenomCible = normaliserPourComparaison(ligne.senateur.prenom);
-        const parPrenom = candidats.filter((c) => normaliserPourComparaison(c.prenom_usuel).startsWith(prenomCible));
+        // Disambiguation by first name prefix
+        const targetFirstName = normalizeForComparison(row.senateur.prenom);
+        const byFirstName = candidates.filter((c) => normalizeForComparison(c.prenom_usuel).startsWith(targetFirstName));
         let senator = null;
-        if (candidats.length === 1) {
-            senator = candidats[0];
+        if (candidates.length === 1) {
+            senator = candidates[0];
         }
-        else if (parPrenom.length === 1) {
-            senator = parPrenom[0];
+        else if (byFirstName.length === 1) {
+            senator = byFirstName[0];
         }
         else {
-            nomsNonResolus.add(`${ligne.senateur.civilite} ${ligne.senateur.nom} ${ligne.senateur.prenom}`.trim());
-            nbNonResolus += 1;
+            unresolvedNames.add(`${row.senateur.civilite} ${row.senateur.nom} ${row.senateur.prenom}`.trim());
+            nbUnresolved += 1;
             continue;
         }
-        let collabs = collabsParMatricule.get(senator.matricule);
+        let collabs = collabsByMatricule.get(senator.matricule);
         if (!collabs) {
             collabs = [];
-            collabsParMatricule.set(senator.matricule, collabs);
+            collabsByMatricule.set(senator.matricule, collabs);
         }
-        // Dédoublonnage
-        const nNom = normaliserPourComparaison(ligne.collaborateur.nom);
-        const nPrenom = normaliserPourComparaison(ligne.collaborateur.prenom);
-        if (!collabs.some((c) => normaliserPourComparaison(c.nom) === nNom && normaliserPourComparaison(c.prenom) === nPrenom)) {
+        // Deduplication
+        const nName = normalizeForComparison(row.collaborateur.nom);
+        const nFirstName = normalizeForComparison(row.collaborateur.prenom);
+        if (!collabs.some((c) => normalizeForComparison(c.nom) === nName && normalizeForComparison(c.prenom) === nFirstName)) {
             collabs.push({
-                civilite: ligne.collaborateur.civilite,
-                nom: ligne.collaborateur.nom,
-                prenom: ligne.collaborateur.prenom,
+                civilite: row.collaborateur.civilite,
+                nom: row.collaborateur.nom,
+                prenom: row.collaborateur.prenom,
             });
         }
     }
-    // 4. Écrire les collaborateurs dans les fichiers sénateurs
-    for (const [matricule, collaborateurs] of collabsParMatricule) {
-        const cheminFichier = path.join(dataDir, "sens", "senateurs", `${matricule}.json`);
-        if (!fs.existsSync(cheminFichier))
+    // 4. Write collaborators into senator files
+    for (const [matricule, collaborateurs] of collabsByMatricule) {
+        const filePath = path.join(dataDir, "sens", "senateurs", `${matricule}.json`);
+        if (!fs.existsSync(filePath))
             continue;
-        const senator = JSON.parse(fs.readFileSync(cheminFichier, "utf-8"));
+        const senator = JSON.parse(fs.readFileSync(filePath, "utf-8"));
         senator.collaborateurs = collaborateurs;
-        fs.writeFileSync(cheminFichier, JSON.stringify(senator, null, 2) + "\n");
-        nbEnrichis += 1;
+        fs.writeFileSync(filePath, JSON.stringify(senator, null, 2) + "\n");
+        nbEnriched += 1;
     }
-    // 5. Nettoyer les collaborateurs des sénateurs absents du PDF
-    const matriculesEnrichis = new Set(collabsParMatricule.keys());
-    const { files: tousLesFichiers } = chargerSenateurs(dataDir);
-    for (const [matricule, senator] of tousLesFichiers) {
-        if (!matriculesEnrichis.has(matricule) && senator.collaborateurs) {
+    // 5. Clean collaborators from senators absent from the PDF
+    const enrichedMatricules = new Set(collabsByMatricule.keys());
+    const { files: allFiles } = loadSenators(dataDir);
+    for (const [matricule, senator] of allFiles) {
+        if (!enrichedMatricules.has(matricule) && senator.collaborateurs) {
             delete senator.collaborateurs;
-            const cheminFichier = path.join(dataDir, "sens", "senateurs", `${matricule}.json`);
-            fs.writeFileSync(cheminFichier, JSON.stringify(senator, null, 2) + "\n");
+            const filePath = path.join(dataDir, "sens", "senateurs", `${matricule}.json`);
+            fs.writeFileSync(filePath, JSON.stringify(senator, null, 2) + "\n");
         }
     }
-    console.log(`${nbEnrichis} sénateur(s) enrichi(s) avec leurs collaborateurs`);
-    if (nomsNonResolus.size > 0) {
-        console.warn(`${nbNonResolus} sénateur(s) du PDF non rattaché(s) : ${[...nomsNonResolus].slice(0, 10).join(", ")}${nomsNonResolus.size > 10 ? "…" : ""}`);
+    console.log(`${nbEnriched} senator(s) enriched with their collaborators`);
+    if (unresolvedNames.size > 0) {
+        console.warn(`${nbUnresolved} PDF senator(s) could not be matched: ${[...unresolvedNames].slice(0, 10).join(", ")}${unresolvedNames.size > 10 ? "…" : ""}`);
     }
 }
 main().catch((error) => {

package/lib/src/scripts/retrieve_documents.js

@@ -5,7 +5,7 @@ import path from "path";
 import { convertSenatXmlToHtml } from "../server/conversion_textes.js";
 import * as git from "../server/git.js";
 import { DATA_ORIGINAL_FOLDER, DATA_TRANSFORMED_FOLDER, ENRICHED_TEXTE_FOLDER, iterLoadSenatRapportUrls, iterLoadSenatTexteUrls, RAPPORT_FOLDER, TEXTE_FOLDER, } from "../server/loaders.js";
-import { parseExposeDesMotifs, parseTexte, parseTexteFromFile } from "../parsers/texte.js";
+import { parseDocument } from "../server/parse_document.js";
 import { getSessionsFromStart, UNDEFINED_SESSION } from "../other_types/sessions.js";
 import { assertExistingDirectory, commonOptions } from "./shared/cli_helpers.js";
 import { ensureAndClearDir, fetchWithRetry, isOptionEmptyOrHasValue } from "./shared/util.js";
@@ -134,21 +134,13 @@ export async function processTexte(texteMetadata, originalTextesDir, transformed
             // Skip re-parsing if the XML was not newly downloaded AND the parsed output already exists
             const needsParsing = !result.skipped || !parsedOutputExists;
             if (needsParsing && (result.buffer !== null || (await fs.pathExists(destPath)))) {
-                await parseDocument(texteMetadata.session, transformedTextesDir, destPath, texteMetadata.name, result.buffer, exposeDesMotifsContent, options);
-                let texteXmlContent = null;
-                if (result.buffer === null && (await fs.pathExists(destPath))) {
-                    texteXmlContent = await fs.readFile(destPath, "utf-8");
+                const texteXml = result.buffer !== null ? textDecoder.decode(result.buffer) : await fs.readFile(destPath, "utf-8");
+                await parseDocument(texteMetadata.session, transformedTextesDir, texteMetadata.name, texteXml, exposeDesMotifsContent ? textDecoder.decode(exposeDesMotifsContent) : null, options);
+                try {
+                    await convertSenatXmlToHtml(texteXml, path.join(enrichedTextesDir, `${texteMetadata.session ?? UNDEFINED_SESSION}`, texteMetadata.name, `${texteMetadata.name}.html`));
                 }
-                else if (result.buffer !== null) {
-                    texteXmlContent = textDecoder.decode(result.buffer);
-                }
-                if (texteXmlContent !== null) {
-                    try {
-                        await convertSenatXmlToHtml(texteXmlContent, path.join(enrichedTextesDir, `${texteMetadata.session ?? UNDEFINED_SESSION}`, texteMetadata.name, `${texteMetadata.name}.html`));
-                    }
-                    catch (error) {
-                        console.error(`Error converting ${texteMetadata.name} to HTML: ${error.message}`);
-                    }
+                catch (error) {
+                    console.error(`Error converting ${texteMetadata.name} to HTML: ${error.message}`);
                 }
             }
             else if (options.verbose) {
@@ -212,37 +204,6 @@ async function processRapports(dataDir, sessions) {
     }
     commitAndPushGit(rapportsDir);
 }
-async function parseDocument(session, transformedTextesDir, textePath, texteName, texteBuffer, exposeDesMotifs = null, options = {}) {
-    if (options.verbose) {
-        console.log(`Parsing texte ${textePath}…`);
-    }
-    let parsedTexte;
-    if (texteBuffer) {
-        const texteXml = textDecoder.decode(texteBuffer);
-        parsedTexte = parseTexte(texteXml);
-    }
-    else {
-        if (!(await fs.pathExists(textePath))) {
-            if (options.verbose) {
-                console.warn(`Skipping parse for missing XML file: ${textePath}`);
-            }
-            return null;
-        }
-        parsedTexte = await parseTexteFromFile(textePath);
-    }
-    if (!parsedTexte)
-        return null;
-    if (exposeDesMotifs) {
-        if (options.verbose) {
-            console.log("Parsing exposé des motifs…");
-        }
-        const exposeDesMotifsHtml = textDecoder.decode(exposeDesMotifs);
-        parsedTexte.expose_motifs = parseExposeDesMotifs(exposeDesMotifsHtml);
-    }
-    const transformedTexteDir = path.join(transformedTextesDir, `${session ?? UNDEFINED_SESSION}`, texteName);
-    await fs.outputJSON(path.join(transformedTexteDir, `${texteName}.json`), parsedTexte, { spaces: 2 });
-    return parsedTexte;
-}
 async function main() {
     const dataDir = assertExistingDirectory(options["dataDir"], "data directory");
     const sessions = getSessionsFromStart((options.fromSession ?? UNDEFINED_SESSION));

package/lib/src/server/parse_document.d.ts

@@ -0,0 +1,5 @@
+import { FlatTexte } from "../other_types/texte.js";
+export type ParseDocumentOptions = {
+    verbose?: boolean;
+};
+export declare function parseDocument(session: number | null | undefined, transformedTextesDir: string, texteName: string, texteXml: string, exposeHtml?: string | null, options?: ParseDocumentOptions): Promise<FlatTexte | null>;

package/lib/src/server/parse_document.js

@@ -0,0 +1,47 @@
+import fs from "fs-extra";
+import { JSDOM } from "jsdom";
+import path from "path";
+import { UNDEFINED_SESSION } from "../other_types/sessions.js";
+import { parseExposeDesMotifs, parseTexte } from "../parsers/texte.js";
+import { parsePlfCredits } from "../parsers/plf/index.js";
+export async function parseDocument(session, transformedTextesDir, texteName, texteXml, exposeHtml = null, options = {}) {
+    if (options.verbose) {
+        console.log(`Parsing texte ${texteName}…`);
+    }
+    let document;
+    try {
+        document = new JSDOM(texteXml, { contentType: "text/xml" }).window.document;
+    }
+    catch (error) {
+        console.error(`Could not parse texte with error ${error.message}`);
+        return null;
+    }
+    const parsedTexte = parseTexte(texteXml, document);
+    if (!parsedTexte)
+        return null;
+    if (exposeHtml) {
+        if (options.verbose) {
+            console.log("Parsing exposé des motifs…");
+        }
+        parsedTexte.expose_motifs = parseExposeDesMotifs(exposeHtml);
+    }
+    const transformedTexteDir = path.join(transformedTextesDir, `${session ?? UNDEFINED_SESSION}`, texteName);
+    await fs.outputJSON(path.join(transformedTexteDir, `${texteName}.json`), parsedTexte, { spaces: 2 });
+    // Parse PLF credits
+    try {
+        const credits = parsePlfCredits(document);
+        if (credits.length > 0) {
+            await fs.outputJSON(path.join(transformedTexteDir, `${texteName}_plf_credits.json`), credits, { spaces: 2 });
+            if (options.verbose) {
+                console.log(`  Parsed ${credits.length} PLF credit section(s) for ${texteName}`);
+            }
+        }
+        else {
+            await fs.remove(path.join(transformedTexteDir, `${texteName}_plf_credits.json`));
+        }
+    }
+    catch {
+        // PLF parsing is best-effort; failures should not block the main text parse
+    }
+    return parsedTexte;
+}

package/lib/tests/collaborateurs.test.js

@@ -1,84 +1,84 @@
 import { describe, expect, it } from "vitest";
-import { construireLignesCollaborateurs, extraireDateEdition, normaliserPourComparaison, parseCellulePersonne, } from "../src/parsers/collaborateurs.js";
-// Bandes x mesurées sur le vrai PDF : employeur ≈ 147, collaborateur ≈ 285.
-const X_EMPLOYEUR = 147;
-const X_COLLABORATEUR = 285;
-/** Construit une page synthétique : pour chaque ligne, [employeur?, collaborateur]. */
-function pageItems(lignes, page = 1) {
+import { buildCollaboratorRows, extractEditionDate, normalizeForComparison, parsePersonCell, } from "../src/parsers/collaborateurs.js";
+// X bands measured on the real PDF: employer ≈ 147, collaborator ≈ 285.
+const X_EMPLOYER = 147;
+const X_COLLABORATOR = 285;
+/** Builds a synthetic page: for each row, [employer?, collaborator]. */
+function pageItems(rows, page = 1) {
     const items = [];
     let y = 700;
-    for (const [employeur, collaborateur] of lignes) {
-        if (employeur)
-            items.push({ str: employeur, x: X_EMPLOYEUR, y, page });
-        items.push({ str: collaborateur, x: X_COLLABORATEUR, y, page });
+    for (const [employer, collaborator] of rows) {
+        if (employer)
+            items.push({ str: employer, x: X_EMPLOYER, y, page });
+        items.push({ str: collaborator, x: X_COLLABORATOR, y, page });
         y -= 15;
     }
     return items;
 }
-describe("parseCellulePersonne", () => {
-    it("sépare civilité, nom et prénom", () => {
-        expect(parseCellulePersonne("M. CHAREF Dahmane")).toEqual({ civilite: "M.", nom: "CHAREF", prenom: "Dahmane" });
-        expect(parseCellulePersonne("Mme OLIVIER Béatrice")).toEqual({
+describe("parsePersonCell", () => {
+    it("splits civility, last name and first name", () => {
+        expect(parsePersonCell("M. CHAREF Dahmane")).toEqual({ civilite: "M.", nom: "CHAREF", prenom: "Dahmane" });
+        expect(parsePersonCell("Mme OLIVIER Béatrice")).toEqual({
             civilite: "Mme",
             nom: "OLIVIER",
             prenom: "Béatrice",
         });
     });
-    it("gère les noms composés (plusieurs jetons en majuscules)", () => {
-        expect(parseCellulePersonne("Mme MAZENOT CHAPPUY Sophie")).toEqual({
+    it("handles compound names (multiple uppercase tokens)", () => {
+        expect(parsePersonCell("Mme MAZENOT CHAPPUY Sophie")).toEqual({
             civilite: "Mme",
             nom: "MAZENOT CHAPPUY",
             prenom: "Sophie",
         });
-        expect(parseCellulePersonne("M. DI FOLCO Camille")).toEqual({ civilite: "M.", nom: "DI FOLCO", prenom: "Camille" });
+        expect(parsePersonCell("M. DI FOLCO Camille")).toEqual({ civilite: "M.", nom: "DI FOLCO", prenom: "Camille" });
     });
-    it("gère les particules nobiliaires en tête de nom (de, de la)", () => {
-        expect(parseCellulePersonne("Mme de CIDRAC Marta")).toEqual({ civilite: "Mme", nom: "de CIDRAC", prenom: "Marta" });
-        expect(parseCellulePersonne("Mme de LA GONTRIE Marie-Pierre")).toEqual({
+    it("handles nobiliary particles at the start of the name (de, de la)", () => {
+        expect(parsePersonCell("Mme de CIDRAC Marta")).toEqual({ civilite: "Mme", nom: "de CIDRAC", prenom: "Marta" });
+        expect(parsePersonCell("Mme de LA GONTRIE Marie-Pierre")).toEqual({
             civilite: "Mme",
             nom: "de LA GONTRIE",
             prenom: "Marie-Pierre",
         });
-        expect(parseCellulePersonne("M. de LEGGE Dominique")).toEqual({
+        expect(parsePersonCell("M. de LEGGE Dominique")).toEqual({
             civilite: "M.",
             nom: "de LEGGE",
             prenom: "Dominique",
         });
-        expect(parseCellulePersonne("Mme APOURCEAU-POLY Cathy")).toEqual({
+        expect(parsePersonCell("Mme APOURCEAU-POLY Cathy")).toEqual({
             civilite: "Mme",
             nom: "APOURCEAU-POLY",
             prenom: "Cathy",
         });
     });
-    it("conserve un prénom tronqué tel quel", () => {
-        expect(parseCellulePersonne("Mme AESCHLIMANN Marie-Do")).toEqual({
+    it("keeps a truncated first name as-is", () => {
+        expect(parsePersonCell("Mme AESCHLIMANN Marie-Do")).toEqual({
             civilite: "Mme",
             nom: "AESCHLIMANN",
             prenom: "Marie-Do",
         });
     });
-    it("ignore le marqueur (*) de congé non rémunéré", () => {
-        expect(parseCellulePersonne("M. DURAND (*) Paul")).toEqual({ civilite: "M.", nom: "DURAND", prenom: "Paul" });
+    it("ignores the (*) unpaid leave marker", () => {
+        expect(parsePersonCell("M. DURAND (*) Paul")).toEqual({ civilite: "M.", nom: "DURAND", prenom: "Paul" });
     });
-    it("renvoie null pour une cellule vide ou une civilité seule", () => {
-        expect(parseCellulePersonne("")).toBeNull();
-        expect(parseCellulePersonne("M.")).toBeNull();
+    it("returns null for an empty cell or civility-only", () => {
+        expect(parsePersonCell("")).toBeNull();
+        expect(parsePersonCell("M.")).toBeNull();
     });
 });
-describe("construireLignesCollaborateurs", () => {
-    it("rattache plusieurs collaborateurs au sénateur courant (report quand l'employeur est vide)", () => {
+describe("buildCollaboratorRows", () => {
+    it("attaches multiple collaborators to the current senator (carry-forward when employer is empty)", () => {
         const items = pageItems([
             ["Mme AESCHLIMANN Marie-Do", "M. CHAREF Dahmane"],
             [null, "M. POURQUERY Alexandre"],
             [null, "M. SEBRIER Valentin"],
             ["M. ALLIZARD Pascal", "Mme OLIVIER Béatrice"],
         ]);
-        const lignes = construireLignesCollaborateurs(items);
-        expect(lignes).toHaveLength(4);
-        expect(lignes.slice(0, 3).every((l) => l.senateur.nom === "AESCHLIMANN")).toBe(true);
-        expect(lignes[3].senateur.nom === "ALLIZARD" && lignes[3].collaborateur.nom === "OLIVIER").toBe(true);
+        const rows = buildCollaboratorRows(items);
+        expect(rows).toHaveLength(4);
+        expect(rows.slice(0, 3).every((r) => r.senateur.nom === "AESCHLIMANN")).toBe(true);
+        expect(rows[3].senateur.nom === "ALLIZARD" && rows[3].collaborateur.nom === "OLIVIER").toBe(true);
     });
-    it("ignore en-têtes, pieds de page et numéros, et gère plusieurs pages", () => {
+    it("ignores headers, footers and page numbers, and handles multiple pages", () => {
         const items = [
             { str: "Liste des collaborateurs par Sénateur", x: 208, y: 760, page: 1 },
             { str: "Employeur", x: 193, y: 740, page: 1 },
@@ -88,28 +88,28 @@ describe("construireLignesCollaborateurs", () => {
             { str: "- 1 -", x: 296, y: 30, page: 1 },
             ...pageItems([["Mme BÉLIM Audrey", "M. BOUCHER Thibault"]], 2),
         ];
-        const lignes = construireLignesCollaborateurs(items);
-        expect(lignes).toHaveLength(2);
-        expect(lignes[0].senateur.nom).toBe("BACCI");
-        expect(lignes[1].senateur.nom).toBe("BÉLIM");
+        const rows = buildCollaboratorRows(items);
+        expect(rows).toHaveLength(2);
+        expect(rows[0].senateur.nom).toBe("BACCI");
+        expect(rows[1].senateur.nom).toBe("BÉLIM");
     });
-    it("n'émet rien tant qu'aucun employeur n'a été rencontré", () => {
-        const orphelin = [{ str: "M. ORPHELIN Jean", x: X_COLLABORATEUR, y: 700, page: 1 }];
-        expect(construireLignesCollaborateurs(orphelin)).toHaveLength(0);
+    it("emits nothing until an employer has been encountered", () => {
+        const orphan = [{ str: "M. ORPHELIN Jean", x: X_COLLABORATOR, y: 700, page: 1 }];
+        expect(buildCollaboratorRows(orphan)).toHaveLength(0);
     });
 });
-describe("extraireDateEdition", () => {
-    it("extrait la date d'édition du pied de page", () => {
-        const date = extraireDateEdition(["…", "Edition du 24/06/2026", "(*) Congé non rémunéré"]);
+describe("extractEditionDate", () => {
+    it("extracts the edition date from the footer", () => {
+        const date = extractEditionDate(["…", "Edition du 24/06/2026", "(*) Congé non rémunéré"]);
         expect(date?.toISOString().slice(0, 10)).toBe("2026-06-24");
     });
-    it("renvoie null si absente", () => {
-        expect(extraireDateEdition(["rien ici"])).toBeNull();
+    it("returns null if absent", () => {
+        expect(extractEditionDate(["nothing here"])).toBeNull();
     });
 });
-describe("normaliserPourComparaison", () => {
-    it("met en majuscules, retire les accents et compacte les espaces", () => {
-        expect(normaliserPourComparaison("  Béatrice   ")).toBe("BEATRICE");
-        expect(normaliserPourComparaison("Bélim")).toBe("BELIM");
+describe("normalizeForComparison", () => {
+    it("uppercases, removes accents and compacts spaces", () => {
+        expect(normalizeForComparison("  Béatrice   ")).toBe("BEATRICE");
+        expect(normalizeForComparison("Bélim")).toBe("BELIM");
     });
 });

package/lib/tests/parsers/parseDocument.test.d.ts

@@ -0,0 +1 @@
+export {};