minotor 7.0.2 → 9.0.0

package/src/gtfs/transfers.ts

@@ -1,12 +1,17 @@
 import { SourceStopId, StopId } from '../stops/stops.js';
 import { Duration } from '../timetable/duration.js';
+import { Route } from '../timetable/route.js';
 import {
   ServiceRouteId,
+  Timetable,
   Transfer,
   TransferType,
+  TripBoarding,
+  TripContinuations,
 } from '../timetable/timetable.js';
+import { encode } from '../timetable/tripBoardingId.js';
 import { GtfsStopsMap } from './stops.js';
-import { TripId } from './trips.js';
+import { GtfsTripId, TripsMapping } from './trips.js';
 import { parseCsv } from './utils.js';
 
 export type GtfsTransferType =
@@ -19,11 +24,18 @@ export type GtfsTransferType =
 
 export type TransfersMap = Map<StopId, Transfer[]>;
 
+export type GtfsTripContinuation = {
+  fromStop: StopId;
+  fromTrip: GtfsTripId;
+  toStop: StopId;
+  toTrip: GtfsTripId;
+};
+
 export type TransferEntry = {
   from_stop_id?: SourceStopId;
   to_stop_id?: SourceStopId;
-  from_trip_id?: TripId;
-  to_trip_id?: TripId;
+  from_trip_id?: GtfsTripId;
+  to_trip_id?: GtfsTripId;
   from_route_id?: ServiceRouteId;
   to_route_id?: ServiceRouteId;
   transfer_type: GtfsTransferType;
@@ -39,9 +51,12 @@ export type TransferEntry = {
 export const parseTransfers = async (
   transfersStream: NodeJS.ReadableStream,
   stopsMap: GtfsStopsMap,
-): Promise<TransfersMap> => {
+): Promise<{
+  transfers: TransfersMap;
+  tripContinuations: GtfsTripContinuation[];
+}> => {
   const transfers: TransfersMap = new Map();
-
+  const tripContinuations: GtfsTripContinuation[] = [];
   for await (const rawLine of parseCsv(transfersStream, [
     'transfer_type',
     'min_transfer_time',
@@ -54,37 +69,67 @@ export const parseTransfers = async (
     ) {
       continue;
     }
-    if (transferEntry.from_trip_id && transferEntry.to_trip_id) {
+    if (!transferEntry.from_stop_id || !transferEntry.to_stop_id) {
+      console.warn(`Missing transfer origin or destination stop.`);
+      continue;
+    }
+    const fromStop = stopsMap.get(transferEntry.from_stop_id);
+    const toStop = stopsMap.get(transferEntry.to_stop_id);
+
+    if (!fromStop || !toStop) {
       console.warn(
-        `Unsupported transfer between trips ${transferEntry.from_trip_id} and ${transferEntry.to_trip_id}.`,
+        `Transfer references non-existent stop(s): from_stop_id=${transferEntry.from_stop_id}, to_stop_id=${transferEntry.to_stop_id}`,
       );
       continue;
     }
-    if (transferEntry.from_route_id && transferEntry.to_route_id) {
+
+    if (transferEntry.transfer_type === 4) {
+      if (
+        transferEntry.from_trip_id === undefined ||
+        transferEntry.from_trip_id === '' ||
+        transferEntry.to_trip_id === undefined ||
+        transferEntry.to_trip_id === ''
+      ) {
+        console.warn(
+          `Unsupported in-seat transfer, missing from_trip_id and/or to_trip_id.`,
+        );
+        continue;
+      }
+      const tripBoardingEntry: GtfsTripContinuation = {
+        fromStop: fromStop.id,
+        fromTrip: transferEntry.from_trip_id,
+        toStop: toStop.id,
+        toTrip: transferEntry.to_trip_id,
+      };
+      tripContinuations.push(tripBoardingEntry);
+      continue;
+    }
+    if (transferEntry.from_trip_id && transferEntry.to_trip_id) {
       console.warn(
-        `Unsupported transfer between routes ${transferEntry.from_route_id} and ${transferEntry.to_route_id}.`,
+        `Unsupported transfer of type ${transferEntry.transfer_type} between trips ${transferEntry.from_trip_id} and ${transferEntry.to_trip_id}.`,
       );
       continue;
     }
-    if (!transferEntry.from_stop_id || !transferEntry.to_stop_id) {
-      console.warn(`Missing transfer origin or destination stop.`);
+    if (transferEntry.from_route_id && transferEntry.to_route_id) {
+      console.warn(
+        `Unsupported transfer of type ${transferEntry.transfer_type} between routes ${transferEntry.from_route_id} and ${transferEntry.to_route_id}.`,
+      );
       continue;
     }
-    if (transferEntry.transfer_type === 2 && !transferEntry.min_transfer_time) {
+
+    if (
+      transferEntry.transfer_type === 2 &&
+      transferEntry.min_transfer_time === undefined
+    ) {
       console.info(
         `Missing minimum transfer time between ${transferEntry.from_stop_id} and ${transferEntry.to_stop_id}.`,
       );
     }
 
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    const fromStop = stopsMap.get(transferEntry.from_stop_id)!;
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    const toStop = stopsMap.get(transferEntry.to_stop_id)!;
-
     const transfer: Transfer = {
       destination: toStop.id,
       type: parseGtfsTransferType(transferEntry.transfer_type),
-      ...(transferEntry.min_transfer_time && {
+      ...(transferEntry.min_transfer_time !== undefined && {
         minTransferTime: Duration.fromSeconds(transferEntry.min_transfer_time),
       }),
     };
@@ -93,7 +138,136 @@ export const parseTransfers = async (
     fromStopTransfers.push(transfer);
     transfers.set(fromStop.id, fromStopTransfers);
   }
-  return transfers;
+  return {
+    transfers,
+    tripContinuations,
+  };
+};
+
+/**
+ * Disambiguates stops involved in a transfer.
+ *
+ * The GTFS specification only refers to a stopId in the trip-to-trip transfers and not the
+ * specific stop index in the route. For routes that have multiple stops with the same stopId,
+ * we need to determine which are the from / to stop indices in respective routes.
+ * We do so by picking the stop indices leading to the most coherent transfer.
+ * (we pick the closest from stop index happening after the to stop index).
+ */
+const disambiguateTransferStopsIndices = (
+  fromStop: StopId,
+  fromRoute: Route,
+  fromTripIndex: number,
+  toStop: StopId,
+  toRoute: Route,
+  toTripIndex: number,
+): { fromStopIndex: number; toStopIndex: number } | undefined => {
+  const fromStopIndices = fromRoute.stopRouteIndices(fromStop);
+  const toStopIndices = toRoute.stopRouteIndices(toStop);
+  let bestFromStopIndex: number | undefined;
+  let bestToStopIndex: number | undefined;
+  let bestTimeDifference = Infinity;
+
+  for (const originStopIndex of fromStopIndices) {
+    const fromArrivalTime = fromRoute.arrivalAt(originStopIndex, fromTripIndex);
+    for (const toStopIndex of toStopIndices) {
+      const toDepartureTime = toRoute.departureFrom(toStopIndex, toTripIndex);
+      if (toDepartureTime.isAfter(fromArrivalTime)) {
+        const timeDifference =
+          toDepartureTime.toMinutes() - fromArrivalTime.toMinutes();
+        if (timeDifference < bestTimeDifference) {
+          bestTimeDifference = timeDifference;
+          bestFromStopIndex = originStopIndex;
+          bestToStopIndex = toStopIndex;
+        }
+      }
+    }
+  }
+
+  if (bestFromStopIndex !== undefined && bestToStopIndex !== undefined) {
+    return {
+      fromStopIndex: bestFromStopIndex,
+      toStopIndex: bestToStopIndex,
+    };
+  }
+
+  return undefined;
+};
+
+/**
+ * Builds trip continuations map from GTFS trip continuation data.
+ *
+ * This function processes GTFS in-seat transfer data and creates a mapping
+ * from trip boarding IDs to continuation boarding information. It disambiguates
+ * stop indices when routes have multiple stops with the same ID by finding
+ * the most coherent transfer timing.
+ *
+ * @param tripsMapping Mapping from GTFS trip IDs to internal trip representations
+ * @param tripContinuations Array of GTFS trip continuation data from transfers.txt
+ * @param timetable The timetable containing route and timing information
+ * @param activeStopIds Set of stop IDs that are active/enabled in the system
+ * @returns A map from trip boarding IDs to arrays of continuation boarding options
+ */
+export const buildTripContinuations = (
+  tripsMapping: TripsMapping,
+  tripContinuations: GtfsTripContinuation[],
+  timetable: Timetable,
+  activeStopIds: Set<StopId>,
+): TripContinuations => {
+  const continuations: TripContinuations = new Map();
+
+  for (const gtfsContinuation of tripContinuations) {
+    if (
+      !activeStopIds.has(gtfsContinuation.fromStop) ||
+      !activeStopIds.has(gtfsContinuation.toStop)
+    ) {
+      continue;
+    }
+    const fromTripMapping = tripsMapping.get(gtfsContinuation.fromTrip);
+    const toTripMapping = tripsMapping.get(gtfsContinuation.toTrip);
+
+    if (!fromTripMapping || !toTripMapping) {
+      continue;
+    }
+
+    const fromRoute = timetable.getRoute(fromTripMapping.routeId);
+    const toRoute = timetable.getRoute(toTripMapping.routeId);
+
+    if (!fromRoute || !toRoute) {
+      continue;
+    }
+
+    const bestStopIndices = disambiguateTransferStopsIndices(
+      gtfsContinuation.fromStop,
+      fromRoute,
+      fromTripMapping.tripRouteIndex,
+      gtfsContinuation.toStop,
+      toRoute,
+      toTripMapping.tripRouteIndex,
+    );
+
+    if (!bestStopIndices) {
+      // No valid continuation found
+      continue;
+    }
+
+    const tripBoardingId = encode(
+      bestStopIndices.fromStopIndex,
+      fromTripMapping.routeId,
+      fromTripMapping.tripRouteIndex,
+    );
+
+    const continuationBoarding: TripBoarding = {
+      hopOnStopIndex: bestStopIndices.toStopIndex,
+      routeId: toTripMapping.routeId,
+      tripIndex: toTripMapping.tripRouteIndex,
+    };
+
+    const existingContinuations = continuations.get(tripBoardingId) || [];
+    existingContinuations.push(continuationBoarding);
+    continuations.set(tripBoardingId, existingContinuations);
+  }
+
+  return continuations;
 };
 
 const parseGtfsTransferType = (

package/src/gtfs/trips.ts

@@ -6,6 +6,8 @@ import {
   NOT_AVAILABLE,
   REGULAR,
   Route,
+  RouteId,
+  TripRouteIndex,
 } from '../timetable/route.js';
 import {
   ServiceRoute,
@@ -19,14 +21,19 @@ import { GtfsTime, toTime } from './time.js';
 import { TransfersMap } from './transfers.js';
 import { hashIds, parseCsv } from './utils.js';
 
-export type TripId = string;
+export type GtfsTripId = string;
 
-export type TripIdsMap = Map<TripId, GtfsRouteId>;
+export type GtfsTripIdsMap = Map<GtfsTripId, GtfsRouteId>;
+
+export type TripsMapping = Map<
+  GtfsTripId,
+  { routeId: RouteId; tripRouteIndex: TripRouteIndex }
+>;
 
 type TripEntry = {
   route_id: GtfsRouteId;
   service_id: ServiceId;
-  trip_id: TripId;
+  trip_id: GtfsTripId;
 };
 
 export type GtfsPickupDropOffType =
@@ -37,7 +44,7 @@ export type GtfsPickupDropOffType =
   | '3'; // Must coordinate with driver
 
 type StopTimeEntry = {
-  trip_id: TripId;
+  trip_id: GtfsTripId;
   arrival_time?: GtfsTime;
   departure_time?: GtfsTime;
   stop_id: SourceStopId;
@@ -55,6 +62,7 @@ type RouteBuilder = {
   serviceRouteId: ServiceRouteId;
   stops: StopId[];
   trips: Array<{
+    gtfsTripId: GtfsTripId;
     firstDeparture: number;
     arrivalTimes: number[];
     departureTimes: number[];
@@ -109,7 +117,9 @@ export const encodePickUpDropOffTypes = (
 /**
  * Sorts trips by departure time and creates optimized typed arrays
  */
-const finalizeRouteFromBuilder = (builder: RouteBuilder): SerializedRoute => {
+const finalizeRouteFromBuilder = (
+  builder: RouteBuilder,
+): [SerializedRoute, GtfsTripId[]] => {
   builder.trips.sort((a, b) => a.firstDeparture - b.firstDeparture);
 
   const stopsCount = builder.stops.length;
@@ -119,11 +129,13 @@ const finalizeRouteFromBuilder = (builder: RouteBuilder): SerializedRoute => {
   const allPickUpTypes: SerializedPickUpDropOffType[] = [];
   const allDropOffTypes: SerializedPickUpDropOffType[] = [];
 
+  const gtfsTripIds = [];
   for (let tripIndex = 0; tripIndex < tripsCount; tripIndex++) {
     const trip = builder.trips[tripIndex];
     if (!trip) {
       throw new Error(`Missing trip data at index ${tripIndex}`);
     }
+    gtfsTripIds.push(trip.gtfsTripId);
     const baseIndex = tripIndex * stopsCount * 2;
 
     for (let stopIndex = 0; stopIndex < stopsCount; stopIndex++) {
@@ -155,12 +167,15 @@ const finalizeRouteFromBuilder = (builder: RouteBuilder): SerializedRoute => {
     allPickUpTypes,
     allDropOffTypes,
   );
-  return {
-    serviceRouteId: builder.serviceRouteId,
-    stops: stopsArray,
-    stopTimes: stopTimesArray,
-    pickUpDropOffTypes: pickUpDropOffTypesArray,
-  };
+  return [
+    {
+      serviceRouteId: builder.serviceRouteId,
+      stops: stopsArray,
+      stopTimes: stopTimesArray,
+      pickUpDropOffTypes: pickUpDropOffTypesArray,
+    },
+    gtfsTripIds,
+  ];
 };
 
 /**
@@ -175,8 +190,8 @@ export const parseTrips = async (
   tripsStream: NodeJS.ReadableStream,
   serviceIds: ServiceIds,
   validGtfsRoutes: GtfsRoutesMap,
-): Promise<TripIdsMap> => {
-  const trips: TripIdsMap = new Map();
+): Promise<GtfsTripIdsMap> => {
+  const trips: GtfsTripIdsMap = new Map();
   for await (const rawLine of parseCsv(tripsStream, ['stop_sequence'])) {
     const line = rawLine as TripEntry;
     if (!serviceIds.has(line.service_id)) {
@@ -199,10 +214,11 @@ export const buildStopsAdjacencyStructure = (
   nbStops: number,
   activeStops: Set<StopId>,
 ): StopAdjacency[] => {
-  // TODO somehow works when it's a map
   const stopsAdjacency = new Array<StopAdjacency>(nbStops);
   for (let i = 0; i < nbStops; i++) {
-    stopsAdjacency[i] = { routes: [], transfers: [] };
+    stopsAdjacency[i] = {
+      routes: [],
+    };
   }
   for (let index = 0; index < routes.length; index++) {
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
@@ -229,7 +245,11 @@ export const buildStopsAdjacencyStructure = (
       const transfer = transfers[i]!;
       if (activeStops.has(stop) || activeStops.has(transfer.destination)) {
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        stopsAdjacency[stop]!.transfers.push(transfer);
+        const stopAdj = stopsAdjacency[stop]!;
+        if (!stopAdj.transfers) {
+          stopAdj.transfers = [];
+        }
+        stopAdj.transfers.push(transfer);
         activeStops.add(transfer.destination);
         activeStops.add(stop);
       }
@@ -250,16 +270,17 @@ export const buildStopsAdjacencyStructure = (
 export const parseStopTimes = async (
   stopTimesStream: NodeJS.ReadableStream,
   stopsMap: GtfsStopsMap,
-  activeTripIds: TripIdsMap,
+  activeTripIds: GtfsTripIdsMap,
   activeStopIds: Set<StopId>,
 ): Promise<{
   routes: Route[];
   serviceRoutesMap: Map<GtfsRouteId, ServiceRouteId>;
+  tripsMapping: TripsMapping;
 }> => {
   /**
    * Adds a trip to the appropriate route builder
    */
-  const addTrip = (currentTripId: TripId) => {
+  const addTrip = (currentTripId: GtfsTripId) => {
     const gtfsRouteId = activeTripIds.get(currentTripId);
 
     if (!gtfsRouteId || stops.length === 0) {
@@ -304,6 +325,7 @@ export const parseStopTimes = async (
 
     routeBuilder.trips.push({
       firstDeparture,
+      gtfsTripId: currentTripId,
       arrivalTimes: arrivalTimes,
       departureTimes: departureTimes,
       pickUpTypes: pickUpTypes,
@@ -330,7 +352,7 @@ export const parseStopTimes = async (
   let departureTimes: number[] = [];
   let pickUpTypes: SerializedPickUpDropOffType[] = [];
   let dropOffTypes: SerializedPickUpDropOffType[] = [];
-  let currentTripId: TripId | undefined = undefined;
+  let currentTripId: GtfsTripId | undefined = undefined;
 
   for await (const rawLine of parseCsv(stopTimesStream, ['stop_sequence'])) {
     const line = rawLine as StopTimeEntry;
@@ -347,6 +369,9 @@ export const parseStopTimes = async (
       continue;
     }
     if (line.pickup_type === '1' && line.drop_off_type === '1') {
+      // Warning: could potentially lead to issues if there is an in-seat transfer
+      // at this stop - it can be not boardable nor alightable but still useful for an in-seat transfer.
+      // This doesn't seem to happen in practice for now so keeping this condition to save memory.
       continue;
     }
     if (currentTripId && line.trip_id !== currentTripId && stops.length > 0) {
@@ -382,18 +407,30 @@ export const parseStopTimes = async (
   }
 
   const routesAdjacency: Route[] = [];
+  const tripsMapping = new Map<
+    GtfsTripId,
+    { routeId: RouteId; tripRouteIndex: TripRouteIndex }
+  >();
   for (const [, routeBuilder] of routeBuilders) {
-    const routeData = finalizeRouteFromBuilder(routeBuilder);
+    const [routeData, gtfsTripIds] = finalizeRouteFromBuilder(routeBuilder);
+    const routeId = routesAdjacency.length;
     routesAdjacency.push(
       new Route(
+        routeId,
         routeData.stopTimes,
         routeData.pickUpDropOffTypes,
         routeData.stops,
         routeData.serviceRouteId,
       ),
     );
+    gtfsTripIds.forEach((tripId, index) => {
+      tripsMapping.set(tripId, {
+        routeId,
+        tripRouteIndex: index,
+      });
+    });
   }
-  return { routes: routesAdjacency, serviceRoutesMap };
+  return { routes: routesAdjacency, serviceRoutesMap, tripsMapping };
 };
 
 const parsePickupDropOffType = (

package/src/router.ts

@@ -3,7 +3,7 @@ import { Query } from './routing/query.js';
 import { Result } from './routing/result.js';
 import type { Leg, Transfer, VehicleLeg } from './routing/route.js';
 import { Route } from './routing/route.js';
-import type { ReachingTime } from './routing/router.js';
+import type { Arrival } from './routing/router.js';
 import { Router } from './routing/router.js';
 import type { LocationType, SourceStopId, StopId } from './stops/stops.js';
 import type { Stop } from './stops/stops.js';
@@ -30,9 +30,9 @@ export {
 };
 
 export type {
+  Arrival,
   Leg,
   LocationType,
-  ReachingTime,
   RouteType,
   ServiceRouteInfo,
   SourceStopId,