@opentripplanner/core-utils 13.0.0-alpha.4 → 13.0.0

package/src/core-utils.story.tsx

@@ -1,6 +1,17 @@
 import React, { useState } from "react";
 import styled from "styled-components";
-import { getMostReadableTextColor } from "./route";
+import {
+  alphabeticShortNameComparator,
+  getMostReadableTextColor,
+  getRouteSortOrderValue,
+  makeMultiCriteriaSort,
+  makeNumericValueComparator,
+  makeStringValueComparator,
+  makeTransitOperatorComparator,
+  routeTypeComparator
+} from "./route";
+import { routes } from "./__mocks__/fake-route-data.story.json";
+import { fakeTransitOperators } from "./__mocks__/fake-transit-operators.story.json";
 
 export default {
   title: "core-utils"
@@ -50,8 +61,196 @@ export const RouteColorTester = (): JSX.Element => {
     </>
   );
 };
-// Disable color contrast checking for the uncorrected color pairs.
+// Disable color contrast checking for the uncorrected color pairs
 RouteColorTester.parameters = {
   a11y: { config: { rules: [{ id: "color-contrast", reviewOnFail: true }] } },
   storyshots: { disable: true }
 };
+
+// Route sort logic story:
+
+const Columns = styled.div`
+  display: flex;
+  flex-direction: row;
+  position: relative;
+  width: 100%;
+`;
+
+const StyledTable = styled.table`
+  td,
+  th {
+    border: 1px solid black;
+    padding: 2px;
+  }
+
+  tr {
+    background-color: white;
+    display: grid;
+    grid-template-columns: 1fr 2fr 2fr 4fr 2fr 2fr;
+    width: 75%;
+    img {
+      height: 30px;
+      width: 30px;
+    }
+  }
+`;
+
+function makeRouteComparator(sortArray): (a: number, b: number) => number {
+  return makeMultiCriteriaSort(
+    ...(sortArray as Array<(a: any, b: any) => number>)
+  );
+}
+
+/**
+ * This is based on the logic in the makeRouteComparator function in route.ts
+ * If another route comparator is added to makeRouteComparator, this component
+ * will need to be updated to reflect the new comparator.
+ */
+export const RouteSortingLogic = (): JSX.Element => {
+  const [useOperatorComparator, setUseOperatorComparator] = useState(true);
+  const [useSortOrderComparator, setUseSortOrderComparator] = useState(true);
+  const [useRouteComparator, setUseRouteComparator] = useState(true);
+  const [useAlphaSortName, setUseAlphaSortName] = useState(true);
+  const [useNumericShortName, setUseNumericShortName] = useState(true);
+  const [useStringShortName, setUseStringShortName] = useState(true);
+  const [useStringLongName, setUseLongName] = useState(true);
+
+  const transitOperatorComparator = useOperatorComparator
+    ? makeTransitOperatorComparator(fakeTransitOperators)
+    : null;
+  const sortOrderComparator = useSortOrderComparator
+    ? makeNumericValueComparator(obj => getRouteSortOrderValue(obj))
+    : null;
+  const routeComparator = useRouteComparator ? routeTypeComparator : null;
+  const alphaShortName = useAlphaSortName
+    ? alphabeticShortNameComparator
+    : null;
+  const numericShortName = useNumericShortName
+    ? makeNumericValueComparator(obj => parseInt(obj.shortName, 10))
+    : null;
+  const stringShortName = useStringShortName
+    ? makeStringValueComparator(obj => obj.shortName)
+    : null;
+  const stringLongName = useStringLongName
+    ? makeStringValueComparator(obj => obj.longName || "")
+    : null;
+
+  const sortArray = [
+    transitOperatorComparator,
+    sortOrderComparator,
+    routeComparator,
+    alphaShortName,
+    numericShortName,
+    stringShortName,
+    stringLongName
+  ].filter(x => x !== null);
+
+  const sortedRoutes = Array.from(routes as Array<any>).sort(
+    makeRouteComparator(sortArray)
+  );
+
+  return (
+    <Columns>
+      <StyledTable>
+        <tr>
+          <th>Logo</th>
+          <th>Mode</th>
+          <th>Short Name</th>
+          <th>Long Name</th>
+          <th>Agency Order</th>
+          <th>Sort Order</th>
+        </tr>
+        {sortedRoutes.map(r => {
+          const operator = fakeTransitOperators.find(
+            x => x.agencyId === r.agency?.id
+          );
+          return (
+            <tr key={r.id}>
+              <td>
+                <img src={operator?.logo} alt={r.agency?.name || ""} />
+              </td>
+              <td>{r.mode}</td>
+              <td>{r.shortName}</td>
+              <td>{r.longName}</td>
+              <td>{operator?.order}</td>
+              <td>{r.sortOrder}</td>
+            </tr>
+          );
+        })}
+      </StyledTable>
+      <div
+        style={{
+          display: "flex",
+          flexDirection: "column",
+          position: "fixed",
+          right: 0,
+          width: "25%"
+        }}
+      >
+        <label htmlFor="operator-comparator">
+          <input
+            checked={useOperatorComparator}
+            id="operator-comparator"
+            onChange={() => setUseOperatorComparator(!useOperatorComparator)}
+            type="checkbox"
+          />
+          Transit Operator Comparator
+        </label>
+        <label htmlFor="sort-order-comparator">
+          <input
+            id="sort-order-comparator"
+            type="checkbox"
+            checked={useSortOrderComparator}
+            onChange={() => setUseSortOrderComparator(!useSortOrderComparator)}
+          />
+          SortOrder Comparator
+        </label>
+        <label htmlFor="route-comparator">
+          <input
+            id="route-comparator"
+            type="checkbox"
+            checked={useRouteComparator}
+            onChange={() => setUseRouteComparator(!useRouteComparator)}
+          />
+          Route Comparator
+        </label>
+        <label htmlFor="alpha-sort-name">
+          <input
+            id="alpha-sort-name"
+            type="checkbox"
+            checked={useAlphaSortName}
+            onChange={() => setUseAlphaSortName(!useAlphaSortName)}
+          />
+          Alpha Short Name
+        </label>
+        <label htmlFor="numeric-short-name">
+          <input
+            id="numeric-short-name"
+            type="checkbox"
+            checked={useNumericShortName}
+            onChange={() => setUseNumericShortName(!useNumericShortName)}
+          />
+          Numeric Short Name
+        </label>
+        <label htmlFor="string-short-name">
+          <input
+            id="string-short-name"
+            type="checkbox"
+            checked={useStringShortName}
+            onChange={() => setUseStringShortName(!useStringShortName)}
+          />
+          String Short Name
+        </label>
+        <label htmlFor="string-long-name">
+          <input
+            id="string-long-name"
+            type="checkbox"
+            checked={useStringLongName}
+            onChange={() => setUseLongName(!useStringLongName)}
+          />
+          String Long Name
+        </label>
+      </div>
+    </Columns>
+  );
+};

