atriusmaps-node-sdk 3.3.897 → 3.3.899

package/dist/cjs/plugins/flightStatus/src/flightDetailsMapper.js

@@ -6,11 +6,10 @@ var date = require('../../../src/utils/date.js');
 var constants = require('../../../utils/constants.js');
 
 const FlightType = {
-  ARRIVAL: 'arr',
-  DEPARTURE: 'dep',
-  ALL: 'all',
+  ARRIVAL: "arr",
+  DEPARTURE: "dep",
+  ALL: "all"
 };
-
 function mapFlightListItem(nowDate, flight, T, tz, locale) {
   const {
     flightId,
@@ -22,35 +21,29 @@ function mapFlightListItem(nowDate, flight, T, tz, locale) {
     arrivalAirport,
     airportResources,
     gatePoi,
-    status: statusCode,
+    status: statusCode
   } = flight;
-
   const rawDateTime = selectRawDateTime(flight);
-  const { localTime, localOldTime } = formatToLocalDateTimes(rawDateTime, tz); // local refers to the venue time
+  const { localTime, localOldTime } = formatToLocalDateTimes(rawDateTime, tz);
   const status = mapFlightStatus(flightType, statusCode, nowDate, localTime, localOldTime);
-  const datePlaceholder =
-    flightType === FlightType.DEPARTURE ? 'flightDetails:Departs _date_' : 'flightDetails:Arrives _date_';
-
+  const datePlaceholder = flightType === FlightType.DEPARTURE ? "flightDetails:Departs _date_" : "flightDetails:Arrives _date_";
   return {
     flightId,
-    name: `${R.propOr('', 'name', airline)} - ${carrierFsCode} ${flightNumber}`,
+    name: `${R.propOr("", "name", airline)} - ${carrierFsCode} ${flightNumber}`,
     status,
     statusText: T(`flightDetails:${getFlightStatusText(status)}`),
-    baggageClaim:
-      flightType === FlightType.ARRIVAL ? prepareBaggageClaim(airportResources.arrivalBagClaim, T) : undefined,
+    baggageClaim: flightType === FlightType.ARRIVAL ? prepareBaggageClaim(airportResources.arrivalBagClaim, T) : void 0,
     connectionAirport: prepareAirportLabel(flightType, departureAirport, arrivalAirport, T),
     time: getLocalFormattedTime(localTime, tz, locale),
     oldTime: getLocalFormattedTime(localOldTime, tz, locale),
     date: T(datePlaceholder, {
-      date: getLocalFormattedDate(localTime, tz, locale),
+      date: getLocalFormattedDate(localTime, tz, locale)
     }),
     dateStamp: localTime.toMillis(),
     gate: formatGate(gatePoi),
-    gateLabel: T('flightDetails:Gate'),
+    gateLabel: T("flightDetails:Gate")
   };
 }
-
-// todo create test when airline is undefined
 function mapFlightDetails(nowDate, flight, T, tz, locale) {
   const {
     flightNumber,
@@ -62,23 +55,20 @@ function mapFlightDetails(nowDate, flight, T, tz, locale) {
     carrierFsCode,
     gatePoi,
     airline,
-    status: statusCode,
+    status: statusCode
   } = flight;
-
-  const pickAirportData = R.pick(['city', 'iata']);
+  const pickAirportData = R.pick(["city", "iata"]);
   const rawDateTime = selectRawDateTime(flight);
-  const { localTime, localOldTime } = formatToLocalDateTimes(rawDateTime, tz); // local refers to the venue time
+  const { localTime, localOldTime } = formatToLocalDateTimes(rawDateTime, tz);
   const status = mapFlightStatus(flightType, statusCode, nowDate, localTime, localOldTime);
-  const flightTypeLabel = flightType === FlightType.DEPARTURE ? 'Departure' : 'Arrival';
-
+  const flightTypeLabel = flightType === FlightType.DEPARTURE ? "Departure" : "Arrival";
   return {
     flightType,
     flightTypeLabel: T(`flightDetails:${flightTypeLabel}`),
-    name: `${R.propOr('', 'name', airline)} - ${carrierFsCode} ${flightNumber}`,
+    name: `${R.propOr("", "name", airline)} - ${carrierFsCode} ${flightNumber}`,
     status,
     statusText: T(`flightDetails:${getFlightStatusText(status)}`),
-    baggageClaim:
-      flightType === FlightType.ARRIVAL ? prepareBaggageClaim(airportResources.arrivalBagClaim, T) : undefined,
+    baggageClaim: flightType === FlightType.ARRIVAL ? prepareBaggageClaim(airportResources.arrivalBagClaim, T) : void 0,
     departure: pickAirportData(departureAirport),
     arrival: pickAirportData(arrivalAirport),
     connectionAirport: prepareAirportLabel(flightType, departureAirport, arrivalAirport, T),
@@ -87,102 +77,72 @@ function mapFlightDetails(nowDate, flight, T, tz, locale) {
     oldTime: getLocalFormattedTime(localOldTime, tz, locale),
     date: getLocalFormattedDate(localTime, tz, locale),
     lastUpdated: prepareLastUpdated(nowDate, flightStatusUpdates, T),
-    flightDuration: '',
-    gateLabel: T('flightDetails:Gate'),
+    flightDuration: "",
+    gateLabel: T("flightDetails:Gate"),
     gate: formatGate(gatePoi),
     tags: [],
-    flightIconBaseName: flightType === FlightType.ARRIVAL ? 'arrivals' : 'departures',
+    flightIconBaseName: flightType === FlightType.ARRIVAL ? "arrivals" : "departures"
   };
 }
-
-// used to sort flights in ASCENDING order of flight arrival/departure time
 const flightComparator = (flight1, flight2) => flight1.dateStamp - flight2.dateStamp;
-
-// Matches gate identifiers: optional letter prefix + digits + optional letter suffix (e.g. "B54", "23", "B32a")
 const gateNameRegex = /[A-Z]?\d+[a-zA-Z]?/;
-
-const formatGate = gate => {
+const formatGate = (gate) => {
   if (!gate) {
-    return { name: '-' };
+    return { name: "-" };
   }
   const match = gate.name.match(gateNameRegex);
   const name = match ? match[0] : gate.name;
   return { ...gate, name };
 };
-
 const prepareFlightIn = (status, flightType, nowDate, flightDate, T) => {
   if (status === constants.FlightLabelStatus.DEPARTED) {
-    return T('flightDetails:Departed');
+    return T("flightDetails:Departed");
   } else if (status === constants.FlightLabelStatus.ARRIVED) {
-    return T('flightDetails:Arrived');
+    return T("flightDetails:Arrived");
   } else if (status === constants.FlightLabelStatus.CANCELLED) {
     return null;
   }
-
-  const prefix = flightType === FlightType.DEPARTURE ? 'Departs' : 'Arrives';
+  const prefix = flightType === FlightType.DEPARTURE ? "Departs" : "Arrives";
   const minutes = minutesBetween(nowDate, flightDate);
   return T(`flightDetails:${prefix} in _minutes_ minute`, { count: minutes });
 };
-
 const prepareLastUpdated = (nowDate, flightStatusUpdates, T) => {
-  const updateDate = R.compose(R.path(['updatedAt', 'dateUtc']), R.last)(flightStatusUpdates);
+  const updateDate = R.compose(R.path(["updatedAt", "dateUtc"]), R.last)(flightStatusUpdates);
   const minutes = minutesBetween(nowDate, getLocalGMTDate(updateDate));
-
   if (minutes < 10) {
-    return T('flightDetails:Last updated a few minutes ago');
+    return T("flightDetails:Last updated a few minutes ago");
   } else if (minutes < 60) {
-    return T('flightDetails:Last updated _minutes_ minutes ago', { minutes });
+    return T("flightDetails:Last updated _minutes_ minutes ago", { minutes });
   } else {
-    return T('flightDetails:Last updated over an hour ago');
+    return T("flightDetails:Last updated over an hour ago");
   }
 };
-
-/**
- * Check minutes difference between two Luxon dates.
- * @param {DateTime} firstDate
- * @param {DateTime} secondDate
- */
 const minutesBetween = (firstDate, secondDate) => {
   const ms = Math.abs(firstDate - secondDate);
   return date.msToMin(ms);
 };
-
-const selectRawDateTime = ({ flightType, operationalTimes, departureDate, arrivalDate }) =>
-  flightType === FlightType.DEPARTURE
-    ? prepareRawDateTime(departureDate, operationalTimes.estimatedGateDeparture)
-    : prepareRawDateTime(arrivalDate, operationalTimes.estimatedGateArrival);
-
+const selectRawDateTime = ({ flightType, operationalTimes, departureDate, arrivalDate }) => flightType === FlightType.DEPARTURE ? prepareRawDateTime(departureDate, operationalTimes.estimatedGateDeparture) : prepareRawDateTime(arrivalDate, operationalTimes.estimatedGateArrival);
 const prepareRawDateTime = (dateTime, estimatedTime) => {
   const localDate = dateTime.dateLocal || dateTime.dateUtc;
   const estimatedDate = estimatedTime.dateLocal || estimatedTime.dateUtc;
   const isTimeChanged = estimatedDate && localDate !== estimatedDate;
   return isTimeChanged ? { time: estimatedDate, oldTime: localDate } : { time: localDate };
 };
-
-/**
- * Parse flight dates strings to Luxon dates relative to the venue timezone.
- * @param {{ time: string, oldTime: string }} - times
- * @param {string} tz - venue timezone
- */
 const formatToLocalDateTimes = ({ time, oldTime }, tz) => ({
   localTime: getLocalGMTDate(time, tz),
-  localOldTime: getLocalGMTDate(oldTime, tz),
+  localOldTime: getLocalGMTDate(oldTime, tz)
 });
-
 function mapFlightStatus(flightType, status, nowDate, localTime, localOldTime) {
   if (!localTime) {
     return constants.FlightLabelStatus.UNKNOWN;
   }
-
   if (nowDate > localTime) {
     return lateFlightStatus(flightType);
   }
-
   status = status.toUpperCase();
-  if (status === 'C') {
+  if (status === "C") {
     return constants.FlightLabelStatus.CANCELLED;
   }
-
   if (!localOldTime) {
     return constants.FlightLabelStatus.ON_TIME;
   } else if (localTime > localOldTime) {
@@ -191,62 +151,33 @@ function mapFlightStatus(flightType, status, nowDate, localTime, localOldTime) {
     return constants.FlightLabelStatus.EARLY;
   }
 }
-
-const getFlightStatusText = status => {
+const getFlightStatusText = (status) => {
   switch (status) {
     case constants.FlightLabelStatus.ON_TIME:
-      return 'on-time';
+      return "on-time";
     case constants.FlightLabelStatus.EARLY:
-      return 'early';
+      return "early";
     case constants.FlightLabelStatus.DELAYED:
-      return 'delayed';
+      return "delayed";
     case constants.FlightLabelStatus.CANCELLED:
-      return 'cancelled';
+      return "cancelled";
     case constants.FlightLabelStatus.DEPARTED:
-      return 'departed';
+      return "departed";
     case constants.FlightLabelStatus.ARRIVED:
-      return 'arrived';
+      return "arrived";
     default:
-      return 'unknown';
+      return "unknown";
   }
 };
-
-const lateFlightStatus = flightType =>
-  flightType === FlightType.DEPARTURE ? constants.FlightLabelStatus.DEPARTED : constants.FlightLabelStatus.ARRIVED;
-
-const prepareAirportLabel = (flightType, departureAirport, arrivalAirport, T) =>
-  flightType === FlightType.DEPARTURE
-    ? T(formatAirportLabel('To'), arrivalAirport)
-    : T(formatAirportLabel('From'), departureAirport);
-
-const formatAirportLabel = prefix => `flightDetails:${prefix} _city_ (_iata_)`;
-
-const prepareBaggageClaim = (claimNum, T) =>
-  claimNum &&
-  T('flightDetails:Collect luggage from Baggage Claim _claimNum_', {
-    claimNum,
-  });
-
-/**
- * Parse date string to Luxon date relative to the venue timezone.
- * @param {string} date string (can be UTC)
- * @param {string} tz - venue timezone
- */
+const lateFlightStatus = (flightType) => flightType === FlightType.DEPARTURE ? constants.FlightLabelStatus.DEPARTED : constants.FlightLabelStatus.ARRIVED;
+const prepareAirportLabel = (flightType, departureAirport, arrivalAirport, T) => flightType === FlightType.DEPARTURE ? T(formatAirportLabel("To"), arrivalAirport) : T(formatAirportLabel("From"), departureAirport);
+const formatAirportLabel = (prefix) => `flightDetails:${prefix} _city_ (_iata_)`;
+const prepareBaggageClaim = (claimNum, T) => claimNum && T("flightDetails:Collect luggage from Baggage Claim _claimNum_", {
+  claimNum
+});
 const getLocalGMTDate = (date, tz) => date && luxon.DateTime.fromISO(date, { zone: tz });
-
-const getLocalFormattedDate = (dateStr, tz, locale = 'en-US') =>
-  dateStr && luxon.DateTime.fromISO(dateStr, { zone: tz }).setLocale(locale).toFormat('EEE, d MMMM');
-
-/**
- * Parse date string to Luxon date in venue timezone and return short time.
- * Set locale, so the returned time can match the format used in particular locale.
- * E.g. for 'en-US' it will return "6:00 AM". For 'fr' it will return "6:00".
- * @param {string} dateStr - date string (can be UTC)
- * @param {string} tz - timezone string
- * @param {string} [locale='en-US'] locale string
- */
-const getLocalFormattedTime = (dateStr, tz, locale = 'en-US') =>
-  dateStr && date.formatTime(luxon.DateTime.fromISO(dateStr, { zone: tz }), locale);
+const getLocalFormattedDate = (dateStr, tz, locale = "en-US") => dateStr && luxon.DateTime.fromISO(dateStr, { zone: tz }).setLocale(locale).toFormat("EEE, d MMMM");
+const getLocalFormattedTime = (dateStr, tz, locale = "en-US") => dateStr && date.formatTime(luxon.DateTime.fromISO(dateStr, { zone: tz }), locale);
 
 exports.FlightType = FlightType;
 exports.flightComparator = flightComparator;

package/dist/cjs/plugins/flightStatus/src/flightStatus.js

@@ -26,40 +26,31 @@ function _interopNamespaceDefault(e) {
 var R__namespace = /*#__PURE__*/_interopNamespaceDefault(R);
 
 function create(app, config) {
-  const createIndex = () =>
-    new FlexSearch.Index({
-      tokenize: 'forward',
-    });
+  const createIndex = () => new FlexSearch.Index({
+    tokenize: "forward"
+  });
   const init = async () => {
-    state.tz = await app.bus.get('venueData/getVenueTimezone');
+    state.tz = await app.bus.get("venueData/getVenueTimezone");
   };
-
   const state = {
     lastUpdated: 0,
     flights: { dep: null, arr: null },
     index: { dep: createIndex(), arr: createIndex() },
     gates: null,
-    apiError: false,
+    apiError: false
   };
-
   const enrichData = (flights, airportsArg, airlinesArg, flightType) => {
     const airports = airportsArg.reduce((acc, obj) => {
       return { ...acc, [obj.iata]: obj };
     }, {});
-    const airlines = airlinesArg
-      .flatMap(airline => [
-        { code: airline.iata, airline },
-        { code: airline.icao, airline },
-      ])
-      .filter(({ code }) => code)
-      .reduce((acc, { code, airline }) => {
-        return { ...acc, [code]: airline };
-      }, {});
-    return flights.map(flight => {
-      const gateId =
-        flightType === flightDetailsMapper.FlightType.DEPARTURE
-          ? R__namespace.pathOr('', ['airportResources', 'departureGate'], flight)
-          : R__namespace.pathOr('', ['airportResources', 'arrivalGate'], flight);
+    const airlines = airlinesArg.flatMap((airline) => [
+      { code: airline.iata, airline },
+      { code: airline.icao, airline }
+    ]).filter(({ code }) => code).reduce((acc, { code, airline }) => {
+      return { ...acc, [code]: airline };
+    }, {});
+    return flights.map((flight) => {
+      const gateId = flightType === flightDetailsMapper.FlightType.DEPARTURE ? R__namespace.pathOr("", ["airportResources", "departureGate"], flight) : R__namespace.pathOr("", ["airportResources", "arrivalGate"], flight);
       const gatePoi = state.gates[gateId];
       return {
         ...flight,
@@ -67,90 +58,84 @@ function create(app, config) {
         gatePoi,
         airline: airlines[flight.carrierFsCode],
         departureAirport: airports[flight.departureAirportFsCode],
-        arrivalAirport: airports[flight.arrivalAirportFsCode],
+        arrivalAirport: airports[flight.arrivalAirportFsCode]
       };
     });
   };
-
   const updateIndexes = (type, flightStatuses) => {
     state.index[type] = createIndex();
     state.flights[type] = {};
-    flightStatuses.forEach(status => {
+    flightStatuses.forEach((status) => {
       state.index[type].add(status.flightId, createFlightSearchEntry(status));
       state.flights[type][status.flightId] = status;
     });
   };
-
   const searchPropertiesPaths = [
-    ['flightNumber'],
-    ['airline', 'iata'],
-    ['airline', 'name'],
-    ['arrivalAirport', 'iata'],
-    ['arrivalAirport', 'city'],
-    ['departureAirport', 'iata'],
-    ['departureAirport', 'city'],
+    ["flightNumber"],
+    ["airline", "iata"],
+    ["airline", "name"],
+    ["arrivalAirport", "iata"],
+    ["arrivalAirport", "city"],
+    ["departureAirport", "iata"],
+    ["departureAirport", "city"]
   ];
   const createFlightSearchEntry = R__namespace.pipe(
     // apply each function one after another to passed object
-    R__namespace.juxt(R__namespace.map(R__namespace.path, searchPropertiesPaths)), // safe collect of nested properties into list
-    R__namespace.filter(R__namespace.identity), // filter 'falsy' values
-    R__namespace.join(' '),
+    R__namespace.juxt(R__namespace.map(R__namespace.path, searchPropertiesPaths)),
+    // safe collect of nested properties into list
+    R__namespace.filter(R__namespace.identity),
+    // filter 'falsy' values
+    R__namespace.join(" ")
   );
-
   const indexGatePois = async () => {
     if (state.gates === null) {
-      const gatePois = await app.bus.get('poi/getByCategoryId', {
-        categoryId: 'gate',
+      const gatePois = await app.bus.get("poi/getByCategoryId", {
+        categoryId: "gate"
       });
-      const parseGate = ({ name }) => R__namespace.tail(name.replace(',', '').split(' '));
+      const parseGate = ({ name }) => R__namespace.tail(name.replace(",", "").split(" "));
       const pairs = R__namespace.reduce(
         (acc, poi) => {
           const gateIds = parseGate(poi);
-          const gateAndPoiPairs = R__namespace.map(gateId => [gateId, poi], gateIds);
+          const gateAndPoiPairs = R__namespace.map((gateId) => [gateId, poi], gateIds);
           return [...acc, ...gateAndPoiPairs];
         },
         [],
-        Object.values(gatePois),
+        Object.values(gatePois)
       );
-
       state.gates = R__namespace.fromPairs(pairs);
     }
     return state;
   };
-
   const updateFlights = async () => {
     await indexGatePois();
-    const venueData = await app.bus.get('venueData/getVenueData');
+    const venueData = await app.bus.get("venueData/getVenueData");
     const params = new URLSearchParams();
     const locale = app.i18n?.().language;
     if (locale) {
-      params.append('locale', locale);
+      params.append("locale", locale);
     }
     if (config?.timeRange) {
       const now = Date.now();
       const startDate = new Date(now - config.timeRange.beforeNowMs).toISOString();
       const endDate = new Date(now + config.timeRange.afterNowMs).toISOString();
-      params.append('startDate', startDate);
-      params.append('endDate', endDate);
+      params.append("startDate", startDate);
+      params.append("endDate", endDate);
     }
-
     const baseURL = `https://marketplace.locuslabs.com/venueId/${venueData.baseVenueId}/flight-status`;
     const apiURL = params.toString() ? `${baseURL}?${params.toString()}` : baseURL;
-
     try {
       const response = await fetch(apiURL);
       const data = await response.json();
-      [flightDetailsMapper.FlightType.ARRIVAL, flightDetailsMapper.FlightType.DEPARTURE].forEach(type => {
-        const key = type === flightDetailsMapper.FlightType.DEPARTURE ? 'departures' : 'arrivals';
+      [flightDetailsMapper.FlightType.ARRIVAL, flightDetailsMapper.FlightType.DEPARTURE].forEach((type) => {
+        const key = type === flightDetailsMapper.FlightType.DEPARTURE ? "departures" : "arrivals";
         const { airports, airlines } = data.data[key].appendix;
         updateIndexes(type, enrichData(data.data[key].flightStatuses, airports, airlines, type));
       });
       state.apiError = false;
     } catch (error) {
       state.apiError = true;
-      console.error('Error from flight status api call', error);
-      [flightDetailsMapper.FlightType.ARRIVAL, flightDetailsMapper.FlightType.DEPARTURE].forEach(type => {
-        // In the case of an api error we still need to update current flights to an empty array, otherwise we get an object undefined error
+      console.error("Error from flight status api call", error);
+      [flightDetailsMapper.FlightType.ARRIVAL, flightDetailsMapper.FlightType.DEPARTURE].forEach((type) => {
         updateIndexes(type, []);
       });
     } finally {
@@ -158,51 +143,32 @@ function create(app, config) {
     }
     return state;
   };
-
   const checkFlights = async () => {
-    // if the data was not update in the last minute, update it
-    if (Date.now() - state.lastUpdated > 60 * 1000) {
+    if (Date.now() - state.lastUpdated > 60 * 1e3) {
       await updateFlights();
     }
   };
-
-  /**
-   * Does query for flight status info. Before doing anything requests verification
-   * if the date is up-to-date
-   * @param  {String} term - term to query the search index, default null, if null returns all flights of provided type
-   * @param  {String} type - type of flights to query for, default 'dep' (departures)
-   */
-  app.bus.on('flightStatus/query', async ({ term = null, type = flightDetailsMapper.FlightType.DEPARTURE } = {}) => {
+  app.bus.on("flightStatus/query", async ({ term = null, type = flightDetailsMapper.FlightType.DEPARTURE } = {}) => {
     await checkFlights();
     return utils.searchFlights(term, type, state);
   });
-
-  /**
-   * Fetches flight info based on flight ID, make sure the data is up-tp-date first
-   * @param  {String} flightId - id of the flight we want to get
-   */
-  app.bus.on('flightStatus/getFlight', async ({ flightId }) => {
+  app.bus.on("flightStatus/getFlight", async ({ flightId }) => {
     await checkFlights();
     const flight = state.flights.dep[flightId] || state.flights.arr[flightId];
     return flight;
   });
-
-  app.bus.on('flightStatus/mapFlightDetails', async ({ flight }) => {
+  app.bus.on("flightStatus/mapFlightDetails", async ({ flight }) => {
     return flightDetailsMapper.mapFlightDetails(luxon.DateTime.local(), flight, app.gt(), state.tz, app.i18n().language);
   });
-
-  app.bus.on('flightStatus/mapFlightListItems', async ({ flights }) => {
-    return flights
-      .map(flight => flightDetailsMapper.mapFlightListItem(luxon.DateTime.local(), flight, app.gt(), state.tz, app.i18n().language))
-      .sort(flightDetailsMapper.flightComparator);
+  app.bus.on("flightStatus/mapFlightListItems", async ({ flights }) => {
+    return flights.map((flight) => flightDetailsMapper.mapFlightListItem(luxon.DateTime.local(), flight, app.gt(), state.tz, app.i18n().language)).sort(flightDetailsMapper.flightComparator);
   });
-
   return {
     init,
     internal: {
       updateFlights,
-      indexGatePois,
-    },
+      indexGatePois
+    }
   };
 }
 

package/dist/cjs/plugins/flightStatus/src/utils.js

@@ -2,30 +2,20 @@
 
 var flightDetailsMapper = require('./flightDetailsMapper.js');
 
-/**
- * Searches flights by term or returns all flights of specified type(s)
- * @param {String} term - Search term, or null to return all flights
- * @param {String} type - Flight type: 'dep', 'arr', or 'all'
- * @param {Object} state - Flight state object { index, flights, apiError }
- * @returns {Object} { flights: Array, apiError: Boolean }
- */
 const searchFlights = (term, type, state) => {
   const { index, flights, apiError } = state;
   const types = type === flightDetailsMapper.FlightType.ALL ? [flightDetailsMapper.FlightType.DEPARTURE, flightDetailsMapper.FlightType.ARRIVAL] : [type];
-
   let flightResults;
   if (term) {
-    flightResults = types.flatMap(t => {
+    flightResults = types.flatMap((t) => {
       const ids = index[t].search({ query: term });
-      return ids.map(id => flights[t][id]);
+      return ids.map((id) => flights[t][id]);
     });
   } else {
-    flightResults = types.flatMap(t => Object.values(flights[t]));
+    flightResults = types.flatMap((t) => Object.values(flights[t]));
   }
-
   if (flightResults.length === 0 && /^\w\w\d{2,4}$/.test(term)) {
-    // When user seach for flight UA4567, we will need to convert it to UA_4567 for a valid search result.
-    const modifiedTerm = term.replace(/(\w\w)(\d{2,4})/, '$1_$2');
+    const modifiedTerm = term.replace(/(\w\w)(\d{2,4})/, "$1_$2");
     return searchFlights(modifiedTerm, type, state);
   }
   return { flights: flightResults, apiError };