@atmosx/event-product-parser 2.0.16 → 3.0.1

package/src/@parsers/events.ts

@@ -1,392 +0,0 @@
-/*
-                                            _               _     __   __
-         /\  | |                           | |             (_)    \ \ / /
-        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ 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 './@events/vtec';
-import UGCAlerts from './@events/ugc';
-import TextAlerts from './@events/text';
-import CAPAlerts from './@events/cap';
-import APIAlerts from './@events/api';
-
-export class EventParser {
-    
-    /**
-     * @function getBaseProperties
-     * @description
-     *     Extracts and compiles the core properties of a weather
-     *     alert message into a structured object. Combines parsed
-     *     textual data, UGC information, VTEC entries, and additional
-     *     metadata for downstream use.
-     *
-     * @static
-     * @async
-     * @param {string} message
-     * @param {types.StanzaCompiled} metadata
-     * @param {types.UGCEntry} [ugc=null]
-     * @param {types.PVtecEntry} [pVtec=null]
-     * @param {types.HVtecEntry} [hVtec=null]
-     * @returns {Promise<Record<string, any>>}
-     */
-    public static async getBaseProperties(message: string, metadata: types.DefaultAttributesType, ugc: types.UGCEntry = null, pVtec: types.PVtecEntry = null, hVtec: types.HVtecEntry = null): Promise<Record<string, any>> {
-        const settings = loader.settings as types.ClientSettingsTypes;
-        const definitions = {
-            tornado: TextParser.textProductToString(message, `TORNADO...`) ?? TextParser.textProductToString(message, `WATERSPOUT...`) ?? null,
-            hail: TextParser.textProductToString(message, `MAX HAIL SIZE...`, [`IN`]) ?? TextParser.textProductToString(message, `HAIL...`, [`IN`]) ?? null,
-            gusts: TextParser.textProductToString(message, `MAX WIND GUST...`) ?? TextParser.textProductToString(message, `WIND...`) ?? null,
-            flood: TextParser.textProductToString(message, `FLASH FLOOD...`) ?? null,
-            damage: TextParser.textProductToString(message, `DAMAGE THREAT...`) ?? null,
-            source: TextParser.textProductToString(message, `SOURCE...`, [`.`]) ?? null,
-            description: TextParser.textProductToDescription(message, pVtec?.raw ?? null),
-            polygon: TextParser.textProductToPolygon(message),
-            wmo: message.match(loader.definitions.regular_expressions.wmo)?.[0] ?? null,
-            mdTorIntensity: TextParser.textProductToString(message, `MOST PROBABLE PEAK TORNADO INTENSITY...`) ?? null,
-            mdWindGusts: TextParser.textProductToString(message, `MOST PROBABLE PEAK WIND GUST...`) ?? null,
-            mdHailSize: TextParser.textProductToString(message, `MOST PROBABLE PEAK HAIL SIZE...`) ?? null,
-        };
-        const getOffice = this.getICAO(pVtec, metadata, definitions.wmo);
-        const getCorrectIssued = this.getCorrectIssuedDate(metadata);
-        const getCorrectExpiry = this.getCorrectExpiryDate(pVtec, ugc);
-        const base = { 
-            locations: ugc?.locations.join(`; `) ?? `No Location Specified (UGC Missing)`,
-            issued: getCorrectIssued,
-            expires: getCorrectExpiry,
-            geocode: { 
-                UGC: ugc?.zones ?? [], 
-                generated: definitions.polygon.length > 0 ? Buffer.from(JSON.stringify([definitions.polygon])).toString('base64') : null
-            },
-            description: definitions.description,
-            instruction: null,
-            sender_name: getOffice.name,
-            sender_icao: getOffice.icao,
-            raw: {...Object.fromEntries(Object.entries(metadata).filter(([key]) => key !== 'message'))},
-            parameters: {
-                wmo: Array.isArray(definitions.wmo) ? definitions.wmo[0] : (definitions.wmo ?? null),
-                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,
-            },
-        };
-        return base;
-    }
-
-    /**
-     * @function getEventGeometry
-     * @description
-     *   Determines the geometry of an event using polygon data fromEntries
-     *   in the message or UGC shapefile coordinates if enabled in settings. Falls
-     *   back to null if no geometry can be determined.
-     * 
-     * @static
-     * @param {string} generated
-     * @param {types.UGCEntry} [ugc=null]
-     * @returns {Promise<types.geometry>}
-     */
-    public static async getEventGeometry(generated: string, ugc: types.UGCEntry = null, isUnion: boolean = true) : Promise<types.geometry> {
-        const settings = loader.settings as types.ClientSettingsTypes;
-        let geometry = { type: "Polygon", coordinates: generated != null ? JSON.parse(Buffer.from(generated, 'base64').toString('utf-8')) : null };
-        if (settings.global_settings.shapefile_coordinates && generated == null && ugc != null) {
-            const coordinates = await UGCParser.getCoordinates(ugc.zones, isUnion) as any;
-            geometry = coordinates
-        }
-        return geometry;
-    }
-    
-    /**
-     * @function betterParsedEventName
-     * @description
-     *     Enhances the parsing of an event name using additional criteria
-     *     from its description and parameters. Can optionally use
-     *     the original parent event name instead.
-     *
-     * @static
-     * @param {types.EventCompiled} event
-     * @param {boolean} [betterParsing=false]
-     * @param {boolean} [useParentEvents=false]
-     * @returns {string}
-     */
-    public static betterParsedEventName(event: types.EventCompiled, betterParsing?: boolean, useParentEvents?: boolean): string {
-        let eventName = event?.properties?.event ?? `Unknown Event`;
-        const defEventTable = loader.definitions.enhancedEvents;
-        const properties = event?.properties;
-        const parameters = properties?.parameters;
-        const description = (properties?.description ?? `Unknown Description`).toLowerCase();
-        const damageThreatTag = parameters?.damage_threat ?? null;
-        const tornadoThreatTag = parameters?.tornado_detection ?? null;
-        if (!betterParsing) { return eventName }
-        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)) {
-                    let conditionMet = false;
-                    if (condition.description) {
-                        conditionMet = description.includes(condition.description.toLowerCase());
-                        if (!conditionMet) continue;
-                    }
-                    if (!conditionMet && condition.condition) {
-                        const tagToCheck = baseEvent.includes('Tornado') || baseEvent.includes('Special Marine Warning')  ? tornadoThreatTag : damageThreatTag;
-                        conditionMet = condition.condition(tagToCheck);
-                    }
-                    if (conditionMet) { 
-                        eventName = specificEvent; 
-                        break; 
-                    }
-                }
-                if (baseEvent === 'Severe Thunderstorm Warning' && tornadoThreatTag === 'POSSIBLE' && !eventName.includes('(TPROB)')) {
-                    eventName += ' (TPROB)';
-                }
-                break;
-            }
-        }
-        return useParentEvents ? event?.properties?.event : eventName;
-    }
-   
-    /**
-     * @function validateEvents
-     * @description
-     *     Processes an array of event objects and filters them based on
-     *     global and EAS filtering settings, and
-     *     other criteria such as expired or test products. Valid events
-     *     trigger relevant event emitters.
-     *
-     * @static
-     * @param {unknown[]} events
-     * @returns {Promise<void>}
-     */
-    public static async validateEvents(events: unknown[]): Promise<void> {
-        if (events.length == 0) return;
-        const filteringSettings = loader.settings?.global_settings?.filtering;
-        const easSettings = loader.settings?.global_settings?.eas_settings;
-        const globalSettings = loader.settings?.global_settings;
-        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((event: types.EventCompiled) => {
-            const originalEvent = this.buildDefaultSignature(event);
-            const props = originalEvent?.properties;
-            const ugcs = props?.geocode?.UGC ?? [];
-            const { details, ...properties } = originalEvent.properties; 
-            originalEvent.properties.parent = originalEvent.properties.event;          
-            originalEvent.properties.event = this.betterParsedEventName(originalEvent, bools?.better_event_parsing, bools?.parent_events_only);
-            originalEvent.properties.hash = loader.packages.crypto.createHash('md5').update(JSON.stringify(properties)).digest('hex');
-            if (originalEvent.properties.is_test == true) {
-                loader.cache.events.emit(`onTest`, originalEvent);
-                if (bools?.ignore_test_products) {
-                    return false;
-                }
-            }
-            if (originalEvent.properties.is_cancelled == true) {
-                loader.cache.events.emit(`onExpired`, originalEvent);
-                if (bools?.check_expired) {
-                    return false;
-                }
-            }
-            loader.cache.events.emit(`on${originalEvent.properties.event.replace(/\s+/g, '')}`, originalEvent);
-            for (const key in sets) {
-                const setting = sets[key];
-                if (key === 'events' && setting.size > 0 && !setting.has(originalEvent.properties.event.toLowerCase())) { 
-                    loader.cache.events.emit(`onFilteredEvent`, originalEvent); return false 
-                } 
-                if (key === 'ignored_events' && setting.size > 0 && setting.has(originalEvent.properties.event.toLowerCase())) { 
-                    loader.cache.events.emit(`onIgnoredEvent`, originalEvent); return false 
-                } 
-                if (key === 'filtered_icao' && setting.size > 0 && props.sender_icao != null && !setting.has(props.sender_icao.toLowerCase())) { 
-                    loader.cache.events.emit(`onFilteredICAO`, originalEvent); return false 
-                }
-                if (key === 'ignored_icao' && setting.size > 0 && props.sender_icao != null && setting.has(props.sender_icao.toLowerCase())) { 
-                    loader.cache.events.emit(`onIgnoredICAO`, originalEvent); return false 
-                }
-                if (key === 'ugc_filter' && setting.size > 0 && ugcs.length > 0 && !ugcs.some((ugc: string) => setting.has(ugc.toLowerCase()))) { 
-                    loader.cache.events.emit(`onFilteredUGC`, originalEvent); return false 
-                }
-                if (key === 'state_filter' && setting.size > 0 && ugcs.length > 0 && !ugcs.some((ugc: string) => setting.has(ugc.substring(0, 2).toLowerCase()))) { 
-                    loader.cache.events.emit(`onFilteredState`, originalEvent); return false 
-                }
-            }
-            return true;
-        })
-            for (const event of filtered as types.EventCompiled[]) {
-                if (!loader.settings.global_settings.ignore_geometry_parsing) {
-                const geometry = await this.getEventGeometry(event.properties.geocode.generated, {
-                    zones: event.properties.geocode != null ? event.properties.geocode.UGC : null
-                })
-                event.geometry = geometry;
-            }
-        } 
-        if (filtered.length > 0) { loader.cache.events.emit(`onEvents`, filtered); }
-    }
-
-    /**
-     * @function getHeader
-     * @description
-     *     Constructs a standardized alert header string using provided
-     *     stanza attributes, event properties, and optional VTEC data.
-     *
-     * @static
-     * @param {types.StanzaAttributes} attributes
-     * @param {types.EventProperties} [properties]
-     * @param {types.PVtecEntry} [pVtec]
-     * @returns {string}
-     */
-    public static getHeader(attributes: types.StanzaAttributes, properties?: types.EventProperties, pVtec?: types.PVtecEntry): string {
-        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 = pVtec?.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
-    }
-   
-    /**
-     * @function eventHandler
-     * @description
-     *     Routes a validated stanza object to the appropriate alert handler
-     *     based on its type flags: API, CAP, pVTEC (Primary VTEC), UGC, or plain text.
-     *
-     * @static
-     * @param {types.StanzaCompiled} metadata
-     * @returns {void}
-     */
-    public static eventHandler(metadata: types.StanzaCompiled): Promise<void> {
-        const settings = loader.settings as types.ClientSettingsTypes;
-        const preferences = settings.noaa_weather_wire_service_settings.preferences;
-        if (metadata.isApi) return APIAlerts.event(metadata)
-        if (metadata.isCap) return CAPAlerts.event(metadata)
-        if (!preferences.disable_vtec && !metadata.isCap && metadata.isPVtec && metadata.isUGC) return VTECAlerts.event(metadata);
-        if (!preferences.disable_ugc && !metadata.isCap && !metadata.isPVtec && metadata.isUGC) return UGCAlerts.event(metadata); 
-        if (!preferences.disable_text && !metadata.isCap && !metadata.isPVtec && !metadata.isUGC) return TextAlerts.event(metadata);
-        return;
-    }
-
-    /**
-     * @function getICAO
-     * @description
-     *     Determines the ICAO code and corresponding name for an event.
-     *     Priority is given to the VTEC tracking code, then the attributes' `cccc` property, 
-     *     and finally the WMO code if available. Returns null if none are found.
-     *
-     * @private
-     * @static
-     * @param {types.PVtecEntry | null} pVtec
-     * @param {Record<string, string>} metadata
-     * @param {RegExpMatchArray | string | null} WMO
-     * @returns {{ icao: string; name: string }}
-     */
-    private static getICAO(pVtec: types.PVtecEntry, metadata: types.DefaultAttributesType, WMO: RegExpMatchArray | string | null): { icao: string; name: string } {
-        const icao = pVtec != null ? pVtec?.tracking.split(`-`)[0] : (metadata.attributes?.cccc || (WMO != null ? (Array.isArray(WMO) ? WMO[0] : WMO) : null));
-        const name = loader.definitions.ICAO?.[icao] ?? null;
-        return { icao, name };
-    }
-
-    /**
-     * @function getCorrectIssuedDate
-     * @description
-     *     Determines the issued date for an event based on the provided attributes.
-     *     Falls back to the current date and time if no valid issue date is available.
-     *
-     * @private
-     * @static
-     * @param {Record<string, string>} metadata
-     * @returns {string}
-     */
-    private static getCorrectIssuedDate(metadata: types.DefaultAttributesType): string {
-        const time = metadata.attributes.issue != null ? 
-            new Date(metadata.attributes.issue).toISOString() : (metadata.attributes?.issue != null ? 
-            new Date(metadata.attributes.issue).toISOString() : 
-            new Date().toISOString());
-        return time;
-    }
-
-    /**
-     * @function getCorrectExpiryDate
-     * @description
-     *     Determines the most appropriate expiry date for an event using VTEC or UGC data.
-     *     Falls back to one hour from the current time if no valid expiry is available.
-     *
-     * @private
-     * @static
-     * @param {types.PVtecEntry} pVtec
-     * @param {types.UGCEntry} ugc
-     * @returns {string}
-     */
-    private static getCorrectExpiryDate(pVtec: types.PVtecEntry, ugc: types.UGCEntry): string | Date {
-        const time =  pVtec?.expires && !isNaN(new Date(pVtec.expires).getTime()) ? 
-            new Date(pVtec.expires).toISOString() : (ugc?.expiry != null ? new Date(ugc.expiry).toISOString() : new Date(new Date().getTime() + 1 * 60 * 60 * 1000))
-        if (isNaN(new Date(time).getTime())) {
-            return `Until Further Notice`
-        }
-        return time;
-    }
-
-    /**
-     * @function buildDefaultSignature
-     * @description
-     *     Populates default properties for an event object, including action type flags,
-     *     tags, and status updates. Determines if the event is issued, updated, or cancelled
-     *     based on correlations, description content, VTEC codes, and expiration time.
-     *
-     * @private
-     * @static
-     * @param {any} event
-     * @returns {types.EventCompiled}
-     */
-    private static buildDefaultSignature(event: types.EventCompiled): types.EventCompiled {
-        const props = event.properties ?? {};
-        const statusCorrelation = loader.definitions.correlations.find((c: { type: string }) => c.type === props.action_type);
-        const defEventTags = loader.definitions.tags;
-        const tags = Object.entries(defEventTags).filter(([key]) => props?.description?.toLowerCase().includes(key.toLowerCase())).map(([, value]) => value)
-        props.tags = tags.length > 0 ? tags : [];
-        if (statusCorrelation) { 
-            props.action_type = statusCorrelation.forward ?? props.action_type; 
-            props.is_updated = !!statusCorrelation.update; props.is_issued = !!statusCorrelation.new;
-            props.is_cancelled = !!statusCorrelation.cancel;
-        } else { 
-            props.is_issued = true
-        }
-        if (props.description) { 
-            const detectedPhrase = loader.definitions.cancelSignatures.find(sig => props.description.toLowerCase().includes(sig.toLowerCase()));
-            if (detectedPhrase) { 
-                props.is_cancelled = true;
-            }
-        }
-        if (props.details?.pvtec) { 
-            const getType = props.details.pvtec.split(`.`)[0]?.replace(`/`, ``)
-            const isTestProduct = loader.definitions.productTypes[getType] == `Test Product`
-            const isTestSig = [`This is a test message`, `THIS_MESSAGE_IS_FOR_TEST_PURPOSES_ONLY`]
-            if (isTestProduct || isTestSig.some(sig => props?.description?.toLowerCase().includes(sig.toLowerCase()) || props?.instruction?.toLowerCase().includes(sig.toLowerCase()))) {
-                props.is_test = true
-            }
-        }
-        if (new Date(props?.expires).getTime() < new Date().getTime()) {
-            props.is_cancelled = true
-        }
-        return event; 
-    }
-}
-
-export default EventParser

package/src/@parsers/hvtec.ts

@@ -1,46 +0,0 @@
-/*
-                                            _               _     __   __
-         /\  | |                           | |             (_)    \ \ / /
-        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ V / 
-       / /\ \| __| "_ ` _ \ / _ \/ __| "_ \| "_ \ / _ \ "__| |/ __| > <  
-      / ____ \ |_| | | | | | (_) \__ \ |_) | | | |  __/ |  | | (__ / . \ 
-     /_/    \_\__|_| |_| |_|\___/|___/ .__/|_| |_|\___|_|  |_|\___/_/ \_\
-                                     | |                                 
-                                     |_|                                                                                                                
-    
-    Written by: KiyoWx (k3yomi)                
-*/
-
-import * as loader from '../bootstrap';
-import * as types from '../types';
-
-export class HVtecParser {
-    
-    /**
-     * @function HVtecExtractor
-     * @description
-     *     Extracts VTEC entries from a raw NWWS message string and returns
-     *     structured objects containing type, tracking, event, status,
-     *     WMO identifiers, and expiry date.
-     *
-     * @static
-     * @param {string} message
-     * @returns {Promise<types.HtecEntry[] | null>}
-     */
-    public static async HVtecExtractor(message: string): Promise<types.HVtecEntry[] | null> {
-        const matches = message.match(loader.definitions.regular_expressions.hvtec);
-        if (!matches || matches.length !== 1) return null;
-        const hvtec = matches[0];
-        const parts = hvtec.split('.');
-        if (parts.length < 7) return null;
-        const hvtecs: types.HVtecEntry[] = [{
-            severity: loader.definitions.severity[parts[1]],
-            cause: loader.definitions.causes[parts[2]],
-            record: loader.definitions.records[parts[6]],
-            raw: hvtec,
-        }];
-        return hvtecs;
-    }
-}
-
-export default HVtecParser;

