feat(text): preserve HTML foreground colors

Author: Toilettrauma

include/aniparse/types/Text.hpp

@@ -4,6 +4,7 @@
  * Author: Toilettrauma <macosinternal@gmail.com>
  */
 #pragma once
+#include <cstdint>
 #include <string>
 #include <variant>
 #include <vector>
@@ -26,10 +27,18 @@ struct TextStyle {
 	Kind kind;
 };
 
+/// Foreground colour of an inline run. Components are straight sRGB in the range 0...255.
+struct TextColor {
+	std::uint8_t red;
+	std::uint8_t green;
+	std::uint8_t blue;
+	std::uint8_t alpha = 255;
+};
+
 struct TextAttributeInfo {
 	int start;
 	int end;
-	std::variant<Hyperlink, TextStyle> data;
+	std::variant<Hyperlink, TextStyle, TextColor> data;
 };
 
 /**

src/utility/HtmlText.cpp

@@ -11,6 +11,7 @@
 
 #include <optional>
 #include <string>
+#include <string_view>
 
 namespace aniparse::text {
 namespace {
@@ -27,6 +28,57 @@ std::optional<TextStyle::Kind> style_of(std::string_view tag) {
 	return std::nullopt;
 }
 
+std::string_view trim(std::string_view value) {
+	while (!value.empty() && (value.front() == ' ' || value.front() == '\t' || value.front() == '\n' || value.front() == '\r'))
+		value.remove_prefix(1);
+	while (!value.empty() && (value.back() == ' ' || value.back() == '\t' || value.back() == '\n' || value.back() == '\r'))
+		value.remove_suffix(1);
+	return value;
+}
+
+int hex_digit(char character) {
+	if (character >= '0' && character <= '9') return character - '0';
+	if (character >= 'a' && character <= 'f') return character - 'a' + 10;
+	if (character >= 'A' && character <= 'F') return character - 'A' + 10;
+	return -1;
+}
+
+std::optional<TextColor> color_value(std::string_view value) {
+	value = trim(value);
+	if (value.size() < 4 || value.front() != '#') return std::nullopt;
+	value.remove_prefix(1);
+	if (value.size() != 3 && value.size() != 4 && value.size() != 6 && value.size() != 8) return std::nullopt;
+	auto component = [&](std::size_t offset) -> std::optional<std::uint8_t> {
+		const int high = hex_digit(value[offset]);
+		const int low = value.size() <= 4 ? high : hex_digit(value[offset + 1]);
+		if (high < 0 || low < 0) return std::nullopt;
+		return static_cast<std::uint8_t>(high * 16 + low);
+	};
+	const std::size_t step = value.size() <= 4 ? 1 : 2;
+	const auto red = component(0), green = component(step), blue = component(step * 2);
+	if (!red || !green || !blue) return std::nullopt;
+	const auto alpha = value.size() == 4 || value.size() == 8 ? component(step * 3) : std::optional<std::uint8_t>{ 255 };
+	if (!alpha) return std::nullopt;
+	return TextColor{ *red, *green, *blue, *alpha };
+}
+
+std::optional<TextColor> color_of(const DOMElementView& element) {
+	if (const auto value = element.get_attr("color"))
+		if (const auto color = color_value(*value)) return color;
+	if (const auto style = element.get_attr("style")) {
+		std::string_view declarations = *style;
+		while (!declarations.empty()) {
+			const std::size_t separator = declarations.find(';');
+			const std::string_view declaration = trim(declarations.substr(0, separator));
+			declarations = separator == std::string_view::npos ? std::string_view{} : declarations.substr(separator + 1);
+			const std::size_t colon = declaration.find(':');
+			if (colon == std::string_view::npos || trim(declaration.substr(0, colon)) != "color") continue;
+			if (const auto color = color_value(declaration.substr(colon + 1))) return color;
+		}
+	}
+	return std::nullopt;
+}
+
 // Emit a line break only when the text does not already end in one, so successive block
 // tags and <br>s collapse instead of stacking blank lines.
 void break_line(std::string& text) {
@@ -55,26 +107,26 @@ void walk(DOMNodeView node, AttributedText& out) {
 			const std::size_t n = out.text.size();
 			if (n < 2 || out.text[n - 1] != '\n' || out.text[n - 2] != '\n')
 				out.text += '\n';
-		} else if (tag == "p" || tag == "div" || tag == "li") {
+			continue;
+		}
+		if (tag == "p" || tag == "div" || tag == "li") {
 			break_line(out.text);
 			walk(child, out);
 			break_line(out.text);
-		} else if (tag == "a") {
-			const int start = static_cast<int>(out.text.size());
-			walk(child, out);
-			const int end = static_cast<int>(out.text.size());
-			if (const auto href = element.get_attr("href"); href && !href->empty() && end > start)
-				out.attributes.push_back({ start, end, Hyperlink{ std::string(*href) } });
-		} else if (const auto kind = style_of(tag)) {
-			const int start = static_cast<int>(out.text.size());
-			walk(child, out);
-			const int end = static_cast<int>(out.text.size());
-			if (end > start)
-				out.attributes.push_back({ start, end, TextStyle{ *kind } });
-		} else {
-			// Unknown/transparent tag (span, wbr, ...): keep its text, drop the tag.
-			walk(child, out);
+			continue;
 		}
+
+		const int start = static_cast<int>(out.text.size());
+		walk(child, out);
+		const int end = static_cast<int>(out.text.size());
+		if (end <= start) continue;
+		if (tag == "a")
+			if (const auto href = element.get_attr("href"); href && !href->empty())
+				out.attributes.push_back({ start, end, Hyperlink{ std::string(*href) } });
+		if (const auto kind = style_of(tag))
+			out.attributes.push_back({ start, end, TextStyle{ *kind } });
+		if (const auto color = color_of(element))
+			out.attributes.push_back({ start, end, *color });
 	}
 }
 } // namespace

tests/HtmlTextTest.cpp

@@ -12,6 +12,7 @@
 
 using aniparse::AttributedText;
 using aniparse::Hyperlink;
+using aniparse::TextColor;
 using aniparse::TextStyle;
 using aniparse::text::from_html;
 
@@ -86,6 +87,22 @@ TEST_CASE("from_html keeps text of unknown tags", "[htmltext]") {
 	REQUIRE(r.attributes.empty());
 }
 
+TEST_CASE("from_html carries foreground colours", "[htmltext]") {
+	const AttributedText r = from_html(R"(<span style="font-weight: 400; color: #789">dim</span> <font color="#10203080">faint</font>)");
+	REQUIRE(r.text == "dim faint");
+	bool dim = false, faint = false;
+	for (const auto& attribute : r.attributes) {
+		const auto* color = std::get_if<TextColor>(&attribute.data);
+		if (!color) continue;
+		if (covered(r, attribute) == "dim")
+			dim = color->red == 0x77 && color->green == 0x88 && color->blue == 0x99 && color->alpha == 0xff;
+		if (covered(r, attribute) == "faint")
+			faint = color->red == 0x10 && color->green == 0x20 && color->blue == 0x30 && color->alpha == 0x80;
+	}
+	REQUIRE(dim);
+	REQUIRE(faint);
+}
+
 TEST_CASE("from_html on a real AniList-shaped description", "[htmltext]") {
 	// The exact shape AniList returns with asHtml:true: block <p>, <br> runs, a source
 	// attribution, an italic label, and a <ul>/<li> list.