chromalogger 1.1.0 → 1.1.2

package/README.fr.md

@@ -0,0 +1,360 @@
+# ChromaLogger
+
+[![npm version](https://img.shields.io/npm/v/chromalogger.svg?style=flat)](https://www.npmjs.com/package/chromalogger)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![GitHub stars](https://img.shields.io/github/stars/OrssiMp/chromalogger.svg?style=social)](https://github.com/OrssiMp/chromalogger/stargazers)
+
+[🇬🇧 English](README.md) | [🇫🇷 Français](README.fr.md)
+
+ChromaLogger est une bibliothèque Node.js puissante et flexible pour la journalisation de console avec un support avancé des couleurs, des styles et des fonctionnalités de débogage. Parfaite pour le développement et le débogage d'applications Node.js.
+
+## 🚀 Fonctionnalités
+
+- 🌈 Support avancé des couleurs et styles (16+ couleurs, formatage de texte)
+- 📊 Niveaux de log intégrés (DEBUG, INFO, WARN, ERROR)
+- 🔄 Détection des références circulaires
+- 📝 Support des templates avec placeholders
+- 🛠️ Création de loggers personnalisés
+- 💻 Utilisation en ligne de commande avec `clog`
+- 🔌 Architecture extensible et API simple
+
+## 📦 Installation
+
+```bash
+# Avec npm
+npm install chromalogger
+
+# Ou avec Yarn
+yarn add chromalogger
+```
+
+## 💡 Démarrage Rapide
+
+```javascript
+import { log, info, warn, error, createLogger } from 'chromalogger';
+
+// Utilisation de base
+log('Ceci est un message de log');
+info('Message informatif');
+warn('Message d\'avertissement');
+error('Message d\'erreur');
+
+// Avec styles
+const success = createLogger('green', 'bold');
+success('Opération réussie !');
+
+// Templates avec placeholders
+const utilisateur = { nom: 'Alice', age: 30 };
+info('L\'utilisateur {0} a {1} ans', utilisateur.nom, utilisateur.age);
+
+// Styles en ligne
+import { red, bgYellow, bold } from 'chromalogger';
+console.log(red('Texte en rouge') + ' et ' + bgYellow('fond jaune'));
+```
+
+## 📚 Documentation
+
+### Niveaux de Log
+
+ChromaLogger définit 5 niveaux de log, du plus bas au plus élevé :
+
+| Niveau  | Valeur | Description                                              |
+| ------- | ------ | -------------------------------------------------------- |
+| `DEBUG` | 0      | Messages détaillés pour le débogage                      |
+| `INFO`  | 1      | Informations générales sur le déroulement du programme   |
+| `WARN`  | 2      | Situations potentiellement problématiques                |
+| `ERROR` | 3      | Erreurs qui n'empêchent pas l'application de fonctionner |
+| `NONE`  | 4      | Aucun log ne sera affiché                                |
+
+### Fonctions Principales
+
+#### `createLogger(...styles)`
+
+Crée un nouveau logger personnalisé avec les styles spécifiés.
+
+```javascript
+const header = createLogger('bgBlue', 'white', 'bold');
+header('En-tête important');
+```
+
+#### `setLogLevel(level)`
+
+Définit le niveau de log minimum à afficher.
+
+```javascript
+setLogLevel('DEBUG'); // Affiche tout
+setLogLevel('WARN'); // Affiche uniquement WARN et ERROR
+```
+
+### Styles Disponibles
+
+#### Couleurs de texte
+- `black`, `red`, `green`, `yellow`, `blue`, `magenta`, `cyan`, `white`
+
+#### Arrière-plans
+- `bgBlack`, `bgRed`, `bgGreen`, `bgYellow`, `bgBlue`, `bgMagenta`, `bgCyan`, `bgWhite`
+
+#### Styles de texte
+- `bright` - Texte en gras
+- `dim` - Texte atténué
+- `italic` - Texte en italique
+- `underline` - Texte souligné
+- `blink` - Texte clignotant
+- `reverse` - Inverse les couleurs
+- `hidden` - Texte caché
+- `strikethrough` - Texte barré
+
+## 🤝 Contribution
+
+Les contributions sont les bienvenues ! Pour contribuer :
+
+1. Forkez le dépôt
+2. Créez une branche pour votre fonctionnalité (`git checkout -b feature/ma-fonctionnalite`)
+3. Committez vos changements (`git commit -am 'Ajouter une fonctionnalité'`)
+4. Poussez vers la branche (`git push origin feature/ma-fonctionnalite`)
+5. Ouvrez une Pull Request
+
+## 📄 Licence
+
+Ce projet est sous licence MIT - voir le fichier [LICENCE](LICENSE) pour plus de détails.
+
+## 🙏 Remerciements
+
+- Inspiré par des bibliothèques populaires comme chalk, winston et debug
+- Merci à tous les contributeurs qui ont aidé à améliorer ce projet
+# Afficher l'aide
+## 🛠️ Interface en Ligne de Commande (CLI)
+
+ChromaLogger inclut un utilitaire en ligne de commande `clog` :
+
+```bash
+# Afficher l'aide
+npx clog --help
+
+# Afficher un message simple
+npx clog "Mon message"
+
+# Utiliser des couleurs et styles
+npx clog --color red --style bright "Message important"
+
+## 🔍 Exemples Complets
+
+### Configuration d'un logger personnalisé
+
+```javascript
+import { createLogger, setLogLevel } from 'chromalogger';
+
+// Créer des loggers personnalisés
+const success = createLogger('green', 'bright');
+const error = createLogger('red', 'bold');
+const debug = createLogger('blue', 'dim');
+
+// Définir le niveau de log
+setLogLevel('DEBUG');
+
+// Utilisation
+success('Connexion réussie !');
+error('Échec de la connexion');
+debug('État de la connexion:', { status: 'connected', time: Date.now() });
+```
+
+### Journalisation dans une application Express
+
+```javascript
+import express from 'express';
+import { createLogger } from 'chromalogger';
+
+const app = express();
+const logger = createLogger('magenta');
+const errorLogger = createLogger('red', 'bold');
+
+app.use((req, res, next) => {
+  logger(`${req.method} ${req.url}`);
+  next();
+});
+
+app.get('/', (req, res) => {
+  res.send('Bienvenue sur mon API');
+});
+
+// Gestion des erreurs
+app.use((err, req, res, next) => {
+  errorLogger('ERREUR:', err.message);
+  res.status(500).send('Quelque chose a mal tourné !');
+});
+
+app.listen(3000, () => {
+  logger('Serveur démarré sur http://localhost:3000');
+});
+```
+
+## 📝 Bonnes Pratiques
+
+1. **Environnement de développement** : Utilisez `DEBUG` pour avoir un maximum d'informations
+2. **Environnement de production** : Utilisez `WARN` ou `ERROR` pour éviter la surcharge de logs
+3. **Créer des loggers spécifiques** : Utilisez `createLogger()` pour des catégories de logs différentes
+4. **Éviter les logs sensibles** : Ne loguez jamais de mots de passe ou informations sensibles
+5. **Utiliser les bons niveaux** :
+   - `debug` pour le débogage détaillé
+   - `info` pour les informations importantes
+   - `warn` pour les avertissements
+   - `error` pour les erreurs
+
+## 📄 Licence
+
+MIT © [Votre Nom]
+
+Pour plus d'informations sur les fonctionnalités avancées, consultez la [documentation complète](https://github.com/OrssiMp/chromalogger#readme).
+
+## 🤝 Contribuer
+
+Les contributions sont les bienvenues ! Voici comment contribuer :
+
+1. Forkez le projet
+2. Créez une branche pour votre fonctionnalité (`git checkout -b feature/AmazingFeature`)
+3. Committez vos changements (`git commit -m 'Add some AmazingFeature'`)
+4. Poussez vers la branche (`git push origin feature/AmazingFeature`)
+5. Ouvrez une Pull Request
+
+## 📄 Licence
+
+Distribué sous licence MIT. Voir le fichier `LICENSE` pour plus d'informations.
+
+## 📞 Contact
+
+Orssi Mp - [@OrssiMp](https://github.com/OrssiMp) - orssimpiere5@gmail.com
+
+Lien du projet : [https://github.com/OrssiMp/chromalogger](https://github.com/OrssiMp/chromalogger)
+
+// Couleurs de base
+logger.red('Ceci est en rouge');
+logger.green('Ceci est en vert');
+logger.blue('Ceci est en bleu');
+logger.yellow('Ceci est en jaune');
+
+````
+
+### Avec CommonJS
+
+```javascript
+const logger = require('logcolor-js');
+
+// Arrière-plans colorés
+logger.bgRed(' Fond rouge ');
+logger.bgGreen(' Fond vert ');
+logger.bgBlue(' Fond bleu ');
+````
+
+## Fonctionnalités
+
+### Couleurs de texte
+
+- `red(text)` - Texte rouge
+- `green(text)` - Texte vert
+- `blue(text)` - Texte bleu
+- `yellow(text)` - Texte jaune
+- `white(text)` - Texte blanc
+- `black(text)` - Texte noir
+- `magenta(text)` - Texte magenta
+- `cyan(text)` - Texte cyan
+
+### Arrière-plans
+
+- `bgRed(text)` - Fond rouge
+- `bgGreen(text)` - Fond vert
+- `bgBlue(text)` - Fond bleu
+- `bgYellow(text)` - Fond jaune
+- `bgWhite(text)` - Fond blanc
+- `bgBlack(text)` - Fond noir
+- `bgMagenta(text)` - Fond magenta
+- `bgCyan(text)` - Fond cyan
+
+### Styles de texte
+
+- `bold(text)` - Texte en gras
+- `underline(text)` - Texte souligné
+- `italic(text)` - Texte en italique
+- `inverse(text)` - Inverse les couleurs
+- `strikethrough(text)` - Texte barré
+
+### Niveaux de log
+
+- `setLogLevel(level)` - Définit le niveau de log ('DEBUG', 'INFO', 'WARN', 'ERROR')
+- `debug(...args)` - Message de débogage
+- `info(...args)` - Information
+- `warn(...args)` - Avertissement
+- `error(...args)` - Erreur
+- `success(...args)` - Succès (alias pour info avec icône de succès)
+- `warning(...args)` - Avertissement (alias pour warn avec icône d'avertissement)
+
+## Exemples avancés
+
+### Combinaison de styles
+
+```javascript
+// Combinaison de styles
+logger.bold(logger.red('Texte en gras et rouge'));
+logger.bgBlue(logger.white('Texte blanc sur fond bleu'));
+```
+
+### Niveaux de log
+
+```javascript
+// Définir le niveau de log (par défaut: 'INFO')
+logger.setLogLevel('DEBUG');
+
+// Messages de log
+logger.debug('Message de débogage');
+logger.info('Information');
+logger.warn('Avertissement');
+logger.error('Erreur');
+```
+
+### Avec des objets et tableaux
+
+```javascript
+// Objets
+const user = {
+  name: 'John',
+  age: 30,
+  roles: ['admin', 'user'],
+};
+logger.info('Utilisateur:', user);
+
+// Tableaux
+const numbers = [1, 2, 3, 4, 5];
+logger.info('Nombres:', numbers);
+
+// Références circulaires
+const obj1 = { name: 'Objet 1' };
+const obj2 = { name: 'Objet 2', ref: obj1 };
+obj1.ref = obj2;
+logger.info('Objet avec référence circulaire:', obj1);
+```
+
+## Personnalisation
+
+### Styles personnalisés
+
+```javascript
+// Accès direct aux codes ANSI
+console.log(
+  `${logger.styles.bold}${logger.styles.red}Texte en gras et rouge${logger.styles.reset}`
+);
+```
+
+### Templates
+
+```javascript
+const name = 'Alice';
+const age = 30;
+logger.info('Nom: {0}, Âge: {1}', name, age);
+```
+
+## Contribution
+
+Les contributions sont les bienvenues ! N'hésitez pas à ouvrir une issue ou une pull request.
+
+## Licence
+
+MIT

package/README.md

@@ -1,148 +1,66 @@
-# LogColor
-
-Une bibliothèque JavaScript simple pour ajouter des couleurs et des styles aux messages de la console en Node.js.
-
-## Installation
-
-```bash
-npm install logcolor-js
-```
-
-## Utilisation
-
-### Avec ES Modules (recommandé)
-
-```javascript
-import logger from 'logcolor-js';
-
-// Couleurs de base
-logger.red('Ceci est en rouge');
-logger.green('Ceci est en vert');
-logger.blue('Ceci est en bleu');
-logger.yellow('Ceci est en jaune');
-```
-
-### Avec CommonJS
-
-```javascript
-const logger = require('logcolor-js');
-
-// Arrière-plans colorés
-logger.bgRed(' Fond rouge ');
-logger.bgGreen(' Fond vert ');
-logger.bgBlue(' Fond bleu ');
-```
-
-## Fonctionnalités
-
-### Couleurs de texte
-
-- `red(text)` - Texte rouge
-- `green(text)` - Texte vert
-- `blue(text)` - Texte bleu
-- `yellow(text)` - Texte jaune
-- `white(text)` - Texte blanc
-- `black(text)` - Texte noir
-- `magenta(text)` - Texte magenta
-- `cyan(text)` - Texte cyan
-
-### Arrière-plans
-
-- `bgRed(text)` - Fond rouge
-- `bgGreen(text)` - Fond vert
-- `bgBlue(text)` - Fond bleu
-- `bgYellow(text)` - Fond jaune
-- `bgWhite(text)` - Fond blanc
-- `bgBlack(text)` - Fond noir
-- `bgMagenta(text)` - Fond magenta
-- `bgCyan(text)` - Fond cyan
-
-### Styles de texte
-
-- `bold(text)` - Texte en gras
-- `underline(text)` - Texte souligné
-- `italic(text)` - Texte en italique
-- `inverse(text)` - Inverse les couleurs
-- `strikethrough(text)` - Texte barré
-
-### Niveaux de log
-
-- `setLogLevel(level)` - Définit le niveau de log ('DEBUG', 'INFO', 'WARN', 'ERROR')
-- `debug(...args)` - Message de débogage
-- `info(...args)` - Information
-- `warn(...args)` - Avertissement
-- `error(...args)` - Erreur
-- `success(...args)` - Succès (alias pour info avec icône de succès)
-- `warning(...args)` - Avertissement (alias pour warn avec icône d'avertissement)
-
-## Exemples avancés
-
-### Combinaison de styles
-
-```javascript
-// Combinaison de styles
-logger.bold(logger.red('Texte en gras et rouge'));
-logger.bgBlue(logger.white('Texte blanc sur fond bleu'));
-```
-
-### Niveaux de log
-
-```javascript
-// Définir le niveau de log (par défaut: 'INFO')
-logger.setLogLevel('DEBUG');
-
-// Messages de log
-logger.debug('Message de débogage');
-logger.info('Information');
-logger.warn('Avertissement');
-logger.error('Erreur');
-```
-
-### Avec des objets et tableaux
-
-```javascript
-// Objets
-const user = {
-  name: 'John',
-  age: 30,
-  roles: ['admin', 'user'],
-};
-logger.info('Utilisateur:', user);
-
-// Tableaux
-const numbers = [1, 2, 3, 4, 5];
-logger.info('Nombres:', numbers);
-
-// Références circulaires
-const obj1 = { name: 'Objet 1' };
-const obj2 = { name: 'Objet 2', ref: obj1 };
-obj1.ref = obj2;
-logger.info('Objet avec référence circulaire:', obj1);
-```
-
-## Personnalisation
-
-### Styles personnalisés
-
-```javascript
-// Accès direct aux codes ANSI
-console.log(
-  `${logger.styles.bold}${logger.styles.red}Texte en gras et rouge${logger.styles.reset}`
-);
-```
-
-### Templates
-
-```javascript
-const name = 'Alice';
-const age = 30;
-logger.info('Nom: {0}, Âge: {1}', name, age);
-```
-
-## Contribution
-
-Les contributions sont les bienvenues ! N'hésitez pas à ouvrir une issue ou une pull request.
-
-## Licence
-
-MIT
+# ChromaLogger
+
+[![npm version](https://img.shields.io/npm/v/chromalogger.svg?style=flat)](https://www.npmjs.com/package/chromalogger)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![GitHub stars](https://img.shields.io/github/stars/OrssiMp/chromalogger.svg?style=social)](https://github.com/OrssiMp/chromalogger/stargazers)
+
+[🇬🇧 English](README.md) | [🇫🇷 Français](README.fr.md)
+
+ChromaLogger is a powerful and flexible Node.js console logging library with advanced support for colors, styles, and debugging features. Perfect for Node.js application development and debugging.
+
+## 🚀 Features
+
+- 🌈 Rich color and style support (16+ colors, text formatting)
+- 📊 Built-in log levels (DEBUG, INFO, WARN, ERROR)
+- 🔄 Circular reference detection
+- 📝 Template string support
+- 🛠️ Customizable loggers
+- 💻 CLI tool included
+- 🔌 Extensible architecture
+
+## 📦 Installation
+
+```bash
+# With npm
+npm install chromalogger
+
+# Or with Yarn
+yarn add chromalogger
+```
+
+## 💡 Quick Start
+
+```javascript
+import { log, info, warn, error, createLogger } from 'chromalogger';
+
+// Basic usage
+log('This is a log message');
+info('Informational message');
+warn('Warning message');
+error('Error message');
+
+// With styles
+const success = createLogger('green', 'bold');
+success('Operation completed successfully!');
+
+// Template strings
+const user = { name: 'Alice', age: 30 };
+info('User {0} is {1} years old', user.name, user.age);
+```
+
+## 📚 Documentation
+
+For complete documentation, please visit our [GitHub Wiki](https://github.com/yourusername/chromalogger/wiki).
+
+## 🤝 Contributing
+
+Contributions are welcome! Please read our [Contributing Guide](CONTRIBUTING.md) to get started.
+
+## 📄 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## 🙏 Acknowledgments
+
+- Inspired by popular logging libraries like chalk, winston, and debug
+- Thanks to all contributors who have helped improve this project

package/core/formatters/objectFormatter.js

@@ -9,9 +9,10 @@ import { isObject } from '../utils/validate.js';
  * Format an object for display
  * @param {Object} obj - Object to format
  * @param {number} [depth=0] - Current depth for indentation
+ * @param {Set} [refs] - Set to track circular references
  * @returns {string} Formatted object string
  */
-export const formatObject = (obj, depth = 0) => {
+export const formatObject = (obj, depth = 0, refs = new WeakSet()) => {
   const indent = '  '.repeat(depth);
   const nextIndent = '  '.repeat(depth + 1);
 
@@ -20,24 +21,40 @@ export const formatObject = (obj, depth = 0) => {
     if (obj === undefined) return 'undefined';
     if (!isObject(obj)) return String(obj);
 
+    // Vérifier les références circulaires
+    if (refs.has(obj)) {
+      return '[Circular]';
+    }
+
+    // Marquer cet objet comme visité
+    refs.add(obj);
+
     const entries = Object.entries(obj);
     if (entries.length === 0) return '{}';
 
     // For small objects, keep on one line
     if (entries.every(([_, value]) => !isObject(value) || value === null)) {
       const content = entries
-        .map(([key, value]) => `${key}: ${formatValue(value, depth + 1)}`)
+        .map(([key, value]) => `${key}: ${formatValue(value, depth + 1, refs)}`)
         .join(', ');
       return `{ ${content} }`;
     }
 
     // For larger or complex objects, use multiple lines
     const content = entries
-      .map(([key, value]) => `${nextIndent}${key}: ${formatValue(value, depth + 1)}`)
+      .map(([key, value]) => `${nextIndent}${key}: ${formatValue(value, depth + 1, refs)}`)
       .join(',\n');
 
-    return `{\n${content}\n${indent}}`;
+    const result = `{\n${content}\n${indent}}`;
+
+    // Nettoyer les références après le formatage
+    refs.delete(obj);
+    return result;
   } catch (error) {
+    // En cas d'erreur, nettoyer les références
+    if (isObject(obj)) {
+      refs.delete(obj);
+    }
     return '[Object]';
   }
 };
@@ -46,9 +63,10 @@ export const formatObject = (obj, depth = 0) => {
  * Format a value for display
  * @param {*} value - Value to format
  * @param {number} [depth=0] - Current depth for indentation
+ * @param {Set} [refs] - Set to track circular references
  * @returns {string} Formatted value
  */
-const formatValue = (value, depth = 0) => {
+const formatValue = (value, depth = 0, refs = new WeakSet()) => {
   if (value === null) return 'null';
   if (value === undefined) return 'undefined';
 
@@ -57,9 +75,9 @@ const formatValue = (value, depth = 0) => {
       return `"${value}"`;
     case 'object':
       if (Array.isArray(value)) {
-        return formatArray(value, depth);
+        return formatArray(value, depth, refs);
       }
-      return formatObject(value, depth);
+      return formatObject(value, depth, refs);
     case 'function':
       return '[Function]';
     case 'symbol':
@@ -73,24 +91,37 @@ const formatValue = (value, depth = 0) => {
  * Format an array for display
  * @param {Array} arr - Array to format
  * @param {number} [depth=0] - Current depth for indentation
+ * @param {Set} [refs] - Set to track circular references
  * @returns {string} Formatted array string
  */
-const formatArray = (arr, depth = 0) => {
+const formatArray = (arr, depth = 0, refs = new WeakSet()) => {
   if (!Array.isArray(arr)) return '[]';
   if (arr.length === 0) return '[]';
 
+  // Vérifier les références circulaires pour les tableaux
+  if (refs.has(arr)) {
+    return '[Circular]';
+  }
+
+  // Marquer ce tableau comme visité
+  refs.add(arr);
+
   const indent = '  '.repeat(depth);
   const nextIndent = '  '.repeat(depth + 1);
 
   // For small arrays, keep on one line
   if (arr.length <= 3 && arr.every((item) => !isObject(item) || item === null)) {
-    return `[ ${arr.map((item) => formatValue(item, depth + 1)).join(', ')} ]`;
+    return `[ ${arr.map((item) => formatValue(item, depth + 1, refs)).join(', ')} ]`;
   }
 
   // For larger or complex arrays, use multiple lines
-  const items = arr.map((item) => `${nextIndent}${formatValue(item, depth + 1)}`).join(',\n');
+  const items = arr.map((item) => `${nextIndent}${formatValue(item, depth + 1, refs)}`).join(',\n');
+
+  const result = `[\n${items}\n${indent}]`;
 
-  return `[\n${items}\n${indent}]`;
+  // Nettoyer les références après le formatage
+  refs.delete(arr);
+  return result;
 };
 
 export default {