@tricoteuses/senat 3.1.7 → 3.1.8

package/lib/src/server/sens.js

@@ -70,9 +70,9 @@ export async function* findAll() {
             sql `to_char(memcom.memcomdatdeb, 'YYYY-MM-DD')`.as("date_debut"),
             sql `to_char(memcom.memcomdatfin, 'YYYY-MM-DD')`.as("date_fin"),
             "memcom.temvalcod as etat",
-            "com2.comlilmin as libelle",
+            sql `nullif(btrim(com2.comlilmin), '')`.as("libelle"),
             "com2.typorgcod as type_code_organisme",
-            "typorg.typorglib as type_organisme",
+            sql `nullif(btrim(typorg.typorglib), '')`.as("type_organisme"),
             "memcom.memcomdatdeb as order_date",
             // Fonctions dans la commission
             jsonArrayFrom(eb2
@@ -83,9 +83,9 @@ export async function* findAll() {
                 sql `to_char(fonmemcom.fonmemcomdatdeb, 'YYYY-MM-DD')`.as("date_debut"),
                 sql `to_char(fonmemcom.fonmemcomdatfin, 'YYYY-MM-DD')`.as("date_fin"),
                 sql `coalesce(
-                    nullif(foncom.foncomlib, ''),
-                    nullif(foncom.foncomlil, ''),
-                    nullif(foncom.foncomlic, ''))`.as("libelle"),
+                    nullif(btrim(foncom.foncomlib), ''),
+                    nullif(btrim(foncom.foncomlil), ''),
+                    nullif(btrim(foncom.foncomlic), ''))`.as("libelle"),
                 "fonmemcom.fonmemcomdatdeb as order_date",
             ])
                 .whereRef("fonmemcom.memcomid", "=", "memcom.memcomid")
@@ -105,9 +105,9 @@ export async function* findAll() {
             sql `to_char(memdelega.memdelegadatdeb, 'YYYY-MM-DD')`.as("date_debut"),
             sql `to_char(memdelega.memdelegadatfin, 'YYYY-MM-DD')`.as("date_fin"),
             "memdelega.temvalcod as etat",
-            "delega.evelib as libelle",
+            sql `nullif(btrim(delega.evelib), '')`.as("libelle"),
             "delega.typorgcod as type_code_organisme",
-            "typorg2.typorglib as type_organisme",
+            sql `nullif(btrim(typorg2.typorglib), '')`.as("type_organisme"),
             "memdelega.memdelegadatdeb as order_date",
             // Fonctions dans la délégation
             jsonArrayFrom(eb2
@@ -118,9 +118,9 @@ export async function* findAll() {
                 sql `to_char(fonmemdelega.fonmemdeldatdeb, 'YYYY-MM-DD')`.as("date_debut"),
                 sql `to_char(fonmemdelega.fonmemdeldatfin, 'YYYY-MM-DD')`.as("date_fin"),
                 sql `coalesce(
-                    nullif(fondelega.fondellib, ''),
-                    nullif(fondelega.fondellil, ''),
-                    nullif(fondelega.fondellic, ''))`.as("libelle"),
+                    nullif(btrim(fondelega.fondellib), ''),
+                    nullif(btrim(fondelega.fondellil), ''),
+                    nullif(btrim(fondelega.fondellic), ''))`.as("libelle"),
                 "fonmemdelega.fonmemdeldatdeb as order_date",
             ])
                 .whereRef("fonmemdelega.memdelegaid", "=", "memdelega.memdelegaid")
