@hamak/logging-api 0.4.0

package/dist/api/index.d.ts

@@ -0,0 +1,4 @@
+export * from './logger.js';
+export * from './transport.js';
+export * from './manager.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/api/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/api/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC"}

package/dist/api/index.js

@@ -0,0 +1,3 @@
+export * from './logger.js';
+export * from './transport.js';
+export * from './manager.js';

package/dist/api/logger.d.ts

@@ -0,0 +1,105 @@
+import { LogLevel, LogContext, LogMetadata } from '../types/index.js';
+/**
+ * Core logging interface
+ *
+ * All logging in the application should go through this interface.
+ * Context is automatically tracked and can be extended with child loggers.
+ *
+ * @example
+ * ```typescript
+ * const logger = logManager.createLogger({ plugin: 'my-plugin' });
+ * logger.info('Application started');
+ * logger.debug('Config loaded', { config: myConfig });
+ *
+ * // Create child logger with additional context
+ * const moduleLogger = logger.child({ module: 'auth' });
+ * moduleLogger.warn('Failed login attempt', { userId: '123' });
+ * ```
+ */
+export interface ILogger {
+    /**
+     * Log a trace message (most verbose)
+     * Use for very detailed debugging information
+     */
+    trace(message: string, meta?: LogMetadata): void;
+    /**
+     * Log a debug message
+     * Use for debugging information useful during development
+     */
+    debug(message: string, meta?: LogMetadata): void;
+    /**
+     * Log an informational message
+     * Use for general application flow information
+     */
+    info(message: string, meta?: LogMetadata): void;
+    /**
+     * Log a warning message
+     * Use for potentially harmful situations
+     */
+    warn(message: string, meta?: LogMetadata): void;
+    /**
+     * Log an error message
+     * Use for error events that might still allow the app to continue
+     */
+    error(message: string, error?: Error, meta?: LogMetadata): void;
+    /**
+     * Log a fatal error message
+     * Use for severe errors that will likely lead to application abort
+     */
+    fatal(message: string, error?: Error, meta?: LogMetadata): void;
+    /**
+     * Create a child logger with additional context
+     * The child inherits all context from the parent and adds new context
+     *
+     * @example
+     * ```typescript
+     * const pluginLogger = logger.child({ plugin: 'auth' });
+     * const moduleLogger = pluginLogger.child({ module: 'login' });
+     * // moduleLogger has context: { plugin: 'auth', module: 'login' }
+     * ```
+     */
+    child(context: LogContext): ILogger;
+    /**
+     * Execute a function with temporary additional context
+     * Useful for scoped operations
+     *
+     * @example
+     * ```typescript
+     * logger.scoped({ requestId: '123' }, (scopedLogger) => {
+     *   scopedLogger.info('Processing request');
+     *   // logs will include requestId: '123'
+     * });
+     * ```
+     */
+    scoped(context: LogContext, fn: (logger: ILogger) => void): void;
+    /**
+     * Check if a log level is enabled
+     * Useful for expensive operations that should only run if logging is enabled
+     *
+     * @example
+     * ```typescript
+     * if (logger.isLevelEnabled(LogLevel.DEBUG)) {
+     *   logger.debug('Expensive data', expensiveSerialize(data));
+     * }
+     * ```
+     */
+    isLevelEnabled(level: LogLevel): boolean;
+    /**
+     * Start a performance timer
+     * Call timeEnd() with the same label to log the duration
+     *
+     * @example
+     * ```typescript
+     * logger.time('database-query');
+     * await db.query('SELECT * FROM users');
+     * logger.timeEnd('database-query'); // logs duration
+     * ```
+     */
+    time(label: string): void;
+    /**
+     * End a performance timer and log the duration
+     * Must be called after time() with the same label
+     */
+    timeEnd(label: string): void;
+}
+//# sourceMappingURL=logger.d.ts.map

