chromalogger 1.0.0

package/.eslintrc.json

@@ -0,0 +1,18 @@
+{
+  "env": {
+    "node": true,
+    "es2021": true,
+    "browser": true
+  },
+  "extends": ["eslint:recommended", "prettier"],
+  "parserOptions": {
+    "ecmaVersion": 2021,
+    "sourceType": "module"
+  },
+  "rules": {
+    "no-console": "off",
+    "no-unused-vars": ["warn", { "argsIgnorePattern": "^_" }],
+    "prettier/prettier": "error"
+  },
+  "plugins": ["prettier"]
+}

package/.prettierrc

@@ -0,0 +1,9 @@
+{
+  "semi": true,
+  "singleQuote": true,
+  "trailingComma": "es5",
+  "printWidth": 100,
+  "tabWidth": 2,
+  "bracketSpacing": true,
+  "arrowParens": "always"
+}

package/CONTRIBUTING.md

@@ -0,0 +1,43 @@
+# Comment contribuer
+
+Merci de votre intérêt pour `logcolor-js` ! Voici comment vous pouvez contribuer au projet.
+
+## Signaler un bug
+
+Si vous trouvez un bug, merci de créer une issue en suivant ces étapes :
+
+1. Vérifiez que le bug n'a pas déjà été signalé
+2. Décrivez le bug de manière claire et concise
+3. Incluez des étapes pour reproduire le bug
+4. Précisez le comportement attendu
+5. Incluez la version de Node.js et du module
+
+## Proposer une amélioration
+
+1. Créez une issue pour discuter de votre idée
+2. Si l'idée est acceptée, créez une branche pour votre fonctionnalité
+3. Assurez-vous que les tests passent (`npm test`)
+4. Soumettez une pull request
+
+## Processus de développement
+
+1. Forkez le dépôt
+2. Installez les dépendances : `npm install`
+3. Créez une branche pour votre fonctionnalité : `git checkout -b ma-nouvelle-fonctionnalite`
+4. Faites vos modifications
+5. Lancez les tests : `npm test`
+6. Formatez votre code : `npm run format`
+7. Vérifiez les erreurs de style : `npm run lint`
+8. Poussez vos modifications : `git push origin ma-nouvelle-fonctionnalite`
+9. Créez une Pull Request
+
+## Directives de codage
+
+- Suivez le style de code existant
+- Écrivez des tests pour les nouvelles fonctionnalités
+- Documentez votre code avec des commentaires clairs
+- Gardez les commits atomiques et bien décrits
+
+## Licence
+
+En contribuant à ce projet, vous acceptez que vos contributions soient sous la même licence que le projet (MIT).

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Votre Nom
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,148 @@
+# 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

package/chromalog.js

@@ -0,0 +1,77 @@
+/**
+ * Chromalog - A colorful console logger with formatting and styling
+ * @module chromalog
+ */
+
+// Import core modules
+import * as styles from './core/styles.js';
+
+// Import logger functions
+import {
+  createLogger,
+  formatMessage,
+  setLogLevel,
+  LOG_LEVELS,
+} from './core/loggers/consoleLogger.js';
+
+// Import formatters
+import { formatObject } from './core/formatters/objectFormatter.js';
+
+// Import chroma utility
+import chroma from './utils/chroma.js';
+
+// Create default logger instances
+const log = createLogger();
+const debug = createLogger('dim');
+const info = createLogger('blue');
+const warn = createLogger('yellow');
+const error = createLogger('red');
+
+// Main chromalog object
+const chromalog = {
+  // Core
+  styles,
+  chroma,
+
+  // Main logger methods
+  createLogger,
+  formatMessage,
+  formatObject,
+  setLogLevel,
+
+  // Log levels
+  LOG_LEVELS,
+
+  // Pre-configured loggers
+  log,
+  debug,
+  info,
+  warn,
+  error,
+};
+
+// Export everything
+export {
+  // Core
+  styles,
+  chroma,
+
+  // Main logger methods
+  createLogger,
+  formatMessage,
+  formatObject,
+  setLogLevel,
+
+  // Log levels
+  LOG_LEVELS,
+
+  // Pre-configured loggers
+  log,
+  debug,
+  info,
+  warn,
+  error,
+
+  // Default export
+  chromalog as default,
+};

