mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 08:12:24 +00:00
Merge main through #1641 into the renderer seam
Takes main's per-point mesh floor readings (#1642) onto the seam's port-based sampler: a spot refused only while the cell's DEM prior was cold is probed again, each spot is recorded once, a cell keeps at most sixteen readings, and grounded flights read the floor at the contact held inside its sticky cell.
This commit is contained in:
commit
077576ed99
79 files changed
+2721
-230
No files matched your search
+24
-4
@@ -678,20 +678,40 @@ export const OSM_PLACES_CREDIT = {
|
||||
/**
|
||||
* Per-feed transit credit, registered the first time that feed's vehicles
|
||||
* render (see `src/data/transitFeeds.js` for the license of each).
|
||||
* @param {{ id: string, attribution: string, license: string, licenseUrl: string }} feed
|
||||
*
|
||||
* Two optional registry fields serve licences that ask for more than a name:
|
||||
* `sourceUrl` links the attribution to the publisher (Warsaw asks for a link
|
||||
* to its API), and `creditDated` adds the UTC date of the data, from the feed
|
||||
* header or else the fetch time (Warsaw and Poznań ask for the download or
|
||||
* update date). A dated credit is keyed by its date, so a new day registers a
|
||||
* new line instead of keeping yesterday's.
|
||||
* @param {{ id: string, attribution: string, license: string, licenseUrl: string,
|
||||
* sourceUrl?: string, creditDated?: boolean }} feed
|
||||
* @param {{ feedTimestamp?: number|null, fetchedAt?: number|null }} [snapshot]
|
||||
* `feedTimestamp` in epoch seconds, `fetchedAt` in epoch ms.
|
||||
* @returns {{ key: string, html: string }}
|
||||
*/
|
||||
export function transitFeedCredit(feed) {
|
||||
export function transitFeedCredit(feed, snapshot = null) {
|
||||
const escape = (text) =>
|
||||
String(text)
|
||||
.replaceAll('&', '&')
|
||||
.replaceAll('<', '<')
|
||||
.replaceAll('>', '>')
|
||||
.replaceAll('"', '"');
|
||||
const source = feed.sourceUrl
|
||||
? `<a href="${escape(feed.sourceUrl)}" target="_blank" rel="noopener">${escape(feed.attribution)}</a>`
|
||||
: escape(feed.attribution);
|
||||
const dataMs = Number.isFinite(snapshot?.feedTimestamp)
|
||||
? snapshot.feedTimestamp * 1000
|
||||
: snapshot?.fetchedAt;
|
||||
const date =
|
||||
feed.creditDated === true && Number.isFinite(dataMs) && dataMs > 0
|
||||
? new Date(dataMs).toISOString().slice(0, 10)
|
||||
: null;
|
||||
return {
|
||||
key: `transit-${feed.id}`,
|
||||
key: date ? `transit-${feed.id}-${date}` : `transit-${feed.id}`,
|
||||
html:
|
||||
`Transit (${escape(feed.attribution)}): ` +
|
||||
`Transit (${source}${date ? `, data of ${date}` : ''}): ` +
|
||||
`<a href="${escape(feed.licenseUrl)}" target="_blank" rel="noopener">${escape(feed.license)}</a>`,
|
||||
};
|
||||
}
|
||||
|
||||
@@ -1,6 +1,11 @@
|
||||
import { test } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import { DATA_CREDITS, NYC_DOT_DISCLAIMER } from './dataCredits.js';
|
||||
import {
|
||||
DATA_CREDITS,
|
||||
NYC_DOT_DISCLAIMER,
|
||||
transitFeedCredit,
|
||||
} from './dataCredits.js';
|
||||
import { getTransitFeed } from './transitFeeds.js';
|
||||
import { bindFakeCesiumCredits } from '../testSupport/fakeCreditsPort.mjs';
|
||||
|
||||
test('every credit carries a unique key and some markup to render', () => {
|
||||
@@ -293,3 +298,24 @@ test('the PR #1506 camera packs are credited with their sources and terms', () =
|
||||
/href="https:\/\/www\.river\.go\.jp\//,
|
||||
);
|
||||
});
|
||||
|
||||
test('Warsaw and Poznań credits carry the data date their licences ask for', () => {
|
||||
const warsaw = getTransitFeed('ztm-warszawa');
|
||||
// 2026-11-09T06:00:00Z as a GTFS-RT header timestamp (seconds).
|
||||
const credit = transitFeedCredit(warsaw, { feedTimestamp: 1_794_204_000 });
|
||||
assert.match(credit.html, /, data of 2026-11-09\)/);
|
||||
assert.match(credit.html, /href="http:\/\/api\.um\.warszawa\.pl"/);
|
||||
assert.equal(credit.key, 'transit-ztm-warszawa-2026-11-09');
|
||||
// Without a feed timestamp the fetch time is the download date.
|
||||
const poznan = transitFeedCredit(getTransitFeed('ztm-poznan'), {
|
||||
feedTimestamp: null,
|
||||
fetchedAt: Date.UTC(2026, 10, 10, 12),
|
||||
});
|
||||
assert.match(poznan.html, /data of 2026-11-10/);
|
||||
// Undated feeds keep one credit line for the session.
|
||||
const mbta = transitFeedCredit(getTransitFeed('mbta'), {
|
||||
feedTimestamp: 1_794_204_000,
|
||||
});
|
||||
assert.equal(mbta.key, 'transit-mbta');
|
||||
assert.doesNotMatch(mbta.html, /data of/);
|
||||
});
|
||||
@@ -180,9 +180,10 @@ test('fire detection key survives a refetch that renumbers the index', () => {
|
||||
});
|
||||
|
||||
test('two satellites over the same pixel at the same time stay distinct', () => {
|
||||
// The proxy merges SNPP + NOAA-20 + NOAA-21 without dedup and their orbits
|
||||
// overlap, so position and time alone are NOT unique. Collapsing them let a
|
||||
// restored selection land on the other satellite's record.
|
||||
// The proxy merges NOAA-20 + NOAA-21 without dedup and their orbits overlap,
|
||||
// so position and time alone are NOT unique. Collapsing them let a restored
|
||||
// selection land on the other satellite's record. Archived Suomi NPP (`N`)
|
||||
// rows must stay distinct too.
|
||||
const base = makeFire({ satellite: 'N20' });
|
||||
const twin = makeFire({ satellite: 'N21' });
|
||||
const suomi = makeFire({ satellite: 'N' });
|
||||
|
||||
@@ -21,7 +21,10 @@ assert.notEqual(start, -1, 'FIRMS refresh function exists');
|
||||
const end = config.indexOf('\n }', start);
|
||||
assert.notEqual(end, -1, 'FIRMS refresh function closes');
|
||||
const refreshSource = config.slice(start, end + 4);
|
||||
const SOURCES = ['VIIRS_NOAA20_NRT', 'VIIRS_NOAA21_NRT', 'VIIRS_SNPP_NRT', 'MODIS_NRT'];
|
||||
// Read the list from production so these tests follow it.
|
||||
const listed = config.match(/const SOURCES = \[([^\]]*)\];/);
|
||||
assert.ok(listed, 'FIRMS source list exists');
|
||||
const SOURCES = [...listed[1].matchAll(/'([A-Z0-9_]+)'/g)].map((m) => m[1]);
|
||||
const NOW = Date.UTC(2026, 8, 11, 12);
|
||||
const recent = { acqDate: '2026-09-11', acqTime: '1100' };
|
||||
|
||||
@@ -54,7 +57,7 @@ test('FIRMS retains large sources in order and filters expired rows', async () =
|
||||
assert.equal(result.fires[199_999], large.at(-1));
|
||||
assert.equal(result.fires.at(-1), last);
|
||||
assert.deepEqual(result.sources, SOURCES.map((source, index) => ({
|
||||
source, count: [200_000, 1, 0, 0][index], ok: true,
|
||||
source, count: [200_000, 1, 0][index], ok: true,
|
||||
})));
|
||||
});
|
||||
|
||||
@@ -63,7 +66,7 @@ test('FIRMS keeps successful sources when another upstream fails', async () => {
|
||||
if (source === SOURCES[1]) throw new Error('upstream unavailable');
|
||||
return [recent];
|
||||
})('fixture');
|
||||
assert.equal(result.fires.length, 3);
|
||||
assert.equal(result.fires.length, SOURCES.length - 1);
|
||||
assert.deepEqual(result.sources, SOURCES.map((source, index) => ({
|
||||
source, count: index === 1 ? 0 : 1, ok: index !== 1,
|
||||
})));
|
||||
@@ -77,7 +80,7 @@ test('FIRMS reports one failure if consuming a source throws before append', asy
|
||||
// Fault injection for aggregation; ordinary parsed CSV returns an array.
|
||||
return { length: 1, [Symbol.iterator]() { throw new Error('aggregation failed'); } };
|
||||
})('fixture');
|
||||
assert.equal(result.fires.length, 3);
|
||||
assert.equal(result.fires.length, SOURCES.length - 1);
|
||||
assert.deepEqual(result.sources, SOURCES.map((source, index) => ({
|
||||
source, count: index === 0 ? 0 : 1, ok: index !== 0,
|
||||
})));
|
||||
@@ -107,7 +110,7 @@ function wrappedAddressSelectionFailure() {
|
||||
{ name: 'ConnectTimeoutError', code: 'UND_ERR_CONNECT_TIMEOUT', cause: inner });
|
||||
return new TypeError('fetch failed', { cause });
|
||||
}
|
||||
const URL_WITH_KEY = 'https://firms.modaps.eosdis.nasa.gov/api/area/csv/SECRET/VIIRS_SNPP_NRT/world/2';
|
||||
const URL_WITH_KEY = 'https://firms.modaps.eosdis.nasa.gov/api/area/csv/SECRET/VIIRS_NOAA20_NRT/world/2';
|
||||
|
||||
test('FIRMS failures log the socket cause, never the keyed URL', () => {
|
||||
const described = describeFetchError(addressSelectionFailure());
|
||||
@@ -307,3 +310,9 @@ test('every FIRMS upstream request goes through the IPv4 fallback', async () =>
|
||||
assert.ok(calls[0][2] instanceof AbortSignal);
|
||||
assert.deepEqual(calls[1], ['read', response, calls[0][2]], 'the body read shares the request deadline');
|
||||
});
|
||||
|
||||
test('FIRMS requests only the satellites NASA still delivers', () => {
|
||||
// NASA stopped delivering Suomi NPP on 2026-11-02; asking for it only spends
|
||||
// a MAP_KEY transaction.
|
||||
assert.ok(!SOURCES.includes('VIIRS_SNPP_NRT'));
|
||||
});
|
||||
@@ -24,9 +24,11 @@ import { setMilitaryLayerActive } from './militaryRegistry.js';
|
||||
import {
|
||||
GROUND_FLOOR_LIFT_M,
|
||||
reportMeshFloorCell,
|
||||
reportValidatedMeshFloorCell,
|
||||
setMeshFloorPreferred,
|
||||
_clearMeshFloorCellsForTest,
|
||||
} from './groundFloor.js';
|
||||
import { resolveEllipsoidalGround } from './terrainHeights.js';
|
||||
import {
|
||||
_setTrackedOverlayHostForTest,
|
||||
destroyTrackedReadout,
|
||||
@@ -1269,6 +1271,39 @@ test('display floor: a grounded contact that drifted onto a higher cell is lifte
|
||||
assert.ok(Math.abs(Cesium.Math.toDegrees(c.longitude) + 97.6604) < 1e-6);
|
||||
});
|
||||
|
||||
test('display floor: reads the reading nearest the contact, not the cell centre', async () => {
|
||||
_clearDisplayFloorStateForTest();
|
||||
_clearMeshFloorCellsForTest();
|
||||
setMeshFloorPreferred(true);
|
||||
const realFetch = globalThis.fetch;
|
||||
globalThis.fetch = async () =>
|
||||
new Response(JSON.stringify({ results: [{ ellipsoid: 120 }] }), {
|
||||
status: 200,
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
});
|
||||
try {
|
||||
await resolveEllipsoidalGround([{ lat: 30.317, lon: -97.717 }]);
|
||||
} finally {
|
||||
globalThis.fetch = realFetch;
|
||||
}
|
||||
// A hangar roof over the cell's centre; the apron where the contact is.
|
||||
assert.equal(reportValidatedMeshFloorCell(30.317, -97.717, 142), true);
|
||||
assert.equal(reportValidatedMeshFloorCell(30.3173, -97.7173, 121), true);
|
||||
const pos = Cesium.Cartesian3.fromDegrees(-97.7173, 30.3173, 100);
|
||||
const out = _floorGroundedDisplayPositionForTest(
|
||||
{ onGround: true },
|
||||
pos,
|
||||
false,
|
||||
);
|
||||
const c = _floorCarto(out);
|
||||
assert.ok(
|
||||
Math.abs(c.height - (121 + GROUND_FLOOR_LIFT_M)) < 0.05,
|
||||
`height ${c.height} should be the apron's 121 + lift`,
|
||||
);
|
||||
_clearMeshFloorCellsForTest();
|
||||
_clearDisplayFloorStateForTest();
|
||||
});
|
||||
|
||||
test('display floor: an AIRBORNE contact over the same cell is never lifted', () => {
|
||||
_clearDisplayFloorStateForTest();
|
||||
_clearMeshFloorCellsForTest();
|
||||
|
||||
@@ -13,7 +13,7 @@ import { isCalibratedAllocationRuntime } from '../../scripts/run-unit-tests.mjs'
|
||||
*/
|
||||
test('converged focus treatment stays within the GC-bracketed allocation budget', (t) => {
|
||||
if (!isCalibratedAllocationRuntime()) {
|
||||
return t.skip(`allocation budgets are calibrated for Node 24; running ${process.versions.node}`);
|
||||
return t.skip(`allocation budgets are calibrated for Node 24 or 26; running ${process.versions.node}`);
|
||||
}
|
||||
const result = spawnSync(
|
||||
process.execPath,
|
||||
|
||||
@@ -22,6 +22,7 @@ export const {
|
||||
reportMeshFloorCell,
|
||||
meshFloorSampleWithinPrior,
|
||||
reportValidatedMeshFloorCell,
|
||||
meshFloorPriorReady,
|
||||
cachedMeshFloor,
|
||||
_clearMeshFloorCellsForTest,
|
||||
cachedGroundFloor,
|
||||
|
||||
+17
-1
@@ -2385,11 +2385,27 @@ export class LayerLifecycle {
|
||||
/**
|
||||
* Ask presentation to repaint layer rows now, for data that lands outside
|
||||
* the manager tick (Transit's proximity polls, Directions' route steps).
|
||||
* @param {string} [layerId] - The layer whose row changed.
|
||||
*/
|
||||
refreshLayerStats() {
|
||||
refreshLayerStats(layerId) {
|
||||
this._dropRecoveredRefreshError(layerId);
|
||||
this._publishActivity({ type: 'status' });
|
||||
}
|
||||
|
||||
/**
|
||||
* Drop a tick failure the layer's stats no longer report (the camera left
|
||||
* that feed) instead of showing it until the next tick.
|
||||
*/
|
||||
_dropRecoveredRefreshError(layerId) {
|
||||
const entry = layerId ? this.layers.get(layerId) : null;
|
||||
if (!entry?.managerRefreshError || entry.refreshing) return;
|
||||
const failure = refreshFailureFromStats(
|
||||
this._moduleStats(entry),
|
||||
entry.module.name || layerId,
|
||||
);
|
||||
if (!failure) entry.managerRefreshError = null;
|
||||
}
|
||||
|
||||
_publishActivity(change) {
|
||||
for (const callback of this._activityListeners) {
|
||||
try {
|
||||
|
||||
@@ -15,16 +15,6 @@ export class DataLayerManager extends LayerLifecycle {
|
||||
this._presentation.refresh();
|
||||
}
|
||||
|
||||
/**
|
||||
* Repaint the toggle panel now. For layers whose data arrives outside their
|
||||
* manager tick (camera-driven loads such as Transit's proximity polls), so a
|
||||
* row shows its count when the data lands instead of at the next interval.
|
||||
* One DOM pass; skipped while the document is hidden.
|
||||
*/
|
||||
refreshLayerStats() {
|
||||
this._refreshTogglePanel();
|
||||
}
|
||||
|
||||
_buildMetaText(layer) {
|
||||
return this._presentation.panel._buildMetaText(layer);
|
||||
}
|
||||
|
||||
@@ -2677,6 +2677,31 @@ test('refreshLayerStats reaches presentation through the bare lifecycle', async
|
||||
assert.deepEqual(changes, ['status']);
|
||||
});
|
||||
|
||||
test('refreshLayerStats(layerId) drops a tick failure the layer no longer reports', async () => {
|
||||
const { LayerLifecycle } = await import('./lifecycle.js');
|
||||
const lifecycle = new LayerLifecycle({});
|
||||
let stats = { count: 0, error: 'Feed unavailable' };
|
||||
lifecycle.register({
|
||||
id: 'feed',
|
||||
name: 'Feed',
|
||||
getStats: () => stats,
|
||||
async update() {},
|
||||
});
|
||||
const entry = lifecycle.layers.get('feed');
|
||||
entry.enabled = true;
|
||||
entry.initialized = true;
|
||||
entry.managerRefreshError = 'Feed unavailable';
|
||||
|
||||
lifecycle.refreshLayerStats('feed');
|
||||
assert.equal(entry.managerRefreshError, 'Feed unavailable');
|
||||
|
||||
stats = { count: 0 };
|
||||
lifecycle.refreshLayerStats();
|
||||
assert.equal(entry.managerRefreshError, 'Feed unavailable');
|
||||
lifecycle.refreshLayerStats('feed');
|
||||
assert.equal(entry.managerRefreshError, null);
|
||||
});
|
||||
|
||||
test('periodic polls pause hidden, catch up once when due, and dispose visibility listeners', async (t) => {
|
||||
const listeners = new Set();
|
||||
const doc = {
|
||||
|
||||
@@ -230,6 +230,18 @@ test('sampler: a viaduct and the street beside it in one cell keep their own hei
|
||||
assert.equal(calls, 2, 'a point next to one already probed is not probed again');
|
||||
});
|
||||
|
||||
test('sampler: a roof over the cell centre does not lift a bus on the street', async () => {
|
||||
reset();
|
||||
const cell = nextSite();
|
||||
await seedDem(cell, 120.0);
|
||||
// A roof 22 m up covering the cell's centre; the street 30 m west of it.
|
||||
const scene = fakeScene((carto) =>
|
||||
Math.abs(Cesium.Math.toDegrees(carto.longitude) - cell.lon) < 0.0001 ? 142.0 : 121.0);
|
||||
const bus = { lat: cell.lat, lon: cell.lon - 0.0003 };
|
||||
sampleMeshFloorCells(scene, [bus], { viewerLat: cell.lat, viewerLon: cell.lon });
|
||||
assert.equal(cachedGroundFloor(bus.lat, bus.lon), 121.0);
|
||||
});
|
||||
|
||||
test('sampler: a second reading at the same spot keeps the lower one', async () => {
|
||||
reset();
|
||||
const cell = nextSite();
|
||||
@@ -241,7 +253,7 @@ test('sampler: a second reading at the same spot keeps the lower one', async ()
|
||||
assert.equal(cachedMeshFloor(cell.lat, cell.lon), 122.0, 'a higher one never raises it');
|
||||
});
|
||||
|
||||
test('sampler: a latched cell is read a few times at most', async () => {
|
||||
test('sampler: a cell with a reading is probed a few times at most', async () => {
|
||||
reset();
|
||||
const cell = nextSite();
|
||||
await seedDem(cell, 120.0);
|
||||
@@ -259,3 +271,99 @@ test('sampler: a latched cell is read a few times at most', async () => {
|
||||
);
|
||||
assert.equal(calls, 8);
|
||||
});
|
||||
|
||||
test('sampler: a cell with no accepted reading is probed again on every call', async () => {
|
||||
reset();
|
||||
const cell = nextSite();
|
||||
let calls = 0;
|
||||
const scene = fakeScene(() => {
|
||||
calls += 1;
|
||||
return 138.0;
|
||||
});
|
||||
const opts = { viewerLat: cell.lat, viewerLon: cell.lon };
|
||||
for (let i = 0; i < 3; i++) sampleMeshFloorCells(scene, [cell], opts);
|
||||
assert.equal(calls, 3, 'no DEM prior yet, so nothing is kept and the cell is retried');
|
||||
await seedDem(cell, 120.0);
|
||||
sampleMeshFloorCells(scene, [cell], opts);
|
||||
assert.equal(cachedMeshFloor(cell.lat, cell.lon), 138.0, 'and lands once the prior is warm');
|
||||
});
|
||||
|
||||
test('sampler: a spot whose reading is refused does not use up the cell', async () => {
|
||||
reset();
|
||||
const cell = nextSite();
|
||||
await seedDem(cell, 120.0);
|
||||
// A tower 260 m up where the first vehicle waits; the street elsewhere and
|
||||
// a deck 9 m up along one line of the cell.
|
||||
const towerLon = cell.lon + 0.0004;
|
||||
const deckLat = cell.lat + 0.0003;
|
||||
const scene = fakeScene((carto) => {
|
||||
if (Math.abs(Cesium.Math.toDegrees(carto.longitude) - towerLon) < 1e-7) return 380.0;
|
||||
return Math.abs(Cesium.Math.toDegrees(carto.latitude) - deckLat) < 1e-7 ? 129.0 : 121.0;
|
||||
});
|
||||
const opts = { viewerLat: cell.lat, viewerLon: cell.lon };
|
||||
for (let i = 0; i < 10; i++) sampleMeshFloorCells(scene, [{ lat: cell.lat, lon: towerLon }], opts);
|
||||
assert.equal(cachedMeshFloor(cell.lat, cell.lon), null, 'the tower is refused every time');
|
||||
sampleMeshFloorCells(scene, [{ lat: cell.lat - 0.0003, lon: cell.lon }], opts);
|
||||
sampleMeshFloorCells(scene, [{ lat: deckLat, lon: cell.lon - 0.0003 }], opts);
|
||||
assert.equal(cachedMeshFloor(deckLat, cell.lon - 0.0003), 129.0, 'the deck is still probed');
|
||||
});
|
||||
|
||||
test('ground floor: a cell keeps at most sixteen readings', async () => {
|
||||
reset();
|
||||
const cell = nextSite();
|
||||
await seedDem(cell, 120.0);
|
||||
for (let i = 0; i < 40; i++) {
|
||||
const lat = cell.lat - 0.00045 + (i % 8) * 0.0001;
|
||||
const lon = cell.lon - 0.00045 + Math.floor(i / 8) * 0.0002;
|
||||
reportValidatedMeshFloorCell(lat, lon, 121.0 + i);
|
||||
}
|
||||
// Readings 0..15 are kept; reading 39 (at the far corner) is not, so that
|
||||
// spot answers from the nearest kept one.
|
||||
assert.equal(cachedMeshFloor(cell.lat - 0.00045, cell.lon - 0.00045), 121.0);
|
||||
assert.equal(cachedMeshFloor(cell.lat + 0.00025, cell.lon + 0.00035), 121.0 + 15);
|
||||
});
|
||||
|
||||
test('sampler: a spot refused while the DEM was cold is probed again once it is warm', async () => {
|
||||
reset();
|
||||
const cell = nextSite();
|
||||
const deckLat = cell.lat + 0.0003;
|
||||
let calls = 0;
|
||||
const scene = fakeScene((carto) => {
|
||||
calls += 1;
|
||||
return Math.abs(Cesium.Math.toDegrees(carto.latitude) - deckLat) < 1e-7 ? 129.0 : 121.0;
|
||||
});
|
||||
const opts = { viewerLat: cell.lat, viewerLon: cell.lon };
|
||||
const onDeck = { lat: deckLat, lon: cell.lon };
|
||||
sampleMeshFloorCells(scene, [onDeck], opts);
|
||||
assert.equal(cachedMeshFloor(onDeck.lat, onDeck.lon), null, 'no prior, nothing kept');
|
||||
await seedDem(cell, 120.0);
|
||||
sampleMeshFloorCells(scene, [{ lat: cell.lat - 0.0003, lon: cell.lon }], opts);
|
||||
sampleMeshFloorCells(scene, [onDeck], opts);
|
||||
assert.equal(calls, 3);
|
||||
assert.equal(cachedMeshFloor(onDeck.lat, onDeck.lon), 129.0);
|
||||
});
|
||||
|
||||
test('sampler: a spot refused while the DEM prior was evicted is probed again', async () => {
|
||||
const { createGroundFloor } = await import('../services/groundFloor.js');
|
||||
const { createMeshFloorSampler } = await import('../services/meshFloorSampler.js');
|
||||
let prior = 120.0;
|
||||
const terrain = {
|
||||
cachedRealEllipsoidalGround: () => prior,
|
||||
resolveEllipsoidalGround: async () => {},
|
||||
};
|
||||
const groundFloor = createGroundFloor({ terrain });
|
||||
const sampler = createMeshFloorSampler({ groundFloor });
|
||||
const cell = { lat: 41.5, lon: -97.66 };
|
||||
const deckLat = cell.lat + 0.0003;
|
||||
const scene = fakeScene((carto) =>
|
||||
Math.abs(Cesium.Math.toDegrees(carto.latitude) - deckLat) < 1e-7 ? 129.0 : 121.0);
|
||||
const opts = { viewerLat: cell.lat, viewerLon: cell.lon };
|
||||
const onDeck = { lat: deckLat, lon: cell.lon };
|
||||
sampler.sampleMeshFloorCells(scene, [{ lat: cell.lat - 0.0003, lon: cell.lon }], opts);
|
||||
prior = null; // the cell's DEM entry is evicted; the street reading stays
|
||||
sampler.sampleMeshFloorCells(scene, [onDeck], opts);
|
||||
assert.equal(groundFloor.cachedMeshFloor(onDeck.lat, onDeck.lon), 121.0);
|
||||
prior = 120.0;
|
||||
sampler.sampleMeshFloorCells(scene, [onDeck], opts);
|
||||
assert.equal(groundFloor.cachedMeshFloor(onDeck.lat, onDeck.lon), 129.0);
|
||||
});
|
||||
@@ -0,0 +1,53 @@
|
||||
/**
|
||||
* @file Upstream-request accounting shared by the keyed tile proxies.
|
||||
*
|
||||
* A soft cap per UTC period, persisted as `{date, count}` so it survives a
|
||||
* restart. Nothing here is provider-specific: the caller picks the period by
|
||||
* the key it passes, and decides what happens over the cap.
|
||||
*
|
||||
* Zero dependencies and Cesium-free, so providers and browser helpers can
|
||||
* import it and node:test can exercise it directly.
|
||||
*
|
||||
* @module data/tileBudget
|
||||
*/
|
||||
|
||||
/**
|
||||
* UTC calendar-day key for budget bucketing.
|
||||
*
|
||||
* @param {number} [epochMs=Date.now()] - Timestamp in ms.
|
||||
* @returns {string} 'YYYY-MM-DD' in UTC.
|
||||
*/
|
||||
export function utcDayKey(epochMs = Date.now()) {
|
||||
return new Date(epochMs).toISOString().slice(0, 10);
|
||||
}
|
||||
|
||||
/**
|
||||
* Normalize a persisted budget state against the current period key.
|
||||
* Rolls the counter to zero when the period changes; replaces missing/corrupt
|
||||
* state. Returns the SAME object when it is already valid for `periodKey`
|
||||
* (cheap to call on every request).
|
||||
*
|
||||
* @param {{date:string, count:number}|null|undefined} state - Persisted state.
|
||||
* @param {string} periodKey - Current period key, e.g. from `utcDayKey`.
|
||||
* @returns {{date:string, count:number}} Valid state for `periodKey`.
|
||||
*/
|
||||
export function normalizeBudget(state, periodKey) {
|
||||
const valid =
|
||||
Boolean(state) &&
|
||||
state.date === periodKey &&
|
||||
Number.isFinite(state.count) &&
|
||||
state.count >= 0;
|
||||
return valid ? state : { date: periodKey, count: 0 };
|
||||
}
|
||||
|
||||
/**
|
||||
* Whether the soft cap for the current period has been reached.
|
||||
*
|
||||
* @param {{count:number}} state - Normalized budget state.
|
||||
* @param {number} limit - Budget per period; non-positive/invalid never blocks.
|
||||
* @returns {boolean} True when `count >= limit`.
|
||||
*/
|
||||
export function isOverBudget(state, limit) {
|
||||
if (!Number.isFinite(limit) || limit <= 0) return false;
|
||||
return state.count >= limit;
|
||||
}
|
||||
@@ -0,0 +1,10 @@
|
||||
import test from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import { isOverBudget, normalizeBudget, utcDayKey } from './tileBudget.js';
|
||||
import * as tomtom from './tomtomTiles.js';
|
||||
|
||||
test('tile budget helpers live in one module and TomTom re-exports them', () => {
|
||||
assert.equal(tomtom.utcDayKey, utcDayKey);
|
||||
assert.equal(tomtom.normalizeBudget, normalizeBudget);
|
||||
assert.equal(tomtom.isOverBudget, isOverBudget);
|
||||
});
|
||||
+6
-40
@@ -1,9 +1,10 @@
|
||||
/**
|
||||
* @file Pure tile math + budget accounting for the TomTom traffic-flow proxy.
|
||||
* @file Pure tile math for the TomTom traffic-flow proxy; budget helpers are
|
||||
* re-exported from `./tileBudget.js`.
|
||||
*
|
||||
* Shared by the `/api/tomtom` vite plugin (server-side: coordinate validation,
|
||||
* daily budget governor) and `src/layers/traffic/flowSource.js` (client-side: which tiles
|
||||
* cover the current traffic fetch bounds). Zero dependencies, Cesium-free, so
|
||||
* cover the current traffic fetch bounds). No external dependencies, Cesium-free, so
|
||||
* both sides can unit-test against it with node:test.
|
||||
*
|
||||
* Slippy scheme: standard Web Mercator XYZ, y grows southward
|
||||
@@ -131,42 +132,7 @@ export function tilesForBounds(bounds, zoom = 12, { maxTiles = 64 } = {}) {
|
||||
// ─── Daily budget accounting ───────────────────────────────
|
||||
|
||||
/**
|
||||
* UTC calendar-day key for budget bucketing.
|
||||
*
|
||||
* @param {number} [epochMs=Date.now()] - Timestamp in ms.
|
||||
* @returns {string} 'YYYY-MM-DD' in UTC.
|
||||
* Re-exported from `./tileBudget.js`, which keyed tile proxies share. The
|
||||
* traffic provider and its tests keep one import for tile math and budget.
|
||||
*/
|
||||
export function utcDayKey(epochMs = Date.now()) {
|
||||
return new Date(epochMs).toISOString().slice(0, 10);
|
||||
}
|
||||
|
||||
/**
|
||||
* Normalize a persisted budget state against today's UTC day key.
|
||||
* Rolls the counter to zero on day change; replaces missing/corrupt state.
|
||||
* Returns the SAME object when it is already valid for `dayKey` (cheap to
|
||||
* call on every request).
|
||||
*
|
||||
* @param {{date:string, count:number}|null|undefined} state - Persisted state.
|
||||
* @param {string} dayKey - Today's UTC day key (from `utcDayKey`).
|
||||
* @returns {{date:string, count:number}} Valid state for `dayKey`.
|
||||
*/
|
||||
export function normalizeBudget(state, dayKey) {
|
||||
const valid =
|
||||
Boolean(state) &&
|
||||
state.date === dayKey &&
|
||||
Number.isFinite(state.count) &&
|
||||
state.count >= 0;
|
||||
return valid ? state : { date: dayKey, count: 0 };
|
||||
}
|
||||
|
||||
/**
|
||||
* Whether the daily soft cap has been reached.
|
||||
*
|
||||
* @param {{count:number}} state - Normalized budget state.
|
||||
* @param {number} limit - Daily tile budget; non-positive/invalid never blocks.
|
||||
* @returns {boolean} True when `count >= limit`.
|
||||
*/
|
||||
export function isOverBudget(state, limit) {
|
||||
if (!Number.isFinite(limit) || limit <= 0) return false;
|
||||
return state.count >= limit;
|
||||
}
|
||||
export { utcDayKey, normalizeBudget, isOverBudget } from './tileBudget.js';
|
||||
@@ -389,6 +389,179 @@ function rioRouteLabel(routeId) {
|
||||
: routeId;
|
||||
}
|
||||
|
||||
/**
|
||||
* Carris Metropolitana realtime route ids wrap the GTFS route id in an
|
||||
* operator-area prefix and keep its pattern suffix: `[LA77N]1708_0` is GTFS
|
||||
* route `1708_0`, whose `short_name` (the number on the bus) is `1708`, per
|
||||
* the operator's own `/v2/routes` API. Anything else passes through.
|
||||
* @param {string|null} routeId
|
||||
* @returns {string|null}
|
||||
*/
|
||||
function carrisMetropolitanaRouteLabel(routeId) {
|
||||
const match = /^\[[A-Z0-9]+\](\d{4})_\d+$/.exec(routeId ?? '');
|
||||
return match ? match[1] : routeId;
|
||||
}
|
||||
|
||||
/**
|
||||
* Route ids that wrap the rider-facing line in a fixed prefix, suffix or
|
||||
* zero-padding. The returned function yields the captured line, or the id
|
||||
* unchanged when it does not match the operator's pattern.
|
||||
* @param {RegExp} pattern One capture group: the line a rider would say.
|
||||
* @returns {(routeId: string|null) => string|null}
|
||||
*/
|
||||
function routeIdPattern(pattern) {
|
||||
return (routeId) => {
|
||||
const match = pattern.exec(routeId ?? '');
|
||||
return match ? match[1] : routeId;
|
||||
};
|
||||
}
|
||||
|
||||
/** Zero-padded numbers (Edmonton `005`, Toulon `0002`, Bordeaux `01`). */
|
||||
const unpaddedRouteLabel = routeIdPattern(/^0+(\d+\w*)$/);
|
||||
/** Turin GTT appends `U` (urban) to the line: `10NU` is night line 10N. */
|
||||
const gttRouteLabel = routeIdPattern(/^(\w+?)U$/);
|
||||
/** Venice ACTV appends the network: `5.1_UN` is waterbus line 5.1, `53E_ES` bus 53E. */
|
||||
const actvRouteLabel = routeIdPattern(/^(.+)_[A-Z]{2}$/);
|
||||
/** BC Transit appends the system: `95-VIC` is Victoria route 95. */
|
||||
const bcTransitRouteLabel = routeIdPattern(/^(.+)-VIC$/);
|
||||
/** Carris (Lisbon city) appends a variant: `172_1` is route 172. */
|
||||
const carrisRouteLabel = routeIdPattern(/^(\w+)_\d+$/);
|
||||
/** Astuce prefixes the network: `TCAR:93` is Rouen line 93. */
|
||||
const astuceNetworkLabel = routeIdPattern(/^[A-Z]+:(.+)$/);
|
||||
/** BAS.MY Johor appends a fixed operator code: `J33CWLMYJB` is route J33. */
|
||||
const mybasJohorRouteLabel = routeIdPattern(/^(.+?)CWLMYJB$/);
|
||||
|
||||
/** LiA prefixes its network: `8-C3` is Le Havre line C3, `8-09` line 9. */
|
||||
const liaRouteLabel = routeIdPattern(/^8-0*(\w.*)$/);
|
||||
|
||||
/**
|
||||
* Le Havre LiA runs its two tram lines as A and B and the funicular as
|
||||
* `FUNI`; every other line is a bus.
|
||||
* @param {string|null} routeId
|
||||
* @returns {string}
|
||||
*/
|
||||
function liaRouteMode(routeId) {
|
||||
if (!routeId) return 'unknown';
|
||||
const line = liaRouteLabel(routeId);
|
||||
if (line === 'FUNI') return 'rail';
|
||||
return /^[AB]$/.test(line) ? 'tram' : 'bus';
|
||||
}
|
||||
|
||||
/**
|
||||
* Rouen Astuce lines that are not buses, by route id, from the TCAR
|
||||
* routes.txt (checked 2026-11-09): line 90 is the Métro (GTFS type 1, a light
|
||||
* rail that runs mostly on the street) and 99 the Calypso river boat.
|
||||
*/
|
||||
const ASTUCE_ROUTES = Object.freeze({
|
||||
// i18n-ignore: line name, as on the vehicle
|
||||
'TCAR:90': Object.freeze({ mode: 'tram', label: 'Métro' }),
|
||||
// i18n-ignore: line name, as on the vehicle
|
||||
'TCAR:99': Object.freeze({ mode: 'ferry', label: 'Calypso' }),
|
||||
});
|
||||
|
||||
/** @param {string|null} routeId @returns {string} */
|
||||
function astuceRouteMode(routeId) {
|
||||
if (!routeId) return 'unknown';
|
||||
return ASTUCE_ROUTES[routeId]?.mode ?? 'bus';
|
||||
}
|
||||
|
||||
/** `TCAR:93` is Rouen line 93; the Métro and Calypso keep their names. */
|
||||
function astuceRouteLabel(routeId) {
|
||||
return ASTUCE_ROUTES[routeId ?? '']?.label ?? astuceNetworkLabel(routeId);
|
||||
}
|
||||
|
||||
/**
|
||||
* Prague PID route ids are `L` plus a number whose range says what runs it,
|
||||
* per PID's GTFS routes.txt (data.pid.cz, checked 2026-11-09): 1–99 trams
|
||||
* (50–59 trolleybuses, 49 the Petřín funicular `LD`), 100–990 buses (the
|
||||
* 800s are the X replacement lines, `L803` is X3), 991–993 metro A–C,
|
||||
* 1000s and 1100s the S and R trains (`L1004` is S4, `L1109` R9), the rest
|
||||
* of 1200–1399 other trains, 1700s town buses, 1800s the P ferries, and from
|
||||
* 2000 more buses (`L2841` is 841). A label the range cannot give stays the
|
||||
* route id.
|
||||
* @param {string|null} routeId
|
||||
* @returns {{mode: string, label: string|null}}
|
||||
*/
|
||||
function pidRoute(routeId) {
|
||||
const match = /^L(\d+)$/.exec(routeId ?? '');
|
||||
if (!match) return { mode: 'unknown', label: routeId };
|
||||
const n = Number(match[1]);
|
||||
// i18n-ignore: line code, as signed
|
||||
if (n === 49) return { mode: 'rail', label: 'LD' };
|
||||
if (n >= 50 && n <= 59) return { mode: 'bus', label: String(n) };
|
||||
if (n < 100) return { mode: 'tram', label: String(n) };
|
||||
if (n >= 800 && n < 900) return { mode: 'bus', label: `X${n - 800}` };
|
||||
if (n < 991) return { mode: 'bus', label: String(n) };
|
||||
// i18n-ignore: metro line letters, as signed
|
||||
if (n <= 993) return { mode: 'subway', label: 'ABC'[n - 991] };
|
||||
if (n >= 1000 && n < 1100) return { mode: 'rail', label: `S${n - 1000}` };
|
||||
if (n >= 1100 && n < 1200) return { mode: 'rail', label: `R${n - 1100}` };
|
||||
if (n >= 1200 && n < 1400) return { mode: 'rail', label: routeId };
|
||||
if (n >= 1800 && n < 1900) return { mode: 'ferry', label: `P${n - 1800}` };
|
||||
if (n >= 2800 && n < 2900) return { mode: 'bus', label: String(n - 2000) };
|
||||
return { mode: n >= 1700 ? 'bus' : 'unknown', label: routeId };
|
||||
}
|
||||
|
||||
/** @param {string|null} routeId @returns {string} */
|
||||
function pidRouteMode(routeId) {
|
||||
return pidRoute(routeId).mode;
|
||||
}
|
||||
|
||||
/** @param {string|null} routeId @returns {string|null} */
|
||||
function pidRouteLabel(routeId) {
|
||||
return pidRoute(routeId).label;
|
||||
}
|
||||
|
||||
/**
|
||||
* Bordeaux TBM tram and boat lines by route id, from TBM's static GTFS
|
||||
* routes.txt (checked 2026-11-09): the trams are numbered ids, not letters.
|
||||
*/
|
||||
const TBM_TRAM_LINES = Object.freeze({
|
||||
59: 'A',
|
||||
60: 'B',
|
||||
61: 'C',
|
||||
62: 'D',
|
||||
163: 'E',
|
||||
164: 'F',
|
||||
});
|
||||
const TBM_BOAT_LINES = new Set(['951', '952', '953']);
|
||||
|
||||
/**
|
||||
* Bordeaux TBM: trams A–F and the BAT³ river shuttles; every other line is a
|
||||
* bus.
|
||||
* @param {string|null} routeId
|
||||
* @returns {string}
|
||||
*/
|
||||
function tbmRouteMode(routeId) {
|
||||
if (!routeId) return 'unknown';
|
||||
if (Object.hasOwn(TBM_TRAM_LINES, routeId)) return 'tram';
|
||||
return TBM_BOAT_LINES.has(routeId) ? 'ferry' : 'bus';
|
||||
}
|
||||
|
||||
/** `59` is tram A; zero-padded bus ids lose their padding (`01` is 1). */
|
||||
function tbmRouteLabel(routeId) {
|
||||
return Object.hasOwn(TBM_TRAM_LINES, routeId ?? '')
|
||||
? TBM_TRAM_LINES[routeId]
|
||||
: unpaddedRouteLabel(routeId);
|
||||
}
|
||||
|
||||
/**
|
||||
* A registry entry, frozen with its centre and terms, and switched on.
|
||||
* @param {object} fields
|
||||
* @returns {Readonly<object>}
|
||||
*/
|
||||
function transitFeed(fields) {
|
||||
return Object.freeze({
|
||||
defaultEnabled: true,
|
||||
...fields,
|
||||
center: Object.freeze({ ...fields.center }),
|
||||
terms: Object.freeze({ ...fields.terms }),
|
||||
...(fields.headers
|
||||
? { headers: Object.freeze({ ...fields.headers }) }
|
||||
: {}),
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Registry of feeds. Order is presentation order in the stats/credit text.
|
||||
* `loadRadiusKm` is the distance from `center` inside which the feed is polled.
|
||||
@@ -398,7 +571,14 @@ function rioRouteLabel(routeId) {
|
||||
* url: string, headers?: Record<string, string>,
|
||||
* license: string, licenseUrl: string, attribution: string,
|
||||
* defaultMode: string, routeMode?: (routeId: string|null) => string,
|
||||
* speedUnit?: 'km/h', refreshMs?: number, sourceUrl?: string,
|
||||
* creditDated?: boolean,
|
||||
* }>>}
|
||||
* `speedUnit` marks a feed that publishes km/h where the spec requires m/s;
|
||||
* the proxy converts it before the snapshot leaves the server. `refreshMs`
|
||||
* stretches the proxy's cache for an upstream that rate-limits below one
|
||||
* request per 15 s TTL. `sourceUrl` and `creditDated` add a link and a date
|
||||
* to the credit for licences that ask for them (`transitFeedCredit`).
|
||||
*/
|
||||
export const TRANSIT_FEED_REGISTRY = Object.freeze([
|
||||
Object.freeze({
|
||||
@@ -788,6 +968,624 @@ export const TRANSIT_FEED_REGISTRY = Object.freeze([
|
||||
defaultMode: 'bus',
|
||||
routeLabel: rioRouteLabel,
|
||||
}),
|
||||
transitFeed({
|
||||
id: 'zditm-szczecin',
|
||||
name: 'Szczecin buses and trams',
|
||||
operator:
|
||||
'Zarząd Dróg i Transportu Miejskiego w Szczecinie (ZDiTM), Szczecin',
|
||||
region: 'Szczecin, Poland',
|
||||
// Every vehicle in a 2026-11-05 snapshot sat between 53.34–53.55 N and
|
||||
// 14.44–14.77 E, inside 20 km of this point.
|
||||
center: { lat: 53.44, lon: 14.56 },
|
||||
loadRadiusKm: 25,
|
||||
url: 'https://www.zditm.szczecin.pl/storage/gtfs/gtfs-rt-vehicles.pb',
|
||||
license: 'CC0 1.0',
|
||||
licenseUrl: 'https://www.zditm.szczecin.pl/en/zditm/for-developers',
|
||||
attribution:
|
||||
'Zarząd Dróg i Transportu Miejskiego w Szczecinie (ZDiTM Szczecin)',
|
||||
terms: {
|
||||
quote:
|
||||
'The data are provided free of charge under the CC0 1.0 licence, for use in any context, with no prior notification required.',
|
||||
note: 'CC0 needs no credit; it is given anyway as a courtesy. ZDiTM gives no guarantee of accuracy or completeness. The developer page says the feed updates every minute; measured on 2026-11-05 the file changed about every 20 seconds, with vehicle timestamps up to 50 seconds old. Speeds are m/s: checked against vehicle movement between two snapshots. The feed carries no route id at all, so every vehicle takes the feed default mode even though the city also runs trams.',
|
||||
},
|
||||
defaultMode: 'bus',
|
||||
}),
|
||||
transitFeed({
|
||||
id: 'carris-metropolitana-lisboa',
|
||||
name: 'Carris Metropolitana',
|
||||
operator: 'Carris Metropolitana (TML), Lisbon Metropolitan Area',
|
||||
region: 'Lisbon Metropolitan Area, Portugal',
|
||||
// Every vehicle in a 2026-11-07 snapshot, from Mafra to Setúbal, sat
|
||||
// between 38.47–39.00 N and 9.47–8.79 W, inside 40 km of this point.
|
||||
center: { lat: 38.73, lon: -9.13 },
|
||||
loadRadiusKm: 45,
|
||||
url: 'https://api.carrismetropolitana.pt/v2/vehicles.pb',
|
||||
license: 'No separate licence for the realtime feed',
|
||||
licenseUrl: 'https://github.com/carrismetropolitana/api',
|
||||
attribution: 'Carris Metropolitana',
|
||||
terms: {
|
||||
quote:
|
||||
'GET /vehicles.pb — Returns vehicle locations in Protobuf format, following the GTFS-RT Vehicle Locations standard.',
|
||||
note: 'The operator publishes this feed keyless and documented for developers in its public API repository, but states no licence for the realtime endpoint; its static GTFS (github.com/carrismetropolitana/gtfs) is CC BY 4.0. Credited as a courtesy, on the same basis as the Metro Transit and OVapi feeds; switch it off if Carris objects. The quote above is the API README, not a licence. `/vehicles.pb` answers with a 307 to `/v2/vehicles.pb`, so the registry points at the target. Speeds are km/h, not the m/s the spec requires: 2026-11-07 readings of 31–33 matched 6–9 m/s of measured movement, so the proxy converts them. Vehicle reports arrive every 30–50 seconds. Route ids are the GTFS route id inside an area prefix and are read as the line number.',
|
||||
},
|
||||
defaultMode: 'bus',
|
||||
routeLabel: carrisMetropolitanaRouteLabel,
|
||||
speedUnit: 'km/h',
|
||||
}),
|
||||
transitFeed({
|
||||
id: 'pid-praha',
|
||||
name: 'Prague PID',
|
||||
operator: 'Pražská integrovaná doprava (PID), via Golemio',
|
||||
region: 'Prague and Central Bohemia, Czechia',
|
||||
// PID reaches across Central Bohemia: on 2026-11-08, 95% of 923 vehicles
|
||||
// sat within 58 km of Prague, the farthest at 98 km.
|
||||
center: { lat: 50.08, lon: 14.45 },
|
||||
loadRadiusKm: 60,
|
||||
url: 'https://api.golemio.cz/v2/vehiclepositions/gtfsrt/vehicle_positions.pb',
|
||||
license: 'CC BY',
|
||||
licenseUrl: 'https://pid.cz/o-systemu/opendata/',
|
||||
attribution: 'Pražská integrovaná doprava (PID) / Golemio',
|
||||
terms: {
|
||||
quote:
|
||||
'Data, která lze stáhnout přímo zde z webu, jsou stejně jako celý obsah webu opatřena licencí CC-BY',
|
||||
note: 'The PID open-data page lists this realtime feed and licenses the data it publishes under CC BY, crediting the author and any changes. The same page says data served from other sources follows that source’s licence; the feed is served by Golemio, the city’s data platform, which states none of its own. Keyless since the catalogue moved it off the X-Access-Token endpoint. Speeds are m/s, checked against movement on 2026-11-07. Route ids are `L` plus a number whose range gives the mode and the line (metro `L991` is A, train `L1004` is S4, ferry `L1801` is P1); `pidRoute` holds the table, read from PID’s GTFS routes.txt on 2026-11-09.',
|
||||
},
|
||||
defaultMode: 'bus',
|
||||
routeLabel: pidRouteLabel,
|
||||
routeMode: pidRouteMode,
|
||||
}),
|
||||
transitFeed({
|
||||
id: 'ztm-warszawa',
|
||||
name: 'Warsaw buses and trams',
|
||||
operator: 'Miasto Stołeczne Warszawa, relayed by mkuran.pl',
|
||||
region: 'Warsaw, Poland',
|
||||
center: { lat: 52.25, lon: 21.02 },
|
||||
loadRadiusKm: 30,
|
||||
url: 'https://mkuran.pl/gtfs/warsaw/vehicles.pb',
|
||||
license: 'Warsaw Open Data Project Usage Terms',
|
||||
licenseUrl: 'https://mkuran.pl/gtfs/',
|
||||
attribution: 'Miasto Stołeczne Warszawa (api.um.warszawa.pl)',
|
||||
sourceUrl: 'http://api.um.warszawa.pl',
|
||||
creditDated: true,
|
||||
terms: {
|
||||
quote:
|
||||
'The City Hall requires a credit by providing the name Miasto Stołeczne Warszawa, data download date (use the timestamp from the FeedHeader) and link to http://api.um.warszawa.pl.',
|
||||
note: 'Positions come from the Warsaw City Hall API, repackaged as GTFS-RT by Mikołaj Kuranowski’s unofficial feed. The credit names the city, links its API (`sourceUrl`) and carries the date of the feed timestamp (`creditDated`), the three things the terms ask for. Vehicle timestamps ran about two minutes old on 2026-11-07, which the delayed playback absorbs.',
|
||||
},
|
||||
defaultMode: 'bus',
|
||||
}),
|
||||
transitFeed({
|
||||
id: 'tbm-bordeaux',
|
||||
name: 'Bordeaux TBM',
|
||||
operator: 'Transports Bordeaux Métropole (TBM), Bordeaux Métropole',
|
||||
region: 'Bordeaux, France',
|
||||
center: { lat: 44.85, lon: -0.65 },
|
||||
loadRadiusKm: 20,
|
||||
url: 'https://bdx.mecatran.com/utw/ws/gtfsfeed/vehicles/bordeaux?apiKey=opendata-bordeaux-metropole-flux-gtfs-rt',
|
||||
license: 'Licence Ouverte / Etalab 2.0',
|
||||
licenseUrl:
|
||||
'https://transport.data.gouv.fr/datasets/offres-de-services-bus-tram-et-scolaire-au-format-gtfs-netex-gtfs-rt-siri-lite',
|
||||
attribution: 'Bordeaux Métropole (TBM)',
|
||||
terms: {
|
||||
quote: 'licence: fr-lo',
|
||||
note: 'The quote is the licence field of the national access point’s dataset record (fr-lo is the Licence Ouverte), which asks only for credit. The `apiKey` in the URL is not a credential: it is the same fixed string printed in the open-data listing for everyone. Speeds are m/s. The trams (A–F) and BAT³ boats ride numbered route ids (tram A is `59`), so `tbmRouteMode` and `tbmRouteLabel` map them from TBM’s static GTFS; other numbered lines are buses.',
|
||||
},
|
||||
defaultMode: 'bus',
|
||||
routeLabel: tbmRouteLabel,
|
||||
routeMode: tbmRouteMode,
|
||||
}),
|
||||
transitFeed({
|
||||
id: 'sendai-city-bus',
|
||||
name: 'Sendai City Bus',
|
||||
operator: 'Sendai City Transportation Bureau (仙台市交通局), via ODPT',
|
||||
region: 'Sendai, Japan',
|
||||
center: { lat: 38.27, lon: 140.82 },
|
||||
loadRadiusKm: 22,
|
||||
url: 'https://api-public.odpt.org/api/v4/gtfs/realtime/odpt_SendaiMunicipal_bus_realtime_information_vehicle',
|
||||
license: 'CC BY 4.0',
|
||||
licenseUrl: 'https://creativecommons.org/licenses/by/4.0/',
|
||||
attribution: '仙台市交通局 (Sendai City Transportation Bureau) / ODPT',
|
||||
terms: {
|
||||
quote: 'https://creativecommons.org/licenses/by/4.0/',
|
||||
note: 'Served by the Open Data Challenge for Public Transportation (ODPT) public API, which needs no key for this feed; the catalogue records CC BY 4.0 as its licence. Vehicle timestamps ran about two minutes old on 2026-11-07. Speeds are m/s.',
|
||||
},
|
||||
defaultMode: 'bus',
|
||||
}),
|
||||
transitFeed({
|
||||
id: 'ztm-poznan',
|
||||
name: 'Poznań buses and trams',
|
||||
operator: 'Zarząd Transportu Miejskiego w Poznaniu (ZTM Poznań)',
|
||||
region: 'Poznań, Poland',
|
||||
center: { lat: 52.39, lon: 16.92 },
|
||||
loadRadiusKm: 20,
|
||||
url: 'https://www.ztm.poznan.pl/pl/dla-deweloperow/getGtfsRtFile/?file=vehicle_positions.pb',
|
||||
license: 'ZTM Poznań open-data terms',
|
||||
licenseUrl: 'https://www.ztm.poznan.pl/otwarte-dane/dla-deweloperow/',
|
||||
attribution: 'Zarząd Transportu Miejskiego w Poznaniu (processed)',
|
||||
creditDated: true,
|
||||
terms: {
|
||||
quote:
|
||||
'Treści udostępniane są bezwnioskowo i bezpłatnie, na zasadach powszechnego dostępu i stanowią źródło informacji.',
|
||||
note: 'Reuse is free on three conditions: name the source, give the date of the last update, and say the data were processed. The credit names ZTM, says processed, and carries the date of the feed timestamp (`creditDated`) as the update date. The feed carries no bearing, so heading comes from movement between fixes.',
|
||||
},
|
||||
defaultMode: 'bus',
|
||||
}),
|
||||
transitFeed({
|
||||
id: 'ztm-gdansk',
|
||||
name: 'Gdańsk buses and trams',
|
||||
operator: 'Zarząd Transportu Miejskiego w Gdańsku (ZTM Gdańsk)',
|
||||
region: 'Gdańsk, Poland',
|
||||
center: { lat: 54.35, lon: 18.6 },
|
||||
loadRadiusKm: 20,
|
||||
url: 'https://ckan2.multimediagdansk.pl/gtfs-rt?feed=vehiclePositions',
|
||||
license: 'CC BY 4.0',
|
||||
licenseUrl:
|
||||
'https://dane.gov.pl/pl/dataset/38599,rozklady-jazdy-i-lokalizacja-przystankow-gtfs-rt',
|
||||
attribution: 'Zarząd Transportu Miejskiego w Gdańsku',
|
||||
terms: {
|
||||
note: 'The national catalogue (dane.gov.pl) lists this dataset under CC BY 4.0. No bearing; heading comes from movement. Speeds are m/s.',
|
||||
},
|
||||
defaultMode: 'bus',
|
||||
}),
|
||||
transitFeed({
|
||||
id: 'ets-edmonton',
|
||||
name: 'Edmonton Transit Service',
|
||||
operator: 'City of Edmonton (Edmonton Transit Service)',
|
||||
region: 'Edmonton, AB',
|
||||
center: { lat: 53.53, lon: -113.52 },
|
||||
loadRadiusKm: 25,
|
||||
url: 'https://gtfs.edmonton.ca/TMGTFSRealTimeWebService/Vehicle/VehiclePositions.pb',
|
||||
license: 'City of Edmonton Open Data Agreement',
|
||||
licenseUrl:
|
||||
'https://www.edmonton.ca/transportation/Web-version2.1-OpenDataAgreement.pdf',
|
||||
attribution:
|
||||
'Contains information licensed under the Open Data Agreement – City of Edmonton',
|
||||
terms: {
|
||||
note: 'The agreement is the same municipal template as Mississauga and Burlington: a licence to use, modify and distribute for any lawful purpose, in any medium. It was read from search excerpts; the PDF itself would not extract here. Route ids are zero-padded. Speeds are m/s.',
|
||||
},
|
||||
defaultMode: 'bus',
|
||||
routeLabel: unpaddedRouteLabel,
|
||||
}),
|
||||
transitFeed({
|
||||
id: 'halifax-transit',
|
||||
name: 'Halifax Transit',
|
||||
operator: 'Halifax Regional Municipality (Halifax Transit)',
|
||||
region: 'Halifax, NS',
|
||||
center: { lat: 44.7, lon: -63.6 },
|
||||
loadRadiusKm: 22,
|
||||
url: 'https://gtfs.halifax.ca/realtime/Vehicle/VehiclePositions.pb',
|
||||
license: 'Open Government Licence – Halifax',
|
||||
licenseUrl: 'https://www.halifax.ca/home/open-data/open-data-license',
|
||||
attribution:
|
||||
'Contains information licenced under the Open Government Licence – Halifax',
|
||||
terms: {
|
||||
quote:
|
||||
'The information provider grants you a worldwide, royalty-free, perpetual, non-exclusive licence to use the Information, including for commercial purposes, subject to the terms below.',
|
||||
note: 'Version 1.0, modelled on the Open Government Licence – Canada 2.0. The attribution is the licence’s own standard statement, with a link to the licence where possible. Logos and crests are excluded and no endorsement may be implied, so the credit stays plain text. The page refuses automated requests (403); its text was read in a browser on 2026-11-08. Speeds are m/s.',
|
||||
},
|
||||
defaultMode: 'bus',
|
||||
}),
|
||||
transitFeed({
|
||||
id: 'bc-transit-victoria',
|
||||
name: 'Victoria Regional Transit',
|
||||
operator: 'BC Transit (Victoria Regional Transit System)',
|
||||
region: 'Victoria, BC',
|
||||
center: { lat: 48.53, lon: -123.43 },
|
||||
loadRadiusKm: 28,
|
||||
url: 'https://bct.tmix.se/gtfs-realtime/vehicleupdates.pb?operatorIds=48',
|
||||
license: 'BC Transit Open Data Terms of Use',
|
||||
licenseUrl: 'https://www.bctransit.com/open-data/terms-of-use',
|
||||
attribution: 'BC Transit',
|
||||
terms: {
|
||||
quote:
|
||||
'BC Transit grants you a limited, revocable and non-exclusive license to use, reproduce, and redistribute the Data in accordance with these Terms.',
|
||||
note: 'The grant is revocable, like the Ontario municipal templates. Route ids carry a `-VIC` system suffix. Speeds are m/s.',
|
||||
},
|
||||
defaultMode: 'bus',
|
||||
routeLabel: bcTransitRouteLabel,
|
||||
}),
|
||||
transitFeed({
|
||||
id: 'tam-montpellier',
|
||||
name: 'Montpellier TaM',
|
||||
operator: 'Montpellier Méditerranée Métropole (TaM)',
|
||||
region: 'Montpellier, France',
|
||||
center: { lat: 43.61, lon: 3.87 },
|
||||
loadRadiusKm: 20,
|
||||
url: 'https://gtfsproxy.e-tam.fr/COMMON/VehiclePosition.pb',
|
||||
license: 'ODbL',
|
||||
licenseUrl:
|
||||
'https://transport.data.gouv.fr/datasets/offre-de-transport-tam-en-temps-reel-gtfs-rt-urbain-et-suburbain',
|
||||
attribution: 'Montpellier Méditerranée Métropole (TaM)',
|
||||
terms: {
|
||||
quote: 'licence: odc-odbl',
|
||||
note: 'The quote is the dataset record’s licence field. ODbL asks for credit and share-alike on a derived database; the layer redistributes no database, it draws the positions. Speeds are km/h: readings ran 3.3 times the measured movement on 2026-11-07, so the proxy converts them.',
|
||||
},
|
||||
defaultMode: 'bus',
|
||||
speedUnit: 'km/h',
|
||||
}),
|
||||
transitFeed({
|
||||
id: 'ztp-krakow-bus',
|
||||
name: 'Kraków buses',
|
||||
operator: 'Zarząd Transportu Publicznego w Krakowie (ZTP Kraków)',
|
||||
region: 'Kraków, Poland',
|
||||
center: { lat: 50.06, lon: 19.94 },
|
||||
loadRadiusKm: 22,
|
||||
url: 'https://gtfs.ztp.krakow.pl/VehiclePositions_A.pb',
|
||||
license: 'No licence stated',
|
||||
licenseUrl: 'https://gtfs.ztp.krakow.pl/',
|
||||
attribution: 'Zarząd Transportu Publicznego w Krakowie',
|
||||
terms: {
|
||||
note: 'ZTP publishes this feed keyless on its own GTFS server and lists it in the Mobility Database, but states no licence there or on dane.gov.pl. Shipped on the same basis as Metro Transit and OVapi; switch it off if ZTP objects.',
|
||||
},
|
||||
defaultMode: 'bus',
|
||||
}),
|
||||
transitFeed({
|
||||
id: 'ztp-krakow-tram',
|
||||
name: 'Kraków trams',
|
||||
operator: 'Zarząd Transportu Publicznego w Krakowie (ZTP Kraków)',
|
||||
region: 'Kraków, Poland',
|
||||
center: { lat: 50.06, lon: 19.94 },
|
||||
loadRadiusKm: 22,
|
||||
url: 'https://gtfs.ztp.krakow.pl/VehiclePositions_T.pb',
|
||||
license: 'No licence stated',
|
||||
licenseUrl: 'https://gtfs.ztp.krakow.pl/',
|
||||
attribution: 'Zarząd Transportu Publicznego w Krakowie',
|
||||
terms: { note: 'Same server and basis as the bus feed.' },
|
||||
defaultMode: 'tram',
|
||||
}),
|
||||
transitFeed({
|
||||
id: 'vilnius-transport',
|
||||
name: 'Vilnius public transport',
|
||||
operator: 'SĮ Susisiekimo paslaugos, Vilnius',
|
||||
region: 'Vilnius, Lithuania',
|
||||
center: { lat: 54.69, lon: 25.28 },
|
||||
loadRadiusKm: 20,
|
||||
url: 'https://www.stops.lt/vilnius/vehicle_positions.pb',
|
||||
license: 'No licence stated',
|
||||
licenseUrl: 'https://mobilitydatabase.org/feeds/gtfs_rt/mdb-2383',
|
||||
attribution: 'SĮ Susisiekimo paslaugos (stops.lt)',
|
||||
terms: {
|
||||
note: 'Published keyless by the city transport agency on stops.lt; no licence found. Shipped on the same basis as Metro Transit and OVapi. Answered 522 once on 2026-11-07 and normally since.',
|
||||
},
|
||||
defaultMode: 'bus',
|
||||
}),
|
||||
transitFeed({
|
||||
id: 'tpbi-bucuresti',
|
||||
name: 'Bucharest public transport',
|
||||
operator: 'Asociația de Dezvoltare Intercomunitară TPBI, Bucharest–Ilfov',
|
||||
region: 'Bucharest, Romania',
|
||||
center: { lat: 44.43, lon: 26.1 },
|
||||
loadRadiusKm: 25,
|
||||
url: 'https://gtfs.tpbi.ro/api/gtfs-rt/vehiclePositions',
|
||||
license: 'No licence stated',
|
||||
licenseUrl: 'https://mobilitydatabase.org/feeds/gtfs_rt/mdb-2104',
|
||||
attribution: 'TPBI (Transport Public București–Ilfov)',
|
||||
terms: {
|
||||
note: 'Keyless public endpoint from the metropolitan transport authority; no licence found. Same basis as Metro Transit and OVapi.',
|
||||
},
|
||||
defaultMode: 'bus',
|
||||
}),
|
||||
transitFeed({
|
||||
id: 'roma-mobilita',
|
||||
name: 'Rome public transport',
|
||||
operator: 'Roma Servizi per la Mobilità',
|
||||
region: 'Rome, Italy',
|
||||
center: { lat: 41.89, lon: 12.5 },
|
||||
loadRadiusKm: 35,
|
||||
url: 'https://romamobilita.it/wp-content/uploads/shared/rome_rtgtfs_vehicle_positions_feed.pb',
|
||||
license: 'No licence stated',
|
||||
licenseUrl: 'https://mobilitydatabase.org/feeds/gtfs_rt/mdb-1776',
|
||||
attribution: 'Roma Servizi per la Mobilità',
|
||||
terms: {
|
||||
note: 'Keyless file on the agency’s own site; the catalogue’s older `/sites/default/files/` path now 404s. No licence found; same basis as Metro Transit and OVapi. Fewer than one vehicle in five carries a bearing, so most headings come from movement.',
|
||||
},
|
||||
defaultMode: 'bus',
|
||||
}),
|
||||
transitFeed({
|
||||
id: 'gtt-torino',
|
||||
name: 'Turin GTT',
|
||||
operator: 'Gruppo Torinese Trasporti (GTT)',
|
||||
region: 'Turin, Italy',
|
||||
center: { lat: 45.07, lon: 7.68 },
|
||||
loadRadiusKm: 20,
|
||||
url: 'https://percorsieorari.gtt.to.it/das_gtfsrt/vehicle_position.aspx',
|
||||
license: 'No licence stated',
|
||||
licenseUrl: 'https://mobilitydatabase.org/feeds/gtfs_rt/mdb-2696',
|
||||
attribution: 'Gruppo Torinese Trasporti (GTT)',
|
||||
terms: {
|
||||
note: 'Official keyless endpoint; no licence found. Same basis as Metro Transit and OVapi. Route ids append `U` for urban lines.',
|
||||
},
|
||||
defaultMode: 'bus',
|
||||
routeLabel: gttRouteLabel,
|
||||
}),
|
||||
transitFeed({
|
||||
id: 'actv-venezia-bus',
|
||||
name: 'Venice ACTV buses',
|
||||
operator: 'Azienda del Consorzio Trasporti Veneziano (ACTV)',
|
||||
region: 'Venice, Italy',
|
||||
center: { lat: 45.4, lon: 12.2 },
|
||||
loadRadiusKm: 38,
|
||||
url: 'https://tpl.actv.it/aut/GTFSRT/vehiclePositions',
|
||||
license: 'ACTV open-data catalogue',
|
||||
licenseUrl:
|
||||
'https://actv.avmspa.it/it/content/catalogo-dei-dati-metadati-e-banche-dati-actv',
|
||||
attribution: 'ACTV S.p.A.',
|
||||
terms: {
|
||||
note: 'ACTV lists this feed in its own open-data catalogue; that page would not render for a script, so its licence is not quoted. Same basis as Metro Transit and OVapi. Route ids append a two-letter network code (`_UM`, `_ES`, `_UN`).',
|
||||
},
|
||||
defaultMode: 'bus',
|
||||
routeLabel: actvRouteLabel,
|
||||
}),
|
||||
transitFeed({
|
||||
id: 'actv-venezia-waterbus',
|
||||
name: 'Venice ACTV waterbuses',
|
||||
operator: 'Azienda del Consorzio Trasporti Veneziano (ACTV) Navigazione',
|
||||
region: 'Venice, Italy',
|
||||
center: { lat: 45.43, lon: 12.33 },
|
||||
loadRadiusKm: 15,
|
||||
url: 'https://tpl.actv.it/nav/GTFSRT/vehiclePositions',
|
||||
license: 'ACTV open-data catalogue',
|
||||
licenseUrl:
|
||||
'https://actv.avmspa.it/it/content/catalogo-dei-dati-metadati-e-banche-dati-actv',
|
||||
attribution: 'ACTV S.p.A.',
|
||||
terms: { note: 'Same catalogue and basis as the ACTV bus feed.' },
|
||||
defaultMode: 'ferry',
|
||||
routeLabel: actvRouteLabel,
|
||||
}),
|
||||
transitFeed({
|
||||
id: 'adelaide-metro',
|
||||
name: 'Adelaide Metro',
|
||||
operator: 'Adelaide Metro (Government of South Australia)',
|
||||
region: 'Adelaide, SA',
|
||||
center: { lat: -34.93, lon: 138.6 },
|
||||
loadRadiusKm: 35,
|
||||
url: 'https://gtfs.adelaidemetro.com.au/v1/realtime/vehicle_positions',
|
||||
// Any Accept naming a protobuf type gets base64 text labelled JSON; only
|
||||
// */* returns the binary feed (checked 2026-11-08).
|
||||
headers: { Accept: '*/*' },
|
||||
license: 'No licence stated for the realtime feed',
|
||||
licenseUrl: 'https://mobilitydatabase.org/feeds/gtfs_rt/mdb-1772',
|
||||
attribution: 'Adelaide Metro',
|
||||
terms: {
|
||||
note: 'Official keyless endpoint; the state catalogue page refused automated reads, so no licence is quoted. Same basis as Metro Transit and OVapi. Speeds are m/s. The server picks its encoding from Accept, hence the override.',
|
||||
},
|
||||
defaultMode: 'bus',
|
||||
}),
|
||||
transitFeed({
|
||||
id: 'marta-atlanta',
|
||||
name: 'MARTA buses',
|
||||
operator: 'Metropolitan Atlanta Rapid Transit Authority (MARTA)',
|
||||
region: 'Atlanta, GA',
|
||||
center: { lat: 33.78, lon: -84.39 },
|
||||
loadRadiusKm: 35,
|
||||
url: 'https://gtfs-rt.itsmarta.com/TMGTFSRealTimeWebService/vehicle/vehiclepositions.pb',
|
||||
license: 'No licence stated',
|
||||
licenseUrl: 'https://mobilitydatabase.org/feeds/gtfs_rt/mdb-1601',
|
||||
attribution: 'MARTA',
|
||||
terms: {
|
||||
note: 'Official keyless endpoint; no licence found. Same basis as Metro Transit and OVapi. Speeds are m/s.',
|
||||
},
|
||||
defaultMode: 'bus',
|
||||
}),
|
||||
transitFeed({
|
||||
id: 'rtd-denver',
|
||||
name: 'Denver RTD',
|
||||
operator: 'Regional Transportation District (RTD), Denver',
|
||||
region: 'Denver, CO',
|
||||
center: { lat: 39.75, lon: -104.99 },
|
||||
loadRadiusKm: 55,
|
||||
url: 'https://open-data.rtd-denver.com/files/gtfs-rt/rtd/VehiclePosition.pb',
|
||||
license: 'RTD GTFS-realtime licence agreement',
|
||||
licenseUrl:
|
||||
'https://www.rtd-denver.com/business-center/open-spatial-data/gtfs-realtime-license-agreement',
|
||||
attribution: 'Regional Transportation District (RTD)',
|
||||
terms: {
|
||||
quote:
|
||||
'RTD hereby grants you non-exclusive, limited and revocable rights to use, reproduce, and redistribute the Data',
|
||||
note: 'Read 2026-11-09. The agreement is a click-through (“By clicking to download the Data files, you confirm that you have read and agree”) that RTD may change without notice; it permits redistribution, asks for no credit wording, and bars RTD trademarks from being used with the data, so the credit stays plain text. The feed itself is keyless. Speeds are m/s.',
|
||||
},
|
||||
defaultMode: 'bus',
|
||||
}),
|
||||
transitFeed({
|
||||
id: 'ctp-cluj',
|
||||
name: 'Cluj-Napoca CTP',
|
||||
operator: 'Compania de Transport Public Cluj-Napoca',
|
||||
region: 'Cluj-Napoca, Romania',
|
||||
center: { lat: 46.77, lon: 23.59 },
|
||||
loadRadiusKm: 15,
|
||||
url: 'https://cluj-rt-feed.gtfs.ro/vehiclePositions',
|
||||
license: 'No licence stated',
|
||||
licenseUrl: 'https://mobilitydatabase.org/feeds/gtfs_rt/mdb-2614',
|
||||
attribution: 'Compania de Transport Public Cluj-Napoca',
|
||||
terms: {
|
||||
note: 'Keyless; no licence found. Same basis as Metro Transit and OVapi.',
|
||||
},
|
||||
defaultMode: 'bus',
|
||||
}),
|
||||
transitFeed({
|
||||
id: 'ctp-iasi',
|
||||
name: 'Iași CTP',
|
||||
operator: 'Compania de Transport Public Iași',
|
||||
region: 'Iași, Romania',
|
||||
center: { lat: 47.16, lon: 27.59 },
|
||||
loadRadiusKm: 15,
|
||||
url: 'https://iasi-rt-feed.gtfs.ro/vehiclePositions',
|
||||
license: 'No licence stated',
|
||||
licenseUrl: 'https://mobilitydatabase.org/feeds/gtfs_rt/mdb-2118',
|
||||
attribution: 'Compania de Transport Public Iași',
|
||||
terms: {
|
||||
note: 'Keyless; no licence found. Same basis as Metro Transit and OVapi.',
|
||||
},
|
||||
defaultMode: 'bus',
|
||||
}),
|
||||
transitFeed({
|
||||
id: 'mpk-rzeszow',
|
||||
name: 'Rzeszów city transport',
|
||||
operator: 'Rzeszowski Transport Miejski (MPK Rzeszów)',
|
||||
region: 'Rzeszów, Poland',
|
||||
center: { lat: 50.04, lon: 22.0 },
|
||||
loadRadiusKm: 15,
|
||||
url: 'https://www.mpkrzeszow.pl/gtfs/rt/gtfsrt.pb',
|
||||
license: 'MPK Rzeszów open data',
|
||||
licenseUrl: 'https://www.mpkrzeszow.pl/otwartedane/',
|
||||
attribution: 'MPK Rzeszów',
|
||||
terms: {
|
||||
note: 'Listed on the operator’s open-data page, which names no licence. No bearing; heading comes from movement.',
|
||||
},
|
||||
defaultMode: 'bus',
|
||||
}),
|
||||
transitFeed({
|
||||
id: 'emt-malaga',
|
||||
name: 'Málaga EMT',
|
||||
operator: 'Empresa Malagueña de Transportes (EMT)',
|
||||
region: 'Málaga, Spain',
|
||||
center: { lat: 36.72, lon: -4.42 },
|
||||
loadRadiusKm: 15,
|
||||
url: 'https://gtfs.emtmalaga.es/GTFSRTapi/api/vehicleposition',
|
||||
license: 'No licence stated',
|
||||
licenseUrl: 'https://mobilitydatabase.org/feeds/gtfs_rt/mdb-2213',
|
||||
attribution: 'EMT Málaga',
|
||||
terms: {
|
||||
note: 'Keyless; no licence found. Same basis as Metro Transit and OVapi. No bearing; heading comes from movement.',
|
||||
},
|
||||
defaultMode: 'bus',
|
||||
}),
|
||||
transitFeed({
|
||||
id: 'carris-lisboa',
|
||||
name: 'Carris (Lisbon city)',
|
||||
operator: 'Carris – Companhia Carris de Ferro de Lisboa',
|
||||
region: 'Lisbon, Portugal',
|
||||
center: { lat: 38.74, lon: -9.15 },
|
||||
loadRadiusKm: 15,
|
||||
url: 'https://gateway.carris.pt/gateway/gtfs/api/v2.11/GTFS/realtime/vehiclepositions',
|
||||
license: 'No licence stated',
|
||||
licenseUrl: 'https://mobilitydatabase.org/feeds/gtfs_rt/mdb-2930',
|
||||
attribution: 'Carris',
|
||||
terms: {
|
||||
note: 'Keyless official gateway; no licence found. Same basis as Metro Transit and OVapi. Carries neither bearing nor speed, and vehicle reports run about a minute old. Route ids append a variant.',
|
||||
},
|
||||
defaultMode: 'bus',
|
||||
routeLabel: carrisRouteLabel,
|
||||
}),
|
||||
transitFeed({
|
||||
id: 'mybas-johor',
|
||||
name: 'BAS.MY Johor Bahru',
|
||||
operator: 'BAS.MY, via data.gov.my',
|
||||
region: 'Johor Bahru, Malaysia',
|
||||
center: { lat: 1.51, lon: 103.75 },
|
||||
loadRadiusKm: 35,
|
||||
url: 'https://api.data.gov.my/gtfs-realtime/vehicle-position/mybas-johor/',
|
||||
license: 'CC BY 4.0',
|
||||
licenseUrl: 'https://developer.data.gov.my/realtime-api/gtfs-realtime',
|
||||
attribution: 'BAS.MY / data.gov.my',
|
||||
// data.gov.my allows 4 GTFS-Realtime requests a minute and refreshes
|
||||
// vehicle positions every 30 seconds, so the proxy asks half as often as
|
||||
// the default 15 s TTL would.
|
||||
refreshMs: 30_000,
|
||||
terms: {
|
||||
quote: 'All GTFS Realtime feeds are licensed under CC BY 4.0.',
|
||||
note: 'Served keyless by Malaysia’s national open-data API (developer.data.gov.my, read 2026-11-09). Its rate-limit page caps GTFS Realtime at 4 requests a minute and answers 429 above that; the feed updates every 30 seconds, hence `refreshMs`. Without the trailing slash the API redirects. Route ids append an operator code.',
|
||||
},
|
||||
defaultMode: 'bus',
|
||||
routeLabel: mybasJohorRouteLabel,
|
||||
}),
|
||||
transitFeed({
|
||||
id: 'mybas-kota-bharu',
|
||||
name: 'BAS.MY Kota Bharu',
|
||||
operator: 'BAS.MY, via data.gov.my',
|
||||
region: 'Kota Bharu, Malaysia',
|
||||
// Routes run south into Kelantan: 95% of vehicles within 58 km on 2026-11-08.
|
||||
center: { lat: 6.06, lon: 102.22 },
|
||||
loadRadiusKm: 60,
|
||||
url: 'https://api.data.gov.my/gtfs-realtime/vehicle-position/mybas-kota-bharu/',
|
||||
license: 'CC BY 4.0',
|
||||
licenseUrl: 'https://developer.data.gov.my/realtime-api/gtfs-realtime',
|
||||
attribution: 'BAS.MY / data.gov.my',
|
||||
refreshMs: 30_000,
|
||||
terms: {
|
||||
quote: 'All GTFS Realtime feeds are licensed under CC BY 4.0.',
|
||||
note: 'Same API, licence and rate limit as Johor Bahru.',
|
||||
},
|
||||
defaultMode: 'bus',
|
||||
}),
|
||||
transitFeed({
|
||||
id: 'astuce-rouen',
|
||||
name: 'Rouen Astuce',
|
||||
operator: 'Métropole Rouen Normandie (Astuce), réseau TCAR',
|
||||
region: 'Rouen, France',
|
||||
center: { lat: 49.44, lon: 1.1 },
|
||||
loadRadiusKm: 20,
|
||||
url: 'https://api.mrn.cityway.fr/dataflow/vehicle-tc-tr/download?provider=TCAR&dataFormat=gtfs-rt',
|
||||
license: 'Licence Ouverte 2.0',
|
||||
licenseUrl:
|
||||
'https://transport.data.gouv.fr/datasets/donnees-statiques-et-temps-reel-du-reseau-astuce-metropole-rouen-normandie',
|
||||
attribution: 'Métropole Rouen Normandie (Astuce)',
|
||||
terms: {
|
||||
quote: 'licence: lov2',
|
||||
note: 'The metropolis publishes its realtime data under the Licence Ouverte (dataset record quoted), and this is its own TCAR vehicle feed from that record (178 vehicles on 2026-11-09). The suburban TAE and TNI networks are separate feeds in the same record and are not read here. Route ids carry the network prefix (`TCAR:`); `TCAR:90` is the Métro (a street-running light rail, drawn as a tram) and `TCAR:99` the Calypso boat.',
|
||||
},
|
||||
defaultMode: 'bus',
|
||||
routeLabel: astuceRouteLabel,
|
||||
routeMode: astuceRouteMode,
|
||||
}),
|
||||
transitFeed({
|
||||
id: 'mpm-toulon',
|
||||
name: 'Toulon Mistral',
|
||||
operator: 'Métropole Toulon Provence Méditerranée (réseau Mistral)',
|
||||
region: 'Toulon, France',
|
||||
center: { lat: 43.12, lon: 5.94 },
|
||||
loadRadiusKm: 18,
|
||||
url: 'https://feed-rdtpm-toulon.ratpdev.com/VehiclePosition/GTFS-RT',
|
||||
license: 'Licence Ouverte 2.0',
|
||||
licenseUrl:
|
||||
'https://transport.data.gouv.fr/datasets/reseau-de-transport-urbain-de-la-metropole-toulon-provence-mediterranee',
|
||||
attribution: 'Métropole Toulon Provence Méditerranée (Mistral)',
|
||||
terms: {
|
||||
quote: 'licence: lov2',
|
||||
note: 'Dataset record’s licence field quoted. Speeds are km/h: readings ran 3.5 times the measured movement on 2026-11-07, so the proxy converts them. Route ids are zero-padded.',
|
||||
},
|
||||
defaultMode: 'bus',
|
||||
routeLabel: unpaddedRouteLabel,
|
||||
speedUnit: 'km/h',
|
||||
}),
|
||||
transitFeed({
|
||||
id: 'lia-le-havre',
|
||||
name: 'Le Havre LiA',
|
||||
operator: 'Le Havre Seine Métropole (LiA)',
|
||||
region: 'Le Havre, France',
|
||||
center: { lat: 49.49, lon: 0.11 },
|
||||
loadRadiusKm: 18,
|
||||
url: 'https://opendata.transports-lia.fr/gtfs-rt/VehiclePosition.pb',
|
||||
license: 'ODbL',
|
||||
licenseUrl:
|
||||
'https://transport.data.gouv.fr/datasets/reseau-de-transport-en-commun-lia-gtfs-siri',
|
||||
attribution: 'Le Havre Seine Métropole (LiA)',
|
||||
terms: {
|
||||
quote: 'licence: odc-odbl',
|
||||
note: 'The network publishes under ODbL (dataset record quoted), and this is its own GTFS-RT vehicle feed from that record (105 vehicles on 2026-11-09). The layer draws positions and redistributes no database. Route ids carry the network prefix `8-`; lines A and B are the tramway.',
|
||||
},
|
||||
defaultMode: 'bus',
|
||||
routeLabel: liaRouteLabel,
|
||||
routeMode: liaRouteMode,
|
||||
}),
|
||||
transitFeed({
|
||||
id: 'filbleu-tours',
|
||||
name: 'Tours Fil Bleu',
|
||||
operator: 'Syndicat des Mobilités de Touraine (Fil Bleu)',
|
||||
region: 'Tours, France',
|
||||
center: { lat: 47.39, lon: 0.69 },
|
||||
loadRadiusKm: 18,
|
||||
url: 'https://data.filbleu.fr/ws-tr/gtfs-rt/opendata/vehicle-positions',
|
||||
license: 'Licence Ouverte 2.0',
|
||||
licenseUrl:
|
||||
'https://transport.data.gouv.fr/datasets/fil-bleu-syndicat-des-mobilites-gtfs-gtfs-rt',
|
||||
attribution: 'Fil Bleu – Syndicat des Mobilités de Touraine',
|
||||
terms: {
|
||||
quote: 'licence: lov2',
|
||||
note: 'Dataset record’s licence field quoted.',
|
||||
},
|
||||
defaultMode: 'bus',
|
||||
}),
|
||||
]);
|
||||
|
||||
/**
|
||||
|
||||
@@ -552,3 +552,229 @@ test('Rio feeds are CC BY 4.0 and live', () => {
|
||||
'Rio has a DATA_SOURCES row',
|
||||
);
|
||||
});
|
||||
|
||||
test('Szczecin is CC0, live, covers the city and not Berlin', () => {
|
||||
const feed = getTransitFeed('zditm-szczecin');
|
||||
assert.equal(feed.defaultEnabled, true);
|
||||
assert.equal(feed.license, 'CC0 1.0');
|
||||
assert.equal(
|
||||
feed.licenseUrl,
|
||||
'https://www.zditm.szczecin.pl/en/zditm/for-developers',
|
||||
);
|
||||
assert.match(feed.terms.quote, /CC0 1\.0 licence/);
|
||||
assert.match(feed.attribution, /ZDiTM/);
|
||||
assert.equal(feed.routeLabel, undefined, 'the feed has no route ids');
|
||||
assert.equal(transitModeFor(feed, null), 'bus');
|
||||
const ids = (lat, lon) => transitFeedsInRange(lat, lon).map((f) => f.id);
|
||||
assert.ok(ids(53.4285, 14.5528).includes('zditm-szczecin'), 'city centre');
|
||||
assert.ok(ids(53.5, 14.7).includes('zditm-szczecin'), 'north-east edge');
|
||||
assert.ok(!ids(52.52, 13.405).includes('zditm-szczecin'), 'Berlin');
|
||||
const sources = readFileSync(
|
||||
new URL('../../DATA_SOURCES.md', import.meta.url),
|
||||
'utf8',
|
||||
);
|
||||
assert.ok(
|
||||
sources.split('\n').some((l) => l.startsWith('| **ZDiTM Szczecin')),
|
||||
'Szczecin has a DATA_SOURCES row',
|
||||
);
|
||||
});
|
||||
|
||||
test('Carris Metropolitana covers Lisbon from Mafra to Setúbal, not Porto', () => {
|
||||
const feed = getTransitFeed('carris-metropolitana-lisboa');
|
||||
assert.equal(feed.defaultEnabled, true);
|
||||
assert.equal(feed.url, 'https://api.carrismetropolitana.pt/v2/vehicles.pb');
|
||||
assert.equal(feed.speedUnit, 'km/h');
|
||||
assert.match(feed.terms.note, /no licence for the realtime endpoint/);
|
||||
const ids = (lat, lon) => transitFeedsInRange(lat, lon).map((f) => f.id);
|
||||
for (const [place, lat, lon] of [
|
||||
['Lisbon', 38.7223, -9.1393],
|
||||
['Mafra', 38.9369, -9.3277],
|
||||
['Setúbal', 38.5244, -8.8882],
|
||||
]) {
|
||||
assert.ok(ids(lat, lon).includes(feed.id), place);
|
||||
}
|
||||
assert.ok(!ids(41.1579, -8.6291).includes(feed.id), 'Porto');
|
||||
const sources = readFileSync(
|
||||
new URL('../../DATA_SOURCES.md', import.meta.url),
|
||||
'utf8',
|
||||
);
|
||||
assert.ok(
|
||||
sources.split('\n').some((l) => l.startsWith('| **Carris Metropolitana')),
|
||||
'Lisbon has a DATA_SOURCES row',
|
||||
);
|
||||
});
|
||||
|
||||
test('Carris Metropolitana route ids read as the line number on the bus', () => {
|
||||
const feed = getTransitFeed('carris-metropolitana-lisboa');
|
||||
assert.equal(transitRouteLabel(feed, '[LA77N]1708_0'), '1708');
|
||||
assert.equal(transitRouteLabel(feed, '[BNA17]2772_1'), '2772');
|
||||
assert.equal(transitRouteLabel(feed, 'unexpected'), 'unexpected');
|
||||
assert.equal(transitRouteLabel(feed, null), null);
|
||||
});
|
||||
|
||||
// The 2026-11 batch: one landmark per feed, inside its own radius.
|
||||
const NEW_CITY_LANDMARKS = {
|
||||
'pid-praha': [50.0875, 14.4213],
|
||||
'ztm-warszawa': [52.2297, 21.0122],
|
||||
'tbm-bordeaux': [44.8378, -0.5792],
|
||||
'sendai-city-bus': [38.2602, 140.8824],
|
||||
'ztm-poznan': [52.4064, 16.9252],
|
||||
'ztm-gdansk': [54.352, 18.6466],
|
||||
'ets-edmonton': [53.5461, -113.4938],
|
||||
'halifax-transit': [44.6488, -63.5752],
|
||||
'bc-transit-victoria': [48.4284, -123.3656],
|
||||
'tam-montpellier': [43.6108, 3.8767],
|
||||
'ztp-krakow-bus': [50.0614, 19.9366],
|
||||
'ztp-krakow-tram': [50.0614, 19.9366],
|
||||
'vilnius-transport': [54.6872, 25.2797],
|
||||
'tpbi-bucuresti': [44.4268, 26.1025],
|
||||
'roma-mobilita': [41.9028, 12.4964],
|
||||
'gtt-torino': [45.0703, 7.6869],
|
||||
'actv-venezia-bus': [45.4408, 12.3155],
|
||||
'actv-venezia-waterbus': [45.4408, 12.3155],
|
||||
'adelaide-metro': [-34.9285, 138.6007],
|
||||
'marta-atlanta': [33.749, -84.388],
|
||||
'rtd-denver': [39.7392, -104.9903],
|
||||
'ctp-cluj': [46.7712, 23.6236],
|
||||
'ctp-iasi': [47.1585, 27.6014],
|
||||
'mpk-rzeszow': [50.0412, 21.9991],
|
||||
'emt-malaga': [36.7213, -4.4214],
|
||||
'carris-lisboa': [38.7223, -9.1393],
|
||||
'mybas-johor': [1.4927, 103.7414],
|
||||
'mybas-kota-bharu': [6.1254, 102.2381],
|
||||
'astuce-rouen': [49.4432, 1.0999],
|
||||
'mpm-toulon': [43.1242, 5.928],
|
||||
'lia-le-havre': [49.4944, 0.1079],
|
||||
'filbleu-tours': [47.3941, 0.6848],
|
||||
};
|
||||
|
||||
test('every city in the 2026-11 batch is live, licensed and covers its own centre', () => {
|
||||
for (const [id, [lat, lon]] of Object.entries(NEW_CITY_LANDMARKS)) {
|
||||
const feed = getTransitFeed(id);
|
||||
assert.ok(feed, `${id} is routable`);
|
||||
assert.ok(
|
||||
publicTransitCatalog().some((f) => f.id === id),
|
||||
`${id} is offered to the browser`,
|
||||
);
|
||||
assert.ok(feed.terms?.note, `${id} records the basis it ships on`);
|
||||
assert.ok(
|
||||
transitFeedsInRange(lat, lon).some((f) => f.id === id),
|
||||
`${id} covers its city`,
|
||||
);
|
||||
}
|
||||
// A feed's radius stays local: Warsaw is not polled for Kraków.
|
||||
assert.ok(
|
||||
!transitFeedsInRange(50.0614, 19.9366).some((f) => f.id === 'ztm-warszawa'),
|
||||
);
|
||||
});
|
||||
|
||||
test('feeds with no stated licence say so and name the basis they ship on', () => {
|
||||
for (const feed of TRANSIT_FEED_REGISTRY.filter((f) =>
|
||||
/^No licence stated/.test(f.license),
|
||||
)) {
|
||||
assert.match(
|
||||
feed.terms.note,
|
||||
/Metro Transit and OVapi|Same .*basis/,
|
||||
`${feed.id} names its basis`,
|
||||
);
|
||||
}
|
||||
});
|
||||
|
||||
test('route ids in the 2026-11 batch read as the line on the vehicle', () => {
|
||||
const label = (id, routeId) => transitRouteLabel(getTransitFeed(id), routeId);
|
||||
assert.equal(label('pid-praha', 'L135'), '135');
|
||||
assert.equal(label('ets-edmonton', '009'), '9');
|
||||
assert.equal(label('mpm-toulon', '0002'), '2');
|
||||
assert.equal(label('gtt-torino', '10NU'), '10N');
|
||||
assert.equal(label('actv-venezia-waterbus', '5.1_UN'), '5.1');
|
||||
assert.equal(label('actv-venezia-bus', '53E_ES'), '53E');
|
||||
assert.equal(label('bc-transit-victoria', '95-VIC'), '95');
|
||||
assert.equal(label('carris-lisboa', '172_1'), '172');
|
||||
assert.equal(label('astuce-rouen', 'TCAR:93'), '93');
|
||||
assert.equal(label('mybas-johor', 'J33CWLMYJB'), 'J33');
|
||||
// Unmatched and absent ids pass through untouched.
|
||||
assert.equal(label('pid-praha', 'S4'), 'S4');
|
||||
assert.equal(label('gtt-torino', null), null);
|
||||
});
|
||||
|
||||
test('trams, waterbuses and buses are told apart where the ids allow it', () => {
|
||||
const mode = (id, routeId) => transitModeFor(getTransitFeed(id), routeId);
|
||||
assert.equal(mode('pid-praha', 'L22'), 'tram');
|
||||
assert.equal(mode('pid-praha', 'L135'), 'bus');
|
||||
assert.equal(mode('tbm-bordeaux', '16'), 'bus');
|
||||
assert.equal(mode('lia-le-havre', '8-B'), 'tram');
|
||||
assert.equal(mode('lia-le-havre', '8-C3'), 'bus');
|
||||
assert.equal(mode('ztp-krakow-tram', null), 'tram');
|
||||
assert.equal(mode('actv-venezia-waterbus', '1_UN'), 'ferry');
|
||||
});
|
||||
|
||||
test('feeds that publish km/h are marked for conversion, and only those', () => {
|
||||
const kmh = TRANSIT_FEED_REGISTRY.filter((f) => f.speedUnit === 'km/h')
|
||||
.map((f) => f.id)
|
||||
.sort();
|
||||
assert.deepEqual(kmh, [
|
||||
'carris-metropolitana-lisboa',
|
||||
'mpm-toulon',
|
||||
'tam-montpellier',
|
||||
]);
|
||||
});
|
||||
|
||||
// Route ids as the live feeds and the operators' own GTFS routes.txt carried
|
||||
// them on 2026-11-09: the ranges and numbered tram ids are not guessable from
|
||||
// the line names riders see.
|
||||
test('Prague route-id ranges give metro, trains, ferries and trolleybuses their mode', () => {
|
||||
const feed = getTransitFeed('pid-praha');
|
||||
const read = (routeId) => [
|
||||
transitModeFor(feed, routeId),
|
||||
transitRouteLabel(feed, routeId),
|
||||
];
|
||||
assert.deepEqual(read('L22'), ['tram', '22']);
|
||||
assert.deepEqual(read('L58'), ['bus', '58'], 'trolleybus');
|
||||
assert.deepEqual(read('L49'), ['rail', 'LD'], 'Petřín funicular');
|
||||
assert.deepEqual(read('L135'), ['bus', '135']);
|
||||
assert.deepEqual(read('L803'), ['bus', 'X3']);
|
||||
assert.deepEqual(read('L991'), ['subway', 'A']);
|
||||
assert.deepEqual(read('L993'), ['subway', 'C']);
|
||||
assert.deepEqual(read('L1004'), ['rail', 'S4']);
|
||||
assert.deepEqual(read('L1109'), ['rail', 'R9']);
|
||||
assert.deepEqual(read('L1204'), ['rail', 'L1204'], 'no label to derive');
|
||||
assert.deepEqual(read('L1801'), ['ferry', 'P1']);
|
||||
assert.deepEqual(read('L1703'), ['bus', 'L1703']);
|
||||
assert.deepEqual(read('L2841'), ['bus', '841']);
|
||||
assert.deepEqual(read('S4'), ['bus', 'S4'], 'unknown ids keep the default');
|
||||
});
|
||||
|
||||
test('Bordeaux trams ride numbered route ids and keep their letters', () => {
|
||||
const feed = getTransitFeed('tbm-bordeaux');
|
||||
for (const [routeId, line] of [
|
||||
['59', 'A'],
|
||||
['62', 'D'],
|
||||
['163', 'E'],
|
||||
]) {
|
||||
assert.equal(transitModeFor(feed, routeId), 'tram', routeId);
|
||||
assert.equal(transitRouteLabel(feed, routeId), line);
|
||||
}
|
||||
assert.equal(transitModeFor(feed, '952'), 'ferry');
|
||||
assert.equal(transitModeFor(feed, '01'), 'bus');
|
||||
assert.equal(transitRouteLabel(feed, '01'), '1');
|
||||
});
|
||||
|
||||
test('Rouen Métro and Calypso are not buses; Le Havre reads its own ids', () => {
|
||||
const feed = getTransitFeed('astuce-rouen');
|
||||
assert.equal(transitModeFor(feed, 'TCAR:90'), 'tram');
|
||||
assert.equal(transitRouteLabel(feed, 'TCAR:90'), 'Métro');
|
||||
assert.equal(transitModeFor(feed, 'TCAR:99'), 'ferry');
|
||||
assert.equal(transitModeFor(feed, 'TCAR:93'), 'bus');
|
||||
assert.equal(transitRouteLabel(feed, 'TAE:F'), 'F');
|
||||
const lia = getTransitFeed('lia-le-havre');
|
||||
assert.equal(transitModeFor(lia, '8-FUNI'), 'rail');
|
||||
assert.equal(transitRouteLabel(lia, '8-C3'), 'C3');
|
||||
assert.equal(transitRouteLabel(lia, '8-09'), '9');
|
||||
assert.equal(transitRouteLabel(lia, '8-A'), 'A');
|
||||
});
|
||||
|
||||
test('data.gov.my feeds ask the proxy for no more than its 4 a minute', () => {
|
||||
for (const id of ['mybas-johor', 'mybas-kota-bharu']) {
|
||||
assert.ok(getTransitFeed(id).refreshMs >= 30_000, id);
|
||||
}
|
||||
});
|
||||
@@ -257,24 +257,43 @@ export function buildTransitSnapshot(feed, bytes, now = Date.now()) {
|
||||
truncated: decoded.truncated,
|
||||
count: decoded.vehicles.length,
|
||||
vehicles: repairVehicleTimestamps(
|
||||
decoded.vehicles,
|
||||
feed.speedUnit === 'km/h'
|
||||
? decoded.vehicles.map((v) =>
|
||||
v.speedMps === null ? v : { ...v, speedMps: v.speedMps / 3.6 },
|
||||
)
|
||||
: decoded.vehicles,
|
||||
decoded.timestamp,
|
||||
Math.floor(now / 1000),
|
||||
),
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Fresh window for one feed's cached snapshot: the shared TTL, stretched by a
|
||||
* registry `refreshMs` for upstreams that rate-limit below one request per
|
||||
* TTL (data.gov.my allows 4 a minute). Never shorter than the shared TTL.
|
||||
* @param {{ refreshMs?: number }|null|undefined} feed Registry entry.
|
||||
* @returns {number}
|
||||
*/
|
||||
export function transitFeedTtlMs(feed) {
|
||||
const refresh = feed?.refreshMs;
|
||||
return Number.isFinite(refresh) && refresh > TRANSIT_PROXY_TTL_MS
|
||||
? refresh
|
||||
: TRANSIT_PROXY_TTL_MS;
|
||||
}
|
||||
|
||||
/**
|
||||
* Classify a cache entry for the request policy.
|
||||
* @param {{ at: number }|null|undefined} entry Cached snapshot (`at` = fetch ms).
|
||||
* @param {number} now
|
||||
* @param {number} [ttlMs] Fresh window; `transitFeedTtlMs(feed)` for a feed.
|
||||
* @returns {'none'|'fresh'|'stale'|'expired'}
|
||||
*/
|
||||
export function transitCacheState(entry, now) {
|
||||
export function transitCacheState(entry, now, ttlMs = TRANSIT_PROXY_TTL_MS) {
|
||||
if (!entry || !Number.isFinite(entry.at)) return 'none';
|
||||
const age = now - entry.at;
|
||||
if (age < 0) return 'fresh';
|
||||
if (age < TRANSIT_PROXY_TTL_MS) return 'fresh';
|
||||
if (age < ttlMs) return 'fresh';
|
||||
if (age < TRANSIT_PROXY_STALE_MAX_MS) return 'stale';
|
||||
return 'expired';
|
||||
}
|
||||
|
||||
@@ -12,6 +12,7 @@ import {
|
||||
repairVehicleTimestamps,
|
||||
resolveTransitRoute,
|
||||
transitCacheState,
|
||||
transitFeedTtlMs,
|
||||
transitRedirectDecision,
|
||||
transitResponseHeaders,
|
||||
transitUpstreamHeaders,
|
||||
@@ -294,6 +295,27 @@ test('Rio speeds pass through as the m/s they are published in', () => {
|
||||
assert.equal(rio.vehicles[0].speedMps, 10);
|
||||
});
|
||||
|
||||
test('Carris Metropolitana km/h speeds leave the proxy as m/s', () => {
|
||||
// 2026-11-07: readings of 31-33 matched 6-9 m/s of measured movement.
|
||||
const bytes = encodeFeed({
|
||||
entities: [
|
||||
{ id: 'moving', lat: 38.72, lon: -9.14, speed: 36 },
|
||||
{ id: 'parked', lat: 38.73, lon: -9.15 },
|
||||
],
|
||||
});
|
||||
const feed = getTransitFeed('carris-metropolitana-lisboa');
|
||||
const lisbon = buildTransitSnapshot(feed, bytes, 1);
|
||||
const byId = Object.fromEntries(lisbon.vehicles.map((v) => [v.id, v]));
|
||||
assert.ok(Math.abs(byId.moving.speedMps - 10) < 1e-6);
|
||||
assert.equal(byId.parked.speedMps, null, 'no speed stays no speed');
|
||||
const szczecin = buildTransitSnapshot(
|
||||
getTransitFeed('zditm-szczecin'),
|
||||
encodeFeed({ entities: [{ id: 'm', lat: 53.43, lon: 14.55, speed: 10 }] }),
|
||||
1,
|
||||
);
|
||||
assert.equal(szczecin.vehicles[0].speedMps, 10, 'm/s feeds are untouched');
|
||||
});
|
||||
|
||||
test('conditional-request validators and gzip ride along with feed identification', () => {
|
||||
const entur = getTransitFeed('entur-norway');
|
||||
const plain = transitUpstreamHeaders(entur);
|
||||
@@ -375,3 +397,24 @@ test('client history validates response bounds, epochs and cancellation through
|
||||
{ name: 'AbortError' },
|
||||
);
|
||||
});
|
||||
|
||||
test('Adelaide asks for */* because a protobuf Accept gets base64 text back', () => {
|
||||
const headers = transitUpstreamHeaders(getTransitFeed('adelaide-metro'));
|
||||
assert.equal(headers.Accept, '*/*');
|
||||
// Every other feed keeps the protobuf-first Accept.
|
||||
assert.match(
|
||||
transitUpstreamHeaders(getTransitFeed('mbta')).Accept,
|
||||
/protobuf/,
|
||||
);
|
||||
});
|
||||
|
||||
test('a feed refreshMs stretches its fresh window, never shortens it', () => {
|
||||
const johor = getTransitFeed('mybas-johor');
|
||||
assert.equal(transitFeedTtlMs(johor), 30_000);
|
||||
assert.equal(transitFeedTtlMs(getTransitFeed('mbta')), TRANSIT_PROXY_TTL_MS);
|
||||
assert.equal(transitFeedTtlMs({ refreshMs: 1_000 }), TRANSIT_PROXY_TTL_MS);
|
||||
const now = 1_000_000;
|
||||
const entry = { at: now - 20_000 };
|
||||
assert.equal(transitCacheState(entry, now), 'stale');
|
||||
assert.equal(transitCacheState(entry, now, transitFeedTtlMs(johor)), 'fresh');
|
||||
});
|
||||
Reference in new issue
Block a user