minotor 11.1.0 → 11.1.1

package/CHANGELOG.md

@@ -1,6 +1,6 @@
-# [11.1.0](https://github.com/aubryio/minotor/compare/v11.0.0...v11.1.0) (2026-04-15)
+## [11.1.1](https://github.com/aubryio/minotor/compare/v11.1.0...v11.1.1) (2026-04-18)
 
 
-### Features
+### Performance Improvements
 
-* basic GTFS frequency.txt support (scheduled only) ([#63](https://github.com/aubryio/minotor/issues/63)) ([05cf559](https://github.com/aubryio/minotor/commit/05cf559cd34ba336dae7f35e9eb7901ae23ea7b4)), closes [#50](https://github.com/aubryio/minotor/issues/50)
+* optimize routing state by swapping maps for arrays ([#64](https://github.com/aubryio/minotor/issues/64)) ([b37d086](https://github.com/aubryio/minotor/commit/b37d08653f115d22c4b49f88f15521efbcfdae62))

package/dist/cli.mjs

@@ -17025,7 +17025,6 @@ function isSet(value) {
     return value !== null && value !== undefined;
 }
 
-const TIME_INFINITY = Number.MAX_SAFE_INTEGER;
 const TIME_ORIGIN = 0;
 const DURATION_ZERO = 0;
 /**
@@ -17763,6 +17762,12 @@ class Timetable {
     isActive(stopId) {
         return this.activeStops.has(stopId);
     }
+    /**
+     * Returns the total number of stops in the timetable.
+     */
+    nbStops() {
+        return this.stopsAdjacency.length;
+    }
     /**
      * Retrieves the route associated with the given route ID.
      *
@@ -21224,8 +21229,8 @@ class Plotter {
      * Determines station type (origin/destination) information.
      */
     getStationInfo(stopId) {
-        var _a, _b;
-        const isOrigin = (_b = (_a = this.result.routingState.graph[0]) === null || _a === void 0 ? void 0 : _a.has(stopId)) !== null && _b !== void 0 ? _b : false;
+        var _a;
+        const isOrigin = ((_a = this.result.routingState.graph[0]) === null || _a === void 0 ? void 0 : _a[stopId]) !== undefined;
         const isDestination = this.result.routingState.destinations.includes(stopId);
         return { isOrigin, isDestination };
     }
@@ -21357,8 +21362,11 @@ class Plotter {
     collectStations() {
         const stations = new Set();
         const graph = this.result.routingState.graph;
-        for (const roundMap of graph) {
-            for (const [stopId, edge] of roundMap) {
+        for (const roundEdges of graph) {
+            for (let stopId = 0; stopId < roundEdges.length; stopId++) {
+                const edge = roundEdges[stopId];
+                if (edge === undefined)
+                    continue;
                 stations.add(stopId);
                 if (isVehicleEdge(edge)) {
                     const fromStopId = this.getVehicleEdgeFromStopId(edge);
@@ -21395,14 +21403,17 @@ class Plotter {
         const continuationEdges = [];
         const graph = this.result.routingState.graph;
         for (let round = 0; round < graph.length; round++) {
-            const roundMap = graph[round];
-            if (!roundMap)
+            const roundEdges = graph[round];
+            if (!roundEdges)
                 continue;
             // Skip round 0 as it contains only origin nodes
             if (round === 0) {
                 continue;
             }
-            for (const edge of roundMap.values()) {
+            for (let stopId = 0; stopId < roundEdges.length; stopId++) {
+                const edge = roundEdges[stopId];
+                if (edge === undefined)
+                    continue;
                 if (isVehicleEdge(edge)) {
                     edges.push(...this.createVehicleEdge(edge, round));
                     if (edge.continuationOf) {
@@ -21684,30 +21695,31 @@ class Result {
         const destinationIterable = to instanceof Set ? to : to ? [to] : this.query.to;
         // Find the fastest-reached destination across all equivalent stops.
         let fastestDestination = undefined;
-        let fastestTime = undefined;
+        let fastestArrivalTime = undefined;
+        let fastestLegNumber = undefined;
         for (const sourceDestination of destinationIterable) {
             const equivalentStops = this.stopsIndex.equivalentStops(sourceDestination);
             for (const destination of equivalentStops) {
-                const arrivalTime = this.routingState.earliestArrivals.get(destination.id);
-                if (arrivalTime !== undefined) {
-                    if (fastestTime === undefined ||
-                        arrivalTime.arrival < fastestTime.arrival) {
-                        fastestDestination = destination.id;
-                        fastestTime = arrivalTime;
-                    }
+                const arrivalData = this.routingState.getArrival(destination.id);
+                if (arrivalData !== undefined &&
+                    (fastestArrivalTime === undefined ||
+                        arrivalData.arrival < fastestArrivalTime)) {
+                    fastestDestination = destination.id;
+                    fastestArrivalTime = arrivalData.arrival;
+                    fastestLegNumber = arrivalData.legNumber;
                 }
             }
         }
-        if (!fastestDestination || !fastestTime) {
+        if (fastestDestination === undefined || fastestLegNumber === undefined) {
             return undefined;
         }
         // Reconstruct the path by walking backwards through the routing graph.
         const route = [];
         let currentStop = fastestDestination;
-        let round = fastestTime.legNumber;
+        let round = fastestLegNumber;
         let previousVehicleEdge;
         while (round > 0) {
-            const edge = (_a = this.routingState.graph[round]) === null || _a === void 0 ? void 0 : _a.get(currentStop);
+            const edge = (_a = this.routingState.graph[round]) === null || _a === void 0 ? void 0 : _a[currentStop];
             if (!edge) {
                 throw new Error(`No edge arriving at stop ${currentStop} at round ${round}`);
             }
@@ -21844,19 +21856,21 @@ class Result {
      * @returns The arrival time if the target stop is reachable, otherwise undefined.
      */
     arrivalAt(stop, maxTransfers) {
-        var _a;
+        var _a, _b;
         const equivalentStops = this.stopsIndex.equivalentStops(stop);
         let earliestArrival = undefined;
         for (const equivalentStop of equivalentStops) {
             let arrivalTime;
-            if (maxTransfers === undefined) {
-                arrivalTime = this.routingState.earliestArrivals.get(equivalentStop.id);
+            if (maxTransfers === undefined ||
+                ((_a = this.routingState.getArrival(equivalentStop.id)) === null || _a === void 0 ? void 0 : _a.legNumber) ===
+                    maxTransfers + 1) {
+                arrivalTime = this.routingState.getArrival(equivalentStop.id);
             }
             else {
                 // We have no guarantee that the stop was visited in the last round,
                 // so we need to check all rounds if it's not found in the last one.
                 for (let i = maxTransfers + 1; i >= 0; i--) {
-                    const arrivalEdge = (_a = this.routingState.graph[i]) === null || _a === void 0 ? void 0 : _a.get(equivalentStop.id);
+                    const arrivalEdge = (_b = this.routingState.graph[i]) === null || _b === void 0 ? void 0 : _b[equivalentStop.id];
                     if (arrivalEdge !== undefined) {
                         arrivalTime = {
                             arrival: arrivalEdge.arrival,
@@ -21877,7 +21891,117 @@ class Result {
     }
 }
 
-const UNREACHED = TIME_INFINITY;
+/**
+ * Sentinel value used in the internal arrival-time array to mark stops not yet reached.
+ * 0xFFFF = 65 535 minutes ≈ 45.5 days, safely beyond any realistic transit arrival time.
+ */
+const UNREACHED_TIME = 0xffff;
+/**
+ * Encapsulates all mutable state for a single RAPTOR routing query.
+ */
+class RoutingState {
+    /**
+     * Initializes the routing state for a fresh query.
+     *
+     * All stops start as unreached. Each origin is immediately recorded at the
+     * departure time with leg number 0, and a corresponding OriginNode is placed
+     * in round 0 of the graph.
+     *
+     * @param origins      Stop IDs to depart from (may be several equivalent stops).
+     * @param destinations Stop IDs that count as the target of the query.
+     * @param departureTime Earliest departure time in minutes from midnight.
+     * @param nbStops      Total number of stops in the timetable (sets array sizes).
+     */
+    constructor(origins, destinations, departureTime, nbStops) {
+        this.origins = origins;
+        this.destinations = destinations;
+        const earliestArrivalTimes = new Uint16Array(nbStops).fill(UNREACHED_TIME);
+        const earliestArrivalLegs = new Uint8Array(nbStops); // zero-initialized = leg 0
+        const graph0 = new Array(nbStops);
+        for (const stop of origins) {
+            earliestArrivalTimes[stop] = departureTime;
+            graph0[stop] = { arrival: departureTime };
+        }
+        this.earliestArrivalTimes = earliestArrivalTimes;
+        this.earliestArrivalLegs = earliestArrivalLegs;
+        this.graph = [graph0];
+    }
+    /** Total number of stops in the timetable */
+    get nbStops() {
+        return this.earliestArrivalTimes.length;
+    }
+    /**
+     * Returns the earliest known arrival time at a stop.
+     * Returns UNREACHED_TIME if the stop has not been reached yet.
+     */
+    arrivalTime(stop) {
+        return this.earliestArrivalTimes[stop];
+    }
+    /**
+     * Records a new earliest arrival at a stop.
+  
+     *
+     * @param stop The stop that was reached.
+     * @param time The arrival time in minutes from midnight.
+     * @param leg  The round number (number of transit legs taken so far).
+     */
+    updateArrival(stop, time, leg) {
+        this.earliestArrivalTimes[stop] = time;
+        this.earliestArrivalLegs[stop] = leg;
+    }
+    /**
+     * Returns the earliest arrival at a stop as an {@link Arrival} object,
+     * or undefined if the stop has not been reached.
+     */
+    getArrival(stop) {
+        const time = this.earliestArrivalTimes[stop];
+        if (time >= UNREACHED_TIME)
+            return undefined;
+        return { arrival: time, legNumber: this.earliestArrivalLegs[stop] };
+    }
+    /**
+     * Creates a {@link RoutingState} from fully-specified raw data.
+     *
+     * Use this in tests instead of constructing the object through the production
+     * constructor, which is designed for incremental algorithm state.
+     *
+     * @param nbStops  Total number of stops (sets array sizes).
+     * @param origins  Origin stop IDs.
+     * @param destinations  Destination stop IDs.
+     * @param arrivals  Each entry is `[stop, time, leg]` — the earliest arrival
+     *                  time in minutes and the round number for one stop.
+     * @param graph  One element per round. Each round is a sparse list of
+     *               `[stop, edge]` pairs; stops absent from the list are
+     *               left as `undefined` in the dense output array.
+     *
+     * @internal For use in tests only.
+     */
+    static fromTestData({ nbStops, origins = [], destinations = [], arrivals = [], graph = [], }) {
+        const state = new RoutingState(origins, destinations, 0, nbStops);
+        // Replace the arrival arrays with freshly built ones so the constructor's
+        // origin-seeding doesn't bleed into the test state.
+        const earliestArrivalTimes = new Uint16Array(nbStops).fill(UNREACHED_TIME);
+        const earliestArrivalLegs = new Uint8Array(nbStops);
+        for (const [stop, time, leg] of arrivals) {
+            earliestArrivalTimes[stop] = time;
+            earliestArrivalLegs[stop] = leg;
+        }
+        state.earliestArrivalTimes = earliestArrivalTimes;
+        state.earliestArrivalLegs = earliestArrivalLegs;
+        // Convert the sparse per-round representation to dense arrays and replace
+        // the graph in-place.
+        const denseRounds = graph.map((round) => {
+            const arr = new Array(nbStops);
+            for (const [stop, edge] of round) {
+                arr[stop] = edge;
+            }
+            return arr;
+        });
+        state.graph.splice(0, state.graph.length, ...denseRounds);
+        return state;
+    }
+}
+
 /**
  * A public transportation router implementing the RAPTOR algorithm.
  * For more information on the RAPTOR algorithm,
@@ -21897,17 +22021,14 @@ class Router {
      */
     route(query) {
         const routingState = this.initRoutingState(query);
-        const markedStops = new Set();
-        for (const originStop of routingState.graph[0].keys()) {
-            markedStops.add(originStop);
-        }
+        const markedStops = new Set(routingState.origins);
         // Initial transfer consideration for origins
         const newlyMarkedStops = this.considerTransfers(query, 0, markedStops, routingState);
         for (const newStop of newlyMarkedStops) {
             markedStops.add(newStop);
         }
         for (let round = 1; round <= query.options.maxTransfers + 1; round++) {
-            const edgesAtCurrentRound = new Map();
+            const edgesAtCurrentRound = new Array(routingState.nbStops);
             routingState.graph.push(edgesAtCurrentRound);
             const reachableRoutes = this.timetable.findReachableRoutes(markedStops, query.options.transportModes);
             markedStops.clear();
@@ -21946,13 +22067,13 @@ class Router {
     /**
      * Finds trip continuations for the given marked stops and edges at the current round.
      * @param markedStops The set of marked stops.
-     * @param edgesAtCurrentRound The map of edges at the current round.
+     * @param edgesAtCurrentRound The array of edges at the current round, indexed by stop ID.
      * @returns An array of trip continuations.
      */
     findTripContinuations(markedStops, edgesAtCurrentRound) {
         const continuations = [];
         for (const stopId of markedStops) {
-            const arrival = edgesAtCurrentRound.get(stopId);
+            const arrival = edgesAtCurrentRound[stopId];
             if (!arrival || !('routeId' in arrival))
                 continue;
             const continuousTrips = this.timetable.getContinuousTrips(arrival.hopOffStopIndex, arrival.routeId, arrival.tripIndex);
@@ -21988,22 +22109,7 @@ class Router {
         const destinations = Array.from(to)
             .flatMap((destination) => this.stopsIndex.equivalentStops(destination))
             .map((destination) => destination.id);
-        const earliestArrivals = new Map();
-        const earliestArrivalsWithoutAnyLeg = new Map();
-        const earliestArrivalsPerRound = [earliestArrivalsWithoutAnyLeg];
-        const initialState = {
-            arrival: departureTime,
-            legNumber: 0,
-        };
-        for (const originStop of origins) {
-            earliestArrivals.set(originStop, initialState);
-            earliestArrivalsWithoutAnyLeg.set(originStop, initialState);
-        }
-        return {
-            destinations,
-            earliestArrivals,
-            graph: earliestArrivalsPerRound,
-        };
+        return new RoutingState(origins, destinations, departureTime, this.timetable.nbStops());
     }
     /**
      * Scans a route to find the earliest possible trips (if not provided) and updates arrival times.
@@ -22020,7 +22126,6 @@ class Router {
      * @param routingState The current routing state containing arrival times and marked stops
      */
     scanRoute(route, hopOnStopIndex, round, routingState, options, tripContinuation) {
-        var _a, _b;
         const newlyMarkedStops = new Set();
         let activeTrip = tripContinuation
             ? {
@@ -22032,7 +22137,7 @@ class Router {
         const edgesAtCurrentRound = routingState.graph[round];
         const edgesAtPreviousRound = routingState.graph[round - 1];
         // Compute target pruning criteria only once per route
-        const earliestArrivalAtAnyDestination = this.earliestArrivalAtAnyStop(routingState.earliestArrivals, routingState.destinations);
+        const earliestArrivalAtAnyDestination = this.earliestArrivalAtAnyStop(routingState);
         for (let currentStopIndex = hopOnStopIndex; currentStopIndex < route.getNbStops(); currentStopIndex++) {
             const currentStop = route.stops[currentStopIndex];
             // If we're currently on a trip,
@@ -22040,7 +22145,7 @@ class Router {
             if (activeTrip !== undefined) {
                 const arrivalTime = route.arrivalAt(currentStopIndex, activeTrip.tripIndex);
                 const dropOffType = route.dropOffTypeAt(currentStopIndex, activeTrip.tripIndex);
-                const earliestArrivalAtCurrentStop = (_b = (_a = routingState.earliestArrivals.get(currentStop)) === null || _a === void 0 ? void 0 : _a.arrival) !== null && _b !== void 0 ? _b : UNREACHED;
+                const earliestArrivalAtCurrentStop = routingState.arrivalTime(currentStop);
                 if (dropOffType !== NOT_AVAILABLE &&
                     arrivalTime < earliestArrivalAtCurrentStop &&
                     arrivalTime < earliestArrivalAtAnyDestination) {
@@ -22055,11 +22160,8 @@ class Router {
                         // In case of continuous trip, we set a pointer to the previous edge
                         edge.continuationOf = tripContinuation.previousEdge;
                     }
-                    edgesAtCurrentRound.set(currentStop, edge);
-                    routingState.earliestArrivals.set(currentStop, {
-                        arrival: arrivalTime,
-                        legNumber: round,
-                    });
+                    edgesAtCurrentRound[currentStop] = edge;
+                    routingState.updateArrival(currentStop, arrivalTime, round);
                     newlyMarkedStops.add(currentStop);
                 }
             }
@@ -22069,7 +22171,7 @@ class Router {
             }
             // check if we can board an earlier trip at the current stop
             // if there was no current trip, find the first one reachable
-            const previousEdge = edgesAtPreviousRound.get(currentStop);
+            const previousEdge = edgesAtPreviousRound[currentStop];
             const earliestArrivalOnPreviousRound = previousEdge === null || previousEdge === void 0 ? void 0 : previousEdge.arrival;
             if (earliestArrivalOnPreviousRound !== undefined &&
                 (activeTrip === undefined ||
@@ -22146,12 +22248,11 @@ class Router {
      * @param routingState The current routing state containing arrival times and marked stops
      */
     considerTransfers(query, round, markedStops, routingState) {
-        var _a, _b;
         const { options } = query;
         const arrivalsAtCurrentRound = routingState.graph[round];
         const newlyMarkedStops = new Set();
         for (const stop of markedStops) {
-            const currentArrival = arrivalsAtCurrentRound.get(stop);
+            const currentArrival = arrivalsAtCurrentRound[stop];
             // Skip transfers if the last leg was also a transfer
             if (!currentArrival || 'type' in currentArrival)
                 continue;
@@ -22170,19 +22271,16 @@ class Router {
                     transferTime = options.minTransferTime;
                 }
                 const arrivalAfterTransfer = currentArrival.arrival + transferTime;
-                const originalArrival = (_b = (_a = routingState.earliestArrivals.get(transfer.destination)) === null || _a === void 0 ? void 0 : _a.arrival) !== null && _b !== void 0 ? _b : UNREACHED;
+                const originalArrival = routingState.arrivalTime(transfer.destination);
                 if (arrivalAfterTransfer < originalArrival) {
-                    arrivalsAtCurrentRound.set(transfer.destination, {
+                    arrivalsAtCurrentRound[transfer.destination] = {
                         arrival: arrivalAfterTransfer,
                         from: stop,
                         to: transfer.destination,
                         minTransferTime: transfer.minTransferTime,
                         type: transfer.type,
-                    });
-                    routingState.earliestArrivals.set(transfer.destination, {
-                        arrival: arrivalAfterTransfer,
-                        legNumber: round,
-                    });
+                    };
+                    routingState.updateArrival(transfer.destination, arrivalAfterTransfer, round);
                     newlyMarkedStops.add(transfer.destination);
                 }
             }
@@ -22192,17 +22290,16 @@ class Router {
     /**
      * Finds the earliest arrival time at any stop from a given set of destinations.
      *
-     * @param earliestArrivals A map of stops to their earliest reaching times.
-     * @param destinations An array of destination stops to evaluate.
+     * @param routingState The routing state containing arrival times and destinations.
      * @returns The earliest arrival time among the provided destinations.
      */
-    earliestArrivalAtAnyStop(earliestArrivals, destinations) {
-        var _a, _b;
-        let earliestArrivalAtAnyDestination = UNREACHED;
-        for (let i = 0; i < destinations.length; i++) {
-            const destination = destinations[i];
-            const arrival = (_b = (_a = earliestArrivals.get(destination)) === null || _a === void 0 ? void 0 : _a.arrival) !== null && _b !== void 0 ? _b : UNREACHED;
-            earliestArrivalAtAnyDestination = Math.min(earliestArrivalAtAnyDestination, arrival);
+    earliestArrivalAtAnyStop(routingState) {
+        let earliestArrivalAtAnyDestination = UNREACHED_TIME;
+        for (let i = 0; i < routingState.destinations.length; i++) {
+            const arrival = routingState.arrivalTime(routingState.destinations[i]);
+            if (arrival < earliestArrivalAtAnyDestination) {
+                earliestArrivalAtAnyDestination = arrival;
+            }
         }
         return earliestArrivalAtAnyDestination;
     }