@fboes/aerofly-data 1.9.1 → 1.9.3

package/docs/update-liveries.md

@@ -0,0 +1,13 @@
+# Update livery-to-ICAO mappings
+
+Review `data/aircraft-liveries-missing.md` and update `src/livery-to-icao.json` with mappings for entries that are clearly official airlines.
+
+- Use each livery name, converted to lowercase, as the JSON key.
+- Use the airline's official three-letter ICAO designator, not its IATA code.
+- Add a mapping only when both the airline identity and its ICAO designator are unambiguous. Check reliable sources when needed.
+- For clear airline-branded variants (such as cargo, anniversary, or special liveries), use the airline's ICAO designator.
+- Leave ambiguous names, fictional liveries, military/government liveries, and other non-airline designs unmapped. Do not guess.
+- Preserve all existing mappings; do not overwrite a mapping with a different code without confirming and explaining the correction.
+- Keep the JSON valid and do not modify the missing-livery list.
+
+After editing, verify that the JSON parses, all keys are lowercase, no duplicate keys were introduced, and the aircraft-functions module still loads.

package/get-aircraft.js

@@ -2,40 +2,73 @@
 
 //@ts-check
 
-import * as fs from "node:fs";
+import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import {
   getAeroflyAircraft,
   getSelectLiveryOptgroupOptions,
   getSelectOptgroupOptions,
   getSelectOptions,
+  MISSING_LIVERIES,
 } from "./src/aircraft-functions.js";
 
 const inputDirectory = process.argv[2] ?? ".";
 const aeroflyAircraft = getAeroflyAircraft(inputDirectory);
 
+/**
+ * @type {Promise<void>[]}
+ */
+const promises = [];
+
 process.stdout
   .write(`Found \x1b[92m${aeroflyAircraft.length}\x1b[0m Aerofly FS Aircraft with \x1b[92m${aeroflyAircraft.reduce((sum, aircraft) => sum + aircraft.liveries.length, 0)}\x1b[0m liveries
 `);
 
 // Ensure the output directory exists
 const outputDirectory = path.join("data");
-await fs.promises.mkdir(outputDirectory, { recursive: true });
+await fs.mkdir(outputDirectory, { recursive: true });
 
 // Write the full output (with liveries) to aircraft-liveries.json
 const outputFilePathWithLiveries = path.join(outputDirectory, "aircraft-liveries.json");
-await fs.promises.writeFile(outputFilePathWithLiveries, JSON.stringify(aeroflyAircraft, null, 2), "utf-8");
-process.stdout.write(`Full aircraft data (with liveries) written to \x1b[92m${outputFilePathWithLiveries}\x1b[0m\n`);
+promises.push(
+  fs.writeFile(outputFilePathWithLiveries, JSON.stringify(aeroflyAircraft, null, 2), "utf-8").then(() => {
+    process.stdout.write(
+      `Full aircraft data (with liveries) written to \x1b[92m${outputFilePathWithLiveries}\x1b[0m\n`,
+    );
+  }),
+);
+
+// Write missing livery file
+const outputMissingLiveries = path.join(outputDirectory, "aircraft-liveries-missing.md");
+/**
+ * @type {string[]}
+ */
+const missingLiveries = [];
+MISSING_LIVERIES.forEach((m) => {
+  missingLiveries.push(`- ${m}`);
+});
+const outputMissingLiveriesContent =
+  "# Aerofly FS: Liveries without ICAO code match\n\n" + missingLiveries.sort().join("\n") + "\n";
+promises.push(
+  fs.writeFile(outputMissingLiveries, outputMissingLiveriesContent, "utf-8").then(() => {
+    process.stdout.write(`Missing livery file written to \x1b[92m${outputMissingLiveries}\x1b[0m\n`);
+  }),
+);
 
 // Write the abbreviated output (without liveries) to aircraft.json
 const outputFilePathWithoutLiveries = path.join(outputDirectory, "aircraft.json");
