/*
* Copyright (C) 2023 Yomitan Authors
* Copyright (C) 2019-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 .
*/
import {EventListenerCollection} from '../core.js';
import {toError} from '../core/to-error.js';
/**
* This class is used to connect Yomitan to a native component that is
* used to parse text into individual terms.
*/
export class Mecab {
/**
* Creates a new instance of the class.
*/
constructor() {
/** @type {?chrome.runtime.Port} */
this._port = null;
/** @type {number} */
this._sequence = 0;
/** @type {Map void, reject: (reason?: unknown) => void, timer: import('core').Timeout}>} */
this._invocations = new Map();
/** @type {EventListenerCollection} */
this._eventListeners = new EventListenerCollection();
/** @type {number} */
this._timeout = 5000;
/** @type {number} */
this._version = 1;
/** @type {?number} */
this._remoteVersion = null;
/** @type {boolean} */
this._enabled = false;
/** @type {?Promise} */
this._setupPortPromise = null;
}
/**
* Returns whether or not the component is enabled.
* @returns {boolean} Whether or not the object is enabled.
*/
isEnabled() {
return this._enabled;
}
/**
* Changes whether or not the component connection is enabled.
* @param {boolean} enabled A boolean indicating whether or not the component should be enabled.
*/
setEnabled(enabled) {
this._enabled = !!enabled;
if (!this._enabled && this._port !== null) {
this._clearPort();
}
}
/**
* Disconnects the current port, but does not disable future connections.
*/
disconnect() {
if (this._port !== null) {
this._clearPort();
}
}
/**
* Returns whether or not the connection to the native application is active.
* @returns {boolean} `true` if the connection is active, `false` otherwise.
*/
isConnected() {
return (this._port !== null);
}
/**
* Returns whether or not any invocation is currently active.
* @returns {boolean} `true` if an invocation is active, `false` otherwise.
*/
isActive() {
return (this._invocations.size > 0);
}
/**
* Gets the local API version being used.
* @returns {number} An integer representing the API version that Yomitan uses.
*/
getLocalVersion() {
return this._version;
}
/**
* Gets the version of the MeCab component.
* @returns {Promise} The version of the MeCab component, or `null` if the component was not found.
*/
async getVersion() {
try {
await this._setupPortWrapper();
} catch (e) {
// NOP
}
return this._remoteVersion;
}
/**
* Parses a string of Japanese text into arrays of lines and terms.
*
* Return value format:
* ```js
* [
* {
* name: (string),
* lines: [
* {term: (string), reading: (string), source: (string)},
* ...
* ]
* },
* ...
* ]
* ```
* @param {string} text The string to parse.
* @returns {Promise} A collection of parsing results of the text.
*/
async parseText(text) {
await this._setupPortWrapper();
const rawResults = await this._invoke('parse_text', {text});
// Note: The format of rawResults is not validated
return this._convertParseTextResults(/** @type {import('mecab').ParseResultRaw} */ (rawResults));
}
// Private
/**
* @param {unknown} message
*/
_onMessage(message) {
if (typeof message !== 'object' || message === null) { return; }
const {sequence, data} = /** @type {import('core').SerializableObject} */ (message);
if (typeof sequence !== 'number') { return; }
const invocation = this._invocations.get(sequence);
if (typeof invocation === 'undefined') { return; }
const {resolve, timer} = invocation;
clearTimeout(timer);
resolve(data);
this._invocations.delete(sequence);
}
/**
* @returns {void}
*/
_onDisconnect() {
if (this._port === null) { return; }
const e = chrome.runtime.lastError;
const error = new Error(e ? e.message : 'MeCab disconnected');
for (const {reject, timer} of this._invocations.values()) {
clearTimeout(timer);
reject(error);
}
this._clearPort();
}
/**
* @param {string} action
* @param {import('core').SerializableObject} params
* @returns {Promise}
*/
_invoke(action, params) {
return new Promise((resolve, reject) => {
if (this._port === null) {
reject(new Error('Port disconnected'));
return;
}
const sequence = this._sequence++;
const timer = setTimeout(() => {
this._invocations.delete(sequence);
reject(new Error(`MeCab invoke timed out after ${this._timeout}ms`));
}, this._timeout);
this._invocations.set(sequence, {resolve, reject, timer});
this._port.postMessage({action, params, sequence});
});
}
/**
* @param {import('mecab').ParseResultRaw} rawResults
* @returns {import('mecab').ParseResult[]}
*/
_convertParseTextResults(rawResults) {
/** @type {import('mecab').ParseResult[]} */
const results = [];
for (const [name, rawLines] of Object.entries(rawResults)) {
/** @type {import('mecab').ParseFragment[][]} */
const lines = [];
for (const rawLine of rawLines) {
const line = [];
for (let {expression: term, reading, source} of rawLine) {
if (typeof term !== 'string') { term = ''; }
if (typeof reading !== 'string') { reading = ''; }
if (typeof source !== 'string') { source = ''; }
line.push({term, reading, source});
}
lines.push(line);
}
results.push({name, lines});
}
return results;
}
/**
* @returns {Promise}
*/
async _setupPortWrapper() {
if (!this._enabled) {
throw new Error('MeCab not enabled');
}
if (this._setupPortPromise === null) {
this._setupPortPromise = this._setupPort();
}
try {
await this._setupPortPromise;
} catch (e) {
throw toError(e);
}
}
/**
* @returns {Promise}
*/
async _setupPort() {
const port = chrome.runtime.connectNative('yomitan_mecab');
this._eventListeners.addListener(port.onMessage, this._onMessage.bind(this));
this._eventListeners.addListener(port.onDisconnect, this._onDisconnect.bind(this));
this._port = port;
try {
const data = await this._invoke('get_version', {});
if (typeof data !== 'object' || data === null) {
throw new Error('Invalid version');
}
const {version} = /** @type {import('core').SerializableObject} */ (data);
if (typeof version !== 'number') {
throw new Error('Invalid version');
}
this._remoteVersion = version;
if (version !== this._version) {
throw new Error(`Unsupported MeCab native messenger version ${version}. Yomitan supports version ${this._version}.`);
}
} catch (e) {
if (this._port === port) {
this._clearPort();
}
throw e;
}
}
/**
* @returns {void}
*/
_clearPort() {
if (this._port !== null) {
this._port.disconnect();
this._port = null;
}
this._invocations.clear();
this._eventListeners.removeAllEventListeners();
this._sequence = 0;
this._setupPortPromise = null;
}
}