@micheeeeel/yinyangapp 2.2.2 → 2.3.1

package/dist/types/components/controller/odd/OddViewManager.d.ts

@@ -3,6 +3,7 @@ import { IYinYangView } from "../../../interfaces/IYinYangView";
 import { YinYangInternalModel } from "../../../interfaces/IYinYangInternalModel";
 import { ForceFieldDetailsPanel } from "../force-field/ForceFieldDetailsPanel";
 import { ActionStackController } from "../action-stack/ActionStackController";
+import { OddHighlightIntensity, ChildHighlightState } from "./childHighlightStyles";
 import type { CumulativeBlock } from "../YinYangController";
 type ChildOddMeta = {
     oddId: string;
@@ -27,18 +28,108 @@ type OddViewManagerDeps = {
         id: string;
     }) => CumulativeBlock[];
     onNavigateToAction: (actionId: string) => void;
+    /** Centre orbital courant d'un satellite dans le repère du globalGroup de
+     *  la facette (identique à celui que consomme WeightPreviewRingRenderer). */
+    getChildRenderedCenter: (childController: IYinYangController) => {
+        x: number;
+        y: number;
+    } | null;
+    getChildRadius: (childController: IYinYangController) => number;
+    /** Satellites atteints par la propagation de l'action en cours — exemptés
+     *  de l'extinction appliquée aux non-membres. */
+    getPropagationTargetKeys: () => Set<string>;
 };
 export declare class OddViewManager {
     private deps;
+    private readonly highlightEffects;
+    /** ODD mis en valeur (clic ou survol d'un arc / d'un chip de légende). */
+    private oddHighlight;
+    /** Satellite sélectionné (menu d'action ouvert) — il porte la même mise en
+     *  valeur que celle d'un ODD, mais resserrée sur lui seul. */
+    private selectedChildKey;
+    /** Aperçu transitoire au survol d'un item de la pile — prioritaire tant
+     *  qu'il dure, et sans effets de sélection. */
+    private stackPreviewKeys;
+    /** Laquelle des deux sélections délibérées — un ODD, ou un satellite — est
+     *  la plus récente. Elles peuvent coexister (le menu d'un satellite reste
+     *  ouvert quand on clique un chip d'ODD) ; c'est la dernière voulue par
+     *  l'utilisateur qui porte la mise en valeur. */
+    private lastDeliberate;
+    /** Résultat des trois couches ci-dessus, relu par
+     *  ChildInteractionController pour que son style "satellite actif"
+     *  n'écrase pas la mise en valeur. */
+    private currentHighlight;
+    getCurrentHighlight(): ChildHighlightState;
     constructor(deps: OddViewManagerDeps);
-    highlightOddInChildren(oddId: string | null): void;
+    highlightOddInChildren(oddId: string | null, intensity?: OddHighlightIntensity): void;
+    /**
+     * Sélectionne (ou désélectionne) le satellite qui porte la mise en valeur.
+     * Elle prime sur celle d'un ODD : sélectionner un satellite resserre le
+     * focus sur lui seul, et le relâcher rend la main à l'ODD éventuellement
+     * sélectionné.
+     */
+    setSelectedChildHighlight(childKey: string | null): void;
+    /**
+     * Recalcule la mise en valeur effective à partir des trois couches — aperçu
+     * de pile, satellite sélectionné, ODD — puis la pose sur les satellites et
+     * synchronise les effets réservés à la sélection.
+     */
+    private applyHighlight;
+    /**
+     * Couche gagnante. L'aperçu de pile et le survol d'un ODD priment toujours
+     * — ce sont des états transitoires, qui doivent rester lisibles même quand
+     * quelque chose est sélectionné. Entre les deux sélections durables, ODD et
+     * satellite, c'est la plus récente qui l'emporte.
+     */
+    private resolveHighlight;
+    private buildSelectedChildLayer;
+    private buildOddLayer;
+    /**
+     * Un ODD *sélectionné* (arc actif, ou ODD affiché en vue ODD) passe en
+     * "full" ; tout le reste — au premier chef le survol d'un arc voisin —
+     * reste en "soft". Corollaire utile : quand la souris quitte un arc
+     * survolé, YinYangController retombe sur l'ODD actif, qui retrouve donc
+     * automatiquement son intensité pleine.
+     */
+    private resolveIntensity;
+    /** Allume (ou éteint) tout ce qui n'appartient qu'à la sélection : anneaux
+     *  de visée + pings + onde de scan, et spikes énergisés avec leurs
+     *  comètes. */
+    private syncFullHighlightEffects;
+    /** Relu à chaque frame par OddHighlightEffects : les satellites orbitent
+     *  sous les anneaux, et peuvent disparaître (satellites masqués, facette
+     *  changée) sans que la mise en valeur soit repassée. */
+    private buildHighlightTargets;
     highlightOddByStackItemId(stackItemId: string | null): void;
     cancelOddHighlight(): void;
     showOddInfo(oddId: string): void;
     showComposanteInfo(): void;
     applyOddHighlight(oddId: string): void;
     applyEnterOddView(oddId: string): void;
+    /**
+     * Sélectionner un satellite ne sélectionne PAS son ODD : la mise en valeur
+     * d'un ODD est réservée à un clic sur l'ODD lui-même (arc du diagramme ou
+     * chip de légende). Seule subsiste ici la navigation propre à la vue ODD,
+     * qui n'affiche qu'un ODD à la fois et doit donc basculer sur celui du
+     * satellite cliqué.
+     */
     applyOddStateForCutting(oddId: string): void;
+    /** Repose sur un satellite le filtre que son état courant impose — utilisé
+     *  après un aperçu qui l'avait écrasé (survol depuis l'arbre Recherche),
+     *  pour ne pas le rendre "sans filtre" alors qu'un ODD est mis en valeur. */
+    refreshChildFilter(childController: IYinYangController): void;
+    /** Recalcule la mise en valeur sans changer de cible — appelé quand le
+     *  champ de force change, puisque les satellites qu'il touche échappent à
+     *  l'extinction. */
+    refreshHighlight(): void;
     private applyChildOddHighlight;
+    /**
+     * Halo coloré d'un satellite membre : deux cercles (lueur + trait net)
+     * dans son yinYangGroup, au même endroit que l'anneau de sélection STACK
+     * (ChildScoresDeltaRenderer) — ils suivent donc l'orbite et la respiration
+     * du satellite sans aucun travail par frame, là où un drop-shadow sur le
+     * groupe était recalculé à chaque déplacement.
+     */
+    private updateChildHaloRing;
 }
 export {};

