@robertprp/intents-sdk/dist/esm/utils/logger.js

Shogun Network Intent-based cross-chain swaps SDK

import { BaseError } from '../errors/index.js';
export var LogLevel;
(function (LogLevel) {
    LogLevel["DEBUG"] = "DEBUG";
    LogLevel["INFO"] = "INFO";
    LogLevel["WARN"] = "WARN";
    LogLevel["ERROR"] = "ERROR";
    LogLevel["NONE"] = "NONE";
})(LogLevel || (LogLevel = {}));
class DefaultLogger {
    debug(message, ...args) {
        console.debug(`[${new Date().toISOString()} DEBUG] ${message}`, ...args);
    }
    info(message, ...args) {
        console.info(`[${new Date().toISOString()} INFO] ${message}`, ...args);
    }
    warn(message, ...args) {
        console.warn(`[${new Date().toISOString()} WARN] ${message}`, ...args);
    }
    error(message, ...args) {
        console.error(`[${new Date().toISOString()} ERROR] ${message}`, ...args);
    }
}
class Logger {
    constructor() {
        Object.defineProperty(this, "loggerImpl", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: new DefaultLogger()
        });
        Object.defineProperty(this, "logLevel", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: LogLevel.INFO
        });
    }
    static getInstance() {
        if (!Logger.instance) {
            Logger.instance = new Logger();
        }
        return Logger.instance;
    }
    configure(config) {
        this.logLevel = config.level;
        if (config.customLogger) {
            this.loggerImpl = config.customLogger;
        }
    }
    debug(message, ...args) {
        if (this.shouldLog(LogLevel.DEBUG)) {
            this.loggerImpl.debug(message, ...args);
        }
    }
    info(message, ...args) {
        if (this.shouldLog(LogLevel.INFO)) {
            this.loggerImpl.info(message, ...args);
        }
    }
    warn(message, ...args) {
        if (this.shouldLog(LogLevel.WARN)) {
            this.loggerImpl.warn(message, ...args);
        }
    }
    error(message, error) {
        if (this.shouldLog(LogLevel.ERROR)) {
            const formattedError = this.formatError(error);
            this.loggerImpl.error(message, formattedError);
        }
    }
    logError(error) {
        if (this.shouldLog(LogLevel.ERROR)) {
            const formattedError = this.formatError(error);
            if (error instanceof BaseError) {
                this.loggerImpl.error(`${error.name}: ${error.message}`, formattedError);
            }
            else if (error instanceof Error) {
                this.loggerImpl.error(`${error.name}: ${error.message}`, formattedError);
            }
            else {
                this.loggerImpl.error('Unknown error', formattedError);
            }
        }
    }
    shouldLog(level) {
        const levels = [LogLevel.DEBUG, LogLevel.INFO, LogLevel.WARN, LogLevel.ERROR];
        const currentLevelIndex = levels.indexOf(this.logLevel);
        const targetLevelIndex = levels.indexOf(level);
        return currentLevelIndex <= targetLevelIndex && this.logLevel !== LogLevel.NONE;
    }
    formatError(error) {
        if (!error)
            return 'No error details provided';
        if (error instanceof BaseError) {
            return error.toJSON();
        }
        if (error instanceof Error) {
            return {
                name: error.name,
                message: error.message,
                stack: error.stack,
            };
        }
        return error;
    }
}
export const logger = Logger.getInstance();
//# sourceMappingURL=logger.js.map