minotor 3.0.2 → 5.0.0

package/src/gtfs/parser.ts

@@ -51,6 +51,7 @@ export class GtfsParser {
   async parse(
     date: Date,
   ): Promise<{ timetable: Timetable; stopsIndex: StopsIndex }> {
+    log.setLevel('INFO');
     const zip = new StreamZip.async({ file: this.path });
     const entries = await zip.entries();
     const datetime = DateTime.fromJSDate(date);
@@ -59,50 +60,75 @@ export class GtfsParser {
     const validStopIds = new Set<StopId>();
 
     log.info(`Parsing ${STOPS_FILE}`);
+    const stopsStart = performance.now();
     const stopsStream = await zip.stream(STOPS_FILE);
     const parsedStops = await parseStops(
       stopsStream,
       this.profile.platformParser,
     );
-    log.info(`${parsedStops.size} parsed stops.`);
+    const stopsEnd = performance.now();
+    log.info(
+      `${parsedStops.size} parsed stops. (${(stopsEnd - stopsStart).toFixed(2)}ms)`,
+    );
 
     if (entries[CALENDAR_FILE]) {
       log.info(`Parsing ${CALENDAR_FILE}`);
+      const calendarStart = performance.now();
       const calendarStream = await zip.stream(CALENDAR_FILE);
       await parseCalendar(calendarStream, validServiceIds, datetime);
-      log.info(`${validServiceIds.size} valid services.`);
+      const calendarEnd = performance.now();
+      log.info(
+        `${validServiceIds.size} valid services. (${(calendarEnd - calendarStart).toFixed(2)}ms)`,
+      );
     }
 
     if (entries[CALENDAR_DATES_FILE]) {
       log.info(`Parsing ${CALENDAR_DATES_FILE}`);
+      const calendarDatesStart = performance.now();
       const calendarDatesStream = await zip.stream(CALENDAR_DATES_FILE);
       await parseCalendarDates(calendarDatesStream, validServiceIds, datetime);
-      log.info(`${validServiceIds.size} valid services.`);
+      const calendarDatesEnd = performance.now();
+      log.info(
+        `${validServiceIds.size} valid services. (${(calendarDatesEnd - calendarDatesStart).toFixed(2)}ms)`,
+      );
     }
 
     log.info(`Parsing ${ROUTES_FILE}`);
+    const routesStart = performance.now();
     const routesStream = await zip.stream(ROUTES_FILE);
     const validGtfsRoutes = await parseRoutes(routesStream, this.profile);
-    log.info(`${validGtfsRoutes.size} valid GTFS routes.`);
+    const routesEnd = performance.now();
+    log.info(
+      `${validGtfsRoutes.size} valid GTFS routes. (${(routesEnd - routesStart).toFixed(2)}ms)`,
+    );
 
     log.info(`Parsing ${TRIPS_FILE}`);
+    const tripsStart = performance.now();
     const tripsStream = await zip.stream(TRIPS_FILE);
     const trips = await parseTrips(
       tripsStream,
       validServiceIds,
       validGtfsRoutes,
     );
-    log.info(`${trips.size} valid trips.`);
+    const tripsEnd = performance.now();
+    log.info(
+      `${trips.size} valid trips. (${(tripsEnd - tripsStart).toFixed(2)}ms)`,
+    );
 
     let transfers = new Map() as TransfersMap;
     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);
-      log.info(`${transfers.size} valid transfers.`);
+      const transfersEnd = performance.now();
+      log.info(
+        `${transfers.size} valid transfers. (${(transfersEnd - transfersStart).toFixed(2)}ms)`,
+      );
     }
 
     log.info(`Parsing ${STOP_TIMES_FILE}`);
+    const stopTimesStart = performance.now();
     const stopTimesStream = await zip.stream(STOP_TIMES_FILE);
     const routesAdjacency = await parseStopTimes(
       stopTimesStream,
@@ -112,15 +138,21 @@ export class GtfsParser {
     );
     const stopsAdjacency = buildStopsAdjacencyStructure(
       validStopIds,
+      validGtfsRoutes,
       routesAdjacency,
       transfers,
     );
-    log.info(`${routesAdjacency.size} valid unique routes.`);
+    const stopTimesEnd = performance.now();
+    log.info(
+      `${routesAdjacency.length} valid unique routes. (${(stopTimesEnd - stopTimesStart).toFixed(2)}ms)`,
+    );
 
     log.info(`Removing unused stops.`);
+    const indexStopsStart = performance.now();
     const stops = indexStops(parsedStops, validStopIds);
+    const indexStopsEnd = performance.now();
     log.info(
-      `${stops.size} used stop stops, ${parsedStops.size - stops.size} unused.`,
+      `${stops.size} used stop stops, ${parsedStops.size - stops.size} unused. (${(indexStopsEnd - indexStopsStart).toFixed(2)}ms)`,
     );
 
     await zip.close();
@@ -132,7 +164,12 @@ export class GtfsParser {
     );
 
     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)`,
+    );
 
     log.info('Parsing complete.');
     return { timetable, stopsIndex };
@@ -149,12 +186,16 @@ export class GtfsParser {
     const zip = new StreamZip.async({ file: this.path });
 
     log.info(`Parsing ${STOPS_FILE}`);
+    const stopsStart = performance.now();
     const stopsStream = await zip.stream(STOPS_FILE);
     const stops = indexStops(
       await parseStops(stopsStream, this.profile.platformParser),
     );
+    const stopsEnd = performance.now();
 
-    log.info(`${stops.size} parsed stops.`);
+    log.info(
+      `${stops.size} parsed stops. (${(stopsEnd - stopsStart).toFixed(2)}ms)`,
+    );
 
     await zip.close();
 

package/src/gtfs/routes.ts

@@ -42,6 +42,7 @@ export const parseRoutes = async (
     routes.set(line.route_id, {
       name: line.route_short_name,
       type: routeType,
+      routes: [],
     });
   }
   return routes;

package/src/gtfs/trips.ts

@@ -6,10 +6,8 @@ import {
   NOT_AVAILABLE,
   REGULAR,
   Route,
-  RouteId,
 } from '../timetable/route.js';
 import {
-  RoutesAdjacency,
   ServiceRouteId,
   ServiceRoutesMap,
   StopsAdjacency,
@@ -32,10 +30,10 @@ type TripEntry = {
 
 export type GtfsPickupDropOffType =
   | '' // Not specified
-  | 0 // Regularly scheduled
-  | 1 // Not available
-  | 2 // Must phone agency
-  | 3; // Must coordinate with driver
+  | '0' // Regularly scheduled
+  | '1' // Not available
+  | '2' // Must phone agency
+  | '3'; // Must coordinate with driver
 
 type StopTimeEntry = {
   trip_id: TripId;
@@ -49,18 +47,133 @@ type StopTimeEntry = {
 
 export type SerializedPickUpDropOffType = 0 | 1 | 2 | 3;
 
+/**
+ * Intermediate data structure for building routes during parsing
+ */
+type RouteBuilder = {
+  serviceRouteId: ServiceRouteId;
+  stops: StopId[];
+  trips: Array<{
+    firstDeparture: number;
+    arrivalTimes: number[];
+    departureTimes: number[];
+    pickUpTypes: SerializedPickUpDropOffType[];
+    dropOffTypes: SerializedPickUpDropOffType[];
+  }>;
+};
+
+/**
+ * Encodes pickup/drop-off types into a Uint8Array using 2 bits per value.
+ * Layout per byte: [drop_off_1][pickup_1][drop_off_0][pickup_0] for stops 0 and 1
+ */
+export const encodePickUpDropOffTypes = (
+  pickUpTypes: SerializedPickUpDropOffType[],
+  dropOffTypes: SerializedPickUpDropOffType[],
+): Uint8Array => {
+  const stopsCount = pickUpTypes.length;
+  // Each byte stores 2 pickup/drop-off pairs (4 bits each)
+  const arraySize = Math.ceil(stopsCount / 2);
+  const encoded = new Uint8Array(arraySize);
+
+  for (let i = 0; i < stopsCount; i++) {
+    const byteIndex = Math.floor(i / 2);
+    const isSecondPair = i % 2 === 1;
+    const dropOffType = dropOffTypes[i];
+    const pickUpType = pickUpTypes[i];
+
+    if (
+      dropOffType !== undefined &&
+      pickUpType !== undefined &&
+      byteIndex < encoded.length
+    ) {
+      if (isSecondPair) {
+        // Second pair: upper 4 bits
+        const currentByte = encoded[byteIndex];
+        if (currentByte !== undefined) {
+          encoded[byteIndex] =
+            currentByte | (dropOffType << 4) | (pickUpType << 6);
+        }
+      } else {
+        // First pair: lower 4 bits
+        const currentByte = encoded[byteIndex];
+        if (currentByte !== undefined) {
+          encoded[byteIndex] = currentByte | dropOffType | (pickUpType << 2);
+        }
+      }
+    }
+  }
+  return encoded;
+};
+
+/**
+ * Sorts trips by departure time and creates optimized typed arrays
+ */
+const finalizeRouteFromBuilder = (builder: RouteBuilder): SerializedRoute => {
+  builder.trips.sort((a, b) => a.firstDeparture - b.firstDeparture);
+
+  const stopsCount = builder.stops.length;
+  const tripsCount = builder.trips.length;
+  const stopsArray = new Uint32Array(builder.stops);
+  const stopTimesArray = new Uint16Array(stopsCount * tripsCount * 2);
+  const allPickUpTypes: SerializedPickUpDropOffType[] = [];
+  const allDropOffTypes: SerializedPickUpDropOffType[] = [];
+
+  for (let tripIndex = 0; tripIndex < tripsCount; tripIndex++) {
+    const trip = builder.trips[tripIndex];
+    if (!trip) {
+      throw new Error(`Missing trip data at index ${tripIndex}`);
+    }
+    const baseIndex = tripIndex * stopsCount * 2;
+
+    for (let stopIndex = 0; stopIndex < stopsCount; stopIndex++) {
+      const timeIndex = baseIndex + stopIndex * 2;
+      const arrivalTime = trip.arrivalTimes[stopIndex];
+      const departureTime = trip.departureTimes[stopIndex];
+      const pickUpType = trip.pickUpTypes[stopIndex];
+      const dropOffType = trip.dropOffTypes[stopIndex];
+
+      if (
+        arrivalTime === undefined ||
+        departureTime === undefined ||
+        pickUpType === undefined ||
+        dropOffType === undefined
+      ) {
+        throw new Error(
+          `Missing trip data for trip ${tripIndex} at stop ${stopIndex}`,
+        );
+      }
+
+      stopTimesArray[timeIndex] = arrivalTime;
+      stopTimesArray[timeIndex + 1] = departureTime;
+      allDropOffTypes.push(dropOffType);
+      allPickUpTypes.push(pickUpType);
+    }
+  }
+  // Use 2-bit encoding for pickup/drop-off types
+  const pickUpDropOffTypesArray = encodePickUpDropOffTypes(
+    allPickUpTypes,
+    allDropOffTypes,
+  );
+  return {
+    serviceRouteId: builder.serviceRouteId,
+    stops: stopsArray,
+    stopTimes: stopTimesArray,
+    pickUpDropOffTypes: pickUpDropOffTypesArray,
+  };
+};
+
 /**
  * Parses the trips.txt file from a GTFS feed
  *
  * @param tripsStream The readable stream containing the trips data.
  * @param serviceIds A mapping of service IDs to corresponding route IDs.
- * @param routeIds A mapping of route IDs to route details.
+ * @param serviceRoutes A mapping of route IDs to route details.
  * @returns A mapping of trip IDs to corresponding route IDs.
  */
 export const parseTrips = async (
   tripsStream: NodeJS.ReadableStream,
   serviceIds: ServiceIds,
-  routeIds: ServiceRoutesMap,
+  serviceRoutes: ServiceRoutesMap,
 ): Promise<TripIdsMap> => {
   const trips: TripIdsMap = new Map();
   for await (const rawLine of parseCsv(tripsStream, ['stop_sequence'])) {
@@ -69,7 +182,7 @@ export const parseTrips = async (
       // The trip doesn't correspond to an active service
       continue;
     }
-    if (!routeIds.get(line.route_id)) {
+    if (!serviceRoutes.get(line.route_id)) {
       // The trip doesn't correspond to a supported route
       continue;
     }
@@ -80,23 +193,27 @@ export const parseTrips = async (
 
 export const buildStopsAdjacencyStructure = (
   validStops: Set<StopId>,
-  routes: RoutesAdjacency,
+  serviceRoutes: ServiceRoutesMap,
+  routes: Route[],
   transfersMap: TransfersMap,
 ): StopsAdjacency => {
   const stopsAdjacency: StopsAdjacency = new Map();
-  for (const routeId of routes.keys()) {
-    const route = routes.get(routeId);
-    if (!route) {
-      throw new Error(`Route ${routeId} not found`);
-    }
+  routes.forEach((route, index) => {
     for (const stop of route.stopsIterator()) {
       if (!stopsAdjacency.get(stop) && validStops.has(stop)) {
         stopsAdjacency.set(stop, { routes: [], transfers: [] });
       }
 
-      stopsAdjacency.get(stop)?.routes.push(routeId);
+      stopsAdjacency.get(stop)?.routes.push(index);
     }
-  }
+    const serviceRoute = serviceRoutes.get(route.serviceRoute());
+    if (!serviceRoute) {
+      throw new Error(
+        `Service route ${route.serviceRoute()} not found for route ${index}.`,
+      );
+    }
+    serviceRoute.routes.push(index);
+  });
   for (const [stop, transfers] of transfersMap) {
     const s = stopsAdjacency.get(stop);
     if (s) {
@@ -124,13 +241,14 @@ export const parseStopTimes = async (
   stopsMap: ParsedStopsMap,
   validTripIds: TripIdsMap,
   validStopIds: Set<StopId>,
-): Promise<RoutesAdjacency> => {
+): Promise<Route[]> => {
   /**
-   * Inserts a trip at the right place in the routes adjacency structure.
+   * Adds a trip to the appropriate route builder
    */
   const addTrip = (currentTripId: TripId) => {
     const gtfsRouteId = validTripIds.get(currentTripId);
-    if (!gtfsRouteId) {
+
+    if (!gtfsRouteId || stops.length === 0) {
       stops = [];
       arrivalTimes = [];
       departureTimes = [];
@@ -138,90 +256,41 @@ export const parseStopTimes = async (
       dropOffTypes = [];
       return;
     }
+
     const routeId = `${gtfsRouteId}_${hashIds(stops)}`;
 
-    let route = routes.get(routeId);
-    if (!route) {
-      const stopsCount = stops.length;
-      const stopsArray = new Uint32Array(stops);
-      const stopTimesArray = new Uint16Array(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 = {
+    const firstDeparture = departureTimes[0];
+    if (firstDeparture === undefined) {
+      console.warn(`Empty trip ${currentTripId}`);
+      stops = [];
+      arrivalTimes = [];
+      departureTimes = [];
+      pickUpTypes = [];
+      dropOffTypes = [];
+      return;
+    }
+
+    let routeBuilder = routeBuilders.get(routeId);
+    if (!routeBuilder) {
+      routeBuilder = {
         serviceRouteId: gtfsRouteId,
-        stops: stopsArray,
-        stopTimes: stopTimesArray,
-        pickUpDropOffTypes: pickUpDropOffTypesArray,
+        stops: [...stops],
+        trips: [],
       };
-      routes.set(routeId, route);
+      routeBuilders.set(routeId, routeBuilder);
       for (const stop of stops) {
         validStopIds.add(stop);
       }
-    } else {
-      const tripFirstStopDeparture = departureTimes[0];
-      if (tripFirstStopDeparture === undefined) {
-        throw new Error(`Empty trip ${currentTripId}`);
-      }
-
-      // 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;
-        }
-      }
+    }
 
-      // insert data for the new trip at the right place
-      const newStopTimesLength = route.stopTimes.length + stopsCount * 2;
-      const newStopTimes = new Uint16Array(newStopTimesLength);
-      const newPickUpDropOffTypes = new Uint8Array(newStopTimesLength);
+    routeBuilder.trips.push({
+      firstDeparture,
+      arrivalTimes: [...arrivalTimes],
+      departureTimes: [...departureTimes],
+      pickUpTypes: [...pickUpTypes],
+      dropOffTypes: [...dropOffTypes],
+    });
 
-      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 = [];
     arrivalTimes = [];
     departureTimes = [];
@@ -229,7 +298,8 @@ export const parseStopTimes = async (
     dropOffTypes = [];
   };
 
-  const routes: Map<RouteId, SerializedRoute> = new Map();
+  type BuilderRouteId = string;
+  const routeBuilders: Map<BuilderRouteId, RouteBuilder> = new Map();
 
   let previousSeq = 0;
   let stops: StopId[] = [];
@@ -242,7 +312,9 @@ export const parseStopTimes = async (
   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}.`);