package/dist/types/components/controller/odd/childHighlightStyles.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Source unique du filtre CSS posé sur le groupe d'un satellite.
+ *
+ * Trois acteurs y touchaient chacun de leur côté — la mise en valeur d'un ODD
+ * (OddViewManager), le style "satellite actif" et le survol
+ * (ChildInteractionController) — et le dernier à passer gagnait : la
+ * sélection d'un ODD était effacée dès qu'un menu d'action se rafraîchissait.
+ * Tout le monde passe désormais par `resolveChildFilter`.
+ */
+/**
+ * Deux niveaux de mise en valeur d'un ODD sur ses satellites :
+ *  - "soft" (survol d'un arc) : uniquement le halo coloré des membres et
+ *    l'extinction des autres. Réversible, sans animation démarrée, pour que
+ *    balayer le cercle central ne fasse pas clignoter toute la constellation.
+ *  - "full" (sélection) : ajoute les anneaux de visée et les pings
+ *    (OddHighlightEffects), les spikes énergisés avec leurs comètes
+ *    (SpikeDrawer.setOddSpikeHighlight) et l'onde de scan initiale.
+ */
+export type OddHighlightIntensity = "soft" | "full";
+/**
+ * Mise en valeur courante sur les satellites d'une facette. Elle porte
+ * l'ensemble des satellites concernés plutôt qu'un ODD, parce que la même
+ * mécanique sert deux cibles : tous les satellites d'un ODD (clic sur son
+ * arc ou son chip de légende) ou le seul satellite sélectionné.
+ */
+export type ChildHighlightState = {
+    /** Identité de la cible — sert à ne tirer l'onde de scan qu'une fois par
+     *  mise en valeur, et non à chaque re-rendu. */
+    key: string;
+    color: string;
+    intensity: OddHighlightIntensity;
+    /** Clés (`controller.getKey()`) des satellites mis en valeur. */
+    memberKeys: Set<string>;
+} | null;
+/** Anneau de halo posé sur le bord du satellite membre, dans la couleur de
+ *  l'ODD — la même que celle de son arc dans le cercle central (voir
+ *  YinYangDrawer.refreshHoverArcStyles) — pour que le lien arc ↔ satellites
+ *  se lise sans avoir à le chercher. Deux traits : une lueur large et
+ *  translucide, un trait net par-dessus ; largeurs en fraction du rayon. */
+export declare const HALO_RING: Record<OddHighlightIntensity, {
+    coreWidth: number;
+    glowWidth: number;
+    coreOpacity: number;
+    glowOpacity: number;
+}>;
+/** Satellite dont le menu d'action est ouvert : blanc pur et plus large, pour
+ *  ne pas se confondre avec un membre de l'ODD mis en valeur. */
+export declare const ACTIVE_CHILD_FILTER = "drop-shadow(0 0 12px rgba(255, 255, 255, 0.9)) brightness(1.1)";
+/** Survol direct d'un satellite — aperçu par-dessus tout le reste. */
+export declare const HOVERED_CHILD_FILTER = "brightness(1.3) drop-shadow(0 0 7px rgba(255,255,255,0.4))";
+/** Aucun ODD mis en valeur et satellite ni actif ni survolé. */
+export declare const IDLE_CHILD_FILTER = "brightness(0.85)";
+/** Sans transition, l'extinction des non-membres se lit comme un
+ *  clignotement quand la souris balaye les arcs du cercle central. */
+export declare const CHILD_FILTER_TRANSITION = "filter 0.22s ease-out";
+/**
+ * Groupe sur lequel poser le filtre d'un satellite : son `globalGroup`, et
+ * surtout pas son `yinYangGroup`. Les disques yin/yang — c'est-à-dire le
+ * corps même du satellite — sont créés dans le globalGroup, en frères du
+ * yinYangGroup (voir ViewInitializer.createYinOrYangGroups) : un filtre posé
+ * sur le yinYangGroup n'atteignait presque rien, ce qui rendait toute mise
+ * en valeur invisible quelle que soit son intensité.
+ */
+export declare function getChildFilterTarget(childController: {
+    view: {
+        viewInitializer: {
+            globalGroup: {
+                node: () => unknown;
+            };
+        };
+    };
+}): SVGGElement | null;
+export declare function resolveChildFilter(params: {
+    isMember: boolean;
+    isActiveChild: boolean;
+    /** Satellite atteint par la propagation de l'action en cours. */
+    isPropagationTarget: boolean;
+    highlight: ChildHighlightState;
+}): string;

