minotor 7.0.2 → 9.0.0

package/src/gtfs/__tests__/trips.test.ts

@@ -13,32 +13,47 @@ import { TransfersMap } from '../transfers.js';
 import {
   buildStopsAdjacencyStructure,
   encodePickUpDropOffTypes,
+  GtfsTripIdsMap,
   parseStopTimes,
   parseTrips,
-  TripIdsMap,
 } from '../trips.js';
 
 describe('buildStopsAdjacencyStructure', () => {
   it('should correctly build stops adjacency for valid routes and transfers', () => {
     const validStops: Set<StopId> = new Set([0]);
-    const routesAdjacency = [
-      new Route(
-        new Uint16Array(),
-        new Uint8Array(),
-        new Uint32Array([0, 1]),
-        0,
-      ),
+    const routes = [
+      Route.of({
+        id: 0,
+        serviceRouteId: 0,
+        trips: [
+          {
+            stops: [
+              {
+                id: 0,
+                arrivalTime: Time.fromHMS(8, 0, 0),
+                departureTime: Time.fromHMS(8, 0, 0),
+              },
+              {
+                id: 1,
+                arrivalTime: Time.fromHMS(8, 5, 0),
+                departureTime: Time.fromHMS(8, 5, 0),
+              },
+            ],
+          },
+        ],
+      }),
     ];
     const transfersMap: TransfersMap = new Map([
       [0, [{ destination: 1, type: 'RECOMMENDED' }]],
     ]);
+
     const serviceRoutes: ServiceRoute[] = [
       { type: 'BUS', name: 'B1', routes: [] },
     ];
 
     const stopsAdjacency = buildStopsAdjacencyStructure(
       serviceRoutes,
-      routesAdjacency,
+      routes,
       transfersMap,
       2,
       validStops,
@@ -61,7 +76,6 @@ describe('buildStopsAdjacencyStructure', () => {
         1,
         {
           routes: [],
-          transfers: [],
         },
       ],
     ]);
@@ -70,13 +84,27 @@ describe('buildStopsAdjacencyStructure', () => {
 
   it('should ignore transfers to invalid stops', () => {
     const validStops: Set<StopId> = new Set([0, 1]);
-    const routesAdjacency = [
-      new Route(
-        new Uint16Array(),
-        new Uint8Array(),
-        new Uint32Array([0, 1]),
-        0,
-      ),
+    const routes = [
+      Route.of({
+        id: 0,
+        serviceRouteId: 0,
+        trips: [
+          {
+            stops: [
+              {
+                id: 0,
+                arrivalTime: Time.fromHMS(8, 0, 0),
+                departureTime: Time.fromHMS(8, 0, 0),
+              },
+              {
+                id: 1,
+                arrivalTime: Time.fromHMS(8, 5, 0),
+                departureTime: Time.fromHMS(8, 5, 0),
+              },
+            ],
+          },
+        ],
+      }),
     ];
     const transfersMap: TransfersMap = new Map([
       [3, [{ destination: 2, type: 'RECOMMENDED' }]],
@@ -87,7 +115,7 @@ describe('buildStopsAdjacencyStructure', () => {
 
     const stopsAdjacency = buildStopsAdjacencyStructure(
       serviceRoutes,
-      routesAdjacency,
+      routes,
       transfersMap,
       4,
       validStops,
@@ -98,33 +126,194 @@ describe('buildStopsAdjacencyStructure', () => {
         0,
         {
           routes: [0],
-          transfers: [],
         },
       ],
       [
         1,
         {
           routes: [0],
-          transfers: [],
         },
       ],
       [
         2,
         {
           routes: [],
-          transfers: [],
         },
       ],
       [
         3,
         {
           routes: [],
-          transfers: [],
         },
       ],
     ]);
     assert.deepEqual(serviceRoutes[0]?.routes, [0]);
   });
+
+  it('should correctly handle trip continuations', () => {
+    const validStops: Set<StopId> = new Set([0, 1]);
+    const routes = [
+      Route.of({
+        id: 0,
+        serviceRouteId: 0,
+        trips: [
+          {
+            stops: [
+              {
+                id: 0,
+                arrivalTime: Time.fromHMS(8, 0, 0),
+                departureTime: Time.fromHMS(8, 0, 0),
+              },
+            ],
+          },
+        ],
+      }),
+      Route.of({
+        id: 1,
+        serviceRouteId: 0,
+        trips: [
+          {
+            stops: [
+              {
+                id: 1,
+                arrivalTime: Time.fromHMS(8, 30, 0),
+                departureTime: Time.fromHMS(8, 30, 0),
+              },
+            ],
+          },
+        ],
+      }),
+    ];
+    const transfersMap: TransfersMap = new Map();
+    const serviceRoutes: ServiceRoute[] = [
+      { type: 'BUS', name: 'B1', routes: [] },
+    ];
+
+    const stopsAdjacency = buildStopsAdjacencyStructure(
+      serviceRoutes,
+      routes,
+      transfersMap,
+      2,
+      validStops,
+    );
+
+    assert.deepEqual(Array.from(stopsAdjacency.entries()), [
+      [
+        0,
+        {
+          routes: [0],
+        },
+      ],
+      [
+        1,
+        {
+          routes: [1],
+        },
+      ],
+    ]);
+  });
+
+  it('should ignore trip continuations with invalid trip IDs', () => {
+    const validStops: Set<StopId> = new Set([0]);
+    const routes = [
+      Route.of({
+        id: 0,
+        serviceRouteId: 0,
+        trips: [
+          {
+            stops: [
+              {
+                id: 0,
+                arrivalTime: Time.fromHMS(8, 0, 0),
+                departureTime: Time.fromHMS(8, 0, 0),
+              },
+            ],
+          },
+        ],
+      }),
+    ];
+    const transfersMap: TransfersMap = new Map();
+    const serviceRoutes: ServiceRoute[] = [
+      { type: 'BUS', name: 'B1', routes: [] },
+    ];
+
+    const stopsAdjacency = buildStopsAdjacencyStructure(
+      serviceRoutes,
+      routes,
+      transfersMap,
+      1,
+      validStops,
+    );
+
+    assert.deepEqual(Array.from(stopsAdjacency.entries()), [
+      [
+        0,
+        {
+          routes: [0],
+        },
+      ],
+    ]);
+  });
+
+  it('should ignore trip continuations for inactive stops', () => {
+    const validStops: Set<StopId> = new Set([0]); // Only stop 0 is active
+    const routes = [
+      Route.of({
+        id: 0,
+        serviceRouteId: 0,
+        trips: [
+          {
+            stops: [
+              {
+                id: 0,
+                arrivalTime: Time.fromHMS(8, 0, 0),
+                departureTime: Time.fromHMS(8, 0, 0),
+              },
+            ],
+          },
+        ],
+      }),
+    ];
+    const transfersMap: TransfersMap = new Map();
+    const serviceRoutes: ServiceRoute[] = [
+      { type: 'BUS', name: 'B1', routes: [] },
+    ];
+
+    const stopsAdjacency = buildStopsAdjacencyStructure(
+      serviceRoutes,
+      routes,
+      transfersMap,
+      4,
+      validStops,
+    );
+
+    assert.deepEqual(Array.from(stopsAdjacency.entries()), [
+      [
+        0,
+        {
+          routes: [0],
+        },
+      ],
+      [
+        1,
+        {
+          routes: [],
+        },
+      ],
+      [
+        2,
+        {
+          routes: [],
+        },
+      ],
+      [
+        3,
+        {
+          routes: [],
+        },
+      ],
+    ]);
+  });
 });
 describe('GTFS trips parser', () => {
   it('should correctly parse valid trips', async () => {
@@ -207,7 +396,7 @@ describe('GTFS stop times parser', () => {
     mockedStream.push('"tripA","08:10:00","08:15:00","stop2","2","0","0"\n');
     mockedStream.push(null);
 
-    const validTripIds: TripIdsMap = new Map([['tripA', 'routeA']]);
+    const validTripIds: GtfsTripIdsMap = new Map([['tripA', 'routeA']]);
     const validStopIds: Set<StopId> = new Set([0, 1]);
     const stopsMap: GtfsStopsMap = new Map([
       [
@@ -243,6 +432,7 @@ describe('GTFS stop times parser', () => {
     );
     assert.deepEqual(result.routes, [
       new Route(
+        0,
         new Uint16Array([
           Time.fromHMS(8, 0, 0).toMinutes(),
           Time.fromHMS(8, 5, 0).toMinutes(),
@@ -254,6 +444,10 @@ describe('GTFS stop times parser', () => {
         0,
       ),
     ]);
+    assert.deepEqual(
+      result.tripsMapping,
+      new Map([['tripA', { routeId: 0, tripRouteIndex: 0 }]]),
+    );
   });
 
   it('should create same route for same GTFS route with same stops', async () => {
@@ -267,7 +461,7 @@ describe('GTFS stop times parser', () => {
     mockedStream.push('"tripB","09:10:00","09:15:00","stop2","2","0","0"\n');
     mockedStream.push(null);
 
-    const validTripIds: TripIdsMap = new Map([
+    const validTripIds: GtfsTripIdsMap = new Map([
       ['tripA', 'routeA'],
       ['tripB', 'routeA'],
     ]);
@@ -303,6 +497,7 @@ describe('GTFS stop times parser', () => {
     );
     assert.deepEqual(result.routes, [
       new Route(
+        0,
         new Uint16Array([
           Time.fromHMS(8, 0, 0).toMinutes(),
           Time.fromHMS(8, 5, 0).toMinutes(),
@@ -321,6 +516,13 @@ describe('GTFS stop times parser', () => {
         0,
       ),
     ]);
+    assert.deepEqual(
+      result.tripsMapping,
+      new Map([
+        ['tripA', { routeId: 0, tripRouteIndex: 0 }],
+        ['tripB', { routeId: 0, tripRouteIndex: 1 }],
+      ]),
+    );
   });
 
   it('should support unsorted trips within a route', async () => {
@@ -334,7 +536,7 @@ describe('GTFS stop times parser', () => {
     mockedStream.push('"tripA","08:10:00","08:15:00","stop2","2","0","0"\n');
     mockedStream.push(null);
 
-    const validTripIds: TripIdsMap = new Map([
+    const validTripIds: GtfsTripIdsMap = new Map([
       ['tripA', 'routeA'],
       ['tripB', 'routeA'],
     ]);
@@ -370,6 +572,7 @@ describe('GTFS stop times parser', () => {
     );
     assert.deepEqual(result.routes, [
       new Route(
+        0,
         new Uint16Array([
           Time.fromHMS(8, 0, 0).toMinutes(),
           Time.fromHMS(8, 5, 0).toMinutes(),
@@ -400,7 +603,7 @@ describe('GTFS stop times parser', () => {
     mockedStream.push('"tripB","09:00:00","09:15:00","stop1","1","0","0"\n');
     mockedStream.push(null);
 
-    const validTripIds: TripIdsMap = new Map([
+    const validTripIds: GtfsTripIdsMap = new Map([
       ['tripA', 'routeA'],
       ['tripB', 'routeA'],
     ]);
@@ -436,6 +639,7 @@ describe('GTFS stop times parser', () => {
     );
     assert.deepEqual(result.routes, [
       new Route(
+        0,
         new Uint16Array([
           Time.fromHMS(8, 0, 0).toMinutes(),
           Time.fromHMS(8, 5, 0).toMinutes(),
@@ -447,6 +651,7 @@ describe('GTFS stop times parser', () => {
         0,
       ),
       new Route(
+        1,
         new Uint16Array([
           Time.fromHMS(9, 0, 0).toMinutes(),
           Time.fromHMS(9, 15, 0).toMinutes(),
@@ -467,7 +672,7 @@ describe('GTFS stop times parser', () => {
     mockedStream.push('"tripA","08:10:00","08:15:00","stop2","1","0","0"\n');
     mockedStream.push(null);
 
-    const validTripIds: TripIdsMap = new Map([['tripA', 'routeA']]);
+    const validTripIds: GtfsTripIdsMap = new Map([['tripA', 'routeA']]);
     const validStopIds: Set<StopId> = new Set([0, 1]);
     const stopsMap: GtfsStopsMap = new Map([
       [
@@ -500,6 +705,7 @@ describe('GTFS stop times parser', () => {
     );
     assert.deepEqual(result.routes, [
       new Route(
+        0,
         new Uint16Array([
           Time.fromHMS(8, 0, 0).toMinutes(),
           Time.fromHMS(8, 5, 0).toMinutes(),
@@ -509,5 +715,80 @@ describe('GTFS stop times parser', () => {
         0,
       ),
     ]);
+    assert.deepEqual(
+      result.tripsMapping,
+      new Map([['tripA', { routeId: 0, tripRouteIndex: 0 }]]),
+    );
+  });
+
+  it('should create trip continuations mapping correctly', async () => {
+    const mockedStream = new Readable();
+    mockedStream.push(
+      'trip_id,arrival_time,departure_time,stop_id,stop_sequence,pickup_type,drop_off_type\n',
+    );
+    mockedStream.push('"trip1","08:00:00","08:05:00","stop1","1","0","0"\n');
+    mockedStream.push('"trip1","08:10:00","08:15:00","stop2","2","0","0"\n');
+    mockedStream.push('"trip2","09:00:00","09:05:00","stop3","1","0","0"\n');
+    mockedStream.push(null);
+
+    const validTripIds: GtfsTripIdsMap = new Map([
+      ['trip1', 'routeA'],
+      ['trip2', 'routeB'],
+    ]);
+    const validStopIds: Set<StopId> = new Set([0, 1, 2]);
+    const stopsMap: GtfsStopsMap = new Map([
+      [
+        'stop1',
+        {
+          id: 0,
+          sourceStopId: 'stop1',
+          name: 'Stop 1',
+          children: [],
+          locationType: 'SIMPLE_STOP_OR_PLATFORM',
+        },
+      ],
+      [
+        'stop2',
+        {
+          id: 1,
+          sourceStopId: 'stop2',
+          name: 'Stop 2',
+          children: [],
+          locationType: 'SIMPLE_STOP_OR_PLATFORM',
+        },
+      ],
+      [
+        'stop3',
+        {
+          id: 2,
+          sourceStopId: 'stop3',
+          name: 'Stop 3',
+          children: [],
+          locationType: 'SIMPLE_STOP_OR_PLATFORM',
+        },
+      ],
+    ]);
+
+    const result = await parseStopTimes(
+      mockedStream,
+      stopsMap,
+      validTripIds,
+      validStopIds,
+    );
+
+    assert.deepEqual(
+      result.tripsMapping,
+      new Map([
+        ['trip1', { routeId: 0, tripRouteIndex: 0 }],
+        ['trip2', { routeId: 1, tripRouteIndex: 0 }],
+      ]),
+    );
+    assert.deepEqual(
+      result.serviceRoutesMap,
+      new Map([
+        ['routeA', 0],
+        ['routeB', 1],
+      ]),
+    );
   });
 });

package/src/gtfs/parser.ts

@@ -9,7 +9,12 @@ import { standardProfile } from './profiles/standard.js';
 import { indexRoutes, parseRoutes } from './routes.js';
 import { parseCalendar, parseCalendarDates, ServiceIds } from './services.js';
 import { parseStops } from './stops.js';
-import { parseTransfers, TransfersMap } from './transfers.js';
+import {
+  buildTripContinuations,
+  GtfsTripContinuation,
+  parseTransfers,
+  TransfersMap,
+} from './transfers.js';
 import {
   buildStopsAdjacencyStructure,
   parseStopTimes,
@@ -107,22 +112,28 @@ export class GtfsParser {
       `${trips.size} valid trips. (${(tripsEnd - tripsStart).toFixed(2)}ms)`,
     );
 
-    let transfers = new Map() as TransfersMap;
+    let transfers: TransfersMap = new Map();
+    let tripContinuationsMap: GtfsTripContinuation[] = [];
     if (entries[TRANSFERS_FILE]) {
       log.info(`Parsing ${TRANSFERS_FILE}`);
       const transfersStart = performance.now();
       const transfersStream = await zip.stream(TRANSFERS_FILE);
-      transfers = await parseTransfers(transfersStream, parsedStops);
+      const {
+        transfers: parsedTransfers,
+        tripContinuations: parsedTripContinuations,
+      } = await parseTransfers(transfersStream, parsedStops);
+      transfers = parsedTransfers;
+      tripContinuationsMap = parsedTripContinuations;
       const transfersEnd = performance.now();
       log.info(
-        `${transfers.size} valid transfers. (${(transfersEnd - transfersStart).toFixed(2)}ms)`,
+        `${transfers.size} valid transfers and ${tripContinuationsMap.length} trip continuations. (${(transfersEnd - transfersStart).toFixed(2)}ms)`,
       );
     }
 
     log.info(`Parsing ${STOP_TIMES_FILE}`);
     const stopTimesStart = performance.now();
     const stopTimesStream = await zip.stream(STOP_TIMES_FILE);
-    const { routes, serviceRoutesMap } = await parseStopTimes(
+    const { routes, serviceRoutesMap, tripsMapping } = await parseStopTimes(
       stopTimesStream,
       parsedStops,
       trips,
@@ -149,10 +160,29 @@ export class GtfsParser {
     );
     await zip.close();
 
+    // temporary timetable for building continuations
     const timetable = new Timetable(stopsAdjacency, routes, serviceRoutes);
 
+    log.info('Building in-seat trip continuations');
+    const tripContinuationsStart = performance.now();
+    const tripContinuations = buildTripContinuations(
+      tripsMapping,
+      tripContinuationsMap,
+      timetable,
+      activeStopIds,
+    );
+    const tripContinuationsEnd = performance.now();
+    log.info(
+      `${tripContinuations.size} in-seat trip continuations origins created. (${(tripContinuationsEnd - tripContinuationsStart).toFixed(2)}ms)`,
+    );
     log.info('Parsing complete.');
-    return timetable;
+
+    return new Timetable(
+      stopsAdjacency,
+      routes,
+      serviceRoutes,
+      tripContinuations,
+    );
   }
 
   /**