atmosx-nwws-parser 1.0.2

package/src/parsers/events.ts

@@ -0,0 +1,289 @@
+/*
+                                            _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ V / 
+       / /\ \| __| "_ ` _ \ / _ \/ __| "_ \| "_ \ / _ \ "__| |/ __| > <  
+      / ____ \ |_| | | | | | (_) \__ \ |_) | | | |  __/ |  | | (__ / . \ 
+     /_/    \_\__|_| |_| |_|\___/|___/ .__/|_| |_|\___|_|  |_|\___/_/ \_\
+                                     | |                                 
+                                     |_|                                                                                                                
+    
+    Written by: KiyoWx (k3yomi)                
+*/
+
+import * as loader from '../bootstrap';
+import * as types from '../types';
+import TextParser from './text';
+import UGCParser from './ugc';
+import VTECAlerts from './types/vtec';
+import UGCAlerts from './types/ugc';
+import TextAlerts from './types/text';
+import CAPAlerts from './types/cap';
+import APIAlerts from './types/api';
+
+
+import EAS from '../eas';
+
+export class EventParser {
+
+    
+    /**
+     * getBaseProperties extracts and compiles the base properties of an alert message, including location, timing, description, sender information, and various parameters.
+     *
+     * @public
+     * @static
+     * @async
+     * @param {string} message 
+     * @param {types.TypeCompiled} validated 
+     * @param {types.UGCParsed} [ugc=null] 
+     * @param {types.VTECParsed} [vtec=null] 
+     * @returns {Promise<types.BaseProperties>} 
+     */
+    public static async getBaseProperties(message: string, validated: types.TypeCompiled, ugc: types.UGCParsed = null, vtec: types.VTECParsed = null): Promise<types.BaseProperties> {
+        const settings = loader.settings as types.ClientSettings;
+        const definitions = {
+            tornado: TextParser.textProductToString(message, `TORNADO...`) || TextParser.textProductToString(message, `WATERSPOUT...`) || `N/A`,
+            hail: TextParser.textProductToString(message, `MAX HAIL SIZE...`, [`IN`]) || TextParser.textProductToString(message, `HAIL...`, [`IN`]) || `N/A`,
+            gusts: TextParser.textProductToString(message, `MAX WIND GUST...`) || TextParser.textProductToString(message, `WIND...`) || `N/A`,
+            flood: TextParser.textProductToString(message, `FLASH FLOOD...`) || `N/A`,
+            damage: TextParser.textProductToString(message, `DAMAGE THREAT...`) || `N/A`,
+            source: TextParser.textProductToString(message, `SOURCE...`, [`.`]) || `N/A`,
+            attributes: TextParser.textProductToString(message, `STANZA ATTRIBUTES...`) ? JSON.parse(TextParser.textProductToString(message, `STANZA ATTRIBUTES...`)) : null,
+            polygon: TextParser.textProductToPolygon(message),
+            description: TextParser.textProductToDescription(message, vtec?.raw ?? null),
+            wmo: message.match(new RegExp(loader.definitions.expressions.wmo, 'imu')),
+            mdTorIntensity: TextParser.textProductToString(message, `MOST PROBABLE PEAK TORNADO INTENSITY...`) || `N/A`,
+            mdWindGusts: TextParser.textProductToString(message, `MOST PROBABLE PEAK WIND GUST...`) || `N/A`,
+            mdHailSize: TextParser.textProductToString(message, `MOST PROBABLE PEAK HAIL SIZE...`) || `N/A`,
+        };
+        const getOffice = this.getICAO(vtec, validated.attributes ?? definitions.attributes ?? {}, definitions.wmo);
+        const getCorrectIssued = this.getCorrectIssuedDate(definitions.attributes ?? validated.attributes  ?? {});
+        const getCorrectExpiry = this.getCorrectExpiryDate(vtec, ugc);
+        const getAwip = TextParser.awipTextToEvent(definitions.attributes?.awipsid ?? validated.awipsType.prefix);
+        const base = { 
+            locations: ugc?.locations.join(`; `) || `No Location Specified (UGC Missing)`,
+            issued: getCorrectIssued,
+            expires: getCorrectExpiry,
+            geocode: { UGC: ugc?.zones || [`XX000`] },
+            description: definitions.description,
+            sender_name: getOffice.name,
+            sender_icao: getOffice.icao,
+            attributes: {
+                ...validated.attributes,
+                ...definitions.attributes,
+                getAwip,
+            },
+            parameters: {
+                wmo: Array.isArray(definitions.wmo) ? definitions.wmo[0] : (definitions.wmo ?? `N/A`),
+                source: definitions.source,
+                max_hail_size: definitions.hail,
+                max_wind_gust: definitions.gusts,
+                damage_threat: definitions.damage,
+                tornado_detection: definitions.tornado,
+                flood_detection: definitions.flood,
+                discussion_tornado_intensity: definitions.mdTorIntensity,
+                discussion_wind_intensity: definitions.mdWindGusts,
+                discussion_hail_intensity:  definitions.mdHailSize,
+            },
+            geometry: definitions.polygon.length > 0 ? { type: "Polygon", coordinates: definitions.polygon } : null
+        };
+        if (settings.NoaaWeatherWireService.alertPreferences.isShapefileUGC && base.geometry == null && ugc != null) {
+            const coordinates = await UGCParser.getCoordinates(ugc.zones);
+            base.geometry = { type: "Polygon", coordinates };
+        }
+        return base;
+    }
+
+    /**
+     * enhanceEvent refines the event name based on specific conditions and tags found in the event's description and parameters.
+     *
+     * @public
+     * @static
+     * @param {types.TypeAlert} event 
+     * @returns {{ eventName: any; tags: any; }} 
+     */
+    public static enhanceEvent(event: types.TypeAlert) {
+        let eventName = event?.properties?.event ?? `Unknown Event`;
+        const defEventTable = loader.definitions.enhancedEvents;
+        const defEventTags = loader.definitions.tags
+
+        const properties = event?.properties;
+        const parameters = properties?.parameters;
+
+        const description = properties?.description ?? `Unknown Description`;
+        const damageThreatTag = parameters?.damage_threat ?? `N/A`;
+        const tornadoThreatTag = parameters?.tornado_detection ?? `N/A`;
+
+
+        for (const eventGroup of defEventTable) {
+            const [baseEvent, conditions] = Object.entries(eventGroup)[0] as [string, Record<string, types.EnhancedEventCondition>];
+            if (eventName === baseEvent) {
+                for (const [specificEvent, condition] of Object.entries(conditions)) {
+                    const conditionMet = (condition.description && description.includes(condition.description.toLowerCase())) || (condition.condition && condition.condition(damageThreatTag || tornadoThreatTag));
+                    if (conditionMet) { eventName = specificEvent; break; }
+                }   
+                if (baseEvent === 'Severe Thunderstorm Warning' && damageThreatTag === 'POSSIBLE' && !eventName.includes('(TPROB)')) eventName += ' (TPROB)';
+                break;
+            }
+        }
+        const tags = Object.entries(defEventTags).filter(([key]) => description.includes(key.toLowerCase())).map(([, value]) => value)
+        return { eventName, tags: tags.length > 0 ? tags : [`N/A`] }
+    }
+    
+    /**
+     * getCorrectExpiryDate determines the correct expiration date for an alert based on VTEC information or UGC zones.
+     *
+     * @public
+     * @static
+     * @param {unknown[]} events 
+     */
+    public static validateEvents(events: unknown[]) {
+        if (events.length == 0) return;
+
+        const settings = loader.settings as types.ClientSettings;
+        const filteringSettings = loader.settings?.global?.alertFiltering;
+        const easSettings = loader.settings?.global?.easSettings;
+        const globalSettings = loader.settings?.global;
+        const sets = {} as Record<string, Set<string>>;
+        const bools = {} as Record<string, boolean>;
+        const megered = {...filteringSettings, ...easSettings, ...globalSettings};
+
+        for (const key in megered) {
+            const setting = megered[key];
+            if (Array.isArray(setting)) { sets[key] = new Set(setting.map(item => item.toLowerCase())); }
+            if (typeof setting === 'boolean') { bools[key] = setting; }
+        }
+
+        const filtered = events.filter((alert: any) => {
+            const originalEvent = alert
+            const props = originalEvent?.properties;
+            const ugcs = props?.geocode?.UGC ?? [];
+            if (bools?.betterEventParsing) {
+                const { eventName, tags } = this.enhanceEvent(originalEvent);
+                originalEvent.properties.event = eventName;
+                originalEvent.properties.tags = tags;
+            }
+            const eventCheck = bools?.useParentEvents ? props.parent?.toLowerCase() : props.event?.toLowerCase();
+            const statusCorrelation = loader.definitions.correlations.find((c: { type: string }) => c.type === originalEvent.properties.action_type);
+            for (const key in sets) {
+                const setting = sets[key];
+                if (key === 'filteredEvents' && setting.size > 0 && eventCheck != null && !setting.has(eventCheck)) return false;
+                if (key === 'ignoredEvents' && setting.size > 0 && eventCheck != null && setting.has(eventCheck)) return false;
+                if (key === 'filteredICOAs' && setting.size > 0 && props.sender_icao != null && !setting.has(props.sender_icao.toLowerCase())) return false;
+                if (key === 'ignoredICOAs' && setting.size > 0 && props.sender_icao != null && setting.has(props.sender_icao.toLowerCase())) return false;
+                if (key === 'ugcFilter' && setting.size > 0 && ugcs.length > 0 && !ugcs.some((ugc: string) => setting.has(ugc.toLowerCase()))) return false;
+                if (key === 'stateFilter' && setting.size > 0 && ugcs.length > 0 && !ugcs.some((ugc: string) => setting.has(ugc.substring(0, 2).toLowerCase()))) return false;
+                if (key === 'easAlerts' && setting.size > 0 && eventCheck != null && setting.has(eventCheck) && settings.isNWWS) { EAS.generateEASAudio(props.description, alert.header) }
+            }
+            for (const key in bools) {
+                const setting = bools[key];
+                if (key === 'checkExpired' && setting && new Date(props?.expires).getTime() < new Date().getTime()) return false;   
+            }
+            originalEvent.properties.action_type = statusCorrelation ? statusCorrelation.forward : originalEvent.properties.action_type;
+            originalEvent.properties.is_cancelled = statusCorrelation ? (statusCorrelation.cancel == true && bools.checkExpired) : false;
+            if (props.description) { 
+                const detectedPhrase = loader.definitions.cancelSignatures.find(sig => props.description.toLowerCase().includes(sig.toLowerCase()));
+                if (detectedPhrase && bools.checkExpired) { originalEvent.properties.action_type = 'Cancel'; originalEvent.properties.is_cancelled = true; return false; } 
+            }
+            if (originalEvent.vtec) { 
+                const getType = originalEvent.vtec.split(`.`)[0];
+                const isTestProduct = loader.definitions.productTypes[getType] == `Test Product`
+                if (isTestProduct) { return false; }
+            }
+            loader.cache.events.emit(`on${originalEvent.properties.parent.replace(/\s+/g, '')}`)
+            return true;
+        })
+        if (filtered.length > 0) { loader.cache.events.emit(`onAlerts`, filtered); }
+    }
+
+    /**
+     * getHeader constructs a standardized alert header string based on provided attributes, properties, and VTEC information.
+     *
+     * @public
+     * @static
+     * @param {types.TypeAttributes} attributes 
+     * @param {?types.BaseProperties} [properties] 
+     * @param {?types.VTECParsed} [vtec] 
+     * @returns {string} 
+     */
+    public static getHeader(attributes: types.TypeAttributes, properties?: types.BaseProperties, vtec?: types.VTECParsed) {
+        const parent = `ATSX`
+        const alertType = attributes?.awipsType?.type ?? attributes?.getAwip?.prefix ?? `XX`;
+        const ugc = properties?.geocode?.UGC != null ? properties?.geocode?.UGC.join(`-`) : `000000`;
+        const status = vtec?.status || 'Issued';
+        const issued = properties?.issued != null ? new Date(properties?.issued)?.toISOString().replace(/[-:]/g, '').split('.')[0] : new Date().toISOString().replace(/[-:]/g, '').split('.')[0];
+        const sender = properties?.sender_icao || `XXXX`;
+        const header = `ZCZC-${parent}-${alertType}-${ugc}-${status}-${issued}-${sender}-`;
+        return header
+    }
+    
+    /**
+     * eventHandler routes the validated alert message to the appropriate event parser based on its type (API, CAP, VTEC, UGC, or plain text).
+     *
+     * @public
+     * @static
+     * @param {types.TypeCompiled} validated 
+     * @returns {*} 
+     */
+    public static eventHandler(validated: types.TypeCompiled) {
+        if (validated.isApi) return APIAlerts.event(validated)
+        if (validated.isCap) return CAPAlerts.event(validated)
+        if (!validated.isCap && validated.isVtec && validated.isUGC) return VTECAlerts.event(validated);
+        if (!validated.isCap && !validated.isVtec && validated.isUGC) return UGCAlerts.event(validated); 
+        if (!validated.isCap && !validated.isVtec && !validated.isUGC) return TextAlerts.event(validated);
+    }
+
+    /**
+     * getICAO retrieves the ICAO code and corresponding office name based on VTEC tracking information, message attributes, or WMO code.
+     *
+     * @private
+     * @static
+     * @param {types.VTECParsed} vtec 
+     * @param {Record<string, string>} attributes 
+     * @param {(RegExpMatchArray | string | null)} WMO 
+     * @returns {{ icao: any; name: any; }} 
+     */
+    private static getICAO(vtec: types.VTECParsed, attributes: Record<string, string>, WMO: RegExpMatchArray | string | null) {
+        const icao = vtec != null ? vtec?.tracking.split(`-`)[0] : (attributes?.cccc ?? (WMO != null ? (Array.isArray(WMO) ? WMO[0] : WMO) : `N/A`));
+        const name = loader.definitions.ICAO?.[icao] ?? `N/A`;
+        return { icao, name };
+    }
+    
+    /**
+     * getCorrectIssuedDate ensures the issued date is valid and falls back to the current date if not.
+     *
+     * @private
+     * @static
+     * @param {Record<string, string>} attributes 
+     * @returns {*} 
+     */
+    private static getCorrectIssuedDate(attributes: Record<string, string>) {
+        const time = attributes.issue != null ? 
+            new Date(attributes.issue).toLocaleString() : (attributes?.issue != null ? 
+            new Date(attributes.issue).toLocaleString() : 
+            new Date().toLocaleString());
+        if (time == `Invalid Date`) return new Date().toLocaleString();
+        return time;
+    }
+    
+    /**
+     * getCorrectExpiryDate determines the correct expiration date for an alert based on VTEC information or UGC zones.
+     *
+     * @private
+     * @static
+     * @param {types.VTECParsed} vtec 
+     * @param {types.UGCParsed} ugc 
+     * @returns {*} 
+     */
+    private static getCorrectExpiryDate(vtec: types.VTECParsed, ugc: types.UGCParsed) {
+        const time =  vtec?.expires && !isNaN(new Date(vtec.expires).getTime()) ? 
+            new Date(vtec.expires).toLocaleString() : 
+            (ugc?.expiry != null ? new Date(ugc.expiry).toLocaleString() : 
+            new Date(new Date().getTime() + 1 * 60 * 60 * 1000).toLocaleString())
+        if (time == `Invalid Date`) return new Date(new Date().getTime() + 1 * 60 * 60 * 1000).toLocaleString();
+        return time;
+    }
+
+}
+
+export default EventParser

