metar-taf-parser 0.0.2 → 1.0.0

package/dist/command/common.js

@@ -135,6 +135,8 @@ class WindVariationCommand {
         wind.maxVariation = +matches[2];
     }
     execute(container, windString) {
+        if (!container.wind)
+            throw new errors_1.InvalidWeatherStatementError();
         this.parseWindVariation(container.wind, windString);
         return true;
     }

package/dist/command/remark.js

@@ -158,7 +158,7 @@ class HourlyPressureCommand extends Command {
         const matches = code.match(__classPrivateFieldGet(this, _HourlyPressureCommand_regex, "f"));
         if (!matches)
             throw new errors_1.UnexpectedParseError("Match not found");
-        remark.push(`${(0, i18n_1._)(`Remark.Barometer.${+matches[1]}`, this.locale)} ${(0, i18n_1.format)((0, i18n_1._)("Remark.Pressure.Tendency", this.locale), +matches[1])}`);
+        remark.push(`${(0, i18n_1._)(`Remark.Barometer.${+matches[1]}`, this.locale)} ${(0, i18n_1.format)((0, i18n_1._)("Remark.Pressure.Tendency", this.locale), +matches[2] / 10)}`);
         return [code.replace(__classPrivateFieldGet(this, _HourlyPressureCommand_regex, "f"), "").trim(), remark];
     }
 }

package/dist/commons/converter.d.ts

@@ -2,5 +2,8 @@ export declare function degreesToCardinal(input: number | string): string;
 export declare function convertVisibility(input: string): string;
 export declare function convertTemperature(input: string): number;
 export declare function convertInchesMercuryToPascal(input: number): number;
-export declare function convertTemperatureRemarks(sign: string, temperature: string): number;
+/**
+ * Converts number `.toFixed(1)` before outputting to match python implementation
+ */
+export declare function convertTemperatureRemarks(sign: string, temperature: string): string;
 export declare function convertPrecipitationAmount(amount: string): number;

package/dist/commons/converter.js

@@ -44,11 +44,14 @@ function convertInchesMercuryToPascal(input) {
     return 33.8639 * input;
 }
 exports.convertInchesMercuryToPascal = convertInchesMercuryToPascal;
