@tricoteuses/senat 3.1.10 → 3.1.12

package/lib/src/types/compte_rendu.d.ts

@@ -0,0 +1,83 @@
+export interface CompteRendu {
+    uid: string;
+    seanceRef: string;
+    sessionRef: string;
+    metadonnees: Metadonnees;
+    contenu: Contenu;
+}
+export interface Metadonnees {
+    dateSeance: string;
+    dateSeanceJour: string;
+    numSeanceJour: string;
+    numSeance: string;
+    typeAssemblee: "AN" | "SN";
+    legislature: string;
+    session: string;
+    nomFichierJo: string;
+    validite: string;
+    etat: string;
+    diffusion: string;
+    version: string;
+    environnement: string;
+    heureGeneration: Date;
+    sommaire?: Sommaire;
+}
+export interface Contenu {
+    quantiemes: Quantiemes;
+    ouvertureSeance?: Point[] | Point;
+    point: Point[] | Point;
+    finSeance?: FinSeance;
+    paragraphe?: Point[];
+}
+export interface FinSeance {
+    point: Point;
+}
+export interface Quantiemes {
+    journee: string;
+    session: string;
+}
+export interface Point {
+    ordre_absolu_seance: string;
+    code_grammaire: string;
+    roledebat?: string;
+    orateurs?: {
+        orateur: {
+            nom: string;
+            id: string;
+            qualite: string;
+        };
+    };
+    texte: {
+        _: string;
+    };
+    code_style?: string;
+}
+export interface Texte {
+    _?: string;
+    id_syceron?: string;
+    stime?: string;
+    sup?: string;
+    lienAdt?: Texte[] | Texte;
+}
+export interface Sommaire {
+    presidentSeance: Texte;
+    sommaire1: SommaireElement[] | SommaireElement;
+    sommaire3?: SommaireElement[] | SommaireElement;
+    sommaire2?: SommaireElement[] | SommaireElement;
+    para?: Texte[] | Texte;
+}
+export interface SommaireElement {
+    valeur_pts_odj: string | undefined;
+    titreStruct: TitreStruct;
+    para?: Array<Texte | string> | Texte;
+    sommaire2?: SommaireElement[] | SommaireElement;
+    sommaire3?: SommaireElement[] | SommaireElement;
+    presidentSeance?: Texte[] | Texte;
+    type_debat?: string;
+}
+export interface TitreStruct {
+    id_syceron: string;
+    intitule?: string;
+    sousIntitule?: string;
+    type_debat?: string;
+}

package/lib/src/types/compte_rendu.js

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

package/lib/src/types/debats.d.ts

@@ -0,0 +1,2 @@
+import { debats as Debat, lecassdeb as LecAssDeb } from "../raw_types_schemats/debats";
+export type { Debat, LecAssDeb };

package/lib/src/types/debats.js

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

package/lib/src/types/dosleg.d.ts

