metar-taf-parser 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Alexander Harding
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,48 @@
+# metar-taf-parser
+
+This is a port of [python-metar-taf-parser](https://github.com/mivek/python-metar-taf-parser) to typescript. It's fully typed and tested with i18n support, and can run on Node or the browser.
+
+## Example
+
+⚠️ This project is an active work in progress. These examples do not currently work.
+
+### Parse METAR
+
+```ts
+import { parseMetar } from 'metar-taf-parser'
+
+// Get the raw METAR/TAF strings in your preferred way
+// For example: https://www.aviationweather.gov/dataserver
+const { metar } = await myService.getAirportData('KMSN')
+
+// Readily serializable
+const metarResult = parseMetar(metar)
+
+// Your code here 🚀
+```
+
+### Parse TAF
+
+```ts
+import { parseTAF } from 'metar-taf-parser'
+
+// Get the raw METAR/TAF strings in your preferred way
+// For example: https://www.aviationweather.gov/dataserver
+const { taf } = await myService.getAirportData('KMSN')
+
+// Readily serializable
+const tafResult = parseTAF(taf)
+
+// Your code here 🚀
+```
+
+### i18n
+
+```ts
+import { parseMetar } from 'metar-taf-parser'
+import de from 'metar-taf-parser/locale/de'
+
+const { metar } = await myService.getAirportData('KMSN')
+
+const metarResult = parseMetar(metar, { locale: de })
+```

package/dist/lib/command/common.d.ts

@@ -0,0 +1,54 @@
+import { IAbstractWeatherContainer, ICloud, IWind, IWindShear } from "model/model";
+interface ICommand {
+    canParse(str: string): boolean;
+    execute(container: IAbstractWeatherContainer, str: string): boolean;
+}
+export declare class CloudCommand implements ICommand {
+    #private;
+    parse(cloudString: string): ICloud | undefined;
+    execute(container: IAbstractWeatherContainer, cloudString: string): boolean;
+    canParse(cloudString: string): boolean;
+}
+export declare class MainVisibilityCommand implements ICommand {
+    #private;
+    canParse(visibilityString: string): boolean;
+    execute(container: IAbstractWeatherContainer, visibilityString: string): boolean;
+}
+export declare class WindCommand implements ICommand {
+    #private;
+    canParse(windString: string): boolean;
+    parseWind(windString: string): IWind;
+    execute(container: IAbstractWeatherContainer, windString: string): boolean;
+}
+export declare class WindVariationCommand implements ICommand {
+    #private;
+    canParse(windString: string): boolean;
+    parseWindVariation(wind: IWind, windString: string): void;
+    execute(container: IAbstractWeatherContainer, windString: string): boolean;
+}
+export declare class WindShearCommand implements ICommand {
+    #private;
+    canParse(windString: string): boolean;
+    parseWindShear(windString: string): IWindShear;
+    execute(container: IAbstractWeatherContainer, windString: string): boolean;
+}
+export declare class VerticalVisibilityCommand implements ICommand {
+    #private;
+    execute(container: IAbstractWeatherContainer, visibilityString: string): boolean;
+    canParse(windString: string): boolean;
+}
+export declare class MinimalVisibilityCommand implements ICommand {
+    #private;
+    execute(container: IAbstractWeatherContainer, visibilityString: string): boolean;
+    canParse(windString: string): boolean;
+}
+export declare class MainVisibilityNauticalMilesCommand implements ICommand {
+    #private;
+    execute(container: IAbstractWeatherContainer, visibilityString: string): boolean;
+    canParse(windString: string): boolean;
+}
+export declare class CommandSupplier {
+    #private;
+    get(input: string): ICommand | undefined;
+}
+export {};

package/dist/lib/command/common.js

@@ -0,0 +1,239 @@
+"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 _CloudCommand_cloudRegex, _MainVisibilityCommand_regex, _WindCommand_regex, _WindVariationCommand_regex, _WindShearCommand_regex, _VerticalVisibilityCommand_regex, _MinimalVisibilityCommand_regex, _MainVisibilityNauticalMilesCommand_regex, _CommandSupplier_commands;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandSupplier = exports.MainVisibilityNauticalMilesCommand = exports.MinimalVisibilityCommand = exports.VerticalVisibilityCommand = exports.WindShearCommand = exports.WindVariationCommand = exports.WindCommand = exports.MainVisibilityCommand = exports.CloudCommand = void 0;
+const converter = __importStar(require("commons/converter"));
+const enum_1 = require("model/enum");
+const errors_1 = require("commons/errors");
+/**
+ * This function creates a wind element.
+ * @param wind The wind object
+ * @param direction The direction in degrees
+ * @param speed The speed
+ * @param gust The speed of the gust.
+ * @param unit The speed unit
+ */
+function makeWind(direction, speed, gust, unit) {
+    return {
+        speed: +speed,
+        direction: converter.degreesToCardinal(direction),
+        degrees: direction !== "VRB" ? +direction : undefined,
+        gust: gust ? +gust : undefined,
+        unit: unit || "KT",
+    };
+}
+class CloudCommand {
+    constructor() {
+        _CloudCommand_cloudRegex.set(this, /^([A-Z]{3})(\d{3})?([A-Z]{2,3})?$/);
+    }
+    parse(cloudString) {
+        const m = cloudString.match(__classPrivateFieldGet(this, _CloudCommand_cloudRegex, "f"));
+        if (!m)
+            return;
+        const quantity = enum_1.CloudQuantity[m[1]];
+        const height = 100 * +m[2] || undefined;
+        const type = enum_1.CloudType[m[3]];
+        if (!quantity)
+            return;
+        return { quantity, height, type };
+    }
+    execute(container, cloudString) {
+        const cloud = this.parse(cloudString);
+        if (cloud) {
+            container.clouds.push(cloud);
+            return true;
+        }
+        return false;
+    }
+    canParse(cloudString) {
+        return __classPrivateFieldGet(this, _CloudCommand_cloudRegex, "f").test(cloudString);
+    }
+}
+exports.CloudCommand = CloudCommand;
+_CloudCommand_cloudRegex = new WeakMap();
+class MainVisibilityCommand {
+    constructor() {
+        _MainVisibilityCommand_regex.set(this, /^(\d{4})(|NDV)$/);
+    }
+    canParse(visibilityString) {
+        return __classPrivateFieldGet(this, _MainVisibilityCommand_regex, "f").test(visibilityString);
+    }
+    execute(container, visibilityString) {
+        const matches = visibilityString.match(__classPrivateFieldGet(this, _MainVisibilityCommand_regex, "f"));
+        if (!matches)
+            return false;
+        const distance = converter.convertVisibility(matches[1]);
+        if (!container.visibility)
+            container.visibility = { distance };
+        container.visibility.distance = distance;
+        return true;
+    }
+}
+exports.MainVisibilityCommand = MainVisibilityCommand;
+_MainVisibilityCommand_regex = new WeakMap();
+class WindCommand {
+    constructor() {
+        _WindCommand_regex.set(this, /^(VRB|\d{3})(\d{2})G?(\d{2})?(KT|MPS|KM\/H)?/);
+    }
+    canParse(windString) {
+        return __classPrivateFieldGet(this, _WindCommand_regex, "f").test(windString);
+    }
+    parseWind(windString) {
+        const matches = windString.match(__classPrivateFieldGet(this, _WindCommand_regex, "f"));
+        if (!matches)
+            throw new errors_1.UnexpectedParseError("Wind should be defined");
+        return makeWind(matches[1], matches[2], matches[3], matches[5]);
+    }
+    execute(container, windString) {
+        const wind = this.parseWind(windString);
+        container.wind = wind;
+        return true;
+    }
+}
+exports.WindCommand = WindCommand;
+_WindCommand_regex = new WeakMap();
+class WindVariationCommand {
+    constructor() {
+        _WindVariationCommand_regex.set(this, /^(\d{3})V(\d{3})/);
+    }
+    canParse(windString) {
+        return __classPrivateFieldGet(this, _WindVariationCommand_regex, "f").test(windString);
+    }
+    parseWindVariation(wind, windString) {
+        const matches = windString.match(__classPrivateFieldGet(this, _WindVariationCommand_regex, "f"));
+        if (!matches)
+            throw new errors_1.UnexpectedParseError("Wind should be defined");
+        wind.minVariation = +matches[1];
+        wind.maxVariation = +matches[2];
+    }
+    execute(container, windString) {
+        this.parseWindVariation(container.wind, windString);
+        return true;
+    }
+}
+exports.WindVariationCommand = WindVariationCommand;
+_WindVariationCommand_regex = new WeakMap();
+class WindShearCommand {
+    constructor() {
+        _WindShearCommand_regex.set(this, /^WS(\d{3})\/(\w{3})(\d{2})G?(\d{2})?(KT|MPS|KM\/H)/);
+    }
+    canParse(windString) {
+        return __classPrivateFieldGet(this, _WindShearCommand_regex, "f").test(windString);
+    }
+    parseWindShear(windString) {
+        const matches = windString.match(__classPrivateFieldGet(this, _WindShearCommand_regex, "f"));
+        if (!matches)
+            throw new errors_1.UnexpectedParseError("Wind shear should be defined");
+        return Object.assign(Object.assign({}, makeWind(matches[2], matches[3], matches[4], matches[5])), { height: 100 * +matches[1] });
+    }
+    execute(container, windString) {
+        container.windShear = this.parseWindShear(windString);
+        return true;
+    }
+}
+exports.WindShearCommand = WindShearCommand;
+_WindShearCommand_regex = new WeakMap();
+class VerticalVisibilityCommand {
+    constructor() {
+        _VerticalVisibilityCommand_regex.set(this, /^VV(\d{3})$/);
+    }
+    execute(container, visibilityString) {
+        const matches = visibilityString.match(__classPrivateFieldGet(this, _VerticalVisibilityCommand_regex, "f"));
+        if (!matches)
+            throw new errors_1.UnexpectedParseError("Vertical visibility should be defined");
+        container.verticalVisibility = 100 * +matches[1];
+        return true;
+    }
+    canParse(windString) {
+        return __classPrivateFieldGet(this, _VerticalVisibilityCommand_regex, "f").test(windString);
+    }
+}
+exports.VerticalVisibilityCommand = VerticalVisibilityCommand;
+_VerticalVisibilityCommand_regex = new WeakMap();
+class MinimalVisibilityCommand {
+    constructor() {
+        _MinimalVisibilityCommand_regex.set(this, /^(\d{4}[a-z])$/);
+    }
+    execute(container, visibilityString) {
+        const matches = visibilityString.match(__classPrivateFieldGet(this, _MinimalVisibilityCommand_regex, "f"));
+        if (!matches)
+            throw new errors_1.UnexpectedParseError("Vertical visibility should be defined");
+        if (!container.visibility)
+            throw new errors_1.UnexpectedParseError("container.visibility not instantiated");
+        container.visibility.minDistance = +matches[1].slice(0, 4);
+        container.visibility.minDirection = matches[1][4];
+        return true;
+    }
+    canParse(windString) {
+        return __classPrivateFieldGet(this, _MinimalVisibilityCommand_regex, "f").test(windString);
+    }
+}
+exports.MinimalVisibilityCommand = MinimalVisibilityCommand;
+_MinimalVisibilityCommand_regex = new WeakMap();
+class MainVisibilityNauticalMilesCommand {
+    constructor() {
+        _MainVisibilityNauticalMilesCommand_regex.set(this, /^(\d)*(\s)?((\d\/\d)?SM)$/);
+    }
+    execute(container, visibilityString) {
+        if (!container.visibility)
+            container.visibility = { distance: visibilityString };
+        container.visibility.distance = visibilityString;
+        return true;
+    }
+    canParse(windString) {
+        return __classPrivateFieldGet(this, _MainVisibilityNauticalMilesCommand_regex, "f").test(windString);
+    }
+}
+exports.MainVisibilityNauticalMilesCommand = MainVisibilityNauticalMilesCommand;
+_MainVisibilityNauticalMilesCommand_regex = new WeakMap();
+class CommandSupplier {
+    constructor() {
+        _CommandSupplier_commands.set(this, [
+            new WindShearCommand(),
+            new WindCommand(),
+            new WindVariationCommand(),
+            new MainVisibilityCommand(),
+            new MainVisibilityNauticalMilesCommand(),
+            new MinimalVisibilityCommand(),
+            new VerticalVisibilityCommand(),
+            new CloudCommand(),
+        ]);
+    }
+    get(input) {
+        for (let i = 0; i < __classPrivateFieldGet(this, _CommandSupplier_commands, "f").length; i++) {
+            const command = __classPrivateFieldGet(this, _CommandSupplier_commands, "f")[i];
+            if (command.canParse(input))
+                return command;
+        }
+    }
+}
+exports.CommandSupplier = CommandSupplier;
+_CommandSupplier_commands = new WeakMap();

package/dist/lib/command/metar.d.ts

@@ -0,0 +1,26 @@
+import { IMetar } from "model/model";
+interface ICommand {
+    canParse(str: string): boolean;
+    execute(metar: IMetar, str: string): void;
+}
+export declare class AltimeterCommand implements ICommand {
+    #private;
+    canParse(input: string): boolean;
+    execute(metar: IMetar, input: string): void;
+}
+export declare class AltimeterMercuryCommand implements ICommand {
+    #private;
+    canParse(input: string): boolean;
+    execute(metar: IMetar, input: string): void;
+}
+export declare class RunwayCommand implements ICommand {
+    #private;
+    canParse(input: string): boolean;
+    execute(metar: IMetar, input: string): void;
+}
+export declare class TemperatureCommand implements ICommand {
+    #private;
+    canParse(input: string): boolean;
+    execute(metar: IMetar, input: string): void;
+}
+export {};

package/dist/lib/command/metar.js

@@ -0,0 +1,134 @@
+"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 _AltimeterCommand_regex, _AltimeterMercuryCommand_regex, _RunwayCommand_genericRegex, _RunwayCommand_runwayMaxRangeRegex, _RunwayCommand_runwayRegex, _TemperatureCommand_regex, _CommandSupplier_commands;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemperatureCommand = exports.RunwayCommand = exports.AltimeterMercuryCommand = exports.AltimeterCommand = void 0;
+const converter = __importStar(require("commons/converter"));
+const errors_1 = require("commons/errors");
+class AltimeterCommand {
+    constructor() {
+        _AltimeterCommand_regex.set(this, /^Q(\d{4})$/);
+    }
+    canParse(input) {
+        return __classPrivateFieldGet(this, _AltimeterCommand_regex, "f").test(input);
+    }
+    execute(metar, input) {
+        const matches = input.match(__classPrivateFieldGet(this, _AltimeterCommand_regex, "f"));
+        if (!matches)
+            throw new errors_1.UnexpectedParseError("Match not found");
+        metar.altimeter = +matches[1];
+    }
+}
+exports.AltimeterCommand = AltimeterCommand;
+_AltimeterCommand_regex = new WeakMap();
+class AltimeterMercuryCommand {
+    constructor() {
+        _AltimeterMercuryCommand_regex.set(this, /^A(\d{4})$/);
+    }
+    canParse(input) {
+        return __classPrivateFieldGet(this, _AltimeterMercuryCommand_regex, "f").test(input);
+    }
+    execute(metar, input) {
+        const matches = input.match(__classPrivateFieldGet(this, _AltimeterMercuryCommand_regex, "f"));
+        if (!matches)
+            throw new errors_1.UnexpectedParseError("Match not found");
+        const mercury = +matches[1] / 100;
+        metar.altimeter = converter.convertInchesMercuryToPascal(mercury);
+    }
+}
+exports.AltimeterMercuryCommand = AltimeterMercuryCommand;
+_AltimeterMercuryCommand_regex = new WeakMap();
+class RunwayCommand {
+    constructor() {
+        _RunwayCommand_genericRegex.set(this, /^(R\d{2}\w?\/)/);
+        _RunwayCommand_runwayMaxRangeRegex.set(this, /^R(\d{2}\w?)\/(\d{4})V(\d{3})(\w{0,2})/);
+        _RunwayCommand_runwayRegex.set(this, /^R(\d{2}\w?)\/(\w)?(\d{4})(\w{0,2})$/);
+    }
+    canParse(input) {
+        return __classPrivateFieldGet(this, _RunwayCommand_genericRegex, "f").test(input);
+    }
+    execute(metar, input) {
+        const matches = input.match(__classPrivateFieldGet(this, _RunwayCommand_runwayRegex, "f"));
+        // TODO idk if this matches super well...
+        if (matches) {
+            metar.runwaysInfo.push({
+                name: matches[1],
+                minRange: +matches[3],
+                trend: matches[4],
+            });
+        }
+        const maxRangeMatches = input.match(__classPrivateFieldGet(this, _RunwayCommand_runwayMaxRangeRegex, "f"));
+        if (maxRangeMatches) {
+            metar.runwaysInfo.push({
+                name: maxRangeMatches[1],
+                minRange: +maxRangeMatches[2],
+                maxRange: +maxRangeMatches[3],
+                trend: maxRangeMatches[4],
+            });
+        }
+    }
+}
+exports.RunwayCommand = RunwayCommand;
+_RunwayCommand_genericRegex = new WeakMap(), _RunwayCommand_runwayMaxRangeRegex = new WeakMap(), _RunwayCommand_runwayRegex = new WeakMap();
+class TemperatureCommand {
+    constructor() {
+        _TemperatureCommand_regex.set(this, /^(M?\d{2})\/(M?\d{2})$/);
+    }
+    canParse(input) {
+        return __classPrivateFieldGet(this, _TemperatureCommand_regex, "f").test(input);
+    }
+    execute(metar, input) {
+        const matches = input.match(__classPrivateFieldGet(this, _TemperatureCommand_regex, "f"));
+        if (!matches)
+            throw new errors_1.UnexpectedParseError("Match not found");
+        metar.temperature = converter.convertTemperature(matches[1]);
+        metar.dewPoint = converter.convertTemperature(matches[2]);
+    }
+}
+exports.TemperatureCommand = TemperatureCommand;
+_TemperatureCommand_regex = new WeakMap();
+class CommandSupplier {
+    constructor() {
+        _CommandSupplier_commands.set(this, [
+            new RunwayCommand(),
+            new TemperatureCommand(),
+            new AltimeterCommand(),
+            new AltimeterMercuryCommand(),
+        ]);
+    }
+    get(input) {
+        for (let i = 0; i < __classPrivateFieldGet(this, _CommandSupplier_commands, "f").length; i++) {
+            const command = __classPrivateFieldGet(this, _CommandSupplier_commands, "f")[i];
+            if (command.canParse(input))
+                return command;
+        }
+    }
+}
+_CommandSupplier_commands = new WeakMap();