CMakeLists.txt

@@ -25,7 +25,7 @@ add_link_options(${FLAGS})
 
 add_executable(${PROJECT_NAME} main.cpp misc.cpp config.cpp servehelper.cpp numberhelper.cpp pixivclient.cpp pixivmodels.cpp
     blankie/serializer.cpp blankie/escape.cpp blankie/murl.cpp
-    routes/home.cpp routes/css.cpp routes/artworks.cpp routes/tags.cpp routes/users/common.cpp routes/users/illustrations.cpp)
+    routes/home.cpp routes/css.cpp routes/artworks.cpp routes/users/common.cpp routes/users/illustrations.cpp)
 set_target_properties(${PROJECT_NAME}
     PROPERTIES
         CXX_STANDARD 20

README.md

@@ -5,13 +5,11 @@ Pixwhile is an alternative frontend to Pixiv that utilizes no Javascript.
 - Does not contain an asinine amount of Javascript
 - Allows you to open the original versions of cover images and profile pictures
 - Can view illustrations and list user illustrations
-- Can search for newest and oldest illustrations
 
 ## Missing Features
 
 This list is not exhaustive, nor does it mean that these are being worked on.
 
-- Can only search for newest and oldest illustrations
 - No search
 - No ability to login
 - No ability to see comments or like counts

blankie/murl.cpp

@@ -38,8 +38,6 @@
     "(?:\\?" QUERY ")?" \
     "(?:#" FRAGMENT ")?"
 
-static inline void hexencode(char c, char out[2]);
-static inline char hexdecode(char nibble1, char nibble2);
 static void handle_segment(std::vector<std::string>& segments, const std::string& str, size_t offset, size_t length);
 static std::string tolower(std::string str);
 
@@ -95,52 +93,6 @@ bool Url::is_host_equal(std::string other) const {
     return tolower(this->hostname) == tolower(std::move(other));
 }
 
-std::string escape(const std::string& in) {
-    std::string out;
-    char encoded[2];
-    size_t pos = 0;
-    size_t last_pos = 0;
-
-    out.reserve(in.size());
-    while ((pos = in.find_first_not_of("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789", pos)) != std::string::npos) {
-        out.append(in, last_pos, pos - last_pos);
-        hexencode(in[pos], encoded);
-        out += '%';
-        out.append(encoded, 2);
-        pos++;
-        last_pos = pos;
-    }
-
-    if (in.size() > last_pos) {
-        out.append(in, last_pos);
-    }
-
-    return out;
-}
-
-std::string unescape(const std::string& in) {
-    std::string out;
-    size_t pos = 0;
-    size_t last_pos = 0;
-
-    out.reserve(in.size());
-    while ((pos = in.find('%', pos)) != std::string::npos) {
-        if (pos + 2 >= in.size()) {
-            throw std::invalid_argument("String abruptly terminated while finding percent-encoded nibbles");
-        }
-        out.append(in, last_pos, pos - last_pos);
-        out += hexdecode(in[pos + 1], in[pos + 2]);
-        pos += 3;
-        last_pos = pos;
-    }
-
-    if (in.size() > last_pos) {
-        out.append(in, last_pos);
-    }
-
-    return out;
-}
-
 std::string normalize_path(const std::string& str) {
     std::vector<std::string> segments;
     std::string res;
@@ -185,30 +137,6 @@ std::string normalize_path(const std::string& str) {
 } // namespace murl
 } // namespace blankie
 
-static inline void hexencode(char c, char out[2]) {
-    char nibble1 = (c >> 4) & 0xF;
-    char nibble2 = c & 0xF;
-
-    auto hexencode = [](char nibble) -> char {
-        return nibble < 10
-            ? '0' + nibble
-            : 'A' + nibble - 10;
-    };
-    out[0] = hexencode(nibble1);
-    out[1] = hexencode(nibble2);
-}
-
-static inline char hexdecode(char nibble1, char nibble2) {
-    auto hexdecode = [](char nibble) -> char {
-        if (nibble >= '0' && nibble <= '9') return nibble - '0';
-        if (nibble >= 'A' && nibble <= 'F') return nibble - 'A' + 10;
-        if (nibble >= 'a' && nibble <= 'f') return nibble - 'a' + 10;
-        throw std::invalid_argument("Invalid percent-encoded nibble received");
-    };
-
-    return static_cast<char>((hexdecode(nibble1) << 4) | hexdecode(nibble2));
-}
-
 static void handle_segment(std::vector<std::string>& segments, const std::string& str, size_t offset, size_t length) {
     if (length == 2 && str[offset] == '.' && str[offset + 1] == '.') {
         if (segments.empty()) {

blankie/murl.h

@@ -38,8 +38,6 @@ struct Url {
     std::string to_string() const;
 };
 
-std::string escape(const std::string& in);
-std::string unescape(const std::string& in);
 std::string normalize_path(const std::string& str);
 
 } // namespace murl

blankie/serializer.cpp

@@ -52,9 +52,5 @@ std::string Element::serialize() const {
 } // namespace blankie
 
 static inline bool is_autoclosing_tag(const char* tag) {
-    return !strncmp(tag, "link", 5)
-        || !strncmp(tag, "meta", 5)
-        || !strncmp(tag, "img", 4)
-        || !strncmp(tag, "br", 3)
-        || !strncmp(tag, "label", 6);
+    return !strncmp(tag, "link", 5) || !strncmp(tag, "meta", 5) || !strncmp(tag, "img", 4) || !strncmp(tag, "br", 3);
 }

main.cpp

@@ -37,12 +37,6 @@ int main(int argc, char** argv) {
     server.Get("/artworks/(\\d+)", [&](const httplib::Request& req, httplib::Response& res) {
         artworks_route(req, res, config, pixiv_client);
     });
-    server.Get("/tags/([^/]+)", [&](const httplib::Request& req, httplib::Response& res) {
-        serve_redirect(req, res, config, get_origin(req, config) + "/tags/" + req.matches.str(1) + "/illustrations");
-    });
-    server.Get("/tags/([^/]+)/illustrations", [&](const httplib::Request& req, httplib::Response& res) {
-        tags_route(req, res, config, pixiv_client);
-    });
 
     server.Get("/member\\.php", [&](const httplib::Request& req, httplib::Response& res) {
         std::string id = req.get_param_value("id");
@@ -62,15 +56,6 @@ int main(int argc, char** argv) {
         }
         serve_redirect(req, res, config, get_origin(req, config) + "/artworks/" + illust_id);
     });
-    server.Get("/search", [&](const httplib::Request& req, httplib::Response& res) {
-        std::string q = req.get_param_value("q");
-        if (q.empty()) {
-            res.status = 400;
-            serve_error(req, res, config, "400: Bad Request", "Missing or empty search query");
-            return;
-        }
-        serve_redirect(req, res, config, get_origin(req, config) + "/tags/" + blankie::murl::escape(std::move(q)));
-    });
 
 #ifndef NDEBUG
     server.Get("/debug/exception/known", [](const httplib::Request& req, httplib::Response& res) {

pixivclient.cpp

@@ -1,21 +1,17 @@
-#include "blankie/murl.h"
 #include "numberhelper.h"
 #include "pixivclient.h"
 
-static const constexpr char* touch_user_agent = "Mozilla/5.0 (Android 12; Mobile; rv:97.0) Gecko/97.0 Firefox/97.0";
-static const constexpr char* desktop_user_agent = "Mozilla/5.0 (Windows NT 10.0; rv:111.0) Gecko/20100101 Firefox/111.0";
-
 PixivClient::PixivClient() {
     this->_www_pixiv_net_client.set_keep_alive(true);
     this->_www_pixiv_net_client.set_default_headers({
-        {"Cookie", "webp_available=1"}
+        {"User-Agent", "Mozilla/5.0 (Android 12; Mobile; rv:97.0) Gecko/97.0 Firefox/97.0"}
     });
 }
 
 User PixivClient::get_user(uint64_t user_id) {
     httplib::Result res = this->_www_pixiv_net_client.Get("/touch/ajax/user/details", {
         {"lang", "en"}, {"id", std::to_string(user_id)}
-    }, {{"User-Agent", touch_user_agent}});
+    }, httplib::Headers());
     return this->_handle_result(std::move(res)).at("user_details").get<User>();
 }
 
@@ -24,54 +20,17 @@ Illusts PixivClient::get_illusts(uint64_t user_id, size_t page) {
     if (page != 0) {
         params.insert({"p", std::to_string(page + 1)});
     }
-    httplib::Result res = this->_www_pixiv_net_client.Get("/touch/ajax/user/illusts", std::move(params), {{"User-Agent", touch_user_agent}});
+    httplib::Result res = this->_www_pixiv_net_client.Get("/touch/ajax/user/illusts", std::move(params), httplib::Headers());
     return this->_handle_result(std::move(res)).get<Illusts>();
 }
 
 Illust PixivClient::get_illust(uint64_t illust_id) {
     httplib::Result res = this->_www_pixiv_net_client.Get("/touch/ajax/illust/details", {
         {"lang", "en"}, {"illust_id", std::to_string(illust_id)}
-    }, {{"User-Agent", touch_user_agent}});
+    }, httplib::Headers());
     return this->_handle_result(std::move(res)).get<Illust>();
 }
 
-SearchResults PixivClient::search_illusts(const std::string& query, size_t page, const std::string& order) {
-    using namespace std::string_literals;
-
-    httplib::Result res = this->_www_pixiv_net_client.Get("/ajax/search/illustrations/"s + blankie::murl::escape(query), {
-        {"lang", "en"},
-        {"mode", "all"},
-        {"p", std::to_string(page + 1)},
-        {"s_mode", "s_tag_full"},
-        {"type", "illust_and_ugoira"},
-        {"order", order},
-        {"word", query}
-    }, {{"User-Agent", desktop_user_agent}});
-    return this->_handle_result(std::move(res)).get<SearchResults>();
-}
-
-std::vector<SearchSuggestion> PixivClient::get_search_suggestions(const std::string& query) {
-    httplib::Result res = this->_www_pixiv_net_client.Get("/rpc/cps.php", {
-        {"lang", "en"}, {"keyword", query}
-    }, {{"User-Agent", desktop_user_agent}, {"Referer", "https://www.pixiv.net/"}});
-    if (!res) {
-        throw HTTPLibException(res.error());
-    }
-    nlohmann::json j = nlohmann::json::parse(std::move(res->body)).at("candidates");
-
-    std::vector<SearchSuggestion> search_suggestions;
-    search_suggestions.reserve(j.size());
-
-    for (const nlohmann::json& i : j) {
-        SearchSuggestion search_suggestion = i.get<SearchSuggestion>();
-        if (search_suggestion.tag != query) {
-            search_suggestions.push_back(std::move(search_suggestion));
-        }
-    }
-
-    return search_suggestions;
-}
-
 nlohmann::json PixivClient::_handle_result(httplib::Result res) {
     if (!res) {
         throw HTTPLibException(res.error());

pixivclient.h

@@ -14,9 +14,6 @@ public:
     Illusts get_illusts(uint64_t user_id, size_t page);
     Illust get_illust(uint64_t illust_id);
 
-    SearchResults search_illusts(const std::string& query, size_t page, const std::string& order);
-    std::vector<SearchSuggestion> get_search_suggestions(const std::string& query);
-
 private:
     nlohmann::json _handle_result(httplib::Result res);
     httplib::Client _www_pixiv_net_client{"https://www.pixiv.net"};

pixivmodels.cpp

@@ -8,9 +8,7 @@
 static inline std::optional<std::string> get_1920x960_cover_image(blankie::murl::Url url);
 static inline std::optional<std::string> get_original_cover_image(blankie::murl::Url url, const nlohmann::json& cover_image);
 static inline std::optional<std::string> get_original_profile_picture(blankie::murl::Url url);
-static inline std::optional<std::string> get_360x360_illust_thumbnail(blankie::murl::Url url);
 static Images get_profile_pictures(const nlohmann::json& j);
-static Images get_profile_pictures(const std::string& url);
 static Images get_illust_image(const nlohmann::json& j);
 
 const std::string& Images::original_or_thumbnail() const {
@@ -82,6 +80,9 @@ void from_json(const nlohmann::json& j, User& user) {
 
 void from_json(const nlohmann::json& j, Tag& tag) {
     j.at("tag").get_to(tag.japanese);
+    if (j.contains("romaji")) {
+        tag.romaji = j["romaji"].get<std::string>();
+    }
     if (j.contains("translation")) {
         tag.english = j["translation"].get<std::string>();
     }
@@ -128,75 +129,6 @@ void from_json(const nlohmann::json& j, Illusts& illusts) {
     j.at("lastPage").get_to(illusts.total_pages);
 }
 
-void from_json(const nlohmann::json& j, SearchResults& search_results) {
-    const nlohmann::json& tag_translations = j.at("tagTranslation");
-    auto get_translated_tag = [&](const std::string& japanese) -> std::optional<std::string> {
-        if (!tag_translations.is_object() || !tag_translations.contains(japanese)) {
-            return std::nullopt;
-        }
-        const nlohmann::json& tag = tag_translations[japanese];
-        return tag.contains("en")
-            ? std::optional(tag["en"].get<std::string>())
-            : std::nullopt;
-    };
-
-    const nlohmann::json& illusts = j.at("illust").at("data");
-    search_results.illusts.illusts.reserve(illusts.size());
-    for (const nlohmann::json& i : illusts) {
-        const nlohmann::json& i_tags = i.at("tags");
-        std::vector<Tag> tags;
-        tags.reserve(i_tags.size());
-
-        for (const nlohmann::json& tag : i_tags) {
-            std::string japanese = tag.get<std::string>();
-            tags.push_back({japanese, get_translated_tag(std::move(japanese))});
-        }
-
-        Illust illust = {
-            .username = "",
-            .user_display_name = i.at("userName").get<std::string>(),
-            .user_id = to_ull(i.at("userId").get<std::string>()),
-            .user_profile_pictures = get_profile_pictures(i.at("profileImageUrl").get<std::string>()),
-
-            .illust_id = to_ull(i.at("id").get<std::string>()),
-            .title = i.at("title").get<std::string>(),
-            .ai_generated = i.at("aiType").get<int>() == 2,
-            // pixiv does have a createDate field, but it can't be portably parsed by strptime
-            // and i cba to use regex for it, especially when it's not even used in this context
-            .upload_time = -1,
-
-            .comment = std::nullopt,
-            .tags = std::move(tags),
-            .images = {get_illust_image(i)}
-        };
-        search_results.illusts.illusts.push_back(illust);
-    }
-
-    j.at("illust").at("total").get_to(search_results.illusts.total_illusts);
-    search_results.illusts.total_pages = search_results.illusts.total_illusts / 60;
-    if (search_results.illusts.total_illusts % 60 != 0) {
-        search_results.illusts.total_pages++;
-    }
-    if (search_results.illusts.total_pages > 10) {
-        search_results.illusts.total_pages = 10;
-    }
-
-    search_results.tag_translations.reserve(tag_translations.size());
-    for (auto &[key, val] : tag_translations.items()) {
-        std::optional<std::string> translated_tag = get_translated_tag(key);
-        if (translated_tag) {
-            search_results.tag_translations.insert({std::move(key), std::move(*translated_tag)});
-        }
-    }
-}
-
-void from_json(const nlohmann::json& j, SearchSuggestion& search_suggestion) {
-    j.at("tag_name").get_to(search_suggestion.tag);
-    if (j.at("type").get_ref<const nlohmann::json::string_t&>() == "tag_translation") {
-        search_suggestion.english_tag = j.at("tag_translation").get<std::string>();
-    }
-}
-
 static std::regex resolution_path_regex("/c/(\\d+x\\d+)(.+)");
 static inline std::optional<std::string> get_1920x960_cover_image(blankie::murl::Url url) {
     std::smatch sm;
@@ -250,56 +182,22 @@ static Images get_profile_pictures(const nlohmann::json& j) {
     return images;
 }
 
-static Images get_profile_pictures(const std::string& url) {
-    return {
-        .original = get_original_profile_picture(url),
-        .thumbnails = {url}
-    };
-}
-
-static std::regex illust_360x360_thumbnail_path_regex(
-    "(?:/c/[^/]+?/img-master|/img-original)?"
-    "(/img/.*/\\d+_p\\d+)(?:_master1200|_square1200)?\\.\\w{3,4}"
-);
-static inline std::optional<std::string> get_360x360_illust_thumbnail(blankie::murl::Url url) {
-    using namespace std::string_literals;
-
-    std::smatch sm;
-    if (!std::regex_match(url.path, sm, illust_360x360_thumbnail_path_regex)) {
-        return std::nullopt;
-    }
-    url.path = "/c/360x360_10_webp/img-master"s + sm.str(1) + "_square1200.jpg";
-    return url.to_string();
-}
-
 static Images get_illust_image(const nlohmann::json& j) {
     Images images;
-    ssize_t add_360x360_to = -1;
 
     auto add_if_exists = [&](const char* key) {
         if (j.contains(key) && j[key].is_string()) {
             images.thumbnails.push_back(j[key].get<std::string>());
-            return true;
         }
-        return false;
     };
     add_if_exists("url_ss");
     add_if_exists("url_placeholder");
     add_if_exists("url_small");
-    if (!add_if_exists("url_s")) {
-        add_360x360_to = static_cast<ssize_t>(images.thumbnails.size());
-    }
+    add_if_exists("url_s");
     add_if_exists("url");
     if (j.contains("url_big") && j["url_big"].is_string()) {
         images.original = j["url_big"].get<std::string>();
     }
 
-    if (add_360x360_to >= 0) {
-        std::optional<std::string> c_360x360 = get_360x360_illust_thumbnail(images.original_or_thumbnail());
-        if (c_360x360) {
-            images.thumbnails.insert(images.thumbnails.begin() + add_360x360_to, std::move(*c_360x360));
-        }
-    }
-
     return images;
 }

pixivmodels.h

@@ -27,6 +27,7 @@ struct User {
 
 struct Tag {
     std::string japanese;
+    std::optional<std::string> romaji;
     std::optional<std::string> english;
 };
 
@@ -52,19 +53,7 @@ struct Illusts {
     size_t total_pages;
 };
 
-struct SearchResults {
-    Illusts illusts;
-    std::unordered_map<std::string, std::string> tag_translations;
-};
-
-struct SearchSuggestion {
-    std::string tag;
-    std::optional<std::string> english_tag;
-};
-
 void from_json(const nlohmann::json& j, User& user);
 void from_json(const nlohmann::json& j, Tag& tag);
 void from_json(const nlohmann::json& j, Illust& illust);
 void from_json(const nlohmann::json& j, Illusts& illusts);
-void from_json(const nlohmann::json& j, SearchResults& search_results);
-void from_json(const nlohmann::json& j, SearchSuggestion& search_suggestion);

routes/artworks.cpp

@@ -11,7 +11,7 @@ static inline Element generate_images(const httplib::Request& req, const Config&
 static inline Element generate_preview_images(const httplib::Request& req, const Config& config, const Illust& illust);
 static inline std::vector<blankie::html::Node> parse_description_line(const httplib::Request& req, const Config& config, std::string str);
 static inline Element generate_description(const httplib::Request& req, const Config& config, const std::string& description);
-static inline Element generate_illust_tags(const httplib::Request& req, const Config& config, const Illust& illust);
+static inline Element generate_illust_tags(const Illust& illust);
 
 static inline bool is_true(const std::string& str);
 static inline std::string time_to_string(time_t time);
@@ -42,14 +42,13 @@ void artworks_route(const httplib::Request& req, httplib::Response& res, const C
     Element body("body", {
         Element("h2", {illust.title}),
         generate_user_link(req, config, illust),
-        Element("br"),
         !preview ? generate_images(req, config, illust) : generate_preview_images(req, config, illust),
         Element("br")
     });
     if (illust.comment) {
         body.nodes.push_back(generate_description(req, config, *illust.comment));
     }
-    body.nodes.push_back(generate_illust_tags(req, config, illust));
+    body.nodes.push_back(generate_illust_tags(illust));
     body.nodes.push_back(Element("p", {time_to_string(illust.upload_time)}));
     serve(req, res, config, std::move(illust.title), std::move(body));
 }
@@ -161,7 +160,7 @@ static inline Element generate_description(const httplib::Request& req, const Co
     return p;
 }
 
-static inline Element generate_illust_tags(const httplib::Request& req, const Config& config, const Illust& illust) {
+static inline Element generate_illust_tags(const Illust& illust) {
     Element div("div", {{"class", "illusttags"}}, {});
 
     if (illust.ai_generated) {
@@ -171,12 +170,11 @@ static inline Element generate_illust_tags(const httplib::Request& req, const Co
     for (const Tag& i : illust.tags) {
         std::string tag = [&]() {
             if (i.english) return *i.english;
+            if (i.romaji) return *i.romaji;
             return i.japanese;
         }();
 
-        div.nodes.push_back(Element("a", {{"href", get_origin(req, config) + "/tags/" + blankie::murl::escape(i.japanese)}}, {
-            "#", std::move(tag)
-        }));
+        div.nodes.push_back(Element("span", {"#", std::move(tag)}));
     }
 
     return div;

routes/css.cpp

@@ -37,11 +37,6 @@ void css_route(const httplib::Request& req, httplib::Response& res) {
         max-width: 100%;
     }
 
-    .center {
-        text-align: center;
-        display: block;
-    }
-
     /* USER PAGE (and a tiny bit for illustrations page) */
     .cover {
         width: 100%;
@@ -66,6 +61,10 @@ void css_route(const httplib::Request& req, httplib::Response& res) {
     }
 
     /* USER ILLUSTRATIONS PAGE (and illustrations page) */
+    .center {
+        text-align: center;
+        display: block;
+    }
     .grid {
         display: flex;
         flex-wrap: wrap;
@@ -95,14 +94,6 @@ void css_route(const httplib::Request& req, httplib::Response& res) {
         padding-bottom: 1em;
     }
 
-    /* SEARCH RESULTS PAGE */
-    .searchsuggestions {
-        text-align: left;
-        display: inline-block;
-        margin-top: .5em;
-        margin-bottom: 0;
-    }
-
     /* ERROR PAGE */
     .error {
         text-align: center;

routes/home.cpp

@@ -15,12 +15,6 @@ void home_route(const httplib::Request& req, httplib::Response& res, const Confi
         "Pixwhile is an alternative frontend to Pixiv that utilizes no Javascript. (",
         Element("a", {{"href", "https://gitlab.com/blankX/pixwhile"}}, {"source code"}),
         ")",
-        Element("form", {{"method", "get"}, {"action", "search"}}, {
-            Element("br"),
-            Element("input", {{"name", "q"}, {"required", ""}}, {}),
-            " ",
-            Element("button", {"Search for illustrations"})
-        }),
         Element("h2", {"Try it out"}),
         Element("ul", {
             get_artwork_element(106623268, "アル社長の日常", 1960050, "torino"),
@@ -30,13 +24,12 @@ void home_route(const httplib::Request& req, httplib::Response& res, const Confi
         Element("ul", {
             Element("li", {"Does not contain an asinine amount of Javascript"}),
             Element("li", {"Allows you to open the original versions of cover images and profile pictures"}),
-            Element("li", {"Can view illustrations and list user illustrations"}),
-            Element("li", {"Can search for newest and oldest illustrations"})
+            Element("li", {"Can view illustrations and list user illustrations"})
         }),
         Element("h2", {"Missing Features"}),
         Element("p", {"This list is not exhaustive, nor does it mean that these are being worked on."}),
         Element("ul", {
-            Element("li", {"Can only search for newest and oldest illustrations"}),
+            Element("li", {"No search"}),
             Element("li", {"No ability to login"}),
             Element("li", {"No ability to see comments or like counts"}),
         })

routes/routes.h

@@ -9,4 +9,3 @@ void home_route(const httplib::Request& req, httplib::Response& res, const Confi
 void css_route(const httplib::Request& req, httplib::Response& res);
 void user_illustrations_route(const httplib::Request& req, httplib::Response& res, const Config& config, PixivClient& pixiv_client);
 void artworks_route(const httplib::Request& req, httplib::Response& res, const Config& config, PixivClient& pixiv_client);
-void tags_route(const httplib::Request& req, httplib::Response& res, const Config& config, PixivClient& pixiv_client);

routes/tags.cpp

@@ -1,177 +0,0 @@
-#include "routes.h"
-#include "../numberhelper.h"
-#include "../servehelper.h"
-#include "../pixivclient.h"
-
-static inline Element generate_header(const httplib::Request& req, const Config& config,
-        const SearchResults& search_results, const std::string& query, const std::vector<std::string>& tags, const std::string& order,
-        const std::vector<SearchSuggestion>& search_suggestions);
-static inline Element generate_search_suggestions(const httplib::Request& req, const Config& config,
-        const std::vector<std::string>& tags, const std::vector<SearchSuggestion>& search_suggestions, bool open_by_default);
-
-static std::string tags_to_string(const std::unordered_map<std::string, std::string>& tag_translations, const std::vector<std::string>& tags);
-static inline std::vector<std::string> split(const std::string& str, char c);
-static inline std::string join(const std::vector<std::string>& items, char c);
-
-void tags_route(const httplib::Request& req, httplib::Response& res, const Config& config, PixivClient& pixiv_client) {
-    std::string query = blankie::murl::unescape(req.matches.str(1));
-    std::string order = req.has_param("order") ? req.get_param_value("order") : "date_d";
-    unsigned long long page = req.has_param("p") ? to_ull(req.get_param_value("p")) - 1 : 0;
-    std::vector<std::string> tags = split(query, ' ');
-
-    if (tags.empty()) {
-        res.status = 400;
-        serve_error(req, res, config, "400: Bad Request", "Empty search query");
-        return;
-    }
-
-    SearchResults search_results;
-    try {
-        search_results = pixiv_client.search_illusts(query, page, order);
-    } catch (const std::exception& e) {
-        res.status = 500;
-        serve_error(req, res, config, "500: Internal server error", "Failed to search for illusts", e.what());
-        return;
-    }
-    std::vector<SearchSuggestion> search_suggestions;
-    try {
-        search_suggestions = pixiv_client.get_search_suggestions(tags.back());
-    } catch (const std::exception& e) {
-        res.status = 500;
-        serve_error(req, res, config, "500: Internal server error", "Failed to get search suggestions", e.what());
-        return;
-    }
-
-    Element body("body", {
-        generate_header(req, config, search_results, query, tags, order, search_suggestions),
-        Element("br"),
-        generate_illusts_pager(req, config, search_results.illusts, page, "illusts")
-    });
-    serve(req, res, config, tags_to_string(std::move(search_results.tag_translations), std::move(tags)), std::move(body));
-}
-
-
-
-static inline Element generate_header(const httplib::Request& req, const Config& config,
-        const SearchResults& search_results, const std::string& query, const std::vector<std::string>& tags, const std::string& order,
-        const std::vector<SearchSuggestion>& search_suggestions) {
-    auto sort_element = [&](const char* title, const char* new_order) {
-        std::string url = get_origin(req, config) + "/tags/" + blankie::murl::escape(query) + "/illustrations?order=" + new_order;
-        Element ret("a", {{"href", std::move(url)}}, {title});
-        if (new_order == order) {
-            ret = Element("b", {std::move(ret)});
-        }
-        return ret;
-    };
-
-    Element header("header", {{"class", "center"}}, {
-        Element("form", {{"method", "get"}, {"action", get_origin(req, config) + "/search"}}, {
-            Element("input", {{"name", "q"}, {"required", ""}, {"value", query}}, {}),
-            " ",
-            Element("button", {"Search for illustrations"})
-        })
-    });
-    if (!search_suggestions.empty()) {
-        header.nodes.push_back(generate_search_suggestions(req, config, tags, search_suggestions, search_results.illusts.total_illusts == 0));
-    }
-    header.nodes.push_back(Element("br"));
-
-    if (search_results.illusts.total_illusts != 1) {
-        header.nodes.push_back("There are ");
-        header.nodes.push_back(std::to_string(search_results.illusts.total_illusts));
-        header.nodes.push_back(" illustrations");
-    } else {
-        header.nodes.push_back("There is 1 illustration");
-    }
-    header.nodes.push_back(" of ");
-    header.nodes.push_back(Element("b", {tags_to_string(search_results.tag_translations, tags)}));
-
-    header.nodes.push_back(Element("br"));
-    header.nodes.push_back("Sort by: ");
-    header.nodes.push_back(sort_element("Newest", "date_d"));
-    header.nodes.push_back(" ");
-    header.nodes.push_back(sort_element("Oldest", "date"));
-
-    return header;
-}
-
-static inline Element generate_search_suggestions(const httplib::Request& req, const Config& config,
-        const std::vector<std::string>& tags, const std::vector<SearchSuggestion>& search_suggestions, bool open_by_default) {
-    std::vector<blankie::html::Node> ul_nodes;
-    ul_nodes.reserve(search_suggestions.size());
-    for (const SearchSuggestion& search_suggestion : search_suggestions) {
-        std::string text = search_suggestion.tag;
-        if (search_suggestion.english_tag) {
-            text += " (";
-            text += *search_suggestion.english_tag;
-            text += ')';
-        }
-
-        std::vector<std::string> new_tags = tags;
-        new_tags.pop_back();
-        new_tags.push_back(search_suggestion.tag);
-        std::string url = get_origin(req, config) + "/tags/" + blankie::murl::escape(join(new_tags, ' '));
-
-        ul_nodes.push_back(Element("li", {
-            Element("a", {{"href", std::move(url)}}, {std::move(text)})
-        }));
-    }
-
-    Element details("details", {
-        Element("summary", {"Search suggestions"}),
-        Element("ul", {{"class", "searchsuggestions"}}, ul_nodes)
-    });
-    if (open_by_default) {
-        details.attributes.push_back({"open", ""});
-    }
-
-    return details;
-}
-
-
-
-static std::string tags_to_string(const std::unordered_map<std::string, std::string>& tag_translations, const std::vector<std::string>& tags) {
-    std::string str;
-    for (const std::string& tag : tags) {
-        if (!str.empty()) {
-            str += ' ';
-        }
-        str += '#';
-
-        auto translated_tag = tag_translations.find(tag);
-        str += translated_tag != tag_translations.cend() ? translated_tag->second : tag;
-    }
-    return str;
-}
-
-static inline std::vector<std::string> split(const std::string& str, char c) {
-    std::vector<std::string> ret;
-    size_t pos = 0;
-    size_t last_pos = 0;
-
-    while ((pos = str.find(c, pos)) != std::string::npos) {
-        if (pos - last_pos > 0) {
-            ret.push_back(str.substr(last_pos, pos - last_pos));
-        }
-        pos++;
-        last_pos = pos;
-    }
-    if (str.size() > last_pos) {
-        ret.push_back(str.substr(last_pos));
-    }
-
-    return ret;
-}
-
-static inline std::string join(const std::vector<std::string>& items, char c) {
-    std::string ret;
-
-    for (size_t i = 0; i < items.size(); i++) {
-        if (i) {
-            ret += c;
-        }
-        ret += items[i];
-    }
-
-    return ret;
-}

routes/users/illustrations.cpp

@@ -6,6 +6,9 @@
 #include "../../pixivclient.h"
 #include "common.h"
 
+static Element generate_pager(const Illusts& illusts, size_t page, bool first_selector);
+static inline Element generate_content(const httplib::Request& req, const Config& config, const Illusts& illusts);
+
 void user_illustrations_route(const httplib::Request& req, httplib::Response& res, const Config& config, PixivClient& pixiv_client) {
     uint64_t user_id = to_ull(req.matches[1].str());
     uint64_t page = req.has_param("p") ? to_ull(req.get_param_value("p")) - 1 : 0;
@@ -32,7 +35,55 @@ void user_illustrations_route(const httplib::Request& req, httplib::Response& re
 
     Element body("body", {
         generate_user_header(std::move(user), config),
-        generate_illusts_pager(req, config, illusts, page, "illusts")
+        generate_pager(illusts, page, true),
+        Element("br"),
+        generate_content(req, config, illusts),
+        generate_pager(illusts, page, false)
     });
     serve(req, res, config, user.display_name + "'s illustrations", std::move(body));
 }
+
+static Element generate_pager(const Illusts& illusts, size_t page, bool first_selector) {
+    auto link = [](size_t new_page, const char* text, bool add_link) {
+        using namespace std::string_literals;
+
+        Element b("b");
+        std::string href = "?p="s + std::to_string(new_page) + "#pageselector";
+
+        if (add_link) {
+            b.nodes.push_back(Element("a", {{"href", std::move(href)}}, {text}));
+        } else {
+            b.nodes.push_back(text);
+        }
+        return b;
+    };
+
+    Element div("div", {{"class", "center"}}, {
+        link(1, "First", page != 0), " ",
+        link(page, "Prev", page != 0), " ",
+        std::to_string(page + 1), "/", std::to_string(illusts.total_pages), " ",
+        link(page + 2, "Next", page + 1 < illusts.total_pages), " ",
+        link(illusts.total_pages, "Last", page + 1 < illusts.total_pages)
+    });
+    if (first_selector) {
+        div.attributes.push_back({"id", "pageselector"});
+    }
+    return div;
+}
+
+static inline Element generate_content(const httplib::Request& req, const Config& config, const Illusts& illusts) {
+    Element div("div", {{"class", "grid"}}, {});
+
+    div.nodes.reserve(illusts.illusts.size());
+    for (const Illust& i : illusts.illusts) {
+        std::string illust_url = get_origin(req, config) + "/artworks/" + std::to_string(i.illust_id);
+        std::string image_url = proxy_image_url(config, i.images[0].thumbnail_or_original(1));
+
+        div.nodes.push_back(Element("a", {{"href", {std::move(illust_url)}}}, {
+            Element("img", {{"loading", "lazy"}, {"src", std::move(image_url)}}, {}),
+            Element("p", {i.title})
+        }));
+    }
+
+    return div;
+}

servehelper.cpp

@@ -1,12 +1,8 @@
 #include <regex>
 
 #include "config.h"
-#include "pixivmodels.h"
 #include "servehelper.h"
 
-static Element generate_pager(const Illusts& illusts, size_t page, const char* id);
-static inline Element generate_content(const httplib::Request& req, const Config& config, const Illusts& illusts);
-
 void serve(const httplib::Request& req, httplib::Response& res, const Config& config, std::string title, Element element) {
     using namespace std::string_literals;
 
@@ -59,8 +55,6 @@ void serve_redirect(const httplib::Request& req, httplib::Response& res, const C
     serve(req, res, config, "Redirecting to "s + std::move(url) + "…", std::move(body));
 }
 
-
-
 std::string get_origin(const httplib::Request& req, const Config& config) {
     if (req.has_header("X-Canonical-Origin")) {
         return req.get_header_value("X-Canonical-Origin");
@@ -97,54 +91,3 @@ std::string proxy_image_url(const Config& config, blankie::murl::Url url) {
     }
     return proxy_url(config.image_proxy_url, std::move(url));
 }
-
-
-
-Element generate_illusts_pager(const httplib::Request& req, const Config& config, const Illusts& illusts, size_t page, const char* id) {
-    return Element("div", {{"id", id}}, {
-        generate_pager(illusts, page, id),
-        Element("br"),
-        generate_content(req, config, illusts),
-        generate_pager(illusts, page, id)
-    });
-}
-
-static Element generate_pager(const Illusts& illusts, size_t page, const char* id) {
-    auto link = [&](size_t new_page, const char* text, bool add_link) {
-        using namespace std::string_literals;
-
-        Element b("b");
-        if (add_link) {
-            std::string href = "?p="s + std::to_string(new_page) + '#' + id;
-            b.nodes.push_back(Element("a", {{"href", std::move(href)}}, {text}));
-        } else {
-            b.nodes.push_back(text);
-        }
-        return b;
-    };
-
-    return Element("div", {{"class", "center"}}, {
-        link(1, "First", page != 0), " ",
-        link(page, "Prev", page != 0), " ",
-        std::to_string(page + 1), "/", std::to_string(illusts.total_pages), " ",
-        link(page + 2, "Next", page + 1 < illusts.total_pages), " ",
-        link(illusts.total_pages, "Last", page + 1 < illusts.total_pages)
-    });
-}
-
-static inline Element generate_content(const httplib::Request& req, const Config& config, const Illusts& illusts) {
-    Element div("div", {{"class", "grid"}}, {});
-
-    div.nodes.reserve(illusts.illusts.size());
-    for (const Illust& i : illusts.illusts) {
-        std::string illust_url = get_origin(req, config) + "/artworks/" + std::to_string(i.illust_id);
-        std::string image_url = proxy_image_url(config, i.images[0].thumbnail_or_original(1));
-
-        div.nodes.push_back(Element("a", {{"href", {std::move(illust_url)}}}, {
-            Element("img", {{"loading", "lazy"}, {"src", std::move(image_url)}}, {}),
-            Element("p", {i.title})
-        }));
-    }
-
-    return div;
-}

servehelper.h

@@ -7,16 +7,12 @@
 #include "blankie/serializer.h"
 
 struct Config; // forward declaration from config.h
-struct Illusts; // forward declaration from pixivmodels.h
 using Element = blankie::html::Element;
 
 void serve(const httplib::Request& req, httplib::Response& res, const Config& config, std::string title, Element element);
 void serve_error(const httplib::Request& req, httplib::Response& res, const Config& config,
         std::string title, std::optional<std::string> subtitle = std::nullopt, std::optional<std::string> info = std::nullopt);
 void serve_redirect(const httplib::Request& req, httplib::Response& res, const Config& config, std::string url);
-
 std::string get_origin(const httplib::Request& req, const Config& config);
 std::string proxy_url(blankie::murl::Url base, blankie::murl::Url url);
 std::string proxy_image_url(const Config& config, blankie::murl::Url url);
-
-Element generate_illusts_pager(const httplib::Request& req, const Config& config, const Illusts& illusts, size_t page, const char* id);