Archicratia/archicratie-edition
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor(glossaire): centralize glossary relation helpers
All checks were successful
CI / build-and-anchors (pull_request) Successful in 42s
Details
SMOKE / smoke (push) Successful in 3s
Details
CI / build-and-anchors (push) Successful in 41s
Details

Browse Source
This commit is contained in:
Archicratia
2026-03-25 14:15:39 +01:00
parent a38f585f3d
commit ad06b34a85
5 changed files with 473 additions and 496 deletions
Download Patch File Download Diff File Expand all files Collapse all files

280
src/components/GlossaryAside.astro
View File

@@ -1,258 +1,46 @@
---
import {
familyOf,
getContextualTheory,
getDisplayDomain,
getDisplayFamily,
getDisplayLevel,
getEntriesOfSameFamily,
getFondamentaux,
getRelationSections,
getSameFamilyTitle,
hrefOfGlossaryEntry,
slugOfGlossaryEntry,
} from "../lib/glossary";
const {
currentEntry,
allEntries = [],
} = Astro.props;
const slugOf = (entry) => String(entry.id).replace(/\.(md|mdx)$/i, "");
const hrefOf = (entry) => `/glossaire/${slugOf(entry)}/`;
const collator = new Intl.Collator("fr", { sensitivity: "base", numeric: true });
const bySlug = new Map(allEntries.map((entry) => [slugOf(entry), entry]));
const currentSlug = slugOf(currentEntry);
const fondamentauxWanted = [
"archicratie",
"tension",
"arcalite",
"cratialite",
"archicration",
"co-viabilite",
];
const fondamentaux = fondamentauxWanted
.map((slug) => bySlug.get(slug))
.filter(Boolean);
function resolveList(slugs = []) {
return slugs
.map((slug) => bySlug.get(String(slug || "").trim()))
.filter(Boolean);
}
function uniqueBySlug(entries) {
const seen = new Set();
const out = [];
for (const entry of entries) {
const slug = slugOf(entry);
if (seen.has(slug)) continue;
seen.add(slug);
out.push(entry);
}
return out;
}
function sortByTerm(entries = []) {
return [...entries].sort((a, b) => collator.compare(a.data.term, b.data.term));
}
function familyOf(entry) {
return entry?.data?.family ?? "";
}
function kindOf(entry) {
return entry?.data?.kind ?? "";
}
const relatedEntries = sortByTerm(
uniqueBySlug(resolveList(currentEntry.data.related ?? []))
);
const opposedEntries = sortByTerm(
uniqueBySlug(resolveList(currentEntry.data.opposedTo ?? []))
);
const seeAlsoEntries = sortByTerm(
uniqueBySlug(resolveList(currentEntry.data.seeAlso ?? []))
);
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",
figure: "Figure",
qualification: "Qualification",
epistemologie: "Épistémologie",
};
const kindLabels = {
concept: "Concept",
diagnostic: "Diagnostic",
topologie: "Topologie",
verbe: "Verbe",
paradigme: "Paradigme",
doctrine: "Doctrine",
dispositif: "Dispositif",
figure: "Figure",
qualification: "Qualification",
epistemologie: "Épistémologie",
};
const domainLabels = {
transversal: "Transversal",
theorie: "Théorie",
"cas-ia": "Cas IA",
};
const levelLabels = {
fondamental: "Fondamental",
intermediaire: "Intermédiaire",
avance: "Avancé",
};
const currentSlug = slugOfGlossaryEntry(currentEntry);
const currentFamily = familyOf(currentEntry);
const displayFamily =
familyLabels[currentFamily] ??
kindLabels[currentEntry.data.kind] ??
"Fiche";
const displayDomain =
domainLabels[currentEntry.data.domain] ??
currentEntry.data.domain;
const fondamentaux = getFondamentaux(allEntries);
const displayLevel =
levelLabels[currentEntry.data.level] ??
currentEntry.data.level;
const displayFamily = getDisplayFamily(currentEntry);
const displayDomain = getDisplayDomain(currentEntry);
const displayLevel = getDisplayLevel(currentEntry);
function entriesOfSameFamily(entry) {
const family = familyOf(entry);
const sameFamilyEntries = getEntriesOfSameFamily(currentEntry, allEntries);
const sameFamilyTitle = getSameFamilyTitle(currentEntry);
if (!family) return [];
const contextualTheory = getContextualTheory(currentEntry, allEntries);
if (family === "concept-fondamental") {
return fondamentaux;
}
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",
figure: "Figures archicratiques",
qualification: "Qualifications archicratiques",
epistemologie: "Outillage épistémologique",
};
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",
"cybernetique",
"biopolitique",
"domination-legale-rationnelle",
"democratie-deliberative",
"gouvernance-des-communs",
"agencement-machinique",
"pharmacologie-technique",
"preemption-algorithmique",
"dissensus-politique",
"lieu-vide-du-pouvoir",
"habitus-et-violence-symbolique",
"theorie-de-la-resonance",
"conatus-et-multitude",
"configuration-et-interdependance",
"technodiversite-et-cosmotechnie",
"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)
.map((slug) => bySlug.get(slug))
.filter(Boolean)
).slice(0, 6);
}
return [];
}
const contextualTheory = contextualTheoryFor(currentEntry);
const showNoyau = currentFamily !== "concept-fondamental" && fondamentaux.length > 0;
const showNoyau =
currentFamily !== "concept-fondamental" &&
fondamentaux.length > 0;
const showSameFamily =
sameFamilyEntries.length > 0 && currentFamily !== "concept-fondamental";
sameFamilyEntries.length > 0 &&
currentFamily !== "concept-fondamental";
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);
const relationSections = getRelationSections(currentEntry, allEntries);
---
<nav class="glossary-aside" aria-label="Navigation du glossaire">
@@ -286,11 +74,11 @@ const relationSections = [
<h2 class="glossary-aside__heading">Noyau archicratique</h2>
<ul class="glossary-aside__list">
{fondamentaux.map((entry) => {
const active = slugOf(entry) === currentSlug;
const active = slugOfGlossaryEntry(entry) === currentSlug;
return (
<li>
<a
href={hrefOf(entry)}
href={hrefOfGlossaryEntry(entry)}
aria-current={active ? "page" : undefined}
class={active ? "is-active" : undefined}
>
@@ -308,11 +96,11 @@ const relationSections = [
<h2 class="glossary-aside__heading">{sameFamilyTitle}</h2>
<ul class="glossary-aside__list">
{sameFamilyEntries.map((entry) => {
const active = slugOf(entry) === currentSlug;
const active = slugOfGlossaryEntry(entry) === currentSlug;
return (
<li>
<a
href={hrefOf(entry)}
href={hrefOfGlossaryEntry(entry)}
aria-current={active ? "page" : undefined}
class={active ? "is-active" : undefined}
>
@@ -334,7 +122,7 @@ const relationSections = [
<h3 class="glossary-aside__subheading">{section.title}</h3>
<ul class="glossary-aside__list">
{section.items.map((entry) => (
<li><a href={hrefOf(entry)}>{entry.data.term}</a></li>
<li><a href={hrefOfGlossaryEntry(entry)}>{entry.data.term}</a></li>
))}
</ul>
</>
@@ -347,7 +135,7 @@ const relationSections = [
<h2 class="glossary-aside__heading">Paysage théorique</h2>
<ul class="glossary-aside__list">
{contextualTheory.map((entry) => (
<li><a href={hrefOf(entry)}>{entry.data.term}</a></li>
<li><a href={hrefOfGlossaryEntry(entry)}>{entry.data.term}</a></li>
))}
</ul>
</section>