Lesson 11-Practical Application – Developing Translation Plugins

This article guides you through building a fully functional browser translation plugin from scratch, supporting word selection translation, full-page translation, multi-engine switching, and vocabulary management, covering the entire process from development to release.

Requirements Analysis and Feature Planning

Core Feature List

  1. Word Selection Translation: Automatically display translation results for selected text.
  2. Full-Page Translation: Translate entire webpage content with one click.
  3. Multi-Engine Support: Google Translate, Baidu Translate, Microsoft Translator.
  4. Vocabulary Management: Save searched words/phrases.
  5. Automatic Language Detection: Intelligently identify source language.

Technology Stack

  • Frontend Technologies: React + Material-UI (for popup UI).
  • Browser APIs: chrome.tabs, chrome.storage.
  • Translation APIs: Official platform APIs + self-hosted proxy service.

Project Initialization and Setup

Create Project Directory Structure

smart-translator-extension/
├── manifest.json          # Extension configuration file
├── popup/                 # Popup UI
│   ├── src/
│   │   ├── App.js
│   │   ├── components/
│   │   │   ├── TranslatePanel.js
│   │   │   ├── LanguageSelector.js
│   │   │   └── VocabularyList.js
│   │   ├── index.js
│   │   └── styles.css
│   ├── public/
│   │   ├── index.html
│   │   └── icons/
│   └── package.json
├── content-scripts/       # Content scripts
│   ├── translator.js      # Core translation logic
│   ├── selection.js       # Word selection functionality
│   └── pageTranslator.js  # Full-page translation
├── background/            # Background service
│   └── background.js      # Background script
├── icons/                 # Extension icons
│   ├── icon16.png
│   ├── icon48.png
│   └── icon128.png
└── proxy/                 # Proxy service (optional)
    └── server.js

Write Basic manifest.json

{
  "manifest_version": 3,
  "name": "Smart Translator Assistant",
  "version": "1.0.0",
  "description": "Multi-engine word selection translation and vocabulary management",
  "permissions": [
    "activeTab",
    "storage",
    "scripting",
    "contextMenus"
  ],
  "host_permissions": [
    "<all_urls>"
  ],
  "action": {
    "default_popup": "popup/popup.html",
    "default_icon": {
      "16": "icons/icon16.png",
      "48": "icons/icon48.png",
      "128": "icons/icon128.png"
    }
  },
  "background": {
    "service_worker": "background/background.js"
  },
  "content_scripts": [
    {
      "matches": ["<all_urls>"],
      "js": ["content-scripts/translator.js", "content-scripts/selection.js"],
      "css": ["content-scripts/translator.css"]
    }
  ],
  "context_menus": [
    {
      "id": "translate-page",
      "title": "Translate This Page",
      "contexts": ["page"]
    }
  ],
  "web_accessible_resources": [
    {
      "resources": ["popup/dist/*"],
      "matches": ["<all_urls>"]
    }
  ]
}

Core Feature Implementation

Word Selection Translation

content-scripts/selection.js

// Core logic for word selection translation
class SelectionTranslator {
  constructor() {
    this.initEventListeners();
    this.initStyle();
  }

  // Initialize event listeners
  initEventListeners() {
    document.addEventListener('mouseup', this.handleMouseUp.bind(this));
    document.addEventListener('click', this.handleClickOutside.bind(this));
  }

  // Initialize floating styles
  initStyle() {
    const style = document.createElement('style');
    style.textContent = `
      .translator-selection {
        background-color: rgba(0, 123, 255, 0.2);
        border-radius: 2px;
      }
      .translator-popup {
        position: absolute;
        background-color: white;
        border: 1px solid #ddd;
        border-radius: 4px;
        box-shadow: 0 2px 10px rgba(0, 0, 0, 0.1);
        padding: 8px;
        max-width: 300px;
        z-index: 999999;
        display: none;
      }
      .translator-popup-close {
        position: absolute;
        right: 4px;
        top: 4px;
        cursor: pointer;
      }
    `;
    document.head.appendChild(style);
  }

  // Handle mouse up event
  handleMouseUp(e) {
    const selection = window.getSelection();
    if (!selection || selection.toString().trim().length === 0) {
      this.hidePopup();
      return;
    }

    // Get selected text
    const text = selection.toString().trim();
    if (text.length > 500) {
      this.showPopup(e, 'Selected text is too long, please shorten and try again');
      return;
    }

    // Show floating popup
    this.showPopup(e, 'Translating...');

    // Send translation request
    this.translateText(text);
  }

  // Handle click outside event
  handleClickOutside(e) {
    const popup = document.querySelector('.translator-popup');
    if (popup && !popup.contains(e.target)) {
      this.hidePopup();
    }
  }

