bctranslate 1.0.0 → 1.0.2

package/src/utils.js

@@ -1,18 +1,99 @@
 import { createHash } from 'crypto';
+import { basename, extname } from 'path';
+
+// Words too generic to use as the sole semantic component of a key
+const STOP_WORDS = new Set([
+  'a', 'an', 'the', 'is', 'are', 'was', 'were', 'be', 'been', 'being',
+  'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would', 'shall',
+  'should', 'may', 'might', 'must', 'can', 'could',
+  'to', 'for', 'and', 'or', 'but', 'of', 'in', 'on', 'at', 'by',
+  'as', 'if', 'its', 'it', 'this', 'that', 'these', 'those',
+  'my', 'your', 'our', 'their', 'with', 'from', 'up', 'about',
+  'no', 'not', 'so',
+]);
 
 /**
- * Generate a deterministic, short key from a string.
- * Same input always produces the same key — idempotent across runs.
+ * Generate a readable, slug-based i18n key from a string.
+ * "Submit" → "submit"
+ * "Please enter your email" → "please_enter_your_email"
+ * Falls back to a hash prefix for non-Latin or symbol-only strings.
  */
-export function hashKey(text) {
-  const normalized = text.trim().toLowerCase().replace(/\s+/g, ' ');
-  const hash = createHash('sha256').update(normalized).digest('hex').slice(0, 8);
-  return `key_${hash}`;
-}
+export function textKey(text) {
+  const trimmed = text.trim();
+
+  const slug = trimmed
+    .toLowerCase()
+    .replace(/[^\w\s]/g, ' ')   // punctuation → space
+    .replace(/\s+/g, '_')        // spaces → underscores
+    .replace(/^[^a-z]+/, '')     // strip non-alpha prefix
+    .replace(/[^a-z0-9_]/g, '') // remove remaining non-ASCII
+    .replace(/_+/g, '_')         // collapse multiple underscores
+    .replace(/^_|_$/g, '')       // trim underscores
+    .slice(0, 40)
+    .replace(/_+$/, '');
+
+  if (slug && slug.length >= 2 && /[a-z]/.test(slug)) {
+    return slug;
+  }
+
+  // Fallback: hash (for Chinese, Arabic, emoji, symbols, etc.)
+  const hash = createHash('sha256').update(trimmed).digest('hex').slice(0, 8);
+  return `key_${hash}`;
+}
+
+/**
+ * Generate a context-aware i18n key using the component name as namespace
+ * and key content words as the slug.
+ *
+ * "Notes"           in HomeView.vue  → home.notes
+ * "Quick Note"      in HomeView.vue  → home.quickNote
+ * "View livestock"  in HomeView.vue  → home.viewLivestock
+ * "Submit"          in LoginForm.vue → loginForm.submit
+ * "你好"             in App.vue       → app.key_3d2a1f
+ *
+ * @param {string} text     The source string to key
+ * @param {string} filePath Absolute or relative path of the source file
+ */
+export function contextKey(text, filePath) {
+  const trimmed = text.trim();
+
+  // ── Namespace: derive from filename ──────────────────────────────────────
+  const fileName = basename(filePath, extname(filePath));
+  // Strip common Vue/React suffixes: HomeView → Home, UserCard → User, etc.
+  const stripped = fileName.replace(
+    /(?:View|Component|Page|Screen|Modal|Dialog|Card|Panel|Widget|Layout|Container)$/,
+    ''
+  ) || fileName;
+  // camelCase namespace: "UserProfile" → "userProfile", "home" → "home"
+  const ns = stripped[0].toLowerCase() + stripped.slice(1);
+
+  // ── Slug: 1-3 meaningful words in camelCase ───────────────────────────────
+  const words = trimmed
+    .replace(/[^\w\s]/g, ' ')
+    .split(/\s+/)
+    .map((w) => w.toLowerCase())
+    .filter((w) => w.length >= 2 && /[a-z]/.test(w) && !STOP_WORDS.has(w));
+
+  if (!words.length) {
+    // Non-Latin scripts, emoji, or all stop words — fall back to hash suffix
+    const hash = createHash('sha256').update(trimmed).digest('hex').slice(0, 6);
+    return `${ns}.key${hash}`;
+  }
+
+  const slug =
+    words[0] + words.slice(1, 3).map((w) => w[0].toUpperCase() + w.slice(1)).join('');
+
+  return `${ns}.${slug}`;
+}
 
 /**
- * Determine if a string is "translatable" — i.e. it contains actual
- * human-readable text and not just whitespace, numbers, symbols, or code.
+ * @deprecated Use contextKey() for new code. textKey() kept for non-file contexts.
+ */
+export const hashKey = textKey;
+
+/**
+ * Determine if a string is "translatable" — contains actual human-readable
+ * text rather than whitespace, numbers, symbols, or code identifiers.
  */
 export function isTranslatable(text) {
   if (!text || typeof text !== 'string') return false;
@@ -27,15 +108,19 @@ export function isTranslatable(text) {
   if (/^[\d.,]+$/.test(trimmed)) return false;
 
   // Skip single characters that are punctuation/symbols
-  if (trimmed.length === 1 && /[^a-zA-Z\u00C0-\u024F\u0400-\u04FF\u4e00-\u9fff\u3040-\u309f\u30a0-\u30ff]/.test(trimmed)) return false;
+  if (
+    trimmed.length === 1 &&
+    /[^a-zA-Z\u00C0-\u024F\u0400-\u04FF\u4e00-\u9fff\u3040-\u309f\u30a0-\u30ff]/.test(trimmed)
+  )
+    return false;
 
-  // Skip things that look like code identifiers (camelCase, snake_case with no spaces)
+  // Skip code identifiers (camelCase, snake_case with no spaces)
   if (/^[a-zA-Z_$][a-zA-Z0-9_$.]*$/.test(trimmed) && !trimmed.includes(' ') && trimmed.length > 1) {
-    // But allow single real words (check if it has vowels or is a common word)
+    // Allow capitalised real words: "Submit", "Cancel", "Home"
     if (/[aeiouAEIOU]/.test(trimmed) && trimmed.length > 2 && /^[A-Z][a-z]+$/.test(trimmed)) {
-      return true; // Likely a real word like "Submit", "Cancel", "Home"
+      return true;
     }
-    // Allow ALL CAPS short words (likely labels)
+    // Allow ALL-CAPS short labels: "OK", "FAQ"
     if (/^[A-Z]{2,12}$/.test(trimmed)) return true;
     return false;
   }
@@ -44,29 +129,80 @@ export function isTranslatable(text) {
   if (/^(https?:\/\/|\/|\.\/|\.\.\/)/.test(trimmed)) return false;
   if (/^[\w.+-]+@[\w.-]+\.\w+$/.test(trimmed)) return false;
 
-  // Skip template expressions that are purely code ({{ something }})
+  // Skip pure template expressions {{ something }}
   if (/^\{\{[^}]+\}\}$/.test(trimmed)) return false;
 
   // Must contain at least one letter from any script
-  if (!/[a-zA-Z\u00C0-\u024F\u0400-\u04FF\u4e00-\u9fff\u3040-\u309f\u30a0-\u30ff\uAC00-\uD7AF]/.test(trimmed)) return false;
+  if (
+    !/[a-zA-Z\u00C0-\u024F\u0400-\u04FF\u4e00-\u9fff\u3040-\u309f\u30a0-\u30ff\uAC00-\uD7AF]/.test(
+      trimmed
+    )
+  )
+    return false;
 
   return true;
 }
 
 /**
- * Check if a string contains interpolation expressions ({{ }}, {}, ${}).
- * Returns the parts if so.
+ * Shield interpolation variables before sending to Argos Translate.
+ * Replaces {{ name }}, {name}, ${name}, %{name} with XML-like tokens <xi/>
+ * that NMT models are trained to preserve verbatim.
+ *
+ * Returns { shielded, tokens } — call unshieldInterpolations() to restore.
+ */
+export function shieldInterpolations(text) {
+  const tokens = [];
+  let shielded = text;
+
+  // Vue {{ expr }} — must come first to avoid matching inner {
+  shielded = shielded.replace(/\{\{[^}]*\}\}/g, (m) => {
+    const i = tokens.length;
+    tokens.push(m);
+    return `<x${i}/>`;
+  });
+
+  // Template literal ${expr}
+  shielded = shielded.replace(/\$\{[^}]*\}/g, (m) => {
+    const i = tokens.length;
+    tokens.push(m);
+    return `<x${i}/>`;
+  });
+
+  // i18next / vue-i18n {varName} or {0}
+  shielded = shielded.replace(/\{[^{}\s][^{}]*\}/g, (m) => {
+    const i = tokens.length;
+    tokens.push(m);
+    return `<x${i}/>`;
+  });
+
+  // Ruby / Rails %{varName}
+  shielded = shielded.replace(/%\{[^}]+\}/g, (m) => {
+    const i = tokens.length;
+    tokens.push(m);
+    return `<x${i}/>`;
+  });
+
+  return { shielded, tokens };
+}
+
+/**
+ * Restore interpolation variables after translation.
+ * Tolerates minor whitespace changes the MT model may introduce.
+ */
+export function unshieldInterpolations(text, tokens) {
+  if (!tokens || tokens.length === 0) return text;
+  return text.replace(/<x(\d+)\s*\/>/gi, (_, idx) => tokens[parseInt(idx, 10)] ?? '');
+}
+
+/**
+ * Check if a string contains interpolation expressions.
  */
 export function parseInterpolation(text) {
-  // Vue-style {{ expr }}
   const vuePattern = /\{\{\s*([^}]+?)\s*\}\}/g;
-  // React/JS-style {expr} or ${expr}
-  const jsPattern = /\$?\{([^}]+)\}/g;
 
   const parts = [];
   let hasInterpolation = false;
 
-  // Check for Vue interpolation
   if (vuePattern.test(text)) {
     hasInterpolation = true;
     vuePattern.lastIndex = 0;
@@ -88,4 +224,4 @@ export function parseInterpolation(text) {
   }
 
   return { hasInterpolation, parts };
-}
+}