i18ntk 3.2.0 → 4.0.0

package/utils/translate/api.js

@@ -1,39 +1,11 @@
-const https = require('https');
 const { URL } = require('url');
+const { safeHttpGet, safeHttpPost, buildGoogleTranslateUrl } = require('./safe-network');
 
 const DEFAULT_CONCURRENCY = 3;
 const DEFAULT_RETRY_COUNT = 3;
 const DEFAULT_RETRY_DELAY = 1000;
 const MAX_BACKOFF_DELAY = 30000;
 
-function httpGet(urlString, timeout = 15000) {
-  return new Promise((resolve) => {
-    const url = new URL(urlString);
-    if (url.protocol !== 'https:') {
-      resolve({ ok: false, error: 'ProtocolError', message: 'Only HTTPS requests are supported' });
-      return;
-    }
-    const req = https.get(urlString, { headers: { 'User-Agent': 'i18ntk/3.2.0' } }, (res) => {
-      let data = '';
-      res.on('data', (chunk) => { data += chunk; });
-      res.on('end', () => {
-        try {
-          const parsed = JSON.parse(data);
-          resolve({ ok: true, data: parsed, status: res.statusCode });
-        } catch (e) {
-          resolve({ ok: false, error: 'ParseError', raw: data.substring(0, 500), status: res.statusCode });
-        }
-      });
-    });
-    req.setTimeout(timeout, () => {
-      req.destroy();
-      resolve({ ok: false, error: 'TimeoutError', message: 'Request timed out' });
-    });
-    req.on('error', (e) => {
-      resolve({ ok: false, error: e.code || 'NetworkError', message: e.message });
-    });
-  });
-}
 
 function extractTranslation(result) {
   if (result && Array.isArray(result) && result[0]) {
@@ -46,6 +18,154 @@ function extractTranslation(result) {
   return null;
 }
 
+function normalizeProvider(provider) {
+  const value = String(provider || process.env.I18NTK_TRANSLATE_PROVIDER || 'google').trim().toLowerCase();
+  if (value === 'deepl-free' || value === 'deepl-pro') return 'deepl';
+  if (value === 'libre' || value === 'libretranslate') return 'libretranslate';
+  if (value === 'google' || value === 'gtx') return 'google';
+  return value;
+}
+
+function normalizeDeepLLanguage(code) {
+  return String(code || '').replace('-', '_').toUpperCase();
+}
+
+function getDeepLApiUrl(options = {}) {
+  if (options.deeplApiUrl) return options.deeplApiUrl;
+  if (process.env.DEEPL_API_URL) return process.env.DEEPL_API_URL;
+  return 'https://api-free.deepl.com/v2/translate';
+}
+
+function isEnabled(value) {
+  return ['1', 'true', 'yes', 'on'].includes(String(value || '').trim().toLowerCase());
+}
+
+function getDeepLAllowedHosts(url, options = {}) {
+  const hosts = ['api-free.deepl.com', 'api.deepl.com'];
+  if (options.allowCustomTranslateHosts || isEnabled(process.env.I18NTK_ALLOW_CUSTOM_TRANSLATE_HOSTS)) {
+    hosts.push(new URL(url).hostname);
+  }
+  return [...new Set(hosts)];
+}
+
+function parseProviderUrl(url, provider) {
+  try {
+    return { ok: true, parsed: new URL(url) };
+  } catch (error) {
+    return {
+      ok: false,
+      error: 'InvalidProviderUrl',
+      message: `${provider} provider URL is invalid: ${error.message}`,
+    };
+  }
+}
+
+function extractDeepLTranslation(data) {
+  const value = data && Array.isArray(data.translations) && data.translations[0] && data.translations[0].text;
+  return typeof value === 'string' && value.trim() ? value : null;
+}
+
+function getLibreTranslateUrl(options = {}) {
+  if (options.libreTranslateUrl) return options.libreTranslateUrl;
+  if (process.env.LIBRETRANSLATE_URL) return process.env.LIBRETRANSLATE_URL;
+  return 'https://libretranslate.com/translate';
+}
+
+function getLibreTranslateAllowedHosts(url) {
+  return [...new Set(['libretranslate.com', new URL(url).hostname])];
+}
+
+function extractLibreTranslateTranslation(data) {
+  const value = data && data.translatedText;
+  return typeof value === 'string' && value.trim() ? value : null;
+}
+
+function buildProviderRequest(text, targetLang, options = {}) {
+  const provider = normalizeProvider(options.provider);
+  const sourceLang = options.sourceLang || 'en';
+
+  if (provider === 'google') {
+    return {
+      provider,
+      method: 'GET',
+      url: buildGoogleTranslateUrl(text, sourceLang, targetLang),
+      extract: extractTranslation,
+    };
+  }
+
+  if (provider === 'deepl') {
+    const apiKey = options.deeplApiKey || process.env.DEEPL_API_KEY;
+    if (!apiKey) {
+      return {
+        provider,
+        error: 'MissingApiKey',
+        message: 'DeepL provider requires DEEPL_API_KEY in the environment or deeplApiKey in options.',
+      };
+    }
+
+    const url = getDeepLApiUrl(options);
+    const parsedUrl = parseProviderUrl(url, 'DeepL');
+    if (!parsedUrl.ok) return { provider, error: parsedUrl.error, message: parsedUrl.message };
+
+    return {
+      provider,
+      method: 'POST',
+      url,
+      body: {
+        text: [text],
+        target_lang: normalizeDeepLLanguage(targetLang),
+        source_lang: normalizeDeepLLanguage(sourceLang),
+      },
+      requestOptions: {
+        provider,
+        allowedHosts: getDeepLAllowedHosts(url, options),
+        allowedPaths: ['/v2/translate'],
+        headers: {
+          Authorization: `DeepL-Auth-Key ${apiKey}`,
+        },
+      },
+      extract: extractDeepLTranslation,
+    };
+  }
+
+  if (provider === 'libretranslate') {
+    const apiKey = options.libreTranslateApiKey || process.env.LIBRETRANSLATE_API_KEY || '';
+    const url = getLibreTranslateUrl(options);
+    const parsedUrl = parseProviderUrl(url, 'LibreTranslate');
+    if (!parsedUrl.ok) return { provider, error: parsedUrl.error, message: parsedUrl.message };
+
+    const params = new URLSearchParams({
+      q: text,
+      source: sourceLang,
+      target: targetLang,
+      format: 'text',
+    });
+    if (apiKey) params.set('api_key', apiKey);
+
+    return {
+      provider,
+      method: 'POST',
+      url,
+      body: params.toString(),
+      requestOptions: {
+        provider,
+        allowedHosts: getLibreTranslateAllowedHosts(url),
+        allowedPaths: ['/translate'],
+        headers: {
+          'Content-Type': 'application/x-www-form-urlencoded',
+        },
+      },
+      extract: extractLibreTranslateTranslation,
+    };
+  }
+
+  return {
+    provider,
+    error: 'UnsupportedProvider',
+    message: `Unsupported translation provider "${provider}". Use google, deepl, or libretranslate.`,
+  };
+}
+
 function detectRateLimitError(result) {
   if (!result.ok && result.status === 429) return true;
   if (result.ok && result.status === 429) return true;
@@ -61,6 +181,8 @@ async function translateText(text, targetLang, options = {}) {
     retryDelay = DEFAULT_RETRY_DELAY,
     customFn,
     timeout = 15000,
+    httpGet = safeHttpGet,
+    httpPost = safeHttpPost,
   } = options;
 
   if (!text || text.trim().length === 0) return { ok: true, translated: text };
@@ -74,14 +196,10 @@ async function translateText(text, targetLang, options = {}) {
     }
   }
 
-  const params = new URLSearchParams({
-    client: 'gtx',
-    sl: sourceLang,
-    tl: targetLang,
-    dt: 't',
-    q: text,
-  });
-  const url = `https://translate.googleapis.com/translate_a/single?${params.toString()}`;
+  const request = buildProviderRequest(text, targetLang, { ...options, sourceLang });
+  if (request.error) {
+    return { ok: false, translated: null, error: request.error, message: request.message };
+  }
 
   let lastError = null;
   for (let attempt = 0; attempt < retryCount; attempt++) {
@@ -90,10 +208,12 @@ async function translateText(text, targetLang, options = {}) {
       await new Promise((resolve) => setTimeout(resolve, delay));
     }
 
-    const result = await httpGet(url, timeout);
+    const result = request.method === 'POST'
+      ? await httpPost(request.url, request.body, { ...(request.requestOptions || {}), timeout })
+      : await httpGet(request.url, timeout);
 
     if (result.ok) {
-      const translated = extractTranslation(result.data);
+      const translated = request.extract(result.data);
       if (translated !== null && translated !== text) {
         return { ok: true, translated };
       }
@@ -101,7 +221,7 @@ async function translateText(text, targetLang, options = {}) {
         return { ok: true, translated: text };
       }
       if (result.status === 429 || (translated === null && result.status >= 400)) {
-        lastError = { error: 'RateLimited', message: 'Google Translate rate limit hit' };
+        lastError = { error: 'RateLimited', message: `${request.provider} rate limit hit` };
         continue;
       }
     }
@@ -165,8 +285,11 @@ async function translateBatch(batch, targetLang, options = {}) {
 }
 
 module.exports = {
-  httpGet,
   extractTranslation,
+  extractDeepLTranslation,
+  extractLibreTranslateTranslation,
+  buildProviderRequest,
+  normalizeProvider,
   detectRateLimitError,
   translateText,
   translateBatch,

package/utils/translate/protection.js

@@ -3,6 +3,8 @@ const SecurityUtils = require('../security');
 
 const DEFAULT_PROTECTION_FILE = 'i18ntk-auto-translate.json';
 const TOKEN_PREFIX = '__I18NTK_KEEP_';
+const MAX_CONTEXT_RULES = 100;
+const MAX_CONTEXT_INPUT_LENGTH = 200;
 
 function defaultProtectionConfig() {
   return {
@@ -49,12 +51,85 @@ function compilePatterns(patterns) {
   return compiled;
 }
 
+function parseContextString(context) {
+  if (typeof context !== 'string') return null;
+  if (context.length > MAX_CONTEXT_INPUT_LENGTH) return null;
+
+  const trimmed = context.trim();
+
+  if (trimmed === 'standalone') {
+    return { mode: 'standalone' };
+  }
+
+  const afterMatch = trimmed.match(/^after:(.+)$/i);
+  if (afterMatch) {
+    const words = afterMatch[1].split('|').map(w => w.trim()).filter(Boolean);
+    if (words.length === 0) return null;
+    return { mode: 'after', words };
+  }
+
+  const beforeMatch = trimmed.match(/^before:(.+)$/i);
+  if (beforeMatch) {
+    const words = beforeMatch[1].split('|').map(w => w.trim()).filter(Boolean);
+    if (words.length === 0) return null;
+    return { mode: 'before', words };
+  }
+
+  const surroundedMatch = trimmed.match(/^surrounded:(.+),(.+)$/i);
+  if (surroundedMatch) {
+    const leftWords = surroundedMatch[1].split('|').map(w => w.trim()).filter(Boolean);
+    const rightWords = surroundedMatch[2].split('|').map(w => w.trim()).filter(Boolean);
+    if (leftWords.length === 0 || rightWords.length === 0) return null;
+    return { mode: 'surrounded', left: leftWords, right: rightWords };
+  }
+
+  return null;
+}
+
+function parseContextRule(rule) {
+  if (typeof rule === 'string') {
+    const trimmed = rule.trim();
+    if (!trimmed || trimmed.length > MAX_CONTEXT_INPUT_LENGTH) return null;
+    return { value: trimmed, type: 'global' };
+  }
+
+  if (
+    typeof rule === 'object' &&
+    rule !== null &&
+    typeof rule.value === 'string' &&
+    typeof rule.context === 'string'
+  ) {
+    const value = rule.value.trim();
+    const rawContext = rule.context;
+
+    if (!value || value.length > MAX_CONTEXT_INPUT_LENGTH) return null;
+    if (!rawContext || rawContext.length > MAX_CONTEXT_INPUT_LENGTH) return null;
+
+    const parsed = parseContextString(rawContext);
+    if (!parsed) return null;
+
+    return { value, type: 'context', context: parsed };
+  }
+
+  return null;
+}
+
 function normalizeProtectionConfig(config = {}, filePath = null) {
   const terms = normalizeList(config.terms);
   const keys = normalizeList(config.keys);
   const values = normalizeList(config.values);
   const patterns = normalizeList(config.patterns);
 
+  const rawTerms = Array.isArray(config.terms) ? config.terms : [];
+  const normalizedTerms = [];
+  for (const term of rawTerms) {
+    const normalized = parseContextRule(term);
+    if (normalized) {
+      normalizedTerms.push(normalized);
+    }
+  }
+  const cappedTerms = normalizedTerms.slice(0, MAX_CONTEXT_RULES);
+
   return {
     enabled: true,
     filePath,
@@ -62,7 +137,8 @@ function normalizeProtectionConfig(config = {}, filePath = null) {
     keys,
     values,
     patterns,
-    compiledPatterns: compilePatterns(patterns)
+    compiledPatterns: compilePatterns(patterns),
+    normalizedTerms: cappedTerms
   };
 }
 
@@ -98,10 +174,20 @@ function saveProtectionFile(filePath, config, options = {}) {
   if (!SecurityUtils.safeExistsSync(dir, path.dirname(dir))) {
     SecurityUtils.safeMkdirSync(dir, path.dirname(dir), { recursive: true });
   }
+
+  const rawTerms = Array.isArray(config?.terms) ? config.terms : [];
+  const sanitizedTerms = [];
+  for (const term of rawTerms) {
+    const normalized = parseContextRule(term);
+    if (normalized) {
+      sanitizedTerms.push(term);
+    }
+  }
+
   const nextConfig = {
     ...defaultProtectionConfig(),
     ...(config || {}),
-    terms: normalizeList(config?.terms),
+    terms: sanitizedTerms.slice(0, MAX_CONTEXT_RULES),
     keys: normalizeList(config?.keys),
     values: normalizeList(config?.values),
     patterns: normalizeList(config?.patterns)
@@ -156,7 +242,8 @@ function shouldPreserveWholeValue(keyPath, value, protection) {
   if (!protection || protection.enabled === false) return false;
   if (protection.keys.some(rule => keyMatchesRule(keyPath, rule))) return true;
   const valueText = String(value);
-  return protection.values.includes(valueText) || protection.terms.includes(valueText);
+  return protection.values.includes(valueText) ||
+    (protection.normalizedTerms || []).some(rule => rule.value === valueText);
 }
 
 function addReplacement(replacements, original) {
@@ -165,13 +252,65 @@ function addReplacement(replacements, original) {
   replacements.push({ original });
 }
 
+function shouldProtectInContext(value, rule, index, fullText) {
+  if (rule.type === 'global') return true;
+
+  const { context } = rule;
+  const before = fullText.substring(0, index);
+  const after = fullText.substring(index + value.length);
+
+  if (context.mode === 'after') {
+    const alternation = context.words.map(escapeRegExp).join('|');
+    const regex = new RegExp(`\\b(${alternation})\\s+$`, 'i');
+    return regex.test(before);
+  }
+
+  if (context.mode === 'before') {
+    const alternation = context.words.map(escapeRegExp).join('|');
+    const regex = new RegExp(`^\\s+(${alternation})\\b`, 'i');
+    return regex.test(after);
+  }
+
+  if (context.mode === 'standalone') {
+    const isBoundaryBefore = before === '' || /\s$/.test(before);
+    const isBoundaryAfter = after === '' || /^[\s.,!?;:]/.test(after);
+    return isBoundaryBefore && isBoundaryAfter;
+  }
+
+  if (context.mode === 'surrounded') {
+    const leftAlternation = context.left.map(escapeRegExp).join('|');
+    const rightAlternation = context.right.map(escapeRegExp).join('|');
+    const leftRegex = new RegExp(`\\b(${leftAlternation})\\s+$`, 'i');
+    const rightRegex = new RegExp(`^\\s+(${rightAlternation})\\b`, 'i');
+    return leftRegex.test(before) && rightRegex.test(after);
+  }
+
+  return false;
+}
+
 function collectReplacements(value, protection) {
   const text = String(value);
   const replacements = [];
 
-  for (const term of protection.terms || []) {
-    if (text.includes(term)) {
-      addReplacement(replacements, term);
+  const rules = protection.normalizedTerms || (protection.terms || [])
+    .map(parseContextRule)
+    .filter(Boolean);
+  for (const rule of rules) {
+    if (rule.type === 'global') {
+      if (text.includes(rule.value)) {
+        addReplacement(replacements, rule.value);
+      }
+    } else {
+      if (!rule.value) continue;
+      const escaped = escapeRegExp(rule.value);
+      const regex = new RegExp(escaped, 'gi');
+      let match;
+      while ((match = regex.exec(text)) !== null) {
+        if (shouldProtectInContext(rule.value, rule, match.index, text)) {
+          addReplacement(replacements, match[0]);
+        }
+        if (match[0] === '') regex.lastIndex++;
+      }
     }
   }
 
@@ -221,6 +360,7 @@ function hasProtectionRules(protection) {
   return Boolean(
     protection &&
     (
+      (protection.normalizedTerms && protection.normalizedTerms.length) ||
       protection.terms.length ||
       protection.keys.length ||
       protection.values.length ||
@@ -235,6 +375,7 @@ module.exports = {
   defaultProtectionConfig,
   hasProtectionRules,
   loadProtectionConfig,
+  parseContextRule,
   protectText,
   readProtectionFile,
   restoreText,