yomichan/ext/js/yomichan.js

256 lines
7.6 KiB
JavaScript
Raw Normal View History

/*
* Copyright (C) 2020-2022 Yomichan Authors
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
/* global
* API
* CrossFrameAPI
*/
// Set up chrome alias if it's not available (Edge Legacy)
if ((() => {
let hasChrome = false;
let hasBrowser = false;
try {
hasChrome = (typeof chrome === 'object' && chrome !== null && typeof chrome.runtime !== 'undefined');
} catch (e) {
// NOP
}
try {
hasBrowser = (typeof browser === 'object' && browser !== null && typeof browser.runtime !== 'undefined');
} catch (e) {
// NOP
}
return (hasBrowser && !hasChrome);
})()) {
chrome = browser;
}
/**
* The Yomichan class is a core component through which various APIs are handled and invoked.
*/
class Yomichan extends EventDispatcher {
/**
* Creates a new instance. The instance should not be used until it has been fully prepare()'d.
*/
constructor() {
super();
try {
const manifest = chrome.runtime.getManifest();
this._extensionName = `${manifest.name} v${manifest.version}`;
} catch (e) {
this._extensionName = 'Yomichan';
}
try {
this._extensionUrlBase = chrome.runtime.getURL('/');
} catch (e) {
this._extensionUrlBase = null;
}
this._isBackground = null;
this._api = null;
this._crossFrame = null;
this._isExtensionUnloaded = false;
this._isTriggeringExtensionUnloaded = false;
this._isReady = false;
const {promise, resolve} = deferPromise();
this._isBackendReadyPromise = promise;
this._isBackendReadyPromiseResolve = resolve;
this._messageHandlers = new Map([
['Yomichan.isReady', {async: false, handler: this._onMessageIsReady.bind(this)}],
['Yomichan.backendReady', {async: false, handler: this._onMessageBackendReady.bind(this)}],
['Yomichan.getUrl', {async: false, handler: this._onMessageGetUrl.bind(this)}],
['Yomichan.optionsUpdated', {async: false, handler: this._onMessageOptionsUpdated.bind(this)}],
['Yomichan.databaseUpdated', {async: false, handler: this._onMessageDatabaseUpdated.bind(this)}],
['Yomichan.zoomChanged', {async: false, handler: this._onMessageZoomChanged.bind(this)}]
]);
}
/**
* Whether the current frame is the background page/service worker or not.
* @type {boolean}
*/
get isBackground() {
return this._isBackground;
}
/**
* Whether or not the extension is unloaded.
* @type {boolean}
*/
get isExtensionUnloaded() {
return this._isExtensionUnloaded;
}
/**
* Gets the API instance for communicating with the backend.
* This value will be null on the background page/service worker.
* @type {API}
*/
get api() {
return this._api;
}
/**
* Gets the CrossFrameAPI instance for communicating with different frames.
* This value will be null on the background page/service worker.
* @type {CrossFrameAPI}
*/
get crossFrame() {
return this._crossFrame;
}
/**
* Prepares the instance for use.
* @param {boolean} [isBackground=false] Assigns whether this instance is being used from the background page/service worker.
*/
async prepare(isBackground=false) {
this._isBackground = isBackground;
chrome.runtime.onMessage.addListener(this._onMessage.bind(this));
if (!isBackground) {
this._api = new API(this);
this._crossFrame = new CrossFrameAPI();
this._crossFrame.prepare();
this.sendMessage({action: 'requestBackendReadySignal'});
await this._isBackendReadyPromise;
log.on('log', this._onForwardLog.bind(this));
}
}
/**
* Sends a message to the backend indicating that the frame is ready and all script
* setup has completed.
*/
ready() {
this._isReady = true;
this.sendMessage({action: 'yomichanReady'});
}
/**
* Checks whether or not a URL is an extension URL.
* @param {string} url The URL to check.
* @returns true if the URL is an extension URL, false otherwise.
*/
isExtensionUrl(url) {
return this._extensionUrlBase !== null && url.startsWith(this._extensionUrlBase);
}
/**
* Runs chrome.runtime.sendMessage() with additional exception handling events.
* @param {...*} args The arguments to be passed to chrome.runtime.sendMessage().
* @returns {void} The result of the chrome.runtime.sendMessage() call.
*/
sendMessage(...args) {
try {
return chrome.runtime.sendMessage(...args);
} catch (e) {
this.triggerExtensionUnloaded();
throw e;
}
}
/**
* Runs chrome.runtime.connect() with additional exception handling events.
* @param {...*} args The arguments to be passed to chrome.runtime.connect().
* @returns {Port} The resulting port.
*/
connect(...args) {
try {
return chrome.runtime.connect(...args);
} catch (e) {
this.triggerExtensionUnloaded();
throw e;
}
}
/**
* Runs chrome.runtime.connect() with additional exception handling events.
*/
triggerExtensionUnloaded() {
this._isExtensionUnloaded = true;
if (this._isTriggeringExtensionUnloaded) { return; }
try {
this._isTriggeringExtensionUnloaded = true;
this.trigger('extensionUnloaded');
} finally {
this._isTriggeringExtensionUnloaded = false;
}
}
// Private
_getUrl() {
return location.href;
}
_getLogContext() {
return {url: this._getUrl()};
}
_onMessage({action, params}, sender, callback) {
const messageHandler = this._messageHandlers.get(action);
if (typeof messageHandler === 'undefined') { return false; }
return invokeMessageHandler(messageHandler, params, callback, sender);
}
_onMessageIsReady() {
return this._isReady;
}
_onMessageBackendReady() {
if (this._isBackendReadyPromiseResolve === null) { return; }
this._isBackendReadyPromiseResolve();
this._isBackendReadyPromiseResolve = null;
}
_onMessageGetUrl() {
return {url: this._getUrl()};
}
_onMessageOptionsUpdated({source}) {
this.trigger('optionsUpdated', {source});
}
_onMessageDatabaseUpdated({type, cause}) {
this.trigger('databaseUpdated', {type, cause});
}
_onMessageZoomChanged({oldZoomFactor, newZoomFactor}) {
this.trigger('zoomChanged', {oldZoomFactor, newZoomFactor});
}
async _onForwardLog({error, level, context}) {
try {
await this._api.log(serializeError(error), level, context);
} catch (e) {
// NOP
}
}
}
/**
* The default Yomichan class instance.
*/
const yomichan = new Yomichan();