metar-taf-parser 1.2.0 → 2.0.0

package/dist/commons/converter.d.ts

@@ -1,9 +1,21 @@
+import { Distance } from "../model/model";
 export declare function degreesToCardinal(input: number | string): string;
-export declare function convertVisibility(input: string): string;
+export declare function convertVisibility(input: string): Distance;
+/**
+ * @param input May start with P or M, and must end with SM
+ * @returns Distance
+ */
+export declare function convertNauticalMilesVisibility(input: string): Distance;
+/**
+ * Converts fractional and/or whole amounts
+ *
+ * Example "1/3", "1 1/3" and "1"
+ */
+export declare function convertFractionalAmount(input: string): number;
 export declare function convertTemperature(input: string): number;
 export declare function convertInchesMercuryToPascal(input: number): number;
 /**
  * Converts number `.toFixed(1)` before outputting to match python implementation
  */
-export declare function convertTemperatureRemarks(sign: string, temperature: string): string;
+export declare function convertTemperatureRemarks(sign: string, temperature: string): number;
 export declare function convertPrecipitationAmount(amount: string): number;

package/dist/commons/converter.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertPrecipitationAmount = exports.convertTemperatureRemarks = exports.convertInchesMercuryToPascal = exports.convertTemperature = exports.convertVisibility = exports.degreesToCardinal = void 0;
+exports.convertPrecipitationAmount = exports.convertTemperatureRemarks = exports.convertInchesMercuryToPascal = exports.convertTemperature = exports.convertFractionalAmount = exports.convertNauticalMilesVisibility = exports.convertVisibility = exports.degreesToCardinal = void 0;
 const helpers_1 = require("../helpers/helpers");
