Merge branch 'main' into samehkhamis/kit-styles

This commit is contained in:
Sameh Khamis authored and GitHub committed 2026-11-19 00:17:02 -08:00
commit c58f9fbdc6
14 files changed
+628 -38

No files matched your search

+4
View File
@@ -0,0 +1,4 @@
- Keep the left and right panel rails clear of obstacles across the middle
of a short window, such as the World Timeline or a card: both rails put
the panels on the side with more room, whatever order the obstacles come
in (manjunath22466, samehkhamis, #1837).
@@ -0,0 +1,4 @@
- "Villages near" a name picks the place of that name in view over a far
bigger namesake, a place lookup reads the detail tiles within 500 km at
most, and rebuilding the places pack never leaves it half removed
(manjunath22466, samehkhamis, #1838).
+17 -3
View File
@@ -966,7 +966,8 @@ the fleet set loaded at startup, so opening a card fetches no model.
country and Wikidata id. `src/data/wikidataCities.js` reads it on the first
lookup and answers `nearestCity` (the largest city within 12 km, else the
nearest within 60 km), `citiesAround`, `findPlace` ("Paris, France", or the
nearest namesake within 150 km of the view, else the largest) and
nearest namesake within 150 km of the view, else the largest; asked to, it
counts the smaller places of the detail tiles near the view too) and
`countryName`. Names match without case or accents ("lodz" finds Łódź). The
app never calls Wikidata; `scripts/build-wikidata-cities.mjs` rebuilds the
pack and fails if well-known cities are missing or a known grouping such as
@@ -1197,7 +1198,15 @@ Cesium's credit box wraps from 1200px, as before; the phone shell, clean
view, recording and scene playback lay the line out themselves.
The left rail treats the centered World Timeline and voice control as
obstacles only where they reach a laid-out panel, not the stack's
transparent gutter.
transparent gutter. Obstacles across the middle of the window (common in
short windows) form one block with any obstacle that leaves no room between
itself and them, and both rails put their panels on whichever side of that
block has more room up to the next obstacle, above it on a tie, whatever
order the obstacles come in (`bandBesideMidpointObstacles` in
`src/ui/panelRailGeometry.js`); on the left rail the panels may then rise
above the corridor's usual top to use all the room above. With no room on
either side (a side under 8% of the window's height counts as none) the
obstacles are read as before.
Wind appears in the Weather group before Audio. The surface-weather prototype
uses keyless NOAA GFS or ECMWF IFS forecasts on an approximately 1° display grid.
@@ -8249,7 +8258,12 @@ clears them but the browser's own site data. Setting `PHOTON_URL`
empty turns the suggestions off along with it. Small places come from the
bundled Wikidata packs and are never looked up online; a small place with
the name of a city within 3 km in the same country is that city, and only
the city is listed. At most 64 detail tiles are kept in memory, the least
the city is listed. A place named in "villages near …" is the nearest of
that name within 150 km of the view, small places included, so a village in
view comes before a bigger namesake far away; with none near, the largest
city of the name. Small places are looked for within 500 km at most, so a
lookup asked for a wider radius reads only the detail tiles around its
centre (the search box asks for 150 km at most). At most 64 detail tiles are kept in memory, the least
recently used dropped first.
### Place-search providers
+21 -4
View File
@@ -39,6 +39,8 @@ import { mkdir, readdir, readFile, rm, writeFile } from 'node:fs/promises';
import path from 'node:path';
import { fileURLToPath } from 'node:url';
import {
keepBuiltIfUnchanged,
keepPackBuiltIfUnchanged,
placeTileFiles,
withoutCities,
withoutNearTwins,
@@ -68,6 +70,8 @@ const outDir = path.join(
: 'src/data/local_data/wikidata_cities',
);
/** A file's text, or undefined when there is none yet. */
const readIfThere = (file) => readFile(file, 'utf8').catch(() => undefined);
const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
const qid = (uri) => uri.slice(uri.lastIndexOf('/') + 1);
@@ -499,17 +503,30 @@ if (tilesMode) {
count: tileRows.length,
maxPopulation,
});
// Tiles from an earlier build that this one has no rows for go.
// The new files are all written before tiles from an earlier build that
// this one has no rows for go, so a build that stops part way never leaves
// an index naming a removed tile.
const earlier = new Map();
for (const name of await readdir(outDir))
if (/^-?\d+_-?\d+\.json$|^index\.json$|^files\.js$/.test(name))
earlier.set(name, await readFile(path.join(outDir, name), 'utf8'));
keepPackBuiltIfUnchanged(files, earlier);
for (const [name, text] of files)
await writeFile(path.join(outDir, name), text);
for (const name of await readdir(outDir))
if (/^-?\d+_-?\d+\.json$/.test(name) && !files.has(name))
await rm(path.join(outDir, name));
for (const [name, text] of files)
await writeFile(path.join(outDir, name), text);
console.log(
`Wrote ${tileRows.length} places in ${files.size - 2} tiles to ${path.relative(root, outDir)}`,
);
process.exit(0);
}
const file = path.join(outDir, 'cities.json');
await writeFile(file, `${JSON.stringify({ meta, rows })}\n`);
await writeFile(
file,
keepBuiltIfUnchanged(
`${JSON.stringify({ meta, rows })}\n`,
await readIfThere(file),
),
);
console.log(`Wrote ${rows.length} places to ${path.relative(root, file)}`);
+45
View File
@@ -89,6 +89,51 @@ export function placeTileFiles(rows, meta) {
return files;
}
/**
* A pack file's new text, keeping the earlier build's `meta.built` when
* nothing else in the file changed, so rebuilding unchanged data leaves the
* file as it was. A file that does not hold all of its pack's data (the
* places index) is passed through this only when the rest of the pack is
* unchanged too.
* @param {string} text The new file, JSON with a `meta.built` stamp.
* @param {string | undefined} earlier The file as it is now, if there is one.
*/
export function keepBuiltIfUnchanged(text, earlier) {
if (!earlier) return text;
let before;
try {
before = JSON.parse(earlier);
} catch {
return text;
}
const after = JSON.parse(text);
if (typeof before?.meta?.built !== 'string' || !after.meta) return text;
const unstamped = (value) =>
JSON.stringify({ ...value, meta: { ...value.meta, built: null } });
if (unstamped(before) !== unstamped(after)) return text;
return `${JSON.stringify({ ...after, meta: { ...after.meta, built: before.meta.built } })}\n`;
}
/**
* Keeps the earlier build's `meta.built` in the places pack's index when the
* rebuild changed nothing: every tile and `files.js` the same text, no tile
* of the earlier build left out, and nothing else in the index changed. The
* index holds only row counts, so it alone cannot tell.
* @param {Map<string, string>} files The new pack, as placeTileFiles gives it; its index is replaced in place.
* @param {Map<string, string>} earlier The pack's files on disk now, by name.
*/
export function keepPackBuiltIfUnchanged(files, earlier) {
for (const name of earlier.keys())
if (name !== 'index.json' && !files.has(name)) return files;
for (const [name, text] of files)
if (name !== 'index.json' && earlier.get(name) !== text) return files;
files.set(
'index.json',
keepBuiltIfUnchanged(files.get('index.json'), earlier.get('index.json')),
);
return files;
}
const kmBetween = (a, b) =>
greatCircleKm({ lat: a[1], lon: a[2] }, { lat: b[1], lon: b[2] });
+138
View File
@@ -31,6 +31,7 @@ import {
speedRulerStep,
speedRulerTicks,
} from './cockpitMath.js';
import { bandBesideMidpointObstacles } from './ui/panelRailGeometry.js';
test('cockpit presentation updates are throttled independently of camera frames', () => {
assert.equal(cockpitUiUpdateDue(1000, 0, 100), true);
@@ -286,6 +287,143 @@ test('HUD rail layout constrains an oversized panel to the safe corridor', () =>
assert.equal(layout.constrained, true);
});
test('HUD rail layout keeps a short window clear of an obstacle across its midpoint', () => {
// 480px window: midpoint 240. Each obstacle is neither wholly above nor
// wholly below the midpoint, and must still limit the band.
const above = resolveHudRailLayout({
viewportHeight: 480,
panelHeight: 120,
laneLeft: 20,
laneRight: 340,
baseTop: 40,
baseBottom: 460,
gap: 10,
obstacles: [{ left: 0, right: 400, top: 200, bottom: 300 }],
});
// Room above: 200 - 10 - 40 = 150; below: 460 - 310 = 150. A tie keeps the
// band above the obstacle.
assert.equal(above.safeTop, 40);
assert.equal(above.safeBottom, 190);
assert(above.top + Math.min(120, above.maxHeight) <= 190);
const below = resolveHudRailLayout({
viewportHeight: 480,
panelHeight: 120,
laneLeft: 20,
laneRight: 340,
baseTop: 40,
baseBottom: 460,
gap: 10,
obstacles: [{ left: 0, right: 400, top: 120, bottom: 260 }],
});
// Room above: 70; below: 190. The band goes under the obstacle.
assert.equal(below.safeTop, 270);
assert.equal(below.safeBottom, 460);
assert(below.top >= 270);
});
test('HUD rail layout leaves the band as it is when an obstacle across the midpoint leaves no room', () => {
const layout = resolveHudRailLayout({
viewportHeight: 480,
panelHeight: 120,
laneLeft: 20,
laneRight: 340,
baseTop: 100,
baseBottom: 400,
gap: 10,
obstacles: [{ left: 0, right: 400, top: 80, bottom: 420 }],
});
assert.equal(layout.safeTop, 100);
assert.equal(layout.safeBottom, 400);
});
test('HUD rail layout reads several obstacles across the midpoint the same in any order', () => {
const a = { left: 0, right: 400, top: 100, bottom: 260 };
const b = { left: 0, right: 400, top: 200, bottom: 470 };
const layoutWith = (obstacles) =>
resolveHudRailLayout({
viewportHeight: 480,
panelHeight: 120,
laneLeft: 20,
laneRight: 340,
baseTop: 40,
baseBottom: 460,
gap: 10,
obstacles,
});
// Together they cover 100 to 470: the only room is above, 40 to 90.
for (const layout of [layoutWith([a, b]), layoutWith([b, a])]) {
assert.equal(layout.safeTop, 40);
assert.equal(layout.safeBottom, 90);
assert.equal(layout.maxHeight, 50);
}
});
test('HUD rail layout counts obstacles beside those across the midpoint', () => {
const band = (obstacles) => {
const layout = resolveHudRailLayout({
viewportHeight: 480,
panelHeight: 120,
laneLeft: 20,
laneRight: 340,
baseTop: 40,
baseBottom: 460,
gap: 10,
obstacles: obstacles.map(([top, bottom]) => ({
left: 0,
right: 400,
top,
bottom,
})),
});
return [layout.safeTop, layout.safeBottom];
};
// One inside the span below the midpoint: 150px below the span, 50 above.
assert.deepEqual(band([[100, 300], [250, 280]]), [310, 460]);
// One touching the midpoint from below: 190px below, 100 above.
assert.deepEqual(band([[150, 260], [240, 250]]), [270, 460]);
// One inside the span above the midpoint: 150px above, 50 below.
assert.deepEqual(band([[200, 400], [210, 230]]), [40, 190]);
// A lower obstacle past the span limits the room below it: 100px between
// them against 70 above, and with a taller one only 60, so above.
assert.deepEqual(band([[120, 260], [380, 420]]), [270, 370]);
assert.deepEqual(band([[120, 260], [340, 420]]), [40, 110]);
// Neighbours exactly two gaps away leave no room between: one block, 100
// to 400, and a tie (50px a side) goes above.
assert.deepEqual(band([[100, 180], [200, 300], [320, 400]]), [40, 90]);
// A neighbour exactly two gaps below joins it too: 150 to 300, 100px
// above against 150 below.
assert.deepEqual(band([[150, 250], [270, 300]]), [310, 460]);
// A side under 8% of the window (38.4px) is no room: 30px above, none
// below, so the band stays as it is.
assert.deepEqual(band([[80, 455]]), [40, 460]);
// Exactly the minimum is enough.
const exact = bandBesideMidpointObstacles({
midpoint: 240,
top: 40,
bottom: 460,
obstacles: [{ top: 90, bottom: 465 }],
gap: 10,
minimum: 40,
});
assert.deepEqual([exact?.top, exact?.bottom], [40, 80]);
});
test('HUD rail layout keeps a band beside a midpoint obstacle inside its own edges', () => {
const layout = resolveHudRailLayout({
viewportHeight: 480,
panelHeight: 80,
laneLeft: 20,
laneRight: 340,
baseTop: 350,
baseBottom: 460,
gap: 10,
obstacles: [{ left: 0, right: 400, top: 100, bottom: 260 }],
});
assert.equal(layout.safeTop, 350);
assert.equal(layout.safeBottom, 460);
});
test('HUD rail layout can anchor controls to the start of the safe corridor', () => {
const layout = resolveHudRailLayout({
viewportHeight: 1000,
@@ -36,7 +36,13 @@ places without an English label.
The build runs one query at a time with pauses and honours the service's
Retry-After; it takes about ten minutes. It fails if a short list of
well-known cities is missing from the result, or a known grouping gets in.
`meta.built` keeps its earlier date when the rows are unchanged.
**Limits:** populations are whatever Wikidata states and differ in date and
definition between places (city proper, municipality, urban district). Some
districts and suburbs appear as their own rows.
**Finding a place by name:** `findPlace` takes the nearest place of the name
within 150 km of the view, else the largest city of the name. When asked,
the smaller places of `../wikidata_places` near the view count too, so a
village in view comes before a bigger namesake far away.
+15 -4
View File
@@ -1,8 +1,11 @@
# Wikidata places detail tiles
Smaller towns and villages, below the cut-off of the cities pack
(`../wikidata_cities`), for "places nearby" around one picked or named spot. Read by `placesNear` in `src/data/wikidataCities.js`. The app reads
these files; it does not call Wikidata or any place service for them.
(`../wikidata_cities`), for "places nearby" around one picked or named spot. Read by `placesNear` in `src/data/wikidataCities.js`, and by `findPlace`
when asked to look for a small place by name near the view: a place of that
name in view, or close to it, comes before a bigger city of the name far
away. The app reads these files; it does not call Wikidata or any place
service for them.
| File | Contents |
|------|----------|
@@ -17,7 +20,12 @@ entry in the index.
**Loading:** nothing here loads with the app. A lookup reads `files.js` and
the index once, then only the tiles its search box touches (one for a short
radius well inside a tile, more near tile edges and for wider searches),
once each; at most 64 tiles are kept in memory, the least recently used
once each. A lookup reaches 500 km at most (`PLACE_TILE_KM`; the search box
asks for 150 km at most), so one asked for a wider radius reads only the
tiles around its centre: at most one
tile past the centre's own on each side, a few more columns toward the
poles, and never all 732. Cities still count to the full radius. At most
64 tiles are kept in memory, the least recently used
dropped first. Rows whose name has no letter (one row, `380` in Nicaragua) are
dropped when a tile is read.
@@ -39,7 +47,10 @@ names from Wikidata (CC0)" as a courtesy once a name from the pack is shown.
`node scripts/build-wikidata-cities.mjs --tiles --min-population 1000 --max-population 15000`.
It writes only to this folder (tiles, `index.json`, `files.js`, through
`scripts/wikidataPlaceTiles.mjs`) and leaves `../wikidata_cities` alone. It
runs one query at a time with pauses and takes a long while.
runs one query at a time with pauses and takes a long while. The new files
are all written before tiles that the new build has no rows for are
removed, and `meta.built` keeps its earlier date when no tile and
nothing else in `index.json` changed.
**Reproducibility:** the step from rows to files is checked offline:
`src/tooling/wikidataPlaceTiles.test.mjs` sorts the shipped rows as the
+50 -25
View File
@@ -217,6 +217,15 @@ const TILE_DEG = 5;
* far more than one lookup touches, and bounds what a long session keeps.
*/
const MAX_TILES = 64;
/**
* How far out small places are looked for, in km. 500 km is under the 556 km
* that 5 degrees of latitude span, so a lookup's tile box reaches at most one
* tile past the point's own on each side: 3 rows, and 3 columns at the
* equator (more toward the poles, where tiles narrow). A lookup asked for a
* wider radius, up to the whole globe, still reads only those tiles; cities
* count to its full radius.
*/
export const PLACE_TILE_KM = 500;
const NAMED = /\p{L}/u;
const tiles = new Map();
let loadTileIndex;
@@ -248,9 +257,11 @@ async function readPlaceTiles(latitude, longitude, radiusKm, fetchImpl) {
readPlacePack(INDEX_URL(), fetchImpl),
);
const index = await loadTileIndex();
const keys = tileKeysAround(latitude, longitude, radiusKm).filter(
(key) => index.tiles[key],
);
const keys = tileKeysAround(
latitude,
longitude,
Math.min(radiusKm, PLACE_TILE_KM),
).filter((key) => index.tiles[key]);
// A tile that cannot be read is left out: the places of the others,
// and the cities, are still the answer.
const settled = await Promise.allSettled(
@@ -281,7 +292,10 @@ async function readPlacePack(url, fetchImpl) {
return response.json();
}
/** Named cities and smaller places around one point, nearest first. */
/**
* Named cities and smaller places around one point, nearest first. Smaller
* places are looked for within PLACE_TILE_KM only.
*/
export async function placesNear(
{ latitude, longitude, radiusKm = 10, limit = 6 },
fetchImpl = (...args) => globalThis.fetch(...args),
@@ -325,7 +339,14 @@ export async function placesNear(
const found = [
...cities.filter((city) => city.distanceKm <= radius),
...detail
.flatMap((source) => citiesWithin(source, latitude, longitude, radius))
.flatMap((source) =>
citiesWithin(
source,
latitude,
longitude,
Math.min(radius, PLACE_TILE_KM),
),
)
.filter((place) => !twinOfCity(place)),
];
const seen = new Set();
@@ -339,12 +360,13 @@ export async function placesNear(
const TWIN_KM = 3;
/**
* The city with this name, or null. A qualifier after a comma that names a
* country ("Paris, France", "Paris, US") keeps only cities there, and finds
* The place with this name, or null. A qualifier after a comma that names a
* country ("Paris, France", "Paris, US") keeps only places there, and finds
* nothing when none is; one that names no country ("Paris, Texas") is
* ignored. A city of that name within `radiusKm` of `near` (the view) wins,
* the nearest first, else the largest city of that name anywhere. Omnibar
* can also ask for a smaller place nearby when the cities pack has no match.
* ignored. A place of that name within `radiusKm` of `near` (the view) wins,
* the nearest first, else the largest city of that name anywhere. With
* `includeSmallPlaces`, the smaller places of the detail tiles near the view
* count too: a village in view comes before a far bigger city of its name.
*/
export async function findPlace(
name,
@@ -360,20 +382,6 @@ export async function findPlace(
const cities = (names.get(wanted) || []).filter(
(row) => !country || row[4] === country,
);
if (!cities.length) {
if (!includeSmallPlaces || !near) return null;
const nearby = await placesNear(
{ ...near, radiusKm, limit: Infinity },
fetchImpl,
);
return (
nearby.find(
(place) =>
foldName(place.name) === wanted &&
(!country || place.country === country),
) ?? null
);
}
if (Number.isFinite(near?.latitude) && Number.isFinite(near?.longitude)) {
let best = null;
for (const row of cities) {
@@ -381,7 +389,24 @@ export async function findPlace(
if (km <= radiusKm && (!best || km < best.distanceKm))
best = toCity(row, km);
}
if (includeSmallPlaces) {
const nearby = await placesNear(
{
latitude: near.latitude,
longitude: near.longitude,
radiusKm,
limit: Infinity,
},
fetchImpl,
);
const small = nearby.find(
(place) =>
foldName(place.name) === wanted &&
(!country || place.country === country),
);
if (small && (!best || small.distanceKm < best.distanceKm)) best = small;
}
if (best) return best;
}
return toCity(cities[0], 0);
return cities.length ? toCity(cities[0], 0) : null;
}
+107
View File
@@ -96,6 +96,66 @@ test('findPlace takes a country qualifier and prefers a namesake in view', async
);
});
test('a small place in view comes before a far bigger city of its name', async () => {
const module = await import(`./wikidataCities.js?small-${Date.now()}`);
// A village called Paris near Austin, in the 30_-100 detail tile.
const village = ['Paris', 30.4, -97.6, 1200, 'US', 'Q-village'];
const fetchImpl = async (url) => {
const file = url.pathname.split('/').at(-1);
const body =
file === 'cities.json'
? { meta: {}, rows: PARIS }
: file === 'index.json'
? { tiles: { '30_-100': 1 } }
: { rows: file === '30_-100.json' ? [village] : [] };
return { ok: true, json: async () => body };
};
const find = (name, near) =>
module.findPlace(name, { near, includeSmallPlaces: true }, fetchImpl);
const austin = { latitude: 30.27, longitude: -97.74 };
assert.equal((await find('Paris', austin)).wikidata, 'Q-village');
assert.ok((await find('Paris', austin)).distanceKm < 20);
// A bigger namesake inside a wider search: the nearer village still wins.
assert.equal(
(
await module.findPlace(
'Paris',
{ near: austin, radiusKm: 600, includeSmallPlaces: true },
fetchImpl,
)
).wikidata,
'Q-village',
);
// Only when small places are asked for.
assert.equal(
(await module.findPlace('Paris', { near: austin }, fetchImpl)).wikidata,
'Q90',
);
// A qualifier still decides.
assert.equal((await find('Paris, France', austin)).wikidata, 'Q90');
// Nowhere near the village: the largest city of the name.
assert.equal(
(await find('Paris', { latitude: 0, longitude: 0 })).wikidata,
'Q90',
);
assert.equal(
(await module.findPlace('Paris', {}, fetchImpl)).wikidata,
'Q90',
);
// Paris, Texas is nearer a view over it than the village is.
const texas = { latitude: 33.6, longitude: -95.6 };
assert.equal(
(
await module.findPlace(
'Paris',
{ near: texas, radiusKm: 600, includeSmallPlaces: true },
fetchImpl,
)
).wikidata,
'Q830149',
);
});
test('a circle that reaches a pole spans every longitude', () => {
assert.equal(lonHalfSpan(89, 150), 180);
assert.ok(lonHalfSpan(60, 150) < 3);
@@ -232,3 +292,50 @@ test('a tile that cannot be read leaves the other places and the cities', async
assert.ok(near.some((place) => place.name === 'Austin'));
assert.ok(near.some((place) => place.longitude > -95));
});
test('a lookup asked for the whole globe reads only the tiles near its centre', async () => {
const { placesNear, PLACE_TILE_KM } =
await import('./wikidataCities.js?globe');
const fetched = [];
const fetchPack = async (url) => {
fetched.push(url.pathname.split('/').at(-1));
return new Response(await readFile(url));
};
const near = await placesNear(
{ latitude: 30.27, longitude: -97.74, radiusKm: 20000, limit: 50 },
fetchPack,
);
const tileReads = fetched
.filter((name) => /^-?\d+_-?\d+\.json$/.test(name))
.sort();
// 500 km around Austin: latitude 25.8 to 34.8, longitude -103 to -92.5.
assert.equal(PLACE_TILE_KM, 500);
assert.deepEqual(tileReads, [
'25_-100.json',
'25_-105.json',
'25_-95.json',
'30_-100.json',
'30_-105.json',
'30_-95.json',
]);
assert.equal(near.length, 50);
assert.ok(near.every((place) => place.distanceKm <= PLACE_TILE_KM));
// Cities still count to the full radius.
const far = await placesNear(
{ latitude: 30.27, longitude: -97.74, radiusKm: 20000, limit: Infinity },
fetchPack,
);
assert.ok(far.some((place) => place.wikidata === 'Q90'));
// Places from the tiles it read stop at 500 km too: Tahoka, Texas
// (Q982084), a town of about 2,500, is 500.6 km away.
assert.ok(!far.some((place) => place.wikidata === 'Q982084'));
assert.ok(
far
.filter((place) => place.distanceKm > PLACE_TILE_KM)
.every((place) => place.population >= 15000),
);
assert.equal(
fetched.filter((name) => /^-?\d+_-?\d+\.json$/.test(name)).length,
tileReads.length,
);
});
+40
View File
@@ -8,6 +8,8 @@ import { createHash } from 'node:crypto';
import { readdir, readFile } from 'node:fs/promises';
import test from 'node:test';
import {
keepBuiltIfUnchanged,
keepPackBuiltIfUnchanged,
placeTileFiles,
tileKey,
withoutCities,
@@ -103,3 +105,41 @@ test('twins are found where longitude cells narrow, and across 180°', () => {
['Q1', 'Q3'],
);
});
test('a rebuild of unchanged rows keeps the earlier build stamp', () => {
const earlier = `${JSON.stringify({ meta: { built: '2026-01-01T00:00:00.000Z', count: 2 }, rows: [1, 2] })}\n`;
const same = `${JSON.stringify({ meta: { built: '2026-11-18T00:00:00.000Z', count: 2 }, rows: [1, 2] })}\n`;
const changed = `${JSON.stringify({ meta: { built: '2026-11-18T00:00:00.000Z', count: 3 }, rows: [1, 2, 3] })}\n`;
assert.equal(keepBuiltIfUnchanged(same, earlier), earlier);
assert.equal(keepBuiltIfUnchanged(changed, earlier), changed);
assert.equal(keepBuiltIfUnchanged(same, undefined), same);
assert.equal(keepBuiltIfUnchanged(same, 'not json'), same);
});
test('the places index keeps its build stamp only when no tile changed', () => {
const rows = [
['Aa', 31, -98, 2000, 'US', 'Q1'],
['Bb', 41, -88, 1500, 'US', 'Q2'],
];
const meta = (built) => ({
source: 's',
license: 'l',
built,
minPopulation: 1000,
maxPopulation: 15000,
columns: [],
});
const earlier = placeTileFiles(rows, meta('2026-01-01T00:00:00.000Z'));
const built = (files) => JSON.parse(files.get('index.json')).meta.built;
const rebuild = (newRows) =>
keepPackBuiltIfUnchanged(
placeTileFiles(newRows, meta('2026-11-18T00:00:00.000Z')),
earlier,
);
assert.equal(built(rebuild(rows)), '2026-01-01T00:00:00.000Z');
// Same row count in every tile, new population: a new stamp.
const changed = [['Aa', 31, -98, 2100, 'US', 'Q1'], rows[1]];
assert.equal(built(rebuild(changed)), '2026-11-18T00:00:00.000Z');
// A tile of the earlier build left out: a new stamp.
assert.equal(built(rebuild([rows[0]])), '2026-11-18T00:00:00.000Z');
});
+24 -1
View File
@@ -5,6 +5,7 @@ import {
resolvePanelStackCorridor,
} from '../panelStackLayout.js';
import { measurePanelNaturalHeight } from './panelMeasurement.js';
import { bandBesideMidpointObstacles } from './panelRailGeometry.js';
import { settleSideAccordion } from './panelAccordion.js';
/**
@@ -114,10 +115,12 @@ export function layoutLeftPanelRail({
const baseTop = viewportHeight * 0.26;
const baseBottomInset = viewportHeight * 0.04;
const safeGap = viewportHeight * 0.012;
let obstacleSafeTop = viewportHeight * 0.04;
const topInset = viewportHeight * 0.04;
let obstacleSafeTop = topInset;
let safeTop = baseTop;
let safeBottom = viewportHeight - baseBottomInset;
const bottomObstacles = [];
const inLane = [];
for (const obstacle of obstacles) {
if (stack.contains(obstacle)) continue;
@@ -147,6 +150,7 @@ export function layoutLeftPanelRail({
);
if (!overlapsHorizontally) continue;
inLane.push(rect);
if (rect.top < baseTop && rect.bottom <= viewportHeight * 0.5) {
const obstacleBottom = rect.bottom + safeGap;
obstacleSafeTop = Math.max(obstacleSafeTop, obstacleBottom);
@@ -155,6 +159,25 @@ export function layoutLeftPanelRail({
bottomObstacles.push({ top: rect.top });
}
}
// Obstacles across the midpoint (common in short windows) put the panels
// on whichever side of them has more room, and the panels may use all of
// it, above the corridor's usual top too; with no room on either side the
// obstacles are read as before.
const beside = bandBesideMidpointObstacles({
midpoint: viewportHeight * 0.5,
top: topInset,
bottom: safeBottom,
obstacles: inLane,
gap: safeGap,
// A side thinner than this holds no usable panel.
minimum: viewportHeight * 0.08,
});
if (beside) {
obstacleSafeTop = beside.top;
safeTop = beside.top;
bottomObstacles.length = 0;
bottomObstacles.push({ top: beside.bottom + safeGap });
}
safeBottom = resolveLeftStackBottomBoundary({
baseBottom: safeBottom,
obstacles: bottomObstacles,
+84 -1
View File
@@ -1,6 +1,9 @@
/**
* Resolve a vertically centered panel slot inside a HUD rail while respecting
* live rectangles that intersect that rail above or below the viewport center.
* live rectangles that intersect that rail. A rectangle above the viewport
* center lowers the top and one below it raises the bottom. Rectangles across
* the center put the band beside them (bandBesideMidpointObstacles); with no
* room on either side they are left out, as before.
*/
export function resolveHudRailLayout({
viewportHeight,
@@ -29,6 +32,7 @@ export function resolveHudRailLayout({
const midpoint = viewportHeight * 0.5;
let safeTop = Math.max(0, baseTop);
let safeBottom = Math.min(viewportHeight, baseBottom);
const inLane = [];
for (const rect of obstacles) {
if (
@@ -41,10 +45,21 @@ export function resolveHudRailLayout({
rect.bottom <= rect.top
)
continue;
inLane.push(rect);
if (rect.bottom <= midpoint) safeTop = Math.max(safeTop, rect.bottom + gap);
else if (rect.top >= midpoint)
safeBottom = Math.min(safeBottom, rect.top - gap);
}
const beside = bandBesideMidpointObstacles({
midpoint,
top: Math.max(0, baseTop),
bottom: Math.min(viewportHeight, baseBottom),
obstacles: inLane,
gap,
// A side thinner than this holds no usable panel.
minimum: viewportHeight * 0.08,
});
if (beside) ({ top: safeTop, bottom: safeBottom } = beside);
safeBottom = Math.max(safeTop, safeBottom);
const availableHeight = Math.max(0, safeBottom - safeTop);
@@ -61,6 +76,74 @@ export function resolveHudRailLayout({
};
}
/**
* Where a rail's band goes when obstacles cross the viewport midpoint, as in
* short windows. Those obstacles, and any other that leaves no band between
* itself and them, form one block; the band takes whichever side of the block
* has more room between it and the next obstacle or the band's own edge,
* above on a tie.
* @param {object} input
* @param {number} input.midpoint The viewport's vertical midpoint.
* @param {number} input.top The band's highest top.
* @param {number} input.bottom The band's lowest bottom.
* @param {Array<{top: number, bottom: number}>} input.obstacles Rectangles that reach the rail.
* @param {number} input.gap Space kept between the band and an obstacle.
* @param {number} [input.minimum=0] The least room a side needs to count;
* a thinner side is no room at all.
* @returns {{side: 'above' | 'below', top: number, bottom: number} | null}
* Null when nothing crosses the midpoint or neither side has room.
*/
export function bandBesideMidpointObstacles({
midpoint,
top,
bottom,
obstacles,
gap,
minimum = 0,
}) {
const crossing = obstacles.filter(
(rect) => rect.top < midpoint && rect.bottom > midpoint,
);
if (!crossing.length) return null;
let blockTop = Math.min(...crossing.map((rect) => rect.top));
let blockBottom = Math.max(...crossing.map((rect) => rect.bottom));
for (let grown = true; grown;) {
grown = false;
for (const rect of obstacles) {
const touches =
rect.top <= blockBottom + 2 * gap && rect.bottom >= blockTop - 2 * gap;
if (touches && (rect.top < blockTop || rect.bottom > blockBottom)) {
blockTop = Math.min(blockTop, rect.top);
blockBottom = Math.max(blockBottom, rect.bottom);
grown = true;
}
}
}
let aboveTop = top;
let belowBottom = bottom;
for (const rect of obstacles) {
if (rect.bottom <= blockTop)
aboveTop = Math.max(aboveTop, rect.bottom + gap);
else if (rect.top >= blockBottom)
belowBottom = Math.min(belowBottom, rect.top - gap);
}
const above = {
side: 'above',
top: aboveTop,
bottom: Math.min(bottom, blockTop - gap),
};
const below = {
side: 'below',
top: Math.max(top, blockBottom + gap),
bottom: belowBottom,
};
const roomAbove = above.bottom - above.top;
const roomBelow = below.bottom - below.top;
const fits = (room) => room > 0 && room >= minimum;
if (roomBelow > roomAbove && fits(roomBelow)) return below;
return fits(roomAbove) ? above : null;
}
/**
* Whether the Tactical layout hid collapsed right panels beside an expanded
* one. The rail now enforces one open panel per side in every layout; this
+73
View File
@@ -219,6 +219,79 @@ test('left corridor respects a lower obstacle but ignores an obstacle hidden by
assert.equal(Number(f.stack.dataset.safeBottomPct), 65.47);
});
test('in a short window the left corridor stays clear of an obstacle across the midpoint', () => {
// 480px window, midpoint 240.
const f = fixture('left');
f.options.windowRef.innerHeight = 480;
f.options.obstacles = [element('card', { top: 100, height: 200 })];
f.run();
// More room below the card than above it: the corridor starts under it.
assert(Number(f.stack.dataset.safeTopPct) * 4.8 >= 300);
// A card starting below the corridor's usual top (26%, 124.8px) that
// crosses the midpoint counts the same way: more room below it.
f.options.obstacles = [element('card', { top: 130, height: 120 })];
f.run();
assert(Number(f.stack.dataset.safeTopPct) * 4.8 >= 250);
// More room above it: the corridor ends over it.
f.options.obstacles = [element('card', { top: 200, height: 250 })];
f.run();
assert(Number(f.stack.dataset.safeBottomPct) * 4.8 <= 200);
});
test('several cards across the midpoint give the left corridor the same room in any order', () => {
const f = fixture('left');
f.options.windowRef.innerHeight = 480;
const a = element('card', { top: 100, height: 160 });
const b = element('card', { top: 110, height: 360 });
f.options.obstacles = [a, b];
f.run();
const first = [f.stack.dataset.safeTopPct, f.stack.dataset.safeBottomPct];
f.options.obstacles = [b, a];
f.run();
assert.deepEqual(
[f.stack.dataset.safeTopPct, f.stack.dataset.safeBottomPct],
first,
);
// Together they cover 100 to 470: the corridor ends above them.
assert(Number(first[1]) * 4.8 <= 100);
});
test('the left corridor counts cards beside those across the midpoint', () => {
const f = fixture('left');
f.options.windowRef.innerHeight = 480;
// A card inside the span below the midpoint: more room below both.
f.options.obstacles = [
element('card', { top: 100, height: 200 }),
element('card', { top: 250, height: 30 }),
];
f.run();
assert(Number(f.stack.dataset.safeTopPct) * 4.8 >= 300);
// About 25px above the cards is under the least usable room (8% of the
// window): they are read as before, the upper card pushing the corridor
// down past it rather than into a sliver at the top.
f.options.obstacles = [
element('card', { top: 50, height: 150 }),
element('card', { top: 150, height: 320 }),
];
f.run();
assert(Number(f.stack.dataset.safeTopPct) * 4.8 >= 200);
// The room above a card is all the panels' to use, above the corridor's
// usual top (26%) too: 700px window, card 300 to 420, about 263px above
// against 244 below.
f.options.windowRef.innerHeight = 700;
f.options.obstacles = [element('card', { top: 300, height: 120 })];
f.run();
assert(Number(f.stack.dataset.safeBottomPct) * 7 <= 300);
assert(Number(f.stack.dataset.safeTopPct) * 7 <= 30);
// No room on either side: the card is read as before.
f.options.windowRef.innerHeight = 480;
f.options.obstacles = [element('card', { top: 0, height: 480 })];
f.run();
assert.equal(Number(f.stack.dataset.safeTopPct), 26);
});
test('a centered timeline only shortens the corridor when it reaches a laid-out panel', () => {
const f = fixture('left');
f.stack.rect.width = 360;