@@ -0,0 +1,70 @@
+import { Ass, Aud as AudRaw, Auteur as AuteurRaw, DateSeance as DateSeanceRaw, Deccoc, Denrap, Docatt as DocattRaw, Ecr as EcrRaw, Etaloi, Lecass as LecassRaw, Lecassrap as LecassrapRaw, Lecture as LectureRaw, Loi as LoiRaw, Org, Oritxt, Qua, Rap as RapRaw, Raporg, Scr, Texte as TexteRaw, Typatt, Typlec, Typloi, Typtxt, Typurl } from "../raw_types/dosleg.js";
+import { TxtAmeli } from "../raw_types/ameli.js";
+import { Debats } from "../raw_types/debats.js";
+import { TxtAmeliCustom } from "./ameli.js";
+export type { Deccoc as DecCoc, Denrap as DenRap, Etaloi as EtaLoi, Oritxt as OriTxt, Raporg as RapOrg, Typatt as TypAtt, Typlec as TypLec, Typloi as TypLoi, Typtxt as TypTxt, Typurl as TypUrl, };
+export interface Aud extends AudRaw {
+    org?: Org;
+}
+export interface Auteur extends AuteurRaw {
+    qua?: Qua;
+}
+export interface DateSeance extends DateSeanceRaw {
+    debat?: Debats;
+    scrids?: string[];
+    scrs?: Scr[];
+}
+export interface DocAtt extends DocattRaw {
+    rap?: RapRaw;
+    typatt?: Typatt;
+}
+export interface Ecr extends EcrRaw {
+    aut?: Auteur;
+}
+export interface LecAss extends LecassRaw {
+    ass?: Ass;
+    auds?: Aud[];
+    audcles?: AudRaw["audcle"][];
+    datesSeances?: DateSeance[];
+    datesSeancesCodes?: DateSeanceRaw["code"][];
+    debatdatseas: Date[];
+    lecassraps?: LecAssRap[];
+    lecassrapids?: string[];
+    org?: Org;
+    texcods: TexteRaw["texcod"][];
+    textes?: Texte[];
+}
+export interface LecAssRap extends LecassrapRaw {
+    rap?: RapRaw;
+}
+export interface Lecture extends LectureRaw {
+    typlec?: Typlec;
+    lecassidts?: LecassRaw["lecassidt"][];
+    lecasss?: LecAss[];
+}
+export interface Loi extends LoiRaw {
+    deccoc?: Deccoc;
+    etaloi?: Etaloi;
+    lecidts?: LectureRaw["lecidt"][];
+    lectures?: Lecture[];
+    typloi?: Typloi;
+}
+export interface Rap extends RapRaw {
+    denrap?: Denrap;
+    docattcles?: DocattRaw["docattcle"][];
+    docatts?: DocAtt[];
+    ecrnums?: EcrRaw["ecrnum"][];
+    ecrs?: Ecr[];
+    orgcods?: Raporg["orgcod"][];
+    orgs?: Org[];
+}
+export interface Texte extends TexteRaw {
+    ecrs?: Ecr[];
+    ecrnums?: EcrRaw["ecrnum"][];
+    libtypurl?: Typurl["libtypurl"];
+    org?: Org;
+    oritxt: Oritxt;
+    typtxt?: Typtxt;
+    txtAmeli?: TxtAmeliCustom;
+    txtAmeliId: TxtAmeli["id"];
+}

package/lib/src/types/dosleg.js

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

package/lib/src/types/questions.d.ts

@@ -0,0 +1,2 @@
+import { TamQuestions } from "../raw_types/questions.js";
+export type { TamQuestions as Question };

package/lib/src/types/questions.js

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

package/lib/src/types/sens.d.ts

@@ -0,0 +1,8 @@
+export interface Photo {
+    chemin: string;
+    cheminMosaique: string;
+    hauteur: number;
+    largeur: number;
+    xMosaique: number;
+    yMosaique: number;
+}

package/lib/src/types/sens.js

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

package/lib/src/types/sessions.d.ts

@@ -0,0 +1,6 @@
+export declare const UNDEFINED_SESSION = 0;
+export declare const sessionOptions: readonly [1958, 1959, 1960, 1961, 1962, 1963, 1964, 1965, 1966, 1967, 1968, 1969, 1970, 1971, 1972, 1973, 1974, 1975, 1976, 1977, 1978, 1979, 1980, 1981, 1982, 1983, 1984, 1985, 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023, 2024, 2025, 2026];
+export declare const sessionOptionsOrAll: readonly [0, 1958, 1959, 1960, 1961, 1962, 1963, 1964, 1965, 1966, 1967, 1968, 1969, 1970, 1971, 1972, 1973, 1974, 1975, 1976, 1977, 1978, 1979, 1980, 1981, 1982, 1983, 1984, 1985, 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023, 2024, 2025, 2026];
+export type Session = (typeof sessionOptions)[number];
+export type SessionOrAll = (typeof sessionOptionsOrAll)[number];
+export declare function getSessionsFromStart(startSession: SessionOrAll): (1958 | 1959 | 1960 | 1961 | 1962 | 1963 | 1964 | 1965 | 1966 | 1967 | 1968 | 1969 | 1970 | 1971 | 1972 | 1973 | 1974 | 1975 | 1976 | 1977 | 1978 | 1979 | 1980 | 1981 | 1982 | 1983 | 1984 | 1985 | 1986 | 1987 | 1988 | 1989 | 1990 | 1991 | 1992 | 1993 | 1994 | 1995 | 1996 | 1997 | 1998 | 1999 | 2000 | 2001 | 2002 | 2003 | 2004 | 2005 | 2006 | 2007 | 2008 | 2009 | 2010 | 2011 | 2012 | 2013 | 2014 | 2015 | 2016 | 2017 | 2018 | 2019 | 2020 | 2021 | 2022 | 2023 | 2024 | 2025 | 2026)[];