-await fs.promises.writeFile(
-  outputFilePathWithoutLiveries,
-  JSON.stringify(aeroflyAircraft, (key, value) => (key === "liveries" ? undefined : value), 2),
-  "utf-8",
-);
-process.stdout.write(
-  `Abbreviated aircraft data (without liveries) written to \x1b[92m${outputFilePathWithoutLiveries}\x1b[0m\n`,
+promises.push(
+  fs
+    .writeFile(
+      outputFilePathWithoutLiveries,
+      JSON.stringify(aeroflyAircraft, (key, value) => (key === "liveries" ? undefined : value), 2),
+      "utf-8",
+    )
+    .then(() => {
+      process.stdout.write(
+        `Abbreviated aircraft data (without liveries) written to \x1b[92m${outputFilePathWithoutLiveries}\x1b[0m\n`,
+      );
+    }),
 );
 
 // Sort aeroflyAircraft by nameFull
@@ -82,29 +115,43 @@ const summaryContent =
 - Total Liveries: **${numberFormat(sortedAircraft.reduce((sum, aircraft) => sum + aircraft.liveries.length, 0))}**
 `;
 
-await fs.promises.writeFile(summaryFilePath, summaryContent, "utf-8");
-process.stdout.write(`Summary written to \x1b[92m${summaryFilePath}\x1b[0m\n`);
+promises.push(
+  fs.writeFile(summaryFilePath, summaryContent, "utf-8").then(() => {
+    process.stdout.write(`Summary written to \x1b[92m${summaryFilePath}\x1b[0m\n`);
+  }),
+);
 
 // Write HTML <select> options to aircraft-select.html
 const selectFilePath = path.join(outputDirectory, "aircraft-select.html");
 let selectContent = getSelectOptions(sortedAircraft);
-await fs.promises.writeFile(selectFilePath, selectContent, "utf-8");
-process.stdout.write(`HTML <select> options written to \x1b[92m${selectFilePath}\x1b[0m\n`);
+promises.push(
+  fs.writeFile(selectFilePath, selectContent, "utf-8").then(() => {
+    process.stdout.write(`HTML <select> options written to \x1b[92m${selectFilePath}\x1b[0m\n`);
+  }),
+);
 
 // Write HTML <select> with <optgroup> to aircraft-select-optgroup.html
 const selectOptgroupFilePath = path.join(outputDirectory, "aircraft-select-optgroup.html");
 let selectOptgroupContent = getSelectOptgroupOptions(sortedAircraft);
-await fs.promises.writeFile(selectOptgroupFilePath, selectOptgroupContent, "utf-8");
-process.stdout.write(
-  `HTML aircraft <select> with category <optgroup> options written to \x1b[92m${selectOptgroupFilePath}\x1b[0m\n`,
+promises.push(
+  fs.writeFile(selectOptgroupFilePath, selectOptgroupContent, "utf-8").then(() => {
+    process.stdout.write(
+      `HTML aircraft <select> with category <optgroup> options written to \x1b[92m${selectOptgroupFilePath}\x1b[0m\n`,
+    );
+  }),
 );
 
 // Write HTML <select> with <optgroup> to aircraft-select-optgroup.html
 const selectOptgroupLiveryFilePath = path.join(outputDirectory, "aircraft-livery-select-optgroup.html");
 let selectOptgroupLiveryContent = getSelectLiveryOptgroupOptions(sortedAircraft);
-await fs.promises.writeFile(selectOptgroupLiveryFilePath, selectOptgroupLiveryContent, "utf-8");
-process.stdout.write(
-  `HTML livery <select> with aircraft <optgroup> options written to \x1b[92m${selectOptgroupLiveryFilePath}\x1b[0m\n`,
+promises.push(
+  fs.writeFile(selectOptgroupLiveryFilePath, selectOptgroupLiveryContent, "utf-8").then(() => {
+    process.stdout.write(
+      `HTML livery <select> with aircraft <optgroup> options written to \x1b[92m${selectOptgroupLiveryFilePath}\x1b[0m\n`,
+    );
+  }),
 );
 
-process.stdout.write(`\nAll aircraft files written to \x1b[92m${path.resolve(outputDirectory)}\x1b[0m\n`);
+Promise.all(promises).then(() => {
+  process.stdout.write(`\nAll aircraft files written to \x1b[92m${path.resolve(outputDirectory)}\x1b[0m\n`);
+});

package/get-airports.js

@@ -3,7 +3,7 @@
 //@ts-check
 
 import GeoJSON from "@fboes/geojson";
-import * as fs from "node:fs";
+import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { parse } from "csv-parse/sync";
 import {
@@ -17,9 +17,7 @@ const inputDirectory = process.argv[2] ?? ".";
 
 // Ensure the output directory exists
 const outputDirectory = path.join("data");
-if (!fs.existsSync(outputDirectory)) {
-  fs.mkdirSync(outputDirectory, { recursive: true });
-}
+await fs.mkdir(outputDirectory, { recursive: true });
 
 const aeroflyGeoJson = new GeoJSON.FeatureCollection();
 const aeroflyAirports = new Map([
@@ -30,7 +28,7 @@ const aeroflyAirportsLength = aeroflyAirports.size;
 process.stdout.write(`Found \x1b[92m${aeroflyAirports.size}\x1b[0m Aerofly FS Airports
 `);
 
-const airportsSource = fs.readFileSync(`tmp/airports.csv`);
+const airportsSource = await fs.readFile(`tmp/airports.csv`);
 
 /** @type {string[][]} with a single CSV line from airports.csv */
 let airportsRecords = parse(airportsSource, { bom: true });
@@ -45,10 +43,10 @@ const icaoCodes = [];
 
 /**
  * @type {{
- *  code: String,
- *  name: String,
- *  lat: Number,
- *  lon: Number
+ *  code: string,
+ *  name: string,
+ *  lat: number,
+ *  lon: number
  * }[]}
  */
 const icaoCoordinatesObject = [];
@@ -58,14 +56,14 @@ const icaoCoordinatesObject = [];
  * @param {string[]} searchWords
  * @returns {[number, string]|[undefined, undefined]} Returns the length of the airport and the code if found, otherwise undefined.
  */
-const getAeroflyAirport = (searchWords) => {
+function getAeroflyAirport(searchWords) {
   for (const word of searchWords) {
     if (aeroflyAirports.has(word)) {
       return [aeroflyAirports.get(word) || 0, word];
     }
   }
   return [undefined, undefined];
-};
+}
 
 /**
  * @param {string} aeroflyCode
@@ -73,7 +71,7 @@ const getAeroflyAirport = (searchWords) => {
  * @param {string[]} airportsRecord
  * @param {number} length
  */
-const addRecord = (aeroflyCode, bestCode, airportsRecord, length) => {
+function addRecord(aeroflyCode, bestCode, airportsRecord, length) {
   // Remove airport from list of Aerofly FS4 Airports
   aeroflyAirports.delete(aeroflyCode);
 
@@ -121,7 +119,7 @@ const addRecord = (aeroflyCode, bestCode, airportsRecord, length) => {
   }
 
   aeroflyGeoJson.addFeature(feature);
-};
+}
 
 // -----------------------------------------------------------------------------
 // PARSING
@@ -187,12 +185,12 @@ icaoCoordinatesObject.sort((a, b) => {
 
 // Write the GeoJSON data to a file
 const outputFilePath = path.join(outputDirectory, "airports.geojson");
-fs.writeFileSync(outputFilePath, JSON.stringify(aeroflyGeoJson, null, 2), "utf-8");
+await fs.writeFile(outputFilePath, JSON.stringify(aeroflyGeoJson, null, 2), "utf-8");
 process.stdout.write(`GeoJSON data written to \x1b[92m${outputFilePath}\x1b[0m\n`);
 
 // Write the ICAO codes to airport-list.json
 const icaoListFilePath = path.join(outputDirectory, "airport-list.json");
-fs.writeFileSync(icaoListFilePath, JSON.stringify(icaoCodes.sort(), null, 2) + "\n", "utf-8");
+await fs.writeFile(icaoListFilePath, JSON.stringify(icaoCodes.sort(), null, 2) + "\n", "utf-8");
 process.stdout.write(`ICAO code list written to \x1b[92m${icaoListFilePath}\x1b[0m\n`);
 
 // Write the ICAO codes with airport names and geocoordinates to airport-coordinates.json
@@ -200,12 +198,12 @@ const icaoCoordinates = icaoCoordinatesObject.map((feature) => {
   return [feature.code, feature.name, feature.lat, feature.lon];
 });
 const icaoCoordinatesFilePath = path.join(outputDirectory, "airport-coordinates.json");
-fs.writeFileSync(icaoCoordinatesFilePath, JSON.stringify(icaoCoordinates, null, 2) + "\n", "utf-8");
+await fs.writeFile(icaoCoordinatesFilePath, JSON.stringify(icaoCoordinates, null, 2) + "\n", "utf-8");
 process.stdout.write(`ICAO coordinates list written to \x1b[92m${icaoCoordinatesFilePath}\x1b[0m\n`);
 
 // Write the ICAO codes with airport names and geocoordinates to airport-coordinates-object.json
 const icaoCoordinatesObjectFilePath = path.join(outputDirectory, "airport-coordinates-object.json");
-fs.writeFileSync(icaoCoordinatesObjectFilePath, JSON.stringify(icaoCoordinatesObject, null, 2) + "\n", "utf-8");
+await fs.writeFile(icaoCoordinatesObjectFilePath, JSON.stringify(icaoCoordinatesObject, null, 2) + "\n", "utf-8");
 process.stdout.write(`ICAO coordinates object list written to \x1b[92m${icaoCoordinatesObjectFilePath}\x1b[0m\n`);
 
 // Write the missing codes to airports-unmatched.md
@@ -216,7 +214,7 @@ const unmatchedCodes = [...aeroflyAirports]
   })
   .sort()
   .join("\n");
-fs.writeFileSync(
+await fs.writeFile(
   unmatchedFilePath,
   `\
 # Aerofly FS4 Unmatched Airports

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fboes/aerofly-data",
-  "version": "1.9.1",
+  "version": "1.9.3",
   "description": "This project contains data sets for airports and aircraft present in Aerofly FS 4.",
   "main": "index.js",
   "scripts": {

package/src/aircraft-functions.js

@@ -3,6 +3,11 @@
 import * as fs from "node:fs";
 import * as path from "path";
 
+/**
+ * @type {Record<string, string>}
+ */
+const LIVERY_TO_ICAO = JSON.parse(fs.readFileSync(new URL("./livery-to-icao.json", import.meta.url), "utf8"));
+
 /**
  * @typedef AeroflyAircraftParsed
  * @type {{
@@ -37,25 +42,31 @@ import * as path from "path";
  * }}
  */
 
+/**
+ * Names of liveries which do not have an ICAO code
+ * @type {Set<string>}
+ */
+export const MISSING_LIVERIES = new Set();
+
 /**
  * Get all potential aircraft directories in the given directory.
  * @param {string} directory
  * @returns {fs.Dirent<string>[]}
  */
-const getAeroflyAircraftDirectories = (directory) => {
+function getAeroflyAircraftDirectories(directory) {
   return fs
     .readdirSync(directory, { withFileTypes: true })
     .filter((dirent) => dirent.isDirectory())
     .sort()
     .filter((dirent) => fs.existsSync(path.join(dirent.parentPath, dirent.name, dirent.name + ".tmc")));
-};
+}
 
 /**
  *
  * @param {string} directory
  * @returns {AeroflyAircraft[]}
  */
-export const getAeroflyAircraft = (directory) => {
+export function getAeroflyAircraft(directory) {
   return getAeroflyAircraftDirectories(directory).map((dirent) => {
     const tmdFileContent = fs.readFileSync(path.join(dirent.parentPath, dirent.name, dirent.name + ".tmc"), "utf8");
 
@@ -97,6 +108,8 @@ export const getAeroflyAircraft = (directory) => {
       const liveryIcaoCode = getLiveryIcaoCode(livery.name);
       if (liveryIcaoCode !== "") {
         livery.icaoCode = liveryIcaoCode;
+      } else {
+        MISSING_LIVERIES.add(livery.name);
       }
 
       return livery;
@@ -108,121 +121,23 @@ export const getAeroflyAircraft = (directory) => {
       liveries,
     };
   });
-};
+}
 
 /**
  * Convert airline name to airline ICA code
  * @param {string} airlineName
  * @returns {string} icaoCode of airline
  */
-const getLiveryIcaoCode = (airlineName) => {
+function getLiveryIcaoCode(airlineName) {
   const name = airlineName.toLowerCase();
-  switch (name) {
-    case "all nippon airlines":
-      return "ANA";
-    case "american airlines":
-    case "american":
-      return "AAL";
-    case "all nippon airways":
-      return "ANA";
-    case "china eastern":
-      return "CES";
-    case "lufthansa":
-    case "lufthansa 100":
-      return "DLH";
-    case "united airlines":
-    case "united":
-      return "UAL";
-    case "delta air lines":
-    case "delta":
-      return "DAL";
-    case "emirates":
-      return "UAE";
-    case "singapore airlines":
-      return "SIA";
-    case "ethiopian":
-      return "ETH";
-    case "air france":
-      return "AFR";
-    case "british airways":
-      return "BAW";
-    case "china southern airlines":
-      return "CSN";
-    case "turkish airlines":
-      return "THY";
-    case "air canada":
-      return "ACA";
-    case "etihad airways":
-    case "ethiad":
-      return "ETD";
-    case "latam airlines":
-    case "latam":
-      return "LAN";
-    case "tam airlines":
-    case "tam":
-      return "TAM";
-    case "jetblue airways":
-    case "jetblue":
-      return "JBU";
-    case "azul brazilian airlines":
-      return "AZU";
-    case "china eastern airlines":
-      return "CES";
-    case "ethiopian airlines":
-      return "ETH";
-    case "klm royal dutch airlines":
-    case "klm":
-      return "KLM";
-    case "korean air":
-    case "korean air lines":
-      return "KAL";
-    case "qatar airways":
-      return "QTR";
-    case "swiss international air lines":
-    case "swiss":
-      return "SWR";
-    case "hawaiian airlines":
-      return "HVN";
-    case "eurowings":
-      return "EWG";
-    case "easyjet":
-      return "EZY";
-    case "iberia":
-      return "IBE";
-    case "sas":
-      return "SAS";
-    case "aeroflot":
-      return "AFL";
-    case "air china":
-      return "CCA";
-    case "alitalia":
-      return "AZA";
-    case "brussels airlines":
-      return "BEL";
-    case "cathay pacific":
-      return "CPA";
-    case "china southern":
-      return "CSN";
-    case "norwegian":
-      return "NAX";
-    case "aer lingus":
-      return "EIN";
-    case "avianca":
-      return "AVA";
-    case "finnair":
-      return "FIN";
-    case "tap portugal":
-      return "TAP";
-    default:
-      return "";
-  }
-};
+  return Object.hasOwn(LIVERY_TO_ICAO, name) ? LIVERY_TO_ICAO[name] : "";
+}
 
 /**
  * @param {string} tmdFileContent
  * @returns {AeroflyAircraftParsed}
  */
-export const parseAircraft = (tmdFileContent) => {
+export function parseAircraft(tmdFileContent) {
   const tags = parseTmdLine(tmdFileContent, "Tags").trim().split(" ");
 
   // type: ;
@@ -269,14 +184,14 @@ export const parseAircraft = (tmdFileContent) => {
     operatingEmptyMassKg: Number(parseTmdLine(tmdFileContent, "OperatingEmptyMass")) || undefined,
     maximumPersonsOnBoard: Number(parseTmdLine(tmdFileContent, "MaximumPersonsOnBoard")) || undefined,
   };
-};
+}
 
 /**
  *
  * @param {string} tmdFileContent
  * @returns {string[]}
  */
-const parseRequirements = (tmdFileContent) => {
+function parseRequirements(tmdFileContent) {
   const requirements = parseTmdLine(tmdFileContent, "Requirements").trim();
   if (requirements === "") {
     return [];
@@ -285,7 +200,7 @@ const parseRequirements = (tmdFileContent) => {
     .split(" ")
     .map((req) => req.trim())
     .filter((req) => req !== "");
-};
+}
 
 /**
  *
@@ -293,45 +208,45 @@ const parseRequirements = (tmdFileContent) => {
  * @param {string} key
  * @returns {string}
  */
-export const parseTmdLine = (tmdFileContent, key) => {
+export function parseTmdLine(tmdFileContent, key) {
   const r = new RegExp("\\[" + key + "\\]\\s*\\[(.+?)\\]");
   const match = tmdFileContent.match(r);
   return match && match[1] ? match[1] : "";
-};
+}
 
 /**
  *
  * @param {string} speed in m/s
  * @returns {number} in kts
  */
-export const convertSpeed = (speed) => {
+export function convertSpeed(speed) {
   return Math.round(Number(speed) * 1.94384449);
-};
+}
 
 /**
  *
  * @param {string} altitude in m
  * @returns {number} in ft
  */
-export const convertAltitude = (altitude) => {
+export function convertAltitude(altitude) {
   return Math.round(Number(altitude) * 3.28084);
-};
+}
 
 /**
  *
  * @param {string} range in m
  * @returns {number} in NM
  */
-export const convertDistance = (range) => {
+export function convertDistance(range) {
   return Math.round(Number(range) / 1852);
-};
+}
 
 /**
  *
  * @param {AeroflyAircraft[]} sortedAircraft
  * @returns {string}
  */
-export const getSelectOptions = (sortedAircraft) => {
+export function getSelectOptions(sortedAircraft) {
   const selectContent = sortedAircraft
     .map((aircraft) => {
       return `  <option value="${aircraft.aeroflyCode}">${aircraft.nameFull}</option>`;
@@ -343,14 +258,14 @@ export const getSelectOptions = (sortedAircraft) => {
 ${selectContent}
 </select>
 `;
-};
+}
 
 /**
  *
  * @param {AeroflyAircraft[]} sortedAircraft
  * @returns {string}
  */
-export const getSelectOptgroupOptions = (sortedAircraft) => {
+export function getSelectOptgroupOptions(sortedAircraft) {
   /**
    * @type {{
    *   [key: string]: {
@@ -438,14 +353,14 @@ export const getSelectOptgroupOptions = (sortedAircraft) => {
 ${html}\
 </select>
 `;
-};
+}
 
 /**
  *
  * @param {AeroflyAircraft[]} sortedAircraft
  * @returns {string}
  */
-export const getSelectLiveryOptgroupOptions = (sortedAircraft) => {
+export function getSelectLiveryOptgroupOptions(sortedAircraft) {
   let html = "";
   for (const aircraft of sortedAircraft) {
     if (aircraft.liveries.length === 0) {
@@ -463,12 +378,12 @@ export const getSelectLiveryOptgroupOptions = (sortedAircraft) => {
 ${html}\
 </select>
 `;
-};
+}
 
 /**
  * @param {AeroflyAircraft[]} sortedAircraft
  * @returns {string[]}
  */
-export const getTags = (sortedAircraft) => {
+export function getTags(sortedAircraft) {
   return [...new Set(sortedAircraft.flatMap((aircraft) => aircraft.tags))].sort();
-};
+}

package/src/airport-functions.js

@@ -10,7 +10,7 @@ import * as path from "path";
  * @param {number|undefined} length in Bytes
  * @returns {string}
  */
-export const geoJsonType = (type, isMilitary, length) => {
+export function geoJsonType(type, isMilitary, length) {
   if (type === "heliport" && length !== undefined && length > 0) {
     return type;
   }
@@ -35,14 +35,14 @@ export const geoJsonType = (type, isMilitary, length) => {
   }
 
   return type;
-};
+}
 
 /**
  *
  * @param {string} directory
  * @returns {Map<string,number>}
  */
-export const getAeroflyAirports = (directory) => {
+export function getAeroflyAirports(directory) {
   const aeroflyAirports = new Map();
   let maxLength = 0;
   let minLength = 10000;
@@ -61,14 +61,14 @@ export const getAeroflyAirports = (directory) => {
   }
 
   return aeroflyAirports;
-};
+}
 
 /**
  *
  * @param {string} filename
  * @returns {Map<string,number>}
  */
-export const addCustomAeroflyAirportsToMap = (filename) => {
+export function addCustomAeroflyAirportsToMap(filename) {
   const aeroflyAirports = new Map();
   const fileContent = fs.readFileSync(filename, "utf-8");
   const lines = fileContent.split(/\r?\n/).sort();
@@ -81,7 +81,7 @@ export const addCustomAeroflyAirportsToMap = (filename) => {
   }
 
   return aeroflyAirports;
-};
+}
 
 /**
  *
@@ -90,7 +90,7 @@ export const addCustomAeroflyAirportsToMap = (filename) => {
  * @param {string[]} airportsRecord
  * @returns {string[]}
  */
-export const getAirportSearchWords = (ident, icaoCode, airportsRecord) => {
+export function getAirportSearchWords(ident, icaoCode, airportsRecord) {
   /**
    * @type {string[]}
    */
@@ -109,4 +109,4 @@ export const getAirportSearchWords = (ident, icaoCode, airportsRecord) => {
     ...airportsRecord[18].split(/,\s*/),
     ...extraWords,
   ].filter((word) => word && word.length > 0);
-};
+}