483 lines
26 KiB
JavaScript
483 lines
26 KiB
JavaScript
// Official emotes (research 09 §4 / §6.6): the 36 in-match emotes of 盟约 (6 themes × 6), their generated reference
|
||
// data/emotes.json (tools/build-emotes.mjs), the local-client extraction (tools/local-extract/extract.py), the protocol
|
||
// whitelist and the pure helpers of public/js/ui/emotes.js. Browser behaviour (picture-only bubbles, pager, cooldown)
|
||
// is covered by test/ui/emotes.e2e.test.js (SP_E2E=1).
|
||
|
||
import { test, describe } from 'node:test';
|
||
import assert from 'node:assert/strict';
|
||
import { readFileSync, existsSync } from 'node:fs';
|
||
import { spawnSync } from 'node:child_process';
|
||
import path from 'node:path';
|
||
import { fileURLToPath } from 'node:url';
|
||
import {
|
||
EMOTES, EMOTE_THEMES, EMOTE_CATALOG, EMOTE_THEME, EMOTE_LABEL, EMOTE_COOLDOWN_MS, EMOTE_BUBBLE_MS,
|
||
emoteInfo, emoteArtPath, emoteArtGroup,
|
||
} from '../../shared/constants.js';
|
||
import { validateC2S } from '../../shared/protocol.js';
|
||
import { buildEmotes, formatEmotes, THEME_DIRS } from '../../tools/build-emotes.mjs';
|
||
|
||
const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..');
|
||
const readJson = (rel) => JSON.parse(readFileSync(path.join(ROOT, rel), 'utf8'));
|
||
const tryJson = (rel) => { try { return readJson(rel); } catch { return null; } };
|
||
const EMOTES_JSON = readJson('data/emotes.json');
|
||
|
||
const ENABLED = ['emoticon_autochess_basic', 'emoticon_originium_slug', 'emoticon_autochess_basic_2',
|
||
'emoticon_foolsday_doctor', 'emoticon_foolsday_amiya', 'emoticon_foolsday_wisdel'];
|
||
|
||
describe('emote catalog (shared/constants.js)', () => {
|
||
test('6 themes × 6 battle emotes = 36 unique official ids, in wheel order', () => {
|
||
assert.deepEqual(EMOTE_THEMES.map((t) => t.themeId), ENABLED, 'pages follow autoChessData.enabledEmoticonThemeIdList');
|
||
for (const t of EMOTE_THEMES) {
|
||
assert.equal(t.emotes.length, 6, t.themeId);
|
||
const sorts = t.emotes.map((e) => e.sortId);
|
||
assert.deepEqual(sorts, [...sorts].sort((a, b) => a - b), `${t.themeId} by sortId`);
|
||
}
|
||
assert.equal(EMOTES.length, 36);
|
||
assert.equal(new Set(EMOTES).size, 36);
|
||
assert.deepEqual([...EMOTES], EMOTE_CATALOG.map((e) => e.id));
|
||
for (const id of EMOTES) assert.match(id, /^(slug_)?autochess_battle_[a-z0-9_]+$/, id);
|
||
assert.ok(Object.isFrozen(EMOTES) && Object.isFrozen(EMOTE_THEMES) && Object.isFrozen(EMOTE_THEMES[0].emotes));
|
||
});
|
||
|
||
test('picId comes from the table, not from the id (fooldoctor 03–06 → pics 04/05/06/08)', () => {
|
||
const doc = EMOTE_THEMES.find((t) => t.themeId === 'emoticon_foolsday_doctor');
|
||
assert.deepEqual(doc.emotes.map((e) => e.picId),
|
||
['pic_fooldoctor_01_battle', 'pic_fooldoctor_02_battle', 'pic_fooldoctor_04_battle', 'pic_fooldoctor_05_battle', 'pic_fooldoctor_06_battle', 'pic_fooldoctor_08_battle']);
|
||
assert.equal(emoteArtPath('autochess_battle_fooldoctor_06'), '/assets/local/emoticon/fooldoctor/pic_fooldoctor_08_battle.png');
|
||
assert.equal(emoteArtPath('autochess_battle_nice_cooperate'), '/assets/local/emoticon/basic/pic_cooperate_battle.png');
|
||
assert.equal(emoteArtPath('slug_autochess_battle_thanks'), '/assets/local/emoticon/slug/pic_thanks_battle.png');
|
||
assert.equal(emoteArtGroup('autochess_battle_dying'), 'emoticon/basic_2');
|
||
for (const e of EMOTE_CATALOG) assert.match(e.picId, /^pic_.+_battle$/, e.id);
|
||
});
|
||
|
||
test('lookups are safe for any input', () => {
|
||
for (const bad of ['happy', 'autochess_room_hello', '__proto__', 'constructor', 'toString', '', null, undefined, 42, {}]) {
|
||
assert.equal(emoteInfo(bad), null, String(bad));
|
||
assert.equal(emoteArtPath(bad), null, String(bad));
|
||
assert.equal(emoteArtGroup(bad), null, String(bad));
|
||
}
|
||
assert.equal(emoteInfo('autochess_battle_call').themeId, 'emoticon_autochess_basic_2');
|
||
assert.equal(EMOTE_THEME.slug_autochess_battle_bye, 'emoticon_originium_slug');
|
||
assert.equal(typeof EMOTE_LABEL.autochess_battle_happy, 'string');
|
||
for (const bad of ['__proto__', 'constructor', 'toString', 'hasOwnProperty']) {
|
||
assert.equal(EMOTE_THEME[bad], undefined, `EMOTE_THEME[${bad}]`);
|
||
assert.equal(EMOTE_LABEL[bad], undefined, `EMOTE_LABEL[${bad}]`);
|
||
}
|
||
assert.equal(Object.keys(EMOTE_THEME).length, 36);
|
||
assert.ok(Object.isFrozen(EMOTE_THEME) && Object.isFrozen(EMOTE_LABEL));
|
||
});
|
||
|
||
test('protocol accepts exactly the 36 official battle ids (g.emote { id })', () => {
|
||
for (const id of EMOTES) assert.equal(validateC2S({ t: 'g.emote', id }), null, id);
|
||
for (const id of ['happy', 'thanks', 'autochess_room_hello', 'multiv3_battle_thanks', 'duel_battle_happy', '__proto__', '', 7, null]) {
|
||
assert.notEqual(validateC2S({ t: 'g.emote', id }), null, String(id));
|
||
}
|
||
});
|
||
|
||
test('cooldown and bubble time are the official chatCD / chatTime', () => {
|
||
assert.equal(EMOTE_COOLDOWN_MS, EMOTES_JSON.chatCD * 1000);
|
||
assert.equal(EMOTE_BUBBLE_MS, EMOTES_JSON.chatTime * 1000);
|
||
assert.equal(EMOTE_COOLDOWN_MS, 1000);
|
||
assert.equal(EMOTE_BUBBLE_MS, 3000);
|
||
// the client reads the bubble time from config.timers (game.js) and the server rate-limits with the constant
|
||
const timers = tryJson('data/config.json')?.timers;
|
||
if (timers) assert.deepEqual([timers.chatCd * 1000, timers.chatBubble * 1000], [EMOTE_COOLDOWN_MS, EMOTE_BUBBLE_MS]);
|
||
});
|
||
});
|
||
|
||
describe('data/emotes.json (tools/build-emotes.mjs)', () => {
|
||
test('is identical to the shared/constants.js table', () => {
|
||
assert.deepEqual(EMOTES_JSON.themes.map(({ themeId, dir, sortId, isBasic, name, emotes }) => ({ themeId, dir, sortId, isBasic, name, emotes })),
|
||
EMOTE_THEMES.map((t) => ({ themeId: t.themeId, dir: t.dir, sortId: t.sortId, isBasic: t.isBasic, name: t.name, emotes: t.emotes.map((e) => e.id) })));
|
||
assert.deepEqual(EMOTES_JSON.emotes, EMOTE_CATALOG.map((e) => ({
|
||
id: e.id, themeId: e.themeId, sortId: e.sortId, picId: e.picId, art: emoteArtPath(e.id), label: e.label,
|
||
})));
|
||
});
|
||
|
||
test('regenerating from the cached official tables reproduces it byte for byte', {
|
||
skip: !existsSync(path.join(ROOT, '.cache/gamedata/excel/display_meta_table.json')) && 'no cached display_meta_table.json',
|
||
}, () => {
|
||
const { doc, warnings } = buildEmotes({
|
||
display: readJson('.cache/gamedata/excel/display_meta_table.json'),
|
||
activity: readJson('.cache/gamedata/excel/activity_table.json'),
|
||
items: tryJson('.cache/gamedata/excel/item_table.json'),
|
||
});
|
||
assert.deepEqual(warnings, []);
|
||
assert.equal(formatEmotes(doc), readFileSync(path.join(ROOT, 'data/emotes.json'), 'utf8'));
|
||
});
|
||
|
||
test('builder: scene filter, enabled-list page order, sortId order, picId from the table, fallbacks', () => {
|
||
const e = (id, type, sortId, picId) => ({ id, type, sortId, picId, desc: null });
|
||
const display = { emoticonData: {
|
||
emojiDataDict: {
|
||
a_room: e('a_room', 'AUTOCHESS_ROOM', 1, 'pic_a'),
|
||
a_2: e('a_2', 'AUTOCHESS_BATTLE', 20, 'pic_a2_battle'),
|
||
a_1: e('a_1', 'AUTOCHESS_BATTLE', 10, 'pic_a9_battle'),
|
||
b_1: e('b_1', 'AUTOCHESS_BATTLE', 5, 'pic_b_battle'),
|
||
b_multi: e('b_multi', 'ACTMULTIV3_BATTLE', 1, 'pic_m_battle'),
|
||
autochess_battle_happy: e('autochess_battle_happy', 'AUTOCHESS_BATTLE', 1, 'pic_happy_battle'),
|
||
},
|
||
emoticonThemeDataDict: { emoticon_x: ['a_room', 'a_2', 'a_1'], emoticon_originium_slug: ['b_multi', 'b_1'], emoticon_empty: ['a_room'] },
|
||
emoticonThemeTypeDict: { emoticon_x: { sortId: 7, isBasic: true }, emoticon_originium_slug: { sortId: 1001, isBasic: false } },
|
||
} };
|
||
const activity = { autoChessData: {
|
||
enabledEmoticonThemeIdList: ['emoticon_originium_slug', 'emoticon_missing', 'emoticon_x', 'emoticon_empty'],
|
||
constData: { chatCD: 1, chatTime: 3 },
|
||
} };
|
||
const items = { items: { emoticon_originium_slug: { name: '表情套组：虫动' } } };
|
||
const { doc, warnings } = buildEmotes({ display, activity, items });
|
||
assert.deepEqual(doc.themes.map((t) => [t.themeId, t.dir, t.emotes]), [
|
||
['emoticon_originium_slug', 'slug', ['b_1']],
|
||
['emoticon_x', 'x', ['a_1', 'a_2']],
|
||
]);
|
||
assert.equal(doc.emotes.find((x) => x.id === 'a_1').art, '/assets/local/emoticon/x/pic_a9_battle.png');
|
||
assert.equal(doc.emotes.find((x) => x.id === 'a_1').label, 'emoticon_x 1', 'no official text: generic aria label');
|
||
assert.equal(doc.emotes.find((x) => x.id === 'b_1').label, '虫动 1');
|
||
assert.equal(doc.themes[0].name, '表情套组：虫动');
|
||
assert.deepEqual([doc.chatCD, doc.chatTime], [1, 3]);
|
||
assert.equal(warnings.length, 2, warnings.join('; '));
|
||
assert.throws(() => buildEmotes({ display: {}, activity }), /emoticonData/);
|
||
assert.throws(() => buildEmotes({ display, activity: {} }), /enabledEmoticonThemeIdList/);
|
||
const text = formatEmotes(doc);
|
||
assert.deepEqual(JSON.parse(text), doc);
|
||
assert.equal(formatEmotes(buildEmotes({ display, activity, items }).doc), text, 'deterministic');
|
||
});
|
||
|
||
test('builder: an emoji listed by two themes / a theme listed twice is kept once; art dirs must be unique', () => {
|
||
const e = (id, sortId, picId = `pic_${id}_battle`) => ({ id, type: 'AUTOCHESS_BATTLE', sortId, picId, desc: null });
|
||
const display = { emoticonData: {
|
||
emojiDataDict: { a: e('a', 1), b: e('b', 2), c: e('c', 3), nopic: { id: 'nopic', type: 'AUTOCHESS_BATTLE', sortId: 4, picId: null } },
|
||
emoticonThemeDataDict: { emoticon_one: ['a', 'b', 'nopic', 'toString'], emoticon_two: ['b', 'c', '__proto__'] },
|
||
emoticonThemeTypeDict: {},
|
||
} };
|
||
const activity = { autoChessData: { enabledEmoticonThemeIdList: ['emoticon_one', 'emoticon_two', 'emoticon_one', 'constructor'] } };
|
||
const { doc, warnings } = buildEmotes({ display, activity });
|
||
assert.deepEqual(doc.themes.map((t) => [t.themeId, t.emotes]), [['emoticon_one', ['a', 'b']], ['emoticon_two', ['c']]]);
|
||
assert.deepEqual(doc.emotes.map((x) => x.id), ['a', 'b', 'c'], 'every protocol id once');
|
||
assert.equal(new Set(doc.emotes.map((x) => x.art)).size, 3);
|
||
assert.ok(warnings.some((w) => /^b: already on an earlier page/.test(w)), warnings.join('; '));
|
||
assert.ok(warnings.some((w) => /emoticon_one: listed twice/.test(w)));
|
||
assert.ok(warnings.some((w) => /constructor: not in emoticonThemeDataDict/.test(w)), 'prototype keys are not themes');
|
||
assert.throws(() => buildEmotes({ display: { emoticonData: { ...display.emoticonData, emoticonThemeDataDict: { emoticon_x: ['a'], emticon_x: ['c'] } } },
|
||
activity: { autoChessData: { enabledEmoticonThemeIdList: ['emoticon_x', 'emticon_x'] } } }), /already used/);
|
||
});
|
||
|
||
test('theme dirs agree between the builder, the constants and data/emotes.json', () => {
|
||
for (const t of EMOTE_THEMES) assert.equal(THEME_DIRS[t.themeId], t.dir, t.themeId);
|
||
assert.equal(Object.keys(THEME_DIRS).length, EMOTE_THEMES.length);
|
||
});
|
||
});
|
||
|
||
const PY = ['python3', 'python'].find((bin) => spawnSync(bin, ['--version']).status === 0);
|
||
const PY_ENV = { ...process.env, PYTHONDONTWRITEBYTECODE: '1' };
|
||
|
||
describe('local-client extraction (tools/local-extract/extract.py)', () => {
|
||
test('extracts every emote theme (battle sprites only) into emoticon/<dir>', { skip: !PY && 'no python3' }, () => {
|
||
const r = spawnSync(PY, [path.join(ROOT, 'tools/local-extract/extract.py'), '--print-jobs'], { encoding: 'utf8', env: PY_ENV });
|
||
assert.equal(r.status, 0, r.stderr);
|
||
const { emoteThemes, jobs } = JSON.parse(r.stdout);
|
||
assert.deepEqual(emoteThemes, EMOTE_THEMES.map((t) => ({ themeId: t.themeId, dir: t.dir })));
|
||
for (const t of EMOTE_THEMES) {
|
||
const job = jobs.find((j) => j.sub === `emoticon/${t.dir}`);
|
||
assert.ok(job, t.themeId);
|
||
assert.equal(job.bundle, `ui/emoticon/theme/[uc]${t.themeId}.ab`);
|
||
assert.deepEqual(job.kinds, ['Sprite'], 'the Sprite (true aspect), not the padded Texture2D');
|
||
const keep = new RegExp(job.keep);
|
||
for (const e of t.emotes) assert.ok(keep.test(e.picId), e.picId);
|
||
for (const other of ['pic_hello', 'pic_thanks', 'pic_bg', 'pic_nice_work', 'pic_very_soon']) assert.ok(!keep.test(other), other);
|
||
}
|
||
// the other jobs are untouched
|
||
for (const sub of ['map/autochess', 'ui/battle', 'ui/outer', 'guide']) assert.ok(jobs.some((j) => j.sub === sub && j.keep === null), sub);
|
||
});
|
||
|
||
test('--only re-extracts a subset and merges it into the existing manifest', { skip: !PY && 'no python3' }, () => {
|
||
const code = `import sys, json; sys.path.insert(0, ${JSON.stringify(path.join(ROOT, 'tools/local-extract'))}); import extract as e
|
||
print(json.dumps({
|
||
'emo': [j[1] for j in e.select_jobs(['emoticon'])], 'slug': [j[1] for j in e.select_jobs(['emoticon/slug/'])],
|
||
'all': len(e.select_jobs([])) == len(e.JOBS), 'none': e.select_jobs(['emo']),
|
||
'merged': e.merge_manifest({'ui/battle': {'b': 1, 'a': 2}, 'emoticon/slug': {'old': 1}, 'emoticon/basic': {'keep': 1}},
|
||
{'emoticon/slug': {'pic_z_battle': 1, 'pic_a_battle': 2}}, {'emoticon/slug'}),
|
||
}))`;
|
||
const r = spawnSync(PY, ['-c', code], { encoding: 'utf8', env: PY_ENV });
|
||
assert.equal(r.status, 0, r.stderr);
|
||
const out = JSON.parse(r.stdout);
|
||
assert.deepEqual(out.emo, EMOTE_THEMES.map((t) => `emoticon/${t.dir}`));
|
||
assert.deepEqual(out.slug, ['emoticon/slug']);
|
||
assert.equal(out.all, true);
|
||
assert.deepEqual(out.none, [], 'prefixes match whole path segments');
|
||
assert.deepEqual(out.merged, { 'emoticon/basic': { keep: 1 }, 'emoticon/slug': { pic_a_battle: 2, pic_z_battle: 1 }, 'ui/battle': { a: 2, b: 1 } });
|
||
assert.deepEqual(Object.keys(out.merged), ['emoticon/basic', 'emoticon/slug', 'ui/battle'], 'sorted, deterministic');
|
||
});
|
||
|
||
const manifest = tryJson('data/local-assets.json');
|
||
test('the extracted manifest lists all 36 pictures under their picId', { skip: !manifest && 'no data/local-assets.json' }, () => {
|
||
for (const e of EMOTE_CATALOG) {
|
||
const entry = manifest.groups[emoteArtGroup(e.id)]?.[e.picId];
|
||
assert.ok(entry, `${e.id} → ${e.picId}`);
|
||
assert.equal(entry.path, emoteArtPath(e.id));
|
||
assert.ok(entry.w >= 64 && entry.h >= 64 && entry.w <= 160 && entry.h <= 160, `${e.picId} ${entry.w}×${entry.h}`);
|
||
assert.equal(entry.kind, 'Sprite');
|
||
}
|
||
for (const t of EMOTE_THEMES) {
|
||
const names = Object.keys(manifest.groups[`emoticon/${t.dir}`]);
|
||
assert.deepEqual(names.sort(), t.emotes.map((e) => e.picId).sort(), `${t.dir}: only the battle sprites`);
|
||
}
|
||
for (const n of ['emoji_bubble_bkg', 'emoji_bkg', 'emoji_cell_bkg', 'emoji_btn', 'emoji_btn_disable']) assert.ok(manifest.groups['ui/battle']?.[n], n);
|
||
});
|
||
|
||
test('the listed pictures exist on disk', { skip: (!manifest || !existsSync(path.join(ROOT, 'public/assets/local/emoticon'))) && 'no extracted art' }, () => {
|
||
for (const e of EMOTE_CATALOG) {
|
||
const file = path.join(ROOT, 'public', emoteArtPath(e.id));
|
||
assert.ok(existsSync(file), file);
|
||
const png = readFileSync(file);
|
||
assert.equal(png.subarray(1, 4).toString(), 'PNG', file);
|
||
}
|
||
});
|
||
});
|
||
|
||
describe('public/js/ui/emotes.js helpers', () => {
|
||
const store = new Map();
|
||
globalThis.localStorage = {
|
||
getItem: (k) => (store.has(k) ? store.get(k) : null),
|
||
setItem: (k, v) => { store.set(k, String(v)); },
|
||
removeItem: (k) => { store.delete(k); },
|
||
};
|
||
const manifest = { version: 1, groups: {
|
||
'emoticon/fooldoctor': { pic_fooldoctor_08_battle: { path: '/assets/local/emoticon/fooldoctor/pic_fooldoctor_08_battle.png', w: 115, h: 115 } },
|
||
'ui/battle': { emoji_bubble_bkg: { path: '/assets/local/ui/battle/emoji_bubble_bkg.png', w: 108, h: 97 } },
|
||
} };
|
||
const realFetch = globalThis.fetch;
|
||
|
||
test('art URLs come only from what the manifests list (here the local one, keyed by picId; data/assets.json absent); unknown / unlisted → null', async () => {
|
||
globalThis.fetch = async (url) => (String(url).endsWith('/local-assets.json')
|
||
? { ok: true, status: 200, json: async () => manifest } : { ok: false, status: 404, json: async () => ({}) });
|
||
try {
|
||
const { data } = await import('../../public/js/data.js');
|
||
await data.invalidate('local');
|
||
await data.load('local');
|
||
const { emoteArtUrl, emoteUiSprite } = await import('../../public/js/ui/emotes.js');
|
||
assert.equal(emoteArtUrl('autochess_battle_fooldoctor_06'), '/assets/local/emoticon/fooldoctor/pic_fooldoctor_08_battle.png');
|
||
assert.equal(emoteArtUrl('autochess_battle_fooldoctor_05'), null, 'unlisted');
|
||
assert.equal(emoteArtUrl('happy'), null, 'v1 id');
|
||
assert.equal(emoteArtUrl('__proto__'), null);
|
||
assert.equal(emoteUiSprite('emoji_bubble_bkg'), '/assets/local/ui/battle/emoji_bubble_bkg.png');
|
||
assert.equal(emoteUiSprite('emoji_bkg'), null);
|
||
} finally {
|
||
globalThis.fetch = realFetch;
|
||
}
|
||
});
|
||
|
||
test('pager helpers: clamp, swipe threshold, remembered theme', async () => {
|
||
const { clampPage, swipeStep, themeIndex, lastThemeIndex, rememberTheme } = await import('../../public/js/ui/emotes.js');
|
||
assert.deepEqual([clampPage(-3), clampPage(2), clampPage(99), clampPage('x'), clampPage(2.7)], [0, 2, 5, 0, 2]);
|
||
assert.deepEqual([swipeStep(-60), swipeStep(60), swipeStep(-10), swipeStep(0), swipeStep(-40)], [1, -1, 0, 0, 1]);
|
||
assert.equal(themeIndex('emoticon_foolsday_amiya'), 4);
|
||
assert.equal(themeIndex('nope'), 0);
|
||
store.clear();
|
||
assert.equal(lastThemeIndex(), 0, 'first page by default');
|
||
rememberTheme('emoticon_foolsday_wisdel');
|
||
assert.equal(lastThemeIndex(), 5);
|
||
rememberTheme('bogus');
|
||
assert.equal(lastThemeIndex(), 5, 'unknown themes are not stored');
|
||
store.set('sp.pref.emoteTheme', '"emoticon_gone"');
|
||
assert.equal(lastThemeIndex(), 0, 'a stale theme falls back to the first page');
|
||
store.set('sp.pref.emoteTheme', '{bad json');
|
||
assert.equal(lastThemeIndex(), 0);
|
||
});
|
||
|
||
test('wheel paging: one page per gesture — a trackpad swipe\'s momentum tail never skips themes', async () => {
|
||
const { wheelStep, wheelDelta, WHEEL_GAP_MS, WHEEL_STEP_PX } = await import('../../public/js/ui/emotes.js');
|
||
// one macOS trackpad swipe: 60 events 16 ms apart, decaying deltaX (≈ 750 px in total)
|
||
const acc = { x: 0, t: -Infinity, spent: false };
|
||
let t = 1000;
|
||
const swipe = (sign) => {
|
||
const steps = [];
|
||
for (let i = 0; i < 60; i++, t += 16) steps.push(wheelStep(acc, sign * Math.max(2, 40 * 0.95 ** i), t));
|
||
return steps.filter(Boolean);
|
||
};
|
||
assert.deepEqual(swipe(1), [1], 'the whole swipe turns exactly one page');
|
||
t += WHEEL_GAP_MS - 20;
|
||
assert.deepEqual(swipe(1), [], 'a tail that continues without a pause is still the same gesture');
|
||
t += WHEEL_GAP_MS + 1;
|
||
assert.deepEqual(swipe(-1), [-1], 'a new gesture after a pause turns the page again (backwards)');
|
||
// mouse wheel notches (100 px) with pauses: one page per notch; small deltas accumulate
|
||
t += 1000;
|
||
assert.equal(wheelStep(acc, 100, t), 1);
|
||
t += 400;
|
||
assert.equal(wheelStep(acc, 100, t), 1);
|
||
t += 400;
|
||
assert.equal(wheelStep(acc, WHEEL_STEP_PX / 2, t), 0);
|
||
assert.equal(wheelStep(acc, WHEEL_STEP_PX / 2, t + 16), 1);
|
||
assert.equal(wheelStep(acc, 0, t + 1000), 0);
|
||
assert.equal(wheelStep({ x: 0, t: 5000, spent: true }, 100, 10), 1, 'a clock that went backwards starts a new gesture');
|
||
// Unity ScrollRect rule: a mostly vertical wheel drives the horizontal pager (down = next); lines / pages → px
|
||
assert.equal(wheelDelta({ deltaX: 0, deltaY: 100 }), 100);
|
||
assert.equal(wheelDelta({ deltaX: 0, deltaY: -100 }), -100);
|
||
assert.equal(wheelDelta({ deltaX: 30, deltaY: 10 }), 30);
|
||
assert.equal(wheelDelta({ deltaX: 0, deltaY: 3, deltaMode: 1 }), 48);
|
||
assert.equal(wheelDelta({ deltaX: 1, deltaY: 0, deltaMode: 2 }, 271), 271);
|
||
assert.equal(wheelDelta({}), 0);
|
||
assert.equal(wheelDelta(null), 0);
|
||
});
|
||
|
||
test('cooldown and bubble timelines are computed from timestamps (robust to remounts and clock jumps)', async () => {
|
||
const { cooldownLeft, bubbleAge } = await import('../../public/js/ui/emotes.js');
|
||
assert.equal(cooldownLeft(-Infinity, 5000), 0, 'never sent');
|
||
assert.equal(cooldownLeft(5000, 5000), EMOTE_COOLDOWN_MS);
|
||
assert.equal(cooldownLeft(5000, 5400), 600);
|
||
assert.equal(cooldownLeft(5000, 6000), 0);
|
||
assert.equal(cooldownLeft(5000, 1000), 0, 'a clock that went backwards never locks the button');
|
||
assert.equal(cooldownLeft(5000, 5100, 500), 400);
|
||
assert.equal(bubbleAge(undefined, 9000), 0);
|
||
assert.equal(bubbleAge(8000, 9000), 1000);
|
||
assert.equal(bubbleAge(8000, 7000), 0, 'future timestamps start fresh');
|
||
assert.equal(bubbleAge(1000, 9000), EMOTE_BUBBLE_MS, 'capped at the display time');
|
||
assert.equal(bubbleAge(NaN, 9000), 0);
|
||
});
|
||
|
||
test('ensureEmoteCss links public/css/emotes.css once, and is a no-op without a document', async () => {
|
||
const { ensureEmoteCss, EMOTE_CSS_HREF } = await import('../../public/js/ui/emotes.js');
|
||
const links = [];
|
||
const doc = {
|
||
head: { appendChild: (n) => links.push(n) },
|
||
createElement: () => ({}),
|
||
querySelector: () => (links.length ? links[0] : null),
|
||
};
|
||
assert.equal(ensureEmoteCss(doc), true);
|
||
assert.equal(ensureEmoteCss(doc), false);
|
||
assert.deepEqual(links, [{ rel: 'stylesheet', href: EMOTE_CSS_HREF }]);
|
||
assert.equal(ensureEmoteCss(undefined), false);
|
||
assert.ok(existsSync(path.join(ROOT, 'public', EMOTE_CSS_HREF)));
|
||
assert.match(readFileSync(path.join(ROOT, 'public/index.html'), 'utf8'), /href="\/css\/emotes\.css"/);
|
||
});
|
||
|
||
test('a hung emote manifest is missing when the clock fires (glyph), and a later retry replaces it', async () => {
|
||
const { createDataStore } = await import('../../public/js/data.js');
|
||
const timers = [];
|
||
let calls = 0;
|
||
let releaseWait;
|
||
const store = createDataStore({
|
||
timeoutMs: 1000,
|
||
retryDelays: [0],
|
||
wait: () => new Promise((r) => { releaseWait = r; }),
|
||
setTimeout: (fn, ms) => { timers.push({ fn, ms }); return timers.length; },
|
||
clearTimeout: () => {},
|
||
fetch: () => {
|
||
calls++;
|
||
if (calls === 1) return new Promise(() => {});
|
||
return Promise.resolve({ ok: true, status: 200, json: async () => ({ ok: true, groups: { a: { pic: { path: '/p.png' } } } }) });
|
||
},
|
||
});
|
||
const states = [];
|
||
store.subscribe(() => states.push(store.status('local')));
|
||
const p = store.load('local');
|
||
assert.equal(store.status('local'), 'loading');
|
||
assert.equal(timers.length, 1);
|
||
assert.equal(timers[0].ms, 1000);
|
||
timers[0].fn();
|
||
await new Promise((r) => setImmediate(r));
|
||
assert.equal(store.status('local'), 'missing', 'glyph as soon as the attempt times out, before the retry');
|
||
assert.equal(calls, 1, 'still on the first attempt while the retry waits');
|
||
releaseWait();
|
||
const value = await p;
|
||
assert.equal(calls, 2);
|
||
assert.equal(store.status('local'), 'ready');
|
||
assert.equal(value.ok, true);
|
||
assert.equal(store.get('local').groups.a.pic.path, '/p.png');
|
||
assert.deepEqual(states, ['missing', 'ready']);
|
||
for (const t of timers) t.fn();
|
||
assert.equal(store.status('local'), 'ready', 'a timer that fires after success does not demote the file');
|
||
});
|
||
|
||
test('a failed emote manifest (no clock) is missing before the retry, then ready; a 404 stays missing', async () => {
|
||
const { createDataStore } = await import('../../public/js/data.js');
|
||
let calls = 0;
|
||
const store = createDataStore({
|
||
timeoutMs: 1000,
|
||
retryDelays: [0],
|
||
wait: async () => {},
|
||
setTimeout: () => 1,
|
||
clearTimeout: () => {},
|
||
fetch: async () => {
|
||
calls++;
|
||
if (calls === 1) throw new TypeError('Failed to fetch');
|
||
return { ok: true, status: 200, json: async () => ({ groups: { emoticon: {} } }) };
|
||
},
|
||
});
|
||
const states = [];
|
||
store.subscribe(() => states.push(store.status('assets')));
|
||
const value = await store.load('assets');
|
||
assert.equal(value.groups.emoticon !== undefined, true);
|
||
assert.deepEqual(states, ['missing', 'ready']);
|
||
const warn = console.warn;
|
||
console.warn = () => {};
|
||
try {
|
||
const timers = [];
|
||
const gone = createDataStore({
|
||
timeoutMs: 5,
|
||
retryDelays: [],
|
||
setTimeout: (fn) => { timers.push(fn); return timers.length; },
|
||
clearTimeout: () => {},
|
||
fetch: () => new Promise(() => {}),
|
||
});
|
||
const p = gone.load('local');
|
||
assert.equal(timers.length, 1);
|
||
timers[0]();
|
||
assert.equal(await p, null);
|
||
assert.equal(gone.status('local'), 'missing');
|
||
let n = 0;
|
||
const missing = createDataStore({
|
||
timeoutMs: 5,
|
||
retryDelays: [0],
|
||
wait: async () => {},
|
||
setTimeout: () => 1,
|
||
clearTimeout: () => {},
|
||
fetch: async () => { n++; return { ok: false, status: 404, json: async () => ({}) }; },
|
||
});
|
||
assert.equal(await missing.load('assets'), null);
|
||
assert.equal(missing.status('assets'), 'missing');
|
||
assert.equal(n, 1, 'a 404 is not retried');
|
||
} finally { console.warn = warn; }
|
||
});
|
||
|
||
test('the art-manifest clock is not armed for other files; the default wait is ART_MANIFEST_TIMEOUT_MS', async () => {
|
||
const { createDataStore, ART_MANIFEST_TIMEOUT_MS } = await import('../../public/js/data.js');
|
||
assert.equal(ART_MANIFEST_TIMEOUT_MS, 8000);
|
||
const arms = [];
|
||
let release;
|
||
const store = createDataStore({
|
||
setTimeout: (fn, ms) => { arms.push(ms); return arms.length; },
|
||
clearTimeout: () => {},
|
||
fetch: (url) => new Promise((resolve) => { release = () => resolve(String(url).includes('chess')
|
||
? { ok: false, status: 404, json: async () => ({}) }
|
||
: { ok: true, status: 200, json: async () => ({ ok: 1 }) }); }),
|
||
});
|
||
const local = store.load('local');
|
||
assert.deepEqual(arms, [8000]);
|
||
release();
|
||
assert.equal((await local).ok, 1);
|
||
arms.length = 0;
|
||
const warn = console.warn;
|
||
console.warn = () => {};
|
||
try {
|
||
const chess = store.load('chess');
|
||
await new Promise((r) => setImmediate(r));
|
||
assert.deepEqual(arms, [], 'chess is not on the emote clock');
|
||
assert.equal(store.status('chess'), 'loading');
|
||
release();
|
||
await chess;
|
||
assert.equal(store.status('chess'), 'missing');
|
||
} finally { console.warn = warn; }
|
||
});
|
||
|
||
test('emote UI never renders an emote label as text (aria-label only)', () => {
|
||
const src = readFileSync(path.join(ROOT, 'public/js/ui/emotes.js'), 'utf8');
|
||
assert.doesNotMatch(src, /EMOTE_TEXT|EMOTE_LABEL/, 'no text table in the UI');
|
||
// every use of a label is an attribute value
|
||
for (const m of src.matchAll(/\.label\b/g)) {
|
||
const before = src.slice(Math.max(0, m.index - 40), m.index);
|
||
assert.match(before, /aria-label=\$\{[^}]*$/, `label used outside aria-label: …${before}`);
|
||
}
|
||
});
|
||
});
|