gtfs-to-html 2.9.2 → 2.9.4

package/dist/index.d.ts

@@ -7,8 +7,8 @@ interface IConfig {
         exclude?: string[];
     }[];
     coordinatePrecision?: number;
-    outputType?: string;
     outputFormat?: string;
+    outputPath?: string;
     startDate?: string;
     endDate?: string;
     verbose?: boolean;
@@ -19,6 +19,6 @@ interface IConfig {
     logError: (text: string) => void;
 }
 
-declare const gtfsToHtml: (initialConfig: IConfig) => Promise<void>;
+declare const gtfsToHtml: (initialConfig: IConfig) => Promise<string>;
 
 export { gtfsToHtml as default };

package/dist/index.js

@@ -5,18 +5,26 @@ var __export = (target, all) => {
 };
 
 // src/lib/gtfs-to-html.ts
-import path2 from "node:path";
+import path from "node:path";
 import { mkdir as mkdir2, writeFile } from "node:fs/promises";
 import { map } from "lodash-es";
 import { openDb as openDb2, importGtfs } from "gtfs";
 import sanitize2 from "sanitize-filename";
 import Timer from "timer-machine";
+import untildify2 from "untildify";
 
 // src/lib/file-utils.ts
-import path from "node:path";
+import { dirname, join, resolve } from "node:path";
 import { createWriteStream } from "node:fs";
 import { fileURLToPath } from "node:url";
-import { access, cp, copyFile, mkdir, readFile, rm } from "node:fs/promises";
+import {
+  access,
+  cp,
+  copyFile,
+  mkdir,
+  readdir,
+  readFile
+} from "node:fs/promises";
 import _ from "lodash-es";
 import archiver from "archiver";
 import beautify from "js-beautify";
@@ -325,7 +333,7 @@ function formatTripNameForCSV(trip, timetable) {
 }
 
 // package.json
-var version = "2.9.1";
+var version = "2.9.3";
 
 // src/lib/utils.ts
 var isTimepoint = (stoptime) => {
@@ -1304,7 +1312,10 @@ function setDefaultConfig(initialConfig) {
     config.menuType = "none";
   }
   config.hasGtfsRealtime = config.agencies.some(
-    (agency) => agency.realtimeTripUpdates?.url || agency.realtimeVehiclePositions?.url
+    (agency) => agency.realtimeTripUpdates?.url || agency.realtimeVehiclePositions?.url || agency.realtimeAlerts?.url
+  );
+  config.hasGtfsRealtimeAlerts = config.agencies.some(
+    (agency) => agency.realtimeAlerts?.url
   );
   return config;
 }
@@ -1787,61 +1798,77 @@ function mergeTimetablesWithSameId(timetables) {
 }
 
 // src/lib/file-utils.ts
