@rsuci/shared-form-components 1.0.15 → 1.0.16

package/dist/components/GroupRenderer.d.ts

@@ -1,14 +1,22 @@
 /**
  * Composant de rendu des groupes pour les formulaires d'enquête
  * RSU v2 - Moteur de Rendu des Formulaires d'Enquête
+ *
+ * Supporte deux modes:
+ * 1. Mode FormTree (nouveau): Utilise le FormTree pour la gestion centralisée de visibilité et jumps
+ * 2. Mode ConditionEngine (legacy): Utilise le ConditionEngine directement
  */
 import React from 'react';
 import { GroupeFormulaire, EnqueteReponse, VariableValue, ValidationError, AutoAction } from '../types/enquete';
 import { ConditionEngine } from '../lib/condition-engine';
+import { FormTree } from '../lib/form-tree';
 interface GroupRendererProps {
     groupe: GroupeFormulaire;
     responses: Record<string, EnqueteReponse>;
-    conditionEngine: ConditionEngine;
+    /** @deprecated Utiliser formTree à la place */
+    conditionEngine?: ConditionEngine;
+    /** Nouveau: FormTree pour gestion centralisée (recommandé) */
+    formTree?: FormTree;
     onChange: (variableCode: string, value: VariableValue, iteration?: number) => void;
     onValidation: (errors: ValidationError[]) => void;
     onAutoAction?: (actions: AutoAction[]) => void;

package/dist/components/GroupRenderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GroupRenderer.d.ts","sourceRoot":"","sources":["../../src/components/GroupRenderer.tsx"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,KAA8B,MAAM,OAAO,CAAC;AAEnD,OAAO,EACL,gBAAgB,EAChB,cAAc,EACd,aAAa,EACb,eAAe,EACf,UAAU,EACX,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAG1D,UAAU,kBAAkB;IAC1B,MAAM,EAAE,gBAAgB,CAAC;IACzB,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;IAC1C,eAAe,EAAE,eAAe,CAAC;IACjC,QAAQ,EAAE,CAAC,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,EAAE,SAAS,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IACnF,YAAY,EAAE,CAAC,MAAM,EAAE,eAAe,EAAE,KAAK,IAAI,CAAC;IAClD,YAAY,CAAC,EAAE,CAAC,OAAO,EAAE,UAAU,EAAE,KAAK,IAAI,CAAC;IAC/C,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAiJD,QAAA,MAAM,aAAa,EAAE,KAAK,CAAC,EAAE,CAAC,kBAAkB,CAkS/C,CAAC;AAEF,eAAe,aAAa,CAAC"}
+{"version":3,"file":"GroupRenderer.d.ts","sourceRoot":"","sources":["../../src/components/GroupRenderer.tsx"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,KAAuC,MAAM,OAAO,CAAC;AAE5D,OAAO,EACL,gBAAgB,EAChB,cAAc,EACd,aAAa,EACb,eAAe,EACf,UAAU,EAEX,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC1D,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAG5C,UAAU,kBAAkB;IAC1B,MAAM,EAAE,gBAAgB,CAAC;IACzB,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;IAC1C,+CAA+C;IAC/C,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,8DAA8D;IAC9D,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,QAAQ,EAAE,CAAC,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,EAAE,SAAS,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IACnF,YAAY,EAAE,CAAC,MAAM,EAAE,eAAe,EAAE,KAAK,IAAI,CAAC;IAClD,YAAY,CAAC,EAAE,CAAC,OAAO,EAAE,UAAU,EAAE,KAAK,IAAI,CAAC;IAC/C,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAsID,QAAA,MAAM,aAAa,EAAE,KAAK,CAAC,EAAE,CAAC,kBAAkB,CAmU/C,CAAC;AAEF,eAAe,aAAa,CAAC"}

package/dist/components/GroupRenderer.js

@@ -1,10 +1,14 @@
 /**
  * Composant de rendu des groupes pour les formulaires d'enquête
  * RSU v2 - Moteur de Rendu des Formulaires d'Enquête
+ *
+ * Supporte deux modes:
+ * 1. Mode FormTree (nouveau): Utilise le FormTree pour la gestion centralisée de visibilité et jumps
+ * 2. Mode ConditionEngine (legacy): Utilise le ConditionEngine directement
  */
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useState, useEffect } from 'react';
+import { useState, useEffect, useMemo } from 'react';
 import { Plus, Trash2, Users, AlertCircle } from 'lucide-react';
 import VariableRenderer from './VariableRenderer';
 // Composant pour gérer les groupes multiples
@@ -25,23 +29,22 @@ const MultipleGroupEntry = ({ groupe, iterationNumber, totalIterations, visibleV
                     const rosterVariables = (variable.typeCode === 'ROSTERCHECK' || variable.typeCode === 'ROSTERLIST')
                         ? variable.rosterVariables
                         : undefined;
-                    // 🔍 LOG: Vérifier la transmission des rosterVariables dans MultipleGroupEntry
-                    if (variable.typeCode === 'ROSTERCHECK' || variable.typeCode === 'ROSTERLIST') {
-                        console.log(`🔍 [GroupRenderer/MultipleGroupEntry] Variable ${variable.code}:`, {
-                            typeCode: variable.typeCode,
-                            rosterVariables: rosterVariables,
-                            rosterVariablesType: typeof rosterVariables,
-                            isArray: Array.isArray(rosterVariables),
-                            length: Array.isArray(rosterVariables) ? rosterVariables.length : 'N/A'
-                        });
-                    }
                     return (_jsx(VariableRenderer, { variable: variable, value: responses[responseKey]?.valeur, onChange: (value) => onChange(responseKey, value, iterationNumber), numeroMembre: iterationNumber, disabled: disabled, rosterVariables: rosterVariables }, responseKey));
                 }) })] }));
 };
 // Composant principal GroupRenderer
