feat(transit): add 112 French networks from transport.data.gouv.fr

Each row is the keyless GTFS-RT vehicle feed of a national access point
record whose licence field is Licence Ouverte 2.0 or ODbL, seen live on
2026-11-13. Rows live in transitFeedsFrance.js; line names for feeds
that publish internal route keys come from each record's routes.txt.
Networks already registered through the operator's own endpoint are not
added again.
This commit is contained in:
Said Turksever committed 2026-11-13 15:38:18 +00:00
1 parent 42540ad85e
commit b3ffe9beb2
8 files changed
+3822 -1

No files matched your search

+57
View File
@@ -1,5 +1,7 @@
import { greatCircleKm } from '../geoDistance.js';
import { RIO_ROUTE_NAMES } from './rioRouteNames.js';
import { FRANCE_TRANSIT_FEED_ROWS } from './transitFeedsFrance.js';
import { FRANCE_ROUTE_NAMES } from './transitRouteNamesFrance.js';
/**
* @module transitFeeds
@@ -10,6 +12,8 @@ import { RIO_ROUTE_NAMES } from './rioRouteNames.js';
* `/api/transit/vehicles/<id>` for a registered id (see SECURITY.md: proxies
* never fetch client-supplied URLs). Adding a feed means adding a row here,
* a DATA_SOURCES.md row with its license, and a credit in dataCredits.js.
* The French networks listed on transport.data.gouv.fr are rows of the same
* shape in `transitFeedsFrance.js`, appended to the registry below.
*
* Admission rules for a feed:
* - No key, token, or registration required (identify-yourself headers are
@@ -562,6 +566,58 @@ function transitFeed(fields) {
});
}
/**
* A French network row (`transitFeedsFrance.js`) as a registry entry. Every
* one is a bus network unless its row says otherwise: `routeModes` names the
* route ids that are trams or boats, and a route id it does not name stays a
* default, never a resolved "bus". The licence name, record link and terms
* note are built from the row's `licence`, `record`, `vehicles` and `note`.
* A feed with a table in
* `transitRouteNamesFrance.js` reads its line names from it; an id missing
* from the table renders unchanged.
* @param {object} row
* @returns {Readonly<object>}
*/
function franceTransitFeed(row) {
const { routeModes, licence, record, vehicles, note, ...fields } = row;
const odbl = licence === 'odc-odbl';
const names = Object.hasOwn(FRANCE_ROUTE_NAMES, row.id)
? FRANCE_ROUTE_NAMES[row.id]
: null;
return transitFeed({
defaultMode: 'bus',
...fields,
license: odbl ? 'ODbL' : 'Licence Ouverte 2.0',
licenseUrl: `https://transport.data.gouv.fr/datasets/${record}`,
terms: {
quote: `licence: ${licence}`,
note: [
`Dataset record’s licence field quoted; this is the record’s own GTFS-RT vehicle feed (${vehicles} vehicles on 2026-11-13).`,
odbl
? 'ODbL asks for credit and share-alike on a derived database; the layer draws positions and redistributes no database.'
: '',
note ?? '',
]
.filter(Boolean)
.join(' '),
},
...(routeModes
? {
routeMode: (routeId) =>
routeId && Object.hasOwn(routeModes, routeId)
? routeModes[routeId]
: 'unknown',
}
: {}),
...(names
? {
routeLabel: (routeId) =>
routeId && Object.hasOwn(names, routeId) ? names[routeId] : routeId,
}
: {}),
});
}
/**
* Registry of feeds. Order is presentation order in the stats/credit text.
* `loadRadiusKm` is the distance from `center` inside which the feed is polled.
@@ -1586,6 +1642,7 @@ export const TRANSIT_FEED_REGISTRY = Object.freeze([
},
defaultMode: 'bus',
}),
...FRANCE_TRANSIT_FEED_ROWS.map(franceTransitFeed),
]);
/**
+5
View File
@@ -713,8 +713,13 @@ test('feeds that publish km/h are marked for conversion, and only those', () =>
.map((f) => f.id)
.sort();
assert.deepEqual(kmh, [
'azalys-blois',
'carris-metropolitana-lisboa',
'divia-dijon',
'maelis-montlucon',
'mpm-toulon',
'rubis-bourg-en-bresse',
'setram-le-mans',
'tam-montpellier',
]);
});
File diff suppressed because it is too large. Load diff
+201
View File
@@ -0,0 +1,201 @@
import { readFileSync } from 'node:fs';
import test from 'node:test';
import assert from 'node:assert/strict';
import {
TRANSIT_FEED_REGISTRY,
TRANSIT_FEED_ID_PATTERN,
getTransitFeed,
publicTransitCatalog,
transitFeedsInRange,
transitModeFor,
transitModeResolved,
transitRouteLabel,
} from './transitFeeds.js';
import { FRANCE_TRANSIT_FEED_ROWS } from './transitFeedsFrance.js';
import { FRANCE_ROUTE_NAMES } from './transitRouteNamesFrance.js';
import {
TRANSIT_ADMISSION_MAX_GLOBAL,
TRANSIT_ADMISSION_WINDOW_MS,
TRANSIT_PROXY_TTL_MS,
} from './transitProxy.js';
const FRANCE_IDS = new Set(FRANCE_TRANSIT_FEED_ROWS.map((row) => row.id));
test('every French row becomes a live feed under its record’s open licence', () => {
assert.equal(FRANCE_IDS.size, FRANCE_TRANSIT_FEED_ROWS.length);
for (const row of FRANCE_TRANSIT_FEED_ROWS) {
assert.match(row.id, TRANSIT_FEED_ID_PATTERN);
const feed = getTransitFeed(row.id);
assert.ok(feed, `${row.id} is routable`);
assert.ok(
publicTransitCatalog().some((entry) => entry.id === row.id),
`${row.id} is offered to the browser`,
);
assert.ok(
['lov2', 'odc-odbl'].includes(row.licence),
`${row.id} states an open licence`,
);
assert.equal(
feed.license,
row.licence === 'lov2' ? 'Licence Ouverte 2.0' : 'ODbL',
);
assert.equal(
feed.licenseUrl,
`https://transport.data.gouv.fr/datasets/${row.record}`,
`${row.id} links its dataset record`,
);
assert.equal(feed.terms.quote, `licence: ${row.licence}`);
assert.match(
feed.terms.note,
/\(\d+ vehicles on 2026-11-13\)/,
`${row.id} records the day it was seen live`,
);
assert.ok(row.vehicles > 0, `${row.id} had vehicles when it was added`);
assert.ok(
transitFeedsInRange(row.center.lat, row.center.lon).some(
(entry) => entry.id === row.id,
),
`${row.id} covers its own centre`,
);
}
});
test('no French row repeats a feed that is already registered', () => {
const seen = new Map();
for (const feed of TRANSIT_FEED_REGISTRY) {
const url = new URL(feed.url);
const key = `${url.origin}${url.pathname.replace(/\/$/, '')}${url.search}`;
assert.equal(
seen.has(key),
false,
`${feed.id} and ${seen.get(key)} fetch the same upstream`,
);
seen.set(key, feed.id);
}
// The networks that were already here through the operator's own endpoint
// stay single: no French row points at a dataset record one of them cites.
const earlier = TRANSIT_FEED_REGISTRY.filter(
(feed) => !FRANCE_IDS.has(feed.id),
);
for (const id of [
'tbm-bordeaux',
'tam-montpellier',
'astuce-rouen',
'mpm-toulon',
'lia-le-havre',
'filbleu-tours',
]) {
assert.ok(earlier.some((feed) => feed.id === id));
}
const earlierRecords = new Set(earlier.map((feed) => feed.licenseUrl));
for (const row of FRANCE_TRANSIT_FEED_ROWS) {
assert.equal(
earlierRecords.has(getTransitFeed(row.id).licenseUrl),
false,
`${row.id} is not a second copy of an earlier feed`,
);
}
});
test('one viewpoint never asks for more feeds than the proxy admits', () => {
// The browser polls each in-range feed once per proxy TTL, and the proxy
// admits a fixed number of upstream requests a minute across all feeds.
const pollsPerFeed = TRANSIT_ADMISSION_WINDOW_MS / TRANSIT_PROXY_TTL_MS;
for (const feed of TRANSIT_FEED_REGISTRY) {
const inRange = transitFeedsInRange(feed.center.lat, feed.center.lon);
assert.ok(
inRange.length * pollsPerFeed <= TRANSIT_ADMISSION_MAX_GLOBAL,
`${inRange.length} feeds overlap at ${feed.id}`,
);
}
});
test('French trams and boats take their mode; every other route stays a default', () => {
const cases = [
['divia-dijon', '4-T1', 'tram'],
['bibus-brest', 'A', 'tram'],
['setram-le-mans', 'T2', 'tram'],
['lignes-dazur-nice', 'L2', 'tram'],
['irigo-angers', 'C', 'tram'],
['orizo-avignon', 'T1', 'tram'],
['transvilles-valenciennes', 'NAVINEO:Line::190:LOC', 'tram'],
['aleop-pays-de-la-loire', 'YEU', 'ferry'],
['martinique-sud', '4001', 'ferry'],
];
for (const [id, routeId, mode] of cases) {
const feed = getTransitFeed(id);
assert.equal(transitModeFor(feed, routeId), mode, `${id} ${routeId}`);
assert.equal(transitModeResolved(feed, routeId), true);
assert.equal(transitModeFor(feed, 'no-such-route'), 'bus');
assert.equal(
transitModeResolved(feed, 'no-such-route'),
false,
`${id} defaults rather than resolves an unlisted route`,
);
}
const busOnly = getTransitFeed('ametis-amiens');
assert.equal(transitModeFor(busOnly, '7'), 'bus');
assert.equal(transitModeResolved(busOnly, '7'), false);
});
test('French feeds that publish km/h are marked for conversion, and only those', () => {
assert.deepEqual(
FRANCE_TRANSIT_FEED_ROWS.filter((row) => row.speedUnit === 'km/h')
.map((row) => row.id)
.sort(),
[
'azalys-blois',
'divia-dijon',
'maelis-montlucon',
'rubis-bourg-en-bresse',
'setram-le-mans',
],
);
for (const row of FRANCE_TRANSIT_FEED_ROWS.filter((r) => r.speedUnit)) {
assert.match(getTransitFeed(row.id).terms.note, /Speeds are km\/h/);
}
});
test('French route-name tables belong to registered feeds and never blank a line', () => {
for (const [id, names] of Object.entries(FRANCE_ROUTE_NAMES)) {
assert.ok(FRANCE_IDS.has(id), `${id} is a registered French feed`);
const feed = getTransitFeed(id);
for (const [routeId, name] of Object.entries(names)) {
assert.ok(typeof name === 'string' && name.trim() === name && name);
assert.notEqual(name, routeId, `${id} ${routeId} is not a no-op`);
assert.equal(transitRouteLabel(feed, routeId), name);
}
assert.equal(transitRouteLabel(feed, 'no-such-route'), 'no-such-route');
assert.equal(transitRouteLabel(feed, null), null);
}
assert.equal(transitRouteLabel(getTransitFeed('divia-dijon'), '4-T1'), 'T1');
assert.equal(
transitRouteLabel(
getTransitFeed('transvilles-valenciennes'),
'NAVINEO:Line::190:LOC',
),
'T1',
);
// A feed whose ids already read as the line has no table and is left alone.
assert.equal(transitRouteLabel(getTransitFeed('ametis-amiens'), '7'), '7');
});
test('every French feed is documented with its licence', () => {
const lines = readFileSync(
new URL('../../DATA_SOURCES.md', import.meta.url),
'utf8',
).split('\n');
for (const row of FRANCE_TRANSIT_FEED_ROWS) {
const feed = getTransitFeed(row.id);
const line = lines.find((l) => l.startsWith(`| **${feed.name}** `));
assert.ok(line, `${feed.name} has a DATA_SOURCES row`);
assert.ok(
line.includes(feed.licenseUrl),
`${feed.name} row links its record`,
);
assert.ok(
line.includes(feed.license),
`${feed.name} row names its licence`,
);
}
});
File diff suppressed because it is too large. Load diff