vulture-wasm 0.2.0 → 0.4.0

package/README.md

@@ -47,15 +47,16 @@ const tt = new VultureTimetable(
 - `tt.nStops()`, `tt.nRoutes()` — counts.
 - `tt.stopIdx(gtfsId)` — GTFS stop id → opaque `StopIdx`, or `undefined`.
 - `tt.stopName(stopIdx)`, `tt.stopCoords(stopIdx)`, `tt.routeName(routeIdx)`, `tt.routeAgency(routeIdx)` — display-data accessors.
-- `tt.allStops()` — bulk catalogue of `{idx, id, name, lat, lon}` per stop.
-- `tt.allRoutes()` — bulk catalogue of `{idx, id, name, agency, route_type, route_color}` per route. `route_type` is the GTFS integer (0=tram, 1=metro, 2=rail, 3=bus, 4=ferry, 5=cable, 6=aerial, 7=funicular, …); `route_color` is `"#rrggbb"` or `null`.
+- `tt.allStops()` — bulk catalogue of `{idx, id, name, lat, lon, location_type, parent_station}` per stop. `location_type` is the GTFS integer (0 = stop or platform, 1 = parent station, 2 = entrance/exit, 3 = generic node, 4 = boarding area); `parent_station` is the parent's GTFS id or `null`.
+- `tt.allRoutes()` — bulk catalogue of `{idx, id, name, agency, route_type, route_color}` per route. `route_type` is the GTFS integer (0 = tram, 1 = metro, 2 = rail, 3 = bus, 4 = ferry, 5 = cable, 6 = aerial, 7 = funicular, …); `route_color` is `"#rrggbb"` or `null`.
+- `tt.stationStops(parentId)` — given a parent station's GTFS id, returns a `Uint32Array` of the platform stop indices that hang off it. Pass the result as `originStops` / `targetStops` to query against every platform of a station; queries rooted at a `location_type = 1` stop return zero journeys without this expansion, because in GTFS vehicles only board at platform-level stops.
 - `tt.withWalkingFootpaths(maxDistMeters, walkSpeedMetersPerSec)` — replace the footpath set with one derived from stop coordinates.
 - `tt.resetFootpaths()` — restore the original `transfers.txt` set.
 
 Free functions:
 
 - `runArrival(tt, originStops, targetStops, maxTransfers, departSeconds, requireWheelchair)` — single-departure query. Returns an array of journeys with timed legs.
-- `runRange(tt, origin, target, maxTransfers, departures, requireWheelchair)` — depart-in-window Pareto profile. Returns `[{depart, journey}]` where each `journey` has the same shape as a `runArrival` entry (`origin`, `target`, `arrival`, `legs`).
+- `runRange(tt, originStops, targetStops, maxTransfers, departures, requireWheelchair)` — depart-in-window Pareto profile. Returns `[{depart, journey}]` where each `journey` has the same shape as a `runArrival` entry (`origin`, `target`, `arrival`, `legs`).
 
 Each leg in `journey.legs` is `{board_stop, alight_stop, route, trip, route_id, depart, arrive, shape}`. `shape` is a `[lat, lon][]` polyline for that leg's segment of the trip's `shapes.txt` geometry, or `null` if the feed has no shape for the trip.
 
@@ -132,7 +133,14 @@ const departures = new Uint32Array(
     Array.from({ length: 13 }, (_, i) => 9 * 3600 + i * 300),
 );
 
-const profile = runRange(tt, origin, target, 10, departures, false);
+const profile = runRange(
+    tt,
+    new Uint32Array([origin]),
+    new Uint32Array([target]),
+    10,
+    departures,
+    false,
+);
 
 for (const entry of profile) {
     console.log(
@@ -175,6 +183,49 @@ console.log(`with footpaths: ${after.length} journey(s)`);
 
 `tt.resetFootpaths()` restores the original `transfers.txt` set.
 
+### 4. Querying entire stations (parent-station expansion)
+
+GTFS feeds with deep station hierarchies (regional German rail, French SNCF, UK NaPTAN, etc.) model a single station as one parent stop (`location_type = 1`) with many child platforms (`location_type = 0`) hanging off it. Vehicles only board at platforms; querying directly against a parent station returns zero journeys. Detect parents and expand them into the platform set:
+
+```js
+import init, { VultureTimetable, runArrival } from "vulture-wasm";
+
+await init();
+
+const tt = new VultureTimetable(
+    new Uint8Array(await (await fetch("/path/to/feed.zip")).arrayBuffer()),
+    "2026-05-04",
+);
+
+// Resolve a stop record (from `tt.allStops()` or any other lookup
+// path) into the array of stop indices to query against.
+function endpointsFor(stop) {
+    if (stop.location_type === 1) {
+        const platforms = tt.stationStops(stop.id);
+        if (platforms.length > 0) return platforms;
+    }
+    return new Uint32Array([stop.idx]);
+}
+
+const stops = tt.allStops();
+const stopByName = new Map(stops.map((s) => [s.name, s]));
+
+const from = stopByName.get("Karlsruhe Hauptbahnhof");   // a parent station
+const to = stopByName.get("Basel SBB");                  // also a parent
+
+const journeys = runArrival(
+    tt,
+    endpointsFor(from),
+    endpointsFor(to),
+    /* maxTransfers */ 10,
+    /* depart        */ 9 * 3600,
+    /* wheelchair    */ false,
+);
+console.log(`${journeys.length} journey(s) across all platform combinations`);
+```
+
+The same `endpointsFor(stop)` helper is what the bundled demo uses across all three panels.
+
 ## Build from source
 
 ```sh

package/package.json

@@ -5,7 +5,7 @@
     "Stephan Hügel <urschrei@gmail.com>"
   ],
   "description": "WebAssembly bindings for vulture (RAPTOR transit routing)",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",

package/vulture_wasm.d.ts

@@ -58,6 +58,19 @@ export class VultureTimetable {
      * routes by stop-pattern.
      */
     routeName(idx: number): string | undefined;
+    /**
+     * Expand a parent station's GTFS id into the platform stop
+     * indices that hang off it. Returns an empty array if `parent_id`
+     * is not a parent station in the feed (or has no children).
+     *
+     * Useful for the "any platform of this station" pattern: in
+     * GTFS, vehicles only board at platform-level stops
+     * (`location_type = 0`), so a query rooted at the parent station
+     * (`location_type = 1`) returns nothing. Pass this method's
+     * result as `originStops` / `targetStops` to query against every
+     * platform.
+     */
+    stationStops(parent_id: string): Uint32Array;
     /**
      * Returns the GTFS `[lat, lon]` for the given stop index, or
      * `undefined` if the stop has no coordinates set.
@@ -94,15 +107,17 @@ export function runArrival(tt: VultureTimetable, origins: Uint32Array, targets:
 
 /**
  * Range query: run RAPTOR across a window of departure times. JS
- * passes `departures` as a `Uint32Array` of seconds-since-midnight
- * values. Returns `[{depart, journey}]` Pareto-filtered on
- * `(later depart, fewer transfers, earlier arrival)`.
+ * passes `origins` / `targets` as `Uint32Array`s of stop indices
+ * (each entry gets walk-time zero), and `departures` as a
+ * `Uint32Array` of seconds-since-midnight values. Returns
+ * `[{depart, journey}]` Pareto-filtered on `(later depart, fewer
+ * transfers, earlier arrival)`.
  *
- * Currently single-source / single-target only — the demo's range
- * panel doesn't need multi-endpoint, and rRAPTOR's serial path
- * (the one we use here) requires `ArrivalTime`.
+ * Multi-source / multi-target so the "any platform of this station"
+ * pattern (via `tt.stationStops(parent_id)`) works the same way as
+ * in `runArrival`.
  */
-export function runRange(tt: VultureTimetable, origin: number, target: number, max_transfers: number, departures: Uint32Array, require_wheelchair: boolean): any;
+export function runRange(tt: VultureTimetable, origins: Uint32Array, targets: Uint32Array, max_transfers: number, departures: Uint32Array, require_wheelchair: boolean): any;
 
 export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
 
@@ -110,7 +125,7 @@ export interface InitOutput {
     readonly memory: WebAssembly.Memory;
     readonly __wbg_vulturetimetable_free: (a: number, b: number) => void;
     readonly runArrival: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number, number];
-    readonly runRange: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number, number];
+    readonly runRange: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => [number, number, number];
     readonly vulturetimetable_allRoutes: (a: number) => [number, number, number];
     readonly vulturetimetable_allStops: (a: number) => [number, number, number];
     readonly vulturetimetable_nRoutes: (a: number) => number;
@@ -119,6 +134,7 @@ export interface InitOutput {
     readonly vulturetimetable_resetFootpaths: (a: number) => [number, number];
     readonly vulturetimetable_routeAgency: (a: number, b: number) => [number, number];
     readonly vulturetimetable_routeName: (a: number, b: number) => [number, number];
+    readonly vulturetimetable_stationStops: (a: number, b: number, c: number) => [number, number];
     readonly vulturetimetable_stopCoords: (a: number, b: number) => [number, number];
     readonly vulturetimetable_stopIdx: (a: number, b: number, c: number) => number;
     readonly vulturetimetable_stopName: (a: number, b: number) => [number, number];

package/vulture_wasm.js

@@ -126,6 +126,28 @@ export class VultureTimetable {
         }
         return v1;
     }
+    /**
+     * Expand a parent station's GTFS id into the platform stop
+     * indices that hang off it. Returns an empty array if `parent_id`
+     * is not a parent station in the feed (or has no children).
+     *
+     * Useful for the "any platform of this station" pattern: in
+     * GTFS, vehicles only board at platform-level stops
+     * (`location_type = 0`), so a query rooted at the parent station
+     * (`location_type = 1`) returns nothing. Pass this method's
+     * result as `originStops` / `targetStops` to query against every
+     * platform.
+     * @param {string} parent_id
+     * @returns {Uint32Array}
+     */
+    stationStops(parent_id) {
+        const ptr0 = passStringToWasm0(parent_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.vulturetimetable_stationStops(this.__wbg_ptr, ptr0, len0);
+        var v2 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v2;
+    }
     /**
      * Returns the GTFS `[lat, lon]` for the given stop index, or
      * `undefined` if the stop has no coordinates set.
@@ -212,26 +234,32 @@ export function runArrival(tt, origins, targets, max_transfers, depart, require_
 
 /**
  * Range query: run RAPTOR across a window of departure times. JS
- * passes `departures` as a `Uint32Array` of seconds-since-midnight
- * values. Returns `[{depart, journey}]` Pareto-filtered on
- * `(later depart, fewer transfers, earlier arrival)`.
+ * passes `origins` / `targets` as `Uint32Array`s of stop indices
+ * (each entry gets walk-time zero), and `departures` as a
+ * `Uint32Array` of seconds-since-midnight values. Returns
+ * `[{depart, journey}]` Pareto-filtered on `(later depart, fewer
+ * transfers, earlier arrival)`.
  *
- * Currently single-source / single-target only — the demo's range
- * panel doesn't need multi-endpoint, and rRAPTOR's serial path
- * (the one we use here) requires `ArrivalTime`.
+ * Multi-source / multi-target so the "any platform of this station"
+ * pattern (via `tt.stationStops(parent_id)`) works the same way as
+ * in `runArrival`.
  * @param {VultureTimetable} tt
- * @param {number} origin
- * @param {number} target
+ * @param {Uint32Array} origins
+ * @param {Uint32Array} targets
  * @param {number} max_transfers
  * @param {Uint32Array} departures
  * @param {boolean} require_wheelchair
  * @returns {any}
  */
-export function runRange(tt, origin, target, max_transfers, departures, require_wheelchair) {
+export function runRange(tt, origins, targets, max_transfers, departures, require_wheelchair) {
     _assertClass(tt, VultureTimetable);
-    const ptr0 = passArray32ToWasm0(departures, wasm.__wbindgen_malloc);
+    const ptr0 = passArray32ToWasm0(origins, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.runRange(tt.__wbg_ptr, origin, target, max_transfers, ptr0, len0, require_wheelchair);
+    const ptr1 = passArray32ToWasm0(targets, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passArray32ToWasm0(departures, wasm.__wbindgen_malloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ret = wasm.runRange(tt.__wbg_ptr, ptr0, len0, ptr1, len1, max_transfers, ptr2, len2, require_wheelchair);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -343,6 +371,11 @@ function getArrayF64FromWasm0(ptr, len) {
     return getFloat64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
 }
 
+function getArrayU32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+
 let cachedDataViewMemory0 = null;
 function getDataViewMemory0() {
     if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {