atmosx-nwws-parser 1.0.19 → 1.0.22

package/src/index.ts

@@ -0,0 +1,229 @@
+/*
+                                            _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ V / 
+       / /\ \| __| "_ ` _ \ / _ \/ __| "_ \| "_ \ / _ \ "__| |/ __| > <  
+      / ____ \ |_| | | | | | (_) \__ \ |_) | | | |  __/ |  | | (__ / . \ 
+     /_/    \_\__|_| |_| |_|\___/|___/ .__/|_| |_|\___|_|  |_|\___/_/ \_\
+                                     | |                                 
+                                     |_|                                                                                                                
+    
+    Written by: KiyoWx (k3yomi)                
+*/
+
+
+import * as loader from './bootstrap';
+import * as types from './types';
+import Utils from './utils';
+import Xmpp from './xmpp';
+import StanzaParser from './parsers/stanza';
+import Database from './database';
+import EAS from './eas';
+import EventParser from './parsers/events';
+import TextParser from './parsers/text';
+import PVtecParser from './parsers/pvtec';
+import HVtecParser from './parsers/hvtec';
+import UGCParser from './parsers/ugc';
+
+export class AlertManager { 
+    isNoaaWeatherWireService: boolean
+    job: any
+    constructor(metadata: types.ClientSettingsTypes) { this.start(metadata) }
+    
+    /**
+     * @function setDisplayName
+     * @description
+     *     Sets the display nickname for the NWWS XMPP session. Trims the provided
+     *     name and validates it, emitting a warning if the name is empty or invalid.
+     *
+     * @param {string} [name]
+     */
+    public setDisplayName(name?: string) {
+        const settings = loader.settings as types.ClientSettingsTypes;
+        const trimmed = name?.trim();
+        if (!trimmed) {
+            Utils.warn(loader.definitions.messages.invalid_nickname);
+            return;
+        }
+        settings.noaa_weather_wire_service_settings.credentials.nickname = trimmed;
+    }
+
+    /**
+     * @function setCurrentLocation
+     * @description
+     *     Sets the current location with a name and geographic coordinates.
+     *     Validates the coordinates before updating the cache, emitting warnings
+     *     if values are missing or invalid.
+     *
+     * @param {string} locationName
+     * @param {types.Coordinates} [coordinates]
+     */
+    public setCurrentLocation(locationName: string, coordinates?: types.Coordinates): void {
+        if (!coordinates) {
+            Utils.warn(`Coordinates not provided for location: ${locationName}`);
+            return;
+        }
+        const { lat, lon } = coordinates;
+        if (typeof lat !== 'number' || typeof lon !== 'number' || lat < -90 || lat > 90 || lon < -180 || lon > 180) {
+            Utils.warn(loader.definitions.messages.invalid_coordinates.replace('{lat}', String(lat)).replace('{lon}', String(lon)));
+            return;
+        }
+        loader.cache.currentLocations[locationName] = coordinates;
+    }
+
+    /**
+     * @function createEasAudio
+     * @description
+     *     Generates an EAS (Emergency Alert System) audio file using the provided
+     *     description and header.
+     *
+     * @async
+     * @param {string} description
+     * @param {string} header
+     * @returns {Promise<Buffer>}
+     */
+    public async createEasAudio(description: string, header: string) {
+        return await EAS.generateEASAudio(description, header);
+    }
+
+    /**
+     * @function getAllAlertTypes
+     * @description
+     *     Generates a list of all possible alert types by combining defined
+     *     event names with action names.
+     *
+     * @returns {string[]}
+     */
+    public getAllAlertTypes(): string[] {
+        const events = new Set(Object.values(loader.definitions.events));
+        const actions = new Set(Object.values(loader.definitions.actions));
+        return Array.from(events).flatMap(event =>
+            Array.from(actions).map(action => `${event} ${action}`)
+        );
+    }
+
+    /**
+     * @function searchStanzaDatabase
+     * @description
+     *     Searches the stanza database for entries containing the specified query.
+     *     Escapes SQL wildcard characters and returns results in descending order
+     *     by ID, up to the specified limit.
+     *
+     * @async
+     * @param {string} query
+     * @param {number} [limit=250]
+     * @returns {Promise<any[]>}
+     */
+    public async searchStanzaDatabase(query: string, limit: number = 250) {
+        const escapeLike = (s: string) => s.replace(/[%_]/g, '\\$&');
+        const rows = await loader.cache.db
+            .prepare(`SELECT * FROM stanzas WHERE stanza LIKE ? ESCAPE '\\' ORDER BY id DESC LIMIT ${limit}`)
+            .all(`%${escapeLike(query)}%`);
+        return rows;
+    }
+
+    /**
+     * @function setSettings
+     * @description
+     *     Merges the provided client settings into the current configuration,
+     *     preserving nested structures.
+     *
+     * @async
+     * @param {types.ClientSettingsTypes} settings
+     * @returns {Promise<void>}
+     */
+    public async setSettings(settings: types.ClientSettingsTypes) {
+        Utils.mergeClientSettings(loader.settings, settings);
+    }
+
+    /**
+     * @function on
+     * @description
+     *     Registers a callback for a specific event and returns a function
+     *     to unregister the listener.
+     *
+     * @param {string} event
+     * @param {(...args: any[]) => void} callback
+     * @returns {() => void}
+     */
+    public on(event: string, callback: (...args: any[]) => void) {
+        loader.cache.events.on(event, callback);
+        return () => loader.cache.events.off(event, callback);
+    }
+
+    /**
+     * @function start
+     * @description
+     *     Initializes the client with the provided settings, starts the NWWS XMPP
+     *     session if applicable, loads cached messages, and sets up scheduled
+     *     tasks (cron jobs) for ongoing processing.
+     *
+     * @async
+     * @param {types.ClientSettingsTypes} metadata
+     * @returns {Promise<void>}
+     */
+    public async start(metadata: types.ClientSettingsTypes): Promise<void> {
+        if (!loader.cache.isReady) { 
+            Utils.warn(loader.definitions.messages.not_ready);
+            return;
+        }
+        this.setSettings(metadata);
+        const settings = loader.settings as types.ClientSettingsTypes;
+        this.isNoaaWeatherWireService = settings.is_wire;
+        loader.cache.isReady = false;
+        while (!Utils.isReadyToProcess()) {
+            await Utils.sleep(2000);
+        }
+        await Database.loadDatabase();
+        if (this.isNoaaWeatherWireService) {
+            (async () => {
+                try {
+                    await Xmpp.deploySession();
+                    await Utils.loadCollectionCache();
+                } catch (err: unknown) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    Utils.warn(`Failed to initialize NWWS services: ${msg}`);
+                }
+            })();
+        }
+        Utils.handleCronJob(this.isNoaaWeatherWireService);
+        if (this.job) {
+            try { this.job.stop(); } catch { Utils.warn(`Failed to stop existing cron job.`); }
+            this.job = null;
+        }
+        const interval = !this.isNoaaWeatherWireService ? settings.national_weather_service_settings.interval : 5;
+        this.job = new loader.packages.jobs.Cron(`*/${interval} * * * * *`, () => { 
+            Utils.handleCronJob(this.isNoaaWeatherWireService);
+        });
+    }
+
+    /**
+     * @function stop
+     * @description
+     *     Stops active scheduled tasks (cron job) and, if connected, the NWWS
+     *     XMPP session. Updates relevant cache flags to indicate the session
+     *     is no longer active.
+     *
+     * @async
+     * @returns {Promise<void>}
+     */
+    public async stop(): Promise<void> {
+        loader.cache.isReady = true;
+        if (this.job) {
+            try { this.job.stop(); } catch { Utils.warn(`Failed to stop cron job.`); }
+            this.job = null;
+        }
+        const session = loader.cache.session;
+        if (session && this.isNoaaWeatherWireService) {
+            try { await session.stop(); } catch { Utils.warn(`Failed to stop XMPP session.`); }
+            loader.cache.sigHalt = true;
+            loader.cache.isConnected = false;
+            loader.cache.session = null;
+            this.isNoaaWeatherWireService = false;
+        }
+    }
+
+}
+
+export default AlertManager;
+export { StanzaParser, EventParser, TextParser, PVtecParser, HVtecParser, UGCParser, EAS, Database, Utils };

