airport-utils 1.0.28 → 1.3.0

package/dist/types/index.d.ts

@@ -1,3 +1,3 @@
 export { convertToUTC, convertLocalToUTCByZone } from './converter';
-export { getAirportInfo, AirportInfo } from './info';
+export { getAirportInfo, getAllAirports, AirportInfo, Airport } from './info';
 export { UnknownAirportError, InvalidTimestampError, UnknownTimezoneError } from './errors';

package/dist/types/info.d.ts

@@ -5,6 +5,12 @@ export interface AirportInfo {
     name: string;
     city: string;
     country: string;
+    countryName: string;
+    continent: string;
 }
 /** @throws UnknownAirportError */
 export declare function getAirportInfo(iata: string): AirportInfo;
+export interface Airport extends AirportInfo {
+    iata: string;
+}
+export declare function getAllAirports(): Airport[];

package/dist/types/mapping/geo.d.ts

@@ -4,5 +4,7 @@ export interface GeoEntry {
     name: string;
     city: string;
     country: string;
+    countryName: string;
+    continent: string;
 }
 export declare const geo: Record<string, GeoEntry>;

package/eslint.config.cjs

@@ -0,0 +1,84 @@
+const tsParser = require('@typescript-eslint/parser');
+const tsPlugin = require('@typescript-eslint/eslint-plugin');
+const js = require('@eslint/js');
+
+const nodeGlobals = {
+  __dirname: 'readonly',
+  module: 'readonly',
+  require: 'readonly',
+  process: 'readonly',
+  console: 'readonly',
+  Buffer: 'readonly',
+  setTimeout: 'readonly',
+  clearTimeout: 'readonly'
+};
+
+const jestGlobals = {
+  describe: 'readonly',
+  it: 'readonly',
+  test: 'readonly',
+  expect: 'readonly',
+  beforeAll: 'readonly',
+  afterAll: 'readonly',
+  beforeEach: 'readonly',
+  afterEach: 'readonly',
+  jest: 'readonly'
+};
+
+module.exports = [
+  {
+    ignores: ['dist/**', 'coverage/**', 'node_modules/**']
+  },
+  js.configs.recommended,
+  {
+    files: ['src/**/*.ts'],
+    languageOptions: {
+      parser: tsParser,
+      parserOptions: {
+        ecmaVersion: 'latest',
+        sourceType: 'module'
+      }
+    },
+    plugins: {
+      '@typescript-eslint': tsPlugin
+    },
+    rules: {
+      ...tsPlugin.configs.recommended.rules
+    }
+  },
+  {
+    files: ['scripts/**/*.ts'],
+    languageOptions: {
+      parser: tsParser,
+      parserOptions: {
+        ecmaVersion: 'latest',
+        sourceType: 'module'
+      },
+      globals: nodeGlobals
+    },
+    plugins: {
+      '@typescript-eslint': tsPlugin
+    },
+    rules: {
+      ...tsPlugin.configs.recommended.rules
+    }
+  },
+  {
+    files: ['tests/**/*.ts'],
+    languageOptions: {
+      parser: tsParser,
+      parserOptions: {
+        ecmaVersion: 'latest',
+        sourceType: 'module'
+      },
+      globals: { ...nodeGlobals, ...jestGlobals }
+    },
+    plugins: {
+      '@typescript-eslint': tsPlugin
+    },
+    rules: {
+      ...tsPlugin.configs.recommended.rules,
+      '@typescript-eslint/no-require-imports': 'off'
+    }
+  }
+];

package/jest.config.js

@@ -3,6 +3,10 @@ export default {
   testEnvironment: 'node',
   roots: ['<rootDir>/tests'],
   collectCoverage: true,
+  collectCoverageFrom: [
+    '<rootDir>/src/**/*.ts',
+    '<rootDir>/scripts/**/*.ts'
+  ],
   coverageThreshold: {
     global: { branches: 100, functions: 100, lines: 100, statements: 100 }
   },
@@ -12,4 +16,4 @@ export default {
     '/node_modules/',
     '/dist/'
   ]
-};
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "airport-utils",
-  "version": "1.0.28",
+  "version": "1.3.0",
   "description": "Convert local ISO 8601 timestamps to UTC using airport IATA codes, with airport geo-data",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
