@arc-js/fodat 0.0.1

package/README.md

@@ -0,0 +1,312 @@
+# @arc-js/fodat
+
+[![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+![TypeScript](https://img.shields.io/badge/TypeScript-5.0+-007ACC)
+![Browser](https://img.shields.io/badge/browser-compatible-green)
+![Node.js](https://img.shields.io/badge/Node.js-18+-339933)
+
+**@arc-js/fodat** est une bibliothèque JavaScript/TypeScript légère et puissante pour la transformation bidirectionnelle entre FormData et objets JSON. Conçue pour simplifier la manipulation des données de formulaires complexes avec support natif des fichiers et structures imbriquées.
+
+## ✨ Fonctionnalités Principales
+
+- 🔄 **Transformation bidirectionnelle** : FormData → JSON et JSON → FormData
+- 🏗️ **Support des structures complexes** : objets imbriqués, tableaux multidimensionnels
+- 📁 **Gestion native des fichiers** : préservation des objets File sans conversion
+- 🎯 **Typage TypeScript complet** : auto-complétion et sécurité des types
+- ⚡ **Léger et performant** : aucune dépendance, optimisé pour les performances
+- 🌐 **Multi-plateforme** : navigateur, Node.js, Deno, Bun
+- 🔧 **Parsing intelligent** : conversion automatique des types (booléens, nombres)
+
+## 📦 Installation
+
+### Via npm/yarn/pnpm
+
+```bash
+npm install @arc-js/fodat
+# ou
+yarn add @arc-js/fodat
+# ou
+pnpm add @arc-js/fodat
+```
+
+### Importation directe (CDN)
+
+```html
+<script src="@arc-js/fodat/fodat.all.js"></script>
+```
+
+## 🚀 Démarrage Rapide
+
+### TypeScript/ES Modules
+
+```typescript
+import Fodat from '@arc-js/fodat';
+// ou
+import { Fodat } from '@arc-js/fodat';
+```
+
+### CommonJS
+
+```javascript
+const { Fodat } = require('@arc-js/fodat');
+```
+
+### Navigateur (global)
+
+```html
+<script src="@arc-js/fodat/fodat.all.js"></script>
+<script>
+  // Disponible globalement comme window.Fodat
+  const formData = new FormData();
+  formData.append('user.name', 'John');
+  const json = Fodat.transform(formData);
+  console.log(json.user.name); // "John"
+</script>
+```
+
+## 📚 Documentation API
+
+### Méthodes Statiques
+
+#### `Fodat.transform(formData: FormData): any`
+
+Transforme un objet FormData en structure JavaScript/JSON.
+
+```typescript
+const formData = new FormData();
+formData.append('user.firstName', 'Jean');
+formData.append('user.lastName', 'Dupont');
+formData.append('user.age', '30');
+formData.append('addresses[0].city', 'Paris');
+
+const result = Fodat.transform(formData);
+/*
+Résultat:
+{
+  user: {
+    firstName: "Jean",
+    lastName: "Dupont",
+    age: 30  // Converti automatiquement en nombre
+  },
+  addresses: [{
+    city: "Paris"
+  }]
+}
+*/
+```
+
+#### `Fodat.toFormData(json: any, formData?: FormData, parentKey?: string): FormData`
+
+Transforme un objet JavaScript/JSON en FormData.
+
+```typescript
+const data = {
+  user: {
+    name: "Marie",
+    active: true,
+    profile: new File(['content'], 'profile.jpg')
+  },
+  tags: ["js", "typescript"]
+};
+
+const formData = Fodat.toFormData(data);
+// Peut être envoyé via fetch ou XMLHttpRequest
+```
+
+### Fonctionnalités Avancées
+
+#### Conversion Automatique des Types
+
+Fodat convertit intelligemment les valeurs string en types appropriés :
+
+- `"true"` → `true` (booléen)
+- `"false"` → `false` (booléen)
+- `"42"` → `42` (nombre)
+- `"3.14"` → `3.14` (nombre)
+- Fichiers → préservés comme objets File natifs
+
+#### Syntaxe des Clés
+
+| Type | Syntaxe | Exemple |
+|------|---------|---------|
+| Propriété simple | `key` | `name` |
+| Propriété imbriquée | `key.subkey` | `user.name` |
+| Tableau | `key[index]` | `tags[0]` |
+| Tableau d'objets | `key[index].prop` | `users[0].email` |
+| Mixte | `key.subkey[index].prop` | `data.items[0].value` |
+
+#### Gestion des Fichiers
+
+```typescript
+// Ajout de fichiers
+const formData = new FormData();
+formData.append('avatar', new File([''], 'photo.jpg'));
+formData.append('documents[0]', new File([''], 'doc.pdf'));
+
+// Transformation
+const json = Fodat.transform(formData);
+console.log(json.avatar instanceof File); // true
+console.log(json.documents[0] instanceof File); // true
+
+// Transformation inverse
+const newFormData = Fodat.toFormData(json);
+```
+
+## 🎯 Exemples Complets
+
+### Exemple 1 : Formulaire d'Utilisateur Complexe
+
+```typescript
+// Création d'un FormData complexe
+const formData = new FormData();
+formData.append('personal.firstName', 'Jean');
+formData.append('personal.lastName', 'Dupont');
+formData.append('personal.email', 'jean@example.com');
+formData.append('personal.age', '35');
+formData.append('personal.active', 'true');
+
+formData.append('addresses[0].street', '123 Rue Exemple');
+formData.append('addresses[0].city', 'Paris');
+formData.append('addresses[1].street', '456 Autre Rue');
+formData.append('addresses[1].city', 'Lyon');
+
+formData.append('skills[0]', 'JavaScript');
+formData.append('skills[1]', 'TypeScript');
+formData.append('skills[2]', 'React');
+
+// Transformation en JSON
+const userData = Fodat.transform(formData);
+console.log(userData.personal.age); // 35 (nombre)
+console.log(userData.personal.active); // true (booléen)
+console.log(userData.addresses.length); // 2
+console.log(userData.skills); // ["JavaScript", "TypeScript", "React"]
+
+// Envoi au serveur après modification
+userData.personal.age = 36;
+const updatedFormData = Fodat.toFormData(userData);
+```
+
+### Exemple 2 : Upload avec Métadonnées
+
+```typescript
+// Préparation des données avec fichiers
+const uploadData = {
+  metadata: {
+    title: "Document Important",
+    category: "legal",
+    tags: ["contract", "signed"],
+    priority: "high"
+  },
+  files: [
+    new File(['contenu'], 'contrat.pdf'),
+    new File(['annexe'], 'annexe.jpg')
+  ],
+  options: {
+    encrypt: true,
+    notify: false
+  }
+};
+
+// Conversion en FormData pour upload
+const formData = Fodat.toFormData(uploadData);
+
+// Simulation d'envoi
+fetch('/api/upload', {
+  method: 'POST',
+  body: formData
+});
+```
+
+### Exemple 3 : Traitement de Réponse Serveur
+
+```typescript
+// Supposons que vous recevez un FormData d'une API
+async function handleFormDataResponse(response: Response) {
+  const formData = await response.formData();
+  
+  // Transformation en objet utilisable
+  const data = Fodat.transform(formData);
+  
+  // Traitement typé
+  if (data.user && typeof data.user.age === 'number') {
+    console.log(`Âge: \${data.user.age}`);
+  }
+  
+  // Modification et renvoi
+  data.timestamp = new Date().toISOString();
+  return Fodat.toFormData(data);
+}
+```
+
+## 🔧 Build et Développement
+
+### Structure du Projet
+
+```
+@arc-js/fodat/
+├── fodat.all.js
+├── fodat.all.min.js
+├── index.d.ts
+├── index.js
+├── index.min.d.ts
+├── index.min.js
+├── package.json
+├── tsconfig.json
+└── README.md
+```
+
+## 📋 Compatibilité
+
+### Navigateurs Supportés
+
+- Chrome 60+
+- Firefox 55+
+- Safari 12+
+- Edge 79+
+- Opera 47+
+- Tous les navigateurs supportant FormData
+
+### Environnements
+
+- Node.js 18+ (avec polyfill FormData)
+- Deno 1.30+
+- Bun 1.0+
+- Tous les environnements ES5+
+
+## 🚨 Notes Importantes
+
+### Performances
+
+Fodat est optimisé pour la performance mais gardez à l'esprit que :
+- La transformation de FormData très larges peut avoir un impact
+- Préférez transformer uniquement les données nécessaires
+- Les fichiers volumineux sont référencés, non copiés
+
+### Limitations
+
+- Les valeurs `null` et `undefined` dans FormData sont traitées comme chaînes vides
+- Les objets cycliques ne sont pas supportés
+- La profondeur maximale d'imbrication est limitée par la pile d'appels
+
+### Sécurité
+
+- Validez toujours les données d'entrée
+- Les fichiers sont préservés tels quels, assurez-vous de valider leur type et taille
+- Évitez d'exposer Fodat à des données non fiables sans validation
+
+## 📄 Licence
+
+MIT License - Voir le fichier [LICENSE](LICENSE) pour plus de détails.
+
+## 🐛 Signaler un Bug
+
+Envoyez nous un mail à l'adresse `contact.inicode@gmail.com` pour :
+- Signaler un bug
+- Proposer une amélioration
+- Poser une question
+
+---
+
+**@arc-js/fodat** - La passerelle intelligente entre FormData et JSON. 🔄
+
+*Développé par l'équipe INICODE*

package/fodat.all.js

@@ -0,0 +1,102 @@
+class Fodat {
+    static transform(formData) {
+        if (formData instanceof FormData) {
+            const result = {};
+            for (const [key, value] of formData.entries()) {
+                const path = this.parseKeyPath(key);
+                this.setDeepValue(result, path, this.wrapValue(value));
+            }
+            return result;
+        }
+        else if (typeof formData === 'object' &&
+            !Array.isArray(formData)) {
+            return formData;
+        }
+        return undefined;
+    }
+    static toFormData(json, form = new FormData(), parentKey) {
+        if (json === null || json === undefined)
+            return form;
+        if (json?.__file === true && json.file instanceof File) {
+            form.append(parentKey, json.file);
+            return form;
+        }
+        if (typeof json !== "object" || json instanceof File) {
+            if (parentKey)
+                form.append(parentKey, json);
+            return form;
+        }
+        if (Array.isArray(json)) {
+            json.forEach((item, index) => {
+                const key = parentKey ? `${parentKey}[${index}]` : `${index}`;
+                this.toFormData(item, form, key);
+            });
+            return form;
+        }
+        Object.keys(json).forEach((key) => {
+            const newKey = parentKey ? `${parentKey}.${key}` : key;
+            this.toFormData(json[key], form, newKey);
+        });
+        return form;
+    }
+    static wrapValue(value) {
+        if (value instanceof File) {
+            // return {
+            //     __file: true,
+            //     name: value.name,
+            //     type: value.type,
+            //     size: value.size,
+            //     lastModified: value.lastModified,
+            //     file: value,
+            // };
+            return value;
+        }
+        else {
+            const strValue = value.toString();
+            if (strValue === "true")
+                return true;
+            if (strValue === "false")
+                return false;
+            if (!isNaN(Number(strValue)))
+                return Number(strValue);
+            return strValue;
+        }
+    }
+    static setDeepValue(obj, path, value) {
+        let current = obj;
+        for (let i = 0; i < path.length - 1; i++) {
+            const key = path[i];
+            const nextKey = path[i + 1];
+            if (current[key] === undefined) {
+                current[key] = typeof nextKey === "number" ? [] : {};
+            }
+            current = current[key];
+        }
+        const finalKey = path[path.length - 1];
+        current[finalKey] = value;
+    }
+    static parseKeyPath(key) {
+        const path = [];
+        const parts = key.split(/\.|(\[\d+\])/).filter(Boolean);
+        for (const p of parts) {
+            const match = p.match(/\[(\d+)\]/);
+            if (match) {
+                path.push(Number(match[1]));
+            }
+            else {
+                path.push(p);
+            }
+        }
+        return path;
+    }
+    static exposeToGlobal() {
+        if (typeof window !== "undefined") {
+            window.Fodat = Fodat;
+        }
+    }
+}
+if (typeof window !== "undefined") {
+    window.Fodat = Fodat;
+}
+
+

package/fodat.all.min.js

@@ -0,0 +1 @@
+class Fodat{static transform(t){if(t instanceof FormData){var e,a,r={};for([e,a]of t.entries()){var o=this.parseKeyPath(e);this.setDeepValue(r,o,this.wrapValue(a))}return r}if("object"==typeof t&&!Array.isArray(t))return t}static toFormData(e,a=new FormData,r){return null!=e&&(!0===e?.__file&&e.file instanceof File?a.append(r,e.file):"object"!=typeof e||e instanceof File?r&&a.append(r,e):Array.isArray(e)?e.forEach((t,e)=>{this.toFormData(t,a,r?r+`[${e}]`:""+e)}):Object.keys(e).forEach(t=>{this.toFormData(e[t],a,r?r+"."+t:t)})),a}static wrapValue(t){return t instanceof File?t:"true"===(t=t.toString())||"false"!==t&&(isNaN(Number(t))?t:Number(t))}static setDeepValue(t,e,a){let r=t;for(let t=0;t<e.length-1;t++){var o=e[t],i=e[t+1];void 0===r[o]&&(r[o]="number"==typeof i?[]:{}),r=r[o]}t=e[e.length-1];r[t]=a}static parseKeyPath(t){var e,a=[];for(e of t.split(/\.|(\[\d+\])/).filter(Boolean)){var r=e.match(/\[(\d+)\]/);a.push(r?Number(r[1]):e)}return a}static exposeToGlobal(){"undefined"!=typeof window&&(window.Fodat=Fodat)}}"undefined"!=typeof window&&(window.Fodat=Fodat);

package/index.d.ts

@@ -0,0 +1,15 @@
+declare global {
+    interface Window {
+        Fodat: typeof Fodat;
+    }
+}
+declare class Fodat {
+    static transform(formData: any): any;
+    static toFormData(json: any, form?: FormData, parentKey?: string): FormData;
+    private static wrapValue;
+    private static setDeepValue;
+    private static parseKeyPath;
+    static exposeToGlobal(): void;
+}
+
+export { Fodat, Fodat as default };

package/index.js

@@ -0,0 +1,94 @@
+class Fodat {
+    static transform(formData) {
+        if (formData instanceof FormData) {
+            const result = {};
+            for (const [key, value] of formData.entries()) {
+                const path = this.parseKeyPath(key);
+                this.setDeepValue(result, path, this.wrapValue(value));
+            }
+            return result;
+        }
+        else if (typeof formData === 'object' &&
+            !Array.isArray(formData)) {
+            return formData;
+        }
+        return undefined;
+    }
+    static toFormData(json, form = new FormData(), parentKey) {
+        if (json === null || json === undefined)
+            return form;
+        if (json?.__file === true && json.file instanceof File) {
+            form.append(parentKey, json.file);
+            return form;
+        }
+        if (typeof json !== "object" || json instanceof File) {
+            if (parentKey)
+                form.append(parentKey, json);
+            return form;
+        }
+        if (Array.isArray(json)) {
+            json.forEach((item, index) => {
+                const key = parentKey ? `${parentKey}[${index}]` : `${index}`;
+                this.toFormData(item, form, key);
+            });
+            return form;
+        }
+        Object.keys(json).forEach((key) => {
+            const newKey = parentKey ? `${parentKey}.${key}` : key;
+            this.toFormData(json[key], form, newKey);
+        });
+        return form;
+    }
+    static wrapValue(value) {
+        if (value instanceof File) {
+            return value;
+        }
+        else {
+            const strValue = value.toString();
+            if (strValue === "true")
+                return true;
+            if (strValue === "false")
+                return false;
+            if (!isNaN(Number(strValue)))
+                return Number(strValue);
+            return strValue;
+        }
+    }
+    static setDeepValue(obj, path, value) {
+        let current = obj;
+        for (let i = 0; i < path.length - 1; i++) {
+            const key = path[i];
+            const nextKey = path[i + 1];
+            if (current[key] === undefined) {
+                current[key] = typeof nextKey === "number" ? [] : {};
+            }
+            current = current[key];
+        }
+        const finalKey = path[path.length - 1];
+        current[finalKey] = value;
+    }
+    static parseKeyPath(key) {
+        const path = [];
+        const parts = key.split(/\.|(\[\d+\])/).filter(Boolean);
+        for (const p of parts) {
+            const match = p.match(/\[(\d+)\]/);
+            if (match) {
+                path.push(Number(match[1]));
+            }
+            else {
+                path.push(p);
+            }
+        }
+        return path;
+    }
+    static exposeToGlobal() {
+        if (typeof window !== "undefined") {
+            window.Fodat = Fodat;
+        }
+    }
+}
+if (typeof window !== "undefined") {
+    window.Fodat = Fodat;
+}
+
+export { Fodat, Fodat as default };

package/index.min.d.ts

@@ -0,0 +1,15 @@
+declare global {
+    interface Window {
+        Fodat: typeof Fodat;
+    }
+}
+declare class Fodat {
+    static transform(formData: any): any;
+    static toFormData(json: any, form?: FormData, parentKey?: string): FormData;
+    private static wrapValue;
+    private static setDeepValue;
+    private static parseKeyPath;
+    static exposeToGlobal(): void;
+}
+
+export { Fodat, Fodat as default };

package/index.min.js

@@ -0,0 +1 @@
+class Fodat{static transform(t){if(t instanceof FormData){var e,a,r={};for([e,a]of t.entries()){var o=this.parseKeyPath(e);this.setDeepValue(r,o,this.wrapValue(a))}return r}if("object"==typeof t&&!Array.isArray(t))return t}static toFormData(e,a=new FormData,r){return null!=e&&(!0===e?.__file&&e.file instanceof File?a.append(r,e.file):"object"!=typeof e||e instanceof File?r&&a.append(r,e):Array.isArray(e)?e.forEach((t,e)=>{this.toFormData(t,a,r?r+`[${e}]`:""+e)}):Object.keys(e).forEach(t=>{this.toFormData(e[t],a,r?r+"."+t:t)})),a}static wrapValue(t){return t instanceof File?t:"true"===(t=t.toString())||"false"!==t&&(isNaN(Number(t))?t:Number(t))}static setDeepValue(t,e,a){let r=t;for(let t=0;t<e.length-1;t++){var o=e[t],i=e[t+1];void 0===r[o]&&(r[o]="number"==typeof i?[]:{}),r=r[o]}t=e[e.length-1];r[t]=a}static parseKeyPath(t){var e,a=[];for(e of t.split(/\.|(\[\d+\])/).filter(Boolean)){var r=e.match(/\[(\d+)\]/);a.push(r?Number(r[1]):e)}return a}static exposeToGlobal(){"undefined"!=typeof window&&(window.Fodat=Fodat)}}"undefined"!=typeof window&&(window.Fodat=Fodat);export{Fodat,Fodat as default};

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@arc-js/fodat",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "0.0.1",
+  "description": "Fodat est une bibliothèque JavaScript/TypeScript légère et puissante pour la transformation bidirectionnelle entre FormData et objets JSON. Conçue pour simplifier la manipulation des données de formulaires complexes avec support natif des fichiers et structures imbriquées",
+  "main": "index.js",
+  "keywords": [],
+  "author": "INICODE <contact@inicode@gmail.com>",
+  "license": "MIT",
+  "scripts": {
+    "init": "npm init --scope=@arc-js/fodat",
+    "login": "npm login"
+  },
+  "devDependencies": {},
+  "dependencies": {}
+}

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+    "compilerOptions": {
+        "target": "ES6",
+        "module": "commonjs",
+        "lib": ["ES2020", "DOM", "DOM.Iterable", "ESNext"],
+        "strict": false,
+        "esModuleInterop": true,
+        "skipLibCheck": true,
+        "declaration": false,
+        "sourceMap": false,
+        "allowSyntheticDefaultImports": true,
+        "noEmit": false
+    },
+    "include": [],
+    "exclude": [
+        "node_modules",
+        "**/*.d.ts"
+    ]
+}