NodeLogging/out/index.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const util = require("util");
const fs = require("fs");
const events_1 = require("events");
const Reset = "\x1b[0m";
const Bright = "\x1b[1m";
const Dim = "\x1b[2m";
const Underscore = "\x1b[4m";
const Blink = "\x1b[5m";
const Reverse = "\x1b[7m";
const Hidden = "\x1b[8m";
const FgBlack = "\x1b[30m";
const FgRed = "\x1b[31m";
const FgGreen = "\x1b[32m";
const FgYellow = "\x1b[33m";
const FgBlue = "\x1b[34m";
const FgMagenta = "\x1b[35m";
const FgCyan = "\x1b[36m";
const FgWhite = "\x1b[37m";
const BgBlack = "\x1b[40m";
const BgRed = "\x1b[41m";
const BgGreen = "\x1b[42m";
const BgYellow = "\x1b[43m";
const BgBlue = "\x1b[44m";
const BgMagenta = "\x1b[45m";
const BgCyan = "\x1b[46m";
const BgWhite = "\x1b[47m";
class Logging {
    static config(logfolder, stdout) {
        this.logFileLocation = logfolder;
        this.stdout = stdout;
    }
    static debug(...message) {
        Logging.message(LoggingTypes.Debug, message);
    }
    static log(...message) {
        Logging.message(LoggingTypes.Log, message);
    }
    static warning(...message) {
        Logging.message(LoggingTypes.Log, message);
    }
    static logWithCustomColors(type, colors, ...message) {
        Logging.message(type, message, colors);
    }
    static error(error) {
        if (typeof error === "string") {
            Logging.errorMessage(error);
            return;
        }
        let m = "";
        error.stack.forEach(e => {
            m += e.toString() + "\n";
        });
        var message = error.name + " " + error.message + "\n" + m;
        Logging.message(LoggingTypes.Error, [message]);
    }
    static errorMessage(...message) {
        Logging.message(LoggingTypes.Error, message);
    }
    static async message(type, message, customColors) {
        var consoleLogFormat = Reset;
        if (!customColors) {
            switch (type) {
                case LoggingTypes.Log:
                    //m += FgWhite + BgBlack;
                    break;
                case LoggingTypes.Error:
                    consoleLogFormat += FgRed; //FgWhite + BgRed + FgWhite;
                    break;
                case LoggingTypes.Debug:
                    consoleLogFormat += FgCyan;
                    break;
                case LoggingTypes.Warning:
                    consoleLogFormat += FgYellow;
                    break;
            }
        }
        else {
            consoleLogFormat += customColors;
        }
        var mb = "";
        if (typeof message === "string") {
            mb = message;
        }
        else {
            message.forEach(e => {
                if (typeof e !== "string")
                    e = util.inspect(e, false, null);
                if (e.endsWith("\n")) {
                    mb += e;
                }
                else {
                    mb += e + " ";
                }
            });
        }
        var m = "[" + LoggingTypes[type] + "][" + _getCallerFile() + "][" + new Date().toISOString().replace(/T/, ' ').replace(/\..+/, '') + "]: " + mb;
        if (this.logFileLocation) {
            if (!this.fileStream || !this.errorStream) {
                await Logging.initializeFile();
            }
            Logging.writeMessageToFile(m, type === LoggingTypes.Error);
        }
        Logging.events.emit("message", { type: type, message: mb });
        if (this.stdout)
            console.log(consoleLogFormat + m + Reset);
    }
    static writeMessageToFile(message, error) {
        Logging.queue.push({ message: message, error: error });
        Logging.checkQueue();
    }
    static checkQueue() {
        if (Logging.writing)
            return;
        if (Logging.queue.length <= 0)
            return;
        Logging.writing = true;
        var message = Logging.queue[0];
        Logging.fileStream.write(message.message + "\n", () => {
            if (message.error) {
                Logging.errorStream.write(message.message + "\n", () => {
                    Logging.queue.splice(Logging.queue.indexOf(message), 1);
                    Logging.writing = false;
                    Logging.checkQueue();
                });
            }
            else {
                Logging.queue.splice(Logging.queue.indexOf(message), 1);
                Logging.writing = false;
                Logging.checkQueue();
            }
        });
    }
    static async initializeFile() {
        if (this.fileStream && this.errorStream)
            return;
        if (!this.logFileLocation)
            return;
        try {
            var exists = util.promisify(fs.exists);
            await new Promise((resolve, reject) => {
                fs.exists(this.logFileLocation, (exists) => {
                    if (!exists) {
                        fs.mkdir(this.logFileLocation, (err) => {
                            if (err) {
                                reject(err);
                            }
                            else {
                                resolve();
                            }
                        });
                    }
                    else
                        resolve();
                });
            });
            Logging.fileStream = fs.createWriteStream(this.logFileLocation + "all.log", { flags: "a" });
            Logging.fileStream.write("\n\n");
            Logging.errorStream = fs.createWriteStream(this.logFileLocation + "error.log", { flags: "a" });
            Logging.errorStream.write("\n\n");
        }
        catch (e) {
            console.log(e);
        }
    }
}
Logging.logFileLocation = "./logs/";
Logging.stdout = true;
Logging.writing = false;
Logging.queue = new Array();
Logging.events = new events_1.EventEmitter();
exports.Logging = Logging;
function _getCallerFile() {
    try {
        var err = new Error();
        var callerfile;
        var currentfile;
        Error.prepareStackTrace = function (err, stack) { return stack; };
        currentfile = err.stack.shift().getFileName();
        while (err.stack.length) {
            callerfile = err.stack.shift().getFileName();
            if (currentfile !== callerfile)
                return callerfile;
        }
    }
    catch (err) { }
    return undefined;
}
var LoggingTypes;
(function (LoggingTypes) {
    LoggingTypes[LoggingTypes["Log"] = 0] = "Log";
    LoggingTypes[LoggingTypes["Warning"] = 1] = "Warning";
    LoggingTypes[LoggingTypes["Error"] = 2] = "Error";
    LoggingTypes[LoggingTypes["Debug"] = 3] = "Debug";
})(LoggingTypes = exports.LoggingTypes || (exports.LoggingTypes = {}));
//# sourceMappingURL=index.js.map