@atmosx/event-product-parser 3.0.621 → 3.1.0

package/src/{@modules/@database/ImportShapefiles.ts → components/database/imports/Shapefiles.ts}

@@ -11,35 +11,32 @@
     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 { EnumShapefiles } from '../../@enums/Shapefiles'
-import { bootstrap } from "../../bootstrap"
-import { SetSleep } from '../@utilities/SetSleep'
-import { SetWarning } from '../@utilities/SetWarning'
+import { EnumShapefiles } from "@Enums/Shapefiles"
+import { Bootstrap } from "@Bootstrap"
+import { SetSleep } from "@Utilities/SetSleep"
+import { SetWarning } from "@Utilities/SetWarning"
+import { CreateQuery } from "@Database/CreateQuery"
 import { existsSync, mkdirSync, writeFileSync, unlinkSync, rm } from "fs"
-import { resolve, extname} from 'path'
-import { loadAsync } from 'jszip'
-import { read } from 'shapefile'
+import { resolve, extname} from "path"
+import { loadAsync } from "jszip"
+import { read } from "shapefile"
 
-export const ImportShapefiles = async (): Promise<void> => {
-    const settings = bootstrap.settings as TypeSettings;
+export const Shapefiles = async (): Promise<void> => {
     try { 
-        const tShapefiles = bootstrap.database
-            .prepare(`SELECT COUNT(*) AS count FROM shapefiles`)
-            .get().count;
-        if (tShapefiles === 0) {
-            await SetSleep({timeout: 1e3});
+        const tShapefiles = CreateQuery({ Query: `SELECT COUNT(*) AS count FROM shapefiles` })[0] as { count: number };
+        if (tShapefiles.count === 0) {
+            await SetSleep({Timeout: 1e3});
             for (const shapefile of EnumShapefiles) {
                 const response = await fetch(shapefile.link);
                 const arrayBuff = await response.arrayBuffer();
                 const content = await loadAsync(arrayBuff);
-                const directory = resolve(__dirname, `../../shapefiles`);
+                const directory = resolve(__dirname, `shapefiles`);
                 if (!existsSync(directory)) {
                     mkdirSync(directory, { recursive: true });
                 }
@@ -50,15 +47,14 @@ export const ImportShapefiles = async (): Promise<void> => {
                         writeFileSync(output, data)
                     }
                 }
-                const filepath = resolve(__dirname, '../../shapefiles', shapefile.name + '_' + shapefile.id)
+                const filepath = resolve(__dirname, 'shapefiles', shapefile.name + '_' + shapefile.id)
                 const { features } = await read(
                     filepath,
                     filepath,
                 );
-                SetWarning({ message: `Importing ${features.length} features from ${shapefile.name}_${shapefile.id} for Shapefiles` })
-                const insert = bootstrap.database
-                    .prepare(`INSERT OR REPLACE INTO shapefiles (id, location, geometry) VALUES (?, ?, ?)`)
-                const transaction = bootstrap.database.transaction((entries: any[]) => {
+                SetWarning({ Message: `Importing ${features.length} features from ${shapefile.name}_${shapefile.id} for Shapefiles` })
+                const insert = `INSERT INTO shapefiles (id, location, source, geometry) VALUES (?, ?, ?, ?)`;
+                const transaction = Bootstrap.Database.transaction((entries: any[]) => {
                     for (const entry of entries) {
                         const { properties, geometry } = entry;
                         let final: string, location: string;
@@ -78,16 +74,17 @@ export const ImportShapefiles = async (): Promise<void> => {
                             final = properties.ID ?? properties.WFO
                             location = properties.NAME;
                         }
-                        insert.run(final, location, JSON.stringify(geometry));
+                        CreateQuery({ Query: insert, Parameters: [final, location, `${shapefile.name}_${shapefile.id}`, JSON.stringify(geometry)] })
                     }
                 })
                 unlinkSync(`${filepath}.shp`)
                 unlinkSync(`${filepath}.dbf`)
                 transaction(features)
             }
-            rm(resolve(__dirname, '../../shapefiles'), { recursive: true, force: true }, () => {});
+            rm(resolve(__dirname, 'shapefiles'), { recursive: true, force: true }, () => {});
         }
-    } catch (error) {
-        SetWarning( {message: `An error occurred while compiling shapefiles: ${error.message}` }) 
+    } catch (error: unknown) {
+        const message = error instanceof Error ? error.message : String(error);
+        SetWarning( {Message: `An error occurred while compiling shapefiles: ${message}` }) 
     }
 }

package/src/{@modules/@database/ImportStanza.ts → components/database/imports/Stanza.ts}

@@ -11,37 +11,33 @@
     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 { TypeStanzaCompiled } from '../../@types/StanzaCompiled';
-import { bootstrap } from '../../bootstrap'
-import { SetWarning } from '../@utilities/SetWarning';
+import { TypeSettings } from "TypesStandard/Settings"
+import { TypeStanzaCompiled } from "TypesStandard/StanzaCompiled"
+import { Bootstrap } from "@Bootstrap"
+import { SetWarning } from "@Utilities/SetWarning"
+import { CreateQuery } from "@Database/CreateQuery"
 
-export const ImportStanza = async (stanza: TypeStanzaCompiled): Promise<void> => {
-    const settings = bootstrap.settings as TypeSettings;
+export const ImportStanza = async (Stanza: TypeStanzaCompiled): Promise<void> => {
+    const settings = Bootstrap.Settings as TypeSettings;
     try { 
         if (!settings.NOAAWeatherWireServiceSettings.CacheSettings.Enabled) { return }
-        bootstrap.database
-            .prepare(`INSERT OR IGNORE INTO stanzas (type, stanza, issued) VALUES (?, ?, ?)`)
-            .run(stanza.getType.type, JSON.stringify(stanza), stanza.attributes.issue)
-        const count = bootstrap.database
-            .prepare(`SELECT COUNT(*) as total FROM stanzas`)
-            .get() as { total: number }
+        CreateQuery({ Query: `INSERT OR IGNORE INTO stanzas (type, stanza, issued) VALUES (?, ?, ?)`, Parameters: [Stanza.Type.Type, JSON.stringify(Stanza), Stanza.Attributes.issue] })
+        const count = CreateQuery({ Query: `SELECT COUNT(*) as total FROM stanzas` }) as { total: number };
         const max = settings.NOAAWeatherWireServiceSettings.CacheSettings.MaxDatabaseHistory;
         if (count.total > max) { 
             const toDelete = count.total - max;
             if (toDelete > 0) {
-                bootstrap.database
-                    .prepare(`DELETE FROM stanzas WHERE id IN (SELECT id FROM stanzas ORDER BY issued ASC LIMIT ?)`)
-                    .run(toDelete);
+                CreateQuery({ Query: `DELETE FROM stanzas WHERE id IN (SELECT id FROM stanzas ORDER BY issued ASC LIMIT ?)`, Parameters: [toDelete] })
             }
         }
-    } catch (error) {
-        SetWarning({ message: `An error occurred while importing stanza: ${error.message}` })
+    } catch (error: unknown) {
+        const message = error instanceof Error ? error.message : String(error);
+        SetWarning({ Message: `An error occurred while importing stanza: ${message}` })
     }
 }

package/src/components/events/CreateEvents.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 { TypeEvent } from "TypesEvent/Event"
+import { TypeSettings } from "TypesStandard/Settings"
+import { EnumGlobalFilter } from "@Enums/GlobalFilter"
+import { Bootstrap } from "@Bootstrap"
+import { CreateTasks } from "@Tasks/CreateTasks"
+import { SetHash } from "@BuilderUtilities/SetHash"
+import { UpdateNode } from "@BuilderUtilities/UpdateNode"
+import { SetEventEmit } from "@Utilities/SetEventEmit"
+import { SetTimeoutAction } from "@Utilities/SetTimeoutAction"
+import { GetStringText } from "@Formatting/GetStringText"
+import { GetEventMerged } from "@BuilderComponents/GetEventMerged"
+
+export const CreateEvents = async (events: TypeEvent[]): Promise<void> => {
+    let tasked = [] as TypeEvent[];
+    const settings = Bootstrap.Settings as TypeSettings;
+    if (events.length === 0) return
+    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 isNodeFiltering = settings.GlobalSettings.EventFiltering.NodeLocationFiltering
+        const getNodes = Bootstrap.Cache.Nodes.features;
+        
+
+        if (isHashed || event.properties.status_metadata.is_expired) return
+        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 })
+        const isLocal = event?.properties?.metadata?.filtered_proximity ? `[LOCAL] ` : ``;
+        const getFeature = features.find(feature => feature.properties.metadata.tracking === getTracking);    
+        const isWatch = event?.properties?.metadata?.vtec?.watch
+        const isWOU = event?.properties?.metadata?.vtec?.wou
+
+        if (!isRatelimited.Limited) {
+            SetEventEmit({
+                Event: `onEventStatus`,
+                Metadata: {
+                    Type: getFeature ? `Updated` : `New`,
+                    Event: event
+                },
+                Tree: Bootstrap.Settings.DeveloperEventLogging ? GetStringText(event).split('\n').filter(line => line.trim() !== '') : [],
+                Message: `${isLocal}[${getFeature ? 'Updated' : 'New'}] ${event.properties.event} (${event.properties.status}) (${event.properties.metadata.tracking})`
+            })
+        }
+        if (event.properties.status_metadata.is_issued || event.properties.status_metadata.is_updated) {
+            if (getFeature) {
+                const getIndex = features.indexOf(getFeature);
+                if (isWatch && isWOU) { return }
+                Bootstrap.Cache.Events.features[getIndex] = GetEventMerged({ Event1: getFeature, Event2: event })
+                tasked.push(Bootstrap.Cache.Events.features[getIndex])
+            } else { 
+                features.push(event);
+                tasked.push(event)
+            }
+        }
+    }))
+
+    tasked = tasked.filter((v, i, a) => a.reduce((last, t, index) => t.properties.metadata.tracking === v.properties.metadata.tracking ? index : last, -1) === i)
+    SetEventEmit({ Event: `onEventCache`, Metadata: Bootstrap.Cache.Events, Limited: true })
+    return await CreateTasks(tasked)
+}

