@rsuci/shared-form-components 1.0.29 → 1.0.32

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

@@ -0,0 +1,114 @@
+/**
+ * Contexte React pour le FormRenderer
+ * Partage l'état et les fonctions entre tous les sous-composants
+ * RSU v2 - Package Partagé
+ */
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useMemo } from 'react';
+import { useFormRenderer } from '../../hooks/useFormRenderer';
+// Création du contexte avec valeur par défaut null
+const FormRendererContext = createContext(null);
+/**
+ * Provider pour le contexte FormRenderer
+ * Encapsule useFormRenderer et fournit l'état à tous les enfants
+ */
+export const FormRendererProvider = ({ children, formulaire, enquete, initialResponses, config, callbacks, services, geographicComponents, disabled, isSubmitting: externalIsSubmitting, isVariableVisible, debug }) => {
+    // Utiliser le hook principal
+    const formRenderer = useFormRenderer(formulaire, enquete, {
+        config,
+        initialResponses: initialResponses || enquete?.reponses,
+        onResponsesChange: callbacks.onResponsesChange,
+        onGroupChange: callbacks.onGroupChange,
+        isVariableVisible,
+        debug
+    });
+    // Construire la valeur du contexte
+    const contextValue = useMemo(() => ({
+        ...formRenderer,
+        // Données initiales
+        formulaire,
+        enquete,
+        // Configuration
+        config,
+        // Callbacks
+        callbacks,
+        // Services
+        services,
+        geographicComponents,
+        // Surcharges externes
+        isSubmitting: externalIsSubmitting ?? formRenderer.isSubmitting,
+        effectiveDisabled: disabled ?? formRenderer.effectiveDisabled
+    }), [
+        formRenderer,
+        formulaire,
+        enquete,
+        config,
+        callbacks,
+        services,
+        geographicComponents,
+        externalIsSubmitting,
+        disabled
+    ]);
+    return (_jsx(FormRendererContext.Provider, { value: contextValue, children: children }));
+};
+/**
+ * Hook pour accéder au contexte FormRenderer
+ * Doit être utilisé à l'intérieur d'un FormRendererProvider
+ */
+export function useFormRendererContext() {
+    const context = useContext(FormRendererContext);
+    if (!context) {
+        throw new Error('useFormRendererContext doit être utilisé à l\'intérieur d\'un FormRendererProvider');
+    }
+    return context;
+}
+/**
+ * Hook pour accéder uniquement à la navigation
+ */
+export function useFormRendererNavigation() {
+    const { navigation } = useFormRendererContext();
+    return navigation;
+}
+/**
+ * Hook pour accéder uniquement à la validation
+ */
+export function useFormRendererValidation() {
+    const { validation } = useFormRendererContext();
+    return validation;
+}
+/**
+ * Hook pour accéder uniquement aux instances
+ */
+export function useFormRendererInstances() {
+    const { instances } = useFormRendererContext();
+    return instances;
+}
+/**
+ * Hook pour accéder à la configuration
+ */
+export function useFormRendererConfig() {
+    const { mode, features, config } = useFormRendererContext();
+    return { mode, features, config };
+}
+/**
+ * Hook pour accéder aux réponses
+ */
+export function useFormRendererResponses() {
+    const { responses, updateResponse, getResponseValue } = useFormRendererContext();
+    return { responses, updateResponse, getResponseValue };
+}
+/**
+ * Hook pour accéder à l'état global
+ */
+export function useFormRendererState() {
+    const { hasUnsavedChanges, isSubmitting, effectiveDisabled, isReadOnly, isConsultationMode } = useFormRendererContext();
+    return {
+        hasUnsavedChanges,
+        isSubmitting,
+        effectiveDisabled,
+        isReadOnly,
+        isConsultationMode
+    };
+}
+export default FormRendererContext;

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

