port_for_chromium

background-script.js

@@ -1,7 +1,155 @@
 // Copyright 2017; Licensed under the Apache License, Version 2.0: https://www.apache.org/licenses/LICENSE-2.0
 
 'use strict';
+if (typeof globalThis.browser === "undefined" && typeof chrome !== "undefined") {
+    globalThis.browser = {
+        ...chrome,
 
+        runtime: {
+            ...chrome.runtime,
+
+            sendMessage: function(message) {
+                return new Promise((resolve, reject) => {
+                    chrome.runtime.sendMessage(message, response => {
+                        const err = chrome.runtime.lastError;
+
+                        // Chrome sets lastError when a message intentionally has no direct response.
+                        // Firefox-style Nazeka code often uses async side-channel replies instead.
+                        if (err) {
+                            console.warn("Nazeka sendMessage warning:", err.message);
+                            resolve(undefined);
+                        } else {
+                            resolve(response);
+                        }
+                    });
+                });
+            },
+
+            getPlatformInfo: function() {
+                return new Promise((resolve, reject) => {
+                    chrome.runtime.getPlatformInfo(info => {
+                        const err = chrome.runtime.lastError;
+                        if (err) reject(err);
+                        else resolve(info);
+                    });
+                });
+            },
+
+            getURL: chrome.runtime.getURL.bind(chrome.runtime),
+
+            onMessage: {
+                addListener: function(listener) {
+                    chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
+                        try {
+                            const result = listener(message, sender);
+
+                            if (result && typeof result.then === "function") {
+                                result.then(sendResponse).catch(error => {
+                                    console.error("Nazeka message listener error:", error);
+                                    sendResponse(undefined);
+                                });
+                                return true;
+                            }
+
+                            if (result !== undefined) {
+                                sendResponse(result);
+                            }
+
+                            return false;
+                        } catch (error) {
+                            console.error("Nazeka message listener exception:", error);
+                            sendResponse(undefined);
+                            return false;
+                        }
+                    });
+                }
+            }
+        },
+
+        storage: {
+            ...chrome.storage,
+
+            local: {
+                ...chrome.storage.local,
+
+                get: function(keys) {
+                    return new Promise((resolve, reject) => {
+                        chrome.storage.local.get(keys, result => {
+                            const err = chrome.runtime.lastError;
+                            if (err) reject(err);
+                            else resolve(result);
+                        });
+                    });
+                },
+
+                set: function(items) {
+                    return new Promise((resolve, reject) => {
+                        chrome.storage.local.set(items, () => {
+                            const err = chrome.runtime.lastError;
+                            if (err) reject(err);
+                            else resolve();
+                        });
+                    });
+                },
+
+                remove: function(keys) {
+                    return new Promise((resolve, reject) => {
+                        chrome.storage.local.remove(keys, () => {
+                            const err = chrome.runtime.lastError;
+                            if (err) reject(err);
+                            else resolve();
+                        });
+                    });
+                }
+            },
+
+            onChanged: chrome.storage.onChanged
+        },
+
+        tabs: chrome.tabs ? {
+            ...chrome.tabs,
+
+                getCurrent: function() {
+                return new Promise((resolve, reject) => {
+            chrome.tabs.getCurrent(tab => {
+                const err = chrome.runtime.lastError;
+                if (err) reject(err);
+                else resolve(tab);
+            });
+        });
+    },
+
+    sendMessage: function(tabId, message) {
+        return new Promise((resolve, reject) => {
+            chrome.tabs.sendMessage(tabId, message, response => {
+                const err = chrome.runtime.lastError;
+                if (err) {
+                    console.warn("Nazeka tabs.sendMessage warning:", err.message);
+                    resolve(undefined);
+                } else {
+                    resolve(response);
+                }
+            });
+        });
+    },
+
+    create: chrome.tabs.create.bind(chrome.tabs)
+} : undefined,
+
+       windows: chrome.windows ? {
+    ...chrome.windows,
+    create: chrome.windows.create.bind(chrome.windows)
+} : undefined,
+
+        extension: {
+            ...chrome.extension,
+            getURL: chrome.runtime.getURL.bind(chrome.runtime)
+        },
+
+        browserAction: chrome.browserAction || undefined,
+contextMenus: chrome.contextMenus || undefined
+    };
+}
 // updated by a timer looping function, based on local storage set by the options page
 // we only use a tiny number of settings here
 
@@ -281,6 +429,8 @@ load_part_of_dictionary("dict/JMdict8.json");
 load_part_of_dictionary("dict/JMdict9.json");
 load_part_of_dictionary("dict/JMdict10.json");
 load_part_of_dictionary("dict/JMdict11.json");
+load_part_of_dictionary("dict/JMdict12.json");
+load_part_of_dictionary("dict/JMdict13.json");
 
 load_jdic_audio_table("dict/jdic audio.txt");
 
@@ -325,7 +475,7 @@ function buildlookups()
 let waiter = undefined;
 function waittobuildlookups()
 {
-    if(dictsloaded == 11)
+    if(dictsloaded == 13)
     {
         clearInterval(waiter);
         waiter = undefined;
@@ -2104,10 +2254,9 @@ browser.contextMenus.create({
     id: "nazeka-toggle",
     title: "Toggle Nazeka",
     contexts: ["page", "selection"],
-    documentUrlPatterns: ["moz-extension://*/reader.html"],
+    documentUrlPatterns: ["chrome-extension://*/reader.html"],
     onclick: toggle_enabled
 });
-
 function sleep(ms)
 {
     return new Promise(resolve => setTimeout(resolve, ms));