@appius-fr/apx 2.5.0 → 2.6.0

package/modules/tools/form-packer/packToJson.mjs

@@ -0,0 +1,549 @@
+/**
+ * Convertit un formulaire HTML en objet JSON
+ * @param {HTMLFormElement} form - Le formulaire à convertir
+ * @returns {Object} L'objet JSON résultant
+ * @throws {TypeError} Si form n'est pas un HTMLFormElement
+ */
+export const packFormToJSON = (form) => {
+    // Validation de l'entrée
+    if (!form || !(form instanceof HTMLFormElement)) {
+        throw new TypeError('packFormToJSON expects an HTMLFormElement');
+    }
+
+    const formData = new FormData(form);
+    const jsonData = {};
+    
+    /**
+     * Construit une représentation string du chemin pour les messages d'erreur
+     * @param {Array} parts - Les parties du chemin
+     * @returns {string} Le chemin formaté
+     */
+    const buildPathString = (parts) => {
+        return parts.reduce((path, part) => {
+            if (part.type === 'key') {
+                return path ? `${path}[${part.name}]` : part.name;
+            }
+            if (part.type === 'numeric') {
+                return `${path}[${part.index}]`;
+            }
+            if (part.type === 'array') {
+                return `${path}[]`;
+            }
+            return path;
+        }, '');
+    };
+    
+    // ============================================================================
+    // PHASE 1 : ANALYSE ET DÉTECTION DES CONFLITS
+    // ============================================================================
+    
+    /**
+     * Structure pour stocker l'utilisation d'un chemin
+     * @typedef {Object} PathUsage
+     * @property {boolean} isFinal - Le chemin est utilisé comme valeur finale
+     * @property {boolean} isIntermediate - Le chemin est utilisé comme chemin intermédiaire
+     * @property {boolean} hasArraySuffix - Le chemin se termine par [] (crée des valeurs primitives)
+     * @property {string} key - La clé du formulaire qui utilise ce chemin
+     */
+    
+    const pathUsage = new Map(); // Map<pathString, PathUsage>
+    const keyAnalysis = new Map(); // Map<basePath, {hasNumeric: boolean, hasString: boolean}>
+    const allEntries = [];
+    
+    /**
+     * Enregistre l'utilisation d'un chemin dans pathUsage
+     * @param {string} currentPath - Le chemin à enregistrer
+     * @param {boolean} isFinal - Si c'est une valeur finale
+     * @param {boolean} isArraySuffix - Si le chemin se termine par []
+     * @param {string} key - La clé du formulaire
+     */
+    const recordPathUsage = (currentPath, isFinal, isArraySuffix, key) => {
+        const usage = pathUsage.get(currentPath) ?? {
+            isFinal: false,
+            isIntermediate: false,
+            hasArraySuffix: false,
+            key
+        };
+        
+        if (!pathUsage.has(currentPath)) {
+            pathUsage.set(currentPath, usage);
+        }
+        
+        if (isFinal) {
+            usage.isFinal = true;
+            usage.key = key;
+            if (isArraySuffix) {
+                usage.hasArraySuffix = true;
+            }
+        } else {
+            usage.isIntermediate = true;
+            usage.key ??= key;
+        }
+    };
+    
+    // Première passe : analyser toutes les clés et enregistrer les chemins
+    for (const [key, value] of formData.entries()) {
+        if (!key) continue;
+        
+        allEntries.push({ key, value });
+        const parts = parseKey(key);
+        
+        // Construire tous les chemins intermédiaires et le chemin final
+        let currentPath = '';
+        
+        for (let i = 0; i < parts.length; i++) {
+            const part = parts[i];
+            const isLast = i === parts.length - 1;
+            const isArraySuffix = part.type === 'array';
+            
+            // Construire le chemin jusqu'à ce niveau
+            if (part.type === 'key') {
+                currentPath = currentPath ? `${currentPath}[${part.name}]` : part.name;
+            } else if (part.type === 'numeric') {
+                currentPath = `${currentPath}[${part.index}]`;
+            } else if (part.type === 'array') {
+                currentPath = `${currentPath}[]`;
+            }
+            
+            // Enregistrer l'utilisation du chemin
+            recordPathUsage(currentPath, isLast, isArraySuffix && isLast, key);
+        }
+        
+        // Analyser chaque niveau de la hiérarchie pour détecter les conflits (indices numériques vs clés de chaîne)
+        for (let i = 0; i < parts.length - 1; i++) {
+            const part = parts[i];
+            const nextPart = parts[i + 1];
+            
+            // Analyser seulement les clés (pas les indices numériques)
+            if (part.type === 'key') {
+                const basePath = part.name; // Le nom de la première clé dans le chemin
+                
+                const analysis = keyAnalysis.get(basePath) ?? { hasNumeric: false, hasString: false };
+                if (!keyAnalysis.has(basePath)) {
+                    keyAnalysis.set(basePath, analysis);
+                }
+                
+                if (nextPart) {
+                    if (nextPart.type === 'numeric') {
+                        analysis.hasNumeric = true;
+                    } else if (nextPart.type === 'key' || nextPart.type === 'array') {
+                        analysis.hasString = true;
+                    }
+                }
+            }
+        }
+    }
+    
+    /**
+     * Détecte et lève une exception pour tous les conflits de chemins
+     * 
+     * Principe simple : pour chaque chemin final (valeur primitive), vérifier si un chemin
+     * intermédiaire commence par ce chemin suivi de '['. Si c'est le cas, c'est un conflit.
+     * 
+     * Cette approche unifiée couvre tous les cas :
+     * - items[] (final) vs items[0][name] (intermédiaire)
+     * - array[3] (final) vs array[3][nested] (intermédiaire)
+     * - data[key] (final) vs data[key][sub] (intermédiaire)
+     */
+    const detectPathConflicts = () => {
+        // 1. Collecter tous les chemins finaux (valeurs primitives)
+        const finalPaths = new Set();
+        const finalPathKeys = new Map(); // Pour les messages d'erreur
+        
+        for (const [path, usage] of pathUsage.entries()) {
+            if (usage.isFinal) {
+                finalPaths.add(path);
+                finalPathKeys.set(path, usage.key);
+            }
+        }
+        
+        // 2. Pour chaque chemin intermédiaire, vérifier s'il commence par un chemin final
+        for (const [path, usage] of pathUsage.entries()) {
+            if (usage.isIntermediate) {
+                for (const finalPath of finalPaths) {
+                    // Vérifier si ce chemin intermédiaire commence par un chemin final suivi de '['
+                    // Exemple: finalPath = "array[3]", path = "array[3][nested]" → conflit
+                    if (path.startsWith(`${finalPath}[`)) {
+                        throw new Error(
+                            `Path conflict: "${finalPath}" is used as a final value (in field "${finalPathKeys.get(finalPath)}"), ` +
+                            `but "${path}" tries to use it as an intermediate path (in field "${usage.key}"). ` +
+                            `This creates incompatible data structures. ` +
+                            `You cannot use "${finalPath}" as a primitive value and then access it as an object.`
+                        );
+                    }
+                }
+            }
+        }
+    };
+    
+    // Exécuter la détection des conflits
+    detectPathConflicts();
+
+    /**
+     * Vérifie si un chemin de base a un conflit (indices numériques ET clés de chaîne)
+     * @param {string} basePath - Le chemin de base à vérifier
+     * @returns {boolean}
+     */
+    const hasConflict = (basePath) => {
+        if (!basePath) return false;
+        const analysis = keyAnalysis.get(basePath);
+        return analysis?.hasNumeric && analysis?.hasString;
+    };
+
+    /**
+     * Convertit un tableau en objet en préservant les indices numériques comme propriétés
+     * @param {Array} arr - Le tableau à convertir
+     * @returns {Object} L'objet résultant
+     */
+    const arrayToObject = (arr) => {
+        const obj = {};
+        // Copier les indices numériques
+        for (let idx = 0; idx < arr.length; idx++) {
+            obj[idx] = arr[idx];
+        }
+        // Copier les propriétés non-numériques
+        for (const [k, v] of Object.entries(arr)) {
+            const numKey = Number.parseInt(k, 10);
+            if (Number.isNaN(numKey) || k !== String(numKey)) {
+                obj[k] = v;
+            }
+        }
+        return obj;
+    };
+
+    /**
+     * Convertit un objet en tableau en préservant les indices numériques
+     * @param {Object} obj - L'objet à convertir
+     * @returns {Array} Le tableau résultant
+     */
+    const objectToArray = (obj) => {
+        if (Array.isArray(obj)) return obj;
+        const arr = [];
+        if (typeof obj === 'object' && obj !== null) {
+            for (const [k, v] of Object.entries(obj)) {
+                const numKey = Number.parseInt(k, 10);
+                if (!Number.isNaN(numKey)) {
+                    arr[numKey] = v;
+                }
+            }
+        }
+        return arr;
+    };
+
+    /**
+     * Assure qu'un conteneur est un objet, en convertissant si nécessaire
+     * @param {*} container - Le conteneur à vérifier
+     * @param {string|null} key - La clé dans le conteneur parent
+     * @param {Object|null} parent - Le conteneur parent
+     * @param {boolean} forceObject - Forcer la conversion en objet même s'il n'y a pas de conflit
+     * @returns {Object} Le conteneur (converti en objet si nécessaire)
+     */
+    const ensureObject = (container, key, parent, forceObject = false) => {
+        if (Array.isArray(container)) {
+            const obj = arrayToObject(container);
+            if (parent && key !== null) {
+                parent[key] = obj;
+            }
+            return obj;
+        }
+        if (typeof container !== 'object' || container === null) {
+            const obj = {};
+            if (parent && key !== null) {
+                parent[key] = obj;
+            }
+            return obj;
+        }
+        return container;
+    };
+
+    /**
+     * Assure qu'un conteneur est un tableau, en convertissant si nécessaire
+     * @param {*} container - Le conteneur à vérifier
+     * @param {string|null} key - La clé dans le conteneur parent
+     * @param {Object|null} parent - Le conteneur parent
+     * @returns {Array} Le conteneur (converti en tableau si nécessaire)
+     */
+    const ensureArray = (container, key, parent) => {
+        if (!Array.isArray(container)) {
+            const arr = objectToArray(container);
+            if (parent && key !== null) {
+                parent[key] = arr;
+            }
+            return arr;
+        }
+        return container;
+    };
+
+    // ============================================================================
+    // PHASE 2 : TRAITEMENT DES VALEURS
+    // ============================================================================
+    
+    /**
+     * Traite une valeur finale (dernière partie du chemin)
+     * @param {*} container - Le conteneur actuel
+     * @param {Object} part - La partie à traiter
+     * @param {*} value - La valeur à assigner
+     * @param {Object} parent - Le conteneur parent
+     * @param {string} basePath - Le chemin de base pour la détection de conflit
+     */
+    const processFinalValue = (container, part, value, parent, basePath) => {
+        if (part.type === 'array') {
+            // Tableau explicite avec []
+            container[part.name] ??= [];
+            if (Array.isArray(container[part.name])) {
+                container[part.name].push(value);
+            } else {
+                container[part.name] = [container[part.name], value];
+            }
+        } else if (part.type === 'numeric') {
+            // Indice numérique final
+            const { index } = part;
+            container = ensureArray(container, parent.key, parent.container);
+            while (container.length <= index) {
+                container.push(undefined);
+            }
+            container[index] = value;
+        } else {
+            // Clé simple finale
+            const conflict = hasConflict(basePath);
+            
+            if (conflict) {
+                container = ensureObject(container, parent.key, parent.container, true);
+                if (Array.isArray(container[part.name])) {
+                    container[part.name] = arrayToObject(container[part.name]);
+                }
+                if (container[part.name] !== undefined && 
+                    (typeof container[part.name] !== 'object' || container[part.name] === null)) {
+                    container[part.name] = value;
+                } else if (container[part.name] === undefined) {
+                    container[part.name] = value;
+                } else if (Array.isArray(container[part.name])) {
+                    container[part.name].push(value);
+                } else {
+                    container[part.name] = [container[part.name], value];
+                }
+            } else {
+                if (container[part.name] === undefined) {
+                    container[part.name] = value;
+                } else if (Array.isArray(container[part.name])) {
+                    container[part.name].push(value);
+                } else {
+                    container[part.name] = [container[part.name], value];
+                }
+            }
+        }
+    };
+    
+    /**
+     * Traite une partie intermédiaire (crée la structure)
+     * @param {*} container - Le conteneur actuel
+     * @param {Object} part - La partie à traiter
+     * @param {Object|null} nextPart - La partie suivante (peut être null)
+     * @param {Object} parent - Le conteneur parent
+     * @param {string} basePath - Le chemin de base pour la détection de conflit
+     * @param {Array} parts - Toutes les parties du chemin (pour construire le chemin complet dans les erreurs)
+     * @param {number} i - L'index de la partie actuelle (pour construire le chemin complet dans les erreurs)
+     * @param {string} key - La clé du formulaire (pour les messages d'erreur)
+     * @returns {*} Le nouveau conteneur après traitement
+     */
+    const processIntermediatePart = (container, part, nextPart, parent, basePath, parts, i, key) => {
+        if (part.type === 'numeric') {
+            // Indice numérique : le container doit être un tableau ou un objet (selon conflit)
+            const { index } = part;
+            const conflict = hasConflict(basePath);
+            
+            if (conflict) {
+                // Conflit : utiliser un objet (les indices seront des propriétés)
+                container = ensureObject(container, parent.key, parent.container, true);
+                container[index] ??= {};
+                if (typeof container[index] !== 'object' || container[index] === null) {
+                    // Cette erreur ne devrait jamais se produire si la détection fonctionne correctement
+                    const pathParts = parts.slice(0, i + 1);
+                    const currentPath = buildPathString(pathParts);
+                    throw new Error(
+                        `Cannot access property on primitive value. ` +
+                        `Key "${key}" tries to access "${currentPath}" but it is already a ${typeof container[index]} value: ${JSON.stringify(container[index])}. ` +
+                        `This should have been detected during conflict detection phase.`
+                    );
+                }
+            } else {
+                // Pas de conflit : utiliser un tableau
+                container = ensureArray(container, parent.key, parent.container);
+                while (container.length <= index) {
+                    container.push(undefined);
+                }
+                container[index] ??= {};
+                if (typeof container[index] !== 'object' || container[index] === null) {
+                    // Cette erreur ne devrait jamais se produire si la détection fonctionne correctement
+                    const pathParts = parts.slice(0, i + 1);
+                    const currentPath = buildPathString(pathParts);
+                    throw new Error(
+                        `Cannot access property on primitive value. ` +
+                        `Key "${key}" tries to access "${currentPath}" but it is already a ${typeof container[index]} value: ${JSON.stringify(container[index])}. ` +
+                        `This should have been detected during conflict detection phase.`
+                    );
+                }
+            }
+            return container[index];
+        }
+        
+        // Clé normale : créer objet ou tableau selon la partie suivante
+        const nextIsNumeric = nextPart?.type === 'numeric';
+        const conflict = hasConflict(basePath);
+        
+        if (conflict) {
+            // Conflit : toujours utiliser un objet
+            container = ensureObject(container, parent.key, parent.container, true);
+            container[part.name] ??= {};
+            if (Array.isArray(container[part.name])) {
+                container[part.name] = arrayToObject(container[part.name]);
+            } else if (typeof container[part.name] !== 'object' || container[part.name] === null) {
+                // Cette erreur ne devrait jamais se produire si la détection fonctionne correctement
+                const pathParts = parts.slice(0, i + 1);
+                const currentPath = buildPathString(pathParts);
+                throw new Error(
+                    `Cannot access property on primitive value. ` +
+                    `Key "${key}" tries to access "${currentPath}" but it is already a ${typeof container[part.name]} value: ${JSON.stringify(container[part.name])}. ` +
+                    `This should have been detected during conflict detection phase.`
+                );
+            }
+        } else if (container[part.name] === undefined) {
+            // Pas de conflit, créer selon la partie suivante
+            container[part.name] = nextIsNumeric ? [] : {};
+        } else if (nextIsNumeric && !Array.isArray(container[part.name])) {
+            // On a besoin d'un tableau mais c'est un objet
+            const hasStringKeys = Object.keys(container[part.name]).some(k => {
+                const numKey = Number.parseInt(k, 10);
+                return Number.isNaN(numKey) || k !== String(numKey);
+            });
+            if (!hasStringKeys) {
+                container[part.name] = objectToArray(container[part.name]);
+            }
+        } else if (!nextIsNumeric && !isPlainObject(container[part.name])) {
+            // On a besoin d'un objet mais c'est un tableau
+            if (Array.isArray(container[part.name])) {
+                container[part.name] = arrayToObject(container[part.name]);
+            } else {
+                container[part.name] = {};
+            }
+        }
+        
+        // S'assurer que container[part.name] est bien un objet après toutes les conversions
+        if (container[part.name] !== undefined && 
+            (typeof container[part.name] !== 'object' || container[part.name] === null)) {
+            // Cette erreur ne devrait jamais se produire si la détection fonctionne correctement
+            const pathParts = parts.slice(0, i + 1);
+            const currentPath = buildPathString(pathParts);
+            throw new Error(
+                `Cannot access property on primitive value. ` +
+                `Key "${key}" tries to access "${currentPath}" but it is already a ${typeof container[part.name]} value: ${JSON.stringify(container[part.name])}. ` +
+                `This should have been detected during conflict detection phase.`
+            );
+        }
+        return container[part.name];
+    };
+    
+    // Traiter toutes les entrées
+    for (const { value, key } of allEntries) {
+        if (!key) continue;
+
+        const parts = parseKey(key);
+        const path = [{ container: jsonData, key: null }];
+        let container = jsonData;
+        const basePath = parts[0]?.type === 'key' ? parts[0].name : '';
+
+        for (let i = 0; i < parts.length; i++) {
+            const part = parts[i];
+            const isLast = i === parts.length - 1;
+            const nextPart = i + 1 < parts.length ? parts[i + 1] : null;
+            const parent = path[path.length - 1];
+
+            if (isLast) {
+                // Dernière partie : assigner la valeur
+                processFinalValue(container, part, value, parent, basePath);
+            } else {
+                // Partie intermédiaire : créer la structure
+                const newContainer = processIntermediatePart(container, part, nextPart, parent, basePath, parts, i, key);
+                path.push({ container, key: part.type === 'numeric' ? part.index : part.name });
+                container = newContainer;
+            }
+        }
+    }
+
+    return jsonData;
+};
+
+/**
+ * Parse une clé de formulaire pour extraire les parties (nom, indices, etc.)
+ * @param {string} key - La clé à parser (ex: "user[email]", "tags[]", "items[0][name]")
+ * @returns {Array<{name: string, type: string, index?: number}>} Tableau des parties parsées
+ * @private
+ */
+const parseKey = (key) => {
+    const parts = [];
+    let current = '';
+    let i = 0;
+    const len = key.length;
+
+    while (i < len) {
+        const char = key[i];
+        
+        if (char === '[') {
+            // Sauvegarder la partie précédente si elle existe
+            if (current) {
+                parts.push({ name: current, type: 'key' });
+                current = '';
+            }
+            
+            // Trouver la fin du crochet
+            i++;
+            let bracketContent = '';
+            while (i < len && key[i] !== ']') {
+                bracketContent += key[i];
+                i++;
+            }
+            
+            if (bracketContent === '') {
+                // [] vide = tableau
+                const lastPart = parts[parts.length - 1];
+                if (lastPart) {
+                    lastPart.type = 'array';
+                } else {
+                    // [] au début, créer une partie spéciale
+                    parts.push({ name: '', type: 'array' });
+                }
+            } else {
+                // Contenu dans les crochets
+                const numIndex = Number.parseInt(bracketContent, 10);
+                if (!Number.isNaN(numIndex) && bracketContent === String(numIndex)) {
+                    // Indice numérique
+                    parts.push({ name: String(numIndex), type: 'numeric', index: numIndex });
+                } else {
+                    // Nom de propriété
+                    parts.push({ name: bracketContent, type: 'key' });
+                }
+            }
+            i++; // Passer le ']'
+        } else {
+            current += char;
+            i++;
+        }
+    }
+    
+    // Ajouter la dernière partie si elle existe
+    if (current) {
+        parts.push({ name: current, type: 'key' });
+    }
+    
+    return parts;
+};
+
+/**
+ * Vérifie si une valeur est un objet simple (pas un tableau, pas null)
+ * @param {*} obj - La valeur à vérifier
+ * @returns {boolean}
+ * @private
+ */
+const isPlainObject = (obj) => {
+    return typeof obj === 'object' && obj !== null && !Array.isArray(obj);
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@appius-fr/apx",
-  "version": "2.5.0",
+  "version": "2.6.0",
   "description": "Appius Extended JS - A powerful JavaScript extension library",
   "main": "dist/APX.prod.mjs",
   "module": "dist/APX.prod.mjs",