@tricoteuses/senat 2.10.0 → 2.10.2

package/lib/types/compte_rendu.d.ts

@@ -20,7 +20,7 @@ export interface Metadonnees {
     version: string;
     environnement: string;
     heureGeneration: Date;
-    sommaire: Sommaire;
+    sommaire?: Sommaire;
 }
 export interface Contenu {
     quantiemes: Quantiemes;

package/lib/utils/cr_spliting.d.ts

@@ -0,0 +1,7 @@
+import { TimeSlot } from "../types/agenda";
+import * as cheerio from "cheerio";
+export declare function computeIntervalsBySlot($: cheerio.CheerioAPI, idx: Map<any, number>, firstSlotOfDay?: TimeSlot): {
+    slot: TimeSlot;
+    start: number;
+    end: number;
+}[];

package/lib/utils/cr_spliting.js

@@ -0,0 +1,125 @@
+export function computeIntervalsBySlot($, idx, firstSlotOfDay) {
+    const all = $("body *").toArray();
+    const cuts = [{ pos: 0, hhmm: undefined }];
+    $('a[name]').each((_, a) => {
+        const name = (a.attribs?.["name"] || "").trim();
+        if (!/^su/i.test(name))
+            return;
+        const pos = idx.get(a);
+        if (pos == null)
+            return;
+        const hhmm = hhmmFromSuName(name); // "SU1620" -> "1620"
+        cuts.push({ pos, hhmm });
+    });
+    cuts.sort((a, b) => a.pos - b.pos);
+    cuts.push({ pos: all.length, hhmm: undefined });
+    let initialSlot = firstSlotOfDay;
+    if (!initialSlot) {
+        const openHHMM = extractOpeningHHMM($);
+        if (openHHMM)
+            initialSlot = slotOfHHMM(openHHMM);
+    }
+    if (!initialSlot)
+        initialSlot = "MATIN";
+    const intervals = [];
+    let lastSlot = initialSlot;
+    for (let i = 0; i + 1 < cuts.length; i++) {
+        const start = cuts[i].pos;
+        const end = cuts[i + 1].pos;
+        if (end <= start)
+            continue;
+        // i=0  initialSlot
+        // i>0 : if current cut has SU -> slotOfHHMM, otherwise lastSlot
+        const slot = i === 0 ? initialSlot : (cuts[i].hhmm ? slotOfHHMM(cuts[i].hhmm) : lastSlot);
+        intervals.push({ slot, start, end });
+        lastSlot = slot;
+    }
+    return intervals;
+}
+function hhmmFromSuName(name) {
+    const m = name.match(/^SU(\d{2})(\d{2})$/i);
+    if (!m)
+        return;
+    return `${m[1]}:${m[2]}`;
+}
+function slotOfHHMM(hhmm) {
+    if (!hhmm)
+        return "MATIN";
+    const [h, m] = hhmm.split(":").map(Number);
+    const v = h + m / 60;
+    if (v < 12)
+        return "MATIN";
+    if (v < 18.5)
+        return "APRES-MIDI";
+    return "SOIR";
+}
+// Looks for text like "(La séance est ouverte à quinze heures.)" and extracts "HH:MM"
+function extractOpeningHHMM($) {
+    let txt = "";
+    $("span.info_entre_parentheses, .info_entre_parentheses").each((_, el) => {
+        const t = ($(el).text() || "").replace(/\s+/g, " ").trim();
+        if (!txt && /\bs[eé]ance est ouverte\b/i.test(t))
+            txt = t;
+    });
+    if (!txt)
+        return undefined;
+    const inner = txt.match(/\(.*?ouverte\s+à\s+([^)]+?)\)/i)?.[1];
+    if (!inner)
+        return undefined;
+    return parseFrenchClockToHHMM(inner);
+}
+// Convert "quinze heures trente", "15 heures 30", "dix-sept heures moins le quart", etc. en "HHMM"
+function parseFrenchClockToHHMM(input) {
+    const s = (input || "").toLowerCase().normalize("NFKD").replace(/[\u0300-\u036f]/g, "").trim();
+    if (!s)
+        return undefined;
+    const digitMatch = s.match(/(\d{1,2})\s*heures?(?:\s*(\d{1,2}))?/);
+    if (digitMatch) {
+        const h = Math.min(24, Math.max(0, parseInt(digitMatch[1], 10)));
+        const m = digitMatch[2] ? Math.min(59, Math.max(0, parseInt(digitMatch[2], 10))) : 0;
+        return `${String(h).padStart(2, "0")}${String(m).padStart(2, "0")}`;
+    }
+    const NUM = new Map([
+        ["zero", 0], ["une", 1], ["un", 1], ["deux", 2], ["trois", 3], ["quatre", 4], ["cinq", 5], ["six", 6],
+        ["sept", 7], ["huit", 8], ["neuf", 9], ["dix", 10], ["onze", 11], ["douze", 12], ["treize", 13],
+        ["quatorze", 14], ["quinze", 15], ["seize", 16], ["dix-sept", 17], ["dix sept", 17], ["dix-huit", 18],
+        ["dix huit", 18], ["dix-neuf", 19], ["dix neuf", 19], ["vingt", 20], ["vingt et une", 21],
+        ["vingt-et-une", 21], ["vingt et un", 21], ["vingt-et-un", 21], ["vingt-deux", 22], ["vingt deux", 22],
+        ["vingt-trois", 23], ["vingt trois", 23], ["vingt-quatre", 24], ["vingt quatre", 24],
+    ]);
+    const hourWordMatch = s.match(/([a-z\- ]+?)\s*heures?/);
+    if (!hourWordMatch)
+        return undefined;
+    const hourWord = hourWordMatch[1].trim();
+    let hour = NUM.get(hourWord);
+    if (hour == null) {
+        const cleaned = hourWord.replace(/\s+/g, " ");
+        hour = NUM.get(cleaned);
+    }
+    if (hour == null)
+        return undefined;
+    let minutes = 0;
+    if (/\bet (demie|demi)\b/.test(s))
+        minutes = 30;
+    else if (/\bet quart\b/.test(s))
+        minutes = 15;
+    else if (/\bmoins le quart\b/.test(s)) {
+        hour = (hour + 23) % 24;
+        minutes = 45;
+    }
+    else {
+        const MIN = new Map([
+            ["cinq", 5], ["dix", 10], ["quinze", 15], ["vingt", 20], ["vingt-cinq", 25], ["vingt cinq", 25],
+            ["trente", 30], ["trente-cinq", 35], ["trente cinq", 35], ["quarante", 40], ["quarante-cinq", 45],
+            ["quarante cinq", 45], ["cinquante", 50], ["cinquante-cinq", 55], ["cinquante cinq", 55],
+        ]);
+        const minWordMatch = s.match(/heures?\s+([a-z\- ]+?)(?:[).,;]|$)/);
+        if (minWordMatch) {
+            const mw = minWordMatch[1].trim();
+            const m1 = MIN.get(mw);
+            if (m1 != null)
+                minutes = m1;
+        }
+    }
+    return `${String(hour).padStart(2, "0")}${String(minutes).padStart(2, "0")}`;
+}

