@fidusia/question-engine-dynamic 1.0.4

package/dist/engine.js

@@ -0,0 +1,1243 @@
+// =====================================================
+// QUESTION ENGINE - MOTEUR PRINCIPAL
+// Gère la queue, la navigation et les triggers
+// Version avec configuration dynamique complète
+// =====================================================
+import { loadAllAIQuestionsForSector, convertAIQuestionToModuleQuestion, checkConditions } from "./ai-questions-loader";
+import { getPriorityMappings, getBookedProviderMappings, getPriorityBoosts, getSystemIds, getPriorityToBookedProviders, getPriorityCalculation, getSpecialBehaviors } from './config-loader';
+// Import conditionnel pour la version serveur (si disponible)
+// Utiliser une fonction helper pour charger la version serveur
+// Note: Les fichiers *-server.ts doivent être fournis par le projet consommateur
+async function getServerLoader() {
+    // Vérifier si on est côté client (browser)
+    // Utiliser une vérification qui fonctionne à la fois en TypeScript et à l'exécution
+    const isClient = typeof globalThis !== 'undefined' && 'window' in globalThis;
+    if (isClient) {
+        // Côté client, ne pas essayer d'importer le module serveur
+        return null;
+    }
+    try {
+        // Utiliser une chaîne construite dynamiquement pour éviter l'analyse statique de Next.js
+        // Cela empêche Next.js d'essayer de résoudre le module au moment du bundling
+        // En construisant le chemin avec des variables, Next.js ne peut pas l'analyser statiquement
+        const parts = ['./ai-questions-loader', '-server'];
+        const serverModulePath = parts.join('');
+        // Utiliser eval pour créer un import vraiment dynamique
+        // qui ne peut pas être analysé statiquement par Next.js
+        // eslint-disable-next-line no-eval
+        const serverModule = await eval(`import('${serverModulePath}')`).catch(() => null);
+        if (serverModule && typeof serverModule.loadAllAIQuestionsForSectorServer === 'function') {
+            return serverModule.loadAllAIQuestionsForSectorServer;
+        }
+        return null;
+    }
+    catch (_a) {
+        // Version serveur non disponible, retourner null
+        return null;
+    }
+}
+export class QuestionEngine {
+    constructor(i18n) {
+        this.modules = new Map();
+        this.listeners = new Set();
+        this.advancedByTrigger = false; // Flag pour éviter double avancement
+        this.aiQuestionsCache = new Map(); // Cache de toutes les questions IA chargées
+        this.config = {}; // Configuration du chatbot
+        this.chatbotId = undefined; // ID du chatbot pour filtrer les questions IA
+        this.i18n = i18n;
+        this.state = this.createInitialState();
+    }
+    /**
+     * Définit l'ID du chatbot pour filtrer les questions IA
+     */
+    setChatbotId(chatbotId) {
+        this.chatbotId = chatbotId;
+    }
+    // =====================================================
+    // INITIALISATION
+    // =====================================================
+    createInitialState() {
+        return {
+            queue: [],
+            currentModuleId: null,
+            currentQuestionId: null,
+            completedModules: [],
+            hiddenModules: [],
+            skippedModules: [],
+            formData: {},
+            answeredQuestions: [],
+            isComplete: false,
+            transitionInfo: null,
+        };
+    }
+    registerModule(module) {
+        this.modules.set(module.id, module);
+    }
+    registerModules(modules) {
+        modules.forEach((m) => this.registerModule(m));
+    }
+    /**
+     * Définit la configuration du chatbot
+     * Doit être appelée avant initialize() pour que la configuration soit utilisée
+     */
+    setConfig(config) {
+        this.config = config;
+    }
+    async initialize() {
+        this.state = this.createInitialState();
+        this.buildQueue();
+        // Charger toutes les questions IA une seule fois pour tous les secteurs
+        await this.loadAllAIQuestions();
+        // Injecter les questions IA qui correspondent aux conditions initiales
+        this.injectAIQuestionsFromCache();
+        // Activer la première question
+        this.activateFirstQuestion();
+        this.notifyListeners();
+    }
+    reset() {
+        this.initialize();
+    }
+    // Restaurer l'état depuis localStorage (pour la persistance de session)
+    async restoreState(savedState) {
+        // Sauvegarder la question actuelle AVANT la restauration
+        const savedCurrentQuestionId = savedState.currentQuestionId;
+        const savedCurrentModuleId = savedState.currentModuleId;
+        this.state = Object.assign({}, savedState);
+        // Reconstruire les références des modules dans la queue
+        this.state.queue.forEach((queuedModule) => {
+            const module = this.modules.get(queuedModule.moduleId);
+            if (module) {
+                // S'assurer que les questions du module sont synchronisées
+                queuedModule.questions.forEach((q) => {
+                    const moduleQuestion = module.questions.find((mq) => mq.id === q.questionId);
+                    if (moduleQuestion) {
+                        q.text = moduleQuestion.text;
+                        q.type = moduleQuestion.type;
+                    }
+                });
+            }
+        });
+        // IMPORTANT: Recharger les questions IA et les réinjecter dans la queue
+        // car elles peuvent avoir changé ou de nouvelles conditions peuvent être remplies
+        await this.loadAllAIQuestions();
+        this.injectAIQuestionsFromCache();
+        // IMPORTANT: Restaurer la question actuelle après l'injection des questions IA
+        // pour éviter que l'injection ne change la question actuelle
+        if (savedCurrentQuestionId && savedCurrentModuleId) {
+            // Vérifier que la question existe toujours dans la queue
+            const queuedModule = this.state.queue.find(m => m.moduleId === savedCurrentModuleId);
+            if (queuedModule) {
+                const queuedQuestion = queuedModule.questions.find(q => q.questionId === savedCurrentQuestionId);
+                if (queuedQuestion) {
+                    // La question existe toujours, restaurer la question actuelle
+                    this.state.currentQuestionId = savedCurrentQuestionId;
+                    this.state.currentModuleId = savedCurrentModuleId;
+                }
+            }
+        }
+        this.notifyListeners();
+    }
+    // =====================================================
+    // CONSTRUCTION DE LA QUEUE
+    // =====================================================
+    buildQueue() {
+        const queuedModules = [];
+        this.modules.forEach((module) => {
+            // Vérifier les triggers au niveau module
+            if (this.shouldHideModule(module)) {
+                this.state.hiddenModules.push(module.id);
+                return;
+            }
+            const queuedModule = {
+                moduleId: module.id,
+                moduleName: module.name,
+                effectivePriority: module.basePriority,
+                status: "pending",
+                questions: this.buildModuleQuestions(module),
+            };
+            queuedModules.push(queuedModule);
+        });
+        // Trier par priorité effective
+        queuedModules.sort((a, b) => a.effectivePriority - b.effectivePriority);
+        this.state.queue = queuedModules;
+    }
+    buildModuleQuestions(module) {
+        // Exclure les questions IA lors de la construction initiale de la queue
+        // Elles seront ré-injectées dynamiquement depuis les métadonnées
+        return module.questions
+            .filter((q) => !q.aiQuestionMetadata) // Exclure les questions IA
+            .map((q) => ({
+            questionId: q.id,
+            moduleId: module.id,
+            text: q.text,
+            type: q.type,
+            status: "pending",
+        }));
+    }
+    /**
+     * Charge toutes les questions IA pour tous les secteurs une seule fois
+     * Utilise la version serveur si disponible (API routes), sinon la version fetch (client)
+     * OU extrait depuis les métadonnées des modules si disponibles (pour JSON)
+     */
+    async loadAllAIQuestions() {
+        // D'abord, essayer d'extraire les questions IA depuis les métadonnées des modules (pour JSON)
+        const aiQuestionsFromMetadata = this.extractAIQuestionsFromModules();
+        if (aiQuestionsFromMetadata.size > 0) {
+            // Utiliser les questions IA extraites depuis les métadonnées
+            aiQuestionsFromMetadata.forEach((questions, sectorId) => {
+                this.aiQuestionsCache.set(sectorId, questions);
+            });
+            return;
+        }
+        // Sinon, charger depuis l'API (comportement normal)
+        // Essayer de charger la version serveur (disponible uniquement côté serveur)
+        const serverLoader = await getServerLoader();
+        // Parcourir tous les modules dans la queue pour charger leurs questions IA
+        const loadPromises = this.state.queue.map(async (queuedModule) => {
+            // Utiliser la version serveur si disponible (côté serveur), sinon la version fetch (côté client)
+            const loader = serverLoader || loadAllAIQuestionsForSector;
+            // Passer le chatbot_id au loader
+            const aiQuestions = await loader(queuedModule.moduleId, this.chatbotId);
+            this.aiQuestionsCache.set(queuedModule.moduleId, aiQuestions);
+        });
+        await Promise.all(loadPromises);
+    }
+    /**
+     * Extrait les questions IA depuis les métadonnées des modules (pour import JSON)
+     * Retourne une Map<sectorId, AIQuestion[]>
+     */
+    extractAIQuestionsFromModules() {
+        const aiQuestionsMap = new Map();
+        // Parcourir tous les modules enregistrés
+        for (const [moduleId, module] of this.modules.entries()) {
+            const aiQuestions = [];
+            // Parcourir toutes les questions du module
+            for (const question of module.questions) {
+                // Si la question a des métadonnées IA, l'extraire
+                if (question.aiQuestionMetadata) {
+                    const metadata = question.aiQuestionMetadata;
+                    aiQuestions.push({
+                        id: question.id, // Utiliser l'ID de la question comme ID
+                        sectorId: metadata.sectorId || moduleId,
+                        questionId: question.id,
+                        questionText: question.text,
+                        questionType: question.type,
+                        options: question.options || null,
+                        placeholder: question.placeholder || null,
+                        minValue: question.min || null,
+                        maxValue: question.max || null,
+                        conditions: metadata.conditions || null,
+                        isActive: metadata.isActive !== false, // Par défaut true
+                        parentQuestionId: metadata.parentQuestionId || null,
+                        nextQuestionId: metadata.nextQuestionId || null,
+                    });
+                }
+            }
+            if (aiQuestions.length > 0) {
+                aiQuestionsMap.set(moduleId, aiQuestions);
+            }
+        }
+        return aiQuestionsMap;
+    }
+    /**
+     * Injecte les questions IA depuis le cache selon les conditions actuelles
+     * Évite les doublons en vérifiant si la question est déjà dans la queue
+     * Gère l'injection récursive des questions IA qui dépendent d'autres questions IA
+     */
+    injectAIQuestionsFromCache() {
+        // Parcourir tous les modules dans la queue
+        for (const queuedModule of this.state.queue) {
+            const module = this.modules.get(queuedModule.moduleId);
+            if (!module)
+                continue;
+            // Récupérer les questions IA depuis le cache pour ce secteur
+            const allAIQuestions = this.aiQuestionsCache.get(queuedModule.moduleId) || [];
+            // Filtrer selon les conditions actuelles
+            const aiQuestions = allAIQuestions.filter(q => checkConditions(q.conditions, this.state.formData));
+            if (aiQuestions.length === 0)
+                continue;
+            // Récupérer les IDs des questions déjà dans la queue pour éviter les doublons
+            const existingQuestionIds = new Set(queuedModule.questions.map(q => q.questionId));
+            // Récupérer les IDs des questions déjà dans le module
+            const existingModuleQuestionIds = new Set(module.questions.map(q => q.id));
+            // Fonction récursive pour injecter une question IA et ses dépendances
+            const injectQuestionRecursive = (aiQuestion, processedIds) => {
+                // Éviter les cycles et les doublons
+                if (processedIds.has(aiQuestion.questionId) || existingQuestionIds.has(aiQuestion.questionId)) {
+                    return;
+                }
+                // Si la question a un parent qui est aussi une question IA, injecter d'abord le parent
+                if (aiQuestion.parentQuestionId && !existingQuestionIds.has(aiQuestion.parentQuestionId)) {
+                    const parentAIQuestion = allAIQuestions.find(q => q.questionId === aiQuestion.parentQuestionId);
+                    if (parentAIQuestion && checkConditions(parentAIQuestion.conditions, this.state.formData)) {
+                        // Injecter récursivement le parent d'abord
+                        injectQuestionRecursive(parentAIQuestion, processedIds);
+                    }
+                }
+                // Maintenant injecter cette question
+                processedIds.add(aiQuestion.questionId);
+                // Convertir en ModuleQuestion
+                const moduleQuestion = convertAIQuestionToModuleQuestion(aiQuestion);
+                // Vérifier si la question n'est pas déjà dans le module
+                if (existingModuleQuestionIds.has(aiQuestion.questionId)) {
+                    return;
+                }
+                // Ajouter au module
+                module.questions.push(moduleQuestion);
+                existingModuleQuestionIds.add(aiQuestion.questionId);
+                // Créer la question dans la queue
+                const queuedQuestion = {
+                    questionId: aiQuestion.questionId,
+                    moduleId: queuedModule.moduleId,
+                    text: aiQuestion.questionText,
+                    type: aiQuestion.questionType,
+                    status: "pending",
+                };
+                // Si parentQuestionId est défini, injecter après cette question
+                if (aiQuestion.parentQuestionId) {
+                    // Chercher dans la queue ET dans le module (pour les questions statiques)
+                    const queuedParentIndex = queuedModule.questions.findIndex(q => q.questionId === aiQuestion.parentQuestionId);
+                    // Si pas trouvé dans la queue, chercher dans le module (question statique)
+                    if (queuedParentIndex < 0) {
+                        const parentInModule = module.questions.find(q => q.id === aiQuestion.parentQuestionId);
+                        if (parentInModule) {
+                            // Trouver où insérer après la question statique dans la queue
+                            // Chercher la dernière question qui correspond à une question du module avant ou égale au parent
+                            let insertIndex = -1;
+                            for (let i = queuedModule.questions.length - 1; i >= 0; i--) {
+                                const q = queuedModule.questions[i];
+                                if (q.questionId === aiQuestion.parentQuestionId) {
+                                    insertIndex = i + 1;
+                                    break;
+                                }
+                                // Si on trouve une question qui vient avant le parent dans le module, insérer après
+                                const qInModule = module.questions.find(mq => mq.id === q.questionId);
+                                if (qInModule) {
+                                    // Vérifier si cette question vient avant le parent dans l'ordre du module
+                                    const parentIndex = module.questions.findIndex(mq => mq.id === aiQuestion.parentQuestionId);
+                                    const currentIndex = module.questions.findIndex(mq => mq.id === q.questionId);
+                                    if (currentIndex < parentIndex) {
+                                        insertIndex = i + 1;
+                                        break;
+                                    }
+                                }
+                            }
+                            if (insertIndex >= 0) {
+                                queuedModule.questions.splice(insertIndex, 0, queuedQuestion);
+                            }
+                            else {
+                                // Si on ne trouve pas où insérer, chercher la position après la question statique
+                                // en suivant le nextInModule
+                                const findInsertPosition = (parentId) => {
+                                    const parentQ = module.questions.find(q => q.id === parentId);
+                                    if (!parentQ || !parentQ.nextInModule) {
+                                        return queuedModule.questions.length;
+                                    }
+                                    // Chercher si nextInModule est déjà dans la queue
+                                    const nextIndex = queuedModule.questions.findIndex(q => q.questionId === parentQ.nextInModule);
+                                    if (nextIndex >= 0) {
+                                        return nextIndex;
+                                    }
+                                    // Sinon, chercher récursivement
+                                    return findInsertPosition(parentQ.nextInModule);
+                                };
+                                const insertPos = findInsertPosition(aiQuestion.parentQuestionId);
+                                queuedModule.questions.splice(insertPos, 0, queuedQuestion);
+                            }
+                            // Modifier le nextInModule de la question parente pour pointer vers la question IA
+                            if (parentInModule.nextInModule !== aiQuestion.questionId) {
+                                const originalNextInModule = parentInModule.nextInModule;
+                                parentInModule.nextInModule = aiQuestion.questionId;
+                                moduleQuestion.nextInModule = originalNextInModule;
+                            }
+                        }
+                        else {
+                            // Parent non trouvé (ni dans la queue, ni dans le module)
+                            // Essayer de trouver une position logique en cherchant la dernière question injectée
+                            // ou en cherchant une question statique qui pourrait être un parent logique
+                            // Si le parent est une question IA qui n'existe pas, chercher la dernière question IA injectée
+                            // ou la dernière question statique du module
+                            let insertIndex = queuedModule.questions.length;
+                            // Chercher la dernière question statique du module dans la queue
+                            for (let i = queuedModule.questions.length - 1; i >= 0; i--) {
+                                const q = queuedModule.questions[i];
+                                const qInModule = module.questions.find(mq => mq.id === q.questionId);
+                                if (qInModule && !allAIQuestions.find(aq => aq.questionId === q.questionId)) {
+                                    // C'est une question statique
+                                    insertIndex = i + 1;
+                                    break;
+                                }
+                            }
+                            // Si on n'a pas trouvé de question statique, chercher la dernière question IA injectée
+                            if (insertIndex === queuedModule.questions.length) {
+                                for (let i = queuedModule.questions.length - 1; i >= 0; i--) {
+                                    const q = queuedModule.questions[i];
+                                    if (allAIQuestions.find(aq => aq.questionId === q.questionId)) {
+                                        insertIndex = i + 1;
+                                        break;
+                                    }
+                                }
+                            }
+                            queuedModule.questions.splice(insertIndex, 0, queuedQuestion);
+                        }
+                    }
+                    else {
+                        // Parent trouvé dans la queue, insérer après
+                        queuedModule.questions.splice(queuedParentIndex + 1, 0, queuedQuestion);
+                        // Modifier le nextInModule de la question parente
+                        const parentQuestionInModule = module.questions.find(q => q.id === aiQuestion.parentQuestionId);
+                        if (parentQuestionInModule && parentQuestionInModule.nextInModule !== aiQuestion.questionId) {
+                            const originalNextInModule = parentQuestionInModule.nextInModule;
+                            parentQuestionInModule.nextInModule = aiQuestion.questionId;
+                            moduleQuestion.nextInModule = originalNextInModule;
+                        }
+                    }
+                }
+                else {
+                    // Si pas de parent, ajouter à la fin du module
+                    queuedModule.questions.push(queuedQuestion);
+                }
+                // Ajouter à la liste des questions existantes pour éviter les doublons
+                existingQuestionIds.add(aiQuestion.questionId);
+            };
+            // Traiter toutes les questions IA en respectant les dépendances
+            const processedIds = new Set();
+            for (const aiQuestion of aiQuestions) {
+                injectQuestionRecursive(aiQuestion, processedIds);
+            }
+        }
+        this.notifyListeners();
+    }
+    shouldHideModule(module) {
+        if (!module.triggers || module.triggers.length === 0)
+            return false;
+        for (const trigger of module.triggers) {
+            if (trigger.action.type === "hide_module" && this.evaluateModuleTrigger(trigger)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    evaluateModuleTrigger(trigger) {
+        const { condition } = trigger;
+        const value = this.state.formData[condition.questionId];
+        switch (condition.type) {
+            case "form_data_equals":
+                return value === condition.value;
+            case "form_data_contains":
+                return typeof value === "string" && value.includes(condition.value);
+            case "form_data_exists":
+                return value !== undefined && value !== null;
+            case "form_data_includes_any":
+                if (Array.isArray(value) && Array.isArray(condition.value)) {
+                    return condition.value.some((v) => value.includes(v));
+                }
+                return false;
+            default:
+                return false;
+        }
+    }
+    // =====================================================
+    // NAVIGATION
+    // =====================================================
+    activateFirstQuestion() {
+        const firstModule = this.state.queue.find((m) => m.status === "pending");
+        if (!firstModule) {
+            this.state.isComplete = true;
+            return;
+        }
+        firstModule.status = "active";
+        this.state.currentModuleId = firstModule.moduleId;
+        const module = this.modules.get(firstModule.moduleId);
+        if (module) {
+            this.state.currentQuestionId = module.entryQuestionId;
+            const queuedQuestion = firstModule.questions.find((q) => q.questionId === module.entryQuestionId);
+            if (queuedQuestion) {
+                queuedQuestion.status = "active";
+            }
+        }
+    }
+    getCurrentQuestion() {
+        if (!this.state.currentModuleId || !this.state.currentQuestionId) {
+            return null;
+        }
+        const module = this.modules.get(this.state.currentModuleId);
+        if (!module)
+            return null;
+        const question = module.questions.find((q) => q.id === this.state.currentQuestionId) || null;
+        if (!question)
+            return null;
+        // Récupérer les IDs système et comportements depuis la config
+        const systemIds = getSystemIds(this.config);
+        const behaviors = getSpecialBehaviors(this.config);
+        // Pour la question budget_priority, filtrer les options en fonction des prestataires déjà réservés
+        if (question.id === systemIds.budgetPriorityQuestionId && behaviors.budgetPriority.enabled) {
+            // Les options du module sont maintenant des clés i18n (ex: "intro_options.budget_priority_venue")
+            const loadedOptions = question.options && question.options.length > 0
+                ? question.options
+                : this.i18n.getQuestionOptions(question.id, 'fr');
+            // Traduire les options pour le filtrage
+            const translatedOptions = loadedOptions.map(opt => {
+                if (opt.includes('.') && !opt.includes(' ')) {
+                    return this.i18n.t(opt, undefined, 'fr');
+                }
+                return opt;
+            });
+            const bookedProviders = this.state.formData.booked_providers;
+            if (bookedProviders && bookedProviders.length > 0 && translatedOptions.length > 0 && behaviors.budgetPriority.filterOptionsByBookedProviders) {
+                // Récupérer le mapping priorité -> prestataires depuis la config
+                const priorityToBookedProviders = getPriorityToBookedProviders(this.config);
+                // Filtrer les options traduites
+                const filteredTranslatedOptions = translatedOptions.filter((translatedOpt, index) => {
+                    // Récupérer les prestataires correspondants à cette priorité (utilise les valeurs traduites)
+                    const relatedProviders = priorityToBookedProviders[translatedOpt] || [];
+                    // Vérifier si AU MOINS UN prestataire de cette catégorie est déjà réservé
+                    if (relatedProviders.length === 0) {
+                        // Pas de prestataire associé (ex: "Les tenues"), on garde l'option
+                        return true;
+                    }
+                    // Si au moins un prestataire de cette catégorie est réservé, on exclut l'option
+                    const hasBookedProvider = relatedProviders.some(provider => bookedProviders.includes(provider));
+                    return !hasBookedProvider;
+                });
+                // Retourner les clés i18n correspondantes aux options traduites filtrées
+                const filteredOptions = filteredTranslatedOptions.map(translatedOpt => {
+                    // Trouver la clé i18n correspondante dans loadedOptions
+                    const originalKeyIndex = translatedOptions.findIndex(opt => opt === translatedOpt);
+                    return originalKeyIndex >= 0 ? loadedOptions[originalKeyIndex] : translatedOpt;
+                });
+                // Retourner les options filtrées (clés i18n) - elles seront traduites dans enrichQuestionWithTranslations
+                return Object.assign(Object.assign({}, question), { options: filteredOptions });
+            }
+            else if (loadedOptions.length > 0) {
+                // Si pas de prestataires réservés, retourner avec les options chargées (clés i18n)
+                return Object.assign(Object.assign({}, question), { options: loadedOptions });
+            }
+        }
+        // Pour la question contact_correction, déterminer dynamiquement le type (email ou phone)
+        if (question.id === systemIds.contactCorrectionQuestionId && behaviors.contactCorrection.enabled) {
+            const contactIntro = this.state.formData.contact_intro;
+            const contactEmail = this.state.formData.contact_email;
+            const detectEmailFrom = behaviors.contactCorrection.detectEmailFrom;
+            const isEmail = detectEmailFrom.some(key => contactIntro === key) || contactEmail !== undefined;
+            // Modifier le type de question selon le mode de contact
+            return Object.assign(Object.assign({}, question), { type: isEmail ? "email" : "phone" });
+        }
+        return question;
+    }
+    getCurrentModule() {
+        if (!this.state.currentModuleId)
+            return null;
+        return this.modules.get(this.state.currentModuleId) || null;
+    }
+    getModuleById(moduleId) {
+        return this.modules.get(moduleId) || null;
+    }
+    // Vérifie si une question has_* doit être sautée (on a déjà l'info depuis l'intro)
+    // Retourne: { shouldSkip: boolean, isBooked: boolean } 
+    checkHasQuestionSkip(questionId, moduleId) {
+        // Vérifier si on a posé la question booked_providers
+        const bookedProviders = this.state.formData.booked_providers;
+        // Si booked_providers n'a pas encore été répondu, ne pas sauter
+        if (bookedProviders === undefined) {
+            return { shouldSkip: false, isBooked: false };
+        }
+        // Chercher si ce module/question correspond à un prestataire dans le mapping
+        const bookedProviderMappings = getBookedProviderMappings(this.config);
+        for (const [providerName, mapping] of Object.entries(bookedProviderMappings)) {
+            if (mapping.moduleId === moduleId && mapping.skipQuestion === questionId) {
+                // On a trouvé le mapping, donc on doit sauter cette question
+                // isBooked = true si le prestataire est dans la liste des réservés
+                // (et n'est pas "Aucun pour l'instant")
+                const isBooked = bookedProviders.includes(providerName) && !bookedProviders.includes("Aucun pour l'instant");
+                return { shouldSkip: true, isBooked };
+            }
+        }
+        return { shouldSkip: false, isBooked: false };
+    }
+    // Récupère l'ID de la question suivante selon la branche choisie
+    getSkipDestination(question, branch) {
+        // Si la question a une navigation conditionnelle, aller vers la branche appropriée
+        if (question.conditionalNextInModule && question.conditionalNextInModule[branch]) {
+            return question.conditionalNextInModule[branch];
+        }
+        return question.nextInModule || null;
+    }
+    // =====================================================
+    // SOUMISSION DE RÉPONSE
+    // =====================================================
+    async submitAnswer(answer) {
+        const currentQuestion = this.getCurrentQuestion();
+        const currentModule = this.getCurrentModule();
+        if (!currentQuestion || !currentModule) {
+            return null;
+        }
+        // Reset le flag de double avancement
+        this.advancedByTrigger = false;
+        // Enregistrer la réponse
+        this.state.formData[currentQuestion.id] = answer;
+        // Récupérer les IDs système et comportements depuis la config
+        const systemIds = getSystemIds(this.config);
+        const behaviors = getSpecialBehaviors(this.config);
+        // Si c'est la question contact_correction, mettre à jour contact_email ou contact_phone selon le mode
+        if (currentQuestion.id === systemIds.contactCorrectionQuestionId && behaviors.contactCorrection.enabled) {
+            const contactIntro = this.state.formData.contact_intro;
+            const contactEmail = this.state.formData.contact_email;
+            const detectEmailFrom = behaviors.contactCorrection.detectEmailFrom;
+            const isEmail = detectEmailFrom.some(key => contactIntro === key) || contactEmail !== undefined;
+            if (isEmail) {
+                // Mettre à jour l'email
+                this.state.formData.contact_email = answer;
+            }
+            else {
+                // Mettre à jour le téléphone
+                this.state.formData.contact_phone = answer;
+            }
+        }
+        // Après avoir enregistré la réponse, injecter les questions IA depuis le cache
+        // qui pourraient maintenant correspondre aux nouvelles conditions
+        this.injectAIQuestionsFromCache();
+        // Marquer la question comme complétée dans la queue
+        const queuedModule = this.state.queue.find((m) => m.moduleId === currentModule.id);
+        if (queuedModule) {
+            const queuedQuestion = queuedModule.questions.find((q) => q.questionId === currentQuestion.id);
+            if (queuedQuestion) {
+                queuedQuestion.status = "completed";
+                queuedQuestion.answer = answer;
+                queuedQuestion.answeredAt = new Date();
+            }
+        }
+        // Ajouter aux questions répondues
+        this.state.answeredQuestions.push({
+            questionId: currentQuestion.id,
+            moduleId: currentModule.id,
+            moduleName: currentModule.name,
+            text: currentQuestion.text,
+            answer,
+            answeredAt: new Date(),
+        });
+        // Exécuter les triggers de la question
+        if (currentQuestion.onAnswer) {
+            this.executeQuestionTriggers(currentQuestion.onAnswer, answer);
+        }
+        // Si la question a des sous-questions à générer (multiselect avec prestataires multiples)
+        let firstSubQuestionId = null;
+        if (currentQuestion.generateSubQuestionsFor && Array.isArray(answer) && answer.length > 0) {
+            firstSubQuestionId = this.generateDynamicSubQuestions(currentModule, currentQuestion, answer, queuedModule);
+        }
+        // Si la question est de type "info" avec generateSubQuestionsFromFormData, 
+        // générer les sous-questions à partir des données du formulaire
+        if (currentQuestion.type === "info" &&
+            currentQuestion.generateSubQuestionsFromFormData &&
+            currentQuestion.subQuestionTemplates) {
+            const sourceData = this.state.formData[currentQuestion.generateSubQuestionsFromFormData];
+            if (Array.isArray(sourceData) && sourceData.length > 0) {
+                // Filtrer "Aucun pour l'instant" si présent
+                const filteredItems = sourceData.filter((item) => item !== "Aucun pour l'instant");
+                if (filteredItems.length > 0) {
+                    firstSubQuestionId = this.generateSubQuestionsFromFormData(currentModule, currentQuestion, filteredItems, queuedModule);
+                }
+            }
+        }
+        // Si des sous-questions ont été générées, naviguer vers la première
+        if (firstSubQuestionId) {
+            this.state.currentQuestionId = firstSubQuestionId;
+            const nextQueuedQuestion = queuedModule === null || queuedModule === void 0 ? void 0 : queuedModule.questions.find((q) => q.questionId === firstSubQuestionId);
+            if (nextQueuedQuestion) {
+                nextQueuedQuestion.status = "active";
+            }
+            this.notifyListeners();
+            return this.getCurrentQuestion();
+        }
+        // Sinon, déterminer la prochaine question normalement
+        const nextQuestionId = this.getNextQuestionId(currentQuestion, answer);
+        if (nextQuestionId === null) {
+            // Fin du module - Si c'est la question de priorité, appliquer la réorganisation
+            if (currentQuestion.id === systemIds.budgetPriorityQuestionId &&
+                Array.isArray(answer) &&
+                behaviors.budgetPriority.enabled) {
+                this.applyPriorityOrder(answer);
+                // Marquer le module intro comme complété
+                if (queuedModule) {
+                    queuedModule.status = "completed";
+                }
+                // Notifier pour mettre à jour la visualisation
+                this.notifyListeners();
+            }
+            // Si c'est la question continue_other_sectors_question et que la réponse est "non"
+            // Sauter directement au module final
+            if (currentQuestion.id === systemIds.continueOtherSectorsQuestionId &&
+                behaviors.continueOtherSectors.enabled &&
+                behaviors.continueOtherSectors.skipToFinalOnNo) {
+                // Détecter la réponse "non" : boolean false, string "non" ou "false"
+                const isNo = answer === false ||
+                    (typeof answer === "string" && (answer.toLowerCase() === "non" || answer.toLowerCase() === "false"));
+                if (isNo) {
+                    // Trouver le module final
+                    const finalModule = this.state.queue.find((m) => m.moduleId === systemIds.finalModuleId);
+                    if (finalModule) {
+                        // Marquer continue_other_sectors comme complété
+                        if (queuedModule) {
+                            queuedModule.status = "completed";
+                            this.state.completedModules.push(queuedModule.moduleId);
+                        }
+                        // Marquer tous les modules non prioritaires comme skippés
+                        const skipPriority = behaviors.continueOtherSectors.skipModulesWithPriority;
+                        this.state.queue.forEach((m) => {
+                            if (m.effectivePriority >= skipPriority &&
+                                m.moduleId !== systemIds.finalModuleId &&
+                                m.moduleId !== systemIds.continueOtherSectorsModuleId) {
+                                m.status = "skipped";
+                                this.state.skippedModules.push(m.moduleId);
+                            }
+                        });
+                        // Activer le module final
+                        finalModule.status = "active";
+                        this.state.currentModuleId = finalModule.moduleId;
+                        const finalModuleDef = this.modules.get(systemIds.finalModuleId);
+                        if (finalModuleDef) {
+                            this.state.currentQuestionId = finalModuleDef.entryQuestionId;
+                            const queuedQuestion = finalModule.questions.find((q) => q.questionId === finalModuleDef.entryQuestionId);
+                            if (queuedQuestion) {
+                                queuedQuestion.status = "active";
+                            }
+                            // S'assurer que le module est bien dans la queue et que la question existe
+                            this.notifyListeners();
+                            const currentQuestion = this.getCurrentQuestion();
+                            if (currentQuestion) {
+                                return currentQuestion;
+                            }
+                        }
+                        // Si on arrive ici, il y a un problème - essayer d'avancer normalement
+                        return this.advanceToNextModule();
+                    }
+                }
+            }
+            // Passer au suivant (qui sera maintenant le module priorisé)
+            // Mais seulement si un trigger n'a pas déjà fait avancer
+            if (this.advancedByTrigger) {
+                this.notifyListeners();
+                return this.getCurrentQuestion();
+            }
+            return this.advanceToNextModule();
+        }
+        // Naviguer vers la prochaine question dans le module
+        this.state.currentQuestionId = nextQuestionId;
+        const nextQueuedQuestion = queuedModule === null || queuedModule === void 0 ? void 0 : queuedModule.questions.find((q) => q.questionId === nextQuestionId);
+        if (nextQueuedQuestion) {
+            nextQueuedQuestion.status = "active";
+        }
+        this.notifyListeners();
+        return this.getCurrentQuestion();
+    }
+    generateDynamicSubQuestions(module, parentQuestion, selectedItems, queuedModule) {
+        if (!parentQuestion.generateSubQuestionsFor || !queuedModule)
+            return null;
+        // Trouver l'index de la question parente dans la queue
+        const parentIndex = queuedModule.questions.findIndex((q) => q.questionId === parentQuestion.id);
+        if (parentIndex === -1)
+            return null;
+        const subQuestions = [];
+        const dynamicModuleQuestions = [];
+        // Vérifier si l'utilisateur veut la coordination
+        const wantsCoordination = this.state.formData.aimi_coordination === "oui";
+        const hasExistingProviders = this.state.formData.has_existing_providers === "oui";
+        const shouldAskContact = wantsCoordination && hasExistingProviders;
+        // Filtrer les templates : exclure provider_contact si pas de coordination
+        const filteredTemplates = parentQuestion.generateSubQuestionsFor.filter(template => {
+            if (template.id === "provider_contact" && !shouldAskContact) {
+                return false;
+            }
+            return true;
+        });
+        // Pour chaque élément sélectionné, générer les sous-questions
+        selectedItems.forEach((item, itemIndex) => {
+            filteredTemplates.forEach((template, templateIndex) => {
+                // ID unique pour la sous-question générée
+                const subQuestionId = `${parentQuestion.id}_${template.id}_${itemIndex}`;
+                // Traduire le template puis remplacer {item}
+                // Le template peut être une clé i18n (ex: "intro_templates.provider_name")
+                let translatedTemplate = template.textTemplate;
+                if (template.textTemplate.includes('.') && !template.textTemplate.includes(' ')) {
+                    // C'est une clé i18n, on la traduit d'abord
+                    translatedTemplate = this.i18n.t(template.textTemplate, undefined, 'fr');
+                }
+                // Remplacer {item} dans le template traduit
+                const text = translatedTemplate.replace("{item}", item);
+                // Traduire le placeholder si c'est une clé i18n
+                let translatedPlaceholder = template.placeholder;
+                if (template.placeholder && template.placeholder.includes('.') && !template.placeholder.includes(' ')) {
+                    translatedPlaceholder = this.i18n.t(template.placeholder, undefined, 'fr');
+                }
+                // Déterminer la prochaine question
+                let nextInModule = null;
+                const nextItemIndex = itemIndex + 1;
+                const hasNextItem = nextItemIndex < selectedItems.length;
+                // Récupérer la destination après les sous-questions (depuis la question parente)
+                const finalDestination = parentQuestion.nextInModule || null;
+                if (template.id === "provider_name") {
+                    // Après le nom, aller vers contact (si coordination) ou prochain prestataire
+                    if (shouldAskContact) {
+                        nextInModule = `${parentQuestion.id}_provider_contact_${itemIndex}`;
+                    }
+                    else {
+                        nextInModule = hasNextItem
+                            ? `${parentQuestion.id}_provider_name_${nextItemIndex}`
+                            : finalDestination;
+                    }
+                }
+                else if (template.id === "provider_contact") {
+                    // Après le contact, passer au prochain prestataire ou destination finale
+                    nextInModule = hasNextItem
+                        ? `${parentQuestion.id}_provider_name_${nextItemIndex}`
+                        : finalDestination;
+                }
+                // Créer la question dynamique
+                const dynamicQuestion = {
+                    id: subQuestionId,
+                    text,
+                    type: template.type,
+                    placeholder: translatedPlaceholder,
+                    isRequired: template.isRequired,
+                    nextInModule,
+                };
+                // Ajouter à la liste des questions du module
+                dynamicModuleQuestions.push(dynamicQuestion);
+                // Ajouter à la queue
+                subQuestions.push({
+                    questionId: subQuestionId,
+                    moduleId: module.id,
+                    text,
+                    type: template.type,
+                    status: "pending",
+                    isDynamic: true,
+                    parentQuestionId: parentQuestion.id,
+                });
+            });
+        });
+        // Ajouter les questions dynamiques au module
+        module.questions.push(...dynamicModuleQuestions);
+        // Insérer les sous-questions après la question parente
+        queuedModule.questions.splice(parentIndex + 1, 0, ...subQuestions);
+        // Retourner l'ID de la première sous-question générée
+        return subQuestions.length > 0 ? subQuestions[0].questionId : null;
+    }
+    // Génère des sous-questions à partir des données du formulaire (pour les questions "info")
+    generateSubQuestionsFromFormData(module, parentQuestion, selectedItems, queuedModule) {
+        if (!parentQuestion.subQuestionTemplates || !queuedModule)
+            return null;
+        // Trouver l'index de la question parente dans la queue
+        const parentIndex = queuedModule.questions.findIndex((q) => q.questionId === parentQuestion.id);
+        if (parentIndex === -1)
+            return null;
+        const subQuestions = [];
+        const dynamicModuleQuestions = [];
+        // Récupérer la destination après les sous-questions
+        const finalDestination = parentQuestion.nextInModule || null;
+        // Pour chaque élément sélectionné, générer les sous-questions
+        selectedItems.forEach((item, itemIndex) => {
+            parentQuestion.subQuestionTemplates.forEach((template, templateIndex) => {
+                // ID unique pour la sous-question générée
+                const subQuestionId = `${parentQuestion.id}_${template.id}_${itemIndex}`;
+                // Traduire le template puis remplacer {item}
+                // Le template peut être une clé i18n (ex: "intro_templates.provider_name")
+                let translatedTemplate = template.textTemplate;
+                if (template.textTemplate.includes('.') && !template.textTemplate.includes(' ')) {
+                    // C'est une clé i18n, on la traduit d'abord
+                    translatedTemplate = this.i18n.t(template.textTemplate, undefined, 'fr');
+                }
+                // Remplacer {item} dans le template traduit (item est déjà traduit depuis booked_providers)
+                const text = translatedTemplate.replace("{item}", item.toLowerCase());
+                // Traduire le placeholder si c'est une clé i18n
+                let translatedPlaceholder = template.placeholder;
+                if (template.placeholder && template.placeholder.includes('.') && !template.placeholder.includes(' ')) {
+                    translatedPlaceholder = this.i18n.t(template.placeholder, undefined, 'fr');
+                }
+                // Déterminer la prochaine question
+                let nextInModule = null;
+                const nextItemIndex = itemIndex + 1;
+                const hasNextItem = nextItemIndex < selectedItems.length;
+                const nextTemplateIndex = templateIndex + 1;
+                const hasNextTemplate = nextTemplateIndex < parentQuestion.subQuestionTemplates.length;
+                if (hasNextTemplate) {
+                    // Aller vers le prochain template pour le même item
+                    nextInModule = `${parentQuestion.id}_${parentQuestion.subQuestionTemplates[nextTemplateIndex].id}_${itemIndex}`;
+                }
+                else if (hasNextItem) {
+                    // Aller vers le premier template du prochain item
+                    nextInModule = `${parentQuestion.id}_${parentQuestion.subQuestionTemplates[0].id}_${nextItemIndex}`;
+                }
+                else {
+                    // Fin des sous-questions, aller vers la destination finale
+                    nextInModule = finalDestination;
+                }
+                // Créer la question dynamique
+                const dynamicQuestion = {
+                    id: subQuestionId,
+                    text,
+                    type: template.type,
+                    placeholder: translatedPlaceholder,
+                    isRequired: template.isRequired,
+                    nextInModule,
+                };
+                // Ajouter à la liste des questions du module
+                dynamicModuleQuestions.push(dynamicQuestion);
+                // Ajouter à la queue
+                subQuestions.push({
+                    questionId: subQuestionId,
+                    moduleId: module.id,
+                    text,
+                    type: template.type,
+                    status: "pending",
+                    isDynamic: true,
+                    parentQuestionId: parentQuestion.id,
+                });
+            });
+        });
+        // Ajouter les questions dynamiques au module
+        module.questions.push(...dynamicModuleQuestions);
+        // Insérer les sous-questions après la question parente
+        queuedModule.questions.splice(parentIndex + 1, 0, ...subQuestions);
+        // Retourner l'ID de la première sous-question générée
+        return subQuestions.length > 0 ? subQuestions[0].questionId : null;
+    }
+    getNextQuestionId(question, answer) {
+        // Vérifier la navigation conditionnelle
+        if (question.conditionalNextInModule) {
+            const answerKey = typeof answer === "boolean"
+                ? (answer ? "oui" : "non")
+                : String(answer).toLowerCase();
+            if (answerKey in question.conditionalNextInModule) {
+                return question.conditionalNextInModule[answerKey];
+            }
+            // Essayer avec la valeur exacte
+            if (String(answer) in question.conditionalNextInModule) {
+                return question.conditionalNextInModule[String(answer)];
+            }
+        }
+        // Navigation par défaut
+        let nextId = question.nextInModule !== undefined ? question.nextInModule : null;
+        // Si la prochaine question est une question de contact (*_contact), 
+        // vérifier si l'utilisateur a accepté la coordination
+        if (nextId && nextId.endsWith("_contact")) {
+            const wantsCoordination = this.state.formData.aimi_coordination === "oui";
+            const hasExistingProviders = this.state.formData.has_existing_providers === "oui";
+            // Si l'utilisateur n'a pas accepté la coordination ou n'a pas de prestataires existants,
+            // on saute la question de contact (fin du module ou branche)
+            if (!wantsCoordination || !hasExistingProviders) {
+                return null;
+            }
+        }
+        return nextId;
+    }
+    advanceToNextModule() {
+        var _a;
+        // Récupérer le module actuel avant de le marquer comme complété
+        const currentQueuedModule = this.state.queue.find((m) => m.moduleId === this.state.currentModuleId);
+        // Stocker l'ID du module qui se termine pour les messages de transition
+        const completedModuleId = (currentQueuedModule === null || currentQueuedModule === void 0 ? void 0 : currentQueuedModule.moduleId) || null;
+        // Marquer le module actuel comme complété
+        if (currentQueuedModule) {
+            currentQueuedModule.status = "completed";
+            this.state.completedModules.push(currentQueuedModule.moduleId);
+        }
+        // Recalculer la queue (pour appliquer les changements de priorité)
+        this.recalculateQueue();
+        // Détecter si on passe des modules prioritaires aux modules non prioritaires
+        // Les modules prioritaires ont une priorité négative (< 0), les autres ont une priorité positive (>= 0)
+        const currentModule = currentQueuedModule ? this.modules.get(currentQueuedModule.moduleId) : null;
+        const currentPriority = (_a = currentQueuedModule === null || currentQueuedModule === void 0 ? void 0 : currentQueuedModule.effectivePriority) !== null && _a !== void 0 ? _a : 0;
+        // Récupérer les IDs système et comportements depuis la config
+        const systemIds = getSystemIds(this.config);
+        const behaviors = getSpecialBehaviors(this.config);
+        // Trouver le prochain module en attente
+        const nextModule = this.state.queue.find((m) => m.status === "pending" && !this.state.hiddenModules.includes(m.moduleId));
+        // Si on passe d'un module prioritaire (priorité < 0) à un module non prioritaire (priorité >= 0)
+        // ET que le module continue_other_sectors n'a pas encore été complété
+        // Alors insérer le module continue_other_sectors
+        if (nextModule &&
+            currentPriority < 0 &&
+            nextModule.effectivePriority >= 0 &&
+            behaviors.continueOtherSectors.enabled &&
+            behaviors.continueOtherSectors.insertBetweenPriorityAndNonPriority) {
+            const continueModule = this.state.queue.find((m) => m.moduleId === systemIds.continueOtherSectorsModuleId &&
+                !this.state.completedModules.includes(systemIds.continueOtherSectorsModuleId));
+            if (continueModule && continueModule.status === "pending") {
+                // Insérer le module continue_other_sectors avant les modules non prioritaires
+                nextModule.status = "pending"; // Remettre en pending
+                continueModule.status = "active";
+                this.state.currentModuleId = continueModule.moduleId;
+                const continueModuleDef = this.modules.get(continueModule.moduleId);
+                if (continueModuleDef) {
+                    this.state.currentQuestionId = continueModuleDef.entryQuestionId;
+                    const queuedQuestion = continueModule.questions.find((q) => q.questionId === continueModuleDef.entryQuestionId);
+                    if (queuedQuestion) {
+                        queuedQuestion.status = "active";
+                    }
+                }
+                this.notifyListeners();
+                return this.getCurrentQuestion();
+            }
+        }
+        if (!nextModule) {
+            this.state.isComplete = true;
+            this.state.currentModuleId = null;
+            this.state.currentQuestionId = null;
+            this.notifyListeners();
+            return null;
+        }
+        // Activer le prochain module
+        nextModule.status = "active";
+        this.state.currentModuleId = nextModule.moduleId;
+        const module = this.modules.get(nextModule.moduleId);
+        if (module) {
+            let entryQuestionId = module.entryQuestionId;
+            const entryQuestion = module.questions.find(q => q.id === entryQuestionId);
+            // Vérifier si le module doit être skippé (prestataire déjà réservé)
+            const { isBooked } = this.checkHasQuestionSkip(entryQuestionId, module.id);
+            // Si le prestataire est déjà réservé, on skip TOUT le module
+            // car les coordonnées ont déjà été collectées dans l'intro (booked_providers_contact_intro)
+            if (isBooked) {
+                // Marquer le module comme skippé
+                nextModule.status = "skipped";
+                this.state.skippedModules.push(nextModule.moduleId);
+                // Marquer toutes les questions comme skippées
+                nextModule.questions.forEach(q => {
+                    q.status = "skipped";
+                });
+                // Passer au module suivant
+                return this.advanceToNextModule();
+            }
+            this.state.currentQuestionId = entryQuestionId;
+            const queuedQuestion = nextModule.questions.find((q) => q.questionId === entryQuestionId);
+            if (queuedQuestion) {
+                queuedQuestion.status = "active";
+            }
+            // Stocker les informations de transition pour les messages
+            // Ces informations seront utilisées dans le hook pour afficher les messages de transition
+            // Ne pas afficher de transition pour les modules exclus
+            // IMPORTANT: transitionInfo est réinitialisé à null après utilisation dans le hook
+            const excludeModules = behaviors.transitions.excludeModules;
+            if (completedModuleId &&
+                !excludeModules.includes(completedModuleId) &&
+                !excludeModules.includes(nextModule.moduleId)) {
+                // Ne créer transitionInfo que s'il n'existe pas déjà (éviter les duplications)
+                if (!this.state.transitionInfo) {
+                    this.state.transitionInfo = {
+                        completedModuleId,
+                        startingModuleId: nextModule.moduleId
+                    };
+                }
+            }
+            else {
+                this.state.transitionInfo = null;
+            }
+        }
+        this.notifyListeners();
+        return this.getCurrentQuestion();
+    }
+    // =====================================================
+    // TRIGGERS
+    // =====================================================
+    executeQuestionTriggers(triggers, answer) {
+        for (const trigger of triggers) {
+            if (this.evaluateQuestionTrigger(trigger, answer)) {
+                this.executeAction(trigger.action);
+            }
+        }
+    }
+    evaluateQuestionTrigger(trigger, answer) {
+        const { condition } = trigger;
+        switch (condition.type) {
+            case "answer_equals":
+                return answer === condition.value ||
+                    (typeof answer === "boolean" &&
+                        ((answer && condition.value === "oui") ||
+                            (!answer && condition.value === "non")));
+            case "answer_not_equals":
+                return answer !== condition.value;
+            case "answer_contains":
+                return typeof answer === "string" &&
+                    answer.toLowerCase().includes(condition.value.toLowerCase());
+            case "answer_exists":
+                return answer !== undefined && answer !== null && answer !== "";
+            case "answer_includes_any":
+                if (Array.isArray(answer) && Array.isArray(condition.value)) {
+                    return condition.value.some((v) => answer.map(a => a.toLowerCase()).includes(v.toLowerCase()));
+                }
+                return false;
+            default:
+                return false;
+        }
+    }
+    executeAction(action) {
+        switch (action.type) {
+            case "hide_module":
+                if (action.targetModuleId && !this.state.hiddenModules.includes(action.targetModuleId)) {
+                    this.state.hiddenModules.push(action.targetModuleId);
+                    // Mettre à jour le statut dans la queue
+                    const queuedModule = this.state.queue.find(m => m.moduleId === action.targetModuleId);
+                    if (queuedModule && queuedModule.status === "pending") {
+                        queuedModule.status = "hidden";
+                    }
+                }
+                break;
+            case "show_module":
+                if (action.targetModuleId) {
+                    this.state.hiddenModules = this.state.hiddenModules.filter((id) => id !== action.targetModuleId);
+                    const queuedModule = this.state.queue.find(m => m.moduleId === action.targetModuleId);
+                    if (queuedModule && queuedModule.status === "hidden") {
+                        queuedModule.status = "pending";
+                    }
+                }
+                break;
+            case "set_priority":
+                if (action.targetModuleId && action.newPriority !== undefined) {
+                    const queuedModule = this.state.queue.find((m) => m.moduleId === action.targetModuleId);
+                    if (queuedModule) {
+                        queuedModule.effectivePriority = action.newPriority;
+                    }
+                }
+                break;
+            case "skip_to_end":
+                // Marquer toutes les questions restantes du module comme skipped
+                const currentQueuedModule = this.state.queue.find((m) => m.moduleId === this.state.currentModuleId);
+                if (currentQueuedModule) {
+                    currentQueuedModule.questions.forEach((q) => {
+                        if (q.status === "pending") {
+                            q.status = "skipped";
+                        }
+                    });
+                }
+                // Avancer au module suivant et marquer qu'on l'a déjà fait
+                this.advancedByTrigger = true;
+                this.advanceToNextModule();
+                break;
+        }
+    }
+    // =====================================================
+    // PRIORITÉ UTILISATEUR
+    // =====================================================
+    applyUserPriority(priority) {
+        const priorityBoosts = getPriorityBoosts(this.config);
+        const boosts = priorityBoosts[priority];
+        if (!boosts)
+            return;
+        for (const boost of boosts) {
+            const queuedModule = this.state.queue.find((m) => m.moduleId === boost.moduleId);
+            if (queuedModule && queuedModule.status === "pending") {
+                const module = this.modules.get(boost.moduleId);
+                if (module && !module.isFixed) {
+                    queuedModule.effectivePriority = module.basePriority + boost.boost;
+                }
+            }
+        }
+        this.recalculateQueue();
+        this.notifyListeners();
+    }
+    recalculateQueue() {
+        // Réévaluer les modules cachés
+        this.modules.forEach((module) => {
+            if (module.triggers) {
+                for (const trigger of module.triggers) {
+                    if (this.evaluateModuleTrigger(trigger)) {
+                        this.executeAction(trigger.action);
+                    }
+                }
+            }
+        });
+        // Trier par priorité effective (ne pas toucher aux modules complétés/actifs)
+        const completed = this.state.queue.filter((m) => m.status === "completed" || m.status === "active");
+        const pending = this.state.queue.filter((m) => m.status === "pending" || m.status === "hidden");
+        pending.sort((a, b) => a.effectivePriority - b.effectivePriority);
+        this.state.queue = [...completed, ...pending];
+    }
+    // =====================================================
+    // GETTERS
+    // =====================================================
+    getState() {
+        return Object.assign({}, this.state);
+    }
+    getFormData() {
+        return Object.assign({}, this.state.formData);
+    }
+    getAnsweredQuestions() {
+        return [...this.state.answeredQuestions];
+    }
+    getProgress() {
+        const totalQuestions = this.state.queue.reduce((acc, m) => acc + (m.status !== "hidden" ? m.questions.length : 0), 0);
+        const answeredCount = this.state.answeredQuestions.length;
+        return {
+            current: answeredCount,
+            total: totalQuestions,
+            percent: totalQuestions > 0 ? Math.round((answeredCount / totalQuestions) * 100) : 0,
+        };
+    }
+    getCurrentModuleName() {
+        const module = this.getCurrentModule();
+        return (module === null || module === void 0 ? void 0 : module.name) || "En cours...";
+    }
+    isComplete() {
+        return this.state.isComplete;
+    }
+    // =====================================================
+    // APPLICATION DES PRIORITÉS
+    // =====================================================
+    applyPriorityOrder(priorityOrder) {
+        // Créer un mapping de priorités: plus haut dans la liste = priorité plus élevée
+        // On utilise des valeurs négatives où plus négatif = plus prioritaire
+        const priorityMappings = getPriorityMappings(this.config);
+        const calc = getPriorityCalculation(this.config);
+        priorityOrder.forEach((priority, index) => {
+            const moduleIds = priorityMappings[priority];
+            if (!moduleIds)
+                return;
+            // Calculer la priorité selon la config
+            const newPriority = calc.base + (index * calc.step);
+            // Appliquer la nouvelle priorité à tous les modules concernés
+            moduleIds.forEach((moduleId) => {
+                const queuedModule = this.state.queue.find((m) => m.moduleId === moduleId);
+                if (queuedModule) {
+                    queuedModule.effectivePriority = newPriority;
+                }
+            });
+        });
+        // Retrier la queue selon les nouvelles priorités
+        this.state.queue.sort((a, b) => {
+            // Les modules fixes restent en place
+            const moduleA = this.modules.get(a.moduleId);
+            const moduleB = this.modules.get(b.moduleId);
+            if ((moduleA === null || moduleA === void 0 ? void 0 : moduleA.isFixed) && !(moduleB === null || moduleB === void 0 ? void 0 : moduleB.isFixed))
+                return -1;
+            if (!(moduleA === null || moduleA === void 0 ? void 0 : moduleA.isFixed) && (moduleB === null || moduleB === void 0 ? void 0 : moduleB.isFixed))
+                return 1;
+            if ((moduleA === null || moduleA === void 0 ? void 0 : moduleA.isFixed) && (moduleB === null || moduleB === void 0 ? void 0 : moduleB.isFixed)) {
+                return a.effectivePriority - b.effectivePriority;
+            }
+            return a.effectivePriority - b.effectivePriority;
+        });
+    }
+    // =====================================================
+    // LISTENERS (pour la réactivité)
+    // =====================================================
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    notifyListeners() {
+        const state = this.getState();
+        this.listeners.forEach((listener) => listener(state));
+    }
+}
+// Instance singleton
+let engineInstance = null;
+export function getQuestionEngine(i18n) {
+    if (!engineInstance) {
+        engineInstance = new QuestionEngine(i18n);
+    }
+    return engineInstance;
+}
+export function resetQuestionEngine(i18n) {
+    engineInstance = new QuestionEngine(i18n);
+    return engineInstance;
+}