mirror of
https://github.com/ksyasuda/SubMiner.git
synced 2026-02-27 18:22:41 -08:00
1250 lines
44 KiB
JavaScript
1250 lines
44 KiB
JavaScript
/*
|
|
* Copyright (C) 2023-2025 Yomitan Authors
|
|
* Copyright (C) 2016-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 {FrameClient} from '../comm/frame-client.js';
|
|
import {DynamicProperty} from '../core/dynamic-property.js';
|
|
import {EventDispatcher} from '../core/event-dispatcher.js';
|
|
import {EventListenerCollection} from '../core/event-listener-collection.js';
|
|
import {ExtensionError} from '../core/extension-error.js';
|
|
import {safePerformance} from '../core/safe-performance.js';
|
|
import {deepEqual} from '../core/utilities.js';
|
|
import {addFullscreenChangeEventListener, computeZoomScale, convertRectZoomCoordinates, getFullscreenElement} from '../dom/document-util.js';
|
|
import {loadStyle} from '../dom/style-util.js';
|
|
import {checkPopupPreviewURL} from '../pages/settings/popup-preview-controller.js';
|
|
import {ThemeController} from './theme-controller.js';
|
|
|
|
/**
|
|
* This class is the container which hosts the display of search results.
|
|
* @augments EventDispatcher<import('popup').Events>
|
|
*/
|
|
export class Popup extends EventDispatcher {
|
|
/**
|
|
* @param {import('../application.js').Application} application The main application instance.
|
|
* @param {string} id The identifier of the popup.
|
|
* @param {number} depth The depth of the popup.
|
|
* @param {number} frameId The frameId of the host frame.
|
|
* @param {boolean} childrenSupported Whether or not the popup is able to show child popups.
|
|
*/
|
|
constructor(application, id, depth, frameId, childrenSupported) {
|
|
super();
|
|
/** @type {import('../application.js').Application} */
|
|
this._application = application;
|
|
/** @type {string} */
|
|
this._id = id;
|
|
/** @type {number} */
|
|
this._depth = depth;
|
|
/** @type {number} */
|
|
this._frameId = frameId;
|
|
/** @type {boolean} */
|
|
this._childrenSupported = childrenSupported;
|
|
/** @type {?Popup} */
|
|
this._parent = null;
|
|
/** @type {?Popup} */
|
|
this._child = null;
|
|
/** @type {?Promise<boolean>} */
|
|
this._injectPromise = null;
|
|
/** @type {boolean} */
|
|
this._injectPromiseComplete = false;
|
|
/** @type {DynamicProperty<boolean>} */
|
|
this._visible = new DynamicProperty(false);
|
|
/** @type {boolean} */
|
|
this._visibleValue = false;
|
|
/** @type {?import('settings').OptionsContext} */
|
|
this._optionsContext = null;
|
|
/** @type {number} */
|
|
this._contentScale = 1;
|
|
/** @type {string} */
|
|
this._targetOrigin = chrome.runtime.getURL('/').replace(/\/$/, '');
|
|
/** @type {?import('core').Timeout} */
|
|
this._hidePopupTimer = null;
|
|
|
|
/** @type {number} */
|
|
this._initialWidth = 400;
|
|
/** @type {number} */
|
|
this._initialHeight = 250;
|
|
/** @type {number} */
|
|
this._horizontalOffset = 0;
|
|
/** @type {number} */
|
|
this._verticalOffset = 10;
|
|
/** @type {number} */
|
|
this._horizontalOffset2 = 10;
|
|
/** @type {number} */
|
|
this._verticalOffset2 = 0;
|
|
/** @type {import('settings').PopupVerticalTextPosition} */
|
|
this._verticalTextPosition = 'before';
|
|
/** @type {boolean} */
|
|
this._horizontalTextPositionBelow = true;
|
|
/** @type {import('settings').PopupDisplayMode} */
|
|
this._displayMode = 'default';
|
|
/** @type {boolean} */
|
|
this._displayModeIsFullWidth = false;
|
|
/** @type {boolean} */
|
|
this._scaleRelativeToVisualViewport = true;
|
|
/** @type {boolean} */
|
|
this._useSecureFrameUrl = true;
|
|
/** @type {boolean} */
|
|
this._useShadowDom = true;
|
|
/** @type {string} */
|
|
this._customOuterCss = '';
|
|
/** @type {boolean} */
|
|
this._hidePopupOnCursorExit = false;
|
|
/** @type {number} */
|
|
this._hidePopupOnCursorExitDelay = 0;
|
|
|
|
/** @type {?number} */
|
|
this._frameSizeContentScale = null;
|
|
/** @type {?FrameClient} */
|
|
this._frameClient = null;
|
|
/** @type {HTMLIFrameElement} */
|
|
this._frame = document.createElement('iframe');
|
|
this._frame.className = 'yomitan-popup';
|
|
this._frame.style.width = '0';
|
|
this._frame.style.height = '0';
|
|
/** @type {boolean} */
|
|
this._frameConnected = false;
|
|
/** @type {boolean} */
|
|
this._isPointerOverPopup = false;
|
|
|
|
/** @type {HTMLElement} */
|
|
this._container = this._frame;
|
|
/** @type {?ShadowRoot} */
|
|
this._shadow = null;
|
|
|
|
/** @type {ThemeController} */
|
|
this._themeController = new ThemeController(this._frame);
|
|
|
|
/** @type {EventListenerCollection} */
|
|
this._fullscreenEventListeners = new EventListenerCollection();
|
|
}
|
|
|
|
/**
|
|
* The ID of the popup.
|
|
* @type {string}
|
|
*/
|
|
get id() {
|
|
return this._id;
|
|
}
|
|
|
|
/**
|
|
* The parent of the popup.
|
|
* @type {?Popup}
|
|
*/
|
|
get parent() {
|
|
return this._parent;
|
|
}
|
|
|
|
/**
|
|
* Sets the parent popup.
|
|
* @param {Popup} value The parent popup to assign.
|
|
*/
|
|
set parent(value) {
|
|
this._parent = value;
|
|
}
|
|
|
|
/**
|
|
* The child of the popup.
|
|
* @type {?Popup}
|
|
*/
|
|
get child() {
|
|
return this._child;
|
|
}
|
|
|
|
/**
|
|
* Sets the child popup.
|
|
* @param {Popup} value The child popup to assign.
|
|
*/
|
|
set child(value) {
|
|
this._child = value;
|
|
}
|
|
|
|
/**
|
|
* The depth of the popup.
|
|
* @type {number}
|
|
*/
|
|
get depth() {
|
|
return this._depth;
|
|
}
|
|
|
|
/**
|
|
* Gets the content window of the frame, which can be `null`
|
|
* depending on the current state of the frame.
|
|
* @type {?Window}
|
|
*/
|
|
get frameContentWindow() {
|
|
return this._frame.contentWindow;
|
|
}
|
|
|
|
/**
|
|
* Gets the DOM node that contains the frame.
|
|
* @type {Element}
|
|
*/
|
|
get container() {
|
|
return this._container;
|
|
}
|
|
|
|
/**
|
|
* Gets the ID of the frame.
|
|
* @type {number}
|
|
*/
|
|
get frameId() {
|
|
return this._frameId;
|
|
}
|
|
|
|
/**
|
|
* Prepares the popup for use.
|
|
*/
|
|
prepare() {
|
|
this._frame.addEventListener('mouseover', this._onFrameMouseOver.bind(this));
|
|
this._frame.addEventListener('mouseout', this._onFrameMouseOut.bind(this));
|
|
this._frame.addEventListener('mousedown', (e) => e.stopPropagation());
|
|
this._frame.addEventListener('scroll', (e) => e.stopPropagation());
|
|
this._frame.addEventListener('load', this._onFrameLoad.bind(this));
|
|
this._visible.on('change', this._onVisibleChange.bind(this));
|
|
this._application.on('extensionUnloaded', this._onExtensionUnloaded.bind(this));
|
|
this._onVisibleChange({value: this.isVisibleSync()});
|
|
this._themeController.prepare();
|
|
}
|
|
|
|
/**
|
|
* Sets the options context for the popup.
|
|
* @param {import('settings').OptionsContext} optionsContext The options context object.
|
|
*/
|
|
async setOptionsContext(optionsContext) {
|
|
await this._setOptionsContext(optionsContext);
|
|
if (this._frameConnected) {
|
|
await this._invokeSafe('displaySetOptionsContext', {optionsContext});
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Hides the popup.
|
|
* @param {boolean} changeFocus Whether or not the parent popup or host frame should be focused.
|
|
*/
|
|
hide(changeFocus) {
|
|
if (!this.isVisibleSync()) {
|
|
return;
|
|
}
|
|
|
|
this.stopHideDelayed();
|
|
|
|
this._setVisible(false);
|
|
if (this._child !== null) {
|
|
this._child.hide(false);
|
|
}
|
|
if (changeFocus) {
|
|
this._focusParent();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param {number} delay
|
|
*/
|
|
hideDelayed(delay) {
|
|
if (this.isPointerOverSelfOrChildren()) { return; }
|
|
|
|
if (delay > 0) {
|
|
this.stopHideDelayed();
|
|
this._hidePopupTimer = setTimeout(() => {
|
|
this._hidePopupTimer = null;
|
|
if (this.isPointerOverSelfOrChildren()) { return; }
|
|
this.hide(false);
|
|
}, delay);
|
|
} else {
|
|
this.hide(false);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @returns {void}
|
|
*/
|
|
stopHideDelayed() {
|
|
if (this._hidePopupTimer !== null) {
|
|
clearTimeout(this._hidePopupTimer);
|
|
this._hidePopupTimer = null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns whether or not the popup is currently visible.
|
|
* @returns {Promise<boolean>} `true` if the popup is visible, `false` otherwise.
|
|
*/
|
|
async isVisible() {
|
|
return this.isVisibleSync();
|
|
}
|
|
|
|
/**
|
|
* Force assigns the visibility of the popup.
|
|
* @param {boolean} value Whether or not the popup should be visible.
|
|
* @param {number} priority The priority of the override.
|
|
* @returns {Promise<?import('core').TokenString>} A token used which can be passed to `clearVisibleOverride`,
|
|
* or null if the override wasn't assigned.
|
|
*/
|
|
async setVisibleOverride(value, priority) {
|
|
return this._visible.setOverride(value, priority);
|
|
}
|
|
|
|
/**
|
|
* Clears a visibility override that was generated by `setVisibleOverride`.
|
|
* @param {import('core').TokenString} token The token returned from `setVisibleOverride`.
|
|
* @returns {Promise<boolean>} `true` if the override existed and was removed, `false` otherwise.
|
|
*/
|
|
async clearVisibleOverride(token) {
|
|
return this._visible.clearOverride(token);
|
|
}
|
|
|
|
/**
|
|
* Checks whether a point is contained within the popup's rect.
|
|
* @param {number} x The x coordinate.
|
|
* @param {number} y The y coordinate.
|
|
* @returns {Promise<boolean>} `true` if the point is contained within the popup's rect, `false` otherwise.
|
|
*/
|
|
async containsPoint(x, y) {
|
|
// eslint-disable-next-line @typescript-eslint/no-this-alias
|
|
for (let popup = /** @type {?Popup} */ (this); popup !== null && popup.isVisibleSync(); popup = popup.child) {
|
|
const rect = popup.getFrameRect();
|
|
if (rect.valid && x >= rect.left && y >= rect.top && x < rect.right && y < rect.bottom) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Shows and updates the positioning and content of the popup.
|
|
* @param {import('popup').ContentDetails} details Settings for the outer popup.
|
|
* @param {?import('display').ContentDetails} displayDetails The details parameter passed to `Display.setContent`.
|
|
* @returns {Promise<void>}
|
|
*/
|
|
async showContent(details, displayDetails) {
|
|
if (this._optionsContext === null) { throw new Error('Options not assigned'); }
|
|
|
|
const {optionsContext, sourceRects, writingMode} = details;
|
|
if (optionsContext !== null) {
|
|
await this._setOptionsContextIfDifferent(optionsContext);
|
|
}
|
|
|
|
// If there's already a timer running on the same popup from a previous lookup, reset it
|
|
this.stopHideDelayed();
|
|
|
|
await this._show(sourceRects, writingMode);
|
|
|
|
if (displayDetails !== null) {
|
|
safePerformance.mark('invokeDisplaySetContent:start');
|
|
void this._invokeSafe('displaySetContent', {details: displayDetails});
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sets the custom styles for the popup content.
|
|
* @param {string} css The CSS rules.
|
|
*/
|
|
async setCustomCss(css) {
|
|
await this._invokeSafe('displaySetCustomCss', {css});
|
|
}
|
|
|
|
/**
|
|
* Stops the audio auto-play timer, if one has started.
|
|
*/
|
|
async clearAutoPlayTimer() {
|
|
if (this._frameConnected) {
|
|
await this._invokeSafe('displayAudioClearAutoPlayTimer', void 0);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sets the scaling factor of the popup content.
|
|
* @param {number} scale The scaling factor.
|
|
*/
|
|
async setContentScale(scale) {
|
|
this._contentScale = scale;
|
|
this._frame.style.fontSize = `${scale}px`;
|
|
if (this._frameClient !== null && this._frameClient.isConnected() && this._frame.contentWindow !== null) {
|
|
await this._invokeSafe('displaySetContentScale', {scale});
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns whether or not the popup is currently visible, synchronously.
|
|
* @returns {boolean} `true` if the popup is visible, `false` otherwise.
|
|
*/
|
|
isVisibleSync() {
|
|
return this._visible.value;
|
|
}
|
|
|
|
/**
|
|
* Updates the outer theme of the popup.
|
|
* @returns {Promise<void>}
|
|
*/
|
|
async updateTheme() {
|
|
this._themeController.updateTheme();
|
|
}
|
|
|
|
/**
|
|
* Sets the custom styles for the outer popup container.
|
|
* @param {string} css The CSS rules.
|
|
* @param {boolean} useWebExtensionApi Whether or not web extension APIs should be used to inject the rules.
|
|
* When web extension APIs are used, a DOM node is not generated, making it harder to detect the changes.
|
|
*/
|
|
async setCustomOuterCss(css, useWebExtensionApi) {
|
|
let parentNode = null;
|
|
const inShadow = (this._shadow !== null);
|
|
if (inShadow) {
|
|
useWebExtensionApi = false;
|
|
parentNode = this._shadow;
|
|
}
|
|
const node = await loadStyle(this._application, 'yomitan-popup-outer-user-stylesheet', 'code', css, useWebExtensionApi, parentNode);
|
|
this.trigger('customOuterCssChanged', {node, useWebExtensionApi, inShadow});
|
|
}
|
|
|
|
/**
|
|
* Gets the rectangle of the DOM frame, synchronously.
|
|
* @returns {import('popup').ValidRect} The rect.
|
|
* `valid` is `false` for `PopupProxy`, since the DOM node is hosted in a different frame.
|
|
*/
|
|
getFrameRect() {
|
|
const {left, top, right, bottom} = this._getFrameBoundingClientRect();
|
|
return {left, top, right, bottom, valid: true};
|
|
}
|
|
|
|
/**
|
|
* Gets the size of the DOM frame.
|
|
* @returns {Promise<import('popup').ValidSize>} The size and whether or not it is valid.
|
|
*/
|
|
async getFrameSize() {
|
|
return {width: this._frame.offsetWidth, height: this._frame.offsetHeight, valid: true};
|
|
}
|
|
|
|
/**
|
|
* Sets the size of the DOM frame.
|
|
* @param {number} width The desired width of the popup.
|
|
* @param {number} height The desired height of the popup.
|
|
* @returns {Promise<boolean>} `true` if the size assignment was successful, `false` otherwise.
|
|
*/
|
|
async setFrameSize(width, height) {
|
|
this._setFrameSize(width, height);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Returns whether the pointer is currently over this popup.
|
|
* @returns {boolean}
|
|
*/
|
|
isPointerOver() {
|
|
return this._isPointerOverPopup;
|
|
}
|
|
|
|
/**
|
|
* Returns whether the pointer is currently over this popup or any children.
|
|
* @returns {boolean}
|
|
*/
|
|
isPointerOverSelfOrChildren() {
|
|
if (this.isPointerOver()) { return true; }
|
|
|
|
let currentChild = this.child;
|
|
while (currentChild !== null) {
|
|
if (currentChild.isPointerOver()) { return true; }
|
|
currentChild = currentChild.child;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// Private functions
|
|
|
|
/**
|
|
* @returns {void}
|
|
*/
|
|
_onFrameMouseOver() {
|
|
this._isPointerOverPopup = true;
|
|
|
|
this.stopHideDelayed();
|
|
this.trigger('mouseOver', {});
|
|
|
|
// Clear all child popups when parent is moused over
|
|
if (this._hidePopupOnCursorExit && this.child !== null) {
|
|
this.child.hideDelayed(this._hidePopupOnCursorExitDelay);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @returns {void}
|
|
*/
|
|
_onFrameMouseOut() {
|
|
this._isPointerOverPopup = false;
|
|
|
|
this.trigger('mouseOut', {});
|
|
|
|
// Propagate mouseOut event up through the entire hierarchy
|
|
let currentParent = this.parent;
|
|
while (currentParent !== null) {
|
|
currentParent.trigger('mouseOut', {});
|
|
currentParent = currentParent.parent;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @returns {Promise<boolean>}
|
|
*/
|
|
_inject() {
|
|
let injectPromise = this._injectPromise;
|
|
if (injectPromise === null) {
|
|
injectPromise = this._injectInnerWrapper();
|
|
this._injectPromise = injectPromise;
|
|
injectPromise.then(
|
|
() => {
|
|
if (injectPromise !== this._injectPromise) { return; }
|
|
this._injectPromiseComplete = true;
|
|
},
|
|
() => {},
|
|
);
|
|
}
|
|
return injectPromise;
|
|
}
|
|
|
|
/**
|
|
* @returns {Promise<boolean>}
|
|
*/
|
|
async _injectInnerWrapper() {
|
|
try {
|
|
await this._injectInner();
|
|
return true;
|
|
} catch (e) {
|
|
this._resetFrame();
|
|
if (e instanceof PopupError && e.source === this) { return false; } // Passive error
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @returns {Promise<void>}
|
|
*/
|
|
async _injectInner() {
|
|
if (this._optionsContext === null) {
|
|
throw new Error('Options not initialized');
|
|
}
|
|
|
|
const useSecurePopupFrameUrl = this._useSecureFrameUrl;
|
|
|
|
await this._setUpContainer(this._useShadowDom);
|
|
|
|
/** @type {import('frame-client').SetupFrameFunction} */
|
|
const setupFrame = (frame) => {
|
|
frame.removeAttribute('src');
|
|
frame.removeAttribute('srcdoc');
|
|
this._observeFullscreen(true);
|
|
this._onFullscreenChanged();
|
|
const {contentDocument} = frame;
|
|
if (contentDocument === null) {
|
|
// This can occur when running inside a sandboxed frame without "allow-same-origin"
|
|
// Custom error is used to detect a passive error which should be ignored
|
|
throw new PopupError('Popup not supported in this context', this);
|
|
}
|
|
const url = chrome.runtime.getURL('/popup.html');
|
|
if (useSecurePopupFrameUrl) {
|
|
contentDocument.location.href = url;
|
|
} else {
|
|
frame.setAttribute('src', url);
|
|
}
|
|
};
|
|
|
|
const frameClient = new FrameClient();
|
|
this._frameClient = frameClient;
|
|
await frameClient.connect(this._frame, this._targetOrigin, this._frameId, setupFrame);
|
|
this._frameConnected = true;
|
|
|
|
// Reattach mouse event listeners after frame injection
|
|
const boundMouseOver = this._onFrameMouseOver.bind(this);
|
|
const boundMouseOut = this._onFrameMouseOut.bind(this);
|
|
this._frame.addEventListener('mouseover', boundMouseOver);
|
|
this._frame.addEventListener('mouseout', boundMouseOut);
|
|
|
|
// Configure
|
|
/** @type {import('display').DirectApiParams<'displayConfigure'>} */
|
|
const configureParams = {
|
|
depth: this._depth,
|
|
parentPopupId: this._id,
|
|
parentFrameId: this._frameId,
|
|
childrenSupported: this._childrenSupported,
|
|
scale: this._contentScale,
|
|
optionsContext: this._optionsContext,
|
|
};
|
|
await this._invokeSafe('displayConfigure', configureParams);
|
|
}
|
|
|
|
/**
|
|
* @returns {void}
|
|
*/
|
|
_onFrameLoad() {
|
|
if (!this._injectPromiseComplete) { return; }
|
|
this._resetFrame();
|
|
}
|
|
|
|
/**
|
|
* @returns {void}
|
|
*/
|
|
_resetFrame() {
|
|
const parent = this._container.parentNode;
|
|
if (parent !== null) {
|
|
parent.removeChild(this._container);
|
|
}
|
|
this._frame.removeAttribute('src');
|
|
this._frame.removeAttribute('srcdoc');
|
|
|
|
this._frameClient = null;
|
|
this._frameConnected = false;
|
|
this._injectPromise = null;
|
|
this._injectPromiseComplete = false;
|
|
}
|
|
|
|
/**
|
|
* @param {boolean} usePopupShadowDom
|
|
*/
|
|
async _setUpContainer(usePopupShadowDom) {
|
|
if (usePopupShadowDom && typeof this._frame.attachShadow === 'function') {
|
|
const container = document.createElement('div');
|
|
container.style.setProperty('all', 'initial', 'important');
|
|
const shadow = container.attachShadow({mode: 'closed', delegatesFocus: true});
|
|
shadow.appendChild(this._frame);
|
|
|
|
this._container = container;
|
|
this._shadow = shadow;
|
|
} else {
|
|
const frameParentNode = this._frame.parentNode;
|
|
if (frameParentNode !== null) {
|
|
frameParentNode.removeChild(this._frame);
|
|
}
|
|
|
|
this._container = this._frame;
|
|
this._shadow = null;
|
|
}
|
|
|
|
await this._injectStyles();
|
|
}
|
|
|
|
/**
|
|
* @returns {Promise<void>}
|
|
*/
|
|
async _injectStyles() {
|
|
try {
|
|
await this._injectPopupOuterStylesheet();
|
|
} catch (e) {
|
|
// NOP
|
|
}
|
|
|
|
try {
|
|
await this.setCustomOuterCss(this._customOuterCss, true);
|
|
} catch (e) {
|
|
// NOP
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @returns {Promise<void>}
|
|
*/
|
|
async _injectPopupOuterStylesheet() {
|
|
/** @type {'code'|'file'|'file-content'} */
|
|
let fileType = 'file';
|
|
let useWebExtensionApi = true;
|
|
let parentNode = null;
|
|
if (this._shadow !== null) {
|
|
fileType = 'file-content';
|
|
useWebExtensionApi = false;
|
|
parentNode = this._shadow;
|
|
}
|
|
await loadStyle(this._application, 'yomitan-popup-outer-stylesheet', fileType, '/css/popup-outer.css', useWebExtensionApi, parentNode);
|
|
}
|
|
|
|
/**
|
|
* @param {boolean} observe
|
|
*/
|
|
_observeFullscreen(observe) {
|
|
if (!observe) {
|
|
this._fullscreenEventListeners.removeAllEventListeners();
|
|
return;
|
|
}
|
|
|
|
if (this._fullscreenEventListeners.size > 0) {
|
|
// Already observing
|
|
return;
|
|
}
|
|
|
|
addFullscreenChangeEventListener(this._onFullscreenChanged.bind(this), this._fullscreenEventListeners);
|
|
}
|
|
|
|
/**
|
|
* @returns {void}
|
|
*/
|
|
_onFullscreenChanged() {
|
|
const parent = this._getFrameParentElement();
|
|
if (parent !== null && this._container.parentNode !== parent) {
|
|
parent.appendChild(this._container);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param {import('popup').Rect[]} sourceRects
|
|
* @param {import('document-util').NormalizedWritingMode} writingMode
|
|
*/
|
|
async _show(sourceRects, writingMode) {
|
|
const injected = await this._inject();
|
|
if (!injected) { return; }
|
|
|
|
const viewport = this._getViewport(this._scaleRelativeToVisualViewport);
|
|
let {left, top, width, height, after, below} = this._getPosition(sourceRects, writingMode, viewport);
|
|
|
|
if (this._displayModeIsFullWidth) {
|
|
left = viewport.left;
|
|
top = below ? viewport.bottom - height : viewport.top;
|
|
width = viewport.right - viewport.left;
|
|
}
|
|
|
|
const frame = this._frame;
|
|
frame.dataset.popupDisplayMode = this._displayMode;
|
|
frame.dataset.after = `${after}`;
|
|
frame.dataset.below = `${below}`;
|
|
frame.style.left = `${left}px`;
|
|
frame.style.top = `${top}px`;
|
|
this._setFrameSize(width, height);
|
|
|
|
this._setVisible(true);
|
|
if (this._child !== null) {
|
|
this._child.hide(true);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param {number} width
|
|
* @param {number} height
|
|
*/
|
|
_setFrameSize(width, height) {
|
|
const {style} = this._frame;
|
|
style.width = `${width}px`;
|
|
style.height = `${height}px`;
|
|
}
|
|
|
|
/**
|
|
* @param {boolean} visible
|
|
*/
|
|
_setVisible(visible) {
|
|
this._visible.defaultValue = visible;
|
|
}
|
|
|
|
/**
|
|
* @param {import('dynamic-property').EventArgument<boolean, 'change'>} event
|
|
*/
|
|
_onVisibleChange({value}) {
|
|
if (this._visibleValue === value) { return; }
|
|
this._visibleValue = value;
|
|
this._frame.style.setProperty('visibility', value ? 'visible' : 'hidden', 'important');
|
|
void this._invokeSafe('displayVisibilityChanged', {value});
|
|
|
|
// Dispatch custom events for popup visibility (Electron integration)
|
|
if (value) {
|
|
window.dispatchEvent(new CustomEvent('yomitan-popup-shown'));
|
|
} else {
|
|
window.dispatchEvent(new CustomEvent('yomitan-popup-hidden'));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @returns {void}
|
|
*/
|
|
_focusParent() {
|
|
if (this._parent !== null) {
|
|
// Chrome doesn't like focusing iframe without contentWindow.
|
|
const contentWindow = this._parent.frameContentWindow;
|
|
if (contentWindow !== null) {
|
|
contentWindow.focus();
|
|
}
|
|
} else {
|
|
// Firefox doesn't like focusing window without first blurring the iframe.
|
|
// this._frame.contentWindow.blur() doesn't work on Firefox for some reason.
|
|
this._frame.blur();
|
|
// This is needed for Chrome.
|
|
window.focus();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @template {import('display').DirectApiNames} TName
|
|
* @param {TName} action
|
|
* @param {import('display').DirectApiParams<TName>} params
|
|
* @returns {Promise<import('display').DirectApiReturn<TName>>}
|
|
*/
|
|
async _invoke(action, params) {
|
|
const contentWindow = this._frame.contentWindow;
|
|
if (this._frameClient === null || !this._frameClient.isConnected() || contentWindow === null) {
|
|
throw new Error(`Failed to invoke action ${action}: frame state invalid`);
|
|
}
|
|
|
|
/** @type {import('display').DirectApiMessage<TName>} */
|
|
const message = {action, params};
|
|
const wrappedMessage = this._frameClient.createMessage(message);
|
|
return /** @type {import('display').DirectApiReturn<TName>} */ (await this._application.crossFrame.invoke(
|
|
this._frameClient.frameId,
|
|
'displayPopupMessage1',
|
|
/** @type {import('display').DirectApiFrameClientMessageAny} */ (wrappedMessage),
|
|
));
|
|
}
|
|
|
|
/**
|
|
* @template {import('display').DirectApiNames} TName
|
|
* @param {TName} action
|
|
* @param {import('display').DirectApiParams<TName>} params
|
|
* @returns {Promise<import('display').DirectApiReturn<TName>|undefined>}
|
|
*/
|
|
async _invokeSafe(action, params) {
|
|
try {
|
|
return await this._invoke(action, params);
|
|
} catch (e) {
|
|
if (!this._application.webExtension.unloaded) { throw e; }
|
|
return void 0;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @template {import('display').WindowApiNames} TName
|
|
* @param {TName} action
|
|
* @param {import('display').WindowApiParams<TName>} params
|
|
*/
|
|
_invokeWindow(action, params) {
|
|
const contentWindow = this._frame.contentWindow;
|
|
if (this._frameClient === null || !this._frameClient.isConnected() || contentWindow === null) { return; }
|
|
|
|
/** @type {import('display').WindowApiMessage<TName>} */
|
|
const message = {action, params};
|
|
const messageWrapper = this._frameClient.createMessage(message);
|
|
contentWindow.postMessage(messageWrapper, this._targetOrigin);
|
|
}
|
|
|
|
/**
|
|
* @returns {void}
|
|
*/
|
|
_onExtensionUnloaded() {
|
|
this._invokeWindow('displayExtensionUnloaded', void 0);
|
|
}
|
|
|
|
/**
|
|
* @returns {Element}
|
|
*/
|
|
_getFrameParentElement() {
|
|
let defaultParent = document.body;
|
|
if (defaultParent !== null && defaultParent.tagName.toLowerCase() === 'frameset') {
|
|
defaultParent = document.documentElement;
|
|
}
|
|
const fullscreenElement = getFullscreenElement();
|
|
if (
|
|
fullscreenElement === null ||
|
|
fullscreenElement.shadowRoot ||
|
|
// @ts-expect-error - openOrClosedShadowRoot is available to Firefox 63+ for WebExtensions
|
|
fullscreenElement.openOrClosedShadowRoot
|
|
) {
|
|
return defaultParent;
|
|
}
|
|
|
|
switch (fullscreenElement.nodeName.toUpperCase()) {
|
|
case 'IFRAME':
|
|
case 'FRAME':
|
|
return defaultParent;
|
|
}
|
|
|
|
return fullscreenElement;
|
|
}
|
|
|
|
/**
|
|
* Computes the position where the popup should be placed relative to the source content.
|
|
* @param {import('popup').Rect[]} sourceRects The rectangles of the source content.
|
|
* @param {import('document-util').NormalizedWritingMode} writingMode The CSS writing mode of the source text.
|
|
* @param {import('popup').Rect} viewport The viewport that the popup can be placed within.
|
|
* @returns {import('popup').SizeRect} The calculated rectangle for where to position the popup.
|
|
*/
|
|
_getPosition(sourceRects, writingMode, viewport) {
|
|
sourceRects = this._convertSourceRectsCoordinateSpace(sourceRects);
|
|
const contentScale = this._contentScale;
|
|
const scaleRatio = this._frameSizeContentScale === null ? 1 : contentScale / this._frameSizeContentScale;
|
|
this._frameSizeContentScale = contentScale;
|
|
const frameRect = this._frame.getBoundingClientRect();
|
|
const frameWidth = Math.max(frameRect.width * scaleRatio, this._initialWidth * contentScale);
|
|
const frameHeight = Math.max(frameRect.height * scaleRatio, this._initialHeight * contentScale);
|
|
|
|
const horizontal = (writingMode === 'horizontal-tb' || this._verticalTextPosition === 'default');
|
|
let preferAfter;
|
|
let horizontalOffset;
|
|
let verticalOffset;
|
|
if (horizontal) {
|
|
preferAfter = this._horizontalTextPositionBelow;
|
|
horizontalOffset = this._horizontalOffset;
|
|
verticalOffset = this._verticalOffset;
|
|
} else {
|
|
preferAfter = this._isVerticalTextPopupOnRight(this._verticalTextPosition, writingMode);
|
|
horizontalOffset = this._horizontalOffset2;
|
|
verticalOffset = this._verticalOffset2;
|
|
}
|
|
horizontalOffset *= contentScale;
|
|
verticalOffset *= contentScale;
|
|
|
|
/** @type {?import('popup').SizeRect} */
|
|
let best = null;
|
|
const sourceRectsLength = sourceRects.length;
|
|
for (let i = 0, ii = (sourceRectsLength > 1 ? sourceRectsLength : 0); i <= ii; ++i) {
|
|
const sourceRect = i < sourceRectsLength ? sourceRects[i] : this._getBoundingSourceRect(sourceRects);
|
|
const result = (
|
|
horizontal ?
|
|
this._getPositionForHorizontalText(sourceRect, frameWidth, frameHeight, viewport, horizontalOffset, verticalOffset, preferAfter) :
|
|
this._getPositionForVerticalText(sourceRect, frameWidth, frameHeight, viewport, horizontalOffset, verticalOffset, preferAfter)
|
|
);
|
|
if (i < ii && this._isOverlapping(result, sourceRects, i)) { continue; }
|
|
if (best === null || result.height > best.height) {
|
|
best = result;
|
|
if (result.height >= frameHeight) { break; }
|
|
}
|
|
}
|
|
// Given the loop conditions, this is guaranteed to be non-null
|
|
return /** @type {import('popup').SizeRect} */ (best);
|
|
}
|
|
|
|
/**
|
|
* Computes the position where the popup should be placed for horizontal text.
|
|
* @param {import('popup').Rect} sourceRect The rectangle of the source content.
|
|
* @param {number} frameWidth The preferred width of the frame.
|
|
* @param {number} frameHeight The preferred height of the frame.
|
|
* @param {import('popup').Rect} viewport The viewport that the frame can be placed within.
|
|
* @param {number} horizontalOffset The horizontal offset from the source rect that the popup will be placed.
|
|
* @param {number} verticalOffset The vertical offset from the source rect that the popup will be placed.
|
|
* @param {boolean} preferBelow Whether or not the popup is preferred to be placed below the source content.
|
|
* @returns {import('popup').SizeRect} The calculated rectangle for where to position the popup.
|
|
*/
|
|
_getPositionForHorizontalText(sourceRect, frameWidth, frameHeight, viewport, horizontalOffset, verticalOffset, preferBelow) {
|
|
const [left, width, after] = this._getConstrainedPosition(
|
|
sourceRect.right - horizontalOffset,
|
|
sourceRect.left + horizontalOffset,
|
|
frameWidth,
|
|
viewport.left,
|
|
viewport.right,
|
|
true,
|
|
);
|
|
const [top, height, below] = this._getConstrainedPositionBinary(
|
|
sourceRect.top - verticalOffset,
|
|
sourceRect.bottom + verticalOffset,
|
|
frameHeight,
|
|
viewport.top,
|
|
viewport.bottom,
|
|
preferBelow,
|
|
);
|
|
return {left, top, width, height, after, below};
|
|
}
|
|
|
|
/**
|
|
* Computes the position where the popup should be placed for vertical text.
|
|
* @param {import('popup').Rect} sourceRect The rectangle of the source content.
|
|
* @param {number} frameWidth The preferred width of the frame.
|
|
* @param {number} frameHeight The preferred height of the frame.
|
|
* @param {import('popup').Rect} viewport The viewport that the frame can be placed within.
|
|
* @param {number} horizontalOffset The horizontal offset from the source rect that the popup will be placed.
|
|
* @param {number} verticalOffset The vertical offset from the source rect that the popup will be placed.
|
|
* @param {boolean} preferRight Whether or not the popup is preferred to be placed to the right of the source content.
|
|
* @returns {import('popup').SizeRect} The calculated rectangle for where to position the popup.
|
|
*/
|
|
_getPositionForVerticalText(sourceRect, frameWidth, frameHeight, viewport, horizontalOffset, verticalOffset, preferRight) {
|
|
const [left, width, after] = this._getConstrainedPositionBinary(
|
|
sourceRect.left - horizontalOffset,
|
|
sourceRect.right + horizontalOffset,
|
|
frameWidth,
|
|
viewport.left,
|
|
viewport.right,
|
|
preferRight,
|
|
);
|
|
const [top, height, below] = this._getConstrainedPosition(
|
|
sourceRect.bottom - verticalOffset,
|
|
sourceRect.top + verticalOffset,
|
|
frameHeight,
|
|
viewport.top,
|
|
viewport.bottom,
|
|
true,
|
|
);
|
|
return {left, top, width, height, after, below};
|
|
}
|
|
|
|
/**
|
|
* @param {import('settings').PopupVerticalTextPosition} positionPreference
|
|
* @param {import('document-util').NormalizedWritingMode} writingMode
|
|
* @returns {boolean}
|
|
*/
|
|
_isVerticalTextPopupOnRight(positionPreference, writingMode) {
|
|
switch (positionPreference) {
|
|
case 'before':
|
|
return !this._isWritingModeLeftToRight(writingMode);
|
|
case 'after':
|
|
return this._isWritingModeLeftToRight(writingMode);
|
|
case 'right':
|
|
return true;
|
|
// case 'left':
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param {import('document-util').NormalizedWritingMode} writingMode
|
|
* @returns {boolean}
|
|
*/
|
|
_isWritingModeLeftToRight(writingMode) {
|
|
switch (writingMode) {
|
|
case 'vertical-lr':
|
|
case 'sideways-lr':
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param {number} positionBefore
|
|
* @param {number} positionAfter
|
|
* @param {number} size
|
|
* @param {number} minLimit
|
|
* @param {number} maxLimit
|
|
* @param {boolean} after
|
|
* @returns {[position: number, size: number, after: boolean]}
|
|
*/
|
|
_getConstrainedPosition(positionBefore, positionAfter, size, minLimit, maxLimit, after) {
|
|
size = Math.min(size, maxLimit - minLimit);
|
|
|
|
let position;
|
|
if (after) {
|
|
position = Math.max(minLimit, positionAfter);
|
|
position = position - Math.max(0, (position + size) - maxLimit);
|
|
} else {
|
|
position = Math.min(maxLimit, positionBefore) - size;
|
|
position = position + Math.max(0, minLimit - position);
|
|
}
|
|
|
|
return [position, size, after];
|
|
}
|
|
|
|
/**
|
|
* @param {number} positionBefore
|
|
* @param {number} positionAfter
|
|
* @param {number} size
|
|
* @param {number} minLimit
|
|
* @param {number} maxLimit
|
|
* @param {boolean} after
|
|
* @returns {[position: number, size: number, after: boolean]}
|
|
*/
|
|
_getConstrainedPositionBinary(positionBefore, positionAfter, size, minLimit, maxLimit, after) {
|
|
const overflowBefore = minLimit - (positionBefore - size);
|
|
const overflowAfter = (positionAfter + size) - maxLimit;
|
|
|
|
if (overflowAfter > 0 || overflowBefore > 0) {
|
|
after = (overflowAfter < overflowBefore);
|
|
}
|
|
|
|
let position;
|
|
if (after) {
|
|
size -= Math.max(0, overflowAfter);
|
|
position = Math.max(minLimit, positionAfter);
|
|
} else {
|
|
size -= Math.max(0, overflowBefore);
|
|
position = Math.min(maxLimit, positionBefore) - size;
|
|
}
|
|
|
|
return [position, size, after];
|
|
}
|
|
|
|
/**
|
|
* Gets the visual viewport.
|
|
* @param {boolean} useVisualViewport Whether or not the `window.visualViewport` should be used.
|
|
* @returns {import('popup').Rect} The rectangle of the visual viewport.
|
|
*/
|
|
_getViewport(useVisualViewport) {
|
|
const {visualViewport} = window;
|
|
if (typeof visualViewport !== 'undefined' && visualViewport !== null) {
|
|
const left = visualViewport.offsetLeft;
|
|
const top = visualViewport.offsetTop;
|
|
const width = visualViewport.width;
|
|
const height = visualViewport.height;
|
|
if (useVisualViewport) {
|
|
return {
|
|
left,
|
|
top,
|
|
right: left + width,
|
|
bottom: top + height,
|
|
};
|
|
} else {
|
|
const scale = visualViewport.scale;
|
|
return {
|
|
left: 0,
|
|
top: 0,
|
|
right: Math.max(left + width, width * scale),
|
|
bottom: Math.max(top + height, height * scale),
|
|
};
|
|
}
|
|
}
|
|
|
|
return {
|
|
left: 0,
|
|
top: 0,
|
|
right: window.innerWidth,
|
|
bottom: window.innerHeight,
|
|
};
|
|
}
|
|
|
|
/**
|
|
* @param {import('settings').OptionsContext} optionsContext
|
|
*/
|
|
async _setOptionsContext(optionsContext) {
|
|
this._optionsContext = optionsContext;
|
|
const options = await this._application.api.optionsGet(optionsContext);
|
|
const {general, scanning} = options;
|
|
this._themeController.theme = general.popupTheme;
|
|
this._themeController.outerTheme = general.popupOuterTheme;
|
|
this._themeController.siteOverride = checkPopupPreviewURL(optionsContext.url);
|
|
if (this._themeController.outerTheme === 'site' && this._themeController.siteOverride && ['dark', 'light'].includes(this._themeController.theme)) {
|
|
this._themeController.outerTheme = this._themeController.theme;
|
|
}
|
|
this._initialWidth = general.popupWidth;
|
|
this._initialHeight = general.popupHeight;
|
|
this._horizontalOffset = general.popupHorizontalOffset;
|
|
this._verticalOffset = general.popupVerticalOffset;
|
|
this._horizontalOffset2 = general.popupHorizontalOffset2;
|
|
this._verticalOffset2 = general.popupVerticalOffset2;
|
|
this._verticalTextPosition = general.popupVerticalTextPosition;
|
|
this._horizontalTextPositionBelow = (general.popupHorizontalTextPosition === 'below');
|
|
this._displayMode = general.popupDisplayMode;
|
|
this._displayModeIsFullWidth = (this._displayMode === 'full-width');
|
|
this._scaleRelativeToVisualViewport = general.popupScaleRelativeToVisualViewport;
|
|
this._useSecureFrameUrl = general.useSecurePopupFrameUrl;
|
|
this._useShadowDom = general.usePopupShadowDom;
|
|
this._customOuterCss = general.customPopupOuterCss;
|
|
this._hidePopupOnCursorExit = scanning.hidePopupOnCursorExit;
|
|
this._hidePopupOnCursorExitDelay = scanning.hidePopupOnCursorExitDelay;
|
|
void this.updateTheme();
|
|
}
|
|
|
|
/**
|
|
* @param {import('settings').OptionsContext} optionsContext
|
|
*/
|
|
async _setOptionsContextIfDifferent(optionsContext) {
|
|
if (deepEqual(this._optionsContext, optionsContext)) { return; }
|
|
await this._setOptionsContext(optionsContext);
|
|
}
|
|
|
|
/**
|
|
* Computes the bounding rectangle for a set of rectangles.
|
|
* @param {import('popup').Rect[]} sourceRects An array of rectangles.
|
|
* @returns {import('popup').Rect} The bounding rectangle for all of the source rectangles.
|
|
*/
|
|
_getBoundingSourceRect(sourceRects) {
|
|
switch (sourceRects.length) {
|
|
case 0: return {left: 0, top: 0, right: 0, bottom: 0};
|
|
case 1: return sourceRects[0];
|
|
}
|
|
let {left, top, right, bottom} = sourceRects[0];
|
|
for (let i = 1, ii = sourceRects.length; i < ii; ++i) {
|
|
const sourceRect = sourceRects[i];
|
|
left = Math.min(left, sourceRect.left);
|
|
top = Math.min(top, sourceRect.top);
|
|
right = Math.max(right, sourceRect.right);
|
|
bottom = Math.max(bottom, sourceRect.bottom);
|
|
}
|
|
return {left, top, right, bottom};
|
|
}
|
|
|
|
/**
|
|
* Checks whether or not a rectangle is overlapping any other rectangles.
|
|
* @param {import('popup').SizeRect} sizeRect The rectangles to check for overlaps.
|
|
* @param {import('popup').Rect[]} sourceRects The list of rectangles to compare against.
|
|
* @param {number} ignoreIndex The index of an item in `sourceRects` to ignore.
|
|
* @returns {boolean} `true` if `sizeRect` overlaps any one of `sourceRects`, excluding `sourceRects[ignoreIndex]`; `false` otherwise.
|
|
*/
|
|
_isOverlapping(sizeRect, sourceRects, ignoreIndex) {
|
|
const {left, top} = sizeRect;
|
|
const right = left + sizeRect.width;
|
|
const bottom = top + sizeRect.height;
|
|
for (let i = 0, ii = sourceRects.length; i < ii; ++i) {
|
|
if (i === ignoreIndex) { continue; }
|
|
const sourceRect = sourceRects[i];
|
|
if (
|
|
left < sourceRect.right &&
|
|
right > sourceRect.left &&
|
|
top < sourceRect.bottom &&
|
|
bottom > sourceRect.top
|
|
) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Gets the bounding client rect for the frame element, with a coordinate conversion applied.
|
|
* @returns {DOMRect} The rectangle of the frame.
|
|
*/
|
|
_getFrameBoundingClientRect() {
|
|
return convertRectZoomCoordinates(this._frame.getBoundingClientRect(), this._container);
|
|
}
|
|
|
|
/**
|
|
* Converts the coordinate space of source rectangles.
|
|
* @param {import('popup').Rect[]} sourceRects The list of rectangles to convert.
|
|
* @returns {import('popup').Rect[]} Either an updated list of rectangles, or `sourceRects` if no change is required.
|
|
*/
|
|
_convertSourceRectsCoordinateSpace(sourceRects) {
|
|
let scale = computeZoomScale(this._container);
|
|
if (scale === 1) { return sourceRects; }
|
|
scale = 1 / scale;
|
|
const sourceRects2 = [];
|
|
for (const rect of sourceRects) {
|
|
sourceRects2.push(this._createScaledRect(rect, scale));
|
|
}
|
|
return sourceRects2;
|
|
}
|
|
|
|
/**
|
|
* Creates a scaled rectangle.
|
|
* @param {import('popup').Rect} rect The rectangle to scale.
|
|
* @param {number} scale The scale factor.
|
|
* @returns {import('popup').Rect} A new rectangle which has been scaled.
|
|
*/
|
|
_createScaledRect(rect, scale) {
|
|
return {
|
|
left: rect.left * scale,
|
|
top: rect.top * scale,
|
|
right: rect.right * scale,
|
|
bottom: rect.bottom * scale,
|
|
};
|
|
}
|
|
}
|
|
|
|
class PopupError extends ExtensionError {
|
|
/**
|
|
* @param {string} message
|
|
* @param {Popup} source
|
|
*/
|
|
constructor(message, source) {
|
|
super(message);
|
|
/** @type {string} */
|
|
this.name = 'PopupError';
|
|
/** @type {Popup} */
|
|
this._source = source;
|
|
}
|
|
|
|
/** @type {Popup} */
|
|
get source() { return this._source; }
|
|
}
|