feat: key reordering

Author: ykisana

Normal/Models/Key.swift

@@ -13,14 +13,15 @@ final class Key: Identifiable {
     var longitude: Double?
     var radiusMeters: Double?
     var radiusKind: LocationRadiusKind?
+    var sortIndex: Int = 0
     private(set) var hashedValue: String
     private(set) var salt: String
 
     private static let pbkdf2Rounds: UInt32 = 100_000
     private static let saltLength = 16
     private static let hashLength = 32
 
-    init(name: String, type: KeyType, rawValue: String, scanKind: ScanCodeKind? = nil) {
+    init(name: String, type: KeyType, rawValue: String, scanKind: ScanCodeKind? = nil, sortIndex: Int = 0) {
         id = UUID()
         self.name = name
         self.type = type
@@ -29,12 +30,20 @@ final class Key: Identifiable {
         longitude = nil
         radiusMeters = nil
         radiusKind = nil
+        self.sortIndex = sortIndex
         let salt = Self.generateSalt()
         self.salt = salt
         hashedValue = Self.hash(unhashedString: rawValue, salt: salt)
     }
 
-    init(name: String, latitude: Double, longitude: Double, radiusMeters: Double, radiusKind: LocationRadiusKind) {
+    init(
+        name: String,
+        latitude: Double,
+        longitude: Double,
+        radiusMeters: Double,
+        radiusKind: LocationRadiusKind,
+        sortIndex: Int = 0
+    ) {
         id = UUID()
         self.name = name
         type = .location
@@ -43,6 +52,7 @@ final class Key: Identifiable {
         self.longitude = longitude
         self.radiusMeters = radiusMeters
         self.radiusKind = radiusKind
+        self.sortIndex = sortIndex
         salt = ""
         hashedValue = ""
     }
@@ -69,7 +79,6 @@ final class Key: Identifiable {
         return Self.hash(unhashedString: unhashedId, salt: salt) == hashedValue
     }
 
-    /// Whether `location` falls inside this key's saved radius.
     func matches(location: CLLocation) -> Bool {
         guard type == .location, let latitude, let longitude, let radiusMeters else { return false }
         let target = CLLocation(latitude: latitude, longitude: longitude)
@@ -80,13 +89,10 @@ final class Key: Identifiable {
         keys.filter { $0.type == .location }
     }
 
-    /// All location keys share a single kind; this returns it (or `nil` if none exist).
     static func existingLocationKind(in keys: [Key]) -> LocationRadiusKind? {
         locationKeys(in: keys).first?.radiusKind
     }
 
-    /// Verifies the location keys against the user's current position.
-    /// Unblock radii pass when inside any zone; block radii pass when outside every zone.
     static func locationKeyVerifies(keys: [Key], location: CLLocation) -> Bool {
         let locKeys = locationKeys(in: keys)
         guard let kind = locKeys.first?.radiusKind else { return false }

Normal/Views/Key/KeyFormSheet.swift

@@ -213,18 +213,26 @@ struct KeyFormSheet: View {
         if let existing {
             existing.name = trimmed
         } else {
+            let nextIndex = SortIndexing.nextIndex(after: keys, sortIndex: \.sortIndex)
             switch keyType {
             case .nfc, .qr:
                 guard let rawValue = scannedKeyId else { return }
-                modelContext.insert(Key(name: trimmed, type: keyType, rawValue: rawValue, scanKind: scannedKind))
+                modelContext.insert(Key(
+                    name: trimmed,
+                    type: keyType,
+                    rawValue: rawValue,
+                    scanKind: scannedKind,
+                    sortIndex: nextIndex
+                ))
             case .location:
                 guard let captured = capturedLocation else { return }
                 modelContext.insert(Key(
                     name: trimmed,
                     latitude: captured.latitude,
                     longitude: captured.longitude,
                     radiusMeters: captured.radiusMeters,
-                    radiusKind: captured.kind
+                    radiusKind: captured.kind,
+                    sortIndex: nextIndex
                 ))
             }
         }

Normal/Views/Key/KeysView.swift

@@ -4,7 +4,8 @@ import SwiftUI
 struct KeysView: View {
     @Environment(ScreenTimeService.self) private var screenTimeService
 
-    @Query private var keys: [Key]
+    @Query(sort: [SortDescriptor(\Key.sortIndex)])
+    private var keys: [Key]
     @State private var isShowingSheet = false
 
     private var isBlocked: Bool {
@@ -36,14 +37,18 @@ struct KeysView: View {
         if keys.isEmpty {
             KeysEmptyStateView { isShowingSheet = true }
         } else {
-            ListView(items: keys) { key in
+            ReorderableListView(items: keys, rowContent: { key in
                 KeyListCardView(key: key)
-            }
-            .safeAreaInset(edge: .bottom) {
-                if isBlocked {
-                    FooterMessage(text: "Unblock all apps to edit or delete keys.")
+            }, onMove: move)
+                .safeAreaInset(edge: .bottom) {
+                    if isBlocked {
+                        FooterMessage(text: "Unblock all apps to edit or delete keys.")
+                    }
                 }
-            }
         }
     }
+
+    private func move(from source: IndexSet, to destination: Int) {
+        _ = SortIndexing.reorder(keys, from: source, to: destination, sortIndex: \.sortIndex)
+    }
 }

NormalTests/Models/KeyMigrationTests.swift

@@ -72,6 +72,25 @@ struct KeyMigrationTests {
         #expect(key.displayTypeLabel == "Barcode")
     }
 
+    @Test func sortIndexDefaultsAndPersistsAcrossReopen() throws {
+        let url = storeURL()
+        defer { removeStore(at: url) }
+
+        do {
+            let container = try makeContainer(at: url)
+            container.mainContext.insert(Key(name: "Legacy", type: .qr, rawValue: "a"))
+            container.mainContext.insert(Key(name: "Ordered", type: .nfc, rawValue: "b", sortIndex: 5))
+            try container.mainContext.save()
+        }
+
+        let reopened = try makeContainer(at: url)
+        let byName = try reopened.mainContext.fetch(FetchDescriptor<Key>())
+            .reduce(into: [String: Key]()) { $0[$1.name] = $1 }
+
+        #expect(byName["Legacy"]?.sortIndex == 0)
+        #expect(byName["Ordered"]?.sortIndex == 5)
+    }
+
     @Test func mixedLegacyAndNewKeysCoexistAfterReopen() throws {
         let url = storeURL()
         defer { removeStore(at: url) }