@atmosx/event-product-parser 3.0.3 → 3.0.6

package/src/@parsers/@ugc/{ugc.extract.ts → UGCExtract.ts}

@@ -17,16 +17,16 @@
 
 */
 
-import { TypeUGC } from "../../@types/types.ugc";
-import { getUGCHeader } from "./ugc.header"
-import { getZones } from "./ugc.zones";
-import { getExpiry } from './ugc.expiry';
-import { getLocations } from "./ugc.locations";
+import { TypeUGC } from "../../@types/UGC";
+import { getUGCHeader } from "./GetUGCHeader"
+import { getZones } from "./GetZones";
+import { GetExpiry } from './GetExpiry';
+import { getLocations } from "./GetLocations";
 
 export const ugcExtract = async (message: string): Promise<TypeUGC> => {
     const head = getUGCHeader(message);
     const ugcs = getZones(head)
-    const expires = getExpiry(message)
+    const expires = GetExpiry(message)
     const areas = await getLocations(ugcs)
     if (!head || ugcs?.length == 0) return;
     return { 

package/src/@types/Actions.ts

@@ -0,0 +1,37 @@
+/*
+              _                             _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ 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 type TypeActions = { 
+    Events: string[]
+    Webhook?: {
+        Enabled: boolean
+        Destination: string
+        Ratelimit: number
+        Title: string
+        Message: string
+    }
+    NotificationServer?: {
+        Enabled: boolean
+        Topic: string
+        Priority?: string | number
+    }
+    Uploads?: {
+        TEXT?: boolean, EAS?: boolean, JSON?: boolean
+    }
+}

package/src/@types/{type.event.ts → Event.ts}

@@ -17,9 +17,9 @@
 
 */
 
-import { TypeEventProperties as BaseTypeEventProperties } from "./type.properties";
-import { TypeHVTEC } from "../@types/types.hvtec";
-import { TypePVTEC } from "./types.pvtec";
+import { TypeEventProperties as BaseTypeEventProperties } from "./Properties";
+import { TypeHVTEC } from "./HVTEC";
+import { TypePVTEC } from "./VTEC";
 
 export type TypeEvent = {
     type: string
@@ -46,8 +46,8 @@ export type TypeEvent = {
             tracking: string
             hash?: string
             header: string
-            vtec: TypePVTEC | null
-            hvtec: TypeHVTEC[]
+            vtec?: TypePVTEC | null
+            hvtec?: TypeHVTEC[] | null
             nodes?: {
                 id?: string | number
                 coordinates: [number, number]
@@ -63,6 +63,8 @@ export type TypeEvent = {
                 issued: string
                 status: string
             }[]
+            attachments?: { name: string; link: string }[]
+            raw: string
         }
     } & BaseTypeEventProperties
 }

package/src/@types/{type.properties.ts → Properties.ts}

@@ -17,12 +17,13 @@
 
 */
 
-import { TypeAttributes } from "./types.attributes";
+import { TypeAttributes } from "./Attributes";
     
 export type TypeEventProperties = {
     locations: string
+    locations_array: string[]
     description: string
-    attributes: TypeAttributes
+    attributes?: TypeAttributes
     geocode: {
         office: {
             name: string 
@@ -33,7 +34,7 @@ export type TypeEventProperties = {
         polygon: string
         polygon_generated: boolean
     }
-    parameters: {
+    parameters?: {
         tags: string[]
         instructions: string
         source: string
@@ -66,10 +67,12 @@ export type TypeEventProperties = {
         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
+    discussion_parameters?: {
+        discussion_number: string
+        discussion_concerning: string
+        discussion_max_tornado: string
+        discussion_max_hail: string
+        discussion_max_wind: string
+        discussion_watch_issuance: string
     }
 }

package/src/@types/{types.settings.ts → Settings.ts}

@@ -17,12 +17,15 @@
 
 */
 
-import { TypeWebhook } from "./types.webhook"
+import { TypeActions } from "./Actions"
+
+type TypeTimezones = string | "CST" | "CDT" | "MDT" | "MST" | "EST" | "EDT" | "HST" | "HDT" | "PDT" | "UTC"
 
 export type TypeSettings = {
     Database: string
     EnableWireService: boolean
     EnableJournal: boolean
+    EnableDebugging: boolean
     NOAAWeatherWireServiceSettings: {
         ReconnectionSettings: {
             Enabled: boolean
@@ -48,16 +51,34 @@ export type TypeSettings = {
         CallbackInterval: number
         EventsEndpoint: string
     }
+    BroadcastifySettings: {
+        BroadcastifyAttachments: boolean
+        BroadcastifyDatabase: string
+        BroadcastifyTags: string[]
+    },
+    NotifyServer: {
+        Enabled: boolean
+        Server: string
+        Timezone?: TypeTimezones
+        MediaStorage: {
+            TEXT?: string
+            JSON?: string
+            EAS?: string
+        }
+        Credentials?: {
+            Username: string | void
+            Password: string | void
+        }
+    }
+    ActionSettings?: TypeActions[]
     GlobalSettings: {
         EventManagement: boolean
-        BetterEventNames: boolean
         DisableGeometryParsing: boolean
         UseShapefileCoordinates: boolean
         SPCWatchesOnly: boolean
         ShapefileSkipPoints: number
         NodeTTL: number
-        NodeMinDistance: number
-        WebhookSettings?: TypeWebhook
+        NodeMaxDistance: number
         EventFiltering: {
             ListeningEvents: string[]
             ListeningICAO: string[]
@@ -68,9 +89,12 @@ export type TypeSettings = {
             NodeLocationFiltering: boolean
             IgnoreTestProducts: boolean
         },
-        EASSettings: {
-            ArchiveDirectory: string,
-            IntroWavFile: string,
+        ArchiveSettings: {
+            TTL: number
+            JSONDirectory: string
+            TextDirectory: string
+            EasDirectory: string
+            EasToneout: string
         }
     }
 }

package/src/@types/{types.compiled.ts → StanzaCompiled.ts}

@@ -17,7 +17,7 @@
 
 */
 
-import { TypeAttributes } from "./types.attributes"
+import { TypeAttributes } from "./Attributes"
 
 export type TypeStanzaCompiled = {
     message?: string
@@ -31,5 +31,6 @@ export type TypeStanzaCompiled = {
     getType?: {
         type: string
         prefix: string
+        discovered: boolean
     }
 }

package/src/bootstrap.ts

@@ -21,7 +21,7 @@ import path from 'path'
 import { EventEmitter } from 'node:events';
 
 export const bootstrap = {
-    version: `3.0.3`,
+    version: `3.0.6`,
     isReady: true,
     ratelimits: {},
     session_xmpp: null,
@@ -42,10 +42,13 @@ export const bootstrap = {
         events: {type: "FeatureCollection", features: []},
         nodes: {type: "FeatureCollection", features: []},
         hashes: [],
+        processed: [],
+        ugc: new Map<string, string[]>()
     },
     settings: {
         Database: path.join(process.cwd(), 'shapefiles.db'),
-        EnableWireService: true,
+        EnableWireService: false,
+        EnableDebugging: false,
         EnableJournal: true,
         NOAAWeatherWireServiceSettings: {
             ReconnectionSettings: {
@@ -72,16 +75,34 @@ export const bootstrap = {
             CallbackInterval: 15,
             EventsEndpoint: `https://api.weather.gov/alerts/active`,
         },
-        WebhookSettings: [],
+        BroadcastifySettings: {
+            BroadcastifyAttachments: true,
+            BroadcastifyDatabase: `https://scriptkitty.cafe/ftp/@atmosphericx/assets/broadcastify.json`,
+            BroadcastifyTags: [`Ham`, `Air`, `Fire`, `Public Safety`, `Weather`, `EMS`, `Police`, `Rail`]
+        },
+        NotifyServer: {
+            Enabled: false,
+            Server: `https://ntfy.sh`,
+            Timezone: "UTC",
+            MediaStorage: {
+                EAS: null,
+                TEXT: null,
+                JSON: null,
+            },
+            Credentials: {
+                Username: null,
+                Password: null
+            }
+        },
+        ActionSettings: [],
         GlobalSettings: {
             EventManagement: true,
-            BetterEventNames: true,
             DisableGeometryParsing: false,
-            UseShapefileCoordinates: false,
+            UseShapefileCoordinates: true,
             SPCWatchesOnly: true,
             ShapefileSkipPoints: 15,
             NodeTTL: 60,
-            NodeMinDistance: 120,
+            NodeMaxDistance: 120,
             EventFiltering: {
                 ListeningEvents: [],
                 ListeningICAO: [],
@@ -92,9 +113,12 @@ export const bootstrap = {
                 NodeLocationFiltering: false,
                 IgnoreTestProducts: true,
             },
-            EASSettings: {
-                ArchiveDirectory: null,
-                IntroWavFile: null,
+            ArchiveSettings: {
+                TTL: 60,
+                JSONDirectory: null,
+                TextDirectory: null,
+                EasDirectory: null,
+                EasToneout: null
             }
         }
     },

package/src/index.ts

@@ -17,37 +17,39 @@
 
 */
 
-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 { createListener } from "./@core/core.createListener"
-import { startService } from "./@core/core.start"
-import { stopService } from "./@core/core.stop"
-import { setEasTone } from './@modules/@eas/eas.setEasTone';
-import { setNode } from "./@core/core.setNode"
-import { getEvents } from "./@core/core.getEvents"
-import { getNodes } from "./@core/core.getNodes"
-import { getRandomEvent } from './@core/core.getRandomEvent';
-import { clearEvents } from './@core/core.clearEvents';
+import { TypeSettings } from './@types/Settings'
+import { SetSettings } from "./@modules/@utilities/SetSettings"
+import { GetEventGeometry } from "./@building/GetEventGeometry";
+import { GetCleanedEvent } from "./@building/GetCleanedEvent"
+import { SetEventEmit } from './@modules/@utilities/SetEventEmit';
+import { SetWarning } from './@modules/@utilities/SetWarning';
+import { CreateListener } from "./@core/CreateListener"
+import { StartService } from "./@core/StartService"
+import { StopService } from "./@core/StopService"
+import { GenerateEASMessage } from './@modules/@eas/GenerateEASMessage';
+import { SetNode } from "./@core/SetNode"
+import { GetEvents } from "./@core/GetEvents"
+import { GetNodes } from "./@core/GetNodes"
+import { ManualEvent } from "./@core/ManualEvent"
+import { GetRandomEvent } from './@core/GetRandomEvent';
+import { QueryStanza } from './@core/QueryStanza';
+import { ClearEvents } from './@core/ClearEvents';
 
 export class Manager { 
-    constructor(settings: TypeSettings) { this.trycatch(); startService(settings) }
+    constructor(settings: TypeSettings) { this.trycatch(); StartService(settings) }
 
     on(event: string, callback: () => void) {
-        createListener(event, callback)
+        CreateListener(event, callback)
     }
 
     trycatch() {
         process.on('uncaughtException', (err: any) => {
-            const ignored = ['ETIMEDOUT', 'ECONNRESET', 'EHOSTUNREACH', 'STARTTLS_FAILURE'];
+            const ignored = ['ETIMEDOUT', 'ECONNRESET', 'EHOSTUNREACH', 'ENOTFOUND', 'ECONNREFUSED', 'EPIPE', 'EADDRINUSE', 'EALREADY', 'EACCES', 'EAGAIN', 'EHOSTDOWN', 'STARTTLS_FAILURE'];
             if (ignored.includes(err?.code)) { 
-                setEventEmit({
+                SetEventEmit({
                     event: `onServiceStatus`,
                     metadata: {
-                        message: `XMPP Critical Error: ${err?.code ?? 'Unknown error code'}. This may indicate a connection issue. Attempting to continue...`,
+                        message: `Ignored Critical Error: ${err?.code ?? 'Unknown error code'}. This may indicate a connection issue. Attempting to continue...`,
                         data: {},
                         type: `error`,
                         error: true 
@@ -55,18 +57,18 @@ export class Manager {
                 })
                 return; 
             }
-            setWarning({message: `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 { TypeEvent } from './@types/type.event';
+export type { TypeEvent } from './@types/Event';
 export { 
-    setSettings, getEventGeometry, 
-    getCleanedEvent, stopService, clearEvents,
-    startService, setNode, getRandomEvent,
-    getEvents, getNodes, setEasTone
+    SetSettings, GetEventGeometry, ManualEvent,
+    GetCleanedEvent, StopService, ClearEvents,
+    StartService, SetNode, GetRandomEvent,
+    GetEvents, GetNodes, GenerateEASMessage, QueryStanza
 }
 
 

package/tsup.config.ts

@@ -4,7 +4,7 @@ export default defineConfig({
 	entry: ['src/index.ts'],
 	outDir: 'dist',
 	format: ['esm', 'cjs'],
-	dts: true,
+	dts: false,
 	noExternal: ["@xmpp/client", "@xmpp/sasl", "@xmpp/sasl-plain"],
 	clean: true,
 	outExtension({ format }) {