-const GroupRenderer = ({ groupe, responses, conditionEngine, onChange, onValidation, onAutoAction, disabled = false }) => {
+const GroupRenderer = ({ groupe, responses, conditionEngine, formTree, onChange, onValidation, onAutoAction, disabled = false }) => {
     const [multipleEntries, setMultipleEntries] = useState([1]);
     const [validationErrors, setValidationErrors] = useState([]);
+    // Déterminer le mode d'utilisation
+    const useFormTreeMode = !!formTree;
+    // Obtenir le ConditionEngine (depuis formTree ou directement)
+    const engine = useMemo(() => {
+        if (formTree) {
+            return formTree.getConditionEngine();
+        }
+        return conditionEngine;
+    }, [formTree, conditionEngine]);
     // Obtenir le nombre d'itérations depuis la variable de contrôle
     const getIterationCount = () => {
         if (!groupe.estMultiple || !groupe.configMultiple?.variableControle) {
@@ -53,26 +56,25 @@ const GroupRenderer = ({ groupe, responses, conditionEngine, onChange, onValidat
         }
         return Math.min(controlValue, groupe.configMultiple.maxIterations || 50);
     };
-    // Filtrer les variables visibles selon les conditions (avec support des nouvelles fonctions)
-    const getVisibleVariables = () => {
-        console.log('📋 [GroupRenderer] Filtering visible variables for group:', groupe.designation);
+    // Filtrer les variables visibles selon les conditions
+    const visibleVariables = useMemo(() => {
+        // Mode FormTree: utiliser directement getVisibleVariables
+        if (useFormTreeMode && formTree) {
+            return formTree.getVisibleVariables(groupe.code);
+        }
+        // Mode Legacy: filtrage manuel avec ConditionEngine
+        if (!engine) {
+            return groupe.variables.filter(v => v.estVisible);
+        }
         return groupe.variables.filter(variable => {
-            console.log(`📋 [GroupRenderer] Processing variable: ${variable.code} (${variable.designation})`);
-            console.log(`📋 [GroupRenderer] - estVisible: ${variable.estVisible}`);
-            console.log(`📋 [GroupRenderer] - conditionsAffichage: ${variable.conditionsAffichage}`);
             if (!variable.conditionsAffichage) {
-                console.log(`📋 [GroupRenderer] - No condition, returning estVisible: ${variable.estVisible}`);
                 return variable.estVisible;
             }
-            // Évaluer la condition avec le moteur étendu
-            const isVisible = conditionEngine.evaluate(variable.conditionsAffichage);
-            console.log(`📋 [GroupRenderer] - Condition evaluation result: ${isVisible}`);
-            const finalResult = variable.estVisible && isVisible;
-            console.log(`📋 [GroupRenderer] - Final visibility: ${finalResult} (estVisible: ${variable.estVisible} && condition: ${isVisible})`);
-            return finalResult;
+            // Évaluer la condition avec le moteur
+            const isVisible = engine.evaluate(variable.conditionsAffichage);
+            return variable.estVisible && isVisible;
         });
-    };
-    const visibleVariables = getVisibleVariables();
+    }, [useFormTreeMode, formTree, engine, groupe, responses]);
     // Mettre à jour le nombre d'itérations quand la variable de contrôle change
     useEffect(() => {
         if (groupe.estMultiple && groupe.configMultiple?.variableControle) {
@@ -95,6 +97,19 @@ const GroupRenderer = ({ groupe, responses, conditionEngine, onChange, onValidat
     }, [responses[groupe.configMultiple?.variableControle || '']?.valeur, groupe]);
     // Validation du groupe
     useEffect(() => {
+        // Mode FormTree: utiliser la validation du FormTree
+        if (useFormTreeMode && formTree) {
+            const { errors } = formTree.validateGroup(groupe.code);
+            const validationErrs = errors.map(msg => ({
+                variableCode: groupe.code,
+                message: msg,
+                type: 'required'
+            }));
+            setValidationErrors(validationErrs);
+            onValidation(validationErrs);
+            return;
+        }
+        // Mode Legacy: validation manuelle
         const errors = [];
         visibleVariables.forEach(variable => {
             if (variable.estObligatoire) {
@@ -129,10 +144,10 @@ const GroupRenderer = ({ groupe, responses, conditionEngine, onChange, onValidat
         });
         setValidationErrors(errors);
         onValidation(errors);
-    }, [responses, visibleVariables, multipleEntries, groupe, onValidation]);
-    // Exécuter les actions automatiques quand les réponses changent
+    }, [responses, visibleVariables, multipleEntries, groupe, onValidation, useFormTreeMode, formTree]);
+    // Exécuter les actions automatiques quand les réponses changent (mode legacy uniquement)
     useEffect(() => {
-        if (!onAutoAction)
+        if (!onAutoAction || !engine || useFormTreeMode)
             return;
         const executeAutoActions = () => {
             const allActions = [];
@@ -140,21 +155,21 @@ const GroupRenderer = ({ groupe, responses, conditionEngine, onChange, onValidat
             visibleVariables.forEach(variable => {
                 if (variable.conditionsAffichage && variable.conditionsAffichage.includes('setValeur(')) {
                     // Évaluer la condition pour déclencher les actions automatiques
-                    conditionEngine.evaluate(variable.conditionsAffichage);
+                    engine.evaluate(variable.conditionsAffichage);
                     // Récupérer les actions générées
-                    const actions = conditionEngine.getAutoActions();
+                    const actions = engine.getAutoActions();
                     allActions.push(...actions);
                 }
             });
             if (allActions.length > 0) {
                 onAutoAction(allActions);
-                conditionEngine.clearAutoActions(); // Nettoyer après exécution
+                engine.clearAutoActions(); // Nettoyer après exécution
             }
         };
         // Exécuter avec un délai pour éviter les boucles infinies
         const timeoutId = setTimeout(executeAutoActions, 100);
         return () => clearTimeout(timeoutId);
-    }, [responses, visibleVariables, conditionEngine, onAutoAction]);
+    }, [responses, visibleVariables, engine, onAutoAction, useFormTreeMode]);
     // Gestion des entrées multiples
     const addEntry = () => {
         if (!groupe.configMultiple?.allowManualControl)
@@ -188,8 +203,19 @@ const GroupRenderer = ({ groupe, responses, conditionEngine, onChange, onValidat
             (Array.isArray(value) && value.length === 0);
     };
     // Vérifier si le groupe doit être affiché
-    const shouldShowGroup = !groupe.conditionsAffichage ||
-        conditionEngine.evaluate(groupe.conditionsAffichage);
+    const shouldShowGroup = useMemo(() => {
+        // Mode FormTree: vérifier l'état du groupe
+        if (useFormTreeMode && formTree) {
+            const groupState = formTree.getGroupState(groupe.code);
+            return groupState?.isVisible ?? true;
+        }
+        // Mode Legacy: évaluer la condition
+        if (!groupe.conditionsAffichage)
+            return true;
+        if (!engine)
+            return true;
+        return engine.evaluate(groupe.conditionsAffichage);
+    }, [useFormTreeMode, formTree, engine, groupe]);
     if (!shouldShowGroup) {
         return null;
     }

package/dist/hooks/useFormTree.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Hook React pour utiliser le FormTree
+ * RSU v2 - Gestion centralisée de l'état de visibilité et des jumps
+ */
+import { GroupeFormulaire, EnqueteReponse, VariableFormulaire } from '../types/enquete';
+import { FormTree } from '../lib/form-tree';
+import { JumpError, JumpRange, VariableNodeState, GroupNodeState } from '../types/form-tree';
+export interface UseFormTreeOptions {
+    /** Callback appelé en cas d'erreur de jump */
+    onJumpError?: (error: JumpError) => void;
+    /** Activer le logging de debug */
+    debug?: boolean;
+}
+export interface UseFormTreeReturn {
+    /** Instance du FormTree */
+    formTree: FormTree;
+    /** Retourne les variables visibles d'un groupe */
+    getVisibleVariables: (groupeCode: string) => VariableFormulaire[];
+    /** Retourne les codes des variables sautées dans un groupe */
+    getJumpedVariableCodes: (groupeCode: string) => Set<string>;
+    /** Valide un groupe et retourne les erreurs */
+    validateGroup: (groupeCode: string) => {
+        isValid: boolean;
+        errors: string[];
+    };
+    /** Retourne les codes des variables à effacer lors de la sauvegarde */
+    getVariablesToClearOnSave: () => string[];
+    /** Retourne l'état d'une variable */
+    getVariableState: (variableCode: string) => VariableNodeState | undefined;
+    /** Retourne l'état d'un groupe */
+    getGroupState: (groupeCode: string) => GroupNodeState | undefined;
+    /** Liste des erreurs de jump actuelles */
+    jumpErrors: JumpError[];
+    /** Liste des jumps actifs */
+    activeJumps: JumpRange[];
+    /** Force une réévaluation de toutes les conditions */
+    forceEvaluate: () => void;
+    /** Compteur de mise à jour (pour forcer le re-render) */
+    updateCount: number;
+}
+/**
+ * Hook pour utiliser le FormTree dans les composants React
+ *
+ * @param groupes Liste des groupes du formulaire
+ * @param responses Dictionnaire des réponses
+ * @param options Options de configuration
+ * @returns Objet avec les méthodes et états du FormTree
+ *
+ * @example
+ * ```tsx
+ * const {
+ *   getVisibleVariables,
+ *   validateGroup,
+ *   jumpErrors,
+ *   activeJumps
+ * } = useFormTree(formulaire.groupes, responses, {
+ *   onJumpError: (error) => toast.error(error.message)
+ * });
+ *
+ * // Obtenir les variables visibles d'un groupe
+ * const visibleVars = getVisibleVariables(groupe.code);
+ *
+ * // Valider avant navigation
+ * const { isValid, errors } = validateGroup(groupe.code);
+ * ```
+ */
+export declare function useFormTree(groupes: GroupeFormulaire[], responses: Record<string, EnqueteReponse>, options?: UseFormTreeOptions): UseFormTreeReturn;
+export default useFormTree;
+//# sourceMappingURL=useFormTree.d.ts.map

package/dist/hooks/useFormTree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFormTree.d.ts","sourceRoot":"","sources":["../../src/hooks/useFormTree.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AACxF,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAC5C,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAE7F,MAAM,WAAW,kBAAkB;IACjC,8CAA8C;IAC9C,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,SAAS,KAAK,IAAI,CAAC;IACzC,kCAAkC;IAClC,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,iBAAiB;IAChC,2BAA2B;IAC3B,QAAQ,EAAE,QAAQ,CAAC;IAEnB,kDAAkD;IAClD,mBAAmB,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,kBAAkB,EAAE,CAAC;IAElE,8DAA8D;IAC9D,sBAAsB,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,GAAG,CAAC,MAAM,CAAC,CAAC;IAE5D,+CAA+C;IAC/C,aAAa,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,MAAM,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;IAE9E,uEAAuE;IACvE,yBAAyB,EAAE,MAAM,MAAM,EAAE,CAAC;IAE1C,qCAAqC;IACrC,gBAAgB,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,iBAAiB,GAAG,SAAS,CAAC;IAE1E,kCAAkC;IAClC,aAAa,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,cAAc,GAAG,SAAS,CAAC;IAElE,0CAA0C;IAC1C,UAAU,EAAE,SAAS,EAAE,CAAC;IAExB,6BAA6B;IAC7B,WAAW,EAAE,SAAS,EAAE,CAAC;IAEzB,sDAAsD;IACtD,aAAa,EAAE,MAAM,IAAI,CAAC;IAE1B,yDAAyD;IACzD,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,WAAW,CACzB,OAAO,EAAE,gBAAgB,EAAE,EAC3B,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,EACzC,OAAO,GAAE,kBAAuB,GAC/B,iBAAiB,CAyFnB;AAED,eAAe,WAAW,CAAC"}

package/dist/hooks/useFormTree.js

@@ -0,0 +1,86 @@
+/**
+ * Hook React pour utiliser le FormTree
+ * RSU v2 - Gestion centralisée de l'état de visibilité et des jumps
+ */
+'use client';
+import { useState, useEffect, useCallback, useMemo, useRef } from 'react';
+import { FormTree } from '../lib/form-tree';
+/**
+ * Hook pour utiliser le FormTree dans les composants React
+ *
+ * @param groupes Liste des groupes du formulaire
+ * @param responses Dictionnaire des réponses
+ * @param options Options de configuration
+ * @returns Objet avec les méthodes et états du FormTree
+ *
+ * @example
+ * ```tsx
+ * const {
+ *   getVisibleVariables,
+ *   validateGroup,
+ *   jumpErrors,
+ *   activeJumps
+ * } = useFormTree(formulaire.groupes, responses, {
+ *   onJumpError: (error) => toast.error(error.message)
+ * });
+ *
+ * // Obtenir les variables visibles d'un groupe
+ * const visibleVars = getVisibleVariables(groupe.code);
+ *
+ * // Valider avant navigation
+ * const { isValid, errors } = validateGroup(groupe.code);
+ * ```
+ */
+export function useFormTree(groupes, responses, options = {}) {
+    // Compteur pour forcer les re-renders
+    const [updateCount, setUpdateCount] = useState(0);
+    // Référence stable pour les options
+    const optionsRef = useRef(options);
+    optionsRef.current = options;
+    // Créer l'instance FormTree (stable tant que groupes ne changent pas)
+    const formTree = useMemo(() => {
+        const tree = new FormTree(responses, {
+            debug: optionsRef.current.debug,
+            onJumpError: optionsRef.current.onJumpError
+        });
+        tree.buildFromFormulaire(groupes);
+        return tree;
+    }, [groupes]); // Reconstruire seulement si groupes changent
+    // Mettre à jour le callback d'erreur quand il change
+    useEffect(() => {
+        formTree.onJumpError = options.onJumpError;
+    }, [formTree, options.onJumpError]);
+    // Mettre à jour quand les réponses changent
+    useEffect(() => {
+        formTree.updateResponses(responses);
+        setUpdateCount(c => c + 1);
+    }, [formTree, responses]);
+    // Fonctions de requête memoizées
+    const getVisibleVariables = useCallback((groupeCode) => formTree.getVisibleVariables(groupeCode), [formTree, updateCount]);
+    const getJumpedVariableCodes = useCallback((groupeCode) => formTree.getJumpedVariableCodes(groupeCode), [formTree, updateCount]);
+    const validateGroup = useCallback((groupeCode) => formTree.validateGroup(groupeCode), [formTree, updateCount]);
+    const getVariablesToClearOnSave = useCallback(() => formTree.getVariablesToClearOnSave(), [formTree, updateCount]);
+    const getVariableState = useCallback((variableCode) => formTree.getVariableState(variableCode), [formTree, updateCount]);
+    const getGroupState = useCallback((groupeCode) => formTree.getGroupState(groupeCode), [formTree, updateCount]);
+    const forceEvaluate = useCallback(() => {
+        formTree.evaluateAll();
+        setUpdateCount(c => c + 1);
+    }, [formTree]);
+    // Valeurs dérivées
+    const jumpErrors = useMemo(() => formTree.getJumpErrors(), [formTree, updateCount]);
+    const activeJumps = useMemo(() => formTree.getActiveJumps(), [formTree, updateCount]);
+    return {
+        formTree,
+        getVisibleVariables,
+        getJumpedVariableCodes,
+        validateGroup,
+        getVariablesToClearOnSave,
+        getVariableState,
+        getGroupState,
+        jumpErrors,
+        activeJumps,
+        forceEvaluate,
+        updateCount
+    };
+}
+export default useFormTree;

package/dist/index.d.ts

@@ -34,8 +34,11 @@ export { default as EnqueteInput } from './components/selectors/EnqueteInput';
 export type { EnqueteReponse, VariableFormulaire, GroupeFormulaire, FormulaireComplet, EnqueteInstance, GroupeInstance, VariableValue, VariableType, ValidationError, AutoAction, NavigationState } from './types/enquete';
 export type { FormRendererServices, GeographicComponents, DistrictSelectorProps, RegionSelectorProps, DepartementSelectorProps, SousPrefectureSelectorProps, QuartierSelectorProps, VillageSelectorProps } from './types/services';
 export type { FormRendererProps, GroupRendererProps, VariableRendererProps } from './types/form-renderer';
+export type { VariableNodeState, GroupNodeState, JumpRange, JumpError, IFormTree, FormTreeOptions, JumpEvaluationResult } from './types/form-tree';
 export { VariableValueConverter } from './lib/utils/variableValueConverter';
 export { interpolateVariableLabel } from './lib/utils/interpolateVariableLabel';
 export { ConditionEngine } from './lib/condition-engine';
+export { FormTree } from './lib/form-tree';
+export { useFormTree, type UseFormTreeOptions, type UseFormTreeReturn } from './hooks/useFormTree';
 export { cn } from './lib/utils/cn';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAOH,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,4BAA4B,CAAC;AACtE,OAAO,EAAE,OAAO,IAAI,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAG5E,OAAO,EACL,OAAO,IAAI,gBAAgB,EAC3B,KAAK,qBAAqB,EAC3B,MAAM,sCAAsC,CAAC;AAE9C,OAAO,EACL,OAAO,IAAI,eAAe,EAC1B,KAAK,oBAAoB,EAC1B,MAAM,qCAAqC,CAAC;AAE7C,OAAO,EACL,OAAO,IAAI,WAAW,EACtB,KAAK,gBAAgB,EACrB,KAAK,cAAc,EACpB,MAAM,iCAAiC,CAAC;AAOzC,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAGhE,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,iCAAiC,CAAC;AACzE,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,iCAAiC,CAAC;AACzE,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,gCAAgC,CAAC;AACvE,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAC7E,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,iCAAiC,CAAC;AACzE,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAC7E,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,gCAAgC,CAAC;AACvE,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AACnE,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,gCAAgC,CAAC;AACvE,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,+BAA+B,CAAC;AAGrE,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,oCAAoC,CAAC;AAC7E,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,mCAAmC,CAAC;AAG3E,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,mCAAmC,CAAC;AAC5E,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,mCAAmC,CAAC;AAM5E,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,uCAAuC,CAAC;AACjF,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,qCAAqC,CAAC;AAC7E,OAAO,EAAE,OAAO,IAAI,gBAAgB,EAAE,MAAM,0CAA0C,CAAC;AACvF,OAAO,EAAE,OAAO,IAAI,mBAAmB,EAAE,MAAM,6CAA6C,CAAC;AAC7F,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,uCAAuC,CAAC;AACjF,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,sCAAsC,CAAC;AAM/E,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,iCAAiC,CAAC;AACtE,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,oCAAoC,CAAC;AAC5E,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,qCAAqC,CAAC;AAO9E,YAAY,EACV,cAAc,EACd,kBAAkB,EAClB,gBAAgB,EAChB,iBAAiB,EACjB,eAAe,EACf,cAAc,EACd,aAAa,EACb,YAAY,EACZ,eAAe,EACf,UAAU,EACV,eAAe,EAChB,MAAM,iBAAiB,CAAC;AAGzB,YAAY,EACV,oBAAoB,EACpB,oBAAoB,EACpB,qBAAqB,EACrB,mBAAmB,EACnB,wBAAwB,EACxB,2BAA2B,EAC3B,qBAAqB,EACrB,oBAAoB,EACrB,MAAM,kBAAkB,CAAC;AAG1B,YAAY,EACV,iBAAiB,EACjB,kBAAkB,EAClB,qBAAqB,EACtB,MAAM,uBAAuB,CAAC;AAG/B,YAAY,EACV,iBAAiB,EACjB,cAAc,EACd,SAAS,EACT,SAAS,EACT,SAAS,EACT,eAAe,EACf,oBAAoB,EACrB,MAAM,mBAAmB,CAAC;AAO3B,OAAO,EAAE,sBAAsB,EAAE,MAAM,oCAAoC,CAAC;AAG5E,OAAO,EAAE,wBAAwB,EAAE,MAAM,sCAAsC,CAAC;AAGhF,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAGzD,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAO3C,OAAO,EAAE,WAAW,EAAE,KAAK,kBAAkB,EAAE,KAAK,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAGnG,OAAO,EAAE,EAAE,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/index.js

@@ -58,5 +58,12 @@ export { VariableValueConverter } from './lib/utils/variableValueConverter';
 export { interpolateVariableLabel } from './lib/utils/interpolateVariableLabel';
 // Moteur de conditions
 export { ConditionEngine } from './lib/condition-engine';
+// FormTree (arbre virtuel du formulaire)
+export { FormTree } from './lib/form-tree';
+// ========================================
+// HOOKS
+// ========================================
+// Hook FormTree
+export { useFormTree } from './hooks/useFormTree';
 // Utilitaire CSS
 export { cn } from './lib/utils/cn';

package/dist/lib/form-tree.d.ts

@@ -0,0 +1,76 @@
+/**
+ * FormTree - Arbre virtuel du formulaire
+ * RSU v2 - Gestion centralisée de l'état de visibilité et des jumps
+ *
+ * L'arbre virtuel (FormTree) est une représentation en mémoire de l'état du formulaire qui:
+ * 1. Connaît l'ordre de toutes les variables
+ * 2. Centralise l'évaluation des conditions
+ * 3. Stocke l'état de visibilité calculé
+ * 4. Gère nativement les jumps comme des "plages masquées"
+ */
+import { VariableFormulaire, GroupeFormulaire, EnqueteReponse, VariableValue } from '../types/enquete';
+import { IFormTree, VariableNodeState, GroupNodeState, JumpRange, JumpError, FormTreeOptions } from '../types/form-tree';
+import { ConditionEngine } from './condition-engine';
+export declare class FormTree implements IFormTree {
+    private groupNodes;
+    private variableNodes;
+    private orderedVariables;
+    private jumpRanges;
+    private jumpErrors;
+    private conditionEngine;
+    private responses;
+    private debug;
+    onJumpError?: (error: JumpError) => void;
+    constructor(responses?: Record<string, EnqueteReponse>, options?: FormTreeOptions);
+    private log;
+    buildFromFormulaire(groupes: GroupeFormulaire[]): void;
+    updateResponses(responses: Record<string, EnqueteReponse>): void;
+    evaluateAll(): void;
+    private evaluateGroupConditions;
+    private containsJump;
+    /**
+     * Évalue la partie non-jump d'une condition mixte
+     * Ex: "showMe(${A} == '1') || jump(${B} == '2', ${Q10})" -> évalue seulement showMe(${A} == '1')
+     */
+    private evaluateNonJumpPart;
+    private processJumpCondition;
+    private evaluateJump;
+    private applyJumpRanges;
+    private computeFinalVisibility;
+    getVisibleVariables(groupeCode: string): VariableFormulaire[];
+    getGroupState(groupeCode: string): GroupNodeState | undefined;
+    getVariableState(variableCode: string): VariableNodeState | undefined;
+    getJumpedVariableCodes(groupeCode: string): Set<string>;
+    getActiveJumps(): JumpRange[];
+    getJumpErrors(): JumpError[];
+    validateGroup(groupeCode: string): {
+        isValid: boolean;
+        errors: string[];
+    };
+    private isValueEmpty;
+    getVariablesToClearOnSave(): string[];
+    /**
+     * Expose le ConditionEngine pour les fonctionnalités existantes
+     * (showMe, hideMe, setValeur, etc.)
+     */
+    getConditionEngine(): ConditionEngine;
+    /**
+     * Retourne un snapshot de l'état complet pour debug
+     */
+    getDebugSnapshot(): {
+        groups: Array<{
+            code: string;
+            isVisible: boolean;
+            variableCount: number;
+        }>;
+        variables: Array<{
+            code: string;
+            isVisible: boolean;
+            isJumpedOver: boolean;
+            value: VariableValue;
+        }>;
+        activeJumps: JumpRange[];
+        errors: JumpError[];
+    };
+}
+//# sourceMappingURL=form-tree.d.ts.map

package/dist/lib/form-tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"form-tree.d.ts","sourceRoot":"","sources":["../../src/lib/form-tree.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EACL,kBAAkB,EAClB,gBAAgB,EAChB,cAAc,EACd,aAAa,EACd,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,SAAS,EACT,iBAAiB,EACjB,cAAc,EACd,SAAS,EACT,SAAS,EACT,eAAe,EAEhB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAErD,qBAAa,QAAS,YAAW,SAAS;IACxC,OAAO,CAAC,UAAU,CAA0C;IAC5D,OAAO,CAAC,aAAa,CAA6C;IAClE,OAAO,CAAC,gBAAgB,CAA4B;IACpD,OAAO,CAAC,UAAU,CAAmB;IACrC,OAAO,CAAC,UAAU,CAAmB;IACrC,OAAO,CAAC,eAAe,CAAkB;IACzC,OAAO,CAAC,SAAS,CAAiC;IAClD,OAAO,CAAC,KAAK,CAAU;IAEhB,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,SAAS,KAAK,IAAI,CAAC;gBAG9C,SAAS,GAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAM,EAC9C,OAAO,GAAE,eAAoB;IAU/B,OAAO,CAAC,GAAG;IAQX,mBAAmB,CAAC,OAAO,EAAE,gBAAgB,EAAE,GAAG,IAAI;IAmDtD,eAAe,CAAC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,GAAG,IAAI;IAchE,WAAW,IAAI,IAAI;IA+BnB,OAAO,CAAC,uBAAuB;IAkC/B,OAAO,CAAC,YAAY;IAIpB;;;OAGG;IACH,OAAO,CAAC,mBAAmB;IAiB3B,OAAO,CAAC,oBAAoB;IA6C5B,OAAO,CAAC,YAAY;IA+DpB,OAAO,CAAC,eAAe;IAsBvB,OAAO,CAAC,sBAAsB;IAY9B,mBAAmB,CAAC,UAAU,EAAE,MAAM,GAAG,kBAAkB,EAAE;IAS7D,aAAa,CAAC,UAAU,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS;IAI7D,gBAAgB,CAAC,YAAY,EAAE,MAAM,GAAG,iBAAiB,GAAG,SAAS;IAIrE,sBAAsB,CAAC,UAAU,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC;IAYvD,cAAc,IAAI,SAAS,EAAE;IAI7B,aAAa,IAAI,SAAS,EAAE;IAM5B,aAAa,CAAC,UAAU,EAAE,MAAM,GAAG;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,MAAM,EAAE,MAAM,EAAE,CAAA;KAAE;IA+BzE,OAAO,CAAC,YAAY;IAOpB,yBAAyB,IAAI,MAAM,EAAE;IAcrC;;;OAGG;IACH,kBAAkB,IAAI,eAAe;IAMrC;;OAEG;IACH,gBAAgB,IAAI;QAClB,MAAM,EAAE,KAAK,CAAC;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,SAAS,EAAE,OAAO,CAAC;YAAC,aAAa,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC;QAC3E,SAAS,EAAE,KAAK,CAAC;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,SAAS,EAAE,OAAO,CAAC;YAAC,YAAY,EAAE,OAAO,CAAC;YAAC,KAAK,EAAE,aAAa,CAAA;SAAE,CAAC,CAAC;QACpG,WAAW,EAAE,SAAS,EAAE,CAAC;QACzB,MAAM,EAAE,SAAS,EAAE,CAAC;KACrB;CAiBF"}

package/dist/lib/form-tree.js

@@ -0,0 +1,371 @@
+/**
+ * FormTree - Arbre virtuel du formulaire
+ * RSU v2 - Gestion centralisée de l'état de visibilité et des jumps
+ *
+ * L'arbre virtuel (FormTree) est une représentation en mémoire de l'état du formulaire qui:
+ * 1. Connaît l'ordre de toutes les variables
+ * 2. Centralise l'évaluation des conditions
+ * 3. Stocke l'état de visibilité calculé
+ * 4. Gère nativement les jumps comme des "plages masquées"
+ */
+import { ConditionEngine } from './condition-engine';
+export class FormTree {
+    constructor(responses = {}, options = {}) {
+        this.groupNodes = new Map();
+        this.variableNodes = new Map();
+        this.orderedVariables = [];
+        this.jumpRanges = [];
+        this.jumpErrors = [];
+        this.responses = responses;
+        this.conditionEngine = new ConditionEngine(responses);
+        this.onJumpError = options.onJumpError;
+        this.debug = options.debug ?? false;
+    }
+    // ============ LOGGING ============
+    log(message, ...args) {
+        if (this.debug) {
+            console.log(`🌳 [FormTree] ${message}`, ...args);
+        }
+    }
+    // ============ CONSTRUCTION ============
+    buildFromFormulaire(groupes) {
+        this.log('Building tree from', groupes.length, 'groups');
+        this.groupNodes.clear();
+        this.variableNodes.clear();
+        this.orderedVariables = [];
+        // Trier les groupes par ordre
+        const sortedGroupes = [...groupes].sort((a, b) => a.ordre - b.ordre);
+        for (const groupe of sortedGroupes) {
+            // Trier les variables par ordre dans le groupe
+            const sortedVariables = [...groupe.variables].sort((a, b) => a.ordre - b.ordre);
+            const variableStates = sortedVariables.map(variable => {
+                const state = {
+                    variable,
+                    isVisible: variable.estVisible,
+                    isJumpedOver: false,
+                    isConditionMet: true,
+                    isValid: true,
+                    skipValidation: false,
+                    currentValue: this.responses[variable.code]?.valeur ?? null,
+                    shouldClearOnSave: false
+                };
+                this.variableNodes.set(variable.code, state);
+                this.orderedVariables.push(variable);
+                return state;
+            });
+            const groupState = {
+                groupe,
+                variables: variableStates,
+                isVisible: true,
+                isComplete: false,
+                validationErrors: [],
+                iterations: new Map()
+            };
+            this.groupNodes.set(groupe.code, groupState);
+            this.log(`Group ${groupe.code} built with ${variableStates.length} variables`);
+        }
+        // Évaluer toutes les conditions initiales
+        this.evaluateAll();
+    }
+    // ============ MISE À JOUR ============
+    updateResponses(responses) {
+        this.log('Updating responses');
+        this.responses = responses;
+        this.conditionEngine.updateContext(responses);
+        // Mettre à jour les valeurs dans les noeuds
+        for (const [code, state] of this.variableNodes) {
+            state.currentValue = responses[code]?.valeur ?? null;
+        }
+        // Réévaluer toutes les conditions
+        this.evaluateAll();
+    }
+    evaluateAll() {
+        this.log('Evaluating all conditions');
+        // Reset des états
+        this.jumpRanges = [];
+        this.jumpErrors = [];
+        for (const state of this.variableNodes.values()) {
+            state.isJumpedOver = false;
+            state.isConditionMet = true;
+            state.skipValidation = false;
+            state.shouldClearOnSave = false;
+        }
+        // Premier passage: évaluer les conditions et détecter les jumps
+        for (const groupNode of this.groupNodes.values()) {
+            this.evaluateGroupConditions(groupNode);
+        }
+        // Deuxième passage: appliquer les jumps
+        this.applyJumpRanges();
+        // Troisième passage: calculer la visibilité finale
+        this.computeFinalVisibility();
+        this.log('Evaluation complete:', {
+            activeJumps: this.jumpRanges.filter(j => j.isActive).length,
+            jumpErrors: this.jumpErrors.length
+        });
+    }
+    evaluateGroupConditions(groupNode) {
+        const { groupe } = groupNode;
+        this.log(`Evaluating group ${groupe.code}`);
+        // Évaluer la condition du groupe
+        if (groupe.conditionsAffichage) {
+            groupNode.isVisible = this.conditionEngine.evaluate(groupe.conditionsAffichage);
+            this.log(`Group ${groupe.code} visibility:`, groupNode.isVisible);
+        }
+        if (!groupNode.isVisible)
+            return;
+        // Évaluer les conditions de chaque variable
+        for (const varState of groupNode.variables) {
+            const condition = varState.variable.conditionsAffichage;
+            if (!condition) {
+                varState.isConditionMet = true;
+                continue;
+            }
+            // Détecter et traiter les jumps
+            if (this.containsJump(condition)) {
+                this.processJumpCondition(varState, groupe.code, condition);
+                // La variable source du jump reste visible (sa condition propre est évaluée séparément)
+                varState.isConditionMet = this.evaluateNonJumpPart(condition);
+            }
+            else {
+                varState.isConditionMet = this.conditionEngine.evaluate(condition);
+            }
+            this.log(`Variable ${varState.variable.code} conditionMet:`, varState.isConditionMet);
+        }
+    }
+    containsJump(condition) {
+        return /jump\s*\(/.test(condition);
+    }
+    /**
+     * Évalue la partie non-jump d'une condition mixte
+     * Ex: "showMe(${A} == '1') || jump(${B} == '2', ${Q10})" -> évalue seulement showMe(${A} == '1')
+     */
+    evaluateNonJumpPart(condition) {
+        // Retirer les appels jump() de la condition
+        const withoutJumps = condition
+            .replace(/jump\s*\([^)]*\)/g, 'true')
+            .replace(/\|\|\s*true/g, '')
+            .replace(/true\s*\|\|/g, '')
+            .replace(/&&\s*true/g, '')
+            .replace(/true\s*&&/g, '')
+            .trim();
+        if (!withoutJumps || withoutJumps === 'true') {
+            return true;
+        }
+        return this.conditionEngine.evaluate(withoutJumps);
+    }
+    processJumpCondition(sourceState, groupeCode, condition) {
+        this.log(`Processing jump condition for ${sourceState.variable.code}:`, condition);
+        // Parser tous les jumps dans la condition
+        // Pattern: jump(condition, ${VARIABLE_CIBLE})
+        const jumpPattern = /jump\s*\(\s*(.+?)\s*,\s*\$\{([A-Z_][A-Z0-9_]*)\}\s*\)/g;
+        let match;
+        while ((match = jumpPattern.exec(condition)) !== null) {
+            const innerCondition = match[1].trim();
+            const targetCode = match[2];
+            this.log(`Found jump: condition="${innerCondition}", target="${targetCode}"`);
+            const result = this.evaluateJump(sourceState, groupeCode, innerCondition, targetCode);
+            if (result.error) {
+                this.jumpErrors.push(result.error);
+                this.onJumpError?.(result.error);
+                continue;
+            }
+            if (result.canExecute && result.targetCode) {
+                const targetState = this.variableNodes.get(result.targetCode);
+                const jumpRange = {
+                    sourceCode: sourceState.variable.code,
+                    sourceOrdre: sourceState.variable.ordre,
+                    targetCode: result.targetCode,
+                    targetOrdre: targetState.variable.ordre,
+                    groupeCode,
+                    condition: innerCondition,
+                    isActive: result.shouldActivate
+                };
+                this.jumpRanges.push(jumpRange);
+                this.log(`Jump range created:`, jumpRange);
+            }
+        }
+    }
+    evaluateJump(sourceState, groupeCode, innerCondition, targetCode) {
+        const result = {
+            isValidSyntax: true,
+            canExecute: false,
+            shouldActivate: false,
+            targetCode: null
+        };
+        // Validation: cible existe?
+        const targetState = this.variableNodes.get(targetCode);
+        if (!targetState) {
+            result.error = {
+                type: 'invalid_target',
+                sourceVariable: sourceState.variable.code,
+                targetVariable: targetCode,
+                message: `Variable cible "${targetCode}" non trouvée pour le jump depuis "${sourceState.variable.code}"`
+            };
+            return result;
+        }
+        // Validation: même groupe?
+        if (targetState.variable.groupeCode !== groupeCode) {
+            result.error = {
+                type: 'cross_group_jump',
+                sourceVariable: sourceState.variable.code,
+                targetVariable: targetCode,
+                message: `Jump inter-groupe non autorisé: "${sourceState.variable.code}" (${groupeCode}) → "${targetCode}" (${targetState.variable.groupeCode})`
+            };
+            return result;
+        }
+        // Validation: direction avant?
+        if (targetState.variable.ordre <= sourceState.variable.ordre) {
+            result.error = {
+                type: 'backward_jump',
+                sourceVariable: sourceState.variable.code,
+                targetVariable: targetCode,
+                message: `Jump arrière non autorisé: "${sourceState.variable.code}" (ordre ${sourceState.variable.ordre}) → "${targetCode}" (ordre ${targetState.variable.ordre})`
+            };
+            return result;
+        }
+        // Le jump est valide
+        result.canExecute = true;
+        result.targetCode = targetCode;
+        // Évaluer la condition du jump
+        try {
+            result.shouldActivate = this.conditionEngine.evaluate(innerCondition);
+            this.log(`Jump condition "${innerCondition}" evaluated to:`, result.shouldActivate);
+        }
+        catch (e) {
+            this.log(`Error evaluating jump condition:`, e);
+            result.shouldActivate = false;
+        }
+        return result;
+    }
+    applyJumpRanges() {
+        for (const jump of this.jumpRanges) {
+            if (!jump.isActive)
+                continue;
+            this.log(`Applying jump from ${jump.sourceCode} to ${jump.targetCode}`);
+            // Marquer toutes les variables entre source et cible comme "jumped over"
+            for (const [code, state] of this.variableNodes) {
+                if (state.variable.groupeCode !== jump.groupeCode)
+                    continue;
+                const ordre = state.variable.ordre;
+                // Variables strictement entre source et cible (exclusif aux deux bornes)
+                if (ordre > jump.sourceOrdre && ordre < jump.targetOrdre) {
+                    state.isJumpedOver = true;
+                    state.skipValidation = true;
+                    state.shouldClearOnSave = true;
+                    this.log(`Variable ${code} marked as jumped over`);
+                }
+            }
+        }
+    }
+    computeFinalVisibility() {
+        for (const state of this.variableNodes.values()) {
+            // Visible = base visible ET condition satisfaite ET pas sauté
+            state.isVisible =
+                state.variable.estVisible &&
+                    state.isConditionMet &&
+                    !state.isJumpedOver;
+        }
+    }
+    // ============ REQUÊTES ============
+    getVisibleVariables(groupeCode) {
+        const groupNode = this.groupNodes.get(groupeCode);
+        if (!groupNode || !groupNode.isVisible)
+            return [];
+        return groupNode.variables
+            .filter(state => state.isVisible)
+            .map(state => state.variable);
+    }
+    getGroupState(groupeCode) {
+        return this.groupNodes.get(groupeCode);
+    }
+    getVariableState(variableCode) {
+        return this.variableNodes.get(variableCode);
+    }
+    getJumpedVariableCodes(groupeCode) {
+        const codes = new Set();
+        for (const [code, state] of this.variableNodes) {
+            if (state.variable.groupeCode === groupeCode && state.isJumpedOver) {
+                codes.add(code);
+            }
+        }
+        return codes;
+    }
+    getActiveJumps() {
+        return this.jumpRanges.filter(j => j.isActive);
+    }
+    getJumpErrors() {
+        return [...this.jumpErrors];
+    }
+    // ============ VALIDATION ============
+    validateGroup(groupeCode) {
+        const groupNode = this.groupNodes.get(groupeCode);
+        if (!groupNode)
+            return { isValid: true, errors: [] };
+        const errors = [];
+        for (const state of groupNode.variables) {
+            // Ignorer les variables masquées ou sautées
+            if (!state.isVisible || state.skipValidation)
+                continue;
+            // Vérifier les champs obligatoires
+            if (state.variable.estObligatoire) {
+                const isEmpty = this.isValueEmpty(state.currentValue);
+                if (isEmpty) {
+                    errors.push(`${state.variable.designation} est obligatoire`);
+                    state.isValid = false;
+                    state.validationError = 'Champ obligatoire';
+                }
+                else {
+                    state.isValid = true;
+                    state.validationError = undefined;
+                }
+            }
+        }
+        groupNode.validationErrors = errors;
+        groupNode.isComplete = errors.length === 0;
+        return { isValid: errors.length === 0, errors };
+    }
+    isValueEmpty(value) {
+        return value === null ||
+            value === undefined ||
+            value === '' ||
+            (Array.isArray(value) && value.length === 0);
+    }
+    getVariablesToClearOnSave() {
+        const codes = [];
+        for (const [code, state] of this.variableNodes) {
+            if (state.shouldClearOnSave && !this.isValueEmpty(state.currentValue)) {
+                codes.push(code);
+            }
+        }
+        return codes;
+    }
+    // ============ ACCÈS AU CONDITION ENGINE ============
+    /**
+     * Expose le ConditionEngine pour les fonctionnalités existantes
+     * (showMe, hideMe, setValeur, etc.)
+     */
+    getConditionEngine() {
+        return this.conditionEngine;
+    }
+    // ============ DEBUG ============
+    /**
+     * Retourne un snapshot de l'état complet pour debug
+     */
+    getDebugSnapshot() {
+        return {
+            groups: Array.from(this.groupNodes.values()).map(g => ({
+                code: g.groupe.code,
+                isVisible: g.isVisible,
+                variableCount: g.variables.length
+            })),
+            variables: Array.from(this.variableNodes.values()).map(v => ({
+                code: v.variable.code,
+                isVisible: v.isVisible,
+                isJumpedOver: v.isJumpedOver,
+                value: v.currentValue
+            })),
+            activeJumps: this.getActiveJumps(),
+            errors: this.jumpErrors
+        };
+    }
+}

package/dist/types/form-tree.d.ts

@@ -0,0 +1,164 @@
+/**
+ * Types et interfaces pour le FormTree (arbre virtuel du formulaire)
+ * RSU v2 - Gestion centralisée de l'état de visibilité et des jumps
+ */
+import { VariableFormulaire, GroupeFormulaire, EnqueteReponse, VariableValue } from './enquete';
+/**
+ * État d'un noeud variable dans l'arbre
+ */
+export interface VariableNodeState {
+    /** Référence à la variable du formulaire */
+    variable: VariableFormulaire;
+    /** Résultat final de visibilité (estVisible && conditionMet && !jumpedOver) */
+    isVisible: boolean;
+    /** Masqué par un jump actif */
+    isJumpedOver: boolean;
+    /** Condition d'affichage satisfaite */
+    isConditionMet: boolean;
+    /** Passe la validation */
+    isValid: boolean;
+    /** Message d'erreur si invalide */
+    validationError?: string;
+    /** Ignorer validation (jumped over) */
+    skipValidation: boolean;
+    /** Valeur actuelle de la variable */
+    currentValue: VariableValue;
+    /** Effacer à la sauvegarde (jumped) */
+    shouldClearOnSave: boolean;
+}
+/**
+ * État d'un noeud groupe dans l'arbre
+ */
+export interface GroupNodeState {
+    /** Référence au groupe du formulaire */
+    groupe: GroupeFormulaire;
+    /** États des variables de ce groupe */
+    variables: VariableNodeState[];
+    /** Le groupe est visible */
+    isVisible: boolean;
+    /** Toutes les variables obligatoires sont remplies */
+    isComplete: boolean;
+    /** Erreurs de validation du groupe */
+    validationErrors: string[];
+    /** Map des itérations avec leurs états de variables */
+    iterations: Map<number, VariableNodeState[]>;
+}
+/**
+ * Plage de jump actif
+ * Représente un saut conditionnel entre deux variables
+ */
+export interface JumpRange {
+    /** Code de la variable source du jump */
+    sourceCode: string;
+    /** Ordre de la variable source */
+    sourceOrdre: number;
+    /** Code de la variable cible du jump */
+    targetCode: string;
+    /** Ordre de la variable cible */
+    targetOrdre: number;
+    /** Code du groupe contenant le jump */
+    groupeCode: string;
+    /** Condition d'activation du jump */
+    condition: string;
+    /** Le jump est actuellement actif */
+    isActive: boolean;
+}
+/**
+ * Erreur de jump pour notification
+ */
+export interface JumpError {
+    /** Type d'erreur */
+    type: 'backward_jump' | 'invalid_target' | 'circular_jump' | 'cross_group_jump';
+    /** Code de la variable source */
+    sourceVariable: string;
+    /** Code de la variable cible */
+    targetVariable: string;
+    /** Message d'erreur descriptif */
+    message: string;
+}
+/**
+ * Interface principale du FormTree
+ */
+export interface IFormTree {
+    /**
+     * Construit l'arbre à partir des groupes du formulaire
+     * @param groupes Liste des groupes du formulaire
+     */
+    buildFromFormulaire(groupes: GroupeFormulaire[]): void;
+    /**
+     * Met à jour les réponses et réévalue toutes les conditions
+     * @param responses Dictionnaire des réponses
+     */
+    updateResponses(responses: Record<string, EnqueteReponse>): void;
+    /**
+     * Évalue toutes les conditions de visibilité et jumps
+     */
+    evaluateAll(): void;
+    /**
+     * Retourne les variables visibles d'un groupe
+     * @param groupeCode Code du groupe
+     */
+    getVisibleVariables(groupeCode: string): VariableFormulaire[];
+    /**
+     * Retourne l'état d'un groupe
+     * @param groupeCode Code du groupe
+     */
+    getGroupState(groupeCode: string): GroupNodeState | undefined;
+    /**
+     * Retourne l'état d'une variable
+     * @param variableCode Code de la variable
+     */
+    getVariableState(variableCode: string): VariableNodeState | undefined;
+    /**
+     * Retourne les codes des variables sautées dans un groupe
+     * @param groupeCode Code du groupe
+     */
+    getJumpedVariableCodes(groupeCode: string): Set<string>;
+    /**
+     * Retourne tous les jumps actifs
+     */
+    getActiveJumps(): JumpRange[];
+    /**
+     * Retourne toutes les erreurs de jump détectées
+     */
+    getJumpErrors(): JumpError[];
+    /**
+     * Valide un groupe et retourne les erreurs
+     * @param groupeCode Code du groupe
+     */
+    validateGroup(groupeCode: string): {
+        isValid: boolean;
+        errors: string[];
+    };
+    /**
+     * Retourne les codes des variables à effacer lors de la sauvegarde
+     */
+    getVariablesToClearOnSave(): string[];
+    /** Callback appelé en cas d'erreur de jump */
+    onJumpError?: (error: JumpError) => void;
+}
+/**
+ * Options pour la création d'un FormTree
+ */
+export interface FormTreeOptions {
+    /** Callback en cas d'erreur de jump */
+    onJumpError?: (error: JumpError) => void;
+    /** Activer le logging de debug */
+    debug?: boolean;
+}
+/**
+ * Résultat de l'évaluation d'une condition de jump
+ */
+export interface JumpEvaluationResult {
+    /** La condition est valide syntaxiquement */
+    isValidSyntax: boolean;
+    /** Le jump peut être exécuté (cible valide, direction correcte) */
+    canExecute: boolean;
+    /** Le jump doit être activé (condition satisfaite) */
+    shouldActivate: boolean;
+    /** Code de la variable cible */
+    targetCode: string | null;
+    /** Erreur éventuelle */
+    error?: JumpError;
+}
+//# sourceMappingURL=form-tree.d.ts.map

package/dist/types/form-tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"form-tree.d.ts","sourceRoot":"","sources":["../../src/types/form-tree.ts"],"names":[],"mappings":"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"}

package/dist/types/form-tree.js

@@ -0,0 +1,5 @@
+/**
+ * Types et interfaces pour le FormTree (arbre virtuel du formulaire)
+ * RSU v2 - Gestion centralisée de l'état de visibilité et des jumps
+ */
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rsuci/shared-form-components",
-  "version": "1.0.15",
+  "version": "1.0.16",
   "description": "Composants partagés de rendu de formulaires RSU v2 - Package local pour frontend Admin et Public",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",