package/src/parsers/stanza.ts

@@ -0,0 +1,103 @@
+/*
+                                            _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ V / 
+       / /\ \| __| "_ ` _ \ / _ \/ __| "_ \| "_ \ / _ \ "__| |/ __| > <  
+      / ____ \ |_| | | | | | (_) \__ \ |_) | | | |  __/ |  | | (__ / . \ 
+     /_/    \_\__|_| |_| |_|\___/|___/ .__/|_| |_|\___|_|  |_|\___/_/ \_\
+                                     | |                                 
+                                     |_|                                                                                                                
+    
+    Written by: KiyoWx (k3yomi)                
+*/
+
+
+import * as loader from '../bootstrap';
+import * as types from '../types';
+
+export class StanzaParser {
+
+    /**
+     * validate handles the validation of incoming XMPP stanzas to ensure they contain valid alert data.
+     * You can also feed debug / cache data directly into this function by specifying the second parameter
+     * which is the attributes object that would normally be parsed from the XMPP stanza.
+     *
+     * @public
+     * @static
+     * @param {*} stanza 
+     * @param {(boolean | types.TypeAttributes)} [isDebug=false] 
+     * @returns {{ message: any; attributes: types.TypeAttributes; isCap: any; isVtec: boolean; isCapDescription: any; awipsType: any; isApi: boolean; ignore: boolean; }} 
+     */
+    public static validate(stanza: any, isDebug: boolean | types.TypeAttributes = false) {
+        if (isDebug !== false) { 
+            const vTypes = isDebug as types.TypeAttributes;
+            const message = stanza;
+            const attributes = vTypes;
+            const isCap = vTypes.isCap ?? message.includes(`<?xml`);
+            const isCapDescription = message.includes(`<areaDesc>`);
+            const isVtec = message.match(loader.definitions.expressions.vtec) != null;
+            const isUGC = message.match(loader.definitions.expressions.ugc1) != null;
+            const awipsType = this.getType(attributes);
+            return { message, attributes, isCap, isVtec, isUGC, isCapDescription, awipsType: awipsType, isApi: false, ignore: false };
+        }
+        if (stanza.is(`message`)) {
+            let cb = stanza.getChild(`x`)
+            if (cb && cb.children) {
+                let message = unescape(cb.children[0])
+                let attributes = cb.attrs
+                if (attributes.awipsid && attributes.awipsid.length > 1) {
+                    const isCap = message.includes(`<?xml`);
+                    const isCapDescription = message.includes(`<areaDesc>`);
+                    const isVtec = message.match(loader.definitions.expressions.vtec) != null;
+                    const isUGC = message.match(loader.definitions.expressions.ugc1) != null;
+                    const awipsType = this.getType(attributes);
+                    const isApi = false;
+                    this.cache({ message, attributes, isCap, isVtec, awipsType: awipsType.type, awipsPrefix: awipsType.prefix });
+                    return { message, attributes, isCap, isApi, isVtec, isUGC, isCapDescription, awipsType: awipsType, ignore: false };
+                }
+            }
+        }
+        return { message: null, attributes: null, isApi: null, isCap: null, isVtec: null, isUGC: null, isCapDescription: null, awipsType: null, ignore: true };
+    }
+
+    /**
+     * getType determines the AWIPS type of the alert based on its attributes, specifically the awipsid.
+     * If no matching type is found, it defaults to 'default'.
+     *
+     * @private
+     * @static
+     * @param {unknown} attributes 
+     * @returns {*} 
+     */
+    private static getType(attributes: unknown) {
+        const attrs = attributes as types.TypeAttributes;
+        if (!attrs || !attrs.awipsid) return {type: `XX`, prefix: `XX`};
+        for (const [prefix, type] of Object.entries(loader.definitions.awips)) {
+            if (attrs.awipsid.startsWith(prefix)) { return {type: type, prefix: prefix}; }
+        }
+        return {type: `XX`, prefix: `XX`};
+    }
+
+    /**
+     * cache stores the compiled alert data into a cache file if caching is enabled in the settings.
+     *
+     * @private
+     * @static
+     * @param {unknown} compiled 
+     */
+    private static cache(compiled: unknown) {
+        const data = compiled as types.TypeCompiled;
+        const settings = loader.settings as types.ClientSettings;
+        if (!settings.NoaaWeatherWireService.cache.directory) return;
+        if (!loader.packages.fs.existsSync(settings.NoaaWeatherWireService.cache.directory)) { loader.packages.fs.mkdirSync(settings.NoaaWeatherWireService.cache.directory, { recursive: true }); }
+        data.message = data.message.replace(/\$\$/g, `\nSTANZA ATTRIBUTES...${JSON.stringify(data.attributes)}\nISSUED TIME...${new Date().toISOString()}\n$$$\n`);
+        if (!data.message.includes(`STANZA ATTRIBUTES...`)) {
+            data.message += `\nSTANZA ATTRIBUTES...${JSON.stringify(data.attributes)}\nISSUED TIME...${new Date().toISOString()}\n$$\n`;
+        }
+        loader.packages.fs.appendFileSync(`${settings.NoaaWeatherWireService.cache.directory}/category-${data.awipsPrefix}-${data.awipsType}s-${data.isCap ? `cap` : `raw`}${data.isVtec ? `-vtec` : ``}.bin`,`=================================================\n${new Date().toISOString().replace(/[:.]/g, '-')}\n=================================================\n${data.message}`, 'utf8');
+        loader.packages.fs.appendFileSync(`${settings.NoaaWeatherWireService.cache.directory}/cache-${data.isCap ? `cap` : `raw`}${data.isVtec ? `-vtec` : ``}.bin`,`=================================================\n${new Date().toISOString().replace(/[:.]/g, '-')}\n=================================================\n${data.message}`, 'utf8');
+    }
+    
+}
+
+export default StanzaParser;

