Channels search, add SDWebImage framework

Model/Applications/InvidiousAPI.swift

@@ -1,3 +1,4 @@
+import AVKit
 import Defaults
 import Foundation
 import Siesta
@@ -80,15 +81,25 @@ final class InvidiousAPI: Service, ObservableObject, VideosAPI {
         }
 
         configureTransformer(pathPattern("popular"), requestMethods: [.get]) { (content: Entity<JSON>) -> [Video] in
-            content.json.arrayValue.map(Video.init)
+            content.json.arrayValue.map(InvidiousAPI.extractVideo)
         }
 
         configureTransformer(pathPattern("trending"), requestMethods: [.get]) { (content: Entity<JSON>) -> [Video] in
-            content.json.arrayValue.map(Video.init)
+            content.json.arrayValue.map(InvidiousAPI.extractVideo)
         }
 
-        configureTransformer(pathPattern("search"), requestMethods: [.get]) { (content: Entity<JSON>) -> [Video] in
-            content.json.arrayValue.map(Video.init)
+        configureTransformer(pathPattern("search"), requestMethods: [.get]) { (content: Entity<JSON>) -> [ContentItem] in
+            content.json.arrayValue.map {
+                let type = $0.dictionaryValue["type"]?.stringValue
+
+                if type == "channel" {
+                    return ContentItem(channel: InvidiousAPI.extractChannel(from: $0))
+                } else if type == "playlist" {
+                    // TODO: fix playlists
+                    return ContentItem(playlist: Playlist(JSON(parseJSON: "{}")))
+                }
+                return ContentItem(video: InvidiousAPI.extractVideo($0))
+            }
         }
 
         configureTransformer(pathPattern("search/suggestions"), requestMethods: [.get]) { (content: Entity<JSON>) -> [String] in
@@ -114,34 +125,34 @@ final class InvidiousAPI: Service, ObservableObject, VideosAPI {
 
         configureTransformer(pathPattern("auth/feed"), requestMethods: [.get]) { (content: Entity<JSON>) -> [Video] in
             if let feedVideos = content.json.dictionaryValue["videos"] {
-                return feedVideos.arrayValue.map(Video.init)
+                return feedVideos.arrayValue.map(InvidiousAPI.extractVideo)
             }
 
             return []
         }
 
         configureTransformer(pathPattern("auth/subscriptions"), requestMethods: [.get]) { (content: Entity<JSON>) -> [Channel] in
-            content.json.arrayValue.map(Channel.init)
+            content.json.arrayValue.map(InvidiousAPI.extractChannel)
         }
 
         configureTransformer(pathPattern("channels/*"), requestMethods: [.get]) { (content: Entity<JSON>) -> Channel in
-            Channel(json: content.json)
+            InvidiousAPI.extractChannel(from: content.json)
         }
 
         configureTransformer(pathPattern("channels/*/latest"), requestMethods: [.get]) { (content: Entity<JSON>) -> [Video] in
-            content.json.arrayValue.map(Video.init)
+            content.json.arrayValue.map(InvidiousAPI.extractVideo)
         }
 
         configureTransformer(pathPattern("videos/*"), requestMethods: [.get]) { (content: Entity<JSON>) -> Video in
-            Video(content.json)
+            InvidiousAPI.extractVideo(content.json)
         }
     }
 
-    fileprivate func pathPattern(_ path: String) -> String {
+    private func pathPattern(_ path: String) -> String {
         "**\(InvidiousAPI.basePath)/\(path)"
     }
 
-    fileprivate func basePathAppending(_ path: String) -> String {
+    private func basePathAppending(_ path: String) -> String {
         "\(InvidiousAPI.basePath)/\(path)"
     }
 
@@ -207,6 +218,7 @@ final class InvidiousAPI: Service, ObservableObject, VideosAPI {
         var resource = resource(baseURL: account.url, path: basePathAppending("search"))
             .withParam("q", searchQuery(query.query))
             .withParam("sort_by", query.sortBy.parameter)
+            .withParam("type", "all")
 
         if let date = query.date, date != .any {
             resource = resource.withParam("date", date.rawValue)
@@ -242,4 +254,106 @@ final class InvidiousAPI: Service, ObservableObject, VideosAPI {
 
         return searchQuery
     }
+
+    static func assetURLFrom(instance: Instance, url: URL) -> URL? {
+        guard let instanceURLComponents = URLComponents(string: instance.url),
+              var urlComponents = URLComponents(url: url, resolvingAgainstBaseURL: false) else { return nil }
+
+        urlComponents.scheme = instanceURLComponents.scheme
+        urlComponents.host = instanceURLComponents.host
+
+        return urlComponents.url
+    }
+
+    static func extractVideo(_ json: JSON) -> Video {
+        let indexID: String?
+        var id: Video.ID
+        var publishedAt: Date?
+
+        if let publishedInterval = json["published"].double {
+            publishedAt = Date(timeIntervalSince1970: publishedInterval)
+        }
+
+        let videoID = json["videoId"].stringValue
+
+        if let index = json["indexId"].string {
+            indexID = index
+            id = videoID + index
+        } else {
+            indexID = nil
+            id = videoID
+        }
+
+        return Video(
+            id: id,
+            videoID: videoID,
+            title: json["title"].stringValue,
+            author: json["author"].stringValue,
+            length: json["lengthSeconds"].doubleValue,
+            published: json["publishedText"].stringValue,
+            views: json["viewCount"].intValue,
+            description: json["description"].stringValue,
+            genre: json["genre"].stringValue,
+            channel: extractChannel(from: json),
+            thumbnails: extractThumbnails(from: json),
+            indexID: indexID,
+            live: json["liveNow"].boolValue,
+            upcoming: json["isUpcoming"].boolValue,
+            publishedAt: publishedAt,
+            likes: json["likeCount"].int,
+            dislikes: json["dislikeCount"].int,
+            keywords: json["keywords"].arrayValue.map { $0.stringValue },
+            streams: extractFormatStreams(from: json["formatStreams"].arrayValue) +
+                extractAdaptiveFormats(from: json["adaptiveFormats"].arrayValue)
+        )
+    }
+
+    static func extractChannel(from json: JSON) -> Channel {
+        let thumbnailURL = "https:\(json["authorThumbnails"].arrayValue.first?.dictionaryValue["url"]?.stringValue ?? "")"
+
+        return Channel(
+            id: json["authorId"].stringValue,
+            name: json["author"].stringValue,
+            thumbnailURL: URL(string: thumbnailURL),
+            subscriptionsCount: json["subCount"].int,
+            subscriptionsText: json["subCountText"].string,
+            videos: json.dictionaryValue["latestVideos"]?.arrayValue.map(InvidiousAPI.extractVideo) ?? []
+        )
+    }
+
+    private static func extractThumbnails(from details: JSON) -> [Thumbnail] {
+        details["videoThumbnails"].arrayValue.map { json in
+            Thumbnail(url: json["url"].url!, quality: .init(rawValue: json["quality"].string!)!)
+        }
+    }
+
+    private static func extractFormatStreams(from streams: [JSON]) -> [Stream] {
+        streams.map {
+            SingleAssetStream(
+                avAsset: AVURLAsset(url: $0["url"].url!),
+                resolution: Stream.Resolution.from(resolution: $0["resolution"].stringValue),
+                kind: .stream,
+                encoding: $0["encoding"].stringValue
+            )
+        }
+    }
+
+    private static func extractAdaptiveFormats(from streams: [JSON]) -> [Stream] {
+        let audioAssetURL = streams.first { $0["type"].stringValue.starts(with: "audio/mp4") }
+        guard audioAssetURL != nil else {
+            return []
+        }
+
+        let videoAssetsURLs = streams.filter { $0["type"].stringValue.starts(with: "video/mp4") && $0["encoding"].stringValue == "h264" }
+
+        return videoAssetsURLs.map {
+            Stream(
+                audioAsset: AVURLAsset(url: audioAssetURL!["url"].url!),
+                videoAsset: AVURLAsset(url: $0["url"].url!),
+                resolution: Stream.Resolution.from(resolution: $0["resolution"].stringValue),
+                kind: .adaptive,
+                encoding: $0["encoding"].stringValue
+            )
+        }
+    }
 }

Model/Applications/PipedAPI.swift

@@ -32,19 +32,19 @@ final class PipedAPI: Service, ObservableObject, VideosAPI {
         }
 
         configureTransformer(pathPattern("channel/*")) { (content: Entity<JSON>) -> Channel? in
-            self.extractChannel(content.json)
+            PipedAPI.extractChannel(content.json)
         }
 
         configureTransformer(pathPattern("streams/*")) { (content: Entity<JSON>) -> Video? in
-            self.extractVideo(content.json)
+            PipedAPI.extractVideo(content.json)
         }
 
         configureTransformer(pathPattern("trending")) { (content: Entity<JSON>) -> [Video] in
-            self.extractVideos(content.json)
+            PipedAPI.extractVideos(content.json)
         }
 
-        configureTransformer(pathPattern("search")) { (content: Entity<JSON>) -> [Video] in
-            self.extractVideos(content.json.dictionaryValue["items"]!)
+        configureTransformer(pathPattern("search")) { (content: Entity<JSON>) -> [ContentItem] in
+            PipedAPI.extractContentItems(content.json.dictionaryValue["items"]!)
         }
 
         configureTransformer(pathPattern("suggestions")) { (content: Entity<JSON>) -> [String] in
@@ -52,154 +52,6 @@ final class PipedAPI: Service, ObservableObject, VideosAPI {
         }
     }
 
-    private func extractChannel(_ content: JSON) -> Channel? {
-        Channel(
-            id: content.dictionaryValue["id"]!.stringValue,
-            name: content.dictionaryValue["name"]!.stringValue,
-            subscriptionsCount: content.dictionaryValue["subscriberCount"]!.intValue,
-            videos: extractVideos(content.dictionaryValue["relatedStreams"]!)
-        )
-    }
-
-    private func extractVideo(_ content: JSON) -> Video? {
-        let details = content.dictionaryValue
-        let url = details["url"]?.string
-
-        if !url.isNil {
-            guard url!.contains("/watch") else {
-                return nil
-            }
-        }
-
-        let channelId = details["uploaderUrl"]!.stringValue.components(separatedBy: "/").last!
-
-        let thumbnails: [Thumbnail] = Thumbnail.Quality.allCases.compactMap {
-            if let url = buildThumbnailURL(content, quality: $0) {
-                return Thumbnail(url: url, quality: $0)
-            }
-
-            return nil
-        }
-
-        let author = details["uploaderName"]?.stringValue ?? details["uploader"]!.stringValue
-
-        return Video(
-            videoID: extractID(content),
-            title: details["title"]!.stringValue,
-            author: author,
-            length: details["duration"]!.doubleValue,
-            published: details["uploadedDate"]?.stringValue ?? details["uploadDate"]!.stringValue,
-            views: details["views"]!.intValue,
-            description: extractDescription(content),
-            channel: Channel(id: channelId, name: author),
-            thumbnails: thumbnails,
-            likes: details["likes"]?.int,
-            dislikes: details["dislikes"]?.int,
-            streams: extractStreams(content)
-        )
-    }
-
-    private func extractID(_ content: JSON) -> Video.ID {
-        content.dictionaryValue["url"]?.stringValue.components(separatedBy: "?v=").last ??
-            extractThumbnailURL(content)!.relativeString.components(separatedBy: "/")[4]
-    }
-
-    private func extractThumbnailURL(_ content: JSON) -> URL? {
-        content.dictionaryValue["thumbnail"]?.url! ?? content.dictionaryValue["thumbnailUrl"]!.url!
-    }
-
-    private func buildThumbnailURL(_ content: JSON, quality: Thumbnail.Quality) -> URL? {
-        let thumbnailURL = extractThumbnailURL(content)
-        guard !thumbnailURL.isNil else {
-            return nil
-        }
-
-        return URL(string: thumbnailURL!
-            .absoluteString
-            .replacingOccurrences(of: "_webp", with: "")
-            .replacingOccurrences(of: ".webp", with: ".jpg")
-            .replacingOccurrences(of: "hqdefault", with: quality.filename)
-            .replacingOccurrences(of: "maxresdefault", with: quality.filename)
-        )!
-    }
-
-    private func extractDescription(_ content: JSON) -> String? {
-        guard var description = content.dictionaryValue["description"]?.string else {
-            return nil
-        }
-
-        description = description.replacingOccurrences(
-            of: "<br/>|<br />|<br>",
-            with: "\n",
-            options: .regularExpression,
-            range: nil
-        )
-
-        description = description.replacingOccurrences(
-            of: "<[^>]+>",
-            with: "",
-            options: .regularExpression,
-            range: nil
-        )
-
-        return description
-    }
-
-    private func extractVideos(_ content: JSON) -> [Video] {
-        content.arrayValue.compactMap(extractVideo(_:))
-    }
-
-    private func extractStreams(_ content: JSON) -> [Stream] {
-        var streams = [Stream]()
-
-        if let hlsURL = content.dictionaryValue["hls"]?.url {
-            streams.append(Stream(hlsURL: hlsURL))
-        }
-
-        guard let audioStream = compatibleAudioStreams(content).first else {
-            return streams
-        }
-
-        let videoStreams = compatibleVideoStream(content)
-
-        videoStreams.forEach { videoStream in
-            let audioAsset = AVURLAsset(url: audioStream.dictionaryValue["url"]!.url!)
-            let videoAsset = AVURLAsset(url: videoStream.dictionaryValue["url"]!.url!)
-
-            let videoOnly = videoStream.dictionaryValue["videoOnly"]?.boolValue ?? true
-            let resolution = Stream.Resolution.from(resolution: videoStream.dictionaryValue["quality"]!.stringValue)
-
-            if videoOnly {
-                streams.append(
-                    Stream(audioAsset: audioAsset, videoAsset: videoAsset, resolution: resolution, kind: .adaptive)
-                )
-            } else {
-                streams.append(
-                    SingleAssetStream(avAsset: videoAsset, resolution: resolution, kind: .stream)
-                )
-            }
-        }
-
-        return streams
-    }
-
-    private func compatibleAudioStreams(_ content: JSON) -> [JSON] {
-        content
-            .dictionaryValue["audioStreams"]?
-            .arrayValue
-            .filter { $0.dictionaryValue["format"]?.stringValue == "M4A" }
-            .sorted {
-                $0.dictionaryValue["bitrate"]?.intValue ?? 0 > $1.dictionaryValue["bitrate"]?.intValue ?? 0
-            } ?? []
-    }
-
-    private func compatibleVideoStream(_ content: JSON) -> [JSON] {
-        content
-            .dictionaryValue["videoStreams"]?
-            .arrayValue
-            .filter { $0.dictionaryValue["format"] == "MPEG_4" } ?? []
-    }
-
     func channel(_ id: String) -> Resource {
         resource(baseURL: account.url, path: "channel/\(id)")
     }
@@ -240,4 +92,205 @@ final class PipedAPI: Service, ObservableObject, VideosAPI {
     private func pathPattern(_ path: String) -> String {
         "**\(path)"
     }
+
+    private static func extractContentItem(_ content: JSON) -> ContentItem? {
+        let details = content.dictionaryValue
+        let url: String! = details["url"]?.string
+
+        let contentType: ContentItem.ContentType
+
+        if !url.isNil {
+            if url.contains("/playlist") {
+                contentType = .playlist
+            } else if url.contains("/channel") {
+                contentType = .channel
+            } else {
+                contentType = .video
+            }
+        } else {
+            contentType = .video
+        }
+
+        switch contentType {
+        case .video:
+            if let video = PipedAPI.extractVideo(content) {
+                return ContentItem(video: video)
+            }
+
+        case .playlist:
+            return nil
+
+        case .channel:
+            if let channel = PipedAPI.extractChannel(content) {
+                return ContentItem(channel: channel)
+            }
+        }
+
+        return nil
+    }
+
+    private static func extractContentItems(_ content: JSON) -> [ContentItem] {
+        content.arrayValue.compactMap { PipedAPI.extractContentItem($0) }
+    }
+
+    private static func extractChannel(_ content: JSON) -> Channel? {
+        let attributes = content.dictionaryValue
+        guard let id = attributes["id"]?.stringValue ??
+            attributes["url"]?.stringValue.components(separatedBy: "/").last
+        else {
+            return nil
+        }
+
+        let subscriptionsCount = attributes["subscriberCount"]?.intValue ?? attributes["subscribers"]?.intValue
+
+        var videos = [Video]()
+        if let relatedStreams = attributes["relatedStreams"] {
+            videos = PipedAPI.extractVideos(relatedStreams)
+        }
+
+        return Channel(
+            id: id,
+            name: attributes["name"]!.stringValue,
+            thumbnailURL: attributes["thumbnail"]?.url,
+            subscriptionsCount: subscriptionsCount,
+            videos: videos
+        )
+    }
+
+    private static func extractVideo(_ content: JSON) -> Video? {
+        let details = content.dictionaryValue
+        let url = details["url"]?.string
+
+        if !url.isNil {
+            guard url!.contains("/watch") else {
+                return nil
+            }
+        }
+
+        let channelId = details["uploaderUrl"]!.stringValue.components(separatedBy: "/").last!
+
+        let thumbnails: [Thumbnail] = Thumbnail.Quality.allCases.compactMap {
+            if let url = PipedAPI.buildThumbnailURL(content, quality: $0) {
+                return Thumbnail(url: url, quality: $0)
+            }
+
+            return nil
+        }
+
+        let author = details["uploaderName"]?.stringValue ?? details["uploader"]!.stringValue
+
+        return Video(
+            videoID: PipedAPI.extractID(content),
+            title: details["title"]!.stringValue,
+            author: author,
+            length: details["duration"]!.doubleValue,
+            published: details["uploadedDate"]?.stringValue ?? details["uploadDate"]!.stringValue,
+            views: details["views"]!.intValue,
+            description: PipedAPI.extractDescription(content),
+            channel: Channel(id: channelId, name: author),
+            thumbnails: thumbnails,
+            likes: details["likes"]?.int,
+            dislikes: details["dislikes"]?.int,
+            streams: extractStreams(content)
+        )
+    }
+
+    private static func extractID(_ content: JSON) -> Video.ID {
+        content.dictionaryValue["url"]?.stringValue.components(separatedBy: "?v=").last ??
+            extractThumbnailURL(content)!.relativeString.components(separatedBy: "/")[4]
+    }
+
+    private static func extractThumbnailURL(_ content: JSON) -> URL? {
+        content.dictionaryValue["thumbnail"]?.url! ?? content.dictionaryValue["thumbnailUrl"]!.url!
+    }
+
+    private static func buildThumbnailURL(_ content: JSON, quality: Thumbnail.Quality) -> URL? {
+        let thumbnailURL = extractThumbnailURL(content)
+        guard !thumbnailURL.isNil else {
+            return nil
+        }
+
+        return URL(string: thumbnailURL!
+            .absoluteString
+            .replacingOccurrences(of: "hqdefault", with: quality.filename)
+            .replacingOccurrences(of: "maxresdefault", with: quality.filename)
+        )!
+    }
+
+    private static func extractDescription(_ content: JSON) -> String? {
+        guard var description = content.dictionaryValue["description"]?.string else {
+            return nil
+        }
+
+        description = description.replacingOccurrences(
+            of: "<br/>|<br />|<br>",
+            with: "\n",
+            options: .regularExpression,
+            range: nil
+        )
+
+        description = description.replacingOccurrences(
+            of: "<[^>]+>",
+            with: "",
+            options: .regularExpression,
+            range: nil
+        )
+
+        return description
+    }
+
+    private static func extractVideos(_ content: JSON) -> [Video] {
+        content.arrayValue.compactMap(extractVideo(_:))
+    }
+
+    private static func extractStreams(_ content: JSON) -> [Stream] {
+        var streams = [Stream]()
+
+        if let hlsURL = content.dictionaryValue["hls"]?.url {
+            streams.append(Stream(hlsURL: hlsURL))
+        }
+
+        guard let audioStream = PipedAPI.compatibleAudioStreams(content).first else {
+            return streams
+        }
+
+        let videoStreams = PipedAPI.compatibleVideoStream(content)
+
+        videoStreams.forEach { videoStream in
+            let audioAsset = AVURLAsset(url: audioStream.dictionaryValue["url"]!.url!)
+            let videoAsset = AVURLAsset(url: videoStream.dictionaryValue["url"]!.url!)
+
+            let videoOnly = videoStream.dictionaryValue["videoOnly"]?.boolValue ?? true
+            let resolution = Stream.Resolution.from(resolution: videoStream.dictionaryValue["quality"]!.stringValue)
+
+            if videoOnly {
+                streams.append(
+                    Stream(audioAsset: audioAsset, videoAsset: videoAsset, resolution: resolution, kind: .adaptive)
+                )
+            } else {
+                streams.append(
+                    SingleAssetStream(avAsset: videoAsset, resolution: resolution, kind: .stream)
+                )
+            }
+        }
+
+        return streams
+    }
+
+    private static func compatibleAudioStreams(_ content: JSON) -> [JSON] {
+        content
+            .dictionaryValue["audioStreams"]?
+            .arrayValue
+            .filter { $0.dictionaryValue["format"]?.stringValue == "M4A" }
+            .sorted {
+                $0.dictionaryValue["bitrate"]?.intValue ?? 0 > $1.dictionaryValue["bitrate"]?.intValue ?? 0
+            } ?? []
+    }
+
+    private static func compatibleVideoStream(_ content: JSON) -> [JSON] {
+        content
+            .dictionaryValue["videoStreams"]?
+            .arrayValue
+            .filter { $0.dictionaryValue["format"] == "MPEG_4" } ?? []
+    }
 }

Model/Channel.swift

@@ -6,31 +6,30 @@ import SwiftyJSON
 struct Channel: Identifiable, Hashable {
     var id: String
     var name: String
+    var thumbnailURL: URL?
     var videos = [Video]()
 
     private var subscriptionsCount: Int?
     private var subscriptionsText: String?
 
-    init(json: JSON) {
-        id = json["authorId"].stringValue
-        name = json["author"].stringValue
-        subscriptionsCount = json["subCount"].int
-        subscriptionsText = json["subCountText"].string
-
-        if let channelVideos = json.dictionaryValue["latestVideos"] {
-            videos = channelVideos.arrayValue.map(Video.init)
-        }
-    }
-
-    init(id: String, name: String, subscriptionsCount: Int? = nil, videos: [Video] = []) {
+    init(
+        id: String,
+        name: String,
+        thumbnailURL: URL? = nil,
+        subscriptionsCount: Int? = nil,
+        subscriptionsText: String? = nil,
+        videos: [Video] = []
+    ) {
         self.id = id
         self.name = name
+        self.thumbnailURL = thumbnailURL
         self.subscriptionsCount = subscriptionsCount
+        self.subscriptionsText = subscriptionsText
         self.videos = videos
     }
 
     var subscriptionsString: String? {
-        if subscriptionsCount != nil {
+        if subscriptionsCount != nil, subscriptionsCount! > 0 {
             return subscriptionsCount!.formattedAsAbbreviation()
         }
 

Model/ContentItem.swift

@@ -0,0 +1,48 @@
+import Foundation
+
+struct ContentItem: Identifiable {
+    enum ContentType: String {
+        case video, playlist, channel
+
+        private var sortOrder: Int {
+            switch self {
+            case .channel:
+                return 1
+            case .video:
+                return 2
+            default:
+                return 3
+            }
+        }
+
+        static func < (lhs: ContentType, rhs: ContentType) -> Bool {
+            lhs.sortOrder < rhs.sortOrder
+        }
+    }
+
+    var video: Video!
+    var playlist: Playlist!
+    var channel: Channel!
+
+    static func array(of videos: [Video]) -> [ContentItem] {
+        videos.map { ContentItem(video: $0) }
+    }
+
+    static func < (lhs: ContentItem, rhs: ContentItem) -> Bool {
+        lhs.contentType < rhs.contentType
+    }
+
+    var id: String {
+        "\(contentType.rawValue)-\(video?.id ?? playlist?.id ?? channel?.id ?? "")"
+    }
+
+    var contentType: ContentType {
+        if !playlist.isNil {
+            return .playlist
+        } else if !channel.isNil {
+            return .channel
+        }
+
+        return .video
+    }
+}

Model/Player/PlayerModel.swift

@@ -98,14 +98,6 @@ final class PlayerModel: ObservableObject {
         }
     }
 
-    func piped(_ instance: Instance) -> PipedAPI {
-        PipedAPI(account: instance.anonymousAccount)
-    }
-
-    func invidious(_ instance: Instance) -> InvidiousAPI {
-        InvidiousAPI(account: instance.anonymousAccount)
-    }
-
     private func playStream(
         _ stream: Stream,
         of video: Video,

Model/Player/PlayerStreams.swift

@@ -1,6 +1,7 @@
 import Foundation
 import Siesta
 import SwiftUI
+import AVFoundation
 
 extension PlayerModel {
     var isLoadingAvailableStreams: Bool {
@@ -101,14 +102,16 @@ extension PlayerModel {
     func streamsWithInstance(instance: Instance, streams: [Stream]) -> [Stream] {
         streams.map { stream in
             stream.instance = instance
+
+            if instance.app == .invidious {
+                stream.audioAsset = AVURLAsset(url: InvidiousAPI.assetURLFrom(instance: instance, url: stream.audioAsset.url)!)
+                stream.videoAsset = AVURLAsset(url: InvidiousAPI.assetURLFrom(instance: instance, url: stream.videoAsset.url)!)
+            }
+            
             return stream
         }
     }
 
-    func streamsWithAssetsFromInstance(instance: Instance, streams: [Stream]) -> [Stream] {
-        streams.map { stream in stream.withAssetsFrom(instance) }
-    }
-
     func streamsSorter(_ lhs: Stream, _ rhs: Stream) -> Bool {
         lhs.kind == rhs.kind ? (lhs.resolution.height > rhs.resolution.height) : (lhs.kind < rhs.kind)
     }

Model/Playlist.swift

@@ -34,7 +34,7 @@ struct Playlist: Identifiable, Equatable, Hashable {
         title = json["title"].stringValue
         visibility = json["isListed"].boolValue ? .public : .private
         updated = json["updated"].doubleValue
-        videos = json["videos"].arrayValue.map { Video($0) }
+        videos = json["videos"].arrayValue.map { InvidiousAPI.extractVideo($0) }
     }
 
     static func == (lhs: Playlist, rhs: Playlist) -> Bool {

Model/RecentsModel.swift

@@ -13,9 +13,11 @@ final class RecentsModel: ObservableObject {
     }
 
     func add(_ item: RecentItem) {
-        if !items.contains(where: { $0.id == item.id }) {
-            items.append(item)
+        if let index = items.firstIndex(where: { $0.id == item.id }) {
+            items.remove(at: index)
         }
+
+        items.append(item)
     }
 
     func close(_ item: RecentItem) {

Model/Search/SearchModel.swift

@@ -3,7 +3,7 @@ import Siesta
 import SwiftUI
 
 final class SearchModel: ObservableObject {
-    @Published var store = Store<[Video]>()
+    @Published var store = Store<[ContentItem]>()
 
     var accounts = AccountsModel()
     @Published var query = SearchQuery()
@@ -62,8 +62,8 @@ final class SearchModel: ObservableObject {
 
         if let request = resource.loadIfNeeded() {
             request.onSuccess { response in
-                if let videos: [Video] = response.typedContent() {
-                    self.replace(videos, for: currentResource)
+                if let results: [ContentItem] = response.typedContent() {
+                    self.replace(results, for: currentResource)
                 }
             }
         } else {
@@ -71,9 +71,9 @@ final class SearchModel: ObservableObject {
         }
     }
 
-    func replace(_ videos: [Video], for resource: Resource) {
+    func replace(_ videos: [ContentItem], for resource: Resource) {
         if self.resource == resource {
-            store = Store<[Video]>(videos)
+            store = Store<[ContentItem]>(videos)
         }
     }
 

Model/Stream.swift

@@ -148,29 +148,4 @@ class Stream: Equatable, Hashable, Identifiable {
         hasher.combine(audioAsset?.url)
         hasher.combine(hlsURL)
     }
-
-    func withAssetsFrom(_ instance: Instance) -> Stream {
-        if kind == .hls {
-            return Stream(instance: instance, hlsURL: hlsURL)
-        } else {
-            return Stream(
-                instance: instance,
-                audioAsset: AVURLAsset(url: assetURLFrom(instance: instance, url: (audioAsset ?? videoAsset).url)!),
-                videoAsset: AVURLAsset(url: assetURLFrom(instance: instance, url: videoAsset.url)!),
-                resolution: resolution,
-                kind: kind,
-                encoding: encoding
-            )
-        }
-    }
-
-    private func assetURLFrom(instance: Instance, url: URL) -> URL? {
-        guard let instanceURLComponents = URLComponents(string: instance.url),
-              var urlComponents = URLComponents(url: url, resolvingAgainstBaseURL: false) else { return nil }
-
-        urlComponents.scheme = instanceURLComponents.scheme
-        urlComponents.host = instanceURLComponents.host
-
-        return urlComponents.url
-    }
 }

Model/Thumbnail.swift

@@ -32,11 +32,6 @@ struct Thumbnail {
     var url: URL
     var quality: Quality
 
-    init(_ json: JSON) {
-        url = json["url"].url!
-        quality = Quality(rawValue: json["quality"].string!)!
-    }
-
     init(url: URL, quality: Quality) {
         self.url = url
         self.quality = quality

Model/Video.swift

@@ -72,49 +72,6 @@ struct Video: Identifiable, Equatable, Hashable {
         self.streams = streams
     }
 
-    init(_ json: JSON) {
-        videoID = json["videoId"].stringValue
-
-        if let id = json["indexId"].string {
-            indexID = id
-            self.id = videoID + id
-        } else {
-            indexID = nil
-            id = videoID
-        }
-
-        title = json["title"].stringValue
-        author = json["author"].stringValue
-        length = json["lengthSeconds"].doubleValue
-        published = json["publishedText"].stringValue
-        views = json["viewCount"].intValue
-        description = json["description"].stringValue
-        genre = json["genre"].stringValue
-
-        thumbnails = Video.extractThumbnails(from: json)
-
-        live = json["liveNow"].boolValue
-        upcoming = json["isUpcoming"].boolValue
-
-        likes = json["likeCount"].int
-        dislikes = json["dislikeCount"].int
-
-        keywords = json["keywords"].arrayValue.map { $0.stringValue }
-
-        if let publishedInterval = json["published"].double {
-            publishedAt = Date(timeIntervalSince1970: publishedInterval)
-        }
-
-        if let hlsURL = json["hlsUrl"].url {
-            streams.append(.init(hlsURL: hlsURL))
-        }
-
-        streams = Video.extractFormatStreams(from: json["formatStreams"].arrayValue)
-        streams.append(contentsOf: Video.extractAdaptiveFormats(from: json["adaptiveFormats"].arrayValue))
-
-        channel = Channel(json: json)
-    }
-
     var playTime: String? {
         guard !length.isZero else {
             return nil
@@ -145,31 +102,6 @@ struct Video: Identifiable, Equatable, Hashable {
         dislikes?.formattedAsAbbreviation()
     }
 
-    var selectableStreams: [Stream] {
-        let streams = streams.sorted { $0.resolution > $1.resolution }
-        var selectable = [Stream]()
-
-        Stream.Resolution.allCases.forEach { resolution in
-            if let stream = streams.filter({ $0.resolution == resolution }).min(by: { $0.kind < $1.kind }) {
-                selectable.append(stream)
-            }
-        }
-
-        return selectable
-    }
-
-    var defaultStream: Stream? {
-        selectableStreams.first { $0.kind == .stream }
-    }
-
-    var bestStream: Stream? {
-        selectableStreams.min { $0.resolution > $1.resolution }
-    }
-
-    func streamWithResolution(_ resolution: Stream.Resolution) -> Stream? {
-        selectableStreams.first { $0.resolution == resolution } ?? defaultStream
-    }
-
     func thumbnailURL(quality: Thumbnail.Quality) -> URL? {
         if let url = thumbnails.first(where: { $0.quality == quality })?.url.absoluteString {
             return URL(string: url.replacingOccurrences(of: "hqdefault", with: quality.filename))
@@ -178,42 +110,6 @@ struct Video: Identifiable, Equatable, Hashable {
         return nil
     }
 
-    private static func extractThumbnails(from details: JSON) -> [Thumbnail] {
-        details["videoThumbnails"].arrayValue.map { json in
-            Thumbnail(json)
-        }
-    }
-
-    private static func extractFormatStreams(from streams: [JSON]) -> [Stream] {
-        streams.map {
-            SingleAssetStream(
-                avAsset: AVURLAsset(url: $0["url"].url!),
-                resolution: Stream.Resolution.from(resolution: $0["resolution"].stringValue),
-                kind: .stream,
-                encoding: $0["encoding"].stringValue
-            )
-        }
-    }
-
-    private static func extractAdaptiveFormats(from streams: [JSON]) -> [Stream] {
-        let audioAssetURL = streams.first { $0["type"].stringValue.starts(with: "audio/mp4") }
-        guard audioAssetURL != nil else {
-            return []
-        }
-
-        let videoAssetsURLs = streams.filter { $0["type"].stringValue.starts(with: "video/mp4") && $0["encoding"].stringValue == "h264" }
-
-        return videoAssetsURLs.map {
-            Stream(
-                audioAsset: AVURLAsset(url: audioAssetURL!["url"].url!),
-                videoAsset: AVURLAsset(url: $0["url"].url!),
-                resolution: Stream.Resolution.from(resolution: $0["resolution"].stringValue),
-                kind: .adaptive,
-                encoding: $0["encoding"].stringValue
-            )
-        }
-    }
-
     static func == (lhs: Video, rhs: Video) -> Bool {
         lhs.id == rhs.id
     }