@adaas/a-utils 0.2.8 → 0.3.1

package/dist/node/lib/A-Logger/A-Logger.component.mjs

@@ -0,0 +1,615 @@
+import { __decorateClass, __decorateParam } from '../../chunk-EQQGB2QZ.mjs';
+import { A_Inject, A_Scope, A_Component, A_Context, A_Error } from '@adaas/a-concept';
+import { A_Config } from '@adaas/a-utils/a-config';
+import { A_LOGGER_COLORS, A_LOGGER_DEFAULT_SCOPE_LENGTH, A_LOGGER_ENV_KEYS, A_LOGGER_TERMINAL, A_LOGGER_SAFE_RANDOM_COLORS, A_LOGGER_FORMAT, A_LOGGER_ANSI, A_LOGGER_TIME_FORMAT } from './A-Logger.constants';
+import { A_Frame } from '@adaas/a-frame';
+
+let A_Logger = class extends A_Component {
+  // =============================================
+  // 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 and color settings
+   */
+  constructor(scope, config) {
+    super();
+    this.scope = scope;
+    this.config = config;
+    this.COLORS = A_LOGGER_COLORS;
+    this.STANDARD_SCOPE_LENGTH = config?.get(A_LOGGER_ENV_KEYS.DEFAULT_SCOPE_LENGTH) || A_LOGGER_DEFAULT_SCOPE_LENGTH;
+    const configScopeColor = config?.get(A_LOGGER_ENV_KEYS.DEFAULT_SCOPE_COLOR);
+    const configLogColor = config?.get(A_LOGGER_ENV_KEYS.DEFAULT_LOG_COLOR);
+    if (configScopeColor || configLogColor) {
+      this.DEFAULT_SCOPE_COLOR = configScopeColor || this.generateColorFromScopeName(this.scope.name);
+      this.DEFAULT_LOG_COLOR = configLogColor || this.generateColorFromScopeName(this.scope.name);
+    } else {
+      const complementaryColors = this.generateComplementaryColorsFromScope(this.scope.name);
+      this.DEFAULT_SCOPE_COLOR = complementaryColors.scopeColor;
+      this.DEFAULT_LOG_COLOR = complementaryColors.logColor;
+    }
+    this.TERMINAL_WIDTH = this.detectTerminalWidth();
+    this.MAX_CONTENT_WIDTH = Math.floor(this.TERMINAL_WIDTH * A_LOGGER_TERMINAL.MAX_LINE_LENGTH_RATIO);
+  }
+  // =============================================
+  // 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
+   */
+  simpleHash(str) {
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+      const char = str.charCodeAt(i);
+      hash = (hash << 5) - hash + char;
+      hash = hash & hash;
+    }
+    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
+   */
+  generateColorFromScopeName(scopeName) {
+    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
+   */
+  generateComplementaryColorsFromScope(scopeName) {
+    const colorPairs = [
+      { scopeColor: "indigo", logColor: "lightBlue" },
+      { scopeColor: "deepBlue", logColor: "cyan" },
+      { scopeColor: "purple", logColor: "lavender" },
+      { scopeColor: "steelBlue", logColor: "skyBlue" },
+      { scopeColor: "slateBlue", logColor: "periwinkle" },
+      { scopeColor: "charcoal", logColor: "silver" },
+      { scopeColor: "violet", logColor: "brightMagenta" },
+      { scopeColor: "darkGray", logColor: "lightGray" },
+      { scopeColor: "cornflower", logColor: "powder" },
+      { scopeColor: "slate", logColor: "smoke" }
+    ];
+    const hash = this.simpleHash(scopeName);
+    const pairIndex = hash % colorPairs.length;
+    return colorPairs[pairIndex];
+  }
+  // =============================================
+  // Terminal Width Detection
+  // =============================================
+  /**
+   * Detect current terminal width based on environment
+   * 
+   * Returns appropriate width for different environments:
+   * - Node.js: Uses process.stdout.columns if available
+   * - Browser: Returns browser default width
+   * - Fallback: Returns default terminal width
+   * 
+   * @returns Terminal width in characters
+   */
+  detectTerminalWidth() {
+    try {
+      if (A_Context.environment === "browser") {
+        return A_LOGGER_TERMINAL.BROWSER_DEFAULT_WIDTH;
+      }
+      if (typeof process !== "undefined" && process.stdout && process.stdout.columns) {
+        const cols = process.stdout.columns;
+        return Math.max(cols, A_LOGGER_TERMINAL.MIN_WIDTH);
+      }
+      return A_LOGGER_TERMINAL.DEFAULT_WIDTH;
+    } catch (error) {
+      return A_LOGGER_TERMINAL.DEFAULT_WIDTH;
+    }
+  }
+  /**
+   * Wrap text to fit within terminal width while preserving formatting
+   * 
+   * @param text - Text to wrap
+   * @param scopePadding - The scope padding string for alignment
+   * @param isFirstLine - Whether this is the first line (affects available width calculation)
+   * @returns Array of wrapped lines with proper indentation
+   */
+  wrapText(text, scopePadding, isFirstLine = true) {
+    if (A_Context.environment === "browser") {
+      return [text];
+    }
+    const scopeHeaderLength = this.formattedScope.length + 4 + this.getTime().length + 4;
+    const continuationIndent = `${scopePadding}${A_LOGGER_FORMAT.PIPE}`;
+    const firstLineMaxWidth = Math.max(this.TERMINAL_WIDTH - scopeHeaderLength - 1, 20);
+    const continuationMaxWidth = Math.max(this.TERMINAL_WIDTH - continuationIndent.length, 20);
+    if (isFirstLine && text.length <= firstLineMaxWidth) {
+      return [text];
+    }
+    const lines = [];
+    const words = text.split(" ");
+    let currentLine = "";
+    let currentMaxWidth = isFirstLine ? firstLineMaxWidth : continuationMaxWidth;
+    for (const word of words) {
+      const spaceNeeded = currentLine ? 1 : 0;
+      const totalLength = currentLine.length + spaceNeeded + word.length;
+      if (totalLength > currentMaxWidth) {
+        if (currentLine) {
+          lines.push(currentLine);
+          currentLine = word;
+          currentMaxWidth = continuationMaxWidth;
+        } else {
+          if (word.length > currentMaxWidth) {
+            const chunks = this.splitLongWord(word, currentMaxWidth);
+            lines.push(...chunks.slice(0, -1));
+            currentLine = chunks[chunks.length - 1];
+          } else {
+            currentLine = word;
+          }
+          currentMaxWidth = continuationMaxWidth;
+        }
+      } else {
+        currentLine += (currentLine ? " " : "") + word;
+      }
+    }
+    if (currentLine) {
+      lines.push(currentLine);
+    }
+    return lines.length ? lines : [text];
+  }
+  /**
+   * Split a long word that doesn't fit on a single line
+   * 
+   * @param word - Word to split
+   * @param maxLength - Maximum length per chunk
+   * @returns Array of word chunks
+   */
+  splitLongWord(word, maxLength) {
+    const chunks = [];
+    for (let i = 0; i < word.length; i += maxLength) {
+      chunks.push(word.slice(i, i + maxLength));
+    }
+    return chunks;
+  }
+  // =============================================
+  // Factory Methods
+  // =============================
+  // =============================================
+  // Scope and Formatting Utilities
+  // =============================================
+  /**
+   * Get the formatted scope length for consistent message alignment
+   * Uses a standard length to ensure all messages align properly regardless of scope name
+   * 
+   * @returns The scope length to use for padding calculations
+   */
+  get scopeLength() {
+    return Math.max(this.scope.name.length, this.STANDARD_SCOPE_LENGTH);
+  }
+  /**
+   * 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 Centered and padded scope name for consistent formatting
+   */
+  get formattedScope() {
+    const scopeName = this.scope.name;
+    const totalLength = this.STANDARD_SCOPE_LENGTH;
+    if (scopeName.length >= totalLength) {
+      return scopeName.substring(0, totalLength);
+    }
+    const totalPadding = totalLength - scopeName.length;
+    const leftPadding = Math.floor(totalPadding / 2);
+    const rightPadding = totalPadding - leftPadding;
+    return " ".repeat(leftPadding) + scopeName + " ".repeat(rightPadding);
+  }
+  // =============================================
+  // Message Compilation and Formatting
+  // =============================================
+  /**
+   * Compile log arguments into formatted console output with colors and proper alignment
+   * 
+   * This method handles the core formatting logic for all log messages:
+   * - 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 messageColor - The color key to apply to the message content
+   * @param args - Variable arguments to format and display
+   * @returns Array of formatted strings and/or objects ready for console output
+   */
+  compile(messageColor, ...args) {
+    const timeString = this.getTime();
+    const scopePadding = " ".repeat(this.STANDARD_SCOPE_LENGTH + 3);
+    const isMultiArg = args.length > 1;
+    return [
+      // 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 ? `
+${scopePadding}${A_LOGGER_FORMAT.TIME_OPEN}${A_LOGGER_FORMAT.SEPARATOR}` : "",
+      // Process each argument with appropriate formatting
+      ...args.map((arg, i) => {
+        const shouldAddNewline = i > 0 || isMultiArg;
+        switch (true) {
+          case arg instanceof A_Error:
+            return this.compile_A_Error(arg);
+          case arg instanceof Error:
+            return this.compile_Error(arg);
+          case (typeof arg === "object" && arg !== null):
+            return this.formatObject(arg, shouldAddNewline, scopePadding);
+          default:
+            return this.formatString(String(arg), shouldAddNewline, scopePadding);
+        }
+      }),
+      // Bottom separator and color reset
+      isMultiArg ? `
+${scopePadding}${A_LOGGER_FORMAT.TIME_OPEN}${A_LOGGER_FORMAT.SEPARATOR}${A_LOGGER_ANSI.RESET}` : A_LOGGER_ANSI.RESET
+    ];
+  }
+  /**
+   * Format an object for display with proper JSON indentation and terminal width awareness
+   * 
+   * @param obj - The object to format
+   * @param shouldAddNewline - Whether to add a newline prefix
+   * @param scopePadding - The padding string for consistent alignment
+   * @returns Formatted object string or the object itself for browser environments
+   */
+  formatObject(obj, shouldAddNewline, scopePadding) {
+    if (A_Context.environment === "browser") {
+      return obj;
+    }
+    if (obj === null) {
+      return shouldAddNewline ? `
+${scopePadding}${A_LOGGER_FORMAT.PIPE}null` : "null";
+    }
+    if (obj === void 0) {
+      return shouldAddNewline ? `
+${scopePadding}${A_LOGGER_FORMAT.PIPE}undefined` : "undefined";
+    }
+    let jsonString;
+    try {
+      jsonString = JSON.stringify(obj, null, 2);
+    } catch (error) {
+      try {
+        const seen = /* @__PURE__ */ new WeakSet();
+        jsonString = JSON.stringify(obj, (key, value) => {
+          if (typeof value === "object" && value !== null) {
+            if (seen.has(value)) {
+              return "[Circular Reference]";
+            }
+            seen.add(value);
+          }
+          return value;
+        }, 2);
+      } catch (fallbackError) {
+        jsonString = String(obj);
+      }
+    }
+    const continuationIndent = `${scopePadding}${A_LOGGER_FORMAT.PIPE}`;
+    const maxJsonLineWidth = this.TERMINAL_WIDTH - continuationIndent.length - 4;
+    const lines = jsonString.split("\n").map((line) => {
+      const stringValueMatch = line.match(/^(\s*"[^"]+":\s*")([^"]+)(".*)?$/);
+      if (stringValueMatch && stringValueMatch[2].length > maxJsonLineWidth - stringValueMatch[1].length - (stringValueMatch[3] || "").length) {
+        const [, prefix, value, suffix = ""] = stringValueMatch;
+        if (value.length > maxJsonLineWidth - prefix.length - suffix.length) {
+          const wrappedValue = this.wrapJsonStringValue(value, maxJsonLineWidth - prefix.length - suffix.length);
+          return prefix + wrappedValue + suffix;
+        }
+      }
+      return line;
+    });
+    const formatted = lines.join("\n" + continuationIndent);
+    return shouldAddNewline ? "\n" + continuationIndent + formatted : formatted;
+  }
+  /**
+   * Wrap a long JSON string value while preserving readability
+   * 
+   * @param value - The string value to wrap
+   * @param maxWidth - Maximum width for the value
+   * @returns Wrapped string value
+   */
+  wrapJsonStringValue(value, maxWidth) {
+    if (value.length <= maxWidth) {
+      return value;
+    }
+    if (maxWidth > 6) {
+      return value.substring(0, maxWidth - 3) + "...";
+    } else {
+      return value.substring(0, Math.max(1, maxWidth));
+    }
+  }
+  /**
+   * Format a string for display with proper indentation and terminal width wrapping
+   * 
+   * @param str - The string to format
+   * @param shouldAddNewline - Whether to add a newline prefix
+   * @param scopePadding - The padding string for consistent alignment
+   * @returns Formatted string
+   */
+  formatString(str, shouldAddNewline, scopePadding) {
+    if (A_Context.environment === "browser") {
+      const prefix = shouldAddNewline ? "\n" : "";
+      return (prefix + str).replace(/\n/g, `
+${scopePadding}${A_LOGGER_FORMAT.PIPE}`);
+    }
+    const wrappedLines = this.wrapText(str, scopePadding, !shouldAddNewline);
+    const continuationIndent = `${scopePadding}${A_LOGGER_FORMAT.PIPE}`;
+    const formattedLines = wrappedLines.map((line, index) => {
+      if (index === 0 && !shouldAddNewline) {
+        return line;
+      } else {
+        return `${continuationIndent}${line}`;
+      }
+    });
+    if (shouldAddNewline) {
+      return "\n" + formattedLines.join("\n");
+    } else {
+      return formattedLines.join("\n");
+    }
+  }
+  // =============================================
+  // Log Level Management
+  // =============================================
+  /**
+   * Determine if a log message should be output based on configured log level
+   * 
+   * Log level hierarchy:
+   * - 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
+   * - all: Shows all messages (alias for debug)
+   * 
+   * @param logMethod - The type of log method being called
+   * @returns True if the message should be logged, false otherwise
+   */
+  shouldLog(logMethod) {
+    const shouldLog = this.config?.get(A_LOGGER_ENV_KEYS.LOG_LEVEL) || "info";
+    switch (shouldLog) {
+      case "debug":
+        return true;
+      case "info":
+        return logMethod === "info" || logMethod === "warning" || logMethod === "error";
+      case "warn":
+        return logMethod === "warning" || logMethod === "error";
+      case "error":
+        return logMethod === "error";
+      case "all":
+        return true;
+      default:
+        return false;
+    }
+  }
+  debug(param1, ...args) {
+    if (!this.shouldLog("debug")) return;
+    if (typeof param1 === "string" && this.COLORS[param1]) {
+      console.log(...this.compile(param1, ...args));
+    } else {
+      console.log(...this.compile(this.DEFAULT_LOG_COLOR, param1, ...args));
+    }
+  }
+  info(param1, ...args) {
+    if (!this.shouldLog("info")) return;
+    if (typeof param1 === "string" && this.COLORS[param1]) {
+      console.log(...this.compile(param1, ...args));
+    } else {
+      console.log(...this.compile(this.DEFAULT_LOG_COLOR, param1, ...args));
+    }
+  }
+  log(param1, ...args) {
+    this.info(param1, ...args);
+  }
+  /**
+   * Log warning messages with yellow color coding
+   * 
+   * Use for non-critical issues that should be brought to attention
+   * but don't prevent normal operation
+   * 
+   * @param args - Arguments to log as warnings
+   * 
+   * @example
+   * ```typescript
+   * logger.warning('Deprecated method used');
+   * logger.warning('Rate limit approaching:', { current: 95, limit: 100 });
+   * ```
+   */
+  warning(...args) {
+    if (!this.shouldLog("warning")) return;
+    console.log(...this.compile("yellow", ...args));
+  }
+  /**
+   * Log error messages with red color coding
+   * 
+   * Use for critical issues, exceptions, and failures that need immediate attention
+   * 
+   * @param args - Arguments to log as errors
+   * @returns void (for compatibility with console.log)
+   * 
+   * @example
+   * ```typescript
+   * logger.error('Database connection failed');
+   * logger.error(new Error('Validation failed'));
+   * logger.error('Critical error:', error, { context: 'user-registration' });
+   * ```
+   */
+  error(...args) {
+    if (!this.shouldLog("error")) return;
+    console.log(...this.compile("red", ...args));
+  }
+  // =============================================
+  // Specialized Error Formatting
+  // =============================================
+  /**
+   * Legacy method for A_Error logging (kept for backward compatibility)
+   * 
+   * @deprecated Use error() method instead which handles A_Error automatically
+   * @param error - The A_Error instance to log
+   */
+  log_A_Error(error) {
+    const time = this.getTime();
+    const scopePadding = " ".repeat(this.STANDARD_SCOPE_LENGTH + 3);
+    console.log(`\x1B[31m[${this.formattedScope}] |${time}| ERROR ${error.code}
+${scopePadding}| ${error.message}
+${scopePadding}| ${error.description} 
+${scopePadding}|-------------------------------
+${scopePadding}| ${error.stack?.split("\n").map((line, index) => index === 0 ? line : `${scopePadding}| ${line}`).join("\n") || "No stack trace"}
+${scopePadding}|-------------------------------
+\x1B[0m` + (error.originalError ? `\x1B[31m${scopePadding}| Wrapped From  ${error.originalError.message}
+${scopePadding}|-------------------------------
+${scopePadding}| ${error.originalError.stack?.split("\n").map((line, index) => index === 0 ? line : `${scopePadding}| ${line}`).join("\n") || "No stack trace"}
+${scopePadding}|-------------------------------
+\x1B[0m` : "") + (error.link ? `\x1B[31m${scopePadding}| Read in docs: ${error.link}
+${scopePadding}|-------------------------------
+\x1B[0m` : ""));
+  }
+  /**
+   * Format A_Error instances for inline display within compiled messages
+   * 
+   * Provides detailed formatting for A_Error objects with:
+   * - Error code, message, and description
+   * - Original error information FIRST (better UX for debugging)
+   * - Stack traces with terminal width awareness
+   * - Documentation links (if available)
+   * - Consistent formatting with rest of logger
+   * 
+   * @param error - The A_Error instance to format
+   * @returns Formatted string ready for display
+   */
+  compile_A_Error(error) {
+    const continuationIndent = `${" ".repeat(this.STANDARD_SCOPE_LENGTH + 3)}${A_LOGGER_FORMAT.PIPE}`;
+    const separator = `${continuationIndent}-------------------------------`;
+    const lines = [];
+    lines.push("");
+    lines.push(separator);
+    lines.push(`${continuationIndent}A_ERROR: ${error.code}`);
+    lines.push(separator);
+    const errorMessage = this.wrapText(`Message: ${error.message}`, continuationIndent, false);
+    const errorDescription = this.wrapText(`Description: ${error.description}`, continuationIndent, false);
+    lines.push(...errorMessage.map((line) => `${continuationIndent}${line}`));
+    lines.push(...errorDescription.map((line) => `${continuationIndent}${line}`));
+    if (error.originalError) {
+      lines.push(separator);
+      lines.push(`${continuationIndent}ORIGINAL ERROR:`);
+      lines.push(separator);
+      const originalMessage = this.wrapText(`${error.originalError.name}: ${error.originalError.message}`, continuationIndent, false);
+      lines.push(...originalMessage.map((line) => `${continuationIndent}${line}`));
+      if (error.originalError.stack) {
+        lines.push(`${continuationIndent}Stack trace:`);
+        const stackLines = this.formatStackTrace(error.originalError.stack, continuationIndent);
+        lines.push(...stackLines);
+      }
+    }
+    if (error.stack) {
+      lines.push(separator);
+      lines.push(`${continuationIndent}A_ERROR STACK:`);
+      lines.push(separator);
+      const stackLines = this.formatStackTrace(error.stack, continuationIndent);
+      lines.push(...stackLines);
+    }
+    if (error.link) {
+      lines.push(separator);
+      const linkText = this.wrapText(`Documentation: ${error.link}`, continuationIndent, false);
+      lines.push(...linkText.map((line) => `${continuationIndent}${line}`));
+    }
+    lines.push(separator);
+    return lines.join("\n");
+  }
+  /**
+   * Format stack trace with proper terminal width wrapping and indentation
+   * 
+   * @param stack - The stack trace string
+   * @param baseIndent - Base indentation for continuation lines
+   * @returns Array of formatted stack trace lines
+   */
+  formatStackTrace(stack, baseIndent) {
+    const stackLines = stack.split("\n");
+    const formatted = [];
+    stackLines.forEach((line, index) => {
+      if (line.trim()) {
+        const stackIndent = index === 0 ? baseIndent : `${baseIndent}  `;
+        const wrappedLines = this.wrapText(line.trim(), stackIndent, false);
+        formatted.push(...wrappedLines.map(
+          (wrappedLine) => index === 0 && wrappedLine === wrappedLines[0] ? `${baseIndent}${wrappedLine}` : `${baseIndent}  ${wrappedLine}`
+        ));
+      }
+    });
+    return formatted;
+  }
+  /**
+   * Format standard Error instances for inline display within compiled messages
+   * 
+   * Provides clean, readable formatting for standard JavaScript errors with:
+   * - Terminal width aware message wrapping
+   * - Properly formatted stack traces
+   * - Consistent indentation with rest of logger
+   * 
+   * @param error - The Error instance to format
+   * @returns Formatted string ready for display
+   */
+  compile_Error(error) {
+    const continuationIndent = `${" ".repeat(this.STANDARD_SCOPE_LENGTH + 3)}${A_LOGGER_FORMAT.PIPE}`;
+    const separator = `${continuationIndent}-------------------------------`;
+    const lines = [];
+    lines.push("");
+    lines.push(separator);
+    lines.push(`${continuationIndent}ERROR: ${error.name}`);
+    lines.push(separator);
+    const errorMessage = this.wrapText(`Message: ${error.message}`, continuationIndent, false);
+    lines.push(...errorMessage.map((line) => `${continuationIndent}${line}`));
+    if (error.stack) {
+      lines.push(separator);
+      lines.push(`${continuationIndent}STACK TRACE:`);
+      lines.push(separator);
+      const stackLines = this.formatStackTrace(error.stack, continuationIndent);
+      lines.push(...stackLines);
+    }
+    lines.push(separator);
+    return lines.join("\n");
+  }
+  // =============================================
+  // Utility Methods
+  // =============================================
+  /**
+   * Generate timestamp string for log messages
+   * 
+   * Format: MM:SS:mmm (minutes:seconds:milliseconds)
+   * This provides sufficient precision for debugging while remaining readable
+   * 
+   * @returns Formatted timestamp string
+   * 
+   * @example
+   * Returns: "15:42:137" for 3:42:15 PM and 137 milliseconds
+   */
+  getTime() {
+    const now = /* @__PURE__ */ new Date();
+    const minutes = String(now.getMinutes()).padStart(A_LOGGER_TIME_FORMAT.MINUTES_PAD, "0");
+    const seconds = String(now.getSeconds()).padStart(A_LOGGER_TIME_FORMAT.SECONDS_PAD, "0");
+    const milliseconds = String(now.getMilliseconds()).padStart(A_LOGGER_TIME_FORMAT.MILLISECONDS_PAD, "0");
+    return `${minutes}${A_LOGGER_TIME_FORMAT.SEPARATOR}${seconds}${A_LOGGER_TIME_FORMAT.SEPARATOR}${milliseconds}`;
+  }
+};
+A_Logger = __decorateClass([
+  A_Frame.Component({
+    namespace: "A-Utils",
+    name: "A_Logger",
+    description: "Advanced Logging Component with Scope-based Output Formatting that provides color-coded console output, multi-type support, and configurable log levels for enhanced debugging and monitoring."
+  }),
+  __decorateParam(0, A_Inject(A_Scope)),
+  __decorateParam(1, A_Inject(A_Config))
+], A_Logger);
+
+export { A_Logger };
+//# sourceMappingURL=A-Logger.component.mjs.map
+//# sourceMappingURL=A-Logger.component.mjs.map