package/src/components/events/FilterEvents.ts

@@ -0,0 +1,149 @@
+/*
+              _                             _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ 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 "TypesEvent/Event"
+import { TypeSettings } from "TypesStandard/Settings"
+import { Bootstrap } from "@Bootstrap"
+import { GetEventEnhancedName } from "@BuilderComponents/GetEventEnhancedName"
+import { GetEventSignature } from "@BuilderComponents/GetEventSignature"
+import { CreateEvents } from "@Builder/CreateEvents"
+import { RemoveEvents } from "@Builder/RemoveEvents"
+import { GetEventAttachments } from "@BuilderComponents/GetEventAttachments"
+import { SetEventEmit } from "@Utilities/SetEventEmit"
+import { SetDebug } from "@Utilities/SetDebug"
+import { GetMatched } from "@Utilities/GetMatched"
+import { GetEventPopulation } from "@BuilderComponents/GetEventPopulation"
+import { GetEventGeometry } from "@BuilderComponents/GetEventGeometry"
+import { createHash } from "crypto"
+
+export const FilterEvents = async (events: TypeEvent[]): Promise<void> => {
+    const tick = performance.now();
+    if (events.length === 0) return
+    const configurations = Bootstrap.Settings as TypeSettings
+    const sets = {} as Record<string, Set<string>>;
+    const bools = {} as Record<string, boolean>;
+    const megered = {...configurations.GlobalSettings, ...configurations.GlobalSettings.EventFiltering}
+    for (const key in megered) {
+        const setting = megered[key as keyof typeof megered]
+        if (Array.isArray(setting)) { 
+            (sets as Record<string, any>)[key] = new Set(setting.map(item => String(item).toLowerCase())); 
+        }
+        if (typeof setting === 'boolean') { 
+            (bools as Record<string, any>)[key] = setting; 
+        }
+    }
+    const isFiltered = (define: TypeEvent): boolean => {
+        const properties = define.properties;
+        const zones = properties.geocode.ugc;
+        const icao = properties.geocode.office.office
+
+        if (properties.status_metadata.is_test) { 
+            SetEventEmit({ Event: `onTestProduct`, Metadata: define })
+            if (bools?.IgnoreTestProducts) return true; 
+        }
+        
+        if (properties.status_metadata.is_expired) { 
+            SetEventEmit({ Event: `onExpiredProduct`, Metadata: define })
+            RemoveEvents({ Event: define, IsTimeBasedExpiration: false })
+            return true; 
+        }
+        
+        if (properties.metadata?.vtec?.watch && properties.metadata.source != `events.api`) {
+            const isWOU = properties.metadata?.vtec?.wou;
+            if (!isWOU) { 
+                properties.metadata.tracking = properties.metadata.tracking.replace(properties.metadata.tracking.split(`.`)[0], `KWNS`)
+            }
+            SetEventEmit({ Event: isWOU ? `onWatchOutlineUpdate` : `onWatchCountyNotification`, Metadata: define })
+        }
+
+        for (const key in sets) {
+            const setting = sets[key]
+            const values = [...setting];
+            if (key === 'ListeningEvents' && setting.size > 0 && !GetMatched({ Strings: values, String: define.properties.event })) {
+                SetEventEmit({
+                    Event: `onFilteredEvent`,
+                    Metadata: define
+                }); 
+                return true 
+            } 
+            if (key === 'IgnoredEvents' && setting.size > 0 && GetMatched({ Strings: values, String: define.properties.event })) {
+                SetEventEmit({
+                    Event: `onIgnoredEvent`,
+                    Metadata: define
+                }); 
+                return true 
+            } 
+            if (key === 'ListeningICAO' && setting.size > 0 && icao != null && !setting.has(icao.toLowerCase())) { 
+                SetEventEmit({
+                    Event: `onFilteredICAO`,
+                    Metadata: define
+                }); 
+                return true 
+            }
+            if (key === 'IgnoredICAO' && setting.size > 0 && icao != null && setting.has(icao.toLowerCase())) { 
+                SetEventEmit({
+                    Event: `onIgnoredICAO`,
+                    Metadata: define
+                }); 
+                return true 
+            }
+            if (key === 'ListeningUGC' && setting.size > 0 && zones.length > 0 && !zones.some((ugc: string) => setting.has(ugc.toLowerCase()))) { 
+                SetEventEmit({
+                    Event: `onFilteredUGC`,
+                    Metadata: define
+                }); 
+                return true 
+            }
+            if (key === 'ListeningStates' && setting.size > 0 && zones.length > 0 && !zones.some((ugc: string) => setting.has(ugc.substring(0, 2).toLowerCase()))) { 
+                SetEventEmit({
+                    Event: `onFilteredState`,
+                    Metadata: define
+                }); 
+                return true 
+            }
+        }
+        return false
+    }
+
+    const filtering = events.filter((event: TypeEvent) => {
+        Bootstrap.Cache.Parsed = Bootstrap.Cache.Parsed.filter((e) => e !== event);
+        const define = GetEventSignature(event) as TypeEvent;
+        const pre = {...define,properties: {...define.properties,  metadata: {...define.properties.metadata }}};
+        const properties = define.properties; delete pre.properties.metadata.ms; delete pre.properties.metadata.header;
+        const enhanced = properties.event = GetEventEnhancedName(event)
+        const filtered = isFiltered(define)
+        if (!filtered) {
+            const tick2 = performance.now();
+            const geometry = !bools?.DisableGeometryParsing ? GetEventGeometry({ Event: event }) : null;
+            const population = GetEventPopulation(geometry)
+            const attachments = GetEventAttachments(event)
+            event.geometry = geometry;
+            event.properties.geocode.census.population = population.population;
+            event.properties.geocode.census.cities = population.cities;
+            properties.metadata.attachments = attachments;
+            SetDebug({ Title: `Filtered`, Message: `${Math.round(performance.now() - tick2)}ms` })
+        }
+        properties.metadata.hash = createHash("sha256").update(JSON.stringify(pre)).digest("hex")  
+        SetEventEmit({ Event: `onProductType${enhanced.replace(/\s+/g, '')}`, Metadata: define });
+        return !filtered
+    })
+    
+    SetDebug({ Title: `FilterEvents (${filtering.length}/${events.length})`, Message: `${Math.round(performance.now() - tick)}ms` })
+    await CreateEvents(filtering)
+}

package/src/{@building/CreateEvent.ts → components/events/ProcessStanza.ts}

@@ -11,46 +11,44 @@
     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 { TypeStanzaCompiled } from "../@types/StanzaCompiled"
-import { TypeSettings } from "../@types/Settings"
-import { bootstrap } from "../bootstrap"
-import { ParseText } from "../@events/ParseText"
-import { ParseUGC } from "../@events/ParseUGC"
-import { ParseVTEC } from "../@events/ParseVTEC"
-import { ParseAPI } from "../@events/ParseAPI"
-import { ValidateEvents } from "../@manager/ValidateEvents"
+import { TypeStanzaCompiled } from "TypesStandard/StanzaCompiled"
+import { TypeSettings } from "TypesStandard/Settings"
+import { Bootstrap } from "@Bootstrap"
+import { ParseText } from "@Events/ParseText"
+import { ParseUGC } from "@Events/ParseUGC"
+import { ParseVTEC } from "@Events/ParseVTEC"
+import { ParseAPI } from "@Events/ParseAPI"
+import { FilterEvents } from "@Builder/FilterEvents"
 
-export const CreateEvent = async (stanza: TypeStanzaCompiled, ignorePushing?: boolean): Promise<void | string> => {
-    const settings = bootstrap.settings as TypeSettings
+export const ProcessStanza = 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)
-
+    const isVtecEvent = (Stanza.VTEC && Stanza.UGC)
+    const isUgcEvent = (!Stanza.VTEC && Stanza.UGC)
+    const isTextEvent = (!Stanza.VTEC && !Stanza.UGC)
+    
+    const isNWWS = (Stanza.NWWS)
     switch (true) {
         case (!isNWWS):
-            await ParseAPI(stanza)
+            await ParseAPI(Stanza)
             break;
         case (isNWWS && !StanzaSettings.DisableVTEC && isVtecEvent):
-            await ParseVTEC(stanza)
+            await ParseVTEC(Stanza)
             break;
         case (isNWWS && !StanzaSettings.DisableUGC && isUgcEvent):
-            await ParseUGC(stanza)
+            await ParseUGC(Stanza)
             break;
         case (isNWWS && !StanzaSettings.DisableText && isTextEvent):
-            await ParseText(stanza)
+            await ParseText(Stanza)
             break;
     }
-    if (!ignorePushing) {
-        await ValidateEvents(bootstrap.cache.processed)
-    }
+    await FilterEvents(Bootstrap.Cache.Parsed)
     return 'nothing picked';
 }

package/src/components/events/RemoveEvents.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 "TypesEvent/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 RemoveEvents = 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/{@building → components/events/components}/GetCleanedEvent.ts

@@ -11,9 +11,9 @@
     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
 
 */
 