package/cli.js

@@ -0,0 +1,87 @@
+#!/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

@@ -0,0 +1,100 @@
+/**
+ * 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
+ * @returns {string} Formatted object string
+ */
+export const formatObject = (obj, depth = 0) => {
+  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);
+
+    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)}`)
+        .join(', ');
+      return `{ ${content} }`;
+    }
+
+    // For larger or complex objects, use multiple lines
+    const content = entries
+      .map(([key, value]) => `${nextIndent}${key}: ${formatValue(value, depth + 1)}`)
+      .join(',\n');
+
+    return `{\n${content}\n${indent}}`;
+  } catch (error) {
+    return '[Object]';
+  }
+};
+
+/**
+ * Format a value for display
+ * @param {*} value - Value to format
+ * @param {number} [depth=0] - Current depth for indentation
+ * @returns {string} Formatted value
+ */
+const formatValue = (value, depth = 0) => {
+  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);
+      }
+      return formatObject(value, depth);
+    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
+ * @returns {string} Formatted array string
+ */
+const formatArray = (arr, depth = 0) => {
+  if (!Array.isArray(arr)) return '[]';
+  if (arr.length === 0) return '[]';
+
+  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(', ')} ]`;
+  }
+
+  // For larger or complex arrays, use multiple lines
+  const items = arr.map((item) => `${nextIndent}${formatValue(item, depth + 1)}`).join(',\n');
+
+  return `[\n${items}\n${indent}]`;
+};
+
+export default {
+  formatObject,
+  formatArray,
+  formatValue,
+};

package/core/loggers/consoleLogger.js

