@nizza/core 0.6.8 → 0.7.0-beta.0

package/dist/lib/logger/core/adapters/pino.adapter.d.ts

@@ -0,0 +1,89 @@
+import { LogLevel } from '../../../constants';
+import { LevelService, LogEntry, LoggerAdapter, LoggerMetadata } from '../../types';
+import { ConsoleLogger } from '../loggers/console';
+import { HttpLogger } from '../loggers/http.logger';
+interface PinoAdapterConfig {
+    source: string;
+    levelService: LevelService;
+    consoleLogger: ConsoleLogger;
+    httpLogger: HttpLogger;
+    metadata?: LoggerMetadata;
+}
+/**
+ * PinoAdapter is a LoggerAdapter implementation using the pino logging library.
+ *
+ * Global metadata is stored in a static variable, so any updates via setMetadata
+ * affect all log entries across all adapter instances.
+ */
+export declare class PinoAdapter implements LoggerAdapter {
+    private static globalMetadata;
+    private static root;
+    private instance;
+    private httpLogger;
+    private consoleLogger;
+    private config;
+    /**
+     * Creates a new instance of PinoAdapter.
+     * @param config - The adapter configuration.
+     */
+    constructor(config: PinoAdapterConfig);
+    /**
+     * Creates the root pino logger with custom options.
+     * @param source - The source context.
+     * @param httpLogger - The HTTP logger for production logs.
+     * @returns A root pino logger instance.
+     */
+    private static createRootLogger;
+    /**
+     * Merges new metadata into the global metadata.
+     * @param metadata - The metadata to merge.
+     */
+    private static mergeGlobalMetadata;
+    /**
+     * Creates a child logger with an extended source context.
+     * Any additional metadata provided is merged into the global metadata.
+     * @param source - The additional source context.
+     * @param metadata - Optional metadata to merge globally.
+     * @returns A new PinoAdapter instance representing the child logger.
+     */
+    child(source: string, metadata?: LoggerMetadata): LoggerAdapter;
+    /**
+     * Sets the logging level for this adapter.
+     * @param level - The desired log level.
+     */
+    setLevel(level: LogLevel): void;
+    /**
+     * Updates the global metadata. All subsequent log entries will include the updated metadata.
+     * @param metadata - The metadata to merge into the global metadata.
+     */
+    setMetadata(metadata: LoggerMetadata): void;
+    /**
+     * Formats a log entry into a structured log payload.
+     * @param entry - The log entry to format.
+     * @returns A formatted log entry.
+     */
+    private formatLogEntry;
+    /**
+     * Formats an individual argument and merges it into the data object.
+     * @param arg - The argument to format.
+     * @param idx - The index of the argument.
+     * @param data - The accumulator for formatted data.
+     */
+    private formatArg;
+    /**
+     * Logs an entry at the specified level.
+     * @param level - The log level method to call.
+     * @param entry - The log entry.
+     * @throws Will throw an error if the log level method is not supported.
+     */
+    private log;
+    trace(entry: LogEntry): void;
+    debug(entry: LogEntry): void;
+    info(entry: LogEntry): void;
+    warn(entry: LogEntry): void;
+    error(entry: LogEntry): void;
+    fatal(entry: LogEntry): void;
+    get source(): string;
+}
+export {};
+//# sourceMappingURL=pino.adapter.d.ts.map

