atmosx-nwws-parser 1.0.2

package/src/parsers/types/cap.ts

@@ -0,0 +1,89 @@
+/*
+                                            _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ V / 
+       / /\ \| __| "_ ` _ \ / _ \/ __| "_ \| "_ \ / _ \ "__| |/ __| > <  
+      / ____ \ |_| | | | | | (_) \__ \ |_) | | | |  __/ |  | | (__ / . \ 
+     /_/    \_\__|_| |_| |_|\___/|___/ .__/|_| |_|\___|_|  |_|\___/_/ \_\
+                                     | |                                 
+                                     |_|                                                                                                                
+    
+    Written by: KiyoWx (k3yomi)                
+*/
+
+import * as types from '../../types';
+import * as loader from '../../bootstrap';
+import EventParser from '../events';
+import TextParser from '../text';
+
+
+export class CapAlerts {
+
+    private static getTracking(extracted: Record<string, string>) {
+        return extracted.vtec ? (() => {
+            const vtecValue = Array.isArray(extracted.vtec) ? extracted.vtec[0] : extracted.vtec;
+            const splitVTEC = vtecValue.split('.');
+            return `${splitVTEC[2]}-${splitVTEC[3]}-${splitVTEC[4]}-${splitVTEC[5]}`;
+        })() : `${extracted.wmoidentifier} (${extracted.ugc})`;
+    }
+
+    public static async event(validated: types.TypeCompiled) {
+        let processed = [] as unknown[];
+        const messages = validated.message.match(/<\?xml[\s\S]*?<\/alert>/g)?.map(msg => msg.trim());
+        if (messages == null || messages.length === 0) return;
+        for (let message of messages) {
+            const tick = performance.now();
+            message = message.substring(message.indexOf(`<?xml version="1.0"`), message.lastIndexOf(`>`) + 1);
+            const parser = new loader.packages.xml2js.Parser({ explicitArray: false, mergeAttrs: true, trim: true })
+            const parsed = await parser.parseStringPromise(message);
+            if (parsed == null || parsed.alert == null) continue;
+            const extracted = TextParser.getXmlValues(parsed, [
+                `vtec`, `wmoidentifier`, `ugc`, `areadesc`, 
+                `expires`, `sent`, `msgtype`, `description`,
+                `event`, `sendername`, `tornadodetection`, `polygon`,
+                `maxHailSize`, `maxWindGust`, `thunderstormdamagethreat`,
+                `tornadodamagethreat`, `waterspoutdetection`, `flooddetection`,
+            ]);
+            const getHeader = EventParser.getHeader({ ...validated.attributes,} as types.TypeAttributes);
+            const getSource = TextParser.textProductToString(extracted.description, `SOURCE...`, [`.`]) || `N/A`;
+            processed.push({
+                preformance: performance.now() - tick,
+                tracking: this.getTracking(extracted),
+                header: getHeader,
+                vtec: extracted.vtec || `N/A`,
+                history: [{ description: extracted.description || `N/A`, issued: extracted.sent ? new Date(extracted.sent).toLocaleString() : `N/A`, type: extracted.msgtype || `N/A` }],
+                properties: {
+                    locations: extracted.areadesc || `N/A`,
+                    event: extracted.event || `N/A`,
+                    issued: extracted.sent ? new Date(extracted.sent).toLocaleString() : `N/A`,
+                    expires: extracted.expires ? new Date(extracted.expires).toLocaleString() : `N/A`,
+                    parent: extracted.event || `N/A`,
+                    action_type: extracted.msgtype || `N/A`,
+                    description: extracted.description || `N/A`,
+                    sender_name: extracted.sendername || `N/A`,
+                    sender_icao: extracted.wmoidentifier ? extracted.wmoidentifier.substring(extracted.wmoidentifier.length - 4) : `N/A`,
+                    attributes: validated.attributes,
+                    geocode: {
+                        UGC: [extracted.ugc],
+                    },
+                    parameters: {
+                        wmo: extracted.wmoidentifier || `N/A`,
+                        source: getSource,
+                        max_hail_size: extracted.maxHailSize || `N/A`,
+                        max_wind_gust: extracted.maxWindGust || `N/A`,
+                        damage_threat: extracted.thunderstormdamagethreat || `N/A`,
+                        tornado_detection: extracted.tornadodetection || extracted.waterspoutdetection || `N/A`,
+                        flood_detection: extracted.flooddetection || `N/A`,
+                        discussion_tornado_intensity: `N/A`,
+                        discussion_wind_intensity: `N/A`,
+                        discussion_hail_intensity: `N/A`,
+                    },
+                    geometry: extracted.polygon ? { type: `Polygon`, coordinates: extracted.polygon.split(` `).map((coord: string) => coord.split(`,`).map((num: string) => parseFloat(num))) } : null,
+                }
+            })
+        }
+        EventParser.validateEvents(processed);
+    }
+}
+
+export default CapAlerts;

