@atmosx/event-product-parser 3.0.62 → 3.0.75

package/src/index.ts

@@ -11,64 +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/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';
+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)) { 
+    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: ${err?.code ?? 'Unknown error code'}. This may indicate a connection issue. Attempting to continue...`,
-                        data: {},
-                        type: `error`,
-                        error: true 
+                    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/Event';
+export type { TypeEvent } from "StaticTypes/Event"
 export { 
     SetSettings, GetEventGeometry, ManualEvent,
     GetCleanedEvent, StopService, ClearEvents,
-    StartService, SetNode, GetRandomEvent,
-    GetEvents, GetNodes, GenerateEASMessage, QueryStanza
+    StartService, SetNode, GetRandomEvent, GetVersion,
+    GetEvents, GetNodes, GenerateAudioMessage, GenerateGraphic,
+    QueryStanza
 }
 
 

package/src/{@manager → manager}/MakeEvents.ts

@@ -11,54 +11,57 @@
     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 { TypeEvent } from "../@types/Event";
-import { TypeSettings } from "../@types/Settings";
-import { EnumGlobalFilter } from "../@enums/GlobalFilter";
-import { bootstrap } from "../bootstrap"
-import { SetHash } from "./SetHash";
-import { Tasks } from "./Tasks";
-import { UpdateNode } from "./UpdateNode";
-import { SetEventEmit } from "../@modules/@utilities/SetEventEmit";
-import { SetTimeoutAction } from "../@modules/@utilities/SetTimeoutAction";
+import { TypeEvent } from "StaticTypes/Event"
+import { TypeSettings } from "Types/Settings"
+import { EnumGlobalFilter } from "@Enums/GlobalFilter"
+import { Bootstrap } from "@Bootstrap"
+import { CreateTasks } from "@Tasks/CreateTasks"
+import { SetHash } from "@Manager/SetHash"
+import { UpdateNode } from "@Manager/UpdateNode"
+import { SetEventEmit } from "@Utilities/SetEventEmit"
+import { SetTimeoutAction } from "@Utilities/SetTimeoutAction"
+import { GetStringText } from "@Utilities/GetStringText"
 
 export const MakeEvents = async (events: TypeEvent[]): Promise<void> => {
-    let tasked = [];
-    const settings = bootstrap.settings as TypeSettings;
+    let tasked = [] as TypeEvent[];
+    const settings = Bootstrap.Settings as TypeSettings;
     if (events.length === 0) return
-    for (const event of events) {
-        const features = bootstrap.cache.events.features;
+    await Promise.all(events.map(async event => {
+        const features = Bootstrap.Cache.Events.features;
         const getHash = event.properties.metadata.hash;
         const getTracking = event.properties.metadata.tracking;
-        const isEntry = bootstrap.cache.hashes?.find(hash => hash.tracking === getTracking)
-        const isHashed = isEntry?.hashes?.includes(getHash) ?? false;
+        const isEntry = Bootstrap.Cache.Hashes?.find(hash => hash.Tracking === getTracking)
+        const isHashed = isEntry?.Hashes?.includes(getHash) ?? false;
         const isNodeFiltering = settings.GlobalSettings.EventFiltering.NodeLocationFiltering
+        const getNodes = Bootstrap.Cache.Nodes.features;
         const getFeature = features.find(feature => feature.properties.metadata.tracking === getTracking);    
-    
+
         if (isHashed || event.properties.status_metadata.is_expired) return
-        SetHash(event, isEntry)
-        
-        if (isNodeFiltering) {
-            await UpdateNode(event);
+        SetHash({ Event: event, Entry: isEntry })
+        await UpdateNode(event);
+        if (isNodeFiltering && getNodes.length > 0) {
             if (!event.properties.metadata.filtered_proximity && !EnumGlobalFilter.includes(event.properties.event.toLowerCase())) { 
                 return
             }
         }
         
-        const isRatelimited = SetTimeoutAction({ identifier: getTracking, interval: 1, max: 1, addTime: true })
-        if (!isRatelimited.limited) {
+        const isRatelimited = SetTimeoutAction({ Identifier: getTracking, Interval: 1, Max: 1, AddTime: true })
+        const isLocal = event.properties.metadata.filtered_proximity ? `[LOCAL] ` : ``;
+        if (!isRatelimited.Limited) {
             SetEventEmit({
-                event: `onEventStatus`,
-                metadata: {
-                    type: getFeature ? `Updated` : `New`,
-                    event: event
+                Event: `onEventStatus`,
+                Metadata: {
+                    Type: getFeature ? `Updated` : `New`,
+                    Event: event
                 },
-                message: `[${getFeature ? 'Updated' : 'New'}] ${event.properties.event} (${event.properties.status}) (${event.properties.metadata.tracking})`
+                Tree: Bootstrap.Settings.EnhancedEventJournaling ? GetStringText(event).split('\n').filter(line => line.trim() !== '') : [],
+                Message: `${isLocal}[${getFeature ? 'Updated' : 'New'}] ${event.properties.event} (${event.properties.status}) (${event.properties.metadata.tracking})`
             })
         }
 
@@ -67,18 +70,10 @@ export const MakeEvents = async (events: TypeEvent[]): Promise<void> => {
                 if (getFeature) { 
                     const getIndex = features.indexOf(getFeature);
                     const cHistory = getFeature?.properties?.metadata?.history ?? [];
-                    const cLocations = getFeature?.properties?.locations?.split(";").map((l: string) => l.trim()) ?? [];
-                    const cUgc = getFeature?.properties?.geocode?.ugc ?? [];
-        
                     const iHistory = event.properties?.metadata?.history ?? [];
-                    const iLocations = event.properties?.locations?.split(";").map((l: string) => l.trim()) ?? [];
-                    const iUgc = event.properties?.geocode?.ugc ?? [];
-        
                     const mHistory = [...cHistory, ...iHistory].filter((v, i, a) => a.indexOf(v) === i).filter((v, i, a) => a.findIndex(h => h.description === v.description && h.issued === v.issued) === i);
-                    const mLocations = [...cLocations, ...iLocations].filter((v, i, a) => a.indexOf(v) === i).join('; ');
-                    const mUgc = [...cUgc, ...iUgc].filter((v, i, a) => a.indexOf(v) === i);
         
-                    bootstrap.cache.events.features[getIndex] = {
+                    Bootstrap.Cache.Events.features[getIndex] = {
                         ...event,
                         properties: {
                             ...event.properties,
@@ -86,21 +81,17 @@ export const MakeEvents = async (events: TypeEvent[]): Promise<void> => {
                                 ...event?.properties?.metadata,
                                 history: mHistory
                             },
-                            locations: mLocations,
-                            geocode: {
-                                ...event?.properties?.geocode,  
-                                ugc: mUgc
-                            },
                         }
                     };
-                    tasked.push(bootstrap.cache.events.features[getIndex])
+
+                    tasked.push(Bootstrap.Cache.Events.features[getIndex])
                 } else { 
                     features.push(event);
                     tasked.push(event)
                 }
             }
         }
-    }
-    await Tasks(tasked)
-    SetEventEmit({ event: `onEventCache`, metadata: bootstrap.cache.events, limited: true })
+    }))
+    SetEventEmit({ Event: `onEventCache`, Metadata: Bootstrap.Cache.Events, Limited: true })
+    return await CreateTasks(tasked)
 }

package/src/manager/RemoveEvent.ts

@@ -0,0 +1,74 @@
+/*
+              _                             _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ 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 { TypeEvent } from "StaticTypes/Event"
+import { EnumStrings } from "@Enums/Strings"
+import { Bootstrap } from "@Bootstrap"
+import { SetEventEmit } from "@Utilities/SetEventEmit"
+import { SetTimeoutAction } from "@Utilities/SetTimeoutAction"
+import { CreateTasks } from "@Tasks/CreateTasks"
+
+interface RemoveEventOptions {
+    Event: TypeEvent
+    IsTimeBasedExpiration: boolean
+}
+
+export const RemoveEvent = async ({ Event, IsTimeBasedExpiration }: RemoveEventOptions):Promise<void> => {
+    const gTracking = Event.properties.metadata.tracking;
+    const isTrackingEventLogged = Bootstrap.Cache.Events.features
+        .find(f => f?.properties?.metadata?.tracking === gTracking);
+    const isStatement = Event.properties.status_metadata.is_statement;
+
+    if (isTrackingEventLogged) { 
+        Event.properties.expires = new Date().toISOString();
+        Event.properties.status = `Expired`;
+        Event.properties.status_metadata.is_expired = true;
+
+        const description = IsTimeBasedExpiration ? EnumStrings.cancellation
+            .replace(`{SENDER}`, Event.properties.geocode.office.name)
+            .replace(`{EVENT}`, Event.properties.event) : Event.properties.description
+        Event.properties.description = description; 
+        Event.properties.metadata.raw = IsTimeBasedExpiration ? description : Event.properties.metadata.raw;
+        Event.properties.metadata.history.push({
+            description: IsTimeBasedExpiration ? description : Event.properties.description,
+            issued: Event.properties.expires,
+            status: Event.properties.status
+        })
+        
+        Bootstrap.Cache.Events.features
+            .splice(Bootstrap.Cache.Events.features.indexOf(isTrackingEventLogged), 1);
+        Bootstrap.Cache.Hashes = Bootstrap.Cache.Hashes
+            .filter(hash => hash.Tracking !== gTracking);
+
+        if (!isStatement) { 
+            SetEventEmit({
+                Event: `onEventStatus`,
+                Metadata: { type: `Removed`, event: Event },
+                Message: `[Removed] ${Event.properties.event} (${Event.properties.status}) (${gTracking})`
+            })
+            CreateTasks([Event])
+        }
+        SetTimeoutAction({ Identifier: gTracking, Expire: true })
+    }
+    SetEventEmit({
+        Event: `onEventCache`,
+        Metadata: Bootstrap.Cache.Events,
+        Limited: true
+    })
+}

package/src/{@manager → manager}/SetHash.ts

@@ -11,26 +11,31 @@
     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 { TypeEvent } from "../@types/Event";
-import { TypeHash } from "../@types/Hash"
-import { bootstrap } from "../bootstrap"
+import { TypeEvent } from "StaticTypes/Event"
+import { TypeHash } from "Types/Hash"
+import { Bootstrap } from "@Bootstrap"
 
-export const SetHash = (event: TypeEvent, entry: TypeHash): void => {
-    if (!entry) {
-        bootstrap.cache.hashes.push({
-            tracking: event.properties.metadata.tracking,
-            hashes: [event.properties.metadata.hash],
-            expires: event.properties.expires
+interface SetHashOptions {
+    Event: TypeEvent
+    Entry: TypeHash
+}
+
+export const SetHash = ({ Event, Entry }: SetHashOptions): void => {
+    if (!Entry) {
+        Bootstrap.Cache.Hashes.push({
+            Tracking: Event.properties.metadata.tracking,
+            Hashes: [Event.properties.metadata.hash],
+            Expires: Event.properties.expires
         });
         return;
     }
 
-    entry.hashes.push(event.properties.metadata.hash);
-    entry.expires = event.properties.expires;
+    Entry.Hashes.push(Event.properties.metadata.hash);
+    Entry.Expires = Event.properties.expires;
 }

package/src/{@manager → manager}/UpdateEvents.ts

@@ -11,25 +11,25 @@
     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 { TypeEvent } from "../@types/Event";
-import { bootstrap } from "../bootstrap"
-import { SetEventEmit } from "../@modules/@utilities/SetEventEmit";
-import { RemoveEvent } from "./RemoveEvent";
+import { TypeEvent } from "StaticTypes/Event"
+import { Bootstrap } from "@Bootstrap"
+import { SetEventEmit } from "@Utilities/SetEventEmit"
+import { RemoveEvent } from "@Manager/RemoveEvent"
 
-export const UpdateEvents = async (selectedEvent?: TypeEvent): Promise<void> => {
-    const events = bootstrap.cache.events.features;
+export const UpdateEvents = async (selected?: TypeEvent): Promise<void> => {
+    const events = Bootstrap.Cache.Events.features;
     async function update(event: TypeEvent) {
         if (new Date(event.properties.expires) < new Date()) {
-            SetEventEmit({ event: `onExpiredProduct`, metadata: event })
-            await RemoveEvent(event, true)
+            SetEventEmit({ Event: `onExpiredProduct`, Metadata: event })
+            await RemoveEvent({ Event: event, IsTimeBasedExpiration: true })
         }
     }
-    if (!selectedEvent) { await Promise.all(events.map(async (event) => { await update(event) })) } 
-    if (selectedEvent) { await update(selectedEvent) }
+    if (!selected) { await Promise.all(events.map(async (event) => { await update(event) })) } 
+    if (selected) { await update(selected) }
 }

package/src/{@manager → manager}/UpdateNode.ts

@@ -11,23 +11,23 @@
     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 { TypeEvent } from "../@types/Event";
-import { bootstrap } from "../bootstrap"
-import { GetEventNodes } from "../@building/GetEventNodes";
-import { SetEventEmit } from "../@modules/@utilities/SetEventEmit";
+import { TypeEvent } from "StaticTypes/Event"
+import { Bootstrap } from "@Bootstrap"
+import { GetEventNodes } from "@Building/GetEventNodes"
+import { SetEventEmit } from "@Utilities/SetEventEmit"
 
-export const UpdateNode = async (selectedEvent?: TypeEvent): Promise<void> => {
-    const events = bootstrap.cache.events.features;
-    const ttl = bootstrap.settings.GlobalSettings.NodeTTL * 1e3;
+export const UpdateNode = async (selected?: TypeEvent): Promise<void> => {
+    const events = Bootstrap.Cache.Events.features;
+    const ttl = Bootstrap.Settings.GlobalSettings.NodeTTL * 1e3;
     let total = 0;
 
-    const TTLEvents = selectedEvent ? [selectedEvent] : events.filter((evt) => {
+    const TTLEvents = selected ? [selected] : events.filter((evt) => {
         const lastUpdate = evt?.properties?.metadata?.updated ?? null;
         return lastUpdate == null || (Date.now() - lastUpdate) >= ttl;
     });
@@ -52,10 +52,10 @@ export const UpdateNode = async (selectedEvent?: TypeEvent): Promise<void> => {
 
     if (total > 0) {
         SetEventEmit({
-            event: `onNodeUpdate`,
-            metadata: {
-                type: `global-update`,
-                updated: total
+            Event: `onNodeUpdate`,
+            Metadata: {
+                Type: `global-update`,
+                Updated: total
             },
         })
     }