Jules NenyandClaude Sonnet
11f24c7925
Extensions optionnelles du composant partagé, sans effet sur / et /agences : tri 'ordre' (ordre du tableau d'entrée) avec config.triDefaut et libellesTri, prop libellesVue (Graphe au lieu de Carte, Voir dans le graphe), adaptateur toMiniMot (kind 'mot'). 22 cas ajoutés à test-vue-fiches (80/80). Co-Authored-By: Claude Sonnet <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_0136n5xMLHuaBDLcPJYCDjRW
375 lines
14 KiB
TypeScript
375 lines
14 KiB
TypeScript
/**
|
||
* vueFiches — B11-M1. Logique pure de la vue fiches (SPEC-vue-fiches §2-§5) :
|
||
* lecture et écriture de l'URL, filtrage, compteurs, tri, regroupement.
|
||
* Aucune dépendance à Vue ni au routeur : `composables/useVueFiches.ts`
|
||
* branche ces fonctions sur la route, `scripts/test-vue-fiches.mjs` les teste.
|
||
*
|
||
* Grammaire des filtres : OU dans une dimension, ET entre dimensions.
|
||
* L'URL est la source de vérité ; un paramètre inconnu ou invalide est ignoré.
|
||
*/
|
||
import type { MiniFiche } from '../composables/useFicheAdapter'
|
||
|
||
export type EtatVue = 'carte' | 'mixte' | 'fiches'
|
||
export type TriFiches = 'pertinence' | 'nom' | 'recent' | 'ordre'
|
||
|
||
export const ETATS_VUE: EtatVue[] = ['carte', 'mixte', 'fiches']
|
||
export const LIBELLES_TRI: Record<TriFiches, string> = {
|
||
pertinence: 'Pertinence',
|
||
nom: 'A → Z',
|
||
recent: 'Récentes',
|
||
ordre: 'Ordre d’origine',
|
||
}
|
||
|
||
export interface ValeurFiltre {
|
||
valeur: string
|
||
libelle: string
|
||
}
|
||
|
||
export interface DimensionFiltre {
|
||
/** Paramètre d'URL ET clé de `MiniFiche.etiquettes`. */
|
||
cle: string
|
||
libelle: string
|
||
valeurs: ValeurFiltre[]
|
||
variante: 'fonction' | 'echelle' | 'posture'
|
||
}
|
||
|
||
export interface GroupeDef {
|
||
/** Valeur de `groupe=` dans l'URL. */
|
||
cle: string
|
||
libelle: string
|
||
/** Clé de `MiniFiche.etiquettes` : la fiche va sous sa PREMIÈRE étiquette. */
|
||
dimension: string
|
||
/** En-tête des fiches qui n'ont aucune étiquette dans cette dimension. */
|
||
sans: string
|
||
/** Libellés et ordre des groupes, sinon ceux de la dimension de filtre, sinon A → Z. */
|
||
valeurs?: ValeurFiltre[]
|
||
}
|
||
|
||
export interface SousVuesCarte {
|
||
/** Paramètre d'URL : `mode` sur `/` (existant), `carte` sur `/agences`. */
|
||
parametre: string
|
||
valeurs: ValeurFiltre[]
|
||
defaut: string
|
||
}
|
||
|
||
export interface ConfigVueFiches {
|
||
dimensions: DimensionFiltre[]
|
||
tris: TriFiches[]
|
||
groupes: GroupeDef[]
|
||
etats: EtatVue[]
|
||
sousVues?: SousVuesCarte
|
||
/** Tri sans filtre actif (défaut : `nom`). Doit figurer dans `tris`. */
|
||
triDefaut?: TriFiches
|
||
/** Libellés de tri propres à la page (sinon `LIBELLES_TRI`). */
|
||
libellesTri?: Partial<Record<TriFiches, string>>
|
||
}
|
||
|
||
export interface EtatFiches {
|
||
/** null = pas de `vue=` dans l'URL : défaut par largeur (Mixte sur ordinateur, Fiches sur téléphone). */
|
||
vue: EtatVue | null
|
||
q: string
|
||
filtres: Record<string, string[]>
|
||
/** `adresse=sans` : seulement les fiches sans coordonnées (lien « N sans adresse »). */
|
||
sansAdresse: boolean
|
||
/** null = défaut automatique (pertinence dès qu'un filtre est actif, sinon nom). */
|
||
tri: TriFiches | null
|
||
/** null = aucun regroupement. */
|
||
groupe: string | null
|
||
sousVue: string
|
||
}
|
||
|
||
export interface GroupeRendu {
|
||
cle: string
|
||
libelle: string
|
||
fiches: MiniFiche[]
|
||
}
|
||
|
||
type Query = Record<string, unknown>
|
||
|
||
function premiere(v: unknown): string {
|
||
if (Array.isArray(v)) return typeof v[0] === 'string' ? v[0] : ''
|
||
return typeof v === 'string' ? v : ''
|
||
}
|
||
|
||
function liste(v: unknown): string[] {
|
||
const brut = premiere(v)
|
||
return [...new Set(brut.split(',').map((s) => s.trim()).filter(Boolean))]
|
||
}
|
||
|
||
/** Minuscules, sans accents : « Régional » et « regional » se valent. */
|
||
export function normaliser(s: string): string {
|
||
return s.normalize('NFD').replace(/[̀-ͯ]/g, '').toLowerCase()
|
||
}
|
||
|
||
// ── URL ↔ état ─────────────────────────────────────────────────────────────
|
||
|
||
export function lireQuery(query: Query, cfg: ConfigVueFiches): EtatFiches {
|
||
const vueBrute = premiere(query.vue) as EtatVue
|
||
const triBrut = premiere(query.tri) as TriFiches
|
||
const groupeBrut = premiere(query.groupe)
|
||
const sv = cfg.sousVues
|
||
const svBrute = sv ? premiere(query[sv.parametre]) : ''
|
||
|
||
const filtres: Record<string, string[]> = {}
|
||
for (const d of cfg.dimensions) filtres[d.cle] = liste(query[d.cle])
|
||
|
||
return {
|
||
vue: cfg.etats.includes(vueBrute) ? vueBrute : null,
|
||
q: premiere(query.q),
|
||
filtres,
|
||
sansAdresse: premiere(query.adresse) === 'sans',
|
||
tri: cfg.tris.includes(triBrut) ? triBrut : null,
|
||
groupe: cfg.groupes.some((g) => g.cle === groupeBrut) ? groupeBrut : null,
|
||
sousVue: sv && sv.valeurs.some((v) => v.valeur === svBrute) ? svBrute : (sv?.defaut ?? ''),
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Query à écrire pour un état. Les paramètres que la vue fiches ne gère pas
|
||
* (`territoire`, `random`…) sont recopiés depuis `base`, `fiche` aussi : un
|
||
* filtre changé garde la fiche ouverte (elle peut passer « hors de vos filtres »).
|
||
*/
|
||
export function ecrireQuery(etat: EtatFiches, cfg: ConfigVueFiches, base: Query = {}): Record<string, string> {
|
||
const geres = new Set(['vue', 'q', 'adresse', 'tri', 'groupe', ...cfg.dimensions.map((d) => d.cle)])
|
||
if (cfg.sousVues) geres.add(cfg.sousVues.parametre)
|
||
|
||
const out: Record<string, string> = {}
|
||
for (const [k, v] of Object.entries(base)) {
|
||
if (!geres.has(k) && typeof premiere(v) === 'string' && premiere(v) !== '') out[k] = premiere(v)
|
||
}
|
||
if (etat.vue) out.vue = etat.vue
|
||
if (etat.q.trim()) out.q = etat.q
|
||
for (const d of cfg.dimensions) {
|
||
const vals = etat.filtres[d.cle] ?? []
|
||
if (vals.length) out[d.cle] = vals.join(',')
|
||
}
|
||
if (etat.sansAdresse) out.adresse = 'sans'
|
||
if (etat.tri) out.tri = etat.tri
|
||
if (etat.groupe) out.groupe = etat.groupe
|
||
if (cfg.sousVues && etat.sousVue && etat.sousVue !== cfg.sousVues.defaut) {
|
||
out[cfg.sousVues.parametre] = etat.sousVue
|
||
}
|
||
return out
|
||
}
|
||
|
||
/**
|
||
* Ne garde que les valeurs connues de chaque dimension. Une dimension dont la
|
||
* liste de valeurs est encore vide (données pas chargées) garde tout : le
|
||
* filtre s'appliquera dès l'arrivée des données, sans perdre le lien partagé.
|
||
*/
|
||
export function filtresValides(filtres: Record<string, string[]>, cfg: ConfigVueFiches): Record<string, string[]> {
|
||
const out: Record<string, string[]> = {}
|
||
for (const d of cfg.dimensions) {
|
||
const vals = filtres[d.cle] ?? []
|
||
out[d.cle] = d.valeurs.length ? vals.filter((v) => d.valeurs.some((x) => x.valeur === v)) : vals
|
||
}
|
||
return out
|
||
}
|
||
|
||
export function nbFiltresActifs(etat: EtatFiches): number {
|
||
return Object.values(etat.filtres).reduce((n, v) => n + v.length, 0) + (etat.sansAdresse ? 1 : 0)
|
||
}
|
||
|
||
// ── Filtrage ───────────────────────────────────────────────────────────────
|
||
|
||
function porte(f: MiniFiche, dimension: string, valeur: string): boolean {
|
||
return (f.etiquettes?.[dimension] ?? []).includes(valeur)
|
||
}
|
||
|
||
export function correspondRecherche(f: MiniFiche, q: string): boolean {
|
||
const n = normaliser(q.trim())
|
||
if (!n) return true
|
||
return [f.nom, f.ville, f.resume, f.texte].some((t) => !!t && normaliser(t).includes(n))
|
||
}
|
||
|
||
/**
|
||
* Fiches qui passent la recherche, `adresse=sans` et les filtres de toutes les
|
||
* dimensions sauf `ignorer` (sert aux compteurs). OU dans une dimension, ET entre.
|
||
*/
|
||
export function filtrerFiches(
|
||
fiches: MiniFiche[],
|
||
etat: EtatFiches,
|
||
cfg: ConfigVueFiches,
|
||
ignorer?: string,
|
||
): MiniFiche[] {
|
||
return fiches.filter((f) => {
|
||
if (etat.sansAdresse && f.geoloc) return false
|
||
if (!correspondRecherche(f, etat.q)) return false
|
||
for (const d of cfg.dimensions) {
|
||
if (d.cle === ignorer) continue
|
||
const vals = etat.filtres[d.cle] ?? []
|
||
if (vals.length && !vals.some((v) => porte(f, d.cle, v))) return false
|
||
}
|
||
return true
|
||
})
|
||
}
|
||
|
||
/**
|
||
* Compteur de chaque chip : fiches qui portent cette étiquette parmi celles que
|
||
* laissent passer la recherche et les AUTRES dimensions. Une chip active affiche
|
||
* donc combien de fiches elle apporte, une chip inactive combien on en aurait
|
||
* en la cochant seule dans sa dimension ; 0 = chip grisée.
|
||
*/
|
||
export function compterEtiquettes(
|
||
fiches: MiniFiche[],
|
||
etat: EtatFiches,
|
||
cfg: ConfigVueFiches,
|
||
): Record<string, Record<string, number>> {
|
||
const out: Record<string, Record<string, number>> = {}
|
||
for (const d of cfg.dimensions) {
|
||
const base = filtrerFiches(fiches, etat, cfg, d.cle)
|
||
const c: Record<string, number> = {}
|
||
for (const v of d.valeurs) c[v.valeur] = 0
|
||
for (const f of base) for (const v of f.etiquettes?.[d.cle] ?? []) if (v in c) c[v]++
|
||
out[d.cle] = c
|
||
}
|
||
return out
|
||
}
|
||
|
||
// ── Tri ────────────────────────────────────────────────────────────────────
|
||
|
||
export function triEffectif(etat: EtatFiches, cfg: ConfigVueFiches): TriFiches {
|
||
if (etat.tri) return etat.tri
|
||
const filtreEtiquette = Object.values(etat.filtres).some((v) => v.length > 0)
|
||
if (filtreEtiquette && cfg.tris.includes('pertinence')) return 'pertinence'
|
||
if (cfg.triDefaut && cfg.tris.includes(cfg.triDefaut)) return cfg.triDefaut
|
||
return cfg.tris.includes('nom') ? 'nom' : cfg.tris[0] ?? 'nom'
|
||
}
|
||
|
||
/** Nombre d'étiquettes cochées que porte la fiche. */
|
||
export function pertinence(f: MiniFiche, etat: EtatFiches): number {
|
||
let s = 0
|
||
for (const [dim, vals] of Object.entries(etat.filtres)) for (const v of vals) if (porte(f, dim, v)) s++
|
||
return s
|
||
}
|
||
|
||
const collator = new Intl.Collator('fr', { sensitivity: 'base', numeric: true })
|
||
|
||
function parNom(a: MiniFiche, b: MiniFiche): number {
|
||
return collator.compare(a.nom ?? '', b.nom ?? '')
|
||
}
|
||
|
||
function idNum(f: MiniFiche): number {
|
||
const n = Number(f.id)
|
||
return Number.isFinite(n) ? n : -Infinity
|
||
}
|
||
|
||
export function trierFiches(fiches: MiniFiche[], tri: TriFiches, etat: EtatFiches): MiniFiche[] {
|
||
const copie = [...fiches]
|
||
if (tri === 'ordre') return copie // ordre du tableau d'entrée (déjà filtré, jamais réordonné)
|
||
if (tri === 'nom') return copie.sort(parNom)
|
||
if (tri === 'pertinence') {
|
||
const score = new Map(copie.map((f) => [f, pertinence(f, etat)]))
|
||
return copie.sort((a, b) => score.get(b)! - score.get(a)! || parNom(a, b))
|
||
}
|
||
// récent : date décroissante, puis Id décroissant (Entraide : Id = ordre d'arrivée)
|
||
return copie.sort((a, b) => {
|
||
if (a.date && b.date && a.date !== b.date) return a.date < b.date ? 1 : -1
|
||
if (!!a.date !== !!b.date) return a.date ? -1 : 1
|
||
return idNum(b) - idNum(a) || parNom(a, b)
|
||
})
|
||
}
|
||
|
||
// ── Regroupement ───────────────────────────────────────────────────────────
|
||
|
||
/**
|
||
* Une fiche va sous sa PREMIÈRE étiquette de la dimension (sinon le compteur
|
||
* de groupe ment). Ordre des groupes : celui de `def.valeurs`, sinon de la
|
||
* dimension de filtre, sinon A → Z ; « sans » en dernier. L'ordre des fiches
|
||
* dans chaque groupe est celui reçu (déjà trié).
|
||
*/
|
||
export function regrouper(fiches: MiniFiche[], def: GroupeDef | null, cfg: ConfigVueFiches): GroupeRendu[] {
|
||
if (!def) return [{ cle: '', libelle: '', fiches }]
|
||
const ref = def.valeurs ?? cfg.dimensions.find((d) => d.cle === def.dimension)?.valeurs ?? []
|
||
const libelle = (v: string) => ref.find((x) => x.valeur === v)?.libelle ?? v
|
||
|
||
const parCle = new Map<string, MiniFiche[]>()
|
||
for (const f of fiches) {
|
||
const cle = f.etiquettes?.[def.dimension]?.[0] ?? ''
|
||
if (!parCle.has(cle)) parCle.set(cle, [])
|
||
parCle.get(cle)!.push(f)
|
||
}
|
||
const rang = (cle: string) => {
|
||
if (cle === '') return Number.MAX_SAFE_INTEGER
|
||
const i = ref.findIndex((x) => x.valeur === cle)
|
||
return i === -1 ? ref.length : i
|
||
}
|
||
return [...parCle.keys()]
|
||
.sort((a, b) => rang(a) - rang(b) || collator.compare(libelle(a), libelle(b)))
|
||
.map((cle) => ({ cle, libelle: cle === '' ? def.sans : libelle(cle), fiches: parCle.get(cle)! }))
|
||
}
|
||
|
||
/** Ordre de lecture courant (filtres + tri + regroupement) : le fiche à fiche de B12 le suit. */
|
||
export function ordreFiches(groupes: GroupeRendu[]): MiniFiche[] {
|
||
return groupes.flatMap((g) => g.fiches)
|
||
}
|
||
|
||
// ── Fiche ouverte (B12) ────────────────────────────────────────────────────
|
||
|
||
/** `fiche=` de l'URL ; null si absent ou vide. L'id reste une chaîne (Entraide : nombre, Réseaux : `f1-rotor`). */
|
||
export function lireFiche(query: Query): string | null {
|
||
const v = premiere(query.fiche).trim()
|
||
return v || null
|
||
}
|
||
|
||
/** Query avec `fiche=` posé (id) ou retiré (null), tout le reste recopié tel quel. */
|
||
export function queryAvecFiche(query: Query, id: string | number | null): Record<string, string> {
|
||
const out: Record<string, string> = {}
|
||
for (const [k, v] of Object.entries(query)) {
|
||
if (k !== 'fiche' && premiere(v) !== '') out[k] = premiere(v)
|
||
}
|
||
if (id != null && String(id) !== '') out.fiche = String(id)
|
||
return out
|
||
}
|
||
|
||
export interface PositionFiche {
|
||
/** Rang dans l'ordre courant, de 1 à total. */
|
||
rang: number
|
||
total: number
|
||
precedente: MiniFiche | null
|
||
suivante: MiniFiche | null
|
||
}
|
||
|
||
/**
|
||
* Place de la fiche dans l'ordre courant (filtres + tri + regroupement).
|
||
* null = fiche hors de l'ordre courant (« hors de vos filtres ») : pas de
|
||
* précédente ni de suivante. Pas de bouclage aux extrémités.
|
||
*/
|
||
export function positionFiche(ordre: MiniFiche[], id: string | number | null): PositionFiche | null {
|
||
if (id == null) return null
|
||
const i = ordre.findIndex((f) => String(f.id) === String(id))
|
||
if (i === -1) return null
|
||
return {
|
||
rang: i + 1,
|
||
total: ordre.length,
|
||
precedente: i > 0 ? ordre[i - 1] : null,
|
||
suivante: i < ordre.length - 1 ? ordre[i + 1] : null,
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Historique (SPEC §5) : OUVRIR une fiche depuis la liste ajoute une entrée
|
||
* (le retour du téléphone la referme) ; passer d'une fiche à l'autre la
|
||
* remplace (le retour ne rejoue pas les vingt fiches parcourues).
|
||
*/
|
||
export function modeOuverture(ficheCourante: string | null): 'push' | 'replace' {
|
||
return ficheCourante == null ? 'push' : 'replace'
|
||
}
|
||
|
||
/**
|
||
* FERMER : si l'entrée a été ajoutée par cette page ET que la liste derrière
|
||
* n'a pas changé depuis (mêmes filtres, tri, vue), on revient en arrière :
|
||
* l'historique reste propre. Sinon (lien partagé, rechargement, filtre changé
|
||
* fiche ouverte), on retire `fiche=` sur place : un retour arrière aurait
|
||
* défait les filtres choisis entre-temps.
|
||
*/
|
||
export function modeFermeture(ouverteParLaPage: boolean, listeInchangee: boolean): 'back' | 'replace' {
|
||
return ouverteParLaPage && listeInchangee ? 'back' : 'replace'
|
||
}
|
||
|
||
/** Empreinte de la liste derrière la fiche : la query sans `fiche=`, clés triées. */
|
||
export function empreinteListe(query: Query): string {
|
||
const q = queryAvecFiche(query, null)
|
||
return Object.keys(q).sort().map((k) => `${k}=${q[k]}`).join('&')
|
||
}
|