Add provider arg to /translate command

7f2cf6f7e6afcfdcbb7ec4da5408559b837de243

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

public/scripts/extensions/translate/index.html+1 -1 Viewed

             <label data-i18n="ext_translate_mode_provider" for="translation_provider">Provider</label>
             <div class="flex-container gap5px flexnowrap marginBot5">
                 <select id="translation_provider" name="provider" class="margin0">
                     <option value="libre">LibreLibreTranslate</option>
                     <option value="google">Google</option>
                     <option value="lingva">Lingva</option>
                     <option value="deepl">DeepL</option>

public/scripts/extensions/translate/index.js+32 -6 Viewed

 import { findSecret, secret_state, writeSecret } from '../../secrets.js';
 import { SlashCommand } from '../../slash-commands/SlashCommand.js';
 import { ARGUMENT_TYPE, SlashCommandArgument, SlashCommandNamedArgument } from '../../slash-commands/SlashCommandArgument.js';
 +import { enumIcons } from '../../slash-commands/SlashCommandCommonEnumsProvider.js';
 +import { enumTypes, SlashCommandEnumValue } from '../../slash-commands/SlashCommandEnumValue.js';
 import { SlashCommandParser } from '../../slash-commands/SlashCommandParser.js';
 import { splitRecursive } from '../../utils.js';

  * Translates text using the selected translation provider
  * @param {string} text Text to translate
  * @param {string} lang Target language code
 + * @param {string} provider Translation provider to use
  * @returns {Promise<string>} Translated text
  */
 async function translate(text, lang, provider = null) {
     try {
         if (text == '') {
             return '';

             lang = extension_settings.translate.target_language;
+        }
 +        if (!provider) {
 +            provider = extension_settings.translate.provider;
 +        }
++
         // split text by embedded images links
         const chunks = text.split(/!\[.*?]\([^)]*\)/);
         const links = [...text.matchAll(/!\[.*?]\([^)]*\)/g)];
         let result = '';
         for (let i = 0; i < chunks.length; i++) {
             result += await translateInner(chunks[i], lang, provider);
             if (i < links.length) result += links[i][0];
+        }

+    }
+}
 -async function translateInner(text, lang) {
 +/**
 + * Common translation function that handles the translation logic
 + * @param {string} text Text to translate
 + * @param {string} lang Target language code
 + * @param {string} provider Translation provider to use
 + * @returns {Promise<string>} Translated text
 + */
 +async function translateInner(text, lang, provider) {
     if (text == '') {
         return '';
+    }
     switchif (extension_settings.translate.!provider) {
 +        provider = extension_settings.translate.provider;
 +    }
 +    switch (provider) {
         case 'libre':
             return await translateProviderLibre(text, lang);
         case 'google':

@@ -446,7 +463,7 @@ async function translateInner(text, lang) {
446	463	case 'yandex':
447	464	return await translateProviderYandex(text, lang);
448	465	default:
449	466	console.error('Unknown translation provider', extension_settings.translate.provider);
450	467	return text;
451	468	}
452	469	}

         helpString: 'Translate text to a target language. If target language is not provided, the value from the extension settings will be used.',
         namedArgumentList: [
             new SlashCommandNamedArgument('target', 'The target language code to translate to', ARGUMENT_TYPE.STRING, false, false, '', Object.values(languageCodes)),
 +            SlashCommandNamedArgument.fromProps({
 +                name: 'provider',
 +                description: 'The translation provider to use. If not provided, the value from the extension settings will be used.',
 +                typeList: [ARGUMENT_TYPE.STRING],
 +                isRequired: false,
 +                acceptsMultiple: false,
 +                enumProvider: () => Array.from(document.getElementById('translation_provider').querySelectorAll('option')).map((option) => new SlashCommandEnumValue(option.value, option.text, enumTypes.name, enumIcons.server)),
 +            }),
         ],
         unnamedArgumentList: [
             new SlashCommandArgument('The text to translate', ARGUMENT_TYPE.STRING, true, false, ''),

             const target = args?.target && Object.values(languageCodes).includes(String(args.target))
                 ? String(args.target)
                 : extension_settings.translate.target_language;
 -            return await translate(String(value), target);
 +            const provider = args?.provider || extension_settings.translate.provider;
 +            return await translate(String(value), target, provider);
         },
         returns: ARGUMENT_TYPE.STRING,
     }));