@micheeeeel/yinyangapp 3.1.0 → 3.1.1

package/dist/types/adapters/yasuniCauseAdapter.d.ts

@@ -1,6 +1,6 @@
 import type { Composante } from "../data/yasuni_cause";
 import type { Cause } from "../interfaces/ICauseModel";
-import { type ContactProfileData } from "../data/contacts";
+import { type ContactProfileData, type ObstacleSignatureData } from "../data/contacts";
 /**
  * Adapte le catalogue Composante[] (format yasuni_cause.ts) vers le format
  * Cause attendu par mapCauseToInternalModel.
@@ -28,3 +28,14 @@ export declare function getYasuniCause(id?: string): Cause;
  * bornes (`validateContactProfile`).
  */
 export declare function contactProfileToCause(profile: ContactProfileData, id?: string): Cause;
+/**
+ * La `Cause` d'une SIGNATURE D'OBSTACLE (OBS-UI-01) : les huit facettes
+ * universelles d'un contact, chacune pesant son exigence O_f, SANS SCORE
+ * (`scoreless`) — un obstacle n'a pas de qualité. Montée avec
+ * `presentation: true`, elle s'affiche en Idle « facettes » ou « tab »
+ * (satellites-facettes à la taille de O_f) ; `setFacetModulation` y
+ * superpose ensuite la lecture d'un contact. Fraîchement construite à
+ * chaque appel ; lève une erreur explicite pour une signature invalide
+ * (`validateObstacleSignature`).
+ */
+export declare function obstacleSignatureToCause(signature: ObstacleSignatureData, id?: string): Cause;

package/dist/types/api.d.ts

@@ -10,6 +10,8 @@ export { mapCauseToInternalModel } from "./adapters/yinYangAdapter";
 /** Sous-état Idle du diagramme (aucune facette ouverte) — voir
  *  `YinYangMountConfig.idleView`. */
 export type YinYangIdleView = "arcs" | "facettes" | "tab";
