metar-taf-parser 1.2.0 → 2.0.0

package/dist/model/enum.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WeatherChangeType = exports.TimeIndicator = exports.Phenomenon = exports.Descriptive = exports.Intensity = exports.CloudType = exports.CloudQuantity = void 0;
+exports.RunwayInfoUnit = exports.RunwayInfoTrend = exports.ValueIndicator = exports.DistanceUnit = exports.Direction = exports.WeatherChangeType = exports.TimeIndicator = exports.Phenomenon = exports.Descriptive = exports.Intensity = exports.CloudType = exports.CloudQuantity = void 0;
 var CloudQuantity;
 (function (CloudQuantity) {
     /**
@@ -119,6 +119,7 @@ var Phenomenon;
     Phenomenon["SPRAY"] = "PY";
     Phenomenon["SQUALL"] = "SQ";
     Phenomenon["SAND_WHIRLS"] = "PO";
+    Phenomenon["THUNDERSTORM"] = "TS";
     Phenomenon["DUSTSTORM"] = "DS";
     Phenomenon["SANDSTORM"] = "SS";
     Phenomenon["FUNNEL_CLOUD"] = "FC";
@@ -229,3 +230,51 @@ var WeatherChangeType;
      */
     WeatherChangeType["PROB"] = "PROB";
 })(WeatherChangeType = exports.WeatherChangeType || (exports.WeatherChangeType = {}));
+var Direction;
+(function (Direction) {
+    Direction["E"] = "E";
+    Direction["ENE"] = "ENE";
+    Direction["ESE"] = "ESE";
+    Direction["N"] = "N";
+    Direction["NE"] = "NE";
+    Direction["NNE"] = "NNE";
+    Direction["NNW"] = "NNW";
+    Direction["NW"] = "NW";
+    Direction["S"] = "S";
+    Direction["SE"] = "SE";
+    Direction["SSE"] = "SSE";
+    Direction["SSW"] = "SSW";
+    Direction["SW"] = "SW";
+    Direction["W"] = "W";
+    Direction["WNW"] = "WNW";
+    Direction["WSW"] = "WSW";
+})(Direction = exports.Direction || (exports.Direction = {}));
+var DistanceUnit;
+(function (DistanceUnit) {
+    DistanceUnit["Meters"] = "m";
+    DistanceUnit["StatuteMiles"] = "SM";
+})(DistanceUnit = exports.DistanceUnit || (exports.DistanceUnit = {}));
+/**
+ * Used to indicate the actual value is greater than or less than the value written
+ *
+ * For example,
+ *
+ *  1. `P6SM` = visibility greater than 6 statute miles
+ *  2. `M1/4SM` = visibility less than 1/4 statute mile
+ */
+var ValueIndicator;
+(function (ValueIndicator) {
+    ValueIndicator["GreaterThan"] = "P";
+    ValueIndicator["LessThan"] = "M";
+})(ValueIndicator = exports.ValueIndicator || (exports.ValueIndicator = {}));
+var RunwayInfoTrend;
+(function (RunwayInfoTrend) {
+    RunwayInfoTrend["Uprising"] = "U";
+    RunwayInfoTrend["Decreasing"] = "D";
+    RunwayInfoTrend["NoSignificantChange"] = "N";
+})(RunwayInfoTrend = exports.RunwayInfoTrend || (exports.RunwayInfoTrend = {}));
+var RunwayInfoUnit;
+(function (RunwayInfoUnit) {
+    RunwayInfoUnit["Feet"] = "FT";
+    RunwayInfoUnit["Meters"] = "m";
+})(RunwayInfoUnit = exports.RunwayInfoUnit || (exports.RunwayInfoUnit = {}));

package/dist/model/model.d.ts

@@ -1,4 +1,5 @@
-import { CloudQuantity, CloudType, Descriptive, Phenomenon, TimeIndicator, WeatherChangeType } from "../model/enum";
+import { CloudQuantity, CloudType, Descriptive, ValueIndicator, Phenomenon, TimeIndicator, WeatherChangeType, DistanceUnit, RunwayInfoTrend, RunwayInfoUnit, Intensity } from "../model/enum";
+import { Remark } from "../command/remark";
 export interface ICountry {
     name: string;
 }