package/src/@parsers/pvtec.ts

@@ -1,72 +0,0 @@
-/*
-                                            _               _     __   __
-         /\  | |                           | |             (_)    \ \ / /
-        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ V / 
-       / /\ \| __| "_ ` _ \ / _ \/ __| "_ \| "_ \ / _ \ "__| |/ __| > <  
-      / ____ \ |_| | | | | | (_) \__ \ |_) | | | |  __/ |  | | (__ / . \ 
-     /_/    \_\__|_| |_| |_|\___/|___/ .__/|_| |_|\___|_|  |_|\___/_/ \_\
-                                     | |                                 
-                                     |_|                                                                                                                
-    
-    Written by: KiyoWx (k3yomi)                
-*/
-
-import * as loader from '../bootstrap';
-import * as types from '../types';
-
-export class PVtecParser {
-    
-    /**
-     * @function pVtecExtractor
-     * @description
-     *     Extracts VTEC entries from a raw NWWS message string and returns
-     *     structured objects containing type, tracking, event, status,
-     *     WMO identifiers, and expiry date.
-     *
-     * @static
-     * @param {string} message
-     * @returns {Promise<types.VtecEntry[] | null>}
-     */
-    public static async pVtecExtractor(message: string): Promise<types.PVtecEntry[] | null> {
-        const matches = message.match(loader.definitions.regular_expressions.pvtec) ?? [];
-        const pVtecs: types.PVtecEntry[] = [];
-        for (const pvtec of matches) {
-            const parts = pvtec.split('.');
-            if (parts.length < 7) continue; 
-            const dates = parts[6].split('-');
-            pVtecs.push({
-                raw: pvtec,
-                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(loader.definitions.regular_expressions.wmo)?.[0] || null,
-                expires: this.parseExpiryDate(dates),
-                isKWNS: (parts[4] == `A` || parts[4] == `Y`) && (parts[3] == `TO` || parts[3] == `SV`) ? true : false,
-            });
-        }
-        return pVtecs.length > 0 ? pVtecs : null;
-    }
-
-    /**
-     * @function parseExpiryDate
-     * @description
-     *     Converts a NWWS VTEC/expiry timestamp string into a formatted local ISO date string
-     *     with an Eastern Time offset (-04:00). Returns `Invalid Date Format` if the input
-     *     is `000000T0000Z`.
-     *
-     * @private
-     * @static
-     * @param {string[]} args
-     * @returns {string}
-     */
-    private static parseExpiryDate(args: String[]): 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 PVtecParser;

package/src/@parsers/stanza.ts

@@ -1,97 +0,0 @@
-/*
-                                            _               _     __   __
-         /\  | |                           | |             (_)    \ \ / /
-        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ V / 
-       / /\ \| __| "_ ` _ \ / _ \/ __| "_ \| "_ \ / _ \ "__| |/ __| > <  
-      / ____ \ |_| | | | | | (_) \__ \ |_) | | | |  __/ |  | | (__ / . \ 
-     /_/    \_\__|_| |_| |_|\___/|___/ .__/|_| |_|\___|_|  |_|\___/_/ \_\
-                                     | |                                 
-                                     |_|                                                                                                                
-    
-    Written by: KiyoWx (k3yomi)                
-*/
-
-import * as loader from '../bootstrap';
-import * as types from '../types';
-
-export class StanzaParser {
-
-    /**
-     * @function validate
-     * @description
-     *     Validates and parses a stanza message, extracting its attributes and metadata.
-     *     Handles both raw message strings (for debug/testing) and actual stanza objects.
-     *     Determines whether the message is a CAP alert, contains VTEC codes, or contains UGCs,
-     *     and identifies the AWIPS product type and prefix.
-     *
-     * @static
-     * @param {any} stanza
-     * @param {boolean | types.StanzaAttributes} [isDebug=false]
-     * @returns {{
-     *     message: string;
-     *     attributes: types.StanzaAttributes;
-     *     isCap: boolean,
-     *     isPVtec: boolean;
-     *     isCapDescription: boolean;
-     *     awipsType: Record<string, string>;
-     *     isApi: boolean;
-     *     ignore: boolean;
-     *     isUGC?: boolean;
-     * }}
-     */
-    public static validate(stanza: any, isDebug: boolean | types.StanzaAttributes = false): { message: string; attributes: types.StanzaAttributes; isCap: any; isPVtec: boolean; isCapDescription: any; awipsType: any; isApi: boolean; ignore: boolean; isUGC?: boolean; } {
-        if (isDebug !== false) { 
-            const vTypes = isDebug as types.StanzaAttributes;  
-            const message = stanza;
-            const attributes = vTypes;
-            const isCap = vTypes.isCap ?? message.includes(`<?xml`);
-            const isCapDescription = message.includes(`<areaDesc>`);
-            const isPVtec = message.match(loader.definitions.regular_expressions.pvtec) != null;
-            const isUGC = message.match(loader.definitions.regular_expressions.ugc1) != null;
-            const awipsType = this.getType(attributes);
-            return { message, attributes, isCap, isPVtec, 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 isPVtec = message.match(loader.definitions.regular_expressions.pvtec) != null;
-                    const isUGC = message.match(loader.definitions.regular_expressions.ugc1) != null;
-                    const awipsType = this.getType(attributes);
-                    return { message, attributes, isCap, isPVtec, isUGC, isCapDescription, awipsType: awipsType, isApi: false, ignore: false  };
-                }
-            }
-        }
-        return { message: null, attributes: null, isApi: null, isCap: null, isPVtec: null, isUGC: null, isCapDescription: null, awipsType: null, ignore: true };
-    }
-
-    /**
-     * @function getType
-     * @description
-     *     Determines the AWIPS product type and prefix from a stanza's attributes.
-     *     Returns a default type of 'XX' if the attributes are missing or the AWIPS ID
-     *     does not match any known definitions.
-     *
-     * @private
-     * @static
-     * @param {unknown} attributes
-     * @returns {Record<string, string>}
-     */
-    private static getType(attributes: unknown): Record<string, string> {
-        const attrs = attributes as types.StanzaAttributesType | undefined;
-        if (!attrs?.awipsid) return { type: 'XX', prefix: 'XX' };
-        const awipsDefs = loader.definitions.awips as Record<string, string>;
-        for (const [prefix, type] of Object.entries(awipsDefs)) {
-            if (attrs.awipsid.startsWith(prefix)) {
-                return { type, prefix };
-            }
-        }
-        return { type: 'XX', prefix: 'XX' };
-    }  
-}
-
-export default StanzaParser;