fallout-utility
Version:
<h1 align="center"> fallout-utility <br> </h1>
212 lines • 9.27 kB
JavaScript
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.Logger = exports.LoggerLevel = void 0;
const node_fs_1 = require("node:fs");
const promises_1 = require("node:fs/promises");
const node_util_1 = require("node:util");
const TypedEmitter_1 = require("./TypedEmitter");
const system_1 = require("../system");
const node_zlib_1 = require("node:zlib");
const ansi_regex_1 = __importDefault(require("ansi-regex"));
const node_path_1 = __importDefault(require("node:path"));
var LoggerLevel;
(function (LoggerLevel) {
LoggerLevel[LoggerLevel["INFO"] = 1] = "INFO";
LoggerLevel[LoggerLevel["WARN"] = 2] = "WARN";
LoggerLevel[LoggerLevel["ERROR"] = 3] = "ERROR";
LoggerLevel[LoggerLevel["DEBUG"] = 4] = "DEBUG";
})(LoggerLevel || (exports.LoggerLevel = LoggerLevel = {}));
class Logger extends TypedEmitter_1.TypedEmitter {
parent;
formatMessage;
formatMessageLines;
objectInspectOptions;
enableDebugmode;
forceEmitLogEvents;
writeStream;
name;
get isDebugging() {
return this.enableDebugmode || (0, system_1.isDebugging)();
}
constructor(options) {
super();
this.formatMessage = options?.formatMessage;
this.formatMessageLines = options?.formatMessageLines ?? {};
this.objectInspectOptions = options?.objectInspectOptions ?? { colors: true };
this.enableDebugmode = options?.enableDebugmode ?? null;
this.forceEmitLogEvents = options?.forceEmitLogEvents ?? false;
this.writeStream = options?.writeStream || undefined;
this.name = options?.name || undefined;
this.parent = options?.parent || undefined;
this.info = this.info.bind(this);
this.warn = this.warn.bind(this);
this.err = this.err.bind(this);
this.log = this.log.bind(this);
this.warning = this.warning.bind(this);
this.error = this.error.bind(this);
this.debug = this.debug.bind(this);
this.logToFile = (0, node_util_1.deprecate)(this.logToFile.bind(this), "'<Logger>.logToFile' is deprecated. Use '<Logger>.createFileWriteStream()' instead.");
this.createFileWriteStream = this.createFileWriteStream.bind(this);
this.setDebugMode = this.setDebugMode.bind(this);
this.setName = this.setName.bind(this);
this.setWriteStream = this.setWriteStream.bind(this);
this.closeWriteStream = this.closeWriteStream.bind(this);
this.clone = this.clone.bind(this);
}
emit(eventName, ...args) {
const emitted = super.emit(eventName, ...args);
if (this.parent)
this.parent.emit(eventName, ...args);
return emitted;
}
info(...message) { this.log(...message); }
warn(...message) { this.warning(...message); }
err(...message) { this.error(...message); }
log(...messages) {
const message = this._print(messages, LoggerLevel.INFO).join('\n');
this._write(message, LoggerLevel.INFO);
this.emit('log', message);
}
warning(...messages) {
const message = this._print(messages, LoggerLevel.WARN).join('\n');
this._write(message, LoggerLevel.WARN);
this.emit('warn', message);
}
error(...messages) {
const message = this._print(messages, LoggerLevel.ERROR).join('\n');
this._write(message, LoggerLevel.ERROR);
this.emit('err', message);
}
debug(...messages) {
const message = this._print(messages, LoggerLevel.DEBUG).join('\n');
if (this.forceEmitLogEvents && !this.isDebugging)
this.emit('debug', message);
if (!this.isDebugging)
return;
this._write(message, LoggerLevel.DEBUG);
this.emit('debug', message);
}
/**
* @deprecated Use {@link Logger.createFileWriteStream} instead
*/
logToFile(filePath, keepOldFile = false, renameFileName) {
if (this.writeStream)
throw new Error('Logger write stream already exist.');
const filePathInfo = node_path_1.default.parse(filePath);
(0, node_fs_1.mkdirSync)(filePathInfo.dir, { recursive: true });
if ((0, node_fs_1.existsSync)(filePath) && !keepOldFile) {
const fileInfo = (0, node_fs_1.lstatSync)(filePath);
const dateFormat = `${fileInfo.birthtime.toDateString()} - ${fileInfo.birthtime.getHours()}-${fileInfo.birthtime.getMinutes()}-${fileInfo.birthtime.getSeconds()}-${fileInfo.birthtime.getMilliseconds()}`;
(0, node_fs_1.renameSync)(filePath, node_path_1.default.join(filePathInfo.dir, renameFileName
? typeof renameFileName === 'string'
? renameFileName
: renameFileName(fileInfo)
: `${dateFormat}${filePathInfo.ext}`));
}
this.setWriteStream((0, node_fs_1.createWriteStream)(filePath));
return this;
}
async createFileWriteStream(options) {
if (this.writeStream && !this.writeStream.closed && !this.writeStream.destroyed)
throw new Error('Logger write stream already exist.');
const file = node_path_1.default.resolve(options.file);
const filePathInfo = node_path_1.default.parse(file);
const isExists = (0, node_fs_1.existsSync)(file);
let oldFileHandled = false;
if (isExists && options.renameOldFile !== false) {
if (options.handleOldFile) {
await Promise.resolve(options.handleOldFile(file));
}
else {
const lines = (await (0, promises_1.readFile)(file, 'utf-8')).split('\n');
const header = lines[0]?.startsWith(`<[LOG - HEADER]> `) ? lines.shift() : undefined;
const date = header ? new Date(Number(header.split('> ')[1])) : (await (0, promises_1.stat)(file)).birthtime;
const dateFormat = `${date.toISOString().substring(0, 10)} ${date.getHours()}-${date.getMinutes()}-${date.getSeconds()}-${date.getMilliseconds()}`;
const newFile = node_path_1.default.join(filePathInfo.dir, `${dateFormat}${filePathInfo.ext}.gz`);
const data = (0, node_zlib_1.gzipSync)(Buffer.from(lines.join('\n')));
await (0, promises_1.writeFile)(file, data);
await (0, promises_1.rename)(file, newFile);
}
oldFileHandled = true;
}
else {
await (0, promises_1.mkdir)(filePathInfo.dir, { recursive: true });
}
this.setWriteStream((0, node_fs_1.createWriteStream)(file, { encoding: 'utf-8' }));
if (isExists && oldFileHandled && !options.handleOldFile)
this.writeStream?.write(`<[LOG - HEADER]> ${Date.now()}\n`, 'utf-8');
return this;
}
setDebugMode(enabled) {
this.enableDebugmode = enabled;
return this;
}
setName(name) {
this.name = name;
return this;
}
setWriteStream(writeStream, close = true) {
if (this.writeStream && close)
this.closeWriteStream();
this.writeStream = writeStream;
return this;
}
closeWriteStream() {
this.writeStream?.close();
this.writeStream = undefined;
return this;
}
clone(options) {
return new Logger({
...this,
...options
});
}
_print(messages, level) {
const formatter = this.formatMessage
? (message) => (this.formatMessage)(message, level, this)
: this.formatMessageLines[level] ?? (e => e);
if (!messages.length)
this._write(formatter('', this), level);
let lastAnsi = '';
let lines = messages.map(msg => typeof msg === 'string' ? msg : (0, node_util_1.inspect)(msg, this.objectInspectOptions))
.join(' ')
.split('\n');
lines = lines.map((msg, index) => {
const previousLine = lines[index - 1];
if (!previousLine)
return formatter(msg, this);
lastAnsi = previousLine.match((0, ansi_regex_1.default)())?.pop() ?? lastAnsi;
return formatter(lastAnsi + msg, this);
});
return lines;
}
_write(message, level, logToConsole = true, logToFile = true) {
if (logToConsole) {
switch (level) {
case LoggerLevel.INFO:
console.log(message);
break;
case LoggerLevel.WARN:
console.warn(message);
break;
case LoggerLevel.ERROR:
console.error(message);
break;
case LoggerLevel.DEBUG:
console.debug(message);
break;
}
}
if (logToFile) {
const strippedMessage = (0, node_util_1.stripVTControlCharacters)(message);
if (this.writeStream && !(this.writeStream.closed || this.writeStream.destroyed))
this.writeStream.write(`${strippedMessage}\n`, 'utf-8');
}
}
}
exports.Logger = Logger;
//# sourceMappingURL=Logger.js.map