  // Show floating popup
  showPopup(event, message) {
    this.hidePopup();

    const popup = document.createElement('div');
    popup.className = 'translator-popup';
    popup.innerHTML = `
      <span class="translator-popup-close">×</span>
      <div class="translator-loading">${message}</div>
    `;

    document.body.appendChild(popup);

    // Position popup
    const rect = event.target.getBoundingClientRect();
    popup.style.left = `${rect.left + window.scrollX}px`;
    popup.style.top = `${rect.bottom + window.scrollY + 5}px`;

    // Close button event
    popup.querySelector('.translator-popup-close').addEventListener('click', () => {
      this.hidePopup();
    });

    this.currentPopup = popup;
  }

  // Hide floating popup
  hidePopup() {
    if (this.currentPopup) {
      this.currentPopup.remove();
      this.currentPopup = null;
    }
  }

  // Send translation request
  async translateText(text) {
    try {
      // Get user configuration from storage
      const { engines, targetLanguage } = await chrome.storage.sync.get(['engines', 'targetLanguage']);
      const defaultEngine = engines?.[0] || 'google';
      const lang = targetLanguage || 'zh-CN';

      // Call translation API
      const translatedText = await this.callTranslationAPI(text, defaultEngine, lang);

      // Update popup content
      if (this.currentPopup) {
        this.currentPopup.innerHTML = `
          <div class="translator-result">
            <strong>${text}</strong><br>
            <em>${translatedText}</em>
          </div>
          <div class="translator-actions">
            <button class="translator-add-vocab">Add to Vocabulary</button>
          </div>
        `;

        // Add vocabulary button event
        this.currentPopup.querySelector('.translator-add-vocab').addEventListener('click', () => {
          this.addToVocabulary(text, translatedText);
          this.hidePopup();
        });
      }
    } catch (error) {
      console.error('Translation failed:', error);
      if (this.currentPopup) {
        this.currentPopup.innerHTML = '<div class="translator-error">Translation failed, please try again</div>';
      }
    }
  }

  // Call translation API
  async callTranslationAPI(text, engine, targetLang) {
    // In actual projects, requests should be proxied through background script
    // Simplified implementation with mock API
    return new Promise((resolve) => {
      setTimeout(() => {
        // Mock translation results for different engines
        const translations = {
          google: {
            'hello': 'Hello',
            'world': 'World'
          },
          baidu: {
            'hello': 'Hello',
            'world': 'World'
          },
          microsoft: {
            'hello': 'Hello',
            'world': 'World'
          }
        };

        const result = translations[engine]?.[text.toLowerCase()] || `[${text}'s ${targetLang} translation]`;
        resolve(result);
      }, 500);
    });
  }

  // Add to vocabulary
  async addToVocabulary(word, translation) {
    const vocabulary = (await chrome.storage.local.get('vocabulary')).vocabulary || [];
    vocabulary.push({ word, translation, date: new Date().toISOString() });
    await chrome.storage.local.set({ vocabulary });
  }
}

// Initialize word selection translation
new SelectionTranslator();

Full-Page Translation

content-scripts/pageTranslator.js

// Core logic for full-page translation
class PageTranslator {
  constructor() {
    this.initContextMenu();
  }