package/dist/api/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/api/logger.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEtE;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,OAAO;IACtB;;;OAGG;IACH,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC;IAEjD;;;OAGG;IACH,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC;IAEjD;;;OAGG;IACH,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC;IAEhD;;;OAGG;IACH,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC;IAEhD;;;OAGG;IACH,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC;IAEhE;;;OAGG;IACH,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC;IAEhE;;;;;;;;;;OAUG;IACH,KAAK,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC;IAEpC;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,OAAO,EAAE,UAAU,EAAE,EAAE,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,IAAI,GAAG,IAAI,CAAC;IAEjE;;;;;;;;;;OAUG;IACH,cAAc,CAAC,KAAK,EAAE,QAAQ,GAAG,OAAO,CAAC;IAEzC;;;;;;;;;;OAUG;IACH,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAE1B;;;OAGG;IACH,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CAC9B"}

package/dist/api/logger.js

@@ -0,0 +1 @@
+export {};

package/dist/api/manager.d.ts

@@ -0,0 +1,120 @@
+import { ILogger } from './logger.js';
+import { ILogTransport } from './transport.js';
+import { LogLevel, LogContext, TransportConfig, LogEntry } from '../types/index.js';
+/**
+ * Log manager interface
+ *
+ * The central coordinator for the logging system.
+ * Manages transports, creates loggers, and dispatches log entries.
+ *
+ * @example
+ * ```typescript
+ * const logManager = new LogManager({ globalLevel: LogLevel.DEBUG });
+ *
+ * // Register transports
+ * logManager.registerTransport(new ConsoleTransport());
+ * logManager.registerTransport(new RemoteTransport(config));
+ *
+ * // Create loggers
+ * const logger = logManager.createLogger({ plugin: 'my-plugin' });
+ * logger.info('Application started');
+ * ```
+ */
+export interface ILogManager {
+    /**
+     * Register a transport
+     * @param transport The transport to register
+     * @param config Optional configuration for this transport
+     */
+    registerTransport(transport: ILogTransport, config?: TransportConfig): void;
+    /**
+     * Unregister a transport by ID
+     * @param id Transport identifier
+     */
+    unregisterTransport(id: string): void;
+    /**
+     * Get a transport by ID
+     * @param id Transport identifier
+     * @returns The transport or undefined if not found
+     */
+    getTransport(id: string): ILogTransport | undefined;
+    /**
+     * Get all registered transports
+     * @returns Array of all transports
+     */
+    listTransports(): ILogTransport[];
+    /**
+     * Create a new logger with the given context
+     * Creates a new logger instance each time
+     *
+     * @param context Initial context for the logger
+     * @returns A new logger instance
+     */
+    createLogger(context?: LogContext): ILogger;
+    /**
+     * Get or create a cached logger for the given context
+     * Returns the same logger instance for the same context
+     *
+     * @param context Context for the logger
+     * @returns A cached logger instance
+     */
+    getLogger(context?: LogContext): ILogger;
+    /**
+     * Set the global minimum log level
+     * Logs below this level will be ignored (unless overridden by plugin/module)
+     *
+     * @param level The minimum log level
+     */
+    setGlobalLevel(level: LogLevel): void;
+    /**
+     * Set the minimum log level for a specific plugin
+     *
+     * @param plugin Plugin name
+     * @param level Minimum log level for this plugin
+     */
+    setPluginLevel(plugin: string, level: LogLevel): void;
+    /**
+     * Set the minimum log level for a specific module
+     *
+     * @param module Module name
+     * @param level Minimum log level for this module
+     */
+    setModuleLevel(module: string, level: LogLevel): void;
+    /**
+     * Flush all buffered logs to all transports
+     * @returns Promise that resolves when all logs are flushed
+     */
+    flush(): Promise<void>;
+    /**
+     * Clear the internal log buffer
+     * Useful for testing or memory management
+     */
+    clearBuffer(): void;
+    /**
+     * Register an event listener
+     * Events: 'log', 'error', 'flush'
+     *
+     * @example
+     * ```typescript
+     * logManager.on('log', (entry: LogEntry) => {
+     *   console.log('Log captured:', entry);
+     * });
+     * ```
+     */
+    on(event: 'log' | 'error' | 'flush', handler: (...args: any[]) => void): void;
+    /**
+     * Remove an event listener
+     *
+     * @param event Event name
+     * @param handler Handler function to remove
+     */
+    off(event: string, handler: (...args: any[]) => void): void;
+    /**
+     * Dispatch a log entry to all transports
+     * Internal method used by loggers
+     *
+     * @param entry The log entry to dispatch
+     */
+    dispatch(entry: LogEntry): void;
+}
+//# sourceMappingURL=manager.d.ts.map

