@lennardgeissler/logger 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,13 @@
+# 📝 Changelog
+
+All notable changes to this project will be documented in this file.
+
+## [1.0.0] - 2025-01-22
+
+### Added
+
+- Initial release
+- Core Logger functionality
+- Console, File, and Storage handlers
+- Text and JSON formatters
+- TypeScript support

package/README.md

@@ -0,0 +1,159 @@
+# @lennardgeissler/logger
+
+A flexible, extensible TypeScript logging library that works in both browser and Node.js environments. Supports multiple handlers, formatters, and log levels.
+
+## 🚀 Features
+
+- 🌟 Works in both browser and Node.js environments
+- 🎨 Customizable formatters (Text, JSON)
+- 📝 Multiple handlers (Console, File, Storage)
+- 🔍 Log levels (debug, info, warn, error, fatal)
+- 🎯 TypeScript support
+- 🧪 Well tested
+- 🔄 Singleton pattern for consistent logging
+- 💾 Browser storage support (localStorage/sessionStorage)
+
+## 🔧 Installation
+
+```bash
+npm install @lennardgeissler/logger
+```
+
+## 📖 Usage
+
+```ts
+import { Logger, ConsoleHandler, TextFormatter } from '@lennardgeissler/logger';
+// Get logger instance
+const logger = Logger.getInstance();
+// Add handler with custom formatter
+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.debug('Debug message');
+logger.warn('Warning message', { details: 'Something went wrong' });
+logger.error('Error occurred', { error: new Error('Failed to process') });
+```
+
+## 📝 Handlers
+
+### ConsoleHandler
+
+Outputs logs to the console with color support in browsers.
+
+```ts
+import { ConsoleHandler } from '@lennardgeissler/logger';
+const handler = new ConsoleHandler();
+logger.addHandler(handler);
+```
+
+### FileHandler
+
+Outputs logs to a file (Node.js environment).
+
+```ts
+import { FileHandler } from '@lennardgeissler/logger';
+const handler = new FileHandler('app.log');
+logger.addHandler(handler);
+```
+
+### StorageHandler
+
+Stores logs in browser's localStorage or sessionStorage.
+
+```ts
+import { StorageHandler } from '@lennardgeissler/logger';
+const handler = new StorageHandler(false, 'app-logs');
+logger.addHandler(handler);
+```
+
+## 🎨 Formatters
+
+### TextFormatter
+
+Formats logs as plain text using a customizable template.
+
+```ts
+import { TextFormatter } from '@lennardgeissler/logger';
+const formatter = new TextFormatter('[{timestamp}] [{level}] {message}');
+handler.setFormatter(formatter);
+```
+
+### JSONFormatter
+
+Formats logs as JSON strings.
+
+```ts
+import { JsonFormatter } from '@lennardgeissler/logger';
+const formatter = new JsonFormatter();
+handler.setFormatter(formatter);
+```
+
+## 📝 Log Levels
+
+Available log levels in order of severity:
+
+- debug
+- info
+- warn
+- error
+- fatal
+
+Set minimum log level:
+
+```ts
+logger.setLevel('warn'); // Only warn, error, and fatal will be logged
+```
+
+## 🧰 Custom Handlers
+
+Create custom handlers by extending BaseHandler:
+
+```ts
+import { BaseHandler, LogMessage } from '@lennardgeissler/logger';
+class CustomHandler extends BaseHandler {
+    handle(log: LogMessage): void {
+    // Your custom logging logic here
+    const formattedLog = this.formatter.format(log);
+    // ... handle the formatted log
+    }
+}
+```
+
+## 🎨 Custom Formatters
+
+Create custom formatters by extending BaseFormatter:
+
+```ts
+import { BaseFormatter, LogMessage } from '@lennardgeissler/logger';
+class CustomFormatter extends BaseFormatter {
+    format(log: LogMessage): string {
+        // Your custom formatting logic here
+        return `Custom format: ${log.message}`;
+    }
+}
+```
+
+## 📝 Changelog
+
+See [CHANGELOG.md](./CHANGELOG.md) for release history.
+
+## 🤝 Contributing
+
+Contributions are welcome! If you would like to contribute, please follow these steps:
+
+1. Fork the repository.
+2. Clone your fork to your local machine.
+3. Create a new branch: `git checkout -b feature/my-new-feature`.
+4. Make your changes and commit them: `git commit -am 'Add new feature'`.
+5. Push your branch to your fork: `git push origin feature/my-new-feature`.
+6. Open a pull request to merge your changes into the main repository.
+
+## 📝 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## 👨‍💻 Authors
+
+- Lennard Geissler