package/src/parsers/types/text.ts

@@ -0,0 +1,54 @@
+/*
+                                            _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ V / 
+       / /\ \| __| "_ ` _ \ / _ \/ __| "_ \| "_ \ / _ \ "__| |/ __| > <  
+      / ____ \ |_| | | | | | (_) \__ \ |_) | | | |  __/ |  | | (__ / . \ 
+     /_/    \_\__|_| |_| |_|\___/|___/ .__/|_| |_|\___|_|  |_|\___/_/ \_\
+                                     | |                                 
+                                     |_|                                                                                                                
+    
+    Written by: KiyoWx (k3yomi)                
+*/
+
+import * as types from '../../types';
+import * as loader from '../../bootstrap';
+import EventParser from '../events';
+
+
+export class UGCAlerts {
+
+    private static getTracking(baseProperties: types.BaseProperties) {
+        return `${baseProperties.sender_icao}`
+    }
+
+    private static getEvent(message: string, attributes: Record<string, any>) {
+        const offshoreEvent = Object.keys(loader.definitions.offshore).find(event => message.toLowerCase().includes(event.toLowerCase()));
+        if (offshoreEvent) return Object.keys(loader.definitions.offshore).find(event => message.toLowerCase().includes(event.toLowerCase()));
+        return attributes.type.split(`-`).map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(` `)
+    }
+    
+    public static async event(validated: types.TypeCompiled) {
+        let processed = [] as unknown[];
+        const messages = validated.message.split(/(?=\$\$|ISSUED TIME...|=================================================)/g)?.map(msg => msg.trim());
+        if (!messages || messages.length == 0) return;
+        for (let i = 0; i < messages.length; i++) {
+            const tick = performance.now();
+            const message = messages[i]
+            const getBaseProperties = await EventParser.getBaseProperties(message, validated) as types.BaseProperties;
+            const getHeader = EventParser.getHeader({ ...validated.attributes, ...getBaseProperties.attributes } as types.TypeAttributes, getBaseProperties);
+            const getEvent = this.getEvent(message, getBaseProperties.attributes.getAwip);
+            processed.push({
+                preformance: performance.now() - tick,
+                tracking: this.getTracking(getBaseProperties),
+                header: getHeader,
+                vtec: `N/A`,
+                history: [{ description: getBaseProperties.description, issued: getBaseProperties.issued, type: `Issued` }],
+                properties: { event: getEvent, parent: getEvent, action_type: `Issued`, ...getBaseProperties, }
+            })
+        }
+        EventParser.validateEvents(processed);
+    }
+}
+
+export default UGCAlerts;

package/src/parsers/types/ugc.ts

