logan-logger 1.1.3 → 1.1.7

package/dist/node.d.ts

@@ -1,190 +1,3 @@
-declare abstract class BaseLogger implements ILogger {
-    protected level: LogLevel;
-    protected config: Partial<LoggerConfig>;
-    protected runtime: RuntimeName;
-    protected childMetadata: Record<string, any>;
-    protected constructor(config?: Partial<LoggerConfig>);
-    debug(message: LogMessage, metadata?: any): void;
-    info(message: LogMessage, metadata?: any): void;
-    warn(message: LogMessage, metadata?: any): void;
-    error(message: LogMessage, metadata?: any): void;
-    log(level: LogLevel, message: LogMessage, metadata?: any): void;
-    setLevel(level: LogLevel): void;
-    getLevel(): LogLevel;
-    child(metadata: Record<string, any>): ILogger;
-    protected shouldLog(level: LogLevel): boolean;
-    protected abstract writeLog(entry: LogEntry): void;
-    protected abstract createChild(): BaseLogger;
-}
-
-/**
- * Convenience function for creating a logger instance.
- * @param config - Optional configuration for the logger
- * @returns A logger instance appropriate for the current runtime
- * @example
- * ```typescript
- * import { createLogger, LogLevel } from 'logan-logger';
- *
- * const logger = createLogger({
- *   level: LogLevel.DEBUG,
- *   colorize: true
- * });
- *
- * logger.info('Hello world!');
- * ```
- */
-export declare function createLogger(config?: Partial<LoggerConfig>): ILogger;
-
-/**
- * Create a logger with configuration based on the current environment.
- * Automatically detects production/development/test environments and
- * sets appropriate log levels and formatting.
- * @returns A logger instance configured for the current environment
- */
-export declare function createLoggerForEnvironment(): ILogger;
-
-export declare function createMorganStream(logger: NodeLogger): {
-    write: (message: string) => void;
-};
-
-/**
- * Main logger interface providing methods for logging at different levels.
- * This interface is implemented by all logger implementations across different runtimes.
- */
-export declare interface ILogger {
-    /**
-     * Log a debug message. Only shown when log level is DEBUG.
-     * @param message - The message to log (string or lazy function)
-     * @param metadata - Optional structured data to include
-     */
-    debug(message: LogMessage, metadata?: any): void;
-    /**
-     * Log an informational message.
-     * @param message - The message to log (string or lazy function)
-     * @param metadata - Optional structured data to include
-     */
-    info(message: LogMessage, metadata?: any): void;
-    /**
-     * Log a warning message.
-     * @param message - The message to log (string or lazy function)
-     * @param metadata - Optional structured data to include
-     */
-    warn(message: LogMessage, metadata?: any): void;
-    /**
-     * Log an error message.
-     * @param message - The message to log (string or lazy function)
-     * @param metadata - Optional structured data to include
-     */
-    error(message: LogMessage, metadata?: any): void;
-    /**
-     * Log a message at a specific level.
-     * @param level - The log level
-     * @param message - The message to log (string or lazy function)
-     * @param metadata - Optional structured data to include
-     */
-    log(level: LogLevel, message: LogMessage, metadata?: any): void;
-    /**
-     * Set the minimum log level for this logger.
-     * @param level - The minimum log level
-     */
-    setLevel(level: LogLevel): void;
-    /**
-     * Get the current minimum log level.
-     * @returns The current log level
-     */
-    getLevel(): LogLevel;
-    /**
-     * Create a child logger with additional metadata.
-     * @param metadata - Additional metadata to include in all child log messages
-     * @returns A new logger instance with the additional metadata
-     */
-    child(metadata: Record<string, any>): ILogger;
-}
-
-/**
- * Internal representation of a log entry.
- */
-declare interface LogEntry {
-    /** When the log entry was created */
-    timestamp: Date;
-    /** Log level of this entry */
-    level: LogLevel;
-    /** The log message */
-    message: string;
-    /** Additional structured data */
-    metadata?: Record<string, any>;
-    /** Runtime that generated this log entry */
-    runtime: RuntimeName;
-}
-
-/**
- * Configuration options for creating a logger instance.
- */
-export declare interface LoggerConfig {
-    /** Minimum log level to output */
-    level: LogLevel;
-    /** Output format for log messages */
-    format: 'json' | 'text' | 'custom';
-    /** Whether to include timestamps in log output */
-    timestamp: boolean;
-    /** Whether to colorize log output (if supported) */
-    colorize: boolean;
-    /** Default metadata to include with all log messages */
-    metadata: Record<string, any>;
-    /** Transport configurations for log output */
-    transports?: TransportConfig[];
-}
-
-/**
- * Log levels in ascending order of severity.
- * Used to filter which messages should be logged.
- */
-export declare enum LogLevel {
-    /** Debug messages - most verbose */
-    DEBUG = 0,
-    /** Informational messages */
-    INFO = 1,
-    /** Warning messages */
-    WARN = 2,
-    /** Error messages */
-    ERROR = 3,
-    /** No messages - silent mode */
-    SILENT = 4
-}
-
-/**
- * A log message can be a string or a function that returns a string.
- * Functions enable lazy evaluation for expensive log message generation.
- */
-declare type LogMessage = string | (() => string);
-
-export declare class NodeLogger extends BaseLogger {
-    private winston?;
-    constructor(config?: Partial<LoggerConfig>);
-    private initializeWinston;
-    private createWinstonLogger;
-    protected writeLog(entry: LogEntry): void;
-    protected createChild(): BaseLogger;
-    private writeToConsole;
-    private getWinstonLevel;
-    setLevel(level: LogLevel): void;
-}
-
-/**
- * Supported JavaScript runtime environments.
- */
-declare type RuntimeName = 'node' | 'deno' | 'bun' | 'browser' | 'webworker' | 'unknown';
-
-/**
- * Configuration for a specific log transport (output destination).
- */
-declare interface TransportConfig {
-    /** Type of transport */
-    type: 'console' | 'file' | 'http' | 'custom';
-    /** Minimum log level for this transport */
-    level?: LogLevel;
-    /** Transport-specific options */
-    options: Record<string, any>;
-}
-
-export { }
+export { NodeLogger, createMorganStream } from './runtime/node';
+export type { ILogger, LoggerConfig, LogLevel } from './core/types';
+export { createLogger, createLoggerForEnvironment } from './core/factory';