package/dist/lib/logger/core/adapters/pino.adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pino.adapter.d.ts","sourceRoot":"","sources":["../../../../../src/lib/logger/core/adapters/pino.adapter.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,QAAQ,EAAoB,MAAM,oBAAoB,CAAC;AAEhE,OAAO,EAEL,YAAY,EACZ,QAAQ,EACR,aAAa,EACb,cAAc,EACf,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAKpD,UAAU,iBAAiB;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,YAAY,CAAC;IAC3B,aAAa,EAAE,aAAa,CAAC;IAC7B,UAAU,EAAE,UAAU,CAAC;IACvB,QAAQ,CAAC,EAAE,cAAc,CAAC;CAC3B;AAED;;;;;GAKG;AACH,qBAAa,WAAY,YAAW,aAAa;IAE/C,OAAO,CAAC,MAAM,CAAC,cAAc,CAAsB;IACnD,OAAO,CAAC,MAAM,CAAC,IAAI,CAAqC;IAExD,OAAO,CAAC,QAAQ,CAAuB;IACvC,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,aAAa,CAAgB;IACrC,OAAO,CAAC,MAAM,CAAoB;IAElC;;;OAGG;gBACS,MAAM,EAAE,iBAAiB;IAyBrC;;;;;OAKG;IACH,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAsB/B;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,mBAAmB;IAIlC;;;;;;OAMG;IACI,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,GAAE,cAAmB,GAAG,aAAa;IAU1E;;;OAGG;IACI,QAAQ,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI;IAItC;;;OAGG;IACI,WAAW,CAAC,QAAQ,EAAE,cAAc,GAAG,IAAI;IAIlD;;;;OAIG;IACH,OAAO,CAAC,cAAc;IAyBtB;;;;;OAKG;IACH,OAAO,CAAC,SAAS;IAWjB;;;;;OAKG;IACH,OAAO,CAAC,GAAG;IAQJ,KAAK,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI;IAI5B,KAAK,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI;IAI5B,IAAI,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI;IAI3B,IAAI,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI;IAI3B,KAAK,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI;IAI5B,KAAK,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI;IAInC,IAAI,MAAM,IAAI,MAAM,CAEnB;CACF"}

package/dist/lib/logger/core/logger-chain.d.ts

@@ -0,0 +1,24 @@
+import { LogOptions, LoggerAdapter } from '../types';
+/**
+ * Implements a chainable logger that allows applying options before
+ * executing the log. The log is committed at the end of the microtask queue.
+ */
+export declare class LoggerChain {
+    private adapter;
+    private committed;
+    private chainOptions;
+    private method;
+    private stack;
+    private args;
+    constructor(adapter: LoggerAdapter, initialOptions?: LogOptions);
+    options(opts: LogOptions): this;
+    trace(...args: any[]): this;
+    debug(...args: any[]): this;
+    info(...args: any[]): this;
+    warn(...args: any[]): this;
+    error(...args: any[]): this;
+    fatal(...args: any[]): this;
+    private log;
+    private commit;
+}
+//# sourceMappingURL=logger-chain.d.ts.map

package/dist/lib/logger/core/logger-chain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger-chain.d.ts","sourceRoot":"","sources":["../../../../src/lib/logger/core/logger-chain.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,aAAa,EAAY,MAAM,UAAU,CAAC;AAE/D;;;GAGG;AACH,qBAAa,WAAW;IAOV,OAAO,CAAC,OAAO;IAN3B,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,YAAY,CAAkB;IACtC,OAAO,CAAC,MAAM,CAAoC;IAClD,OAAO,CAAC,KAAK,CAAM;IACnB,OAAO,CAAC,IAAI,CAAa;gBAEL,OAAO,EAAE,aAAa,EAAE,cAAc,CAAC,EAAE,UAAU;IAQhE,OAAO,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI;IAK/B,KAAK,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI;IAI3B,KAAK,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI;IAI3B,IAAI,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI;IAI1B,IAAI,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI;IAI1B,KAAK,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI;IAI3B,KAAK,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI;IAIlC,OAAO,CAAC,GAAG;IAOX,OAAO,CAAC,MAAM;CAgBf"}

package/dist/lib/logger/core/loggers/console/config.d.ts

@@ -0,0 +1,3 @@
+import { ConsoleLoggerConfig } from '../../../types';
+export declare const config: ConsoleLoggerConfig;
+//# sourceMappingURL=config.d.ts.map

package/dist/lib/logger/core/loggers/console/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../../../../src/lib/logger/core/loggers/console/config.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAErD,eAAO,MAAM,MAAM,EAAE,mBA6DpB,CAAC"}

package/dist/lib/logger/core/loggers/console/console.logger.d.ts

