@lennardgeissler/logger 1.0.0 → 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Lennard Geißler
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -30,7 +30,7 @@ const handler = new ConsoleHandler();
 handler.setFormatter(new TextFormatter('[{timestamp}] [{level}] {message}'));
 logger.addHandler(handler);
 // Start logging!
-logger.info('Application started', { version: '1.0.0' });
+logger.info('Application started', { version: '1.0.1' });
 logger.debug('Debug message');
 logger.warn('Warning message', { details: 'Something went wrong' });
 logger.error('Error occurred', { error: new Error('Failed to process') });
@@ -156,4 +156,4 @@ This project is licensed under the MIT License - see the [LICENSE](LICENSE) file
 
 ## 👨‍💻 Authors
 
-- Lennard Geissler
+- Lennard Geissler (@LennardGeissler)

package/dist/components/LoggerProvider.d.ts

@@ -1,9 +1,20 @@
-import React, { ReactNode } from 'react';
+import { JSX, ReactNode } from 'react';
 import { Logger } from '../core/Logger';
 interface LoggerProviderProps {
     children: ReactNode;
     logger?: Logger;
     handlers?: Array<any>;
 }
-export declare function LoggerProvider({ children, logger, handlers }: LoggerProviderProps): React.JSX.Element;
+/**
+ * A React component that provides a logging context to its child components.
+ * It initializes a logger instance and configures it with specified handlers.
+ *
+ * @param {LoggerProviderProps} props - The props for the LoggerProvider component.
+ * @param {ReactNode} props.children - The child components that will have access to the logger context.
+ * @param {Logger} [props.logger] - An optional custom logger instance. If not provided, the default singleton Logger is used.
+ * @param {Array<any>} [props.handlers] - An optional array of handlers to configure the logger. Defaults to a single ConsoleHandler.
+ *
+ * @returns {JSX.Element} A context provider wrapping the child components.
+ */
+export declare function LoggerProvider({ children, logger, handlers }: LoggerProviderProps): JSX.Element;
 export {};

package/dist/components/LoggerProvider.js

@@ -8,6 +8,17 @@ const react_1 = __importDefault(require("react"));
 const Logger_1 = require("../core/Logger");
 const LoggerContext_1 = require("../context/LoggerContext");
 const ConsoleHandler_1 = require("../handlers/ConsoleHandler");
