@opentripplanner/core-utils 9.0.0-alpha.2 → 9.0.0-alpha.21

package/src/itinerary.ts

@@ -5,8 +5,10 @@ import {
   ElevationProfile,
   FlexBookingInfo,
   Itinerary,
+  ItineraryOnlyLegsRequired,
   LatLngArray,
   Leg,
+  MassUnitOption,
   Money,
   Place,
   Step,
@@ -212,7 +214,9 @@ export function getCompanyFromLeg(leg: Leg): string {
   return null;
 }
 
-export function getItineraryBounds(itinerary: Itinerary): LatLngArray[] {
+export function getItineraryBounds(
+  itinerary: ItineraryOnlyLegsRequired
+): LatLngArray[] {
   let coords = [];
   itinerary.legs.forEach(leg => {
     const legCoords = polyline
@@ -391,10 +395,13 @@ export function getCompanyForNetwork(
  * @return {string}  A label for use in presentation on a website.
  */
 export function getCompaniesLabelFromNetworks(
-  networks: string[],
+  networks: string | string[],
   companies: Company[] = []
 ): string {
-  return networks
+  let networksArray = networks;
+  if (typeof networks === "string") networksArray = [networks];
+
+  return (networksArray as string[])
     .map(network => getCompanyForNetwork(network, companies))
     .filter(co => !!co)
     .map(co => co.label)
@@ -407,7 +414,7 @@ export function getTNCLocation(leg: Leg, type: string): string {
 }
 
 export function calculatePhysicalActivity(
-  itinerary: Itinerary
+  itinerary: ItineraryOnlyLegsRequired
 ): {
   bikeDuration: number;
   caloriesBurned: number;
@@ -433,7 +440,9 @@ export function calculatePhysicalActivity(
  * these values and currency info.
  * It is assumed that the same currency is used for all TNC legs.
  */
-export function calculateTncFares(itinerary: Itinerary): TncFare {
+export function calculateTncFares(
+  itinerary: ItineraryOnlyLegsRequired
+): TncFare {
   return itinerary.legs
     .filter(leg => leg.mode === "CAR" && leg.hailedCar && leg.tncData)
     .reduce(
@@ -501,15 +510,16 @@ const CARBON_INTENSITY_DEFAULTS = {
 };
 
 /**
- * @param  {itinerary} itinerary OTP trip itinierary
- * @param  {carbonIntensity} carbonIntensity carbon intensity by mode in grams/meter
+ * @param {itinerary} itinerary OTP trip itinierary, only legs is required.
+ * @param {carbonIntensity} carbonIntensity carbon intensity by mode in grams/meter
  * @param {units} units units to be used in return value
  * @return Amount of carbon in chosen unit
  */
 export function calculateEmissions(
-  itinerary: Itinerary,
+  // This type makes all the properties from Itinerary optional except legs.
+  itinerary: ItineraryOnlyLegsRequired,
   carbonIntensity: Record<string, number> = {},
-  units?: string
+  units?: MassUnitOption
 ): number {
   // Apply defaults for any values that we don't have.
   const carbonIntensityWithDefaults = {
@@ -555,3 +565,70 @@ export function getDisplayedStopId(placeOrStop: Place | Stop): string {
   }
   return stopCode || stopId?.split(":")[1] || stopId;
 }
+
+/**
+ * Adds the fare product info to each leg in an itinerary, from the itinerary's fare property
+ * @param itinerary Itinerary with legProducts in fare object
+ * @returns Itinerary with legs that have fare products attached to them
+ */
+export function getLegsWithFares(itinerary: Itinerary): Leg[] {
+  return itinerary.legs.map((leg, i) => ({
+    ...leg,
+    fareProducts: itinerary.fare?.legProducts
+      ?.filter(lp => lp?.legIndices?.includes(i))
+      .flatMap(lp => lp.products)
+  }));
+}
+
+/**
+ * Extracts useful data from the fare products on a leg, such as the leg cost and transfer info.
+ * @param leg Leg with fare products (must have used getLegsWithFares)
+ * @param category Rider category
+ * @param container Fare container (cash, electronic)
+ * @returns Object containing price as well as the transfer discount amount, if a transfer was used.
+ */
+export function getLegCost(
+  leg: Leg,
+  category: string,
+  container: string
+): { price?: Money; transferAmount?: number } {
+  if (!leg.fareProducts) return { price: undefined };
+
+  const relevantFareProducts = leg.fareProducts.filter(
+    fp => fp.category.name === category && fp.container.name === container
+  );
+  const totalCost = relevantFareProducts.find(fp => fp.name === "rideCost")
+    ?.amount;
+  const transferFareProduct = relevantFareProducts.find(
+    fp => fp.name === "transfer"
+  );
+
+  return {
+    price: totalCost,
+    transferAmount: transferFareProduct?.amount?.cents
+  };
+}
+
+/**
+ * Returns the total itinerary cost for a given set of legs.
+ * @param legs Itinerary legs with fare products (must have used getLegsWithFares)
+ * @param category Rider category (youth, regular, senior)
+ * @param container Fare container (cash, electronic)
+ * @returns Money object for the total itinerary cost.
+ */
+export function getItineraryCost(
+  legs: Leg[],
+  category: string,
+  container: string
+): Money {
+  return legs
+    .filter(leg => !!leg.fareProducts)
+    .map(leg => getLegCost(leg, category, container).price)
+    .reduce<Money>(
+      (prev, cur) => ({
+        cents: prev.cents + cur?.cents || 0,
+        currency: prev.currency ?? cur?.currency
+      }),
+      { cents: 0, currency: null }
+    );
+}

package/src/planQuery.graphql

@@ -0,0 +1,176 @@
+query PlanQuery(
+  $fromPlace: String!
+  $toPlace: String!
+  $modes: [TransportMode]
+  $time: String
+  $date: String
+  $wheelchair: Boolean
+  $bikeReluctance: Float
+  $carReluctance: Float
+  $walkReluctance: Float
+  $arriveBy: Boolean
+  $intermediatePlaces: [InputCoordinates]
+  $preferred: InputPreferred
+  $unpreferred: InputUnpreferred
+  $banned: InputBanned
+  $numItineraries: Int
+) {
+  plan(
+    fromPlace: $fromPlace
+    toPlace: $toPlace
+    transportModes: $modes
+    # Currently only supporting EN locale, used for times and text
+    locale: "en"
+    time: $time
+    date: $date
+    wheelchair: $wheelchair
+    bikeReluctance: $bikeReluctance
+    carReluctance: $carReluctance
+    walkReluctance: $walkReluctance
+    arriveBy: $arriveBy
+    intermediatePlaces: $intermediatePlaces
+    preferred: $preferred
+    unpreferred: $unpreferred
+    banned: $banned
+    numItineraries: $numItineraries
+  ) {
+    routingErrors {
+      code
+      inputField
+      description
+    }
+    itineraries {
+      duration
+      endTime
+      startTime
+      waitingTime
+      walkTime
+      accessibilityScore
+      legs {
+        pickupType
+        dropoffType
+        pickupBookingInfo {
+          earliestBookingTime {
+            daysPrior
+          }
+        }
+        rentedBike
+        interlineWithPreviousLeg
+        departureDelay
+        arrivalDelay
+        distance
+        duration
+        endTime
+        mode
+        realTime
+        realtimeState
+        startTime
+        transitLeg
+        accessibilityScore
+        trip {
+          id
+          gtfsId
+          tripHeadsign
+        }
+        agency {
+          name
+          id
+          timezone
+          url
+          alerts {
+            alertHeaderText
+            alertDescriptionText
+            alertUrl
+            effectiveStartDate
+          }
+        }
+        legGeometry {
+          length
+          points
+        }
+        intermediateStops {
+          lat
+          lon
+          name
+          stopCode: code
+          stopId: id
+          locationType
+        }
+        route {
+          shortName
+          longName
+          color
+          textColor
+          id
+          type
+          alerts {
+            alertHeaderText
+            alertDescriptionText
+            alertUrl
+            effectiveStartDate
+          }
+        }
+        from {
+          lat
+          lon
+          name
+          vertexType
+          rentalVehicle {
+            network
+          }
+          stop {
+            id
+            code
+            gtfsId
+            alerts {
+              alertHeaderText
+              alertDescriptionText
+              alertUrl
+              effectiveStartDate
+            }
+          }
+        }
+        to {
+          lat
+          lon
+          name
+          vertexType
+          rentalVehicle {
+            network
+          }
+          stop {
+            id
+            code
+            gtfsId
+            alerts {
+              alertHeaderText
+              alertDescriptionText
+              alertUrl
+              effectiveStartDate
+            }
+          }
+        }
+        steps {
+          distance
+          lat
+          lon
+          relativeDirection
+          absoluteDirection
+          stayOn
+          streetName
+          area
+          alerts {
+            alertHeaderText
+            alertDescriptionText
+            alertUrl
+            effectiveStartDate
+          }
+          elevationProfile {
+            distance
+            elevation
+          }
+        }
+      }
+    }
+  }
+}

package/src/query-gen.ts

@@ -0,0 +1,244 @@
+import { LonLatOutput } from "@conveyal/lonlat";
+import { print } from "graphql";
+import {
+  ModeSetting,
+  ModeSettingValues,
+  TransportMode
+} from "@opentripplanner/types";
+
+import PlanQuery from "./planQuery.graphql";
+
+type InputBanned = {
+  routes?: string;
+  agencies?: string;
+  trips?: string;
+  stops?: string;
+  stopsHard?: string;
+};
+
+type InputPreferred = {
+  routes?: string;
+  agencies?: string;
+  unpreferredCost?: string;
+};
+
+type OTPQueryParams = {
+  arriveBy: boolean;
+  date?: string;
+  from: LonLatOutput & { name?: string };
+  modes: TransportMode[];
+  modeSettings: ModeSetting[];
+  time?: string;
+  numItineraries?: number;
+  to: LonLatOutput & { name?: string };
+  banned?: InputBanned;
+  preferred?: InputPreferred;
+};
+
+type GraphQLQuery = {
+  query: string;
+  variables: Record<string, unknown>;
+};
+
+/**
+ * Mode Settings can contain additional modes to add to the query,
+ * this function extracts those additional modes from the settings
+ * and returns them in an array.
+ * @param modeSettings List of mode settings with values populated
+ * @returns Additional transport modes to add to query
+ */
+export function extractAdditionalModes(
+  modeSettings: ModeSetting[],
+  enabledModes: TransportMode[]
+): TransportMode[] {
+  return modeSettings.reduce<TransportMode[]>((prev, cur) => {
+    // First, ensure that the mode associated with this setting is even enabled
+    if (!enabledModes.map(m => m.mode).includes(cur.applicableMode)) {
+      return prev;
+    }
+
+    // In checkboxes, mode must be enabled and have a transport mode in it
+    if (cur.type === "CHECKBOX" && cur.addTransportMode && cur.value) {
+      return [...prev, cur.addTransportMode];
+    }
+    if (cur.type === "DROPDOWN") {
+      const transportMode = cur.options.find(o => o.value === cur.value)
+        .addTransportMode;
+      if (transportMode) {
+        return [...prev, transportMode];
+      }
+    }
+    return prev;
+  }, []);
+}
+
+/**
+ * Generates every possible mathematical subset of the input TransportModes.
+ * Uses code from:
+ * https://stackoverflow.com/questions/5752002/find-all-possible-subset-combos-in-an-array
+ * @param array Array of input transport modes
+ * @returns 2D array representing every possible subset of transport modes from input
+ */
+function combinations(array: TransportMode[]): TransportMode[][] {
+  if (!array) return [];
+  return (
+    // eslint-disable-next-line no-bitwise
+    new Array(1 << array.length)
+      .fill(null)
+      // eslint-disable-next-line no-bitwise
+      .map((e1, i) => array.filter((e2, j) => i & (1 << j)))
+  );
+}
+
+/**
+ * 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 = {
+  AIRPLANE: "TRANSIT",
+  BICYCLE: "PERSONAL",
+  BUS: "TRANSIT",
+  CABLE_CAR: "TRANSIT",
+  CAR: "CAR",
+  FERRY: "TRANSIT",
+  FLEX: "SHARED", // TODO: this allows FLEX+WALK. Is this reasonable?
+  FUNICULAR: "TRANSIT",
+  GONDOLA: "TRANSIT",
+  RAIL: "TRANSIT",
+  SCOOTER: "PERSONAL",
+  SUBWAY: "TRANSIT",
+  TRAM: "TRANSIT",
+  TRANSIT: "TRANSIT",
+  WALK: "WALK"
+};
+
+// Inclusion of "TRANSIT" alone automatically implies "WALK" in OTP
+const VALID_COMBOS = [
+  ["WALK"],
+  ["PERSONAL"],
+  ["TRANSIT", "SHARED"],
+  ["WALK", "SHARED"],
+  ["TRANSIT"],
+  ["TRANSIT", "PERSONAL"],
+  ["TRANSIT", "CAR"]
+];
+
+const BANNED_TOGETHER = ["SCOOTER", "BICYCLE"];
+
+export const TRANSIT_SUBMODES = Object.keys(SIMPLIFICATIONS).filter(
+  mode => SIMPLIFICATIONS[mode] === "TRANSIT" && mode !== "TRANSIT"
+);
+export const TRANSIT_SUBMODES_AND_TRANSIT = Object.keys(SIMPLIFICATIONS).filter(
+  mode => SIMPLIFICATIONS[mode] === "TRANSIT"
+);
+
+function isCombinationValid(
+  combo: TransportMode[],
+  queryTransitSubmodes: string[]
+): boolean {
+  if (combo.length === 0) return false;
+
+  // All current qualifiers currently simplify to "SHARED"
+  const simplifiedModes = Array.from(
+    new Set(combo.map(c => (c.qualifier ? "SHARED" : SIMPLIFICATIONS[c.mode])))
+  );
+
+  // Ensure that if we have one transit mode, then we include ALL transit modes
+  if (simplifiedModes.includes("TRANSIT")) {
+    // Don't allow TRANSIT along with any other submodes
+    if (queryTransitSubmodes.length && combo.find(c => c.mode === "TRANSIT")) {
+      return false;
+    }
+
+    if (
+      combo.reduce((prev, cur) => {
+        if (queryTransitSubmodes.includes(cur.mode)) {
+          return prev - 1;
+        }
+        return prev;
+      }, queryTransitSubmodes.length) !== 0
+    ) {
+      return false;
+    }
+    // Continue to the other checks
+  }
+
+  // OTP doesn't support multiple non-walk modes
+  if (BANNED_TOGETHER.every(m => combo.find(c => c.mode === m))) return false;
+
+  return !!VALID_COMBOS.find(
+    vc =>
+      simplifiedModes.every(m => vc.includes(m)) &&
+      vc.every(m => simplifiedModes.includes(m))
+  );
+}
+
+/**
+ * Generates a list of queries for OTP to get a comprehensive
+ * set of results based on the modes input.
+ * @param params OTP Query Params
+ * @returns Set of parameters to generate queries
+ */
+export function generateCombinations(params: OTPQueryParams): OTPQueryParams[] {
+  const completeModeList = [
+    ...extractAdditionalModes(params.modeSettings, params.modes),
+    ...params.modes
+  ];
+
+  // List of the transit *submodes* that are included in the input params
+  const queryTransitSubmodes = completeModeList
+    .filter(mode => TRANSIT_SUBMODES.includes(mode.mode))
+    .map(mode => mode.mode);
+
+  return combinations(completeModeList)
+    .filter(combo => isCombinationValid(combo, queryTransitSubmodes))
+    .map(combo => ({ ...params, modes: combo }));
+}
+
+export function generateOtp2Query({
+  arriveBy,
+  banned,
+  date,
+  from,
+  modes,
+  modeSettings,
+  numItineraries,
+  preferred,
+  time,
+  to
+}: OTPQueryParams): GraphQLQuery {
+  // This extracts the values from the mode settings to key value pairs
+  const modeSettingValues = modeSettings.reduce((prev, cur) => {
+    if (cur.type === "SLIDER" && cur.inverseKey) {
+      prev[cur.inverseKey] = cur.high - cur.value + cur.low;
+    }
+    prev[cur.key] = cur.value;
+    return prev;
+  }, {}) as ModeSettingValues;
+
+  const {
+    bikeReluctance,
+    carReluctance,
+    walkReluctance,
+    wheelchair
+  } = modeSettingValues;
+
+  return {
+    query: print(PlanQuery),
+    variables: {
+      arriveBy,
+      banned,
+      bikeReluctance,
+      carReluctance,
+      date,
+      fromPlace: `${from.name}::${from.lat},${from.lon}}`,
+      modes,
+      numItineraries,
+      preferred,
+      time,
+      toPlace: `${to.name}::${to.lat},${to.lon}}`,
+      walkReluctance,
+      wheelchair
+    }
+  };
+}

package/tsconfig.json

@@ -2,9 +2,12 @@
   "extends": "../../tsconfig.json",
   "compilerOptions": {
     "composite": true,
+    "target": "es2019",
     "outDir": "./lib",
     "rootDir": "./src",
+    "lib": ["es2019", "dom"],
     "skipLibCheck": true
   },
-  "include": ["src/**/*"]
+  "include": ["src/**/*"],
+  "exclude": ["src/__tests__/**/*"]
 }