package/lib/utils/reunion_grouping.d.ts

@@ -0,0 +1,6 @@
+import { AgendaEvent, GroupedReunion, TimeSlot } from "../types/agenda";
+export declare function groupNonSPByTypeOrganeHour(events: AgendaEvent[]): Record<"IDC" | "IDM" | "IDO" | "IDI", GroupedReunion[]>;
+export declare function groupSeancePubliqueBySlot(events: AgendaEvent[]): GroupedReunion[];
+export declare function makeGroupUid(date: string, slot: TimeSlot): string;
+export declare function formatYYYYMMDD(dateYYYYMMDD: string): string;
+export declare function makeReunionUid(agenda: AgendaEvent): string;

package/lib/utils/reunion_grouping.js

@@ -0,0 +1,359 @@
+import { DateTime } from "luxon";
+import { norm } from "../model/util";
+const PARIS = "Europe/Paris";
+const STOPWORDS = new Set([
+    "de", "du", "des",
+    "la", "le", "les", "l",
+    "d",
+    "et",
+    "en",
+    "au", "aux",
+    "pour",
+    "sur", "sous", "à", "a", "aux",
+]);
+export function groupNonSPByTypeOrganeHour(events) {
+    const out = { IDC: [], IDM: [], IDO: [], IDI: [] };
+    if (!events?.length)
+        return out;
+    const nonSP = events.filter(e => !isSeancePublique(e?.type));
+    if (nonSP.length === 0)
+        return out;
+    const buckets = new Map();
+    for (const e of nonSP) {
+        const kind = classifyAgendaType(e?.type);
+        if (!kind || kind === "SP")
+            continue;
+        const { startISO, endISO } = deriveTimesForEvent(e);
+        const hourShort = hourShortFromISO(startISO) ?? hourShortFromOriginal(e.timeOriginal);
+        const key = [e.date, kind, hourShort || "NA"].join("|");
+        if (!buckets.has(key))
+            buckets.set(key, []);
+        buckets.get(key).push({ ...e, startTime: startISO ?? e.startTime, endTime: endISO ?? e.endTime });
+    }
+    for (const [key, list] of buckets) {
+        const [date, kindStr, hourShort] = key.split("|");
+        const kind = kindStr;
+        const enriched = list.map(ev => {
+            const { startISO, endISO } = deriveTimesForEvent(ev);
+            return { ev, startISO: startISO ?? ev.startTime, endISO: endISO ?? ev.endTime };
+        }).sort((a, b) => {
+            const ta = a.startISO ? parseISO(a.startISO)?.toMillis() ?? Number.MAX_SAFE_INTEGER : Number.MAX_SAFE_INTEGER;
+            const tb = b.startISO ? parseISO(b.startISO)?.toMillis() ?? Number.MAX_SAFE_INTEGER : Number.MAX_SAFE_INTEGER;
+            return ta - tb;
+        });
+        const startTime = enriched.find(x => !!x.startISO)?.startISO ?? null;
+        const endTime = enriched.reduce((acc, x) => {
+            const de = x.endISO ? parseISO(x.endISO)?.toMillis() : null;
+            const accMs = acc ? parseISO(acc)?.toMillis() : null;
+            if (de != null && (accMs == null || de > accMs))
+                return x.endISO;
+            return acc;
+        }, null);
+        const any = enriched[0]?.ev;
+        const hour = hourShort !== "NA" ? hourShort : (hourShortFromISO(startTime) ?? hourShortFromOriginal(any?.timeOriginal));
+        const uid = makeTypeGroupUid(date, kind, hour ?? null, any?.organe || undefined);
+        const suffix = (kind === "COM" ? "IDC" : kind === "MC" ? "IDM" : kind === 'OD' ? 'IDO' : "IDI");
+        const group = {
+            uid,
+            chambre: "SN",
+            date,
+            type: any?.type || "",
+            organe: any?.organe || undefined,
+            startTime,
+            endTime,
+            captationVideo: enriched.some(x => x.ev.captationVideo === true),
+            titre: compactTitleList(enriched.map(x => x.ev.titre || "").filter(Boolean), 8),
+            objet: joinObjets(enriched.map(x => x.ev)),
+            events: enriched.map(x => x.ev),
+        };
+        out[suffix].push(group);
+    }
+    for (const k of Object.keys(out)) {
+        out[k].sort((a, b) => {
+            const da = DateTime.fromISO(`${a.date}T${a.startTime || "00:00:00.000+02:00"}`, { zone: PARIS }).toMillis();
+            const db = DateTime.fromISO(`${b.date}T${b.startTime || "00:00:00.000+02:00"}`, { zone: PARIS }).toMillis();
+            return da - db || (a.organe || "").localeCompare(b.organe || "");
+        });
+    }
+    return out;
+}
+export function groupSeancePubliqueBySlot(events) {
+    if (!events?.length)
+        return [];
+    const sp = events.filter(e => isSeancePublique(e?.type));
+    if (sp.length === 0)
+        return [];
+    const byDate = new Map();
+    for (const e of sp) {
+        const d = norm(e.date);
+        if (!d)
+            continue;
+        if (!byDate.has(d))
+            byDate.set(d, []);
+        byDate.get(d).push(e);
+    }
+    const out = [];
+    for (const [date, dayEvents] of byDate) {
+        const enriched = dayEvents.map((e) => {
+            const { startISO, endISO, slot } = deriveTimesForEvent(e);
+            return { ev: e, startISO, endISO, slot };
+        });
+        enriched.sort((a, b) => {
+            const da = a.startISO ? parseISO(a.startISO)?.toMillis() ?? Number.MAX_SAFE_INTEGER : Number.MAX_SAFE_INTEGER;
+            const db = b.startISO ? parseISO(b.startISO)?.toMillis() ?? Number.MAX_SAFE_INTEGER : Number.MAX_SAFE_INTEGER;
+            return da - db;
+        });
+        const bySlot = new Map();
+        for (const it of enriched) {
+            let s = it.slot;
+            if (s === "UNKNOWN" && it.startISO) {
+                const dt = parseISO(it.startISO);
+                if (dt)
+                    s = slotOf(dt);
+            }
+            if (!bySlot.has(s))
+                bySlot.set(s, []);
+            bySlot.get(s).push(it);
+        }
+        for (const [slot, list] of bySlot) {
+            const sorted = list.slice().sort((a, b) => {
+                const da = a.startISO ? parseISO(a.startISO)?.toMillis() ?? Number.MAX_SAFE_INTEGER : Number.MAX_SAFE_INTEGER;
+                const db = b.startISO ? parseISO(b.startISO)?.toMillis() ?? Number.MAX_SAFE_INTEGER : Number.MAX_SAFE_INTEGER;
+                return da - db;
+            });
+            const startTime = sorted.find((x) => !!x.startISO)?.startISO ?? null;
+            const endTime = sorted.reduce((acc, x) => {
+                const de = x.endISO ? parseISO(x.endISO)?.toMillis() : null;
+                const accMs = acc ? parseISO(acc)?.toMillis() : null;
+                if (de != null && (accMs == null || de > accMs))
+                    return x.endISO;
+                return acc;
+            }, null);
+            const titres = sorted.map((x) => x.ev.titre || "").filter(Boolean);
+            const captationVideo = sorted.some((x) => x.ev.captationVideo === true);
+            out.push({
+                uid: makeGroupUid(date, slot),
+                chambre: "SN",
+                date,
+                slot,
+                type: "Séance publique",
+                startTime,
+                endTime,
+                captationVideo,
+                titre: compactTitleList(titres, 5),
+                objet: joinObjets(sorted.map((x) => x.ev)),
+                events: sorted.map((x) => x.ev),
+            });
+        }
+    }
+    out.sort((a, b) => {
+        const da = DateTime.fromISO(`${a.date}T${a.startTime || "00:00:00.000+02:00"}`, { zone: PARIS }).toMillis();
+        const db = DateTime.fromISO(`${b.date}T${b.startTime || "00:00:00.000+02:00"}`, { zone: PARIS }).toMillis();
+        return da - db || a.slot.localeCompare(b.slot);
+    });
+    return out;
+}
+function normalizeNoAccents(s) {
+    return (s || "")
+        .trim()
+        .normalize("NFKD")
+        .replace(/[\u0300-\u036f]/g, "");
+}
+function isSeancePublique(typeLabel) {
+    const s = normalizeNoAccents(typeLabel || "").toLowerCase();
+    return /\bseance\b.*\bpublique\b/.test(s);
+}
+function classifyAgendaType(typeLabel) {
+    const s = normalizeNoAccents(typeLabel || "").toLowerCase();
+    if (/\bseance\b.*\bpublique\b/.test(s))
+        return "SP";
+    if (/\bcommissions\b/.test(s))
+        return "COM";
+    if (/\bmission\b.*\bcontrole\b/.test(s))
+        return "MC";
+    if (/\boffices\b|\bdelegations\b/.test(s))
+        return "OD";
+    if (/\instances\b|\decisionelles\b/.test(s))
+        return "ID";
+    return null;
+}
+function typeToSuffixStrict(kind) {
+    switch (kind) {
+        case "SP": return "IDS";
+        case "COM": return "IDC";
+        case "MC": return "IDM";
+        case "OD": return "IDO";
+        case "ID": return "IDI";
+    }
+}
+function hourShortFromISO(iso) {
+    if (!iso)
+        return null;
+    const dt = parseISO(iso);
+    if (!dt)
+        return null;
+    const z = DateTime.fromISO(iso, { zone: PARIS });
+    const H = String(z.hour);
+    const mm = String(z.minute).padStart(2, "0");
+    return `${H}${mm}`;
+}
+function hourShortFromOriginal(s) {
+    if (!s)
+        return null;
+    const clean = normalizeNoAccents(s).toLowerCase();
+    const m = clean.match(/(\d{1,2})\s*[h:]\s*(\d{2})/);
+    if (m) {
+        const H = String(parseInt(m[1], 10));
+        const mm = m[2].padStart(2, "0");
+        return `${H}${mm}`;
+    }
+    const m2 = clean.match(/(\d{1,2})\s*h\b/);
+    if (m2)
+        return `${parseInt(m2[1], 10)}00`;
+    return null;
+}
+function organeInitials(input, maxLen = 8) {
+    if (!input)
+        return "";
+    const clean = normalizeNoAccents(input)
+        .replace(/['’]/g, " ")
+        .replace(/[^A-Za-z0-9\s]/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+    if (!clean)
+        return "";
+    const parts = clean.split(" ");
+    const letters = [];
+    for (const raw of parts) {
+        const w = raw.toLowerCase();
+        if (!w)
+            continue;
+        if (STOPWORDS.has(w))
+            continue;
+        // if all uppercase, keep it
+        if (/^[A-Z0-9]{2,}$/.test(raw)) {
+            letters.push(raw.toUpperCase());
+            continue;
+        }
+        // otherwise, take first letter if alphanumeric
+        const ch = raw[0];
+        if (/[A-Za-z0-9]/.test(ch))
+            letters.push(ch.toUpperCase());
+    }
+    const out = letters.join("");
+    return out.slice(0, maxLen);
+}
+function makeTypeGroupUid(dateISO, kind, hourShort, organe) {
+    const ymd = dateISO ? formatYYYYMMDD(dateISO) : "00000000";
+    const suffix = typeToSuffixStrict(kind);
+    const hh = hourShort ?? "NA";
+    const org = organe ? organeInitials(organe) : "";
+    return `RUSN${ymd}${suffix}${org ? org : ""}-${hh}`;
+}
+function parseISO(isoLike) {
+    if (!isoLike)
+        return null;
+    const dt = DateTime.fromISO(isoLike, { zone: PARIS });
+    return dt.isValid ? dt : null;
+}
+function slotOf(dt) {
+    if (!dt)
+        return "UNKNOWN";
+    const h = dt.hour + dt.minute / 60;
+    if (h < 12.5)
+        return "MATIN";
+    if (h < 19.0)
+        return "APRES-MIDI";
+    return "SOIR";
+}
+function trimWords(s, max = 40) {
+    const words = norm(s).split(/\s+/).filter(Boolean);
+    return words.length <= max ? words.join(" ") : words.slice(0, max).join(" ");
+}
+function compactTitleList(titres, maxTitles = 5) {
+    const uniq = Array.from(new Set(titres.map(t => norm(t)).filter(Boolean)));
+    return uniq.slice(0, maxTitles).join(" · ") || "(sans titre)";
+}
+export function makeGroupUid(date, slot) {
+    const ymd = date ? formatYYYYMMDD(date) : "00000000";
+    return `RUSN${ymd}IDS-${slot}`;
+}
+export function formatYYYYMMDD(dateYYYYMMDD) {
+    const [y, m, d] = dateYYYYMMDD.split("-");
+    return `${y}${m}${d}`;
+}
+export function makeReunionUid(agenda) {
+    const ymd = agenda.date ? formatYYYYMMDD(agenda.date) : "00000000";
+    return `${ymd}-${agenda.id}`;
+}
+function joinObjets(events) {
+    const objets = events
+        .map(e => (e.objet || "").trim())
+        .filter(Boolean)
+        .map(s => trimWords(s, 40));
+    if (objets.length === 0)
+        return "";
+    return objets.join(" · ");
+}
+// Extract hours/minutes from French text like "à 10 h 30", "de 10 h à 12 h", etc.
+function parseTimeOriginalFR(timeOriginal) {
+    if (!timeOriginal)
+        return { start: null, end: null };
+    const txt = (timeOriginal || "")
+        .replace(/\u00A0/g, " ") // nbsp → space
+        .replace(/\s+/g, " ") // espaces multiples
+        .toLowerCase()
+        .trim();
+    // 1) "de 10 h 30 à 12 heures", "de 10h30 à 12h", "de 9 h à 11 h 15", etc.
+    const reRange = /\bde\s+(\d{1,2})\s*(?:h|:)?\s*(\d{1,2})?\s*(?:heures?)?\s*à\s*(\d{1,2})\s*(?:h|:)?\s*(\d{1,2})?\s*(?:heures?)?/i;
+    const mRange = txt.match(reRange);
+    if (mRange) {
+        const h1 = clampHour(+mRange[1]), m1 = clampMinute(mRange[2] ? +mRange[2] : 0);
+        const h2 = clampHour(+mRange[3]), m2 = clampMinute(mRange[4] ? +mRange[4] : 0);
+        return { start: toIsoTime(h1, m1), end: toIsoTime(h2, m2) };
+    }
+    // 2) "à 10 h 30", "à 10h", "A 10h30", "A 9 heures", etc.
+    const reAt = /\b(?:a|à)\s*(\d{1,2})\s*(?:h|:)?\s*(\d{1,2})?\s*(?:heures?)?/i;
+    const mAt = txt.match(reAt);
+    if (mAt) {
+        const h = clampHour(+mAt[1]), m = clampMinute(mAt[2] ? +mAt[2] : 0);
+        return { start: toIsoTime(h, m), end: null };
+    }
+    // 3) "10 h 30", "15h", "9 heures" sans 'à' / 'de ... à ...'
+    const reBare = /\b(\d{1,2})\s*(?:h|:)?\s*(\d{1,2})?\s*(?:heures?)?\b/;
+    const mBare = txt.match(reBare);
+    if (mBare) {
+        const h = clampHour(+mBare[1]), m = clampMinute(mBare[2] ? +mBare[2] : 0);
+        return { start: toIsoTime(h, m), end: null };
+    }
+    return { start: null, end: null };
+}
+function clampHour(h) { return Math.max(0, Math.min(23, h)); }
+function clampMinute(m) { return Math.max(0, Math.min(59, m)); }
+function toIsoTime(h, m) {
+    return `${String(h).padStart(2, "0")}:${String(m).padStart(2, "0")}:00.000+02:00`;
+}
+function slotFromTimesOrText(startISO, timeOriginal) {
+    if (startISO) {
+        const dt = parseISO(startISO);
+        if (dt)
+            return slotOf(dt);
+    }
+    const t = (timeOriginal || "").toLowerCase();
+    if (/\b(apr(?:è|e)s[-\s]?midi)\b/.test(t))
+        return "APRES-MIDI";
+    if (/\b(soir(?:ée)?)\b/.test(t))
+        return "SOIR";
+    if (/\b(matin(?:ée)?)\b/.test(t))
+        return "MATIN";
+    return "UNKNOWN";
+}
+function deriveTimesForEvent(ev) {
+    const directStart = ev.startTime ?? null;
+    const directEnd = ev.endTime ?? null;
+    const fromText = parseTimeOriginalFR(ev.timeOriginal);
+    const startISO = directStart ?? fromText.start ?? null;
+    const endISO = directEnd ?? fromText.end ?? null;
+    const slot = slotFromTimesOrText(startISO, ev.timeOriginal);
+    return { startISO, endISO, slot };
+}

package/lib/validators/senat.js

@@ -0,0 +1,24 @@
+"use strict";
+// import { validateNonEmptyTrimmedString } from "@biryani/core"
+// const acteurUidRegExp = /^PA\d+$/
+// const organeUidRegExp = /^PO\d+$/
+// export function validateSenateurUid(input: any): [any, any] {
+//   const [value, error] = validateNonEmptyTrimmedString(input)
+//   if (error !== null) {
+//     return [value, error]
+//   }
+//   if (!acteurUidRegExp.test(value)) {
+//     return [value, 'Invalid "acteur" unique ID']
+//   }
+//   return [value, null]
+// }
+// export function validateOrganeUid(input: any): [any, any] {
+//   const [value, error] = validateNonEmptyTrimmedString(input)
+//   if (error !== null) {
+//     return [value, error]
+//   }
+//   if (!organeUidRegExp.test(value)) {
+//     return [value, 'Invalid "organe" unique ID']
+//   }
+//   return [value, null]
+// }