@@ -27,13 +28,25 @@ export interface IWind {
 export interface IWindShear extends IWind {
     height: number;
 }
-export interface Visibility {
-    distance: string;
-    minDistance?: number;
-    minDirection?: string;
-}
+export interface Distance {
+    indicator?: ValueIndicator;
+    value: number;
+    unit: DistanceUnit;
+    /** No Directional Visibility */
+    ndv?: true;
+}
+export declare type Visibility = Distance & {
+    /**
+     * Never in North American METARs
+     */
+    min?: {
+        /** Always in meters */
+        value: number;
+        direction: string;
+    };
+};
 export interface IWeatherCondition {
-    intensity?: string;
+    intensity?: Intensity;
     descriptive?: Descriptive;
     phenomenons: Phenomenon[];
 }
@@ -47,7 +60,15 @@ export interface IRunwayInfo {
     name: string;
     minRange: number;
     maxRange?: number;
-    trend: unknown;
+    /**
+     * Only used in North American runway ranges (feet unit of measurement)
+     */
+    indicator?: ValueIndicator;
+    /**
+     * Only used in IACO runway ranges (meters unit of measurement)
+     */
+    trend?: RunwayInfoTrend;
+    unit: RunwayInfoUnit;
 }
 export interface ICloud {
     height?: number;
@@ -59,9 +80,9 @@ export interface IAbstractWeatherContainer {
     visibility?: Visibility;
     verticalVisibility?: number;
     windShear?: IWindShear;
-    cavok?: boolean;
+    cavok?: true;
     remark?: string;
-    remarks: string[];
+    remarks: Remark[];
     clouds: ICloud[];
     weatherConditions: IWeatherCondition[];
 }
@@ -83,21 +104,27 @@ export interface IAbstractWeatherCode extends IAbstractWeatherContainer, ITime {
     station: string;
     trends: IAbstractTrend[];
 }
+export interface IAbstractWeatherCodeDated extends IAbstractWeatherCode {
+    issued: Date;
+}
 export interface IMetar extends IAbstractWeatherCode {
     temperature?: number;
     dewPoint?: number;
     altimeter?: number;
-    nosig?: boolean;
-    auto?: boolean;
+    nosig?: true;
+    auto?: true;
     runwaysInfo: IRunwayInfo[];
+    /**
+     * Not used in North America
+     */
     trends: IMetarTrend[];
 }
 export interface ITAF extends IAbstractWeatherCode {
     validity: IValidity;
     maxTemperature?: ITemperatureDated;
     minTemperature?: ITemperatureDated;
-    amendment?: boolean;
-    trends: ITAFTrend[];
+    amendment?: true;
+    trends: TAFTrend[];
 }
 export interface IAbstractTrend extends IAbstractWeatherContainer {
     type: WeatherChangeType;
@@ -108,16 +135,54 @@ export interface IMetarTrendTime extends ITime {
 export interface IMetarTrend extends IAbstractTrend {
     times: IMetarTrendTime[];
 }
-export interface ITAFTrend extends IAbstractTrend {
+export interface IBaseTAFTrend extends IAbstractTrend {
+    /**
+     * Will not be found on FM trends. May exist on others.
+     *
+     * If does not exist, probability is > 40%
+     */
     probability?: number;
-    validity?: IFMValidity;
-}
+    /**
+     * All trends have `startDay` and `startHour` defined. Additionally:
+     *
+     * - FM trends also have `startMinutes`. They **DO NOT** have an explicit end
+     *   validity (it is implied by the following FM).
+     * - All others (PROB, TEMPO, BECMG) have `endDay` and `endHour`.
+     *
+     * All properties are allowed to be accessed (as optionals), but if you want
+     * type guarantees, you can check the trend type. For example:
+     *
+     * ```ts
+     * switch (trend.type) {
+     *   case WeatherChangeType.FM:
+     *     // trend.validity now has startMinutes defined
+     *     break;
+     *   case WeatherChangeType.PROB:
+     *   case WeatherChangeType.BECMG:
+     *   case WeatherChangeType.TEMPO:
+     *     // trend.validity now has endHour, endDay defined
+     * }
+     * ```
+     */
+    validity: IAbstractValidity & Partial<IFMValidity> & Partial<IValidity>;
+}
+export declare type TAFTrend = IBaseTAFTrend & ({
+    type: WeatherChangeType.FM;
+    validity: IFMValidity;
+} | {
+    type: WeatherChangeType;
+    validity: IValidity;
+});
 export interface IEndValidity {
     endHour: number;
     endDay: number;
 }
 export interface IValidity extends IAbstractValidity, IEndValidity {
 }
-export interface IFMValidity extends IAbstractValidity, Partial<IEndValidity> {
-    startMinutes?: number;
+export interface IValidityDated extends IAbstractValidity, IEndValidity {
+    start: Date;
+    end: Date;
+}
+export interface IFMValidity extends IAbstractValidity {
+    startMinutes: number;
 }

package/dist/model/model.js

@@ -4,6 +4,8 @@ exports.isWeatherConditionValid = void 0;
 const enum_1 = require("../model/enum");
 function isWeatherConditionValid(weather) {
     return (weather.phenomenons.length !== 0 ||
-        weather.descriptive == enum_1.Descriptive.THUNDERSTORM);
+        weather.descriptive == enum_1.Descriptive.THUNDERSTORM ||
+        (weather.intensity === enum_1.Intensity.IN_VICINITY &&
+            weather.descriptive == enum_1.Descriptive.SHOWERS));
 }
 exports.isWeatherConditionValid = isWeatherConditionValid;

package/dist/parser/parser.d.ts

@@ -1,5 +1,5 @@
-import { IAbstractWeatherContainer, IMetar, IMetarTrend, ITAF, ITAFTrend, ITemperatureDated, IValidity, IWeatherCondition } from "../model/model";
-import { WeatherChangeType } from "../model/enum";
+import { Remark } from "../command/remark";
+import { IAbstractWeatherContainer, IMetar, IMetarTrend, ITAF, TAFTrend, ITemperatureDated, IValidity, IWeatherCondition, IValidityDated } from "../model/model";
 import { Locale } from "../commons/i18n";
 /**
  * Parses the temperature in a TAF
@@ -12,7 +12,7 @@ export declare function parseTemperature(input: string): ITemperatureDated;
  * @param input the string containing the validity
  * @returns Validity object
  */
-export declare function parseValidity(input: string): IValidity;
+export declare function parseValidity(input: string, date?: Date): IValidityDated | IValidity;
 /**
  * Abstract class.
  * Base parser.
@@ -87,18 +87,25 @@ export declare class TAFParser extends AbstractParser {
      * @param lineTokens the array of tokens representing a line
      */
     parseLine(taf: ITAF, lineTokens: string[]): void;
+    /**
+     * 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: number, line: string[]): IValidity | undefined;
     /**
      * 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;
+    parseTrend(index: number, line: string[], trend: TAFTrend): void;
+    makeEmptyTAFTrend(): Omit<TAFTrend, "type" | "validity">;
 }
 export declare class RemarkParser {
     #private;
     private locale;
     constructor(locale: Locale);
-    parse(code: string): string[];
+    parse(code: string): Remark[];
 }

package/dist/parser/parser.js

@@ -32,10 +32,11 @@ 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_1 = require("../model/enum");
+const enum_2 = require("../model/enum");
 const metar_1 = require("../command/metar");
 const errors_1 = require("../commons/errors");
 /**
@@ -44,10 +45,15 @@ const errors_1 = require("../commons/errors");
  * @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: +timeString.slice(0, 2),
-        hour: +timeString.slice(2, 4),
-        minute: +timeString.slice(4, 6),
+        day,
+        hour,
+        minute,
     };
 }
 /**
@@ -59,7 +65,9 @@ function parseDeliveryTime(timeString) {
 function parseRemark(container, line, index, locale) {
     const remarks = new RemarkParser(locale).parse(line.slice(index + 1).join(" "));
     container.remarks = remarks;
-    container.remark = remarks.join(" ");
+    container.remark = remarks
+        .map(({ description, raw }) => description || raw)
+        .join(" ");
 }
 /**
  * Parses the temperature in a TAF
@@ -80,7 +88,7 @@ exports.parseTemperature = parseTemperature;
  * @param input the string containing the validity
  * @returns Validity object
  */
-function parseValidity(input) {
+function parseValidity(input, date) {
     const parts = (0, helpers_1.pySplit)(input, "/");
     return {
         startDay: +parts[0].slice(0, 2),
@@ -128,7 +136,7 @@ class AbstractParser {
                 intensity = match;
         }
         let descriptive;
-        for (const key of Object.values(enum_1.Descriptive)) {
+        for (const key of Object.values(enum_2.Descriptive)) {
             if (input.includes(key))
                 descriptive = key;
         }
@@ -137,7 +145,10 @@ class AbstractParser {
             descriptive,
             phenomenons: [],
         };
-        for (const key of Object.values(enum_1.Phenomenon)) {
+        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);
         }
@@ -154,7 +165,7 @@ class AbstractParser {
         // Hack for safari below...
         const splitRegex = /\s|=/;
         const smRegex = /^\d\/\dSM$/;
-        const digitRegex = /^\d$/;
+        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++) {
@@ -176,12 +187,11 @@ class AbstractParser {
     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;
+            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);
@@ -221,7 +231,7 @@ class MetarParser extends AbstractParser {
                 trendParts[i].startsWith(this.TL) ||
                 trendParts[i].startsWith(this.AT)) {
                 const trendTime = {
-                    type: enum_1.TimeIndicator[trendParts[i].slice(0, 2)],
+                    type: enum_2.TimeIndicator[trendParts[i].slice(0, 2)],
                     hour: +trendParts[i].slice(2, 4),
                     minute: +trendParts[i].slice(4, 6),
                 };
@@ -241,7 +251,7 @@ class MetarParser extends AbstractParser {
      */
     parse(input) {
         const metarTab = this.tokenize(input);
-        const metar = Object.assign(Object.assign({}, parseDeliveryTime(metarTab[1])), { station: metarTab[0], message: input, remark: "", remarks: [], clouds: [], weatherConditions: [], trends: [], runwaysInfo: [] });
+        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])) {
@@ -254,7 +264,7 @@ class MetarParser extends AbstractParser {
                 else if (metarTab[index] === this.TEMPO ||
                     metarTab[index] === this.BECMG) {
                     const trend = {
-                        type: enum_1.WeatherChangeType[metarTab[index]],
+                        type: enum_2.WeatherChangeType[metarTab[index]],
                         weatherConditions: [],
                         clouds: [],
                         times: [],
@@ -302,7 +312,7 @@ class TAFParser extends AbstractParser {
         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"');
+            throw new errors_1.InvalidWeatherStatementError('TAF report must begin with "TAF"');
         let index = 1;
         if (lines[0][1] === this.TAF)
             index = 2;
@@ -319,8 +329,10 @@ class TAFParser extends AbstractParser {
             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)
+            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))
@@ -375,22 +387,42 @@ class TAFParser extends AbstractParser {
         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]) });
+            trend = Object.assign(Object.assign({}, this.makeEmptyTAFTrend()), { type: enum_2.WeatherChangeType.FM, validity: parseFromValidity(lineTokens[0]) });
         }
         else if (lineTokens[0].startsWith(this.PROB)) {
-            trend = this.makeEmptyTAFTrend(enum_1.WeatherChangeType.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 = this.makeEmptyTAFTrend(enum_1.WeatherChangeType[lineTokens[1]]);
+                trend = Object.assign(Object.assign({}, this.makeEmptyTAFTrend()), { type: enum_2.WeatherChangeType[lineTokens[1]], validity });
                 index = 2;
             }
             trend.probability = +lineTokens[0].slice(4);
         }
         else {
-            trend = this.makeEmptyTAFTrend(enum_1.WeatherChangeType[lineTokens[0]]);
+            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
@@ -399,17 +431,19 @@ class TAFParser extends AbstractParser {
      */
     parseTrend(index, line, trend) {
         for (let i = index; i < line.length; i++) {
-            if (line[i] === this.RMK)
+            if (line[i] === this.RMK) {
                 parseRemark(trend, line, i, this.locale);
+                break;
+            }
+            // already parsed
             else if (__classPrivateFieldGet(this, _TAFParser_validityPattern, "f").test(line[i]))
-                trend.validity = parseValidity(line[i]);
+                continue;
             else
                 super.generalParse(trend, line[i]);
         }
     }
-    makeEmptyTAFTrend(type) {
+    makeEmptyTAFTrend() {
         return {
-            type,
             remarks: [],
             clouds: [],
             weatherConditions: [],
@@ -431,7 +465,7 @@ class RemarkParser {
                 [rmkStr, rmkList] = __classPrivateFieldGet(this, _RemarkParser_supplier, "f").get(rmkStr).execute(rmkStr, rmkList);
             }
             catch (e) {
-                if (e instanceof errors_1.TranslationError) {
+                if (e instanceof errors_1.CommandExecutionError) {
                     [rmkStr, rmkList] = __classPrivateFieldGet(this, _RemarkParser_supplier, "f").defaultCommand.execute(rmkStr, rmkList);
                 }
                 else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metar-taf-parser",
-  "version": "1.2.0",
+  "version": "2.0.0",
   "description": "Parse METAR and TAF reports",
   "homepage": "https://aeharding.github.io/metar-taf-parser",
   "keywords": [
@@ -21,7 +21,7 @@
     "url": "https://github.com/aeharding/metar-taf-parser.git"
   },
   "scripts": {
-    "build": "yarn clean; tsc --project tsconfig.build.json && tsc-alias",
+    "build": "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",
@@ -29,7 +29,7 @@
     "watch": "watch 'yarn build' src",
     "test": "jest --coverage",
     "test-watch": "jest --watch --coverage",
-    "prepublishOnly": "yarn build"
+    "prepublishOnly": "yarn clean && yarn build"
   },
   "files": [
     "dist",