@atmosx/event-product-parser 2.0.16 → 3.0.1

package/dist/index.d.mts

@@ -0,0 +1,235 @@
+type TypeWebhook = {
+    webhook: string;
+    title: string;
+    message: string;
+    rate: number;
+    events: string[];
+};
+
+type TypeSettings = {
+    Database: string;
+    EnableWireService: boolean;
+    EnableJournal: boolean;
+    NOAAWeatherWireServiceSettings: {
+        ReconnectionSettings: {
+            Enabled: boolean;
+            ReconnectionInterval: number;
+        };
+        CredentialSettings: {
+            Username: string | void;
+            Password: string | void;
+            Nickname: string | void;
+        };
+        CacheSettings: {
+            Enabled: boolean;
+            MaxDatabaseHistory: number;
+            MaxRetentionHistory: number;
+        };
+        StanzaSettings: {
+            DisableUGC: boolean;
+            DisableVTEC: boolean;
+            DisableText: boolean;
+        };
+    };
+    NationalWeatherServiceSettings: {
+        CallbackInterval: number;
+        EventsEndpoint: string;
+    };
+    GlobalSettings: {
+        EventManagement: boolean;
+        BetterEventNames: boolean;
+        DisableGeometryParsing: boolean;
+        UseShapefileCoordinates: boolean;
+        SPCWatchesOnly: boolean;
+        ShapefileSkipPoints: number;
+        NodeTTL: number;
+        NodeMinDistance: number;
+        WebhookSettings?: TypeWebhook;
+        EventFiltering: {
+            ListeningEvents: string[];
+            ListeningICAO: string[];
+            ListeningUGC: string[];
+            ListeningStates: string[];
+            IgnoredICAO: string[];
+            IgnoredEvents: string[];
+            NodeLocationFiltering: boolean;
+            IgnoreTestProducts: boolean;
+        };
+        EASSettings: {
+            ArchiveDirectory: string;
+            IntroWavFile: string;
+        };
+    };
+};
+
+declare const setSettings: (newSettings: TypeSettings) => TypeSettings;
+
+type TypeAttributes = {
+    xmlns: string;
+    id: string;
+    issue: string;
+    ttaaii: string;
+    cccc: string;
+    awipsid: string;
+};
+
+type TypeEventProperties = {
+    locations: string;
+    description: string;
+    attributes: TypeAttributes;
+    geocode: {
+        office: {
+            name: string;
+            office: string;
+        };
+        organization: string;
+        ugc: string[];
+        polygon: string;
+        polygon_generated: boolean;
+    };
+    parameters: {
+        tags: string[];
+        instructions: string;
+        source: string;
+        hazards: string;
+        impacts: string;
+        estimated_hail_size: string;
+        estimated_wind_gusts: string;
+        damage_threat: string;
+        tornado_threat: string;
+        flood_threat: string;
+        wind_threat: string;
+        hail_threat: string;
+        max_hail_inches?: string;
+        max_wind_gusts_surface_knots?: string;
+        max_tops_x100feet?: string;
+        mean_storm_motion_vector?: string;
+        particularly_dangerous_situation?: string;
+    };
+    watch_parameters?: {
+        watch_number: string;
+        watch_type: string;
+        additional_tornadoes_probability: string;
+        strong_tornadoes_probability: string;
+        severe_wind_probability: string;
+        severe_hail_probability: string;
+        hail_2in_probability: string;
+        combined_hail_wind_probability: string;
+        max_hail_in: string;
+        max_wind_surface: string;
+        max_tops_x100feet: string;
+        pds_watch: boolean;
+    };
+    spc_parameters: {
+        spc_max_tornado: string;
+        spc_max_hail: string;
+        spc_max_wind: string;
+        spc_watch_issuance: string;
+    };
+};
+
+type TypeHVTEC = {
+    hvtec: string;
+    severity: string;
+    cause: string;
+    record: string;
+};
+
+type TypePVTEC = {
+    vtec: string;
+    product: string;
+    tracking: string;
+    event: string;
+    status: string;
+    organization: string;
+    expires: string;
+    is_watch: boolean;
+    prediction_center: boolean;
+};
+
+type TypeEvent = {
+    type: string;
+    geometry: {
+        type: string;
+        coordinates: number[][];
+    };
+    properties: {
+        event: string;
+        parent: string;
+        status: string;
+        issued: string;
+        expires: string;
+        status_metadata?: {
+            is_issued?: boolean;
+            is_updated?: boolean;
+            is_expired?: boolean;
+            is_test?: boolean;
+        };
+        metadata: {
+            ms: number;
+            source: string;
+            tracking: string;
+            hash?: string;
+            header: string;
+            vtec: TypePVTEC | null;
+            hvtec: TypeHVTEC[];
+            nodes?: {
+                id?: string | number;
+                coordinates: [number, number];
+                nearest: [number, number];
+                miles: number | null;
+                kilometers: number | null;
+                proximity: boolean;
+            }[];
+            filtered_proximity?: boolean;
+            updated?: number;
+            history: {
+                description: string;
+                issued: string;
+                status: string;
+            }[];
+        };
+    } & TypeEventProperties;
+};
+
+interface GetGeometryResponse {
+    type: `Polygon` | `MultiPolygon`;
+    coordinates: any[];
+}
+declare const getEventGeometry: (event: TypeEvent) => Promise<GetGeometryResponse>;
+
+declare const getCleanedEvent: <T extends Record<string, any>>(event: T) => T;
+
+declare const startService: (settings: TypeSettings) => Promise<void>;
+
+declare const stopService: () => Promise<void>;
+
+interface GenerateEASOptions {
+    message: string;
+    header: string;
+}
+declare const setEasTone: (options: GenerateEASOptions) => Promise<string>;
+
+interface GetAddChaserOptions {
+    identifier: string;
+    delete?: boolean;
+    coordinates: {
+        longitude: number;
+        latitude: number;
+    };
+}
+declare const setNode: (options: GetAddChaserOptions) => void;
+
+declare const getEvents: () => any;
+
+declare const getNodes: () => any;
+
+declare const getRandomEvent: () => any;
+
+declare class Manager {
+    constructor(settings: TypeSettings);
+    on(event: string, callback: () => void): void;
+    trycatch(): void;
+}
+
+export { Manager, type TypeEvent, Manager as default, getCleanedEvent, getEventGeometry, getEvents, getNodes, getRandomEvent, setEasTone, setNode, setSettings, startService, stopService };

