metar-taf-parser 0.0.1 → 0.0.2

package/dist/parser/parser.js

@@ -0,0 +1,322 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    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;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemarkParser = 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"));
+const helpers_1 = require("../helpers/helpers");
+const common_1 = require("../command/common");
+const enum_1 = require("../model/enum");
+const metar_1 = require("../command/metar");
+const errors_1 = require("../commons/errors");
+/**
+ * Parses the delivery time of a METAR/TAF
+ * @param abstractWeatherCode The TAF or METAR object
+ * @param timeString The string representing the delivery time
+ */
+function parseDeliveryTime(timeString) {
+    return {
+        day: +timeString.slice(0, 2),
+        hour: +timeString.slice(2, 4),
+        minute: +timeString.slice(4, 6),
+    };
+    // TODO
+    // abstractWeatherCode.time = new Date()
+}
+/**
+ * This function parses the array containing the remark and concat the array into a string
+ * @param container the metar, taf or taf trend to update
+ * @param line The array containing the current line tokens
+ * @param index the index starting the remark ie token RMK
+ */
+function parseRemark(container, line, index, locale) {
+    const remarks = new RemarkParser(locale).parse(line.slice(index + 1).join(" "));
+    container.remarks = remarks;
+    container.remark = remarks.join(" ");
+}
+/**
+ * Parses the temperature in a TAF
+ * @param input the string containing the temperature
+ * @returns TemperatureDated object
+ */
+function parseTemperature(input) {
+    const parts = (0, helpers_1.pySplit)(input, "/");
+    return {
+        temperature: converter.convertTemperature(parts[0].slice(2)),
+        day: +parts[1].slice(0, 2),
+        hour: +parts[1].slice(2, 4),
+    };
+}
+exports.parseTemperature = parseTemperature;
+/**
+ * Parses validity of a TAF or a TAFTrend
+ * @param input the string containing the validity
+ * @returns Validity object
+ */
+function parseValidity(input) {
+    const parts = (0, helpers_1.pySplit)(input, "/");
+    return {
+        startDay: +parts[0].slice(0, 2),
+        startHour: +parts[0].slice(2),
+        endDay: +parts[1].slice(0, 2),
+        endHour: +parts[1].slice(2),
+    };
+}
+exports.parseValidity = parseValidity;
+/**
+ * Parses the validity for a FROM taf trend
+ * @param input the string containing the validity
+ * @returns a Validity object
+ */
+function parseFromValidity(input) {
+    return {
+        startDay: +input.slice(2, 4),
+        startHour: +input.slice(4, 6),
+        startMinutes: +input.slice(6, 8),
+    };
+}
+/**
+ * Abstract class.
+ * Base parser.
+ */
+class AbstractParser {
+    constructor() {
+        this.FM = "FM";
+        this.TEMPO = "TEMPO";
+        this.BECMG = "BECMG";
+        this.RMK = "RMK";
+        // Safari does not currently support negative lookbehind
+        // #TOKENIZE_REGEX = /\s((?=\d\/\dSM)(?<!\s\d\s)|(?!\d\/\dSM))|=/;
+        _AbstractParser_INTENSITY_REGEX.set(this, /^(-|\+|VC)/);
+        _AbstractParser_CAVOK.set(this, "CAVOK");
+        _AbstractParser_commonSupplier.set(this, new common_1.CommandSupplier());
+    }
+    parseWeatherCondition(input) {
+        var _a;
+        let intensity;
+        if (input.match(__classPrivateFieldGet(this, _AbstractParser_INTENSITY_REGEX, "f"))) {
+            const match = (_a = input.match(__classPrivateFieldGet(this, _AbstractParser_INTENSITY_REGEX, "f"))) === null || _a === void 0 ? void 0 : _a[0];
+            if (match)
+                intensity = match;
+        }
+        let descriptive;
+        for (const key of Object.values(enum_1.Descriptive)) {
+            if (input.includes(key))
+                descriptive = key;
+        }
+        const weatherCondition = {
+            intensity,
+            descriptive,
+            phenomenons: [],
+        };
+        for (const key of Object.values(enum_1.Phenomenon)) {
+            if (input.includes(key))
+                weatherCondition.phenomenons.push(key);
+        }
+        return weatherCondition;
+    }
+    /**
+     * Parses the message into different tokens
+     * @param input The metar or TAF as string
+     * @returns List of tokens
+     */
+    tokenize(input) {
+        // Missing safari support. If added in the future, put this back
+        // return input.split(this.#TOKENIZE_REGEX).filter((v) => v);
+        // Hack for safari below...
+        const splitRegex = /\s|=/;
+        const smRegex = /^\d\/\dSM$/;
+        const digitRegex = /^\d$/;
+        // return input.split(this.#TOKENIZE_REGEX).filter((v) => v);
+        const splitted = input.split(splitRegex);
+        for (let i = 0; i < splitted.length; i++) {
+            if (digitRegex.test(splitted[i])) {
+                if (splitted[i + 1] && smRegex.test(splitted[i + 1])) {
+                    splitted.splice(i, 2, `${splitted[i]} ${splitted[i + 1]}`);
+                    i--;
+                }
+            }
+        }
+        return splitted.filter((t) => t);
+    }
+    /**
+     * Common parse method for METAR, TAF and trends object
+     * @param abstractWeatherCode the object to update
+     * @param input The token to parse
+     * @returns True if the token was parsed false otherwise
+     */
+    generalParse(abstractWeatherContainer, input) {
+        if (input === __classPrivateFieldGet(this, _AbstractParser_CAVOK, "f")) {
+            abstractWeatherContainer.cavok = true;
+            const distance = "> 10km";
+            if (!abstractWeatherContainer.visibility)
+                abstractWeatherContainer.visibility = {
+                    distance,
+                };
+            abstractWeatherContainer.visibility.distance = distance;
+            return true;
+        }
+        const command = __classPrivateFieldGet(this, _AbstractParser_commonSupplier, "f").get(input);
+        if (command) {
+            return command.execute(abstractWeatherContainer, input);
+        }
+        const weatherCondition = this.parseWeatherCondition(input);
+        if ((0, model_1.isWeatherConditionValid)(weatherCondition)) {
+            abstractWeatherContainer.weatherConditions.push(weatherCondition);
+            return true;
+        }
+        return false;
+    }
+}
+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;
+        this.AT = "AT";
+        this.TL = "TL";
+        _MetarParser_commandSupplier.set(this, new metar_1.CommandSupplier());
+    }
+    /**
+     * Parses a trend of a metar
+     * @param index the index starting the trend in the list
+     * @param trend The trend to update
+     * @param trendParts array of tokens
+     * @returns the last index of the token that was last parsed
+     */
+    parseTrend(index, trend, trendParts) {
+        let i = index + 1;
+        while (i < trendParts.length &&
+            trendParts[i] !== this.TEMPO &&
+            trendParts[i] !== this.BECMG) {
+            if (trendParts[i].startsWith(this.FM) ||
+                trendParts[i].startsWith(this.TL) ||
+                trendParts[i].startsWith(this.AT)) {
+                const trendTime = {
+                    type: enum_1.TimeIndicator[trendParts[i].slice(0, 2)],
+                    // TODO implement time
+                    hour: +trendParts[i].slice(2, 4),
+                    minute: +trendParts[i].slice(4, 6),
+                };
+                trend.times.push(trendTime);
+            }
+            else {
+                this.generalParse(trend, trendParts[i]);
+            }
+            i = i + 1;
+        }
+        return i - 1;
+    }
+    /**
+     * Parses an message and returns a METAR
+     * @param input The message to parse
+     * @returns METAR
+     */
+    parse(input) {
+        const metarTab = this.tokenize(input);
+        const metar = Object.assign(Object.assign({}, parseDeliveryTime(metarTab[1])), { station: metarTab[0], message: input, 
+            // wind: IWind,
+            // visibility?: Visibility,
+            // verticalVisibility: number,
+            // windShear: IWindShear,
+            cavok: false, remark: "", remarks: [], clouds: [], weatherConditions: [], 
+            // airport: IAirport,
+            trends: [], 
+            // temperature: number,
+            // dewPoint: number,
+            // altimeter: number,
+            nosig: false, auto: false, runwaysInfo: [] }); // TODO remove cast
+        let index = 2;
+        while (index < metarTab.length) {
+            if (!super.generalParse(metar, metarTab[index])) {
+                if (metarTab[index] === "NOSIG") {
+                    metar.nosig = true;
+                }
+                else if (metarTab[index] === "AUTO") {
+                    metar.auto = true;
+                }
+                else if (metarTab[index] === this.TEMPO ||
+                    metarTab[index] === this.BECMG) {
+                    const trend = {
+                        type: enum_1.WeatherChangeType[metarTab[index]],
+                        weatherConditions: [],
+                        clouds: [],
+                        times: [],
+                    };
+                    // TODO - remove casting
+                    index = this.parseTrend(index, trend, metarTab);
+                    metar.trends.push(trend);
+                }
+                else if (metarTab[index] === this.RMK) {
+                    parseRemark(metar, metarTab, index, this.locale);
+                    break;
+                }
+                else {
+                    const command = __classPrivateFieldGet(this, _MetarParser_commandSupplier, "f").get(metarTab[index]);
+                    if (command)
+                        command.execute(metar, metarTab[index]);
+                }
+            }
+            index = index + 1;
+        }
+        return metar;
+    }
+}
+exports.MetarParser = MetarParser;
+_MetarParser_commandSupplier = new WeakMap();
+class RemarkParser {
+    constructor(locale) {
+        this.locale = locale;
+        _RemarkParser_supplier.set(this, new remark_1.RemarkCommandSupplier(this.locale));
+    }
+    parse(code) {
+        let rmkStr = code;
+        let rmkList = [];
+        while (rmkStr) {
+            try {
+                [rmkStr, rmkList] = __classPrivateFieldGet(this, _RemarkParser_supplier, "f").get(rmkStr).execute(rmkStr, rmkList);
+            }
+            catch (e) {
+                if (e instanceof errors_1.TranslationError) {
+                    [rmkStr, rmkList] = __classPrivateFieldGet(this, _RemarkParser_supplier, "f").defaultCommand.execute(rmkStr, rmkList);
+                }
+                else {
+                    throw e;
+                }
+            }
+        }
+        return rmkList;
+    }
+}
+exports.RemarkParser = RemarkParser;
+_RemarkParser_supplier = new WeakMap();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metar-taf-parser",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "Parse METAR and TAF files",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -11,7 +11,7 @@
     "url": "https://github.com/aeharding/metar-taf-parser.git"
   },
   "scripts": {
-    "build": "yarn clean; tsc",
+    "build": "yarn clean; tsc && tsc-alias",
     "clean": "rm -rf ./dist",
     "start": "node --experimental-specifier-resolution=node --loader ts-node/esm lib",
     "check-types": "tsc --noEmit",
@@ -30,13 +30,18 @@
     "@babel/preset-typescript": "^7.16.7",
     "@types/fs-extra": "^9.0.12",
     "@types/jest": "^27.4.1",
+    "@types/lodash": "^4.14.181",
     "fs-extra": "^10.0.0",
     "jest": "^27.5.1",
     "prettier": "^2.6.2",
     "ts-jest": "^27.1.4",
     "ts-node": "^10.2.1",
+    "tsc-alias": "^1.6.6",
     "typescript": "^4.4.2",
     "watch": "^1.0.2"
   },
-  "dependencies": {}
+  "dependencies": {
+    "lodash": "^4.17.21",
+    "po2json": "^0.4.5"
+  }
 }

package/dist/lib/commons/i18n.d.ts

@@ -1,3 +0,0 @@
-import messages from "locale/en.json";
-export default messages;
-export declare function format(message: string, ...args: unknown[]): string;

package/dist/lib/helpers/helpers.js

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.findAll = exports.pySplit = void 0;
-/**
- * Split behaving similar to Python's implementation
- */
-function pySplit(string, separator, n) {
-    const split = string.split(separator);
-    if (n == null || split.length <= n)
-        return split;
-    const out = split.slice(0, n);
-    out.push(split.slice(n).join(separator));
-    return out;
-}
-exports.pySplit = pySplit;
-function findAll(regex, str) {
-    const hits = [];
-    // Iterate hits
-    let match = null;
-    do {
-        match = regex.exec(str);
-        if (match) {
-            hits.push(match[0]);
-        }
-    } while (match);
-    return hits;
-}
-exports.findAll = findAll;

package/dist/lib/index.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/lib/index.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-// i18n();