+export type { FacetModulation, FacetModulationOptions, } from "./components/controller/children/facetModulation";
+import type { FacetModulation, FacetModulationOptions } from "./components/controller/children/facetModulation";
 /** Données acceptées : soit une `Cause` (format métier), soit le modèle interne déjà adapté. */
 export type YinYangData = Cause | YinYangInternalModel;
 export interface YinYangSvgConfig {
@@ -46,6 +48,15 @@ export interface YinYangMountHandle {
     /** Bascule (animée) du sous-état Idle — voir `YinYangMountConfig.idleView`.
      *  Facette ouverte : le choix s'applique à sa fermeture. */
     setIdleView(view: YinYangIdleView): Promise<void>;
+    /** Signature d'obstacle (`obstacleSignatureToCause`) : y superpose la
+     *  lecture d'un contact, ou la retire (`null`). Pour chaque facette (id) :
+     *  `weights` le poids modulé W_f (0–10, diamètre du satellite), `scores`
+     *  la qualité Q_f du contact (0–100, sa chance affichée). Le diamètre
+     *  d'origine (O_f) reste visible en fantôme ; places et échelle ne
+     *  bougent pas. `durationMs` anime le passage (0 : immédiat),
+     *  `ghostWaves` fait courir la vague du fantôme (à couper en mouvement
+     *  réduit). Une facette de poids nul reste sans score. */
+    setFacetModulation(modulation: FacetModulation | null, options?: FacetModulationOptions): Promise<void>;
     /** Arrête toutes les boucles d'animation du diagramme (champ de force,
      *  orbite, rotation, ghost, étincelles…) puis vide le conteneur. */
     destroy(): void;
@@ -73,10 +84,12 @@ export { createYinYangFilmSvg, createYinYangFilmSvgAsync } from "./api-film";
 export type { YinYangFilmConfig, YinYangFilmAsyncOptions } from "./api-film";
 export { createRandomCause } from "./api-random";
 export type { RandomCauseOptions, RandomRange } from "./api-random";
-export { getYasuniCause, contactProfileToCause } from "./adapters/yasuniCauseAdapter";
+export { getYasuniCause, contactProfileToCause, obstacleSignatureToCause, } from "./adapters/yasuniCauseAdapter";
 export { validateContactProfile } from "./data/contacts/buildContactSphere";
 export type { ContactProfileData, ContactSatelliteValue, } from "./data/contacts/buildContactSphere";
 export { UNIVERSAL_FACETS, CONTACT_CATEGORIES } from "./data/contacts/universalFacets";
+export { contactFacetReadings, obstacleFacetWeight, obstacleModulation, validateObstacleSignature, } from "./data/contacts/obstacleSignature";
+export type { ContactFacetReading, ObstacleSignatureData, } from "./data/contacts/obstacleSignature";
 export type { SatelliteKey, ContactFacetId, ContactCategoryId, UniversalFacet, UniversalSatellite, ContactCategory, } from "./data/contacts/universalFacets";
 export { mountYinYangWorkspace } from "./api-workspace";
 export type { YinYangWorkspaceConfig, YinYangWorkspaceHandle, } from "./api-workspace";

package/dist/types/components/controller/YinYangController.d.ts

@@ -6,6 +6,7 @@ import { IAnimator } from "../../interfaces/IAnimator";
 import { YinYangInternalModel } from "../../interfaces/IYinYangInternalModel";
 import { ForceFieldLinkDetail } from "./force-field/types";
 import { type IdleTabHooks } from "./children/IdleFacettesController";
+import type { FacetModulation, FacetModulationOptions } from "./children/facetModulation";
 import type { IdleView } from "./state/YinYangControllerState";
 import type { DiagramNavEvent } from "./types";
 export declare class YinYangController implements IYinYangController {
@@ -88,6 +89,10 @@ export declare class YinYangController implements IYinYangController {
     /** Clic sur l'illustration centrale : facettes ↔ tab (sans effet hors Idle
      *  et en « arcs »). */
     toggleIdleView(): Promise<void>;
+    /** Superpose (ou retire, `null`) la lecture d'un contact à une
+     *  signature d'obstacle (OBS-UI-01) — voir
+     *  IdleFacettesController.setModulation. */
+    setFacetModulation(modulation: FacetModulation | null, options?: FacetModulationOptions): Promise<void>;
     /** Vrai quand le sous-état Idle « facettes » est visé (arcs repliés). */
     isIdleFacettesActive(): boolean;
     /** Réaligne le sous-état Idle après une entrée/sortie d'Idle. */

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

@@ -9,6 +9,8 @@ import { StackFocusController } from "../action-stack/StackFocusController";
 import { ComponentTitlePresenter } from "../labels/ComponentTitlePresenter";
 import type { ControllerUiCallbacks } from "../state/ControllerUiCallbacks";
 import { ChildrenOrbitManager } from "../odd/ChildrenOrbitManager";
+/** Écart (px, repère du motif) entre deux satellites voisins d'un anneau. */
+export declare const SATELLITE_RING_GAP_PX = 6;
 export type ChildrenBuilderDeps = {
     animateChildren: (show: boolean) => Promise<void>;
     applyChildrenOrbitTransforms: (angleOffset: number, orbitData?: ChildrenOrbitEntry[]) => void;
@@ -58,28 +60,21 @@ export declare class ChildrenBuilder {
      *  baseline radius, independent of any satellite's own weight-scaled
      *  radius — mirrors ChildActionMenuController's action cluster geometry. */
     private getChildActionClusterReach;
-    /** Décalage constant appliqué au poids ET à sa moyenne avant de calculer le
-     *  ratio de taille d'un satellite (voir weightToSizeRatio) : resserre la
-     *  fourchette de tailles (poids min moins minuscule, poids max un peu
-     *  moins dominant) sans changer la taille d'un satellite au poids moyen
-     *  exact (ratio toujours 1 dans ce cas), et sans dépendre du poids moyen
-     *  de la fratrie pour l'ampleur du resserrement. */
-    private static readonly WEIGHT_SIZE_FLOOR_OFFSET;
-    /** Ratio de taille d'un satellite (rayon relatif à la baseline uniforme de
-     *  sa facette) à partir de son poids et du poids moyen de sa fratrie —
-     *  voir WEIGHT_SIZE_FLOOR_OFFSET pour le resserrement. */
-    static weightToSizeRatio(weight: number, averageWeight: number): number;
-    /** Ratio of a component's heaviest satellite radius to its own uniform
-     *  baseline radius. Mirrors the per-cutting weight-based scaling applied
-     *  in createYinYangChildren(). */
-    private getMaxWeightRatio;
-    /** The container-fit shrink ratio only depends on borderOuterRadius/
-     *  smallCircleRadius/distanceFromChild, which are fixed for the whole
-     *  session once this top-level view is first initialized (they don't get
-     *  recomputed on facette switch) — so this is computed once (on the worst
-     *  case weight ratio across every facette) and cached. That's what keeps
-     *  the whole diagram's size from visibly changing every time the user
-     *  switches facette. */
+    /** Ratio de taille d'un satellite (rayon relatif à la taille de base,
+     *  ViewInitializer.smallCircleRadius) : sur son poids ABSOLU, le même pour
+     *  la cause et pour la sphère d'un personnage — un satellite de poids 7 a
+     *  la même taille dans tous les diagrammes, quels que soient ses voisins.
+     *  `(poids + 1) / (référence + 1)` : 1 au poids de référence (5), 1/6 au
+     *  poids nul (un satellite vide reste visible), 11/6 au poids maximal. */
+    static weightToSizeRatio(weight: number): number;
+    /** Ratio de taille du satellite le plus lourd possible (poids maximal). */
+    static readonly MAX_SIZE_RATIO: number;
+    /** Réduction d'ensemble qui fait tenir l'anneau de satellites dans le
+     *  conteneur. Elle ne dépend que de la géométrie du motif (rayon, taille
+     *  de base, orbite), pas des données : elle réserve la place du satellite
+     *  le plus lourd possible, si bien que le cercle central occupe la même
+     *  part du conteneur dans tous les diagrammes, et qu'aucune évolution des
+     *  poids en cours de partie ne fait déborder l'anneau. Calculée une fois. */
     private cachedGlobalFitShrinkRatio?;
     private computeGlobalFitShrinkRatio;
     applyChildrenFitScale(): void;

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

@@ -3,6 +3,7 @@ import { IYinYangController } from "../../../interfaces/IYinYangController";
 import { IYinYangAppFactory } from "../../../interfaces/IYinYangAppFactory";
 import { YinYangInternalModel } from "../../../interfaces/IYinYangInternalModel";
 import { IdleView, YinYangControllerState } from "../state/YinYangControllerState";
+import { FacetModulation, FacetModulationOptions } from "./facetModulation";
 /** Crochets de l'hôte autour du sous-état « tab » — voir
  *  `IYinYangController.setIdleTabHooks`. */
 export type IdleTabHooks = {
@@ -76,13 +77,31 @@ export declare class IdleFacettesController {
     private settled;
     private queue;
     private escapeListener;
+    /** Modulation de la signature par un contact (OBS-UI-01), voir
+     *  setModulation ; null : chaque satellite montre son propre modèle. */
+    private modulation;
+    private modulationOptions;
+    /** Géométrie radiale de l'anneau, calculée à la sortie sur les poids du
+     *  MODÈLE (O_f d'une signature) : la modulation change les tailles,
+     *  jamais les places ni l'échelle. */
+    private ring;
+    /** Par satellite : clé de son affichage, son diamètre au poids du modèle
+     *  et son diamètre réel (modulé). */
+    private displays;
+    /** Fantôme de signature de chaque satellite modulé (dans son enveloppe). */
+    private ghosts;
+    /** Détruit : les transitions encore en file n'ont plus rien à faire (sans
+     *  quoi un diagramme démonté puis remonté dans le même conteneur — double
+     *  montage d'un hôte React en développement — y recevait les satellites
+     *  du premier, sortis après coup). */
+    private destroyed;
     constructor(deps: IdleFacettesControllerDeps);
     setTabHooks(hooks: IdleTabHooks | null): void;
     getView(): IdleView;
     /** Vrai dès qu'un sous-état à satellites-facettes (« facettes » ou
      *  « tab ») est l'état visé en Idle (arcs repliés ou en train de l'être). */
     isActive(): boolean;
-    setView(view: IdleView): Promise<void>;
+    setView(requested: IdleView): Promise<void>;
     /** Centre et rayon du satellite-facette d'une facette, une fois sorti. */
     getSatelliteAnchor(componentId: string): {
         center: {
@@ -96,6 +115,21 @@ export declare class IdleFacettesController {
      *  chaque entrée/sortie d'Idle. */
     sync(): Promise<void>;
     private isIdle;
+    /** Vrai pour une Cause sans score (signature d'obstacle). */
+    private isScorelessModel;
+    /**
+     * Superpose à la signature la lecture d'un contact (OBS-UI-01) — ou la
+     * retire (`null`). Chaque satellite-facette concerné prend le diamètre de
+     * W_f et la chance Q_f, à partir de sa taille courante (animation de
+     * `durationMs`) ; un fantôme garde le diamètre du poids du modèle (O_f).
+     * Les places et l'échelle restent celles du modèle : revenir à la
+     * signature puis réappliquer le même contact redonne exactement le même
+     * dessin. Appliquée en file avec les bascules de sous-état ; hors
+     * « facettes »/« tab », elle est mémorisée pour la prochaine sortie.
+     */
+    setModulation(modulation: FacetModulation | null, options?: FacetModulationOptions): Promise<void>;
+    private applyModulation;
+    private displayOf;
     private wantedLayout;
     private applyDesiredState;
     /** Arcs repliés sous l'illustration, puis satellites jaillissant du centre
@@ -127,8 +161,28 @@ export declare class IdleFacettesController {
      *  SVG). */
     private tabArea;
     private fadeImageRing;
+    /** Ratio de taille de chaque satellite-facette : sur le poids de sa
+     *  facette (C_f), ramené à l'échelle d'un satellite [0, WEIGHT_MAX] — tel
+     *  quel en règle `mean`, divisé par le nombre de satellites en règle `sum`
+     *  — pour la même règle de taille que les satellites d'une Facette. */
     private computeSizeRatios;
     private createSatellites;
+    /** Angles et resserrement de l'anneau, sur les poids du modèle. */
+    private computeRing;
+    /** Crée le satellite-facette d'une composante, à sa place dans l'anneau,
+     *  selon son affichage (ordinaire, signature, modulé). */
+    private createSatellite;
+    /**
+     * Remplace un satellite-facette par celui de son nouvel affichage, SUR
+     * PLACE : même enveloppe de grille, même centre. Le nouveau part de la
+     * taille de l'ancien et gagne la sienne (O_f → W_f, ou retour) pendant
+     * que l'ancien s'efface ; sans durée, d'un coup.
+     */
+    private replaceSatellite;
+    /** Fantôme de signature d'un satellite modulé plus petit que son poids
+     *  de modèle : contour au diamètre de O_f, dans son enveloppe (il suit la
+     *  grille). Retiré sinon. */
+    private refreshGhost;
     /** Glisse un groupe enveloppe entre le satellite et le groupe des enfants
      *  du motif : il porte la transformation de la grille, sans interférer
      *  avec celles que d'autres posent sur le satellite lui-même. */

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

@@ -0,0 +1,49 @@
+import { YinYangComponentNode } from "../../../interfaces/IYinYangInternalModel";
+/**
+ * MODULATION d'une signature par un contact (OBS-UI-01) : pour chaque
+ * facette (id de composante), le poids W_f que la signature prend face à ce
+ * contact (0–10) et la qualité Q_f du contact (0–100), sa chance de
+ * réussir cette facette. L'hôte fournit les valeurs : la lib ne fait que
+ * les montrer (diamètre sur W_f, pourcentage Q_f, fantôme sur le poids du
+ * modèle, O_f).
+ */
+export type FacetModulation = {
+    weights: Record<string, number>;
+    scores: Record<string, number>;
+};
+export type FacetModulationOptions = {
+    /** Durée de l'animation des diamètres (ms) ; 0 : immédiat (défaut). */
+    durationMs?: number;
+    /** Vague entre satellite et fantôme ; à couper en mouvement réduit.
+     *  Défaut : false. */
+    ghostWaves?: boolean;
+};
+/** Ce qu'un satellite-facette montre. */
+export type FacetDisplay = 
+/** Ses propres score et poids (diagramme ordinaire). */
+{
+    kind: "ordinary";
+}
+/** Poids seul, sans score (signature d'obstacle). */
+ | {
+    kind: "signature";
+}
+/** Poids modulé W_f et qualité Q_f d'un contact. */
+ | {
+    kind: "modulated";
+    weight: number;
+    quality: number;
+};
+/** Poids d'une facette du modèle (O_f pour une signature, C_f sinon). */
+export declare function componentWeight(component: YinYangComponentNode): number;
+/**
+ * Affichage d'une facette. Une facette sans exigence (poids nul) d'une
+ * signature reste sans score même modulée : W_f y est nul, elle n'entre
+ * dans aucun tirage — lui montrer une chance serait faux.
+ */
+export declare function resolveFacetDisplay(component: YinYangComponentNode, scoreless: boolean, modulation: FacetModulation | null): FacetDisplay;
+/** Clé d'égalité d'un affichage (un satellite inchangé n'est pas refait). */
+export declare function facetDisplayKey(display: FacetDisplay): string;
+/** La facette portant la qualité Q_f d'un contact : tous ses satellites
+ *  à la même tension, si bien que sa qualité (moyenne pondérée) vaut Q_f. */
+export declare function withQuality(component: YinYangComponentNode, quality: number): YinYangComponentNode;

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

@@ -0,0 +1,10 @@
+import { IYinYangController } from "../../../interfaces/IYinYangController";
+/**
+ * Apparence d'un satellite-facette SANS SCORE (signature d'obstacle,
+ * OBS-UI-01) : un disque neutre, liseré de la couleur de sa catégorie, et
+ * sa pastille de poids — ni lobes yin/yang ni pourcentage, puisqu'un
+ * obstacle n'a pas de qualité. Le marquage `data-scoreless` tait le reste
+ * (styles/signature.css) ; le disque est posé dans le cœur, qui porte
+ * aussi l'animation de sortie du satellite.
+ */
+export declare function applyScorelessLook(satellite: IYinYangController): void;

package/dist/types/components/controller/labels/WeightPreviewRingRenderer.d.ts

@@ -18,6 +18,11 @@ export declare class WeightPreviewRingRenderer {
     private basePulseEnabled;
     private pulseDurationMs;
     private pulseMorphRatio;
+    /** Fantôme en contour seul (signature, voir renderFixed) plutôt qu'en
+     *  lavis quand il est plus grand que le satellite. */
+    private outlineOnly;
+    /** Vague entre le satellite et son fantôme (coupée en mouvement réduit). */
+    private wavesEnabled;
     private getChildRenderedCenter;
     render(params: {
         orbitData: ChildrenOrbitEntry[];
@@ -41,6 +46,28 @@ export declare class WeightPreviewRingRenderer {
         pulseDurationMs: number;
         pulseMorphRatio: number;
     }): void;
+    /**
+     * Fantôme de SIGNATURE (OBS-UI-01, satellites-facettes d'une signature
+     * d'obstacle modulée par un contact) : le même cercle d'or et la même
+     * vague que l'aperçu de poids, mais sur des rayons fournis par l'appelant
+     * — le satellite a déjà sa taille modulée (`baseRadius`), le fantôme garde
+     * celle de la signature (`targetRadius`). Contour seul (une trace de
+     * l'exigence, pas un gain), sans pulsation du satellite : sa taille est
+     * celle de la modulation, l'animer la rendrait fausse. `waves: false`
+     * (mouvement réduit) laisse le fantôme immobile, même information.
+     */
+    renderFixed(params: {
+        groupNode: SVGGElement | null;
+        entries: Array<{
+            id: string;
+            controller: IYinYangController;
+            centerX: number;
+            centerY: number;
+            baseRadius: number;
+            targetRadius: number;
+        }>;
+        waves: boolean;
+    }): void;
     /** Frame d'orbite : recentre fantômes et vagues sur leur satellite (les
      *  entrées sont les données liées aux cercles), sans data join. */
     followOrbit(): void;

package/dist/types/components/controls/ObstacleDemoControl.d.ts

@@ -0,0 +1,3 @@
+import type { YinYangController } from "../controller/YinYangController";
+/** Câble le groupe #debug-obstacle-group (affiché pour l'obstacle seul). */
+export declare function mountObstacleDemoControl(controller: YinYangController): void;