@rsuci/shared-form-components 1.0.86 → 1.0.87

package/dist/components/form-renderer/FormRenderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FormRenderer.d.ts","sourceRoot":"","sources":["../../../src/components/form-renderer/FormRenderer.tsx"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAA4D,MAAM,OAAO,CAAC;AACjF,OAAO,EACL,iBAAiB,EACjB,eAAe,EACf,cAAc,EAIf,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,kBAAkB,EAClB,qBAAqB,EAEtB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAsBlF;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,6BAA6B;IAC7B,UAAU,EAAE,iBAAiB,CAAC;IAC9B,6DAA6D;IAC7D,OAAO,CAAC,EAAE,eAAe,CAAC;IAC1B,yBAAyB;IACzB,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;IAClD,oCAAoC;IACpC,MAAM,EAAE,kBAAkB,CAAC;IAC3B,iCAAiC;IACjC,SAAS,EAAE,qBAAqB,CAAC;IACjC,wBAAwB;IACxB,QAAQ,CAAC,EAAE,oBAAoB,CAAC;IAChC,wCAAwC;IACxC,oBAAoB,CAAC,EAAE,oBAAoB,CAAC;IAC5C,iCAAiC;IACjC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,iCAAiC;IACjC,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB;AA0xBD;;;GAGG;AACH,eAAO,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC,iBAAiB,CAgBpD,CAAC;AAEF,eAAe,YAAY,CAAC"}
+{"version":3,"file":"FormRenderer.d.ts","sourceRoot":"","sources":["../../../src/components/form-renderer/FormRenderer.tsx"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAA4D,MAAM,OAAO,CAAC;AACjF,OAAO,EACL,iBAAiB,EACjB,eAAe,EACf,cAAc,EAIf,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,kBAAkB,EAClB,qBAAqB,EAEtB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAsBlF;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,6BAA6B;IAC7B,UAAU,EAAE,iBAAiB,CAAC;IAC9B,6DAA6D;IAC7D,OAAO,CAAC,EAAE,eAAe,CAAC;IAC1B,yBAAyB;IACzB,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;IAClD,oCAAoC;IACpC,MAAM,EAAE,kBAAkB,CAAC;IAC3B,iCAAiC;IACjC,SAAS,EAAE,qBAAqB,CAAC;IACjC,wBAAwB;IACxB,QAAQ,CAAC,EAAE,oBAAoB,CAAC;IAChC,wCAAwC;IACxC,oBAAoB,CAAC,EAAE,oBAAoB,CAAC;IAC5C,iCAAiC;IACjC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,iCAAiC;IACjC,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB;AAwyBD;;;GAGG;AACH,eAAO,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC,iBAAiB,CAgBpD,CAAC;AAEF,eAAe,YAAY,CAAC"}

package/dist/components/form-renderer/FormRenderer.js

@@ -206,16 +206,22 @@ const FormRendererInner = () => {
         navigation.changeInstance(instanceIndex);
     };
     // Handler pour l'ajout d'instance
-    const handleInstanceAdded = (instance) => {
-        navigation.updateTotalInstances(currentGroup?.instances?.length || 1);
+    const handleInstanceAdded = (instance, updatedGroupe) => {
+        // Mettre à jour le groupe via l'état React (pas de mutation directe)
+        instances.setGroupesWithInstances(prev => prev.map(g => g.code === updatedGroupe.code ? updatedGroupe : g));
+        navigation.updateTotalInstances(updatedGroupe.instances?.length || 1);
         // Naviguer vers la nouvelle instance
-        if (currentGroup?.instances) {
-            navigation.changeInstance(currentGroup.instances.length - 1);
+        if (updatedGroupe.instances) {
+            navigation.changeInstance(updatedGroupe.instances.length - 1);
         }
     };
     // Handler pour la suppression d'instance
-    const handleInstanceRemoved = (instanceNumber) => {
-        navigation.updateTotalInstances(currentGroup?.instances?.length || 1);
+    const handleInstanceRemoved = (instanceNumber, updatedGroupe, updatedResponses) => {
+        // CRITIQUE : mettre à jour les réponses via l'état React
+        context.setResponses(updatedResponses);
+        // Mettre à jour le groupe via l'état React
+        instances.setGroupesWithInstances(prev => prev.map(g => g.code === updatedGroupe.code ? updatedGroupe : g));
+        navigation.updateTotalInstances(updatedGroupe.instances?.length || 1);
         // Revenir à la première instance
         navigation.changeInstance(0);
     };

package/dist/components/form-renderer/GroupeInstanceTabs.d.ts

@@ -9,8 +9,8 @@ export interface GroupeInstanceTabsProps {
     currentInstanceIndex: number;
     responses: Record<string, EnqueteReponse>;
     onInstanceChange: (instanceIndex: number) => void;
-    onInstanceAdded: (instance: GroupeInstance) => void;
-    onInstanceRemoved: (instanceNumber: number) => void;
+    onInstanceAdded: (instance: GroupeInstance, updatedGroupe: GroupeFormulaire) => void;
+    onInstanceRemoved: (instanceNumber: number, updatedGroupe: GroupeFormulaire, updatedResponses: Record<string, EnqueteReponse>) => void;
     disabled?: boolean;
 }
 declare const GroupeInstanceTabs: React.FC<GroupeInstanceTabsProps>;

package/dist/components/form-renderer/GroupeInstanceTabs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GroupeInstanceTabs.d.ts","sourceRoot":"","sources":["../../../src/components/form-renderer/GroupeInstanceTabs.tsx"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,KAA8B,MAAM,OAAO,CAAC;AAEnD,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAIvF,MAAM,WAAW,uBAAuB;IACtC,MAAM,EAAE,gBAAgB,CAAC;IACzB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;IAC1C,gBAAgB,EAAE,CAAC,aAAa,EAAE,MAAM,KAAK,IAAI,CAAC;IAClD,eAAe,EAAE,CAAC,QAAQ,EAAE,cAAc,KAAK,IAAI,CAAC;IACpD,iBAAiB,EAAE,CAAC,cAAc,EAAE,MAAM,KAAK,IAAI,CAAC;IACpD,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,QAAA,MAAM,kBAAkB,EAAE,KAAK,CAAC,EAAE,CAAC,uBAAuB,CA0RzD,CAAC;AAEF,eAAe,kBAAkB,CAAC"}
+{"version":3,"file":"GroupeInstanceTabs.d.ts","sourceRoot":"","sources":["../../../src/components/form-renderer/GroupeInstanceTabs.tsx"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,KAA8B,MAAM,OAAO,CAAC;AAEnD,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAIvF,MAAM,WAAW,uBAAuB;IACtC,MAAM,EAAE,gBAAgB,CAAC;IACzB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;IAC1C,gBAAgB,EAAE,CAAC,aAAa,EAAE,MAAM,KAAK,IAAI,CAAC;IAClD,eAAe,EAAE,CAAC,QAAQ,EAAE,cAAc,EAAE,aAAa,EAAE,gBAAgB,KAAK,IAAI,CAAC;IACrF,iBAAiB,EAAE,CAAC,cAAc,EAAE,MAAM,EAAE,aAAa,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,KAAK,IAAI,CAAC;IACvI,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,QAAA,MAAM,kBAAkB,EAAE,KAAK,CAAC,EAAE,CAAC,uBAAuB,CAuQzD,CAAC;AAEF,eAAe,kBAAkB,CAAC"}

package/dist/components/form-renderer/GroupeInstanceTabs.js

@@ -26,12 +26,6 @@ const GroupeInstanceTabs = ({ groupe, currentInstanceIndex, responses, onInstanc
     useEffect(() => {
         const newMaxInstances = GroupeInstanceManager.getMaxInstances(groupe, responses);
         if (newMaxInstances !== maxInstances) {
-            console.log('GroupeInstanceTabs - Changement de maxInstances détecté:', {
-                groupeCode: groupe.code,
-                oldMaxInstances: maxInstances,
-                newMaxInstances,
-                codeVariable: groupe.codeVariable
-            });
             setForceUpdate(prev => prev + 1);
         }
     }, [responses, groupe.codeVariable, groupe.maxInstances]);
@@ -39,18 +33,6 @@ const GroupeInstanceTabs = ({ groupe, currentInstanceIndex, responses, onInstanc
     // Le nombre d'onglets affichés = Math.max(maxInstances, instances existantes)
     const minDisplayCount = Math.max(maxInstances, groupe.instances.length);
     const displayedInstances = groupe.instances.slice(0, minDisplayCount);
-    console.log('GroupeInstanceTabs - Debug avec protection:', {
-        groupeCode: groupe.code,
-        codeVariable: groupe.codeVariable,
-        maxInstances,
-        totalInstances: groupe.instances.length,
-        minDisplayCount,
-        displayedInstances: displayedInstances.length,
-        canAdd: canAdd.canProceed,
-        canRemove: canRemove.canProceed,
-        canAddMessage: canAdd.constraints[0]?.message,
-        canRemoveMessage: canRemove.constraints[0]?.message
-    });
     // Fonction pour déterminer l'état d'une instance
     const getInstanceState = (instance) => {
         const responseCount = Object.keys(instance.reponses).length;
@@ -109,8 +91,8 @@ const GroupeInstanceTabs = ({ groupe, currentInstanceIndex, responses, onInstanc
         setError(null);
         try {
             const result = GroupeInstanceManager.addInstance(groupe, responses);
-            if (result.success && result.instance) {
-                onInstanceAdded(result.instance);
+            if (result.success && result.instance && result.updatedGroupe) {
+                onInstanceAdded(result.instance, result.updatedGroupe);
             }
             else {
                 setError(result.error || 'Erreur lors de l\'ajout de l\'instance');
@@ -143,8 +125,8 @@ const GroupeInstanceTabs = ({ groupe, currentInstanceIndex, responses, onInstanc
                 return;
             }
             const result = GroupeInstanceManager.removeInstance(groupe, currentInstance.numeroInstance, responses);
-            if (result.success) {
-                onInstanceRemoved(currentInstance.numeroInstance);
+            if (result.success && result.updatedGroupe && result.updatedResponses) {
+                onInstanceRemoved(currentInstance.numeroInstance, result.updatedGroupe, result.updatedResponses);
             }
             else {
                 setError(result.error || 'Erreur lors de la suppression de l\'instance');

package/dist/hooks/useFormInstances.js

@@ -81,16 +81,16 @@ export function useFormInstances(initialGroupes, initialResponses, options = {})
      */
     const addInstance = useCallback((groupe, responses) => {
         const result = GroupeInstanceManager.addInstance(groupe, responses);
-        if (result.success && result.instance) {
+        if (result.success && result.instance && result.updatedGroupe) {
             log('Instance ajoutée:', {
                 groupeCode: groupe.code,
                 instanceNumber: result.instance.numeroInstance
             });
-            // Mettre à jour les groupes
+            // Mettre à jour les groupes avec le nouveau groupe immutable
             setGroupesWithInstances(prev => {
                 const updated = prev.map(g => {
-                    if (g.code === groupe.code) {
-                        return { ...groupe };
+                    if (g.code === result.updatedGroupe.code) {
+                        return result.updatedGroupe;
                     }
                     return g;
                 });
@@ -110,16 +110,16 @@ export function useFormInstances(initialGroupes, initialResponses, options = {})
      */
     const removeInstance = useCallback((groupe, instanceNumber, responses) => {
         const result = GroupeInstanceManager.removeInstance(groupe, instanceNumber, responses);
-        if (result.success) {
+        if (result.success && result.updatedGroupe) {
             log('Instance supprimée:', {
                 groupeCode: groupe.code,
                 instanceNumber
             });
-            // Mettre à jour les groupes
+            // Mettre à jour les groupes avec le nouveau groupe immutable
             setGroupesWithInstances(prev => {
                 const updated = prev.map(g => {
-                    if (g.code === groupe.code) {
-                        return { ...groupe };
+                    if (g.code === result.updatedGroupe.code) {
+                        return result.updatedGroupe;
                     }
                     return g;
                 });

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

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

package/dist/hooks/useFormRenderer.js

@@ -7,6 +7,7 @@ import { useState, useCallback, useEffect, useMemo } from 'react';
 import { useFormNavigation } from './useFormNavigation';
 import { useFormValidation } from './useFormValidation';
 import { useFormInstances } from './useFormInstances';
+import { GroupeInstanceManager } from '../lib/utils/groupeInstanceManager';
 /**
  * Hook principal pour gérer un formulaire d'enquête
  *
@@ -94,6 +95,20 @@ export function useFormRenderer(formulaire, enquete, options = { config: { mode:
     // === Mise à jour des réponses ===
     const updateResponse = useCallback((variableCode, value, variable, numeroMembre) => {
         const responseKey = getResponseKey(variableCode, numeroMembre);
+        // Validation de la variable de contrôle : empêcher la réduction en-dessous des instances existantes
+        if (isControlVariable(variable) && value !== null && value !== '') {
+            const numericValue = typeof value === 'number' ? value : parseInt(String(value), 10);
+            if (!isNaN(numericValue)) {
+                const groupesMultiples = (instances.groupesWithInstances.length > 0
+                    ? instances.groupesWithInstances
+                    : formulaire?.groupes || []).filter(g => g.estMultiple);
+                const validation = GroupeInstanceManager.canModifyControlVariable(variableCode, numericValue, groupesMultiples, responses);
+                if (!validation.canProceed) {
+                    console.warn('[FormRenderer] Variable de contrôle rejetée:', validation.constraints[0]?.message);
+                    return; // Rejeter le changement - l'input revient à la valeur précédente
+                }
+            }
+        }
         const newResponse = {
             variableId: variable.id,
             variableCode: variableCode,
@@ -129,9 +144,11 @@ export function useFormRenderer(formulaire, enquete, options = { config: { mode:
         setHasUnsavedChanges(true);
     }, [
         getResponseKey,
+        isControlVariable,
         currentGroup,
         currentInstance,
         instances,
+        formulaire?.groupes,
         responses,
         onResponsesChange
     ]);

package/dist/lib/__tests__/groupeInstanceManager.test.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Tests unitaires pour GroupeInstanceManager
+ * Couvre le comptage, l'ajout/suppression, la validation et les scénarios d'intégration
+ */
+export {};
+//# sourceMappingURL=groupeInstanceManager.test.d.ts.map

package/dist/lib/__tests__/groupeInstanceManager.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"groupeInstanceManager.test.d.ts","sourceRoot":"","sources":["../../../src/lib/__tests__/groupeInstanceManager.test.ts"],"names":[],"mappings":"AAAA;;;GAGG"}

package/dist/lib/__tests__/groupeInstanceManager.test.js

@@ -0,0 +1,454 @@
+/**
+ * Tests unitaires pour GroupeInstanceManager
+ * Couvre le comptage, l'ajout/suppression, la validation et les scénarios d'intégration
+ */
+import { GroupeInstanceManager } from '../utils/groupeInstanceManager';
+// === Helpers de création de données de test ===
+function createVariable(code, overrides = {}) {
+    return {
+        id: Math.floor(Math.random() * 10000),
+        code,
+        designation: `Variable ${code}`,
+        typeCode: 'STRING',
+        groupeCode: 'TEST_GROUP',
+        ordre: 1,
+        estObligatoire: false,
+        estVisible: true,
+        ...overrides
+    };
+}
+function createGroupe(overrides = {}) {
+    return {
+        code: 'TEST_GROUP',
+        designation: 'Groupe Test',
+        ordre: 1,
+        estMultiple: false,
+        variables: [createVariable('S1_01'), createVariable('S1_02')],
+        ...overrides
+    };
+}
+function createMultipleGroupe(overrides = {}) {
+    return createGroupe({
+        estMultiple: true,
+        codeVariable: 'S0_23',
+        ...overrides
+    });
+}
+function createInstance(numero, reponses = {}) {
+    return {
+        numeroInstance: numero,
+        libelle: `Groupe Test ${numero}`,
+        estComplete: false,
+        reponses
+    };
+}
+function createResponse(variableCode, valeur, numeroMembre) {
+    return {
+        variableId: Math.floor(Math.random() * 10000),
+        variableCode,
+        valeur,
+        numeroMembre,
+        dateModification: new Date()
+    };
+}
+function createControlResponse(value) {
+    return {
+        S0_23: createResponse('S0_23', value)
+    };
+}
+// === Tests ===
+describe('GroupeInstanceManager', () => {
+    describe('getMaxInstances', () => {
+        it('devrait retourner 1 pour un groupe non multiple', () => {
+            const groupe = createGroupe({ estMultiple: false });
+            expect(GroupeInstanceManager.getMaxInstances(groupe, {})).toBe(1);
+        });
+        it('devrait retourner 1 pour un groupe multiple sans codeVariable', () => {
+            const groupe = createGroupe({ estMultiple: true, codeVariable: undefined });
+            expect(GroupeInstanceManager.getMaxInstances(groupe, {})).toBe(1);
+        });
+        it('devrait retourner la valeur numerique de la variable de controle', () => {
+            const groupe = createMultipleGroupe();
+            const responses = createControlResponse(3);
+            expect(GroupeInstanceManager.getMaxInstances(groupe, responses)).toBe(3);
+        });
+        it('devrait parser une valeur string de la variable de controle', () => {
+            const groupe = createMultipleGroupe();
+            const responses = {
+                S0_23: createResponse('S0_23', '5')
+            };
+            expect(GroupeInstanceManager.getMaxInstances(groupe, responses)).toBe(5);
+        });
+        it('devrait retourner 1 si aucune reponse pour la variable de controle', () => {
+            const groupe = createMultipleGroupe();
+            expect(GroupeInstanceManager.getMaxInstances(groupe, {})).toBe(1);
+        });
+        it('devrait trouver la reponse par variableCode quand la cle directe manque', () => {
+            const groupe = createMultipleGroupe();
+            const responses = {
+                'some_other_key': createResponse('S0_23', 4)
+            };
+            expect(GroupeInstanceManager.getMaxInstances(groupe, responses)).toBe(4);
+        });
+        it('devrait retourner strictement la valeur de controle (pas gonflee par instances existantes)', () => {
+            // Apres Fix 1c: getMaxInstances ne doit PAS gonfler au-dela de la variable de controle
+            const groupe = createMultipleGroupe({
+                instances: [createInstance(1), createInstance(2), createInstance(3), createInstance(4), createInstance(5)]
+            });
+            const responses = createControlResponse(3);
+            // Le max devrait etre 3 (valeur de controle), pas 5 (nombre d'instances)
+            expect(GroupeInstanceManager.getMaxInstances(groupe, responses)).toBe(3);
+        });
+    });
+    describe('getInstancesCount', () => {
+        it('devrait retourner 1 pour un groupe non multiple', () => {
+            const groupe = createGroupe({ estMultiple: false });
+            expect(GroupeInstanceManager.getInstancesCount(groupe, {})).toBe(1);
+        });
+        it('devrait retourner le nombre d\'instances si elles existent', () => {
+            const groupe = createMultipleGroupe({
+                instances: [createInstance(1), createInstance(2), createInstance(3)]
+            });
+            expect(GroupeInstanceManager.getInstancesCount(groupe, {})).toBe(3);
+        });
+        it('devrait utiliser le fallback par numeroMembre quand instances est vide', () => {
+            const groupe = createMultipleGroupe({ instances: undefined });
+            const responses = {
+                'S1_01_1': createResponse('S1_01', 'val1', 1),
+                'S1_01_2': createResponse('S1_01', 'val2', 2),
+                'S1_02_1': createResponse('S1_02', 'val3', 1),
+                'S1_02_2': createResponse('S1_02', 'val4', 2),
+            };
+            expect(GroupeInstanceManager.getInstancesCount(groupe, responses)).toBe(2);
+        });
+        it('devrait retourner au minimum 1', () => {
+            const groupe = createMultipleGroupe({ instances: undefined });
+            expect(GroupeInstanceManager.getInstancesCount(groupe, {})).toBe(1);
+        });
+        it('ne devrait PAS fausser le comptage avec des codes variables contenant des chiffres', () => {
+            // Apres Fix 1a: le parsing de cles "S1_01" ne doit pas creer un faux instance numero 1
+            const groupe = createMultipleGroupe({
+                instances: [createInstance(1), createInstance(2)]
+            });
+            // Meme s'il y a des cles avec des formats ambigus, instances.length prime
+            expect(GroupeInstanceManager.getInstancesCount(groupe, {})).toBe(2);
+        });
+    });
+    describe('createInstance', () => {
+        it('devrait creer une instance avec le bon numero et libelle', () => {
+            const groupe = createMultipleGroupe();
+            const instance = GroupeInstanceManager.createInstance(groupe, 3);
+            expect(instance.numeroInstance).toBe(3);
+            expect(instance.libelle).toBe('Groupe Test 3');
+            expect(instance.estComplete).toBe(false);
+            expect(instance.reponses).toEqual({});
+        });
+    });
+    describe('initializeInstances', () => {
+        it('devrait creer au moins 1 instance si aucune reponse', () => {
+            const groupe = createMultipleGroupe();
+            const responses = createControlResponse(3);
+            const instances = GroupeInstanceManager.initializeInstances(groupe, responses);
+            expect(instances.length).toBeGreaterThanOrEqual(1);
+        });
+        it('devrait creer des instances basees sur les reponses existantes avec numeroMembre', () => {
+            const groupe = createMultipleGroupe();
+            const responses = {
+                ...createControlResponse(3),
+                'S1_01_1': createResponse('S1_01', 'Alice', 1),
+                'S1_02_1': createResponse('S1_02', '25', 1),
+                'S1_01_2': createResponse('S1_01', 'Bob', 2),
+                'S1_02_2': createResponse('S1_02', '30', 2),
+            };
+            const instances = GroupeInstanceManager.initializeInstances(groupe, responses);
+            expect(instances.length).toBe(2);
+        });
+        it('ne devrait PAS muter l\'objet responses original', () => {
+            const groupe = createMultipleGroupe();
+            const responses = {
+                ...createControlResponse(2),
+                'S1_01_1': createResponse('S1_01', 'Alice', 1),
+            };
+            const originalKeys = Object.keys(responses).sort();
+            GroupeInstanceManager.initializeInstances(groupe, responses);
+            expect(Object.keys(responses).sort()).toEqual(originalKeys);
+        });
+    });
+    describe('canAddInstance', () => {
+        it('devrait retourner false pour un groupe non multiple', () => {
+            const groupe = createGroupe({ estMultiple: false });
+            const result = GroupeInstanceManager.canAddInstance(groupe, {});
+            expect(result.canProceed).toBe(false);
+        });
+        it('devrait retourner true si currentCount < maxInstances', () => {
+            const groupe = createMultipleGroupe({
+                instances: [createInstance(1)]
+            });
+            const responses = createControlResponse(3);
+            const result = GroupeInstanceManager.canAddInstance(groupe, responses);
+            expect(result.canProceed).toBe(true);
+        });
+        it('devrait retourner false si currentCount >= maxInstances', () => {
+            const groupe = createMultipleGroupe({
+                instances: [createInstance(1), createInstance(2), createInstance(3)]
+            });
+            const responses = createControlResponse(3);
+            const result = GroupeInstanceManager.canAddInstance(groupe, responses);
+            expect(result.canProceed).toBe(false);
+        });
+    });
+    describe('canRemoveInstance', () => {
+        it('devrait retourner true si plus de 1 instance', () => {
+            const groupe = createMultipleGroupe({
+                instances: [createInstance(1), createInstance(2)]
+            });
+            const result = GroupeInstanceManager.canRemoveInstance(groupe, {});
+            expect(result.canProceed).toBe(true);
+        });
+        it('devrait retourner false si 1 seule instance', () => {
+            const groupe = createMultipleGroupe({
+                instances: [createInstance(1)]
+            });
+            const result = GroupeInstanceManager.canRemoveInstance(groupe, {});
+            expect(result.canProceed).toBe(false);
+        });
+        it('devrait retourner false si aucune instance', () => {
+            const groupe = createMultipleGroupe({
+                instances: []
+            });
+            const result = GroupeInstanceManager.canRemoveInstance(groupe, {});
+            expect(result.canProceed).toBe(false);
+        });
+    });
+    describe('addInstance', () => {
+        it('devrait ajouter une instance et retourner success=true', () => {
+            const groupe = createMultipleGroupe({
+                instances: [createInstance(1)]
+            });
+            const responses = createControlResponse(3);
+            const result = GroupeInstanceManager.addInstance(groupe, responses);
+            expect(result.success).toBe(true);
+            expect(result.instance).toBeDefined();
+            expect(result.instance.numeroInstance).toBe(2);
+        });
+        it('ne devrait PAS muter le groupe original (immutabilite)', () => {
+            const groupe = createMultipleGroupe({
+                instances: [createInstance(1)]
+            });
+            const originalLength = groupe.instances.length;
+            const responses = createControlResponse(3);
+            const result = GroupeInstanceManager.addInstance(groupe, responses);
+            expect(result.success).toBe(true);
+            // Apres Fix 2a: le groupe original ne doit PAS avoir ete mute
+            expect(groupe.instances.length).toBe(originalLength);
+            // Le nouveau groupe doit etre retourne dans updatedGroupe
+            expect(result.updatedGroupe).toBeDefined();
+            expect(result.updatedGroupe.instances.length).toBe(originalLength + 1);
+        });
+        it('devrait refuser si deja au maximum', () => {
+            const groupe = createMultipleGroupe({
+                instances: [createInstance(1), createInstance(2)]
+            });
+            const responses = createControlResponse(2);
+            const result = GroupeInstanceManager.addInstance(groupe, responses);
+            expect(result.success).toBe(false);
+            expect(result.error).toBeDefined();
+        });
+    });
+    describe('removeInstance', () => {
+        it('devrait supprimer une instance et retourner success=true', () => {
+            const groupe = createMultipleGroupe({
+                instances: [createInstance(1), createInstance(2)]
+            });
+            const responses = {
+                ...createControlResponse(2),
+                'S1_01_1': createResponse('S1_01', 'Alice', 1),
+                'S1_01_2': createResponse('S1_01', 'Bob', 2),
+            };
+            const result = GroupeInstanceManager.removeInstance(groupe, 1, responses);
+            expect(result.success).toBe(true);
+        });
+        it('ne devrait PAS muter le groupe original ni les reponses (immutabilite)', () => {
+            const groupe = createMultipleGroupe({
+                instances: [createInstance(1), createInstance(2)]
+            });
+            const responses = {
+                ...createControlResponse(2),
+                'S1_01_1': createResponse('S1_01', 'Alice', 1),
+                'S1_01_2': createResponse('S1_01', 'Bob', 2),
+            };
+            const originalGroupeInstancesLength = groupe.instances.length;
+            const originalResponsesKeys = Object.keys(responses).sort();
+            const result = GroupeInstanceManager.removeInstance(groupe, 1, responses);
+            expect(result.success).toBe(true);
+            // Apres Fix 2b: le groupe original ne doit PAS avoir ete mute
+            expect(groupe.instances.length).toBe(originalGroupeInstancesLength);
+            // Les reponses originales ne doivent PAS avoir ete mutees
+            expect(Object.keys(responses).sort()).toEqual(originalResponsesKeys);
+            // Les nouveaux objets doivent etre retournes
+            expect(result.updatedGroupe).toBeDefined();
+            expect(result.updatedResponses).toBeDefined();
+        });
+        it('devrait refuser si 1 seule instance', () => {
+            const groupe = createMultipleGroupe({
+                instances: [createInstance(1)]
+            });
+            const result = GroupeInstanceManager.removeInstance(groupe, 1, {});
+            expect(result.success).toBe(false);
+        });
+        it('devrait reordonner les instances apres suppression (2 supprime de [1,2,3] → [1,2])', () => {
+            const groupe = createMultipleGroupe({
+                instances: [createInstance(1), createInstance(2), createInstance(3)]
+            });
+            const responses = {
+                ...createControlResponse(3),
+                'S1_01_1': createResponse('S1_01', 'Alice', 1),
+                'S1_01_2': createResponse('S1_01', 'Bob', 2),
+                'S1_01_3': createResponse('S1_01', 'Charlie', 3),
+            };
+            const result = GroupeInstanceManager.removeInstance(groupe, 2, responses);
+            expect(result.success).toBe(true);
+            // Apres Fix 2b+2c: verifier via updatedGroupe
+            const updatedGroupe = result.updatedGroupe;
+            if (updatedGroupe) {
+                expect(updatedGroupe.instances.length).toBe(2);
+                expect(updatedGroupe.instances[0].numeroInstance).toBe(1);
+                expect(updatedGroupe.instances[1].numeroInstance).toBe(2);
+            }
+        });
+        it('devrait mettre a jour les cles de reponses apres reordonnancement', () => {
+            const groupe = createMultipleGroupe({
+                instances: [createInstance(1), createInstance(2), createInstance(3)]
+            });
+            const responses = {
+                ...createControlResponse(3),
+                'S1_01_1': createResponse('S1_01', 'Alice', 1),
+                'S1_01_2': createResponse('S1_01', 'Bob', 2),
+                'S1_01_3': createResponse('S1_01', 'Charlie', 3),
+            };
+            const result = GroupeInstanceManager.removeInstance(groupe, 1, responses);
+            expect(result.success).toBe(true);
+            // Apres Fix 2b+2c: verifier via updatedResponses
+            const updatedResponses = result.updatedResponses;
+            if (updatedResponses) {
+                // Instance 2 (Bob) → instance 1, Instance 3 (Charlie) → instance 2
+                expect(updatedResponses['S1_01_1']?.valeur).toBe('Bob');
+                expect(updatedResponses['S1_01_2']?.valeur).toBe('Charlie');
+                expect(updatedResponses['S1_01_3']).toBeUndefined();
+            }
+        });
+    });
+    describe('canModifyControlVariable', () => {
+        it('devrait retourner true si newValue >= existingInstances', () => {
+            const groupe = createMultipleGroupe({
+                instances: [createInstance(1), createInstance(2)]
+            });
+            const result = GroupeInstanceManager.canModifyControlVariable('S0_23', 3, [groupe], {});
+            expect(result.canProceed).toBe(true);
+        });
+        it('devrait retourner true si newValue = existingInstances (egal)', () => {
+            const groupe = createMultipleGroupe({
+                instances: [createInstance(1), createInstance(2)]
+            });
+            const result = GroupeInstanceManager.canModifyControlVariable('S0_23', 2, [groupe], {});
+            expect(result.canProceed).toBe(true);
+        });
+        it('devrait retourner false si newValue < existingInstances', () => {
+            const groupe = createMultipleGroupe({
+                instances: [createInstance(1), createInstance(2), createInstance(3)]
+            });
+            const result = GroupeInstanceManager.canModifyControlVariable('S0_23', 2, [groupe], {});
+            expect(result.canProceed).toBe(false);
+        });
+        it('devrait retourner true si aucun groupe n\'utilise cette variable', () => {
+            const groupe = createMultipleGroupe({
+                codeVariable: 'OTHER_VAR',
+                instances: [createInstance(1), createInstance(2)]
+            });
+            const result = GroupeInstanceManager.canModifyControlVariable('S0_23', 1, [groupe], {});
+            expect(result.canProceed).toBe(true);
+        });
+    });
+    describe('isInstanceComplete', () => {
+        it('devrait retourner true quand toutes les variables obligatoires sont remplies', () => {
+            const groupe = createMultipleGroupe({
+                variables: [
+                    createVariable('S1_01', { estObligatoire: true }),
+                    createVariable('S1_02', { estObligatoire: false })
+                ]
+            });
+            const instance = createInstance(1, {
+                S1_01: createResponse('S1_01', 'Alice', 1)
+            });
+            expect(GroupeInstanceManager.isInstanceComplete(instance, groupe)).toBe(true);
+        });
+        it('devrait retourner false quand une variable obligatoire manque', () => {
+            const groupe = createMultipleGroupe({
+                variables: [
+                    createVariable('S1_01', { estObligatoire: true }),
+                    createVariable('S1_02', { estObligatoire: true })
+                ]
+            });
+            const instance = createInstance(1, {
+                S1_01: createResponse('S1_01', 'Alice', 1)
+            });
+            expect(GroupeInstanceManager.isInstanceComplete(instance, groupe)).toBe(false);
+        });
+    });
+    describe('scenarios integration', () => {
+        it('S0_23=2, creer 2 instances, supprimer 1, ajouter 1 → doit fonctionner', () => {
+            // Setup: S0_23=2, 2 instances
+            let groupe = createMultipleGroupe({
+                instances: [createInstance(1), createInstance(2)]
+            });
+            let responses = {
+                ...createControlResponse(2),
+                'S1_01_1': createResponse('S1_01', 'Alice', 1),
+                'S1_01_2': createResponse('S1_01', 'Bob', 2),
+            };
+            // Supprimer instance 1
+            const removeResult = GroupeInstanceManager.removeInstance(groupe, 1, responses);
+            expect(removeResult.success).toBe(true);
+            // Utiliser les objets mis a jour si disponibles (apres Fix 2)
+            const updatedGroupe = removeResult.updatedGroupe || groupe;
+            const updatedResponses = removeResult.updatedResponses || responses;
+            // Ajouter une nouvelle instance
+            const addResult = GroupeInstanceManager.addInstance(updatedGroupe, updatedResponses);
+            expect(addResult.success).toBe(true);
+        });
+        it('S0_23=3, creer 3 instances, tenter d\'ajouter → doit bloquer', () => {
+            const groupe = createMultipleGroupe({
+                instances: [createInstance(1), createInstance(2), createInstance(3)]
+            });
+            const responses = createControlResponse(3);
+            const result = GroupeInstanceManager.addInstance(groupe, responses);
+            expect(result.success).toBe(false);
+        });
+        it('cycle complet ajout/suppression/ajout avec immutabilite', () => {
+            // Debut: 1 instance, max 3
+            let groupe = createMultipleGroupe({
+                instances: [createInstance(1)]
+            });
+            let responses = createControlResponse(3);
+            // Ajouter instance 2
+            let result = GroupeInstanceManager.addInstance(groupe, responses);
+            expect(result.success).toBe(true);
+            groupe = result.updatedGroupe || groupe;
+            // Ajouter instance 3
+            result = GroupeInstanceManager.addInstance(groupe, responses);
+            expect(result.success).toBe(true);
+            groupe = result.updatedGroupe || groupe;
+            // Tenter d'ajouter instance 4 → refuse
+            result = GroupeInstanceManager.addInstance(groupe, responses);
+            expect(result.success).toBe(false);
+            // Supprimer instance 2
+            const removeResult = GroupeInstanceManager.removeInstance(groupe, 2, responses);
+            expect(removeResult.success).toBe(true);
+            groupe = removeResult.updatedGroupe || groupe;
+            responses = removeResult.updatedResponses || responses;
+            // Ajouter a nouveau → doit fonctionner
+            result = GroupeInstanceManager.addInstance(groupe, responses);
+            expect(result.success).toBe(true);
+        });
+    });
+});

package/dist/lib/utils/groupeInstanceManager.d.ts

@@ -15,6 +15,8 @@ export declare class GroupeInstanceManager {
     static getMinInstances(groupe: GroupeFormulaire): number;
     /**
      * 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: GroupeFormulaire, responses: Record<string, EnqueteReponse>): number;
     /**
@@ -42,18 +44,23 @@ export declare class GroupeInstanceManager {
      */
     static canModifyControlVariable(variableCode: string, newValue: number, groupesMultiples: GroupeFormulaire[], responses: Record<string, EnqueteReponse>): ConstraintValidationResult;
     /**
-     * Ajoute une nouvelle instance à un groupe
+     * Ajoute une nouvelle instance à un groupe (immutable)
+     * Retourne un nouveau groupe sans muter l'original
      */
     static addInstance(groupe: GroupeFormulaire, responses: Record<string, EnqueteReponse>): {
         success: boolean;
         instance?: GroupeInstance;
+        updatedGroupe?: GroupeFormulaire;
         error?: string;
     };
     /**
-     * Supprime une instance d'un groupe
+     * Supprime une instance d'un groupe (immutable)
+     * Retourne de nouveaux objets sans muter les originaux
      */
     static removeInstance(groupe: GroupeFormulaire, instanceNumber: number, responses: Record<string, EnqueteReponse>): {
         success: boolean;
+        updatedGroupe?: GroupeFormulaire;
+        updatedResponses?: Record<string, EnqueteReponse>;
         error?: string;
     };
     /**
@@ -81,8 +88,12 @@ export declare class GroupeInstanceManager {
         progressPercentage: number;
     };
     /**
-     * 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: GroupeFormulaire, responses: Record<string, EnqueteReponse>): void;
+    static reorderInstances(instances: GroupeInstance[], responses: Record<string, EnqueteReponse>, groupe: GroupeFormulaire): {
+        reorderedInstances: GroupeInstance[];
+        reorderedResponses: Record<string, EnqueteReponse>;
+    };
 }
 //# sourceMappingURL=groupeInstanceManager.d.ts.map

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

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

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rsuci/shared-form-components",
-  "version": "1.0.86",
+  "version": "1.0.87",
   "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",