@flying-dice/tslua-common/dist/logger.js

Common Utils Library

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Logger = exports.LogLevel = void 0;
/**
 * LogLevel represents the different severity levels that can be used to log messages.
 *
 * The levels are TRACE, DEBUG, INFO, WARN, ERROR, and OFF.
 *
 * OFF is a special level that can be used to disable logging.
 */
var LogLevel;
(function (LogLevel) {
    LogLevel[LogLevel["TRACE"] = 10] = "TRACE";
    LogLevel[LogLevel["DEBUG"] = 20] = "DEBUG";
    LogLevel[LogLevel["INFO"] = 30] = "INFO";
    LogLevel[LogLevel["WARN"] = 40] = "WARN";
    LogLevel[LogLevel["ERROR"] = 50] = "ERROR";
    LogLevel[LogLevel["OFF"] = 100] = "OFF";
})(LogLevel || (exports.LogLevel = LogLevel = {}));
/**
 * Represents a logger that can be used to log messages with different severity levels.
 *
 * Change the static level property to change the severity level of messages that are logged.
 *
 * Change the static transports property to change the way messages are logged.
 *
 * Use Logger.ignore to ignore a severity level.
 *
 * @example
 * const logger = new Logger("MyLogger");
 * Logger.level = LogLevel.DEBUG;
 * Logger.transports = { debug: print, info: print, warn: print, error: print };
 */
var Logger = /** @class */ (function () {
    function Logger(name) {
        this.name = name;
    }
    /**
     * Logs a trace message.
     *
     * Trace messages are the most verbose and should only be used for debugging.
     *
     * @param message The message to be logged.
     * @example
     * const logger = new Logger("MyLogger");
     * logger.trace("This is a trace message");
     */
    Logger.prototype.trace = function (message) {
        if (Logger.level <= LogLevel.TRACE) {
            Logger.transports.trace("[TRACE] [".concat(this.name, "] - ").concat(message));
        }
    };
    /**
     * Logs a debug message.
     *
     * Debug messages are less verbose than trace messages and should be used for debugging.
     *
     * @param message The message to be logged.
     * @example
     * const logger = new Logger("MyLogger");
     * logger.debug("This is a debug message");
     */
    Logger.prototype.debug = function (message) {
        if (Logger.level <= LogLevel.DEBUG) {
            Logger.transports.debug("[DEBUG] [".concat(this.name, "] - ").concat(message));
        }
    };
    /**
     * Logs an info message.
     *
     * Info messages are less verbose than debug messages and should be used for logging information.
     *
     * @param message The message to be logged.
     * @example
     * const logger = new Logger("MyLogger");
     * logger.info("This is an info message");
     */
    Logger.prototype.info = function (message) {
        if (Logger.level <= LogLevel.INFO) {
            Logger.transports.info("[INFO] [".concat(this.name, "] - ").concat(message));
        }
    };
    /**
     * Logs a warning message.
     *
     * Warning messages are less verbose than info messages and should be used for logging warnings.
     *
     * @param message The message to be logged.
     * @example
     * const logger = new Logger("MyLogger");
     * logger.warn("This is a warning message");
     */
    Logger.prototype.warn = function (message) {
        if (Logger.level <= LogLevel.WARN) {
            Logger.transports.warn("[WARN] [".concat(this.name, "] - ").concat(message));
        }
    };
    /**
     * Logs an error message.
     *
     * Error messages are the least verbose and should be used for logging errors.
     *
     * @param message The message to be logged.
     * @example
     * const logger = new Logger("MyLogger");
     * logger.error("This is an error message");
     */
    Logger.prototype.error = function (message) {
        if (Logger.level <= LogLevel.ERROR) {
            Logger.transports.error("[ERROR] [".concat(this.name, "] - ").concat(message));
        }
    };
    /**
     * A transport function that does nothing.
     *
     * Use this to ignore a severity level as an alternative to setting the LogLevel, this can be useful
     * where for example the trace transport is enabled but sending to an alternative location,
     * but you want to disable info.
     *
     * @example
     * const logger = new Logger("MyLogger");
     * logger.transports = { debug: Logger.ignore, info: Logger.ignore, warn: print, error: print };
     */
    Logger.ignore = function () { };
    Logger.level = LogLevel.INFO;
    Logger.transports = {
        trace: Logger.ignore,
        debug: Logger.ignore,
        info: Logger.ignore,
        warn: Logger.ignore,
        error: Logger.ignore,
    };
    return Logger;
}());
exports.Logger = Logger;