Initial commit.

Packages/Localization/Sources/Public/Enumerations/CatalogState.swift

@@ -0,0 +1,12 @@
+/// The outcome of reading a String Catalog from its bundle.
+///
+/// The package degrades gracefully when a catalog cannot be read — lookups return their keys and the language list falls back to the default language — so
+/// nothing fails at the call site. This state is the signal a server checks once at startup to warn before visitors ever see raw localization keys.
+public enum CatalogState: Equatable, Sendable {
+    /// The catalog was found and decoded; its entries are resolvable.
+    case loaded
+    /// No catalog resource exists in the bundle; every lookup returns its key.
+    case missing
+    /// The catalog resource exists but is not valid `.xcstrings` JSON; every lookup returns its key.
+    case undecodable
+}

Packages/Localization/Sources/Public/Methods/Localize.swift

@@ -0,0 +1,69 @@
+import Foundation
+
+/// A reusable, bundle-bound localizer that resolves String Catalog entries for an explicit locale.
+///
+/// A server has no single "current" locale, so each lookup must name the locale to use. An instance is bound to the bundle whose catalog holds the strings,
+/// then invoked like a function to resolve a key in a chosen locale.
+public struct Localize: Sendable {
+
+    // MARK: Properties
+
+    /// The backend that resolves keys against the catalog.
+    private let resolver: any CatalogResolving
+
+    // MARK: Computed
+
+    /// The outcome of reading the bundle's String Catalog.
+    ///
+    /// Resolution degrades to returning raw keys rather than failing, so check this once at startup and warn when it is not ``CatalogState/loaded``.
+    public var catalogState: CatalogState {
+        resolver.state
+    }
+
+    // MARK: Initializers
+
+    /// Creates a localizer backed by the String Catalog in the given bundle.
+    /// - Parameters:
+    ///   - bundle: the bundle whose String Catalog contains the keys to resolve.
+    ///   - table: the name of the String Catalog resource, without the `.xcstrings` extension.
+    public init(
+        bundle: Bundle,
+        table: String = "Localizable"
+    ) {
+        self.init(resolver: StringCatalog.cached(
+            bundle: bundle,
+            table: table
+        ))
+    }
+
+    /// Creates a localizer backed by the given resolver.
+    ///
+    /// The seam for tests and alternative backends; the public API resolves against a bundled catalog.
+    /// - Parameter resolver: the backend that resolves keys to localized strings.
+    init(
+        resolver: any CatalogResolving
+    ) {
+        self.resolver = resolver
+    }
+
+    // MARK: Methods
+
+    /// Resolves a catalog key in the given locale.
+    ///
+    /// Invoked by calling the instance directly, for example `localize("index.title", locale: locale)`.
+    /// - Parameters:
+    ///   - key: the String Catalog key to look up.
+    ///   - locale: the locale to resolve the key in.
+    /// - Returns: the localized string for the locale, the source-language string when the locale has no entry, or the key itself when the catalog has no
+    ///   entry for it.
+    public func callAsFunction(
+        _ key: String,
+        locale: Locale
+    ) -> String {
+        resolver.string(
+            for: key,
+            in: locale
+        )
+    }
+
+}

Packages/Localization/Sources/Public/Methods/Negotiate.swift

