path: root/ext/js/comm/mecab.js

/*
 * Copyright (C) 2023-2024  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 <https://www.gnu.org/licenses/>.
 */

import {EventListenerCollection} from '../core/event-listener-collection.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<number, {resolve: (value: unknown) => 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<void>} */
        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<?number>} 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<import('mecab').ParseResult[]>} 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<unknown>}
     */
    _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<void>}
     */
    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<void>}
     */
    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;
    }
}