@x-oasis/log 0.1.2 → 0.1.4

package/package.json

@@ -1,13 +1,23 @@
 {
   "name": "@x-oasis/log",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "A friendly logging library for browser environments",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
   "module": "dist/log.esm.js",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/log.esm.js",
+      "require": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
   "files": [
     "dist",
-    "index.ts"
+    "index.ts",
+    "src"
   ],
   "publishConfig": {
     "access": "public"

package/src/index.ts

@@ -0,0 +1,39 @@
+import { Logger } from './logger';
+import { LogLevel } from './types';
+
+export { Logger, LogLevel };
+export type {
+  LogEntry,
+  LoggerOptions,
+  LoggerChain,
+  OutputHandler,
+} from './types';
+
+/**
+ * Default logger instance
+ */
+export const defaultLogger = new Logger();
+
+/**
+ * Convenience methods using the default logger
+ */
+export const log = {
+  trace: (message: string, context?: Record<string, unknown>) =>
+    defaultLogger.trace(message, context),
+  debug: (message: string, context?: Record<string, unknown>) =>
+    defaultLogger.debug(message, context),
+  info: (message: string, context?: Record<string, unknown>) =>
+    defaultLogger.info(message, context),
+  warn: (message: string, context?: Record<string, unknown>) =>
+    defaultLogger.warn(message, context),
+  error: (message: string, context?: Record<string, unknown>) =>
+    defaultLogger.error(message, context),
+  setLevel: (level: LogLevel | keyof typeof LogLevel) =>
+    defaultLogger.setLevel(level),
+  withContext: (context: Record<string, unknown>) =>
+    defaultLogger.withContext(context),
+  withPrefix: (prefix: string) => defaultLogger.withPrefix(prefix),
+  chain: () => defaultLogger.chain(),
+};
+
+export default Logger;

package/src/logger.ts

@@ -0,0 +1,247 @@
+import {
+  LogLevel,
+  LogEntry,
+  LoggerOptions,
+  LoggerChain,
+  OutputHandler,
+} from './types';
+import { parseLogLevel, createConsoleHandler } from './utils';
+
+/**
+ * Main Logger class
+ */
+export class Logger {
+  private level: LogLevel;
+  private handler: OutputHandler;
+  private enableTimestamp: boolean;
+  private defaultContext?: Record<string, unknown>;
+  private defaultPrefix?: string;
+
+  constructor(options: LoggerOptions = {}) {
+    this.level = options.level ? parseLogLevel(options.level) : LogLevel.INFO;
+    this.handler = options.handler || createConsoleHandler();
+    this.enableTimestamp =
+      options.enableTimestamp !== undefined ? options.enableTimestamp : true;
+    this.defaultContext = options.defaultContext;
+    this.defaultPrefix = options.defaultPrefix;
+  }
+
+  /**
+   * Set the minimum log level
+   */
+  setLevel(level: LogLevel | keyof typeof LogLevel): void {
+    this.level = parseLogLevel(level);
+  }
+
+  /**
+   * Get the current log level
+   */
+  getLevel(): LogLevel {
+    return this.level;
+  }
+
+  /**
+   * Set a custom output handler
+   */
+  setHandler(handler: OutputHandler): void {
+    this.handler = handler;
+  }
+
+  /**
+   * Set default context that will be included in all logs
+   */
+  setDefaultContext(context: Record<string, unknown>): void {
+    this.defaultContext = context;
+  }
+
+  /**
+   * Set default prefix for all log messages
+   */
+  setDefaultPrefix(prefix: string): void {
+    this.defaultPrefix = prefix;
+  }
+
+  /**
+   * Create a chainable logger instance
+   */
+  chain(): LoggerChain {
+    return new LoggerChainBuilder(this);
+  }
+
+  /**
+   * Log at trace level
+   */
+  trace(message: string, context?: Record<string, unknown>): void {
+    this.log(LogLevel.TRACE, message, context);
+  }
+
+  /**
+   * Log at debug level
+   */
+  debug(message: string, context?: Record<string, unknown>): void {
+    this.log(LogLevel.DEBUG, message, context);
+  }
+
+  /**
+   * Log at info level
+   */
+  info(message: string, context?: Record<string, unknown>): void {
+    this.log(LogLevel.INFO, message, context);
+  }
+
+  /**
+   * Log at warn level
+   */
+  warn(message: string, context?: Record<string, unknown>): void {
+    this.log(LogLevel.WARN, message, context);
+  }
+
+  /**
+   * Log at error level
+   */
+  error(message: string, context?: Record<string, unknown>): void {
+    this.log(LogLevel.ERROR, message, context);
+  }
+
+  /**
+   * Internal log method
+   */
+  private log(
+    level: LogLevel,
+    message: string,
+    context?: Record<string, unknown>
+  ): void {
+    if (level < this.level) {
+      return;
+    }
+
+    const entry: LogEntry = {
+      level,
+      message,
+      timestamp: this.enableTimestamp ? Date.now() : 0,
+      prefix: this.defaultPrefix,
+    };
+
+    // Merge default context with provided context
+    if (this.defaultContext || context) {
+      entry.context = {
+        ...this.defaultContext,
+        ...context,
+      };
+    }
+
+    this.handler(entry);
+  }
+
+  /**
+   * Create a chainable logger with initial context
+   */
+  withContext(context: Record<string, unknown>): LoggerChain {
+    return new LoggerChainBuilder(this).withContext(context);
+  }
+
+  /**
+   * Create a chainable logger with initial prefix
+   */
+  withPrefix(prefix: string): LoggerChain {
+    return new LoggerChainBuilder(this).withPrefix(prefix);
+  }
+}
+
+/**
+ * Chainable logger builder
+ */
+class LoggerChainBuilder implements LoggerChain {
+  private logger: Logger;
+  private context?: Record<string, unknown>;
+  private metadata?: Record<string, unknown>;
+  private errorObj?: Error;
+  private prefix?: string;
+
+  constructor(logger: Logger) {
+    this.logger = logger;
+  }
+
+  withContext(context: Record<string, unknown>): LoggerChain {
+    this.context = {
+      ...this.context,
+      ...context,
+    };
+    return this;
+  }
+
+  withMetadata(metadata: Record<string, unknown>): LoggerChain {
+    this.metadata = {
+      ...this.metadata,
+      ...metadata,
+    };
+    return this;
+  }
+
+  withError(error: Error): LoggerChain {
+    this.errorObj = error;
+    return this;
+  }
+
+  withPrefix(prefix: string): LoggerChain {
+    this.prefix = prefix;
+    return this;
+  }
+
+  private createEntry(level: LogLevel, message: string): LogEntry {
+    const entry: LogEntry = {
+      level,
+      message,
+      timestamp: this.logger['enableTimestamp'] ? Date.now() : 0,
+      prefix: this.prefix || this.logger['defaultPrefix'],
+    };
+
+    // Merge contexts
+    const defaultContext = this.logger['defaultContext'];
+    if (defaultContext || this.context) {
+      entry.context = {
+        ...defaultContext,
+        ...this.context,
+      };
+    }
+
+    if (this.metadata) {
+      entry.metadata = this.metadata;
+    }
+
+    if (this.errorObj) {
+      entry.error = this.errorObj;
+    }
+
+    return entry;
+  }
+
+  private log(level: LogLevel, message: string): void {
+    if (level < this.logger.getLevel()) {
+      return;
+    }
+
+    const entry = this.createEntry(level, message);
+    this.logger['handler'](entry);
+  }
+
+  trace(message: string): void {
+    this.log(LogLevel.TRACE, message);
+  }
+
+  debug(message: string): void {
+    this.log(LogLevel.DEBUG, message);
+  }
+
+  info(message: string): void {
+    this.log(LogLevel.INFO, message);
+  }
+
+  warn(message: string): void {
+    this.log(LogLevel.WARN, message);
+  }
+
+  error(message: string): void {
+    this.log(LogLevel.ERROR, message);
+  }
+}

package/src/types.ts

@@ -0,0 +1,109 @@
+/**
+ * Log levels in order of severity
+ */
+export enum LogLevel {
+  TRACE = 0,
+  DEBUG = 1,
+  INFO = 2,
+  WARN = 3,
+  ERROR = 4,
+  SILENT = 5,
+}
+
+/**
+ * Log entry data structure
+ */
+export interface LogEntry {
+  level: LogLevel;
+  message: string;
+  timestamp: number;
+  context?: Record<string, unknown>;
+  metadata?: Record<string, unknown>;
+  error?: Error;
+  prefix?: string;
+}
+
+/**
+ * Output handler function type
+ */
+export type OutputHandler = (entry: LogEntry) => void;
+
+/**
+ * Logger configuration options
+ */
+export interface LoggerOptions {
+  /**
+   * Minimum log level to output (default: LogLevel.INFO)
+   */
+  level?: LogLevel | keyof typeof LogLevel;
+
+  /**
+   * Custom output handler (default: console)
+   */
+  handler?: OutputHandler;
+
+  /**
+   * Enable timestamps in log entries (default: true)
+   */
+  enableTimestamp?: boolean;
+
+  /**
+   * Default context that will be included in all logs
+   */
+  defaultContext?: Record<string, unknown>;
+
+  /**
+   * Default prefix for all log messages
+   */
+  defaultPrefix?: string;
+}
+
+/**
+ * Chainable logger interface
+ */
+export interface LoggerChain {
+  /**
+   * Add context data that will be included in this log entry
+   */
+  withContext(context: Record<string, unknown>): LoggerChain;
+
+  /**
+   * Add metadata that will be included in this log entry
+   */
+  withMetadata(metadata: Record<string, unknown>): LoggerChain;
+
+  /**
+   * Add an error object to this log entry
+   */
+  withError(error: Error): LoggerChain;
+
+  /**
+   * Add a prefix to this log message
+   */
+  withPrefix(prefix: string): LoggerChain;
+
+  /**
+   * Log at trace level
+   */
+  trace(message: string): void;
+
+  /**
+   * Log at debug level
+   */
+  debug(message: string): void;
+
+  /**
+   * Log at info level
+   */
+  info(message: string): void;
+
+  /**
+   * Log at warn level
+   */
+  warn(message: string): void;
+
+  /**
+   * Log at error level
+   */
+  error(message: string): void;
+}

package/src/utils.ts

@@ -0,0 +1,63 @@
+import { LogLevel, LogEntry } from './types';
+
+/**
+ * Convert log level string to LogLevel enum
+ */
+export function parseLogLevel(
+  level: LogLevel | keyof typeof LogLevel
+): LogLevel {
+  if (typeof level === 'number') {
+    return level;
+  }
+  return LogLevel[level] ?? LogLevel.INFO;
+}
+
+/**
+ * Get log level name
+ */
+export function getLogLevelName(level: LogLevel): string {
+  return LogLevel[level] ?? 'UNKNOWN';
+}
+
+/**
+ * Default console output handler
+ */
+export function createConsoleHandler(): (entry: LogEntry) => void {
+  const consoleMethods: Record<number, typeof console.log> = {
+    [LogLevel.TRACE]: console.trace || console.debug,
+    [LogLevel.DEBUG]: console.debug,
+    [LogLevel.INFO]: console.info,
+    [LogLevel.WARN]: console.warn,
+    [LogLevel.ERROR]: console.error,
+  };
+
+  return (entry) => {
+    const method = consoleMethods[entry.level] || console.log;
+    const parts: unknown[] = [];
+
+    // Add prefix if present
+    if (entry.prefix) {
+      parts.push(entry.prefix);
+    }
+
+    // Add message
+    parts.push(entry.message);
+
+    // Add context if present
+    if (entry.context && Object.keys(entry.context).length > 0) {
+      parts.push('\nContext:', entry.context);
+    }
+
+    // Add metadata if present
+    if (entry.metadata && Object.keys(entry.metadata).length > 0) {
+      parts.push('\nMetadata:', entry.metadata);
+    }
+
+    // Add error if present
+    if (entry.error) {
+      parts.push('\nError:', entry.error);
+    }
+
+    method(...parts);
+  };
+}