/gm,
);
let tgt = "";
if (res.length > 0) {
tgt = res[0].replace(/<[^>]*>?/gm, "\n");
tgt = tgt.replace(/\n\s*\n/g, "\n");
tgt = tgt.replace(/\s\s+/g, " ");
tgt = tgt.trim();
}
if (tgt.length != 0) {
const audioList: Array<{ text: string; url: string }> = [];
const en = tgt.match(/英 \[.+?\]/gm);
if (en != null && en.length != 0) {
audioList.push({
text: en[0],
url: `https://dict.youdao.com/dictvoice?audio=${data.raw}&type=1`,
});
}
const us = tgt.match(/美 \[.+?\]/gm);
if (us != null && us.length != 0) {
audioList.push({
text: us[0],
url: `https://dict.youdao.com/dictvoice?audio=${data.raw}&type=2`,
});
}
data.audio = audioList;
}
data.result = tgt;
} catch (e) {
throw "Parse Error";
}
};
export const YoudaoDict: TranslateService = {
id: "youdaodict",
type: "word",
translate,
};
================================================
FILE: src/modules/services/youdaozhiyun.ts
================================================
import { hex, sha256Digest } from "../../utils/crypto";
import { getPref } from "../../utils/prefs";
import { TranslateService } from "./base";
const translate: TranslateService["translate"] = async function (data) {
function encodeRFC5987ValueChars(str: string) {
return encodeURIComponent(str)
.replace(
/['()]/g,
(c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`,
) // i.e., %27 %28 %29
.replace(/\*/g, "%2A")
.replace(/%20/g, "+");
}
function truncate(q: string) {
const len = q.length;
if (len <= 20) return q;
return q.substring(0, 10) + len + q.substring(len - 10, len);
}
const [appid, key, vocabId] = data.secret.split("#");
const salt = new Date().getTime();
const curtime = Math.round(new Date().getTime() / 1000);
const query = data.raw;
const from = data.langfrom;
const to = data.langto;
const str1 = appid + truncate(query) + salt + curtime + key;
const sign = hex(await sha256Digest(str1));
const domain = getPref("youdaozhiyun.domain") as string;
const xhr = await Zotero.HTTP.request(
"GET",
`https://openapi.youdao.com/api?q=${encodeRFC5987ValueChars(
query,
)}&appKey=${appid}&salt=${salt}&from=${from}&to=${to}&sign=${sign}&signType=v3&curtime=${curtime}&vocabId=${vocabId}&domain=${domain}`,
{
headers: {
"Content-Type": "application/x-www-form-urlencoded",
},
responseType: "json",
},
);
if (xhr?.status !== 200) {
throw `Request error: ${xhr?.status}`;
}
const res = xhr.response;
if (parseInt(res.errorCode) !== 0) {
throw `Service error: ${res.errorCode}`;
}
data.result = res.translation.join("");
};
export const YoudaoZhiyun: TranslateService = {
id: "youdaozhiyun",
type: "sentence",
helpUrl: "https://ai.youdao.com/console/#/service-singleton/text-translation",
defaultSecret: "appid#appsecret#vocabid(optional)",
secretValidator(secret: string) {
const parts = secret?.split("#");
const flag = [2, 3].includes(parts.length);
const partsInfo = `AppID: ${parts[0]}\nAppKey: ${parts[1]}\nVocabID: ${
parts[2] ? parts[2] : ""
}`;
return {
secret,
status: flag && secret !== YoudaoZhiyun.defaultSecret,
info:
secret === YoudaoZhiyun.defaultSecret
? "The secret is not set."
: flag
? partsInfo
: `The secret format of YoudaoZhiyun is AppID#AppKey#VocabID(optional). The secret must have 2 or 3 parts joined by '#', but got ${parts?.length}.\n${partsInfo}`,
};
},
translate,
config(settings) {
settings.addSelectSetting({
prefKey: "youdaozhiyun.domain",
nameKey: "service-youdaozhiyun-dialog-domain",
options: [
{
value: "general",
label: "general",
},
{
value: "computers",
label: "computers",
},
{
value: "medicine",
label: "medicine",
},
{
value: "finance",
label: "finance",
},
{
value: "game",
label: "game",
},
],
});
},
};
================================================
FILE: src/modules/services/youdaozhiyunllm.ts
================================================
import { hex, sha256Digest } from "../../utils/crypto";
import { getPref } from "../../utils/prefs";
import { getString } from "../../utils/locale";
import { TranslateService } from "./base";
const translate: TranslateService["translate"] = async function (data) {
function truncate(q: string) {
const len = q.length;
if (len <= 20) return q;
return q.substring(0, 10) + len + q.substring(len - 10, len);
}
function transLang(inlang: string = "") {
const langs = [{ regex: /zh(?:[-_]\w+)?/, lang: "zh-CHS" }];
// default
let outlang = inlang.split("-")[0];
langs.forEach((obj) => {
if (obj.regex.test(inlang)) {
outlang = obj.lang;
}
});
return outlang;
}
const [appid, key] = data.secret.split("#");
const salt = new Date().getTime();
const curtime = Math.round(new Date().getTime() / 1000);
const query = data.raw;
const from = transLang(data.langfrom);
const to = transLang(data.langto);
const str1 = appid + truncate(query) + salt + curtime + key;
const sign = hex(await sha256Digest(str1));
const model = getPref("youdaozhiyunllm.model");
const prompt = getPref("youdaozhiyunllm.prompt");
const stream = getPref("youdaozhiyunllm.stream") as boolean;
const streamType = stream ? "increment" : "full";
const refreshHandler = addon.api.getTemporaryRefreshHandler({ task: data });
if (!stream) {
data.result = getString("status-translating");
refreshHandler();
}
const streamCallback = (xmlhttp: XMLHttpRequest) => {
let preLength = 0;
let result = "";
let buffer = "";
let currentEventType = "";
xmlhttp.onprogress = (e: any) => {
// Only concatenate the new strings
const newResponse = e.target.response.slice(preLength);
preLength = e.target.response.length;
buffer += newResponse;
const events = buffer.split("\n\n");
buffer = events.pop() || "";
for (const event of events) {
if (!event) continue;
let eventData = "";
let isMessageEvent = false;
const lines = event.split("\n");
for (const line of lines) {
if (line.startsWith("event:")) {
currentEventType = line.replace("event:", "").trim();
isMessageEvent = currentEventType === "message";
} else if (line.startsWith("data:")) {
eventData = line.replace("data:", "").trim();
}
}
if (isMessageEvent && eventData) {
try {
const dataObj = JSON.parse(eventData);
if (dataObj.transIncre) {
result += dataObj.transIncre;
}
} catch (error) {
return;
}
}
}
if (e.target.timeout) {
e.target.timeout = 0;
}
data.result = result;
refreshHandler();
};
};
const nonStreamCallback = (xmlhttp: XMLHttpRequest) => {
let result = "";
let currentEventType = "";
xmlhttp.onload = () => {
try {
const responseObj = xmlhttp.responseText;
const lines = responseObj.split("\n");
let eventData = "";
let isMessageEvent = false;
for (const line of lines) {
if (line.startsWith("event:")) {
currentEventType = line.replace("event:", "").trim();
isMessageEvent = currentEventType === "message";
} else if (line.startsWith("data:")) {
eventData = line.replace("data:", "").trim();
}
if (isMessageEvent && eventData) {
try {
const dataObj = JSON.parse(eventData);
if (dataObj.transFull) {
result = dataObj.transFull;
}
} catch (error) {
return;
}
}
}
} catch (error) {
return;
}
data.result = result;
refreshHandler();
};
};
const xhr = await Zotero.HTTP.request(
"POST",
`https://openapi.youdao.com/llm_trans?i=${encodeURIComponent(query)}&appKey=${appid}&salt=${salt}&from=${from}&to=${to}&sign=${sign}&signType=v3&curtime=${curtime}&handleOption=${model}&prompt=${encodeURIComponent(prompt)}&streamType=${streamType}`,
{
headers: {
"Content-Type": "application/x-www-form-urlencoded",
},
responseType: "text",
requestObserver: (xmlhttp: XMLHttpRequest) => {
if (stream) {
streamCallback(xmlhttp);
} else {
nonStreamCallback(xmlhttp);
}
},
},
);
if (xhr?.status !== 200) {
throw `Request error: ${xhr?.status}`;
}
const res = xhr.response;
if (res.includes("errorCode")) {
throw `Service error: ${res}`;
}
if (res.includes("event:error")) {
throw `Service error: ${grepErrorParagraphs(res)}`;
}
function grepErrorParagraphs(input: string): string[] {
const paragraphs = input.split(/\n\n+/);
return paragraphs.filter((paragraph) => paragraph.includes("event:error"));
}
};
export const YoudaoZhiyunLLM: TranslateService = {
id: "youdaozhiyunllm",
type: "sentence",
helpUrl: "https://ai.youdao.com/console/#/service-singleton/llm_translate",
defaultSecret: "appid#appsecret",
secretValidator(secret: string) {
const parts = secret?.split("#");
const flag = parts.length == 2;
const partsInfo = `AppID: ${parts[0]}\nAppKey: ${parts[1]}`;
return {
secret,
status: flag && secret !== YoudaoZhiyunLLM.defaultSecret,
info:
secret === YoudaoZhiyunLLM.defaultSecret
? "The secret is not set."
: flag
? partsInfo
: `The secret format of YoudaoLLM is AppID#AppKey. The secret must have 2 parts joined by '#', but got ${parts?.length}.\n${partsInfo}`,
};
},
translate,
config(settings) {
settings
.addSelectSetting({
nameKey: "service-youdaozhiyunllm-dialog-model",
prefKey: "youdaozhiyunllm.model",
options: [
{
value: "0",
label: getString("service-youdaozhiyunllm-dialog-pro"),
},
{
value: "3",
label: getString("service-youdaozhiyunllm-dialog-lite"),
},
],
})
.addTextAreaSetting({
nameKey: "service-youdaozhiyunllm-dialog-prompt",
// @ts-expect-error this pref is not inited in prefs.js
prefKey: "youdaozhiyunllm.prompt",
placeholder: "Maximum 1200 characters or 400 words",
maxlength: "1200",
})
.addCheckboxSetting({
prefKey: "youdaozhiyunllm.stream",
nameKey: "service-youdaozhiyunllm-dialog-stream",
});
},
};
================================================
FILE: src/modules/settings/manageKeys.ts
================================================
import { getPrefJSON, setPref } from "../../utils/prefs";
import { getString } from "../../utils/locale";
export async function manageKeysDialog() {
const dialog = new ztoolkit.Dialog(2, 1);
const secrets = getPrefJSON("secretObj");
const dialogData: {
secrets: string;
updateSuccess: boolean;
unloadLock?: any;
_lastButtonId?: string;
} = {
secrets: JSON.stringify(secrets, null, 2),
updateSuccess: false,
};
dialog
.setDialogData(dialogData)
.addCell(
0,
0,
{
tag: "div",
namespace: "html",
styles: {
display: "flex",
flexDirection: "column",
gap: "15px",
padding: "20px",
},
children: [
{
tag: "label",
namespace: "html",
properties: {
innerHTML: getString("service-manageKeys-head"),
},
styles: {
marginBottom: "5px",
},
},
{
tag: "textarea",
namespace: "html",
attributes: {
"data-bind": "secrets",
"data-prop": "value",
rows: "25",
cols: "70",
},
styles: {
fontFamily: "monospace",
whiteSpace: "pre",
overflowX: "auto",
padding: "8px",
},
},
],
},
false,
)
.addButton(getString("service-manageKeys-close"), "close")
.addButton(getString("service-manageKeys-save"), "save")
.open(getString("service-manageKeys-title"));
if (dialogData.unloadLock && dialogData.unloadLock.promise) {
try {
await dialogData.unloadLock.promise;
} catch (error) {
console.error("Error waiting for dialog to close:", error);
}
}
if (dialogData._lastButtonId === "save") {
try {
const parsedSecrets = JSON.parse(dialogData.secrets);
setPref("secretObj", JSON.stringify(parsedSecrets));
dialogData.updateSuccess = true;
// Refresh UI if needed
addon.hooks.onReaderTabPanelRefresh();
} catch (e) {
if (dialog.window) {
Zotero.alert(
dialog.window,
"Error",
`Failed to save keys: ${e instanceof Error ? e.message : String(e)}`,
);
}
}
}
return dialogData.updateSuccess;
}
================================================
FILE: src/modules/settings/renameServices.ts
================================================
import { getPref, setPref } from "../../utils/prefs";
import { getString } from "../../utils/locale";
export async function renameServicesDialog() {
const dialog = new ztoolkit.Dialog(4, 1);
const dialogData: { [key: string | number]: any } = {
customgpt1: getPref("renameServices.customgpt1"),
customgpt2: getPref("renameServices.customgpt2"),
customgpt3: getPref("renameServices.customgpt3"),
};
dialog
.setDialogData(dialogData)
.addCell(
0,
0,
{
tag: "div",
namespace: "html",
styles: {
display: "grid",
gridTemplateColumns: "auto 1fr",
gap: "15px 20px",
alignItems: "center",
padding: "20px",
},
children: [
{
tag: "label",
namespace: "html",
properties: {
innerHTML: getString("service-renameServices-head"),
},
styles: {
gridColumn: "1 / span 2",
marginBottom: "5px",
},
},
{
tag: "label",
namespace: "html",
attributes: {
for: "customgpt1",
},
properties: {
innerHTML: getString("service-customgpt1"),
},
},
{
tag: "input",
id: "customgpt1",
attributes: {
"data-bind": "customgpt1",
"data-prop": "value",
type: "string",
placeholder: "Maximum 15 characters",
maxlength: "15",
},
},
{
tag: "label",
namespace: "html",
attributes: {
for: "customgpt2",
},
properties: {
innerHTML: getString("service-customgpt2"),
},
},
{
tag: "input",
id: "customgpt2",
attributes: {
"data-bind": "customgpt2",
"data-prop": "value",
type: "string",
placeholder: "Maximum 15 characters",
maxlength: "15",
},
},
{
tag: "label",
namespace: "html",
attributes: {
for: "customgpt3",
},
properties: {
innerHTML: getString("service-customgpt3"),
},
},
{
tag: "input",
id: "customgpt3",
attributes: {
"data-bind": "customgpt3",
"data-prop": "value",
type: "string",
placeholder: "Maximum 15 characters",
maxlength: "15",
},
},
{
tag: "label",
namespace: "html",
properties: {
innerHTML: getString("service-renameServices-hint"),
},
styles: {
gridColumn: "1 / span 2",
fontSize: "0.9rem",
},
},
],
},
false,
)
.addButton(getString("service-renameServices-close"), "close")
.addButton(getString("service-renameServices-save"), "save")
.open(getString("service-renameServices-title"));
await dialogData.unloadLock?.promise;
switch (dialogData._lastButtonId) {
case "save":
{
setPref("renameServices.customgpt1", dialogData.customgpt1);
setPref("renameServices.customgpt2", dialogData.customgpt2);
setPref("renameServices.customgpt3", dialogData.customgpt3);
}
break;
default:
break;
}
}
================================================
FILE: src/modules/shortcuts.ts
================================================
const concatKey = Zotero.isMac ? "Meta" : "Control";
export function registerShortcuts() {
ztoolkit.Keyboard.register((ev, data) => {
if (data.type === "keydown") {
if (ev.key === concatKey) {
addon.data.translate.concatKey = true;
}
}
if (data.type === "keyup") {
addon.data.translate.concatKey = false;
if (data.keyboard?.equals("accel,T")) {
const isReaderWindow =
ev.target?.ownerGlobal?.location?.href ===
"chrome://zotero/content/reader.xhtml";
if (!isReaderWindow) {
addon.hooks.onShortcuts(
Zotero.getMainWindow().Zotero_Tabs.selectedType,
);
} else {
addon.hooks.onShortcuts("reader");
}
}
}
});
}
================================================
FILE: src/modules/tabpanel.ts
================================================
import { getLocaleID } from "../utils/locale";
import { config } from "../../package.json";
import { getPref, setPref } from "../utils/prefs";
import { getLastTranslateTask } from "../utils/task";
import { TranslatorPanel } from "../elements/panel";
import { isWindowAlive } from "../utils/window";
import { services } from "./services";
let paneKey = "";
export function registerReaderTabPanel() {
const key = Zotero.ItemPaneManager.registerSection({
paneID: "translate",
pluginID: config.addonID,
header: {
l10nID: getLocaleID("itemPaneSection-header"),
icon: `chrome://${config.addonRef}/content/icons/section-16.svg`,
},
sidenav: {
l10nID: getLocaleID("itemPaneSection-sidenav"),
icon: `chrome://${config.addonRef}/content/icons/section-20.svg`,
// @ts-ignore
orderable: false,
},
bodyXHTML: "[
{ code: "af", name: "Afrikaans" },
{ code: "af-ZA", name: "Afrikaans (South Africa)" },
{ code: "sq", name: "Albanian" },
{ code: "sq-AL", name: "Albanian (Albania)" },
{ code: "am", name: "Amharic" },
{ code: "ar", name: "Arabic" },
{ code: "ar-DZ", name: "Arabic (Algeria)" },
{ code: "ar-BH", name: "Arabic (Bahrain)" },
{ code: "ar-EG", name: "Arabic (Egypt)" },
{ code: "ar-IQ", name: "Arabic (Iraq)" },
{ code: "ar-JO", name: "Arabic (Jordan)" },
{ code: "ar-KW", name: "Arabic (Kuwait)" },
{ code: "ar-LB", name: "Arabic (Lebanon)" },
{ code: "ar-LY", name: "Arabic (Libya)" },
{ code: "ar-MA", name: "Arabic (Morocco)" },
{ code: "ar-OM", name: "Arabic (Oman)" },
{ code: "ar-QA", name: "Arabic (Qatar)" },
{ code: "ar-SA", name: "Arabic (Saudi Arabia)" },
{ code: "ar-SY", name: "Arabic (Syria)" },
{ code: "ar-TN", name: "Arabic (Tunisia)" },
{ code: "ar-AE", name: "Arabic (U.A.E.)" },
{ code: "ar-YE", name: "Arabic (Yemen)" },
{ code: "hy", name: "Armenian" },
{ code: "hy-AM", name: "Armenian (Armenia)" },
{ code: "as", name: "Assamese" },
{ code: "ay", name: "Aymara" },
{ code: "az-AZ", name: "Azeri (Cyrillic) (Azerbaijan)" },
{ code: "az", name: "Azeri (Latin)" },
{ code: "az-AZ", name: "Azeri (Latin) (Azerbaijan)" },
{ code: "bm", name: "Bambara" },
{ code: "eu", name: "Basque" },
{ code: "eu-ES", name: "Basque (Spain)" },
{ code: "be", name: "Belarusian" },
{ code: "be-BY", name: "Belarusian (Belarus)" },
{ code: "bn", name: "Bengali" },
{ code: "bho", name: "Bhojpuri" },
{ code: "bo", name: "Tibetan" },
{ code: "bs", name: "Bosnian" },
{ code: "bs-BA", name: "Bosnian (Bosnia and Herzegovina)" },
{ code: "bg", name: "Bulgarian" },
{ code: "bg-BG", name: "Bulgarian (Bulgaria)" },
{ code: "ca", name: "Catalan" },
{ code: "ca-ES", name: "Catalan (Spain)" },
{ code: "ceb", name: "Cebuano" },
{ code: "ny", name: "Chichewa" },
{ code: "zh", name: "Chinese" },
{ code: "zh-HK", name: "Chinese (Hong Kong)" },
{ code: "zh-MO", name: "Chinese (Macau)" },
{ code: "zh-CN", name: "Chinese (S)" },
{ code: "zh-SG", name: "Chinese (Singapore)" },
{ code: "zh-TW", name: "Chinese (T)" },
{ code: "co", name: "Corsican" },
{ code: "hr", name: "Croatian" },
{ code: "hr-BA", name: "Croatian (Bosnia and Herzegovina)" },
{ code: "hr-HR", name: "Croatian (Croatia)" },
{ code: "cs", name: "Czech" },
{ code: "cs-CZ", name: "Czech (Czech Republic)" },
{ code: "da", name: "Danish" },
{ code: "da-DK", name: "Danish (Denmark)" },
{ code: "dv", name: "Divehi" },
{ code: "dv-MV", name: "Divehi (Maldives)" },
{ code: "doi", name: "Dogri" },
{ code: "nl", name: "Dutch" },
{ code: "nl-BE", name: "Dutch (Belgium)" },
{ code: "nl-NL", name: "Dutch (Netherlands)" },
{ code: "en", name: "English" },
{ code: "en-AU", name: "English (Australia)" },
{ code: "en-BZ", name: "English (Belize)" },
{ code: "en-CA", name: "English (Canada)" },
{ code: "en-CB", name: "English (Caribbean)" },
{ code: "en-IE", name: "English (Ireland)" },
{ code: "en-JM", name: "English (Jamaica)" },
{ code: "en-NZ", name: "English (New Zealand)" },
{ code: "en-PH", name: "English (Republic of the Philippines)" },
{ code: "en-ZA", name: "English (South Africa)" },
{ code: "en-TT", name: "English (Trinidad and Tobago)" },
{ code: "en-GB", name: "English (United Kingdom)" },
{ code: "en-US", name: "English (United States)" },
{ code: "en-ZW", name: "English (Zimbabwe)" },
{ code: "eo", name: "Esperanto" },
{ code: "et", name: "Estonian" },
{ code: "et-EE", name: "Estonian (Estonia)" },
{ code: "ee", name: "Ewe" },
{ code: "fo", name: "Faroese" },
{ code: "fo-FO", name: "Faroese (Faroe Islands)" },
{ code: "fa", name: "Farsi" },
{ code: "fa-IR", name: "Farsi (Iran)" },
{ code: "fi", name: "Finnish" },
{ code: "fi-FI", name: "Finnish (Finland)" },
{ code: "fr", name: "French" },
{ code: "fr-BE", name: "French (Belgium)" },
{ code: "fr-CA", name: "French (Canada)" },
{ code: "fr-FR", name: "French (France)" },
{ code: "fr-LU", name: "French (Luxembourg)" },
{ code: "fr-MC", name: "French (Principality of Monaco)" },
{ code: "fr-CH", name: "French (Switzerland)" },
{ code: "fy", name: "Frisian" },
{ code: "mk", name: "FYRO Macedonian" },
{
code: "mk-MK",
name: "FYRO Macedonian (Former Yugoslav Republic of Macedonia)",
},
{ code: "gl", name: "Galician" },
{ code: "gl-ES", name: "Galician (Spain)" },
{ code: "ka", name: "Georgian" },
{ code: "ka-GE", name: "Georgian (Georgia)" },
{ code: "de", name: "German" },
{ code: "de-AT", name: "German (Austria)" },
{ code: "de-DE", name: "German (Germany)" },
{ code: "de-LI", name: "German (Liechtenstein)" },
{ code: "de-LU", name: "German (Luxembourg)" },
{ code: "de-CH", name: "German (Switzerland)" },
{ code: "el", name: "Greek" },
{ code: "el-GR", name: "Greek (Greece)" },
{ code: "gn", name: "Guarani" },
{ code: "gu", name: "Gujarati" },
{ code: "gu-IN", name: "Gujarati (India)" },
{ code: "ht", name: "Haitian Creole" },
{ code: "ha", name: "Hausa" },
{ code: "haw", name: "Hawaiian" },
{ code: "he", name: "Hebrew" },
{ code: "iw", name: "Hebrew" },
{ code: "he-IL", name: "Hebrew (Israel)" },
{ code: "hi", name: "Hindi" },
{ code: "hi-IN", name: "Hindi (India)" },
{ code: "hmn", name: "Hmong" },
{ code: "hu", name: "Hungarian" },
{ code: "hu-HU", name: "Hungarian (Hungary)" },
{ code: "is", name: "Icelandic" },
{ code: "is-IS", name: "Icelandic (Iceland)" },
{ code: "ig", name: "Igbo" },
{ code: "ilo", name: "Ilocano" },
{ code: "id", name: "Indonesian" },
{ code: "id-ID", name: "Indonesian (Indonesia)" },
{ code: "ga", name: "Irish" },
{ code: "it", name: "Italian" },
{ code: "it-IT", name: "Italian (Italy)" },
{ code: "it-CH", name: "Italian (Switzerland)" },
{ code: "ja", name: "Japanese" },
{ code: "ja-JP", name: "Japanese (Japan)" },
{ code: "jw", name: "Javanese" },
{ code: "kn", name: "Kannada" },
{ code: "kn-IN", name: "Kannada (India)" },
{ code: "kk", name: "Kazakh" },
{ code: "kk-KZ", name: "Kazakh (Kazakhstan)" },
{ code: "km", name: "Khmer" },
{ code: "rw", name: "Kinyarwanda" },
{ code: "kok", name: "Konkani" },
{ code: "gom", name: "Konkani" },
{ code: "kok-IN", name: "Konkani (India)" },
{ code: "ko", name: "Korean" },
{ code: "ko-KR", name: "Korean (Korea)" },
{ code: "kri", name: "Krio" },
{ code: "ku", name: "Kurdish (Kurmanji)" },
{ code: "ckb", name: "Kurdish (Sorani)" },
{ code: "ky", name: "Kyrgyz" },
{ code: "ky-KG", name: "Kyrgyz (Kyrgyzstan)" },
{ code: "lo", name: "Lao" },
{ code: "la", name: "Latin" },
{ code: "lv", name: "Latvian" },
{ code: "lv-LV", name: "Latvian (Latvia)" },
{ code: "ln", name: "Lingala" },
{ code: "lt", name: "Lithuanian" },
{ code: "lt-LT", name: "Lithuanian (Lithuania)" },
{ code: "lg", name: "Luganda" },
{ code: "lb", name: "Luxembourgish" },
{ code: "mai", name: "Maithili" },
{ code: "mg", name: "Malagasy" },
{ code: "ms", name: "Malay" },
{ code: "ms-BN", name: "Malay (Brunei Darussalam)" },
{ code: "ms-MY", name: "Malay (Malaysia)" },
{ code: "ml", name: "Malayalam" },
{ code: "mt", name: "Maltese" },
{ code: "mt-MT", name: "Maltese (Malta)" },
{ code: "mi", name: "Maori" },
{ code: "mi-NZ", name: "Maori (New Zealand)" },
{ code: "mr", name: "Marathi" },
{ code: "mr-IN", name: "Marathi (India)" },
{ code: "mni-Mtei", name: "Meiteilon (Manipuri)" },
{ code: "lus", name: "Mizo" },
{ code: "mn", name: "Mongolian" },
{ code: "mn-MN", name: "Mongolian (Mongolia)" },
{ code: "my", name: "Myanmar (Burmese)" },
{ code: "ne", name: "Nepali" },
{ code: "ns", name: "Northern Sotho" },
{ code: "ns-ZA", name: "Northern Sotho (South Africa)" },
{ code: "no", name: "Norwegian" },
{ code: "nb", name: "Norwegian (Bokm?l)" },
{ code: "nb-NO", name: "Norwegian (Bokm?l) (Norway)" },
{ code: "nn-NO", name: "Norwegian (Nynorsk) (Norway)" },
{ code: "or", name: "Odia (Oriya)" },
{ code: "om", name: "Oromo" },
{ code: "ps", name: "Pashto" },
{ code: "ps-AR", name: "Pashto (Afghanistan)" },
{ code: "pl", name: "Polish" },
{ code: "pl-PL", name: "Polish (Poland)" },
{ code: "pt", name: "Portuguese" },
{ code: "pt-BR", name: "Portuguese (Brazil)" },
{ code: "pt-PT", name: "Portuguese (Portugal)" },
{ code: "pli", name: "Pali" },
{ code: "pa", name: "Punjabi" },
{ code: "pa-IN", name: "Punjabi (India)" },
{ code: "qu", name: "Quechua" },
{ code: "qu-BO", name: "Quechua (Bolivia)" },
{ code: "qu-EC", name: "Quechua (Ecuador)" },
{ code: "qu-PE", name: "Quechua (Peru)" },
{ code: "ro", name: "Romanian" },
{ code: "ro-RO", name: "Romanian (Romania)" },
{ code: "ru", name: "Russian" },
{ code: "ru-RU", name: "Russian (Russia)" },
{ code: "se-FI", name: "Sami (Inari) (Finland)" },
{ code: "se-NO", name: "Sami (Lule) (Norway)" },
{ code: "se-SE", name: "Sami (Lule) (Sweden)" },
{ code: "se", name: "Sami (Northern)" },
{ code: "se-FI", name: "Sami (Northern) (Finland)" },
{ code: "se-NO", name: "Sami (Northern) (Norway)" },
{ code: "se-SE", name: "Sami (Northern) (Sweden)" },
{ code: "se-FI", name: "Sami (Skolt) (Finland)" },
{ code: "se-NO", name: "Sami (Southern) (Norway)" },
{ code: "se-SE", name: "Sami (Southern) (Sweden)" },
{ code: "sm", name: "Samoan" },
{ code: "sa", name: "Sanskrit" },
{ code: "sa-IN", name: "Sanskrit (India)" },
{ code: "gd", name: "Scots Gaelic" },
{ code: "nso", name: "Sepedi" },
{ code: "sr", name: "Serbian" },
{ code: "sr-BA", name: "Serbian (Cyrillic) (Bosnia and Herzegovina)" },
{ code: "sr-SP", name: "Serbian (Cyrillic) (Serbia and Montenegro)" },
{ code: "sr-BA", name: "Serbian (Latin) (Bosnia and Herzegovina)" },
{ code: "sr-SP", name: "Serbian (Latin) (Serbia and Montenegro)" },
{ code: "st", name: "Sesotho" },
{ code: "sn", name: "Shona" },
{ code: "sd", name: "Sindhi" },
{ code: "si", name: "Sinhala" },
{ code: "sk", name: "Slovak" },
{ code: "sk-SK", name: "Slovak (Slovakia)" },
{ code: "sl", name: "Slovenian" },
{ code: "sl-SI", name: "Slovenian (Slovenia)" },
{ code: "so", name: "Somali" },
{ code: "es", name: "Spanish" },
{ code: "es-AR", name: "Spanish (Argentina)" },
{ code: "es-BO", name: "Spanish (Bolivia)" },
{ code: "es-ES", name: "Spanish (Castilian)" },
{ code: "es-CL", name: "Spanish (Chile)" },
{ code: "es-CO", name: "Spanish (Colombia)" },
{ code: "es-CR", name: "Spanish (Costa Rica)" },
{ code: "es-DO", name: "Spanish (Dominican Republic)" },
{ code: "es-EC", name: "Spanish (Ecuador)" },
{ code: "es-SV", name: "Spanish (El Salvador)" },
{ code: "es-GT", name: "Spanish (Guatemala)" },
{ code: "es-HN", name: "Spanish (Honduras)" },
{ code: "es-MX", name: "Spanish (Mexico)" },
{ code: "es-NI", name: "Spanish (Nicaragua)" },
{ code: "es-PA", name: "Spanish (Panama)" },
{ code: "es-PY", name: "Spanish (Paraguay)" },
{ code: "es-PE", name: "Spanish (Peru)" },
{ code: "es-PR", name: "Spanish (Puerto Rico)" },
{ code: "es-ES", name: "Spanish (Spain)" },
{ code: "es-UY", name: "Spanish (Uruguay)" },
{ code: "es-VE", name: "Spanish (Venezuela)" },
{ code: "su", name: "Sundanese" },
{ code: "sw", name: "Swahili" },
{ code: "sw-KE", name: "Swahili (Kenya)" },
{ code: "sv", name: "Swedish" },
{ code: "sv-FI", name: "Swedish (Finland)" },
{ code: "sv-SE", name: "Swedish (Sweden)" },
{ code: "syr", name: "Syriac" },
{ code: "syr-SY", name: "Syriac (Syria)" },
{ code: "tl", name: "Tagalog" },
{ code: "tl-PH", name: "Tagalog (Philippines)" },
{ code: "tg", name: "Tajik" },
{ code: "ta", name: "Tamil" },
{ code: "ta-IN", name: "Tamil (India)" },
{ code: "tt", name: "Tatar" },
{ code: "tt-RU", name: "Tatar (Russia)" },
{ code: "te", name: "Telugu" },
{ code: "te-IN", name: "Telugu (India)" },
{ code: "th", name: "Thai" },
{ code: "th-TH", name: "Thai (Thailand)" },
{ code: "ti", name: "Tigrinya" },
{ code: "ts", name: "Tsonga" },
{ code: "tn", name: "Tswana" },
{ code: "tn-ZA", name: "Tswana (South Africa)" },
{ code: "tr", name: "Turkish" },
{ code: "tr-TR", name: "Turkish (Turkey)" },
{ code: "tk", name: "Turkmen" },
{ code: "ak", name: "Twi" },
{ code: "uk", name: "Ukrainian" },
{ code: "uk-UA", name: "Ukrainian (Ukraine)" },
{ code: "ur", name: "Urdu" },
{ code: "ur-PK", name: "Urdu (Islamic Republic of Pakistan)" },
{ code: "ug", name: "Uyghur" },
{ code: "uz-UZ", name: "Uzbek (Cyrillic) (Uzbekistan)" },
{ code: "uz", name: "Uzbek (Latin)" },
{ code: "uz-UZ", name: "Uzbek (Latin) (Uzbekistan)" },
{ code: "vi", name: "Vietnamese" },
{ code: "vi-VN", name: "Vietnamese (Viet Nam)" },
{ code: "cy", name: "Welsh" },
{ code: "cy-GB", name: "Welsh (United Kingdom)" },
{ code: "xh", name: "Xhosa" },
{ code: "xh-ZA", name: "Xhosa (South Africa)" },
{ code: "yi", name: "Yiddish" },
{ code: "yo", name: "Yoruba" },
{ code: "zu", name: "Zulu" },
{ code: "zu-ZA", name: "Zulu (South Africa)" },
];
const MACRO_LANG_MAP = Object.entries(ISO6393_MACRO_LANGS).reduce(
(prev, [curr, items]) => {
items.forEach((macroLang) => {
Object.keys(macroLang).forEach((macroLangCode) => {
prev[macroLangCode] = curr;
});
});
return prev;
},
{} as Record,
);
const LANG_CODE_INDEX_MAP = LANG_CODE.reduce(
(acc, cur, index) => {
const code = cur.code.split("-")[0];
if (acc[code]) {
return acc;
}
acc[cur.code] = index;
return acc;
},
{} as Record,
);
function mapISO6393to6391(code: string) {
return (
ISO6393_3_TO_2[code as keyof typeof ISO6393_3_TO_2] ||
ISO6393_3_TO_2[
MACRO_LANG_MAP[
code as keyof typeof MACRO_LANG_MAP
] as keyof typeof ISO6393_3_TO_2
] ||
undefined
);
}
export const SVGIcon = ``;
================================================
FILE: src/utils/crypto.ts
================================================
function base64(buffer: ArrayBuffer) {
const str = String.fromCharCode(...new Uint8Array(buffer));
return ztoolkit.getGlobal("btoa")(str);
}
function randomString(length: number) {
const baseLen = Math.ceil(length / 4) * 3;
const random = crypto.getRandomValues(new Uint8Array(baseLen));
return base64(random as unknown as ArrayBuffer).substring(0, length);
}
function hex(buffer: ArrayBuffer) {
const hashArray = Array.from(new Uint8Array(buffer));
return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
}
async function hmacSha1Digest(
stringToSign: string,
secretKey: string | ArrayBuffer,
) {
const enc = new TextEncoder();
let keyData: ArrayBuffer;
if (typeof secretKey === "string") {
keyData = enc.encode(secretKey).buffer as ArrayBuffer;
} else {
keyData = secretKey;
}
const key = await crypto.subtle.importKey(
"raw",
keyData,
{
name: "HMAC",
hash: "SHA-1",
},
false,
["sign"],
);
return crypto.subtle.sign("HMAC", key, enc.encode(stringToSign));
}
async function hmacSha256Digest(
stringToSign: string,
secretKey: string | ArrayBuffer,
): Promise {
const enc = new TextEncoder();
let keyData: ArrayBuffer;
if (typeof secretKey === "string") {
keyData = enc.encode(secretKey).buffer as ArrayBuffer;
} else {
keyData = secretKey;
}
const key = await crypto.subtle.importKey(
"raw",
keyData,
{
name: "HMAC",
hash: "SHA-256",
},
false,
["sign"],
);
return crypto.subtle.sign("HMAC", key, enc.encode(stringToSign));
}
async function sha256Digest(message: string): Promise {
const enc = new TextEncoder();
return crypto.subtle.digest("SHA-256", enc.encode(message));
}
function pkcs7Pad(block: Uint8Array | Array) {
const padding = 16 - block.length;
const pad = new Uint8Array(padding);
pad.fill(padding);
return new Uint8Array([...block, ...pad]);
}
// AES ECB encrypt, use CBC mode to simulate ECB mode
async function aesEcbEncrypt(message: string, secret: string) {
const key = await crypto.subtle.importKey(
"raw",
new TextEncoder().encode(secret),
{
name: "AES-CBC",
},
false,
["encrypt"],
);
const encodeStr = new TextEncoder().encode(message);
// split encoded string to 16 byte blocks
const blocks = [];
for (let i = 0; i < encodeStr.length; i += 16) {
const block = encodeStr.subarray(i, i + 16);
blocks.push(block);
}
if (!blocks.length || blocks[blocks.length - 1].length === 16) {
blocks.push(pkcs7Pad([])); // pad empty block
} else {
blocks[blocks.length - 1] = pkcs7Pad(blocks[blocks.length - 1]);
}
// encrypt each block, do not pad
const zeros = new Uint8Array(16);
const encryptedBlocks = await Promise.all(
blocks.map((block) =>
crypto.subtle.encrypt(
{
name: "AES-CBC",
iv: block,
},
key,
zeros,
),
),
);
// concatenate encrypted blocks
const encrypted = new Uint8Array(encryptedBlocks.length * 16);
let offset = 0;
for (const block of encryptedBlocks) {
encrypted.set(new Uint8Array(block).subarray(0, 16), offset);
offset += 16;
}
return encrypted;
}
export {
aesEcbEncrypt,
base64,
randomString,
hex,
hmacSha1Digest,
hmacSha256Digest,
sha256Digest,
};
================================================
FILE: src/utils/index.ts
================================================
export * from "./config";
export * from "./crypto";
export * from "./llmPrompt";
export * from "./locale";
export * from "./prefs";
export * from "./secret";
export * from "./str";
export * from "./task";
export * from "./wait";
export * from "./window";
export * from "./ztoolkit";
export * from "./settingsDialog";
================================================
FILE: src/utils/llmPrompt.ts
================================================
import { getPref } from "./prefs";
import { TranslateTask } from "./task";
export function transformPromptWithContext(
prefKey: string,
langFrom: string,
langTo: string,
sourceText: string,
data: Required,
): string {
let prompt = getPref(prefKey) as string;
if (getPref("attachPaperContext") && data.itemId) {
const item = Zotero.Items.get(data.itemId);
const topItem = item ? Zotero.Items.getTopLevel([item])[0] : null;
if (topItem) {
let contextInfo = "";
const title = topItem.getField("title") as string;
const abstract = topItem.getField("abstractNote") as string;
if (title) {
contextInfo += `Paper Title: ${title}`;
}
if (abstract) {
contextInfo += title
? `\n\nPaper Abstract: ${abstract}`
: `Paper Abstract: ${abstract}`;
}
if (contextInfo) {
prompt = prompt.replace(
"${sourceText}",
`Context from the academic paper:\n${contextInfo}\n\nText to translate: ${sourceText}`,
);
}
}
}
return prompt
.replaceAll("${langFrom}", langFrom)
.replaceAll("${langTo}", langTo)
.replaceAll("${sourceText}", sourceText);
}
================================================
FILE: src/utils/locale.ts
================================================
import { config } from "../../package.json";
import { FluentMessageId } from "../../typings/i10n";
export { initLocale, getString, getLocaleID };
/**
* Initialize locale data
*/
function initLocale() {
const l10n = new (
typeof Localization === "undefined"
? ztoolkit.getGlobal("Localization")
: Localization
)([`${config.addonRef}-addon.ftl`], true);
addon.data.locale = {
current: l10n,
};
}
/**
* Get locale string, see https://firefox-source-docs.mozilla.org/l10n/fluent/tutorial.html#fluent-translation-list-ftl
* @param localString ftl key
* @param options.branch branch name
* @param options.args args
* @example
* ```ftl
* # addon.ftl
* addon-static-example = This is default branch!
* .branch-example = This is a branch under addon-static-example!
* addon-dynamic-example =
{ $count ->
[one] I have { $count } apple
*[other] I have { $count } apples
}
* ```
* ```js
* getString("addon-static-example"); // This is default branch!
* getString("addon-static-example", { branch: "branch-example" }); // This is a branch under addon-static-example!
* getString("addon-dynamic-example", { args: { count: 1 } }); // I have 1 apple
* getString("addon-dynamic-example", { args: { count: 2 } }); // I have 2 apples
* ```
*/
function getString(localString: FluentMessageId): string;
function getString(localString: FluentMessageId, branch: string): string;
function getString(
localeString: FluentMessageId,
options: { branch?: string | undefined; args?: Record },
): string;
function getString(...inputs: any[]): string;
function getString(...inputs: any[]) {
if (inputs.length === 1) {
return _getString(inputs[0]);
} else if (inputs.length === 2) {
if (typeof inputs[1] === "string") {
return _getString(inputs[0], { branch: inputs[1] });
} else {
return _getString(inputs[0], inputs[1]);
}
} else {
throw new Error("Invalid arguments");
}
}
function _getString(
localeString: FluentMessageId,
options: { branch?: string | undefined; args?: Record } = {},
): string {
const localStringWithPrefix = `${config.addonRef}-${localeString}`;
const { branch, args } = options;
const pattern = addon.data.locale?.current.formatMessagesSync([
{ id: localStringWithPrefix, args },
])[0];
if (!pattern) {
return localStringWithPrefix;
}
if (branch && pattern.attributes) {
for (const attr of pattern.attributes) {
if (attr.name === branch) {
return attr.value;
}
}
return pattern.attributes[branch] || localStringWithPrefix;
} else {
return pattern.value || localStringWithPrefix;
}
}
function getLocaleID(id: FluentMessageId) {
return `${config.addonRef}-${id}`;
}
================================================
FILE: src/utils/mathRenderer.ts
================================================
import katex from "katex";
// Unified, robust math rendering helpers
// Avoid lookbehind for broader engine compatibility by capturing a non-escape prefix
// Order: display (“$$ … $$”, "\\[ … \"] first), then inline “$ … $” (no newline), then "\\( … \")
const MATH_REGEX =
/(^|[^\\])\$\$([\s\S]*?)\$\$|\\\[([\s\S]*?)\\\]|(^|[^\\])\$(?!\$)([^\n]*?)\$(?!\$)|\\\(([\s\S]*?)\\\)/g;
const DEFAULT_KATEX_OPTIONS = {
throwOnError: false,
errorColor: "#cc0000",
strict: false,
} as const;
export function containsMath(text: string): boolean {
if (!text) return false;
const TEST_REGEX =
/(^|[^\\])\$\$[\s\S]*?\$\$|\\\[[\s\S]*?\\\]|(^|[^\\])\$[^\n]*?\$|\\\([\s\S]*?\\\)/;
return TEST_REGEX.test(text);
}
export function escapeHtml(doc: Document, text: string): string {
const div = doc.createElement("div");
div.textContent = text;
return div.innerHTML.replace(/\n/g, "
"); } export function renderMathInText(doc: Document, text: string): string { if (!text) return ""; if (!containsMath(text)) return escapeHtml(doc, text); let result = ""; let lastIndex = 0; let match: RegExpExecArray | null; while ((match = MATH_REGEX.exec(text)) !== null) { const [ full, dispPrefix, dispDollar, dispBracket, inlinePrefix, inlineDollar, inlineParen, ] = match; const prefixLen = dispPrefix || inlinePrefix ? 1 : 0; const plainEnd = match.index + prefixLen; if (plainEnd > lastIndex) { result += escapeHtml(doc, text.slice(lastIndex, plainEnd)); } let displayMode = false; let latex = ""; if (typeof dispDollar !== "undefined") { displayMode = true; latex = String(dispDollar).trim(); } else if (typeof dispBracket !== "undefined") { displayMode = true; latex = String(dispBracket).trim(); } else if (typeof inlineDollar !== "undefined") { displayMode = false; latex = String(inlineDollar).trim(); } else if (typeof inlineParen !== "undefined") { displayMode = false; latex = String(inlineParen).trim(); } try { const rendered = katex.renderToString(latex, { ...DEFAULT_KATEX_OPTIONS, displayMode, }); result += rendered; } catch (e) { result += escapeHtml(doc, full.slice(prefixLen)); } lastIndex = match.index + full.length; } if (lastIndex < text.length) { result += escapeHtml(doc, text.slice(lastIndex)); } return result; } export function renderMathInElement(element: HTMLElement, text: string): void { if (!element) return; element.innerHTML = renderMathInText(element.ownerDocument, text); } ================================================ FILE: src/utils/prefs.ts ================================================ import { config } from "../../package.json"; export { getPref, setPref, clearPref, getPrefJSON, registerPrefObserver, unregisterPrefObserver, }; type KeysWithStringValue = {
[K in keyof T]: T[K] extends string ? K : never;
}[keyof T];
type KeysWithNumberValue = {
[K in keyof T]: T[K] extends number ? K : never;
}[keyof T];
type KeysWithBooleanValue = {
[K in keyof T]: T[K] extends boolean ? K : never;
}[keyof T];
type _PluginPrefsMap = _ZoteroTypes.Prefs["PluginPrefsMap"];
export type PrefKeys = keyof _PluginPrefsMap;
export type PrefKeysWithStringValue = KeysWithStringValue<_PluginPrefsMap>;
export type PrefKeysWithNumberValue = KeysWithNumberValue<_PluginPrefsMap>;
export type PrefKeysWithBooleanValue = KeysWithBooleanValue<_PluginPrefsMap>;
function getPref(key: K): _PluginPrefsMap[K];
function getPref(key: string): string | number | boolean;
function getPref(key: string): string | number | boolean {
return Zotero.Prefs.get(`${config.prefsPrefix}.${key}`, true) as any;
}
function setPref(
key: K,
value: _PluginPrefsMap[K],
): void;
function setPref(key: string, value: string | number | boolean): void;
function setPref(key: string, value: string | number | boolean) {
return Zotero.Prefs.set(`${config.prefsPrefix}.${key}`, value, true);
}
function clearPref(key: K): void;
function clearPref(key: string): void;
function clearPref(key: string) {
return Zotero.Prefs.clear(`${config.prefsPrefix}.${key}`, true);
}
function getPrefJSON(key: string) {
try {
return JSON.parse(String(getPref(key) || "{}"));
} catch (e) {
setPref(key, "{}");
}
return {};
}
function registerPrefObserver(
key: K,
callback: (value: _PluginPrefsMap[K]) => void,
): symbol;
function registerPrefObserver(
key: string,
callback: (value: any) => void,
): symbol;
function registerPrefObserver(key: string, callback: (value: any) => void) {
return Zotero.Prefs.registerObserver(
`${config.prefsPrefix}.${key}`,
callback,
true,
);
}
function unregisterPrefObserver(observerID: symbol) {
return Zotero.Prefs.unregisterObserver(observerID);
}
================================================
FILE: src/utils/secret.ts
================================================
import { getPrefJSON, setPref } from "./prefs";
export interface SecretValidateResult {
secret: string;
status: boolean;
info: string;
}
export function getServiceSecret(serviceId: string) {
try {
return getPrefJSON("secretObj")[serviceId] || "";
} catch (e) {
setPref("secretObj", "{}");
return "";
}
}
export function setServiceSecret(serviceId: string, secret: string) {
let secrets;
try {
secrets = getPrefJSON("secretObj");
} catch (e) {
secrets = {};
}
secrets[serviceId] = secret;
setPref("secretObj", JSON.stringify(secrets));
}
export function validateServiceSecret(
serviceId: string,
validateCallback?: (result: SecretValidateResult) => void,
): SecretValidateResult {
const secret = getServiceSecret(serviceId);
// We should get service from addon.data.translate.services here,
// Otherwise, `services` will be bundled into customElement.js.
const service = addon.data.translate.services.getServiceById(serviceId);
const validator = service?.secretValidator;
if (!validator) {
return { secret, status: true, info: "" };
}
const validateResult = validator(secret);
if (validateCallback) {
validateCallback(validateResult);
}
return validateResult;
}
================================================
FILE: src/utils/settingsDialog.ts
================================================
import {
getPref,
PrefKeys,
PrefKeysWithBooleanValue,
PrefKeysWithNumberValue,
PrefKeysWithStringValue,
setPref,
} from "./prefs";
import { getString } from "./locale";
import { SettingsDialogHelper } from "zotero-plugin-toolkit";
import { FluentMessageId } from "../../typings/i10n";
import { TranslateService } from "../modules/services/base";
export type ConfigField =
| InputField
| TextareaField
| CheckboxField
| SelectField
| ButtonField
| ParamsField;
type DialogFieldBase = {
/**
* The fluent key of field name
*
*/
nameKey?: FluentMessageId;
/**
* The description of this field
*
*/
desc?: string;
/**
* The pref key of field value
*
*/
prefKey?: PrefKeys;
/**
* is hidden this field
*
* @default true
*/
hidden?: boolean;
};
type InputField = InputFieldBase | InputFieldText | InputFieldNumber;
type InputFieldBase = DialogFieldBase & {
inputType?: string;
placeholder?: string;
};
type InputFieldText = InputFieldBase & {
prefKey: PrefKeysWithStringValue;
};
type InputFieldNumber = InputFieldBase & {
// For compatibility, includes number and string here
prefKey: PrefKeysWithNumberValue | PrefKeysWithStringValue;
min?: number;
max?: number;
step?: number;
};
type TextareaField = DialogFieldBase & {
prefKey: PrefKeysWithStringValue;
placeholder?: string;
};
type CheckboxField = DialogFieldBase & {
prefKey: PrefKeysWithBooleanValue;
};
type SelectField = DialogFieldBase & {
prefKey: PrefKeysWithStringValue;
options: Array<{
value: string;
label: string;
}>;
};
type ButtonField = DialogFieldBase & {
callback?: () => void;
};
type ParamsField = DialogFieldBase & {
prefKey: PrefKeysWithStringValue;
};
type Validater = (
data: Record,
) => true | string | Promise;
/**
* A restricted interface of {@link ServiceSettingsDialog} that exposes
* only the setting-adding and validation methods allowed inside
* {@link TranslateService.config}.
*
*/
export type AllowedSettingsMethods = Pick<
ServiceSettingsDialog,
| "addCheckboxSetting"
| "addPasswordSetting"
| "addTextSetting"
| "addNumberSetting"
| "addSelectSetting"
| "addTextAreaSetting"
| "addCustomParamsSetting"
| "addButton"
| "addSetting"
| "addStaticRow"
| "onSave"
>;
export class ServiceSettingsDialog extends SettingsDialogHelper {
constructor() {
super();
this.setSettingHandlers(getPref, setPref);
}
addTextSetting(field: InputFieldText): AllowedSettingsMethods {
return this.addSetting(getString(field.nameKey), field.prefKey, {
tag: "input",
attributes: {
type: field.inputType || "text",
placeholder: field.placeholder || "",
},
styles: {
minWidth: "400px",
},
});
}
addPasswordSetting(field: InputFieldText): AllowedSettingsMethods {
return this.addSetting(getString(field.nameKey), field.prefKey, {
tag: "input",
attributes: {
type: "password",
},
styles: {
minWidth: "400px",
},
});
}
addNumberSetting(field: InputFieldNumber): AllowedSettingsMethods {
return this.addSetting(getString(field.nameKey), field.prefKey, {
tag: "input",
attributes: {
type: "number",
min: field.min || 0,
max: field.max || 100,
step: field.step || 1,
},
styles: {
minWidth: "400px",
},
});
}
addCheckboxSetting(field: CheckboxField): AllowedSettingsMethods {
return this.addSetting(
getString(field.nameKey),
field.prefKey,
{
tag: "input",
attributes: {
type: "checkbox",
},
styles: {
justifySelf: "start",
},
},
{
valueType: "boolean",
},
);
}
addSelectSetting(field: SelectField): AllowedSettingsMethods {
return this.addSetting(getString(field.nameKey), field.prefKey, {
tag: "select",
children: field.options.map(({ label, value }) => ({
tag: "option",
properties: {
innerHTML: label,
value,
},
})),
styles: {
minWidth: "400px",
// auto resize to window width
width: "-moz-available",
},
});
}
addTextAreaSetting(field: TextareaField): AllowedSettingsMethods {
return this.addSetting(getString(field.nameKey), field.prefKey, {
tag: "textarea",
attributes: {
placeholder: field.placeholder,
rows: 5,
},
styles: {
minWidth: "400px",
},
});
}
addCustomParamsSetting(field: ParamsField): AllowedSettingsMethods {
return this.addButton(getString(field.nameKey), field.prefKey, {
noClose: true,
callback(ev) {
openCustomRequestDialog(field.prefKey);
},
});
}
validater?: Validater;
onSaveCallback?: () => void;
onSave(validate?: Validater) {
this.validater = validate;
return this;
}
}
export async function createServiceSettingsDialog(
service: TranslateService,
): Promise {
const dialog = new ServiceSettingsDialog();
if (service.config) {
service.config(dialog);
}
const { id, helpUrl } = service;
if (helpUrl) {
dialog.addButton(getString(`service-dialog-help`), "help", {
noClose: true,
callback: async () => {
await Zotero.launchURL(helpUrl);
},
});
}
const serviceName = service.name || getString(`service-${id}`);
dialog
.addButton(getString(`service-dialog-close`), "close")
.addAutoSaveButton(getString(`service-dialog-save`), "save", {
// https://github.com/windingwind/zotero-plugin-toolkit/issues/87
validate: dialog.validater,
})
.open(
getString(`service-dialog-title`, {
args: { service: serviceName },
}),
);
}
// =======================================================
// Custom parameters field
//========================================================
const CUSTOM_PARAMS_INPUT_STYLES = {
width: "100%",
height: "32px",
padding: "6px 8px",
boxSizing: "border-box",
border: "1px solid var(--color-border)",
borderRadius: "4px",
fontSize: "1rem",
};
function createParamInputCell(
doc: Document,
type: "key" | "value",
index: number,
value: string = "",
): HTMLTableCellElement {
const cell = doc.createElement("td");
cell.style.padding = "8px";
const input = doc.createElement("input");
input.type = "text";
input.id = `${type}-${index}`;
input.placeholder =
type === "key" ? "Parameter name" : "Parameter value (JSON format)";
input.value = value;
Object.assign(input.style, CUSTOM_PARAMS_INPUT_STYLES);
cell.appendChild(input);
return cell;
}
async function openCustomRequestDialog(prefKey: string) {
const dialog = new ztoolkit.Dialog(2, 1);
// Get stored custom parameters or default empty object
const storedCustomParams = (getPref(prefKey) as string) || "{}";
let customParams: Record = {};
try {
customParams = JSON.parse(storedCustomParams);
} catch (e) {
customParams = {};
}
// Convert to key-value pairs for display
const keyValuePairs: Array<{ key: string; value: string }> = Object.entries(
customParams,
).map(([key, value]) => ({
key,
value: JSON.stringify(value),
}));
// Add empty pair for new entries
keyValuePairs.push({ key: "", value: "" });
const dialogData: { [key: string | number]: any } = {
customParams: keyValuePairs,
};
let paramIndex = keyValuePairs.length;
const createTableRow = (
pair: { key: string; value: string },
index: number,
) => ({
tag: "tr",
namespace: "html",
children: [
{
tag: "td",
namespace: "html",
styles: { padding: "8px" },
children: [
{
tag: "input",
namespace: "html",
id: `key-${index}`,
attributes: {
type: "text",
placeholder: "Parameter name",
value: pair.key || "",
},
styles: CUSTOM_PARAMS_INPUT_STYLES,
},
],
},
{
tag: "td",
namespace: "html",
styles: { padding: "8px" },
children: [
{
tag: "input",
namespace: "html",
id: `value-${index}`,
attributes: {
type: "text",
placeholder: "Parameter value (JSON format)",
value: pair.value || "",
},
styles: CUSTOM_PARAMS_INPUT_STYLES,
},
],
},
],
});
const createTableRows = () => {
return keyValuePairs.map((pair, index) => createTableRow(pair, index));
};
dialog
.setDialogData(dialogData)
.addCell(
0,
0,
{
tag: "div",
namespace: "html",
styles: {
width: "600px",
height: "400px",
maxWidth: "90vw",
maxHeight: "80vh",
minWidth: "500px",
minHeight: "300px",
overflowY: "auto",
padding: "15px",
resize: "both",
},
children: [
{
tag: "p",
namespace: "html",
styles: {
marginBottom: "15px",
},
properties: {
innerHTML: getString(`service-dialog-custom-request-description`),
},
},
{
tag: "table",
namespace: "html",
id: "custom-params-table",
styles: {
width: "100%",
borderCollapse: "collapse",
marginBottom: "10px",
},
children: [
{
tag: "thead",
namespace: "html",
children: [
{
tag: "tr",
namespace: "html",
children: [
{
tag: "th",
namespace: "html",
styles: {
textAlign: "left",
padding: "10px 8px",
borderBottom: "2px solid var(--color-border)",
backgroundColor: "var(--color-menu)",
fontWeight: "bold",
},
properties: {
innerHTML: "Parameter Name",
},
},
{
tag: "th",
namespace: "html",
styles: {
textAlign: "left",
padding: "10px 8px",
borderBottom: "2px solid var(--color-border)",
backgroundColor: "var(--color-menu)",
fontWeight: "bold",
},
properties: {
innerHTML: "Parameter Value",
},
},
],
},
],
},
{
tag: "tbody",
namespace: "html",
id: "custom-params-tbody",
children: createTableRows(),
},
],
},
{
tag: "div",
namespace: "html",
styles: {
marginTop: "15px",
display: "flex",
justifyContent: "flex-start",
},
children: [
{
tag: "a",
namespace: "html",
id: "custom-add-param-btn",
attributes: {
href: "#",
},
styles: {
color: "var(--fill-primary, #2ea8e5)",
textDecoration: "underline",
cursor: "pointer",
fontSize: "13px",
},
properties: {
innerHTML: getString(
`service-dialog-custom-request-add-param`,
),
},
listeners: [
{
type: "click",
listener: (e: Event) => {
e.preventDefault();
const doc = (e.target as HTMLElement).ownerDocument;
const tbody = doc.getElementById("custom-params-tbody");
if (tbody) {
const row = doc.createElement("tr");
row.appendChild(
createParamInputCell(doc, "key", paramIndex),
);
row.appendChild(
createParamInputCell(doc, "value", paramIndex),
);
tbody.appendChild(row);
paramIndex++;
}
},
},
],
},
],
},
],
},
false,
)
.addButton(getString(`service-dialog-close`), "close")
.addButton(getString(`service-dialog-save`), "save")
.open(getString(`service-dialog-custom-request-title`));
await dialogData.unloadLock?.promise;
switch (dialogData._lastButtonId) {
case "save": {
// Collect and save custom parameters from all existing input fields
const finalParams: Record = {};
let index = 0;
// Loop through all possible input fields
while (true) {
const keyElement = dialog.window.document.getElementById(
`key-${index}`,
) as HTMLInputElement;
const valueElement = dialog.window.document.getElementById(
`value-${index}`,
) as HTMLInputElement;
if (!keyElement || !valueElement) break;
if (keyElement.value.trim()) {
try {
finalParams[keyElement.value] = JSON.parse(valueElement.value);
} catch (e) {
finalParams[keyElement.value] = valueElement.value;
}
}
index++;
}
setPref(prefKey, JSON.stringify(finalParams));
break;
}
default:
break;
}
}
================================================
FILE: src/utils/str.ts
================================================
import { getString } from "./locale";
export function slice(str: string, len: number) {
return str.length > len ? `${str.slice(0, len - 3)}...` : str;
}
export function fill(
str: string,
len: number,
options: { char: string; position: "start" | "end" } = {
char: " ",
position: "end",
},
) {
if (str.length >= len) {
return str;
}
return str[options.position === "start" ? "padStart" : "padEnd"](
len - str.length,
options.char,
);
}
/**
* Strip empty lines and thinking tags from text
* @param text Text to process
* @param enabled Whether stripping is enabled
* @returns Processed text
*/
export function stripEmptyLines(text: string, enabled: boolean): string {
if (!text || !enabled) return text;
// Strip ... tags and their content
const processedText = text.replace(/[\s\S]*?<\/think>/gi, "");
// Leave blank lines for error messages
const errorPrefix = getString("service-errorPrefix");
if (processedText.includes(errorPrefix)) {
return processedText;
} else {
// Normalize line endings to \n
const normalizedText = processedText
.replace(/\r\n/g, "\n")
.replace(/\r/g, "\n");
// Remove leading newlines, then replace all remaining newlines with spaces
const result = normalizedText.replace(/^\n+/, "").replace(/\n+/g, " ");
return result;
}
}
================================================
FILE: src/utils/task.ts
================================================
import { inferLanguage, matchLanguage } from "./config";
import { getString } from "./locale";
import { getPref } from "./prefs";
import { getServiceSecret } from "./secret";
import { config } from "../../package.json";
import Addon from "../addon";
export interface TranslateTask {
/**
* Task id.
*/
id: string;
/**
* Task type.
*/
type: "text" | "annotation" | "title" | "abstract" | "addtonote" | "custom";
/**
* Raw text for translation.
*/
raw: string;
/**
* Translation result or error info.
*/
result: string;
/**
* Audio resources.
*/
audio: { text: string; url: string }[];
/**
* Service id.
*/
service: string;
/**
* Candidate service ids.
*
* Only used when the run of `service` fails.
* Generally this is for the fallback of word services.
*/
candidateServices: string[];
/**
* Zotero item id.
*
* For language disable check.
*/
itemId: number | undefined;
/**
* From language
*
* Generated at task runtime.
*/
langfrom?: string;
/**
* To language.
*
* Generated at task runtime.
*/
langto?: string;
/**
* Whether the from language is inferred.
*/
langfromInferred?: boolean;
/**
* Service secret.
*
* Generated at task runtime.
*/
secret?: string;
/**
* task status.
*/
status: "waiting" | "processing" | "success" | "fail";
/**
* Extra tasks.
*
* For extra services function.
*/
extraTasks: TranslateTask[] & { extraTasks: [] }[];
/**
* Whether to mute error info, depends on the implementation of the service.
*/
silent?: boolean;
/**
* Caller identifier.
*
* This is for translate service provider to identify the caller.
* If not provided, the call will fail.
*/
callerID?: string;
/**
* If the task is once processed.
*/
processed?: boolean;
}
export type TranslateTaskProcessor = (
data: Required,
) => Promise | void;
export class TranslateTaskRunner {
protected processor: TranslateTaskProcessor;
constructor(processor: TranslateTaskProcessor) {
this.processor = processor;
}
public async run(data: TranslateTask) {
// @ts-ignore - Plugin instance is not typed
const addon = Zotero[config.addonInstance] as Addon;
const ztoolkit = addon.data.ztoolkit;
if (!data.langfrom || !data.langto) {
ztoolkit.log("try auto detect language");
const { fromLanguage, toLanguage, isInferred } = autoDetectLanguage(
Zotero.Items.get(data.itemId || -1),
);
data.langfrom = data.langfrom || fromLanguage;
data.langto = data.langto || toLanguage;
if (isInferred) {
data.langfromInferred = true;
}
}
// If the task is not new, update language settings
if (data.processed) {
updateTranslateTaskLang(data);
}
data.callerID = data.callerID || config.addonID;
data.secret = getServiceSecret(data.service);
data.status = "processing";
try {
ztoolkit.log(data);
await this.processor(data as Required);
data.status = "success";
} catch (e) {
data.result = this.makeErrorInfo(data.service, String(e));
data.status = "fail";
}
data.processed = true;
}
protected makeErrorInfo(serviceId: string, detail: string) {
return `${getString("service-errorPrefix")} ${getString(
`service-${serviceId}`,
)}\n\n${detail}`;
}
}
export function addTranslateTask(
raw: string,
itemId?: number,
type?: TranslateTask["type"],
service?: string,
) {
if (!raw) {
return;
}
// @ts-ignore - Plugin instance is not typed
const addon = Zotero[config.addonInstance] as Addon;
type = type || "text";
// Filter raw string
// eslint-disable-next-line no-control-regex
raw = raw.replace(/[\u0000-\u001F\u007F-\u009F]/gu, " ").normalize("NFKC");
// Append raw text to last task's raw if in concat mode
const isConcatMode =
type === "text" &&
(addon.data.translate.concatCheckbox ||
(getPref("enableConcatKey") && addon.data.translate.concatKey));
const lastTask = getLastTranslateTask({ type: "text" });
if (isConcatMode && lastTask) {
lastTask.raw += " " + raw;
lastTask.extraTasks.forEach((extraTask) => (extraTask.raw += " " + raw));
lastTask.status = "waiting";
putTranslateTaskAtHead(lastTask.id);
return;
}
// Create a new task
const newTask: TranslateTask = {
id: `${Zotero.Utilities.randomString()}-${new Date().getTime()}`,
type,
raw,
result: "",
audio: [],
service: "",
candidateServices: [],
itemId,
status: "waiting",
extraTasks: [],
};
if (!service) {
setDefaultService(newTask);
} else {
newTask.service = service;
}
addon.data.translate.queue.push(newTask);
// In case window panel requires extra translations
if (
type === "text" &&
addon.data.panel.windowPanel &&
!addon.data.panel.windowPanel.closed
) {
(getPref("extraEngines") as string)
.split(",")
.filter((s) => s)
.forEach((extraService) =>
newTask.extraTasks.push({
id: `${Zotero.Utilities.randomString()}-${new Date().getTime()}`,
type: "text",
raw,
result: "",
audio: [],
service: extraService,
candidateServices: [],
extraTasks: [],
itemId,
status: "waiting",
}),
);
}
// Keep queue size
cleanTasks();
return newTask;
}
export function addTranslateAnnotationTask(
libraryID: number,
itemKey: string,
): TranslateTask | undefined;
export function addTranslateAnnotationTask(
itemID: number,
): TranslateTask | undefined;
export function addTranslateAnnotationTask(
itemIDOrLibraryID: number,
itemKey?: string,
) {
let item: Zotero.Item | false;
if (itemKey) {
item = Zotero.Items.getByLibraryAndKey(
itemIDOrLibraryID,
itemKey,
) as Zotero.Item;
} else {
item = Zotero.Items.get(itemIDOrLibraryID);
}
if (!item) {
return;
}
return addTranslateTask(item.annotationText, item.id, "annotation");
}
export function addTranslateTitleTask(
itemId: number,
skipIfExists: boolean = false,
) {
// @ts-ignore - Plugin instance is not typed
const addon = Zotero[config.addonInstance] as Addon;
const ztoolkit = addon.data.ztoolkit;
const item = Zotero.Items.get(itemId);
if (
item?.isRegularItem() &&
!(
skipIfExists &&
ztoolkit.ExtraField.getExtraField(item, "titleTranslation")
)
) {
return addTranslateTask(item.getField("title") as string, item.id, "title");
}
}
export function addTranslateAbstractTask(
itemId: number,
skipIfExists: boolean = false,
) {
// @ts-ignore - Plugin instance is not typed
const addon = Zotero[config.addonInstance] as Addon;
const ztoolkit = addon.data.ztoolkit;
const item = Zotero.Items.get(itemId);
if (
item?.isRegularItem() &&
!(
skipIfExists &&
ztoolkit.ExtraField.getExtraField(item, "abstractTranslation")
)
) {
return addTranslateTask(
item.getField("abstractNote") as string,
item.id,
"abstract",
);
}
}
function setDefaultService(task: TranslateTask) {
// Use wordService(dictSource) for single word translation
if (
getPref("enableDict") &&
task.raw.trim().split(/[^a-zA-Z]+/).length == 1
) {
task.service = getPref("dictSource") as string;
task.candidateServices.push(getPref("translateSource") as string);
} else {
task.service = getPref("translateSource") as string;
}
// In case service is still empty
task.service =
task.service || addon.data.translate.services.getAllServices()[0].id;
}
function cleanTasks() {
// @ts-ignore - Plugin instance is not typed
const addon = Zotero[config.addonInstance] as Addon;
if (
addon.data.translate.queue.length > addon.data.translate.maximumQueueLength
) {
addon.data.translate.queue.splice(
0,
Math.floor(addon.data.translate.maximumQueueLength / 3),
);
}
}
export function getTranslateTasks(count: number) {
// @ts-ignore - Plugin instance is not typed
return (Zotero[config.addonInstance] as Addon).data.translate.queue.slice(
-count,
);
}
export function getLastTranslateTask<
K extends keyof TranslateTask,
V extends TranslateTask[K],
>(conditions?: { [key in K]: V }) {
// @ts-ignore - Plugin instance is not typed
const queue = (Zotero[config.addonInstance] as Addon).data.translate.queue;
let i = queue.length - 1;
while (i >= 0) {
const currentTask = queue[i];
const notMatchConditions =
conditions &&
Object.keys(conditions)
.map((key) => currentTask[key as K] === conditions[key as K])
.includes(false);
if (!notMatchConditions) {
return queue[i];
}
i--;
}
return undefined;
}
/**
* Update the task with the latest language settings.
*/
export function updateTranslateTaskLang(task: TranslateTask) {
if (!task.langfromInferred) {
task.langfrom = getPref("sourceLanguage") as string;
}
task.langto = getPref("targetLanguage") as string;
}
export function putTranslateTaskAtHead(taskId: string) {
// @ts-ignore - Plugin instance is not typed
const queue = (Zotero[config.addonInstance] as Addon).data.translate.queue;
const idx = queue.findIndex((task) => task.id === taskId);
if (idx >= 0) {
const targetTask = queue.splice(idx, 1)[0];
queue.push(targetTask);
return true;
}
return false;
}
export function autoDetectLanguage(item: Zotero.Item | null) {
if (!item) {
return {
fromLanguage: getPref("sourceLanguage") as string,
toLanguage: getPref("targetLanguage") as string,
};
}
// @ts-ignore - Plugin instance is not typed
const addon = Zotero[config.addonInstance] as Addon;
const ztoolkit = addon.data.ztoolkit;
const topItem = Zotero.Items.getTopLevel([item])[0];
const fromLanguage = getPref("sourceLanguage") as string;
const toLanguage = getPref("targetLanguage") as string;
let detectedFromLanguage = fromLanguage;
// Use cached source language
const sourceLanguageCache =
addon.data.translate.cachedSourceLanguage[item.id];
if (sourceLanguageCache && sourceLanguageCache !== toLanguage) {
return {
fromLanguage: sourceLanguageCache,
toLanguage,
};
}
let isInferred = false;
if (getPref("enableAutoDetectLanguage")) {
if (topItem) {
let itemLanguage: string =
// Respect language field
matchLanguage((topItem.getField("language") as string) || "").code;
ztoolkit.log("try itemLanguage", itemLanguage);
if (!itemLanguage) {
// Respect AbstractNote or Title inferred language
const inferredLanguage = inferLanguage(
(topItem.getField("abstractNote") as string) ||
(topItem.getField("title") as string) ||
"",
).code;
ztoolkit.log("try inferredLanguage", inferredLanguage);
if (inferredLanguage) {
// Update language field so that it can be used in the future
itemLanguage = inferredLanguage;
if (topItem.isRegularItem()) {
topItem.setField("language", fromLanguage);
}
}
}
const itemLanguageMajor = itemLanguage.split("-")[0];
if (
itemLanguage &&
![fromLanguage, toLanguage].find(
(lang) => lang.split("-")[0] === itemLanguageMajor,
)
) {
ztoolkit.log("use autoDetect", itemLanguage);
// If the item language is not the same as the target/source language, use it
detectedFromLanguage = itemLanguage;
isInferred = true;
}
}
}
return {
fromLanguage: detectedFromLanguage,
toLanguage,
isInferred,
};
}
================================================
FILE: src/utils/wait.ts
================================================
export function waitUntil(
condition: () => boolean,
callback: () => void,
interval = 100,
timeout = 10000,
) {
const start = Date.now();
const intervalId = setInterval(() => {
if (condition()) {
clearInterval(intervalId);
callback();
} else if (Date.now() - start > timeout) {
clearInterval(intervalId);
}
}, interval);
}
export function waitUtilAsync(
condition: () => boolean,
interval = 100,
timeout = 10000,
) {
return new Promise((resolve, reject) => {
const start = Date.now();
const intervalId = setInterval(() => {
if (condition()) {
clearInterval(intervalId);
resolve();
} else if (Date.now() - start > timeout) {
clearInterval(intervalId);
reject();
}
}, interval);
});
}
================================================
FILE: src/utils/window.ts
================================================
export { isWindowAlive, getFocusedWindow };
function isWindowAlive(win?: Window) {
return win && !Components.utils.isDeadWrapper(win) && !win.closed;
}
function getFocusedWindow() {
const wins = Services.wm.getEnumerator("") as unknown as Window[];
for (const win of wins) {
if (win.document?.hasFocus()) {
return win;
}
}
}
================================================
FILE: src/utils/ztoolkit.ts
================================================
import {
BasicTool,
UITool,
ExtraFieldTool,
FieldHookManager,
KeyboardManager,
MenuManager,
PromptManager,
DialogHelper,
SettingsDialogHelper,
ProgressWindowHelper,
ClipboardHelper,
makeHelperTool,
unregister,
} from "zotero-plugin-toolkit";
import { config } from "../../package.json";
export { createZToolkit };
function createZToolkit() {
// const _ztoolkit = new ZoteroToolkit();
/**
* Alternatively, import toolkit modules you use to minify the plugin size.
* You can add the modules under the `MyToolkit` class below and uncomment the following line.
*/
const _ztoolkit = new MyToolkit();
initZToolkit(_ztoolkit);
return _ztoolkit;
}
function initZToolkit(_ztoolkit: ReturnType) {
const env = __env__;
_ztoolkit.basicOptions.log.prefix = `[${config.addonName}]`;
_ztoolkit.basicOptions.log.disableConsole = env === "production";
_ztoolkit.UI.basicOptions.ui.enableElementJSONLog = __env__ === "development";
_ztoolkit.UI.basicOptions.ui.enableElementDOMLog = __env__ === "development";
_ztoolkit.basicOptions.debug.disableDebugBridgePassword =
__env__ === "development";
_ztoolkit.basicOptions.api.pluginID = config.addonID;
_ztoolkit.ProgressWindow.setIconURI(
"default",
`chrome://${config.addonRef}/content/icons/favicon.png`,
);
}
export class MyToolkit extends BasicTool {
UI: UITool;
ExtraField: ExtraFieldTool;
FieldHook: FieldHookManager;
Keyboard: KeyboardManager;
Menu: MenuManager;
Prompt: PromptManager;
Dialog: typeof DialogHelper;
SettingsDialog: typeof SettingsDialogHelper;
ProgressWindow: typeof ProgressWindowHelper;
Clipboard: typeof ClipboardHelper;
constructor() {
super();
this.UI = new UITool(this);
this.ExtraField = new ExtraFieldTool(this);
this.FieldHook = new FieldHookManager(this);
this.Keyboard = new KeyboardManager(this);
this.Menu = new MenuManager(this);
this.Prompt = new PromptManager(this);
this.Dialog = makeHelperTool(DialogHelper, this);
this.SettingsDialog = makeHelperTool(SettingsDialogHelper, this);
this.ProgressWindow = makeHelperTool(ProgressWindowHelper, this);
this.Clipboard = makeHelperTool(ClipboardHelper, this);
}
unregisterAll() {
unregister(this);
}
}
================================================
FILE: tsconfig.json
================================================
{
"extends": "zotero-types/entries/sandbox",
"include": ["src", "typings", "node_modules/zotero-types"],
"exclude": ["build", "addon"]
}
================================================
FILE: typings/global.d.ts
================================================
declare const _globalThis: {
[key: string]: any;
Zotero: _ZoteroTypes.Zotero;
crypto: Crypto;
TextEncoder: typeof TextEncoder;
ztoolkit: ZToolkit;
addon: typeof addon;
};
declare type ZToolkit = ReturnType<
typeof import("../src/utils/ztoolkit").createZToolkit
>;
declare const ztoolkit: ZToolkit;
declare const rootURI: string;
declare const addon: import("../src/addon").default;
declare const __env__: "production" | "development";
declare class XULElementBase extends HTMLElement {
get content(): DocumentFragment;
init(): void;
destroy(): void;
connectedCallback(): void;
disconnectedCallback(): void;
attributeChangedCallback(
name: string,
oldValue: string,
newValue: string,
): void;
_handleWindowUnload(): void;
initialized: boolean;
static get observedAttributes(): string[];
}
declare class MozXULElement {
static parseXULToFragment(xul: string): DocumentFragment;
static insertFTLIfNeeded(ftl: string): void;
}
declare namespace Zotero {
const PDFTranslate: import("../src/addon").default;
}
================================================
FILE: typings/i10n.d.ts
================================================
// Generated by zotero-plugin-scaffold
/* prettier-ignore */
/* eslint-disable */
// @ts-nocheck
export type FluentMessageId =
| 'add-source'
| 'auto'
| 'autoTranslateAnnotation'
| 'autoTranslateSelection'
| 'clearConcat'
| 'copy'
| 'copyBoth'
| 'copyRaw'
| 'copyResult'
| 'enableConcat'
| 'field-abstractTranslation'
| 'field-titleTranslation'
| 'itemPaneSection-fullHeight'
| 'itemPaneSection-header'
| 'itemPaneSection-openStandalone'
| 'itemPaneSection-sidenav'
| 'itemmenu-translateAbstract'
| 'itemmenu-translateTitle'
| 'pin-window'
| 'pref-about'
| 'pref-about-docs'
| 'pref-about-feedback'
| 'pref-about-version'
| 'pref-advanced'
| 'pref-advanced-disabledLanguages'
| 'pref-advanced-disabledLanguages-alert'
| 'pref-advanced-enableAutoDetectLanguage'
| 'pref-advanced-extraEngines'
| 'pref-advanced-reset'
| 'pref-advanced-reset-abstractTranslation'
| 'pref-advanced-reset-titleTranslation'
| 'pref-advanced-resultRegex'
| 'pref-advanced-splitChar'
| 'pref-advanced-stripEmptyLines'
| 'pref-audio-autoPlay'
| 'pref-audio-showPlayBtn'
| 'pref-basic-annotationTagContent'
| 'pref-basic-annotationTranslationInBody'
| 'pref-basic-annotationTranslationInComment'
| 'pref-basic-enableAnnotationFromSyncTranslation'
| 'pref-basic-enableAuto'
| 'pref-basic-enableAutoTagAnnotation'
| 'pref-basic-enableComment'
| 'pref-basic-enableHidePopupTextarea'
| 'pref-basic-enableNote'
| 'pref-basic-enableNoteReplaceMode'
| 'pref-basic-enablePopup'
| 'pref-general'
| 'pref-interface'
| 'pref-interface-enableConcatKey'
| 'pref-interface-enableMathRendering'
| 'pref-interface-fontSize'
| 'pref-interface-hideUnconfiguredServices'
| 'pref-interface-keepPopupSize'
| 'pref-interface-keepWindowTop'
| 'pref-interface-lineHeight'
| 'pref-interface-rawResultOrder'
| 'pref-interface-showItemBoxAbstractTranslation'
| 'pref-interface-showItemBoxTitleTranslation'
| 'pref-interface-showItemMenu'
| 'pref-interface-showItemMenuAbstractTranslation'
| 'pref-interface-showItemMenuTitleTranslation'
| 'pref-interface-showSidebarConcat'
| 'pref-interface-showSidebarCopy'
| 'pref-interface-showSidebarEngine'
| 'pref-interface-showSidebarLanguage'
| 'pref-interface-showSidebarRaw'
| 'pref-interface-showSidebarSettings'
| 'pref-service'
| 'pref-service-attachPaperContext'
| 'pref-service-hint'
| 'pref-service-langfrom'
| 'pref-service-langto'
| 'pref-service-manageKeys'
| 'pref-service-manageKeys-hint'
| 'pref-service-renameServices'
| 'pref-service-renameServices-hint'
| 'pref-service-sentenceServices'
| 'pref-service-sentenceServicesSecret'
| 'pref-service-useWordService'
| 'pref-service-wordServices'
| 'pref-service-wordServicesSecret'
| 'pref-title'
| 'readerpopup-addToNote-label'
| 'readerpopup-translate-label'
| 'remove-source'
| 'selection'
| 'service-aliyun'
| 'service-aliyun-dialog-action'
| 'service-aliyun-dialog-scene'
| 'service-azuregpt'
| 'service-azuregpt-dialog-apiVersion'
| 'service-azuregpt-dialog-custom-request'
| 'service-azuregpt-dialog-endPoint'
| 'service-azuregpt-dialog-model'
| 'service-azuregpt-dialog-prompt'
| 'service-azuregpt-dialog-stream'
| 'service-azuregpt-dialog-temperature'
| 'service-baidu'
| 'service-baidufield'
| 'service-bing'
| 'service-bingdict'
| 'service-caiyun'
| 'service-cambridgedict'
| 'service-chatgpt'
| 'service-chatgpt-dialog-custom-request'
| 'service-chatgpt-dialog-endPoint'
| 'service-chatgpt-dialog-model'
| 'service-chatgpt-dialog-prompt'
| 'service-chatgpt-dialog-stream'
| 'service-chatgpt-dialog-temperature'
| 'service-claude'
| 'service-claude-dialog-endPoint'
| 'service-claude-dialog-maxTokens'
| 'service-claude-dialog-model'
| 'service-claude-dialog-prompt'
| 'service-claude-dialog-stream'
| 'service-claude-dialog-temperature'
| 'service-cnki'
| 'service-cnki-dialog-regex'
| 'service-cnki-dialog-split'
| 'service-cnki-settings'
| 'service-collinsdict'
| 'service-customgpt1'
| 'service-customgpt2'
| 'service-customgpt3'
| 'service-deeplcustom'
| 'service-deeplcustom-dialog-endPoint'
| 'service-deeplfree'
| 'service-deeplpro'
| 'service-deeplx'
| 'service-deeplx-dialog-endPoint'
| 'service-dialog-close'
| 'service-dialog-config'
| 'service-dialog-custom-request-add-param'
| 'service-dialog-custom-request-description'
| 'service-dialog-custom-request-title'
| 'service-dialog-help'
| 'service-dialog-save'
| 'service-dialog-title'
| 'service-errorPrefix'
| 'service-freedictionaryapi'
| 'service-gemini'
| 'service-gemini-dialog-endPoint'
| 'service-gemini-dialog-prompt'
| 'service-gemini-dialog-stream'
| 'service-google'
| 'service-googleapi'
| 'service-haici'
| 'service-haicidict'
| 'service-huoshan'
| 'service-huoshanweb'
| 'service-libretranslate'
| 'service-libretranslate-dialog-endPoint'
| 'service-manageKeys-close'
| 'service-manageKeys-head'
| 'service-manageKeys-save'
| 'service-manageKeys-title'
| 'service-microsoft'
| 'service-mtranserver'
| 'service-mtranserver-dialog-endPoint'
| 'service-mtranserver-dialog-versionlabel'
| 'service-niutranspro'
| 'service-niutranspro-dialog-dictLib'
| 'service-niutranspro-dialog-endpoint'
| 'service-niutranspro-dialog-forget'
| 'service-niutranspro-dialog-memoryLib'
| 'service-niutranspro-dialog-password'
| 'service-niutranspro-dialog-refresh'
| 'service-niutranspro-dialog-signin'
| 'service-niutranspro-dialog-signout'
| 'service-niutranspro-dialog-signup'
| 'service-niutranspro-dialog-tip0'
| 'service-niutranspro-dialog-tip1'
| 'service-niutranspro-dialog-tip2'
| 'service-niutranspro-dialog-username'
| 'service-nllb'
| 'service-nllb-dialog-apiendpoint'
| 'service-nllb-dialog-apilabel'
| 'service-nllb-dialog-apistream'
| 'service-nllb-dialog-model'
| 'service-nllb-dialog-serveendpoint'
| 'service-nllb-dialog-servelabel'
| 'service-openl'
| 'service-pot'
| 'service-pot-dialog-port'
| 'service-qwenmt'
| 'service-qwenmt-dialog-domains'
| 'service-qwenmt-dialog-endPoint'
| 'service-qwenmt-dialog-model'
| 'service-renameServices-close'
| 'service-renameServices-head'
| 'service-renameServices-hint'
| 'service-renameServices-save'
| 'service-renameServices-title'
| 'service-tencent'
| 'service-tencent-dialog-projectid'
| 'service-tencent-dialog-region'
| 'service-tencent-dialog-secretid'
| 'service-tencent-dialog-secretkey'
| 'service-tencent-dialog-sentrepoid'
| 'service-tencent-dialog-termrepoid'
| 'service-tencenttransmart'
| 'service-webliodict'
| 'service-xftrans'
| 'service-xftrans-dialog-engine'
| 'service-youdao'
| 'service-youdaodict'
| 'service-youdaozhiyun'
| 'service-youdaozhiyun-dialog-domain'
| 'service-youdaozhiyunllm'
| 'service-youdaozhiyunllm-dialog-lite'
| 'service-youdaozhiyunllm-dialog-model'
| 'service-youdaozhiyunllm-dialog-pro'
| 'service-youdaozhiyunllm-dialog-prompt'
| 'service-youdaozhiyunllm-dialog-stream'
| 'sideBarIcon-title'
| 'status-translating'
| 'swapLanguage'
| 'translate';
================================================
FILE: typings/prefs.d.ts
================================================
// Generated by zotero-plugin-scaffold
/* prettier-ignore */
/* eslint-disable */
// @ts-nocheck
// prettier-ignore
declare namespace _ZoteroTypes {
interface Prefs {
PluginPrefsMap: {
"enableAuto": boolean;
"enableDict": boolean;
"attachPaperContext": boolean;
"enablePopup": boolean;
"enableComment": boolean;
"enableAnnotationFromSyncTranslation": boolean;
"enableAutoTagAnnotation": boolean;
"annotationTagContent": string;
"annotationTranslationPosition": string;
"enableNote": boolean;
"enableNoteReplaceMode": boolean;
"translateSource": string;
"dictSource": string;
"sourceLanguage": string;
"targetLanguage": string;
"fontSize": string;
"lineHeight": string;
"splitChar": string;
"resultRegex": string;
"rawResultOrder": boolean;
"showItemMenuTitleTranslation": boolean;
"showItemMenuAbstractTranslation": boolean;
"showSidebarEngine": boolean;
"hideUnconfiguredServices": boolean;
"showSidebarSettings": boolean;
"showSidebarConcat": boolean;
"enableConcatKey": boolean;
"showSidebarLanguage": boolean;
"showSidebarRaw": boolean;
"showSidebarCopy": boolean;
"customRawRatio": string;
"customResultRatio": string;
"showItemBoxTitleTranslation": boolean;
"showItemBoxAbstractTranslation": boolean;
"keepWindowTop": boolean;
"keepPopupSize": boolean;
"popupWidth": number;
"popupHeight": number;
"niutransEndpoint": string;
"niutransUsername": string;
"niutransPassword": string;
"niutransDictNo": string;
"niutransMemoryNo": string;
"niutransDictLibList": string;
"niutransMemoryLibList": string;
"autoPlay": boolean;
"showPlayBtn": boolean;
"enableAutoDetectLanguage": boolean;
"disabledLanguages": string;
"extraEngines": string;
"titleColumnMode": string;
"chatGPT.endPoint": string;
"chatGPT.model": string;
"chatGPT.temperature": string;
"chatGPT.prompt": string;
"chatGPT.stream": boolean;
"chatGPT.customParams": string;
"azureGPT.endPoint": string;
"azureGPT.model": string;
"azureGPT.apiVersion": string;
"azureGPT.temperature": string;
"azureGPT.prompt": string;
"azureGPT.stream": boolean;
"azureGPT.customParams": string;
"gemini.endPoint": string;
"gemini.prompt": string;
"gemini.stream": boolean;
"cnkiRegex": string;
"cnkiSplitSecond": number;
"cnkiUseSplit": boolean;
"deeplx.endpoint": string;
"deeplcustom.endpoint": string;
"pot.port": number;
"qwenmt.endPoint": string;
"qwenmt.model": string;
"qwenmt.domains": string;
"aliyun.action": string;
"aliyun.scene": string;
"enableMathRendering": boolean;
"stripEmptyLines": boolean;
"libretranslate.endpoint": string;
"mtranserver.endpoint": string;
"mtranserver.versionlabel": boolean;
"claude.stream": boolean;
"claude.endPoint": string;
"claude.model": string;
"claude.temperature": string;
"claude.prompt": string;
"claude.maxTokens": string;
"xftrans.engine": string;
"tencent.region": string;
"tencent.projectId": string;
"youdaozhiyun.domain": string;
"youdaozhiyunllm.model": string;
"youdaozhiyunllm.stream": boolean;
"nllb.model": string;
"nllb.apiendpoint": string;
"nllb.apistream": boolean;
"nllb.serveendpoint": string;
};
}
}
================================================
FILE: update-beta.json
================================================
{
"addons": {
"zoteropdftranslate@euclpts.com": {
"updates": [
{
"version": "1.0.25",
"update_link": "https://github.com/windingwind/zotero-pdf-translate/releases/download/v1.0.25/zotero-pdf-translate.xpi",
"applications": {
"gecko": {
"strict_min_version": "60.0"
}
}
},
{
"version": "1.1.0-beta.42",
"update_link": "https://github.com/windingwind/zotero-pdf-translate/releases/download/v1.1.0-beta.42/translate-for-zotero.xpi",
"applications": {
"zotero": {
"strict_min_version": "7.0.0-beta.70"
}
}
}
]
}
}
}
================================================
FILE: update.json
================================================
{
"addons": {
"zoteropdftranslate@euclpts.com": {
"updates": [
{
"version": "2.0.0",
"update_link": "https://github.com/windingwind/zotero-pdf-translate/releases/download/v2.0.0/translate-for-zotero.xpi",
"update_hash": "sha512:86dda24e8547cd9d5cd7386f8662e6444fe2cda0b5780d63b79072e623df4e5c44fdd5bae4ecaf4c7c2babb6c3a8e6b3623250586fd13429304edc1f2deb0e01",
"applications": {
"zotero": {
"strict_min_version": "7.0.0-beta.70",
"strict_max_version": "7.0.*"
}
}
}
]
}
}
}
================================================
FILE: update.rdf
================================================
{
"addons": {
"zoteropdftranslate@euclpts.com": {
"updates": [
{
"version": "2.0.0",
"update_link": "https://github.com/windingwind/zotero-pdf-translate/releases/download/v2.0.0/translate-for-zotero.xpi",
"update_hash": "sha512:86dda24e8547cd9d5cd7386f8662e6444fe2cda0b5780d63b79072e623df4e5c44fdd5bae4ecaf4c7c2babb6c3a8e6b3623250586fd13429304edc1f2deb0e01",
"applications": {
"zotero": {
"strict_min_version": "7.0.0-beta.70",
"strict_max_version": "7.0.*"
}
}
}
]
}
}
}
================================================
FILE: zotero-plugin.config.ts
================================================
import { defineConfig } from "zotero-plugin-scaffold";
import pkg from "./package.json";
import { copyFileSync } from "fs";
export default defineConfig({
source: ["src", "addon"],
dist: "build",
name: pkg.config.addonName,
id: pkg.config.addonID,
namespace: pkg.config.addonRef,
updateURL: `https://github.com/{{owner}}/{{repo}}/releases/download/release/${
pkg.version.includes("-") ? "update-beta.json" : "update.json"
}`,
xpiDownloadLink:
"https://github.com/{{owner}}/{{repo}}/releases/download/v{{version}}/{{xpiName}}.xpi",
server: {
asProxy: false,
},
build: {
assets: ["addon/**/*.*"],
define: {
...pkg.config,
author: pkg.author,
description: pkg.description,
homepage: pkg.homepage,
buildVersion: pkg.version,
buildTime: "{{buildTime}}",
},
esbuildOptions: [
{
entryPoints: [
{ in: "src/index.ts", out: pkg.config.addonRef },
{ in: "src/extras/*.*", out: "" },
],
define: {
__env__: `"${process.env.NODE_ENV}"`,
},
bundle: true,
target: "firefox115",
outdir: "build/addon/chrome/content/scripts",
},
],
// If you want to checkout update.json into the repository, uncomment the following lines:
// makeUpdateJson: {
// hash: false,
// },
// hooks: {
// "build:makeUpdateJSON": (ctx) => {
// copyFileSync("build/update.json", "update.json");
// copyFileSync("build/update-beta.json", "update-beta.json");
// },
// },
},
// release: {
// bumpp: {
// execute: "npm run build",
// },
// },
// If you need to see a more detailed build log, uncomment the following line:
// logLevel: "trace",
});
"); } export function renderMathInText(doc: Document, text: string): string { if (!text) return ""; if (!containsMath(text)) return escapeHtml(doc, text); let result = ""; let lastIndex = 0; let match: RegExpExecArray | null; while ((match = MATH_REGEX.exec(text)) !== null) { const [ full, dispPrefix, dispDollar, dispBracket, inlinePrefix, inlineDollar, inlineParen, ] = match; const prefixLen = dispPrefix || inlinePrefix ? 1 : 0; const plainEnd = match.index + prefixLen; if (plainEnd > lastIndex) { result += escapeHtml(doc, text.slice(lastIndex, plainEnd)); } let displayMode = false; let latex = ""; if (typeof dispDollar !== "undefined") { displayMode = true; latex = String(dispDollar).trim(); } else if (typeof dispBracket !== "undefined") { displayMode = true; latex = String(dispBracket).trim(); } else if (typeof inlineDollar !== "undefined") { displayMode = false; latex = String(inlineDollar).trim(); } else if (typeof inlineParen !== "undefined") { displayMode = false; latex = String(inlineParen).trim(); } try { const rendered = katex.renderToString(latex, { ...DEFAULT_KATEX_OPTIONS, displayMode, }); result += rendered; } catch (e) { result += escapeHtml(doc, full.slice(prefixLen)); } lastIndex = match.index + full.length; } if (lastIndex < text.length) { result += escapeHtml(doc, text.slice(lastIndex)); } return result; } export function renderMathInElement(element: HTMLElement, text: string): void { if (!element) return; element.innerHTML = renderMathInText(element.ownerDocument, text); } ================================================ FILE: src/utils/prefs.ts ================================================ import { config } from "../../package.json"; export { getPref, setPref, clearPref, getPrefJSON, registerPrefObserver, unregisterPrefObserver, }; type KeysWithStringValue