@@ -0,0 +1,50 @@
+import { Log } from '../../../../types';
+/**
+ * Utility for formatted logging with support for dark and light themes.
+ */
+export declare class ConsoleLogger {
+    private theme;
+    constructor();
+    /**
+     * Initializes the theme based on localStorage or browser settings.
+     * @returns 'light' or 'dark'
+     */
+    private initializeTheme;
+    /**
+     * Detects the current console theme based on browser settings.
+     * @returns 'light' or 'dark'
+     */
+    private detectTheme;
+    /**
+     * Sets up a listener to detect changes in the browser's theme settings.
+     */
+    private setupThemeChangeListener;
+    /**
+     * Manually sets the theme and stores it in localStorage.
+     * @param theme - 'light' or 'dark'
+     */
+    static setTheme(theme: 'light' | 'dark'): void;
+    /**
+     * Formats and filters the stack trace.
+     * @param stack - Raw stack trace.
+     * @returns Filtered and formatted stack trace.
+     */
+    private formatStack;
+    /**
+     * Retrieves the appropriate style for a log level based on the theme.
+     * @param level - Log level.
+     * @returns Console style string.
+     */
+    private getStyles;
+    /**
+     * Gets the current time formatted as HH:mm:ss.SSS.
+     * @returns Formatted time string.
+     */
+    private getTime;
+    /**
+     * Prints a formatted log entry to the console.
+     * @param log - Log object containing level, source, message, and data.
+     */
+    print({ level, source, msg, data }: Log, stack?: string): void;
+}
+//# sourceMappingURL=console.logger.d.ts.map

package/dist/lib/logger/core/loggers/console/console.logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"console.logger.d.ts","sourceRoot":"","sources":["../../../../../../src/lib/logger/core/loggers/console/console.logger.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,GAAG,EAAE,MAAM,mBAAmB,CAAC;AAGxC;;GAEG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,KAAK,CAAmB;;IAOhC;;;OAGG;IACH,OAAO,CAAC,eAAe;IAQvB;;;OAGG;IACH,OAAO,CAAC,WAAW;IAMnB;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAQhC;;;OAGG;WACW,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI;IAIrD;;;;OAIG;IACH,OAAO,CAAC,WAAW;IAOnB;;;;OAIG;IACH,OAAO,CAAC,SAAS;IAUjB;;;OAGG;IACH,OAAO,CAAC,OAAO;IAOf;;;OAGG;IACI,KAAK,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,IAAI,EAAE,EAAE,GAAG,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI;CA4BtE"}

package/dist/lib/logger/core/loggers/console/index.d.ts

@@ -0,0 +1,2 @@
+export { ConsoleLogger } from './console.logger';
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/logger/core/loggers/console/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/lib/logger/core/loggers/console/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/lib/logger/core/loggers/http.logger.d.ts

@@ -0,0 +1,24 @@
+import { Log } from '../../../types';
+import { HttpLoggerConfig } from '../../types';
+export declare class HttpLogger {
+    private config;
+    private isFlushing;
+    private retryCount;
+    private isFlushScheduled;
+    private constructor();
+    static create(config: HttpLoggerConfig): HttpLogger;
+    save(log: Log): Promise<void>;
+    private scheduleFlush;
+    private flush;
+    private processLogsBatch;
+    private getLogsBatch;
+    private splitLogsByPayloadSize;
+    private sendLogs;
+    private buildPayload;
+    private deleteLogs;
+    private logError;
+    private handleRetry;
+    private hasPendingLogs;
+    private setupUnloadListener;
+}
+//# sourceMappingURL=http.logger.d.ts.map

