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
- Word Selection Translation: Automatically display translation results for selected text.
- Full-Page Translation: Translate entire webpage content with one click.
- Multi-Engine Support: Google Translate, Baidu Translate, Microsoft Translator.
- Vocabulary Management: Save searched words/phrases.
- 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.jsWrite 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 UI Implementation
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
- Open Chrome browser and navigate to
chrome://extensions/. - Enable “Developer mode”.
- Click “Load unpacked” and select the project root directory
smart-translator-extension.
Packaging the Extension
- In the Extensions management page, click “Pack extension”.
- Select the extension root directory.
- Set the private key file (generated automatically on first pack).
- Click “Pack” button.
- Obtain the generated
.crxand.pemfiles.
Publishing to Chrome Web Store
- Register a Google Developer account ($5 one-time fee).
- Go to the Chrome Developer Console.
- Create a new project.
- Upload the packaged
.crxfile. - 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.
- Submit for review (typically takes 1-7 days).
Advanced Optimization Directions
- Performance Optimization:
- Use Web Workers for large text translation.
- Implement translation caching mechanism.
- Optimize DOM manipulation performance.
- Feature Enhancements:
- Add pronunciation functionality (using TTS API).
- Support PDF document translation.
- Implement translation history records.
- User Experience Improvements:
- Add keyboard shortcut support (Ctrl+Shift+T for quick translation).
- Highlight translation results.
- Support custom translation engine API keys.
- 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.