@@ -0,0 +1,85 @@
+/*
+                                            _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ V / 
+       / /\ \| __| "_ ` _ \ / _ \/ __| "_ \| "_ \ / _ \ "__| |/ __| > <  
+      / ____ \ |_| | | | | | (_) \__ \ |_) | | | |  __/ |  | | (__ / . \ 
+     /_/    \_\__|_| |_| |_|\___/|___/ .__/|_| |_|\___|_|  |_|\___/_/ \_\
+                                     | |                                 
+                                     |_|                                                                                                                
+    
+    Written by: KiyoWx (k3yomi)                
+*/
+
+import * as types from '../../types';
+import * as loader from '../../bootstrap';
+import UgcParser from '../ugc';
+import EventParser from '../events';
+
+
+export class UGCAlerts {
+    
+    /**
+     * getTracking generates a unique tracking identifier based on the sender's ICAO code and a hash of the UGC zones.
+     *
+     * @private
+     * @static
+     * @param {types.BaseProperties} baseProperties 
+     * @param {string[]} zones 
+     * @returns {string} 
+     */
+    private static getTracking(baseProperties: types.BaseProperties, zones: string[]) {
+        return `${baseProperties.sender_icao} (${loader.packages.crypto.createHash('md5').update(zones.join(``)).digest('hex')}})`
+    }
+    
+    /**
+     * getEvent determines the event name based on offshore definitions or formats it from the attributes.
+     *
+     * @private
+     * @static
+     * @param {string} message 
+     * @param {Record<string, any>} attributes 
+     * @returns {*} 
+     */
+    private static getEvent(message: string, attributes: Record<string, any>) {
+        const offshoreEvent = Object.keys(loader.definitions.offshore).find(event => message.toLowerCase().includes(event.toLowerCase()));
+        if (offshoreEvent != undefined ) return Object.keys(loader.definitions.offshore).find(event => message.toLowerCase().includes(event.toLowerCase()));
+        return attributes.type.split(`-`).map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(` `)
+    }
+    
+    /**
+     * event processes validated UGC alert messages, extracting relevant information and compiling it into structured event objects.
+     *
+     * @public
+     * @static
+     * @async
+     * @param {types.TypeCompiled} validated 
+     * @returns {*} 
+     */
+    public static async event(validated: types.TypeCompiled) {
+        let processed = [] as unknown[];
+        const messages = validated.message.split(/(?=\$\$|ISSUED TIME...|=================================================)/g)?.map(msg => msg.trim());
+        if (!messages || messages.length == 0) return;
+        for (let i = 0; i < messages.length; i++) {
+            const tick = performance.now();
+            const message = messages[i]
+            const getUGC = await UgcParser.ugcExtractor(message) as types.UGCParsed;
+            if (getUGC != null) {
+                const getBaseProperties = await EventParser.getBaseProperties(message, validated, getUGC) as types.BaseProperties;
+                const getHeader = EventParser.getHeader({ ...validated.attributes, ...getBaseProperties.attributes } as types.TypeAttributes, getBaseProperties);
+                const getEvent = this.getEvent(message, getBaseProperties.attributes.getAwip);
+                processed.push({
+                    preformance: performance.now() - tick,
+                    tracking: this.getTracking(getBaseProperties, getUGC.zones),
+                    header: getHeader,
+                    vtec: `N/A`,
+                    history: [{ description: getBaseProperties.description, issued: getBaseProperties.issued, type: `Issued` }],
+                    properties: { event: getEvent, parent: getEvent, action_type: `Issued`, ...getBaseProperties, }
+                })
+            }
+        }
+        EventParser.validateEvents(processed);
+    }
+}
+
+export default UGCAlerts;

package/src/parsers/types/vtec.ts

@@ -0,0 +1,60 @@
+/*
+                                            _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ V / 
+       / /\ \| __| "_ ` _ \ / _ \/ __| "_ \| "_ \ / _ \ "__| |/ __| > <  
+      / ____ \ |_| | | | | | (_) \__ \ |_) | | | |  __/ |  | | (__ / . \ 
+     /_/    \_\__|_| |_| |_|\___/|___/ .__/|_| |_|\___|_|  |_|\___/_/ \_\
+                                     | |                                 
+                                     |_|                                                                                                                
+    
+    Written by: KiyoWx (k3yomi)                
+*/
+
+import * as types from '../../types';
+import VtecParser from '../vtec';
+import UgcParser from '../ugc';
+import EventParser from '../events';
+
+
+export class VTECAlerts {
+
+    /**
+     * event processes validated VTEC alert messages, extracting relevant information and compiling it into structured event objects.
+     *
+     * @public
+     * @static
+     * @async
+     * @param {types.TypeCompiled} validated 
+     * @returns {*} 
+     */
+    public static async event(validated: types.TypeCompiled) {
+        let processed = [] as unknown[];
+        const messages = validated.message.split(/(?=\$\$)/g)?.map(msg => msg.trim());
+        if (!messages || messages.length == 0) return;
+        for (let i = 0; i < messages.length; i++) {
+            const tick = performance.now();
+            const message = messages[i]
+            const getVTEC = await VtecParser.vtecExtractor(message) as types.VTECParsed[];
+            const getUGC = await UgcParser.ugcExtractor(message) as types.UGCParsed;
+            if (getVTEC != null && getUGC != null) {
+                for (let j = 0; j < getVTEC.length; j++) {
+                    const vtec = getVTEC[j];
+                    const getBaseProperties = await EventParser.getBaseProperties(message, validated, getUGC, vtec) as types.BaseProperties;
+                    const getHeader = EventParser.getHeader({ ...validated.attributes, ...getBaseProperties.attributes } as types.TypeAttributes, getBaseProperties, vtec);
+                    processed.push({
+                        preformance: performance.now() - tick,
+                        tracking: vtec.tracking,
+                        header: getHeader,
+                        vtec: vtec.raw,
+                        history: [{ description: getBaseProperties.description, issued: getBaseProperties.issued, type: vtec.status }],
+                        properties: { event: vtec.event, parent: vtec.event, action_type: vtec.status, ...getBaseProperties, }
+                    })
+                }
+            }
+        }
+        EventParser.validateEvents(processed);
+    }
+}
+
+export default VTECAlerts;

