minotor 11.1.1 → 11.1.3

package/CHANGELOG.md

@@ -1,6 +1,6 @@
-## [11.1.1](https://github.com/aubryio/minotor/compare/v11.1.0...v11.1.1) (2026-04-18)
+## [11.1.3](https://github.com/aubryio/minotor/compare/v11.1.2...v11.1.3) (2026-04-18)
 
 
-### Performance Improvements
+### Bug Fixes
 
-* optimize routing state by swapping maps for arrays ([#64](https://github.com/aubryio/minotor/issues/64)) ([b37d086](https://github.com/aubryio/minotor/commit/b37d08653f115d22c4b49f88f15521efbcfdae62))
+* re-expose arrivals iterator ([681ee3a](https://github.com/aubryio/minotor/commit/681ee3a7c131c097734333cd60f5b0eed35cf3bd))

package/dist/cli.mjs

@@ -17263,6 +17263,45 @@ let Route$1 = class Route {
         }
         return arrival;
     }
+    /**
+     * Computes the per-trip base offset used by the hot-path scanning methods.
+     *
+     * Cache the result once when boarding a new trip and pass it to
+     * {@link arrivalAtOffset} and {@link dropOffTypeAtOffset} throughout the
+     * scanning loop to avoid recomputing `tripIndex × nbStops` on every stop.
+     *
+     * @param tripIndex - The index of the trip.
+     * @returns `tripIndex × nbStops`.
+     */
+    tripStopOffset(tripIndex) {
+        return tripIndex * this.nbStops;
+    }
+    /**
+     * Hot-path variant of {@link arrivalAt} that accepts a precomputed base offset.
+     *
+     * @param stopIndex - The index of the stop in the route.
+     * @param offset    - Precomputed value from {@link tripStopOffset}.
+     * @returns The arrival time at the specified stop.
+     */
+    arrivalAtOffset(stopIndex, offset) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        return this.stopTimes[(offset + stopIndex) * 2];
+    }
+    /**
+     * Hot-path variant of {@link dropOffTypeAt} that accepts a precomputed base offset.
+     *
+     * @param stopIndex - The index of the stop in the route.
+     * @param offset    - Precomputed value from {@link tripStopOffset}.
+     * @returns The drop-off type at the specified stop.
+     */
+    dropOffTypeAtOffset(stopIndex, offset) {
+        const globalIndex = offset + stopIndex;
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const byte = this.pickupDropOffTypes[globalIndex >> 1];
+        // Bit layout per byte (two pairs): [pickup_1(2)][dropOff_1(2)][pickup_0(2)][dropOff_0(2)]
+        // First pair  → drop-off in lower 2 bits; second pair → drop-off in bits 4-5.
+        return (globalIndex & 1 ? (byte >> 4) & 0x03 : byte & 0x03);
+    }
     /**
      * Retrieves the departure time at a specific stop for a given trip.
      *
@@ -17854,21 +17893,26 @@ class Timetable {
      */
     findReachableRoutes(fromStops, transportModes = ALL_TRANSPORT_MODES) {
         const reachableRoutes = new Map();
-        const fromStopsArray = Array.from(fromStops);
-        for (let i = 0; i < fromStopsArray.length; i++) {
-            const originStop = fromStopsArray[i];
-            const validRoutes = this.routesPassingThrough(originStop).filter((route) => {
-                const serviceRoute = this.getServiceRouteInfo(route);
-                return transportModes.has(serviceRoute.type);
-            });
-            for (let j = 0; j < validRoutes.length; j++) {
-                const route = validRoutes[j];
-                const originStopIndices = route.stopRouteIndices(originStop);
-                const originStopIndex = originStopIndices[0];
+        // Skip the per-route mode check entirely when all modes are allowed,
+        // which is the common case.
+        const filterByMode = transportModes !== ALL_TRANSPORT_MODES;
+        for (const originStop of fromStops) {
+            const stopData = this.stopsAdjacency[originStop];
+            if (!stopData)
+                continue;
+            for (let i = 0; i < stopData.routes.length; i++) {
+                const route = this.routesAdjacency[stopData.routes[i]];
+                if (!route)
+                    continue;
+                if (filterByMode) {
+                    const serviceRoute = this.serviceRoutes[route.serviceRoute()];
+                    if (!serviceRoute || !transportModes.has(serviceRoute.type))
+                        continue;
+                }
+                const originStopIndex = route.stopRouteIndices(originStop)[0];
                 const existingHopOnStopIndex = reachableRoutes.get(route);
                 if (existingHopOnStopIndex !== undefined) {
                     if (originStopIndex < existingHopOnStopIndex) {
-                        // if the current stop is before the existing hop on stop, replace it
                         reachableRoutes.set(route, originStopIndex);
                     }
                 }
@@ -17893,9 +17937,15 @@ class Timetable {
         if (!guaranteedTransfers) {
             return false;
         }
-        return guaranteedTransfers.some((transfer) => transfer.stopIndex === toTripStop.stopIndex &&
-            transfer.routeId === toTripStop.routeId &&
-            transfer.tripIndex === toTripStop.tripIndex);
+        for (let i = 0; i < guaranteedTransfers.length; i++) {
+            const transfer = guaranteedTransfers[i];
+            if (transfer.stopIndex === toTripStop.stopIndex &&
+                transfer.routeId === toTripStop.routeId &&
+                transfer.tripIndex === toTripStop.tripIndex) {
+                return true;
+            }
+        }
+        return false;
     }
     /**
      * Retrieves all guaranteed trip transfer options available at the specified stop for a given trip.
@@ -21949,6 +21999,31 @@ class RoutingState {
         this.earliestArrivalTimes[stop] = time;
         this.earliestArrivalLegs[stop] = leg;
     }
+    /**
+     * Iterates over every stop that has been reached, yielding its stop ID,
+     * earliest arrival time, and the number of legs taken to reach it.
+     *
+     * Unreached stops (those still at UNREACHED_TIME) are skipped entirely.
+     *
+     * @example
+     * ```ts
+     * for (const { stop, arrival, legNumber } of routingState.arrivals()) {
+     *   console.log(`Stop ${stop}: arrived at ${arrival} after ${legNumber} leg(s)`);
+     * }
+     * ```
+     */
+    *arrivals() {
+        for (let stop = 0; stop < this.earliestArrivalTimes.length; stop++) {
+            const time = this.earliestArrivalTimes[stop];
+            if (time < UNREACHED_TIME) {
+                yield {
+                    stop,
+                    arrival: time,
+                    legNumber: this.earliestArrivalLegs[stop],
+                };
+            }
+        }
+    }
     /**
      * Returns the earliest arrival at a stop as an {@link Arrival} object,
      * or undefined if the stop has not been reached.
@@ -22041,11 +22116,12 @@ class Router {
             }
             // process in-seat trip continuations
             let continuations = this.findTripContinuations(markedStops, edgesAtCurrentRound);
+            const stopsFromContinuations = new Set();
             while (continuations.length > 0) {
-                const stopsFromContinuations = new Set();
+                stopsFromContinuations.clear();
                 for (const continuation of continuations) {
                     const route = this.timetable.getRoute(continuation.routeId);
-                    const routeScanResults = this.scanRoute(route, continuation.stopIndex, round, routingState, query.options, continuation);
+                    const routeScanResults = this.scanRouteContinuation(route, continuation.stopIndex, round, routingState, continuation);
                     for (const newStop of routeScanResults) {
                         stopsFromContinuations.add(newStop);
                     }
@@ -22112,84 +22188,113 @@ class Router {
         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.
+     * Scans a route for an in-seat trip continuation.
      *
-     * This method implements the core route scanning logic of the RAPTOR algorithm.
-     * It iterates through all stops on a given route starting from the hop-on stop,
-     * maintaining the current best trip and updating arrival times when improvements
-     * are found. The method also handles boarding new trips when earlier departures
-     * are available if no given trip is provided as a parameter.
+     * The boarded trip and entry stop are fixed, so there is no need to probe for
+     * earlier boardings.
      *
-     * @param route The route to scan for possible trips
-     * @param hopOnStopIndex The stop index where passengers can board the route
-     * @param round The current round number in the RAPTOR algorithm
-     * @param routingState The current routing state containing arrival times and marked stops
+     * @param route The route to scan
+     * @param hopOnStopIndex The stop index where the continuation begins
+     * @param round The current RAPTOR round
+     * @param routingState Current routing state
+     * @param tripContinuation The in-seat continuation descriptor
      */
-    scanRoute(route, hopOnStopIndex, round, routingState, options, tripContinuation) {
+    scanRouteContinuation(route, hopOnStopIndex, round, routingState, tripContinuation) {
         const newlyMarkedStops = new Set();
-        let activeTrip = tripContinuation
-            ? {
-                routeId: route.id,
-                stopIndex: hopOnStopIndex,
-                tripIndex: tripContinuation.tripIndex,
+        const edgesAtCurrentRound = routingState.graph[round];
+        const earliestArrivalAtAnyDestination = this.earliestArrivalAtAnyStop(routingState);
+        const nbStops = route.getNbStops();
+        const routeId = route.id;
+        const tripIndex = tripContinuation.tripIndex;
+        const tripStopOffset = route.tripStopOffset(tripIndex);
+        const previousEdge = tripContinuation.previousEdge;
+        for (let currentStopIndex = hopOnStopIndex; currentStopIndex < nbStops; currentStopIndex++) {
+            const currentStop = route.stops[currentStopIndex];
+            const arrivalTime = route.arrivalAtOffset(currentStopIndex, tripStopOffset);
+            const dropOffType = route.dropOffTypeAtOffset(currentStopIndex, tripStopOffset);
+            const earliestArrivalAtCurrentStop = routingState.arrivalTime(currentStop);
+            if (dropOffType !== NOT_AVAILABLE &&
+                arrivalTime < earliestArrivalAtCurrentStop &&
+                arrivalTime < earliestArrivalAtAnyDestination) {
+                edgesAtCurrentRound[currentStop] = {
+                    routeId,
+                    stopIndex: hopOnStopIndex,
+                    tripIndex,
+                    arrival: arrivalTime,
+                    hopOffStopIndex: currentStopIndex,
+                    continuationOf: previousEdge,
+                };
+                routingState.updateArrival(currentStop, arrivalTime, round);
+                newlyMarkedStops.add(currentStop);
             }
-            : undefined;
+        }
+        return newlyMarkedStops;
+    }
+    /**
+     * Scans a route using the standard RAPTOR boarding logic.
+     *
+     * Iterates through all stops from the hop-on point, maintaining the current
+     * best trip and improving arrival times when possible. At each marked stop it
+     * also checks whether an earlier (or first) trip can be boarded, upgrading the
+     * active trip when one is found.
+     *
+     * @param route The route to scan
+     * @param hopOnStopIndex The stop index where passengers can first board
+     * @param round The current RAPTOR round
+     * @param routingState Current routing state
+     * @param options Query options (minTransferTime, etc.)
+     */
+    scanRoute(route, hopOnStopIndex, round, routingState, options) {
+        const newlyMarkedStops = new Set();
         const edgesAtCurrentRound = routingState.graph[round];
         const edgesAtPreviousRound = routingState.graph[round - 1];
-        // Compute target pruning criteria only once per route
         const earliestArrivalAtAnyDestination = this.earliestArrivalAtAnyStop(routingState);
-        for (let currentStopIndex = hopOnStopIndex; currentStopIndex < route.getNbStops(); currentStopIndex++) {
+        const nbStops = route.getNbStops();
+        const routeId = route.id;
+        let activeTripIndex;
+        let activeTripBoardStopIndex = hopOnStopIndex;
+        // tripStopOffset = activeTripIndex * nbStops, precomputed when the trip changes.
+        // Only valid while activeTripIndex !== undefined.
+        let activeTripStopOffset = 0;
+        for (let currentStopIndex = hopOnStopIndex; currentStopIndex < nbStops; currentStopIndex++) {
             const currentStop = route.stops[currentStopIndex];
-            // If we're currently on a trip,
-            // check if arrival at the stop improves the earliest arrival time
-            if (activeTrip !== undefined) {
-                const arrivalTime = route.arrivalAt(currentStopIndex, activeTrip.tripIndex);
-                const dropOffType = route.dropOffTypeAt(currentStopIndex, activeTrip.tripIndex);
+            // If on a trip, check whether alighting here improves the global best.
+            if (activeTripIndex !== undefined) {
+                const arrivalTime = route.arrivalAtOffset(currentStopIndex, activeTripStopOffset);
+                const dropOffType = route.dropOffTypeAtOffset(currentStopIndex, activeTripStopOffset);
                 const earliestArrivalAtCurrentStop = routingState.arrivalTime(currentStop);
                 if (dropOffType !== NOT_AVAILABLE &&
                     arrivalTime < earliestArrivalAtCurrentStop &&
                     arrivalTime < earliestArrivalAtAnyDestination) {
-                    const edge = {
-                        routeId: activeTrip.routeId,
-                        stopIndex: activeTrip.stopIndex,
-                        tripIndex: activeTrip.tripIndex,
+                    edgesAtCurrentRound[currentStop] = {
+                        routeId,
+                        stopIndex: activeTripBoardStopIndex,
+                        tripIndex: activeTripIndex,
                         arrival: arrivalTime,
                         hopOffStopIndex: currentStopIndex,
                     };
-                    if (tripContinuation) {
-                        // In case of continuous trip, we set a pointer to the previous edge
-                        edge.continuationOf = tripContinuation.previousEdge;
-                    }
-                    edgesAtCurrentRound[currentStop] = edge;
                     routingState.updateArrival(currentStop, arrivalTime, round);
                     newlyMarkedStops.add(currentStop);
                 }
             }
-            if (tripContinuation) {
-                // If it's a trip continuation, no need to check for earlier trips
-                continue;
-            }
-            // check if we can board an earlier trip at the current stop
-            // if there was no current trip, find the first one reachable
+            // Check whether we can board an earlier (or first) trip at this stop.
             const previousEdge = edgesAtPreviousRound[currentStop];
             const earliestArrivalOnPreviousRound = previousEdge === null || previousEdge === void 0 ? void 0 : previousEdge.arrival;
             if (earliestArrivalOnPreviousRound !== undefined &&
-                (activeTrip === undefined ||
+                (activeTripIndex === undefined ||
                     earliestArrivalOnPreviousRound <=
-                        route.departureFrom(currentStopIndex, activeTrip.tripIndex))) {
-                const earliestTrip = route.findEarliestTrip(currentStopIndex, earliestArrivalOnPreviousRound, activeTrip === null || activeTrip === void 0 ? void 0 : activeTrip.tripIndex);
+                        route.departureFrom(currentStopIndex, activeTripIndex))) {
+                const earliestTrip = route.findEarliestTrip(currentStopIndex, earliestArrivalOnPreviousRound, activeTripIndex);
                 if (earliestTrip === undefined) {
                     continue;
                 }
-                const firstBoardableTrip = this.findFirstBoardableTrip(currentStopIndex, route, earliestTrip, earliestArrivalOnPreviousRound, activeTrip === null || activeTrip === void 0 ? void 0 : activeTrip.tripIndex, 
-                // provide the previous trip if the previous edge was a vehicle
+                const firstBoardableTrip = this.findFirstBoardableTrip(currentStopIndex, route, earliestTrip, earliestArrivalOnPreviousRound, activeTripIndex, 
+                // provide the previous edge only if it was a vehicle leg
                 previousEdge && 'routeId' in previousEdge ? previousEdge : undefined, options.minTransferTime);
                 if (firstBoardableTrip !== undefined) {
-                    activeTrip = {
-                        routeId: route.id,
-                        tripIndex: firstBoardableTrip,
-                        stopIndex: currentStopIndex,
-                    };
+                    activeTripIndex = firstBoardableTrip;
+                    activeTripBoardStopIndex = currentStopIndex;
+                    activeTripStopOffset = route.tripStopOffset(firstBoardableTrip);
                 }
             }
         }