package/dist/api/manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manager.d.ts","sourceRoot":"","sources":["../../src/api/manager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AACtC,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAEpF;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,WAAW,WAAW;IAC1B;;;;OAIG;IACH,iBAAiB,CAAC,SAAS,EAAE,aAAa,EAAE,MAAM,CAAC,EAAE,eAAe,GAAG,IAAI,CAAC;IAE5E;;;OAGG;IACH,mBAAmB,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;IAEtC;;;;OAIG;IACH,YAAY,CAAC,EAAE,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS,CAAC;IAEpD;;;OAGG;IACH,cAAc,IAAI,aAAa,EAAE,CAAC;IAElC;;;;;;OAMG;IACH,YAAY,CAAC,OAAO,CAAC,EAAE,UAAU,GAAG,OAAO,CAAC;IAE5C;;;;;;OAMG;IACH,SAAS,CAAC,OAAO,CAAC,EAAE,UAAU,GAAG,OAAO,CAAC;IAEzC;;;;;OAKG;IACH,cAAc,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI,CAAC;IAEtC;;;;;OAKG;IACH,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,GAAG,IAAI,CAAC;IAEtD;;;;;OAKG;IACH,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,GAAG,IAAI,CAAC;IAEtD;;;OAGG;IACH,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAEvB;;;OAGG;IACH,WAAW,IAAI,IAAI,CAAC;IAEpB;;;;;;;;;;OAUG;IACH,EAAE,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,GAAG,OAAO,EAAE,OAAO,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,GAAG,IAAI,CAAC;IAE9E;;;;;OAKG;IACH,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,GAAG,IAAI,CAAC;IAE5D;;;;;OAKG;IACH,QAAQ,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI,CAAC;CACjC"}

package/dist/api/manager.js

@@ -0,0 +1 @@
+export {};

package/dist/api/transport.d.ts

