diff --git a/changelog.d/1837-rail-short-window.md b/changelog.d/1837-rail-short-window.md new file mode 100644 index 0000000000..5a6662ca1a --- /dev/null +++ b/changelog.d/1837-rail-short-window.md @@ -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). diff --git a/changelog.d/1838-nearby-places-namesake.md b/changelog.d/1838-nearby-places-namesake.md new file mode 100644 index 0000000000..ffda7e347e --- /dev/null +++ b/changelog.d/1838-nearby-places-namesake.md @@ -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). diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md index 6b0cc95cdb..809ceb47e0 100644 --- a/docs/CURRENT-STATE.md +++ b/docs/CURRENT-STATE.md @@ -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 diff --git a/scripts/build-wikidata-cities.mjs b/scripts/build-wikidata-cities.mjs index a276062831..d2016fa3d7 100644 --- a/scripts/build-wikidata-cities.mjs +++ b/scripts/build-wikidata-cities.mjs @@ -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)}`); diff --git a/scripts/wikidataPlaceTiles.mjs b/scripts/wikidataPlaceTiles.mjs index 15f0c89e3a..d3396937f6 100644 --- a/scripts/wikidataPlaceTiles.mjs +++ b/scripts/wikidataPlaceTiles.mjs @@ -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} files The new pack, as placeTileFiles gives it; its index is replaced in place. + * @param {Map} 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] }); diff --git a/src/cockpitMath.test.mjs b/src/cockpitMath.test.mjs index 3892d510b0..3f8d396211 100644 --- a/src/cockpitMath.test.mjs +++ b/src/cockpitMath.test.mjs @@ -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, diff --git a/src/data/local_data/wikidata_cities/README.md b/src/data/local_data/wikidata_cities/README.md index 8c2abf3818..026f412988 100644 --- a/src/data/local_data/wikidata_cities/README.md +++ b/src/data/local_data/wikidata_cities/README.md @@ -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. diff --git a/src/data/local_data/wikidata_places/README.md b/src/data/local_data/wikidata_places/README.md index 2831f89a56..efad9ea1b3 100644 --- a/src/data/local_data/wikidata_places/README.md +++ b/src/data/local_data/wikidata_places/README.md @@ -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 diff --git a/src/data/wikidataCities.js b/src/data/wikidataCities.js index 70dcb3e67a..e106d2bc4c 100644 --- a/src/data/wikidataCities.js +++ b/src/data/wikidataCities.js @@ -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; } diff --git a/src/data/wikidataCities.test.mjs b/src/data/wikidataCities.test.mjs index ae96f1e462..4c62b1b65b 100644 --- a/src/data/wikidataCities.test.mjs +++ b/src/data/wikidataCities.test.mjs @@ -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, + ); +}); diff --git a/src/tooling/wikidataPlaceTiles.test.mjs b/src/tooling/wikidataPlaceTiles.test.mjs index 9e9cf54179..9f807c20e5 100644 --- a/src/tooling/wikidataPlaceTiles.test.mjs +++ b/src/tooling/wikidataPlaceTiles.test.mjs @@ -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'); +}); diff --git a/src/ui/leftPanelRail.js b/src/ui/leftPanelRail.js index 2d3edda5e1..5b6af7be0f 100644 --- a/src/ui/leftPanelRail.js +++ b/src/ui/leftPanelRail.js @@ -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, diff --git a/src/ui/panelRailGeometry.js b/src/ui/panelRailGeometry.js index 673f4871e7..0cc2f0db25 100644 --- a/src/ui/panelRailGeometry.js +++ b/src/ui/panelRailGeometry.js @@ -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 diff --git a/src/ui/panelRails.test.mjs b/src/ui/panelRails.test.mjs index 416079aec7..d4a67ed523 100644 --- a/src/ui/panelRails.test.mjs +++ b/src/ui/panelRails.test.mjs @@ -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;