package/src/itinerary.ts

@@ -104,8 +104,6 @@ export function isFlex(leg: Leg): boolean {
     legContainsGeometry(leg)
   );
 }
-
-// alpha-only comment
 export function isRideshareLeg(leg: Leg): boolean {
   return !!leg.rideHailingEstimate?.provider?.id;
 }

package/src/otpSchema.json

@@ -9671,18 +9671,6 @@
               "isDeprecated": false,
               "deprecationReason": null
             },
-            {
-              "name": "stopPosition",
-              "description": "The sequence of the stop in the pattern. This is not required to start from 0 or be consecutive - any\nincreasing integer sequence along the stops is valid.\n\nThe purpose of this field is to identify the stop within the pattern so it can be cross-referenced\nbetween it and the itinerary. It is safe to cross-reference when done quickly, i.e. within seconds.\nHowever, it should be noted that realtime updates can change the values, so don't store it for\nlonger amounts of time.\n\nDepending on the source data, this might not be the GTFS `stop_sequence` but another value, perhaps\neven generated.",
-              "args": [],
-              "type": {
-                "kind": "SCALAR",
-                "name": "Int",
-                "ofType": null
-              },
-              "isDeprecated": false,
-              "deprecationReason": null
-            },
             {
               "name": "scheduledArrival",
               "description": "Scheduled arrival time. Format: seconds since midnight of the departure date",

package/src/profile.js

@@ -1,5 +1,5 @@
 export function filterProfileOptions(response) {
-  // Filter out similar options. TODO: handle on server??
+  // Filter out similar options. TODO: handle on server?
   const optStrs = [];
   const filteredIndices = [];
 

package/src/query-gen.ts

@@ -58,7 +58,7 @@ export function extractAdditionalModes(
       return prev;
     }
 
-    // In checkboxes (or submode checkboxes), mode must be enabled and have a transport mode in it
+    // In checkboxes, mode must be enabled and have a transport mode in it
     if (
       (cur.type === "CHECKBOX" || cur.type === "SUBMODE") &&
       cur.addTransportMode &&
@@ -180,7 +180,7 @@ function isCombinationValid(
 
   return !!VALID_COMBOS.find(
     vc =>
-      simplifiedModes.every(m => vc.includes(m)) &&
+      simplifiedModes.length === vc.length &&
       vc.every(m => simplifiedModes.includes(m))
   );
 }

package/src/query.js

@@ -72,10 +72,7 @@ export function ensureSingleAccessMode(queryModes) {
 }
 
 export function getUrlParams() {
-  if (window) {
-    return qs.parse(window.location.href.split("?")[1]);
-  }
-  return undefined;
+  return qs.parse(window.location.href.split("?")[1]);
 }
 
 export function getOtpUrlParams() {

package/src/route.ts

@@ -65,10 +65,10 @@ export function getTransitOperatorFromOtpRoute(
   const feedId = route.id.split(":")[0];
   let agencyId: string | number;
   if (route.agency) {
-    // This is returned in the OTP Route model
+    // This is returned in OTP2
     agencyId = route.agency.id;
   } else if (route.agencyId) {
-    // This is returned in the OTP RouteShort model (such as in the IBI fork)
+    // This is returned in OTP1
     agencyId = route.agencyId;
   } else {
     return null;
@@ -112,9 +112,9 @@ function getTransitOperatorComparatorValue(
   // if the transitOperators is undefined or has zero length, use the route's
   // agency name as the comparator value
   if (!transitOperators || transitOperators.length === 0) {
-    // OTP Route
+    // OTP2 Route
     if (route.agency) return route.agency.name;
-    // OTP RouteShort (base OTP repo or IBI fork)
+    // OTP1 Route
     if (route.agencyName) return route.agencyName;
     // shouldn't happen as agency names will be defined
     return "zzz";
@@ -140,7 +140,9 @@ function getTransitOperatorComparatorValue(
  * Calculates the sort comparator value given two routes based off of the
  * route's agency and provided transitOperators config data.
  */
-function makeTransitOperatorComparator(transitOperators: TransitOperator[]) {
+export function makeTransitOperatorComparator(
+  transitOperators: TransitOperator[]
+) {
   return (a: Route, b: Route) => {
     const aVal = getTransitOperatorComparatorValue(a, transitOperators);
     const bVal = getTransitOperatorComparatorValue(b, transitOperators);
@@ -237,7 +239,7 @@ function getRouteTypeComparatorValue(route: Route): number {
  * Calculates the sort comparator value given two routes based off of route type
  * (OTP mode).
  */
-function routeTypeComparator(a: Route, b: Route): number {
+export function routeTypeComparator(a: Route, b: Route): number {
   return getRouteTypeComparatorValue(a) - getRouteTypeComparatorValue(b);
 }
 
@@ -261,7 +263,7 @@ function startsWithAlphabeticCharacter(val: unknown): boolean {
  * character. Routes with shortn that do start with an alphabetic character will
  * be prioritized over those that don't.
  */
-function alphabeticShortNameComparator(a: Route, b: Route): number {
+export function alphabeticShortNameComparator(a: Route, b: Route): number {
   const aStartsWithAlphabeticCharacter = startsWithAlphabeticCharacter(
     a.shortName
   );
@@ -282,6 +284,14 @@ function alphabeticShortNameComparator(a: Route, b: Route): number {
   return 0;
 }
 
+const isNullOrNaN = (val: any): boolean => {
+  // isNaN(null) returns false so we have to check for null explicitly.
+  // Note: Using the global version of isNaN (the Number version behaves differently.
+  // eslint-disable-next-line no-restricted-globals
+  if (typeof val === null || isNaN(val)) return true;
+
+  return typeof val !== "number";
+};
 /**
  * Checks whether an appropriate comparison of numeric values can be made for
  * sorting purposes. If both values are not valid numbers according to the
@@ -304,19 +314,21 @@ function alphabeticShortNameComparator(a: Route, b: Route): number {
 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: number, b: number): number => {
+  return (a: number, b: number): number | null => {
     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;
+    if (isNullOrNaN(aVal) && isNullOrNaN(bVal)) {
+      return 0;
+    }
     // b is a valid number, b gets priority
-    if (isNaN(aVal)) return 1;
+    if (isNullOrNaN(aVal)) return 1;
+
     // a is a valid number, a gets priority
-    if (isNaN(bVal)) return -1;
+    if (isNullOrNaN(bVal)) return -1;
+
     // a and b are valid numbers, return the sort value
+    // @ts-expect-error We know from the checks above that both aVal and bVal are valid numbers.
     return aVal - bVal;
   };
 }
@@ -350,15 +362,23 @@ export function makeStringValueComparator(
 }
 
 /**
- * OpenTripPlanner sets the routeSortOrder to -999 by default. So, if that value
- * is encountered, assume that it actually means that the routeSortOrder is not
- * set in the GTFS.
+ * OTP1 sets the routeSortOrder to -999 by default. If we're encountering that value in OTP1,
+ * assume that it actually means that the route sortOrder is not set in the GTFS. If we encounter
+ * it in OTP2, it's a valid value, so we should return it.
  *
  * See https://github.com/opentripplanner/OpenTripPlanner/issues/2938
  * Also see https://github.com/opentripplanner/otp-react-redux/issues/122
+ * This was updated in OTP2 TO be empty by default. https://docs.opentripplanner.org/en/v2.3.0/OTP2-MigrationGuide/#:~:text=the%20Alerts-,Changes%20to%20the%20Index%20API,-Error%20handling%20is
  */
-function getRouteSortOrderValue(val: number): number {
-  return val === -999 ? undefined : val;
+export function getRouteSortOrderValue(route: Route): number {
+  const isOTP1 = !!route.agencyId;
+  const { sortOrder } = route;
+
+  if ((isOTP1 && sortOrder === -999) || sortOrder === undefined) {
+    return null;
+  }
+
+  return sortOrder;
 }
 
 /**
@@ -368,7 +388,7 @@ function getRouteSortOrderValue(val: number): number {
  * returned. If all comparison functions return equivalence, then the values
  * are assumed to be equivalent.
  */
-function makeMultiCriteriaSort(
+export function makeMultiCriteriaSort(
   ...criteria: ((a: unknown, b: unknown) => number)[]
 ) {
   return (a: number, b: number): number => {
@@ -420,7 +440,7 @@ export function makeRouteComparator(
 ): (a: number, b: number) => number {
   return makeMultiCriteriaSort(
     makeTransitOperatorComparator(transitOperators),
-    makeNumericValueComparator(obj => getRouteSortOrderValue(obj.sortOrder)),
+    makeNumericValueComparator(obj => getRouteSortOrderValue(obj)),
     routeTypeComparator,
     alphabeticShortNameComparator,
     makeNumericValueComparator(obj => parseInt(obj.shortName, 10)),

package/src/storage.ts

@@ -6,12 +6,10 @@ const STORAGE_PREFIX = "otp";
  * Store a javascript object at the specified key.
  */
 export function storeItem(key: string, object: unknown): void {
-  if (window) {
-    window.localStorage.setItem(
-      `${STORAGE_PREFIX}.${key}`,
-      JSON.stringify(object)
-    );
-  }
+  window.localStorage.setItem(
+    `${STORAGE_PREFIX}.${key}`,
+    JSON.stringify(object)
+  );
 }
 
 /**
@@ -36,9 +34,7 @@ export function getItem(key: string, notFoundValue: unknown = null): unknown {
  * Remove item at specified key.
  */
 export function removeItem(key: string): void {
-  if (window) {
-    window.localStorage.removeItem(`${STORAGE_PREFIX}.${key}`);
-  }
+  window.localStorage.removeItem(`${STORAGE_PREFIX}.${key}`);
 }
 
 /**

package/src/time.ts

@@ -26,6 +26,15 @@ export function toHoursMinutesSeconds(
   };
 }
 
+/**
+ * If a duration is less than 60 seconds, round it to one minute, to avoid a duration
+ * of 0 minutes on a leg.
+ * @param {number} duration The leg or trip duration in seconds
+ * @returns a duration in seconds of at least 60 seconds.
+ */
+export const ensureAtLeastOneMinute = (duration: number): number =>
+  duration < 60 ? 60 : duration;
+
 /**
  * @param  {[type]} config the OTP config object found in store
  * @return {string}        the config-defined time formatter or HH:mm (24-hr time)