@opentripplanner/core-utils 12.0.2 → 12.2.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"
@@ -55,3 +66,191 @@ 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/query-gen.ts

@@ -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/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/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)