@@ -140,9 +140,9 @@ export async function* findAll() {
             sql `to_char(memgrppol.memgrppoldatdeb, 'YYYY-MM-DD')`.as("date_debut"),
             sql `to_char(memgrppol.memgrppoldatfin, 'YYYY-MM-DD')`.as("date_fin"),
             "memgrppol.temvalcod as etat",
-            "grppol2.grppollibcou as libelle",
+            sql `nullif(btrim(grppol2.grppollibcou), '')`.as("libelle"),
             "grppol2.typorgcod as type_code_organisme",
-            "typorg3.typorglib as type_organisme",
+            sql `nullif(btrim(typorg3.typorglib), '')`.as("type_organisme"),
             "memgrppol.memgrppoldatdeb as order_date",
             // Fonctions dans le groupe politique
             jsonArrayFrom(eb2
@@ -153,9 +153,9 @@ export async function* findAll() {
                 sql `to_char(fonmemgrppol.fonmemgrppoldatdeb, 'YYYY-MM-DD')`.as("date_debut"),
                 sql `to_char(fonmemgrppol.fonmemgrppoldatfin, 'YYYY-MM-DD')`.as("date_fin"),
                 sql `coalesce(
-                    nullif(fongrppol.fongrppollib, ''),
-                    nullif(fongrppol.fongrppollil, ''),
-                    nullif(fongrppol.fongrppollic, ''))`.as("libelle"),
+                    nullif(btrim(fongrppol.fongrppollib), ''),
+                    nullif(btrim(fongrppol.fongrppollil), ''),
+                    nullif(btrim(fongrppol.fongrppollic), ''))`.as("libelle"),
                 "fonmemgrppol.fonmemgrppoldatdeb as order_date",
             ])
                 .whereRef("fonmemgrppol.memgrppolid", "=", "memgrppol.memgrppolid")
@@ -174,9 +174,9 @@ export async function* findAll() {
             sql `to_char(memorg.memorgdatdeb, 'YYYY-MM-DD')`.as("date_debut"),
             sql `to_char(memorg.memorgdatfin, 'YYYY-MM-DD')`.as("date_fin"),
             "memorg.temvalcod as etat",
-            "org.evelib as libelle",
+            sql `nullif(btrim(org.evelib), '')`.as("libelle"),
             "org.typorgcod as type_code_organisme",
-            "typorg4.typorglib as type_organisme",
+            sql `nullif(btrim(typorg4.typorglib), '')`.as("type_organisme"),
             "memorg.memorgdatdeb as order_date",
             // Fonctions dans l'organisme
             jsonArrayFrom(eb2
@@ -187,9 +187,9 @@ export async function* findAll() {
                 sql `to_char(fonmemorg.fonmemorgdatdeb, 'YYYY-MM-DD')`.as("date_debut"),
                 sql `to_char(fonmemorg.fonmemorgdatfin, 'YYYY-MM-DD')`.as("date_fin"),
                 sql `coalesce(
-                    nullif(fonorg.fonorglib, ''),
-                    nullif(fonorg.fonorglil, ''),
-                    nullif(fonorg.fonorglic, ''))`.as("libelle"),
+                    nullif(btrim(fonorg.fonorglib), ''),
+                    nullif(btrim(fonorg.fonorglil), ''),
+                    nullif(btrim(fonorg.fonorglic), ''))`.as("libelle"),
                 "fonmemorg.fonmemorgdatdeb as order_date",
             ])
                 .whereRef("fonmemorg.memorgid", "=", "memorg.memorgid")
