Rename Favorites to Home

Fix #329

Shared/Home/DropFavorite.swift

@@ -0,0 +1,43 @@
+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
+        }
+
+        guard let current else {
+            return
+        }
+
+        let from = favorites.firstIndex(of: current)
+        let to = favorites.firstIndex(of: item)
+
+        guard let from, let to else {
+            return
+        }
+
+        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/Home/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/Home/FavoriteItemView.swift

@@ -0,0 +1,137 @@
+import Defaults
+import Siesta
+import SwiftUI
+import UniformTypeIdentifiers
+
+struct FavoriteItemView: View {
+    let item: FavoriteItem
+
+    @StateObject private var store = FavoriteResourceObserver()
+
+    @Default(.favorites) private var favorites
+    @Binding private var dragging: FavoriteItem?
+
+    @EnvironmentObject<AccountsModel> private var accounts
+    @EnvironmentObject<PlaylistsModel> private var playlists
+
+    private var favoritesModel = FavoritesModel.shared
+
+    init(
+        item: FavoriteItem,
+        dragging: Binding<FavoriteItem?>
+    ) {
+        self.item = item
+        _dragging = dragging
+    }
+
+    var body: some View {
+        Group {
+            if isVisible {
+                VStack(alignment: .leading, spacing: 2) {
+                    Text(label)
+                        .font(.title3.bold())
+                        .foregroundColor(.secondary)
+                        .contextMenu {
+                            Button {
+                                favoritesModel.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.contentItems)
+                }
+
+                .contentShape(Rectangle())
+                #if os(macOS)
+                    .opacity(dragging?.id == item.id ? 0.5 : 1)
+                #endif
+                    .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
+            }
+        }
+        .onChange(of: accounts.current) { _ in
+            resource?.addObserver(store)
+            resource?.load()
+        }
+    }
+
+    private var isVisible: Bool {
+        switch item.section {
+        case .subscriptions:
+            return accounts.app.supportsSubscriptions && accounts.signedIn
+        case .popular:
+            return accounts.app.supportsPopular
+        default:
+            return true
+        }
+    }
+
+    private var resource: 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)
+
+        case let .searchQuery(text, date, duration, order):
+            return accounts.api.search(
+                .init(
+                    query: text,
+                    sortBy: SearchQuery.SortOrder(rawValue: order) ?? .uploadDate,
+                    date: SearchQuery.Date(rawValue: date),
+                    duration: SearchQuery.Duration(rawValue: duration)
+                ),
+                page: nil
+            )
+        }
+
+        return nil
+    }
+
+    private var label: String {
+        if case let .playlist(id) = item.section {
+            return playlists.find(id: id)?.title ?? "Playlist"
+        }
+
+        return item.section.label
+    }
+}

Shared/Home/FavoriteResourceObserver.swift

@@ -0,0 +1,22 @@
+import Foundation
+import Siesta
+
+final class FavoriteResourceObserver: ObservableObject, ResourceObserver {
+    @Published var contentItems = [ContentItem]()
+
+    func resourceChanged(_ resource: Resource, event _: ResourceEvent) {
+        if let videos: [Video] = resource.typedContent() {
+            contentItems = videos.map { ContentItem(video: $0) }
+        } else if let channel: Channel = resource.typedContent() {
+            contentItems = channel.videos.map { ContentItem(video: $0) }
+        } else if let playlist: ChannelPlaylist = resource.typedContent() {
+            contentItems = playlist.videos.map { ContentItem(video: $0) }
+        } else if let playlist: Playlist = resource.typedContent() {
+            contentItems = playlist.videos.map { ContentItem(video: $0) }
+        } else if let page: SearchPage = resource.typedContent() {
+            contentItems = page.results
+        } else if let items: [ContentItem] = resource.typedContent() {
+            contentItems = items
+        }
+    }
+}

Shared/Home/HistoryView.swift

