minotor 7.0.1 → 8.0.0

package/src/gtfs/transfers.ts

@@ -6,7 +6,7 @@ import {
   TransferType,
 } from '../timetable/timetable.js';
 import { GtfsStopsMap } from './stops.js';
-import { TripId } from './trips.js';
+import { GtfsTripId } from './trips.js';
 import { parseCsv } from './utils.js';
 
 export type GtfsTransferType =
@@ -19,11 +19,19 @@ export type GtfsTransferType =
 
 export type TransfersMap = Map<StopId, Transfer[]>;
 
+export type GtfsTripBoarding = {
+  fromTrip: GtfsTripId;
+  toTrip: GtfsTripId;
+  hopOnStop: StopId;
+};
+
+export type TripContinuationsMap = Map<StopId, GtfsTripBoarding[]>;
+
 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 +47,12 @@ export type TransferEntry = {
 export const parseTransfers = async (
   transfersStream: NodeJS.ReadableStream,
   stopsMap: GtfsStopsMap,
-): Promise<TransfersMap> => {
+): Promise<{
+  transfers: TransfersMap;
+  tripContinuations: TripContinuationsMap;
+}> => {
   const transfers: TransfersMap = new Map();
-
+  const tripContinuations: TripContinuationsMap = new Map();
   for await (const rawLine of parseCsv(transfersStream, [
     'transfer_type',
     'min_transfer_time',
@@ -54,33 +65,62 @@ export const parseTransfers = async (
     ) {
       continue;
     }
+    if (!transferEntry.from_stop_id || !transferEntry.to_stop_id) {
+      console.warn(`Missing transfer origin or destination stop.`);
+      continue;
+    }
+    // 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)!;
+
+    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: GtfsTripBoarding = {
+        fromTrip: transferEntry.from_trip_id,
+        toTrip: transferEntry.to_trip_id,
+        hopOnStop: toStop.id,
+      };
+      const existingBoardings = tripContinuations.get(fromStop.id);
+      if (existingBoardings) {
+        existingBoardings.push(tripBoardingEntry);
+      } else {
+        tripContinuations.set(fromStop.id, [tripBoardingEntry]);
+      }
+      continue;
+    }
     if (transferEntry.from_trip_id && transferEntry.to_trip_id) {
       console.warn(
-        `Unsupported transfer between trips ${transferEntry.from_trip_id} and ${transferEntry.to_trip_id}.`,
+        `Unsupported transfer of type ${transferEntry.transfer_type} between trips ${transferEntry.from_trip_id} and ${transferEntry.to_trip_id}.`,
       );
       continue;
     }
     if (transferEntry.from_route_id && transferEntry.to_route_id) {
       console.warn(
-        `Unsupported transfer between routes ${transferEntry.from_route_id} and ${transferEntry.to_route_id}.`,
+        `Unsupported transfer of type ${transferEntry.transfer_type} between routes ${transferEntry.from_route_id} and ${transferEntry.to_route_id}.`,
       );
       continue;
     }
-    if (!transferEntry.from_stop_id || !transferEntry.to_stop_id) {
-      console.warn(`Missing transfer origin or destination stop.`);
-      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),
@@ -93,7 +133,10 @@ export const parseTransfers = async (
     fromStopTransfers.push(transfer);
     transfers.set(fromStop.id, fromStopTransfers);
   }
-  return transfers;
+  return {
+    transfers,
+    tripContinuations,
+  };
 };
 
 const parseGtfsTransferType = (

package/src/gtfs/trips.ts

@@ -6,27 +6,35 @@ import {
   NOT_AVAILABLE,
   REGULAR,
   Route,
+  RouteId,
+  TripRouteIndex,
 } from '../timetable/route.js';
 import {
   ServiceRoute,
   ServiceRouteId,
   StopAdjacency,
 } from '../timetable/timetable.js';
+import { encode } from '../timetable/tripId.js';
 import { GtfsRouteId, GtfsRoutesMap } from './routes.js';
 import { ServiceId, ServiceIds } from './services.js';
 import { GtfsStopsMap } from './stops.js';
 import { GtfsTime, toTime } from './time.js';
-import { TransfersMap } from './transfers.js';
+import { TransfersMap, TripContinuationsMap } 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 +45,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 +63,7 @@ type RouteBuilder = {
   serviceRouteId: ServiceRouteId;
   stops: StopId[];
   trips: Array<{
+    gtfsTripId: GtfsTripId;
     firstDeparture: number;
     arrivalTimes: number[];
     departureTimes: number[];
@@ -109,7 +118,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 +130,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 +168,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 +191,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)) {
@@ -193,16 +209,19 @@ export const parseTrips = async (
 };
 
 export const buildStopsAdjacencyStructure = (
+  tripsMapping: TripsMapping,
   serviceRoutes: ServiceRoute[],
   routes: Route[],
   transfersMap: TransfersMap,
+  tripContinuationsMap: TripContinuationsMap,
   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,12 +248,51 @@ 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);
       }
     }
   }
+  for (const [stop, tripContinuations] of tripContinuationsMap) {
+    for (let i = 0; i < tripContinuations.length; i++) {
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      const tripContinuation = tripContinuations[i]!;
+      if (
+        activeStops.has(stop) ||
+        activeStops.has(tripContinuation.hopOnStop)
+      ) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const stopAdj = stopsAdjacency[stop]!;
+        if (!stopAdj.tripContinuations) {
+          stopAdj.tripContinuations = new Map();
+        }
+        const originTrip = tripsMapping.get(tripContinuation.fromTrip);
+        const destinationTrip = tripsMapping.get(tripContinuation.toTrip);
+        if (destinationTrip === undefined || originTrip === undefined) {
+          continue;
+        }
+        const tripBoarding = {
+          hopOnStop: tripContinuation.hopOnStop,
+          routeId: destinationTrip.routeId,
+          tripIndex: destinationTrip.tripRouteIndex,
+        };
+        const tripId = encode(originTrip.routeId, originTrip.tripRouteIndex);
+        const existingContinuations = stopAdj.tripContinuations.get(tripId);
+        if (existingContinuations) {
+          existingContinuations.push(tripBoarding);
+        } else {
+          stopAdj.tripContinuations.set(tripId, [tripBoarding]);
+        }
+        activeStops.add(tripContinuation.hopOnStop);
+        activeStops.add(stop);
+      }
+    }
+  }
   return stopsAdjacency;
 };
 
@@ -250,16 +308,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 +363,7 @@ export const parseStopTimes = async (
 
     routeBuilder.trips.push({
       firstDeparture,
+      gtfsTripId: currentTripId,
       arrivalTimes: arrivalTimes,
       departureTimes: departureTimes,
       pickUpTypes: pickUpTypes,
@@ -330,7 +390,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 +407,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 +445,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,

package/src/routing/__tests__/plotter.test.ts

@@ -0,0 +1,230 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+
+import { Timetable } from '../../router.js';
+import { Stop, StopId } from '../../stops/stops.js';
+import { StopsIndex } from '../../stops/stopsIndex.js';
+import { Route } from '../../timetable/route.js';
+import { Time } from '../../timetable/time.js';
+import { ServiceRoute, StopAdjacency } from '../../timetable/timetable.js';
+import { Plotter } from '../plotter.js';
+import { Query } from '../query.js';
+import { Result } from '../result.js';
+import { RoutingEdge } from '../router.js';
+
+describe('Plotter', () => {
+  const stop1: Stop = {
+    id: 0,
+    sourceStopId: 'stop1',
+    name: 'Lausanne',
+    children: [],
+    locationType: 'SIMPLE_STOP_OR_PLATFORM',
+  };
+
+  const stop2: Stop = {
+    id: 1,
+    sourceStopId: 'stop2',
+    name: 'Fribourg',
+    children: [],
+    locationType: 'SIMPLE_STOP_OR_PLATFORM',
+  };
+
+  const stopsAdjacency: StopAdjacency[] = [{ routes: [0] }, { routes: [0] }];
+
+  const routesAdjacency = [
+    Route.of({
+      id: 0,
+      serviceRouteId: 0,
+      trips: [
+        {
+          stops: [
+            {
+              id: 0,
+              arrivalTime: Time.fromString('08:00:00'),
+              departureTime: Time.fromString('08:05:00'),
+            },
+            {
+              id: 1,
+              arrivalTime: Time.fromString('08:30:00'),
+              departureTime: Time.fromString('08:35:00'),
+            },
+          ],
+        },
+      ],
+    }),
+  ];
+
+  const routes: ServiceRoute[] = [
+    {
+      type: 'RAIL',
+      name: 'IC 1',
+      routes: [0],
+    },
+  ];
+
+  const mockStopsIndex = new StopsIndex([stop1, stop2]);
+  const mockTimetable = new Timetable(stopsAdjacency, routesAdjacency, routes);
+  const mockQuery = new Query.Builder()
+    .from('stop1')
+    .to(new Set(['stop2']))
+    .departureTime(Time.fromHMS(8, 0, 0))
+    .build();
+
+  describe('plotDotGraph', () => {
+    it('should generate valid DOT graph structure', () => {
+      const result = new Result(
+        mockQuery,
+        {
+          earliestArrivals: new Map(),
+          graph: [],
+          destinations: [],
+        },
+        mockStopsIndex,
+        mockTimetable,
+      );
+
+      const plotter = new Plotter(result);
+      const dotGraph = plotter.plotDotGraph();
+
+      assert(dotGraph.includes('digraph RoutingGraph {'));
+      assert(dotGraph.includes('// Stations'));
+      assert(dotGraph.includes('// Edges'));
+      assert(dotGraph.endsWith('}'));
+    });
+
+    it('should include station nodes', () => {
+      const graph: Map<StopId, RoutingEdge>[] = [
+        new Map([[0, { arrival: Time.fromHMS(8, 0, 0) }]]),
+      ];
+
+      const result = new Result(
+        mockQuery,
+        {
+          earliestArrivals: new Map(),
+          graph,
+          destinations: [0],
+        },
+        mockStopsIndex,
+        mockTimetable,
+      );
+
+      const plotter = new Plotter(result);
+      const dotGraph = plotter.plotDotGraph();
+
+      assert(dotGraph.includes('"s_0"'));
+      assert(dotGraph.includes('Lausanne'));
+      assert(dotGraph.includes('shape=box'));
+    });
+
+    it('should handle empty graph gracefully', () => {
+      const result = new Result(
+        mockQuery,
+        {
+          earliestArrivals: new Map(),
+          graph: [],
+          destinations: [],
+        },
+        mockStopsIndex,
+        mockTimetable,
+      );
+
+      const plotter = new Plotter(result);
+      const dotGraph = plotter.plotDotGraph();
+
+      assert(dotGraph.includes('digraph RoutingGraph {'));
+      assert(dotGraph.endsWith('}'));
+    });
+
+    it('should escape special characters', () => {
+      const specialStop: Stop = {
+        id: 2,
+        sourceStopId: 'test"stop\\with\nlines\rand\ttabs',
+        name: 'Station "Test"\nWith\\Special\rChars\tAndTabs',
+        lat: 0,
+        lon: 0,
+        children: [],
+        parent: undefined,
+        locationType: 'SIMPLE_STOP_OR_PLATFORM',
+      };
+
+      const specialStopsIndex = new StopsIndex([stop1, stop2, specialStop]);
+      const graph: Map<StopId, RoutingEdge>[] = [
+        new Map([[2, { arrival: Time.fromHMS(8, 0, 0) }]]),
+      ];
+
+      const result = new Result(
+        mockQuery,
+        {
+          earliestArrivals: new Map(),
+          graph,
+          destinations: [2],
+        },
+        specialStopsIndex,
+        mockTimetable,
+      );
+
+      const plotter = new Plotter(result);
+      const dotGraph = plotter.plotDotGraph();
+
+      // Check that special characters are properly escaped in the station label
+      assert(
+        dotGraph.includes(
+          'Station \\"Test\\"\\nWith\\\\Special\\rChars\\tAndTabs\\n2',
+        ),
+        'Station name should have properly escaped special characters',
+      );
+    });
+
+    it('should use correct colors', () => {
+      const graph: Map<StopId, RoutingEdge>[] = [
+        new Map([[0, { arrival: Time.fromHMS(8, 0, 0) }]]),
+        new Map([
+          [
+            1,
+            {
+              from: 0,
+              to: 1,
+              arrival: Time.fromHMS(8, 30, 0),
+              routeId: 0,
+              tripIndex: 0,
+            },
+          ],
+        ]),
+        new Map([
+          [
+            1,
+            {
+              from: 0,
+              to: 1,
+              arrival: Time.fromHMS(8, 45, 0),
+              type: 'WALKING',
+              minTransferTime: Time.fromHMS(0, 5, 0),
+            },
+          ],
+        ]),
+      ];
+
+      const result = new Result(
+        mockQuery,
+        {
+          earliestArrivals: new Map(),
+          graph,
+          destinations: [1],
+        },
+        mockStopsIndex,
+        mockTimetable,
+      );
+
+      const plotter = new Plotter(result);
+      const dotGraph = plotter.plotDotGraph();
+      assert(
+        dotGraph.includes('color="#60a5fa"'),
+        'Round 1 should use blue color (#60a5fa)',
+      );
+      assert(
+        dotGraph.includes('color="#ff9800"'),
+        'Round 2 should use orange color (#ff9800)',
+      );
+    });
+  });
+});