+/**
+ * Converts number `.toFixed(1)` before outputting to match python implementation
+ */
 function convertTemperatureRemarks(sign, temperature) {
     const temp = +temperature / 10;
     if (sign === "0")
-        return temp;
-    return -temp;
+        return temp.toFixed(1);
+    return (-temp).toFixed(1);
 }
 exports.convertTemperatureRemarks = convertTemperatureRemarks;
 function convertPrecipitationAmount(amount) {

package/dist/index.d.ts

@@ -1,10 +1,11 @@
-import { IMetar } from "./model/model";
+import { IMetar, ITAF } from "./model/model";
 import { Locale } from "./commons/i18n";
-export interface IMetarTAFParserOptions {
-    locale?: Locale;
-}
-export declare function parseMetar(metar: string, options: IMetarTAFParserOptions): IMetar;
 export { Locale } from "./commons/i18n";
 export * from "./commons/errors";
 export * from "./model/model";
 export * from "./model/enum";
+export interface IMetarTAFParserOptions {
+    locale?: Locale;
+}
+export declare function parseMetar(metar: string, options?: IMetarTAFParserOptions): IMetar;
+export declare function parseTAF(taf: string, options?: IMetarTAFParserOptions): ITAF;

package/dist/index.js

@@ -17,14 +17,25 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseMetar = void 0;
+exports.parseTAF = exports.parseMetar = void 0;
 const parser_1 = require("./parser/parser");
 const errors_1 = require("./commons/errors");
 const en_1 = __importDefault(require("./locale/en"));
+__exportStar(require("./commons/errors"), exports);
+__exportStar(require("./model/model"), exports);
+__exportStar(require("./model/enum"), exports);
 function parseMetar(metar, options) {
+    return parse(metar, options, parser_1.MetarParser);
+}
+exports.parseMetar = parseMetar;
+function parseTAF(taf, options) {
+    return parse(taf, options, parser_1.TAFParser);
+}
+exports.parseTAF = parseTAF;
+function parse(report, options, parser) {
     const lang = (options === null || options === void 0 ? void 0 : options.locale) || en_1.default;
     try {
-        return new parser_1.MetarParser(lang).parse(metar);
+        return new parser(lang).parse(report);
     }
     catch (e) {
         if (e instanceof errors_1.ParseError)
@@ -32,7 +43,3 @@ function parseMetar(metar, options) {
         throw new errors_1.InvalidWeatherStatementError(e);
     }
 }
-exports.parseMetar = parseMetar;
-__exportStar(require("./commons/errors"), exports);
-__exportStar(require("./model/model"), exports);
-__exportStar(require("./model/enum"), exports);

package/dist/model/model.d.ts

@@ -55,12 +55,12 @@ export interface ICloud {
     type?: CloudType;
 }
 export interface IAbstractWeatherContainer {
-    wind: IWind;
+    wind?: IWind;
     visibility?: Visibility;
-    verticalVisibility: number;
-    windShear: IWindShear;
-    cavok: boolean;
-    remark: string;
+    verticalVisibility?: number;
+    windShear?: IWindShear;
+    cavok?: boolean;
+    remark?: string;
     remarks: string[];
     clouds: ICloud[];
     weatherConditions: IWeatherCondition[];
@@ -78,7 +78,7 @@ export interface ITime {
 }
 export interface IAbstractWeatherCode extends IAbstractWeatherContainer, ITime {
     day: number;
-    airport: IAirport;
+    airport?: IAirport;
     message: string;
     station: string;
     trends: IAbstractTrend[];
@@ -93,10 +93,10 @@ export interface IMetar extends IAbstractWeatherCode {
     trends: IMetarTrend[];
 }
 export interface ITAF extends IAbstractWeatherCode {
-    validity: IAbstractValidity;
-    maxTemperature: number;
-    minTemperature: number;
-    amendment: boolean;
+    validity: IValidity;
+    maxTemperature?: ITemperatureDated;
+    minTemperature?: ITemperatureDated;
+    amendment?: boolean;
     trends: ITAFTrend[];
 }
 export interface IAbstractTrend extends IAbstractWeatherContainer {
@@ -109,13 +109,15 @@ export interface IMetarTrend extends IAbstractTrend {
     times: IMetarTrendTime[];
 }
 export interface ITAFTrend extends IAbstractTrend {
-    probability: number;
-    validity: IAbstractValidity;
+    probability?: number;
+    validity?: IFMValidity;
 }
-export interface IValidity extends IAbstractValidity {
+export interface IEndValidity {
     endHour: number;
     endDay: number;
 }
-export interface IFMValidity extends IAbstractValidity {
-    startMinutes: number;
+export interface IValidity extends IAbstractValidity, IEndValidity {
+}
+export interface IFMValidity extends IAbstractValidity, Partial<IEndValidity> {
+    startMinutes?: number;
 }

package/dist/parser/parser.d.ts

@@ -1,4 +1,5 @@
-import { IAbstractWeatherContainer, IMetar, IMetarTrend, ITemperatureDated, IValidity, IWeatherCondition } from "../model/model";
+import { IAbstractWeatherContainer, IMetar, IMetarTrend, ITAF, ITAFTrend, ITemperatureDated, IValidity, IWeatherCondition } from "../model/model";
+import { WeatherChangeType } from "../model/enum";
 import { Locale } from "../commons/i18n";
 /**
  * Parses the temperature in a TAF
@@ -18,10 +19,12 @@ export declare function parseValidity(input: string): IValidity;
  */
 export declare abstract class AbstractParser {
     #private;
+    protected locale: Locale;
     FM: string;
     TEMPO: string;
     BECMG: string;
     RMK: string;
+    constructor(locale: Locale);
     parseWeatherCondition(input: string): IWeatherCondition;
     /**
      * Parses the message into different tokens
@@ -39,10 +42,8 @@ export declare abstract class AbstractParser {
 }
 export declare class MetarParser extends AbstractParser {
     #private;
-    private locale;
     AT: string;
     TL: string;
-    constructor(locale: Locale);
     /**
      * Parses a trend of a metar
      * @param index the index starting the trend in the list
@@ -58,6 +59,43 @@ export declare class MetarParser extends AbstractParser {
      */
     parse(input: string): IMetar;
 }
+/**
+ * Parser for TAF messages
+ */
+export declare class TAFParser extends AbstractParser {
+    #private;
+    TAF: string;
+    PROB: string;
+    TX: string;
+    TN: string;
+    /**
+     * the message to parse
+     * @param input
+     * @returns a TAF object
+     * @throws ParseError if the message is invalid
+     */
+    parse(input: string): ITAF;
+    /**
+     * Format the message as a multiple line code so each line can be parsed
+     * @param tafCode The base message
+     * @returns a list of string representing the lines of the message
+     */
+    extractLinesTokens(tafCode: string): string[][];
+    /**
+     * Parses the tokens of the line and updates the TAF object
+     * @param taf TAF object to update
+     * @param lineTokens the array of tokens representing a line
+     */
+    parseLine(taf: ITAF, lineTokens: string[]): void;
+    /**
+     * Parses a trend of the TAF
+     * @param index the index at which the array should be parsed
+     * @param line The array of string containing the line
+     * @param trend The trend object to update
+     */
+    parseTrend(index: number, line: string[], trend: ITAFTrend): void;
+    makeEmptyTAFTrend(type: WeatherChangeType): ITAFTrend;
+}
 export declare class RemarkParser {
     #private;
     private locale;

package/dist/parser/parser.js

@@ -27,9 +27,9 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _AbstractParser_INTENSITY_REGEX, _AbstractParser_CAVOK, _AbstractParser_commonSupplier, _MetarParser_commandSupplier, _RemarkParser_supplier;
+var _AbstractParser_INTENSITY_REGEX, _AbstractParser_CAVOK, _AbstractParser_commonSupplier, _MetarParser_commandSupplier, _TAFParser_validityPattern, _RemarkParser_supplier;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RemarkParser = exports.MetarParser = exports.AbstractParser = exports.parseValidity = exports.parseTemperature = void 0;
+exports.RemarkParser = exports.TAFParser = exports.MetarParser = exports.AbstractParser = exports.parseValidity = exports.parseTemperature = void 0;
 const remark_1 = require("../command/remark");
 const model_1 = require("../model/model");
 const converter = __importStar(require("../commons/converter"));
@@ -109,7 +109,8 @@ function parseFromValidity(input) {
  * Base parser.
  */
 class AbstractParser {
-    constructor() {
+    constructor(locale) {
+        this.locale = locale;
         this.FM = "FM";
         this.TEMPO = "TEMPO";
         this.BECMG = "BECMG";
@@ -200,9 +201,8 @@ class AbstractParser {
 exports.AbstractParser = AbstractParser;
 _AbstractParser_INTENSITY_REGEX = new WeakMap(), _AbstractParser_CAVOK = new WeakMap(), _AbstractParser_commonSupplier = new WeakMap();
 class MetarParser extends AbstractParser {
-    constructor(locale) {
-        super();
-        this.locale = locale;
+    constructor() {
+        super(...arguments);
         this.AT = "AT";
         this.TL = "TL";
         _MetarParser_commandSupplier.set(this, new metar_1.CommandSupplier());
@@ -294,6 +294,144 @@ class MetarParser extends AbstractParser {
 }
 exports.MetarParser = MetarParser;
 _MetarParser_commandSupplier = new WeakMap();
+/**
+ * Parser for TAF messages
+ */
+class TAFParser extends AbstractParser {
+    constructor() {
+        super(...arguments);
+        this.TAF = "TAF";
+        this.PROB = "PROB";
+        this.TX = "TX";
+        this.TN = "TN";
+        _TAFParser_validityPattern.set(this, /^\d{4}\/\d{4}$/);
+    }
+    /**
+     * the message to parse
+     * @param input
+     * @returns a TAF object
+     * @throws ParseError if the message is invalid
+     */
+    parse(input) {
+        let amendment;
+        const lines = this.extractLinesTokens(input);
+        if (lines[0][0] !== this.TAF)
+            throw new errors_1.InvalidWeatherStatementError('TAF report must begin with string "TAF"');
+        let index = 1;
+        if (lines[0][1] === this.TAF)
+            index = 2;
+        if (lines[0][index] === "AMD") {
+            amendment = true;
+            index += 1;
+        }
+        const station = lines[0][index];
+        index += 1;
+        const time = parseDeliveryTime(lines[0][index]);
+        index += 1;
+        const validity = parseValidity(lines[0][index]);
+        const taf = Object.assign(Object.assign({ station,
+            amendment }, time), { validity, message: input, trends: [], remarks: [], clouds: [], weatherConditions: [] });
+        for (let i = index + 1; i < lines[0].length; i++) {
+            const token = lines[0][i];
+            if (token == this.RMK)
+                parseRemark(taf, lines[0], i, this.locale);
+            else if (token.startsWith(this.TX))
+                taf.maxTemperature = parseTemperature(token);
+            else if (token.startsWith(this.TN))
+                taf.minTemperature = parseTemperature(token);
+            else
+                this.generalParse(taf, token);
+        }
+        // Handle the other lines
+        for (let i = 1; i < lines.length; i++) {
+            this.parseLine(taf, lines[i]);
+        }
+        return taf;
+    }
+    /**
+     * Format the message as a multiple line code so each line can be parsed
+     * @param tafCode The base message
+     * @returns a list of string representing the lines of the message
+     */
+    extractLinesTokens(tafCode) {
+        const singleLine = tafCode.replace(/\n/g, " ");
+        const cleanLine = singleLine.replace(/\s{2,}/g, " ");
+        const lines = joinProbIfNeeded(cleanLine
+            .replace(/\s(?=PROB\d{2}\sTEMPO|TEMPO|BECMG|FM|PROB)/g, "\n")
+            .split(/\n/));
+        // TODO cleanup
+        function joinProbIfNeeded(ls) {
+            for (let i = 0; i < ls.length; i++) {
+                if (/PROB\d{2}/.test(ls[i]) && /TEMPO/.test(ls[i + 1])) {
+                    ls.splice(i, 2, `${ls[i]} ${ls[i + 1]}`);
+                    i--;
+                }
+            }
+            return ls;
+        }
+        const linesToken = lines.map(this.tokenize);
+        if (linesToken.length > 1) {
+            const lastLine = linesToken[lines.length - 1];
+            const temperatures = lastLine.filter((l) => l.startsWith(this.TX) || l.startsWith(this.TN));
+            if (temperatures.length) {
+                linesToken[0] = linesToken[0].concat(temperatures);
+                linesToken[lines.length - 1] = lastLine.filter((l) => !l.startsWith(this.TX) && !l.startsWith(this.TN));
+            }
+        }
+        return linesToken;
+    }
+    /**
+     * Parses the tokens of the line and updates the TAF object
+     * @param taf TAF object to update
+     * @param lineTokens the array of tokens representing a line
+     */
+    parseLine(taf, lineTokens) {
+        let index = 1;
+        let trend;
+        if (lineTokens[0].startsWith(this.FM)) {
+            trend = Object.assign(Object.assign({}, this.makeEmptyTAFTrend(enum_1.WeatherChangeType.FM)), { validity: parseFromValidity(lineTokens[0]) });
+        }
+        else if (lineTokens[0].startsWith(this.PROB)) {
+            trend = this.makeEmptyTAFTrend(enum_1.WeatherChangeType.PROB);
+            if (lineTokens.length > 1 && lineTokens[1] === this.TEMPO) {
+                trend = this.makeEmptyTAFTrend(enum_1.WeatherChangeType[lineTokens[1]]);
+                index = 2;
+            }
+            trend.probability = +lineTokens[0].slice(4);
+        }
+        else {
+            trend = this.makeEmptyTAFTrend(enum_1.WeatherChangeType[lineTokens[0]]);
+        }
+        this.parseTrend(index, lineTokens, trend);
+        taf.trends.push(trend);
+    }
+    /**
+     * Parses a trend of the TAF
+     * @param index the index at which the array should be parsed
+     * @param line The array of string containing the line
+     * @param trend The trend object to update
+     */
+    parseTrend(index, line, trend) {
+        for (let i = index; i < line.length; i++) {
+            if (line[i] === this.RMK)
+                parseRemark(trend, line, i, this.locale);
+            else if (__classPrivateFieldGet(this, _TAFParser_validityPattern, "f").test(line[i]))
+                trend.validity = parseValidity(line[i]);
+            else
+                super.generalParse(trend, line[i]);
+        }
+    }
+    makeEmptyTAFTrend(type) {
+        return {
+            type,
+            remarks: [],
+            clouds: [],
+            weatherConditions: [],
+        };
+    }
+}
+exports.TAFParser = TAFParser;
+_TAFParser_validityPattern = new WeakMap();
 class RemarkParser {
     constructor(locale) {
         this.locale = locale;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metar-taf-parser",
-  "version": "0.0.2",
+  "version": "1.0.0",
   "description": "Parse METAR and TAF files",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -11,14 +11,14 @@
     "url": "https://github.com/aeharding/metar-taf-parser.git"
   },
   "scripts": {
-    "build": "yarn clean; tsc && tsc-alias",
+    "build": "yarn clean; tsc --project tsconfig.build.json && tsc-alias",
     "clean": "rm -rf ./dist",
     "start": "node --experimental-specifier-resolution=node --loader ts-node/esm lib",
     "check-types": "tsc --noEmit",
     "check-formatting": "prettier --check '**/*.{js,json,css,md,scss,tsx,ts}'",
     "watch": "watch 'yarn build' lib",
-    "test": "jest",
-    "test-watch": "jest --watch",
+    "test": "jest --coverage",
+    "test-watch": "jest --watch --coverage",
     "prepublishOnly": "yarn build"
   },
   "files": [