mirror of
https://github.com/Rain-kl/OpenFlare.git
synced 2026-11-16 23:04:24 +08:00
fix(i18n): use English runtime text and localize system UI
This commit is contained in:
@@ -0,0 +1,286 @@
|
||||
// Copyright 2026 Arctel.net
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
|
||||
// Package i18n translates built-in server text at presentation boundaries.
|
||||
// Runtime diagnostics and stored task text remain English.
|
||||
package i18n
|
||||
|
||||
import (
|
||||
"embed"
|
||||
"encoding/json"
|
||||
"io/fs"
|
||||
"path"
|
||||
"regexp"
|
||||
"sort"
|
||||
"strconv"
|
||||
"strings"
|
||||
"unicode"
|
||||
)
|
||||
|
||||
//go:embed locales/*.json
|
||||
var catalogFiles embed.FS
|
||||
|
||||
// DefaultLocale is the source language used for API clients without a preference.
|
||||
const DefaultLocale = "en"
|
||||
|
||||
type textPattern struct {
|
||||
id string
|
||||
match *regexp.Regexp
|
||||
prefix string
|
||||
suffix string
|
||||
score int
|
||||
}
|
||||
|
||||
type catalog struct {
|
||||
locales map[string]map[string]string
|
||||
exact map[string]string
|
||||
patterns []textPattern
|
||||
}
|
||||
|
||||
var (
|
||||
printfVerb = regexp.MustCompile(`%(?:\[[0-9]+\])?[-+# 0]*(?:[0-9]+|\*)?(?:\.(?:[0-9]+|\*))?[a-zA-Z%]`)
|
||||
builtIn = loadCatalog()
|
||||
)
|
||||
|
||||
func loadCatalog() catalog {
|
||||
result := catalog{locales: make(map[string]map[string]string), exact: make(map[string]string)}
|
||||
files, err := fs.Glob(catalogFiles, "locales/*.json")
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
for _, file := range files {
|
||||
data, readErr := catalogFiles.ReadFile(file)
|
||||
if readErr != nil {
|
||||
panic(readErr)
|
||||
}
|
||||
var messages map[string]string
|
||||
if decodeErr := json.Unmarshal(data, &messages); decodeErr != nil {
|
||||
panic(decodeErr)
|
||||
}
|
||||
locale := strings.TrimSuffix(path.Base(file), ".json")
|
||||
result.locales[locale] = messages
|
||||
}
|
||||
locales := make([]string, 0, len(result.locales))
|
||||
for locale := range result.locales {
|
||||
locales = append(locales, locale)
|
||||
}
|
||||
sort.Strings(locales)
|
||||
for _, locale := range locales {
|
||||
messages := result.locales[locale]
|
||||
ids := make([]string, 0, len(messages))
|
||||
for id := range messages {
|
||||
ids = append(ids, id)
|
||||
}
|
||||
sort.Strings(ids)
|
||||
for _, id := range ids {
|
||||
text := messages[id]
|
||||
if _, exists := result.exact[text]; !exists {
|
||||
result.exact[text] = id
|
||||
}
|
||||
if pattern, ok := compilePattern(id, text); ok {
|
||||
result.patterns = append(result.patterns, pattern)
|
||||
}
|
||||
}
|
||||
}
|
||||
// Go errors use a lowercase initial. Recognize the earlier capitalized
|
||||
// English spelling too when displaying existing task errors and logs.
|
||||
english := result.locales[DefaultLocale]
|
||||
ids := make([]string, 0, len(english))
|
||||
for id := range english {
|
||||
ids = append(ids, id)
|
||||
}
|
||||
sort.Strings(ids)
|
||||
for _, id := range ids {
|
||||
text := english[id]
|
||||
if text == "" || text[0] < 'a' || text[0] > 'z' {
|
||||
continue
|
||||
}
|
||||
legacy := strings.ToUpper(text[:1]) + text[1:]
|
||||
if _, exists := result.exact[legacy]; exists {
|
||||
continue
|
||||
}
|
||||
result.exact[legacy] = id
|
||||
if pattern, ok := compilePattern(id, legacy); ok {
|
||||
result.patterns = append(result.patterns, pattern)
|
||||
}
|
||||
}
|
||||
sort.SliceStable(result.patterns, func(left, right int) bool {
|
||||
return result.patterns[left].score > result.patterns[right].score
|
||||
})
|
||||
return result
|
||||
}
|
||||
|
||||
func splitFormat(format string) ([]string, bool) {
|
||||
indices := printfVerb.FindAllStringIndex(format, -1)
|
||||
if len(indices) == 0 {
|
||||
// Some existing boundaries append an external error to a literal prefix.
|
||||
if strings.HasSuffix(format, ": ") {
|
||||
return []string{format, ""}, true
|
||||
}
|
||||
return nil, false
|
||||
}
|
||||
parts := []string{}
|
||||
start := 0
|
||||
for _, index := range indices {
|
||||
if format[index[0]:index[1]] == "%%" {
|
||||
continue
|
||||
}
|
||||
parts = append(parts, strings.ReplaceAll(format[start:index[0]], "%%", "%"))
|
||||
start = index[1]
|
||||
}
|
||||
if len(parts) == 0 {
|
||||
return nil, false
|
||||
}
|
||||
parts = append(parts, strings.ReplaceAll(format[start:], "%%", "%"))
|
||||
return parts, true
|
||||
}
|
||||
|
||||
func compilePattern(id, format string) (textPattern, bool) {
|
||||
parts, ok := splitFormat(format)
|
||||
if !ok {
|
||||
return textPattern{}, false
|
||||
}
|
||||
score := 0
|
||||
var pattern strings.Builder
|
||||
pattern.WriteString("(?s)^")
|
||||
for index, part := range parts {
|
||||
score += len(part)
|
||||
if index > 0 {
|
||||
pattern.WriteString("(.*?)")
|
||||
}
|
||||
pattern.WriteString(regexp.QuoteMeta(part))
|
||||
}
|
||||
pattern.WriteString("$")
|
||||
if score == 0 {
|
||||
return textPattern{}, false
|
||||
}
|
||||
return textPattern{id: id, match: regexp.MustCompile(pattern.String()), prefix: parts[0], suffix: parts[len(parts)-1], score: score}, true
|
||||
}
|
||||
|
||||
// ResolveLocale honors a supported locale cookie, then Accept-Language, then English.
|
||||
func ResolveLocale(cookie, acceptLanguage string) string {
|
||||
if locale, ok := supportedLocale(cookie); ok {
|
||||
return locale
|
||||
}
|
||||
type preference struct {
|
||||
locale string
|
||||
weight float64
|
||||
}
|
||||
preferences := make([]preference, 0)
|
||||
for _, item := range strings.Split(acceptLanguage, ",") {
|
||||
fields := strings.Split(item, ";")
|
||||
locale, ok := supportedLocale(fields[0])
|
||||
if !ok {
|
||||
continue
|
||||
}
|
||||
weight := 1.0
|
||||
for _, field := range fields[1:] {
|
||||
if value, found := strings.CutPrefix(strings.TrimSpace(field), "q="); found {
|
||||
parsed, err := strconv.ParseFloat(value, 64)
|
||||
if err != nil || parsed < 0 || parsed > 1 {
|
||||
weight = 0
|
||||
} else {
|
||||
weight = parsed
|
||||
}
|
||||
}
|
||||
}
|
||||
if weight > 0 {
|
||||
preferences = append(preferences, preference{locale: locale, weight: weight})
|
||||
}
|
||||
}
|
||||
sort.SliceStable(preferences, func(left, right int) bool {
|
||||
return preferences[left].weight > preferences[right].weight
|
||||
})
|
||||
if len(preferences) > 0 {
|
||||
return preferences[0].locale
|
||||
}
|
||||
return DefaultLocale
|
||||
}
|
||||
|
||||
func supportedLocale(value string) (string, bool) {
|
||||
value = strings.ToLower(strings.ReplaceAll(strings.TrimSpace(value), "_", "-"))
|
||||
for locale := range builtIn.locales {
|
||||
if strings.EqualFold(locale, value) {
|
||||
return locale, true
|
||||
}
|
||||
}
|
||||
base, _, _ := strings.Cut(value, "-")
|
||||
if base == "zh" {
|
||||
_, ok := builtIn.locales["zh-CN"]
|
||||
return "zh-CN", ok
|
||||
}
|
||||
_, ok := builtIn.locales[base]
|
||||
return base, ok
|
||||
}
|
||||
|
||||
// Translate renders known system text without modifying interpolated values.
|
||||
// Both English and historical translated templates are recognized. Unknown text
|
||||
// is returned unchanged; this function must only be used for system-owned fields.
|
||||
func Translate(locale, text string) string {
|
||||
// Authentication responses include stable control prefixes consumed by the
|
||||
// login UI. Translate their human-readable suffix, preserving the protocol.
|
||||
for _, prefix := range []string{"smtp_invalid:", "need_email_code:"} {
|
||||
if suffix, ok := strings.CutPrefix(text, prefix); ok {
|
||||
return prefix + translate(locale, suffix)
|
||||
}
|
||||
}
|
||||
return translate(locale, text)
|
||||
}
|
||||
|
||||
func translate(locale, text string) string {
|
||||
messages, ok := builtIn.locales[locale]
|
||||
if !ok {
|
||||
messages = builtIn.locales[DefaultLocale]
|
||||
}
|
||||
if id, found := builtIn.exact[text]; found {
|
||||
if translated, exists := messages[id]; exists {
|
||||
return translated
|
||||
}
|
||||
return text
|
||||
}
|
||||
// English diagnostics are already in the source language. Avoid scanning the
|
||||
// legacy catalog for ordinary English log lines.
|
||||
if locale == DefaultLocale && !strings.ContainsFunc(text, func(r rune) bool { return unicode.Is(unicode.Han, r) }) {
|
||||
return text
|
||||
}
|
||||
for _, pattern := range builtIn.patterns {
|
||||
if !strings.HasPrefix(text, pattern.prefix) || !strings.HasSuffix(text, pattern.suffix) {
|
||||
continue
|
||||
}
|
||||
matches := pattern.match.FindStringSubmatch(text)
|
||||
if len(matches) == 0 {
|
||||
continue
|
||||
}
|
||||
translated, found := messages[pattern.id]
|
||||
if !found {
|
||||
return text
|
||||
}
|
||||
parts, valid := splitFormat(translated)
|
||||
if !valid || len(parts) != len(matches) {
|
||||
return text
|
||||
}
|
||||
var output strings.Builder
|
||||
for index, part := range parts {
|
||||
if index > 0 {
|
||||
output.WriteString(matches[index])
|
||||
}
|
||||
output.WriteString(part)
|
||||
}
|
||||
return output.String()
|
||||
}
|
||||
return text
|
||||
}
|
||||
|
||||
// TranslateLog preserves timestamps and unknown legacy lines while translating
|
||||
// the known system template on each line. Stored log contents are never rewritten.
|
||||
func TranslateLog(locale, text string) string {
|
||||
lines := strings.Split(text, "\n")
|
||||
for index, line := range lines {
|
||||
prefix := ""
|
||||
if len(line) >= len("[00:00:00] ") && line[0] == '[' && line[9] == ']' && line[10] == ' ' {
|
||||
prefix, line = line[:11], line[11:]
|
||||
}
|
||||
lines[index] = prefix + Translate(locale, line)
|
||||
}
|
||||
return strings.Join(lines, "\n")
|
||||
}
|
||||
Reference in New Issue
Block a user