@@ -0,0 +1,97 @@
+import { LogEntry } from '../types/index.js';
+/**
+ * Log transport interface
+ *
+ * Transports are responsible for outputting logs to different destinations
+ * (console, file, remote API, event bus, etc.)
+ *
+ * @example
+ * ```typescript
+ * class MyCustomTransport implements ILogTransport {
+ *   readonly id = 'my-transport';
+ *   readonly name = 'My Custom Transport';
+ *
+ *   log(entry: LogEntry): void {
+ *     // Send log to custom destination
+ *     myService.sendLog(entry);
+ *   }
+ *
+ *   async flush(): Promise<void> {
+ *     await myService.flushBuffer();
+ *   }
+ * }
+ * ```
+ */
+export interface ILogTransport {
+    /** Unique identifier for the transport */
+    readonly id: string;
+    /** Human-readable name */
+    readonly name: string;
+    /**
+     * Handle a log entry
+     * Can be synchronous or asynchronous
+     */
+    log(entry: LogEntry): void | Promise<void>;
+    /**
+     * Flush any buffered logs
+     * Optional - implement if transport buffers logs
+     */
+    flush?(): Promise<void>;
+    /**
+     * Close the transport and release resources
+     * Optional - implement if transport needs cleanup
+     */
+    close?(): Promise<void>;
+    /**
+     * Determine if this transport should handle a log entry
+     * Optional - implement for custom filtering beyond TransportConfig
+     *
+     * @example
+     * ```typescript
+     * shouldLog(entry: LogEntry): boolean {
+     *   // Only log errors from production
+     *   return entry.level >= LogLevel.ERROR &&
+     *          entry.context.environment === 'production';
+     * }
+     * ```
+     */
+    shouldLog?(entry: LogEntry): boolean;
+    /**
+     * Handle transport errors
+     * Optional - implement for custom error handling
+     *
+     * @example
+     * ```typescript
+     * onError(error: Error): void {
+     *   console.error('[Transport Error]', error);
+     *   // Maybe send to error tracking service
+     * }
+     * ```
+     */
+    onError?(error: Error): void;
+}
+/**
+ * Log formatter interface
+ *
+ * Formatters convert LogEntry objects into formatted strings
+ * for display or transmission.
+ */
+export interface ILogFormatter {
+    /**
+     * Format a log entry into a string
+     *
+     * @example
+     * ```typescript
+     * format(entry: LogEntry): string {
+     *   return `[${entry.level}] ${entry.message}`;
+     * }
+     * ```
+     */
+    format(entry: LogEntry): string | any;
+    /**
+     * Format batch of log entries
+     * Optional - implement for efficient batch formatting
+     */
+    formatBatch?(entries: LogEntry[]): string | any;
+}
+//# sourceMappingURL=transport.d.ts.map

package/dist/api/transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport.d.ts","sourceRoot":"","sources":["../../src/api/transport.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAE7C;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,WAAW,aAAa;IAC5B,0CAA0C;IAC1C,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IAEpB,0BAA0B;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB;;;OAGG;IACH,GAAG,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAE3C;;;OAGG;IACH,KAAK,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAExB;;;OAGG;IACH,KAAK,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAExB;;;;;;;;;;;;OAYG;IACH,SAAS,CAAC,CAAC,KAAK,EAAE,QAAQ,GAAG,OAAO,CAAC;IAErC;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;CAC9B;AAED;;;;;GAKG;AACH,MAAM,WAAW,aAAa;IAC5B;;;;;;;;;OASG;IACH,MAAM,CAAC,KAAK,EAAE,QAAQ,GAAG,MAAM,GAAG,GAAG,CAAC;IAEtC;;;OAGG;IACH,WAAW,CAAC,CAAC,OAAO,EAAE,QAAQ,EAAE,GAAG,MAAM,GAAG,GAAG,CAAC;CACjD"}

package/dist/api/transport.js

@@ -0,0 +1 @@
+export {};

package/dist/es2015/api/index.js

@@ -0,0 +1,3 @@
+export * from './logger.js';
+export * from './transport.js';
+export * from './manager.js';

package/dist/es2015/api/logger.js

@@ -0,0 +1 @@
+export {};

package/dist/es2015/api/manager.js

@@ -0,0 +1 @@
+export {};

package/dist/es2015/api/transport.js

@@ -0,0 +1 @@
+export {};

package/dist/es2015/index.js

@@ -0,0 +1,14 @@
+/**
+ * @hamak/logging-api
+ *
+ * Public API for the pluggable logging system.
+ * Provides interfaces, types, and service tokens for logging.
+ *
+ * @packageDocumentation
+ */
+// Export all API interfaces
+export * from './api/index.js';
+// Export all types
+export * from './types/index.js';
+// Export service tokens
+export * from './tokens/index.js';

package/dist/es2015/tokens/index.js

@@ -0,0 +1 @@
+export * from './service-tokens.js';

package/dist/es2015/tokens/service-tokens.js