+/**
+ * A React component that provides a logging context to its child components.
+ * It initializes a logger instance and configures it with specified handlers.
+ *
+ * @param {LoggerProviderProps} props - The props for the LoggerProvider component.
+ * @param {ReactNode} props.children - The child components that will have access to the logger context.
+ * @param {Logger} [props.logger] - An optional custom logger instance. If not provided, the default singleton Logger is used.
+ * @param {Array<any>} [props.handlers] - An optional array of handlers to configure the logger. Defaults to a single ConsoleHandler.
+ *
+ * @returns {JSX.Element} A context provider wrapping the child components.
+ */
 function LoggerProvider({ children, logger = Logger_1.Logger.getInstance(), handlers = [new ConsoleHandler_1.ConsoleHandler()] }) {
     // Initialize logger with handlers if provided
     react_1.default.useEffect(() => {

package/dist/context/LoggerContext.d.ts

@@ -1,2 +1,9 @@
 import { Logger } from '../core/Logger';
-export declare const LoggerContext: import("react").Context<Logger | null>;
+/**
+ * A React context for providing a Logger instance to components within the application.
+ * It allows child components to access and use a shared Logger instance for logging purposes.
+ *
+ * @type {React.Context<Logger | null>}
+ * @defaultValue null - The default value is `null`, indicating that no Logger instance is provided by default.
+ */
+export declare const LoggerContext: React.Context<Logger | null>;

package/dist/context/LoggerContext.js

@@ -2,4 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LoggerContext = void 0;
 const react_1 = require("react");
+/**
+ * A React context for providing a Logger instance to components within the application.
+ * It allows child components to access and use a shared Logger instance for logging purposes.
+ *
+ * @type {React.Context<Logger | null>}
+ * @defaultValue null - The default value is `null`, indicating that no Logger instance is provided by default.
+ */
 exports.LoggerContext = (0, react_1.createContext)(null);

package/dist/core/Logger.d.ts

@@ -1,21 +1,118 @@
 import { LogLevel } from "../types/LogLevel";
 import { BaseHandler } from "../handlers/BaseHandler";
+/**
+ * A singleton class for managing application logging.
+ * It supports multiple log levels, custom handlers, and centralized logging configuration.
+ */
 export declare class Logger {
     private static instance;
     private logLevel;
     private handlers;
+    /**
+     * Private constructor to prevent direct instantiation.
+     * Use `Logger.getInstance()` to obtain the singleton instance.
+     * @private
+     */
     private constructor();
+    /**
+     * Retrieves the singleton instance of the Logger.
+     *
+     * @returns {Logger} The singleton Logger instance.
+     */
     static getInstance(): Logger;
+    /**
+     * Adds a handler to the Logger.
+     *
+     * @param {BaseHandler} handler - The handler to add.
+     * @returns {void}
+     */
     addHandler(handler: BaseHandler): void;
+    /**
+     * Removes a handler from the Logger.
+     *
+     * @param {BaseHandler} handler - The handler to remove.
+     * @returns {void}
+     */
     removeHandler(handler: BaseHandler): void;
+    /**
+     * Clears all handlers from the Logger.
+     *
+     * @returns {void}
+     */
     clearHandlers(): void;
+    /**
+     * Sets the log level of the Logger. Messages below this level are ignored.
+     *
+     * @param {LogLevel} level - The log level to set.
+     * @returns {void}
+     */
     setLogLevel(level: LogLevel): void;
+    /**
+     * Determines whether a message at the specified log level should be logged.
+     *
+     * @private
+     * @param {LogLevel} level - The log level of the message.
+     * @returns {boolean} `true` if the message should be logged; otherwise, `false`.
+     */
     private shouldLog;
+    /**
+     * Creates a structured log message object.
+     *
+     * @private
+     * @param {LogLevel} level - The log level of the message.
+     * @param {string} message - The message to log.
+     * @param {Record<string, any> | null} [context] - Additional context for the log message.
+     * @returns {LogMessage} A structured log message object.
+     */
     private createLogMessage;
+    /**
+     * Logs a message at the specified level, dispatching it to the registered handlers.
+     *
+     * @private
+     * @param {LogLevel} level - The log level of the message.
+     * @param {string} message - The message to log.
+     * @param {Record<string, any> | null} [context] - Additional context for the log message.
+     * @returns {void}
+     */
     private log;
+    /**
+     * Logs a debug message.
+     *
+     * @param {string} message - The message to log.
+     * @param {Record<string, any> | null} [context] - Additional context for the log message.
+     * @returns {void}
+     */
     debug(message: string, context?: Record<string, any> | null): void;
+    /**
+     * Logs an informational message.
+     *
+     * @param {string} message - The message to log.
+     * @param {Record<string, any> | null} [context] - Additional context for the log message.
+     * @returns {void}
+     */
     info(message: string, context?: Record<string, any> | null): void;
+    /**
+     * Logs a warning message.
+     *
+     * @param {string} message - The message to log.
+     * @param {Record<string, any> | null} [context] - Additional context for the log message.
+     * @returns {void}
+     */
     warn(message: string, context?: Record<string, any> | null): void;
+    /**
+     * Logs an error message.
+     *
+     * @param {string} message - The message to log.
+     * @param {Record<string, any> | null} [context] - Additional context for the log message.
+     * @returns {void}
+     */
     error(message: string, context?: Record<string, any> | null): void;
+    /**
+     * Logs a fatal error message.
+     *
+     * @param {string} message - The message to log.
+     * @param {Record<string, any> | null} [context] - Additional context for the log message.
+     * @returns {void}
+     */
     fatal(message: string, context?: Record<string, any> | null): void;
 }

package/dist/core/Logger.js

@@ -2,36 +2,89 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Logger = void 0;
 const getTimestamp_1 = require("../utils/getTimestamp");
+/**
+ * A singleton class for managing application logging.
+ * It supports multiple log levels, custom handlers, and centralized logging configuration.
+ */
 class Logger {
+    /**
+     * Private constructor to prevent direct instantiation.
+     * Use `Logger.getInstance()` to obtain the singleton instance.
+     * @private
+     */
     constructor() {
         this.logLevel = "info";
         this.handlers = [];
     }
+    /**
+     * Retrieves the singleton instance of the Logger.
+     *
+     * @returns {Logger} The singleton Logger instance.
+     */
     static getInstance() {
         if (!Logger.instance) {
             Logger.instance = new Logger();
         }
         return Logger.instance;
     }
+    /**
+     * Adds a handler to the Logger.
+     *
+     * @param {BaseHandler} handler - The handler to add.
+     * @returns {void}
+     */
     addHandler(handler) {
         this.handlers.push(handler);
     }
+    /**
+     * Removes a handler from the Logger.
+     *
+     * @param {BaseHandler} handler - The handler to remove.
+     * @returns {void}
+     */
     removeHandler(handler) {
         const index = this.handlers.indexOf(handler);
         if (index > -1) {
             this.handlers.splice(index, 1);
         }
     }
+    /**
+     * Clears all handlers from the Logger.
+     *
+     * @returns {void}
+     */
     clearHandlers() {
         this.handlers = [];
     }
+    /**
+     * Sets the log level of the Logger. Messages below this level are ignored.
+     *
+     * @param {LogLevel} level - The log level to set.
+     * @returns {void}
+     */
     setLogLevel(level) {
         this.logLevel = level;
     }
+    /**
+     * Determines whether a message at the specified log level should be logged.
+     *
+     * @private
+     * @param {LogLevel} level - The log level of the message.
+     * @returns {boolean} `true` if the message should be logged; otherwise, `false`.
+     */
     shouldLog(level) {
         const levels = ["debug", "info", "warn", "error", "fatal"];
         return levels.indexOf(level) >= levels.indexOf(this.logLevel);
     }
+    /**
+     * Creates a structured log message object.
+     *
+     * @private
+     * @param {LogLevel} level - The log level of the message.
+     * @param {string} message - The message to log.
+     * @param {Record<string, any> | null} [context] - Additional context for the log message.
+     * @returns {LogMessage} A structured log message object.
+     */
     createLogMessage(level, message, context) {
         return {
             timestamp: (0, getTimestamp_1.getTimestamp)(),
@@ -40,6 +93,15 @@ class Logger {
             context
         };
     }
+    /**
+     * Logs a message at the specified level, dispatching it to the registered handlers.
+     *
+     * @private
+     * @param {LogLevel} level - The log level of the message.
+     * @param {string} message - The message to log.
+     * @param {Record<string, any> | null} [context] - Additional context for the log message.
+     * @returns {void}
+     */
     log(level, message, context) {
         if (!this.shouldLog(level))
             return;
@@ -62,18 +124,53 @@ class Logger {
             }
         });
     }
+    /**
+     * Logs a debug message.
+     *
+     * @param {string} message - The message to log.
+     * @param {Record<string, any> | null} [context] - Additional context for the log message.
+     * @returns {void}
+     */
     debug(message, context) {
         this.log("debug", message, context);
     }
+    /**
+     * Logs an informational message.
+     *
+     * @param {string} message - The message to log.
+     * @param {Record<string, any> | null} [context] - Additional context for the log message.
+     * @returns {void}
+     */
     info(message, context) {
         this.log("info", message, context);
     }
+    /**
+     * Logs a warning message.
+     *
+     * @param {string} message - The message to log.
+     * @param {Record<string, any> | null} [context] - Additional context for the log message.
+     * @returns {void}
+     */
     warn(message, context) {
         this.log("warn", message, context);
     }
+    /**
+     * Logs an error message.
+     *
+     * @param {string} message - The message to log.
+     * @param {Record<string, any> | null} [context] - Additional context for the log message.
+     * @returns {void}
+     */
     error(message, context) {
         this.log("error", message, context);
     }
+    /**
+     * Logs a fatal error message.
+     *
+     * @param {string} message - The message to log.
+     * @param {Record<string, any> | null} [context] - Additional context for the log message.
+     * @returns {void}
+     */
     fatal(message, context) {
         this.log("fatal", message, context);
     }

package/dist/formatters/BaseFormatter.d.ts

@@ -1,4 +1,17 @@
 import { LogMessage } from "../types/LogMessage";
+/**
+ * BaseFormatter is an abstract class that defines the structure for log message formatters.
+ * Subclasses should implement the `format` method to specify how log messages are formatted.
+ *
+ * @abstract
+ */
 export declare abstract class BaseFormatter {
+    /**
+     * Formats a log message into a string.
+     *
+     * @abstract
+     * @param {LogMessage} log - The log message to format.
+     * @returns {string} The formatted log message as a string.
+     */
     abstract format(log: LogMessage): string;
 }

package/dist/formatters/BaseFormatter.js

@@ -1,6 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseFormatter = void 0;
+/**
+ * BaseFormatter is an abstract class that defines the structure for log message formatters.
+ * Subclasses should implement the `format` method to specify how log messages are formatted.
+ *
+ * @abstract
+ */
 class BaseFormatter {
 }
 exports.BaseFormatter = BaseFormatter;

package/dist/formatters/JsonFormatter.d.ts

@@ -1,5 +1,15 @@
 import { BaseFormatter } from "./BaseFormatter";
 import { LogMessage } from "../types/LogMessage";
+/**
+ * A concrete implementation of the BaseFormatter class.
+ * It formats log messages as JSON strings for structured logging.
+ */
 export declare class JsonFormatter extends BaseFormatter {
+    /**
+     * Formats a log message into a JSON string.
+     *
+     * @param {LogMessage} log - The log message to format.
+     * @returns {string} The formatted log message as a JSON string.
+     */
     format(log: LogMessage): string;
 }

package/dist/formatters/JsonFormatter.js

@@ -2,7 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.JsonFormatter = void 0;
 const BaseFormatter_1 = require("./BaseFormatter");
+/**
+ * A concrete implementation of the BaseFormatter class.
+ * It formats log messages as JSON strings for structured logging.
+ */
 class JsonFormatter extends BaseFormatter_1.BaseFormatter {
+    /**
+     * Formats a log message into a JSON string.
+     *
+     * @param {LogMessage} log - The log message to format.
+     * @returns {string} The formatted log message as a JSON string.
+     */
     format(log) {
         return JSON.stringify({
             timestamp: log.timestamp,

package/dist/formatters/TextFormatter.d.ts

@@ -1,7 +1,23 @@
 import { BaseFormatter } from "./BaseFormatter";
 import { LogMessage } from "../types/LogMessage";
+/**
+ * A concrete implementation of the BaseFormatter class.
+ * It formats log messages into a customizable plain text format.
+ */
 export declare class TextFormatter extends BaseFormatter {
     private template;
+    /**
+     * Constructs a TextFormatter with a customizable template.
+     *
+     * @param {string} [template] - The template string for formatting log messages.
+     * @default '[{timestamp}] [{level}] {message} {context}' - The default template.
+     */
     constructor(template?: string);
+    /**
+     * Formats a log message into a string using the configured template.
+     *
+     * @param {LogMessage} log - The log message to format.
+     * @returns {string} The formatted log message as a string.
+     */
     format(log: LogMessage): string;
 }

package/dist/formatters/TextFormatter.js

@@ -2,11 +2,27 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TextFormatter = void 0;
 const BaseFormatter_1 = require("./BaseFormatter");
+/**
+ * A concrete implementation of the BaseFormatter class.
+ * It formats log messages into a customizable plain text format.
+ */
 class TextFormatter extends BaseFormatter_1.BaseFormatter {
+    /**
+     * Constructs a TextFormatter with a customizable template.
+     *
+     * @param {string} [template] - The template string for formatting log messages.
+     * @default '[{timestamp}] [{level}] {message} {context}' - The default template.
+     */
     constructor(template = '[{timestamp}] [{level}] {message} {context}') {
         super();
         this.template = template;
     }
+    /**
+     * Formats a log message into a string using the configured template.
+     *
+     * @param {LogMessage} log - The log message to format.
+     * @returns {string} The formatted log message as a string.
+     */
     format(log) {
         return this.template
             .replace('{timestamp}', log.timestamp)

package/dist/handlers/BaseHandler.d.ts

@@ -1,8 +1,33 @@
 import { LogMessage } from "../types/LogMessage";
 import { BaseFormatter } from "../formatters/BaseFormatter";
+/**
+ * An abstract class that defines the structure for log handlers.
+ * Log handlers are responsible for processing log messages, such as sending them
+ * to a destination (e.g., console, file, or remote server).
+ */
 export declare abstract class BaseHandler {
     protected formatter: BaseFormatter;
+    /**
+     * Constructs a BaseHandler with an optional formatter.
+     *
+     * @param {BaseFormatter} [formatter] - The formatter to use for this handler.
+     * @default new TextFormatter() - The default formatter.
+     */
     constructor(formatter?: BaseFormatter);
+    /**
+     * Sets the formatter for this handler.
+     *
+     * @param {BaseFormatter} formatter - The formatter to use for this handler.
+     * @returns {void}
+     */
     setFormatter(formatter: BaseFormatter): void;
+    /**
+     * Handles a log message. This method must be implemented by subclasses
+     * to define the specific behavior of the handler.
+     *
+     * @abstract
+     * @param {LogMessage} log - The log message to handle.
+     * @returns {void}
+     */
     abstract handle(log: LogMessage): void;
 }

package/dist/handlers/BaseHandler.js

@@ -2,10 +2,27 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseHandler = void 0;
 const TextFormatter_1 = require("../formatters/TextFormatter");
+/**
+ * An abstract class that defines the structure for log handlers.
+ * Log handlers are responsible for processing log messages, such as sending them
+ * to a destination (e.g., console, file, or remote server).
+ */
 class BaseHandler {
+    /**
+     * Constructs a BaseHandler with an optional formatter.
+     *
+     * @param {BaseFormatter} [formatter] - The formatter to use for this handler.
+     * @default new TextFormatter() - The default formatter.
+     */
     constructor(formatter) {
         this.formatter = formatter || new TextFormatter_1.TextFormatter();
     }
+    /**
+     * Sets the formatter for this handler.
+     *
+     * @param {BaseFormatter} formatter - The formatter to use for this handler.
+     * @returns {void}
+     */
     setFormatter(formatter) {
         this.formatter = formatter;
     }

package/dist/handlers/ConsoleHandler.d.ts

@@ -1,5 +1,15 @@
 import { BaseHandler } from "./BaseHandler";
 import { LogMessage } from "../types/LogMessage";
+/**
+ * A concrete implementation of the BaseHandler class.
+ * It logs log messages to the console with color-coded levels.
+ */
 export declare class ConsoleHandler extends BaseHandler {
+    /**
+     * Handles a log message by logging it to the console with color-coded levels.
+     *
+     * @param {LogMessage} log - The log message to handle.
+     * @returns {void}
+     */
     handle(log: LogMessage): void;
 }

package/dist/handlers/ConsoleHandler.js

@@ -3,7 +3,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConsoleHandler = void 0;
 const BaseHandler_1 = require("./BaseHandler");
 const getLogLevelColor_1 = require("../utils/getLogLevelColor");
+/**
+ * A concrete implementation of the BaseHandler class.
+ * It logs log messages to the console with color-coded levels.
+ */
 class ConsoleHandler extends BaseHandler_1.BaseHandler {
+    /**
+     * Handles a log message by logging it to the console with color-coded levels.
+     *
+     * @param {LogMessage} log - The log message to handle.
+     * @returns {void}
+     */
     handle(log) {
         const formattedLog = this.formatter.format(log);
         if (typeof window !== 'undefined') {

package/dist/handlers/FileHandler.d.ts

@@ -1,7 +1,23 @@
 import { BaseHandler } from "./BaseHandler";
 import { LogMessage } from "../types/LogMessage";
+/**
+ * A concrete implementation of the BaseHandler class.
+ * It logs log messages to a file.
+ */
 export declare class FileHandler extends BaseHandler {
     private filePath;
+    /**
+     * Constructs a FileHandler with a specified file path.
+     *
+     * @param {string} [filePath] - The path to the log file.
+     * @default "logs.txt" - The default file path.
+     */
     constructor(filePath?: string);
+    /**
+     * Handles a log message by appending it to the file.
+     *
+     * @param {LogMessage} log - The log message to handle.
+     * @returns {void}
+     */
     handle(log: LogMessage): void;
 }

package/dist/handlers/FileHandler.js

@@ -7,11 +7,27 @@ exports.FileHandler = void 0;
 const BaseHandler_1 = require("./BaseHandler");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
+/**
+ * A concrete implementation of the BaseHandler class.
+ * It logs log messages to a file.
+ */
 class FileHandler extends BaseHandler_1.BaseHandler {
+    /**
+     * Constructs a FileHandler with a specified file path.
+     *
+     * @param {string} [filePath] - The path to the log file.
+     * @default "logs.txt" - The default file path.
+     */
     constructor(filePath = "logs.txt") {
         super();
         this.filePath = path_1.default.resolve(filePath);
     }
+    /**
+     * Handles a log message by appending it to the file.
+     *
+     * @param {LogMessage} log - The log message to handle.
+     * @returns {void}
+     */
     handle(log) {
         const formattedLog = this.formatter.format(log) + '\n';
         fs_1.default.appendFileSync(this.filePath, formattedLog, "utf-8");

package/dist/handlers/StorageHandler.d.ts

@@ -1,8 +1,26 @@
 import { BaseHandler } from "./BaseHandler";
 import { LogMessage } from "../types/LogMessage";
+/**
+ * A concrete implementation of the BaseHandler class.
+ * It logs log messages to a storage (localStorage or sessionStorage).
+ */
 export declare class StorageHandler extends BaseHandler {
     private storage;
     private key;
+    /**
+     * Constructs a StorageHandler with a specified storage type and key.
+     *
+     * @param {boolean} useSessionStorage - Whether to use sessionStorage or localStorage.
+     * @param {string} key - The key to use for storing log messages.
+     * @default false - Use localStorage.
+     * @default "logs" - The default key for storing log messages.
+     */
     constructor(useSessionStorage?: boolean, key?: string);
+    /**
+     * Handles a log message by appending it to the storage.
+     *
+     * @param {LogMessage} log - The log message to handle.
+     * @returns {void}
+     */
     handle(log: LogMessage): void;
 }

package/dist/handlers/StorageHandler.js

@@ -2,12 +2,30 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StorageHandler = void 0;
 const BaseHandler_1 = require("./BaseHandler");
+/**
+ * A concrete implementation of the BaseHandler class.
+ * It logs log messages to a storage (localStorage or sessionStorage).
+ */
 class StorageHandler extends BaseHandler_1.BaseHandler {
+    /**
+     * Constructs a StorageHandler with a specified storage type and key.
+     *
+     * @param {boolean} useSessionStorage - Whether to use sessionStorage or localStorage.
+     * @param {string} key - The key to use for storing log messages.
+     * @default false - Use localStorage.
+     * @default "logs" - The default key for storing log messages.
+     */
     constructor(useSessionStorage = false, key = "logs") {
         super();
         this.storage = useSessionStorage ? sessionStorage : localStorage;
         this.key = key;
     }
+    /**
+     * Handles a log message by appending it to the storage.
+     *
+     * @param {LogMessage} log - The log message to handle.
+     * @returns {void}
+     */
     handle(log) {
         const existingLogs = this.storage.getItem(this.key);
         const logs = existingLogs ? JSON.parse(existingLogs) : [];

package/dist/hooks/useLogger.d.ts

@@ -1 +1,8 @@
-export declare function useLogger(): import("..").Logger;
+import { Logger } from '../core/Logger';
+/**
+ * Custom hook to access the Logger instance from the LoggerContext.
+ *
+ * @returns {Logger} The Logger instance.
+ * @throws {Error} If used outside of a LoggerProvider.
+ */
+export declare function useLogger(): Logger;

package/dist/hooks/useLogger.js

@@ -3,6 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.useLogger = useLogger;
 const react_1 = require("react");
 const LoggerContext_1 = require("../context/LoggerContext");
+/**
+ * Custom hook to access the Logger instance from the LoggerContext.
+ *
+ * @returns {Logger} The Logger instance.
+ * @throws {Error} If used outside of a LoggerProvider.
+ */
 function useLogger() {
     const logger = (0, react_1.useContext)(LoggerContext_1.LoggerContext);
     if (!logger) {

package/dist/react/index.d.ts

@@ -1,3 +1,7 @@
+/**
+ * Exports the LoggerProvider, useLogger, and LoggerContext from the react module.
+ * @module react
+ */
 export { LoggerProvider } from '../components/LoggerProvider';
 export { useLogger } from '../hooks/useLogger';
 export { LoggerContext } from '../context/LoggerContext';

package/dist/react/index.js

@@ -1,6 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LoggerContext = exports.useLogger = exports.LoggerProvider = void 0;
+/**
+ * Exports the LoggerProvider, useLogger, and LoggerContext from the react module.
+ * @module react
+ */
 var LoggerProvider_1 = require("../components/LoggerProvider");
 Object.defineProperty(exports, "LoggerProvider", { enumerable: true, get: function () { return LoggerProvider_1.LoggerProvider; } });
 var useLogger_1 = require("../hooks/useLogger");

package/dist/types/LogLevel.d.ts

@@ -1 +1,6 @@
+/**
+ * An enum representing the different log levels.
+ * @enum {string}
+ * @readonly
+ */
 export type LogLevel = "debug" | "info" | "warn" | "error" | "fatal";

package/dist/types/LogMessage.d.ts

@@ -1,4 +1,12 @@
 import { LogLevel } from "./LogLevel";
+/**
+ * An interface representing a log message.
+ * @interface
+ * @property {string} timestamp - The timestamp of the log message.
+ * @property {LogLevel} level - The log level of the message.
+ * @property {string} message - The log message.
+ * @property {Record<string, any> | null} context - Optional context data for the log message.
+ */
 export interface LogMessage {
     timestamp: string;
     level: LogLevel;

package/dist/utils/getLogLevelColor.d.ts

@@ -1,2 +1,7 @@
 import { LogLevel } from "../types/LogLevel";
+/**
+ * Get the color for a log level.
+ * @param {LogLevel} level - The log level.
+ * @returns {string} The color for the log level.
+ */
 export declare function getLogLevelColor(level: LogLevel): string;

package/dist/utils/getLogLevelColor.js

@@ -1,6 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getLogLevelColor = getLogLevelColor;
+/**
+ * Get the color for a log level.
+ * @param {LogLevel} level - The log level.
+ * @returns {string} The color for the log level.
+ */
 function getLogLevelColor(level) {
     switch (level) {
         case "debug":

package/dist/utils/getTimestamp.d.ts

@@ -1 +1,5 @@
+/**
+ * Get the current timestamp in ISO format.
+ * @returns {string} The current timestamp in ISO format.
+ */
 export declare function getTimestamp(): string;

package/dist/utils/getTimestamp.js

@@ -1,6 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getTimestamp = getTimestamp;
+/**
+ * Get the current timestamp in ISO format.
+ * @returns {string} The current timestamp in ISO format.
+ */
 function getTimestamp() {
     return new Date().toISOString();
 }

package/package.json

@@ -1,46 +1,50 @@
-{
-  "name": "@lennardgeissler/logger",
-  "version": "1.0.0",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "files": [
-    "dist",
-    "README.md",
-    "CHANGELOG.md",
-    "LICENSE"
-  ],
-  "scripts": {
-    "clean": "if exist dist rd /s /q dist",
-    "build": "npm run clean && tsc",
-    "test": "jest",
-    "test:watch": "jest --watch",
-    "test:coverage": "jest --coverage",
-    "prepublishOnly": "npm test && npm run build",
-    "preversion": "npm test",
-    "postversion": "git push && git push --tags"
-  },
-  "keywords": [
-    "logging",
-    "typescript",
-    "react",
-    "node"
-  ],
-  "author": "Lennard Geißler",
-  "license": "MIT",
-  "type": "commonjs",
-  "description": "",
-  "devDependencies": {
-    "@types/jest": "^29.5.14",
-    "@types/node": "^22.10.7",
-    "@types/react": "^19.0.7",
-    "@types/react-dom": "^19.0.3",
-    "@vitejs/plugin-react": "^4.3.4",
-    "jest": "^29.7.0",
-    "ts-jest": "^29.2.5",
-    "typescript": "^5.7.3"
-  },
-  "peerDependencies": {
-    "react": "^19.0.0",
-    "react-dom": "^19.0.0"
-  }
-}
+{
+  "name": "@lennardgeissler/logger",
+  "version": "1.0.1",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "clean": "if exist dist rd /s /q dist",
+    "build": "npm run clean && tsc",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "prepublishOnly": "npm test && npm run build",
+    "preversion": "npm test",
+    "postversion": "git push && git push --tags"
+  },
+  "keywords": [
+    "logging",
+    "typescript",
+    "react",
+    "node"
+  ],
+  "author": "Lennard Geißler",
+  "license": "MIT",
+  "type": "commonjs",
+  "description": "",
+  "devDependencies": {
+    "@types/jest": "^29.5.14",
+    "@types/node": "^22.10.7",
+    "@types/react": "^19.0.7",
+    "@types/react-dom": "^19.0.3",
+    "@vitejs/plugin-react": "^4.3.4",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.2.5",
+    "typescript": "^5.7.3"
+  },
+  "peerDependencies": {
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/lennardgeissler/logger.git"
+  }
+}