Repository Public
1// SP Notes Core2// File: Sources/SPNotesFeatures/Work/Search/UnifiedSearchModel.swift3// Description: View model of the unified search: local full-text as you type, then (after a testable debounce) the4// server's lexical search merged in — free. Semantic search is an explicit switch and only runs when the5// user submits, because the server makes one paid provider call per search. A failing server never fails6// the search: the local results stay, with a calm note.7//8// Author: Simon-Pierre Boucher9// Contact: contact@spboucher.ai10import Foundation11import Observation12import SPNotesAPI13import SPNotesStore14import SPNotesSync1516@Observable @MainActor17public final class UnifiedSearchModel {18 /// Presets of the "modified since" filter.19 public enum Period: String, Sendable, CaseIterable, Identifiable {20 case any, week, month, year21 public var id: String { rawValue }2223 public var title: String {24 switch self {25 case .any: return L("Toute date")26 case .week: return L("7 derniers jours")27 case .month: return L("30 derniers jours")28 case .year: return L("12 derniers mois")29 }30 }3132 var days: Int? {33 switch self {34 case .any: return nil35 case .week: return 736 case .month: return 3037 case .year: return 36538 }39 }40 }4142 // MARK: state4344 public var query = ""45 public private(set) var results: [UnifiedSearchResult] = []46 public private(set) var phase: LoadPhase = .idle47 public let freshness: Freshness? = nil48 public var actionFailure: FeatureFailure?49 /// The server could not be asked (offline, error): shown calmly, local results stay.50 public private(set) var serverFailure: FeatureFailure?51 /// True when the results on screen include the server's.52 public private(set) var usedServer = false53 public private(set) var isAskingServer = false54 /// The text the results on screen answer.55 public private(set) var answeredQuery = ""56 /// The explicit "search by meaning" switch (paid). Off by default; never searched as you type.57 public var semantic = false58 /// True when the results on screen came from a semantic search.59 public private(set) var answeredSemantic = false6061 public var section: PageSection?62 public var period: Period = .any63 public var favoritesOnly = false64 public var pinnedOnly = false65 public var includeArchived = false66 public var tags: [String] = []6768 private let repo: SearchRepository69 private weak var router: (any FeatureRouter)?70 private let now: @Sendable () -> Date71 private let debounce: Duration72 private let sleep: @Sendable (Duration) async throws -> Void73 private var pending: Task<Void, Never>?74 private var generation = 07576 /// - Parameters:77 /// - debounce: wait after the last keystroke before the server is asked.78 /// - sleep: how the wait is done (injectable for tests).79 public init(repositories: NotesRepositories, router: (any FeatureRouter)? = nil, debounce: Duration = .milliseconds(350),80 sleep: @escaping @Sendable (Duration) async throws -> Void = { try await Task.sleep(for: $0) },81 now: @escaping @Sendable () -> Date = { Date() }) {82 repo = repositories.search83 self.router = router84 self.debounce = debounce85 self.sleep = sleep86 self.now = now87 }8889 public var filters: SearchFilters {90 SearchFilters(section: section?.rawValue, tags: tags, updatedAfter: period.days.map { now().addingTimeInterval(-Double($0) * 86_400) },91 favoritesOnly: favoritesOnly, pinnedOnly: pinnedOnly, includeArchived: includeArchived)92 }9394 public var activeFilterCount: Int {95 (section == nil ? 0 : 1) + (period == .any ? 0 : 1) + (favoritesOnly ? 1 : 0) + (pinnedOnly ? 1 : 0) + (includeArchived ? 1 : 0) + tags.count96 }9798 public var trimmedQuery: String { query.trimmingCharacters(in: .whitespacesAndNewlines) }99100 /// The screen has nothing to load before the user types.101 public func load() async { if phase == .idle { phase = .loaded } }102103 /// Call on every change of the text or of a filter: local results at once, then the free server search after the104 /// debounce. The semantic search is never started from here.105 public func queryChanged() {106 pending?.cancel()107 generation += 1108 let generation = generation109 let text = trimmedQuery110 guard !text.isEmpty else {111 results = []; answeredQuery = ""; usedServer = false; serverFailure = nil; isAskingServer = false; answeredSemantic = false112 phase = .loaded113 return114 }115 pending = Task { [weak self] in116 guard let self else { return }117 await self.runLocal(text, generation: generation)118 do { try await self.sleep(self.debounce) } catch { return }119 guard !Task.isCancelled else { return }120 await self.runServer(text, scope: .serverLexical, generation: generation)121 }122 }123124 /// The user pressed Return / « Rechercher »: searches now; with the semantic switch on, this is the (paid) hybrid search.125 public func submit() async {126 pending?.cancel()127 generation += 1128 let text = trimmedQuery129 guard !text.isEmpty else { return }130 await runLocal(text, generation: generation)131 await runServer(text, scope: semantic ? .hybrid : .serverLexical, generation: generation)132 }133134 /// Waits for the search started by `queryChanged()` (tests).135 public func settle() async { await pending?.value }136137 private func runLocal(_ text: String, generation: Int) async {138 do {139 let local = try await repo.local(text, filters: filters)140 guard generation == self.generation else { return }141 results = local142 answeredQuery = text143 usedServer = false144 answeredSemantic = false145 phase = .loaded146 } catch {147 guard generation == self.generation else { return }148 phase = .failed(FeatureFailure(error))149 }150 }151152 private func runServer(_ text: String, scope: SearchScope, generation: Int) async {153 isAskingServer = true154 defer { if generation == self.generation { isAskingServer = false } }155 do {156 let outcome = try await repo.search(text, scope: scope, filters: filters)157 guard generation == self.generation else { return }158 results = outcome.results159 answeredQuery = text160 usedServer = outcome.usedServer161 answeredSemantic = outcome.usedServer && scope == .hybrid162 serverFailure = outcome.serverError.map { FeatureFailure($0) }163 phase = .loaded164 } catch {165 guard generation == self.generation else { return }166 phase = .failed(FeatureFailure(error))167 }168 }169170 public func open(_ result: UnifiedSearchResult) {171 router?.openPage(id: result.pageId, blockId: result.blockId)172 }173174 public func clearFilters() {175 section = nil; period = .any; favoritesOnly = false; pinnedOnly = false; includeArchived = false; tags = []176 queryChanged()177 }178179 public nonisolated static func originLabel(_ origin: UnifiedSearchResult.Origin) -> String {180 switch origin {181 case .local: return L("Appareil")182 case .server: return L("Serveur")183 case .both: return L("Appareil + serveur")184 }185 }186187 public nonisolated static func originSymbol(_ origin: UnifiedSearchResult.Origin) -> String {188 switch origin {189 case .local: return "internaldrive"190 case .server: return "cloud"191 case .both: return "checkmark.icloud"192 }193 }194195 /// What the status line says under the field.196 public var statusText: String? {197 guard !answeredQuery.isEmpty else { return nil }198 let count = results.count > 1 ? LF("%lld résultats", results.count) : LF("%lld résultat", results.count)199 if isAskingServer { return LF("%@ sur l'appareil · interrogation du serveur…", count) }200 if answeredSemantic { return LF("%@ · recherche par le sens", count) }201 if usedServer { return LF("%@ · appareil et serveur", count) }202 return LF("%@ · appareil seulement", count)203 }204}205