@@ -21,9 +21,12 @@
     "build:types": "tsc --emitDeclarationOnly --declaration --outDir dist/types",
     "build:js": "rollup -c",
     "build": "npm run build:types && npm run build:js",
+    "lint": "eslint \"src/**/*.ts\" \"tests/**/*.ts\" \"scripts/**/*.ts\"",
+    "format": "prettier --write \"src/**/*.ts\" \"tests/**/*.ts\" \"scripts/**/*.ts\"",
+    "format:check": "prettier --check \"src/**/*.ts\" \"tests/**/*.ts\" \"scripts/**/*.ts\"",
     "test": "jest --coverage",
     "prepublishOnly": "npm run build",
-    "update:mapping": "node --loader ts-node/esm scripts/generateMapping.ts"
+    "update:mapping": "node --loader ts-node/esm --input-type=module -e \"import { generateMapping } from './scripts/generateMapping.ts'; await generateMapping();\""
   },
   "keywords": [
     "amadeus",
@@ -36,23 +39,27 @@
   ],
   "license": "MIT",
   "dependencies": {
-    "@date-fns/tz": "^1.2.0",
-    "date-fns": "^4.1.0"
+    "@date-fns/tz": "^1.2.0"
   },
   "devDependencies": {
     "@rollup/plugin-node-resolve": "^16.0.1",
     "@rollup/plugin-typescript": "^12.1.2",
     "@semantic-release/commit-analyzer": "^13.0.1",
-    "@semantic-release/github": "^12.0.0",
-    "@semantic-release/npm": "^13.0.0",
-    "@semantic-release/release-notes-generator": "^14.0.3",
+    "@semantic-release/github": "^12.0.2",
+    "@semantic-release/npm": "^13.1.3",
+    "@semantic-release/release-notes-generator": "^14.1.0",
     "@types/jest": "^30.0.0",
     "@types/node-fetch": "^2.6.12",
+    "@typescript-eslint/eslint-plugin": "^8.53.1",
+    "@typescript-eslint/parser": "^8.53.1",
     "conventional-changelog-conventionalcommits": "^9.1.0",
+    "eslint": "^9.39.2",
+    "eslint-config-prettier": "^10.1.8",
     "jest": "^30.0.5",
     "node-fetch": "^3.3.2",
+    "prettier": "^3.8.0",
     "rollup": "^4.40.2",
-    "semantic-release": "^25.0.0",
+    "semantic-release": "^25.0.2",
     "ts-jest": "^29.0.0",
     "ts-node": "^10.9.1",
     "tslib": "^2.8.1",

package/scripts/generateMapping.ts

@@ -1,16 +1,28 @@
 #!/usr/bin/env node
-import fetch from 'node-fetch';
 import fs from 'fs';
 import path from 'path';
+import prettier from 'prettier';
 
-async function generateMapping() {
-  const url =
-    'https://raw.githubusercontent.com/opentraveldata/opentraveldata/master/opentraveldata/optd_por_public.csv';
-  const res = await fetch(url);
-  if (!res.ok) throw new Error(`Fetch failed: ${res.statusText}`);
+const DEFAULT_SOURCE_URL =
+  'https://raw.githubusercontent.com/opentraveldata/opentraveldata/master/opentraveldata/optd_por_public.csv';
+
+export async function generateMapping() {
+  const resolvedFetch = globalThis.fetch;
+  if (!resolvedFetch) {
+    throw new Error('Global fetch is not available.');
+  }
+  const cwd = process.cwd();
+
+  const prettierConfig =
+    (await prettier.resolveConfig(path.join(cwd, 'package.json'), {
+      editorconfig: true
+    })) ?? {};
+
+  const res = await resolvedFetch(DEFAULT_SOURCE_URL);
+  if (!res.ok) throw new Error(`Fetch failed: ${res.statusText ?? 'Unknown error'}`);
   const text = await res.text();
 
-  const lines = text.split('\n').filter(l => l.trim());
+  const lines = text.split('\n').filter((l) => l.trim());
   const header = lines[0].split('^');
   const idx = {
     iata: header.indexOf('iata_code'),
@@ -19,77 +31,102 @@ async function generateMapping() {
     lon: header.indexOf('longitude'),
     name: header.indexOf('name'),
     city: header.indexOf('city_name_list'),
-    country: header.indexOf('country_code')
+    locationType: header.indexOf('location_type'),
+    country: header.indexOf('country_code'),
+    countryName: header.indexOf('country_name'),
+    continent: header.indexOf('continent_name')
   };
-  if (Object.values(idx).some(i => i < 0)) {
+  if (Object.values(idx).some((i) => i < 0)) {
     throw new Error('Missing required OPTD columns');
   }
 
   const timezonesMap: Record<string, string> = {};
-  const geoMap: Record<string, {
-    latitude: number;
-    longitude: number;
-    name: string;
-    city: string;
-    country: string;
-  }> = {};
+  const geoMap: Record<
+    string,
+    {
+      latitude: number;
+      longitude: number;
+      name: string;
+      city: string;
+      country: string;
+      countryName: string;
+      continent: string;
+    }
+  > = {};
+  const pickCity = (cityNameList: string) => {
+    const parts = cityNameList
+      .split(/[=,]/)
+      .map((part) => part.trim())
+      .filter(Boolean);
+    return parts.at(-1) ?? '';
+  };
 
   for (let i = 1; i < lines.length; i++) {
     const cols = lines[i].split('^');
     const code = cols[idx.iata];
     if (!code || code.length !== 3) continue;
+    const locationType = cols[idx.locationType] ?? '';
+    if (locationType !== 'A') continue;
     const tz = cols[idx.tz];
-    if (tz) timezonesMap[code] = tz;
+    if (tz) {
+      timezonesMap[code] = tz;
+    }
 
     const lat = parseFloat(cols[idx.lat]);
     const lon = parseFloat(cols[idx.lon]);
     const name = cols[idx.name];
-    const city = cols[idx.city].split(',')[0].trim();
+    const city = pickCity(cols[idx.city]);
     const country = cols[idx.country];
-    if (!isNaN(lat) && !isNaN(lon) && name && city && country) {
-      geoMap[code] = { latitude: lat, longitude: lon, name, city, country };
+    const countryName = cols[idx.countryName];
+    const continent = cols[idx.continent];
+    if (!isNaN(lat) && !isNaN(lon) && name && city && country && countryName && continent) {
+      geoMap[code] = { latitude: lat, longitude: lon, name, city, country, countryName, continent };
     }
   }
 
   const sortedCodes = Object.keys(timezonesMap).sort();
-  const sortedTz = Object.fromEntries(sortedCodes.map(c => [c, timezonesMap[c]]));
+  const sortedTz = Object.fromEntries(sortedCodes.map((c) => [c, timezonesMap[c]]));
   const sortedGeo = Object.fromEntries(
-    sortedCodes.filter(c => geoMap[c]).map(c => [c, geoMap[c]])
+    sortedCodes.filter((c) => geoMap[c]).map((c) => [c, geoMap[c]])
   );
 
-  const dir = path.resolve(path.dirname(import.meta.url.replace('file://', '')), '../src/mapping');
+  const dir = path.resolve(cwd, 'src/mapping');
   fs.mkdirSync(dir, { recursive: true });
 
   // Write TypeScript modules
   const tzTs = [
     '// generated — do not edit',
     'export const timezones: Record<string, string> = ',
-    JSON.stringify(sortedTz, null, 2) + ';',
+    JSON.stringify(sortedTz, null, 2) + ';'
   ].join('\n');
-  fs.writeFileSync(path.join(dir, 'timezones.ts'), tzTs + '\n');
+  const formattedTz = await prettier.format(tzTs, {
+    ...prettierConfig,
+    parser: 'typescript'
+  });
+  fs.writeFileSync(path.join(dir, 'timezones.ts'), formattedTz);
 
-  const geoEntries = Object.entries(sortedGeo)
-    .map(([code, g]) => `  "${code}": ${JSON.stringify(g)}`)
-    .join(',\n');
   const geoTs = [
     '// generated — do not edit',
     'export interface GeoEntry {',
     '  latitude: number;',
     '  longitude: number;',
-    '  name: string;', 
+    '  name: string;',
     '  city: string;',
     '  country: string;',
-    '}', '',
-    'export const geo: Record<string, GeoEntry> = {',
-    geoEntries,
-    '};',
+    '  countryName: string;',
+    '  continent: string;',
+    '}',
+    '',
+    'export const geo: Record<string, GeoEntry> = ',
+    JSON.stringify(sortedGeo, null, 2) + ';'
   ].join('\n');
-  fs.writeFileSync(path.join(dir, 'geo.ts'), geoTs + '\n');
+  const formattedGeo = await prettier.format(geoTs, {
+    ...prettierConfig,
+    parser: 'typescript'
+  });
+  fs.writeFileSync(path.join(dir, 'geo.ts'), formattedGeo);
 
-  console.log(`✅ Mappings: ${sortedCodes.length} timezones, ${Object.keys(sortedGeo).length} geo entries`);
+  console.log(
+    `✅ Mappings: ${sortedCodes.length} timezones, ${Object.keys(sortedGeo).length} geo entries`
+  );
 }
-
-generateMapping().catch(err => {
-  console.error(err);
-  process.exit(1);
-});

package/src/converter.ts

@@ -1,84 +1,91 @@
-import { parseISO } from 'date-fns';
 import { TZDate } from '@date-fns/tz';
 import { timezones } from './mapping/timezones';
-import {
-  UnknownAirportError,
-  InvalidTimestampError,
-  UnknownTimezoneError
-} from './errors';
+import { UnknownAirportError, InvalidTimestampError, UnknownTimezoneError } from './errors';
 
 const ISO_LOCAL_RE = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})(?::(\d{2}))?$/;
 
-function parseLocalIso(
-    localIso: string
-): [number, number, number, number, number, number] {
-  const m = ISO_LOCAL_RE.exec(localIso);
-  if (!m) throw new InvalidTimestampError(localIso);
-  const [, Y, Mo, D, h, mi, s] = m;
-  return [
-    Number(Y),
-    Number(Mo) - 1,
-    Number(D),
-    Number(h),
-    Number(mi),
-    s ? Number(s) : 0
-  ];
-}
+type LocalDateTimeParts = [number, number, number, number, number, number];
 
-/**
- * Convert a local ISO‐8601 string at an airport (IATA) into a UTC ISO string.
- * Always emits "YYYY-MM-DDTHH:mm:ssZ" (no milliseconds).
- */
-export function convertToUTC(localIso: string, iata: string): string {
-  const tz = timezones[iata];
-  if (!tz) throw new UnknownAirportError(iata);
+const VALID_TIMEZONE_CACHE = new Map<string, boolean>();
+
+function isLeapYear(year: number): boolean {
+  return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
+}
 
-  // Quick semantic check
-  const base = parseISO(localIso);
-  if (isNaN(base.getTime())) throw new InvalidTimestampError(localIso);
+function daysInMonth(year: number, month: number): number {
+  if (month === 1) return isLeapYear(year) ? 29 : 28;
+  if (month === 3 || month === 5 || month === 8 || month === 10) return 30;
+  return 31;
+}
 
-  const [year, month, day, hour, minute, second] = parseLocalIso(localIso);
+function parseLocalIsoStrict(localIso: string): LocalDateTimeParts {
+  const m = ISO_LOCAL_RE.exec(localIso);
+  if (!m) throw new InvalidTimestampError(localIso);
+  const [, Y, Mo, D, h, mi, s] = m;
+  const year = Number(Y);
+  const month = Number(Mo) - 1;
+  const day = Number(D);
+  const hour = Number(h);
+  const minute = Number(mi);
+  const second = s ? Number(s) : 0;
 
-  let zoned: TZDate;
-  try {
-    zoned = TZDate.tz(tz, year, month, day, hour, minute, second);
-  } catch {
-    throw new InvalidTimestampError(localIso);
-  }
-  if (isNaN(zoned.getTime())) throw new InvalidTimestampError(localIso);
+  if (month < 0 || month > 11) throw new InvalidTimestampError(localIso);
+  if (day < 1 || day > daysInMonth(year, month)) throw new InvalidTimestampError(localIso);
+  if (hour < 0 || hour > 23) throw new InvalidTimestampError(localIso);
+  if (minute < 0 || minute > 59) throw new InvalidTimestampError(localIso);
+  if (second < 0 || second > 59) throw new InvalidTimestampError(localIso);
 
-  // Strip ".000" from the ISO string
-  return new Date(zoned.getTime()).toISOString().replace('.000Z', 'Z');
+  return [year, month, day, hour, minute, second];
 }
 
-/**
- * Convert a local ISO‐8601 string in any IANA timezone into a UTC ISO string.
- * Always emits "YYYY-MM-DDTHH:mm:ssZ" (no milliseconds).
- */
-export function convertLocalToUTCByZone(
-    localIso: string,
-    timeZone: string
-): string {
-  // Validate timezone
+function assertValidTimezone(timeZone: string): void {
+  const cached = VALID_TIMEZONE_CACHE.get(timeZone);
+  if (cached === true) return;
+  if (cached === false) throw new UnknownTimezoneError(timeZone);
   try {
     new Intl.DateTimeFormat('en-US', { timeZone }).format();
+    VALID_TIMEZONE_CACHE.set(timeZone, true);
   } catch {
+    VALID_TIMEZONE_CACHE.set(timeZone, false);
     throw new UnknownTimezoneError(timeZone);
   }
+}
 
-  // Quick semantic check
-  const base = parseISO(localIso);
-  if (isNaN(base.getTime())) throw new InvalidTimestampError(localIso);
-
-  const [year, month, day, hour, minute, second] = parseLocalIso(localIso);
+function toUtcIso(
+  localIso: string,
+  timeZone: string,
+  onTimeZoneError: (err: unknown) => Error
+): string {
+  const [year, month, day, hour, minute, second] = parseLocalIsoStrict(localIso);
 
   let zoned: TZDate;
   try {
     zoned = TZDate.tz(timeZone, year, month, day, hour, minute, second);
-  } catch {
-    throw new UnknownTimezoneError(timeZone);
+  } catch (err) {
+    throw onTimeZoneError(err);
   }
   if (isNaN(zoned.getTime())) throw new InvalidTimestampError(localIso);
 
+  // Strip ".000" from the ISO string
   return new Date(zoned.getTime()).toISOString().replace('.000Z', 'Z');
 }
+
+/**
+ * Convert a local ISO‐8601 string at an airport (IATA) into a UTC ISO string.
+ * Always emits "YYYY-MM-DDTHH:mm:ssZ" (no milliseconds).
+ */
+export function convertToUTC(localIso: string, iata: string): string {
+  const tz = timezones[iata];
+  if (!tz) throw new UnknownAirportError(iata);
+
+  return toUtcIso(localIso, tz, () => new InvalidTimestampError(localIso));
+}
+
+/**
+ * Convert a local ISO‐8601 string in any IANA timezone into a UTC ISO string.
+ * Always emits "YYYY-MM-DDTHH:mm:ssZ" (no milliseconds).
+ */
+export function convertLocalToUTCByZone(localIso: string, timeZone: string): string {
+  assertValidTimezone(timeZone);
+  return toUtcIso(localIso, timeZone, () => new UnknownTimezoneError(timeZone));
+}

package/src/errors.ts

@@ -15,4 +15,4 @@ export class UnknownTimezoneError extends Error {
     super(`Unknown timezone: ${tz}`);
     this.name = 'UnknownTimezoneError';
   }
-}
+}

package/src/index.ts

@@ -1,3 +1,3 @@
 export { convertToUTC, convertLocalToUTCByZone } from './converter';
-export { getAirportInfo, AirportInfo } from './info';
-export { UnknownAirportError, InvalidTimestampError, UnknownTimezoneError } from './errors';
+export { getAirportInfo, getAllAirports, AirportInfo, Airport } from './info';
+export { UnknownAirportError, InvalidTimestampError, UnknownTimezoneError } from './errors';

package/src/info.ts

@@ -1,5 +1,5 @@
 import { timezones } from './mapping/timezones';
-import { geo, GeoEntry } from './mapping/geo';
+import { geo } from './mapping/geo';
 import { UnknownAirportError } from './errors';
 
 export interface AirportInfo {
@@ -9,6 +9,8 @@ export interface AirportInfo {
   name: string;
   city: string;
   country: string;
+  countryName: string;
+  continent: string;
 }
 
 /** @throws UnknownAirportError */
@@ -17,4 +19,19 @@ export function getAirportInfo(iata: string): AirportInfo {
   const g = geo[iata];
   if (!tz || !g) throw new UnknownAirportError(iata);
   return { timezone: tz, ...g };
-}
+}
+
+export interface Airport extends AirportInfo {
+  iata: string;
+}
+
+export function getAllAirports(): Airport[] {
+  const all: Airport[] = [];
+  for (const iata of Object.keys(geo)) {
+    const tz = timezones[iata];
+    const g = geo[iata];
+    if (!tz || !g) continue;
+    all.push({ iata, timezone: tz, ...g });
+  }
+  return all;
+}