metar-taf-parser 3.1.2 → 4.0.2

package/dist/parser/parser.js

@@ -1,480 +0,0 @@
-"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, _TAFParser_validityPattern, _RemarkParser_supplier;
-Object.defineProperty(exports, "__esModule", { value: true });
-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 enum_1 = require("../model/enum");
-const converter = __importStar(require("../commons/converter"));
-const helpers_1 = require("../helpers/helpers");
-const common_1 = require("../command/common");
-const enum_2 = 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) {
-    const day = +timeString.slice(0, 2);
-    const hour = +timeString.slice(2, 4);
-    const minute = +timeString.slice(4, 6);
-    if (isNaN(day) || isNaN(hour) || isNaN(minute))
-        throw new errors_1.InvalidWeatherStatementError("Report time is invalid");
-    return {
-        day,
-        hour,
-        minute,
-    };
-}
-/**
- * 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
-        .map(({ description, raw }) => description || raw)
-        .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, date) {
-    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(locale) {
-        this.locale = locale;
-        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_2.Descriptive)) {
-            if (input.includes(key))
-                descriptive = key;
-        }
-        const weatherCondition = {
-            intensity,
-            descriptive,
-            phenomenons: [],
-        };
-        for (const key of Object.values(enum_2.Phenomenon)) {
-            // Thunderstorm as descriptive should not be added as a phenomenon
-            if (descriptive === key)
-                continue;
-            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 = /^(P|M)?\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;
-            abstractWeatherContainer.visibility = {
-                indicator: enum_1.ValueIndicator.GreaterThan,
-                value: 9999,
-                unit: enum_1.DistanceUnit.Meters,
-            };
-            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() {
-        super(...arguments);
-        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_2.TimeIndicator[trendParts[i].slice(0, 2)],
-                    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, remarks: [], clouds: [], weatherConditions: [], trends: [], runwaysInfo: [] });
-        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_2.WeatherChangeType[metarTab[index]],
-                        weatherConditions: [],
-                        clouds: [],
-                        times: [],
-                        remarks: [],
-                    };
-                    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();
-/**
- * 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);
-        let index = 0;
-        if (lines[0][0] === this.TAF)
-            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);
-                break;
-            }
-            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()), { type: enum_2.WeatherChangeType.FM, validity: parseFromValidity(lineTokens[0]) });
-        }
-        else if (lineTokens[0].startsWith(this.PROB)) {
-            const validity = this.findLineValidity(index, lineTokens);
-            if (!validity)
-                return;
-            trend = Object.assign(Object.assign({}, this.makeEmptyTAFTrend()), { type: enum_2.WeatherChangeType.PROB, validity });
-            if (lineTokens.length > 1 && lineTokens[1] === this.TEMPO) {
-                trend = Object.assign(Object.assign({}, this.makeEmptyTAFTrend()), { type: enum_2.WeatherChangeType[lineTokens[1]], validity });
-                index = 2;
-            }
-            trend.probability = +lineTokens[0].slice(4);
-        }
-        else {
-            const validity = this.findLineValidity(index, lineTokens);
-            if (!validity)
-                return;
-            trend = Object.assign(Object.assign({}, this.makeEmptyTAFTrend()), { type: enum_2.WeatherChangeType[lineTokens[0]], validity });
-        }
-        this.parseTrend(index, lineTokens, trend);
-        taf.trends.push(trend);
-    }
-    /**
-     * Finds a non-FM validity in a line
-     * @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
-     */
-    findLineValidity(index, line) {
-        let validity;
-        for (let i = index; i < line.length; i++) {
-            if (__classPrivateFieldGet(this, _TAFParser_validityPattern, "f").test(line[i]))
-                validity = parseValidity(line[i]);
-        }
-        return validity;
-    }
-    /**
-     * 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);
-                break;
-            }
-            // already parsed
-            else if (__classPrivateFieldGet(this, _TAFParser_validityPattern, "f").test(line[i]))
-                continue;
-            else
-                super.generalParse(trend, line[i]);
-        }
-    }
-    makeEmptyTAFTrend() {
-        return {
-            remarks: [],
-            clouds: [],
-            weatherConditions: [],
-        };
-    }
-}
-exports.TAFParser = TAFParser;
-_TAFParser_validityPattern = 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.CommandExecutionError) {
-                    [rmkStr, rmkList] = __classPrivateFieldGet(this, _RemarkParser_supplier, "f").defaultCommand.execute(rmkStr, rmkList);
-                }
-                else {
-                    throw e;
-                }
-            }
-        }
-        return rmkList;
-    }
-}
-exports.RemarkParser = RemarkParser;
-_RemarkParser_supplier = new WeakMap();