@tricoteuses/senat 3.0.2 → 3.1.0

package/lib/src/scripts/retrieve_open_data.js

@@ -3,17 +3,18 @@ import { execFileSync } from "child_process";
 import commandLineArgs from "command-line-args";
 import fs from "fs-extra";
 import { formatWithPrettier, makePgTsGenerator, markAsGenerated, processDatabase } from "kanel";
+import { makeKyselyHook } from "kanel-kysely";
 import path from "path";
 import StreamZip from "node-stream-zip";
 import readline from "readline";
 import { pipeline, Readable } from "stream";
 import { promisify } from "util";
 import * as windows1252 from "windows-1252";
-import config from "../config.js";
-import { getChosenDatasets, getEnabledDatasets } from "../datasets.js";
+import config from "../server/config.js";
+import { getChosenDatasets, getEnabledDatasets } from "../server/datasets.js";
 import { assertExistingDirectory, commonOptions } from "./shared/cli_helpers.js";
 import { buildIncrementalDatasetImportSql, buildNormalizeStagingSchemaSql } from "./shared/incremental_import_sql.js";
-import { buildGeneratedTableManifest, getGeneratedDefinitionPath, getGeneratedTableManifestPath, prefixedName, rawTypesDir, senatSchemaName, stagingSchemaName, stripDatasetPrefix, } from "./shared/prefixed_tables.js";
+import { buildGeneratedTableManifest, getGeneratedDefinitionPath, getGeneratedTableManifestPath, prefixedName, kanelTypesDir, kyselyTypesDir, senatSchemaName, stagingSchemaName, stripDatasetPrefix, } from "./shared/prefixed_tables.js";
 import { buildEnsureSchemaVersionTableSql, buildIncrementSchemaVersionSql, buildSchemaStructureFingerprintQuery, } from "./shared/schema_version.js";
 import { makeGenerateZodSchemas } from "./shared/make_generate_zod_schemas.js";
 import { buildExportStagingMetadataStatementsQuery } from "./shared/staging_metadata_sql.js";
@@ -29,7 +30,7 @@ const optionsDefinitions = [
     },
     {
         alias: "c",
-        help: "create TypeScript interfaces and Zod schemas from database tables into src/raw_types",
+        help: "create TypeScript interfaces, Zod schemas, and Kysely types from database tables",
         name: "schema",
         type: Boolean,
     },
