Instance Management

/**
 * Create a new Consola instance with custom configuration
 * @param options - Configuration options for the new instance
 * @returns New ConsolaInstance with specified configuration
 */
function createConsola(options?: Partial<ConsolaOptions>): ConsolaInstance;

import { createConsola } from "consola";
import { BasicReporter } from "consola/reporters";

// Create instance with custom configuration
const apiLogger = createConsola({
  level: 3,
  defaults: { tag: "api" },
  reporters: [new BasicReporter()],
  formatOptions: {
    date: true,
    colors: false
  }
});

// Create minimal logger for production
const prodLogger = createConsola({
  level: 1, // Only warnings and errors
  formatOptions: { compact: true }
});

interface ConsolaInstance {
  /**
   * Create a new Consola instance inheriting from current instance
   * @param options - Configuration overrides for the new instance
   * @returns New ConsolaInstance with merged configuration
   */
  create(options: Partial<ConsolaOptions>): ConsolaInstance;
}

import { consola } from "consola";

// Create specialized logger from default instance
const dbLogger = consola.create({
  defaults: { tag: "database" },
  level: 4 // More verbose for database operations
});

// Create test logger with mocking
const testLogger = consola.create({
  mockFn: (type, defaults) => jest.fn()
});

interface ConsolaInstance {
  /**
   * Create instance with default properties for all log messages
   * @param defaults - Default properties to merge with all logs
   * @returns New ConsolaInstance with specified defaults
   */
  withDefaults(defaults: InputLogObject): ConsolaInstance;
}

import { consola } from "consola";

// Create logger with service identifier
const serviceLogger = consola.withDefaults({
  tag: "user-service",
  additional: [`PID: ${process.pid}`]
});

// Create logger with request context
const requestLogger = consola.withDefaults({
  requestId: "req-123",
  userId: "user-456",
  level: 3
});

serviceLogger.info("Processing user request");
// Output includes default tag and PID information

interface ConsolaInstance {
  /**
   * Create instance with hierarchical tag scoping
   * @param tag - Tag to append to existing tag hierarchy
   * @returns New ConsolaInstance with appended tag
   */
  withTag(tag: string): ConsolaInstance;
}

import { consola } from "consola";

// Create hierarchical tagged loggers
const apiLogger = consola.withTag("api");
const userApiLogger = apiLogger.withTag("users");
const authLogger = userApiLogger.withTag("auth");

apiLogger.info("API server started");        // [api] API server started
userApiLogger.info("User endpoint called"); // [api:users] User endpoint called  
authLogger.error("Authentication failed");  // [api:users:auth] Authentication failed

// Multiple levels of tagging
const moduleLogger = consola
  .withTag("billing")
  .withTag("subscriptions")
  .withTag("webhooks");

moduleLogger.warn("Webhook delivery failed");
// [billing:subscriptions:webhooks] Webhook delivery failed

interface ConsolaInstance {
  /** Current instance configuration */
  options: ConsolaOptions;
  /** Current log level */
  level: LogLevel;
}

interface ConsolaOptions {
  /** Array of reporter instances for output formatting */
  reporters: ConsolaReporter[];
  /** Log type configurations */
  types: Record<LogType, InputLogObject>;
  /** Minimum log level for output */
  level: LogLevel;
  /** Default properties for all log messages */
  defaults: InputLogObject;
  /** Throttle window in milliseconds */
  throttle: number;
  /** Minimum throttle threshold */
  throttleMin: number;
  /** Standard output stream */
  stdout?: NodeJS.WriteStream;
  /** Standard error stream */
  stderr?: NodeJS.WriteStream;
  /** Mock function for testing */
  mockFn?: (type: LogType, defaults: InputLogObject) => (...args: any) => void;
  /** Custom prompt function */
  prompt?: Function;
  /** Formatting configuration */
  formatOptions: FormatOptions;
}

import { consola, createConsola } from "consola";

// Check current configuration
console.log("Current level:", consola.level);
console.log("Active reporters:", consola.options.reporters.length);

// Create instance with comprehensive configuration
const configuredLogger = createConsola({
  level: 2,
  defaults: {
    tag: "app",
    type: "info"
  },
  throttle: 2000,
  throttleMin: 5,
  formatOptions: {
    date: true,
    colors: true,
    columns: 120,
    compact: false
  }
});

// Modify level dynamically
if (process.env.DEBUG) {
  configuredLogger.level = 4; // Enable debug logs
}

// Node.js optimized instance
import { createConsola } from "consola";
import { FancyReporter } from "consola/reporters";

const nodeLogger = createConsola({
  reporters: [new FancyReporter()],
  formatOptions: {
    colors: true,
    date: false
  }
});

// Browser optimized instance  
import { createConsola } from "consola/browser";

const browserLogger = createConsola({
  formatOptions: {
    colors: false, // Browser handles colors
    compact: true
  }
});

// Basic instance for minimal environments
import { createConsola } from "consola/basic";

const basicLogger = createConsola({
  level: 1, // Warnings and errors only
  formatOptions: {
    date: false,
    colors: false
  }
});

// Testing instance with mocks
const testLogger = createConsola({
  mockFn: (type, defaults) => {
    return (...args) => {
      // Custom test logging behavior
      global.testLogs = global.testLogs || [];
      global.testLogs.push({ type, args });
    };
  }
});

interface ConsolaInstance {
  // Legacy aliases (deprecated but supported)
  withScope(tag: string): ConsolaInstance; // → withTag
}

interface ConsolaInstance extends Consola {
  // All log methods
  silent: LogFn;
  fatal: LogFn;
  error: LogFn;
  warn: LogFn;
  log: LogFn;
  info: LogFn;
  success: LogFn;
  fail: LogFn;
  ready: LogFn;
  start: LogFn;
  box: LogFn;
  debug: LogFn;
  trace: LogFn;
  verbose: LogFn;
}

interface LogFn {
  (message?: InputLogObject | any, ...args: any[]): void;
  raw: (...args: any[]) => void;
}

interface FormatOptions {
  columns?: number;
  date?: boolean;
  colors?: boolean;
  compact?: boolean | number;
  errorLevel?: number;
  [key: string]: unknown;
}