@@ -0,0 +1,18 @@
+/**
+ * Composant d'interface à onglets pour les instances multiples de groupes
+ * RSU v2 - Moteur de Rendu des Formulaires d'Enquête
+ */
+import React from 'react';
+import { GroupeFormulaire, EnqueteReponse, GroupeInstance } from '../../types/enquete';
+export interface GroupeInstanceTabsProps {
+    groupe: GroupeFormulaire;
+    currentInstanceIndex: number;
+    responses: Record<string, EnqueteReponse>;
+    onInstanceChange: (instanceIndex: number) => void;
+    onInstanceAdded: (instance: GroupeInstance) => void;
+    onInstanceRemoved: (instanceNumber: number) => void;
+    disabled?: boolean;
+}
+declare const GroupeInstanceTabs: React.FC<GroupeInstanceTabsProps>;
+export default GroupeInstanceTabs;
+//# sourceMappingURL=GroupeInstanceTabs.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,174 @@
+/**
+ * Composant d'interface à onglets pour les instances multiples de groupes
+ * RSU v2 - Moteur de Rendu des Formulaires d'Enquête
+ */
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useEffect } from 'react';
+import { Plus, Minus, AlertTriangle, Check, AlertCircle, AlertTriangle as ExclamationIcon } from 'lucide-react';
+import { GroupeInstanceManager } from '../../lib/utils/groupeInstanceManager';
+import ConfirmationModal from './ConfirmationModal';
+const GroupeInstanceTabs = ({ groupe, currentInstanceIndex, responses, onInstanceChange, onInstanceAdded, onInstanceRemoved, disabled = false }) => {
+    const [isProcessing, setIsProcessing] = useState(false);
+    const [error, setError] = useState(null);
+    const [forceUpdate, setForceUpdate] = useState(0);
+    const [showDeleteConfirmation, setShowDeleteConfirmation] = useState(false);
+    // Ne pas afficher pour les groupes non multiples
+    if (!groupe.estMultiple || !groupe.instances) {
+        return null;
+    }
+    // Calculer les informations sur les instances
+    const currentCount = GroupeInstanceManager.getInstancesCount(groupe, responses);
+    const maxInstances = GroupeInstanceManager.getMaxInstances(groupe, responses);
+    const canAdd = GroupeInstanceManager.canAddInstance(groupe, responses);
+    const canRemove = GroupeInstanceManager.canRemoveInstance(groupe, responses);
+    // CORRECTION: Détecter les changements de maxInstances et forcer le re-rendu
+    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]);
+    // PROTECTION DES DONNÉES: Afficher toutes les instances existantes, même si la variable de contrôle est plus petite
+    // 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;
+        if (responseCount === 0) {
+            return 'empty';
+        }
+        if (GroupeInstanceManager.isInstanceComplete(instance, groupe)) {
+            return 'complete';
+        }
+        return 'incomplete';
+    };
+    // Fonction pour obtenir l'icône et la couleur selon l'état
+    const getInstanceDisplay = (instance, isActive) => {
+        const state = getInstanceState(instance);
+        const baseClasses = `
+      flex items-center justify-center min-w-[3rem] h-10 px-3 rounded-lg font-medium text-sm
+      transition-all duration-200 cursor-pointer border-2
+    `;
+        let stateClasses = '';
+        let icon = null;
+        switch (state) {
+            case 'complete':
+                stateClasses = isActive
+                    ? 'bg-blue-600 text-white border-blue-600 shadow-lg'
+                    : 'bg-green-100 text-green-700 border-green-300 hover:bg-green-200';
+                icon = _jsx(Check, { className: "h-4 w-4 ml-1" });
+                break;
+            case 'incomplete':
+                stateClasses = isActive
+                    ? 'bg-blue-600 text-white border-blue-600 shadow-lg'
+                    : 'bg-green-100 text-orange-700 border-green-300 hover:bg-green-200';
+                icon = _jsx(AlertCircle, { className: "h-4 w-4 ml-1" });
+                break;
+            case 'empty':
+                stateClasses = isActive
+                    ? 'bg-blue-600 text-white border-blue-600 shadow-lg'
+                    : 'bg-gray-600 text-white border-gray-600 hover:bg-gray-700';
+                icon = _jsx(ExclamationIcon, { className: "h-4 w-4 ml-1" });
+                break;
+        }
+        return {
+            className: `${baseClasses} ${stateClasses}`,
+            icon
+        };
+    };
+    const handleInstanceClick = (instanceIndex) => {
+        // En mode consultation, permettre la navigation entre onglets mais pas les modifications
+        if (isProcessing)
+            return;
+        onInstanceChange(instanceIndex);
+    };
+    const handleAddInstance = async () => {
+        if (disabled || isProcessing)
+            return;
+        setIsProcessing(true);
+        setError(null);
+        try {
+            const result = GroupeInstanceManager.addInstance(groupe, responses);
+            if (result.success && result.instance) {
+                onInstanceAdded(result.instance);
+            }
+            else {
+                setError(result.error || 'Erreur lors de l\'ajout de l\'instance');
+            }
+        }
+        catch (err) {
+            setError('Erreur inattendue lors de l\'ajout de l\'instance');
+            console.error('Erreur ajout instance:', err);
+        }
+        finally {
+            setIsProcessing(false);
+        }
+    };
+    const handleRemoveInstanceClick = () => {
+        if (disabled || isProcessing || !groupe.instances)
+            return;
+        setShowDeleteConfirmation(true);
+    };
+    const handleConfirmRemoveInstance = async () => {
+        if (disabled || isProcessing || !groupe.instances)
+            return;
+        setShowDeleteConfirmation(false);
+        setIsProcessing(true);
+        setError(null);
+        try {
+            // Supprimer l'instance actuellement affichée (correction du bug)
+            const currentInstance = groupe.instances[currentInstanceIndex];
+            if (!currentInstance) {
+                setError('Aucune instance sélectionnée à supprimer');
+                return;
+            }
+            const result = GroupeInstanceManager.removeInstance(groupe, currentInstance.numeroInstance, responses);
+            if (result.success) {
+                onInstanceRemoved(currentInstance.numeroInstance);
+            }
+            else {
+                setError(result.error || 'Erreur lors de la suppression de l\'instance');
+            }
+        }
+        catch (err) {
+            setError('Erreur inattendue lors de la suppression de l\'instance');
+            console.error('Erreur suppression instance:', err);
+        }
+        finally {
+            setIsProcessing(false);
+        }
+    };
+    const handleCancelRemoveInstance = () => {
+        setShowDeleteConfirmation(false);
+    };
+    return (_jsxs("div", { className: "w-full", children: [_jsxs("div", { className: "flex items-center space-x-2 overflow-x-auto pb-2 relative", children: [_jsx("div", { className: "flex space-x-2 flex-shrink-0", children: displayedInstances.map((instance, index) => {
+                            const isActive = index === currentInstanceIndex;
+                            const display = getInstanceDisplay(instance, isActive);
+                            return (_jsxs("button", { onClick: () => handleInstanceClick(index), disabled: isProcessing, className: display.className, title: `Instance ${instance.numeroInstance} - ${getInstanceState(instance) === 'complete' ? 'Complète' : getInstanceState(instance) === 'incomplete' ? 'Incomplète' : 'Vide'}`, children: [_jsx("span", { className: "font-semibold", children: instance.numeroInstance }), display.icon] }, instance.numeroInstance));
+                        }) }), _jsx("div", { className: "h-6 w-px bg-gray-300 flex-shrink-0" }), _jsxs("div", { className: "flex items-center space-x-2 flex-shrink-0", children: [_jsx("button", { type: "button", onClick: handleAddInstance, disabled: disabled || isProcessing || !canAdd.canProceed, className: `p-2 rounded-lg transition-colors flex-shrink-0 ${disabled || isProcessing || !canAdd.canProceed
+                                    ? 'bg-gray-100 text-gray-400 cursor-not-allowed'
+                                    : 'bg-green-500 text-white hover:bg-green-600 focus:ring-2 focus:ring-green-500 focus:ring-offset-2'}`, title: canAdd.canProceed ? 'Ajouter une instance' : canAdd.constraints[0]?.message, children: _jsx(Plus, { className: "h-4 w-4" }) }), _jsx("button", { type: "button", onClick: handleRemoveInstanceClick, disabled: disabled || isProcessing || !canRemove.canProceed, className: `p-2 rounded-lg transition-colors flex-shrink-0 ${disabled || isProcessing || !canRemove.canProceed
+                                    ? 'bg-gray-100 text-gray-400 cursor-not-allowed'
+                                    : 'bg-red-500 text-white hover:bg-red-600 focus:ring-2 focus:ring-red-500 focus:ring-offset-2'}`, title: canRemove.canProceed ? 'Supprimer l\'instance courante' : canRemove.constraints[0]?.message, children: _jsx(Minus, { className: "h-4 w-4" }) }), isProcessing && (_jsx("div", { className: "animate-spin rounded-full h-4 w-4 border-b-2 border-blue-600 flex-shrink-0" }))] })] }), error && (_jsxs("div", { className: "mt-2 p-2 bg-red-50 border border-red-200 rounded-lg shadow-sm", children: [_jsxs("div", { className: "flex items-start space-x-2", children: [_jsx(AlertTriangle, { className: "h-4 w-4 text-red-500 flex-shrink-0 mt-0.5" }), _jsx("div", { className: "text-sm text-red-700", children: error })] }), _jsx("button", { onClick: () => setError(null), className: "absolute top-1 right-1 text-red-400 hover:text-red-600", children: "\u00D7" })] })), showDeleteConfirmation && (_jsx(ConfirmationModal, { isOpen: showDeleteConfirmation, title: "Confirmer la suppression", message: `Êtes-vous sûr de vouloir supprimer l'instance ${groupe.instances?.[currentInstanceIndex]?.numeroInstance || currentInstanceIndex + 1} ? Cette action est irréversible.`, confirmText: "Supprimer", cancelText: "Annuler", onConfirm: handleConfirmRemoveInstance, onCancel: handleCancelRemoveInstance, type: "danger" }))] }));
+};
+export default GroupeInstanceTabs;

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