@@ -0,0 +1,198 @@
+import Foundation
+
+/// Negotiates the best supported language for a request from its `Accept-Language` header.
+///
+/// Bound to a bundle's catalog languages via ``LanguageList``, an instance is invoked like a function — through
+/// ``callAsFunction(acceptLanguage:)`` — to resolve a header value to a supported language identifier, honouring the header's `q` weights as
+/// RFC 9110 prescribes and falling back to the default language.
+public struct Negotiate: Sendable {
+
+    // MARK: Properties
+
+    /// The supported languages and default language, derived from the bundle's String Catalog.
+    private let list: LanguageList
+
+    // MARK: Initializers
+
+    /// Creates a language negotiator backed by the given bundle's String Catalog.
+    /// - Parameter bundle: the bundle whose String Catalog defines the supported languages.
+    public init(
+        bundle: Bundle
+    ) {
+        self.list = .init(bundle: bundle)
+    }
+
+    // MARK: Methods
+
+    /// Picks the best supported language for the given `Accept-Language` header value.
+    ///
+    /// Invoked by calling the instance directly, for example `negotiate(acceptLanguage: header)`.
+    /// The header is parsed into its language ranges, which are ordered by descending `q` weight as RFC 9110 prescribes: an entry without a weight
+    /// counts as 1, entries weighted 0 are "not acceptable" and dropped, and equal weights keep the header order. Each tag is then matched against the
+    /// supported languages in turn — first by an exact match, then by its primary language subtag, so `de-AT` resolves to a supported `de` — while the
+    /// `*` wildcard accepts the default language. When the header is absent or matches nothing, the default language is returned.
+    /// - Parameter acceptLanguage: the raw `Accept-Language` header value, if any.
+    /// - Returns: the identifier of the supported language to serve.
+    public func callAsFunction(
+        acceptLanguage language: String?
+    ) -> String {
+        guard let language else {
+            return list.default
+        }
+
+        let ranges = ranges(from: language)
+
+        guard !ranges.isEmpty else {
+            return list.default
+        }
+
+        let supported = list.all
+
+        for range in ranges {
+            if range.tag == .wildcard {
+                return list.default
+            }
+
+            if let match = match(range.tag, in: supported) {
+                return match
+            }
+        }
+
+        return list.default
+    }
+
+}
+
+// MARK: - Helpers
+
+private extension Negotiate {
+
+    // MARK: Methods
+
+    /// Parses an `Accept-Language` header value into its ``LanguageRange`` list, ordered by preference.
+    ///
+    /// Each comma-separated entry yields its language tag and `q` weight. The ranges are sorted by descending weight, entries weighted 0 are dropped
+    /// as "not acceptable", and equally weighted entries keep the header order.
+    /// - Parameter acceptLanguage: the raw `Accept-Language` header value.
+    /// - Returns: the language ranges, most preferred first.
+    func ranges(
+        from acceptLanguage: String
+    ) -> [LanguageRange] {
+        acceptLanguage
+            .split(separator: .Separator.comma)
+            .compactMap(range(from:))
+            .filter { $0.quality > 0 }
+            .enumerated()
+            .sorted { lhs, rhs in
+                lhs.element.quality == rhs.element.quality
+                    ? lhs.offset < rhs.offset
+                    : lhs.element.quality > rhs.element.quality
+            }
+            .map(\.element)
+    }
+
+    /// Parses a single `Accept-Language` header entry into its ``LanguageRange``.
+    ///
+    /// The entry's language tag precedes the first `;`; a `q` parameter after it sets the weight.
+    /// A missing or malformed weight counts as 1, the highest preference, matching a tag sent without one.
+    /// - Parameter entry: a single comma-separated header entry.
+    /// - Returns: the entry's language range, or `nil` when it has no language tag.
+    func range(
+        from entry: Substring
+    ) -> LanguageRange? {
+        let parts = entry.split(separator: .Separator.semicolon)
+        let tag = parts.first
+            .map(String.init)?
+            .trimmingCharacters(in: .whitespaces)
+            ?? .empty
+
+        guard !tag.isEmpty else {
+            return nil
+        }
+
+        let quality = parts
+            .dropFirst()
+            .compactMap { parameter -> Double? in
+                let parameter = parameter
+                    .trimmingCharacters(in: .whitespaces)
+                    .lowercased()
+
+                guard parameter.hasPrefix(.Prefix.quality) else {
+                    return nil
+                }
+
+                return Double(parameter.dropFirst(String.Prefix.quality.count))
+            }
+            .first
+            ?? 1
+
+        return .init(
+            tag: tag,
+            quality: quality
+        )
+    }
+
+    /// Finds the supported language that best matches a single `Accept-Language` tag.
+    ///
+    /// An exact, case-insensitive match wins; otherwise the tag's primary subtag is matched against the supported languages' primary subtags, so a
+    /// regional tag such as `de-AT` resolves to `de`.
+    /// - Parameters:
+    ///   - tag: a single language tag from the header.
+    ///   - supported: the supported language identifiers.
+    /// - Returns: the matching supported language, or `nil` when the tag matches none.
+    func match(
+        _ tag: String,
+        in supported: [String]
+    ) -> String? {
+        let tag = tag.lowercased()
+
+        if let exact = supported.first(
+            where: { $0.lowercased() == tag }
+        ) {
+            return exact
+        }
+
+        let primary = tag.primarySubtag
+
+        return supported.first {
+            $0.lowercased().primarySubtag == primary
+        }
+    }
+
+}
+
+// MARK: - Character+Extensions
+
+private extension Character {
+    
+    // MARK: Constants
+    
+    enum Separator {
+        static let comma: Character = ","
+        static let dash: Character = "-"
+        static let semicolon: Character = ";"
+    }
+}
+
+
+// MARK: - String+Extensions
+
+private extension String {
+    
+    // MARK: Constants
+
+    static let empty: String = ""
+    static let wildcard: String = "*"
+    
+    enum Prefix {
+        static let quality = "q="
+    }
+
+    /// The primary language subtag, i.e. everything before the first `-` (`de-AT` becomes `de`).
+    var primarySubtag: String {
+        split(separator: .Separator.dash)
+            .first
+            .map(String.init)
+        ?? self
+    }
+}

