Minor fixes, split files into folders

Shared/Playlists/CoverSectionRowView.swift

@@ -0,0 +1,20 @@
+import SwiftUI
+
+struct CoverSectionRowView<ControlContent: View>: View {
+    let label: String?
+    let controlView: ControlContent
+
+    init(_ label: String? = nil, @ViewBuilder controlView: @escaping () -> ControlContent) {
+        self.label = label
+        self.controlView = controlView()
+    }
+
+    var body: some View {
+        HStack {
+            Text(label ?? "")
+
+            Spacer()
+            controlView
+        }
+    }
+}

Shared/Playlists/CoverSectionView.swift

@@ -0,0 +1,52 @@
+import SwiftUI
+
+struct CoverSectionView<Content: View>: View {
+    let title: String?
+
+    let actionsView: Content
+    let divider: Bool
+    let inline: Bool
+
+    init(_ title: String? = nil, divider: Bool = true, inline: Bool = false, @ViewBuilder actionsView: @escaping () -> Content) {
+        self.title = title
+        self.divider = divider
+        self.inline = inline
+        self.actionsView = actionsView()
+    }
+
+    var body: some View {
+        VStack(alignment: .leading) {
+            if inline {
+                HStack {
+                    if title != nil {
+                        sectionTitle
+                    }
+
+                    Spacer()
+                    actionsView
+                }
+            } else if title != nil {
+                sectionTitle
+            }
+
+            if !inline {
+                actionsView
+            }
+        }
+
+        if divider {
+            Divider()
+                .padding(.vertical)
+        }
+    }
+
+    var sectionTitle: some View {
+        Text(title ?? "")
+
+            .font(.title2)
+        #if os(macOS)
+            .bold()
+        #endif
+        .padding(.bottom)
+    }
+}

Shared/Playlists/PlaylistFormView.swift

@@ -0,0 +1,200 @@
+import Siesta
+import SwiftUI
+
+struct PlaylistFormView: View {
+    @State private var name = ""
+    @State private var visibility = Playlist.Visibility.public
+
+    @State private var valid = false
+    @State private var showingDeleteConfirmation = false
+
+    @FocusState private var focused: Bool
+
+    @Binding var playlist: Playlist!
+
+    @Environment(\.dismiss) private var dismiss
+
+    var editing: Bool {
+        playlist != nil
+    }
+
+    var body: some View {
+        #if os(macOS) || os(iOS)
+            VStack(alignment: .leading) {
+                HStack(alignment: .center) {
+                    Text(editing ? "Edit Playlist" : "Create Playlist")
+                        .font(.title2.bold())
+
+                    Spacer()
+
+                    Button("Cancel") {
+                        dismiss()
+                    }.keyboardShortcut(.cancelAction)
+                }
+                Form {
+                    TextField("Name", text: $name, onCommit: validate)
+                        .frame(maxWidth: 450)
+                        .padding(.leading, 10)
+                        .focused($focused)
+
+                    Picker("Visibility", selection: $visibility) {
+                        ForEach(Playlist.Visibility.allCases, id: \.self) { visibility in
+                            Text(visibility.name)
+                        }
+                    }
+                    .pickerStyle(SegmentedPickerStyle())
+                }
+                Divider()
+                    .padding(.vertical, 4)
+                HStack {
+                    if editing {
+                        deletePlaylistButton
+                    }
+
+                    Spacer()
+
+                    Button("Save", action: submitForm)
+                        .disabled(!valid)
+                        .keyboardShortcut(.defaultAction)
+                }
+            }
+            .onChange(of: name) { _ in validate() }
+            .onAppear(perform: initializeForm)
+            .padding(.horizontal)
+            #if !os(iOS)
+                .frame(width: 400, height: 150)
+            #endif
+
+        #else
+            HStack {
+                Spacer()
+
+                VStack {
+                    Spacer()
+
+                    CoverSectionView(editing ? "Edit Playlist" : "Create Playlist") {
+                        CoverSectionRowView("Name") {
+                            TextField("Playlist Name", text: $name, onCommit: validate)
+                                .frame(maxWidth: 450)
+                        }
+
+                        CoverSectionRowView("Visibility") { visibilityButton }
+                    }
+
+                    CoverSectionRowView {
+                        Button("Save", action: submitForm).disabled(!valid)
+                    }
+
+                    if editing {
+                        CoverSectionView("Delete Playlist", divider: false, inline: true) { deletePlaylistButton }
+                            .padding(.top, 50)
+                    }
+
+                    Spacer()
+                }
+                .frame(maxWidth: 800)
+
+                Spacer()
+            }
+            .background(.thinMaterial)
+            .onAppear {
+                guard editing else {
+                    return
+                }
+
+                self.name = self.playlist.title
+                self.visibility = self.playlist.visibility
+
+                validate()
+            }
+        #endif
+    }
+
+    func initializeForm() {
+        focused = true
+        
+        guard editing else {
+            return
+        }
+
+        name = playlist.title
+        visibility = playlist.visibility
+
+        validate()
+    }
+
+    func validate() {
+        valid = !name.isEmpty
+    }
+
+    func submitForm() {
+        guard valid else {
+            return
+        }
+
+        let body = ["title": name, "privacy": visibility.rawValue]
+
+        resource.request(editing ? .patch : .post, json: body).onSuccess { response in
+            if let modifiedPlaylist: Playlist = response.typedContent() {
+                playlist = modifiedPlaylist
+            }
+
+            dismiss()
+        }
+    }
+
+    var resource: Resource {
+        editing ? InvidiousAPI.shared.playlist(playlist.id) : InvidiousAPI.shared.playlists
+    }
+
+    var visibilityButton: some View {
+        #if os(macOS)
+            Picker("Visibility", selection: $visibility) {
+                ForEach(Playlist.Visibility.allCases) { visibility in
+                    Text(visibility.name)
+                }
+            }
+        #else
+            Button(self.visibility.name) {
+                self.visibility = self.visibility.next()
+            }
+            .contextMenu {
+                ForEach(Playlist.Visibility.allCases) { visibility in
+                    Button(visibility.name) {
+                        self.visibility = visibility
+                    }
+                }
+            }
+        #endif
+    }
+
+    var deletePlaylistButton: some View {
+        Button("Delete", role: .destructive) {
+            showingDeleteConfirmation = true
+        }.alert(isPresented: $showingDeleteConfirmation) {
+            Alert(
+                title: Text("Are you sure you want to delete playlist?"),
+                message: Text("Playlist \"\(playlist.title)\" will be deleted.\nIt cannot be undone."),
+                primaryButton: .destructive(Text("Delete"), action: deletePlaylistAndDismiss),
+                secondaryButton: .cancel()
+            )
+        }
+        #if os(macOS)
+            .foregroundColor(.red)
+        #endif
+    }
+
+    func deletePlaylistAndDismiss() {
+        let resource = InvidiousAPI.shared.playlist(playlist.id)
+        resource.request(.delete).onSuccess { _ in
+            playlist = nil
+            dismiss()
+        }
+    }
+}
+
+struct PlaylistFormView_Previews: PreviewProvider {
+    static var previews: some View {
+        PlaylistFormView(playlist: .constant(Playlist.fixture))
+    }
+}

