@opentripplanner/core-utils 15.0.0-alpha.2 → 16.0.0

package/lib/route.js

@@ -1,10 +1,22 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getMostReadableTextColor = exports.makeRouteComparator = exports.makeMultiCriteriaSort = exports.getRouteSortOrderValue = exports.makeStringValueComparator = exports.makeNumericValueComparator = exports.alphabeticShortNameComparator = exports.routeTypeComparator = exports.makeTransitOperatorComparator = exports.getTransitOperatorFromOtpRoute = exports.getTransitOperatorFromLeg = exports.getTransitOperatorFromFeedIdAndAgencyId = void 0;
-const chroma_js_1 = __importDefault(require("chroma-js"));
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.alphabeticShortNameComparator = alphabeticShortNameComparator;
+exports.getMostReadableTextColor = getMostReadableTextColor;
+exports.getRouteSortOrderValue = getRouteSortOrderValue;
+exports.getTransitOperatorFromFeedIdAndAgencyId = getTransitOperatorFromFeedIdAndAgencyId;
+exports.getTransitOperatorFromLeg = getTransitOperatorFromLeg;
+exports.getTransitOperatorFromOtpRoute = getTransitOperatorFromOtpRoute;
+exports.makeMultiCriteriaSort = makeMultiCriteriaSort;
+exports.makeNumericValueComparator = makeNumericValueComparator;
+exports.makeRouteComparator = makeRouteComparator;
+exports.makeStringValueComparator = makeStringValueComparator;
+exports.makeTransitOperatorComparator = makeTransitOperatorComparator;
+exports.routeTypeComparator = routeTypeComparator;
+var _chromaJs = _interopRequireDefault(require("chroma-js"));
 /**
  * Returns the transit operator (if an exact match is found) from the transit
  * operators config value. It is critical to use both the feedId and agencyId in
@@ -18,10 +30,9 @@ const chroma_js_1 = __importDefault(require("chroma-js"));
  *    was found
  */
 function getTransitOperatorFromFeedIdAndAgencyId(feedId, agencyId, transitOperators) {
-    return (transitOperators.find(transitOperator => transitOperator.feedId === feedId &&
-        transitOperator.agencyId === agencyId) || null);
+  return transitOperators.find(transitOperator => transitOperator.feedId === feedId && transitOperator.agencyId === agencyId) || null;
 }
-exports.getTransitOperatorFromFeedIdAndAgencyId = getTransitOperatorFromFeedIdAndAgencyId;
+
 /**
  * Looks up an operator from the provided leg.
  *
@@ -31,12 +42,11 @@ exports.getTransitOperatorFromFeedIdAndAgencyId = getTransitOperatorFromFeedIdAn
  * @return {object} the operator if one was found or null if no match was found
  */
 function getTransitOperatorFromLeg(leg, transitOperators) {
-    if (!leg.routeId || !leg.agencyId)
-        return null;
-    const feedId = leg.routeId.split(":")[0];
-    return getTransitOperatorFromFeedIdAndAgencyId(feedId, leg.agencyId, transitOperators);
+  if (!leg.routeId || !leg.agencyId) return null;
+  const feedId = leg.routeId.split(":")[0];
+  return getTransitOperatorFromFeedIdAndAgencyId(feedId, leg.agencyId, transitOperators);
 }
-exports.getTransitOperatorFromLeg = getTransitOperatorFromLeg;
+
 /**
  * Looks up an operator from the provided configuration given an OTP route.
  * NOTE: this assumes the use of the OTP Route model or a modified OTP
@@ -48,34 +58,33 @@ exports.getTransitOperatorFromLeg = getTransitOperatorFromLeg;
  * @return {object} the operator if one was found or null if no match was found
  */
 function getTransitOperatorFromOtpRoute(route, transitOperators) {
-    if (!route.id)
-        return null;
-    const feedId = route.id.split(":")[0];
-    let agencyId;
-    if (route.agency) {
-        // This is returned in OTP2
-        agencyId = route.agency.id;
-    }
-    else if (route.agencyId) {
-        // This is returned in OTP1
-        agencyId = route.agencyId;
-    }
-    else {
-        return null;
-    }
-    return getTransitOperatorFromFeedIdAndAgencyId(feedId, agencyId, transitOperators);
+  if (!route.id) return null;
+  const feedId = route.id.split(":")[0];
+  let agencyId;
+  if (route.agency) {
+    // This is returned in OTP2
+    agencyId = route.agency.id;
+  } else if (route.agencyId) {
+    // This is returned in OTP1
+    agencyId = route.agencyId;
+  } else {
+    return null;
+  }
+  return getTransitOperatorFromFeedIdAndAgencyId(feedId, agencyId, transitOperators);
 }