@@ -0,0 +1,42 @@
+/**
+ * Dependency Injection tokens for logging services
+ */
+/**
+ * Token for injecting the LogManager service
+ *
+ * @example
+ * ```typescript
+ * export const myPlugin: PluginModule = {
+ *   initialize(ctx) {
+ *     const logManager = ctx.resolve(LOG_MANAGER_TOKEN);
+ *     const logger = logManager.createLogger({ plugin: 'my-plugin' });
+ *   }
+ * };
+ * ```
+ */
+export const LOG_MANAGER_TOKEN = Symbol.for('@hamak/logging:LogManager');
+/**
+ * Token for injecting a Logger instance
+ * This is typically a factory that creates plugin-scoped loggers
+ *
+ * @example
+ * ```typescript
+ * export const myPlugin: PluginModule = {
+ *   initialize(ctx) {
+ *     // Get logger factory
+ *     const createLogger = ctx.resolve(LOGGER_TOKEN);
+ *     const logger = createLogger('my-plugin');
+ *   }
+ * };
+ * ```
+ */
+export const LOGGER_TOKEN = Symbol.for('@hamak/logging:Logger');
+/**
+ * Token for injecting the LogConfig
+ */
+export const LOG_CONFIG_TOKEN = Symbol.for('@hamak/logging:Config');
+/**
+ * Token for injecting the transport registry
+ * Used internally by the logging system
+ */
+export const LOG_TRANSPORTS_TOKEN = Symbol.for('@hamak/logging:Transports');

package/dist/es2015/types/index.js

@@ -0,0 +1,2 @@
+export * from './log-entry.js';
+export * from './log-config.js';

package/dist/es2015/types/log-config.js

@@ -0,0 +1 @@
+export {};

package/dist/es2015/types/log-entry.js

@@ -0,0 +1,12 @@
+/**
+ * Log severity levels
+ */
+export var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["TRACE"] = 0] = "TRACE";
+    LogLevel[LogLevel["DEBUG"] = 1] = "DEBUG";
+    LogLevel[LogLevel["INFO"] = 2] = "INFO";
+    LogLevel[LogLevel["WARN"] = 3] = "WARN";
+    LogLevel[LogLevel["ERROR"] = 4] = "ERROR";
+    LogLevel[LogLevel["FATAL"] = 5] = "FATAL";
+})(LogLevel || (LogLevel = {}));

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @hamak/logging-api
+ *
+ * Public API for the pluggable logging system.
+ * Provides interfaces, types, and service tokens for logging.
+ *
+ * @packageDocumentation
+ */
+export * from './api/index.js';
+export * from './types/index.js';
+export * from './tokens/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,cAAc,gBAAgB,CAAC;AAG/B,cAAc,kBAAkB,CAAC;AAGjC,cAAc,mBAAmB,CAAC"}

package/dist/index.js

@@ -0,0 +1,14 @@
+/**
+ * @hamak/logging-api
+ *
+ * Public API for the pluggable logging system.
+ * Provides interfaces, types, and service tokens for logging.
+ *
+ * @packageDocumentation
+ */
+// Export all API interfaces
+export * from './api/index.js';
+// Export all types
+export * from './types/index.js';
+// Export service tokens
+export * from './tokens/index.js';

package/dist/tokens/index.d.ts

@@ -0,0 +1,2 @@
+export * from './service-tokens.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/tokens/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tokens/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC"}

package/dist/tokens/index.js

@@ -0,0 +1 @@
+export * from './service-tokens.js';

