native macOS codings agent orchestrator prowl.onev.cat
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104import Foundation
/// The language choice shown in Settings. Prowl keeps no copy of it: the per-app/// `AppleLanguages` default is the only source (see `AppLanguageStore`).nonisolated enum AppLanguage: String, CaseIterable, Identifiable, Sendable { case system case zhHans = "zh-Hans" case english = "en"
var id: String { rawValue }
/// Each language is named in its own language, so a user who picked a language /// they cannot read can still find their way back. "Follow System" is localized /// because it always sits first in the picker. var title: String { switch self { case .system: return String(localized: "Follow System") case .zhHans: return "简体中文" case .english: return "English" } }
/// Reads the choice from a per-app `AppleLanguages` value. macOS writes the same key from /// System Settings → Language & Region → Applications, with regional identifiers and a /// fallback list, so the value is negotiated the way the platform does it. A language /// Prowl has no localization for reads as English, because that is what the app shows. init(appleLanguages: [String]?) { guard let appleLanguages, !appleLanguages.isEmpty else { self = .system return } let resolved = AppLanguageResolver.match( preferences: appleLanguages, supported: ResolvedAppLanguage.allCases.map(\.rawValue) ) self = resolved == .zhHans ? .zhHans : .english }
/// The per-app `AppleLanguages` value for this choice. `nil` removes the key, so the app /// follows the system language again. var appleLanguages: [String]? { self == .system ? nil : [rawValue] }}
/// The languages Prowl ships localizations for.nonisolated enum ResolvedAppLanguage: String, CaseIterable, Sendable { case english = "en" case zhHans = "zh-Hans"
/// The language this process runs in. Foundation negotiates it once at launch, so a later /// change of the choice does not affect it. static func effective(bundle: Bundle = .main) -> ResolvedAppLanguage { AppLanguageResolver.match( preferences: bundle.preferredLocalizations, supported: allCases.map(\.rawValue) ) ?? .english }}
nonisolated enum AppLanguageResolver { /// Predicts the language of the next normal launch: an explicit choice wins, and /// "Follow System" negotiates the system languages. Matching is delegated to the /// platform (`Bundle.preferredLocalizations(from:forPreferences:)`) rather than /// hand-rolled "any zh prefix means Simplified" rules. /// /// - Parameters: /// - preference: The current choice. /// - platformLanguages: The system languages, without the per-app override. /// - supportedLanguages: Localizations the app ships, in fallback order. static func resolve( preference: AppLanguage, platformLanguages: [String], supportedLanguages: [String] ) -> ResolvedAppLanguage { switch preference { case .zhHans: return .zhHans case .english: return .english case .system: let supported = supportedLanguages.isEmpty ? ResolvedAppLanguage.allCases.map(\.rawValue) : supportedLanguages guard !platformLanguages.isEmpty else { return .english } return match(preferences: platformLanguages, supported: supported) ?? .english } }
static func match(preferences: [String], supported: [String]) -> ResolvedAppLanguage? { guard let matched = Bundle.preferredLocalizations(from: supported, forPreferences: preferences).first else { return nil } return ResolvedAppLanguage(rawValue: matched) }}