-exports.getTransitOperatorFromOtpRoute = getTransitOperatorFromOtpRoute;
+
 // The functions below are for enhanced route sorting functions for the route
 // viewer on OTP-react-redux.
 // They address route ordering issues discussed in
 // https://github.com/opentripplanner/otp-react-redux/pull/123 and
 // https://github.com/opentripplanner/otp-react-redux/pull/124.
+
 /**
  * A large comparator value that can safely be used in mathematical sort
  * comparisons to place things at the end of lists
  */
 const END_OF_LIST_COMPARATOR_VALUE = 999999999999;
+
 /**
  * Returns a transit operator comparator value given a route and an optional
  * transitOperators config value. This function will do its best to handle all
@@ -90,172 +99,184 @@ const END_OF_LIST_COMPARATOR_VALUE = 999999999999;
  *   returned.
  */
 function getTransitOperatorComparatorValue(route, transitOperators) {
-    // if the transitOperators is undefined or has zero length, use the route's
-    // agency name as the comparator value
-    if (!transitOperators || transitOperators.length === 0) {
-        // OTP2 Route
-        if (route.agency)
-            return route.agency.name;
-        // OTP1 Route
-        if (route.agencyName)
-            return route.agencyName;
-        // shouldn't happen as agency names will be defined
-        return "zzz";
-    }
-    // find operator associated with route
-    const transitOperator = getTransitOperatorFromOtpRoute(route, transitOperators);
-    // if transit operator not found, return infinity
-    if (!transitOperator)
-        return END_OF_LIST_COMPARATOR_VALUE;
-    // return the transit operator's sort value or END_OF_LIST_COMPARATOR_VALUE if
-    // the sort value is not a number
-    return typeof transitOperator.order === "number"
-        ? transitOperator.order
-        : END_OF_LIST_COMPARATOR_VALUE;
+  // if the transitOperators is undefined or has zero length, use the route's
+  // agency name as the comparator value
+  if (!transitOperators || transitOperators.length === 0) {
+    // OTP2 Route
+    if (route.agency) return route.agency.name;
+    // OTP1 Route
+    if (route.agencyName) return route.agencyName;
+    // shouldn't happen as agency names will be defined
+    return "zzz";
+  }
+
+  // find operator associated with route
+  const transitOperator = getTransitOperatorFromOtpRoute(route, transitOperators);
+
+  // if transit operator not found, return infinity
+  if (!transitOperator) return END_OF_LIST_COMPARATOR_VALUE;
+
+  // return the transit operator's sort value or END_OF_LIST_COMPARATOR_VALUE if
+  // the sort value is not a number
+  return typeof transitOperator.order === "number" ? transitOperator.order : END_OF_LIST_COMPARATOR_VALUE;
 }
+
 /**
  * Calculates the sort comparator value given two routes based off of the
  * route's agency and provided transitOperators config data.
  */
 function makeTransitOperatorComparator(transitOperators) {
-    return (a, b) => {
-        const aVal = getTransitOperatorComparatorValue(a, transitOperators);
-        const bVal = getTransitOperatorComparatorValue(b, transitOperators);
-        if (typeof aVal === "string") {
-            // happens when transitOperators is undefined. Both aVal are guaranteed to
-            // be strings. Make a string comparison.
-            if (aVal < bVal)
-                return -1;
-            if (aVal > bVal)
-                return 1;
-            return 0;
-        }
-        // @ts-expect-error transitOperators are defined and therefore a numeric value is guaranteed
-        // to be returned
-        return aVal - bVal;
-    };
+  return (a, b) => {
+    const aVal = getTransitOperatorComparatorValue(a, transitOperators);
+    const bVal = getTransitOperatorComparatorValue(b, transitOperators);
+    if (typeof aVal === "string" && typeof bVal === "string") {
+      // happens when transitOperators is undefined. Both aVal are guaranteed to
+      // be strings. Make a string comparison.
+      if (aVal < bVal) return -1;
+      if (aVal > bVal) return 1;
+      return 0;
+    }
+    // @ts-expect-error transitOperators are defined and therefore a numeric value is guaranteed
+    // to be returned
+    return aVal - bVal;
+  };
 }
