auto-gpt-ts/dist/logging/logger.js

my take of Auto-GPT in typescript

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.getLogger = exports.Loggable = exports.Logger = exports.noop = exports.LogLevel = void 0;
var LogLevel;
(function (LogLevel) {
    LogLevel["INFO"] = "info";
    LogLevel["WARN"] = "warn";
    LogLevel["ERROR"] = "error";
    LogLevel["DEBUG"] = "debug";
    LogLevel["SILENT"] = "silent";
})(LogLevel = exports.LogLevel || (exports.LogLevel = {}));
const noop = () => { };
exports.noop = noop;
class Logger {
    static logLevelToNumber(logLevel) {
        switch (logLevel) {
            case LogLevel.DEBUG:
                return 0;
            case LogLevel.INFO:
                return 1;
            case LogLevel.WARN:
                return 2;
            case LogLevel.ERROR:
                return 3;
            case LogLevel.SILENT:
                return 4;
            default:
                return 3;
        }
    }
    constructor(logger, ...prefixes) {
        this.logger = logger;
        this.prefixes = prefixes.filter((p) => p !== undefined);
        this.logFrefixString = this.prefixes.map((p) => `[${p}]`).join(" ");
    }
    static addTask(task) {
        if (!Logger.useTypewriterAffect) {
            return task();
        }
        const actualTask = (callback) => () => __awaiter(this, void 0, void 0, function* () {
            try {
                const res = yield task();
                callback(res);
            }
            catch (error) {
                throw error;
            }
        });
        return new Promise((resolve) => {
            this.taskStack.push(actualTask(resolve));
            Logger.loop();
        });
    }
    static loop(_force = false) {
        if (this.isLooping && !_force) {
            return;
        }
        this.isLooping = true;
        const task = this.taskStack.shift();
        if (task) {
            process.stdout.write("\n");
            return Promise.resolve(task()).then(() => process.nextTick(() => this.loop(true), 10));
        }
        this.isLooping = false;
    }
    static typewriterTyper(stack) {
        return __awaiter(this, void 0, void 0, function* () {
            this.taskStack.push(() => new Promise((resolve) => {
                const write = (char) => {
                    const callback = char.length > 1
                        ? () => setTimeout(() => write(char.slice(3)), 20)
                        : resolve;
                    process.stdout.write(char.slice(0, 3), callback);
                };
                write(stack);
            }));
            Logger.loop();
        });
    }
    typewriter(message, jsonObject) {
        let typewriterStack = message;
        if (jsonObject) {
            typewriterStack += JSON.stringify(jsonObject, null, 2);
        }
        Logger.typewriterTyper(typewriterStack);
    }
    createLogFunction(logFunction, typeWriter = false) {
        return (message, jsonObject) => __awaiter(this, void 0, void 0, function* () {
            const messageWithPrefix = `${this.logFrefixString} ${message}`;
            const inputs = jsonObject
                ? [messageWithPrefix, jsonObject]
                : [messageWithPrefix];
            if (!Logger.useTypewriterAffect) {
                return logFunction(...inputs);
            }
            if (typeWriter) {
                return this.typewriter(...inputs);
            }
            Logger.taskStack.push(() => new Promise((res) => {
                res(logFunction(...inputs));
            }));
            Logger.loop();
        });
    }
    get info() {
        if (Logger.logLevelToNumber(Logger.logLevel) >
            Logger.logLevelToNumber(LogLevel.INFO)) {
            return exports.noop;
        }
        return this.createLogFunction(this.logger.info, true);
    }
    get warn() {
        if (Logger.logLevelToNumber(Logger.logLevel) >
            Logger.logLevelToNumber(LogLevel.WARN)) {
            return exports.noop;
        }
        return this.createLogFunction(this.logger.warn);
    }
    get error() {
        if (Logger.logLevelToNumber(Logger.logLevel) >
            Logger.logLevelToNumber(LogLevel.ERROR)) {
            return exports.noop;
        }
        return this.createLogFunction(this.logger.error);
    }
    get debug() {
        if (Logger.logLevelToNumber(Logger.logLevel) >
            Logger.logLevelToNumber(LogLevel.DEBUG)) {
            return exports.noop;
        }
        return this.createLogFunction(this.logger.debug);
    }
}
Logger.noDebug = false;
Logger.logLevel = LogLevel.INFO;
Logger.useTypewriterAffect = true;
Logger.isLooping = false;
Logger.taskStack = [];
exports.Logger = Logger;
class Loggable {
    constructor(...prefixes) {
        this.logger = new Logger(console, this.constructor.name, ...prefixes);
        this.logger.debug(`new instance created`);
    }
}
exports.Loggable = Loggable;
function getLogger(...prefixes) {
    return new Logger(console, ...prefixes);
}
exports.getLogger = getLogger;
//# sourceMappingURL=logger.js.map