@micheeeeel/yinyangapp 3.0.1 → 3.1.1

package/dist/types/components/controller/actions/ChildActionMenuController.d.ts

@@ -3,16 +3,31 @@ import { IYinYangView } from "../../../interfaces/IYinYangView";
 import { type ActionDefinition } from "../../../data/yasuni_actions";
 import { ChildrenOrbitEntry } from "../utils/childrenOrbit";
 import { type Point } from "./radialItemMenu";
+/** Mise en scène d'une bulle détachée : "focus" = l'action regardée (style
+ *  ambre, faisceau pulsé) ; "plain" = pleine, style ordinaire (aucune action
+ *  en focus) ; "dimmed" = translucide (une autre action est en focus). */
+export type DetachedBubbleEmphasis = "focus" | "plain" | "dimmed";
+export type DetachedBubble = {
+    /** Identité stable de la bulle (id de l'item de pile, par exemple) : une
+     *  bulle qui ne change que d'emphase est restylée, pas rejouée. */
+    key: string;
+    /** Satellite source porteur de la bulle. */
+    sourceChildKey: string;
+    action: ActionDefinition;
+    /** Actions du menu RECHERCHE de la source dans le mode de l'action : la
+     *  bulle reprend sa place (son angle) dans cet éventail, pour apparaître
+     *  exactement où l'utilisateur l'a trouvée. */
+    menuActions: ActionDefinition[];
+    emphasis: DetachedBubbleEmphasis;
+};
 type DetachedBubbleContext = {
     orbitData: ChildrenOrbitEntry[];
-    /** Satellite source porteur de la bulle — null = aucune bulle détachée. */
-    sourceChildKey: string | null;
-    action: ActionDefinition | null;
+    /** Bulles à afficher — [] les replie toutes. */
+    bubbles: DetachedBubble[];
     childActionMenuItemDistance: number;
     childActionMenuItemScale: number;
     childActionIconFontScale: number;
-    /** Clic sur la bulle : typiquement, sélectionner le satellite source. */
-    onClick: (sourceChildKey: string, actionId: string) => void;
+    onClick: (bubble: DetachedBubble) => void;
 };
 type ChildActionMenuContext = {
     orbitData: ChildrenOrbitEntry[];
@@ -23,10 +38,10 @@ type ChildActionMenuContext = {
     childActionIconFontScale: number;
     /** Actions filtrées pour le cutting actif (depuis yasuniCause + actionMap). */
     actionsForActiveChild: ActionDefinition[];
-    /** Mode STACK : la seule bulle déployée est celle de l'item en focus, et
-     *  son clic vaut clic sur le libellé de cet item dans la pile (ni aperçu,
-     *  ni glisser). null hors STACK. */
-    onStackBubbleClick: (() => void) | null;
+    /** RECHERCHE multi-blocs : un panneau verrouillé fige l'action source.
+     *  Les autres bulles s'estompent, et tout clic passe par ce refus, qui
+     *  peut rejouer le clic (`retry`) une fois déverrouillé. null sinon. */
+    onBlockedActionClick: ((retry: () => void) => void) | null;
 };
 export declare class ChildActionMenuController {
     private readonly view;
@@ -34,6 +49,9 @@ export declare class ChildActionMenuController {
     private readonly refreshActionStackVisual;
     /** Aperçu — clic sur une action : affiche sa carte, ne joue rien. */
     private readonly activateActionFromChild;
+    /** Re-clic sur l'action déjà active : la désélectionne et replie ses
+     *  champs de force, comme un re-clic dans la hiérarchie RECHERCHE. */
+    private readonly deactivateActionFromChild;
     /** Validation — dépôt d'une bulle glissée sur la pile : l'y ajoute. */
     private readonly validateActionSelection;
     /** Glisser une bulle vers une position précise de la pile — cœur partagé
@@ -46,7 +64,7 @@ export declare class ChildActionMenuController {
     /** Groupe séparé pour les traits satellite → bulle, repositionné à chaque
      *  update() juste devant children-group (voir ensureLineLayer) pour
      *  qu'ils s'affichent derrière les satellites plutôt que par-dessus —
-     *  même technique que CoreEventMenuController.coreEventLineLayer. */
+     *  même technique que KeyEventMenuController.coreEventLineLayer. */
     private childActionLineLayer;
     private lastChildActionMenuSourceCenter;
     /** Poignée d'annulation du glisser-déposer en cours (voir startActionDrag),
@@ -59,21 +77,28 @@ export declare class ChildActionMenuController {
      *  le contexte courant) et rejoué au survol : rallumer une impulsion ne
      *  doit pas relancer la chorégraphie d'ouverture. */
     private linkStyleGetter;
-    /** Positions du dernier update() — exposées au champ de force (le segment
-     *  « bulle → source » démarre au centre de la bulle de l'action en focus). */
-    private lastPositions;
+    /** Réglages de la dernière passe de rendu, pour retailler les icônes
+     *  affichées quand une mesure abaisse le facteur admissible. */
+    private iconScaleSetting;
+    private iconActiveActionId;
     private detachedGroup;
     private detachedLineLayer;
-    private lastDetachedCenter;
-    private lastDetachedPosition;
-    /** Centre (coordonnées du globalGroup) de la bulle `actionId` du menu radial
-     *  ouvert, ou null si elle n'y est pas. */
-    getItemCenter(actionId: string): Point | null;
-    /** Centre de la bulle détachée si elle porte `actionId`, sinon null. */
-    getDetachedCenter(actionId: string): Point | null;
+    /** Bulles détachées affichées, par uniqueKey de position — relu pour faire
+     *  rentrer une bulle sortante dans SON satellite source. */
+    private detachedMeta;
+    private detachedPositions;
+    /** Dernière mise en page rendue, relue par followOrbit. null : rien à
+     *  suivre (menu fermé, ou bulles détachées repliées). */
+    private menuLayout;
+    private detachedContext;
+    /** Centre de la bulle détachée de clé `bubbleKey`, ou null si absente. */
+    getDetachedCenter(bubbleKey: string): Point | null;
     constructor(view: IYinYangView, getChildRenderedCenter: (childController: IYinYangController) => Point | null, refreshActionStackVisual: () => void, 
     /** Aperçu — clic sur une action : affiche sa carte, ne joue rien. */
     activateActionFromChild: (childController: IYinYangController, actionId: string, label?: string) => void, 
+    /** Re-clic sur l'action déjà active : la désélectionne et replie ses
+     *  champs de force, comme un re-clic dans la hiérarchie RECHERCHE. */
+    deactivateActionFromChild: (childController: IYinYangController, actionId: string) => void, 
     /** Validation — dépôt d'une bulle glissée sur la pile : l'y ajoute. */
     validateActionSelection: (childController: IYinYangController, actionId: string, label: string, insertAtVisibleIndex?: number | null, entryOrigin?: Point) => void, 
     /** Glisser une bulle vers une position précise de la pile — cœur partagé
@@ -87,8 +112,8 @@ export declare class ChildActionMenuController {
     setOnActionHover(cb: (actionId: string | null, activeChildKey: string) => void): void;
     /**
      * Applique un highlight de survol sur le cercle d'action identifié, ou le retire si null.
-     * Le highlight est posé sur le <g> wrapper (pas sur le <circle>) pour éviter le conflit
-     * avec le filtre inline déjà présent sur le cercle.
+     * Halo blanc à la place de la lueur de la bulle (voir setRadialItemHaloHighlight) :
+     * pas de filtre, la bulle suit l'orbite de son satellite.
      */
     highlightActionById(actionId: string | null): void;
     /** Restyle les seuls liens (impulsion allumée/éteinte), sans toucher à leur
@@ -96,8 +121,8 @@ export declare class ChildActionMenuController {
     private setHoveredAction;
     retractAndDispose(): void;
     clearImmediately(): void;
-    /** Retire la bulle détachée et son faisceau, tout de suite (0) ou après un
-     *  délai (fin d'une transition de facette). */
+    /** Retire les bulles détachées et leurs faisceaux, tout de suite (0) ou
+     *  après un délai (fin d'une transition de facette). */
     private disposeDetached;
     /**
      * Starts the fold-out animation on the visible action buttons, then removes
@@ -106,19 +131,36 @@ export declare class ChildActionMenuController {
      * that follows is a no-op and won't cancel the in-flight transition.
      */
     animateClose(): void;
-    /** Replie la bulle détachée (chorégraphie de fermeture), groupes conservés. */
+    /** Replie les bulles détachées (chorégraphie de fermeture), groupes
+     *  conservés. */
     private closeDetached;
     /**
-     * Bulle détachée de l'action en focus : quand un bloc de propagation est
-     * en focus, le satellite sélectionné n'est pas la source et son menu ne
-     * montre donc pas la bulle de l'action. On pose alors, sur le satellite
-     * source, la seule bulle de cette action (pas ses sœurs), en style
-     * « regardée », avec son faisceau — le champ de force peut ainsi toujours
-     * démarrer à la bulle. Un clic sélectionne le satellite source (le menu
-     * complet prend alors le relais et la bulle détachée se replie).
+     * Bulles détachées : la seule bulle d'une action (pas ses sœurs), posée sur
+     * son satellite source avec son faisceau, hors de tout menu radial.
+     *  - STACK : une par action activée de la pile — celle en focus en style
+     *    « regardée », les autres translucides comme leurs champs de force,
+     *    toutes pleines sans focus. Le champ de l'action en focus démarre à sa
+     *    bulle.
+     *  - RECHERCHE multi-blocs : celle de l'action source du panneau
+     *    verrouillé, quand on consulte un autre satellite.
+     * Chaque bulle garde la place qu'elle occupe dans le menu RECHERCHE de
+     * sa source (voir DetachedBubble.menuActions) : deux actions d'un même
+     * satellite ne s'y chevauchent donc pas.
      * Cluster indépendant du menu radial : update() n'en sait rien.
      */
     updateDetached(context: DetachedBubbleContext): void;
+    /**
+     * Frame d'orbite : recale le menu radial et les bulles détachées déjà
+     * affichés sur la position courante de leur satellite, avec la mise en
+     * page de leur dernier rendu. Ni data join, ni transition, ni listeners :
+     * leur contenu ne change que par update() / updateDetached().
+     */
+    followOrbit(orbitData: ChildrenOrbitEntry[]): void;
+    private computeDetachedLayout;
+    /** Retaille les icônes déjà affichées (menu et bulle détachée) sans
+     *  repasser par update() : un simple satellite sélectionné, sans action
+     *  active, ne déclencherait pas de rendu via le réglage du debug. */
+    private refitActionIcons;
     private ensureDetachedGroups;
     update(context: ChildActionMenuContext): void;
     private ensureChildActionMenuGroup;

package/dist/types/components/controller/actions/KeyEventController.d.ts

@@ -1,8 +1,7 @@
 import { IYinYangView } from "../../../interfaces/IYinYangView";
 import { YinYangInternalModel } from "../../../interfaces/IYinYangInternalModel";
 import { type KeyEventDefinition } from "../../../data/yasuni_key_events";
-import { ChildrenOrbitEntry } from "../utils/childrenOrbit";
-import { CoreEventMenuController } from "./CoreEventMenuController";
+import { KeyEventMenuController } from "./KeyEventMenuController";
 import { ActionStackController } from "../action-stack/ActionStackController";
 import { ForceFieldDetailsPanel } from "../force-field/ForceFieldDetailsPanel";
 import { EventFieldRenderer } from "../force-field/EventFieldRenderer";
@@ -15,10 +14,8 @@ import { ActionStackManager } from "../action-stack/ActionStackManager";
 export type KeyEventControllerDeps = {
     actionStackController: ActionStackController;
     actionStackManager: ActionStackManager;
-    animateChildrenHide: () => void;
-    buildChildrenOrbitData: () => ChildrenOrbitEntry[];
     closeChildActionMenu: () => void;
-    coreEventMenuController: CoreEventMenuController;
+    keyEventMenuController: KeyEventMenuController;
     eventFieldLifecycleController: EventFieldLifecycleController;
     eventFieldRenderer: EventFieldRenderer;
     forceFieldDetailsPanel: ForceFieldDetailsPanel;
@@ -27,52 +24,93 @@ export type KeyEventControllerDeps = {
         y: number;
     } | null;
     getCurrentComponentOrUndefined: () => YinYangInternalModel["components"][number] | undefined;
+    /** Satellite-facette d'une facette en sous-état Idle « facettes » : centre
+     *  rendu et rayon, ou null s'il n'est pas (encore) affiché. */
+    getFacetteSatelliteAnchor: (componentId: string) => {
+        center: {
+            x: number;
+            y: number;
+        };
+        radius: number;
+    } | null;
+    /** Vrai quand le sous-état Idle « facettes » est affiché. */
+    isIdleFacettesActive: () => boolean;
+    /** Amène le diagramme en Idle « facettes » (referme la Facette ouverte,
+     *  bascule le sous-état) ; résolu une fois les satellites-facettes sortis. */
+    showIdleFacettes: () => Promise<void>;
     navigateToPrereqAction: (actionId: string) => void;
-    prepareForComponentSwitch: (targetComponentId: string) => void;
     session: ControllerSession;
     state: YinYangControllerState;
     titlePresenter: ComponentTitlePresenter;
     ui: ControllerUiCallbacks;
     view: IYinYangView;
 };
-/** Événements Clés : menu radial du cœur, aperçu de carte, champ
- *  d'événement et ajout à la pile. */
+/** Événements Clés : menu radial des satellites-facettes, aperçu de carte,
+ *  champ d'événement et ajout à la pile. */
 export declare class KeyEventController {
     private deps;
+    /** Aperçu effacé par le dernier clic sur un satellite-facette, avec
+     *  l'instant de l'effacement — voir restorePreviewClearedByDoubleClick. */
+    private previewClearedBySwitch;
     constructor(deps: KeyEventControllerDeps);
+    /** Facette dont les bulles d'Événements Clés sont déployées, ou null. */
+    getKeyEventMenuFacetteId(): string | null;
+    private notifyKeyEventMenuState;
+    /**
+     * Clic sur un satellite-facette (Idle « facettes ») : déploie ses bulles
+     * d'Événements Clés, ou les replie si elles l'étaient déjà — même règle
+     * que le clic sur un satellite de cutting pour ses boutons d'action. Un
+     * seul menu à la fois : ouvrir celui d'une facette replie celui d'une
+     * autre.
+     */
+    toggleKeyEventMenu(componentId: string): void;
     /**
-     * Appelé par YinYangDrawer quand le petit cercle "œil" du lobe dominant
-     * (yin ou yang, selon Composante.orientation) est cliqué — jamais l'autre
-     * lobe, jamais un satellite (garde déjà appliquée côté YinYangDrawer, même
-     * principe que onDiagramOddArcClicked pour les arcs ODD). Ouvre/ferme le
-     * menu radial des Événements Clés de la facette active.
+     * Double-clic sur un satellite-facette (entrée dans sa Facette) : son
+     * premier clic a déjà basculé (ou replié) les bulles, effaçant au passage
+     * l'aperçu en cours — celui-là même dont le souffle doit se poursuivre
+     * dans la Facette. On le rétablit s'il vient d'être effacé.
      */
-    onCoreEventNucleusClicked(): void;
-    notifyKeyEventMenuState(open: boolean): void;
-    private toggleCoreEventMenu;
+    restorePreviewClearedByDoubleClick(): void;
+    /** Replie les bulles du satellite-facette ouvert — et l'aperçu qu'elles
+     *  portaient. No-op si aucun menu n'est déployé. */
+    closeKeyEventMenu(): void;
+    /** Les satellites-facettes sont sortis : un Événement Clé encore en aperçu
+     *  (revenu d'une Facette) retrouve ses bulles sur le satellite-facette
+     *  d'origine, sa bulle allumée, et son souffle en part. */
+    onIdleFacettesShown(): void;
+    /** Les satellites-facettes rentrent (bascule vers les arcs ou ouverture
+     *  d'une Facette) : leurs bulles rentrent avec eux. L'aperçu, lui, reste
+     *  en place jusqu'au choix d'une autre action ou d'un autre événement —
+     *  invisible en Idle « arcs », il retrouve son souffle dans une Facette
+     *  concernée ou au retour des satellites-facettes. */
+    onIdleFacettesHidden(): void;
     /**
      * Fermeture du Champ d'événement : l'Événement Clé en aperçu et les bulles
-     * du menu cœur — chemin unique partagé par la fermeture de facette
+     * du satellite-facette — chemin unique partagé par la fermeture de facette
      * (closeCurrentComposante) et par l'exclusivité action/événement
      * (openActionMenuFromChild). No-op si rien n'est ouvert.
      *
      * hide() d'abord pour la rétraction immédiate du souffle (le geste
      * d'ouverture joué à l'envers — cf. prepareForComponentSwitch),
-     * updateCoreEventMenu() ensuite pour replier les bulles et laisser
+     * updateKeyEventMenu() ensuite pour replier les bulles et laisser
      * refreshTargets constater qu'il n'y a plus rien à dessiner. La carte du
      * panneau RECHERCHE part avec : elle décrit l'Événement Clé qu'on vient de
      * retirer du diagramme, et rien ne garantit qu'un autre bloc prenne sa
      * place (ouvrir un satellite n'affiche qu'un descriptif, pas un bloc).
      */
     closeKeyEventField(): void;
-    updateCoreEventMenu(): void;
+    updateKeyEventMenu(): void;
     /**
      * Événements Clés qui pilotent le Champ d'événement en ce moment — source
      * unique de vérité pour EventFieldLifecycleController (cibles) comme pour
      * getEventFieldSource (point d'émission).
      *
+     * Rien en Idle « arcs ». En Idle « facettes », le souffle relie le
+     * satellite-facette d'origine aux AUTRES satellites-facettes atteints ; en
+     * Facette, il part du cœur vers les satellites de cutting.
+     *
      * Deux régimes, mêmes règles de priorité que le champ de force d'action :
-     * un APERÇU (clic sur une bulle du menu cœur ou sur l'entrée de l'arbre
+     * un APERÇU (clic sur une bulle d'un satellite-facette ou sur l'entrée de l'arbre
      * RECHERCHE) prend toujours la main — c'est le geste que l'utilisateur
      * vient de faire, quel que soit l'onglet ; sinon, en mode STACK, ce sont
      * les Événements Clés COCHÉS de la pile qui décident, exactement comme les
@@ -87,25 +125,10 @@ export declare class KeyEventController {
      * l'arc de sa facette d'origine).
      */
     getEventFieldKeyEvents(): KeyEventDefinition[];
-    /**
-     * Point d'émission du Champ d'événement : le CŒUR du yin/yang, c'est-à-dire
-     * le disque central du lobe correspondant à l'orientation de la facette
-     * courante — le cœur noir du yang sur une facette Yang, le cœur blanc du
-     * yin sur une facette Yin. Ce n'est PAS le centre géométrique du symbole :
-     * les deux lobes ont des rayons qui varient avec le score, donc le cœur se
-     * déplace le long de l'axe vertical au fil de la partie, d'où la
-     * relecture de la géométrie à chaque frame. Injecté dans
-     * EventFieldLifecycleController (getEventFieldSource), rappelé à chaque
-     * frame de son animation.
-     *
-     * `geometry.yin/yang.centerY` est la position CANONIQUE (pré-rotation) :
-     * pendant une rotation Yin/Yang (AnimationsMngr), le cœur visible se
-     * déplace via un `transform` écrit à même `graphElementGroup` à chaque
-     * frame, sans jamais toucher `geometry`. On lit donc la position réelle
-     * via getLiveLobeCoreCenter plutôt que la géométrie statique, pour que les
-     * anneaux du champ d'événement suivent le cœur qui tourne au lieu de
-     * naître à une origine figée.
-     */
+    /** Événements Clés cochés de la pile, dans l'ordre de la pile, réduits à
+     *  ceux qui ont une bulle dans le mode courant. */
+    private getCheckedStackKeyEvents;
+    /** Origin satellite while visible; its facet arc carries the field after navigation. */
     getEventFieldSource(): {
         center: {
             x: number;
@@ -113,18 +136,6 @@ export declare class KeyEventController {
         } | null;
         radius: number;
     };
-    /**
-     * Résout un point porté par `lobeGroup` (coordonnées locales, ici le
-     * centre canonique du cœur) dans le repère de globalGroup — celui où
-     * EventFieldRenderer dessine (voir EventFieldLifecycleController,
-     * getGlobalGroupNode). Passe par les CTM SVG plutôt que de reparser
-     * l'attribut `transform` (comme getChildRenderedCenter le fait pour une
-     * simple translation) : le transform posé sur graphElementGroup pendant
-     * une rotation combine rotate ET translate, et cette composition suit
-     * fidèlement AnimationsMngr sans dépendre de sa formule exacte — un
-     * changement futur de celle-ci n'a pas besoin d'être répercuté ici.
-     */
-    private getLiveLobeCoreCenter;
     /**
      * Rejoue l'aperçu d'un Événement Clé depuis une navigation Recherche
      * (historique précédent/suivant) — pendant minimal de searchNavigateToAction,
@@ -139,41 +150,35 @@ export declare class KeyEventController {
      *
      * Volontairement plus étroit que previewKeyEvent : ni carte redessinée, ni
      * notification de navigation (donc pas d'entrée d'historique en double) —
-     * le panneau montre déjà cet événement, c'est le diagramme qui le rattrape.
-     * On garde en revanche l'exclusivité action/événement : les deux champs ne
-     * cohabitent jamais.
-     *
-     * Si la facette courante n'est plus celle de l'événement (l'utilisateur a
-     * navigué ailleurs pendant le mode STACK), on revient d'abord sur sa facette
-     * d'origine — mêmes gestes que searchSetKeyEventMenuOpen : l'aperçu survit
-     * au switch (prepareForComponentSwitch le garde vivant, destination =
-     * origine) et le menu cœur se redéploie à l'arrivée avec sa bulle active.
+     * le panneau montre déjà cet événement, c'est le diagramme qui le rattrape :
+     * bascule en Idle « facettes » (une Facette ouverte se referme), bulles du
+     * satellite-facette d'origine déployées, celle de l'événement allumée.
      */
     restoreKeyEventDiagramState(keyEventId: string): void;
     /**
      * Dépli/repli du groupe "Événements Clés" depuis la hiérarchie RECHERCHE —
-     * pendant exact du clic sur le cœur du yin/yang (onCoreEventNucleusClicked),
-     * pour que l'arbre et le diagramme montrent le même menu déployé : ouvrir le
-     * groupe déploie les bulles de la facette, le refermer les rétracte (même
-     * règle que le dépli d'un Satellite, qui déploie ses boutons d'Action).
+     * pendant exact du clic sur un satellite-facette, pour que l'arbre et le
+     * diagramme montrent le même menu déployé : ouvrir le groupe bascule en
+     * Idle « facettes » (une Facette ouverte se referme) et déploie les bulles
+     * de ce satellite-facette, le refermer les rétracte.
      *
      * Le repli passe par closeKeyEventField plutôt que par le toggle : il doit
      * aussi emporter l'Événement Clé en aperçu (et sa carte), sinon une bulle
      * validée resterait allumée sous un groupe replié.
      */
     searchSetKeyEventMenuOpen(componentIndex: number, open: boolean): void;
-    /** Ouverture idempotente du menu cœur — no-op s'il est déjà déployé (le
-     *  toggle le refermerait). */
-    openCoreEventMenu(): void;
+    /** Ouverture idempotente des bulles d'un satellite-facette — no-op si
+     *  elles sont déjà déployées (le toggle les refermerait). */
+    openKeyEventMenu(componentId: string): void;
     /** Seul point de mutation de activeKeyEventId — resynchronise la ligne
      *  Événement Clé du titre (voir getCurrentSatelliteTitle) à chaque
      *  changement, exactement comme setActiveChildKey le fait pour le
      *  satellite. */
     setActiveKeyEventId(keyEventId: string | null): void;
     /**
-     * Clic sur une bulle du menu cœur. En STACK : clic sur le libellé de son
-     * item de pile — celui en focus s'il s'agit de cet événement, sinon le
-     * plus récent ; rien s'il n'est pas dans la pile. Ailleurs : aperçu.
+     * Clic sur une bulle d'un satellite-facette. En STACK : clic sur le libellé de son
+     * item coché de pile — celui en focus s'il s'agit de cet événement, sinon le
+     * plus récent ; rien s'il n'est pas coché dans la pile. Ailleurs : aperçu.
      */
     onKeyEventBubbleClick(keyEvent: KeyEventDefinition): void;
     /** Aperçu — 1er clic sur un Événement Clé : affiche sa carte descriptive
@@ -189,4 +194,7 @@ export declare class KeyEventController {
         x: number;
         y: number;
     }): void;
+    /** En Idle « tab » : sélectionne une facette pour le titre dynamique, sans
+     *  ouvrir/fermer les bulles d'événements. Rafraîchit le titre. */
+    selectKeyEventFacetteForTab(componentId: string): void;
 }

package/dist/types/components/controller/actions/{CoreEventMenuController.d.ts → KeyEventMenuController.d.ts}

@@ -1,41 +1,36 @@
 import { IYinYangView } from "../../../interfaces/IYinYangView";
 import { type KeyEventDefinition } from "../../../data/yasuni_key_events";
 import { type Point } from "./radialItemMenu";
-type CoreEventMenuContext = {
-    /** null/false ferme le menu (même logique que activeActionMenuChildKey côté satellite). */
-    isOpen: boolean;
-    keyEventsForActiveFacette: KeyEventDefinition[];
+type KeyEventMenuContext = {
+    /** Satellite-facette (Idle « facettes ») qui porte le menu, ou null pour
+     *  le refermer : centre rendu et rayon du satellite. */
+    anchor: {
+        center: Point;
+        radius: number;
+    } | null;
+    /** Centre du cercle global : l'éventail s'ouvre vers l'extérieur, sur
+     *  l'axe centre → satellite, comme les boutons d'action d'un satellite. */
+    parentCenter: Point;
+    keyEvents: KeyEventDefinition[];
     /** Id de l'événement actuellement en aperçu (carte affichée), ou null. */
     activeKeyEventId: string | null;
-    /** Même valeur que le contrôle "Distance boutons" du groupe "Grappe Actions"
-     *  (state.menu.itemDistance) — pas de contrôle dédié : voir le calcul de
-     *  offsetDistance plus bas, qui la réutilise telle quelle. */
-    childActionMenuItemDistance: number;
-    /** Distance centre du cercle central → satellites de la facette active
-     *  (moyenne des rayons d'orbite réels, cf. buildChildrenOrbitData) — le
-     *  "connu" dont dérive offsetDistance plus bas. */
-    childrenOrbitRadius: number;
-    /** Taille des bulles — contrôle dédié "Taille boutons" du groupe
-     *  "Événements clés" (state.menu.coreEventMenuItemScale) : les Événements
-     *  Clés se dimensionnent indépendamment des boutons d'action des
-     *  satellites. */
-    coreEventMenuItemScale: number;
-    coreEventIconFontScale: number;
-    /** Ajustement fin (px) de la distance des boutons, de part et d'autre de
-     *  la longueur auto-calculée — contrôle "Distance boutons" du groupe
-     *  "Événements clés", voir state.menu.coreEventMenuDistanceOffset. */
-    coreEventMenuDistanceOffset: number;
+    /** Distance satellite → bulles : même base que les boutons d'action
+     *  (smallCircleRadius × state.menu.itemDistance, voir
+     *  ChildActionMenuController), ajustée par keyEventMenuDistanceOffset. */
+    offsetDistance: number;
+    /** Rayon des bulles — contrôle dédié "Taille boutons" du groupe
+     *  "Événements clés" (state.menu.keyEventMenuItemScale). */
+    itemRadius: number;
+    keyEventIconFontScale: number;
 };
 /**
- * Menu radial des Événements Clés, déclenché par un clic sur le cercle
- * central (yin-yang) de la facette active — même langage visuel et même
- * sémantique de clic que ChildActionMenuController (bulles + icône,
- * chorégraphie D3 en éventail factorisée dans radialItemMenu.ts ; clic =
- * aperçu, glisser vers la pile = validation), mais ancré sur
- * le centre fixe de la facette plutôt que sur un satellite, et déployé à
- * angle égal sur 360° plutôt que sur un axe source.
+ * Menu radial des Événements Clés d'une facette, déployé autour de son
+ * satellite-facette (sous-état Idle « facettes ») — même langage visuel et
+ * même sémantique que ChildActionMenuController autour d'un satellite de
+ * cutting (bulles + icône, chorégraphie D3 en éventail factorisée dans
+ * radialItemMenu.ts ; clic = aperçu, glisser vers la pile = validation).
  */
-export declare class CoreEventMenuController {
+export declare class KeyEventMenuController {
     private readonly view;
     /** Clic sur une bulle — aperçu, ou focus de son item de pile en STACK
      *  (voir KeyEventController.onKeyEventBubbleClick). */
@@ -48,11 +43,11 @@ export declare class CoreEventMenuController {
      *  SearchPanelSynchronizer.startActionDrag, entièrement générique).
      *  Retourne une poignée d'annulation, conservée dans activeDragCancel. */
     private readonly startKeyEventDrag;
-    private coreEventMenuGroup;
+    private keyEventMenuGroup;
     /** Groupe séparé pour les traits centre → bulle, abaissé au fond du
      *  z-order (voir ensureLineLayer) pour qu'ils s'affichent derrière le
      *  disque central et les satellites plutôt que par-dessus. */
-    private coreEventLineLayer;
+    private keyEventLineLayer;
     /** Poignée d'annulation du glisser-déposer en cours (voir startKeyEventDrag),
      *  ou null si aucun glisser n'est en cours — même rôle que
      *  ChildActionMenuController.activeDragCancel. */
@@ -80,7 +75,7 @@ export declare class CoreEventMenuController {
     private _onHoverCb?;
     setOnHover(cb: (keyEventId: string | null) => void): void;
     clearImmediately(): void;
-    update(context: CoreEventMenuContext): void;
+    update(context: KeyEventMenuContext): void;
     /** Restyle les seuls liens (impulsion allumée/éteinte) sans toucher à leur
      *  géométrie : le survol ne doit rien réanimer. */
     private setHoveredKeyEvent;

package/dist/types/components/controller/actions/radialItemMenu.d.ts

@@ -20,6 +20,19 @@ export type RadialMenuItemPosition<T> = {
  *   cercle central — pas d'axe source à respecter, maximise l'écart
  *   angulaire entre bulles).
  */
+/** Lueur d'une bulle : équivalent de `drop-shadow(0 0 ${blur}px ${color})`. */
+export type RadialItemGlow = {
+    color: string;
+    blur: number;
+} | null;
+/**
+ * Habille le halo pré-rendu d'une bulle (cercle `${dataRole}-halo`, créé
+ * sous la plaque) : un disque à dégradé radial au lieu d'un drop-shadow sur
+ * la plaque. `null` l'éteint.
+ */
+export declare function styleRadialItemHalo(group: d3.Selection<SVGGElement, unknown, null, undefined>, dataRole: string, radius: number, glow: RadialItemGlow): void;
+/** Allume / éteint le halo de survol d'une bulle, sans perdre sa lueur propre. */
+export declare function setRadialItemHaloHighlight(group: d3.Selection<SVGGElement, unknown, null, undefined>, dataRole: string, highlighted: boolean): void;
 export declare function computeFanPositions<T extends {
     id: string;
 }>(items: T[], opts: {
@@ -31,6 +44,14 @@ export declare function computeFanPositions<T extends {
     itemRadius: number;
     keyPrefix: string;
 }): RadialMenuItemPosition<T>[];
+/**
+ * Recale des bulles DÉJÀ rendues sur de nouvelles positions (frame d'orbite) :
+ * ni data join, ni transition, ni listeners. Une bulle encore en ouverture
+ * n'est pas touchée directement — sa transition relit la cible mise à jour
+ * ici (liveItemTransformTween). Les bulles absentes de `positions` (en
+ * sortie) restent à leur chorégraphie.
+ */
+export declare function followRadialItems<T>(groupNode: SVGGElement, dataRole: string, positions: RadialMenuItemPosition<T>[]): void;
 /**
  * Referme et retire toutes les bulles d'un menu radial (repli en
  * éventail), utilisé à la fois quand update() ne reçoit plus de
@@ -48,8 +69,10 @@ export declare function renderRadialItemsChoreography<T>(params: {
     groupNode: SVGGElement;
     dataRole: string;
     positions: RadialMenuItemPosition<T>[];
-    exitAnimationCenter: Point;
-    enterCenter: Point;
+    /** Un point unique, ou un point par bulle (bulles détachées : chacune naît
+     *  de son propre satellite source et y retourne). */
+    exitAnimationCenter: Point | ((d: RadialMenuItemPosition<T>) => Point);
+    enterCenter: Point | ((d: RadialMenuItemPosition<T>) => Point);
     getIconUrl: (id: string) => string;
     /** Décor optionnel inséré entre la plaque (cercle) et le pictogramme, sur
      *  la seule sélection enter() — c'est par là que le menu des Événements
@@ -86,7 +109,7 @@ export declare function styleRadialItemLinks<T extends {
 }>(groupNode: SVGGElement | null, dataRole: string, getStyle: (d: RadialMenuItemPosition<T>) => RadialItemLinkStyle): void;
 /**
  * Chorégraphie D3 des liens parent → item, rendus dans un groupe SÉPARÉ de
- * celui des bulles (voir CoreEventMenuController : ce groupe est glissé plus
+ * celui des bulles (voir KeyEventMenuController : ce groupe est glissé plus
  * tôt dans le z-order pour passer derrière les satellites et le disque
  * central, alors que les bulles restent devant dans leur propre groupe).
  * Anime directement x2/y2 des lignes : un lien entrant grandit depuis le bord
@@ -101,8 +124,23 @@ export declare function renderRadialItemLinks<T extends {
     groupNode: SVGGElement;
     dataRole: string;
     positions: RadialMenuItemPosition<T>[];
-    center: Point;
+    /** Centre du parent — un seul, ou un par bulle (bulles détachées). */
+    center: Point | ((d: RadialMenuItemPosition<T>) => Point);
     /** Rayon du disque parent : le faisceau démarre à son bord. 0 = au centre. */
-    startRadius?: number;
+    startRadius?: number | ((d: RadialMenuItemPosition<T>) => number);
     getStyle?: (d: RadialMenuItemPosition<T>) => RadialItemLinkStyle;
 }): void;
+/**
+ * Pendant de followRadialItems pour les faisceaux : origine, extrémité et
+ * dégradé recalés sur les nouvelles positions, sans data join ni transition.
+ * Un faisceau encore en ouverture garde sa transition, qui relit la cible.
+ */
+export declare function followRadialItemLinks<T extends {
+    id: string;
+}>(params: {
+    groupNode: SVGGElement;
+    dataRole: string;
+    positions: RadialMenuItemPosition<T>[];
+    center: Point | ((d: RadialMenuItemPosition<T>) => Point);
+    startRadius?: number | ((d: RadialMenuItemPosition<T>) => number);
+}): void;

package/dist/types/components/controller/children/ChildInteractionController.d.ts

@@ -32,6 +32,9 @@ export declare class ChildInteractionController {
     setChildrenHiddenState(childControllers: IYinYangController[], hidden: boolean): void;
     attachChildToggleHandler(childController: IYinYangController, childOddMap: Map<string, ChildOddMeta>): void;
     attachChildHoverHandler(childController: IYinYangController, childOddMap: Map<string, ChildOddMeta>): void;
+    private backgroundClickContainer;
+    /** Un seul écouteur par conteneur : le SVG racine survit aux recréations de
+     *  satellites, et cette méthode est rappelée à chacune. */
     attachBackgroundClickHandler(): void;
     enterOddView(oddId: string): void;
     exitOddView(): void;
@@ -41,6 +44,7 @@ export declare class ChildInteractionController {
     private applyChildActiveStyle;
     /** Filtre courant d'un satellite : la mise en valeur d'un ODD prime sur le
      *  style "actif", qui prime lui-même sur l'état neutre. */
+    private resolveGlowFor;
     private resolveFilterFor;
     private getChildOffset;
 }