@@ -0,0 +1,153 @@
+/**
+ * Console logger implementation
+ * @module core/loggers/consoleLogger
+ */
+
+import { formatObject } from '../formatters/objectFormatter.js';
+import { validateInput } from '../utils/validate.js';
+import styles from '../styles.js';
+
+/**
+ * Log levels and their priorities
+ * @type {Object}
+ */
+const LOG_LEVELS = {
+  DEBUG: 0,
+  INFO: 1,
+  WARN: 2,
+  ERROR: 3,
+  NONE: 4,
+};
+
+let currentLogLevel = LOG_LEVELS.INFO;
+
+/**
+ * Create a logger with the specified styles
+ * @param {...string} styleNames - Names of styles to apply
+ * @returns {Function} Logger function
+ */
+const createLogger = (...styleNames) => {
+  // Get style codes
+  const styleCodes = styleNames.map((name) => {
+    if (!styles[name]) {
+      console.warn(`LogColor: Unknown style "${name}"`);
+      return '';
+    }
+    return styles[name];
+  });
+
+  const stylePrefix = styleCodes.join('');
+
+  /**
+   * Logger function
+   * @param {...*} args - Arguments to log
+   */
+  const logger = (...args) => {
+    try {
+      // Vérifier le niveau de log
+      let logLevel = LOG_LEVELS.INFO;
+      if (styleNames.includes('dim')) {
+        logLevel = LOG_LEVELS.DEBUG;
+      } else if (styleNames.includes('yellow')) {
+        logLevel = LOG_LEVELS.WARN;
+      } else if (styleNames.includes('red')) {
+        logLevel = LOG_LEVELS.ERROR;
+      }
+
+      if (logLevel < currentLogLevel) return;
+
+      const validArgs = validateInput(args);
+
+      // Handle template strings
+      if (typeof validArgs[0] === 'string' && validArgs.length > 1) {
+        const message = formatMessage(validArgs[0], validArgs.slice(1));
+        console.log(`${stylePrefix}${message}${styles.reset}`);
+      } else {
+        // Format each argument
+        const formattedArgs = validArgs.map((arg) => {
+          if (arg === null) return 'null';
+          if (arg === undefined) return 'undefined';
+          if (typeof arg === 'object' || Array.isArray(arg)) {
+            return formatObject(arg);
+          }
+          if (typeof arg === 'string') return arg;
+          return String(arg);
+        });
+
+        // Handle multi-line output
+        const output = formattedArgs.join(' ').split('\n').join('\n  ');
+        console.log(`${stylePrefix}${output}${styles.reset}`);
+      }
+    } catch (error) {
+      console.error(`${styles.red}LogColor: Logging error - ${error.message}${styles.reset}`);
+    }
+  };
+
+  // Add style methods for method chaining
+  Object.keys(styles).forEach((styleName) => {
+    Object.defineProperty(logger, styleName, {
+      get: () => createLogger(...styleNames, styleName),
+    });
+  });
+
+  return logger;
+};
+
+/**
+ * Format a message with placeholders
+ * @param {string} message - Message with {0}, {1}, etc. placeholders
+ * @param {Array} values - Values to replace placeholders
+ * @returns {string} Formatted message
+ */
+const formatMessage = (message, values = []) => {
+  if (typeof message !== 'string' || !Array.isArray(values)) {
+    return String(message);
+  }
+
+  return message.replace(/\{(\d+)\}/g, (match, index) => {
+    const value = values[parseInt(index, 10)];
+    if (value === undefined) return match;
+
+    if (typeof value === 'object' || Array.isArray(value)) {
+      return formatObject(value);
+    }
+
+    return String(value);
+  });
+};
+
+/**
+ * Set the current log level
+ * @param {string} level - Log level (DEBUG, INFO, WARN, ERROR, NONE)
+ */
+const setLogLevel = (level) => {
+  const upperLevel = level.toUpperCase();
+  if (LOG_LEVELS[upperLevel] !== undefined) {
+    currentLogLevel = LOG_LEVELS[upperLevel];
+  } else {
+    console.warn(`LogColor: Unknown log level "${level}". Using INFO.`);
+    currentLogLevel = LOG_LEVELS.INFO;
+  }
+};
+
+// Create default loggers
+const log = createLogger();
+const debug = createLogger('dim');
+const info = createLogger('cyan');
+const warn = createLogger('yellow');
+const error = createLogger('red');
+
+// Export everything
+export { createLogger, formatMessage, setLogLevel, log, debug, info, warn, error, LOG_LEVELS };
+
+export default {
+  createLogger,
+  formatMessage,
+  setLogLevel,
+  log,
+  debug,
+  info,
+  warn,
+  error,
+  LOG_LEVELS,
+};

package/core/styles.js

