mirror of
https://github.com/thelounge/thelounge.git
synced 2024-05-09 09:46:42 +02:00
1126 lines
21 KiB
JavaScript
1126 lines
21 KiB
JavaScript
"use strict";
|
|
|
|
const expect = require("chai").expect;
|
|
const parseStyle = require("../../../../../client/js/helpers/ircmessageparser/parseStyle");
|
|
|
|
describe("parseStyle", () => {
|
|
it("should skip control codes", () => {
|
|
const input = "text\x01with\x04control\x05codes";
|
|
const expected = [
|
|
{
|
|
bold: false,
|
|
textColor: undefined,
|
|
bgColor: undefined,
|
|
hexColor: undefined,
|
|
hexBgColor: undefined,
|
|
italic: false,
|
|
underline: false,
|
|
strikethrough: false,
|
|
monospace: false,
|
|
text: "textwithcontrolcodes",
|
|
|
|
start: 0,
|
|
end: 20,
|
|
},
|
|
];
|
|
|
|
const actual = parseStyle(input);
|
|
|
|
expect(actual).to.deep.equal(expected);
|
|
});
|
|
|
|
it("should parse bold", () => {
|
|
const input = "\x02bold";
|
|
const expected = [
|
|
{
|
|
bold: true,
|
|
textColor: undefined,
|
|
bgColor: undefined,
|
|
hexColor: undefined,
|
|
hexBgColor: undefined,
|
|
italic: false,
|
|
underline: false,
|
|
strikethrough: false,
|
|
monospace: false,
|
|
text: "bold",
|
|
|
|
start: 0,
|
|
end: 4,
|
|
},
|
|
];
|
|
|
|
const actual = parseStyle(input);
|
|
|
|
expect(actual).to.deep.equal(expected);
|
|
});
|
|
|
|
it("should parse strikethrough", () => {
|
|
const input = "\x1estrikethrough text\x1e";
|
|
const expected = [
|
|
{
|
|
bold: false,
|
|
textColor: undefined,
|
|
bgColor: undefined,
|
|
hexColor: undefined,
|
|
hexBgColor: undefined,
|
|
italic: false,
|
|
underline: false,
|
|
strikethrough: true,
|
|
monospace: false,
|
|
text: "strikethrough text",
|
|
|
|
start: 0,
|
|
end: 18,
|
|
},
|
|
];
|
|
|
|
const actual = parseStyle(input);
|
|
|
|
expect(actual).to.deep.equal(expected);
|
|
});
|
|
|
|
it("should parse monospace", () => {
|
|
const input = "\x11monospace text\x1e";
|
|
const expected = [
|
|
{
|
|
bold: false,
|
|
textColor: undefined,
|
|
bgColor: undefined,
|
|
hexColor: undefined,
|
|
hexBgColor: undefined,
|
|
italic: false,
|
|
underline: false,
|
|
strikethrough: false,
|
|
monospace: true,
|
|
text: "monospace text",
|
|
|
|
start: 0,
|
|
end: 14,
|
|
},
|
|
];
|
|
|
|
const actual = parseStyle(input);
|
|
|
|
expect(actual).to.deep.equal(expected);
|
|
});
|
|
|
|
it("should toggle monospace correctly", () => {
|
|
const input = "toggling \x11on and \x11off and \x11on again\x11";
|
|
const expected = [
|
|
{
|
|
bold: false,
|
|
textColor: undefined,
|
|
bgColor: undefined,
|
|
hexColor: undefined,
|
|
hexBgColor: undefined,
|
|
italic: false,
|
|
underline: false,
|
|
strikethrough: false,
|
|
monospace: false,
|
|
text: "toggling ",
|
|
|
|
start: 0,
|
|
end: 9,
|
|
},
|
|
{
|
|
bold: false,
|
|
textColor: undefined,
|
|
bgColor: undefined,
|
|
hexColor: undefined,
|
|
hexBgColor: undefined,
|
|
italic: false,
|
|
underline: false,
|
|
strikethrough: false,
|
|
monospace: true,
|
|
text: "on and ",
|
|
|
|
start: 9,
|
|
end: 16,
|
|
},
|
|
{
|
|
bold: false,
|
|
textColor: undefined,
|
|
bgColor: undefined,
|
|
hexColor: undefined,
|
|
hexBgColor: undefined,
|
|
italic: false,
|
|
underline: false,
|
|
strikethrough: false,
|
|
monospace: false,
|
|
text: "off and ",
|
|
|
|
start: 16,
|
|
end: 24,
|
|
},
|
|
{
|
|
bold: false,
|
|
textColor: undefined,
|
|
bgColor: undefined,
|
|
hexColor: undefined,
|
|
hexBgColor: undefined,
|
|
italic: false,
|
|
underline: false,
|
|
strikethrough: false,
|
|
monospace: true,
|
|
text: "on again",
|
|
|
|
start: 24,
|
|
end: 32,
|
|
},
|
|
];
|
|
|
|
const actual = parseStyle(input);
|
|
|
|
expect(actual).to.deep.equal(expected);
|
|
});
|
|
|
|
it("should parse monospace and underline", () => {
|
|
const input =
|
|
"\x1funderline formatting \x11with monospace\x1f no underline \x11 and vanilla";
|
|
const expected = [
|
|
{
|
|
bold: false,
|
|
textColor: undefined,
|
|
bgColor: undefined,
|
|
hexColor: undefined,
|
|
hexBgColor: undefined,
|
|
italic: false,
|
|
underline: true,
|
|
strikethrough: false,
|
|
monospace: false,
|
|
text: "underline formatting ",
|
|
|
|
start: 0,
|
|
end: 21,
|
|
},
|
|
{
|
|
bold: false,
|
|
textColor: undefined,
|
|
bgColor: undefined,
|
|
hexColor: undefined,
|
|
hexBgColor: undefined,
|
|
italic: false,
|
|
underline: true,
|
|
strikethrough: false,
|
|
monospace: true,
|
|
text: "with monospace",
|
|
|
|
start: 21,
|
|
end: 35,
|
|
},
|
|
{
|
|
bold: false,
|
|
textColor: undefined,
|
|
bgColor: undefined,
|
|
hexColor: undefined,
|
|
hexBgColor: undefined,
|
|
italic: false,
|
|
underline: false,
|
|
strikethrough: false,
|
|
monospace: true,
|
|
text: " no underline ",
|
|
|
|
start: 35,
|
|
end: 49,
|
|
},
|
|
{
|
|
bold: false,
|
|
textColor: undefined,
|
|
bgColor: undefined,
|
|
hexColor: undefined,
|
|
hexBgColor: undefined,
|
|
italic: false,
|
|
underline: false,
|
|
strikethrough: false,
|
|
monospace: false,
|
|
text: " and vanilla",
|
|
|
|
start: 49,
|
|
end: 61,
|
|
},
|
|
];
|
|
|
|
const actual = parseStyle(input);
|
|
|
|
expect(actual).to.deep.equal(expected);
|
|
});
|
|
|
|
it("should parse monospace and text colors", () => {
|
|
const input = "\x037,9\x11text with color and monospace\x11\x03";
|
|
const expected = [
|
|
{
|
|
bold: false,
|
|
textColor: 7,
|
|
bgColor: 9,
|
|
hexColor: undefined,
|
|
hexBgColor: undefined,
|
|
italic: false,
|
|
underline: false,
|
|
strikethrough: false,
|
|
monospace: true,
|
|
text: "text with color and monospace",
|
|
|
|
start: 0,
|
|
end: 29,
|
|
},
|
|
];
|
|
|
|
const actual = parseStyle(input);
|
|
|
|
expect(actual).to.deep.equal(expected);
|
|
});
|
|
|
|
it("should parse strikethrough and italics", () => {
|
|
const input = "\x1ditalic formatting \x1ewith strikethrough\x1d no italic \x1e and vanilla";
|
|
const expected = [
|
|
{
|
|
bold: false,
|
|
textColor: undefined,
|
|
bgColor: undefined,
|
|
hexColor: undefined,
|
|
hexBgColor: undefined,
|
|
italic: true,
|
|
underline: false,
|
|
strikethrough: false,
|
|
monospace: false,
|
|
text: "italic formatting ",
|
|
|
|
start: 0,
|
|
end: 18,
|
|
},
|
|
{
|
|
bold: false,
|
|
textColor: undefined,
|
|
bgColor: undefined,
|
|
hexColor: undefined,
|
|
hexBgColor: undefined,
|
|
italic: true,
|
|
underline: false,
|
|
strikethrough: true,
|
|
monospace: false,
|
|
text: "with strikethrough",
|
|
|
|
start: 18,
|
|
end: 36,
|
|
},
|
|
{
|
|
bold: false,
|
|
textColor: undefined,
|
|
bgColor: undefined,
|
|
hexColor: undefined,
|
|
hexBgColor: undefined,
|
|
italic: false,
|
|
underline: false,
|
|
strikethrough: true,
|
|
monospace: false,
|
|
text: " no italic ",
|
|
|
|
start: 36,
|
|
end: 47,
|
|
},
|
|
{
|
|
bold: false,
|
|
textColor: undefined,
|
|
bgColor: undefined,
|
|
hexColor: undefined,
|
|
hexBgColor: undefined,
|
|
italic: false,
|
|
underline: false,
|
|
strikethrough: false,
|
|
monospace: false,
|
|
text: " and vanilla",
|
|
|
|
start: 47,
|
|
end: 59,
|
|
},
|
|
];
|
|
|
|
const actual = parseStyle(input);
|
|
|
|
expect(actual).to.deep.equal(expected);
|
|
});
|
|
|
|
it("should parse strikethrough and text colors", () => {
|
|
const input = "\x031,2text with color \x1eand strikethrough\x1e\x03";
|
|
const expected = [
|
|
{
|
|
bold: false,
|
|
textColor: 1,
|
|
bgColor: 2,
|
|
hexColor: undefined,
|
|
hexBgColor: undefined,
|
|
italic: false,
|
|
underline: false,
|
|
strikethrough: false,
|
|
monospace: false,
|
|
text: "text with color ",
|
|
|
|
start: 0,
|
|
end: 16,
|
|
},
|
|
{
|
|
bold: false,
|
|
textColor: 1,
|
|
bgColor: 2,
|
|
hexColor: undefined,
|
|
hexBgColor: undefined,
|
|
italic: false,
|
|
underline: false,
|
|
strikethrough: true,
|
|
monospace: false,
|
|
text: "and strikethrough",
|
|
|
|
start: 16,
|
|
end: 33,
|
|
},
|
|
];
|
|
|
|
const actual = parseStyle(input);
|
|
|
|
expect(actual).to.deep.equal(expected);
|
|
});
|
|
|
|
it("should correctly parse multiple unclosed format tokens", () => {
|
|
const input = "\x1e\x02\x1d\x033,4string with multiple unclosed formats";
|
|
const expected = [
|
|
{
|
|
bold: true,
|
|
textColor: 3,
|
|
bgColor: 4,
|
|
hexColor: undefined,
|
|
hexBgColor: undefined,
|
|
italic: true,
|
|
underline: false,
|
|
strikethrough: true,
|
|
monospace: false,
|
|
text: "string with multiple unclosed formats",
|
|
|
|
start: 0,
|
|
end: 37,
|
|
},
|
|
];
|
|
|
|
const actual = parseStyle(input);
|
|
|
|
expect(actual).to.deep.equal(expected);
|
|
});
|
|
|
|
it("should toggle strikethrough correctly", () => {
|
|
const input = "toggling \x1eon and \x1eoff and \x1eon again\x1e";
|
|
const expected = [
|
|
{
|
|
bold: false,
|
|
textColor: undefined,
|
|
bgColor: undefined,
|
|
hexColor: undefined,
|
|
hexBgColor: undefined,
|
|
italic: false,
|
|
underline: false,
|
|
strikethrough: false,
|
|
monospace: false,
|
|
text: "toggling ",
|
|
|
|
start: 0,
|
|
end: 9,
|
|
},
|
|
{
|
|
bold: false,
|
|
textColor: undefined,
|
|
bgColor: undefined,
|
|
hexColor: undefined,
|
|
hexBgColor: undefined,
|
|
italic: false,
|
|
underline: false,
|
|
strikethrough: true,
|
|
monospace: false,
|
|
text: "on and ",
|
|
|
|
start: 9,
|
|
end: 16,
|
|
},
|
|
{
|
|
bold: false,
|
|
textColor: undefined,
|
|
bgColor: undefined,
|
|
hexColor: undefined,
|
|
hexBgColor: undefined,
|
|
italic: false,
|
|
underline: false,
|
|
strikethrough: false,
|
|
monospace: false,
|
|
text: "off and ",
|
|
|
|
start: 16,
|
|
end: 24,
|
|
},
|
|
{
|
|
bold: false,
|
|
textColor: undefined,
|
|
bgColor: undefined,
|
|
hexColor: undefined,
|
|
hexBgColor: undefined,
|
|
italic: false,
|
|
underline: false,
|
|
strikethrough: true,
|
|
monospace: false,
|
|
text: "on again",
|
|
|
|
start: 24,
|
|
end: 32,
|
|
},
|
|
];
|
|
|
|
const actual = parseStyle(input);
|
|
|
|
expect(actual).to.deep.equal(expected);
|
|
});
|
|
|
|
it("should parse textColor", () => {
|
|
const input = "\x038yellowText";
|
|
const expected = [
|
|
{
|
|
bold: false,
|
|
textColor: 8,
|
|
bgColor: undefined,
|
|
hexColor: undefined,
|
|
hexBgColor: undefined,
|
|
italic: false,
|
|
underline: false,
|
|
strikethrough: false,
|
|
monospace: false,
|
|
text: "yellowText",
|
|
|
|
start: 0,
|
|
end: 10,
|
|
},
|
|
];
|
|
|
|
const actual = parseStyle(input);
|
|
|
|
expect(actual).to.deep.equal(expected);
|
|
});
|
|
|
|
it("should parse textColor and background", () => {
|
|
const input = "\x034,8yellowBG redText";
|
|
const expected = [
|
|
{
|
|
textColor: 4,
|
|
bgColor: 8,
|
|
hexColor: undefined,
|
|
hexBgColor: undefined,
|
|
bold: false,
|
|
italic: false,
|
|
underline: false,
|
|
strikethrough: false,
|
|
monospace: false,
|
|
text: "yellowBG redText",
|
|
|
|
start: 0,
|
|
end: 16,
|
|
},
|
|
];
|
|
|
|
const actual = parseStyle(input);
|
|
|
|
expect(actual).to.deep.equal(expected);
|
|
});
|
|
|
|
it("should parse extended colors", () => {
|
|
const input = "\x0370,99some text";
|
|
const expected = [
|
|
{
|
|
textColor: 70,
|
|
bgColor: 99,
|
|
hexColor: undefined,
|
|
hexBgColor: undefined,
|
|
bold: false,
|
|
italic: false,
|
|
underline: false,
|
|
strikethrough: false,
|
|
monospace: false,
|
|
text: "some text",
|
|
|
|
start: 0,
|
|
end: 9,
|
|
},
|
|
];
|
|
|
|
const actual = parseStyle(input);
|
|
|
|
expect(actual).to.deep.equal(expected);
|
|
});
|
|
|
|
it("should parse italic", () => {
|
|
const input = "\x1ditalic";
|
|
const expected = [
|
|
{
|
|
bold: false,
|
|
textColor: undefined,
|
|
bgColor: undefined,
|
|
hexColor: undefined,
|
|
hexBgColor: undefined,
|
|
italic: true,
|
|
underline: false,
|
|
strikethrough: false,
|
|
monospace: false,
|
|
text: "italic",
|
|
|
|
start: 0,
|
|
end: 6,
|
|
},
|
|
];
|
|
|
|
const actual = parseStyle(input);
|
|
|
|
expect(actual).to.deep.equal(expected);
|
|
});
|
|
|
|
it("should parse hex colors", () => {
|
|
const input =
|
|
"test \x04FFFFFFnice \x02\x04RES006 \x0303,04\x04ff00FFcolored\x04eeeaFF,001122 background\x04\x03\x02?";
|
|
const expected = [
|
|
{
|
|
bold: false,
|
|
textColor: undefined,
|
|
bgColor: undefined,
|
|
hexColor: undefined,
|
|
hexBgColor: undefined,
|
|
italic: false,
|
|
underline: false,
|
|
strikethrough: false,
|
|
monospace: false,
|
|
text: "test ",
|
|
|
|
start: 0,
|
|
end: 5,
|
|
},
|
|
{
|
|
bold: false,
|
|
textColor: undefined,
|
|
bgColor: undefined,
|
|
hexColor: "FFFFFF",
|
|
hexBgColor: undefined,
|
|
italic: false,
|
|
underline: false,
|
|
strikethrough: false,
|
|
monospace: false,
|
|
text: "nice ",
|
|
|
|
start: 5,
|
|
end: 10,
|
|
},
|
|
{
|
|
bold: true,
|
|
textColor: undefined,
|
|
bgColor: undefined,
|
|
hexColor: undefined,
|
|
hexBgColor: undefined,
|
|
italic: false,
|
|
underline: false,
|
|
strikethrough: false,
|
|
monospace: false,
|
|
text: "RES006 ",
|
|
|
|
start: 10,
|
|
end: 17,
|
|
},
|
|
{
|
|
bold: true,
|
|
textColor: 3,
|
|
bgColor: 4,
|
|
hexColor: "FF00FF",
|
|
hexBgColor: undefined,
|
|
italic: false,
|
|
underline: false,
|
|
strikethrough: false,
|
|
monospace: false,
|
|
text: "colored",
|
|
|
|
start: 17,
|
|
end: 24,
|
|
},
|
|
{
|
|
bold: true,
|
|
textColor: 3,
|
|
bgColor: 4,
|
|
hexColor: "EEEAFF",
|
|
hexBgColor: "001122",
|
|
italic: false,
|
|
underline: false,
|
|
strikethrough: false,
|
|
monospace: false,
|
|
text: " background",
|
|
|
|
start: 24,
|
|
end: 35,
|
|
},
|
|
{
|
|
bold: false,
|
|
textColor: undefined,
|
|
bgColor: undefined,
|
|
hexColor: undefined,
|
|
hexBgColor: undefined,
|
|
italic: false,
|
|
underline: false,
|
|
strikethrough: false,
|
|
monospace: false,
|
|
text: "?",
|
|
|
|
start: 35,
|
|
end: 36,
|
|
},
|
|
];
|
|
|
|
const actual = parseStyle(input);
|
|
|
|
expect(actual).to.deep.equal(expected);
|
|
});
|
|
|
|
it("should reverse and format color", () => {
|
|
const input = "\x032,9text with fg and bg \x16with text reversed";
|
|
const expected = [
|
|
{
|
|
bold: false,
|
|
textColor: 2,
|
|
bgColor: 9,
|
|
hexColor: undefined,
|
|
hexBgColor: undefined,
|
|
italic: false,
|
|
underline: false,
|
|
strikethrough: false,
|
|
monospace: false,
|
|
text: "text with fg and bg ",
|
|
|
|
start: 0,
|
|
end: 20,
|
|
},
|
|
{
|
|
bold: false,
|
|
textColor: 9,
|
|
bgColor: 2,
|
|
hexColor: undefined,
|
|
hexBgColor: undefined,
|
|
italic: false,
|
|
underline: false,
|
|
strikethrough: false,
|
|
monospace: false,
|
|
text: "with text reversed",
|
|
|
|
start: 20,
|
|
end: 38,
|
|
},
|
|
];
|
|
|
|
const actual = parseStyle(input);
|
|
|
|
expect(actual).to.deep.equal(expected);
|
|
});
|
|
|
|
it("should toggle reverse correctly", () => {
|
|
const input = "\x0305,11text \x16reversed and \x16back again and \x16reversed";
|
|
const expected = [
|
|
{
|
|
bold: false,
|
|
textColor: 5,
|
|
bgColor: 11,
|
|
hexColor: undefined,
|
|
hexBgColor: undefined,
|
|
italic: false,
|
|
underline: false,
|
|
strikethrough: false,
|
|
monospace: false,
|
|
text: "text ",
|
|
|
|
start: 0,
|
|
end: 5,
|
|
},
|
|
{
|
|
bold: false,
|
|
textColor: 11,
|
|
bgColor: 5,
|
|
hexColor: undefined,
|
|
hexBgColor: undefined,
|
|
italic: false,
|
|
underline: false,
|
|
strikethrough: false,
|
|
monospace: false,
|
|
text: "reversed and ",
|
|
|
|
start: 5,
|
|
end: 18,
|
|
},
|
|
{
|
|
bold: false,
|
|
textColor: 5,
|
|
bgColor: 11,
|
|
hexColor: undefined,
|
|
hexBgColor: undefined,
|
|
italic: false,
|
|
underline: false,
|
|
strikethrough: false,
|
|
monospace: false,
|
|
text: "back again and ",
|
|
|
|
start: 18,
|
|
end: 33,
|
|
},
|
|
{
|
|
bold: false,
|
|
textColor: 11,
|
|
bgColor: 5,
|
|
hexColor: undefined,
|
|
hexBgColor: undefined,
|
|
italic: false,
|
|
underline: false,
|
|
strikethrough: false,
|
|
monospace: false,
|
|
text: "reversed",
|
|
|
|
start: 33,
|
|
end: 41,
|
|
},
|
|
];
|
|
|
|
const actual = parseStyle(input);
|
|
|
|
expect(actual).to.deep.equal(expected);
|
|
});
|
|
|
|
it("should escape reverse when a new style is applied", () => {
|
|
const input = "\x0311,02text \x16 reversed \x0304,05 and new style";
|
|
const expected = [
|
|
{
|
|
bold: false,
|
|
textColor: 11,
|
|
bgColor: 2,
|
|
hexColor: undefined,
|
|
hexBgColor: undefined,
|
|
italic: false,
|
|
underline: false,
|
|
strikethrough: false,
|
|
monospace: false,
|
|
text: "text ",
|
|
|
|
start: 0,
|
|
end: 5,
|
|
},
|
|
{
|
|
bold: false,
|
|
textColor: 2,
|
|
bgColor: 11,
|
|
hexColor: undefined,
|
|
hexBgColor: undefined,
|
|
italic: false,
|
|
underline: false,
|
|
strikethrough: false,
|
|
monospace: false,
|
|
text: " reversed ",
|
|
|
|
start: 5,
|
|
end: 15,
|
|
},
|
|
{
|
|
bold: false,
|
|
textColor: 4,
|
|
bgColor: 5,
|
|
hexColor: undefined,
|
|
hexBgColor: undefined,
|
|
italic: false,
|
|
underline: false,
|
|
strikethrough: false,
|
|
monospace: false,
|
|
text: " and new style",
|
|
|
|
start: 15,
|
|
end: 29,
|
|
},
|
|
];
|
|
|
|
const actual = parseStyle(input);
|
|
|
|
expect(actual).to.deep.equal(expected);
|
|
});
|
|
|
|
it("should not reverse if color is specified after reverse tag", () => {
|
|
const input = "\x16\x032,9text with fg and bg";
|
|
const expected = [
|
|
{
|
|
bold: false,
|
|
textColor: 2,
|
|
bgColor: 9,
|
|
hexColor: undefined,
|
|
hexBgColor: undefined,
|
|
italic: false,
|
|
underline: false,
|
|
strikethrough: false,
|
|
monospace: false,
|
|
text: "text with fg and bg",
|
|
|
|
start: 0,
|
|
end: 19,
|
|
},
|
|
];
|
|
|
|
const actual = parseStyle(input);
|
|
|
|
expect(actual).to.deep.equal(expected);
|
|
});
|
|
|
|
it("should reverse, bold, and italics", () => {
|
|
const input = "\x034,13\x16\x02some text with \x1ditalics";
|
|
const expected = [
|
|
{
|
|
bold: true,
|
|
textColor: 13,
|
|
bgColor: 4,
|
|
hexColor: undefined,
|
|
hexBgColor: undefined,
|
|
italic: false,
|
|
underline: false,
|
|
strikethrough: false,
|
|
monospace: false,
|
|
text: "some text with ",
|
|
|
|
start: 0,
|
|
end: 15,
|
|
},
|
|
{
|
|
bold: true,
|
|
textColor: 13,
|
|
bgColor: 4,
|
|
hexColor: undefined,
|
|
hexBgColor: undefined,
|
|
italic: true,
|
|
underline: false,
|
|
strikethrough: false,
|
|
monospace: false,
|
|
text: "italics",
|
|
|
|
start: 15,
|
|
end: 22,
|
|
},
|
|
];
|
|
|
|
const actual = parseStyle(input);
|
|
|
|
expect(actual).to.deep.equal(expected);
|
|
});
|
|
|
|
it("should carry state correctly forward", () => {
|
|
const input = "\x02bold\x038yellow\x02nonBold\x03default";
|
|
const expected = [
|
|
{
|
|
bold: true,
|
|
textColor: undefined,
|
|
bgColor: undefined,
|
|
hexColor: undefined,
|
|
hexBgColor: undefined,
|
|
italic: false,
|
|
underline: false,
|
|
strikethrough: false,
|
|
monospace: false,
|
|
text: "bold",
|
|
|
|
start: 0,
|
|
end: 4,
|
|
},
|
|
{
|
|
bold: true,
|
|
textColor: 8,
|
|
bgColor: undefined,
|
|
hexColor: undefined,
|
|
hexBgColor: undefined,
|
|
italic: false,
|
|
underline: false,
|
|
strikethrough: false,
|
|
monospace: false,
|
|
text: "yellow",
|
|
|
|
start: 4,
|
|
end: 10,
|
|
},
|
|
{
|
|
bold: false,
|
|
textColor: 8,
|
|
bgColor: undefined,
|
|
hexColor: undefined,
|
|
hexBgColor: undefined,
|
|
italic: false,
|
|
underline: false,
|
|
strikethrough: false,
|
|
monospace: false,
|
|
text: "nonBold",
|
|
|
|
start: 10,
|
|
end: 17,
|
|
},
|
|
{
|
|
bold: false,
|
|
textColor: undefined,
|
|
bgColor: undefined,
|
|
hexColor: undefined,
|
|
hexBgColor: undefined,
|
|
italic: false,
|
|
underline: false,
|
|
strikethrough: false,
|
|
monospace: false,
|
|
text: "default",
|
|
|
|
start: 17,
|
|
end: 24,
|
|
},
|
|
];
|
|
|
|
const actual = parseStyle(input);
|
|
|
|
expect(actual).to.deep.equal(expected);
|
|
});
|
|
|
|
it("should toggle bold correctly", () => {
|
|
const input = "\x02bold\x02 \x02bold\x02";
|
|
const expected = [
|
|
{
|
|
bold: true,
|
|
textColor: undefined,
|
|
bgColor: undefined,
|
|
hexColor: undefined,
|
|
hexBgColor: undefined,
|
|
italic: false,
|
|
underline: false,
|
|
strikethrough: false,
|
|
monospace: false,
|
|
text: "bold",
|
|
|
|
start: 0,
|
|
end: 4,
|
|
},
|
|
{
|
|
bold: false,
|
|
textColor: undefined,
|
|
bgColor: undefined,
|
|
hexColor: undefined,
|
|
hexBgColor: undefined,
|
|
italic: false,
|
|
underline: false,
|
|
strikethrough: false,
|
|
monospace: false,
|
|
text: " ",
|
|
|
|
start: 4,
|
|
end: 5,
|
|
},
|
|
{
|
|
bold: true,
|
|
textColor: undefined,
|
|
bgColor: undefined,
|
|
hexColor: undefined,
|
|
hexBgColor: undefined,
|
|
italic: false,
|
|
underline: false,
|
|
strikethrough: false,
|
|
monospace: false,
|
|
text: "bold",
|
|
|
|
start: 5,
|
|
end: 9,
|
|
},
|
|
];
|
|
|
|
const actual = parseStyle(input);
|
|
|
|
expect(actual).to.deep.equal(expected);
|
|
});
|
|
|
|
it("should reset all styles", () => {
|
|
const input = "\x11\x1e\x02\x034\x16\x1d\x1ffull\x0fnone";
|
|
const expected = [
|
|
{
|
|
bold: true,
|
|
textColor: undefined,
|
|
bgColor: 4, // \x16: fg- and bg- are reversed
|
|
hexColor: undefined,
|
|
hexBgColor: undefined,
|
|
italic: true,
|
|
underline: true,
|
|
strikethrough: true,
|
|
monospace: true,
|
|
text: "full",
|
|
|
|
start: 0,
|
|
end: 4,
|
|
},
|
|
{
|
|
bold: false,
|
|
textColor: undefined,
|
|
bgColor: undefined,
|
|
hexColor: undefined,
|
|
hexBgColor: undefined,
|
|
italic: false,
|
|
underline: false,
|
|
strikethrough: false,
|
|
monospace: false,
|
|
text: "none",
|
|
|
|
start: 4,
|
|
end: 8,
|
|
},
|
|
];
|
|
|
|
const actual = parseStyle(input);
|
|
|
|
expect(actual).to.deep.equal(expected);
|
|
});
|
|
|
|
it("should not emit empty fragments", () => {
|
|
const input = "\x031\x031,2\x031\x031,2\x031\x031,2\x03a";
|
|
const expected = [
|
|
{
|
|
bold: false,
|
|
textColor: undefined,
|
|
bgColor: undefined,
|
|
hexColor: undefined,
|
|
hexBgColor: undefined,
|
|
italic: false,
|
|
underline: false,
|
|
strikethrough: false,
|
|
monospace: false,
|
|
text: "a",
|
|
|
|
start: 0,
|
|
end: 1,
|
|
},
|
|
];
|
|
|
|
const actual = parseStyle(input);
|
|
|
|
expect(actual).to.deep.equal(expected);
|
|
});
|
|
|
|
it("should optimize fragments", () => {
|
|
const rawString = "oh hi test text";
|
|
const colorCode = "\x0312";
|
|
const input = colorCode + rawString.split("").join(colorCode);
|
|
const expected = [
|
|
{
|
|
bold: false,
|
|
textColor: 12,
|
|
bgColor: undefined,
|
|
hexColor: undefined,
|
|
hexBgColor: undefined,
|
|
italic: false,
|
|
underline: false,
|
|
strikethrough: false,
|
|
monospace: false,
|
|
text: rawString,
|
|
|
|
start: 0,
|
|
end: rawString.length,
|
|
},
|
|
];
|
|
|
|
const actual = parseStyle(input);
|
|
|
|
expect(actual).to.deep.equal(expected);
|
|
});
|
|
});
|