Repository navigation
Expand file tree
/
Copy pathbackground.js
More file actions
127 lines (117 loc) · 5.2 KB
/
Copy pathbackground.js
File metadata and controls
127 lines (117 loc) · 5.2 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
import { isLanguage, normalizeSettings, validateSettings } from './languages.js';
import { isMapsUrl, languageRules, tabLanguage, withLanguage } from './redirects.js';
const dnr = chrome.declarativeNetRequest;
const readSettings = async () => normalizeSettings((await chrome.storage.local.get('settings')).settings);
async function installDefault(language) {
const rules = await dnr.getDynamicRules();
await dnr.updateDynamicRules({ removeRuleIds: rules.map(rule => rule.id), addRules: languageRules(language) });
}
async function initialize() {
const settings = await readSettings();
await installDefault(settings.defaultLanguage);
await chrome.storage.local.set({ settings });
// Session rules survive worker suspension. Only discard rules for closed tabs.
const tabs = new Set((await chrome.tabs.query({})).map(tab => tab.id));
const stale = (await dnr.getSessionRules()).filter(rule => !tabs.has(rule.condition.tabIds?.[0]));
if (stale.length) await dnr.updateSessionRules({ removeRuleIds: stale.map(rule => rule.id) });
}
// Serialize settings and tab-rule mutations so rapid selections cannot race.
let queue = initialize();
function enqueue(work) {
const result = queue.then(work);
queue = result.catch(error => console.error(error));
return result;
}
// Attach a rejection handler even if no UI is open when initialization fails.
queue = queue.catch(error => console.error(error));
async function saveSettings(value) {
const settings = validateSettings(value);
const previous = await readSettings();
await installDefault(settings.defaultLanguage);
try {
await chrome.storage.local.set({ settings });
} catch (error) {
await installDefault(previous.defaultLanguage);
throw error;
}
return settings;
}
async function clearTab(tabId) {
const rules = (await dnr.getSessionRules()).filter(rule => rule.condition.tabIds?.includes(tabId));
if (rules.length) await dnr.updateSessionRules({ removeRuleIds: rules.map(rule => rule.id) });
}
async function setTabLanguage(tabId, language) {
const rules = await dnr.getSessionRules();
const old = rules.filter(rule => rule.condition.tabIds?.includes(tabId));
const firstId = old.length ? Math.min(...old.map(rule => rule.id))
: Math.max(99, ...rules.map(rule => rule.id)) + 1;
await dnr.updateSessionRules({
removeRuleIds: old.map(rule => rule.id),
addRules: languageRules(language, { firstId, priority: 10, tabId }),
});
}
async function getState(tabId) {
const settings = await readSettings();
let tab;
if (Number.isInteger(tabId) && tabId >= 0) {
try { tab = await chrome.tabs.get(tabId); } catch { /* Tab was closed. */ }
}
const temporaryLanguage = tabLanguage(await dnr.getSessionRules(), tabId);
return {
settings,
canApply: isMapsUrl(tab?.pendingUrl || tab?.url),
language: temporaryLanguage || settings.defaultLanguage,
temporary: Boolean(temporaryLanguage),
};
}
async function handle(message) {
switch (message.type) {
case 'getState': return getState(message.tabId);
case 'saveSettings': return { settings: await saveSettings(message.settings) };
case 'selectLanguage': {
if (!isLanguage(message.language) || typeof message.persistent !== 'boolean'
|| !Number.isInteger(message.tabId) || message.tabId < 0) throw new Error('invalidSelection');
const tab = await chrome.tabs.get(message.tabId);
if (!isMapsUrl(tab.pendingUrl || tab.url)) throw new Error('notMaps');
if (message.persistent) {
await saveSettings({ ...await readSettings(), defaultLanguage: message.language });
await clearTab(tab.id);
} else {
await setTabLanguage(tab.id, message.language);
}
// Re-read in case the user navigated while rules were being updated.
const current = await chrome.tabs.get(tab.id);
const url = current.pendingUrl || current.url;
if (isMapsUrl(url)) {
const next = withLanguage(url, message.language);
if (next !== url) await chrome.tabs.update(tab.id, { url: next });
}
return getState(tab.id);
}
case 'useDefault': {
if (!Number.isInteger(message.tabId) || message.tabId < 0) throw new Error('invalidSelection');
await clearTab(message.tabId);
const tab = await chrome.tabs.get(message.tabId);
const url = tab.pendingUrl || tab.url;
if (isMapsUrl(url)) {
const { defaultLanguage } = await readSettings();
const next = withLanguage(url, defaultLanguage);
if (next !== url) await chrome.tabs.update(tab.id, { url: next });
}
return getState(tab.id);
}
default: throw new Error('unknownMessage');
}
}
chrome.runtime.onMessage.addListener((message, sender, respond) => {
// Accept commands only from this extension's own pages.
if (sender.id !== chrome.runtime.id || !sender.url?.startsWith(chrome.runtime.getURL(''))) return;
enqueue(() => handle(message)).then(
data => respond({ ok: true, ...data }),
error => respond({ ok: false, error: error.message }),
);
return true;
});
chrome.tabs.onRemoved.addListener(tabId => { void enqueue(() => clearTab(tabId)); });
chrome.runtime.onInstalled.addListener(() => { void enqueue(initialize); });
chrome.runtime.onStartup.addListener(() => { void enqueue(initialize); });