@@ -379,11 +380,11 @@ function trimComment(comment) {
     return trimmed ? trimmed : undefined;
 }
 async function generateRawTypes(dataset, runtime, prefixedTables) {
-    await fs.ensureDir(rawTypesDir);
+    await fs.ensureDir(kanelTypesDir);
     const definitionFilePath = getGeneratedDefinitionPath(dataset.database);
     const manifestFilePath = getGeneratedTableManifestPath(dataset.database);
     const datasetPrefix = `${dataset.database}_`;
-    const datasetOutputPath = path.join(rawTypesDir, dataset.database);
+    const datasetOutputPath = path.join(kanelTypesDir, dataset.database);
     const generateZodSchemas = makeGenerateZodSchemas({
         castToSchema: true,
         getZodIdentifierMetadata: (column, details) => ({
@@ -447,7 +448,7 @@ async function generateRawTypes(dataset, runtime, prefixedTables) {
                 preRenderHooks: [generateZodSchemas],
             }),
         ],
-        outputPath: rawTypesDir,
+        outputPath: kanelTypesDir,
         postRenderHooks: [markAsGenerated, formatWithPrettier],
         schemaNames: [senatSchemaName],
         typescriptConfig: {
@@ -459,6 +460,68 @@ async function generateRawTypes(dataset, runtime, prefixedTables) {
     await fs.writeFile(definitionFilePath, generatedDefinition.replace(/\r\n/g, "\n"));
     await fs.writeFile(manifestFilePath, buildGeneratedTableManifest(dataset.database, prefixedTables));
 }
+async function generateKyselyTypes(dataset, runtime) {
+    const datasetPrefix = `${dataset.database}_`;
+    const datasetOutputDir = path.join(kyselyTypesDir, dataset.database);
+    await fs.remove(datasetOutputDir);
+    await fs.ensureDir(datasetOutputDir);
+    await processDatabase({
+        connection: {
+            database: runtime.target.name,
+            host: runtime.target.host,
+            password: runtime.target.password,
+            port: runtime.target.port,
+            user: runtime.target.user,
+        },
+        filter: (pgType) => pgType.schemaName === senatSchemaName && pgType.name.startsWith(datasetPrefix),
+        generators: [
+            makePgTsGenerator({
+                filter: (pgType) => pgType.schemaName === senatSchemaName && pgType.name.startsWith(datasetPrefix),
+                generateIdentifierType: (column, details, builtinType) => {
+                    const tableName = stripDatasetPrefix(details.name, dataset.database);
+                    return {
+                        ...builtinType,
+                        comment: undefined,
+                        name: toIdentifierName(tableName, column.name),
+                        typeDefinition: builtinType.typeDefinition.map((typeDefinition) => typeDefinition.replace(/ & \{ __flavor\?: '[^']+' \}/g, "").replace(/ & \{ __brand: '[^']+' \}/g, "")),
+                    };
+                },
+                getMetadata: (details, generateFor, builtinMetadata) => {
+                    const baseName = toPascalCase(stripDatasetPrefix(details.name, dataset.database));
+                    const suffix = generateFor === "selector" || generateFor === undefined ? "" : toPascalCase(generateFor);
+                    const tableComment = trimComment(details.comment);
+                    return {
+                        ...builtinMetadata,
+                        comment: tableComment ? [tableComment] : undefined,
+                        exportAs: generateFor === "selector" ? "default" : "named",
+                        name: `${baseName}${suffix}`,
+                        path: path.join(datasetOutputDir, baseName),
+                    };
+                },
+                getPropertyMetadata: (property, _details, _generateFor, builtinMetadata) => {
+                    const comment = trimComment(property.comment);
+                    return {
+                        ...builtinMetadata,
+                        comment: comment ? [comment] : undefined,
+                    };
+                },
+                preRenderHooks: [
+                    makeKyselyHook({
+                        databaseFilename: "Database",
+                        includeSchemaNameInTableName: false,
+                    }),
+                ],
+            }),
+        ],
+        outputPath: datasetOutputDir,
+        postRenderHooks: [markAsGenerated, formatWithPrettier],
+        schemaNames: [senatSchemaName],
+        typescriptConfig: {
+            enumStyle: "literal-union",
+            tsModuleFormat: "esm",
+        },
+    });
+}
 async function downloadFile(url, dest) {
     const response = await fetch(url);
     if (!response.ok) {
@@ -602,13 +665,14 @@ async function retrieveDataset(dataDir, dataset, options, runtime) {
         }
     }
     if (options["schema"]) {
-        await fs.ensureDir(rawTypesDir);
+        await fs.ensureDir(kanelTypesDir);
         if (!options["silent"]) {
             console.log(`Creating TypeScript definitions from prefixed ${senatSchemaName} tables ` +
                 `for '${dataset.database}' in database '${runtime.target.name}'...`);
         }
         const prefixedTables = listPrefixedTables(dataset, dataDir, options, runtime);
         await generateRawTypes(dataset, runtime, prefixedTables);
+        await generateKyselyTypes(dataset, runtime);
     }
 }
 function buildRuntimeContext() {

package/lib/src/scripts/retrieve_senateurs_photos.js

@@ -6,8 +6,8 @@ import path from "path";
 import { fileURLToPath } from "url";
 // import stream from "stream"
 // import util from "util"
-import * as git from "../git.js";
-import { findActif as findActifSenateurs } from "../model/sens.js";
+import * as git from "../server/git.js";
+import { findActif as findActifSenateurs } from "../server/sens.js";
 import { slugify } from "../strings.js";
 import { assertExistingDirectory, commonOptions } from "./shared/cli_helpers.js";
 const optionsDefinitions = [

package/lib/src/scripts/retrieve_videos.js

@@ -3,9 +3,9 @@ import commandLineArgs from "command-line-args";
 import fs from "fs-extra";
 import fsp from "fs/promises";
 import path from "path";
-import * as git from "../git.js";
-import { AGENDA_FOLDER, iterLoadSenatAgendas } from "../loaders.js";
-import { getSessionsFromStart, UNDEFINED_SESSION } from "../types/sessions.js";
+import * as git from "../server/git.js";
+import { AGENDA_FOLDER, iterLoadSenatAgendas } from "../server/loaders.js";
+import { getSessionsFromStart, UNDEFINED_SESSION } from "../other_types/sessions.js";
 import { assertExistingDirectory, commonOptions } from "./shared/cli_helpers.js";
 import { getAgendaSegmentTimecodes, buildSenatVodMasterM3u8FromNvs } from "../utils/nvs-parsing.js";
 import { epochToParisDateTime, isAmbiguousTimeOriginal, toTargetEpoch } from "../utils/date.js";

package/lib/src/scripts/shared/incremental_import_sql.js

@@ -10,7 +10,8 @@ function buildConfiguredMergeKeysValues(datasetName, mergeKeys) {
         .sort(([leftTable], [rightTable]) => leftTable.localeCompare(rightTable))
         .map(([tableName, columns]) => {
         const sqlColumns = columns.map((columnName) => `'${escapeSqlLiteral(columnName)}'`).join(", ");
-        return `SELECT '${escapeSqlLiteral(prefixedName(datasetName, tableName))}' AS tablename, ARRAY[${sqlColumns}]::text[] AS key_columns`;
+        return (`SELECT '${escapeSqlLiteral(prefixedName(datasetName, tableName))}'` +
+            ` AS tablename, ARRAY[${sqlColumns}]::text[] AS key_columns`);
     })
         .join("\nUNION ALL\n");
 }
@@ -371,7 +372,10 @@ BEGIN
       IF column_row.generated_kind = 's' THEN
         column_definition :=
           column_definition ||
-          ' GENERATED ALWAYS AS (' || replace(column_row.default_expression, '${stagingSchema}.', '${senatSchemaName}.') || ') STORED';
+          ' GENERATED ALWAYS AS (' ||
+          replace(column_row.default_expression,
+            '${stagingSchema}.', '${senatSchemaName}.') ||
+          ') STORED';
       ELSIF column_row.identity_kind = 'a' THEN
         column_definition := column_definition || ' GENERATED ALWAYS AS IDENTITY';
       ELSIF column_row.identity_kind = 'd' THEN
@@ -599,8 +603,12 @@ BEGIN
       AND columns.table_name = table_row.tablename;
 
     SELECT
-      string_agg(format('%1$I = s.%1$I', columns.column_name), ', ' ORDER BY columns.ordinal_position),
-      string_agg(format('t.%1$I IS DISTINCT FROM s.%1$I', columns.column_name), ' OR ' ORDER BY columns.ordinal_position)
+      string_agg(
+        format('%1$I = s.%1$I', columns.column_name),
+        ', ' ORDER BY columns.ordinal_position),
+      string_agg(
+        format('t.%1$I IS DISTINCT FROM s.%1$I', columns.column_name),
+        ' OR ' ORDER BY columns.ordinal_position)
     INTO update_assignments, change_condition
     FROM information_schema.columns columns
     WHERE columns.table_schema = '${escapedStagingSchema}'
@@ -636,8 +644,12 @@ BEGIN
     END IF;
 
     SELECT
-      'jsonb_build_array(' || string_agg(format('t.%I', columns.column_name), ', ' ORDER BY columns.ordinal_position) || ')',
-      'jsonb_build_array(' || string_agg(format('s.%I', columns.column_name), ', ' ORDER BY columns.ordinal_position) || ')'
+      'jsonb_build_array(' ||
+        string_agg(format('t.%I', columns.column_name),
+          ', ' ORDER BY columns.ordinal_position) || ')',
+      'jsonb_build_array(' ||
+        string_agg(format('s.%I', columns.column_name),
+          ', ' ORDER BY columns.ordinal_position) || ')'
     INTO target_row_signature_expression, staging_row_signature_expression
     FROM information_schema.columns columns
     WHERE columns.table_schema = '${escapedStagingSchema}'
@@ -745,7 +757,10 @@ BEGIN
       END IF;
 
       EXECUTE format(
-        'INSERT INTO ${senatSchemaName}.%1$I (%2$s) SELECT %3$s FROM %4$I.%1$I s WHERE NOT EXISTS (SELECT 1 FROM ${senatSchemaName}.%1$I t WHERE %5$s)',
+        'INSERT INTO ${senatSchemaName}.%1$I (%2$s) ' ||
+        'SELECT %3$s FROM %4$I.%1$I s ' ||
+        'WHERE NOT EXISTS ' ||
+        '(SELECT 1 FROM ${senatSchemaName}.%1$I t WHERE %5$s)',
         table_row.tablename,
         column_list,
         staging_column_list,

package/lib/src/scripts/shared/prefixed_tables.d.ts

@@ -1,5 +1,6 @@
 export declare const senatSchemaName = "senat";
-export declare const rawTypesDir: string;
+export declare const kanelTypesDir: string;
+export declare const kyselyTypesDir: string;
 export declare function prefixedName(datasetName: string, relationName: string): string;
 export declare function stagingSchemaName(datasetName: string): string;
 export declare function escapeRegExp(text: string): string;

package/lib/src/scripts/shared/prefixed_tables.js

@@ -1,6 +1,7 @@
 import path from "path";
 export const senatSchemaName = "senat";
-export const rawTypesDir = path.resolve("src", "raw_types");
+export const kanelTypesDir = path.resolve("src", "kanel_types");
+export const kyselyTypesDir = path.resolve("src", "kysely_types");
 export function prefixedName(datasetName, relationName) {
     return `${datasetName}_${relationName}`;
 }
@@ -15,10 +16,10 @@ export function stripDatasetPrefix(relationName, datasetName) {
     return relationName.startsWith(datasetPrefix) ? relationName.slice(datasetPrefix.length) : relationName;
 }
 export function getGeneratedDefinitionPath(datasetName) {
-    return path.join(rawTypesDir, `${datasetName}.ts`);
+    return path.join(kanelTypesDir, `${datasetName}.ts`);
 }
 export function getGeneratedTableManifestPath(datasetName) {
-    return path.join(rawTypesDir, `${datasetName}.tables.json`);
+    return path.join(kanelTypesDir, `${datasetName}.tables.json`);
 }
 export function buildGeneratedTableManifest(datasetName, prefixedTables) {
     const manifest = {

package/lib/src/scripts/shared/staging_import.d.ts

@@ -1,3 +1,3 @@
-import type { Dataset } from "../../datasets.js";
+import type { Dataset } from "../../server/datasets.js";
 export declare function isCopyFromStdinLine(line: string): boolean;
 export declare function rewriteLineForStagingImport(line: string, dataset: Dataset, stagingSchema: string, inCopyData?: boolean): string;

package/lib/src/scripts/validate_prefixed_tables.js

@@ -1,21 +1,22 @@
 import commandLineArgs from "command-line-args";
 import fs from "fs-extra";
-import { sql } from "../databases_postgres.js";
-import { getChosenDatasets, getEnabledDatasets } from "../datasets.js";
+import { sql } from "kysely";
+import { db } from "../server/databases_postgres.js";
+import { getChosenDatasets, getEnabledDatasets } from "../server/datasets.js";
 import { categoriesOption, silentOption } from "./shared/cli_helpers.js";
 import { extractPrefixedTableNamesFromGeneratedManifest, getGeneratedTableManifestPath, senatSchemaName, } from "./shared/prefixed_tables.js";
 const optionsDefinitions = [categoriesOption, silentOption];
 const options = commandLineArgs(optionsDefinitions);
 async function listPrefixedSenatTables(dataset) {
     const prefix = `${dataset.database}_`;
-    const rows = await sql `
-    select tablename as relation_name
+    const result = await sql `
+    select tablename
     from pg_tables
     where schemaname = ${senatSchemaName}
       and tablename like ${prefix + "%"}
     order by tablename
-  `;
-    return rows.map(({ relation_name }) => relation_name);
+  `.execute(db);
+    return result.rows.map(({ tablename }) => tablename);
 }
 function getGeneratedDefinitionPath(dataset) {
     return getGeneratedTableManifestPath(dataset.database);
@@ -26,14 +27,14 @@ function listExpectedPrefixedSenatTables(dataset) {
     return extractPrefixedTableNamesFromGeneratedManifest(manifest, dataset.database);
 }
 async function listColumns(schema, relationName) {
-    const rows = await sql `
+    const result = await sql `
     select column_name
     from information_schema.columns
     where table_schema = ${schema}
       and table_name = ${relationName}
     order by ordinal_position
-  `;
-    return rows.map(({ column_name }) => column_name);
+  `.execute(db);
+    return result.rows.map(({ column_name }) => column_name);
 }
 async function validateDataset(dataset) {
     const issues = [];
@@ -86,7 +87,7 @@ async function validatePrefixedTables() {
             console.error(`- ${issue}`);
         }
     }
-    await sql.end();
+    await db.destroy();
     if (hasErrors) {
         process.exit(1);
     }
@@ -95,7 +96,7 @@ async function validatePrefixedTables() {
     }
 }
 validatePrefixedTables().catch(async (error) => {
-    await sql.end();
+    await db.destroy();
     console.error(error);
     process.exit(1);
 });

package/lib/src/scrutins.d.ts

@@ -0,0 +1,47 @@
+export interface VoteScrutinRow {
+    groupe_politique_code: string | null;
+    groupe_politique_id: string | null;
+    matricule_delegant: string | null;
+    matricule_votant: string;
+    position: string | null;
+    statut_votant: string | null;
+    titre_votant: string | null;
+}
+export interface GroupeVotantRow {
+    groupe_politique_code: string | null;
+    nombre_abstentions: string;
+    nombre_contre: string;
+    nombre_non_votants: string;
+    nombre_pour: string;
+    nombre_votants: string;
+}
+export interface MiseAuPointRow {
+    ordre: string | null;
+    texte: string;
+    url: string | null;
+}
+export interface ScrutinResult {
+    date_scrutin: string | null;
+    date_scrutin_effective: string | null;
+    groupes_votants: GroupeVotantRow[];
+    intitule: string | null;
+    lecture_id: string | null;
+    lecture_libelle: string | null;
+    mises_au_point: MiseAuPointRow[];
+    nombre_contre: string | null;
+    nombre_contre_seance: string | null;
+    nombre_majorite: string | null;
+    nombre_majorite_seance: string | null;
+    nombre_pour: string | null;
+    nombre_pour_seance: string | null;
+    nombre_suffrages: string | null;
+    nombre_suffrages_seance: string | null;
+    nombre_votants: string | null;
+    nombre_votants_seance: string | null;
+    note: string | null;
+    numero: string;
+    session: string;
+    signet_dossier: string | null;
+    type_lecture: string | null;
+    votes: VoteScrutinRow[];
+}

package/lib/src/scrutins.js

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

package/lib/src/sens.d.ts

@@ -0,0 +1,104 @@
+export interface FonctionRow {
+    date_debut: string | null;
+    date_fin: string | null;
+    libelle: string | null;
+}
+export interface MandatSenateurRow {
+    code_circonscription: string | null;
+    date_debut: string | null;
+    date_fin: string | null;
+    etat: string | null;
+    etat_debut: string | null;
+    etat_fin: string | null;
+}
+export interface MandatOrganismeRow {
+    code_organisme: string;
+    date_debut: string | null;
+    date_fin: string | null;
+    etat: string | null;
+    fonctions: FonctionRow[];
+    libelle: string | null;
+    type_code_organisme: string | null;
+    type_organisme: string | null;
+}
+export interface AdressePointContactRow {
+    bureau_distributeur: string | null;
+    code_cedex: string | null;
+    code_postal: string | null;
+    commune: string | null;
+    complement: string | null;
+    complement2: string | null;
+    libelle_cedex: string | null;
+    nom_voie: string | null;
+    numero_voie: string | null;
+}
+export interface TelephonePointContactRow {
+    numero: string | null;
+    type: string;
+}
+export interface PointContactRow {
+    adresses: AdressePointContactRow[];
+    id: string;
+    libelle: string | null;
+    telephones: TelephonePointContactRow[];
+    type: string;
+}
+export interface UrlRow {
+    code_url: string;
+    url: string;
+}
+export interface SenateurResult {
+    PCS_INSEE: string | null;
+    PCS_INSEE_24: string | null;
+    PCS_INSEE_42: string | null;
+    PCS_INSEE_8: string | null;
+    circonscription: string | null;
+    code_circonscription: string | null;
+    code_commission_permanente: string | null;
+    code_groupe_politique: string | null;
+    commission_permanente: string | null;
+    commissions: MandatOrganismeRow[];
+    courrier_electronique: string | null;
+    date_deces: string | null;
+    date_naissance: string | null;
+    delegations: MandatOrganismeRow[];
+    description_profession: string | null;
+    etat: string;
+    fonction_bureau_senat: string | null;
+    fonctions_bureau: FonctionRow[];
+    groupe_politique: string | null;
+    groupes: MandatOrganismeRow[];
+    mandats_senateur: MandatSenateurRow[];
+    matricule: string;
+    nom_usuel: string | null;
+    points_contact: PointContactRow[];
+    prenom_usuel: string;
+    qualite: string;
+    siege: string | null;
+    url_hatvp: string | null;
+    urls: UrlRow[];
+}
+export interface CirconscriptionResult {
+    article: string | null;
+    code: string;
+    date_debut: string | null;
+    date_fin: string | null;
+    etat: string | null;
+    identifiant: string;
+    libelle_departement: string;
+    libelle_region: string;
+    nombre_senateurs: string | null;
+    url: string | null;
+}
+export interface OrganismeResult {
+    code: string;
+    date_debut: string | null;
+    date_fin: string | null;
+    etat: string | null;
+    libelle: string | null;
+    libelle_court: string | null;
+    libelle_long: string | null;
+    type_code: string;
+    type_libelle: string | null;
+    url: string | null;
+}

package/lib/src/sens.js

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

package/lib/src/server/agenda.d.ts

@@ -0,0 +1,6 @@
+import { AgendaEvent } from "../other_types/agenda.js";
+export declare function getStartAndEndTimes(timeStr: string | null | undefined, dateISO: string): {
+    startTime: string | null;
+    endTime: string | null;
+};
+export declare function parseAgendaFromFile(htmlFilePath: string): Promise<AgendaEvent[] | null>;

package/lib/src/server/agenda.js

@@ -0,0 +1,148 @@
+import { JSDOM } from "jsdom";
+import { DateTime } from "luxon";
+import path from "path";
+import { ID_DATE_FORMAT, STANDARD_DATE_FORMAT } from "../scripts/datautil.js";
+const FR_TZ = "Europe/Paris";
+function eventIsSeance(eventElement) {
+    return eventElement.classList.contains("evt-seance");
+}
+function getEventType(eventClasses) {
+    const typeClass = [...eventClasses].find((className) => className.startsWith("evt-")) || null;
+    switch (typeClass) {
+        case "evt-seance":
+            return "Séance publique";
+        case "evt-instanz":
+            return "Commissions";
+        case "evt-cemi":
+            return "Mission de contrôle";
+        case "evt-deleg":
+            return "Offices et délégations";
+        case "evt-bureau":
+            return "Instances décisionnelles";
+    }
+    return null;
+}
+function getUrlDossierSenat(lienElements) {
+    const urlElement = [...lienElements].find((lienElement) => lienElement.textContent?.includes("dossier législatif"));
+    return urlElement ? urlElement.getAttribute("href") : null;
+}
+function getQuantieme(eventElement, seancesElements) {
+    const seanceIndex = seancesElements.indexOf(eventElement);
+    if (seancesElements.length === 1 && seanceIndex === 0) {
+        return "Unique";
+    }
+    else {
+        switch (seanceIndex) {
+            case 0:
+                return "Première";
+            case 1:
+                return "Deuxième";
+            case 2:
+                return "Troisième";
+            case 3:
+                return "Quatrième";
+            case 4:
+                return "Cinquième";
+        }
+    }
+    return "Non défini";
+}
+/**
+ * Normalize time string to become a simple start time ("H'h'mm") or a duration ("'de 'H'h'mm' à 'H'h'mm").
+ */
+function normalizeTime(timeStr) {
+    return timeStr
+        ?.replace(/^À l'issue de l'espace réservé .* et au plus tard\s/i, "") // Must be processed first
+        ?.replace(/^(?:le )?matin/i, "10h00") // We chose "matin" to mean 10h00
+        ?.replace(/^(?:l')?après-midi/i, "16h00") // We chose "après-midi" to mean 16h00
+        ?.replace(/^(?:le )?soir/i, "20h00") // We chose "soir" to mean 20h00
+        ?.replace(/^(?:la )?nuit/i, "22h00") // We chose "nuit" to mean 22h00
+        ?.replace(/^à\s/gi, "")
+        ?.replace(/heures/gi, "h00")
+        ?.replace(/\set.*/i, "")
+        ?.replace(/,.*/, "")
+        ?.replace(/\s\(hors hémicycle\)/i, "")
+        ?.replace(/\s*h\s*/gi, "h");
+}
+export function getStartAndEndTimes(timeStr, dateISO) {
+    const normalizedTime = normalizeTime(timeStr);
+    if (!normalizedTime) {
+        return { startTime: null, endTime: null };
+    }
+    const rangeMatch = normalizedTime.match(/^de (?<start>\d{1,2}h\d{2}) à (?<end>\d{1,2}h\d{2})$/i);
+    const toUtcTimeOnly = (value) => {
+        if (!value)
+            return null;
+        const time = DateTime.fromFormat(value, "H'h'mm", { zone: FR_TZ });
+        if (!time.isValid)
+            return null;
+        const local = DateTime.fromISO(dateISO, { zone: FR_TZ }).set({
+            hour: time.hour,
+            minute: time.minute,
+            second: 0,
+            millisecond: 0,
+        });
+        if (!local.isValid)
+            return null;
+        return local.toUTC().toFormat("HH:mm:ss.SSS'Z'");
+    };
+    if (rangeMatch?.groups) {
+        const { start, end } = rangeMatch.groups;
+        return {
+            startTime: toUtcTimeOnly(start),
+            endTime: toUtcTimeOnly(end),
+        };
+    }
+    return {
+        startTime: toUtcTimeOnly(normalizedTime),
+        endTime: null,
+    };
+}
+function transformAgenda(document, fileName) {
+    const agendaEvents = [];
+    const eventElements = document.querySelectorAll(".evt");
+    const seanceElements = Array.from(eventElements).filter((eventElement) => eventIsSeance(eventElement));
+    for (const eventElement of eventElements) {
+        const id = eventElement.previousElementSibling?.getAttribute("name") || null;
+        if (!id) {
+            continue;
+        }
+        const type = getEventType(eventElement.classList);
+        const date = DateTime.fromFormat(fileName, ID_DATE_FORMAT).toFormat(STANDARD_DATE_FORMAT);
+        const timeOriginal = eventElement.querySelector(".time")?.textContent || null;
+        const { startTime, endTime } = getStartAndEndTimes(timeOriginal, date);
+        const titre = eventElement.querySelector(".titre")?.textContent?.trim() || "";
+        const organe = eventElement.querySelector(".organe")?.textContent?.trim() || null;
+        const objet = eventElement.querySelector(".objet")?.textContent?.trim()?.replace(/^- /, "") || null;
+        const lieu = eventElement.querySelector(".lieu")?.textContent || null;
+        const videoElement = eventElement.querySelector(".video");
+        const urlDossierSenat = getUrlDossierSenat(eventElement.querySelectorAll(".lien a"));
+        agendaEvents.push({
+            id,
+            type,
+            date,
+            startTime,
+            endTime,
+            timeOriginal,
+            titre,
+            organe,
+            objet,
+            lieu,
+            captationVideo: videoElement !== null,
+            urlDossierSenat: urlDossierSenat,
+            quantieme: eventIsSeance(eventElement) ? getQuantieme(eventElement, seanceElements) : null,
+        });
+    }
+    return agendaEvents;
+}
+export async function parseAgendaFromFile(htmlFilePath) {
+    try {
+        const { document } = (await JSDOM.fromFile(htmlFilePath, { contentType: "text/html" })).window;
+        const fileName = path.parse(htmlFilePath).name;
+        return transformAgenda(document, fileName);
+    }
+    catch (error) {
+        console.error(`Could not parse texte with error ${error.message}`);
+    }
+    return null;
+}

package/lib/src/server/ameli.d.ts

@@ -0,0 +1,2 @@
+import type { AmendementResult } from "../rich_types/ameli.js";
+export declare function findAllAmendements(fromSession?: number): AsyncGenerator<AmendementResult, void, unknown>;