package/dist/lib/logger/core/loggers/http.logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.logger.d.ts","sourceRoot":"","sources":["../../../../../src/lib/logger/core/loggers/http.logger.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AAGrC,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAE/C,qBAAa,UAAU;IACrB,OAAO,CAAC,MAAM,CAA6B;IAC3C,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,UAAU,CAAK;IACvB,OAAO,CAAC,gBAAgB,CAAS;IAEjC,OAAO;IAKP,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,gBAAgB,GAAG,UAAU;IAiB7C,IAAI,CAAC,GAAG,EAAE,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC;IAMnC,OAAO,CAAC,aAAa;YAWP,KAAK;YA2BL,gBAAgB;YAWhB,YAAY;IAM1B,OAAO,CAAC,sBAAsB;YAwBhB,QAAQ;IAStB,OAAO,CAAC,YAAY;YAIN,UAAU;IAKxB,OAAO,CAAC,QAAQ;IAIhB,OAAO,CAAC,WAAW;YAYL,cAAc;IAK5B,OAAO,CAAC,mBAAmB;CAiB5B"}

package/dist/lib/logger/core/services/local-storage-level.service.d.ts

@@ -0,0 +1,59 @@
+import { LogLevel } from '../../../constants';
+import { LevelService } from '../../types';
+export declare const LOGLEVEL_PATTERNS_KEY: "loglevel-patterns";
+export declare const LOGLEVEL_PREFIX: "loglevel:";
+export declare const OVERRIDE_SUFFIX: "!";
+export declare class LocalStorageLevelService implements LevelService {
+    private readonly projectPrefix;
+    private patternsCache;
+    /**
+     * Initializes the service with a specific project name.
+     * @param project - The project for which log levels are managed.
+     */
+    constructor(project: string);
+    /**
+     * Retrieves the log level for a given context.
+     * Resolves the most specific match, considering override rules.
+     * @param context - The specific context to retrieve the log level for.
+     * @returns The resolved log level.
+     */
+    getLevel(context: string): LogLevel;
+    /**
+     * Sets the log level for a specific context as an individual key.
+     * @param context - The specific context for which to set the log level.
+     * @param level - The log level to set, optionally with "!".
+     */
+    setLevel(context: string, level: LogLevel | `${LogLevel}${typeof OVERRIDE_SUFFIX}`): void;
+    /**
+     * Loads and unifies patterns from both loglevel-patterns and individual keys.
+     * Ensures the process is done only once per app lifecycle.
+     * @returns A unified map of patterns.
+     */
+    private loadAndUnifyPatterns;
+    /**
+     * Resolves the log level for a context using the unified patterns.
+     * Handles override logic and prioritizes more specific matches.
+     * @param context - The context to resolve the log level for.
+     * @param patterns - The unified patterns map.
+     * @returns The resolved log level, or undefined if no match is found.
+     */
+    private resolveLogLevelFromPatterns;
+    /**
+     * Reads patterns from loglevel-patterns in localStorage.
+     * @returns The parsed patterns map.
+     */
+    private readPatternsFromJSON;
+    /**
+     * Unifies patterns from loglevel-patterns with individual keys from localStorage.
+     * @param basePatterns - The base patterns loaded from loglevel-patterns.
+     * @returns A unified map of patterns.
+     */
+    private unifyWithIndividualKeys;
+    /**
+     * Parses a log level string, identifying if it's an override.
+     * @param value - The value to parse (e.g., "ERROR!").
+     * @returns An object with the level and override flag.
+     */
+    private parseLogLevel;
+}
+//# sourceMappingURL=local-storage-level.service.d.ts.map

package/dist/lib/logger/core/services/local-storage-level.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-storage-level.service.d.ts","sourceRoot":"","sources":["../../../../../src/lib/logger/core/services/local-storage-level.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAGH,OAAO,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAG3C,eAAO,MAAM,qBAAqB,EAAG,mBAA4B,CAAC;AAClE,eAAO,MAAM,eAAe,EAAG,WAAoB,CAAC;AACpD,eAAO,MAAM,eAAe,EAAG,GAAY,CAAC;AAU5C,qBAAa,wBAAyB,YAAW,YAAY;IAC3D,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;IACvC,OAAO,CAAC,aAAa,CAA8B;IAEnD;;;OAGG;gBACS,OAAO,EAAE,MAAM;IAI3B;;;;;OAKG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,QAAQ;IAKnC;;;;OAIG;IACH,QAAQ,CACN,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,QAAQ,GAAG,GAAG,QAAQ,GAAG,OAAO,eAAe,EAAE,GACvD,IAAI;IAcP;;;;OAIG;IACH,OAAO,CAAC,oBAAoB;IAS5B;;;;;;OAMG;IACH,OAAO,CAAC,2BAA2B;IAwBnC;;;OAGG;IACH,OAAO,CAAC,oBAAoB;IAU5B;;;;OAIG;IACH,OAAO,CAAC,uBAAuB;IAuB/B;;;;OAIG;IACH,OAAO,CAAC,aAAa;CAYtB"}

