@lightningjs/renderer

/* * If not stated otherwise in this file or this component's LICENSE file the * following copyright and licenses apply: * * Copyright 2025 Comcast Cable Communications Management, LLC. * * Licensed under the Apache License, Version 2.0 (the License); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ import { describe, it, expect, beforeEach } from 'vitest'; import { ParseResult, RichSpan, parseRichText, stripRichText, } from '../RichTextParser.js'; // --------------------------------------------------------------------------- // Helpers // --------------------------------------------------------------------------- let out: ParseResult; beforeEach(() => { out = new ParseResult(); }); const parse = (text: string) => { parseRichText(text, out); return out; }; /** Extract only the fields we care about from a span for concise assertions. */ const span = ( start: number, end: number, overrides: Partial<Omit<RichSpan, 'start' | 'end'>> = {}, ) => ({ start, end, bold: false, italic: false, underline: false, strikethrough: false, color: 0, ...overrides, }); const spansOf = (r: ParseResult) => Array.from({ length: r.spanCount }, (_, i) => { const s = r.spans[i]!; return { start: s.start, end: s.end, bold: s.bold, italic: s.italic, underline: s.underline, strikethrough: s.strikethrough, color: s.color, }; }); // --------------------------------------------------------------------------- // parseRichText — empty / plain text // --------------------------------------------------------------------------- describe('parseRichText', () => { describe('empty and plain text', () => { it('returns empty stripped and zero spans for empty string', () => { parse(''); expect(out.stripped).toBe(''); expect(out.spanCount).toBe(0); }); it('returns full text and one default span for plain text', () => { parse('Hello World'); expect(out.stripped).toBe('Hello World'); expect(out.spanCount).toBe(1); expect(spansOf(out)).toEqual([span(0, 11)]); }); it('returns original text and one span when no tags are present', () => { parse('No [markup] here'); // '[markup]' is unrecognised — emitted as literal expect(out.stripped).toBe('No [markup] here'); expect(out.spanCount).toBe(1); }); }); // ------------------------------------------------------------------------- // Single tags // ------------------------------------------------------------------------- describe('bold [b]', () => { it('parses a fully wrapped bold string', () => { parse('[b]hello[/b]'); expect(out.stripped).toBe('hello'); expect(spansOf(out)).toEqual([span(0, 5, { bold: true })]); }); it('produces three spans for bold inline', () => { parse('a [b]b[/b] c'); expect(out.stripped).toBe('a b c'); expect(spansOf(out)).toEqual([ span(0, 2), // 'a ' span(2, 3, { bold: true }), // 'b' span(3, 5), // ' c' ]); }); }); describe('italic [i]', () => { it('parses a fully wrapped italic string', () => { parse('[i]world[/i]'); expect(out.stripped).toBe('world'); expect(spansOf(out)).toEqual([span(0, 5, { italic: true })]); }); }); describe('underline [u]', () => { it('parses underline', () => { parse('[u]under[/u]'); expect(out.stripped).toBe('under'); expect(spansOf(out)).toEqual([span(0, 5, { underline: true })]); }); }); describe('strikethrough [s]', () => { it('parses strikethrough', () => { parse('[s]strike[/s]'); expect(out.stripped).toBe('strike'); expect(spansOf(out)).toEqual([span(0, 6, { strikethrough: true })]); }); }); // ------------------------------------------------------------------------- // Color tag // ------------------------------------------------------------------------- describe('[color]', () => { it('parses 0xRRGGBBAA color (opaque red)', () => { parse('[color=0xff0000ff]red[/color]'); expect(out.stripped).toBe('red'); expect(spansOf(out)).toEqual([span(0, 3, { color: 0xff0000ff })]); }); it('parses 0xRRGGBBAA color with partial alpha', () => { parse('[color=0xff000080]red[/color]'); expect(out.stripped).toBe('red'); expect(spansOf(out)).toEqual([span(0, 3, { color: 0xff000080 })]); }); it('parses 0xRRGGBBAA with uppercase 0X prefix', () => { parse('[color=0XFF0000FF]red[/color]'); expect(out.stripped).toBe('red'); expect(spansOf(out)).toEqual([span(0, 3, { color: 0xff0000ff })]); }); it('parses 0xRRGGBBAA with mixed-case hex digits', () => { parse('[color=0xFF0000ff]red[/color]'); expect(out.stripped).toBe('red'); expect(spansOf(out)).toEqual([span(0, 3, { color: 0xff0000ff })]); }); it('treats [color=] with no value as literal', () => { parse('[color=]text'); expect(out.stripped).toBe('[color=]text'); }); it('treats CSS #rrggbb as literal (app-level format not supported)', () => { parse('[color=#ff0000]text[/color]'); expect(out.stripped).toContain('[color=#ff0000]'); expect(out.stripped).toContain('text'); }); it('treats CSS #rgb shorthand as literal (app-level format not supported)', () => { parse('[color=#f00]text[/color]'); expect(out.stripped).toContain('[color=#f00]'); }); it('treats 0xRRGGBB (6-digit, no alpha) as literal', () => { parse('[color=0xff0000]text[/color]'); expect(out.stripped).toContain('[color=0xff0000]'); expect(out.stripped).toContain('text'); }); it('treats invalid hex chars in 0x color as literal', () => { parse('[color=0xGGGGGGGG]text'); expect(out.stripped).toContain('[color=0xGGGGGGGG]'); }); it('treats named color as literal (app-level format not supported)', () => { parse('[color=red]text[/color]'); expect(out.stripped).toContain('[color=red]'); expect(out.stripped).toContain('text'); }); it('resets color on [/color]', () => { parse('[color=0xff0000ff]A[/color]B'); expect(out.stripped).toBe('AB'); const spans = spansOf(out); expect(spans[0]).toEqual(span(0, 1, { color: 0xff0000ff })); expect(spans[1]).toEqual(span(1, 2)); // color back to 0 (inherit) }); }); // ------------------------------------------------------------------------- // Nesting // ------------------------------------------------------------------------- describe('nested tags', () => { it('combines bold + italic when nested', () => { parse('[b][i]bold italic[/i][/b]'); expect(out.stripped).toBe('bold italic'); expect(spansOf(out)).toEqual([span(0, 11, { bold: true, italic: true })]); }); it('correctly splits spans for partially overlapping styles', () => { parse('[b]bold[/b][i]italic[/i]'); expect(out.stripped).toBe('bolditalic'); expect(spansOf(out)).toEqual([ span(0, 4, { bold: true }), span(4, 10, { italic: true }), ]); }); it('handles three nested tags', () => { parse('[b][i][u]all[/u][/i][/b]'); expect(out.stripped).toBe('all'); expect(spansOf(out)).toEqual([ span(0, 3, { bold: true, italic: true, underline: true }), ]); }); it('combines color with bold', () => { parse('[color=0xff0000ff][b]red bold[/b][/color]'); expect(out.stripped).toBe('red bold'); expect(spansOf(out)).toEqual([ span(0, 8, { bold: true, color: 0xff0000ff }), ]); }); it('produces correct spans for text before, inside and after tags', () => { parse('Hello [b]World[/b]!'); expect(out.stripped).toBe('Hello World!'); expect(spansOf(out)).toEqual([ span(0, 6), // 'Hello ' span(6, 11, { bold: true }), // 'World' span(11, 12), // '!' ]); }); }); // ------------------------------------------------------------------------- // Mis-nested / malformed tags // ------------------------------------------------------------------------- describe('mis-nesting and malformed tags', () => { it('handles mis-nested closing tag by implicitly closing inner tags', () => { // [b][i]…[/b] — [/b] closes both italic (inner) and bold, leaving plain parse('[b][i]AB[/b]C'); expect(out.stripped).toBe('ABC'); const spans = spansOf(out); // 'AB' is bold+italic; 'C' is plain (both closed by [/b]) expect(spans[0]).toEqual(span(0, 2, { bold: true, italic: true })); expect(spans[1]).toEqual(span(2, 3)); }); it('ignores over-closing (close without matching open)', () => { parse('hello[/b]'); expect(out.stripped).toBe('hello'); expect(spansOf(out)).toEqual([span(0, 5)]); }); it('treats tag without closing bracket as literal', () => { parse('[b'); expect(out.stripped).toBe('[b'); expect(out.spanCount).toBe(1); }); it('treats unknown tag as literal text', () => { parse('[xyz]text[/xyz]'); expect(out.stripped).toBe('[xyz]text[/xyz]'); }); it('treats empty tag [] as literal', () => { parse('a[]b'); expect(out.stripped).toBe('a[]b'); }); it('treats empty closing tag [/] as literal', () => { parse('a[/]b'); expect(out.stripped).toBe('a[/]b'); }); }); // ------------------------------------------------------------------------- // Unclosed tags // ------------------------------------------------------------------------- describe('unclosed tags', () => { it('extends an unclosed tag to end of string', () => { parse('[b]hello'); expect(out.stripped).toBe('hello'); expect(spansOf(out)).toEqual([span(0, 5, { bold: true })]); }); it('extends multiple stacked unclosed tags to end of string', () => { parse('[b][i]text'); expect(out.stripped).toBe('text'); expect(spansOf(out)).toEqual([span(0, 4, { bold: true, italic: true })]); }); }); // ------------------------------------------------------------------------- // Edge cases // ------------------------------------------------------------------------- describe('edge cases', () => { it('produces no spans for a string that is only tags with no characters', () => { parse('[b][/b]'); expect(out.stripped).toBe(''); expect(out.spanCount).toBe(0); }); it('does not create a span when the style does not change (duplicate tag)', () => { // [b][b]text[/b][/b] — nested bold: still one span, bold throughout parse('[b][b]text[/b][/b]'); expect(out.stripped).toBe('text'); // Both [b] frames push bold=true; stylesEqual detects no visible change // on the second [b], so there is exactly one span. expect(out.spanCount).toBe(1); expect(spansOf(out)).toEqual([span(0, 4, { bold: true })]); }); it('handles adjacent spans with different styles', () => { parse('[b]A[/b][i]B[/i][u]C[/u]'); expect(out.stripped).toBe('ABC'); expect(spansOf(out)).toEqual([ span(0, 1, { bold: true }), span(1, 2, { italic: true }), span(2, 3, { underline: true }), ]); }); it('reuses the ParseResult correctly on a second call', () => { parse('[b]first[/b]'); expect(out.stripped).toBe('first'); parse('[i]second[/i]'); expect(out.stripped).toBe('second'); expect(spansOf(out)).toEqual([span(0, 6, { italic: true })]); }); it('handles text with multiple [ that are not tags', () => { parse('a[0]b[1]c'); // '[0]' and '[1]' are unrecognised — literal expect(out.stripped).toBe('a[0]b[1]c'); }); }); }); // --------------------------------------------------------------------------- // stripRichText // --------------------------------------------------------------------------- describe('stripRichText', () => { it('returns the same string reference when there are no brackets', () => { const input = 'no brackets here'; expect(stripRichText(input)).toBe(input); }); it('strips bold tags', () => { expect(stripRichText('[b]hello[/b]')).toBe('hello'); }); it('strips italic tags', () => { expect(stripRichText('[i]hello[/i]')).toBe('hello'); }); it('strips underline tags', () => { expect(stripRichText('[u]under[/u]')).toBe('under'); }); it('strips strikethrough tags', () => { expect(stripRichText('[s]strike[/s]')).toBe('strike'); }); it('strips color tags', () => { expect(stripRichText('[color=0xff0000ff]text[/color]')).toBe('text'); }); it('strips multiple tags leaving plain text', () => { expect(stripRichText('Hello [b]World[/b]!')).toBe('Hello World!'); }); it('preserves unrecognised tags as literal', () => { expect(stripRichText('[xyz]text[/xyz]')).toBe('[xyz]text[/xyz]'); }); it('handles empty string', () => { expect(stripRichText('')).toBe(''); }); it('handles only tags with no text', () => { expect(stripRichText('[b][/b]')).toBe(''); }); it('strips nested tags', () => { expect(stripRichText('[b][i]text[/i][/b]')).toBe('text'); }); it('handles tag without closing bracket as literal', () => { expect(stripRichText('[b')).toBe('[b'); }); });