package/src/{@building → components/events/components}/GetEventAttachments.ts

@@ -11,17 +11,18 @@
     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 { EnumStates } from "../@enums/States"
-import { EnumExpressions } from "../@enums/Expressions"
-import { GetLatestIssuance } from "../@modules/@utilities/GetLatestIssuance";
+import { TypeEvent } from "TypesEvent/Event"
+import { EnumStates } from "@Enums/States"
+import { Bootstrap } from "@Bootstrap"
+import { EnumExpressions } from "@Enums/Expressions"
+import { GetLatestIssuance } from "@Utilities/GetLatestIssuance"
+import { CreateQuery } from "@Database/CreateQuery"
 
 interface GetEventAttachmentsResponse { 
     name: string
@@ -38,7 +39,7 @@ type BroadcastifyResponse = {
 
 export const GetEventAttachments = (event: TypeEvent): GetEventAttachmentsResponse[] | null => {
     let attachments = [];
-    const settings = bootstrap.settings;
+    const settings = Bootstrap.Settings;
     const issuanceTime = GetLatestIssuance();
     const spcNumber = event?.properties?.discussion_parameters?.discussion_number;
     const watchNumber = event?.properties?.watch_parameters?.watch_number;
@@ -64,14 +65,15 @@ export const GetEventAttachments = (event: TypeEvent): GetEventAttachmentsRespon
                 const lines = [`Northern`, `Southern`, `Eastern`, `Western`, `Inland`, `Costal`, `County`]
                 const county = location?.split(',')[0]?.trim().replace(new RegExp(`^(${lines.join('|')}) `), '')
                 const state = EnumStates[location?.split(',')[1]?.trim()]
-                const feeds = bootstrap.database.prepare(`SELECT * FROM broadcastify WHERE state = ? AND county = ?`).all(state, county).sort((a, b) => {
+                const feeds = CreateQuery({ Query: `SELECT * FROM broadcastify WHERE state = ? AND county = ?`, Parameters: [state, county] }) as BroadcastifyResponse[];
+                const so = feeds.sort((a: BroadcastifyResponse, b: BroadcastifyResponse) => {
                     const typeOrder = ['Other', 'Public Safety'];
                     const indexA = typeOrder.indexOf(a.type);
                     const indexB = typeOrder.indexOf(b.type);
                     return indexA - indexB;
-                })
-                const tags = bootstrap.settings.BroadcastifySettings.BroadcastifyTags;
-                const filtered = feeds.filter((feed: BroadcastifyResponse) => tags.includes(feed.type));
+                });
+                const tags = Bootstrap.Settings.BroadcastifySettings.BroadcastifyTags;
+                const filtered = so.filter((feed: BroadcastifyResponse) => tags.includes(feed.type));
                 if (filtered.length > 0) {
                     filtered.map((filtered: BroadcastifyResponse) => {
                         if (!attachments.some((a) => a.link === filtered.link)) {

package/src/components/events/components/GetEventDirection.ts

@@ -0,0 +1,28 @@
+/*
+              _                             _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ 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
+    
+*/
+
+export const GetEventDirection = (message: string): string | null => {
+    const direction = message
+        .replace(/\s+/g, ' ')
+        .match(/moving\s+(north|south|east|west|northeast|northwest|southeast|southwest)\s+at\s+(\d+)\s+mph/i);
+    if (direction) {
+        return direction[1].charAt(0).toUpperCase() + direction[1].slice(1).toLowerCase() + ` @ ${direction[2]} MPH`;   
+    }
+    return null;
+};