package/dist/tokens/service-tokens.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Dependency Injection tokens for logging services
+ */
+/**
+ * Token for injecting the LogManager service
+ *
+ * @example
+ * ```typescript
+ * export const myPlugin: PluginModule = {
+ *   initialize(ctx) {
+ *     const logManager = ctx.resolve(LOG_MANAGER_TOKEN);
+ *     const logger = logManager.createLogger({ plugin: 'my-plugin' });
+ *   }
+ * };
+ * ```
+ */
+export declare const LOG_MANAGER_TOKEN: unique symbol;
+/**
+ * Token for injecting a Logger instance
+ * This is typically a factory that creates plugin-scoped loggers
+ *
+ * @example
+ * ```typescript
+ * export const myPlugin: PluginModule = {
+ *   initialize(ctx) {
+ *     // Get logger factory
+ *     const createLogger = ctx.resolve(LOGGER_TOKEN);
+ *     const logger = createLogger('my-plugin');
+ *   }
+ * };
+ * ```
+ */
+export declare const LOGGER_TOKEN: unique symbol;
+/**
+ * Token for injecting the LogConfig
+ */
+export declare const LOG_CONFIG_TOKEN: unique symbol;
+/**
+ * Token for injecting the transport registry
+ * Used internally by the logging system
+ */
+export declare const LOG_TRANSPORTS_TOKEN: unique symbol;
+/**
+ * Type helper for LOG_MANAGER_TOKEN
+ */
+export type LogManagerToken = typeof LOG_MANAGER_TOKEN;
+/**
+ * Type helper for LOGGER_TOKEN
+ */
+export type LoggerToken = typeof LOGGER_TOKEN;
+//# sourceMappingURL=service-tokens.d.ts.map

package/dist/tokens/service-tokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-tokens.d.ts","sourceRoot":"","sources":["../../src/tokens/service-tokens.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,iBAAiB,eAA0C,CAAC;AAEzE;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,YAAY,eAAsC,CAAC;AAEhE;;GAEG;AACH,eAAO,MAAM,gBAAgB,eAAsC,CAAC;AAEpE;;;GAGG;AACH,eAAO,MAAM,oBAAoB,eAA0C,CAAC;AAE5E;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG,OAAO,iBAAiB,CAAC;AAEvD;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG,OAAO,YAAY,CAAC"}

package/dist/tokens/service-tokens.js

@@ -0,0 +1,42 @@
+/**
+ * Dependency Injection tokens for logging services
+ */
+/**
+ * Token for injecting the LogManager service
+ *
+ * @example
+ * ```typescript
+ * export const myPlugin: PluginModule = {
+ *   initialize(ctx) {
+ *     const logManager = ctx.resolve(LOG_MANAGER_TOKEN);
+ *     const logger = logManager.createLogger({ plugin: 'my-plugin' });
+ *   }
+ * };
+ * ```
+ */
+export const LOG_MANAGER_TOKEN = Symbol.for('@hamak/logging:LogManager');
+/**
+ * Token for injecting a Logger instance
+ * This is typically a factory that creates plugin-scoped loggers
+ *
+ * @example
+ * ```typescript
+ * export const myPlugin: PluginModule = {
+ *   initialize(ctx) {
+ *     // Get logger factory
+ *     const createLogger = ctx.resolve(LOGGER_TOKEN);
+ *     const logger = createLogger('my-plugin');
+ *   }
+ * };
+ * ```
+ */
+export const LOGGER_TOKEN = Symbol.for('@hamak/logging:Logger');
+/**
+ * Token for injecting the LogConfig
+ */
+export const LOG_CONFIG_TOKEN = Symbol.for('@hamak/logging:Config');
+/**
+ * Token for injecting the transport registry
+ * Used internally by the logging system
+ */
+export const LOG_TRANSPORTS_TOKEN = Symbol.for('@hamak/logging:Transports');

package/dist/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from './log-entry.js';
+export * from './log-config.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,iBAAiB,CAAC"}

package/dist/types/index.js

@@ -0,0 +1,2 @@
+export * from './log-entry.js';
+export * from './log-config.js';

package/dist/types/log-config.d.ts