@@ -0,0 +1,75 @@
+/**
+ * ANSI escape codes for colors and styles
+ * @module core/styles
+ */
+
+export const styles = {
+  // Text colors
+  black: '\x1b[30m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  magenta: '\x1b[35m',
+  cyan: '\x1b[36m',
+  white: '\x1b[37m',
+  gray: '\x1b[90m',
+
+  // Background colors
+  bgBlack: '\x1b[40m',
+  bgRed: '\x1b[41m',
+  bgGreen: '\x1b[42m',
+  bgYellow: '\x1b[43m',
+  bgBlue: '\x1b[44m',
+  bgMagenta: '\x1b[45m',
+  bgCyan: '\x1b[46m',
+  bgWhite: '\x1b[47m',
+
+  // Text styles
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  dim: '\x1b[2m',
+  italic: '\x1b[3m',
+  underline: '\x1b[4m',
+  blink: '\x1b[5m',
+  reverse: '\x1b[7m',
+  hidden: '\x1b[8m',
+  strikethrough: '\x1b[9m',
+};
+
+// Aliases for common styles
+export const colors = {
+  // Text colors
+  black: styles.black,
+  red: styles.red,
+  green: styles.green,
+  yellow: styles.yellow,
+  blue: styles.blue,
+  magenta: styles.magenta,
+  cyan: styles.cyan,
+  white: styles.white,
+  gray: styles.gray,
+
+  // Background colors
+  bgBlack: styles.bgBlack,
+  bgRed: styles.bgRed,
+  bgGreen: styles.bgGreen,
+  bgYellow: styles.bgYellow,
+  bgBlue: styles.bgBlue,
+  bgMagenta: styles.bgMagenta,
+  bgCyan: styles.bgCyan,
+  bgWhite: styles.bgWhite,
+
+  // Styles
+  reset: styles.reset,
+  bold: styles.bright,
+  dim: styles.dim,
+  italic: styles.italic,
+  underline: styles.underline,
+  blink: styles.blink,
+  inverse: styles.reverse,
+  hidden: styles.hidden,
+  strikethrough: styles.strikethrough,
+};
+
+export default styles;

package/core/utils/validate.js

@@ -0,0 +1,42 @@
+/**
+ * Input validation utilities
+ * @module core/utils/validate
+ */
+
+/**
+ * Validate input arguments
+ * @param {Array} args - Arguments to validate
+ * @returns {Array} Validated arguments
+ * @throws {Error} If no arguments are provided
+ */
+export const validateInput = (args) => {
+  if (args.length === 0) {
+    throw new Error('No arguments provided');
+  }
+
+  return args;
+};
+
+/**
+ * Check if a value is an object (and not null/array)
+ * @param {*} value - Value to check
+ * @returns {boolean} True if the value is a non-null object and not an array
+ */
+export const isObject = (value) => {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+};
+
+/**
+ * Check if a value is a plain object
+ * @param {*} value - Value to check
+ * @returns {boolean} True if the value is a plain object
+ */
+export const isPlainObject = (value) => {
+  return isObject(value) && Object.prototype.toString.call(value) === '[object Object]';
+};
+
+export default {
+  validateInput,
+  isObject,
+  isPlainObject,
+};

package/index.js

@@ -0,0 +1,101 @@
+/**
+ * ChromaLog - A powerful console logger with rich formatting and styling
+ * @module chromalog
+ * @example
+ * // Importation de base
+ * import chromalog from './index.js';
+ *
+ * // Utilisation des loggers prédéfinis
+ * chromalog.info('Message informatif');
+ * chromalog.error('Erreur critique!');
+ *
+ * // Création d'un logger personnalisé
+ * const myLogger = chromalog.createLogger('green', 'underline');
+ * myLogger('Message personnalisé');
+ */
+
+// Import core modules
+import * as styles from './core/styles.js';
+import {
+  createLogger,
+  formatMessage,
+  setLogLevel,
+  LOG_LEVELS,
+} from './core/loggers/consoleLogger.js';
+import { formatObject } from './core/formatters/objectFormatter.js';
+
+/**
+ * Logger de base sans style particulier
+ * @type {Function}
+ */
+const log = createLogger();
+
+/**
+ * Logger pour les messages de débogage (style atténué)
+ * @type {Function}
+ */
+const debug = createLogger('dim');
+
+/**
+ * Logger pour les messages informatifs (style cyan)
+ * @type {Function}
+ */
+const info = createLogger('cyan');
+
+/**
+ * Logger pour les avertissements (style jaune)
+ * @type {Function}
+ */
+const warn = createLogger('yellow');
+
+/**
+ * Logger pour les erreurs (style rouge)
+ * @type {Function}
+ */
+const error = createLogger('red');
+
+// Export par défaut avec toutes les fonctionnalités
+const ChromaLog = {
+  // Core
+  styles,
+
+  // Main logger methods
+  createLogger,
+  formatMessage,
+  formatObject,
+  setLogLevel,
+
+  // Log levels
+  LOG_LEVELS,
+
+  // Pre-configured loggers
+  log,
+  debug,
+  info,
+  warn,
+  error,
+};
+
+export default ChromaLog;
+
+// Export nommé pour l'import déstructuré
+export {
+  // Core
+  styles,
+
+  // Main logger methods
+  createLogger,
+  formatMessage,
+  formatObject,
+  setLogLevel,
+
+  // Log levels
+  LOG_LEVELS,
+
+  // Pre-configured loggers
+  log,
+  debug,
+  info,
+  warn,
+  error,
+};

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "chromalogger",
+  "version": "1.0.0",
+  "description": "A colorful and flexible console logger for Node.js with CLI support",
+  "main": "chromalog.js",
+  "type": "module",
+  "bin": {
+    "clog": "./cli.js"
+  },
+  "scripts": {
+    "test": "node test.js",
+    "test:watch": "nodemon --watch chromalog.js --watch test.js --exec \"npm test\"",
+    "lint": "eslint .",
+    "test:chroma": "node chromatest.js",
+    "test:cli": "node clitest.js",
+    "test:all": "npm run test && npm run test:chroma && npm run test:cli",
+    "format": "prettier --write .",
+    "fix": "eslint --fix .",
+    "coverage": "c8 npm test"
+  },
+  "keywords": [
+    "log",
+    "color",
+    "console",
+    "logger",
+    "chroma",
+    "clog",
+    "nodejs",
+    "browser",
+    "ansi",
+    "terminal",
+    "styling",
+    "formatting"
+  ],
+  "author": {
+    "name": "Orssi Mp",
+    "email": "votre@email.com",
+    "url": "https://github.com/votrepseudo"
+  },
+  "license": "MIT",
+  "homepage": "https://github.com/votre-utilisateur/logcolor-js#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/votre-utilisateur/logcolor-js.git"
+  },
+  "bugs": {
+    "url": "https://github.com/votre-utilisateur/logcolor-js/issues"
+  },
+  "engines": {
+    "node": ">=12.0.0"
+  },
+  "devDependencies": {
+    "c8": "^10.1.3",
+    "eslint": "^8.0.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.4",
+    "nodemon": "^3.1.11",
+    "prettier": "^3.7.3"
+  }
+}