package/src/parsers/events/api.ts

@@ -0,0 +1,151 @@
+/*
+                                            _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ 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 {
+    
+    /**
+     * @function getTracking
+     * @description
+     *   Generates a unique tracking identifier for a CAP alert based on extracted XML values.
+     *   If VTEC information is available, it constructs the tracking ID from the VTEC components.
+     *   Otherwise, it uses the WMO identifier along with TTAI and CCCC attributes.
+     *
+     * @private
+     * @static
+     * @param {Record<string, string>} extracted 
+     * @returns {string} 
+     */
+    private static getTracking(extracted: Record<string, string>) {
+        return extracted.pVtec ? (() => {
+            const vtecValue = Array.isArray(extracted.pVtec) ? extracted.pVtec[0] : extracted.pVtec;
+            const splitPVTEC = vtecValue.split('.');
+            return `${splitPVTEC[2]}-${splitPVTEC[3]}-${splitPVTEC[4]}-${splitPVTEC[5]}`;
+        })() : (() => {
+            const wmoMatch = extracted.wmoidentifier?.match(/([A-Z]{4}\d{2})\s+([A-Z]{4})/);
+            const id = wmoMatch?.[1] || 'N/A';
+            const station = wmoMatch?.[2] || 'N/A';
+            return `${station}-${id}`;
+        })();
+    }
+
+    /**
+     * @function getICAO
+     * @description
+     *    Extracts the sender's ICAO code and corresponding name from a VTEC string.    
+     *
+     * @private
+     * @static
+     * @param {string} pVtec 
+     * @returns {{ icao: any; name: any; }} 
+     */
+    private static getICAO(pVtec: string) {
+        const icao = pVtec ? pVtec.split(`.`)[2] : `N/A`;
+        const name = loader.definitions.ICAO?.[icao] ?? `N/A`;
+        return { icao, name };
+    }
+    
+    /**
+     * @function event
+     * @description
+     *   Processes validated API alert messages, extracting relevant information and compiling it into structured event objects.
+     *
+     * @public
+     * @static
+     * @async
+     * @param {types.StanzaCompiled} validated 
+     * @returns {*} 
+     */
+    public static async event(validated: types.StanzaCompiled) {
+        let processed = [] as unknown[];
+        const settings = loader.settings as types.ClientSettingsTypes;
+        const messages = Object.values(JSON.parse(validated.message).features) as types.EventCompiled[];
+        for (let feature of messages) {
+            const tick = performance.now();
+            const getPVTEC = 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.StanzaAttributes);
+            const getSource = TextParser.textProductToString(getDescription, `SOURCE...`, [`.`]) || `N/A`;
+            const getOffice = this.getICAO(getPVTEC || ``);
+            processed.push({
+                type: "Feature",
+                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`]
+                    },
+                    metadata: {},
+                    technical: {
+                        vtec: getPVTEC || `N/A`,
+                        ugc: getUgc ? getUgc.join(`,`) : `N/A`,
+                        hvtec: `N/A`,
+                    },
+                    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`,
+                    },
+                },
+                details: {
+                    performance: performance.now() - tick,
+                    source: `api-parser`,
+                    tracking: this.getTracking({ pVtec: getPVTEC, wmoidentifier: getWmo, ugc: getUgc ? getUgc.join(`,`) : null }),
+                    header: getHeader,
+                    pvtec: getPVTEC || `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`
+                    }],
+                },
+                geometry: feature?.geometry?.coordinates?.[0] != null ? {
+                    type: "Polygon", 
+                    coordinates: [
+                        feature?.geometry?.coordinates?.[0]?.map((coord: number[] | any) => {
+                            const [lat, lon] = Array.isArray(coord) ? coord : [0, 0];
+                            return [lat, lon];
+                        })
+                    ]
+                } : await EventParser.getEventGeometry(``, {zones: getUgc})
+            })
+        }
+        EventParser.validateEvents(processed);
+    }
+}
+
+export default APIAlerts;

