@tricoteuses/senat 2.21.5 → 2.21.6

package/lib/src/conversion_textes.d.ts

@@ -0,0 +1,11 @@
+export interface SenatMetadata {
+    number: string | null;
+    session: string | null;
+    date: string | null;
+    type: string | null;
+    authors: string | null;
+    title: string | null;
+    commission: string | null;
+}
+export declare function extractMetadata(xmlDoc: Document): SenatMetadata;
+export declare function convertSenatXmlToHtml(texteXml: string, outputFilePath: string): Promise<void>;

package/lib/src/conversion_textes.js

@@ -0,0 +1,307 @@
+import { JSDOM } from "jsdom";
+import fs from "fs-extra";
+import path from "path";
+import { DateTime } from "luxon";
+export function extractMetadata(xmlDoc) {
+    const metadata = {
+        number: null,
+        session: null,
+        date: null,
+        type: null,
+        authors: null,
+        title: xmlDoc.querySelector("docTitle")?.textContent?.trim() || null,
+        commission: null,
+    };
+    // Extract Number
+    const docIdAlias = xmlDoc.querySelector('FRBRalias[name="signet-dossier-legislatif-senat"]');
+    if (docIdAlias) {
+        const value = docIdAlias.getAttribute("value");
+        if (value) {
+            const match = value.match(/\d+$/);
+            if (match)
+                metadata.number = match[0];
+        }
+    }
+    // Extract Session
+    const sessionUri = xmlDoc.querySelector("FRBRExpression > FRBRuri")?.getAttribute("value");
+    if (sessionUri) {
+        const match = sessionUri.match(/\d{4}-\d{4}/);
+        if (match)
+            metadata.session = match[0];
+    }
+    // Extract Date
+    const depotDate = xmlDoc.querySelector('FRBRdate[name="#depot"]')?.getAttribute("date");
+    if (depotDate) {
+        metadata.date = DateTime.fromISO(depotDate).setLocale("fr").toFormat("d MMMM yyyy");
+    }
+    else {
+        const presentationDate = xmlDoc.querySelector('FRBRdate[name="#presentation"]')?.getAttribute("date");
+        if (presentationDate) {
+            metadata.date = DateTime.fromISO(presentationDate).setLocale("fr").toFormat("d MMMM yyyy");
+        }
+    }
+    // Extract Type
+    const bill = xmlDoc.querySelector("bill");
+    const typeCode = bill?.getAttribute("name");
+    if (typeCode === "ppl") {
+        metadata.type = "PROPOSITION DE LOI";
+    }
+    else if (typeCode === "pjl") {
+        metadata.type = "PROJET DE LOI";
+    }
+    // Extract Authors
+    const authorRef = xmlDoc.querySelector('FRBRWork > FRBRauthor[as="#auteur"]')?.getAttribute("href");
+    if (authorRef) {
+        const authorId = authorRef.replace(/^#/, "");
+        const authorPerson = xmlDoc.querySelector(`TLCPerson[eId="${authorId}"]`);
+        if (authorPerson) {
+            const showAs = authorPerson.getAttribute("showAs");
+            if (showAs) {
+                metadata.authors = showAs.replace(/, Sénateurs$/, ", Sénateurs et Sénatrices");
+            }
+        }
+    }
+    // Extract Commission
+    const commissionNode = xmlDoc.querySelector('TLCOrganization[eId="commission-senat"]') ||
+        xmlDoc.querySelector('TLCOrganization[eId^="commission-"]:not([eId*="assemblee"])');
+    if (commissionNode) {
+        metadata.commission = commissionNode.getAttribute("showAs");
+    }
+    return metadata;
+}
+export async function convertSenatXmlToHtml(texteXml, outputFilePath) {
+    const { document: xmlDoc } = new JSDOM(texteXml, { contentType: "text/xml" }).window;
+    const metadata = extractMetadata(xmlDoc);
+    const xmlBody = xmlDoc.querySelector("body");
+    const style = `
+body {
+  font-family: "URW Bookman", "Bookman Old Style", serif;
+  max-width: 800px;
+  margin: 40px auto;
+  line-height: 1.5;
+  color: #333;
+}
+.header {
+  text-align: center;
+  margin-bottom: 40px;
+  border-bottom: 2px solid #333;
+  padding-bottom: 20px;
+}
+.header-top {
+  font-weight: bold;
+  font-size: 1.2em;
+  margin-bottom: 10px;
+}
+.header-session {
+  text-transform: uppercase;
+  font-size: 0.9em;
+  margin-bottom: 5px;
+}
+.header-date {
+  font-size: 0.9em;
+  margin-bottom: 5px;
+}
+.header-number {
+  font-weight: bold;
+  font-size: 1.1em;
+  margin-bottom: 20px;
+}
+.header-type {
+  font-weight: bold;
+  font-size: 1.5em;
+  margin-top: 20px;
+}
+.header-authors {
+  margin-top: 20px;
+  font-style: italic;
+}
+.header-commission {
+  margin-top: 15px;
+  font-size: 0.9em;
+}
+h1 {
+  text-align: center;
+  font-size: 1.8em;
+  margin-top: 10px;
+}
+p {
+  margin: 0.6em 0;
+}
+p.has-alinea {
+  position: relative;
+  padding-left: 2.5em;
+}
+.alinea {
+  position: absolute;
+  left: 0;
+  top: 0.15em;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  min-width: 1.5em;
+  height: 1.5em;
+  padding: 0 0.3em;
+  margin-right: 0.3em;
+  font-size: 0.75em;
+  font-weight: bold;
+  color: #555;
+  background-color: #f0f0f0;
+  border: 1px solid #ccc;
+  border-radius: 1em;
+}
+.num {
+  font-weight: bold;
+  margin-right: 0.2em;
+}
+.article {
+  margin-top: 2em;
+}
+.article h3 {
+  border-bottom: 1px solid #eee;
+  padding-bottom: 5px;
+}
+`;
+    const htmlDocTemplate = `<!DOCTYPE html>
+<html lang="fr">
+<head>
+  <meta charset="utf-8">
+  <title>${metadata.title || "Document Sénat"}</title>
+  <style>${style}</style>
+</head>
+<body>
+  <div class="header">
+    <div class="header-top">SÉNAT</div>
+    <div class="header-session">SESSION ORDINAIRE DE ${metadata.session || "...."}</div>
+    ${metadata.date ? `<div class="header-date">Enregistré à la Présidence du Sénat le ${metadata.date}</div>` : ""}
+    <div class="header-number">N° ${metadata.number || "...."}</div>
+    <div class="header-type">${metadata.type || ""}</div>
+    <div class="header-authors">${metadata.authors || ""}</div>
+    ${metadata.commission
+        ? `<div class="header-commission">Envoyée à la ${metadata.commission.toLowerCase()}, sous réserve de la constitution éventuelle d'une commission spéciale dans les conditions prévues par le Règlement.</div>`
+        : ""}
+  </div>
+  <h1>${metadata.title || ""}</h1>
+</body>
+</html>`;
+    const { document: htmlDoc } = new JSDOM(htmlDocTemplate).window;
+    const body = htmlDoc.body;
+    if (xmlBody) {
+        const processNode = (xmlNode, htmlParent, alineaData = null) => {
+            const children = Array.from(xmlNode.childNodes);
+            const alineaChildren = [];
+            const otherChildren = [];
+            for (const child of children) {
+                if (child.nodeType === 1 && child.tagName.toLowerCase() === "alinea") {
+                    alineaChildren.push(child);
+                }
+                else {
+                    otherChildren.push(child);
+                }
+            }
+            for (const child of otherChildren) {
+                if (child.nodeType === 3) {
+                    htmlParent.appendChild(htmlDoc.createTextNode(child.textContent || ""));
+                }
+                else if (child.nodeType === 1) {
+                    const element = child;
+                    const tagName = element.tagName.toLowerCase();
+                    let htmlElement = null;
+                    switch (tagName) {
+                        case "article": {
+                            htmlElement = htmlDoc.createElement("div");
+                            htmlElement.className = "article";
+                            const artId = element.getAttribute("eId");
+                            if (artId)
+                                htmlElement.id = artId;
+                            const artGuid = element.getAttribute("GUID");
+                            if (artGuid)
+                                htmlElement.setAttribute("data-guid", artGuid);
+                            break;
+                        }
+                        case "num": {
+                            const parentTagName = element.parentElement?.tagName.toLowerCase();
+                            if (parentTagName === "alinea" && alineaData) {
+                                alineaData.numText = element.textContent?.trim();
+                                continue;
+                            }
+                            htmlElement = htmlDoc.createElement("span");
+                            htmlElement.className = "num";
+                            break;
+                        }
+                        case "heading":
+                            htmlElement = htmlDoc.createElement("h4");
+                            break;
+                        case "p":
+                            htmlElement = htmlDoc.createElement("p");
+                            if (alineaData) {
+                                htmlElement.classList.add("has-alinea");
+                                if (alineaData.id)
+                                    htmlElement.id = alineaData.id;
+                                if (alineaData.guid)
+                                    htmlElement.setAttribute("data-guid", alineaData.guid);
+                                const pastille = alineaData.pastille;
+                                if (pastille) {
+                                    htmlElement.setAttribute("data-pastille", pastille);
+                                    if (!alineaData.pastilleApplied) {
+                                        const span = htmlDoc.createElement("span");
+                                        span.className = "alinea";
+                                        span.setAttribute("data-alinea", pastille);
+                                        span.textContent = pastille;
+                                        htmlElement.appendChild(span);
+                                        alineaData.pastilleApplied = true;
+                                    }
+                                }
+                                if (alineaData.numText) {
+                                    const xmlPText = element.textContent || "";
+                                    const normalize = (s) => s.replace(/[\\s\\u00A0]+/g, " ").trim();
+                                    const normalizedNum = normalize(alineaData.numText);
+                                    const normalizedP = normalize(xmlPText);
+                                    if (normalizedNum && !normalizedP.startsWith(normalizedNum)) {
+                                        const numSpan = htmlDoc.createElement("span");
+                                        numSpan.className = "num";
+                                        numSpan.textContent = alineaData.numText + " ";
+                                        htmlElement.appendChild(numSpan);
+                                    }
+                                    alineaData.numText = null;
+                                }
+                            }
+                            break;
+                        case "content":
+                            processNode(element, htmlParent, alineaData);
+                            continue;
+                        case "doctitle":
+                            continue;
+                        case "i":
+                        case "b":
+                        case "u":
+                        case "sup":
+                        case "sub":
+                            htmlElement = htmlDoc.createElement(tagName);
+                            break;
+                        default:
+                            htmlElement = htmlDoc.createElement("span");
+                            htmlElement.setAttribute("data-xml-tag", tagName);
+                            break;
+                    }
+                    if (htmlElement) {
+                        htmlParent.appendChild(htmlElement);
+                        processNode(element, htmlElement, alineaData);
+                    }
+                }
+            }
+            for (const element of alineaChildren) {
+                const nextAlineaData = {
+                    id: element.getAttribute("eId"),
+                    guid: element.getAttribute("GUID"),
+                    pastille: element.getAttribute("data:pastille"),
+                    pastilleApplied: false,
+                };
+                processNode(element, htmlParent, nextAlineaData);
+            }
+        };
+        processNode(xmlBody, body);
+    }
+    const htmlContent = "<!DOCTYPE html>\n" + htmlDoc.documentElement.outerHTML;
+    await fs.ensureDir(path.dirname(outputFilePath));
+    await fs.outputFile(outputFilePath, htmlContent);
+}

package/lib/src/loaders.js

@@ -199,7 +199,7 @@ export function* iterLoadSenatTextes(dataDir, session, options = {}) {
         const texteId = texte["id"];
         const { item: texteContent } = loadSenatTexteContent(dataDir, texte["session"], texteId);
         if (texteContent) {
-            texteItem.item.divisions = texteContent.divisions;
+            Object.assign(texteItem.item, texteContent);
         }
         yield texteItem;
     }

package/lib/src/parsers/texte.js

@@ -118,16 +118,16 @@ export function transformTexte(document) {
     const datePublicationXml = metaElement?.querySelector("FRBRdate[name='#publication-xml']")?.getAttribute("date");
     return {
         titre: preambleElement?.querySelector("docTitle")?.textContent || null,
-        titreCourt: metaElement?.querySelector("FRBRalias[name='intitule-court']")?.getAttribute("value") || null,
-        signetDossier: metaElement?.querySelector("FRBRalias[name='signet-dossier-legislatif-senat']")?.getAttribute("value") || null,
-        urlDossierSenat: metaElement?.querySelector("FRBRalias[name='url-senat']")?.getAttribute("value") || null,
-        urlDossierAssemblee: metaElement?.querySelector("FRBRalias[name='url-AN']")?.getAttribute("value") || null,
+        titre_court: metaElement?.querySelector("FRBRalias[name='intitule-court']")?.getAttribute("value") || null,
+        signet_dossier: metaElement?.querySelector("FRBRalias[name='signet-dossier-legislatif-senat']")?.getAttribute("value") || null,
+        url_dossier_senat: metaElement?.querySelector("FRBRalias[name='url-senat']")?.getAttribute("value") || null,
+        url_dossier_assemblee: metaElement?.querySelector("FRBRalias[name='url-AN']")?.getAttribute("value") || null,
         type: identificationParts?.["type"] || null,
         session: sessionYears && sessionYears.length > 0 ? sessionYears[0] : null,
         numero: identificationParts?.["numTexte"] ? parseInt(identificationParts["numTexte"]) : null,
-        datePresentation: datePresentation ? new Date(datePresentation) : null,
-        dateDepot: dateDepot ? new Date(dateDepot) : null,
-        datePublicationXml: datePublicationXml ? new Date(datePublicationXml) : null,
+        date_presentation: datePresentation ? new Date(datePresentation) : null,
+        date_depot: dateDepot ? new Date(dateDepot) : null,
+        date_publication_xml: datePublicationXml ? new Date(datePublicationXml) : null,
         version: identificationParts?.["version"] ? identificationParts["version"] : null,
         divisions: bodyElement ? flattenTexte(bodyElement) : [],
     };

package/lib/src/scripts/convert_data.js

@@ -234,7 +234,7 @@ async function convertTextes(dataDir, options) {
         const texteName = path.parse(texte["url"]).name;
         const texteDir = path.join(originalTextesDir, `${session}`, texteName);
         // oritxtcod = 1 corresponds to "Texte de loi déposé au Sénat"
-        const hasExposeDesMotifs = texte["origine"] === "Sénat" && texte["ordre_origine"] === "1";
+        const hasExposeDesMotifs = texte["origine"] === "déposé au Sénat" || texte["origine"] === "transmis au Sénat";
         const metadata = {
             name: texteName,
             session: texte["session"],

package/lib/src/scripts/convert_xml_to_html.d.ts

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

package/lib/src/scripts/convert_xml_to_html.js

@@ -0,0 +1,62 @@
+import fs from "fs-extra";
+import path from "path";
+import commandLineArgs from "command-line-args";
+import { convertSenatXmlToHtml } from "../conversion_textes";
+const optionDefinitions = [
+    { name: "input", alias: "i", type: String, defaultOption: true },
+    { name: "output", alias: "o", type: String },
+    { name: "help", alias: "h", type: Boolean },
+];
+async function main() {
+    let options;
+    try {
+        options = commandLineArgs(optionDefinitions, { stopAtFirstUnknown: true });
+    }
+    catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+    }
+    // Handle positional arguments if not using flags
+    const argv = options["_unknown"] || [];
+    if (!options["output"] && argv.length > 0) {
+        options["output"] = argv[0];
+    }
+    if (options["help"] || !options["input"]) {
+        console.log("Usage: npx tsx src/scripts/convert_xml_to_html.ts <input_xml_path> [output_html_path]");
+        console.log("Options:");
+        console.log("  -i, --input <path>   Input XML file path (default option)");
+        console.log("  -o, --output <path>  Output HTML file path");
+        console.log("  -h, --help           Show this help message");
+        return;
+    }
+    const inputPath = path.resolve(options["input"]);
+    let outputPath = options["output"];
+    if (!outputPath) {
+        outputPath = inputPath.replace(/\.xml$/, ".html");
+        if (outputPath === inputPath) {
+            outputPath += ".html";
+        }
+    }
+    else {
+        outputPath = path.resolve(outputPath);
+    }
+    if (!fs.existsSync(inputPath)) {
+        console.error(`Error: Input file not found: ${inputPath}`);
+        process.exit(1);
+    }
+    try {
+        const xmlContent = await fs.readFile(inputPath, "utf-8");
+        await convertSenatXmlToHtml(xmlContent, outputPath);
+        console.log("Successfully converted:");
+        console.log(`  From: ${inputPath}`);
+        console.log(`  To:   ${outputPath}`);
+    }
+    catch (error) {
+        console.error(`Error during conversion: ${error.message}`);
+        process.exit(1);
+    }
+}
+main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+});

package/lib/src/scripts/retrieve_documents.js

@@ -214,7 +214,7 @@ async function parseDocument(session, transformedTextesDir, textePath, texteName
             console.log("Parsing exposé des motifs…");
         }
         const exposeDesMotifsHtml = textDecoder.decode(exposeDesMotifs);
-        parsedTexte.exposeDesMotifs = parseExposeDesMotifs(exposeDesMotifsHtml);
+        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 });

package/lib/src/scripts/test_iter_load.js

@@ -1,12 +1,12 @@
-import { iterLoadSenatRapports, } from "../loaders";
+import { iterLoadSenatTextes, } from "../loaders";
 import commandLineArgs from "command-line-args";
 import { dataDirDefaultOption } from "./shared/cli_helpers";
 const optionsDefinitions = [dataDirDefaultOption];
 const options = commandLineArgs(optionsDefinitions);
-const session = 2024;
+const session = 2025;
 const sinceCommit = undefined;
-for (const { item: rapport } of iterLoadSenatRapports(options["dataDir"], session, {
+for (const { item: texte } of iterLoadSenatTextes(options["dataDir"], session, {
     sinceCommit: sinceCommit,
 })) {
-    console.log(rapport);
+    console.log(texte);
 }

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

@@ -24,19 +24,19 @@ export interface DocumentMetadata {
 }
 export interface FlatTexte {
     titre: string | null;
-    titreCourt: string | null;
-    signetDossier: string | null;
-    urlDossierSenat: string | null;
-    urlDossierAssemblee: string | null;
+    titre_court: string | null;
+    signet_dossier: string | null;
+    url_dossier_senat: string | null;
+    url_dossier_assemblee: string | null;
     type: string | null;
     session: string | null;
     numero: number | null;
-    datePresentation: Date | null;
-    dateDepot: Date | null;
-    datePublicationXml: Date | null;
+    date_presentation: Date | null;
+    date_depot: Date | null;
+    date_publication_xml: Date | null;
     version: Version | null;
     divisions: Division[];
-    exposeDesMotifs?: ExposeDesMotifs | null;
+    expose_motifs?: ExposeDesMotifs | null;
 }
 export type Version = "RECT" | "RECT_BIS" | "RECT_TER" | "RECT_QUATER" | "RECT_QUINQUIES";
 export interface Step {

package/package.json

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