package/test.js

@@ -0,0 +1,130 @@
+/**
+ * Test de la bibliothèque LogColor
+ * Ce fichier démontre les différentes fonctionnalités de LogColor
+ */
+
+// Import du module principal Chromalog
+import chromalog from './index.js';
+
+// Alias pour les propriétés
+const { createLogger, setLogLevel, log, debug, info, warn, error } = chromalog;
+
+// ========================================
+// 1. Test des styles de base
+// ========================================
+const title = createLogger('bright');
+const redText = createLogger('red');
+const greenText = createLogger('green');
+const blueText = createLogger('blue');
+const highlightText = createLogger('black', 'bgYellow');
+const bold = createLogger('bright');
+const underlineText = createLogger('underline');
+
+console.log();
+title('=== 1. Test des styles de base ===');
+redText('Texte en rouge');
+greenText('Texte en vert');
+blueText('Texte en bleu');
+highlightText('Texte noir sur fond jaune');
+bold('Texte en gras');
+underlineText('Texte souligné');
+
+// ========================================
+// 2. Test des loggers prédéfinis
+// ========================================
+console.log('\n=== 2. Test des loggers prédéfinis ===');
+log('Message de log standard');
+debug('Message de débogage');
+info("Message d'information");
+warn("Message d'avertissement");
+error("Message d'erreur");
+
+// ========================================
+// 3. Test du formatage d'objets
+// ========================================
+console.log("\n=== 3. Test du formatage d'objets ===");
+const utilisateur = {
+  id: 1,
+  nom: 'Dupont',
+  prenom: 'Jean',
+  email: 'jean.dupont@example.com',
+  actif: true,
+  roles: ['admin', 'utilisateur'],
+  preferences: {
+    theme: 'sombre',
+    notifications: true,
+    langue: 'fr',
+  },
+};
+
+info('Utilisateur:', utilisateur);
+
+// ========================================
+// 4. Test des templates
+// ========================================
+console.log('\n=== 4. Test des templates ===');
+const nom = 'Alice';
+const age = 31;
+info('Bonjour {0}, vous avez {1} ans', nom, age);
+
+// ========================================
+// 5. Test des niveaux de log
+// ========================================
+console.log('\n=== 5. Test des niveaux de log ===');
+console.log('Niveau de log actuel: DEBUG');
+setLogLevel('DEBUG');
+debug("Ce message de débogage devrait s'afficher");
+
+console.log('\nChangement du niveau de log à WARN');
+setLogLevel('WARN');
+debug("Ce message de débogage ne devrait PAS s'afficher");
+info("Ce message d'information ne devrait PAS s'afficher");
+warn("Ce message d'avertissement devrait s'afficher");
+error("Ce message d'erreur devrait s'afficher");
+
+// ========================================
+// 6. Test des styles personnalisés
+// ========================================
+const customTitle = createLogger('bright');
+const success = createLogger('green', 'bright');
+const important = createLogger('yellow', 'bgRed', 'bright');
+const highlight = createLogger('black', 'bgYellow', 'bright');
+
+console.log();
+customTitle('=== 6. Test des styles personnalisés ===');
+success('Opération réussie !');
+important('Ceci est un message important !');
+
+// ========================================
+// 7. Test des chaînages de styles
+// ========================================
+const styledText = createLogger('red', 'bright', 'underline');
+styledText('Ce texte est en rouge, en gras et souligné');
+
+// ========================================
+// 8. Test avec des tableaux
+// ========================================
+const sectionTitle = createLogger('bright');
+const cyanText = createLogger('cyan');
+
+console.log();
+sectionTitle('=== 8. Test avec des tableaux ===');
+console.log();
+cyanText('Tableau de nombres:');
+console.log(JSON.stringify([1, 2, 3, 4, 5], null, 2));
+
+console.log();
+cyanText('Liste des utilisateurs:');
+console.log(
+  JSON.stringify(
+    [
+      { id: 1, nom: 'Alice' },
+      { id: 2, nom: 'Bob' },
+      { id: 3, nom: 'Charlie' },
+    ],
+    null,
+    2
+  )
+);
+
+console.log('\n=== Fin des tests ===');

