Merge pull request #3576 from SillyTavern/debug-track-dynamic-translations Debug function to track missing dynamic translation fields (`t` and `translate` calls)

20b5c962dbdc03e6c7e46855f66f780de0f3fd38

Cohee <18619528+Cohee1207@users.noreply.github.com>

Signed

Parents: f43b42544b39d21ef50323660f044e46eb5fd220 a8f05c92aef64247b874440b10478805710b53ae

public/scripts/i18n.js+61 -11 Viewed

 // eslint-disable-next-line prefer-const
 var localeData;
 +/** @type {Set<string>|null} Array of translations keys if they should be tracked - if not tracked then null */
 +let trackMissingDynamicTranslate = null;
++
 export const getCurrentLocale = () => localeFile;
 /**

  */
 export function translate(text, key = null) {
     const translationKey = key || text;
 +    if (translationKey === null || translationKey === undefined) {
 +        console.trace('WARN: No translation key provided');
 +        return '';
 +    }
 +    if (trackMissingDynamicTranslate && localeData && !Object.hasOwn(localeData, translationKey)) {
 +        trackMissingDynamicTranslate.add(translationKey);
 +    }
     return localeData?.[translationKey] || text;
+}

+    }
+}
 +/**
 + * Checks if the given locale is supported and not English.
 + * @param {string} [locale=null] The locale to check (defaults to the current locale)
 + * @returns {boolean} True if the locale is not English and supported
 + */
 +function isSupportedNonEnglish(locale = null) {
 +    const lang = locale || localeFile;
 +    return lang && lang != 'en' && findLang(lang);
 +}
 async function getMissingTranslations() {
 +    /** @type {Array<{key: string, language: string, value: string}>} */
     const missingData = [];
 +    if (trackMissingDynamicTranslate) {
 +        missingData.push(...Array.from(trackMissingDynamicTranslate).map(key => ({ key, language: localeFile, value: key })));
 +    }
++
     // Determine locales to search for untranslated strings
     const isNotSupportedlangsToProcess = !isSupportedNonEnglish() ? [findLang(localeFile)] : langs;
 -    const langsToProcess = (isNotSupported || localeFile == 'en') ? langs : [findLang(localeFile)];
     for (const language of langsToProcess) {
         const localeData = await getLocaleData(language.lang);

                 if (attributeMatch) { // attribute-tagged key
                     const localizedValue = localeData?.[attributeMatch[2]];
                     if (!localizedValue) {
                         missingData.push({ key, language: language.lang, value: String($(this).attr(attributeMatch[1])) });
+                    }
                 } else { // No attribute tag, treat as 'text'
                     const localizedValue = localeData?.[key];

     uniqueMissingData.sort((a, b) => a.language.localeCompare(b.language) || a.key.localeCompare(b.key));
     // Map to { language: { key: value } }
 -    let missingDataMap = {};
 +    const missingDataMap = Object.fromEntries(uniqueMissingData.map(({ key, value }) => [key, value]));
 -    for (const { key, value } of uniqueMissingData) {
 -        if (!missingDataMap) {
 -            missingDataMap = {};
 -        }
 -        missingDataMap[key] = value;
 -    }
 +    console.log(`Missing Translations (${uniqueMissingData.length}):`);
     console.table(uniqueMissingData);
 +    console.log(`Full map of missing data (${Object.keys(missingDataMap).length}):`);
     console.log(missingDataMap);
 +    if (trackMissingDynamicTranslate) {
 +        const trackMissingDynamicTranslateMap = Object.fromEntries(Array.from(trackMissingDynamicTranslate).map(key => [key, key]));
 +        console.log(`Dynamic translations missing (${Object.keys(trackMissingDynamicTranslateMap).length}):`);
 +        console.log(trackMissingDynamicTranslateMap);
 +    }
++
     toastr.success(`Found ${uniqueMissingData.length} missing translations. See browser console for details.`);
+}

         attributeFilter: ['data-i18n'],
     });
 -    registerDebugFunction('getMissingTranslations', 'Get missing translations', 'Detects missing localization data in the current locale and dumps the data into the browser console. If the current locale is English, searches all other locales.', getMissingTranslations);
 +    if (localStorage.getItem('trackDynamicTranslate') === 'true' && isSupportedNonEnglish()) {
 +        trackMissingDynamicTranslate = new Set();
 +    }
++
 +    registerDebugFunction('getMissingTranslations', 'Get missing translations',
 +        'Detects missing localization data in the current locale and dumps the data into the browser console. ' +
 +        'If the current locale is English, searches all other locales.',
 +        getMissingTranslations);
 +    registerDebugFunction('trackDynamicTranslate', 'Track dynamic translation',
 +        'Toggles tracking of dynamic translations, which will be dumped into the missing translations translations too. ' +
 +        'This includes things translated via the t`...` function and translate(). It will only track strings translated <b>after</b> this is toggled on, '
 +        + 'and when they actually pop up, so refreshing the page and opening popups, etc, is needed. Will only track if the current locale is not English.',
 +        () => {
 +            const isTracking = localStorage.getItem('trackDynamicTranslate') !== 'true';
 +            localStorage.setItem('trackDynamicTranslate', isTracking ? 'true' : 'false');
 +            if (isTracking && isSupportedNonEnglish()) {
 +                trackMissingDynamicTranslate = new Set();
 +                toastr.success('Dynamic translation tracking enabled.');
 +            } else if (isTracking) {
 +                trackMissingDynamicTranslate = null;
 +                toastr.warning('Dynamic translation tracking enabled, but will not be tracked with locale English.');
 +            } else {
 +                trackMissingDynamicTranslate = null;
 +                toastr.info('Dynamic translation tracking disabled.');
 +            }
 +        });
     registerDebugFunction('applyLocale', 'Apply locale', 'Reapplies the currently selected locale to the page.', applyLocale);
+}

public/scripts/reasoning.js+1 -1 Viewed

@@ -493,7 +493,7 @@ export class ReasoningHandler {
493	493	data = null;
494	494	}
495	495
496	496	if (this.type && this.type !== ReasoningType.Model) {
497	497	title += ` [${translate(this.type)}]`;
498	498	title = title.trim();
499	499	}