@@ -0,0 +1,42 @@
+import SwiftUI
+
+struct HistoryView: View {
+    @FetchRequest(sortDescriptors: [.init(key: "watchedAt", ascending: false)])
+    var watches: FetchedResults<Watch>
+
+    @EnvironmentObject<PlayerModel> private var player
+
+    var limit = 10
+
+    var body: some View {
+        LazyVStack {
+            ForEach(visibleWatches, id: \.videoID) { watch in
+                PlayerQueueRow(
+                    item: PlayerQueueItem.from(watch, video: player.historyVideo(watch.videoID)),
+                    history: true
+                )
+                .onAppear {
+                    player.loadHistoryVideoDetails(watch.videoID)
+                }
+                .contextMenu {
+                    VideoContextMenuView(video: watch.video)
+                }
+            }
+            #if os(tvOS)
+            .padding(.horizontal, 40)
+            #else
+            .padding(.horizontal, 15)
+            #endif
+        }
+    }
+
+    private var visibleWatches: [Watch] {
+        Array(watches.filter { $0.videoID != player.currentVideo?.videoID }.prefix(limit))
+    }
+}
+
+struct HistoryView_Previews: PreviewProvider {
+    static var previews: some View {
+        HistoryView()
+    }
+}

Shared/Home/HomeView.swift

@@ -0,0 +1,119 @@
+import Defaults
+import Siesta
+import SwiftUI
+import UniformTypeIdentifiers
+
+struct HomeView: View {
+    @EnvironmentObject<AccountsModel> private var accounts
+    @EnvironmentObject<PlaylistsModel> private var playlists
+
+    @State private var dragging: FavoriteItem?
+    @State private var presentingEditFavorites = false
+
+    @State private var favoritesChanged = false
+
+    var favoritesObserver: Any?
+
+    #if !os(tvOS)
+        @Default(.favorites) private var favorites
+    #endif
+
+    private var navigation: NavigationModel { .shared }
+
+    var body: some View {
+        BrowserPlayerControls {
+            ScrollView(.vertical, showsIndicators: false) {
+                if !accounts.current.isNil {
+                    #if os(tvOS)
+                        ForEach(Defaults[.favorites]) { item in
+                            FavoriteItemView(item: item, dragging: $dragging)
+                        }
+                    #else
+                        #if os(iOS)
+                            let first = favorites.first
+                        #endif
+                        ForEach(favorites) { item in
+                            FavoriteItemView(item: item, dragging: $dragging)
+                            #if os(macOS)
+                                .workaroundForVerticalScrollingBug()
+                            #endif
+                            #if os(iOS)
+                            .padding(.top, item == first && RefreshControl.navigationBarTitleDisplayMode == .inline ? 10 : 0)
+                            #endif
+                        }
+                    #endif
+                }
+
+                VStack {
+                    Text("History")
+
+                    #if os(tvOS)
+                        .padding(.horizontal, 40)
+                    #else
+                        .padding(.horizontal, 15)
+                    #endif
+                        .font(.title3.bold())
+                        .frame(maxWidth: .infinity, alignment: .leading)
+                        .foregroundColor(.secondary)
+
+                    HistoryView(limit: 100)
+                }
+
+                #if os(tvOS)
+                    HStack {
+                        Button {
+                            navigation.presentingOpenVideos = true
+                        } label: {
+                            Label("Open Videos...", systemImage: "folder")
+                                .padding(.horizontal, 20)
+                                .padding(.vertical, 10)
+                        }
+                        .buttonStyle(.plain)
+                    }
+                #else
+                    Color.clear.padding(.bottom, 60)
+                #endif
+            }
+            .onAppear {
+                Defaults.observe(.favorites) { _ in
+                    favoritesChanged.toggle()
+                }
+                .tieToLifetime(of: accounts)
+            }
+
+            .redrawOn(change: favoritesChanged)
+
+            #if os(tvOS)
+                .edgesIgnoringSafeArea(.horizontal)
+            #else
+                .onDrop(of: [UTType.text], delegate: DropFavoriteOutside(current: $dragging))
+                .navigationTitle("Home")
+            #endif
+            #if os(macOS)
+            .background(Color.secondaryBackground)
+            .frame(minWidth: 360)
+            #endif
+            #if os(iOS)
+            .navigationBarTitleDisplayMode(RefreshControl.navigationBarTitleDisplayMode)
+            #endif
+            #if !os(macOS)
+            .onReceive(NotificationCenter.default.publisher(for: UIApplication.willEnterForegroundNotification)) { _ in
+                favoritesChanged.toggle()
+            }
+            #endif
+        }
+    }
+}
+
+struct Favorites_Previews: PreviewProvider {
+    static var previews: some View {
+        TabView {
+            HomeView()
+//                .overlay(VideoPlayerView().injectFixtureEnvironmentObjects())
+                .injectFixtureEnvironmentObjects()
+                .tabItem {
+                    Label("Home", systemImage: "house")
+                }
+        }
+    }
+}