-function getTemplatePath(templateFileName, config) {
-  let fullTemplateFileName = templateFileName;
-  if (config.noHead !== true) {
-    fullTemplateFileName += "_full";
+function getPathToViewsFolder(config) {
+  if (config.templatePath) {
+    return untildify(config.templatePath);
+  }
+  const __dirname = dirname(fileURLToPath(import.meta.url));
+  let viewsFolderPath;
+  if (__dirname.endsWith("/dist/bin") || __dirname.endsWith("/dist/app")) {
+    viewsFolderPath = resolve(__dirname, "../../views/default");
+  } else if (__dirname.endsWith("/dist")) {
+    viewsFolderPath = resolve(__dirname, "../views/default");
+  } else {
+    viewsFolderPath = resolve(__dirname, "views/default");
   }
-  const templatePath = config.templatePath === void 0 ? path.join(fileURLToPath(import.meta.url), "../../../views/default") : untildify(config.templatePath);
-  return path.join(templatePath, `${fullTemplateFileName}.pug`);
+  return viewsFolderPath;
 }
-async function prepDirectory(exportPath) {
-  await rm(exportPath, { recursive: true, force: true });
+function getPathToTemplateFile(templateFileName, config) {
+  const fullTemplateFileName = config.noHead !== true ? `${templateFileName}_full.pug` : `${templateFileName}.pug`;
+  return join(getPathToViewsFolder(config), fullTemplateFileName);
+}
+async function prepDirectory(outputPath) {
   try {
-    await mkdir(exportPath, { recursive: true });
+    await access(outputPath);
   } catch (error) {
-    if (error.code === "ENOENT") {
-      throw new Error(
-        `Unable to write to ${exportPath}. Try running this command from a writable directory.`
-      );
+    try {
+      await mkdir(outputPath, { recursive: true });
+    } catch (error2) {
+      if (error2?.code === "ENOENT") {
+        throw new Error(
+          `Unable to write to ${outputPath}. Try running this command from a writable directory.`
+        );
+      }
+      throw error2;
     }
-    throw error;
+  }
+  const files = await readdir(outputPath);
+  if (files.length > 0) {
+    throw new Error(
+      `Output directory ${outputPath} is not empty. Please specify an empty directory.`
+    );
   }
 }
-async function copyStaticAssets(config, exportPath) {
-  const staticAssetPath = config.templatePath === void 0 ? path.join(fileURLToPath(import.meta.url), "../../../views/default") : untildify(config.templatePath);
+async function copyStaticAssets(config, outputPath) {
+  const viewsFolderPath = getPathToViewsFolder(config);
   const foldersToCopy = ["css", "js", "img"];
   for (const folder of foldersToCopy) {
-    if (await access(path.join(staticAssetPath, folder)).then(() => true).catch(() => false)) {
-      await cp(
-        path.join(staticAssetPath, folder),
-        path.join(exportPath, folder),
-        {
-          recursive: true
-        }
-      );
+    if (await access(join(viewsFolderPath, folder)).then(() => true).catch(() => false)) {
+      await cp(join(viewsFolderPath, folder), join(outputPath, folder), {
+        recursive: true
+      });
     }
   }
   if (config.hasGtfsRealtime) {
     await copyFile(
       "node_modules/pbf/dist/pbf.js",
-      path.join(exportPath, "js/pbf.js")
+      join(outputPath, "js/pbf.js")
     );
     await copyFile(
       "node_modules/gtfs-realtime-pbf-js-module/gtfs-realtime.browser.proto.js",
-      path.join(exportPath, "js/gtfs-realtime.browser.proto.js")
+      join(outputPath, "js/gtfs-realtime.browser.proto.js")
     );
   }
 }
-function zipFolder(exportPath) {
-  const output = createWriteStream(path.join(exportPath, "timetables.zip"));
+function zipFolder(outputPath) {
+  const output = createWriteStream(join(outputPath, "timetables.zip"));
   const archive = archiver("zip");
-  return new Promise((resolve, reject) => {
-    output.on("close", resolve);
+  return new Promise((resolve2, reject) => {
+    output.on("close", resolve2);
     archive.on("error", reject);
     archive.pipe(output);
     archive.glob("**/*.{txt,css,js,html}", {
-      cwd: exportPath
+      cwd: outputPath
     });
     archive.finalize();
   });
@@ -1865,7 +1892,7 @@ function generateFolderName(timetablePage) {
   return sanitize(`${timetable.start_date}-${timetable.end_date}`);
 }
 async function renderTemplate(templateFileName, templateVars, config) {
-  const templatePath = getTemplatePath(templateFileName, config);
+  const templatePath = getPathToTemplateFile(templateFileName, config);
   const html = await renderFile(templatePath, {
     _,
     md: (text) => insane(marked.parseInline(text)),
@@ -2075,8 +2102,8 @@ var gtfsToHtml = async (initialConfig) => {
   const agencyKey = config.agencies.map(
     (agency) => agency.agencyKey ?? agency.agency_key ?? "unknown"
   ).join("-");
-  const exportPath = path2.join(process.cwd(), "html", sanitize2(agencyKey));
-  const outputStats = {
+  const outputPath = config.outputPath ? untildify2(config.outputPath) : path.join(process.cwd(), "html", sanitize2(agencyKey));
+  const stats = {
     timetables: 0,
     timetablePages: 0,
     calendars: 0,
@@ -2090,9 +2117,9 @@ var gtfsToHtml = async (initialConfig) => {
     getTimetablePagesForAgency(config),
     "timetable_page_id"
   );
-  await prepDirectory(exportPath);
+  await prepDirectory(outputPath);
   if (config.noHead !== true && ["html", "pdf"].includes(config.outputFormat)) {
-    await copyStaticAssets(config, exportPath);
+    await copyStaticAssets(config, outputPath);
   }
   const bar = progressBar(
     `${agencyKey}: Generating ${config.outputFormat.toUpperCase()} timetables {bar} {value}/{total}`,
@@ -2107,7 +2134,7 @@ var gtfsToHtml = async (initialConfig) => {
       );
       for (const timetable of timetablePage.timetables) {
         for (const warning of timetable.warnings) {
-          outputStats.warnings.push(warning);
+          stats.warnings.push(warning);
           bar?.interrupt(warning);
         }
       }
@@ -2116,20 +2143,20 @@ var gtfsToHtml = async (initialConfig) => {
           `No timetables found for timetable_page_id=${timetablePage.timetable_page_id}`
         );
       }
-      outputStats.timetables += timetablePage.consolidatedTimetables.length;
-      outputStats.timetablePages += 1;
+      stats.timetables += timetablePage.consolidatedTimetables.length;
+      stats.timetablePages += 1;
       const datePath = generateFolderName(timetablePage);
-      await mkdir2(path2.join(exportPath, datePath), { recursive: true });
+      await mkdir2(path.join(outputPath, datePath), { recursive: true });
       config.assetPath = "../";
-      timetablePage.relativePath = path2.join(
+      timetablePage.relativePath = path.join(
         datePath,
         sanitize2(timetablePage.filename)
       );
       if (config.outputFormat === "csv") {
         for (const timetable of timetablePage.consolidatedTimetables) {
           const csv = await generateTimetableCSV(timetable);
-          const csvPath = path2.join(
-            exportPath,
+          const csvPath = path.join(
+            outputPath,
             datePath,
             generateFileName(timetable, config, "csv")
           );
@@ -2137,8 +2164,8 @@ var gtfsToHtml = async (initialConfig) => {
         }
       } else {
         const html = await generateTimetableHTML(timetablePage, config);
-        const htmlPath = path2.join(
-          exportPath,
+        const htmlPath = path.join(
+          outputPath,
           datePath,
           sanitize2(timetablePage.filename)
         );
@@ -2149,12 +2176,12 @@ var gtfsToHtml = async (initialConfig) => {
       }
       timetablePages.push(timetablePage);
       const timetableStats = generateStats(timetablePage);
-      outputStats.stops += timetableStats.stops;
-      outputStats.routes += timetableStats.routes;
-      outputStats.trips += timetableStats.trips;
-      outputStats.calendars += timetableStats.calendars;
+      stats.stops += timetableStats.stops;
+      stats.routes += timetableStats.routes;
+      stats.trips += timetableStats.trips;
+      stats.calendars += timetableStats.calendars;
     } catch (error) {
-      outputStats.warnings.push(error?.message);
+      stats.warnings.push(error?.message);
       bar?.interrupt(error.message);
     }
     bar?.increment();
@@ -2162,26 +2189,27 @@ var gtfsToHtml = async (initialConfig) => {
   if (config.outputFormat === "html") {
     config.assetPath = "";
     const html = await generateOverviewHTML(timetablePages, config);
-    await writeFile(path2.join(exportPath, "index.html"), html);
+    await writeFile(path.join(outputPath, "index.html"), html);
   }
-  const logText = generateLogText(outputStats, config);
-  await writeFile(path2.join(exportPath, "log.txt"), logText);
+  const logText = generateLogText(stats, config);
+  await writeFile(path.join(outputPath, "log.txt"), logText);
   if (config.zipOutput) {
-    await zipFolder(exportPath);
+    await zipFolder(outputPath);
   }
-  const fullExportPath = path2.join(
-    exportPath,
+  const fullOutputPath = path.join(
+    outputPath,
     config.zipOutput ? "/timetables.zip" : ""
   );
   config.log(
-    `${agencyKey}: ${config.outputFormat.toUpperCase()} timetables created at ${fullExportPath}`
+    `${agencyKey}: ${config.outputFormat.toUpperCase()} timetables created at ${fullOutputPath}`
   );
-  logStats(outputStats, config);
+  logStats(stats, config);
   const seconds = Math.round(timer.time() / 1e3);
   config.log(
     `${agencyKey}: ${config.outputFormat.toUpperCase()} timetable generation required ${seconds} seconds`
   );
   timer.stop();
+  return fullOutputPath;
 };
 var gtfs_to_html_default = gtfsToHtml;
 export {