minotor 3.0.1 → 3.0.2

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

@@ -3,6 +3,7 @@ import { Readable } from 'node:stream';
 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 {
   RoutesAdjacency,
@@ -24,16 +25,12 @@ describe('buildStopsAdjacencyStructure', () => {
     const routesAdjacency: RoutesAdjacency = new Map([
       [
         'routeA',
-        {
-          serviceRouteId: 'service1',
-          stops: new Uint32Array([0, 1]),
-          stopIndices: new Map([
-            [0, 0],
-            [1, 1],
-          ]),
-          stopTimes: new Uint16Array(),
-          pickUpDropOffTypes: new Uint8Array(),
-        },
+        new Route(
+          new Uint16Array(),
+          new Uint8Array(),
+          new Uint32Array([0, 1]),
+          'service1',
+        ),
       ],
     ]);
     const transfersMap: TransfersMap = new Map([
@@ -62,16 +59,12 @@ describe('buildStopsAdjacencyStructure', () => {
     const routesAdjacency: RoutesAdjacency = new Map([
       [
         'routeA',
-        {
-          serviceRouteId: 'service1',
-          stops: new Uint32Array([0, 1]),
-          stopIndices: new Map([
-            [0, 0],
-            [1, 1],
-          ]),
-          stopTimes: new Uint16Array(),
-          pickUpDropOffTypes: new Uint8Array(),
-        },
+        new Route(
+          new Uint16Array(),
+          new Uint8Array(),
+          new Uint32Array([0, 1]),
+          'service1',
+        ),
       ],
     ]);
     const transfersMap: TransfersMap = new Map([
@@ -222,21 +215,17 @@ describe('GTFS stop times parser', () => {
       new Map([
         [
           'routeA_1',
-          {
-            serviceRouteId: 'routeA',
-            stops: new Uint32Array([0, 1]),
-            stopIndices: new Map([
-              [0, 0],
-              [1, 1],
-            ]),
-            stopTimes: new Uint16Array([
+          new Route(
+            new Uint16Array([
               Time.fromHMS(8, 0, 0).toMinutes(),
               Time.fromHMS(8, 5, 0).toMinutes(),
               Time.fromHMS(8, 10, 0).toMinutes(),
               Time.fromHMS(8, 15, 0).toMinutes(),
             ]),
-            pickUpDropOffTypes: new Uint8Array([0, 0, 0, 0]),
-          },
+            new Uint8Array([REGULAR, REGULAR, REGULAR, REGULAR]),
+            new Uint32Array([0, 1]),
+            'routeA',
+          ),
         ],
       ]),
     );
@@ -292,14 +281,8 @@ describe('GTFS stop times parser', () => {
       new Map([
         [
           'routeA_1',
-          {
-            serviceRouteId: 'routeA',
-            stops: new Uint32Array([0, 1]),
-            stopIndices: new Map([
-              [0, 0],
-              [1, 1],
-            ]),
-            stopTimes: new Uint16Array([
+          new Route(
+            new Uint16Array([
               Time.fromHMS(8, 0, 0).toMinutes(),
               Time.fromHMS(8, 5, 0).toMinutes(),
               Time.fromHMS(8, 10, 0).toMinutes(),
@@ -309,8 +292,19 @@ describe('GTFS stop times parser', () => {
               Time.fromHMS(9, 10, 0).toMinutes(),
               Time.fromHMS(9, 15, 0).toMinutes(),
             ]),
-            pickUpDropOffTypes: new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0]),
-          },
+            new Uint8Array([
+              REGULAR,
+              REGULAR,
+              REGULAR,
+              REGULAR,
+              REGULAR,
+              REGULAR,
+              REGULAR,
+              REGULAR,
+            ]),
+            new Uint32Array([0, 1]),
+            'routeA',
+          ),
         ],
       ]),
     );
@@ -366,14 +360,8 @@ describe('GTFS stop times parser', () => {
       new Map([
         [
           'routeA_1',
-          {
-            serviceRouteId: 'routeA',
-            stops: new Uint32Array([0, 1]),
-            stopIndices: new Map([
-              [0, 0],
-              [1, 1],
-            ]),
-            stopTimes: new Uint16Array([
+          new Route(
+            new Uint16Array([
               Time.fromHMS(8, 0, 0).toMinutes(),
               Time.fromHMS(8, 5, 0).toMinutes(),
               Time.fromHMS(8, 10, 0).toMinutes(),
@@ -383,8 +371,19 @@ describe('GTFS stop times parser', () => {
               Time.fromHMS(9, 10, 0).toMinutes(),
               Time.fromHMS(9, 15, 0).toMinutes(),
             ]),
-            pickUpDropOffTypes: new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0]),
-          },
+            new Uint8Array([
+              REGULAR,
+              REGULAR,
+              REGULAR,
+              REGULAR,
+              REGULAR,
+              REGULAR,
+              REGULAR,
+              REGULAR,
+            ]),
+            new Uint32Array([0, 1]),
+            'routeA',
+          ),
         ],
       ]),
     );
@@ -439,34 +438,29 @@ describe('GTFS stop times parser', () => {
       new Map([
         [
           'routeA_1',
-          {
-            serviceRouteId: 'routeA',
-            stops: new Uint32Array([0, 1]),
-            stopIndices: new Map([
-              [0, 0],
-              [1, 1],
-            ]),
-            stopTimes: new Uint16Array([
+          new Route(
+            new Uint16Array([
               Time.fromHMS(8, 0, 0).toMinutes(),
               Time.fromHMS(8, 5, 0).toMinutes(),
               Time.fromHMS(8, 10, 0).toMinutes(),
               Time.fromHMS(8, 15, 0).toMinutes(),
             ]),
-            pickUpDropOffTypes: new Uint8Array([0, 0, 0, 0]),
-          },
+            new Uint8Array([REGULAR, REGULAR, REGULAR, REGULAR]),
+            new Uint32Array([0, 1]),
+            'routeA',
+          ),
         ],
         [
           'routeA_0',
-          {
-            serviceRouteId: 'routeA',
-            stops: new Uint32Array([0]),
-            stopIndices: new Map([[0, 0]]),
-            stopTimes: new Uint16Array([
+          new Route(
+            new Uint16Array([
               Time.fromHMS(9, 0, 0).toMinutes(),
               Time.fromHMS(9, 15, 0).toMinutes(),
             ]),
-            pickUpDropOffTypes: new Uint8Array([0, 0]),
-          },
+            new Uint8Array([REGULAR, REGULAR]),
+            new Uint32Array([0]),
+            'routeA',
+          ),
         ],
       ]),
     );
@@ -517,16 +511,15 @@ describe('GTFS stop times parser', () => {
       new Map([
         [
           'routeA_0',
-          {
-            serviceRouteId: 'routeA',
-            stops: new Uint32Array([0]),
-            stopIndices: new Map([[0, 0]]),
-            stopTimes: new Uint16Array([
+          new Route(
+            new Uint16Array([
               Time.fromHMS(8, 0, 0).toMinutes(),
               Time.fromHMS(8, 5, 0).toMinutes(),
             ]),
-            pickUpDropOffTypes: new Uint8Array([0, 0]),
-          },
+            new Uint8Array([REGULAR, REGULAR]),
+            new Uint32Array([0]),
+            'routeA',
+          ),
         ],
       ]),
     );

package/src/gtfs/profiles/ch.ts

@@ -10,7 +10,7 @@ import { Maybe } from '../utils.js';
  * @returns The platform corresponding to this stop.
  */
 const platformParser = (stopEntry: StopEntry): Maybe<Platform> => {
-  const stopId = String(stopEntry.stop_id);
+  const stopId = stopEntry.stop_id;
   const stopParts = stopId.split(':');
   if (stopParts.length > 2) {
     return stopParts[2];

package/src/gtfs/routes.ts

@@ -1,6 +1,6 @@
 import log from 'loglevel';
 
-import { RouteId, ServiceRoutesMap } from '../timetable/timetable.js';
+import { ServiceRouteId, ServiceRoutesMap } from '../timetable/timetable.js';
 import { GtfsProfile } from './parser.js';
 import { standardProfile } from './profiles/standard.js';
 import { parseCsv } from './utils.js';
@@ -10,7 +10,7 @@ import { parseCsv } from './utils.js';
 export type GtfsRouteType = number;
 
 type RouteEntry = {
-  route_id: RouteId;
+  route_id: ServiceRouteId;
   agency_id: string;
   route_short_name: string;
   route_long_name: string;
@@ -30,7 +30,7 @@ export const parseRoutes = async (
   profile: GtfsProfile = standardProfile,
 ): Promise<ServiceRoutesMap> => {
   const routes: ServiceRoutesMap = new Map();
-  for await (const rawLine of parseCsv(routesStream)) {
+  for await (const rawLine of parseCsv(routesStream, ['route_type'])) {
     const line = rawLine as RouteEntry;
     const routeType = profile.routeTypeParser(line.route_type);
     if (routeType === undefined) {
@@ -40,7 +40,7 @@ export const parseRoutes = async (
       continue;
     }
     routes.set(line.route_id, {
-      name: line.route_short_name + '',
+      name: line.route_short_name,
       type: routeType,
     });
   }

package/src/gtfs/services.ts

@@ -55,7 +55,17 @@ export const parseCalendar = async (
   const activeDate: number = toGtfsDate(date);
   const weekday = date.weekday as Weekday;
   const weekdayIndex = weekdays[weekday] as keyof CalendarEntry;
-  for await (const rawLine of parseCsv(calendarStream)) {
+  for await (const rawLine of parseCsv(calendarStream, [
+    'monday',
+    'tuesday',
+    'wednesday',
+    'thursday',
+    'friday',
+    'saturday',
+    'sunday',
+    'start_date',
+    'end_date',
+  ])) {
     const line = rawLine as CalendarEntry;
     if (activeDate < line.start_date || activeDate > line.end_date) {
       // If the service is not valid on this date
@@ -82,7 +92,10 @@ export const parseCalendarDates = async (
   date: DateTime,
 ) => {
   const activeDate: number = toGtfsDate(date);
-  for await (const rawLine of parseCsv(calendarDatesStream)) {
+  for await (const rawLine of parseCsv(calendarDatesStream, [
+    'date',
+    'exception_type',
+  ])) {
     const line = rawLine as CalendarDatesEntry;
     if (line.date !== activeDate) {
       // No rule on the active date

package/src/gtfs/stops.ts

@@ -44,11 +44,15 @@ export const parseStops = async (
 ): Promise<ParsedStopsMap> => {
   const parsedStops = new Map<SourceStopId, ParsedStop>();
   let i = 0;
-  for await (const rawLine of parseCsv(stopsStream)) {
+  for await (const rawLine of parseCsv(stopsStream, [
+    'stop_lat',
+    'stop_lon',
+    'location_type',
+  ])) {
     const line = rawLine as StopEntry;
     const stop: ParsedStop = {
       id: i,
-      sourceStopId: line.stop_id + '',
+      sourceStopId: line.stop_id,
       name: line.stop_name,
       lat: line.stop_lat,
       lon: line.stop_lon,
@@ -68,7 +72,7 @@ export const parseStops = async (
         console.info(`Could not parse platform for stop ${line.stop_id}.`);
       }
     }
-    parsedStops.set(line.stop_id + '', stop);
+    parsedStops.set(line.stop_id, stop);
     i = i + 1;
   }
 

package/src/gtfs/transfers.ts

@@ -42,7 +42,10 @@ export const parseTransfers = async (
 ): Promise<TransfersMap> => {
   const transfers: TransfersMap = new Map();
 
-  for await (const rawLine of parseCsv(transfersStream)) {
+  for await (const rawLine of parseCsv(transfersStream, [
+    'transfer_type',
+    'min_transfer_time',
+  ])) {
     const transferEntry = rawLine as TransferEntry;
 
     if (
@@ -74,9 +77,9 @@ export const parseTransfers = async (
     }
 
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    const fromStop = stopsMap.get(transferEntry.from_stop_id + '')!;
+    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 toStop = stopsMap.get(transferEntry.to_stop_id)!;
 
     const transfer: Transfer = {
       destination: toStop.id,

package/src/gtfs/trips.ts

@@ -1,18 +1,20 @@
 import { SourceStopId, StopId } from '../stops/stops.js';
+import { SerializedRoute } from '../timetable/io.js';
 import {
   MUST_COORDINATE_WITH_DRIVER,
   MUST_PHONE_AGENCY,
   NOT_AVAILABLE,
-  PickUpDropOffType,
   REGULAR,
   Route,
   RouteId,
+} from '../timetable/route.js';
+import {
   RoutesAdjacency,
   ServiceRouteId,
   ServiceRoutesMap,
   StopsAdjacency,
 } from '../timetable/timetable.js';
-import { ServiceIds } from './services.js';
+import { ServiceId, ServiceIds } from './services.js';
 import { ParsedStopsMap } from './stops.js';
 import { GtfsTime, toTime } from './time.js';
 import { TransfersMap } from './transfers.js';
@@ -23,8 +25,8 @@ export type TripId = string;
 export type TripIdsMap = Map<TripId, ServiceRouteId>;
 
 type TripEntry = {
-  route_id: RouteId;
-  service_id: ServiceRouteId;
+  route_id: ServiceRouteId;
+  service_id: ServiceId;
   trip_id: TripId;
 };
 
@@ -45,6 +47,8 @@ type StopTimeEntry = {
   drop_off_type?: GtfsPickupDropOffType;
 };
 
+export type SerializedPickUpDropOffType = 0 | 1 | 2 | 3;
+
 /**
  * Parses the trips.txt file from a GTFS feed
  *
@@ -59,7 +63,7 @@ export const parseTrips = async (
   routeIds: ServiceRoutesMap,
 ): Promise<TripIdsMap> => {
   const trips: TripIdsMap = new Map();
-  for await (const rawLine of parseCsv(tripsStream)) {
+  for await (const rawLine of parseCsv(tripsStream, ['stop_sequence'])) {
     const line = rawLine as TripEntry;
     if (!serviceIds.has(line.service_id)) {
       // The trip doesn't correspond to an active service
@@ -81,8 +85,11 @@ export const buildStopsAdjacencyStructure = (
 ): StopsAdjacency => {
   const stopsAdjacency: StopsAdjacency = new Map();
   for (const routeId of routes.keys()) {
-    const route = routes.get(routeId) as Route;
-    for (const stop of route.stops) {
+    const route = routes.get(routeId);
+    if (!route) {
+      throw new Error(`Route ${routeId} not found`);
+    }
+    for (const stop of route.stopsIterator()) {
       if (!stopsAdjacency.get(stop) && validStops.has(stop)) {
         stopsAdjacency.set(stop, { routes: [], transfers: [] });
       }
@@ -154,7 +161,6 @@ export const parseStopTimes = async (
       route = {
         serviceRouteId: gtfsRouteId,
         stops: stopsArray,
-        stopIndices: new Map(stops.map((stop, i) => [stop, i])),
         stopTimes: stopTimesArray,
         pickUpDropOffTypes: pickUpDropOffTypesArray,
       };
@@ -223,17 +229,17 @@ export const parseStopTimes = async (
     dropOffTypes = [];
   };
 
-  const routes: RoutesAdjacency = new Map();
+  const routes: Map<RouteId, SerializedRoute> = new Map();
 
   let previousSeq = 0;
   let stops: StopId[] = [];
   let arrivalTimes: number[] = [];
   let departureTimes: number[] = [];
-  let pickUpTypes: PickUpDropOffType[] = [];
-  let dropOffTypes: PickUpDropOffType[] = [];
+  let pickUpTypes: SerializedPickUpDropOffType[] = [];
+  let dropOffTypes: SerializedPickUpDropOffType[] = [];
   let currentTripId: TripId | undefined = undefined;
 
-  for await (const rawLine of parseCsv(stopTimesStream)) {
+  for await (const rawLine of parseCsv(stopTimesStream, ['stop_sequence'])) {
     const line = rawLine as StopTimeEntry;
     if (line.trip_id === currentTripId && line.stop_sequence <= previousSeq) {
       console.warn(`Stop sequences not increasing for trip ${line.trip_id}.`);
@@ -253,7 +259,7 @@ export const parseStopTimes = async (
     }
     currentTripId = line.trip_id;
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    stops.push(stopsMap.get(line.stop_id + '')!.id);
+    stops.push(stopsMap.get(line.stop_id)!.id);
     const departure = line.departure_time ?? line.arrival_time;
     const arrival = line.arrival_time ?? line.departure_time;
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
@@ -269,15 +275,26 @@ export const parseStopTimes = async (
     addTrip(currentTripId);
   }
 
-  return routes;
+  const routesAdjacency: RoutesAdjacency = new Map<RouteId, Route>();
+  for (const [routeId, routeData] of routes) {
+    routesAdjacency.set(
+      routeId,
+      new Route(
+        routeData.stopTimes,
+        routeData.pickUpDropOffTypes,
+        routeData.stops,
+        routeData.serviceRouteId,
+      ),
+    );
+  }
+  return routesAdjacency;
 };
 
 const parsePickupDropOffType = (
   gtfsType?: GtfsPickupDropOffType,
-): PickUpDropOffType => {
+): SerializedPickUpDropOffType => {
   switch (gtfsType) {
     default:
-      console.warn(`Unknown pickup/drop-off type ${gtfsType}`);
       return REGULAR;
     case 0:
       return REGULAR;

package/src/gtfs/utils.ts

@@ -28,12 +28,23 @@ export const hashIds = (ids: number[]): string => {
  * @param stream The CSV stream.
  * @returns A parser from the csv-parse library.
  */
-export const parseCsv = (stream: NodeJS.ReadableStream): Parser => {
+export const parseCsv = (
+  stream: NodeJS.ReadableStream,
+  numericColumns: string[] = [],
+): Parser => {
   return stream.pipe(
     parse({
       delimiter: ',',
       columns: true,
-      cast: true,
+      cast: (value, context) => {
+        if (
+          typeof context.column === 'string' &&
+          numericColumns.includes(context.column)
+        ) {
+          return Number(value);
+        }
+        return value;
+      },
       bom: true,
       ignore_last_delimiters: true,
       relax_column_count: true,

package/src/parser.ts

@@ -1,4 +1,6 @@
-import { GtfsParser, GtfsProfile } from './gtfs/parser.js';
+import type { GtfsProfile } from './gtfs/parser.js';
+import { GtfsParser } from './gtfs/parser.js';
 import { chGtfsProfile } from './gtfs/profiles/ch.js';
 
-export { chGtfsProfile, GtfsParser, GtfsProfile };
+export { chGtfsProfile, GtfsParser };
+export type { GtfsProfile };

package/src/router.ts

@@ -1,37 +1,43 @@
 import { Plotter } from './routing/plotter.js';
 import { Query } from './routing/query.js';
 import { Result } from './routing/result.js';
-import { Leg, Route, Transfer, VehicleLeg } from './routing/route.js';
-import { ReachingTime, Router } from './routing/router.js';
-import { LocationType, SourceStopId, Stop, StopId } from './stops/stops.js';
+import type { Leg, Transfer, VehicleLeg } from './routing/route.js';
+import { Route } from './routing/route.js';
+import type { ReachingTime } 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';
 import { StopsIndex } from './stops/stopsIndex.js';
 import { Duration } from './timetable/duration.js';
 import { Time } from './timetable/time.js';
-import {
+import type {
   RouteType,
   ServiceRoute,
-  Timetable,
   TransferType,
 } from './timetable/timetable.js';
+import { Timetable } from './timetable/timetable.js';
 
 export {
   Duration,
-  Leg,
-  LocationType,
   Plotter,
   Query,
-  ReachingTime,
   Result,
   Route,
   Router,
+  StopsIndex,
+  Time,
+  Timetable,
+};
+
+export type {
+  Leg,
+  LocationType,
+  ReachingTime,
   RouteType,
   ServiceRoute,
   SourceStopId,
   Stop,
   StopId,
-  StopsIndex,
-  Time,
-  Timetable,
   Transfer,
   TransferType,
   VehicleLeg,