Something went wrong. Try again.
Pop-up dictionary browser extension for language learning. Successor to Yomichan. (PERSONAL FORK)
Something went wrong. Try again.
JavaScript
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288/* * Copyright (C) 2023-2025 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 {EventDispatcher} from '../core/event-dispatcher.js';import {EventListenerCollection} from '../core/event-listener-collection.js';import {getActiveModifiers, isInputElementFocused} from '../dom/document-util.js';
/** * Class which handles hotkey events and actions. * @augments EventDispatcher<import('hotkey-handler').Events> */export class HotkeyHandler extends EventDispatcher { /** * Creates a new instance of the class. */ constructor() { super(); /** @type {Map<string, (argument: unknown) => (boolean|void)>} */ this._actions = new Map(); /** @type {Map<(string | null), import('hotkey-handler').HotkeyHandlers>} */ this._hotkeys = new Map(); /** @type {Map<import('settings').InputsHotkeyScope, import('settings').InputsHotkeyOptions[]>} */ this._hotkeyRegistrations = new Map(); /** @type {EventListenerCollection} */ this._eventListeners = new EventListenerCollection(); /** @type {boolean} */ this._isPrepared = false; /** @type {boolean} */ this._hasEventListeners = false; }
/** * Begins listening to key press events in order to detect hotkeys. * @param {import('../comm/cross-frame-api.js').CrossFrameAPI} crossFrameApi */ prepare(crossFrameApi) { this._isPrepared = true; this._updateEventHandlers(); crossFrameApi.registerHandlers([ ['hotkeyHandlerForwardHotkey', this._onMessageForwardHotkey.bind(this)], ]); }
/** * Registers a set of actions that this hotkey handler supports. * @param {[name: string, handler: (argument: unknown) => (boolean|void)][]} actions An array of `[name, handler]` entries, where `name` is a string and `handler` is a function. */ registerActions(actions) { for (const [name, handler] of actions) { this._actions.set(name, handler); } }
/** * Registers a set of hotkeys for a given scope. * @param {import('settings').InputsHotkeyScope} scope The scope that the hotkey definitions must be for in order to be activated. * @param {import('settings').InputsHotkeyOptions[]} hotkeys An array of hotkey definitions. */ registerHotkeys(scope, hotkeys) { let registrations = this._hotkeyRegistrations.get(scope); if (typeof registrations === 'undefined') { registrations = []; this._hotkeyRegistrations.set(scope, registrations); } registrations.push(...hotkeys); this._updateHotkeyRegistrations(); }
/** * Removes all registered hotkeys for a given scope. * @param {import('settings').InputsHotkeyScope} scope The scope that the hotkey definitions were registered in. */ clearHotkeys(scope) { const registrations = this._hotkeyRegistrations.get(scope); if (typeof registrations !== 'undefined') { registrations.length = 0; } this._updateHotkeyRegistrations(); }
/** * Assigns a set of hotkeys for a given scope. This is an optimized shorthand for calling * `clearHotkeys`, then calling `registerHotkeys`. * @param {import('settings').InputsHotkeyScope} scope The scope that the hotkey definitions must be for in order to be activated. * @param {import('settings').InputsHotkeyOptions[]} hotkeys An array of hotkey definitions. */ setHotkeys(scope, hotkeys) { let registrations = this._hotkeyRegistrations.get(scope); if (typeof registrations === 'undefined') { registrations = []; this._hotkeyRegistrations.set(scope, registrations); } else { registrations.length = 0; } for (const {action, argument, key, modifiers, scopes, enabled} of hotkeys) { registrations.push({ action, argument, key, modifiers: [...modifiers], scopes: [...scopes], enabled, }); } this._updateHotkeyRegistrations(); }
/** * @template {import('core').EventNames<import('hotkey-handler').Events>} TName * @param {TName} eventName * @param {(details: import('core').EventArgument<import('hotkey-handler').Events, TName>) => void} callback */ on(eventName, callback) { super.on(eventName, callback); this._updateHasEventListeners(); this._updateEventHandlers(); }
/** * @template {import('core').EventNames<import('hotkey-handler').Events>} TName * @param {TName} eventName * @param {(details: import('core').EventArgument<import('hotkey-handler').Events, TName>) => void} callback * @returns {boolean} */ off(eventName, callback) { const result = super.off(eventName, callback); this._updateHasEventListeners(); this._updateEventHandlers(); return result; }
/** * Attempts to simulate an action for a given combination of key and modifiers. * @param {string} key A keyboard key code indicating which key needs to be pressed. * @param {import('input').ModifierKey[]} modifiers An array of keyboard modifiers which also need to be pressed. Supports: `'alt', 'ctrl', 'shift', 'meta'`. * @returns {boolean} `true` if an action was performed, `false` otherwise. */ simulate(key, modifiers) { const hotkeyInfo = this._hotkeys.get(key); return ( typeof hotkeyInfo !== 'undefined' && this._invokeHandlers(modifiers, hotkeyInfo, key) ); }
// Message handlers
/** @type {import('cross-frame-api').ApiHandler<'hotkeyHandlerForwardHotkey'>} */ _onMessageForwardHotkey({key, modifiers}) { return this.simulate(key, modifiers); }
// Private
/** * @param {KeyboardEvent} event */ _onKeyDown(event) { let hotkeyInfo = this._hotkeys.get(event.code); const modifierKeycodes = ['ControlLeft', 'ControlRight', 'ShiftLeft', 'ShiftRight', 'AltLeft', 'AltRight', 'MetaLeft', 'MetaRight']; if (modifierKeycodes.includes(event.code)) { hotkeyInfo = this._hotkeys.get(null); // Hotkeys with only modifiers are stored as null } if (typeof hotkeyInfo !== 'undefined') { const eventModifiers = getActiveModifiers(event); if (this._invokeHandlers(eventModifiers, hotkeyInfo, event.key)) { event.preventDefault(); return; } } this.trigger('keydownNonHotkey', event); }
/** * @param {import('input').ModifierKey[]} modifiers * @param {import('hotkey-handler').HotkeyHandlers} hotkeyInfo * @param {string} key * @returns {boolean} */ _invokeHandlers(modifiers, hotkeyInfo, key) { for (const {modifiers: handlerModifiers, action, argument} of hotkeyInfo.handlers) { if (!this._areSame(handlerModifiers, modifiers) || !this._isHotkeyPermitted(modifiers, key)) { continue; }
const actionHandler = this._actions.get(action); if (typeof actionHandler !== 'undefined') { const result = actionHandler(argument); if (result !== false) { return true; } } }
return false; }
/** * @param {Set<unknown>} set * @param {unknown[]} array * @returns {boolean} */ _areSame(set, array) { if (set.size !== array.length) { return false; } for (const value of array) { if (!set.has(value)) { return false; } } return true; }
/** * @returns {void} */ _updateHotkeyRegistrations() { if (this._hotkeys.size === 0 && this._hotkeyRegistrations.size === 0) { return; }
this._hotkeys.clear(); for (const [scope, registrations] of this._hotkeyRegistrations.entries()) { for (const {action, argument, key, modifiers, scopes, enabled} of registrations) { if (!(enabled && (key !== null || modifiers.length > 0) && action !== '' && scopes.includes(scope))) { continue; } let hotkeyInfo = this._hotkeys.get(key); if (typeof hotkeyInfo === 'undefined') { hotkeyInfo = {handlers: []}; this._hotkeys.set(key, hotkeyInfo); }
hotkeyInfo.handlers.push({modifiers: new Set(modifiers), action, argument}); } } this._updateEventHandlers(); }
/** * @returns {void} */ _updateHasEventListeners() { this._hasEventListeners = this.hasListeners('keydownNonHotkey'); }
/** * @returns {void} */ _updateEventHandlers() { if (this._isPrepared && (this._hotkeys.size > 0 || this._hasEventListeners)) { if (this._eventListeners.size > 0) { return; } this._eventListeners.addEventListener(document, 'keydown', this._onKeyDown.bind(this), false); } else { this._eventListeners.removeAllEventListeners(); } }
/** * @param {import('input').ModifierKey[]} modifiers * @param {string} key * @returns {boolean} */ _isHotkeyPermitted(modifiers, key) { return !( (modifiers.length === 0 || (modifiers.length === 1 && modifiers[0] === 'shift')) && isInputElementFocused() && this._isKeyCharacterInput(key) ); }
/** * @param {string} key * @returns {boolean} */ _isKeyCharacterInput(key) { return key.length === 1 || key === 'Process'; }}