476 lines
37 KiB
JavaScript
476 lines
37 KiB
JavaScript
// Language packs as content packs (docs/I18N.md "Adding a language", docs/PACKS.md): discovery (server/packs.js — the
|
|
// language folders and the pack folders, a pack dropped in shows without a restart; GET /packs/index.json and the file
|
|
// allowlist), the manifest (shared/packs.js: types, app ranges), the fallback chain (shared/i18n.js: base, fallback, the
|
|
// Chinese msgid), placeholder validation, plural categories (Intl.PluralRules: English unchanged, Russian named forms),
|
|
// the per-text fallback of game texts (shared/i18nData.js onto, data.js chains), the client loader and menu
|
|
// (ui/lang.js), the translator tools (tools/i18n.mjs template / check, tools/packs.mjs index), the machine-translation
|
|
// mark (`_meta.machineTranslated`: the manifest, the index, the client's registry, the 设置 note), and that the Chinese
|
|
// and English output of t() is what it was before packs. The example packs live only here, in temporary folders ('qaa'
|
|
// … 'qtz' are the ISO 639 codes reserved for local use).
|
|
|
|
import { test, afterEach } from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import fs from 'node:fs';
|
|
import os from 'node:os';
|
|
import path from 'node:path';
|
|
import { spawnSync } from 'node:child_process';
|
|
import http from 'node:http';
|
|
import { fileURLToPath } from 'node:url';
|
|
import { APP_VERSION } from '../shared/constants.js';
|
|
import {
|
|
t, tc, tParts, setLang, getLang, addMessages, setMessages, setI18nWarn, registerLangs, getLangs, langChain, langInfo, normalizeLang,
|
|
checkTranslation, parsePluralForms, pluralCategory, format,
|
|
} from '../shared/i18n.js';
|
|
import { canonicalLang, computeChain, scriptOf, langFields, packMeta } from '../shared/i18nPacks.js';
|
|
import { normalizeManifest, appVersionMatches, isVersionRange, readPackIndex, langMetaOf, PACK_TYPES, isPackPath, packIndexEntry } from '../shared/packs.js';
|
|
import { buildRecordOverlay, applyFileOverlay, applyRecordOverlay } from '../shared/i18nData.js';
|
|
import { buildOverlay, LANG_SOURCES } from '../tools/build-i18n.mjs';
|
|
import { scanPacks, createPackRegistry, packIndexOf } from '../server/packs.js';
|
|
import { createDataStore } from '../public/js/data.js';
|
|
import { checkPack, packTemplate } from '../tools/i18n.mjs';
|
|
import { writePackIndex } from '../tools/packs.mjs';
|
|
|
|
const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
|
|
const EN = JSON.parse(fs.readFileSync(path.join(ROOT, 'public/i18n/en.json'), 'utf8'));
|
|
const ZH_TW = JSON.parse(fs.readFileSync(path.join(ROOT, 'public/i18n/zh-TW.json'), 'utf8'));
|
|
/** The 设置 note of a pack marked as machine translation (ui/lang.js machineTranslationNote). */
|
|
const MT_NOTE = '当前语言的界面文字为机器翻译，可能不够准确，欢迎在 GitHub 上指正。';
|
|
|
|
afterEach(() => {
|
|
setLang('zh');
|
|
setI18nWarn(null);
|
|
for (const l of ['en', 'qaa', 'qab', 'pt', 'pt-BR', 'zh-TW', 'ru']) setMessages(l, {});
|
|
});
|
|
|
|
const tmpdir = (tag) => fs.mkdtempSync(path.join(os.tmpdir(), `sp-packs-${tag}-`));
|
|
const put = (dir, rel, body) => {
|
|
fs.mkdirSync(path.join(dir, path.dirname(rel)), { recursive: true });
|
|
fs.writeFileSync(path.join(dir, rel), typeof body === 'string' ? body : JSON.stringify(body, null, 2));
|
|
};
|
|
|
|
/** A checkout-shaped temporary root with example packs of both layouts and a few broken ones. */
|
|
function exampleRoot() {
|
|
const dir = tmpdir('root');
|
|
put(dir, 'public/i18n/en.json', { _meta: { name: 'English', complete: true }, 开始: 'Start', 设置: 'Settings' });
|
|
put(dir, 'public/i18n/qaa.json', { _meta: { name: 'Qaa-Sprache', englishName: 'Test language A', fallback: ['en'], app: '>=0.2.0', authors: 'Tester' }, 开始: 'Los' });
|
|
put(dir, 'data/i18n/qaa.json', { version: 1, lang: 'qaa', names: {}, files: {} });
|
|
put(dir, 'public/i18n/zh.json', { 开始: '开始' }); // the source language is never a pack
|
|
put(dir, 'public/i18n/QAC.json', { 开始: 'x' }); // not in its usual case
|
|
put(dir, 'public/i18n/qad.json', '{ not json');
|
|
put(dir, 'packs/qab/pack.json', { type: 'lang', lang: 'qab', name: 'Qab', version: '1.0.0', app: '0.1.x', files: { ui: 'ui.json', data: 'texts/game.json' } });
|
|
put(dir, 'packs/qab/ui.json', { 开始: 'Qab-Start', 设置: 'Qab-Settings' });
|
|
put(dir, 'packs/qab/texts/game.json', { version: 1, lang: 'qab', names: { 阿米娅: 'Qab-Amiya' }, files: {} });
|
|
put(dir, 'packs/qab/notes.html', '<script>alert(1)</script>');
|
|
put(dir, 'packs/art/pack.json', { type: 'assets', name: 'HD art' });
|
|
put(dir, 'packs/dup/pack.json', { type: 'lang', lang: 'qaa', files: { ui: 'ui.json' } });
|
|
put(dir, 'packs/dup/ui.json', { 开始: 'dup' });
|
|
put(dir, 'packs/broken/pack.json', { type: 'lang', files: { ui: '../escape.json' } });
|
|
put(dir, 'packs/nomanifest/ui.json', { 开始: 'x' });
|
|
return dir;
|
|
}
|
|
const dirsOf = (root) => ({ publicDir: path.join(root, 'public'), dataDir: path.join(root, 'data'), packsDir: path.join(root, 'packs') });
|
|
|
|
test('discovery: single-file language packs and folder packs, one registry; broken, planned and duplicate packs are skipped with a reason', () => {
|
|
const root = exampleRoot();
|
|
try {
|
|
const scan = scanPacks(dirsOf(root), { app: '0.2.0' });
|
|
assert.deepEqual(scan.packs.map((p) => [p.id, p.type, p.layout, p.manifest.lang]), [['en', 'lang', 'file', 'en'], ['qaa', 'lang', 'file', 'qaa'], ['qab', 'lang', 'folder', 'qab']]);
|
|
const why = Object.fromEntries(scan.skipped.map((s) => [s.where, s.problems.join('; ')]));
|
|
assert.match(why['public/i18n/zh.json'], /source language/);
|
|
assert.match(why['public/i18n/QAC.json'], /not a language code in its usual case/);
|
|
assert.match(why['public/i18n/qad.json'], /not valid JSON/);
|
|
assert.match(why['packs/art/'], /type "assets" is planned/);
|
|
assert.match(why['packs/dup/'], /language qaa is already provided by public\/i18n\/qaa\.json/);
|
|
assert.match(why['packs/broken/'], /no "lang".*"files\.ui": "\.\.\/escape\.json" is not a path inside the pack folder/);
|
|
assert.match(why['packs/nomanifest/'], /no pack\.json/);
|
|
assert.ok(scan.warnings.some((w) => w.where === 'packs/qab/' && /made for app 0\.1\.x; this is 0\.2\.0/.test(w.warning)));
|
|
const index = packIndexOf(scan.packs, { app: '0.2.0' });
|
|
const qaa = index.packs.find((p) => p.id === 'qaa');
|
|
assert.deepEqual(qaa, {
|
|
id: 'qaa', type: 'lang', name: 'Qaa-Sprache', englishName: 'Test language A', app: '>=0.2.0', compatible: true, authors: ['Tester'],
|
|
lang: 'qaa', fallback: ['en'], strings: 1, files: { ui: '/i18n/qaa.json', data: '/data/i18n/qaa.json' },
|
|
});
|
|
const qab = index.packs.find((p) => p.id === 'qab');
|
|
assert.equal(qab.compatible, false, 'outside its app range: listed, flagged');
|
|
assert.deepEqual(qab.files, { ui: '/packs/qab/ui.json', data: '/packs/qab/texts/game.json' });
|
|
assert.equal(index.packs.find((p) => p.id === 'en').files.data, undefined, 'no data/i18n/en.json in this root');
|
|
} finally { fs.rmSync(root, { recursive: true, force: true }); }
|
|
});
|
|
|
|
test('discovery: a pack dropped into the folder shows on the next look (no restart), a removed one leaves; only named files are servable', () => {
|
|
const root = exampleRoot();
|
|
try {
|
|
const reg = createPackRegistry(dirsOf(root), { recheckMs: 0 });
|
|
assert.ok(!reg.index().packs.some((p) => p.id === 'qae'));
|
|
put(root, 'public/i18n/qae.json', { _meta: { name: 'Neu' }, 开始: 'Neu-Start' });
|
|
assert.ok(reg.index().packs.some((p) => p.id === 'qae' && p.name === 'Neu'), 'appears without a restart');
|
|
put(root, 'packs/qaf/pack.json', { type: 'lang', lang: 'qaf', files: { ui: 'ui.json' } });
|
|
put(root, 'packs/qaf/ui.json', { 开始: 'F' });
|
|
assert.ok(reg.index().packs.some((p) => p.id === 'qaf' && p.files.ui === '/packs/qaf/ui.json'));
|
|
fs.rmSync(path.join(root, 'public/i18n/qae.json'));
|
|
assert.ok(!reg.index().packs.some((p) => p.id === 'qae'), 'removed');
|
|
assert.equal(reg.servable('qab', 'ui.json'), path.join(root, 'packs/qab/ui.json'));
|
|
assert.equal(reg.servable('qab', 'texts/game.json'), path.join(root, 'packs/qab/texts/game.json'));
|
|
assert.equal(reg.servable('qab', 'notes.html'), null, 'a file the manifest does not name');
|
|
assert.equal(reg.servable('qab', 'pack.json'), null);
|
|
assert.equal(reg.servable('art', 'pack.json'), null, 'a planned type is never served');
|
|
assert.equal(reg.servable('qaa', 'qaa.json'), null, 'a single-file pack is served by the language folders');
|
|
} finally { fs.rmSync(root, { recursive: true, force: true }); }
|
|
});
|
|
|
|
test('the server: GET /packs/index.json lists the packs live, GET /packs/<id>/<file> serves only what a manifest names', async () => {
|
|
const root = exampleRoot();
|
|
const { startServer } = await import('../server/index.js');
|
|
const srv = await startServer({ port: 0, host: '127.0.0.1', quiet: true, publicDir: path.join(root, 'public'), packsDir: path.join(root, 'packs') });
|
|
try {
|
|
const get = (u) => fetch(srv.url + u);
|
|
const res = await get('/packs/index.json');
|
|
assert.equal(res.status, 200);
|
|
assert.equal(res.headers.get('cache-control'), 'no-store');
|
|
const body = await res.json();
|
|
assert.equal(body.version, 1);
|
|
assert.deepEqual(readPackIndex(body, 'lang').map((p) => p.id), ['en', 'qaa', 'qab']);
|
|
assert.equal((await get('/packs/qab/ui.json')).status, 200);
|
|
assert.deepEqual(await (await get('/packs/qab/texts/game.json')).json(), { version: 1, lang: 'qab', names: { 阿米娅: 'Qab-Amiya' }, files: {} });
|
|
for (const u of ['/packs/qab/notes.html', '/packs/qab/pack.json', '/packs/art/pack.json', '/packs/qab/', '/packs/nope/ui.json']) {
|
|
assert.equal((await get(u)).status, 404, u);
|
|
}
|
|
// a raw path (fetch would normalize the dots away)
|
|
const raw = await new Promise((resolve, reject) => {
|
|
http.get({ host: '127.0.0.1', port: srv.port, path: '/packs/qab/../qab/ui.json' }, (r) => { r.resume(); resolve(r.statusCode); }).on('error', reject);
|
|
});
|
|
assert.equal(raw, 404);
|
|
assert.equal((await get('/i18n/qaa.json')).status, 200, 'a single-file pack: the language folder');
|
|
put(root, 'public/i18n/qag.json', { 开始: 'G' });
|
|
await new Promise((r) => setTimeout(r, 1100)); // the registry looks again after a second
|
|
assert.ok((await (await get('/packs/index.json')).json()).packs.some((p) => p.id === 'qag'), 'a dropped pack shows on the next request');
|
|
} finally {
|
|
await srv.close();
|
|
fs.rmSync(root, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
test('manifest: common fields, type fields, app ranges; English is a pack like any other', () => {
|
|
assert.deepEqual(Object.entries(PACK_TYPES).map(([k, v]) => [k, v.status]), [['lang', 'supported'], ['assets', 'planned'], ['data', 'planned']]);
|
|
for (const [range, v, ok] of [['>=0.2.0', '0.2.0-dev', true], ['>=0.2.0', '0.1.4', false], ['0.2.x', '0.2.7', true], ['0.2.x', '0.3.0', false],
|
|
['^0.2.1', '0.2.9', true], ['^0.2.1', '0.3.0', false], ['^1.2.0', '1.9.0', true], ['~0.2.1', '0.2.0', false], ['>=0.2.0 <0.3.0', '0.2.5', true],
|
|
['>=0.2.0 <0.3.0', '0.3.0', false], ['0.1.x || 0.2.x', '0.2.0', true], ['*', '9.9.9', true], ['', '0.0.1', true], ['0.2.0', '0.2.1', false]]) {
|
|
assert.equal(appVersionMatches(range, v), ok, `${range} ∋ ${v}`);
|
|
}
|
|
assert.equal(isVersionRange('soon'), false);
|
|
assert.equal(appVersionMatches('soon', '0.2.0'), true, 'an unreadable range never blocks');
|
|
const { manifest, problems, warnings } = normalizeManifest({ type: 'lang', lang: 'pt_br', id: 'other', name: 'Português', fallback: ['pt', 'zh', 'en'], base: 'zh', numberUnits: ['a'] }, { id: 'pt-BR', folder: true, app: '0.2.0' });
|
|
assert.deepEqual(problems, ['no "files.ui"']);
|
|
assert.equal(manifest, null);
|
|
assert.ok(warnings.some((w) => /"id": "other" is not "pt-BR"/.test(w)));
|
|
const ok = normalizeManifest({ type: 'lang', lang: 'pt-BR', fallback: ['pt', 'zh', 'en'], base: 'zh', files: { ui: 'ui.json', extra: 'x.json' } }, { id: 'pt-BR', folder: true, app: '0.2.0' });
|
|
assert.deepEqual([ok.manifest.lang, ok.manifest.base, ok.manifest.fallback, ok.manifest.files], ['pt-BR', null, ['pt', 'en'], { ui: 'ui.json' }], 'the source is never a base or a fallback');
|
|
assert.ok(ok.warnings.some((w) => /files\.extra/.test(w)));
|
|
assert.match(normalizeManifest({ type: 'theme' }, { id: 'x', folder: true }).problems.join(), /unknown type "theme"/);
|
|
assert.match(normalizeManifest({ type: 'assets' }, { id: 'x', type: 'lang', lang: 'qaa' }).problems.join(), /"type": "assets" where a lang pack belongs/);
|
|
assert.deepEqual(['ui.json', 'a/b.json', '../x.json', '/abs.json', 'a//b.json', '.hidden.json', 'a\\b.json'].map(isPackPath), [true, true, false, false, false, false, false]);
|
|
// English: a single-file pack whose `_meta` is the manifest — complete, no fallback, nothing special in the client
|
|
const en = normalizeManifest(EN._meta, { id: 'en', type: 'lang', lang: 'en', app: '0.2.0' });
|
|
assert.deepEqual(en.problems, []);
|
|
assert.deepEqual(en.warnings, []);
|
|
assert.deepEqual([en.manifest.name, en.manifest.complete, en.manifest.fallback, en.manifest.numberUnits], ['English', true, [], null]);
|
|
assert.ok(en.manifest.authors.some((a) => a.includes('@YuriRestia')), 'PR #70 credited');
|
|
});
|
|
|
|
test('manifest: machineTranslated — a boolean, carried into the index entry like complete and into the client\'s registry (from the index or the pack\'s own _meta); the shipped zh-TW pack has it', () => {
|
|
const ctx = { id: 'qam', type: 'lang', lang: 'qam', app: '0.2.0' };
|
|
const on = normalizeManifest({ name: 'Qam', machineTranslated: true }, ctx);
|
|
assert.deepEqual([on.problems, on.warnings, on.manifest.machineTranslated], [[], [], true]);
|
|
assert.equal(normalizeManifest({ name: 'Qam' }, ctx).manifest.machineTranslated, false, 'optional: absent reads as false');
|
|
const odd = normalizeManifest({ name: 'Qam', machineTranslated: 'yes' }, ctx);
|
|
assert.deepEqual(odd.problems, [], 'a warning, not a problem: the pack still loads');
|
|
assert.deepEqual(odd.warnings, ['"machineTranslated": "yes" is not true or false (read as false)']);
|
|
assert.equal(odd.manifest.machineTranslated, false);
|
|
assert.match(normalizeManifest({ machineTranslated: 1 }, ctx).warnings.join(), /"machineTranslated": 1 is not true or false/);
|
|
// the index entry: only when true (like complete)
|
|
const files = { ui: '/i18n/qam.json' };
|
|
assert.equal(packIndexEntry(on.manifest, { files, strings: 1 }).machineTranslated, true);
|
|
assert.equal(Object.hasOwn(packIndexEntry(odd.manifest, { files }), 'machineTranslated'), false);
|
|
// a checkout's packs → the index → readPackIndex / langMetaOf → the client's registry (langInfo)
|
|
const root = tmpdir('mt');
|
|
try {
|
|
put(root, 'public/i18n/qam.json', { _meta: { name: 'Qam', fallback: ['en'], machineTranslated: true }, 开始: 'Qam-Start' });
|
|
put(root, 'public/i18n/qan.json', { _meta: { name: 'Qan' }, 开始: 'Qan-Start' });
|
|
const index = packIndexOf(scanPacks(dirsOf(root), { app: '0.2.0' }).packs, { app: '0.2.0' });
|
|
const entries = readPackIndex(index, 'lang');
|
|
assert.deepEqual(entries.map((e) => [e.id, e.machineTranslated]), [['qam', true], ['qan', undefined]]);
|
|
registerLangs(entries.map(langMetaOf));
|
|
assert.deepEqual([langInfo('qam').machineTranslated, langInfo('qan').machineTranslated, langInfo('zh').machineTranslated], [true, false, false]);
|
|
} finally { fs.rmSync(root, { recursive: true, force: true }); }
|
|
// without an index the pack's own `_meta` registers it (addMessages → packMeta)
|
|
assert.equal(packMeta('qao', { _meta: { machineTranslated: true } }).machineTranslated, true);
|
|
addMessages('qao', { _meta: { name: 'Qao', machineTranslated: true }, 开始: 'Qao-Start' });
|
|
assert.equal(langInfo('qao').machineTranslated, true);
|
|
// the shipped Traditional Chinese pack: a machine conversion (OpenCC, the official TW terms, a manual pass), complete,
|
|
// no fallback (the Simplified Chinese msgids), the note in Traditional Chinese
|
|
const tw = normalizeManifest(ZH_TW._meta, { id: 'zh-TW', type: 'lang', lang: 'zh-TW', app: '0.2.0' });
|
|
assert.deepEqual([tw.problems, tw.warnings], [[], []]);
|
|
assert.deepEqual([tw.manifest.machineTranslated, tw.manifest.complete, tw.manifest.fallback, tw.manifest.numberUnits], [true, true, [], ['萬', '億']]);
|
|
assert.equal(ZH_TW[MT_NOTE], '目前語言的介面文字為機器翻譯，可能不夠準確，歡迎在 GitHub 上指正。');
|
|
assert.ok(EN[MT_NOTE], 'English has the note');
|
|
});
|
|
|
|
test('fallback chain: the pack, its base (pt-BR → pt; zh-TW none), its fallbacks, then the Chinese msgid; cycles end', () => {
|
|
const metas = { 'pt-BR': { fallback: ['en'] }, pt: { fallback: ['es'] }, es: {}, en: {}, 'zh-TW': { fallback: [] }, a: { fallback: ['b'] }, b: { fallback: ['a'] } };
|
|
const known = (c) => Object.hasOwn(metas, c);
|
|
assert.deepEqual(computeChain('pt-BR', (c) => metas[c], known), ['pt-BR', 'pt', 'es', 'en']);
|
|
assert.deepEqual(computeChain('zh-TW', (c) => metas[c], known), ['zh-TW'], 'zh is the source: no base');
|
|
assert.deepEqual(computeChain('pt-BR', (c) => metas[c], (c) => c !== 'pt' && known(c)), ['pt-BR', 'en'], 'a base without a pack is skipped');
|
|
assert.deepEqual(computeChain('a', (c) => metas[c], known), ['a', 'b']);
|
|
assert.deepEqual(computeChain('pt-BR', () => ({ base: null }), known), ['pt-BR'], 'base: null switches it off');
|
|
// through t() / tc(): a partial pack falls through per string
|
|
registerLangs([{ code: 'pt-BR', name: 'Português (Brasil)', fallback: ['en'] }, { code: 'pt', name: 'Português' }, { code: 'en', name: 'English' }]);
|
|
addMessages('en', { 开始: 'Start', 设置: 'Settings', 关闭: 'Close', 'toggle::关闭': 'Off', 准备: 'Ready' });
|
|
addMessages('pt', { 设置: 'Configurações', 关闭: 'Fechar' });
|
|
addMessages('pt-BR', { 开始: 'Iniciar' });
|
|
assert.deepEqual(langChain('pt-BR'), ['pt-BR', 'pt', 'en']);
|
|
assert.equal(normalizeLang('PT_br'), 'pt-BR');
|
|
assert.equal(normalizeLang('pt-PT'), 'pt', 'a region without a pack takes the language');
|
|
setLang('pt-BR');
|
|
assert.deepEqual([t('开始'), t('设置'), t('准备'), t('没有的')], ['Iniciar', 'Configurações', 'Ready', '没有的']);
|
|
assert.equal(tc('toggle', '关闭'), 'Fechar', 'per language: pt\'s plain msgid before en\'s context key');
|
|
setLang('en');
|
|
assert.equal(tc('toggle', '关闭'), 'Off');
|
|
assert.equal(t('开始'), 'Start');
|
|
});
|
|
|
|
test('placeholders: a translation that drops one or uses one the caller does not pass is skipped (reported once), the chain goes on', () => {
|
|
assert.deepEqual(checkTranslation('还剩 {n} 秒', '{n} seconds left'), { ok: true, problems: [], extras: [] });
|
|
assert.deepEqual(checkTranslation('还剩 {n} 秒', 'seconds left').problems, ['drops {n}']);
|
|
assert.deepEqual(checkTranslation('还剩 {n} 秒', '{n|second|seconds} left').problems, ['drops {n}'], 'a plural form does not show the number');
|
|
assert.deepEqual(checkTranslation('{n} 名', '{n} {count|unit|units}').extras, ['count']);
|
|
assert.deepEqual(checkTranslation('{n}', '{n} {n|a|b|c}').problems, ['malformed plural {n|a|b|c}']);
|
|
registerLangs([{ code: 'qaa', fallback: ['en'] }, { code: 'en' }]);
|
|
addMessages('en', { '还剩 {n} 秒': '{n} seconds left', '临时整备区 {n} 个单位待处理': 'Bench: {n} {count|unit|units}' });
|
|
addMessages('qaa', { '还剩 {n} 秒': 'nur noch Sekunden', '临时整备区 {n} 个单位待处理': '{n} {count|Einheit|Einheiten} {extra}' });
|
|
const seen = [];
|
|
setI18nWarn((w) => seen.push(w));
|
|
setLang('qaa');
|
|
assert.equal(t('还剩 {n} 秒', { n: 3 }), '3 seconds left', 'qaa drops {n}: English shows');
|
|
assert.equal(t('还剩 {n} 秒', { n: 4 }), '4 seconds left');
|
|
assert.equal(t('临时整备区 {n} 个单位待处理', { n: 2, count: 2 }), 'Bench: 2 units', '{extra} is not passed');
|
|
assert.equal(t('临时整备区 {n} 个单位待处理', { n: 2, count: 2, extra: '!' }), '2 Einheiten !', 'passed: fine');
|
|
assert.deepEqual(seen.map((w) => [w.lang, w.key, w.problems.join()]), [
|
|
['qaa', '还剩 {n} 秒', 'drops {n}'],
|
|
['qaa', '临时整备区 {n} 个单位待处理', 'uses {extra}, which the caller does not pass'],
|
|
], 'once per language and key');
|
|
setMessages('en', {});
|
|
assert.equal(t('还剩 {n} 秒', { n: 3 }), '还剩 3 秒', 'nothing fits: the Chinese msgid');
|
|
});
|
|
|
|
test('plurals: {n|one|other} by Intl.PluralRules (English as before); named categories for other languages (Russian)', () => {
|
|
assert.deepEqual(parsePluralForms('|second|seconds'), { one: 'second', other: 'seconds' });
|
|
assert.deepEqual(parsePluralForms('|one:день|few:дня|many:дней|other:дня'), { one: 'день', few: 'дня', many: 'дней', other: 'дня' });
|
|
assert.equal(parsePluralForms('|one:a|few:b'), null, 'named forms need other');
|
|
assert.equal(parsePluralForms('|one:a|b'), null, 'no mixing');
|
|
assert.equal(parsePluralForms('|a|b|c'), null, 'three plain forms: the category order is not stable');
|
|
assert.deepEqual([0, 1, 2, 5, 21, 1.5].map((n) => pluralCategory('en', n)), ['other', 'one', 'other', 'other', 'other', 'other']);
|
|
assert.deepEqual([0, 1, 2, 5, 21, 1.5].map((n) => pluralCategory('ru', n)), ['many', 'one', 'few', 'many', 'one', 'other']);
|
|
assert.deepEqual([0, 1, 2].map((n) => pluralCategory('qaa', n)), ['other', 'one', 'other'], 'a language the runtime does not know: one for exactly 1');
|
|
registerLangs([{ code: 'ru', name: 'Русский' }, { code: 'en' }]);
|
|
addMessages('en', { '还剩 {n} 秒': '{n} {n|second|seconds} left' });
|
|
addMessages('ru', { '还剩 {n} 秒': 'осталось {n} {n|one:секунда|few:секунды|many:секунд|other:секунды}', '{n} 名干员': '{n} {n|оператор|операторов}' });
|
|
setLang('en');
|
|
assert.deepEqual([0, 1, 2].map((n) => t('还剩 {n} 秒', { n })), ['0 seconds left', '1 second left', '2 seconds left']);
|
|
setLang('ru');
|
|
assert.deepEqual([1, 2, 5, 21, 1.5].map((n) => t('还剩 {n} 秒', { n })), ['осталось 1 секунда', 'осталось 2 секунды', 'осталось 5 секунд', 'осталось 21 секунда', 'осталось 1.5 секунды']);
|
|
assert.deepEqual([1, 3].map((n) => t('{n} 名干员', { n })), ['1 оператор', '3 операторов'], 'two plain forms: one / the rest');
|
|
const b = { type: 'b' }; // a vnode stand-in: no number, so the form of 'other'
|
|
assert.deepEqual(tParts('还剩 {n} 秒', { n: b }), ['осталось ', b, ' секунды']);
|
|
assert.equal(format('{n|one:a|other:b}', { n: 1 }, { lang: 'ru' }), 'a');
|
|
});
|
|
|
|
test('zh and English output of t() / tc() / tParts() is what it was before language packs (every msgid of public/i18n/en.json)', () => {
|
|
// the renderer of 0.2.0 before packs, frozen: one catalog, `{n|one|other}` by Number(v) === 1, lists ', ' / '、'
|
|
const OLD = /\{([A-Za-z0-9_$]+)(?:\|([^{}|]*)\|([^{}|]*))?\}/g;
|
|
const own = (o, k) => o != null && typeof o === 'object' && Object.prototype.hasOwnProperty.call(o, k);
|
|
const val = (v, lang) => (v == null ? '' : Array.isArray(v) ? v.map((x) => val(x, lang)).filter((x) => x !== '').join(lang === 'en' ? ', ' : '、') : typeof v === 'object' ? (own(v, 'dn') ? String(v.dn) : '') : String(v));
|
|
const oldFormat = (s, params, lang) => (!params || !s.includes('{') ? s : s.replace(OLD, (m, k, one, other) => (!own(params, k) ? m : one !== undefined ? (Number(params[k]) === 1 ? one : other) : val(params[k], lang))));
|
|
addMessages('en', EN);
|
|
const samples = [0, 1, 2, 5, 21, 'x', ['甲', '乙']];
|
|
let compared = 0;
|
|
for (const lang of ['zh', 'en']) {
|
|
setLang(lang);
|
|
for (const [key, tr] of Object.entries(EN)) {
|
|
if (key.startsWith('_')) continue;
|
|
const sep = key.indexOf('::');
|
|
const ctx = sep >= 0 ? key.slice(0, sep) : null;
|
|
const msgid = sep >= 0 ? key.slice(sep + 2) : key;
|
|
const names = [...new Set([...`${msgid} ${tr}`.matchAll(OLD)].map((m) => m[1]))];
|
|
for (let k = 0; k < samples.length; k++) {
|
|
const params = names.length ? Object.fromEntries(names.map((nm, i) => [nm, samples[(i + k) % samples.length]])) : undefined;
|
|
const want = oldFormat(lang === 'en' ? tr : msgid, params, lang);
|
|
const got = ctx ? tc(ctx, msgid, params) : t(msgid, params);
|
|
assert.equal(got, want, `${lang} ${key} ${JSON.stringify(params)}`);
|
|
compared++;
|
|
if (!names.length) break;
|
|
}
|
|
}
|
|
}
|
|
assert.ok(compared > 3000, `${compared} renders compared`);
|
|
assert.equal(getLang(), 'en');
|
|
});
|
|
|
|
test('game texts fall back per text: the pack\'s overlay, then its fallback\'s, then Chinese (data.js chains, i18nData onto)', async () => {
|
|
const zh = { a: { name: '甲', desc: '一', skills: [{ name: '技' }] }, b: { name: '乙' } };
|
|
const ov = (lang, leaves) => ({ version: 1, lang, names: {}, files: { chess: leaves } });
|
|
const qaa = ov('qaa', { a: buildRecordOverlay([{ path: ['name'], zh: '甲', en: 'A-qaa' }]) });
|
|
const en = ov('en', { a: buildRecordOverlay([{ path: ['name'], zh: '甲', en: 'A' }, { path: ['desc'], zh: '一', en: 'one' }, { path: ['skills', 0, 'name'], zh: '技', en: 'Skill' }]), b: buildRecordOverlay([{ path: ['name'], zh: '乙', en: 'B' }]) });
|
|
en.names = { 甲: 'A' };
|
|
qaa.names = { 乙: 'B-qaa' };
|
|
// the chained apply: lowest priority first, each over the last, hashes always against the Chinese
|
|
let v = applyFileOverlay(zh, en.files.chess).value;
|
|
v = applyFileOverlay(zh, qaa.files.chess, v).value;
|
|
assert.deepEqual(v, { a: { name: 'A-qaa', desc: 'one', skills: [{ name: 'Skill' }] }, b: { name: 'B' } });
|
|
const stale = applyFileOverlay({ ...zh, a: { ...zh.a, name: '变了' } }, qaa.files.chess, v);
|
|
assert.equal(stale.value.a.name, 'A-qaa', 'a stale leaf keeps what the overlays before it left');
|
|
assert.equal(stale.stale, 1);
|
|
const files = { '/data/chess.json': zh, '/packs/qaa/game.json': qaa, '/data/i18n/en.json': en };
|
|
const calls = [];
|
|
const d = createDataStore({ retryDelays: [], fetch: async (url) => { calls.push(url); return files[url] ? { ok: true, status: 200, json: async () => files[url] } : { ok: false, status: 404, json: async () => null }; } });
|
|
await d.load('chess');
|
|
assert.equal(await d.setLocale('qaa', [{ code: 'qaa', url: '/packs/qaa/game.json' }, 'en']), 'qaa');
|
|
assert.deepEqual(calls.filter((u) => u.includes('i18n') || u.includes('packs')).sort(), ['/data/i18n/en.json', '/packs/qaa/game.json']);
|
|
assert.deepEqual(d.lookup('chess', 'a'), { name: 'A-qaa', desc: 'one', skills: [{ name: 'Skill' }] });
|
|
assert.equal(d.lookup('chess', 'b').name, 'B');
|
|
assert.deepEqual([d.localeName('乙'), d.localeName('甲'), d.localeName('丙')], ['B-qaa', 'A', '丙'], 'names: the first overlay of the chain that knows one');
|
|
assert.deepEqual(d.localeChain(), ['qaa', 'en']);
|
|
assert.equal(await d.setLocale('qab', []), 'qab', 'a pack without game texts switches with the Chinese ones');
|
|
assert.equal(d.lookup('chess', 'a').name, '甲');
|
|
const w = console.warn;
|
|
console.warn = () => {};
|
|
try {
|
|
assert.equal(await d.setLocale('qac', ['qac']), 'qab', 'every overlay of the chain missing: no switch (as before packs)');
|
|
} finally { console.warn = w; }
|
|
});
|
|
|
|
test('client: the index registers the language packs; the menu lists them (buttons up to four, a list beyond); packs load by their URLs', async () => {
|
|
const lang = await import('../public/js/ui/lang.js');
|
|
const index = { version: 1, packs: [
|
|
{ id: 'en', type: 'lang', lang: 'en', name: 'English', englishName: 'English', fallback: [], files: { ui: '/i18n/en.json', data: '/data/i18n/en.json' } },
|
|
{ id: 'qab', type: 'lang', lang: 'qab', name: 'Qab', englishName: 'Test B', fallback: ['en'], numberUnits: ['W', 'Y'], files: { ui: '/packs/qab/ui.json' } },
|
|
{ id: 'art', type: 'assets', name: 'x', files: {} },
|
|
{ id: 'evil', type: 'lang', lang: 'qay', name: 'x', files: { ui: 'https://example.com/x.json' } },
|
|
] };
|
|
const got = [];
|
|
const fetchFake = async (url) => {
|
|
got.push(url);
|
|
const body = url === '/packs/index.json' ? index : url === '/packs/qab/ui.json' ? { 开始: 'Qab-Start' } : url === '/i18n/en.json' ? { 开始: 'Start', 设置: 'Settings' } : null;
|
|
return body ? { ok: true, status: 200, json: async () => body } : { ok: false, status: 404, json: async () => null };
|
|
};
|
|
assert.equal(await lang.loadLangIndex(fetchFake), true);
|
|
assert.deepEqual(readPackIndex(index, 'lang').map((e) => e.id), ['en', 'qab'], 'other types and off-site URLs are dropped');
|
|
assert.deepEqual(getLangs().map((m) => m.code).filter((c) => ['zh', 'en', 'qab'].includes(c)), ['zh', 'en', 'qab'], 'the source first, then by code');
|
|
assert.equal(langInfo('qab').ui, '/packs/qab/ui.json');
|
|
const menu = lang.langMenuModel(getLangs().filter((m) => ['zh', 'en', 'qab'].includes(m.code)), 'en');
|
|
assert.equal(menu.kind, 'buttons');
|
|
assert.deepEqual(menu.items.map((i) => [i.code, i.label, i.htmlLang, i.on]), [['zh', '中文', 'zh-CN', false], ['en', 'English', 'en', true], ['qab', 'Qab', 'qab', false]]);
|
|
assert.equal(menu.items[2].title, 'Test B', 'the English name as a tooltip when it reads differently');
|
|
const many = ['a1', 'a2', 'a3', 'a4', 'a5'].map((c) => ({ code: c, name: c, englishName: c }));
|
|
assert.equal(lang.langMenuModel(many, 'a1').kind, 'select');
|
|
assert.equal(await lang.loadLangChain('qab', fetchFake), true);
|
|
assert.ok(got.includes('/packs/qab/ui.json') && got.includes('/i18n/en.json'), 'the pack and its fallback, by their URLs');
|
|
assert.deepEqual(lang.dataChain('qab'), [{ code: 'en', url: '/data/i18n/en.json' }], 'only packs with game texts');
|
|
setLang('qab');
|
|
assert.deepEqual([t('开始'), t('设置')], ['Qab-Start', 'Settings']);
|
|
const { fmtNum } = await import('../public/js/ui/gameLogic.js');
|
|
assert.deepEqual([fmtNum(150_000), fmtNum(2.5e8)], ['15.0W', '2.5Y'], 'the pack\'s own number units');
|
|
setLang('en');
|
|
assert.deepEqual([fmtNum(150_000), fmtNum(2.5e8)], ['150K', '250M'], 'English: K / M / B as before');
|
|
setLang('zh');
|
|
assert.deepEqual([fmtNum(150_000), fmtNum(2.5e8)], ['15.0万', '2.5亿'], 'Chinese as before');
|
|
assert.deepEqual(lang.initialLang('?lang=QAB', () => null), { lang: 'qab', fromUrl: true });
|
|
assert.deepEqual(lang.initialLang('', () => 'qzz'), { lang: 'zh', fromUrl: false }, 'a stored pack that is gone: Chinese');
|
|
assert.deepEqual(lang.initialLang('', () => 'qzz', { tentative: true }), { lang: 'qzz', fromUrl: false }, 'without an index: tried by its code');
|
|
assert.deepEqual([scriptOf('Stronghold Protocol'), scriptOf('卫戍协议'), scriptOf('堅守協定'), scriptOf('위수 협의'), scriptOf('Протокол')], ['alphabetic', 'cjk', 'cjk', 'cjk', 'alphabetic']);
|
|
assert.deepEqual(langMetaOf(readPackIndex(index, 'lang')[1]).numberUnits, ['W', 'Y']);
|
|
assert.deepEqual(langFields('qab', { base: 'zh', fallback: 'en' }), { lang: 'qab', base: null, fallback: ['en'], complete: false, machineTranslated: false, numberUnits: null });
|
|
assert.equal(canonicalLang('zh-hant-tw'), 'zh-Hant-TW');
|
|
});
|
|
|
|
test('设置: the machine-translation note shows while the current language\'s pack is marked (ui/lang.js machineTranslationNote), in that language; none for Chinese, English or an unmarked pack', async () => {
|
|
const { machineTranslationNote } = await import('../public/js/ui/lang.js');
|
|
registerLangs([{ code: 'qap', name: 'Qap', fallback: ['en'], machineTranslated: true }, { code: 'qaq', name: 'Qaq', fallback: ['en'] }, { code: 'en', name: 'English' }]);
|
|
addMessages('en', { [MT_NOTE]: EN[MT_NOTE] });
|
|
addMessages('qap', { [MT_NOTE]: 'Qap-Hinweis' });
|
|
assert.equal(machineTranslationNote(), null, 'Chinese: no note');
|
|
setLang('qap');
|
|
assert.equal(machineTranslationNote(), 'Qap-Hinweis', 'the marked pack, in its own words');
|
|
setMessages('qap', {});
|
|
assert.equal(machineTranslationNote(), EN[MT_NOTE], 'a marked pack without the string: the next language of its chain');
|
|
setLang('qaq');
|
|
assert.equal(machineTranslationNote(), null, 'a pack that is not marked');
|
|
setLang('en');
|
|
assert.equal(machineTranslationNote(), null, 'English is not marked');
|
|
// the shipped zh-TW pack (no index here: its `_meta` registers it)
|
|
addMessages('zh-TW', ZH_TW);
|
|
setLang('zh-TW');
|
|
assert.equal(machineTranslationNote(), ZH_TW[MT_NOTE]);
|
|
assert.equal(t('设置'), '設定', 'and the rest of the interface in Traditional Chinese');
|
|
});
|
|
|
|
test('tools: template writes a skeleton (or adds the missing msgids to a pack), check reports coverage and errors per pack; packs index writes the static index', () => {
|
|
const used = new Map([['开始', { where: 'a.js:1', params: [] }], ['还剩 {n} 秒', { where: 'b.js:2', params: new Set(['n']) }], ['{n} 名', { where: 'c.js:3', params: new Set(['n', 'count']) }], ['表里的', { where: 'd.js:4', params: null }]]);
|
|
const skel = packTemplate('qaa', { msgids: [...used.keys()] });
|
|
assert.deepEqual(Object.keys(skel.json), ['_meta', '开始', '还剩 {n} 秒', '{n} 名', '表里的']);
|
|
assert.deepEqual([skel.json._meta.type, skel.json._meta.lang, skel.json._meta.fallback, skel.json._meta.app], ['lang', 'qaa', ['en'], `>=${APP_VERSION.replace(/-.*$/, '')}`], 'this release and later (tools/i18n.mjs appRange)');
|
|
assert.equal(packTemplate('zh-TW', { msgids: [] }).json._meta.fallback.length, 0, 'a Chinese variant falls back to the Chinese msgid');
|
|
assert.equal(skel.json['开始'], '');
|
|
const again = packTemplate('qaa', { existing: { _meta: { name: 'Mine' }, 开始: 'Los', 旧的: 'alt' }, msgids: [...used.keys()], fill: { 还剩: 'x' } });
|
|
assert.deepEqual([again.json._meta, again.json['开始'], again.json['旧的'], again.kept, again.added], [{ name: 'Mine' }, 'Los', 'alt', 1, 3], 'translations and _meta kept, the rest added');
|
|
const r = checkPack({ 开始: 'Los', '还剩 {n} 秒': 'Sekunden', '{n} 名': '{n} {count|Name|Namen} {who}', 表里的: '{any}', 旧的: 'alt', 'x::y': 3 }, used, new Set([...used.keys()]));
|
|
assert.deepEqual([r.total, r.translated, r.missing.length, r.obsolete], [4, 2, 0, ['旧的']]);
|
|
assert.deepEqual(r.errors.map((e) => e.split(':')[0]), ['not a string', 'drops {n}', 'uses {who}, which no call site passes']);
|
|
// the CLI on a temporary checkout's packs (the msgids come from this checkout's code)
|
|
const root = tmpdir('cli');
|
|
try {
|
|
put(root, 'public/i18n/en.json', EN);
|
|
const run = (...args) => spawnSync(process.execPath, [path.join(ROOT, 'tools/i18n.mjs'), ...args, '--root', root], { encoding: 'utf8' });
|
|
const tpl = run('template', 'qaa');
|
|
assert.equal(tpl.status, 0, tpl.stderr);
|
|
assert.match(tpl.stdout, /wrote public\/i18n\/qaa\.json: \d+ msgids — 0 translations kept, \d+ added \(empty\)/);
|
|
const pack = JSON.parse(fs.readFileSync(path.join(root, 'public/i18n/qaa.json'), 'utf8'));
|
|
assert.equal(Object.keys(pack).length - 1, Object.keys(EN).filter((k) => !k.startsWith('_')).length, 'every msgid of the complete pack');
|
|
pack['开始'] = 'Los';
|
|
fs.writeFileSync(path.join(root, 'public/i18n/qaa.json'), JSON.stringify(pack));
|
|
const ok = run('check', 'qaa', '--strict');
|
|
assert.equal(ok.status, 0, `${ok.stdout}${ok.stderr}`);
|
|
assert.match(ok.stdout, /public\/i18n\/qaa\.json \(qaa, qaa\): \d+ msgids used, 1 translated \([\d.]+ %\), \d+ missing, 0 errors/);
|
|
pack['还剩 {n} 秒'] = 'x';
|
|
pack['第 {r} 回合 · 最终攻势'] = 'Runde';
|
|
fs.writeFileSync(path.join(root, 'public/i18n/qaa.json'), JSON.stringify(pack));
|
|
const bad = run('check', 'qaa', '--strict');
|
|
assert.equal(bad.status, 1);
|
|
assert.match(bad.stdout, /error {4}public\/i18n\/qaa\.json: drops \{r\}: 第 \{r\} 回合 · 最终攻势 {2}→ {2}Runde/);
|
|
const all = run('check', '--all');
|
|
assert.match(all.stdout, /public\/i18n\/en\.json \(English, en, complete\): (\d+) msgids used, \1 translated \(100 %\), 0 missing, 0 errors/);
|
|
const body = writePackIndex(root);
|
|
assert.deepEqual(body.packs.map((p) => p.id), ['en', 'qaa']);
|
|
assert.deepEqual(JSON.parse(fs.readFileSync(path.join(root, 'packs/index.json'), 'utf8')), body);
|
|
} finally { fs.rmSync(root, { recursive: true, force: true }); }
|
|
});
|
|
|
|
test('build-i18n --lang: another official client (a text equal to the Chinese is no translation, no English composites); --dict for a language without one', () => {
|
|
assert.deepEqual(Object.keys(LANG_SOURCES), ['en', 'ja', 'ko', 'zh-TW']);
|
|
assert.match(LANG_SOURCES.ja.sources.assets.url, /ArknightsAssets\/ArknightsGamedata\/master\/jp\/gamedata\/$/);
|
|
const zh = [{ chars: { char_x: { name: '测试员', description: '攻击造成法术伤害' } } }];
|
|
const ja = [{ chars: { char_x: { name: 'テスター', description: '攻击造成法术伤害' } } }];
|
|
const data = { chess: { chess_x_a: { charId: 'char_x', name: '测试员', trait: { desc: '攻击造成法术伤害' } } }, stages: { m1: { name: '战场#05(下半) 测试员' } } };
|
|
const { overlay, report } = buildOverlay({ zh, en: ja, data, lang: 'ja' });
|
|
assert.equal(overlay.lang, 'ja');
|
|
const c = applyRecordOverlay(data.chess.chess_x_a, overlay.files.chess.chess_x_a).value;
|
|
assert.deepEqual([c.name, c.trait.desc], ['テスター', '攻击造成法术伤害'], 'the JP text equal to the Chinese one stays untranslated (falls back at run time)');
|
|
assert.equal(overlay.files.stages, undefined, 'the remake\'s stage-name composite is English wording only');
|
|
assert.equal(overlay.names['测试员'], 'テスター');
|
|
assert.equal(report.coverage.operators.translated, 1);
|
|
const fr = buildOverlay({ zh: [], en: [], data, lang: 'fr', fallback: { dict: { 测试员: 'Testeur', 攻击造成法术伤害: 'Inflige des dégâts magiques' } } });
|
|
const f = applyRecordOverlay(data.chess.chess_x_a, fr.overlay.files.chess.chess_x_a).value;
|
|
assert.deepEqual([fr.overlay.lang, f.name, f.trait.desc, fr.overlay.names['测试员']], ['fr', 'Testeur', 'Inflige des dégâts magiques', 'Testeur']);
|
|
assert.deepEqual([fr.report.coverage.operators.dict, fr.report.coverage.traits.dict], [1, 1], 'counted as the dictionary\'s');
|
|
});
|