@atmosx/event-product-parser 2.0.1

package/src/@parsers/@events/text.ts

@@ -0,0 +1,104 @@
+/*
+                                            _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ V / 
+       / /\ \| __| "_ ` _ \ / _ \/ __| "_ \| "_ \ / _ \ "__| |/ __| > <  
+      / ____ \ |_| | | | | | (_) \__ \ |_) | | | |  __/ |  | | (__ / . \ 
+     /_/    \_\__|_| |_| |_|\___/|___/ .__/|_| |_|\___|_|  |_|\___/_/ \_\
+                                     | |                                 
+                                     |_|                                                                                                                
+    
+    Written by: KiyoWx (k3yomi)                
+*/
+
+import * as types from '../../types';
+import * as loader from '../../bootstrap';
+import EventParser from '../events';
+
+export class TextAlerts {
+
+    /**
+     * @function getTracking
+     * @description
+     *    Generates a unique tracking identifier for an event using the sender's ICAO
+     *    and some attributes.
+     *
+     * @private
+     * @static
+     * @param {types.EventProperties} properties 
+     * @returns {string} 
+     */
+    private static getTracking(properties: types.EventProperties): string {
+        return `${properties.sender_icao}-${properties.raw.attributes.ttaaii}-${properties?.raw?.attributes?.id.slice(-4) ?? 'N/A'}`;
+    }
+
+    /**
+     * @function getEvent
+     * @description
+     *     Determines the event name from a text message and its AWIPS attributes.
+     *     If the message contains a known offshore event keyword, that offshore
+     *     event is returned. Otherwise, the event type from the AWIPS attributes
+     *     is formatted into a human-readable string with each word capitalized.
+     *
+     * @private
+     * @static
+     * @param {string} message
+     * @param {types.StanzaAttributes} metadata
+     * @returns {string}
+     */
+    private static getEvent(message: string, metadata: types.StanzaAttributes): string {
+        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 metadata.awipsType.type.split(`-`).map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(` `)
+    }
+
+    /**
+     * @function event
+     * @description
+     *     Processes a compiled text-based NOAA Stanza message and extracts relevant
+     *     event information. Splits the message into multiple segments based on
+     *     markers such as "$$", "ISSUED TIME...", or separator lines, generates
+     *     base properties, headers, event names, and tracking information for
+     *     each segment, then validates and emits the processed events.
+     *
+     * @public
+     * @static
+     * @async
+     * @param {types.StanzaCompiled} validated
+     * @returns {Promise<void>}
+     */
+    public static async event(validated: types.StanzaCompiled): Promise<void> {
+        let processed = [] as unknown[];
+        const messages = validated?.message?.split(/(?=\$\$)/g)?.map(msg => msg.trim())?.filter(msg => msg && msg !== "$$");
+        if (!messages || messages.length == 0) { return }
+        for (let i = 0; i < messages.length; i++) {
+            const tick = performance.now();
+            const message = messages[i]
+            const attributes = validated as types.StanzaAttributes;
+            const baseProperties = await EventParser.getBaseProperties(message, attributes) as types.EventProperties;
+            const getHeader = EventParser.getHeader({ ...validated.attributes, ...baseProperties.raw } as types.StanzaAttributes, baseProperties)
+            const getEvent = this.getEvent(message, attributes);
+            processed.push({
+                properties: { 
+                    event: getEvent, 
+                    parent: getEvent, 
+                    action_type: `Issued`, 
+                    ...baseProperties,
+                    details: {
+                        type: "Feature",
+                        performance: performance.now() - tick,
+                        source: `text-parser`,
+                        tracking: this.getTracking(baseProperties),
+                        header: getHeader,
+                        pvtec: null,
+                        hvtec: null,
+                        history: [{ description: baseProperties.description, issued: baseProperties.issued, type: `Issued` }],
+                    }, 
+                },
+            })
+        }
+        EventParser.validateEvents(processed);
+    }
+}
+
+export default TextAlerts;

package/src/@parsers/@events/ugc.ts

