transit-departures-widget 2.5.5 → 2.7.0

package/README.md

@@ -60,6 +60,32 @@ The following transit agencies use `transit-departures-widget` on their websites
 - [Mountain View Community Shuttle](https://mvcommunityshuttle.com)
 - [MVgo](https://mvgo.org/)
 
+## Quick Start
+
+### CLI
+
+```bash
+npm install transit-departures-widget -g
+transit-departures-widget --configPath ./config-sample.json
+```
+
+Outputs are written to `html/<agency_key>/`:
+
+- `index.html` (full page unless `noHead: true`)
+- `data/routes.json`
+- `data/stops.json`
+- `css/`, `js/` (when `noHead` is false)
+
+### Programmatic
+
+```ts
+import transitDeparturesWidget from 'transit-departures-widget'
+import config from './config.json' assert { type: 'json' }
+
+await transitDeparturesWidget(config)
+// outputs to html/<agency_key>/ by default
+```
+
 ## Command Line Usage
 
 The `transit-departures-widget` command-line utility will download the GTFS file specified in `config.js` and then build the transit departures widget and save the HTML, CSS and JS in `html/:agency_key`.
@@ -92,20 +118,22 @@ Copy `config-sample.json` to `config.json` and then add your projects configurat
 
     cp config-sample.json config.json
 
-| option                                              | type    | description                                                                                                                 |
-| --------------------------------------------------- | ------- | --------------------------------------------------------------------------------------------------------------------------- |
-| [`agency`](#agency)                                 | object  | Information about the GTFS and GTFS-RT to be used.                                                                          |
-| [`beautify`](#beautify)                             | boolean | Whether or not to beautify the HTML output.                                                                                 |
-| [`endDate`](#enddate)                               | string  | A date in YYYYMMDD format to use to filter calendar.txt service. Optional, defaults to using all service in specified GTFS. |
-| [`includeCoordinates`](#includecoordinates)         | boolean  | Whether or not to include stop coordinates in JSON output. |
-| [`locale`](#locale)                                 | string  | The 2-letter code of the language to use for the interface.                                                                 |
-| [`noHead`](#nohead)                                 | boolean | Whether or not to skip the header and footer of the HTML document.                                                          |
-| [`refreshIntervalSeconds`](#refreshIntervalSeconds) | integer | How often the widget should refresh departure data in seconds. Optional, defaults to 20 seconds.                            |
-| [`skipImport`](#skipimport)                         | boolean | Whether or not to skip importing GTFS data into SQLite.                                                                     |
-| [`sqlitePath`](#sqlitepath)                         | string  | A path to an SQLite database. Optional, defaults to using an in-memory database.                                            |
-| [`startDate`](#startdate)                           | string  | A date in YYYYMMDD format to use to filter calendar.txt service. Optional, defaults to using all service in specified GTFS. |
-| [`templatePath`](#templatepath)                     | string  | Path to custom pug template for rendering widget.                                                                           |
-| [`timeFormat`](#timeFormat)                         | string  | The format (12hour or 24hour) for the "as of" display.                                                                      |
+| option                                              | type    | default   | notes                                                                                                                        |
+| --------------------------------------------------- | ------- | --------- | ---------------------------------------------------------------------------------------------------------------------------- |
+| [`agency`](#agency)                                 | object  | —         | Required: GTFS static (url or path) and GTFS-RT trip updates URL.                                                            |
+| [`assetPath`](#assetpath)                           | string  | `''`      | Prefix for assets in HTML; set when hosting assets elsewhere.                                                                |
+| [`beautify`](#beautify)                             | boolean | `false`   | Pretty-print HTML output.                                                                                                   |
+| [`endDate`](#enddate)                               | string  | all svc   | YYYYMMDD calendar filter upper bound.                                                                                        |
+| [`includeCoordinates`](#includecoordinates)         | boolean | `false`   | Include stop lat/lon in `stops.json`.                                                                                        |
+| [`locale`](#locale)                                 | string  | `en`      | UI language code.                                                                                                            |
+| [`noHead`](#nohead)                                 | boolean | `false`   | If true, omit `<html>/<head>/<body>`; only widget markup is output.                                                          |
+| [`outputPath`](#outputpath)                         | string  | `./html/<agency_key>` | Where to write generated files.                                                                                      |
+| [`refreshIntervalSeconds`](#refreshIntervalSeconds) | integer | `20`      | Autorefresh interval on the widget page.                                                                                     |
+| [`skipImport`](#skipimport)                         | boolean | `false`   | Skip GTFS import if DB already populated (`sqlitePath` recommended).                                                         |
+| [`sqlitePath`](#sqlitepath)                         | string  | in-memory | Path to SQLite DB file; enables reusing imports across runs.                                                                 |
+| [`startDate`](#startdate)                           | string  | all svc   | YYYYMMDD calendar filter lower bound.                                                                                        |
+| [`templatePath`](#templatepath)                     | string  | built-in | Custom templates folder (expects `widget.pug` and `widget_full.pug`).                                                        |
+| [`timeFormat`](#timeFormat)                         | string  | `12hour`  | `12hour` or `24hour` time display.                                                                                           |
 
 ### agency
 
@@ -195,6 +223,24 @@ Copy `config-sample.json` to `config.json` and then add your projects configurat
     "noHead": false
 ```
 
+If `noHead` is `true`, you’ll embed the widget into an existing HTML page. See the examples below for including the generated assets.
+
+### assetPath
+
+{String} Prefix to use when linking to generated assets (`css`, `js`). Useful if you host assets on a CDN or a different path from the HTML file.
+
+```
+    "assetPath": "/static/widget/"
+```
+
+### outputPath
+
+{String} Path where generated files are written. Defaults to `./html/<agency_key>`.
+
+```
+    "outputPath": "/var/www/widget-output"
+```
+
 ### refreshIntervalSeconds
 
 {Integer} How often the widget should refresh departure data in seconds. Optional, defaults to 20 seconds.
@@ -259,6 +305,32 @@ By default, `transit-departures-widget` will look for a `config.json` file in th
 
 Once running, you can view the HTML in your browser at [localhost:3000](http://localhost:3000)
 
+## Embedding examples
+
+### Default (with head/footer)
+
+If `noHead` is `false` (default), `index.html` is a complete HTML page with linked assets in `css/` and `js/` under the output directory. You can host that folder as-is (e.g., serve `html/<agency_key>/` from your web server root).
+
+### Headless embed (`noHead: true`)
+
+When `noHead` is `true`, you get only the widget markup. Include the generated CSS/JS and mount it in your page:
+
+```html
+<!doctype html>
+<html>
+  <head>
+    <link rel="stylesheet" href="/path/to/css/transit-departures-widget-styles.css" />
+  </head>
+  <body>
+    <div id="tdw-app"></div>
+    <script src="/path/to/js/transit-departures-widget.js"></script>
+    <script>
+      // Transit Departures Widget initializes itself on load using data/routes.json and data/stops.json
+    </script>
+  </body>
+</html>
+```
+
 ## Notes
 
 `transit-departures-widget` uses the [`node-gtfs`](https://github.com/blinktaginc/node-gtfs) library to handle importing and querying GTFS data.

package/dist/app/index.js

@@ -1,39 +1,46 @@
 // src/app/index.ts
+import { dirname as dirname2, join as join3 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 import { readFileSync } from "fs";
-import { join as join3 } from "path";
 import yargs from "yargs";
-import { getRoutes as getRoutes2, importGtfs, openDb as openDb2 } from "gtfs";
+import { hideBin } from "yargs/helpers";
+import { openDb as openDb2, importGtfs } from "gtfs";
+import express from "express";
 import { clone, omit } from "lodash-es";
 import untildify2 from "untildify";
-import express from "express";
-import logger from "morgan";
-
-// src/lib/utils.ts
-import { join as join2 } from "path";
-import { openDb, getDirections, getRoutes, getStops, getTrips } from "gtfs";
-import { groupBy, last, maxBy, size, sortBy, uniqBy } from "lodash-es";
 
 // src/lib/file-utils.ts
 import { dirname, join, resolve } from "path";
 import { fileURLToPath } from "url";
-import { access, cp, mkdir, readdir, readFile, rm } from "fs/promises";
+import {
+  access,
+  cp,
+  copyFile,
+  mkdir,
+  readdir,
+  readFile,
+  rm
+} from "fs/promises";
 import beautify from "js-beautify";
 import pug from "pug";
 import untildify from "untildify";
-function getPathToViewsFolder(config2) {
-  if (config2.templatePath) {
-    return untildify(config2.templatePath);
-  }
+function getPathToThisModuleFolder() {
   const __dirname = dirname(fileURLToPath(import.meta.url));
-  let viewsFolderPath;
+  let distFolderPath;
   if (__dirname.endsWith("/dist/bin") || __dirname.endsWith("/dist/app")) {
-    viewsFolderPath = resolve(__dirname, "../../views/widget");
+    distFolderPath = resolve(__dirname, "../../");
   } else if (__dirname.endsWith("/dist")) {
-    viewsFolderPath = resolve(__dirname, "../views/widget");
+    distFolderPath = resolve(__dirname, "../");
   } else {
-    viewsFolderPath = resolve(__dirname, "views/widget");
+    distFolderPath = resolve(__dirname, "../../");
   }
-  return viewsFolderPath;
+  return distFolderPath;
+}
+function getPathToViewsFolder(config2) {
+  if (config2.templatePath) {
+    return untildify(config2.templatePath);
+  }
+  return join(getPathToThisModuleFolder(), "views/default");
 }
 function getPathToTemplateFile(templateFileName, config2) {
   const fullTemplateFileName = config2.noHead !== true ? `${templateFileName}_full.pug` : `${templateFileName}.pug`;
@@ -49,15 +56,45 @@ async function renderFile(templateFileName, templateVars, config2) {
 }
 
 // src/lib/utils.ts
+import { openDb, getDirections, getRoutes, getStops, getTrips } from "gtfs";
+import { groupBy, last, maxBy, size, sortBy, uniqBy } from "lodash-es";
 import sqlString from "sqlstring-sqlite";
 import toposort from "toposort";
-import { I18n } from "i18n";
 
-// src/lib/log-utils.ts
+// src/lib/logging/log.ts
 import { clearLine, cursorTo } from "readline";
 import { noop } from "lodash-es";
 import * as colors from "yoctocolors";
-function logWarning(config2) {
+var formatWarning = (text) => {
+  const warningMessage = `${colors.underline("Warning")}: ${text}`;
+  return colors.yellow(warningMessage);
+};
+var formatError = (error) => {
+  const messageText = error instanceof Error ? error.message : error;
+  const errorMessage = `${colors.underline("Error")}: ${messageText.replace(
+    "Error: ",
+    ""
+  )}`;
+  return colors.red(errorMessage);
+};
+var logInfo = (config2) => {
+  if (config2.verbose === false) {
+    return noop;
+  }
+  if (config2.logFunction) {
+    return config2.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);
+  };
+};
+var logWarn = (config2) => {
   if (config2.logFunction) {
     return config2.logFunction;
   }
@@ -66,10 +103,59 @@ function logWarning(config2) {
 ${formatWarning(text)}
 `);
   };
+};
+var logError = (config2) => {
+  if (config2.logFunction) {
+    return config2.logFunction;
+  }
+  return (text) => {
+    process.stdout.write(`
+${formatError(text)}
+`);
+  };
+};
+function createLogger(config2) {
+  return {
+    info: logInfo(config2),
+    warn: logWarn(config2),
+    error: logError(config2)
+  };
 }
-function formatWarning(text) {
-  const warningMessage = `${colors.underline("Warning")}: ${text}`;
-  return colors.yellow(warningMessage);
+
+// src/lib/logging/messages.ts
+var messages = {
+  noActiveCalendarsGlobal: "No active calendars found for the configured date range - returning empty routes and stops",
+  noActiveCalendarsForRoute: (routeId) => `route_id ${routeId} has no active calendars in range - skipping directions`,
+  noActiveCalendarsForDirection: (routeId, directionId) => `route_id ${routeId} direction ${directionId} has no active calendars in range - skipping stops`,
+  routeHasNoDirections: (routeId) => `route_id ${routeId} has no directions - skipping`,
+  stopNotFound: (routeId, directionId, stopId) => `stop_id ${stopId} for route ${routeId} direction ${directionId} not found - dropping`
+};
+
+// src/lib/config/defaults.ts
+import { join as join2 } from "path";
+import { I18n } from "i18n";
+function setDefaultConfig(initialConfig) {
+  const defaults = {
+    beautify: false,
+    noHead: false,
+    refreshIntervalSeconds: 20,
+    skipImport: false,
+    timeFormat: "12hour",
+    includeCoordinates: false,
+    overwriteExistingFiles: true,
+    verbose: true
+  };
+  const config2 = Object.assign(defaults, initialConfig);
+  const viewsFolderPath = getPathToViewsFolder(config2);
+  const i18n = new I18n({
+    directory: join2(viewsFolderPath, "locales"),
+    defaultLocale: config2.locale,
+    updateFiles: false
+  });
+  const configWithI18n = Object.assign(config2, {
+    __: i18n.__
+  });
+  return configWithI18n;
 }
 
 // src/lib/utils.ts
@@ -102,12 +188,20 @@ function formatRouteName(route) {
   return routeName;
 }
 function getDirectionsForRoute(route, config2) {
+  const logger = createLogger(config2);
   const db = openDb(config2);
   const directions = getDirections({ route_id: route.route_id }, [
     "direction_id",
     "direction"
-  ]);
+  ]).filter((direction) => direction.direction_id !== void 0).map((direction) => ({
+    direction_id: direction.direction_id,
+    direction: direction.direction
+  }));
   const calendars = getCalendarsForDateRange(config2);
+  if (calendars.length === 0) {
+    logger.warn(messages.noActiveCalendarsForRoute(route.route_id));
+    return [];
+  }
   if (directions.length === 0) {
     const headsigns = db.prepare(
       `SELECT direction_id, trip_headsign, count(*) AS count FROM trips WHERE route_id = ? AND service_id IN (${calendars.map((calendar) => `'${calendar.service_id}'`).join(", ")}) GROUP BY direction_id, trip_headsign`
@@ -148,11 +242,24 @@ function sortStopIdsBySequence(stoptimes) {
     Object.values(stoptimesGroupedByTrip),
     (stoptimes2) => size(stoptimes2)
   );
+  if (!longestTripStoptimes) {
+    return [];
+  }
   return longestTripStoptimes.map((stoptime) => stoptime.stop_id);
 }
-function getStopsForDirection(route, direction, config2) {
+function getStopsForDirection(route, direction, config2, stopCache) {
+  const logger = createLogger(config2);
   const db = openDb(config2);
   const calendars = getCalendarsForDateRange(config2);
+  if (calendars.length === 0) {
+    logger.warn(
+      messages.noActiveCalendarsForDirection(
+        route.route_id,
+        direction.direction_id
+      )
+    );
+    return [];
+  }
   const whereClause = formatWhereClauses({
     direction_id: direction.direction_id,
     route_id: route.route_id,
@@ -172,14 +279,34 @@ function getStopsForDirection(route, direction, config2) {
     []
   );
   deduplicatedStopIds.pop();
-  const stopFields = ["stop_id", "stop_name", "stop_code", "parent_station"];
+  const stopFields = [
+    "stop_id",
+    "stop_name",
+    "stop_code",
+    "parent_station"
+  ];
   if (config2.includeCoordinates) {
     stopFields.push("stop_lat", "stop_lon");
   }
-  const stops = getStops({ stop_id: deduplicatedStopIds }, stopFields);
-  return deduplicatedStopIds.map(
-    (stopId) => stops.find((stop) => stop.stop_id === stopId)
-  );
+  const missingStopIds = stopCache ? deduplicatedStopIds.filter((stopId) => !stopCache.has(stopId)) : deduplicatedStopIds;
+  const fetchedStops = missingStopIds.length ? getStops(
+    { stop_id: missingStopIds },
+    stopFields
+  ) : [];
+  if (stopCache) {
+    for (const stop of fetchedStops) {
+      stopCache.set(stop.stop_id, stop);
+    }
+  }
+  return deduplicatedStopIds.map((stopId) => {
+    const stop = stopCache?.get(stopId) ?? fetchedStops.find((candidate) => candidate.stop_id === stopId);
+    if (!stop) {
+      logger.warn(
+        messages.stopNotFound(route.route_id, direction.direction_id, stopId)
+      );
+    }
+    return stop;
+  }).filter(Boolean);
 }
 function generateTransitDeparturesWidgetHtml(config2) {
   const templateVars = {
@@ -189,23 +316,37 @@ function generateTransitDeparturesWidgetHtml(config2) {
   return renderFile("widget", templateVars, config2);
 }
 function generateTransitDeparturesWidgetJson(config2) {
+  const logger = createLogger(config2);
+  const calendars = getCalendarsForDateRange(config2);
+  if (calendars.length === 0) {
+    logger.warn(messages.noActiveCalendarsGlobal);
+    return { routes: [], stops: [] };
+  }
   const routes = getRoutes();
   const stops = [];
   const filteredRoutes = [];
-  const calendars = getCalendarsForDateRange(config2);
+  const stopCache = /* @__PURE__ */ new Map();
   for (const route of routes) {
-    route.route_full_name = formatRouteName(route);
-    const directions = getDirectionsForRoute(route, config2);
+    const routeWithFullName = {
+      ...route,
+      route_full_name: formatRouteName(route)
+    };
+    const directions = getDirectionsForRoute(routeWithFullName, config2);
     if (directions.length === 0) {
-      logWarning(config2)(
-        `route_id ${route.route_id} has no directions - skipping`
-      );
+      logger.warn(messages.routeHasNoDirections(route.route_id));
       continue;
     }
-    for (const direction of directions) {
-      const directionStops = getStopsForDirection(route, direction, config2);
+    const directionsWithData = directions.map((direction) => {
+      const directionStops = getStopsForDirection(
+        routeWithFullName,
+        direction,
+        config2,
+        stopCache
+      );
+      if (directionStops.length === 0) {
+        return null;
+      }
       stops.push(...directionStops);
-      direction.stopIds = directionStops.map((stop) => stop?.stop_id);
       const trips = getTrips(
         {
           route_id: route.route_id,
@@ -216,69 +357,82 @@ function generateTransitDeparturesWidgetJson(config2) {
         },
         ["trip_id"]
       );
-      direction.tripIds = trips.map((trip) => trip.trip_id);
+      return {
+        ...direction,
+        stopIds: directionStops.map((stop) => stop.stop_id),
+        tripIds: trips.map((trip) => trip.trip_id)
+      };
+    }).filter(Boolean);
+    if (directionsWithData.length === 0) {
+      continue;
     }
-    route.directions = directions;
-    filteredRoutes.push(route);
+    filteredRoutes.push({
+      ...routeWithFullName,
+      directions: directionsWithData
+    });
   }
-  const sortedRoutes = sortBy(
-    sortBy(filteredRoutes, (route) => route.route_short_name?.toLowerCase()),
-    (route) => Number.parseInt(route.route_short_name, 10)
-  );
-  const parentStationIds = new Set(stops.map((stop) => stop?.parent_station));
+  const sortedRoutes = [...filteredRoutes].sort((a, b) => {
+    const aShort = a.route_short_name ?? "";
+    const bShort = b.route_short_name ?? "";
+    const aNum = Number.parseInt(aShort, 10);
+    const bNum = Number.parseInt(bShort, 10);
+    if (!Number.isNaN(aNum) && !Number.isNaN(bNum) && aNum !== bNum) {
+      return aNum - bNum;
+    }
+    if (Number.isNaN(aNum) && !Number.isNaN(bNum)) {
+      return 1;
+    }
+    if (!Number.isNaN(aNum) && Number.isNaN(bNum)) {
+      return -1;
+    }
+    return aShort.localeCompare(bShort, void 0, {
+      numeric: true,
+      sensitivity: "base"
+    });
+  });
+  const parentStationIds = new Set(stops.map((stop) => stop.parent_station));
   const parentStationStops = getStops(
     { stop_id: Array.from(parentStationIds) },
     ["stop_id", "stop_name", "stop_code", "parent_station"]
   );
   stops.push(
-    ...parentStationStops.map((stop) => {
-      stop.is_parent_station = true;
-      return stop;
-    })
+    ...parentStationStops.map((stop) => ({
+      ...stop,
+      is_parent_station: true
+    }))
   );
   const sortedStops = sortBy(uniqBy(stops, "stop_id"), "stop_name");
   return {
-    routes: removeNulls(sortedRoutes),
-    stops: removeNulls(sortedStops)
+    routes: arrayOfArrays(removeNulls(sortedRoutes)),
+    stops: arrayOfArrays(removeNulls(sortedStops))
   };
 }
 function removeNulls(data) {
   if (Array.isArray(data)) {
     return data.map(removeNulls).filter((item) => item !== null && item !== void 0);
-  } else if (typeof data === "object" && data !== null) {
-    return Object.entries(data).reduce((acc, [key, value]) => {
-      const cleanedValue = removeNulls(value);
-      if (cleanedValue !== null && cleanedValue !== void 0) {
-        acc[key] = cleanedValue;
-      }
-      return acc;
-    }, {});
+  } else if (data !== null && typeof data === "object" && Object.getPrototypeOf(data) === Object.prototype) {
+    return Object.entries(data).reduce(
+      (acc, [key, value]) => {
+        const cleanedValue = removeNulls(value);
+        if (cleanedValue !== null && cleanedValue !== void 0) {
+          acc[key] = cleanedValue;
+        }
+        return acc;
+      },
+      {}
+    );
   } else {
     return data;
   }
 }
-function setDefaultConfig(initialConfig) {
-  const defaults = {
-    beautify: false,
-    noHead: false,
-    refreshIntervalSeconds: 20,
-    skipImport: false,
-    timeFormat: "12hour",
-    includeCoordinates: false,
-    overwriteExistingFiles: true,
-    verbose: true
+function arrayOfArrays(array) {
+  if (array.length === 0) {
+    return { fields: [], rows: [] };
+  }
+  return {
+    fields: Object.keys(array[0]),
+    rows: array.map((item) => Object.values(item))
   };
-  const config2 = Object.assign(defaults, initialConfig);
-  const viewsFolderPath = getPathToViewsFolder(config2);
-  const i18n = new I18n({
-    directory: join2(viewsFolderPath, "locales"),
-    defaultLocale: config2.locale,
-    updateFiles: false
-  });
-  const configWithI18n = Object.assign(config2, {
-    __: i18n.__
-  });
-  return configWithI18n;
 }
 function formatWhereClause(key, value) {
   if (Array.isArray(value)) {
@@ -304,7 +458,7 @@ function formatWhereClauses(query) {
 }
 
 // src/app/index.ts
-var argv = yargs(process.argv).option("c", {
+var argv = yargs(hideBin(process.argv)).option("c", {
   alias: "configPath",
   describe: "Path to config file",
   default: "./config.json",
@@ -319,27 +473,45 @@ config.assetPath = "/";
 config.logFunction = console.log;
 try {
   openDb2(config);
-  getRoutes2();
-} catch (error) {
-  console.log("Importing GTFS");
-  try {
-    const gtfsImportConfig = {
-      ...clone(omit(config, "agency")),
-      agencies: [
-        {
-          agency_key: config.agency.agency_key,
-          path: config.agency.gtfs_static_path,
-          url: config.agency.gtfs_static_url
-        }
-      ]
-    };
-    await importGtfs(gtfsImportConfig);
-  } catch (error2) {
-    console.error(
-      `Unable to open sqlite database "${config.sqlitePath}" defined as \`sqlitePath\` config.json. Ensure the parent directory exists and import GTFS before running this app.`
+  const gtfsPath = config.agency.gtfs_static_path;
+  const gtfsUrl = config.agency.gtfs_static_url;
+  if (!gtfsPath && !gtfsUrl) {
+    throw new Error(
+      "Missing GTFS source. Set `agency.gtfs_static_path` or `agency.gtfs_static_url` in config.json."
     );
-    throw error2;
   }
+  const agencyImportConfig = gtfsPath ? { path: gtfsPath } : { url: gtfsUrl };
+  const gtfsImportConfig = {
+    ...clone(omit(config, "agency")),
+    agencies: [agencyImportConfig]
+  };
+  await importGtfs(gtfsImportConfig);
+} catch (error) {
+  console.error(
+    `Unable to open sqlite database "${config.sqlitePath}" defined as \`sqlitePath\` config.json. Ensure the parent directory exists and run gtfs-to-html to import GTFS before running this app.`
+  );
+  throw error;
+}
+app.set("views", getPathToViewsFolder(config));
+app.set("view engine", "pug");
+app.use((req, res, next) => {
+  console.log(`${req.method} ${req.url}`);
+  next();
+});
+var staticAssetPath = config.templatePath === void 0 ? getPathToViewsFolder(config) : untildify2(config.templatePath);
+app.use(express.static(staticAssetPath));
+var frontendLibraryPaths = [
+  { route: "/js", package: "pbf", subPath: "dist" },
+  { route: "/js", package: "gtfs-realtime-pbf-js-module", subPath: "" },
+  { route: "/js", package: "accessible-autocomplete", subPath: "" },
+  { route: "/css", package: "accessible-autocomplete", subPath: "" }
+];
+var resolvePackagePath = (packageName, subPath) => {
+  const packagePath = dirname2(fileURLToPath2(import.meta.resolve(packageName)));
+  return subPath ? join3(packagePath, subPath) : packagePath;
+};
+for (const { route, package: pkg, subPath } of frontendLibraryPaths) {
+  app.use(route, express.static(resolvePackagePath(pkg, subPath)));
 }
 app.get("/", async (request, response, next) => {
   try {
@@ -365,11 +537,6 @@ app.get("/data/stops.json", async (request, response, next) => {
     next(error);
   }
 });
-app.set("views", getPathToViewsFolder(config));
-app.set("view engine", "pug");
-app.use(logger("dev"));
-var staticAssetPath = config.templatePath === void 0 ? getPathToViewsFolder(config) : untildify2(config.templatePath);
-app.use(express.static(staticAssetPath));
 app.use((req, res) => {
   res.status(404).send("Not Found");
 });