@tricoteuses/senat 3.1.23 → 3.2.0

package/lib/src/index.d.ts

@@ -39,3 +39,5 @@ export type { Session, SessionOrAll } from "./other_types/sessions.js";
 export { UNDEFINED_SESSION, sessionOptions, sessionOptionsOrAll, getSessionsFromStart } from "./other_types/sessions.js";
 export { DivisionType } from "./other_types/texte.js";
 export type { DivisionTag, Version, DocumentMetadata, FlatTexte, Step, Division, Article, DivisionContent, Alinea, ExposeDesMotifs, } from "./other_types/texte.js";
+export type { CollaborateurSenat } from "./other_types/collaborateurs.js";
+export type { PlfBudgetType, PlfLigne, PlfProgramme, PlfMission, PlfCreditsSection } from "./other_types/plf.js";

package/lib/src/other_types/plf.d.ts

@@ -0,0 +1,21 @@
+export type PlfBudgetType = "budgetGeneral" | "budgetsAnnexes" | "comptesSpeciaux";
+export interface PlfLigne {
+    libelle: string;
+    autorisationEngagement?: number;
+    creditPaiement?: number;
+    autorisationEngagementAnnule?: number;
+    creditPaiementAnnule?: number;
+}
+export interface PlfProgramme extends PlfLigne {
+    lignes?: PlfLigne[];
+}
+export interface PlfMission extends PlfLigne {
+    budgetType: PlfBudgetType;
+    programmes: PlfProgramme[];
+}
+export interface PlfCreditsSection {
+    budgetType: PlfBudgetType;
+    libelle: string;
+    missions: PlfMission[];
+    total?: Omit<PlfLigne, "libelle">;
+}

package/lib/src/other_types/plf.js

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

package/lib/src/parsers/collaborateurs.d.ts

@@ -1,44 +1,44 @@
 /**
- * Fonctions pures de parsing du PDF DRH des collaborateurs de sénateurs
+ * Pure functions for parsing the HR PDF listing senators' collaborators
  * (https://www.senat.fr/pubagas/liste_senateurs_collaborateurs.pdf).
  *
- * Le PDF est un tableau à deux colonnes par page :
- *  - "Employeur" (le sénateur) à gauche, ex. "Mme AESCHLIMANN Marie-Do" ;
- *  - "Nom Collaborateur" à droite, ex. "M. CHAREF Dahmane".
- * Une ligne sans employeur prolonge le sénateur précédent.
+ * The PDF is a two-column table per page:
+ *  - "Employeur" (the senator) on the left, e.g. "Mme AESCHLIMANN Marie-Do" ;
+ *  - "Nom Collaborateur" on the right, e.g. "M. CHAREF Dahmane".
+ * A line without an employer extends the previous senator.
  *
- * Pièges traités ici : aucun matricule dans le PDF, prénoms de sénateurs tronqués
- * ("Marie-Do"), noms composés ("DI FOLCO", "MAZENOT CHAPPUY"), accents.
+ * Edge cases handled here: no matricule in the PDF, truncated senator first names
+ * ("Marie-Do"), compound names ("DI FOLCO", "MAZENOT CHAPPUY"), accents.
  */
-/** Élément de texte positionné extrait du PDF (x croissant vers la droite, y croissant vers le haut). */
+/** Positioned text element extracted from the PDF (x goes right, y goes up). */
 export type PdfTextItem = {
     str: string;
     x: number;
     y: number;
     page: number;
 };
