@opentripplanner/core-utils 4.11.6-alpha.1 → 5.0.1

package/src/{itinerary.js → itinerary.ts}

@@ -1,4 +1,14 @@
 import polyline from "@mapbox/polyline";
+import {
+  Company,
+  Config,
+  ElevationProfile,
+  FlexBookingInfo,
+  Itinerary,
+  LatLngArray,
+  Leg,
+  Step
+} from "@opentripplanner/types";
 import turfAlong from "@turf/along";
 
 import {
@@ -40,13 +50,16 @@ export const transitModes = [
  * @return {Array}  List of all transit modes defined in config; otherwise default mode list
  */
 
-export function getTransitModes(config) {
+export function getTransitModes(config: Config): string[] {
   if (!config || !config.modes || !config.modes.transitModes)
     return transitModes;
-  return config.modes.transitModes.map(tm => tm.mode);
+
+  return config.modes.transitModes.map(tm =>
+    typeof tm !== "string" ? tm.mode : tm
+  );
 }
 
-export function isTransit(mode) {
+export function isTransit(mode: string): boolean {
   return transitModes.includes(mode) || mode === "TRANSIT";
 }
 
@@ -55,7 +68,7 @@ export function isTransit(mode) {
  * calling ahead for the service to run. "mustPhone" is the only
  * property of boardRule which encodes this info.
  */
-export function isReservationRequired(leg) {
+export function isReservationRequired(leg: Leg): boolean {
   return leg.boardRule === "mustPhone";
 }
 /**
@@ -63,53 +76,53 @@ export function isReservationRequired(leg) {
  * asking the driver to let the user off. "coordinateWithDriver" is the only
  * property of alightRule which encodes this info.
  */
-export function isContinuousDropoff(leg) {
+export function isContinuousDropoff(leg: Leg): boolean {
   return leg.alightRule === "coordinateWithDriver";
 }
 /**
  * The two rules checked by the above two functions are the only values
  * returned by OTP when a leg is a flex leg.
  */
-export function isFlex(leg) {
+export function isFlex(leg: Leg): boolean {
   return isReservationRequired(leg) || isContinuousDropoff(leg);
 }
 
-export function isAdvanceBookingRequired(info) {
+export function isAdvanceBookingRequired(info: FlexBookingInfo): boolean {
   return info?.latestBookingTime?.daysPrior > 0;
 }
-export function legDropoffRequiresAdvanceBooking(leg) {
+export function legDropoffRequiresAdvanceBooking(leg: Leg): boolean {
   return isAdvanceBookingRequired(leg.dropOffBookingInfo);
 }
 
-export function isWalk(mode) {
+export function isWalk(mode: string): boolean {
   if (!mode) return false;
 
   return mode === "WALK";
 }
 
-export function isBicycle(mode) {
+export function isBicycle(mode: string): boolean {
   if (!mode) return false;
 
   return mode === "BICYCLE";
 }
 
-export function isBicycleRent(mode) {
+export function isBicycleRent(mode: string): boolean {
   if (!mode) return false;
 
   return mode === "BICYCLE_RENT";
 }
 
-export function isCar(mode) {
+export function isCar(mode: string): boolean {
   if (!mode) return false;
   return mode.startsWith("CAR");
 }
 
-export function isMicromobility(mode) {
+export function isMicromobility(mode: string): boolean {
   if (!mode) return false;
   return mode.startsWith("MICROMOBILITY") || mode.startsWith("SCOOTER");
 }
 
-export function isAccessMode(mode) {
+export function isAccessMode(mode: string): boolean {
   return (
     isWalk(mode) ||
     isBicycle(mode) ||
@@ -123,7 +136,7 @@ export function isAccessMode(mode) {
  * @param  {string}  modesStr a comma-separated list of OTP modes
  * @return {boolean} whether any of the modes are transit modes
  */
-export function hasTransit(modesStr) {
+export function hasTransit(modesStr: string): boolean {
   return modesStr.split(",").some(mode => isTransit(mode));
 }
 
@@ -131,7 +144,7 @@ export function hasTransit(modesStr) {
  * @param  {string}  modesStr a comma-separated list of OTP modes
  * @return {boolean} whether any of the modes are car-based modes
  */
-export function hasCar(modesStr) {
+export function hasCar(modesStr: string): boolean {
   return modesStr.split(",").some(mode => isCar(mode));
 }
 
@@ -139,7 +152,7 @@ export function hasCar(modesStr) {
  * @param  {string}  modesStr a comma-separated list of OTP modes
  * @return {boolean} whether any of the modes are bicycle-based modes
  */
-export function hasBike(modesStr) {
+export function hasBike(modesStr: string): boolean {
   return modesStr
     .split(",")
     .some(mode => isBicycle(mode) || isBicycleRent(mode));
@@ -149,7 +162,7 @@ export function hasBike(modesStr) {
  * @param  {string}  modesStr a comma-separated list of OTP modes
  * @return {boolean} whether any of the modes are micromobility-based modes
  */
-export function hasMicromobility(modesStr) {
+export function hasMicromobility(modesStr: string): boolean {
   return modesStr.split(",").some(mode => isMicromobility(mode));
 }
 
@@ -157,7 +170,7 @@ export function hasMicromobility(modesStr) {
  * @param  {string}  modesStr a comma-separated list of OTP modes
  * @return {boolean} whether any of the modes is a hailing mode
  */
-export function hasHail(modesStr) {
+export function hasHail(modesStr: string): boolean {
   return modesStr.split(",").some(mode => mode.indexOf("_HAIL") > -1);
 }
 
@@ -165,11 +178,11 @@ export function hasHail(modesStr) {
  * @param  {string}  modesStr a comma-separated list of OTP modes
  * @return {boolean} whether any of the modes is a rental mode
  */
-export function hasRental(modesStr) {
+export function hasRental(modesStr: string): boolean {
   return modesStr.split(",").some(mode => mode.indexOf("_RENT") > -1);
 }
 
-export function getMapColor(mode) {
+export function getMapColor(mode: string): string {
   mode = mode || this.get("mode");
   if (mode === "WALK") return "#444";
   if (mode === "BICYCLE") return "#0073e5";
@@ -183,7 +196,7 @@ export function getMapColor(mode) {
   return "#aaa";
 }
 
-export function toSentenceCase(str) {
+export function toSentenceCase(str: string): string {
   if (str == null) {
     return "";
   }
@@ -194,7 +207,7 @@ export function toSentenceCase(str) {
 /**
  * Derive the company string based on mode and network associated with leg.
  */
-export function getCompanyFromLeg(leg) {
+export function getCompanyFromLeg(leg: Leg): string {
   if (!leg) return null;
   const { from, mode, rentedBike, rentedCar, rentedVehicle, tncData } = leg;
   if (mode === "CAR" && rentedCar) {
@@ -216,12 +229,12 @@ export function getCompanyFromLeg(leg) {
   return null;
 }
 
-export function getItineraryBounds(itinerary) {
+export function getItineraryBounds(itinerary: Itinerary): LatLngArray[] {
   let coords = [];
   itinerary.legs.forEach(leg => {
     const legCoords = polyline
       .toGeoJSON(leg.legGeometry.points)
-      .coordinates.map(c => [c[1], c[0]]);
+      .coordinates.map((c: number[]) => [c[1], c[0]]);
     coords = [...coords, ...legCoords];
   });
   return coords;
@@ -230,7 +243,7 @@ export function getItineraryBounds(itinerary) {
 /**
  * Return a coords object that encloses the given leg's geometry.
  */
-export function getLegBounds(leg) {
+export function getLegBounds(leg: Leg): number[] {
   const coords = polyline
     .toGeoJSON(leg.legGeometry.points)
     .coordinates.map(c => [c[1], c[0]]);
@@ -246,7 +259,7 @@ export function getLegBounds(leg) {
 
 /* Returns an interpolated lat-lon at a specified distance along a leg */
 
-export function legLocationAtDistance(leg, distance) {
+export function legLocationAtDistance(leg: Leg, distance: number): number[] {
   if (!leg.legGeometry) return null;
 
   try {
@@ -264,7 +277,10 @@ export function legLocationAtDistance(leg, distance) {
 
 /* Returns an interpolated elevation at a specified distance along a leg */
 
-export function legElevationAtDistance(points, distance) {
+export function legElevationAtDistance(
+  points: number[][],
+  distance: number
+): number {
   // Iterate through the combined elevation profile
   let traversed = 0;
   // If first point distance is not zero, insert starting point at zero with
@@ -302,7 +318,10 @@ export function legElevationAtDistance(points, distance) {
 
 // Iterate through the steps, building the array of elevation points and
 // keeping track of the minimum and maximum elevations reached
-export function getElevationProfile(steps, unitConversion = 1) {
+export function getElevationProfile(
+  steps: Step[],
+  unitConversion = 1
+): ElevationProfile {
   let minElev = 100000;
   let maxElev = -100000;
   let traversed = 0;
@@ -349,11 +368,14 @@ export function getElevationProfile(steps, unitConversion = 1) {
  *
  * @see https://stackoverflow.com/questions/118241/calculate-text-width-with-javascript/21015393#21015393
  */
-export function getTextWidth(text, font = "22px Arial") {
+export function getTextWidth(text: string, font = "22px Arial"): number {
+  // Create custom type for function including re-used canvas object
+  type GetTextWidth = typeof getTextWidth & { canvas: HTMLCanvasElement };
+
   // re-use canvas object for better performance
   const canvas =
-    getTextWidth.canvas ||
-    (getTextWidth.canvas = document.createElement("canvas"));
+    (getTextWidth as GetTextWidth).canvas ||
+    ((getTextWidth as GetTextWidth).canvas = document.createElement("canvas"));
   const context = canvas.getContext("2d");
   context.font = font;
   const metrics = context.measureText(text);
@@ -364,7 +386,10 @@ export function getTextWidth(text, font = "22px Arial") {
  * Get the configured company object for the given network string if the company
  * has been defined in the provided companies array config.
  */
-export function getCompanyForNetwork(networkString, companies = []) {
+export function getCompanyForNetwork(
+  networkString: string,
+  companies: Company[] = []
+): Company {
   const company = companies.find(co => co.id === networkString);
   if (!company) {
     console.warn(
@@ -382,7 +407,10 @@ export function getCompanyForNetwork(networkString, companies = []) {
  * @param  {Array<object>}  [companies=[]] An optional list of the companies config.
  * @return {string}  A label for use in presentation on a website.
  */
-export function getCompaniesLabelFromNetworks(networks, companies = []) {
+export function getCompaniesLabelFromNetworks(
+  networks: string[],
+  companies: Company[] = []
+): string {
   return networks
     .map(network => getCompanyForNetwork(network, companies))
     .filter(co => !!co)
@@ -390,12 +418,18 @@ export function getCompaniesLabelFromNetworks(networks, companies = []) {
     .join("/");
 }
 
-export function getTNCLocation(leg, type) {
+export function getTNCLocation(leg: Leg, type: string): string {
   const location = leg[type];
   return `${location.lat.toFixed(5)},${location.lon.toFixed(5)}`;
 }
 
-export function calculatePhysicalActivity(itinerary) {
+export function calculatePhysicalActivity(
+  itinerary: Itinerary
+): {
+  bikeDuration: number;
+  caloriesBurned: number;
+  walkDuration: number;
+} {
   let walkDuration = 0;
   let bikeDuration = 0;
   itinerary.legs.forEach(leg => {

package/src/{map.js → map.ts}

@@ -1,9 +1,18 @@
+import {
+  Company,
+  Itinerary,
+  LatLngArray,
+  Leg,
+  Location,
+  TransitiveData,
+  UserPosition
+} from "@opentripplanner/types";
 import {
   getPlaceName,
-  isTransit,
+  isAccessMode,
   isFlex,
-  toSentenceCase,
-  isAccessMode
+  isTransit,
+  toSentenceCase
 } from "./itinerary";
 
 import {
@@ -15,7 +24,9 @@ import {
 
 export { coordsToString, getDetailText, latlngToString };
 
-export function currentPositionToLocation(currentPosition) {
+export function currentPositionToLocation(
+  currentPosition: UserPosition
+): Location {
   if (currentPosition.error || !currentPosition.coords) {
     console.warn(
       "Cannot construct location from current position due to geolocation error or missing coordinates."
@@ -29,18 +40,24 @@ export function currentPositionToLocation(currentPosition) {
   };
 }
 
-export function stringToCoords(str) {
+export function stringToCoords(str: string): number[] {
   return (str && str.split(",").map(c => +c)) || [];
 }
 
-export function constructLocation(latlng) {
+export function constructLocation(latlng: {
+  lat: number;
+  lng: number;
+}): Location {
   return {
     lat: latlng.lat,
     lon: latlng.lng
   };
 }
 
-export function formatStoredPlaceName(location, withDetails = true) {
+export function formatStoredPlaceName(
+  location: Location,
+  withDetails = true
+): string {
   if (withDetails) {
     logDeprecationWarning("the formatStoredPlaceName withDetails parameter");
   }
@@ -56,7 +73,7 @@ export function formatStoredPlaceName(location, withDetails = true) {
   return displayName;
 }
 
-export function matchLatLon(location1, location2) {
+export function matchLatLon(location1: Location, location2: Location): boolean {
   if (!location1 || !location2) return location1 === location2;
   return location1.lat === location2.lat && location1.lon === location2.lon;
 }
@@ -70,11 +87,11 @@ export function matchLatLon(location1, location2) {
  * @returns An itinerary in the transitive.js format.
  */
 export function itineraryToTransitive(
-  itin,
-  companies,
-  getRouteLabel,
-  disableFlexArc
-) {
+  itin: Itinerary,
+  companies: Company[],
+  getRouteLabel: (leg: Leg) => string,
+  disableFlexArc: boolean
+): TransitiveData {
   const tdata = {
     journeys: [],
     streetEdges: [],
@@ -109,20 +126,17 @@ export function itineraryToTransitive(
 
   itin.legs.forEach((leg, idx) => {
     if (isAccessMode(leg.mode)) {
-      let fromPlaceId;
-      if (
-        leg.from.bikeShareId &&
-        (leg.mode === "BICYCLE" || leg.mode === "BICYCLE_RENT")
-      ) {
+      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.name}`;
+          fromPlaceId = `escooter_rent_station_${leg.from.bikeShareId}`;
         }
-        // OTP1 Scooter case
       } else if (leg.from.vertexType === "VEHICLERENTAL") {
+        // OTP1 Scooter case
         fromPlaceId = `escooter_rent_station_${leg.from.name}`;
       } else if (
         leg.mode === "CAR" &&
@@ -131,13 +145,18 @@ export function itineraryToTransitive(
       ) {
         // create a special place ID for car legs preceded by walking legs
         fromPlaceId = `itin_car_${streetEdgeId}_from`;
-      } else {
+      } 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 (
@@ -147,11 +166,12 @@ export function itineraryToTransitive(
       ) {
         // create a special place ID for car legs followed by walking legs
         toPlaceId = `itin_car_${streetEdgeId}_to`;
-      } else {
+      } else if (!toPlaceId) {
         toPlaceId = `itin_street_${streetEdgeId}_to`;
       }
 
       const segment = {
+        arc: false,
         type: leg.mode,
         streetEdges: [streetEdgeId],
         from: { type: "PLACE", place_id: fromPlaceId },
@@ -307,27 +327,30 @@ export function itineraryToTransitive(
   return tdata;
 }
 
-export function isBikeshareStation(place) {
+type TransitivePlaceRaw = {
+  place_id: string;
+};
+export function isBikeshareStation(place: TransitivePlaceRaw): boolean {
   return place.place_id.lastIndexOf("bicycle_rent_station") !== -1;
 }
 
-export function isEScooterStation(place) {
+export function isEScooterStation(place: TransitivePlaceRaw): boolean {
   return place.place_id.lastIndexOf("escooter_rent_station") !== -1;
 }
 
-export function isCarWalkTransition(place) {
+export function isCarWalkTransition(place: TransitivePlaceRaw): boolean {
   return place.place_id.lastIndexOf("itin_car_") !== -1;
 }
 
-export function isValidLat(lat) {
+export function isValidLat(lat: number): boolean {
   return Number.isFinite(lat) && lat >= -90 && lat <= 90;
 }
 
-export function isValidLng(lng) {
+export function isValidLng(lng: number): boolean {
   return Number.isFinite(lng) && lng >= -180 && lng <= 180;
 }
 
-export function isValidLatLng(arr) {
+export function isValidLatLng(arr: LatLngArray): boolean {
   return (
     Array.isArray(arr) &&
     arr.length === 2 &&

package/src/{route.js → route.ts}

@@ -1,3 +1,4 @@
+import { Leg, Route, TransitOperator } from "@opentripplanner/types";
 /**
  * Returns the transit operator (if an exact match is found) from the transit
  * operators config value. It is critical to use both the feedId and agencyId in
@@ -11,10 +12,10 @@
  *    was found
  */
 export function getTransitOperatorFromFeedIdAndAgencyId(
-  feedId,
-  agencyId,
-  transitOperators
-) {
+  feedId: string,
+  agencyId: string | number,
+  transitOperators: TransitOperator[]
+): TransitOperator {
   return (
     transitOperators.find(
       transitOperator =>
@@ -32,7 +33,10 @@ export function getTransitOperatorFromFeedIdAndAgencyId(
  * @param  {object} transitOperators transitOperators from config.
  * @return {object} the operator if one was found or null if no match was found
  */
-export function getTransitOperatorFromLeg(leg, transitOperators) {
+export function getTransitOperatorFromLeg(
+  leg: Leg,
+  transitOperators: TransitOperator[]
+): TransitOperator {
   if (!leg.routeId || !leg.agencyId) return null;
   const feedId = leg.routeId.split(":")[0];
   return getTransitOperatorFromFeedIdAndAgencyId(
@@ -52,10 +56,13 @@ export function getTransitOperatorFromLeg(leg, transitOperators) {
  * @param  {array} transitOperators transitOperators from config
  * @return {object} the operator if one was found or null if no match was found
  */
-export function getTransitOperatorFromOtpRoute(route, transitOperators) {
+export function getTransitOperatorFromOtpRoute(
+  route: Route,
+  transitOperators: TransitOperator[]
+): TransitOperator {
   if (!route.id) return null;
   const feedId = route.id.split(":")[0];
-  let agencyId;
+  let agencyId: string | number;
   if (route.agency) {
     // This is returned in the OTP Route model
     agencyId = route.agency.id;
@@ -97,7 +104,10 @@ const END_OF_LIST_COMPARATOR_VALUE = 999999999999;
  *   the transitOperators value is not defined. Otherwise an integer will be
  *   returned.
  */
-function getTransitOperatorComparatorValue(route, transitOperators) {
+function getTransitOperatorComparatorValue(
+  route: Route,
+  transitOperators: TransitOperator[]
+): number | string {
   // if the transitOperators is undefined or has zero length, use the route's
   // agency name as the comparator value
   if (!transitOperators || transitOperators.length === 0) {
@@ -129,8 +139,8 @@ function getTransitOperatorComparatorValue(route, transitOperators) {
  * Calculates the sort comparator value given two routes based off of the
  * route's agency and provided transitOperators config data.
  */
-function makeTransitOperatorComparator(transitOperators) {
-  return (a, b) => {
+function makeTransitOperatorComparator(transitOperators: TransitOperator[]) {
+  return (a: Route, b: Route) => {
     const aVal = getTransitOperatorComparatorValue(a, transitOperators);
     const bVal = getTransitOperatorComparatorValue(b, transitOperators);
     if (typeof aVal === "string") {
@@ -140,8 +150,7 @@ function makeTransitOperatorComparator(transitOperators) {
       if (aVal > bVal) return 1;
       return 0;
     }
-
-    // transitOperators are defined and therefore a numeric value is guaranteed
+    // @ts-expect-error transitOperators are defined and therefore a numeric value is guaranteed
     // to be returned
     return aVal - bVal;
   };
@@ -151,9 +160,13 @@ function makeTransitOperatorComparator(transitOperators) {
  * Gets the desired sort values according to an optional getter function. If the
  * getter function is not defined, the original sort values are returned.
  */
-function getSortValues(getterFn, a, b) {
-  let aVal;
-  let bVal;
+function getSortValues(
+  getterFn: (item: unknown) => unknown,
+  a: unknown,
+  b: unknown
+) {
+  let aVal: unknown;
+  let bVal: unknown;
   if (typeof getterFn === "function") {
     aVal = getterFn(a);
     bVal = getterFn(b);
@@ -199,11 +212,11 @@ const routeTypeComparatorValue = {
 // Gets a comparator value for a given route's type (OTP mode).
 // Note: JSDoc format not used to avoid bug in documentationjs.
 // ttps://github.com/documentationjs/documentation/issues/372
-function getRouteTypeComparatorValue(route) {
+function getRouteTypeComparatorValue(route: Route): number {
   // For some strange reason, the short route response in OTP returns the
   // string-based modes, but the long route response returns the
   // integer route type. This attempts to account for both of those cases.
-  if (!route) throw new Error("Route is undefined.", route);
+  if (!route) throw new Error(`Route is undefined. ${route}`);
   if (typeof modeComparatorValue[route.mode] !== "undefined") {
     return modeComparatorValue[route.mode];
   }
@@ -212,6 +225,7 @@ function getRouteTypeComparatorValue(route) {
   }
   // Default the comparator value to a large number (placing the route at the
   // end of the list).
+  // eslint-disable-next-line no-console
   console.warn("no mode/route type found for route", route);
   return END_OF_LIST_COMPARATOR_VALUE;
 }
@@ -220,7 +234,7 @@ function getRouteTypeComparatorValue(route) {
  * Calculates the sort comparator value given two routes based off of route type
  * (OTP mode).
  */
-function routeTypeComparator(a, b) {
+function routeTypeComparator(a: Route, b: Route): number {
   return getRouteTypeComparatorValue(a) - getRouteTypeComparatorValue(b);
 }
 
@@ -228,7 +242,7 @@ function routeTypeComparator(a, b) {
  * Determines whether a value is a string that starts with an alphabetic
  * ascii character.
  */
-function startsWithAlphabeticCharacter(val) {
+function startsWithAlphabeticCharacter(val: unknown): boolean {
   if (typeof val === "string" && val.length > 0) {
     const firstCharCode = val.charCodeAt(0);
     return (
@@ -244,7 +258,7 @@ function startsWithAlphabeticCharacter(val) {
  * character. Routes with shortn that do start with an alphabetic character will
  * be prioritized over those that don't.
  */
-function alphabeticShortNameComparator(a, b) {
+function alphabeticShortNameComparator(a: Route, b: Route): number {
   const aStartsWithAlphabeticCharacter = startsWithAlphabeticCharacter(
     a.shortName
   );
@@ -284,11 +298,15 @@ function alphabeticShortNameComparator(a, b) {
  * @param  {function} [objGetterFn] An optional function to obtain the
  *  comparison value from the comparator function arguments
  */
-export function makeNumericValueComparator(objGetterFn) {
+export function makeNumericValueComparator(
+  objGetterFn?: (item: Route) => number
+) {
   /* Note: Using the global version of isNaN (the Number version behaves differently. */
   /* eslint-disable no-restricted-globals */
-  return (a, b) => {
+  return (a: number, b: number): number => {
     const { aVal, bVal } = getSortValues(objGetterFn, a, b);
+    if (typeof aVal !== "number" || typeof bVal !== "number") return 0;
+
     // if both values aren't valid numbers, use the next sort criteria
     if (isNaN(aVal) && isNaN(bVal)) return 0;
     // b is a valid number, b gets priority
@@ -310,8 +328,10 @@ export function makeNumericValueComparator(objGetterFn) {
  * @param  {function} [objGetterFn] An optional function to obtain the
  *  comparison value from the comparator function arguments
  */
-export function makeStringValueComparator(objGetterFn) {
-  return (a, b) => {
+export function makeStringValueComparator(
+  objGetterFn?: (item: Route) => string
+) {
+  return (a: string, b: string): number => {
     const { aVal, bVal } = getSortValues(objGetterFn, a, b);
     // both a and b are uncomparable strings, return equivalent value
     if (!aVal && !bVal) return 0;
@@ -334,7 +354,7 @@ export function makeStringValueComparator(objGetterFn) {
  * See https://github.com/opentripplanner/OpenTripPlanner/issues/2938
  * Also see https://github.com/opentripplanner/otp-react-redux/issues/122
  */
-function getRouteSortOrderValue(val) {
+function getRouteSortOrderValue(val: number): number {
   return val === -999 ? undefined : val;
 }
 
@@ -345,8 +365,10 @@ function getRouteSortOrderValue(val) {
  * returned. If all comparison functions return equivalence, then the values
  * are assumed to be equivalent.
  */
-function makeMultiCriteriaSort(...criteria) {
-  return (a, b) => {
+function makeMultiCriteriaSort(
+  ...criteria: ((a: unknown, b: unknown) => number)[]
+) {
+  return (a: number, b: number): number => {
     for (let i = 0; i < criteria.length; i++) {
       const curCriteriaComparatorValue = criteria[i](a, b);
       // if the comparison objects are not equivalent, return the value obtained
@@ -390,7 +412,9 @@ function makeMultiCriteriaSort(...criteria) {
  *    those with shortNames.
  *  7. longName as string.
  */
-export function makeRouteComparator(transitOperators) {
+export function makeRouteComparator(
+  transitOperators: TransitOperator[]
+): (a: number, b: number) => number {
   return makeMultiCriteriaSort(
     makeTransitOperatorComparator(transitOperators),
     makeNumericValueComparator(obj => getRouteSortOrderValue(obj.sortOrder)),