@dylmye/flight-designator
Version:
Parse and construct flight designators - now with TypeScript
120 lines • 4.31 kB
JavaScript
"use strict";
var _a;
Object.defineProperty(exports, "__esModule", { value: true });
/** Validator object for Flight Designators */
class FlightDesignator {
constructor(airline, number, suffix) {
this.isValid = () => {
return (!!this.airlineCode &&
this.flightNumber !== undefined &&
!Number.isNaN(this.flightNumber) &&
FlightDesignator.isValidAirlineCode(this.airlineCode) &&
FlightDesignator.isValidFlightNumber(this.flightNumber.toString()) &&
FlightDesignator.isValidSuffix(this.operationalSuffix));
};
this.parse = (value) => {
const parts = (value + "").match(FlightDesignator.pattern);
if (parts == null || !FlightDesignator.isValidFlightNumber(parts[2]))
throw new Error('Invalid flight designator "' + value + '"');
this.operationalSuffix = parts.pop();
this.flightNumber = parseInt(parts.pop(), 10);
this.airlineCode = parts.pop();
return this;
};
this.toString = (spaces = false, pad = false) => {
if (!this.flightNumber || !this.airlineCode) {
return "";
}
var parts = [
this.airlineCode.toUpperCase(),
pad ? zeroPad(this.flightNumber.toString()) : this.flightNumber,
];
if (this.operationalSuffix) {
parts.push(this.operationalSuffix.toUpperCase());
}
return parts.join(spaces ? " " : "");
};
if (!(this instanceof FlightDesignator))
return new FlightDesignator(airline, number, suffix);
this.airlineCode = airline;
this.flightNumber = number ? parseInt(number, 10) : undefined;
this.operationalSuffix = suffix || "";
}
}
exports.default = FlightDesignator;
_a = FlightDesignator;
/**
* Flight designator pattern (IATA/ICAO)
* NOTE: This pattern DOES NOT validate the flight number
* (i.e. it does match invalid '0000' flight numbers)
*
* @static
* @readonly
*/
FlightDesignator.pattern = /^([A-Z0-9]{2}[A-Z]?)\s*([0-9]{1,4})\s*([A-Z]?)$/i;
/** IATA/ICAO airline code pattern
* @static
* @readonly
*/
FlightDesignator.airlinePattern = /^([A-Z0-9]{2}[A-Z]?)$/i;
/**
* Flight number pattern
* NOTE: This regular expression checks for two things
* by utilizing a lookahead: The first group checks (via the lookahead)
* if the number is non-zero, the second whether it is between 1-4 chars long
*
* @static
* @readonly
*/
FlightDesignator.flightPattern = /(?=^0*[1-9][0-9]*\s*[A-Z]?$)(?:^([0-9]{1,4})\s*([A-Z]?)$)/;
/** Operational suffix test pattern
* @static
* @readonly
*/
FlightDesignator.suffixPattern = /^[A-Z]$/i;
/** Determine whether the input is a valid flight designator
* @static
*/
FlightDesignator.isValid = (designator) => {
const parts = (designator + "").match(FlightDesignator.pattern);
return parts != null && FlightDesignator.isValidFlightNumber(parts[2]);
};
/** Determines whether the input is a valid airline code
* @static
*/
FlightDesignator.isValidAirlineCode = (airlineCode) => _a.airlinePattern.test(airlineCode);
/** Determines whether the input is a valid flight number
* @static
*/
FlightDesignator.isValidFlightNumber = (flightNumber) => _a.flightPattern.test(flightNumber);
/** Determine whether the input is a valid operational suffix
* @static
*/
FlightDesignator.isValidSuffix = (suffix) => {
return suffix == null || suffix === ""
? true
: _a.suffixPattern.test(suffix);
};
/** Parses a flight designator
* @static
*/
FlightDesignator.parse = (value) => {
try {
return new FlightDesignator().parse(value);
}
catch (e) {
return null;
}
};
/** Parses and formats a flight designator */
FlightDesignator.format = (value, spaces = false, pad = false) => {
var _b;
return (_b = _a.parse(value)) === null || _b === void 0 ? void 0 : _b.toString(spaces, pad);
};
function zeroPad(str) {
str = str + "";
while (str.length < 4)
str = "0" + str;
return str;
}
//# sourceMappingURL=flight-designator.js.map