package/dist/node.esm.js

@@ -1,4 +1,4 @@
-import { N as a, c as o, a as g, e as t } from "./node-cR0agAz0.mjs";
+import { N as a, c as o, a as g, e as t } from "./node-D140bib-.mjs";
 export {
   a as NodeLogger,
   o as createLogger,

package/dist/node.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./node-BO4IXArm.js");exports.NodeLogger=e.NodeLogger;exports.createLogger=e.createLogger;exports.createLoggerForEnvironment=e.createLoggerForEnvironment;exports.createMorganStream=e.createMorganStream;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./node-C009y7d7.js");exports.NodeLogger=e.NodeLogger;exports.createLogger=e.createLogger;exports.createLoggerForEnvironment=e.createLoggerForEnvironment;exports.createMorganStream=e.createMorganStream;

package/dist/runtime/browser.d.ts

@@ -0,0 +1,31 @@
+import { BaseLogger } from '../core/logger';
+import { LogEntry, LogLevel, LoggerConfig } from '../core/types';
+export declare class BrowserLogger extends BaseLogger {
+    constructor(config?: Partial<LoggerConfig>);
+    protected writeLog(entry: LogEntry): void;
+    protected createChild(): BaseLogger;
+    private formatMessage;
+    private getConsoleStyle;
+    private shouldLogInProduction;
+    protected shouldLog(level: LogLevel): boolean;
+}
+export declare class ConsoleGroupLogger extends BrowserLogger {
+    private groupStack;
+    group(label: string): void;
+    groupCollapsed(label: string): void;
+    groupEnd(): void;
+    getCurrentGroupStack(): string[];
+    getCurrentGroupPath(): string;
+    time(label: string): void;
+    timeEnd(label: string): void;
+    trace(message: string, metadata?: any): void;
+    count(label?: string): void;
+    countReset(label?: string): void;
+    table(data: any): void;
+}
+export declare class PerformanceLogger extends BrowserLogger {
+    mark(name: string): void;
+    measure(name: string, startMark?: string, endMark?: string): void;
+    clearMarks(name?: string): void;
+    clearMeasures(name?: string): void;
+}

package/dist/runtime/node.d.ts

@@ -0,0 +1,16 @@
+import { BaseLogger } from '../core/logger';
+import { LogEntry, LogLevel, LoggerConfig } from '../core/types';
+export declare class NodeLogger extends BaseLogger {
+    private winston?;
+    constructor(config?: Partial<LoggerConfig>);
+    private initializeWinston;
+    private createWinstonLogger;
+    protected writeLog(entry: LogEntry): void;
+    protected createChild(): BaseLogger;
+    private writeToConsole;
+    private getWinstonLevel;
+    setLevel(level: LogLevel): void;
+}
+export declare function createMorganStream(logger: NodeLogger): {
+    write: (message: string) => void;
+};

package/dist/utils/config.d.ts

@@ -0,0 +1,5 @@
+import { LoggerConfig } from '../core/types';
+export declare function getDefaultConfig(): LoggerConfig;
+export declare function loadConfigFromEnvironment(): Partial<LoggerConfig>;
+export declare function loadConfigFromFile(configPath?: string): Promise<Partial<LoggerConfig>>;
+export declare function mergeConfigs(...configs: Partial<LoggerConfig>[]): LoggerConfig;

package/dist/utils/formatting.d.ts

