@appius-fr/apx 2.5.2 → 2.6.0

package/dist/APX.standalone.js

@@ -2728,6 +2728,698 @@ Object.assign(toast, {
 /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (toast);
 
 
+/***/ }),
+
+/***/ "./modules/tools/exports.mjs":
+/*!***********************************!*\
+  !*** ./modules/tools/exports.mjs ***!
+  \***********************************/
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   augmentWithPack: () => (/* reexport safe */ _form_packer_augment_apx_mjs__WEBPACK_IMPORTED_MODULE_0__["default"]),
+/* harmony export */   packFormToJSON: () => (/* reexport safe */ _form_packer_packToJson_mjs__WEBPACK_IMPORTED_MODULE_1__.packFormToJSON),
+/* harmony export */   tools: () => (/* binding */ tools)
+/* harmony export */ });
+/* harmony import */ var _form_packer_augment_apx_mjs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./form-packer/augment-apx.mjs */ "./modules/tools/form-packer/augment-apx.mjs");
+/* harmony import */ var _form_packer_packToJson_mjs__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./form-packer/packToJson.mjs */ "./modules/tools/form-packer/packToJson.mjs");
+// Import des fonctions et modules des sous-modules
+
+
+
+// Export de la fonction d'augmentation
+
+
+// Export des fonctions utilitaires
+
+
+// Export d'un objet tools pour faciliter l'utilisation
+var tools = {
+  packFormToJSON: _form_packer_packToJson_mjs__WEBPACK_IMPORTED_MODULE_1__.packFormToJSON
+};
+
+/***/ }),
+
+/***/ "./modules/tools/form-packer/augment-apx.mjs":
+/*!***************************************************!*\
+  !*** ./modules/tools/form-packer/augment-apx.mjs ***!
+  \***************************************************/
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "default": () => (/* export default binding */ __WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* harmony import */ var _packToJson_mjs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./packToJson.mjs */ "./modules/tools/form-packer/packToJson.mjs");
+
+
+/**
+ * Ajoute la méthode pack() aux objets APX pour convertir les formulaires en JSON
+ * @param {Object} apx - L'objet APX à augmenter
+ * @returns {Object} L'objet APX augmenté
+ */
+/* harmony default export */ function __WEBPACK_DEFAULT_EXPORT__(apx) {
+  /**
+   * Convertit le premier formulaire sélectionné en objet JSON
+   * @returns {Object} L'objet JSON résultant
+   * @throws {Error} Si aucun formulaire n'est trouvé ou si le premier élément n'est pas un formulaire
+   * @example
+   * const data = APX('form.myformclass').pack();
+   */
+  apx.pack = function () {
+    var firstElement = this.first();
+    if (!firstElement) {
+      throw new Error('No element found');
+    }
+    if (firstElement.tagName !== 'FORM') {
+      throw new Error('Element is not a form');
+    }
+    return (0,_packToJson_mjs__WEBPACK_IMPORTED_MODULE_0__.packFormToJSON)(firstElement);
+  };
+  return apx;
+}
+
+/***/ }),
+
+/***/ "./modules/tools/form-packer/packToJson.mjs":
+/*!**************************************************!*\
+  !*** ./modules/tools/form-packer/packToJson.mjs ***!
+  \**************************************************/
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   packFormToJSON: () => (/* binding */ packFormToJSON)
+/* harmony export */ });
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+/**
+ * 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
+ */
+var packFormToJSON = function packFormToJSON(form) {
+  // Validation de l'entrée
+  if (!form || !(form instanceof HTMLFormElement)) {
+    throw new TypeError('packFormToJSON expects an HTMLFormElement');
+  }
+  var formData = new FormData(form);
+  var 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é
+   */
+  var buildPathString = function buildPathString(parts) {
+    return parts.reduce(function (path, part) {
+      if (part.type === 'key') {
+        return path ? "".concat(path, "[").concat(part.name, "]") : part.name;
+      }
+      if (part.type === 'numeric') {
+        return "".concat(path, "[").concat(part.index, "]");
+      }
+      if (part.type === 'array') {
+        return "".concat(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
+   */
+
+  var pathUsage = new Map(); // Map<pathString, PathUsage>
+  var keyAnalysis = new Map(); // Map<basePath, {hasNumeric: boolean, hasString: boolean}>
+  var 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
+   */
+  var recordPathUsage = function recordPathUsage(currentPath, isFinal, isArraySuffix, key) {
+    var _pathUsage$get;
+    var usage = (_pathUsage$get = pathUsage.get(currentPath)) !== null && _pathUsage$get !== void 0 ? _pathUsage$get : {
+      isFinal: false,
+      isIntermediate: false,
+      hasArraySuffix: false,
+      key: key
+    };
+    if (!pathUsage.has(currentPath)) {
+      pathUsage.set(currentPath, usage);
+    }
+    if (isFinal) {
+      usage.isFinal = true;
+      usage.key = key;
+      if (isArraySuffix) {
+        usage.hasArraySuffix = true;
+      }
+    } else {
+      var _usage$key;
+      usage.isIntermediate = true;
+      (_usage$key = usage.key) !== null && _usage$key !== void 0 ? _usage$key : usage.key = key;
+    }
+  };
+
+  // Première passe : analyser toutes les clés et enregistrer les chemins
+  var _iterator = _createForOfIteratorHelper(formData.entries()),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var _step$value = _slicedToArray(_step.value, 2),
+        _key = _step$value[0],
+        _value = _step$value[1];
+      if (!_key) continue;
+      allEntries.push({
+        key: _key,
+        value: _value
+      });
+      var _parts = parseKey(_key);
+
+      // Construire tous les chemins intermédiaires et le chemin final
+      var currentPath = '';
+      for (var _i4 = 0; _i4 < _parts.length; _i4++) {
+        var _part = _parts[_i4];
+        var _isLast = _i4 === _parts.length - 1;
+        var isArraySuffix = _part.type === 'array';
+
+        // Construire le chemin jusqu'à ce niveau
+        if (_part.type === 'key') {
+          currentPath = currentPath ? "".concat(currentPath, "[").concat(_part.name, "]") : _part.name;
+        } else if (_part.type === 'numeric') {
+          currentPath = "".concat(currentPath, "[").concat(_part.index, "]");
+        } else if (_part.type === 'array') {
+          currentPath = "".concat(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 (var _i5 = 0; _i5 < _parts.length - 1; _i5++) {
+        var _part2 = _parts[_i5];
+        var _nextPart = _parts[_i5 + 1];
+
+        // Analyser seulement les clés (pas les indices numériques)
+        if (_part2.type === 'key') {
+          var _keyAnalysis$get;
+          var _basePath = _part2.name; // Le nom de la première clé dans le chemin
+
+          var analysis = (_keyAnalysis$get = keyAnalysis.get(_basePath)) !== null && _keyAnalysis$get !== void 0 ? _keyAnalysis$get : {
+            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)
+     */
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  var detectPathConflicts = function detectPathConflicts() {
+    // 1. Collecter tous les chemins finaux (valeurs primitives)
+    var finalPaths = new Set();
+    var finalPathKeys = new Map(); // Pour les messages d'erreur
+    var _iterator2 = _createForOfIteratorHelper(pathUsage.entries()),
+      _step2;
+    try {
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        var _step2$value = _slicedToArray(_step2.value, 2),
+          path = _step2$value[0],
+          usage = _step2$value[1];
+        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
+    } catch (err) {
+      _iterator2.e(err);
+    } finally {
+      _iterator2.f();
+    }
+    var _iterator3 = _createForOfIteratorHelper(pathUsage.entries()),
+      _step3;
+    try {
+      for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+        var _step3$value = _slicedToArray(_step3.value, 2),
+          _path = _step3$value[0],
+          _usage = _step3$value[1];
+        if (_usage.isIntermediate) {
+          var _iterator4 = _createForOfIteratorHelper(finalPaths),
+            _step4;
+          try {
+            for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+              var finalPath = _step4.value;
+              // 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("".concat(finalPath, "["))) {
+                throw new Error("Path conflict: \"".concat(finalPath, "\" is used as a final value (in field \"").concat(finalPathKeys.get(finalPath), "\"), ") + "but \"".concat(_path, "\" tries to use it as an intermediate path (in field \"").concat(_usage.key, "\"). ") + "This creates incompatible data structures. " + "You cannot use \"".concat(finalPath, "\" as a primitive value and then access it as an object."));
+              }
+            }
+          } catch (err) {
+            _iterator4.e(err);
+          } finally {
+            _iterator4.f();
+          }
+        }
+      }
+    } catch (err) {
+      _iterator3.e(err);
+    } finally {
+      _iterator3.f();
+    }
+  };
+
+  // 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}
+   */
+  var hasConflict = function hasConflict(basePath) {
+    if (!basePath) return false;
+    var analysis = keyAnalysis.get(basePath);
+    return (analysis === null || analysis === void 0 ? void 0 : analysis.hasNumeric) && (analysis === null || analysis === void 0 ? void 0 : 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
+   */
+  var arrayToObject = function arrayToObject(arr) {
+    var obj = {};
+    // Copier les indices numériques
+    for (var idx = 0; idx < arr.length; idx++) {
+      obj[idx] = arr[idx];
+    }
+    // Copier les propriétés non-numériques
+    for (var _i = 0, _Object$entries = Object.entries(arr); _i < _Object$entries.length; _i++) {
+      var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
+        k = _Object$entries$_i[0],
+        v = _Object$entries$_i[1];
+      var 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
+   */
+  var objectToArray = function objectToArray(obj) {
+    if (Array.isArray(obj)) return obj;
+    var arr = [];
+    if (_typeof(obj) === 'object' && obj !== null) {
+      for (var _i2 = 0, _Object$entries2 = Object.entries(obj); _i2 < _Object$entries2.length; _i2++) {
+        var _Object$entries2$_i = _slicedToArray(_Object$entries2[_i2], 2),
+          k = _Object$entries2$_i[0],
+          v = _Object$entries2$_i[1];
+        var 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)
+   */
+  var ensureObject = function ensureObject(container, key, parent) {
+    var forceObject = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+    if (Array.isArray(container)) {
+      var obj = arrayToObject(container);
+      if (parent && key !== null) {
+        parent[key] = obj;
+      }
+      return obj;
+    }
+    if (_typeof(container) !== 'object' || container === null) {
+      var _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)
+   */
+  var ensureArray = function ensureArray(container, key, parent) {
+    if (!Array.isArray(container)) {
+      var 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
+   */
+  var processFinalValue = function processFinalValue(container, part, value, parent, basePath) {
+    if (part.type === 'array') {
+      var _container, _part$name, _container$_part$name;
+      // Tableau explicite avec []
+      (_container$_part$name = (_container = container)[_part$name = part.name]) !== null && _container$_part$name !== void 0 ? _container$_part$name : _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
+      var index = part.index;
+      container = ensureArray(container, parent.key, parent.container);
+      while (container.length <= index) {
+        container.push(undefined);
+      }
+      container[index] = value;
+    } else {
+      // Clé simple finale
+      var 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
+   */
+  var processIntermediatePart = function 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)
+      var index = part.index;
+      var _conflict = hasConflict(basePath);
+      if (_conflict) {
+        var _container2, _container2$index;
+        // Conflit : utiliser un objet (les indices seront des propriétés)
+        container = ensureObject(container, parent.key, parent.container, true);
+        (_container2$index = (_container2 = container)[index]) !== null && _container2$index !== void 0 ? _container2$index : _container2[index] = {};
+        if (_typeof(container[index]) !== 'object' || container[index] === null) {
+          // Cette erreur ne devrait jamais se produire si la détection fonctionne correctement
+          var pathParts = parts.slice(0, i + 1);
+          var currentPath = buildPathString(pathParts);
+          throw new Error("Cannot access property on primitive value. " + "Key \"".concat(key, "\" tries to access \"").concat(currentPath, "\" but it is already a ").concat(_typeof(container[index]), " value: ").concat(JSON.stringify(container[index]), ". ") + "This should have been detected during conflict detection phase.");
+        }
+      } else {
+        var _container3, _container3$index;
+        // Pas de conflit : utiliser un tableau
+        container = ensureArray(container, parent.key, parent.container);
+        while (container.length <= index) {
+          container.push(undefined);
+        }
+        (_container3$index = (_container3 = container)[index]) !== null && _container3$index !== void 0 ? _container3$index : _container3[index] = {};
+        if (_typeof(container[index]) !== 'object' || container[index] === null) {
+          // Cette erreur ne devrait jamais se produire si la détection fonctionne correctement
+          var _pathParts = parts.slice(0, i + 1);
+          var _currentPath = buildPathString(_pathParts);
+          throw new Error("Cannot access property on primitive value. " + "Key \"".concat(key, "\" tries to access \"").concat(_currentPath, "\" but it is already a ").concat(_typeof(container[index]), " value: ").concat(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
+    var nextIsNumeric = (nextPart === null || nextPart === void 0 ? void 0 : nextPart.type) === 'numeric';
+    var conflict = hasConflict(basePath);
+    if (conflict) {
+      var _container4, _part$name2, _container4$_part$nam;
+      // Conflit : toujours utiliser un objet
+      container = ensureObject(container, parent.key, parent.container, true);
+      (_container4$_part$nam = (_container4 = container)[_part$name2 = part.name]) !== null && _container4$_part$nam !== void 0 ? _container4$_part$nam : _container4[_part$name2] = {};
+      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
+        var _pathParts2 = parts.slice(0, i + 1);
+        var _currentPath2 = buildPathString(_pathParts2);
+        throw new Error("Cannot access property on primitive value. " + "Key \"".concat(key, "\" tries to access \"").concat(_currentPath2, "\" but it is already a ").concat(_typeof(container[part.name]), " value: ").concat(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
+      var hasStringKeys = Object.keys(container[part.name]).some(function (k) {
+        var 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
+      var _pathParts3 = parts.slice(0, i + 1);
+      var _currentPath3 = buildPathString(_pathParts3);
+      throw new Error("Cannot access property on primitive value. " + "Key \"".concat(key, "\" tries to access \"").concat(_currentPath3, "\" but it is already a ").concat(_typeof(container[part.name]), " value: ").concat(JSON.stringify(container[part.name]), ". ") + "This should have been detected during conflict detection phase.");
+    }
+    return container[part.name];
+  };
+
+  // Traiter toutes les entrées
+  for (var _i3 = 0, _allEntries = allEntries; _i3 < _allEntries.length; _i3++) {
+    var _parts$;
+    var _allEntries$_i = _allEntries[_i3],
+      value = _allEntries$_i.value,
+      key = _allEntries$_i.key;
+    if (!key) continue;
+    var parts = parseKey(key);
+    var path = [{
+      container: jsonData,
+      key: null
+    }];
+    var container = jsonData;
+    var basePath = ((_parts$ = parts[0]) === null || _parts$ === void 0 ? void 0 : _parts$.type) === 'key' ? parts[0].name : '';
+    for (var i = 0; i < parts.length; i++) {
+      var part = parts[i];
+      var isLast = i === parts.length - 1;
+      var nextPart = i + 1 < parts.length ? parts[i + 1] : null;
+      var 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
+        var newContainer = processIntermediatePart(container, part, nextPart, parent, basePath, parts, i, key);
+        path.push({
+          container: 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
+ */
+var parseKey = function parseKey(key) {
+  var parts = [];
+  var current = '';
+  var i = 0;
+  var len = key.length;
+  while (i < len) {
+    var _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++;
+      var bracketContent = '';
+      while (i < len && key[i] !== ']') {
+        bracketContent += key[i];
+        i++;
+      }
+      if (bracketContent === '') {
+        // [] vide = tableau
+        var 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
+        var 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
+ */
+var isPlainObject = function isPlainObject(obj) {
+  return _typeof(obj) === 'object' && obj !== null && !Array.isArray(obj);
+};
+
 /***/ }),
 
 /***/ "./modules/tristate/tristate.mjs":
@@ -3039,42 +3731,44 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony import */ var _modules_dialog_dialog_mjs__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./modules/dialog/dialog.mjs */ "./modules/dialog/dialog.mjs");
 /* harmony import */ var _modules_toast_toast_mjs__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./modules/toast/toast.mjs */ "./modules/toast/toast.mjs");
 /* harmony import */ var _modules_common_mjs__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./modules/common.mjs */ "./modules/common.mjs");
-
-
-
-
-
-
-/**
- * Creates an APX object that wraps one or more HTML elements.
- * @param {string|HTMLElement|NodeList|HTMLCollection|Array<HTMLElement>|jQuery|Function} input - The input to create the APX object from.
- * @returns {Object} The APX object.
- * @throws {Error} If the input type is invalid.
- * @example
- * // XPath
- * const apx1 = APX('//div[@class="example"]');
- *
- * // CSS selector
- * const apx2 = APX('.example');
- *
- * // Single element
- * const element = document.querySelector('.example');
- * const apx3 = APX(element);
- *
- * // NodeList or HTMLCollection
- * const nodeList = document.querySelectorAll('.example');
- * const apx4 = APX(nodeList);
- *
- * // Array of elements
- * const elements = [document.querySelector('.example1'), document.querySelector('.example2')];
- * const apx5 = APX(elements);
- *
- * // jQuery object
- * const $example = $('.example');
- * const apx6 = APX($example);
- *
- * // Function returning an APX object
- * const apx7 = APX(() => APX('.example'));
+/* harmony import */ var _modules_tools_exports_mjs__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./modules/tools/exports.mjs */ "./modules/tools/exports.mjs");
+
+
+
+
+
+
+
+/**
+ * Creates an APX object that wraps one or more HTML elements.
+ * @param {string|HTMLElement|NodeList|HTMLCollection|Array<HTMLElement>|jQuery|Function} input - The input to create the APX object from.
+ * @returns {Object} The APX object.
+ * @throws {Error} If the input type is invalid.
+ * @example
+ * // XPath
+ * const apx1 = APX('//div[@class="example"]');
+ *
+ * // CSS selector
+ * const apx2 = APX('.example');
+ *
+ * // Single element
+ * const element = document.querySelector('.example');
+ * const apx3 = APX(element);
+ *
+ * // NodeList or HTMLCollection
+ * const nodeList = document.querySelectorAll('.example');
+ * const apx4 = APX(nodeList);
+ *
+ * // Array of elements
+ * const elements = [document.querySelector('.example1'), document.querySelector('.example2')];
+ * const apx5 = APX(elements);
+ *
+ * // jQuery object
+ * const $example = $('.example');
+ * const apx6 = APX($example);
+ *
+ * // Function returning an APX object
+ * const apx7 = APX(() => APX('.example'));
  */
 var APX = function APX(input) {
   var context = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : document;
@@ -3150,11 +3844,13 @@ var APX = function APX(input) {
   };
   (0,_modules_listen_listen_mjs__WEBPACK_IMPORTED_MODULE_0__["default"])(apx);
   (0,_modules_tristate_tristate_mjs__WEBPACK_IMPORTED_MODULE_1__["default"])(apx);
+  (0,_modules_tools_exports_mjs__WEBPACK_IMPORTED_MODULE_5__.augmentWithPack)(apx);
   return apx;
 };
 APX.loadCss = _modules_common_mjs__WEBPACK_IMPORTED_MODULE_4__.loadCss;
 APX.dialog = _modules_dialog_dialog_mjs__WEBPACK_IMPORTED_MODULE_2__["default"];
 APX.toast = _modules_toast_toast_mjs__WEBPACK_IMPORTED_MODULE_3__["default"];
+APX.tools = _modules_tools_exports_mjs__WEBPACK_IMPORTED_MODULE_5__.tools;
 APX.isAPXObject = function (obj) {
   return obj && obj._isAPXObject === true;
 };