  // Initialize context menu
  initContextMenu() {
    chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
      if (message.type === 'translate-page') {
        this.translateCurrentPage();
        sendResponse({ success: true });
      }
      return true;
    });
  }

  // Translate current page
  async translateCurrentPage() {
    try {
      // Show loading overlay
      this.showLoadingOverlay();

      // Get user configuration
      const { engines, targetLanguage } = await chrome.storage.sync.get(['engines', 'targetLanguage']);
      const defaultEngine = engines?.[0] || 'google';
      const lang = targetLanguage || 'zh-CN';

      // Get page text content
      const textNodes = this.getTextNodes(document.body);
      const textToTranslate = textNodes.map(node => node.textContent).join('\n');

      // Split into chunks (to avoid API limits)
      const chunkSize = 5000; // Max characters per chunk
      const chunks = this.splitIntoChunks(textToTranslate, chunkSize);
      const translatedChunks = [];

      for (const chunk of chunks) {
        const translated = await this.callTranslationAPI(chunk, defaultEngine, lang);
        translatedChunks.push(translated);
      }

      // Combine translated results
      const translatedText = translatedChunks.join('\n');

      // Replace page text (simplified implementation)
      this.replacePageText(textNodes, translatedText);

      // Hide loading overlay
      this.hideLoadingOverlay();
    } catch (error) {
      console.error('Full-page translation failed:', error);
      this.hideLoadingOverlay();
      alert('Full-page translation failed, please try again');
    }
  }

  // Get all text nodes in page
  getTextNodes(node) {
    const textNodes = [];
    const walker = document.createTreeWalker(
      node,
      NodeFilter.SHOW_TEXT,
      {
        acceptNode: (node) => {
          // Filter out text in script, style, etc. tags
          if (node.parentNode.nodeName.match(/^(SCRIPT|STYLE|NOSCRIPT)$/i)) {
            return NodeFilter.FILTER_REJECT;
          }
          return NodeFilter.FILTER_ACCEPT;
        }
      }
    );

    let currentNode;
    while (currentNode = walker.nextNode()) {
      if (currentNode.textContent.trim().length > 0) {
        textNodes.push(currentNode);
      }
    }

    return textNodes;
  }

  // Split text into chunks
  splitIntoChunks(text, chunkSize) {
    const chunks = [];
    for (let i = 0; i < text.length; i += chunkSize) {
      chunks.push(text.substring(i, i + chunkSize));
    }
    return chunks;
  }

  // Call translation API
  async callTranslationAPI(text, engine, targetLang) {
    // In actual projects, requests should be proxied through background script
    // Simplified implementation with mock API
    return new Promise((resolve) => {
      setTimeout(() => {
        // Mock translation result
        resolve(`[Translation Result] ${text}`);
      }, 1000);
    });
  }

  // Replace page text
  replacePageText(textNodes, translatedText) {
    // Simplified implementation: actual text replacement requires more precise logic
    textNodes.forEach(node => {
      node.textContent = '[Translated]';
    });
  }

  // Show loading overlay
  showLoadingOverlay() {
    const overlay = document.createElement('div');
    overlay.className = 'translator-loading-overlay';
    overlay.innerHTML = `
      <div class="translator-loading-spinner"></div>
      <div class="translator-loading-text">Translating...</div>
    `;

    document.body.appendChild(overlay);

    const style = document.createElement('style');
    style.textContent = `
      .translator-loading-overlay {
        position: fixed;
        top: 0;
        left: 0;
        width: 100%;
        height: 100%;
        background-color: rgba(255, 255, 255, 0.8);
        display: flex;
        flex-direction: column;
        justify-content: center;
        align-items: center;
        z-index: 999999;
      }
      .translator-loading-spinner {
        border: 4px solid rgba(0, 0, 0, 0.1);
        border-radius: 50%;
        border-top: 4px solid #007bff;
        width: 40px;
        height: 40px;
        animation: spin 1s linear infinite;
      }
      .translator-loading-text {
        margin-top: 16px;
        font-size: 16px;
        color: #333;
      }
      @keyframes spin {
        0% { transform: rotate(0deg); }
        100% { transform: rotate(360deg); }
      }
    `;
    document.head.appendChild(style);
  }

  // Hide loading overlay
  hideLoadingOverlay() {
    const overlay = document.querySelector('.translator-loading-overlay');
    if (overlay) {
      overlay.remove();
    }
  }
}

// Initialize full-page translation
new PageTranslator();

popup/src/App.js

import React, { useState, useEffect } from 'react';
import TranslatePanel from './components/TranslatePanel';
import VocabularyList from './components/VocabularyList';
import './styles.css';

function App() {
  const [activeTab, setActiveTab] = useState(null);
  const [showVocabulary, setShowVocabulary] = useState(false);
  const [loading, setLoading] = useState(true);

  useEffect(() => {
    // Get current active tab
    chrome.tabs.query({ active: true, currentWindow: true }, (tabs) => {
      if (tabs[0]) {
        setActiveTab(tabs[0]);
        setLoading(false);
      }
    });
  }, []);

  const handleTranslatePage = () => {
    chrome.runtime.sendMessage({ type: 'translate-page' });
  };

  const toggleVocabulary = () => {
    setShowVocabulary(!showVocabulary);
  };

  if (loading) {
    return <div className="loading">Loading...</div>;
  }

  return (
    <div className="translator-popup">
      <div className="translator-header">
        <h3>Smart Translator Assistant</h3>
        <div className="translator-tabs">
          <button 
            className={!showVocabulary ? 'active' : ''}
            onClick={() => setShowVocabulary(false)}
          >
            Translate
          </button>
          <button 
            className={showVocabulary ? 'active' : ''}
            onClick={toggleVocabulary}
          >
            Vocabulary
          </button>
        </div>
      </div>

      {!showVocabulary ? (
        <TranslatePanel tab={activeTab} onTranslatePage={handleTranslatePage} />
      ) : (
        <VocabularyList />
      )}
    </div>
  );
}

