@opentripplanner/core-utils 5.0.3-alpha.1 → 7.0.0-alpha.1

package/src/itinerary.ts

@@ -7,33 +7,37 @@ import {
   Itinerary,
   LatLngArray,
   Leg,
-  Step
+  Money,
+  Step,
+  TncFare
 } from "@opentripplanner/types";
 import turfAlong from "@turf/along";
 
+/*
 import {
-  calculateFares,
-  getLegModeLabel,
-  getModeForPlace,
-  getPlaceName,
-  getStepDirection,
-  getStepInstructions,
-  getStepStreetName,
-  getTimeZoneOffset,
-  getTransitFare
+  // calculateFares,
+  // getLegModeLabel,
+  // getModeForPlace,
+  // getPlaceName,
+  // getStepDirection,
+  // getStepInstructions,
+  // getStepStreetName,
+  // getTimeZoneOffset,
+  // getTransitFare
 } from "./deprecated";
 
 export {
-  calculateFares,
-  getLegModeLabel,
-  getModeForPlace,
-  getPlaceName,
-  getStepDirection,
-  getStepInstructions,
-  getStepStreetName,
-  getTimeZoneOffset,
-  getTransitFare
+  // calculateFares,
+  // getLegModeLabel,
+  // getModeForPlace,
+  // getPlaceName,
+  // getStepDirection,
+  // getStepInstructions,
+  // getStepStreetName,
+  // getTimeZoneOffset,
+  // getTransitFare
 };
+*/
 
 // All OTP transit modes
 export const transitModes = [
@@ -445,12 +449,53 @@ export function calculatePhysicalActivity(
   };
 }
 