-exports.makeTransitOperatorComparator = makeTransitOperatorComparator;
+
 /**
  * Gets the desired sort values according to an optional getter function. If the
  * getter function is not defined, the original sort values are returned.
  */
-function getSortValues(getterFn, a, b) {
-    let aVal;
-    let bVal;
-    if (typeof getterFn === "function") {
-        aVal = getterFn(a);
-        bVal = getterFn(b);
-    }
-    else {
-        aVal = a;
-        bVal = b;
-    }
-    return { aVal, bVal };
+
+function getSortValues(a, b, getterFn) {
+  if (typeof getterFn === "function") {
+    return {
+      aVal: getterFn(a),
+      bVal: getterFn(b)
+    };
+  }
+
+  // When no getter is provided, TValue is inferred as T via overload.
+  return {
+    aVal: a,
+    bVal: b
+  };
 }
+
 // Lookup for the sort values associated with various OTP modes.
 // Note: JSDoc format not used to avoid bug in documentationjs.
 // https://github.com/documentationjs/documentation/issues/372
 const modeComparatorValue = {
-    SUBWAY: 1,
-    TRAM: 2,
-    TROLLEYBUS: 9,
-    RAIL: 3,
-    GONDOLA: 4,
-    FERRY: 5,
-    CABLE_CAR: 6,
-    FUNICULAR: 7,
-    BUS: 8
+  SUBWAY: 1,
+  TRAM: 2,
+  TROLLEYBUS: 9,
+  RAIL: 3,
+  GONDOLA: 4,
+  FERRY: 5,
+  CABLE_CAR: 6,
+  FUNICULAR: 7,
+  BUS: 8
+  // eslint-disable-next-line prettier/prettier
 };
+function isSupportedTransitMode(mode) {
+  return mode in modeComparatorValue;
+}
+
 // Lookup that maps route types to the OTP mode sort values.
 // Note: JSDoc format not used to avoid bug in documentationjs.
 // https://github.com/documentationjs/documentation/issues/372
 const routeTypeComparatorValue = {
-    0: modeComparatorValue.TRAM,
-    1: modeComparatorValue.SUBWAY,
-    2: modeComparatorValue.RAIL,
-    3: modeComparatorValue.BUS,
-    4: modeComparatorValue.FERRY,
-    5: modeComparatorValue.CABLE_CAR,
-    6: modeComparatorValue.GONDOLA,
-    7: modeComparatorValue.FUNICULAR,
-    // TODO: 11 and 12 are not a part of OTP as of 2019-02-14, but for now just
-    // associate them with bus/rail.
-    11: modeComparatorValue.BUS,
-    12: modeComparatorValue.RAIL,
-    13: modeComparatorValue.TROLLEYBUS
+  0: modeComparatorValue.TRAM,
+  // - Tram, Streetcar, Light rail.
+  1: modeComparatorValue.SUBWAY,
+  // - Subway, Metro.
+  2: modeComparatorValue.RAIL,
+  // - Rail. Used for intercity or long-distance travel.
+  3: modeComparatorValue.BUS,
+  // - Bus.
+  4: modeComparatorValue.FERRY,
+  // - Ferry.
+  5: modeComparatorValue.CABLE_CAR,
+  // - Cable tram.
+  6: modeComparatorValue.GONDOLA,
+  // - Gondola, etc.
+  7: modeComparatorValue.FUNICULAR,
+  // - Funicular.
+  // TODO: 11 and 12 are not a part of OTP as of 2019-02-14, but for now just
+  // associate them with bus/rail.
+  11: modeComparatorValue.BUS,
+  // - Trolleybus.
+  12: modeComparatorValue.RAIL,
+  // - Monorail.
+  13: modeComparatorValue.TROLLEYBUS
 };
+
 // Gets a comparator value for a given route's type (OTP mode).
 // Note: JSDoc format not used to avoid bug in documentationjs.
 // ttps://github.com/documentationjs/documentation/issues/372
 function getRouteTypeComparatorValue(route) {
-    // For some strange reason, the short route response in OTP returns the
-    // string-based modes, but the long route response returns the
-    // integer route type. This attempts to account for both of those cases.
-    if (!route)
-        throw new Error(`Route is undefined. ${route}`);
-    if (typeof modeComparatorValue[route.mode] !== "undefined") {
-        return modeComparatorValue[route.mode];
-    }
-    if (typeof routeTypeComparatorValue[route.type] !== "undefined") {
-        return routeTypeComparatorValue[route.type];
-    }
-    // Default the comparator value to a large number (placing the route at the
-    // end of the list).
-    // eslint-disable-next-line no-console
-    console.warn("no mode/route type found for route", route);
-    return END_OF_LIST_COMPARATOR_VALUE;
+  // For some strange reason, the short route response in OTP returns the
+  // string-based modes, but the long route response returns the
+  // integer route type. This attempts to account for both of those cases.
+  if (!route) throw new Error(`Route is undefined. ${route}`);
+  if (route.mode && isSupportedTransitMode(route.mode)) {
+    return modeComparatorValue[route.mode];
+  }
+  if (route.type && typeof routeTypeComparatorValue[route.type] !== "undefined") {
+    return routeTypeComparatorValue[route.type];
+  }
+  // Default the comparator value to a large number (placing the route at the
+  // end of the list).
+  // eslint-disable-next-line no-console
+  console.warn("no mode/route type found for route", route);
+  return END_OF_LIST_COMPARATOR_VALUE;
 }
+
 /**
  * Calculates the sort comparator value given two routes based off of route type
  * (OTP mode).
  */
 function routeTypeComparator(a, b) {
-    return getRouteTypeComparatorValue(a) - getRouteTypeComparatorValue(b);
+  return getRouteTypeComparatorValue(a) - getRouteTypeComparatorValue(b);
 }
-exports.routeTypeComparator = routeTypeComparator;
+
 /**
  * Determines whether a value is a string that starts with an alphabetic
  * ascii character.
  */
 function startsWithAlphabeticCharacter(val) {
-    if (typeof val === "string" && val.length > 0) {
-        const firstCharCode = val.charCodeAt(0);
-        return ((firstCharCode >= 65 && firstCharCode <= 90) ||
-            (firstCharCode >= 97 && firstCharCode <= 122));
-    }
-    return false;
+  if (typeof val === "string" && val.length > 0) {
+    const firstCharCode = val.charCodeAt(0);
+    return firstCharCode >= 65 && firstCharCode <= 90 || firstCharCode >= 97 && firstCharCode <= 122;
+  }
+  return false;
 }
+
 /**
  * Sorts routes based off of whether the shortName begins with an alphabetic
  * character. Routes with shortn that do start with an alphabetic character will
  * be prioritized over those that don't.
  */
 function alphabeticShortNameComparator(a, b) {
-    const aStartsWithAlphabeticCharacter = startsWithAlphabeticCharacter(a.shortName);
-    const bStartsWithAlphabeticCharacter = startsWithAlphabeticCharacter(b.shortName);
-    if (aStartsWithAlphabeticCharacter && bStartsWithAlphabeticCharacter) {
-        // both start with an alphabetic character, return equivalence
-        return 0;
-    }
-    // a does start with an alphabetic character, but b does not. Prioritize a
-    if (aStartsWithAlphabeticCharacter)
-        return -1;
-    // b does start with an alphabetic character, but a does not. Prioritize b
-    if (bStartsWithAlphabeticCharacter)
-        return 1;
-    // neither route has a shortName that starts with an alphabetic character.
-    // Return equivalence
+  const aStartsWithAlphabeticCharacter = startsWithAlphabeticCharacter(a.shortName);
+  const bStartsWithAlphabeticCharacter = startsWithAlphabeticCharacter(b.shortName);
+  if (aStartsWithAlphabeticCharacter && bStartsWithAlphabeticCharacter) {
+    // both start with an alphabetic character, return equivalence
     return 0;
+  }
+  // a does start with an alphabetic character, but b does not. Prioritize a
+  if (aStartsWithAlphabeticCharacter) return -1;
+  // b does start with an alphabetic character, but a does not. Prioritize b
+  if (bStartsWithAlphabeticCharacter) return 1;
+  // neither route has a shortName that starts with an alphabetic character.
+  // Return equivalence
+  return 0;
 }
-exports.alphabeticShortNameComparator = alphabeticShortNameComparator;
-const isNullOrNaN = (val) => {
-    // 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";
+const isNullOrNaN = val => {
+  // 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
@@ -276,25 +297,29 @@ const isNullOrNaN = (val) => {
  * @param  {function} [objGetterFn] An optional function to obtain the
  *  comparison value from the comparator function arguments
  */
+
 function makeNumericValueComparator(objGetterFn) {
-    return (a, b) => {
-        const { aVal, bVal } = getSortValues(objGetterFn, a, b);
-        // if both values aren't valid numbers, use the next sort criteria
-        if (isNullOrNaN(aVal) && isNullOrNaN(bVal)) {
-            return 0;
-        }
-        // b is a valid number, b gets priority
-        if (isNullOrNaN(aVal))
-            return 1;
-        // a is a valid number, a gets priority
-        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;
-    };
+  return (a, b) => {
+    const {
+      aVal,
+      bVal
+    } = typeof objGetterFn === "function" ? getSortValues(a, b, objGetterFn) : getSortValues(a, b);
+
+    // if both values aren't valid numbers, use the next sort criteria
+    if (isNullOrNaN(aVal) && isNullOrNaN(bVal)) {
+      return 0;
+    }
+    // b is a valid number, b gets priority
+    if (isNullOrNaN(aVal)) return 1;
+
+    // a is a valid number, a gets priority
+    if (isNullOrNaN(bVal)) return -1;
+
+    // a and b are valid numbers, return the sort value
+    return aVal - bVal;
+  };
 }
-exports.makeNumericValueComparator = makeNumericValueComparator;
+
 /**
  * Create a comparator function that compares string values. The comparison
  * values feed to the sort comparator function are assumed to be objects that
@@ -305,27 +330,27 @@ exports.makeNumericValueComparator = makeNumericValueComparator;
  * @param  {function} [objGetterFn] An optional function to obtain the
  *  comparison value from the comparator function arguments
  */
+
 function makeStringValueComparator(objGetterFn) {
-    return (a, b) => {
-        const { aVal, bVal } = getSortValues(objGetterFn, a, b);
-        // both a and b are uncomparable strings, return equivalent value
-        if (!aVal && !bVal)
-            return 0;
-        // a is not a comparable string, b gets priority
-        if (!aVal)
-            return 1;
-        // b is not a comparable string, a gets priority
-        if (!bVal)
-            return -1;
-        // a and b are comparable strings, return the sort value
-        if (aVal < bVal)
-            return -1;
-        if (aVal > bVal)
-            return 1;
-        return 0;
-    };
+  return (a, b) => {
+    const {
+      aVal,
+      bVal
+    } = typeof objGetterFn === "function" ? getSortValues(a, b, objGetterFn) : getSortValues(a, b);
+
+    // both a and b are uncomparable strings, return equivalent value
+    if (!aVal && !bVal) return 0;
+    // a is not a comparable string, b gets priority
+    if (!aVal) return 1;
+    // b is not a comparable string, a gets priority
+    if (!bVal) return -1;
+    // a and b are comparable strings, return the sort value
+    if (aVal < bVal) return -1;
+    if (aVal > bVal) return 1;
+    return 0;
+  };
 }
-exports.makeStringValueComparator = makeStringValueComparator;
+
 /**
  * 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
@@ -336,14 +361,16 @@ exports.makeStringValueComparator = makeStringValueComparator;
  * 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(route) {
-    const isOTP1 = !!route.agencyId;
-    const { sortOrder } = route;
-    if ((isOTP1 && sortOrder === -999) || sortOrder === undefined) {
-        return null;
-    }
-    return sortOrder;
+  const isOTP1 = !!route.agencyId;
+  const {
+    sortOrder
+  } = route;
+  if (isOTP1 && sortOrder === -999 || sortOrder === undefined) {
+    return null;
+  }
+  return sortOrder;
 }
-exports.getRouteSortOrderValue = getRouteSortOrderValue;
+
 /**
  * Create a multi-criteria sort comparator function composed of other sort
  * comparator functions. Each comparator function will be ran in the order given
@@ -352,19 +379,19 @@ exports.getRouteSortOrderValue = getRouteSortOrderValue;
  * are assumed to be equivalent.
  */
 function makeMultiCriteriaSort(...criteria) {
-    return (a, b) => {
-        for (let i = 0; i < criteria.length; i++) {
-            const curCriteriaComparatorValue = criteria[i](a, b);
-            // if the comparison objects are not equivalent, return the value obtained
-            // in this current criteria comparison
-            if (curCriteriaComparatorValue !== 0) {
-                return curCriteriaComparatorValue;
-            }
-        }
-        return 0;
-    };
+  return (a, b) => {
+    for (let i = 0; i < criteria.length; i++) {
+      const curCriteriaComparatorValue = criteria[i](a, b);
+      // if the comparison objects are not equivalent, return the value obtained
+      // in this current criteria comparison
+      if (curCriteriaComparatorValue !== 0) {
+        return curCriteriaComparatorValue;
+      }
+    }
+    return 0;
+  };
 }
-exports.makeMultiCriteriaSort = makeMultiCriteriaSort;
+
 /**
  * Creates a sort comparator function to compares routes for the purposes of
  * sorting and displaying in a user interface. This takes in a single optional
@@ -397,9 +424,9 @@ exports.makeMultiCriteriaSort = makeMultiCriteriaSort;
  *  7. longName as string.
  */
 function makeRouteComparator(transitOperators) {
-    return makeMultiCriteriaSort(makeTransitOperatorComparator(transitOperators), makeNumericValueComparator(obj => getRouteSortOrderValue(obj)), routeTypeComparator, alphabeticShortNameComparator, makeNumericValueComparator(obj => parseInt(obj.shortName, 10)), makeStringValueComparator(obj => obj.shortName), makeStringValueComparator(obj => obj.longName));
+  return makeMultiCriteriaSort(makeTransitOperatorComparator(transitOperators), makeNumericValueComparator(obj => getRouteSortOrderValue(obj)), routeTypeComparator, alphabeticShortNameComparator, makeNumericValueComparator(obj => parseInt(obj.shortName, 10)), makeStringValueComparator(obj => obj.shortName), makeStringValueComparator(obj => obj.longName));
 }
-exports.makeRouteComparator = makeRouteComparator;
+
 /**
  * Tests if a pair of colors is readable. If it is, that readable color is returned.
  * If it is not, a more appropriate alternative is returned.
@@ -414,29 +441,26 @@ exports.makeRouteComparator = makeRouteComparator;
  * @param proposedTextColor   A hex string, usually the "routeTextColor"
  */
 function getMostReadableTextColor(backgroundColor, proposedTextColor) {
-    // Sometimes input will defy the method signature. Therefore we need extra fallbacks
-    if (!backgroundColor)
-        backgroundColor = "#333333";
-    if (!proposedTextColor)
-        proposedTextColor = "#ffffff";
-    if (!backgroundColor.startsWith("#")) {
-        backgroundColor = `#${backgroundColor}`;
-    }
-    if (!proposedTextColor.startsWith("#")) {
-        proposedTextColor = `#${proposedTextColor}`;
-    }
-    // Check if proposed color is readable
-    // Luminance thresholds have been selected based on actual transit agency colors
-    const fgLuminance = (0, chroma_js_1.default)(proposedTextColor).luminance();
-    const bgLuminance = (0, chroma_js_1.default)(backgroundColor).luminance();
-    if (bgLuminance + fgLuminance < 1.41 &&
-        bgLuminance + fgLuminance > 0.25 &&
-        Math.abs(bgLuminance - fgLuminance) > 0.2) {
-        return proposedTextColor;
-    }
-    // Return black or white based on luminance of background color
-    // When generating colors, white is preferred.
-    return (0, chroma_js_1.default)(backgroundColor).luminance() < 0.4 ? "#ffffff" : "#000000";
+  // Sometimes input will defy the method signature. Therefore we need extra fallbacks
+  if (!backgroundColor) backgroundColor = "#333333";
+  if (!proposedTextColor) proposedTextColor = "#ffffff";
+  if (!backgroundColor.startsWith("#")) {
+    backgroundColor = `#${backgroundColor}`;
+  }
+  if (!proposedTextColor.startsWith("#")) {
+    proposedTextColor = `#${proposedTextColor}`;
+  }
+
+  // Check if proposed color is readable
+  // Luminance thresholds have been selected based on actual transit agency colors
+  const fgLuminance = (0, _chromaJs.default)(proposedTextColor).luminance();
+  const bgLuminance = (0, _chromaJs.default)(backgroundColor).luminance();
+  if (bgLuminance + fgLuminance < 1.41 && bgLuminance + fgLuminance > 0.25 && Math.abs(bgLuminance - fgLuminance) > 0.2) {
+    return proposedTextColor;
+  }
+
+  // Return black or white based on luminance of background color
+  // When generating colors, white is preferred.
+  return (0, _chromaJs.default)(backgroundColor).luminance() < 0.4 ? "#ffffff" : "#000000";
 }
-exports.getMostReadableTextColor = getMostReadableTextColor;
 //# sourceMappingURL=route.js.map