package/src/parsers/events/cap.ts

@@ -0,0 +1,138 @@
+/*
+                                            _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ V / 
+       / /\ \| __| "_ ` _ \ / _ \/ __| "_ \| "_ \ / _ \ "__| |/ __| > <  
+      / ____ \ |_| | | | | | (_) \__ \ |_) | | | |  __/ |  | | (__ / . \ 
+     /_/    \_\__|_| |_| |_|\___/|___/ .__/|_| |_|\___|_|  |_|\___/_/ \_\
+                                     | |                                 
+                                     |_|                                                                                                                
+    
+    Written by: KiyoWx (k3yomi)                
+*/
+
+import * as types from '../../types';
+import * as loader from '../../bootstrap';
+import EventParser from '../events';
+import TextParser from '../text';
+
+
+export class CapAlerts {
+    
+    /**
+     * @function getTracking
+     * @description
+     *   Generates a unique tracking identifier for a CAP alert based on extracted XML values.
+     *   If VTEC information is available, it constructs the tracking ID from the VTEC components.
+     *   Otherwise, it uses the WMO identifier along with TTAI and CCCC attributes.
+     *
+     * @private
+     * @static
+     * @param {Record<string, string>} extracted 
+     * @returns {string} 
+     */
+    private static getTracking(extracted: Record<string, string>, metadata: types.StanzaAttributes) {
+        return extracted.vtec ? (() => {
+            const vtecValue = Array.isArray(extracted.vtec) ? extracted.vtec[0] : extracted.vtec;
+            const splitPVTEC = vtecValue.split('.');
+            return `${splitPVTEC[2]}-${splitPVTEC[3]}-${splitPVTEC[4]}-${splitPVTEC[5]}`;
+        })() : `${extracted.wmoidentifier.substring(extracted.wmoidentifier.length - 4)}-${metadata.attributes.ttaaii}-${metadata.attributes.id.slice(-4)}`;
+    }
+
+    /**
+     * @function event
+     * @description
+     *    Processes validated CAP alert messages, extracting relevant information and compiling it into structured event objects.   
+     *
+     * @public
+     * @static
+     * @async
+     * @param {types.StanzaCompiled} validated 
+     * @returns {*} 
+     */
+    public static async event(validated: types.StanzaCompiled) {
+        let processed = [] as unknown[];
+        const tick = performance.now();
+        const settings = loader.settings as types.ClientSettingsTypes;
+        const blocks = validated.message.split(/\[SoF\]/gim)?.map(msg => msg.trim());
+        for (const block of blocks) {
+            const cachedAttribute = block.match(/STANZA ATTRIBUTES\.\.\.(\{.*\})/);
+            const messages = block.split(/(?=\$\$)/g)?.map(msg => msg.trim());
+            if (!messages || messages.length == 0) return;
+            for (let i = 0; i < messages.length; i++) {
+                let message = messages[i]
+                const attributes = cachedAttribute != null ? JSON.parse(cachedAttribute[1]) : validated;
+                message = message.substring(message.indexOf(`<?xml version="1.0"`), message.lastIndexOf(`>`) + 1);
+                const parser = new loader.packages.xml2js.Parser({ explicitArray: false, mergeAttrs: true, trim: true })
+                const parsed = await parser.parseStringPromise(message);
+                if (parsed == null || parsed.alert == null) continue;
+                const extracted = TextParser.getXmlValues(parsed, [
+                    `vtec`, `wmoidentifier`, `ugc`, `areadesc`, 
+                    `expires`, `sent`, `msgtype`, `description`,
+                    `event`, `sendername`, `tornadodetection`, `polygon`,
+                    `maxHailSize`, `maxWindGust`, `thunderstormdamagethreat`,
+                    `tornadodamagethreat`, `waterspoutdetection`, `flooddetection`,
+                ]);
+                const getHeader = EventParser.getHeader({ ...validated.attributes,} as types.StanzaAttributes);
+                const getSource = TextParser.textProductToString(extracted.description, `SOURCE...`, [`.`]) || `N/A`;
+                processed.push({
+                    type: "Feature",
+                    properties: {
+                        locations: extracted.areadesc || `N/A`,
+                        event: extracted.event || `N/A`,
+                        issued: extracted.sent ? new Date(extracted.sent).toLocaleString() : `N/A`,
+                        expires: extracted.expires ? new Date(extracted.expires).toLocaleString() : `N/A`,
+                        parent: extracted.event || `N/A`,
+                        action_type: extracted.msgtype || `N/A`,
+                        description: extracted.description || `N/A`,
+                        sender_name: extracted.sendername || `N/A`,
+                        sender_icao: extracted.wmoidentifier ? extracted.wmoidentifier.substring(extracted.wmoidentifier.length - 4) : `N/A`,
+                        attributes: attributes,
+                        geocode: {
+                            UGC: [extracted.ugc],
+                        },
+                        metadata: {attributes},
+                        technical: {
+                            vtec: extracted.vtec || `N/A`,
+                            ugc: extracted.ugc || `N/A`,
+                            hvtec: `N/A`,
+                        },
+                        parameters: {
+                            wmo: extracted.wmoidentifier || `N/A`,
+                            source: getSource,
+                            max_hail_size: extracted.maxHailSize || `N/A`,
+                            max_wind_gust: extracted.maxWindGust || `N/A`,
+                            damage_threat: extracted.thunderstormdamagethreat || `N/A`,
+                            tornado_detection: extracted.tornadodetection || extracted.waterspoutdetection || `N/A`,
+                            flood_detection: extracted.flooddetection || `N/A`,
+                            discussion_tornado_intensity: `N/A`,
+                            discussion_wind_intensity: `N/A`,
+                            discussion_hail_intensity: `N/A`,
+                        },
+                    },
+                    details: {
+                        performance: performance.now() - tick,
+                        source: `cap-parser`,
+                        tracking: this.getTracking(extracted, attributes),
+                        header: getHeader,
+                        pvtec: extracted.vtec || `N/A`,
+                        hvtec: `N/A`,
+                        history: [{ description: extracted.description || `N/A`, issued: extracted.sent ? new Date(extracted.sent).toLocaleString() : `N/A`, type: extracted.msgtype || `N/A` }],
+                    },
+                    geometry: extracted.polygon ? { 
+                        type: "Polygon", 
+                        coordinates: [
+                            extracted.polygon.split(" ").map((coord: string) => {
+                                const [lon, lat] = coord.split(",").map((num: string) => parseFloat(num));
+                                return [lat, lon];
+                            })
+                        ]
+                    } : await EventParser.getEventGeometry(``, {zones: [extracted.ugc]}),
+                })
+            }
+        }
+        EventParser.validateEvents(processed);
+    }
+}
+
+export default CapAlerts;

