@hkdigital/lib-sveltekit 0.2.13 → 0.2.15

package/dist/classes/logging/Logger.d.ts

@@ -8,28 +8,18 @@ export default class Logger extends EventEmitter {
      *
      * @param {string} name - Name of the service/component for this logger
      * @param {string} [defaultLevel=INFO] - Initial log level threshold
+     * @param {Object} [context={}] - Default context data for all logs
      */
-    constructor(name: string, defaultLevel?: string);
+    constructor(name: string, defaultLevel?: string, context?: any);
     name: string;
     level: string;
     /**
      * Set the minimum log level threshold
      *
-     * @param {string} level - New log level (DEBUG, INFO, WARN, ERROR, FATAL,
-     *                         or NONE)
+     * @param {string} level - New log level (DEBUG, INFO, WARN, ERROR or NONE)
      * @returns {boolean} True if level was valid and set, false otherwise
      */
     setLevel(level: string): boolean;
-    /**
-     * Internal logging method
-     *
-     * @param {string} level - Log level
-     * @param {string} message - Log message
-     * @param {*} [details] - Additional details to include in the log
-     * @returns {boolean} True if the log was emitted, false if filtered
-     * @private
-     */
-    private _log;
     /**
      * Log a debug message
      *
@@ -63,12 +53,26 @@ export default class Logger extends EventEmitter {
      */
     error(message: string, details?: any): boolean;
     /**
-     * Log a fatal error message
+     * Create a child logger with additional context
+     *
+     * @param {string} namespace
+     *   Namespace of the context (needed for chaining contexts)
+     *
+     * @param {Object} additionalContext - Additional context data
      *
+     * @returns {Logger} New logger instance with merged context
+     */
+    context(namespace: string, additionalContext: any): Logger;
+    /**
+     * Internal logging method
+     *
+     * @param {string} level - Log level
      * @param {string} message - Log message
-     * @param {*} [details] - Additional details
-     * @returns {boolean} True if the log was emitted
+     * @param {*} [details] - Additional details to include in the log
+     * @returns {boolean} True if the log was emitted, false if filtered
+     * @private
      */
-    fatal(message: string, details?: any): boolean;
+    private _log;
+    #private;
 }
 import { EventEmitter } from '../events';

package/dist/classes/logging/Logger.js

@@ -34,30 +34,36 @@
 
 import { EventEmitter } from '../events';
 
