SPB Git

Repository Public

UnifiedSearchModel.swift 8.3 KB 205 lines swift

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
Files main
Menu

Theme