@@ -0,0 +1,107 @@
+/*
+                                            _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ 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 {
+
+    /**
+     * @function getTracking
+     * @description
+     *    Generates a unique tracking identifier for an event using the sender's ICAO
+     *    and some attributes.
+     *
+     * @private
+     * @static
+     * @param {types.EventProperties} properties 
+     * @returns {string} 
+     */
+    private static getTracking(properties: types.EventProperties): string {
+        return `${properties.sender_icao}-${properties.raw.attributes.ttaaii}-${properties?.raw?.attributes?.id.slice(-4) ?? 'N/A'}`;
+    }
+
+    /**
+     * @function getEvent
+     * @description
+     *     Determines the human-readable event name from a message and AWIPS attributes.
+     *     - Checks if the message contains any predefined offshore event keywords
+     *       and returns the matching offshore event if found.
+     *     - Otherwise, returns a formatted event type string from the provided attributes,
+     *       capitalizing the first letter of each word.
+     *
+     * @private
+     * @static
+     * @param {string} message
+     * @param {Record<string, any>} metadata
+     * @returns {string}
+     */
+    private static getEvent(message: string, metadata: types.StanzaAttributes): string {
+        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 metadata.awipsType.type.split(`-`).map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(` `)
+    }
+
+    /**
+     * @function event
+     * @description
+     *     Processes a validated stanza message, extracting UGC entries and
+     *     computing base properties for non-VTEC events. Each extracted event
+     *     is enriched with metadata, performance timing, and history information,
+     *     then filtered and emitted via `EventParser.validateEvents`.
+     *
+     * @static
+     * @async
+     * @param {types.StanzaCompiled} validated
+     * @returns {Promise<void>}
+     */
+    public static async event(validated: types.StanzaCompiled): Promise<void> {
+        let processed = [] as unknown[];
+        const messages = validated?.message?.split(/(?=\$\$)/g)?.map(msg => msg.trim())?.filter(msg => msg && msg !== "$$");
+        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.UGCEntry
+            if (getUGC != null) {
+                const attributes = validated as types.StanzaAttributes;
+                const baseProperties = await EventParser.getBaseProperties(message, attributes, getUGC) as types.EventProperties;
+                const getHeader = EventParser.getHeader({ ...attributes, ...baseProperties.raw } as types.StanzaAttributes, baseProperties);
+                const getEvent = this.getEvent(message, attributes);
+                processed.push({
+                    type: "Feature",
+                    properties: { 
+                        event: getEvent, 
+                        parent: getEvent, 
+                        action_type: `Issued`, 
+                        ...baseProperties, 
+                        details: {
+                            performance: performance.now() - tick,
+                            source: `ugc-parser`,
+                            tracking: this.getTracking(baseProperties),
+                            header: getHeader,
+                            pvtec: null,
+                            hvtec: null,
+                            history: [{ description: baseProperties.description, issued: baseProperties.issued, type: `Issued` }],
+                        }  
+                    },
+                })
+            }
+        }
+        EventParser.validateEvents(processed);
+    }
+}
+
+export default UGCAlerts;

package/src/@parsers/@events/vtec.ts

@@ -0,0 +1,76 @@
+/*
+                                            _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ V / 
+       / /\ \| __| "_ ` _ \ / _ \/ __| "_ \| "_ \ / _ \ "__| |/ __| > <  
+      / ____ \ |_| | | | | | (_) \__ \ |_) | | | |  __/ |  | | (__ / . \ 
+     /_/    \_\__|_| |_| |_|\___/|___/ .__/|_| |_|\___|_|  |_|\___/_/ \_\
+                                     | |                                 
+                                     |_|                                                                                                                
+    
+    Written by: KiyoWx (k3yomi)                
+*/
+
+import * as types from '../../types';
+import pVtecParser from '../pvtec';
+import hVtecParser from '../hvtec';
+import UgcParser from '../ugc';
+import EventParser from '../events';
+
+export class VTECAlerts {
+
+    /**
+     * @function event
+     * @description
+     *     Processes a validated stanza message, extracting VTEC and UGC entries,
+     *     computing base properties, generating headers, and preparing structured
+     *     event objects for downstream handling. Each extracted event is enriched
+     *     with metadata, performance timing, and history information.
+     *
+     * @static
+     * @async
+     * @param {types.StanzaCompiled} validated
+     * @returns {Promise<void>}
+     */
+    public static async event(validated: types.StanzaCompiled): Promise<void> {
+        let processed = [] as unknown[];
+        const messages = validated?.message?.split(/(?=\$\$)/g)?.map(msg => msg.trim())?.filter(msg => msg && msg !== "$$");
+        if (!messages || messages.length == 0) { return }
+        for (let i = 0; i < messages.length; i++) {
+            const tick = performance.now();
+            const message = messages[i]
+            const attributes = validated as types.StanzaAttributes;
+            const getPVTEC = await pVtecParser.pVtecExtractor(message) as types.PVtecEntry[]
+            const getHVTEC = await hVtecParser.HVtecExtractor(message) as types.HVtecEntry
+            const getUGC = await UgcParser.ugcExtractor(message) as types.UGCEntry
+            if (getPVTEC != null && getUGC != null) {
+                for (let j = 0; j < getPVTEC.length; j++) {
+                    const pVtec = getPVTEC[j];
+                    const baseProperties = await EventParser.getBaseProperties(message, attributes, getUGC, pVtec, getHVTEC) as types.EventProperties;
+                    const getHeader = EventParser.getHeader({ ...validated.attributes, ...baseProperties.raw } as types.StanzaAttributes, baseProperties, pVtec);
+                    processed.push({
+                        type: "Feature",
+                        properties: { 
+                            event: pVtec.event, 
+                            parent: pVtec.event, 
+                            action_type: pVtec.status, 
+                            ...baseProperties, 
+                            details: {
+                                performance: performance.now() - tick,
+                                source: `pvtec-parser`,
+                                tracking: pVtec.tracking,
+                                header: getHeader,
+                                pvtec: pVtec.raw,
+                                hvtec: getHVTEC != null ? getHVTEC.raw : null,
+                                history: [{ description: baseProperties.description, issued: baseProperties.issued, type: pVtec.status }],
+                            },
+                        },
+                    })
+                }
+            }
+        }
+        EventParser.validateEvents(processed);
+    }
+}
+
+export default VTECAlerts;

package/src/@parsers/events.ts

@@ -0,0 +1,392 @@
+/*
+                                            _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ 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') ? 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