-export function calculateTncFares(itinerary) {
-  // TODO: don't rely on deprecated methods!
-  // At the moment this is safe as none of these exported variables contain strings
-  const { maxTNCFare, minTNCFare, tncCurrencyCode } = calculateFares(
-    itinerary,
-    true
-  );
-  return { maxTNCFare, minTNCFare, tncCurrencyCode };
+/**
+ * For an itinerary, calculates the TNC fares and returns an object with
+ * these values and currency info.
+ * It is assumed that the same currency is used for all TNC legs.
+ */
+export function calculateTncFares(itinerary: Itinerary): TncFare {
+  let minTNCFare = 0;
+  let maxTNCFare = 0;
+  let currencyCode;
+  itinerary.legs.forEach(({ hailedCar, mode, tncData }) => {
+    if (mode === "CAR" && hailedCar && tncData) {
+      const { currency, maxCost, minCost } = tncData;
+      minTNCFare += minCost;
+      maxTNCFare += maxCost;
+      // Assumes a single currency for entire itinerary.
+      currencyCode = currency;
+    }
+  });
+
+  return {
+    currencyCode,
+    maxTNCFare,
+    minTNCFare
+  };
+}
+
+/**
+ * For a given fare component (either total fare or component parts), returns
+ * an object with the fare value (in cents).
+ */
+export function getTransitFare(
+  fareComponent: Money
+): {
+  currencyCode: string;
+  transitFare: number;
+} {
+  // Default values (if fare component is not valid).
+  let transitFare = 0;
+  let currencyCode = "USD";
+  if (fareComponent) {
+    // Assign values without declaration.
+    // See: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment#assignment_without_declaration
+    ({ currencyCode } = fareComponent.currency);
+    transitFare = fareComponent.cents;
+  }
+  return {
+    currencyCode,
+    transitFare
+  };
 }

package/src/map.ts

@@ -1,28 +1,16 @@
-import {
-  Company,
-  Itinerary,
-  LatLngArray,
-  Leg,
-  Location,
-  TransitiveData,
-  UserPosition
-} from "@opentripplanner/types";
-import {
-  getPlaceName,
-  isAccessMode,
-  isFlex,
-  isTransit,
-  toSentenceCase
-} from "./itinerary";
+import { LatLngArray, Location, UserPosition } from "@opentripplanner/types";
+import { toSentenceCase } from "./itinerary";
 
+/*
 import {
-  coordsToString,
-  getDetailText,
-  latlngToString,
-  logDeprecationWarning
+  // coordsToString,
+  // getDetailText //,
+  // latlngToString,
+  // logDeprecationWarning
 } from "./deprecated";
 
-export { coordsToString, getDetailText, latlngToString };
+export { coordsToString, getDetailText , latlngToString };
+*/
 
 export function currentPositionToLocation(
   currentPosition: UserPosition
@@ -40,6 +28,12 @@ export function currentPositionToLocation(
   };
 }
 
+// TRICKY: It is used in query.js and in the context of
+// otp-rr actions where the intl context is not available.
+export function coordsToString(coords: number[]): string {
+  return coords.length && coords.map(c => (+c).toFixed(5)).join(", ");
+}
+
 export function stringToCoords(str: string): number[] {
   return (str && str.split(",").map(c => +c)) || [];
 }
@@ -54,23 +48,10 @@ export function constructLocation(latlng: {
   };
 }
 
-export function formatStoredPlaceName(
-  location: Location,
-  withDetails = true
-): string {
-  if (withDetails) {
-    logDeprecationWarning("the formatStoredPlaceName withDetails parameter");
-  }
-
-  let displayName =
-    location.type === "home" || location.type === "work"
-      ? toSentenceCase(location.type)
-      : location.name;
-  if (withDetails) {
-    const detailText = getDetailText(location);
-    if (detailText) displayName += ` (${detailText})`;
-  }
-  return displayName;
+export function formatStoredPlaceName(location: Location): string {
+  return location.type === "home" || location.type === "work"
+    ? toSentenceCase(location.type)
+    : location.name;
 }
 
 export function matchLatLon(location1: Location, location2: Location): boolean {
@@ -78,255 +59,6 @@ export function matchLatLon(location1: Location, location2: Location): boolean {
   return location1.lat === location2.lat && location1.lon === location2.lon;
 }
 
-/**
- * Converts an OTP itinerary object to a transtive.js itinerary object.
- * @param {*} itin Required OTP itinerary (see @opentripplanner/core-utils/types#itineraryType) to convert.
- * @param {*} companies Optional list of companies, used for labeling vehicle rental locations.
- * @param {*} getRouteLabel Optional function that takes an itinerary leg (see @opentripplanner/core-utils/types#legType)
- *                          and returns a string representing the route label to display for that leg.
- * @returns An itinerary in the transitive.js format.
- */
-export function itineraryToTransitive(
-  itin: Itinerary,
-  companies: Company[],
-  getRouteLabel: (leg: Leg) => string,
-  disableFlexArc: boolean
-): TransitiveData {
-  const tdata = {
-    journeys: [],
-    streetEdges: [],
-    places: [],
-    patterns: [],
-    routes: [],
-    stops: []
-  };
-  const routes = {};
-  const stops = {};
-  let streetEdgeId = 0;
-  let patternId = 0;
-
-  const journey = {
-    journey_id: "itin",
-    // This string is not shown in the UI
-    journey_name: "Iterarary-derived Journey",
-    segments: []
-  };
-
-  // add 'from' and 'to' places to the tdata places array
-  tdata.places.push({
-    place_id: "from",
-    place_lat: itin.legs[0].from.lat,
-    place_lon: itin.legs[0].from.lon
-  });
-  tdata.places.push({
-    place_id: "to",
-    place_lat: itin.legs[itin.legs.length - 1].to.lat,
-    place_lon: itin.legs[itin.legs.length - 1].to.lon
-  });
-
-  itin.legs.forEach((leg, idx) => {
-    if (isAccessMode(leg.mode)) {
-      let fromPlaceId: string;
-      if (leg.from.bikeShareId) {
-        fromPlaceId = `bicycle_rent_station_${leg.from.bikeShareId}`;
-        if (
-          // OTP2 Scooter case
-          leg.mode === "SCOOTER"
-        ) {
-          fromPlaceId = `escooter_rent_station_${leg.from.bikeShareId}`;
-        }
-      } else if (leg.from.vertexType === "VEHICLERENTAL") {
-        // OTP1 Scooter case
-        fromPlaceId = `escooter_rent_station_${leg.from.name}`;
-      } else if (
-        leg.mode === "CAR" &&
-        idx > 0 &&
-        itin.legs[idx - 1].mode === "WALK"
-      ) {
-        // create a special place ID for car legs preceded by walking legs
-        fromPlaceId = `itin_car_${streetEdgeId}_from`;
-      } else if (!fromPlaceId) {
-        fromPlaceId = `itin_street_${streetEdgeId}_from`;
-      }
-
-      let toPlaceId;
-      if (leg.to.bikeShareId) {
-        toPlaceId = `bicycle_rent_station_${leg.to.bikeShareId}`;
-        // OTP2 scooter case
-        // Need to check next leg since this is a "to" place "
-        if (leg.mode === "SCOOTER" || itin.legs?.[idx + 1].mode === "SCOOTER") {
-          toPlaceId = `escooter_rent_station_${leg.to.bikeShareId}`;
-        }
-      } else if (leg.to.vertexType === "VEHICLERENTAL") {
-        toPlaceId = `escooter_rent_station_${leg.to.name}`;
-      } else if (
-        leg.mode === "CAR" &&
-        idx < itin.legs.length - 1 &&
-        itin.legs[idx + 1].mode === "WALK"
-      ) {
-        // create a special place ID for car legs followed by walking legs
-        toPlaceId = `itin_car_${streetEdgeId}_to`;
-      } else if (!toPlaceId) {
-        toPlaceId = `itin_street_${streetEdgeId}_to`;
-      }
-
-      const segment = {
-        arc: false,
-        type: leg.mode,
-        streetEdges: [streetEdgeId],
-        from: { type: "PLACE", place_id: fromPlaceId },
-        to: { type: "PLACE", place_id: toPlaceId }
-      };
-      // For TNC segments, draw using an arc
-      if (leg.mode === "CAR" && leg.hailedCar) segment.arc = true;
-      journey.segments.push(segment);
-
-      tdata.streetEdges.push({
-        edge_id: streetEdgeId,
-        geometry: leg.legGeometry
-      });
-      tdata.places.push({
-        place_id: fromPlaceId,
-        // Do not label the from place in addition to the to place. Otherwise,
-        // in some cases (bike rental station) the label for a single place will
-        // appear twice on the rendered transitive view.
-        // See https://github.com/conveyal/trimet-mod-otp/issues/152
-        // place_name: leg.from.name,
-        place_lat: leg.from.lat,
-        place_lon: leg.from.lon
-      });
-      tdata.places.push({
-        place_id: toPlaceId,
-        // This string is not shown in the UI
-        place_name: getPlaceName(leg.to, companies),
-        place_lat: leg.to.lat,
-        place_lon: leg.to.lon
-      });
-      streetEdgeId++;
-    }
-
-    if (isTransit(leg.mode)) {
-      // Flex routes sometimes have the same from and to IDs, but
-      // these stops still need to be rendered separately!
-      if (leg.from.stopId === leg.to.stopId) {
-        leg.to.stopId = `${leg.to.stopId}_flexed_to`;
-      }
-      // determine if we have valid inter-stop geometry
-      const hasInterStopGeometry = !!leg.interStopGeometry;
-      const hasLegGeometry = !!leg.legGeometry?.points;
-      const hasIntermediateStopGeometry =
-        hasInterStopGeometry &&
-        leg.intermediateStops &&
-        leg.interStopGeometry.length === leg.intermediateStops.length + 1;
-
-      // create leg-specific pattern
-      const ptnId = `ptn_${patternId}`;
-      const pattern = {
-        pattern_id: ptnId,
-        // This string is not shown in the UI
-        pattern_name: `Pattern ${patternId}`,
-        route_id: leg.routeId,
-        stops: []
-      };
-
-      // add 'from' stop to stops dictionary and pattern object
-      stops[leg.from.stopId] = {
-        stop_id: leg.from.stopId,
-        stop_name: leg.from.name,
-        stop_lat: leg.from.lat,
-        stop_lon: leg.from.lon
-      };
-      pattern.stops.push({ stop_id: leg.from.stopId });
-
-      // add intermediate stops to stops dictionary and pattern object
-      // If there is no intermediateStopGeometry, do not add the intermediate stops
-      // as it will be straight lines instead of the nice legGeometry (but only if
-      // the legGeometry exists).
-      if (
-        leg.intermediateStops &&
-        (hasIntermediateStopGeometry || !hasLegGeometry)
-      ) {
-        leg.intermediateStops.forEach((stop, i) => {
-          stops[stop.stopId] = {
-            stop_id: stop.stopId,
-            stop_name: stop.name,
-            stop_lat: stop.lat,
-            stop_lon: stop.lon
-          };
-          pattern.stops.push({
-            stop_id: stop.stopId,
-            geometry:
-              hasIntermediateStopGeometry && leg.interStopGeometry[i].points
-          });
-        });
-      }
-
-      // add 'to' stop to stops dictionary and pattern object
-      stops[leg.to.stopId] = {
-        stop_id: leg.to.stopId,
-        stop_name: leg.to.name,
-        stop_lat: leg.to.lat,
-        stop_lon: leg.to.lon
-      };
-      pattern.stops.push({
-        stop_id: leg.to.stopId,
-        geometry:
-          // Some legs don't have intermediateStopGeometry, but do have valid legGeometry
-          (hasInterStopGeometry || hasLegGeometry) &&
-          (hasIntermediateStopGeometry
-            ? leg.interStopGeometry[leg.interStopGeometry.length - 1].points
-            : leg.legGeometry.points)
-      });
-
-      // add route to the route dictionary
-      // with a custom route label if specified.
-      const routeLabel =
-        typeof getRouteLabel === "function"
-          ? getRouteLabel(leg)
-          : leg.routeShortName;
-      routes[leg.routeId] = {
-        agency_id: leg.agencyId,
-        route_id: leg.routeId,
-        route_short_name: routeLabel || "",
-        route_long_name: leg.routeLongName || "",
-        route_type: leg.routeType,
-        route_color: leg.routeColor
-      };
-
-      // add the pattern to the tdata patterns array
-      tdata.patterns.push(pattern);
-
-      // add the pattern reference to the journey object
-      journey.segments.push({
-        arc:
-          typeof disableFlexArc === "undefined" ? isFlex(leg) : !disableFlexArc,
-        type: "TRANSIT",
-        patterns: [
-          {
-            pattern_id: ptnId,
-            from_stop_index: 0,
-            to_stop_index: hasIntermediateStopGeometry
-              ? leg.intermediateStops.length + 2 - 1
-              : 1
-          }
-        ]
-      });
-
-      patternId++;
-    }
-  });
-
-  // add the routes and stops to the tdata arrays
-  tdata.routes.push(...Object.values(routes));
-  tdata.stops.push(...Object.values(stops));
-
-  // add the journey to the tdata journeys array
-  tdata.journeys.push(journey);
-
-  // console.log('derived tdata', tdata);
-  return tdata;
-}
-
 type TransitivePlaceRaw = {
   place_id: string;
 };

package/src/query.js

@@ -1,20 +1,20 @@
-import moment from "moment";
+import { format, isMatch, parse } from "date-fns";
 import getGeocoder from "@opentripplanner/geocoder/lib";
 import qs from "qs";
 
 import { getTransitModes, hasCar, isAccessMode } from "./itinerary";
-import { stringToCoords } from "./map";
+import { coordsToString, stringToCoords } from "./map";
 import queryParams from "./query-params";
 import {
   getCurrentTime,
   getCurrentDate,
-  OTP_API_DATE_FORMAT,
-  OTP_API_TIME_FORMAT
+  OTP_API_TIME_FORMAT,
+  OTP_API_DATE_FORMAT_DATE_FNS
 } from "./time";
 
-import { coordsToString, summarizeQuery } from "./deprecated";
+// import { coordsToString, summarizeQuery } from "./deprecated";
 
-export { summarizeQuery };
+// export { summarizeQuery };
 
 /* The list of default parameters considered in the settings panel */
 
@@ -315,9 +315,15 @@ export function planParamsToQuery(params) {
         break;
       case "time":
         {
-          const parsedTime = moment(params.time, TIME_FORMATS);
-          query.time = parsedTime.isValid()
-            ? parsedTime.format(OTP_API_TIME_FORMAT)
+          // Match one of the supported time formats
+          const matchedTimeFormat = TIME_FORMATS.find(timeFormat =>
+            isMatch(params.time, timeFormat)
+          );
+          query.time = matchedTimeFormat
+            ? format(
+                parse(params.time, matchedTimeFormat, new Date()),
+                OTP_API_TIME_FORMAT
+              )
             : getCurrentTime();
         }
         break;
@@ -421,8 +427,8 @@ export function getRoutingParams(config, currentQuery, ignoreRealtimeUpdates) {
     }
 
     // check date/time validity; ignore both if either is invalid
-    const dateValid = moment(params.date, OTP_API_DATE_FORMAT).isValid();
-    const timeValid = moment(params.time, OTP_API_TIME_FORMAT).isValid();
+    const dateValid = isMatch(params.date, OTP_API_DATE_FORMAT_DATE_FNS);
+    const timeValid = isMatch(params.time, OTP_API_TIME_FORMAT);
 
     if (!dateValid || !timeValid) {
       delete params.time;
@@ -447,11 +453,8 @@ export function getRoutingParams(config, currentQuery, ignoreRealtimeUpdates) {
     // Additional processing specific to PROFILE mode
   } else {
     // check start and end time validity; ignore both if either is invalid
-    const startTimeValid = moment(
-      params.startTime,
-      OTP_API_TIME_FORMAT
-    ).isValid();
-    const endTimeValid = moment(params.endTime, OTP_API_TIME_FORMAT).isValid();
+    const startTimeValid = isMatch(params.startTime, OTP_API_TIME_FORMAT);
+    const endTimeValid = isMatch(params.endTime, OTP_API_TIME_FORMAT);
 
     if (!startTimeValid || !endTimeValid) {
       delete params.startTimeValid;

package/src/time.ts

@@ -1,21 +1,7 @@
 import { Config } from "@opentripplanner/types";
-import {
-  startOfDay,
-  add,
-  format,
-  formatDuration as dateFnsFormatDuration
-} from "date-fns";
+import { startOfDay, add, format } from "date-fns";
 import { utcToZonedTime } from "date-fns-tz";
 
-/* eslint-disable import/no-cycle */
-import {
-  formatTime,
-  formatDurationWithSeconds,
-  formatDuration
-} from "./deprecated-with-types";
-
-export { formatTime, formatDuration, formatDurationWithSeconds };
-
 // special constants for making sure the following date format is always sent to
 // OTP regardless of whatever the user has configured as the display format
 export const OTP_API_DATE_FORMAT = "YYYY-MM-DD";
@@ -24,73 +10,22 @@ export const OTP_API_DATE_FORMAT = "YYYY-MM-DD";
 export const OTP_API_DATE_FORMAT_DATE_FNS = "yyyy-MM-dd";
 export const OTP_API_TIME_FORMAT = "HH:mm";
 
-/**
- * To ease the transition away from moment.js, this method uses date-fns to format durations
- * the way moment.js did.
- * @param {number}  seconds     The number of seconds to format
- * @param {boolean} showSeconds Whether to render seconds or not
- * @param {boolean} localize    If true, will create output like moment.js using date-fns locale.
- * Otherwise, uses date-fns default
- * @returns                   Formatted duration
- */
-export function formatDurationLikeMoment(
-  seconds: number,
-  showSeconds: boolean,
-  localize: { enabled: boolean; code: string } = {
-    enabled: true,
-    code: "en-US"
-  }
-): string {
-  // date-fns doesn't do this automatically
-  if ((!showSeconds && seconds < 60) || seconds === 0) {
-    return "0 min";
-  }
-
-  const hours = Math.floor(seconds / 3600);
-  const minutes = Math.floor((seconds - hours * 3600) / 60);
-  const secondsLeftOver = showSeconds
-    ? seconds - hours * 3600 - minutes * 60
-    : 0;
-  const specLookup = {
-    xHours: "hr",
-    xMinutes: "min",
-    xSeconds: "sec"
-  };
-  const locale = localize
-    ? {
-        // Maintain backwards compatibility when called with localize=true
-        code: localize?.code || "en-US",
-        formatDistance: (spec, val) => {
-          return `${val} ${specLookup[spec]}`;
-        }
-      }
-    : undefined;
-
-  return dateFnsFormatDuration(
-    {
-      hours,
-      minutes,
-      seconds: secondsLeftOver
-    },
-    {
-      format: ["hours", "minutes", "seconds"],
-      locale
-    }
-  );
-}
-
 /**
  * Breaks up a duration in seconds into hours, minutes, and seconds.
  * @param {number} seconds The number of seconds to break up
  * @returns an object with fields with the corresponding, hours, minutes, seconds.
  */
-export function toHoursMinutesSeconds(seconds) {
-  const hours = Math.floor(seconds / 3600);
-  const minutes = Math.floor((seconds - hours * 3600) / 60);
+export function toHoursMinutesSeconds(
+  seconds: number
+): {
+  hours: number;
+  minutes: number;
+  seconds: number;
+} {
   return {
-    hours,
-    minutes,
-    seconds: seconds - hours * 3600 - minutes * 60
+    hours: Math.floor(seconds / 3600),
+    minutes: Math.floor(seconds / 60) % 60,
+    seconds: seconds % 60
   };
 }