package/dist/index.d.ts

@@ -0,0 +1,235 @@
+type TypeWebhook = {
+    webhook: string;
+    title: string;
+    message: string;
+    rate: number;
+    events: string[];
+};
+
+type TypeSettings = {
+    Database: string;
+    EnableWireService: boolean;
+    EnableJournal: boolean;
+    NOAAWeatherWireServiceSettings: {
+        ReconnectionSettings: {
+            Enabled: boolean;
+            ReconnectionInterval: number;
+        };
+        CredentialSettings: {
+            Username: string | void;
+            Password: string | void;
+            Nickname: string | void;
+        };
+        CacheSettings: {
+            Enabled: boolean;
+            MaxDatabaseHistory: number;
+            MaxRetentionHistory: number;
+        };
+        StanzaSettings: {
+            DisableUGC: boolean;
+            DisableVTEC: boolean;
+            DisableText: boolean;
+        };
+    };
+    NationalWeatherServiceSettings: {
+        CallbackInterval: number;
+        EventsEndpoint: string;
+    };
+    GlobalSettings: {
+        EventManagement: boolean;
+        BetterEventNames: boolean;
+        DisableGeometryParsing: boolean;
+        UseShapefileCoordinates: boolean;
+        SPCWatchesOnly: boolean;
+        ShapefileSkipPoints: number;
+        NodeTTL: number;
+        NodeMinDistance: number;
+        WebhookSettings?: TypeWebhook;
+        EventFiltering: {
+            ListeningEvents: string[];
+            ListeningICAO: string[];
+            ListeningUGC: string[];
+            ListeningStates: string[];
+            IgnoredICAO: string[];
+            IgnoredEvents: string[];
+            NodeLocationFiltering: boolean;
+            IgnoreTestProducts: boolean;
+        };
+        EASSettings: {
+            ArchiveDirectory: string;
+            IntroWavFile: string;
+        };
+    };
+};
+
+declare const setSettings: (newSettings: TypeSettings) => TypeSettings;
+
+type TypeAttributes = {
+    xmlns: string;
+    id: string;
+    issue: string;
+    ttaaii: string;
+    cccc: string;
+    awipsid: string;
+};
+
+type TypeEventProperties = {
+    locations: string;
+    description: string;
+    attributes: TypeAttributes;
+    geocode: {
+        office: {
+            name: string;
+            office: string;
+        };
+        organization: string;
+        ugc: string[];
+        polygon: string;
+        polygon_generated: boolean;
+    };
+    parameters: {
+        tags: string[];
+        instructions: string;
+        source: string;
+        hazards: string;
+        impacts: string;
+        estimated_hail_size: string;
+        estimated_wind_gusts: string;
+        damage_threat: string;
+        tornado_threat: string;
+        flood_threat: string;
+        wind_threat: string;
+        hail_threat: string;
+        max_hail_inches?: string;
+        max_wind_gusts_surface_knots?: string;
+        max_tops_x100feet?: string;
+        mean_storm_motion_vector?: string;
+        particularly_dangerous_situation?: string;
+    };
+    watch_parameters?: {
+        watch_number: string;
+        watch_type: string;
+        additional_tornadoes_probability: string;
+        strong_tornadoes_probability: string;
+        severe_wind_probability: string;
+        severe_hail_probability: string;
+        hail_2in_probability: string;
+        combined_hail_wind_probability: string;
+        max_hail_in: string;
+        max_wind_surface: string;
+        max_tops_x100feet: string;
+        pds_watch: boolean;
+    };
+    spc_parameters: {
+        spc_max_tornado: string;
+        spc_max_hail: string;
+        spc_max_wind: string;
+        spc_watch_issuance: string;
+    };
+};
+
+type TypeHVTEC = {
+    hvtec: string;
+    severity: string;
+    cause: string;
+    record: string;
+};
+
+type TypePVTEC = {
+    vtec: string;
+    product: string;
+    tracking: string;
+    event: string;
+    status: string;
+    organization: string;
+    expires: string;
+    is_watch: boolean;
+    prediction_center: boolean;
+};
+
+type TypeEvent = {
+    type: string;
+    geometry: {
+        type: string;
+        coordinates: number[][];
+    };
+    properties: {
+        event: string;
+        parent: string;
+        status: string;
+        issued: string;
+        expires: string;
+        status_metadata?: {
+            is_issued?: boolean;
+            is_updated?: boolean;
+            is_expired?: boolean;
+            is_test?: boolean;
+        };
+        metadata: {
+            ms: number;
+            source: string;
+            tracking: string;
+            hash?: string;
+            header: string;
+            vtec: TypePVTEC | null;
+            hvtec: TypeHVTEC[];
+            nodes?: {
+                id?: string | number;
+                coordinates: [number, number];
+                nearest: [number, number];
+                miles: number | null;
+                kilometers: number | null;
+                proximity: boolean;
+            }[];
+            filtered_proximity?: boolean;
+            updated?: number;
+            history: {
+                description: string;
+                issued: string;
+                status: string;
+            }[];
+        };
+    } & TypeEventProperties;
+};
+
+interface GetGeometryResponse {
+    type: `Polygon` | `MultiPolygon`;
+    coordinates: any[];
+}
+declare const getEventGeometry: (event: TypeEvent) => Promise<GetGeometryResponse>;
+
+declare const getCleanedEvent: <T extends Record<string, any>>(event: T) => T;
+
+declare const startService: (settings: TypeSettings) => Promise<void>;
+
+declare const stopService: () => Promise<void>;
+
+interface GenerateEASOptions {
+    message: string;
+    header: string;
+}
+declare const setEasTone: (options: GenerateEASOptions) => Promise<string>;
+
+interface GetAddChaserOptions {
+    identifier: string;
+    delete?: boolean;
+    coordinates: {
+        longitude: number;
+        latitude: number;
+    };
+}
+declare const setNode: (options: GetAddChaserOptions) => void;
+
+declare const getEvents: () => any;
+
+declare const getNodes: () => any;
+
+declare const getRandomEvent: () => any;
+
+declare class Manager {
+    constructor(settings: TypeSettings);
+    on(event: string, callback: () => void): void;
+    trycatch(): void;
+}
+
+export { Manager, type TypeEvent, Manager as default, getCleanedEvent, getEventGeometry, getEvents, getNodes, getRandomEvent, setEasTone, setNode, setSettings, startService, stopService };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@atmosx/event-product-parser",
-	"version": "2.0.016",
+	"version": "3.0.1",
 	"description": "NOAA Weather Wire & NWS API Parser - Built for standalone and Project AtmosphericX Integration.",
 	"main": "dist/cjs/index.cjs",
 	"module": "dist/esm/index.mjs",
