@micheeeeel/yinyangapp 1.0.6 → 2.0.1

package/dist/types/components/search/GlobalSearchController.d.ts

@@ -0,0 +1,396 @@
+export interface SearchEntry {
+    componentId: string;
+    componentIndex: number;
+    componentName: string;
+    oddId: string;
+    oddName: string;
+    cuttingId: number;
+    cuttingIndex: number;
+    cuttingName: string;
+    actionId: string;
+    actionName: string;
+}
+export type SearchNavTarget = {
+    type: "composante";
+    componentIndex: number;
+} | {
+    type: "odd";
+    componentIndex: number;
+    oddId: string;
+} | {
+    type: "cutting";
+    componentIndex: number;
+    oddId: string;
+    cuttingIndex: number;
+} | {
+    type: "action";
+    componentIndex: number;
+    oddId: string;
+    cuttingIndex: number;
+    actionId: string;
+} | {
+    type: "keyEvent";
+    componentIndex: number;
+    keyEventId: string;
+};
+export interface GlobalSearchControllerOptions {
+    /** Appelé quand l'utilisateur clique sur un label ou une action */
+    onNavigate: (target: SearchNavTarget) => void;
+    /** Nombre max de résultats affichés en mode arbre filtré (défaut : 500) */
+    maxResults?: number;
+    /** Mode contexte : affiche uniquement le chemin ciblé, sans barre de recherche. */
+    contextMode?: boolean;
+    /** Affiche la description dans le panneau de détail même pour les cibles de type "action". */
+    alwaysShowDesc?: boolean;
+    /** Appelé quand un élément sélectionné est re-cliqué (désélection/repli) ou que la composante
+     *  parente est repliée alors qu'un cutting/action était actif. Permet de synchroniser le
+     *  diagramme (fermer le menu d'action du satellite). */
+    onDeselect?: (target: SearchNavTarget) => void;
+    /** Appelé au dépli/repli du groupe "Événements Clés" d'une facette. Le groupe
+     *  n'est pas une cible de navigation (pas de data-nav-key, rien à
+     *  sélectionner) mais il a bien un pendant dans le diagramme : le menu radial
+     *  des Événements Clés, déployé depuis le cœur du yin/yang. */
+    onKeyEventGroupToggle?: (componentIndex: number, open: boolean) => void;
+}
+export declare class GlobalSearchController {
+    private readonly index;
+    private readonly actionMap;
+    private readonly options;
+    private inputEl;
+    private listEl;
+    private clearBtn;
+    private activeIndex;
+    private currentResults;
+    /** Référence directe à l'item actuellement surligné (évite O(n) querySelectorAll). */
+    private _activeItemEl;
+    /** Timer de debounce pour l'input de recherche. */
+    private _inputDebounceTimer;
+    /** Vrai quand le rendu courant est un arbre filtré (query non vide). */
+    private _filteredTreeMode;
+    /** Cache hex + rgb par oddId — calculé une seule fois au démarrage. */
+    private readonly oddRgbCache;
+    /** Index composante id → index pour décodage O(1) des data-nav-key. */
+    private readonly compIdToIndex;
+    /** Vrai si le panneau est en mode contexte (chemin unique, pas de barre de recherche). */
+    private readonly _contextMode;
+    private _onHover?;
+    private _onTitleUpdate?;
+    private onActionDragStart?;
+    private onKeyEventDragStart?;
+    private openComposanteId;
+    private openOddKey;
+    private openCuttingKey;
+    /** Facette dont le groupe "Événements Clés" est déplié (un seul à la fois). */
+    private openEvtGroupId;
+    /** Événement Clé dont les Actions cibles sont surlignées (survol prioritaire sur sélection). */
+    private _amplifierKeyEventId;
+    private expandedDescId;
+    private selectedNavKey;
+    /** Bloc d'impact d'action directe injecté inline sous un cutting dans l'arbre. */
+    private _currentImpactBlock;
+    /** Vrai quand le panneau est verrouillé : toute navigation utilisateur est bloquée. */
+    private _navigationLocked;
+    /** Vrai quand l'utilisateur a manuellement épinglé le bloc d'impact (via le bouton lock). */
+    private _impactBlockLocked;
+    /** Vrai quand le bloc a été masqué suite à une navigation vers un élément hors action (non locké). */
+    private _impactBlockHidden;
+    /** Carte descriptive d'un Événement Clé, injectée dans le panneau de détail
+     *  (droite) — parallèle à _currentImpactBlock mais volontairement séparée :
+     *  un Événement Clé n'a pas (encore) d'entrée dans l'arbre Recherche, donc
+     *  pas de repli "arbre inline", pas d'épinglage, pas de oddId/cutIdx. */
+    private _currentKeyEventBlock;
+    /** Bloc d'action propagée injecté inline sous un cutting cible dans l'arbre. */
+    private _currentPropagationBlock;
+    /** Panneau de détail (droite de l'onglet Recherche) — reçoit descriptions + blocs. */
+    private _detailPanelEl;
+    /** Nom/description de la sphère, affichés dans le placeholder tant qu'aucune
+     *  facette n'est active (voir _syncPlaceholder). Non renseignés = placeholder par défaut. */
+    private _sphereName;
+    private _sphereDescription;
+    /** Enregistre les infos de la sphère à afficher dans le panneau de détail quand rien n'est sélectionné. */
+    setSphereInfo(name: string, description: string): void;
+    /** Container persistant pour l'arbre browse — construit une seule fois, jamais reconstruit. */
+    private _browseContainer;
+    private _compWrappers;
+    private _compToggles;
+    private _oddWrappers;
+    private _oddToggles;
+    private _cutWrappers;
+    private _cutToggles;
+    private _evtGroupWrappers;
+    private _evtGroupToggles;
+    private _navRows;
+    private _descWrappers;
+    private _descBtns;
+    constructor(options: GlobalSearchControllerOptions);
+    mount(containerOrId: string | HTMLElement): void;
+    /**
+     * Événements Clés correspondant à la requête, groupés par facette.
+     *
+     * Match sur `name` et `shortDescription` **uniquement**, jamais via les
+     * actions ciblées : faire remonter un événement parce qu'une action fille
+     * matche afficherait deux fois la même action dans les résultats — une fois
+     * sous son Satellite, une fois sous l'événement.
+     */
+    private searchKeyEvents;
+    private search;
+    private handleInput;
+    private handleKeyDown;
+    /**
+     * Version debounceée de handleInput(), utilisée par le listener "input".
+     * Les appels programmatiques (clear, Escape, setQuery) appellent handleInput() directement.
+     */
+    private debouncedHandleInput;
+    /**
+     * Configure les écouteurs délégués sur listEl (clic, pointerdown, survol).
+     * Monté une seule fois dans mount() — couvre l'arbre ET la liste plate,
+     * éliminant les N listeners inline recréés à chaque renderTree().
+     */
+    private setupDelegatedListeners;
+    /** Décode un data-nav-key en SearchNavTarget. O(1) grâce à compIdToIndex. */
+    private _decodeNavKey;
+    private _clearNodeCaches;
+    /** Relit le DOM fraîchement construit et peuple les Maps de références. Appelé une fois à la fin de chaque rendu. */
+    private _rebuildNodeCaches;
+    private renderTree;
+    /**
+     * Ajoute le groupe "Événements Clés" en fin de liste des enfants d'une
+     * Facette : un séparateur libellé, puis une ligne par Événement Clé.
+     *
+     * Le séparateur est une étiquette, pas un niveau de hiérarchie — il n'a ni
+     * data-nav-key ni sélection, et ses enfants gardent l'indentation des
+     * Satellites. C'est ce qui préserve l'invariant "une Action est toujours
+     * rangée sous un Satellite".
+     *
+     * Une ligne Événement Clé est une **feuille** : elle ne se déplie pas. La
+     * liste de ses Actions cibles est déjà portée par sa carte dans le panneau
+     * de détail — la répéter dans l'arbre serait un doublon. Le lien vers ces
+     * actions s'exprime ici par le projecteur ambre (voir _setAmplifierHighlight),
+     * qui les désigne là où elles vivent vraiment, sous leur Satellite.
+     *
+     * `alwaysOpen` force l'ouverture du groupe (arbre filtré, tout déplié).
+     */
+    private appendKeyEventGroup;
+    private renderFilteredTree;
+    private renderContextEmptyState;
+    /**
+     * Rend le chemin unique composante → ODD → cutting dans le panneau Éclairage.
+     * Quand actionId est fourni (bloc d'action directe), les actions du cutting sont affichées.
+     * Quand actionId est absent (bloc propagé), les actions sont omises — le bloc injecté
+     * suffit ; le div [data-cut-wrapper] reste présent comme ancre d'injection.
+     */
+    private renderContextPath;
+    /** Retourne `true` quand l'appel a replié la facette courante (fermeture),
+     *  `false` quand il en a ouvert une autre. Une fermeture est traitée par
+     *  l'appelant comme un retour en mode Sphère — diagramme et descriptif
+     *  (voir resetToSphereView). */
+    private toggleComposante;
+    private toggleOdd;
+    private setComposanteOpen;
+    private setOddOpen;
+    private toggleCutting;
+    private setCuttingOpen;
+    /**
+     * Groupe "Événements Clés" d'une facette — un seul déplié à la fois.
+     *
+     * Synchronise le diagramme comme le fait le dépli d'un Satellite pour ses
+     * boutons d'Action : ouvrir le groupe déploie le menu radial des Événements
+     * Clés de la facette, le refermer le rétracte. Seul le dépli venu d'un clic
+     * utilisateur émet — applyTreeSync ouvre le groupe en écrivant directement
+     * openEvtGroupId (diagramme → arbre), sans repasser par ici, donc pas de
+     * boucle de rebond.
+     */
+    private toggleEvtGroup;
+    /**
+     * Diagramme → arbre : reflète l'état réel du menu radial des Événements Clés.
+     * Le diagramme referme ces bulles de lui-même dans plusieurs cas (ouverture
+     * du menu d'un Satellite, fermeture ou changement de facette) ; sans ce
+     * miroir, le groupe resterait déplié au-dessus d'un diagramme vide et il
+     * aurait fallu deux clics pour le rouvrir (le premier ne faisant que
+     * rattraper le décalage). DOM seul — n'émet jamais vers le diagramme.
+     */
+    syncKeyEventGroupOpen(componentIndex: number, open: boolean): void;
+    private setEvtGroupOpen;
+    /**
+     * Surligne les lignes Action ciblées par un Événement Clé. Contextuel et non
+     * permanent : dans une facette, jusqu'aux deux tiers des Actions sont ciblées
+     * par au moins un événement — un liseré permanent noierait la teinte ODD sans
+     * jamais dire *par quel* événement.
+     *
+     * Ne déplie aucun Satellite : l'arbre n'ouvre qu'un cutting à la fois, et une
+     * action ciblée vit souvent sous plusieurs. Les lignes déjà visibles se
+     * marquent, les autres le seront au dépli de leur Satellite.
+     */
+    private _setAmplifierHighlight;
+    /** (Ré)applique le surlignage au DOM courant — aussi après reconstruction. */
+    private _applyAmplifierHighlight;
+    /** Événement Clé sélectionné, s'il y en a un — source par défaut du projecteur. */
+    private _selectedKeyEventId;
+    private toggleDesc;
+    private setDescVisible;
+    private restoreExpandedDesc;
+    private highlightMatch;
+    private syncClearBtn;
+    private updateActiveItem;
+    private navKeyFromTarget;
+    private setSelectedNavKey;
+    private restoreSelectedRow;
+    private _syncImpactBlockVisibility;
+    private emitNav;
+    /** Lie le panneau de détail à droite de l'arbre de recherche. */
+    setDetailPanel(el: HTMLElement): void;
+    /** Callback vers le diagramme quand un chip de la légende ODD est
+     *  déplié/replié par un clic direct dans le panneau (sens panneau →
+     *  diagramme — voir syncDiagramOdd pour le sens inverse). */
+    private _onOddLegendActiveChangeCb;
+    setOnOddLegendActiveChange(cb: (componentIndex: number, oddId: string, isOpen: boolean) => void): void;
+    /** Ouvre/ferme la description de cet ODD sous le descriptif actuellement
+     *  affiché (sphère/facette/satellite), comme un clic direct sur son chip
+     *  de légende. Retourne `null` si aucun chip pour cet ODD n'est visible
+     *  dans le contexte courant (no-op), sinon le nouvel état (ouvert/fermé). */
+    toggleOddLegendChipById(oddId: string): boolean | null;
+    /** Lien visuel bidirectionnel chip légende ODD ↔ arc du diagramme (sens
+     *  "chip → diagramme") — voir highlightOddLegendChip pour le retour. */
+    private _attachOddLegendHover;
+    /** Surligne (ou éteint si `oddId` est `null`) le chip de la légende ODD
+     *  correspondant à l'arc actuellement survolé dans le diagramme. */
+    highlightOddLegendChip(oddId: string | null): void;
+    /** Masque le placeholder si du contenu est présent ; sinon l'affiche, avec le
+     *  bloc Sphère si aucune facette n'est active (voir setSphereInfo). */
+    private _syncPlaceholder;
+    /** Efface la description/les blocs affichés et revient au placeholder (bloc Sphère
+     *  si renseigné). Utilisé quand une facette est désactivée depuis le diagramme/la hiérarchie. */
+    clearDetailDesc(): void;
+    /**
+     * `desc` accepte soit une chaîne simple (composante/cutting — un seul champ
+     * `description`, affiché tel quel, jamais de bouton déplier), soit une paire
+     * `{short, full}` (action/keyEvent, qui ont les deux champs) : `short` reste
+     * toujours visible, `full` est repliée par défaut et se substitue à `short`
+     * au clic sur le bouton dédié (les deux ne s'empilent jamais — `description`
+     * est un paragraphe autonome, pas la suite de `shortDescription`).
+     */
+    private _buildDetailDescSection;
+    /** Affiche la description d'un élément (composante/ODD/cutting/action) dans le panneau de détail. */
+    private _showDetailDesc;
+    /**
+     * Affiche un bloc secondaire (prérequis d'action ou propagation) dans le panneau de détail.
+     * Appelé depuis main.ts en remplacement de panelB.showCuttingActionBlock / panelB.showPropagationBlock.
+     */
+    showSecondaryBlock(label: string, html: string, key: string, attachHandlers: (container: HTMLElement) => void): void;
+    /** Retire le bloc secondaire du panneau de détail. */
+    clearSecondaryBlock(): void;
+    /** Met à jour le handler de navigation après construction (pour les slots créés avant la liste de slots). */
+    setOnNavigate(handler: (target: SearchNavTarget) => void): void;
+    /** Enregistre le callback de désélection (re-clic sur un élément sélectionné ou repli de composante). */
+    setOnDeselect(handler: (target: SearchNavTarget) => void): void;
+    /** Enregistre le callback de dépli/repli du groupe "Événements Clés". */
+    setOnKeyEventGroupToggle(handler: (componentIndex: number, open: boolean) => void): void;
+    /** Enregistre le callback de survol de l'arbre. */
+    setOnHover(handler: (target: SearchNavTarget | null) => void): void;
+    /** Enregistre le callback de mise à jour du titre du panneau (badge + nom de l'élément). */
+    setOnTitleUpdate(handler: (badge: {
+        label: string;
+        cssClass: string;
+    } | undefined, title: string | undefined, oddColor?: string, stateValue?: number, weightValue?: number, iconUrl?: string) => void): void;
+    /** Retourne la cible de navigation actuellement sélectionnée dans l'arbre. */
+    getSelectedTarget(): SearchNavTarget | null;
+    private _externalHoverNavKey;
+    /**
+     * Signale visuellement une ligne de l'arbre depuis l'extérieur (ex. survol dans le diagramme).
+     * Utilise la classe gs-row-hover-ext, distincte de la sélection (gs-row-selected).
+     * Passer null efface le highlight.
+     */
+    setExternalHoverNavKey(navKey: string | null): void;
+    setOnActionDragStart(cb: (componentIndex: number, oddId: string, cuttingIndex: number, actionId: string, label: string, event: PointerEvent, el: Element) => void): void;
+    setOnKeyEventDragStart(cb: (componentIndex: number, keyEventId: string, label: string, event: PointerEvent, el: Element) => void): void;
+    setQuery(query: string): void;
+    /**
+     * Cœur partagé de la synchronisation arbre→diagramme.
+     * Ouvre les nœuds nécessaires, sélectionne la ligne et scrolle jusqu'à elle.
+     * No-op en mode arbre filtré (query active).
+     */
+    private applyTreeSync;
+    /** Active ou désactive le mode "action sélectionnée" : bloque les mises à jour d'arbre/sélection pour les cibles non-action. */
+    /** Appelé depuis main.ts quand l'utilisateur clique un arc ODD dans le diagramme. */
+    syncDiagramOdd(componentIndex: number, oddId: string): void;
+    /** Navigue l'arbre jusqu'à la cible. Met aussi à jour l'entête du panneau de détail
+     *  quand alwaysShowDesc est actif (panneaux contextuels) et qu'aucun bloc primaire
+     *  n'est déjà affiché — évite d'écraser l'entête d'un bloc d'action directe en cours. */
+    syncTreeOnly(target: SearchNavTarget): void;
+    /** Navigation vers une action depuis la stack — résout le componentIndex à partir du componentId. */
+    locateStackItem(componentId: string, oddId: string, cuttingIndex: number, actionId: string): void;
+    /** Appelé depuis main.ts pour les clics composante / cutting / action dans le diagramme. */
+    syncDiagramNav(target: SearchNavTarget): void;
+    /**
+     * Called when the active satellite is deselected in the diagram — toggle-to-close,
+     * or an ODD-level interaction taking over. Collapses the open cutting row and
+     * restores the detail panel to the (still current) facette's description, so the
+     * hierarchy mirrors the diagram closing its action menu and falling back to the
+     * facette view rather than being left showing the stale satellite card.
+     */
+    clearDiagramNavSelection(componentIndex: number): void;
+    /**
+     * Retour en mode Sphère : appelé dès qu'une facette est fermée, que ce soit
+     * depuis le diagramme (clic sur l'arc de bordure de la facette courante) ou
+     * depuis la hiérarchie (repli / désélection de la ligne facette). Replie
+     * l'arbre jusqu'à la racine, efface la sélection ET tous les blocs affichés
+     * (action directe, Événement Clé, propagation) pour que le panneau retombe
+     * sur le descriptif Sphère — un bloc d'action laissé en place bloquerait le
+     * placeholder (voir _syncPlaceholder).
+     */
+    resetToSphereView(): void;
+    /**
+     * Injecte le HTML des cartes d'impact directement sous la ligne action dans l'arbre,
+     * comme élément frère suivant le <li class="gs-tree-action"> de l'action sélectionnée.
+     * Ré-utilisé après chaque renderTree pour que le bloc survive aux reconstructions DOM.
+     */
+    private _markActionBeacon;
+    private _clearActionBeacon;
+    /** Verrouille ou déverrouille le panneau : bloque la navigation utilisateur et le bloc d'impact. */
+    setLocked(locked: boolean): void;
+    private _injectImpactBlockIfActive;
+    /** Anime la fermeture d'un bloc puis appelle onDone une seule fois. */
+    private _animateBlockOut;
+    /**
+     * Affiche les cartes d'impact d'une action directe sous la ligne action correspondante
+     * dans l'arbre Recherche, en ouvrant le nœud si nécessaire.
+     * Sélectionne également la ligne action dans l'arbre (surbrillance).
+     * Si un ancien bloc est présent, le ferme d'abord avant d'ouvrir le nouveau.
+     */
+    showCuttingActionBlock(compId: string, oddId: string, cutIdx: number, actionId: string, cardsHtml: string, attachHandlers: (container: HTMLElement) => void): void;
+    /**
+     * Affiche la carte descriptive d'un Événement Clé dans le panneau de
+     * détail (droite) — parallèle à showCuttingActionBlock, sans la logique
+     * d'arbre (pas d'entrée d'arbre pour un Événement Clé pour l'instant) ni
+     * d'épinglage. Ferme d'abord tout bloc existant (exclusivité du panneau).
+     */
+    showKeyEventBlock(compId: string, keyEventId: string, cardsHtml: string, attachHandlers: (container: HTMLElement) => void): void;
+    /** Retire la carte d'Événement Clé du panneau de détail et efface la mémoire. */
+    clearKeyEventBlock(): void;
+    private _injectKeyEventBlockIfActive;
+    /**
+     * Retire le bloc d'impact d'action directe de l'arbre Recherche et efface la mémoire.
+     */
+    clearCuttingActionBlock(): void;
+    /**
+     * Injecte le HTML d'analyse d'action propagée directement sous l'élément cutting
+     * dans l'arbre, après le wrapper de description et avant la liste d'actions.
+     * Ré-utilisé après chaque renderTree pour que le bloc survive aux reconstructions DOM.
+     */
+    private _injectPropagationBlockIfActive;
+    /**
+     * Affiche le bloc d'analyse d'action propagée sous le cutting cible correspondant
+     * dans l'arbre Recherche, en ouvrant le nœud si nécessaire.
+     * Si un ancien bloc est présent, le ferme d'abord avant d'ouvrir le nouveau.
+     */
+    showPropagationBlock(compId: string, oddId: string, cutIdx: number, html: string, attachHandlers: (container: HTMLElement) => void, sourceDesc?: {
+        breadcrumb: string;
+        title: string;
+        description: string;
+    }): void;
+    /** Retire immédiatement (sans animation) les blocs primaire et secondaire du panneau de détail.
+     *  Utilisé lors de la navigation historique pour garantir un état propre avant de réafficher
+     *  le contenu de la cible restaurée. */
+    clearDetailBlocks(): void;
+    clearPropagationBlock(): void;
+}

