@atmosx/event-product-parser 2.0.15 → 3.0.0

package/src/index.ts

@@ -1,240 +1,72 @@
 /*
-                                            _               _     __   __
+              _                             _               _     __   __
          /\  | |                           | |             (_)    \ \ / /
         /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ V / 
-       / /\ \| __| "_ ` _ \ / _ \/ __| "_ \| "_ \ / _ \ "__| |/ __| > <  
+       / /\ \| __| '_ ` _ \ / _ \/ __| '_ \| '_ \ / _ \ '__| |/ __| > <  
       / ____ \ |_| | | | | | (_) \__ \ |_) | | | |  __/ |  | | (__ / . \ 
      /_/    \_\__|_| |_| |_|\___/|___/ .__/|_| |_|\___|_|  |_|\___/_/ \_\
-                                     | |                                 
+                                     | |                            
                                      |_|                                                                                                                
-    
-    Written by: KiyoWx (k3yomi)                
-*/
-
-import * as loader from './bootstrap';
-import * as types from './types';
-import Utils from './@submodules/utils';
-import Xmpp from './@submodules/xmpp';
-import EAS from './@submodules/eas';
-import Database from './@submodules/database';
-import StanzaParser from './@parsers/stanza';
-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 Manager { 
-    isNoaaWeatherWireService: boolean
-    job: any
-    constructor(metadata: types.ClientSettingsTypes) { 
-        this.sigCatch();
-        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 getEventPolygon
-     * @description
-     *    Retrieves the geographical polygon for a given event based on its
-     *    generated geocode and UGC zones.
-     * 
-     * @async
-     * @param {types.EventCompiled} event
-     * @returns {Promise<types.geometry | null>}
-     */
-    public async getEventPolygon(event: types.EventCompiled, isUnion: boolean = true): Promise<types.geometry | null> {
-        const hasGenerated = event.properties.geocode?.generated ?? null;
-        const getUgc = event.properties.geocode?.UGC ?? null;
-        return await EventParser.getEventGeometry(hasGenerated, {zones: getUgc}, isUnion);
-    }
-
-    /**
-     * @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<string>}
-     */
-    public async createEasAudio(description: string, header: string): Promise<string> {
-        return await EAS.generateEASAudio(description, header);
-    }
+    Created with ♥ by the AtmosphericX Team (KiyoWx, StarflightWx, Everwatch1, & CJ Ziegler)
+    Discord: https://atmosphericx-discord.scriptkitty.cafe
+    Ko-Fi: https://ko-fi.com/k3yomi
+    Documentation: http://localhost/documentation | https://atmosphericx.scriptkitty.cafe/documentation
 
-    /**
-     * @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}`)
-        );
-    }
+    Internal Package: @atmosx/event-product-parser
 
-    /**
-     * @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<string[]>}
-     */
-    public async searchStanzaDatabase(query: string, limit: number = 250): Promise<string[]> {
-        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): Promise<void> {
-        Utils.mergeClientSettings(loader.settings, settings);
-    }
+import { TypeSettings } from './@types/types.settings'
+import { setSettings } from "./@modules/@utilities/utilities.setSettings"
+import { getEventGeometry } from "./@building/building.geometry";
+import { getCleanedEvent } from "./@building/building.clean"
+import { setEventEmit } from './@modules/@utilities/utilities.setEventEmit';
+import { setWarning } from './@modules/@utilities/utilities.setWarning';
+import { listener } from "./@core/core.listener"
+import { startService } from "./@core/core.start"
+import { stopService } from "./@core/core.stop"
+import { setNode } from "./@core/core.setNode"
+import { getEvents } from "./@core/core.getEvents"
+import { getNodes } from "./@core/core.getNodes"
 
-    /**
-     * @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): () => void {
-        loader.cache.events.on(event, callback);
-        return () => loader.cache.events.off(event, callback);
-    }
+export class Manager { 
+    constructor(settings: TypeSettings) { this.trycatch();startService(settings) }
 
-    /**
-     * @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;
-        await Database.loadDatabase();
-        if (this.isNoaaWeatherWireService) {
-            (async () => {
-                try {
-                    await Xmpp.deploySession();
-                    await Database.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);
-        });
+    on(event: string, callback: () => void) {
+        listener(event, callback)
     }
 
-    /**
-     * @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;
-        }
-    }
-    
-    /**
-     * @function sigCatch
-     * @description
-     *     Sets up a global handler for uncaught exceptions, ignoring specific error codes
-     *
-     * @async
-     * @returns void
-     */
-    private sigCatch() {
+    trycatch() {
         process.on('uncaughtException', (err: any) => {
             const ignored = ['ETIMEDOUT', 'ECONNRESET', 'EHOSTUNREACH', 'STARTTLS_FAILURE'];
             if (ignored.includes(err?.code)) { 
-                Utils.warn(`XMPP Critical Error: ${err?.code ?? 'Unknown error code'}. This may indicate a connection issue. Attempting to continue...`);
+                setEventEmit({
+                    event: `onXMPPStatus`,
+                    metadata: {
+                        message: `XMPP Critical Error: ${err?.code ?? 'Unknown error code'}. This may indicate a connection issue. Attempting to continue...`,
+                        data: {},
+                        type: `error`,
+                        error: true 
+                    }
+                })
                 return; 
             }
-            Utils.warn(`Uncaught Exception: ${err instanceof Error ? err.stack || err.message : String(err)}`);
+            setWarning({message: `Uncaught Exception: ${err instanceof Error ? err.stack || err.message : String(err)}`})
         })
     }
 }
 
 export default Manager;
-export type * as types from './types';
-export { StanzaParser, EventParser, TextParser, PVtecParser, HVtecParser, UGCParser, EAS, Database, Utils };
+export { 
+    setSettings,
+    getEventGeometry,
+    getCleanedEvent,
+    stopService,
+    startService,
+    setNode,
+    getEvents,
+    getNodes,
+}
+
+export type { TypeSettings } from './@types/types.settings'

package/test.js

@@ -1,62 +1,78 @@
-const { AlertManager } = require(`@atmosx/event-product-parser`)
+const { Manager, setSettings, getSettings, getListener } = require(`../dist/cjs/index.cjs`)
 
-
-const parser = new AlertManager({ 
+const NOAAWeatherWireService = new Manager({
     database: `shapefile-manager.db`,
-    is_wire: true,
-    journal: true,
-    noaa_weather_wire_service_settings: {
-        reconnection_settings: {
-            enabled: true,
-            interval: 60,
+    EnableWireService: true,
+    EnableJournal: false,
+    NOAAWeatherWireServiceSettings: {
+        ReconnectionSettings: {
+            Enabled: true,
+            ReconnectionInterval: 60,
         },
-        credentials: {
-            username: `username123`,
-            password: `password123`,
-            nickname: "AtmosphericX Standalone Parser",
+        CredentialSettings: {
+            Username: `username_here`,
+            Password: `password_here`,
+            Nickname: "nick_name_here (@atmosx/event-product-parser/3.0)",
         },   
-        cache: {
-            enabled: false,
-            max_db_history: 5000,
-            max_db_cache_size: 1000,
+        CacheSettings: {
+            Enabled: true,
+            MaxDatabaseHistory: 15000,
+            MaxRetentionHistory: 500,
         },
-        preferences: {
-            disable_ugc: false,
-            disable_vtec: false,
-            disable_text: false,
-            cap_only: false,
+        StanzaSettings: {
+            DisableUGC: false,
+            DisableVTEC: false,
+            DisableText: false,
         }
     },
-    national_weather_service_settings: {
-        interval: 15,
-        endpoint: `https://api.weather.gov/alerts/active`,
+    NationalWeatherServiceSettings: {
+        CallbackInterval: 15,
+        EventsEndpoint: `https://api.weather.gov/alerts/active`,
     },
-    global_settings: {
-        parent_events_only: true,
-        better_event_parsing: true,
-        ignore_geometry_parsing: false,
-        shapefile_coordinates: true,
-        filtering: {
-            events: [`Severe Thunderstorm Warning`],
-            filtered_icao: ["PAFC"],
-            ignored_icao: [],
-            ignored_events: [`Xx`, `Test Message`],
-            ugc_filter: [],
-            state_filter: [],
-            check_expired: true,
-            ignore_test_products: true,
+    GlobalSettings: {
+        BetterEventNames: true,
+        DisableGeometryParsing: false,
+        UseShapefileCoordinates: true,
+        EventFiltering: {
+            ListeningEvents: [
+                "Tornado Emergency", "PDS Tornado Warning", "Tornado Warning",
+                "Confirmed Tornado Warning", "Radar Indicated Tornado Warning",
+                "Special Marine Warning (TPROB)", "PDS Tornado Watch", "Tornado Watch",
+                "EDS Severe Thunderstorm Warning (TPROB)", "EDS Severe Thunderstorm Warning",
+                "Destructive Severe Thunderstorm Warning (TPROB)", "Destructive Severe Thunderstorm Warning",
+                "Considerable Severe Thunderstorm Warning (TPROB)", "Considerable Severe Thunderstorm Warning",
+                "Severe Thunderstorm Warning (TPROB)", "Severe Thunderstorm Warning",
+                "Severe Thunderstorm Watch",
+                "Flash Flood Emergency", "Flash Flood Warning",
+                "Flash Flood Watch",
+                "Tsunami Warning", "Tsunami Watch",
+                "Tsunami Advisory", "Special Marine Warning",
+                "Earthquake Warning",
+                "Hurricane Warning", "Hurricane Watch",
+                "Tropical Storm Warning",
+                "Winter Storm Warning", "Blizzard Warning",
+                "Ice Storm Warning", "Snow Squall Warning",
+                "Winter Weather Advisory", "Extreme Cold Watch"
+            ],
+            ListeningICAO: [],
+            IgnoredICAO: [],
+            IgnoredEvents: [],
+            ListeningUGC: [],
+            ListeningStates: [],
+            IgnoreTestProducts: true,
         },
-        eas_settings: {
-            directory: null,
-            intro_wav: null,
+        EASSettings: {
+            ArchiveDirectory: null,
+            IntroWavFile: null,
         }
     }
 })
 
-parser.on(`onEvents`, (alerts) => {
-   for (const alert of alerts) {
-        if (alert.geometry != null) {
-            console.log(`[${ new Date(alert.properties.issued).toLocaleString()}] ${alert.properties.event} for ${alert.properties.locations} (ID: ${alert.properties.details.tracking})`);
-        }
-    }
-});
+
+NOAAWeatherWireService.on(`log`, (data) => {
+    console.log(data)
+})
+
+NOAAWeatherWireService.on(`onEventStatus`, (data) => { 
+    console.log(`[${data.type}]: ${data.event.properties.event} (${data.event.properties.status}) (${data.event.properties.metadata.tracking})`)
+})

package/src/@dictionaries/events.ts

@@ -1,168 +0,0 @@
-/*
-                                            _               _     __   __
-         /\  | |                           | |             (_)    \ \ / /
-        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ V / 
-       / /\ \| __| "_ ` _ \ / _ \/ __| "_ \| "_ \ / _ \ "__| |/ __| > <  
-      / ____ \ |_| | | | | | (_) \__ \ |_) | | | |  __/ |  | | (__ / . \ 
-     /_/    \_\__|_| |_| |_|\___/|___/ .__/|_| |_|\___|_|  |_|\___/_/ \_\
-                                     | |                                 
-                                     |_|                                                                                                                
-    
-    Written by: KiyoWx (k3yomi)                
-*/
-
-export const events: Record<string, string> = {
-    "AF": "Ashfall",
-    "AS": "Air Stagnation",
-    "BH": "Beach Hazard",
-    "BW": "Brisk Wind",
-    "BZ": "Blizzard",
-    "CF": "Coastal Flood",
-    "DF": "Debris Flow",
-    "DS": "Dust Storm",
-    "EC": "Extreme Cold",
-    "EH": "Excessive Heat",
-    "XH": "Extreme Heat",
-    "EW": "Extreme Wind",
-    "FA": "Areal Flood",
-    "FF": "Flash Flood",
-    "FG": "Dense Fog",
-    "FL": "Flood",
-    "FR": "Frost",
-    "FW": "Fire Weather",
-    "FZ": "Freeze",
-    "GL": "Gale",
-    "HF": "Hurricane Force Wind",
-    "HT": "Heat",
-    "HU": "Hurricane",
-    "HW": "High Wind",
-    "HY": "Hydrologic",
-    "HZ": "Hard Freeze",
-    "IS": "Ice Storm",
-    "LE": "Lake Effect Snow",
-    "LO": "Low Water",
-    "LS": "Lakeshore Flood",
-    "LW": "Lake Wind",
-    "MA": "Special Marine",
-    "EQ": "Earthquake",
-    "MF": "Dense Fog",
-    "MH": "Ashfall",
-    "MS": "Dense Smoke",
-    "RB": "Small Craft for Rough Bar",
-    "RP": "Rip Current Risk",
-    "SC": "Small Craft",
-    "SE": "Hazardous Seas",
-    "SI": "Small Craft for Winds",
-    "SM": "Dense Smoke",
-    "SQ": "Snow Squall",
-    "SR": "Storm",
-    "SS": "Storm Surge",
-    "SU": "High Surf",
-    "SV": "Severe Thunderstorm",
-    "SW": "Small Craft for Hazardous Seas",
-    "TO": "Tornado",
-    "TR": "Tropical Storm",
-    "TS": "Tsunami",
-    "TY": "Typhoon",
-    "SP": "Special Weather",
-    "UP": "Heavy Freezing Spray",
-    "WC": "Wind Chill",
-    "WI": "Wind",
-    "WS": "Winter Storm",
-    "WW": "Winter Weather",
-    "ZF": "Freezing Fog",
-    "ZR": "Freezing Rain",
-    "ZY": "Freezing Spray"
-};
-
-export const offshore: Record<string, string> = {
-    "Special Weather Statement": "Special Weather Statement",
-    "Hurricane Warning": "Hurricane Warning",
-    "Hurricane Force Wind Warning": "Hurricane Force Wind Warning",
-    "Hurricane Watch": "Hurricane Watch",
-    "Tropical Storm Warning": "Tropical Storm Warning",
-    "Tropical Storm Watch": "Tropical Storm Watch",
-    "High Wind Warning": "High Wind Warning",
-    "Gale Warning": "Gale Warning",
-    "Small Craft Advisory": "Small Craft Advisory",
-    "Small Craft Warning": "Small Craft Warning",
-};
-
-export const actions: Record<string, string> = {
-    "W": "Warning", 
-    "F": "Forecast", 
-    "A": "Watch", 
-    "O": "Outlook", 
-    "Y": "Advisory", 
-    "N": "Synopsis", 
-    "S": "Statement"
-}
-
-
-export const status: Record<string, string> = {
-    "NEW": "Issued", 
-    "CON": "Updated", 
-    "EXT": "Extended", 
-    "EXA": "Extended", 
-    "EXB": "Extended",
-    "UPG": "Upgraded", 
-    "COR": "Correction", 
-    "ROU": "Routine", 
-    "CAN": "Cancelled", 
-    "EXP": "Expired" 
-}
-
-export const types: Record<string, string> = {
-    "O": "Operational Product",
-    "T": "Test Product",
-    "E": "Experimental Product",
-    "X": "Experimental Product (Non-Operational)",
-}
-
-export const status_correlations: {type: string, forward: string, cancel: boolean, update: boolean, new: boolean}[] = [
-    {type: "Update", forward: "Updated", cancel: false, update: true, new: false},
-    {type: "Cancel", forward: "Cancelled", cancel: true, update: false, new: false},
-    {type: "Alert", forward: "Issued", cancel: false, update: false, new: true},
-    {type: "Updated", forward: "Updated", cancel: false, update: true, new: false},
-    {type: "Expired", forward: "Expired", cancel: true, update: false, new: false},
-    {type: "Issued", forward: "Issued", cancel: false, update: false, new: true},
-    {type: "Extended", forward: "Updated", cancel: false, update: true, new: false},
-    {type: "Correction", forward: "Updated", cancel: false, update: true, new: false},
-    {type: "Upgraded", forward: "Upgraded", cancel: false, update: true, new: false},
-    {type: "Cancelled", forward: "Cancelled", cancel: true, update: false, new: false},
-    {type: "Routine", forward: "Routine", cancel: false, update: true, new: false},
-]
-
-export const causes : Record<string, string> = {
-    "SM": "Snow Melt",
-    "RS": "Rain/Snow Melt",
-    "ER": "Excessive Rain",
-    "DM": "Dam/Levee Failure",
-    "IJ": "Ice Jam",
-    "GO": "Glacier Lake Outburst",
-    "IC": "Ice",
-    "FS": "Flash Flood / Storm Surge",
-    "FT": "Tidal Effects",
-    "ET": "Elevated Upstream Flow",
-    "MC": "Other Multiple Causes",
-    "WT": "Wind and/or Tidal Effects",
-    "DR": "Reservoir Release",
-    "UU": "Unknown",
-    "OT": "Other Effects"
-}
-
-export const records: Record<string, string> = {
-    "NO": "No Record Expected",
-    "NR": "Near Record or possible record",
-    "UU": "Unknown history of records",
-    "OO": "Other",
-}
-
-export const severity: Record<string, string> = {
-    N: "Not Expected",
-    0: "Areal Flood or FF Product",
-    1: "Minor",
-    2: "Moderate",
-    3: "Major",
-    U: "Unknown",
-}