@@ -0,0 +1,17 @@
+/**
+ * Exports du module form-renderer
+ * RSU v2 - Composants partagés de rendu de formulaires
+ */
+export { default as ConfirmationModal } from './ConfirmationModal';
+export type { ConfirmationModalProps, ConfirmationModalType } from './ConfirmationModal';
+export { default as GroupeInstanceTabs } from './GroupeInstanceTabs';
+export type { GroupeInstanceTabsProps } from './GroupeInstanceTabs';
+export { FormRendererProvider, useFormRendererContext, useFormRendererNavigation, useFormRendererValidation, useFormRendererInstances, useFormRendererConfig, useFormRendererResponses, useFormRendererState, type FormRendererContextValue, type FormRendererProviderProps } from './FormRendererContext';
+export { default as FormProgress } from './FormProgress';
+export type { FormProgressProps } from './FormProgress';
+export { default as FormNavigationButtons } from './FormNavigationButtons';
+export type { FormNavigationButtonsProps } from './FormNavigationButtons';
+export { default as FormActions } from './FormActions';
+export type { FormActionsProps } from './FormActions';
+export { default as FormRenderer, type FormRendererProps } from './FormRenderer';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/form-renderer/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH,OAAO,EAAE,OAAO,IAAI,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACnE,YAAY,EAAE,sBAAsB,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAEzF,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AACrE,YAAY,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AAMpE,OAAO,EACL,oBAAoB,EACpB,sBAAsB,EACtB,yBAAyB,EACzB,yBAAyB,EACzB,wBAAwB,EACxB,qBAAqB,EACrB,wBAAwB,EACxB,oBAAoB,EACpB,KAAK,wBAAwB,EAC7B,KAAK,yBAAyB,EAC/B,MAAM,uBAAuB,CAAC;AAM/B,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,gBAAgB,CAAC;AACzD,YAAY,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAExD,OAAO,EAAE,OAAO,IAAI,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAC3E,YAAY,EAAE,0BAA0B,EAAE,MAAM,yBAAyB,CAAC;AAE1E,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,eAAe,CAAC;AACvD,YAAY,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAMtD,OAAO,EACL,OAAO,IAAI,YAAY,EACvB,KAAK,iBAAiB,EACvB,MAAM,gBAAgB,CAAC"}

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

