@atmosx/event-product-parser 3.0.4 → 3.0.7

package/src/events/ParseAPI.ts

@@ -0,0 +1,129 @@
+/*
+              _                             _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ 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: https://atmosphericx.scriptkitty.cafe/documentation
+
+    Independent Package: @atmosx/event-product-parser
+
+*/
+
+import { TypeStanzaCompiled } from "Types/StanzaCompiled"
+import { TypeVTEC } from "Types/VTEC"
+import { EnumICAO } from "@Enums/ICAO"
+import { Bootstrap } from "@Bootstrap"
+import { GetEventTracking } from "@Building/GetEventTracking"
+import { VTECExtract } from "@ParsingVTEC/VTECExtract"
+import { GetEventTags } from "@Building/GetEventTags"
+import { GetEventTheme } from "@Building/GetEventTheme"
+import { GetEventDirection } from "@Building/GetEventDirection"
+import { GetTextFromProduct } from "@ParsingText/GetTextFromProduct"
+import { SetDebug } from "@Utilities/SetDebug"
+
+export const ParseAPI = async (Stanza: TypeStanzaCompiled): Promise<void> => {
+    const messages = Object.values(JSON.parse(Stanza.Message).features) as any;
+    for (const feature of messages) {
+        const tick = performance.now();
+        const VTEC = VTECExtract(feature?.properties?.parameters?.VTEC?.[0]) ?? null as TypeVTEC[]
+        Bootstrap.Cache.Parsed.push({
+            type: `Feature`,
+            geometry: {
+                type: `Polygon`,
+                coordinates: []
+            },
+            properties: { 
+                event: feature?.properties?.event ?? null,
+                parent: feature?.properties?.event ?? null,
+                status: feature?.properties?.messageType ?? null,
+                issued: feature?.properties?.sent ? new Date(feature?.properties?.sent).toISOString() : null,
+                expires: feature?.properties?.expires ? new Date(feature?.properties?.expires).toISOString() : null,
+                locations: feature?.properties?.areaDesc ?? null,
+                locations_array: feature?.properties?.areaDesc ? feature?.properties?.areaDesc.split('; ') : [],
+                regions: [...new Set(
+                    feature?.properties?.geocode?.UGC?.map((ugc: string) => ugc.match(/^([A-Z]{2})[CZ](\d{3})$/)?.[1])
+                    .filter(Boolean) ?? []
+                )] as string[],
+                regions_string: (() => {
+                    const abbrs = [...new Set(feature?.properties?.geocode?.UGC?.map((l: string) => l.match(/^([A-Z]{2})[CZ](\d{3})$/)?.[1]).filter(Boolean) ?? [])];
+                    return abbrs.length ? abbrs.join(`-`) : null;
+                })(),
+                description: feature?.properties?.description ?? null,
+                attributes: feature?.properties?.attributes ?? {},
+                theme: GetEventTheme(feature?.properties?.event),
+                geocode: {
+                    office: {
+                        office: VTEC ? VTEC?.[0]?.Tracking.split(`.`)[0] : null,
+                        name: EnumICAO[VTEC ? VTEC?.[0]?.Tracking.split(`.`)[0] : null] ?? null,
+                    },
+                    organization:  feature?.properties?.parameters?.WMOidentifier?.[0],
+                    ugc: feature?.properties?.geocode?.UGC ?? [], 
+                    polygon: feature?.geometry?.coordinates.length > 0 ? Buffer.from(JSON.stringify([feature?.geometry?.coordinates[0]])).toString('base64') : null,
+                    polygon_generated: feature?.geometry?.coordinates.length > 0 ? true : false,
+                },
+                parameters: {
+                    tags: GetEventTags(feature?.properties?.description),
+                    instructions: feature?.properties?.instruction ?? null,
+                    source: GetTextFromProduct({ Message: feature?.properties?.description, Find: [`SOURCE...`], Removal: [`.`]}) ?? null,
+                    hazards: GetTextFromProduct({ Message: feature?.properties?.description, Find: [`HAZARD...`], Removal: [`.`]}) ?? null,
+                    impacts: GetTextFromProduct({ Message: feature?.properties?.description, Find: [`IMPACT...`], Removal: [`.`]}) ?? null,
+                    estimated_hail_size: feature?.properties?.parameters?.maxHailSize?.[0] ?? null,
+                    estimated_wind_gusts: feature?.properties?.parameters?.maxWindGust?.[0] ?? null,
+                    direction: GetEventDirection(feature?.properties?.description) ?? null,
+                    damage_threat: feature?.properties?.parameters?.thunderstormDamageThreat?.[0] ?? null,
+                    tornado_threat: feature?.properties?.parameters?.tornadoDetection?.[0] ?? null,
+                    flood_threat: feature?.properties?.parameters?.flashFloodDamageThreat?.[0] ?? null,
+                    wind_threat: feature?.properties?.parameters?.windThreat?.[0] ?? null,
+                    hail_threat: feature?.properties?.parameters?.hailThreat?.[0] ?? null,
+                },
+                discussion_parameters: {
+                    discussion_number: GetTextFromProduct({ Message: feature?.properties?.description, Find: [`Mesoscale Discussion `], Removal: [`Mesoscale Discussion`, `Number`, `...`] })?.toString()?.padStart(4, "0") ?? null,
+                    discussion_concerning: GetTextFromProduct({ Message: feature?.properties?.description, Find: [`Concerning...`] }) ?? null,
+                    discussion_max_tornado: GetTextFromProduct({ Message: feature?.properties?.description, Find: [`MOST PROBABLE PEAK TORNADO INTENSITY...`] }) ?? null,
+                    discussion_max_hail: GetTextFromProduct({ Message: feature?.properties?.description, Find: [`MOST PROBABLE PEAK HAIL SIZE...`] }) ?? null,
+                    discussion_max_wind: GetTextFromProduct({ Message: feature?.properties?.description, Find: [`MOST PROBABLE PEAK WIND GUST...`] }) ?? null,
+                    discussion_watch_issuance: GetTextFromProduct({ Message: feature?.properties?.description, Find: [`Probability of Watch Issuance...`], Removal: [`percent`]}) ?? null,
+                },
+                watch_parameters: {
+                    watch_number: (VTEC?.[0]?.Watch) && (GetTextFromProduct({ Message: feature?.properties?.description, Find: [`ITIES FOR`, `UPDATE FOR`, `Watch Number `], Removal: [`%`, `<`, `:`] })?.replace(/(WT|WS|)/g, '')?.trim()?.toString()?.padStart(4, "0") ?? VTEC?.[0]?.Tracking?.slice(-4)?.toString()?.padStart(4, "0") ?? null),
+                    watch_type: feature?.properties?.description.includes(`TORNADO WATCH`) ? `Tornado` : feature?.properties?.description.includes(`SEVERE`) ? `Severe` : null,
+                    additional_tornadoes_probability: GetTextFromProduct({ Message: feature?.properties?.description, Find: [`PROB OF 2 OR MORE TORNADOES`], Removal: [`%`, `<`, `:`] }) ?? null,
+                    strong_tornadoes_probability: GetTextFromProduct({ Message: feature?.properties?.description, Find: [`PROB OF 1 OR MORE STRONG /EF2-EF5/ TORNADOES`], Removal: [`%`, `<`, `:`] }) ?? null,
+                    severe_wind_probability: GetTextFromProduct({ Message: feature?.properties?.description, Find: [`PROB OF 10 OR MORE SEVERE WIND EVENTS`], Removal: [`%`, `<`, `:`] }) ?? null,
+                    severe_hail_probability: GetTextFromProduct({ Message: feature?.properties?.description, Find: [`PROB OF 10 OR MORE SEVERE HAIL EVENTS`], Removal: [`%`, `<`, `:`] }) ?? null,
+                    hail_2in_probability: GetTextFromProduct({ Message: feature?.properties?.description, Find: [`PROB OF 1 OR MORE HAIL EVENTS >= 2 INCHES`], Removal: [`%`, `<`, `:`] }) ?? null,
+                    combined_hail_wind_probability: GetTextFromProduct({ Message: feature?.properties?.description, Find: [`PROB OF 6 OR MORE COMBINED SEVERE HAIL/WIND EVENTS`], Removal: [`%`, `<`, `:`] }) ?? null,
+                    max_hail_in: GetTextFromProduct({ Message: feature?.properties?.description, Find: [`MAX HAIL /INCHES/`], Removal: [`%`, `<`, `:`] }) ?? null,
+                    max_wind_surface:  GetTextFromProduct({ Message: feature?.properties?.description, Find: [`MAX WIND GUSTS SURFACE /KNOTS/`], Removal: [`%`, `<`, `:`] }) ?? null,
+                    max_tops_x100feet:  GetTextFromProduct({ Message: feature?.properties?.description, Find: [`MAX TOPS /X 100 FEET/`], Removal: [`%`, `<`, `:`] }) ?? null,
+                    pds_watch: (GetTextFromProduct({ Message: feature?.properties?.description, Find: [`PARTICULARLY DANGEROUS SITUATION`], Removal: [`%`, `<`, `:`] }) === `YES`)
+                },
+                metadata: {
+                    ms: performance.now() - tick,
+                    source: `events.api`,
+                    tracking: GetEventTracking({ Type: `API`, WMO: { Identifier: feature?.properties?.parameters?.WMOidentifier?.[0], ID: feature?.id}, VTEC: VTEC?.[0]}),
+                    header: `ZCZC-ATMOSX-${feature?.properties?.parameters?.WMOidentifier}`,
+                    vtec: VTEC?.[0],
+                    hvtec: null,
+                    raw: feature?.properties?.description,
+                    history: [
+                        {
+                            description: feature?.properties?.description,
+                            issued: feature?.properties?.sent ? new Date(feature?.properties?.sent).toISOString() : null,
+                            status: feature?.properties?.messageType ?? null,
+                        }
+                    ]
+                }
+            }
+        })
+        SetDebug({ Title: `ParseAPI`, Message: `${Math.round(performance.now() - tick)}ms` })
+    }
+}