package/dist/types/components/stack-nav/StackNavOverlay.d.ts

@@ -0,0 +1,82 @@
+import { type Composante } from "../../data/yasuni_cause";
+import { type SearchNavTarget } from "../search/GlobalSearchController";
+export declare class StackNavOverlay {
+    private readonly containerEl;
+    private readonly chipEl;
+    private readonly chipLabelEl;
+    private readonly chipDotEl;
+    private readonly chipStateEl;
+    private readonly dropdownEl;
+    private readonly composantes;
+    private readonly onNavigate;
+    private readonly onDeselect?;
+    private _onHover?;
+    private isOpen;
+    private openCompId;
+    private selectedNavKey;
+    private selectedCompId;
+    private readonly _compToggles;
+    private readonly _compWrappers;
+    private readonly _compRows;
+    private readonly _cuttingRows;
+    private _outsideClickHandler;
+    private _keyHandler;
+    constructor(opts: {
+        containerEl: HTMLElement;
+        composantes: Composante[];
+        onNavigate: (target: SearchNavTarget) => void;
+        /** Appelé quand un cutting ou une Facette déjà sélectionné(e) est re-cliqué(e) (désélection). */
+        onDeselect?: (kind: "cutting" | "composante") => void;
+    });
+    private _buildTree;
+    private _selectCutting;
+    private _toggleComp;
+    private _updateChip;
+    private _positionDropdown;
+    setOnHover(handler: (target: SearchNavTarget | null) => void): void;
+    open(): void;
+    close(): void;
+    /** Déplie la composante donnée dans l'arbre, en repliant l'ancienne — commun
+     *  à toute navigation qui doit révéler son contexte (satellite, Facette, ODD). */
+    private _expandComposante;
+    /** Replie la composante actuellement dépliée, s'il y en a une — utilisé pour
+     *  l'état Sphère (rien de sélectionné), qui remet l'arbre à plat. */
+    private _collapseAll;
+    /** Surligne la ligne Facette donnée (niveau Facette actif, aucun satellite
+     *  sélectionné) — pendant de gs-row-selected sur les lignes satellite. */
+    private _highlightComposanteRow;
+    /** Efface le highlight de satellite dans l'arbre — commun à toute navigation
+     *  vers un niveau non-Satellite (Facette, ODD, Sphère). */
+    private _clearSatelliteHighlight;
+    /**
+     * Called externally whenever the active satellite changes (diagram click,
+     * RECHERCHE navigation, component switch, etc.) to keep the chip in sync.
+     */
+    syncToActiveChild(info: {
+        label: string;
+        oddColor: string;
+        compId: string;
+        oddId: string;
+        cutIdx: number;
+        stateValue?: number;
+        weightValue?: number;
+    } | null): void;
+    /**
+     * Called when the active hierarchy level becomes a Facette (Composante) with no
+     * specific Satellite selected: clic sur une ligne Facette du dropdown, entrée
+     * d'historique "composante" rejouée par back/forward, ou clic direct sur l'arc de
+     * bordure dans le diagramme en mode STACK. Affiche le nom de la Facette dans le
+     * chip en style neutre (pas de couleur ODD), déplie sa ligne dans l'arbre et la
+     * surligne.
+     */
+    syncToActiveComposante(name: string | null): void;
+    /** Même rôle que syncToActiveComposante, pour un clic sur un arc ODD du diagramme —
+     *  déplie la composante parente pour révéler son contexte, sans surligner de ligne
+     *  Facette (l'ODD n'a pas sa propre ligne dans cet arbre). */
+    syncToActiveOdd(name: string | null): void;
+    /** Même rôle que syncToActiveComposante, pour l'état "rien de sélectionné"
+     *  (intro Sphère) — miroir du header RECHERCHE dans ce même état ; remet
+     *  l'arbre à plat (aucune composante dépliée). */
+    syncToSphere(name: string | null): void;
+    destroy(): void;
+}