@@ -0,0 +1,23 @@
+/**
+ * Exports du module form-renderer
+ * RSU v2 - Composants partagés de rendu de formulaires
+ */
+// ========================================
+// COMPOSANTS UI DE BASE
+// ========================================
+export { default as ConfirmationModal } from './ConfirmationModal';
+export { default as GroupeInstanceTabs } from './GroupeInstanceTabs';
+// ========================================
+// CONTEXTE ET PROVIDER
+// ========================================
+export { FormRendererProvider, useFormRendererContext, useFormRendererNavigation, useFormRendererValidation, useFormRendererInstances, useFormRendererConfig, useFormRendererResponses, useFormRendererState } from './FormRendererContext';
+// ========================================
+// SOUS-COMPOSANTS DU FORM RENDERER
+// ========================================
+export { default as FormProgress } from './FormProgress';
+export { default as FormNavigationButtons } from './FormNavigationButtons';
+export { default as FormActions } from './FormActions';
+// ========================================
+// COMPOSANT PRINCIPAL FORM RENDERER
+// ========================================
+export { default as FormRenderer } from './FormRenderer';

package/dist/hooks/useFormInstances.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Hook de gestion des instances multiples pour les formulaires d'enquête
+ * Gère l'ajout, la suppression et la synchronisation des instances de groupes
+ * RSU v2 - Package Partagé
+ */
+import { GroupeFormulaire, GroupeInstance, EnqueteReponse } from '../types/enquete';
+export interface UseFormInstancesOptions {
+    /** Callback appelé lors de l'ajout d'une instance */
+    onInstanceAdded?: (instance: GroupeInstance) => void;
+    /** Callback appelé lors de la suppression d'une instance */
+    onInstanceRemoved?: (instanceNumber: number) => void;
+    /** Callback appelé lors du changement d'instance active */
+    onInstanceChange?: (instanceIndex: number) => void;
+    /** Callback appelé lors de la mise à jour des groupes */
+    onGroupesUpdated?: (groupes: GroupeFormulaire[]) => void;
+    /** Mode debug */
+    debug?: boolean;
+}
+export interface UseFormInstancesResult {
+    /** Groupes avec leurs instances initialisées */
+    groupesWithInstances: GroupeFormulaire[];
+    /** Index de l'instance actuellement active */
+    currentInstanceIndex: number;
+    /** Instance actuellement active */
+    currentInstance: GroupeInstance | undefined;
+    /** Ajouter une instance au groupe actuel */
+    addInstance: (groupe: GroupeFormulaire, responses: Record<string, EnqueteReponse>) => {
+        success: boolean;
+        instance?: GroupeInstance;
+        error?: string;
+    };
+    /** Supprimer une instance du groupe actuel */
+    removeInstance: (groupe: GroupeFormulaire, instanceNumber: number, responses: Record<string, EnqueteReponse>) => {
+        success: boolean;
+        error?: string;
+    };
+    /** Changer d'instance active */
+    changeInstance: (instanceIndex: number) => void;
+    /** Synchroniser les réponses avec l'instance */
+    syncInstanceResponses: (instance: GroupeInstance, groupe: GroupeFormulaire, allResponses: Record<string, EnqueteReponse>) => void;
+    /** Mettre à jour les propriétés d'un groupe */
+    updateGroupeProperties: (groupe: GroupeFormulaire, responses: Record<string, EnqueteReponse>) => void;
+    /** Initialiser les groupes avec instances */
+    initializeGroupesWithInstances: (groupes: GroupeFormulaire[], responses: Record<string, EnqueteReponse>) => GroupeFormulaire[];
+    /** Vérifier si une instance est complète */
+    isInstanceComplete: (instance: GroupeInstance, groupe: GroupeFormulaire) => boolean;
+    /** Peut-on ajouter une instance ? */
+    canAddInstance: (groupe: GroupeFormulaire, responses: Record<string, EnqueteReponse>) => {
+        canProceed: boolean;
+        constraints: Array<{
+            message: string;
+        }>;
+    };
+    /** Peut-on supprimer une instance ? */
+    canRemoveInstance: (groupe: GroupeFormulaire, responses: Record<string, EnqueteReponse>) => {
+        canProceed: boolean;
+        constraints: Array<{
+            message: string;
+        }>;
+    };
+    /** Mettre à jour les groupes avec instances */
+    setGroupesWithInstances: React.Dispatch<React.SetStateAction<GroupeFormulaire[]>>;
+}
+/**
+ * Hook pour gérer les instances multiples dans un formulaire d'enquête
+ *
+ * @param initialGroupes - Liste initiale des groupes du formulaire
+ * @param initialResponses - Réponses initiales
+ * @param options - Options de configuration
+ * @returns Objet contenant l'état et les fonctions de gestion des instances
+ *
+ * @example
+ * ```tsx
+ * const {
+ *   groupesWithInstances,
+ *   addInstance,
+ *   removeInstance,
+ *   currentInstance
+ * } = useFormInstances(formulaire.groupes, enquete.reponses, {
+ *   onInstanceAdded: (instance) => console.log('Added:', instance),
+ *   onInstanceRemoved: (num) => console.log('Removed:', num)
+ * });
+ * ```
+ */
+export declare function useFormInstances(initialGroupes: GroupeFormulaire[], initialResponses: Record<string, EnqueteReponse>, options?: UseFormInstancesOptions): UseFormInstancesResult;
+export default useFormInstances;
+//# sourceMappingURL=useFormInstances.d.ts.map

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

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