@@ -200,7 +200,24 @@ export async function* findAll() {
         // Groupes sénatoriaux (groupes d'amitié)
         jsonArrayFrom(eb
             .withSchema("senat")
-            .selectFrom("sens_memgrpsen as memgrpsen")
+            .selectFrom(eb
+            .withSchema("senat")
+            .selectFrom("sens_memgrpsen as memgrpsen_raw")
+            .select([
+            "memgrpsen_raw.orgcod as orgcod",
+            "memgrpsen_raw.memgrpsendatent as memgrpsendatent",
+            "memgrpsen_raw.memgrpsendatsor as memgrpsendatsor",
+            "memgrpsen_raw.temvalcod as temvalcod",
+            sql `min(memgrpsen_raw.memgrpsenid)`.as("memgrpsenid"),
+        ])
+            .whereRef("memgrpsen_raw.senmat", "=", "sen.senmat")
+            .groupBy([
+            "memgrpsen_raw.orgcod",
+            "memgrpsen_raw.memgrpsendatent",
+            "memgrpsen_raw.memgrpsendatsor",
+            "memgrpsen_raw.temvalcod",
+        ])
+            .as("memgrpsen"))
             .leftJoin("sens_grpsenami as grpsenami", "grpsenami.orgcod", "memgrpsen.orgcod")
             .leftJoin("sens_typorg as typorg5", "typorg5.typorgcod", "grpsenami.typorgcod")
             .select((eb2) => [
@@ -208,9 +225,9 @@ export async function* findAll() {
             sql `to_char(memgrpsen.memgrpsendatent, 'YYYY-MM-DD')`.as("date_debut"),
             sql `to_char(memgrpsen.memgrpsendatsor, 'YYYY-MM-DD')`.as("date_fin"),
             "memgrpsen.temvalcod as etat",
-            "grpsenami.evelib as libelle",
+            sql `nullif(btrim(grpsenami.evelib), '')`.as("libelle"),
             "grpsenami.typorgcod as type_code_organisme",
-            "typorg5.typorglib as type_organisme",
+            sql `nullif(btrim(typorg5.typorglib), '')`.as("type_organisme"),
             "memgrpsen.memgrpsendatent as order_date",
             // Fonctions dans le groupe sénatorial
             jsonArrayFrom(eb2
@@ -221,15 +238,14 @@ export async function* findAll() {
                 sql `to_char(fonmemgrpsen.fonmemgrpsendatdeb, 'YYYY-MM-DD')`.as("date_debut"),
                 sql `to_char(fonmemgrpsen.fonmemgrpsendatfin, 'YYYY-MM-DD')`.as("date_fin"),
                 sql `coalesce(
-                    nullif(fongrpsen.fongrpsenlib, ''),
-                    nullif(fongrpsen.fongrpsenlil, ''),
-                    nullif(fongrpsen.fongrpsenlic, ''))`.as("libelle"),
+                    nullif(btrim(fongrpsen.fongrpsenlib), ''),
+                    nullif(btrim(fongrpsen.fongrpsenlil), ''),
+                    nullif(btrim(fongrpsen.fongrpsenlic), ''))`.as("libelle"),
                 "fonmemgrpsen.fonmemgrpsendatdeb as order_date",
             ])
                 .whereRef("fonmemgrpsen.memgrpsenid", "=", "memgrpsen.memgrpsenid")
                 .orderBy("fonmemgrpsen.fonmemgrpsendatdeb", (ob) => ob.desc().nullsLast())).as("fonctions"),
         ])
-            .whereRef("memgrpsen.senmat", "=", "sen.senmat")
             .orderBy("memgrpsen.memgrpsendatent", (ob) => ob.desc().nullsLast())).as("groupes_senatoriaux"),
         // Fonctions au bureau du Sénat
         jsonArrayFrom(eb
@@ -239,7 +255,11 @@ export async function* findAll() {
             .select([
             sql `to_char(senbur.senburdatdeb, 'YYYY-MM-DD')`.as("date_debut"),
             sql `to_char(senbur.senburdatfin, 'YYYY-MM-DD')`.as("date_fin"),
-            sql `coalesce(nullif(bur.burlib, ''), nullif(bur.burlil, ''), nullif(bur.burlic, ''))`.as("libelle"),
+            sql `coalesce(
+              nullif(btrim(bur.burlib), ''),
+              nullif(btrim(bur.burlil), ''),
+              nullif(btrim(bur.burlic), '')
+            )`.as("libelle"),
             "senbur.senburdatdeb as order_date",
         ])
             .whereRef("senbur.senmat", "=", "sen.senmat")
@@ -251,7 +271,7 @@ export async function* findAll() {
             .select((eb2) => [
             sql `poicon.poiconid::text`.as("id"),
             "poicon.typpoiconcod as type",
-            "poicon.poiconlib as libelle",
+            sql `nullif(btrim(poicon.poiconlib), '')`.as("libelle"),
             "poicon.poiconnumtri as order_num",
             // Adresses
             jsonArrayFrom(eb2

package/package.json

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

package/lib/src/config.d.ts

@@ -1,43 +0,0 @@
-import "dotenv/config";
-import { z } from "zod";
-export declare const dbSchema: z.ZodObject<{
-    host: z.ZodString;
-    name: z.ZodString;
-    password: z.ZodString;
-    port: z.ZodCoercedNumber<unknown>;
-    user: z.ZodString;
-}, z.core.$strip>;
-export type DbConfig = z.infer<typeof dbSchema>;
-export declare const configSchema: z.ZodObject<{
-    db: z.ZodObject<{
-        host: z.ZodString;
-        name: z.ZodString;
-        password: z.ZodString;
-        port: z.ZodCoercedNumber<unknown>;
-        user: z.ZodString;
-    }, z.core.$strip>;
-    stagingDb: z.ZodObject<{
-        host: z.ZodString;
-        name: z.ZodString;
-        password: z.ZodString;
-        port: z.ZodCoercedNumber<unknown>;
-        user: z.ZodString;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-declare const _default: {
-    db: {
-        host: string;
-        name: string;
-        password: string;
-        port: number;
-        user: string;
-    };
-    stagingDb: {
-        host: string;
-        name: string;
-        password: string;
-        port: number;
-        user: string;
-    };
-};
-export default _default;

package/lib/src/config.js

@@ -1,37 +0,0 @@
-import "dotenv/config";
-import { z } from "zod";
-export const dbSchema = z.object({
-    host: z.string().trim().min(1, "Must not be empty"),
-    name: z.string().trim().min(1, "Must not be empty"),
-    password: z.string().trim().min(1, "Must not be empty"),
-    port: z.coerce.number().int().min(0).max(65535),
-    user: z.string().trim().min(1, "Must not be empty"),
-});
-export const configSchema = z.object({
-    db: dbSchema,
-    stagingDb: dbSchema,
-});
-const config = {
-    db: {
-        host: process.env["DB_HOST"] || "localhost",
-        name: process.env["DB_NAME"] || "senat",
-        password: process.env["DB_PASSWORD"] || "opendata",
-        port: process.env["DB_PORT"] || 5432,
-        user: process.env["DB_USER"] || "opendata",
-    },
-    stagingDb: {
-        host: process.env["STAGING_DB_HOST"] || process.env["DB_HOST"] || "localhost",
-        name: process.env["STAGING_DB_NAME"] || "senat_staging",
-        password: process.env["STAGING_DB_PASSWORD"] || process.env["DB_PASSWORD"] || "opendata",
-        port: process.env["STAGING_DB_PORT"] || process.env["DB_PORT"] || 5432,
-        user: process.env["STAGING_DB_USER"] || process.env["DB_USER"] || "opendata",
-    },
-};
-const result = configSchema.safeParse(config);
-if (!result.success) {
-    const issues = JSON.stringify(result.error.issues, null, 2);
-    const serializedConfig = JSON.stringify(config, null, 2);
-    console.error(`Error in configuration:\n${serializedConfig}\nError:\n${issues}`);
-    process.exit(-1);
-}
-export default result.data;

package/lib/src/conversion_textes.d.ts

@@ -1,11 +0,0 @@
-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

@@ -1,320 +0,0 @@
-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) {
-    let xmlDoc;
-    try {
-        xmlDoc = new JSDOM(texteXml, { contentType: "text/xml" }).window.document;
-    }
-    catch (err) {
-        if (await fs.pathExists(outputFilePath)) {
-            await fs.remove(outputFilePath);
-        }
-        throw err;
-    }
-    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>",
-        ].join(" ")
-        : ""}
-  </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/databases_postgres.d.ts

@@ -1,4 +0,0 @@
-import postgres from "postgres";
-export type SqlValue = postgres.ParameterOrJSON<never>;
-export declare const sql: postgres.Sql<{}>;
-export declare function streamUnsafeQuery<T>(query: string, params?: readonly unknown[], batchSize?: number): AsyncGenerator<T, void, unknown>;

package/lib/src/databases_postgres.js

@@ -1,23 +0,0 @@
-import postgres from "postgres";
-import config from "./config.js";
-export const sql = postgres({
-    database: config.db.name,
-    host: config.db.host,
-    password: config.db.password,
-    port: config.db.port,
-    transform: {
-        undefined: null,
-    },
-    user: config.db.user,
-});
-function toSqlValue(value) {
-    return value;
-}
-export async function* streamUnsafeQuery(query, params = [], batchSize = 100) {
-    const values = params.map(toSqlValue);
-    for await (const rows of sql.unsafe(query, values).cursor(batchSize)) {
-        for (const row of rows) {
-            yield row;
-        }
-    }
-}

package/lib/src/datasets.d.ts

@@ -1,38 +0,0 @@
-export interface Dataset {
-    database: string;
-    repairEncoding: boolean;
-    repairZip?: (dataset: Dataset, dataDir: string) => void;
-    title: string;
-    url: string;
-    indexes?: {
-        [table: string]: Array<{
-            name: string;
-            columns: string[];
-        }>;
-    };
-    mergeKeys?: {
-        [table: string]: string[];
-    };
-    rowMultisetMergeTables?: string[];
-}
-export interface Datasets {
-    ameli: Dataset;
-    debats: Dataset;
-    dosleg: Dataset;
-    questions: Dataset;
-    sens: Dataset;
-}
-export declare enum EnabledDatasets {
-    None = 0,
-    Ameli = 1,
-    Debats = 2,
-    DosLeg = 4,
-    Questions = 8,
-    Sens = 16,
-    PhotosSenateurs = 32,
-    Agenda = 64,
-    All = 127
-}
-export declare const datasets: Datasets;
-export declare function getEnabledDatasets(categories: string[]): EnabledDatasets;
-export declare function getChosenDatasets(enabledDatasets: EnabledDatasets): Dataset[];