@log-rush/log-formatter
Version:
Parse/Format/Style colored logs
180 lines • 7.49 kB
JavaScript
;
var __assign = (this && this.__assign) || function () {
__assign = Object.assign || function(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.SGRCommandParser = exports.CLOSE_BYTE = exports.OPEN_BYTE = exports.CTRL_CHARS = void 0;
var ast_1 = require("./ast");
var commands_1 = require("./commands");
var effects_1 = require("./effects");
var types_1 = require("./types");
exports.CTRL_CHARS = ['\x1b', '\\e', '\\x1b', '\\033', '\\u001b', '\\u1b', '\\33'];
exports.OPEN_BYTE = '[';
exports.CLOSE_BYTE = 'm';
var SGRCommandOpener = exports.CTRL_CHARS.map(function (ctrl) { return "".concat(ctrl).concat(exports.OPEN_BYTE); });
var SGRCommandParser = /** @class */ (function () {
function SGRCommandParser() {
}
SGRCommandParser.prototype.parse = function (data) {
var pointer = 0;
var contentStart = 0;
var ASTRoot = ast_1.SGRAstNode.Default();
var ASTHead = ASTRoot;
while (pointer < data.length) {
var isStart = this.isSGRCommandStart(data, pointer);
if (isStart.isValid) {
ASTHead.appendContent(data.substring(contentStart, pointer)); // store old content
pointer += isStart.commandOffset; // move pointer after start byte
// search for closing byte
var commandLength = data.substring(pointer).indexOf(exports.CLOSE_BYTE);
if (commandLength < 0) {
break;
}
// parse command content (between opening sequence and closing byte)
var node = this.parseSGRCommand(data.slice(pointer, pointer + commandLength));
// update current index + new content start
pointer += commandLength + 1;
contentStart = pointer;
// insert new node
ASTHead = ASTHead.insertAfter(node);
continue;
}
pointer++;
}
if (pointer > contentStart) {
var finalNode = ast_1.SGRAstNode.New();
finalNode.setContent(data.substring(contentStart, pointer));
ASTHead = ASTHead.insertAfter(finalNode);
}
this.normalizeAst(ASTRoot);
return ASTRoot;
};
SGRCommandParser.prototype.isSGRCommandStart = function (data, position) {
var char = data[position];
for (var _i = 0, SGRCommandOpener_1 = SGRCommandOpener; _i < SGRCommandOpener_1.length; _i++) {
var openingSequence = SGRCommandOpener_1[_i];
// search for variants of the escape character followed by an opening byte
if (openingSequence.length === 1
? char === openingSequence
: openingSequence === data.slice(position, position + openingSequence.length)) {
return {
isValid: true,
commandOffset: openingSequence.length,
};
}
}
return {
isValid: false,
commandOffset: 0,
};
};
SGRCommandParser.prototype.parseSGRCommand = function (data) {
var node = new ast_1.SGRAstNode(types_1.EmptySGREffects, '');
var command = data;
// iterate incrementally over the command
while (command.length > 0) {
var hasFoundToken = false;
for (var i = 0; i < effects_1.TOKENS.length; i++) {
// search for a token, that matches the current command
if (command.startsWith(effects_1.EFFECTS[effects_1.TOKENS[i].token])) {
var token = effects_1.TOKENS[i].token;
// find a command parser for that matching token
var commandParser = commands_1.CommandParserMap[token];
if (!commandParser)
break;
// execute the command
var result = commandParser(command.slice(effects_1.EFFECTS[token].length));
// apply result, if command was successful
if (result.matches) {
hasFoundToken = true;
command = result.remainingCommand;
node.setEffects(__assign({}, result.alteredEffects));
break;
}
}
}
// it did not find a matching token or no token could successfully parse
if (!hasFoundToken) {
// check if there might be some valid commands remaining
var index = command.indexOf(effects_1.EFFECTS[effects_1.EffectKey.ChainCommand]);
if (index >= 0) {
// try again with probably still parsable content
command = command.substring(index + effects_1.EFFECTS[effects_1.EffectKey.ChainCommand].length);
}
else {
break;
}
}
}
return node;
};
/**
* ! this method *only* mutates references
* @internal
*/
SGRCommandParser.prototype.normalizeAst = function (head) {
var currentNode = head;
var previousEffects = types_1.EmptySGREffects;
while (currentNode !== undefined) {
var newEffects = this.mergeEffects(previousEffects, currentNode.effect);
var normalizedEffects = this.normalizeEffect(newEffects);
currentNode.setEffects(normalizedEffects);
previousEffects = normalizedEffects;
currentNode = currentNode.nextNode;
}
};
/**
* @internal
*/
SGRCommandParser.prototype.mergeEffects = function (before, after) {
var effects = __assign(__assign({}, types_1.EmptySGREffects), before);
for (var _i = 0, _a = Object.entries(after); _i < _a.length; _i++) {
var _b = _a[_i], key = _b[0], value = _b[1];
if (value !== undefined) {
// @ts-ignore
effects[key] = value;
}
}
return effects;
};
/**
* @internal
*/
SGRCommandParser.prototype.normalizeEffect = function (effect) {
var base = __assign({}, types_1.DefaultSGREffects);
for (var _i = 0, _a = Object.entries(effect); _i < _a.length; _i++) {
var _b = _a[_i], key = _b[0], value = _b[1];
if (value !== undefined) {
// @ts-ignore
base[key] = value;
}
}
return base;
};
/**
* @internal
*/
SGRCommandParser.prototype.removeDefaultsFromEffect = function (effect) {
var base = __assign({}, types_1.EmptySGREffects);
for (var _i = 0, _a = Object.entries(effect); _i < _a.length; _i++) {
var _b = _a[_i], key = _b[0], value = _b[1];
// @ts-ignore
if (value !== undefined && value !== types_1.DefaultSGREffects[key]) {
// @ts-ignore
base[key] = value;
}
}
return base;
};
return SGRCommandParser;
}());
exports.SGRCommandParser = SGRCommandParser;
//# sourceMappingURL=parser.js.map