package/src/parsers/text.ts

@@ -0,0 +1,167 @@
+/*
+                                            _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ V / 
+       / /\ \| __| "_ ` _ \ / _ \/ __| "_ \| "_ \ / _ \ "__| |/ __| > <  
+      / ____ \ |_| | | | | | (_) \__ \ |_) | | | |  __/ |  | | (__ / . \ 
+     /_/    \_\__|_| |_| |_|\___/|___/ .__/|_| |_|\___|_|  |_|\___/_/ \_\
+                                     | |                                 
+                                     |_|                                                                                                                
+    
+    Written by: KiyoWx (k3yomi)                
+*/
+
+import * as loader from '../bootstrap';
+
+export class TextParser {
+    
+    /**
+     * textProductToString extracts a specific value from a text-based weather product message based on a given key and optional removal strings.
+     *
+     * @public
+     * @static
+     * @param {string} message 
+     * @param {string} value 
+     * @param {string[]} [removal=[]] 
+     * @returns {(string | null)} 
+     */
+    public static textProductToString(message: string,value: string,removal: string[] = []): string | null {
+        const lines = message.split('\n');
+        for (const line of lines) {
+            if (line.includes(value)) {
+                let result = line.slice(line.indexOf(value) + value.length).trim();
+                for (const str of removal) { result = result.split(str).join(''); }
+                result = result.replace(value, '').replace('<', '').trim();
+                return result || null;
+            }
+        }
+        return null;
+    }
+    
+    /**
+     * textProductToPolygon extracts geographical coordinates from a text-based weather product message and returns them as an array of [longitude, latitude] pairs.
+     *
+     * @public
+     * @static
+     * @param {string} message 
+     * @returns {[number, number][]} 
+     */
+    public static textProductToPolygon(message: string): [number, number][] {
+        const coordinates: [number, number][] = [];
+        const latLonMatch = message.match(/LAT\.{3}LON\s+([\d\s]+)/i);
+        if (!latLonMatch || !latLonMatch[1]) return coordinates;
+        const coordStrings = latLonMatch[1].replace(/\n/g, ' ').trim().split(/\s+/);
+        for (let i = 0; i < coordStrings.length - 1; i += 2) {
+            const lat = parseFloat(coordStrings[i]) / 100;
+            const lon = -parseFloat(coordStrings[i + 1]) / 100;
+            if (!isNaN(lat) && !isNaN(lon)) { coordinates.push([lon, lat]); }
+        }
+        if (coordinates.length > 2) { coordinates.push(coordinates[0]); }
+        return coordinates;
+    }
+
+    /**
+     * textProductToDescription extracts the main description from a text-based weather product message.
+     *
+     * @public
+     * @static
+     * @param {string} message 
+     * @param {string} [handle=null] 
+     * @returns {string} 
+     */
+    public static textProductToDescription(message: string, handle: string = null): string {
+        const original = message;
+        const dateRegex = /\d{3,4}\s*(AM|PM)?\s*[A-Z]{2,4}\s+[A-Z]{3,}\s+[A-Z]{3,}\s+\d{1,2}\s+\d{4}/gim;
+        const discoveredDates = Array.from(message.matchAll(dateRegex));
+        if (discoveredDates.length) {
+            const lastMatch = discoveredDates[discoveredDates.length - 1][0];
+            const startIdx = message.lastIndexOf(lastMatch);
+            if (startIdx !== -1) {
+                const endIdx = message.indexOf('&&', startIdx);
+                message = message.substring(startIdx + lastMatch.length, endIdx !== -1 ? endIdx : undefined).trimStart();
+                if (message.startsWith('/')) message = message.slice(1).trimStart();
+                if (handle && message.includes(handle)) {
+                    const handleIdx = message.indexOf(handle);
+                    message = message.substring(handleIdx + handle.length).trimStart();
+                    if (message.startsWith('/')) message = message.slice(1).trimStart();
+                }
+            }
+        } else if (handle) {
+            const handleIdx = message.indexOf(handle);
+            if (handleIdx !== -1) {
+                let afterHandle = message.substring(handleIdx + handle.length).trimStart();
+                if (afterHandle.startsWith('/')) afterHandle = afterHandle.slice(1).trimStart();
+                const latEnd = afterHandle.indexOf('&&');
+                message = latEnd !== -1 ? afterHandle.substring(0, latEnd).trim() : afterHandle.trim();
+            }
+        }
+        return message.replace(/\s+/g, ' ').trim().startsWith('ISSUED TIME...') ? original : message.trim();
+    }
+
+    /**
+     * awipTextToEvent converts an AWIPS ID prefix from a text-based weather product message to its corresponding event type and prefix.
+     *
+     * @public
+     * @static
+     * @param {string} message 
+     * @returns {{ type: any; prefix: any; }} 
+     */
+    public static awipTextToEvent(message: string) {
+        for (const [prefix, type] of Object.entries(loader.definitions.awips)) {
+            if (message.startsWith(prefix)) {
+                return {type: type, prefix: prefix};
+            }
+        }
+        return {type: `XX`, prefix: `XX`};
+    }
+    
+    /**
+     * getXmlValues recursively searches a parsed XML object for specified keys and extracts their values.
+     *
+     * @public
+     * @static
+     * @param {*} parsed 
+     * @param {string[]} valuesToExtract 
+     * @returns {Record<string, any>} 
+     */
+    public static getXmlValues(parsed: any, valuesToExtract: string[]) {
+        const extracted: Record<string, any> = {};   
+        const findValueByKey = (obj: any, searchKey: string): any[] => {
+            const results: any[] = [];
+            if (obj === null || typeof obj !== 'object') {
+                return results;
+            }
+            const searchKeyLower = searchKey.toLowerCase();
+            for (const key in obj) {
+                if (obj.hasOwnProperty(key) && key.toLowerCase() === searchKeyLower) {
+                    results.push(obj[key]);
+                }
+            }
+            if (Array.isArray(obj)) {
+                for (const item of obj) {
+                    if (item.valueName && item.valueName.toLowerCase() === searchKeyLower && item.value !== undefined) {
+                        results.push(item.value);
+                    }
+                    const nestedResults = findValueByKey(item, searchKey);
+                    results.push(...nestedResults);
+                }
+            }
+            for (const key in obj) {
+                if (obj.hasOwnProperty(key)) {
+                    const nestedResults = findValueByKey(obj[key], searchKey);
+                    results.push(...nestedResults);
+                }
+            }
+            return results;
+        };
+        for (const key of valuesToExtract) {
+            const values = findValueByKey(parsed.alert, key);
+            const uniqueValues = [...new Set(values)];
+            extracted[key] = uniqueValues.length === 0 ? null : (uniqueValues.length === 1 ? uniqueValues[0] : uniqueValues);
+        }
+        return extracted;
+    }
+    
+}
+
+export default TextParser;