+const enum_1 = require("../model/enum");
 function degreesToCardinal(input) {
     const degrees = +input;
     if (isNaN(degrees))
@@ -30,10 +31,57 @@ function degreesToCardinal(input) {
 exports.degreesToCardinal = degreesToCardinal;
 function convertVisibility(input) {
     if (input === "9999")
-        return "> 10km";
-    return `${+input}m`;
+        return {
+            indicator: enum_1.ValueIndicator.GreaterThan,
+            value: +input,
+            unit: enum_1.DistanceUnit.Meters,
+        };
+    return {
+        value: +input,
+        unit: enum_1.DistanceUnit.Meters,
+    };
 }
 exports.convertVisibility = convertVisibility;
+/**
+ * @param input May start with P or M, and must end with SM
+ * @returns Distance
+ */
+function convertNauticalMilesVisibility(input) {
+    let indicator;
+    let index = 0;
+    if (input.startsWith("P")) {
+        indicator = enum_1.ValueIndicator.GreaterThan;
+        index = 1;
+    }
+    else if (input.startsWith("M")) {
+        indicator = enum_1.ValueIndicator.LessThan;
+        index = 1;
+    }
+    return {
+        indicator,
+        value: convertFractionalAmount(input.slice(index, -2)),
+        unit: enum_1.DistanceUnit.StatuteMiles,
+    };
+}
+exports.convertNauticalMilesVisibility = convertNauticalMilesVisibility;
+/**
+ * Converts fractional and/or whole amounts
+ *
+ * Example "1/3", "1 1/3" and "1"
+ */
+function convertFractionalAmount(input) {
+    const [whole, fraction] = input.split(" ");
+    if (!fraction)
+        return parseFraction(whole);
+    return +whole + parseFraction(fraction);
+}
+exports.convertFractionalAmount = convertFractionalAmount;
+function parseFraction(input) {
+    const [top, bottom] = input.split("/");
+    if (!bottom)
+        return +top;
+    return Math.round((+top / +bottom) * 100) / 100;
+}
 function convertTemperature(input) {
     if (input.startsWith("M"))
         return -(0, helpers_1.pySplit)(input, "M")[1];
@@ -50,8 +98,8 @@ exports.convertInchesMercuryToPascal = convertInchesMercuryToPascal;
 function convertTemperatureRemarks(sign, temperature) {
     const temp = +temperature / 10;
     if (sign === "0")
-        return temp.toFixed(1);
-    return (-temp).toFixed(1);
+        return temp;
+    return -temp;
 }
 exports.convertTemperatureRemarks = convertTemperatureRemarks;
 function convertPrecipitationAmount(amount) {

package/dist/commons/errors.d.ts

@@ -7,9 +7,13 @@ export declare class InvalidWeatherStatementError extends ParseError {
     cause?: unknown;
     constructor(cause?: unknown);
 }
-export declare class TranslationError extends ParseError {
+/**
+ * Thrown when command marked as canParse, but couldn't parse when
+ * executing (for example, an invalid CloudQuantity)
+ */
+export declare class CommandExecutionError extends ParseError {
     name: string;
-    constructor(missingLocale: string);
+    constructor(message: string);
 }
 /**
  * Should never occur

package/dist/commons/errors.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UnexpectedParseError = exports.TranslationError = exports.InvalidWeatherStatementError = exports.ParseError = void 0;
+exports.UnexpectedParseError = exports.CommandExecutionError = exports.InvalidWeatherStatementError = exports.ParseError = void 0;
 class ParseError extends Error {
     constructor(message) {
         super(message);
@@ -11,21 +11,28 @@ class ParseError extends Error {
 exports.ParseError = ParseError;
 class InvalidWeatherStatementError extends ParseError {
     constructor(cause) {
-        super(`Invalid weather string.`);
+        super(typeof cause === "string"
+            ? `Invalid weather string: ${cause}`
+            : "Invalid weather string");
         this.name = "InvalidWeatherStatementError";
         Object.setPrototypeOf(this, new.target.prototype);
-        this.cause = cause;
+        if (typeof cause !== "string")
+            this.cause = cause;
     }
 }
 exports.InvalidWeatherStatementError = InvalidWeatherStatementError;
-class TranslationError extends ParseError {
-    constructor(missingLocale) {
-        super(`Missing translation "${missingLocale}"`);
-        this.name = "TranslationError";
+/**
+ * Thrown when command marked as canParse, but couldn't parse when
+ * executing (for example, an invalid CloudQuantity)
+ */
+class CommandExecutionError extends ParseError {
+    constructor(message) {
+        super(message);
+        this.name = "CommandExecutionError";
         Object.setPrototypeOf(this, new.target.prototype);
     }
 }
-exports.TranslationError = TranslationError;
+exports.CommandExecutionError = CommandExecutionError;
 /**
  * Should never occur
  */

package/dist/commons/i18n.d.ts

@@ -8,5 +8,5 @@ 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;
+export declare function _(path: Join<PathsToStringProps<typeof en>, ".">, lang: Locale): string | undefined;
+export declare function format(message: string | undefined, ...args: unknown[]): string | undefined;

package/dist/commons/i18n.js

@@ -6,19 +6,25 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.format = exports._ = void 0;
 const en_1 = __importDefault(require("../locale/en"));
 const helpers_1 = require("../helpers/helpers");
-const errors_1 = require("./errors");
 exports.default = en_1.default;
 function _(path, lang) {
     const translation = (0, helpers_1.resolve)(lang, path);
     if (!translation || typeof translation !== "string")
-        throw new errors_1.TranslationError(path);
+        return undefined;
     return translation;
 }
 exports._ = _;
 function format(message, ...args) {
+    if (!message)
+        return;
+    // All arguments must be defined, otherwise nothing is returned
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === undefined)
+            return;
+    }
     return message.replace(/{\d+}/g, (match) => {
         const index = +match.slice(1, -1);
-        return args[index] !== undefined ? `${args[index]}` : "";
+        return `${args[index]}`;
     });
 }
 exports.format = format;

package/dist/dates/metar.d.ts

@@ -0,0 +1,5 @@
+import { IMetar } from "../model/model";
+export interface IMetarDated extends IMetar {
+    issued: Date;
+}
+export declare function metarDatesHydrator(report: IMetar, date: Date): IMetarDated;

package/dist/dates/metar.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.metarDatesHydrator = void 0;
+const date_1 = require("../helpers/date");
+function metarDatesHydrator(report, date) {
+    return Object.assign(Object.assign({}, report), { issued: (0, date_1.determineReportIssuedDate)(date, report.day, report.hour, report.minute) });
+}
+exports.metarDatesHydrator = metarDatesHydrator;

package/dist/dates/taf.d.ts

@@ -0,0 +1,28 @@
+import { WeatherChangeType } from "../model/enum";
+import { IAbstractTrend, IFMValidity, ITAF, IBaseTAFTrend, IValidity } from "../model/model";
+export declare type TAFTrendDated = IAbstractTrend & IBaseTAFTrend & {
+    validity: IBaseTAFTrend["validity"] & {
+        start: Date;
+        end?: Date;
+    };
+} & ({
+    type: WeatherChangeType.FM;
+    validity: IFMValidity & {
+        start: Date;
+    };
+} | {
+    type: WeatherChangeType;
+    validity: IValidity & {
+        start: Date;
+        end: Date;
+    };
+});
+export interface ITAFDated extends ITAF {
+    issued: Date;
+    validity: ITAF["validity"] & {
+        start: Date;
+        end: Date;
+    };
+    trends: TAFTrendDated[];
+}
+export declare function tafDatesHydrator(report: ITAF, date: Date): ITAFDated;

package/dist/dates/taf.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tafDatesHydrator = void 0;
+const enum_1 = require("../model/enum");
+const date_1 = require("../helpers/date");
+function tafDatesHydrator(report, date) {
+    const issued = (0, date_1.determineReportIssuedDate)(date, report.day, report.hour, report.minute);
+    return Object.assign(Object.assign({}, report), { issued, validity: Object.assign(Object.assign({}, report.validity), { start: (0, date_1.getReportDate)(issued, report.validity.startDay, report.validity.startHour), end: (0, date_1.getReportDate)(issued, report.validity.endDay, report.validity.endHour) }), trends: report.trends.map((trend) => (Object.assign(Object.assign({}, trend), { validity: (() => {
+                switch (trend.type) {
+                    case enum_1.WeatherChangeType.FM:
+                        return Object.assign(Object.assign({}, trend.validity), { start: (0, date_1.getReportDate)(issued, trend.validity.startDay, trend.validity.startHour, trend.validity.startMinutes) });
+                    default:
+                        return Object.assign(Object.assign({}, trend.validity), { start: (0, date_1.getReportDate)(issued, trend.validity.startDay, trend.validity.startHour), end: (0, date_1.getReportDate)(issued, trend.validity.endDay, trend.validity.endHour) });
+                }
+            })() }))) });
+}
+exports.tafDatesHydrator = tafDatesHydrator;

package/dist/forecast/forecast.d.ts

@@ -0,0 +1,36 @@
+import { TAFTrendDated } from "../dates/taf";
+import { ITAFDated } from "../dates/taf";
+import { ParseError } from "../commons/errors";
+/**
+ * The initial forecast, extracted from the first line of the TAF, does not have
+ * a trend type (FM, BECMG, etc)
+ */
+export declare type Forecast = Omit<TAFTrendDated, "type"> & Partial<Pick<TAFTrendDated, "type">>;
+export interface IForecastContainer {
+    station: string;
+    issued: Date;
+    start: Date;
+    end: Date;
+    message: string;
+    forecast: Forecast[];
+}
+export declare function getForecastFromTAF(taf: ITAFDated): IForecastContainer;
+export interface ICompositeForecast {
+    /**
+     * The base forecast (type is `FM` or initial group)
+     */
+    base: Forecast;
+    /**
+     * Any forecast here should pre-empt the base forecast. These forecasts may
+     * have probabilities of occuring, be temporary, or otherwise notable
+     * precipitation events
+     *
+     * `type` is (`BECMG`, `TEMPO` or `PROB`)
+     */
+    additional: Forecast[];
+}
+export declare class TimestampOutOfBoundsError extends ParseError {
+    name: string;
+    constructor(message?: string);
+}
+export declare function getCompositeForecastForDate(date: Date, forecastContainer: IForecastContainer): ICompositeForecast;

package/dist/forecast/forecast.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCompositeForecastForDate = exports.TimestampOutOfBoundsError = exports.getForecastFromTAF = void 0;
+const date_1 = require("../helpers/date");
+const errors_1 = require("../commons/errors");
+function getForecastFromTAF(taf) {
+    return {
+        issued: taf.issued,
+        station: taf.station,
+        message: taf.message,
+        start: (0, date_1.getReportDate)(taf.issued, taf.validity.startDay, taf.validity.startHour),
+        end: (0, date_1.getReportDate)(taf.issued, taf.validity.endDay, taf.validity.endHour),
+        forecast: [makeInitialForecast(taf), ...taf.trends],
+    };
+}
+exports.getForecastFromTAF = getForecastFromTAF;
+/**
+ * Treat the base of the TAF as a FM
+ */
+function makeInitialForecast(taf) {
+    return {
+        wind: taf.wind,
+        visibility: taf.visibility,
+        verticalVisibility: taf.verticalVisibility,
+        windShear: taf.windShear,
+        cavok: taf.cavok,
+        remark: taf.remark,
+        remarks: taf.remarks,
+        clouds: taf.clouds,
+        weatherConditions: taf.weatherConditions,
+        validity: {
+            // End day/hour are for end of the entire TAF
+            startDay: taf.validity.startDay,
+            startHour: taf.validity.startHour,
+            startMinutes: 0,
+            start: taf.validity.start,
+        },
+    };
+}
+class TimestampOutOfBoundsError extends errors_1.ParseError {
+    constructor(message) {
+        super(message);
+        this.name = "TimestampOutOfBoundsError";
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.TimestampOutOfBoundsError = TimestampOutOfBoundsError;
+function getCompositeForecastForDate(date, forecastContainer) {
+    // Validity bounds check
+    if (date.getTime() > forecastContainer.end.getTime() ||
+        date.getTime() < forecastContainer.start.getTime())
+        throw new TimestampOutOfBoundsError("Provided timestamp is outside the report validity period");
+    let base;
+    let additional = [];
+    for (let i = 0; i < forecastContainer.forecast.length; i++) {
+        const forecast = forecastContainer.forecast[i];
+        if (!forecast.validity.end &&
+            forecast.validity.start.getTime() <= date.getTime()) {
+            // Is FM or initial forecast
+            base = forecast;
+        }
+        if (forecast.validity.end &&
+            forecast.validity.end.getTime() - date.getTime() > 0 &&
+            forecast.validity.start.getTime() - date.getTime() <= 0) {
+            // Is BECMG or TEMPO
+            additional.push(forecast);
+        }
+    }
+    if (!base)
+        throw new errors_1.UnexpectedParseError("Unable to find trend for date");
+    return { base, additional };
+}
+exports.getCompositeForecastForDate = getCompositeForecastForDate;

package/dist/helpers/date.d.ts

@@ -0,0 +1,11 @@
+/**
+ *
+ * @param date Ideally the date the report was issued. However, any date within
+ * ~14 days of the report will work.
+ * @param day Day of the month (from the report)
+ * @param hour Hour (from the report)
+ * @param minute Minute (from the report)
+ * @returns
+ */
+export declare function determineReportIssuedDate(date: Date, day: number, hour: number, minute?: number): Date;
+export declare function getReportDate(issued: Date, day: number, hour: number, minute?: number): Date;

package/dist/helpers/date.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getReportDate = exports.determineReportIssuedDate = void 0;
+/**
+ *
+ * @param date Ideally the date the report was issued. However, any date within
+ * ~14 days of the report will work.
+ * @param day Day of the month (from the report)
+ * @param hour Hour (from the report)
+ * @param minute Minute (from the report)
+ * @returns
+ */
+function determineReportIssuedDate(date, day, hour, minute) {
+    const months = [
+        setDateComponents(addMonthsUTC(date, -1), day, hour, minute),
+        setDateComponents(new Date(date), day, hour, minute),
+        setDateComponents(addMonthsUTC(date, 1), day, hour, minute),
+    ];
+    return months
+        .map((d) => ({
+        date: d,
+        difference: Math.abs(d.getTime() - date.getTime()),
+    }))
+        .sort((a, b) => a.difference - b.difference)[0].date;
+}
+exports.determineReportIssuedDate = determineReportIssuedDate;
+function getReportDate(issued, day, hour, minute = 0) {
+    let date = new Date(issued);
+    if (day < date.getUTCDate()) {
+        date = addMonthsUTC(date, 1);
+    }
+    date.setUTCDate(day);
+    date.setUTCHours(hour);
+    if (minute != null)
+        date.setUTCMinutes(minute);
+    return date;
+}
+exports.getReportDate = getReportDate;
+function setDateComponents(date, day, hour, minute) {
+    date.setUTCDate(day);
+    date.setUTCHours(hour);
+    if (minute != null)
+        date.setUTCMinutes(minute);
+    return date;
+}
+function addMonthsUTC(date, count) {
+    if (date && count) {
+        let m, d = (date = new Date(+date)).getUTCDate();
+        date.setUTCMonth(date.getUTCMonth() + count, 1);
+        m = date.getUTCMonth();
+        date.setUTCDate(d);
+        if (date.getUTCMonth() !== m)
+            date.setUTCDate(0);
+    }
+    return date;
+}

package/dist/helpers/helpers.d.ts

@@ -8,3 +8,10 @@ export declare function pySplit(string: string, separator: string, n?: number):
  * https://stackoverflow.com/a/22129960
  */
 export declare function resolve(obj: any, path: string | string[], separator?: string): unknown;
+/**
+ * For safely casting input values
+ * @param input String that is expected to be in the snum
+ * @param enumExpected The enum to cast the input value to
+ * @throws RemarkExecutionError when input is not a key of enum
+ */
+export declare function as<T extends Record<string, unknown>>(input: string, enumExpected: T): T[keyof T];

package/dist/helpers/helpers.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolve = exports.pySplit = void 0;
+exports.as = exports.resolve = exports.pySplit = void 0;
+const errors_1 = require("../commons/errors");
 /**
  * Split behaving similar to Python's implementation
  */
@@ -31,3 +32,15 @@ function resolve(obj, path, separator = ".") {
     return properties.reduce((prev, curr) => prev === null || prev === void 0 ? void 0 : prev[curr], obj);
 }
 exports.resolve = resolve;
+/**
+ * For safely casting input values
+ * @param input String that is expected to be in the snum
+ * @param enumExpected The enum to cast the input value to
+ * @throws RemarkExecutionError when input is not a key of enum
+ */
+function as(input, enumExpected) {
+    if (!Object.values(enumExpected).includes(input))
+        throw new errors_1.CommandExecutionError(`${input} not found in ${Object.values(enumExpected)}`);
+    return input;
+}
+exports.as = as;

package/dist/index.d.ts

@@ -1,11 +1,32 @@
 import { IMetar, ITAF } from "./model/model";
 import { Locale } from "./commons/i18n";
+import { IMetarDated } from "./dates/metar";
+import { ITAFDated } from "./dates/taf";
+import { IForecastContainer } from "./forecast/forecast";
 export { Locale } from "./commons/i18n";
 export * from "./commons/errors";
 export * from "./model/model";
 export * from "./model/enum";
+export { RemarkType, IBaseRemark, IUnknownRemark, Remark, ICeilingHeightRemark, ICeilingSecondLocationRemark, IHourlyMaximumMinimumTemperatureRemark, IHourlyMaximumTemperatureRemark, IHourlyMinimumTemperatureRemark, IHourlyPrecipitationAmountRemark, IHourlyPressureRemark, IHourlyTemperatureDewPointRemark, IIceAccretionRemark, IObscurationRemark, IPrecipitationAmount24HourRemark, IPrecipitationAmount36HourRemark, IPrecipitationBegEndRemark, IPrevailingVisibilityRemark, ISeaLevelPressureRemark, ISecondLocationVisibilityRemark, ISectorVisibilityRemark, ISmallHailSizeRemark, ISnowIncreaseRemark, ISnowPelletsRemark, ISunshineDurationRemark, ISurfaceVisibilityRemark, IThunderStormLocationRemark, IThunderStormLocationMovingRemark, ITornadicActivityBegRemark, ITornadicActivityBegEndRemark, ITornadicActivityEndRemark, ITowerVisibilityRemark, IVariableSkyRemark, IVariableSkyHeightRemark, IVirgaDirectionRemark, IWaterEquivalentSnowRemark, IWindPeakCommandRemark, IWindShiftFropaRemark, } from "./command/remark";
+export { getCompositeForecastForDate, IForecastContainer, ICompositeForecast, Forecast, TimestampOutOfBoundsError, } from "./forecast/forecast";
+export { TAFTrendDated } from "./dates/taf";
 export interface IMetarTAFParserOptions {
     locale?: Locale;
 }
-export declare function parseMetar(metar: string, options?: IMetarTAFParserOptions): IMetar;
-export declare function parseTAF(taf: string, options?: IMetarTAFParserOptions): ITAF;
+export interface IMetarTAFParserOptionsDated extends IMetarTAFParserOptions {
+    /**
+     * This date should ideally be the date the report was issued. Otherwise, it
+     * can be be +/- one week of the actual report date and work properly.
+     *
+     * So if you know the report was recently issued, you can pass `new Date()`
+     *
+     * This date is needed to create actual timestamps since the report only has
+     * day of month, hour, and minute.
+     */
+    date: Date;
+}
+export declare function parseMetar(rawMetar: string, options?: IMetarTAFParserOptions): IMetar;
+export declare function parseMetar(rawMetar: string, options?: IMetarTAFParserOptionsDated): IMetarDated;
+export declare function parseTAF(rawTAF: string, options?: IMetarTAFParserOptions): ITAF;
+export declare function parseTAF(rawTAF: string, options?: IMetarTAFParserOptionsDated): ITAFDated;
+export declare function parseTAFAsForecast(rawTAF: string, options: IMetarTAFParserOptionsDated): IForecastContainer;

package/dist/index.js

@@ -17,25 +17,42 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseTAF = exports.parseMetar = void 0;
+exports.parseTAFAsForecast = exports.parseTAF = exports.parseMetar = exports.TimestampOutOfBoundsError = exports.getCompositeForecastForDate = exports.RemarkType = void 0;
 const parser_1 = require("./parser/parser");
 const errors_1 = require("./commons/errors");
 const en_1 = __importDefault(require("./locale/en"));
+const metar_1 = require("./dates/metar");
+const taf_1 = require("./dates/taf");
+const forecast_1 = require("./forecast/forecast");
 __exportStar(require("./commons/errors"), exports);
 __exportStar(require("./model/model"), exports);
 __exportStar(require("./model/enum"), exports);
-function parseMetar(metar, options) {
-    return parse(metar, options, parser_1.MetarParser);
+var remark_1 = require("./command/remark");
+Object.defineProperty(exports, "RemarkType", { enumerable: true, get: function () { return remark_1.RemarkType; } });
+var forecast_2 = require("./forecast/forecast");
+Object.defineProperty(exports, "getCompositeForecastForDate", { enumerable: true, get: function () { return forecast_2.getCompositeForecastForDate; } });
+Object.defineProperty(exports, "TimestampOutOfBoundsError", { enumerable: true, get: function () { return forecast_2.TimestampOutOfBoundsError; } });
+function parseMetar(rawMetar, options) {
+    return parse(rawMetar, options, parser_1.MetarParser, metar_1.metarDatesHydrator);
 }
 exports.parseMetar = parseMetar;
-function parseTAF(taf, options) {
-    return parse(taf, options, parser_1.TAFParser);
+function parseTAF(rawTAF, options) {
+    return parse(rawTAF, options, parser_1.TAFParser, taf_1.tafDatesHydrator);
 }
 exports.parseTAF = parseTAF;
-function parse(report, options, parser) {
+function parseTAFAsForecast(rawTAF, options) {
+    const taf = parseTAF(rawTAF, options);
+    return (0, forecast_1.getForecastFromTAF)(taf);
+}
+exports.parseTAFAsForecast = parseTAFAsForecast;
+function parse(rawReport, options, parser, datesHydrator) {
     const lang = (options === null || options === void 0 ? void 0 : options.locale) || en_1.default;
     try {
-        return new parser(lang).parse(report);
+        const report = new parser(lang).parse(rawReport);
+        if (options && "date" in options) {
+            return datesHydrator(report, options.date);
+        }
+        return report;
     }
     catch (e) {
         if (e instanceof errors_1.ParseError)

package/dist/model/enum.d.ts

@@ -111,6 +111,7 @@ export declare enum Phenomenon {
     SPRAY = "PY",
     SQUALL = "SQ",
     SAND_WHIRLS = "PO",
+    THUNDERSTORM = "TS",
     DUSTSTORM = "DS",
     SANDSTORM = "SS",
     FUNNEL_CLOUD = "FC"
@@ -219,3 +220,46 @@ export declare enum WeatherChangeType {
      */
     PROB = "PROB"
 }
+export declare enum Direction {
+    E = "E",
+    ENE = "ENE",
+    ESE = "ESE",
+    N = "N",
+    NE = "NE",
+    NNE = "NNE",
+    NNW = "NNW",
+    NW = "NW",
+    S = "S",
+    SE = "SE",
+    SSE = "SSE",
+    SSW = "SSW",
+    SW = "SW",
+    W = "W",
+    WNW = "WNW",
+    WSW = "WSW"
+}
+export declare enum DistanceUnit {
+    Meters = "m",
+    StatuteMiles = "SM"
+}
+/**
+ * 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
+ */
+export declare enum ValueIndicator {
+    GreaterThan = "P",
+    LessThan = "M"
+}
+export declare enum RunwayInfoTrend {
+    Uprising = "U",
+    Decreasing = "D",
+    NoSignificantChange = "N"
+}
+export declare enum RunwayInfoUnit {
+    Feet = "FT",
+    Meters = "m"
+}