package/lib/src/types/sessions.js

@@ -0,0 +1,19 @@
+export const UNDEFINED_SESSION = 0;
+export const sessionOptions = [
+    1958, 1959, 1960, 1961, 1962, 1963, 1964, 1965, 1966, 1967, 1968, 1969, 1970, 1971, 1972, 1973, 1974, 1975, 1976,
+    1977, 1978, 1979, 1980, 1981, 1982, 1983, 1984, 1985, 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
+    1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014,
+    2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023, 2024, 2025, 2026,
+    // TO COMPLETE EVERY YEAR :)
+];
+export const sessionOptionsOrAll = [UNDEFINED_SESSION, ...sessionOptions];
+export function getSessionsFromStart(startSession) {
+    if (startSession === UNDEFINED_SESSION) {
+        return Array.from(sessionOptions);
+    }
+    const sessionIndex = sessionOptions.findIndex((session) => startSession === session);
+    if (sessionIndex >= 0) {
+        return sessionOptions.slice(sessionIndex);
+    }
+    return [];
+}

package/lib/src/types/texte.d.ts

@@ -0,0 +1,72 @@
+import { DocumentResult } from "../loaders.js";
+export declare enum DivisionType {
+    tome = 1,
+    part = 2,
+    book = 3,
+    title = 4,
+    subtitle = 5,
+    chapter = 6,
+    section = 7,
+    subsection = 8,
+    paragraph = 9,
+    article = 10,
+    alinea = 11,
+    division = 12
+}
+export type DivisionTag = keyof typeof DivisionType;
+export interface DocumentMetadata {
+    name: string;
+    session: number | null | undefined;
+    date?: string | null;
+    url_expose_des_motifs?: URL;
+    url_xml?: URL;
+    url_html: URL;
+    url_pdf: URL;
+}
+export interface FlatTexte extends Partial<DocumentResult> {
+    titre: string | null;
+    titre_court: string | null;
+    url_dossier_senat: string | null;
+    url_dossier_assemblee: string | null;
+    date_presentation: Date | null;
+    date_depot: Date | null;
+    date_publication_xml: Date | null;
+    version: Version | null;
+    divisions: Division[];
+    expose_motifs?: ExposeDesMotifs | null;
+}
+export type Version = "RECT" | "RECT_BIS" | "RECT_TER" | "RECT_QUATER" | "RECT_QUINQUIES";
+export interface Step {
+    eId: string;
+    date: Date | null;
+    type: string | null;
+    session: string | null;
+    numero: string | null;
+    version: Version | null;
+    outcome: string | null;
+}
+export interface Division {
+    index: number;
+    eId: string;
+    tag: DivisionTag;
+    level: number;
+    headings: DivisionContent[];
+}
+export interface Article extends Division {
+    alineas: Alinea[];
+}
+export interface DivisionContent {
+    text: string | null;
+    html?: string | null;
+}
+export interface Alinea extends DivisionContent {
+    eId: string;
+    heading: DivisionContent;
+    pastille: string | null;
+    text_avec_liens?: string | null;
+    html_avec_liens?: string | null;
+}
+export interface ExposeDesMotifs {
+    text: string | null;
+    html: string | null;
+}

package/lib/src/types/texte.js

