@adaas/a-utils 0.1.18 → 0.1.20

package/src/lib/A-Logger/A-Logger.component.ts

@@ -8,7 +8,8 @@ import {
     A_LOGGER_ANSI,
     A_LOGGER_TIME_FORMAT,
     A_LOGGER_FORMAT,
-    A_LOGGER_ENV_KEYS
+    A_LOGGER_ENV_KEYS,
+    A_LOGGER_SAFE_RANDOM_COLORS
 } from "./A-Logger.constants";
 
 /**
@@ -32,21 +33,33 @@ import {
  * 
  * @example
  * ```typescript
- * // Basic usage with dependency injection
+ * // Basic usage with dependency injection (uses deterministic colors based on scope name)
  * class MyService {
  *   constructor(@A_Inject(A_Logger) private logger: A_Logger) {}
  *   
  *   doSomething() {
- *     this.logger.log('Processing started');
- *     this.logger.log('blue', 'Custom color message');
+ *     this.logger.info('Processing started'); // Uses scope-name-based colors, always shows
+ *     this.logger.debug('Debug information'); // Only shows when debug level enabled
+ *     this.logger.info('green', 'Custom message color'); // Green message, scope stays default
  *     this.logger.warning('Something might be wrong');
  *     this.logger.error(new Error('Something failed'));
  *   }
  * }
  * 
- * // Advanced usage with objects
- * logger.log('green', 'User data:', { id: 1, name: 'John' });
- * logger.error(new A_Error('VALIDATION_FAILED', 'Invalid input data'));
+ * // Same scope names will always get the same colors automatically
+ * const logger1 = new A_Logger(new A_Scope({name: 'UserService'})); // Gets consistent colors
+ * const logger2 = new A_Logger(new A_Scope({name: 'UserService'})); // Gets same colors as logger1
+ * 
+ * // Configuration via environment variables or A_Config (overrides automatic selection)
+ * process.env.A_LOGGER_DEFAULT_SCOPE_COLOR = 'magenta';
+ * process.env.A_LOGGER_DEFAULT_LOG_COLOR = 'green';
+ * 
+ * // Or through A_Config instance
+ * const config = new A_Config({
+ *   A_LOGGER_DEFAULT_SCOPE_COLOR: 'red',
+ *   A_LOGGER_DEFAULT_LOG_COLOR: 'white'
+ * });
+ * const logger = new A_Logger(scope, config);
  * ```
  */
 export class A_Logger extends A_Component {
@@ -67,25 +80,122 @@ export class A_Logger extends A_Component {
      */
     private readonly STANDARD_SCOPE_LENGTH;
 
+    /**
+     * Default color for the scope portion of log messages
+     * This color is used for the scope brackets and content, and remains consistent
+     * for this logger instance regardless of message color overrides
+     */
+    private readonly DEFAULT_SCOPE_COLOR: keyof typeof A_LOGGER_COLORS;
+
+    /**
+     * Default color for log message content when no explicit color is provided
+     * This color is used for the message body when logging without specifying a color
+     */
+    private readonly DEFAULT_LOG_COLOR: keyof typeof A_LOGGER_COLORS;
+
     // =============================================
     // Constructor and Initialization
     // =============================================
 
     /**
      * Initialize A_Logger with dependency injection
+     * Colors are configured through A_Config or generated randomly if not provided
      * 
      * @param scope - The current scope context for message prefixing
-     * @param config - Optional configuration for log level filtering
+     * @param config - Optional configuration for log level filtering and color settings
      */
     constructor(
         @A_Inject(A_Scope) protected scope: A_Scope,
-        @A_Inject(A_Config) protected config?: A_Config<A_LoggerEnvVariablesType>,
+        @A_Inject(A_Config) protected config?: A_Config<A_LoggerEnvVariablesType>
     ) {
         super();
         this.COLORS = A_LOGGER_COLORS;
-        this.STANDARD_SCOPE_LENGTH = config?.get('A_LOGGER_DEFAULT_SCOPE_LENGTH') || A_LOGGER_DEFAULT_SCOPE_LENGTH;
+        this.STANDARD_SCOPE_LENGTH = config?.get(A_LOGGER_ENV_KEYS.DEFAULT_SCOPE_LENGTH) || A_LOGGER_DEFAULT_SCOPE_LENGTH;
+        
+        // Get colors from config or generate deterministic colors based on scope name
+        const configScopeColor = config?.get(A_LOGGER_ENV_KEYS.DEFAULT_SCOPE_COLOR) as keyof typeof A_LOGGER_COLORS;
+        const configLogColor = config?.get(A_LOGGER_ENV_KEYS.DEFAULT_LOG_COLOR) as keyof typeof A_LOGGER_COLORS;
+        
+        if (configScopeColor || configLogColor) {
+            // If any color is configured, use config values or fallback to scope-based selection
+            this.DEFAULT_SCOPE_COLOR = configScopeColor || this.generateColorFromScopeName(this.scope.name);
+            this.DEFAULT_LOG_COLOR = configLogColor || this.generateColorFromScopeName(this.scope.name );
+        } else {
+            // If no colors configured, generate complementary pair based on scope name
+            const complementaryColors = this.generateComplementaryColorsFromScope(this.scope.name);
+            this.DEFAULT_SCOPE_COLOR = complementaryColors.scopeColor;
+            this.DEFAULT_LOG_COLOR = complementaryColors.logColor;
+        }
     }
 
+    // =============================================
+    // Color Generation Utilities
+    // =============================================
+
+    /**
+     * Generate a simple hash from a string
+     * Used to create deterministic color selection based on scope name
+     * 
+     * @param str - The string to hash
+     * @returns A numeric hash value
+     */
+    private simpleHash(str: string): number {
+        let hash = 0;
+        for (let i = 0; i < str.length; i++) {
+            const char = str.charCodeAt(i);
+            hash = ((hash << 5) - hash) + char;
+            hash = hash & hash; // Convert to 32-bit integer
+        }
+        return Math.abs(hash);
+    }
+
+    /**
+     * Generate a deterministic color based on scope name
+     * Same scope names will always get the same color, but uses safe color palette
+     * 
+     * @param scopeName - The scope name to generate color for
+     * @returns A color key from the safe colors palette
+     */
+    private generateColorFromScopeName(scopeName: string): keyof typeof A_LOGGER_COLORS {
+        const safeColors = A_LOGGER_SAFE_RANDOM_COLORS;
+        const hash = this.simpleHash(scopeName);
+        const colorIndex = hash % safeColors.length;
+        return safeColors[colorIndex];
+    }
+
+    /**
+     * Generate a pair of complementary colors based on scope name
+     * Ensures visual harmony between scope and message colors while being deterministic
+     * 
+     * @param scopeName - The scope name to base colors on
+     * @returns Object with scopeColor and logColor that work well together
+     */
+    private generateComplementaryColorsFromScope(scopeName: string): { scopeColor: keyof typeof A_LOGGER_COLORS, logColor: keyof typeof A_LOGGER_COLORS } {
+        // Define color groups that work well together
+        const colorPairs = [
+            { scopeColor: 'indigo' as const, logColor: 'lightBlue' as const },
+            { scopeColor: 'deepBlue' as const, logColor: 'cyan' as const },
+            { scopeColor: 'purple' as const, logColor: 'lavender' as const },
+            { scopeColor: 'steelBlue' as const, logColor: 'skyBlue' as const },
+            { scopeColor: 'slateBlue' as const, logColor: 'periwinkle' as const },
+            { scopeColor: 'charcoal' as const, logColor: 'silver' as const },
+            { scopeColor: 'violet' as const, logColor: 'brightMagenta' as const },
+            { scopeColor: 'darkGray' as const, logColor: 'lightGray' as const },
+            { scopeColor: 'cornflower' as const, logColor: 'powder' as const },
+            { scopeColor: 'slate' as const, logColor: 'smoke' as const },
+        ];
+        
+        const hash = this.simpleHash(scopeName);
+        const pairIndex = hash % colorPairs.length;
+        return colorPairs[pairIndex];
+    }
+
+    // =============================================
+    // Factory Methods
+    // =============================================
+
+
+
     // =============================================
     // Scope and Formatting Utilities
     // =============================================
@@ -101,13 +211,26 @@ export class A_Logger extends A_Component {
     }
 
     /**
-     * Get the formatted scope name with proper padding
-     * Ensures consistent width for all scope names in log output
+     * Get the formatted scope name with proper padding, centered within the container
+     * Ensures consistent width for all scope names in log output with centered alignment
      * 
-     * @returns Padded scope name for consistent formatting
+     * @returns Centered and padded scope name for consistent formatting
      */
     get formattedScope(): string {
-        return this.scope.name.padEnd(this.STANDARD_SCOPE_LENGTH);
+        const scopeName = this.scope.name;
+        const totalLength = this.STANDARD_SCOPE_LENGTH;
+        
+        // If scope name is longer than standard length, truncate it
+        if (scopeName.length >= totalLength) {
+            return scopeName.substring(0, totalLength);
+        }
+        
+        // Calculate padding for centering
+        const totalPadding = totalLength - scopeName.length;
+        const leftPadding = Math.floor(totalPadding / 2);
+        const rightPadding = totalPadding - leftPadding;
+        
+        return ' '.repeat(leftPadding) + scopeName + ' '.repeat(rightPadding);
     }
 
 
@@ -119,17 +242,17 @@ export class A_Logger extends A_Component {
      * Compile log arguments into formatted console output with colors and proper alignment
      * 
      * This method handles the core formatting logic for all log messages:
-     * - Applies terminal color codes for visual distinction
+     * - Applies separate colors for scope and message content
      * - Formats scope names with consistent padding
      * - Handles different data types appropriately
      * - Maintains proper indentation for multi-line content
      * 
-     * @param color - The color key to apply to the message
+     * @param messageColor - The color key to apply to the message content
      * @param args - Variable arguments to format and display
      * @returns Array of formatted strings ready for console output
      */
     compile(
-        color: keyof typeof this.COLORS,
+        messageColor: keyof typeof this.COLORS,
         ...args: any[]
     ): Array<string> {
         const timeString = this.getTime();
@@ -137,8 +260,8 @@ export class A_Logger extends A_Component {
         const isMultiArg = args.length > 1;
 
         return [
-            // Header with color, scope, and timestamp
-            `${A_LOGGER_ANSI.PREFIX}${this.COLORS[color]}${A_LOGGER_ANSI.SUFFIX}${A_LOGGER_FORMAT.SCOPE_OPEN}${this.formattedScope}${A_LOGGER_FORMAT.SCOPE_CLOSE} ${A_LOGGER_FORMAT.TIME_OPEN}${timeString}${A_LOGGER_FORMAT.TIME_CLOSE}`,
+            // Header with separate colors for scope and message content
+            `${A_LOGGER_ANSI.PREFIX}${this.COLORS[this.DEFAULT_SCOPE_COLOR]}${A_LOGGER_ANSI.SUFFIX}${A_LOGGER_FORMAT.SCOPE_OPEN}${this.formattedScope}${A_LOGGER_FORMAT.SCOPE_CLOSE}${A_LOGGER_ANSI.RESET} ${A_LOGGER_ANSI.PREFIX}${this.COLORS[messageColor]}${A_LOGGER_ANSI.SUFFIX}${A_LOGGER_FORMAT.TIME_OPEN}${timeString}${A_LOGGER_FORMAT.TIME_CLOSE}`,
 
             // Top separator for multi-argument messages
             isMultiArg ? '\n' + `${scopePadding}${A_LOGGER_FORMAT.TIME_OPEN}${A_LOGGER_FORMAT.SEPARATOR}` : '',
@@ -219,7 +342,7 @@ export class A_Logger extends A_Component {
      * Determine if a log message should be output based on configured log level
      * 
      * Log level hierarchy:
-     * - debug: Shows all messages
+     * - debug: Shows all messages (debug, info, warning, error)
      * - info: Shows info, warning, and error messages
      * - warn: Shows warning and error messages only
      * - error: Shows error messages only
@@ -228,14 +351,14 @@ export class A_Logger extends A_Component {
      * @param logMethod - The type of log method being called
      * @returns True if the message should be logged, false otherwise
      */
-    protected shouldLog(logMethod: 'log' | 'warning' | 'error'): boolean {
-        const shouldLog: A_LoggerLevel = this.config?.get(A_LOGGER_ENV_KEYS.LOG_LEVEL) || 'all';
+    protected shouldLog(logMethod: 'debug' | 'info' | 'warning' | 'error'): boolean {
+        const shouldLog: A_LoggerLevel = this.config?.get(A_LOGGER_ENV_KEYS.LOG_LEVEL) || 'info';
 
         switch (shouldLog) {
             case 'debug':
                 return true;
             case 'info':
-                return logMethod === 'log' || logMethod === 'warning' || logMethod === 'error';
+                return logMethod === 'info' || logMethod === 'warning' || logMethod === 'error';
             case 'warn':
                 return logMethod === 'warning' || logMethod === 'error';
             case 'error':
@@ -253,36 +376,89 @@ export class A_Logger extends A_Component {
     // =============================================
 
     /**
-     * General purpose logging method with optional color specification
+     * Debug logging method with optional color specification
+     * Only logs when debug level is enabled
      * 
      * Supports two usage patterns:
-     * 1. log(message, ...args) - Uses default blue color
-     * 2. log(color, message, ...args) - Uses specified color
+     * 1. debug(message, ...args) - Uses instance's default log color
+     * 2. debug(color, message, ...args) - Uses specified color for message content only
+     * 
+     * Note: The scope color always remains the instance's default scope color,
+     * only the message content color changes when explicitly specified.
      * 
      * @param color - Optional color key or the first message argument
      * @param args - Additional arguments to log
      * 
      * @example
      * ```typescript
-     * logger.log('Hello World');
-     * logger.log('green', 'Success message');
-     * logger.log('Processing user:', { id: 1, name: 'John' });
+     * logger.debug('Debug information'); // Uses instance default colors
+     * logger.debug('gray', 'Debug message'); // Gray message, scope stays instance color
+     * logger.debug('Processing user:', { id: 1, name: 'John' });
      * ```
      */
-    log(color: keyof typeof this.COLORS, ...args: any[]): void;
-    log(...args: any[]): void;
-    log(param1: any, ...args: any[]): void {
-        if (!this.shouldLog('log')) return;
+    debug(color: keyof typeof this.COLORS, ...args: any[]): void;
+    debug(...args: any[]): void;
+    debug(param1: any, ...args: any[]): void {
+        if (!this.shouldLog('debug')) return;
 
         // Check if first parameter is a valid color key
         if (typeof param1 === 'string' && this.COLORS[param1 as keyof typeof this.COLORS]) {
             console.log(...this.compile(param1 as keyof typeof this.COLORS, ...args));
         } else {
-            // Use default blue color and treat param1 as first message argument
-            console.log(...this.compile('blue', param1, ...args));
+            // Use instance's default log color and treat param1 as first message argument
+            console.log(...this.compile(this.DEFAULT_LOG_COLOR, param1, ...args));
         }
     }
 
+    /**
+     * Info logging method with optional color specification
+     * Logs without any restrictions (always shows regardless of log level)
+     * 
+     * Supports two usage patterns:
+     * 1. info(message, ...args) - Uses instance's default log color
+     * 2. info(color, message, ...args) - Uses specified color for message content only
+     * 
+     * Note: The scope color always remains the instance's default scope color,
+     * only the message content color changes when explicitly specified.
+     * 
+     * @param color - Optional color key or the first message argument
+     * @param args - Additional arguments to log
+     * 
+     * @example
+     * ```typescript
+     * logger.info('Hello World'); // Uses instance default colors
+     * logger.info('green', 'Success message'); // Green message, scope stays instance color
+     * logger.info('Processing user:', { id: 1, name: 'John' });
+     * ```
+     */
+    info(color: keyof typeof this.COLORS, ...args: any[]): void;
+    info(...args: any[]): void;
+    info(param1: any, ...args: any[]): void {
+        if (!this.shouldLog('info')) return;
+
+        // Check if first parameter is a valid color key
+        if (typeof param1 === 'string' && this.COLORS[param1 as keyof typeof this.COLORS]) {
+            console.log(...this.compile(param1 as keyof typeof this.COLORS, ...args));
+        } else {
+            // Use instance's default log color and treat param1 as first message argument
+            console.log(...this.compile(this.DEFAULT_LOG_COLOR, param1, ...args));
+        }
+    }
+
+    /**
+     * Legacy log method (kept for backward compatibility)
+     * @deprecated Use info() method instead
+     * 
+     * @param color - Optional color key or the first message argument
+     * @param args - Additional arguments to log
+     */
+    log(color: keyof typeof this.COLORS, ...args: any[]): void;
+    log(...args: any[]): void;
+    log(param1: any, ...args: any[]): void {
+        // Delegate to info method for backward compatibility
+        this.info(param1, ...args);
+    }
+
     /**
      * Log warning messages with yellow color coding
      * 

package/src/lib/A-Logger/A-Logger.constants.ts

@@ -18,17 +18,54 @@ export const A_LOGGER_DEFAULT_LEVEL = 'all';
  * Terminal color codes mapping
  */
 export const A_LOGGER_COLORS = {
-    green: '32',    // Success, completion messages
-    blue: '34',     // Info, general messages  
-    red: '31',      // Errors, critical issues
-    yellow: '33',   // Warnings, caution messages
-    gray: '90',     // Debug, less important info
-    magenta: '35',  // Special highlighting
-    cyan: '36',     // Headers, titles
-    white: '37',    // Default text
-    pink: '95',     // Custom highlighting
+    // System colors (reserved for specific purposes)
+    red: '31',          // Errors, critical issues
+    yellow: '33',       // Warnings, caution messages
+    green: '32',        // Success, completion messages
+    
+    // Safe palette for random selection (grey-blue-violet theme)
+    blue: '34',         // Info, general messages
+    cyan: '36',         // Headers, titles
+    magenta: '35',      // Special highlighting
+    gray: '90',         // Debug, less important info
+    brightBlue: '94',   // Bright blue variant
+    brightCyan: '96',   // Bright cyan variant
+    brightMagenta: '95', // Bright magenta variant
+    darkGray: '30',     // Dark gray
+    lightGray: '37',    // Light gray (white)
+    
+    // Extended blue-violet palette
+    indigo: '38;5;54',      // Deep indigo
+    violet: '38;5;93',      // Violet
+    purple: '38;5;129',     // Purple
+    lavender: '38;5;183',   // Lavender
+    skyBlue: '38;5;117',    // Sky blue
+    steelBlue: '38;5;67',   // Steel blue
+    slateBlue: '38;5;62',   // Slate blue
+    deepBlue: '38;5;18',    // Deep blue
+    lightBlue: '38;5;153',  // Light blue
+    periwinkle: '38;5;111', // Periwinkle
+    cornflower: '38;5;69',  // Cornflower blue
+    powder: '38;5;152',     // Powder blue
+    
+    // Additional grays for variety
+    charcoal: '38;5;236',   // Charcoal
+    silver: '38;5;250',     // Silver
+    smoke: '38;5;244',      // Smoke gray
+    slate: '38;5;240',      // Slate gray
 } as const;
 
+/**
+ * Safe colors for random selection - grey-blue-violet palette
+ * Excludes system colors (red, yellow, green) to avoid confusion with warnings/errors
+ */
+export const A_LOGGER_SAFE_RANDOM_COLORS = [
+    'blue', 'cyan', 'magenta', 'gray', 'brightBlue', 'brightCyan', 'brightMagenta',
+    'darkGray', 'lightGray', 'indigo', 'violet', 'purple', 'lavender', 'skyBlue',
+    'steelBlue', 'slateBlue', 'deepBlue', 'lightBlue', 'periwinkle', 'cornflower',
+    'powder', 'charcoal', 'silver', 'smoke', 'slate'
+] as const;
+
 /**
  * ANSI escape codes
  */
@@ -65,5 +102,8 @@ export const A_LOGGER_FORMAT = {
  * Environment variable keys
  */
 export const A_LOGGER_ENV_KEYS = {
-    LOG_LEVEL: 'A_LOGGER_LEVEL'
+    LOG_LEVEL: 'A_LOGGER_LEVEL',
+    DEFAULT_SCOPE_LENGTH: 'A_LOGGER_DEFAULT_SCOPE_LENGTH',
+    DEFAULT_SCOPE_COLOR: 'A_LOGGER_DEFAULT_SCOPE_COLOR',
+    DEFAULT_LOG_COLOR: 'A_LOGGER_DEFAULT_LOG_COLOR'
 } as const;

package/src/lib/A-Logger/A-Logger.env.ts

@@ -8,19 +8,35 @@ export const A_LoggerEnvVariables = {
      */
     A_LOGGER_LEVEL: 'A_LOGGER_LEVEL',
 
-
     /**     
      * Sets the default scope length for log messages
      * 
      * @example 'A_LOGGER_DEFAULT_SCOPE_LENGTH'
      */
     A_LOGGER_DEFAULT_SCOPE_LENGTH: 'A_LOGGER_DEFAULT_SCOPE_LENGTH',
+
+    /**
+     * Sets the default color for scope display in log messages
+     * 
+     * @example 'green', 'blue', 'red', 'yellow', 'gray', 'magenta', 'cyan', 'white', 'pink'
+     */
+    A_LOGGER_DEFAULT_SCOPE_COLOR: 'A_LOGGER_DEFAULT_SCOPE_COLOR',
+
+    /**
+     * Sets the default color for log message content
+     * 
+     * @example 'green', 'blue', 'red', 'yellow', 'gray', 'magenta', 'cyan', 'white', 'pink'
+     */
+    A_LOGGER_DEFAULT_LOG_COLOR: 'A_LOGGER_DEFAULT_LOG_COLOR',
 } as const;
 
 
 
 export const A_LoggerEnvVariablesArray = [
     A_LoggerEnvVariables.A_LOGGER_LEVEL,
+    A_LoggerEnvVariables.A_LOGGER_DEFAULT_SCOPE_LENGTH,
+    A_LoggerEnvVariables.A_LOGGER_DEFAULT_SCOPE_COLOR,
+    A_LoggerEnvVariables.A_LOGGER_DEFAULT_LOG_COLOR,
 ] as const;