From d6b4eb82f41525021b9c24d3950d7e567a3db49d Mon Sep 17 00:00:00 2001 From: Archicratia Date: Thu, 19 Mar 2026 21:53:33 +0100 Subject: [PATCH] feat(glossaire): enrich entries and refine glossary navigation --- src/components/GlossaryAside.astro | 330 ++++-- src/content.config.ts | 13 + .../glossaire/agencement-machinique.md | 1 + src/content/glossaire/arcalite.md | 1 + src/content/glossaire/archicratie.md | 1 + src/content/glossaire/archicration.md | 1 + ...ions-differentielles-et-formes-hybrides.md | 3 +- .../glossaire/archicrations-epistemiques.md | 1 + .../archicrations-esthetico-symboliques.md | 1 + .../glossaire/archicrations-guerrieres.md | 1 + .../archicrations-historiographiques.md | 1 + .../glossaire/archicrations-marchandes.md | 1 + .../archicrations-normativo-politiques.md | 1 + .../archicrations-proto-symboliques.md | 1 + .../archicrations-sacrales-non-etatiques.md | 1 + .../archicrations-scripturo-cosmologiques.md | 1 + .../archicrations-scripturo-normatives.md | 1 + .../archicrations-techno-logistiques.md | 1 + .../glossaire/archicrations-theologiques.md | 1 + src/content/glossaire/autarchicratie.md | 1 + src/content/glossaire/biopolitique.md | 1 + src/content/glossaire/co-viabilite.md | 1 + src/content/glossaire/conatus-et-multitude.md | 1 + .../configuration-et-interdependance.md | 1 + .../glossaire/contractualisme-hobbesien.md | 1 + src/content/glossaire/cosmopolitique.md | 1 + src/content/glossaire/cratialite.md | 1 + src/content/glossaire/cybernetique.md | 1 + .../glossaire/decisionnisme-souverain.md | 1 + .../glossaire/democratie-deliberative.md | 1 + src/content/glossaire/dissensus-politique.md | 1 + .../domination-legale-rationnelle.md | 1 + .../glossaire/droit-naturel-et-propriete.md | 1 + src/content/glossaire/exception-souveraine.md | 1 + src/content/glossaire/fait-social-total.md | 1 + .../glossaire/gouvernance-des-communs.md | 1 + .../gouvernementalite-algorithmique.md | 1 + src/content/glossaire/gouvernementalite.md | 1 + ...matisation-et-proletarisation-cognitive.md | 1 + .../habitus-et-violence-symbolique.md | 1 + src/content/glossaire/lieu-vide-du-pouvoir.md | 1 + .../glossaire/obliteration-archicratique.md | 1 + src/content/glossaire/pensee-complexe.md | 1 + .../glossaire/pharmacologie-technique.md | 1 + .../glossaire/pluralite-natalite-action.md | 1 + .../glossaire/preemption-algorithmique.md | 1 + src/content/glossaire/scene-depreuve.md | 1 + .../technodiversite-et-cosmotechnie.md | 1 + src/content/glossaire/tension.md | 1 + .../glossaire/theorie-de-la-justification.md | 1 + .../glossaire/theorie-de-la-resonance.md | 1 + .../glossaire/theorie-de-lacteur-reseau.md | 1 + .../transduction-et-individuation.md | 1 + src/content/glossaire/volonte-generale.md | 1 + src/pages/glossaire/[...slug].astro | 271 ++++- src/pages/glossaire/index-complet.astro | 223 ++++ src/pages/glossaire/index.astro | 1009 ++++++++++++----- 57 files changed, 1471 insertions(+), 429 deletions(-) create mode 100644 src/pages/glossaire/index-complet.astro diff --git a/src/components/GlossaryAside.astro b/src/components/GlossaryAside.astro index dfea7d6..c2f9a46 100644 --- a/src/components/GlossaryAside.astro +++ b/src/components/GlossaryAside.astro @@ -26,7 +26,7 @@ const fondamentaux = fondamentauxWanted function resolveList(slugs = []) { return slugs - .map((slug) => bySlug.get(slug)) + .map((slug) => bySlug.get(String(slug || "").trim())) .filter(Boolean); } @@ -42,43 +42,138 @@ function uniqueBySlug(entries) { return out; } -const relatedEntries = uniqueBySlug(resolveList(currentEntry.data.related ?? [])) - .sort((a, b) => collator.compare(a.data.term, b.data.term)); +function sortByTerm(entries = []) { + return [...entries].sort((a, b) => collator.compare(a.data.term, b.data.term)); +} -const opposedEntries = uniqueBySlug(resolveList(currentEntry.data.opposedTo ?? [])) - .sort((a, b) => collator.compare(a.data.term, b.data.term)); +function familyOf(entry) { + return entry?.data?.family ?? ""; +} -const seeAlsoEntries = uniqueBySlug(resolveList(currentEntry.data.seeAlso ?? [])) - .sort((a, b) => collator.compare(a.data.term, b.data.term)); +function kindOf(entry) { + return entry?.data?.kind ?? ""; +} -const paradigmes = [...allEntries] - .filter((e) => e.data.kind === "paradigme" && slugOf(e) !== currentSlug) - .sort((a, b) => collator.compare(a.data.term, b.data.term)); +const relatedEntries = sortByTerm( + uniqueBySlug(resolveList(currentEntry.data.related ?? [])) +); -function contextualParadigmsFor(entry) { - const relatedParadigms = (entry.data.related ?? []) - .map((slug) => bySlug.get(slug)) - .filter((e) => e && e.data.kind === "paradigme"); +const opposedEntries = sortByTerm( + uniqueBySlug(resolveList(currentEntry.data.opposedTo ?? [])) +); - const seeAlsoParadigms = (entry.data.seeAlso ?? []) - .map((slug) => bySlug.get(slug)) - .filter((e) => e && e.data.kind === "paradigme"); +const seeAlsoEntries = sortByTerm( + uniqueBySlug(resolveList(currentEntry.data.seeAlso ?? [])) +); - const opposedParadigms = (entry.data.opposedTo ?? []) - .map((slug) => bySlug.get(slug)) - .filter((e) => e && e.data.kind === "paradigme"); +const familyLabels = { + "concept-fondamental": "Concept fondamental", + scene: "Scène", + dynamique: "Dynamique", + pathologie: "Pathologie", + topologie: "Topologie", + "meta-regime": "Méta-régime", + paradigme: "Paradigme", + doctrine: "Doctrine", + verbe: "Verbe", + "dispositif-ia": "Dispositif IA", + "tension-irreductible": "Tension irréductible", +}; - const merged = uniqueBySlug([ - ...relatedParadigms, - ...seeAlsoParadigms, - ...opposedParadigms, - ]); +const kindLabels = { + concept: "Concept", + diagnostic: "Diagnostic", + topologie: "Topologie", + verbe: "Verbe", + paradigme: "Paradigme", + doctrine: "Doctrine", +}; - if (merged.length > 0) { - return merged.slice(0, 5); +const domainLabels = { + transversal: "Transversal", + theorie: "Théorie", + "cas-ia": "Cas IA", +}; + +const levelLabels = { + fondamental: "Fondamental", + intermediaire: "Intermédiaire", + avance: "Avancé", +}; + +const currentFamily = familyOf(currentEntry); +const displayFamily = + familyLabels[currentFamily] ?? + kindLabels[currentEntry.data.kind] ?? + "Fiche"; + +const displayDomain = + domainLabels[currentEntry.data.domain] ?? + currentEntry.data.domain; + +const displayLevel = + levelLabels[currentEntry.data.level] ?? + currentEntry.data.level; + +function entriesOfSameFamily(entry) { + const family = familyOf(entry); + + if (!family) return []; + + if (family === "concept-fondamental") { + return fondamentaux; } - if (entry.data.kind === "paradigme") { + return sortByTerm( + allEntries.filter((item) => familyOf(item) === family) + ); +} + +const sameFamilyEntries = entriesOfSameFamily(currentEntry); + +const familySectionTitles = { + "concept-fondamental": "Noyau archicratique", + scene: "Scènes archicratiques", + dynamique: "Dynamiques archicratiques", + pathologie: "Pathologies archicratiques", + topologie: "Topologies voisines", + "meta-regime": "Méta-régimes archicratiques", + paradigme: "Paradigmes voisins", + doctrine: "Doctrines fondatrices", + verbe: "Verbes de la scène", + "dispositif-ia": "Dispositifs IA", + "tension-irreductible": "Tensions irréductibles", +}; + +const sameFamilyTitle = + familySectionTitles[currentFamily] ?? "Même famille"; + +function isTheoryEntry(entry) { + const family = familyOf(entry); + const kind = kindOf(entry); + + return ( + family === "paradigme" || + family === "doctrine" || + kind === "paradigme" || + kind === "doctrine" + ); +} + +function contextualTheoryFor(entry) { + const fromRelations = uniqueBySlug([ + ...resolveList(entry.data.related ?? []), + ...resolveList(entry.data.seeAlso ?? []), + ...resolveList(entry.data.opposedTo ?? []), + ]) + .filter((item) => slugOf(item) !== currentSlug) + .filter((item) => isTheoryEntry(item)); + + if (fromRelations.length > 0) { + return sortByTerm(fromRelations).slice(0, 6); + } + + if (familyOf(entry) === "paradigme") { const preferred = [ "gouvernementalite", "gouvernementalite-algorithmique", @@ -100,6 +195,22 @@ function contextualParadigmsFor(entry) { "grammatisation-et-proletarisation-cognitive", ]; + return uniqueBySlug( + preferred + .filter((slug) => slug !== currentSlug) + .map((slug) => bySlug.get(slug)) + .filter(Boolean) + ).slice(0, 8); + } + + if (familyOf(entry) === "doctrine") { + const preferred = [ + "contractualisme-hobbesien", + "droit-naturel-et-propriete", + "volonte-generale", + "decisionnisme-souverain", + ]; + return uniqueBySlug( preferred .filter((slug) => slug !== currentSlug) @@ -108,55 +219,56 @@ function contextualParadigmsFor(entry) { ).slice(0, 6); } - return paradigmes.slice(0, 5); + return []; } -const contextualParadigms = contextualParadigmsFor(currentEntry); +const contextualTheory = contextualTheoryFor(currentEntry); -const kindLabels = { - concept: "Concept", - diagnostic: "Diagnostic", - topologie: "Topologie", - verbe: "Verbe", - paradigme: "Paradigme", - doctrine: "Doctrine", -}; +const showNoyau = currentFamily !== "concept-fondamental" && fondamentaux.length > 0; -const domainLabels = { - transversal: "Transversal", - theorie: "Théorie", - "cas-ia": "Cas IA", -}; +const showSameFamily = + sameFamilyEntries.length > 0 && currentFamily !== "concept-fondamental"; -const levelLabels = { - fondamental: "Fondamental", - intermediaire: "Intermédiaire", - avance: "Avancé", -}; - -const metaLabel = [ - kindLabels[currentEntry.data.kind] ?? currentEntry.data.kind, - domainLabels[currentEntry.data.domain] ?? currentEntry.data.domain, - levelLabels[currentEntry.data.level] ?? currentEntry.data.level, -].join(" · "); +const relationSections = [ + { + title: "Concepts liés", + items: relatedEntries, + }, + { + title: "En tension avec", + items: opposedEntries, + }, + { + title: "Voir aussi", + items: seeAlsoEntries, + }, +].filter((section) => section.items.length > 0); ---