Managing Favorites sections

Shared/Favorites/DropFavorite.swift

@@ -0,0 +1,35 @@
+import Foundation
+import SwiftUI
+
+struct DropFavorite: DropDelegate {
+    let item: FavoriteItem
+    @Binding var favorites: [FavoriteItem]
+    @Binding var current: FavoriteItem?
+
+    func dropEntered(info _: DropInfo) {
+        guard item != current else {
+            return
+        }
+
+        let from = favorites.firstIndex(of: current!)!
+        let to = favorites.firstIndex(of: item)!
+
+        guard favorites[to].id != current!.id else {
+            return
+        }
+
+        favorites.move(
+            fromOffsets: IndexSet(integer: from),
+            toOffset: to > from ? to + 1 : to
+        )
+    }
+
+    func dropUpdated(info _: DropInfo) -> DropProposal? {
+        DropProposal(operation: .move)
+    }
+
+    func performDrop(info _: DropInfo) -> Bool {
+        current = nil
+        return true
+    }
+}

Shared/Favorites/DropFavoriteOutside.swift

@@ -0,0 +1,11 @@
+import Foundation
+import SwiftUI
+
+struct DropFavoriteOutside: DropDelegate {
+    @Binding var current: FavoriteItem?
+
+    func performDrop(info _: DropInfo) -> Bool {
+        current = nil
+        return true
+    }
+}

Shared/Favorites/FavoriteItemView.swift

@@ -0,0 +1,93 @@
+import Defaults
+import Siesta
+import SwiftUI
+import UniformTypeIdentifiers
+
+final class FavoriteResourceObserver: ObservableObject, ResourceObserver {
+    @Published var videos = [Video]()
+
+    func resourceChanged(_ resource: Resource, event _: ResourceEvent) {
+        if let videos: [Video] = resource.typedContent() {
+            self.videos = videos
+        } else if let channel: Channel = resource.typedContent() {
+            videos = channel.videos
+        } else if let playlist: ChannelPlaylist = resource.typedContent() {
+            videos = playlist.videos
+        } else if let playlist: Playlist = resource.typedContent() {
+            videos = playlist.videos
+        }
+    }
+}
+
+struct FavoriteItemView: View {
+    let item: FavoriteItem
+    let resource: Resource?
+
+    @StateObject private var store = FavoriteResourceObserver()
+
+    @Binding private var favorites: [FavoriteItem]
+    @Binding private var dragging: FavoriteItem?
+
+    @EnvironmentObject<PlaylistsModel> private var playlistsModel
+
+    init(
+        item: FavoriteItem,
+        resource: Resource?,
+        favorites: Binding<[FavoriteItem]>,
+        dragging: Binding<FavoriteItem?>
+    ) {
+        self.item = item
+        self.resource = resource
+        _favorites = favorites
+        _dragging = dragging
+    }
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 2) {
+            Text(label)
+                .font(.title3.bold())
+                .foregroundColor(.secondary)
+
+                .contextMenu {
+                    Button {
+                        FavoritesModel.shared.remove(item)
+                    } label: {
+                        Label("Remove from Favorites", systemImage: "trash")
+                    }
+                }
+                .contentShape(Rectangle())
+            #if os(tvOS)
+                .padding(.leading, 40)
+            #else
+                .padding(.leading, 15)
+            #endif
+
+            HorizontalCells(items: store.videos.map { ContentItem(video: $0) })
+        }
+
+        .contentShape(Rectangle())
+        .opacity(dragging?.id == item.id ? 0.5 : 1)
+        .onAppear {
+            resource?.addObserver(store)
+            resource?.loadIfNeeded()
+        }
+        #if !os(tvOS)
+            .onDrag {
+                dragging = item
+                return NSItemProvider(object: item.id as NSString)
+            }
+            .onDrop(
+                of: [UTType.text],
+                delegate: DropFavorite(item: item, favorites: $favorites, current: $dragging)
+            )
+        #endif
+    }
+
+    var label: String {
+        if case let .playlist(id) = item.section {
+            return playlistsModel.find(id: id)?.title ?? "Unknown Playlist"
+        }
+
+        return item.section.label
+    }
+}

Shared/Favorites/FavoritesView.swift

@@ -0,0 +1,91 @@
+import Defaults
+import Siesta
+import SwiftUI
+import UniformTypeIdentifiers
+
+struct FavoritesView: View {
+    @EnvironmentObject<AccountsModel> private var accounts
+    @EnvironmentObject<PlaylistsModel> private var playlists
+
+    @State private var dragging: FavoriteItem?
+    @State private var presentingEditFavorites = false
+
+    @Default(.favorites) private var favorites
+
+    var body: some View {
+        PlayerControlsView {
+            ScrollView(.vertical, showsIndicators: false) {
+                if !accounts.current.isNil {
+                    VStack(alignment: .leading, spacing: 0) {
+                        ForEach(favorites) { item in
+                            VStack {
+                                if let resource = resource(item) {
+                                    FavoriteItemView(item: item, resource: resource, favorites: $favorites, dragging: $dragging)
+                                }
+                            }
+                        }
+                    }
+
+                    #if os(tvOS)
+                        Button {
+                            presentingEditFavorites = true
+                        } label: {
+                            Text("Edit Favorites...")
+                        }
+                    #endif
+                }
+            }
+            #if os(tvOS)
+                .sheet(isPresented: $presentingEditFavorites) {
+                    EditFavorites()
+                }
+                .edgesIgnoringSafeArea(.horizontal)
+            #else
+                .onDrop(of: [UTType.text], delegate: DropFavoriteOutside(current: $dragging))
+                .navigationTitle("Favorites")
+            #endif
+            #if os(macOS)
+                .background()
+                .frame(minWidth: 360)
+            #endif
+        }
+    }
+
+    func resource(_ item: FavoriteItem) -> Resource? {
+        switch item.section {
+        case .subscriptions:
+            if accounts.app.supportsSubscriptions {
+                return accounts.api.feed
+            }
+
+        case .popular:
+            if accounts.app.supportsPopular {
+                return accounts.api.popular
+            }
+
+        case let .trending(country, category):
+            let trendingCountry = Country(rawValue: country)!
+            let trendingCategory = category.isNil ? nil : TrendingCategory(rawValue: category!)!
+
+            return accounts.api.trending(country: trendingCountry, category: trendingCategory)
+
+        case let .channel(id, _):
+            return accounts.api.channelVideos(id)
+
+        case let .channelPlaylist(id, _):
+            return accounts.api.channelPlaylist(id)
+
+        case let .playlist(id):
+            return accounts.api.playlist(id)
+        }
+
+        return nil
+    }
+}
+
+struct Favorites_Previews: PreviewProvider {
+    static var previews: some View {
+        FavoritesView()
+            .injectFixtureEnvironmentObjects()
+    }
+}