@micheeeeel/yinyangapp 1.0.6 → 2.0.0

package/dist/bundle.js.LICENSE.txt

@@ -0,0 +1 @@
+/*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/babel/babel/blob/main/packages/babel-helpers/LICENSE */

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

@@ -0,0 +1,10 @@
+import { YinYangComponentNode, YinYangInternalModel, YinYangOddNode } from "../interfaces/IYinYangInternalModel";
+import { Cause } from "../interfaces/ICauseModel";
+export declare function mapCauseToInternalModel(cause: Cause): YinYangInternalModel;
+/**
+ * Builds a single-component, single-odd, single-cutting internal model for a
+ * satellite child, preserving the parent odd's orientation/labels so the
+ * child renders identically to its parent component instead of falling back
+ * to legacy defaults.
+ */
+export declare function buildChildCuttingInternalModel(component: YinYangComponentNode, odd: YinYangOddNode, cuttingIndex: number, cuttingScore: number): YinYangInternalModel;

package/dist/types/animations/AnimationsMngr.d.ts

@@ -1,26 +1,14 @@
 import { IYinYangController } from "../interfaces/IYinYangController";
 export declare class AnimationsMngr {
-    private subscribers;
-    constructor();
-    /**
-     * Subscribes a component (YinYangController) to the animation manager.
-     * Each component will have a specified rotation direction and duration.
-     */
+    private subscriberMap;
     subscribe(component: IYinYangController, clockWise?: boolean, time?: number): void;
-    /**
-     * Starts the animations for all subscribed components.
-     * Each component will rotate based on the specified direction and duration.
-     */
     startAll(): void;
-    /**
-     * Reverts the rotation direction of a specific component and re-applies the animation.
-     * This will interrupt any ongoing animations and start a new one with the opposite direction.
-     */
+    setRotationDuration(durationMs: number): void;
     revertRotation(component: IYinYangController): void;
-    /**
-     * Animates the specified component (YinYangController) with a rotation.
-     * The rotation applies to the entire group with the center of the large circle as the pivot.
-     * It also applies individual translations and rotations to the Yin and Yang parts.
-     */
+    stopRotation(component: IYinYangController): void;
+    private resetRotationFrame;
     animate(component: IYinYangController, clockWise: boolean, time?: number): void;
+    private startRotationLoop;
+    private applyRotationFrame;
+    private applyRotationToYinYangGroup;
 }

package/dist/types/api-film.d.ts

@@ -0,0 +1,22 @@
+import type { YinYangData } from "./api";
+export interface YinYangFilmConfig {
+    data: YinYangData;
+    /** Côté du SVG produit (px). */
+    size: number;
+    /** Durée d'un tour complet de l'étincelle. Défaut : 7000 ms. Surchargeable
+     *  sans recuire via la variable CSS `--yy-rotation` sur le <svg> (ex. "9s"). */
+    rotationDurationMs?: number;
+    /** Durée réelle d'une bascule de composante. Défaut : animationConfig. */
+    switchDurationMs?: number;
+    /** Images échantillonnées par bascule (0 = switch immédiat). Défaut : 4. */
+    transitionFrames?: number;
+    spark?: {
+        color?: string;
+        strokeWidth?: number;
+        lengthRatio?: number;
+    };
+    /** Retire les <text> (titres) — inutiles à petite taille. Défaut : true. */
+    stripText?: boolean;
+}
+/** Cuit un tour complet et renvoie un <svg> autonome (keyframes inlinées). */
+export declare function createYinYangFilmSvg(config: YinYangFilmConfig): SVGSVGElement;

package/dist/types/api.d.ts

@@ -0,0 +1,48 @@
+import type { IViewData } from "./interfaces/IViewData";
+import type { IYinYangController } from "./interfaces/IYinYangController";
+import type { YinYangInternalModel } from "./interfaces/IYinYangInternalModel";
+import type { Cause } from "./interfaces/ICauseModel";
+export type { IViewData } from "./interfaces/IViewData";
+export type { IYinYangController } from "./interfaces/IYinYangController";
+export type { Cause, CauseComponent, CauseOdd, CauseOddCutting, } from "./interfaces/ICauseModel";
+export type { YinYangInternalModel, YinYangComponentNode, YinYangOddNode, YinYangCuttingNode, YinYangCategorySlice, YinYangOrientation, } from "./interfaces/IYinYangInternalModel";
+export { mapCauseToInternalModel } from "./adapters/yinYangAdapter";
+/** 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 {
+    data: YinYangData;
+    /** `containerId` est optionnel : un id unique est généré si absent. */
+    viewData: Partial<Omit<IViewData, "minEdge">> & {
+        minEdge: number;
+    };
+    /** Crée aussi les satellites (facettes). Défaut : true. */
+    includeChildren?: boolean;
+}
+export interface YinYangMountConfig {
+    data: YinYangData;
+    /** Élément DOM (ou son id) déjà présent dans la page, dimensionné par l'hôte. */
+    container: HTMLElement | string;
+    /** Défaut : min(largeur, hauteur) du conteneur. */
+    minEdge?: number;
+    borderAnimationDuration?: number;
+    includeChildren?: boolean;
+}
+export interface YinYangMountHandle {
+    controller: IYinYangController;
+    /** Vide le conteneur. */
+    destroy(): void;
+}
+/**
+ * Monte un diagramme vivant (interactif) dans un conteneur fourni par l'hôte.
+ * À appeler côté client uniquement (accès au DOM).
+ */
+export declare function mountYinYang(config: YinYangMountConfig): YinYangMountHandle;
+/**
+ * Rend un diagramme hors écran et renvoie un clone détaché du `<svg>` produit,
+ * que l'hôte injecte où il veut (ex. `ref.current.appendChild(svg)` en React).
+ */
+export declare function createYinYangSvg(config: YinYangSvgConfig): SVGSVGElement | null;
+/** Variante en lot : une seule zone hors écran pour tous les rendus. */
+export declare function createYinYangSvgs(configs: YinYangSvgConfig[]): (SVGSVGElement | null)[];
+export { createYinYangFilmSvg } from "./api-film";
+export type { YinYangFilmConfig } from "./api-film";