package/dist/lib/logger/core/utils.d.ts

@@ -0,0 +1,16 @@
+import { LogLevel } from '../../constants';
+/**
+ * Validates whether a given value is a valid LogTypes.
+ * @param value - The value to validate.
+ * @returns True if valid, false otherwise.
+ */
+export declare function isValidLogType(value: unknown): value is LogLevel;
+export declare class InvalidLogLevelError extends Error {
+    /**
+     * Creates a new instance of InvalidLogLevelError.
+     * @param level - The invalid log level.
+     */
+    constructor(level: any);
+}
+export declare function getRootSource(source: string): string;
+//# sourceMappingURL=utils.d.ts.map

package/dist/lib/logger/core/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../src/lib/logger/core/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAE3C;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,QAAQ,CAIhE;AAED,qBAAa,oBAAqB,SAAQ,KAAK;IAC7C;;;OAGG;gBACS,KAAK,EAAE,GAAG;CAIvB;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAEpD"}

package/dist/lib/logger/index.d.ts

@@ -0,0 +1,6 @@
+import { BaseDB } from '../dexie';
+import { Logger } from './logger';
+export declare function createNizzaLogger(source: string): Logger;
+export declare function createPinoLogger(project: string, db: BaseDB): Logger;
+export { Logger };
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/logger/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lib/logger/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAMlC,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAElC,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAGxD;AAED,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CASpE;AAED,OAAO,EAAE,MAAM,EAAE,CAAC"}

package/dist/lib/logger/logger.d.ts

