gtfs 4.15.4 → 4.15.6

package/dist/index.js

@@ -3175,11 +3175,20 @@ async function prepDirectory(exportPath) {
   await mkdir(exportPath, { recursive: true });
 }
 async function unzip(zipfilePath, exportPath) {
-  const zip = new StreamZip.async({ file: zipfilePath });
-  await zip.extract(null, exportPath);
-  await zip.close();
+  try {
+    const zip = new StreamZip.async({ file: zipfilePath });
+    await zip.extract(null, exportPath);
+    await zip.close();
+  } catch (error) {
+    throw new Error(
+      `Failed to extract zip file: ${error instanceof Error ? error.message : "Unknown error"}`
+    );
+  }
 }
 function generateFolderName(folderName) {
+  if (!folderName || typeof folderName !== "string") {
+    throw new Error("Folder name must be a non-empty string");
+  }
   return snakeCase(sanitize(folderName));
 }
 
@@ -3198,69 +3207,63 @@ import { feature, featureCollection } from "@turf/helpers";
 function isValidJSON(string) {
   try {
     JSON.parse(string);
+    return true;
   } catch (error) {
     return false;
   }
-  return true;
 }
 function isValidLineString(lineString) {
-  if (!lineString) {
+  if (!lineString || lineString.length <= 1) {
     return false;
   }
-  if (lineString.length <= 1) {
-    return false;
-  }
-  if (lineString.length === 2 && lineString[0][0] === lineString[1][0] && lineString[0][1] === lineString[1][1]) {
-    return false;
+  if (lineString.length === 2) {
+    const [[x1, y1], [x2, y2]] = lineString;
+    return !(x1 === x2 && y1 === y2);
   }
   return true;
 }
 function consolidateShapes(shapeGroups) {
   const keys = /* @__PURE__ */ new Set();
   const segmentsArray = shapeGroups.map(
-    (shapes2) => shapes2.reduce(
-      (memo, point, idx) => {
-        if (idx > 0) {
-          memo.push([
-            [shapes2[idx - 1].shape_pt_lon, shapes2[idx - 1].shape_pt_lat],
-            [point.shape_pt_lon, point.shape_pt_lat]
-          ]);
-        }
-        return memo;
-      },
-      []
-    )
+    (shapes2) => shapes2.reduce((memo, point, idx) => {
+      if (idx > 0) {
+        const prevPoint = shapes2[idx - 1];
+        memo.push([
+          [prevPoint.shape_pt_lon, prevPoint.shape_pt_lat],
+          [point.shape_pt_lon, point.shape_pt_lat]
+        ]);
+      }
+      return memo;
+    }, [])
   );
   const consolidatedLineStrings = [];
   for (const segments of segmentsArray) {
     consolidatedLineStrings.push([]);
     for (const segment of segments) {
-      const key1 = `${segment[0][0]},${segment[0][1]},${segment[1][0]},${segment[1][1]}`;
-      const key2 = `${segment[1][0]},${segment[1][1]},${segment[0][0]},${segment[0][1]}`;
+      const key1 = segment.flat().join(",");
+      const key2 = segment.reverse().flat().join(",");
       const currentLine = last(consolidatedLineStrings);
-      if (keys.has(key1) || keys.has(key2)) {
+      if (!currentLine || keys.has(key1) || keys.has(key2)) {
         consolidatedLineStrings.push([]);
-      } else {
-        if (currentLine?.length === 0) {
-          currentLine.push(segment[0]);
-        }
-        currentLine?.push(segment[1]);
-        keys.add(key1);
-        keys.add(key2);
+        continue;
+      }
+      if (currentLine.length === 0) {
+        currentLine.push(segment[0]);
       }
+      currentLine.push(segment[1]);
+      keys.add(key1);
+      keys.add(key2);
     }
   }
   return filter(consolidatedLineStrings, isValidLineString);
 }
 function formatHexColor(color) {
-  if (color === null || color === void 0) {
-    return;
-  }
+  if (!color) return void 0;
   return `#${color}`;
 }
 function formatProperties(properties) {
   const formattedProperties = cloneDeep(
-    omitBy(properties, (value) => value === null || value === void 0)
+    omitBy(properties, (value) => value == null)
   );
   const formattedRouteColor = formatHexColor(properties.route_color);
   const formattedRouteTextColor = formatHexColor(properties.route_text_color);
@@ -3294,7 +3297,7 @@ function stopsToGeoJSONFeatureCollection(stops2) {
   const features = compact(
     stops2.map((stop) => {
       if (!stop.stop_lon || !stop.stop_lat) {
-        return;
+        return void 0;
       }
       return feature(
         {
@@ -3319,14 +3322,14 @@ import { clearLine, cursorTo } from "node:readline";
 import { noop } from "lodash-es";
 import * as colors from "yoctocolors";
 function log(config) {
-  if (config.verbose === false) {
+  if (!config.verbose) {
     return noop;
   }
   if (config.logFunction) {
     return config.logFunction;
   }
-  return (text, overwrite) => {
-    if (overwrite === true && process.stdout.isTTY) {
+  return (text, overwrite = false) => {
+    if (overwrite && process.stdout.isTTY) {
       clearLine(process.stdout, 0);
       cursorTo(process.stdout, 0);
     } else {
@@ -3356,16 +3359,12 @@ ${formatError(text)}
   };
 }
 function formatWarning(text) {
-  const warningMessage = `${colors.underline("Warning")}: ${text}`;
-  return colors.yellow(warningMessage);
+  return colors.yellow(`${colors.underline("Warning")}: ${text}`);
 }
 function formatError(error) {
   const messageText = error instanceof Error ? error.message : error;
-  const errorMessage = `${colors.underline("Error")}: ${messageText.replace(
-    "Error: ",
-    ""
-  )}`;
-  return colors.red(errorMessage);
+  const cleanMessage = messageText.replace(/^Error:\s*/i, "");
+  return colors.red(`${colors.underline("Error")}: ${cleanMessage}`);
 }
 
 // src/lib/utils.ts
@@ -3398,14 +3397,17 @@ function setDefaultConfig(initialConfig) {
 }
 function convertLongTimeToDate(longDate) {
   const { high, low, unsigned } = longDate;
-  return new Date(new Long(low, high, unsigned).toInt() * 1e3).toISOString();
+  return new Date(
+    Long.fromBits(low, high, unsigned).toNumber() * 1e3
+  ).toISOString();
 }
 function calculateSecondsFromMidnight(time) {
-  const split = time.split(":").map((d) => Number.parseInt(d, 10));
-  if (split.length !== 3) {
+  if (!time || typeof time !== "string") return null;
+  const [hours, minutes, seconds] = time.split(":").map(Number);
+  if ([hours, minutes, seconds].some(isNaN) || hours >= 24 || minutes >= 60 || seconds >= 60) {
     return null;
   }
-  return split[0] * 3600 + split[1] * 60 + split[2];
+  return hours * 3600 + minutes * 60 + seconds;
 }
 function padLeadingZeros(time) {
   const split = time.split(":").map((d) => String(Number(d)).padStart(2, "0"));
@@ -3437,19 +3439,22 @@ function degree2radian(angle) {
 function radian2degree(angle) {
   return angle / Math.PI * 180;
 }
+var EARTH_RADIUS_METERS = 6371e3;
 function formatWhereClauseBoundingBox(latitudeDegree, longitudeDegree, boundingBoxSideMeters) {
-  const earthRadius = 6371e3;
-  latitudeDegree = typeof latitudeDegree === "string" ? parseFloat(latitudeDegree) : latitudeDegree;
-  longitudeDegree = typeof longitudeDegree === "string" ? parseFloat(longitudeDegree) : longitudeDegree;
-  const latitudeRadian = degree2radian(latitudeDegree);
-  const radiusFromLatitude = Math.cos(latitudeRadian) * earthRadius;
-  const deltaLatitude = radian2degree(boundingBoxSideMeters / 2 / earthRadius);
-  const deltaLongitude = radian2degree(
-    boundingBoxSideMeters / 2 / radiusFromLatitude
-  );
-  let query = `stop_lat BETWEEN ${latitudeDegree - deltaLatitude} AND ${latitudeDegree + deltaLatitude}`;
-  query += ` AND stop_lon BETWEEN ${longitudeDegree - deltaLongitude} AND ${longitudeDegree + deltaLongitude}`;
-  return query;
+  const lat = Number(latitudeDegree);
+  const lon = Number(longitudeDegree);
+  if (isNaN(lat) || isNaN(lon) || lat < -90 || lat > 90 || lon < -180 || lon > 180) {
+    throw new Error("Invalid latitude or longitude values");
+  }
+  const latitudeRadian = degree2radian(lat);
+  const radiusFromLatitude = Math.cos(latitudeRadian) * EARTH_RADIUS_METERS;
+  const halfSide = boundingBoxSideMeters / 2;
+  const deltaLatitude = radian2degree(halfSide / EARTH_RADIUS_METERS);
+  const deltaLongitude = radian2degree(halfSide / radiusFromLatitude);
+  return [
+    `stop_lat BETWEEN ${lat - deltaLatitude} AND ${lat + deltaLatitude}`,
+    `stop_lon BETWEEN ${lon - deltaLongitude} AND ${lon + deltaLongitude}`
+  ].join(" AND ");
 }
 function formatWhereClause(key, value) {
   if (Array.isArray(value)) {
@@ -3485,7 +3490,7 @@ function formatOrderByClause(orderBy2) {
   return orderByClause;
 }
 function getDayOfWeekFromDate(date) {
-  const daysOfWeek = [
+  const DAYS_OF_WEEK = [
     "sunday",
     "monday",
     "tuesday",
@@ -3494,10 +3499,17 @@ function getDayOfWeekFromDate(date) {
     "friday",
     "saturday"
   ];
-  const dateString = date.toString().replace(/(\d{4})(\d{2})(\d{2})/, "$1-$2-$3");
-  const [year, month, day] = dateString.split("-").map(Number);
-  const dayOfWeek = new Date(year, month - 1, day).getDay();
-  return daysOfWeek[dayOfWeek];
+  if (!Number.isInteger(date) || date.toString().length !== 8) {
+    throw new Error("Date must be in YYYYMMDD format");
+  }
+  const year = Math.floor(date / 1e4);
+  const month = Math.floor(date % 1e4 / 100);
+  const day = date % 100;
+  const dateObj = new Date(year, month - 1, day);
+  if (dateObj.toString() === "Invalid Date") {
+    throw new Error("Invalid date");
+  }
+  return DAYS_OF_WEEK[dateObj.getDay()];
 }
 
 // src/lib/import-gtfs-realtime.ts
@@ -4018,6 +4030,9 @@ var importGtfsFiles = (db, task) => mapSeries2(
     task.log(`Importing - ${filename}\r`);
     const columns = model.schema.filter((column) => column.name !== "id");
     const placeholder = columns.map(({ name }) => `@${name}`).join(", ");
+    const prefixedColumns = new Set(
+      columns.filter((col) => col.prefix).map((col) => col.name)
+    );
     const prepareStatement = `INSERT ${task.ignoreDuplicates ? "OR IGNORE" : ""} INTO ${model.filenameBase} (${columns.map((column) => column.name).join(", ")}) VALUES (${placeholder})`;
     const insert = db.prepare(prepareStatement);
     const insertLines = db.transaction((lines) => {
@@ -4031,7 +4046,7 @@ var importGtfsFiles = (db, task) => mapSeries2(
                 line
               ).map(([columnName, value]) => [
                 columnName,
-                columns.find((col) => col.name === columnName)?.prefix ? `${task.prefix}${value}` : value
+                prefixedColumns.has(columnName) && value !== null ? `${task.prefix}${value}` : value
               ])
             );
             insert.run(prefixedLine);