package/dist/types/benchmark/runner.d.ts

@@ -0,0 +1,5 @@
+declare global {
+    var runBenchmark: () => Promise<void>;
+    var runBenchmarkAvg: (n: number) => Promise<void>;
+}
+export {};

package/dist/types/benchmark/scenarios.d.ts

@@ -0,0 +1,118 @@
+/**
+ * Scenario 1 — Large dataset initialization.
+ *
+ * Creates a full Yasuni instance (6 composantes, ~30 ODDs, ~120 cuttings) and
+ * renders all orbit children via the real factory/controller pipeline.
+ * Measures the synchronous initialization cost: SVG group creation, arc
+ * geometry, gradient/mask defs, and the full children orbit setup.
+ *
+ * Performance measure name: "bm-large"
+ */
+export declare function runLargeDatasetScenario(): Promise<void>;
+export interface ComponentSwitchHooks {
+    onSwitchStart?: () => void;
+    onSwitchEnd?: () => void;
+}
+export interface ForceFieldHooks {
+    onSteadyStateStart?: () => void;
+    onSteadyStateEnd?: () => void;
+}
+/**
+ * Scenario 2 — Component switch animation.
+ *
+ * Navigates sequentially through all 6 Yasuni composantes via
+ * searchNavigateToComponent(), letting each 800 ms animation complete before
+ * triggering the next. Measures the cumulative per-frame cost of arc-geometry
+ * recalculation and RGB colour interpolation across a full cycle.
+ *
+ * hooks.onSwitchStart / onSwitchEnd fire around each 800 ms animation window
+ * (not the 100 ms inter-switch buffer), allowing the caller to measure FPS
+ * only during active animation rather than idle sleep time.
+ *
+ * Performance measure name: "bm-switch"
+ */
+export declare function runComponentSwitchScenario(hooks?: ComponentSwitchHooks): Promise<void>;
+/**
+ * Scenario 3 — Rotation animation.
+ *
+ * Starts the continuous rotation animation (AnimationsMngr RAF loop) on a
+ * full Yasuni instance including orbit children, and lets it run for
+ * TRANSITION_DURATION_MS. Measures per-frame cost: Yin/Yang orbital math,
+ * SVG transform updates for parent + all children.
+ *
+ * Performance measure name: "bm-transition"
+ */
+export declare function runTransitionScenario(): Promise<void>;
+export interface BaselineHooks {
+    onMeasureStart?: () => void;
+    onMeasureEnd?: () => void;
+}
+/**
+ * Scenario — Baseline (pivot).
+ *
+ * Controller + satellites en état idle : aucune action activée, aucune rotation,
+ * aucun champ de force. Seuls les RAF loops systèmes tournent en arrière-plan
+ * (ghost pulse, outer spark, cycle couleurs de bordure).
+ *
+ * Sert de référence directe pour quantifier le surcoût de chaque autre scénario :
+ * (forceField.avgFps - baseline.avgFps) = coût pur du champ de force.
+ *
+ * Performance measure name: "bm-baseline"
+ */
+export declare function runBaselineScenario(hooks?: BaselineHooks): Promise<void>;
+/**
+ * Scenario 4 — forceFieldNav : activation via la pile de navigation complète.
+ *
+ * Appelle searchNavigateToAction(0, "ODD_15", 0, "gen_bhf_moratoire_infra").
+ * Cette voie active le champ de force ET les panneaux UI (menu d'action, panneau
+ * cutting/action detail) qui ont leurs propres cycles d'animation. setupMs mesure
+ * donc la navigation + build() + ensureElements(), pas le build() seul.
+ *
+ * Scénario "production" : reflète le coût réel ressenti par l'utilisateur.
+ * Comparer avgFrameMsVsBaseline avec forceFieldDirect pour isoler le surcoût
+ * des panneaux UI par rapport au champ de force seul.
+ *
+ * Performance measure names: "bm-forcefield-nav-setup", "bm-forcefield-nav"
+ */
+export declare function runForceFieldNavScenario(hooks?: ForceFieldHooks): Promise<void>;
+/**
+ * Scenario 5 — forceFieldDirect : activation directe, source unique, sans UI.
+ *
+ * Appelle activateForceFieldMultiSource([ODD_15/cut0]) directement, sans passer
+ * par la pile de navigation. Aucun panneau de détail, aucun menu d'action :
+ * seul le RAF loop du champ de force est actif pendant la mesure steady-state.
+ *
+ * Référence pure : avgFrameMsVsBaseline mesure uniquement le coût du pipeline
+ * de rendu (pulse, dashoffset, gradient cache) — sans le bruit des animations UI.
+ * setupMs = 1× build() + ensureElements() + premier updateVisual().
+ *
+ * Comparer avec forceFieldNav pour isoler le surcoût des panneaux UI.
+ * Comparer avec forceFieldMerged pour mesurer le coût marginal des 2 sources
+ * supplémentaires après fusion.
+ *
+ * Performance measure names: "bm-forcefield-direct-setup", "bm-forcefield-direct"
+ */
+export declare function runForceFieldDirectScenario(hooks?: ForceFieldHooks): Promise<void>;
+/**
+ * Scenario 6 — forceFieldMerged : 3 sources simultanées, activation directe.
+ *
+ * Appelle activateForceFieldMultiSource() avec 3 sources sur composante 0 :
+ *   - ODD_15 cut0 (Corridors brisés)
+ *   - ODD_6  cut0 (Pipelines qui fuient dans les rivières)
+ *   - ODD_3  cut0 (Maladies de peau en hausse)
+ *
+ * Même voie d'activation que forceFieldDirect (sans panneaux UI), mais 3× sources.
+ * Les liens cross-composante des 3 sources partagent le même targetComponentId
+ * → _computeMergedSegments() les fusionne : N×3 layer groups → N par composante
+ * externe, réduisant les passes GPU drop-shadow proportionnellement.
+ *
+ * setupMs   = 3× build() + ensureElements(N fusionnés) + premier updateVisual().
+ * duration  = régime établi (3 s), directement comparable à forceFieldDirect.
+ *
+ * Comparaison clé : forceFieldMerged.avgFrameMsVsBaseline vs forceFieldDirect.avgFrameMsVsBaseline
+ * = coût marginal réel des 2 sources supplémentaires après fusion des segments.
+ * Si les deux valeurs sont proches → la fusion absorbe le surcoût des sources additionnelles.
+ *
+ * Performance measure names: "bm-forcefield-merged-setup", "bm-forcefield-merged"
+ */
+export declare function runForceFieldMergedScenario(hooks?: ForceFieldHooks): Promise<void>;

