metar-taf-parser 0.0.1 → 0.0.2

package/dist/{lib/commons → commons}/errors.js

@@ -4,20 +4,24 @@ exports.UnexpectedParseError = exports.TranslationError = exports.InvalidWeather
 class ParseError extends Error {
     constructor(message) {
         super(message);
+        this.name = "ParseError";
         Object.setPrototypeOf(this, new.target.prototype);
     }
 }
 exports.ParseError = ParseError;
 class InvalidWeatherStatementError extends ParseError {
-    constructor(missing) {
-        super(`Invalid weather string. Missing: ${missing}`);
+    constructor(cause) {
+        super(`Invalid weather string.`);
+        this.name = "InvalidWeatherStatementError";
         Object.setPrototypeOf(this, new.target.prototype);
+        this.cause = cause;
     }
 }
 exports.InvalidWeatherStatementError = InvalidWeatherStatementError;
 class TranslationError extends ParseError {
     constructor(missingLocale) {
-        super(`Missing locale "${missingLocale}"`);
+        super(`Missing translation "${missingLocale}"`);
+        this.name = "TranslationError";
         Object.setPrototypeOf(this, new.target.prototype);
     }
 }
@@ -28,6 +32,7 @@ exports.TranslationError = TranslationError;
 class UnexpectedParseError extends ParseError {
     constructor(message) {
         super(message);
+        this.name = "UnexpectedParseError";
         Object.setPrototypeOf(this, new.target.prototype);
     }
 }

package/dist/commons/i18n.d.ts

@@ -0,0 +1,12 @@
+import en from "../locale/en";
+export default en;
+declare type DeepPartial<T> = T extends object ? {
+    [P in keyof T]?: DeepPartial<T[P]>;
+} : T;
+export declare type Locale = DeepPartial<typeof en>;
+declare type PathsToStringProps<T> = T extends string ? [] : {
+    [K in Extract<keyof T, string>]: [K, ...PathsToStringProps<T[K]>];
+}[Extract<keyof T, string>];
+declare type Join<T extends string[], D extends string> = T extends [] ? never : T extends [infer F] ? F : T extends [infer F, ...infer R] ? F extends string ? `${F}${D}${Join<Extract<R, string[]>, D>}` : never : string;
+export declare function _(path: Join<PathsToStringProps<typeof en>, ".">, lang: Locale): string;
+export declare function format(message: string, ...args: unknown[]): string;

package/dist/{lib/commons → commons}/i18n.js

@@ -3,10 +3,18 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.format = void 0;
-const en_json_1 = __importDefault(require("locale/en.json"));
-// TODO - add other language support. EN hardcoded for now.
-exports.default = en_json_1.default;
+exports.format = exports._ = void 0;
+const en_1 = __importDefault(require("../locale/en"));
+const get_1 = __importDefault(require("lodash/get"));
+const errors_1 = require("./errors");
+exports.default = en_1.default;
+function _(path, lang) {
+    const translation = (0, get_1.default)(lang, path);
+    if (!translation || typeof translation !== "string")
+        throw new errors_1.TranslationError(path);
+    return translation;
+}
+exports._ = _;
 function format(message, ...args) {
     return message.replace(/{\d+}/g, (match) => {
         const index = +match.slice(1, -1);

package/dist/{lib/helpers → helpers}/helpers.d.ts

@@ -2,4 +2,3 @@
  * Split behaving similar to Python's implementation
  */
 export declare function pySplit(string: string, separator: string, n?: number): string[];
-export declare function findAll(regex: RegExp, str: string): string[];

package/dist/helpers/helpers.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pySplit = void 0;
+/**
+ * Split behaving similar to Python's implementation
+ */
+function pySplit(string, separator, n) {
+    let split = string.split(separator);
+    // Note: Python implementation will automatically trim empty values if
+    // separator is undefined. Since this function is kinda meh, we'll just do it
+    // for any spaces (pretty close to their implementation, since a space is the
+    // default character to split on)
+    //
+    // https://docs.python.org/3/library/stdtypes.html?highlight=split#str.split
+    if (separator === " ")
+        split = split.filter((n) => n);
+    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;

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+import { IMetar } 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";

package/dist/index.js

@@ -0,0 +1,38 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMetar = void 0;
+const parser_1 = require("./parser/parser");
+const errors_1 = require("./commons/errors");
+const en_1 = __importDefault(require("./locale/en"));
+function parseMetar(metar, options) {
+    const lang = (options === null || options === void 0 ? void 0 : options.locale) || en_1.default;
+    try {
+        return new parser_1.MetarParser(lang).parse(metar);
+    }
+    catch (e) {
+        if (e instanceof errors_1.ParseError)
+            throw e;
+        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/locale/de.d.ts

@@ -0,0 +1,321 @@
+declare const _default: {
+    CloudQuantity: {
+        BKN: string;
+        FEW: string;
+        NSC: string;
+        OVC: string;
+        SCT: string;
+        SKC: string;
+    };
+    CloudType: {
+        CC: string;
+        TCU: string;
+    };
+    DepositBrakingCapacity: {
+        NOT_REPORTED: string;
+        POOR: string;
+        MEDIUM_POOR: string;
+        MEDIUM: string;
+        MEDIUM_GOOD: string;
+        GOOD: string;
+        UNRELIABLE: string;
+    };
+    DepositCoverage: {
+        NOT_REPORTED: string;
+        LESS_10: string;
+        FROM_11_TO_25: string;
+        FROM_26_TO_50: string;
+        FROM_51_TO_100: string;
+    };
+    DepositThickness: {
+        NOT_REPORTED: string;
+        LESS_1_MM: string;
+        THICKNESS_40: string;
+        CLOSED: string;
+    };
+    DepositType: {
+        NOT_REPORTED: string;
+        CLEAR_DRY: string;
+        DAMP: string;
+        WET_WATER_PATCHES: string;
+        RIME_FROST_COVERED: string;
+        DRY_SNOW: string;
+        WET_SNOW: string;
+        ICE: string;
+        COMPACTED_SNOW: string;
+        FROZEN_RIDGES: string;
+    };
+    Descriptive: {
+        BC: string;
+        BL: string;
+        DR: string;
+        FZ: string;
+        MI: string;
+        PR: string;
+        SH: string;
+        TS: string;
+    };
+    Error: {
+        prefix: string;
+    };
+    ErrorCode: {
+        AirportNotFound: string;
+        InvalidMessage: string;
+    };
+    Indicator: {
+        M: string;
+        P: string;
+    };
+    Intensity: {
+        "-": string;
+        VC: string;
+    };
+    "intensity-plus": string;
+    Phenomenon: {
+        BR: string;
+        DS: string;
+        DU: string;
+        DZ: string;
+        FC: string;
+        FG: string;
+        FU: string;
+        GR: string;
+        GS: string;
+        HZ: string;
+        IC: string;
+        PL: string;
+        PO: string;
+        PY: string;
+        RA: string;
+        SA: string;
+        SG: string;
+        SN: string;
+        SQ: string;
+        SS: string;
+        UP: string;
+        VA: string;
+        TS: string;
+    };
+    Remark: {
+        AO1: string;
+        AO2: string;
+        BASED: string;
+        Ceiling: {
+            Height: string;
+            Second: {
+                Location: string;
+            };
+        };
+        FCST: string;
+        FUNNELCLOUD: string;
+        Hail: {
+            "0": string;
+            LesserThan: string;
+        };
+        HVY: string;
+        LGT: string;
+        MOD: string;
+        Obscuration: string;
+        ON: string;
+        NXT: string;
+        PeakWind: string;
+        Precipitation: {
+            Beg: {
+                End: string;
+            };
+        };
+        PRESFR: string;
+        PRESRR: string;
+        Second: {
+            Location: {
+                Visibility: string;
+            };
+        };
+        Sea: {
+            Level: {
+                Pressure: string;
+            };
+        };
+        Sector: {
+            Visibility: string;
+        };
+        SLPNO: string;
+        Snow: {
+            Increasing: {
+                Rapidly: string;
+            };
+            Pellets: string;
+        };
+        Surface: {
+            Visibility: string;
+        };
+        Thunderstorm: {
+            Location: {
+                "0": string;
+                Moving: string;
+            };
+        };
+        Tornadic: {
+            Activity: {
+                Beginning: string;
+                BegEnd: string;
+                Ending: string;
+            };
+        };
+        TORNADO: string;
+        Tower: {
+            Visibility: string;
+        };
+        Variable: {
+            Prevailing: {
+                Visibility: string;
+            };
+            Sky: {
+                Condition: {
+                    "0": string;
+                    Height: string;
+                };
+            };
+        };
+        VIRGA: string;
+        Virga: {
+            Direction: string;
+        };
+        WATERSPOUT: string;
+        WindShift: {
+            "0": string;
+            FROPA: string;
+        };
+    };
+    MetarFacade: {
+        InvalidIcao: string;
+    };
+    Converter: {
+        D: string;
+        E: string;
+        ENE: string;
+        ESE: string;
+        N: string;
+        NE: string;
+        NNE: string;
+        NNW: string;
+        NSC: string;
+        NW: string;
+        S: string;
+        SE: string;
+        SSE: string;
+        SSW: string;
+        SW: string;
+        U: string;
+        VRB: string;
+        WNW: string;
+        WSW: string;
+    };
+    WeatherChangeType: {
+        FM: string;
+        BECMG: string;
+        TEMPO: string;
+        PROB: string;
+    };
+    TimeIndicator: {
+        AT: string;
+        FM: string;
+        TL: string;
+    };
+    ToString: {
+        airport: string;
+        altimeter: string;
+        amendment: string;
+        auto: string;
+        cavok: string;
+        clouds: string;
+        day: {
+            month: string;
+            hour: string;
+        };
+        deposit: {
+            braking: string;
+            coverage: string;
+            thickness: string;
+            type: string;
+        };
+        descriptive: string;
+        dew: {
+            point: string;
+        };
+        end: {
+            day: {
+                month: string;
+            };
+            hour: {
+                day: string;
+            };
+        };
+        height: {
+            feet: string;
+            meter: string;
+        };
+        intensity: string;
+        indicator: string;
+        message: string;
+        name: string;
+        nosig: string;
+        phenomenons: string;
+        probability: string;
+        quantity: string;
+        remark: string;
+        report: {
+            time: string;
+        };
+        runway: {
+            info: string;
+        };
+        start: {
+            day: {
+                month: string;
+            };
+            hour: {
+                day: string;
+            };
+            minute: string;
+        };
+        temperature: {
+            "0": string;
+            max: string;
+            min: string;
+        };
+        trend: string;
+        trends: string;
+        type: string;
+        visibility: {
+            main: string;
+            min: {
+                "0": string;
+                direction: string;
+            };
+            max: string;
+        };
+        vertical: {
+            visibility: string;
+        };
+        weather: {
+            conditions: string;
+        };
+        wind: {
+            direction: {
+                "0": string;
+                degrees: string;
+            };
+            gusts: string;
+            min: {
+                variation: string;
+            };
+            max: {
+                variation: string;
+            };
+            speed: string;
+            unit: string;
+        };
+    };
+};
+export default _default;