minotor 5.0.1 → 7.0.0

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

@@ -5,9 +5,10 @@ import { describe, it } from 'node:test';
 import { StopId } from '../../stops/stops.js';
 import { REGULAR, Route } from '../../timetable/route.js';
 import { Time } from '../../timetable/time.js';
-import { ServiceRoutesMap } from '../../timetable/timetable.js';
+import { ServiceRoute } from '../../timetable/timetable.js';
+import { GtfsRoutesMap } from '../routes.js';
 import { ServiceIds } from '../services.js';
-import { ParsedStopsMap } from '../stops.js';
+import { GtfsStopsMap } from '../stops.js';
 import { TransfersMap } from '../transfers.js';
 import {
   buildStopsAdjacencyStructure,
@@ -25,21 +26,22 @@ describe('buildStopsAdjacencyStructure', () => {
         new Uint16Array(),
         new Uint8Array(),
         new Uint32Array([0, 1]),
-        'service1',
+        0,
       ),
     ];
     const transfersMap: TransfersMap = new Map([
       [0, [{ destination: 1, type: 'RECOMMENDED' }]],
     ]);
-    const serviceRoutes: ServiceRoutesMap = new Map([
-      ['service1', { type: 'BUS', name: 'B1', routes: [] }],
-    ]);
+    const serviceRoutes: ServiceRoute[] = [
+      { type: 'BUS', name: 'B1', routes: [] },
+    ];
 
     const stopsAdjacency = buildStopsAdjacencyStructure(
-      validStops,
       serviceRoutes,
       routesAdjacency,
       transfersMap,
+      2,
+      validStops,
     );
 
     assert.deepEqual(Array.from(stopsAdjacency.entries()), [
@@ -47,11 +49,23 @@ describe('buildStopsAdjacencyStructure', () => {
         0,
         {
           routes: [0],
+          transfers: [
+            {
+              destination: 1,
+              type: 'RECOMMENDED',
+            },
+          ],
+        },
+      ],
+      [
+        1,
+        {
+          routes: [],
           transfers: [],
         },
       ],
     ]);
-    assert.deepEqual(serviceRoutes.get('service1')?.routes, [0]);
+    assert.deepEqual(serviceRoutes[0]?.routes, [0]);
   });
 
   it('should ignore transfers to invalid stops', () => {
@@ -61,21 +75,22 @@ describe('buildStopsAdjacencyStructure', () => {
         new Uint16Array(),
         new Uint8Array(),
         new Uint32Array([0, 1]),
-        'service1',
+        0,
       ),
     ];
     const transfersMap: TransfersMap = new Map([
-      [0, [{ destination: 2, type: 'RECOMMENDED' }]],
-    ]);
-    const serviceRoutes: ServiceRoutesMap = new Map([
-      ['service1', { type: 'BUS', name: 'B1', routes: [] }],
+      [3, [{ destination: 2, type: 'RECOMMENDED' }]],
     ]);
+    const serviceRoutes: ServiceRoute[] = [
+      { type: 'BUS', name: 'B1', routes: [] },
+    ];
 
     const stopsAdjacency = buildStopsAdjacencyStructure(
-      validStops,
       serviceRoutes,
       routesAdjacency,
       transfersMap,
+      4,
+      validStops,
     );
 
     assert.deepEqual(Array.from(stopsAdjacency.entries()), [
@@ -93,8 +108,22 @@ describe('buildStopsAdjacencyStructure', () => {
           transfers: [],
         },
       ],
+      [
+        2,
+        {
+          routes: [],
+          transfers: [],
+        },
+      ],
+      [
+        3,
+        {
+          routes: [],
+          transfers: [],
+        },
+      ],
     ]);
-    assert.deepEqual(serviceRoutes.get('service1')?.routes, [0]);
+    assert.deepEqual(serviceRoutes[0]?.routes, [0]);
   });
 });
 describe('GTFS trips parser', () => {
@@ -106,9 +135,9 @@ describe('GTFS trips parser', () => {
     mockedStream.push(null);
 
     const validServiceIds: ServiceIds = new Set(['service1', 'service2']);
-    const validRouteIds: ServiceRoutesMap = new Map([
-      ['routeA', { type: 'BUS', name: 'B1', routes: [0] }],
-      ['routeB', { type: 'TRAM', name: 'T1', routes: [1] }],
+    const validRouteIds: GtfsRoutesMap = new Map([
+      ['routeA', { type: 'BUS', name: 'B1' }],
+      ['routeB', { type: 'TRAM', name: 'T1' }],
     ]);
 
     const trips = await parseTrips(
@@ -133,9 +162,9 @@ describe('GTFS trips parser', () => {
     mockedStream.push(null);
 
     const validServiceIds: ServiceIds = new Set(['service1', 'service2']);
-    const validRouteIds: ServiceRoutesMap = new Map([
-      ['routeA', { type: 'BUS', name: 'B1', routes: [0] }],
-      ['routeB', { type: 'TRAM', name: 'T1', routes: [1] }],
+    const validRouteIds: GtfsRoutesMap = new Map([
+      ['routeA', { type: 'BUS', name: 'B1' }],
+      ['routeB', { type: 'TRAM', name: 'T1' }],
     ]);
 
     const trips = await parseTrips(
@@ -154,9 +183,9 @@ describe('GTFS trips parser', () => {
     mockedStream.push(null);
 
     const validServiceIds: ServiceIds = new Set(['service1', 'service2']);
-    const validRouteIds: ServiceRoutesMap = new Map([
-      ['routeA', { type: 'BUS', name: 'B1', routes: [0] }],
-      ['routeB', { type: 'TRAM', name: 'T1', routes: [1] }],
+    const validRouteIds: GtfsRoutesMap = new Map([
+      ['routeA', { type: 'BUS', name: 'B1' }],
+      ['routeB', { type: 'TRAM', name: 'T1' }],
     ]);
 
     const trips = await parseTrips(
@@ -180,7 +209,7 @@ describe('GTFS stop times parser', () => {
 
     const validTripIds: TripIdsMap = new Map([['tripA', 'routeA']]);
     const validStopIds: Set<StopId> = new Set([0, 1]);
-    const stopsMap: ParsedStopsMap = new Map([
+    const stopsMap: GtfsStopsMap = new Map([
       [
         'stop1',
         {
@@ -206,13 +235,13 @@ describe('GTFS stop times parser', () => {
         },
       ],
     ]);
-    const routes = await parseStopTimes(
+    const result = await parseStopTimes(
       mockedStream,
       stopsMap,
       validTripIds,
       validStopIds,
     );
-    assert.deepEqual(routes, [
+    assert.deepEqual(result.routes, [
       new Route(
         new Uint16Array([
           Time.fromHMS(8, 0, 0).toMinutes(),
@@ -222,7 +251,7 @@ describe('GTFS stop times parser', () => {
         ]),
         encodePickUpDropOffTypes([REGULAR, REGULAR], [REGULAR, REGULAR]),
         new Uint32Array([0, 1]),
-        'routeA',
+        0,
       ),
     ]);
   });
@@ -243,7 +272,7 @@ describe('GTFS stop times parser', () => {
       ['tripB', 'routeA'],
     ]);
     const validStopIds: Set<StopId> = new Set([0, 1]);
-    const stopsMap: ParsedStopsMap = new Map([
+    const stopsMap: GtfsStopsMap = new Map([
       [
         'stop1',
         {
@@ -266,13 +295,13 @@ describe('GTFS stop times parser', () => {
       ],
     ]);
 
-    const routes = await parseStopTimes(
+    const result = await parseStopTimes(
       mockedStream,
       stopsMap,
       validTripIds,
       validStopIds,
     );
-    assert.deepEqual(routes, [
+    assert.deepEqual(result.routes, [
       new Route(
         new Uint16Array([
           Time.fromHMS(8, 0, 0).toMinutes(),
@@ -289,7 +318,7 @@ describe('GTFS stop times parser', () => {
           [REGULAR, REGULAR, REGULAR, REGULAR],
         ),
         new Uint32Array([0, 1]),
-        'routeA',
+        0,
       ),
     ]);
   });
@@ -310,7 +339,7 @@ describe('GTFS stop times parser', () => {
       ['tripB', 'routeA'],
     ]);
     const validStopIds: Set<StopId> = new Set([0, 1]);
-    const stopsMap: ParsedStopsMap = new Map([
+    const stopsMap: GtfsStopsMap = new Map([
       [
         'stop1',
         {
@@ -333,13 +362,13 @@ describe('GTFS stop times parser', () => {
       ],
     ]);
 
-    const routes = await parseStopTimes(
+    const result = await parseStopTimes(
       mockedStream,
       stopsMap,
       validTripIds,
       validStopIds,
     );
-    assert.deepEqual(routes, [
+    assert.deepEqual(result.routes, [
       new Route(
         new Uint16Array([
           Time.fromHMS(8, 0, 0).toMinutes(),
@@ -356,7 +385,7 @@ describe('GTFS stop times parser', () => {
           [REGULAR, REGULAR, REGULAR, REGULAR],
         ),
         new Uint32Array([0, 1]),
-        'routeA',
+        0,
       ),
     ]);
   });
@@ -376,7 +405,7 @@ describe('GTFS stop times parser', () => {
       ['tripB', 'routeA'],
     ]);
     const validStopIds: Set<StopId> = new Set([0, 1]);
-    const stopsMap: ParsedStopsMap = new Map([
+    const stopsMap: GtfsStopsMap = new Map([
       [
         'stop1',
         {
@@ -399,13 +428,13 @@ describe('GTFS stop times parser', () => {
       ],
     ]);
 
-    const routes = await parseStopTimes(
+    const result = await parseStopTimes(
       mockedStream,
       stopsMap,
       validTripIds,
       validStopIds,
     );
-    assert.deepEqual(routes, [
+    assert.deepEqual(result.routes, [
       new Route(
         new Uint16Array([
           Time.fromHMS(8, 0, 0).toMinutes(),
@@ -415,7 +444,7 @@ describe('GTFS stop times parser', () => {
         ]),
         encodePickUpDropOffTypes([REGULAR, REGULAR], [REGULAR, REGULAR]),
         new Uint32Array([0, 1]),
-        'routeA',
+        0,
       ),
       new Route(
         new Uint16Array([
@@ -424,7 +453,7 @@ describe('GTFS stop times parser', () => {
         ]),
         encodePickUpDropOffTypes([REGULAR], [REGULAR]),
         new Uint32Array([0]),
-        'routeA',
+        0,
       ),
     ]);
   });
@@ -440,7 +469,7 @@ describe('GTFS stop times parser', () => {
 
     const validTripIds: TripIdsMap = new Map([['tripA', 'routeA']]);
     const validStopIds: Set<StopId> = new Set([0, 1]);
-    const stopsMap: ParsedStopsMap = new Map([
+    const stopsMap: GtfsStopsMap = new Map([
       [
         'stop1',
         {
@@ -463,13 +492,13 @@ describe('GTFS stop times parser', () => {
       ],
     ]);
 
-    const routes = await parseStopTimes(
+    const result = await parseStopTimes(
       mockedStream,
       stopsMap,
       validTripIds,
       validStopIds,
     );
-    assert.deepEqual(routes, [
+    assert.deepEqual(result.routes, [
       new Route(
         new Uint16Array([
           Time.fromHMS(8, 0, 0).toMinutes(),
@@ -477,7 +506,7 @@ describe('GTFS stop times parser', () => {
         ]),
         encodePickUpDropOffTypes([REGULAR], [REGULAR]),
         new Uint32Array([0]),
-        'routeA',
+        0,
       ),
     ]);
   });

package/src/gtfs/parser.ts

@@ -6,9 +6,9 @@ import { StopId } from '../stops/stops.js';
 import { StopsIndex } from '../stops/stopsIndex.js';
 import { RouteType, Timetable } from '../timetable/timetable.js';
 import { standardProfile } from './profiles/standard.js';
-import { parseRoutes } from './routes.js';
+import { indexRoutes, parseRoutes } from './routes.js';
 import { parseCalendar, parseCalendarDates, ServiceIds } from './services.js';
-import { indexStops, parseStops } from './stops.js';
+import { parseStops } from './stops.js';
 import { parseTransfers, TransfersMap } from './transfers.js';
 import {
   buildStopsAdjacencyStructure,
@@ -43,20 +43,16 @@ export class GtfsParser {
    * Parses a GTFS feed to extract all the data relevant to a given day in a transit-planner friendly format.
    *
    * @param date The active date.
-   * @param gtfsPath A path to the zipped GTFS feed.
-   * @param gtfsProfile The GTFS profile configuration.
-   * @returns An object containing the timetable and stops map.
+   * @returns The parsed timetable.
    */
-  async parse(
-    date: Date,
-  ): Promise<{ timetable: Timetable; stopsIndex: StopsIndex }> {
+  async parseTimetable(date: Date): Promise<Timetable> {
     log.setLevel('INFO');
     const zip = new StreamZip.async({ file: this.path });
     const entries = await zip.entries();
     const datetime = DateTime.fromJSDate(date);
 
-    const validServiceIds: ServiceIds = new Set();
-    const validStopIds = new Set<StopId>();
+    const activeServiceIds: ServiceIds = new Set();
+    const activeStopIds = new Set<StopId>();
 
     log.info(`Parsing ${STOPS_FILE}`);
     const stopsStart = performance.now();
@@ -71,10 +67,10 @@ export class GtfsParser {
       log.info(`Parsing ${CALENDAR_FILE}`);
       const calendarStart = performance.now();
       const calendarStream = await zip.stream(CALENDAR_FILE);
-      await parseCalendar(calendarStream, validServiceIds, datetime);
+      await parseCalendar(calendarStream, activeServiceIds, datetime);
       const calendarEnd = performance.now();
       log.info(
-        `${validServiceIds.size} valid services. (${(calendarEnd - calendarStart).toFixed(2)}ms)`,
+        `${activeServiceIds.size} valid services. (${(calendarEnd - calendarStart).toFixed(2)}ms)`,
       );
     }
 
@@ -82,10 +78,10 @@ export class GtfsParser {
       log.info(`Parsing ${CALENDAR_DATES_FILE}`);
       const calendarDatesStart = performance.now();
       const calendarDatesStream = await zip.stream(CALENDAR_DATES_FILE);
-      await parseCalendarDates(calendarDatesStream, validServiceIds, datetime);
+      await parseCalendarDates(calendarDatesStream, activeServiceIds, datetime);
       const calendarDatesEnd = performance.now();
       log.info(
-        `${validServiceIds.size} valid services. (${(calendarDatesEnd - calendarDatesStart).toFixed(2)}ms)`,
+        `${activeServiceIds.size} valid services. (${(calendarDatesEnd - calendarDatesStart).toFixed(2)}ms)`,
       );
     }
 
@@ -103,7 +99,7 @@ export class GtfsParser {
     const tripsStream = await zip.stream(TRIPS_FILE);
     const trips = await parseTrips(
       tripsStream,
-      validServiceIds,
+      activeServiceIds,
       validGtfsRoutes,
     );
     const tripsEnd = performance.now();
@@ -126,57 +122,44 @@ export class GtfsParser {
     log.info(`Parsing ${STOP_TIMES_FILE}`);
     const stopTimesStart = performance.now();
     const stopTimesStream = await zip.stream(STOP_TIMES_FILE);
-    const routesAdjacency = await parseStopTimes(
+    const { routes, serviceRoutesMap } = await parseStopTimes(
       stopTimesStream,
       parsedStops,
       trips,
-      validStopIds,
-    );
-    const stopsAdjacency = buildStopsAdjacencyStructure(
-      validStopIds,
-      validGtfsRoutes,
-      routesAdjacency,
-      transfers,
+      activeStopIds,
     );
+    const serviceRoutes = indexRoutes(validGtfsRoutes, serviceRoutesMap);
     const stopTimesEnd = performance.now();
     log.info(
-      `${routesAdjacency.length} valid unique routes. (${(stopTimesEnd - stopTimesStart).toFixed(2)}ms)`,
+      `${routes.length} valid unique routes. (${(stopTimesEnd - stopTimesStart).toFixed(2)}ms)`,
+    );
+    log.info('Building stops adjacency structure');
+    const stopsAdjacencyStart = performance.now();
+    const stopsAdjacency = buildStopsAdjacencyStructure(
+      serviceRoutes,
+      routes,
+      transfers,
+      parsedStops.size,
+      activeStopIds,
     );
 
-    log.info(`Removing unused stops.`);
-    const indexStopsStart = performance.now();
-    const stops = indexStops(parsedStops, validStopIds);
-    const indexStopsEnd = performance.now();
+    const stopsAdjacencyEnd = performance.now();
     log.info(
-      `${stops.size} used stop stops, ${parsedStops.size - stops.size} unused. (${(indexStopsEnd - indexStopsStart).toFixed(2)}ms)`,
+      `${stopsAdjacency.length} valid stops in the structure. (${(stopsAdjacencyEnd - stopsAdjacencyStart).toFixed(2)}ms)`,
     );
-
     await zip.close();
 
-    const timetable = new Timetable(
-      stopsAdjacency,
-      routesAdjacency,
-      validGtfsRoutes,
-    );
-
-    log.info(`Building stops index.`);
-    const stopsIndexStart = performance.now();
-    const stopsIndex = new StopsIndex(stops);
-    const stopsIndexEnd = performance.now();
-    log.info(
-      `Stops index built. (${(stopsIndexEnd - stopsIndexStart).toFixed(2)}ms)`,
-    );
+    const timetable = new Timetable(stopsAdjacency, routes, serviceRoutes);
 
     log.info('Parsing complete.');
-    return { timetable, stopsIndex };
+    return timetable;
   }
 
   /**
    * Parses a GTFS feed to extract all stops.
    *
-   * @param gtfsPath A path the zipped GTFS feed.
-   * @param gtfsProfile The GTFS profile configuration.
-   * @returns An object containing the timetable and stops map.
+   * @param activeStops The set of active stop IDs to include in the index.
+   * @returns An index of stops.
    */
   async parseStops(): Promise<StopsIndex> {
     const zip = new StreamZip.async({ file: this.path });
@@ -184,7 +167,7 @@ export class GtfsParser {
     log.info(`Parsing ${STOPS_FILE}`);
     const stopsStart = performance.now();
     const stopsStream = await zip.stream(STOPS_FILE);
-    const stops = indexStops(await parseStops(stopsStream));
+    const stops = await parseStops(stopsStream);
     const stopsEnd = performance.now();
 
     log.info(
@@ -193,6 +176,6 @@ export class GtfsParser {
 
     await zip.close();
 
-    return new StopsIndex(stops);
+    return new StopsIndex(Array.from(stops.values()));
   }
 }

package/src/gtfs/routes.ts

@@ -1,6 +1,7 @@
 import log from 'loglevel';
 
-import { ServiceRouteId, ServiceRoutesMap } from '../timetable/timetable.js';
+import { RouteType } from '../router.js';
+import { ServiceRoute, ServiceRouteId } from '../timetable/timetable.js';
 import { GtfsProfile } from './parser.js';
 import { standardProfile } from './profiles/standard.js';
 import { parseCsv } from './utils.js';
@@ -8,9 +9,18 @@ import { parseCsv } from './utils.js';
 // Can be a standard gtfs route type or an extended route type
 // the profile converter handles the conversion to a route type.
 export type GtfsRouteType = number;
+export type GtfsRouteId = string;
+
+export type GtfsRoutesMap = Map<
+  GtfsRouteId,
+  {
+    name: string;
+    type: RouteType;
+  }
+>;
 
 type RouteEntry = {
-  route_id: ServiceRouteId;
+  route_id: GtfsRouteId;
   agency_id: string;
   route_short_name: string;
   route_long_name: string;
@@ -28,8 +38,8 @@ type RouteEntry = {
 export const parseRoutes = async (
   routesStream: NodeJS.ReadableStream,
   profile: GtfsProfile = standardProfile,
-): Promise<ServiceRoutesMap> => {
-  const routes: ServiceRoutesMap = new Map();
+): Promise<GtfsRoutesMap> => {
+  const routes: GtfsRoutesMap = new Map();
   for await (const rawLine of parseCsv(routesStream, ['route_type'])) {
     const line = rawLine as RouteEntry;
     const routeType = profile.routeTypeParser(line.route_type);
@@ -42,8 +52,36 @@ export const parseRoutes = async (
     routes.set(line.route_id, {
       name: line.route_short_name,
       type: routeType,
-      routes: [],
     });
   }
   return routes;
 };
+
+/**
+ * Creates an array of ServiceRoute objects by combining GTFS route data with service route mappings.
+ *
+ * @param gtfsRoutesMap A map containing GTFS route information indexed by route ID
+ * @param serviceRoutesMap A map linking GTFS route IDs to service route IDs
+ * @returns An array of ServiceRoute objects with route information
+ */
+export const indexRoutes = (
+  gtfsRoutesMap: GtfsRoutesMap,
+  serviceRoutesMap: Map<GtfsRouteId, ServiceRouteId>,
+): ServiceRoute[] => {
+  const serviceRoutes: ServiceRoute[] = new Array<ServiceRoute>(
+    serviceRoutesMap.size,
+  );
+  for (const [gtfsRouteId, serviceRouteId] of serviceRoutesMap) {
+    const route = gtfsRoutesMap.get(gtfsRouteId);
+    if (route === undefined) {
+      log.warn(`Route ${gtfsRouteId} not found.`);
+      continue;
+    }
+    serviceRoutes[serviceRouteId] = {
+      name: route.name,
+      type: route.type,
+      routes: [],
+    };
+  }
+  return serviceRoutes;
+};

package/src/gtfs/stops.ts

@@ -5,8 +5,6 @@ import {
   Platform,
   SourceStopId,
   Stop,
-  StopId,
-  StopsMap,
 } from '../stops/stops.js';
 import { parseCsv } from './utils.js';
 
@@ -31,7 +29,7 @@ type ParsedStop = Stop & {
   parentSourceId?: SourceStopId;
 };
 
-export type ParsedStopsMap = Map<SourceStopId, ParsedStop>;
+export type GtfsStopsMap = Map<SourceStopId, ParsedStop>;
 /**
  * Parses the stops.txt file from a GTFS feed.
  *
@@ -40,7 +38,7 @@ export type ParsedStopsMap = Map<SourceStopId, ParsedStop>;
  */
 export const parseStops = async (
   stopsStream: NodeJS.ReadableStream,
-): Promise<ParsedStopsMap> => {
+): Promise<GtfsStopsMap> => {
   const parsedStops = new Map<SourceStopId, ParsedStop>();
   let i = 0;
   for await (const rawLine of parseCsv(stopsStream, [
@@ -82,46 +80,6 @@ export const parseStops = async (
   return parsedStops;
 };
 
-/**
- * Builds the final stop map indexed by internal IDs.
- * Excludes all stops that do not have at least one valid stopId
- * as a child, a parent, or being valid itself.
- *
- * @param parsedStops - The map of parsed stops.
- * @param validStops - A set of valid stop IDs.
- * @returns A map of stops indexed by internal IDs.
- */
-export const indexStops = (
-  parsedStops: ParsedStopsMap,
-  validStops?: Set<StopId>,
-): StopsMap => {
-  const stops = new Map<StopId, Stop>();
-
-  for (const [, stop] of parsedStops) {
-    if (
-      !validStops ||
-      validStops.has(stop.id) ||
-      (stop.parent && validStops.has(stop.parent)) ||
-      stop.children.some((childId) => validStops.has(childId))
-    ) {
-      stops.set(stop.id, {
-        id: stop.id,
-        sourceStopId: stop.sourceStopId,
-        name: stop.name,
-        lat: stop.lat,
-        lon: stop.lon,
-        locationType: stop.locationType,
-        platform: stop.platform,
-        children: stop.children.filter(
-          (childId) => !validStops || validStops.has(childId),
-        ),
-        parent: stop.parent,
-      });
-    }
-  }
-  return stops;
-};
-
 const parseGtfsLocationType = (
   gtfsLocationType: GtfsLocationType,
 ): LocationType => {

package/src/gtfs/transfers.ts

@@ -5,7 +5,7 @@ import {
   Transfer,
   TransferType,
 } from '../timetable/timetable.js';
-import { ParsedStopsMap } from './stops.js';
+import { GtfsStopsMap } from './stops.js';
 import { TripId } from './trips.js';
 import { parseCsv } from './utils.js';
 
@@ -38,7 +38,7 @@ export type TransferEntry = {
  */
 export const parseTransfers = async (
   transfersStream: NodeJS.ReadableStream,
-  stopsMap: ParsedStopsMap,
+  stopsMap: GtfsStopsMap,
 ): Promise<TransfersMap> => {
   const transfers: TransfersMap = new Map();