@rsuci/shared-form-components 1.0.86 → 1.0.88

package/dist/lib/utils/groupeInstanceManager.js

@@ -9,19 +9,8 @@ export class GroupeInstanceManager {
      */
     static getMaxInstances(groupe, responses) {
         if (!groupe.estMultiple || !groupe.codeVariable) {
-            console.log('GroupeInstanceManager.getMaxInstances - Groupe non multiple ou sans variable de contrôle:', {
-                estMultiple: groupe.estMultiple,
-                codeVariable: groupe.codeVariable,
-                groupeCode: groupe.code
-            });
             return 1;
         }
-        console.log('GroupeInstanceManager.getMaxInstances - Recherche variable de contrôle:', {
-            groupeCode: groupe.code,
-            codeVariable: groupe.codeVariable,
-            responsesKeys: Object.keys(responses),
-            responses: responses
-        });
         // Chercher la réponse de la variable de contrôle
         // D'abord essayer avec la clé directe
         let controlResponse = responses[groupe.codeVariable];
@@ -31,17 +20,8 @@ export class GroupeInstanceManager {
             if (foundResponse) {
                 controlResponse = foundResponse;
             }
-            console.log('GroupeInstanceManager.getMaxInstances - Recherche par variableCode:', {
-                found: !!foundResponse,
-                controlResponse: foundResponse
-            });
         }
         const controlValue = controlResponse?.valeur;
-        console.log('GroupeInstanceManager.getMaxInstances - Valeur de contrôle trouvée:', {
-            controlResponse: controlResponse,
-            controlValue: controlValue,
-            valueType: typeof controlValue
-        });
         // Convertir la valeur en nombre
         let maxFromControl = 1; // Valeur par défaut
         if (typeof controlValue === 'number') {
@@ -53,20 +33,9 @@ export class GroupeInstanceManager {
                 maxFromControl = parsed;
             }
         }
-        // PROTECTION DES DONNÉES : Obtenir le nombre d'instances existantes
-        const existingInstancesCount = groupe.instances?.length || 0;
-        // Le maximum effectif est au moins égal au nombre d'instances existantes
-        const protectedMax = Math.max(maxFromControl, existingInstancesCount);
-        console.log('GroupeInstanceManager.getMaxInstances - Résultat avec protection:', {
-            groupeCode: groupe.code,
-            codeVariable: groupe.codeVariable,
-            maxFromControl: maxFromControl,
-            existingInstancesCount: existingInstancesCount,
-            protectedMax: protectedMax,
-            isProtectionActive: protectedMax > maxFromControl
-        });
-        // S'assurer qu'on a au moins 1 instance
-        return Math.max(1, protectedMax);
+        // Le max pour l'ajout est strictement la valeur de la variable de contrôle
+        // La protection d'affichage des onglets existants est dans GroupeInstanceTabs (minDisplayCount)
+        return Math.max(1, maxFromControl);
     }
     /**
      * Récupère le nombre minimum d'instances (basé sur les instances existantes)
@@ -80,19 +49,19 @@ export class GroupeInstanceManager {
     }
     /**
      * Compte le nombre d'instances existantes pour un groupe
+     * Source de vérité : groupe.instances.length
+     * Fallback par numeroMembre uniquement pour l'initialisation
      */
     static getInstancesCount(groupe, responses) {
         if (!groupe.estMultiple) {
             return 1;
         }
-        console.log('GroupeInstanceManager.getInstancesCount - Début:', {
-            groupeCode: groupe.code,
-            variableCodes: groupe.variables.map(v => v.code),
-            responsesKeys: Object.keys(responses)
-        });
-        // Compter les instances basées sur les réponses
+        // Source de vérité : le tableau instances
+        if (groupe.instances && groupe.instances.length > 0) {
+            return groupe.instances.length;
+        }
+        // Fallback pour l'initialisation : compter par numeroMembre uniquement
         const instanceNumbers = new Set();
-        // Méthode 1: Par numeroMembre
         groupe.variables.forEach(variable => {
             Object.values(responses).forEach(response => {
                 if (response.variableCode === variable.code && response.numeroMembre) {
@@ -100,30 +69,7 @@ export class GroupeInstanceManager {
                 }
             });
         });
-        // Méthode 2: Par clé avec format "CODE_NUMERO"
-        groupe.variables.forEach(variable => {
-            Object.keys(responses).forEach(key => {
-                const response = responses[key];
-                if (response.variableCode === variable.code) {
-                    // Extraire le numéro d'instance de la clé si elle suit le format "CODE_NUMERO"
-                    const keyParts = key.split('_');
-                    if (keyParts.length >= 2) {
-                        const lastPart = keyParts[keyParts.length - 1];
-                        const instanceNum = parseInt(lastPart, 10);
-                        if (!isNaN(instanceNum) && instanceNum > 0) {
-                            instanceNumbers.add(instanceNum);
-                        }
-                    }
-                }
-            });
-        });
-        const count = Math.max(1, instanceNumbers.size);
-        console.log('GroupeInstanceManager.getInstancesCount - Résultat:', {
-            groupeCode: groupe.code,
-            instanceNumbers: Array.from(instanceNumbers).sort(),
-            finalCount: count
-        });
-        return count;
+        return Math.max(1, instanceNumbers.size);
     }
     /**
      * Crée une nouvelle instance pour un groupe multiple
@@ -144,12 +90,6 @@ export class GroupeInstanceManager {
         if (!groupe.estMultiple) {
             return [];
         }
-        console.log('GroupeInstanceManager.initializeInstances - Début:', {
-            groupeCode: groupe.code,
-            codeVariable: groupe.codeVariable,
-            responsesKeys: Object.keys(responses),
-            allResponses: responses
-        });
         // Identifier toutes les instances existantes pour ce groupe
         const instanceNumbers = new Set();
         // Collecter les réponses existantes pour ce groupe (avec et sans numeroMembre)
@@ -164,29 +104,8 @@ export class GroupeInstanceManager {
                 }
             }
         });
-        // Aussi chercher par clé avec format "CODE_NUMERO"
-        Object.keys(responses).forEach(key => {
-            const response = responses[key];
-            const belongsToGroup = groupe.variables.some(v => v.code === response.variableCode);
-            if (belongsToGroup) {
-                // Extraire le numéro d'instance de la clé si elle suit le format "CODE_NUMERO"
-                const keyParts = key.split('_');
-                if (keyParts.length >= 2) {
-                    const lastPart = keyParts[keyParts.length - 1];
-                    const instanceNum = parseInt(lastPart, 10);
-                    if (!isNaN(instanceNum) && instanceNum > 0) {
-                        instanceNumbers.add(instanceNum);
-                    }
-                }
-            }
-        });
-        console.log('GroupeInstanceManager.initializeInstances - Données trouvées:', {
-            groupeCode: groupe.code,
-            instanceNumbers: Array.from(instanceNumbers).sort(),
-            groupResponsesCount: groupResponses.length,
-            responsesWithNumeroMembre: groupResponses.filter(r => r.numeroMembre).length,
-            responsesWithoutNumeroMembre: groupResponses.filter(r => !r.numeroMembre).length
-        });
+        // Note: le parsing de clé par format "CODE_NUMERO" a été supprimé car il
+        // produisait des faux positifs pour les codes variables contenant des chiffres (ex: S1_01)
         const maxInstances = this.getMaxInstances(groupe, responses);
         // Déterminer le nombre d'instances à créer
         let instanceCount = Math.max(1, instanceNumbers.size);
@@ -197,12 +116,6 @@ export class GroupeInstanceManager {
         if (instanceCount === 0) {
             instanceCount = 1;
         }
-        console.log('GroupeInstanceManager.initializeInstances - Calcul instances:', {
-            groupeCode: groupe.code,
-            maxInstances,
-            existingInstancesCount: instanceNumbers.size,
-            finalInstanceCount: instanceCount
-        });
         const instances = [];
         // Séparer les réponses avec et sans numeroMembre
         const responsesWithMember = groupResponses.filter(r => r.numeroMembre);
@@ -226,12 +139,6 @@ export class GroupeInstanceManager {
                     if (i === 1) {
                         existingResponse = responsesWithoutMember.find(r => r.variableCode === variable.code);
                         if (existingResponse) {
-                            console.log('GroupeInstanceManager.initializeInstances - Attribution réponse sans numeroMembre:', {
-                                groupeCode: groupe.code,
-                                instanceNumber: i,
-                                variableCode: variable.code,
-                                originalResponse: existingResponse
-                            });
                             // Créer une copie avec numeroMembre pour cette instance
                             existingResponse = {
                                 ...existingResponse,
@@ -241,35 +148,13 @@ export class GroupeInstanceManager {
                     }
                 }
                 if (existingResponse) {
-                    console.log('GroupeInstanceManager.initializeInstances - Réponse trouvée:', {
-                        groupeCode: groupe.code,
-                        instanceNumber: i,
-                        variableCode: variable.code,
-                        hasNumeroMembre: !!existingResponse.numeroMembre,
-                        response: existingResponse
-                    });
                     instance.reponses[variable.code] = existingResponse;
                 }
             });
             // Vérifier si l'instance est complète
             instance.estComplete = this.isInstanceComplete(instance, groupe);
             instances.push(instance);
-            console.log('GroupeInstanceManager.initializeInstances - Instance créée:', {
-                groupeCode: groupe.code,
-                instanceNumber: i,
-                responsesCount: Object.keys(instance.reponses).length,
-                isComplete: instance.estComplete
-            });
         }
-        console.log('GroupeInstanceManager.initializeInstances - Résultat final:', {
-            groupeCode: groupe.code,
-            instancesCreated: instances.length,
-            instances: instances.map(inst => ({
-                numero: inst.numeroInstance,
-                responsesCount: Object.keys(inst.reponses).length,
-                isComplete: inst.estComplete
-            }))
-        });
         return instances;
     }
     /**
@@ -332,12 +217,6 @@ export class GroupeInstanceManager {
         const constraints = [];
         // CORRECTION: Utiliser le nombre d'instances du groupe directement
         const currentCount = groupe.instances?.length || 0;
-        console.log('GroupeInstanceManager.canRemoveInstance - Debug:', {
-            groupeCode: groupe.code,
-            instancesLength: groupe.instances?.length,
-            currentCount,
-            canRemove: currentCount > 1
-        });
         if (currentCount <= 1) {
             constraints.push({
                 type: 'instance_limit',
@@ -368,7 +247,7 @@ export class GroupeInstanceManager {
         // Trouver tous les groupes qui utilisent cette variable de contrôle
         const affectedGroups = groupesMultiples.filter(g => g.codeVariable === variableCode);
         for (const groupe of affectedGroups) {
-            const existingInstances = this.getInstancesCount(groupe, responses);
+            const existingInstances = groupe.instances?.length || this.getInstancesCount(groupe, responses);
             if (newValue < existingInstances) {
                 constraints.push({
                     type: 'bidirectional_control',
@@ -396,7 +275,8 @@ export class GroupeInstanceManager {
         };
     }
     /**
-     * Ajoute une nouvelle instance à un groupe
+     * Ajoute une nouvelle instance à un groupe (immutable)
+     * Retourne un nouveau groupe sans muter l'original
      */
     static addInstance(groupe, responses) {
         const validation = this.canAddInstance(groupe, responses);
@@ -406,29 +286,25 @@ export class GroupeInstanceManager {
                 error: validation.constraints[0]?.message || 'Impossible d\'ajouter une instance'
             };
         }
-        // CORRECTION: Calculer le bon numéro d'instance
-        if (!groupe.instances) {
-            groupe.instances = [];
-        }
-        const newInstanceNumber = groupe.instances.length + 1;
+        const currentInstances = groupe.instances || [];
+        const newInstanceNumber = currentInstances.length + 1;
         const newInstance = this.createInstance(groupe, newInstanceNumber);
-        // Ajouter l'instance au groupe
-        groupe.instances.push(newInstance);
-        // Mettre à jour les propriétés calculées
-        groupe.instancesCount = groupe.instances.length;
-        console.log('GroupeInstanceManager.addInstance - Instance ajoutée:', {
-            groupeCode: groupe.code,
-            newInstanceNumber,
-            totalInstances: groupe.instances.length,
-            maxInstances: this.getMaxInstances(groupe, responses)
-        });
+        // Construire un nouveau groupe avec l'instance ajoutée (sans muter l'original)
+        const updatedInstances = [...currentInstances, newInstance];
+        const updatedGroupe = {
+            ...groupe,
+            instances: updatedInstances,
+            instancesCount: updatedInstances.length
+        };
         return {
             success: true,
-            instance: newInstance
+            instance: newInstance,
+            updatedGroupe
         };
     }
     /**
-     * Supprime une instance d'un groupe
+     * Supprime une instance d'un groupe (immutable)
+     * Retourne de nouveaux objets sans muter les originaux
      */
     static removeInstance(groupe, instanceNumber, responses) {
         const validation = this.canRemoveInstance(groupe, responses);
@@ -438,26 +314,29 @@ export class GroupeInstanceManager {
                 error: validation.constraints[0]?.message || 'Impossible de supprimer cette instance'
             };
         }
-        // Supprimer l'instance du tableau
-        if (groupe.instances) {
-            groupe.instances = groupe.instances.filter(i => i.numeroInstance !== instanceNumber);
-            groupe.instancesCount = groupe.instances.length;
-        }
-        // Supprimer les réponses associées à cette instance
-        Object.keys(responses).forEach(key => {
-            const response = responses[key];
-            if (response.numeroMembre === instanceNumber) {
-                // Trouver si cette réponse appartient à ce groupe
-                const belongsToGroup = groupe.variables.some(v => v.code === response.variableCode);
-                if (belongsToGroup) {
-                    delete responses[key];
-                }
+        // Filtrer les instances (sans muter l'original)
+        const filteredInstances = (groupe.instances || []).filter(i => i.numeroInstance !== instanceNumber);
+        // Construire de nouvelles réponses en excluant celles de l'instance supprimée
+        const cleanedResponses = {};
+        Object.entries(responses).forEach(([key, response]) => {
+            const belongsToGroup = groupe.variables.some(v => v.code === response.variableCode);
+            if (belongsToGroup && response.numeroMembre === instanceNumber) {
+                // Exclure les réponses de l'instance supprimée
+                return;
             }
+            cleanedResponses[key] = { ...response };
         });
         // Réorganiser les instances pour maintenir une numérotation séquentielle
-        this.reorderInstances(groupe, responses);
+        const { reorderedInstances, reorderedResponses } = this.reorderInstances(filteredInstances, cleanedResponses, groupe);
+        const updatedGroupe = {
+            ...groupe,
+            instances: reorderedInstances,
+            instancesCount: reorderedInstances.length
+        };
         return {
-            success: true
+            success: true,
+            updatedGroupe,
+            updatedResponses: reorderedResponses
         };
     }
     /**
@@ -473,14 +352,6 @@ export class GroupeInstanceManager {
         if (!groupe.instances) {
             groupe.instances = this.initializeInstances(groupe, responses);
         }
-        // PROTECTION DES DONNÉES : Ne plus supprimer automatiquement les instances
-        // La logique de protection est maintenant dans getMaxInstances()
-        console.log('GroupeInstanceManager.updateGroupeProperties - Protection des données active:', {
-            groupeCode: groupe.code,
-            currentInstances: groupe.instances.length,
-            maxInstances: groupe.maxInstances,
-            protectionActive: groupe.instances.length > 0
-        });
         groupe.instancesCount = groupe.instances.length;
         // Mettre à jour le statut de completion des instances
         groupe.instances.forEach(instance => {
@@ -567,40 +438,64 @@ export class GroupeInstanceManager {
         };
     }
     /**
-     * Réorganise les numéros d'instances après suppression
+     * Réorganise les numéros d'instances après suppression (immutable)
+     * Retourne de nouveaux objets sans muter les originaux
      */
-    static reorderInstances(groupe, responses) {
-        if (!groupe.instances) {
-            return;
+    static reorderInstances(instances, responses, groupe) {
+        if (!instances || instances.length === 0) {
+            return { reorderedInstances: [], reorderedResponses: { ...responses } };
         }
-        // Trier les instances par numéro
-        groupe.instances.sort((a, b) => a.numeroInstance - b.numeroInstance);
-        // Réassigner les numéros séquentiellement
-        groupe.instances.forEach((instance, index) => {
+        // Trier les instances par numéro (sur des copies)
+        const sortedInstances = [...instances].sort((a, b) => a.numeroInstance - b.numeroInstance);
+        // Construire le mapping oldNumber → newNumber
+        const numberMapping = new Map();
+        sortedInstances.forEach((instance, index) => {
             const newNumber = index + 1;
-            const oldNumber = instance.numeroInstance;
-            if (newNumber !== oldNumber) {
-                // Mettre à jour le numéro de l'instance
-                instance.numeroInstance = newNumber;
-                instance.libelle = `${groupe.designation} ${newNumber}`;
-                // Mettre à jour les réponses dans le store global
-                Object.keys(responses).forEach(key => {
-                    const response = responses[key];
-                    if (response.numeroMembre === oldNumber) {
-                        const belongsToGroup = groupe.variables.some(v => v.code === response.variableCode);
-                        if (belongsToGroup) {
-                            response.numeroMembre = newNumber;
-                            // Mettre à jour la clé si nécessaire
-                            delete responses[key];
-                            responses[`${response.variableCode}_${newNumber}`] = response;
-                        }
-                    }
-                });
-                // Mettre à jour les réponses dans l'instance
-                Object.keys(instance.reponses).forEach(variableCode => {
-                    instance.reponses[variableCode].numeroMembre = newNumber;
-                });
+            if (instance.numeroInstance !== newNumber) {
+                numberMapping.set(instance.numeroInstance, newNumber);
+            }
+        });
+        // Créer les nouvelles instances avec les numéros mis à jour
+        const reorderedInstances = sortedInstances.map((instance, index) => {
+            const newNumber = index + 1;
+            if (instance.numeroInstance === newNumber) {
+                return { ...instance }; // Copie sans changement de numéro
+            }
+            // Copier avec nouveau numéro
+            const newReponses = {};
+            Object.entries(instance.reponses).forEach(([variableCode, response]) => {
+                newReponses[variableCode] = { ...response, numeroMembre: newNumber };
+            });
+            return {
+                ...instance,
+                numeroInstance: newNumber,
+                libelle: `${groupe.designation} ${newNumber}`,
+                reponses: newReponses
+            };
+        });
+        // Si aucun renumérotage nécessaire, retourner une copie simple
+        if (numberMapping.size === 0) {
+            return { reorderedInstances, reorderedResponses: { ...responses } };
+        }
+        // Construire les nouvelles réponses avec les clés mises à jour
+        const reorderedResponses = {};
+        Object.entries(responses).forEach(([key, response]) => {
+            const belongsToGroup = groupe.variables.some(v => v.code === response.variableCode);
+            if (belongsToGroup && response.numeroMembre && numberMapping.has(response.numeroMembre)) {
+                const newNumber = numberMapping.get(response.numeroMembre);
+                const newKey = `${response.variableCode}_${newNumber}`;
+                reorderedResponses[newKey] = { ...response, numeroMembre: newNumber };
+            }
+            else if (belongsToGroup && response.numeroMembre && !numberMapping.has(response.numeroMembre)) {
+                // Réponse du groupe mais pas de renumérotage nécessaire - garder avec la bonne clé
+                const correctKey = `${response.variableCode}_${response.numeroMembre}`;
+                reorderedResponses[correctKey] = { ...response };
+            }
+            else {
+                // Réponse hors du groupe, garder telle quelle
+                reorderedResponses[key] = { ...response };
             }
         });
+        return { reorderedInstances, reorderedResponses };
     }
 }

package/dist/lib/utils/interpolateVariableLabel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"interpolateVariableLabel.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/interpolateVariableLabel.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAErD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,MAAM,EACb,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,EAC5C,qBAAqB,CAAC,EAAE,MAAM,GAC7B,MAAM,CA6ER;AA2DD;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAG5D;AAED;;;;;;;;;GASG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAcjE;AAED,eAAe,wBAAwB,CAAC"}
+{"version":3,"file":"interpolateVariableLabel.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/interpolateVariableLabel.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAErD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,MAAM,EACb,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,EAC5C,qBAAqB,CAAC,EAAE,MAAM,GAC7B,MAAM,CA0CR;AA2DD;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAG5D;AAED;;;;;;;;;GASG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAcjE;AAED,eAAe,wBAAwB,CAAC"}

package/dist/lib/utils/interpolateVariableLabel.js

@@ -31,71 +31,37 @@
  * // Cherchera MEMBRE_NOM_2 → "Nom: Pierre"
  */
 export function interpolateVariableLabel(label, allResponses, currentInstanceNumber) {
-    console.log('🔍 [interpolateVariableLabel] DEBUT', {
-        label,
-        currentInstanceNumber,
-        allResponsesKeys: Object.keys(allResponses),
-        allResponsesCount: Object.keys(allResponses).length
-    });
     // Si pas de label ou pas de pattern ${}, retourner tel quel
     if (!label || !label.includes('${')) {
-        console.log('🔍 [interpolateVariableLabel] Pas de pattern ${} trouvé, retour direct');
         return label;
     }
     // Regex pour capturer ${CODE} - le code peut contenir lettres, chiffres, underscores
     const regex = /\$\{([A-Za-z0-9_]+)\}/g;
     const result = label.replace(regex, (match, variableCode) => {
-        console.log('🔍 [interpolateVariableLabel] Traitement de', { match, variableCode });
         let response;
         // Stratégie de recherche de la valeur
         // 1. Essayer avec le code exact tel quel
         // Cela couvre le cas ${CODE_N} où N est explicite
         response = allResponses[variableCode];
-        console.log('🔍 [interpolateVariableLabel] Stratégie 1 - Code exact', {
-            variableCode,
-            found: !!response,
-            value: response?.valeur
-        });
         // 2. Si pas trouvé, essayer avec l'instance courante
-        // La stratégie de recherche en étapes garantit le bon fonctionnement :
         // - Les références explicites (${CODE_1}) sont trouvées à l'étape 1
         // - Les variables dans groupes multiples (${S0_1} -> S0_1_2) sont trouvées ici
         if (!response && currentInstanceNumber) {
-            // Essayer CODE_instanceNumber
             const keyWithInstance = `${variableCode}_${currentInstanceNumber}`;
             response = allResponses[keyWithInstance];
-            console.log('🔍 [interpolateVariableLabel] Stratégie 2 - Avec instance', {
-                keyWithInstance,
-                found: !!response,
-                value: response?.valeur
-            });
         }
         // 3. Si toujours pas trouvé, chercher dans les réponses par variableCode
         // (pour le cas où la clé est juste le code sans suffix)
         if (!response) {
             response = Object.values(allResponses).find(r => r.variableCode === variableCode);
-            console.log('🔍 [interpolateVariableLabel] Stratégie 3 - Par variableCode', {
-                variableCode,
-                found: !!response,
-                value: response?.valeur
-            });
         }
         // 4. Formater et retourner la valeur si trouvée
         if (response?.valeur !== undefined && response?.valeur !== null && response?.valeur !== '') {
-            const formatted = formatValue(response.valeur);
-            console.log('🔍 [interpolateVariableLabel] Valeur trouvée et formatée', {
-                match,
-                variableCode,
-                rawValue: response.valeur,
-                formatted
-            });
-            return formatted;
+            return formatValue(response.valeur);
         }
         // 5. Pas de valeur trouvée → garder le placeholder pour indiquer le champ à remplir
-        console.log('⚠️ [interpolateVariableLabel] Aucune valeur trouvée, garder le placeholder', { match, variableCode });
         return match;
     });
-    console.log('🔍 [interpolateVariableLabel] RESULTAT', { original: label, result });
     return result;
 }
 /**

package/package.json

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