package/src/parsers/types/api.ts

@@ -0,0 +1,94 @@
+/*
+                                            _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ 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 APIAlerts {
+
+    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})`;
+    }
+    
+    private static getICAO(vtec: string) {
+        const icao = vtec ? vtec.split(`.`)[2] : `N/A`;
+        const name = loader.definitions.ICAO?.[icao] ?? `N/A`;
+        return { icao, name };
+    }
+
+    public static async event(validated: types.TypeCompiled) {
+        let processed = [] as unknown[];
+        const messages = Object.values(JSON.parse(validated.message).features) as types.TypeAlert[];
+        for (let feature of messages) {
+            const tick = performance.now();
+            const getVTEC = feature?.properties?.parameters?.VTEC?.[0] ?? null;
+            const getWmo = feature?.properties?.parameters?.WMOidentifier[0] ?? null;
+            const getUgc = feature?.properties?.geocode?.UGC ?? null;
+            const getHeadline = feature?.properties?.parameters?.NWSheadline?.[0] ?? "";
+            const getDescription = `${getHeadline} ${feature?.properties?.description ?? ``}`
+            const getAWIP = feature?.properties?.parameters?.AWIPSidentifier?.[0] ?? null;
+            const getHeader = EventParser.getHeader({ ...{ getAwip: {prefix: getAWIP?.slice(0, -3) }},} as types.TypeAttributes);
+            const getSource = TextParser.textProductToString(getDescription, `SOURCE...`, [`.`]) || `N/A`;
+            const getOffice = this.getICAO(getVTEC || ``);
+            processed.push({
+                preformance: performance.now() - tick,
+                tracking: this.getTracking({ vtec: getVTEC, wmoidentifier: getWmo, ugc: getUgc ? getUgc.join(`,`) : null }),
+                header: getHeader,
+                vtec: getVTEC || `N/A`,
+                history: [{
+                    description: feature?.properties?.description ?? `N/A`,
+                    action: feature?.properties?.messageType ?? `N/A`,
+                    time: feature?.properties?.sent ? new Date(feature?.properties?.sent).toLocaleString() : `N/A`
+                }],
+                properties: {
+                    locations: feature?.properties?.areaDesc ?? `N/A`,
+                    event: feature?.properties?.event ?? `N/A`,
+                    issued: feature?.properties?.sent ? new Date(feature?.properties?.sent).toLocaleString() : `N/A`,
+                    expires: feature?.properties?.expires ? new Date(feature?.properties?.expires).toLocaleString() : `N/A`,
+                    parent: feature?.properties?.event ?? `N/A`,
+                    action_type: feature?.properties?.messageType ?? `N/A`,
+                    description: feature?.properties?.description ?? `N/A`,
+                    sender_name: getOffice.name || `N/A`,
+                    sender_icao: getOffice.icao || `N/A`,
+                    attributes: validated.attributes,
+                    geocode: {
+                        UGC: feature?.properties?.geocode?.UGC ?? [`XX000`]
+                    },
+                    parameters: {
+                        wmo: feature?.properties?.parameters?.WMOidentifier?.[0] || getWmo || `N/A`,
+                        source: getSource,
+                        max_hail_size: feature?.properties?.parameters?.maxHailSize || `N/A`,
+                        max_wind_gust: feature?.properties?.parameters?.maxWindGust || `N/A`,
+                        damage_threat: feature?.properties?.parameters?.thunderstormDamageThreat || [`N/A`],
+                        tornado_detection: feature?.properties?.parameters?.tornadoDetection || [`N/A`],
+                        flood_detection: feature?.properties?.parameters?.floodDetection || [`N/A`],
+                        discussion_tornado_intensity: "N/A", 
+                        peakWindGust: `N/A`,
+                        peakHailSize: `N/A`,
+                    },
+                    geometry: feature?.geometry ?? null,
+                }
+            })
+        }
+        EventParser.validateEvents(processed);
+    }
+}
+
+export default APIAlerts;