@@ -0,0 +1,199 @@
+import { LogLevel } from '../constants';
+import { LoggerChain } from './core/logger-chain';
+import { LoggerAdapter, LoggerMetadata, LogOptions } from './types';
+/**
+ * Logger class that provides a structured, chainable, and extensible logging API.
+ *
+ * This class allows logging messages with various severity levels (`trace`, `debug`,
+ * `info`, `warn`, `error`, `fatal`) and supports setting global metadata.
+ *
+ * It follows a **chainable pattern**, allowing flexible usage such as:
+ *
+ * ```ts
+ * logger.info('Application started');
+ * logger.error(new Error('Critical failure')).options({ silent: true });
+ * logger.options({ silent: true }).debug('User data', user);
+ * ```
+ */
+export declare class Logger {
+    private adapter;
+    /**
+     * Private constructor to enforce instantiation through `Logger.create()`.
+     *
+     * @param {LoggerAdapter} adapter - The logging adapter implementation.
+     */
+    private constructor();
+    /**
+     * Factory Static Method to create a new Logger instance.
+     *
+     * This method accepts a logging adapter and returns a new Logger instance.
+     *
+     * @param {LoggerAdapter} adapter - The logging adapter implementation.
+     * @returns {Logger} A new Logger instance.
+     *
+     * @example
+     * ```ts
+     * const logger = Logger.create(new PinoAdapter(config));
+     * ```
+     */
+    static create(adapter: LoggerAdapter): Logger;
+    /**
+     * Creates a child logger with additional context.
+     *
+     * The child logger inherits the parent's configuration and metadata.
+     *
+     * @param {string} name - The context to append to the logger's source.
+     * @param {LoggerMetadata} [metadata={}] - Additional metadata for the child logger.
+     * @returns {Logger} A new child Logger instance.
+     *
+     * @example
+     * ```ts
+     * const userLogger = logger.child('UserService');
+     * userLogger.info('Fetching user data');
+     * ```
+     */
+    child(name: string, metadata?: LoggerMetadata): Logger;
+    /**
+     * Creates a lazy child logger with delayed initialization.
+     *
+     * The lazy child logger is a proxy that initializes the child logger only when its methods are first accessed.
+     *
+     * @param {string} name - The context name for the lazy child logger.
+     * @param {LoggerMetadata} [metadata={}] - Additional metadata for the lazy child logger.
+     * @returns {Logger} A new lazy child Logger instance.
+     *
+     * @example
+     * ```ts
+     * const lazyLogger = logger.lazyChild('Deferred');
+     * lazyLogger.info('This is executed only when used');
+     * ```
+     */
+    lazyChild(name: string, metadata?: LoggerMetadata): Logger;
+    /**
+     * Sets or updates the metadata for the logger.
+     *
+     * The provided metadata is merged with existing global metadata and included in every log entry.
+     *
+     * @param {LoggerMetadata} metadata - The metadata to set.
+     *
+     * @example
+     * ```ts
+     * logger.setMetadata({ account: '1234', user: 'admin' });
+     * ```
+     */
+    setMetadata(metadata: LoggerMetadata): void;
+    /**
+     * Sets the log level.
+     *
+     * @param {LogLevel} level - The new log level to be set.
+     * @throws {Error} Throws an error if the provided log level is invalid.
+     */
+    setLevel(level: LogLevel): void;
+    /**
+     * Creates a new instance of LoggerChain for chaining log calls with optional settings.
+     *
+     * @param {LogOptions} [initialOptions] - Optional log options.
+     * @returns {LoggerChain} A new LoggerChain instance.
+     */
+    private createChain;
+    /**
+     * Logs a **trace-level** message for deep debugging.
+     *
+     * Use this for very detailed logs that help trace the execution flow.
+     *
+     * @param {...any} args - The log message and optional additional data.
+     * @returns {LoggerChain} A chainable logger instance.
+     *
+     * @example
+     * ```ts
+     * logger.trace('Function execution trace', { function: 'fetchData' });
+     * ```
+     */
+    trace(...args: any[]): LoggerChain;
+    /**
+     * Logs a **debug-level** message for troubleshooting.
+     *
+     * Use this for diagnostic information useful during development.
+     *
+     * @param {...any} args - The log message and optional additional data.
+     * @returns {LoggerChain} A chainable logger instance.
+     *
+     * @example
+     * ```ts
+     * logger.debug('User session data', session);
+     * ```
+     */
+    debug(...args: any[]): LoggerChain;
+    /**
+     * Logs an **info-level** message for general system events.
+     *
+     * Use this for regular information that tracks system operations.
+     *
+     * @param {...any} args - The log message and optional additional data.
+     * @returns {LoggerChain} A chainable logger instance.
+     *
+     * @example
+     * ```ts
+     * logger.info('User logged in', { userId: 123 });
+     * ```
+     */
+    info(...args: any[]): LoggerChain;
+    /**
+     * Logs a **warning-level** message to indicate potential issues.
+     *
+     * Use this when an unexpected event occurs but the application can continue operating.
+     *
+     * @param {...any} args - The log message and optional additional data.
+     * @returns {LoggerChain} A chainable logger instance.
+     *
+     * @example
+     * ```ts
+     * logger.warn('API response took too long', { duration: 5000 });
+     * ```
+     */
+    warn(...args: any[]): LoggerChain;
+    /**
+     * Logs an **error-level** message for recoverable failures.
+     *
+     * Use this when an error occurs that does not require immediate termination of the application.
+     *
+     * @param {...any} args - The log message and optional additional data.
+     * @returns {LoggerChain} A chainable logger instance.
+     *
+     * @example
+     * ```ts
+     * logger.error(new Error('Database connection lost'));
+     * ```
+     */
+    error(...args: any[]): LoggerChain;
+    /**
+     * Logs a **fatal-level** message for critical failures.
+     *
+     * Use this when an unrecoverable error occurs and the system must be terminated.
+     *
+     * @param {...any} args - The log message and optional additional data.
+     * @returns {LoggerChain} A chainable logger instance.
+     *
+     * @example
+     * ```ts
+     * logger.fatal('Critical system failure', { code: 'SYSTEM_CRASH' });
+     * ```
+     */
+    fatal(...args: any[]): LoggerChain;
+    /**
+     * Sets the log options for the current chain.
+     *
+     * This method allows modifying log behavior (e.g., silencing the console output)
+     * before calling a log method.
+     *
+     * @param {LogOptions} opts - The log options to apply.
+     * @returns {LoggerChain} A chainable logger instance.
+     *
+     * @example
+     * ```ts
+     * logger.options({ silent: true }).error(new Error('Silent error'));
+     * ```
+     */
+    options(opts: LogOptions): LoggerChain;
+}
+//# sourceMappingURL=logger.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../../src/lib/logger/logger.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAExC,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAElD,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAEpE;;;;;;;;;;;;;GAaG;AACH,qBAAa,MAAM;IACjB,OAAO,CAAC,OAAO,CAAgB;IAE/B;;;;OAIG;IACH,OAAO;IAIP;;;;;;;;;;;;OAYG;WACW,MAAM,CAAC,OAAO,EAAE,aAAa,GAAG,MAAM;IAUpD;;;;;;;;;;;;;;OAcG;IACI,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,GAAE,cAAmB,GAAG,MAAM;IAIjE;;;;;;;;;;;;;;OAcG;IACI,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,GAAE,cAAmB,GAAG,MAAM;IAYrE;;;;;;;;;;;OAWG;IACI,WAAW,CAAC,QAAQ,EAAE,cAAc,GAAG,IAAI;IAIlD;;;;;OAKG;IACI,QAAQ,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI;IAOtC;;;;;OAKG;IACH,OAAO,CAAC,WAAW;IAInB;;;;;;;;;;;;OAYG;IACI,KAAK,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,WAAW;IAIzC;;;;;;;;;;;;OAYG;IACI,KAAK,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,WAAW;IAIzC;;;;;;;;;;;;OAYG;IACI,IAAI,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,WAAW;IAIxC;;;;;;;;;;;;OAYG;IACI,IAAI,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,WAAW;IAIxC;;;;;;;;;;;;OAYG;IACI,KAAK,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,WAAW;IAIzC;;;;;;;;;;;;OAYG;IACI,KAAK,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,WAAW;IAIzC;;;;;;;;;;;;;OAaG;IACI,OAAO,CAAC,IAAI,EAAE,UAAU,GAAG,WAAW;CAG9C"}

