251 lines
6.8 KiB
JavaScript
251 lines
6.8 KiB
JavaScript
import { getCookie } from "./cookie";
|
|
import { get } from "./request";
|
|
import { nullOrEmpty } from "./strings";
|
|
|
|
/** @typedef {import('../types').LanguageResource} LanguageResource */
|
|
|
|
const g = typeof window !== 'undefined' ? window : self;
|
|
|
|
/** @type {LanguageResource} */
|
|
let cache;
|
|
|
|
function getCurrentLgId() {
|
|
let lgid;
|
|
if (typeof g.consts !== 'undefined') {
|
|
lgid = getCookie(g.consts.cookie?.lang);
|
|
if (nullOrEmpty(lgid)) {
|
|
lgid = g.consts.user?.language;
|
|
}
|
|
}
|
|
if (nullOrEmpty(lgid)) {
|
|
lgid = getCookie('lgid');
|
|
}
|
|
if (nullOrEmpty(lgid)) {
|
|
lgid = navigator.language || 'en-us';
|
|
}
|
|
lgid = lgid.toLowerCase().replace(/-/g, '_');
|
|
if (nullOrEmpty(lgid)) {
|
|
lgid = 'en';
|
|
}
|
|
switch (lgid) {
|
|
case 'en_au':
|
|
case 'en_ca':
|
|
case 'fr_ca':
|
|
case 'zh_cn':
|
|
return lgid;
|
|
}
|
|
const lang = lgid.split('_')[0];
|
|
switch (lang) {
|
|
case 'en':
|
|
case 'es':
|
|
case 'fr':
|
|
case 'pt':
|
|
return lang;
|
|
case 'zh':
|
|
return 'zh_cn';
|
|
}
|
|
return 'en';
|
|
}
|
|
|
|
/**
|
|
* @private
|
|
* @param {"en" | "en_au" | "en_ca" | "fr_ca" | "zh_cn" | "es" | "fr" | "pt"} lgid
|
|
* @returns {string}
|
|
*/
|
|
function getStorageKey(lgid) {
|
|
if (typeof g.consts !== 'undefined') {
|
|
return (g.consts.prefix || '') + `res_${lgid}`;
|
|
}
|
|
return `res_${lgid}`;
|
|
}
|
|
|
|
/**
|
|
* @private
|
|
* @param {string} [template]
|
|
* @returns {Promise<LanguageResource>}
|
|
*/
|
|
async function doRefreshLgres(template = '') {
|
|
const lgid = getCurrentLgId();
|
|
const url = template.length > 0 ? template.replace('{lgid}', lgid) : `language/${lgid}`;
|
|
const r = await get(url);
|
|
const dict = await r.json();
|
|
localStorage.setItem(getStorageKey(lgid), JSON.stringify(dict));
|
|
return dict;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param {string} [template]
|
|
* @param {LanguageResource | null} [lgres]
|
|
* @returns {Promise<LanguageResource>}
|
|
*/
|
|
async function refreshLgres(template, lgres) {
|
|
if (lgres == null || typeof g.consts === 'undefined') {
|
|
lgres = await doRefreshLgres(template);
|
|
}
|
|
const ver = Number(g.consts?.resver);
|
|
const currentVer = Number(lgres.ver);
|
|
if (isNaN(currentVer) || isNaN(ver) || ver > currentVer) {
|
|
console.log(`found new language res version: ${lgres.ver} => ${g.consts?.resver}`);
|
|
lgres = await doRefreshLgres(template);
|
|
}
|
|
Object.defineProperty(lgres, 'r', {
|
|
writable: false,
|
|
configurable: false,
|
|
enumerable: false,
|
|
value: function (/** @type {string} */ key, /** @type {string | undefined} */ defaultValue) {
|
|
return getLanguage(this, key, defaultValue);
|
|
}
|
|
});
|
|
cache = lgres;
|
|
return lgres;
|
|
}
|
|
|
|
/**
|
|
* @private
|
|
* @param {LanguageResource} lgres
|
|
* @param {string} [key]
|
|
* @param {string | null} [defaultValue]
|
|
* @returns {string}
|
|
*/
|
|
function getLanguage(lgres, key, defaultValue) {
|
|
if (key == null) {
|
|
return '';
|
|
}
|
|
let value = lgres[key];
|
|
if (value != null && typeof value !== 'string') {
|
|
value = String(value);
|
|
}
|
|
return value ?? defaultValue ?? '';
|
|
}
|
|
|
|
/**
|
|
* @private
|
|
* @template {keyof HTMLElementTagNameMap} K
|
|
* @param {Element} element
|
|
* @param {K} tagName
|
|
* @returns {element is HTMLElementTagNameMap[K]}
|
|
*/
|
|
export function isTag(element, tagName) {
|
|
return element.tagName.toLowerCase() === tagName;
|
|
}
|
|
|
|
/**
|
|
* @private
|
|
* @param {HTMLElement} dom
|
|
* @param {LanguageResource} result
|
|
*/
|
|
function applyLanguage(dom, result) {
|
|
for (let text of dom.querySelectorAll('[data-lgid]')) {
|
|
if (!(text instanceof HTMLElement)) {
|
|
continue;
|
|
}
|
|
const key = text.dataset.lgid;
|
|
if (isTag(text, 'input')) {
|
|
text.value = getLanguage(result, key, text.value);
|
|
} else {
|
|
text.innerText = getLanguage(result, key, text.innerText);
|
|
}
|
|
// delete text.dataset.lgid;
|
|
text.dataset.lgid = '';
|
|
}
|
|
for (let title of dom.querySelectorAll('[data-title-lgid]')) {
|
|
if (!(title instanceof HTMLElement)) {
|
|
continue;
|
|
}
|
|
const key = title.dataset.titleLgid;
|
|
title.setAttribute('title', getLanguage(result, key, title.getAttribute('title')));
|
|
// delete title.dataset.titleLgid;
|
|
title.dataset.titleLgid = '';
|
|
}
|
|
for (let holder of dom.querySelectorAll('[data-placeholder-lgid]')) {
|
|
if (!(holder instanceof HTMLElement)) {
|
|
continue;
|
|
}
|
|
const key = holder.dataset.placeholderLgid;
|
|
holder.setAttribute('placeholder', getLanguage(result, key, holder.getAttribute('placeholder')));
|
|
// delete holder.dataset.placeholderLgid;
|
|
holder.dataset.placeholderLgid = '';
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @returns {Promise<void>}
|
|
*/
|
|
export function domLoad() {
|
|
if (document.readyState === 'loading') {
|
|
return new Promise((resolve, reject) => {
|
|
/** @type {number | undefined} */
|
|
let tid = setTimeout(() => reject('timeout'), 30000);
|
|
document.addEventListener('DOMContentLoaded', () => {
|
|
clearTimeout(tid);
|
|
tid = void 0;
|
|
resolve();
|
|
});
|
|
});
|
|
}
|
|
return Promise.resolve();
|
|
}
|
|
|
|
/**
|
|
* @typedef LgresOptions
|
|
* @property {string} [template]
|
|
* @property {(result: LanguageResource) => void} [callback]
|
|
*/
|
|
|
|
/**
|
|
* @param {HTMLElement} dom
|
|
* @param {LgresOptions} options
|
|
* @returns
|
|
*/
|
|
export async function init(dom = document.body, options = {}) {
|
|
const lgid = getCurrentLgId();
|
|
const json = localStorage.getItem(getStorageKey(lgid));
|
|
let result;
|
|
if (json != null) {
|
|
try {
|
|
const lgres = JSON.parse(json);
|
|
result = await refreshLgres(options.template, lgres);
|
|
} catch (e) {
|
|
console.error('error while parsing lgres, try refresh ...', e);
|
|
result = await refreshLgres(options.template);
|
|
}
|
|
} else {
|
|
result = await refreshLgres(options.template);
|
|
}
|
|
|
|
try {
|
|
await domLoad();
|
|
if (typeof options.callback === 'function') {
|
|
options.callback(result);
|
|
}
|
|
applyLanguage(dom, result);
|
|
return result;
|
|
} catch (err) {
|
|
console.error('error while loading language res ...', err);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param {string} key
|
|
* @param {string | null} [defaultValue]
|
|
* @returns {string}
|
|
*/
|
|
export function r(key, defaultValue) {
|
|
if (cache != null) {
|
|
return getLanguage(cache, key, defaultValue);
|
|
}
|
|
return defaultValue ?? '';
|
|
}
|
|
|
|
export const lang = {
|
|
get current() {
|
|
return getCurrentLgId();
|
|
},
|
|
get unknownError() {
|
|
return r('unknownError', 'An unknown error occurred, please contact the administrator.');
|
|
},
|
|
get savedSuccessfully() {
|
|
return r('savedSuccessfully', 'Saved successfully.');
|
|
}
|
|
} |