chromalogger 1.1.1 → 1.1.2

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 {

package/core/loggers/consoleLogger.js

@@ -3,9 +3,9 @@
  * @module core/loggers/consoleLogger
  */
 
-import { formatObject } from '../formatters/objectFormatter.js';
 import { validateInput } from '../utils/validate.js';
 import styles from '../styles.js';
+import util from 'util';
 
 /**
  * Log levels and their priorities
@@ -44,6 +44,9 @@ const createLogger = (...styleNames) => {
    */
   const logger = (...args) => {
     try {
+      console.log('\n=== DEBUG: Début de la fonction logger ===');
+      console.log('Arguments reçus:', args);
+
       // Vérifier le niveau de log
       let logLevel = LOG_LEVELS.INFO;
       if (styleNames.includes('dim')) {
@@ -54,30 +57,57 @@ const createLogger = (...styleNames) => {
         logLevel = LOG_LEVELS.ERROR;
       }
 
+      console.log('Niveau de log actuel:', currentLogLevel, 'Niveau requis:', logLevel);
+
       if (logLevel < currentLogLevel) return;
 
-      const validArgs = validateInput(args);
+      // Si pas d'arguments, afficher une ligne vide
+      if (args.length === 0) {
+        console.log();
+        return;
+      }
+
+      // Préparer le message final
+      let output = '';
 
-      // 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}`);
+      // Si le premier argument est une chaîne et qu'il y a plus d'un argument,
+      // traiter comme un template string
+      if (typeof args[0] === 'string' && args.length > 1) {
+        const message = args[0];
+        const values = args.slice(1);
+        output = formatMessage(message, values);
       } 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);
+        // Sinon, formater chaque argument individuellement
+        const formattedArgs = args.map((arg) => {
+          try {
+            if (arg === null) return 'null';
+            if (arg === undefined) return 'undefined';
+            if (typeof arg === 'object' || Array.isArray(arg)) {
+              return util.inspect(arg, {
+                showHidden: false,
+                depth: 6,
+                colors: false,
+                maxArrayLength: 10,
+                breakLength: 80,
+                compact: 3,
+                sorted: false,
+                getters: false,
+                showProxy: false,
+                customInspect: true,
+              });
+            }
+            return String(arg);
+          } catch (e) {
+            return `[Error: ${e.message}]`;
           }
-          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}`);
+        output = formattedArgs.join(' ');
       }
+
+      // Afficher le message formaté avec les styles
+      const finalOutput = stylePrefix + output + styles.reset;
+      console.log('=== DEBUG: Sortie finale ===\n', finalOutput, '\n======================');
+      console.log(finalOutput);
     } catch (error) {
       console.error(`${styles.red}LogColor: Logging error - ${error.message}${styles.reset}`);
     }
@@ -100,20 +130,55 @@ const createLogger = (...styleNames) => {
  * @returns {string} Formatted message
  */
 const formatMessage = (message, values = []) => {
-  if (typeof message !== 'string' || !Array.isArray(values)) {
-    return String(message);
+  if (typeof message !== 'string') {
+    return '';
   }
 
-  return message.replace(/\{(\d+)\}/g, (match, index) => {
+  if (!Array.isArray(values) || values.length === 0) {
+    // Remplacer les doubles accolades échappées par des marqueurs temporaires
+    return message.replace(/\{\{/g, '\uE000').replace(/\}\}/g, '\uE001')
+      .replace(/\{\d+\}/g, match => match) // Laisser les placeholders tels quels
+      .replace(/\uE000/g, '{').replace(/\uE001/g, '}');
+  }
+
+  // Si le message ne contient pas de placeholders, ajouter les valeurs à la suite
+  if (!/\{\d+\}/.test(message)) {
+    return `${message} ${values
+      .map((v) => (typeof v === 'object' ? JSON.stringify(v) : String(v)))
+      .join(' ')}`.trim();
+  }
+
+  // Remplacer d'abord les doubles accolades échappées par des marqueurs temporaires
+  const tempMessage = message.replace(/\{\{/g, '\uE000').replace(/\}\}/g, '\uE001');
+  
+  // Remplacer les placeholders
+  const formatted = tempMessage.replace(/\{(\d+)\}/g, (match, index) => {
     const value = values[parseInt(index, 10)];
-    if (value === undefined) return match;
+    if (value === undefined || value === null) {
+      return match;
+    }
 
+    // Utiliser util.inspect pour les objets et tableaux
     if (typeof value === 'object' || Array.isArray(value)) {
-      return formatObject(value);
+      return util.inspect(value, {
+        showHidden: false,
+        depth: 6,
+        colors: false,
+        maxArrayLength: 10,
+        breakLength: 80,
+        compact: 3,
+        sorted: false,
+        getters: false,
+        showProxy: false,
+        customInspect: true,
+      });
     }
 
     return String(value);
   });
+  
+  // Remplacer les marqueurs temporaires par des accolades simples
+  return formatted.replace(/\uE000/g, '{').replace(/\uE001/g, '}');
 };
 
 /**

package/core/utils/validate.js

@@ -10,11 +10,14 @@
  * @throws {Error} If no arguments are provided
  */
 export const validateInput = (args) => {
-  if (args.length === 0) {
-    throw new Error('No arguments provided');
+  if (!args || args.length === 0) {
+    return [];
   }
 
-  return args;
+  // Convertir les arguments en tableau s'ils ne le sont pas déjà
+  const argsArray = Array.isArray(args) ? args : Array.from(args);
+
+  return argsArray;
 };
 
 /**

package/index.js

@@ -24,78 +24,38 @@ import {
 } from './core/loggers/consoleLogger.js';
 import { formatObject } from './core/formatters/objectFormatter.js';
 
-/**
- * Logger de base sans style particulier
- * @type {Function}
- */
+// Créer les loggers avec leurs styles respectifs
 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');
+const error = createLogger('red');
 
 /**
- * Logger pour les erreurs (style rouge)
- * @type {Function}
+ * ChromaLog - A powerful console logger with rich formatting and styling
  */
-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,
+  LOG_LEVELS: { ...LOG_LEVELS },
+
+  // Loggers
+  log: (...args) => log(...args),
+  debug: (...args) => debug(...args),
+  info: (...args) => info(...args),
+  warn: (...args) => warn(...args),
+  error: (...args) => error(...args),
 };
 
-export default ChromaLog;
+// Exporter les loggers individuellement
+export { log, debug, info, warn, error };
 
-// Export nommé pour l'import déstructuré
-export {
-  // Core
-  styles,
+// Exporter les fonctions utilitaires
+export { styles, createLogger, formatMessage, formatObject, setLogLevel, LOG_LEVELS };
 
-  // Main logger methods
-  createLogger,
-  formatMessage,
-  formatObject,
-  setLogLevel,
-
-  // Log levels
-  LOG_LEVELS,
-
-  // Pre-configured loggers
-  log,
-  debug,
-  info,
-  warn,
-  error,
-};
+// Exporter par défaut l'objet ChromaLog
+export default ChromaLog;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chromalogger",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "description": "A colorful and flexible console logger for Node.js with CLI support",
   "main": "chromalog.js",
   "type": "module",
@@ -49,6 +49,9 @@
   "engines": {
     "node": ">=12.0.0"
   },
+  "dependencies": {
+    "util": "^0.12.5"
+  },
   "devDependencies": {
     "c8": "^10.1.3",
     "eslint": "^8.0.0",

package/test.js

@@ -4,10 +4,7 @@
  */
 
 // 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;
+import { createLogger, setLogLevel, log, debug, info, warn, error } from './index.js';
 
 // ========================================
 // 1. Test des styles de base
@@ -65,7 +62,7 @@ info('Utilisateur:', utilisateur);
 console.log('\n=== 4. Test des templates ===');
 const nom = 'Alice';
 const age = 31;
-info('Bonjour {0}, vous avez {1} ans', nom, age);
+info('Bonjour {0}, vous avez {1} ans de {{nom et age}}', nom, age);
 
 // ========================================
 // 5. Test des niveaux de log
@@ -127,4 +124,36 @@ console.log(
   )
 );
 
+// Références circulaires
+console.log('\n=== 6. Test des références circulaires ===');
+const obj1 = { name: 'Objet 1' };
+const obj2 = { name: 'Objet 2', ref: obj1 };
+obj1.ref = obj2;
+
+// Afficher directement l'objet pour le débogage
+console.log('Obj1:', obj1);
+console.log('Obj2:', obj2);
+
+// Afficher avec le logger personnalisé
+console.log('\n=== Test du logger personnalisé ===');
+console.log('Type de log:', typeof log);
+console.log('log est une fonction ?:', typeof log === 'function');
+
+// Définir le niveau de log sur DEBUG pour voir tous les messages
+setLogLevel('DEBUG');
+console.log('Niveau de log défini sur DEBUG');
+
+// Tester avec un simple message
+console.log('\nTest avec un message simple:');
+log('Ceci est un test simple');
+
+// Tester avec un objet simple
+console.log('\nTest avec un objet simple:');
+log({ test: 'objet simple' });
+
+// Tester avec les objets circulaires
+log('\nTest avec les objets circulaires:');
+log('obj1:', obj1);
+log('obj2:', obj2);
+
 console.log('\n=== Fin des tests ===');