gtfs-to-html 2.2.0 → 2.3.2

package/lib/utils.js

@@ -1,24 +1,92 @@
 import { readFileSync } from 'node:fs';
 
-import { cloneDeep, compact, every, find, findLast, first, flatMap, flattenDeep, isEqual, groupBy, last, maxBy, reduce, size, some, sortBy, uniq, uniqBy } from 'lodash-es';
-import { getCalendarDates, getTrips, getTimetableNotesReferences, getTimetableNotes, getRoutes, getDb, getCalendars, getTimetableStopOrders, getStops, getStopAttributes, getStoptimes, getFrequencies, getTimetables, getTimetablePages, getAgencies } from 'gtfs';
+import {
+  cloneDeep,
+  compact,
+  every,
+  find,
+  findLast,
+  first,
+  flatMap,
+  flattenDeep,
+  isEqual,
+  groupBy,
+  last,
+  maxBy,
+  reduce,
+  size,
+  some,
+  sortBy,
+  uniq,
+  uniqBy,
+  zip,
+} from 'lodash-es';
+import {
+  getCalendarDates,
+  getTrips,
+  getTimetableNotesReferences,
+  getTimetableNotes,
+  getRoutes,
+  getDb,
+  getCalendars,
+  getTimetableStopOrders,
+  getStops,
+  getStopAttributes,
+  getStoptimes,
+  getFrequencies,
+  getTimetables,
+  getTimetablePages,
+  getAgencies,
+} from 'gtfs';
+import { stringify } from 'csv-stringify';
 import moment from 'moment';
 import sqlString from 'sqlstring';
 import toposort from 'toposort';
 
 import { generateFileName, renderTemplate } from './file-utils.js';
-import { formatDate, formatDays, formatDaysLong, formatFrequency, formatStops, formatTimetableId, formatTimetableLabel, formatTimetablePageLabel, formatTrip, isNullOrEmpty, mergeTimetablesWithSameId, resetStoptimesToMidnight, timeToSeconds, updateStoptimesByOffset } from './formatters.js';
+import {
+  formatDate,
+  formatDays,
+  formatDaysLong,
+  formatFrequency,
+  formatStopName,
+  formatStops,
+  formatTimetableId,
+  formatTimetableLabel,
+  formatTimetablePageLabel,
+  formatTrip,
+  formatTripContinuesAs,
+  formatTripContinuesFrom,
+  isNullOrEmpty,
+  mergeTimetablesWithSameId,
+  resetStoptimesToMidnight,
+  timeToSeconds,
+  updateStoptimesByOffset,
+} from './formatters.js';
 import { getTimetableGeoJSON, getAgencyGeoJSON } from './geojson-utils.js';
-import { fromGTFSDate, toGTFSDate, calendarToCalendarCode, secondsAfterMidnight, fromGTFSTime, calendarCodeToCalendar } from './time-utils.js';
-
-const { version } = JSON.parse(readFileSync(new URL('../package.json', import.meta.url)));
+import {
+  fromGTFSDate,
+  toGTFSDate,
+  calendarToCalendarCode,
+  secondsAfterMidnight,
+  fromGTFSTime,
+  calendarCodeToCalendar,
+} from './time-utils.js';
+import { formatTripNameForCSV } from './template-functions.js';
+
+const { version } = JSON.parse(
+  readFileSync(new URL('../package.json', import.meta.url))
+);
 
 /*
  * Determine if a stoptime is a timepoint.
  */
