Skip to content

🎧 Your Personal Streaming Service

feat(ui): show translation completion percentage in the language selector (#5979)

Deluan Quintão4b1218eec006
diff --git a/server/nativeapi/translations.go b/server/nativeapi/translations.go
index 685713083..39d071279 100644
--- a/server/nativeapi/translations.go
+++ b/server/nativeapi/translations.go
@@ -17,9 +17,10 @@ import (
)
type translation struct {
- ID string `json:"id"`
- Name string `json:"name"`
- Data string `json:"data"`
+ ID string `json:"id"`
+ Name string `json:"name"`
+ Data string `json:"data"`
+ TermCount int `json:"termCount"`
}
func newTranslationRepository(context.Context) rest.Repository {
@@ -97,27 +98,46 @@ func loadTranslation(fsys fs.FS, fileName string) (translation translation, err
// Load translation from json file
file, err := fsys.Open(filePath)
if err != nil {
- return
+ return translation, err
}
data, err := io.ReadAll(file)
if err != nil {
- return
+ return translation, err
}
var out map[string]any
if err = json.Unmarshal(data, &out); err != nil {
- return
+ return translation, err
}
// Compress JSON
buf := new(bytes.Buffer)
if err = json.Compact(buf, data); err != nil {
- return
+ return translation, err
}
translation.Data = buf.String()
translation.Name = out["languageName"].(string)
translation.ID = id
- return
+ translation.TermCount = countTranslatedTerms(out)
+ return translation, nil
+}
+
+// countTranslatedTerms counts non-empty leaf values, matching the UI's notion of a translated term
+func countTranslatedTerms(obj map[string]any) int {
+ count := 0
+ for _, v := range obj {
+ switch v := v.(type) {
+ case map[string]any:
+ count += countTranslatedTerms(v)
+ case string:
+ if v != "" {
+ count++
+ }
+ default:
+ count++
+ }
+ }
+ return count
}
var _ rest.Repository = (*translationRepository)(nil)
diff --git a/server/nativeapi/translations_test.go b/server/nativeapi/translations_test.go
index 6c834070c..77c088f6f 100644
--- a/server/nativeapi/translations_test.go
+++ b/server/nativeapi/translations_test.go
@@ -6,6 +6,7 @@ import (
"io/fs"
"os"
"path/filepath"
+ "testing/fstest"
"github.com/navidrome/navidrome/consts"
"github.com/navidrome/navidrome/resources"
@@ -45,5 +46,16 @@ var _ = Describe("Translations", func() {
var out map[string]any
Expect(json.Unmarshal([]byte(tr.Data), &out)).To(BeNil())
})
+
+ It("counts only non-empty leaf terms", func() {
+ fsys := fstest.MapFS{
+ "i18n/test.json": &fstest.MapFile{
+ Data: []byte(`{"languageName":"Test","a":"x","b":"","nested":{"c":"y","d":""}}`),
+ },
+ }
+ tr, err := loadTranslation(fsys, "test.json")
+ Expect(err).To(BeNil())
+ Expect(tr.TermCount).To(Equal(3))
+ })
})
})
diff --git a/ui/src/i18n/provider.js b/ui/src/i18n/provider.js
index f17a5b4ac..58f1782bb 100644
--- a/ui/src/i18n/provider.js
+++ b/ui/src/i18n/provider.js
@@ -42,13 +42,14 @@ const removeEmpty = (obj) => {
const prepareLanguage = (lang) => {
removeEmpty(lang)
+ // Aliases below go on the merged copy: mutating `en` would corrupt the completion baseline
+ const merged = deepmerge(en, lang)
// Make "albumSong" and "playlistTrack" resource use the same translations as "song"
- lang.resources.albumSong = lang.resources.song
- lang.resources.playlistTrack = lang.resources.song
+ merged.resources.albumSong = merged.resources.song
+ merged.resources.playlistTrack = merged.resources.song
// ra.boolean.null should always be empty
- lang.ra.boolean.null = ''
- // Fallback to english translations
- return deepmerge(en, lang)
+ merged.ra.boolean.null = ''
+ return merged
}
export default polyglotI18nProvider((locale) => {
diff --git a/ui/src/i18n/provider.test.js b/ui/src/i18n/provider.test.js
new file mode 100644
index 000000000..82b593788
--- /dev/null
+++ b/ui/src/i18n/provider.test.js
@@ -0,0 +1,19 @@
+import { describe, it, expect, vi } from 'vitest'
+import en from './en.json'
+
+vi.mock('../dataProvider', () => ({ default: { getOne: vi.fn() } }))
+
+const countLeaves = (obj) =>
+ Object.values(obj).reduce(
+ (sum, v) =>
+ sum + (typeof v === 'object' && v !== null ? countLeaves(v) : v ? 1 : 0),
+ 0,
+ )
+
+describe('i18n provider', () => {
+ it('does not mutate the bundled English translations', async () => {
+ const before = countLeaves(en)
+ await import('./provider')
+ expect(countLeaves(en)).toEqual(before)
+ })
+})
diff --git a/ui/src/i18n/useGetLanguageChoices.jsx b/ui/src/i18n/useGetLanguageChoices.jsx
index 0c708691f..38f95e422 100644
--- a/ui/src/i18n/useGetLanguageChoices.jsx
+++ b/ui/src/i18n/useGetLanguageChoices.jsx
@@ -1,5 +1,22 @@
// React Hook to get a list of all languages available. English is hardcoded
import { useGetList } from 'react-admin'
+import en from './en.json'
+
+const countLeaves = (obj) =>
+ Object.values(obj).reduce(
+ (sum, v) =>
+ sum + (typeof v === 'object' && v !== null ? countLeaves(v) : v ? 1 : 0),
+ 0,
+ )
+
+const enTermCount = countLeaves(en)
+
+const withPercentage = ({ id, name, termCount }) => {
+ if (!termCount) return { id, name }
+ const pct = Math.min(100, Math.round((100 * termCount) / enTermCount))
+ // Isolate the percentage, or it renders as "(%61)" next to a right-to-left name
+ return { id, name: `${name} ⁦(${pct}%)⁩` }
+}
const useGetLanguageChoices = () => {
const { ids, data, loaded, loading } = useGetList(
@@ -9,13 +26,19 @@ const useGetLanguageChoices = () => {
{},
)
- const choices = [{ id: 'en', name: 'English' }]
+ const languages = [{ id: 'en', name: 'English', termCount: enTermCount }]
if (loaded) {
- ids.forEach((id) => choices.push({ id: id, name: data[id].name }))
+ ids.forEach((id) =>
+ languages.push({
+ id,
+ name: data[id].name,
+ termCount: data[id].termCount,
+ }),
+ )
}
- choices.sort((a, b) => a.name.localeCompare(b.name))
+ languages.sort((a, b) => a.name.localeCompare(b.name))
- return { choices, loaded, loading }
+ return { choices: languages.map(withPercentage), loaded, loading }
}
export default useGetLanguageChoices
diff --git a/ui/src/i18n/useGetLanguageChoices.test.jsx b/ui/src/i18n/useGetLanguageChoices.test.jsx
new file mode 100644
index 000000000..b8214868e
--- /dev/null
+++ b/ui/src/i18n/useGetLanguageChoices.test.jsx
@@ -0,0 +1,92 @@
+import { describe, it, expect, vi } from 'vitest'
+import { renderHook } from '@testing-library/react-hooks'
+import { useGetList } from 'react-admin'
+import en from './en.json'
+import useGetLanguageChoices from './useGetLanguageChoices'
+
+vi.mock('react-admin', () => ({
+ useGetList: vi.fn(),
+}))
+
+const countLeaves = (obj) =>
+ Object.values(obj).reduce(
+ (sum, v) =>
+ sum + (typeof v === 'object' && v !== null ? countLeaves(v) : v ? 1 : 0),
+ 0,
+ )
+const enTermCount = countLeaves(en)
+
+// The percentage is wrapped in a left-to-right isolate, so it reads the same
+// next to right-to-left language names
+const label = (pct) => `⁦(${pct}%)⁩`
+
+const mockLanguages = (languages) => {
+ const data = {}
+ languages.forEach((l) => (data[l.id] = l))
+ useGetList.mockReturnValue({
+ ids: languages.map((l) => l.id),
+ data,
+ loaded: true,
+ loading: false,
+ })
+}
+
+const choiceFor = (id) => {
+ const { result } = renderHook(() => useGetLanguageChoices())
+ return result.current.choices.find((c) => c.id === id)
+}
+
+describe('useGetLanguageChoices', () => {
+ it('appends the completion percentage to incomplete languages', () => {
+ const termCount = Math.round(enTermCount * 0.62)
+ mockLanguages([{ id: 'cs', name: 'Čeština', termCount }])
+
+ const pct = Math.round((100 * termCount) / enTermCount)
+ expect(choiceFor('cs').name).toEqual(`Čeština ${label(pct)}`)
+ })
+
+ it('shows 100% for a complete language', () => {
+ mockLanguages([{ id: 'de', name: 'Deutsch', termCount: enTermCount }])
+
+ expect(choiceFor('de').name).toEqual(`Deutsch ${label(100)}`)
+ })
+
+ it('caps the percentage at 100 when a language has extra terms', () => {
+ mockLanguages([
+ { id: 'pt', name: 'Português', termCount: enTermCount + 20 },
+ ])
+
+ expect(choiceFor('pt').name).toEqual(`Português ${label(100)}`)
+ })
+
+ it('isolates the percentage next to a right-to-left name', () => {
+ const termCount = Math.round(enTermCount * 0.61)
+ mockLanguages([{ id: 'ar', name: 'العربية', termCount }])
+
+ const pct = Math.round((100 * termCount) / enTermCount)
+ expect(choiceFor('ar').name).toEqual(`العربية ⁦(${pct}%)⁩`)
+ })
+
+ it('omits the percentage when the server does not send a term count', () => {
+ mockLanguages([{ id: 'fr', name: 'Français' }])
+
+ expect(choiceFor('fr').name).toEqual('Français')
+ })
+
+ it('shows 100% for the bundled English', () => {
+ mockLanguages([])
+
+ expect(choiceFor('en').name).toEqual(`English ${label(100)}`)
+ })
+
+ it('sorts by language name, ignoring the percentage', () => {
+ mockLanguages([
+ { id: 'no', name: 'Norsk', termCount: enTermCount },
+ { id: 'da', name: 'Dansk', termCount: 1 },
+ ])
+
+ const { result } = renderHook(() => useGetLanguageChoices())
+
+ expect(result.current.choices.map((c) => c.id)).toEqual(['da', 'en', 'no'])
+ })
+})