@@ -0,0 +1,31 @@
+import { LogEntry, LogLevel } from '../core/types';
+/**
+ * Format a log entry for output in different formats.
+ * @param entry - The log entry to format
+ * @param format - Output format ('json' or 'text')
+ * @returns Formatted log string
+ * @example
+ * ```typescript
+ * const entry: LogEntry = {
+ *   timestamp: new Date(),
+ *   level: LogLevel.INFO,
+ *   message: 'User logged in',
+ *   metadata: { userId: 123 },
+ *   runtime: 'node'
+ * };
+ *
+ * const textFormat = formatLogEntry(entry, 'text');
+ * // Result: "[2024-01-01T12:00:00.000Z] INFO: User logged in {\"userId\":123}"
+ *
+ * const jsonFormat = formatLogEntry(entry, 'json');
+ * // Result: {"timestamp":"2024-01-01T12:00:00.000Z","level":"info","message":"User logged in","metadata":{"userId":123},"runtime":"node"}
+ * ```
+ */
+export declare function formatLogEntry(entry: LogEntry, format?: 'json' | 'text'): string;
+/**
+ * Format log level as a colored string for terminal output.
+ * @param level - The log level to format
+ * @param colorize - Whether to apply ANSI color codes
+ * @returns Formatted level string with optional colors
+ */
+export declare function formatLevel(level: LogLevel, colorize?: boolean): string;

package/dist/utils/runtime.d.ts

@@ -0,0 +1,31 @@
+import { RuntimeInfo } from '../core/types';
+/**
+ * Detects the current JavaScript runtime environment and its capabilities.
+ * @returns Information about the detected runtime
+ * @example
+ * ```typescript
+ * const runtime = detectRuntime();
+ * console.log(`Running on: ${runtime.name} ${runtime.version}`);
+ * ```
+ */
+export declare function detectRuntime(): RuntimeInfo;
+/**
+ * Check if the current runtime is Node.js.
+ * @returns True if running in Node.js
+ */
+export declare function isNode(): boolean;
+/**
+ * Check if the current runtime is a browser.
+ * @returns True if running in a browser
+ */
+export declare function isBrowser(): boolean;
+/**
+ * Check if the current runtime is Deno.
+ * @returns True if running in Deno
+ */
+export declare function isDeno(): boolean;
+/**
+ * Check if the current runtime is Bun.
+ * @returns True if running in Bun
+ */
+export declare function isBun(): boolean;

package/dist/utils/serialization.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Safely stringify an object to JSON, handling circular references,
+ * Error objects, functions, and other non-serializable values.
+ * @param obj - The object to stringify
+ * @param space - Number of spaces for pretty-printing (optional)
+ * @returns JSON string representation
+ */
+export declare function safeStringify(obj: any, space?: number): string;
+/**
+ * Filter out sensitive data from an object before logging.
+ * @param obj - The object to filter
+ * @param sensitiveKeys - Array of key names to redact (case-insensitive)
+ * @returns A new object with sensitive values replaced with '[REDACTED]'
+ * @example
+ * ```typescript
+ * const data = { username: 'john', password: 'secret123' };
+ * const filtered = filterSensitiveData(data);
+ * // Result: { username: 'john', password: '[REDACTED]' }
+ * ```
+ */
+export declare function filterSensitiveData(obj: any, sensitiveKeys?: string[]): any;
+/**
+ * Serialize Error objects to plain objects for logging.
+ * @param error - The error to serialize
+ * @returns Serialized error object or original value if not an Error
+ * @example
+ * ```typescript
+ * const error = new Error('Something went wrong');
+ * const serialized = serializeError(error);
+ * // Result: { name: 'Error', message: 'Something went wrong', stack: '...' }
+ * ```
+ */
+export declare function serializeError(error: any): any;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "logan-logger",
-  "version": "1.1.3",
+  "version": "1.1.7",
   "description": "Universal TypeScript logging library for all JavaScript runtimes",
   "main": "dist/index.js",
   "module": "dist/index.esm.js",
@@ -46,15 +46,15 @@
   "author": "Logan Lindquist Land",
   "license": "MIT",
   "devDependencies": {
-    "@types/node": "^20.0.0",
-    "@typescript-eslint/eslint-plugin": "^6.0.0",
-    "@typescript-eslint/parser": "^6.0.0",
-    "@vitest/ui": "^3.0.0",
-    "eslint": "^8.0.0",
-    "typescript": "^5.0.0",
-    "vite": "^6.0.0",
-    "vite-plugin-dts": "^4.0.0",
-    "vitest": "^3.0.0"
+    "@types/node": "^20.19.17",
+    "@typescript-eslint/eslint-plugin": "^6.21.0",
+    "@typescript-eslint/parser": "^6.21.0",
+    "@vitest/ui": "^3.2.4",
+    "eslint": "^8.57.1",
+    "typescript": "^5.9.2",
+    "vite": "^6.3.6",
+    "vite-plugin-dts": "^4.5.4",
+    "vitest": "^3.2.4"
   },
   "peerDependencies": {
     "winston": "^3.8.0"
@@ -83,6 +83,7 @@
     "test:coverage": "vitest run --coverage",
     "lint": "eslint src --ext .ts",
     "typecheck": "tsc --noEmit",
+    "bump": "npm version patch",
     "publish:jsr": "deno publish --set-version ${npm_package_version:-$(npm pkg get version | tr -d '\"')}"
   }
 }