package/src/parsers/ugc.ts

@@ -0,0 +1,148 @@
+/*
+                                            _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ V / 
+       / /\ \| __| "_ ` _ \ / _ \/ __| "_ \| "_ \ / _ \ "__| |/ __| > <  
+      / ____ \ |_| | | | | | (_) \__ \ |_) | | | |  __/ |  | | (__ / . \ 
+     /_/    \_\__|_| |_| |_|\___/|___/ .__/|_| |_|\___|_|  |_|\___/_/ \_\
+                                     | |                                 
+                                     |_|                                                                                                                
+    
+    Written by: KiyoWx (k3yomi)                
+*/
+
+import * as loader from '../bootstrap';
+
+
+export class UGCParser {
+
+    /**
+     * ugcExtractor extracts and parses UGC codes from a given message string.
+     *
+     * @public
+     * @static
+     * @async
+     * @param {string} message 
+     * @returns {unknown} 
+     */
+    public static async ugcExtractor(message: string) {
+        const header = this.getHeader(message);
+        const zones = this.getZones(header);
+        const expiry = this.getExpiry(message)
+        const locations = await this.getLocations(zones)
+        const ugc = zones.length > 0 ? { zones, locations, expiry } : null;
+        return ugc;
+    }
+
+    /**
+     * getHeader extracts the UGC header from a UGC message string.
+     *
+     * @public
+     * @static
+     * @param {string} message 
+     * @returns {*} 
+     */
+    public static getHeader(message: string) {
+        const start = message.search(new RegExp(loader.definitions.expressions.ugc1, "gimu"));
+        const end = message.substring(start).search(new RegExp(loader.definitions.expressions.ugc2, "gimu"));
+        const full = message.substring(start, start + end).replace(/\s+/g, '').slice(0, -1);
+        return full;
+    }
+
+    /**
+     * getExpiry extracts the expiry date and time from a UGC message and returns it as a Date object.
+     *
+     * @public
+     * @static
+     * @param {string} message 
+     * @returns {*} 
+     */
+    public static getExpiry (message: string) {
+        const start = message.match(new RegExp(loader.definitions.expressions.ugc3, "gimu"));
+        if (start != null) { 
+            const day = parseInt(start[0].substring(0, 2), 10);
+            const hour = parseInt(start[0].substring(2, 4), 10);
+            const minute = parseInt(start[0].substring(4, 6), 10);
+            const now = new Date();
+            const expires = new Date(now.getUTCFullYear(), now.getUTCMonth(), day, hour, minute, 0);
+            return expires;
+        }
+        return null;
+    }
+
+    /**
+     * getLocations retrieves unique location names for the provided UGC zone codes from the database.
+     *
+     * @public
+     * @static
+     * @async
+     * @param {String[]} zones 
+     * @returns {unknown} 
+     */
+    public static async getLocations (zones: String[]) {
+        const locations: string[] = [];
+        for (let i = 0; i < zones.length; i++) {
+            const id = zones[i].trim();
+            const located = await loader.cache.db.prepare(`SELECT location FROM shapefiles WHERE id = ?`).get(id);
+            located != undefined ? locations.push(located.location) : locations.push(id);
+        }
+        return Array.from(new Set(locations)).sort();
+    }
+
+    /**
+     * getCoordinates retrieves geographical coordinates for the provided UGC zone codes from the database.
+     *
+     * @public
+     * @static
+     * @param {String[]} zones 
+     * @returns {{}} 
+     */
+    public static getCoordinates (zones: String[]) {
+        let coordinates: [number, number][] = [];
+        for (let i = 0; i < zones.length; i++) {
+            const id = zones[i].trim();
+            let located = loader.cache.db.prepare(`SELECT geometry FROM shapefiles WHERE id = ?`).get(id);
+            if (located != undefined) {
+                let geometry = JSON.parse(located.geometry);
+                if (geometry?.type === 'Polygon') {
+                    coordinates.push(...geometry.coordinates[0].map((coord: [number, number]) => [coord[0], coord[1]]));
+                    break;
+                }
+            }
+        }
+        return coordinates;
+    }
+
+    /**
+     * getZones parses a UGC header string and returns an array of individual UGC zone codes.
+     *
+     * @public
+     * @static
+     * @param {string} header 
+     * @returns {*} 
+     */
+    public static getZones (header: string) {
+        const ugcSplit = header.split('-') 
+        const zones: string[] = [];
+        let state = ugcSplit[0].substring(0, 2)
+        let format = ugcSplit[0].substring(2, 3);
+        for (let i = 0; i < ugcSplit.length; i++) {
+            if (/^[A-Z]/.test(ugcSplit[i])) {
+                state = ugcSplit[i].substring(0, 2);
+                if (ugcSplit[i].includes('>')) {
+                    let [start, end] = ugcSplit[i].split('>'), startNum = parseInt(start.substring(3), 10), endNum = parseInt(end, 10);
+                    for (let j = startNum; j <= endNum; j++) zones.push(`${state}${format}${j.toString().padStart(3, '0')}`);
+                } else zones.push(ugcSplit[i]);
+                continue;
+            }
+            if (ugcSplit[i].includes('>')) {
+                let [start, end] = ugcSplit[i].split('>'), startNum = parseInt(start, 10), endNum = parseInt(end, 10);
+                for (let j = startNum; j <= endNum; j++) zones.push(`${state}${format}${j.toString().padStart(3, '0')}`);
+            } else zones.push(`${state}${format}${ugcSplit[i]}`);
+        }
+        return zones.filter(item => item !== '');
+    }
+    
+}
+
+export default UGCParser;