@@ -0,0 +1,15 @@
+export var DivisionType;
+(function (DivisionType) {
+    DivisionType[DivisionType["tome"] = 1] = "tome";
+    DivisionType[DivisionType["part"] = 2] = "part";
+    DivisionType[DivisionType["book"] = 3] = "book";
+    DivisionType[DivisionType["title"] = 4] = "title";
+    DivisionType[DivisionType["subtitle"] = 5] = "subtitle";
+    DivisionType[DivisionType["chapter"] = 6] = "chapter";
+    DivisionType[DivisionType["section"] = 7] = "section";
+    DivisionType[DivisionType["subsection"] = 8] = "subsection";
+    DivisionType[DivisionType["paragraph"] = 9] = "paragraph";
+    DivisionType[DivisionType["article"] = 10] = "article";
+    DivisionType[DivisionType["alinea"] = 11] = "alinea";
+    DivisionType[DivisionType["division"] = 12] = "division";
+})(DivisionType || (DivisionType = {}));

package/lib/src/utils/reunion_odj_building.d.ts

@@ -4,6 +4,12 @@ import { AgendaEvent, ReunionOdj } from "../other_types/agenda.js";
 type DossierWithActes = DossierLegislatifResult & {
     actes_legislatifs?: ActeLegislatif[] | null;
 };
-export declare function buildOdj(events: AgendaEvent[], dossierBySenatUrl: Record<string, DossierWithActes>): ReunionOdj | undefined;
+export type DoslegReunionIndex = Map<string, {
+    signet: string;
+    dossier: DossierWithActes;
+    reunionTitre?: string;
+}[]>;
+export declare function buildOdj(events: AgendaEvent[], dossierBySenatUrl: Record<string, DossierWithActes>, doslegReunionIndex?: DoslegReunionIndex): ReunionOdj | undefined;
 export declare function buildSenatDossierIndex(options: commandLineArgs.CommandLineOptions): Record<string, DossierWithActes>;
+export declare function buildDoslegReunionIndex(options: commandLineArgs.CommandLineOptions): DoslegReunionIndex;
 export {};

package/lib/src/utils/reunion_odj_building.js

@@ -1,34 +1,111 @@
 import { getSessionsFromStart } from "../other_types/sessions.js";
 import { iterLoadSenatDossiersLegislatifs } from "../server/loaders.js";
