Skip to content

Open source CapCut alternative.

TypeScript

feat(ios): note folders nest, with drag and drop

David Le0aa9a1cabe3d
diff --git a/apps/ios/Donkey/Controllers/CutCloudClient.swift b/apps/ios/Donkey/Controllers/CutCloudClient.swift
index 962f8ed4..240cb95b 100644
--- a/apps/ios/Donkey/Controllers/CutCloudClient.swift
+++ b/apps/ios/Donkey/Controllers/CutCloudClient.swift
@@ -432,6 +432,7 @@ extension CutCloudClient: CloudSyncServicing {
private struct NoteFolderDTO: Decodable {
var id: String
var name: String
+ var parentId: String?
var updatedAt: Double
var createdAt: Double
}
@@ -471,6 +472,7 @@ extension CutCloudClient: CloudSyncServicing {
return RemoteNoteFolder(
id: id,
name: dto.name,
+ parentId: dto.parentId.flatMap(UUID.init(uuidString:)),
updatedAt: Date(timeIntervalSince1970: dto.updatedAt / 1000),
createdAt: Date(timeIntervalSince1970: dto.createdAt / 1000)
)
@@ -508,11 +510,13 @@ extension CutCloudClient: CloudSyncServicing {
}
func putNoteFolder(_ folder: RemoteNoteFolder) async throws {
+ var body: [String: Any] = ["name": folder.name]
+ body["parentId"] = folder.parentId.map { $0.uuidString.lowercased() } ?? NSNull()
_ = try await send(
try request(
"PUT",
"/api/cut-cloud/notes/folders/\(folder.id.uuidString.lowercased())",
- body: ["name": folder.name]
+ body: body
)
)
}
diff --git a/apps/ios/Donkey/Info.plist b/apps/ios/Donkey/Info.plist
index d533d744..5cf2ea68 100644
--- a/apps/ios/Donkey/Info.plist
+++ b/apps/ios/Donkey/Info.plist
@@ -4,6 +4,19 @@
<dict>
<key>GIDClientID</key>
<string>$(GOOGLE_IOS_CLIENT_ID)</string>
+ <key>UTExportedTypeDeclarations</key>
+ <array>
+ <dict>
+ <key>UTTypeIdentifier</key>
+ <string>com.donkeycut.notes-item</string>
+ <key>UTTypeDescription</key>
+ <string>Donkey Cut note or folder</string>
+ <key>UTTypeConformsTo</key>
+ <array>
+ <string>public.data</string>
+ </array>
+ </dict>
+ </array>
<key>CFBundleURLTypes</key>
<array>
<dict>
diff --git a/apps/ios/DonkeyKit/Sources/DonkeyKitModels/CloudSync.swift b/apps/ios/DonkeyKit/Sources/DonkeyKitModels/CloudSync.swift
index 59a2267f..6f248b0b 100644
--- a/apps/ios/DonkeyKit/Sources/DonkeyKitModels/CloudSync.swift
+++ b/apps/ios/DonkeyKit/Sources/DonkeyKitModels/CloudSync.swift
@@ -131,12 +131,15 @@ nonisolated public struct RemoteNote: Equatable, Sendable {
nonisolated public struct RemoteNoteFolder: Equatable, Sendable {
public var id: UUID
public var name: String
+ /// The folder this one is filed in; nil is the top level.
+ public var parentId: UUID?
public var updatedAt: Date
public var createdAt: Date
- public init(id: UUID, name: String, updatedAt: Date, createdAt: Date) {
+ public init(id: UUID, name: String, parentId: UUID? = nil, updatedAt: Date, createdAt: Date) {
self.id = id
self.name = name
+ self.parentId = parentId
self.updatedAt = updatedAt
self.createdAt = createdAt
}
@@ -312,7 +315,7 @@ public protocol CloudSyncServicing: AnyObject {
/// Returns the winning version — this write, or a newer one already there.
func putNote(_ note: RemoteNote) async throws -> RemoteNote
func deleteNote(id: UUID) async throws
- /// Create or rename one folder under the id the phone gave it.
+ /// Create, rename or move one folder under the id the phone gave it.
func putNoteFolder(_ folder: RemoteNoteFolder) async throws
func deleteNoteFolder(id: UUID) async throws
/// Create or rename one label under the id the phone gave it.
diff --git a/apps/ios/DonkeyKit/Sources/DonkeyKitModels/DonkeyStore.swift b/apps/ios/DonkeyKit/Sources/DonkeyKitModels/DonkeyStore.swift
index a0423de8..c5cc739a 100644
--- a/apps/ios/DonkeyKit/Sources/DonkeyKitModels/DonkeyStore.swift
+++ b/apps/ios/DonkeyKit/Sources/DonkeyKitModels/DonkeyStore.swift
@@ -57,6 +57,8 @@ final class NoteRecord {
final class NoteFolderRecord {
@Attribute(.unique) var id: UUID
var name: String
+ /// The folder this one is filed in; nil is the top level.
+ var parentId: UUID?
var createdAt: Date
var updatedAt: Date
var dirty: Bool
@@ -64,13 +66,14 @@ final class NoteFolderRecord {
init(_ folder: NoteFolder, dirty: Bool) {
id = folder.id
name = folder.name
+ parentId = folder.parentId
createdAt = folder.createdAt
updatedAt = folder.updatedAt
self.dirty = dirty
}
var folder: NoteFolder {
- NoteFolder(id: id, name: name, createdAt: createdAt, updatedAt: updatedAt)
+ NoteFolder(id: id, name: name, parentId: parentId, createdAt: createdAt, updatedAt: updatedAt)
}
}
@@ -309,6 +312,7 @@ public final class DonkeyStore: IdeasStoring, RecordingStoring, SyncJournalStori
let descriptor = FetchDescriptor<NoteFolderRecord>(predicate: #Predicate { $0.id == id })
if let existing = try context.fetch(descriptor).first {
existing.name = folder.name
+ existing.parentId = folder.parentId
existing.updatedAt = folder.updatedAt
existing.dirty = true
} else {
@@ -318,12 +322,20 @@ public final class DonkeyStore: IdeasStoring, RecordingStoring, SyncJournalStori
}
public func deleteNoteFolder(id: UUID) throws {
+ let parentId = try noteFolderParent(id)
try context.delete(model: NoteFolderRecord.self, where: #Predicate { $0.id == id })
- // The notes stay; they come back to the top level, and each one is a
- // write of its own so the cloud files them there too.
- let descriptor = FetchDescriptor<NoteRecord>(predicate: #Predicate { $0.folderId == id })
- for record in try context.fetch(descriptor) {
- record.folderId = nil
+ // What the folder held stays and comes up one level. Each note is a
+ // write of its own so the cloud files it there too, and so is each
+ // folder.
+ let notes = FetchDescriptor<NoteRecord>(predicate: #Predicate { $0.folderId == id })
+ for record in try context.fetch(notes) {
+ record.folderId = parentId
+ record.updatedAt = .now
+ record.dirty = true
+ }
+ let folders = FetchDescriptor<NoteFolderRecord>(predicate: #Predicate { $0.parentId == id })
+ for record in try context.fetch(folders) {
+ record.parentId = parentId
record.updatedAt = .now
record.dirty = true
}
@@ -331,6 +343,13 @@ public final class DonkeyStore: IdeasStoring, RecordingStoring, SyncJournalStori
try context.save()
}
+ /// Where a folder is filed, read before it goes so what it held can
+ /// follow.
+ private func noteFolderParent(_ id: UUID) throws -> UUID? {
+ let descriptor = FetchDescriptor<NoteFolderRecord>(predicate: #Predicate { $0.id == id })
+ return try context.fetch(descriptor).first?.parentId
+ }
+
public func loadNoteLabels() throws -> [NoteLabel] {
let descriptor = FetchDescriptor<NoteLabelRecord>(sortBy: [SortDescriptor(\.createdAt)])
return try context.fetch(descriptor).map(\.label)
@@ -497,6 +516,7 @@ public final class DonkeyStore: IdeasStoring, RecordingStoring, SyncJournalStori
if let existing = try context.fetch(descriptor).first {
guard !existing.dirty else { return }
existing.name = folder.name
+ existing.parentId = folder.parentId
existing.updatedAt = folder.updatedAt
} else {
context.insert(NoteFolderRecord(folder, dirty: false))
@@ -520,10 +540,17 @@ public final class DonkeyStore: IdeasStoring, RecordingStoring, SyncJournalStori
}
public func removeNoteFolderFromCloudDelete(id: UUID) throws {
+ // The cloud filed what the folder held one level up; the listing
+ // already carried the folders, and the notes follow here.
+ let parentId = try noteFolderParent(id)
try context.delete(model: NoteFolderRecord.self, where: #Predicate { $0.id == id })
- let descriptor = FetchDescriptor<NoteRecord>(predicate: #Predicate { $0.folderId == id })
- for record in try context.fetch(descriptor) where record.dirty != true {
- record.folderId = nil
+ let notes = FetchDescriptor<NoteRecord>(predicate: #Predicate { $0.folderId == id })
+ for record in try context.fetch(notes) where record.dirty != true {
+ record.folderId = parentId
+ }
+ let folders = FetchDescriptor<NoteFolderRecord>(predicate: #Predicate { $0.parentId == id })
+ for record in try context.fetch(folders) {
+ record.parentId = parentId
}
try context.save()
}
diff --git a/apps/ios/DonkeyKit/Sources/DonkeyKitModels/Ideas.swift b/apps/ios/DonkeyKit/Sources/DonkeyKitModels/Ideas.swift
index be1a661b..14a87308 100644
--- a/apps/ios/DonkeyKit/Sources/DonkeyKitModels/Ideas.swift
+++ b/apps/ios/DonkeyKit/Sources/DonkeyKitModels/Ideas.swift
@@ -33,20 +33,36 @@ nonisolated public enum NoteColor: Int, CaseIterable, Codable, Sendable {
/// A folder notes are filed in. Ids are minted by whichever client makes the
/// folder — the phone here, the desktop in its Notes tab — and the cloud
/// stores the folder under that id, so a folder made offline pushes as itself.
+/// Folders file into folders the way notes do; `parentId` nil is the top level.
nonisolated public struct NoteFolder: Identifiable, Equatable, Hashable, Sendable {
public var id: UUID
public var name: String
+ public var parentId: UUID?
public var createdAt: Date
public var updatedAt: Date
- public init(id: UUID = UUID(), name: String, createdAt: Date = .now, updatedAt: Date = .now) {
+ public init(
+ id: UUID = UUID(),
+ name: String,
+ parentId: UUID? = nil,
+ createdAt: Date = .now,
+ updatedAt: Date = .now
+ ) {
self.id = id
self.name = name
+ self.parentId = parentId
self.createdAt = createdAt
self.updatedAt = updatedAt
}
}
+/// One folder in the tree laid out as a list: the folder and how deep it sits.
+nonisolated public struct NoteFolderTreeRow: Identifiable, Equatable, Sendable {
+ public var folder: NoteFolder
+ public var depth: Int
+ public var id: UUID { folder.id }
+}
+
/// A label notes carry. Like folders, ids are minted by whichever client
/// makes the label, one PUT both creates and renames, and the cloud listing
/// is the truth — a label missing from it was deleted.
@@ -267,8 +283,8 @@ public protocol IdeasStoring: AnyObject {
func deleteNote(id: UUID) throws
func loadNoteFolders() throws -> [NoteFolder]
func upsert(_ folder: NoteFolder) throws
- /// Delete a folder. Its notes come back to the top level rather than
- /// going with it — the same line the cloud draws.
+ /// Delete a folder. What it held — its notes and the folders inside it —
+ /// comes up one level, the same line the cloud draws.
func deleteNoteFolder(id: UUID) throws
func loadNoteLabels() throws -> [NoteLabel]
func upsert(_ label: NoteLabel) throws
@@ -323,10 +339,18 @@ public final class IdeasModel {
reloadFromStore()
}
- /// Re-read what the store holds — how a cloud merge lands on screen.
+ /// Re-read what the store holds — how a cloud merge lands on screen. A
+ /// folder whose parent the store does not hold reads as top level, so
+ /// nothing on screen hangs off a folder nobody can open.
public func reloadFromStore() {
notes = (try? store.loadNotes()) ?? []
- folders = (try? store.loadNoteFolders()) ?? []
+ let loaded = (try? store.loadNoteFolders()) ?? []
+ let known = Set(loaded.map(\.id))
+ folders = loaded.map { folder in
+ var folder = folder
+ if let parent = folder.parentId, !known.contains(parent) { folder.parentId = nil }
+ return folder
+ }
labels = (try? store.loadNoteLabels()) ?? []
inspiration = (try? store.loadInspiration()) ?? []
}
@@ -337,24 +361,84 @@ public final class IdeasModel {
notes.filter { $0.folderId == folderId }
}
+ /// The folders filed in one folder, or at the top level when `parentId`
+ /// is nil.
+ public func folders(in parentId: UUID?) -> [NoteFolder] {
+ folders.filter { $0.parentId == parentId }
+ }
+
public func folder(_ id: UUID?) -> NoteFolder? {
guard let id else { return nil }
return folders.first { $0.id == id }
}
+ /// Whether `folderId` is `ancestorId` or filed somewhere under it.
+ public func folder(_ folderId: UUID?, isWithin ancestorId: UUID) -> Bool {
+ var cur = folderId
+ var steps = 0
+ while let id = cur, steps <= folders.count {
+ if id == ancestorId { return true }
+ cur = folder(id)?.parentId
+ steps += 1
+ }
+ return false
+ }
+
+ /// The folders from the top level down to `folderId`, the open one last.
+ public func trail(to folderId: UUID?) -> [NoteFolder] {
+ var trail: [NoteFolder] = []
+ var cur = folder(folderId)
+ while let here = cur, trail.count <= folders.count {
+ trail.insert(here, at: 0)
+ cur = folder(here.parentId)
+ }
+ return trail
+ }
+
+ /// The whole tree as one list, parents before their children, each row
+ /// saying how deep it sits. A folder named in `excluding` is left out with
+ /// everything under it — the picker for moving a folder never offers the
+ /// folder itself.
+ public func folderTree(excluding: UUID? = nil) -> [NoteFolderTreeRow] {
+ var rows: [NoteFolderTreeRow] = []
+ func walk(_ parentId: UUID?, depth: Int) {
+ guard depth <= folders.count else { return }
+ for folder in folders(in: parentId) where folder.id != excluding {
+ rows.append(NoteFolderTreeRow(folder: folder, depth: depth))
+ walk(folder.id, depth: depth + 1)
+ }
+ }
+ walk(nil, depth: 0)
+ return rows
+ }
+
// MARK: Folders
@discardableResult
- public func addFolder(named name: String) -> NoteFolder? {
+ public func addFolder(named name: String, in parentId: UUID? = nil) -> NoteFolder? {
let trimmed = name.trimmingCharacters(in: .whitespacesAndNewlines)
guard !trimmed.isEmpty else { return nil }
- let folder = NoteFolder(name: trimmed)
+ let folder = NoteFolder(name: trimmed, parentId: folder(parentId)?.id)
try? store.upsert(folder)
folders.append(folder)
onLocalChange?()
return folder
}
+ /// File a folder in a folder, or at the top level. A folder never files
+ /// into itself or into anything under it.
+ public func moveFolder(id: UUID, to parentId: UUID?) {
+ guard var moving = folders.first(where: { $0.id == id }), moving.parentId != parentId else { return }
+ if let parentId {
+ guard folder(parentId) != nil, !folder(parentId, isWithin: id) else { return }
+ }
+ moving.parentId = parentId
+ moving.updatedAt = .now
+ try? store.upsert(moving)
+ if let index = folders.firstIndex(where: { $0.id == id }) { folders[index] = moving }
+ onLocalChange?()
+ }
+
public func renameFolder(id: UUID, to name: String) {
let trimmed = name.trimmingCharacters(in: .whitespacesAndNewlines)
guard !trimmed.isEmpty, var folder = folders.first(where: { $0.id == id }) else { return }
@@ -365,7 +449,7 @@ public final class IdeasModel {
onLocalChange?()
}
- /// Delete a folder. Its notes come back to the top level.
+ /// Delete a folder. What it held comes up one level.
public func deleteFolder(id: UUID) {
try? store.deleteNoteFolder(id: id)
reloadFromStore()
diff --git a/apps/ios/DonkeyKit/Sources/DonkeyKitModels/SyncEngine.swift b/apps/ios/DonkeyKit/Sources/DonkeyKitModels/SyncEngine.swift
index 397d8738..40d71e0e 100644
--- a/apps/ios/DonkeyKit/Sources/DonkeyKitModels/SyncEngine.swift
+++ b/apps/ios/DonkeyKit/Sources/DonkeyKitModels/SyncEngine.swift
@@ -422,13 +422,16 @@ public final class SyncEngine {
private func syncNotes() async {
guard online else { return }
// Folders go up before the notes that name them, so a note filed in a
- // folder made offline never reaches a cloud that has no such folder.
- for folder in (try? journal.dirtyNoteFolders()) ?? [] {
+ // folder made offline never reaches a cloud that has no such folder —
+ // and a folder goes up after the folder it is filed in, for the same
+ // reason.
+ for folder in Self.pushOrder((try? journal.dirtyNoteFolders()) ?? []) {
do {
try await service.putNoteFolder(
RemoteNoteFolder(
id: folder.id,
name: folder.name,
+ parentId: folder.parentId,
updatedAt: folder.updatedAt,
createdAt: folder.createdAt
)
@@ -494,6 +497,28 @@ public final class SyncEngine {
}
}
+ /// The dirty folders with every parent ahead of its children. The cloud
+ /// files a folder whose parent it does not know at the top level, so a
+ /// folder moved into one made after it has to wait for that one to land.
+ nonisolated static func pushOrder(_ folders: [NoteFolder]) -> [NoteFolder] {
+ var waiting = folders
+ var ordered: [NoteFolder] = []
+ while !waiting.isEmpty {
+ let held = Set(waiting.map(\.id))
+ let ready = waiting.filter { folder in
+ guard let parent = folder.parentId else { return true }
+ return !held.contains(parent)
+ }
+ // Only a loop leaves nothing ready; the rest go as they are and
+ // the cloud files them where it can.
+ let batch = ready.isEmpty ? waiting : ready
+ ordered.append(contentsOf: batch)
+ let sent = Set(batch.map(\.id))
+ waiting.removeAll { sent.contains($0.id) }
+ }
+ return ordered
+ }
+
/// Folders carry no tombstone in the cloud, so the listing is the truth:
/// what it holds is applied, and a folder this phone has clean that the
/// listing does not name was deleted on the other side.
@@ -516,6 +541,7 @@ public final class SyncEngine {
NoteFolder(
id: folder.id,
name: folder.name,
+ parentId: folder.parentId,
createdAt: folder.createdAt,
updatedAt: folder.updatedAt
)
diff --git a/apps/ios/DonkeyKit/Sources/DonkeyKitUI/IdeasScreen.swift b/apps/ios/DonkeyKit/Sources/DonkeyKitUI/IdeasScreen.swift
index 5b173861..6e7c3dcd 100644
--- a/apps/ios/DonkeyKit/Sources/DonkeyKitUI/IdeasScreen.swift
+++ b/apps/ios/DonkeyKit/Sources/DonkeyKitUI/IdeasScreen.swift
@@ -2,11 +2,45 @@
import AVFoundation
import AVKit
import Combine
+import CoreTransferable
import Photos
import PhotosUI
import SwiftUI
+import UniformTypeIdentifiers
import DonkeyKitModels
+/// What a drag on the Ideas screen carries: one note or one folder, by id.
+/// Dropped on a folder row it is filed there. The move sheet names its
+/// subject the same way.
+nonisolated struct NotesDragItem: Codable, Identifiable, Transferable {
+ enum Kind: String, Codable {
+ case note, folder
+ }
+
+ var kind: Kind
+ var id: UUID
+
+ static var transferRepresentation: some TransferRepresentation {
+ CodableRepresentation(contentType: .donkeyNotesItem)
+ }
+}
+
+extension UTType {
+ nonisolated static let donkeyNotesItem = UTType(exportedAs: "com.donkeycut.notes-item")
+}
+
+extension IdeasModel {
+ /// File what a drop carried in `folderId`, or at the top level.
+ func file(_ items: [NotesDragItem], in folderId: UUID?) {
+ for item in items {
+ switch item.kind {
+ case .note: move(noteId: item.id, to: folderId)
+ case .folder: moveFolder(id: item.id, to: folderId)
+ }
+ }
+ }
+}
+
struct IdeasScreen: View {
@Bindable var app: AppModel
@Bindable var ideas: IdeasModel
@@ -18,7 +52,7 @@ struct IdeasScreen: View {
@State private var showsPhotoPicker = false
@State private var pickerItems: [PhotosPickerItem] = []
@State private var folderPrompt: FolderPrompt?
- @State private var moving: Note?
+ @State private var moving: NotesDragItem?
/// The inspiration item open full screen. A card is a tile; the media
/// plays in the viewer, the way a Library clip does.
@State private var viewing: InspirationItem?
@@ -66,8 +100,8 @@ struct IdeasScreen: View {
LinkSheet(app: app, ideas: ideas)
.presentationDetents([.medium])
}
- .sheet(item: $moving) { note in
- MoveToFolderSheet(ideas: ideas, note: note)
+ .sheet(item: $moving) { item in
+ MoveToFolderSheet(ideas: ideas, item: item)
}
.fullScreenCover(item: $viewing) { item in
InspirationViewer(item: item, ideas: ideas)
@@ -112,7 +146,7 @@ struct IdeasScreen: View {
Button("New note", systemImage: "note.text") { ideas.openEditor() }
Button("Paste link", systemImage: "link") { showsLinkSheet = true }
Button("Camera roll", systemImage: "photo") { openCameraRoll() }
- Button("New folder", systemImage: "folder.badge.plus") { folderPrompt = .create }
+ Button("New folder", systemImage: "folder.badge.plus") { folderPrompt = .create(in: nil) }
} label: {
Image(systemName: "plus")
.font(.title2.weight(.bold))
@@ -186,10 +220,11 @@ struct IdeasScreen: View {
@ViewBuilder private var notesSection: some View {
FolderList(
- folders: ideas.folders,
- count: { ideas.notes(in: $0).count },
+ ideas: ideas,
+ folders: ideas.folders(in: nil),
onRename: { folderPrompt = .rename($0) },
- onDelete: { ideas.deleteFolder(id: $0.id) }
+ onDelete: { ideas.deleteFolder(id: $0.id) },
+ onMove: { moving = $0 }
)
NotesGrid(notes: loose, ideas: ideas, onMove: { moving = $0 })
}
@@ -249,50 +284,79 @@ func mediaPixelSize(at url: URL, isVideo: Bool) async -> (width: Int, height: In
return (Int(abs(rect.width).rounded()), Int(abs(rect.height).rounded()))
}
-/// One folder's notes, pushed from the Ideas screen.
+/// One folder, pushed from the Ideas screen or from the folder above it. It
+/// works the way the top level does: the folders filed here on a list, the
+/// notes filed here on the grid, and a plus that makes either. Nothing above
+/// this folder shows here; a note or folder leaves through the move sheet.
struct NoteFolderScreen: View {
@Bindable var ideas: IdeasModel
var media: MediaModel
let folder: NoteFolder
- let onMove: (Note) -> Void
+ let onMove: (NotesDragItem) -> Void
+
+ @State private var folderPrompt: FolderPrompt?
private var notes: [Note] { ideas.notes(in: folder.id) }
+ private var subfolders: [NoteFolder] { ideas.folders(in: folder.id) }
var body: some View {
ScrollView {
- if notes.isEmpty {
- EmptyState(
- title: "This folder is empty",
- message: "Notes you move here — or write here — show up in this folder."
+ VStack(alignment: .leading, spacing: 18) {
+ FolderList(
+ ideas: ideas,
+ folders: subfolders,
+ onRename: { folderPrompt = .rename($0) },
+ onDelete: { ideas.deleteFolder(id: $0.id) },
+ onMove: onMove
)
- .padding(.top, 40)
- } else {
- NotesGrid(notes: notes, ideas: ideas, onMove: onMove)
- .padding(.horizontal, 20)
- .padding(.top, 14)
- .padding(.bottom, 24)
+ if notes.isEmpty && subfolders.isEmpty {
+ EmptyState(
+ title: "This folder is empty",
+ message: "Notes you move here — or write here — show up in this folder."
+ )
+ .padding(.top, 20)
+ } else {
+ NotesGrid(notes: notes, ideas: ideas, onMove: onMove)
+ }
}
+ .padding(.horizontal, 20)
+ .padding(.top, 14)
+ .padding(.bottom, 24)
}
.refreshable { await media.sync?.refreshNow() }
.navigationTitle(ideas.folder(folder.id)?.name ?? folder.name)
.navigationBarTitleDisplayMode(.large)
.toolbar {
ToolbarItem(placement: .primaryAction) {
- Button("New note", systemImage: "square.and.pencil") {
- ideas.openEditor(in: folder.id)
+ Menu {
+ Button("New note", systemImage: "square.and.pencil") {
+ ideas.openEditor(in: folder.id)
+ }
+ Button("New folder", systemImage: "folder.badge.plus") {
+ folderPrompt = .create(in: folder.id)
+ }
+ } label: {
+ Image(systemName: "plus")
}
+ .accessibilityLabel("Add")
}
}
+ .folderPrompt($folderPrompt, ideas: ideas)
}
}
/// The Apple-standard folder list: a row per folder with its count, opened by
-/// a tap, renamed or deleted by a swipe or a long press.
+/// a tap, renamed, moved or deleted by a long press. Each row takes a dragged
+/// note or folder and files it inside, and each row is itself draggable.
struct FolderList: View {
+ var ideas: IdeasModel
let folders: [NoteFolder]
- let count: (UUID) -> Int
let onRename: (NoteFolder) -> Void
let onDelete: (NoteFolder) -> Void
+ let onMove: (NotesDragItem) -> Void
+
+ /// The row a drag is held over.
+ @State private var targeted: UUID?
var body: some View {
if !folders.isEmpty {
@@ -306,7 +370,7 @@ struct FolderList: View {
Text(folder.name)
.foregroundStyle(.primary)
Spacer(minLength: 8)
- Text("\(count(folder.id))")
+ Text("\(ideas.notes(in: folder.id).count + ideas.folders(in: folder.id).count)")
.foregroundStyle(.secondary)
.monospacedDigit()
Image(systemName: "chevron.right")
@@ -317,8 +381,17 @@ struct FolderList: View {
.contentShape(.rect)
}
.buttonStyle(.plain)
+ .listRowHighlight(targeted == folder.id)
+ .draggable(NotesDragItem(kind: .folder, id: folder.id))
+ .dropDestination(for: NotesDragItem.self) { items, _ in
+ ideas.file(items, in: folder.id)
+ return true
+ } isTargeted: { targeted = $0 ? folder.id : (targeted == folder.id ? nil : targeted) }
.contextMenu {
Button("Rename", systemImage: "pencil") { onRename(folder) }
+ Button("Move to Folder…", systemImage: "folder") {
+ onMove(NotesDragItem(kind: .folder, id: folder.id))
+ }
Button("Delete", systemImage: "trash", role: .destructive) {
onDelete(folder)
}
@@ -334,10 +407,17 @@ struct FolderList: View {
}
}
+extension View {
+ /// The tint a folder row takes while a drag is held over it.
+ fileprivate func listRowHighlight(_ on: Bool) -> some View {
+ background(on ? Color.accentColor.opacity(0.15) : .clear, in: RoundedRectangle(cornerRadius: 10))
+ }
+}
+
struct NotesGrid: View {
let notes: [Note]
var ideas: IdeasModel
- let onMove: (Note) -> Void
+ let onMove: (NotesDragItem) -> Void
var body: some View {
LazyVGrid(columns: ideaColumns, spacing: 14) {
@@ -348,8 +428,11 @@ struct NotesGrid: View {
NoteCard(note: note, labels: ideas.labels(on: note))
}
.buttonStyle(.plain)
+ .draggable(NotesDragItem(kind: .note, id: note.id))
.contextMenu {
- Button("Move to Folder…", systemImage: "folder") { onMove(note) }
+ Button("Move to Folder…", systemImage: "folder") {
+ onMove(NotesDragItem(kind: .note, id: note.id))
+ }
Button("Delete", systemImage: "trash", role: .destructive) {
ideas.deleteNote(id: note.id)
}
@@ -360,53 +443,67 @@ struct NotesGrid: View {
}
}
-/// Where a note is filed, chosen from the folders that exist — or a new one
-/// named on the spot.
+/// Where a note or a folder is filed, chosen from the tree of folders that
+/// exist — or a new one named on the spot, made beside where the item sits
+/// now. A folder being moved is offered nothing under itself.
struct MoveToFolderSheet: View {
var ideas: IdeasModel
- let note: Note
+ let item: NotesDragItem
@State private var prompt: FolderPrompt?
@Environment(\.dismiss) private var dismiss
+ /// Where the item is filed now.
+ private var currentParent: UUID? {
+ switch item.kind {
+ case .note: ideas.notes.first { $0.id == item.id }?.folderId
+ case .folder: ideas.folder(item.id)?.parentId
+ }
+ }
+
+ private var rows: [NoteFolderTreeRow] {
+ ideas.folderTree(excluding: item.kind == .folder ? item.id : nil)
+ }
+
var body: some View {
NavigationStack {
List {
Section {
- row(name: "Notes", systemImage: "note.text", folderId: nil)
- ForEach(ideas.folders) { folder in
- row(name: folder.name, systemImage: "folder", folderId: folder.id)
+ row(name: "Notes", systemImage: "note.text", folderId: nil, depth: 0)
+ ForEach(rows) { row in
+ self.row(name: row.folder.name, systemImage: "folder", folderId: row.folder.id, depth: row.depth)
}
}
Section {
- Button("New Folder…", systemImage: "folder.badge.plus") { prompt = .create }
+ Button("New Folder…", systemImage: "folder.badge.plus") { prompt = .create(in: currentParent) }
}
}
- .navigationTitle("Move Note")
+ .navigationTitle(item.kind == .note ? "Move Note" : "Move Folder")
.navigationBarTitleDisplayMode(.inline)
.toolbar {
ToolbarItem(placement: .cancellationAction) {
Button("Cancel") { dismiss() }
}
}
- // A folder made here takes the note with it.
+ // A folder made here takes the item with it.
.folderPrompt($prompt, ideas: ideas) { folder in
- ideas.move(noteId: note.id, to: folder.id)
+ ideas.file([item], in: folder.id)
dismiss()
}
}
.presentationDetents([.medium, .large])
}
- private func row(name: String, systemImage: String, folderId: UUID?) -> some View {
+ private func row(name: String, systemImage: String, folderId: UUID?, depth: Int) -> some View {
Button {
- ideas.move(noteId: note.id, to: folderId)
+ ideas.file([item], in: folderId)
dismiss()
} label: {
HStack {
Label(name, systemImage: systemImage)
+ .padding(.leading, CGFloat(depth) * 20)
Spacer()
- if note.folderId == folderId {
+ if currentParent == folderId {
Image(systemName: "checkmark")
.foregroundStyle(.tint)
}
@@ -416,10 +513,10 @@ struct MoveToFolderSheet: View {
}
}
-/// Naming a folder: the standard alert with a text field, for a new folder or
-/// a rename.
+/// Naming a folder: the standard alert with a text field, for a new folder
+/// made inside `in` (nil for the top level) or a rename.
enum FolderPrompt: Identifiable {
- case create
+ case create(in: UUID?)
case rename(NoteFolder)
var id: String {
@@ -469,8 +566,8 @@ private struct FolderPromptModifier: ViewModifier {
Button("Cancel", role: .cancel) {}
Button("Save") {
switch prompt {
- case .create:
- if let folder = ideas.addFolder(named: name) { onCreate(folder) }
+ case .create(let parentId):
+ if let folder = ideas.addFolder(named: name, in: parentId) { onCreate(folder) }
case .rename(let folder):
ideas.renameFolder(id: folder.id, to: name)
}
diff --git a/apps/ios/DonkeyKit/Tests/DonkeyKitModelsTests/DonkeyKitModelsTests.swift b/apps/ios/DonkeyKit/Tests/DonkeyKitModelsTests/DonkeyKitModelsTests.swift
index a4e8461e..a2cbaa5c 100644
--- a/apps/ios/DonkeyKit/Tests/DonkeyKitModelsTests/DonkeyKitModelsTests.swift
+++ b/apps/ios/DonkeyKit/Tests/DonkeyKitModelsTests/DonkeyKitModelsTests.swift
@@ -308,16 +308,24 @@ import Testing
notes[id] = nil
}
+ /// The site files a folder whose parent it does not know at the top
+ /// level.
func putNoteFolder(_ folder: RemoteNoteFolder) async throws {
- folders[folder.id] = folder
+ var stored = folder
+ if let parent = folder.parentId, folders[parent] == nil { stored.parentId = nil }
+ folders[folder.id] = stored
}
+ /// What the folder held comes up one level, the way the site files it.
func deleteNoteFolder(id: UUID) async throws {
deletedFolders.append(id)
+ let parent = folders[id]?.parentId
folders[id] = nil
for (noteId, note) in notes where note.folderId == id {
- notes[noteId]?.folderId = nil
- _ = noteId
+ notes[noteId]?.folderId = parent
+ }
+ for (folderId, folder) in folders where folder.parentId == id {
+ folders[folderId]?.parentId = parent
}
}
@@ -677,6 +685,67 @@ import Testing
#expect(try rig.store.tombstones().isEmpty)
}
+ @Test func folderPushesAfterTheFolderItMovedInto() async throws {
+ let rig = try makeRig()
+ let first = try #require(rig.ideas.addFolder(named: "Scripts"))
+ let second = try #require(rig.ideas.addFolder(named: "Series"))
+ // Made first, so it sits first in the push; it has to wait for the
+ // folder it now names, or the cloud files it at the top level.
+ rig.ideas.moveFolder(id: first.id, to: second.id)
+ await rig.engine.run()
+ #expect(rig.cloud.folders[first.id]?.parentId == second.id)
+ #expect(rig.ideas.folders(in: second.id).map(\.id) == [first.id])
+ #expect(rig.ideas.trail(to: first.id).map(\.id) == [second.id, first.id])
+ }
+
+ @Test func aFolderNeverFilesUnderItself() throws {
+ let rig = try makeRig()
+ let parent = try #require(rig.ideas.addFolder(named: "Scripts"))
+ let child = try #require(rig.ideas.addFolder(named: "Drafts", in: parent.id))
+ rig.ideas.moveFolder(id: parent.id, to: child.id)
+ rig.ideas.moveFolder(id: parent.id, to: parent.id)
+ #expect(rig.ideas.folder(parent.id)?.parentId == nil)
+ #expect(rig.ideas.folder(child.id)?.parentId == parent.id)
+ #expect(rig.ideas.folderTree().map(\.depth) == [0, 1])
+ #expect(rig.ideas.folderTree(excluding: parent.id).isEmpty)
+ }
+
+ @Test func deletingAFolderLiftsWhatItHeld() async throws {
+ let rig = try makeRig()
+ let parent = try #require(rig.ideas.addFolder(named: "Scripts"))
+ let child = try #require(rig.ideas.addFolder(named: "Drafts", in: parent.id))
+ let grandchild = try #require(rig.ideas.addFolder(named: "Old", in: child.id))
+ rig.ideas.openEditor(in: child.id)
+ rig.ideas.draft?.body = "filed"
+ let note = try #require(rig.ideas.saveDraft())
+ await rig.engine.run()
+ rig.ideas.deleteFolder(id: child.id)
+ #expect(rig.ideas.folder(grandchild.id)?.parentId == parent.id)
+ #expect(rig.ideas.notes(in: parent.id).map(\.id) == [note.id])
+ await rig.engine.run()
+ #expect(rig.cloud.deletedFolders == [child.id])
+ #expect(rig.cloud.folders[grandchild.id]?.parentId == parent.id)
+ #expect(rig.cloud.notes[note.id]?.folderId == parent.id)
+ }
+
+ @Test func folderDeletedInTheCloudLiftsWhatItHeldHere() async throws {
+ let rig = try makeRig()
+ let parent = try #require(rig.ideas.addFolder(named: "Scripts"))
+ let child = try #require(rig.ideas.addFolder(named: "Drafts", in: parent.id))
+ let grandchild = try #require(rig.ideas.addFolder(named: "Old", in: child.id))
+ rig.ideas.openEditor(in: child.id)
+ rig.ideas.draft?.body = "filed"
+ let note = try #require(rig.ideas.saveDraft())
+ await rig.engine.run()
+ // Deleted at the desk: the listing no longer names it, and what it
+ // held is filed a level up there. The notes keep their stamps.
+ try await rig.cloud.deleteNoteFolder(id: child.id)
+ await rig.engine.run()
+ #expect(rig.ideas.folder(child.id) == nil)
+ #expect(rig.ideas.folder(grandchild.id)?.parentId == parent.id)
+ #expect(rig.ideas.notes(in: parent.id).map(\.id) == [note.id])
+ }
+
@Test func labelPushesAheadOfTheNoteWearingIt() async throws {
let rig = try makeRig()
let label = try #require(rig.ideas.addLabel(named: "Hooks"))