@arc-js/pajo 0.0.1

package/README.md

@@ -0,0 +1,568 @@
+# @arc-js/pajo
+
+[![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)
+![Deno](https://img.shields.io/badge/Deno-1.30+-000000)
+![Bun](https://img.shields.io/badge/Bun-1.0+-FBF0DF)
+
+**@arc-js/pajo** est une bibliothèque TypeScript légère et robuste pour la manipulation de chemins de fichiers et d'URLs. Elle offre une API unifiée et type-safe pour travailler avec des chemins de fichiers sur différentes plateformes (Windows, Linux, macOS) et pour construire des URLs de manière cohérente.
+
+## ✨ Fonctionnalités Principales
+
+### 📁 Manipulation de Chemins
+- **Style multi-plateforme** : Support natif des chemins Windows (\) et Unix (/)
+- **Joindre des chemins** : Méthode intelligente pour joindre plusieurs segments de chemin
+- **Chemins absolus/relatifs** : Détection automatique du type de chemin
+- **Normalisation** : Élimination des séparateurs redondants et des points (., ..)
+- **Extraction** : Récupération du nom de fichier, extension et répertoire parent
+
+### 🌐 Manipulation d'URLs
+- **Construction d'URLs** : Joindre des segments avec un hôte (avec ou sans protocole)
+- **Normalisation automatique** : Ajout de protocole si absent, gestion des slashs
+- **Support des protocoles** : Reconnaissance automatique des schémas (http://, https://, etc.)
+
+### 🔄 Conversion
+- **Conversion de style** : Convertir entre chemins Windows et Unix
+- **Adaptation automatique** : Détection du style basée sur le contenu du chemin
+
+### 🛡️ Robustesse
+- **Gestion des cas limites** : Chemins vides, séparateurs multiples, points spéciaux
+- **Type-safe** : Entièrement écrit en TypeScript avec des types stricts
+- **Pas de dépendances** : Bibliothèque autonome, zéro dépendance
+
+## 📦 Installation
+
+### Via npm/yarn/pnpm
+
+```bash
+npm install @arc-js/pajo
+# ou
+yarn add @arc-js/pajo
+# ou
+pnpm add @arc-js/pajo
+```
+
+### Importation directe (CDN)
+
+```html
+<script src="@arc-js/pajo/pajo.all.js"></script>
+```
+
+## 🚀 Démarrage Rapide
+
+### TypeScript/ES Modules
+
+```typescript
+import Pajo from '@arc-js/pajo';
+// ou
+import { Pajo } from '@arc-js/pajo';
+```
+
+### CommonJS
+
+```javascript
+const Pajo = require('@arc-js/pajo').default;
+// ou
+const { Pajo } = require('@arc-js/pajo');
+```
+
+### Navigateur (global)
+
+```html
+<script src="@arc-js/pajo/pajo.all.js"></script>
+<script>
+  // Disponible globalement via window.Pajo
+  console.log(Pajo.join('path', 'to', 'file.txt'));
+</script>
+```
+
+### Deno
+
+```typescript
+import Pajo from '@arc-js/pajo';
+```
+
+## 📚 Documentation API
+
+### Méthodes Statiques
+
+#### `Pajo.join(...paths: string[]): string | undefined`
+Joint plusieurs segments de chemin en normalisant les séparateurs.
+
+**Paramètres:**
+- `paths`: Segments de chemin à joindre (peut être vide)
+
+**Retourne:** Le chemin normalisé ou `undefined` si aucun chemin valide
+
+**Exemples:**
+```typescript
+// Chemins Unix
+Pajo.join('/var', 'www', 'html');           // "/var/www/html"
+Pajo.join('/usr/', '/local/', '/bin');      // "/usr/local/bin"
+Pajo.join('./src', './utils', '../components'); // "src/components"
+
+// Chemins Windows
+Pajo.join('C:\\Users', 'Documents', 'file.txt'); // "C:\\Users\\Documents\\file.txt"
+Pajo.join('D:\\Projects\\', '\\src\\', '\\app.js'); // "D:\\Projects\\src\\app.js"
+
+// Chemins mixtes
+Pajo.join('path', 'to', 'file.txt');        // "path/to/file.txt"
+Pajo.join('path/', '//to/', 'file.txt');    // "path/to/file.txt"
+```
+
+#### `Pajo.joinWithHost(host: string, ...paths: string[]): string | undefined`
+Joint un hôte avec des segments de chemin pour former une URL.
+
+**Paramètres:**
+- `host`: Hôte (peut inclure le protocole)
+- `paths`: Segments de chemin à joindre
+
+**Retourne:** L'URL complète normalisée ou `undefined` si invalide
+
+**Exemples:**
+```typescript
+Pajo.joinWithHost('example.com', 'api', 'v1', 'users'); 
+// "https://example.com/api/v1/users"
+
+Pajo.joinWithHost('https://example.com', 'api', 'v1'); 
+// "https://example.com/api/v1"
+
+Pajo.joinWithHost('myserver.com', '/var', 'log', 'app.log'); 
+// "https://myserver.com/var/log/app.log"
+```
+
+#### `Pajo.resolve(...paths: string[]): string | undefined`
+Résout les chemins avec . et .. pour obtenir un chemin normalisé.
+
+**Paramètres:**
+- `paths`: Segments de chemin à résoudre
+
+**Retourne:** Chemin résolu ou `undefined` si invalide
+
+**Exemples:**
+```typescript
+Pajo.resolve('/foo/bar', './baz');          // "/foo/bar/baz"
+Pajo.resolve('/foo/bar', '../baz');         // "/foo/baz"
+Pajo.resolve('C:\\foo\\bar', '..\\baz'); // "C:\\foo\\baz"
+```
+
+#### `Pajo.isAbsolute(path: string): boolean`
+Vérifie si un chemin est absolu.
+
+**Paramètres:**
+- `path`: Chemin à vérifier
+
+**Retourne:** `true` si le chemin est absolu
+
+**Exemples:**
+```typescript
+Pajo.isAbsolute('/path/to/file');           // true
+Pajo.isAbsolute('C:\\Windows\\System32'); // true
+Pajo.isAbsolute('https://example.com');     // true
+Pajo.isAbsolute('relative/path');           // false
+Pajo.isAbsolute('./file.txt');              // false
+```
+
+#### `Pajo.dirname(path: string): string | undefined`
+Extrait le répertoire parent d'un chemin.
+
+**Paramètres:**
+- `path`: Chemin source
+
+**Retourne:** Le répertoire parent ou `undefined`
+
+**Exemples:**
+```typescript
+Pajo.dirname('/path/to/file.txt');          // "/path/to"
+Pajo.dirname('C:\\Users\\file.txt');      // "C:\\Users"
+Pajo.dirname('file.txt');                   // "."
+```
+
+#### `Pajo.basename(path: string, ext?: string): string | undefined`
+Extrait le nom de fichier d'un chemin.
+
+**Paramètres:**
+- `path`: Chemin source
+- `ext` (optionnel): Extension à retirer
+
+**Retourne:** Le nom de fichier ou `undefined`
+
+**Exemples:**
+```typescript
+Pajo.basename('/path/to/file.txt');         // "file.txt"
+Pajo.basename('/path/to/file.txt', '.txt'); // "file"
+Pajo.basename('C:\\Users\\document.pdf'); // "document.pdf"
+```
+
+#### `Pajo.extname(path: string): string | undefined`
+Extrait l'extension d'un fichier.
+
+**Paramètres:**
+- `path`: Chemin source
+
+**Retourne:** L'extension (incluant le point) ou `undefined`
+
+**Exemples:**
+```typescript
+Pajo.extname('/path/to/file.txt');          // ".txt"
+Pajo.extname('document.pdf');               // ".pdf"
+Pajo.extname('file.with.many.dots.tar.gz'); // ".gz"
+Pajo.extname('noextension');                // undefined
+```
+
+#### `Pajo.toUnixPath(path: string): string`
+Convertit un chemin Windows en chemin Unix.
+
+**Paramètres:**
+- `path`: Chemin Windows
+
+**Retourne:** Chemin Unix
+
+**Exemples:**
+```typescript
+Pajo.toUnixPath('C:\\Users\\file.txt');   // "C:/Users/file.txt"
+Pajo.toUnixPath('D:\\Projects\\src');     // "D:/Projects/src"
+```
+
+#### `Pajo.toWindowsPath(path: string): string`
+Convertit un chemin Unix en chemin Windows.
+
+**Paramètres:**
+- `path`: Chemin Unix
+
+**Retourne:** Chemin Windows
+
+**Exemples:**
+```typescript
+Pajo.toWindowsPath('/home/user/file.txt');  // "\\home\\user\\file.txt"
+Pajo.toWindowsPath('C:/Users/document');    // "C:\\Users\\document"
+```
+
+#### `Pajo.exposeToGlobal(): void`
+Expose la classe Pajo à l'objet global (window) pour une utilisation dans les navigateurs.
+
+**Exemple:**
+```javascript
+// Dans un navigateur, après avoir chargé le script
+Pajo.exposeToGlobal();
+console.log(window.Pajo); // La classe Pajo est disponible
+```
+
+## 🔧 Utilisation Détaillée
+
+### Gestion Multi-Plateforme
+
+Pajo détecte automatiquement le style de chemin basé sur le contenu :
+
+```typescript
+// Détection automatique du style
+Pajo.join('C:\\Users', 'Documents');      // Style Windows
+Pajo.join('/home', 'user');                 // Style Unix
+Pajo.join('relative', 'path');              // Style Unix par défaut
+```
+
+### Construction d'URLs
+
+```typescript
+// Construction d'URLs avec protocole automatique
+Pajo.joinWithHost('api.example.com', 'v1', 'users');
+// → "https://api.example.com/v1/users"
+
+// Avec protocole explicite
+Pajo.joinWithHost('http://localhost:3000', 'api', 'data');
+// → "http://localhost:3000/api/data"
+
+// Avec chemin absolu sur l'hôte
+Pajo.joinWithHost('example.com', '/absolute/path');
+// → "https://example.com/absolute/path"
+```
+
+### Résolution de Chemins Relatifs
+
+```typescript
+// Résolution des chemins avec .. et .
+Pajo.resolve('/usr/local/bin', '..', 'share');
+// → "/usr/local/share"
+
+Pajo.resolve('C:\\Program Files\\App', '..', 'Common Files');
+// → "C:\\Program Files\\Common Files"
+
+Pajo.resolve('./src', '../lib', './utils');
+// → "lib/utils"
+```
+
+### Extraction d'Informations
+
+```typescript
+const path = '/var/www/html/index.html';
+
+Pajo.dirname(path);    // "/var/www/html"
+Pajo.basename(path);   // "index.html"
+Pajo.extname(path);    // ".html"
+Pajo.isAbsolute(path); // true
+```
+
+## 🎯 Exemples Complets
+
+### Exemple 1 : Gestion de Chemins dans une Application
+
+```typescript
+import Pajo from '@arc-js/pajo';
+
+class FileManager {
+  private baseDir: string;
+  
+  constructor(baseDir: string) {
+    this.baseDir = baseDir;
+  }
+  
+  getFilePath(...segments: string[]): string {
+    const fullPath = Pajo.join(this.baseDir, ...segments);
+    return Pajo.resolve(fullPath) || fullPath;
+  }
+  
+  getFileInfo(path: string) {
+    return {
+      directory: Pajo.dirname(path),
+      filename: Pajo.basename(path),
+      extension: Pajo.extname(path),
+      isAbsolute: Pajo.isAbsolute(path),
+      unixPath: Pajo.toUnixPath(path)
+    };
+  }
+}
+
+// Utilisation
+const manager = new FileManager('/var/www');
+const filePath = manager.getFilePath('uploads', '..', 'images', 'photo.jpg');
+console.log(filePath); // "/var/images/photo.jpg"
+
+const info = manager.getFileInfo(filePath);
+console.log(info);
+// {
+//   directory: "/var/images",
+//   filename: "photo.jpg",
+//   extension: ".jpg",
+//   isAbsolute: true,
+//   unixPath: "/var/images/photo.jpg"
+// }
+```
+
+### Exemple 2 : Construction d'APIs REST
+
+```typescript
+import Pajo from '@arc-js/pajo';
+
+class ApiClient {
+  private baseUrl: string;
+  
+  constructor(baseUrl: string) {
+    this.baseUrl = baseUrl;
+  }
+  
+  buildUrl(endpoint: string, ...params: string[]): string {
+    return Pajo.joinWithHost(this.baseUrl, endpoint, ...params) || '';
+  }
+  
+  async getResource(endpoint: string, id?: string) {
+    const url = id 
+      ? this.buildUrl(endpoint, id)
+      : this.buildUrl(endpoint);
+    
+    const response = await fetch(url);
+    return response.json();
+  }
+}
+
+// Utilisation
+const api = new ApiClient('https://api.example.com');
+
+// Construire des URLs
+const usersUrl = api.buildUrl('users'); 
+// → "https://api.example.com/users"
+
+const userUrl = api.buildUrl('users', '123');
+// → "https://api.example.com/users/123"
+
+// Récupérer des données
+const users = await api.getResource('users');
+const user = await api.getResource('users', '123');
+```
+
+### Exemple 3 : Migration Multi-Plateforme
+
+```typescript
+import Pajo from '@arc-js/pajo';
+
+function migratePath(oldPath: string, newBase: string): string {
+  // Normaliser le chemin d'entrée
+  const normalized = Pajo.resolve(oldPath);
+  if (!normalized) return newBase;
+  
+  // Extraire le nom de fichier
+  const filename = Pajo.basename(normalized);
+  
+  // Construire le nouveau chemin
+  return Pajo.join(newBase, filename);
+}
+
+// Migration depuis Windows vers Unix
+const windowsPath = 'C:\\Users\\John\\Documents\\file.txt';
+const unixBase = '/home/john/files';
+
+const migrated = migratePath(windowsPath, unixBase);
+console.log(migrated); // "/home/john/files/file.txt"
+
+// Conversion explicite si nécessaire
+console.log(Pajo.toUnixPath(windowsPath)); // "C:/Users/John/Documents/file.txt"
+```
+
+## 🔧 Configuration Avancée
+
+### Personnalisation du Style de Chemin
+
+Bien que Pajo détecte automatiquement le style, vous pouvez forcer un style spécifique :
+
+```typescript
+function forceWindowsPath(...segments: string[]): string {
+  // Ajouter un préfixe Windows pour forcer le style
+  return Pajo.join('C:\\forced', ...segments).replace('C:\\forced\\', '');
+}
+
+function forceUnixPath(...segments: string[]): string {
+  // Ajouter un slash initial pour forcer le style Unix
+  return Pajo.join('/forced', ...segments).replace('/forced/', '');
+}
+```
+
+### Extension pour les Chemins d'URL
+
+```typescript
+class UrlPath extends Pajo {
+  static normalizeUrlPath(path: string): string {
+    // Pour les URLs, on utilise toujours des slashs
+    return path.replace(/\\/g, '/').replace(/\/+/g, '/');
+  }
+  
+  static buildQueryString(params: Record<string, any>): string {
+    const query = new URLSearchParams();
+    Object.entries(params).forEach(([key, value]) => {
+      if (value !== undefined && value !== null) {
+        query.append(key, String(value));
+      }
+    });
+    const queryString = query.toString();
+    return queryString ? `?\${queryString}` : '';
+  }
+  
+  static joinWithQuery(host: string, path: string, queryParams?: Record<string, any>): string {
+    const url = this.joinWithHost(host, path);
+    if (!url || !queryParams) return url || '';
+    
+    const query = this.buildQueryString(queryParams);
+    return `\${url}\${query}`;
+  }
+}
+
+// Utilisation
+const url = UrlPath.joinWithQuery(
+  'example.com',
+  'api/search',
+  { q: 'test', page: 1 }
+);
+console.log(url); // "https://example.com/api/search?q=test&page=1"
+```
+
+## 📋 Table de Compatibilité
+
+### Caractères Spéciaux Supportés
+
+| Caractère | Description | Exemple |
+|-----------|-------------|---------|
+| . | Répertoire courant | `./file.txt` |
+| .. | Répertoire parent | `../parent/file.txt` |
+| ~ | Répertoire home (Unix) | `~/.config/app` |
+| \\ | Séparateur Windows | `C:\\Users\\file.txt` |
+| / | Séparateur Unix | `/home/user/file.txt` |
+
+### Plates-formes Supportées
+
+| Plate-forme | Support | Notes |
+|-------------|---------|-------|
+| Windows | ✅ Complet | Détection automatique des chemins Windows |
+| Linux | ✅ Complet | Détection automatique des chemins Unix |
+| macOS | ✅ Complet | Identique à Linux |
+| Navigateurs | ✅ Complet | Via CDN ou module ES |
+| Node.js | ✅ Complet | v18+ recommandé |
+| Deno | ✅ Complet | Via esm.sh ou npm: |
+| Bun | ✅ Complet | Support natif des modules ES |
+
+## 🚨 Gestion des Cas Limites
+
+### Chemins Vides ou Nuls
+
+```typescript
+Pajo.join();                    // undefined
+Pajo.join('');                  // undefined
+Pajo.join('', 'path');          // "path"
+Pajo.join('path', '', 'file');  // "path/file"
+```
+
+### Séparateurs Multiples
+
+```typescript
+Pajo.join('path///', '//to/', 'file.txt');  // "path/to/file.txt"
+Pajo.join('C:\\\\Windows', '\\\\System32'); // "C:\\\\Windows\\\\System32"
+```
+
+### Chemins avec Points
+
+```typescript
+Pajo.join('..', 'parent', 'file.txt');     // "../parent/file.txt"
+Pajo.join('.', 'current', 'file.txt');     // "current/file.txt"
+Pajo.join('path..', 'file.txt');           // "path../file.txt"
+```
+
+### URLs et Protocoles
+
+```typescript
+Pajo.joinWithHost('https://example.com');  // "https://example.com"
+Pajo.joinWithHost('ftp://server.com', 'files'); // "ftp://server.com/files"
+Pajo.joinWithHost('file:///C:/Users', 'doc.txt'); // "file:///C:/Users/doc.txt"
+```
+
+## 🔧 Build et Développement
+
+### Structure du Projet
+
+```
+@arc-js/pajo/
+├── pajo.all.js
+├── pajo.all.min.js
+├── index.d.ts
+├── index.js
+├── index.min.d.ts
+├── index.min.js
+├── package.json
+├── tsconfig.json
+└── README.md
+```
+
+## 📄 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/pajo** - Manipulation de chemins multi-plateforme, simple et robuste.
+
+*Développé par l'équipe INICODE*

package/index.d.ts

@@ -0,0 +1,90 @@
+declare global {
+    interface Window {
+        Pajo: typeof Pajo;
+    }
+}
+declare class Pajo {
+    private static readonly PROTOCOL_REGEX;
+    private static readonly DOUBLE_SLASH_REGEX;
+    private static readonly DOUBLE_BACKSLASH_REGEX;
+    private static readonly TRAILING_SLASH_REGEX;
+    private static readonly TRAILING_BACKSLASH_REGEX;
+    private static readonly LEADING_SLASH_REGEX;
+    private static readonly WINDOWS_DRIVE_REGEX;
+    private static readonly MIXED_SEPARATORS_REGEX;
+    /**
+     * Joint plusieurs segments de chemin en normalisant les séparateurs
+     * @param paths Segments de chemin à joindre
+     * @returns Le chemin normalisé ou undefined si aucun chemin valide
+     */
+    static join(...paths: string[]): string | undefined;
+    /**
+     * Joint un hôte avec des segments de chemin
+     * @param host Hôte (peut inclure le protocole)
+     * @param paths Segments de chemin à joindre
+     * @returns L'URL complète normalisée ou undefined si invalide
+     */
+    static joinWithHost(host: string, ...paths: string[]): string | undefined;
+    /**
+     * Normalise un segment de chemin individuel
+     * @param path Segment de chemin à normaliser
+     * @param isWindowsStyle Si on doit utiliser le style Windows
+     * @returns Le segment normalisé
+     */
+    private static normalizePathSegment;
+    /**
+     * Vérifie si le chemin est un chemin Windows
+     * @param path Chemin à vérifier
+     * @returns True si c'est un chemin Windows
+     */
+    private static isWindowsPath;
+    /**
+     * Résout les chemins avec . et .. (simplifié)
+     * @param paths Segments de chemin à résoudre
+     * @returns Chemin résolu
+     */
+    static resolve(...paths: string[]): string | undefined;
+    /**
+     * Vérifie si un chemin est absolu
+     * @param path Chemin à vérifier
+     * @returns True si le chemin est absolu
+     */
+    static isAbsolute(path: string): boolean;
+    /**
+     * Extrait le répertoire parent d'un chemin
+     * @param path Chemin source
+     * @returns Le répertoire parent ou undefined
+     */
+    static dirname(path: string): string | undefined;
+    /**
+     * Extrait le nom de fichier d'un chemin
+     * @param path Chemin source
+     * @param ext Extension optionnelle à retirer
+     * @returns Le nom de fichier ou undefined
+     */
+    static basename(path: string, ext?: string): string | undefined;
+    /**
+     * Extrait l'extension d'un fichier
+     * @param path Chemin source
+     * @returns L'extension ou undefined
+     */
+    static extname(path: string): string | undefined;
+    /**
+     * Convertit un chemin Windows en chemin Unix
+     * @param path Chemin Windows
+     * @returns Chemin Unix
+     */
+    static toUnixPath(path: string): string;
+    /**
+     * Convertit un chemin Unix en chemin Windows
+     * @param path Chemin Unix
+     * @returns Chemin Windows
+     */
+    static toWindowsPath(path: string): string;
+    /**
+     * Exposition globale de la classe
+     */
+    static exposeToGlobal(): void;
+}
+
+export { Pajo, Pajo as default };

package/index.js

@@ -0,0 +1,150 @@
+class Pajo {
+    static PROTOCOL_REGEX = /^[a-zA-Z]+:\/\//;
+    static DOUBLE_SLASH_REGEX = /\/+/g;
+    static DOUBLE_BACKSLASH_REGEX = /\\+/g;
+    static TRAILING_SLASH_REGEX = /\/+$/;
+    static TRAILING_BACKSLASH_REGEX = /\\+$/;
+    static LEADING_SLASH_REGEX = /^\/+/;
+    static WINDOWS_DRIVE_REGEX = /^[a-zA-Z]:\\/;
+    static MIXED_SEPARATORS_REGEX = /[\\/]+/g;
+    static join(...paths) {
+        if (paths.length === 0)
+            return undefined;
+        const isWindowsPath = paths.some(path => this.isWindowsPath(path));
+        const cleanPaths = paths
+            .filter(path => path != null && path.trim().length > 0)
+            .map(path => this.normalizePathSegment(path, isWindowsPath));
+        if (cleanPaths.length === 0)
+            return undefined;
+        const separator = isWindowsPath ? '\\' : '/';
+        let result = cleanPaths.join(separator);
+        if (isWindowsPath) {
+            result = result.replace(this.DOUBLE_BACKSLASH_REGEX, '\\');
+        }
+        else {
+            result = result.replace(this.DOUBLE_SLASH_REGEX, '/');
+            const hasLeadingSlash = paths[0]?.startsWith('/') || false;
+            if (hasLeadingSlash && !result.startsWith('/')) {
+                result = '/' + result;
+            }
+        }
+        return result || undefined;
+    }
+    static joinWithHost(host, ...paths) {
+        if (!host || host.trim().length === 0) {
+            return this.join(...paths);
+        }
+        const cleanHost = host.trim().replace(this.TRAILING_SLASH_REGEX, '');
+        const hasProtocol = this.PROTOCOL_REGEX.test(cleanHost);
+        const normalizedHost = hasProtocol ? cleanHost : `https://${cleanHost}`;
+        const joinedPath = this.join(...paths);
+        if (!joinedPath) {
+            return normalizedHost;
+        }
+        const cleanPath = joinedPath.replace(/\\/g, '/').replace(this.LEADING_SLASH_REGEX, '');
+        return `${normalizedHost}/${cleanPath}`;
+    }
+    static normalizePathSegment(path, isWindowsStyle) {
+        if (!path || path.trim().length === 0)
+            return '';
+        const trimmed = path.trim();
+        if (isWindowsStyle) {
+            return trimmed
+                .replace(this.DOUBLE_BACKSLASH_REGEX, '\\')
+                .replace(this.TRAILING_BACKSLASH_REGEX, '');
+        }
+        else {
+            return trimmed
+                .replace(this.DOUBLE_SLASH_REGEX, '/')
+                .replace(this.TRAILING_SLASH_REGEX, '');
+        }
+    }
+    static isWindowsPath(path) {
+        return this.WINDOWS_DRIVE_REGEX.test(path) || path.includes('\\');
+    }
+    static resolve(...paths) {
+        const joined = this.join(...paths);
+        if (!joined)
+            return undefined;
+        const isWindows = this.isWindowsPath(joined);
+        const separator = isWindows ? '\\' : '/';
+        const parts = joined.split(separator);
+        const resolved = [];
+        for (const part of parts) {
+            if (part === '..') {
+                if (resolved.length > 0 && resolved[resolved.length - 1] !== '..') {
+                    resolved.pop();
+                }
+                else {
+                    resolved.push(part);
+                }
+            }
+            else if (part !== '.' && part !== '') {
+                resolved.push(part);
+            }
+        }
+        let result = resolved.join(separator);
+        if (isWindows && this.WINDOWS_DRIVE_REGEX.test(parts[0])) {
+            result = parts[0] + separator + result;
+        }
+        return result;
+    }
+    static isAbsolute(path) {
+        if (!path)
+            return false;
+        return path.startsWith('/') ||
+            this.WINDOWS_DRIVE_REGEX.test(path) ||
+            this.PROTOCOL_REGEX.test(path);
+    }
+    static dirname(path) {
+        if (!path)
+            return undefined;
+        const isWindows = this.isWindowsPath(path);
+        const separator = isWindows ? '\\' : '/';
+        const normalized = this.normalizePathSegment(path, isWindows);
+        const lastSeparatorIndex = normalized.lastIndexOf(separator);
+        if (lastSeparatorIndex === -1)
+            return isWindows ? '.' : '.';
+        if (lastSeparatorIndex === 0)
+            return isWindows ? normalized.substring(0, 2) : '/';
+        return normalized.substring(0, lastSeparatorIndex) || (isWindows ? '.' : '/');
+    }
+    static basename(path, ext) {
+        if (!path)
+            return undefined;
+        const isWindows = this.isWindowsPath(path);
+        const separator = isWindows ? '\\' : '/';
+        const normalized = this.normalizePathSegment(path, isWindows);
+        const lastSeparatorIndex = normalized.lastIndexOf(separator);
+        let basename = lastSeparatorIndex === -1 ? normalized : normalized.substring(lastSeparatorIndex + 1);
+        if (ext && basename.endsWith(ext)) {
+            basename = basename.substring(0, basename.length - ext.length);
+        }
+        return basename || undefined;
+    }
+    static extname(path) {
+        if (!path)
+            return undefined;
+        const basename = this.basename(path);
+        if (!basename)
+            return undefined;
+        const lastDotIndex = basename.lastIndexOf('.');
+        return lastDotIndex > 0 ? basename.substring(lastDotIndex) : undefined;
+    }
+    static toUnixPath(path) {
+        return path.replace(/\\/g, '/');
+    }
+    static toWindowsPath(path) {
+        return path.replace(/\//g, '\\');
+    }
+    static exposeToGlobal() {
+        if (typeof window !== "undefined") {
+            window.Pajo = Pajo;
+        }
+    }
+}
+if (typeof window !== "undefined") {
+    Pajo.exposeToGlobal();
+}
+
+export { Pajo, Pajo as default };

package/index.min.d.ts

@@ -0,0 +1,90 @@
+declare global {
+    interface Window {
+        Pajo: typeof Pajo;
+    }
+}
+declare class Pajo {
+    private static readonly PROTOCOL_REGEX;
+    private static readonly DOUBLE_SLASH_REGEX;
+    private static readonly DOUBLE_BACKSLASH_REGEX;
+    private static readonly TRAILING_SLASH_REGEX;
+    private static readonly TRAILING_BACKSLASH_REGEX;
+    private static readonly LEADING_SLASH_REGEX;
+    private static readonly WINDOWS_DRIVE_REGEX;
+    private static readonly MIXED_SEPARATORS_REGEX;
+    /**
+     * Joint plusieurs segments de chemin en normalisant les séparateurs
+     * @param paths Segments de chemin à joindre
+     * @returns Le chemin normalisé ou undefined si aucun chemin valide
+     */
+    static join(...paths: string[]): string | undefined;
+    /**
+     * Joint un hôte avec des segments de chemin
+     * @param host Hôte (peut inclure le protocole)
+     * @param paths Segments de chemin à joindre
+     * @returns L'URL complète normalisée ou undefined si invalide
+     */
+    static joinWithHost(host: string, ...paths: string[]): string | undefined;
+    /**
+     * Normalise un segment de chemin individuel
+     * @param path Segment de chemin à normaliser
+     * @param isWindowsStyle Si on doit utiliser le style Windows
+     * @returns Le segment normalisé
+     */
+    private static normalizePathSegment;
+    /**
+     * Vérifie si le chemin est un chemin Windows
+     * @param path Chemin à vérifier
+     * @returns True si c'est un chemin Windows
+     */
+    private static isWindowsPath;
+    /**
+     * Résout les chemins avec . et .. (simplifié)
+     * @param paths Segments de chemin à résoudre
+     * @returns Chemin résolu
+     */
+    static resolve(...paths: string[]): string | undefined;
+    /**
+     * Vérifie si un chemin est absolu
+     * @param path Chemin à vérifier
+     * @returns True si le chemin est absolu
+     */
+    static isAbsolute(path: string): boolean;
+    /**
+     * Extrait le répertoire parent d'un chemin
+     * @param path Chemin source
+     * @returns Le répertoire parent ou undefined
+     */
+    static dirname(path: string): string | undefined;
+    /**
+     * Extrait le nom de fichier d'un chemin
+     * @param path Chemin source
+     * @param ext Extension optionnelle à retirer
+     * @returns Le nom de fichier ou undefined
+     */
+    static basename(path: string, ext?: string): string | undefined;
+    /**
+     * Extrait l'extension d'un fichier
+     * @param path Chemin source
+     * @returns L'extension ou undefined
+     */
+    static extname(path: string): string | undefined;
+    /**
+     * Convertit un chemin Windows en chemin Unix
+     * @param path Chemin Windows
+     * @returns Chemin Unix
+     */
+    static toUnixPath(path: string): string;
+    /**
+     * Convertit un chemin Unix en chemin Windows
+     * @param path Chemin Unix
+     * @returns Chemin Windows
+     */
+    static toWindowsPath(path: string): string;
+    /**
+     * Exposition globale de la classe
+     */
+    static exposeToGlobal(): void;
+}
+
+export { Pajo, Pajo as default };

package/index.min.js

@@ -0,0 +1 @@
+class Pajo{static PROTOCOL_REGEX=/^[a-zA-Z]+:\/\//;static DOUBLE_SLASH_REGEX=/\/+/g;static DOUBLE_BACKSLASH_REGEX=/\\+/g;static TRAILING_SLASH_REGEX=/\/+$/;static TRAILING_BACKSLASH_REGEX=/\\+$/;static LEADING_SLASH_REGEX=/^\/+/;static WINDOWS_DRIVE_REGEX=/^[a-zA-Z]:\\/;static MIXED_SEPARATORS_REGEX=/[\\/]+/g;static join(...s){if(0!==s.length){let i=s.some(t=>this.isWindowsPath(t));var e=s.filter(t=>null!=t&&0<t.trim().length).map(t=>this.normalizePathSegment(t,i));if(0!==e.length){var a=i?"\\":"/";let t=e.join(a);return i?t=t.replace(this.DOUBLE_BACKSLASH_REGEX,"\\"):(t=t.replace(this.DOUBLE_SLASH_REGEX,"/"),s[0]?.startsWith("/")&&!t.startsWith("/")&&(t="/"+t)),t||void 0}}}static joinWithHost(t,...i){var s;return t&&0!==t.trim().length?(t=t.trim().replace(this.TRAILING_SLASH_REGEX,""),t=this.PROTOCOL_REGEX.test(t)?t:"https://"+t,(s=this.join(...i))?t+"/"+s.replace(/\\/g,"/").replace(this.LEADING_SLASH_REGEX,""):t):this.join(...i)}static normalizePathSegment(t,i){return t&&0!==t.trim().length?(t=t.trim(),i?t.replace(this.DOUBLE_BACKSLASH_REGEX,"\\").replace(this.TRAILING_BACKSLASH_REGEX,""):t.replace(this.DOUBLE_SLASH_REGEX,"/").replace(this.TRAILING_SLASH_REGEX,"")):""}static isWindowsPath(t){return this.WINDOWS_DRIVE_REGEX.test(t)||t.includes("\\")}static resolve(...i){i=this.join(...i);if(i){var s,e=this.isWindowsPath(i),a=e?"\\":"/",i=i.split(a),n=[];for(s of i)".."===s?0<n.length&&".."!==n[n.length-1]?n.pop():n.push(s):"."!==s&&""!==s&&n.push(s);let t=n.join(a);return t=e&&this.WINDOWS_DRIVE_REGEX.test(i[0])?i[0]+a+t:t}}static isAbsolute(t){return!!t&&(t.startsWith("/")||this.WINDOWS_DRIVE_REGEX.test(t)||this.PROTOCOL_REGEX.test(t))}static dirname(t){var i,s;if(t)return s=(i=this.isWindowsPath(t))?"\\":"/",-1===(s=(t=this.normalizePathSegment(t,i)).lastIndexOf(s))?".":0===s?i?t.substring(0,2):"/":t.substring(0,s)||(i?".":"/")}static basename(i,s){if(i){var e=this.isWindowsPath(i),a=e?"\\":"/",i=this.normalizePathSegment(i,e),e=i.lastIndexOf(a);let t=-1===e?i:i.substring(e+1);return(t=s&&t.endsWith(s)?t.substring(0,t.length-s.length):t)||void 0}}static extname(t){var i;return(t=t&&this.basename(t))&&0<(i=t.lastIndexOf("."))?t.substring(i):void 0}static toUnixPath(t){return t.replace(/\\/g,"/")}static toWindowsPath(t){return t.replace(/\//g,"\\")}static exposeToGlobal(){"undefined"!=typeof window&&(window.Pajo=Pajo)}}"undefined"!=typeof window&&Pajo.exposeToGlobal();export{Pajo,Pajo as default};

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@arc-js/pajo",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "0.0.1",
+  "description": "Pajo est une bibliothèque TypeScript légère et robuste pour la manipulation de chemins de fichiers et d'URLs. Elle offre une API unifiée et type-safe pour travailler avec des chemins de fichiers sur différentes plateformes (Windows, Linux, macOS) et pour construire des URLs de manière cohérente.",
+  "main": "index.js",
+  "keywords": [],
+  "author": "INICODE <contact@inicode@gmail.com>",
+  "license": "MIT",
+  "scripts": {
+    "init": "npm init --scope=@arc-js/pajo",
+    "login": "npm login"
+  },
+  "devDependencies": {},
+  "dependencies": {}
+}

package/pajo.all.js

@@ -0,0 +1,222 @@
+class Pajo {
+    static PROTOCOL_REGEX = /^[a-zA-Z]+:\/\//;
+    static DOUBLE_SLASH_REGEX = /\/+/g;
+    static DOUBLE_BACKSLASH_REGEX = /\\+/g;
+    static TRAILING_SLASH_REGEX = /\/+$/;
+    static TRAILING_BACKSLASH_REGEX = /\\+$/;
+    static LEADING_SLASH_REGEX = /^\/+/;
+    static WINDOWS_DRIVE_REGEX = /^[a-zA-Z]:\\/;
+    static MIXED_SEPARATORS_REGEX = /[\\/]+/g;
+    /**
+     * Joint plusieurs segments de chemin en normalisant les séparateurs
+     * @param paths Segments de chemin à joindre
+     * @returns Le chemin normalisé ou undefined si aucun chemin valide
+     */
+    static join(...paths) {
+        if (paths.length === 0)
+            return undefined;
+        // Détection du style de chemin (Windows ou Unix)
+        const isWindowsPath = paths.some(path => this.isWindowsPath(path));
+        // Filtre les chemins vides et nettoie chaque segment
+        const cleanPaths = paths
+            .filter(path => path != null && path.trim().length > 0)
+            .map(path => this.normalizePathSegment(path, isWindowsPath));
+        if (cleanPaths.length === 0)
+            return undefined;
+        // Reconstruction du chemin final avec le séparateur approprié
+        const separator = isWindowsPath ? '\\' : '/';
+        let result = cleanPaths.join(separator);
+        // Normalisation des séparateurs multiples
+        if (isWindowsPath) {
+            result = result.replace(this.DOUBLE_BACKSLASH_REGEX, '\\');
+        }
+        else {
+            result = result.replace(this.DOUBLE_SLASH_REGEX, '/');
+            // Préservation du slash initial pour les chemins absolus Linux
+            const hasLeadingSlash = paths[0]?.startsWith('/') || false;
+            if (hasLeadingSlash && !result.startsWith('/')) {
+                result = '/' + result;
+            }
+        }
+        return result || undefined;
+    }
+    /**
+     * Joint un hôte avec des segments de chemin
+     * @param host Hôte (peut inclure le protocole)
+     * @param paths Segments de chemin à joindre
+     * @returns L'URL complète normalisée ou undefined si invalide
+     */
+    static joinWithHost(host, ...paths) {
+        if (!host || host.trim().length === 0) {
+            return this.join(...paths);
+        }
+        const cleanHost = host.trim().replace(this.TRAILING_SLASH_REGEX, '');
+        // Vérification du protocole
+        const hasProtocol = this.PROTOCOL_REGEX.test(cleanHost);
+        const normalizedHost = hasProtocol ? cleanHost : `https://${cleanHost}`;
+        // Traitement des chemins
+        const joinedPath = this.join(...paths);
+        if (!joinedPath) {
+            return normalizedHost;
+        }
+        // Pour les URLs, on utilise toujours des slashs
+        const cleanPath = joinedPath.replace(/\\/g, '/').replace(this.LEADING_SLASH_REGEX, '');
+        return `${normalizedHost}/${cleanPath}`;
+    }
+    /**
+     * Normalise un segment de chemin individuel
+     * @param path Segment de chemin à normaliser
+     * @param isWindowsStyle Si on doit utiliser le style Windows
+     * @returns Le segment normalisé
+     */
+    static normalizePathSegment(path, isWindowsStyle) {
+        if (!path || path.trim().length === 0)
+            return '';
+        const trimmed = path.trim();
+        if (isWindowsStyle) {
+            return trimmed
+                .replace(this.DOUBLE_BACKSLASH_REGEX, '\\')
+                .replace(this.TRAILING_BACKSLASH_REGEX, '');
+        }
+        else {
+            return trimmed
+                .replace(this.DOUBLE_SLASH_REGEX, '/')
+                .replace(this.TRAILING_SLASH_REGEX, '');
+        }
+    }
+    /**
+     * Vérifie si le chemin est un chemin Windows
+     * @param path Chemin à vérifier
+     * @returns True si c'est un chemin Windows
+     */
+    static isWindowsPath(path) {
+        return this.WINDOWS_DRIVE_REGEX.test(path) || path.includes('\\');
+    }
+    /**
+     * Résout les chemins avec . et .. (simplifié)
+     * @param paths Segments de chemin à résoudre
+     * @returns Chemin résolu
+     */
+    static resolve(...paths) {
+        const joined = this.join(...paths);
+        if (!joined)
+            return undefined;
+        const isWindows = this.isWindowsPath(joined);
+        const separator = isWindows ? '\\' : '/';
+        const parts = joined.split(separator);
+        const resolved = [];
+        for (const part of parts) {
+            if (part === '..') {
+                if (resolved.length > 0 && resolved[resolved.length - 1] !== '..') {
+                    resolved.pop();
+                }
+                else {
+                    resolved.push(part);
+                }
+            }
+            else if (part !== '.' && part !== '') {
+                resolved.push(part);
+            }
+        }
+        let result = resolved.join(separator);
+        // Restauration du préfixe Windows si nécessaire
+        if (isWindows && this.WINDOWS_DRIVE_REGEX.test(parts[0])) {
+            result = parts[0] + separator + result;
+        }
+        return result;
+    }
+    /**
+     * Vérifie si un chemin est absolu
+     * @param path Chemin à vérifier
+     * @returns True si le chemin est absolu
+     */
+    static isAbsolute(path) {
+        if (!path)
+            return false;
+        return path.startsWith('/') ||
+            this.WINDOWS_DRIVE_REGEX.test(path) ||
+            this.PROTOCOL_REGEX.test(path);
+    }
+    /**
+     * Extrait le répertoire parent d'un chemin
+     * @param path Chemin source
+     * @returns Le répertoire parent ou undefined
+     */
+    static dirname(path) {
+        if (!path)
+            return undefined;
+        const isWindows = this.isWindowsPath(path);
+        const separator = isWindows ? '\\' : '/';
+        const normalized = this.normalizePathSegment(path, isWindows);
+        const lastSeparatorIndex = normalized.lastIndexOf(separator);
+        if (lastSeparatorIndex === -1)
+            return isWindows ? '.' : '.';
+        if (lastSeparatorIndex === 0)
+            return isWindows ? normalized.substring(0, 2) : '/';
+        return normalized.substring(0, lastSeparatorIndex) || (isWindows ? '.' : '/');
+    }
+    /**
+     * Extrait le nom de fichier d'un chemin
+     * @param path Chemin source
+     * @param ext Extension optionnelle à retirer
+     * @returns Le nom de fichier ou undefined
+     */
+    static basename(path, ext) {
+        if (!path)
+            return undefined;
+        const isWindows = this.isWindowsPath(path);
+        const separator = isWindows ? '\\' : '/';
+        const normalized = this.normalizePathSegment(path, isWindows);
+        const lastSeparatorIndex = normalized.lastIndexOf(separator);
+        let basename = lastSeparatorIndex === -1 ? normalized : normalized.substring(lastSeparatorIndex + 1);
+        // Gestion de l'extension optionnelle
+        if (ext && basename.endsWith(ext)) {
+            basename = basename.substring(0, basename.length - ext.length);
+        }
+        return basename || undefined;
+    }
+    /**
+     * Extrait l'extension d'un fichier
+     * @param path Chemin source
+     * @returns L'extension ou undefined
+     */
+    static extname(path) {
+        if (!path)
+            return undefined;
+        const basename = this.basename(path);
+        if (!basename)
+            return undefined;
+        const lastDotIndex = basename.lastIndexOf('.');
+        return lastDotIndex > 0 ? basename.substring(lastDotIndex) : undefined;
+    }
+    /**
+     * Convertit un chemin Windows en chemin Unix
+     * @param path Chemin Windows
+     * @returns Chemin Unix
+     */
+    static toUnixPath(path) {
+        return path.replace(/\\/g, '/');
+    }
+    /**
+     * Convertit un chemin Unix en chemin Windows
+     * @param path Chemin Unix
+     * @returns Chemin Windows
+     */
+    static toWindowsPath(path) {
+        return path.replace(/\//g, '\\');
+    }
+    /**
+     * Exposition globale de la classe
+     */
+    static exposeToGlobal() {
+        if (typeof window !== "undefined") {
+            window.Pajo = Pajo;
+        }
+    }
+}
+// Exposition automatique en environnement browser
+if (typeof window !== "undefined") {
+    Pajo.exposeToGlobal();
+}
+
+

package/pajo.all.min.js

@@ -0,0 +1 @@
+class Pajo{static PROTOCOL_REGEX=/^[a-zA-Z]+:\/\//;static DOUBLE_SLASH_REGEX=/\/+/g;static DOUBLE_BACKSLASH_REGEX=/\\+/g;static TRAILING_SLASH_REGEX=/\/+$/;static TRAILING_BACKSLASH_REGEX=/\\+$/;static LEADING_SLASH_REGEX=/^\/+/;static WINDOWS_DRIVE_REGEX=/^[a-zA-Z]:\\/;static MIXED_SEPARATORS_REGEX=/[\\/]+/g;static join(...s){if(0!==s.length){let i=s.some(t=>this.isWindowsPath(t));var e=s.filter(t=>null!=t&&0<t.trim().length).map(t=>this.normalizePathSegment(t,i));if(0!==e.length){var a=i?"\\":"/";let t=e.join(a);return i?t=t.replace(this.DOUBLE_BACKSLASH_REGEX,"\\"):(t=t.replace(this.DOUBLE_SLASH_REGEX,"/"),s[0]?.startsWith("/")&&!t.startsWith("/")&&(t="/"+t)),t||void 0}}}static joinWithHost(t,...i){var s;return t&&0!==t.trim().length?(t=t.trim().replace(this.TRAILING_SLASH_REGEX,""),t=this.PROTOCOL_REGEX.test(t)?t:"https://"+t,(s=this.join(...i))?t+"/"+s.replace(/\\/g,"/").replace(this.LEADING_SLASH_REGEX,""):t):this.join(...i)}static normalizePathSegment(t,i){return t&&0!==t.trim().length?(t=t.trim(),i?t.replace(this.DOUBLE_BACKSLASH_REGEX,"\\").replace(this.TRAILING_BACKSLASH_REGEX,""):t.replace(this.DOUBLE_SLASH_REGEX,"/").replace(this.TRAILING_SLASH_REGEX,"")):""}static isWindowsPath(t){return this.WINDOWS_DRIVE_REGEX.test(t)||t.includes("\\")}static resolve(...i){i=this.join(...i);if(i){var s,e=this.isWindowsPath(i),a=e?"\\":"/",i=i.split(a),n=[];for(s of i)".."===s?0<n.length&&".."!==n[n.length-1]?n.pop():n.push(s):"."!==s&&""!==s&&n.push(s);let t=n.join(a);return t=e&&this.WINDOWS_DRIVE_REGEX.test(i[0])?i[0]+a+t:t}}static isAbsolute(t){return!!t&&(t.startsWith("/")||this.WINDOWS_DRIVE_REGEX.test(t)||this.PROTOCOL_REGEX.test(t))}static dirname(t){var i,s;if(t)return s=(i=this.isWindowsPath(t))?"\\":"/",-1===(s=(t=this.normalizePathSegment(t,i)).lastIndexOf(s))?".":0===s?i?t.substring(0,2):"/":t.substring(0,s)||(i?".":"/")}static basename(i,s){if(i){var e=this.isWindowsPath(i),a=e?"\\":"/",i=this.normalizePathSegment(i,e),e=i.lastIndexOf(a);let t=-1===e?i:i.substring(e+1);return(t=s&&t.endsWith(s)?t.substring(0,t.length-s.length):t)||void 0}}static extname(t){var i;return(t=t&&this.basename(t))&&0<(i=t.lastIndexOf("."))?t.substring(i):void 0}static toUnixPath(t){return t.replace(/\\/g,"/")}static toWindowsPath(t){return t.replace(/\//g,"\\")}static exposeToGlobal(){"undefined"!=typeof window&&(window.Pajo=Pajo)}}"undefined"!=typeof window&&Pajo.exposeToGlobal();

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"
+    ]
+}