@opentripplanner/core-utils 9.0.0-alpha.1 → 9.0.0-alpha.3

package/src/__tests__/query-params.js

@@ -1,5 +1,6 @@
 import { reduceOtpFlexModes } from "../query";
 import queryParams, { getCustomQueryParams } from "../query-params";
+import { generateCombinations } from "../query-gen";
 
 const customWalkDistanceOptions = [
   {
@@ -12,6 +13,130 @@ const customWalkDistanceOptions = [
   }
 ];
 
+function modeStrToTransportMode(m) {
+  const splitVals = m.split("_");
+  return {
+    mode: splitVals[0],
+    qualifier: splitVals?.[1] || null
+  };
+}
+
+const mockLatLon = {
+  lat: 1,
+  lon: 2
+};
+
+function expectModes(modes, expectedModes) {
+  const generatedModesList = generateCombinations({
+    modes: modes.map(modeStrToTransportMode),
+    to: mockLatLon,
+    from: mockLatLon,
+    modeSettings: []
+  });
+  const expandedExpectedModesList = expectedModes.map(em => ({
+    modes: em.map(modeStrToTransportMode),
+    to: mockLatLon,
+    from: mockLatLon,
+    modeSettings: []
+  }));
+  return it(
+    modes.join(" "),
+    () =>
+      expect(generatedModesList.length === expandedExpectedModesList.length) &&
+      expect(new Set(generatedModesList)).toEqual(
+        new Set(expandedExpectedModesList)
+      )
+  );
+}
+
+describe("query-gen", () => {
+  describe("generateCombinations", () => {
+    expectModes(["WALK"], [["WALK"]]);
+    expectModes(["WALK", "TRANSIT"], [["WALK"], ["TRANSIT"]]);
+    expectModes(
+      ["WALK", "TRANSIT", "BICYCLE"],
+      [["WALK"], ["TRANSIT"], ["BICYCLE"], ["TRANSIT", "BICYCLE"]]
+    );
+    expectModes(
+      ["WALK", "TRANSIT", "CAR"],
+      [["WALK"], ["TRANSIT"], ["TRANSIT", "CAR"]]
+    );
+    expectModes(["TRANSIT", "CAR"], [["TRANSIT"], ["TRANSIT", "CAR"]]);
+    expectModes(["CAR"], []);
+    expectModes(
+      ["WALK", "TRANSIT", "BICYCLE", "CAR"],
+      [
+        ["WALK"],
+        ["TRANSIT"],
+        ["TRANSIT", "BICYCLE"],
+        ["BICYCLE"],
+        ["TRANSIT", "CAR"]
+      ]
+    );
+    expectModes(
+      ["BICYCLE_RENT", "TRANSIT", "WALK"],
+      [
+        ["TRANSIT"],
+        ["BICYCLE_RENT", "TRANSIT"],
+        ["BICYCLE_RENT", "WALK"],
+        ["WALK"]
+      ]
+    );
+    expectModes(
+      ["BICYCLE_RENT", "BICYCLE", "TRANSIT", "WALK"],
+      [
+        ["TRANSIT"],
+        ["BICYCLE_RENT", "TRANSIT"],
+        ["BICYCLE", "TRANSIT"],
+        ["BICYCLE_RENT", "WALK"],
+        ["BICYCLE"],
+        ["WALK"]
+      ]
+    );
+    expectModes(
+      ["SCOOTER_RENT", "BICYCLE_RENT", "TRANSIT", "WALK"],
+      [
+        ["TRANSIT"],
+        ["BICYCLE_RENT", "TRANSIT"],
+        ["BICYCLE_RENT", "WALK"],
+        ["SCOOTER_RENT", "TRANSIT"],
+        ["SCOOTER_RENT", "WALK"],
+        ["WALK"]
+      ]
+    );
+    expectModes(
+      ["FLEX", "TRANSIT", "WALK"],
+      [["TRANSIT"], ["FLEX", "TRANSIT"], ["FLEX", "WALK"], ["WALK"]]
+    );
+    expectModes(
+      ["FLEX", "SCOOTER_RENT", "TRANSIT", "WALK"],
+      [
+        ["TRANSIT"],
+        ["FLEX", "TRANSIT"],
+        ["WALK"],
+        ["FLEX", "WALK"],
+        ["FLEX", "SCOOTER_RENT", "WALK"], // Is this sensible?
+        ["FLEX", "SCOOTER_RENT", "TRANSIT"],
+        ["SCOOTER_RENT", "WALK"],
+        ["SCOOTER_RENT", "TRANSIT"]
+      ]
+    );
+    expectModes(
+      ["FLEX", "SCOOTER_RENT", "TRANSIT"],
+      [
+        ["TRANSIT"],
+        ["FLEX", "TRANSIT"],
+        ["FLEX", "SCOOTER_RENT", "TRANSIT"],
+        ["SCOOTER_RENT", "TRANSIT"]
+      ]
+    );
+    expectModes(
+      ["BUS", "RAIL", "GONDOLA", "TRAM"],
+      [["BUS", "RAIL", "GONDOLA", "TRAM"]]
+    );
+  });
+});
+
 describe("query-params", () => {
   describe("getCustomQueryParams", () => {
     it("should return the original unmodified queryParams if no customizations", () => {

package/src/graphql.d.ts

@@ -0,0 +1,7 @@
+declare module "*.graphql" {
+  import { DocumentNode } from "graphql";
+
+  const Schema: DocumentNode;
+
+  export = Schema;
+}

package/src/index.ts

@@ -7,12 +7,14 @@ import * as route from "./route";
 import * as storage from "./storage";
 import * as time from "./time";
 import * as ui from "./ui";
+import * as queryGen from "./query-gen";
 
 const core = {
   itinerary,
   map,
   profile,
   query,
+  queryGen,
   queryParams,
   route,
   storage,

package/src/planQuery.graphql

@@ -0,0 +1,107 @@
+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,
+) {
+	plan(
+		fromPlace: $fromPlace
+		toPlace: $toPlace
+		transportModes: $modes
+		locale: "en",
+		time: $time,
+		date: $date,
+		wheelchair: $wheelchair,
+		bikeReluctance: $bikeReluctance,
+		carReluctance: $carReluctance,
+		walkReluctance: $walkReluctance,
+		arriveBy: $arriveBy,
+		intermediatePlaces: $intermediatePlaces,
+		preferred: $preferred,
+		unpreferred: $unpreferred,
+		banned: $banned,
+	) {
+		itineraries {
+			duration
+			endTime
+			startTime
+			waitingTime
+			walkTime
+			legs {
+				distance
+				duration
+				endTime
+				mode
+				realTime
+				realtimeState	
+				startTime
+				transitLeg
+				agency {
+					name
+					id
+					timezone
+					url
+				}
+				legGeometry {
+					length
+					points
+				}
+				intermediateStops {
+					lat
+					lon
+					name
+					stopCode: code
+					stopId: id
+					locationType
+				}
+				route {
+					shortName
+					color
+					textColor
+					id
+					type
+				}
+				from {
+					lat
+					lon
+					name
+					vertexType
+					stop {
+						id
+						code
+						
+					}
+				}
+				to {
+					lat
+					lon
+					name
+					vertexType
+					stop {
+						id
+						code
+					}
+				}
+				steps {
+					distance
+					lat
+					lon
+					elevationProfile {
+						distance
+						elevation
+					}
+				}
+			}
+		}
+	}
+}

package/src/query-gen.ts

@@ -0,0 +1,152 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { print } from "graphql";
+import {
+  ModeSetting,
+  ModeSettingValues,
+  TransportMode
+} from "@opentripplanner/types";
+import { LonLatOutput } from "@conveyal/lonlat";
+import PlanQuery from "./planQuery.graphql";
+
+type OTPQueryParams = {
+  to: LonLatOutput;
+  from: LonLatOutput;
+  modes: Array<TransportMode>;
+  modeSettings: ModeSetting[];
+};
+
+/**
+ * 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)))
+  );
+}
+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"
+};
+
+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"
+);
+
+export function generateCombinations(params: OTPQueryParams): OTPQueryParams[] {
+  const VALID_COMBOS = [
+    ["WALK"],
+    ["PERSONAL"],
+    ["TRANSIT", "SHARED"],
+    ["WALK", "SHARED"],
+    ["TRANSIT"],
+    ["TRANSIT", "PERSONAL"],
+    ["TRANSIT", "CAR"]
+  ];
+
+  const BANNED_TOGETHER = ["SCOOTER", "BICYCLE"];
+
+  // List of the transit submodes that are included in the input params
+  const queryTransitSubmodes = params.modes
+    .filter(mode => TRANSIT_SUBMODES.includes(mode.mode))
+    .map(mode => mode.mode);
+
+  return (
+    combinations(params.modes)
+      .filter(combo => {
+        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")) {
+          const flatModes = combo.map(m => m.mode);
+          if (
+            combo.reduce((prev, cur) => {
+              if (queryTransitSubmodes.includes(cur.mode)) {
+                return prev - 1;
+              }
+              return prev;
+            }, queryTransitSubmodes.length) !== 0
+          ) {
+            return false;
+          }
+        }
+
+        // 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))
+        );
+      })
+      // create new filter that removes subTransit modes from appearing on their own
+      // ONLY IF there's multiple of them!
+      .map(combo => ({ ...params, modes: combo }))
+  );
+}
+
+// eslint-disable-next-line import/prefer-default-export
+export function generateOtp2Query(params: OTPQueryParams): any {
+  const { to, from, modeSettings } = params;
+
+  // This extracts the values from the mode settings to key value pairs
+  const modeSettingValues = modeSettings.reduce((prev, cur) => {
+    prev[cur.key] = cur.value;
+    return prev;
+  }, {}) as ModeSettingValues;
+
+  const {
+    walkReluctance,
+    wheelchair,
+    bikeReluctance,
+    carReluctance,
+    allowBikeRental
+  } = modeSettingValues;
+
+  return {
+    query: print(PlanQuery),
+    variables: {
+      fromPlace: [from.lat, from.lon].join(","),
+      toPlace: [to.lat, to.lon].join(","),
+      modes: params.modes,
+      allowBikeRental,
+      walkReluctance,
+      wheelchair,
+      bikeReluctance,
+      carReluctance
+    }
+  };
+}

package/tsconfig.json

@@ -2,6 +2,7 @@
   "extends": "../../tsconfig.json",
   "compilerOptions": {
     "composite": true,
+    "target": "es2019",
     "outDir": "./lib",
     "rootDir": "./src",
     "skipLibCheck": true