package/dist/types/components/action-image/ActionImageModal.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Popup plein écran affichant la version Full (HD) d'une vignette de carte.
+ * Singleton monté une fois : un seul <img> réutilisé (src remplacé à
+ * chaque ouverture) pour ne jamais garder plus d'une image HD en mémoire.
+ *
+ * Ouverture par délégation d'événements sur `document` : toute vignette
+ * ajoutée après coup (re-render innerHTML) est cliquable sans re-binding.
+ *
+ * Deux contrats reconnus, résolus par _resolveZoomTarget :
+ *  - `.action-thumb[data-action-id]` — vignette d'action, dont le Full et le
+ *    libellé se déduisent du catalogue ;
+ *  - `[data-full-src]` (+ `data-caption`) — contrat neutre pour tout ce qui
+ *    n'est pas une action et porte donc sa propre image : carte Événement
+ *    Clé aujourd'hui (voir ForceFieldDetailsPanel.buildKeyEventCardHtml), un
+ *    autre type de carte demain, sans rien changer ici.
+ */
+export declare class ActionImageModal {
+    private readonly overlayEl;
+    private readonly imgEl;
+    private readonly captionEl;
+    private isOpen;
+    private readonly _preloaded;
+    private _outsideClickHandler;
+    private _keyHandler;
+    private _dragState;
+    constructor();
+    /** Vignette cliquable la plus proche de `el`, résolue en (Full, légende). */
+    private _resolveZoomTarget;
+    private _bindGlobalListeners;
+    /**
+     * Certaines cartes superposent leurs liens de propagation (.ff-card-steps)
+     * en surimpression de la vignette, dans un bandeau ancré en bas et scrollable
+     * (.ff-card-steps-overlay) — voir ForceFieldDetailsPanel._renderChainCardHtml.
+     * Comme ce bandeau couvre toute l'image, il faut distinguer soi-même un clic
+     * (ouvrir la popup HD) d'un glissé (faire défiler les liens par-dessus l'image) :
+     * un clic natif sur ce calque n'atteint jamais l'<img> qu'il recouvre.
+     */
+    private _bindCardStepsOverlayDrag;
+    private _preloadFull;
+    open(fullSrc: string, caption: string): void;
+    close(): void;
+}