package/utils/chroma.js

@@ -0,0 +1,42 @@
+/**
+ * Fonction utilitaire pour afficher du texte avec style
+ * @module utils/chroma
+ * @example
+ * import chroma from './utils/chroma.js';
+ * chroma('Texte en rouge et gras', 'red', 'bright');
+ */
+
+import { styles } from '../core/styles.js';
+
+/**
+ * Affiche du texte formaté dans la console avec des styles
+ * @param {string} text - Le texte à afficher
+ * @param {...string} styleNames - Noms des styles à appliquer
+ * @returns {void}
+ */
+const chroma = (text, ...styleNames) => {
+  const styleCodes = styleNames
+    .flatMap((style) => style.split(','))
+    .map((style) => style.trim())
+    .filter(Boolean)
+    .map((name) => {
+      // Vérifier si le style existe directement
+      if (styles[name] !== undefined) {
+        return styles[name];
+      }
+
+      // Gestion des couleurs de fond (ex: 'bgRed')
+      if (name.startsWith('bg')) {
+        const bgColor = name.substring(2);
+        const bgKey = `bg${bgColor.charAt(0).toUpperCase() + bgColor.slice(1)}`;
+        return styles[bgKey] || '';
+      }
+
+      return '';
+    })
+    .join('');
+
+  process.stdout.write(`${styleCodes}${text}${styles.reset}\n`);
+};
+
+export default chroma;