#home-search-entry {
    outline: 4px solid rgb(229, 231, 235);
  }

.dark #home-search-entry {
    outline: 4px solid rgb(44, 44, 44);
  }

const { Translate } = require('@google-cloud/translate').v2;
const fs = require('fs').promises;
const path = require('path');
const matter = require('gray-matter');
const glob = require('glob');

const languages = ['es', 'ja', 'pt-BR'];

const translate = new Translate();

async function translateText(text, targetLanguage) {
  try {
    const [translation] = await translate.translate(text, {
      to: targetLanguage,
      format: 'text' // this is needed to preserve newlines
    });
    return translation;
  } catch (error) {
    console.error('Translation error:', error);
    return text;
  }
}

async function translateMDXFile(filePath, targetLanguage) {
  try {
    let newHeader = '';
    let body = '';
    const content = await fs.readFile(filePath, 'utf8');
    // process content by line
    const lines = content.split('\n');
    let isHeader = false;
    for (const line of lines) {
      if (line.startsWith('---')) {
        isHeader = !isHeader;
        newHeader += line + '\n';
        continue;
      }
      // handle header separately. especially we don't want to mess with groups
      if (isHeader) {
        if (line.startsWith('title:')) {
          const [, title] = line.split(':');
          newHeader += `title: ${await translateText(title, targetLanguage)}\n`;
        } else if (line.startsWith('description:')) {
          const [, description] = line.split(':');
          newHeader += `description: ${await translateText(description, targetLanguage)}\n`;
        } else {
          // keep the line as is
          newHeader += line + '\n';
        }
      } else {
        body += line + '\n';
      }
    }
    
    const { data: frontmatter, content: markdownContent } = matter(body);
    const translatedBody = await translateText(markdownContent, targetLanguage);

    const relativePath = path.relative(process.cwd(), filePath);
    const newPath = path.join(targetLanguage, relativePath);
    
    await fs.mkdir(path.dirname(newPath), { recursive: true });
    const translatedFile = matter.stringify(translatedBody, frontmatter);
    await fs.writeFile(newPath, newHeader + translatedFile);
    
    console.log(`Translated: ${filePath} -> ${newPath}`);
  } catch (error) {
    console.error(`Error processing ${filePath}:`, error);
  }
}

function shouldTranslate(file) {
  if (!file.endsWith('.mdx')) {
    console.warn(`Skipping ${file}: not an MDX file`);
    return false;
  }
  for (const language of languages) {
    if (file.startsWith(language + '/')) {
      console.warn(`Skipping ${file}: already in localized directory ${language}`);
      return false;
    }
  }
  return true;
}

async function main() {
  try {
    // Check for Google Cloud credentials
    if (!process.env.GOOGLE_APPLICATION_CREDENTIALS) {
      console.error('Error: GOOGLE_APPLICATION_CREDENTIALS environment variable is not set');
      console.error('Please set it to the path of your Google Cloud service account key file');
      process.exit(1);
    }

    // Get files from command line arguments or use glob pattern
    const files = process.argv.slice(2).length > 0
      ? process.argv.slice(2)
      : glob.sync('**/*.mdx', { ignore: 'es/**/*.mdx' });
    
    if (files.length === 0) {
      console.log('No MDX files found to translate');
      return;
    }

    console.log(`Found ${files.length} files to translate`);
    
    for (const file of files) {
      if (shouldTranslate(file)) {
        for (const language of languages) {
          await translateMDXFile(file, language);
        }
      }
    }
  } catch (error) {
    console.error('Error in main process:', error);
    process.exit(1);
  }
}

// Allow running directly from command line
if (require.main === module) {
  main();
} 

Overview

Account Risk

Card Spending Risk

Funding Risk

Transaction Monitoring