mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 08:12:24 +00:00
railCardBlocks.js is the Vue wrapper on this branch, so main's verbatim legend units move into RailCardBlocks.vue.
787 lines
26 KiB
JavaScript
787 lines
26 KiB
JavaScript
import '../testSupport/registerDom.mjs';
|
||
import test from 'node:test';
|
||
import assert from 'node:assert/strict';
|
||
import { assertSameNode } from '../testSupport/domAssert.mjs';
|
||
import { setLocale } from '../i18n/index.js';
|
||
import { createWeatherPanel } from './weatherPanel.js';
|
||
import { railDocumentFixture as railFixture } from './railTestFixture.mjs';
|
||
import { createAirQualityLayer } from '../layers/airQuality/index.js';
|
||
const ticks = ['2026-09-22T01:00:00Z', '2026-09-22T01:05:00Z'];
|
||
const wind = {
|
||
id: 'wind',
|
||
icon: '🌬',
|
||
summary: {
|
||
label: 'Wind motion',
|
||
coverage: 'Global · 1° grid',
|
||
validTime: ticks[0],
|
||
issuedTime: ticks[0],
|
||
},
|
||
};
|
||
const radar = {
|
||
id: 'weather-radar',
|
||
icon: '◉',
|
||
summary: { label: 'Rain radar', coverage: 'CONUS' },
|
||
};
|
||
function fixture() {
|
||
const f = railFixture();
|
||
const panel = f.document.createElement('div');
|
||
const count = f.document.createElement('span');
|
||
let collapsed = true;
|
||
let clicks = 0;
|
||
panel.hidden = true;
|
||
Object.defineProperty(panel, 'classList', {
|
||
value: { contains: () => collapsed },
|
||
});
|
||
const collapse = {
|
||
click() {
|
||
collapsed = !collapsed;
|
||
clicks++;
|
||
},
|
||
};
|
||
panel.querySelector = (selector) =>
|
||
selector === '#weather-panel-count' ? count : collapse;
|
||
f.container.closest = () => panel;
|
||
const listeners = new Set();
|
||
const calls = [];
|
||
let state = {
|
||
mode: 'latest',
|
||
timeline: ticks,
|
||
products: [{ id: radar.id, shown: ticks[1], selected: ticks[1] }],
|
||
};
|
||
const clock = {
|
||
getState: () => state,
|
||
subscribe: (fn) => {
|
||
listeners.add(fn);
|
||
return () => listeners.delete(fn);
|
||
},
|
||
setTarget: (tick) => calls.push(['target', tick]),
|
||
latest: () => calls.push(['latest']),
|
||
togglePlay: () => calls.push(['play']),
|
||
step: (n) => calls.push(['step', n]),
|
||
};
|
||
return {
|
||
...f,
|
||
panel,
|
||
count,
|
||
collapse,
|
||
clicks: () => clicks,
|
||
calls,
|
||
listeners,
|
||
clock,
|
||
state: (next) => {
|
||
state = { ...state, ...next };
|
||
for (const fn of listeners) fn(state);
|
||
},
|
||
};
|
||
}
|
||
const timelineHost = (f) =>
|
||
f.find((n) => n.className === 'weather-timeline-block');
|
||
const card = (f, id) => f.find((n) => n.dataset.cardId === id);
|
||
const line = (f, id, name) =>
|
||
f.find((n) => n.dataset.lineId === name, card(f, id));
|
||
test('timeline stays visible with any observed product; native preview and transport use the clock', (t) => {
|
||
t.mock.timers.enable({ apis: ['setTimeout'] });
|
||
const f = fixture();
|
||
const view = createWeatherPanel(f);
|
||
view.update([wind]);
|
||
assert.equal(timelineHost(f).hidden, true);
|
||
view.update([wind, radar]);
|
||
assert.equal(timelineHost(f).hidden, false);
|
||
f.state({ timeline: [ticks[0]] });
|
||
assert.equal(timelineHost(f).hidden, false);
|
||
assert.equal(f.find((n) => n.tagName === 'INPUT').disabled, true);
|
||
f.state({ timeline: [] });
|
||
assert.equal(timelineHost(f).hidden, false);
|
||
f.state({ timeline: ticks });
|
||
assert.equal(timelineHost(f).hidden, false);
|
||
const slider = f.find((n) => n.tagName === 'INPUT');
|
||
slider.value = '0';
|
||
slider.dispatchEvent(new Event('input'));
|
||
assert.deepEqual(f.calls, []);
|
||
slider.dispatchEvent(new Event('change'));
|
||
assert.deepEqual(f.calls, [['target', ticks[0]]]);
|
||
f.find((n) => n.textContent === 'Latest' && n.tagName === 'BUTTON').click();
|
||
f.find((n) => n.textContent === 'Play').click();
|
||
assert.deepEqual(f.calls.slice(1), [['latest'], ['play']]);
|
||
slider.dispatchEvent(new Event('input'));
|
||
view.update([wind]);
|
||
t.mock.timers.tick(150);
|
||
assert.equal(f.calls.length, 3, 'hiding cancels pending drag');
|
||
view.destroy();
|
||
assert.equal(f.listeners.size, 0);
|
||
});
|
||
test('ordered articles omit Controls and retain history labels, forecast dates and missing-frame readouts', () => {
|
||
const f = fixture();
|
||
const view = createWeatherPanel(f);
|
||
view.update([radar, wind]);
|
||
const windCard = card(f, 'wind');
|
||
assert.equal(windCard.tagName, 'ARTICLE');
|
||
assertSameNode(windCard.parentElement.children[0], windCard);
|
||
assert.equal(
|
||
f.find((n) => n.dataset.weatherOpen),
|
||
null,
|
||
);
|
||
assert.match(
|
||
line(f, 'wind', 'time').textContent,
|
||
/Forecast · valid .*UTC · issued .*UTC/,
|
||
);
|
||
f.state({ mode: 'history', target: ticks[1] });
|
||
assert.match(line(f, radar.id, 'time').textContent, /01:05 UTC.*synced/);
|
||
assert.match(line(f, 'wind', 'time').textContent, /Does not follow history/);
|
||
f.state({
|
||
products: [{ id: radar.id, shown: ticks[0], selected: ticks[0] }],
|
||
});
|
||
assert.match(line(f, radar.id, 'time').textContent, /01:00 UTC.*nearest/);
|
||
f.state({ products: [{ id: radar.id, shown: null, selected: null }] });
|
||
assert.equal(
|
||
line(f, radar.id, 'time').textContent,
|
||
'No frame within 30 min of 01:05 UTC',
|
||
);
|
||
const global = {
|
||
id: 'weather-satellite',
|
||
summary: { label: 'Satellite clouds', maxGapMinutes: 180 },
|
||
};
|
||
view.update([global]);
|
||
f.state({ products: [{ id: global.id, shown: null, selected: null }] });
|
||
assert.equal(
|
||
line(f, global.id, 'time').textContent,
|
||
'No frame within 3 h of 01:05 UTC',
|
||
);
|
||
view.destroy();
|
||
});
|
||
test('cyclone readout retains advisory, position, intensity, geometry, coverage, legend and source link', () => {
|
||
const f = fixture();
|
||
const view = createWeatherPanel(f);
|
||
const cyclone = {
|
||
id: 'weather-cyclones',
|
||
summary: {
|
||
label: 'Cyclones',
|
||
coverage: 'Atlantic + E/C Pacific',
|
||
detail: 'JULIO · Hurricane · Advisory 10 · 09-22 01:00 UTC',
|
||
status: 'Loading advisories…',
|
||
lines: [
|
||
{ id: 'position', text: 'Position as of 09-22 00:00 UTC' },
|
||
{ id: 'intensity', text: '80 kt · 970 hPa' },
|
||
{ id: 'geometry', text: 'Track/cone awaiting advisory 10' },
|
||
],
|
||
actions: [
|
||
{
|
||
id: 'advisory',
|
||
label: 'Official advisory ↗',
|
||
href: 'https://www.nhc.noaa.gov/advisory',
|
||
},
|
||
],
|
||
},
|
||
legendCategorical: true,
|
||
legend: [
|
||
{ label: 'Advisory center / forecast track', color: '#7fe6ed' },
|
||
{ label: 'Center-track uncertainty cone', color: '#7fe6ed44' },
|
||
],
|
||
};
|
||
view.update([cyclone]);
|
||
assert.equal(timelineHost(f).hidden, true);
|
||
assert.match(
|
||
line(f, cyclone.id, 'time').textContent,
|
||
/JULIO.*Hurricane.*Advisory 10.*UTC/,
|
||
);
|
||
assert.match(line(f, cyclone.id, 'position').textContent, /00:00 UTC/);
|
||
assert.match(line(f, cyclone.id, 'intensity').textContent, /80 kt · 970 hPa/);
|
||
assert.match(
|
||
line(f, cyclone.id, 'geometry').textContent,
|
||
/awaiting advisory 10/,
|
||
);
|
||
const link = f.find(
|
||
(n) => n.tagName === 'A' && n.textContent === 'Official advisory ↗',
|
||
);
|
||
assert.equal(link.href, cyclone.summary.actions[0].href);
|
||
assert.equal(link.tagName, 'A');
|
||
assert.equal(link.rel, 'noopener');
|
||
const entries = f.find((n) => n.className === 'rail-card-legend-entries');
|
||
assert.equal(entries.children.length, 2);
|
||
assert.match(entries.children[0].children[1].textContent, /forecast track/);
|
||
assert.match(entries.children[1].children[1].textContent, /uncertainty cone/);
|
||
assert.equal(f.find((n) => n.className === 'rail-card-ramp').hidden, true);
|
||
view.destroy();
|
||
});
|
||
test('identical updates write nothing and status keeps its line through loading and empty text', () => {
|
||
const f = fixture();
|
||
const view = createWeatherPanel(f);
|
||
for (const entries of [
|
||
[wind, radar],
|
||
[{ ...wind, summary: { ...wind.summary, status: 'Loading' } }],
|
||
[wind],
|
||
[],
|
||
]) {
|
||
view.update(entries);
|
||
const status = entries.length ? line(f, 'wind', 'status') : null;
|
||
f.writes();
|
||
view.update(entries);
|
||
assert.equal(f.writes(), 0);
|
||
if (status) {
|
||
assert.equal(status.hidden, false);
|
||
assert.equal(line(f, 'wind', 'status'), status);
|
||
}
|
||
}
|
||
view.destroy();
|
||
assert.equal(f.container.children.length, 0);
|
||
assert.equal(createWeatherPanel(), null);
|
||
});
|
||
test('count, hidden-empty and first-appearance expansion survive remount and owner collapse', () => {
|
||
const f = fixture();
|
||
let view = createWeatherPanel(f);
|
||
view.update([]);
|
||
assert.equal(f.panel.hidden, true);
|
||
assert.equal(f.clicks(), 0);
|
||
view.update([wind, radar, { id: 'missing' }]);
|
||
assert.equal(f.count.textContent, '2');
|
||
assert.equal(f.panel.hidden, false);
|
||
assert.equal(f.clicks(), 1);
|
||
f.collapse.click();
|
||
view.update([]);
|
||
view.update([wind]);
|
||
assert.equal(f.panel.classList.contains('collapsed'), true);
|
||
assert.equal(f.clicks(), 2);
|
||
assert.equal(f.count.textContent, '1');
|
||
view.destroy();
|
||
assert.equal(f.count.textContent, '0');
|
||
assert.equal(f.panel.hidden, true);
|
||
view = createWeatherPanel(f);
|
||
view.update([radar]);
|
||
assert.equal(f.panel.hidden, false);
|
||
assert.equal(f.clicks(), 2);
|
||
view.destroy();
|
||
const expanded = fixture();
|
||
expanded.collapse.click();
|
||
const other = createWeatherPanel(expanded);
|
||
other.update([wind]);
|
||
assert.equal(expanded.clicks(), 1);
|
||
other.destroy();
|
||
});
|
||
|
||
test('a stored or shared collapse choice is not overridden on first appearance', () => {
|
||
for (const preference of ['stored', 'share']) {
|
||
const f = fixture();
|
||
f.panel.dataset.collapsedPreference = preference;
|
||
const view = createWeatherPanel(f);
|
||
view.update([radar]);
|
||
assert.equal(f.panel.hidden, false);
|
||
assert.equal(
|
||
f.clicks(),
|
||
0,
|
||
`${preference} preference keeps the panel collapsed`,
|
||
);
|
||
view.destroy();
|
||
}
|
||
const f = fixture();
|
||
f.panel.dataset.collapsedPreference = 'default';
|
||
const view = createWeatherPanel(f);
|
||
view.update([radar]);
|
||
assert.equal(f.clicks(), 1, 'a default state still expands once');
|
||
view.destroy();
|
||
});
|
||
|
||
test('settings, reading and footer actions pass the layer id, params and user origin', async () => {
|
||
const { windReadingResult } = await import('../layers/wind/presentation.js');
|
||
const { createWindLayer } = await import('../layers/wind/index.js');
|
||
const layer = createWindLayer({ feed: { getSnapshot: async () => null } });
|
||
const action = layer.getRowControls().summary.actions[0];
|
||
assert.equal(action.label, 'Read wind at map center');
|
||
assert.equal(action.hint, undefined);
|
||
const f = fixture();
|
||
const calls = [];
|
||
const view = createWeatherPanel({
|
||
...f,
|
||
setLayerParams: (...args) => calls.push(args),
|
||
});
|
||
const reading = {
|
||
coordinates: '26.59°N · 123.34°W',
|
||
wind: '6.0 m/s from N',
|
||
model: 'ECMWF',
|
||
validTime: '2026-09-22 06:00 UTC',
|
||
scalarLabel: 'Wind speed',
|
||
scalarValue: '6.0 m/s',
|
||
explanation: 'Interpolated model forecast.',
|
||
};
|
||
const summary = {
|
||
...wind.summary,
|
||
reading,
|
||
result: windReadingResult(reading),
|
||
settings: [
|
||
{
|
||
id: 'units',
|
||
label: 'UNITS',
|
||
chips: [{ id: 'units-mph', label: 'mph', params: { units: 'mph' } }],
|
||
},
|
||
],
|
||
actions: [{ ...action, disabled: false }],
|
||
};
|
||
view.update([{ ...wind, summary }]);
|
||
f.find((n) => n.dataset.actionId === 'read-wind').click();
|
||
f.find((n) => n.dataset.chipId === 'units-mph').click();
|
||
f.find((n) => n.dataset.actionId === 'clear').click();
|
||
assert.deepEqual(calls, [
|
||
['wind', { inspect: true }, { origin: 'user' }],
|
||
['wind', { units: 'mph' }, { origin: 'user' }],
|
||
['wind', { inspect: false }, { origin: 'user' }],
|
||
]);
|
||
const result = f.find((n) => n.className === 'rail-card-result');
|
||
const header = result.children[0];
|
||
assert.equal(header.className, 'rail-card-result-header');
|
||
assert.equal(header.children[0].textContent, 'WIND AT 26.59°N 123.34°W');
|
||
assert.equal(header.children[1].textContent, '×');
|
||
assert.equal(header.children[1].getAttribute('aria-label'), 'Clear reading');
|
||
assert.deepEqual(
|
||
[...result.children[1].children[0].children].map((n) => [
|
||
n.dataset.lineId,
|
||
n.textContent,
|
||
]),
|
||
[
|
||
['wind', '6.0 m/s from N'],
|
||
['meta', 'ECMWF · valid 09-22 06:00 UTC'],
|
||
['scalar', 'Wind speed · 6.0 m/s'],
|
||
['explanation', 'Interpolated model forecast.'],
|
||
],
|
||
);
|
||
assert.equal(
|
||
f.find((n) => n.dataset.actionId === 'read-wind').textContent,
|
||
'Read wind at map center',
|
||
);
|
||
assert.equal(
|
||
f.find((n) => n.className === 'rail-card-action-hint').hidden,
|
||
true,
|
||
);
|
||
layer.destroy();
|
||
const body = card(f, 'wind').children[1];
|
||
assert.deepEqual(
|
||
[...body.children].map((n) => n.dataset.blockId),
|
||
['details', 'settings', 'actions', 'reading'],
|
||
);
|
||
view.destroy();
|
||
});
|
||
|
||
const cyclone = {
|
||
id: 'weather-cyclones',
|
||
icon: '◉',
|
||
summary: {
|
||
label: 'Cyclones',
|
||
compact: '3 active storms · Fay selected',
|
||
detail: 'Fay · Advisory 3',
|
||
},
|
||
list: {
|
||
items: [
|
||
{
|
||
id: 'fay',
|
||
text: 'Fay · Tropical storm · 40 kt',
|
||
active: true,
|
||
params: { stormId: 'fay', focus: true },
|
||
},
|
||
],
|
||
},
|
||
};
|
||
const satellite = {
|
||
id: 'weather-satellite',
|
||
icon: '☁',
|
||
summary: { label: 'Satellite clouds' },
|
||
};
|
||
const lightning = {
|
||
id: 'weather-lightning',
|
||
icon: 'ϟ',
|
||
summary: { label: 'Lightning density' },
|
||
};
|
||
const opened = (f) =>
|
||
[cyclone, wind, radar, satellite, lightning]
|
||
.filter(({ id }) => card(f, id)?.dataset.open === 'true')
|
||
.map(({ id }) => id);
|
||
const clickHeader = (f, id) => card(f, id).children[0].click();
|
||
|
||
test('cyclones lead, and observed history owns one bordered group with only active products in scope', () => {
|
||
const f = fixture();
|
||
const view = createWeatherPanel(f);
|
||
view.update([lightning, radar, wind, cyclone, satellite]);
|
||
const root = f.container.children[0];
|
||
assert.deepEqual(
|
||
[...root.children[0].children].map((n) => n.dataset.cardId),
|
||
['weather-cyclones', 'wind'],
|
||
);
|
||
const group = f.find((n) => n.className === 'weather-observed-group');
|
||
assertSameNode(root.children[1], group);
|
||
assert.equal(group.children[0].textContent, 'Observed history');
|
||
assert.equal(
|
||
group.children[1].textContent,
|
||
'Rain radar · Satellite clouds · Lightning density',
|
||
);
|
||
assertSameNode(group.children[2], timelineHost(f));
|
||
assert.deepEqual(
|
||
[...group.children[3].children].map((n) => n.dataset.cardId),
|
||
['weather-radar', 'weather-satellite', 'weather-lightning'],
|
||
);
|
||
assert.deepEqual(opened(f), ['weather-cyclones']);
|
||
assert.equal(
|
||
card(f, cyclone.id).children[1].children[0].dataset.blockId,
|
||
'list',
|
||
);
|
||
view.update([wind, satellite]);
|
||
assert.equal(group.children[1].textContent, 'Satellite clouds');
|
||
view.update([wind]);
|
||
assert.equal(group.hidden, true);
|
||
view.destroy();
|
||
});
|
||
|
||
test('accordion changes only on headers, newly enabled layers and loss of the open layer', () => {
|
||
const f = fixture();
|
||
const calls = [];
|
||
let view = createWeatherPanel({
|
||
...f,
|
||
setLayerParams: (...args) => calls.push(args),
|
||
});
|
||
view.update([wind, cyclone, radar]);
|
||
assert.deepEqual(opened(f), [cyclone.id]);
|
||
clickHeader(f, wind.id);
|
||
clickHeader(f, wind.id);
|
||
assert.deepEqual(opened(f), [wind.id]);
|
||
assert.equal(
|
||
card(f, wind.id).children[0].getAttribute('aria-expanded'),
|
||
'true',
|
||
);
|
||
assert.equal(
|
||
card(f, cyclone.id).children[0].getAttribute('aria-expanded'),
|
||
'false',
|
||
);
|
||
assert.equal(card(f, cyclone.id).children[1].hidden, true);
|
||
assert.deepEqual(calls, [], 'opening/collapsing never selects a storm');
|
||
f.state({ mode: 'history', target: ticks[0] });
|
||
view.update([
|
||
wind,
|
||
{ ...cyclone, summary: { ...cyclone.summary, status: 'Updated' } },
|
||
radar,
|
||
]);
|
||
assert.deepEqual(opened(f), [wind.id]);
|
||
view.update([wind, cyclone, radar, lightning, satellite]);
|
||
assert.deepEqual(opened(f), [satellite.id], 'last newly enabled entry wins');
|
||
view.update([wind, cyclone, radar, lightning]);
|
||
assert.deepEqual(
|
||
opened(f),
|
||
[cyclone.id],
|
||
'disabled open layer falls back to first in card order',
|
||
);
|
||
clickHeader(f, radar.id);
|
||
view.destroy();
|
||
view = createWeatherPanel(f);
|
||
view.update([]);
|
||
view.update([wind, cyclone, radar]);
|
||
assert.deepEqual(opened(f), [radar.id], 'explicit choice survives remount');
|
||
view.update([]);
|
||
view.update([wind]);
|
||
assert.deepEqual(opened(f), [wind.id]);
|
||
view.destroy();
|
||
});
|
||
|
||
test('first appearance without storms chooses the first card and late storm arrival never steals it', () => {
|
||
const f = fixture();
|
||
const view = createWeatherPanel(f);
|
||
view.update([satellite, wind]);
|
||
assert.deepEqual(opened(f), [wind.id]);
|
||
view.update([satellite, wind, { ...cyclone, list: { items: [] } }]);
|
||
assert.deepEqual(opened(f), [cyclone.id]);
|
||
clickHeader(f, wind.id);
|
||
view.update([satellite, wind, cyclone]);
|
||
assert.deepEqual(opened(f), [wind.id]);
|
||
view.destroy();
|
||
});
|
||
|
||
test('compact lines show observation age, forecast validity, storm selection or accented status', (t) => {
|
||
t.mock.timers.enable({
|
||
apis: ['Date'],
|
||
now: Date.parse('2026-09-22T01:13:00Z'),
|
||
});
|
||
const f = fixture();
|
||
const view = createWeatherPanel(f);
|
||
view.update([cyclone, wind, radar]);
|
||
const compact = (id) =>
|
||
f.find((n) => n.className.startsWith('rail-card-compact'), card(f, id));
|
||
assert.equal(compact(radar.id).textContent, '09-22 01:05 UTC · 8m ago');
|
||
assert.equal(
|
||
compact(wind.id).textContent,
|
||
'Forecast · valid 09-22 01:00 UTC',
|
||
);
|
||
f.state({ mode: 'history', target: ticks[1] });
|
||
assert.equal(
|
||
compact(radar.id).textContent,
|
||
'09-22 01:05 UTC · 8m ago · synced',
|
||
);
|
||
assert.equal(
|
||
compact(wind.id).textContent,
|
||
'Forecast · valid 09-22 01:00 UTC',
|
||
);
|
||
assert.match(
|
||
line(f, wind.id, 'time').textContent,
|
||
/issued .*Does not follow history/,
|
||
);
|
||
f.state({
|
||
products: [{ id: radar.id, shown: ticks[0], selected: ticks[0] }],
|
||
});
|
||
assert.equal(
|
||
compact(radar.id).textContent,
|
||
'09-22 01:00 UTC · 13m ago · nearest',
|
||
);
|
||
clickHeader(f, wind.id);
|
||
assert.equal(
|
||
compact(cyclone.id).textContent,
|
||
'3 active storms · Fay selected',
|
||
);
|
||
view.update([
|
||
cyclone,
|
||
wind,
|
||
{
|
||
...radar,
|
||
summary: { ...radar.summary, status: 'Map center outside coverage' },
|
||
},
|
||
]);
|
||
assert.equal(compact(radar.id).textContent, 'Map center outside coverage');
|
||
assert.match(compact(radar.id).className, /status/);
|
||
view.destroy();
|
||
});
|
||
|
||
test('all five headers retain descriptor icons and disclosure state when opened or compact', () => {
|
||
const f = fixture();
|
||
const view = createWeatherPanel(f);
|
||
const entries = [cyclone, wind, radar, satellite, lightning];
|
||
view.update(entries);
|
||
for (const active of entries) {
|
||
clickHeader(f, active.id);
|
||
for (const entry of entries) {
|
||
const article = card(f, entry.id);
|
||
const open = entry === active;
|
||
assert.equal(article.dataset.open, String(open));
|
||
assert.equal(article.classList.contains('is-open'), open);
|
||
const header = article.children[0];
|
||
const labels = header.children[0];
|
||
const heading = labels.children[0];
|
||
assert.equal(
|
||
labels.children[1].textContent,
|
||
entry.summary.coverage || '',
|
||
);
|
||
assert.equal(
|
||
labels.children[1].classList.contains('rail-card-badge'),
|
||
true,
|
||
);
|
||
assert.equal(header.children[1].className, 'rail-card-disclosure');
|
||
assert.equal(heading.children[0].className, 'data-icon');
|
||
assert.equal(heading.children[0].textContent, entry.icon);
|
||
assert.equal(heading.children[0].hidden, false);
|
||
assert.equal(heading.children[1].textContent, entry.summary.label);
|
||
assert.equal(
|
||
heading.children[1].getAttribute('title'),
|
||
entry.summary.label,
|
||
);
|
||
assert.equal(
|
||
heading.children[1].classList.contains('rail-card-nowrap'),
|
||
true,
|
||
);
|
||
assert.equal(header.children[1].textContent, open ? '▾' : '▸');
|
||
}
|
||
}
|
||
view.destroy();
|
||
});
|
||
|
||
test('a change of open card scrolls its header into view once; refreshes never move the body', (t) => {
|
||
const f = fixture();
|
||
const body = f.container;
|
||
const writes = [];
|
||
const intoView = [];
|
||
const rects = new Map();
|
||
let scrollTop = 240;
|
||
Object.defineProperty(body, 'scrollTop', {
|
||
configurable: true,
|
||
get: () => scrollTop,
|
||
set: (value) => {
|
||
writes.push(value);
|
||
scrollTop = value;
|
||
},
|
||
});
|
||
Object.defineProperty(body, 'clientHeight', { value: 200 });
|
||
body.getBoundingClientRect = () => ({ top: 100, height: 200 });
|
||
const create = f.document.createElement;
|
||
t.after(() => {
|
||
f.document.createElement = create;
|
||
});
|
||
f.document.createElement = (tag) => {
|
||
const node = create.call(f.document, tag);
|
||
node.getBoundingClientRect = function () {
|
||
return rects.get(this.dataset.cardId) || { top: 0, height: 0 };
|
||
};
|
||
node.scrollIntoView = function () {
|
||
intoView.push(this.dataset.cardId);
|
||
};
|
||
return node;
|
||
};
|
||
// Rectangles are viewport coordinates; the body's visible top is at 100.
|
||
const place = (id, top, height) => rects.set(id, { top: 100 + top, height });
|
||
const view = createWeatherPanel(f);
|
||
view.update([cyclone, wind, radar]);
|
||
assert.deepEqual(opened(f), [cyclone.id]);
|
||
|
||
// Plain refreshes: clock, identical and changed descriptors, the open header.
|
||
f.state({ mode: 'history', target: ticks[0] });
|
||
view.update([cyclone, wind, radar]);
|
||
view.update([
|
||
{ ...cyclone, summary: { ...cyclone.summary, status: 'Updated' } },
|
||
wind,
|
||
radar,
|
||
]);
|
||
clickHeader(f, cyclone.id);
|
||
assert.deepEqual(writes, [], 'no scroll writes without a change of card');
|
||
|
||
// Opened below the fold: the smallest move that shows the whole card.
|
||
place(radar.id, 150, 120);
|
||
clickHeader(f, radar.id);
|
||
assert.deepEqual(opened(f), [radar.id]);
|
||
assert.deepEqual(writes, [240 + 70], 'one write, placed by the opened card');
|
||
|
||
// Taller than the body: the header goes to the top.
|
||
place(wind.id, 40, 480);
|
||
clickHeader(f, wind.id);
|
||
assert.deepEqual(writes.slice(1), [310 + 40]);
|
||
|
||
// Header left above the view by the collapse: back to the top edge.
|
||
place(cyclone.id, -60, 120);
|
||
clickHeader(f, cyclone.id);
|
||
assert.deepEqual(writes.slice(2), [350 - 60]);
|
||
|
||
// Already fully visible: nothing to do.
|
||
place(radar.id, 20, 100);
|
||
clickHeader(f, radar.id);
|
||
assert.equal(writes.length, 3);
|
||
|
||
// A newly enabled layer opens and is revealed the same way.
|
||
place(lightning.id, 190, 60);
|
||
view.update([cyclone, wind, radar, lightning]);
|
||
assert.deepEqual(opened(f), [lightning.id]);
|
||
assert.deepEqual(writes.slice(3), [290 + 50]);
|
||
|
||
f.state({ mode: 'latest' });
|
||
view.update([cyclone, wind, radar, lightning]);
|
||
assert.equal(writes.length, 4, 'refresh after a reveal leaves it alone');
|
||
assert.deepEqual(intoView, [], 'ancestor scrollers are never moved');
|
||
view.destroy();
|
||
});
|
||
test('history time keeps the hour whatever the length of the localized date', () => {
|
||
for (const locale of ['en', 'es', 'ru']) {
|
||
setLocale(locale);
|
||
try {
|
||
const f = fixture();
|
||
const view = createWeatherPanel(f);
|
||
view.update([wind, radar]);
|
||
const ends = f.find((n) => n.className === 'rail-timeline-endpoints');
|
||
assert.deepEqual(
|
||
[...ends.children].map((n) => n.textContent),
|
||
['01:00 UTC', '01:05 UTC'],
|
||
locale,
|
||
);
|
||
f.state({ mode: 'history', target: ticks[1] });
|
||
assert.match(
|
||
line(f, radar.id, 'time').textContent,
|
||
/(^|[^\d:])01:05 UTC/,
|
||
locale,
|
||
);
|
||
f.state({ products: [{ id: radar.id, shown: null, selected: null }] });
|
||
assert.match(
|
||
line(f, radar.id, 'time').textContent,
|
||
/(^|[^\d:])01:05 UTC/,
|
||
locale,
|
||
);
|
||
view.destroy();
|
||
} finally {
|
||
setLocale('en');
|
||
}
|
||
}
|
||
});
|
||
|
||
test('air-quality readout renders its band legend, Canada coverage and worst-first list', async () => {
|
||
const observedMs = Date.now() - 10 * 60_000;
|
||
const reading = (stationId, value, band, name) => ({
|
||
id: `eccc:${stationId}`,
|
||
provider: 'eccc',
|
||
scale: 'AQHI',
|
||
value,
|
||
band,
|
||
stationId,
|
||
name,
|
||
zone: 'on',
|
||
lat: 43.65,
|
||
lon: -79.38,
|
||
observedMs,
|
||
color: '#4cc9f0',
|
||
label: String(value),
|
||
risk: `${band} risk`,
|
||
note: null,
|
||
});
|
||
const layer = createAirQualityLayer({
|
||
source: {
|
||
getSnapshot: async () => [
|
||
reading('B', 8, 'high', 'Hamilton'),
|
||
reading('A', 2, 'low', 'Toronto'),
|
||
],
|
||
},
|
||
overlayHost: { setEntries() {}, setVisible() {}, clearSource() {} },
|
||
});
|
||
layer.init({ dataSources: { add() {}, remove() {} } });
|
||
layer.enable();
|
||
await layer.update();
|
||
const f = fixture();
|
||
const view = createWeatherPanel(f);
|
||
view.update([{ id: layer.id, icon: layer.icon, ...layer.getRowControls() }]);
|
||
const aq = card(f, 'air-quality');
|
||
assert.ok(aq, 'the air-quality card is shown');
|
||
assert.equal(aq.dataset.open, 'true');
|
||
assert.match(
|
||
f.find((n) => n.classList?.contains?.('rail-card-badge'), aq).textContent,
|
||
/Canada only/,
|
||
);
|
||
assert.match(line(f, 'air-quality', 'status').textContent, /2 stations/);
|
||
const entries = f.find((n) => n.className === 'rail-card-legend-entries', aq);
|
||
assert.equal(entries.hidden, false);
|
||
assert.deepEqual(
|
||
[...entries.children].map((entry) => entry.children[1].textContent),
|
||
['Low', 'Moderate', 'High', 'Very High'],
|
||
);
|
||
assert.equal(
|
||
f.find((n) => n.className === 'rail-card-ramp', aq).hidden,
|
||
true,
|
||
);
|
||
const list = f.find((n) => n.dataset.blockId === 'list', aq);
|
||
assert.equal(list.hidden, false);
|
||
assert.deepEqual(
|
||
[...list.children].map((item) =>
|
||
[...item.children[0].children].map((part) => part.textContent).join(' '),
|
||
),
|
||
['AQHI 8 Hamilton · high risk', 'AQHI 2 Toronto · low risk'],
|
||
);
|
||
view.destroy();
|
||
layer.destroy();
|
||
});
|
||
test('source-supplied legend units are shown as given; catalog units are translated', () => {
|
||
setLocale('ru');
|
||
try {
|
||
const f = fixture();
|
||
const view = createWeatherPanel(f);
|
||
const row = (summary) => ({
|
||
...radar,
|
||
summary: { ...radar.summary, units: 'km/h', ...summary },
|
||
legend: [
|
||
{ label: '1', color: '#000000' },
|
||
{ label: '2', color: '#ffffff' },
|
||
],
|
||
});
|
||
const scale = () =>
|
||
f.find((n) => n.className === 'rail-card-scale').textContent;
|
||
view.update([row()]);
|
||
assert.equal(scale(), '1 — 2 км/ч');
|
||
view.update([row({ unitsVerbatim: true })]);
|
||
assert.equal(scale(), '1 — 2 km/h');
|
||
view.destroy();
|
||
} finally {
|
||
setLocale('en');
|
||
}
|
||
});
|