package/dist/lib/logger/types.d.ts

@@ -0,0 +1,108 @@
+import { LogLevel } from '../constants';
+import { BaseDB } from '../dexie';
+import { Log } from '../types';
+export interface LogOptions {
+    /** Determines whether the log entry should not be displayed in the console. */
+    silent?: boolean;
+}
+export interface LogContent {
+    /** The main message or error to be logged. Can be of any type. */
+    message: any;
+    /** Additional arguments that may be included in the log entry. */
+    args?: any[];
+}
+export interface LogEntry {
+    /** The primary log content, including message and optional arguments. */
+    content: LogContent;
+    /** The stack trace of the log entry. */
+    stack: string;
+    /** Additional log options. */
+    options?: LogOptions;
+}
+export interface FormattedLogEntry {
+    /** The user partial log data. */
+    payload: Partial<Log>;
+    /** Additional logging options. */
+    options: LogOptions;
+    /** The stack trace of the log entry. */
+    stack: string;
+    /** Additional properties managed by the logger. */
+    [key: string]: any;
+}
+export interface LoggerAdapter {
+    readonly source: string;
+    trace(entry: LogEntry): void;
+    debug(entry: LogEntry): void;
+    info(entry: LogEntry): void;
+    warn(entry: LogEntry): void;
+    error(entry: LogEntry): void;
+    fatal(entry: LogEntry): void;
+    child(source: string, metadata?: LoggerMetadata): LoggerAdapter;
+    setMetadata(data: LoggerMetadata): void;
+    setLevel(level: string): void;
+}
+export interface LevelService {
+    getLevel(context?: string): LogLevel;
+    setLevel(context: string, level: LogLevel): void;
+}
+export type LoggerMetadata = Record<string, any>;
+export interface ThemeConfig {
+    baseStyles: Record<string, string>;
+    levels: Record<number, string>;
+    messages: Record<number, string>;
+}
+export interface ConsoleLoggerConfig {
+    stackExclusionPatterns: RegExp;
+    themes: {
+        dark: ThemeConfig;
+        light: ThemeConfig;
+    };
+}
+/**
+ * Configuration options for the HttpLogger.
+ */
+export interface HttpLoggerConfig {
+    /**
+     * Database for run operations.
+     */
+    db: BaseDB;
+    /**
+     * Name of the project or service generating the logs.
+     * Used to identify the source of logs in the backend.
+     */
+    project: string;
+    /**
+     * The endpoint where logs will be sent.
+     */
+    endpoint?: string;
+    /**
+     * Maximum number of logs to send in a single batch.
+     * Determines the batch size for each request.
+     */
+    batchSize?: number;
+    /**
+     * Interval in seconds between log flushes.
+     * Controls how frequently logs are sent to the server.
+     */
+    flushInterval?: number;
+    /**
+     * Maximum number of retry attempts for failed requests.
+     * If exceeded, logs will remain in the database for the next successful flush.
+     */
+    maxRetries?: number;
+    /**
+     * Exponential backoff factor for retry delays.
+     * Delay = flushInterval * (retryBackoffFactor ^ retryCount).
+     */
+    retryBackoffFactor?: number;
+    /**
+     * Maximum payload size in kilobytes (KB) for a single request.
+     * Helps to prevent requests that exceed server or network limits.
+     */
+    maxPayloadSize?: number;
+}
+export interface LogBatch {
+    logs: Log[];
+    timestamp: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/lib/logger/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/lib/logger/types.ts"],"names":[],"mappings":"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"}

package/dist/lib/mobx/hooks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../../../src/lib/mobx/hooks.ts"],"names":[],"mappings":"AACA,OAAO,EAIL,cAAc,EACd,cAAc,EACf,MAAM,OAAO,CAAC;AAGf,MAAM,WAAW,eAAe,CAAC,CAAC;IAChC,YAAY,CAAC,EAAE,CAAC,CAAC;IACjB,IAAI,CAAC,EAAE,cAAc,CAAC;CACvB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,cAAc,EAAE,IAAI,GAAE,cAAmB,QAK3E;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,SAAS,CAAC,CAAC,EACzB,OAAO,EAAE,MAAM,CAAC,EAChB,MAAM,GAAE,eAAe,CAAC,CAAC,CAAM,GAC9B,CAAC,CAcH;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAC3B,OAAO,EAAE,MAAM,CAAC,EAChB,MAAM,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,EAC1B,IAAI,GAAE,cAAmB,QAS1B"}
+{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../../../src/lib/mobx/hooks.ts"],"names":[],"mappings":"AACA,OAAO,EAIL,cAAc,EACd,cAAc,EACf,MAAM,OAAO,CAAC;AAGf,MAAM,WAAW,eAAe,CAAC,CAAC;IAChC,YAAY,CAAC,EAAE,CAAC,CAAC;IACjB,IAAI,CAAC,EAAE,cAAc,CAAC;CACvB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,UAAU,CACxB,MAAM,EAAE,cAAc,EACtB,IAAI,GAAE,cAAmB,GACxB,IAAI,CAKN;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,SAAS,CAAC,CAAC,EACzB,OAAO,EAAE,MAAM,CAAC,EAChB,MAAM,GAAE,eAAe,CAAC,CAAC,CAAM,GAC9B,CAAC,CAcH;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAC3B,OAAO,EAAE,MAAM,CAAC,EAChB,MAAM,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,EAC1B,IAAI,GAAE,cAAmB,GACxB,IAAI,CAQN"}