minotor 1.0.7 → 2.0.0

package/src/gtfs/stops.ts

@@ -3,14 +3,13 @@ import {
   LocationType,
   Longitude,
   Platform,
+  SourceStopId,
   Stop,
   StopId,
   StopsMap,
 } from '../stops/stops.js';
 import { Maybe, parseCsv } from './utils.js';
 
-export type StopIds = Set<StopId>;
-
 export type GtfsLocationType =
   | 0 // simple stop or platform (can also be empty)
   | 1 // station
@@ -19,15 +18,20 @@ export type GtfsLocationType =
   | 4; // boarding area
 
 export type StopEntry = {
-  stop_id: StopId;
+  stop_id: SourceStopId;
   stop_name: string;
   stop_lat?: Latitude;
   stop_lon?: Longitude;
   location_type?: GtfsLocationType;
-  parent_station?: StopId;
+  parent_station?: SourceStopId;
   platform_code?: Platform;
 };
 
+type ParsedStop = Stop & {
+  parentSourceId?: SourceStopId;
+};
+
+export type ParsedStopsMap = Map<SourceStopId, ParsedStop>;
 /**
  * Parses the stops.txt file from a GTFS feed.
  *
@@ -37,14 +41,14 @@ export type StopEntry = {
 export const parseStops = async (
   stopsStream: NodeJS.ReadableStream,
   platformParser?: (stopEntry: StopEntry) => Maybe<Platform>,
-  validStops?: StopIds,
-): Promise<StopsMap> => {
-  const stops: StopsMap = new Map();
-
+): Promise<ParsedStopsMap> => {
+  const parsedStops = new Map<SourceStopId, ParsedStop>();
+  let i = 0;
   for await (const rawLine of parseCsv(stopsStream)) {
     const line = rawLine as StopEntry;
-    const stop: Stop = {
-      id: line.stop_id,
+    const stop: ParsedStop = {
+      id: i,
+      sourceStopId: line.stop_id + '',
       name: line.stop_name,
       lat: line.stop_lat,
       lon: line.stop_lon,
@@ -52,7 +56,7 @@ export const parseStops = async (
         ? parseGtfsLocationType(line.location_type)
         : 'SIMPLE_STOP_OR_PLATFORM',
       children: [],
-      ...(line.parent_station && { parent: line.parent_station }),
+      ...(line.parent_station && { parentSourceId: line.parent_station }),
     };
     if (platformParser) {
       try {
@@ -64,30 +68,61 @@ export const parseStops = async (
         console.info(`Could not parse platform for stop ${line.stop_id}.`);
       }
     }
-    stops.set(line.stop_id, stop);
+    parsedStops.set(line.stop_id + '', stop);
+    i = i + 1;
   }
 
-  for (const [stopId, stop] of stops) {
-    if (stop.parent) {
-      const parentStop = stops.get(stop.parent);
+  for (const [sourceStopId, stop] of parsedStops) {
+    if (stop.parentSourceId) {
+      const parentStop = parsedStops.get(stop.parentSourceId);
       if (!parentStop) {
-        console.warn(`Cannot find parent stop ${stop.parent} of ${stopId}`);
+        console.warn(
+          `Cannot find parent stop ${stop.parentSourceId} of ${sourceStopId}`,
+        );
         continue;
       }
-      parentStop.children.push(stopId);
+      stop.parent = parentStop.id;
+      parentStop.children.push(stop.id);
     }
   }
-  if (validStops) {
-    // Remove all stops which don't have at least one valid stopId as a child,
-    // a parent or as its own.
-    for (const [stopId, stop] of stops) {
-      if (
-        !validStops.has(stopId) &&
-        (!stop.parent || !validStops.has(stop.parent)) &&
-        !stop.children.some((childId) => validStops.has(childId))
-      ) {
-        stops.delete(stopId);
-      }
+  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;

package/src/gtfs/transfers.ts

@@ -1,10 +1,11 @@
-import { StopId } from '../stops/stops.js';
+import { SourceStopId, StopId } from '../stops/stops.js';
 import { Duration } from '../timetable/duration.js';
 import {
   ServiceRouteId,
   Transfer,
   TransferType,
 } from '../timetable/timetable.js';
+import { ParsedStopsMap } from './stops.js';
 import { TripId } from './trips.js';
 import { parseCsv } from './utils.js';
 
@@ -19,8 +20,8 @@ export type GtfsTransferType =
 export type TransfersMap = Map<StopId, Transfer[]>;
 
 export type TransferEntry = {
-  from_stop_id?: StopId;
-  to_stop_id?: StopId;
+  from_stop_id?: SourceStopId;
+  to_stop_id?: SourceStopId;
   from_trip_id?: TripId;
   to_trip_id?: TripId;
   from_route_id?: ServiceRouteId;
@@ -37,11 +38,13 @@ export type TransferEntry = {
  */
 export const parseTransfers = async (
   transfersStream: NodeJS.ReadableStream,
+  stopsMap: ParsedStopsMap,
 ): Promise<TransfersMap> => {
   const transfers: TransfersMap = new Map();
 
   for await (const rawLine of parseCsv(transfersStream)) {
     const transferEntry = rawLine as TransferEntry;
+
     if (
       transferEntry.transfer_type === 3 ||
       transferEntry.transfer_type === 5
@@ -70,17 +73,22 @@ export const parseTransfers = async (
       );
     }
 
+    // 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: transferEntry.to_stop_id,
+      destination: toStop.id,
       type: parseGtfsTransferType(transferEntry.transfer_type),
       ...(transferEntry.min_transfer_time && {
         minTransferTime: Duration.fromSeconds(transferEntry.min_transfer_time),
       }),
     };
 
-    const fromStopTransfers = transfers.get(transferEntry.from_stop_id) || [];
+    const fromStopTransfers = transfers.get(fromStop.id) || [];
     fromStopTransfers.push(transfer);
-    transfers.set(transferEntry.from_stop_id, fromStopTransfers);
+    transfers.set(fromStop.id, fromStopTransfers);
   }
   return transfers;
 };