@@ -0,0 +1,72 @@
+import { LogLevel, LogEntry } from './log-entry.js';
+/**
+ * Configuration for a log transport
+ */
+export interface TransportConfig {
+    /** Unique identifier for the transport */
+    id: string;
+    /** Whether the transport is enabled */
+    enabled?: boolean;
+    /** Minimum log level to handle */
+    minLevel?: LogLevel;
+    /** Maximum log level to handle */
+    maxLevel?: LogLevel;
+    /** Custom filter function */
+    filter?: (entry: LogEntry) => boolean;
+    /** Only log from specific plugins */
+    plugins?: string[];
+    /** Only log from specific modules */
+    modules?: string[];
+    /** Only log entries with specific tags */
+    tags?: string[];
+}
+/**
+ * Configuration for the log manager
+ */
+export interface LogManagerConfig {
+    /** Global minimum log level */
+    globalLevel?: LogLevel;
+    /** Buffer size before forcing flush */
+    bufferSize?: number;
+    /** Automatic flush interval in milliseconds */
+    flushInterval?: number;
+    /** Default transports to register */
+    defaultTransports?: TransportConfig[];
+    /** Plugin-specific log levels */
+    pluginLevels?: Record<string, LogLevel>;
+    /** Module-specific log levels */
+    moduleLevels?: Record<string, LogLevel>;
+}
+/**
+ * Configuration for console transport
+ */
+export interface ConsoleTransportConfig {
+    /** Use colors in output */
+    colors?: boolean;
+    /** Use emojis in output */
+    emojis?: boolean;
+    /** Show timestamps */
+    timestamps?: boolean;
+    /** Show context (plugin/module/component) */
+    showContext?: boolean;
+}
+/**
+ * Configuration for remote transport
+ */
+export interface RemoteTransportConfig {
+    /** Remote logging endpoint URL */
+    endpoint: string;
+    /** API key for authentication */
+    apiKey?: string;
+    /** Client identifier */
+    clientId?: string;
+    /** Environment (dev, staging, production) */
+    environment?: string;
+    /** Batch size for sending logs */
+    batchSize?: number;
+    /** Timeout for requests in milliseconds */
+    timeout?: number;
+    /** Retry attempts on failure */
+    retryAttempts?: number;
+}
+//# sourceMappingURL=log-config.d.ts.map

package/dist/types/log-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log-config.d.ts","sourceRoot":"","sources":["../../src/types/log-config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAEpD;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,0CAA0C;IAC1C,EAAE,EAAE,MAAM,CAAC;IACX,uCAAuC;IACvC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,kCAAkC;IAClC,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,kCAAkC;IAClC,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,6BAA6B;IAC7B,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,QAAQ,KAAK,OAAO,CAAC;IACtC,qCAAqC;IACrC,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,qCAAqC;IACrC,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,0CAA0C;IAC1C,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;CACjB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,+BAA+B;IAC/B,WAAW,CAAC,EAAE,QAAQ,CAAC;IACvB,uCAAuC;IACvC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,+CAA+C;IAC/C,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,qCAAqC;IACrC,iBAAiB,CAAC,EAAE,eAAe,EAAE,CAAC;IACtC,iCAAiC;IACjC,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;IACxC,iCAAiC;IACjC,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;CACzC;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,2BAA2B;IAC3B,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,2BAA2B;IAC3B,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,sBAAsB;IACtB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,6CAA6C;IAC7C,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,kCAAkC;IAClC,QAAQ,EAAE,MAAM,CAAC;IACjB,iCAAiC;IACjC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,wBAAwB;IACxB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,6CAA6C;IAC7C,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,kCAAkC;IAClC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,2CAA2C;IAC3C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,gCAAgC;IAChC,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB"}

package/dist/types/log-config.js

@@ -0,0 +1 @@
+export {};

