cute-logger
Version:
Simple way to log messages in stdout or other stream.
250 lines (219 loc) • 7.75 kB
JavaScript
;
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
var Couleurs = require("couleurs"),
AnsiParser = require("ansi-parser"),
Typpy = require("typpy"),
Deffy = require("deffy"),
Daty = require("daty"),
util = require("util");
var CuteLogger = function () {
function CuteLogger() {
_classCallCheck(this, CuteLogger);
}
_createClass(CuteLogger, null, [{
key: "log",
/**
* log
* Displays debug messages by providing the type.
*
* Usage:
*
* ```js
* CuteLogger.log("Some info message")
* CuteLogger.log(new Error("Interesting error"))
* ```
*
* The config object can be modified to make this module to act diferently.
* Defaults are shown:
*
* ```js
* CuteLogger.config = {
* // The error type
* error: {
* color: [192, 57, 43]
* , text: "error"
* , level: 1
* }
* // The warning type
* , warn: {
* color: [241, 196, 15]
* , text: "warn "
* , level: 2
* }
* // The info type
* , info: {
* color: [52, 152, 219]
* , text: "info "
* , level: 3
* }
* // Display date
* , date: false
* // Log level
* , level: 4
*
* // Output streams
* , stdout: process.stdout
* , stderr: process.stderr
*
* // The options passed to `util.inspect`
* , inspectOptions: { colors: true }
* }
* ````
*
* @name log
* @function
* @param {Object} message The debug message that should be displayed. If
* `message` is an object, it will show the inspected object.
* @param {String} type The message type (e.g. "error", "info" etc). Default is
* computed (`"error"` if the message is an `Error`) or `"info"` if the provided
* `type` is invalid.
* @return {Object} The `CuteLogger` instance.
*/
value: function log(message, type) {
var _this = this;
if (Array.isArray(message)) {
message.forEach(function (c) {
_this.log(c, type);
});
return CuteLogger;
}
var logMessage = "";
type = Deffy(type, Typpy(message));
if (type === "error" && message && message.message) {
message = message.message;
}
if (Typpy(CuteLogger.config[type]) === "undefined") {
type = "info";
}
// Get type from config
type = CuteLogger.config[type];
if (type.level > CuteLogger.config.level) {
return CuteLogger;
}
// Build message
logMessage += Couleurs(type.text).bold().fg(type.color) + " ";
if (CuteLogger.config.date) {
logMessage += Couleurs(CuteLogger.getDate()).bold() + " ";
}
if ((typeof message === "undefined" ? "undefined" : _typeof(message)) === "object") {
message = util.inspect(message, CuteLogger.config.inspectOptions);
}
// Add message
logMessage += message;
// Where should the message go?
var str = CuteLogger.config.streams[type.stream] || CuteLogger.config.streams.out;
// No fun when the stream is not TTY
if (!str.isTTY) {
logMessage = AnsiParser.removeAnsi(logMessage);
}
// Print message
str.write(logMessage + "\n");
return CuteLogger;
}
/**
* getDate
* Returns the stringified date. This method can be overrided for a custom date format.
*
* @name getDate
* @function
* @return {String} The date in HH:mm.ss - DD.MM.YYYY format.
*/
}, {
key: "getDate",
value: function getDate() {
return "[" + new Daty().format("dddd, MMMM DD, YYYY hh:mm:ss A") + "]";
}
/**
* error
* Displays debug messages by providing setting the type to `"error"`.
*
* Usage:
*
* ```js
* CuteLogger.error("Some error message")
* ```
*
* @name error
* @function
* @param {Object} message The debug message that should be displayed. If
* `message` is an object, it will show the inspected object.
* @return {Object} The `CuteLogger` instance.
*/
}, {
key: "error",
value: function error(message) {
return CuteLogger.log(message, "error");
}
/**
* warn
* Displays debug messages by providing setting the type to `"warn"`.
*
* Usage:
*
* ```js
* CuteLogger.warn("Some warn message")
* ```
*
* @name warn
* @function
* @param {Object} message The debug message that should be displayed. If
* `message` is an object, it will show the inspected object.
* @return {Object} The `CuteLogger` instance.
*/
}, {
key: "warn",
value: function warn(message) {
return CuteLogger.log(message, "warn");
}
/**
* info
* Displays debug messages by providing setting the type to `"info"`.
*
* Usage:
*
* ```js
* CuteLogger.info("Some info message")
* ```
*
* @name info
* @function
* @param {Object} message The debug message that should be displayed. If
* `message` is an object, it will show the inspected object.
* @return {Object} The `CuteLogger` instance.
*/
}, {
key: "info",
value: function info(message) {
return CuteLogger.log(message, "info");
}
}]);
return CuteLogger;
}();
CuteLogger.config = {
error: {
color: [192, 57, 43],
text: "error",
level: 1,
stream: "err"
},
warn: {
color: [241, 196, 15],
text: "warn ",
level: 2
},
info: {
color: [52, 152, 219],
text: "info ",
level: 3
},
date: true,
level: 4,
streams: {
out: process.stdout,
err: process.stderr
},
inspectOptions: { colors: true }
};
module.exports = CuteLogger;