mirror of
https://github.com/AgentSeal/codeburn.git
synced 2026-11-17 14:19:35 +00:00
All 533 catalog keys translated into zh-Hans, so the menubar app now follows
the system language with no setting to find and no third-party library. AppKit
picks the table: `CFBundleLocalizations` in both packaging scripts advertises
`en` and `zh-Hans`, which is also what puts the app under System Settings >
Language & Region so a user can override the language for CodeBurn alone.
Wording follows macOS system apps rather than a literal gloss: 立即刷新,
断开连接, 存储并连接, 载入配额, 再试一次. Product nouns stay as users
already know them: provider, model and plan names (Claude, Codex, Gemini,
Opus, Sonnet, Antigravity), Token, Dock, API, OAuth, shell commands and file
paths, currency codes.
Format specifiers are identical to the English entry in count and argument
order. `%%` is a literal percent sign and not an argument, so it may move where
Chinese word order demands it ("%@ · %@ 达到 100%%"); the argument-consuming
specifiers may not, because String(format:) binds them positionally. The next
commit's test enforces exactly that distinction.
Numbers, dates and currency are untouched: they already went through
NumberFormatter / DateFormatter / asCurrency(), and `L(_:_:)` only substitutes
values those produced.
62 lines
2.9 KiB
Swift
62 lines
2.9 KiB
Swift
import Foundation
|
|
|
|
/// Localization for the menubar app (#1219). No third-party library: one
|
|
/// `Localizable.strings` table per locale, shipped as SwiftPM target resources
|
|
/// and resolved by AppKit against the user's system language.
|
|
///
|
|
/// # Why every lookup is explicit
|
|
///
|
|
/// SwiftPM emits target resources into a *sibling* bundle
|
|
/// (`CodeBurnMenubar_CodeBurnMenubar.bundle`, copied into the app's
|
|
/// `Contents/Resources` by the packaging scripts), never into the app
|
|
/// bundle's resource root. `Bundle.main` therefore has no `.lproj` at all, so
|
|
/// the implicit `LocalizedStringKey` path that SwiftUI uses for
|
|
/// `Text("literal")` would always miss. Routing every string through `L(_:)`,
|
|
/// which names `Bundle.module`, is the one form that resolves identically in
|
|
/// `swift run`, in `swift test`, and in the packaged `.app`.
|
|
///
|
|
/// # Keys are the English copy
|
|
///
|
|
/// The key *is* the English string (`"Refresh Now"`, `"%lld sessions"`), so
|
|
/// English stays the development language: a key with no translation renders
|
|
/// as correct English rather than a visible identifier, and `en.lproj` is an
|
|
/// identity table kept only so the bundle advertises `en` as a localization
|
|
/// and so `LocalizationCatalogTests` can diff the two tables.
|
|
///
|
|
/// # What is not translated
|
|
///
|
|
/// Provider and model names (`Claude`, `Codex`, `Gemini`, `Sonnet`), units
|
|
/// (`tok/s`, `ACU`, `%`), currency codes, shell commands, and anything the
|
|
/// `codeburn` CLI itself produces (payload labels, activity and project names,
|
|
/// error text forwarded from the subprocess) stay verbatim. Numbers, dates,
|
|
/// and currency keep going through the locale-aware formatters they already
|
|
/// used — `L(_:_:)` only substitutes already-formatted values.
|
|
enum L10n {
|
|
/// The bundle that carries `en.lproj` / `zh-Hans.lproj`.
|
|
static let bundle: Bundle = .module
|
|
|
|
/// Table name, i.e. `Localizable.strings`.
|
|
static let table = "Localizable"
|
|
|
|
/// Locales shipped today. Mirrored by `CFBundleLocalizations` in the two
|
|
/// packaging scripts and asserted by `LocalizationCatalogTests`.
|
|
static let supportedLocalizations = ["en", "zh-Hans"]
|
|
}
|
|
|
|
/// Localized copy for `key`, falling back to the key (its English text) when a
|
|
/// translation is missing.
|
|
func L(_ key: String) -> String {
|
|
L10n.bundle.localizedString(forKey: key, value: key, table: L10n.table)
|
|
}
|
|
|
|
/// Localized format string for `key`, filled with `arguments`.
|
|
///
|
|
/// The specifiers in the key are part of the contract between the tables:
|
|
/// `%@` for an already-formatted value (currency, token count, provider name),
|
|
/// `%lld` for a plain `Int`. Deliberately formatted without a locale so the
|
|
/// substituted values keep exactly the grouping the existing formatters chose
|
|
/// — re-grouping a `%lld` here would disagree with the
|
|
/// `asCurrency()` / `asThousandsSeparated()` output next to it.
|
|
func L(_ key: String, _ arguments: CVarArg...) -> String {
|
|
String(format: L(key), arguments: arguments)
|
|
}
|