Packages/Localization/Sources/Public/Types/LanguageList.swift

@@ -0,0 +1,61 @@
+import Foundation
+
+/// The list of languages an app can serve, derived from a bundle's String Catalog.
+///
+/// The languages are read from the injected `bundle`'s String Catalog, so the catalog that ships in that bundle is the single source of truth: adding
+/// a language is a translation-only change — once a locale exists in the catalog, it appears in ``all`` with no code change required.
+public struct LanguageList: Sendable {
+
+    // MARK: Properties
+
+    /// The backend that reports the available languages.
+    private let resolver: any CatalogResolving
+
+    // MARK: Initializers
+
+    /// Creates a language list backed by the given bundle.
+    /// - Parameter bundle: the bundle whose String Catalog defines the available languages.
+    public init(
+        bundle: Bundle
+    ) {
+        self.init(resolver: StringCatalog.cached(bundle: bundle))
+    }
+
+    /// Creates a language list backed by the given resolver.
+    ///
+    /// The seam for tests and alternative backends; the public API derives languages from a bundled catalog.
+    /// - Parameter resolver: the backend that reports the available languages.
+    init(
+        resolver: any CatalogResolving
+    ) {
+        self.resolver = resolver
+    }
+
+    // MARK: Computed
+
+    /// The outcome of reading the bundle's String Catalog.
+    ///
+    /// The list degrades to the default language rather than failing, so check this once at startup and warn when it is not ``CatalogState/loaded``.
+    public var catalogState: CatalogState {
+        resolver.state
+    }
+
+    /// The language served when none of the supported languages match a request.
+    ///
+    /// Always the catalog's source (development) language, so the default cannot drift from the bundle the list is bound to.
+    public var `default`: String {
+        resolver.sourceLanguage
+    }
+
+    /// Every language the bundle's String Catalog provides a localization for.
+    ///
+    /// The `Base` internationalization is excluded, as it is a development placeholder rather than a real language.
+    /// The result is sorted for a stable order.
+    public var all: [String] {
+        resolver
+            .languages
+            .filter { $0 != "Base" }
+            .sorted()
+    }
+
+}