Shared/Playlists/PlaylistsView.swift

@@ -0,0 +1,238 @@
+import Defaults
+import Siesta
+import SwiftUI
+
+struct PlaylistsView: View {
+    @ObservedObject private var store = Store<[Playlist]>()
+
+    @Default(.selectedPlaylistID) private var selectedPlaylistID
+
+    @State private var showingNewPlaylist = false
+    @State private var createdPlaylist: Playlist?
+
+    @State private var showingEditPlaylist = false
+    @State private var editedPlaylist: Playlist?
+
+    var resource: Resource {
+        InvidiousAPI.shared.playlists
+    }
+
+    init() {
+        resource.addObserver(store)
+    }
+
+    var videos: [Video] {
+        currentPlaylist?.videos ?? []
+    }
+
+    var videosViewMaxHeight: CGFloat {
+        #if os(tvOS)
+            videos.isEmpty ? 150 : .infinity
+        #else
+            videos.isEmpty ? 0 : .infinity
+        #endif
+    }
+
+    var body: some View {
+        VStack {
+            #if os(tvOS)
+                toolbar
+                    .font(.system(size: 28))
+
+            #endif
+            if currentPlaylist != nil, videos.isEmpty {
+                hintText("Playlist is empty\n\nTap and hold on a video and then tap \"Add to Playlist\"")
+            } else if store.collection.isEmpty {
+                hintText("You have no playlists\n\nTap on \"New Playlist\" to create one")
+            } else {
+                VideosView(videos: videos)
+            }
+
+            #if os(iOS)
+                toolbar
+                    .font(.system(size: 14))
+                    .padding(.horizontal)
+                    .padding(.vertical, 10)
+                    .overlay(Divider().offset(x: 0, y: -2), alignment: .topTrailing)
+                    .transaction { t in t.animation = .none }
+            #endif
+        }
+        #if os(tvOS)
+            .fullScreenCover(isPresented: $showingNewPlaylist, onDismiss: selectCreatedPlaylist) {
+                PlaylistFormView(playlist: $createdPlaylist)
+            }
+            .fullScreenCover(isPresented: $showingEditPlaylist, onDismiss: selectEditedPlaylist) {
+                PlaylistFormView(playlist: $editedPlaylist)
+            }
+        #else
+            .sheet(isPresented: $showingNewPlaylist, onDismiss: selectCreatedPlaylist) {
+                PlaylistFormView(playlist: $createdPlaylist)
+            }
+            .sheet(isPresented: $showingEditPlaylist, onDismiss: selectEditedPlaylist) {
+                PlaylistFormView(playlist: $editedPlaylist)
+            }
+        #endif
+        .toolbar {
+            ToolbarItemGroup {
+                #if !os(iOS)
+                    if !store.collection.isEmpty {
+                        selectPlaylistButton
+                    }
+
+                    if currentPlaylist != nil {
+                        editPlaylistButton
+                    }
+                #endif
+                newPlaylistButton
+            }
+        }
+        .onAppear {
+            resource.loadIfNeeded()?.onSuccess { _ in
+                selectPlaylist(selectedPlaylistID)
+            }
+        }
+        #if !os(tvOS)
+            .navigationTitle("Playlists")
+        #elseif os(iOS)
+            .navigationBarItems(trailing: newPlaylistButton)
+        #endif
+    }
+
+    var scaledToolbar: some View {
+        toolbar.scaleEffect(0.85)
+    }
+
+    var toolbar: some View {
+        HStack {
+            if store.collection.isEmpty {
+                Text("No Playlists")
+                    .foregroundColor(.secondary)
+            } else {
+                Text("Current Playlist")
+                    .foregroundColor(.secondary)
+
+                selectPlaylistButton
+            }
+
+            #if os(iOS)
+                Spacer()
+            #endif
+
+            if currentPlaylist != nil {
+                editPlaylistButton
+            }
+
+            #if !os(iOS)
+                newPlaylistButton
+                    .padding(.leading, 40)
+            #endif
+        }
+    }
+
+    func hintText(_ text: String) -> some View {
+        VStack {
+            Spacer()
+            Text(text)
+                .foregroundColor(.secondary)
+                .multilineTextAlignment(.center)
+            Spacer()
+        }
+        .frame(minWidth: 0, maxWidth: .infinity, minHeight: 0, maxHeight: .infinity)
+        #if os(macOS)
+            .background()
+        #endif
+    }
+
+    func selectPlaylist(_ id: String?) {
+        selectedPlaylistID = id
+    }
+
+    func selectCreatedPlaylist() {
+        guard createdPlaylist != nil else {
+            return
+        }
+
+        resource.load().onSuccess { _ in
+            self.selectPlaylist(createdPlaylist?.id)
+
+            self.createdPlaylist = nil
+        }
+    }
+
+    func selectEditedPlaylist() {
+        if editedPlaylist == nil {
+            selectPlaylist(nil)
+        }
+
+        resource.load().onSuccess { _ in
+            selectPlaylist(editedPlaylist?.id)
+
+            self.editedPlaylist = nil
+        }
+    }
+
+    var currentPlaylist: Playlist? {
+        store.collection.first { $0.id == selectedPlaylistID } ?? store.collection.first
+    }
+
+    var selectPlaylistButton: some View {
+        #if os(tvOS)
+            Button(currentPlaylist?.title ?? "Select playlist") {
+                guard currentPlaylist != nil else {
+                    return
+                }
+
+                selectPlaylist(store.collection.next(after: currentPlaylist!)?.id)
+            }
+            .contextMenu {
+                ForEach(store.collection) { playlist in
+                    Button(playlist.title) {
+                        selectPlaylist(playlist.id)
+                    }
+                }
+            }
+        #else
+            Menu(currentPlaylist?.title ?? "Select playlist") {
+                ForEach(store.collection) { playlist in
+                    Button(action: { selectPlaylist(playlist.id) }) {
+                        if playlist == self.currentPlaylist {
+                            Label(playlist.title, systemImage: "checkmark")
+                        } else {
+                            Text(playlist.title)
+                        }
+                    }
+                }
+            }
+        #endif
+    }
+
+    var editPlaylistButton: some View {
+        Button(action: {
+            self.editedPlaylist = self.currentPlaylist
+            self.showingEditPlaylist = true
+        }) {
+            HStack(spacing: 8) {
+                Image(systemName: "slider.horizontal.3")
+                Text("Edit")
+            }
+        }
+    }
+
+    var newPlaylistButton: some View {
+        Button(action: { self.showingNewPlaylist = true }) {
+            HStack(spacing: 8) {
+                Image(systemName: "plus")
+                #if os(tvOS)
+                    Text("New Playlist")
+                #endif
+            }
+        }
+    }
+}
+
+struct PlaylistsView_Provider: PreviewProvider {
+    static var previews: some View {
+        PlaylistsView()
+            .environmentObject(NavigationState())
+    }
+}