loglevelnext/dist/MethodFactory.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.MethodFactory = exports.MethodFactoryLevels = void 0;
const noop = () => { };
const levels = Symbol('log-levels');
const instance = Symbol('log-instance');
exports.MethodFactoryLevels = {
    TRACE: 0,
    DEBUG: 1,
    INFO: 2,
    WARN: 3,
    ERROR: 4,
    SILENT: 5
};
class MethodFactory {
    constructor(logger) {
        this[instance] = logger;
        this[levels] = exports.MethodFactoryLevels;
    }
    get levels() {
        return this[levels];
    }
    get logger() {
        return this[instance];
    }
    set logger(logger) {
        this[instance] = logger;
    }
    get methods() {
        return Object.keys(this.levels)
            .map((key) => key.toLowerCase())
            .filter((key) => key !== 'silent');
    }
    bindMethod(obj, methodName) {
        const method = obj[methodName];
        if (typeof method.bind === 'function') {
            return method.bind(obj);
        }
        try {
            return Function.prototype.bind.call(method, obj);
        }
        catch (e) {
            return function result() {
                return Function.prototype.apply.apply(method, [obj, arguments]);
            };
        }
    }
    distillLevel(level) {
        let result = level;
        if (typeof result === 'string' && typeof this.levels[result.toUpperCase()] !== 'undefined') {
            result = this.levels[result.toUpperCase()];
        }
        if (this.levelValid(result)) {
            return result;
        }
        return null;
    }
    levelValid(level) {
        if (typeof level === 'number' && level >= 0 && level <= this.levels.SILENT) {
            return true;
        }
        return false;
    }
    make(methodName) {
        const target = console;
        if (typeof target[methodName] !== 'undefined') {
            return this.bindMethod(target, methodName);
        }
        else if (typeof console.log !== 'undefined') {
            return this.bindMethod(target, 'log');
        }
        return noop;
    }
    replaceMethods(logLevel) {
        const level = this.distillLevel(logLevel);
        if (level === null) {
            throw new Error(`loglevelnext: replaceMethods() called with invalid level: ${logLevel}`);
        }
        if (!this.logger || this.logger.type !== 'LogLevel') {
            throw new TypeError('loglevelnext: Logger is undefined or invalid. Please specify a valid Logger instance.');
        }
        this.methods.forEach((methodName) => {
            const { [methodName.toUpperCase()]: methodLevel } = this.levels;
            this.logger[methodName] = methodLevel < level ? noop : this.make(methodName);
        });
        this.logger.log = this.logger.debug;
    }
}
exports.MethodFactory = MethodFactory;
//# sourceMappingURL=MethodFactory.js.map