package/src/parsers/events/text.ts

@@ -0,0 +1,106 @@
+/*
+                                            _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ 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} baseProperties 
+     * @returns {string} 
+     */
+    private static getTracking(properties: types.EventProperties) {
+        return `${properties.sender_icao}-${properties.raw.attributes.ttaaii}-${properties.raw.attributes.id.slice(-4)}`
+    }
+
+    /**
+     * @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) {
+        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) {
+        let processed = [] as unknown[];
+        const blocks = validated.message.split(/\[SoF\]/gim)?.map(msg => msg.trim());
+        for (const block of blocks) {
+            const cachedAttribute = block.match(/STANZA ATTRIBUTES\.\.\.(\{.*\})/);
+            const messages = block.split(/(?=\$\$)/g)?.map(msg => msg.trim());
+            if (!messages || messages.length == 0) return;
+            for (let i = 0; i < messages.length; i++) {
+                const tick = performance.now();
+                const message = messages[i]
+                const attributes = cachedAttribute != null ? JSON.parse(cachedAttribute[1]) : validated;
+                const baseProperties = await EventParser.getBaseProperties(message, attributes) as types.EventProperties;
+                const baseGeometry = await EventParser.getEventGeometry(message);
+                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: `N/A`,
+                        hvtec: `N/A`,
+                        history: [{ description: baseProperties.description, issued: baseProperties.issued, type: `Issued` }],
+                    },
+                    geometry: baseGeometry,
+                })
+            }
+        }
+        EventParser.validateEvents(processed);
+    }
+}
+
+export default TextAlerts;