diff options
Diffstat (limited to 'ext/js/dictionary/dictionary-worker.js')
| -rw-r--r-- | ext/js/dictionary/dictionary-worker.js | 206 |
1 files changed, 206 insertions, 0 deletions
diff --git a/ext/js/dictionary/dictionary-worker.js b/ext/js/dictionary/dictionary-worker.js new file mode 100644 index 00000000..669c65ac --- /dev/null +++ b/ext/js/dictionary/dictionary-worker.js @@ -0,0 +1,206 @@ +/* + * Copyright (C) 2023 Yomitan Authors + * Copyright (C) 2021-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/>. + */ + +import {ExtensionError} from '../core/extension-error.js'; +import {DictionaryImporterMediaLoader} from './dictionary-importer-media-loader.js'; + +export class DictionaryWorker { + constructor() { + /** @type {DictionaryImporterMediaLoader} */ + this._dictionaryImporterMediaLoader = new DictionaryImporterMediaLoader(); + } + + /** + * @param {ArrayBuffer} archiveContent + * @param {import('dictionary-importer').ImportDetails} details + * @param {?import('dictionary-worker').ImportProgressCallback} onProgress + * @returns {Promise<import('dictionary-importer').ImportResult>} + */ + importDictionary(archiveContent, details, onProgress) { + return this._invoke( + 'importDictionary', + {details, archiveContent}, + [archiveContent], + onProgress, + this._formatImportDictionaryResult.bind(this) + ); + } + + /** + * @param {string} dictionaryTitle + * @param {?import('dictionary-worker').DeleteProgressCallback} onProgress + * @returns {Promise<void>} + */ + deleteDictionary(dictionaryTitle, onProgress) { + return this._invoke('deleteDictionary', {dictionaryTitle}, [], onProgress, null); + } + + /** + * @param {string[]} dictionaryNames + * @param {boolean} getTotal + * @returns {Promise<import('dictionary-database').DictionaryCounts>} + */ + getDictionaryCounts(dictionaryNames, getTotal) { + return this._invoke('getDictionaryCounts', {dictionaryNames, getTotal}, [], null, null); + } + + // Private + + /** + * @template [TParams=import('core').SerializableObject] + * @template [TResponseRaw=unknown] + * @template [TResponse=unknown] + * @param {string} action + * @param {TParams} params + * @param {Transferable[]} transfer + * @param {?(arg: import('core').SafeAny) => void} onProgress + * @param {?(result: TResponseRaw) => TResponse} formatResult + */ + _invoke(action, params, transfer, onProgress, formatResult) { + return new Promise((resolve, reject) => { + const worker = new Worker('/js/dictionary/dictionary-worker-main.js', {type: 'module'}); + /** @type {import('dictionary-worker').InvokeDetails<TResponseRaw, TResponse>} */ + const details = { + complete: false, + worker, + resolve, + reject, + onMessage: null, + onProgress, + formatResult + }; + // Ugly typecast below due to not being able to explicitly state the template types + /** @type {(event: MessageEvent<import('dictionary-worker').MessageData<TResponseRaw>>) => void} */ + const onMessage = /** @type {(details: import('dictionary-worker').InvokeDetails<TResponseRaw, TResponse>, event: MessageEvent<import('dictionary-worker').MessageData<TResponseRaw>>) => void} */ (this._onMessage).bind(this, details); + details.onMessage = onMessage; + worker.addEventListener('message', onMessage); + worker.postMessage({action, params}, transfer); + }); + } + + /** + * @template [TResponseRaw=unknown] + * @template [TResponse=unknown] + * @param {import('dictionary-worker').InvokeDetails<TResponseRaw, TResponse>} details + * @param {MessageEvent<import('dictionary-worker').MessageData<TResponseRaw>>} event + */ + _onMessage(details, event) { + if (details.complete) { return; } + const {action, params} = event.data; + switch (action) { + case 'complete': + { + const {worker, resolve, reject, onMessage, formatResult} = details; + if (worker === null || onMessage === null || resolve === null || reject === null) { return; } + details.complete = true; + details.worker = null; + details.resolve = null; + details.reject = null; + details.onMessage = null; + details.onProgress = null; + details.formatResult = null; + worker.removeEventListener('message', onMessage); + worker.terminate(); + this._onMessageComplete(params, resolve, reject, formatResult); + } + break; + case 'progress': + this._onMessageProgress(params, details.onProgress); + break; + case 'getImageDetails': + { + const {worker} = details; + if (worker === null) { return; } + this._onMessageGetImageDetails(params, worker); + } + break; + } + } + + /** + * @template [TResponseRaw=unknown] + * @template [TResponse=unknown] + * @param {import('dictionary-worker').MessageCompleteParams<TResponseRaw>} params + * @param {(result: TResponse) => void} resolve + * @param {(reason?: import('core').RejectionReason) => void} reject + * @param {?(result: TResponseRaw) => TResponse} formatResult + */ + _onMessageComplete(params, resolve, reject, formatResult) { + const {error} = params; + if (typeof error !== 'undefined') { + reject(ExtensionError.deserialize(error)); + } else { + const {result} = params; + if (typeof formatResult === 'function') { + let result2; + try { + result2 = formatResult(result); + } catch (e) { + reject(e); + return; + } + resolve(result2); + } else { + // If formatResult is not provided, the response is assumed to be the same type + // For some reason, eslint thinks the TResponse type is undefined + // eslint-disable-next-line jsdoc/no-undefined-types + resolve(/** @type {TResponse} */ (/** @type {unknown} */ (result))); + } + } + } + + /** + * @param {import('dictionary-worker').MessageProgressParams} params + * @param {?(...args: unknown[]) => void} onProgress + */ + _onMessageProgress(params, onProgress) { + if (typeof onProgress !== 'function') { return; } + const {args} = params; + onProgress(...args); + } + + /** + * @param {import('dictionary-worker').MessageGetImageDetailsParams} params + * @param {Worker} worker + */ + async _onMessageGetImageDetails(params, worker) { + const {id, content, mediaType} = params; + /** @type {Transferable[]} */ + const transfer = []; + let response; + try { + const result = await this._dictionaryImporterMediaLoader.getImageDetails(content, mediaType, transfer); + response = {id, result}; + } catch (e) { + response = {id, error: ExtensionError.serialize(e)}; + } + worker.postMessage({action: 'getImageDetails.response', params: response}, transfer); + } + + /** + * @param {import('dictionary-worker').MessageCompleteResultSerialized} response + * @returns {import('dictionary-worker').MessageCompleteResult} + */ + _formatImportDictionaryResult(response) { + const {result, errors} = response; + return { + result, + errors: errors.map((error) => ExtensionError.deserialize(error)) + }; + } +} |