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 isNotSupported = !findLang(localeFile);
+    const langsToProcess = 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: $(this).attr(attributeMatch[1]) });
+                        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	data = null;	493	data = null;
494	}	494	}
495		495
496	if (this.type !== ReasoningType.Model) {	496	if (this.type && this.type !== ReasoningType.Model) {
497	title += ` [${translate(this.type)}]`;	497	title += ` [${translate(this.type)}]`;
498	title = title.trim();	498	title = title.trim();
499	}	499	}