package/dist/components/LoggerProvider.d.ts

@@ -0,0 +1,9 @@
+import React, { 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;
+export {};

package/dist/components/LoggerProvider.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggerProvider = LoggerProvider;
+const react_1 = __importDefault(require("react"));
+const Logger_1 = require("../core/Logger");
+const LoggerContext_1 = require("../context/LoggerContext");
+const ConsoleHandler_1 = require("../handlers/ConsoleHandler");
+function LoggerProvider({ children, logger = Logger_1.Logger.getInstance(), handlers = [new ConsoleHandler_1.ConsoleHandler()] }) {
+    // Initialize logger with handlers if provided
+    react_1.default.useEffect(() => {
+        logger.clearHandlers();
+        handlers.forEach(handler => logger.addHandler(handler));
+    }, [logger, handlers]);
+    return (react_1.default.createElement(LoggerContext_1.LoggerContext.Provider, { value: logger }, children));
+}

package/dist/context/LoggerContext.d.ts

@@ -0,0 +1,2 @@
+import { Logger } from '../core/Logger';
+export declare const LoggerContext: import("react").Context<Logger | null>;

package/dist/context/LoggerContext.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggerContext = void 0;
+const react_1 = require("react");
+exports.LoggerContext = (0, react_1.createContext)(null);

package/dist/core/Logger.d.ts

@@ -0,0 +1,21 @@
+import { LogLevel } from "../types/LogLevel";
+import { BaseHandler } from "../handlers/BaseHandler";
+export declare class Logger {
+    private static instance;
+    private logLevel;
+    private handlers;
+    private constructor();
+    static getInstance(): Logger;
+    addHandler(handler: BaseHandler): void;
+    removeHandler(handler: BaseHandler): void;
+    clearHandlers(): void;
+    setLogLevel(level: LogLevel): void;
+    private shouldLog;
+    private createLogMessage;
+    private log;
+    debug(message: string, context?: Record<string, any> | null): void;
+    info(message: string, context?: Record<string, any> | null): void;
+    warn(message: string, context?: Record<string, any> | null): void;
+    error(message: string, context?: Record<string, any> | null): void;
+    fatal(message: string, context?: Record<string, any> | null): void;
+}

package/dist/core/Logger.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+const getTimestamp_1 = require("../utils/getTimestamp");
+class Logger {
+    constructor() {
+        this.logLevel = "info";
+        this.handlers = [];
+    }
+    static getInstance() {
+        if (!Logger.instance) {
+            Logger.instance = new Logger();
+        }
+        return Logger.instance;
+    }
+    addHandler(handler) {
+        this.handlers.push(handler);
+    }
+    removeHandler(handler) {
+        const index = this.handlers.indexOf(handler);
+        if (index > -1) {
+            this.handlers.splice(index, 1);
+        }
+    }
+    clearHandlers() {
+        this.handlers = [];
+    }
+    setLogLevel(level) {
+        this.logLevel = level;
+    }
+    shouldLog(level) {
+        const levels = ["debug", "info", "warn", "error", "fatal"];
+        return levels.indexOf(level) >= levels.indexOf(this.logLevel);
+    }
+    createLogMessage(level, message, context) {
+        return {
+            timestamp: (0, getTimestamp_1.getTimestamp)(),
+            level,
+            message,
+            context
+        };
+    }
+    log(level, message, context) {
+        if (!this.shouldLog(level))
+            return;
+        const logMessage = this.createLogMessage(level, message, context);
+        // If no handlers are registered, use console as fallback
+        if (this.handlers.length === 0) {
+            console.warn('No handlers registered for logger, using console as fallback');
+            console.log(`${logMessage.timestamp} [${level.toUpperCase()}]: ${message}`);
+            if (context)
+                console.log('Context:', context);
+            return;
+        }
+        // Dispatch to all handlers
+        this.handlers.forEach(handler => {
+            try {
+                handler.handle(logMessage);
+            }
+            catch (error) {
+                console.error('Error in log handler:', error);
+            }
+        });
+    }
+    debug(message, context) {
+        this.log("debug", message, context);
+    }
+    info(message, context) {
+        this.log("info", message, context);
+    }
+    warn(message, context) {
+        this.log("warn", message, context);
+    }
+    error(message, context) {
+        this.log("error", message, context);
+    }
+    fatal(message, context) {
+        this.log("fatal", message, context);
+    }
+}
+exports.Logger = Logger;

package/dist/formatters/BaseFormatter.d.ts

@@ -0,0 +1,4 @@
+import { LogMessage } from "../types/LogMessage";
+export declare abstract class BaseFormatter {
+    abstract format(log: LogMessage): string;
+}

package/dist/formatters/BaseFormatter.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseFormatter = void 0;
+class BaseFormatter {
+}
+exports.BaseFormatter = BaseFormatter;

package/dist/formatters/JsonFormatter.d.ts

@@ -0,0 +1,5 @@
+import { BaseFormatter } from "./BaseFormatter";
+import { LogMessage } from "../types/LogMessage";
+export declare class JsonFormatter extends BaseFormatter {
+    format(log: LogMessage): string;
+}

package/dist/formatters/JsonFormatter.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonFormatter = void 0;
+const BaseFormatter_1 = require("./BaseFormatter");
+class JsonFormatter extends BaseFormatter_1.BaseFormatter {
+    format(log) {
+        return JSON.stringify({
+            timestamp: log.timestamp,
+            level: log.level,
+            message: log.message,
+            context: log.context || {}
+        });
+    }
+}
+exports.JsonFormatter = JsonFormatter;

package/dist/formatters/TextFormatter.d.ts

@@ -0,0 +1,7 @@
+import { BaseFormatter } from "./BaseFormatter";
+import { LogMessage } from "../types/LogMessage";
+export declare class TextFormatter extends BaseFormatter {
+    private template;
+    constructor(template?: string);
+    format(log: LogMessage): string;
+}

package/dist/formatters/TextFormatter.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextFormatter = void 0;
+const BaseFormatter_1 = require("./BaseFormatter");
+class TextFormatter extends BaseFormatter_1.BaseFormatter {
+    constructor(template = '[{timestamp}] [{level}] {message} {context}') {
+        super();
+        this.template = template;
+    }
+    format(log) {
+        return this.template
+            .replace('{timestamp}', log.timestamp)
+            .replace('{level}', log.level.toUpperCase())
+            .replace('{message}', log.message)
+            .replace('{context}', log.context ? JSON.stringify(log.context) : '');
+    }
+}
+exports.TextFormatter = TextFormatter;

package/dist/handlers/BaseHandler.d.ts

@@ -0,0 +1,8 @@
+import { LogMessage } from "../types/LogMessage";
+import { BaseFormatter } from "../formatters/BaseFormatter";
+export declare abstract class BaseHandler {
+    protected formatter: BaseFormatter;
+    constructor(formatter?: BaseFormatter);
+    setFormatter(formatter: BaseFormatter): void;
+    abstract handle(log: LogMessage): void;
+}

package/dist/handlers/BaseHandler.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseHandler = void 0;
+const TextFormatter_1 = require("../formatters/TextFormatter");
+class BaseHandler {
+    constructor(formatter) {
+        this.formatter = formatter || new TextFormatter_1.TextFormatter();
+    }
+    setFormatter(formatter) {
+        this.formatter = formatter;
+    }
+}
+exports.BaseHandler = BaseHandler;

package/dist/handlers/ConsoleHandler.d.ts

@@ -0,0 +1,5 @@
+import { BaseHandler } from "./BaseHandler";
+import { LogMessage } from "../types/LogMessage";
+export declare class ConsoleHandler extends BaseHandler {
+    handle(log: LogMessage): void;
+}

package/dist/handlers/ConsoleHandler.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsoleHandler = void 0;
+const BaseHandler_1 = require("./BaseHandler");
+const getLogLevelColor_1 = require("../utils/getLogLevelColor");
+class ConsoleHandler extends BaseHandler_1.BaseHandler {
+    handle(log) {
+        const formattedLog = this.formatter.format(log);
+        if (typeof window !== 'undefined') {
+            // Browser environment
+            console.log(`%c${formattedLog}`, (0, getLogLevelColor_1.getLogLevelColor)(log.level));
+        }
+        else {
+            // Node.js environment
+            console.log(formattedLog);
+        }
+    }
+}
+exports.ConsoleHandler = ConsoleHandler;

package/dist/handlers/FileHandler.d.ts

@@ -0,0 +1,7 @@
+import { BaseHandler } from "./BaseHandler";
+import { LogMessage } from "../types/LogMessage";
+export declare class FileHandler extends BaseHandler {
+    private filePath;
+    constructor(filePath?: string);
+    handle(log: LogMessage): void;
+}

package/dist/handlers/FileHandler.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileHandler = void 0;
+const BaseHandler_1 = require("./BaseHandler");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+class FileHandler extends BaseHandler_1.BaseHandler {
+    constructor(filePath = "logs.txt") {
+        super();
+        this.filePath = path_1.default.resolve(filePath);
+    }
+    handle(log) {
+        const formattedLog = this.formatter.format(log) + '\n';
+        fs_1.default.appendFileSync(this.filePath, formattedLog, "utf-8");
+    }
+}
+exports.FileHandler = FileHandler;

package/dist/handlers/StorageHandler.d.ts

@@ -0,0 +1,8 @@
+import { BaseHandler } from "./BaseHandler";
+import { LogMessage } from "../types/LogMessage";
+export declare class StorageHandler extends BaseHandler {
+    private storage;
+    private key;
+    constructor(useSessionStorage?: boolean, key?: string);
+    handle(log: LogMessage): void;
+}

package/dist/handlers/StorageHandler.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StorageHandler = void 0;
+const BaseHandler_1 = require("./BaseHandler");
+class StorageHandler extends BaseHandler_1.BaseHandler {
+    constructor(useSessionStorage = false, key = "logs") {
+        super();
+        this.storage = useSessionStorage ? sessionStorage : localStorage;
+        this.key = key;
+    }
+    handle(log) {
+        const existingLogs = this.storage.getItem(this.key);
+        const logs = existingLogs ? JSON.parse(existingLogs) : [];
+        logs.push(this.formatter.format(log));
+        this.storage.setItem(this.key, JSON.stringify(logs));
+    }
+}
+exports.StorageHandler = StorageHandler;

package/dist/hooks/useLogger.d.ts

@@ -0,0 +1 @@
+export declare function useLogger(): import("..").Logger;

package/dist/hooks/useLogger.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useLogger = useLogger;
+const react_1 = require("react");
+const LoggerContext_1 = require("../context/LoggerContext");
+function useLogger() {
+    const logger = (0, react_1.useContext)(LoggerContext_1.LoggerContext);
+    if (!logger) {
+        throw new Error('useLogger must be used within a LoggerProvider');
+    }
+    return logger;
+}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export { Logger } from "./core/Logger";
+export { BaseHandler } from "./handlers/BaseHandler";
+export { ConsoleHandler } from "./handlers/ConsoleHandler";
+export { FileHandler } from "./handlers/FileHandler";
+export { StorageHandler } from "./handlers/StorageHandler";
+export { BaseFormatter } from './formatters/BaseFormatter';
+export { JsonFormatter } from './formatters/JsonFormatter';
+export { TextFormatter } from './formatters/TextFormatter';
+export type { LogLevel } from "./types/LogLevel";
+export type { LogMessage } from "./types/LogMessage";

package/dist/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextFormatter = exports.JsonFormatter = exports.BaseFormatter = exports.StorageHandler = exports.FileHandler = exports.ConsoleHandler = exports.BaseHandler = exports.Logger = void 0;
+// Core exports
+var Logger_1 = require("./core/Logger");
+Object.defineProperty(exports, "Logger", { enumerable: true, get: function () { return Logger_1.Logger; } });
+var BaseHandler_1 = require("./handlers/BaseHandler");
+Object.defineProperty(exports, "BaseHandler", { enumerable: true, get: function () { return BaseHandler_1.BaseHandler; } });
+var ConsoleHandler_1 = require("./handlers/ConsoleHandler");
+Object.defineProperty(exports, "ConsoleHandler", { enumerable: true, get: function () { return ConsoleHandler_1.ConsoleHandler; } });
+var FileHandler_1 = require("./handlers/FileHandler");
+Object.defineProperty(exports, "FileHandler", { enumerable: true, get: function () { return FileHandler_1.FileHandler; } });
+var StorageHandler_1 = require("./handlers/StorageHandler");
+Object.defineProperty(exports, "StorageHandler", { enumerable: true, get: function () { return StorageHandler_1.StorageHandler; } });
+var BaseFormatter_1 = require("./formatters/BaseFormatter");
+Object.defineProperty(exports, "BaseFormatter", { enumerable: true, get: function () { return BaseFormatter_1.BaseFormatter; } });
+var JsonFormatter_1 = require("./formatters/JsonFormatter");
+Object.defineProperty(exports, "JsonFormatter", { enumerable: true, get: function () { return JsonFormatter_1.JsonFormatter; } });
+var TextFormatter_1 = require("./formatters/TextFormatter");
+Object.defineProperty(exports, "TextFormatter", { enumerable: true, get: function () { return TextFormatter_1.TextFormatter; } });

package/dist/react/index.d.ts

@@ -0,0 +1,3 @@
+export { LoggerProvider } from '../components/LoggerProvider';
+export { useLogger } from '../hooks/useLogger';
+export { LoggerContext } from '../context/LoggerContext';

package/dist/react/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggerContext = exports.useLogger = exports.LoggerProvider = void 0;
+var LoggerProvider_1 = require("../components/LoggerProvider");
+Object.defineProperty(exports, "LoggerProvider", { enumerable: true, get: function () { return LoggerProvider_1.LoggerProvider; } });
+var useLogger_1 = require("../hooks/useLogger");
+Object.defineProperty(exports, "useLogger", { enumerable: true, get: function () { return useLogger_1.useLogger; } });
+var LoggerContext_1 = require("../context/LoggerContext");
+Object.defineProperty(exports, "LoggerContext", { enumerable: true, get: function () { return LoggerContext_1.LoggerContext; } });

package/dist/types/LogLevel.d.ts

@@ -0,0 +1 @@
+export type LogLevel = "debug" | "info" | "warn" | "error" | "fatal";

package/dist/types/LogLevel.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/LogMessage.d.ts

@@ -0,0 +1,7 @@
+import { LogLevel } from "./LogLevel";
+export interface LogMessage {
+    timestamp: string;
+    level: LogLevel;
+    message: string;
+    context?: Record<string, any> | null;
+}

package/dist/types/LogMessage.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/getLogLevelColor.d.ts

@@ -0,0 +1,2 @@
+import { LogLevel } from "../types/LogLevel";
+export declare function getLogLevelColor(level: LogLevel): string;

package/dist/utils/getLogLevelColor.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLogLevelColor = getLogLevelColor;
+function getLogLevelColor(level) {
+    switch (level) {
+        case "debug":
+            return "color: gray;";
+        case "info":
+            return "color: blue;";
+        case "warn":
+            return "color: orange;";
+        case "error":
+            return "color: red;";
+        case "fatal":
+            return "color: darkred; font-weight: bold;";
+        default:
+            return "color: black;";
+    }
+}

package/dist/utils/getTimestamp.d.ts

@@ -0,0 +1 @@
+export declare function getTimestamp(): string;

package/dist/utils/getTimestamp.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTimestamp = getTimestamp;
+function getTimestamp() {
+    return new Date().toISOString();
+}

package/package.json

@@ -0,0 +1,46 @@
+{
+  "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"
+  }
+}