package/src/parsers/vtec.ts

@@ -0,0 +1,66 @@
+/*
+                                            _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ V / 
+       / /\ \| __| "_ ` _ \ / _ \/ __| "_ \| "_ \ / _ \ "__| |/ __| > <  
+      / ____ \ |_| | | | | | (_) \__ \ |_) | | | |  __/ |  | | (__ / . \ 
+     /_/    \_\__|_| |_| |_|\___/|___/ .__/|_| |_|\___|_|  |_|\___/_/ \_\
+                                     | |                                 
+                                     |_|                                                                                                                
+    
+    Written by: KiyoWx (k3yomi)                
+*/
+
+import * as loader from '../bootstrap';
+
+export class VtecParser {
+
+    /**
+     * vtecExtractor extracts and parses VTEC codes from a given message string.
+     *
+     * @public
+     * @static
+     * @async
+     * @param {string} message 
+     * @returns {unknown} 
+     */
+    public static async vtecExtractor(message: string) {
+        const vtecs: unknown[] = [];
+        const matches = message.match(new RegExp(loader.definitions.expressions.vtec, 'g'));
+        if (!matches) return null;
+        for (let i = 0; i < matches.length; i++) {
+            const vtec = matches[i];
+            const parts = vtec.split(`.`);
+            const dates = parts[6].split(`-`);
+            vtecs.push({
+                raw: vtec,
+                type: loader.definitions.productTypes[parts[0]],
+                tracking: `${parts[2]}-${parts[3]}-${parts[4]}-${parts[5]}`,
+                event: `${loader.definitions.events[parts[3]]} ${loader.definitions.actions[parts[4]]}`,
+                status: loader.definitions.status[parts[1]],
+                wmo: message.match(new RegExp(loader.definitions.expressions.wmo, 'gimu')),
+                expires: this.parseExpiryDate(dates)
+            })
+        }
+        return vtecs;
+    }
+
+    /**
+     * parseExpiryDate converts VTEC expiry date format to a standard ISO 8601 format with timezone adjustment.
+     *
+     * @private
+     * @static
+     * @param {String[]} args 
+     * @returns {string} 
+     */
+    private static parseExpiryDate(args: String[]) {
+        if (args[1] == `000000T0000Z`) return `Invalid Date Format`;
+        const expires = `${new Date().getFullYear().toString().substring(0, 2)}${args[1].substring(0, 2)}-${args[1].substring(2, 4)}-${args[1].substring(4, 6)}T${args[1].substring(7, 9)}:${args[1].substring(9, 11)}:00`;
+        const local = new Date(new Date(expires).getTime() - 4 * 60 * 60000);
+        const pad = (n: number) => n.toString().padStart(2, '0');
+        return `${local.getFullYear()}-${pad(local.getMonth() + 1)}-${pad(local.getDate())}T${pad(local.getHours())}:${pad(local.getMinutes())}:00.000-04:00`;
+    }
+
+}
+
+export default VtecParser;