package/dist/types/components/controller/search/SearchPanelSynchronizer.d.ts

@@ -58,6 +58,12 @@ type SearchPanelSynchronizerDeps = {
     onDiagramNavChange?: (event: DiagramCuttingNavEvent) => void;
     applyEnterOddView: (oddId: string) => void;
     applyOddHighlight: (oddId: string) => void;
+    /** Aperçu de survol d'un ODD, `null` retombant sur l'ODD actif — même
+     *  point d'entrée que le survol d'un arc du diagramme. */
+    previewOddHighlight: (oddId: string | null) => void;
+    /** Repose sur un satellite le filtre imposé par l'état courant, après un
+     *  aperçu de survol qui l'avait écrasé. */
+    refreshChildFilter: (childController: IYinYangController) => void;
     focusChildByOddCutting: (oddId: string, cuttingIndex: number, forceOpen?: boolean) => void;
     focusChildByOddCuttingAndAction: (oddId: string, cuttingIndex: number, actionId: string) => void;
     validateActionSelection: (childController: IYinYangController, actionId: string, label: string, insertAtVisibleIndex?: number | null, entryOrigin?: {
@@ -87,6 +93,9 @@ type SearchPanelSynchronizerDeps = {
 export declare class SearchPanelSynchronizer {
     private deps;
     private searchHoverChildNode;
+    /** Satellite dont l'aperçu de survol est en cours — mémorisé en plus de son
+     *  nœud pour pouvoir lui rendre son filtre d'état à la sortie. */
+    private searchHoverChild;
     constructor(deps: SearchPanelSynchronizerDeps);
     searchHandleComposanteClick(componentIndex: number): void;
     searchNavigateToComponent(componentIndex: number): void;

package/dist/types/components/controller/state/YinYangControllerState.d.ts

@@ -100,6 +100,13 @@ export declare class YinYangControllerState {
         orbitData: ChildrenOrbitEntry[] | null;
         revealStartedAt: number | undefined;
         selectedLinkIndex: number | null;
+        /** Item de pile en focus — persistant, posé par le clic sur l'en-tête
+         *  d'un bloc du panneau de description. Survit à la navigation entre
+         *  satellites et facettes ; effacé quand l'item quitte la pile active. */
+        focusedStackItemId: string | null;
+        /** Aperçu temporaire (survol d'un bloc du panneau ou d'un item de la
+         *  pile) — prime sur le focus tant qu'il dure. */
+        hoveredStackItemId: string | null;
     };
     eventField: {
         targets: EventFieldTarget[];
@@ -122,10 +129,21 @@ export declare class YinYangControllerState {
     resetOrbitAngle(): void;
     clearMenuActiveSelection(): void;
     setMenuActiveChild(childKey: string | null): void;
+    /** Notifié à chaque changement du satellite sélectionné (menu d'action
+     *  ouvert), quel que soit le chemin — le nombre de points d'entrée qui
+     *  posent ou effacent cette sélection rend l'observation plus sûre que
+     *  d'appeler la mise à jour visuelle sur chacun d'eux. */
+    private _onMenuActiveChildChange;
+    setOnMenuActiveChildChange(cb: (childKey: string | null) => void): void;
     setActionSourceChildKey(childKey: string | null): void;
     setMenuActiveAction(actionId: string | null): void;
     setHasActiveChildAction(isActive: boolean): void;
     setForceFieldSourceChildIndex(index: number): void;
+    setFocusedStackItemId(id: string | null): void;
+    setHoveredStackItemId(id: string | null): void;
+    /** Item de pile dont le satellite source porte l'emphase : l'aperçu par
+     *  survol l'emporte, sinon le focus persistant. */
+    getEmphasisStackItemId(): string | null;
     setForceFieldSourceChildIndices(indices: number[]): void;
     setIncomingForceFieldLinks(links: ForceFieldLink[], allDetails: ForceFieldLinkDetail[]): void;
     setForceFieldRandomCount(count: number): void;
@@ -163,6 +181,11 @@ export declare class YinYangControllerState {
     setForceFieldSelectedLinkIndex(index: number | null): void;
     setForceFieldRevealStartedAt(timestamp: number | undefined): void;
     setForceFieldLinksAndDetails(links: ForceFieldLink[], allLinkDetails: ForceFieldLinkDetail[]): void;
+    /** Notifié à chaque recomposition des liens du champ de force — les
+     *  satellites qu'ils touchent échappent à l'extinction appliquée par une
+     *  mise en valeur (voir resolveChildFilter). */
+    private _onForceFieldLinksChange;
+    setOnForceFieldLinksChange(cb: () => void): void;
     setEventFieldTargets(targets: EventFieldTarget[]): void;
     setEventFieldFrameId(frameId: number | undefined): void;
     setEventFieldLastTimestamp(timestamp: number | undefined): void;

package/dist/types/components/view/BorderDrawer.d.ts

@@ -146,9 +146,8 @@ export declare class BorderDrawer {
     /** Lifts the "voile terne" on one facette's image, veiling every other one
      *  — only one can be unveiled at a time. Driven by the outer spark
      *  sweeping across border arcs. Veils *all* others rather than just the
-     *  previously-tracked index, so this also correctly restores the
-     *  single-spotlight invariant the first time it's called after Idle
-     *  (where every image starts unveiled, not just one). */
+     *  previously-tracked index, so the single-spotlight invariant holds
+     *  whatever state the ring was left in. */
     revealFacetteImage(segmentIndex: number): void;
     /** Center + radius (pre-scale coordinate space) of a facette's image
      *  thumbnail, so labels can be anchored onto the image instead of
@@ -172,13 +171,13 @@ export declare class BorderDrawer {
      *  timers D3. */
     activateSegment(segmentIndex: number, immediate?: boolean): void;
     /** Resets all arc segments to inactive style (e.g. when satellites are
-     *  folded) and returns to Idle: every facette image goes back to full
-     *  color, exactly like a fresh load. */
+     *  folded) and returns to Idle: every facette image goes back to black and
+     *  white, exactly like a fresh load. */
     deactivateSegment(): void;
-    /** Restores every facette image to full color — the Idle visual, reached
-     *  both at true init and whenever no facette is currently active (e.g.
-     *  after deselecting one via deactivateSegment). */
-    revealAllFacetteImages(): void;
+    /** Veils every facette image — the Idle visual, reached both at true init
+     *  and whenever no facette is currently active (e.g. after deselecting one
+     *  via deactivateSegment): no arc is active, so no image is in color. */
+    veilAllFacetteImages(): void;
     /**
      * Highlights the source component border arc with a temporary beacon.
      * Used during a component switch when the active action has no visible force field.

package/dist/types/components/view/SpikeDrawer.d.ts

@@ -8,6 +8,13 @@ export declare class SpikeDrawer {
     spikesEnabled: boolean;
     private spikeGhostEntries;
     private spikeGhostFrameId;
+    /** ODD actuellement sélectionné dans le cercle central (clic sur un arc) :
+     *  ses spikes restent énergisés en continu et une comète les remonte.
+     *  Mémorisé parce qu'unhighlightSpikes() est appelé au mouseleave d'un
+     *  satellite et ne doit pas éteindre au passage la sélection en cours. */
+    private oddSpikeHighlight;
+    private oddCometEntries;
+    private oddCometFrameId;
     constructor(ViewInitializer: ViewInitializer);
     /**
      * Initializes the necessary data for drawing spikes.
@@ -57,4 +64,25 @@ export declare class SpikeDrawer {
      * Restores all spikes to their default appearance.
      */
     unhighlightSpikes(): void;
+    /**
+     * Énergise en continu les spikes de l'ODD sélectionné — la ligne de force
+     * qui relie son arc du cercle central à chacun de ses satellites — et
+     * éteint les autres, puis lance les comètes qui les remontent. `oddId` à
+     * null rend leur apparence par défaut à tous les spikes.
+     *
+     * C'est l'effet qui *montre* le rattachement satellite ↔ ODD, là où le
+     * halo posé sur les satellites (voir OddViewManager) ne fait que le
+     * suggérer. Réservé à l'intensité "full" (clic).
+     */
+    setSpikeHighlight(target: {
+        oddId: string;
+        cuttingIndex?: number;
+    } | null, color: string): void;
+    /** Vrai si ce spike fait partie de la mise en valeur courante. */
+    private isHighlightedSpike;
+    private forEachSpikeLine;
+    private applyOddSpikeHighlight;
+    private refreshOddSpikeComets;
+    private ensureOddCometLoop;
+    private clearOddSpikeComets;
 }

package/dist/types/components/view/ViewInitializer.d.ts

@@ -176,7 +176,7 @@ export declare class ViewInitializer {
     /** Exponent (0-1) applied to each facette's weight ratio (its weight over
      *  the heaviest facette's weight) before it scales the thumbnail radius:
      *  radius = baseRadius * weightRatio^curve. 1 = linear (proportional to
-     *  weight, the default, and the strongest shrinkage). Below 1 attenuates
+     *  weight, and the strongest shrinkage). Below 1 attenuates
      *  the falloff — lighter facettes stay closer to full size — down to 0,
      *  where every facette renders at the same full size regardless of weight. */
     facetteImageWeightCurve: number;