@atmosx/event-product-parser 3.0.4 → 3.0.7

package/src/manager/MakeEvents.ts

@@ -0,0 +1,110 @@
+/*
+              _                             _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ 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 { 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 "@ParsingText/GetStringText"
+
+export const MakeEvents = 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;
+        const getFeature = features.find(feature => feature.properties.metadata.tracking === getTracking);    
+
+        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] ` : ``;
+        if (!isRatelimited.Limited) {
+            SetEventEmit({
+                Event: `onEventStatus`,
+                Metadata: {
+                    Type: getFeature ? `Updated` : `New`,
+                    Event: event
+                },
+                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})`
+            })
+        }
+
+        if (settings.GlobalSettings.EventManagement) {
+            if (event.properties.status_metadata.is_issued || event.properties.status_metadata.is_updated) {
+                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] = {
+                        ...event,
+                        properties: {
+                            ...event.properties,
+                            metadata: {
+                                ...event?.properties?.metadata,
+                                history: mHistory
+                            },
+                            locations: mLocations,
+                            geocode: {
+                                ...event?.properties?.geocode,  
+                                ugc: mUgc
+                            },
+                        }
+                    };
+
+                    tasked.push(Bootstrap.Cache.Events.features[getIndex])
+                } else { 
+                    features.push(event);
+                    tasked.push(event)
+                }
+            }
+        }
+    }))
+    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 → manager/SetHash.ts}

@@ -11,27 +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/type.event";
-import { TypeHash } from "../@types/types.hash"
-import { bootstrap } from "../bootstrap"
+import { TypeEvent } from "StaticTypes/Event"
+import { TypeHash } from "Types/Hash"
+import { Bootstrap } from "@Bootstrap"
 
+interface SetHashOptions {
+    Event: TypeEvent
+    Entry: TypeHash
+}
 
-export const setHash = async (event: TypeEvent, entry: TypeHash): Promise<void> => {
-    if (entry) {
-        entry.hashes.push(event.properties.metadata.hash);
-        entry.expires = event.properties.expires;
-    } else { 
-        bootstrap.cache.hashes.push({
-            tracking: event.properties.metadata.tracking,
-            hashes: [event.properties.metadata.hash],
-            expires: event.properties.expires
+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;
 }

package/src/manager/UpdateEvents.ts

@@ -0,0 +1,35 @@
+/*
+              _                             _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ 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 { Bootstrap } from "@Bootstrap"
+import { SetEventEmit } from "@Utilities/SetEventEmit"
+import { RemoveEvent } from "@Manager/RemoveEvent"
+
+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: event, IsTimeBasedExpiration: true })
+        }
+    }
+    if (!selected) { await Promise.all(events.map(async (event) => { await update(event) })) } 
+    if (selected) { await update(selected) }
+}

package/src/manager/UpdateNode.ts

@@ -0,0 +1,62 @@
+/*
+              _                             _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ 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 { Bootstrap } from "@Bootstrap"
+import { GetEventNodes } from "@Building/GetEventNodes"
+import { SetEventEmit } from "@Utilities/SetEventEmit"
+
+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 = selected ? [selected] : events.filter((evt) => {
+        const lastUpdate = evt?.properties?.metadata?.updated ?? null;
+        return lastUpdate == null || (Date.now() - lastUpdate) >= ttl;
+    });
+
+    if (TTLEvents.length === 0) return;
+
+    async function update(evt: TypeEvent) {
+        const node = await GetEventNodes(evt);
+        if (node.nodes.length > 0) {
+            total++;
+        }
+        evt.properties.metadata.nodes = node.nodes;
+        evt.properties.metadata.filtered_proximity = node.filtered;
+        evt.properties.metadata.updated = node.updated;
+    }
+
+    const concurrency = 4;
+    for (let index = 0; index < TTLEvents.length; index += concurrency) {
+        const batch = TTLEvents.slice(index, index + concurrency);
+        await Promise.all(batch.map((evt) => update(evt)));
+    }
+
+    if (total > 0) {
+        SetEventEmit({
+            Event: `onNodeUpdate`,
+            Metadata: {
+                Type: `global-update`,
+                Updated: total
+            },
+        })
+    }
+}

package/src/manager/ValidateEvents.ts

@@ -0,0 +1,144 @@
+/*
+              _                             _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ 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 { TypeSettings } from "Types/Settings"
+import { Bootstrap } from "@Bootstrap"
+import { GetEventEnhancedName } from "@Building/GetEventEnhancedName"
+import { GetEventSignature } from "@Building/GetEventSignature"
+import { MakeEvents } from "@Manager/MakeEvents"
+import { RemoveEvent } from "@Manager/RemoveEvent"
+import { GetEventAttachments } from "@Building/GetEventAttachments"
+import { SetEventEmit } from "@Utilities/SetEventEmit"
+import { SetDebug } from "@Utilities/SetDebug"
+import { GetMatched } from "@Utilities/GetMatched"
+import { GetEventGeometry } from "@Building/GetEventGeometry"
+import { createHash } from "crypto"
+
+export const ValidateEvents = 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 })
+            RemoveEvent({ Event: define, IsTimeBasedExpiration: false })
+            return true; 
+        }
+        
+        if (properties.metadata?.vtec?.Watch && properties.metadata.source != `events.api`) {
+            const isSPC = properties.metadata?.vtec?.PredictionCenter;
+            SetEventEmit({ Event: isSPC ? `onStormPredictionWatch` : `onNonStormPredictionWatch`, Metadata: define })
+            if (bools?.SPCWatchesOnly && !isSPC) {
+                return true;
+            }
+            if ((!bools?.SPCWatchesOnly) && isSPC) {
+                return true 
+             }
+        }
+
+        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) {
+            event.geometry = !bools?.DisableGeometryParsing ? GetEventGeometry({ Event: event }) : null;
+            properties.metadata.attachments = GetEventAttachments(event)
+        }
+        properties.metadata.hash = createHash("sha256").update(JSON.stringify(pre)).digest("hex")  
+        SetEventEmit({ Event: `onProductType${enhanced.replace(/\s+/g, '')}`, Metadata: define });
+        return !filtered
+    })
+    
+    SetDebug({ Title: `ValidateEvents (${filtering.length}/${events.length})`, Message: `${Math.round(performance.now() - tick)}ms` })
+    await MakeEvents(filtering)
+}

package/src/{@parsers/@hvtec/hvtec.extract.ts → parsers/hvtec/HVExtract.ts}

@@ -11,29 +11,29 @@
     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 { TypeHVTEC } from "../../@types/types.hvtec";
-import { eventCauses } from "../../@dictionaries/dictionaries.eventCauses";
-import { eventRecords } from "../../@dictionaries/dictionaries.eventRecords";
-import { regExp } from "../../@dictionaries/dictionaries.regExp";
-import { eventSeverity } from "../../@dictionaries/dictionaries.eventSeverity";
+import { TypeHVTEC } from "Types/HVTEC"
+import { EnumCauses } from "@Enums/Causes"
+import { EnumRecords } from "@Enums/Records"
+import { EnumExpressions } from "@Enums/Expressions"
+import { EnumSeverity } from "@Enums/Severity"
 
-export const hvExtract = (message: string): TypeHVTEC[] | null => {
-    const getHVTECs = message.match(regExp.hvtec) ?? [];
+export const HVExtract = (message: string): TypeHVTEC[] | null => {
+    const getHVTECs = message.match(EnumExpressions.hvtec) ?? [];
     const vtecs: TypeHVTEC[] = [];
     for (const vtec of getHVTECs) {
         const sub = vtec.split(`.`);
         if (sub.length < 7) continue;
         vtecs.push({
-            hvtec: vtec,
-            severity: eventSeverity[sub[1]],
-            cause: eventCauses[sub[2]],
-            record: eventRecords[sub[6]]
+            HVTEC: vtec,
+            Severity: EnumSeverity[sub[1]],
+            Cause: EnumCauses[sub[2]],
+            Record: EnumRecords[sub[6]]
         })
     }
     return vtecs.length > 0 ? vtecs : null;

package/src/parsers/text/GetDescriptionFromProduct.ts

@@ -0,0 +1,59 @@
+/*
+              _                             _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ 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 { EnumExpressions } from "@Enums/Expressions"
+
+interface GetDescriptionFromProductOptions { 
+    Message: string
+    Handle?: string
+}
+
+export const GetDescriptionFromProduct = ({ Message, Handle }: GetDescriptionFromProductOptions): string => {
+    const predefinedEndMarkers = ['&&', 'LAT...'];
+    const getEndIndex = (text: string, fromIndex = 0): number => {
+        const indices = predefinedEndMarkers
+            .map((marker) => text.indexOf(marker, fromIndex))
+            .filter((idx) => idx !== -1);
+        return indices.length ? Math.min(...indices) : -1;
+    };
+    const dates = Array.from(Message.matchAll(EnumExpressions.dateline));
+    if (dates.length) {
+        const lastMatch = dates[dates.length - 1][0];
+        const sIndx = Message.lastIndexOf(lastMatch);
+        if (sIndx !== -1) {
+            const endIndx = getEndIndex(Message, sIndx);
+            Message = Message.substring(sIndx + lastMatch.length, endIndx !== -1 ? endIndx : undefined).trimStart();
+            if (Message.startsWith('/')) Message = Message.slice(1).trimStart();
+            if (Handle && Message.includes(Handle)) {
+                const handleIdx = Message.indexOf(Handle);
+                Message = Message.substring(handleIdx + Handle.length).trimStart();
+                if (Message.startsWith('/')) Message = Message.slice(1).trimStart();
+            }
+        }
+    } else if (Handle) {
+        const handleIndx = Message.indexOf(Handle);
+        if (handleIndx !== -1) {
+            let afterHandle = Message.substring(handleIndx + Handle.length).trimStart();
+            if (afterHandle.startsWith('/')) afterHandle = afterHandle.slice(1).trimStart();
+            const latEnd = getEndIndex(afterHandle);
+            Message = latEnd !== -1 ? afterHandle.substring(0, latEnd).trim() : afterHandle.trim();
+        }
+    }
+    return Message.trim();
+}

package/src/parsers/text/GetEmbededText.ts

@@ -0,0 +1,57 @@
+/*
+              _                             _               _     __   __
+         /\  | |                           | |             (_)    \ \ / /
+        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ 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"
+
+export const GetEmbededText = (event: TypeEvent): string => {
+    const line = (label: string, value: unknown, condition = true) => condition && value ? `${label} ${value}` : null;
+    const isStatement = event.properties.status_metadata.is_statement;
+    const isExpired = event.properties.status_metadata.is_expired;
+    return [
+        line(`**Locations:**`, event?.properties?.locations?.slice(0, 100)),
+        line(`**Issued:**`, `<t:${Math.floor(new Date(event.properties.issued).getTime() / 1000)}:R>`, !isExpired),
+        line(`**Expires:**`, `<t:${Math.floor(new Date(event.properties.expires).getTime() / 1000)}:R>`, !isStatement),
+        line(`**Damage Threat:**`, event?.properties?.parameters?.damage_threat, !isExpired),
+        line(`**Flood Threat:**`, event?.properties?.parameters?.flood_threat, !isExpired),
+        line(`**Tornado Threat:**`, event?.properties?.parameters?.tornado_threat, !isExpired),
+        line(`**Wind Gusts:**`, `${event?.properties?.parameters?.estimated_wind_gusts} ${event?.properties?.parameters?.wind_threat ? ` (${event?.properties?.parameters?.wind_threat})` : ''}`, !isExpired && event?.properties?.parameters?.estimated_wind_gusts != null),
+        line(`**Hail Size:**`, `${event?.properties?.parameters?.estimated_hail_size} ${event?.properties?.parameters?.hail_threat ? ` (${event?.properties?.parameters?.hail_threat})` : ''}`, !isExpired && event?.properties?.parameters?.estimated_hail_size != null),
+        line(`**Direction:**`, event?.properties?.parameters?.direction, !isExpired && event?.properties?.parameters?.direction != null),
+        line(`**Discussion:**`, event?.properties?.discussion_parameters?.discussion_number, !isExpired),
+        line(`**Concern:**`, event?.properties?.discussion_parameters?.discussion_concerning, !isExpired),
+        line(`**SPC Max Tornado Threat:**`, event?.properties?.discussion_parameters?.discussion_max_tornado, !isExpired),
+        line(`**SPC Max Hail Threat:**`, event?.properties?.discussion_parameters?.discussion_max_hail, !isExpired),
+        line(`**SPC Max Wind Threat:**`, event?.properties?.discussion_parameters?.discussion_max_wind, !isExpired),
+        line(`**SPC Watch Issuance Probability:**`, event?.properties?.discussion_parameters?.discussion_watch_issuance ? `${event?.properties?.discussion_parameters?.discussion_watch_issuance}%` : null, !isExpired),
+        line(`**Watch Number:**`, event?.properties?.watch_parameters?.watch_number, !isExpired),
+        line(`**Strong Tornadoes Probability:**`, event?.properties?.watch_parameters?.strong_tornadoes_probability ? `${event?.properties?.watch_parameters?.strong_tornadoes_probability}%` : null, !isExpired),
+        line(`**Additional Tornadoes Probability:**`, event?.properties?.watch_parameters?.additional_tornadoes_probability ? `${event?.properties?.watch_parameters?.additional_tornadoes_probability}%` : null, !isExpired),
+        line(`**Combined Hail/Wind Probability:**`, event?.properties?.watch_parameters?.combined_hail_wind_probability ? `${event?.properties?.watch_parameters?.combined_hail_wind_probability}%` : null, !isExpired),
+        line(`**Severe Hail Probability:**`, event?.properties?.watch_parameters?.severe_hail_probability ? `${event?.properties?.watch_parameters?.severe_hail_probability}%` : null, !isExpired),
+        line(`**Hail >2in Probability:**`, event?.properties?.watch_parameters?.hail_2in_probability ? `${event?.properties?.watch_parameters?.hail_2in_probability}%` : null, !isExpired),
+        line(`**Max Hail Inches:**`, event?.properties?.watch_parameters?.max_hail_in, !isExpired),
+        line(`**Severe Wind Probability:**`, event?.properties?.watch_parameters?.severe_wind_probability ? `${event?.properties?.watch_parameters?.severe_wind_probability}%` : null, !isExpired),
+        line(`**Max Surface Wind:**`, event?.properties?.watch_parameters?.max_wind_surface, !isExpired),
+        line(`**Max Tops (x100 feet):**`, event?.properties?.watch_parameters?.max_tops_x100feet, !isExpired), 
+        line(`**Tags:**`, event?.properties?.parameters?.tags?.length > 0 ? event?.properties?.parameters?.tags.join(', ') : null, !isExpired),
+        line(`**Sender:**`, event?.properties?.geocode?.office?.name ? `${event?.properties?.geocode?.office?.name} (${event?.properties?.geocode?.office?.office})` : event?.properties?.geocode?.office?.office),
+        line(`**Tracking:**`, event?.properties?.metadata?.tracking),
+        line(`**Logs:**`, event?.properties?.metadata?.history?.length > 0 ? event?.properties?.metadata?.history.length : null),
+    ].filter(Boolean).join('\n');
+}