@@ -11,9 +11,10 @@
 	},
 	"scripts": {
 		"start": "cd ./test && node ./index.js",
-    	"build": "tsup && cd ./test && node ./index.js",
+		"build": "tsup && cd ./test && node ./index.js",
+		"heap-memory-errors": "node --heap-prof --heap-prof-name=heap-profile-%p.heapsnapshot ./test/index.js",
 		"publish": "tsup && npm publish --access public",
-		"publish-beta": "tsup && npm publish --tag beta --access public"
+		"publish-beta-branch": "tsup && npm publish --tag v3-beta-branch --access public"
 	},
 	"keywords": [
 		"NWWS",
@@ -33,10 +34,11 @@
 	"homepage": "https://github.com/AtmosphericX/event-product-parser#readme",
 	"dependencies": {
 		"@xmpp/client": "0.14.0",
-		"better-sqlite3": "11.10.0",
+		"better-sqlite3": "12.10.0",
 		"croner": "10.0.1",
 		"jszip": "3.10.1",
 		"polygon-clipping": "0.15.7",
+		"request": "^2.88.2",
 		"say": "0.16.0",
 		"shapefile": "0.6.6",
 		"typescript": "5.9.3",

package/src/@building/building.clean.ts

@@ -0,0 +1,30 @@
+/*
+              _                             _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ V / 
+       / /\ \| __| '_ ` _ \ / _ \/ __| '_ \| '_ \ / _ \ '__| |/ __| > <  
+      / ____ \ |_| | | | | | (_) \__ \ |_) | | | |  __/ |  | | (__ / . \ 
+     /_/    \_\__|_| |_| |_|\___/|___/ .__/|_| |_|\___|_|  |_|\___/_/ \_\
+                                     | |                            
+                                     |_|                                                                                                                
+
+    Created with ♥ by the AtmosphericX Team (KiyoWx, StarflightWx, & CJ Ziegler)
+    Discord: https://atmosphericx-discord.scriptkitty.cafe
+    Ko-Fi: https://ko-fi.com/k3yomi
+    Documentation: http://localhost/documentation | https://atmosphericx.scriptkitty.cafe/documentation
+
+    Internal Package: @atmosx/event-product-parser
+
+*/
+
+export const getCleanedEvent = <T extends Record<string, any>>(event: T): T => {
+    for (const key of Object.keys(event)) {
+        const value = event[key];
+        if (value === null || value === undefined) {
+            delete event[key];
+        } else if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+            (event as Record<string, any>)[key] = getCleanedEvent(value as Record<string, any>) as any;
+        }
+    }
+    return event;
+};

package/src/@building/building.create.ts

@@ -0,0 +1,42 @@
+/*
+              _                             _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ V / 
+       / /\ \| __| '_ ` _ \ / _ \/ __| '_ \| '_ \ / _ \ '__| |/ __| > <  
+      / ____ \ |_| | | | | | (_) \__ \ |_) | | | |  __/ |  | | (__ / . \ 
+     /_/    \_\__|_| |_| |_|\___/|___/ .__/|_| |_|\___|_|  |_|\___/_/ \_\
+                                     | |                            
+                                     |_|                                                                                                                
+
+    Created with ♥ by the AtmosphericX Team (KiyoWx, StarflightWx, & CJ Ziegler)
+    Discord: https://atmosphericx-discord.scriptkitty.cafe
+    Ko-Fi: https://ko-fi.com/k3yomi
+    Documentation: http://localhost/documentation | https://atmosphericx.scriptkitty.cafe/documentation
+
+    Internal Package: @atmosx/event-product-parser
+
+*/
+
+import { TypeStanzaCompiled } from "../@types/types.compiled"
+import { TypeSettings } from "../@types/types.settings"
+import { bootstrap } from "../bootstrap"
+import { text } from "../@events/events.text"
+import { ugc } from "../@events/events.ugc"
+import { vtec } from "../@events/events.vtec"
+import { api } from "../@events/events.api"
+
+export const createEvent = async (stanza: TypeStanzaCompiled): Promise<void | string> => {
+    const settings = bootstrap.settings as TypeSettings
+    const StanzaSettings = settings.NOAAWeatherWireServiceSettings.StanzaSettings;
+
+    const isVtecEvent = (stanza.isVTEC && stanza.isUGC)
+    const isUgcEvent = (!stanza.isVTEC && stanza.isUGC)
+    const isTextEvent = (!stanza.isVTEC && !stanza.isUGC)
+    const isNWWS = (stanza.isNWWS)
+
+    if (!isNWWS) return await api(stanza)
+    if (!StanzaSettings.DisableVTEC && isVtecEvent) return await vtec(stanza)
+    if (!StanzaSettings.DisableUGC && isUgcEvent) return await ugc(stanza);
+    if (!StanzaSettings.DisableText && isTextEvent) return await text(stanza);
+    return 'nothing picked';
+}

package/src/@building/building.enhance.ts

@@ -0,0 +1,56 @@
+/*
+              _                             _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ V / 
+       / /\ \| __| '_ ` _ \ / _ \/ __| '_ \| '_ \ / _ \ '__| |/ __| > <  
+      / ____ \ |_| | | | | | (_) \__ \ |_) | | | |  __/ |  | | (__ / . \ 
+     /_/    \_\__|_| |_| |_|\___/|___/ .__/|_| |_|\___|_|  |_|\___/_/ \_\
+                                     | |                            
+                                     |_|                                                                                                                
+
+    Created with ♥ by the AtmosphericX Team (KiyoWx, StarflightWx, & CJ Ziegler)
+    Discord: https://atmosphericx-discord.scriptkitty.cafe
+    Ko-Fi: https://ko-fi.com/k3yomi
+    Documentation: http://localhost/documentation | https://atmosphericx.scriptkitty.cafe/documentation
+
+    Internal Package: @atmosx/event-product-parser
+
+*/
+
+import { TypeEvent } from "../@types/type.event";
+import { TypeSettings } from "../@types/types.settings";
+import { bootstrap } from "../bootstrap"
+import { betterEventNames } from "../@dictionaries/dictionaries.betterEventNames"
+
+export const getEventEnhancedName = (event: TypeEvent): string => {
+    const configurations = bootstrap.settings as TypeSettings
+    let name = event?.properties?.event
+
+    if (!configurations?.GlobalSettings?.BetterEventNames) {
+        return name 
+    }
+
+    const damage = event?.properties?.parameters?.damage_threat
+    const tornado = event?.properties?.parameters.tornado_threat;
+    const description = event?.properties?.description?.toLowerCase()
+    for (const [eventKey, eventConfig] of Object.entries(betterEventNames)) {
+        if (eventKey !== name) continue;
+        for (const [paramKey, paramValue] of Object.entries(eventConfig)) {
+            let matches = true;
+            if (paramValue?.description) {
+                if (!description.includes(paramValue.description.toLowerCase())) matches = false;
+            }
+            if (paramValue?.damage) {
+                if (paramValue.damage !== damage) matches = false;
+            }
+            if (paramValue?.tornado) {
+                if (paramValue.tornado !== tornado) matches = false;
+            }
+            if (matches) {
+                name = paramKey;
+                break;
+            }
+        }
+    }
+    return name;
+}

package/src/@building/building.geometry.ts

@@ -0,0 +1,48 @@
+/*
+              _                             _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ V / 
+       / /\ \| __| '_ ` _ \ / _ \/ __| '_ \| '_ \ / _ \ '__| |/ __| > <  
+      / ____ \ |_| | | | | | (_) \__ \ |_) | | | |  __/ |  | | (__ / . \ 
+     /_/    \_\__|_| |_| |_|\___/|___/ .__/|_| |_|\___|_|  |_|\___/_/ \_\
+                                     | |                            
+                                     |_|                                                                                                                
+
+    Created with ♥ by the AtmosphericX Team (KiyoWx, StarflightWx, & CJ Ziegler)
+    Discord: https://atmosphericx-discord.scriptkitty.cafe
+    Ko-Fi: https://ko-fi.com/k3yomi
+    Documentation: http://localhost/documentation | https://atmosphericx.scriptkitty.cafe/documentation
+
+    Internal Package: @atmosx/event-product-parser
+
+*/
+
+import { getSettings } from "../@modules/@utilities/utilities.getSettings";
+import { TypeSettings } from "../@types/types.settings"
+import { TypeEvent } from "../@types/type.event"
+import { getZonePolygon } from "../@parsers/@ugc/ugc.coordinates";
+
+interface GetGeometryResponse { 
+    type: `Polygon` | `MultiPolygon`
+    coordinates: any[]
+}
+
+export const getEventGeometry = async (event: TypeEvent): Promise<GetGeometryResponse> => {
+    const settings = getSettings() as TypeSettings
+    const generated = event?.properties?.geocode?.polygon ?? null;
+    const ugc = event?.properties?.geocode?.ugc ?? null;
+    let geo: GetGeometryResponse = {
+        type: `Polygon`,
+        coordinates: generated != null ? JSON.parse(Buffer.from(generated, 'base64').toString('utf-8')) : null
+    }
+    if (settings.GlobalSettings.UseShapefileCoordinates && generated == null && ugc != null) { 
+        geo = await getZonePolygon({zones: ugc, isUnion: false})
+        if (geo == null) {
+            geo = {
+                type: `Polygon`,
+                coordinates: []
+            }
+        }
+    }
+    return geo;
+}