-
{$seance.evenement?.nom}
+{#snippet tete()}
+
-
+{/snippet}
+
+
+
+ {#if $seance.supportRompu !== null}
+
+ {/if}
+
+
+
diff --git a/src/interface/evenement/modele.js b/src/interface/evenement/modele.js
new file mode 100644
index 0000000..44176d8
--- /dev/null
+++ b/src/interface/evenement/modele.js
@@ -0,0 +1,134 @@
+// © 2026 TechnoLibre (http://www.technolibre.ca)
+// License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl)
+
+// Le modèle de l'événement ouvert, pur : ce que ses composants montrent de
+// l'état observable de la séance (§ 8.4, § 8.5, § 8.8, § 8.9, § 9). Le cadre
+// de mode et sa forme, la commande de la place fixe, les états du plan et
+// leurs clés, la reprise de verrou que l'écran offre, et les avertissements
+// dans l'ordre de la séance, chacun avec son remède. Rien n'y est décidé
+// que la séance ne décide déjà : le refus courant, le mode et l'état du plan
+// se lisent dans EtatSeance, jamais se recalculent.
+import { cleDeMode } from '../mode.js';
+
+// La forme du cadre pour chaque clé du libellé de mode : un trait différent
+// par mode, pour qu'aucun ne se distingue par la seule couleur (§ 14.5).
+const FORMES = new Map([
+ ['coquille.mode.lecture', 'tirets'],
+ ['coquille.mode.ecriture', 'plein'],
+ ['coquille.mode.bloque', 'double'],
+]);
+
+/**
+ * Libellé et forme du cadre de mode : cle, celle de cleDeMode (mode.js) — le
+ * libellé du bandeau — ; forme : lecture (tirets), écriture (trait plein),
+ * bloqué (trait double), quel que soit le mode d'un plan bloqué. null sans
+ * événement.
+ *
+ * @param {Object} etatSeance EtatSeance
+ * @returns {null|{cle: string, forme: 'tirets'|'plein'|'double'}}
+ */
+export function cadreDeMode(etatSeance) {
+ const cle = cleDeMode(etatSeance);
+ if (cle === null) return null;
+ return { cle, forme: FORMES.get(cle) };
+}
+
+/**
+ * La commande de la place fixe (§ 8.4, § 8.5, § 8.8) : 'format' quand le
+ * refus courant est celui d'un format plus récent — l'explication remplace
+ * alors toute commande, plan bloqué compris ; 'debloquer' sur un plan
+ * bloqué ; 'lecture' — « Revenir en lecture » — en écriture ; 'modifier'
+ * sinon. null sans événement.
+ *
+ * @param {Object} etatSeance EtatSeance
+ * @returns {null|'format'|'debloquer'|'lecture'|'modifier'}
+ */
+export function commandeFixe(etatSeance) {
+ if (etatSeance.evenement === null) return null;
+ const { refus } = etatSeance;
+ if (refus?.code === 'LECTURE_SEULE' && refus.details?.raison === 'FORMAT') return 'format';
+ if (etatSeance.evenement.etat === 'bloque') return 'debloquer';
+ return etatSeance.mode === 'ecriture' ? 'lecture' : 'modifier';
+}
+
+/** Les états d'un plan (§ 9), dans l'ordre du spec. */
+export const ETATS_PLAN = Object.freeze(['brouillon', 'propose', 'retenu', 'bloque']);
+
+/**
+ * La clé du libellé d'un état du plan, evenement.etat.
.
+ *
+ * @param {string} etat
+ * @returns {string}
+ * @throws {RangeError} hors d'ETATS_PLAN
+ */
+export function cleEtat(etat) {
+ if (!ETATS_PLAN.includes(etat)) throw new RangeError(`état du plan inconnu : ${JSON.stringify(etat)}`);
+ return `evenement.etat.${etat}`;
+}
+
+/**
+ * Le verrou que l'écran offre de reprendre (§ 8.8) : en lecture, celui qui a
+ * refusé le dernier passage en écriture quand sa vie ne se prouve pas
+ * (vivant null) — un autre poste, un verrou illisible. Un verrou vivant ne
+ * se reprend jamais, et celui d'une séance morte, la séance le reprend
+ * seule. null sinon.
+ *
+ * @param {Object} etatSeance EtatSeance
+ * @returns {null|{seance: string|null, depuis: string|null, vivant: null}}
+ */
+export function repriseOfferte(etatSeance) {
+ const { evenement, mode, verrouAutre } = etatSeance;
+ if (evenement === null || mode !== 'lecture' || verrouAutre === null || verrouAutre.vivant !== null) return null;
+ return verrouAutre;
+}
+
+// Le remède que l'écran joint à un avertissement : rouvrir la version
+// précédente d'un retenu fautif ; ouvrir les propositions devant une dérive,
+// et les tables devant des places manquantes. Les autres n'en ont pas.
+const VERS_PROPOSITIONS = Object.freeze({ geste: 'ouvrirSection', section: 'propositions' });
+const REMEDES = new Map([
+ ['RETENU_FAUTIF', Object.freeze({ geste: 'ouvrirSecours', source: 'precedent' })],
+ ['DERIVE', VERS_PROPOSITIONS],
+ ['DERIVE_NOUVELLE', VERS_PROPOSITIONS],
+ ['PLACES_MANQUANTES', Object.freeze({ geste: 'ouvrirSection', section: 'tables' })],
+]);
+
+// Ce que l'examen de la séance dit de chaque placement que nomme une dérive
+// {ids, retenu} : le retenu d'abord, quand la dérive le nomme, puis chaque
+// proposition de ids, dans l'ordre de ids, avec ses raisons. Un placement
+// que l'examen ne porte pas n'apparaît pas.
+function derivesNommees({ ids = [], retenu = false }, examen) {
+ if (examen === null || examen === undefined) return [];
+ const nommees = [];
+ if (retenu && examen.retenu.raisons.length > 0) nommees.push({ id: 'retenu', raisons: examen.retenu.raisons });
+ for (const id of ids) {
+ const derive = examen.derives.find((candidate) => candidate.id === id);
+ if (derive !== undefined) nommees.push({ id, raisons: derive.raisons });
+ }
+ return nommees;
+}
+
+/**
+ * Les avertissements à montrer, dans l'ordre d'EtatSeance.avertissements —
+ * celui de la séance : ceux de l'Ouvert courant, INVARIANT_VIOLE, ceux du
+ * dernier geste, RETOUR_AUTOMATIQUE —, sans en retirer ni en ajouter. Chacun
+ * garde son code et ses détails, et reçoit son remède : RETENU_FAUTIF →
+ * { geste: 'ouvrirSecours', source: 'precedent' } ; DERIVE et
+ * DERIVE_NOUVELLE → { geste: 'ouvrirSection', section: 'propositions' } ;
+ * PLACES_MANQUANTES → { geste: 'ouvrirSection', section: 'tables' } ; null
+ * pour les autres. PROPOSITIONS_FAUTIVES porte en plus fautives, celles
+ * d'EtatSeance.fautives ; DERIVE, derives, ce que l'examen dit de chaque
+ * placement qu'elle nomme ({id: number|'retenu', raisons}). Le texte vient
+ * de la traduction, sur le code.
+ *
+ * @param {Object} etatSeance EtatSeance
+ * @returns {Array<{code: string, details: Object, remede: Object|null, fautives?: Object[], derives?: Object[]}>}
+ */
+export function avertissementsOrdonnes(etatSeance) {
+ return etatSeance.avertissements.map(({ code, details }) => {
+ const rendu = { code, details, remede: REMEDES.get(code) ?? null };
+ if (code === 'PROPOSITIONS_FAUTIVES') rendu.fautives = etatSeance.fautives;
+ if (code === 'DERIVE') rendu.derives = derivesNommees(details, etatSeance.examen);
+ return rendu;
+ });
+}
diff --git a/src/interface/evenement/modele.test.js b/src/interface/evenement/modele.test.js
new file mode 100644
index 0000000..23618ea
--- /dev/null
+++ b/src/interface/evenement/modele.test.js
@@ -0,0 +1,218 @@
+// © 2026 TechnoLibre (http://www.technolibre.ca)
+// License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl)
+
+// Le modèle de l'événement ouvert (§ 8.4, § 8.5, § 8.8, § 8.9, § 9) : le cadre
+// de mode et sa forme, la commande de la place fixe, les états du plan et
+// leurs clés, la reprise de verrou offerte, et les avertissements ordonnés,
+// chacun avec son remède. Chaque épreuve part d'un EtatSeance réduit à ce que
+// la fonction lit ; les noms et identifiants sont inventés.
+import assert from 'node:assert/strict';
+import { describe, test } from '../../../test/lanceur.js';
+import { TABLES_APPLICATION } from '../../application/libelles.js';
+import { creerTraduction } from '../../application/traduction.js';
+import { TABLES_INTERFACE } from '../libelles.js';
+import { ETATS_PLAN, avertissementsOrdonnes, cadreDeMode, cleEtat, commandeFixe, repriseOfferte } from './modele.js';
+
+const { t } = creerTraduction([...TABLES_APPLICATION, ...TABLES_INTERFACE]);
+
+const FORMAT_REFUS = { code: 'LECTURE_SEULE', details: { raison: 'FORMAT', remede: null } };
+const BLOQUE_REFUS = { code: 'LECTURE_SEULE', details: { raison: 'BLOQUE', remede: { geste: 'debloquer' } } };
+
+// Un EtatSeance réduit : mode, événement (null, ou son état du plan), refus,
+// avertissements, fautives, examen, verrouAutre.
+function etat({
+ mode = 'lecture',
+ plan = 'brouillon',
+ refus = null,
+ avertissements = [],
+ fautives = [],
+ examen = null,
+ verrouAutre = null,
+} = {}) {
+ return {
+ mode,
+ evenement:
+ plan === null ? null : { base: 'merles', id: 'evt-merles', nom: 'Club des Merles', etat: plan, revision: 3, annonceFormat: null },
+ refus,
+ avertissements,
+ fautives,
+ examen,
+ verrouAutre,
+ };
+}
+
+describe('cadreDeMode (§ 8.4, § 14.5)', () => {
+ test('null sans événement', () => {
+ assert.equal(cadreDeMode(etat({ plan: null })), null);
+ });
+
+ test('lecture : tirets ; écriture : trait plein ; bloqué : trait double, quel que soit le mode', () => {
+ assert.deepEqual(cadreDeMode(etat({ mode: 'lecture' })), { cle: 'coquille.mode.lecture', forme: 'tirets' });
+ assert.deepEqual(cadreDeMode(etat({ mode: 'ecriture' })), { cle: 'coquille.mode.ecriture', forme: 'plein' });
+ assert.deepEqual(cadreDeMode(etat({ mode: 'lecture', plan: 'bloque' })), { cle: 'coquille.mode.bloque', forme: 'double' });
+ assert.deepEqual(cadreDeMode(etat({ mode: 'ecriture', plan: 'bloque' })), { cle: 'coquille.mode.bloque', forme: 'double' });
+ });
+
+ test('trois formes distinctes pour trois libellés distincts, chaque libellé traduit', () => {
+ const cadres = [etat(), etat({ mode: 'ecriture' }), etat({ plan: 'bloque' })].map(cadreDeMode);
+ assert.equal(new Set(cadres.map(({ forme }) => forme)).size, 3);
+ assert.equal(new Set(cadres.map(({ cle }) => t(cle))).size, 3);
+ });
+});
+
+describe('commandeFixe (§ 8.4, § 8.5, § 8.8)', () => {
+ test('null sans événement ; modifier en lecture ; lecture en écriture ; debloquer sur un plan bloqué', () => {
+ assert.equal(commandeFixe(etat({ plan: null })), null);
+ assert.equal(commandeFixe(etat()), 'modifier');
+ assert.equal(commandeFixe(etat({ mode: 'ecriture', plan: 'retenu' })), 'lecture');
+ assert.equal(commandeFixe(etat({ plan: 'bloque', refus: BLOQUE_REFUS })), 'debloquer');
+ });
+
+ test("un format plus récent remplace la commande par l'explication, avant le plan bloqué", () => {
+ assert.equal(commandeFixe(etat({ refus: FORMAT_REFUS })), 'format');
+ assert.equal(commandeFixe(etat({ plan: 'bloque', refus: FORMAT_REFUS })), 'format');
+ });
+});
+
+describe('les états du plan (§ 9)', () => {
+ test("les quatre états, dans l'ordre du § 9, figés, chacun sous sa clé evenement.etat., traduite", () => {
+ assert.deepEqual(ETATS_PLAN, ['brouillon', 'propose', 'retenu', 'bloque']);
+ assert.ok(Object.isFrozen(ETATS_PLAN));
+ assert.ok(ETATS_PLAN.length > 0);
+ for (const nom of ETATS_PLAN) {
+ assert.equal(cleEtat(nom), `evenement.etat.${nom}`);
+ assert.notEqual(t(cleEtat(nom)).trim(), '');
+ }
+ assert.equal(new Set(ETATS_PLAN.map((nom) => t(cleEtat(nom)))).size, 4);
+ });
+
+ test('un état inconnu lève RangeError', () => {
+ assert.throws(() => cleEtat('archive'), RangeError);
+ assert.throws(() => cleEtat('toString'), RangeError);
+ });
+});
+
+describe('repriseOfferte (§ 8.8)', () => {
+ const lointain = { seance: 'lointaine-1', depuis: '2031-05-17T09:00:00-04:00', vivant: null };
+
+ test('en lecture, un verrou refusé dont la vie ne se prouve pas : le verrou, à reprendre', () => {
+ assert.deepEqual(repriseOfferte(etat({ verrouAutre: lointain })), lointain);
+ const illisible = { seance: null, depuis: null, vivant: null };
+ assert.deepEqual(repriseOfferte(etat({ verrouAutre: illisible })), illisible);
+ });
+
+ test('ni sans verrou refusé, ni en écriture, ni sans événement, ni pour un verrou vivant ou mort', () => {
+ assert.equal(repriseOfferte(etat()), null);
+ assert.equal(repriseOfferte(etat({ mode: 'ecriture', verrouAutre: lointain })), null);
+ assert.equal(repriseOfferte(etat({ plan: null, verrouAutre: lointain })), null);
+ assert.equal(repriseOfferte(etat({ verrouAutre: { ...lointain, vivant: true } })), null);
+ assert.equal(repriseOfferte(etat({ verrouAutre: { ...lointain, vivant: false } })), null);
+ });
+});
+
+describe('avertissementsOrdonnes (§ 8.6, § 8.8, § 8.9, § 9)', () => {
+ // Un avertissement de chaque code du contrat, dans l'ordre où la séance
+ // les rend, avec des détails de forme quelconque : la fonction n'en lit
+ // aucun, hors de ceux qu'elle complète.
+ const CODES = [
+ 'RETENU_FAUTIF',
+ 'JOURNAL_REPRIS',
+ 'JOURNAL_EN_AVANCE_DE',
+ 'JOURNAL_INCOMPLET',
+ 'JOURNAL_ECARTEES',
+ 'JOURNAL_RECREE',
+ 'JOURNAL_FORMAT_PLUS_RECENT',
+ 'JOURNAL_ILLISIBLE',
+ 'JOURNAL_ETRANGER',
+ 'PROPOSITIONS_FAUTIVES',
+ 'PROPOSITIONS_MANQUANTES',
+ 'DERIVE',
+ 'INVARIANT_VIOLE',
+ 'VERROU_REPRIS',
+ 'EVENEMENT_CHANGE',
+ 'VERROU_NON_RENDU',
+ 'JALON_NON_ECRIT',
+ 'SUPPORT_AMOVIBLE',
+ 'RESERVATIONS_SUSPENDUES',
+ 'IMPORT_EN_RETENU',
+ 'PLACES_MANQUANTES',
+ 'DERIVE_NOUVELLE',
+ 'RESERVATION_NON_HONOREE',
+ 'CONFIGURATION_INCOHERENTE',
+ 'RETOUR_AUTOMATIQUE',
+ ];
+ const REMEDES = new Map([
+ ['RETENU_FAUTIF', { geste: 'ouvrirSecours', source: 'precedent' }],
+ ['DERIVE', { geste: 'ouvrirSection', section: 'propositions' }],
+ ['DERIVE_NOUVELLE', { geste: 'ouvrirSection', section: 'propositions' }],
+ ['PLACES_MANQUANTES', { geste: 'ouvrirSection', section: 'tables' }],
+ ]);
+ const avertissement = (code, rang) => ({ code, details: { rang, ids: [], retenu: false } });
+
+ test('[] sans avertissement', () => {
+ assert.deepEqual(avertissementsOrdonnes(etat()), []);
+ assert.deepEqual(avertissementsOrdonnes(etat({ plan: null })), []);
+ });
+
+ test("l'ordre de la séance, codes et détails gardés, chacun avec son remède, null hors des quatre", () => {
+ const recus = CODES.map(avertissement);
+ const rendus = avertissementsOrdonnes(etat({ avertissements: recus }));
+ assert.equal(rendus.length, CODES.length);
+ assert.ok(rendus.length > 0);
+ rendus.forEach((rendu, rang) => {
+ assert.equal(rendu.code, CODES[rang]);
+ assert.deepEqual(rendu.details, recus[rang].details);
+ assert.deepEqual(rendu.remede, REMEDES.get(rendu.code) ?? null, rendu.code);
+ });
+ });
+
+ test("l'ordre est celui reçu, jamais un ordre propre : la liste renversée revient renversée", () => {
+ const renverses = [...CODES].reverse().map(avertissement);
+ assert.deepEqual(
+ avertissementsOrdonnes(etat({ avertissements: renverses })).map(({ code }) => code),
+ [...CODES].reverse(),
+ );
+ });
+
+ test('PROPOSITIONS_FAUTIVES porte les fautives de la séance, et lui seul', () => {
+ const fautives = [{ rang: 1, id: 4, fautes: [{ code: 'LONGUEUR', chemin: 'tours' }] }];
+ const rendus = avertissementsOrdonnes(
+ etat({ fautives, avertissements: [{ code: 'PROPOSITIONS_FAUTIVES', details: { ids: [4] } }, avertissement('DERIVE_NOUVELLE', 0)] }),
+ );
+ assert.deepEqual(rendus[0].fautives, fautives);
+ assert.equal(Object.hasOwn(rendus[1], 'fautives'), false);
+ });
+
+ test("DERIVE porte ce que l'examen dit de chaque placement nommé : le retenu d'abord, puis chaque proposition de ids", () => {
+ const raisonRetenu = { code: 'PARTICIPANT_EXCLU', participant: 2 };
+ const raisonCinq = { code: 'TOURS_CHANGES', avant: 3, maintenant: 2 };
+ const examen = {
+ derives: [
+ { id: 5, raisons: [raisonCinq] },
+ { id: 9, raisons: [raisonCinq] },
+ ],
+ retenu: { fautes: [], raisons: [raisonRetenu] },
+ };
+ const [derive] = avertissementsOrdonnes(
+ etat({ examen, avertissements: [{ code: 'DERIVE', details: { ids: [5], retenu: true } }] }),
+ );
+ assert.deepEqual(derive.derives, [
+ { id: 'retenu', raisons: [raisonRetenu] },
+ { id: 5, raisons: [raisonCinq] },
+ ]);
+ const [seule] = avertissementsOrdonnes(etat({ examen, avertissements: [{ code: 'DERIVE', details: { ids: [9], retenu: false } }] }));
+ assert.deepEqual(seule.derives, [{ id: 9, raisons: [raisonCinq] }]);
+ const [sansExamen] = avertissementsOrdonnes(etat({ avertissements: [{ code: 'DERIVE', details: { ids: [9], retenu: false } }] }));
+ assert.deepEqual(sansExamen.derives, []);
+ });
+
+ test('chaque remède rendu se traduit : sa clé existe', () => {
+ const rendus = avertissementsOrdonnes(etat({ avertissements: CODES.map(avertissement) }));
+ const avecRemede = rendus.filter(({ remede }) => remede !== null);
+ assert.equal(avecRemede.length, 4);
+ for (const { remede } of avecRemede) {
+ const cle = remede.geste === 'ouvrirSecours' ? `communs.remede.ouvrirSecours.${remede.source}` : `communs.remede.ouvrirSection.${remede.section}`;
+ assert.notEqual(t(cle).trim(), '');
+ }
+ });
+});
diff --git a/src/interface/import/Apercu.svelte b/src/interface/import/Apercu.svelte
new file mode 100644
index 0000000..46d4220
--- /dev/null
+++ b/src/interface/import/Apercu.svelte
@@ -0,0 +1,322 @@
+
+
+
+
+
+
+ {#if source.origine === 'fichier'}
+ - {t('import.apercu.fichier')}
+ - {source.nom}
+ {:else}
+ - {t('import.apercu.collage')}
+
+ {/if}
+ {#if modele.encodage !== null}
+ - {t('import.apercu.encodage')}
+ - {t(modele.encodage)}
+ {/if}
+ {#if modele.separateur !== null}
+ - {t('import.apercu.separateur')}
+ - {t(modele.separateur)}
+ {/if}
+
+
+ {#if global !== null}
+
+
{t(global.cle, global.details)}
+ {#if !global.remede.dansLaCause}
+
{t(global.remede.cle, global.remede.details)}
+ {/if}
+
+ {/if}
+
+ {#if modele.colonnes.length > 0}
+
+ {t('import.apercu.colonnes')}
+
+
+ | {t('import.apercu.entete')} |
+ {t('import.apercu.devient')} |
+
+
+
+ {#each modele.colonnes as colonne (colonne.rang)}
+
+ | {colonne.entete} |
+ {t(colonne.cle)} |
+
+ {/each}
+
+
+ {/if}
+
+ {#if choisir !== null}
+ {#each modele.ambigus as ambigu (ambigu.champ)}
+
+ {/each}
+ {/if}
+
+ {#if global === null || modele.valides > 0}
+
+ {format.nombre(modele.valides)}
+ {t('import.apercu.valides', { n: modele.valides })}
+
+ {/if}
+
+ {#if modele.lignes.length > 0}
+
+
+
+
+ | {t('import.apercu.ligne')} |
+ {#each COLONNES_DES_LIGNES as { champ, cle } (champ)}
+ {t(cle)} |
+ {/each}
+
+
+
+ {#each modele.lignes as { ligne, cellules } (ligne)}
+
+ | {format.nombre(ligne)} |
+ {#each cellules as { champ, texte, cle } (champ)}
+ {cle === null ? (texte ?? '') : t(cle)} |
+ {/each}
+
+ {/each}
+
+
+
+ {/if}
+
+ {#if refuseesMontrees.length > 0}
+
+ {t('import.apercu.refusees')}
+
+
+ | {t('import.apercu.ligne')} |
+ {t('import.apercu.motif')} |
+
+
+
+ {#each refuseesMontrees as { ligne, code, details } (ligne)}
+
+ | {format.nombre(ligne)} |
+
+ {motif(code, details)}
+ {#if details.participants !== undefined}
+ {t('import.rapport.designees')}
+ {#each nommer(participants, details.participants) as personne (personne.id)}
+
+ {#if personne.prenom !== null}{personne.prenom}{/if}
+ {personne.nom}
+
+ {/each}
+ {/if}
+ |
+
+ {/each}
+
+
+ {/if}
+
+ {#if modele.fusions.length > 0}
+
+ {t('import.apercu.fusions')}
+
+ {#each modele.fusions as fusion, rang (rang)}
+ -
+ {t('import.apercu.affichee')}
+ {fusion.affichee}
+
+ {#each fusion.orthographes as orthographe (orthographe.texte)}
+ -
+ {orthographe.texte}
+ {format.nombre(orthographe.lignes)}
+ {t('import.apercu.orthographeLignes', { n: orthographe.lignes })}
+
+ {/each}
+
+
+ {/each}
+
+
+ {/if}
+
+ {#if modele.doublons.length > 0}
+
+ {t('import.apercu.doublons')}
+
+ {#each modele.doublons as doublon, rang (rang)}
+ -
+ {t('import.apercu.doublonLignes')}
+ {#each doublon.lignes as ligne (ligne)}
+ {format.nombre(ligne)}
+ {/each}
+ {#if doublon.existants.length > 0}
+ {t('import.apercu.doublonExistants')}
+ {#each nommer(participants, doublon.existants) as personne (personne.id)}
+
+ {#if personne.prenom !== null}{personne.prenom}{/if}
+ {personne.nom}
+
+ {/each}
+ {/if}
+
+ {/each}
+
+
+ {/if}
+
+ {#if modele.homonymes.length > 0}
+
+ {t('import.apercu.homonymes')}
+
+ {#each modele.homonymes as homonyme (homonyme.ligne)}
+ -
+ {t('import.apercu.ligne')}
+ {format.nombre(homonyme.ligne)}
+ {#each nommer(participants, homonyme.participants) as personne (personne.id)}
+
+ {#if personne.prenom !== null}{personne.prenom}{/if}
+ {personne.nom}
+
+ {/each}
+
+ {/each}
+
+
+ {/if}
+
+ {#if modele.multilignes.length > 0}
+
+ {t('import.apercu.multilignes')}
+
+ {#each modele.multilignes as multiligne (multiligne.ligne)}
+ -
+ {t('import.apercu.ligne')}
+ {format.nombre(multiligne.ligne)}
+
+ {/each}
+
+
+ {/if}
+
{t('import.rapport.titre')}
+ {#if rapport.libelle === null}
+ {t('import.rapport.rienEcrit')}
+ {/if}
+
+ {#each COMPTES as [nom, cle] (nom)}
+ -
+ {format.nombre(rapport.resume[nom])}
+ {t(cle, { n: rapport.resume[nom] })}
+
+ {/each}
+
+
+
+
+
diff --git a/src/interface/import/SectionImport.svelte b/src/interface/import/SectionImport.svelte
index 8307797..6a2172f 100644
--- a/src/interface/import/SectionImport.svelte
+++ b/src/interface/import/SectionImport.svelte
@@ -2,12 +2,292 @@
License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl) -->
-
+
+
+
{t('coquille.section.import')}
+ {t('import.consigne')}
+
+
+
+
+ {#if source !== null}
+ {#key source}
+
+ {/key}
+ {/if}
+
+ {#if rapport !== null}
+
+
+ {#if rapport.resume.refusees.length > 0}
+ enregistrerRefus(exporterRefus(rapport.apercu, rapport.resume.refusees))}
+ />
+ {/if}
+ (rapport = null)} />
+
+ {#if enregistre !== null}
+ {t('import.refusEnregistres')} {enregistre}
+ {/if}
+ {/if}
+
+ {#if confirmation !== null}
+ (confirmation = null)}
+ />
+ {/if}
+
+
diff --git a/src/interface/import/modele.js b/src/interface/import/modele.js
new file mode 100644
index 0000000..72c2c18
--- /dev/null
+++ b/src/interface/import/modele.js
@@ -0,0 +1,309 @@
+// © 2026 TechnoLibre (http://www.technolibre.ca)
+// License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl)
+
+// Le modèle de l'aperçu d'import (§ 10.1, § 10.2) : ce que l'aperçu montre,
+// en clés de libellés et en données, d'un fichier décodé, d'un fichier que
+// decoder refuse, ou d'un collage. Le texte vient de la traduction ; ce
+// module ne choisit que les clés, et ne recalcule rien de ce que l'aperçu de
+// src/csv établit : association, lignes, fusions et doublons s'y lisent tels
+// quels.
+import { CHAMPS } from '../../application/csv.js';
+
+/** La clé du nom de chaque encodage que rend decoder, dans l'ordre de ses
+ * quatre temps. */
+export const ENCODAGES = new Map([
+ ['utf-8-bom', 'import.encodage.utf8Marque'],
+ ['utf-16le', 'import.encodage.utf16le'],
+ ['utf-16be', 'import.encodage.utf16be'],
+ ['utf-8', 'import.encodage.utf8'],
+ ['windows-1252', 'import.encodage.windows1252'],
+]);
+
+/** La clé du nom de chaque séparateur de l'aperçu ; null : le fichier n'a
+ * qu'une colonne. */
+export const SEPARATEURS = new Map([
+ [';', 'import.separateur.pointVirgule'],
+ [',', 'import.separateur.virgule'],
+ ['\t', 'import.separateur.tabulation'],
+ [null, 'import.separateur.uneColonne'],
+]);
+
+// La clé du nom de chaque champ, dans l'ordre de CHAMPS.
+const CLES_DES_CHAMPS = new Map([
+ ['nom', 'import.champ.nom'],
+ ['prenom', 'import.champ.prenom'],
+ ['appartenance', 'import.champ.appartenance'],
+ ['courriel', 'import.champ.courriel'],
+ ['titre_pressenti', 'import.champ.titrePressenti'],
+ ['exclu', 'import.champ.exclu'],
+ ['notes', 'import.champ.notes'],
+]);
+
+// La clé de la valeur lue d'« exclu » ; une cellule vide n'en a pas.
+const CLES_D_EXCLU = new Map([
+ [true, 'import.exclu.oui'],
+ [false, 'import.exclu.non'],
+]);
+
+// Le nom de chaque champ dans ChampsLus, celui de l'aperçu de src/csv.
+const CHAMPS_LUS = new Map([['titre_pressenti', 'titrePressenti']]);
+
+/** Les trois modes de l'import (§ 10.1), dans l'ordre où l'écran les
+ * offre, et la clé de leur nom. */
+export const MODES_D_IMPORT = Object.freeze(
+ [
+ ['ajouter', 'import.mode.ajouter'],
+ ['mettreAJour', 'import.mode.mettreAJour'],
+ ['remplacer', 'import.mode.remplacer'],
+ ].map(([mode, cle]) => Object.freeze({ mode, cle })),
+);
+
+/** Les colonnes du tableau des lignes : chaque champ, dans l'ordre de
+ * CHAMPS, et la clé de son nom. */
+export const COLONNES_DES_LIGNES = Object.freeze(CHAMPS.map((champ) => Object.freeze({ champ, cle: CLES_DES_CHAMPS.get(champ) })));
+
+// Le remède d'un refus de decoder : le code que ses détails portent, que le
+// texte du refus compose déjà (contrat « Refus et avertissements »).
+const REFUS_DE_DECODER = new Set(['UTF16_SANS_MARQUE', 'UTF16_INVALIDE', 'UTF8_INVALIDE', 'CARACTERE_NUL']);
+
+// La clé du remède de chaque refus global de l'aperçu. Un caractère nul n'y
+// arrive que d'un texte collé : celui d'un fichier, decoder le refuse.
+const REMEDES_DE_L_APERCU = new Map([
+ ['CARACTERE_NUL', 'import.remede.caractereNulCollage'],
+ ['AUCUN_ENTETE', 'import.remede.aucunEntete'],
+ ['NOM_NON_ASSOCIE', 'import.remede.nomNonAssocie'],
+ ['AUCUNE_LIGNE_VALIDE', 'import.remede.aucuneLigneValide'],
+ ['GUILLEMET_OUVERT', 'import.remede.guillemetOuvert'],
+ ['SEPARATEUR_INTROUVABLE', 'import.remede.separateurIntrouvable'],
+]);
+
+// Le remède d'un collage auquel l'aperçu offre l'ordre de la grille.
+const REMEDES_DE_LA_GRILLE = new Map([
+ ['AUCUN_ENTETE', 'import.remede.aucunEnteteCollage'],
+ ['SEPARATEUR_INTROUVABLE', 'import.remede.separateurIntrouvableCollage'],
+]);
+
+// La valeur d'une table de clés, ou RangeError qui nomme ce qui manque :
+// jamais une clé devinée.
+function dans(table, valeur, quoi) {
+ if (!table.has(valeur)) throw new RangeError(`import : ${quoi} inconnu ${JSON.stringify(valeur)}`);
+ return table.get(valeur);
+}
+
+// Vrai quand l'aperçu offre la lecture dans l'ordre de la grille : un texte
+// non blanc sans en-tête reconnu, ou une seule colonne sans séparateur.
+function offreLaGrille(apercu) {
+ if (apercu.refusGlobal === 'AUCUN_ENTETE') return apercu.entetes.length > 0;
+ return apercu.refusGlobal === 'SEPARATEUR_INTROUVABLE' && apercu.refusGlobalLigne === null;
+}
+
+// Le refus global d'un refus de decoder : sa cause, le code ; son remède,
+// le code de details.remede, déjà dans la cause.
+function globalDeDecoder({ code, details }) {
+ if (!REFUS_DE_DECODER.has(code)) throw new RangeError(`import : refus de decoder inconnu ${JSON.stringify(code)}`);
+ return { cle: code, details, remede: { cle: details.remede, details: {}, dansLaCause: true } };
+}
+
+// Le refus global d'un aperçu, null sans refus. Un collage auquel l'aperçu
+// offre l'ordre de la grille prend le remède qui le nomme.
+function globalDeLApercu(apercu, collage) {
+ const code = apercu.refusGlobal;
+ if (code === null) return null;
+ const remede = collage && offreLaGrille(apercu) ? REMEDES_DE_LA_GRILLE.get(code) : dans(REMEDES_DE_L_APERCU, code, 'refus global');
+ const rang = apercu.refusGlobalLigne;
+ const details = rang === null ? {} : { ligne: rang };
+ return { cle: code, details, remede: { cle: remede, details, dansLaCause: false } };
+}
+
+// Le nom du séparateur, quand la lecture l'a établi : rien sous un caractère
+// nul, un séparateur introuvable ou un texte blanc, où l'aperçu porte null
+// sans que le texte ait une seule colonne.
+function separateurDe(apercu) {
+ const nonEtabli =
+ apercu.refusGlobal === 'CARACTERE_NUL' ||
+ apercu.refusGlobal === 'SEPARATEUR_INTROUVABLE' ||
+ apercu.entetes.length === 0;
+ return nonEtabli ? null : dans(SEPARATEURS, apercu.separateur, 'séparateur');
+}
+
+// Chaque colonne de l'en-tête : son rang, son en-tête tel qu'écrit, et la
+// clé de ce qu'elle devient — un champ, une colonne à trancher, une colonne
+// écartée par le choix d'une autre, une colonne non reconnue.
+function colonnesDe({ entetes, association }) {
+ const champDuRang = new Map(CHAMPS.filter((champ) => Object.hasOwn(association.colonnes, champ)).map((champ) => [association.colonnes[champ], champ]));
+ const aTrancher = new Set(association.ambigus.flatMap(({ rangs }) => rangs));
+ const nonReconnues = new Set(association.nonReconnues);
+ return entetes.map((entete, rang) => {
+ let cle = 'import.colonne.ecartee';
+ if (champDuRang.has(rang)) cle = CLES_DES_CHAMPS.get(champDuRang.get(rang));
+ else if (aTrancher.has(rang)) cle = 'import.colonne.aTrancher';
+ else if (nonReconnues.has(rang)) cle = 'import.colonne.nonReconnue';
+ return { rang, entete, cle };
+ });
+}
+
+// Chaque ligne valide : son rang, puis une cellule par champ, dans l'ordre
+// de CHAMPS : le texte lu, ou la clé de la valeur d'« exclu ».
+function lignesDe(lignes) {
+ return lignes.map(({ ligne, champs }) => ({
+ ligne,
+ cellules: CHAMPS.map((champ) => {
+ const valeur = champs[CHAMPS_LUS.get(champ) ?? champ];
+ if (champ === 'exclu') return { champ, texte: null, cle: valeur === null ? null : CLES_D_EXCLU.get(valeur) };
+ return { champ, texte: valeur, cle: null };
+ }),
+ }));
+}
+
+/**
+ * Les lignes refusées, par l'aperçu ou par la mise à jour, telles que
+ * l'aperçu et le rapport les montrent : le rang, le code, et les détails que
+ * reçoit le motif — la ligne refusée sans son code ni ses champs découpés,
+ * comme exporterRefus les passe au motif du CSV.
+ *
+ * @param {Array<{ligne: number, code: string, brut: string[]}>} refusees
+ * @returns {Array<{ligne: number, code: string, details: Object}>}
+ */
+export function refuseesDe(refusees) {
+ return refusees.map(({ code, brut, ...details }) => ({ ligne: details.ligne, code, details }));
+}
+
+/**
+ * Les personnes que désigne une liste d'identifiants, dans son ordre ; un
+ * identifiant que la liste des participants ne porte plus est omis.
+ *
+ * @param {Array<{id: number, nom: string, prenom: string|null}>} participants
+ * @param {number[]} ids
+ * @returns {Array<{id: number, nom: string, prenom: string|null}>}
+ */
+export function nommer(participants, ids) {
+ const parId = new Map(participants.map((participant) => [participant.id, participant]));
+ return ids.filter((id) => parId.has(id)).map((id) => {
+ const { nom, prenom } = parId.get(id);
+ return { id, nom, prenom };
+ });
+}
+
+/**
+ * Le mode d'import proposé (§ 10.1) : Ajouter pour un événement sans
+ * participant, Mettre à jour sinon. Remplacer ne se propose jamais : il se
+ * choisit.
+ *
+ * @param {Array