package/dist/hooks/useFormInstances.js

@@ -0,0 +1,197 @@
+/**
+ * Hook de gestion des instances multiples pour les formulaires d'enquête
+ * Gère l'ajout, la suppression et la synchronisation des instances de groupes
+ * RSU v2 - Package Partagé
+ */
+import { useState, useCallback, useEffect } from 'react';
+import { GroupeInstanceManager } from '../lib/utils/groupeInstanceManager';
+/**
+ * Hook pour gérer les instances multiples dans un formulaire d'enquête
+ *
+ * @param initialGroupes - Liste initiale des groupes du formulaire
+ * @param initialResponses - Réponses initiales
+ * @param options - Options de configuration
+ * @returns Objet contenant l'état et les fonctions de gestion des instances
+ *
+ * @example
+ * ```tsx
+ * const {
+ *   groupesWithInstances,
+ *   addInstance,
+ *   removeInstance,
+ *   currentInstance
+ * } = useFormInstances(formulaire.groupes, enquete.reponses, {
+ *   onInstanceAdded: (instance) => console.log('Added:', instance),
+ *   onInstanceRemoved: (num) => console.log('Removed:', num)
+ * });
+ * ```
+ */
+export function useFormInstances(initialGroupes, initialResponses, options = {}) {
+    const { onInstanceAdded, onInstanceRemoved, onInstanceChange, onGroupesUpdated, debug = false } = options;
+    // État des groupes avec instances
+    const [groupesWithInstances, setGroupesWithInstances] = useState([]);
+    // Index de l'instance active
+    const [currentInstanceIndex, setCurrentInstanceIndex] = useState(0);
+    // Fonction utilitaire pour logger en mode debug
+    const log = useCallback((message, data) => {
+        if (debug) {
+            console.log(`[FormInstances] ${message}`, data || '');
+        }
+    }, [debug]);
+    /**
+     * Initialiser les groupes avec leurs instances
+     */
+    const initializeGroupesWithInstances = useCallback((groupes, responses) => {
+        if (!groupes)
+            return [];
+        log('Initialisation des groupes multiples:', {
+            groupesCount: groupes.length,
+            responsesCount: Object.keys(responses).length
+        });
+        return groupes.map(groupe => {
+            if (groupe.estMultiple) {
+                log('Traitement groupe multiple:', {
+                    groupeCode: groupe.code,
+                    codeVariable: groupe.codeVariable,
+                    designation: groupe.designation
+                });
+                // Initialiser les propriétés pour les groupes multiples
+                GroupeInstanceManager.updateGroupeProperties(groupe, responses);
+                // S'assurer qu'il y a toujours au moins une instance
+                if (!groupe.instances || groupe.instances.length === 0) {
+                    groupe.instances = [GroupeInstanceManager.createInstance(groupe, 1)];
+                }
+                // Synchroniser les réponses avec chaque instance
+                groupe.instances.forEach((instance, index) => {
+                    GroupeInstanceManager.syncInstanceResponses(instance, groupe, responses);
+                });
+            }
+            return groupe;
+        });
+    }, [log]);
+    // Initialisation au montage
+    useEffect(() => {
+        if (initialGroupes?.length) {
+            const initialized = initializeGroupesWithInstances(initialGroupes, initialResponses);
+            setGroupesWithInstances(initialized);
+        }
+    }, []);
+    /**
+     * Ajouter une instance à un groupe
+     */
+    const addInstance = useCallback((groupe, responses) => {
+        const result = GroupeInstanceManager.addInstance(groupe, responses);
+        if (result.success && result.instance) {
+            log('Instance ajoutée:', {
+                groupeCode: groupe.code,
+                instanceNumber: result.instance.numeroInstance
+            });
+            // Mettre à jour les groupes
+            setGroupesWithInstances(prev => {
+                const updated = prev.map(g => {
+                    if (g.code === groupe.code) {
+                        return { ...groupe };
+                    }
+                    return g;
+                });
+                if (onGroupesUpdated) {
+                    onGroupesUpdated(updated);
+                }
+                return updated;
+            });
+            if (onInstanceAdded) {
+                onInstanceAdded(result.instance);
+            }
+        }
+        return result;
+    }, [log, onInstanceAdded, onGroupesUpdated]);
+    /**
+     * Supprimer une instance d'un groupe
+     */
+    const removeInstance = useCallback((groupe, instanceNumber, responses) => {
+        const result = GroupeInstanceManager.removeInstance(groupe, instanceNumber, responses);
+        if (result.success) {
+            log('Instance supprimée:', {
+                groupeCode: groupe.code,
+                instanceNumber
+            });
+            // Mettre à jour les groupes
+            setGroupesWithInstances(prev => {
+                const updated = prev.map(g => {
+                    if (g.code === groupe.code) {
+                        return { ...groupe };
+                    }
+                    return g;
+                });
+                if (onGroupesUpdated) {
+                    onGroupesUpdated(updated);
+                }
+                return updated;
+            });
+            if (onInstanceRemoved) {
+                onInstanceRemoved(instanceNumber);
+            }
+        }
+        return result;
+    }, [log, onInstanceRemoved, onGroupesUpdated]);
+    /**
+     * Changer d'instance active
+     */
+    const changeInstance = useCallback((instanceIndex) => {
+        setCurrentInstanceIndex(instanceIndex);
+        if (onInstanceChange) {
+            onInstanceChange(instanceIndex);
+        }
+    }, [onInstanceChange]);
+    /**
+     * Synchroniser les réponses avec l'instance
+     */
+    const syncInstanceResponses = useCallback((instance, groupe, allResponses) => {
+        GroupeInstanceManager.syncInstanceResponses(instance, groupe, allResponses);
+    }, []);
+    /**
+     * Mettre à jour les propriétés d'un groupe
+     */
+    const updateGroupeProperties = useCallback((groupe, responses) => {
+        GroupeInstanceManager.updateGroupeProperties(groupe, responses);
+    }, []);
+    /**
+     * Vérifier si une instance est complète
+     */
+    const isInstanceComplete = useCallback((instance, groupe) => {
+        return GroupeInstanceManager.isInstanceComplete(instance, groupe);
+    }, []);
+    /**
+     * Peut-on ajouter une instance ?
+     */
+    const canAddInstance = useCallback((groupe, responses) => {
+        return GroupeInstanceManager.canAddInstance(groupe, responses);
+    }, []);
+    /**
+     * Peut-on supprimer une instance ?
+     */
+    const canRemoveInstance = useCallback((groupe, responses) => {
+        return GroupeInstanceManager.canRemoveInstance(groupe, responses);
+    }, []);
+    /**
+     * Instance actuellement active
+     */
+    const currentInstance = groupesWithInstances.find(g => g.estMultiple)
+        ?.instances?.[currentInstanceIndex];
+    return {
+        groupesWithInstances,
+        currentInstanceIndex,
+        currentInstance,
+        addInstance,
+        removeInstance,
+        changeInstance,
+        syncInstanceResponses,
+        updateGroupeProperties,
+        initializeGroupesWithInstances,
+        isInstanceComplete,
+        canAddInstance,
+        canRemoveInstance,
+        setGroupesWithInstances
+    };
+}
+export default useFormInstances;