package/src/{@events/events.text.ts → events/ParseText.ts}

@@ -11,45 +11,52 @@
     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
+    Documentation: https://atmosphericx.scriptkitty.cafe/documentation
 
-    Internal Package: @atmosx/event-product-parser
+    Independent Package: @atmosx/event-product-parser
 
 */
 
-import { TypeAttributes } from "../@types/types.attributes";
-import { TypeStanzaCompiled } from "../@types/types.compiled"
-import { TypeEvent } from "../@types/type.event";
-import { properties } from "../@building/building.properties";
-import { getEventHeader } from "../@building/building.headers";
-import { eventsMatchText } from "../@dictionaries/dictionaries.eventsMatchText";
-import { getEventTracking } from "../@building/building.tracking";
-import { validateEvents } from "../@building/building.validate";
+import { TypeAttributes } from "StaticTypes/Attributes"
+import { TypeStanzaCompiled } from "Types/StanzaCompiled"
+import { EnumMatches } from "@Enums/Matches"
+import { Bootstrap } from "@Bootstrap"
+import { GetEventProperties } from "@Building/GetEventProperties"
+import { GetEventHeader } from "@Building/GetEventHeader"
+import { GetEventTracking } from "@Building/GetEventTracking"
+import { GetEventTheme } from "@Building/GetEventTheme"
+import { SetDebug } from "@Utilities/SetDebug"
 