-export type PersonneNom = {
+export type PersonName = {
     civilite: string;
     nom: string;
     prenom: string;
 };
-export type LigneCollaborateur = {
-    senateur: PersonneNom;
-    collaborateur: PersonneNom;
+export type CollaboratorRow = {
+    senateur: PersonName;
+    collaborateur: PersonName;
 };
-/** Normalise un texte pour la comparaison : majuscules, sans accents, espaces compactés. */
-export declare function normaliserPourComparaison(valeur: string): string;
+/** Normalizes a string for comparison: uppercase, no accents, compacted spaces. */
+export declare function normalizeForComparison(value: string): string;
 /**
- * Sépare une cellule "Civilité NOM(S) Prénom" en {civilite, nom, prenom}.
- * Les jetons en majuscules de tête forment le nom (gère les noms composés), le reste le prénom.
- * Renvoie null si la cellule n'est pas un nom de personne exploitable.
+ * Splits a "Civility LAST_NAME(S) FirstName" cell into {civilite, nom, prenom}.
+ * Uppercase head tokens form the name (handles compound names), the rest is the first name.
+ * Returns null if the cell is not a usable person name.
  */
-export declare function parseCellulePersonne(cellule: string): PersonneNom | null;
-/** Extrait la date d'édition imprimée en pied de page ("Edition du JJ/MM/AAAA"). */
-export declare function extraireDateEdition(strings: string[]): Date | null;
+export declare function parsePersonCell(cell: string): PersonName | null;
+/** Extracts the edition date printed in the footer ("Edition du JJ/MM/AAAA"). */
+export declare function extractEditionDate(strings: string[]): Date | null;
 /**
- * Reconstruit la liste {sénateur, collaborateur} à partir des éléments de texte positionnés.
- * Parcourt les pages puis les lignes de haut en bas ; mémorise le sénateur courant et lui
- * rattache les collaborateurs des lignes suivantes tant qu'aucun nouvel employeur n'apparaît.
+ * Reconstructs the {senator, collaborator} list from positioned text items.
+ * Iterates pages then lines top to bottom; tracks the current senator and
+ * attaches collaborators from subsequent lines until a new employer appears.
  */
-export declare function construireLignesCollaborateurs(items: PdfTextItem[]): LigneCollaborateur[];
+export declare function buildCollaboratorRows(items: PdfTextItem[]): CollaboratorRow[];

package/lib/src/parsers/collaborateurs.js

@@ -1,22 +1,22 @@
 /**
- * Fonctions pures de parsing du PDF DRH des collaborateurs de sénateurs
+ * Pure functions for parsing the HR PDF listing senators' collaborators
  * (https://www.senat.fr/pubagas/liste_senateurs_collaborateurs.pdf).
  *
- * Le PDF est un tableau à deux colonnes par page :
- *  - "Employeur" (le sénateur) à gauche, ex. "Mme AESCHLIMANN Marie-Do" ;
- *  - "Nom Collaborateur" à droite, ex. "M. CHAREF Dahmane".
- * Une ligne sans employeur prolonge le sénateur précédent.
+ * The PDF is a two-column table per page:
+ *  - "Employeur" (the senator) on the left, e.g. "Mme AESCHLIMANN Marie-Do" ;
+ *  - "Nom Collaborateur" on the right, e.g. "M. CHAREF Dahmane".
+ * A line without an employer extends the previous senator.
  *
- * Pièges traités ici : aucun matricule dans le PDF, prénoms de sénateurs tronqués
- * ("Marie-Do"), noms composés ("DI FOLCO", "MAZENOT CHAPPUY"), accents.
+ * Edge cases handled here: no matricule in the PDF, truncated senator first names
+ * ("Marie-Do"), compound names ("DI FOLCO", "MAZENOT CHAPPUY"), accents.
  */
-// Bandes horizontales des deux colonnes (mesurées sur le PDF : employeur ≈ 147, collaborateur ≈ 285).
-const COLONNE_EMPLOYEUR = { min: 130, max: 225 };
-const COLONNE_COLLABORATEUR = { min: 255, max: 360 };
-const CIVILITES = ["Mme", "M.", "Mlle", "M"];
-// Particules nobiliaires/patronymiques en minuscules, qui font partie du nom quand elles le précèdent
-// (ex. "de CIDRAC", "de LA GONTRIE", "de LEGGE"). Le référentiel Sénat les conserve dans Nom_usuel.
-const PARTICULES = new Set([
+// Horizontal bands of the two columns (measured on the PDF: employer ≈ 147, collaborator ≈ 285).
+const EMPLOYER_COLUMN = { min: 130, max: 225 };
+const COLLABORATOR_COLUMN = { min: 255, max: 360 };
+const CIVILITIES = ["Mme", "M.", "Mlle", "M"];
+// Lowercase nobiliary/patronymic particles that are part of the name when they precede it
+// (e.g. "de CIDRAC", "de LA GONTRIE", "de LEGGE"). The Senate reference keeps them in Nom_usuel.
+const PARTICLES = new Set([
     "de",
     "du",
     "des",
@@ -33,8 +33,8 @@ const PARTICULES = new Set([
     "del",
     "dos",
 ]);
-// Lignes d'en-tête / pied de page à ignorer.
-const LIGNES_IGNOREES = [
+// Header / footer lines to ignore.
+const IGNORED_LINES = [
     /liste des collaborateurs/i,
     /^employeur$/i,
     /^nom collaborateur$/i,
@@ -43,9 +43,9 @@ const LIGNES_IGNOREES = [
     /congé non rémunéré/i,
     /^-\s*\d+\s*-$/,
 ];
-/** Normalise un texte pour la comparaison : majuscules, sans accents, espaces compactés. */
-export function normaliserPourComparaison(valeur) {
-    return valeur
+/** Normalizes a string for comparison: uppercase, no accents, compacted spaces. */
+export function normalizeForComparison(value) {
+    return value
         .normalize("NFD")
         .replace(/\p{Diacritic}/gu, "")
         .toUpperCase()
@@ -53,105 +53,105 @@ export function normaliserPourComparaison(valeur) {
         .replace(/\s+/g, " ")
         .trim();
 }
-function estIgnoree(str) {
+function isIgnored(str) {
     const t = str.trim();
     if (!t)
         return true;
-    return LIGNES_IGNOREES.some((re) => re.test(t));
+    return IGNORED_LINES.some((re) => re.test(t));
 }
 /**
- * Sépare une cellule "Civilité NOM(S) Prénom" en {civilite, nom, prenom}.
- * Les jetons en majuscules de tête forment le nom (gère les noms composés), le reste le prénom.
- * Renvoie null si la cellule n'est pas un nom de personne exploitable.
+ * Splits a "Civility LAST_NAME(S) FirstName" cell into {civilite, nom, prenom}.
+ * Uppercase head tokens form the name (handles compound names), the rest is the first name.
+ * Returns null if the cell is not a usable person name.
  */
-export function parseCellulePersonne(cellule) {
-    const brut = cellule
+export function parsePersonCell(cell) {
+    const raw = cell
         .replace(/\(\*\)/g, "")
         .replace(/\s+/g, " ")
         .trim();
-    if (!brut)
+    if (!raw)
         return null;
     let civilite = "";
-    let reste = brut;
-    for (const civ of CIVILITES) {
-        if (brut === civ)
+    let rest = raw;
+    for (const civ of CIVILITIES) {
+        if (raw === civ)
             return null;
-        if (brut.startsWith(`${civ} `)) {
+        if (raw.startsWith(`${civ} `)) {
             civilite = civ;
-            reste = brut.slice(civ.length + 1).trim();
+            rest = raw.slice(civ.length + 1).trim();
             break;
         }
     }
-    if (!reste)
+    if (!rest)
         return null;
-    const jetons = reste.split(" ");
-    const estMajuscule = (jeton) => {
-        const lettres = jeton.replace(/[^A-Za-zÀ-ÿ]/g, "");
-        return lettres.length > 0 && lettres === lettres.toUpperCase();
+    const tokens = rest.split(" ");
+    const isUppercase = (token) => {
+        const letters = token.replace(/[^A-Za-zÀ-ÿ]/g, "");
+        return letters.length > 0 && letters === letters.toUpperCase();
     };
-    const jetonsNom = [];
+    const nameTokens = [];
     let i = 0;
-    // Particules de tête en minuscules (ex. "de", "de la") faisant partie du nom.
-    while (i < jetons.length && PARTICULES.has(jetons[i].toLowerCase())) {
-        jetonsNom.push(jetons[i]);
+    // Leading lowercase particles (e.g. "de", "de la") that are part of the name.
+    while (i < tokens.length && PARTICLES.has(tokens[i].toLowerCase())) {
+        nameTokens.push(tokens[i]);
         i++;
     }
-    // Puis les jetons du nom en majuscules.
-    while (i < jetons.length && estMajuscule(jetons[i])) {
-        jetonsNom.push(jetons[i]);
+    // Then uppercase name tokens.
+    while (i < tokens.length && isUppercase(tokens[i])) {
+        nameTokens.push(tokens[i]);
         i++;
     }
-    // Une particule seule sans nom en majuscules n'est pas un nom valide : on rétablit.
-    if (jetonsNom.length > 0 && jetonsNom.every((j) => PARTICULES.has(j.toLowerCase()))) {
-        jetonsNom.length = 0;
+    // A lone particle without an uppercase name is not valid: reset.
+    if (nameTokens.length > 0 && nameTokens.every((j) => PARTICLES.has(j.toLowerCase()))) {
+        nameTokens.length = 0;
         i = 0;
     }
-    // Si aucun jeton majuscule (cas inattendu), on prend le premier comme nom.
-    if (jetonsNom.length === 0 && jetons.length > 0) {
-        jetonsNom.push(jetons[0]);
+    // If no uppercase token (unexpected case), take the first as name.
+    if (nameTokens.length === 0 && tokens.length > 0) {
+        nameTokens.push(tokens[0]);
         i = 1;
     }
-    const nom = jetonsNom.join(" ");
-    const prenom = jetons.slice(i).join(" ");
+    const nom = nameTokens.join(" ");
+    const prenom = tokens.slice(i).join(" ");
     if (!nom)
         return null;
     return { civilite, nom, prenom };
 }
-/** Extrait la date d'édition imprimée en pied de page ("Edition du JJ/MM/AAAA"). */
-export function extraireDateEdition(strings) {
+/** Extracts the edition date printed in the footer ("Edition du JJ/MM/AAAA"). */
+export function extractEditionDate(strings) {
     for (const s of strings) {
         const m = s.match(/Edition du\s+(\d{2})\/(\d{2})\/(\d{4})/i);
         if (m) {
-            const [, jj, mm, aaaa] = m;
-            return new Date(Date.UTC(Number(aaaa), Number(mm) - 1, Number(jj)));
+            const [, dd, mm, yyyy] = m;
+            return new Date(Date.UTC(Number(yyyy), Number(mm) - 1, Number(dd)));
         }
     }
     return null;
 }
 /**
- * Reconstruit la liste {sénateur, collaborateur} à partir des éléments de texte positionnés.
- * Parcourt les pages puis les lignes de haut en bas ; mémorise le sénateur courant et lui
- * rattache les collaborateurs des lignes suivantes tant qu'aucun nouvel employeur n'apparaît.
+ * Reconstructs the {senator, collaborator} list from positioned text items.
+ * Iterates pages then lines top to bottom; tracks the current senator and
+ * attaches collaborators from subsequent lines until a new employer appears.
  */
-export function construireLignesCollaborateurs(items) {
-    const utiles = items.filter((it) => !estIgnoree(it.str));
-    // Tri lecture : page croissante, puis y décroissant (haut → bas), puis x croissant (gauche → droite).
-    const tries = [...utiles].sort((a, b) => a.page - b.page || b.y - a.y || a.x - b.x);
-    const lignes = [];
-    let senateurCourant = null;
-    for (const it of tries) {
-        const dansEmployeur = it.x >= COLONNE_EMPLOYEUR.min && it.x <= COLONNE_EMPLOYEUR.max;
-        const dansCollaborateur = it.x >= COLONNE_COLLABORATEUR.min && it.x <= COLONNE_COLLABORATEUR.max;
-        if (dansEmployeur) {
-            const personne = parseCellulePersonne(it.str);
-            if (personne)
-                senateurCourant = personne;
+export function buildCollaboratorRows(items) {
+    const useful = items.filter((it) => !isIgnored(it.str));
+    // Reading order: increasing page, then decreasing y (top → bottom), then increasing x (left → right).
+    const sorted = [...useful].sort((a, b) => a.page - b.page || b.y - a.y || a.x - b.x);
+    const rows = [];
+    let currentSenator = null;
+    for (const it of sorted) {
+        const inEmployer = it.x >= EMPLOYER_COLUMN.min && it.x <= EMPLOYER_COLUMN.max;
+        const inCollaborator = it.x >= COLLABORATOR_COLUMN.min && it.x <= COLLABORATOR_COLUMN.max;
+        if (inEmployer) {
+            const person = parsePersonCell(it.str);
+            if (person)
+                currentSenator = person;
         }
-        else if (dansCollaborateur && senateurCourant) {
-            const collaborateur = parseCellulePersonne(it.str);
+        else if (inCollaborator && currentSenator) {
+            const collaborateur = parsePersonCell(it.str);
             if (collaborateur)
-                lignes.push({ senateur: senateurCourant, collaborateur });
+                rows.push({ senateur: currentSenator, collaborateur });
         }
     }
-    return lignes;
+    return rows;
 }

package/lib/src/parsers/plf/credits.d.ts

@@ -0,0 +1,2 @@
+import { type PlfCreditsSection } from "../../other_types/plf.js";
+export declare function parsePlfCredits(document: Document): PlfCreditsSection[];

package/lib/src/parsers/plf/credits.js

@@ -0,0 +1,171 @@
+import { cleanText, classifyRow, detectEtatDSubSection, etatNumToBudgetType, etatNumToLibelle, isHeaderRow, parseLibelle, rowToMontants, SUBSECTION_DEFINITIONS, } from "./parser_utils.js";
+// ---------------------------------------------------------------------------
+// Table parsing
+// ---------------------------------------------------------------------------
+function parseCreditTable(table) {
+    const missions = [];
+    let currentMission = null;
+    let currentProgramme = null;
+    let tableTotal;
+    const rows = [...table.querySelectorAll("tr")];
+    // Skip header rows: the first row normally has colspan (the "(En euros)" row),
+    // and the second row has the column headers (bold, border-bottom).
+    let dataStartIndex = 0;
+    for (let i = 0; i < rows.length; i++) {
+        const tds = rows[i].querySelectorAll("td");
+        if (tds.length < 2) {
+            dataStartIndex = i + 1;
+            continue;
+        }
+        // Check if this is a header row: border-bottom on first td, or contains header text
+        const firstTdStyle = (tds[0]?.getAttribute("style") ?? "").replace(/[\n\t\r]/g, " ");
+        if (/border-bottom\s*:\s*1px/.test(firstTdStyle) ||
+            isHeaderRow(tds)) {
+            dataStartIndex = i + 1;
+            continue;
+        }
+        // If we have enough td cells, assume we're past headers
+        if (tds.length >= 3) {
+            dataStartIndex = i;
+            break;
+        }
+        dataStartIndex = i + 1;
+    }
+    for (let i = dataStartIndex; i < rows.length; i++) {
+        const tr = rows[i];
+        const tds = tr.querySelectorAll("td");
+        if (tds.length < 3)
+            continue;
+        const kind = classifyRow(tr);
+        const nameText = cleanText(tds[0].textContent ?? "");
+        if (!nameText)
+            continue;
+        if (kind === "total") {
+            tableTotal = rowToMontants(tr);
+            continue;
+        }
+        if (kind === "ligne") {
+            if (currentProgramme) {
+                const ligneLibelle = parseLibelle(tds[0].textContent ?? "");
+                if (ligneLibelle === undefined)
+                    continue;
+                currentProgramme.lignes = currentProgramme.lignes || [];
+                currentProgramme.lignes.push({
+                    libelle: ligneLibelle,
+                    ...rowToMontants(tr),
+                });
+            }
+            continue;
+        }
+        if (kind === "mission") {
+            if (currentMission) {
+                missions.push(currentMission);
+            }
+            const libelle = parseLibelle(tds[0].textContent ?? "");
+            if (libelle === undefined) {
+                currentMission = null;
+                currentProgramme = null;
+                continue;
+            }
+            currentMission = {
+                budgetType: "budgetGeneral",
+                libelle,
+                ...rowToMontants(tr),
+                programmes: [],
+            };
+            currentProgramme = null;
+            continue;
+        }
+        // programme row
+        if (currentMission) {
+            const libelle = parseLibelle(tds[0].textContent ?? "");
+            if (libelle === undefined) {
+                currentProgramme = null;
+                continue;
+            }
+            currentProgramme = {
+                libelle,
+                ...rowToMontants(tr),
+            };
+            currentMission.programmes.push(currentProgramme);
+        }
+        else {
+            // If no mission is active, treat this as a mission with one programme
+            const libelle = parseLibelle(tds[0].textContent ?? "");
+            if (libelle === undefined)
+                continue;
+            currentMission = {
+                budgetType: "budgetGeneral",
+                libelle,
+                ...rowToMontants(tr),
+                programmes: [],
+            };
+        }
+    }
+    if (currentMission) {
+        missions.push(currentMission);
+    }
+    if (missions.length === 0)
+        return null;
+    return { missions, total: tableTotal };
+}
+// ---------------------------------------------------------------------------
+// Main parser
+// ---------------------------------------------------------------------------
+export function parsePlfCredits(document) {
+    const body = document.querySelector("body");
+    if (!body)
+        return [];
+    const etatArticles = [...body.querySelectorAll('article[class="etat"]')];
+    if (etatArticles.length === 0)
+        return [];
+    const results = [];
+    for (const article of etatArticles) {
+        const numEl = article.querySelector(":scope > num");
+        if (!numEl)
+            continue;
+        const num = cleanText(numEl.textContent ?? "");
+        const budgetType = etatNumToBudgetType(num);
+        if (!budgetType)
+            continue;
+        // Find all tables in this etat article
+        const tables = [...article.querySelectorAll("table.alinea-table.etat-tableau")];
+        if (tables.length === 0)
+            continue;
+        // For État D, handle CAS/CCF sub-sections
+        if (budgetType === "comptesSpeciaux") {
+            let fallbackCasIndex = 0;
+            for (const table of tables) {
+                const subsection = detectEtatDSubSection(table) ??
+                    (fallbackCasIndex === 0 ? "cas" : fallbackCasIndex === 1 ? "ccf" : undefined);
+                fallbackCasIndex++;
+                if (!subsection)
+                    continue;
+                const parsed = parseCreditTable(table);
+                if (!parsed)
+                    continue;
+                const def = SUBSECTION_DEFINITIONS[subsection];
+                results.push({
+                    budgetType,
+                    libelle: def.libelle,
+                    missions: parsed.missions.map((m) => ({ ...m, budgetType })),
+                    total: parsed.total,
+                });
+            }
+        }
+        else {
+            // État B or État C: single table
+            const parsed = parseCreditTable(tables[0]);
+            if (!parsed)
+                continue;
+            const libelle = etatNumToLibelle(num) ?? num;
+            results.push({
+                budgetType,
+                libelle,
+                missions: parsed.missions.map((m) => ({ ...m, budgetType })),
+                total: parsed.total,
+            });
+        }
+    }
+    return results;
+}

package/lib/src/parsers/plf/index.d.ts

@@ -0,0 +1 @@
+export { parsePlfCredits } from "./credits.js";

package/lib/src/parsers/plf/index.js

@@ -0,0 +1 @@
+export { parsePlfCredits } from "./credits.js";

package/lib/src/parsers/plf/parser_utils.d.ts

@@ -0,0 +1,18 @@
+import { type PlfBudgetType, type PlfLigne } from "../../other_types/plf.js";
+export declare function cleanText(text: string): string;
+export declare function hasBorderTop(style: string): boolean;
+export declare function hasFontWeightBold(style: string): boolean;
+export declare function hasFontStyleItalic(style: string): boolean;
+export declare function normalizeAmount(text: string): number | undefined;
+export declare function parseLibelle(text: string): string | undefined;
+export declare function etatNumToBudgetType(num: string): PlfBudgetType | undefined;
+export declare function etatNumToLibelle(num: string): string | undefined;
+export type RowKind = "mission" | "programme" | "ligne" | "total" | "unknown";
+export declare function classifyRow(tr: Element): RowKind;
+export declare function rowToMontants(tr: Element): Omit<PlfLigne, "libelle">;
+export declare function isHeaderRow(tds: Iterable<Element>): boolean;
+export type EtatDSubSection = "cas" | "ccf";
+export declare const SUBSECTION_DEFINITIONS: Record<EtatDSubSection, {
+    libelle: string;
+}>;
+export declare function detectEtatDSubSection(table: Element): EtatDSubSection | undefined;