package/dist/types/log-entry.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Log severity levels
+ */
+export declare enum LogLevel {
+    TRACE = 0,
+    DEBUG = 1,
+    INFO = 2,
+    WARN = 3,
+    ERROR = 4,
+    FATAL = 5
+}
+/**
+ * Context information for a log entry
+ * Automatically tracks plugin, module, component hierarchy
+ */
+export interface LogContext {
+    /** Plugin that created the log */
+    plugin?: string;
+    /** Module within the plugin */
+    module?: string;
+    /** Component (e.g., React component name) */
+    component?: string;
+    /** Operation being performed */
+    operation?: string;
+    /** Request ID for distributed tracing */
+    requestId?: string;
+    /** User ID for user-specific logs */
+    userId?: string;
+    /** Additional custom context */
+    [key: string]: any;
+}
+/**
+ * Additional metadata for a log entry
+ */
+export interface LogMetadata {
+    /** Error object (for ERROR/FATAL logs) */
+    error?: Error;
+    /** Stack trace */
+    stack?: string;
+    /** Duration in milliseconds (for performance logs) */
+    duration?: number;
+    /** Tags for categorization */
+    tags?: string[];
+    /** Additional custom metadata */
+    [key: string]: any;
+}
+/**
+ * Complete log entry
+ */
+export interface LogEntry {
+    /** Timestamp in milliseconds since epoch */
+    timestamp: number;
+    /** Log severity level */
+    level: LogLevel;
+    /** Log message */
+    message: string;
+    /** Context information */
+    context: LogContext;
+    /** Additional metadata */
+    metadata?: LogMetadata;
+    /** Pre-formatted message (optional, for caching) */
+    formattedMessage?: string;
+}
+//# sourceMappingURL=log-entry.d.ts.map

package/dist/types/log-entry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log-entry.d.ts","sourceRoot":"","sources":["../../src/types/log-entry.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,oBAAY,QAAQ;IAClB,KAAK,IAAI;IACT,KAAK,IAAI;IACT,IAAI,IAAI;IACR,IAAI,IAAI;IACR,KAAK,IAAI;IACT,KAAK,IAAI;CACV;AAED;;;GAGG;AACH,MAAM,WAAW,UAAU;IACzB,kCAAkC;IAClC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,+BAA+B;IAC/B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,6CAA6C;IAC7C,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,gCAAgC;IAChC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,yCAAyC;IACzC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,qCAAqC;IACrC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,gCAAgC;IAChC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,0CAA0C;IAC1C,KAAK,CAAC,EAAE,KAAK,CAAC;IACd,kBAAkB;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,sDAAsD;IACtD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,8BAA8B;IAC9B,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,iCAAiC;IACjC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,QAAQ;IACvB,4CAA4C;IAC5C,SAAS,EAAE,MAAM,CAAC;IAClB,yBAAyB;IACzB,KAAK,EAAE,QAAQ,CAAC;IAChB,kBAAkB;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,0BAA0B;IAC1B,OAAO,EAAE,UAAU,CAAC;IACpB,0BAA0B;IAC1B,QAAQ,CAAC,EAAE,WAAW,CAAC;IACvB,oDAAoD;IACpD,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B"}

package/dist/types/log-entry.js

@@ -0,0 +1,12 @@
+/**
+ * Log severity levels
+ */
+export var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["TRACE"] = 0] = "TRACE";
+    LogLevel[LogLevel["DEBUG"] = 1] = "DEBUG";
+    LogLevel[LogLevel["INFO"] = 2] = "INFO";
+    LogLevel[LogLevel["WARN"] = 3] = "WARN";
+    LogLevel[LogLevel["ERROR"] = 4] = "ERROR";
+    LogLevel[LogLevel["FATAL"] = 5] = "FATAL";
+})(LogLevel || (LogLevel = {}));

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@hamak/logging-api",
+  "version": "0.4.0",
+  "description": "Logging API - Public interfaces and types for pluggable logging system",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js",
+      "legacy": "./dist/es2015/index.js"
+    },
+    "./es2015": {
+      "import": "./dist/es2015/index.js",
+      "default": "./dist/es2015/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/amah/app-framework.git",
+    "directory": "packages/logging/logging-api"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.lib.json && tsc -p tsconfig.es2015.json",
+    "clean": "rm -rf dist"
+  },
+  "keywords": [
+    "logging",
+    "api",
+    "interfaces",
+    "microkernel"
+  ],
+  "author": "",
+  "license": "MIT",
+  "devDependencies": {
+    "typescript": "^5.9.3",
+    "vitest": "^3.2.4"
+  }
+}