package/src/gtfs/trips.ts

@@ -1,19 +1,22 @@
-import { StopId } from '../stops/stops.js';
+import { SourceStopId, StopId } from '../stops/stops.js';
 import {
+  MUST_COORDINATE_WITH_DRIVER,
+  MUST_PHONE_AGENCY,
+  NOT_AVAILABLE,
   PickUpDropOffType,
+  REGULAR,
   Route,
   RouteId,
   RoutesAdjacency,
   ServiceRouteId,
   ServiceRoutesMap,
   StopsAdjacency,
-  StopTimes,
 } from '../timetable/timetable.js';
 import { ServiceIds } from './services.js';
-import { StopIds } from './stops.js';
+import { ParsedStopsMap } from './stops.js';
 import { GtfsTime, toTime } from './time.js';
 import { TransfersMap } from './transfers.js';
-import { hash, parseCsv } from './utils.js';
+import { hashIds, parseCsv } from './utils.js';
 
 export type TripId = string;
 
@@ -36,7 +39,7 @@ type StopTimeEntry = {
   trip_id: TripId;
   arrival_time?: GtfsTime;
   departure_time?: GtfsTime;
-  stop_id: StopId;
+  stop_id: SourceStopId;
   stop_sequence: number;
   pickup_type?: GtfsPickupDropOffType;
   drop_off_type?: GtfsPickupDropOffType;
@@ -72,7 +75,7 @@ export const parseTrips = async (
 };
 
 export const buildStopsAdjacencyStructure = (
-  validStops: StopIds,
+  validStops: Set<StopId>,
   routes: RoutesAdjacency,
   transfersMap: TransfersMap,
 ): StopsAdjacency => {
@@ -104,65 +107,130 @@ export const buildStopsAdjacencyStructure = (
  * Parses the stop_times.txt data from a GTFS feed.
  *
  * @param stopTimesStream The readable stream containing the stop times data.
+ * @param stopsMap A map of parsed stops from the GTFS feed.
  * @param validTripIds A map of valid trip IDs to corresponding route IDs.
- * @param validStopIds A map of valid stop IDs.
- * @returns A mapping of route IDs to route details. The routes return corresponds to the set of trips from GTFS that share the same stop list.
+ * @param validStopIds A set of valid stop IDs.
+ * @returns A mapping of route IDs to route details. The routes returned correspond to the set of trips from GTFS that share the same stop list.
  */
 export const parseStopTimes = async (
   stopTimesStream: NodeJS.ReadableStream,
+  stopsMap: ParsedStopsMap,
   validTripIds: TripIdsMap,
-  validStopIds: StopIds,
+  validStopIds: Set<StopId>,
 ): Promise<RoutesAdjacency> => {
+  /**
+   * Inserts a trip at the right place in the routes adjacency structure.
+   */
   const addTrip = (currentTripId: TripId) => {
     const gtfsRouteId = validTripIds.get(currentTripId);
     if (!gtfsRouteId) {
       stops = [];
-      stopTimes = [];
+      arrivalTimes = [];
+      departureTimes = [];
+      pickUpTypes = [];
+      dropOffTypes = [];
       return;
     }
-    const routeId = `${gtfsRouteId}_${hash(stops.join('$'))}`;
+    const routeId = `${gtfsRouteId}_${hashIds(stops)}`;
 
     let route = routes.get(routeId);
     if (!route) {
+      const stopsCount = stops.length;
+      const stopsArray = new Uint32Array(stops);
+      const stopTimesArray = new Uint32Array(stopsCount * 2);
+      for (let i = 0; i < stopsCount; i++) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        stopTimesArray[i * 2] = arrivalTimes[i]!;
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        stopTimesArray[i * 2 + 1] = departureTimes[i]!;
+      }
+      const pickUpDropOffTypesArray = new Uint8Array(stopsCount * 2);
+      for (let i = 0; i < stopsCount; i++) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        pickUpDropOffTypesArray[i * 2] = pickUpTypes[i]!;
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        pickUpDropOffTypesArray[i * 2 + 1] = dropOffTypes[i]!;
+      }
       route = {
         serviceRouteId: gtfsRouteId,
-        stops: [...stops],
+        stops: stopsArray,
         stopIndices: new Map(stops.map((stop, i) => [stop, i])),
-        stopTimes: [...stopTimes],
+        stopTimes: stopTimesArray,
+        pickUpDropOffTypes: pickUpDropOffTypesArray,
       };
       routes.set(routeId, route);
       for (const stop of stops) {
         validStopIds.add(stop);
       }
     } else {
-      const tripFirstStop = stopTimes[0];
-      if (!tripFirstStop) {
+      const tripFirstStopDeparture = departureTimes[0];
+      if (tripFirstStopDeparture === undefined) {
         throw new Error(`Empty trip ${currentTripId}`);
       }
-      // insert the stopTimes at the right position
-      let stopTimesIndex = 0;
-      for (let i = 0; i < route.stopTimes.length; i += stops.length) {
-        const currentDeparture = route.stopTimes[i];
-        if (
-          currentDeparture &&
-          tripFirstStop.departure > currentDeparture.departure
-        ) {
-          stopTimesIndex = i + stops.length;
+
+      // Find the correct position to insert the new trip
+      const stopsCount = stops.length;
+      let insertPosition = 0;
+      const existingTripsCount = route.stopTimes.length / (stopsCount * 2);
+
+      for (let tripIndex = 0; tripIndex < existingTripsCount; tripIndex++) {
+        const currentDeparture =
+          route.stopTimes[tripIndex * stopsCount * 2 + 1];
+        if (currentDeparture && tripFirstStopDeparture > currentDeparture) {
+          insertPosition = (tripIndex + 1) * stopsCount;
         } else {
           break;
         }
       }
-      route.stopTimes.splice(stopTimesIndex, 0, ...stopTimes);
+
+      // insert data for the new trip at the right place
+      const newStopTimesLength = route.stopTimes.length + stopsCount * 2;
+      const newStopTimes = new Uint32Array(newStopTimesLength);
+      const newPickUpDropOffTypes = new Uint8Array(newStopTimesLength);
+
+      newStopTimes.set(route.stopTimes.slice(0, insertPosition * 2), 0);
+      newPickUpDropOffTypes.set(
+        route.pickUpDropOffTypes.slice(0, insertPosition * 2),
+        0,
+      );
+      for (let i = 0; i < stopsCount; i++) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        newStopTimes[(insertPosition + i) * 2] = arrivalTimes[i]!;
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        newStopTimes[(insertPosition + i) * 2 + 1] = departureTimes[i]!;
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        newPickUpDropOffTypes[(insertPosition + i) * 2] = pickUpTypes[i]!;
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        newPickUpDropOffTypes[(insertPosition + i) * 2 + 1] = dropOffTypes[i]!;
+      }
+      const afterInsertionSlice = route.stopTimes.slice(insertPosition * 2);
+      newStopTimes.set(afterInsertionSlice, (insertPosition + stopsCount) * 2);
+      const afterInsertionTypesSlice = route.pickUpDropOffTypes.slice(
+        insertPosition * 2,
+      );
+      newPickUpDropOffTypes.set(
+        afterInsertionTypesSlice,
+        (insertPosition + stopsCount) * 2,
+      );
+
+      route.stopTimes = newStopTimes;
+      route.pickUpDropOffTypes = newPickUpDropOffTypes;
     }
     stops = [];
-    stopTimes = [];
+    arrivalTimes = [];
+    departureTimes = [];
+    pickUpTypes = [];
+    dropOffTypes = [];
   };
 
   const routes: RoutesAdjacency = new Map();
 
   let previousSeq = 0;
   let stops: StopId[] = [];
-  let stopTimes: StopTimes[] = [];
+  let arrivalTimes: number[] = [];
+  let departureTimes: number[] = [];
+  let pickUpTypes: PickUpDropOffType[] = [];
+  let dropOffTypes: PickUpDropOffType[] = [];
   let currentTripId: TripId | undefined = undefined;
 
   for await (const rawLine of parseCsv(stopTimesStream)) {
@@ -180,26 +248,21 @@ export const parseStopTimes = async (
     if (line.pickup_type === 1 && line.drop_off_type === 1) {
       continue;
     }
-    if (
-      currentTripId &&
-      line.trip_id !== currentTripId &&
-      stops.length > 0 &&
-      stopTimes.length > 0
-    ) {
+    if (currentTripId && line.trip_id !== currentTripId && stops.length > 0) {
       addTrip(currentTripId);
     }
     currentTripId = line.trip_id;
-    stops.push(line.stop_id);
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    stops.push(stopsMap.get(line.stop_id + '')!.id);
     const departure = line.departure_time ?? line.arrival_time;
     const arrival = line.arrival_time ?? line.departure_time;
-    stopTimes.push({
-      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-      departure: toTime(departure!),
-      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-      arrival: toTime(arrival!),
-      pickUpType: parsePickupDropOffType(line.pickup_type),
-      dropOffType: parsePickupDropOffType(line.drop_off_type),
-    });
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    arrivalTimes.push(toTime(arrival!).toSeconds());
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    departureTimes.push(toTime(departure!).toSeconds());
+    pickUpTypes.push(parsePickupDropOffType(line.pickup_type));
+    dropOffTypes.push(parsePickupDropOffType(line.drop_off_type));
+
     previousSeq = line.stop_sequence;
   }
   if (currentTripId) {
@@ -215,14 +278,14 @@ const parsePickupDropOffType = (
   switch (gtfsType) {
     default:
       console.warn(`Unknown pickup/drop-off type ${gtfsType}`);
-      return 'REGULAR';
+      return REGULAR;
     case 0:
-      return 'REGULAR';
+      return REGULAR;
     case 1:
-      return 'NOT_AVAILABLE';
+      return NOT_AVAILABLE;
     case 2:
-      return 'MUST_PHONE_AGENCY';
+      return MUST_PHONE_AGENCY;
     case 3:
-      return 'MUST_COORDINATE_WITH_DRIVER';
+      return MUST_COORDINATE_WITH_DRIVER;
   }
 };

package/src/gtfs/utils.ts

@@ -3,23 +3,23 @@ import { parse, Parser } from 'csv-parse';
 export type Maybe<T> = T | undefined;
 
 /**
- * Generates a simple hash from a string.
+ * Generates a simple hash from an array of numeric IDs.
  *
- * This function computes a hash for a given string by iterating over each
- * character and applying bitwise operations to accumulate a hash value.
- * The final hash is then converted to a base-36 string and padded to
- * ensure a minimum length of 6 characters.
+ * This function computes a hash for a given array of numbers by iterating over each
+ * ID and applying bitwise operations to accumulate a hash value.
+ * The final hash is then converted to a base-36 string.
  *
- * @param str - The input string to hash.
- * @returns A hashed string representation of the input.
+ * @param ids - The array of numeric IDs to hash.
+ * @returns A hashed string representation of the input array.
  */
-export const hash = (str: string): string => {
+export const hashIds = (ids: number[]): string => {
   let hash = 0;
-  for (let i = 0; i < str.length; i++) {
-    hash = (hash << 5) - hash + str.charCodeAt(i);
+  for (let i = 0; i < ids.length; i++) {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    hash = (hash << 5) - hash + ids[i]!;
     hash &= hash;
   }
-  return (hash >>> 0).toString(36).padStart(6, '0');
+  return (hash >>> 0).toString(36);
 };
 
 /**

package/src/router.ts

@@ -3,12 +3,11 @@ 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, Stop, StopId } from './stops/stops.js';
+import { LocationType, SourceStopId, Stop } from './stops/stops.js';
 import { StopsIndex } from './stops/stopsIndex.js';
 import { Duration } from './timetable/duration.js';
 import { Time } from './timetable/time.js';
 import {
-  PickUpDropOffType,
   RouteType,
   ServiceRoute,
   Timetable,
@@ -19,7 +18,6 @@ export {
   Duration,
   Leg,
   LocationType,
-  PickUpDropOffType,
   Plotter,
   Query,
   ReachingTime,
@@ -29,7 +27,7 @@ export {
   RouteType,
   ServiceRoute,
   Stop,
-  StopId,
+  SourceStopId as StopId,
   StopsIndex,
   Time,
   Timetable,

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

@@ -0,0 +1,112 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+
+import { Stop } from '../../stops/stops.js';
+import { Duration } from '../../timetable/duration.js';
+import { Time } from '../../timetable/time.js';
+import { ServiceRoute, TransferType } from '../../timetable/timetable.js';
+import { Route } from '../route.js';
+
+describe('Route', () => {
+  const stopA: Stop = {
+    id: 1,
+    sourceStopId: 'A',
+    name: 'Stop A',
+    locationType: 'SIMPLE_STOP_OR_PLATFORM',
+    children: [],
+  };
+
+  const stopB: Stop = {
+    id: 2,
+    sourceStopId: 'B',
+    name: 'Stop B',
+    locationType: 'SIMPLE_STOP_OR_PLATFORM',
+    children: [],
+  };
+
+  const stopC: Stop = {
+    id: 3,
+    sourceStopId: 'C',
+    name: 'Stop C',
+    locationType: 'SIMPLE_STOP_OR_PLATFORM',
+    children: [],
+  };
+
+  const stopD: Stop = {
+    id: 4,
+    sourceStopId: 'D',
+    name: 'Stop D',
+    locationType: 'SIMPLE_STOP_OR_PLATFORM',
+    children: [],
+  };
+
+  const serviceRoute: ServiceRoute = {
+    type: 'BUS',
+    name: 'Route 1',
+  };
+
+  const serviceRoute2: ServiceRoute = {
+    type: 'RAIL',
+    name: 'Route 2',
+  };
+
+  const vehicleLeg = {
+    from: stopA,
+    to: stopB,
+    route: serviceRoute,
+    departureTime: Time.fromHMS(8, 0, 0),
+    arrivalTime: Time.fromHMS(8, 30, 0),
+  };
+
+  const transferLeg = {
+    from: stopB,
+    to: stopC,
+    type: 'RECOMMENDED' as TransferType,
+    minTransferTime: Duration.fromMinutes(5),
+  };
+
+  const secondVehicleLeg = {
+    from: stopC,
+    to: stopD,
+    route: serviceRoute2,
+    departureTime: Time.fromHMS(8, 40, 0),
+    arrivalTime: Time.fromHMS(9, 0, 0),
+  };
+
+  it('should calculate the correct departure time', () => {
+    const route = new Route([vehicleLeg, transferLeg, secondVehicleLeg]);
+    const departureTime = route.departureTime();
+    assert.strictEqual(
+      departureTime.toSeconds(),
+      Time.fromHMS(8, 0, 0).toSeconds(),
+    );
+  });
+
+  it('should calculate the correct arrival time', () => {
+    const route = new Route([vehicleLeg, transferLeg, secondVehicleLeg]);
+    const arrivalTime = route.arrivalTime();
+    assert.strictEqual(
+      arrivalTime.toSeconds(),
+      Time.fromHMS(9, 0, 0).toSeconds(),
+    );
+  });
+
+  it('should calculate the total duration of the route', () => {
+    const route = new Route([vehicleLeg, transferLeg, secondVehicleLeg]);
+    const totalDuration = route.totalDuration();
+    assert.strictEqual(
+      totalDuration.toSeconds(),
+      Duration.fromMinutes(60).toSeconds(),
+    );
+  });
+
+  it('should throw an error if no vehicle leg is found for departure time', () => {
+    const route = new Route([transferLeg]);
+    assert.throws(() => route.departureTime(), /No vehicle leg found in route/);
+  });
+
+  it('should throw an error if no vehicle leg is found for arrival time', () => {
+    const route = new Route([transferLeg]);
+    assert.throws(() => route.arrivalTime(), /No vehicle leg found in route/);
+  });
+});