@rsuci/shared-form-components 1.0.15 → 1.0.17

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/lib/roster-condition-engine.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Moteur d'évaluation des conditions scopées pour les variables ROSTER
+ * RSU v2 - Moteur de Rendu des Formulaires d'Enquête
+ *
+ * Ce moteur est ISOLÉ du ConditionEngine principal.
+ * Les conditions sont évaluées PAR LIGNE (par option de roster) indépendamment.
+ * Le scope est limité aux variables du même ROSTER uniquement.
+ */
+export type RosterConditionErrorType = 'variable_not_in_scope' | 'jump_out_of_scope' | 'backward_jump' | 'self_reference' | 'syntax_error';
+export interface RosterConditionError {
+    type: RosterConditionErrorType;
+    variableCode: string;
+    message: string;
+}
+export interface RosterConditionValidationResult {
+    isValid: boolean;
+    errors: RosterConditionError[];
+}
+export interface RosterVariableRef {
+    code: string;
+    ordre: number;
+}
+/**
+ * Moteur de conditions scopées pour les ROSTER
+ * Toutes les méthodes sont statiques pour une utilisation sans état
+ */
+export declare class RosterConditionEngine {
+    /**
+     * Valide une condition au moment du design (admin)
+     * Vérifie que les références sont dans le scope et que les jumps sont valides
+     */
+    static validateCondition(condition: string, availableVariables: RosterVariableRef[], currentVariableCode: string, currentVariableOrdre: number): RosterConditionValidationResult;
+    /**
+     * Évalue une condition au runtime (rendu)
+     * Utilise les valeurs de la ligne courante du roster
+     */
+    static evaluate(condition: string, lineValues: Record<string, any>): boolean;
+    /**
+     * Extrait toutes les références de variables d'une condition
+     * Format: ${VAR_CODE}
+     */
+    static extractVariableReferences(condition: string): string[];
+    /**
+     * Extrait la cible d'un jump s'il existe dans la condition
+     * Format: jump(condition, ${TARGET})
+     */
+    static extractJumpTarget(condition: string): string | null;
+    /**
+     * Calcule les variables qui doivent être masquées à cause des jumps actifs
+     */
+    static computeJumpedVariables(sortedVariables: RosterVariableRef[], lineValues: Record<string, any>): Set<string>;
+    /**
+     * Valide la syntaxe de base d'une condition
+     */
+    private static validateSyntax;
+}
+//# sourceMappingURL=roster-condition-engine.d.ts.map

package/dist/lib/roster-condition-engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roster-condition-engine.d.ts","sourceRoot":"","sources":["../../src/lib/roster-condition-engine.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,MAAM,MAAM,wBAAwB,GAChC,uBAAuB,GACvB,mBAAmB,GACnB,eAAe,GACf,gBAAgB,GAChB,cAAc,CAAC;AAEnB,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,wBAAwB,CAAC;IAC/B,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,+BAA+B;IAC9C,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,oBAAoB,EAAE,CAAC;CAChC;AAED,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;GAGG;AACH,qBAAa,qBAAqB;IAEhC;;;OAGG;IACH,MAAM,CAAC,iBAAiB,CACtB,SAAS,EAAE,MAAM,EACjB,kBAAkB,EAAE,iBAAiB,EAAE,EACvC,mBAAmB,EAAE,MAAM,EAC3B,oBAAoB,EAAE,MAAM,GAC3B,+BAA+B;IAgElC;;;OAGG;IACH,MAAM,CAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,OAAO;IAyB5E;;;OAGG;IACH,MAAM,CAAC,yBAAyB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE;IAO7D;;;OAGG;IACH,MAAM,CAAC,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAO1D;;OAEG;IACH,MAAM,CAAC,sBAAsB,CAC3B,eAAe,EAAE,iBAAiB,EAAE,EACpC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAC9B,GAAG,CAAC,MAAM,CAAC;IA2Bd;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,cAAc;CA0B9B"}

package/dist/lib/roster-condition-engine.js