+      console.warn(
+        `Stop sequences not increasing for trip ${line.trip_id}: ${line.stop_sequence} > ${previousSeq}.`,
+      );
       continue;
     }
     if (!line.arrival_time && !line.departure_time) {
@@ -251,21 +323,32 @@ export const parseStopTimes = async (
       );
       continue;
     }
-    if (line.pickup_type === 1 && line.drop_off_type === 1) {
+    if (line.pickup_type === '1' && line.drop_off_type === '1') {
       continue;
     }
     if (currentTripId && line.trip_id !== currentTripId && stops.length > 0) {
       addTrip(currentTripId);
     }
     currentTripId = line.trip_id;
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    stops.push(stopsMap.get(line.stop_id)!.id);
+
+    const stopData = stopsMap.get(line.stop_id);
+    if (!stopData) {
+      console.warn(`Unknown stop ID: ${line.stop_id}`);
+      continue;
+    }
+    stops.push(stopData.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
-    arrivalTimes.push(toTime(arrival!).toMinutes());
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    departureTimes.push(toTime(departure!).toMinutes());
+
+    if (!arrival || !departure) {
+      console.warn(
+        `Missing time data for ${line.trip_id} at stop ${line.stop_id}`,
+      );
+      continue;
+    }
+    arrivalTimes.push(toTime(arrival).toMinutes());
+    departureTimes.push(toTime(departure).toMinutes());
     pickUpTypes.push(parsePickupDropOffType(line.pickup_type));
     dropOffTypes.push(parsePickupDropOffType(line.drop_off_type));
 
@@ -275,10 +358,10 @@ export const parseStopTimes = async (
     addTrip(currentTripId);
   }
 
-  const routesAdjacency: RoutesAdjacency = new Map<RouteId, Route>();
-  for (const [routeId, routeData] of routes) {
-    routesAdjacency.set(
-      routeId,
+  const routesAdjacency: Route[] = [];
+  for (const [, routeBuilder] of routeBuilders) {
+    const routeData = finalizeRouteFromBuilder(routeBuilder);
+    routesAdjacency.push(
       new Route(
         routeData.stopTimes,
         routeData.pickUpDropOffTypes,
@@ -296,13 +379,13 @@ const parsePickupDropOffType = (
   switch (gtfsType) {
     default:
       return REGULAR;
-    case 0:
+    case '0':
       return REGULAR;
-    case 1:
+    case '1':
       return NOT_AVAILABLE;
-    case 2:
+    case '2':
       return MUST_PHONE_AGENCY;
-    case 3:
+    case '3':
       return MUST_COORDINATE_WITH_DRIVER;
   }
 };

package/src/router.ts

@@ -12,7 +12,7 @@ import { Duration } from './timetable/duration.js';
 import { Time } from './timetable/time.js';
 import type {
   RouteType,
-  ServiceRoute,
+  ServiceRouteInfo,
   TransferType,
 } from './timetable/timetable.js';
 import { Timetable } from './timetable/timetable.js';
@@ -34,7 +34,7 @@ export type {
   LocationType,
   ReachingTime,
   RouteType,
-  ServiceRoute,
+  ServiceRouteInfo,
   SourceStopId,
   Stop,
   StopId,

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

@@ -4,7 +4,7 @@ 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 { ServiceRouteInfo, TransferType } from '../../timetable/timetable.js';
 import { Route } from '../route.js';
 
 describe('Route', () => {
@@ -40,12 +40,12 @@ describe('Route', () => {
     children: [],
   };
 
-  const serviceRoute: ServiceRoute = {
+  const serviceRoute: ServiceRouteInfo = {
     type: 'BUS',
     name: 'Route 1',
   };
 
-  const serviceRoute2: ServiceRoute = {
+  const serviceRoute2: ServiceRouteInfo = {
     type: 'RAIL',
     name: 'Route 2',
   };