-import { DEBUG, INFO, WARN, ERROR, FATAL, LEVELS } from './constants.js';
+import { DEBUG, INFO, WARN, ERROR, LEVELS } from './constants.js';
 
 /**
  * Logger class for consistent logging across services
  * @extends EventEmitter
  */
 export default class Logger extends EventEmitter {
+  #defaultContext;
+  #hasContext;
+
   /**
    * Create a new Logger instance
    *
    * @param {string} name - Name of the service/component for this logger
    * @param {string} [defaultLevel=INFO] - Initial log level threshold
+   * @param {Object} [context={}] - Default context data for all logs
    */
-  constructor(name, defaultLevel = INFO) {
+  constructor(name, defaultLevel = INFO, context = {}) {
     super();
     this.name = name;
     this.level = defaultLevel;
+
+    this.#defaultContext = structuredClone(context);
+    this.#hasContext = Object.keys(this.#defaultContext).length > 0;
   }
 
   /**
    * Set the minimum log level threshold
    *
-   * @param {string} level - New log level (DEBUG, INFO, WARN, ERROR, FATAL,
-   *                         or NONE)
+   * @param {string} level - New log level (DEBUG, INFO, WARN, ERROR or NONE)
    * @returns {boolean} True if level was valid and set, false otherwise
    */
   setLevel(level) {
@@ -70,37 +76,6 @@ export default class Logger extends EventEmitter {
     return false;
   }
 
-  /**
-   * Internal logging method
-   *
-   * @param {string} level - Log level
-   * @param {string} message - Log message
-   * @param {*} [details] - Additional details to include in the log
-   * @returns {boolean} True if the log was emitted, false if filtered
-   * @private
-   */
-  _log(level, message, details) {
-    // Check if this log level should be filtered
-    if (LEVELS[level] < LEVELS[this.level]) {
-      return false; // Below threshold, don't emit
-    }
-
-    const timestamp = new Date();
-    const logEvent = {
-      timestamp,
-      service: this.name,
-      level,
-      message,
-      details
-    };
-
-    // Emit as both specific level event and generic 'log' event
-    this.emit(level, logEvent);
-    this.emit('log', logEvent);
-
-    return true;
-  }
-
   /**
    * Log a debug message
    *
@@ -146,13 +121,57 @@ export default class Logger extends EventEmitter {
   }
 
   /**
-   * Log a fatal error message
+   * Create a child logger with additional context
+   *
+   * @param {string} namespace
+   *   Namespace of the context (needed for chaining contexts)
    *
+   * @param {Object} additionalContext - Additional context data
+   *
+   * @returns {Logger} New logger instance with merged context
+   */
+  context(namespace, additionalContext) {
+    if( typeof namespace !== "string" ) {
+      throw new Error('Invalid namespace');
+    }
+
+    const mergedContext = {
+      ...this.#defaultContext,
+      [namespace]: additionalContext
+    };
+
+    return new Logger(this.name, this.level, mergedContext);
+  }
+
+  /**
+   * Internal logging method
+   *
+   * @param {string} level - Log level
    * @param {string} message - Log message
-   * @param {*} [details] - Additional details
-   * @returns {boolean} True if the log was emitted
+   * @param {*} [details] - Additional details to include in the log
+   * @returns {boolean} True if the log was emitted, false if filtered
+   * @private
    */
-  fatal(message, details) {
-    return this._log(FATAL, message, details);
+  _log(level, message, details) {
+    // Check if this log level should be filtered
+    if (LEVELS[level] < LEVELS[this.level]) {
+      return false; // Below threshold, don't emit
+    }
+
+    const timestamp = new Date();
+    const logEvent = {
+      timestamp,
+      service: this.name,
+      level,
+      message,
+      context: this.#hasContext ? this.#defaultContext : null,
+      details
+    };
+
+    // Emit as both specific level event and generic 'log' event
+    this.emit(level, logEvent);
+    this.emit('log', logEvent);
+
+    return true;
   }
 }

package/dist/classes/logging/constants.d.ts

@@ -2,13 +2,11 @@ export const DEBUG: "debug";
 export const INFO: "info";
 export const WARN: "warn";
 export const ERROR: "error";
-export const FATAL: "fatal";
 export const NONE: "none";
 export namespace LEVELS {
     let debug: number;
     let info: number;
     let warn: number;
     let error: number;
-    let fatal: number;
     let none: number;
 }

package/dist/classes/logging/constants.js

@@ -4,7 +4,6 @@ export const DEBUG = 'debug';
 export const INFO = 'info';
 export const WARN = 'warn';
 export const ERROR = 'error';
-export const FATAL = 'fatal';
 export const NONE = 'none';
 
 // Level values for filtering (higher = more important)
@@ -13,6 +12,5 @@ export const LEVELS = {
   [INFO]: 2,
   [WARN]: 3,
   [ERROR]: 4,
-  [FATAL]: 5,
   [NONE]: 6
 };

package/dist/classes/services/ServiceManager.d.ts

@@ -40,10 +40,10 @@ export class ServiceManager extends EventEmitter {
      *
      * @param {string} name - Service name
      *
-     * @returns {import('./typedef.js').ServiceBase|null}
+     * @returns {import('./typedef.js').ServiceInstance|null}
      *   Service instance or null if not found
      */
-    get(name: string): import("./typedef.js").ServiceBase | null;
+    get(name: string): import("./typedef.js").ServiceInstance | null;
     /**
      * Initialize a service
      *
@@ -153,7 +153,7 @@ export class ServiceManager extends EventEmitter {
      *
      * @private
      * @param {string} name - Service name
-     * @param {import('./typedef.js').ServiceBase} instance
+     * @param {import('./typedef.js').ServiceInstance} instance
      *   Service instance
      */
     private _attachServiceEvents;

package/dist/classes/services/ServiceManager.js

@@ -67,6 +67,7 @@ import { EventEmitter } from '../events';
 import { Logger, DEBUG, INFO, WARN } from '../logging';
 
 import {
+  NOT_CREATED,
   CREATED,
   RUNNING,
   DESTROYED
@@ -147,6 +148,7 @@ export class ServiceManager extends EventEmitter {
     });
 
     this.services.set(name, entry);
+
     this.logger.debug(`Registered service '${name}'`, {
       dependencies: entry.dependencies,
       tags: entry.tags
@@ -158,7 +160,7 @@ export class ServiceManager extends EventEmitter {
    *
    * @param {string} name - Service name
    *
-   * @returns {import('./typedef.js').ServiceBase|null}
+   * @returns {import('./typedef.js').ServiceInstance|null}
    *   Service instance or null if not found
    */
   get(name) {
@@ -223,7 +225,9 @@ export class ServiceManager extends EventEmitter {
     // Start dependencies first
     for (const dep of entry.dependencies) {
       if (!await this.isRunning(dep)) {
+
         this.logger.debug(`Starting dependency '${dep}' for '${name}'`);
+
         const started = await this.startService(dep);
         if (!started) {
           this.logger.error(
@@ -408,6 +412,7 @@ export class ServiceManager extends EventEmitter {
    * @returns {Promise<HealthCheckResult>} Health status for all services
    */
   async checkHealth() {
+    /** @type {HealthCheckResult} */
     const health = {};
 
     for (const [name, entry] of this.services) {
@@ -416,7 +421,7 @@ export class ServiceManager extends EventEmitter {
       } else {
         health[name] = {
           name,
-          state: 'NOT_CREATED',
+          state: NOT_CREATED,
           healthy: false
         };
       }
@@ -540,7 +545,7 @@ export class ServiceManager extends EventEmitter {
    *
    * @private
    * @param {string} name - Service name
-   * @param {import('./typedef.js').ServiceBase} instance
+   * @param {import('./typedef.js').ServiceInstance} instance
    *   Service instance
    */
   _attachServiceEvents(name, instance) {

package/dist/classes/services/index.d.ts

@@ -0,0 +1,4 @@
+export { default as ServiceBase } from "./ServiceBase.js";
+export { default as ServiceManager } from "./ServiceManager.js";
+export * from "./service-states.js";
+export * from "./typedef.js";

package/dist/classes/services/index.js

@@ -0,0 +1,5 @@
+export { default as ServiceBase } from './ServiceBase.js';
+export { default as ServiceManager } from './ServiceManager.js';
+
+export * from './service-states.js';
+export * from './typedef.js';

package/dist/classes/services/service-states.d.ts

@@ -69,6 +69,11 @@ export function isInactive(state: string): boolean;
  *     break;
  * }
  */
+/**
+ * Service has not been created yet
+ * @const {string}
+ */
+export const NOT_CREATED: "not-created";
 /**
  * Service has been created but not initialized
  * @const {string}

package/dist/classes/services/service-states.js

@@ -37,6 +37,12 @@
  * }
  */
 
+/**
+ * Service has not been created yet
+ * @const {string}
+ */
+export const NOT_CREATED = 'not-created';
+
 /**
  * Service has been created but not initialized
  * @const {string}

package/dist/classes/services/typedef.d.ts

@@ -1,40 +1,12 @@
 /**
- * //
+ * Service configuration object passed to service initialization
  */
-export type ServiceConfig = import("./typedef.js").ServiceConfig;
-/**
- * class MyService extends ServiceBase {
- *   async _init(config) {
- *     // config is typed as ServiceConfig
- *   }
- *
- *   async _healthCheck() {
- *     // Return type is HealthStatus
- *     return { latency: 10 };
- *   }
- * }
- */
-export type HealthStatus = import("./typedef.js").HealthStatus;
-/**
- * //
- */
-export type ServiceManagerConfig = import("./typedef.js").ServiceManagerConfig;
-/**
- * const config = {
- *   environment: 'development',
- *   stopTimeout: 5000
- * };
- *
- * const manager = new ServiceManager(config);
- *
- * const options = {
- *   dependencies: ['database'],
- *   tags: ['critical']
- * };
- *
- * manager.register('auth', AuthService, {}, options);
- */
-export type ServiceRegistrationOptions = import("./typedef.js").ServiceRegistrationOptions;
+export type ServiceConfig = {
+    /**
+     * - Service-specific configuration properties
+     */
+    key?: any;
+};
 /**
  * Options for creating a service instance
  */
@@ -61,6 +33,35 @@ export type StopOptions = {
      */
     force?: boolean;
 };
+/**
+ * Health status returned by service health checks
+ */
+export type HealthStatus = {
+    /**
+     * - Service name
+     */
+    name: string;
+    /**
+     * - Current service state
+     */
+    state: string;
+    /**
+     * - Whether the service is healthy
+     */
+    healthy: boolean;
+    /**
+     * - Error message if unhealthy
+     */
+    error?: string;
+    /**
+     * - Error from health check itself
+     */
+    checkError?: string;
+    /**
+     * - Additional health check properties
+     */
+    key?: any;
+};
 /**
  * Event emitted when service state changes
  */
@@ -111,7 +112,49 @@ export type ServiceErrorEvent = {
 /**
  * Service class constructor type
  */
-export type ServiceConstructor = new (name: string, options?: ServiceOptions) => ServiceBase;
+export type ServiceConstructor = new (name: string, options?: ServiceOptions) => ServiceInstance;
+/**
+ * Options for registering a service
+ */
+export type ServiceRegistrationOptions = {
+    /**
+     * - Services this service depends on
+     */
+    dependencies?: string[];
+    /**
+     * - Tags for grouping services
+     */
+    tags?: string[];
+    /**
+     * - Startup priority (higher starts first)
+     */
+    priority?: number;
+};
+/**
+ * Configuration for ServiceManager
+ */
+export type ServiceManagerConfig = {
+    /**
+     * - Debug mode switch
+     */
+    debug?: boolean;
+    /**
+     * - Auto-start services on registration
+     */
+    autoStart?: boolean;
+    /**
+     * - Default timeout for stopping services
+     */
+    stopTimeout?: number;
+    /**
+     * - Initial log level for ServiceManager
+     */
+    logLevel?: string;
+    /**
+     * - Logging configuration
+     */
+    logConfig?: LogConfig;
+};
 /**
  * Logging configuration
  */
@@ -142,7 +185,7 @@ export type ServiceEntry = {
     /**
      * - Service instance (lazy-created)
      */
-    instance: ServiceBase | null;
+    instance: ServiceInstance | null;
     /**
      * - Service configuration
      */
@@ -168,12 +211,12 @@ export type ServiceEntry = {
  * Result of health check for all services
  */
 export type HealthCheckResult = {
-    [x: string]: any;
+    [x: string]: HealthStatus;
 };
 /**
  * Base class interface that services must implement
  */
-export type ServiceBase = {
+export type ServiceInstance = {
     /**
      * - Service name
      */
@@ -193,7 +236,7 @@ export type ServiceBase = {
     /**
      * - Service logger
      */
-    logger: Logger;
+    logger: import("../logging").Logger;
     initialize: (config?: ServiceConfig) => Promise<boolean>;
     start: () => Promise<boolean>;
     stop: (options?: StopOptions) => Promise<boolean>;

package/dist/classes/services/typedef.js

@@ -9,8 +9,8 @@
  * // In your service implementation
  * import { ServiceBase } from './ServiceBase.js';
  * 
- * // @typedef {import('./typedef.js').ServiceConfig} ServiceConfig
- * // @typedef {import('./typedef.js').HealthStatus} HealthStatus
+ * // @ typedef {import('./typedef.js').ServiceConfig} ServiceConfig
+ * // @ typedef {import('./typedef.js').HealthStatus} HealthStatus
  * 
  * class MyService extends ServiceBase {
  *   async _init(config) {
@@ -27,8 +27,8 @@
  * // When using ServiceManager
  * import { ServiceManager } from './ServiceManager.js';
  * 
- * // @typedef {import('./typedef.js').ServiceManagerConfig} ServiceManagerConfig
- * // @typedef {import('./typedef.js').ServiceRegistrationOptions} ServiceRegistrationOptions
+ * // @ typedef {import('./typedef.js').ServiceManagerConfig} ServiceManagerConfig
+ * // @ typedef {import('./typedef.js').ServiceRegistrationOptions} ServiceRegistrationOptions
  * 
  * const config = {
  *   environment: 'development',
@@ -47,12 +47,14 @@
 
 /**
  * Service configuration object passed to service initialization
+ *
  * @typedef {Object} ServiceConfig
- * @property {*} [*] - Service-specific configuration properties
+ * @property {*} [key] - Service-specific configuration properties
  */
 
 /**
  * Options for creating a service instance
+ *
  * @typedef {Object} ServiceOptions
  * @property {string} [logLevel] - Initial log level for the service
  * @property {number} [shutdownTimeout=5000] - Timeout for graceful shutdown
@@ -60,6 +62,7 @@
 
 /**
  * Options for stopping a service
+ *
  * @typedef {Object} StopOptions
  * @property {number} [timeout] - Override shutdown timeout
  * @property {boolean} [force=false] - Force stop even if timeout exceeded
@@ -67,17 +70,19 @@
 
 /**
  * Health status returned by service health checks
+ *
  * @typedef {Object} HealthStatus
  * @property {string} name - Service name
  * @property {string} state - Current service state
  * @property {boolean} healthy - Whether the service is healthy
  * @property {string} [error] - Error message if unhealthy
  * @property {string} [checkError] - Error from health check itself
- * @property {*} [*] - Additional health check properties
+ * @property {*} [key] - Additional health check properties
  */
 
 /**
  * Event emitted when service state changes
+ *
  * @typedef {Object} StateChangeEvent
  * @property {string} service - Service name
  * @property {string} oldState - Previous state
@@ -86,6 +91,7 @@
 
 /**
  * Event emitted when service health changes
+ *
  * @typedef {Object} HealthChangeEvent
  * @property {string} service - Service name
  * @property {boolean} healthy - New health status
@@ -93,6 +99,7 @@
 
 /**
  * Event emitted when service encounters an error
+ *
  * @typedef {Object} ServiceErrorEvent
  * @property {string} service - Service name
  * @property {string} operation - Operation that failed
@@ -101,11 +108,13 @@
 
 /**
  * Service class constructor type
- * @typedef {new (name: string, options?: ServiceOptions) => ServiceBase} ServiceConstructor
+ *
+ * @typedef {new (name: string, options?: ServiceOptions) => ServiceInstance} ServiceConstructor
  */
 
 /**
  * Options for registering a service
+ *
  * @typedef {Object} ServiceRegistrationOptions
  * @property {string[]} [dependencies=[]] - Services this service depends on
  * @property {string[]} [tags=[]] - Tags for grouping services
@@ -114,8 +123,9 @@
 
 /**
  * Configuration for ServiceManager
+ *
  * @typedef {Object} ServiceManagerConfig
- * @property {string} [environment='production'] - Runtime environment
+ * @property {boolean} [debug=false] - Debug mode switch
  * @property {boolean} [autoStart=false] - Auto-start services on registration
  * @property {number} [stopTimeout=10000] - Default timeout for stopping services
  * @property {string} [logLevel] - Initial log level for ServiceManager
@@ -124,6 +134,7 @@
 
 /**
  * Logging configuration
+ *
  * @typedef {Object} LogConfig
  * @property {string} [defaultLevel] - Default log level for services
  * @property {string} [globalLevel] - Override level for all services
@@ -132,9 +143,10 @@
 
 /**
  * Internal service registry entry
+ *
  * @typedef {Object} ServiceEntry
  * @property {ServiceConstructor} ServiceClass - Service class constructor
- * @property {ServiceBase|null} instance - Service instance (lazy-created)
+ * @property {ServiceInstance|null} instance - Service instance (lazy-created)
  * @property {ServiceConfig} config - Service configuration
  * @property {string[]} dependencies - Service dependencies
  * @property {Set<string>} dependents - Services that depend on this one
@@ -149,12 +161,13 @@
 
 /**
  * Base class interface that services must implement
- * @typedef {Object} ServiceBase
+ *
+ * @typedef {Object} ServiceInstance
  * @property {string} name - Service name
  * @property {string} state - Current state
  * @property {boolean} healthy - Health status
  * @property {Error|null} error - Last error
- * @property {Logger} logger - Service logger
+ * @property {import('../logging').Logger} logger - Service logger
  * @property {(config?: ServiceConfig) => Promise<boolean>} initialize
  * @property {() => Promise<boolean>} start
  * @property {(options?: StopOptions) => Promise<boolean>} stop

package/dist/logging/adapters/console.d.ts

@@ -0,0 +1,47 @@
+/**
+ * (Browser) console adapter that uses native DevTools styling
+ */
+export class ConsoleAdapter {
+    /**
+     * Create a new ConsoleAdapter
+     *
+     * @param {Object} [options] - Browser configuration options
+     * @param {string} [options.level] - Minimum log level
+     * @param {Object} [options.context] - Additional context data to include with all logs
+     */
+    constructor(options?: {
+        level?: string;
+        context?: any;
+    });
+    level: string;
+    context: any;
+    /**
+     * Handle log events from Logger
+     *
+     * @param {Object} logEvent - Log event from Logger
+     */
+    handleLog(logEvent: any): void;
+    /**
+     * Get CSS styles for browser console
+     *
+     * @param {string} level - Log level
+     * @returns {string} CSS styles
+     * @private
+     */
+    private _getStyles;
+    /**
+     * Get appropriate console method for log level
+     *
+     * @param {string} level - Log level
+     * @returns {string} Console method name
+     * @private
+     */
+    private _getConsoleMethod;
+    /**
+     * Create a child logger with additional context
+     *
+     * @param {Object} context - Additional context data
+     * @returns {ConsoleAdapter} New adapter instance with context
+     */
+    child(context: any): ConsoleAdapter;
+}

package/dist/logging/adapters/console.js

@@ -0,0 +1,113 @@
+import { LEVELS } from '../constants.js';
+
+/**
+ * (Browser) console adapter that uses native DevTools styling
+ */
+export class ConsoleAdapter {
+  /**
+   * Create a new ConsoleAdapter
+   *
+   * @param {Object} [options] - Browser configuration options
+   * @param {string} [options.level] - Minimum log level
+   * @param {Object} [options.context] - Additional context data to include with all logs
+   */
+  constructor(options = {}) {
+    this.level = options.level || 'info';
+    this.context = options.context || {};
+  }
+
+  /**
+   * Handle log events from Logger
+   *
+   * @param {Object} logEvent - Log event from Logger
+   */
+  handleLog(logEvent) {
+    // eslint-disable-next-line no-unused-vars
+    const { level, message, details, service, timestamp } = logEvent;
+
+    // Filter by level
+    if (LEVELS[level] < LEVELS[this.level]) {
+      return;
+    }
+
+    // Use browser console styling
+    const styles = this._getStyles(level);
+    const prefix = `%c[${service}]`;
+
+    // Merge context with details
+    const logData = details
+      ? { ...this.context, ...details }
+      : Object.keys(this.context).length > 0
+        ? this.context
+        : undefined;
+
+    if (logData) {
+      console[this._getConsoleMethod(level)](prefix, styles, message, logData);
+    } else {
+      console[this._getConsoleMethod(level)](prefix, styles, message);
+    }
+  }
+
+  /**
+   * Get CSS styles for browser console
+   *
+   * @param {string} level - Log level
+   * @returns {string} CSS styles
+   * @private
+   */
+  _getStyles(level) {
+    const baseStyle =
+      'padding: 2px 4px; border-radius: 2px; font-weight: bold;';
+
+    switch (level) {
+      case 'debug':
+        return `${baseStyle} background: #e3f2fd; color: #1976d2;`;
+      case 'info':
+        return `${baseStyle} background: #e8f5e8; color: #2e7d32;`;
+      case 'warn':
+        return `${baseStyle} background: #fff3e0; color: #f57c00;`;
+      case 'error':
+        return `${baseStyle} background: #ffebee; color: #d32f2f;`;
+      case 'fatal':
+        return `${baseStyle} background: #d32f2f; color: white;`;
+      default:
+        return baseStyle;
+    }
+  }
+
+  /**
+   * Get appropriate console method for log level
+   *
+   * @param {string} level - Log level
+   * @returns {string} Console method name
+   * @private
+   */
+  _getConsoleMethod(level) {
+    switch (level) {
+      case 'debug':
+        return 'debug';
+      case 'info':
+        return 'info';
+      case 'warn':
+        return 'warn';
+      case 'error':
+      case 'fatal':
+        return 'error';
+      default:
+        return 'log';
+    }
+  }
+
+  /**
+   * Create a child logger with additional context
+   *
+   * @param {Object} context - Additional context data
+   * @returns {ConsoleAdapter} New adapter instance with context
+   */
+  child(context) {
+    return new ConsoleAdapter({
+      level: this.level,
+      context: { ...this.context, ...context }
+    });
+  }
+}

package/dist/logging/adapters/pino.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Pino adapter that bridges Logger events to pino
+ */
+export class PinoAdapter {
+    /**
+     * Create a new PinoAdapter
+     *
+     * @param {Object} [options] - Pino configuration options
+     */
+    constructor(options?: any);
+    pino: import("pino").Logger<never, boolean>;
+    /**
+     * Handle log events from Logger
+     *
+     * @param {Object} logEvent - Log event from Logger
+     */
+    handleLog(logEvent: any): void;
+    /**
+     * Create a child logger with additional context
+     *
+     * @param {Object} context - Additional context data
+     * @returns {PinoAdapter} New adapter instance with context
+     */
+    child(context: any): PinoAdapter;
+}

package/dist/logging/adapters/pino.js

@@ -0,0 +1,60 @@
+/**
+ * Pino adapter for server-side logging
+ */
+
+import pino from 'pino';
+import { dev } from '$app/environment';
+
+/**
+ * Pino adapter that bridges Logger events to pino
+ */
+export class PinoAdapter {
+  /**
+   * Create a new PinoAdapter
+   *
+   * @param {Object} [options] - Pino configuration options
+   */
+  constructor(options = {}) {
+    const defaultOptions = dev ? {
+      level: 'debug',
+      transport: {
+        target: 'pino-pretty',
+        options: {
+          colorize: true
+        }
+      }
+    } : {};
+
+    this.pino = pino({ ...defaultOptions, ...options });
+  }
+
+  /**
+   * Handle log events from Logger
+   *
+   * @param {Object} logEvent - Log event from Logger
+   */
+  handleLog(logEvent) {
+    const { level, message, details, service, timestamp } = logEvent;
+
+    const logData = {
+      service,
+      timestamp,
+      ...(details && { details })
+    };
+
+    this.pino[level](logData, message);
+  }
+
+  /**
+   * Create a child logger with additional context
+   *
+   * @param {Object} context - Additional context data
+   * @returns {PinoAdapter} New adapter instance with context
+   */
+  child(context) {
+    const childPino = this.pino.child(context);
+    const adapter = new PinoAdapter();
+    adapter.pino = childPino;
+    return adapter;
+  }
+}

package/dist/logging/constants.d.ts

@@ -0,0 +1 @@
+export * from "../classes/logging/constants.js";

package/dist/logging/constants.js

@@ -0,0 +1 @@
+export * from '../classes/logging/constants.js';

package/dist/logging/factories/client.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Create a client-side logger with console adapter
+ *
+ * @param {string} serviceName - Name of the service
+ * @param {string} [level=INFO] - Initial log level
+ * @param {Object} [consoleOptions] - Additional console options
+ * @returns {Logger} Configured logger instance
+ */
+export function createClientLogger(serviceName: string, level?: string, consoleOptions?: any): Logger;
+import { Logger } from '../../classes/logging';

package/dist/logging/factories/client.js

@@ -0,0 +1,21 @@
+import { Logger } from '../../classes/logging';
+import { ConsoleAdapter } from '../adapters/console.js';
+import { INFO } from '../constants.js';
+
+/**
+ * Create a client-side logger with console adapter
+ *
+ * @param {string} serviceName - Name of the service
+ * @param {string} [level=INFO] - Initial log level
+ * @param {Object} [consoleOptions] - Additional console options
+ * @returns {Logger} Configured logger instance
+ */
+export function createClientLogger(serviceName, level = INFO, consoleOptions = {}) {
+  const logger = new Logger(serviceName, level);
+  const adapter = new ConsoleAdapter({ ...consoleOptions, level });
+
+  // Connect adapter to logger events
+  logger.on('log', (logEvent) => adapter.handleLog(logEvent));
+
+  return logger;
+}

package/dist/logging/factories/server.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Create a server-side logger with pino adapter
+ *
+ * @param {string} serviceName - Name of the service
+ * @param {string} [level=INFO] - Initial log level
+ * @param {Object} [pinoOptions] - Additional pino options
+ * @returns {Logger} Configured logger instance
+ */
+export function createServerLogger(serviceName: string, level?: string, pinoOptions?: any): Logger;
+import { Logger } from '../../classes/logging';

package/dist/logging/factories/server.js

@@ -0,0 +1,22 @@
+import { Logger } from '../../classes/logging';
+
+import { PinoAdapter } from '../adapters/pino.js';
+import { INFO } from '../constants.js';
+
+/**
+ * Create a server-side logger with pino adapter
+ *
+ * @param {string} serviceName - Name of the service
+ * @param {string} [level=INFO] - Initial log level
+ * @param {Object} [pinoOptions] - Additional pino options
+ * @returns {Logger} Configured logger instance
+ */
+export function createServerLogger(serviceName, level = INFO, pinoOptions = {}) {
+  const logger = new Logger(serviceName, level);
+  const adapter = new PinoAdapter(pinoOptions);
+
+  // Connect adapter to logger events
+  logger.on('log', (logEvent) => adapter.handleLog(logEvent));
+
+  return logger;
+}

package/dist/logging/factories/universal.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Create a logger that works in both server and client environments
+ *
+ * @param {string} serviceName - Name of the service
+ * @param {string} [level] - Initial log level
+ * @param {Object} [options] - Additional options
+ * @returns {Logger} Configured logger instance
+ */
+export function createLogger(serviceName: string, level?: string, options?: any): Logger;

package/dist/logging/factories/universal.js

@@ -0,0 +1,23 @@
+/**
+ * Universal logger factory that auto-detects environment
+ */
+
+import { browser } from '$app/environment';
+import { createServerLogger } from './server.js';
+import { createClientLogger } from './client.js';
+
+/**
+ * Create a logger that works in both server and client environments
+ *
+ * @param {string} serviceName - Name of the service
+ * @param {string} [level] - Initial log level
+ * @param {Object} [options] - Additional options
+ * @returns {Logger} Configured logger instance
+ */
+export function createLogger(serviceName, level, options = {}) {
+  if (browser) {
+    return createClientLogger(serviceName, level, options);
+  } else {
+    return createServerLogger(serviceName, level, options);
+  }
+}

package/dist/logging/index.d.ts

@@ -0,0 +1,4 @@
+export { createServerLogger } from "./factories/server.js";
+export { createClientLogger } from "./factories/client.js";
+export { createLogger } from "./factories/universal.js";
+export { DEBUG, INFO, WARN, ERROR, NONE, LEVELS } from "./constants.js";

package/dist/logging/index.js

@@ -0,0 +1,7 @@
+export { DEBUG, INFO, WARN, ERROR, NONE, LEVELS } from './constants.js';
+
+// Factories
+export { createServerLogger } from './factories/server.js';
+export { createClientLogger } from './factories/client.js';
+export { createLogger } from './factories/universal.js';
+

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@hkdigital/lib-sveltekit",
-	"version": "0.2.13",
+	"version": "0.2.15",
 	"author": {
 		"name": "HKdigital",
 		"url": "https://hkdigital.nl"