@@ -0,0 +1,182 @@
+/**
+ * Moteur d'évaluation des conditions scopées pour les variables ROSTER
+ * RSU v2 - Moteur de Rendu des Formulaires d'Enquête
+ *
+ * Ce moteur est ISOLÉ du ConditionEngine principal.
+ * Les conditions sont évaluées PAR LIGNE (par option de roster) indépendamment.
+ * Le scope est limité aux variables du même ROSTER uniquement.
+ */
+import { ConditionEngine } from './condition-engine';
+/**
+ * Moteur de conditions scopées pour les ROSTER
+ * Toutes les méthodes sont statiques pour une utilisation sans état
+ */
+export class RosterConditionEngine {
+    /**
+     * Valide une condition au moment du design (admin)
+     * Vérifie que les références sont dans le scope et que les jumps sont valides
+     */
+    static validateCondition(condition, availableVariables, currentVariableCode, currentVariableOrdre) {
+        const errors = [];
+        if (!condition?.trim()) {
+            return { isValid: true, errors: [] };
+        }
+        const availableCodes = new Set(availableVariables.map(v => v.code));
+        // 1. Vérifier les références de variables
+        const refs = this.extractVariableReferences(condition);
+        for (const ref of refs) {
+            if (ref === currentVariableCode) {
+                errors.push({
+                    type: 'self_reference',
+                    variableCode: ref,
+                    message: 'Une variable ne peut pas se référencer elle-même'
+                });
+            }
+            else if (!availableCodes.has(ref)) {
+                errors.push({
+                    type: 'variable_not_in_scope',
+                    variableCode: ref,
+                    message: `La variable \${${ref}} n'existe pas dans ce Roster`
+                });
+            }
+        }
+        // 2. Vérifier le jump s'il existe
+        const jumpTarget = this.extractJumpTarget(condition);
+        if (jumpTarget) {
+            if (!availableCodes.has(jumpTarget)) {
+                errors.push({
+                    type: 'jump_out_of_scope',
+                    variableCode: jumpTarget,
+                    message: `La variable cible \${${jumpTarget}} n'existe pas dans ce Roster`
+                });
+            }
+            else {
+                const targetVar = availableVariables.find(v => v.code === jumpTarget);
+                if (targetVar && targetVar.ordre <= currentVariableOrdre) {
+                    errors.push({
+                        type: 'backward_jump',
+                        variableCode: jumpTarget,
+                        message: 'Le jump ne peut pas cibler une variable précédente'
+                    });
+                }
+            }
+        }
+        // 3. Valider la syntaxe générale
+        const syntaxError = this.validateSyntax(condition);
+        if (syntaxError) {
+            errors.push({
+                type: 'syntax_error',
+                variableCode: '',
+                message: syntaxError
+            });
+        }
+        return {
+            isValid: errors.length === 0,
+            errors
+        };
+    }
+    /**
+     * Évalue une condition au runtime (rendu)
+     * Utilise les valeurs de la ligne courante du roster
+     */
+    static evaluate(condition, lineValues) {
+        if (!condition?.trim()) {
+            return true;
+        }
+        try {
+            // Construire un contexte isolé pour cette ligne du roster
+            const responses = {};
+            for (const [code, value] of Object.entries(lineValues)) {
+                responses[code] = {
+                    variableCode: code,
+                    valeur: value,
+                    dateModification: new Date()
+                };
+            }
+            // Utiliser le ConditionEngine en composition (pas héritage)
+            const engine = new ConditionEngine(responses);
+            return engine.evaluate(condition);
+        }
+        catch (error) {
+            console.warn('[RosterConditionEngine] Erreur évaluation:', condition, error);
+            return true; // En cas d'erreur, afficher par défaut
+        }
+    }
+    /**
+     * Extrait toutes les références de variables d'une condition
+     * Format: ${VAR_CODE}
+     */
+    static extractVariableReferences(condition) {
+        if (!condition)
+            return [];
+        const matches = condition.match(/\$\{([A-Z_][A-Z0-9_]*)\}/g) || [];
+        return matches.map(m => m.slice(2, -1));
+    }
+    /**
+     * Extrait la cible d'un jump s'il existe dans la condition
+     * Format: jump(condition, ${TARGET})
+     */
+    static extractJumpTarget(condition) {
+        if (!condition)
+            return null;
+        const match = condition.match(/jump\s*\([^,]+,\s*\$\{([A-Z_][A-Z0-9_]*)\}\s*\)/);
+        return match ? match[1] : null;
+    }
+    /**
+     * Calcule les variables qui doivent être masquées à cause des jumps actifs
+     */
+    static computeJumpedVariables(sortedVariables, lineValues) {
+        const jumped = new Set();
+        for (const rosterVar of sortedVariables) {
+            const condition = rosterVar.conditionsAffichage;
+            if (!condition)
+                continue;
+            const jumpTarget = this.extractJumpTarget(condition);
+            if (!jumpTarget)
+                continue;
+            // Évaluer si le jump doit s'activer
+            if (this.evaluate(condition, lineValues)) {
+                const targetVar = sortedVariables.find(v => v.code === jumpTarget);
+                if (targetVar) {
+                    // Masquer toutes les variables entre la source et la cible
+                    for (const v of sortedVariables) {
+                        if (v.ordre > rosterVar.ordre && v.ordre < targetVar.ordre) {
+                            jumped.add(v.code);
+                        }
+                    }
+                }
+            }
+        }
+        return jumped;
+    }
+    /**
+     * Valide la syntaxe de base d'une condition
+     */
+    static validateSyntax(condition) {
+        try {
+            // Vérifier les parenthèses équilibrées
+            let depth = 0;
+            for (const char of condition) {
+                if (char === '(')
+                    depth++;
+                if (char === ')')
+                    depth--;
+                if (depth < 0) {
+                    return 'Parenthèses non équilibrées';
+                }
+            }
+            if (depth !== 0) {
+                return 'Parenthèses non équilibrées';
+            }
+            // Vérifier les fonctions reconnues
+            const functionMatch = condition.match(/^(showMe|hideMe|jump)\s*\(/);
+            if (!functionMatch && !condition.includes('${')) {
+                return 'Condition invalide: utilisez showMe(), hideMe() ou jump()';
+            }
+            return null;
+        }
+        catch (error) {
+            return `Erreur de syntaxe: ${error instanceof Error ? error.message : 'Erreur inconnue'}`;
+        }
+    }
+}