refactor: clean up response models

src/client/response/channel.rs

@@ -23,15 +23,6 @@ pub struct Channel {
     pub alerts: Option<Vec<Alert>>,
 }
 
-#[serde_as]
-#[derive(Debug, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct ChannelCont {
-    #[serde(default)]
-    #[serde_as(as = "VecSkipError<_>")]
-    pub on_response_received_actions: Vec<OnResponseReceivedAction>,
-}
-
 #[derive(Debug, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct Contents {
@@ -205,17 +196,3 @@ pub struct PrimaryLink {
     pub title: String,
     pub navigation_endpoint: NavigationEndpoint,
 }
-
-#[derive(Debug, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct OnResponseReceivedAction {
-    pub append_continuation_items_action: AppendAction,
-}
-
-#[serde_as]
-#[derive(Debug, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct AppendAction {
-    #[serde_as(as = "VecLogError<_>")]
-    pub continuation_items: MapResult<Vec<YouTubeListItem>>,
-}

src/client/response/mod.rs

@@ -9,13 +9,11 @@ pub mod video_details;
 pub mod video_item;
 
 pub use channel::Channel;
-pub use channel::ChannelCont;
 pub use player::Player;
 pub use playlist::Playlist;
 pub use playlist::PlaylistCont;
 pub use playlist_music::PlaylistMusic;
 pub use search::Search;
-pub use search::SearchCont;
 pub use trends::Startpage;
 pub use trends::Trending;
 pub use url_endpoint::ResolvedUrl;

src/client/response/search.rs

@@ -1,14 +1,7 @@
 use serde::Deserialize;
-use serde_with::json::JsonString;
+use serde_with::{json::JsonString, serde_as};
-use serde_with::{serde_as, VecSkipError};
 
-use crate::serializer::ignore_any;
+use super::video_item::YouTubeListRendererWrap;
-use crate::serializer::{text::Text, MapResult, VecLogError};
-
-use super::video_item::YouTubeListItem;
-use super::{
-    ChannelRenderer, ContentsRenderer, ContinuationEndpoint, PlaylistRenderer, VideoRenderer,
-};
 
 #[serde_as]
 #[derive(Debug, Deserialize)]
@@ -19,28 +12,6 @@ pub struct Search {
     pub contents: Contents,
 }
 
-#[serde_as]
-#[derive(Debug, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct SearchCont {
-    #[serde_as(as = "Option<JsonString>")]
-    pub estimated_results: Option<u64>,
-    #[serde_as(as = "VecSkipError<_>")]
-    pub on_response_received_commands: Vec<SearchContCommand>,
-}
-
-#[derive(Debug, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct SearchContCommand {
-    pub append_continuation_items_action: SearchContAction,
-}
-
-#[derive(Debug, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct SearchContAction {
-    pub continuation_items: Vec<SectionListItem>,
-}
-
 #[derive(Debug, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct Contents {
@@ -50,52 +21,5 @@ pub struct Contents {
 #[derive(Debug, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct TwoColumnSearchResultsRenderer {
-    pub primary_contents: PrimaryContents,
+    pub primary_contents: YouTubeListRendererWrap,
-}
-
-#[derive(Debug, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct PrimaryContents {
-    pub section_list_renderer: ContentsRenderer<SectionListItem>,
-}
-
-#[serde_as]
-#[derive(Debug, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub enum SectionListItem {
-    #[serde(rename_all = "camelCase")]
-    ItemSectionRenderer {
-        #[serde_as(as = "VecLogError<_>")]
-        contents: MapResult<Vec<YouTubeListItem>>,
-    },
-    /// Continuation token to fetch more search results
-    #[serde(rename_all = "camelCase")]
-    ContinuationItemRenderer {
-        continuation_endpoint: ContinuationEndpoint,
-    },
-}
-
-#[serde_as]
-#[derive(Debug, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub enum SearchItem {
-    /// Video in search results
-    VideoRenderer(VideoRenderer),
-    /// Playlist in search results
-    PlaylistRenderer(PlaylistRenderer),
-    /// Channel displayed in search results
-    ChannelRenderer(ChannelRenderer),
-
-    /// Corrected search query
-    #[serde(rename_all = "camelCase")]
-    ShowingResultsForRenderer {
-        #[serde_as(as = "Text")]
-        corrected_query: String,
-    },
-    /// No search result item (e.g. ad) or unimplemented item
-    ///
-    /// Unimplemented:
-    /// - shelfRenderer (e.g. Latest from channel, For you)
-    #[serde(other, deserialize_with = "ignore_any")]
-    None,
 }

src/client/response/trends.rs

@@ -1,37 +1,33 @@
 use serde::Deserialize;
 use serde_with::{serde_as, VecSkipError};
 
-use crate::serializer::{MapResult, VecLogError};
+use super::{video_item::YouTubeListRendererWrap, ContentRenderer};
-
-use super::{ContentRenderer, YouTubeListItem};
 
 #[derive(Debug, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct Startpage {
