fock-logger
Version:
Simple logger for your pet-project
233 lines • 7.5 kB
JavaScript
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const configurator_1 = __importDefault(require("../config/configurator"));
const { config } = new configurator_1.default();
const f_formatter_1 = __importDefault(require("f-formatter"));
const loggers_names_1 = __importDefault(require("../data/loggers.names"));
const file_logger_1 = __importDefault(require("./file.logger"));
const formatter = new f_formatter_1.default();
const loggersNames = new loggers_names_1.default(config.logging);
const defaultExecuteData = {
level: "info",
end: "\n",
join: " ",
sign: true
};
class InitLogger {
out;
input;
_name;
_colors;
_log;
_config;
constructor(dir, data, out = process.stdout, input = process.stdin) {
this.out = out;
this.input = input;
this._name = data.name;
this._colors = data.colors;
this._config = {
...data,
logging: data.logging || config.logging,
dir: data.dir || config.dir,
level: data.level || config.level,
levels: data.levels || config.levels,
defaultLevel: data.defaultLevel || config.defaultLevel,
deletion_interval: data.deletion_interval || config.deletion_interval,
date: data.date || config.date,
date_format: data.date_format || config.date_format,
colors: data.colors || config.colors,
loggers: data.loggers || config.loggers
};
this._log = new file_logger_1.default(dir, this._config, config.logging);
}
execute = (text, data = {
...defaultExecuteData,
color: this._colors[1],
write: config.logging,
}) => {
const out = typeof text === "string"
? [text]
: text;
const name = formatter.Color(this._name, this._colors[0]) + ":";
const date = `[${new Date().toISOString()}]`;
const output = out.map(text => formatter.Color(typeof text !== "string"
? text instanceof Error
? text.stack || text.message
: JSON.stringify(text, undefined, 4)
: text, data.color || this._colors[1]));
const start = `${this._config.date
? date + " "
: ""}${data.sign !== false
? `${name} `
: ""}`;
const end = data.end !== undefined
? data.end
: defaultExecuteData.end;
const join = data.join !== undefined
? data.join
: defaultExecuteData.join;
const isLevelEqualsOrLess = this._config.levels[config.level] <= this._config.levels[data.level || config.defaultLevel];
if (isLevelEqualsOrLess) {
if (typeof text === "string") {
this.out.write(start + output.join(join) + end);
}
else {
this.out.write(start + formatter.Color(output.join(join), data.color || this._colors[1]) + end);
}
}
const logEnabled = (config.logging && this._log) || data.write;
if (logEnabled) {
if (typeof text === "string") {
this._log.writeFile(this._name + ": " + text);
}
else {
this._log.writeFile(this._name + ":");
for (const msg of output) {
this._log.writeFile(msg[1]);
}
}
;
}
return {
colored: output,
base: out
};
};
readLine = (text, data = {
...defaultExecuteData,
color: this._colors[1],
write: config.logging,
}) => {
return new Promise((resolve, reject) => {
this.input.resume();
this.input.setEncoding("utf8");
const cleanup = () => {
this.input.removeListener("readable", onReadable);
this.input.removeListener("error", onError);
this.input.removeListener("end", onEnd);
};
this.execute(text, data);
const onReadable = () => {
const userInput = this.input.read();
if (!userInput) {
cleanup();
reject(new Error());
}
cleanup();
const input = userInput.slice(0, userInput.indexOf("\r\n"));
this._log.writeFile("User: " + input);
resolve(input);
};
const onError = (err) => {
cleanup();
reject(err);
};
const onEnd = () => {
cleanup();
reject(new Error("Stream ended without data"));
};
this.input.on("readable", onReadable);
this.input.on("error", onError);
this.input.on("end", onEnd);
});
};
get write() {
return this._log.writeFile;
}
get colors() {
return this._colors;
}
get name() {
return this._name;
}
}
const loggers = {};
class Logger {
_name;
_dir;
_file_log;
_data;
_colors;
_logger;
constructor(name, data = {
...defaultExecuteData,
dir: config.dir,
level: "info",
write: config.logging
}) {
this._name = name;
this._file_log = data;
this._dir = data.dir || config.dir;
this._colors = data?.colors
? data.colors
: loggers[name]
? loggers[name].colors
: loggersNames.GetNames()[name]?.colors || config.colors;
this._data = {
...defaultExecuteData,
level: config.level,
write: config.logging,
...data,
color: this._colors[1],
};
this._logger = this.init();
}
init = () => {
this._logger = new InitLogger(this._dir, {
name: this._name,
colors: this._colors,
...this._file_log
});
for (const key in loggersNames.GetNames()) {
const logger = loggersNames.GetNames()[key];
loggers[key] = new InitLogger(this._dir, {
name: logger.name,
colors: logger.colors
});
}
loggers[this._name] = this._logger;
loggersNames.SetNames({
[this._logger.name]: {
name: this._logger.name,
colors: this._colors
}
});
if (!this._colors)
this._colors = this._logger.colors;
return this._logger;
};
get write() {
return this._logger.write;
}
execute = (text, data = {
...defaultExecuteData,
color: this._colors[1],
write: config.logging,
}) => {
return this._logger.execute(text, {
...this._data,
...data
});
};
read = (text, data = {
...defaultExecuteData,
color: this._colors[1],
write: config.logging,
}) => {
return this._logger.readLine(text, {
...this._data,
...data
});
};
get colors() {
return this._colors;
}
get name() {
return this._name;
}
}
exports.default = Logger;
//# sourceMappingURL=index.logger.js.map