gtfs-to-html
Version:
Build human readable transit timetables as HTML, PDF or CSV from GTFS
1,574 lines (1,560 loc) • 98.1 kB
JavaScript
var __defProp = Object.defineProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
// src/lib/gtfs-to-html.ts
import path from "path";
import { mkdir as mkdir2, writeFile } from "fs/promises";
import { openDb as openDb2, importGtfs, isGtfsError as isGtfsError3 } from "gtfs";
import sanitize2 from "sanitize-filename";
// src/lib/file-utils.ts
import { dirname, join, resolve } from "path";
import cssEscape from "css.escape";
import { createWriteStream } from "fs";
import { createRequire } from "module";
import { fileURLToPath } from "url";
import {
access,
cp,
copyFile,
mkdir,
readdir,
readFile,
rm
} from "fs/promises";
import { homedir } from "os";
import * as _ from "lodash-es";
import { uniqBy as uniqBy2 } from "lodash-es";
import { ZipArchive } from "archiver";
import beautify from "js-beautify";
import sanitizeHtml from "sanitize-html";
import { renderFile } from "pug";
import puppeteer from "puppeteer";
import sanitize from "sanitize-filename";
import { marked } from "marked";
// src/lib/formatters.ts
import {
clone,
find as find2,
first as first2,
groupBy as groupBy2,
last as last2,
omit,
sortBy as sortBy2,
zipObject
} from "lodash-es";
import moment3 from "moment";
// src/lib/time-utils.ts
import moment from "moment";
function fromGTFSTime(timeString) {
const duration = moment.duration(timeString);
return moment({
hour: duration.hours(),
minute: duration.minutes(),
second: duration.seconds()
});
}
function toGTFSTime(time) {
return time.format("HH:mm:ss");
}
function calendarToCalendarCode(calendar) {
if (Object.values(calendar).every((value) => value === null)) {
return "";
}
return `${calendar.monday ?? "0"}${calendar.tuesday ?? "0"}${calendar.wednesday ?? "0"}${calendar.thursday ?? "0"}${calendar.friday ?? "0"}${calendar.saturday ?? "0"}${calendar.sunday ?? "0"}`;
}
function calendarCodeToCalendar(code) {
const days2 = [
"monday",
"tuesday",
"wednesday",
"thursday",
"friday",
"saturday",
"sunday"
];
const calendar = {};
for (const [index, day] of days2.entries()) {
calendar[day] = code[index];
}
return calendar;
}
function calendarToDateList(calendar, startDate, endDate) {
if (!startDate || !endDate) {
return [];
}
const activeWeekdays = [
calendar.monday === 1 ? 1 : null,
calendar.tuesday === 1 ? 2 : null,
calendar.wednesday === 1 ? 3 : null,
calendar.thursday === 1 ? 4 : null,
calendar.friday === 1 ? 5 : null,
calendar.saturday === 1 ? 6 : null,
calendar.sunday === 1 ? 7 : null
].filter((weekday) => weekday !== null);
if (activeWeekdays.length === 0) {
return [];
}
const activeWeekdaySet = new Set(activeWeekdays);
const dates = /* @__PURE__ */ new Set();
const date = moment(startDate.toString(), "YYYYMMDD");
const endDateMoment = moment(endDate.toString(), "YYYYMMDD");
while (date.isSameOrBefore(endDateMoment)) {
const isoWeekday = date.isoWeekday();
if (activeWeekdaySet.has(isoWeekday)) {
dates.add(parseInt(date.format("YYYYMMDD"), 10));
}
date.add(1, "day");
}
return Array.from(dates);
}
function combineCalendars(calendars) {
const combinedCalendar = {
monday: 0,
tuesday: 0,
wednesday: 0,
thursday: 0,
friday: 0,
saturday: 0,
sunday: 0
};
for (const calendar of calendars) {
for (const day of Object.keys(
combinedCalendar
)) {
if (calendar[day] === 1) {
combinedCalendar[day] = 1;
}
}
}
return combinedCalendar;
}
function secondsAfterMidnight(timeString) {
return moment.duration(timeString).asSeconds();
}
function minutesAfterMidnight(timeString) {
return moment.duration(timeString).asMinutes();
}
function updateTimeByOffset(timeString, offsetSeconds) {
const newTime = fromGTFSTime(timeString);
return toGTFSTime(newTime.add(offsetSeconds, "seconds"));
}
// src/lib/utils.ts
import {
cloneDeep,
compact,
countBy,
difference,
entries,
every as every2,
find,
findLast,
first,
flatMap,
flow,
groupBy,
head,
last,
maxBy,
orderBy,
partialRight,
reduce,
size,
some,
sortBy,
uniq,
uniqBy,
zip
} from "lodash-es";
import {
getCalendarDates,
getTrips,
getTimetableNotesReferences,
getTimetableNotes,
getRoutes,
getCalendars,
getTimetableStopOrders,
getStops,
getStopAttributes,
getStoptimes,
getFrequencies,
getTimetables,
getTimetablePages,
getAgencies as getAgencies2,
openDb
} from "gtfs";
import { stringify } from "csv-stringify";
import moment2 from "moment";
import sqlString from "sqlstring";
import toposort from "toposort";
// src/lib/geojson-utils.ts
import { getShapesAsGeoJSON, getStopsAsGeoJSON } from "gtfs";
import simplify from "@turf/simplify";
import { featureCollection, round } from "@turf/helpers";
// src/lib/log-utils.ts
import { clearLine, cursorTo } from "readline";
import { noop } from "lodash-es";
import * as colors from "yoctocolors";
import { getAgencies, getFeedInfo, isGtfsError as isGtfsError2, formatGtfsError } from "gtfs";
import Table from "cli-table";
// src/lib/errors.ts
import { GtfsErrorCategory, isGtfsError } from "gtfs";
var GtfsToHtmlErrorCategory = /* @__PURE__ */ ((GtfsToHtmlErrorCategory2) => {
GtfsToHtmlErrorCategory2["CONFIG"] = "config";
GtfsToHtmlErrorCategory2["DATABASE"] = "database";
GtfsToHtmlErrorCategory2["GTFS"] = "gtfs";
GtfsToHtmlErrorCategory2["FILE_SYSTEM"] = "file_system";
GtfsToHtmlErrorCategory2["TEMPLATE"] = "template";
GtfsToHtmlErrorCategory2["QUERY"] = "query";
GtfsToHtmlErrorCategory2["VALIDATION"] = "validation";
GtfsToHtmlErrorCategory2["INTERNAL"] = "internal";
return GtfsToHtmlErrorCategory2;
})(GtfsToHtmlErrorCategory || {});
var GtfsToHtmlErrorCode = /* @__PURE__ */ ((GtfsToHtmlErrorCode2) => {
GtfsToHtmlErrorCode2["CONFIG_INVALID"] = "GTFS_TO_HTML_CONFIG_INVALID";
GtfsToHtmlErrorCode2["CONFIG_FILE_NOT_FOUND"] = "GTFS_TO_HTML_CONFIG_FILE_NOT_FOUND";
GtfsToHtmlErrorCode2["CONFIG_PARSE_FAILED"] = "GTFS_TO_HTML_CONFIG_PARSE_FAILED";
GtfsToHtmlErrorCode2["CONFIG_DATE_INVALID"] = "GTFS_TO_HTML_CONFIG_DATE_INVALID";
GtfsToHtmlErrorCode2["CONFIG_MISSING_AGENCIES"] = "GTFS_TO_HTML_CONFIG_MISSING_AGENCIES";
GtfsToHtmlErrorCode2["DATABASE_OPEN_FAILED"] = "GTFS_TO_HTML_DATABASE_OPEN_FAILED";
GtfsToHtmlErrorCode2["GTFS_IMPORT_FAILED"] = "GTFS_TO_HTML_GTFS_IMPORT_FAILED";
GtfsToHtmlErrorCode2["FILE_SYSTEM_WRITE_FAILED"] = "GTFS_TO_HTML_FILE_SYSTEM_WRITE_FAILED";
GtfsToHtmlErrorCode2["OUTPUT_DIRECTORY_NOT_EMPTY"] = "GTFS_TO_HTML_OUTPUT_DIRECTORY_NOT_EMPTY";
GtfsToHtmlErrorCode2["QUERY_RESULT_NOT_FOUND"] = "GTFS_TO_HTML_QUERY_RESULT_NOT_FOUND";
GtfsToHtmlErrorCode2["QUERY_RESULT_AMBIGUOUS"] = "GTFS_TO_HTML_QUERY_RESULT_AMBIGUOUS";
GtfsToHtmlErrorCode2["QUERY_INVALID"] = "GTFS_TO_HTML_QUERY_INVALID";
GtfsToHtmlErrorCode2["TIMETABLE_GENERATION_FAILED"] = "GTFS_TO_HTML_TIMETABLE_GENERATION_FAILED";
return GtfsToHtmlErrorCode2;
})(GtfsToHtmlErrorCode || {});
var GtfsToHtmlError = class extends Error {
code;
category;
isOperational;
details;
constructor(message, options) {
super(message, { cause: options.cause });
this.name = "GtfsToHtmlError";
this.code = options.code;
this.category = options.category;
this.isOperational = options.isOperational ?? true;
this.details = options.details;
}
};
function isGtfsToHtmlError(error) {
if (!error || typeof error !== "object") {
return false;
}
const candidate = error;
return candidate.name === "GtfsToHtmlError" && typeof candidate.message === "string" && typeof candidate.code === "string" && typeof candidate.category === "string" && typeof candidate.isOperational === "boolean";
}
function isGtfsParsingError(error) {
return isGtfsError(error) && [
GtfsErrorCategory.PARSE,
GtfsErrorCategory.VALIDATION,
GtfsErrorCategory.ZIP
].includes(error.category);
}
function toGtfsToHtmlError(error, fallback) {
if (isGtfsToHtmlError(error)) {
return error;
}
return new GtfsToHtmlError(fallback.message, {
...fallback,
cause: error
});
}
function formatGtfsToHtmlError(error, options = { verbosity: "developer" }) {
if (!isGtfsToHtmlError(error)) {
const message = error instanceof Error ? error.message : String(error);
return options.verbosity === "user" ? message : `UNKNOWN_ERROR: ${message}`;
}
if (options.verbosity === "user") {
return error.message;
}
return [
`${error.code}: ${error.message}`,
`category=${error.category}`,
error.details ? `details=${JSON.stringify(error.details)}` : null
].filter(Boolean).join(" | ");
}
// src/lib/log-utils.ts
function generateLogText(outputStats, config) {
const feedInfo = getFeedInfo();
const agencies = getAgencies();
const feedVersion = feedInfo.length > 0 && feedInfo[0].feed_version ? feedInfo[0].feed_version : "Unknown";
const logText = [
`Agencies: ${agencies.map((agency) => agency.agency_name).join(", ")}`,
`Feed Version: ${feedVersion}`,
`GTFS-to-HTML Version: ${config.gtfsToHtmlVersion}`,
`Date Generated: ${(/* @__PURE__ */ new Date()).toISOString()}`,
`Timetable Page Count: ${outputStats.timetablePages}`,
`Timetable Count: ${outputStats.timetables}`,
`Calendar Service ID Count: ${outputStats.calendars}`,
`Route Count: ${outputStats.routes}`,
`Trip Count: ${outputStats.trips}`,
`Stop Count: ${outputStats.stops}`
];
for (const agency of config.agencies) {
if (agency.url) {
logText.push(`Source: ${agency.url}`);
} else if (agency.path) {
logText.push(`Source: ${agency.path}`);
}
}
if (outputStats.warnings.length > 0) {
logText.push("", "Warnings:", ...outputStats.warnings);
}
return logText.join("\n");
}
function log(config) {
if (config.verbose === false) {
return noop;
}
if (config.logFunction) {
return config.logFunction;
}
return (text, overwrite) => {
if (overwrite === true && process.stdout.isTTY) {
clearLine(process.stdout, 0);
cursorTo(process.stdout, 0);
} else {
process.stdout.write("\n");
}
process.stdout.write(text);
};
}
function logWarning(config) {
if (config.logFunction) {
return config.logFunction;
}
return (text) => {
process.stdout.write(`
${formatWarning(text)}
`);
};
}
function logError(config) {
if (config.logFunction) {
return config.logFunction;
}
return (text) => {
process.stdout.write(`
${formatError(text)}
`);
};
}
function formatWarning(text) {
const warningMessage = `${colors.underline("Warning")}: ${text}`;
return colors.yellow(warningMessage);
}
function formatError(error, options = {}) {
const verbosity = options.verbosity ?? "developer";
const sourceLabel = isGtfsToHtmlError(error) ? "GTFS-to-HTML" : isGtfsError2(error) ? "GTFS" : null;
const messageText = isGtfsToHtmlError(error) ? formatGtfsToHtmlError(error, { verbosity }) : isGtfsError2(error) ? formatGtfsError(error, { verbosity }) : error instanceof Error ? error.message : String(error);
const labeledMessage = sourceLabel ? `[${sourceLabel}] ${messageText}` : messageText;
const errorMessage = `${colors.underline("Error")}: ${labeledMessage.replace(
"Error: ",
""
)}`;
return colors.red(errorMessage);
}
function logStats(config) {
if (config.logFunction) {
return noop;
}
return (stats) => {
const table = new Table({
colWidths: [40, 20],
head: ["Item", "Count"]
});
table.push(
["\u{1F4C4} Timetable Pages", stats.timetablePages],
["\u{1F551} Timetables", stats.timetables],
["\u{1F4C5} Calendar Service IDs", stats.calendars],
["\u{1F504} Routes", stats.routes],
["\u{1F68D} Trips", stats.trips],
["\u{1F6D1} Stops", stats.stops],
["\u26D4\uFE0F Warnings", stats.warnings.length]
);
log(config)(table.toString());
};
}
var generateProgressBarString = (barTotal, barProgress, size2 = 40) => {
const line = "-";
const slider = "=";
if (!barTotal) {
throw new GtfsToHtmlError("Total value is either not provided or invalid", {
code: "GTFS_TO_HTML_QUERY_INVALID" /* QUERY_INVALID */,
category: "validation" /* VALIDATION */,
details: { field: "barTotal", value: barTotal }
});
}
if (!barProgress && barProgress !== 0) {
throw new GtfsToHtmlError(
"Current value is either not provided or invalid",
{
code: "GTFS_TO_HTML_QUERY_INVALID" /* QUERY_INVALID */,
category: "validation" /* VALIDATION */,
details: { field: "barProgress", value: barProgress }
}
);
}
if (isNaN(barTotal)) {
throw new GtfsToHtmlError("Total value is not an integer", {
code: "GTFS_TO_HTML_QUERY_INVALID" /* QUERY_INVALID */,
category: "validation" /* VALIDATION */,
details: { field: "barTotal", value: barTotal }
});
}
if (isNaN(barProgress)) {
throw new GtfsToHtmlError("Current value is not an integer", {
code: "GTFS_TO_HTML_QUERY_INVALID" /* QUERY_INVALID */,
category: "validation" /* VALIDATION */,
details: { field: "barProgress", value: barProgress }
});
}
if (isNaN(size2)) {
throw new GtfsToHtmlError("Size is not an integer", {
code: "GTFS_TO_HTML_QUERY_INVALID" /* QUERY_INVALID */,
category: "validation" /* VALIDATION */,
details: { field: "size", value: size2 }
});
}
if (barProgress > barTotal) {
return slider.repeat(size2 + 2);
}
const percentage = barProgress / barTotal;
const progress = Math.round(size2 * percentage);
const emptyProgress = size2 - progress;
const progressText = slider.repeat(progress);
const emptyProgressText = line.repeat(emptyProgress);
return progressText + emptyProgressText;
};
function progressBar(formatString, barTotal, config) {
let barProgress = 0;
if (config.verbose === false) {
return {
increment: noop,
interrupt: noop
};
}
if (barTotal === 0) {
return null;
}
const renderProgressString = () => formatString.replace("{value}", barProgress).replace("{total}", barTotal).replace("{bar}", generateProgressBarString(barTotal, barProgress));
log(config)(renderProgressString(), true);
return {
interrupt(text) {
logWarning(config)(text);
log(config)("");
},
increment() {
barProgress += 1;
log(config)(renderProgressString(), true);
}
};
}
// src/lib/trip-id-utils.ts
var getBaseTripId = (tripId) => tripId.replace(/_freq_\d+$/, "");
var getBaseTripIds = (trips) => Array.from(new Set(trips.map((trip) => getBaseTripId(trip.trip_id))));
// src/lib/geojson-utils.ts
var mergeGeojson = (...geojsons) => featureCollection(geojsons.flatMap((geojson) => geojson.features));
var truncateGeoJSONDecimals = (geojson, config) => {
for (const feature of geojson.features) {
if (feature.geometry.coordinates) {
if (feature.geometry.type.toLowerCase() === "point") {
feature.geometry.coordinates = feature.geometry.coordinates.map(
(number) => round(number, config.coordinatePrecision)
);
} else if (feature.geometry.type.toLowerCase() === "linestring") {
feature.geometry.coordinates = feature.geometry.coordinates.map(
(coordinate) => coordinate.map(
(number) => round(number, config.coordinatePrecision)
)
);
} else if (feature.geometry.type.toLowerCase() === "multilinestring") {
feature.geometry.coordinates = feature.geometry.coordinates.map(
(linestring) => linestring.map(
(coordinate) => coordinate.map(
(number) => round(number, config.coordinatePrecision)
)
)
);
}
}
}
return geojson;
};
function getTimetableGeoJSON(timetable, config) {
const tripIds = getBaseTripIds(timetable.orderedTrips);
const shapesGeojsons = timetable.route_ids.map(
(routeId) => getShapesAsGeoJSON({
route_id: routeId,
direction_id: timetable.direction_id,
trip_id: tripIds
})
);
const stopsGeojsons = timetable.route_ids.map(
(routeId) => getStopsAsGeoJSON({
route_id: routeId,
direction_id: timetable.direction_id,
trip_id: tripIds
})
);
const geojson = mergeGeojson(...shapesGeojsons, ...stopsGeojsons);
let simplifiedGeojson;
try {
simplifiedGeojson = simplify(geojson, {
tolerance: 1 / 10 ** config.coordinatePrecision,
highQuality: true
});
} catch {
timetable.warnings.push(
`Timetable ${timetable.timetable_id} - Unable to simplify geojson`
);
simplifiedGeojson = geojson;
}
return truncateGeoJSONDecimals(simplifiedGeojson, config);
}
function getAgencyGeoJSON(config) {
const shapesGeojsons = getShapesAsGeoJSON();
const stopsGeojsons = getStopsAsGeoJSON();
const geojson = mergeGeojson(shapesGeojsons, stopsGeojsons);
let simplifiedGeojson;
try {
simplifiedGeojson = simplify(geojson, {
tolerance: 1 / 10 ** config.coordinatePrecision,
highQuality: true
});
} catch {
logWarning(config)("Unable to simplify geojson");
simplifiedGeojson = geojson;
}
return truncateGeoJSONDecimals(simplifiedGeojson, config);
}
// src/lib/template-functions.ts
var template_functions_exports = {};
__export(template_functions_exports, {
formatTripName: () => formatTripName,
formatTripNameForCSV: () => formatTripNameForCSV,
getNotesForStop: () => getNotesForStop,
getNotesForStoptime: () => getNotesForStoptime,
getNotesForTimetableLabel: () => getNotesForTimetableLabel,
getNotesForTrip: () => getNotesForTrip,
hasNotesOrNotices: () => hasNotesOrNotices,
timetableHasDifferentDays: () => timetableHasDifferentDays,
timetablePageHasDifferentDays: () => timetablePageHasDifferentDays,
timetablePageHasDifferentLabels: () => timetablePageHasDifferentLabels
});
import { every } from "lodash-es";
function timetableHasDifferentDays(timetable) {
return !every(timetable.orderedTrips, (trip, idx) => {
if (idx === 0) {
return true;
}
return trip.dayList === timetable.orderedTrips[idx - 1].dayList;
});
}
function timetablePageHasDifferentDays(timetablePage) {
return !every(timetablePage.consolidatedTimetables, (timetable, idx) => {
if (idx === 0) {
return true;
}
return timetable.dayListLong === timetablePage.consolidatedTimetables[idx - 1].dayListLong;
});
}
function timetablePageHasDifferentLabels(timetablePage) {
return !every(timetablePage.consolidatedTimetables, (timetable, idx) => {
if (idx === 0) {
return true;
}
return timetable.timetable_label === timetablePage.consolidatedTimetables[idx - 1].timetable_label;
});
}
function hasNotesOrNotices(timetable) {
return timetable.requestPickupSymbolUsed || timetable.noPickupSymbolUsed || timetable.requestDropoffSymbolUsed || timetable.noDropoffSymbolUsed || timetable.noServiceSymbolUsed || timetable.interpolatedStopSymbolUsed || timetable.notes.length > 0;
}
function getNotesForTimetableLabel(notes) {
return notes.filter((note) => !note.stop_id && !note.trip_id);
}
function getNotesForStop(notes, stop) {
return notes.filter((note) => {
if (note.trip_id) {
return false;
}
if (note.stop_sequence && !stop.trips.some((trip) => trip.stop_sequence === note.stop_sequence)) {
return false;
}
return note.stop_id === stop.stop_id;
});
}
function getNotesForTrip(notes, trip) {
return notes.filter((note) => {
if (note.stop_id) {
return false;
}
return note.trip_id === trip.trip_id;
});
}
function getNotesForStoptime(notes, stoptime) {
return notes.filter((note) => {
if (!note.trip_id && note.stop_id === stoptime.stop_id && note.show_on_stoptime === 1) {
return true;
}
if (!note.stop_id && note.trip_id === stoptime.trip_id && note.show_on_stoptime === 1) {
return true;
}
return note.trip_id === stoptime.trip_id && note.stop_id === stoptime.stop_id;
});
}
function formatTripName(trip, index, timetable) {
let tripName;
if (timetable.routes.length > 1) {
tripName = trip.route_short_name;
} else if (timetable.orientation === "horizontal") {
if (trip.trip_short_name) {
tripName = trip.trip_short_name;
} else {
tripName = `Run #${index + 1}`;
}
}
if (timetableHasDifferentDays(timetable)) {
tripName += ` ${trip.dayList}`;
}
return tripName;
}
function formatTripNameForCSV(trip, timetable) {
let tripName = "";
if (timetable.routes.length > 1) {
tripName += `${trip.route_short_name} - `;
}
if (trip.trip_short_name) {
tripName += trip.trip_short_name;
} else {
tripName += trip.trip_id;
}
if (trip.trip_headsign) {
tripName += ` - ${trip.trip_headsign}`;
}
if (timetableHasDifferentDays(timetable)) {
tripName += ` - ${trip.dayList}`;
}
return tripName;
}
// package.json
var package_default = {
name: "gtfs-to-html",
version: "2.12.12",
private: false,
description: "Build human readable transit timetables as HTML, PDF or CSV from GTFS",
keywords: [
"transit",
"gtfs",
"gtfs-realtime",
"transportation",
"timetables"
],
homepage: "https://gtfstohtml.com",
bugs: {
url: "https://github.com/blinktaginc/gtfs-to-html/issues"
},
repository: "git://github.com/blinktaginc/gtfs-to-html",
license: "MIT",
author: "Brendan Nee <brendan@blinktag.com>",
contributors: [
"Evan Siroky <evan.siroky@yahoo.com>",
"Nathan Selikoff",
"Aaron Antrim <aaron@trilliumtransit.com>",
"Thomas Craig <thomas@trilliumtransit.com>",
"Holly Kvalheim",
"Pawajoro",
"Andrea Mignone",
"Evo Stamatov",
"Sebastian Knopf"
],
type: "module",
main: "./dist/index.js",
types: "./dist/index.d.ts",
files: [
"dist",
"docker",
"examples",
"scripts",
"views/default",
"config-sample.json"
],
bin: {
"gtfs-to-html": "dist/bin/gtfs-to-html.js"
},
scripts: {
build: "tsup && node scripts/copy-browser-assets.js",
start: "node ./dist/app",
prepare: "husky && pnpm run build",
prepack: "husky && pnpm run build"
},
dependencies: {
"@turf/helpers": "^7.3.5",
"@turf/simplify": "^7.3.5",
archiver: "^8.0.0",
"cli-table": "^0.3.11",
"css.escape": "^1.5.1",
"csv-stringify": "^6.7.0",
express: "^5.2.1",
gtfs: "^4.18.7",
"js-beautify": "^1.15.4",
"lodash-es": "^4.18.1",
marked: "^18.0.4",
moment: "^2.30.1",
"pretty-error": "^4.0.0",
pug: "^3.0.4",
puppeteer: "^25.1.0",
"sanitize-filename": "^1.6.4",
"sanitize-html": "^2.17.4",
sqlstring: "^2.3.3",
toposort: "^2.0.2",
yargs: "^18.0.0",
yoctocolors: "^2.1.2"
},
devDependencies: {
"@maplibre/maplibre-gl-geocoder": "^1.9.4",
"@types/archiver": "^7.0.0",
"@types/cli-table": "^0.3.4",
"@types/express": "^5.0.6",
"@types/js-beautify": "^1.14.3",
"@types/lodash-es": "^4.17.12",
"@types/node": "^25",
"@types/pug": "^2.0.10",
"@types/sanitize-html": "^2.16.1",
"@types/sqlstring": "^2.3.2",
"@types/toposort": "^2.0.7",
"@types/yargs": "^17.0.35",
anchorme: "^3.0.8",
"gtfs-realtime-pbf-js-module": "^1.0.0",
husky: "^9.1.7",
"lint-staged": "^17.0.5",
"maplibre-gl": "^5.24.0",
pbf: "^5.0.0",
prettier: "^3.8.3",
tsup: "^8.5.1",
typescript: "^6.0.3"
},
engines: {
node: ">= 22"
},
packageManager: "pnpm@11.4.0",
"release-it": {
github: {
release: true
},
plugins: {
"@release-it/keep-a-changelog": {
filename: "CHANGELOG.md"
}
},
hooks: {
"after:bump": "pnpm run build"
}
},
prettier: {
singleQuote: true
},
"lint-staged": {
"*.{js,ts,json}": "prettier --write"
}
};
// src/lib/utils.ts
var { version } = package_default;
var isTimepoint = (stoptime) => {
if (isNullOrEmpty(stoptime.timepoint)) {
return !isNullOrEmpty(stoptime.arrival_time) && !isNullOrEmpty(stoptime.departure_time);
}
return stoptime.timepoint === 1;
};
var getLongestTripStoptimes = (trips, config) => {
const filteredTripStoptimes = trips.map(
(trip) => trip.stoptimes.filter((stoptime) => {
if (config.showOnlyTimepoint === true) {
return isTimepoint(stoptime);
}
return true;
})
);
return maxBy(filteredTripStoptimes, (stoptimes) => size(stoptimes));
};
var findCommonStopId = (trips, config) => {
const longestTripStoptimes = getLongestTripStoptimes(trips, config);
if (!longestTripStoptimes) {
return null;
}
const commonStoptime = longestTripStoptimes.find((stoptime, idx) => {
if (idx === 0 && stoptime.stop_id === last(longestTripStoptimes)?.stop_id) {
return false;
}
if (isNullOrEmpty(stoptime.arrival_time)) {
return false;
}
return every2(
trips,
(trip) => trip.stoptimes.find(
(tripStoptime) => tripStoptime.stop_id === stoptime.stop_id && tripStoptime.arrival_time !== null
)
);
});
return commonStoptime ? commonStoptime.stop_id : null;
};
var deduplicateTrips = (trips) => {
if (trips.length <= 1) {
return trips;
}
const uniqueTrips = /* @__PURE__ */ new Map();
for (const trip of trips) {
const tripSignature = trip.stoptimes.map(
(stoptime) => `${stoptime.stop_id}|${stoptime.departure_time}|${stoptime.arrival_time}`
).join("|");
if (!uniqueTrips.has(tripSignature)) {
uniqueTrips.set(tripSignature, trip);
} else {
const existingTrip = uniqueTrips.get(tripSignature);
if (!existingTrip) {
continue;
}
if (!existingTrip.additional_service_ids) {
existingTrip.additional_service_ids = [];
}
existingTrip.additional_service_ids.push(trip.service_id);
uniqueTrips.set(tripSignature, existingTrip);
}
}
return Array.from(uniqueTrips.values());
};
var sortTrips = (trips, config) => {
let sortedTrips;
let commonStopId;
if (config.sortingAlgorithm === "common") {
commonStopId = findCommonStopId(trips, config);
if (commonStopId) {
sortedTrips = sortTripsByStoptimeAtStop(trips, commonStopId);
} else {
sortedTrips = sortTrips(trips, {
...config,
sortingAlgorithm: "beginning"
});
}
} else if (config.sortingAlgorithm === "beginning") {
for (const trip of trips) {
if (trip.stoptimes.length === 0) {
continue;
}
trip.firstStoptime = timeToSeconds(trip.stoptimes[0].departure_time);
trip.lastStoptime = timeToSeconds(
trip.stoptimes[trip.stoptimes.length - 1].departure_time
);
}
sortedTrips = sortBy(trips, ["firstStoptime", "lastStoptime"]);
} else if (config.sortingAlgorithm === "end") {
for (const trip of trips) {
if (trip.stoptimes.length === 0) {
continue;
}
trip.firstStoptime = timeToSeconds(trip.stoptimes[0].departure_time);
trip.lastStoptime = timeToSeconds(
trip.stoptimes[trip.stoptimes.length - 1].departure_time
);
}
sortedTrips = sortBy(trips, ["lastStoptime", "firstStoptime"]);
} else if (config.sortingAlgorithm === "first") {
const longestTripStoptimes = getLongestTripStoptimes(trips, config);
const firstStopId = first(longestTripStoptimes).stop_id;
sortedTrips = sortTripsByStoptimeAtStop(trips, firstStopId);
} else if (config.sortingAlgorithm === "last") {
const longestTripStoptimes = getLongestTripStoptimes(trips, config);
const lastStopId = last(longestTripStoptimes).stop_id;
sortedTrips = sortTripsByStoptimeAtStop(trips, lastStopId);
}
return sortedTrips ?? [];
};
var sortTripsByStoptimeAtStop = (trips, stopId) => sortBy(trips, (trip) => {
const stoptime = find(trip.stoptimes, { stop_id: stopId });
return stoptime ? timeToSeconds(stoptime.departure_time) : void 0;
});
var getCalendarDatesForTimetable = (timetable, config) => {
const calendarDates = getCalendarDates(
{
service_id: timetable.service_ids
},
[],
[["date", "ASC"]]
);
const start = moment2(timetable.start_date, "YYYYMMDD");
const end = moment2(timetable.end_date, "YYYYMMDD");
const excludedDates = /* @__PURE__ */ new Set();
const includedDates = /* @__PURE__ */ new Set();
for (const calendarDate of calendarDates) {
if (moment2(calendarDate.date, "YYYYMMDD").isBetween(
start,
end,
void 0,
"[]"
)) {
if (calendarDate.exception_type === 1) {
includedDates.add(formatDate(calendarDate, config.dateFormat));
} else if (calendarDate.exception_type === 2) {
excludedDates.add(formatDate(calendarDate, config.dateFormat));
}
}
}
const includedAndExcludedDates = new Set(
[...excludedDates].filter((date) => includedDates.has(date))
);
return {
excludedDates: [...excludedDates].filter(
(date) => !includedAndExcludedDates.has(date)
),
includedDates: [...includedDates].filter(
(date) => !includedAndExcludedDates.has(date)
)
};
};
var getDaysFromCalendars = (calendars) => {
const days2 = {
monday: 0,
tuesday: 0,
wednesday: 0,
thursday: 0,
friday: 0,
saturday: 0,
sunday: 0
};
for (const calendar of calendars) {
for (const day of Object.keys(days2)) {
days2[day] = days2[day] | calendar[day];
}
}
return days2;
};
var getDirectionHeadsignFromTimetable = (timetable) => {
const trips = getTrips(
{
direction_id: timetable.direction_id,
route_id: timetable.route_ids
},
["trip_headsign"]
);
if (trips.length === 0) {
return "";
}
const mostCommonHeadsign = flow(
countBy,
entries,
partialRight(maxBy, last),
head
)(compact(trips.map((trip) => trip.trip_headsign)));
return mostCommonHeadsign;
};
var getTimetableNotesForTimetable = (timetable, config) => {
const noteReferences = [
// Get all notes for this timetable.
...getTimetableNotesReferences({
timetable_id: timetable.timetable_id
}),
// Get all notes for this route.
...getTimetableNotesReferences({
route_id: timetable.routes.map((route) => route.route_id),
timetable_id: null
}),
// Get all notes for all trips in this timetable.
...getTimetableNotesReferences({
trip_id: getBaseTripIds(timetable.orderedTrips)
}),
// Get all notes for all stops in this timetable.
...getTimetableNotesReferences({
stop_id: timetable.stops.map((stop) => stop.stop_id),
trip_id: null,
route_id: null,
timetable_id: null
})
];
const usedNoteReferences = [];
for (const noteReference of noteReferences) {
if (noteReference.stop_sequence === "" || noteReference.stop_sequence === null) {
usedNoteReferences.push(noteReference);
continue;
}
if (noteReference.stop_id === "" || noteReference.stop_id === null) {
timetable.warnings.push(
`Timetable Note Reference for note_id=${noteReference.note_id} has a \`stop_sequence\` but no \`stop_id\` - ignoring`
);
continue;
}
const stop = timetable.stops.find(
(stop2) => stop2.stop_id === noteReference.stop_id
);
if (!stop) {
continue;
}
const tripWithMatchingStopSequence = stop.trips.find(
(trip) => trip.stop_sequence === noteReference.stop_sequence
);
if (tripWithMatchingStopSequence) {
usedNoteReferences.push(noteReference);
}
}
const notes = getTimetableNotes({
note_id: usedNoteReferences.map((noteReference) => noteReference.note_id)
});
const symbols = "abcdefghijklmnopqrstuvwxyz".split("");
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;
symbolIndex += 1;
}
}
const formattedNotes = usedNoteReferences.map((noteReference) => ({
...noteReference,
...notes.find((note) => note.note_id === noteReference.note_id)
}));
return sortBy(formattedNotes, "symbol");
};
var createTimetablePage = ({
timetablePageId,
timetables,
config
}) => {
const updatedTimetables = timetables.map((timetable) => {
if (!timetable.routes) {
timetable.routes = getRoutes({
route_id: timetable.route_ids
});
}
return timetable;
});
const timetablePage = {
timetable_page_id: timetablePageId,
timetables: updatedTimetables,
routes: updatedTimetables.flatMap((timetable) => timetable.routes)
};
const filename = generateTimetablePageFileName(timetablePage, config);
return {
...timetablePage,
filename
};
};
var createTimetable = ({
route,
directionId,
tripHeadsign,
calendars,
calendarDates
}) => {
const serviceIds = uniq([
...calendars?.map((calendar) => calendar.service_id) ?? [],
...calendarDates?.map((calendarDate) => calendarDate.service_id) ?? []
]);
const days2 = {
monday: null,
tuesday: null,
wednesday: null,
thursday: null,
friday: null,
saturday: null,
sunday: null
};
let startDate = null;
let endDate = null;
if (calendars && calendars.length > 0) {
Object.assign(days2, getDaysFromCalendars(calendars));
startDate = parseInt(
moment2.min(
calendars.map((calendar) => moment2(calendar.start_date, "YYYYMMDD"))
).format("YYYYMMDD"),
10
);
endDate = parseInt(
moment2.max(calendars.map((calendar) => moment2(calendar.end_date, "YYYYMMDD"))).format("YYYYMMDD"),
10
);
}
const timetableId = formatTimetableId({
routeIds: [route.route_id],
directionId,
days: days2,
dates: calendarDates?.map((calendarDate) => calendarDate.date)
});
return {
timetable_id: timetableId,
route_ids: [route.route_id],
direction_id: directionId === null ? null : directionId,
direction_name: tripHeadsign === null ? null : tripHeadsign,
routes: [route],
include_exceptions: calendarDates && calendarDates.length > 0 ? 1 : 0,
service_ids: serviceIds,
service_notes: null,
timetable_label: null,
start_time: null,
end_time: null,
orientation: null,
timetable_sequence: null,
show_trip_continuation: null,
start_date: startDate,
end_date: endDate,
...days2
};
};
var convertRoutesToTimetablePages = (config) => {
const routes = getRoutes();
const timetablePages = [];
const { calendars, calendarDates } = getCalendarsFromConfig(config);
for (const route of routes) {
const trips = getTrips(
{
route_id: route.route_id
},
["trip_headsign", "direction_id", "trip_id", "service_id"]
);
const uniqueTripDirections = orderBy(
uniqBy(trips, (trip) => trip.direction_id),
"direction_id"
);
const sortedCalendars = orderBy(calendars, calendarToCalendarCode, "desc");
const calendarGroups = groupBy(sortedCalendars, calendarToCalendarCode);
const calendarDateGroups = groupBy(calendarDates, "service_id");
const timetables = [];
for (const uniqueTripDirection of uniqueTripDirections) {
for (const calendars2 of Object.values(calendarGroups)) {
const tripsForCalendars = trips.filter(
(trip) => some(calendars2, { service_id: trip.service_id })
);
if (tripsForCalendars.length > 0) {
timetables.push(
createTimetable({
route,
directionId: uniqueTripDirection.direction_id,
tripHeadsign: uniqueTripDirection.trip_headsign,
calendars: calendars2
})
);
}
}
for (const calendarDates2 of Object.values(calendarDateGroups)) {
const tripsForCalendarDates = trips.filter(
(trip) => some(calendarDates2, { service_id: trip.service_id })
);
if (tripsForCalendarDates.length > 0) {
timetables.push(
createTimetable({
route,
directionId: uniqueTripDirection.direction_id,
tripHeadsign: uniqueTripDirection.trip_headsign,
calendarDates: calendarDates2
})
);
}
}
}
if (timetables.length === 0) {
continue;
}
if (config.groupTimetablesIntoPages === true) {
timetablePages.push(
createTimetablePage({
timetablePageId: `route_${route.route_id}`,
timetables,
config
})
);
} else {
for (const timetable of timetables) {
timetablePages.push(
createTimetablePage({
timetablePageId: timetable.timetable_id,
timetables: [timetable],
config
})
);
}
}
}
return timetablePages;
};
var generateTripsByFrequencies = (trip, frequencies, config) => {
const formattedFrequencies = frequencies.map(
(frequency) => formatFrequency(frequency, config)
);
const resetTrip = resetStoptimesToMidnight(trip);
const trips = [];
for (const frequency of formattedFrequencies) {
const startSeconds = secondsAfterMidnight(frequency.start_time);
const endSeconds = secondsAfterMidnight(frequency.end_time);
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)
});
}
}
return trips;
};
var duplicateStopsForDifferentArrivalDeparture = (stopIds, timetable, config) => {
if (config.showArrivalOnDifference === null || config.showArrivalOnDifference === void 0) {
return stopIds;
}
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 (timepointDifference < config.showArrivalOnDifference) {
continue;
}
const index = stopIds.indexOf(stoptime.stop_id);
if (index === 0 || index === stopIds.length - 1) {
continue;
}
if (stoptime.stop_id === stopIds[index + 1] || stoptime.stop_id === stopIds[index - 1]) {
continue;
}
stopIds.splice(index, 0, stoptime.stop_id);
}
}
return stopIds;
};
var getStopOrder = (timetable, config) => {
const timetableStopOrders = getTimetableStopOrders(
{
timetable_id: timetable.timetable_id
},
["stop_id"],
[["stop_sequence", "ASC"]]
);
if (timetableStopOrders.length > 0) {
return timetableStopOrders.map(
(timetableStopOrder) => timetableStopOrder.stop_id
);
}
try {
const stopGraph = [];
const timepointStopIds = new Set(
timetable.orderedTrips.flatMap(
(trip) => trip.stoptimes.filter((stoptime) => isTimepoint(stoptime)).map((stoptime) => stoptime.stop_id)
)
);
for (const trip of timetable.orderedTrips) {
const sortedStopIds = trip.stoptimes.filter((stoptime) => {
if (config.showOnlyTimepoint === true) {
return timepointStopIds.has(stoptime.stop_id);
}
return true;
}).map((stoptime) => stoptime.stop_id);
for (const [index, stopId] of sortedStopIds.entries()) {
if (index === sortedStopIds.length - 1) {
continue;
}
stopGraph.push([stopId, sortedStopIds[index + 1]]);
}
}
if (stopGraph.length === 0 && config.showOnlyTimepoint === true) {
timetable.warnings.push(
`Timetable ${timetable.timetable_id}'s trips have stoptimes with timepoints but \`showOnlyTimepoint\` is true. Try setting \`showOnlyTimepoint\` to false.`
);
}
const stopIds = toposort(stopGraph);
return duplicateStopsForDifferentArrivalDeparture(
stopIds,
timetable,
config
);
} catch {
const longestTripStoptimes = getLongestTripStoptimes(
timetable.orderedTrips,
config
);
const stopIds = longestTripStoptimes.map(
(stoptime) => stoptime.stop_id
);
const missingStopIds = difference(
new Set(
timetable.orderedTrips.flatMap(
(trip) => trip.stoptimes.map((stoptime) => stoptime.stop_id)
)
),
new Set(stopIds)
);
if (missingStopIds.length > 0) {
timetable.warnings.push(
`Timetable ${timetable.timetable_id} stops are unable to be topologically sorted and has no \`timetable_stop_order.txt\`. Falling back to using the using the stop order from trip with most stoptimes, but this does not include stop_ids ${formatListForDisplay(missingStopIds)}. Try manually specifying stops with \`timetable_stop_order.txt\`. Read more at https://gtfstohtml.com/docs/timetable-stop-order`
);
}
return duplicateStopsForDifferentArrivalDeparture(
stopIds,
timetable,
config
);
}
};
var getStopsForTimetable = (timetable, config) => {
if (timetable.orderedTrips.length === 0) {
return [];
}
const orderedStopIds = getStopOrder(timetable, config);
const orderedStops = orderedStopIds.map((stopId, index) => {
const stops = getStops({
stop_id: stopId
});
if (stops.length === 0) {
throw new GtfsToHtmlError(
`No stop found found for stop_id=${stopId} in timetable_id=${timetable.timetable_id}`,
{
code: "GTFS_TO_HTML_QUERY_RESULT_NOT_FOUND" /* QUERY_RESULT_NOT_FOUND */,
category: "query" /* QUERY */,
details: {
entity: "stop",
stopId,
timetableId: timetable.timetable_id
}
}
);
}
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;
});
if (config.showStopCity) {
const stopAttributes = getStopAttributes({
stop_id: orderedStopIds
});
for (const stopAttribute of stopAttributes) {
const stop = orderedStops.find(
(stop2) => stop2.stop_id === stopAttribute.stop_id
);
if (stop) {
stop.stop_city = stopAttribute.stop_city;
}
}
}
return orderedStops;
};
var getCalendarsFromConfig = (config) => {
const db = openDb();
let whereClause = "";
const whereClauses = [];
if (config.endDate) {
if (!moment2(config.endDate).isValid()) {
throw new GtfsToHtmlError(
`Invalid endDate=${config.endDate} in config.json`,
{
code: "GTFS_TO_HTML_CONFIG_DATE_INVALID" /* CONFIG_DATE_INVALID */,
category: "config" /* CONFIG */,
details: { field: "endDate", value: config.endDate }
}
);
}
whereClauses.push(
`start_date <= ${sqlString.escape(moment2(config.endDate).format("YYYYMMDD"))}`
);
}
if (config.startDate) {
if (!moment2(config.startDate).isValid()) {
throw new GtfsToHtmlError(
`Invalid startDate=${config.startDate} in config.json`,
{
code: "GTFS_TO_HTML_CONFIG_DATE_INVALID" /* CONFIG_DATE_INVALID */,
category: "config" /* CONFIG */,
details: { field: "startDate", value: config.startDate }
}
);
}
whereClauses.push(
`end_date >= ${sqlString.escape(moment2(config.startDate).format("YYYYMMDD"))}`
);
}
if (whereClauses.length > 0) {
whereClause = `WHERE ${whereClauses.join(" AND ")}`;
}
const calendars = db.prepare(`SELECT * FROM calendar ${whereClause}`).all();
const serviceIds = calendars.map((calendar) => calendar.service_id);
const calendarDatesQuery = serviceIds.length > 0 ? `SELECT * FROM calendar_dates WHERE exception_type = 1 AND service_id NOT IN (${serviceIds.map((serviceId) => sqlString.escape(serviceId)).join(", ")})` : "SELECT * FROM calendar_dates WHERE exception_type = 1";
const calendarDates = db.prepare(calendarDatesQuery).all();
return {
calendars,
calendarDates
};
};
var getCalendarsFromTimetable = (timetable) => {
const db = openDb();
let whereClause = "";
const whereClauses = [];
if (timetable.end_date) {
if (!moment2(timetable.end_date, "YYYYMMDD", true).isValid()) {
throw new GtfsToHtmlError(
`Invalid end_date=${timetable.end_date} for timetable_id=${timetable.timetable_id}`,
{
code: "GTFS_TO_HTML_QUERY_INVALID" /* QUERY_INVALID */,
category: "validation" /* VALIDATION */,
details: {
field: "end_date",
value: timetable.end_date,
timetableId: timetable.timetable_id
}
}
);
}
whereClauses.push(`start_date <= ${sqlString.escape(timetable.end_date)}`);
}
if (timetable.start_date) {
if (!moment2(timetable.start_date, "YYYYMMDD", true).isValid()) {
throw new GtfsToHtmlError(
`Invalid start_date=${timetable.start_date} for timetable_id=${timetable.timetable_id}`,
{
code: "GTFS_TO_HTML_QUERY_INVALID" /* QUERY_INVALID */,
category: "validation" /* VALIDATION */,
details: {
field: "start_date",
value: timetable.start_date,
timetableId: timetable.timetable_id
}
}
);
}
whereClauses.push(`end_date >= ${sqlString.escape(timetable.start_date)}`);
}
const days2 = getDaysFromCalendars([timetable]);
const dayQueries = reduce(
days2,
(memo, value, key) => {
if (value === 1) {
memo.push(`${key} = 1`);
}
return memo;
},
[]
);
if (dayQueries.length > 0) {
whereClauses.push(`(${dayQueries.join(" OR ")})`);
}
if (whereClauses.length > 0) {
whereClause = `WHERE ${whereClauses.join(" AND ")}`;
}
return db.prepare(`SELECT * FROM calendar ${whereClause}`).all();
};
var getCalendarDatesForDateRange = (startDate, endDate) => {
const db = openDb();
const whereClauses = [];
if (endDate) {
whereClauses.push(`date <= ${sqlString.escape(endDate)}`);
}
if (startDate) {
whereClauses.push(`date >= ${sqlString.escape(startDate)}`);
}
const whereClause = whereClauses.length > 0 ? ` WHERE ${whereClauses.join(" AND ")}` : "";
const calendarDates = db.prepare(
`SELECT service_id, date, exception_type FROM calendar_dates${whereClause}`
).all();
return calendarDates;
};
var getAllStationStopIds = (stopId) => {
const stops = getStops({
stop_id: stopId
});
if (stops.length === 0) {
throw new GtfsToHtmlError(`No stop found for stop_id=${stopId}`, {
code: "GTFS_TO_HTML_QUERY_RESULT_NOT_FOUND" /* QUERY_RESULT_NOT_FOUND */,
category: "query" /* QUERY */,
details: { entity: "stop", stopId }
});
}
const stop = stops[0];
if (isNullOrEmpty(stop.parent_station)) {
return [stopId];
}
const stopsInParentStation = getStops(
{
parent_station: stop.parent_station
},
["stop_id"]
);
return [
stop.parent_station,
...stopsInParentStation.map((stop2) => stop2.stop_id)
];
};
var getTripsWithSameBlock = (trip, timetable) => {
const trips = getTrips(
{
block_id: trip.block_id,
service_id: timetable.service_ids
},
["trip_id", "route_id"]
);
for (const blockTrip of trips) {
const stopTimes = getStoptimes(
{
trip_id: blockTrip.trip_id
},
[],
[["stop_sequence", "ASC"]]
);
if (stopTimes.length === 0) {
throw new GtfsToHtmlError(
`No stoptimes found found for trip_id=${blockTrip.trip_id}`,
{
code: "GTFS_TO_HTML_QUERY_RESULT_NOT_FOUND" /* QUERY_RESULT_NOT_FOUND */,
category: "query" /* QUERY */,
details: { entity: "stoptime", tripId: blockTrip.trip_id }
}
);
}
blockTrip.firstStoptime = first(stopTimes);
blockTrip.lastStoptime = last(stopTimes);
}
return sortBy(trips, (trip2) => trip2.firstStoptime.departure_timestamp);
};
var addTripContinuation = (trip, timetable) => {
if (!trip.block_id || trip.stoptimes.length === 0) {
return;
}
const maxContinuesAsWaitingTimeSeconds = 60 * 60;
const firstStoptime = first(trip.stoptimes);
const firstStopIds = getAllStationStopIds(firstStoptime.stop_id);
const lastStoptime = last(trip.stoptimes);
const lastStopIds = getAllStationStopIds(lastStoptime.stop_id);
const blockTrips = getTripsWithSameBlock(trip, timetable);
const previousTrip = findLast(
blockTrips,
(blockTrip) => blockTrip.lastStoptime.arrival_timestamp <= firstStoptime.departure_timestamp
);
if (previousTrip && previousTrip.route_id !== trip.route_id && previousTrip.lastStoptime.arrival_timestamp >= firstStoptime.departure_timestamp - maxContinuesAsWaitingTimeSeconds && firstStopIds.includes(previousTrip.lastStoptime.stop_id)) {
const routes = getRoutes({
route_id: previousTrip.route_id
});
previousTrip.route = routes[0];
trip.continues_from_route = previousTrip;
}
const nextTrip = find(
blockTrips,
(blockTrip) => blockTrip.firstStoptime.departure_timestamp >= lastStoptime.arrival_timestamp
);
if (nextTrip && nextTrip.route_id !== trip.route_id && nextTrip.firstStoptime.departure_timestamp <= lastStoptime.arrival_timestamp + maxContinuesAsWaitingTimeSeconds && lastStopIds.includes(nextTrip.firstStoptime.stop_id)) {
const routes = getRoutes({
route_id: nextTrip.route_id
});
nextTrip.route = routes[0];
trip.continues_as_route = nextTrip;
}
};
var filterTrips = (timetable, calendars, config) => {
let filteredTrips = timetable.orderedTrips;
for (const trip of filteredTrips) {
const combinedStoptimes = [];
for (const [index, st