@fboes/aerofly-data 1.9.1 → 1.9.2

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.2",
   "description": "This project contains data sets for airports and aircraft present in Aerofly FS 4.",
   "main": "index.js",
   "scripts": {

package/src/aircraft-functions.js

@@ -37,25 +37,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 +103,8 @@ export const getAeroflyAircraft = (directory) => {
       const liveryIcaoCode = getLiveryIcaoCode(livery.name);
       if (liveryIcaoCode !== "") {
         livery.icaoCode = liveryIcaoCode;
+      } else {
+        MISSING_LIVERIES.add(livery.name);
       }
 
       return livery;
@@ -108,7 +116,7 @@ export const getAeroflyAircraft = (directory) => {
       liveries,
     };
   });
-};
+}
 
 /**
  * Convert airline name to airline ICA code
@@ -118,6 +126,7 @@ export const getAeroflyAircraft = (directory) => {
 const getLiveryIcaoCode = (airlineName) => {
   const name = airlineName.toLowerCase();
   switch (name) {
+    case "ana":
     case "all nippon airlines":
       return "ANA";
     case "american airlines":
@@ -153,7 +162,7 @@ const getLiveryIcaoCode = (airlineName) => {
     case "air canada":
       return "ACA";
     case "etihad airways":
-    case "ethiad":
+    case "etihad":
       return "ETD";
     case "latam airlines":
     case "latam":
@@ -175,6 +184,7 @@ const getLiveryIcaoCode = (airlineName) => {
       return "KLM";
     case "korean air":
     case "korean air lines":
+    case "korean airlines":
       return "KAL";
     case "qatar airways":
       return "QTR";
@@ -213,6 +223,22 @@ const getLiveryIcaoCode = (airlineName) => {
       return "FIN";
     case "tap portugal":
       return "TAP";
+    case "egypt air":
+      return "MSR";
+    case "japan airlines":
+      return "JAL";
+    case "kuwait":
+      return "KAC";
+    case "saudia":
+    case "saudia arabian":
+      return "SVA";
+    case "virgin australia":
+      return "VOZ";
+    case "virgin":
+    case "virgin atlantic":
+      return "VIR";
+    case "qantas":
+      return "QFA";
     default:
       return "";
   }
@@ -222,7 +248,7 @@ const getLiveryIcaoCode = (airlineName) => {
  * @param {string} tmdFileContent
  * @returns {AeroflyAircraftParsed}
  */
-export const parseAircraft = (tmdFileContent) => {
+export function parseAircraft(tmdFileContent) {
   const tags = parseTmdLine(tmdFileContent, "Tags").trim().split(" ");
 
   // type: ;
@@ -269,14 +295,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 +311,7 @@ const parseRequirements = (tmdFileContent) => {
     .split(" ")
     .map((req) => req.trim())
     .filter((req) => req !== "");
-};
+}
 
 /**
  *
@@ -293,45 +319,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 +369,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 +464,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 +489,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);
-};
+}