@opentripplanner/core-utils 15.0.0 → 16.0.0

package/src/__tests__/itinerary.ts

@@ -12,6 +12,7 @@ import {
   getLegRouteShortName,
   isFlex,
   isTransit,
+  legElevationAtDistance,
   mapOldElevationComponentToNew
 } from "../itinerary";
 
@@ -261,21 +262,21 @@ describe("util > itinerary", () => {
         "cash",
         "regular"
       );
-      expect(result.amount).toEqual(5.75);
-      expect(result.currency).toEqual({
+      expect(result?.amount).toEqual(5.75);
+      expect(result?.currency).toEqual({
         code: "USD",
         digits: 2
       });
     });
     it("should calculate the total cost of an itinerary using fares v2", () => {
       const result = getItineraryCost(faresv2Itinerary.legs, "3", "ADULT");
-      expect(result.amount).toEqual(2.8);
+      expect(result?.amount).toEqual(2.8);
       const complexResult = getItineraryCost(
         faresv2Itinerary.legs,
         ["0", "0"],
         ["ADULT", "ADULT"]
       );
-      expect(complexResult.amount).toEqual(2.8 * 2);
+      expect(complexResult?.amount).toEqual(2.8 * 2);
     });
     it("should calculate the total cost of an itinerary with multiple v2 fares & transfers", () => {
       const result = getItineraryCost(complexItinerary.legs, "0", "ADULT");
@@ -287,7 +288,7 @@ describe("util > itinerary", () => {
         ["0", "0"],
         ["ADULT", null]
       );
-      expect(result.amount).toEqual(11.55);
+      expect(result?.amount).toEqual(11.55);
     });
     it("should calculate the individual leg cost of a fares v2 legs", () => {
       const firstLegResult = getLegCost(faresv2Itinerary.legs[1], "3", "ADULT");
@@ -404,4 +405,53 @@ describe("util > itinerary", () => {
       ).toBe("15");
     });
   });
+
+  describe("legElevationAtDistance", () => {
+    it("should interpolate elevation within a segment", () => {
+      const points: any = [
+        [0, 100],
+        [10, 110],
+        [20, 120]
+      ];
+      // halfway between 100 and 110
+      expect(legElevationAtDistance(points, 5)).toBe(105);
+      expect(legElevationAtDistance(points, 15)).toBe(115);
+    });
+
+    it("should return start elevation at distance 0", () => {
+      const points: any = [
+        [0, 42],
+        [10, 52]
+      ];
+      expect(legElevationAtDistance(points, 0)).toBe(42);
+    });
+
+    it("should return end elevation at the segment boundary", () => {
+      const points: any = [
+        [0, 100],
+        [10, 110],
+        [20, 120]
+      ];
+      expect(legElevationAtDistance(points, 10)).toBe(110);
+      expect(legElevationAtDistance(points, 20)).toBe(120);
+    });
+
+    it("should return undefined when distance is before the profile", () => {
+      const points: any = [
+        [0, 100],
+        [10, 110],
+        [20, 120]
+      ];
+      expect(legElevationAtDistance(points, -1)).toBeUndefined();
+      expect(legElevationAtDistance(points, 21)).toBeUndefined();
+    });
+
+    it("should return undefined when first point is not at zero", () => {
+      const points: any = [
+        [5, 100],
+        [15, 110]
+      ];
+      expect(legElevationAtDistance(points, 4)).toBeUndefined();
+    });
+  });
 });

package/src/index.ts

@@ -1,7 +1,10 @@
 import * as itinerary from "./itinerary";
 import * as map from "./map";
+// @ts-expect-error not typed
 import * as profile from "./profile";
+// @ts-expect-error not typed
 import * as query from "./query";
+// @ts-expect-error not typed
 import * as queryParams from "./query-params";
 import * as route from "./route";
 import * as storage from "./storage";

package/src/itinerary.ts

