chromalogger 1.1.2 → 1.2.0

package/README.fr.md

@@ -1,360 +0,0 @@
-# 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/cli.js

@@ -1,87 +0,0 @@
-#!/usr/bin/env node
-
-console.log('Démarrage du CLI...'); // Debug
-
-import { createLogger } from './chromalog.js';
-import fs from 'fs';
-import { fileURLToPath } from 'url';
-import path from 'path';
-
-console.log('Chargement des modules terminé'); // Debug
-
-function showHelp() {
-  const helpText = `
-  Utilisation : clog [options] <message>
-
-  Options :
-    --color <couleur>   Couleur du texte (red, green, blue, etc.)
-    --style <styles>    Styles (séparés par des virgules)
-    -v, --version       Affiche la version
-    -h, --help          Affiche cette aide
-
-  Exemples :
-    $ npx clog --color red --style bright "Attention !"
-    $ npx clog --color green "Opération réussie"
-  `;
-  console.log(helpText);
-}
-
-function main() {
-  console.log('Début de la fonction main'); // Debug
-  const args = process.argv.slice(2);
-  console.log('Arguments:', args); // Debug
-
-  // Afficher l'aide
-  if (args.length === 0 || args.includes('--help') || args.includes('-h') || args.includes('-V')) {
-    return showHelp();
-  }
-
-  // Afficher la version
-  if (args.includes('--version') || args.includes('-v')) {
-    const __filename = fileURLToPath(import.meta.url);
-    const __dirname = path.dirname(__filename);
-    const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, 'package.json'), 'utf8'));
-    return console.log(pkg.version);
-  }
-
-  // Traitement des arguments de couleur et de style
-  let messageParts = [];
-  let color = 'white';
-  let styles = [];
-
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i];
-
-    if (arg === '--color' && args[i + 1]) {
-      color = args[++i];
-    } else if (arg === '--style' && args[i + 1]) {
-      styles = args[++i].split(',').map((s) => s.trim());
-    } else if (!arg.startsWith('--')) {
-      messageParts.push(arg);
-    }
-  }
-
-  const message = messageParts.join(' ');
-
-  if (!message) {
-    console.error('Erreur: Aucun message fourni');
-    return showHelp();
-  }
-
-  try {
-    // Créer et utiliser le logger
-    const logger = createLogger(color, ...styles);
-    logger(message);
-  } catch (error) {
-    console.error('Erreur:', error.message);
-    console.log('\nCouleurs disponibles: red, green, blue, yellow, magenta, cyan, white');
-    console.log(
-      'Styles disponibles: bright, dim, italic, underline, blink, reverse, hidden, strikethrough'
-    );
-  }
-}
-
-// Exécuter le CLI
-if (process.argv[1] && process.argv[1].endsWith('cli.js')) {
-  main();
-}

package/core/formatters/objectFormatter.js

@@ -1,131 +0,0 @@
-/**
- * Object formatting utilities
- * @module core/formatters/objectFormatter
- */
-
-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, refs = new WeakSet()) => {
-  const indent = '  '.repeat(depth);
-  const nextIndent = '  '.repeat(depth + 1);
-
-  try {
-    if (obj === null) return 'null';
-    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, refs)}`)
-        .join(', ');
-      return `{ ${content} }`;
-    }
-
-    // For larger or complex objects, use multiple lines
-    const content = entries
-      .map(([key, value]) => `${nextIndent}${key}: ${formatValue(value, depth + 1, refs)}`)
-      .join(',\n');
-
-    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]';
-  }
-};
-
-/**
- * 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, refs = new WeakSet()) => {
-  if (value === null) return 'null';
-  if (value === undefined) return 'undefined';
-
-  switch (typeof value) {
-    case 'string':
-      return `"${value}"`;
-    case 'object':
-      if (Array.isArray(value)) {
-        return formatArray(value, depth, refs);
-      }
-      return formatObject(value, depth, refs);
-    case 'function':
-      return '[Function]';
-    case 'symbol':
-      return value.toString();
-    default:
-      return String(value);
-  }
-};
-
-/**
- * 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, 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, refs)).join(', ')} ]`;
-  }
-
-  // For larger or complex arrays, use multiple lines
-  const items = arr.map((item) => `${nextIndent}${formatValue(item, depth + 1, refs)}`).join(',\n');
-
-  const result = `[\n${items}\n${indent}]`;
-
-  // Nettoyer les références après le formatage
-  refs.delete(arr);
-  return result;
-};
-
-export default {
-  formatObject,
-  formatArray,
-  formatValue,
-};