mirror of
https://github.com/ksyasuda/SubMiner.git
synced 2026-09-22 17:16:19 -07:00
sudacode
d9fdc7ef6d
- Add backend selection, setup gating, Anki integration, and external host support - Add launcher flags, documentation, packaging, and focused tests - Open on-demand overlay modals on the first attempt
4064 lines
154 KiB
JavaScript
4064 lines
154 KiB
JavaScript
/*
|
|
* Hover scanning, popup hosting, and offscreen-engine messaging for
|
|
* Hachidori.
|
|
*
|
|
* Rendering lives in render/popup.js and render/glossary.js (ported from
|
|
* GameSentenceMiner PR #549); this file only produces the
|
|
* {sentence, matchOffset, sourceElements} candidates those modules consume and
|
|
* drives the request/reply state machine. Like Yomitan's default layout-unaware
|
|
* scan, page text is read in DOM order regardless of how it is boxed, and a
|
|
* pointer candidate's sources are the text nodes around the hovered glyph.
|
|
*
|
|
* Copyright (C) 2026 Manhhao
|
|
* SPDX-License-Identifier: GPL-3.0-or-later
|
|
*/
|
|
|
|
(function () {
|
|
"use strict";
|
|
|
|
const TARGET = "hoshidicts-offscreen";
|
|
const PAGE_ZOOM_TARGET = "hachidori-page-zoom";
|
|
const WORKER_TARGET = "hoshidicts-worker";
|
|
const READER_TARGET = "hachidori-reader";
|
|
const HIGHLIGHT_NAME = "gsm-hoshidicts-match";
|
|
const READER_STYLESHEET = "render/reader.css";
|
|
const HOST_TAG = "hachidori-host";
|
|
const POPUP_SHOWN_EVENT = "hachidori-popup-shown";
|
|
const POPUP_HIDDEN_EVENT = "hachidori-popup-hidden";
|
|
const EXTENSION_PROTOCOL = (() => {
|
|
try {
|
|
return new URL(chrome.runtime.getURL("")).protocol;
|
|
} catch {
|
|
return "";
|
|
}
|
|
})();
|
|
|
|
const {
|
|
DEFAULT_OPTIONS,
|
|
KEYBIND_MODIFIERS,
|
|
KEYBIND_MODIFIER_CODES,
|
|
clampOption,
|
|
definitionBlurFrequencyEvidence,
|
|
definitionBlurQualifies,
|
|
normaliseActivationKey,
|
|
projectContentOptions,
|
|
} = globalThis.HDReaderOptions;
|
|
const { normaliseDictionaryGroups } = globalThis.HDDictionaryGroups;
|
|
const { normaliseLookupTerm, lookupStatsKey } = globalThis.HDLookupStats;
|
|
const { normaliseDictionaryTab: normalizedDictionaryTab } = globalThis.HDPopup;
|
|
const MODIFIER_PROPERTIES = new Map([
|
|
["Shift", "shiftKey"],
|
|
["Control", "ctrlKey"],
|
|
["Alt", "altKey"],
|
|
["Meta", "metaKey"],
|
|
]);
|
|
|
|
const POPUP_GAP_PX = 4;
|
|
const POPUP_PADDING_PX = 6;
|
|
const MAX_MEDIA_CACHE_BYTES = 16 * 1024 * 1024;
|
|
const MAX_MEDIA_CACHE_ENTRIES = 64;
|
|
const MAX_MEDIA_CONCURRENT_REQUESTS = 4;
|
|
const MAX_MEDIA_PENDING_REQUESTS = 128;
|
|
const MEDIA_REQUEST_TIMEOUT_MS = 4000;
|
|
// Yomitan's sentence scan extent: how far the sentence reaches to either
|
|
// side of the hovered glyph before a newline cuts it.
|
|
const SENTENCE_SCAN_EXTENT = 200;
|
|
|
|
// Same character set PR #549 gates lookups on: kana, halfwidth katakana, CJK
|
|
// ideographs (including ext-A and ext-B), and the iteration/repeat marks.
|
|
const JAPANESE_CHARACTER_PATTERN =
|
|
/[々-〇〻-ヿㇰ-ㇿ㐀-䶿一-鿿豈-ｦ-ﾟ\u{20000}-\u{2fa1f}]/u;
|
|
const TOKEN_BOUNDARY_PATTERN = /[\p{White_Space}\p{Punctuation}\p{Symbol}]/u;
|
|
const COLLAPSIBLE_WHITESPACE_PATTERN = /[\t\n\r\f ]/u;
|
|
const SEGMENT_BREAK_PATTERN = /[\n\r]/u;
|
|
// Deliberately narrow: "receiving end does not exist" also fires while the
|
|
// service worker is still waking up, and tearing down on that would kill the
|
|
// content script over a transient race.
|
|
const INVALIDATED_MESSAGE_PATTERN = /context invalidated/iu;
|
|
|
|
// Text in these never belongs to the running prose: script and style hold
|
|
// source, rt/rp hold reading annotations that must not splice into the
|
|
// scanned string, and form controls hold values rather than page text.
|
|
const OPAQUE_TAGS = new Set([
|
|
"audio",
|
|
"canvas",
|
|
"embed",
|
|
"head",
|
|
"iframe",
|
|
"math",
|
|
"noscript",
|
|
"object",
|
|
"option",
|
|
"optgroup",
|
|
"rp",
|
|
"rt",
|
|
"script",
|
|
"select",
|
|
"style",
|
|
"svg",
|
|
"template",
|
|
"textarea",
|
|
"title",
|
|
"video",
|
|
]);
|
|
const EDITING_TAGS = new Set(["button", "input", "select", "textarea"]);
|
|
const EDITING_SELECTOR = [...EDITING_TAGS, "[contenteditable]"].join(",");
|
|
// A whitespace-only text node with a line break separates blocks in the
|
|
// source ("</p>\n<p>", an overlay's block separator) and ends the sentence.
|
|
const BLOCK_SEPARATOR_PATTERN = /^\s*[\n\r]\s*$/u;
|
|
const PRESERVED_WHITESPACE = new Set([
|
|
"pre",
|
|
"pre-wrap",
|
|
"pre-line",
|
|
"break-spaces",
|
|
]);
|
|
|
|
if (typeof document.createTreeWalker !== "function") {
|
|
return;
|
|
}
|
|
// The reader belongs to ordinary pages. First-run setup loads these same
|
|
// scripts into its own startup page for the practice step. Its native skip
|
|
// link may leave the known heading fragment before the module loads or on
|
|
// reload; query variants and every other internal page stay excluded.
|
|
if (
|
|
location.protocol === EXTENSION_PROTOCOL &&
|
|
location.href !== chrome.runtime.getURL("startup.html") &&
|
|
location.href !== chrome.runtime.getURL("startup.html#setup-heading")
|
|
) {
|
|
return;
|
|
}
|
|
|
|
let disposed = false;
|
|
let appearance;
|
|
let customStyle;
|
|
let audio, mining;
|
|
let options = { ...DEFAULT_OPTIONS };
|
|
let dictionaries = [];
|
|
let dictionaryGroups = [];
|
|
let nextRequestId = 0;
|
|
let currentGeneration = -1;
|
|
|
|
const rootLevel = createLevelState(0);
|
|
const levels = [rootLevel];
|
|
let nextLevelId = 0;
|
|
|
|
function createLevelState(depth) {
|
|
return {
|
|
depth, popup: null, view: null, highlighter: null, retired: false,
|
|
activeCandidate: null, activeSignature: null, activeHighlightText: "",
|
|
activeTermRender: null, currentViewRequest: null, noteEditing: false,
|
|
pendingCustomAppends: 0, deferredDictionaryInvalidationRevision: -1,
|
|
deferredRefresh: null, lookupToken: 0, pendingHover: null, pendingLink: null,
|
|
pendingPopupInteraction: null,
|
|
retainedView: false,
|
|
pendingViewReplay: null,
|
|
blurTimer: null,
|
|
capturePin: null,
|
|
capturePinPromise: null,
|
|
};
|
|
}
|
|
|
|
let host = null;
|
|
let shadow = null;
|
|
let highlighter = null;
|
|
let uiPromise = null;
|
|
let popupLayoutFrame = null;
|
|
let popupLayouts = new Map();
|
|
let pageZoom = 1;
|
|
let pageZoomRatio = null;
|
|
let pageZoomRequest = 0;
|
|
let sessionPopupSize = null;
|
|
let popupResize = null;
|
|
|
|
let styleGeneration = -1;
|
|
let styleRequest = null;
|
|
const mediaCache = new Map();
|
|
const pendingMedia = new Map();
|
|
let mediaCacheBytes = 0;
|
|
let activeMediaRequests = 0;
|
|
let mediaQueue = [];
|
|
let popupImageSources = null;
|
|
|
|
let lastPointer = null;
|
|
let scanTimer = null;
|
|
let hideTimer = null;
|
|
let transferTimer = null;
|
|
let descendantTimer = null;
|
|
let pointerLevel = null;
|
|
let pointerInPopup = false;
|
|
let activationPressed = false;
|
|
let activationCode = null;
|
|
let pendingCandidateLookup = null;
|
|
let selectionDragActive = false;
|
|
let activeSelectionCandidate = null;
|
|
// A drag the reader selects itself, glyph by glyph, in an overlay host.
|
|
let dragSelection = null;
|
|
let overlayMode = false;
|
|
let hostCapabilities = { linkButtons: true, externalLinkHost: false, mediaCapture: true };
|
|
let hostAttentionPublished = false;
|
|
let hostAttentionHold = 0;
|
|
|
|
let optionsStorageRevision = -1;
|
|
let ankiMaturityEpoch = 0;
|
|
let dictionaryStateRevision = -1;
|
|
let lookupStatsDescriptor = { generation: null, revision: -1 };
|
|
const DEFINITION_BLUR_KEYS = [
|
|
"definitionBlurEnabled", "definitionBlurAnkiMature", "definitionBlurFrequencyEnabled",
|
|
"definitionBlurFrequencyDictionary", "definitionBlurFrequencyOrder", "definitionBlurFrequencyThreshold",
|
|
"definitionBlurDirection", "definitionBlurThreshold", "definitionBlurReveal", "definitionBlurDelayMs",
|
|
];
|
|
|
|
function extensionAlive() {
|
|
try {
|
|
return Boolean(chrome && chrome.runtime && chrome.runtime.id);
|
|
} catch {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// An overlay host such as GSM passes clicks through to the game unless the
|
|
// reader says it needs the window. A popup needs it, and so does a drag that
|
|
// is selecting text: the host answers a mousedown by turning click-through on,
|
|
// which would lose the drag before release could look anything up. The claim
|
|
// carries over to the selection's pending lookup, so the host never sees a
|
|
// gap between the drag and the popup it produces.
|
|
function syncHostAttention() {
|
|
const wanted = Boolean(rootLevel.popup && !rootLevel.popup.hidden) || selectionDragActive
|
|
|| hostAttentionHold > 0 || pendingCandidateLookup?.candidate?.exactSelection === true;
|
|
if (wanted === hostAttentionPublished) return;
|
|
hostAttentionPublished = wanted;
|
|
globalThis.SubMinerHachidori?.attention(host, wanted);
|
|
window.dispatchEvent(new CustomEvent(wanted ? POPUP_SHOWN_EVENT : POPUP_HIDDEN_EVENT));
|
|
}
|
|
|
|
function setSelectionDrag(active) {
|
|
selectionDragActive = active;
|
|
if (!active) dragSelection = null;
|
|
syncHostAttention();
|
|
}
|
|
|
|
// Overlay hosts (docs/overlay-mode.md) set the flag in overlay-mode.js. This
|
|
// classic script reads the module through its extension URL; a host without
|
|
// it, such as a test page, gets the browser behaviour.
|
|
async function loadOverlayMode() {
|
|
try {
|
|
const module = await import(chrome.runtime.getURL("overlay-mode.js"));
|
|
overlayMode = module.OVERLAY_MODE === true;
|
|
const advertised = module.HOST_CAPABILITIES ?? {};
|
|
hostCapabilities = { ...hostCapabilities, ...advertised };
|
|
if (!Object.hasOwn(advertised, "linkButtons") && Object.hasOwn(advertised, "customLinks")) {
|
|
hostCapabilities.linkButtons = advertised.customLinks;
|
|
}
|
|
const next = applyHostCapabilities(options);
|
|
const customButtonsChanged = JSON.stringify(next.customButtons) !== JSON.stringify(options.customButtons);
|
|
const miningChanged = customButtonsChanged
|
|
|| JSON.stringify(next.mediaCapture) !== JSON.stringify(options.mediaCapture);
|
|
options = next;
|
|
if (customButtonsChanged) {
|
|
for (const level of levels) level.view?.setCustomButtons(options.customButtons);
|
|
}
|
|
if (miningChanged) mining?.update(options, optionsStorageRevision >= 0);
|
|
} catch {
|
|
overlayMode = false;
|
|
}
|
|
}
|
|
|
|
function applyHostCapabilities(projected) {
|
|
if (!hostCapabilities.mediaCapture) {
|
|
projected = { ...projected, mediaCapture: { ...projected.mediaCapture, enabled: false } };
|
|
}
|
|
if (!hostCapabilities.linkButtons) projected = {
|
|
...projected,
|
|
customLinks: [],
|
|
customButtons: projected.customButtons.filter(button => button.type !== "link"),
|
|
};
|
|
return projected;
|
|
}
|
|
|
|
const projectHostOptions = stored => applyHostCapabilities(projectContentOptions(stored));
|
|
|
|
function nonnegativeCount(value) {
|
|
const count = Math.trunc(Number(value));
|
|
return Number.isFinite(count) && count > 0 ? count : 0;
|
|
}
|
|
|
|
function normalizeDictionaryState(stored) {
|
|
const state = stored && typeof stored === "object" ? stored : {};
|
|
const rows = Array.isArray(state.dictionaries) ? state.dictionaries : [];
|
|
const normalized = rows.flatMap((entry) => {
|
|
const title = typeof entry?.title === "string" ? entry.title : "";
|
|
if (!title) {
|
|
return [];
|
|
}
|
|
return [{
|
|
id: typeof entry.id === "string" ? entry.id : "",
|
|
title,
|
|
displayName: typeof entry.displayName === "string" && entry.displayName.trim() !== ""
|
|
? entry.displayName.trim()
|
|
: null,
|
|
path: typeof entry.path === "string" ? entry.path : "",
|
|
revision: typeof entry.revision === "string" ? entry.revision : "",
|
|
enabled: entry.enabled !== false,
|
|
favorite: entry.favorite === true,
|
|
termCount: nonnegativeCount(entry.termCount),
|
|
frequencyCount: nonnegativeCount(entry.frequencyCount),
|
|
frequencyMode: entry.frequencyMode,
|
|
pitchCount: nonnegativeCount(entry.pitchCount),
|
|
kanjiCount: nonnegativeCount(entry.kanjiCount),
|
|
longKeyLength: nonnegativeCount(entry.longKeyLength),
|
|
}];
|
|
});
|
|
return {
|
|
revision: Number.isInteger(state.revision) && state.revision >= 0 ? state.revision : 0,
|
|
dictionaries: normalized,
|
|
groups: normaliseDictionaryGroups(state.groups, normalized),
|
|
};
|
|
}
|
|
|
|
function sameDictionaries(left, right) {
|
|
return JSON.stringify(left) === JSON.stringify(right);
|
|
}
|
|
|
|
function sameDictionaryContents(left, right) {
|
|
const contents = (entries) => entries.map(({ displayName, favorite, frequencyMode, ...dictionary }) => dictionary);
|
|
return left === right || sameDictionaries(contents(left), contents(right));
|
|
}
|
|
|
|
function dictionaryPresentation() {
|
|
return dictionaries
|
|
.filter((entry) => entry.enabled !== false)
|
|
.map((entry) => ({
|
|
id: entry.id,
|
|
title: entry.title,
|
|
favorite: entry.favorite,
|
|
frequencyMode: entry.frequencyMode,
|
|
...(entry.displayName ? { displayName: entry.displayName } : {}),
|
|
}));
|
|
}
|
|
|
|
function dictionaryTabGroups() {
|
|
const titles = new Map(dictionaries.filter((entry) => entry.enabled)
|
|
.map((entry) => [entry.id, entry.title]));
|
|
return dictionaryGroups.map((group) => ({
|
|
id: group.id,
|
|
name: group.name,
|
|
dictionaries: group.dictionaryIds.filter((id) => titles.has(id)).map((id) => titles.get(id)),
|
|
}));
|
|
}
|
|
|
|
function selectedKanjiDictionaryCapability() {
|
|
return globalThis.HDReaderOptions.resolveKanjiDictionary(options.kanjiClickDictionary, dictionaries);
|
|
}
|
|
|
|
function projectResultsToDictionary(results, title) {
|
|
const projected = [];
|
|
for (const result of results) {
|
|
const glossaries = Array.isArray(result?.term?.glossaries)
|
|
? result.term.glossaries.filter((glossary) => glossary && glossary.dictionary === title)
|
|
: [];
|
|
if (glossaries.length > 0) {
|
|
projected.push({
|
|
...result,
|
|
term: { ...result.term, glossaries },
|
|
});
|
|
}
|
|
}
|
|
return projected;
|
|
}
|
|
|
|
function isJapaneseToken(text) {
|
|
const token = text.split(TOKEN_BOUNDARY_PATTERN, 1)[0];
|
|
return JAPANESE_CHARACTER_PATTERN.test(token);
|
|
}
|
|
|
|
function computedStyleFor(element, styleCache) {
|
|
let style = styleCache.get(element);
|
|
if (!style) {
|
|
style = window.getComputedStyle(element);
|
|
styleCache.set(element, style);
|
|
}
|
|
return style;
|
|
}
|
|
|
|
function isHiddenElement(element, styleCache) {
|
|
const style = computedStyleFor(element, styleCache);
|
|
return style.display === "none" ||
|
|
style.visibility === "hidden" ||
|
|
style.visibility === "collapse";
|
|
}
|
|
|
|
function preservesWhitespace(element, styleCache) {
|
|
if (!element) {
|
|
return false;
|
|
}
|
|
const style = computedStyleFor(element, styleCache);
|
|
const collapse = style.whiteSpaceCollapse;
|
|
if (typeof collapse === "string" && collapse) {
|
|
return collapse !== "collapse";
|
|
}
|
|
return PRESERVED_WHITESPACE.has(style.whiteSpace);
|
|
}
|
|
|
|
function isOurNode(node) {
|
|
if (!host) {
|
|
return false;
|
|
}
|
|
// The popup lives in a closed shadow root, so a caret or event inside it is
|
|
// retargeted to the host; a node whose root is not the page document also
|
|
// means "not page text" (user-agent shadow DOM of <input>, page shadow DOM).
|
|
return node === host || (node.nodeType === Node.ELEMENT_NODE
|
|
? host.contains(node)
|
|
: host.contains(node.parentNode));
|
|
}
|
|
|
|
/**
|
|
* Both caret APIs return the nearest caret *boundary*, so a pointer in the
|
|
* right half of a glyph reports the offset after it and the scan would start
|
|
* one character late -- pointing straight at 食 in 食べたかった would look up
|
|
* べたかった. Step back onto the preceding character when the pointer is
|
|
* actually inside its box.
|
|
*/
|
|
function alignToCharacter(range, clientX, clientY) {
|
|
const node = range.startContainer;
|
|
const offset = range.startOffset;
|
|
if (!range.collapsed || offset === 0 || node.nodeType !== Node.TEXT_NODE) {
|
|
return range;
|
|
}
|
|
const probe = document.createRange();
|
|
try {
|
|
probe.setStart(node, offset - 1);
|
|
probe.setEnd(node, offset);
|
|
} catch {
|
|
return range;
|
|
}
|
|
for (const rect of probe.getClientRects()) {
|
|
if (
|
|
clientX >= rect.left && clientX <= rect.right &&
|
|
clientY >= rect.top && clientY <= rect.bottom
|
|
) {
|
|
range.setStart(node, offset - 1);
|
|
range.collapse(true);
|
|
return range;
|
|
}
|
|
}
|
|
return range;
|
|
}
|
|
|
|
function rangeFromCaretPosition(position, clientX, clientY) {
|
|
if (!position) {
|
|
return null;
|
|
}
|
|
const range = document.createRange();
|
|
try {
|
|
range.setStart(position.offsetNode, position.offset);
|
|
range.setEnd(position.offsetNode, position.offset);
|
|
} catch {
|
|
return null;
|
|
}
|
|
return alignToCharacter(range, clientX, clientY);
|
|
}
|
|
|
|
function caretRangeAt(clientX, clientY, shadowRoot = null) {
|
|
if (shadowRoot) {
|
|
if (typeof document.caretPositionFromPoint !== "function") {
|
|
return null;
|
|
}
|
|
try {
|
|
return rangeFromCaretPosition(
|
|
document.caretPositionFromPoint(clientX, clientY, {
|
|
shadowRoots: [shadowRoot],
|
|
}),
|
|
clientX,
|
|
clientY
|
|
);
|
|
} catch {
|
|
return null;
|
|
}
|
|
}
|
|
if (typeof document.caretRangeFromPoint === "function") {
|
|
const range = document.caretRangeFromPoint(clientX, clientY);
|
|
return range === null ? null : alignToCharacter(range, clientX, clientY);
|
|
}
|
|
if (typeof document.caretPositionFromPoint === "function") {
|
|
return rangeFromCaretPosition(
|
|
document.caretPositionFromPoint(clientX, clientY),
|
|
clientX,
|
|
clientY
|
|
);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* The glyph under the pointer as a text range, for a drag the reader selects
|
|
* itself. An overlay boxes each glyph in a span wider than the glyph, and from
|
|
* the box's trailing margin the caret APIs report the boundary after its text;
|
|
* the box still belongs to its last glyph.
|
|
*/
|
|
function glyphAtPoint(clientX, clientY) {
|
|
const range = caretRangeAt(clientX, clientY);
|
|
const node = range?.startContainer;
|
|
if (!node || !isScannableTextNode(node, new Map())) return null;
|
|
const text = node.nodeValue || "";
|
|
let offset = range.startOffset;
|
|
if (offset >= text.length) {
|
|
const box = node.parentElement.getBoundingClientRect();
|
|
if (text.length === 0 || clientX < box.left || clientX > box.right
|
|
|| clientY < box.top || clientY > box.bottom) return null;
|
|
offset = text.length - 1;
|
|
if (offset > 0 && (text.charCodeAt(offset) & 0xfc00) === 0xdc00) offset -= 1;
|
|
}
|
|
return { node, start: offset, end: offset + (text.codePointAt(offset) > 0xffff ? 2 : 1) };
|
|
}
|
|
|
|
function isEditingElement(element) {
|
|
return element?.isContentEditable === true || EDITING_TAGS.has(element?.localName);
|
|
}
|
|
|
|
function pageEditorFocused() {
|
|
for (let focused = document.activeElement; focused; focused = focused.shadowRoot?.activeElement) {
|
|
if (isEditingElement(focused)) {
|
|
// Startup is the only extension page allowed above. Its scene arrow
|
|
// keeps keyboard focus without pausing the practice lookup.
|
|
if (location.protocol === EXTENSION_PROTOCOL && focused.matches(".vn-next")) continue;
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
function isScannableElement(element, styleCache) {
|
|
if (!element || element.getRootNode() !== document || isOurNode(element) || isHiddenElement(element, styleCache)) {
|
|
return false;
|
|
}
|
|
for (let current = element; current; current = current.parentElement) {
|
|
if (isEditingElement(current) || OPAQUE_TAGS.has(current.localName)
|
|
|| computedStyleFor(current, styleCache).display === "none") {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
function isScannableTextNode(node, styleCache) {
|
|
return node?.nodeType === Node.TEXT_NODE && isScannableElement(node.parentElement, styleCache);
|
|
}
|
|
|
|
function createScanWalker(root, styleCache) {
|
|
return document.createTreeWalker(
|
|
root,
|
|
NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_TEXT,
|
|
{
|
|
acceptNode(node) {
|
|
if (node.nodeType === Node.TEXT_NODE) {
|
|
return isHiddenElement(node.parentElement, styleCache) ? NodeFilter.FILTER_REJECT : NodeFilter.FILTER_ACCEPT;
|
|
}
|
|
const editing = isEditingElement(node);
|
|
if (
|
|
(!editing && OPAQUE_TAGS.has(node.localName)) ||
|
|
isOurNode(node) ||
|
|
computedStyleFor(node, styleCache).display === "none"
|
|
) {
|
|
return NodeFilter.FILTER_REJECT;
|
|
}
|
|
if (editing) return hasVisibleContent(node, styleCache) ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_REJECT;
|
|
// Visible controls and line breaks are boundaries. Every other element
|
|
// is crossed whatever its layout, as Yomitan's layout-unaware scan
|
|
// does: a word boxed one glyph per positioned span is still one word.
|
|
// Hidden wrappers are skipped too, since a descendant may restore
|
|
// visibility.
|
|
return node.localName === "br"
|
|
? NodeFilter.FILTER_ACCEPT
|
|
: NodeFilter.FILTER_SKIP;
|
|
},
|
|
}
|
|
);
|
|
}
|
|
|
|
/**
|
|
* The text nodes around `startNode`, in document order, that make up the
|
|
* sentence: neighbours up to SENTENCE_SCAN_EXTENT characters each way, cut at
|
|
* a block separator, a line break or a control. They are the candidate's
|
|
* `sourceElements`, so `sourceElements.map(textContent).join("") === sentence`
|
|
* holds by construction, which is what createSourceHighlighter requires.
|
|
*/
|
|
function collectSentenceSources(startNode, root, styleCache) {
|
|
const sources = [startNode];
|
|
for (const backward of [true, false]) {
|
|
const walker = createScanWalker(root, styleCache);
|
|
walker.currentNode = startNode;
|
|
let length = 0;
|
|
while (length < SENTENCE_SCAN_EXTENT) {
|
|
const node = backward ? walker.previousNode() : walker.nextNode();
|
|
if (
|
|
!node ||
|
|
node.nodeType !== Node.TEXT_NODE ||
|
|
BLOCK_SEPARATOR_PATTERN.test(node.nodeValue || "") ||
|
|
// The walker stops at a control going forward but reaches its text
|
|
// first going backward.
|
|
(backward && isEditingElement(node.parentElement?.closest(EDITING_SELECTOR)))
|
|
) {
|
|
break;
|
|
}
|
|
if (backward) sources.unshift(node); else sources.push(node);
|
|
length += (node.nodeValue || "").length;
|
|
}
|
|
}
|
|
return sources;
|
|
}
|
|
|
|
function withinSources(sources, node) {
|
|
return sources.some((source) => source === node
|
|
|| (source.nodeType === Node.ELEMENT_NODE && source.contains(node)));
|
|
}
|
|
|
|
/** `offset` inside `node` expressed in the concatenated text of `sources`. */
|
|
function sourceOffset(sources, node, offset) {
|
|
let consumed = 0;
|
|
for (const source of sources) {
|
|
if (source === node) return consumed + offset;
|
|
if (source.nodeType === Node.ELEMENT_NODE && source.contains(node)) {
|
|
return consumed + rangeOffsetWithin(source, node, offset);
|
|
}
|
|
consumed += (source.textContent || "").length;
|
|
}
|
|
throw new RangeError("node is not inside the candidate sources");
|
|
}
|
|
|
|
function pushCollapsedSpace(entries, node, offset, sourceLength, segmentBreak) {
|
|
const previous = entries[entries.length - 1];
|
|
if (previous && previous.collapsed) {
|
|
// A run split across text nodes ("<span>食べ </span><span> ます</span>")
|
|
// is still one collapsed space in the rendered line.
|
|
previous.segmentBreak = previous.segmentBreak || segmentBreak;
|
|
return;
|
|
}
|
|
entries.push({
|
|
collapsed: true,
|
|
node,
|
|
offset,
|
|
segmentBreak,
|
|
sourceLength,
|
|
text: " ",
|
|
});
|
|
}
|
|
|
|
/** Appends `node`'s characters from `from` onward; false stops the walk. */
|
|
function appendTextNode(entries, node, from, budget, styleCache) {
|
|
const raw = node.nodeValue || "";
|
|
const preserve = preservesWhitespace(node.parentElement, styleCache);
|
|
let index = from;
|
|
while (index < raw.length && entries.length < budget) {
|
|
const character = String.fromCodePoint(raw.codePointAt(index));
|
|
if (preserve) {
|
|
if (SEGMENT_BREAK_PATTERN.test(character)) {
|
|
return false;
|
|
}
|
|
} else if (COLLAPSIBLE_WHITESPACE_PATTERN.test(character)) {
|
|
let end = index;
|
|
let segmentBreak = false;
|
|
while (
|
|
end < raw.length &&
|
|
COLLAPSIBLE_WHITESPACE_PATTERN.test(raw[end])
|
|
) {
|
|
segmentBreak = segmentBreak || SEGMENT_BREAK_PATTERN.test(raw[end]);
|
|
end += 1;
|
|
}
|
|
pushCollapsedSpace(entries, node, index, end - index, segmentBreak);
|
|
index = end;
|
|
continue;
|
|
}
|
|
entries.push({
|
|
collapsed: false,
|
|
node,
|
|
offset: index,
|
|
segmentBreak: false,
|
|
sourceLength: character.length,
|
|
text: character,
|
|
});
|
|
index += character.length;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
function dropCjkSegmentBreaks(entries) {
|
|
for (let index = entries.length - 1; index >= 1; index -= 1) {
|
|
const entry = entries[index];
|
|
const next = entries[index + 1];
|
|
if (!entry.collapsed || !entry.segmentBreak || !next) {
|
|
continue;
|
|
}
|
|
// CSS drops a segment break between two wide characters instead of
|
|
// turning it into a space, so a source-wrapped 「日本\n語」 renders as
|
|
// 日本語 and has to be scanned that way.
|
|
if (
|
|
JAPANESE_CHARACTER_PATTERN.test(entries[index - 1].text) &&
|
|
JAPANESE_CHARACTER_PATTERN.test(next.text)
|
|
) {
|
|
entries.splice(index, 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
// How many code points of page text a lookup is given. The engine scans
|
|
// options.scanLength of them as before, and reaches further only when the
|
|
// text begins like a dictionary key longer than that (hoshidicts long-key
|
|
// index; each package row carries the longest such key it lists). Eight more
|
|
// leaves room for an inflected ending, matching the engine. Dictionaries
|
|
// imported before the index existed report 0 and cost nothing extra. Off by
|
|
// default: Settings → Advanced → Experimental features → Long dictionary
|
|
// entries switches it on.
|
|
const LONG_KEY_INFLECTION_SLACK = 8;
|
|
const MAX_SCAN_WINDOW = 256;
|
|
|
|
function scanWindow() {
|
|
if (options.experimental.longKeyScan !== true) return options.scanLength;
|
|
let longest = 0;
|
|
for (const entry of dictionaries) {
|
|
if (entry.enabled !== false && entry.termCount > 0 && entry.longKeyLength > longest) {
|
|
longest = entry.longKeyLength;
|
|
}
|
|
}
|
|
if (longest === 0) return options.scanLength;
|
|
return Math.min(MAX_SCAN_WINDOW, Math.max(options.scanLength, longest + LONG_KEY_INFLECTION_SLACK));
|
|
}
|
|
|
|
function collectScanEntries(startNode, startOffset, root, scanLength, styleCache) {
|
|
const walker = createScanWalker(root, styleCache);
|
|
walker.currentNode = startNode;
|
|
|
|
const entries = [];
|
|
// Collapsing and segment-break removal can only shorten the scan, so
|
|
// over-collect and trim once the string is final.
|
|
const budget = scanLength * 3 + 32;
|
|
let node = startNode;
|
|
let offset = startOffset;
|
|
while (node && node.nodeType === Node.TEXT_NODE && entries.length < budget) {
|
|
if (!appendTextNode(entries, node, offset, budget, styleCache)) {
|
|
break;
|
|
}
|
|
offset = 0;
|
|
node = walker.nextNode();
|
|
// A word never continues into the next block, as Yomitan's kept "\n"
|
|
// ends its match there.
|
|
if (node?.nodeType === Node.TEXT_NODE && BLOCK_SEPARATOR_PATTERN.test(node.nodeValue || "")) {
|
|
break;
|
|
}
|
|
}
|
|
dropCjkSegmentBreaks(entries);
|
|
return entries.slice(0, scanLength);
|
|
}
|
|
|
|
function rangeOffsetWithin(container, node, offset) {
|
|
const range = document.createRange();
|
|
range.selectNodeContents(container);
|
|
range.setEnd(node, offset);
|
|
return range.toString().length;
|
|
}
|
|
|
|
/**
|
|
* Builds a candidate for the caret at (clientX, clientY), or null when there
|
|
* is nothing Japanese to look up there.
|
|
*/
|
|
function resolveCandidate(clientX, clientY) {
|
|
const caretRange = caretRangeAt(clientX, clientY);
|
|
if (!caretRange) {
|
|
return null;
|
|
}
|
|
return resolveCandidateAt(caretRange.startContainer, caretRange.startOffset);
|
|
}
|
|
|
|
function resolveCandidateAt(startNode, startOffset) {
|
|
const styleCache = new Map();
|
|
if (!isScannableTextNode(startNode, styleCache)) {
|
|
return null;
|
|
}
|
|
const entries = collectScanEntries(
|
|
startNode,
|
|
Math.min(startOffset, (startNode.nodeValue || "").length),
|
|
document.body,
|
|
scanWindow(),
|
|
styleCache
|
|
);
|
|
if (entries.length === 0) {
|
|
return null;
|
|
}
|
|
const query = entries.map((entry) => entry.text).join("");
|
|
if (options.onlyScanJapaneseText && !isJapaneseToken(query)) {
|
|
return null;
|
|
}
|
|
|
|
const first = entries[0];
|
|
const sourceElements = collectSentenceSources(first.node, document.body, styleCache);
|
|
let matchOffset;
|
|
let anchorRange;
|
|
try {
|
|
matchOffset = sourceOffset(sourceElements, first.node, first.offset);
|
|
anchorRange = document.createRange();
|
|
anchorRange.setStart(first.node, first.offset);
|
|
anchorRange.setEnd(
|
|
first.node,
|
|
Math.min(
|
|
(first.node.nodeValue || "").length,
|
|
first.offset + first.sourceLength
|
|
)
|
|
);
|
|
} catch {
|
|
return null;
|
|
}
|
|
return {
|
|
anchor: first.node.parentElement,
|
|
anchorRange,
|
|
matchOffset,
|
|
query,
|
|
scanEntries: entries,
|
|
sentence: sourceElements.map((source) => source.nodeValue || "").join(""),
|
|
sourceDepth: -1,
|
|
sourceElements,
|
|
vertical: computedStyleFor(first.node.parentElement, styleCache)
|
|
.writingMode.startsWith("vertical"),
|
|
};
|
|
}
|
|
|
|
function resolveDefinitionCandidate(clientX, clientY, level) {
|
|
if (
|
|
!shadow ||
|
|
!level ||
|
|
level.retired ||
|
|
levels[level.depth] !== level ||
|
|
!level.popup ||
|
|
level.popup.hidden
|
|
) {
|
|
return null;
|
|
}
|
|
const styleCache = new Map();
|
|
const caretRange = caretRangeAt(clientX, clientY, shadow);
|
|
if (!caretRange) {
|
|
return null;
|
|
}
|
|
const startNode = caretRange.startContainer;
|
|
if (startNode.nodeType !== Node.TEXT_NODE) {
|
|
return null;
|
|
}
|
|
const lookupText = startNode.parentElement?.closest(
|
|
".gsm-hoshidicts-glossary-content, .gsm-hoshidicts-compact-definition-summary"
|
|
);
|
|
if (
|
|
!lookupText ||
|
|
!level.popup.contains(lookupText) ||
|
|
!lookupText.contains(startNode)
|
|
) {
|
|
return null;
|
|
}
|
|
for (
|
|
let current = startNode.parentElement;
|
|
current;
|
|
current = current.parentElement
|
|
) {
|
|
if (
|
|
isHiddenElement(current, styleCache) ||
|
|
isEditingElement(current) ||
|
|
current.localName === "a" ||
|
|
OPAQUE_TAGS.has(current.localName) ||
|
|
computedStyleFor(current, styleCache).display === "none"
|
|
) {
|
|
return null;
|
|
}
|
|
if (current === lookupText) {
|
|
break;
|
|
}
|
|
if (current === level.popup) {
|
|
return null;
|
|
}
|
|
}
|
|
let entries = collectScanEntries(
|
|
startNode,
|
|
Math.min(caretRange.startOffset, (startNode.nodeValue || "").length),
|
|
lookupText,
|
|
scanWindow(),
|
|
styleCache
|
|
);
|
|
const linkBoundary = entries.findIndex((entry) =>
|
|
entry.node.parentElement?.closest("a")
|
|
);
|
|
if (linkBoundary >= 0) {
|
|
entries = entries.slice(0, linkBoundary);
|
|
}
|
|
if (entries.length === 0) {
|
|
return null;
|
|
}
|
|
const query = entries.map((entry) => entry.text).join("");
|
|
if (options.onlyScanJapaneseText && !isJapaneseToken(query)) {
|
|
return null;
|
|
}
|
|
const first = entries[0];
|
|
let matchOffset;
|
|
let anchorRange;
|
|
try {
|
|
matchOffset = rangeOffsetWithin(lookupText, first.node, first.offset);
|
|
anchorRange = document.createRange();
|
|
anchorRange.setStart(first.node, first.offset);
|
|
anchorRange.setEnd(
|
|
first.node,
|
|
Math.min(
|
|
(first.node.nodeValue || "").length,
|
|
first.offset + first.sourceLength
|
|
)
|
|
);
|
|
} catch {
|
|
return null;
|
|
}
|
|
return {
|
|
anchor: lookupText,
|
|
anchorRange,
|
|
matchOffset,
|
|
query,
|
|
scanEntries: entries,
|
|
sentence: lookupText.textContent || "",
|
|
sourceDepth: level.depth,
|
|
sourceElements: [lookupText],
|
|
vertical: computedStyleFor(lookupText, styleCache)
|
|
.writingMode.startsWith("vertical"),
|
|
};
|
|
}
|
|
|
|
function selectionBoundaryElement(node) {
|
|
return node.nodeType === Node.ELEMENT_NODE ? node : node.parentElement;
|
|
}
|
|
|
|
function hasVisibleContent(element, styleCache) {
|
|
if (computedStyleFor(element, styleCache).display === "none") return false;
|
|
const visible = !isHiddenElement(element, styleCache);
|
|
if (visible && element.getClientRects().length > 0) return true;
|
|
for (const child of element.childNodes) {
|
|
if (child.nodeType === Node.ELEMENT_NODE && hasVisibleContent(child, styleCache)) return true;
|
|
if (visible && child.nodeType === Node.TEXT_NODE) {
|
|
// A display:contents editor has no box, but its editable text still does.
|
|
const range = document.createRange();
|
|
range.selectNodeContents(child);
|
|
if (range.getClientRects().length > 0) return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
function resolveSelectedLookupCandidate(selection = window.getSelection()) {
|
|
if (!selection || selection.rangeCount !== 1 || selection.isCollapsed) return null;
|
|
const range = selection.getRangeAt(0);
|
|
const styleCache = new Map();
|
|
if (!isScannableElement(selectionBoundaryElement(range.startContainer), styleCache)
|
|
|| !isScannableElement(selectionBoundaryElement(range.endContainer), styleCache)) return null;
|
|
const query = selection.toString();
|
|
if (!query.trim()) return null;
|
|
const anchor = selectionBoundaryElement(range.commonAncestorContainer);
|
|
for (const control of anchor.querySelectorAll(EDITING_SELECTOR)) {
|
|
if (isEditingElement(control) && range.intersectsNode(control)
|
|
&& hasVisibleContent(control, styleCache)) return null;
|
|
}
|
|
return {
|
|
anchor,
|
|
anchorRange: range.cloneRange(),
|
|
exactSelection: true,
|
|
matchOffset: rangeOffsetWithin(anchor, range.startContainer, range.startOffset),
|
|
query,
|
|
rawSelectionText: range.toString(),
|
|
sentence: anchor.textContent || "",
|
|
sourceDepth: -1,
|
|
sourceElements: [anchor],
|
|
vertical: computedStyleFor(anchor, styleCache).writingMode.startsWith("vertical"),
|
|
};
|
|
}
|
|
|
|
// Yomitan's Scan text at selection: an ordinary scan from the selection's
|
|
// first text. The live selection, not the scanned word, keeps it retained.
|
|
function resolveSelectionScanCandidate(selection = window.getSelection()) {
|
|
if (!selection || selection.rangeCount !== 1 || selection.isCollapsed) return null;
|
|
const range = selection.getRangeAt(0);
|
|
let node = range.startContainer, offset = range.startOffset;
|
|
if (node.nodeType !== Node.TEXT_NODE) {
|
|
const walker = document.createTreeWalker(range.commonAncestorContainer, NodeFilter.SHOW_TEXT);
|
|
do node = walker.nextNode(); while (node && !range.intersectsNode(node));
|
|
offset = 0;
|
|
}
|
|
const candidate = node ? resolveCandidateAt(node, offset) : null;
|
|
return candidate && { ...candidate, selectionRange: range.cloneRange(), selectionText: selection.toString() };
|
|
}
|
|
|
|
function candidateStart(candidate) {
|
|
if (candidate.linkAnchor) return { node: candidate.anchor, offset: 0 };
|
|
return candidate.exactSelection === true
|
|
? { node: candidate.anchorRange.startContainer, offset: candidate.anchorRange.startOffset }
|
|
: candidate.scanEntries[0];
|
|
}
|
|
|
|
function candidateSignature(candidate) {
|
|
const first = candidateStart(candidate);
|
|
return `${candidate.exactSelection === true}\u001f${first.offset}\u001f${candidate.matchOffset}\u001f${candidate.query}`;
|
|
}
|
|
|
|
function sameAnchorNode(candidate, other) {
|
|
return Boolean(other) &&
|
|
other.anchor === candidate.anchor &&
|
|
candidateStart(other).node === candidateStart(candidate).node;
|
|
}
|
|
|
|
/** Returns the last scanned source character covered by the engine match. */
|
|
function matchedScanEnd(candidate, matched) {
|
|
const wanted = typeof matched === "string" ? matched.length : 0;
|
|
if (wanted <= 0 || !Array.isArray(candidate.scanEntries)) return null;
|
|
let consumed = 0;
|
|
let last = null;
|
|
for (const entry of candidate.scanEntries) {
|
|
if (consumed >= wanted) {
|
|
break;
|
|
}
|
|
consumed += entry.text.length;
|
|
last = entry;
|
|
}
|
|
return last;
|
|
}
|
|
|
|
function expandCandidateAnchor(candidate, matched) {
|
|
if (candidate.linkAnchor || candidate.exactSelection === true || !candidate.anchorRange) return;
|
|
const first = candidate.scanEntries?.[0];
|
|
const last = matchedScanEnd(candidate, matched);
|
|
if (!first || !last) return;
|
|
// A page can move scanned text while the lookup is pending.
|
|
if (!withinSources(candidate.sourceElements, first.node) || !withinSources(candidate.sourceElements, last.node)) return;
|
|
try {
|
|
// Scanning starts with a one-glyph range. Once lookup identifies the
|
|
// complete match, place the popup against that word like Yomitan/PR 549.
|
|
const range = document.createRange();
|
|
range.setStart(first.node, first.offset);
|
|
range.setEnd(
|
|
last.node,
|
|
Math.min(
|
|
(last.node.nodeValue || "").length,
|
|
last.offset + last.sourceLength
|
|
)
|
|
);
|
|
if (!range.collapsed) candidate.anchorRange = range;
|
|
} catch {
|
|
// Keep the original hovered-glyph range if the page changed meanwhile.
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Translates a matched length in scan coordinates into the raw substring of
|
|
* `candidate.sentence` that covers it. createSourceHighlighter measures the
|
|
* highlight as `matchedText.length` from `candidate.matchOffset` inside
|
|
* `sentence`, and `sentence` still carries the rt text and uncollapsed
|
|
* whitespace the scan dropped -- so the engine's own `matched` string is the
|
|
* wrong length whenever the word crosses ruby or a line wrap.
|
|
*/
|
|
function rawMatchedText(candidate, matched) {
|
|
if (candidate.linkAnchor) return candidate.sentence;
|
|
if (candidate.exactSelection === true) return candidate.rawSelectionText;
|
|
const last = matchedScanEnd(candidate, matched);
|
|
if (!last) {
|
|
return "";
|
|
}
|
|
try {
|
|
const end = sourceOffset(
|
|
candidate.sourceElements,
|
|
last.node,
|
|
Math.min(
|
|
(last.node.nodeValue || "").length,
|
|
last.offset + last.sourceLength
|
|
)
|
|
);
|
|
if (end > candidate.matchOffset) {
|
|
return candidate.sentence.slice(candidate.matchOffset, end);
|
|
}
|
|
} catch {
|
|
// Fall through to the engine's own string.
|
|
}
|
|
return matched;
|
|
}
|
|
|
|
function releaseCapture(value) {
|
|
if (!value) return;
|
|
void Promise.resolve(value).then(pin => window.HDCapture?.release(pin)).catch(() => {});
|
|
}
|
|
|
|
function releaseProvisionalCapture(value, level) {
|
|
// Child requests borrow the root pin. A root replay also borrows the pin
|
|
// already adopted by the visible popup, even if that replay becomes stale.
|
|
if (level !== rootLevel) return;
|
|
void Promise.resolve(value).then(pin => {
|
|
if (pin !== rootLevel.capturePin) releaseCapture(pin);
|
|
}).catch(() => {});
|
|
}
|
|
|
|
function releaseRootCapture() {
|
|
const capture = rootLevel.capturePinPromise ?? rootLevel.capturePin;
|
|
rootLevel.capturePin = null;
|
|
rootLevel.capturePinPromise = null;
|
|
releaseCapture(capture);
|
|
}
|
|
|
|
function teardown(reason) {
|
|
if (disposed) {
|
|
return;
|
|
}
|
|
releaseRootCapture();
|
|
audio?.dispose();
|
|
mining?.retire();
|
|
disposed = true;
|
|
disconnectSubminer?.();
|
|
selectionDragActive = false;
|
|
dragSelection = null;
|
|
cancelPopupLayout();
|
|
clearDictionaryResources();
|
|
window.clearTimeout(scanTimer);
|
|
window.clearTimeout(hideTimer);
|
|
clearTransferTimer();
|
|
clearDescendantTimer();
|
|
scanTimer = null;
|
|
hideTimer = null;
|
|
document.removeEventListener("mousemove", onMouseMove, true);
|
|
document.removeEventListener("mousedown", onMouseDown, true);
|
|
document.removeEventListener("mouseup", onMouseUp, true);
|
|
document.removeEventListener("selectionchange", onSelectionChange);
|
|
document.removeEventListener("focusin", onPageFocusIn, true);
|
|
document.removeEventListener("keydown", onKeyDown, true);
|
|
document.removeEventListener("keyup", onKeyUp, true);
|
|
document.removeEventListener("mouseout", onMouseOut, true);
|
|
window.removeEventListener("scroll", onScroll, true);
|
|
window.removeEventListener("blur", onWindowBlur);
|
|
window.removeEventListener("pagehide", onPageHide);
|
|
window.removeEventListener("pageshow", onPageShow);
|
|
window.removeEventListener("resize", refreshPageZoom);
|
|
try {
|
|
chrome.storage.onChanged.removeListener(onStorageChanged);
|
|
chrome.runtime.onMessage?.removeListener(onReaderCommand);
|
|
} catch {
|
|
// The context is already gone; the listener died with it.
|
|
}
|
|
try {
|
|
highlighter?.clearAll();
|
|
for (const level of levels) level.view?.destroy();
|
|
} catch {
|
|
// Teardown is best effort.
|
|
}
|
|
appearance?.destroy();
|
|
customStyle?.destroy();
|
|
host?.remove();
|
|
host = null;
|
|
shadow = null;
|
|
rootLevel.popup = null;
|
|
rootLevel.view = null;
|
|
highlighter = null;
|
|
rootLevel.activeCandidate = null;
|
|
rootLevel.activeTermRender = null;
|
|
rootLevel.currentViewRequest = null;
|
|
rootLevel.noteEditing = false;
|
|
syncHostAttention();
|
|
if (reason) {
|
|
console.debug(`hachidori: content script stopped (${reason})`);
|
|
}
|
|
}
|
|
|
|
function discardUi() {
|
|
releaseRootCapture();
|
|
audio?.retire();
|
|
mining?.retire();
|
|
cancelPopupLayout();
|
|
clearDictionaryResources();
|
|
try {
|
|
highlighter?.clearAll();
|
|
for (const level of levels) level.view?.destroy();
|
|
} catch {
|
|
// Best effort: the point is only to leave nothing half-built behind.
|
|
}
|
|
host?.remove();
|
|
host = null;
|
|
shadow = null;
|
|
rootLevel.popup = null;
|
|
rootLevel.view = null;
|
|
highlighter = null;
|
|
rootLevel.activeCandidate = null;
|
|
rootLevel.activeSignature = null;
|
|
rootLevel.activeTermRender = null;
|
|
rootLevel.currentViewRequest = null;
|
|
rootLevel.noteEditing = false;
|
|
syncHostAttention();
|
|
}
|
|
|
|
function clearDictionaryResources() {
|
|
mediaCache.clear();
|
|
mediaCacheBytes = 0;
|
|
mediaQueue = [];
|
|
for (const job of [...pendingMedia.values()]) {
|
|
finishMediaJob(job, new Error("obsolete media request"));
|
|
}
|
|
styleGeneration = -1;
|
|
styleRequest = null;
|
|
}
|
|
|
|
function noteGeneration(generation, owner = rootLevel) {
|
|
if (!Number.isFinite(generation) || generation === currentGeneration) {
|
|
return;
|
|
}
|
|
currentGeneration = generation;
|
|
audio?.retire();
|
|
mining?.retire();
|
|
clearDictionaryResources();
|
|
// Generation is an engine incarnation, not a monotonic storage revision.
|
|
// Invalidate other in-flight owners even when a restarted engine returns 1.
|
|
for (const level of levels) {
|
|
if (level !== owner) {
|
|
level.lookupToken += 1;
|
|
level.retainedView = Boolean(level.currentViewRequest && !level.popup.hidden);
|
|
}
|
|
}
|
|
}
|
|
|
|
function sendRequest(type, payload, target = TARGET) {
|
|
return new Promise((resolve, reject) => {
|
|
if (disposed || !extensionAlive()) {
|
|
teardown("context-invalidated");
|
|
reject(new Error("extension context invalidated"));
|
|
return;
|
|
}
|
|
const requestId = payload?.requestId ?? `${type.replace(/^hd_/u, "")}-${nextRequestId += 1}`;
|
|
const request = { ...payload, requestId, target, type };
|
|
try {
|
|
chrome.runtime.sendMessage(request, (reply) => {
|
|
const lastError = chrome.runtime.lastError;
|
|
if (lastError) {
|
|
const message = lastError.message || "sendMessage failed";
|
|
if (INVALIDATED_MESSAGE_PATTERN.test(message)) {
|
|
teardown("context-invalidated");
|
|
}
|
|
reject(new Error(message));
|
|
return;
|
|
}
|
|
if (
|
|
!reply ||
|
|
reply.type !== `${type}_result` ||
|
|
reply.requestId !== requestId
|
|
) {
|
|
reject(new Error(`unexpected reply for ${type}`));
|
|
return;
|
|
}
|
|
if (reply.ok !== true) {
|
|
const error = new Error(reply.error || `${type} failed`);
|
|
error.responseReceived = true;
|
|
if (typeof reply.errorCode === "string") error.code = reply.errorCode;
|
|
reject(error);
|
|
return;
|
|
}
|
|
resolve(reply);
|
|
});
|
|
} catch (error) {
|
|
teardown("context-invalidated");
|
|
reject(error);
|
|
}
|
|
});
|
|
}
|
|
|
|
function cacheMedia(key, url) {
|
|
// The engine produces base64 data URLs. Count decoded bytes without
|
|
// decoding or copying the payload merely to maintain the cache budget.
|
|
const padding = url.endsWith("==") ? 2 : url.endsWith("=") ? 1 : 0;
|
|
const byteLength = (url.length - url.indexOf(",") - 1) / 4 * 3 - padding;
|
|
mediaCache.set(key, { url, byteLength });
|
|
mediaCacheBytes += byteLength;
|
|
while (mediaCache.size > MAX_MEDIA_CACHE_ENTRIES || mediaCacheBytes > MAX_MEDIA_CACHE_BYTES) {
|
|
const oldestKey = mediaCache.keys().next().value;
|
|
mediaCacheBytes -= mediaCache.get(oldestKey).byteLength;
|
|
// These are data URLs, not revocable Blob URLs. Drop our reference;
|
|
// an image already rendered from it retains its independent DOM owner.
|
|
mediaCache.delete(oldestKey);
|
|
}
|
|
}
|
|
|
|
function finishMediaJob(job, error, url) {
|
|
if (job.settled) return;
|
|
job.settled = true;
|
|
if (job.timer !== null) window.clearTimeout(job.timer);
|
|
if (pendingMedia.get(job.key) === job) pendingMedia.delete(job.key);
|
|
if (job.active) {
|
|
job.active = false;
|
|
activeMediaRequests -= 1;
|
|
}
|
|
if (error) job.reject(error);
|
|
else job.resolve(url);
|
|
}
|
|
|
|
function pruneMediaQueue() {
|
|
mediaQueue = mediaQueue.filter((job) => {
|
|
if (job.consumers.some((isCurrent) => isCurrent())) return true;
|
|
finishMediaJob(job, new Error("obsolete media request"));
|
|
return false;
|
|
});
|
|
}
|
|
|
|
async function dispatchMedia(job) {
|
|
try {
|
|
const reply = await sendRequest("hd_media", job.payload);
|
|
if (job.settled) return;
|
|
if (pendingMedia.get(job.key) !== job || job.payload.generation !== currentGeneration
|
|
|| reply.generation !== job.payload.generation) {
|
|
throw new Error("obsolete media reply");
|
|
}
|
|
if (typeof reply.dataUrl !== "string") throw new Error("dictionary image is unavailable");
|
|
// Started resource fetches may finish while hidden; image callbacks
|
|
// separately check their current view before touching DOM.
|
|
cacheMedia(job.key, reply.dataUrl);
|
|
finishMediaJob(job, null, reply.dataUrl);
|
|
} catch (error) {
|
|
finishMediaJob(job, error);
|
|
} finally {
|
|
pumpMediaQueue();
|
|
}
|
|
}
|
|
|
|
function pumpMediaQueue() {
|
|
while (mediaQueue.length > 0 && activeMediaRequests < MAX_MEDIA_CONCURRENT_REQUESTS) {
|
|
const job = mediaQueue.shift();
|
|
if (!job.consumers.some((isCurrent) => isCurrent())) {
|
|
finishMediaJob(job, new Error("obsolete media request"));
|
|
continue;
|
|
}
|
|
job.active = true;
|
|
activeMediaRequests += 1;
|
|
job.timer = window.setTimeout(() => {
|
|
finishMediaJob(job, new Error("dictionary image request timed out"));
|
|
pumpMediaQueue();
|
|
}, MEDIA_REQUEST_TIMEOUT_MS);
|
|
void dispatchMedia(job);
|
|
}
|
|
}
|
|
|
|
function resolveMedia({ dictionary, generation, path, isCurrent }) {
|
|
if (!isCurrent() || generation !== currentGeneration) {
|
|
return Promise.reject(new Error("obsolete media request"));
|
|
}
|
|
const key = `${generation}\u0000${dictionary}\u0000${path}`;
|
|
const cached = mediaCache.get(key);
|
|
if (cached) {
|
|
mediaCache.delete(key);
|
|
mediaCache.set(key, cached);
|
|
return Promise.resolve(cached.url);
|
|
}
|
|
const pending = pendingMedia.get(key);
|
|
if (pending) {
|
|
pending.consumers.push(isCurrent);
|
|
return pending.promise;
|
|
}
|
|
if (pendingMedia.size >= MAX_MEDIA_PENDING_REQUESTS) pruneMediaQueue();
|
|
if (pendingMedia.size >= MAX_MEDIA_PENDING_REQUESTS) {
|
|
return Promise.reject(new Error("dictionary image queue is full"));
|
|
}
|
|
const job = { key, consumers: [isCurrent], payload: { dictionary, generation, path },
|
|
active: false, settled: false, timer: null };
|
|
job.promise = new Promise((resolveJob, rejectJob) => {
|
|
job.resolve = resolveJob;
|
|
job.reject = rejectJob;
|
|
});
|
|
pendingMedia.set(key, job);
|
|
mediaQueue.push(job);
|
|
pumpMediaQueue();
|
|
return job.promise;
|
|
}
|
|
|
|
function imageSourceContext() {
|
|
const next = window.HDReaderOptions.resolvePopupImageSources(options.popupImageSource, dictionaries, dictionaryGroups);
|
|
// Keep the effective route's identity through alias/name-only changes.
|
|
// In-flight consumers capture it, independently of broad storage revisions.
|
|
if (next !== popupImageSources && !sameDictionaries(next, popupImageSources)) popupImageSources = next;
|
|
return { popupImageSources, resolveMedia: resolvePopupMedia };
|
|
}
|
|
|
|
function resolvePopupMedia(request) {
|
|
const sources = popupImageSources;
|
|
const isCurrent = () => sources === popupImageSources && request.generation === currentGeneration && request.isCurrent();
|
|
const ownedRequest = { ...request, isCurrent };
|
|
if (sources !== null) return resolveRoutedMedia(ownedRequest, sources);
|
|
// Automatic retains the direct cache/queue path without candidate scans.
|
|
return resolveMedia(ownedRequest).then(url => {
|
|
if (!isCurrent()) throw new Error("obsolete media reply");
|
|
return url;
|
|
});
|
|
}
|
|
|
|
async function resolveRoutedMedia(request, sources) {
|
|
const { isCurrent } = request;
|
|
for (const dictionary of sources) {
|
|
if (!isCurrent()) throw new Error("obsolete media request");
|
|
let url;
|
|
try {
|
|
url = await resolveMedia({ ...request, dictionary, isCurrent });
|
|
} catch (error) {
|
|
if (!isCurrent()) throw error;
|
|
// Availability is per requested path, not one global group winner.
|
|
continue;
|
|
}
|
|
if (!isCurrent()) throw new Error("obsolete media reply");
|
|
request.onResolvedSource?.(dictionary);
|
|
return url;
|
|
}
|
|
throw new Error("dictionary image is unavailable");
|
|
}
|
|
|
|
function ensureDictionaryStyles(generation) {
|
|
if (!shadow || generation === styleGeneration) {
|
|
return;
|
|
}
|
|
styleGeneration = generation;
|
|
const request = {};
|
|
styleRequest = request;
|
|
sendRequest("hd_styles", {}).then((reply) => {
|
|
if (disposed || !shadow || styleRequest !== request) {
|
|
return;
|
|
}
|
|
if (reply.generation !== generation) throw new Error("obsolete dictionary styles");
|
|
window.HDGlossary.applyDictionaryStyles(
|
|
document,
|
|
shadow,
|
|
generation,
|
|
Array.isArray(reply.styles) ? reply.styles : []
|
|
);
|
|
}).catch(() => {
|
|
// Dictionary CSS is cosmetic; a failure must not block the lookup that
|
|
// asked for it. Retry on the next render without resetting a newer job.
|
|
if (styleRequest === request) {
|
|
styleGeneration = -1;
|
|
styleRequest = null;
|
|
}
|
|
});
|
|
}
|
|
|
|
// Browser zoom scales CSS pixels. The popup cancels it with CSS zoom to keep
|
|
// one on-screen size, so its lengths are unzoomed pixels and page geometry is
|
|
// converted into them before placement.
|
|
function popupRect(rect) {
|
|
return window.HDPopup.scaleRect(rect, window.HDPopup.popupCoordinateScale(pageZoom, options.popupScalePercent));
|
|
}
|
|
|
|
function popupViewport() {
|
|
const factor = window.HDPopup.popupCoordinateScale(pageZoom, options.popupScalePercent);
|
|
return { width: window.innerWidth * factor, height: window.innerHeight * factor };
|
|
}
|
|
|
|
function applyPageZoom() {
|
|
host?.style.setProperty("--gsm-hoshidicts-page-zoom", String(1 / pageZoom));
|
|
}
|
|
|
|
function refreshPageZoom() {
|
|
// Resizing a window keeps its device pixel ratio; a zoom change does not.
|
|
if (disposed || window.devicePixelRatio === pageZoomRatio) return;
|
|
pageZoomRatio = window.devicePixelRatio;
|
|
const request = ++pageZoomRequest;
|
|
sendRequest("hd_page_zoom", {}, PAGE_ZOOM_TARGET).then((reply) => {
|
|
if (disposed || request !== pageZoomRequest || !(reply.zoomFactor > 0) || reply.zoomFactor === pageZoom) return;
|
|
pageZoom = reply.zoomFactor;
|
|
applyPageZoom();
|
|
for (const level of levels) level.view?.hideImagePreview();
|
|
positionPopup();
|
|
}, (error) => console.debug("hachidori: page zoom unavailable", error));
|
|
}
|
|
|
|
function calculatePopupPosition(anchorRect, viewport, vertical) {
|
|
return window.HDPopup.calculatePopupPosition(anchorRect, sessionPopupSize ?? {
|
|
width: options.popupWidthPx, height: options.popupHeightPx,
|
|
}, viewport, { gap: POPUP_GAP_PX, padding: POPUP_PADDING_PX, vertical });
|
|
}
|
|
|
|
function anchorRectFor(candidate) {
|
|
if (candidate.anchorRange) {
|
|
try {
|
|
const first = candidate.scanEntries?.[0];
|
|
if (first && !candidate.linkAnchor && candidate.exactSelection !== true) {
|
|
const origin = document.createRange();
|
|
origin.setStart(first.node, first.offset);
|
|
origin.setEnd(first.node, first.offset + first.sourceLength);
|
|
const glyph = origin.getBoundingClientRect();
|
|
const x = (glyph.left + glyph.right) / 2;
|
|
const y = (glyph.top + glyph.bottom) / 2;
|
|
const fragment = [...candidate.anchorRange.getClientRects()].find(rect =>
|
|
rect.left <= x && rect.right >= x && rect.top <= y && rect.bottom >= y);
|
|
if (fragment) return fragment;
|
|
}
|
|
const rect = candidate.anchorRange.getBoundingClientRect();
|
|
if (rect && Number.isFinite(rect.left) && (rect.width > 0 || rect.height > 0)) {
|
|
return rect;
|
|
}
|
|
} catch {
|
|
// The range's nodes moved; fall back to the container box.
|
|
}
|
|
}
|
|
return candidate.anchor.getBoundingClientRect();
|
|
}
|
|
|
|
function anchorConnected(candidate) {
|
|
return Boolean(candidate) &&
|
|
candidate.anchor.isConnected &&
|
|
candidateStart(candidate).node.isConnected &&
|
|
(candidate.exactSelection !== true || (
|
|
!candidate.anchorRange.collapsed
|
|
&& candidate.anchor.contains(candidate.anchorRange.startContainer)
|
|
&& candidate.anchor.contains(candidate.anchorRange.endContainer)
|
|
));
|
|
}
|
|
|
|
function requestCanRender(token, candidate, level = rootLevel) {
|
|
if (disposed || level.retired || token !== level.lookupToken || !level.popup) return false;
|
|
if (retireDetachedAncestor(level)) return false;
|
|
// Initial selections still own the live page selection; Note/Back replays
|
|
// intentionally use their stored descriptor even after focus collapses it.
|
|
if (!anchorConnected(candidate) || (level === rootLevel && pendingCandidateLookup?.token === token
|
|
&& candidate.exactSelection === true && !selectionIsUnchanged(candidate))) {
|
|
hide(level);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
function retireDetachedAncestor(level) {
|
|
for (let depth = 0; depth < level.depth; depth += 1) {
|
|
const ancestor = levels[depth];
|
|
if (!anchorConnected(ancestor.activeCandidate)) {
|
|
hide(ancestor);
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
function lookupFailureState(error, request = null) {
|
|
const message = error instanceof Error ? error.message : String(error);
|
|
if (error?.code === "dictionary-structured-content-limit") {
|
|
return {
|
|
kind: "render",
|
|
title: typeof error.userTitle === "string"
|
|
? error.userTitle
|
|
: "Dictionary content could not be rendered.",
|
|
detail: typeof error.userDetail === "string" ? error.userDetail : message,
|
|
};
|
|
}
|
|
if (error?.code === "engine-mutating" || message === "the dictionary engine is busy mutating") {
|
|
return {
|
|
kind: "updating",
|
|
title: "Dictionary update in progress.",
|
|
detail: "Try the lookup again when the update finishes.",
|
|
};
|
|
}
|
|
if (error?.code === "sharing-disconnected" || message === "The linked Hachidori is not reachable.") {
|
|
return {
|
|
kind: "disconnected",
|
|
title: "Shared Hachidori is disconnected.",
|
|
detail: "Reconnect it in Settings → Sharing, then try again.",
|
|
};
|
|
}
|
|
if (error?.code === "engine-starting" || message === "the dictionary engine is still starting") {
|
|
return {
|
|
kind: "starting",
|
|
title: "Dictionary engine is starting.",
|
|
detail: "Wait a moment, then try again.",
|
|
};
|
|
}
|
|
if (error?.code === "engine-start-failed") {
|
|
return {
|
|
kind: "engine",
|
|
title: "Dictionary engine could not start.",
|
|
detail: "Open Settings to check the engine status, then try again.",
|
|
};
|
|
}
|
|
if (request?.kind === "kanji") {
|
|
return {
|
|
kind: "kanji",
|
|
title: "Kanji lookup failed.",
|
|
detail: "The current definition is still available. Try again.",
|
|
};
|
|
}
|
|
return null;
|
|
}
|
|
|
|
function retainFailedView(request, token, level, replayOptions) {
|
|
if (!replayOptions?.preserveViewControls || disposed || level.retired
|
|
|| token !== level.lookupToken || level.currentViewRequest !== request
|
|
|| level.popup.hidden || !requestCanRender(token, request.candidate, level)) return false;
|
|
level.retainedView = true;
|
|
return true;
|
|
}
|
|
|
|
function handleRequestFailure(request, token, error, level, replayOptions) {
|
|
const preserveView = retainProtectedReplay(request, token, level, replayOptions)
|
|
|| retainFailedView(request, token, level, replayOptions);
|
|
return handleLookupFailure(token, error, level, request, preserveView);
|
|
}
|
|
|
|
function handleLookupFailure(token, error, level = rootLevel, request = null, preserveView = false) {
|
|
if (disposed || level.retired || token !== level.lookupToken) return false;
|
|
if (error?.code !== "dictionary-structured-content-limit") {
|
|
console.debug("hachidori: lookup failed", error);
|
|
}
|
|
const state = lookupFailureState(error, request);
|
|
if (state === null) {
|
|
if (!preserveView) hide(level);
|
|
return false;
|
|
}
|
|
if (!preserveView) {
|
|
show(request?.candidate ?? level.activeCandidate, level);
|
|
level.currentViewRequest = request;
|
|
level.activeHighlightText = "";
|
|
level.activeTermRender = null;
|
|
clearDefinitionBlurTimer(level);
|
|
pruneLevels(level.depth + 1);
|
|
}
|
|
level.view.renderLookupFailure({
|
|
...state,
|
|
actionLabel: "Try again",
|
|
onAction: () => executeViewRequest(
|
|
request,
|
|
level,
|
|
preserveView ? { preserveViewControls: true } : null,
|
|
),
|
|
}, { preserveView });
|
|
positionPopup(level);
|
|
return false;
|
|
}
|
|
|
|
function handleRenderFailure(token, error, request, level = rootLevel) {
|
|
if (disposed || level.retired || token !== level.lookupToken) return false;
|
|
if (error?.cause instanceof Error) {
|
|
console.warn("hachidori: could not render results", error, "caused by", error.cause);
|
|
} else {
|
|
console.warn("hachidori: could not render results", error);
|
|
}
|
|
return handleLookupFailure(token, error, level, request);
|
|
}
|
|
|
|
function retainProtectedReplay(request, token, level, replayOptions) {
|
|
if (!replayOptions?.preserveViewControls || disposed || level.retired
|
|
|| token !== level.lookupToken || level.currentViewRequest !== request
|
|
|| level.popup.hidden
|
|
|| (!level.noteEditing && level.pendingCustomAppends === 0)) return false;
|
|
if (!requestCanRender(token, request.candidate, level)) return false;
|
|
level.retainedView = true;
|
|
return true;
|
|
}
|
|
|
|
function positionToolbar(level, placement, reset = false) {
|
|
const desired = window.HDPopup.resolveToolbarPosition(options.popupToolbarPosition, placement,
|
|
reset ? "top" : level.popup.dataset.toolbarPosition);
|
|
if (level.popup.dataset.toolbarPosition !== desired) level.view.setToolbarPosition(desired);
|
|
}
|
|
|
|
function positionPopup(fromLevel = rootLevel, resetToolbar = false) {
|
|
if (fromLevel.retired || fromLevel.popup?.inert || !rootLevel.popup || rootLevel.popup.hidden || !rootLevel.activeCandidate) {
|
|
return;
|
|
}
|
|
if (retireDetachedAncestor(fromLevel)) return;
|
|
if (!anchorConnected(rootLevel.activeCandidate)) {
|
|
hide();
|
|
return;
|
|
}
|
|
highlighter?.refresh();
|
|
if (fromLevel === rootLevel) {
|
|
const position = popupResize?.level === rootLevel ? popupResizePosition() : calculatePopupPosition(
|
|
popupRect(anchorRectFor(rootLevel.activeCandidate)),
|
|
popupViewport(),
|
|
rootLevel.activeCandidate.vertical
|
|
);
|
|
positionToolbar(rootLevel, position.placement, resetToolbar);
|
|
rootLevel.popup.style.left = `${position.left}px`;
|
|
rootLevel.popup.style.top = `${position.top}px`;
|
|
rootLevel.popup.style.width = `${position.width}px`;
|
|
rootLevel.popup.style.height = `${position.height}px`;
|
|
}
|
|
if (levels.length === 1) return;
|
|
const viewport = popupViewport();
|
|
if (viewport.width <= POPUP_PADDING_PX * 2 || viewport.height <= POPUP_PADDING_PX * 2) {
|
|
pruneLevels(1);
|
|
// Finish this placement before a newly unprotected view can reproject.
|
|
window.queueMicrotask(flushDictionaryPresentation);
|
|
return;
|
|
}
|
|
const startDepth = Math.max(1, fromLevel.depth);
|
|
let parentRect = popupRect(levels[startDepth - 1].popup.getBoundingClientRect());
|
|
for (const level of levels.slice(startDepth)) {
|
|
if (level.popup.hidden) break;
|
|
if (!anchorConnected(level.activeCandidate)) {
|
|
hide(level);
|
|
break;
|
|
}
|
|
positionToolbar(level, "beside", resetToolbar);
|
|
const anchorRect = popupRect(anchorRectFor(level.activeCandidate));
|
|
const width = Math.min(sessionPopupSize?.width ?? options.popupWidthPx, viewport.width - POPUP_PADDING_PX * 2);
|
|
const height = Math.min(sessionPopupSize?.height ?? options.popupHeightPx, viewport.height - POPUP_PADDING_PX * 2);
|
|
const rightRoom = viewport.width - parentRect.right - POPUP_GAP_PX - POPUP_PADDING_PX;
|
|
const leftRoom = parentRect.left - POPUP_GAP_PX - POPUP_PADDING_PX;
|
|
const preferredLeft = rightRoom >= width || rightRoom >= leftRoom
|
|
? parentRect.right + POPUP_GAP_PX
|
|
: parentRect.left - width - POPUP_GAP_PX;
|
|
const left = Math.max(POPUP_PADDING_PX, Math.min(preferredLeft, viewport.width - width - POPUP_PADDING_PX));
|
|
const top = Math.max(POPUP_PADDING_PX, Math.min(anchorRect.top, viewport.height - height - POPUP_PADDING_PX));
|
|
level.popup.style.left = `${left}px`;
|
|
level.popup.style.top = `${top}px`;
|
|
level.popup.style.width = `${width}px`;
|
|
level.popup.style.height = `${height}px`;
|
|
if (popupResize?.level === level) {
|
|
const position = popupResizePosition();
|
|
level.popup.style.left = `${position.left}px`;
|
|
level.popup.style.top = `${position.top}px`;
|
|
level.popup.style.width = `${position.width}px`;
|
|
level.popup.style.height = `${position.height}px`;
|
|
}
|
|
// Each parent box is read once, after its own placement, not once per
|
|
// ancestor for every descendant. Narrow viewports may overlap panes.
|
|
parentRect = popupRect(level.popup.getBoundingClientRect());
|
|
}
|
|
}
|
|
|
|
function cancelPopupLayout() {
|
|
if (popupLayoutFrame !== null) window.cancelAnimationFrame(popupLayoutFrame);
|
|
popupLayoutFrame = null;
|
|
popupLayouts.clear();
|
|
}
|
|
|
|
function cancelMasonry(level, layout) {
|
|
if (popupLayouts.get(level) !== layout) return;
|
|
popupLayouts.delete(level);
|
|
if (popupLayouts.size === 0) cancelPopupLayout();
|
|
}
|
|
|
|
function popupResizePosition() {
|
|
const viewport = popupViewport();
|
|
const left = Math.min(popupResize.left, viewport.width - POPUP_PADDING_PX);
|
|
const top = Math.min(popupResize.top, viewport.height - POPUP_PADDING_PX);
|
|
return { left, top, placement: "beside",
|
|
width: Math.min(sessionPopupSize.width, viewport.width - left - POPUP_PADDING_PX),
|
|
height: Math.min(sessionPopupSize.height, viewport.height - top - POPUP_PADDING_PX) };
|
|
}
|
|
|
|
function startPopupResize(event, level) {
|
|
if (event.button !== 0 || level.retired) return;
|
|
event.preventDefault();
|
|
const handle = event.currentTarget;
|
|
const rect = popupRect(level.popup.getBoundingClientRect());
|
|
const minimum = popupRect(handle.getBoundingClientRect());
|
|
cancelCandidateScan();
|
|
clearHideTimer();
|
|
clearTransferTimer();
|
|
clearDescendantTimer();
|
|
sessionPopupSize = { width: rect.width, height: rect.height };
|
|
popupResize = { level, handle, pointerId: event.pointerId, ...rect,
|
|
x: event.clientX, y: event.clientY, minimum };
|
|
handle.setPointerCapture(event.pointerId);
|
|
}
|
|
|
|
function movePopupResize(event) {
|
|
if (!popupResize || event.pointerId !== popupResize.pointerId) return;
|
|
if ((event.buttons & 1) === 0) { stopPopupResize(); return; }
|
|
const drag = popupResize;
|
|
const factor = window.HDPopup.popupCoordinateScale(pageZoom, options.popupScalePercent);
|
|
sessionPopupSize = {
|
|
width: Math.max(drag.minimum.width, drag.width + (event.clientX - drag.x) * factor),
|
|
height: Math.max(drag.minimum.height, drag.height + (event.clientY - drag.y) * factor),
|
|
};
|
|
const position = popupResizePosition();
|
|
sessionPopupSize = { width: position.width, height: position.height };
|
|
positionPopup();
|
|
}
|
|
|
|
function stopPopupResize() {
|
|
if (!popupResize) return;
|
|
const { handle, pointerId } = popupResize;
|
|
popupResize = null;
|
|
if (handle.hasPointerCapture(pointerId)) handle.releasePointerCapture(pointerId);
|
|
}
|
|
|
|
function queueMasonry(level, layout) {
|
|
if (disposed || level.retired || level.popup.hidden || level.popup.inert) return;
|
|
popupLayouts.set(level, layout);
|
|
if (popupLayoutFrame !== null) return;
|
|
// Lay out every dirty pane before placing the chain once in this frame.
|
|
// A width change can queue another observer batch without losing its work.
|
|
popupLayoutFrame = window.requestAnimationFrame(() => {
|
|
const layouts = popupLayouts;
|
|
popupLayouts = new Map();
|
|
popupLayoutFrame = null;
|
|
let owner = null;
|
|
for (const [level, layout] of layouts) {
|
|
if (level.retired || level.popup.hidden || level.popup.inert) continue;
|
|
layout();
|
|
if (!owner || level.depth < owner.depth) owner = level;
|
|
}
|
|
if (owner) positionPopup(owner);
|
|
});
|
|
}
|
|
|
|
// A screenshot of the page must not contain anything Hachidori drew: the host
|
|
// carries the popup, its image preview and the fallback highlight paint, and the
|
|
// registered highlight is suspended beside it. Two frames give the change time
|
|
// to paint before the capture. Concealment is counted, so one capture cannot
|
|
// reveal the reader while another still owns it, and everything is restored
|
|
// whatever the captures did.
|
|
let concealing = 0;
|
|
let restoreMatchHighlight = null;
|
|
let hostOpacity = "";
|
|
let hostOpacityPriority = "";
|
|
async function concealReader(during) {
|
|
if (host === null) return during();
|
|
// The source-term highlight is painted by the document, not by the shadow
|
|
// tree, so the highlighter stops publishing for as long as this lasts —
|
|
// including for a lookup that settles while the picture is being taken.
|
|
if (concealing === 0) {
|
|
restoreMatchHighlight = highlighter?.suspend() ?? null;
|
|
hostOpacity = host.style.getPropertyValue("opacity");
|
|
hostOpacityPriority = host.style.getPropertyPriority("opacity");
|
|
// Descendants can override inherited visibility, including masonry cards.
|
|
// Opacity composites the whole host without changing its layout.
|
|
host.style.setProperty("opacity", "0", "important");
|
|
}
|
|
concealing += 1;
|
|
try {
|
|
await new Promise(resolve => window.requestAnimationFrame(() => window.requestAnimationFrame(resolve)));
|
|
return await during();
|
|
} finally {
|
|
concealing -= 1;
|
|
if (concealing === 0) {
|
|
host.style.setProperty("opacity", hostOpacity, hostOpacityPriority);
|
|
restoreMatchHighlight?.();
|
|
restoreMatchHighlight = null;
|
|
}
|
|
}
|
|
}
|
|
|
|
async function readerStyleSheet() {
|
|
const response = await fetch(chrome.runtime.getURL(READER_STYLESHEET));
|
|
if (!response.ok) {
|
|
throw new Error(`HTTP ${response.status}`);
|
|
}
|
|
const iconResponse = await fetch(chrome.runtime.getURL("icons.css"));
|
|
if (!iconResponse.ok) throw new Error(`HTTP ${iconResponse.status}`);
|
|
const text = `${await response.text()}\n${await iconResponse.text()}`;
|
|
try {
|
|
const sheet = new CSSStyleSheet();
|
|
sheet.replaceSync(text);
|
|
return { sheet, text };
|
|
} catch {
|
|
// A constructed sheet is preferred (one parse shared by every frame), but
|
|
// a plain <style> in the shadow root renders the same rules.
|
|
return { sheet: null, text };
|
|
}
|
|
}
|
|
|
|
function buildUi(styles) {
|
|
host = document.createElement(HOST_TAG);
|
|
globalThis.SubMinerHachidori?.markHost(host, hostAttentionPublished);
|
|
// Inline !important is the only declaration a page cannot override, and the
|
|
// host must stay a zero-sized, non-interactive fixed anchor whatever the
|
|
// page's CSS says. `all: initial` also stops inherited page typography from
|
|
// reaching the shadow tree.
|
|
host.style.cssText = [
|
|
"all: initial !important",
|
|
"position: fixed !important",
|
|
"top: 0 !important",
|
|
"left: 0 !important",
|
|
"width: 0 !important",
|
|
"height: 0 !important",
|
|
"pointer-events: none !important",
|
|
"z-index: 2147483647 !important",
|
|
].join("; ");
|
|
applyPageZoom();
|
|
shadow = host.attachShadow({ mode: "open" });
|
|
if (styles.sheet) {
|
|
shadow.adoptedStyleSheets = [styles.sheet];
|
|
} else {
|
|
const fallback = document.createElement("style");
|
|
fallback.textContent = styles.text;
|
|
shadow.appendChild(fallback);
|
|
}
|
|
|
|
document.body.appendChild(host);
|
|
appearance = window.HDPopup.createPopupAppearance(host);
|
|
appearance.update(options);
|
|
customStyle = window.HDPopup.createCustomPopupStyle(shadow);
|
|
customStyle.update(options.customPopupCss);
|
|
|
|
highlighter = window.HDPopup.createSourceHighlighter(
|
|
window,
|
|
document,
|
|
HIGHLIGHT_NAME,
|
|
shadow
|
|
);
|
|
buildLevelUi(rootLevel);
|
|
}
|
|
|
|
function buildLevelUi(level) {
|
|
mining ??= window.HDAnki.createAnkiController({
|
|
send: (type, fields) => sendRequest(type, fields, "hachidori-anki"),
|
|
capture: (type, fields) => sendRequest(type, fields, "hachidori-capture"),
|
|
onChange: owner => positionPopup(owner),
|
|
conceal: concealReader,
|
|
});
|
|
mining.update(options, optionsStorageRevision >= 0);
|
|
audio ??= window.HDAudio.createAudioController({ window,
|
|
send: (type, fields) => sendRequest(type, fields, "hachidori-audio"),
|
|
onMenuChange(owner) { cancelCandidateScan(); clearHideTimer(); positionPopup(owner); },
|
|
onSelectionChange: owner => mining.refresh(owner),
|
|
});
|
|
audio.update(options, optionsStorageRevision >= 0);
|
|
const popup = document.createElement("div");
|
|
popup.className = "gsm-hoshidicts-popup";
|
|
popup.dataset.hoshidictsDepth = String(level.depth);
|
|
popup.hidden = true;
|
|
globalThis.SubMinerHachidori?.popup(popup);
|
|
popup.addEventListener("focusin", () => {
|
|
cancelCandidateScan();
|
|
clearHideTimer();
|
|
});
|
|
popup.addEventListener("focusout", onPopupFocusOut);
|
|
// Scroll events do not bubble from the definition pane or its inner cards.
|
|
// Keep linked popups aligned with anchors moving inside those scrollers.
|
|
popup.addEventListener("scroll", () => {
|
|
if (level.retired) return;
|
|
const child = levels[level.depth + 1];
|
|
if (child) positionPopup(child);
|
|
}, { capture: true, passive: true });
|
|
popup.addEventListener("wheel", onPopupWheel, { passive: false });
|
|
popup.addEventListener("mouseenter", () => onPopupEnter(level));
|
|
popup.addEventListener(
|
|
"mousemove",
|
|
(event) => onPopupMouseMove(event, level),
|
|
{ capture: true, passive: true }
|
|
);
|
|
popup.addEventListener("mouseover", (event) => {
|
|
const request = level.currentViewRequest;
|
|
if (request?.blur && request.blur.state !== "revealed" && event.target instanceof Element
|
|
&& event.target.closest(".gsm-hoshidicts-definitions, .gsm-hoshidicts-compact-definition-summary")) {
|
|
revealDefinitions(request, level);
|
|
}
|
|
});
|
|
shadow.appendChild(popup);
|
|
level.popup = popup;
|
|
level.highlighter = highlighter.scope(level);
|
|
level.view = window.HDPopup.createPopupView({
|
|
appendExpressionRuby: window.HDGlossary.appendExpressionRuby,
|
|
buildPitchAccentMorae: window.HDGlossary.buildPitchAccentMorae,
|
|
appendTextOnlyGlossary: window.HDGlossary.appendTextOnlyGlossary,
|
|
appendStructuredImage: window.HDGlossary.appendStructuredImage,
|
|
document,
|
|
getPageZoom: () => pageZoom,
|
|
getPopupScalePercent: () => options.popupScalePercent,
|
|
getPopupColumns: () => options.popupColumns,
|
|
onResizeStart: event => startPopupResize(event, level),
|
|
onResizeMove: movePopupResize,
|
|
onResizeEnd: stopPopupResize,
|
|
customButtons: options.customButtons,
|
|
highlightName: HIGHLIGHT_NAME,
|
|
idPrefix: level === rootLevel ? "hoshidicts" : `hoshidicts-${nextLevelId += 1}`,
|
|
onAddCustomEntry: (entry) => appendCustomEntry(entry, level),
|
|
onCustomLinkClick(link) {
|
|
if (!level.currentViewRequest || level.retainedView
|
|
|| !requestCanRender(level.lookupToken, level.activeCandidate, level)) return;
|
|
openExternalLink(link);
|
|
},
|
|
onKanjiClick: (character, result, candidate, link) => showKanji(character, result, candidate, link, level),
|
|
onNoteEditingChange: (editing) => onNoteEditingChange(editing, level),
|
|
onResultsRendered: rendered => bindResultActions(rendered, level),
|
|
onResultsExpanded: rendered => bindResultActions(rendered, level),
|
|
onBeforeResultsRendered: (intent) => {
|
|
audio.retire(level);
|
|
mining.retire(level);
|
|
pruneLevels(level.depth + 1);
|
|
if (level.retainedView) {
|
|
replayVisibleView(level, intent);
|
|
return false;
|
|
}
|
|
},
|
|
canProjectDictionaryPresentation: () => !level.retired && !level.noteEditing
|
|
&& level.pendingCustomAppends === 0 && levels.length === level.depth + 1
|
|
&& requestCanRender(level.lookupToken, level.activeCandidate, level),
|
|
canUpdateCompactSummary: () => requestCanRender(level.lookupToken, level.activeCandidate, level),
|
|
parseTagList: window.HDGlossary.parseTagList,
|
|
popup,
|
|
positionPopup: () => positionPopup(level),
|
|
queueMasonry: (layout) => queueMasonry(level, layout),
|
|
cancelMasonry: (layout) => cancelMasonry(level, layout),
|
|
sourceHighlighter: level.highlighter,
|
|
sourceHighlightEnabled: options.sourceHighlightEnabled,
|
|
toolbarPosition: window.HDPopup.resolveToolbarPosition(options.popupToolbarPosition),
|
|
window,
|
|
});
|
|
}
|
|
|
|
function bindResultActions(rendered, level) {
|
|
const token = level.lookupToken, request = level.currentViewRequest;
|
|
// Keybinds index these like the view's entries; Show more grows the same
|
|
// arrays and rebinds only the newly revealed controls. The count element
|
|
// belongs to the initial render and stays until the next one.
|
|
level.entryAudio = rendered.audioButtons;
|
|
level.entryMining = rendered.miningActions;
|
|
if ("lookupStats" in rendered) {
|
|
level.lookupStatsElement = rendered.lookupStats;
|
|
paintLookupStatistics(request, level);
|
|
}
|
|
const context = { owner: level, popup: level.popup, request,
|
|
isCurrent: () => level.currentViewRequest === request && !level.retainedView
|
|
&& requestCanRender(token, level.activeCandidate, level),
|
|
};
|
|
// The primary result's autoplay waits until its definitions are revealed,
|
|
// whichever tab or expansion binds.
|
|
audio.bind(rendered.audioButtons, {
|
|
...context,
|
|
...("lookupStats" in rendered ? { autoplayHeld: () => request?.blur?.autoplayHeld === true } : {}),
|
|
});
|
|
mining.bind(rendered.miningActions, { ...context, getRequest: result => {
|
|
const candidate = level.activeCandidate;
|
|
const selection = shadow.getSelection?.() ?? window.getSelection();
|
|
const frequencyModes = new Map(dictionaries.map(item => [item.title, item.frequencyMode]));
|
|
const term = { ...result.term, frequencies: result.term.frequencies.map(group =>
|
|
({ ...group, frequencyMode: frequencyModes.get(group.dictionary) })) };
|
|
return { ...result, term, generation: level.activeTermRender.generation, sentence: candidate.sentence,
|
|
matchOffset: candidate.matchOffset, matched: rawMatchedText(candidate, result.matched || result.term.expression),
|
|
searchQuery: request?.payload?.text ?? request?.termPayload?.text ?? candidate.query,
|
|
popupSelectionText: selection?.anchorNode && level.popup.contains(selection.anchorNode) ? selection.toString() : "",
|
|
documentTitle: document.title, audioSelection: audio.selectionFor(result) ?? undefined,
|
|
capturePin: rootLevel.capturePin ?? undefined,
|
|
dictionaryAliases: Object.fromEntries(dictionaries.filter(item => item.displayName).map(item => [item.title, item.displayName])),
|
|
dictionaryIds: Object.fromEntries(dictionaries.map(item => [item.title, item.id])),
|
|
frequencyDictionaries: dictionaries.filter(item => item.enabled && item.frequencyCount > 0).map(item => item.title),
|
|
};
|
|
} });
|
|
}
|
|
|
|
function paintLookupStatistics(request, level) {
|
|
if (!options.showLookupCounts) {
|
|
if (level.lookupStatsElement) level.lookupStatsElement.hidden = true;
|
|
return;
|
|
}
|
|
if (request !== level.currentViewRequest
|
|
|| !requestCanRender(level.lookupToken, level.activeCandidate, level) || !level.lookupStatsElement?.isConnected) return;
|
|
const entry = request?.lookupStats;
|
|
const statistics = entry?.payload?.descriptor.generation === lookupStatsDescriptor.generation
|
|
? entry.payload.statistics : null;
|
|
level.view.setLookupStats(level.lookupStatsElement, statistics);
|
|
}
|
|
|
|
function adoptLookupStatsDescriptor(descriptor, changes = {}) {
|
|
if (!Number.isSafeInteger(descriptor?.revision) || descriptor.revision < 0
|
|
|| (descriptor.generation !== null
|
|
&& (typeof descriptor.generation !== "string" || descriptor.generation === ""))) return;
|
|
const sameGeneration = descriptor.generation === lookupStatsDescriptor.generation;
|
|
if (descriptor.revision < lookupStatsDescriptor.revision && !sameGeneration) return;
|
|
const replaced = descriptor.generation !== lookupStatsDescriptor.generation;
|
|
if (descriptor.revision >= lookupStatsDescriptor.revision) lookupStatsDescriptor = descriptor;
|
|
for (const level of levels) {
|
|
const request = level.currentViewRequest;
|
|
const entry = request?.lookupStats;
|
|
if (!entry) continue;
|
|
const row = changes[lookupStatsKey(descriptor, entry)]?.newValue;
|
|
if (row && (!entry.payload || entry.payload.descriptor.generation !== descriptor.generation
|
|
|| entry.payload.descriptor.revision < descriptor.revision)) {
|
|
entry.payload = { descriptor, statistics: row };
|
|
entry.needsRefresh = false;
|
|
} else if (replaced) entry.needsRefresh = true;
|
|
else continue;
|
|
paintLookupStatistics(request, level);
|
|
if (row) settleDefinitionBlur(request, level, currentLookupCount(entry));
|
|
refreshLookupStatistics(request, level);
|
|
}
|
|
}
|
|
|
|
// The count that decides definition blur: null while unknown or unavailable.
|
|
function currentLookupCount(entry) {
|
|
const payload = entry.payload;
|
|
if (!payload || payload.descriptor.generation !== lookupStatsDescriptor.generation) return null;
|
|
return payload.statistics?.lookupCount ?? null;
|
|
}
|
|
|
|
function refreshLookupStatistics(request, level, record = false) {
|
|
const entry = request.lookupStats;
|
|
if (!options.showLookupCounts || entry.pending || (!record && !entry.needsRefresh)
|
|
|| request !== level.currentViewRequest
|
|
|| !requestCanRender(level.lookupToken, level.activeCandidate, level)) return;
|
|
entry.pending = true;
|
|
entry.needsRefresh = false;
|
|
const requestedOptionsRevision = optionsStorageRevision;
|
|
void sendRequest(record ? "hd_lookup_stats_record" : "hd_lookup_stats_read", {
|
|
term: entry.term, reading: entry.reading,
|
|
}, "hoshidicts-worker").then(payload => {
|
|
adoptLookupStatsDescriptor(payload.descriptor);
|
|
if (payload.descriptor.generation !== lookupStatsDescriptor.generation) {
|
|
entry.needsRefresh = true;
|
|
return;
|
|
}
|
|
if (!(entry.payload?.descriptor.revision > payload.descriptor.revision)) {
|
|
entry.payload = payload;
|
|
entry.needsRefresh = options.showLookupCounts
|
|
&& payload.statistics === null && requestedOptionsRevision !== optionsStorageRevision;
|
|
}
|
|
if (request.lookupStats === entry) {
|
|
paintLookupStatistics(request, level);
|
|
settleDefinitionBlur(request, level, currentLookupCount(entry));
|
|
}
|
|
}).catch(error => {
|
|
// A lost reply may follow a committed increment. Never retry the write.
|
|
console.debug("hachidori: lookup statistics unavailable", error);
|
|
if (request.lookupStats === entry) settleDefinitionBlur(request, level, null);
|
|
}).finally(() => {
|
|
entry.pending = false;
|
|
if (request.lookupStats === entry && entry.needsRefresh) refreshLookupStatistics(request, level);
|
|
});
|
|
}
|
|
|
|
function acceptLookupStatistics(results, request, level) {
|
|
const { term, reading } = normaliseLookupTerm(results[0].term.expression, results[0].term.reading);
|
|
const firstVisit = !request.lookupStats;
|
|
let entry = request.lookupStats;
|
|
if (!entry || entry.term !== term || entry.reading !== reading) {
|
|
entry = request.lookupStats = { term, reading, pending: false, payload: null, needsRefresh: true };
|
|
} else if (entry.payload && entry.payload.descriptor.generation !== lookupStatsDescriptor.generation) {
|
|
entry.needsRefresh = true;
|
|
}
|
|
// The descriptor owns one visit, including a visit while counts are off.
|
|
// Back, tabs and Note refresh can read a replacement, but cannot increment.
|
|
paintLookupStatistics(request, level);
|
|
refreshLookupStatistics(request, level, firstVisit);
|
|
checkDefinitionBlurMaturity(request, level);
|
|
}
|
|
|
|
// The primary word owns one local maturity-cache check per visit. It starts after
|
|
// rendering and never joins the lookup or storage queue. Back keeps its
|
|
// result; a changed Anki configuration discards the old evidence.
|
|
function checkDefinitionBlurMaturity(request, level) {
|
|
const blur = request.blur;
|
|
if (blur.awaitingOptions || !options.definitionBlurAnkiMature || blur.ankiCheck !== undefined) return;
|
|
const check = blur.ankiCheck = { epoch: ankiMaturityEpoch };
|
|
const { expression, reading } = level.activeTermRender.results[0].term;
|
|
void sendRequest("hd_anki_maturity", { request: { term: { expression, reading } } }, "hachidori-anki")
|
|
.then(payload => payload.mature === true, () => false).then(mature => {
|
|
if (blur.ankiCheck !== check) return;
|
|
blur.ankiMature = check.epoch === ankiMaturityEpoch && mature;
|
|
settleDefinitionBlur(request, level);
|
|
});
|
|
}
|
|
|
|
function definitionBlurActive(candidate = options) {
|
|
return (candidate.definitionBlurEnabled && candidate.showLookupCounts)
|
|
|| candidate.definitionBlurAnkiMature || candidate.definitionBlurFrequencyEnabled;
|
|
}
|
|
|
|
function snapshotDefinitionBlurFrequency(results) {
|
|
const groups = Array.isArray(results?.[0]?.term?.frequencies) ? results[0].term.frequencies : [];
|
|
return {
|
|
groups: groups.flatMap(group => typeof group?.dictionary === "string" && Array.isArray(group.frequencies)
|
|
? [{ dictionary: group.dictionary,
|
|
frequencies: group.frequencies.map(frequency => ({ value: frequency?.value })) }]
|
|
: []),
|
|
dictionaries: dictionaries
|
|
.filter(dictionary => dictionary.enabled !== false && dictionary.frequencyCount > 0)
|
|
.map(({ title, frequencyMode, frequencyCount }) => ({ title, frequencyMode, frequencyCount })),
|
|
};
|
|
}
|
|
|
|
function currentDefinitionBlurFrequency(blur, candidate = options) {
|
|
return definitionBlurFrequencyEvidence(candidate, blur.frequency.groups, blur.frequency.dictionaries);
|
|
}
|
|
|
|
function discardStaleAnkiMaturity(request, level) {
|
|
const blur = request.blur;
|
|
if (!blur.ankiCheck || blur.ankiCheck.epoch === ankiMaturityEpoch) return;
|
|
blur.ankiCheck = null;
|
|
blur.ankiMature = false;
|
|
settleDefinitionBlur(request, level);
|
|
}
|
|
|
|
// Definition blur (issue #9 L5). The decision lives on the request, so tabs,
|
|
// expansion, Note refresh and Back keep it while a new request starts fresh.
|
|
// One absolute reveal deadline runs from the first display; a live timer
|
|
// exists only while that request is the level's current view.
|
|
function clearDefinitionBlurTimer(level) {
|
|
if (level.blurTimer === null) return;
|
|
clearTimeout(level.blurTimer);
|
|
level.blurTimer = null;
|
|
}
|
|
|
|
function applyDefinitionBlurState(request, level) {
|
|
if (level.currentViewRequest === request && level.view) level.view.setDefinitionBlurState(request.blur.state);
|
|
}
|
|
|
|
function revealDefinitions(request, level) {
|
|
const blur = request?.blur;
|
|
if (!blur || blur.state === "revealed") return;
|
|
blur.state = "revealed";
|
|
if (level.currentViewRequest === request) clearDefinitionBlurTimer(level);
|
|
applyDefinitionBlurState(request, level);
|
|
releaseDefinitionBlurAutoplay(request, level);
|
|
}
|
|
|
|
function armDefinitionBlurTimer(request, level) {
|
|
clearDefinitionBlurTimer(level);
|
|
const blur = request.blur;
|
|
if (blur.state === "revealed" || options.definitionBlurReveal !== "timed") return;
|
|
const remaining = blur.displayedAt + options.definitionBlurDelayMs - Date.now();
|
|
if (remaining <= 0) {
|
|
revealDefinitions(request, level);
|
|
return;
|
|
}
|
|
level.blurTimer = setTimeout(() => {
|
|
level.blurTimer = null;
|
|
if (level.currentViewRequest === request) revealDefinitions(request, level);
|
|
}, remaining);
|
|
}
|
|
|
|
// Before the stored settings arrive the decision stays pending, like the
|
|
// audio controller's own options hold, so a first lookup cannot reveal or
|
|
// auto-play against defaults that the stored settings then contradict.
|
|
function beginDefinitionBlur(request, level, results) {
|
|
clearDefinitionBlurTimer(level);
|
|
if (!request) return;
|
|
if (!request.blur) {
|
|
const awaitingOptions = optionsStorageRevision < 0;
|
|
const active = awaitingOptions || definitionBlurActive();
|
|
request.blur = { state: active ? "pending" : "revealed", displayedAt: Date.now(), awaitingOptions,
|
|
lookupCount: undefined, ankiMature: undefined, autoplayHeld: active,
|
|
frequency: snapshotDefinitionBlurFrequency(results) };
|
|
}
|
|
if (!request.blur.awaitingOptions) {
|
|
discardStaleAnkiMaturity(request, level);
|
|
settleDefinitionBlur(request, level);
|
|
armDefinitionBlurTimer(request, level);
|
|
}
|
|
}
|
|
|
|
function resolveDefinitionBlurOptions(request, level) {
|
|
const blur = request.blur;
|
|
blur.awaitingOptions = false;
|
|
checkDefinitionBlurMaturity(request, level);
|
|
armDefinitionBlurTimer(request, level);
|
|
settleDefinitionBlur(request, level);
|
|
}
|
|
|
|
// Pending and blurred definitions hold the first result's autoplay; every
|
|
// reveal releases it once.
|
|
function releaseDefinitionBlurAutoplay(request, level) {
|
|
if (!request.blur.autoplayHeld) return;
|
|
request.blur.autoplayHeld = false;
|
|
audio?.settleAutoplay(level, request);
|
|
}
|
|
|
|
// Any enabled signal can qualify immediately. Frequency is synchronous,
|
|
// while a negative decision waits for enabled count and Anki evidence.
|
|
// Retain the first count while Anki is pending so later row events cannot
|
|
// change this visit's decision. Hover and the absolute deadline can reveal
|
|
// before either reply, without reblurring.
|
|
function settleDefinitionBlur(request, level, lookupCount) {
|
|
const blur = request.blur;
|
|
if (!blur) return;
|
|
if (blur.lookupCount === undefined && lookupCount !== undefined) blur.lookupCount = lookupCount;
|
|
if (blur.awaitingOptions || blur.state === "revealed") return;
|
|
const countEnabled = options.definitionBlurEnabled && options.showLookupCounts;
|
|
const frequency = currentDefinitionBlurFrequency(blur);
|
|
const qualifies = definitionBlurQualifies(options, countEnabled ? blur.lookupCount : null,
|
|
blur.ankiMature, frequency.qualified);
|
|
const pending = !qualifies && ((countEnabled && blur.lookupCount === undefined)
|
|
|| (options.definitionBlurAnkiMature && blur.ankiMature === undefined));
|
|
if (pending) {
|
|
if (blur.state !== "pending") {
|
|
blur.state = "pending";
|
|
applyDefinitionBlurState(request, level);
|
|
}
|
|
return;
|
|
}
|
|
if (!qualifies) {
|
|
revealDefinitions(request, level);
|
|
return;
|
|
}
|
|
if (blur.state !== "blurred") {
|
|
blur.state = "blurred";
|
|
applyDefinitionBlurState(request, level);
|
|
}
|
|
}
|
|
|
|
function ensureUi() {
|
|
if (!uiPromise) {
|
|
uiPromise = (async () => {
|
|
if (!document.body || !window.HDPopup || !window.HDGlossary) {
|
|
throw new Error("render modules or document body unavailable");
|
|
}
|
|
let styles;
|
|
try {
|
|
styles = await readerStyleSheet();
|
|
} catch (error) {
|
|
throw new Error(`could not load ${READER_STYLESHEET}: ${error.message}`);
|
|
}
|
|
if (disposed) {
|
|
throw new Error("torn down");
|
|
}
|
|
buildUi(styles);
|
|
})().catch((error) => {
|
|
console.warn("hachidori: popup unavailable", error);
|
|
// The next hover retries, so a half-built host must not stay in the page
|
|
// and must not leave `view` null behind a non-null `popup`.
|
|
discardUi();
|
|
uiPromise = null;
|
|
throw error;
|
|
});
|
|
}
|
|
return uiPromise;
|
|
}
|
|
|
|
function show(candidate, level = rootLevel) {
|
|
level.activeCandidate = candidate;
|
|
level.activeSignature = candidateSignature(candidate);
|
|
if (!host.isConnected && document.body) {
|
|
// A single-page app that swapped out document.body took the host with it.
|
|
document.body.appendChild(host);
|
|
}
|
|
level.popup.hidden = false;
|
|
level.popup.inert = false;
|
|
level.view.scrollElement.scrollTop = 0;
|
|
syncHostAttention();
|
|
}
|
|
|
|
function pruneLevels(depth, restoreFocus = true) {
|
|
clearDescendantTimer();
|
|
if (levels.length <= Math.max(1, depth)) {
|
|
if (levels.length === 1) clearTransferTimer();
|
|
return;
|
|
}
|
|
const source = levels[depth]?.activeCandidate?.anchor;
|
|
const removed = levels.splice(Math.max(1, depth));
|
|
const focused = removed.some((level) => level.popup?.contains(shadow?.activeElement));
|
|
for (const level of removed.reverse()) {
|
|
if (popupResize?.level === level) stopPopupResize();
|
|
audio?.retire(level);
|
|
mining?.retire(level);
|
|
clearDefinitionBlurTimer(level);
|
|
level.retired = true;
|
|
level.lookupToken += 1;
|
|
level.popup.hidden = true;
|
|
level.view?.clear();
|
|
level.view?.destroy();
|
|
level.popup?.remove();
|
|
}
|
|
// Removing a pane can uncover surviving fallback source paint.
|
|
highlighter?.refresh();
|
|
if (restoreFocus && focused && source?.isConnected) source.focus({ preventScroll: true });
|
|
if (levels.length === 1) clearTransferTimer();
|
|
}
|
|
|
|
function hide(level = rootLevel) {
|
|
if (level === rootLevel || popupResize?.level === level) stopPopupResize();
|
|
audio?.retire(level);
|
|
mining?.retire(level);
|
|
clearDefinitionBlurTimer(level);
|
|
if (level !== rootLevel) {
|
|
if (!level.retired) {
|
|
pruneLevels(level.depth);
|
|
flushDeferredNotes();
|
|
flushDictionaryPresentation();
|
|
}
|
|
return;
|
|
}
|
|
cancelPopupLayout();
|
|
clearScanTimer();
|
|
selectionDragActive = false;
|
|
dragSelection = null;
|
|
activeSelectionCandidate = null;
|
|
pendingCandidateLookup = null;
|
|
clearHideTimer();
|
|
clearTransferTimer();
|
|
pointerLevel = null;
|
|
pruneLevels(1, false);
|
|
releaseRootCapture();
|
|
rootLevel.activeCandidate = null;
|
|
rootLevel.activeSignature = null;
|
|
rootLevel.activeHighlightText = "";
|
|
rootLevel.activeTermRender = null;
|
|
rootLevel.currentViewRequest = null;
|
|
rootLevel.noteEditing = false;
|
|
rootLevel.deferredDictionaryInvalidationRevision = -1;
|
|
rootLevel.deferredRefresh = null;
|
|
rootLevel.retainedView = false;
|
|
rootLevel.lookupToken += 1;
|
|
if (rootLevel.popup) {
|
|
rootLevel.popup.hidden = true;
|
|
rootLevel.popup.inert = false;
|
|
rootLevel.view.clear();
|
|
highlighter.clearAll();
|
|
}
|
|
syncHostAttention();
|
|
}
|
|
|
|
function clearHideTimer() {
|
|
if (hideTimer !== null) {
|
|
window.clearTimeout(hideTimer);
|
|
hideTimer = null;
|
|
}
|
|
}
|
|
|
|
function clearTransferTimer() {
|
|
if (transferTimer !== null) window.clearTimeout(transferTimer);
|
|
transferTimer = null;
|
|
}
|
|
|
|
function scheduleTransferCheck() {
|
|
clearTransferTimer();
|
|
transferTimer = window.setTimeout(() => {
|
|
transferTimer = null;
|
|
if (lastPointer && (isOurNode(lastPointer.target)
|
|
|| pointInsidePopup(lastPointer.clientX, lastPointer.clientY))) {
|
|
pointerInPopup = true;
|
|
clearHideTimer();
|
|
} else if (lastPointer) scanPointer(lastPointer);
|
|
else scheduleHide();
|
|
}, 80);
|
|
}
|
|
|
|
function clearDescendantTimer() {
|
|
if (descendantTimer !== null) window.clearTimeout(descendantTimer);
|
|
descendantTimer = null;
|
|
}
|
|
|
|
function onPopupEnter(level) {
|
|
if (level.retired) return;
|
|
pointerLevel = level;
|
|
pointerInPopup = true;
|
|
clearTransferTimer();
|
|
clearHideTimer();
|
|
scheduleDescendantPrune(level);
|
|
}
|
|
|
|
function scheduleDescendantPrune(level) {
|
|
clearDescendantTimer();
|
|
const depth = level.depth + 1;
|
|
if (depth >= levels.length) return;
|
|
const prune = () => {
|
|
descendantTimer = null;
|
|
if (!hasProtectedNote(depth) && (!pointerLevel || pointerLevel.depth < depth)
|
|
&& !levels.slice(depth).some((child) => child.popup.contains(shadow.activeElement))) {
|
|
pruneLevels(depth);
|
|
flushDeferredNotes();
|
|
flushDictionaryPresentation();
|
|
}
|
|
};
|
|
if (options.popupHideDelayMs === 0) prune();
|
|
else descendantTimer = window.setTimeout(prune, options.popupHideDelayMs);
|
|
}
|
|
|
|
function popupHasFocus() {
|
|
return levels.some((level) => level.popup && !level.popup.hidden && level.popup.contains(shadow?.activeElement));
|
|
}
|
|
|
|
function hasProtectedNote(fromDepth = 0) {
|
|
for (let index = fromDepth; index < levels.length; index += 1) {
|
|
if (levels[index].noteEditing || levels[index].pendingCustomAppends > 0) return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// The popup's wheel belongs to the popup. Readers such as ttu turn pages from
|
|
// wheel events on their body, and a pane that cannot scroll further (or has
|
|
// nothing to scroll) would otherwise chain the gesture into the page.
|
|
function onPopupWheel(event) {
|
|
event.stopPropagation();
|
|
if (event.defaultPrevented || event.ctrlKey) return;
|
|
const popup = event.currentTarget;
|
|
for (let node = event.target; node instanceof Element; node = node === popup ? null : node.parentElement) {
|
|
if (canScrollBy(node, event.deltaX, event.deltaY)) return;
|
|
}
|
|
event.preventDefault();
|
|
}
|
|
|
|
function canScrollBy(element, deltaX, deltaY) {
|
|
const room = (delta, offset, size, viewport) => delta > 0 ? offset + viewport < size - 1 : delta < 0 && offset > 0;
|
|
const vertical = room(deltaY, element.scrollTop, element.scrollHeight, element.clientHeight);
|
|
const horizontal = room(deltaX, element.scrollLeft, element.scrollWidth, element.clientWidth);
|
|
if (!vertical && !horizontal) return false;
|
|
const style = window.getComputedStyle(element);
|
|
const scrolls = overflow => overflow === "auto" || overflow === "scroll";
|
|
return (vertical && scrolls(style.overflowY)) || (horizontal && scrolls(style.overflowX));
|
|
}
|
|
|
|
function onPopupFocusOut(event) {
|
|
const target = event.target;
|
|
window.queueMicrotask(() => {
|
|
// A redraw can remove the focused Note form. That is not departure
|
|
// from the refreshed popup; wait until removal/focus transfer settles.
|
|
if (target.isConnected && levels.some((level) => level.popup?.contains(target))) scheduleHide();
|
|
flushDictionaryPresentation();
|
|
});
|
|
}
|
|
|
|
function scheduleHide() {
|
|
if (disposed || hasProtectedNote() || audio?.hasMenu() || !rootLevel.popup || rootLevel.popup.hidden
|
|
|| popupHasFocus() || hideTimer !== null || transferTimer !== null) {
|
|
return;
|
|
}
|
|
// The gap between the word and the popup is dead space; give the pointer
|
|
// time to cross it so the popup stays reachable and selectable.
|
|
const dismiss = () => {
|
|
hideTimer = null;
|
|
if (!hasProtectedNote() && !audio?.hasMenu() && !pointerInPopup && !popupHasFocus()) {
|
|
hide();
|
|
}
|
|
};
|
|
if (options.popupHideDelayMs === 0) dismiss();
|
|
else hideTimer = window.setTimeout(dismiss, options.popupHideDelayMs);
|
|
}
|
|
|
|
function compactSummaryOptions() {
|
|
return { showCompactDefinitionSummary: options.showCompactDefinitionSummary,
|
|
compactDefinitionSummaryCount: options.compactDefinitionSummaryCount,
|
|
compactDefinitionSummaryDictionary: options.compactDefinitionSummaryDictionary };
|
|
}
|
|
|
|
function openExternalLink({ url, active }) {
|
|
if (hostCapabilities.externalLinkHost) {
|
|
void window.HDExternalLinkHost.open(window, { url, active }).catch((error) => {
|
|
console.debug("hachidori: overlay host could not open external link", error);
|
|
});
|
|
return;
|
|
}
|
|
// A lost reply may follow a successful open, so never retry navigation.
|
|
void sendRequest("hd_open_external", { url, active }, "hoshidicts-worker").catch((error) => {
|
|
console.debug("hachidori: external link could not be opened", error);
|
|
});
|
|
}
|
|
|
|
function renderContextFor(level = rootLevel) {
|
|
return {
|
|
definitionBlurState: level.currentViewRequest?.blur?.state ?? "revealed",
|
|
dictionaryPresentation: dictionaryPresentation(),
|
|
dictionaryTabGroups: dictionaryTabGroups(),
|
|
generation: currentGeneration,
|
|
onExternalLink: openExternalLink,
|
|
onInternalLink: (link) => onInternalLink(link, level),
|
|
...imageSourceContext(),
|
|
...compactSummaryOptions(),
|
|
...window.HDPopup.metadataOptions(options),
|
|
};
|
|
}
|
|
|
|
function focusPopupControl(selector, level = rootLevel) {
|
|
const control = level.popup?.querySelector(selector);
|
|
if (typeof control?.focus !== "function") {
|
|
return;
|
|
}
|
|
try {
|
|
control.focus({ preventScroll: true });
|
|
} catch {
|
|
control.focus();
|
|
}
|
|
}
|
|
|
|
function kanjiLinkFocusTarget(sourceLink, character, level = rootLevel) {
|
|
const links = level.popup?.querySelectorAll(".gsm-hoshidicts-kanji-link");
|
|
const index = links ? Array.prototype.indexOf.call(links, sourceLink) : -1;
|
|
return { character, index };
|
|
}
|
|
|
|
function focusKanjiLink(focusTarget, level = rootLevel) {
|
|
const links = level.popup?.querySelectorAll(".gsm-hoshidicts-kanji-link");
|
|
if (!links || links.length === 0) {
|
|
return;
|
|
}
|
|
const character = typeof focusTarget === "object" ? focusTarget?.character : focusTarget;
|
|
let target = links[0];
|
|
const index = Number.isInteger(focusTarget?.index) ? focusTarget.index : -1;
|
|
if (index >= 0 && index < links.length && links[index].textContent === character) {
|
|
target = links[index];
|
|
} else if (typeof character === "string" && character !== "") {
|
|
for (const link of links) {
|
|
if (link.textContent === character) {
|
|
target = link;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (typeof target?.focus !== "function") {
|
|
return;
|
|
}
|
|
try {
|
|
target.focus({ preventScroll: true });
|
|
} catch {
|
|
target.focus();
|
|
}
|
|
}
|
|
|
|
async function restoreTermRender(previous, focusTarget, level = rootLevel) {
|
|
audio?.retire(level);
|
|
mining?.retire(level);
|
|
if (previous.generation !== currentGeneration || !sameDictionaryContents(previous.dictionaries, dictionaries)) {
|
|
const restoring = executeViewRequest(previous.request, level, previous.viewport);
|
|
const token = level.lookupToken;
|
|
if (await restoring && token === level.lookupToken && level.currentViewRequest === previous.request) {
|
|
focusKanjiLink(focusTarget, level);
|
|
}
|
|
return;
|
|
}
|
|
level.lookupToken += 1;
|
|
renderTerms(
|
|
previous.results,
|
|
previous.candidate,
|
|
previous.matchedText,
|
|
previous.renderOptions,
|
|
previous.request,
|
|
level,
|
|
previous.viewport,
|
|
);
|
|
focusKanjiLink(focusTarget, level);
|
|
}
|
|
|
|
function dictionarySelectionContext(request) {
|
|
return {
|
|
selectedDictionaryTab: request?.selectedDictionaryTab ?? null,
|
|
onDictionaryTabSelected(selection) {
|
|
if (request) request.selectedDictionaryTab = normalizedDictionaryTab(selection);
|
|
},
|
|
};
|
|
}
|
|
|
|
function backRenderOptions(request, level = rootLevel) {
|
|
return request?.previous
|
|
? { onBack: () => restoreTermRender(request.previous, request.returnFocus, level) }
|
|
: level === rootLevel ? {} : { onClose: () => hide(level) };
|
|
}
|
|
|
|
function renderTerms(
|
|
results,
|
|
candidate,
|
|
matchedText,
|
|
renderOptions = {},
|
|
request,
|
|
level = rootLevel,
|
|
replayOptions = null,
|
|
) {
|
|
request ??= level.currentViewRequest;
|
|
level.deferredRefresh = null;
|
|
level.deferredDictionaryInvalidationRevision = -1;
|
|
level.retainedView = false;
|
|
pruneLevels(level.depth + 1);
|
|
const token = level.lookupToken;
|
|
level.currentViewRequest = request ?? null;
|
|
beginDefinitionBlur(request, level, results);
|
|
level.activeTermRender = {
|
|
candidate,
|
|
dictionaries,
|
|
generation: currentGeneration,
|
|
matchedText,
|
|
renderOptions,
|
|
request: level.currentViewRequest,
|
|
results,
|
|
token,
|
|
};
|
|
try {
|
|
level.view.renderResults(results, candidate, {
|
|
...renderContextFor(level),
|
|
...renderOptions,
|
|
...replayOptions,
|
|
highlightText: matchedText,
|
|
isCurrentRequest: () => !disposed && !level.retired && token === level.lookupToken,
|
|
isCurrentView: () => !disposed && !level.retired && level.currentViewRequest === request
|
|
&& (token === level.lookupToken || level.retainedView),
|
|
onRenderError(error) { handleRenderFailure(token, error, request, level); },
|
|
...dictionarySelectionContext(request),
|
|
});
|
|
} catch (error) {
|
|
// A malformed result must cost one hover, not the whole content script.
|
|
handleRenderFailure(token, error, request, level);
|
|
return false;
|
|
}
|
|
level.activeHighlightText = matchedText;
|
|
ensureDictionaryStyles(currentGeneration);
|
|
positionPopup(level);
|
|
if (!replayOptions?.preserveViewControls
|
|
&& (typeof renderOptions.onBack === "function" || typeof renderOptions.onClose === "function")
|
|
&& (level === rootLevel || request?.previous || level.focusLinkedBack)) {
|
|
focusPopupControl(renderOptions.onClose ? ".gsm-hoshidicts-popup-close" : ".gsm-hoshidicts-kanji-back", level);
|
|
}
|
|
acceptLookupStatistics(results, request, level);
|
|
if (!replayOptions) globalThis.SubMinerHachidori?.lookup();
|
|
return true;
|
|
}
|
|
|
|
function handleTermMiss(request, dictionaryCount, token, level, replayOptions) {
|
|
if (retainProtectedReplay(request, token, level, replayOptions)) return false;
|
|
if (dictionaryCount === 0 || request.exactSelection) {
|
|
show(request.candidate, level);
|
|
level.activeHighlightText = "";
|
|
level.activeTermRender = null;
|
|
clearDefinitionBlurTimer(level);
|
|
// Keep the exact request so saving a new word can refresh this notice
|
|
// into its personal definition, even after the form collapses selection.
|
|
level.currentViewRequest = request;
|
|
level.view.renderNotice(
|
|
dictionaryCount === 0
|
|
? "No dictionaries loaded. Import a Yomitan .zip in Settings, or add your own definition with the pencil."
|
|
: "No definition found. Add your own with the pencil.",
|
|
request.candidate,
|
|
{ isCurrentRequest: () => !disposed && !level.retired && token === level.lookupToken },
|
|
);
|
|
positionPopup(level);
|
|
return false;
|
|
}
|
|
hide(level);
|
|
return false;
|
|
}
|
|
|
|
async function executeTermRequest(request, level = rootLevel, replayOptions = null) {
|
|
audio?.retire(level);
|
|
mining?.retire(level);
|
|
const token = (level.lookupToken += 1);
|
|
level.retainedView = replayOptions?.preserveViewControls === true;
|
|
if (level.popup && !level.popup.hidden && request !== level.currentViewRequest) {
|
|
pruneLevels(level.depth + 1, false);
|
|
clearDefinitionBlurTimer(level);
|
|
level.popup.inert = true;
|
|
level.currentViewRequest = null;
|
|
level.activeTermRender = null;
|
|
level.deferredRefresh = null;
|
|
level.deferredDictionaryInvalidationRevision = -1;
|
|
level.noteEditing = false;
|
|
}
|
|
level.view?.hideImagePreview();
|
|
let reply, capturePin;
|
|
const capturePinPromise = request.capturePinPromise ?? Promise.resolve(rootLevel.capturePin);
|
|
try {
|
|
// The first hover pays for the popup host and the stylesheet fetch; run
|
|
// them alongside the lookup instead of ahead of it.
|
|
[, reply, capturePin] = await Promise.all([
|
|
ensureUi(),
|
|
sendRequest("hd_lookup", request.payload),
|
|
capturePinPromise,
|
|
]);
|
|
} catch (error) {
|
|
releaseProvisionalCapture(capturePinPromise, level);
|
|
return handleRequestFailure(request, token, error, level, replayOptions);
|
|
}
|
|
request.capturePin = capturePin;
|
|
// Hover fires far faster than lookups return; anything but the newest reply
|
|
// would repaint a word the pointer already left.
|
|
if (!requestCanRender(token, request.candidate, level)) {
|
|
releaseProvisionalCapture(capturePin, level);
|
|
return;
|
|
}
|
|
if (level === rootLevel) rootLevel.capturePin = capturePin;
|
|
noteGeneration(reply.generation, level);
|
|
let results = (Array.isArray(reply.results) ? reply.results : [])
|
|
.filter((result) => result && result.term
|
|
&& (!request.exactSelection || result.matched === request.payload.text));
|
|
results = globalThis.SubMinerHachidori?.prioritizeCharacterResults(
|
|
results, request.payload.options, dictionaryPresentation()) ?? results;
|
|
if (results.length === 0) {
|
|
return handleTermMiss(request, reply.dictionaryCount, token, level, replayOptions);
|
|
}
|
|
const matched = results[0].matched || results[0].term.expression;
|
|
expandCandidateAnchor(request.candidate, matched);
|
|
if (!replayOptions?.preserveViewControls) show(request.candidate, level);
|
|
if (request.highlightText === undefined) {
|
|
request.highlightText = rawMatchedText(request.candidate, matched);
|
|
}
|
|
return renderTerms(
|
|
results,
|
|
request.candidate,
|
|
request.highlightText,
|
|
backRenderOptions(request, level),
|
|
request,
|
|
level,
|
|
replayOptions,
|
|
);
|
|
}
|
|
|
|
function runLookup(candidate, overrides = {}, level = rootLevel) {
|
|
const text = typeof overrides.text === "string" ? overrides.text : candidate.query;
|
|
const exactSelection = candidate.exactSelection === true && overrides.text === undefined;
|
|
return executeTermRequest({
|
|
candidate,
|
|
exactSelection,
|
|
highlightText: overrides.keepHighlight === true ? level.activeHighlightText : undefined,
|
|
kind: "term",
|
|
payload: {
|
|
maxResults: options.maxResults,
|
|
options: {
|
|
frequencyDictionary: options.frequencyDictionary,
|
|
frequencyOrder: options.frequencyOrder,
|
|
primaryReading: typeof overrides.primaryReading === "string"
|
|
? overrides.primaryReading
|
|
: "",
|
|
},
|
|
scanLength: exactSelection ? clampOption("scanLength", Array.from(text).length) : options.scanLength,
|
|
text,
|
|
},
|
|
previous: overrides.previous ?? null,
|
|
returnFocus: overrides.returnFocus ?? null,
|
|
selectedDictionaryTab: normalizedDictionaryTab(overrides.selectedDictionaryTab),
|
|
capturePinPromise: level === rootLevel ? level.capturePinPromise : rootLevel.capturePinPromise,
|
|
}, level);
|
|
}
|
|
|
|
function sameChildLookup(existing, candidate, primaryReading) {
|
|
return Boolean(existing?.activeCandidate) &&
|
|
existing.primaryReading === primaryReading &&
|
|
existing.activeSignature === candidateSignature(candidate) &&
|
|
sameAnchorNode(candidate, existing.activeCandidate);
|
|
}
|
|
|
|
function openChildLookup(candidate, level, {
|
|
focusChild = false,
|
|
primaryReading = "",
|
|
source = "hover",
|
|
} = {}) {
|
|
if (
|
|
level.retired ||
|
|
!level.activeCandidate ||
|
|
!anchorConnected(candidate) ||
|
|
!level.popup.contains(candidate.anchor) ||
|
|
level.depth >= options.popupNestingMaxDepth ||
|
|
popupViewport().width <= POPUP_PADDING_PX * 2 ||
|
|
popupViewport().height <= POPUP_PADDING_PX * 2
|
|
) {
|
|
return;
|
|
}
|
|
clearHideTimer();
|
|
clearTransferTimer();
|
|
clearDescendantTimer();
|
|
const existing = levels[level.depth + 1];
|
|
const pendingKey = source === "link" ? "pendingLink" : "pendingHover";
|
|
const pending = existing?.[pendingKey];
|
|
if (
|
|
sameChildLookup(existing, candidate, primaryReading) &&
|
|
(
|
|
pending?.token === existing.lookupToken ||
|
|
(
|
|
existing.currentViewRequest?.kind === "term" &&
|
|
existing.activeTermRender?.token === existing.lookupToken
|
|
)
|
|
)
|
|
) {
|
|
if (focusChild) {
|
|
existing.focusLinkedBack = true;
|
|
if (!existing.popup.hidden) {
|
|
focusPopupControl(
|
|
existing.currentViewRequest?.previous
|
|
? ".gsm-hoshidicts-kanji-back"
|
|
: ".gsm-hoshidicts-popup-close",
|
|
existing
|
|
);
|
|
}
|
|
}
|
|
return pending?.promise;
|
|
}
|
|
pruneLevels(level.depth + 2, false);
|
|
const child = existing ?? createLevelState(level.depth + 1);
|
|
if (!existing) {
|
|
levels.push(child);
|
|
buildLevelUi(child);
|
|
}
|
|
child.primaryReading = primaryReading;
|
|
child.focusLinkedBack = focusChild;
|
|
child.activeCandidate = candidate;
|
|
child.activeSignature = candidateSignature(candidate);
|
|
const promise = runLookup(candidate, {
|
|
primaryReading,
|
|
selectedDictionaryTab: level.currentViewRequest?.selectedDictionaryTab,
|
|
}, child);
|
|
const record = { promise, token: child.lookupToken };
|
|
child[pendingKey] = record;
|
|
void promise.finally(() => {
|
|
if (child[pendingKey] === record) {
|
|
child[pendingKey] = null;
|
|
}
|
|
});
|
|
return promise;
|
|
}
|
|
|
|
function onInternalLink({ anchor, focusChild = false, primaryReading = "", query }, level = rootLevel) {
|
|
if (!anchor?.isConnected || !query) {
|
|
return;
|
|
}
|
|
// Link text is an anchor/highlight, never the query's page-scan offsets.
|
|
const candidate = {
|
|
anchor, linkAnchor: true, query, matchOffset: 0,
|
|
sentence: anchor.textContent || "", sourceElements: [anchor], sourceDepth: level.depth,
|
|
vertical: false,
|
|
};
|
|
return openChildLookup(candidate, level, {
|
|
focusChild,
|
|
primaryReading,
|
|
source: "link",
|
|
});
|
|
}
|
|
|
|
async function executeKanjiRequest(request, level = rootLevel, replayOptions = null) {
|
|
audio?.retire(level);
|
|
mining?.retire(level);
|
|
const { candidate, capability, character } = request;
|
|
const useTermDictionary = capability?.kind === "term";
|
|
const token = (level.lookupToken += 1);
|
|
level.pendingPopupInteraction = token;
|
|
const finishInteraction = () => {
|
|
if (level.pendingPopupInteraction === token) level.pendingPopupInteraction = null;
|
|
};
|
|
level.retainedView = replayOptions?.preserveViewControls === true;
|
|
level.view?.hideImagePreview();
|
|
let reply;
|
|
try {
|
|
reply = useTermDictionary
|
|
? await sendRequest("hd_lookup_dictionary", request.termPayload)
|
|
: await sendRequest("hd_kanji", request.kanjiPayload);
|
|
} catch (error) {
|
|
finishInteraction();
|
|
return handleLookupFailure(token, error, level, request, true);
|
|
}
|
|
if (!requestCanRender(token, candidate, level) || level.popup.hidden) {
|
|
finishInteraction();
|
|
return false;
|
|
}
|
|
noteGeneration(reply.generation, level);
|
|
if (useTermDictionary) {
|
|
const results = projectResultsToDictionary(
|
|
Array.isArray(reply.results) ? reply.results : [],
|
|
capability.title
|
|
);
|
|
if (results.length > 0) {
|
|
finishInteraction();
|
|
return renderTerms(
|
|
results,
|
|
candidate,
|
|
request.highlightText,
|
|
backRenderOptions(request, level),
|
|
request,
|
|
level,
|
|
replayOptions,
|
|
);
|
|
}
|
|
try {
|
|
reply = await sendRequest("hd_kanji", request.kanjiPayload);
|
|
} catch (error) {
|
|
finishInteraction();
|
|
return handleLookupFailure(token, error, level, request, true);
|
|
}
|
|
if (!requestCanRender(token, candidate, level) || level.popup.hidden) {
|
|
finishInteraction();
|
|
return false;
|
|
}
|
|
noteGeneration(reply.generation, level);
|
|
}
|
|
const kanji = reply.kanji;
|
|
if (!kanji || !Array.isArray(kanji.entries) || kanji.entries.length === 0) {
|
|
finishInteraction();
|
|
return handleLookupFailure(token, new Error("kanji lookup returned no usable result"), level, request, true);
|
|
}
|
|
const validEntries = kanji.entries.filter((entry) => entry && typeof entry === "object"
|
|
&& typeof entry.dictionary === "string" && entry.dictionary !== "");
|
|
if (validEntries.length === 0) {
|
|
finishInteraction();
|
|
return handleLookupFailure(token, new Error("kanji lookup returned no usable result"), level, request, true);
|
|
}
|
|
const selectedEntries = capability?.kind === "kanji"
|
|
? validEntries.filter((entry) => entry.dictionary === capability.title)
|
|
: validEntries;
|
|
const entries = selectedEntries.length > 0 ? selectedEntries : validEntries;
|
|
clearDefinitionBlurTimer(level);
|
|
level.currentViewRequest = request;
|
|
level.deferredRefresh = null;
|
|
level.deferredDictionaryInvalidationRevision = -1;
|
|
level.retainedView = false;
|
|
pruneLevels(level.depth + 1);
|
|
try {
|
|
level.view.renderKanji({ ...kanji, entries }, candidate, {
|
|
...renderContextFor(level),
|
|
isCurrentRequest: () => !disposed && !level.retired && token === level.lookupToken,
|
|
isCurrentView: () => !disposed && !level.retired && level.currentViewRequest === request
|
|
&& (token === level.lookupToken || level.retainedView),
|
|
onRenderError(error) { handleLookupFailure(token, error, level); },
|
|
...dictionarySelectionContext(request),
|
|
highlightText: request.highlightText,
|
|
...backRenderOptions(request, level),
|
|
...replayOptions,
|
|
});
|
|
} catch (error) {
|
|
console.warn("hachidori: could not render kanji", error);
|
|
return handleLookupFailure(token, error, level, request, true);
|
|
} finally {
|
|
finishInteraction();
|
|
}
|
|
ensureDictionaryStyles(currentGeneration);
|
|
positionPopup(level);
|
|
if (!replayOptions?.preserveViewControls) focusPopupControl(".gsm-hoshidicts-kanji-back", level);
|
|
return true;
|
|
}
|
|
|
|
function showKanji(character, _result, _candidate, sourceLink, level = rootLevel) {
|
|
if (!level.activeCandidate || typeof character !== "string" || !character) {
|
|
return;
|
|
}
|
|
const capability = selectedKanjiDictionaryCapability();
|
|
return executeKanjiRequest({
|
|
candidate: level.activeCandidate,
|
|
capability,
|
|
character,
|
|
highlightText: level.activeHighlightText || character,
|
|
kanjiPayload: { character },
|
|
kind: "kanji",
|
|
previous: level.activeTermRender && {
|
|
...level.activeTermRender,
|
|
viewport: level.view.captureTermView?.(),
|
|
},
|
|
returnFocus: kanjiLinkFocusTarget(sourceLink, character, level),
|
|
selectedDictionaryTab: normalizedDictionaryTab(level.currentViewRequest?.selectedDictionaryTab),
|
|
termPayload: capability?.kind === "term"
|
|
? {
|
|
dictionary: capability.title,
|
|
maxResults: options.maxResults,
|
|
options: {
|
|
frequencyDictionary: options.frequencyDictionary,
|
|
frequencyOrder: options.frequencyOrder,
|
|
primaryReading: "",
|
|
},
|
|
scanLength: 1,
|
|
text: character,
|
|
}
|
|
: null,
|
|
}, level);
|
|
}
|
|
|
|
function executeViewRequest(request, level = rootLevel, replayOptions = null) {
|
|
return request.kind === "kanji"
|
|
? executeKanjiRequest(request, level, replayOptions)
|
|
: executeTermRequest(request, level, replayOptions);
|
|
}
|
|
|
|
function replayVisibleView(level, intent) {
|
|
const request = level.currentViewRequest;
|
|
const pending = level.pendingViewReplay;
|
|
if (pending?.request === request && pending.token === level.lookupToken) {
|
|
pending.options.expandAll = intent?.expandAll === true;
|
|
return;
|
|
}
|
|
const replayOptions = { preserveViewControls: true, expandAll: intent?.expandAll === true };
|
|
const operation = executeViewRequest(request, level, replayOptions);
|
|
const replay = { request, token: level.lookupToken, options: replayOptions };
|
|
level.pendingViewReplay = replay;
|
|
void operation.finally(() => {
|
|
if (level.pendingViewReplay === replay) level.pendingViewReplay = null;
|
|
});
|
|
}
|
|
|
|
async function appendCustomEntry(entry, level = rootLevel) {
|
|
const expectedView = level.currentViewRequest;
|
|
level.pendingCustomAppends += 1;
|
|
try {
|
|
const reply = await sendRequest("hd_custom_append", { entry });
|
|
const adoption = adoptDictionaryState(reply.state);
|
|
if (adoption.dictionaryChanged) invalidateStoredState(true);
|
|
else if (adoption.presentationChanged) updateDictionaryPresentation();
|
|
if (
|
|
expectedView !== null
|
|
&& !level.retired
|
|
&& level.currentViewRequest === expectedView
|
|
&& level.popup && !level.popup.hidden
|
|
&& anchorConnected(expectedView.candidate)
|
|
) {
|
|
level.deferredRefresh = expectedView;
|
|
}
|
|
return reply;
|
|
} finally {
|
|
level.pendingCustomAppends -= 1;
|
|
flushDeferredNotes();
|
|
flushDictionaryPresentation();
|
|
}
|
|
}
|
|
|
|
function flushDeferredNotes() {
|
|
for (const level of levels) {
|
|
if (level.pendingCustomAppends > 0 || hasProtectedNote(level.depth + 1)) continue;
|
|
const request = level.deferredRefresh;
|
|
if (request && request === level.currentViewRequest && !level.popup.hidden
|
|
&& anchorConnected(request.candidate)) {
|
|
level.deferredRefresh = null;
|
|
level.deferredDictionaryInvalidationRevision = -1;
|
|
// The append has committed. Replay failures must never invite a second
|
|
// append, and a protected descendant must keep its source DOM alive.
|
|
void executeViewRequest(request, level).catch((error) => {
|
|
console.debug("hachidori: Note saved but the lookup could not refresh", error);
|
|
});
|
|
return;
|
|
}
|
|
if (!level.noteEditing && level.deferredDictionaryInvalidationRevision >= 0) {
|
|
hide(level);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
function clearScanTimer() {
|
|
if (scanTimer !== null) {
|
|
window.clearTimeout(scanTimer);
|
|
scanTimer = null;
|
|
}
|
|
}
|
|
|
|
function discardPendingCandidate() {
|
|
if (pendingCandidateLookup?.candidate === activeSelectionCandidate) activeSelectionCandidate = null;
|
|
pendingCandidateLookup = null;
|
|
}
|
|
|
|
function cancelCandidateScan() {
|
|
clearScanTimer();
|
|
if (rootLevel.popup?.inert) {
|
|
hide();
|
|
return;
|
|
}
|
|
// Retaining a rendered popup during transfer must not invalidate its media
|
|
// or deferred glossary. Only an unfinished candidate loses ownership.
|
|
if (pendingCandidateLookup?.token === rootLevel.lookupToken) rootLevel.lookupToken += 1;
|
|
discardPendingCandidate();
|
|
}
|
|
|
|
function cancelPendingHover(level) {
|
|
const child = levels[level.depth + 1];
|
|
if (
|
|
!child ||
|
|
child.pendingHover?.token !== child.lookupToken ||
|
|
(!child.popup?.hidden && !child.popup?.inert)
|
|
) {
|
|
return;
|
|
}
|
|
pruneLevels(child.depth, false);
|
|
}
|
|
|
|
function lookupCandidate(candidate, signature = candidateSignature(candidate)) {
|
|
rootLevel.capturePin = null;
|
|
rootLevel.capturePinPromise = Promise.resolve(window.HDCapture?.rootLookup(candidate) ?? null);
|
|
const lookup = runLookup(candidate);
|
|
const pending = { token: rootLevel.lookupToken, candidate, signature };
|
|
pendingCandidateLookup = pending;
|
|
void lookup.finally(() => {
|
|
if (pendingCandidateLookup === pending) pendingCandidateLookup = null;
|
|
syncHostAttention();
|
|
});
|
|
}
|
|
|
|
function activationAllowed() {
|
|
return options.lookupMode === "hover" || activationPressed;
|
|
}
|
|
|
|
// Yomitan's default: once shown, the popup outlives the activation key and
|
|
// the pointer's wanderings; only an explicit dismissal or a new lookup ends it.
|
|
function schedulePointerHide() {
|
|
if (options.lookupMode !== "activationSticky") scheduleHide();
|
|
}
|
|
|
|
function updateModifierState(event) {
|
|
const property = MODIFIER_PROPERTIES.get(options.activationKey);
|
|
if (property) activationPressed = event[property] === true;
|
|
}
|
|
|
|
function pointInsidePopup(clientX, clientY) {
|
|
if (!rootLevel.popup || rootLevel.popup.hidden) return false;
|
|
let previous = null;
|
|
for (const level of levels) {
|
|
if (!level.popup || level.popup.hidden) continue;
|
|
const rect = level.popup.getBoundingClientRect();
|
|
if (clientX >= rect.left && clientX <= rect.right
|
|
&& clientY >= rect.top && clientY <= rect.bottom) return true;
|
|
if (previous) {
|
|
const left = previous.right <= rect.left ? previous.right : rect.right;
|
|
const right = previous.right <= rect.left ? rect.left : previous.left;
|
|
if (left <= right && clientX >= left - 2 && clientX <= right + 2
|
|
&& clientY >= Math.max(previous.top, rect.top) - 4
|
|
&& clientY <= Math.min(previous.bottom, rect.bottom) + 4) return true;
|
|
}
|
|
previous = rect;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
function activePointerLevel(pointer) {
|
|
const level = pointer?.level;
|
|
return level &&
|
|
!level.retired &&
|
|
levels[level.depth] === level &&
|
|
level.popup?.contains(pointer.target)
|
|
? level
|
|
: null;
|
|
}
|
|
|
|
function popupLinkAt(target, level) {
|
|
const element = target?.nodeType === Node.ELEMENT_NODE
|
|
? target
|
|
: target?.parentElement;
|
|
const link = element?.closest?.("a");
|
|
return link && level.popup.contains(link) ? link : null;
|
|
}
|
|
|
|
function scanDefinitionPointer(pointer, level) {
|
|
pointerInPopup = true;
|
|
pointerLevel = level;
|
|
clearHideTimer();
|
|
const link = popupLinkAt(pointer.target, level);
|
|
if (link) {
|
|
cancelPendingHover(level);
|
|
if (link.hasAttribute("data-hoshidicts-query")) clearDescendantTimer();
|
|
else scheduleDescendantPrune(level);
|
|
return;
|
|
}
|
|
if (!activationAllowed() || level.depth >= options.popupNestingMaxDepth) {
|
|
cancelPendingHover(level);
|
|
scheduleDescendantPrune(level);
|
|
return;
|
|
}
|
|
const candidate = resolveDefinitionCandidate(
|
|
pointer.clientX,
|
|
pointer.clientY,
|
|
level
|
|
);
|
|
if (!candidate) {
|
|
cancelPendingHover(level);
|
|
scheduleDescendantPrune(level);
|
|
return;
|
|
}
|
|
clearDescendantTimer();
|
|
openChildLookup(candidate, level);
|
|
}
|
|
|
|
function scanPointer(pointer) {
|
|
if (disposed || !extensionAlive()) {
|
|
teardown("context-invalidated");
|
|
return;
|
|
}
|
|
if (!options.hoverEnabled) return;
|
|
if (transferTimer !== null) return;
|
|
const popupLevel = activePointerLevel(pointer);
|
|
if (hasProtectedNote() || popupHasFocus()) {
|
|
cancelCandidateScan();
|
|
if (popupLevel) cancelPendingHover(popupLevel);
|
|
clearHideTimer();
|
|
return;
|
|
}
|
|
if (popupLevel) {
|
|
scanDefinitionPointer(pointer, popupLevel);
|
|
return;
|
|
}
|
|
if (selectionDragActive || retainSelectedLookup()) return;
|
|
pointerInPopup = isOurNode(pointer.target) ||
|
|
pointInsidePopup(pointer.clientX, pointer.clientY);
|
|
if (pointerInPopup) {
|
|
cancelCandidateScan();
|
|
clearHideTimer();
|
|
return;
|
|
}
|
|
const selection = window.getSelection();
|
|
if (selection && !selection.isCollapsed) {
|
|
if (!activationAllowed()) {
|
|
cancelCandidateScan();
|
|
schedulePointerHide();
|
|
return;
|
|
}
|
|
const selected = resolveSelectedLookupCandidate(selection);
|
|
if (selected) startSelectionLookup(selected);
|
|
else {
|
|
cancelCandidateScan();
|
|
scheduleHide();
|
|
}
|
|
return;
|
|
}
|
|
if (!activationAllowed()) {
|
|
cancelCandidateScan();
|
|
schedulePointerHide();
|
|
return;
|
|
}
|
|
const candidate = resolveCandidate(pointer.clientX, pointer.clientY);
|
|
if (!candidate) {
|
|
cancelCandidateScan();
|
|
schedulePointerHide();
|
|
return;
|
|
}
|
|
const signature = candidateSignature(candidate);
|
|
if (pendingCandidateLookup?.token === rootLevel.lookupToken
|
|
&& pendingCandidateLookup.signature === signature
|
|
&& sameAnchorNode(candidate, pendingCandidateLookup.candidate)) {
|
|
clearHideTimer();
|
|
return;
|
|
}
|
|
if (
|
|
rootLevel.popup && !rootLevel.popup.hidden && !rootLevel.popup.inert &&
|
|
rootLevel.activeSignature === signature &&
|
|
sameAnchorNode(candidate, rootLevel.activeCandidate)
|
|
) {
|
|
clearHideTimer();
|
|
return;
|
|
}
|
|
clearHideTimer();
|
|
lookupCandidate(candidate, signature);
|
|
}
|
|
|
|
function onPopupMouseMove(event, level) {
|
|
if (popupResize) return;
|
|
if (disposed || !options.hoverEnabled || level.retired) {
|
|
return;
|
|
}
|
|
lastPointer = {
|
|
clientX: event.clientX,
|
|
clientY: event.clientY,
|
|
level,
|
|
target: event.target,
|
|
};
|
|
updateModifierState(event);
|
|
pointerInPopup = true;
|
|
pointerLevel = level;
|
|
clearTransferTimer();
|
|
clearHideTimer();
|
|
if (hasProtectedNote() || popupHasFocus()) {
|
|
cancelPendingHover(level);
|
|
clearScanTimer();
|
|
return;
|
|
}
|
|
const link = popupLinkAt(event.target, level);
|
|
if (link) {
|
|
cancelPendingHover(level);
|
|
clearScanTimer();
|
|
if (link.hasAttribute("data-hoshidicts-query")) clearDescendantTimer();
|
|
else scheduleDescendantPrune(level);
|
|
return;
|
|
}
|
|
if (selectionDragActive || !activationAllowed()) {
|
|
cancelPendingHover(level);
|
|
clearScanTimer();
|
|
return;
|
|
}
|
|
scheduleScan();
|
|
}
|
|
|
|
function onMouseMove(event) {
|
|
if (popupResize) return;
|
|
if (disposed || !options.hoverEnabled) {
|
|
return;
|
|
}
|
|
lastPointer = {
|
|
clientX: event.clientX,
|
|
clientY: event.clientY,
|
|
target: event.target,
|
|
};
|
|
updateModifierState(event);
|
|
// A release the page never saw, such as one outside the window, ends the
|
|
// drag on the next move.
|
|
if (selectionDragActive && (event.buttons & 1) === 0) finishSelectionDrag({ dismissClick: false });
|
|
if (dragSelection) {
|
|
extendGlyphDrag(event);
|
|
return;
|
|
}
|
|
// Cancel a pending dismissal here rather than waiting for the throttled
|
|
// scan, so the popup stays reachable even with hoverDelayMs turned up. The
|
|
// retargeted event target is enough; the rect test costs a layout and can
|
|
// wait for the scan.
|
|
if (isOurNode(event.target)) {
|
|
pointerInPopup = true;
|
|
clearTransferTimer();
|
|
cancelCandidateScan();
|
|
clearHideTimer();
|
|
return;
|
|
}
|
|
const leavingChain = pointerInPopup && levels.length > 1;
|
|
pointerInPopup = false;
|
|
pointerLevel = null;
|
|
if (leavingChain) scheduleTransferCheck();
|
|
if (hasProtectedNote() || popupHasFocus()) {
|
|
cancelCandidateScan();
|
|
return;
|
|
}
|
|
if (selectionDragActive) return;
|
|
if (activeSelectionCandidate) {
|
|
clearHideTimer();
|
|
scheduleScan();
|
|
return;
|
|
}
|
|
if (!activationAllowed()) {
|
|
cancelCandidateScan();
|
|
schedulePointerHide();
|
|
return;
|
|
}
|
|
scheduleScan();
|
|
}
|
|
|
|
function scheduleScan() {
|
|
if (scanTimer !== null) {
|
|
return;
|
|
}
|
|
// Trailing-edge throttle: at most one scan per hoverDelayMs, always at the
|
|
// pointer's latest position.
|
|
scanTimer = window.setTimeout(() => {
|
|
scanTimer = null;
|
|
if (lastPointer) {
|
|
scanPointer(lastPointer);
|
|
}
|
|
}, options.hoverDelayMs);
|
|
}
|
|
|
|
const GLYPH_DRAG_START_PX = 3;
|
|
|
|
// In an overlay the browser's own drag cannot be trusted: Chromium loses the
|
|
// anchor when the press lands after a boxed glyph, and the selection ends as
|
|
// the glyph under the pointer or nothing. The reader selects whole glyphs from
|
|
// the pressed one to the pointer's instead, and the prevented mousedown keeps
|
|
// the browser's selection out of it.
|
|
function startGlyphDrag(event) {
|
|
const anchor = glyphAtPoint(event.clientX, event.clientY);
|
|
if (!anchor) return null;
|
|
event.preventDefault();
|
|
window.getSelection()?.removeAllRanges();
|
|
return { anchor, focus: null, x: event.clientX, y: event.clientY };
|
|
}
|
|
|
|
function extendGlyphDrag(event) {
|
|
// A press that does not travel is a click, not a one-glyph selection.
|
|
if (!dragSelection.focus
|
|
&& Math.hypot(event.clientX - dragSelection.x, event.clientY - dragSelection.y) < GLYPH_DRAG_START_PX) return;
|
|
// A gap between boxes keeps the last glyph, as does the popup itself.
|
|
const focus = glyphAtPoint(event.clientX, event.clientY) ?? dragSelection.focus;
|
|
if (!focus) return;
|
|
dragSelection.focus = focus;
|
|
const { anchor } = dragSelection;
|
|
const forward = anchor.node === focus.node
|
|
? anchor.start <= focus.start
|
|
: Boolean(anchor.node.compareDocumentPosition(focus.node) & Node.DOCUMENT_POSITION_FOLLOWING);
|
|
try {
|
|
const selection = window.getSelection();
|
|
if (forward) selection.setBaseAndExtent(anchor.node, anchor.start, focus.node, focus.end);
|
|
else selection.setBaseAndExtent(anchor.node, anchor.end, focus.node, focus.start);
|
|
} catch {
|
|
// The page replaced a glyph mid-drag; the next move selects afresh.
|
|
}
|
|
}
|
|
|
|
function onMouseDown(event) {
|
|
if (disposed) {
|
|
return;
|
|
}
|
|
if (isOurNode(event.target) || pointInsidePopup(event.clientX, event.clientY)) return;
|
|
updateModifierState(event);
|
|
if (event.button === 0 && options.hoverEnabled
|
|
&& isScannableElement(selectionBoundaryElement(event.target), new Map())) {
|
|
// A press on text may start a selection, so the popup stays until release
|
|
// decides, and the host hears now that the reader needs the window.
|
|
cancelCandidateScan();
|
|
clearHideTimer();
|
|
activeSelectionCandidate = null;
|
|
setSelectionDrag(true);
|
|
if (overlayMode) dragSelection = startGlyphDrag(event);
|
|
return;
|
|
}
|
|
hide();
|
|
}
|
|
|
|
// Release decides what the press was: a selection looks up that text, a
|
|
// plain click dismisses. The drag's claim on the host window carries over to
|
|
// the lookup it starts.
|
|
function finishSelectionDrag({ dismissClick }) {
|
|
hostAttentionHold += 1;
|
|
try {
|
|
setSelectionDrag(false);
|
|
const token = rootLevel.lookupToken;
|
|
onSelectionChange();
|
|
if (dismissClick && rootLevel.lookupToken === token) hide();
|
|
} finally {
|
|
hostAttentionHold -= 1;
|
|
syncHostAttention();
|
|
}
|
|
}
|
|
|
|
function selectionIsUnchanged(candidate = activeSelectionCandidate) {
|
|
if (!candidate) return false;
|
|
const selection = window.getSelection();
|
|
if (!selection || selection.rangeCount !== 1 || selection.isCollapsed) return false;
|
|
const range = selection.getRangeAt(0);
|
|
const previous = candidate.selectionRange ?? candidate.anchorRange;
|
|
return range.startContainer === previous.startContainer && range.startOffset === previous.startOffset
|
|
&& range.endContainer === previous.endContainer && range.endOffset === previous.endOffset
|
|
&& selection.toString() === (candidate.selectionText ?? candidate.query);
|
|
}
|
|
|
|
function startSelectionLookup(candidate) {
|
|
hostAttentionHold += 1;
|
|
try {
|
|
hide();
|
|
activeSelectionCandidate = candidate;
|
|
lookupCandidate(candidate);
|
|
} finally {
|
|
hostAttentionHold -= 1;
|
|
syncHostAttention();
|
|
}
|
|
}
|
|
|
|
function retainSelectedLookup() {
|
|
if (!activeSelectionCandidate) return false;
|
|
if (!selectionIsUnchanged()) onSelectionChange();
|
|
if (!activeSelectionCandidate) return false;
|
|
clearHideTimer();
|
|
return true;
|
|
}
|
|
|
|
function onSelectionChange() {
|
|
if (disposed || !options.hoverEnabled || selectionDragActive || hasProtectedNote()
|
|
|| popupHasFocus() || pageEditorFocused() || selectionIsUnchanged()) return;
|
|
const selection = window.getSelection();
|
|
if ([selection?.anchorNode, selection?.focusNode].some((node) =>
|
|
node && (node === host || node.getRootNode() === shadow))) return;
|
|
const candidate = resolveSelectedLookupCandidate(selection);
|
|
if (!candidate && !activeSelectionCandidate) return;
|
|
if (candidate && !activationAllowed()) hide();
|
|
else if (candidate) startSelectionLookup(candidate);
|
|
else hide();
|
|
}
|
|
|
|
function onMouseUp(event) {
|
|
if (disposed || event.button !== 0 || !selectionDragActive) return;
|
|
updateModifierState(event);
|
|
finishSelectionDrag({ dismissClick: true });
|
|
}
|
|
|
|
function onPageFocusIn() {
|
|
if (!disposed && pageEditorFocused()) {
|
|
cancelCandidateScan();
|
|
activationPressed = false;
|
|
activationCode = null;
|
|
}
|
|
}
|
|
|
|
// Close keeps the reader's Escape order: an audio menu, then a Note form,
|
|
// then the focused or deepest popup, then a pending lookup. Nothing closed
|
|
// leaves the key to activation.
|
|
function closeFromKeybind(event) {
|
|
if (audio?.closeMenu()) {
|
|
event.preventDefault();
|
|
event.stopPropagation();
|
|
return true;
|
|
}
|
|
if (rootLevel.popup && !rootLevel.popup.hidden) {
|
|
const focused = levels.find((level) => level.popup.contains(shadow.activeElement));
|
|
const editing = focused?.noteEditing ? focused : levels.findLast((level) => level.noteEditing);
|
|
const noteOwner = editing || focused || levels.at(-1);
|
|
if (!noteOwner.popup.inert && noteOwner.view?.closeNoteForm?.() === true) {
|
|
event.preventDefault();
|
|
event.stopPropagation();
|
|
return true;
|
|
}
|
|
event.stopPropagation();
|
|
hide(focused || levels.at(-1));
|
|
return true;
|
|
}
|
|
const dismissedCandidate = pendingCandidateLookup !== null || activeSelectionCandidate !== null;
|
|
hide();
|
|
return dismissedCandidate;
|
|
}
|
|
|
|
// Yomitan leaves unmodified character keys to a focused text field.
|
|
function textFieldFocused() {
|
|
let focused = document.activeElement;
|
|
while (focused) {
|
|
if (focused.isContentEditable || ["input", "select", "textarea"].includes(focused.localName)) return true;
|
|
focused = focused === host ? shadow.activeElement : focused.shadowRoot?.activeElement;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
function clickKeybindControl(control) {
|
|
if (!control?.isConnected || control.hidden || control.disabled) return false;
|
|
control.click();
|
|
return true;
|
|
}
|
|
|
|
function scanSelectedText() {
|
|
if (disposed || !options.hoverEnabled) return false;
|
|
const candidate = resolveSelectedLookupCandidate();
|
|
if (!candidate) return false;
|
|
startSelectionLookup(candidate);
|
|
return true;
|
|
}
|
|
|
|
function runKeybindAction({ action, argument }, event) {
|
|
if (action === "close") return closeFromKeybind(event);
|
|
if (action === "scanSelectedText" || action === "scanTextAtSelection") {
|
|
if (!options.hoverEnabled) return false;
|
|
if (action === "scanSelectedText") return scanSelectedText();
|
|
const candidate = resolveSelectionScanCandidate();
|
|
if (!candidate) return false;
|
|
startSelectionLookup(candidate);
|
|
return true;
|
|
}
|
|
if (action === "toggleOption") {
|
|
if (!argument || optionsStorageRevision < 0) return false;
|
|
// A conflicting write changes nothing; the storage event carries the result.
|
|
void sendRequest("hd_options_write", { baseRevision: optionsStorageRevision,
|
|
options: { [argument]: !options[argument] } }, WORKER_TARGET).catch(() => {});
|
|
return true;
|
|
}
|
|
const level = levels.findLast((item) => item.popup && !item.popup.hidden);
|
|
if (!level?.view || level.popup.inert) return false;
|
|
const entry = level.view.currentEntryIndex();
|
|
switch (action) {
|
|
case "nextEntry":
|
|
case "previousEntry":
|
|
return level.view.focusEntry({ offset: (action === "nextEntry" ? 1 : -1) * Number(argument) });
|
|
case "firstEntry":
|
|
case "lastEntry":
|
|
return level.view.focusEntry(action === "firstEntry" ? "first" : "last");
|
|
case "nextEntryDifferentDictionary":
|
|
case "previousEntryDifferentDictionary":
|
|
return level.view.focusEntry({ dictionary: action === "nextEntryDifferentDictionary" ? 1 : -1 });
|
|
case "historyBackward":
|
|
return clickKeybindControl(level.popup.querySelector(".gsm-hoshidicts-kanji-back"));
|
|
case "addNote":
|
|
case "viewNotes":
|
|
return clickKeybindControl(level.entryMining?.[entry]?.actions.querySelector(
|
|
`.gsm-hoshidicts-mine-button[data-action="${action === "addNote" ? "add" : "view"}"]`));
|
|
case "playAudio":
|
|
case "playAudioFromSource": {
|
|
const button = level.entryAudio?.[entry]?.button;
|
|
if (!button || (action === "playAudioFromSource" && !argument)) return false;
|
|
return audio.playButton(button, action === "playAudioFromSource" ? argument : "");
|
|
}
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// A browser shortcut runs its keybind action here; entry moves go one entry.
|
|
function onReaderCommand(message) {
|
|
if (disposed || message?.target !== READER_TARGET || message.type !== "hd_reader_command") return false;
|
|
runKeybindAction({ action: message.action, argument: ["nextEntry", "previousEntry"].includes(message.action) ? "1" : "" },
|
|
{ preventDefault() {}, stopPropagation() {} });
|
|
return false;
|
|
}
|
|
|
|
// After Yomitan's HotkeyHandler: the physical key and the exact modifier set
|
|
// select enabled keybinds whose scope applies; the first handled one wins.
|
|
function runKeybinds(event) {
|
|
const key = KEYBIND_MODIFIER_CODES.has(event.code) ? null : event.code;
|
|
const modifiers = KEYBIND_MODIFIERS.filter(modifier => event[`${modifier}Key`] === true);
|
|
// A pending lookup counts as its popup: Escape has always cancelled one.
|
|
const popupScope = Boolean(rootLevel.popup && !rootLevel.popup.hidden)
|
|
|| pendingCandidateLookup !== null || activeSelectionCandidate !== null;
|
|
const characterInput = (modifiers.length === 0 || modifiers.join() === "shift")
|
|
&& (event.key?.length === 1 || event.key === "Process");
|
|
for (const bind of options.keybinds) {
|
|
if (!bind.enabled || bind.action === "" || (bind.key === null && bind.modifiers.length === 0)
|
|
|| bind.key !== key || bind.modifiers.join() !== modifiers.join()
|
|
|| !(bind.scopes.includes("web") || (popupScope && bind.scopes.includes("popup")))
|
|
|| (characterInput && textFieldFocused())) continue;
|
|
if (runKeybindAction(bind, event) === false) continue;
|
|
if (bind.action !== "close") event.preventDefault();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
function onKeyDown(event) {
|
|
if (disposed || event.repeat || runKeybinds(event)) {
|
|
return;
|
|
}
|
|
if (!options.hoverEnabled) return;
|
|
// Autofocused search fields (such as Jisho's) must not disable lookups on
|
|
// the rest of the page. Modifier activation leaves native typing intact;
|
|
// printable/editor keys stay reserved for the focused field.
|
|
if (pageEditorFocused() && !MODIFIER_PROPERTIES.has(options.activationKey)) return;
|
|
// Pressing the gate key while the pointer is stationary should reveal the
|
|
// word under it without asking the reader to jiggle the mouse.
|
|
const wasPressed = activationPressed;
|
|
updateModifierState(event);
|
|
if (normaliseActivationKey(event.key, null) === options.activationKey) {
|
|
activationPressed = true;
|
|
activationCode = event.code;
|
|
}
|
|
const popupLevel = activePointerLevel(lastPointer);
|
|
if (!wasPressed && activationPressed && options.lookupMode !== "hover"
|
|
&& lastPointer && !hasProtectedNote() && !popupHasFocus()
|
|
&& (!pointerInPopup || popupLevel)
|
|
&& !selectionDragActive
|
|
&& (popupLevel || !retainSelectedLookup())) {
|
|
scheduleScan();
|
|
}
|
|
}
|
|
|
|
function onKeyUp(event) {
|
|
if (disposed) return;
|
|
updateModifierState(event);
|
|
if (!MODIFIER_PROPERTIES.has(options.activationKey)
|
|
&& (event.code === activationCode || normaliseActivationKey(event.key, null) === options.activationKey)) {
|
|
activationPressed = false;
|
|
}
|
|
if (!activationPressed) activationCode = null;
|
|
if (options.lookupMode === "activation" && !activationPressed) {
|
|
if (selectionIsUnchanged()) return;
|
|
cancelCandidateScan();
|
|
scheduleHide();
|
|
}
|
|
}
|
|
|
|
function onMouseOut(event) {
|
|
if (popupResize) return;
|
|
// A null relatedTarget on a document-level mouseout means the pointer left
|
|
// the window entirely, which mouseleave cannot report from here: it does not
|
|
// bubble, and a capture listener would fire for every element left.
|
|
if (!disposed && event.relatedTarget === null) {
|
|
lastPointer = null;
|
|
pointerInPopup = false;
|
|
cancelCandidateScan();
|
|
schedulePointerHide();
|
|
}
|
|
}
|
|
|
|
function onWindowBlur() {
|
|
stopPopupResize();
|
|
if (!disposed) {
|
|
setSelectionDrag(false);
|
|
lastPointer = null;
|
|
activationPressed = false;
|
|
activationCode = null;
|
|
pointerInPopup = false;
|
|
const interaction = levels.find((level) => !level.popup?.hidden
|
|
&& level.pendingPopupInteraction === level.lookupToken);
|
|
if (interaction) {
|
|
interaction.pendingPopupInteraction = null;
|
|
return;
|
|
}
|
|
hide();
|
|
}
|
|
}
|
|
|
|
function onPageHide() {
|
|
stopPopupResize();
|
|
sessionPopupSize = null;
|
|
// Navigation can destroy the content owner without blurring the tab.
|
|
// Retire while runtime messaging is alive; a BFCache return can reuse UI.
|
|
audio?.retire();
|
|
mining?.retire();
|
|
for (const level of levels) clearDefinitionBlurTimer(level);
|
|
}
|
|
|
|
function onPageShow(event) {
|
|
if (!event.persisted) return;
|
|
positionPopup();
|
|
// The absolute deadline kept running while the page was cached.
|
|
for (const level of levels) {
|
|
const request = level.currentViewRequest;
|
|
if (request?.blur && !request.blur.awaitingOptions) armDefinitionBlurTimer(request, level);
|
|
}
|
|
}
|
|
|
|
function onScroll() {
|
|
cancelCandidateScan();
|
|
rootLevel.view?.hideImagePreview();
|
|
if (disposed || !rootLevel.popup || rootLevel.popup.hidden || !rootLevel.activeCandidate) {
|
|
return;
|
|
}
|
|
if (!anchorConnected(rootLevel.activeCandidate)) {
|
|
hide();
|
|
return;
|
|
}
|
|
const rect = anchorRectFor(rootLevel.activeCandidate);
|
|
if (
|
|
rect.bottom < 0 || rect.top > window.innerHeight ||
|
|
rect.right < 0 || rect.left > window.innerWidth
|
|
) {
|
|
hide();
|
|
return;
|
|
}
|
|
positionPopup();
|
|
}
|
|
|
|
function invalidateStoredState(dictionaryChanged) {
|
|
audio?.retire();
|
|
mining?.retire();
|
|
discardPendingCandidate();
|
|
// A completed selection hit or miss also belongs to the old lookup state.
|
|
// Preserve Note's view ownership through its deferred refresh.
|
|
if (!hasProtectedNote()) activeSelectionCandidate = null;
|
|
for (const level of levels) {
|
|
level.view?.hideImagePreview();
|
|
if (level.popup?.inert) {
|
|
hide(level);
|
|
return;
|
|
}
|
|
level.lookupToken += 1;
|
|
level.retainedView = Boolean(level.currentViewRequest && !level.popup.hidden);
|
|
if (dictionaryChanged && level.popup && !level.popup.hidden) {
|
|
if (!hasProtectedNote(level.depth)) {
|
|
hide(level);
|
|
return;
|
|
}
|
|
if (level.noteEditing || level.pendingCustomAppends > 0) {
|
|
level.deferredDictionaryInvalidationRevision = dictionaryStateRevision;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
function onNoteEditingChange(editing, level = rootLevel) {
|
|
if (level.retired) return;
|
|
level.noteEditing = editing === true;
|
|
if (level.noteEditing) {
|
|
cancelCandidateScan();
|
|
clearHideTimer();
|
|
} else {
|
|
flushDeferredNotes();
|
|
flushDictionaryPresentation();
|
|
}
|
|
}
|
|
|
|
function updateDictionaryPresentation() {
|
|
const context = { dictionaryPresentation: dictionaryPresentation(), dictionaryTabGroups: dictionaryTabGroups(),
|
|
...compactSummaryOptions(), ...imageSourceContext(), ...window.HDPopup.metadataOptions(options) };
|
|
for (const level of levels) {
|
|
if (level.popup && !level.popup.hidden) level.view.updateDictionaryPresentation(context);
|
|
}
|
|
}
|
|
|
|
function flushDictionaryPresentation() {
|
|
for (const level of levels) {
|
|
if (level.popup && !level.popup.hidden) level.view.flushDictionaryPresentation();
|
|
}
|
|
}
|
|
|
|
function adoptDictionaryState(stored) {
|
|
const next = normalizeDictionaryState(stored);
|
|
if (next.revision <= dictionaryStateRevision) {
|
|
return { adopted: false, dictionaryChanged: false, presentationChanged: false };
|
|
}
|
|
const dictionaryChanged = !sameDictionaryContents(next.dictionaries, dictionaries);
|
|
const presentationChanged = !sameDictionaries(next.dictionaries, dictionaries)
|
|
|| !sameDictionaries(next.groups, dictionaryGroups);
|
|
if (dictionaryChanged) clearDictionaryResources();
|
|
dictionaryStateRevision = next.revision;
|
|
dictionaries = next.dictionaries;
|
|
dictionaryGroups = next.groups;
|
|
return { adopted: true, dictionaryChanged, presentationChanged };
|
|
}
|
|
|
|
function onStorageChanged(changes, area) {
|
|
if (disposed || area !== "local") {
|
|
return;
|
|
}
|
|
let changed = false;
|
|
const previousLevelCount = levels.length;
|
|
let dictionaryChanged = false;
|
|
let presentationChanged = false;
|
|
if (changes.options) {
|
|
const adoption = adoptOptions(changes.options.newValue);
|
|
changed = adoption.lookupChanged;
|
|
presentationChanged = adoption.presentationChanged;
|
|
}
|
|
if (changes.dictionaryState) {
|
|
const adoption = adoptDictionaryState(changes.dictionaryState.newValue);
|
|
dictionaryChanged = adoption.dictionaryChanged;
|
|
presentationChanged ||= adoption.presentationChanged;
|
|
changed ||= dictionaryChanged;
|
|
}
|
|
if (changes.lookupStats) adoptLookupStatsDescriptor(changes.lookupStats.newValue, changes);
|
|
if (changed) {
|
|
invalidateStoredState(dictionaryChanged);
|
|
} else if (presentationChanged) updateDictionaryPresentation();
|
|
if (levels.length < previousLevelCount) {
|
|
flushDeferredNotes();
|
|
flushDictionaryPresentation();
|
|
}
|
|
}
|
|
|
|
function adoptOptions(stored) {
|
|
const revision = Number.isInteger(stored?.revision) && stored.revision >= 0 ? stored.revision : 0;
|
|
if (revision <= optionsStorageRevision) return { lookupChanged: false, presentationChanged: false };
|
|
const next = projectHostOptions(stored);
|
|
const lookupChanged = next.scanLength !== options.scanLength || next.maxResults !== options.maxResults
|
|
|| next.frequencyDictionary !== options.frequencyDictionary || next.frequencyOrder !== options.frequencyOrder
|
|
|| JSON.stringify(next.kanjiClickDictionary) !== JSON.stringify(options.kanjiClickDictionary);
|
|
const activationChanged = next.lookupMode !== options.lookupMode || next.activationKey !== options.activationKey;
|
|
const interactionChanged = activationChanged || next.hoverEnabled !== options.hoverEnabled
|
|
|| next.onlyScanJapaneseText !== options.onlyScanJapaneseText;
|
|
const scanDelayChanged = next.hoverDelayMs !== options.hoverDelayMs && scanTimer !== null;
|
|
const hideDelayChanged = next.popupHideDelayMs !== options.popupHideDelayMs && hideTimer !== null;
|
|
const columnsChanged = next.popupColumns !== options.popupColumns;
|
|
const sizeChanged = next.popupWidthPx !== options.popupWidthPx || next.popupHeightPx !== options.popupHeightPx
|
|
|| next.popupScalePercent !== options.popupScalePercent;
|
|
const toolbarChanged = next.popupToolbarPosition !== options.popupToolbarPosition;
|
|
const highlightChanged = next.sourceHighlightEnabled !== options.sourceHighlightEnabled;
|
|
const summaryChanged = next.showCompactDefinitionSummary !== options.showCompactDefinitionSummary
|
|
|| next.compactDefinitionSummaryCount !== options.compactDefinitionSummaryCount
|
|
|| next.compactDefinitionSummaryDictionary !== options.compactDefinitionSummaryDictionary;
|
|
const imageSourceChanged = JSON.stringify(next.popupImageSource) !== JSON.stringify(options.popupImageSource);
|
|
const metadataChanged = Object.entries(window.HDPopup.metadataOptions(next)).some(([key, value]) => value !== options[key]);
|
|
// The caller adopts the complete storage delivery before new summary work.
|
|
// A simultaneous dictionary replacement must invalidate the old view first.
|
|
const countsChanged = next.showLookupCounts !== options.showLookupCounts;
|
|
const ankiChanged = JSON.stringify(next.anki) !== JSON.stringify(options.anki);
|
|
const customButtonsChanged = JSON.stringify(next.customButtons) !== JSON.stringify(options.customButtons);
|
|
if (ankiChanged || next.definitionBlurAnkiMature !== options.definitionBlurAnkiMature) ankiMaturityEpoch++;
|
|
const blurChanged = ankiChanged || next.showLookupCounts !== options.showLookupCounts || DEFINITION_BLUR_KEYS
|
|
.some(key => next[key] !== options[key]);
|
|
const optionsArrived = optionsStorageRevision < 0;
|
|
const adoption = { lookupChanged,
|
|
presentationChanged: (summaryChanged || imageSourceChanged || metadataChanged) && next.hoverEnabled };
|
|
if (activationChanged) {
|
|
activationPressed = false;
|
|
activationCode = null;
|
|
}
|
|
optionsStorageRevision = revision;
|
|
options = next;
|
|
if (customButtonsChanged) {
|
|
for (const level of levels) level.view?.setCustomButtons(options.customButtons);
|
|
}
|
|
if (countsChanged) {
|
|
for (const level of levels) {
|
|
const request = level.currentViewRequest;
|
|
const entry = request?.lookupStats;
|
|
if (!entry) continue;
|
|
if (next.showLookupCounts) entry.needsRefresh = true;
|
|
paintLookupStatistics(request, level);
|
|
refreshLookupStatistics(request, level);
|
|
}
|
|
}
|
|
if (optionsArrived) {
|
|
for (const level of levels) {
|
|
const request = level.currentViewRequest;
|
|
if (request?.blur?.awaitingOptions) resolveDefinitionBlurOptions(request, level);
|
|
}
|
|
} else if (blurChanged) {
|
|
for (const level of levels) {
|
|
const request = level.currentViewRequest;
|
|
const blur = request?.blur;
|
|
if (!blur) continue;
|
|
discardStaleAnkiMaturity(request, level);
|
|
settleDefinitionBlur(request, level);
|
|
if (blur.state === "pending") checkDefinitionBlurMaturity(request, level);
|
|
// Disabling reveals at once; other edits apply to unrevealed views
|
|
// from their original display time. Note drafts are untouched.
|
|
if (!definitionBlurActive()) {
|
|
revealDefinitions(request, level);
|
|
} else armDefinitionBlurTimer(request, level);
|
|
}
|
|
}
|
|
audio?.update(options);
|
|
mining?.update(options);
|
|
appearance?.update(options);
|
|
if (sizeChanged) for (const level of levels) level.view?.hideImagePreview();
|
|
const cssChanged = customStyle?.update(options.customPopupCss);
|
|
if (highlightChanged) {
|
|
for (const level of levels) level.view?.setSourceHighlightEnabled(options.sourceHighlightEnabled);
|
|
}
|
|
if (toolbarChanged) {
|
|
for (const level of levels) {
|
|
if (level.popup && (!options.hoverEnabled || level.popup.hidden)) positionToolbar(level, null, true);
|
|
}
|
|
}
|
|
if (levels.length > options.popupNestingMaxDepth + 1) pruneLevels(options.popupNestingMaxDepth + 1);
|
|
// Masonry must measure the new inline width, not lay out the old width and
|
|
// wait for ResizeObserver to correct every card in a second frame.
|
|
if ((sizeChanged || toolbarChanged) && options.hoverEnabled && rootLevel.popup && !rootLevel.popup.hidden) {
|
|
positionPopup(rootLevel, toolbarChanged);
|
|
}
|
|
if ((columnsChanged || sizeChanged || cssChanged) && options.hoverEnabled) {
|
|
for (const level of levels) {
|
|
if (!level.popup?.hidden) level.view?.scheduleMasonry();
|
|
}
|
|
}
|
|
if (!options.hoverEnabled) {
|
|
setSelectionDrag(false);
|
|
lastPointer = null;
|
|
activationPressed = false;
|
|
activationCode = null;
|
|
hide();
|
|
}
|
|
else if (interactionChanged || scanDelayChanged) {
|
|
if (selectionIsUnchanged()) {
|
|
clearScanTimer();
|
|
clearHideTimer();
|
|
return adoption;
|
|
}
|
|
cancelCandidateScan();
|
|
clearHideTimer();
|
|
const popupLevel = activePointerLevel(lastPointer);
|
|
if (!hasProtectedNote() && !popupHasFocus() && (!pointerInPopup || popupLevel)) {
|
|
if (!activationAllowed()) {
|
|
if (popupLevel) cancelPendingHover(popupLevel);
|
|
else schedulePointerHide();
|
|
}
|
|
else if (lastPointer) scheduleScan();
|
|
}
|
|
} else if (hideDelayChanged) {
|
|
clearHideTimer();
|
|
scheduleHide();
|
|
}
|
|
return adoption;
|
|
}
|
|
|
|
function start() {
|
|
void loadOverlayMode();
|
|
// Startup awaits this snapshot before demonstrating its first selection.
|
|
let storageReady;
|
|
const reader = Object.freeze({ scanSelectedText });
|
|
globalThis.HDReaderReady = new Promise(resolve => {
|
|
storageReady = () => { resolve(reader); };
|
|
});
|
|
try {
|
|
chrome.storage.onChanged.addListener(onStorageChanged);
|
|
// Optional like the worker's commands API: reader smoke hosts have no runtime messages.
|
|
chrome.runtime.onMessage?.addListener(onReaderCommand);
|
|
chrome.storage.local.get({ dictionaryState: null, options: DEFAULT_OPTIONS, lookupStats: null }, (stored) => {
|
|
try {
|
|
if (disposed || chrome.runtime.lastError) return;
|
|
const optionsAdoption = adoptOptions(stored && stored.options);
|
|
const adoption = adoptDictionaryState(stored && stored.dictionaryState);
|
|
adoptLookupStatsDescriptor(stored && stored.lookupStats);
|
|
if (optionsAdoption.lookupChanged || adoption.dictionaryChanged) {
|
|
invalidateStoredState(adoption.dictionaryChanged);
|
|
} else if (optionsAdoption.presentationChanged || adoption.presentationChanged) updateDictionaryPresentation();
|
|
} finally {
|
|
storageReady();
|
|
}
|
|
});
|
|
} catch {
|
|
// Without storage access the defaults are still usable.
|
|
storageReady();
|
|
}
|
|
// Capture so a page that stops propagation on its own text still gets
|
|
// scanned; passive so the hot pointer and scroll paths can never delay the
|
|
// page's own scrolling. A press stays cancelable: an overlay drag is the
|
|
// reader's, not the browser's.
|
|
const observe = { capture: true, passive: true };
|
|
document.addEventListener("mousemove", onMouseMove, observe);
|
|
document.addEventListener("mousedown", onMouseDown, { capture: true });
|
|
document.addEventListener("mouseup", onMouseUp, observe);
|
|
document.addEventListener("selectionchange", onSelectionChange);
|
|
document.addEventListener("focusin", onPageFocusIn, observe);
|
|
document.addEventListener("mouseout", onMouseOut, observe);
|
|
document.addEventListener("keydown", onKeyDown, true);
|
|
document.addEventListener("keyup", onKeyUp, true);
|
|
window.addEventListener("scroll", onScroll, observe);
|
|
window.addEventListener("blur", onWindowBlur);
|
|
window.addEventListener("pagehide", onPageHide);
|
|
window.addEventListener("pageshow", onPageShow);
|
|
window.addEventListener("resize", refreshPageZoom);
|
|
refreshPageZoom();
|
|
}
|
|
|
|
let subminerAudioSource = "";
|
|
const disconnectSubminer = globalThis.SubMinerHachidori?.connect({
|
|
hide,
|
|
clear() { hide(); highlighter?.clearAll(); },
|
|
action(action) { runKeybindAction({ action }, new KeyboardEvent("keydown")); },
|
|
keydown: onKeyDown,
|
|
scroll(deltaX, deltaY) {
|
|
levels.findLast(level => level.popup && !level.popup.hidden)?.view?.scrollElement.scrollBy({ left: deltaX, top: deltaY });
|
|
},
|
|
cycleAudio(direction) {
|
|
const sources = options.audioSources.filter(source => source.enabled);
|
|
if (!sources.length) return;
|
|
const previous = sources.findIndex(source => source.id === subminerAudioSource);
|
|
const index = previous < 0 ? (direction === 1 ? 0 : sources.length - 1)
|
|
: (previous + direction + sources.length) % sources.length;
|
|
subminerAudioSource = sources[index].id;
|
|
runKeybindAction({ action: "playAudioFromSource", argument: subminerAudioSource }, new KeyboardEvent("keydown"));
|
|
},
|
|
});
|
|
start();
|
|
}());
|