-const isTimepoint = stoptime => {
+const isTimepoint = (stoptime) => {
   if (isNullOrEmpty(stoptime.timepoint)) {
-    return !isNullOrEmpty(stoptime.arrival_time) && !isNullOrEmpty(stoptime.departure_time);
+    return (
+      !isNullOrEmpty(stoptime.arrival_time) &&
+      !isNullOrEmpty(stoptime.departure_time)
+    );
   }
 
   return stoptime.timepoint === 1;
@@ -29,9 +97,14 @@ const isTimepoint = stoptime => {
  */
 const getLongestTripStoptimes = (trips, config) => {
   // If `showOnlyTimepoint` is true, then filter out all non-timepoints.
-  const filteredTripStoptimes = config.showOnlyTimepoint === true ? trips.map(trip => trip.stoptimes.filter(stoptime => isTimepoint(stoptime))) : trips.map(trip => trip.stoptimes);
-
-  return maxBy(filteredTripStoptimes, stoptimes => size(stoptimes));
+  const filteredTripStoptimes =
+    config.showOnlyTimepoint === true
+      ? trips.map((trip) =>
+          trip.stoptimes.filter((stoptime) => isTimepoint(stoptime))
+        )
+      : trips.map((trip) => trip.stoptimes);
+
+  return maxBy(filteredTripStoptimes, (stoptimes) => size(stoptimes));
 };
 
 /*
@@ -57,7 +130,13 @@ const findCommonStopId = (trips, config) => {
     }
 
     // Check if all trips have this stoptime and that they have a time.
-    return every(trips, trip => trip.stoptimes.find(tripStoptime => tripStoptime.stop_id === stoptime.stop_id && tripStoptime.arrival_time !== null));
+    return every(trips, (trip) =>
+      trip.stoptimes.find(
+        (tripStoptime) =>
+          tripStoptime.stop_id === stoptime.stop_id &&
+          tripStoptime.arrival_time !== null
+      )
+    );
   });
 
   return commonStoptime ? commonStoptime.stop_id : null;
@@ -77,15 +156,17 @@ const deduplicateTrips = (trips, commonStopId) => {
       continue;
     }
 
-    const stoptimes = trip.stoptimes.map(stoptime => stoptime.departure_time);
-    const selectedStoptime = commonStopId ? find(trip.stoptimes, {
-      stop_id: commonStopId
-    }) : trip.stoptimes[0];
+    const stoptimes = trip.stoptimes.map((stoptime) => stoptime.departure_time);
+    const selectedStoptime = commonStopId
+      ? find(trip.stoptimes, {
+          stop_id: commonStopId,
+        })
+      : trip.stoptimes[0];
 
     // Find all other trips where the common stop has the same departure time.
-    const similarTrips = deduplicatedTrips.filter(trip => {
+    const similarTrips = deduplicatedTrips.filter((trip) => {
       const stoptime = find(trip.stoptimes, {
-        stop_id: selectedStoptime.stop_id
+        stop_id: selectedStoptime.stop_id,
       });
       if (!stoptime) {
         return false;
@@ -95,8 +176,10 @@ const deduplicateTrips = (trips, commonStopId) => {
     });
 
     // Only add trip if no existing trip with the same set of timepoints has already been added.
-    const tripIsUnique = every(similarTrips, similarTrip => {
-      const similarTripStoptimes = similarTrip.stoptimes.map(stoptime => stoptime.departure_time);
+    const tripIsUnique = every(similarTrips, (similarTrip) => {
+      const similarTripStoptimes = similarTrip.stoptimes.map(
+        (stoptime) => stoptime.departure_time
+      );
       return !isEqual(stoptimes, similarTripStoptimes);
     });
 
@@ -124,7 +207,10 @@ const sortTrips = (trips, config) => {
       sortedTrips = sortTripsByStoptimeAtStop(trips, commonStopId);
     } else {
       // Default to 'beginning' if no common stop is found.
-      sortedTrips = sortTrips(trips, { ...config, sortingAlgorithm: 'beginning' });
+      sortedTrips = sortTrips(trips, {
+        ...config,
+        sortingAlgorithm: 'beginning',
+      });
     }
   } else if (config.sortingAlgorithm === 'beginning') {
     // Sort trips chronologically using first stoptime of each trip, which can be at different stops.
@@ -138,7 +224,11 @@ const sortTrips = (trips, config) => {
       trip.lastStoptime = timeToSeconds(last(trip.stoptimes).departure_time);
     }
 
-    sortedTrips = sortBy(trips, ['firstStoptime', 'lastStoptime'], ['asc', 'asc']);
+    sortedTrips = sortBy(
+      trips,
+      ['firstStoptime', 'lastStoptime'],
+      ['asc', 'asc']
+    );
   } else if (config.sortingAlgorithm === 'end') {
     // Sort trips chronologically using last stoptime of each trip, which can be at different stops.
 
@@ -151,7 +241,11 @@ const sortTrips = (trips, config) => {
       trip.lastStoptime = timeToSeconds(last(trip.stoptimes).departure_time);
     }
 
-    sortedTrips = sortBy(trips, ['lastStoptime', 'firstStoptime'], ['asc', 'asc']);
+    sortedTrips = sortBy(
+      trips,
+      ['lastStoptime', 'firstStoptime'],
+      ['asc', 'asc']
+    );
   } else if (config.sortingAlgorithm === 'first') {
     // Sort trips chronologically using the stoptime of a the first stop of the longest trip.
 
@@ -172,33 +266,40 @@ const sortTrips = (trips, config) => {
 /*
  * Sort trips by stoptime at a specific stop
  */
-const sortTripsByStoptimeAtStop = (trips, stopId) => sortBy(trips, trip => {
-  const stoptime = find(trip.stoptimes, { stop_id: stopId });
-  return stoptime ? timeToSeconds(stoptime.departure_time) : undefined;
-});
+const sortTripsByStoptimeAtStop = (trips, stopId) =>
+  sortBy(trips, (trip) => {
+    const stoptime = find(trip.stoptimes, { stop_id: stopId });
+    return stoptime ? timeToSeconds(stoptime.departure_time) : undefined;
+  });
 
 /*
  * Get all calendar dates for a specific timetable.
  */
 const getCalendarDatesForTimetable = async (timetable, config) => {
-  const calendarDates = await getCalendarDates({
-    service_id: timetable.service_ids
-  }, [], [
-    ['date', 'ASC']
-  ]);
+  const calendarDates = await getCalendarDates(
+    {
+      service_id: timetable.service_ids,
+    },
+    [],
+    [['date', 'ASC']]
+  );
   const start = fromGTFSDate(timetable.start_date);
   const end = fromGTFSDate(timetable.end_date);
   const filteredCalendarDates = {
     excludedDates: [],
-    includedDates: []
+    includedDates: [],
   };
 
   for (const calendarDate of calendarDates) {
     if (moment(calendarDate.date, 'YYYYMMDD').isBetween(start, end)) {
       if (calendarDate.exception_type === 1) {
-        filteredCalendarDates.includedDates.push(formatDate(calendarDate, config.dateFormat));
+        filteredCalendarDates.includedDates.push(
+          formatDate(calendarDate, config.dateFormat)
+        );
       } else if (calendarDate.exception_type === 2) {
-        filteredCalendarDates.excludedDates.push(formatDate(calendarDate, config.dateFormat));
+        filteredCalendarDates.excludedDates.push(
+          formatDate(calendarDate, config.dateFormat)
+        );
       }
     }
   }
@@ -209,7 +310,7 @@ const getCalendarDatesForTimetable = async (timetable, config) => {
 /*
  * Get days of the week from calendars.
  */
-const getDaysFromCalendars = calendars => {
+const getDaysFromCalendars = (calendars) => {
   const days = {
     monday: 0,
     tuesday: 0,
@@ -217,7 +318,7 @@ const getDaysFromCalendars = calendars => {
     thursday: 0,
     friday: 0,
     saturday: 0,
-    sunday: 0
+    sunday: 0,
   };
 
   for (const calendar of calendars) {
@@ -233,13 +334,14 @@ const getDaysFromCalendars = calendars => {
 /*
  * Get the `trip_headsign` for a specific timetable.
  */
-const getDirectionHeadsignFromTimetable = async timetable => {
-  const trips = await getTrips({
-    direction_id: timetable.direction_id,
-    route_id: timetable.route_ids
-  }, [
-    'trip_headsign'
-  ]);
+const getDirectionHeadsignFromTimetable = async (timetable) => {
+  const trips = await getTrips(
+    {
+      direction_id: timetable.direction_id,
+      route_id: timetable.route_ids,
+    },
+    ['trip_headsign']
+  );
 
   if (trips.length === 0) {
     return '';
@@ -254,51 +356,60 @@ const getDirectionHeadsignFromTimetable = async timetable => {
 const getTimetableNotesForTimetable = async (timetable, config) => {
   const noteReferences = [
     // Get all notes for this timetable.
-    ...await getTimetableNotesReferences({
-      timetable_id: timetable.timetable_id
-    }),
+    ...(await getTimetableNotesReferences({
+      timetable_id: timetable.timetable_id,
+    })),
 
     // Get all notes for this route.
-    ...await getTimetableNotesReferences({
-      route_id: timetable.routes.map(route => route.route_id),
-      timetable_id: null
-    }),
+    ...(await getTimetableNotesReferences({
+      route_id: timetable.routes.map((route) => route.route_id),
+      timetable_id: null,
+    })),
 
     // Get all notes for all trips in this timetable.
-    ...await getTimetableNotesReferences({
-      trip_id: timetable.orderedTrips.map(trip => trip.trip_id)
-    }),
+    ...(await getTimetableNotesReferences({
+      trip_id: timetable.orderedTrips.map((trip) => trip.trip_id),
+    })),
 
     // Get all notes for all stops in this timetable.
-    ...await getTimetableNotesReferences({
-      stop_id: timetable.stops.map(stop => stop.stop_id),
+    ...(await getTimetableNotesReferences({
+      stop_id: timetable.stops.map((stop) => stop.stop_id),
       trip_id: null,
       route_id: null,
-      timetable_id: null
-    })
+      timetable_id: null,
+    })),
   ];
 
   const usedNoteReferences = [];
   // Check if stop_sequence matches any trip.
   for (const noteReference of noteReferences) {
-    if (noteReference.stop_sequence === '' || noteReference.stop_sequence === null) {
+    if (
+      noteReference.stop_sequence === '' ||
+      noteReference.stop_sequence === null
+    ) {
       usedNoteReferences.push(noteReference);
       continue;
     }
 
     // Note references with stop_sequence must also have stop_id.
     if (noteReference.stop_id === '' || noteReference.stop_id === null) {
-      config.logWarning(`Timetable Note Reference for note_id=${noteReference.note_id} has a \`stop_sequence\` but no \`stop_id\` - ignoring`);
+      config.logWarning(
+        `Timetable Note Reference for note_id=${noteReference.note_id} has a \`stop_sequence\` but no \`stop_id\` - ignoring`
+      );
       continue;
     }
 
-    const stop = timetable.stops.find(stop => stop.stop_id === noteReference.stop_id);
+    const stop = timetable.stops.find(
+      (stop) => stop.stop_id === noteReference.stop_id
+    );
 
     if (!stop) {
       continue;
     }
 
-    const tripWithMatchingStopSequence = stop.trips.find(trip => trip.stop_sequence === noteReference.stop_sequence);
+    const tripWithMatchingStopSequence = stop.trips.find(
+      (trip) => trip.stop_sequence === noteReference.stop_sequence
+    );
 
     if (tripWithMatchingStopSequence) {
       usedNoteReferences.push(noteReference);
@@ -306,7 +417,7 @@ const getTimetableNotesForTimetable = async (timetable, config) => {
   }
 
   const notes = await getTimetableNotes({
-    note_id: usedNoteReferences.map(noteReference => noteReference.note_id)
+    note_id: usedNoteReferences.map((noteReference) => noteReference.note_id),
   });
 
   // Assign symbols to each note if unassigned. Use a-z then default to integers.
@@ -314,14 +425,17 @@ const getTimetableNotesForTimetable = async (timetable, config) => {
   let symbolIndex = 0;
   for (const note of notes) {
     if (note.symbol === '' || note.symbol === null) {
-      note.symbol = symbolIndex < (symbols.length - 1) ? symbols[symbolIndex] : (symbolIndex - symbols.length);
+      note.symbol =
+        symbolIndex < symbols.length - 1
+          ? symbols[symbolIndex]
+          : symbolIndex - symbols.length;
       symbolIndex += 1;
     }
   }
 
-  const formattedNotes = usedNoteReferences.map(noteReference => ({
+  const formattedNotes = usedNoteReferences.map((noteReference) => ({
     ...noteReference,
-    ...notes.find(note => note.note_id === noteReference.note_id)
+    ...notes.find((note) => note.note_id === noteReference.note_id),
   }));
 
   return sortBy(formattedNotes, 'symbol');
@@ -334,7 +448,7 @@ const getTimetableNotesForTimetable = async (timetable, config) => {
 const convertTimetableToTimetablePage = async (timetable, config) => {
   if (!timetable.routes) {
     timetable.routes = await getRoutes({
-      route_id: timetable.route_ids
+      route_id: timetable.route_ids,
     });
   }
 
@@ -344,7 +458,7 @@ const convertTimetableToTimetablePage = async (timetable, config) => {
     timetable_page_id: timetable.timetable_id,
     timetable_page_label: timetable.timetable_label,
     timetables: [timetable],
-    filename
+    filename,
   };
 };
 
@@ -353,14 +467,23 @@ const convertTimetableToTimetablePage = async (timetable, config) => {
  * is present.
  */
 /* eslint-disable max-params */
-const convertRouteToTimetablePage = (route, direction, calendars, calendarDates, config) => {
+const convertRouteToTimetablePage = (
+  route,
+  direction,
+  calendars,
+  calendarDates,
+  config
+) => {
   const timetable = {
     route_ids: [route.route_id],
     direction_id: direction ? direction.direction_id : undefined,
     direction_name: direction ? direction.trip_headsign : undefined,
     routes: [route],
-    include_exceptions: (calendarDates && calendarDates.length > 0) ? 1 : 0,
-    service_id: (calendarDates && calendarDates.length > 0) ? calendarDates[0].service_id : null,
+    include_exceptions: calendarDates && calendarDates.length > 0 ? 1 : 0,
+    service_id:
+      calendarDates && calendarDates.length > 0
+        ? calendarDates[0].service_id
+        : null,
     service_notes: null,
     timetable_label: null,
     start_time: null,
@@ -369,7 +492,7 @@ const convertRouteToTimetablePage = (route, direction, calendars, calendarDates,
     timetable_sequence: null,
     show_trip_continuation: null,
     start_date: null,
-    end_date: null
+    end_date: null,
   };
   /* eslint-enable max-params */
 
@@ -377,8 +500,12 @@ const convertRouteToTimetablePage = (route, direction, calendars, calendarDates,
     // Get days of week from calendars and assign to timetable.
     Object.assign(timetable, getDaysFromCalendars(calendars));
 
-    timetable.start_date = toGTFSDate(moment.min(calendars.map(calendar => fromGTFSDate(calendar.start_date))));
-    timetable.end_date = toGTFSDate(moment.max(calendars.map(calendar => fromGTFSDate(calendar.end_date))));
+    timetable.start_date = toGTFSDate(
+      moment.min(calendars.map((calendar) => fromGTFSDate(calendar.start_date)))
+    );
+    timetable.end_date = toGTFSDate(
+      moment.max(calendars.map((calendar) => fromGTFSDate(calendar.end_date)))
+    );
   }
 
   timetable.timetable_id = formatTimetableId(timetable);
@@ -390,31 +517,61 @@ const convertRouteToTimetablePage = (route, direction, calendars, calendarDates,
  * Create timetable pages for all routes in an agency. Used if no
  * `timetables.txt` is present.
  */
-const convertRoutesToTimetablePages = async config => {
+const convertRoutesToTimetablePages = async (config) => {
   const db = getDb();
   const routes = await getRoutes();
   const calendars = await getCalendars();
 
   // Find all calendar dates with service_ids not present in `calendar.txt`.
-  const serviceIds = calendars.map(calendar => calendar.service_id);
-  const calendarDates = await db.all(`SELECT * FROM calendar_dates WHERE exception_type = 1 AND service_id NOT IN (${serviceIds.map(serviceId => `'${serviceId}'`).join(', ')})`);
-
-  const timetablePages = await Promise.all(routes.map(async route => {
-    const trips = await getTrips({
-      route_id: route.route_id
-    }, [
-      'trip_headsign',
-      'direction_id'
-    ]);
-    const directions = uniqBy(trips, trip => trip.direction_id);
-    const dayGroups = groupBy(calendars, calendarToCalendarCode);
-    const calendarDateGroups = groupBy(calendarDates, 'service_id');
-
-    return Promise.all(directions.map(direction => Promise.all([
-      Promise.all(Object.values(dayGroups).map(calendars => convertRouteToTimetablePage(route, direction, calendars, null, config))),
-      Promise.all(Object.values(calendarDateGroups).map(calendarDates => convertRouteToTimetablePage(route, direction, null, calendarDates, config)))
-    ])));
-  }));
+  const serviceIds = calendars.map((calendar) => calendar.service_id);
+  const calendarDates = await db.all(
+    `SELECT * FROM calendar_dates WHERE exception_type = 1 AND service_id NOT IN (${serviceIds
+      .map((serviceId) => `'${serviceId}'`)
+      .join(', ')})`
+  );
+
+  const timetablePages = await Promise.all(
+    routes.map(async (route) => {
+      const trips = await getTrips(
+        {
+          route_id: route.route_id,
+        },
+        ['trip_headsign', 'direction_id']
+      );
+      const directions = uniqBy(trips, (trip) => trip.direction_id);
+      const dayGroups = groupBy(calendars, calendarToCalendarCode);
+      const calendarDateGroups = groupBy(calendarDates, 'service_id');
+
+      return Promise.all(
+        directions.map((direction) =>
+          Promise.all([
+            Promise.all(
+              Object.values(dayGroups).map((calendars) =>
+                convertRouteToTimetablePage(
+                  route,
+                  direction,
+                  calendars,
+                  null,
+                  config
+                )
+              )
+            ),
+            Promise.all(
+              Object.values(calendarDateGroups).map((calendarDates) =>
+                convertRouteToTimetablePage(
+                  route,
+                  direction,
+                  null,
+                  calendarDates,
+                  config
+                )
+              )
+            ),
+          ])
+        )
+      );
+    })
+  );
 
   return compact(flattenDeep(timetablePages));
 };
@@ -423,7 +580,9 @@ const convertRoutesToTimetablePages = async config => {
  * Generate all trips based on a start trip and an array of frequencies.
  */
 const generateTripsByFrequencies = (trip, frequencies, config) => {
-  const formattedFrequencies = frequencies.map(frequency => formatFrequency(frequency, config));
+  const formattedFrequencies = frequencies.map((frequency) =>
+    formatFrequency(frequency, config)
+  );
   const resetTrip = resetStoptimesToMidnight(trip);
   const trips = [];
 
@@ -431,12 +590,16 @@ const generateTripsByFrequencies = (trip, frequencies, config) => {
     const startSeconds = secondsAfterMidnight(frequency.start_time);
     const endSeconds = secondsAfterMidnight(frequency.end_time);
 
-    for (let offset = startSeconds; offset < endSeconds; offset += frequency.headway_secs) {
+    for (
+      let offset = startSeconds;
+      offset < endSeconds;
+      offset += frequency.headway_secs
+    ) {
       const newTrip = cloneDeep(resetTrip);
       trips.push({
         ...newTrip,
         trip_id: `${resetTrip.trip_id}_freq_${trips.length}`,
-        stoptimes: updateStoptimesByOffset(newTrip, offset)
+        stoptimes: updateStoptimesByOffset(newTrip, offset),
       });
     }
   }
@@ -448,12 +611,22 @@ const generateTripsByFrequencies = (trip, frequencies, config) => {
  * Check if any stoptimes have different arrival and departure times and
  * if they do, duplicate the stop id unless it is the first or last stop.
  */
-const duplicateStopsForDifferentArrivalDeparture = (stopIds, timetable, config) => {
+const duplicateStopsForDifferentArrivalDeparture = (
+  stopIds,
+  timetable,
+  config
+) => {
   for (const trip of timetable.orderedTrips) {
     for (const stoptime of trip.stoptimes) {
-      const timepointDifference = fromGTFSTime(stoptime.departure_time).diff(fromGTFSTime(stoptime.arrival_time), 'minutes');
-
-      if (config.showArrivalOnDifference === null || timepointDifference < config.showArrivalOnDifference) {
+      const timepointDifference = fromGTFSTime(stoptime.departure_time).diff(
+        fromGTFSTime(stoptime.arrival_time),
+        'minutes'
+      );
+
+      if (
+        config.showArrivalOnDifference === null ||
+        timepointDifference < config.showArrivalOnDifference
+      ) {
         continue;
       }
 
@@ -462,7 +635,10 @@ const duplicateStopsForDifferentArrivalDeparture = (stopIds, timetable, config)
         continue;
       }
 
-      if (stoptime.stop_id === stopIds[index + 1] || stoptime.stop_id === stopIds[index - 1]) {
+      if (
+        stoptime.stop_id === stopIds[index + 1] ||
+        stoptime.stop_id === stopIds[index - 1]
+      ) {
         continue;
       }
 
@@ -478,18 +654,18 @@ const duplicateStopsForDifferentArrivalDeparture = (stopIds, timetable, config)
  */
 const getStopOrder = async (timetable, config) => {
   // First, check if `timetable_stop_order.txt` for route exists
-  const timetableStopOrders = await getTimetableStopOrders({
-    timetable_id: timetable.timetable_id
-  },
-  [
-    'stop_id'
-  ],
-  [
-    ['stop_sequence', 'ASC']
-  ]);
+  const timetableStopOrders = await getTimetableStopOrders(
+    {
+      timetable_id: timetable.timetable_id,
+    },
+    ['stop_id'],
+    [['stop_sequence', 'ASC']]
+  );
 
   if (timetableStopOrders.length > 0) {
-    return timetableStopOrders.map(timetableStopOrder => timetableStopOrder.stop_id);
+    return timetableStopOrders.map(
+      (timetableStopOrder) => timetableStopOrder.stop_id
+    );
   }
 
   // Next, try using a directed graph to determine stop order.
@@ -498,7 +674,12 @@ const getStopOrder = async (timetable, config) => {
 
     for (const trip of timetable.orderedTrips) {
       // If `showOnlyTimepoint` is true, then filter out all non-timepoints.
-      const sortedStopIds = config.showOnlyTimepoint === true ? trip.stoptimes.filter(stoptime => isTimepoint(stoptime)).map(stoptime => stoptime.stop_id) : trip.stoptimes.map(stoptime => stoptime.stop_id);
+      const sortedStopIds =
+        config.showOnlyTimepoint === true
+          ? trip.stoptimes
+              .filter((stoptime) => isTimepoint(stoptime))
+              .map((stoptime) => stoptime.stop_id)
+          : trip.stoptimes.map((stoptime) => stoptime.stop_id);
 
       for (const [index, stopId] of sortedStopIds.entries()) {
         if (index === sortedStopIds.length - 1) {
@@ -511,14 +692,21 @@ const getStopOrder = async (timetable, config) => {
 
     const stopIds = toposort(stopGraph);
 
-    return duplicateStopsForDifferentArrivalDeparture(stopIds, timetable, config);
+    return duplicateStopsForDifferentArrivalDeparture(
+      stopIds,
+      timetable,
+      config
+    );
   } catch {
     // Ignore errors and move to next strategy.
   }
 
   // Finally, fall back to using the stop order from the trip with the most stoptimes.
-  const longestTripStoptimes = getLongestTripStoptimes(timetable.orderedTrips, config);
-  const stopIds = longestTripStoptimes.map(stoptime => stoptime.stop_id);
+  const longestTripStoptimes = getLongestTripStoptimes(
+    timetable.orderedTrips,
+    config
+  );
+  const stopIds = longestTripStoptimes.map((stoptime) => stoptime.stop_id);
 
   return duplicateStopsForDifferentArrivalDeparture(stopIds, timetable, config);
 };
@@ -532,37 +720,46 @@ const getStopsForTimetable = async (timetable, config) => {
   }
 
   const orderedStopIds = await getStopOrder(timetable, config);
-  const orderedStops = await Promise.all(orderedStopIds.map(async (stopId, index) => {
-    const stops = await getStops({
-      stop_id: stopId
-    });
-
-    if (stops.length === 0) {
-      throw new Error(`No stop found found for stop_id=${stopId} in timetable_id=${timetable.timetable_id}`);
-    }
+  const orderedStops = await Promise.all(
+    orderedStopIds.map(async (stopId, index) => {
+      const stops = await getStops({
+        stop_id: stopId,
+      });
 
-    const stop = {
-      ...stops[0],
-      trips: []
-    };
+      if (stops.length === 0) {
+        throw new Error(
+          `No stop found found for stop_id=${stopId} in timetable_id=${timetable.timetable_id}`
+        );
+      }
 
-    if (index < (orderedStopIds.length - 1) && stopId === orderedStopIds[index + 1]) {
-      stop.type = 'arrival';
-    } else if (index > 0 && stopId === orderedStopIds[index - 1]) {
-      stop.type = 'departure';
-    }
+      const stop = {
+        ...stops[0],
+        trips: [],
+      };
+
+      if (
+        index < orderedStopIds.length - 1 &&
+        stopId === orderedStopIds[index + 1]
+      ) {
+        stop.type = 'arrival';
+      } else if (index > 0 && stopId === orderedStopIds[index - 1]) {
+        stop.type = 'departure';
+      }
 
-    return stop;
-  }));
+      return stop;
+    })
+  );
 
   // If `showStopCity` is true, look up stop attributes.
   if (timetable.showStopCity) {
     const stopAttributes = await getStopAttributes({
-      stop_id: orderedStopIds
+      stop_id: orderedStopIds,
     });
 
     for (const stopAttribute of stopAttributes) {
-      const stop = orderedStops.find(stop => stop.stop_id === stopAttribute.stop_id);
+      const stop = orderedStops.find(
+        (stop) => stop.stop_id === stopAttribute.stop_id
+      );
 
       if (stop) {
         stop.stop_city = stopAttribute.stop_city;
@@ -576,7 +773,7 @@ const getStopsForTimetable = async (timetable, config) => {
 /*
  * Get all calendars from a specific timetable.
  */
-const getCalendarsFromTimetable = async timetable => {
+const getCalendarsFromTimetable = async (timetable) => {
   const db = getDb();
   let whereClause = '';
   const whereClauses = [];
@@ -591,13 +788,17 @@ const getCalendarsFromTimetable = async timetable => {
 
   const days = getDaysFromCalendars([timetable]);
   // Create an 'OR' query array of days based on calendars.
-  const dayQueries = reduce(days, (memo, value, key) => {
-    if (value === 1) {
-      memo.push(`${key} = 1`);
-    }
+  const dayQueries = reduce(
+    days,
+    (memo, value, key) => {
+      if (value === 1) {
+        memo.push(`${key} = 1`);
+      }
 
-    return memo;
-  }, []);
+      return memo;
+    },
+    []
+  );
 
   if (dayQueries.length > 0) {
     whereClauses.push(`(${dayQueries.join(' OR ')})`);
@@ -625,8 +826,12 @@ const getCalendarDatesServiceIds = async (startDate, endDate) => {
     whereClauses.push(`date >= ${sqlString.escape(startDate)}`);
   }
 
-  const calendarDates = await db.all(`SELECT DISTINCT service_id FROM calendar_dates WHERE ${whereClauses.join(' AND ')}`);
-  return calendarDates.map(calendarDate => calendarDate.service_id);
+  const calendarDates = await db.all(
+    `SELECT DISTINCT service_id FROM calendar_dates WHERE ${whereClauses.join(
+      ' AND '
+    )}`
+  );
+  return calendarDates.map((calendarDate) => calendarDate.service_id);
 };
 
 /*
@@ -634,9 +839,9 @@ const getCalendarDatesServiceIds = async (startDate, endDate) => {
  * and the stop_id of parent station itself. If no parent station, it returns the
  * stop_id.
  */
-const getAllStationStopIds = async stopId => {
+const getAllStationStopIds = async (stopId) => {
   const stops = await getStops({
-    stop_id: stopId
+    stop_id: stopId,
   });
 
   const stop = stops[0];
@@ -645,44 +850,53 @@ const getAllStationStopIds = async stopId => {
     return [stopId];
   }
 
-  const stopsInParentStation = await getStops({
-    parent_station: stop.parent_station
-  }, ['stop_id']);
+  const stopsInParentStation = await getStops(
+    {
+      parent_station: stop.parent_station,
+    },
+    ['stop_id']
+  );
 
-  return [stop.parent_station, ...stopsInParentStation.map(stop => stop.stop_id)];
+  return [
+    stop.parent_station,
+    ...stopsInParentStation.map((stop) => stop.stop_id),
+  ];
 };
 
 /*
  * Get trips with the same `block_id`.
  */
 const getTripsWithSameBlock = async (trip, timetable) => {
-  const trips = await getTrips({
-    block_id: trip.block_id,
-    service_id: timetable.service_ids
-  }, [
-    'trip_id',
-    'route_id'
-  ]);
-
-  await Promise.all(trips.map(async blockTrip => {
-    const stopTimes = await getStoptimes({
-      trip_id: blockTrip.trip_id
+  const trips = await getTrips(
+    {
+      block_id: trip.block_id,
+      service_id: timetable.service_ids,
     },
-    [],
-    [
-      ['stop_sequence', 'ASC']
-    ]
-    );
-
-    if (stopTimes.length === 0) {
-      throw new Error(`No stoptimes found found for trip_id=${blockTrip.trip_id}`);
-    }
+    ['trip_id', 'route_id']
+  );
+
+  await Promise.all(
+    trips.map(async (blockTrip) => {
+      const stopTimes = await getStoptimes(
+        {
+          trip_id: blockTrip.trip_id,
+        },
+        [],
+        [['stop_sequence', 'ASC']]
+      );
+
+      if (stopTimes.length === 0) {
+        throw new Error(
+          `No stoptimes found found for trip_id=${blockTrip.trip_id}`
+        );
+      }
 
-    blockTrip.firstStoptime = first(stopTimes);
-    blockTrip.lastStoptime = last(stopTimes);
-  }));
+      blockTrip.firstStoptime = first(stopTimes);
+      blockTrip.lastStoptime = last(stopTimes);
+    })
+  );
 
-  return sortBy(trips, trip => trip.firstStoptime.departure_timestamp);
+  return sortBy(trips, (trip) => trip.firstStoptime.departure_timestamp);
 };
 
 /*
@@ -703,7 +917,12 @@ const addTripContinuation = async (trip, timetable) => {
   const blockTrips = await getTripsWithSameBlock(trip, timetable);
 
   // "Continues From" trips must be the previous trip chronologically.
-  const previousTrip = findLast(blockTrips, blockTrip => blockTrip.lastStoptime.arrival_timestamp <= firstStoptime.departure_timestamp);
+  const previousTrip = findLast(
+    blockTrips,
+    (blockTrip) =>
+      blockTrip.lastStoptime.arrival_timestamp <=
+      firstStoptime.departure_timestamp
+  );
 
   /*
    * "Continues From" trips
@@ -711,9 +930,15 @@ const addTripContinuation = async (trip, timetable) => {
    * * must not be more than 60 minutes before
    * * must have their last stop_id be the same as the next trip's first stop_id
    */
-  if (previousTrip && previousTrip.route_id !== trip.route_id && previousTrip.lastStoptime.arrival_timestamp >= firstStoptime.departure_timestamp - maxContinuesAsWaitingTimeSeconds && firstStopIds.includes(previousTrip.lastStoptime.stop_id)) {
+  if (
+    previousTrip &&
+    previousTrip.route_id !== trip.route_id &&
+    previousTrip.lastStoptime.arrival_timestamp >=
+      firstStoptime.departure_timestamp - maxContinuesAsWaitingTimeSeconds &&
+    firstStopIds.includes(previousTrip.lastStoptime.stop_id)
+  ) {
     const routes = await getRoutes({
-      route_id: previousTrip.route_id
+      route_id: previousTrip.route_id,
     });
 
     previousTrip.route = routes[0];
@@ -722,7 +947,12 @@ const addTripContinuation = async (trip, timetable) => {
   }
 
   // "Continues As" trips must be the next trip chronologically.
-  const nextTrip = find(blockTrips, blockTrip => blockTrip.firstStoptime.departure_timestamp >= lastStoptime.arrival_timestamp);
+  const nextTrip = find(
+    blockTrips,
+    (blockTrip) =>
+      blockTrip.firstStoptime.departure_timestamp >=
+      lastStoptime.arrival_timestamp
+  );
 
   // "Continues As" trips must be a different route_id.
   /*
@@ -731,9 +961,15 @@ const addTripContinuation = async (trip, timetable) => {
    * * must not be more than 60 minutes later
    * * must have their first stop_id be the same as the previous trip's last stop_id
    */
-  if (nextTrip && nextTrip.route_id !== trip.route_id && nextTrip.firstStoptime.departure_timestamp <= lastStoptime.arrival_timestamp + maxContinuesAsWaitingTimeSeconds && lastStopIds.includes(nextTrip.firstStoptime.stop_id)) {
+  if (
+    nextTrip &&
+    nextTrip.route_id !== trip.route_id &&
+    nextTrip.firstStoptime.departure_timestamp <=
+      lastStoptime.arrival_timestamp + maxContinuesAsWaitingTimeSeconds &&
+    lastStopIds.includes(nextTrip.firstStoptime.stop_id)
+  ) {
     const routes = await getRoutes({
-      route_id: nextTrip.route_id
+      route_id: nextTrip.route_id,
     });
 
     nextTrip.route = routes[0];
@@ -745,17 +981,19 @@ const addTripContinuation = async (trip, timetable) => {
  * Apply time range filters to trips and remove trips with less than two stoptimes for stops used in this timetable.
  * Stops can be excluded by using `timetable_stop_order.txt`. Additionally, remove trip stoptimes for unused stops.
  */
-const filterTrips = timetable => {
+const filterTrips = (timetable) => {
   let filteredTrips = timetable.orderedTrips;
 
   // Remove stoptimes for stops not used in timetable
-  const timetableStopIds = new Set(timetable.stops.map(stop => stop.stop_id));
+  const timetableStopIds = new Set(timetable.stops.map((stop) => stop.stop_id));
   for (const trip of filteredTrips) {
-    trip.stoptimes = trip.stoptimes.filter(stoptime => timetableStopIds.has(stoptime.stop_id));
+    trip.stoptimes = trip.stoptimes.filter((stoptime) =>
+      timetableStopIds.has(stoptime.stop_id)
+    );
   }
 
   // Exclude trips with less than two stops
-  filteredTrips = filteredTrips.filter(trip => trip.stoptimes.length > 1);
+  filteredTrips = filteredTrips.filter((trip) => trip.stoptimes.length > 1);
 
   return filteredTrips;
 };
@@ -766,7 +1004,7 @@ const filterTrips = timetable => {
 const getTripsForTimetable = async (timetable, calendars, config) => {
   const tripQuery = {
     route_id: timetable.route_ids,
-    service_id: timetable.service_ids
+    service_id: timetable.service_ids,
   };
 
   if (!isNullOrEmpty(timetable.direction_id)) {
@@ -776,70 +1014,98 @@ const getTripsForTimetable = async (timetable, calendars, config) => {
   const trips = await getTrips(tripQuery);
 
   if (trips.length === 0) {
-    timetable.warnings.push(`No trips found for route_id=${timetable.route_ids.join('_')}, direction_id=${timetable.direction_id}, service_ids=${JSON.stringify(timetable.service_ids)}, timetable_id=${timetable.timetable_id}`);
+    timetable.warnings.push(
+      `No trips found for route_id=${timetable.route_ids.join(
+        '_'
+      )}, direction_id=${timetable.direction_id}, service_ids=${JSON.stringify(
+        timetable.service_ids
+      )}, timetable_id=${timetable.timetable_id}`
+    );
   }
 
   const frequencies = await getFrequencies({
-    trip_id: trips.map(trip => trip.trip_id)
+    trip_id: trips.map((trip) => trip.trip_id),
   });
 
   // Updated timetable.serviceIds with only the service IDs actually used in one or more trip.
-  timetable.service_ids = uniq(trips.map(trip => trip.service_id));
+  timetable.service_ids = uniq(trips.map((trip) => trip.service_id));
 
   const formattedTrips = [];
-  await Promise.all(trips.map(async trip => {
-    const formattedTrip = formatTrip(trip, timetable, calendars, config);
-    formattedTrip.stoptimes = await getStoptimes({
-      trip_id: formattedTrip.trip_id
-    },
-    [],
-    [
-      ['stop_sequence', 'ASC']
-    ]);
-
-    if (formattedTrip.stoptimes.length === 0) {
-      timetable.warnings.push(`No stoptimes found for trip_id=${formattedTrip.trip_id}, route_id=${timetable.route_ids.join('_')}, timetable_id=${timetable.timetable_id}`);
-    }
+  await Promise.all(
+    trips.map(async (trip) => {
+      const formattedTrip = formatTrip(trip, timetable, calendars, config);
+      formattedTrip.stoptimes = await getStoptimes(
+        {
+          trip_id: formattedTrip.trip_id,
+        },
+        [],
+        [['stop_sequence', 'ASC']]
+      );
+
+      if (formattedTrip.stoptimes.length === 0) {
+        timetable.warnings.push(
+          `No stoptimes found for trip_id=${
+            formattedTrip.trip_id
+          }, route_id=${timetable.route_ids.join('_')}, timetable_id=${
+            timetable.timetable_id
+          }`
+        );
+      }
 
-    // Exclude trips before timetable `start_timestamp`
-    if (timetable.start_timestamp !== '' && timetable.start_timestamp !== null && timetable.start_timestamp !== undefined) {
-      if (trip.stoptimes[0].arrival_timestamp < timetable.start_timestamp) {
-        return;
+      // Exclude trips before timetable `start_timestamp`
+      if (
+        timetable.start_timestamp !== '' &&
+        timetable.start_timestamp !== null &&
+        timetable.start_timestamp !== undefined
+      ) {
+        if (trip.stoptimes[0].arrival_timestamp < timetable.start_timestamp) {
+          return;
+        }
       }
-    }
 
-    // Exclude trips after timetable `end_timestamp`
-    if (timetable.end_timestamp !== '' && timetable.end_timestamp !== null && timetable.end_timestamp !== undefined) {
-      if (trip.stoptimes[0].arrival_timestamp >= timetable.end_timestamp) {
-        return;
+      // Exclude trips after timetable `end_timestamp`
+      if (
+        timetable.end_timestamp !== '' &&
+        timetable.end_timestamp !== null &&
+        timetable.end_timestamp !== undefined
+      ) {
+        if (trip.stoptimes[0].arrival_timestamp >= timetable.end_timestamp) {
+          return;
+        }
       }
-    }
 
-    if (timetable.show_trip_continuation) {
-      await addTripContinuation(formattedTrip, timetable);
+      if (timetable.show_trip_continuation) {
+        await addTripContinuation(formattedTrip, timetable);
 
-      if (formattedTrip.continues_as_route) {
-        timetable.has_continues_as_route = true;
-      }
+        if (formattedTrip.continues_as_route) {
+          timetable.has_continues_as_route = true;
+        }
 
-      if (formattedTrip.continues_from_route) {
-        timetable.has_continues_from_route = true;
+        if (formattedTrip.continues_from_route) {
+          timetable.has_continues_from_route = true;
+        }
       }
-    }
 
-    const tripFrequencies = frequencies.filter(frequency => frequency.trip_id === trip.trip_id);
-
-    if (tripFrequencies.length === 0) {
-      formattedTrips.push(formattedTrip);
-    } else {
-      const frequencyTrips = generateTripsByFrequencies(formattedTrip, frequencies, config);
-      formattedTrips.push(...frequencyTrips);
-      timetable.frequencies = frequencies;
-      timetable.frequencyExactTimes = some(frequencies, {
-        exact_times: 1
-      });
-    }
-  }));
+      const tripFrequencies = frequencies.filter(
+        (frequency) => frequency.trip_id === trip.trip_id
+      );
+
+      if (tripFrequencies.length === 0) {
+        formattedTrips.push(formattedTrip);
+      } else {
+        const frequencyTrips = generateTripsByFrequencies(
+          formattedTrip,
+          frequencies,
+          config
+        );
+        formattedTrips.push(...frequencyTrips);
+        timetable.frequencies = frequencies;
+        timetable.frequencyExactTimes = some(frequencies, {
+          exact_times: 1,
+        });
+      }
+    })
+  );
 
   if (config.useParentStation) {
     const stopIds = [];
@@ -850,18 +1116,20 @@ const getTripsForTimetable = async (timetable, calendars, config) => {
       }
     }
 
-    const stops = await getStops({
-      stop_id: uniq(stopIds)
-    },
-    [
-      'parent_station',
-      'stop_id'
-    ]);
+    const stops = await getStops(
+      {
+        stop_id: uniq(stopIds),
+      },
+      ['parent_station', 'stop_id']
+    );
 
     for (const trip of formattedTrips) {
       for (const stoptime of trip.stoptimes) {
-        const parentStationStop = stops.find(stop => stop.stop_id === stoptime.stop_id);
-        stoptime.stop_id = parentStationStop.parent_station || parentStationStop.stop_id;
+        const parentStationStop = stops.find(
+          (stop) => stop.stop_id === stoptime.stop_id
+        );
+        stoptime.stop_id =
+          parentStationStop.parent_station || parentStationStop.stop_id;
       }
     }
   }
@@ -873,62 +1141,76 @@ const getTripsForTimetable = async (timetable, calendars, config) => {
  * Format timetables for display.
  */
 const formatTimetables = async (timetables, config) => {
-  const formattedTimetables = await Promise.all(timetables.map(async timetable => {
-    timetable.warnings = [];
-    const dayList = formatDays(timetable, config);
-    const calendars = await getCalendarsFromTimetable(timetable);
-    let serviceIds = calendars.map(calendar => calendar.service_id);
-
-    if (timetable.include_exceptions === 1) {
-      const calendarDatesServiceIds = await getCalendarDatesServiceIds(timetable.start_date, timetable.end_date);
-      serviceIds = uniq([...serviceIds, ...calendarDatesServiceIds]);
-    }
-
-    Object.assign(timetable, {
-      noServiceSymbolUsed: false,
-      requestDropoffSymbolUsed: false,
-      noDropoffSymbolUsed: false,
-      requestPickupSymbolUsed: false,
-      noPickupSymbolUsed: false,
-      interpolatedStopSymbolUsed: false,
-      showStopCity: config.showStopCity,
-      showStopDescription: config.showStopDescription,
-      noServiceSymbol: config.noServiceSymbol,
-      requestDropoffSymbol: config.requestDropoffSymbol,
-      noDropoffSymbol: config.noDropoffSymbol,
-      requestPickupSymbol: config.requestPickupSymbol,
-      noPickupSymbol: config.noPickupSymbol,
-      interpolatedStopSymbol: config.interpolatedStopSymbol,
-      orientation: timetable.orientation || config.defaultOrientation,
-      service_ids: serviceIds,
-      dayList,
-      dayListLong: formatDaysLong(dayList, config)
-    });
+  const formattedTimetables = await Promise.all(
+    timetables.map(async (timetable) => {
+      timetable.warnings = [];
+      const dayList = formatDays(timetable, config);
+      const calendars = await getCalendarsFromTimetable(timetable);
+      let serviceIds = calendars.map((calendar) => calendar.service_id);
+
+      if (timetable.include_exceptions === 1) {
+        const calendarDatesServiceIds = await getCalendarDatesServiceIds(
+          timetable.start_date,
+          timetable.end_date
+        );
+        serviceIds = uniq([...serviceIds, ...calendarDatesServiceIds]);
+      }
 
-    timetable.orderedTrips = await getTripsForTimetable(timetable, calendars, config);
-    timetable.stops = await getStopsForTimetable(timetable, config);
-    timetable.calendarDates = await getCalendarDatesForTimetable(timetable, config);
-    timetable.timetable_label = formatTimetableLabel(timetable);
-    timetable.notes = await getTimetableNotesForTimetable(timetable, config);
+      Object.assign(timetable, {
+        noServiceSymbolUsed: false,
+        requestDropoffSymbolUsed: false,
+        noDropoffSymbolUsed: false,
+        requestPickupSymbolUsed: false,
+        noPickupSymbolUsed: false,
+        interpolatedStopSymbolUsed: false,
+        showStopCity: config.showStopCity,
+        showStopDescription: config.showStopDescription,
+        noServiceSymbol: config.noServiceSymbol,
+        requestDropoffSymbol: config.requestDropoffSymbol,
+        noDropoffSymbol: config.noDropoffSymbol,
+        requestPickupSymbol: config.requestPickupSymbol,
+        noPickupSymbol: config.noPickupSymbol,
+        interpolatedStopSymbol: config.interpolatedStopSymbol,
+        orientation: timetable.orientation || config.defaultOrientation,
+        service_ids: serviceIds,
+        dayList,
+        dayListLong: formatDaysLong(dayList, config),
+      });
 
-    if (config.showMap) {
-      timetable.geojson = await getTimetableGeoJSON(timetable, config);
-    }
+      timetable.orderedTrips = await getTripsForTimetable(
+        timetable,
+        calendars,
+        config
+      );
+      timetable.stops = await getStopsForTimetable(timetable, config);
+      timetable.calendarDates = await getCalendarDatesForTimetable(
+        timetable,
+        config
+      );
+      timetable.timetable_label = formatTimetableLabel(timetable);
+      timetable.notes = await getTimetableNotesForTimetable(timetable, config);
+
+      if (config.showMap) {
+        timetable.geojson = await getTimetableGeoJSON(timetable, config);
+      }
 
-    // Filter trips after all timetable properties are assigned
-    timetable.orderedTrips = filterTrips(timetable);
+      // Filter trips after all timetable properties are assigned
+      timetable.orderedTrips = filterTrips(timetable);
 
-    // Format stops after all timetable properties are assigned
-    timetable.stops = formatStops(timetable, config);
+      // Format stops after all timetable properties are assigned
+      timetable.stops = formatStops(timetable, config);
 
-    return timetable;
-  }));
+      return timetable;
+    })
+  );
 
   if (config.allowEmptyTimetables) {
     return formattedTimetables;
   }
 
-  return formattedTimetables.filter(timetable => timetable.orderedTrips.length > 0);
+  return formattedTimetables.filter(
+    (timetable) => timetable.orderedTrips.length > 0
+  );
 };
 
 /*
@@ -942,29 +1224,45 @@ export async function getTimetablePagesForAgency(config) {
     return convertRoutesToTimetablePages(config);
   }
 
-  const timetablePages = await getTimetablePages({}, [], [
-    ['timetable_page_id', 'ASC']
-  ]);
+  const timetablePages = await getTimetablePages(
+    {},
+    [],
+    [['timetable_page_id', 'ASC']]
+  );
 
   // Check if there are any timetable pages defined in `timetable_pages.txt`.
   if (timetablePages.length === 0) {
     // If no timetablepages, use timetables
-    return Promise.all(timetables.map(timetable => convertTimetableToTimetablePage(timetable, config)));
+    return Promise.all(
+      timetables.map((timetable) =>
+        convertTimetableToTimetablePage(timetable, config)
+      )
+    );
   }
 
   const routes = await getRoutes();
 
   // Otherwise, use timetable pages defined in `timetable_pages.txt`.
-  return Promise.all(timetablePages.map(async timetablePage => {
-    timetablePage.timetables = sortBy(timetables.filter(timetable => timetable.timetable_page_id === timetablePage.timetable_page_id), 'timetable_sequence');
-
-    // Add routes for each timetable.
-    for (const timetable of timetablePage.timetables) {
-      timetable.routes = routes.filter(route => timetable.route_ids.includes(route.route_id));
-    }
+  return Promise.all(
+    timetablePages.map(async (timetablePage) => {
+      timetablePage.timetables = sortBy(
+        timetables.filter(
+          (timetable) =>
+            timetable.timetable_page_id === timetablePage.timetable_page_id
+        ),
+        'timetable_sequence'
+      );
+
+      // Add routes for each timetable.
+      for (const timetable of timetablePage.timetables) {
+        timetable.routes = routes.filter((route) =>
+          timetable.route_ids.includes(route.route_id)
+        );
+      }
 
-    return timetablePage;
-  }));
+      return timetablePage;
+    })
+  );
 }
 
 /*
@@ -973,36 +1271,49 @@ export async function getTimetablePagesForAgency(config) {
 const getTimetablePageById = async (timetablePageId, config) => {
   // Check if there are any timetable pages defined in `timetable_pages.txt`.
   const timetablePages = await getTimetablePages({
-    timetable_page_id: timetablePageId
+    timetable_page_id: timetablePageId,
   });
 
   const timetables = mergeTimetablesWithSameId(await getTimetables());
 
   if (timetablePages.length > 1) {
-    throw new Error(`Multiple timetable_pages found for timetable_page_id=${timetablePageId}`);
+    throw new Error(
+      `Multiple timetable_pages found for timetable_page_id=${timetablePageId}`
+    );
   }
 
   if (timetablePages.length === 1) {
     // Use timetablePage defined in `timetable_pages.txt`.
     const timetablePage = timetablePages[0];
-    timetablePage.timetables = sortBy(timetables.filter(timetable => timetable.timetable_page_id === timetablePageId), 'timetable_sequence');
+    timetablePage.timetables = sortBy(
+      timetables.filter(
+        (timetable) => timetable.timetable_page_id === timetablePageId
+      ),
+      'timetable_sequence'
+    );
 
     // Add routes for each timetable
-    await Promise.all(timetablePage.timetables.map(async timetable => {
-      timetable.routes = await getRoutes({
-        route_id: timetable.route_ids
-      });
-    }));
+    await Promise.all(
+      timetablePage.timetables.map(async (timetable) => {
+        timetable.routes = await getRoutes({
+          route_id: timetable.route_ids,
+        });
+      })
+    );
 
     return timetablePage;
   }
 
   if (timetables.length > 0) {
     // If no timetable_page, use timetable defined in `timetables.txt`.
-    const timetablePageTimetables = timetables.filter(timetable => timetable.timetable_id === timetablePageId);
+    const timetablePageTimetables = timetables.filter(
+      (timetable) => timetable.timetable_id === timetablePageId
+    );
 
     if (timetablePageTimetables.length === 0) {
-      throw new Error(`No timetable found for timetable_page_id=${timetablePageId}`);
+      throw new Error(
+        `No timetable found for timetable_page_id=${timetablePageId}`
+      );
     }
 
     return convertTimetableToTimetablePage(timetablePageTimetables[0], config);
@@ -1026,35 +1337,43 @@ const getTimetablePageById = async (timetablePageId, config) => {
   const routeId = parts.join('|');
 
   const routes = await getRoutes({
-    route_id: routeId
+    route_id: routeId,
   });
 
-  const trips = await getTrips({
-    route_id: routeId,
-    direction_id: directionId
-  }, [
-    'trip_headsign',
-    'direction_id'
-  ]);
-  const directions = uniqBy(trips, trip => trip.direction_id);
+  const trips = await getTrips(
+    {
+      route_id: routeId,
+      direction_id: directionId,
+    },
+    ['trip_headsign', 'direction_id']
+  );
+  const directions = uniqBy(trips, (trip) => trip.direction_id);
 
   if (directions.length === 0) {
-    throw new Error(`No trips found for timetable_page_id=${timetablePageId} route_id=${routeId} direction_id=${directionId}`);
+    throw new Error(
+      `No trips found for timetable_page_id=${timetablePageId} route_id=${routeId} direction_id=${directionId}`
+    );
   }
 
   if (/^[01]*$/.test(calendarCode)) {
     calendars = await getCalendars({
-      ...calendarCodeToCalendar(calendarCode)
+      ...calendarCodeToCalendar(calendarCode),
     });
   } else {
     serviceId = calendarCode;
     calendarDates = await getCalendarDates({
       exception_type: 1,
-      service_id: serviceId
+      service_id: serviceId,
     });
   }
 
-  return convertRouteToTimetablePage(routes[0], directions[0], calendars, calendarDates, config);
+  return convertRouteToTimetablePage(
+    routes[0],
+    directions[0],
+    calendars,
+    calendarDates,
+    config
+  );
 };
 
 /*
@@ -1067,7 +1386,15 @@ export function setDefaultConfig(initialConfig) {
     coordinatePrecision: 5,
     dateFormat: 'MMM D, YYYY',
     daysShortStrings: ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun'],
-    daysStrings: ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday'],
+    daysStrings: [
+      'Monday',
+      'Tuesday',
+      'Wednesday',
+      'Thursday',
+      'Friday',
+      'Saturday',
+      'Sunday',
+    ],
     defaultOrientation: 'vertical',
     interpolatedStopSymbol: '•',
     interpolatedStopText: 'Estimated time of arrival',
@@ -1099,7 +1426,7 @@ export function setDefaultConfig(initialConfig) {
     timeFormat: 'h:mma',
     useParentStation: true,
     verbose: true,
-    zipOutput: false
+    zipOutput: false,
   };
 
   const config = Object.assign(defaults, initialConfig);
@@ -1118,23 +1445,36 @@ export function setDefaultConfig(initialConfig) {
 export async function getFormattedTimetablePage(timetablePageId, config) {
   const timetablePage = await getTimetablePageById(timetablePageId, config);
 
-  timetablePage.consolidatedTimetables = await formatTimetables(timetablePage.timetables, config);
+  timetablePage.consolidatedTimetables = await formatTimetables(
+    timetablePage.timetables,
+    config
+  );
   timetablePage.timetable_page_label = formatTimetablePageLabel(timetablePage);
-  timetablePage.dayList = formatDays(getDaysFromCalendars(timetablePage.consolidatedTimetables), config);
-  timetablePage.dayLists = uniq(timetablePage.consolidatedTimetables.map(timetable => timetable.dayList));
-  timetablePage.route_ids = uniq(flatMap(timetablePage.consolidatedTimetables, 'route_ids'));
-
-  const timetableRoutes = await getRoutes({
-    route_id: timetablePage.route_ids
-  }, [
-    'route_color',
-    'route_text_color',
-    'agency_id'
-  ]);
+  timetablePage.dayList = formatDays(
+    getDaysFromCalendars(timetablePage.consolidatedTimetables),
+    config
+  );
+  timetablePage.dayLists = uniq(
+    timetablePage.consolidatedTimetables.map((timetable) => timetable.dayList)
+  );
+  timetablePage.route_ids = uniq(
+    flatMap(timetablePage.consolidatedTimetables, 'route_ids')
+  );
+
+  const timetableRoutes = await getRoutes(
+    {
+      route_id: timetablePage.route_ids,
+    },
+    ['route_color', 'route_text_color', 'agency_id']
+  );
 
-  timetablePage.routeColors = timetableRoutes.map(route => route.route_color);
-  timetablePage.routeTextColors = timetableRoutes.map(route => route.route_text_color);
-  timetablePage.agency_ids = compact(timetableRoutes.map(route => route.agency_id));
+  timetablePage.routeColors = timetableRoutes.map((route) => route.route_color);
+  timetablePage.routeTextColors = timetableRoutes.map(
+    (route) => route.route_text_color
+  );
+  timetablePage.agency_ids = compact(
+    timetableRoutes.map((route) => route.agency_id)
+  );
 
   // Set default filename.
   if (!timetablePage.filename) {
@@ -1142,17 +1482,21 @@ export async function getFormattedTimetablePage(timetablePageId, config) {
   }
 
   // Get `direction_name` for each timetable.
-  await Promise.all(timetablePage.consolidatedTimetables.map(async timetable => {
-    if (isNullOrEmpty(timetable.direction_name)) {
-      timetable.direction_name = await getDirectionHeadsignFromTimetable(timetable);
-    }
+  await Promise.all(
+    timetablePage.consolidatedTimetables.map(async (timetable) => {
+      if (isNullOrEmpty(timetable.direction_name)) {
+        timetable.direction_name = await getDirectionHeadsignFromTimetable(
+          timetable
+        );
+      }
 
-    if (!timetable.routes) {
-      timetable.routes = await getRoutes({
-        route_id: timetable.route_ids
-      });
-    }
-  }));
+      if (!timetable.routes) {
+        timetable.routes = await getRoutes({
+          route_id: timetable.route_ids,
+        });
+      }
+    })
+  );
 
   return timetablePage;
 }
@@ -1160,12 +1504,12 @@ export async function getFormattedTimetablePage(timetablePageId, config) {
 /*
  * Generate stats about timetable page.
  */
-const generateStats = timetablePage => {
+export const generateStats = (timetablePage) => {
   const stats = {
     stops: 0,
     trips: 0,
     route_ids: {},
-    service_ids: {}
+    service_ids: {},
   };
 
   for (const timetable of timetablePage.consolidatedTimetables) {
@@ -1189,17 +1533,54 @@ const generateStats = timetablePage => {
 /*
  * Generate the HTML timetable for a timetable page.
  */
-export async function generateHTML(timetablePage, config) {
+export function generateTimetableHTML(timetablePage, config) {
   const templateVars = {
     timetablePage,
-    config
-  };
-  const html = await renderTemplate('timetablepage', templateVars, config);
-  const stats = generateStats(timetablePage);
-  return {
-    html,
-    stats
+    config,
   };
+  return renderTemplate('timetablepage', templateVars, config);
+}
+
+/*
+ * Generate the CSV timetable for a timetable page.
+ */
+export async function generateTimetableCSV(timetable) {
+  // Generate horizontal orientation, then transpose if vertical is needed.
+  const lines = [];
+
+  lines.push([
+    '',
+    ...timetable.orderedTrips.map((trip) =>
+      formatTripNameForCSV(trip, timetable)
+    ),
+  ]);
+
+  if (timetable.has_continues_from_route) {
+    lines.push([
+      'Continues from route',
+      ...timetable.orderedTrips.map((trip) => formatTripContinuesFrom(trip)),
+    ]);
+  }
+
+  for (const stop of timetable.stops) {
+    lines.push([
+      formatStopName(stop),
+      ...stop.trips.map((stoptime) => stoptime.formatted_time),
+    ]);
+  }
+
+  if (timetable.has_continues_as_route) {
+    lines.push([
+      'Continues as route',
+      ...timetable.orderedTrips.map((trip) => formatTripContinuesAs(trip)),
+    ]);
+  }
+
+  if (timetable.orientation === 'vertical') {
+    return stringify(zip(...lines));
+  }
+
+  return stringify(lines);
 }
 
 /*
@@ -1218,27 +1599,37 @@ export async function generateOverviewHTML(timetablePages, config) {
 
   // Sort timetables for display, first numerically then alphabetically.
   const sortedTimetablePages = sortBy(timetablePages, [
-    timetablePage => {
-      if (timetablePage.consolidatedTimetables.length > 0 && timetablePage.consolidatedTimetables[0].routes.length > 0) {
-        return Number.parseInt(timetablePage.consolidatedTimetables[0].routes[0].route_short_name, 10);
+    (timetablePage) => {
+      if (
+        timetablePage.consolidatedTimetables.length > 0 &&
+        timetablePage.consolidatedTimetables[0].routes.length > 0
+      ) {
+        return Number.parseInt(
+          timetablePage.consolidatedTimetables[0].routes[0].route_short_name,
+          10
+        );
       }
     },
-    timetablePage => {
-      if (timetablePage.consolidatedTimetables.length > 0 && timetablePage.consolidatedTimetables[0].routes.length > 0) {
-        return timetablePage.consolidatedTimetables[0].routes[0].route_short_name;
+    (timetablePage) => {
+      if (
+        timetablePage.consolidatedTimetables.length > 0 &&
+        timetablePage.consolidatedTimetables[0].routes.length > 0
+      ) {
+        return timetablePage.consolidatedTimetables[0].routes[0]
+          .route_short_name;
       }
-    }
+    },
   ]);
 
   const templateVars = {
     agency: {
       ...first(agencies),
-      geojson
+      geojson,
     },
     agencies,
     geojson,
     config,
-    timetablePages: sortedTimetablePages
+    timetablePages: sortedTimetablePages,
   };
   return renderTemplate('overview', templateVars, config);
 }