-export const text = async (stanza: TypeStanzaCompiled): Promise<void> => {
-    let processed: TypeEvent[] = [];
-    const getMessages = stanza?.message
+export const ParseText = async (Stanza: TypeStanzaCompiled): Promise<void> => {
+    const getMessages = Stanza?.Message
         ?.split(/(?=\$\$)/g)
         ?.map(message => message.trim())
         ?.filter(message => message && message !== "$$");
     if (!getMessages || getMessages?.length == 0 ) return;
     for (const message of getMessages) {
         const tick = performance.now();
-        const attributes = stanza?.attributes as TypeAttributes
-        const props = properties({ message, attributes })
-        const header = getEventHeader({properties: props, getType: stanza.getType})   
+        const attributes = Stanza?.Attributes as TypeAttributes
+        const props = GetEventProperties({ Message: message, Attributes: attributes })
+        const header = GetEventHeader({ Properties: props, VTEC: null, Type: Stanza.Type })   
         const issued = new Date(attributes.issue)
         const expires = new Date(issued.getTime() + 12 * 60 * 60 * 1000)
-        let event = Object.keys(eventsMatchText).find(event => message.toLowerCase().includes(event.toLowerCase()));
-        let isStatement = false;
+        const matches = EnumMatches[Stanza.Type.Prefix]?.find(match => match.match.test(message.toUpperCase()));
+        
+        let event = matches?.label;
+        let isStatement = matches?.statement ?? false;
+
         if (!event) { 
-            event = stanza.getType.type.split(`-`).map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(` `)
+            event = Stanza.Type.Type;
+            if (!Stanza.Type.Discovered) {
+                event += ` (AWIPSID)`
+            }
             isStatement = true;
         }
-        processed.push({
+        
+        Bootstrap.Cache.Parsed.push({
             type: `Feature`,
             geometry: {
-                type: `Point`,
+                type: `Polygon`,
                 coordinates: []
             },
             properties: { 
@@ -58,14 +65,16 @@ export const text = async (stanza: TypeStanzaCompiled): Promise<void> => {
                 status: isStatement ? `Statement` : `Issued`,
                 issued: (!isNaN(issued.getTime())) ? issued.toISOString() : new Date().toISOString(),
                 expires: isStatement ? new Date(issued.getTime() + 120 * 1000).toISOString() : (!isNaN(expires.getTime())) ? expires.toISOString() : new Date(Date.now() + 60 * 60 * 1000).toISOString(),
+                theme: GetEventTheme(event),
                 ...props,
                 metadata: {
                     ms: performance.now() - tick,
                     source: `events.text`,
-                    tracking: getEventTracking({ type: `RAW`, stanza, attributes, properties: props }),
+                    tracking: GetEventTracking({ Type: `RAW`, Stanza, Attributes: attributes, Properties: props }),
                     header: header,
                     vtec: null,
                     hvtec: null,
+                    raw: message,
                     history: [
                         {
                             description: props.description,
@@ -76,6 +85,6 @@ export const text = async (stanza: TypeStanzaCompiled): Promise<void> => {
                 }
             }
         })  
+        SetDebug({ Title: `ParseText`, Message: `${Math.round(performance.now() - tick)}ms` })
     }
-    validateEvents(processed)
 }

package/src/{@events/events.ugc.ts → events/ParseUGC.ts}

@@ -11,48 +11,56 @@
     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
+    Documentation: https://atmosphericx.scriptkitty.cafe/documentation
 
-    Internal Package: @atmosx/event-product-parser
+    Independent Package: @atmosx/event-product-parser
 
 */
 
-import { TypeAttributes } from "../@types/types.attributes";
-import { TypeStanzaCompiled } from "../@types/types.compiled"
-import { TypeEvent } from "../@types/type.event";
-import { eventsMatchText } from "../@dictionaries/dictionaries.eventsMatchText";
-import { ugcExtract } from "../@parsers/@ugc/ugc.extract";
-import { properties } from "../@building/building.properties";
-import { getEventHeader } from "../@building/building.headers";
-import { getEventTracking } from "../@building/building.tracking";
-import { validateEvents } from "../@building/building.validate";
+import { TypeAttributes } from "StaticTypes/Attributes"
+import { TypeStanzaCompiled } from "Types/StanzaCompiled"
+import { EnumMatches } from "@Enums/Matches"
+import { Bootstrap } from "@Bootstrap"
+import { UGCExtract } from "@ParsingUGC/UGCExtract"
+import { GetEventProperties } from "@Building/GetEventProperties"
+import { GetEventHeader } from "@Building/GetEventHeader"
+import { GetEventTracking } from "@Building/GetEventTracking"
+import { GetEventTheme } from "@Building/GetEventTheme"
+import { SetDebug } from "@Utilities/SetDebug"
 
-export const ugc = async (stanza: TypeStanzaCompiled): Promise<void> => {
-    let processed: TypeEvent[] = [];
-    const getMessages = stanza?.message
+export const ParseUGC = async (Stanza: TypeStanzaCompiled): Promise<void> => {
+    const getMessages = Stanza?.Message
         ?.split(/(?=\$\$)/g)
         ?.map(message => message.trim())
         ?.filter(message => message && message !== "$$");
     if (!getMessages || getMessages?.length == 0 ) return;
     for (const message of getMessages) {
         const tick = performance.now();
-        const attributes = stanza?.attributes as TypeAttributes
-        const ugc = await ugcExtract(message)
+        const attributes = Stanza?.Attributes as TypeAttributes
+        const ugc = await UGCExtract(message)
+
         if (ugc != null ) {
-            const props = properties({ message, attributes, ugc: ugc })
+            const props = GetEventProperties({ Message: message, Attributes: attributes, UGC: ugc })
             const issued = new Date(attributes.issue)
-            const expires = new Date(ugc.expires)
-            const header = getEventHeader({properties: props, getType: stanza.getType })
-            let event = Object.keys(eventsMatchText).find(event => message.toLowerCase().includes(event.toLowerCase()));
-            let isStatement = false;
+            const expires = new Date(ugc.Expires)
+            const header = GetEventHeader({ Properties: props, VTEC: null, Type: Stanza.Type })
+            const matches = EnumMatches[Stanza.Type.Prefix]?.find(match => match.match.test(message.toUpperCase()));
+            
+            let event = matches?.label;
+            let isStatement = matches?.statement ?? false;
+            
             if (!event) { 
-                event = stanza.getType.type.split(`-`).map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(` `)
+                event = Stanza.Type.Type;
+                if (!Stanza.Type.Discovered) {
+                    event += ` (AWIPSID)`
+                }
                 isStatement = true;
             }
-            processed.push({
+            
+            Bootstrap.Cache.Parsed.push({
                 type: `Feature`,
                 geometry: {
-                    type: `Point`,
+                    type: `Polygon`,
                     coordinates: []
                 },
                 properties: { 
@@ -61,14 +69,16 @@ export const ugc = async (stanza: TypeStanzaCompiled): Promise<void> => {
                     status: isStatement ? `Statement` : `Issued`,
                     issued: (!isNaN(issued.getTime())) ? issued.toISOString() : new Date().toISOString(),
                     expires: isStatement ? new Date(issued.getTime() + 120 * 1000).toISOString() : (!isNaN(expires.getTime())) ? expires.toISOString() : new Date(Date.now() + 60 * 60 * 1000).toISOString(),
+                    theme: GetEventTheme(event),
                     ...props,
                     metadata: {
                         ms: performance.now() - tick,
                         source: `events.ugc`,
-                        tracking: getEventTracking({ type: `RAW`, stanza, attributes, properties: props }),
+                        tracking: GetEventTracking({ Type: `RAW`, Stanza, Attributes: attributes, Properties: props }),
                         header: header,
                         vtec: null,
                         hvtec: null,
+                        raw: message,
                         history: [
                             {
                                 description: props.description,
@@ -79,7 +89,7 @@ export const ugc = async (stanza: TypeStanzaCompiled): Promise<void> => {
                     }
                 }
             })
+            SetDebug({ Title: `ParseUGC`, Message: `${Math.round(performance.now() - tick)}ms` })
         }
     }
-    validateEvents(processed)
 }

package/src/events/ParseVTEC.ts

@@ -0,0 +1,88 @@
+/*
+              _                             _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ 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: https://atmosphericx.scriptkitty.cafe/documentation
+
+    Independent Package: @atmosx/event-product-parser
+
+*/
+
+import { TypeAttributes } from "StaticTypes/Attributes"
+import { TypeStanzaCompiled } from "Types/StanzaCompiled"
+import { TypeVTEC } from "Types/VTEC"
+import { TypeHVTEC } from "Types/HVTEC"
+import { Bootstrap } from "@Bootstrap"
+import { VTECExtract } from "@ParsingVTEC/VTECExtract"
+import { HVExtract } from "@ParsingHVTEC/HVExtract"
+import { UGCExtract } from "@ParsingUGC/UGCExtract"
+import { GetEventProperties } from "@Building/GetEventProperties"
+import { GetEventHeader } from "@Building/GetEventHeader"
+import { GetEventTracking } from "@Building/GetEventTracking"
+import { GetEventTheme } from "@Building/GetEventTheme"
+import { SetDebug } from "@Utilities/SetDebug"
+
+export const ParseVTEC = async (Stanza: TypeStanzaCompiled): Promise<void> => {
+    const getMessages = Stanza?.Message
+        ?.split(/(?=\$\$)/g)
+        ?.map(message => message.trim())
+        ?.filter(message => message && message !== "$$");
+    if (!getMessages || getMessages?.length == 0 ) return;
+    for (const message of getMessages) {
+        const tick = performance.now();
+        const attributes = Stanza?.Attributes as TypeAttributes
+        const VTEC = VTECExtract(message) as TypeVTEC[];
+        const hVTEC = HVExtract(message) as TypeHVTEC[];
+        const ugc = await UGCExtract(message)
+        if (VTEC != null && ugc != null ) {
+            for (const vtec of VTEC) {
+                const props = GetEventProperties({ Message: message, Attributes: attributes, UGC: ugc, VTEC: vtec })
+                const header = GetEventHeader({ Properties: props, VTEC: vtec, Type: Stanza.Type })
+                const issued = new Date(attributes.issue)?? new Date()
+                const expires = new Date(vtec.Expires)
+                Bootstrap.Cache.Parsed.push({
+                    type: `Feature`,
+                    geometry: {
+                        type: `Polygon`,
+                        coordinates: []
+                    },
+                    properties: { 
+                        event: vtec.Event,
+                        parent: vtec.Event,
+                        status: vtec.Status,
+                        issued: (!isNaN(issued.getTime())) ? issued.toISOString() : new Date().toISOString(),
+                        expires: (!isNaN(expires.getTime())) ? expires.toISOString() : ugc.Expires ??  new Date(issued.getTime() + 60 * 60 * 1000).toISOString(),
+                        theme: GetEventTheme(vtec.Event),
+                        ...props,
+                        metadata: {
+                            ms: performance.now() - tick,
+                            source: `events.vtec`,
+                            tracking: GetEventTracking({ Type: `VTEC`, Stanza, Attributes: attributes, Properties: props, VTEC: vtec }),
+                            header: header,
+                            vtec: vtec,
+                            hvtec: hVTEC,
+                            raw: message,
+                            history: [
+                                {
+                                    description: props.description,
+                                    issued: (!isNaN(issued.getTime())) ? issued.toISOString() : new Date().toISOString(),
+                                    status: vtec.Status
+                                }
+                            ]
+                        }
+                    }
+                })
+                SetDebug({ Title: `ParseVTEC`, Message: `${Math.round(performance.now() - tick)}ms` })
+            }
+        }
+    }
+}

package/src/index.ts

@@ -11,62 +11,84 @@
     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
+    Documentation: https://atmosphericx.scriptkitty.cafe/documentation
 
-    Internal Package: @atmosx/event-product-parser
+    Independent Package: @atmosx/event-product-parser
 
 */
 
-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 { Bootstrap } from "@Bootstrap"
+import { GetEventGeometry } from "@Building/GetEventGeometry"
+import { GetCleanedEvent } from "@Building/GetCleanedEvent"
+import { SetSettings } from "@Utilities/SetSettings"
+import { SetEventEmit } from "@Utilities/SetEventEmit"
+import { SetWarning } from "@Utilities/SetWarning"
+import { GenerateAudioMessage } from "@Audio/GenerateAudioMessage"
+import { GenerateGraphic } from "@Image/GenerateGraphic"
+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"
+import { StartService } from "@Core/StartService"
+import { StopService } from "@Core/StopService"
+import { GetVersion } from "@Core/GetVersion"
+
 
 export class Manager { 
-    constructor(settings: TypeSettings) { this.trycatch(); startService(settings) }
+    public constructor(settings: TypeSettings) { 
+        this.ErrorHandler(); StartService(settings) 
+    }
 
-    on(event: string, callback: () => void) {
-        createListener(event, callback)
+    public on(event: string, callback: () => void) {
+        Bootstrap.Listener.on(event, callback)
+        return () => { void Bootstrap.Listener.off(event, callback) };
     }
 
-    trycatch() {
-        process.on('uncaughtException', (err: any) => {
-            const ignored = ['ETIMEDOUT', 'ECONNRESET', 'EHOSTUNREACH', 'ENOTFOUND', 'ECONNREFUSED', 'EPIPE', 'EADDRINUSE', 'EALREADY', 'EACCES', 'EAGAIN', 'EHOSTDOWN', 'STARTTLS_FAILURE'];
-            if (ignored.includes(err?.code)) { 
-                setEventEmit({
-                    event: `onServiceStatus`,
-                    metadata: {
-                        message: `Ignored Critical Error: ${err?.code ?? 'Unknown error code'}. This may indicate a connection issue. Attempting to continue...`,
-                        data: {},
-                        type: `error`,
-                        error: true 
+    private ErrorHandler() {
+        process.on('uncaughtException', (error: any) => {
+            const _IGNORED = [
+                'ETIMEDOUT', 
+                'ECONNRESET', 
+                'EHOSTUNREACH', 
+                'ENOTFOUND', 
+                'ECONNREFUSED', 
+                'EPIPE', 
+                'EADDRINUSE', 
+                'EALREADY', 
+                'EACCES', 
+                'EAGAIN', 
+                'EHOSTDOWN', 
+                'STARTTLS_FAILURE'
+            ];
+            if (_IGNORED.includes(error?.code)) { 
+                SetEventEmit({
+                    Event: `onServiceStatus`,
+                    Metadata: {
+                        Message: `Ignored Critical Error: ${error?.code ?? 'Unknown error code'}. This may indicate a connection issue. Attempting to continue...`,
+                        Data: {},
+                        Type: `error`,
+                        Error: true 
                     }
                 })
-                return; 
             }
-            setWarning({message: `Uncaught Exception: ${err instanceof Error ? err.stack || err.message : String(err)}`})
+            console.log(`Uncaught Exception: ${error instanceof Error ? error.stack ?? error.message : String(error)}`);
+            SetWarning({Message: `Uncaught Exception: ${error instanceof Error ? error.stack ?? error.message : String(error)}`})
         })
     }
 }
 
 export default Manager;
-export type { TypeEvent } from './@types/type.event';
+export type { TypeEvent } from "StaticTypes/Event"
 export { 
-    setSettings, getEventGeometry, 
-    getCleanedEvent, stopService, clearEvents,
-    startService, setNode, getRandomEvent,
-    getEvents, getNodes, setEasTone
+    SetSettings, GetEventGeometry, ManualEvent,
+    GetCleanedEvent, StopService, ClearEvents,
+    StartService, SetNode, GetRandomEvent, GetVersion,
+    GetEvents, GetNodes, GenerateAudioMessage, GenerateGraphic,
+    QueryStanza
 }