-export function buildOdj(events, dossierBySenatUrl) {
-    const byObjet = new Map(); // objet -> set de dossier uids
-    let codeEtape = null;
-    let dossier = null;
+function normalizeOrganeForMatch(text) {
+    return (text || "")
+        .toLowerCase()
+        .normalize("NFD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .replace(/[^a-z0-9\s]/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+function buildReunionLookupKey(date, organe) {
+    const d = (date || "").split("T")[0];
+    const o = normalizeOrganeForMatch(organe || "");
+    return `${d}|${o}`;
+}
+export function buildOdj(events, dossierBySenatUrl, doslegReunionIndex) {
+    const byObjet = new Map();
+    let lastCodeEtape = null;
+    let lastFlatActes;
     for (const ev of events) {
         const objetKey = (ev.objet ?? "").trim();
         const url = normalizeSenatUrl(ev.urlDossierSenat) ?? undefined;
-        dossier = url ? dossierBySenatUrl[url] : null;
+        let dossier = url ? (dossierBySenatUrl[url] ?? null) : null;
+        if (!dossier && doslegReunionIndex) {
+            dossier = lookupDossierFromDoslegReunion(ev, doslegReunionIndex);
+        }
         const dossierUid = dossier ? pickDossierUid(dossier) : undefined;
-        codeEtape = dossier ? computeCodeEtape(ev, dossier) : null;
-        // si on n’a ni objet ni dossier, ça ne sert à rien de créer un point
+        if (dossier) {
+            lastFlatActes = buildFlatActes(dossier);
+            lastCodeEtape = computeCodeEtape(ev, dossier, lastFlatActes);
+        }
+        else {
+            lastFlatActes = undefined;
+            lastCodeEtape = null;
+        }
         if (!objetKey && !dossierUid)
             continue;
-        if (!byObjet.has(objetKey) && dossierUid) {
-            byObjet.set(objetKey, dossierUid);
+        if (!byObjet.has(objetKey) && dossierUid && dossier) {
+            byObjet.set(objetKey, { dossierUid, dossier, flatActes: lastFlatActes });
         }
     }
     if (byObjet.size === 0)
         return undefined;
     const pointsOdj = [];
-    for (const [objetKey, dossierUid] of byObjet) {
+    for (const [objetKey, { dossierUid, dossier: matchedDossier, flatActes }] of byObjet) {
+        const matchedCodeEtape = lastCodeEtape ?? (matchedDossier ? computeCodeEtapeFromFirstAct(matchedDossier, flatActes) : null);
         pointsOdj.push({
             objet: objetKey || null,
             dossierLegislatifRef: dossierUid || null,
-            codeEtape,
+            codeEtape: matchedCodeEtape,
         });
     }
     return { pointsOdj };
 }
+function scoreCandidate(c, evText) {
+    let score = 0;
+    const dosSignet = c.signet.toLowerCase();
+    if (evText.includes(dosSignet))
+        score += 10;
+    if (c.reunionTitre) {
+        const reunionWords = normalizeOrganeForMatch(c.reunionTitre).split(/\s+/).filter((w) => w.length >= 5);
+        score += reunionWords.filter((w) => evText.includes(w)).length;
+    }
+    const dossierTitre = normalizeOrganeForMatch(c.dossier.titre ?? "");
+    if (dossierTitre && evText.includes(dossierTitre))
+        score += 5;
+    if (dossierTitre) {
+        const words = dossierTitre.split(/\s+/).filter((w) => w.length >= 5);
+        score += words.filter((w) => evText.includes(w)).length;
+    }
+    return score;
+}
+function bestMatch(candidates, evText) {
+    if (candidates.length === 0)
+        return null;
+    const scored = candidates.map((c) => ({ c, score: scoreCandidate(c, evText) }));
+    scored.sort((a, b) => b.score - a.score);
+    return scored[0].score >= 3 ? scored[0].c.dossier : null;
+}
+function lookupDossierFromDoslegReunion(ev, index) {
+    const evDate = (ev.date || "").split("T")[0];
+    const evOrgane = normalizeOrganeForMatch(ev.organe ?? "");
+    const key = buildReunionLookupKey(evDate, ev.organe);
+    const evText = normalizeOrganeForMatch((ev.titre ?? "") + " " + (ev.objet ?? ""));
+    const candidates = index.get(key);
+    if (candidates && candidates.length > 0) {
+        return bestMatch(candidates, evText);
+    }
+    const dateOnlyCandidates = [];
+    for (const [k, v] of index) {
+        if (k.startsWith(evDate + "|") && k !== key) {
+            const kOrgane = k.split("|")[1] || "";
+            if (evOrgane && kOrgane && (evOrgane.includes(kOrgane) || kOrgane.includes(evOrgane))) {
+                dateOnlyCandidates.push(...v);
+            }
+        }
+    }
+    return bestMatch(dateOnlyCandidates, evText);
+}
+function computeCodeEtapeFromFirstAct(dossier, flatActes) {
+    const flat = flatActes ?? buildFlatActes(dossier);
+    if (flat.length === 0)
+        return null;
+    const cleanCode = (code) => code.replace(/-SEANCE$/, "");
+    flat.sort((a, b) => a.date.localeCompare(b.date) || a.codeActe.length - b.codeActe.length);
+    return cleanCode(flat[0].codeActe);
+}
 function pickDossierUid(d) {
     if (d["signet"] && d["signet"].trim())
         return d["signet"].trim();
@@ -62,6 +139,44 @@ export function buildSenatDossierIndex(options) {
     }
     return index;
 }
+export function buildDoslegReunionIndex(options) {
+    const index = new Map();
+    const sessions = getSessionsFromStart(2015);
+    for (const session of sessions) {
+        for (const item of iterLoadSenatDossiersLegislatifs(options["dataDir"], session)) {
+            const dossier = item.item;
+            const signet = dossier.signet?.trim();
+            if (!signet)
+                continue;
+            const lectures = dossier.lectures ?? [];
+            for (const lecture of lectures) {
+                const lecturesAssemblee = lecture.lectures_assemblee ?? [];
+                for (const lecAss of lecturesAssemblee) {
+                    if (lecAss.assemblee !== "Sénat")
+                        continue;
+                    const commissions = lecAss.commissions_saisies ?? [];
+                    for (const commission of commissions) {
+                        const reunions = commission.reunions ?? [];
+                        for (const reunion of reunions) {
+                            if (!reunion.date)
+                                continue;
+                            const key = buildReunionLookupKey(reunion.date, commission.libelle_organisme);
+                            let entries = index.get(key);
+                            if (!entries) {
+                                entries = [];
+                                index.set(key, entries);
+                            }
+                            if (!entries.some((e) => e.signet === signet)) {
+                                entries.push({ signet, dossier, reunionTitre: reunion.titre ?? undefined });
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return index;
+}
 function detectLecture(objet) {
     objet = objet.toLowerCase();
     if (objet.includes("première lecture"))
@@ -72,18 +187,17 @@ function detectLecture(objet) {
         return 3;
     return undefined;
 }
-function computeCodeEtape(ev, dossier) {
-    // In order to match with stage, we need to remove the '-SEANCE' suffix from the codeActe
+function computeCodeEtape(ev, dossier, flatActes) {
     const cleanCode = (code) => code.replace(/-SEANCE$/, "");
     const lecture = detectLecture(ev.objet ?? "");
-    const organe = ev.organe ?? "";
-    const nature = organe.toLowerCase().includes("commission")
+    const organeLower = (ev.organe ?? "").toLowerCase();
+    const nature = organeLower.includes("commission")
         ? "COM"
-        : organe.toLowerCase().includes("séance publique")
+        : organeLower.includes("séance publique")
             ? "DEBATS"
             : "";
     const evDate = ev.date.split("T")[0];
-    const flat = buildFlatActes(dossier);
+    const flat = flatActes ?? buildFlatActes(dossier);
     // 1) Strict matching: same date + same nature
     let candidates = flat.filter((a) => {
         if (a.date !== evDate)
@@ -105,17 +219,26 @@ function computeCodeEtape(ev, dossier) {
         return cleanCode(candidates[0].codeActe);
     }
     // 2) Fallback COM: If no exact date match for a commission event,
-    // take the latest commission act for this lecture on or before the event date.
+    // find the nearest commission act for this lecture (before or after the event date).
     if (nature === "COM") {
-        let comActs = flat.filter((a) => a.codeActe.includes("COM") && a.date <= evDate);
+        let comActs = flat.filter((a) => a.codeActe.includes("COM"));
         if (lecture !== undefined) {
             const byLecture = comActs.filter((a) => a.ordreLecture === lecture);
             if (byLecture.length > 0)
                 comActs = byLecture;
         }
         if (comActs.length > 0) {
-            comActs.sort((a, b) => b.date.localeCompare(a.date) || b.codeActe.length - a.codeActe.length);
-            return cleanCode(comActs[0].codeActe);
+            // Prefer acts on or before the event date (latest first), then closest after
+            const before = comActs.filter((a) => a.date <= evDate);
+            const after = comActs.filter((a) => a.date > evDate);
+            if (before.length > 0) {
+                before.sort((a, b) => b.date.localeCompare(a.date) || b.codeActe.length - a.codeActe.length);
+                return cleanCode(before[0].codeActe);
+            }
+            if (after.length > 0) {
+                after.sort((a, b) => a.date.localeCompare(b.date) || a.codeActe.length - b.codeActe.length);
+                return cleanCode(after[0].codeActe);
+            }
         }
     }
     // 3) Fallback general lecture: if nothing else worked but a lecture is identified,

package/lib/src/utils/reunion_parsing.d.ts

@@ -2,12 +2,13 @@ import { DateTime } from "luxon";
 import type { AnyNode } from "domhandler";
 import { AgendaEvent, Reunion } from "../other_types/agenda.js";
 import { DossierLegislatifResult } from "../rich_types/dosleg.js";
+import { DoslegReunionIndex } from "./reunion_odj_building.js";
 import * as cheerio from "cheerio";
 type KnownType = "SP" | "COM" | "MC" | "OD" | "ID";
-type DossierBySenatUrl = Record<string, DossierLegislatifResult>;
 type ReunionBucket = "IDS" | "IDC" | "IDM" | "IDO" | "IDI";
 type ReunionsByBucket = Record<ReunionBucket, Reunion[]>;
-export declare function buildReunionsByBucket(events: AgendaEvent[], dossierBySenatUrl: DossierBySenatUrl): ReunionsByBucket;
+type DossierBySenatUrl = Record<string, DossierLegislatifResult>;
+export declare function buildReunionsByBucket(events: AgendaEvent[], dossierBySenatUrl: DossierBySenatUrl, doslegReunionIndex?: DoslegReunionIndex): ReunionsByBucket;
 export declare function makeReunionUid(dateISO: string, kind: KnownType, agendaEventId: string, organe?: string | null): string;
 export declare function formatYYYYMMDD(dateYYYYMMDD: string): string;
 export declare function deriveTimesForEvent(ev: AgendaEvent): {

package/lib/src/utils/reunion_parsing.js

@@ -22,7 +22,7 @@ const STOPWORDS = new Set([
     "a",
     "aux",
 ]);
-function toReunion(e, dossierBySenatUrl, uid) {
+function toReunion(e, dossierBySenatUrl, uid, doslegReunionIndex) {
     const date = norm(e.date) ?? e.date;
     const { startISO, endISO } = deriveTimesForEvent(e);
     const startTime = startISO ?? e.startTime ?? null;
@@ -39,11 +39,11 @@ function toReunion(e, dossierBySenatUrl, uid) {
         titre: e.titre,
         objet: e.objet || "",
         events: [e], // TODO remove
-        odj: buildOdj([e], dossierBySenatUrl),
+        odj: buildOdj([e], dossierBySenatUrl, doslegReunionIndex),
         lieu: e.lieu || undefined,
     };
 }
-export function buildReunionsByBucket(events, dossierBySenatUrl) {
+export function buildReunionsByBucket(events, dossierBySenatUrl, doslegReunionIndex) {
     const out = { IDS: [], IDC: [], IDM: [], IDO: [], IDI: [] };
     if (!events?.length)
         return out;
@@ -55,7 +55,7 @@ export function buildReunionsByBucket(events, dossierBySenatUrl) {
         }
         const bucket = typeToSuffixStrict(kind);
         const uid = makeReunionUid(e.date, kind, e.id, e.organe ?? null);
-        out[bucket].push(toReunion(e, dossierBySenatUrl, uid));
+        out[bucket].push(toReunion(e, dossierBySenatUrl, uid, doslegReunionIndex));
     }
     // Tri stable par bucket (date + heure, inconnus à la fin)
     for (const k of Object.keys(out)) {

package/lib/src/validators/config.d.ts

@@ -0,0 +1,9 @@
+import { z } from "zod";
+export declare const configSchema: z.ZodObject<{
+    db: z.ZodObject<{
+        host: z.ZodString;
+        password: z.ZodString;
+        user: z.ZodString;
+        port: z.ZodCoercedNumber<unknown>;
+    }, z.core.$strip>;
+}, z.core.$strip>;

package/lib/src/validators/config.js

@@ -0,0 +1,10 @@
+import { z } from "zod";
+const dbSchema = z.object({
+    host: z.string().trim().min(1, "Must not be empty"),
+    password: z.string().trim().min(1, "Must not be empty"),
+    user: z.string().trim().min(1, "Must not be empty"),
+    port: z.coerce.number().int().min(0).max(65535),
+});
+export const configSchema = z.object({
+    db: dbSchema,
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tricoteuses/senat",
-  "version": "3.1.10",
+  "version": "3.1.12",
   "description": "Handle French Sénat's open data",
   "keywords": [
     "France",