-    pub contents: Contents<BrowseResultsStartpage>,
+    pub contents: Contents,
     pub response_context: ResponseContext,
 }
 
 #[derive(Debug, Deserialize)]
 #[serde(rename_all = "camelCase")]
-pub struct Contents<T> {
+pub struct Trending {
-    pub two_column_browse_results_renderer: T,
+    pub contents: Contents,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Contents {
+    pub two_column_browse_results_renderer: BrowseResults,
 }
 
 #[serde_as]
 #[derive(Debug, Deserialize)]
 #[serde(rename_all = "camelCase")]
-pub struct BrowseResultsStartpage {
+pub struct BrowseResults {
     #[serde_as(as = "VecSkipError<_>")]
-    pub tabs: Vec<Tab<StartpageTabContent>>,
+    pub tabs: Vec<Tab<YouTubeListRendererWrap>>,
-}
-
-#[serde_as]
-#[derive(Debug, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct BrowseResultsTrends {
-    #[serde_as(as = "VecSkipError<_>")]
-    pub tabs: Vec<Tab<TrendingTabContent>>,
 }
 
 #[derive(Debug, Deserialize)]
@@ -40,40 +36,6 @@ pub struct Tab<T> {
     pub tab_renderer: ContentRenderer<T>,
 }
 
-#[derive(Debug, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct StartpageTabContent {
-    pub rich_grid_renderer: RichGridRenderer,
-}
-
-#[serde_as]
-#[derive(Debug, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct RichGridRenderer {
-    #[serde_as(as = "VecLogError<_>")]
-    pub contents: MapResult<Vec<YouTubeListItem>>,
-}
-
-#[derive(Debug, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct Trending {
-    pub contents: Contents<BrowseResultsTrends>,
-}
-
-#[derive(Debug, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct TrendingTabContent {
-    pub section_list_renderer: SectionListRenderer,
-}
-
-#[serde_as]
-#[derive(Debug, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct SectionListRenderer {
-    #[serde_as(as = "VecLogError<_>")]
-    pub contents: MapResult<Vec<YouTubeListItem>>,
-}
-
 #[derive(Debug, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ResponseContext {

src/client/response/video_item.rs

@@ -165,6 +165,21 @@ pub struct ChannelRenderer {
     pub owner_badges: Vec<ChannelBadge>,
 }
 
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct YouTubeListRendererWrap {
+    #[serde(alias = "richGridRenderer")]
+    pub section_list_renderer: YouTubeListRenderer,
+}
+
+#[serde_as]
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct YouTubeListRenderer {
+    #[serde_as(as = "VecLogError<_>")]
+    pub contents: MapResult<Vec<YouTubeListItem>>,
+}
+
 /// Result of mapping a list of different YouTube enities
 /// (videos, channels, playlists)
 #[derive(Debug)]

src/client/search.rs

@@ -93,21 +93,19 @@ impl MapResponse<SearchResult> for response::Search {
         lang: Language,
         _deobf: Option<&Deobfuscator>,
     ) -> Result<MapResult<SearchResult>, ExtractionError> {
-        let section_list_items = self
+        let items = self
             .contents
             .two_column_search_results_renderer
             .primary_contents
             .section_list_renderer
             .contents;
 
-        let (items, ctoken) = map_section_list_items(section_list_items)?;
-
         let mut mapper = response::YouTubeListMapper::<YouTubeItem>::new(lang);
         mapper.map_response(items);
 
         Ok(MapResult {
             c: SearchResult {
-                items: Paginator::new(self.estimated_results, mapper.items, ctoken),
+                items: Paginator::new(self.estimated_results, mapper.items, mapper.ctoken),
                 corrected_query: mapper.corrected_query,
             },
             warnings: mapper.warnings,
@@ -115,32 +113,6 @@ impl MapResponse<SearchResult> for response::Search {
     }
 }
 
-fn map_section_list_items(
-    section_list_items: Vec<response::search::SectionListItem>,
-) -> Result<(MapResult<Vec<response::YouTubeListItem>>, Option<String>), ExtractionError> {
-    let mut items = None;
-    let mut ctoken = None;
-    section_list_items.into_iter().for_each(|item| match item {
-        response::search::SectionListItem::ItemSectionRenderer { contents } => {
-            items = Some(contents);
-        }
-        response::search::SectionListItem::ContinuationItemRenderer {
-            continuation_endpoint,
-        } => {
-            ctoken = Some(continuation_endpoint.continuation_command.token);
-        }
-    });
-
-    let items = some_or_bail!(
-        items,
-        Err(ExtractionError::InvalidData(
-            "no item section renderer".into()
-        ))
-    );
-
-    Ok((items, ctoken))
-}
-
 #[cfg(test)]
 mod tests {
     use std::{fs::File, io::BufReader, path::Path};

src/client/trends.rs

@@ -57,7 +57,7 @@ impl MapResponse<Paginator<VideoItem>> for response::Startpage {
             .ok_or_else(|| ExtractionError::InvalidData("no contents".into()))?
             .tab_renderer
             .content
-            .rich_grid_renderer
+            .section_list_renderer
             .contents;
 
         Ok(map_startpage_videos(