export default App;

popup/src/components/TranslatePanel.js

import React, { useState, useEffect } from 'react';
import LanguageSelector from './LanguageSelector';

function TranslatePanel({ tab, onTranslatePage }) {
  const [selectedText, setSelectedText] = useState('');
  const [translation, setTranslation] = useState('');
  const [sourceLanguage, setSourceLanguage] = useState('auto');
  const [targetLanguage, setTargetLanguage] = useState('zh-CN');
  const [engines, setEngines] = useState(['google', 'baidu', 'microsoft']);
  const [selectedEngine, setSelectedEngine] = useState('google');

  useEffect(() => {
    // Get user settings
    chrome.storage.sync.get(['targetLanguage', 'engines'], (result) => {
      if (result.targetLanguage) {
        setTargetLanguage(result.targetLanguage);
      }
      if (result.engines) {
        setEngines(result.engines);
        if (result.engines.length > 0) {
          setSelectedEngine(result.engines[0]);
        }
      }
    });
  }, []);

  const handleTextSelect = (e) => {
    // In actual projects, selected text should be obtained via content script communication
    // Simplified implementation
    setSelectedText('Sample selected text');
    translateText('Sample selected text');
  };

  const translateText = (text) => {
    // In actual projects, requests should be proxied through background script
    // Simplified implementation
    setTimeout(() => {
      setTranslation(`[${selectedEngine}] ${text}'s translation result`);
    }, 500);
  };

  const handleTranslatePage = () => {
    onTranslatePage();
  };

  return (
    <div className="translate-panel">
      <div className="translate-controls">
        <button onClick={handleTranslatePage}>Translate This Page</button>
        <button onClick={handleTextSelect}>Simulate Word Selection Translation</button>
      </div>

      <div className="translate-input">
        <textarea 
          value={selectedText}
          placeholder="Select text to translate automatically..."
          readOnly
        />
      </div>

      <div className="translate-settings">
        <LanguageSelector 
          label="Source Language"
          value={sourceLanguage}
          onChange={setSourceLanguage}
          includeAuto={true}
        />
        <LanguageSelector 
          label="Target Language"
          value={targetLanguage}
          onChange={setTargetLanguage}
          includeAuto={false}
        />
        <div className="engine-selector">
          <label>Translation Engine:</label>
          <select 
            value={selectedEngine}
            onChange={(e) => setSelectedEngine(e.target.value)}
          >
            {engines.map(engine => (
              <option key={engine} value={engine}>
                {engine.charAt(0).toUpperCase() + engine.slice(1)}
              </option>
            ))}
          </select>
        </div>
      </div>

      {translation && (
        <div className="translate-result">
          <h4>Translation Result:</h4>
          <div className="result-text">{translation}</div>
        </div>
      )}
    </div>
  );
}

export default TranslatePanel;

Packaging and Release Process

Local Testing of the Extension

  1. Open Chrome browser and navigate to chrome://extensions/.
  2. Enable “Developer mode”.
  3. Click “Load unpacked” and select the project root directory smart-translator-extension.

Packaging the Extension

  1. In the Extensions management page, click “Pack extension”.
  2. Select the extension root directory.
  3. Set the private key file (generated automatically on first pack).
  4. Click “Pack” button.
  5. Obtain the generated .crx and .pem files.

Publishing to Chrome Web Store

  1. Register a Google Developer account ($5 one-time fee).
  2. Go to the Chrome Developer Console.
  3. Create a new project.
  4. Upload the packaged .crx file.
  5. Provide extension details:
    • Detailed description (supports HTML format).
    • High-quality screenshots (at least 4, various sizes).
    • Feature icons (16×16, 48×48, 128×128).
    • Category selection (Tools > Translation).
    • Privacy policy link.
  6. Submit for review (typically takes 1-7 days).

Advanced Optimization Directions

  1. Performance Optimization:
    • Use Web Workers for large text translation.
    • Implement translation caching mechanism.
    • Optimize DOM manipulation performance.
  2. Feature Enhancements:
    • Add pronunciation functionality (using TTS API).
    • Support PDF document translation.
    • Implement translation history records.
  3. User Experience Improvements:
    • Add keyboard shortcut support (Ctrl+Shift+T for quick translation).
    • Highlight translation results.
    • Support custom translation engine API keys.
  4. Multilingual Support:
    • Interface internationalization (i18n).
    • Automatically detect user system language.
    • Support more language pairs.

Through this practical project, you not only master the core technologies of browser extension development but also learn how to build a practical translation tool. A great extension should balance performance, privacy, and user experience while maintaining simplicity and usability.

Share your love