@@ -6,6 +6,7 @@ import {
   Currency,
   ElevationProfile,
   ElevationProfileComponent,
+  FareProduct,
   FlexBookingInfo,
   ItineraryOnlyLegsRequired,
   LatLngArray,
@@ -86,11 +87,12 @@ export function startsWithGeometry(leg: Leg): boolean {
 export function legContainsGeometry(leg: Leg): boolean {
   return endsWithGeometry(leg) || startsWithGeometry(leg);
 }
-export function isAdvanceBookingRequired(info: FlexBookingInfo): boolean {
-  return info?.latestBookingTime?.daysPrior > 0;
+export function isAdvanceBookingRequired(info?: FlexBookingInfo): boolean {
+  const daysPrior = info?.latestBookingTime?.daysPrior;
+  return typeof daysPrior === "number" && daysPrior > 0;
 }
 export function legDropoffRequiresAdvanceBooking(leg: Leg): boolean {
-  return isAdvanceBookingRequired(leg?.dropOffBookingInfo);
+  return isAdvanceBookingRequired(leg.dropOffBookingInfo);
 }
 
 /**
@@ -199,6 +201,7 @@ export function hasRental(modesStr: string): boolean {
 }
 
 export function getMapColor(mode: string): string {
+  // @ts-expect-error this is not typed
   mode = mode || this.get("mode");
   if (mode === "WALK") return "#444";
   if (mode === "BICYCLE") return "#0073e5";
@@ -224,7 +227,7 @@ export function toSentenceCase(str: string): string {
 /**
  * Derive the company string based on mode and network associated with leg.
  */
-export function getCompanyFromLeg(leg: Leg): string {
+export function getCompanyFromLeg(leg?: Leg): string | null {
   if (!leg) return null;
   const {
     from,
@@ -234,14 +237,20 @@ export function getCompanyFromLeg(leg: Leg): string {
     rentedVehicle,
     rideHailingEstimate
   } = leg;
+
+  const firstNetwork =
+    Array.isArray(from.networks) && from.networks.length > 0
+      ? from.networks[0]
+      : null;
+
   if (mode === "CAR" && rentedCar) {
-    return from.networks[0];
+    return firstNetwork;
   }
   if (mode === "CAR" && rideHailingEstimate) {
     return rideHailingEstimate.provider.id;
   }
-  if (mode === "BICYCLE" && rentedBike && from.networks) {
-    return from.networks[0];
+  if (mode === "BICYCLE" && rentedBike) {
+    return firstNetwork;
   }
   if (from.rentalVehicle) {
     return from.rentalVehicle.network;
@@ -249,12 +258,8 @@ export function getCompanyFromLeg(leg: Leg): string {
   if (from.vehicleRentalStation?.rentalNetwork) {
     return from.vehicleRentalStation.rentalNetwork.networkId;
   }
-  if (
-    (mode === "MICROMOBILITY" || mode === "SCOOTER") &&
-    rentedVehicle &&
-    from.networks
-  ) {
-    return from.networks[0];
+  if ((mode === "MICROMOBILITY" || mode === "SCOOTER") && rentedVehicle) {
+    return firstNetwork;
   }
   return null;
 }
@@ -262,12 +267,12 @@ export function getCompanyFromLeg(leg: Leg): string {
 export function getItineraryBounds(
   itinerary: ItineraryOnlyLegsRequired
 ): LatLngArray[] {
-  let coords = [];
+  const coords: LatLngArray[] = [];
   itinerary.legs.forEach(leg => {
     const legCoords = polyline
       .toGeoJSON(leg.legGeometry.points)
-      .coordinates.map((c: number[]) => [c[1], c[0]]);
-    coords = [...coords, ...legCoords];
+      .coordinates.map((c): LatLngArray => [c[1], c[0]]);
+    coords.push(...legCoords);
   });
   return coords;
 }
@@ -290,62 +295,56 @@ export function getLegBounds(leg: Leg): number[][] {
 }
 
 /* Returns an interpolated lat-lon at a specified distance along a leg */
-
-export function legLocationAtDistance(leg: Leg, distance: number): number[] {
-  if (!leg.legGeometry) return null;
+export function legLocationAtDistance(
+  leg: Leg,
+  distance: number
+): LatLngArray | undefined | null {
+  if (!leg.legGeometry) return undefined;
 
   try {
     const line = polyline.toGeoJSON(leg.legGeometry.points);
     const pt = turfAlong(line, distance, { units: "meters" });
-    if (pt && pt.geometry && pt.geometry.coordinates) {
-      return [pt.geometry.coordinates[1], pt.geometry.coordinates[0]];
-    }
-  } catch (e) {
-    // FIXME handle error!
+    const coords = pt?.geometry?.coordinates;
+    return [coords[1], coords[0]];
+  } catch {
+    // This is designed to catch the toGeoJSON from throwing if the geometry is not in the correct format
   }
 
   return null;
 }
 
-/* Returns an interpolated elevation at a specified distance along a leg */
+/**
+ * Returns an interpolated elevation at a specified distance along a leg
+ * @param points - The points of the elevation profile. Each point is a tuple of [distance, elevation].
+ * @param distance - The distance along the leg to interpolate the elevation at
+ * @returns The interpolated elevation at the specified distance
+ */
 
 export function legElevationAtDistance(
-  points: number[][],
+  points: [number, 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
-  // null elevation. Encountering this value should trigger the warning below.
-  if (points[0][0] > 0) {
-    points.unshift([0, null]);
-  }
-  for (let i = 1; i < points.length; i++) {
-    const start = points[i - 1];
-    const elevDistanceSpan = points[i][0] - start[0];
-    if (distance >= traversed && distance <= traversed + elevDistanceSpan) {
-      // Distance falls within this point and the previous one;
-      // compute & return interpolated elevation value
-      if (start[1] === null) {
-        console.warn(
-          "Elevation value does not exist for distance.",
-          distance,
-          traversed
-        );
-        return null;
-      }
-      const pct = (distance - traversed) / elevDistanceSpan;
-      const elevSpan = points[i][1] - start[1];
-      return start[1] + elevSpan * pct;
+): number | undefined {
+  const elevation = points.reduce<number | undefined>((acc, point, index) => {
+    const prevPoint = points[index - 1];
+    // at the first index there is no previous point
+    if (!prevPoint) return acc;
+    const [pointDistance, pointElevation] = point;
+    const [prevPointDistance, prevPointElevation] = prevPoint;
+    if (distance >= prevPointDistance && distance <= pointDistance) {
+      return (
+        prevPointElevation +
+        ((pointElevation - prevPointElevation) *
+          (distance - prevPointDistance)) /
+          (pointDistance - prevPointDistance)
+      );
     }
-    traversed += elevDistanceSpan;
+    return acc;
+  }, undefined);
+  if (elevation === undefined) {
+    console.warn("Elevation value does not exist for distance.", distance);
+    return undefined;
   }
-  console.warn(
-    "Elevation value does not exist for distance.",
-    distance,
-    traversed
-  );
-  return null;
+  return elevation;
 }
 
 export function mapOldElevationComponentToNew(oldElev: {
@@ -370,7 +369,7 @@ export function getElevationProfile(
   let gain = 0;
   let loss = 0;
   let previous: ElevationProfileComponent | null = null;
-  const points = [];
+  const points: [number, number][] = [];
   steps.forEach(step => {
     // Support for old REST response data (in step.elevation)
     const stepElevationProfile =
@@ -430,6 +429,7 @@ export function getTextWidth(text: string, font = "22px Arial"): number {
     (getTextWidth as GetTextWidth).canvas ||
     ((getTextWidth as GetTextWidth).canvas = document.createElement("canvas"));
   const context = canvas.getContext("2d");
+  if (!context) return 0;
   context.font = font;
   const metrics = context.measureText(text);
   return metrics.width;
@@ -442,7 +442,7 @@ export function getTextWidth(text: string, font = "22px Arial"): number {
 export function getCompanyForNetwork(
   networkString: string,
   companies: Company[] = []
-): Company {
+): Company | undefined {
   const company = companies.find(co => co.id === networkString);
   if (!company) {
     console.warn(
@@ -473,7 +473,10 @@ export function getCompaniesLabelFromNetworks(
     .join("/");
 }
 
-export function getTNCLocation(leg: Leg, type: string): string {
+export function getTNCLocation(
+  leg: Pick<Leg, "from" | "to">,
+  type: "from" | "to"
+): string {
   const location = leg[type];
   return `${location.lat.toFixed(5)},${location.lon.toFixed(5)}`;
 }
@@ -509,15 +512,21 @@ export function calculateTncFares(
   itinerary: ItineraryOnlyLegsRequired
 ): TncFare {
   return itinerary.legs
-    .filter(leg => leg.mode === "CAR" && leg.rideHailingEstimate)
-    .reduce(
-      ({ maxTNCFare, minTNCFare }, { rideHailingEstimate }) => {
-        const { minPrice, maxPrice } = rideHailingEstimate;
+    .filter(
+      (
+        leg
+      ): leg is Leg & {
+        rideHailingEstimate: NonNullable<Leg["rideHailingEstimate"]>;
+      } => leg.mode === "CAR" && leg.rideHailingEstimate !== undefined
+    )
+    .reduce<TncFare>(
+      (acc, leg) => {
+        const { minPrice, maxPrice } = leg.rideHailingEstimate;
         return {
           // Assumes a single currency for entire itinerary.
           currencyCode: minPrice.currency.code,
-          maxTNCFare: maxTNCFare + maxPrice.amount,
-          minTNCFare: minTNCFare + minPrice.amount
+          maxTNCFare: acc.maxTNCFare + maxPrice.amount,
+          minTNCFare: acc.minTNCFare + minPrice.amount
         };
       },
       {
@@ -535,7 +544,7 @@ export function calculateTncFares(
  * - https://www.itf-oecd.org/sites/default/files/life-cycle-assessment-calculations-2020.xlsx
  * Other values extrapolated.
  */
-const CARBON_INTENSITY_DEFAULTS = {
+const CARBON_INTENSITY_DEFAULTS: Record<string, number> = {
   walk: 0.026,
   bicycle: 0.017,
   car: 0.162,
@@ -627,6 +636,8 @@ export const zeroDollars = (currency: Currency): Money => ({
   currency
 });
 
+type FareProductWithPrice = FareProduct & { price: Money };
+
 /**
  * Extracts useful data from the fare products on a leg, such as the leg cost and transfer info.
  * @param leg                Leg with Fares v2 information
@@ -642,7 +653,7 @@ export function getLegCost(
   leg: Leg,
   mediumId?: string | null,
   riderCategoryId?: string | null,
-  seenFareIds?: string[]
+  seenFareIds?: string[] | null
 ): {
   alternateFareProducts?: AppliedFareProduct[];
   appliedFareProduct?: AppliedFareProduct;
@@ -673,14 +684,22 @@ export function getLegCost(
         product?.price
       );
     })
+    // Make sure there's a price
+    // Some fare products don't have a price at all.
+    .filter(
+      (fare): fare is { id: string; product: FareProductWithPrice } =>
+        fare.product?.price !== undefined
+    )
     .map(fare => {
-      const alreadySeen = seenFareIds?.indexOf(fare.id) > -1;
-      const { currency } = fare.product.price;
+      const alreadySeen = !!seenFareIds && seenFareIds?.indexOf(fare.id) > -1;
       return {
         id: fare.id,
         product: {
           ...fare.product,
-          legPrice: alreadySeen ? zeroDollars(currency) : fare.product.price
+          legPrice:
+            alreadySeen && fare.product.price
+              ? zeroDollars(fare.product.price.currency)
+              : fare.product.price
         } as AppliedFareProduct
       };
     })
@@ -712,35 +731,51 @@ export function getLegCost(
  */
 export function getItineraryCost(
   legs: Leg[],
-  mediumId?: string | string[] | null,
-  riderCategoryId?: string | string[] | null
+  mediumId?: string | (string | null)[] | null,
+  riderCategoryId?: string | (string | null)[] | null
 ): Money | undefined {
-  // TODO: Better input type handling
   if (Array.isArray(mediumId) || Array.isArray(riderCategoryId)) {
-    if (mediumId?.length !== riderCategoryId.length) {
-      console.warn(
-        "Invalid input types, only using first item. medium id list and rider category list must have same number of items"
+    // TODO: Better input type handling
+    if (Array.isArray(mediumId) && Array.isArray(riderCategoryId)) {
+      if (mediumId.length !== riderCategoryId.length) {
+        console.warn(
+          "Invalid input types, only using first item. medium id list and rider category list must have same number of items"
+        );
+        return getItineraryCost(legs, mediumId[0], riderCategoryId[0]);
+      }
+
+      const total = mediumId.reduce<Money>(
+        (acc, currentMediumId, index) => {
+          const newCost = getItineraryCost(
+            legs,
+            currentMediumId,
+            riderCategoryId[index]
+          );
+          if (!newCost) return acc;
+
+          return {
+            amount: acc.amount + (newCost.amount || 0),
+            currency:
+              acc.currency.code !== ""
+                ? acc.currency
+                : newCost.currency ?? acc.currency
+          };
+        },
+        { amount: 0, currency: { code: "", digits: 0 } }
       );
-      return getItineraryCost(legs, mediumId[0], riderCategoryId[0]);
-    }
 
-    let total = { amount: 0, currency: null };
-    for (let i = 0; i < mediumId.length; i++) {
-      const newCost = getItineraryCost(legs, mediumId[i], riderCategoryId[i]);
-      if (newCost) {
-        total = {
-          amount: total?.amount + (newCost?.amount || 0),
-          currency: total.currency ?? newCost?.currency
-        };
-      }
+      if (!total.currency?.code) return undefined;
+      return total;
     }
-    if (total.currency === null) return undefined;
-    return total;
+    console.warn(
+      "Invalid input types, only using first item. medium id list and rider category list must have same number of items"
+    );
+    return undefined;
   }
 
   const legCosts = legs
     // Only legs with fares (no walking legs)
-    .filter(leg => leg.fareProducts?.length > 0)
+    .filter(leg => leg.fareProducts?.length && leg.fareProducts.length > 0)
     // Get the leg cost object of each leg
     .reduce<{ seenIds: string[]; legCosts: AppliedFareProduct[] }>(
       (acc, leg) => {
@@ -755,6 +790,7 @@ export function getItineraryCost(
           acc.seenIds
         );
         if (!appliedFareProduct) return acc;
+        if (!productUseId) return acc;
         return {
           legCosts: [...acc.legCosts, appliedFareProduct],
           seenIds: [...acc.seenIds, productUseId]
@@ -769,9 +805,10 @@ export function getItineraryCost(
   return legCosts.reduce<Money>(
     (prev, cur) => ({
       amount: prev.amount + cur?.amount || 0,
-      currency: prev.currency ?? cur?.currency
+      currency: prev.currency.code !== "" ? prev.currency : cur.currency
     }),
-    { amount: 0, currency: null }
+    // eslint-disable-next-line prettier/prettier -- old eslint doesn't know satisfies
+    { amount: 0, currency: { code: "", digits: 0 } satisfies Currency }
   );
 }
 
@@ -790,7 +827,7 @@ const pickupDropoffTypeToOtp1 = (otp2Type: string): string | null => {
   }
 };
 
-export const convertGraphQLResponseToLegacy = (leg: any): any => ({
+export const convertGraphQLResponseToLegacy = (leg: any): Leg => ({
   ...leg,
   agencyBrandingUrl: leg.agency?.url,
   agencyId: leg.agency?.id,
@@ -839,7 +876,7 @@ export const getLegRouteShortName = (
 /** Extract the route long name for a leg returned from OTP1 or OTP2. */
 export const getLegRouteLongName = (
   leg: Pick<Leg, "route" | "routeLongName">
-): string | null => {
+): string | undefined => {
   const { route, routeLongName } = leg;
   // typeof route === "object" denotes newer OTP2 responses. routeLongName is OTP1.
   return typeof route === "object" ? route?.longName : routeLongName;
@@ -851,6 +888,6 @@ export const getLegRouteLongName = (
  */
 export const getLegRouteName = (
   leg: Pick<Leg, "route" | "routeLongName" | "routeShortName">
-): string => {
+): string | undefined => {
   return getLegRouteShortName(leg) || getLegRouteLongName(leg);
 };

package/src/map.ts

@@ -2,7 +2,7 @@ import { LatLngArray, Location, UserPosition } from "@opentripplanner/types";
 
 export function currentPositionToLocation(
   currentPosition: UserPosition
-): Location {
+): Location | null {
   if (currentPosition.error || !currentPosition.coords) {
     console.warn(
       "Cannot construct location from current position due to geolocation error or missing coordinates."
@@ -18,8 +18,10 @@ export function currentPositionToLocation(
 
 // TRICKY: This method is used in query.js and in the context of
 // otp-rr actions where the intl context is not available/does not apply.
-export function coordsToString(coords: number[]): string {
-  return coords.length && coords.map(c => (+c).toFixed(5)).join(", ");
+export function coordsToString(coords: number[]): string | undefined {
+  return coords.length > 0
+    ? coords.map(c => (+c).toFixed(5)).join(", ")
+    : undefined;
 }
 
 export function stringToCoords(str: string): number[] {

package/src/query-gen.ts

@@ -102,7 +102,7 @@ function combinations(array: TransportMode[]): TransportMode[][] {
  * This constant maps all the transport mode to a broader mode type,
  * which is used to determine the valid combinations of modes used in query generation.
  */
-export const SIMPLIFICATIONS = {
+export const SIMPLIFICATIONS: Record<string, string> = {
   AIRPLANE: "TRANSIT",
   BICYCLE: "PERSONAL",
   BUS: "TRANSIT",
@@ -123,7 +123,7 @@ export const SIMPLIFICATIONS = {
 };
 
 // Inclusion of "TRANSIT" alone automatically implies "WALK" in OTP
-const VALID_COMBOS = [
+const VALID_COMBOS: string[][] = [
   ["WALK"],
   ["PERSONAL"],
   ["TRANSIT", "SHARED"],
@@ -220,19 +220,25 @@ export function generateOtp2Query(
   const { from, modeSettings, to, ...otherOtpQueryParams } = otpQueryParams;
 
   // This extracts the values from the mode settings to key value pairs
-  const modeSettingValues = modeSettings.reduce((prev, cur) => {
-    if (cur.type === "SLIDER" && cur.inverseKey) {
+  const modeSettingValues = modeSettings.reduce<
+    Record<string, string | number | boolean>
+  >((prev, cur) => {
+    if (cur.type === "SLIDER" && cur.inverseKey && cur.value) {
       prev[cur.inverseKey] = cur.high - cur.value + cur.low;
+    } else if (cur.value) {
+      prev[cur.key] = cur.value;
     }
-    prev[cur.key] = cur.value;
 
     // If we assign a value on true, return the value (or null) instead of a boolean.
-    if (cur.type === "CHECKBOX" && cur.truthValue) {
-      prev[cur.key] =
-        cur.value === true ? cur.truthValue : cur.falseValue ?? null;
+    if (cur.type === "CHECKBOX" && cur.truthValue && cur.falseValue) {
+      const newVal = cur.value === true ? cur.truthValue : cur.falseValue;
+      if (newVal) {
+        prev[cur.key] = newVal;
+      }
     }
     return prev;
-  }, {}) as ModeSettingValues;
+  // eslint-disable-next-line prettier/prettier -- old eslint doesn't know satisfies
+  }, {}) satisfies ModeSettingValues;
 
   const {
     bikeReluctance,