@abdokouta/react-logger 1.0.0

package/dist/index.mjs

@@ -0,0 +1,886 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/enums/log-level.enum.ts
+var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+  LogLevel2[LogLevel2["Debug"] = 0] = "Debug";
+  LogLevel2[LogLevel2["Info"] = 1] = "Info";
+  LogLevel2[LogLevel2["Warn"] = 2] = "Warn";
+  LogLevel2[LogLevel2["Error"] = 3] = "Error";
+  LogLevel2[LogLevel2["Fatal"] = 4] = "Fatal";
+  return LogLevel2;
+})(LogLevel || {});
+
+// src/services/logger.service.ts
+import { Injectable, Inject } from "@abdokouta/react-di";
+
+// src/logger.ts
+var Logger = class {
+  constructor(config) {
+    __publicField(this, "config");
+    __publicField(this, "sharedContext", {});
+    this.config = config;
+    if (config.context) {
+      this.sharedContext = { ...config.context };
+    }
+  }
+  debug(message, context) {
+    this.log(LogLevel.DEBUG, message, context);
+  }
+  info(message, context) {
+    this.log(LogLevel.INFO, message, context);
+  }
+  warn(message, context) {
+    this.log(LogLevel.WARN, message, context);
+  }
+  error(message, context) {
+    this.log(LogLevel.ERROR, message, context);
+  }
+  fatal(message, context) {
+    this.log(LogLevel.FATAL, message, context);
+  }
+  withContext(context) {
+    this.sharedContext = { ...this.sharedContext, ...context };
+    return this;
+  }
+  withoutContext(keys) {
+    if (!keys) {
+      this.sharedContext = {};
+    } else {
+      for (const key of keys) {
+        delete this.sharedContext[key];
+      }
+    }
+    return this;
+  }
+  getTransporters() {
+    return this.config.transporters;
+  }
+  log(level, message, context) {
+    const entry = {
+      level,
+      message,
+      context: { ...this.sharedContext, ...context },
+      timestamp: /* @__PURE__ */ new Date()
+    };
+    for (const transporter of this.config.transporters) {
+      transporter.log(entry);
+    }
+  }
+};
+
+// src/constants/tokens.constant.ts
+var LOGGER_CONFIG = /* @__PURE__ */ Symbol("LOGGER_CONFIG");
+
+// src/services/logger.service.ts
+var LoggerService = class {
+  /**
+   * Create a new logger service
+   * 
+   * @param config - Logger configuration
+   */
+  constructor(config) {
+    /** Logger configuration */
+    __publicField(this, "config");
+    /** Cached channel instances */
+    __publicField(this, "channels", /* @__PURE__ */ new Map());
+    /** Default channel instance */
+    __publicField(this, "defaultChannel");
+    this.config = config;
+  }
+  /**
+   * Get a logger channel instance
+   * 
+   * Returns the specified channel, or the default channel if no name is provided.
+   * Channels are lazily initialized and cached.
+   * 
+   * @param name - Channel name (uses default if not specified)
+   * @returns Logger instance
+   * @throws Error if channel is not configured
+   * 
+   * @example
+   * ```typescript
+   * // Use default channel
+   * const logger = loggerService.channel();
+   * logger.info('Default message');
+   * 
+   * // Use specific channel
+   * const errorLogger = loggerService.channel('errors');
+   * errorLogger.error('Critical error');
+   * ```
+   */
+  channel(name) {
+    const channelName = name ?? this.config.default;
+    if (this.channels.has(channelName)) {
+      return this.channels.get(channelName);
+    }
+    const channel = this.resolve(channelName);
+    this.channels.set(channelName, channel);
+    return channel;
+  }
+  /**
+   * Log a message at the debug level (default channel)
+   * 
+   * @param message - The log message
+   * @param context - Optional contextual data
+   * 
+   * @example
+   * ```typescript
+   * loggerService.debug('Cache hit', { key: 'user:123' });
+   * ```
+   */
+  debug(message, context = {}) {
+    this.getDefaultChannel().debug(message, context);
+  }
+  /**
+   * Log a message at the info level (default channel)
+   * 
+   * @param message - The log message
+   * @param context - Optional contextual data
+   * 
+   * @example
+   * ```typescript
+   * loggerService.info('User logged in', { userId: '123' });
+   * ```
+   */
+  info(message, context = {}) {
+    this.getDefaultChannel().info(message, context);
+  }
+  /**
+   * Log a message at the warn level (default channel)
+   * 
+   * @param message - The log message
+   * @param context - Optional contextual data
+   * 
+   * @example
+   * ```typescript
+   * loggerService.warn('API rate limit approaching', { remaining: 10 });
+   * ```
+   */
+  warn(message, context = {}) {
+    this.getDefaultChannel().warn(message, context);
+  }
+  /**
+   * Log a message at the error level (default channel)
+   * 
+   * @param message - The log message
+   * @param context - Optional contextual data
+   * 
+   * @example
+   * ```typescript
+   * loggerService.error('Database connection failed', { error });
+   * ```
+   */
+  error(message, context = {}) {
+    this.getDefaultChannel().error(message, context);
+  }
+  /**
+   * Log a message at the fatal level (default channel)
+   * 
+   * @param message - The log message
+   * @param context - Optional contextual data
+   * 
+   * @example
+   * ```typescript
+   * loggerService.fatal('Application crashed', { error, stack });
+   * ```
+   */
+  fatal(message, context = {}) {
+    this.getDefaultChannel().fatal(message, context);
+  }
+  /**
+   * Add persistent context to the default channel
+   * 
+   * @param context - Key-value pairs to add to the shared context
+   * @returns The logger service instance for fluent chaining
+   * 
+   * @example
+   * ```typescript
+   * loggerService
+   *   .withContext({ requestId: 'abc-123' })
+   *   .withContext({ userId: 42 })
+   *   .info('Processing request');
+   * ```
+   */
+  withContext(context) {
+    this.getDefaultChannel().withContext(context);
+    return this;
+  }
+  /**
+   * Remove keys from the default channel's shared context
+   * 
+   * @param keys - Optional array of context keys to remove
+   * @returns The logger service instance for fluent chaining
+   * 
+   * @example
+   * ```typescript
+   * // Remove specific keys
+   * loggerService.withoutContext(['userId', 'requestId']);
+   * 
+   * // Clear all context
+   * loggerService.withoutContext();
+   * ```
+   */
+  withoutContext(keys) {
+    this.getDefaultChannel().withoutContext(keys);
+    return this;
+  }
+  /**
+   * Get all transporters from the default channel
+   * 
+   * @returns Array of transporter instances
+   */
+  getTransporters() {
+    return this.getDefaultChannel().getTransporters();
+  }
+  /**
+   * Get the default channel name
+   * 
+   * @returns Default channel name
+   */
+  getDefaultChannelName() {
+    return this.config.default;
+  }
+  /**
+   * Get all configured channel names
+   * 
+   * @returns Array of channel names
+   */
+  getChannelNames() {
+    return Object.keys(this.config.channels);
+  }
+  /**
+   * Check if a channel is configured
+   * 
+   * @param name - Channel name
+   * @returns True if the channel is configured
+   */
+  hasChannel(name) {
+    return name in this.config.channels;
+  }
+  /**
+   * Check if a channel is currently active (cached)
+   * 
+   * @param name - Channel name (uses default if not specified)
+   * @returns True if the channel is active
+   */
+  isChannelActive(name) {
+    const channelName = name ?? this.config.default;
+    return this.channels.has(channelName);
+  }
+  /**
+   * Get the default channel instance
+   * 
+   * @returns Logger instance
+   * @throws Error if default channel cannot be resolved
+   * @private
+   */
+  getDefaultChannel() {
+    if (this.defaultChannel) {
+      return this.defaultChannel;
+    }
+    const channelName = this.config.default;
+    if (this.channels.has(channelName)) {
+      this.defaultChannel = this.channels.get(channelName);
+      return this.defaultChannel;
+    }
+    this.defaultChannel = this.resolve(channelName);
+    this.channels.set(channelName, this.defaultChannel);
+    return this.defaultChannel;
+  }
+  /**
+   * Resolve a channel by name
+   * 
+   * Creates a new logger instance based on channel configuration.
+   * 
+   * @param name - Channel name
+   * @returns Logger instance
+   * @throws Error if channel is not configured
+   * @private
+   */
+  resolve(name) {
+    const channelConfig = this.config.channels[name];
+    if (!channelConfig) {
+      throw new Error(
+        `Logger channel [${name}] is not configured. Available channels: ${Object.keys(this.config.channels).join(", ")}`
+      );
+    }
+    return new Logger(channelConfig);
+  }
+};
+LoggerService = __decorateClass([
+  Injectable(),
+  __decorateParam(0, Inject(LOGGER_CONFIG))
+], LoggerService);
+
+// src/logger.module.ts
+import { Module, forRoot } from "@abdokouta/react-di";
+
+// src/formatters/pretty.formatter.ts
+var LEVEL_EMOJI = {
+  [0 /* Debug */]: "\u{1F41B}",
+  [1 /* Info */]: "\u2139\uFE0F",
+  [2 /* Warn */]: "\u26A0\uFE0F",
+  [3 /* Error */]: "\u274C",
+  [4 /* Fatal */]: "\u{1F480}"
+};
+var LEVEL_LABEL = {
+  [0 /* Debug */]: "DEBUG",
+  [1 /* Info */]: "INFO",
+  [2 /* Warn */]: "WARN",
+  [3 /* Error */]: "ERROR",
+  [4 /* Fatal */]: "FATAL"
+};
+var LEVEL_COLORS = {
+  [0 /* Debug */]: "color: #8B8B8B",
+  [1 /* Info */]: "color: #2196F3",
+  [2 /* Warn */]: "color: #FF9800",
+  [3 /* Error */]: "color: #F44336",
+  [4 /* Fatal */]: "color: #FFFFFF; background: #F44336; font-weight: bold; padding: 1px 4px; border-radius: 2px"
+};
+var PrettyFormatter = class {
+  /**
+   * Format a log entry into a pretty, human-readable string with
+   * emoji prefix, level badge, timestamp, message, and context.
+   *
+   * The returned string includes `%c` placeholders for CSS styling
+   * in the browser console. The ConsoleTransporter is responsible
+   * for passing the corresponding style strings.
+   *
+   * @param entry - The log entry to format.
+   * @returns The formatted string with CSS style placeholders.
+   */
+  format(entry) {
+    const emoji = LEVEL_EMOJI[entry.level];
+    const label = LEVEL_LABEL[entry.level];
+    const time = this.formatTimestamp(entry.timestamp);
+    const contextStr = this.formatContext(entry.context);
+    return `${emoji} %c[${label}]%c [${time}] ${entry.message}${contextStr}`;
+  }
+  /**
+   * Extract a short time string (HH:mm:ss.SSS) from an ISO timestamp.
+   *
+   * @param timestamp - ISO 8601 timestamp string.
+   * @returns A short time-only representation.
+   */
+  formatTimestamp(timestamp) {
+    try {
+      const date = new Date(timestamp);
+      const hours = String(date.getHours()).padStart(2, "0");
+      const minutes = String(date.getMinutes()).padStart(2, "0");
+      const seconds = String(date.getSeconds()).padStart(2, "0");
+      const ms = String(date.getMilliseconds()).padStart(3, "0");
+      return `${hours}:${minutes}:${seconds}.${ms}`;
+    } catch {
+      return timestamp;
+    }
+  }
+  /**
+   * Serialize context data into a compact, readable string.
+   * Returns an empty string when context is empty to keep output clean.
+   *
+   * @param context - The context record to serialize.
+   * @returns A formatted context string or empty string.
+   */
+  formatContext(context) {
+    const keys = Object.keys(context);
+    if (keys.length === 0) {
+      return "";
+    }
+    try {
+      return ` ${JSON.stringify(context)}`;
+    } catch {
+      return ` [context serialization failed]`;
+    }
+  }
+};
+
+// src/formatters/json.formatter.ts
+var LEVEL_STRING = {
+  [0 /* Debug */]: "debug",
+  [1 /* Info */]: "info",
+  [2 /* Warn */]: "warn",
+  [3 /* Error */]: "error",
+  [4 /* Fatal */]: "fatal"
+};
+var JsonFormatter = class {
+  /**
+   * Format a log entry as a JSON string.
+   *
+   * Produces a flat JSON object with level (as string), message,
+   * timestamp, and context fields. Context is omitted when empty
+   * to keep output compact.
+   *
+   * @param entry - The log entry to format.
+   * @returns A JSON-serialized string representation of the entry.
+   */
+  format(entry) {
+    const payload = {
+      level: LEVEL_STRING[entry.level],
+      message: entry.message,
+      timestamp: entry.timestamp
+    };
+    if (Object.keys(entry.context).length > 0) {
+      payload.context = entry.context;
+    }
+    try {
+      return JSON.stringify(payload);
+    } catch {
+      return JSON.stringify({
+        level: LEVEL_STRING[entry.level],
+        message: entry.message,
+        timestamp: entry.timestamp,
+        error: "context serialization failed"
+      });
+    }
+  }
+};
+
+// src/formatters/simple.formatter.ts
+var LEVEL_LABEL2 = {
+  [0 /* Debug */]: "DEBUG",
+  [1 /* Info */]: "INFO",
+  [2 /* Warn */]: "WARN",
+  [3 /* Error */]: "ERROR",
+  [4 /* Fatal */]: "FATAL"
+};
+var SimpleFormatter = class {
+  /**
+   * Format a log entry into a plain text line.
+   *
+   * Output pattern: `[LEVEL] [timestamp] message {context}`
+   *
+   * @param entry - The log entry to format.
+   * @returns A plain text string with no styling.
+   */
+  format(entry) {
+    const label = LEVEL_LABEL2[entry.level];
+    const contextStr = this.formatContext(entry.context);
+    return `[${label}] [${entry.timestamp}] ${entry.message}${contextStr}`;
+  }
+  /**
+   * Serialize context data into a compact string.
+   * Returns an empty string when context is empty.
+   *
+   * @param context - The context record to serialize.
+   * @returns A formatted context string or empty string.
+   */
+  formatContext(context) {
+    const keys = Object.keys(context);
+    if (keys.length === 0) {
+      return "";
+    }
+    try {
+      return ` ${JSON.stringify(context)}`;
+    } catch {
+      return " [context serialization failed]";
+    }
+  }
+};
+
+// src/transporters/silent.transporter.ts
+var SilentTransporter = class {
+  /**
+   * Create a new SilentTransporter instance.
+   * All parameters are optional and exist only for interface compliance.
+   */
+  constructor() {
+    /**
+    The formatter instance (maintained for interface compliance). */
+    __publicField(this, "_formatter");
+    /**
+    The minimum log level (maintained for interface compliance). */
+    __publicField(this, "_level");
+    this._formatter = new SimpleFormatter();
+    this._level = 0 /* Debug */;
+  }
+  /**
+   * No-op transport method. Silently discards the entry.
+   *
+   * @param _entry - The log entry (ignored).
+   */
+  transport(_entry) {
+  }
+  /**
+   * Replace the current formatter.
+   *
+   * @param formatter - The new formatter instance.
+   */
+  setFormatter(formatter) {
+    this._formatter = formatter;
+  }
+  /**
+   * Retrieve the currently assigned formatter.
+   *
+   * @returns The active formatter instance.
+   */
+  getFormatter() {
+    return this._formatter;
+  }
+  /**
+   * Get the minimum log level.
+   *
+   * @returns The current minimum LogLevel threshold.
+   */
+  getLevel() {
+    return this._level;
+  }
+  /**
+   * Set the minimum log level.
+   *
+   * @param level - The new minimum LogLevel threshold.
+   */
+  setLevel(level) {
+    this._level = level;
+  }
+};
+
+// src/transporters/console.transporter.ts
+var ConsoleTransporter = class {
+  /**
+   * Create a new ConsoleTransporter instance.
+   *
+   * @param options - Optional configuration for formatter and minimum level.
+   */
+  constructor(options = {}) {
+    /**
+    The formatter used to convert log entries into output strings. */
+    __publicField(this, "_formatter");
+    /**
+    The minimum log level threshold for this transporter. */
+    __publicField(this, "_level");
+    this._formatter = options.formatter ?? new PrettyFormatter();
+    this._level = options.level ?? 0 /* Debug */;
+  }
+  /**
+   * Deliver a log entry to the browser console.
+   *
+   * Routes the entry to the appropriate `console.*` method based on
+   * the log level. When using the PrettyFormatter, CSS styles are
+   * applied via `%c` placeholders for colored output.
+   *
+   * Entries below the configured minimum level are silently skipped.
+   *
+   * @param entry - The log entry to output.
+   */
+  transport(entry) {
+    if (entry.level < this._level) {
+      return;
+    }
+    const formatted = this._formatter.format(entry);
+    const method = this.resolveConsoleMethod(entry.level);
+    if (this._formatter instanceof PrettyFormatter) {
+      const levelStyle = LEVEL_COLORS[entry.level];
+      const resetStyle = "color: inherit";
+      method(formatted, levelStyle, resetStyle);
+    } else {
+      method(formatted);
+    }
+  }
+  /**
+   * Replace the current formatter.
+   *
+   * @param formatter - The new formatter instance to use.
+   */
+  setFormatter(formatter) {
+    this._formatter = formatter;
+  }
+  /**
+   * Retrieve the currently assigned formatter.
+   *
+   * @returns The active formatter instance.
+   */
+  getFormatter() {
+    return this._formatter;
+  }
+  /**
+   * Get the minimum log level this transporter handles.
+   *
+   * @returns The current minimum LogLevel threshold.
+   */
+  getLevel() {
+    return this._level;
+  }
+  /**
+   * Set the minimum log level this transporter handles.
+   *
+   * @param level - The new minimum LogLevel threshold.
+   */
+  setLevel(level) {
+    this._level = level;
+  }
+  /**
+   * Resolve the appropriate `console.*` method for a given log level.
+   *
+   * Maps logger severity levels to the closest browser console method
+   * to ensure proper DevTools filtering and visual distinction.
+   *
+   * @param level - The log level to resolve.
+   * @returns The bound console method function.
+   */
+  resolveConsoleMethod(level) {
+    switch (level) {
+      case 0 /* Debug */:
+        return console.debug.bind(console);
+      case 1 /* Info */:
+        return console.info.bind(console);
+      case 2 /* Warn */:
+        return console.warn.bind(console);
+      case 3 /* Error */:
+        return console.error.bind(console);
+      case 4 /* Fatal */:
+        return console.error.bind(console);
+      default:
+        return console.log.bind(console);
+    }
+  }
+};
+
+// src/logger.module.ts
+var LoggerModule = class {
+  /**
+   * Configure the logger module
+   * 
+   * @param config - Logger configuration (can be passed directly without defineConfig)
+   * @returns Dynamic module
+   * 
+   * @example
+   * ```typescript
+   * LoggerModule.forRoot({
+   *   default: 'console',
+   *   channels: {
+   *     console: {
+   *       transporters: [new ConsoleTransporter()],
+   *     },
+   *   },
+   * })
+   * ```
+   */
+  static forRoot(config) {
+    const processedConfig = LoggerModule.processConfig(config);
+    return forRoot(LoggerModule, {
+      providers: [
+        {
+          provide: LOGGER_CONFIG,
+          useValue: processedConfig
+        },
+        LoggerService
+      ],
+      exports: [LoggerService, LOGGER_CONFIG]
+    });
+  }
+  /**
+   * Process configuration to add default transporters if needed
+   * 
+   * @param config - Raw configuration
+   * @returns Processed configuration with defaults
+   * @private
+   */
+  static processConfig(config) {
+    const processedChannels = {};
+    for (const name in config.channels) {
+      if (Object.prototype.hasOwnProperty.call(config.channels, name)) {
+        const channelConfig = config.channels[name];
+        if (!channelConfig) continue;
+        if (!channelConfig.transporters || channelConfig.transporters.length === 0) {
+          if (name === "silent") {
+            processedChannels[name] = {
+              ...channelConfig,
+              transporters: [new SilentTransporter()]
+            };
+          } else {
+            processedChannels[name] = {
+              ...channelConfig,
+              transporters: [new ConsoleTransporter()]
+            };
+          }
+        } else {
+          processedChannels[name] = channelConfig;
+        }
+      }
+    }
+    return {
+      ...config,
+      channels: processedChannels
+    };
+  }
+};
+LoggerModule = __decorateClass([
+  Module({})
+], LoggerModule);
+
+// src/config/logger.config.ts
+function defineConfig(config) {
+  return config;
+}
+
+// src/transporters/storage.transporter.ts
+var DEFAULT_STORAGE_KEY = "logger:entries";
+var DEFAULT_MAX_ENTRIES = 100;
+var StorageTransporter = class {
+  /**
+   * Create a new StorageTransporter instance.
+   *
+   * @param options - Optional configuration for storage key, limits, and formatter.
+   */
+  constructor(options = {}) {
+    /**
+    The formatter used to convert log entries into storable strings. */
+    __publicField(this, "_formatter");
+    /**
+    The minimum log level threshold for this transporter. */
+    __publicField(this, "_level");
+    /**
+    The localStorage key for persisting entries. */
+    __publicField(this, "_key");
+    /**
+    Maximum number of entries to retain. */
+    __publicField(this, "_maxEntries");
+    this._formatter = options.formatter ?? new JsonFormatter();
+    this._level = options.level ?? 0 /* Debug */;
+    this._key = options.key ?? DEFAULT_STORAGE_KEY;
+    this._maxEntries = options.maxEntries ?? DEFAULT_MAX_ENTRIES;
+  }
+  /**
+   * Persist a log entry to localStorage.
+   *
+   * The entry is formatted, appended to the existing entries array,
+   * and trimmed to the maximum entry limit. If localStorage is
+   * unavailable or full, the error is silently swallowed to avoid
+   * crashing the application.
+   *
+   * @param entry - The log entry to persist.
+   */
+  transport(entry) {
+    if (entry.level < this._level) {
+      return;
+    }
+    try {
+      const formatted = this._formatter.format(entry);
+      const entries = this.readEntries();
+      entries.push(formatted);
+      while (entries.length > this._maxEntries) {
+        entries.shift();
+      }
+      localStorage.setItem(this._key, JSON.stringify(entries));
+    } catch {
+    }
+  }
+  /**
+   * Replace the current formatter.
+   *
+   * @param formatter - The new formatter instance.
+   */
+  setFormatter(formatter) {
+    this._formatter = formatter;
+  }
+  /**
+   * Retrieve the currently assigned formatter.
+   *
+   * @returns The active formatter instance.
+   */
+  getFormatter() {
+    return this._formatter;
+  }
+  /**
+   * Get the minimum log level this transporter handles.
+   *
+   * @returns The current minimum LogLevel threshold.
+   */
+  getLevel() {
+    return this._level;
+  }
+  /**
+   * Set the minimum log level this transporter handles.
+   *
+   * @param level - The new minimum LogLevel threshold.
+   */
+  setLevel(level) {
+    this._level = level;
+  }
+  /**
+   * Clear all stored log entries from localStorage.
+   * Useful for manual cleanup or when resetting application state.
+   */
+  clear() {
+    try {
+      localStorage.removeItem(this._key);
+    } catch {
+    }
+  }
+  /**
+   * Retrieve all stored log entries from localStorage.
+   *
+   * @returns An array of formatted log entry strings.
+   */
+  getEntries() {
+    return this.readEntries();
+  }
+  /**
+   * Read the current entries array from localStorage.
+   * Returns an empty array if the key does not exist or parsing fails.
+   *
+   * @returns The parsed entries array.
+   */
+  readEntries() {
+    try {
+      const raw = localStorage.getItem(this._key);
+      if (!raw) {
+        return [];
+      }
+      const parsed = JSON.parse(raw);
+      return Array.isArray(parsed) ? parsed : [];
+    } catch {
+      return [];
+    }
+  }
+};
+
+// src/hooks/use-logger/use-logger.hook.ts
+import { useInject } from "@abdokouta/react-di";
+function useLogger(channelName) {
+  const loggerService = useInject(LoggerService);
+  if (channelName) {
+    return loggerService.channel(channelName);
+  }
+  return loggerService;
+}
+
+// src/hooks/use-logger-context/use-logger-context.hook.ts
+import { useEffect } from "react";
+function useLoggerContext(context, channelName) {
+  const logger = useLogger(channelName);
+  useEffect(() => {
+    logger.withContext(context);
+    return () => {
+      logger.withoutContext(Object.keys(context));
+    };
+  }, [logger, context]);
+}
+export {
+  ConsoleTransporter,
+  JsonFormatter,
+  LogLevel,
+  LoggerService as Logger,
+  LoggerModule,
+  LoggerService,
+  PrettyFormatter,
+  SilentTransporter,
+  SimpleFormatter,
+  StorageTransporter,
+  defineConfig,
+  useLogger,
+  useLoggerContext
+};
+//# sourceMappingURL=index.mjs.map