292 lines
9.0 KiB
JavaScript
292 lines
9.0 KiB
JavaScript
/* jslint node: true */
|
|
'use strict';
|
|
|
|
var ansi = require('./ansi_term.js');
|
|
var getPredefinedMCIValue = require('./predefined_mci.js').getPredefinedMCIValue;
|
|
|
|
var assert = require('assert');
|
|
var _ = require('lodash');
|
|
|
|
exports.enigmaToAnsi = enigmaToAnsi;
|
|
exports.stripPipeCodes = exports.stripEnigmaCodes = stripEnigmaCodes;
|
|
exports.pipeStrLen = exports.enigmaStrLen = enigmaStrLen;
|
|
exports.pipeToAnsi = exports.renegadeToAnsi = renegadeToAnsi;
|
|
exports.controlCodesToAnsi = controlCodesToAnsi;
|
|
|
|
// :TODO: Not really happy with the module name of "color_codes". Would like something better
|
|
|
|
|
|
|
|
|
|
// Also add:
|
|
// * fromCelerity(): |<case sensitive letter>
|
|
// * fromPCBoard(): (@X<bg><fg>)
|
|
// * fromWildcat(): (@<bg><fg>@ (same as PCBoard without 'X' prefix and '@' suffix)
|
|
// * fromWWIV(): <ctrl-c><0-7>
|
|
// * fromSyncronet(): <ctrl-a><colorCode>
|
|
// See http://wiki.synchro.net/custom:colors
|
|
|
|
// :TODO: rid of enigmaToAnsi() -- never really use. Instead, create bbsToAnsi() that supports renegade, PCB, WWIV, etc...
|
|
function enigmaToAnsi(s, client) {
|
|
if(-1 == s.indexOf('|')) {
|
|
return s; // no pipe codes present
|
|
}
|
|
|
|
var result = '';
|
|
var re = /\|([A-Z\d]{2}|\|)/g;
|
|
var m;
|
|
var lastIndex = 0;
|
|
while((m = re.exec(s))) {
|
|
var val = m[1];
|
|
|
|
if('|' == val) {
|
|
result += '|';
|
|
continue;
|
|
}
|
|
|
|
// convert to number
|
|
val = parseInt(val, 10);
|
|
if(isNaN(val)) {
|
|
//
|
|
// ENiGMA MCI code? Only available if |client|
|
|
// is supplied.
|
|
//
|
|
val = getPredefinedMCIValue(client, m[1]) || ('|' + m[1]); // value itself or literal
|
|
}
|
|
|
|
if(_.isString(val)) {
|
|
result += s.substr(lastIndex, m.index - lastIndex) + val;
|
|
} else {
|
|
assert(val >= 0 && val <= 47);
|
|
|
|
var attr = '';
|
|
if(7 == val) {
|
|
attr = ansi.sgr('normal');
|
|
} else if (val < 7 || val >= 16) {
|
|
attr = ansi.sgr(['normal', val]);
|
|
} else if (val <= 15) {
|
|
attr = ansi.sgr(['normal', val - 8, 'bold']);
|
|
}
|
|
|
|
result += s.substr(lastIndex, m.index - lastIndex) + attr;
|
|
}
|
|
|
|
lastIndex = re.lastIndex;
|
|
}
|
|
|
|
result = (0 === result.length ? s : result + s.substr(lastIndex));
|
|
|
|
return result;
|
|
}
|
|
|
|
function stripEnigmaCodes(s) {
|
|
return s.replace(/\|[A-Z\d]{2}/g, '');
|
|
}
|
|
|
|
function enigmaStrLen(s) {
|
|
return stripEnigmaCodes(s).length;
|
|
}
|
|
|
|
function ansiSgrFromRenegadeColorCode(cc) {
|
|
return ansi.sgr({
|
|
0 : [ 'reset', 'black' ],
|
|
1 : [ 'reset', 'blue' ],
|
|
2 : [ 'reset', 'green' ],
|
|
3 : [ 'reset', 'cyan' ],
|
|
4 : [ 'reset', 'red' ],
|
|
5 : [ 'reset', 'magenta' ],
|
|
6 : [ 'reset', 'yellow' ],
|
|
7 : [ 'reset', 'white' ],
|
|
|
|
8 : [ 'bold', 'black' ],
|
|
9 : [ 'bold', 'blue' ],
|
|
10 : [ 'bold', 'green' ],
|
|
11 : [ 'bold', 'cyan' ],
|
|
12 : [ 'bold', 'red' ],
|
|
13 : [ 'bold', 'magenta' ],
|
|
14 : [ 'bold', 'yellow' ],
|
|
15 : [ 'bold', 'white' ],
|
|
|
|
16 : [ 'blackBG' ],
|
|
17 : [ 'blueBG' ],
|
|
18 : [ 'greenBG' ],
|
|
19 : [ 'cyanBG' ],
|
|
20 : [ 'redBG' ],
|
|
21 : [ 'magentaBG' ],
|
|
22 : [ 'yellowBG' ],
|
|
23 : [ 'whiteBG' ],
|
|
|
|
24 : [ 'blink', 'blackBG' ],
|
|
25 : [ 'blink', 'blueBG' ],
|
|
26 : [ 'blink', 'greenBG' ],
|
|
27 : [ 'blink', 'cyanBG' ],
|
|
28 : [ 'blink', 'redBG' ],
|
|
29 : [ 'blink', 'magentaBG' ],
|
|
30 : [ 'blink', 'yellowBG' ],
|
|
31 : [ 'blink', 'whiteBG' ],
|
|
}[cc] || 'normal');
|
|
}
|
|
|
|
function renegadeToAnsi(s, client) {
|
|
if(-1 == s.indexOf('|')) {
|
|
return s; // no pipe codes present
|
|
}
|
|
|
|
var result = '';
|
|
var re = /\|([A-Z\d]{2}|\|)/g;
|
|
var m;
|
|
var lastIndex = 0;
|
|
while((m = re.exec(s))) {
|
|
var val = m[1];
|
|
|
|
if('|' == val) {
|
|
result += '|';
|
|
continue;
|
|
}
|
|
|
|
// convert to number
|
|
val = parseInt(val, 10);
|
|
if(isNaN(val)) {
|
|
val = getPredefinedMCIValue(client, m[1]) || ('|' + m[1]); // value itself or literal
|
|
}
|
|
|
|
if(_.isString(val)) {
|
|
result += s.substr(lastIndex, m.index - lastIndex) + val;
|
|
} else {
|
|
const attr = ansiSgrFromRenegadeColorCode(val);
|
|
result += s.substr(lastIndex, m.index - lastIndex) + attr;
|
|
}
|
|
|
|
lastIndex = re.lastIndex;
|
|
}
|
|
|
|
return (0 === result.length ? s : result + s.substr(lastIndex));
|
|
}
|
|
|
|
//
|
|
// Converts various control codes popular in BBS packages
|
|
// to ANSI escape sequences. Additionaly supports ENiGMA style
|
|
// MCI codes.
|
|
//
|
|
// Supported control code formats:
|
|
// * Renegade : |##
|
|
// * PCBoard : @X## where the first number/char is FG color, and second is BG
|
|
// * WildCat! : @##@ the same as PCBoard without the X prefix, but with a @ suffix
|
|
// * WWIV : ^#
|
|
//
|
|
// TODO: Add Synchronet and Celerity format support
|
|
//
|
|
// Resources:
|
|
// * http://wiki.synchro.net/custom:colors
|
|
//
|
|
function controlCodesToAnsi(s, client) {
|
|
const RE = /(\|([A-Z0-9]{2})|\|)|(@X([0-9A-F]{2}))|(@([0-9A-F]{2})@)|(\x03[0-9]|\x03)/g; // eslint-disable-line no-control-regex
|
|
|
|
let m;
|
|
let result = '';
|
|
let lastIndex = 0;
|
|
let v;
|
|
let fg;
|
|
let bg;
|
|
|
|
while((m = RE.exec(s))) {
|
|
switch(m[0].charAt(0)) {
|
|
case '|' :
|
|
// Renegade or ENiGMA MCI
|
|
v = parseInt(m[2], 10);
|
|
|
|
if(isNaN(v)) {
|
|
v = getPredefinedMCIValue(client, m[2]) || m[0]; // value itself or literal
|
|
}
|
|
|
|
if(_.isString(v)) {
|
|
result += s.substr(lastIndex, m.index - lastIndex) + v;
|
|
} else {
|
|
v = ansiSgrFromRenegadeColorCode(v);
|
|
result += s.substr(lastIndex, m.index - lastIndex) + v;
|
|
}
|
|
break;
|
|
|
|
case '@' :
|
|
// PCBoard @X## or Wildcat! @##@
|
|
if('@' === m[0].substr(-1)) {
|
|
// Wildcat!
|
|
v = m[6];
|
|
} else {
|
|
v = m[4];
|
|
}
|
|
|
|
fg = {
|
|
0 : [ 'reset', 'black' ],
|
|
1 : [ 'reset', 'blue' ],
|
|
2 : [ 'reset', 'green' ],
|
|
3 : [ 'reset', 'cyan' ],
|
|
4 : [ 'reset', 'red' ],
|
|
5 : [ 'reset', 'magenta' ],
|
|
6 : [ 'reset', 'yellow' ],
|
|
7 : [ 'reset', 'white' ],
|
|
|
|
8 : [ 'blink', 'black' ],
|
|
9 : [ 'blink', 'blue' ],
|
|
A : [ 'blink', 'green' ],
|
|
B : [ 'blink', 'cyan' ],
|
|
C : [ 'blink', 'red' ],
|
|
D : [ 'blink', 'magenta' ],
|
|
E : [ 'blink', 'yellow' ],
|
|
F : [ 'blink', 'white' ],
|
|
}[v.charAt(0)] || ['normal'];
|
|
|
|
bg = {
|
|
0 : [ 'blackBG' ],
|
|
1 : [ 'blueBG' ],
|
|
2 : [ 'greenBG' ],
|
|
3 : [ 'cyanBG' ],
|
|
4 : [ 'redBG' ],
|
|
5 : [ 'magentaBG' ],
|
|
6 : [ 'yellowBG' ],
|
|
7 : [ 'whiteBG' ],
|
|
|
|
8 : [ 'bold', 'blackBG' ],
|
|
9 : [ 'bold', 'blueBG' ],
|
|
A : [ 'bold', 'greenBG' ],
|
|
B : [ 'bold', 'cyanBG' ],
|
|
C : [ 'bold', 'redBG' ],
|
|
D : [ 'bold', 'magentaBG' ],
|
|
E : [ 'bold', 'yellowBG' ],
|
|
F : [ 'bold', 'whiteBG' ],
|
|
}[v.charAt(1)] || [ 'normal' ];
|
|
|
|
v = ansi.sgr(fg.concat(bg));
|
|
result += s.substr(lastIndex, m.index - lastIndex) + v;
|
|
break;
|
|
|
|
case '\x03' :
|
|
v = parseInt(m[8], 10);
|
|
|
|
if(isNaN(v)) {
|
|
v += m[0];
|
|
} else {
|
|
v = ansi.sgr({
|
|
0 : [ 'reset', 'black' ],
|
|
1 : [ 'bold', 'cyan' ],
|
|
2 : [ 'bold', 'yellow' ],
|
|
3 : [ 'reset', 'magenta' ],
|
|
4 : [ 'bold', 'white', 'blueBG' ],
|
|
5 : [ 'reset', 'green' ],
|
|
6 : [ 'bold', 'blink', 'red' ],
|
|
7 : [ 'bold', 'blue' ],
|
|
8 : [ 'reset', 'blue' ],
|
|
9 : [ 'reset', 'cyan' ],
|
|
}[v] || 'normal');
|
|
}
|
|
|
|
result += s.substr(lastIndex, m.index - lastIndex) + v;
|
|
|
|
break;
|
|
}
|
|
|
|
lastIndex = RE.lastIndex;
|
|
}
|
|
|
|
return (0 === result.length ? s : result + s.substr(lastIndex));
|
|
} |